@autonoma-ai/planner 0.1.13 → 0.1.14-canary.9e91c81

package/dist/index.js

@@ -604,7 +604,7 @@ async function runAgent(config, prompt, extractResult) {
       err
     );
   };
-  const YELLOW5 = "\x1B[33m";
+  const YELLOW4 = "\x1B[33m";
   const RESET8 = "\x1B[0m";
   for (let modelIdx = 0; modelIdx < modelsToTry.length; modelIdx++) {
     const model = modelsToTry[modelIdx];
@@ -630,7 +630,7 @@ async function runAgent(config, prompt, extractResult) {
         while (extractResult() === void 0 && nudges < MAX_NUDGES) {
           nudges++;
           console.log(
-            `  ${YELLOW5}[${config.id}] agent stopped without finishing \u2014 nudging (${nudges}/${MAX_NUDGES})...${RESET8}`
+            `  ${YELLOW4}[${config.id}] agent stopped without finishing \u2014 nudging (${nudges}/${MAX_NUDGES})...${RESET8}`
           );
           track("cli_agent_nudged", { agent: config.id, nudge: nudges });
           messages.push(...generation.response.messages);
@@ -646,14 +646,14 @@ async function runAgent(config, prompt, extractResult) {
         if (errorClass === "fatal") fail(err, model);
         const msg = err instanceof Error ? err.message : String(err);
         if (errorClass === "timeout") {
-          console.log(`  ${YELLOW5}[${config.id}] step timed out after ${stepTimeout / 1e3}s${RESET8}`);
+          console.log(`  ${YELLOW4}[${config.id}] step timed out after ${stepTimeout / 1e3}s${RESET8}`);
         } else {
-          console.log(`  ${YELLOW5}[${config.id}] provider error: ${msg}${RESET8}`);
+          console.log(`  ${YELLOW4}[${config.id}] provider error: ${msg}${RESET8}`);
         }
         track("cli_agent_retryable_error", { agent: config.id, error_class: errorClass, retry });
         if (retry < RETRIES_BEFORE_FALLBACK - 1) {
           console.log(
-            `  ${YELLOW5}[${config.id}] retrying (${retry + 1}/${RETRIES_BEFORE_FALLBACK})...${RESET8}`
+            `  ${YELLOW4}[${config.id}] retrying (${retry + 1}/${RETRIES_BEFORE_FALLBACK})...${RESET8}`
           );
           if (errorClass === "transient") {
             await sleep(Math.min(2e3 * 2 ** retry, 1e4));
@@ -663,7 +663,7 @@ async function runAgent(config, prompt, extractResult) {
         if (modelIdx < modelsToTry.length - 1) {
           const nextModel = FALLBACK_MODELS[modelIdx];
           console.log(
-            `  ${YELLOW5}[${config.id}] ${RETRIES_BEFORE_FALLBACK} failed attempts, switching to ${nextModel}${RESET8}`
+            `  ${YELLOW4}[${config.id}] ${RETRIES_BEFORE_FALLBACK} failed attempts, switching to ${nextModel}${RESET8}`
           );
           break;
         }
@@ -2839,19 +2839,10 @@ async function parseScenario(outputDir) {
   }
   try {
     const data = matter3(raw).data;
-    const varsByEntity = /* @__PURE__ */ new Map();
-    for (const vf of data.variable_fields ?? []) {
-      const entity = vf?.entity != null ? String(vf.entity) : "";
-      const field = vf?.field != null ? String(vf.field) : "";
-      if (!entity || !field) continue;
-      const list = varsByEntity.get(entity) ?? [];
-      list.push(field);
-      varsByEntity.set(entity, list);
-    }
     const entityTypes = (data.entity_types ?? []).map((e) => {
       const name = e?.name != null ? String(e.name).trim() : "";
       const count = typeof e?.count === "number" ? e.count : Number(e?.count ?? 0) || 0;
-      return { name, count, variableFields: varsByEntity.get(name) ?? [] };
+      return { name, count };
     }).filter((e) => e.name.length > 0);
     const scenarioNames = (data.scenarios ?? []).map((s) => s?.name != null ? String(s.name).trim() : "").filter((n) => n.length > 0);
     return { scenarioNames, entityTypes };
@@ -2859,6 +2850,23 @@ async function parseScenario(outputDir) {
     return { scenarioNames: [], entityTypes: [] };
   }
 }
+function validateScenarioIsConcrete(content) {
+  const errors = [];
+  const checks = [
+    { pattern: /\{\{[a-zA-Z0-9_]+\}\}/g, label: "{{token}} placeholder" },
+    { pattern: /(?<!\{)\{[a-z][a-zA-Z]*\}(?!\})/g, label: "bare {variable} placeholder" },
+    { pattern: /^\s*variable_fields\s*:/m, label: "variable_fields block" }
+  ];
+  for (const { pattern, label } of checks) {
+    const match = content.match(pattern);
+    if (match && match.length > 0) {
+      errors.push(
+        `${label}: "${match[0].trim()}" \u2014 scenario values must be concrete. Replace it with the exact static value (there is no variable mechanism).`
+      );
+    }
+  }
+  return errors;
+}
 function truncate3(s, max) {
   if (s.length <= max) return s;
   return s.slice(0, max - 1).trimEnd() + "\u2026";
@@ -2869,40 +2877,32 @@ function pad3(s, width) {
 function renderScenarioTable(parsed) {
   if (parsed.entityTypes.length === 0) return "";
   const NAME_MAX = 32;
-  const VARS_MAX = 40;
   const rows = parsed.entityTypes.map((e, i) => ({
     num: String(i + 1),
     name: truncate3(e.name, NAME_MAX),
-    count: String(e.count),
-    vars: e.variableFields.length ? truncate3(e.variableFields.join(", "), VARS_MAX) : "\u2014",
-    hasVars: e.variableFields.length > 0
+    count: String(e.count)
   }));
   const numW = Math.max(1, ...rows.map((r) => r.num.length));
   const nameW = Math.max("Entity".length, ...rows.map((r) => r.name.length));
   const countW = Math.max("Count".length, ...rows.map((r) => r.count.length));
   const totalRecords = parsed.entityTypes.reduce((sum, e) => sum + e.count, 0);
-  const withVars = parsed.entityTypes.filter((e) => e.variableFields.length > 0).length;
-  const header = `${BOLD4}${pad3("#", numW)}  ${pad3("Entity", nameW)}  ${pad3("Count", countW)}  Variable fields${RESET6}`;
-  const sep = `${DIM6}${"\u2500".repeat(numW + nameW + countW + VARS_MAX + 6)}${RESET6}`;
-  const body = rows.map((r) => {
-    const line = `${pad3(r.num, numW)}  ${pad3(r.name, nameW)}  ${pad3(r.count, countW)}  ${r.vars}`;
-    return r.hasVars ? `${YELLOW4}${line}${RESET6}` : line;
-  }).join("\n");
+  const header = `${BOLD4}${pad3("#", numW)}  ${pad3("Entity", nameW)}  ${pad3("Count", countW)}${RESET6}`;
+  const sep = `${DIM6}${"\u2500".repeat(numW + nameW + countW + 4)}${RESET6}`;
+  const body = rows.map((r) => `${pad3(r.num, numW)}  ${pad3(r.name, nameW)}  ${pad3(r.count, countW)}`).join("\n");
   const scenarioLabel = parsed.scenarioNames.length ? `scenario: ${parsed.scenarioNames.join(", ")} \xB7 ` : "";
-  const caption = `${DIM6}${scenarioLabel}${parsed.entityTypes.length} entity types \xB7 ${totalRecords} records \xB7 ${withVars} with variable fields${RESET6}`;
+  const caption = `${DIM6}${scenarioLabel}${parsed.entityTypes.length} entity types \xB7 ${totalRecords} records${RESET6}`;
   return `${header}
 ${sep}
 ${body}
 ${caption}`;
 }
-var RESET6, DIM6, YELLOW4, BOLD4;
+var RESET6, DIM6, BOLD4;
 var init_scenario_table = __esm({
   "src/agents/03-scenario-recipe/scenario-table.ts"() {
     "use strict";
     init_esm_shims();
     RESET6 = "\x1B[0m";
     DIM6 = "\x1B[2m";
-    YELLOW4 = "\x1B[33m";
     BOLD4 = "\x1B[1m";
   }
 });
@@ -2948,27 +2948,23 @@ entity_types:
     count: 3
   - name: Project
     count: 5
-variable_fields:
-  - token: "{{user_email_1}}"
-    entity: User
-    field: email
-    test_reference: "primary test user email"
 ---
 \`\`\`
 
 After frontmatter, write entity tables showing the data for the standard scenario.
 Use markdown tables. Show enough detail that a recipe builder can generate the exact records.
 
-## Variable fields
-Some values must change between test runs (emails, unique slugs, timestamps).
-List these in variable_fields with a {{token}} placeholder.
-The rest can be static.`;
+## Data values
+Every value in the scenario is concrete and static \u2014 write the actual data the
+records should hold. Do NOT use placeholders, tokens, or templated/"dynamic"
+values; the recipe builder generates the exact records from what you write.`;
   }
 });
 
 // src/agents/03-scenario-recipe/index.ts
 var scenario_recipe_exports = {};
 __export(scenario_recipe_exports, {
+  buildFinishTool: () => buildFinishTool3,
   feedbackToScenario: () => feedbackToScenario,
   runScenarioRecipe: () => runScenarioRecipe
 });
@@ -2985,23 +2981,30 @@ function buildFinishTool3(requiredEntities, outputDir, onFinish) {
       artifacts: z13.array(z13.string()).describe("Files written")
     }),
     execute: async (input) => {
+      let content;
+      try {
+        content = await readFile13(join19(outputDir, "scenarios.md"), "utf-8");
+      } catch {
+        return { error: "Cannot finish: scenarios.md not found. Write it first." };
+      }
       if (requiredEntities.length > 0) {
-        try {
-          const content = await readFile13(join19(outputDir, "scenarios.md"), "utf-8");
-          const missing = requiredEntities.filter(
-            (e) => !content.includes(e)
-          );
-          if (missing.length > 0) {
-            return {
-              error: `Cannot finish: ${missing.length} entities from the entity audit are missing from scenarios.md.
+        const missing = requiredEntities.filter((e) => !content.includes(e));
+        if (missing.length > 0) {
+          return {
+            error: `Cannot finish: ${missing.length} entities from the entity audit are missing from scenarios.md.
 Add these entities to the scenario before calling finish:
 ` + missing.map((e) => `  - ${e}`).join("\n")
-            };
-          }
-        } catch {
-          return { error: "Cannot finish: scenarios.md not found. Write it first." };
+          };
         }
       }
+      const concretenessErrors = validateScenarioIsConcrete(content);
+      if (concretenessErrors.length > 0) {
+        return {
+          error: `Cannot finish: scenario data must be fully concrete \u2014 no variables, tokens, or placeholders.
+Fix these before calling finish:
+` + concretenessErrors.map((e) => `  - ${e}`).join("\n")
+        };
+      }
       onFinish({
         success: true,
         artifacts: input.artifacts,
@@ -3033,7 +3036,6 @@ The scenario should:
 1. Cover ALL ${requiredEntities.length || ""} entity types from the entity audit \u2014 no exceptions
 2. Use realistic data volumes (not just 1 of each)
 3. Cover all enum values (at least one record per value)
-4. Include variable_fields for values that must change between runs
 
 When done, call finish.`;
   const agentConfig = {
@@ -3059,7 +3061,7 @@ When done, call finish.`;
       const parsed = await parseScenario(input.outputDir);
       return parsed.entityTypes.length ? renderScenarioTable(parsed) : void 0;
     },
-    reviewGuidance: "The scenario defines test data that will exist in the database during E2E tests.\nEach entity_type should have a realistic count and data values.\n\nWhat to check:\n  - Every entity from the entity audit should appear here\n  - Counts should be realistic (not just 1 of each)\n  - Enum fields should have diverse values (not all the same)\n  - variable_fields should mark values that must change between runs (emails, slugs)\n  - Data values should match your actual database patterns",
+    reviewGuidance: "The scenario defines test data that will exist in the database during E2E tests.\nEach entity_type should have a realistic count and data values.\n\nWhat to check:\n  - Every entity from the entity audit should appear here\n  - Counts should be realistic (not just 1 of each)\n  - Enum fields should have diverse values (not all the same)\n  - Data values should match your actual database patterns",
     onFeedback: async (feedback) => {
       result = void 0;
       const feedbackPrompt = `The user reviewed the scenario design and has this feedback:
@@ -5535,6 +5537,22 @@ import { dirname as dirname3, join as join28 } from "path";
 import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool18, ToolLoopAgent as ToolLoopAgent3 } from "ai";
 import matter5 from "gray-matter";
 import { z as z21 } from "zod";
+function findForbiddenPlaceholder(stepsSection) {
+  const placeholderPatterns = [
+    { pattern: /Dynamic:\s/gi, name: '"Dynamic:" placeholder' },
+    { pattern: /\{\{[a-zA-Z0-9_]+\}\}/g, name: "{{token}} placeholder" },
+    { pattern: /(?<!\{)\{[a-z][a-zA-Z]*\}(?!\})/g, name: "bare {variable}" },
+    { pattern: /\(e\.g\./gi, name: '"(e.g." example' },
+    { pattern: /(?:^|\s)e\.g\.,?\s/gim, name: '"e.g." example' }
+  ];
+  for (const { pattern, name } of placeholderPatterns) {
+    const matches = stepsSection.match(pattern);
+    if (matches && matches.length > 0) {
+      return { name, match: matches[0] };
+    }
+  }
+  return null;
+}
 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.",
@@ -5577,19 +5595,11 @@ function buildWriteTestTool(state, outputDir) {
       const bodyStart = input.content.indexOf("---", 3);
       const body = bodyStart > -1 ? input.content.slice(bodyStart + 3) : input.content;
       const stepsSection = body.slice(body.indexOf("**Steps**") || 0);
-      const placeholderPatterns = [
-        { pattern: /Dynamic:\s/gi, name: '"Dynamic:" placeholder' },
-        { pattern: /(?<!\{)\{[a-z][a-zA-Z]*\}(?!\})/g, name: "bare {variable}" },
-        { pattern: /\(e\.g\./gi, name: '"(e.g." example' },
-        { pattern: /(?:^|\s)e\.g\.,?\s/gim, name: '"e.g." example' }
-      ];
-      for (const { pattern, name } of placeholderPatterns) {
-        const matches = stepsSection.match(pattern);
-        if (matches && matches.length > 0) {
-          return {
-            error: `Test steps contain ${name}: "${matches[0]}". Use EXACT values from scenarios.md \u2014 not placeholders or examples.`
-          };
-        }
+      const placeholder = findForbiddenPlaceholder(stepsSection);
+      if (placeholder) {
+        return {
+          error: `Test steps contain ${placeholder.name}: "${placeholder.match}". Use EXACT values from scenarios.md \u2014 not placeholders or examples.`
+        };
       }
       const relPath = join28("qa-tests", input.folder, input.filename);
       const absPath = join28(outputDir, relPath);
@@ -6012,7 +6022,7 @@ EVERY assertion MUST include location context \u2014 where on the page the eleme
 - Be specific: use exact button text, field names, toast messages FROM THE CODE
 - One test per file
 - Never write meta-tests that "audit" scenario/fixture contents
-- Reference scenario data when needed for real user flows, using {{token}} placeholders for variable fields
+- Reference scenario data when needed for real user flows, using the exact values from the scenario
 - Do NOT write tests that verify the test infrastructure itself
 - Every step must be concrete and reproducible. "assert: text 'Deal Created' is visible in toast" is GOOD. "assert: success indicator appears" is BAD.
 
@@ -6041,8 +6051,8 @@ Therefore:
 The scenarios define EXACTLY what data exists in the database. Since WE control the test data, assertions should reference EXACT values from the scenario.
 - When a test needs to verify data is displayed, use the EXACT values from the scenario (names, emails, titles, counts)
 - Read scenarios.md carefully and use the exact entity names, counts, and field values in your assertions
-- Use {{token}} placeholders ONLY for values that genuinely vary between runs (like auto-generated IDs)
-- NEVER use "Dynamic:", "{variableName}", or "e.g." in steps or assertions. You have exact data \u2014 use it.
+- Do NOT assert on values that are auto-generated or vary at runtime (like database IDs); assert on the stable scenario values instead
+- NEVER use "Dynamic:", "{variableName}", "{{token}}", or "e.g." in steps or assertions. You have exact data \u2014 use it.
 - NEVER assume facts not stated in the scenario data.
 
 ## Test generation ordering (for consistency)