@autonoma-ai/planner 0.1.23 → 0.1.24

package/dist/index.js

@@ -76,16 +76,24 @@ var init_debug = __esm({
 
 // src/core/posthog.ts
 function getPostHogConfig() {
+  const signature = [
+    process.env.AUTONOMA_POSTHOG_KEY,
+    process.env.AUTONOMA_POSTHOG_HOST,
+    process.env.DONT_TRACK
+  ].join("\0");
+  if (cached?.signature === signature) return cached.config;
   const env = readEnv();
   const key = (env.AUTONOMA_POSTHOG_KEY ?? POSTHOG_PUBLIC_KEY).trim();
   const optedOut = env.DONT_TRACK === "1" || env.DONT_TRACK === "true";
-  return {
+  const config = {
     key,
     host: (env.AUTONOMA_POSTHOG_HOST ?? DEFAULT_HOST).replace(/\/+$/, ""),
     enabled: !optedOut && key.length > 0
   };
+  cached = { signature, config };
+  return config;
 }
-var POSTHOG_PUBLIC_KEY, DEFAULT_HOST;
+var POSTHOG_PUBLIC_KEY, DEFAULT_HOST, cached;
 var init_posthog = __esm({
   "src/core/posthog.ts"() {
     "use strict";
@@ -211,15 +219,6 @@ function nowUnixNano() {
 }
 function captureLog(level, message, attributes = {}) {
   if (!getPostHogConfig().enabled) return;
-  if (recordsThisRun >= MAX_RECORDS_PER_RUN) {
-    if (!capReported) {
-      capReported = true;
-      enqueue(buildRecord("warn", "Log budget exhausted for this run; further logs are dropped", {}));
-      flush();
-    }
-    return;
-  }
-  recordsThisRun++;
   enqueue(buildRecord(level, message, attributes));
 }
 async function flushLogs(timeoutMs = 1500) {
@@ -277,7 +276,7 @@ function buildRecord(level, message, attributes) {
     timeUnixNano: `${nowUnixNano()}`,
     severityNumber: SEVERITY_NUMBERS[level],
     severityText: level.toUpperCase(),
-    body: { stringValue: truncate(message, MAX_MESSAGE_CHARS) },
+    body: { stringValue: message },
     attributes: toKeyValues(merged)
   };
 }
@@ -304,12 +303,9 @@ function toAnyValue(value) {
   if (typeof value === "number") {
     return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
   }
-  return { stringValue: truncate(value, MAX_ATTRIBUTE_CHARS) };
-}
-function truncate(text2, max) {
-  return text2.length <= max ? text2 : `${text2.slice(0, max)}...`;
+  return { stringValue: value };
 }
-var LOGS_PATH, SERVICE_NAME, MAX_BATCH_RECORDS, FLUSH_INTERVAL_MS, MAX_RECORDS_PER_RUN, MAX_MESSAGE_CHARS, MAX_ATTRIBUTE_CHARS, SEVERITY_NUMBERS, CLOCK_ORIGIN_MS, CLOCK_ORIGIN_NS, queue, inFlight, recordsThisRun, capReported, flushTimer;
+var LOGS_PATH, SERVICE_NAME, MAX_BATCH_RECORDS, FLUSH_INTERVAL_MS, SEVERITY_NUMBERS, CLOCK_ORIGIN_MS, CLOCK_ORIGIN_NS, queue, inFlight, flushTimer;
 var init_logs = __esm({
   "src/core/logs.ts"() {
     "use strict";
@@ -321,9 +317,6 @@ var init_logs = __esm({
     SERVICE_NAME = "autonoma-planner";
     MAX_BATCH_RECORDS = 50;
     FLUSH_INTERVAL_MS = 2e3;
-    MAX_RECORDS_PER_RUN = 5e3;
-    MAX_MESSAGE_CHARS = 2e3;
-    MAX_ATTRIBUTE_CHARS = 500;
     SEVERITY_NUMBERS = {
       debug: 5,
       info: 9,
@@ -334,8 +327,6 @@ var init_logs = __esm({
     CLOCK_ORIGIN_NS = process.hrtime.bigint();
     queue = [];
     inFlight = /* @__PURE__ */ new Set();
-    recordsThisRun = 0;
-    capReported = false;
   }
 });
 
@@ -2196,7 +2187,7 @@ function analysisVerdictPlane(category) {
   const tier = analysisFindingTier(category);
   return tier === "bug" || tier === "passed" ? "app_health" : "coverage";
 }
-var analysisVerdictSchema, ANALYSIS_VERDICT, VERDICT_TIER, coverageVerdicts, analysisTestOriginSchema, coverageCategoryCountSchema, coverageSummarySchema, analysisClassificationReportSchema, analysisClassificationSummarySchema, analysisFindingViewSchema, analysisReportDataSchema, analysisIssueKindSchema, analysisIssueSeveritySchema, analysisIssueStatusSchema, resolvedPrimaryScreenshotSchema, analysisIssueSummarySchema, analysisIssueFindingInstanceSchema, analysisIssueDetailSchema, analysisSnapshotIssueChangesSchema;
+var analysisVerdictSchema, ANALYSIS_VERDICT, VERDICT_TIER, coverageVerdicts, analysisTestOriginSchema, coverageCategoryCountSchema, coverageSummarySchema, analysisClassificationReportSchema, analysisClassificationSummarySchema, analysisFindingViewSchema, analysisReportDataSchema, analysisIssueKindSchema, analysisIssueSeveritySchema, analysisIssueStatusSchema, resolvedPrimaryScreenshotSchema, analysisIssueSummarySchema, analysisIssueFindingInstanceSchema, analysisIssueDetailSchema, analysisPrCoveredTestSchema, analysisPrIssueSchema, analysisPrNewerRunSchema, analysisForPrSchema, analysisSnapshotIssueChangesSchema;
 var init_analysis = __esm({
   "../../packages/types/src/schemas/analysis.ts"() {
     "use strict";
@@ -2389,6 +2380,71 @@ var init_analysis = __esm({
       resolvedAt: z8.date().optional(),
       findingInstances: z8.array(analysisIssueFindingInstanceSchema)
     });
+    analysisPrCoveredTestSchema = z8.object({
+      slug: z8.string(),
+      origin: analysisTestOriginSchema.optional(),
+      /** Impact Analysis's reason for selecting this test for the run. */
+      selectionReason: z8.string().optional(),
+      /** The test's terminal verdict in the run that attributed it here. A plain string, so a stored value outside the
+       * current taxonomy still reads as a label instead of failing the payload. */
+      category: z8.string()
+    });
+    analysisPrIssueSchema = z8.object({
+      id: z8.string(),
+      title: z8.string(),
+      /** What kind of failure this is, which decides WHERE the fix lives: a `bug` is fixed in the repo, while
+       * `environment` and `scenario` are fixed in Autonoma (secrets/preview config, and scenario recipes). */
+      kind: analysisIssueKindSchema,
+      severity: analysisIssueSeveritySchema,
+      expectedBehavior: z8.string().optional(),
+      actualBehavior: z8.string(),
+      /** The grounded diagnosis: how the referenced code produces the symptom, with file:line references and the
+       * verbatim lines that were read. A lead to confirm, never a verdict. */
+      suspectedCause: suspectedCauseSchema.optional(),
+      /** Short-lived signed URL of the issue's hero frame. */
+      screenshotUrl: z8.string().optional(),
+      /** Short-lived signed URL of an animated clip of the designated reproduction, when the run captured one. */
+      clipUrl: z8.string().optional(),
+      /** Distinct runs this issue has been attributed to - its recurrence across the branch. */
+      runCount: z8.number().int().nonnegative(),
+      /** The issue's detail page (login required). */
+      issueUrl: z8.string(),
+      /** The run designated as the clearest reproduction (login required). Absent when none was resolved. */
+      replayUrl: z8.string().optional(),
+      coveredTests: z8.array(analysisPrCoveredTestSchema)
+    });
+    analysisPrNewerRunSchema = z8.object({
+      status: z8.enum(["running", "failed"]),
+      failureReason: z8.string().optional()
+    });
+    analysisForPrSchema = z8.discriminatedUnion("status", [
+      z8.object({ status: z8.literal("no_analysis") }),
+      z8.object({ status: z8.literal("in_progress") }),
+      z8.object({ status: z8.literal("failed"), failureReason: z8.string().optional() }),
+      z8.object({
+        status: z8.literal("complete"),
+        /** The app-health verdict: `client_bug` when the branch has an open bug issue, else `passed`. */
+        verdict: analysisVerdictSchema,
+        /** The Reporter's one-paragraph summary of the run. */
+        summary: z8.string().optional(),
+        /** The Reporter's holistic report prose. Its `evidence:` image tokens resolve against `reportEvidence`, and
+         * its `issue:` tokens against the `issues` below. */
+        reportMarkdown: z8.string().optional(),
+        reportEvidence: z8.array(resolvedEvidenceAssetSchema),
+        /** Per-category counts of the run's non-app-health findings. These never block the PR, and a category here
+         * without a matching issue below is one the run could not turn into something actionable. */
+        coverage: coverageSummarySchema.optional(),
+        testCount: z8.number().int().nonnegative(),
+        clientBugCount: z8.number().int().nonnegative(),
+        /** Impact Analysis's account of why the run selected the tests it did. */
+        impactReasoning: z8.string().optional(),
+        /** The PR overview page (login required). */
+        prUrl: z8.string(),
+        /** The branch's open issues, every kind, most actionable first. */
+        issues: z8.array(analysisPrIssueSchema),
+        newerRun: analysisPrNewerRunSchema.optional()
+      })
+    ]);
     analysisSnapshotIssueChangesSchema = z8.object({
       opened: z8.array(analysisIssueSummarySchema),
       carriedForward: z8.array(analysisIssueSummarySchema),
@@ -4048,8 +4104,140 @@ var init_bug_detail = __esm({
   }
 });
 
-// ../../packages/types/src/schemas/index.ts
+// ../../packages/types/src/schemas/suite-health.ts
 import { z as z29 } from "zod";
+var SUITE_HEALTH_LEVELS, suiteHealthLevelSchema, suiteHealthDriverSchema, suiteHealthGateSchema, suiteHealthEvidenceSchema, suiteHealthBreakdownSchema, suiteHealthSchema;
+var init_suite_health = __esm({
+  "../../packages/types/src/schemas/suite-health.ts"() {
+    "use strict";
+    init_esm_shims();
+    SUITE_HEALTH_LEVELS = ["degraded", "at_risk", "calibrating", "steady", "proven"];
+    suiteHealthLevelSchema = z29.enum(SUITE_HEALTH_LEVELS);
+    suiteHealthDriverSchema = z29.enum(["environment", "scenario", "plan", "engine", "balanced", "none"]);
+    suiteHealthGateSchema = z29.enum(["runs", "pull_requests", "age", "stale_issues", "no_triage"]);
+    suiteHealthEvidenceSchema = z29.object({
+      /** Analysis runs in the window. A run that selected no tests is not one. */
+      runs: z29.number().int(),
+      /** Distinct branches those runs covered. */
+      pullRequests: z29.number().int(),
+      /** Tests the agent re-planned and re-ran, that then passed. */
+      selfHeals: z29.number().int(),
+      /** Tests the agent re-planned and re-ran at all - the denominator of the self-heal rate. */
+      selfHealAttempts: z29.number().int(),
+      /** Total findings in the window - the denominator of the trust rate. */
+      findings: z29.number().int(),
+      /** Whole days since the app's first analysis run of any pipeline. */
+      ageDays: z29.number().int(),
+      /** Whole days since its most recent run. Drives the inactivity decay. */
+      daysSinceLastRun: z29.number().int()
+    });
+    suiteHealthBreakdownSchema = z29.object({
+      passed: z29.number().int(),
+      clientBug: z29.number().int(),
+      environmentFailure: z29.number().int(),
+      scenarioIssue: z29.number().int(),
+      planMismatch: z29.number().int(),
+      engineArtifact: z29.number().int(),
+      invalidTest: z29.number().int()
+    });
+    suiteHealthSchema = z29.object({
+      level: suiteHealthLevelSchema,
+      /** 1-5. Always `suiteHealthRank(level)`; sent so clients never re-derive it. */
+      rank: z29.number().int(),
+      /** 0-100, after modifiers. Display-only - the level is what surfaces read. */
+      score: z29.number(),
+      /**
+       * `(passed + client_bug) / findings`, 0-100, before modifiers. The headline fact: of the tests the agent
+       * investigated, how many produced a verdict you can act on.
+       */
+      trust: z29.number(),
+      evidence: suiteHealthEvidenceSchema,
+      breakdown: suiteHealthBreakdownSchema,
+      driver: suiteHealthDriverSchema,
+      /** Open issues older than a week on a branch that is still live. What DEGRADED is actually made of. */
+      staleIssues: z29.number().int(),
+      /** The gate holding the level down, if the score alone would have placed it higher. */
+      gatedBy: suiteHealthGateSchema.optional(),
+      /** False before the first analysis run ever - the meter shows "waiting for your first pull request". */
+      hasEverRun: z29.boolean()
+    });
+  }
+});
+
+// ../../packages/types/src/schemas/suite-health-fix-plan.ts
+import { z as z30 } from "zod";
+var suiteHealthFixKindSchema, suiteHealthFixSeveritySchema, suiteHealthFixIssueSchema, suiteHealthFixBranchStateSchema, suiteHealthFixBranchSchema, suiteHealthFixClusterSchema, suiteHealthFixPlanSchema;
+var init_suite_health_fix_plan = __esm({
+  "../../packages/types/src/schemas/suite-health-fix-plan.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_analysis();
+    suiteHealthFixKindSchema = analysisIssueKindSchema;
+    suiteHealthFixSeveritySchema = analysisIssueSeveritySchema;
+    suiteHealthFixIssueSchema = z30.object({
+      id: z30.string(),
+      kind: suiteHealthFixKindSchema,
+      severity: suiteHealthFixSeveritySchema,
+      title: z30.string(),
+      ageDays: z30.number().int()
+    });
+    suiteHealthFixBranchStateSchema = z30.enum(["open", "merged", "closed", "main"]);
+    suiteHealthFixBranchSchema = z30.object({
+      branchId: z30.string(),
+      branchName: z30.string(),
+      state: suiteHealthFixBranchStateSchema,
+      prNumber: z30.number().int().optional(),
+      prTitle: z30.string().optional(),
+      prUrl: z30.string().optional(),
+      /** The findings shown. Capped - `issueCount` is the true total. */
+      issues: z30.array(suiteHealthFixIssueSchema),
+      issueCount: z30.number().int(),
+      /** Kind tally over EVERY finding on the branch, not just the shown ones - those two routinely differ. */
+      byKind: z30.object({
+        bug: z30.number().int(),
+        environment: z30.number().int(),
+        scenario: z30.number().int()
+      }),
+      /** Age of the oldest unresolved finding on this branch, in whole days. */
+      oldestAgeDays: z30.number().int()
+    });
+    suiteHealthFixClusterSchema = z30.object({
+      title: z30.string(),
+      kind: suiteHealthFixKindSchema,
+      /** Distinct branches carrying it. */
+      branches: z30.number().int(),
+      /** How many of those are still-open pull requests - the ones a fix unblocks today. */
+      openBranches: z30.number().int(),
+      findings: z30.number().int()
+    });
+    suiteHealthFixPlanSchema = z30.object({
+      /**
+       * `owner/repo`, which every MCP tool is keyed by. Absent when it cannot be resolved without asking GitHub,
+       * in which case the prompt tells the agent to read the git remote instead - which is what the MCP's own
+       * instructions tell it to do anyway.
+       */
+      repoFullName: z30.string().optional(),
+      /** Unresolved findings across every branch. */
+      totalIssues: z30.number().int(),
+      byKind: z30.object({
+        bug: z30.number().int(),
+        environment: z30.number().int(),
+        scenario: z30.number().int()
+      }),
+      /** Age of the oldest unresolved finding anywhere on the app, in whole days. */
+      oldestAgeDays: z30.number().int(),
+      /** True when the scan hit its cap, so `totalIssues` is a floor rather than the count. Never hide this. */
+      truncated: z30.boolean(),
+      /** Repeated findings, most-shared first. Empty when nothing repeats. */
+      clusters: z30.array(suiteHealthFixClusterSchema),
+      /** The prompt the user copies. Authored from the rows above. */
+      prompt: z30.string()
+    });
+  }
+});
+
+// ../../packages/types/src/schemas/index.ts
+import { z as z31 } from "zod";
 var PlatformSchema, TestStatusSchema;
 var init_schemas = __esm({
   "../../packages/types/src/schemas/index.ts"() {
@@ -4081,8 +4269,10 @@ var init_schemas = __esm({
     init_pr_pipeline_status();
     init_bug_detail();
     init_investigation_report();
-    PlatformSchema = z29.enum(["web", "ios", "android"]);
-    TestStatusSchema = z29.enum(["pending", "running", "passed", "failed", "cancelled"]);
+    init_suite_health();
+    init_suite_health_fix_plan();
+    PlatformSchema = z31.enum(["web", "ios", "android"]);
+    TestStatusSchema = z31.enum(["pending", "running", "passed", "failed", "cancelled"]);
   }
 });
 
@@ -4117,16 +4307,16 @@ var init_billing = __esm({
 });
 
 // ../../packages/types/src/schemas/billing.ts
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 var BillingTransactionSchema, BillingStatusSchema, CreateCheckoutInputSchema, AutoTopUpInputSchema, RunCompletedSchema;
 var init_billing2 = __esm({
   "../../packages/types/src/schemas/billing.ts"() {
     "use strict";
     init_esm_shims();
     init_billing();
-    BillingTransactionSchema = z30.object({
-      id: z30.string(),
-      type: z30.enum([
+    BillingTransactionSchema = z32.object({
+      id: z32.string(),
+      type: z32.enum([
         "SUBSCRIPTION_GRANT",
         "SUBSCRIPTION_RESET",
         "TOPUP_PURCHASE",
@@ -4135,70 +4325,70 @@ var init_billing2 = __esm({
         "GENERATION_REFUND",
         "RUN_CONSUMPTION"
       ]),
-      amount: z30.number(),
-      balanceAfter: z30.number(),
-      generationId: z30.string().optional(),
-      runId: z30.string().optional(),
-      stripePaymentIntentId: z30.string().optional(),
-      stripeInvoiceId: z30.string().optional(),
-      stripeRefundId: z30.string().optional(),
-      createdAt: z30.date()
+      amount: z32.number(),
+      balanceAfter: z32.number(),
+      generationId: z32.string().optional(),
+      runId: z32.string().optional(),
+      stripePaymentIntentId: z32.string().optional(),
+      stripeInvoiceId: z32.string().optional(),
+      stripeRefundId: z32.string().optional(),
+      createdAt: z32.date()
     });
-    BillingStatusSchema = z30.object({
-      creditBalance: z30.number(),
-      subscriptionCreditBalance: z30.number(),
-      topupCreditBalance: z30.number(),
-      subscriptionStatus: z30.enum(["active", "canceled", "past_due", "unpaid", "trialing", "paused", "incomplete", "incomplete_expired"]).optional(),
-      currentPeriodEnd: z30.date().optional(),
-      cancelAtPeriodEnd: z30.boolean(),
-      gracePeriodEndsAt: z30.date().optional(),
-      autoTopUpEnabled: z30.boolean(),
-      autoTopUpThreshold: z30.number(),
-      transactions: z30.array(BillingTransactionSchema)
+    BillingStatusSchema = z32.object({
+      creditBalance: z32.number(),
+      subscriptionCreditBalance: z32.number(),
+      topupCreditBalance: z32.number(),
+      subscriptionStatus: z32.enum(["active", "canceled", "past_due", "unpaid", "trialing", "paused", "incomplete", "incomplete_expired"]).optional(),
+      currentPeriodEnd: z32.date().optional(),
+      cancelAtPeriodEnd: z32.boolean(),
+      gracePeriodEndsAt: z32.date().optional(),
+      autoTopUpEnabled: z32.boolean(),
+      autoTopUpThreshold: z32.number(),
+      transactions: z32.array(BillingTransactionSchema)
     });
-    CreateCheckoutInputSchema = z30.object({
-      type: z30.enum([BILLING_CHECKOUT_TYPES.SUBSCRIPTION, BILLING_CHECKOUT_TYPES.TOPUP])
+    CreateCheckoutInputSchema = z32.object({
+      type: z32.enum([BILLING_CHECKOUT_TYPES.SUBSCRIPTION, BILLING_CHECKOUT_TYPES.TOPUP])
     });
-    AutoTopUpInputSchema = z30.object({
-      enabled: z30.boolean(),
-      threshold: z30.number().int().min(0)
+    AutoTopUpInputSchema = z32.object({
+      enabled: z32.boolean(),
+      threshold: z32.number().int().min(0)
     });
-    RunCompletedSchema = z30.object({
-      generationId: z30.string()
+    RunCompletedSchema = z32.object({
+      generationId: z32.string()
     });
   }
 });
 
 // ../../packages/types/src/schemas/github.ts
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 var GitHubInstallationStatusSchema, GithubInstallationSchema;
 var init_github = __esm({
   "../../packages/types/src/schemas/github.ts"() {
     "use strict";
     init_esm_shims();
-    GitHubInstallationStatusSchema = z31.enum(["active", "suspended", "deleted"]);
-    GithubInstallationSchema = z31.object({
-      id: z31.string(),
-      installationId: z31.number(),
-      organizationId: z31.string(),
-      accountLogin: z31.string(),
-      accountId: z31.number(),
-      accountType: z31.string(),
+    GitHubInstallationStatusSchema = z33.enum(["active", "suspended", "deleted"]);
+    GithubInstallationSchema = z33.object({
+      id: z33.string(),
+      installationId: z33.number(),
+      organizationId: z33.string(),
+      accountLogin: z33.string(),
+      accountId: z33.number(),
+      accountType: z33.string(),
       status: GitHubInstallationStatusSchema,
-      createdAt: z31.date(),
-      updatedAt: z31.date()
+      createdAt: z33.date(),
+      updatedAt: z33.date()
     });
   }
 });
 
 // ../../packages/types/src/schemas/vercel.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 var VercelInstallationWireStatusSchema;
 var init_vercel = __esm({
   "../../packages/types/src/schemas/vercel.ts"() {
     "use strict";
     init_esm_shims();
-    VercelInstallationWireStatusSchema = z32.enum([
+    VercelInstallationWireStatusSchema = z34.enum([
       "ready",
       "pending",
       "onboarding",
@@ -4257,6 +4447,22 @@ var init_preview_url = __esm({
   }
 });
 
+// ../../packages/types/src/app-links.ts
+var init_app_links = __esm({
+  "../../packages/types/src/app-links.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/types/src/designated-run.ts
+var init_designated_run = __esm({
+  "../../packages/types/src/designated-run.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // ../../packages/types/src/constants/pipeline-labels.ts
 var init_pipeline_labels = __esm({
   "../../packages/types/src/constants/pipeline-labels.ts"() {
@@ -4302,6 +4508,8 @@ var init_src = __esm({
     init_vercel();
     init_sensitive_detection();
     init_preview_url();
+    init_app_links();
+    init_designated_run();
     init_constants();
     init_architecture();
     init_step_overlay_points();
@@ -4597,47 +4805,6 @@ var init_colors = __esm({
   }
 });
 
-// src/core/context.ts
-import { readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { join as join10 } from "path";
-async function loadContext(outputDir) {
-  try {
-    const raw = await readFile4(join10(outputDir, CONTEXT_FILE), "utf-8");
-    const parsed = JSON.parse(raw);
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-function formatContext(ctx) {
-  let output = `## Project Context (from the user)
-
-**What this project is:** ${ctx.description}
-
-**Why they want testing:** ${ctx.testingGoal}
-
-**Critical flows (user-declared - these MUST be covered):** ${ctx.criticalFlows}
-
-These are flows the user explicitly said cannot break. Treat them as authoritative: every one of them must be represented faithfully in your output - never drop or downplay them. Start with these, then expand to cover the rest of the application.`;
-  if (ctx.pages?.length) {
-    output += `
-
-## Discovered Pages (${ctx.pages.length} routes)
-
-`;
-    output += ctx.pages.map((p) => `- \`${p.route}\` - ${p.description} (\`${p.path}\`)`).join("\n");
-  }
-  return output;
-}
-var CONTEXT_FILE;
-var init_context = __esm({
-  "src/core/context.ts"() {
-    "use strict";
-    init_esm_shims();
-    CONTEXT_FILE = ".project-context.json";
-  }
-});
-
 // src/core/errors.ts
 import { APICallError, RetryError, LoadAPIKeyError, InvalidPromptError, NoSuchModelError } from "ai";
 function sleep(ms) {
@@ -5102,16 +5269,16 @@ var init_notify = __esm({
 });
 
 // src/core/project-map.ts
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { join as join13 } from "path";
-import { z as z34 } from "zod";
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { join as join12 } from "path";
+import { z as z36 } from "zod";
 async function saveProjectMap(outputDir, map) {
-  await writeFile5(join13(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
+  await writeFile4(join12(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
 }
 async function loadProjectMap(outputDir) {
-  const path3 = join13(outputDir, PROJECT_MAP_FILE);
+  const path3 = join12(outputDir, PROJECT_MAP_FILE);
   try {
-    const raw = await readFile6(path3, "utf-8");
+    const raw = await readFile5(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 });
@@ -5213,34 +5380,34 @@ var init_project_map = __esm({
     "use strict";
     init_esm_shims();
     init_debug();
-    FrontendEntry = z34.object({
-      path: z34.string().min(1).describe("Repo-relative path to the frontend app/directory (the UI surface)."),
-      framework: z34.string().describe("Detected UI framework/stack, or 'unknown' if not obvious (e.g. next, react, vue, svelte)."),
-      dependsOn: z34.array(z34.string()).describe(
+    FrontendEntry = z36.object({
+      path: z36.string().min(1).describe("Repo-relative path to the frontend app/directory (the UI surface)."),
+      framework: z36.string().describe("Detected UI framework/stack, or 'unknown' if not obvious (e.g. next, react, vue, svelte)."),
+      dependsOn: z36.array(z36.string()).describe(
         "Repo-relative paths (each matching a backend in this map) that THIS frontend needs in order to function - the API/service(s) it calls and the data layer(s) that own the records it renders. These are pre-selected when the user picks this frontend, so only list backends this frontend actually depends on. Empty if it needs none."
       ),
-      why: z34.string().min(1).describe("One line: the evidence that made you classify this as a frontend.")
-    });
-    BackendEntry = z34.object({
-      path: z34.string().min(1).describe("Repo-relative path to the backend/API/service or the package that owns the data layer."),
-      language: z34.string().describe("Primary language, or 'unknown' (e.g. typescript, python, go, rust)."),
-      framework: z34.string().describe("Web/service framework or ORM stack, or 'unknown' (e.g. express, hono, fastapi, rails)."),
-      dataLayer: z34.object({
-        kind: z34.string().describe("How models are defined (e.g. prisma, drizzle, sqlalchemy, typeorm, raw-sql, unknown)."),
-        schemaPath: z34.string().optional().describe("Repo-relative path to the schema/models definition, if found.")
+      why: z36.string().min(1).describe("One line: the evidence that made you classify this as a frontend.")
+    });
+    BackendEntry = z36.object({
+      path: z36.string().min(1).describe("Repo-relative path to the backend/API/service or the package that owns the data layer."),
+      language: z36.string().describe("Primary language, or 'unknown' (e.g. typescript, python, go, rust)."),
+      framework: z36.string().describe("Web/service framework or ORM stack, or 'unknown' (e.g. express, hono, fastapi, rails)."),
+      dataLayer: z36.object({
+        kind: z36.string().describe("How models are defined (e.g. prisma, drizzle, sqlalchemy, typeorm, raw-sql, unknown)."),
+        schemaPath: z36.string().optional().describe("Repo-relative path to the schema/models definition, if found.")
       }).optional().describe("Where this backend's database models live. Omit if this backend owns no data layer."),
-      why: z34.string().min(1).describe("One line: the evidence that made you classify this as a backend.")
+      why: z36.string().min(1).describe("One line: the evidence that made you classify this as a backend.")
     });
-    IgnoreEntry = z34.object({
-      path: z34.string().min(1).describe("Repo-relative path to a directory that is NOT relevant to testing this app."),
-      why: z34.string().min(1).describe("One line: why it is irrelevant (e.g. docs site, infra, tooling, examples, unrelated app).")
+    IgnoreEntry = z36.object({
+      path: z36.string().min(1).describe("Repo-relative path to a directory that is NOT relevant to testing this app."),
+      why: z36.string().min(1).describe("One line: why it is irrelevant (e.g. docs site, infra, tooling, examples, unrelated app).")
     });
-    ProjectMapSchema = z34.object({
-      frontends: z34.array(FrontendEntry).describe("The UI surface(s) whose pages/flows get tested. Usually 1; may be more."),
-      backends: z34.array(BackendEntry).describe(
+    ProjectMapSchema = z36.object({
+      frontends: z36.array(FrontendEntry).describe("The UI surface(s) whose pages/flows get tested. Usually 1; may be more."),
+      backends: z36.array(BackendEntry).describe(
         "The API/service(s) and data layer(s) that own the models we seed. May be 0 (frontend-only), 1, or many."
       ),
-      ignore: z34.array(IgnoreEntry).describe("Directories judged irrelevant to this app's tests, so later steps skip them.")
+      ignore: z36.array(IgnoreEntry).describe("Directories judged irrelevant to this app's tests, so later steps skip them.")
     });
     PROJECT_MAP_FILE = "project-map.json";
   }
@@ -5251,11 +5418,11 @@ var parse_entity_audit_exports = {};
 __export(parse_entity_audit_exports, {
   parseEntityNames: () => parseEntityNames
 });
-import { readFile as readFile8 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join14 } from "path";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile8(join15(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile7(join14(outputDir, "entity-audit.md"), "utf-8");
     const names = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^\s+-\s+name:\s+(.+)$/);
@@ -5290,7 +5457,7 @@ var init_count_generated_tests = __esm({
 });
 
 // src/core/display.ts
-import { join as join16 } from "path";
+import { join as join15 } from "path";
 function formatArgs(input, keys) {
   const parts = [];
   for (const key of keys) {
@@ -5382,7 +5549,7 @@ function logToStore(store, agentId, info, stats) {
       const folder = String(tc.input.folder ?? "");
       const filename = String(tc.input.filename ?? "");
       if (folder && filename) {
-        store.noteWrite(join16(TESTS_DIR, folder, normalizeTestFilename(filename)));
+        store.noteWrite(join15(TESTS_DIR, folder, normalizeTestFilename(filename)));
       }
     }
     if (tc.name === "bash") {
@@ -5620,10 +5787,8 @@ async function runAgent(config, prompt, extractResult) {
     });
     try {
       const messages = [{ role: "user", content: prompt }];
-      let generation = await agent.generate({
-        messages,
-        timeout: { stepMs: stepTimeout }
-      });
+      const callOptions = stepTimeout > 0 ? { timeout: { stepMs: stepTimeout } } : {};
+      let generation = await agent.generate({ messages, ...callOptions });
       let nudges = 0;
       while (extractResult() === void 0 && nudges < MAX_NUDGES) {
         nudges++;
@@ -5638,10 +5803,7 @@ async function runAgent(config, prompt, extractResult) {
         });
         messages.push(...generation.response.messages);
         messages.push({ role: "user", content: NUDGE_PROMPT });
-        generation = await agent.generate({
-          messages,
-          timeout: { stepMs: stepTimeout }
-        });
+        generation = await agent.generate({ messages, ...callOptions });
       }
       return extractResult();
     } catch (err) {
@@ -5688,15 +5850,15 @@ var init_agent = __esm({
     init_logs();
     init_model();
     MAX_RETRIES = 3;
-    STEP_TIMEOUT_MS = 12e4;
+    STEP_TIMEOUT_MS = 0;
     MAX_NUDGES = 2;
     NUDGE_PROMPT = "You stopped before completing the task. The task is only complete once the finish tool has been called and succeeded. If your last finish call returned an error, fix exactly what it reported. Otherwise, continue where you left off and call the finish tool when done.";
   }
 });
 
 // src/core/gitignore.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join17, relative as relative2 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join16, relative as relative2 } from "path";
 import { glob as glob2 } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -5716,10 +5878,10 @@ async function loadGitignorePatterns(projectRoot) {
   ];
   const matches = await glob2("**/.gitignore", { cwd: projectRoot, dot: true });
   for (const match of matches) {
-    const fullPath = join17(projectRoot, match);
+    const fullPath = join16(projectRoot, match);
     try {
-      const content = await readFile9(fullPath, "utf-8");
-      const prefix = relative2(projectRoot, join17(projectRoot, match, ".."));
+      const content = await readFile8(fullPath, "utf-8");
+      const prefix = relative2(projectRoot, join16(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -5782,7 +5944,7 @@ var init_exec_error = __esm({
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { tool } from "ai";
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 function validateCommand(command, allowed) {
   const trimmed = command.trim();
   if (trimmed.length === 0) return "Empty command";
@@ -5848,8 +6010,8 @@ var init_bash = __esm({
     DEFAULT_ALLOWED = /* @__PURE__ */ new Set(["git", "wc", "sort", "head", "tail", "cat", "ls", "find", "diff", "echo"]);
     TIMEOUT_MS = 3e4;
     MAX_OUTPUT_BYTES = 1024 * 512;
-    inputSchema = z35.object({
-      command: z35.string().describe("Shell command to execute")
+    inputSchema = z37.object({
+      command: z37.string().describe("Shell command to execute")
     });
   }
 });
@@ -5857,7 +6019,7 @@ var init_bash = __esm({
 // src/tools/glob.ts
 import { tool as tool2 } from "ai";
 import { glob as glob3 } from "glob";
-import { z as z36 } from "zod";
+import { z as z38 } from "zod";
 async function executeGlob(pattern, cwd, ignorePatterns = DEFAULT_IGNORE) {
   try {
     const matches = await glob3(pattern, {
@@ -5891,9 +6053,9 @@ var init_glob = __esm({
   "src/tools/glob.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema2 = z36.object({
-      pattern: z36.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
-      cwd: z36.string().optional().describe("Directory to search in. Defaults to working directory.")
+    inputSchema2 = z38.object({
+      pattern: z38.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
+      cwd: z38.string().optional().describe("Directory to search in. Defaults to working directory.")
     });
     DEFAULT_IGNORE = [
       "**/node_modules/**",
@@ -5911,7 +6073,7 @@ var init_glob = __esm({
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { tool as tool3 } from "ai";
-import { z as z37 } from "zod";
+import { z as z39 } from "zod";
 function buildGrepTool(workingDirectory) {
   return tool3({
     description: "Search file contents with ripgrep. Returns matching lines with file paths and line numbers.",
@@ -5955,10 +6117,10 @@ var init_grep = __esm({
     init_esm_shims();
     init_exec_error();
     execFileAsync3 = promisify3(execFile4);
-    inputSchema3 = z37.object({
-      pattern: z37.string().describe("Regex pattern to search for in file contents"),
-      glob: z37.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
-      path: z37.string().optional().describe("File or directory to search in")
+    inputSchema3 = z39.object({
+      pattern: z39.string().describe("Regex pattern to search for in file contents"),
+      glob: z39.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
+      path: z39.string().optional().describe("File or directory to search in")
     });
   }
 });
@@ -5966,10 +6128,10 @@ var init_grep = __esm({
 // src/tools/list-directory.ts
 import { readdir } from "fs/promises";
 import { stat } from "fs/promises";
-import { join as join18, relative as relative3 } from "path";
+import { join as join17, relative as relative3 } from "path";
 import { tool as tool4 } from "ai";
 import { minimatch } from "minimatch";
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 function buildMatcher(patterns) {
   const positive = patterns.filter((p) => !p.startsWith("!"));
   const negative = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
@@ -5991,7 +6153,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
   const withTypes = [];
   for (const name of rawEntries) {
     try {
-      const s = await stat(join18(dirPath, name));
+      const s = await stat(join17(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -6011,7 +6173,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join18(dirPath, entry.name),
+        join17(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -6049,10 +6211,10 @@ async function buildListDirectoryTool(workingDirectory) {
   const isIgnored = buildMatcher(patterns);
   return tool4({
     description: "List directory structure as a tree. Use this for an overview of the project layout. Start at the root (path='.') with depth 3, then increase depth or narrow path if needed. Do NOT call this on every subdirectory - use glob to find specific files instead. Returns cached result if the same path+depth was already requested.",
-    inputSchema: z38.object({
-      path: z38.string().default(".").describe("Directory path relative to project root. Defaults to root."),
-      depth: z38.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
-      gitignore: z38.boolean().describe(
+    inputSchema: z40.object({
+      path: z40.string().default(".").describe("Directory path relative to project root. Defaults to root."),
+      depth: z40.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
+      gitignore: z40.boolean().describe(
         "Whether to respect the gitignore or to ignore it. true will respect it. false will ignore it. Default true"
       ).default(true)
     }),
@@ -6064,7 +6226,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join18(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join17(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -6100,10 +6262,10 @@ var init_list_directory = __esm({
 });
 
 // src/tools/read-file.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { relative as relative4, resolve as resolve2 } from "path";
 import { tool as tool5 } from "ai";
-import { z as z39 } from "zod";
+import { z as z41 } from "zod";
 function resolveSandboxedPath(workingDirectory, filePath) {
   const absolutePath = resolve2(workingDirectory, filePath);
   const relativePath = relative4(workingDirectory, absolutePath);
@@ -6128,7 +6290,7 @@ async function executeReadFile(workingDirectory, filePath, offset, limit) {
   const resolved = resolveSandboxedPath(workingDirectory, filePath);
   if ("error" in resolved) return resolved;
   try {
-    const content = await readFile10(resolved.absolutePath, "utf-8");
+    const content = await readFile9(resolved.absolutePath, "utf-8");
     const sliced = sliceLines(content, offset ?? 0, limit ?? MAX_LINES);
     if (sliced.numbered.length > MAX_OUTPUT_BYTES2) {
       sliced.numbered = sliced.numbered.slice(0, MAX_OUTPUT_BYTES2) + `
@@ -6161,10 +6323,10 @@ var init_read_file = __esm({
     init_esm_shims();
     MAX_LINES = 2e3;
     MAX_OUTPUT_BYTES2 = 256 * 1024;
-    inputSchema4 = z39.object({
-      filePath: z39.string().describe("Path to the file (absolute or relative to working directory)"),
-      offset: z39.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
-      limit: z39.number().int().min(1).optional().describe("Maximum number of lines to read")
+    inputSchema4 = z41.object({
+      filePath: z41.string().describe("Path to the file (absolute or relative to working directory)"),
+      offset: z41.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
+      limit: z41.number().int().min(1).optional().describe("Maximum number of lines to read")
     });
   }
 });
@@ -6187,7 +6349,7 @@ var init_pick_string = __esm({
 
 // src/tools/subagent.ts
 import { ToolLoopAgent as ToolLoopAgent2, hasToolCall as hasToolCall2, stepCountIs as stepCountIs2, tool as tool6 } from "ai";
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 function buildSubagentTools(workingDirectory, onFileRead) {
   const baseReadFile = buildReadFileTool(workingDirectory);
   const readFile25 = onFileRead ? tool6({
@@ -6260,11 +6422,11 @@ var init_subagent = __esm({
     init_glob();
     init_grep();
     init_read_file();
-    inputSchema5 = z40.object({
-      instruction: z40.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
+    inputSchema5 = z42.object({
+      instruction: z42.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
     });
-    resultSchema = z40.object({
-      findings: z40.string().describe("Summary of what was found")
+    resultSchema = z42.object({
+      findings: z42.string().describe("Summary of what was found")
     });
     SYSTEM_PROMPT = `You are a code research assistant. You have tools to explore a codebase: bash (shell commands, mainly git), glob (find files), grep (search content), and read_file (read files).
 
@@ -6275,10 +6437,10 @@ Be thorough but focused - only investigate what's relevant to your instruction.`
 });
 
 // src/tools/write-file.ts
-import { writeFile as writeFile6, mkdir as mkdir2 } from "fs/promises";
+import { writeFile as writeFile5, mkdir as mkdir2 } from "fs/promises";
 import { dirname as dirname2, relative as relative5, resolve as resolve3 } from "path";
 import { tool as tool7 } from "ai";
-import { z as z41 } from "zod";
+import { z as z43 } from "zod";
 async function executeWriteFile(outputDirectory, filePath, content) {
   const cleaned = filePath.replace(/^autonoma\//, "");
   const absolutePath = resolve3(outputDirectory, cleaned);
@@ -6288,7 +6450,7 @@ async function executeWriteFile(outputDirectory, filePath, content) {
   }
   try {
     await mkdir2(dirname2(absolutePath), { recursive: true });
-    await writeFile6(absolutePath, content, "utf-8");
+    await writeFile5(absolutePath, content, "utf-8");
     return { path: relativePath, bytesWritten: content.length };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -6307,21 +6469,21 @@ var init_write_file = __esm({
   "src/tools/write-file.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema6 = z41.object({
-      filePath: z41.string().describe("Path to write (absolute or relative to output directory)"),
-      content: z41.string().describe("File content to write")
+    inputSchema6 = z43.object({
+      filePath: z43.string().describe("Path to write (absolute or relative to output directory)"),
+      content: z43.string().describe("File content to write")
     });
   }
 });
 
 // src/tools/ask-user.ts
 import { tool as tool8 } from "ai";
-import { z as z42 } from "zod";
+import { z as z44 } from "zod";
 function buildAskUserTool() {
   return tool8({
     description: "Ask the user a question ONLY when the answer is truly unknowable from the codebase. Valid reasons: untyped JSON/JSONB field schemas, business rules not in code, config values not in source. NEVER ask about: field names (read the schema), field types (read the ORM model), enum values (read the code), relationships (read foreign keys), numeric values (read the seed data or defaults). If you can find it by reading a file, DO NOT ask - read the file instead.",
-    inputSchema: z42.object({
-      question: z42.string().describe(
+    inputSchema: z44.object({
+      question: z44.string().describe(
         "A clear, plain-language question. State exactly what you need to know and why you can't find it in code. BAD: 'What are the decimal values for checking_balance?' - GOOD: 'Your Account model has a metadata JSON column with no type definition. What fields go inside it?'"
       )
     }),
@@ -6381,7 +6543,7 @@ var init_tools = __esm({
 
 // src/agents/00-project-mapper/coverage.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join18 } from "path";
 async function findUncoveredDirs(projectRoot, map) {
   const entries = [...map.frontends, ...map.backends, ...map.ignore].map(
     (e) => e.path.replace(/^\.\//, "").replace(/\/+$/, "")
@@ -6405,7 +6567,7 @@ async function findUncoveredDirs(projectRoot, map) {
       const childRel = rel === "" ? child.name : `${rel}/${child.name}`;
       if (underEntry(childRel)) continue;
       if (hasEntryWithin(childRel)) {
-        if (depth + 1 < MAX_DEPTH) await walk(join19(abs, child.name), childRel, depth + 1);
+        if (depth + 1 < MAX_DEPTH) await walk(join18(abs, child.name), childRel, depth + 1);
       } else {
         out.push(childRel);
       }
@@ -6432,7 +6594,7 @@ __export(project_mapper_exports, {
   runProjectMapper: () => runProjectMapper
 });
 import { tool as tool9 } from "ai";
-import { z as z43 } from "zod";
+import { z as z45 } from "zod";
 async function runProjectMapper(input) {
   const model = getModel(input.modelId);
   const { logger, onStepFinish } = buildDefaultStepLogger("project-map", MAX_STEPS);
@@ -6466,7 +6628,7 @@ First build the full inventory (workspace/package manifests + top-level director
         }),
         finish: tool9({
           description: "End this step. Call once set_project_map has recorded a complete map.",
-          inputSchema: z43.object({}),
+          inputSchema: z45.object({}),
           execute: () => {
             if (captured == null) {
               return { error: "Cannot finish: no map recorded - call set_project_map first." };
@@ -6510,7 +6672,7 @@ __export(pages_finder_exports, {
 import { existsSync } from "fs";
 import * as path2 from "path";
 import { tool as tool10 } from "ai";
-import { z as z44 } from "zod";
+import { z as z46 } from "zod";
 async function runPageFinder(input) {
   const model = getModel(input.modelId);
   const pageCollector = new PageCollector();
@@ -6545,12 +6707,12 @@ ${input.extraMessage}`;
         }),
         view_pages: tool10({
           description: "use this tool to view all the pages that you already added",
-          inputSchema: z44.object(),
+          inputSchema: z46.object(),
           execute: () => pageCollector.viewPages()
         }),
         finish: tool10({
           description: "End this step. Call once every page in the codebase has been added via add_page.",
-          inputSchema: z44.object({}),
+          inputSchema: z46.object({}),
           execute: () => {
             if (pageCollector.pages.size === 0) {
               return {
@@ -6577,10 +6739,10 @@ var init_pages_finder = __esm({
     init_agent();
     init_model();
     init_tools();
-    Page = z44.object({
-      route: z44.string().min(1),
-      path: z44.string().min(1),
-      description: z44.string().min(10)
+    Page = z46.object({
+      route: z46.string().min(1),
+      path: z46.string().min(1),
+      description: z46.string().min(10)
     });
     PageCollector = class {
       // the key is the path
@@ -6770,15 +6932,15 @@ var kb_generator_exports = {};
 __export(kb_generator_exports, {
   runKBGenerator: () => runKBGenerator
 });
-import { readFile as readFile11 } from "fs/promises";
-import { join as join20, resolve as resolve5 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join19, resolve as resolve5 } from "path";
 import { tool as tool11 } from "ai";
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 function buildRegisterPagesTool(tracker) {
   return tool11({
     description: "Register ALL page/route files discovered via glob. Call this ONCE after globbing for page files. The system will track which ones you've read and block finish until all are covered.",
-    inputSchema: z45.object({
-      pages: z45.array(z45.string()).describe("All page file paths found by glob")
+    inputSchema: z47.object({
+      pages: z47.array(z47.string()).describe("All page file paths found by glob")
     }),
     execute: async (input) => {
       tracker.register(input.pages);
@@ -6792,7 +6954,7 @@ function buildRegisterPagesTool(tracker) {
 function buildPageCoverageTool(tracker) {
   return tool11({
     description: "Check how many registered pages you've read vs how many remain.",
-    inputSchema: z45.object({}),
+    inputSchema: z47.object({}),
     execute: async () => tracker.coverage()
   });
 }
@@ -6803,9 +6965,9 @@ function requiredReads(total) {
 function buildFinishTool(tracker, onFinish) {
   return tool11({
     description: "Call when you have finished generating the knowledge base. BLOCKED until you have read enough of the registered routes (every route on a small app; a strong majority on a large one) - call page_coverage first to check how many remain.",
-    inputSchema: z45.object({
-      summary: z45.string().describe("Summary of what was generated"),
-      artifacts: z45.array(z45.string()).describe("List of files written")
+    inputSchema: z47.object({
+      summary: z47.string().describe("Summary of what was generated"),
+      artifacts: z47.array(z47.string()).describe("List of files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -6866,24 +7028,9 @@ async function runKBGenerator(input) {
     result = r;
   };
   const { logger, onStepFinish } = buildDefaultStepLogger("kb", 150);
-  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + formatRetryGuidance(input.retryGuidance);
-  const pages = input.projectContext?.pages;
+  const contextBlock = formatRetryGuidance(input.retryGuidance);
   const tracker = new PageTracker(input.projectRoot);
-  if (pages?.length) {
-    tracker.register(pages.map((p) => p.path));
-  }
-  const prompt = pages?.length ? `Analyze the codebase at the working directory and generate a complete knowledge base.
-${contextBlock}
-MANDATORY PROCESS:
-Pages have already been discovered (${pages.length} routes pre-registered). You do NOT need to glob for them.
-1. Use list_directory at root to understand the project structure
-2. Read EVERY registered page file with read_file - the system tracks this
-3. Write AUTONOMA.md progressively as you go (update it after each major area)
-4. Call page_coverage to verify you've read all pages
-5. Call finish - it will REJECT if you have not read enough of the registered routes
-
-Output files:
-1. AUTONOMA.md - with YAML frontmatter (app_name, app_description, core_flows, feature_count)` : `Analyze the codebase at the working directory and generate a complete knowledge base.
+  const prompt = `Analyze the codebase at the working directory and generate a complete knowledge base.
 ${contextBlock}
 MANDATORY PROCESS:
 1. Use list_directory at root to understand the project structure
@@ -6899,8 +7046,8 @@ Output files:
   const agentConfig = buildKbAgentConfig(tracker, model, input, onStepFinish, setResult);
   await runAgent(agentConfig, prompt, () => result);
   logger.summary();
-  const autonomaPath = join20(input.outputDir, "AUTONOMA.md");
-  const autonomaExists = await readFile11(autonomaPath, "utf-8").then(() => true).catch((err) => {
+  const autonomaPath = join19(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;
   });
@@ -6911,32 +7058,6 @@ Output files:
       summary: "Knowledge base generated."
     };
   }
-  const finalTracker = new PageTracker(input.projectRoot);
-  if (pages?.length) {
-    const paths = pages.map((p) => p.path);
-    finalTracker.register(paths);
-    for (const path3 of paths) finalTracker.markRead(path3);
-  }
-  const finalConfig = buildKbAgentConfig(finalTracker, model, input, onStepFinish, setResult);
-  const declaredCriticalFlows = input.projectContext?.criticalFlows?.trim();
-  if (result?.success && declaredCriticalFlows) {
-    const beforeSelfReview = result;
-    result = void 0;
-    const selfReviewPrompt = `Before this knowledge base is shown to the user, verify it honors the critical flows they explicitly declared.
-
-The user said these flows are critical and cannot break:
-"${declaredCriticalFlows}"
-
-Read your AUTONOMA.md output. For EACH critical flow the user named:
-- Confirm it appears as a feature in core_flows (map the user's wording to the matching feature).
-- Confirm that feature is marked core: true with a coreReason.
-
-If any declared critical flow is missing, mismatched, or left core: false, FIX AUTONOMA.md now - add the feature if it is genuinely absent, or flip core to true with a coreReason. Do not downgrade or drop anything the user declared critical.
-
-When AUTONOMA.md correctly reflects every declared critical flow, call finish.`;
-    await runAgent(finalConfig, selfReviewPrompt, () => result);
-    if (!result) result = beforeSelfReview;
-  }
   const reviewed = result;
   return reviewed ?? {
     success: false,
@@ -6950,7 +7071,6 @@ var init_kb_generator = __esm({
     "use strict";
     init_esm_shims();
     init_agent();
-    init_context();
     init_debug();
     init_model();
     init_pick_string();
@@ -7113,17 +7233,17 @@ var entity_audit_exports = {};
 __export(entity_audit_exports, {
   runEntityAudit: () => runEntityAudit
 });
-import { readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
-import { join as join21 } from "path";
+import { readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { join as join20 } from "path";
 import { tool as tool12 } from "ai";
 import { glob as glob4 } from "glob";
-import { z as z46 } from "zod";
+import { z as z48 } from "zod";
 function buildRegisterModelsTool(tracker) {
   return tool12({
     description: "Register ALL database models discovered via grep. Call this ONCE after grepping for model definitions. After registering, use next_model to process them one at a time.",
-    inputSchema: z46.object({
-      models: z46.array(z46.string()).describe("All model/table names found by grep"),
-      framework: z46.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
+    inputSchema: z48.object({
+      models: z48.array(z48.string()).describe("All model/table names found by grep"),
+      framework: z48.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
     }),
     execute: async (input) => {
       tracker.register(input.models);
@@ -7139,7 +7259,7 @@ function buildRegisterModelsTool(tracker) {
 function buildNextModelTool(tracker) {
   return tool12({
     description: "Get the next model to audit from the queue. If you called next_model before without calling mark_model_audited, the previous model is auto-skipped (marked as no creation path found). Returns done:true when all models are processed.",
-    inputSchema: z46.object({}),
+    inputSchema: z48.object({}),
     execute: async () => {
       const next = tracker.nextModel();
       if (!next) {
@@ -7159,17 +7279,17 @@ function buildNextModelTool(tracker) {
 function buildMarkModelAuditedTool(tracker) {
   return tool12({
     description: "Mark a model as audited after you have determined its creation paths. Call this for EACH model after reading its creation code and determining independently_created + created_by. Include creation_function (e.g. 'UserService.create'), side_effects (list of things the creation does beyond the model itself), and for each created_by entry include owner, via (function name), and why (one sentence explaining the relationship).",
-    inputSchema: z46.object({
-      model: z46.string().describe("Model name"),
-      independently_created: z46.boolean(),
-      creation_file: z46.string().optional().describe("File containing the creation function"),
-      creation_function: z46.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
-      side_effects: z46.array(z46.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
-      created_by: z46.array(
-        z46.object({
-          owner: z46.string().describe("Owner model name"),
-          via: z46.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
-          why: z46.string().optional().describe("One sentence explaining why this model is created as a side effect")
+    inputSchema: z48.object({
+      model: z48.string().describe("Model name"),
+      independently_created: z48.boolean(),
+      creation_file: z48.string().optional().describe("File containing the creation function"),
+      creation_function: z48.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
+      side_effects: z48.array(z48.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
+      created_by: z48.array(
+        z48.object({
+          owner: z48.string().describe("Owner model name"),
+          via: z48.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
+          why: z48.string().optional().describe("One sentence explaining why this model is created as a side effect")
         })
       ).describe("List of owner models that create this as a side effect, empty array if none")
     }),
@@ -7208,16 +7328,16 @@ function buildMarkModelAuditedTool(tracker) {
 function buildModelCoverageTool(tracker) {
   return tool12({
     description: "Check how many registered models you've audited vs how many remain.",
-    inputSchema: z46.object({}),
+    inputSchema: z48.object({}),
     execute: async () => tracker.coverage()
   });
 }
 function buildFinishTool2(tracker, onFinish) {
   return tool12({
     description: "Call when entity audit is complete. BLOCKED if there are unaudited models - call model_coverage first to check.",
-    inputSchema: z46.object({
-      summary: z46.string().describe("Summary of the audit"),
-      artifacts: z46.array(z46.string()).describe("Files written")
+    inputSchema: z48.object({
+      summary: z48.string().describe("Summary of the audit"),
+      artifacts: z48.array(z48.string()).describe("Files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -7245,7 +7365,7 @@ async function findPrismaSchema(projectRoot) {
   return candidates[0] ?? void 0;
 }
 async function extractPrismaModels(schemaPath) {
-  const content = await readFile12(schemaPath, "utf-8");
+  const content = await readFile11(schemaPath, "utf-8");
   return content.split("\n").filter((line) => line.startsWith("model ")).map((line) => line.split(/\s+/)[1]).filter((name) => name != null);
 }
 async function detectFrameworkAndModels(projectRoot) {
@@ -7272,7 +7392,7 @@ async function runEntityAudit(input) {
   const scopeBlock = input.scopeHint != null ? `
 ${input.scopeHint}
 ` : "";
-  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + scopeBlock + formatRetryGuidance(input.retryGuidance);
+  const contextBlock = scopeBlock + formatRetryGuidance(input.retryGuidance);
   const preRegBlock = preRegisteredCount > 0 ? `
 ## Pre-registered models (${preRegisteredCount} found via ${detection.framework} schema at ${detection.schemaFile})
 
@@ -7332,8 +7452,8 @@ ${formatException(err)}`);
   logger.summary();
   const writeCanonicalAudit = async () => {
     if (tracker.auditedModels.size === 0) return void 0;
-    const auditPath = join21(input.outputDir, "entity-audit.md");
-    await writeFile7(auditPath, tracker.generateAuditMarkdown(), "utf-8");
+    const auditPath = join20(input.outputDir, "entity-audit.md");
+    await writeFile6(auditPath, tracker.generateAuditMarkdown(), "utf-8");
     return auditPath;
   };
   const canonicalPath = await writeCanonicalAudit();
@@ -7347,9 +7467,9 @@ ${formatException(err)}`);
   }
   const reviewed = result;
   if (!reviewed) {
-    const auditPath = join21(input.outputDir, "entity-audit.md");
+    const auditPath = join20(input.outputDir, "entity-audit.md");
     try {
-      await readFile12(auditPath, "utf-8");
+      await readFile11(auditPath, "utf-8");
       return {
         success: true,
         artifacts: ["entity-audit.md"],
@@ -7371,7 +7491,6 @@ var init_entity_audit = __esm({
     "use strict";
     init_esm_shims();
     init_agent();
-    init_context();
     init_debug();
     init_errors();
     init_model();
@@ -7560,8 +7679,8 @@ on a unique constraint. Everything else stays concrete and static, and no other
 });
 
 // src/agents/03-scenario-recipe/scenario-table.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join21 } from "path";
 import matter2 from "gray-matter";
 function validateScenarioIsConcrete(content) {
   const errors = findUnknownRecipeTokens(content).map(
@@ -7596,22 +7715,22 @@ __export(scenario_recipe_exports, {
   feedbackToScenario: () => feedbackToScenario,
   runScenarioRecipe: () => runScenarioRecipe
 });
-import { readFile as readFile14 } from "fs/promises";
-import { join as join23 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join22 } from "path";
 import { tool as tool13 } from "ai";
-import { z as z47 } from "zod";
+import { z as z49 } from "zod";
 function buildFinishTool3(requiredEntities, outputDir, onFinish) {
   return tool13({
     description: "Call when scenario design is complete and scenarios.md is written. BLOCKED if any required entities are missing from the scenario.",
-    inputSchema: z47.object({
-      summary: z47.string().describe("Summary of the scenario"),
-      entityCount: z47.number().describe("Number of entity types in the scenario"),
-      artifacts: z47.array(z47.string()).describe("Files written")
+    inputSchema: z49.object({
+      summary: z49.string().describe("Summary of the scenario"),
+      entityCount: z49.number().describe("Number of entity types in the scenario"),
+      artifacts: z49.array(z49.string()).describe("Files written")
     }),
     execute: async (input) => {
       let content;
       try {
-        content = await readFile14(join23(outputDir, "scenarios.md"), "utf-8");
+        content = await readFile13(join22(outputDir, "scenarios.md"), "utf-8");
       } catch {
         return { error: "Cannot finish: scenarios.md not found. Write it first." };
       }
@@ -7649,7 +7768,7 @@ async function runScenarioRecipe(input) {
   const scopeBlock = input.scopeHint != null ? `
 ${input.scopeHint}
 ` : "";
-  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + scopeBlock + formatRetryGuidance(input.retryGuidance);
+  const contextBlock = scopeBlock + formatRetryGuidance(input.retryGuidance);
   const requiredEntities = await parseEntityNames(input.outputDir);
   const entityListBlock = requiredEntities.length > 0 ? `
 ## Required entities (${requiredEntities.length} total - ALL must appear in the scenario)
@@ -7690,9 +7809,9 @@ When done, call finish.`;
   logger.summary();
   const reviewed = result;
   if (!reviewed) {
-    const scenariosPath = join23(input.outputDir, "scenarios.md");
+    const scenariosPath = join22(input.outputDir, "scenarios.md");
     try {
-      await readFile14(scenariosPath, "utf-8");
+      await readFile13(scenariosPath, "utf-8");
       return {
         success: true,
         artifacts: ["scenarios.md"],
@@ -7740,7 +7859,6 @@ var init_scenario_recipe = __esm({
     init_esm_shims();
     init_src();
     init_agent();
-    init_context();
     init_debug();
     init_model();
     init_parse_entity_audit();
@@ -7752,12 +7870,12 @@ var init_scenario_recipe = __esm({
 });
 
 // src/agents/04-recipe-builder/entity-order.ts
-import { readFile as readFile15 } from "fs/promises";
-import { join as join24 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join23 } from "path";
 import matter3 from "gray-matter";
-import { z as z48 } from "zod";
+import { z as z50 } from "zod";
 async function parseEntityAudit(outputDir) {
-  const raw = await readFile15(join24(outputDir, "entity-audit.md"), "utf-8");
+  const raw = await readFile14(join23(outputDir, "entity-audit.md"), "utf-8");
   try {
     const parsed = frontmatterSchema.safeParse(matter3(raw).data);
     if (parsed.success && parsed.data.models.length > 0) {
@@ -7918,34 +8036,34 @@ var init_entity_order = __esm({
   "src/agents/04-recipe-builder/entity-order.ts"() {
     "use strict";
     init_esm_shims();
-    createdBySchema = z48.object({
-      owner: z48.string(),
-      via: z48.string().optional(),
-      why: z48.string().optional()
+    createdBySchema = z50.object({
+      owner: z50.string(),
+      via: z50.string().optional(),
+      why: z50.string().optional()
     });
-    auditedModelSchema = z48.object({
-      name: z48.string(),
-      independently_created: z48.coerce.boolean().default(false),
-      creation_file: z48.string().optional(),
-      creation_function: z48.string().optional(),
-      side_effects: z48.array(z48.string()).optional(),
+    auditedModelSchema = z50.object({
+      name: z50.string(),
+      independently_created: z50.coerce.boolean().default(false),
+      creation_file: z50.string().optional(),
+      creation_function: z50.string().optional(),
+      side_effects: z50.array(z50.string()).optional(),
       // Tolerate a stray `created_by:` with no entries (parsed as null by YAML).
-      created_by: z48.array(createdBySchema).nullish().transform((v) => v ?? [])
+      created_by: z50.array(createdBySchema).nullish().transform((v) => v ?? [])
     });
-    frontmatterSchema = z48.object({
-      models: z48.array(auditedModelSchema).nullish().transform((v) => v ?? [])
+    frontmatterSchema = z50.object({
+      models: z50.array(auditedModelSchema).nullish().transform((v) => v ?? [])
     });
   }
 });
 
 // src/agents/04-recipe-builder/completion.ts
-import { readFile as readFile16 } from "fs/promises";
-import { join as join25 } from "path";
-import { z as z49 } from "zod";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join24 } from "path";
+import { z as z51 } from "zod";
 async function readCompletion(outputDir) {
   let raw;
   try {
-    raw = await readFile16(join25(outputDir, COMPLETION_MARKER_FILE), "utf-8");
+    raw = await readFile15(join24(outputDir, COMPLETION_MARKER_FILE), "utf-8");
   } catch (err) {
     debugLog("No completion marker yet", { err });
     return false;
@@ -7971,7 +8089,7 @@ var init_completion = __esm({
     init_esm_shims();
     init_debug();
     COMPLETION_MARKER_FILE = ".sdk-integration-complete";
-    completionSchema = z49.object({ complete: z49.literal(true) });
+    completionSchema = z51.object({ complete: z51.literal(true) });
   }
 });
 
@@ -8160,8 +8278,8 @@ var init_launcher = __esm({
 });
 
 // src/agents/04-recipe-builder/integration-prompt.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import { join as join26 } from "path";
+import { writeFile as writeFile7 } from "fs/promises";
+import { join as join25 } from "path";
 function renderIntegrationPrompt(params) {
   const priorFailureSection = params.priorFailure != null ? `
 \u2550\u2550\u2550 A PRIOR SESSION DID NOT COMPLETE - READ THIS FIRST \u2550\u2550\u2550
@@ -8183,6 +8301,22 @@ Work without asking questions. Make reasonable, codebase-grounded decisions. Onl
 stop for missing secrets, credentials, or external services that genuinely cannot
 be mocked or run locally - and when you do, say exactly what you need and why.
 
+\u2550\u2550\u2550 BRANCH FIRST - BEFORE YOU CHANGE A SINGLE FILE \u2550\u2550\u2550
+Your work ships to the developer as a pull request, so cut the branch before your
+first edit - never commit onto the default branch. Do not assume it is called "main":
+read it from the remote (\`git symbolic-ref refs/remotes/origin/HEAD\`, or
+\`git remote show origin\`), then:
+    git fetch origin
+    git switch --create ${INTEGRATION_BRANCH} origin/<default-branch>
+Two cases to handle before you run that:
+  \u2022 The working tree already has uncommitted changes: they are the developer's, so do
+    NOT stash, discard, or commit them. Branch off the CURRENT HEAD instead, and keep
+    them out of your commit later.
+  \u2022 A branch from a prior session already exists (or you are already on one): stay on
+    it and continue there rather than cutting a second one.
+If this checkout is not a git repository at all, skip the branch and say so at the end -
+everything else in this prompt still applies.
+
 \u2550\u2550\u2550 DISCOVER FIRST (never assume) \u2550\u2550\u2550
 Before writing anything, investigate this specific app with your tools. Determine,
 from the actual source, every one of:
@@ -8314,8 +8448,8 @@ Before implementing, write a checklist file inside the app (e.g. IMPLEMENTATION.
 and keep it updated. It must enumerate, as explicit checkboxes: EVERY entity the
 entity audit says needs a factory (by name, copied from the audit), plus the
 endpoint, teardown, the auth callback, the maintenance note, the full-recipe pass,
-and the two-concurrent-instances proof. Check items off only when actually done and
-verified. The single most common failure is stopping with entities left uncovered.
+the two-concurrent-instances proof, and the pushed branch + opened pull request.
+Check items off only when actually done and verified. The single most common failure is stopping with entities left uncovered.
 
 \u2550\u2550\u2550 VALIDATE - ENTITY BY ENTITY, THEN THE WHOLE RECIPE \u2550\u2550\u2550
 You validate your own work by driving the endpoint through THIS CLI's signed client
@@ -8375,43 +8509,71 @@ concurrently because the app's own schema forces a global singleton, write that
 IMPLEMENTATION.md - name the table, the constraint, and why it cannot be made per-run -
 and then proceed. Never leave this step silently unfinished.
 
+\u2550\u2550\u2550 SHIP IT - COMMIT, PUSH, OPEN A PULL REQUEST \u2550\u2550\u2550
+Everything green means nothing until the developer can review it. Once the full recipe
+and the concurrency proof pass, put the work up as a pull request - do not leave it
+sitting uncommitted in the working tree:
+  1. Read \`git status\` and \`git diff\` and stage ONLY your integration: the endpoint,
+     the factories, the SDK dependency and its lockfile change, and the maintenance
+     note. Leave the developer's pre-existing uncommitted changes out of it, and NEVER
+     commit secrets, .env files, credentials, or local scratch output.
+  2. Commit in the style the repo already uses (read \`git log\`) - one commit is fine.
+  3. Push the branch and set its upstream:
+        git push --set-upstream origin ${INTEGRATION_BRANCH}
+  4. Open a pull request against the DEFAULT branch you cut from, using the repo's own
+     tooling if it is installed and authenticated (e.g. \`gh pr create --base <default>\`).
+     Describe what you added: the endpoint path, which entities got factories, how
+     teardown is scoped, and anything you documented as a limitation. If no PR tool is
+     available or authenticated, the push is still mandatory - then print the compare
+     URL the push prints back so the developer can open the PR in one click.
+  5. If pushing or opening the PR genuinely cannot be done (no remote, no write access,
+     no auth, not a git repo), leave the work COMMITTED on the branch and write which
+     step failed and why in IMPLEMENTATION.md. Committing is the one part you can always
+     do - never stop at an uncommitted working tree.
+
 \u2550\u2550\u2550 FINISH - THE LAST THING YOU DO \u2550\u2550\u2550
-Only after every entity, the full-recipe pass, and the two-concurrent-instances proof
-are green (or the blocking constraint is documented in IMPLEMENTATION.md), and
-${params.recipePath} holds the recipe you validated, write the completion marker so the
-CLI knows the session is done and can upload the recipe:
-    ${join26(params.outputDir, COMPLETION_MARKER_FILE)}
+Write the completion marker once ALL of these hold:
+  \u2022 every entity, the full-recipe pass, and the two-concurrent-instances proof are green
+    - or the blocking constraint is documented in IMPLEMENTATION.md
+  \u2022 ${params.recipePath} holds the recipe you validated
+  \u2022 your work is committed, and pushed with a pull request open - or the reason you could
+    not push / open one is documented in IMPLEMENTATION.md
+A step you documented as genuinely blocked NEVER justifies withholding the marker; a
+checklist item you simply have not finished always does. The marker is how the CLI knows
+the session is done and can upload the recipe:
+    ${join25(params.outputDir, COMPLETION_MARKER_FILE)}
 Its contents MUST be exactly:
     { "complete": true }
-Do NOT write this marker while any checklist item is unfinished. It is how control
-returns to the CLI - it is not optional. The planner watches for this marker and
-takes the terminal back shortly after it appears. After writing it, end with ONE
-short closing message telling the developer:
+Writing it is not optional: the planner watches for this marker and takes the terminal
+back shortly after it appears. After writing it, end with ONE short closing message that
+names the pull request you opened - or, if you couldn't open one, the branch you pushed,
+or the commit you left behind and what blocked the push - and then says:
     "The integration is done. The Autonoma planner takes this terminal back in a
     few seconds to continue the setup - or exit now to continue immediately."
 Nothing after that message - no further questions, summaries, or work.`;
 }
 async function writeIntegrationPrompt(params) {
-  const path3 = join26(params.outputDir, INTEGRATION_PROMPT_FILE);
-  await writeFile8(path3, renderIntegrationPrompt(params), "utf-8");
+  const path3 = join25(params.outputDir, INTEGRATION_PROMPT_FILE);
+  await writeFile7(path3, renderIntegrationPrompt(params), "utf-8");
   return path3;
 }
-var INTEGRATION_PROMPT_VERSION, INTEGRATION_PROMPT_FILE, DEFAULT_ENDPOINT_PATH;
+var INTEGRATION_PROMPT_VERSION, INTEGRATION_PROMPT_FILE, DEFAULT_ENDPOINT_PATH, INTEGRATION_BRANCH;
 var init_integration_prompt = __esm({
   "src/agents/04-recipe-builder/integration-prompt.ts"() {
     "use strict";
     init_esm_shims();
     init_src();
     init_completion();
-    INTEGRATION_PROMPT_VERSION = 7;
+    INTEGRATION_PROMPT_VERSION = 9;
     INTEGRATION_PROMPT_FILE = "integration-prompt.md";
     DEFAULT_ENDPOINT_PATH = "/api/autonoma";
+    INTEGRATION_BRANCH = "autonoma-integration";
   }
 });
 
 // src/agents/04-recipe-builder/state.ts
-import { readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
-import { join as join27 } from "path";
+import { readFile as readFile16, writeFile as writeFile8 } from "fs/promises";
+import { join as join26 } from "path";
 function initialRecipeState() {
   return {
     phase: "tech-detect",
@@ -8421,7 +8583,7 @@ function initialRecipeState() {
 }
 async function loadRecipeState(outputDir) {
   try {
-    const raw = await readFile17(join27(outputDir, STATE_FILE2), "utf-8");
+    const raw = await readFile16(join26(outputDir, STATE_FILE2), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -8429,7 +8591,7 @@ async function loadRecipeState(outputDir) {
   }
 }
 async function saveRecipeState(outputDir, state) {
-  await writeFile9(join27(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
+  await writeFile8(join26(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
 }
 var STATE_FILE2;
 var init_state2 = __esm({
@@ -8442,9 +8604,9 @@ var init_state2 = __esm({
 
 // src/agents/04-recipe-builder/phases/handoff.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join28 } from "path";
+import { join as join27 } from "path";
 async function runHandoffPhase(state, deps, outputDir) {
-  const recipePath = state.recipePath ?? join28(outputDir, RECIPE_FILE);
+  const recipePath = state.recipePath ?? join27(outputDir, RECIPE_FILE);
   state.recipePath = recipePath;
   const launcher = await selectLauncher(deps.launchers, state.agentId ?? deps.presetAgentId, deps.interactive);
   if (launcher == null) {
@@ -8471,7 +8633,7 @@ async function runHandoffPhase(state, deps, outputDir) {
   return { kind: "advance" };
 }
 async function runCompletionPhase(state, deps, outputDir) {
-  const recipePath = state.recipePath ?? join28(outputDir, RECIPE_FILE);
+  const recipePath = state.recipePath ?? join27(outputDir, RECIPE_FILE);
   while (true) {
     const [complete, read] = await Promise.all([readCompletion(outputDir), loadRecipe(outputDir)]);
     const uploadProblems = read.status === "ok" ? findRecipeUploadProblems(read.recipe) : [];
@@ -8504,7 +8666,7 @@ async function runCompletionPhase(state, deps, outputDir) {
 function handbackSummary(failure, outputDir) {
   return `${failure}
 
-Finish the integration (see the prompt at ${join28(outputDir, INTEGRATION_PROMPT_FILE)}), then re-run with --resume.`;
+Finish the integration (see the prompt at ${join27(outputDir, INTEGRATION_PROMPT_FILE)}), then re-run with --resume.`;
 }
 async function launchAgent(launcher, permissionMode, target) {
   const promptFile = await writeIntegrationPrompt({
@@ -8513,7 +8675,7 @@ async function launchAgent(launcher, permissionMode, target) {
     cliCommand: target.cliCommand,
     priorFailure: target.priorFailure
   });
-  await rm2(join28(target.outputDir, COMPLETION_MARKER_FILE), { force: true }).catch((err) => {
+  await rm2(join27(target.outputDir, COMPLETION_MARKER_FILE), { force: true }).catch((err) => {
     debugLog("Could not clear a stale completion marker", { err });
   });
   log.info(`Launching ${launcher.label}. It will implement the integration - watch and steer it as it works.`);
@@ -8522,7 +8684,7 @@ async function launchAgent(launcher, permissionMode, target) {
     await countdown({
       title: `Handing off to ${launcher.label}`,
       lines: [
-        `Your terminal is about to switch to ${launcher.label}. It will implement the Autonoma SDK integration inside your repo: install the SDK, wire the endpoint, and write a real factory for every entity in the audit, validating each one against your locally running app.`,
+        `Your terminal is about to switch to ${launcher.label}. It will implement the Autonoma SDK integration inside your repo: install the SDK, wire the endpoint, and write a real factory for every entity in the audit, validating each one against your locally running app. It works on its own branch and opens a pull request with the result.`,
         `This dashboard disappears while it works - that's expected. Watch and steer it like any ${launcher.label} session; this usually takes a while.`,
         `When it finishes and exits, you come straight back here and the planner continues where it left off: submitting the validated recipe, then generating your test suite.`
       ],
@@ -8687,465 +8849,37 @@ var init_recipe_builder = __esm({
   }
 });
 
-// src/agents/05-test-generator/restore-deleted-test.ts
-import { access, mkdir as mkdir3, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname4 } from "path";
-async function restoreDeletedTest(testPath, originalContent) {
-  try {
-    await access(testPath);
-    return false;
-  } catch (err) {
-    debugLog("Test absent after its fix pass - restoring the pre-review content", { testPath, err });
-  }
-  try {
-    await mkdir3(dirname4(testPath), { recursive: true });
-    await writeFile10(testPath, originalContent, "utf-8");
-    return true;
-  } catch (err) {
-    console.warn(`  [fix] Could not restore ${testPath}: ${err instanceof Error ? err.message : String(err)}`);
-    captureLog("error", "Failed to restore a reviewed test - it stays missing from the suite", {
-      source: "test-generator",
-      step: "review-fix",
-      path: testPath
-    });
-    return false;
-  }
+// src/agents/00b-feature-discovery/index.ts
+import { readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
+import { join as join28 } from "path";
+import { tool as tool14 } from "ai";
+import { z as z52 } from "zod";
+async function saveFeatures(outputDir, features) {
+  const obj = Object.fromEntries(features);
+  await writeFile9(join28(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
-var init_restore_deleted_test = __esm({
-  "src/agents/05-test-generator/restore-deleted-test.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_debug();
-    init_logs();
+async function loadFeatures(outputDir) {
+  try {
+    const raw = await readFile17(join28(outputDir, FEATURES_FILE), "utf-8");
+    const obj = JSON.parse(raw);
+    return new Map(Object.entries(obj));
+  } catch {
+    return void 0;
   }
-});
-
-// src/agents/05-test-generator/rubrics.ts
-import { z as z50 } from "zod";
-function reviewResultSchema(shape) {
-  return z50.object(shape);
 }
-var dimensionResultSchema, reviewResultRecordSchema, structuralIntentRubric, flowCompletenessRubric, uiTextRubric, dataAccuracyRubric, ALL_RUBRICS;
-var init_rubrics = __esm({
-  "src/agents/05-test-generator/rubrics.ts"() {
-    "use strict";
-    init_esm_shims();
-    dimensionResultSchema = z50.object({
-      pass: z50.boolean(),
-      evidence: z50.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
-      suggestion: z50.string().optional().describe("What the planner agent should fix, if failing")
-    });
-    reviewResultRecordSchema = z50.record(z50.string(), dimensionResultSchema);
-    structuralIntentRubric = {
-      name: "structural-intent",
-      maxSteps: 8,
-      dimensions: ["structuralValidity", "intentQuality", "missionAlignment"],
-      resultSchema: reviewResultSchema({
-        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?"
-        ),
-        intentQuality: dimensionResultSchema.describe(
-          "Is the intent a specific, falsifiable behavioral claim - not just 'verify X is visible'?"
-        ),
-        missionAlignment: dimensionResultSchema.describe(
-          "Does the test's intent + steps verify the feature's core purpose? Not just UI appearance."
-        )
-      }),
-      systemPrompt: `You are a structural reviewer for E2E test plans. Each test will be executed by a VISUAL agent that sees the screen like a human user - it cannot inspect code, network, URLs, or any non-visual state.
-
-Your job is to EVALUATE tests against a rubric, NOT to rewrite them. You have tools to read source code if needed.
-
-## Rubric dimensions
+async function runFeatureDiscovery(input) {
+  const model = getModel(input.modelId);
+  const collector = new FeatureCollector();
+  let result;
+  const { logger, onStepFinish } = buildDefaultStepLogger("feature-discovery", 300);
+  const pagesDescription = Array.from(input.pages.entries()).map(([path3, page]) => `- ${page.route} \u2192 ${path3}
+  ${page.description}`).join("\n");
+  const prompt = `Discover sub-features for all pages in this project.
 
-### 1. Structural validity
-- All step verbs must be one of: click, type, scroll, assert, hover, drag, read, refresh
-- assert: can ONLY verify what a human sees on screen (no URLs, network, console, localStorage)
-- No code selectors (data-testid, aria-label, CSS classes, HTML element types)
-- No login/authentication instructions - user is always already authenticated
-- No internal/meta steps like "(Internal: simulate X)" or "(Note: this assumes Y)"
-- No "or" in assertions - test data is deterministic
-- Assertions must reference specific visible text, not vague descriptions ("success indicator", "results are displayed")
+Project root: ${input.projectRoot}
 
-### 2. Intent quality
-Is the intent a specific, falsifiable behavioral claim?
-FAIL: "When a user clicks the clock icon, the Wait modal should open" (just UI mechanics)
-PASS: "Adding a 5-second wait step should insert a Wait action into the step list with the configured duration"
-
-### 3. Mission alignment
-Does the test's intent + steps actually verify the feature's core purpose?
-FAIL if the intent just describes UI appearance when the feature is about functionality.
-
-When done reviewing, call finish with your structured evaluation.`
-    };
-    flowCompletenessRubric = {
-      name: "flow-completeness",
-      maxSteps: 12,
-      dimensions: ["actionCompletion", "mutationVerification"],
-      resultSchema: reviewResultSchema({
-        actionCompletion: dimensionResultSchema.describe(
-          "Does the test complete a core action and reach an OUTCOME? Not just opening a modal or clicking a tab."
-        ),
-        mutationVerification: dimensionResultSchema.describe(
-          "Does the test verify its mutation at the source of truth - not just a toast or inline indicator?"
-        )
-      }),
-      systemPrompt: `You are a flow completeness reviewer for E2E test plans. Each test will be executed by a VISUAL agent that sees the screen like a human user.
-
-Your job is to EVALUATE whether the test completes a meaningful action and verifies the result properly. You have tools to read the project's source code to understand what the feature actually does.
-
-## Rubric dimensions
-
-### 1. Action completion
-Does the test complete a core action and reach an OUTCOME?
-FAIL if the last meaningful step is just opening a modal, clicking a tab, or viewing a page.
-PASS if the test creates, saves, deletes, configures, or otherwise produces a verifiable result.
-
-Read the source files to understand what the feature's complete workflow looks like. Does the test cover the full cycle?
-
-### 2. Mutation verification
-Does the test verify its mutation at the source of truth?
-FAIL if the test ends at the point of action - checking a toast, a modal closing, or an inline success indicator.
-PASS if the test navigates to where the mutation's effect should be visible and asserts it there.
-
-For example: after creating a record, does the test navigate back to the list and verify the record appears? After toggling a setting, does it refresh and verify the toggle persists?
-
-Read the source code to understand where the "source of truth" view is for each mutation.
-
-When done reviewing, call finish with your structured evaluation.`
-    };
-    uiTextRubric = {
-      name: "ui-text",
-      maxSteps: 20,
-      dimensions: ["uiTextAuthenticity"],
-      resultSchema: reviewResultSchema({
-        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."
-        )
-      }),
-      systemPrompt: `You are a UI text authenticity reviewer for E2E test plans. Your ONLY job is verifying that every piece of quoted text in the test steps matches what a human user would actually see on screen.
-
-You have tools to read source code. USE THEM AGGRESSIVELY. Do not guess - verify.
-
-## Your process for EVERY quoted string in the test:
-
-1. Grep for the exact string in the project source code
-2. Check WHERE it appears:
-   - If it appears as rendered text in the template/markup \u2192 PASS (it's real visible text)
-   - If it appears inside a translation/i18n function call \u2192 it's a TRANSLATION KEY, not visible text. FAIL.
-   - If it looks like a code identifier (camelCase, dot.notation, SCREAMING_CASE, PascalCase names) \u2192 FAIL
-3. If the string is a translation key, trace it to the actual rendered value:
-   - Find the translation/i18n file or dictionary
-   - Look up the key to find what text actually appears on screen
-   - Report both the key used and the correct visible text in your evidence
-
-## Common patterns to catch:
-- Translation keys used as labels: "aiBackoffice.tabPipeline" instead of "Pipeline"
-- Dot-notation config paths: "settings.general.title"
-- **Icon component names used as button descriptions**: if a quoted string in a test step refers to a button or clickable element, grep for that string in the source code. If it's imported as a component and renders an icon (SVG, image), it's a code identifier - NOT what the user sees. The test must describe the icon visually instead. To verify: find the icon's source file or infer from its name what it depicts, and check whether the test uses a visual description or the code name.
-- Enum values: "QUOTE_REQUEST_RECEIVED", "IN_REVIEW"
-- CSS class names or HTML attributes used as visible text
-
-## Important:
-- Check EVERY quoted string, not just suspicious ones
-- A string existing in source code is NOT enough - it must be the RENDERED text
-- When in doubt, read more files. You have 20 steps - use them all if needed.
-
-When done reviewing, call finish with your structured evaluation.`
-    };
-    dataAccuracyRubric = {
-      name: "data-accuracy",
-      maxSteps: 20,
-      dimensions: ["dataAccuracy"],
-      resultSchema: reviewResultSchema({
-        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 - NOT from other tests?"
-        )
-      }),
-      systemPrompt: `You are a data accuracy reviewer for E2E test plans. Your ONLY job is verifying that every UI element referenced in the test actually exists in the source code and behaves as the test expects.
-
-You have tools to read source code. USE THEM AGGRESSIVELY. Do not guess - verify.
-
-## Your process:
-
-### 1. Identify the page/component
-Read the test's starting page and find the corresponding source file. Read it.
-
-### 2. For each UI element referenced in the test:
-- **Buttons**: grep for the button label. Verify it exists as a rendered string (not just a variable name).
-- **Tab names**: find the tab component, read the tab definitions, verify the names match.
-- **Field labels**: find the form component, verify field labels match.
-- **Headings**: verify section/modal headings exist in the JSX.
-- **Toast messages**: find where toasts are triggered, verify the message text.
-- **Dropdown options**: find the select/dropdown component, verify the options.
-
-### 3. Check default states:
-- Toggle/switch default positions (is it on or off by default?)
-- Default selected tabs (which tab is active on load?)
-- Default form values (what are the initial values?)
-- Conditional rendering (does the element actually show given the default state?)
-
-### 4. Check preconditions and scenario data grounding:
-- Does the test assume data exists that might not be seeded? (e.g., "click on the first item" when the list might be empty)
-- CRITICAL: If the prompt includes scenario data, every data value the test references (entity names, folder names, app names, URLs, email addresses, etc.) MUST appear in that scenario data. If the test uses a value that only exists because another test created it, that is a FAIL - tests must be independent.
-- Cross-reference every specific name/value in the test steps against the scenario data provided.
-
-## Important:
-- READ the actual component source files - don't just grep for strings
-- Check conditional rendering - an element might exist in code but only show under certain conditions
-- Verify the FLOW makes sense - after a page refresh, what state resets?
-- Tests MUST be independent - they cannot depend on data created by other tests
-
-When done reviewing, call finish with your structured evaluation.`
-    };
-    ALL_RUBRICS = [
-      structuralIntentRubric,
-      flowCompletenessRubric,
-      uiTextRubric,
-      dataAccuracyRubric
-    ];
-  }
-});
-
-// src/agents/05-test-generator/review-pass.ts
-import { basename as basename3 } from "path";
-import "ai";
-import { tool as tool14 } from "ai";
-async function runReviewPass(testContent, testPath, rubric, projectRoot, model, scenarioData) {
-  let result;
-  const agentLabel = `review:${rubric.name}:${basename3(testPath)}`;
-  const { onStepFinish } = buildDefaultStepLogger(agentLabel, rubric.maxSteps);
-  const finishTool = tool14({
-    description: "Submit your structured review. Every dimension must have evidence from your investigation.",
-    inputSchema: rubric.resultSchema,
-    execute: async (input) => {
-      result = reviewResultRecordSchema.parse(input);
-    }
-  });
-  const agentConfig = {
-    id: agentLabel,
-    systemPrompt: rubric.systemPrompt,
-    model,
-    maxSteps: rubric.maxSteps,
-    stepTimeoutMs: REVIEW_STEP_TIMEOUT_MS,
-    maxRetries: REVIEW_MAX_RETRIES,
-    tools: (_heartbeat) => ({
-      read_file: buildReadFileTool(projectRoot),
-      grep: buildGrepTool(projectRoot),
-      glob: buildGlobTool(projectRoot),
-      bash: buildBashTool(projectRoot),
-      finish: finishTool
-    }),
-    onStepFinish
-  };
-  const scenarioContext = scenarioData && rubric.name === "data-accuracy" ? `
-## Scenario data (the ONLY test data that exists in the database)
-\`\`\`
-${scenarioData}
-\`\`\`
-
-IMPORTANT: Every piece of data the test references (names, titles, URLs, folder names, etc.) MUST exist in the scenario data above. If the test uses a value that doesn't appear in scenarios, it FAILS the dataAccuracy dimension.
-` : "";
-  const prompt = `Review this E2E test plan:
-
-## Test file: ${testPath}
-\`\`\`
-${testContent}
-\`\`\`
-${scenarioContext}
-Evaluate EVERY dimension in your rubric: ${rubric.dimensions.join(", ")}
-
-For each one:
-1. Investigate using your tools (read source files, grep for strings referenced in the test)
-2. Provide specific evidence of what you found
-3. Pass or fail with a clear reason
-
-When done, call finish with your structured evaluation.`;
-  await runAgent(agentConfig, prompt, () => result);
-  return result ?? void 0;
-}
-var REVIEW_STEP_TIMEOUT_MS, REVIEW_MAX_RETRIES;
-var init_review_pass = __esm({
-  "src/agents/05-test-generator/review-pass.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_agent();
-    init_tools();
-    init_rubrics();
-    REVIEW_STEP_TIMEOUT_MS = 3e5;
-    REVIEW_MAX_RETRIES = 1;
-  }
-});
-
-// src/agents/05-test-generator/review.ts
-import { readFile as readFile18 } from "fs/promises";
-import { join as join29, relative as relative7, basename as basename4 } from "path";
-import "ai";
-import { glob as glob5 } from "glob";
-async function reviewSingleTest(testContent, testPath, projectRoot, model, scenarioData) {
-  const passes = await Promise.all(
-    ALL_RUBRICS.map(
-      (rubric) => runReviewPass(testContent, testPath, rubric, projectRoot, model, scenarioData).catch((err) => {
-        console.warn(
-          `  [review] ${rubric.name} error on ${basename4(testPath)}: ${err instanceof Error ? err.message : String(err)}`
-        );
-        return void 0;
-      })
-    )
-  );
-  const merged = {};
-  for (let i = 0; i < ALL_RUBRICS.length; i++) {
-    const rubric = ALL_RUBRICS[i];
-    const passResult = passes[i];
-    for (const dim of rubric.dimensions) {
-      if (passResult && dim in passResult) {
-        merged[dim] = passResult[dim];
-      } else {
-        merged[dim] = { pass: true, evidence: "Rubric pass did not return result - fail-open" };
-      }
-    }
-  }
-  return merged;
-}
-async function runConsolidatedReview(outputDir, projectRoot, model, deadline) {
-  const testsDir = join29(outputDir, TESTS_DIR);
-  const logger = createStepLogger("review", 5);
-  let scenarioData;
-  try {
-    scenarioData = await readFile18(join29(outputDir, "scenarios.md"), "utf-8");
-  } catch {
-  }
-  const testFiles = await glob5(join29(testsDir, TEST_FILE_GLOB));
-  const tests = [];
-  for (const testPath of testFiles) {
-    if (!isTestFile(testPath)) continue;
-    if (testPath.includes("/_invalid/")) continue;
-    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,
-      relativePath: relative7(testsDir, testPath),
-      content,
-      flow: flowMatch?.[1]?.trim() ?? "unknown"
-    });
-  }
-  const totalAgents = tests.length * ALL_RUBRICS.length;
-  logger.log({
-    stepNumber: 1,
-    maxSteps: 2,
-    text: `Reviewing ${tests.length} tests \xD7 ${ALL_RUBRICS.length} rubrics = ${totalAgents} agents (${MAX_CONCURRENT_TESTS} tests concurrent)`,
-    toolCalls: [],
-    toolErrors: [],
-    writtenFiles: []
-  });
-  let passed = 0;
-  let failed = 0;
-  let ranOutOfTime = false;
-  const feedback = [];
-  for (let i = 0; i < tests.length; i += MAX_CONCURRENT_TESTS) {
-    if (Date.now() > deadline) {
-      ranOutOfTime = true;
-      const unreviewed = tests.length - i;
-      console.log(`  [review] Out of time - ${unreviewed} of ${tests.length} tests left unreviewed`);
-      captureLog("warn", `Review out of time - ${unreviewed} of ${tests.length} tests left unreviewed`, {
-        source: "review",
-        unreviewed,
-        total: tests.length
-      });
-      break;
-    }
-    const batch = tests.slice(i, i + MAX_CONCURRENT_TESTS);
-    const results = await Promise.all(
-      batch.map(async (test) => {
-        const result = await reviewSingleTest(
-          test.content,
-          test.relativePath,
-          projectRoot,
-          model,
-          scenarioData
-        );
-        return { test, result };
-      })
-    );
-    for (const { test, result } of results) {
-      const failedDimensions = [];
-      for (const [key, dim] of Object.entries(result)) {
-        if (!dim.pass) failedDimensions.push(key);
-      }
-      if (failedDimensions.length === 0) {
-        passed++;
-      } else {
-        failed++;
-        feedback.push({
-          testPath: test.path,
-          relativePath: test.relativePath,
-          content: test.content,
-          flow: test.flow,
-          passed: false,
-          dimensions: result,
-          failedDimensions
-        });
-      }
-    }
-    console.log(
-      `  [review] Progress: ${Math.min(i + MAX_CONCURRENT_TESTS, tests.length)}/${tests.length} reviewed, ${passed} passed, ${failed} failed`
-    );
-  }
-  logger.log({
-    stepNumber: 2,
-    maxSteps: 2,
-    text: `Review complete: ${passed} passed, ${failed} failed`,
-    toolCalls: [],
-    toolErrors: [],
-    writtenFiles: []
-  });
-  logger.summary();
-  return { passed, failed, feedback, ranOutOfTime };
-}
-var MAX_CONCURRENT_TESTS;
-var init_review = __esm({
-  "src/agents/05-test-generator/review.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_display();
-    init_logs();
-    init_test_files();
-    init_review_pass();
-    init_rubrics();
-    MAX_CONCURRENT_TESTS = 4;
-  }
-});
-
-// src/agents/00b-feature-discovery/index.ts
-import { readFile as readFile19, writeFile as writeFile11 } from "fs/promises";
-import { join as join30 } from "path";
-import { tool as tool15 } from "ai";
-import { z as z51 } from "zod";
-async function saveFeatures(outputDir, features) {
-  const obj = Object.fromEntries(features);
-  await writeFile11(join30(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
-}
-async function loadFeatures(outputDir) {
-  try {
-    const raw = await readFile19(join30(outputDir, FEATURES_FILE), "utf-8");
-    const obj = JSON.parse(raw);
-    return new Map(Object.entries(obj));
-  } catch {
-    return void 0;
-  }
-}
-async function runFeatureDiscovery(input) {
-  const model = getModel(input.modelId);
-  const collector = new FeatureCollector();
-  let result;
-  const { logger, onStepFinish } = buildDefaultStepLogger("feature-discovery", 300);
-  const pagesDescription = Array.from(input.pages.entries()).map(([path3, page]) => `- ${page.route} \u2192 ${path3}
-  ${page.description}`).join("\n");
-  const prompt = `Discover sub-features for all pages in this project.
-
-Project root: ${input.projectRoot}
-
-## Pages to analyze
-${pagesDescription}
+## Pages to analyze
+${pagesDescription}
 
 Process every page. Call add_feature for each sub-feature you discover. When done, call finish.`;
   const agentConfig = {
@@ -9157,10 +8891,10 @@ Process every page. Call add_feature for each sub-feature you discover. When don
       const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat);
       return {
         ...tools,
-        add_feature: tool15({
+        add_feature: tool14({
           description: "Add a discovered sub-feature",
           inputSchema: Feature.extend({
-            id: z51.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
+            id: z52.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
           }),
           execute: (featureInput) => {
             const { id, ...rest } = featureInput;
@@ -9172,19 +8906,19 @@ Process every page. Call add_feature for each sub-feature you discover. When don
             return `Feature "${id}" added (${collector.features.size} total)`;
           }
         }),
-        view_features: tool15({
+        view_features: tool14({
           description: "View all discovered features so far",
-          inputSchema: z51.object({}),
+          inputSchema: z52.object({}),
           execute: () => collector.viewFeatures()
         }),
-        view_pages: tool15({
+        view_pages: tool14({
           description: "View the pages list to know what to analyze",
-          inputSchema: z51.object({}),
+          inputSchema: z52.object({}),
           execute: () => pagesDescription
         }),
-        finish: tool15({
+        finish: tool14({
           description: "Signal that feature discovery is complete",
-          inputSchema: z51.object({ summary: z51.string() }),
+          inputSchema: z52.object({ summary: z52.string() }),
           execute: async (finishInput) => {
             result = {
               success: true,
@@ -9215,13 +8949,13 @@ var init_b_feature_discovery = __esm({
     init_model();
     init_tools();
     FEATURES_FILE = "features.json";
-    Feature = z51.object({
-      name: z51.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
-      type: z51.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
-      parentPagePath: z51.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
-      sourceFiles: z51.array(z51.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
-      interactiveElements: z51.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
-      description: z51.string().min(10).describe("What this sub-feature does")
+    Feature = z52.object({
+      name: z52.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
+      type: z52.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
+      parentPagePath: z52.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
+      sourceFiles: z52.array(z52.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
+      interactiveElements: z52.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
+      description: z52.string().min(10).describe("What this sub-feature does")
     });
     FeatureCollector = class {
       features = /* @__PURE__ */ new Map();
@@ -9304,21 +9038,21 @@ Use kebab-case IDs that indicate the parent page and feature type:
 });
 
 // src/agents/05-test-generator/graph.ts
-import { readFile as readFile20, writeFile as writeFile12 } from "fs/promises";
-import { join as join31 } from "path";
+import { readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
+import { join as join29 } from "path";
 function estimateExpectedTests(written, processed, totalNodes) {
   if (totalNodes <= 0) return written;
   const rate = written > 0 && processed >= LIVE_RATE_MIN_PROCESSED ? written / processed : TESTS_PER_NODE_PRIOR;
   return Math.max(written, Math.round(rate * totalNodes));
 }
 async function saveBfsState(outputDir, state) {
-  const path3 = join31(outputDir, state.stateFile);
-  await writeFile12(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
+  const path3 = join29(outputDir, state.stateFile);
+  await writeFile10(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
 }
 async function loadBfsState(outputDir) {
-  const path3 = join31(outputDir, BFS_STATE_FILE);
+  const path3 = join29(outputDir, BFS_STATE_FILE);
   try {
-    const raw = await readFile20(path3, "utf-8");
+    const raw = await readFile18(path3, "utf-8");
     return CoverageState.deserialize(JSON.parse(raw));
   } catch {
     return void 0;
@@ -9522,7 +9256,7 @@ If a node has no testable behavior (utility, redirect), call next_node to skip i
 - get_progress: Check how many nodes tested vs remaining
 
 ### Writing
-- write_test: Write a test file with validated frontmatter
+- write_test: Write one test. You give it the test's parts (title, intent, steps, ...); it renders and validates the file.
 - create_folder: Create a folder under qa-tests/
 
 ### Research
@@ -9531,6 +9265,17 @@ If a node has no testable behavior (utility, redirect), call next_node to skip i
 ### Completion
 - finish: Signal you're done with a coverage report
 
+## Two sources of truth - know which governs what (CRITICAL)
+
+You have exactly two authorities, and they never overlap:
+
+- **The application source code** governs STRUCTURE and BEHAVIOUR: what elements exist, their exact labels, default states, conditional rendering, and what each action does.
+- **The test data section of this prompt** governs DATA: every balance, name, email, count, status and date your assertions reference.
+
+Never take a data value from the application's source. Files named seed, fixture, factory, mock, demo or sample hold the app's own local development data - Autonoma does NOT run them, and the values in them will NOT be on screen. A test asserting a balance found in a seed file fails on every run.
+
+If the source and the test data disagree about a value, the test data wins. Always.
+
 ## Source code grounding (CRITICAL)
 
 Before writing tests for any node, READ the source files for that page using read_file or spawn_researcher. Your tests MUST only reference elements you found in the actual source code.
@@ -9548,14 +9293,14 @@ If you can't find an element in the source, don't assert it. Read more files or
 
 Each feature has a "mission" - the ONE thing it must do correctly. Your tests MUST verify the mission. Before writing tests for any node:
 
-1. Find the mission for this feature from the Feature Missions section below
+1. Read the \`mission\` field that next_node returned for this node. That is the mission. If it is absent, derive one from the core_flows in the Knowledge Base.
 2. Ask: "Does my planned test verify the mission, or just UI mechanics?"
 3. At least ONE test per feature must directly assert the mission outcome
-4. Core features (core: true) also have a coreReason explaining the blast radius of failure - allocate more depth to these
+4. next_node also returns \`interactiveElements\` - the number of interactive elements discovery counted on this node. Use it to size your test count (see "Test depth"), and treat a high count as a signal to explore harder.
 
 Example: If the mission is "Show correct execution counts and success rates for the selected time range":
 - BAD: assert: the "Executions" tab heading is visible (UI mechanics - proves nothing about data)
-- GOOD: assert: text "12" is visible in the executions count (verifies actual data from scenarios)
+- GOOD: assert: text "12" is visible in the executions count (verifies actual data from the test data)
 
 If you find yourself writing a test that only opens/closes UI elements without verifying the mission outcome, STOP and redesign the test.
 
@@ -9628,79 +9373,87 @@ Use NESTED folders to mirror the app hierarchy. Use create_folder with "/" separ
 
 Group related areas under parent folders.
 
-## Test file format
-
-Every test file must start with YAML frontmatter:
-
-\`\`\`yaml
----
-title: "Toggle recording stops active session"
-description: "Verify toggling recording OFF stops the session"
-intent: "When the recording toggle is ON (default), clicking it should stop recording and show a confirmation toast"
-criticality: critical
-scenario: standard
-flow: "User Settings"
-verification: "Refresh the Settings page, assert the recording toggle is in the OFF position"
----
-\`\`\`
-
-### Frontmatter rules
-- title: Short, descriptive test name
-- description: One sentence explaining what the test verifies
-- intent: A specific, falsifiable claim derived from the feature's MISSION - what the user does, what the feature produces, and why it matters. Focus on OUTCOMES, not UI mechanics.
-  GOOD: "Toggling recording from ON to OFF stops the active session and shows a confirmation toast"
-  BAD: "Click the recording toggle" (that's a step, not an intent)
-  BAD: "Verify the page displays correctly" (visibility check, not a behavior)
-  Derive from the mission: if the mission is "Generate valid config files", every test's intent must be about generating, previewing, or copying config - not about UI elements appearing.
-- criticality: One of: critical, high, mid, low
-- scenario: Which scenario this test uses (usually "standard")
-- flow: Which feature/flow this belongs to (must match a feature from AUTONOMA.md)
-- verification: (REQUIRED - write tool rejects without it) WHERE to navigate and WHAT to assert to prove the mutation worked. Every test performs a mutation - render-only tests should be folded into another test's flow. Must describe the source of truth, not a UI acknowledgment.
+## Writing a test
+
+You do NOT write markdown. Call write_test with the test's parts and the file is rendered
+for you - identically every time, so two tests that say the same thing look the same. The
+tool's schema rejects anything malformed, so read the field descriptions and answer them.
+
+The fields, and what makes each one good:
+
+- **title** - short and descriptive.
+- **description** - one sentence on what the test verifies.
+- **intent** - a specific, falsifiable claim derived from the node's MISSION: the expected
+  INITIAL STATE, the ACTION the user takes, the EXPECTED OUTCOME, and why it matters. Write
+  it before the steps - it is the north star the execution agent uses when the screen does
+  not match a step. If the steps conflict with the intent, fix the STEPS.
+  GOOD: "Toggling recording from ON to OFF stops the active session, and the setting persists across a refresh"
+  BAD: "Click the recording toggle" (a step, not an intent)
+  BAD: "Verify the page displays correctly" (a visibility check, not a behaviour)
+- **criticality** - critical, high, mid or low.
+- **scenario** - usually "standard".
+- **flow** - must match a flow from AUTONOMA.md.
+- **verification** - WHERE to navigate and WHAT to assert to prove the mutation worked. Name
+  the source of truth. A toast, a confirmation dialog or an inline success indicator is an
+  acknowledgment, not proof.
   GOOD: "Navigate to the test list, assert 'Login Flow' is visible in the table"
   GOOD: "Refresh the page, assert the toggle retained its OFF state"
-  BAD: "Assert toast 'Deleted' appears" (UI acknowledgment, not verification)
-
-### Test body format
-
-After frontmatter:
-
-**Setup**: Which page the user starts on. Describe the clicks to reach the page. Read the app's layout/navigation code to determine the correct path. Look for sidebar, tab navigation, and route definitions. NEVER invent navigation paths - if you can't find how to reach a page, use spawn_researcher to investigate.
-
-NEVER write "Login as..." or "Log in" in Setup. The user is ALWAYS already authenticated. Setup only describes WHERE the user is, not authentication.
-NEVER write tests that require navigating to invalid URLs, 404 pages, or error states.
-
-**Intent**: A specific, falsifiable claim derived from the feature's MISSION. States what the user does, what should happen, and WHY it matters. Write this BEFORE writing steps - it's the "north star" that the execution agent uses to adapt if steps don't match reality.
-
-The intent is NOT "what UI appears" - it's "what the feature DOES".
-
-Include in your intent:
-- The expected INITIAL STATE of relevant elements
-- The ACTION the user takes
-- The EXPECTED OUTCOME (what the feature produces, not what UI appears)
-- Why this matters to the user
-
-The intent is the source of truth. If your steps conflict with the intent, fix the STEPS.
-
-**Steps**: Numbered list using ONLY these actions (any other verb is INVALID):
+  BAD: "Assert toast 'Deleted' appears"
+- **setup** - which page the user starts on and how they got there. Read the app's
+  layout/navigation code for the real path; never invent one - use spawn_researcher if you
+  cannot find it. NEVER authentication: no "Login as...", "Log in", "Sign in", no typing
+  credentials to reach the page. Signing in happens outside the test. This holds even when
+  the test's own subject is the login screen: start on it, do not authenticate your way to
+  it. Never a route that 404s or errors.
+- **steps** - the action sequence. Each step is a verb, a description, and (for assert) a
+  location.
+- **verificationSteps** - the steps that navigate to the source of truth and assert the
+  mutation landed. This is what the \`verification\` field describes, as steps.
+- **expectedResult** - what is true when the test passes.
+- **notes** - OPTIONAL free text. Use it when something was genuinely unresolvable: a default
+  state you could not determine, an element you could not find in the source, an assumption
+  you had to make. It is recorded for a human and never written into the test file, so it
+  cannot affect execution. Prefer flagging an uncertainty here over guessing silently.
+
+### Step verbs
+
+Only these exist, and the schema rejects anything else:
 - click: Click a button, link, or element
 - type: Type text into an input field
 - scroll: Scroll to an element or position
-- assert: Verify something VISUALLY visible on screen - text, headings, buttons, labels, images. MUST include location context when the same text could appear in multiple places. Use visual landmarks: "in the side panel", "in the modal", "in the table header", "below the form", "in the toast notification". CANNOT assert URLs, network requests, console logs, cookies, localStorage, or any non-visual state.
+- assert: Verify something VISUALLY visible - text, headings, buttons, labels, images. CANNOT
+  assert URLs, network requests, console logs, cookies, localStorage, or any non-visual state.
 - hover: Hover over an element
 - drag: Drag an element
-- read: Read text from an element into a variable
 - refresh: Refresh the page
 
-BANNED actions (NEVER use these):
-- wait: - INVALID. Do not write "wait:" steps.
-- verify: - INVALID. Use "assert:" instead.
-- navigate: - INVALID. Put navigation in Setup, not in steps.
-- select: - INVALID. Use "click:" to select dropdown items.
-- check: - INVALID. Use "click:" to check checkboxes, "assert:" to verify state.
+There is no wait (do not simulate delays), no verify (use assert), no navigate (navigation
+belongs in setup), no select (click the trigger, then click the option), no check (click it),
+and no read - nothing can capture a value for a later step to compare against.
+
+Because nothing carries a value between steps, an assertion can never be RELATIVE to an
+earlier state. "the balance is $500 lower than before" is INVALID - nothing remembers
+"before". You know the starting value from the test data and what the action does, so assert
+the exact resulting value: description \`text "$11,950.50"\`, location \`in the Checking Account card\`.
+
+### The location field
 
-**Verification**: Steps that usually navigate AWAY from the action screen to the source of truth and assert the mutation's effect. This section implements what the frontmatter 'verification' field describes.
+Every click, type and assert step needs a **location** saying where on screen its target is -
+"in the modal", "in the toast notification", "on the Sony WH-1000XM5 product card", "in the
+dashboard header", "as a page heading". It is a separate field so it cannot be forgotten in
+prose. scroll and refresh act on the page, so they do not need one.
 
-**Expected Result**: What should be true when the test passes
+It matters as much for an action as for a check. \`click: the "Add Funds" button\` reads as
+unambiguous right up to the moment you notice the same label sits in the page header AND
+inside the modal that first click opened - and clicking the wrong one fails later, somewhere
+that looks unrelated.
+
+Write it by default. Omit it only when you have READ the page source and confirmed the string
+renders in exactly one place. Ask: "could this text plausibly appear anywhere else on this
+screen?" A label that is also a column header, a button text repeated per row ("Buy", "Edit",
+"Delete" in a list), a heading matching a nav item, a value in both a summary and a detail
+row - all need a location. The cost of an unnecessary one is nothing; the cost of a missing
+one is an assertion that matches the wrong element.
 
 ### Interaction requirements (CRITICAL)
 - Every test MUST include at least 2 meaningful interactions (click, type, drag). Tests that ONLY assert visibility of elements are REJECTED.
@@ -9717,169 +9470,841 @@ BAD PATTERN (open/close cycle - tests nothing):
 4. assert: "Import component" is no longer visible
 This only proves the modal opens and closes. It does NOT test importing a component.
 
-GOOD PATTERN (completing the action - tests the feature):
-1. click: the "Import component" button
-2. assert: "Import component" is visible in the modal header
-3. click: "Login Component" in the component list
-4. click: the "Import" button
-5. assert: "Login Component" is visible in the step list
+GOOD PATTERN (completing the action - tests the feature):
+1. click: the "Import component" button
+2. assert: "Import component" is visible in the modal header
+3. click: "Login Component" in the component list
+4. click: the "Import" button
+5. assert: "Login Component" is visible in the step list
+
+If your last assertion is about a modal being open, a heading being visible, or an element disappearing, you probably haven't tested anything. Ask: "What is the OUTCOME of this action?" Your test must prove the feature's MISSION is fulfilled.
+
+### Variation coverage
+When you find branching patterns in the source, decide whether each variant produces DIFFERENT BEHAVIOR (different code path, different UI, different output) or just passes different data through the SAME code path.
+
+The question to ask: "In the source code, is there a conditional that renders different components or runs different logic based on this variant?" If yes \u2192 separate tests. If no \u2192 one test is enough.
+
+Why this matters: tests that only vary in what string is passed through identical UI don't catch different bugs - they just inflate the test count.
+
+GOOD variations (code branches differently):
+- Different providers rendering different templates/forms per provider
+- Different platform types showing different upload/input components
+- Status states rendering different visual components per state
+
+BAD variations (same code path, different data):
+- Switching between different items that use the same component
+- Deleting different records through the same confirmation flow
+- Filtering by different values through the same dropdown
+
+### Default state awareness (CRITICAL)
+Read the source code to find default states for toggles, checkboxes, and dropdowns. BEFORE writing a step that interacts with a stateful element:
+- Check the source code for the element's initial value
+- If a toggle defaults to ON: clicking it turns it OFF (stops/disables)
+- ALWAYS state the expected state transition: "click: the 'Recording' toggle to switch it from ON to OFF" - not just "click: the 'Recording' toggle"
+- Assert the initial state BEFORE interacting
+
+### Test writing rules
+- Each test follows ONE deterministic path - no conditionals, no "e.g.", no "(mocked or ...)"
+- A step names ONE target, never a choice. "click the sign in or onboarding button" is invalid: those two controls go to different places, so nothing about the step is falsifiable - a run cannot say what it did, and a reader cannot say whether it was right. The same for an expectation: "assert the total or subtotal" passes either way and proves nothing. You have read the source and you have the test data, so say which one. For a button whose label you are unsure of, read the source again; for an icon button, describe the icon visually (see "Icon buttons").
+  This is about the target, not the word: text INSIDE quotes is the application's own wording, so \`assert: text "Invalid email or password"\` is correct and expected.
+- Assertions must specify EXACT text, element, or visual state - never "or similar", never "e.g."
+- 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 the test data when a flow needs real values, using its exact values
+- Do NOT write tests that verify the test infrastructure itself
+- Every step must be concrete and reproducible. "assert: text 'Deal Created' is visible in the toast notification" is GOOD as a STEP. "assert: success indicator appears" is BAD - it names no exact text and no location.
+
+### Visual-only rules (CRITICAL)
+Tests are executed by a VISUAL agent that sees the screen like a human. It can ONLY see what's rendered on screen.
+
+The agent CANNOT access:
+- URLs or the browser address bar
+- Network requests or API calls
+- Console logs or errors
+- localStorage, cookies, or session data
+- HTML source, DOM structure, or element attributes
+
+Therefore:
+- NEVER assert URLs: "assert: URL contains /creation" is INVALID. Instead assert visible page content.
+- NEVER assert network: "assert: API call was made" is INVALID
+- NEVER assert non-visual state: "assert: form state is valid" is INVALID
+- NEVER reference HTML elements: no "div", "span", "section", "input", "button" as element types
+- NEVER reference data attributes: no "data-testid", "data-cy", "data-test"
+- NEVER reference aria attributes: no "[aria-label]", "[role=dialog]"
+- NEVER reference CSS selectors: no "#id", ".class-name", "[attribute=value]"
+- NEVER use meta-steps: no "(Internal: ...)", "(Note: ...)", or parenthetical commentary
+- Instead, describe what the user SEES: button text, label text, placeholder text, heading text, visible icons, tab names
+
+### Test data references (CRITICAL)
+The "Test data" section of this prompt lists EXACTLY what Autonoma writes to the database before your tests run. Since WE control that data, assertions reference its exact values.
+- When a test needs to verify data is displayed, use the EXACT values from the test data (names, emails, titles, counts)
+- A value shown as \`<generated per run>\` differs every run - NEVER assert it literally. Assert a stable field on the same row instead.
+- Never take a data value from the app's own seed/fixture/mock files (see "Two sources of truth")
+- 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 - use it.
+- NEVER assume facts not stated in the scenario data.
+
+## Test generation ordering (for consistency)
+When generating tests for a node, follow this deterministic order:
+1. First: CRUD operations for the primary entity (Create, Read/View, Update, Delete)
+2. Second: State transitions (toggle, enable/disable, activate/deactivate)
+3. Third: Validation (required fields, invalid input, boundary values)
+4. Fourth: Navigation and linking (links to detail pages, breadcrumbs, back navigation)
+5. Fifth: Edge cases (empty states, maximum values, permission boundaries)
+
+## Test depth - proportional to complexity (ENFORCED)
+
+You determine feature complexity by READING THE SOURCE CODE, not by counting files. Before writing tests for a node:
+1. Read the page file and explore all related source files
+2. Count the interactive elements you find: forms, buttons, toggles, modals, tables, tabs
+3. Write tests proportional to what you found - more interactive elements = more tests
+
+A complex multi-step wizard with many forms needs 8-15 tests. A simple settings page with one toggle needs 2-3 tests. Use your judgment based on what you actually read in the source.
+
+## CRUD completeness (MANDATORY - zero tolerance)
+
+If the source code for a feature supports Create, Read, Edit, and Delete for ANY entity, you MUST write tests for ALL of them. Missing even ONE CRUD operation is a critical failure.
+
+**How to detect CRUD support:** Look for:
+- Create: "New", "Add", "Create" buttons; form submission handlers; modals with input fields
+- Read/View: Detail pages, list pages, tables, cards displaying entity data
+- Edit: "Edit", "Rename", "Update" buttons; pre-filled forms
+- Delete: "Delete", "Remove", "Trash" buttons; confirmation dialogs
+
+If you find yourself writing only 1-2 tests for a CRUD page, STOP. Re-read the source. Find ALL the entity operations. Write tests for each.
+
+## Outcome verification - STRUCTURALLY ENFORCED
+
+The write_test schema REJECTS any test without a \`verification\` field. This is not advisory - it is a hard gate.
+
+What does NOT count as verification (these are UI acknowledgments, not proof):
+- Toast messages
+- Confirmation dialogs
+- Inline success indicators
+- The action button changing state
+
+Verification destinations:
+- After CREATE \u2192 verify in list/table
+- After EDIT \u2192 verify changed field in detail/list view
+- After DELETE \u2192 verify absence in list, refresh, verify still absent
+- After TOGGLE \u2192 refresh, verify retained state
+
+## CRUD test templates (for any page with forms/CRUD):
+1. **Create**: fill all fields, submit, verify the item appears
+2. **Validation**: submit with empty required fields, verify error messages
+3. **Edit**: modify existing item, save, verify change reflected
+4. **Delete**: remove item, verify disappears, refresh, verify stays gone
+5. **Boundary**: extremely long strings, special characters
+
+**For pages with dropdowns/filters:**
+- You MUST click the dropdown trigger first, THEN click an option.
+
+**For elements revealed by hover:**
+- Include a hover step before clicking elements that only appear on hover.
+
+**After every action (create/edit/delete), verify the OUTCOME:**
+- BAD: click "Save" and move on
+- GOOD: click "Save" \u2192 assert the saved data appears in the list/detail view
+
+## Excluded routes
+- **Admin/backoffice pages**: routes under /admin/ are excluded from test generation. These require special auth, affect all users globally, and are not part of the standard user experience.
+- **Authentication itself** is never the subject of a test and never a step: signing the user in is handled outside the test (see Setup). If a queued node is a login/signup screen, test only what it does BESIDES authenticating - field validation, error messaging, navigation to password reset - and never a successful-login flow.
+
+## Test distribution guidelines
+- Core flows (from AUTONOMA.md where core: true): spend MOST of your time here. These features break \u2192 users leave.
+- Supporting flows: adequate coverage - happy path plus important variations.
+- Simple display/config pages: basic coverage.
+
+## Coverage dimensions
+
+You track THREE kinds of coverage:
+1. Route/file coverage: which routes explored, which source files visited
+2. Entity coverage: which entity types and variations (enum values, states) appear in tests
+3. Behavioral variant coverage: which code-branching variants have dedicated tests. If a switch/map dispatches to N different renderers, you should have tests for the most important variants.
+
+When you finish, all dimensions are reported so the user knows what's covered and what gaps remain.`;
+  }
+});
+
+// src/agents/05-test-generator/recipe-context.ts
+import { readFile as readFile19 } from "fs/promises";
+import { join as join30 } from "path";
+import { z as z53 } from "zod";
+async function loadRecipeContext(outputDir) {
+  let raw;
+  try {
+    raw = await readFile19(join30(outputDir, "recipe.json"), "utf-8");
+  } catch (err) {
+    debugLog("recipe.json not present; test generation falls back to scenarios.md alone", { err });
+    return "";
+  }
+  const parsed = recipeFileSchema.safeParse(JSON.parse(raw));
+  if (!parsed.success) {
+    debugLog("recipe.json did not match the expected shape; skipping it", { issues: parsed.error.issues });
+    return "";
+  }
+  const sections = parsed.data.recipes.map(renderRecipe);
+  if (sections.length === 0) return "";
+  return `
+## Test data (from recipe.json - THE source of truth)
+
+These are the exact rows Autonoma writes to the database before your tests run. Assert against
+these values, never against seed/fixture/mock data you find in the application's own source.
+
+A value shown as \`<generated per run>\` is templated and differs on every run - never assert it
+literally. Assert a stable neighbouring field instead.
+${sections.join("\n")}`;
+}
+function renderRecipe(recipe) {
+  const lines = [`
+### Scenario "${recipe.name}"`];
+  if (recipe.description != null) lines.push(`
+${recipe.description}`);
+  for (const [model, rows] of Object.entries(recipe.create ?? {})) {
+    lines.push(`
+**${model}** (${rows.length} row${rows.length === 1 ? "" : "s"})`);
+    for (const row of rows) {
+      const fields = Object.entries(row).filter(([key]) => !STRUCTURAL_KEYS.has(key)).map(([key, value]) => `${key}=${renderValue(value)}`);
+      if (fields.length === 0) continue;
+      const alias = row["_alias"];
+      const label = typeof alias === "string" ? `${alias}: ` : "";
+      lines.push(`- ${label}${fields.join(", ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderValue(value) {
+  if (typeof value === "string") {
+    return TEMPLATE_TOKEN.test(value) ? "<generated per run>" : JSON.stringify(value);
+  }
+  if (typeof value === "object" && value !== null && "_ref" in value) {
+    const ref = Reflect.get(value, "_ref");
+    return typeof ref === "string" ? `(the row aliased ${ref})` : JSON.stringify(value);
+  }
+  return JSON.stringify(value);
+}
+var STRUCTURAL_KEYS, TEMPLATE_TOKEN, recipeRowSchema, recipeFileSchema;
+var init_recipe_context = __esm({
+  "src/agents/05-test-generator/recipe-context.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debug();
+    STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["_alias", "_ref"]);
+    TEMPLATE_TOKEN = /\{\{\s*\w+\s*\}\}/;
+    recipeRowSchema = z53.record(z53.string(), z53.unknown());
+    recipeFileSchema = z53.object({
+      recipes: z53.array(
+        z53.object({
+          name: z53.string(),
+          description: z53.string().optional(),
+          create: z53.record(z53.string(), z53.array(recipeRowSchema)).optional()
+        })
+      )
+    });
+  }
+});
+
+// src/agents/05-test-generator/restore-deleted-test.ts
+import { access, mkdir as mkdir3, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+async function restoreDeletedTest(testPath, originalContent) {
+  try {
+    await access(testPath);
+    return false;
+  } catch (err) {
+    debugLog("Test absent after its fix pass - restoring the pre-review content", { testPath, err });
+  }
+  try {
+    await mkdir3(dirname4(testPath), { recursive: true });
+    await writeFile11(testPath, originalContent, "utf-8");
+    return true;
+  } catch (err) {
+    console.warn(`  [fix] Could not restore ${testPath}: ${err instanceof Error ? err.message : String(err)}`);
+    captureLog("error", "Failed to restore a reviewed test - it stays missing from the suite", {
+      source: "test-generator",
+      step: "review-fix",
+      path: testPath
+    });
+    return false;
+  }
+}
+var init_restore_deleted_test = __esm({
+  "src/agents/05-test-generator/restore-deleted-test.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debug();
+    init_logs();
+  }
+});
+
+// src/core/pool.ts
+async function runPool(items, { limit, shouldContinue }, work) {
+  const completed = [];
+  const failed = [];
+  const skipped = [];
+  const inFlight2 = /* @__PURE__ */ new Set();
+  let next = 0;
+  const dispatch = (item, index) => {
+    const promise = work(item, index).then((result) => {
+      completed.push({ item, index, result });
+    }).catch((error) => {
+      failed.push({ item, index, error });
+    }).finally(() => {
+      inFlight2.delete(promise);
+    });
+    inFlight2.add(promise);
+  };
+  const cap = Math.max(1, limit);
+  while (next < items.length) {
+    if (shouldContinue != null && !shouldContinue()) {
+      skipped.push(...items.slice(next));
+      break;
+    }
+    while (inFlight2.size < cap && next < items.length) {
+      dispatch(items[next], next);
+      next++;
+    }
+    if (inFlight2.size > 0) await Promise.race(inFlight2);
+  }
+  await Promise.all(inFlight2);
+  return { completed, failed, skipped };
+}
+var init_pool = __esm({
+  "src/core/pool.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/agents/05-test-generator/rubrics.ts
+import { z as z54 } from "zod";
+function reviewResultSchema(shape) {
+  return z54.object(shape);
+}
+var dimensionResultSchema, reviewResultRecordSchema, structuralIntentRubric, flowCompletenessRubric, uiTextRubric, dataAccuracyRubric, ALL_RUBRICS;
+var init_rubrics = __esm({
+  "src/agents/05-test-generator/rubrics.ts"() {
+    "use strict";
+    init_esm_shims();
+    dimensionResultSchema = z54.object({
+      pass: z54.boolean(),
+      evidence: z54.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
+      suggestion: z54.string().optional().describe("What the planner agent should fix, if failing")
+    });
+    reviewResultRecordSchema = z54.record(z54.string(), dimensionResultSchema);
+    structuralIntentRubric = {
+      name: "structural-intent",
+      maxSteps: 8,
+      dimensions: ["structuralValidity", "intentQuality", "missionAlignment"],
+      resultSchema: reviewResultSchema({
+        structuralValidity: dimensionResultSchema.describe(
+          'Are all step verbs valid (click/type/scroll/assert/hover/drag/refresh)? Are asserts visual-only (no URLs, network, console)? Does every assert name WHERE on screen it looks? No code selectors? No login steps? No "or" anywhere?'
+        ),
+        intentQuality: dimensionResultSchema.describe(
+          "Is the intent a specific, falsifiable behavioral claim - not just 'verify X is visible'?"
+        ),
+        missionAlignment: dimensionResultSchema.describe(
+          "Does the test's intent + steps verify the feature's core purpose? Not just UI appearance."
+        )
+      }),
+      systemPrompt: `You are a structural reviewer for E2E test plans. Each test will be executed by a VISUAL agent that sees the screen like a human user - it cannot inspect code, network, URLs, or any non-visual state.
+
+Your job is to EVALUATE tests against a rubric, NOT to rewrite them. You have tools to read source code if needed.
 
-If your last assertion is about a modal being open, a heading being visible, or an element disappearing, you probably haven't tested anything. Ask: "What is the OUTCOME of this action?" Your test must prove the feature's MISSION is fulfilled.
+## Rubric dimensions
 
-### Variation coverage
-When you find branching patterns in the source, decide whether each variant produces DIFFERENT BEHAVIOR (different code path, different UI, different output) or just passes different data through the SAME code path.
+### 1. Structural validity
+- All step verbs must be one of: click, type, scroll, assert, hover, drag, refresh
+- assert: can ONLY verify what a human sees on screen (no URLs, network, console, localStorage)
+- No code selectors (data-testid, aria-label, CSS classes, HTML element types)
+- The setup must not sign the user in - the run arrives authenticated, so "log in as X" or "after logging in" is a FAIL. Naming a login or sign-in PAGE as where the user starts is fine, and a test OF the login screen must be able to say so; judge what the sentence instructs, not whether it contains the word.
+- No internal/meta steps like "(Internal: simulate X)" or "(Note: this assumes Y)"
+- No step may offer a CHOICE of target: "click the sign in or onboarding button" names two controls that go to different places, and "assert the total or subtotal" passes either way, so neither is falsifiable. Judge the target, not the word - "or" inside a quoted string is the application's own message ("Invalid email or password") and is exactly what a test should assert.
+- Every click, type and assert names WHERE on screen its target is (in the modal, in the dashboard header, on the card, as a page heading, ...). A bare "click the Save button" or "assert text X is visible" fails unless that label provably appears exactly once on the screen at that point - the same label in a header and in the modal it opens is the common case
+- No assertion relative to an earlier state ("$500 less than before") - nothing remembers "before"
+- Assertions must reference specific visible text, not vague descriptions ("success indicator", "results are displayed")
 
-The question to ask: "In the source code, is there a conditional that renders different components or runs different logic based on this variant?" If yes \u2192 separate tests. If no \u2192 one test is enough.
+### 2. Intent quality
+Is the intent a specific, falsifiable behavioral claim?
+FAIL: "When a user clicks the clock icon, the Wait modal should open" (just UI mechanics)
+PASS: "Adding a 5-second wait step should insert a Wait action into the step list with the configured duration"
 
-Why this matters: tests that only vary in what string is passed through identical UI don't catch different bugs - they just inflate the test count.
+### 3. Mission alignment
+Does the test's intent + steps actually verify the feature's core purpose?
+FAIL if the intent just describes UI appearance when the feature is about functionality.
 
-GOOD variations (code branches differently):
-- Different providers rendering different templates/forms per provider
-- Different platform types showing different upload/input components
-- Status states rendering different visual components per state
+When done reviewing, call finish with your structured evaluation.`
+    };
+    flowCompletenessRubric = {
+      name: "flow-completeness",
+      maxSteps: 12,
+      dimensions: ["actionCompletion", "mutationVerification"],
+      resultSchema: reviewResultSchema({
+        actionCompletion: dimensionResultSchema.describe(
+          "Does the test complete a core action and reach an OUTCOME? Not just opening a modal or clicking a tab."
+        ),
+        mutationVerification: dimensionResultSchema.describe(
+          "Does the test verify its mutation at the source of truth - not just a toast or inline indicator?"
+        )
+      }),
+      systemPrompt: `You are a flow completeness reviewer for E2E test plans. Each test will be executed by a VISUAL agent that sees the screen like a human user.
 
-BAD variations (same code path, different data):
-- Switching between different items that use the same component
-- Deleting different records through the same confirmation flow
-- Filtering by different values through the same dropdown
+Your job is to EVALUATE whether the test completes a meaningful action and verifies the result properly. You have tools to read the project's source code to understand what the feature actually does.
 
-### Default state awareness (CRITICAL)
-Read the source code to find default states for toggles, checkboxes, and dropdowns. BEFORE writing a step that interacts with a stateful element:
-- Check the source code for the element's initial value
-- If a toggle defaults to ON: clicking it turns it OFF (stops/disables)
-- ALWAYS state the expected state transition: "click: the 'Recording' toggle to switch it from ON to OFF" - not just "click: the 'Recording' toggle"
-- Assert the initial state BEFORE interacting
+## Rubric dimensions
 
-### Assertion location context (CRITICAL)
-EVERY assertion MUST include location context - where on the page the element appears. Never write a bare "assert: text X is visible". Always specify: in the modal, in the sidebar, in the table, in the header, in the toast notification, in the dropdown, on the card, in the form, in the dialog, in the panel, as a page heading, as a button label, etc.
-- GOOD: assert: text "Run preview" is visible in the side panel
-- BAD: assert: text "Status" is visible (WHERE? column header? form label? sidebar?)
+### 1. Action completion
+Does the test complete a core action and reach an OUTCOME?
+FAIL if the last meaningful step is just opening a modal, clicking a tab, or viewing a page.
+PASS if the test creates, saves, deletes, configures, or otherwise produces a verifiable result.
 
-### Test writing rules
-- Each test follows ONE deterministic path - no conditionals, no "e.g.", no "(mocked or ...)"
-- "or" in click/type steps is OK for naming the same element (click: the "Edit" or "Pencil" icon) - these are visual synonyms
-- "or" in assert steps is NEVER OK - since scenarios define the exact data, you always know what to expect
-- Assertions must specify EXACT text, element, or visual state - never "or similar", never "e.g."
-- 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 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.
+Read the source files to understand what the feature's complete workflow looks like. Does the test cover the full cycle?
 
-### Visual-only rules (CRITICAL)
-Tests are executed by a VISUAL agent that sees the screen like a human. It can ONLY see what's rendered on screen.
+### 2. Mutation verification
+Does the test verify its mutation at the source of truth?
+FAIL if the test ends at the point of action - checking a toast, a modal closing, or an inline success indicator.
+PASS if the test navigates to where the mutation's effect should be visible and asserts it there.
 
-The agent CANNOT access:
-- URLs or the browser address bar
-- Network requests or API calls
-- Console logs or errors
-- localStorage, cookies, or session data
-- HTML source, DOM structure, or element attributes
+For example: after creating a record, does the test navigate back to the list and verify the record appears? After toggling a setting, does it refresh and verify the toggle persists?
 
-Therefore:
-- NEVER assert URLs: "assert: URL contains /creation" is INVALID. Instead assert visible page content.
-- NEVER assert network: "assert: API call was made" is INVALID
-- NEVER assert non-visual state: "assert: form state is valid" is INVALID
-- NEVER reference HTML elements: no "div", "span", "section", "input", "button" as element types
-- NEVER reference data attributes: no "data-testid", "data-cy", "data-test"
-- NEVER reference aria attributes: no "[aria-label]", "[role=dialog]"
-- NEVER reference CSS selectors: no "#id", ".class-name", "[attribute=value]"
-- NEVER use meta-steps: no "(Internal: ...)", "(Note: ...)", or parenthetical commentary
-- Instead, describe what the user SEES: button text, label text, placeholder text, heading text, visible icons, tab names
+Read the source code to understand where the "source of truth" view is for each mutation.
 
-### Scenario data references (CRITICAL)
-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
-- 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 - use it.
-- NEVER assume facts not stated in the scenario data.
+When done reviewing, call finish with your structured evaluation.`
+    };
+    uiTextRubric = {
+      name: "ui-text",
+      maxSteps: 20,
+      dimensions: ["uiTextAuthenticity"],
+      resultSchema: reviewResultSchema({
+        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."
+        )
+      }),
+      systemPrompt: `You are a UI text authenticity reviewer for E2E test plans. Your ONLY job is verifying that every piece of quoted text in the test steps matches what a human user would actually see on screen.
 
-## Test generation ordering (for consistency)
-When generating tests for a node, follow this deterministic order:
-1. First: CRUD operations for the primary entity (Create, Read/View, Update, Delete)
-2. Second: State transitions (toggle, enable/disable, activate/deactivate)
-3. Third: Validation (required fields, invalid input, boundary values)
-4. Fourth: Navigation and linking (links to detail pages, breadcrumbs, back navigation)
-5. Fifth: Edge cases (empty states, maximum values, permission boundaries)
+You have tools to read source code. USE THEM AGGRESSIVELY. Do not guess - verify.
 
-## Test depth - proportional to complexity (ENFORCED)
+## Your process for EVERY quoted string in the test:
 
-You determine feature complexity by READING THE SOURCE CODE, not by counting files. Before writing tests for a node:
-1. Read the page file and explore all related source files
-2. Count the interactive elements you find: forms, buttons, toggles, modals, tables, tabs
-3. Write tests proportional to what you found - more interactive elements = more tests
+1. Grep for the exact string in the project source code
+2. Check WHERE it appears:
+   - If it appears as rendered text in the template/markup \u2192 PASS (it's real visible text)
+   - If it appears inside a translation/i18n function call \u2192 it's a TRANSLATION KEY, not visible text. FAIL.
+   - If it looks like a code identifier (camelCase, dot.notation, SCREAMING_CASE, PascalCase names) \u2192 FAIL
+3. If the string is a translation key, trace it to the actual rendered value:
+   - Find the translation/i18n file or dictionary
+   - Look up the key to find what text actually appears on screen
+   - Report both the key used and the correct visible text in your evidence
 
-A complex multi-step wizard with many forms needs 8-15 tests. A simple settings page with one toggle needs 2-3 tests. Use your judgment based on what you actually read in the source.
+## Common patterns to catch:
+- Translation keys used as labels: "aiBackoffice.tabPipeline" instead of "Pipeline"
+- Dot-notation config paths: "settings.general.title"
+- **Icon component names used as button descriptions**: if a quoted string in a test step refers to a button or clickable element, grep for that string in the source code. If it's imported as a component and renders an icon (SVG, image), it's a code identifier - NOT what the user sees. The test must describe the icon visually instead. To verify: find the icon's source file or infer from its name what it depicts, and check whether the test uses a visual description or the code name.
+- Enum values: "QUOTE_REQUEST_RECEIVED", "IN_REVIEW"
+- CSS class names or HTML attributes used as visible text
 
-## CRUD completeness (MANDATORY - zero tolerance)
+## Important:
+- Check EVERY quoted string, not just suspicious ones
+- A string existing in source code is NOT enough - it must be the RENDERED text
+- When in doubt, read more files. You have 20 steps - use them all if needed.
 
-If the source code for a feature supports Create, Read, Edit, and Delete for ANY entity, you MUST write tests for ALL of them. Missing even ONE CRUD operation is a critical failure.
+When done reviewing, call finish with your structured evaluation.`
+    };
+    dataAccuracyRubric = {
+      name: "data-accuracy",
+      maxSteps: 20,
+      dimensions: ["dataAccuracy"],
+      resultSchema: reviewResultSchema({
+        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 provided test data - NOT from the app's own seed/fixture/mock files, and NOT from other tests?"
+        )
+      }),
+      systemPrompt: `You are a data accuracy reviewer for E2E test plans. Your ONLY job is verifying that every UI element referenced in the test actually exists in the source code and behaves as the test expects.
 
-**How to detect CRUD support:** Look for:
-- Create: "New", "Add", "Create" buttons; form submission handlers; modals with input fields
-- Read/View: Detail pages, list pages, tables, cards displaying entity data
-- Edit: "Edit", "Rename", "Update" buttons; pre-filled forms
-- Delete: "Delete", "Remove", "Trash" buttons; confirmation dialogs
+You have tools to read source code. USE THEM AGGRESSIVELY. Do not guess - verify.
 
-If you find yourself writing only 1-2 tests for a CRUD page, STOP. Re-read the source. Find ALL the entity operations. Write tests for each.
+## Your process:
 
-## Outcome verification - STRUCTURALLY ENFORCED
+### 1. Identify the page/component
+Read the test's starting page and find the corresponding source file. Read it.
 
-The write_test tool REJECTS any test without a \`verification\` frontmatter field. This is not advisory - it's a hard gate.
+### 2. For each UI element referenced in the test:
+- **Buttons**: grep for the button label. Verify it exists as a rendered string (not just a variable name).
+- **Tab names**: find the tab component, read the tab definitions, verify the names match.
+- **Field labels**: find the form component, verify field labels match.
+- **Headings**: verify section/modal headings exist in the JSX.
+- **Toast messages**: find where toasts are triggered, verify the message text.
+- **Dropdown options**: find the select/dropdown component, verify the options.
 
-What does NOT count as verification (these are UI acknowledgments, not proof):
-- Toast messages
-- Confirmation dialogs
-- Inline success indicators
-- The action button changing state
+### 3. Check default states:
+- Toggle/switch default positions (is it on or off by default?)
+- Default selected tabs (which tab is active on load?)
+- Default form values (what are the initial values?)
+- Conditional rendering (does the element actually show given the default state?)
 
-Verification destinations:
-- After CREATE \u2192 verify in list/table
-- After EDIT \u2192 verify changed field in detail/list view
-- After DELETE \u2192 verify absence in list, refresh, verify still absent
-- After TOGGLE \u2192 refresh, verify retained state
+### 4. Check preconditions and scenario data grounding:
+- Does the test assume data exists that might not be seeded? (e.g., "click on the first item" when the list might be empty)
+- CRITICAL: If the prompt includes test data, every data value the test references (entity names, folder names, app names, URLs, email addresses, etc.) MUST appear in that test data. If the test uses a value that only exists because another test created it, that is a FAIL - tests must be independent.
+- CRITICAL: a value that appears ONLY in the application's own seed/fixture/factory/mock/demo files is a FAIL, even though you found it in the source. Autonoma does not run those files; the provided test data is what will be on screen.
+- A value the test data marks as "<generated per run>" must never be asserted literally - that is a FAIL.
+- Cross-reference every specific name/value in the test steps against the test data provided.
 
-## CRUD test templates (for any page with forms/CRUD):
-1. **Create**: fill all fields, submit, verify the item appears
-2. **Validation**: submit with empty required fields, verify error messages
-3. **Edit**: modify existing item, save, verify change reflected
-4. **Delete**: remove item, verify disappears, refresh, verify stays gone
-5. **Boundary**: extremely long strings, special characters
+## Important:
+- READ the actual component source files - don't just grep for strings
+- Check conditional rendering - an element might exist in code but only show under certain conditions
+- Verify the FLOW makes sense - after a page refresh, what state resets?
+- Tests MUST be independent - they cannot depend on data created by other tests
 
-**For pages with dropdowns/filters:**
-- You MUST click the dropdown trigger first, THEN click an option.
+When done reviewing, call finish with your structured evaluation.`
+    };
+    ALL_RUBRICS = [
+      structuralIntentRubric,
+      flowCompletenessRubric,
+      uiTextRubric,
+      dataAccuracyRubric
+    ];
+  }
+});
 
-**For elements revealed by hover:**
-- Include a hover step before clicking elements that only appear on hover.
+// src/agents/05-test-generator/review-pass.ts
+import { basename as basename3 } from "path";
+import "ai";
+import { tool as tool15 } from "ai";
+async function runReviewPass(testContent, testPath, rubric, projectRoot, model, scenarioData) {
+  let result;
+  const agentLabel = `review:${rubric.name}:${basename3(testPath)}`;
+  const { onStepFinish } = buildDefaultStepLogger(agentLabel, rubric.maxSteps);
+  const finishTool = tool15({
+    description: "Submit your structured review. Every dimension must have evidence from your investigation.",
+    inputSchema: rubric.resultSchema,
+    execute: async (input) => {
+      result = reviewResultRecordSchema.parse(input);
+    }
+  });
+  const agentConfig = {
+    id: agentLabel,
+    systemPrompt: rubric.systemPrompt,
+    model,
+    maxSteps: rubric.maxSteps,
+    stepTimeoutMs: REVIEW_STEP_TIMEOUT_MS,
+    maxRetries: REVIEW_MAX_RETRIES,
+    tools: (_heartbeat) => ({
+      read_file: buildReadFileTool(projectRoot),
+      grep: buildGrepTool(projectRoot),
+      glob: buildGlobTool(projectRoot),
+      bash: buildBashTool(projectRoot),
+      finish: finishTool
+    }),
+    onStepFinish
+  };
+  const scenarioContext = scenarioData && rubric.name === "data-accuracy" ? `
+## Scenario data (the ONLY test data that exists in the database)
+\`\`\`
+${scenarioData}
+\`\`\`
 
-**After every action (create/edit/delete), verify the OUTCOME:**
-- BAD: click "Save" and move on
-- GOOD: click "Save" \u2192 assert the saved data appears in the list/detail view
+IMPORTANT: Every piece of data the test references (names, titles, URLs, folder names, etc.) MUST exist in the scenario data above. If the test uses a value that doesn't appear in scenarios, it FAILS the dataAccuracy dimension.
+` : "";
+  const prompt = `Review this E2E test plan:
 
-## Excluded routes
-- **Admin/backoffice pages**: routes under /admin/ are excluded from test generation. These require special auth, affect all users globally, and are not part of the standard user experience.
-- **Auth/login pages**: never test authentication flows - the user is always already logged in.
+## Test file: ${testPath}
+\`\`\`
+${testContent}
+\`\`\`
+${scenarioContext}
+Evaluate EVERY dimension in your rubric: ${rubric.dimensions.join(", ")}
 
-## Test distribution guidelines
-- Core flows (from AUTONOMA.md where core: true): spend MOST of your time here. These features break \u2192 users leave.
-- Supporting flows: adequate coverage - happy path plus important variations.
-- Simple display/config pages: basic coverage.
+For each one:
+1. Investigate using your tools (read source files, grep for strings referenced in the test)
+2. Provide specific evidence of what you found
+3. Pass or fail with a clear reason
 
-## Coverage dimensions
+When done, call finish with your structured evaluation.`;
+  await runAgent(agentConfig, prompt, () => result);
+  return result ?? void 0;
+}
+var REVIEW_STEP_TIMEOUT_MS, REVIEW_MAX_RETRIES;
+var init_review_pass = __esm({
+  "src/agents/05-test-generator/review-pass.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_agent();
+    init_tools();
+    init_rubrics();
+    REVIEW_STEP_TIMEOUT_MS = 3e5;
+    REVIEW_MAX_RETRIES = 1;
+  }
+});
 
-You track THREE kinds of coverage:
-1. Route/file coverage: which routes explored, which source files visited
-2. Entity coverage: which entity types and variations (enum values, states) appear in tests
-3. Behavioral variant coverage: which code-branching variants have dedicated tests. If a switch/map dispatches to N different renderers, you should have tests for the most important variants.
+// src/agents/05-test-generator/review.ts
+import { readFile as readFile20 } from "fs/promises";
+import { join as join31, relative as relative7, basename as basename4 } from "path";
+import "ai";
+import { glob as glob5 } from "glob";
+function mergeRubricResults(reported) {
+  const merged = {};
+  for (const rubric of ALL_RUBRICS) {
+    const result = reported.get(rubric.name);
+    for (const dim of rubric.dimensions) {
+      merged[dim] = result?.[dim] ?? {
+        pass: true,
+        evidence: "Rubric pass did not return result - fail-open"
+      };
+    }
+  }
+  return merged;
+}
+async function reviewOneTest({
+  projectRoot,
+  model,
+  test,
+  dataContract
+}) {
+  const reported = /* @__PURE__ */ new Map();
+  await Promise.all(
+    ALL_RUBRICS.map(async (rubric) => {
+      const result = await runReviewPass(
+        test.content,
+        test.relativePath,
+        rubric,
+        projectRoot,
+        model,
+        dataContract
+      ).catch((err) => {
+        console.warn(
+          `  [review] ${rubric.name} error on ${basename4(test.relativePath)}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return void 0;
+      });
+      reported.set(rubric.name, result ?? {});
+    })
+  );
+  const dimensions = mergeRubricResults(reported);
+  return {
+    relativePath: test.relativePath,
+    content: test.content,
+    dimensions,
+    failedDimensions: Object.entries(dimensions).filter(([, dim]) => !dim.pass).map(([key]) => key)
+  };
+}
+async function readDataContract(outputDir) {
+  const recipe = await loadRecipeContext(outputDir);
+  if (recipe !== "") return recipe;
+  try {
+    return await readFile20(join31(outputDir, "scenarios.md"), "utf-8");
+  } catch (err) {
+    debugLog("No data contract available for review", { err });
+    return void 0;
+  }
+}
+async function runConsolidatedReview(outputDir, projectRoot, model, deadline, settled = /* @__PURE__ */ new Set(), precomputed = []) {
+  const testsDir = join31(outputDir, TESTS_DIR);
+  const logger = createStepLogger("review", 5);
+  const scenarioData = await readDataContract(outputDir);
+  const testFiles = await glob5(join31(testsDir, TEST_FILE_GLOB));
+  const tests = [];
+  for (const testPath of testFiles) {
+    if (!isTestFile(testPath)) continue;
+    if (testPath.includes("/_invalid/")) continue;
+    const relativePath = relative7(testsDir, testPath);
+    if (settled.has(relativePath)) continue;
+    const content = await readFile20(testPath, "utf-8");
+    const flowMatch = content.match(/^---\n[\s\S]*?flow:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
+    tests.push({ path: testPath, relativePath, content, flow: flowMatch?.[1]?.trim() ?? "unknown" });
+  }
+  const reusable = /* @__PURE__ */ new Map();
+  for (const review of precomputed) {
+    const current = tests.find((test) => test.relativePath === review.relativePath);
+    if (current != null && current.content === review.content) reusable.set(review.relativePath, review);
+  }
+  const toReview = tests.filter((test) => !reusable.has(test.relativePath));
+  const jobs = toReview.flatMap((test) => ALL_RUBRICS.map((rubric) => ({ test, rubric })));
+  logger.log({
+    stepNumber: 1,
+    maxSteps: 2,
+    text: `Reviewing ${toReview.length} tests \xD7 ${ALL_RUBRICS.length} rubrics = ${jobs.length} agents (${REVIEW_CONCURRENCY} concurrent)` + (reusable.size > 0 ? `; ${reusable.size} already reviewed during generation` : ""),
+    toolCalls: [],
+    toolErrors: [],
+    writtenFiles: []
+  });
+  let passed = 0;
+  let failed = 0;
+  const feedback = [];
+  const passedPaths = [];
+  const byTest = /* @__PURE__ */ new Map();
+  let reviewed = 0;
+  const outcome = await runPool(
+    jobs,
+    { limit: REVIEW_CONCURRENCY, shouldContinue: () => Date.now() <= deadline },
+    (job) => runReviewPass(job.test.content, job.test.relativePath, job.rubric, projectRoot, model, scenarioData)
+  );
+  for (const { item, error } of outcome.failed) {
+    console.warn(
+      `  [review] ${item.rubric.name} error on ${basename4(item.test.path)}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const record = (relativePath, rubricName, result) => {
+    const slot = byTest.get(relativePath) ?? /* @__PURE__ */ new Map();
+    slot.set(rubricName, result);
+    byTest.set(relativePath, slot);
+  };
+  for (const { item, result } of outcome.completed) {
+    record(item.test.relativePath, item.rubric.name, result ?? {});
+  }
+  for (const { item } of outcome.failed) {
+    record(item.test.relativePath, item.rubric.name, {});
+  }
+  const skippedTests = new Set(outcome.skipped.map((job) => job.test.relativePath));
+  const ranOutOfTime = outcome.skipped.length > 0;
+  for (const test of tests) {
+    const alreadyReviewed = reusable.get(test.relativePath);
+    const reported = byTest.get(test.relativePath);
+    const complete = reported != null && reported.size === ALL_RUBRICS.length;
+    if (alreadyReviewed == null && (!complete || skippedTests.has(test.relativePath))) continue;
+    reviewed++;
+    const merged = alreadyReviewed?.dimensions ?? mergeRubricResults(reported ?? /* @__PURE__ */ new Map());
+    const failedDimensions = alreadyReviewed?.failedDimensions ?? Object.entries(merged).filter(([, dim]) => !dim.pass).map(([key]) => key);
+    if (failedDimensions.length === 0) {
+      passed++;
+      passedPaths.push(test.relativePath);
+    } else {
+      failed++;
+      feedback.push({
+        testPath: test.path,
+        relativePath: test.relativePath,
+        content: test.content,
+        flow: test.flow,
+        passed: false,
+        dimensions: merged,
+        failedDimensions
+      });
+    }
+  }
+  if (ranOutOfTime) {
+    const unreviewed = tests.length - reviewed;
+    console.log(`  [review] Out of time - ${unreviewed} of ${tests.length} tests left unreviewed`);
+    captureLog("warn", `Review out of time - ${unreviewed} of ${tests.length} tests left unreviewed`, {
+      source: "review",
+      unreviewed,
+      total: tests.length
+    });
+  }
+  logger.log({
+    stepNumber: 2,
+    maxSteps: 2,
+    text: `Review complete: ${passed} passed, ${failed} failed`,
+    toolCalls: [],
+    toolErrors: [],
+    writtenFiles: []
+  });
+  logger.summary();
+  return { passed, failed, feedback, ranOutOfTime, passedPaths };
+}
+var REVIEW_CONCURRENCY;
+var init_review = __esm({
+  "src/agents/05-test-generator/review.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debug();
+    init_display();
+    init_logs();
+    init_pool();
+    init_test_files();
+    init_recipe_context();
+    init_review_pass();
+    init_rubrics();
+    REVIEW_CONCURRENCY = 16;
+  }
+});
 
-When you finish, all dimensions are reported so the user knows what's covered and what gaps remain.`;
+// src/agents/05-test-generator/review-pipeline.ts
+var PIPELINE_CONCURRENCY, ReviewPipeline;
+var init_review_pipeline = __esm({
+  "src/agents/05-test-generator/review-pipeline.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logs();
+    init_review();
+    PIPELINE_CONCURRENCY = 4;
+    ReviewPipeline = class {
+      constructor(outputDir, projectRoot, model, deadline) {
+        this.outputDir = outputDir;
+        this.projectRoot = projectRoot;
+        this.model = model;
+        this.deadline = deadline;
+      }
+      inFlight = /* @__PURE__ */ new Set();
+      done = [];
+      queue = [];
+      seen = /* @__PURE__ */ new Set();
+      /** The contract is identical for every test, so it is read and rendered once. */
+      dataContract;
+      closed = false;
+      /**
+       * Hand a freshly written test over for review. Returns immediately - the
+       * generator must never block on a reviewer.
+       */
+      submit(test) {
+        if (this.closed || this.seen.has(test.relativePath)) return;
+        this.seen.add(test.relativePath);
+        this.queue.push(test);
+        this.pump();
+      }
+      pump() {
+        while (this.inFlight.size < PIPELINE_CONCURRENCY && this.queue.length > 0) {
+          if (Date.now() > this.deadline) {
+            this.queue.length = 0;
+            return;
+          }
+          const test = this.queue.shift();
+          this.dataContract ??= readDataContract(this.outputDir);
+          const promise = this.dataContract.then(
+            (dataContract) => reviewOneTest({ projectRoot: this.projectRoot, model: this.model, test, dataContract })
+          ).then((review) => {
+            this.done.push(review);
+          }).catch((err) => {
+            captureLog("warn", `Pipelined review failed; the test will be reviewed in the fix cycles`, {
+              source: "review-pipeline",
+              path: test.relativePath,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }).finally(() => {
+            this.inFlight.delete(promise);
+            this.pump();
+          });
+          this.inFlight.add(promise);
+        }
+      }
+      /**
+       * Stop accepting work and wait for what is running. Everything queued but not
+       * started is dropped - the cycles that follow will pick those tests up, and
+       * they are cheaper to review there than to hold generation open for.
+       */
+      async drain() {
+        this.closed = true;
+        this.queue.length = 0;
+        await Promise.all(this.inFlight);
+        return [...this.done];
+      }
+    };
   }
 });
 
 // src/agents/05-test-generator/validation.ts
 import matter4 from "gray-matter";
+function isValidVerb(verb) {
+  return VALID_VERBS.has(verb);
+}
+function isInteractionVerb(verb) {
+  return INTERACTION_VERBS.has(verb);
+}
+function requiresLocation(verb) {
+  return LOCATED_VERBS.has(verb);
+}
+function parseStepVerbs(content) {
+  return [...content.matchAll(STEP_LINE_PATTERN)].map((m) => m[1]);
+}
 function validateTestContent(content) {
   const errors = [];
   if (!/^---\n[\s\S]*?\n---/.test(content)) {
@@ -9899,17 +10324,13 @@ function validateTestContent(content) {
   if (!/\*\*Intent\*\*:/.test(content)) {
     errors.push("Missing **Intent**: section");
   }
-  const stepMatches = content.match(/^\d+\.\s+(click|type|scroll|assert|hover|drag|read|refresh):/gm) || [];
-  const interactions = stepMatches.filter((s) => /^\d+\.\s+(click|type|drag):/.test(s));
-  if (interactions.length < 2) {
-    errors.push(`Only ${interactions.length} interaction(s) (minimum 2)`);
+  const verbs = parseStepVerbs(content);
+  const interactions = verbs.filter(isInteractionVerb);
+  if (interactions.length < MIN_INTERACTIONS) {
+    errors.push(`Only ${interactions.length} interaction(s) (minimum ${MIN_INTERACTIONS})`);
   }
-  const allSteps = content.match(/^\d+\.\s+(\w+):/gm) || [];
-  for (const step of allSteps) {
-    const verbMatch = step.match(/^\d+\.\s+(\w+):/);
-    if (verbMatch && !VALID_VERBS.has(verbMatch[1])) {
-      errors.push(`Invalid verb: "${verbMatch[1]}"`);
-    }
+  for (const verb of verbs) {
+    if (!isValidVerb(verb)) errors.push(`Invalid verb: "${verb}"`);
   }
   const bodyStart = content.indexOf("---", 3);
   const body = bodyStart > -1 ? content.slice(bodyStart + 3) : content;
@@ -9919,90 +10340,136 @@ function validateTestContent(content) {
   }
   return { valid: errors.length === 0, errors };
 }
-var VALID_VERBS, CRITICALITY_LEVELS;
+var STEP_VERBS, VALID_VERBS, INTERACTION_VERBS, LOCATED_VERBS, STEP_LINE_PATTERN, MIN_INTERACTIONS, CRITICALITY_LEVELS;
 var init_validation = __esm({
   "src/agents/05-test-generator/validation.ts"() {
     "use strict";
     init_esm_shims();
-    VALID_VERBS = /* @__PURE__ */ new Set(["click", "type", "scroll", "assert", "hover", "drag", "read", "refresh"]);
+    STEP_VERBS = ["click", "type", "scroll", "assert", "hover", "drag", "refresh"];
+    VALID_VERBS = new Set(STEP_VERBS);
+    INTERACTION_VERBS = /* @__PURE__ */ new Set(["click", "type", "drag"]);
+    LOCATED_VERBS = /* @__PURE__ */ new Set(["assert", "click", "type"]);
+    STEP_LINE_PATTERN = /^\d+\.\s+(\w+):/gm;
+    MIN_INTERACTIONS = 2;
     CRITICALITY_LEVELS = ["critical", "high", "mid", "low"];
   }
 });
 
-// src/agents/05-test-generator/tools.ts
-import { mkdir as mkdir4, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname5, join as join32 } from "path";
-import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool16, ToolLoopAgent as ToolLoopAgent3 } from "ai";
-import matter5 from "gray-matter";
-import { z as z52 } 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' }
+// src/agents/05-test-generator/test-spec.ts
+import { z as z55 } from "zod";
+function hasPlaceholder(text2) {
+  if (text2 == null) return false;
+  return PLACEHOLDER_PATTERNS.some(({ pattern }) => pattern.test(text2));
+}
+function renderTestMarkdown(spec) {
+  const frontmatter = [
+    "---",
+    `title: ${JSON.stringify(spec.title)}`,
+    `description: ${JSON.stringify(spec.description)}`,
+    `intent: ${JSON.stringify(spec.intent)}`,
+    `criticality: ${spec.criticality}`,
+    `scenario: ${spec.scenario}`,
+    `flow: ${JSON.stringify(spec.flow)}`,
+    `verification: ${JSON.stringify(spec.verification)}`,
+    "---"
+  ].join("\n");
+  const sections = [
+    frontmatter,
+    `**Setup**: ${spec.setup}`,
+    `**Intent**: ${spec.intent}`,
+    `**Steps**:
+${renderSteps(spec.steps)}`
   ];
-  for (const { pattern, name } of placeholderPatterns) {
-    const matches = stepsSection.match(pattern);
-    if (matches && matches.length > 0) {
-      return { name, match: matches[0] };
-    }
+  if (spec.verificationSteps.length > 0) {
+    sections.push(`**Verification**:
+${renderSteps(spec.verificationSteps)}`);
   }
-  return void 0;
+  sections.push(`**Expected Result**: ${spec.expectedResult}`);
+  return `${sections.join("\n\n")}
+`;
 }
-function buildWriteTestTool(state, outputDir) {
+function renderSteps(steps) {
+  return steps.map((step, index) => {
+    const location = step.location?.trim();
+    const text2 = location != null && location !== "" ? `${step.description} ${location}` : step.description;
+    return `${index + 1}. ${step.verb}: ${text2}`;
+  }).join("\n");
+}
+var PLACEHOLDER_PATTERNS, stepSchema, testSpecSchema;
+var init_test_spec = __esm({
+  "src/agents/05-test-generator/test-spec.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_validation();
+    PLACEHOLDER_PATTERNS = [
+      { pattern: /Dynamic:\s/i, name: '"Dynamic:" placeholder' },
+      { pattern: /\{\{[a-zA-Z0-9_]+\}\}/, name: "{{token}} placeholder" },
+      { pattern: /(?<!\{)\{[a-z][a-zA-Z]*\}(?!\})/, name: "bare {variable}" },
+      { pattern: /\be\.g\./i, name: '"e.g." example' }
+    ];
+    stepSchema = z55.object({
+      verb: z55.enum(STEP_VERBS).describe("The action. Only these verbs exist."),
+      description: z55.string().min(1).describe(
+        `What to do or check, naming the exact visible text. For assert, the thing expected on screen - e.g. 'text "Transfer Successful"'.`
+      ),
+      location: z55.string().optional().describe(
+        'WHERE on screen the target is - "in the modal", "in the toast notification", "on the Sony WH-1000XM5 product card", "in the dashboard header", "as a page heading". REQUIRED for click, type and assert: the same label routinely appears more than once (a header button and the modal button it opens, "Buy" on every card in a list), and acting on the wrong one fails confusingly. Not needed for scroll or refresh, which act on the page.'
+      )
+    }).refine((step) => !requiresLocation(step.verb) || (step.location?.trim() ?? "") !== "", {
+      message: 'This verb requires a "location" - say WHERE on screen its target is. The same label often appears more than once (a header button and the modal button it opens), so naming the element is not enough on its own.',
+      path: ["location"]
+    }).refine((step) => !hasPlaceholder(step.description) && !hasPlaceholder(step.location), {
+      message: "steps carry no variables - use the exact value from the test data, not a placeholder or example",
+      path: ["description"]
+    });
+    testSpecSchema = z55.object({
+      title: z55.string().min(1).describe("Short, descriptive test name."),
+      description: z55.string().min(1).describe("One sentence explaining what the test verifies."),
+      intent: z55.string().min(30).describe(
+        "A specific, falsifiable claim derived from the node's mission: what the user does, what the feature produces, why it matters. Not the steps, not 'the page displays correctly'."
+      ),
+      criticality: z55.enum(CRITICALITY_LEVELS),
+      scenario: z55.string().min(1).describe('Which scenario this test uses (usually "standard").'),
+      flow: z55.string().min(1).describe("Which feature/flow this belongs to (must match a flow from AUTONOMA.md)."),
+      verification: z55.string().min(20).describe(
+        "WHERE to navigate and WHAT to assert to prove the mutation worked. Must name the source of truth - a toast, a confirmation dialog or an inline success indicator is an acknowledgment, not proof."
+      ),
+      setup: z55.string().min(1).describe(
+        "Which page the user starts on and how they got there. Never authentication - the user is already signed in."
+      ),
+      steps: z55.array(stepSchema).min(1).describe("The action sequence, in order."),
+      verificationSteps: z55.array(stepSchema).describe(
+        "Steps that navigate to the source of truth and assert the mutation landed. Implements the `verification` field above."
+      ),
+      expectedResult: z55.string().min(1).describe("What should be true when the test passes."),
+      notes: z55.string().optional().describe(
+        "Optional free text for anything you could not resolve or want to flag - an ambiguous default state, a element you could not find in the source, an assumption you had to make. Recorded for humans and NEVER written into the test file, so it will not affect execution. Use it instead of guessing silently."
+      )
+    }).refine((spec) => spec.steps.filter((step) => isInteractionVerb(step.verb)).length >= MIN_INTERACTIONS, {
+      message: `A test needs at least ${MIN_INTERACTIONS} real interactions (click/type/drag) - a visibility-only test verifies nothing`,
+      path: ["steps"]
+    });
+  }
+});
+
+// src/agents/05-test-generator/tools.ts
+import { mkdir as mkdir4, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname5, join as join32 } from "path";
+import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool16, ToolLoopAgent as ToolLoopAgent3 } from "ai";
+import { z as z56 } from "zod";
+function buildWriteTestTool(state, outputDir, onWritten) {
   return tool16({
-    description: "Write a test file to qa-tests/{folder}/{filename}.md. Validates frontmatter before writing. Returns error if frontmatter is invalid.",
-    inputSchema: z52.object({
-      folder: z52.string().describe("Subfolder name under qa-tests/"),
-      filename: z52.string().describe(`File name ending in ${TEST_FILE_EXT} (e.g. login-valid-credentials${TEST_FILE_EXT})`),
-      content: z52.string().describe("Full file content including YAML frontmatter"),
-      nodeId: z52.string().describe(
+    description: "Write one test to qa-tests/{folder}/{filename}.md. You supply the test's parts; the file is rendered for you, so do not write markdown or frontmatter yourself.",
+    inputSchema: z56.object({
+      folder: z56.string().describe("Subfolder name under qa-tests/"),
+      filename: z56.string().describe(`File name ending in ${TEST_FILE_EXT} (e.g. login-valid-credentials${TEST_FILE_EXT})`),
+      nodeId: z56.string().describe(
         "The id next_node returned for this feature, copied verbatim. Not a re-slugged version of it, not a folder path, not the test filename."
-      )
+      ),
+      test: testSpecSchema
     }),
     execute: async (input) => {
-      const frontmatter = extractFrontmatter(input.content);
-      if (!frontmatter) {
-        return { error: "File must start with YAML frontmatter (--- delimiters)" };
-      }
-      const parsed = testFrontmatterSchema.safeParse(frontmatter);
-      if (!parsed.success) {
-        return {
-          error: `Invalid frontmatter: ${parsed.error.issues.map((i) => i.message).join(", ")}`
-        };
-      }
-      if (!/\*\*Intent\*\*:/.test(input.content)) {
-        return {
-          error: "Test must include an **Intent**: section between Setup and Steps describing what behavior is being tested"
-        };
-      }
-      const allSteps = input.content.match(/^\d+\.\s+(\w+):/gm) || [];
-      for (const step of allSteps) {
-        const verbMatch = step.match(/^\d+\.\s+(\w+):/);
-        if (verbMatch && !VALID_VERBS.has(verbMatch[1])) {
-          return {
-            error: `Invalid step verb "${verbMatch[1]}". Only valid verbs are: ${[...VALID_VERBS].join(", ")}`
-          };
-        }
-      }
-      const stepMatches = input.content.match(/^\d+\.\s+(click|type|scroll|assert|hover|drag|read|refresh):/gm) || [];
-      const interactions = stepMatches.filter((s) => /^\d+\.\s+(click|type|drag):/.test(s));
-      if (interactions.length < 2) {
-        return {
-          error: `Test has ${interactions.length} interaction(s) (click/type/drag). Minimum is 2. Visibility-only tests are not allowed - what BEHAVIOR does this test verify?`
-        };
-      }
-      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 placeholder = findForbiddenPlaceholder(stepsSection);
-      if (placeholder) {
-        return {
-          error: `Test steps contain ${placeholder.name}: "${placeholder.match}". Use EXACT values from scenarios.md - not placeholders or examples.`
-        };
-      }
+      const content = renderTestMarkdown(input.test);
       const relPath = join32(TESTS_DIR, input.folder, normalizeTestFilename(input.filename));
       const absPath = join32(outputDir, relPath);
       const nodeId = state.resolveNodeId(input.nodeId, relPath);
@@ -10023,9 +10490,23 @@ function buildWriteTestTool(state, outputDir) {
       }
       try {
         await mkdir4(dirname5(absPath), { recursive: true });
-        await writeFile13(absPath, input.content, "utf-8");
+        await writeFile12(absPath, content, "utf-8");
         state.markTested(nodeId, [relPath]);
         await saveBfsState(outputDir, state);
+        const notes = input.test.notes?.trim();
+        if (notes != null && notes !== "") {
+          track("cli_write_test_notes", { node_id: nodeId });
+          captureLog("info", `Test author flagged an uncertainty: ${notes}`, {
+            source: "test-generator",
+            path: relPath,
+            node_id: nodeId
+          });
+        }
+        onWritten?.({
+          relativePath: join32(input.folder, normalizeTestFilename(input.filename)),
+          content,
+          flow: input.test.flow
+        });
         if (nodeId !== input.nodeId) {
           debugLog("write_test received an unknown nodeId; attributed it to the current node", {
             given: input.nodeId,
@@ -10045,11 +10526,11 @@ function buildWriteTestTool(state, outputDir) {
           });
           return {
             path: relPath,
-            title: parsed.data.title,
+            title: input.test.title,
             note: `nodeId "${input.nodeId}" is not a known node - recorded under "${nodeId}". Pass the id returned by next_node verbatim.`
           };
         }
-        return { path: relPath, title: parsed.data.title };
+        return { path: relPath, title: input.test.title };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `Failed to write test: ${message}` };
@@ -10060,8 +10541,8 @@ function buildWriteTestTool(state, outputDir) {
 function buildCreateFolderTool(outputDir) {
   return tool16({
     description: "Create a folder under qa-tests/ for organizing tests.",
-    inputSchema: z52.object({
-      folder: z52.string().describe("Folder name (kebab-case)")
+    inputSchema: z56.object({
+      folder: z56.string().describe("Folder name (kebab-case)")
     }),
     execute: async (input) => {
       const absPath = join32(outputDir, TESTS_DIR, input.folder);
@@ -10078,7 +10559,7 @@ function buildCreateFolderTool(outputDir) {
 function buildNextNodeTool(state, outputDir) {
   return tool16({
     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: z52.object({}),
+    inputSchema: z56.object({}),
     execute: async () => {
       const next = state.nextNode();
       await saveBfsState(outputDir, state);
@@ -10096,10 +10577,15 @@ function buildNextNodeTool(state, outputDir) {
           routePath: next.node.routePath,
           sourceFiles: next.node.sourceFiles,
           parentId: next.node.parentId,
-          depth: next.node.depth
+          depth: next.node.depth,
+          // The node's mission and its discovered element count. Every test
+          // for this node has to verify the mission; the element count is
+          // what "test depth proportional to complexity" is measured against.
+          mission: next.node.description,
+          interactiveElements: next.node.interactiveElements
         },
         remaining: next.remaining,
-        instruction: `Explore "${next.node.name}": read its source files, find all interactive elements, then write tests with write_test. If no tests are needed after reading the source (e.g. utility route, redirect), call next_node to skip.`
+        instruction: `Explore "${next.node.name}": read its source files, find all interactive elements, then write tests with write_test. ` + (next.node.description != null ? `This node's MISSION is: "${next.node.description}". At least one test must directly assert that mission's outcome. ` : "") + "If no tests are needed after reading the source (e.g. utility route, redirect), call next_node to skip."
       };
     }
   });
@@ -10107,7 +10593,7 @@ function buildNextNodeTool(state, outputDir) {
 function buildGetProgressTool(state) {
   return tool16({
     description: "Check how many nodes have been tested vs how many remain.",
-    inputSchema: z52.object({}),
+    inputSchema: z56.object({}),
     execute: async () => {
       const stats = state.summary();
       const nodes = [...state.nodes.values()].map((n) => ({
@@ -10123,12 +10609,12 @@ function buildGetProgressTool(state) {
 function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
   return tool16({
     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: z52.object({
-      instruction: z52.string().describe("What to research - be specific about files and what to look for")
+    inputSchema: z56.object({
+      instruction: z56.string().describe("What to research - be specific about files and what to look for")
     }),
     execute: async (input) => {
-      const resultSchema2 = z52.object({
-        findings: z52.string().describe("Summary of what was found")
+      const resultSchema2 = z56.object({
+        findings: z56.string().describe("Summary of what was found")
       });
       let result;
       const subagent = new ToolLoopAgent3({
@@ -10165,15 +10651,6 @@ function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
     }
   });
 }
-function extractFrontmatter(content) {
-  try {
-    const { data } = matter5(content);
-    return data && Object.keys(data).length > 0 ? data : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var testFrontmatterSchema;
 var init_tools2 = __esm({
   "src/agents/05-test-generator/tools.ts"() {
     "use strict";
@@ -10185,32 +10662,20 @@ var init_tools2 = __esm({
     init_test_files();
     init_tools();
     init_graph();
-    init_validation();
-    testFrontmatterSchema = z52.object({
-      title: z52.string().min(1),
-      description: z52.string().min(1),
-      intent: z52.string().min(30, "Intent must be at least 30 characters - describe the BEHAVIOR being tested, not the steps"),
-      criticality: z52.enum(CRITICALITY_LEVELS),
-      scenario: z52.string().min(1),
-      flow: z52.string().min(1),
-      verification: z52.string().min(
-        20,
-        "Verification must describe WHERE to navigate and WHAT to assert at the source of truth - not UI acknowledgments like toasts"
-      )
-    });
+    init_test_spec();
   }
 });
 
 // src/agents/05-test-generator/write-index.ts
-import { readFile as readFile21, writeFile as writeFile14 } from "fs/promises";
+import { readFile as readFile21, writeFile as writeFile13 } from "fs/promises";
 import { join as join33 } from "path";
 async function scanTest(outputDir, path3) {
   try {
     const content = await readFile21(join33(outputDir, path3), "utf-8");
     return {
       criticality: content.match(/criticality:\s*(\w+)/)?.[1] ?? "",
-      steps: content.match(STEP_VERBS)?.length ?? 0,
-      interactions: content.match(INTERACTION_VERBS)?.length ?? 0
+      steps: content.match(STEP_VERBS2)?.length ?? 0,
+      interactions: content.match(INTERACTION_VERBS2)?.length ?? 0
     };
   } catch (err) {
     debugLog("Skipping a test file the index could not read", { path: path3, err });
@@ -10277,7 +10742,7 @@ ${folders.map((f) => `| ${f.name} | ${f.test_count} |`).join("\n")}
 
 ${[...testsByFolder.entries()].flatMap(([_folder, tests]) => tests.map((t) => `- \`${t}\``)).join("\n")}
 ${renderSection("Features with no tests", "the run walked these and produced no test for them - re-run the planner to cover them", untested)}${renderSection("Tests lost in review", "the review cycle removed these and nothing could put them back - re-run the planner to regenerate them", lost)}`;
-  await writeFile14(join33(outputDir, TESTS_DIR, TEST_INDEX_FILE), content, "utf-8");
+  await writeFile13(join33(outputDir, TESTS_DIR, TEST_INDEX_FILE), content, "utf-8");
 }
 function untestedFeatures(state) {
   const withTests = new Set(state.testsWritten.keys());
@@ -10293,7 +10758,7 @@ ${items.length} ${items.length === 1 ? "entry" : "entries"} - ${explanation}.
 ${items.map((item) => `- ${item}`).join("\n")}
 `;
 }
-var STEP_VERBS, INTERACTION_VERBS;
+var STEP_VERBS2, INTERACTION_VERBS2;
 var init_write_index = __esm({
   "src/agents/05-test-generator/write-index.ts"() {
     "use strict";
@@ -10301,8 +10766,8 @@ var init_write_index = __esm({
     init_debug();
     init_test_files();
     init_validation();
-    STEP_VERBS = /^\d+\.\s+(click|type|scroll|assert|hover|drag|read|refresh):/gm;
-    INTERACTION_VERBS = /^\d+\.\s+(click|type|drag):/gm;
+    STEP_VERBS2 = /^\d+\.\s+(click|type|scroll|assert|hover|drag|read|refresh):/gm;
+    INTERACTION_VERBS2 = /^\d+\.\s+(click|type|drag):/gm;
   }
 });
 
@@ -10312,11 +10777,11 @@ __export(test_generator_exports, {
   runTestGenerator: () => runTestGenerator
 });
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir5, readFile as readFile22, rmdir, unlink, writeFile as writeFile15 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile22, rmdir, unlink, writeFile as writeFile14 } from "fs/promises";
 import { basename as basename5, join as join34 } from "path";
 import { tool as tool17 } from "ai";
-import { z as z53 } from "zod";
 import { glob as glob6 } from "glob";
+import { z as z57 } from "zod";
 async function preseedQueue(state, projectRoot, pages, features) {
   let seeded = 0;
   const pageIdByPath = /* @__PURE__ */ new Map();
@@ -10334,7 +10799,8 @@ async function preseedQueue(state, projectRoot, pages, features) {
       sourceFiles: [relPath],
       parentId: void 0,
       depth: 0,
-      status: "queued"
+      status: "queued",
+      description: page.description
     };
     if (state.enqueue(node)) seeded++;
   }
@@ -10349,7 +10815,9 @@ async function preseedQueue(state, projectRoot, pages, features) {
         sourceFiles: feature.sourceFiles,
         parentId,
         depth: 1,
-        status: "queued"
+        status: "queued",
+        description: feature.description,
+        interactiveElements: feature.interactiveElements
       };
       if (state.enqueue(node)) seeded++;
     }
@@ -10358,15 +10826,15 @@ async function preseedQueue(state, projectRoot, pages, features) {
 Pre-seeded: ${seeded} nodes (pages + sub-features). Call next_node to start processing them one at a time.` : "";
 }
 async function runTestGenerator(input) {
-  const model = getModel(input.modelId);
+  const model = input.model ?? getModel(input.modelId);
   const ignorePatterns = await loadGitignorePatterns(input.projectRoot);
   const existingState = await loadBfsState(input.outputDir);
   const state = existingState ?? new CoverageState();
   let result;
   const finishTool = tool17({
     description: "Call when the BFS queue is empty and all routes have been explored.",
-    inputSchema: z53.object({
-      summary: z53.string().describe("Coverage summary")
+    inputSchema: z57.object({
+      summary: z57.string().describe("Coverage summary")
     }),
     execute: async (finishInput) => {
       const stats = state.summary();
@@ -10402,14 +10870,20 @@ ${autonomaMd}
 `;
   } catch {
   }
-  try {
-    const scenariosMd = await readFile22(join34(input.outputDir, "scenarios.md"), "utf-8");
-    kbContext += `
+  const recipeContext = await loadRecipeContext(input.outputDir);
+  if (recipeContext !== "") {
+    kbContext += recipeContext;
+  } else {
+    try {
+      const scenariosMd = await readFile22(join34(input.outputDir, "scenarios.md"), "utf-8");
+      kbContext += `
 ## Scenarios
 
 ${scenariosMd}
 `;
-  } catch {
+    } catch (err) {
+      debugLog("Neither recipe.json nor scenarios.md is readable; generating without a data contract", { err });
+    }
   }
   let features;
   if (!existingState) {
@@ -10430,7 +10904,7 @@ ${scenariosMd}
   const preseedContext = existingState ? "" : await preseedQueue(state, input.projectRoot, input.pages, features ?? void 0);
   const resumeContext = existingState ? `
 You are RESUMING a previous run. ${existingState.summary().tested} nodes tested, ${existingState.summary().totalTests} tests written. Call next_node to continue.` : "";
-  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + formatRetryGuidance(input.retryGuidance);
+  const contextBlock = formatRetryGuidance(input.retryGuidance);
   let prompt = `Generate E2E test cases by processing every node in the queue.
 ${contextBlock}${kbContext}${resumeContext}${preseedContext}
 
@@ -10454,6 +10928,8 @@ Do NOT try to finish early. Process EVERY node via next_node until it returns do
   const MAX_STALE_CHUNKS = 3;
   let totalSteps = 0;
   const logger = createStepLogger("test-gen", CHUNK_STEPS);
+  const reviewDeadline = Date.now() + REVIEW_BUDGET_MS;
+  const pipeline = new ReviewPipeline(input.outputDir, input.projectRoot, model, reviewDeadline);
   const listDirectoryFn = await buildListDirectoryTool(input.projectRoot);
   const agentConfig = {
     id: "test-generator",
@@ -10468,7 +10944,10 @@ Do NOT try to finish early. Process EVERY node via next_node until it returns do
       grep: buildGrepTool(input.projectRoot),
       bash: buildBashTool(input.projectRoot),
       list_directory: listDirectoryFn,
-      write_test: buildWriteTestTool(state, input.outputDir),
+      write_test: buildWriteTestTool(state, input.outputDir, (test) => {
+        consecutiveRejections = 0;
+        pipeline.submit(test);
+      }),
       create_folder: buildCreateFolderTool(input.outputDir),
       next_node: buildNextNodeTool(state, input.outputDir),
       get_progress: buildGetProgressTool(state),
@@ -10477,6 +10956,7 @@ Do NOT try to finish early. Process EVERY node via next_node until it returns do
     }),
     onStepFinish: (info) => {
       logger.log(info);
+      recordToolErrors(info.toolErrors);
       const stats = state.summary();
       if (info.stepNumber > 0 && info.stepNumber % 10 === 0) {
         logger.checkpoint(
@@ -10485,6 +10965,29 @@ Do NOT try to finish early. Process EVERY node via next_node until it returns do
       }
     }
   };
+  let consecutiveRejections = 0;
+  let lastRejection;
+  function recordToolErrors(toolErrors) {
+    const writeErrors = toolErrors.filter((e) => e.name === "write_test");
+    if (writeErrors.length === 0) return;
+    consecutiveRejections += writeErrors.length;
+    lastRejection = String(writeErrors.at(-1)?.error ?? "").slice(0, REJECTION_MESSAGE_CHARS);
+    if (consecutiveRejections === MAX_CONSECUTIVE_REJECTIONS) {
+      track("cli_write_test_rejection_loop", { rejections: consecutiveRejections });
+      captureLog("error", `write_test has rejected ${consecutiveRejections} attempts in a row`, {
+        source: "test-generator",
+        rejections: consecutiveRejections,
+        last_error: lastRejection
+      });
+      console.error(
+        `
+  write_test has rejected ${consecutiveRejections} attempts in a row without a test being written.
+  The model cannot satisfy a validation rule, so retrying will not converge:
+  ${lastRejection}
+`
+      );
+    }
+  }
   let staleChunks = 0;
   let lastTestCount = state.summary().totalTests;
   while (!result) {
@@ -10496,6 +10999,10 @@ ${formatException(err)}`);
     }
     totalSteps += CHUNK_STEPS;
     if (result) break;
+    if (consecutiveRejections >= MAX_CONSECUTIVE_REJECTIONS) {
+      console.log(`  [chunk] write_test is rejecting every attempt - stopping rather than burning the budget.`);
+      break;
+    }
     const stats = state.summary();
     const newTests = stats.totalTests - lastTestCount;
     if (newTests === 0) {
@@ -10540,7 +11047,11 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       console.log(`  Generated ${journeyCount} journey tests`);
     }
     const lostTests = /* @__PURE__ */ new Set();
-    const reviewDeadline = Date.now() + REVIEW_BUDGET_MS;
+    const pipelined = await pipeline.drain();
+    if (pipelined.length > 0) {
+      console.log(`  ${pipelined.length} tests were already reviewed during generation`);
+    }
+    const settled = /* @__PURE__ */ new Set();
     for (let cycle = 0; cycle < MAX_REVIEW_CYCLES; cycle++) {
       if (Date.now() > reviewDeadline) {
         console.log(`  Review budget spent after ${cycle} cycle${cycle === 1 ? "" : "s"} - moving on`);
@@ -10555,22 +11066,51 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       }
       console.log(`  Review cycle ${cycle + 1}/${MAX_REVIEW_CYCLES}`);
       state.setPhase(`review cycle ${cycle + 1}/${MAX_REVIEW_CYCLES}`);
-      const reviewResult = await runConsolidatedReview(input.outputDir, input.projectRoot, model, reviewDeadline);
-      console.log(`  Review: ${reviewResult.passed} passed, ${reviewResult.failed} failed`);
+      const scanDeadline = Date.now() + Math.floor((reviewDeadline - Date.now()) * REVIEW_SCAN_SHARE);
+      const reviewResult = await runConsolidatedReview(
+        input.outputDir,
+        input.projectRoot,
+        model,
+        scanDeadline,
+        settled,
+        cycle === 0 ? pipelined : []
+      );
+      for (const path3 of reviewResult.passedPaths) settled.add(path3);
+      console.log(
+        `  Review: ${reviewResult.passed} passed, ${reviewResult.failed} failed (${settled.size} settled overall)`
+      );
       if (reviewResult.feedback.length === 0) {
         console.log(`  All tests passed review - done`);
         break;
       }
-      if (reviewResult.ranOutOfTime) {
-        console.log(`  Review budget ran out mid-cycle - moving on`);
-        track("cli_review_budget_exhausted", { cycles_completed: cycle });
-        captureLog("warn", `Review budget ran out mid-cycle - some tests were left unreviewed`, {
+      const scanCutShort = reviewResult.ranOutOfTime;
+      if (Date.now() > reviewDeadline) {
+        console.log(`  Review budget spent - moving on`);
+        track("cli_review_budget_exhausted", {
+          cycles_completed: cycle,
+          findings_discarded: reviewResult.feedback.length
+        });
+        captureLog("warn", `Review budget spent - findings from this cycle were not fixed`, {
           source: "test-generator",
           step: "review",
-          cycles_completed: cycle
+          cycles_completed: cycle,
+          findings_discarded: reviewResult.feedback.length
         });
         break;
       }
+      if (scanCutShort) {
+        console.log(`  Review scan cut short - fixing the ${reviewResult.feedback.length} it did judge`);
+        track("cli_review_scan_cut_short", {
+          cycles_completed: cycle,
+          findings_carried: reviewResult.feedback.length
+        });
+        captureLog("warn", `Review scan cut short - some tests were left unreviewed`, {
+          source: "test-generator",
+          step: "review",
+          cycles_completed: cycle,
+          findings_carried: reviewResult.feedback.length
+        });
+      }
       for (const fb of reviewResult.feedback) {
         try {
           await unlink(fb.testPath);
@@ -10627,6 +11167,7 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
         });
       }
       console.log(`  Fix pass complete`);
+      if (scanCutShort) break;
     }
     state.setPhase("checking every test");
     const allTestFiles = await glob6(join34(input.outputDir, TESTS_DIR, TEST_FILE_GLOB));
@@ -10642,7 +11183,7 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
         const dest = join34(invalidDir, basename5(testPath));
         const annotated = `<!-- VALIDATION ERRORS: ${validation.errors.join("; ")} -->
 ${content}`;
-        await writeFile15(dest, annotated, "utf-8");
+        await writeFile14(dest, annotated, "utf-8");
         await unlink(testPath);
         markedInvalid++;
       }
@@ -10746,13 +11287,13 @@ Each journey test:
 - Has scenario: standard
 - Includes an **Intent**: section explaining the cross-feature flow being tested
 - Verifies that the OUTPUT of one feature is correctly consumed by the NEXT feature
-- Goes in the "journeys" folder
+- Goes in the "${JOURNEY_NODE_ID}" folder
 
-Write 5-8 journey tests using the write_test tool with folder "journeys". Then call finish.`;
+Write 5-8 journey tests using the write_test tool with folder "${JOURNEY_NODE_ID}" and nodeId "${JOURNEY_NODE_ID}". Then call finish.`;
   const ignorePatterns = await loadGitignorePatterns(projectRoot);
   const journeyState = new CoverageState({ stateFile: JOURNEY_STATE_FILE, reportsProgress: false });
   journeyState.enqueue({
-    id: "journeys",
+    id: JOURNEY_NODE_ID,
     name: "Journey Tests",
     sourceFiles: [],
     parentId: void 0,
@@ -10763,7 +11304,7 @@ Write 5-8 journey tests using the write_test tool with folder "journeys". Then c
   let journeyResult;
   const journeyFinish = tool17({
     description: "Signal journey generation is complete.",
-    inputSchema: z53.object({ summary: z53.string() }),
+    inputSchema: z57.object({ summary: z57.string() }),
     execute: async (finishInput) => {
       journeyResult = {
         success: true,
@@ -10798,33 +11339,38 @@ ${formatException(err)}`);
   logger.summary();
   return journeyState.allTestPaths().length;
 }
-var MAX_CONCURRENCY, MAX_REVIEW_CYCLES, REVIEW_BUDGET_MS;
+var MAX_CONCURRENCY, MAX_REVIEW_CYCLES, REVIEW_BUDGET_MS, MAX_CONSECUTIVE_REJECTIONS, REJECTION_MESSAGE_CHARS, REVIEW_SCAN_SHARE, JOURNEY_NODE_ID;
 var init_test_generator = __esm({
   "src/agents/05-test-generator/index.ts"() {
     "use strict";
     init_esm_shims();
     init_agent();
     init_analytics();
-    init_context();
+    init_debug();
     init_display();
     init_errors();
     init_gitignore();
     init_logs();
     init_model();
-    init_restore_deleted_test();
-    init_review();
-    init_debug();
     init_test_files();
     init_tools();
     init_b_feature_discovery();
     init_graph();
     init_prompt5();
+    init_recipe_context();
+    init_restore_deleted_test();
+    init_review();
+    init_review_pipeline();
     init_tools2();
     init_validation();
     init_write_index();
     MAX_CONCURRENCY = 8;
     MAX_REVIEW_CYCLES = 4;
     REVIEW_BUDGET_MS = 45 * 60 * 1e3;
+    MAX_CONSECUTIVE_REJECTIONS = 25;
+    REJECTION_MESSAGE_CHARS = 300;
+    REVIEW_SCAN_SHARE = 0.6;
+    JOURNEY_NODE_ID = "journeys";
   }
 });
 
@@ -12052,8 +12598,8 @@ var init_useTerminalSize = __esm({
 
 // src/ui/grid.ts
 function rgbOf(hex) {
-  const cached = rgbCache.get(hex);
-  if (cached != null) return cached;
+  const cached2 = rgbCache.get(hex);
+  if (cached2 != null) return cached2;
   const r = parseInt(hex.slice(1, 3), 16);
   const g = parseInt(hex.slice(3, 5), 16);
   const b = parseInt(hex.slice(5, 7), 16);
@@ -12839,7 +13385,7 @@ ensureSupportedNode();
 
 // src/index.ts
 init_submit();
-import { readFile as readFile24, writeFile as writeFile16 } from "fs/promises";
+import { readFile as readFile24, writeFile as writeFile15 } from "fs/promises";
 import { join as join35 } from "path";
 
 // src/agents/04-recipe-builder/sdk-command.ts
@@ -13029,7 +13575,7 @@ function shortHash(seed) {
 }
 
 // src/agents/04-recipe-builder/sdk-command.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 
 // src/agents/04-recipe-builder/http-client.ts
 init_esm_shims();
@@ -13078,15 +13624,15 @@ async function down(config, refsToken) {
 
 // src/agents/04-recipe-builder/sdk-command.ts
 var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
-var createSchema = z33.record(z33.string(), z33.array(z33.unknown()));
-var recipeSliceSchema = z33.object({ create: createSchema, variables: ScenarioRecipeVariablesSchema.optional() });
-var envelopeSchema = z33.object({ recipes: z33.array(recipeSliceSchema).min(1) });
-var flagsSchema = z33.object({
-  url: z33.string().min(1).optional(),
-  recipe: z33.string().min(1).optional(),
-  "refs-token": z33.string().min(1).optional(),
-  "test-run-id": z33.string().min(1).optional(),
-  timeout: z33.coerce.number().int().positive().optional()
+var createSchema = z35.record(z35.string(), z35.array(z35.unknown()));
+var recipeSliceSchema = z35.object({ create: createSchema, variables: ScenarioRecipeVariablesSchema.optional() });
+var envelopeSchema = z35.object({ recipes: z35.array(recipeSliceSchema).min(1) });
+var flagsSchema = z35.object({
+  url: z35.string().min(1).optional(),
+  recipe: z35.string().min(1).optional(),
+  "refs-token": z35.string().min(1).optional(),
+  "test-run-id": z35.string().min(1).optional(),
+  timeout: z35.coerce.number().int().positive().optional()
 }).strict();
 async function runSdkCommand(argv, io) {
   const action = argv[0];
@@ -13295,7 +13841,6 @@ function loadConfig(args) {
 // src/index.ts
 init_analytics();
 init_colors();
-init_context();
 init_errors();
 
 // src/core/flush-telemetry.ts
@@ -13315,13 +13860,13 @@ init_model();
 // src/core/output.ts
 init_esm_shims();
 init_debug();
-import { mkdir, rm, writeFile as writeFile3 } from "fs/promises";
+import { mkdir, rm, writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join11 } from "path";
-var AUTONOMA_HOME3 = join11(homedir3(), ".autonoma");
+import { join as join10 } from "path";
+var AUTONOMA_HOME3 = join10(homedir3(), ".autonoma");
 var WRITE_PROBE_FILE = ".write-probe";
 function getOutputDir(projectSlug) {
-  return join11(AUTONOMA_HOME3, projectSlug);
+  return join10(AUTONOMA_HOME3, projectSlug);
 }
 async function clearOutputDir(projectSlug) {
   const dir = getOutputDir(projectSlug);
@@ -13336,9 +13881,9 @@ function displayPath(absPath) {
 async function ensureOutputDir(projectSlug) {
   const dir = getOutputDir(projectSlug);
   await mkdir(dir, { recursive: true });
-  const probe = join11(dir, WRITE_PROBE_FILE);
+  const probe = join10(dir, WRITE_PROBE_FILE);
   try {
-    await writeFile3(probe, "ok", "utf-8");
+    await writeFile2(probe, "ok", "utf-8");
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     throw new Error(
@@ -13362,8 +13907,8 @@ init_prompts();
 // src/core/git.ts
 init_esm_shims();
 import { execFile } from "child_process";
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join11 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var GIT_INFO_FILE = ".git-info.json";
@@ -13387,11 +13932,11 @@ async function readGitInfo(projectRoot) {
   };
 }
 async function saveGitInfo(outputDir, info) {
-  await writeFile4(join12(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile3(join11(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 async function loadGitInfo(outputDir) {
   try {
-    const raw = await readFile5(join12(outputDir, GIT_INFO_FILE), "utf-8");
+    const raw = await readFile4(join11(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;
@@ -13413,15 +13958,15 @@ init_state();
 init_esm_shims();
 init_prompts();
 init_debug();
-import { readFile as readFile7 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join13 } from "path";
 init_test_files();
 var ARTIFACT_FILES = ["AUTONOMA.md", "scenarios.md", "entity-audit.md"];
 async function readArtifacts(outputDir) {
   const files = await Promise.all(
     ARTIFACT_FILES.map(async (name) => {
       try {
-        return { name, content: await readFile7(join14(outputDir, name), "utf-8") };
+        return { name, content: await readFile6(join13(outputDir, name), "utf-8") };
       } catch (err) {
         debugLog(`Artifact ${name} not on disk; skipping upload`, { err });
         return void 0;
@@ -13437,7 +13982,7 @@ async function readTestCases(outputDir) {
       const segments = testPath.split("/").slice(1);
       const name = segments[segments.length - 1];
       const folder = segments.slice(0, -1).join("/");
-      const content = await readFile7(join14(outputDir, testPath), "utf-8");
+      const content = await readFile6(join13(outputDir, testPath), "utf-8");
       return { name, content, folder: folder.length > 0 ? folder : void 0 };
     })
   );
@@ -13501,7 +14046,7 @@ process.setSourceMapsEnabled(true);
 var PAGES_FILE = "pages.json";
 async function savePages(outputDir, pages) {
   const obj = Object.fromEntries(pages);
-  await writeFile16(join35(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile15(join35(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadPages(outputDir) {
   try {
@@ -13593,7 +14138,7 @@ async function promptScopeSelection(map) {
     return { frontend, backends };
   }
 }
-async function runStep(step, outputDir, state, config, projectContext, nonInteractive, retryGuidance) {
+async function runStep(step, outputDir, state, config, nonInteractive, retryGuidance) {
   const label = STEP_LABELS[step];
   note(STEP_INTROS[step], `Step: ${label}`);
   const stepStartedAt = Date.now();
@@ -13605,14 +14150,6 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
   });
   state = await markStep(outputDir, state, step, "running");
   getActiveStore()?.startStep(step);
-  if (step !== "pagesFinder" && projectContext && !projectContext.pages) {
-    const pages = await loadPages(outputDir);
-    if (pages.size > 0) {
-      projectContext = { ...projectContext, pages: [...pages.values()] };
-    }
-  }
-  const knownPages = projectContext?.pages?.length ?? 0;
-  if (knownPages > 0) getActiveStore()?.setSizes({ pages: knownPages });
   let stepMetrics = {};
   try {
     let result;
@@ -13676,12 +14213,10 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
       }
       case "kb": {
         const { runKBGenerator: runKBGenerator2 } = await Promise.resolve().then(() => (init_kb_generator(), kb_generator_exports));
-        stepMetrics = { page_count: projectContext?.pages?.length ?? 0 };
         result = await runKBGenerator2({
           projectRoot: config.projectRoot,
           outputDir,
           modelId: config.modelId,
-          projectContext,
           nonInteractive,
           retryGuidance
         });
@@ -13694,7 +14229,6 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
           projectRoot: config.projectRoot,
           outputDir,
           modelId: config.modelId,
-          projectContext,
           nonInteractive,
           retryGuidance,
           scopeHint: auditMap != null ? formatBackendScope(auditMap) : void 0
@@ -13709,7 +14243,6 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
           outputDir,
           modelId: config.modelId,
           config,
-          projectContext,
           nonInteractive,
           retryGuidance,
           scopeHint: recipeMap != null ? formatBackendScope(recipeMap) : void 0
@@ -13724,7 +14257,6 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
           outputDir,
           modelId: config.modelId,
           config,
-          projectContext,
           nonInteractive,
           retryGuidance,
           agent: config.agent,
@@ -13741,7 +14273,6 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
           outputDir,
           modelId: config.modelId,
           config,
-          projectContext,
           nonInteractive,
           pages,
           retryGuidance
@@ -13831,10 +14362,10 @@ async function promptStepFailure(label) {
     return { kind: "retry", guidance: trimmed || void 0 };
   }
 }
-async function runStepWithRecovery(step, outputDir, state, config, projectContext, nonInteractive) {
+async function runStepWithRecovery(step, outputDir, state, config, nonInteractive) {
   let guidance;
   while (true) {
-    state = await runStep(step, outputDir, state, config, projectContext, nonInteractive, guidance);
+    state = await runStep(step, outputDir, state, config, nonInteractive, guidance);
     if (state.steps[step] !== "failed" || nonInteractive) return state;
     const action = await promptStepFailure(STEP_LABELS[step]);
     if (action.kind === "exit") return state;
@@ -13989,7 +14520,6 @@ async function main() {
   }
   if (!nonInteractive) mountedUi = await mountDashboard(outputDir, config.projectSlug);
   let isResuming = !!(args.resume || args.step);
-  let projectContext;
   const hasProgress = Object.values(state.steps).some((s) => s === "done" || s === "running");
   if (!nonInteractive && !isResuming && !hasProgress) {
     await welcome({
@@ -14023,11 +14553,6 @@ async function main() {
     }
   }
   if (isResuming) seedDashboard(mountedUi, state);
-  const saved = await loadContext(outputDir);
-  if (saved) {
-    projectContext = saved;
-    log.info(`Loaded project context from previous run`);
-  }
   note(
     `${outputDir}
 
@@ -14051,7 +14576,7 @@ or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
       log.error("Cannot run test generation yet - the scenario recipe step must complete first.");
       return;
     }
-    state = await runStepWithRecovery(targetStep, outputDir, state, config, projectContext, nonInteractive);
+    state = await runStepWithRecovery(targetStep, outputDir, state, config, nonInteractive);
     mountedUi?.unmount();
     mountedUi = void 0;
     if (state.steps[targetStep] === "failed") {
@@ -14076,7 +14601,7 @@ or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
   try {
     for (let i = startIdx; i < steps.length; i++) {
       const step = steps[i];
-      state = await runStepWithRecovery(step, outputDir, state, config, projectContext, nonInteractive);
+      state = await runStepWithRecovery(step, outputDir, state, config, nonInteractive);
       if (state.steps[step] === "paused") {
         break;
       }