@autonoma-ai/planner 0.1.20 → 0.1.21

package/dist/index.js

@@ -23,6 +23,202 @@ var init_esm_shims = __esm({
   }
 });
 
+// src/core/to-record.ts
+function toRecord(value) {
+  if (typeof value !== "object" || value === null) return {};
+  const record = {};
+  for (const [key, entry] of Object.entries(value)) {
+    record[key] = entry;
+  }
+  return record;
+}
+var init_to_record = __esm({
+  "src/core/to-record.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/agents/04-recipe-builder/recipe.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+function collectRefs(value, out) {
+  if (Array.isArray(value)) {
+    for (const v of value) collectRefs(v, out);
+  } else if (value !== null && typeof value === "object") {
+    const obj = toRecord(value);
+    if (typeof obj._ref === "string") out.add(obj._ref);
+    for (const v of Object.values(obj)) collectRefs(v, out);
+  }
+}
+function buildSingleEntityRecipe(entityName, models, entityOrder, allEntities) {
+  const modelMap = new Map(models.map((m) => [m.name, m]));
+  const aliasOwner = /* @__PURE__ */ new Map();
+  for (const [name, entity] of Object.entries(allEntities)) {
+    for (const rec of entity?.recipeData ?? []) {
+      if (typeof rec._alias === "string") aliasOwner.set(rec._alias, name);
+    }
+  }
+  const recipe = {};
+  const done = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  function include(name) {
+    if (done.has(name) || onStack.has(name)) return;
+    onStack.add(name);
+    const records = allEntities[name]?.recipeData ?? [];
+    for (const dep of modelMap.get(name)?.created_by ?? []) {
+      if (entityOrder.includes(dep.owner)) include(dep.owner);
+    }
+    const refs = /* @__PURE__ */ new Set();
+    collectRefs(records, refs);
+    for (const alias of refs) {
+      const owner = aliasOwner.get(alias);
+      if (owner && owner !== name) include(owner);
+    }
+    onStack.delete(name);
+    done.add(name);
+    if (records.length > 0) recipe[name] = records;
+  }
+  include(entityName);
+  return recipe;
+}
+function buildFullRecipe(entityOrder, allEntities) {
+  const recipe = {};
+  for (const name of entityOrder) {
+    const entity = allEntities[name];
+    if (entity?.recipeData && entity.recipeData.length > 0) {
+      recipe[name] = entity.recipeData;
+    }
+  }
+  return recipe;
+}
+function buildSubmittableRecipe(create, description) {
+  return {
+    version: 1,
+    source: {
+      discoverPath: "discover.json",
+      scenariosPath: "scenarios.md"
+    },
+    validationMode: "endpoint-lifecycle",
+    recipes: [
+      {
+        name: "standard",
+        description,
+        create,
+        validation: {
+          status: "validated",
+          method: "endpoint-up-down"
+        }
+      }
+    ]
+  };
+}
+async function saveRecipe(outputDir, recipe) {
+  await writeFile(join(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
+}
+async function loadRecipe(outputDir) {
+  try {
+    const raw = await readFile(join(outputDir, RECIPE_FILE), "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+var RECIPE_FILE;
+var init_recipe = __esm({
+  "src/agents/04-recipe-builder/recipe.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_to_record();
+    RECIPE_FILE = "recipe.json";
+  }
+});
+
+// src/agents/04-recipe-builder/phases/submit.ts
+import * as p from "@clack/prompts";
+async function runSubmit(state, outputDir, autonomaApiUrl, autonomaApiToken, autonomaGenerationId) {
+  const fullCreate = buildFullRecipe(state.entityOrder, state.entities);
+  const recipe = buildSubmittableRecipe(fullCreate, "Standard test scenario with realistic data");
+  await saveRecipe(outputDir, recipe);
+  p.log.success(`Recipe saved to ${RECIPE_FILE2}`);
+  const uploaded = await submitRecipe(recipe, {
+    apiUrl: autonomaApiUrl,
+    apiToken: autonomaApiToken,
+    generationId: autonomaGenerationId
+  });
+  return { recipePath: RECIPE_FILE2, uploaded };
+}
+async function uploadRecipeFromDisk(outputDir, creds) {
+  const recipe = await loadRecipe(outputDir);
+  if (recipe == null) {
+    p.log.error(
+      `No ${RECIPE_FILE2} found in ${outputDir}. Run the planner's recipe step first to generate it, then retry.`
+    );
+    return false;
+  }
+  return submitRecipe(recipe, creds);
+}
+async function submitRecipe(recipe, creds) {
+  const { apiUrl, apiToken, generationId } = creds;
+  if (!apiUrl || !apiToken || !generationId) {
+    p.log.info(
+      "Autonoma API credentials not configured - recipe saved locally, not uploaded. Set AUTONOMA_API_URL, AUTONOMA_API_TOKEN and AUTONOMA_GENERATION_ID, then run `" + UPLOAD_COMMAND + "`."
+    );
+    return false;
+  }
+  const url = `${apiUrl.replace(/\/+$/, "")}/v1/setup/setups/${generationId}/scenario-recipe-versions`;
+  p.log.step("Submitting recipe to Autonoma...");
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiToken}`
+      },
+      body: JSON.stringify(recipe)
+    });
+  } catch (err) {
+    p.log.error(`Recipe submission failed (network error): ${err instanceof Error ? err.message : String(err)}`);
+    printRecipeForRecovery(recipe);
+    return false;
+  }
+  if (res.ok) {
+    p.log.success(`Recipe submitted successfully (HTTP ${res.status})`);
+    return true;
+  }
+  const text6 = await res.text();
+  p.log.error(`Recipe submission failed (HTTP ${res.status}): ${text6}`);
+  printRecipeForRecovery(recipe);
+  return false;
+}
+function printRecipeForRecovery(recipe) {
+  console.log(
+    [
+      "",
+      "\u2500".repeat(72),
+      "RECIPE NOT UPLOADED - copy the JSON below into a recipe.json and re-upload with:",
+      `  ${UPLOAD_COMMAND}`,
+      "(with the same AUTONOMA_API_URL / AUTONOMA_API_TOKEN / AUTONOMA_GENERATION_ID env vars set)",
+      "\u2500".repeat(72),
+      JSON.stringify(recipe, null, 2),
+      "\u2500".repeat(72),
+      ""
+    ].join("\n")
+  );
+}
+var RECIPE_FILE2, UPLOAD_COMMAND;
+var init_submit = __esm({
+  "src/agents/04-recipe-builder/phases/submit.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_recipe();
+    RECIPE_FILE2 = "recipe.json";
+    UPLOAD_COMMAND = "npx @autonoma-ai/planner@latest upload";
+  }
+});
+
 // src/env.ts
 import { createEnv } from "@t3-oss/env-core";
 import { z } from "zod";
@@ -82,14 +278,14 @@ var init_debug = __esm({
 
 // src/core/version.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { dirname, join as join3 } from "path";
+import { dirname, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveVersion() {
   try {
     const here = dirname(fileURLToPath2(import.meta.url));
     for (const rel of ["../package.json", "../../package.json", "../../../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync3(join3(here, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync3(join4(here, rel), "utf-8"));
         if (pkg?.name === PACKAGE_NAME && typeof pkg.version === "string") {
           return pkg.version;
         }
@@ -114,7 +310,7 @@ var init_version = __esm({
 import { randomUUID } from "crypto";
 import { readFileSync as readFileSync4, writeFileSync, mkdirSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function resolveKey() {
   return (readEnv().AUTONOMA_POSTHOG_KEY ?? POSTHOG_PUBLIC_KEY).trim();
 }
@@ -209,8 +405,8 @@ var init_analytics = __esm({
     init_env();
     init_debug();
     init_version();
-    AUTONOMA_HOME2 = join4(homedir2(), ".autonoma");
-    DEVICE_ID_PATH = join4(AUTONOMA_HOME2, ".device-id");
+    AUTONOMA_HOME2 = join5(homedir2(), ".autonoma");
+    DEVICE_ID_PATH = join5(AUTONOMA_HOME2, ".device-id");
     POSTHOG_PUBLIC_KEY = "phc_mUOwUj62r8vyiisFPvXLC3G5RftETIBMnKNSHqTBdka";
     DEFAULT_HOST = "https://us.i.posthog.com";
     RUN_ID = randomUUID();
@@ -242,14 +438,14 @@ var init_colors = __esm({
 });
 
 // src/core/context.ts
-import { readFile, writeFile } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
 async function saveContext(outputDir, ctx) {
-  await writeFile(join5(outputDir, CONTEXT_FILE), JSON.stringify(ctx, null, 2), "utf-8");
+  await writeFile2(join6(outputDir, CONTEXT_FILE), JSON.stringify(ctx, null, 2), "utf-8");
 }
 async function loadContext(outputDir) {
   try {
-    const raw = await readFile(join5(outputDir, CONTEXT_FILE), "utf-8");
+    const raw = await readFile2(join6(outputDir, CONTEXT_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -493,16 +689,16 @@ 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 { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { join as join9 } from "path";
 import { z as z2 } from "zod";
 async function saveProjectMap(outputDir, map) {
-  await writeFile3(join8(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
+  await writeFile4(join9(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
 }
 async function loadProjectMap(outputDir) {
-  const path3 = join8(outputDir, PROJECT_MAP_FILE);
+  const path3 = join9(outputDir, PROJECT_MAP_FILE);
   try {
-    const raw = await readFile3(path3, "utf-8");
+    const raw = await readFile4(path3, "utf-8");
     const parsed = ProjectMapSchema.safeParse(JSON.parse(raw));
     if (parsed.success) return parsed.data;
     debugLog("project-map.json failed schema validation, ignoring it", { path: path3, issues: parsed.error.issues });
@@ -911,8 +1107,8 @@ var init_agent = __esm({
 });
 
 // src/core/gitignore.ts
-import { readFile as readFile6 } from "fs/promises";
-import { join as join11, relative as relative2 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join12, relative as relative2 } from "path";
 import { glob as glob2 } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -932,10 +1128,10 @@ async function loadGitignorePatterns(projectRoot) {
   ];
   const matches = await glob2("**/.gitignore", { cwd: projectRoot, dot: true });
   for (const match of matches) {
-    const fullPath = join11(projectRoot, match);
+    const fullPath = join12(projectRoot, match);
     try {
-      const content = await readFile6(fullPath, "utf-8");
-      const prefix = relative2(projectRoot, join11(projectRoot, match, ".."));
+      const content = await readFile7(fullPath, "utf-8");
+      const prefix = relative2(projectRoot, join12(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -1167,7 +1363,7 @@ var init_grep = __esm({
 // src/tools/list-directory.ts
 import { readdir } from "fs/promises";
 import { stat } from "fs/promises";
-import { join as join12, relative as relative3 } from "path";
+import { join as join13, relative as relative3 } from "path";
 import { tool as tool4 } from "ai";
 import { minimatch } from "minimatch";
 import { z as z7 } from "zod";
@@ -1192,7 +1388,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
   const withTypes = [];
   for (const name of rawEntries) {
     try {
-      const s = await stat(join12(dirPath, name));
+      const s = await stat(join13(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -1212,7 +1408,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join12(dirPath, entry.name),
+        join13(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -1265,7 +1461,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join12(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join13(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -1297,7 +1493,7 @@ var init_list_directory = __esm({
 });
 
 // src/tools/read-file.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { relative as relative4, resolve as resolve2 } from "path";
 import { tool as tool5 } from "ai";
 import { z as z8 } from "zod";
@@ -1325,7 +1521,7 @@ async function executeReadFile(workingDirectory, filePath, offset, limit) {
   const resolved = resolveSandboxedPath(workingDirectory, filePath);
   if ("error" in resolved) return resolved;
   try {
-    const content = await readFile7(resolved.absolutePath, "utf-8");
+    const content = await readFile8(resolved.absolutePath, "utf-8");
     const sliced = sliceLines(content, offset ?? 0, limit ?? MAX_LINES);
     return {
       path: resolved.relativePath,
@@ -1461,7 +1657,7 @@ Be thorough but focused - only investigate what's relevant to your instruction.`
 });
 
 // src/tools/write-file.ts
-import { writeFile as writeFile5, mkdir as mkdir2 } from "fs/promises";
+import { writeFile as writeFile6, mkdir as mkdir2 } from "fs/promises";
 import { dirname as dirname2, relative as relative5, resolve as resolve3 } from "path";
 import { tool as tool7 } from "ai";
 import { z as z10 } from "zod";
@@ -1474,7 +1670,7 @@ async function executeWriteFile(outputDirectory, filePath, content) {
   }
   try {
     await mkdir2(dirname2(absolutePath), { recursive: true });
-    await writeFile5(absolutePath, content, "utf-8");
+    await writeFile6(absolutePath, content, "utf-8");
     return { path: relativePath, bytesWritten: content.length };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1501,7 +1697,7 @@ var init_write_file = __esm({
 });
 
 // src/tools/ask-user.ts
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 import { tool as tool8 } from "ai";
 import { z as z11 } from "zod";
 function buildAskUserTool() {
@@ -1518,8 +1714,8 @@ function buildAskUserTool() {
           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" };
+      const answer = await p3.text({ message: input.question });
+      if (p3.isCancel(answer)) return { answer: "User skipped this question" };
       return { answer };
     }
   });
@@ -1706,13 +1902,13 @@ var init_pages_finder = __esm({
 
 // src/core/review.ts
 import { access } from "fs/promises";
-import { join as join13, isAbsolute } from "path";
-import * as p3 from "@clack/prompts";
+import { join as join14, isAbsolute } from "path";
+import * as p4 from "@clack/prompts";
 import spawn from "cross-spawn";
 import which from "which";
 function resolvePath(artifact, outputDir) {
   if (isAbsolute(artifact)) return artifact;
-  return join13(outputDir, artifact);
+  return join14(outputDir, artifact);
 }
 async function detectEditors() {
   if (cachedEditors) return cachedEditors;
@@ -1736,7 +1932,7 @@ async function launchEditor(editor, files) {
     };
     const proc = spawn(editor.command, args, { stdio: "inherit" });
     proc.on("error", (err) => {
-      p3.log.warn(`Couldn't open ${editor.label} (${err.message}). Review the files manually:`);
+      p4.log.warn(`Couldn't open ${editor.label} (${err.message}). Review the files manually:`);
       for (const f of files) console.log(`    ${CYAN}${f}${RESET3}`);
       settle();
     });
@@ -1750,17 +1946,17 @@ async function launchEditor(editor, files) {
 async function openInEditor(files) {
   const editors = await detectEditors();
   if (editors.length === 0) {
-    p3.log.warn("No editors found. Review the files manually:");
+    p4.log.warn("No editors found. Review the files manually:");
     for (const f of files) console.log(`    ${CYAN}${f}${RESET3}`);
     return;
   }
   if (preferredEditor) {
     const editor2 = editors.find((e) => e.command === preferredEditor);
     if (editor2) {
-      const open = await p3.confirm({
+      const open = await p4.confirm({
         message: `Open in ${editor2.label}?`
       });
-      if (!p3.isCancel(open) && open) {
+      if (!p4.isCancel(open) && open) {
         await launchEditor(editor2, files);
       }
       return;
@@ -1770,20 +1966,20 @@ async function openInEditor(files) {
     value: e.command,
     label: e.label
   }));
-  const selected = await p3.select({
+  const selected = await p4.select({
     message: "Open output files for review?",
     options: [...options, { value: "skip", label: "No, skip - I'll review later" }]
   });
-  if (p3.isCancel(selected) || selected === "skip") return;
+  if (p4.isCancel(selected) || selected === "skip") return;
   const editor = editors.find((e) => e.command === selected);
-  const remember = await p3.select({
+  const remember = await p4.select({
     message: `Use ${editor.label} for all future reviews?`,
     options: [
       { value: "always", label: `Yes, always use ${editor.label}` },
       { value: "ask", label: "No, ask me each time" }
     ]
   });
-  if (!p3.isCancel(remember) && remember === "always") {
+  if (!p4.isCancel(remember) && remember === "always") {
     preferredEditor = editor.command;
   }
   await launchEditor(editor, files);
@@ -1794,7 +1990,7 @@ async function showResults(result, options) {
   if (result.artifacts.length === 0) {
     const knownFiles = ["AUTONOMA.md", "entity-audit.md", "scenarios.md"];
     for (const f of knownFiles) {
-      const fullPath = join13(options.outputDir, f);
+      const fullPath = join14(options.outputDir, f);
       try {
         await access(fullPath);
         result.artifacts.push(f);
@@ -1824,7 +2020,7 @@ async function showResults(result, options) {
     }
   }
   if (options.reviewGuidance) {
-    p3.note(options.reviewGuidance, "What to check");
+    p4.note(options.reviewGuidance, "What to check");
   }
   const showPreview = options.showPreview !== false;
   if (showPreview && resolvedPaths.length > 0 && !options.nonInteractive) {
@@ -1837,21 +2033,21 @@ async function reviewLoop(result, options) {
   await showResults(result, options);
   if (options.nonInteractive) return result;
   while (true) {
-    const input = await p3.text({
+    const input = await p4.text({
       message: "Review the output. Press Enter to approve, or type feedback for the agent.",
       placeholder: "Looks good (Enter to approve)",
       defaultValue: ""
     });
-    if (p3.isCancel(input)) {
-      p3.log.warn("Cancelled.");
+    if (p4.isCancel(input)) {
+      p4.log.warn("Cancelled.");
       return result;
     }
     const feedback = input.trim();
     if (feedback === "") {
-      p3.log.success("Approved - moving on.");
+      p4.log.success("Approved - moving on.");
       return result;
     }
-    p3.log.info(`Sending feedback to ${options.agentId}...`);
+    p4.log.info(`Sending feedback to ${options.agentId}...`);
     console.log("");
     const revised = await options.onFeedback(feedback);
     if (revised) {
@@ -1883,13 +2079,13 @@ var init_review = __esm({
 });
 
 // src/agents/01-kb-generator/flows.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join15 } from "path";
 import matter from "gray-matter";
 async function parseCoreFlows(outputDir) {
   let raw;
   try {
-    raw = await readFile8(join14(outputDir, "AUTONOMA.md"), "utf-8");
+    raw = await readFile9(join15(outputDir, "AUTONOMA.md"), "utf-8");
   } catch {
     return [];
   }
@@ -2102,8 +2298,8 @@ var kb_generator_exports = {};
 __export(kb_generator_exports, {
   runKBGenerator: () => runKBGenerator
 });
-import { readFile as readFile9 } from "fs/promises";
-import { join as join15, resolve as resolve5 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join16, resolve as resolve5 } from "path";
 import { tool as tool11 } from "ai";
 import { z as z13 } from "zod";
 function buildRegisterPagesTool(tracker) {
@@ -2231,8 +2427,8 @@ Output files:
   const agentConfig = buildKbAgentConfig(tracker, model, input, onStepFinish, setResult);
   await runAgent(agentConfig, prompt, () => result);
   logger.summary();
-  const autonomaPath = join15(input.outputDir, "AUTONOMA.md");
-  const autonomaExists = await readFile9(autonomaPath, "utf-8").then(() => true).catch((err) => {
+  const autonomaPath = join16(input.outputDir, "AUTONOMA.md");
+  const autonomaExists = await readFile10(autonomaPath, "utf-8").then(() => true).catch((err) => {
     debugLog("AUTONOMA.md not found while checking step completion", { err });
     return false;
   });
@@ -2351,12 +2547,12 @@ var init_kb_generator = __esm({
 });
 
 // src/agents/04-recipe-builder/entity-order.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join17 } from "path";
 import matter2 from "gray-matter";
 import { z as z14 } from "zod";
 async function parseEntityAudit(outputDir) {
-  const raw = await readFile10(join16(outputDir, "entity-audit.md"), "utf-8");
+  const raw = await readFile11(join17(outputDir, "entity-audit.md"), "utf-8");
   try {
     const parsed = frontmatterSchema.safeParse(matter2(raw).data);
     if (parsed.success && parsed.data.models.length > 0) {
@@ -2742,8 +2938,8 @@ var entity_audit_exports = {};
 __export(entity_audit_exports, {
   runEntityAudit: () => runEntityAudit
 });
-import { readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { join as join18 } from "path";
 import { tool as tool12 } from "ai";
 import { glob as glob4 } from "glob";
 import { z as z15 } from "zod";
@@ -2874,7 +3070,7 @@ async function findPrismaSchema(projectRoot) {
   return candidates[0] ?? void 0;
 }
 async function extractPrismaModels(schemaPath) {
-  const content = await readFile11(schemaPath, "utf-8");
+  const content = await readFile12(schemaPath, "utf-8");
   return content.split("\n").filter((line) => line.startsWith("model ")).map((line) => line.split(/\s+/)[1]).filter((name) => name != null);
 }
 async function detectFrameworkAndModels(projectRoot) {
@@ -2961,8 +3157,8 @@ ${formatException(err)}`);
   logger.summary();
   const writeCanonicalAudit = async () => {
     if (tracker.auditedModels.size === 0) return void 0;
-    const auditPath = join17(input.outputDir, "entity-audit.md");
-    await writeFile6(auditPath, tracker.generateAuditMarkdown(), "utf-8");
+    const auditPath = join18(input.outputDir, "entity-audit.md");
+    await writeFile7(auditPath, tracker.generateAuditMarkdown(), "utf-8");
     return auditPath;
   };
   const canonicalPath = await writeCanonicalAudit();
@@ -2999,9 +3195,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const auditPath = join17(input.outputDir, "entity-audit.md");
+    const auditPath = join18(input.outputDir, "entity-audit.md");
     try {
-      await readFile11(auditPath, "utf-8");
+      await readFile12(auditPath, "utf-8");
       return {
         success: true,
         artifacts: ["entity-audit.md"],
@@ -3143,11 +3339,11 @@ ${duals.length > 0 ? duals.map((m) => `- **${m.name}** - standalone: ${m.creatio
 });
 
 // src/core/parse-entity-audit.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";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile12(join18(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile13(join19(outputDir, "entity-audit.md"), "utf-8");
     const names = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^\s+-\s+name:\s+(.+)$/);
@@ -3220,13 +3416,13 @@ values; the recipe builder generates the exact records from what you write.`;
 });
 
 // src/agents/03-scenario-recipe/scenario-table.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join20 } from "path";
 import matter3 from "gray-matter";
 async function parseScenario(outputDir) {
   let raw;
   try {
-    raw = await readFile13(join19(outputDir, "scenarios.md"), "utf-8");
+    raw = await readFile14(join20(outputDir, "scenarios.md"), "utf-8");
   } catch {
     return { scenarioNames: [], entityTypes: [] };
   }
@@ -3307,8 +3503,8 @@ __export(scenario_recipe_exports, {
   feedbackToScenario: () => feedbackToScenario,
   runScenarioRecipe: () => runScenarioRecipe
 });
-import { readFile as readFile14 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join21 } from "path";
 import { tool as tool13 } from "ai";
 import { z as z16 } from "zod";
 function buildFinishTool3(requiredEntities, outputDir, onFinish) {
@@ -3322,7 +3518,7 @@ function buildFinishTool3(requiredEntities, outputDir, onFinish) {
     execute: async (input) => {
       let content;
       try {
-        content = await readFile14(join20(outputDir, "scenarios.md"), "utf-8");
+        content = await readFile15(join21(outputDir, "scenarios.md"), "utf-8");
       } catch {
         return { error: "Cannot finish: scenarios.md not found. Write it first." };
       }
@@ -3422,9 +3618,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const scenariosPath = join20(input.outputDir, "scenarios.md");
+    const scenariosPath = join21(input.outputDir, "scenarios.md");
     try {
-      await readFile14(scenariosPath, "utf-8");
+      await readFile15(scenariosPath, "utf-8");
       return {
         success: true,
         artifacts: ["scenarios.md"],
@@ -3581,11 +3777,11 @@ var init_entity_relevance = __esm({
 
 // src/core/detect-pkg-manager.ts
 import { existsSync as existsSync2 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function detectPackageManager(projectRoot) {
-  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";
+  if (existsSync2(join22(projectRoot, "bun.lock")) || existsSync2(join22(projectRoot, "bun.lockb"))) return "bun";
+  if (existsSync2(join22(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join22(projectRoot, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installCommand(pm, ...packages) {
@@ -3660,22 +3856,6 @@ var init_highlight = __esm({
   }
 });
 
-// src/core/to-record.ts
-function toRecord(value) {
-  if (typeof value !== "object" || value === null) return {};
-  const record = {};
-  for (const [key, entry] of Object.entries(value)) {
-    record[key] = entry;
-  }
-  return record;
-}
-var init_to_record = __esm({
-  "src/core/to-record.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
 // src/agents/04-recipe-builder/http-client.ts
 import { createHmac } from "crypto";
 function sign(body, secret) {
@@ -3811,7 +3991,7 @@ function validateRecipeAgainstSchema(recipe, schema) {
         }
       }
       const refs = /* @__PURE__ */ new Set();
-      collectRefs(record, refs);
+      collectRefs2(record, refs);
       for (const alias of refs) {
         if (!declaredAliases.has(alias)) {
           problems.push({
@@ -3825,16 +4005,16 @@ function validateRecipeAgainstSchema(recipe, schema) {
   }
   return problems;
 }
-function collectRefs(value, out) {
+function collectRefs2(value, out) {
   if (Array.isArray(value)) {
-    for (const v of value) collectRefs(v, out);
+    for (const v of value) collectRefs2(v, out);
   } else if (value !== null && typeof value === "object") {
     const obj = toRecord(value);
     if (typeof obj._ref === "string") {
       out.add(obj._ref);
       return;
     }
-    for (const v of Object.values(obj)) collectRefs(v, out);
+    for (const v of Object.values(obj)) collectRefs2(v, out);
   }
 }
 function formatValidationProblems(problems) {
@@ -3855,93 +4035,6 @@ var init_discover_schema = __esm({
   }
 });
 
-// src/agents/04-recipe-builder/recipe.ts
-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);
-  } else if (value !== null && typeof value === "object") {
-    const obj = toRecord(value);
-    if (typeof obj._ref === "string") out.add(obj._ref);
-    for (const v of Object.values(obj)) collectRefs2(v, out);
-  }
-}
-function buildSingleEntityRecipe(entityName, models, entityOrder, allEntities) {
-  const modelMap = new Map(models.map((m) => [m.name, m]));
-  const aliasOwner = /* @__PURE__ */ new Map();
-  for (const [name, entity] of Object.entries(allEntities)) {
-    for (const rec of entity?.recipeData ?? []) {
-      if (typeof rec._alias === "string") aliasOwner.set(rec._alias, name);
-    }
-  }
-  const recipe = {};
-  const done = /* @__PURE__ */ new Set();
-  const onStack = /* @__PURE__ */ new Set();
-  function include(name) {
-    if (done.has(name) || onStack.has(name)) return;
-    onStack.add(name);
-    const records = allEntities[name]?.recipeData ?? [];
-    for (const dep of modelMap.get(name)?.created_by ?? []) {
-      if (entityOrder.includes(dep.owner)) include(dep.owner);
-    }
-    const refs = /* @__PURE__ */ new Set();
-    collectRefs2(records, refs);
-    for (const alias of refs) {
-      const owner = aliasOwner.get(alias);
-      if (owner && owner !== name) include(owner);
-    }
-    onStack.delete(name);
-    done.add(name);
-    if (records.length > 0) recipe[name] = records;
-  }
-  include(entityName);
-  return recipe;
-}
-function buildFullRecipe(entityOrder, allEntities) {
-  const recipe = {};
-  for (const name of entityOrder) {
-    const entity = allEntities[name];
-    if (entity?.recipeData && entity.recipeData.length > 0) {
-      recipe[name] = entity.recipeData;
-    }
-  }
-  return recipe;
-}
-function buildSubmittableRecipe(create, description) {
-  return {
-    version: 1,
-    source: {
-      discoverPath: "discover.json",
-      scenariosPath: "scenarios.md"
-    },
-    validationMode: "endpoint-lifecycle",
-    recipes: [
-      {
-        name: "standard",
-        description,
-        create,
-        validation: {
-          status: "validated",
-          method: "endpoint-up-down"
-        }
-      }
-    ]
-  };
-}
-async function saveRecipe(outputDir, recipe) {
-  await writeFile7(join22(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
-}
-var RECIPE_FILE;
-var init_recipe = __esm({
-  "src/agents/04-recipe-builder/recipe.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_to_record();
-    RECIPE_FILE = "recipe.json";
-  }
-});
-
 // src/agents/04-recipe-builder/state.ts
 import { readFile as readFile16, writeFile as writeFile8 } from "fs/promises";
 import { join as join23 } from "path";
@@ -4128,7 +4221,7 @@ So a failure has exactly two possible origins, and your only job is to tell them
 import { writeFile as writeFile9, readFile as readFile17 } from "fs/promises";
 import { tmpdir } from "os";
 import { join as join24 } from "path";
-import * as p4 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 import { tool as tool14 } from "ai";
 import spawn2 from "cross-spawn";
 import { z as z19 } from "zod";
@@ -4244,10 +4337,10 @@ Read scenarios.md and entity-audit.md to understand the correct aliases and sche
   );
   logger.summary();
   if (revised) {
-    p4.note(JSON.stringify(revised, null, 2), `Fixed data for ${entityName}`, { format: codeNoteFormat });
+    p5.note(JSON.stringify(revised, null, 2), `Fixed data for ${entityName}`, { format: codeNoteFormat });
     return revised;
   }
-  p4.log.warn("Could not auto-fix. Returning original data.");
+  p5.log.warn("Could not auto-fix. Returning original data.");
   return current;
 }
 async function generateInstructions(entityName, entityIndex, totalEntities, isFirst, techStack, auditModel, recipeData, model, projectRoot, outputDir) {
@@ -4314,20 +4407,20 @@ Read the creation file from the project to understand the existing service/funct
   return result ?? "No instructions generated. Check the entity audit for creation_file and creation_function.";
 }
 async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed, model, outputDir, completedEntities, schemaSpec) {
-  p4.log.info(
+  p5.log.info(
     `Legend for recipe fields:
   _alias - Internal ID used to reference this record from other entities (e.g., { "_ref": "org_1" })
   _ref   - Reference to a record created by a parent entity's _alias
   All other fields are the actual data that will be inserted into your database.`
   );
-  p4.note(JSON.stringify(proposed, null, 2), `Proposed data for ${entityName} (${proposed.length} records)`, {
+  p5.note(JSON.stringify(proposed, null, 2), `Proposed data for ${entityName} (${proposed.length} records)`, {
     format: codeNoteFormat
   });
-  p4.log.info(
+  p5.log.info(
     "Review checklist:\n  - Do field values match your real data patterns?\n  - Are _ref references pointing to correct parent aliases?\n  - Are enum fields varied across records (not all the same value)?\n  - Are there enough records for your test scenarios?"
   );
   while (true) {
-    const action = await p4.select({
+    const action = await p5.select({
       message: `[${entityIndex + 1}/${totalEntities}] ${entityName} - does this data look right?`,
       options: [
         { value: "keep", label: "Yes, keep" },
@@ -4335,19 +4428,19 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
         { value: "edit", label: "No, edit manually" }
       ]
     });
-    if (p4.isCancel(action)) throw new Error("Recipe review cancelled");
+    if (p5.isCancel(action)) throw new Error("Recipe review cancelled");
     if (action === "keep") return proposed;
     if (action === "edit") {
       const tmpPath = 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.`);
+      p5.log.info(`Opening ${editor}... Save and close when done.`);
       const launched = await new Promise((resolve6) => {
         const proc = spawn2(editor, [tmpPath], { stdio: "inherit" });
         proc.on("close", () => resolve6(true));
         proc.on("error", (err) => {
-          p4.log.error(
+          p5.log.error(
             `Couldn't open ${editor} (${err.message}). Edit this file manually, then choose "edit" again: ${tmpPath}`
           );
           resolve6(false);
@@ -4357,18 +4450,18 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
       const edited = await readFile17(tmpPath, "utf-8");
       try {
         proposed = JSON.parse(edited);
-        p4.note(JSON.stringify(proposed, null, 2), `Updated data for ${entityName}`, { format: codeNoteFormat });
+        p5.note(JSON.stringify(proposed, null, 2), `Updated data for ${entityName}`, { format: codeNoteFormat });
       } catch (err) {
-        p4.log.error(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}. Try again.`);
+        p5.log.error(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}. Try again.`);
       }
       continue;
     }
     if (action === "chat") {
-      const feedback = await p4.text({
+      const feedback = await p5.text({
         message: "What should be changed?",
         placeholder: "e.g., add more records, change field values, fix references..."
       });
-      if (p4.isCancel(feedback) || !feedback.trim()) continue;
+      if (p5.isCancel(feedback) || !feedback.trim()) continue;
       proposed = await reviseRecipeData(
         entityName,
         entityIndex,
@@ -4408,14 +4501,14 @@ async function promptOnFailure(entityName, errorBody, ctx, phase, httpStatus) {
   });
   if (ctx.budget.attempts < MAX_AUTOFIX_ATTEMPTS) {
     ctx.budget.attempts++;
-    p4.log.info(`Triage: ${reason}`);
-    p4.log.info(
+    p5.log.info(`Triage: ${reason}`);
+    p5.log.info(
       `Handing the failure to the agent to fix from the error (attempt ${ctx.budget.attempts}/${MAX_AUTOFIX_ATTEMPTS})...`
     );
     return seedFeedbackFromError(errorContext, reason);
   }
-  p4.log.warn(`The agent tried ${MAX_AUTOFIX_ATTEMPTS}\xD7 without resolving it. Latest triage: ${reason}`);
-  const action = await p4.select({
+  p5.log.warn(`The agent tried ${MAX_AUTOFIX_ATTEMPTS}\xD7 without resolving it. Latest triage: ${reason}`);
+  const action = await p5.select({
     message: "What would you like to do?",
     options: [
       { value: "retry", label: "Yes, retry - I fixed my handler code", hint: "Send the same request again" },
@@ -4432,22 +4525,22 @@ async function promptOnFailure(entityName, errorBody, ctx, phase, httpStatus) {
       { value: "skip", label: "No, skip this entity", hint: "Move on to the next entity" }
     ]
   });
-  if (p4.isCancel(action)) throw new Error("Entity loop cancelled");
+  if (p5.isCancel(action)) throw new Error("Entity loop cancelled");
   if (action === "skip") return "skip";
   if (action === "retry") return "retry";
   if (action === "autofix") {
     ctx.budget.attempts++;
     return seedFeedbackFromError(errorContext, reason);
   }
-  const fb = await p4.text({
+  const fb = await p5.text({
     message: "What's wrong with the recipe data?",
     placeholder: "e.g. Transaction references acc_1 but Account uses account_1 as its alias"
   });
-  if (p4.isCancel(fb)) throw new Error("Entity loop cancelled");
+  if (p5.isCancel(fb)) throw new Error("Entity loop cancelled");
   return { feedback: `${fb.trim()}${errorContext}` };
 }
 async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, recipe, grounding, discoverSchema) {
-  p4.log.info(
+  p5.log.info(
     `Let's verify this factory works. We'll send a test request to create ${entityName}, then check the database.`
   );
   const failureCtx = { ...grounding, recipe };
@@ -4457,7 +4550,7 @@ async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, rec
       if (problems.length > 0) {
         const errorBody = `Recipe failed local schema validation against /discover (not sent to the server):
 ${formatValidationProblems(problems)}`;
-        p4.log.error(errorBody);
+        p5.log.error(errorBody);
         const action = await promptOnFailure(entityName, errorBody, failureCtx, "create");
         if (action === "skip") return "skip";
         if (action === "retry") continue;
@@ -4465,12 +4558,12 @@ ${formatValidationProblems(problems)}`;
       }
     }
     const testRunId = `test-${Date.now()}`;
-    p4.log.step(`[${entityIndex + 1}/${totalEntities}] Sending UP request...`);
+    p5.log.step(`[${entityIndex + 1}/${totalEntities}] Sending UP request...`);
     let upResult;
     try {
       upResult = await up(sdkConfig, recipe, testRunId);
     } catch (err) {
-      p4.log.error(`UP request failed:
+      p5.log.error(`UP request failed:
 ${formatException(err)}`);
       const action = await promptOnFailure(entityName, formatException(err), failureCtx, "create");
       if (action === "skip") return "skip";
@@ -4478,29 +4571,29 @@ ${formatException(err)}`);
       return action;
     }
     if (!upResult.ok) {
-      p4.log.error(`UP failed (HTTP ${upResult.status}):`);
+      p5.log.error(`UP failed (HTTP ${upResult.status}):`);
       console.log(JSON.stringify(upResult.body, null, 2));
       const action = await promptOnFailure(entityName, upResult.body, failureCtx, "create", upResult.status);
       if (action === "skip") return "skip";
       if (action === "retry") continue;
       return action;
     }
-    p4.log.success(`UP succeeded!`);
+    p5.log.success(`UP succeeded!`);
     console.log(JSON.stringify(upResult.body, null, 2));
     const refsTokenValue = toRecord(upResult.body).refsToken;
     const refsToken = typeof refsTokenValue === "string" ? refsTokenValue : void 0;
     if (!refsToken) {
-      p4.log.error("No refsToken in UP response - cannot test DOWN.");
+      p5.log.error("No refsToken in UP response - cannot test DOWN.");
       return "skip";
     }
-    p4.log.info("Now let's verify teardown works - leftover test data would pollute your database.");
+    p5.log.info("Now let's verify teardown works - leftover test data would pollute your database.");
     while (true) {
-      p4.log.step(`[${entityIndex + 1}/${totalEntities}] Sending DOWN request...`);
+      p5.log.step(`[${entityIndex + 1}/${totalEntities}] Sending DOWN request...`);
       let downResult;
       try {
         downResult = await down(sdkConfig, refsToken);
       } catch (err) {
-        p4.log.error(`DOWN request failed:
+        p5.log.error(`DOWN request failed:
 ${formatException(err)}`);
         const action = await promptOnFailure(entityName, formatException(err), failureCtx, "teardown");
         if (action === "skip") return "skip";
@@ -4508,7 +4601,7 @@ ${formatException(err)}`);
         return action;
       }
       if (!downResult.ok) {
-        p4.log.error(`DOWN failed (HTTP ${downResult.status}):`);
+        p5.log.error(`DOWN failed (HTTP ${downResult.status}):`);
         console.log(JSON.stringify(downResult.body, null, 2));
         const action = await promptOnFailure(
           entityName,
@@ -4521,7 +4614,7 @@ ${formatException(err)}`);
         if (action === "retry") continue;
         return action;
       }
-      p4.log.success("DOWN succeeded!");
+      p5.log.success("DOWN succeeded!");
       return "success";
     }
   }
@@ -4538,7 +4631,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
     if (!schema) return {};
     return { schema, spec: renderModelSchema(schema, name) ?? void 0 };
   }
-  p4.log.info(
+  p5.log.info(
     `We're going to set up your test data factories one entity at a time. Each factory teaches the Autonoma SDK how to create and tear down a specific type of record in YOUR database, using YOUR existing service functions.
 
   We'll test each one live before moving on - this way if something breaks, you'll know exactly which entity caused it. Let's start with the root entities (no dependencies), then work through the dependents.`
@@ -4547,7 +4640,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
     const entityName = state.entityOrder[i];
     const auditModel = modelMap.get(entityName);
     if (!auditModel) {
-      p4.log.warn(`[${i + 1}/${total}] ${entityName} - not found in entity audit, skipping`);
+      p5.log.warn(`[${i + 1}/${total}] ${entityName} - not found in entity audit, skipping`);
       state.entities[entityName] = {
         entityName,
         status: "skipped",
@@ -4559,13 +4652,13 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
     }
     const existing = state.entities[entityName];
     if (existing?.status === "tested-down") {
-      p4.log.info(`[${i + 1}/${total}] ${entityName} - already done, skipping`);
+      p5.log.info(`[${i + 1}/${total}] ${entityName} - already done, skipping`);
       continue;
     }
     const isRoot = auditModel.created_by.length === 0;
     const depInfo = isRoot ? "This is a root entity - no dependencies." : `This depends on: ${auditModel.created_by.map((d) => d.owner).join(", ")}`;
-    p4.log.step(`[${i + 1}/${total}] ${entityName}`);
-    p4.log.info(depInfo);
+    p5.log.step(`[${i + 1}/${total}] ${entityName}`);
+    p5.log.info(depInfo);
     const { spec: recipeSchemaSpec } = await loadLiveSchema(entityName);
     let recipeData = existing?.recipeData;
     if (!recipeData || existing?.status === "pending") {
@@ -4614,28 +4707,28 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
         outputDir
       );
       const DOCS_BASE2 = "https://docs.autonoma.app";
-      p4.log.info(
+      p5.log.info(
         `Next: implement the ${entityName} factory. The block below is a copy-paste guide -
   paste it into Claude Code (or your AI assistant) and it will write the factory in your codebase.
   A factory teaches the Autonoma SDK how to create and tear down ${entityName} records using your app's own code.
   Keep it local for now: implement it, run your app on localhost, and we'll test it live here. You deploy later.`
       );
-      p4.note(instructions, `Implementation guide for ${entityName} (paste into your AI assistant)`, {
+      p5.note(instructions, `Implementation guide for ${entityName} (paste into your AI assistant)`, {
         format: codeNoteFormat
       });
-      p4.log.info(`Autonoma SDK docs: ${DOCS_BASE2}/sdk/environment-factory`);
+      p5.log.info(`Autonoma SDK docs: ${DOCS_BASE2}/sdk/environment-factory`);
       if (i === 0) {
-        p4.log.info(
+        p5.log.info(
           "This is your first factory - the guide includes one-time SDK setup. Later entities only need the factory function."
         );
       }
       notify("Autonoma", `${entityName} - implementation ready, waiting for you`);
-      const ready = await p4.confirm({
+      const ready = await p5.confirm({
         message: `[${i + 1}/${total}] Is your app running locally with the ${entityName} factory wired up?`
       });
-      if (p4.isCancel(ready)) throw new Error("Entity loop cancelled");
+      if (p5.isCancel(ready)) throw new Error("Entity loop cancelled");
       if (!ready) {
-        p4.log.info("Take your time implementing. Run again with --resume to continue from here.");
+        p5.log.info("Take your time implementing. Run again with --resume to continue from here.");
         return;
       }
     }
@@ -4651,7 +4744,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
           JSON.stringify({ sharedSecret: secret, endpointUrl: state.sdkEndpointUrl }, null, 2),
           "utf-8"
         );
-        p4.note(
+        p5.note(
           `AUTONOMA_SHARED_SECRET=${secret}
 
 Add this to your server's .env file and restart it.
@@ -4661,22 +4754,22 @@ The same value must be set in both your server and the Autonoma dashboard.
 Saved to: ${join24(outputDir, "autonoma-config.json")}`,
           "Shared secret generated"
         );
-        const secretReady = await p4.confirm({
+        const secretReady = await p5.confirm({
           message: "Did you add the secret to your .env and restart the server?"
         });
-        if (p4.isCancel(secretReady)) throw new Error("Entity loop cancelled");
+        if (p5.isCancel(secretReady)) throw new Error("Entity loop cancelled");
         if (!secretReady) {
-          p4.log.info("Add the secret and run again with --resume to continue.");
+          p5.log.info("Add the secret and run again with --resume to continue.");
           return;
         }
       }
       if (!state.sdkEndpointUrl) {
-        const url = await p4.text({
+        const url = await p5.text({
           message: "What's your SDK endpoint URL?",
           placeholder: "http://localhost:3000/api/autonoma",
           defaultValue: "http://localhost:3000/api/autonoma"
         });
-        if (p4.isCancel(url)) throw new Error("Entity loop cancelled");
+        if (p5.isCancel(url)) throw new Error("Entity loop cancelled");
         state.sdkEndpointUrl = url.trim() || "http://localhost:3000/api/autonoma";
         await saveRecipeState(outputDir, state);
         await writeFile9(
@@ -4712,15 +4805,15 @@ Saved to: ${join24(outputDir, "autonoma-config.json")}`,
         );
         if (testResult === "success") {
           state.entities[entityName].status = "tested-down";
-          p4.log.success(`[${i + 1}/${total}] ${entityName} - factory verified`);
+          p5.log.success(`[${i + 1}/${total}] ${entityName} - factory verified`);
           testDone = true;
         } else if (testResult === "skip") {
           state.entities[entityName].status = "skipped";
           state.entities[entityName].errorLog.push("UP/DOWN test skipped by user");
-          p4.log.warn(`[${i + 1}/${total}] ${entityName} - skipped, continuing to next entity`);
+          p5.log.warn(`[${i + 1}/${total}] ${entityName} - skipped, continuing to next entity`);
           testDone = true;
         } else {
-          p4.log.info(`Re-generating recipe data for ${entityName} based on your feedback...`);
+          p5.log.info(`Re-generating recipe data for ${entityName} based on your feedback...`);
           const revised = await reviseRecipeData(
             entityName,
             i,
@@ -4795,7 +4888,7 @@ When done, call finish with the instructions text.`;
 });
 
 // src/agents/04-recipe-builder/phases/full-validation.ts
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import { tool as tool15 } from "ai";
 import { z as z20 } from "zod";
 async function reviseFullRecipe(current, feedback, model, outputDir, entityOrder, schemaSpec) {
@@ -4854,35 +4947,35 @@ Revise the recipe to address the feedback, then call finish with the complete up
 }
 async function teardown(sdkConfig, refsToken, successMessage) {
   if (!refsToken) return true;
-  p5.log.step("[Full validation] Tearing down all entities...");
+  p6.log.step("[Full validation] Tearing down all entities...");
   let downResult;
   try {
     downResult = await down(sdkConfig, refsToken);
   } catch (err) {
-    p5.log.error(`Full DOWN request failed:
+    p6.log.error(`Full DOWN request failed:
 ${formatException(err)}`);
     return false;
   }
   if (!downResult.ok) {
-    p5.log.error(`Full DOWN failed (HTTP ${downResult.status}):`);
+    p6.log.error(`Full DOWN failed (HTTP ${downResult.status}):`);
     console.log(JSON.stringify(downResult.body, null, 2));
     return false;
   }
-  p5.log.success(successMessage);
+  p6.log.success(successMessage);
   return true;
 }
 async function runFullValidation(state, _models, outputDir, model) {
   const total = state.entityOrder.length;
-  p5.log.info(
+  p6.log.info(
     `All individual factories work. Now let's create EVERYTHING together and verify the app looks right with a full dataset. This is the recipe that will run before every test execution.`
   );
   if (!state.sdkEndpointUrl) {
-    const url = await p5.text({
+    const url = await p6.text({
       message: "What's your SDK endpoint URL?",
       placeholder: "http://localhost:3000/api/autonoma",
       defaultValue: "http://localhost:3000/api/autonoma"
     });
-    if (p5.isCancel(url)) throw new Error("Cancelled");
+    if (p6.isCancel(url)) throw new Error("Cancelled");
     state.sdkEndpointUrl = url.trim() || "http://localhost:3000/api/autonoma";
     await saveRecipeState(outputDir, state);
   }
@@ -4897,69 +4990,69 @@ async function runFullValidation(state, _models, outputDir, model) {
     if (discoverSchema) {
       const problems = validateRecipeAgainstSchema(fullRecipe, discoverSchema);
       if (problems.length > 0) {
-        p5.log.warn(
+        p6.log.warn(
           `Heads up - the recipe has likely schema problems (from /discover); the full UP may fail:
 ${formatValidationProblems(problems)}`
         );
       }
     }
     const testRunId = `full-${Date.now()}`;
-    p5.log.step(`[Full validation] Creating all ${total} entities...`);
+    p6.log.step(`[Full validation] Creating all ${total} entities...`);
     let upResult;
     try {
       upResult = await up(sdkConfig, fullRecipe, testRunId);
     } catch (err) {
-      p5.log.error(`Full UP request failed:
+      p6.log.error(`Full UP request failed:
 ${formatException(err)}`);
       notify("Autonoma", "Full validation UP failed, action needed");
-      const action = await p5.select({
+      const action = await p6.select({
         message: "What would you like to do?",
         options: [
           { value: "retry", label: "Yes, retry - I fixed it", hint: "Send the request again" },
           { value: "skip", label: "No, skip full validation", hint: "Continue to test generation" }
         ]
       });
-      if (p5.isCancel(action)) throw new Error("Cancelled");
+      if (p6.isCancel(action)) throw new Error("Cancelled");
       if (action === "skip") return false;
       continue;
     }
     if (!upResult.ok) {
-      p5.log.error(`Full UP failed (HTTP ${upResult.status}):`);
+      p6.log.error(`Full UP failed (HTTP ${upResult.status}):`);
       console.log(JSON.stringify(upResult.body, null, 2));
       notify("Autonoma", "Full validation UP failed, action needed");
-      const action = await p5.select({
+      const action = await p6.select({
         message: "What would you like to do?",
         options: [
           { value: "retry", label: "Yes, retry - I fixed it", hint: "Send the request again" },
           { value: "skip", label: "No, skip full validation", hint: "Continue to test generation" }
         ]
       });
-      if (p5.isCancel(action)) throw new Error("Cancelled");
+      if (p6.isCancel(action)) throw new Error("Cancelled");
       if (action === "skip") return false;
       continue;
     }
-    p5.log.success("Full UP succeeded!");
+    p6.log.success("Full UP succeeded!");
     const body = toRecord(upResult.body);
     const refsToken = typeof body.refsToken === "string" ? body.refsToken : void 0;
     const auth = body.auth != null && typeof body.auth === "object" ? toRecord(body.auth) : void 0;
     if (auth && Object.keys(auth).length > 0) {
       const authJson = JSON.stringify(auth, null, 2);
       const looksPlaceholder = authJson.includes("test-token") || authJson.includes("placeholder") || authJson.includes("todo");
-      p5.note(
+      p6.note(
         authJson + "\n\nThese are the credentials your auth callback returns.\nThe test runner will use them to authenticate as the test user when executing tests." + (looksPlaceholder ? "\n\n\u26A0 This looks like a placeholder. Update your auth callback to return real credentials\n(a valid JWT, session cookie, or email/password) so the test runner can actually log in." : ""),
         "Auth credentials"
       );
     } else {
-      p5.log.warn(
+      p6.log.warn(
         "No auth credentials returned. Your createHandler's auth callback must return credentials the test runner can use to log in (cookies, headers, or email/password). Without it, tests can't authenticate."
       );
     }
-    p5.log.info("Browse the app and check if the test data looks right.");
+    p6.log.info("Browse the app and check if the test data looks right.");
     notify("Autonoma", "Full validation succeeded - review the app");
-    const looksGood = await p5.confirm({
+    const looksGood = await p6.confirm({
       message: "Does the app look right with the test data?"
     });
-    if (p5.isCancel(looksGood)) throw new Error("Cancelled");
+    if (p6.isCancel(looksGood)) throw new Error("Cancelled");
     const torndown = await teardown(
       sdkConfig,
       refsToken,
@@ -4967,15 +5060,15 @@ ${formatException(err)}`);
     );
     if (!torndown) return false;
     if (looksGood) return true;
-    const feedback = await p5.text({
+    const feedback = await p6.text({
       message: "What's wrong with the test data? Describe what to change.",
       placeholder: "e.g. accounts need realistic balances, transactions should reference the right account..."
     });
-    if (p5.isCancel(feedback) || !feedback.trim()) {
-      p5.log.info("No feedback given. You can edit recipe.json manually and re-run with --resume.");
+    if (p6.isCancel(feedback) || !feedback.trim()) {
+      p6.log.info("No feedback given. You can edit recipe.json manually and re-run with --resume.");
       return false;
     }
-    p5.log.info("Revising the full recipe based on your feedback...");
+    p6.log.info("Revising the full recipe based on your feedback...");
     const revised = await reviseFullRecipe(
       fullRecipe,
       feedback.trim(),
@@ -4985,7 +5078,7 @@ ${formatException(err)}`);
       fullSchemaSpec
     );
     if (!revised) {
-      p5.log.warn("Couldn't revise automatically. Edit recipe.json manually and re-run with --resume.");
+      p6.log.warn("Couldn't revise automatically. Edit recipe.json manually and re-run with --resume.");
       return false;
     }
     for (const [name, records] of Object.entries(revised)) {
@@ -4995,7 +5088,7 @@ ${formatException(err)}`);
     }
     await saveRecipeState(outputDir, state);
     fullRecipe = buildFullRecipe(state.entityOrder, state.entities);
-    p5.note(JSON.stringify(fullRecipe, null, 2), "Revised recipe - re-running full validation", {
+    p6.note(JSON.stringify(fullRecipe, null, 2), "Revised recipe - re-running full validation", {
       format: codeNoteFormat
     });
   }
@@ -5017,45 +5110,6 @@ var init_full_validation = __esm({
   }
 });
 
-// src/agents/04-recipe-builder/phases/submit.ts
-import * as p6 from "@clack/prompts";
-async function runSubmit(state, outputDir, autonomaApiUrl, autonomaApiToken, autonomaGenerationId) {
-  const fullCreate = buildFullRecipe(state.entityOrder, state.entities);
-  const recipe = buildSubmittableRecipe(fullCreate, "Standard test scenario with realistic data");
-  await saveRecipe(outputDir, recipe);
-  p6.log.success("Recipe saved to recipe.json");
-  if (!autonomaApiUrl || !autonomaApiToken || !autonomaGenerationId) {
-    p6.log.info(
-      "Autonoma API credentials not configured - recipe saved locally. Submit manually or configure AUTONOMA_API_URL, AUTONOMA_API_TOKEN, AUTONOMA_GENERATION_ID."
-    );
-    return "recipe.json";
-  }
-  const url = `${autonomaApiUrl}/v1/setup/setups/${autonomaGenerationId}/scenario-recipe-versions`;
-  p6.log.step("Submitting recipe to Autonoma...");
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${autonomaApiToken}`
-    },
-    body: JSON.stringify(recipe)
-  });
-  if (res.ok) {
-    p6.log.success(`Recipe submitted successfully (HTTP ${res.status})`);
-  } else {
-    const text6 = await res.text();
-    p6.log.error(`Recipe submission failed (HTTP ${res.status}): ${text6}`);
-  }
-  return "recipe.json";
-}
-var init_submit = __esm({
-  "src/agents/04-recipe-builder/phases/submit.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_recipe();
-  }
-});
-
 // src/agents/04-recipe-builder/phases/tech-detect.ts
 import * as p7 from "@clack/prompts";
 import { tool as tool16 } from "ai";
@@ -5235,13 +5289,21 @@ async function runRecipeBuilder(input) {
   }
   if (state.phase === "submit") {
     const env = readEnv();
-    const recipePath = await runSubmit(
+    const { recipePath, uploaded } = await runSubmit(
       state,
       input.outputDir,
       env.AUTONOMA_API_URL,
       env.AUTONOMA_API_TOKEN,
       env.AUTONOMA_GENERATION_ID
     );
+    const uploadCredentialsPresent = env.AUTONOMA_API_URL != null && env.AUTONOMA_API_TOKEN != null && env.AUTONOMA_GENERATION_ID != null;
+    if (uploadCredentialsPresent && !uploaded) {
+      return {
+        success: false,
+        artifacts: [recipePath],
+        summary: `Recipe was generated but not accepted by Autonoma. The recipe JSON was printed above - re-upload with \`npx @autonoma-ai/planner@latest upload\` (or run again with --resume).`
+      };
+    }
     state.phase = "done";
     await saveRecipeState(input.outputDir, state);
     return {
@@ -7179,6 +7241,7 @@ function ensureSupportedNode() {
 ensureSupportedNode();
 
 // src/index.ts
+init_submit();
 import { readFile as readFile23, writeFile as writeFile14 } from "fs/promises";
 import { join as join31 } from "path";
 import * as p9 from "@clack/prompts";
@@ -7186,16 +7249,16 @@ import * as p9 from "@clack/prompts";
 // src/config.ts
 init_esm_shims();
 import { readFileSync as readFileSync2 } from "fs";
-import { resolve, join as join2 } from "path";
+import { resolve, join as join3 } from "path";
 
 // src/core/global-env.ts
 init_esm_shims();
 init_env();
 import { readFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
-var AUTONOMA_HOME = join(homedir(), ".autonoma");
-var GLOBAL_ENV_PATH = join(AUTONOMA_HOME, ".env");
+import { join as join2 } from "path";
+var AUTONOMA_HOME = join2(homedir(), ".autonoma");
+var GLOBAL_ENV_PATH = join2(AUTONOMA_HOME, ".env");
 function parseEnvContent(content) {
   const out = {};
   for (const line of content.split("\n")) {
@@ -7231,7 +7294,7 @@ init_env();
 function loadProjectEnv(projectRoot) {
   let content;
   try {
-    content = readFileSync2(join2(projectRoot, ".env"), "utf-8");
+    content = readFileSync2(join3(projectRoot, ".env"), "utf-8");
   } catch {
     return;
   }
@@ -7396,10 +7459,10 @@ init_model();
 init_esm_shims();
 import { mkdir } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
-var AUTONOMA_HOME3 = join6(homedir3(), ".autonoma");
+import { join as join7 } from "path";
+var AUTONOMA_HOME3 = join7(homedir3(), ".autonoma");
 function getOutputDir(projectSlug) {
-  return join6(AUTONOMA_HOME3, projectSlug);
+  return join7(AUTONOMA_HOME3, projectSlug);
 }
 async function ensureOutputDir(projectSlug) {
   const dir = getOutputDir(projectSlug);
@@ -7413,8 +7476,8 @@ init_env();
 // src/core/git.ts
 init_esm_shims();
 import { execFile } from "child_process";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join8 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var GIT_INFO_FILE = ".git-info.json";
@@ -7438,11 +7501,11 @@ async function readGitInfo(projectRoot) {
   };
 }
 async function saveGitInfo(outputDir, info) {
-  await writeFile2(join7(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile3(join8(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 async function loadGitInfo(outputDir) {
   try {
-    const raw = await readFile2(join7(outputDir, GIT_INFO_FILE), "utf-8");
+    const raw = await readFile3(join8(outputDir, GIT_INFO_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed != null && "sha" in parsed && typeof parsed.sha === "string") {
       const branch = "branch" in parsed && typeof parsed.branch === "string" ? parsed.branch : void 0;
@@ -7462,8 +7525,8 @@ init_project_map();
 // src/core/state.ts
 init_esm_shims();
 init_debug();
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { join as join10 } from "path";
 import { z as z3 } from "zod";
 var StepStatusSchema = z3.enum(["pending", "running", "done", "failed", "paused"]);
 var PipelineStateSchema = z3.object({
@@ -7492,9 +7555,9 @@ function initialState() {
   };
 }
 async function loadState(outputDir) {
-  const path3 = join9(outputDir, STATE_FILE);
+  const path3 = join10(outputDir, STATE_FILE);
   try {
-    const raw = await readFile4(path3, "utf-8");
+    const raw = await readFile5(path3, "utf-8");
     return PipelineStateSchema.parse(JSON.parse(raw));
   } catch (err) {
     const isMissingFile = err instanceof Error && "code" in err && err.code === "ENOENT";
@@ -7503,8 +7566,8 @@ async function loadState(outputDir) {
   }
 }
 async function saveState(outputDir, state) {
-  const path3 = join9(outputDir, STATE_FILE);
-  await writeFile4(path3, JSON.stringify(state, null, 2), "utf-8");
+  const path3 = join10(outputDir, STATE_FILE);
+  await writeFile5(path3, JSON.stringify(state, null, 2), "utf-8");
 }
 async function markStep(outputDir, state, step, status) {
   const updated = {
@@ -7530,16 +7593,16 @@ function nextPendingStep(state) {
 // src/core/upload.ts
 init_esm_shims();
 init_debug();
-import { readFile as readFile5 } from "fs/promises";
-import { basename, join as join10, relative } from "path";
-import * as p from "@clack/prompts";
+import { readFile as readFile6 } from "fs/promises";
+import { basename, join as join11, relative } from "path";
+import * as p2 from "@clack/prompts";
 import { glob } from "glob";
 var ARTIFACT_FILES = ["AUTONOMA.md", "scenarios.md", "entity-audit.md"];
 async function readArtifacts(outputDir) {
   const files = [];
   for (const name of ARTIFACT_FILES) {
     try {
-      const content = await readFile5(join10(outputDir, name), "utf-8");
+      const content = await readFile6(join11(outputDir, name), "utf-8");
       files.push({ name, content });
     } catch (err) {
       debugLog(`Artifact ${name} not on disk; skipping upload`, { err });
@@ -7548,13 +7611,13 @@ async function readArtifacts(outputDir) {
   return files;
 }
 async function readTestCases(outputDir) {
-  const testsDir = join10(outputDir, "qa-tests");
+  const testsDir = join11(outputDir, "qa-tests");
   const matches = await glob("**/*.md", { cwd: testsDir, nodir: true });
   const files = [];
   for (const match of matches) {
     const name = basename(match);
     if (name === "INDEX.md") continue;
-    const content = await readFile5(join10(testsDir, match), "utf-8");
+    const content = await readFile6(join11(testsDir, match), "utf-8");
     const folderPath = relative(".", match).split("/").slice(0, -1).join("/");
     files.push({ name, content, folder: folderPath.length > 0 ? folderPath : void 0 });
   }
@@ -7591,14 +7654,14 @@ async function patchJson(url, token, body) {
 async function uploadArtifacts(config, outputDir) {
   const { autonomaApiUrl, autonomaApiToken, autonomaGenerationId } = config;
   if (autonomaApiUrl == null || autonomaApiToken == null || autonomaGenerationId == null) {
-    p.log.info(
+    p2.log.info(
       `Autonoma upload credentials not configured - artifacts saved locally only. They live in ${outputDir}.`
     );
     return;
   }
   const baseUrl = autonomaApiUrl.replace(/\/+$/, "");
   const setupUrl = `${baseUrl}/v1/setup/setups/${autonomaGenerationId}`;
-  p.log.step("Uploading artifacts to Autonoma...");
+  p2.log.step("Uploading artifacts to Autonoma...");
   const [testCases, artifacts, gitInfo] = await Promise.all([
     readTestCases(outputDir),
     readArtifacts(outputDir),
@@ -7606,7 +7669,7 @@ async function uploadArtifacts(config, outputDir) {
   ]);
   await postJson(`${setupUrl}/artifacts`, autonomaApiToken, { testCases, artifacts, commitSha: gitInfo?.sha });
   await patchJson(setupUrl, autonomaApiToken, { status: "completed" });
-  p.log.success(
+  p2.log.success(
     `Uploaded ${testCases.length} test case${testCases.length === 1 ? "" : "s"} and ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"}. Return to your browser to continue onboarding.`
   );
 }
@@ -7974,12 +8037,28 @@ async function main() {
     await showStatus(outputDir2);
     return;
   }
+  if (command === "upload") {
+    const config2 = loadConfig({
+      project: strArg(args, "project"),
+      slug: strArg(args, "slug")
+    });
+    const outputDir2 = await ensureOutputDir(config2.projectSlug);
+    const recipeUploaded = await uploadRecipeFromDisk(outputDir2, {
+      apiUrl: config2.autonomaApiUrl,
+      apiToken: config2.autonomaApiToken,
+      generationId: config2.autonomaGenerationId
+    });
+    await uploadArtifacts(config2, outputDir2);
+    await flushAnalytics();
+    process.exit(recipeUploaded ? 0 : 1);
+  }
   if (command === "help" || args.help) {
     console.log("Usage:");
     console.log(
       "  test-planner [run] [--project <path>] [--frontend <path>] [--backends <path,path>] [--model <id>] [--step <name>] [--resume] [--non-interactive]"
     );
     console.log("  test-planner status [--project <path>]");
+    console.log("  test-planner upload [--project <path>]   # re-upload already-generated recipe + artifacts");
     console.log("");
     console.log("`run` is the default command; it may be omitted.");
     return;