@autonoma-ai/planner 0.1.24 → 0.1.25

package/dist/index.js

@@ -42,6 +42,11 @@ var init_env = __esm({
       AUTONOMA_API_URL: z.string().optional(),
       AUTONOMA_API_TOKEN: z.string().optional(),
       AUTONOMA_GENERATION_ID: z.string().optional(),
+      // The Autonoma application this run belongs to. Unlike AUTONOMA_GENERATION_ID
+      // (which identifies one setup's uploads) this identifies the app itself, and is
+      // what the onboarding calls - reading state, minting a pairing code for an agent
+      // this CLI spawns - are keyed by.
+      AUTONOMA_APPLICATION_ID: z.string().optional(),
       AUTONOMA_POSTHOG_KEY: z.string().optional(),
       AUTONOMA_POSTHOG_HOST: z.string().optional(),
       AUTONOMA_DISTINCT_ID: z.string().optional(),
@@ -498,13 +503,13 @@ function wrapStyledLines(lines, width) {
       continue;
     }
     const leading = leadingSpaces(line);
-    const indent = leading > 0 && leading <= Math.floor(width / 2) ? leading : 0;
+    const indent2 = leading > 0 && leading <= Math.floor(width / 2) ? leading : 0;
     const chars = [];
     for (const span of line) for (const ch of span.text) chars.push({ ch, span });
     let start = 0;
     let first = true;
     while (start < chars.length) {
-      const avail = first ? width : width - indent;
+      const avail = first ? width : width - indent2;
       let end = Math.min(start + avail, chars.length);
       if (end < chars.length) {
         let back = end;
@@ -518,7 +523,7 @@ function wrapStyledLines(lines, width) {
         if (last != null && chars[i - 1]?.span === span && i > start) last.text += ch;
         else folded.push({ text: ch, color: span.color, bold: span.bold, dim: span.dim });
       }
-      if (!first && indent > 0) folded.unshift({ text: " ".repeat(indent) });
+      if (!first && indent2 > 0) folded.unshift({ text: " ".repeat(indent2) });
       out.push(folded.length ? folded : [{ text: "" }]);
       start = end;
       while (start < chars.length && chars[start].ch === " ") start++;
@@ -2017,7 +2022,7 @@ var init_evidence_tokens = __esm({
 
 // ../../packages/types/src/schemas/investigation-report.ts
 import { z as z6 } from "zod";
-var investigationEvidenceSchema, investigationPointSchema, investigationRunStepSchema, investigationFindingSchema, investigationValidationSchema, investigationSuggestedTestSchema, investigationDeployedPerTestSchema, investigationDeployedComparisonSchema, investigationReportDataSchema;
+var investigationEvidenceSchema, investigationPointSchema, investigationRunStepSchema, investigationFindingSchema, investigationDeployedPerTestSchema, investigationDeployedComparisonSchema;
 var init_investigation_report = __esm({
   "../../packages/types/src/schemas/investigation-report.ts"() {
     "use strict";
@@ -2096,7 +2101,9 @@ var init_investigation_report = __esm({
       /** Browser-openable HTTPS URL of the dead-time-stripped mp4 recording, signed on read. When present, the
        *  finding page shows an Optimized/Original toggle; absent for runs recorded before the optimizer landed. */
       optimizedVideoUrl: z6.string().optional(),
-      finalScreenshotUrl: z6.string().optional(),
+      /** Browser-openable HTTPS URL of the frame the classifier chose (`keyStepIndex`), signed on read. Absent when
+       *  it chose none, in which case the finding deliberately shows no still. */
+      keyScreenshotUrl: z6.string().optional(),
       /** Present instead of the verdict fields when the model failed to classify this test. */
       error: z6.string().optional(),
       /**
@@ -2113,17 +2120,6 @@ var init_investigation_report = __esm({
       issueId: z6.string().optional(),
       issueTitle: z6.string().optional()
     });
-    investigationValidationSchema = z6.object({
-      passed: z6.boolean(),
-      iterations: z6.number(),
-      failureReason: z6.string().optional()
-    });
-    investigationSuggestedTestSchema = z6.object({
-      name: z6.string(),
-      instruction: z6.string(),
-      reasoning: z6.string(),
-      validation: investigationValidationSchema.optional()
-    });
     investigationDeployedPerTestSchema = z6.object({
       testSlug: z6.string(),
       affectedReason: z6.string().optional(),
@@ -2138,20 +2134,6 @@ var init_investigation_report = __esm({
       failureReason: z6.string().optional(),
       perTest: z6.array(investigationDeployedPerTestSchema)
     });
-    investigationReportDataSchema = z6.object({
-      client: z6.string(),
-      appSlug: z6.string(),
-      prNumber: z6.number(),
-      prTitle: z6.string().optional(),
-      prBody: z6.string().optional(),
-      /** owner/repo for the app's GitHub repository - used to build code permalinks. Absent on legacy reports. */
-      repoFullName: z6.string().optional(),
-      /** The PR head commit the run tested - the permalink ref. Absent on legacy reports. */
-      commitSha: z6.string().optional(),
-      findings: z6.array(investigationFindingSchema),
-      suggested: z6.array(investigationSuggestedTestSchema),
-      deployed: investigationDeployedComparisonSchema.optional()
-    });
   }
 });
 
@@ -2187,7 +2169,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, analysisPrCoveredTestSchema, analysisPrIssueSchema, analysisPrNewerRunSchema, analysisForPrSchema, 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, mainProblemSourceSchema, mainOpenProblemSchema, mainOpenProblemsSchema, analysisSnapshotIssueChangesSchema;
 var init_analysis = __esm({
   "../../packages/types/src/schemas/analysis.ts"() {
     "use strict";
@@ -2445,6 +2427,21 @@ var init_analysis = __esm({
         newerRun: analysisPrNewerRunSchema.optional()
       })
     ]);
+    mainProblemSourceSchema = z8.enum(["legacy_bug", "analysis_issue"]);
+    mainOpenProblemSchema = z8.object({
+      id: z8.string(),
+      title: z8.string(),
+      kind: analysisIssueKindSchema,
+      severity: analysisIssueSeveritySchema,
+      /** The problem's own account of what went wrong (a bug's description, an issue's actual behavior). */
+      detail: z8.string().optional(),
+      occurrences: z8.number().int().nonnegative(),
+      lastSeenAt: z8.date()
+    });
+    mainOpenProblemsSchema = z8.object({
+      source: mainProblemSourceSchema,
+      problems: z8.array(mainOpenProblemSchema)
+    });
     analysisSnapshotIssueChangesSchema = z8.object({
       opened: z8.array(analysisIssueSummarySchema),
       carriedForward: z8.array(analysisIssueSummarySchema),
@@ -2542,7 +2539,7 @@ function findRecipeCreateGraphProblems(create, declaredTokens = /* @__PURE__ */
   }
   return problems;
 }
-var SdkFieldSchema, SdkModelSchema, SdkEdgeSchema, SdkRelationSchema, SdkSchemaSchema, SdkDiscoverResponseSchema, ScenarioRecipeValidationSchema, ScenarioVariableScalarSchema, ScenarioVariableDefinitionSchema, ScenarioRecipeVariablesSchema, ScenarioStructureModelSchema, ScenarioStructureJsonSchema, ScenarioRecipeSchema, ScenarioCreateGraphSchema, TEST_RUN_ID_TOKEN, TEST_RUN_SHORT_ID_TOKEN, BUILT_IN_RECIPE_TOKENS, BUILT_IN_RECIPE_TOKEN_LIST, RECIPE_TEMPLATE_PATTERN, ScenarioRecipesFileSchema, AuthCookieSchema, AuthHeadersSchema, AuthCredentialsSchema, AuthPayloadSchema, RefsSchema, UpResponseSchema, DownResponseSchema, ConfigureWebhookInputSchema, RemoveWebhookInputSchema, DiscoverInputSchema, ListScenariosInputSchema, ListInstancesInputSchema, ListWebhookCallsInputSchema, DryRunInputSchema, GetRecipeInputSchema, UpdateRecipeInputSchema, PreviewkitEnvFactoryOptionsInputSchema, PreviewkitEnvFactoryUpInputSchema, PreviewkitEnvFactoryDownInputSchema, TestUserOptionsInputSchema, TestUserProvisionInputSchema, TestUserTeardownInputSchema;
+var SdkFieldSchema, SdkModelSchema, SdkEdgeSchema, SdkRelationSchema, SdkSchemaSchema, SdkDiscoverResponseSchema, SCENARIO_VALIDATION_METHODS, ScenarioRecipeValidationSchema, ScenarioVariableScalarSchema, ScenarioVariableDefinitionSchema, ScenarioRecipeVariablesSchema, ScenarioStructureModelSchema, ScenarioStructureJsonSchema, ScenarioRecipeSchema, ScenarioCreateGraphSchema, TEST_RUN_ID_TOKEN, TEST_RUN_SHORT_ID_TOKEN, BUILT_IN_RECIPE_TOKENS, BUILT_IN_RECIPE_TOKEN_LIST, RECIPE_TEMPLATE_PATTERN, ScenarioRecipesFileSchema, AuthCookieSchema, AuthHeadersSchema, AuthCredentialsSchema, AuthPayloadSchema, RefsSchema, UpResponseSchema, DownResponseSchema, ConfigureWebhookInputSchema, RemoveWebhookInputSchema, DiscoverInputSchema, ListScenariosInputSchema, ListInstancesInputSchema, ListWebhookCallsInputSchema, DryRunInputSchema, GetRecipeInputSchema, UpdateRecipeInputSchema, PreviewkitEnvFactoryOptionsInputSchema, PreviewkitEnvFactoryUpInputSchema, PreviewkitEnvFactoryDownInputSchema, TestUserOptionsInputSchema, TestUserProvisionInputSchema, TestUserTeardownInputSchema;
 var init_scenarios = __esm({
   "../../packages/types/src/schemas/scenarios.ts"() {
     "use strict";
@@ -2582,9 +2579,10 @@ var init_scenarios = __esm({
       sdk: z9.record(z9.string(), z9.unknown()).optional(),
       schema: SdkSchemaSchema
     }).passthrough();
+    SCENARIO_VALIDATION_METHODS = ["checkScenario", "checkAllScenarios", "endpoint-up-down"];
     ScenarioRecipeValidationSchema = z9.object({
       status: z9.literal("validated"),
-      method: z9.enum(["checkScenario", "checkAllScenarios", "endpoint-up-down"]),
+      method: z9.enum(SCENARIO_VALIDATION_METHODS),
       phase: z9.literal("ok"),
       up_ms: z9.number().int().nonnegative().optional(),
       down_ms: z9.number().int().nonnegative().optional()
@@ -3162,33 +3160,11 @@ var init_secrets = __esm({
   }
 });
 
-// ../../packages/types/src/schemas/org-secrets.ts
-import { z as z17 } from "zod";
-var ORG_SECRET_NAME_REGEX, OrgSecretNameSchema, ListOrgSecretsInputSchema, UpsertOrgSecretInputSchema, DeleteOrgSecretKeyInputSchema;
-var init_org_secrets = __esm({
-  "../../packages/types/src/schemas/org-secrets.ts"() {
+// ../../packages/types/src/schemas/previewkit-node-pm.ts
+var init_previewkit_node_pm = __esm({
+  "../../packages/types/src/schemas/previewkit-node-pm.ts"() {
     "use strict";
     init_esm_shims();
-    init_secrets();
-    ORG_SECRET_NAME_REGEX = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
-    OrgSecretNameSchema = z17.string().min(2).max(63).regex(
-      ORG_SECRET_NAME_REGEX,
-      "Org secret name must be lowercase alphanumeric with hyphens (matches the preview config auth_secret field)"
-    );
-    ListOrgSecretsInputSchema = z17.object({
-      name: OrgSecretNameSchema
-    });
-    UpsertOrgSecretInputSchema = z17.object({
-      name: OrgSecretNameSchema,
-      // Same item shape as per-app secrets: { key, value } where the AWS SM
-      // SecretString stores them as a flat JSON map. Providers pick the keys
-      // they care about (NeonProvider expects `token`).
-      items: z17.array(SecretItemSchema).min(1).max(50)
-    });
-    DeleteOrgSecretKeyInputSchema = z17.object({
-      name: OrgSecretNameSchema,
-      key: z17.string().min(1)
-    });
   }
 });
 
@@ -3348,8 +3324,268 @@ var init_previewkit_runtimes = __esm({
   }
 });
 
+// ../../packages/types/src/schemas/previewkit-presets.ts
+function previewkitPresetSpec(preset) {
+  return PREVIEWKIT_PRESET_CATALOG[preset];
+}
+var PREVIEWKIT_PRESET_IDS, SERVER_TREE, PREVIEWKIT_PRESET_CATALOG, PREVIEWKIT_PRESETS;
+var init_previewkit_presets = __esm({
+  "../../packages/types/src/schemas/previewkit-presets.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_previewkit_runtimes();
+    PREVIEWKIT_PRESET_IDS = [
+      "nextjs",
+      "nuxt",
+      "sveltekit",
+      "remix",
+      "hono",
+      "express",
+      "astro",
+      "vite",
+      "django",
+      "fastapi",
+      "python",
+      "rails",
+      "ruby",
+      "node",
+      "static"
+    ];
+    SERVER_TREE = { mode: "server", copy: "tree" };
+    PREVIEWKIT_PRESET_CATALOG = {
+      nextjs: {
+        id: "nextjs",
+        label: "Next.js",
+        toolchain: "node",
+        detect: {
+          dependencies: ["next"],
+          configFiles: ["next.config.js", "next.config.mjs", "next.config.ts"]
+        },
+        buildCommand: "run build",
+        runCommand: "run start",
+        defaultPort: 3e3,
+        // `next start` needs `.next` + node_modules + config, so carry the whole
+        // built tree. (Standalone-output slimming is a later optimization.)
+        output: SERVER_TREE
+      },
+      nuxt: {
+        id: "nuxt",
+        label: "Nuxt",
+        toolchain: "node",
+        detect: {
+          dependencies: ["nuxt", "nuxt3"],
+          configFiles: ["nuxt.config.js", "nuxt.config.ts", "nuxt.config.mjs"]
+        },
+        buildCommand: "run build",
+        // Nuxt 3's default Nitro preset is a self-contained node server under
+        // `.output`; run it directly rather than through a package script.
+        runCommand: "node .output/server/index.mjs",
+        defaultPort: 3e3,
+        output: SERVER_TREE
+      },
+      sveltekit: {
+        id: "sveltekit",
+        label: "SvelteKit",
+        toolchain: "node",
+        detect: {
+          dependencies: ["@sveltejs/kit"],
+          configFiles: ["svelte.config.js"]
+        },
+        buildCommand: "run build",
+        // Assumes adapter-node (the previewkit-supported adapter): it emits a
+        // `build/` server started with `node build`. Apps on another adapter must
+        // override run_command / output_directory.
+        runCommand: "node build",
+        defaultPort: 3e3,
+        output: SERVER_TREE
+      },
+      remix: {
+        id: "remix",
+        label: "Remix",
+        toolchain: "node",
+        detect: {
+          dependencies: ["@remix-run/dev", "@remix-run/node", "@remix-run/serve"],
+          configFiles: ["remix.config.js"]
+        },
+        buildCommand: "run build",
+        runCommand: "run start",
+        defaultPort: 3e3,
+        output: SERVER_TREE
+      },
+      hono: {
+        id: "hono",
+        label: "Hono",
+        toolchain: "node",
+        detect: {
+          dependencies: ["hono"],
+          configFiles: []
+        },
+        buildCommand: "run build",
+        runCommand: "run start",
+        defaultPort: 3e3,
+        // Assumes the Node adapter (@hono/node-server). Edge / Workers / Bun
+        // deploys build differently and would override the run command.
+        output: SERVER_TREE
+      },
+      express: {
+        id: "express",
+        label: "Express",
+        toolchain: "node",
+        detect: {
+          dependencies: ["express"],
+          configFiles: []
+        },
+        // A plain-JS Express API: the derived dependency install is the only prep, so
+        // there is no build step. Assumes a `start` script; an app without one overrides
+        // run_command with its entry file (e.g. `node server.js`).
+        buildCommand: "",
+        runCommand: "run start",
+        defaultPort: 3e3,
+        output: SERVER_TREE
+      },
+      astro: {
+        id: "astro",
+        label: "Astro",
+        toolchain: "node",
+        detect: {
+          dependencies: ["astro"],
+          configFiles: ["astro.config.mjs", "astro.config.ts", "astro.config.js"]
+        },
+        buildCommand: "run build",
+        runCommand: "",
+        defaultPort: 80,
+        // Default Astro output is a static site in `dist`. An SSR Astro app (with a
+        // server adapter) must override output to server mode.
+        output: { mode: "static", dir: "dist" }
+      },
+      vite: {
+        id: "vite",
+        label: "Vite",
+        toolchain: "node",
+        detect: {
+          dependencies: ["vite"],
+          configFiles: ["vite.config.js", "vite.config.ts", "vite.config.mjs"]
+        },
+        buildCommand: "run build",
+        runCommand: "",
+        defaultPort: 80,
+        output: { mode: "static", dir: "dist" }
+      },
+      django: {
+        id: "django",
+        label: "Django",
+        toolchain: "python",
+        detect: {
+          dependencies: ["django", "Django"],
+          configFiles: ["manage.py"]
+        },
+        // No build step in dev mode (runserver serves static with DEBUG=True). For
+        // production, override build_command with `python manage.py collectstatic --noinput`.
+        buildCommand: "",
+        runCommand: "python manage.py runserver 0.0.0.0:$PORT",
+        defaultPort: 8e3,
+        output: SERVER_TREE
+      },
+      fastapi: {
+        id: "fastapi",
+        label: "FastAPI",
+        toolchain: "python",
+        detect: {
+          dependencies: ["fastapi"],
+          configFiles: []
+        },
+        buildCommand: "",
+        // Assumes the app object is `main:app`; override for another module path
+        // (e.g. `uvicorn app.main:app --host 0.0.0.0 --port $PORT`).
+        runCommand: "uvicorn main:app --host 0.0.0.0 --port $PORT",
+        defaultPort: 8e3,
+        output: SERVER_TREE
+      },
+      python: {
+        id: "python",
+        label: "Python",
+        toolchain: "python",
+        detect: {
+          dependencies: [],
+          configFiles: ["pyproject.toml", "requirements.txt", "Pipfile"]
+        },
+        // Dependency install (uv) is derived from the toolchain; most Python web
+        // apps have no separate build step.
+        buildCommand: "",
+        // Generic default - override run_command for your framework (e.g.
+        // `python manage.py runserver 0.0.0.0:$PORT`, `uvicorn main:app --port $PORT`).
+        runCommand: "python main.py",
+        defaultPort: 8e3,
+        output: SERVER_TREE
+      },
+      rails: {
+        id: "rails",
+        label: "Ruby on Rails",
+        toolchain: "ruby",
+        detect: {
+          dependencies: ["rails"],
+          configFiles: ["bin/rails", "config/application.rb"]
+        },
+        // No build step in development mode (assets compile on the fly). For
+        // production, override with `SECRET_KEY_BASE_DUMMY=1 bin/rails assets:precompile`.
+        buildCommand: "",
+        runCommand: "bin/rails server -b 0.0.0.0 -p $PORT",
+        defaultPort: 3e3,
+        output: SERVER_TREE
+      },
+      ruby: {
+        id: "ruby",
+        label: "Ruby",
+        toolchain: "ruby",
+        detect: {
+          dependencies: [],
+          configFiles: ["Gemfile", "config.ru", "Rakefile"]
+        },
+        // `bundle install` is derived from the toolchain; no separate build step.
+        buildCommand: "",
+        // Rack default - override for Rails (`bin/rails server -b 0.0.0.0 -p $PORT`).
+        runCommand: "bundle exec rackup --host 0.0.0.0 --port $PORT",
+        defaultPort: 9292,
+        output: SERVER_TREE
+      },
+      node: {
+        id: "node",
+        label: "Node.js",
+        toolchain: "node",
+        // Fallback for any package.json that matched no specific framework above.
+        detect: {
+          dependencies: [],
+          configFiles: ["package.json"]
+        },
+        buildCommand: "run build",
+        runCommand: "run start",
+        defaultPort: 3e3,
+        output: SERVER_TREE
+      },
+      static: {
+        id: "static",
+        label: "Static",
+        toolchain: "node",
+        // Last-resort fallback: a plain static site with no build step. The output
+        // directory is the most common thing to override.
+        detect: {
+          dependencies: [],
+          configFiles: ["index.html"]
+        },
+        buildCommand: "",
+        runCommand: "",
+        defaultPort: 80,
+        output: { mode: "static", dir: "." }
+      }
+    };
+    PREVIEWKIT_PRESETS = PREVIEWKIT_PRESET_IDS.map(
+      (id) => PREVIEWKIT_PRESET_CATALOG[id]
+    );
+  }
+});
+
 // ../../packages/types/src/schemas/previewkit-config.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 function buildResourcesSchema(role, allowCustomResources) {
   return resourcesInput.transform((input) => {
     if (!allowCustomResources || input == null) {
@@ -3363,65 +3599,96 @@ function buildResourcesSchema(role, allowCustomResources) {
     };
   });
 }
+function singleLineCommand(label) {
+  return z17.string().min(1).regex(/^[^\r\n]+$/, `${label} must be a single line (no line breaks)`);
+}
+function heredocSafeScript(label) {
+  return z17.string().min(1).refine(
+    (value) => !value.split("\n").includes(PREVIEWKIT_BUILD_SCRIPT_HEREDOC),
+    `${label} cannot contain a line equal to "${PREVIEWKIT_BUILD_SCRIPT_HEREDOC}" (reserved heredoc delimiter)`
+  );
+}
 function nodeFrameworkBuildSchema(framework) {
-  return z18.object({
-    framework: z18.literal(framework),
-    package_manager: z18.enum(["npm", "pnpm", "yarn"]).default("pnpm"),
-    node_version: z18.string().regex(nodeVersionRegex, "must look like 22, 22.5, or 22.5.0").default("22"),
-    install_command: z18.string().min(1).optional(),
-    build_command: z18.string().min(1).optional(),
-    run_command: z18.string().min(1).optional(),
+  return z17.object({
+    framework: z17.literal(framework),
+    package_manager: z17.enum(["npm", "pnpm", "yarn"]).default("pnpm"),
+    node_version: z17.string().regex(nodeVersionRegex, "must look like 22, 22.5, or 22.5.0").default("22"),
+    install_command: z17.string().min(1).optional(),
+    build_command: z17.string().min(1).optional(),
+    run_command: z17.string().min(1).optional(),
     build_context: buildContextSchema
   });
 }
 function buildPreviewConfigSchema(build, allowCustomResources) {
-  const appSchema = z18.object({
-    name: z18.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
-    path: z18.string().default("."),
-    build_context: z18.string().optional(),
-    dockerfile: z18.string().optional(),
+  const appSchema = z17.object({
+    name: z17.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
+    repository: z17.string().regex(repoFullNameRegex, "Must be an owner/repo full name").describe(
+      "The owner/repo full name of the GitHub repository this app builds from. Mandatory even in single-repo setups. Any value other than the application's own repository makes this app a multirepo dependency: that repo is cloned at the branch the branch_convention (or its repositories[] fallback_branch) resolves to."
+    ),
+    path: z17.string().default("."),
+    build_context: z17.string().optional(),
+    dockerfile: z17.string().optional(),
     build: build.optional(),
+    // The preset-based deploy model, mutually exclusive with `build` (enforced
+    // by the superRefine below). Lowered to a `runtime` Build by the generator.
+    blueprint: blueprintSchema.optional(),
     // The AWS-secret keys to also inject at build time (Docker build args).
     // Runtime secret values live in AWS Secrets Manager, never in this document.
-    build_secrets: z18.array(z18.string()).default([]),
-    port: z18.number().int().positive(),
+    build_secrets: z17.array(z17.string()).default([]),
+    port: z17.number().int().positive(),
     // Non-secret variables wired to the topology, resolved at deploy time.
     // All user-typed values are secrets (AWS), so they never appear here.
-    connections: z18.array(connectionSchema).default([]),
-    command: z18.string().optional(),
-    health_check: z18.string().optional(),
-    primary: z18.boolean().optional(),
+    connections: z17.array(connectionSchema).default([]),
+    command: z17.string().optional(),
+    health_check: z17.string().optional(),
+    primary: z17.boolean().optional(),
     // This app serves the Environment Factory handler (`/api/autonoma`), so
     // scenario up/down calls go to its preview URL. Independent of `primary`:
     // a full-stack app (Next.js, Rails) is both the browsed frontend and the
     // SDK host, while a split topology mounts the handler on its API service.
-    sdk_implemented: z18.boolean().optional(),
+    sdk_implemented: z17.boolean().optional(),
     resources: buildResourcesSchema("app", allowCustomResources),
-    depends_on: z18.array(z18.string()).optional()
+    depends_on: z17.array(z17.string()).optional()
+  }).superRefine((app, ctx) => {
+    if (app.build != null && app.blueprint != null) {
+      ctx.addIssue({
+        code: z17.ZodIssueCode.custom,
+        message: "an app cannot set both `build` and `blueprint` - `blueprint` is the preset-based deploy model, `build` is the manual one",
+        path: ["blueprint"]
+      });
+    }
   });
-  const serviceSchema = z18.object({
-    name: z18.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
-    recipe: z18.string(),
-    version: z18.string().optional(),
+  const serviceSchema = z17.object({
+    name: z17.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
+    recipe: z17.string(),
+    version: z17.string().optional(),
     // Recipe-functional knobs (e.g. postgres user/database, or a docker-image
     // service's image/ports/env) live in `options`, validated per-recipe.
-    options: z18.record(z18.string(), z18.unknown()).default({}),
+    options: z17.record(z17.string(), z17.unknown()).default({}),
     // Guided setup for database-recipe services (schema, seed, migrations),
     // run with the repo checked out. Empty for non-database services.
-    setup_tasks: z18.array(databaseSetupTaskSchema).default([]),
+    setup_tasks: z17.array(databaseSetupTaskSchema).default([]),
     resources: buildResourcesSchema("service", allowCustomResources),
-    s3: z18.boolean().optional(),
-    sqs: z18.boolean().optional(),
-    sns: z18.boolean().optional()
+    s3: z17.boolean().optional(),
+    sqs: z17.boolean().optional(),
+    sns: z17.boolean().optional()
   });
-  return z18.object({
-    version: z18.literal(1),
-    domain: z18.string().optional(),
-    registry: z18.string().optional(),
-    config: configSchema.optional(),
-    apps: z18.array(appSchema).min(1, "At least one app is required"),
-    services: z18.array(serviceSchema).default([]),
-    addons: z18.array(addonSchema).default([]),
+  return z17.object({
+    version: z17.literal(2),
+    domain: z17.string().optional(),
+    registry: z17.string().optional(),
+    // Per-repository overrides + deploy provenance; the repo set itself
+    // is derived from `apps[].repository`. See repositorySettingsSchema.
+    repositories: z17.array(repositorySettingsSchema).default([]).describe(
+      "Optional per-repository settings. The topology's repositories are derived from apps[].repository - an entry here only overrides defaults (fallback_branch: which branch to clone when the PR's branch does not exist in that repo; default main)."
+    ),
+    // Topology-wide: how a dependency repo's branch is derived from the
+    // PR's branch. Defaults to same_branch_name behavior when absent.
+    branch_convention: branchConventionSchema.optional().describe(
+      "How a dependency repo's branch is derived from the PR branch: same_branch_name (default), regex (pattern + replacement rewrite), or manual (always the fallback_branch)."
+    ),
+    apps: z17.array(appSchema).min(1, "At least one app is required"),
+    services: z17.array(serviceSchema).default([]),
     hooks: hooksSchema
   }).superRefine((cfg, ctx) => {
     const seen = /* @__PURE__ */ new Map();
@@ -3429,8 +3696,8 @@ function buildPreviewConfigSchema(build, allowCustomResources) {
       const existing = seen.get(name);
       if (existing != null) {
         ctx.addIssue({
-          code: z18.ZodIssueCode.custom,
-          message: `Name "${name}" is used by both a ${existing} and an ${kind} - names must be unique across apps, services, and addons`
+          code: z17.ZodIssueCode.custom,
+          message: `Name "${name}" is used by both a ${existing} and an ${kind} - names must be unique across apps and services`
         });
         return;
       }
@@ -3438,7 +3705,18 @@ function buildPreviewConfigSchema(build, allowCustomResources) {
     };
     for (const app of cfg.apps) check(app.name, "app");
     for (const service of cfg.services) check(service.name, "service");
-    for (const addon of cfg.addons) check(addon.name, "addon");
+    const seenRepos = /* @__PURE__ */ new Set();
+    cfg.repositories.forEach((settings, index) => {
+      const key = settings.repo.toLowerCase();
+      if (seenRepos.has(key)) {
+        ctx.addIssue({
+          code: z17.ZodIssueCode.custom,
+          path: ["repositories", index, "repo"],
+          message: `Repository "${settings.repo}" has more than one settings entry`
+        });
+      }
+      seenRepos.add(key);
+    });
   });
 }
 function standardResources(role) {
@@ -3449,12 +3727,14 @@ function standardResources(role) {
     memoryLimit: standard.memoryLimit
   };
 }
-var STANDARD_RESOURCES, k8sNameRegex, resourcesInput, addonSchema, branchConventionSchema, repoDependencySchema, multirepoConfigSchema, configSchema, hookStepSchema, hooksSchema, databaseSetupLocationSchema, databaseSetupTaskSchema, nodeVersionRegex, buildContextSchema, PREVIEWKIT_BUILD_SCRIPT_HEREDOC, DEPRECATED_BUILD_FRAMEWORKS, UNSUPPORTED_BUILD_METHOD_MESSAGE, deprecatedBuildArms, authoredBuildArms, authoredBuildSchema, storedBuildSchema, connectionSchema, previewConfigSchema, trustedPreviewConfigSchema, authoringPreviewConfigSchema;
+var STANDARD_RESOURCES, k8sNameRegex, repoFullNameRegex, resourcesInput, branchConventionSchema, repositorySettingsSchema, hookStepSchema, hooksSchema, databaseSetupLocationSchema, databaseSetupTaskSchema, nodeVersionRegex, buildContextSchema, PREVIEWKIT_BUILD_SCRIPT_HEREDOC, imageTagSchema, DEPRECATED_BUILD_FRAMEWORKS, UNSUPPORTED_BUILD_METHOD_MESSAGE, deprecatedBuildArms, authoredBuildArms, authoredBuildSchema, storedBuildSchema, presetBlueprintSchema, dockerfileBlueprintSchema, blueprintSchema, connectionSchema, previewConfigSchema, trustedPreviewConfigSchema, authoringPreviewConfigSchema;
 var init_previewkit_config = __esm({
   "../../packages/types/src/schemas/previewkit-config.ts"() {
     "use strict";
     init_esm_shims();
     init_previewkit_builtins();
+    init_previewkit_node_pm();
+    init_previewkit_presets();
     init_previewkit_runtimes();
     init_secrets();
     STANDARD_RESOURCES = {
@@ -3462,23 +3742,18 @@ var init_previewkit_config = __esm({
       service: { cpu: "100m", memoryRequest: "256Mi", memoryLimit: "1Gi" }
     };
     k8sNameRegex = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
-    resourcesInput = z18.object({
-      cpu: z18.string().optional(),
-      memory: z18.string().optional(),
-      memoryRequest: z18.string().optional(),
-      memoryLimit: z18.string().optional()
+    repoFullNameRegex = /^[^/\s]+\/[^/\s]+$/;
+    resourcesInput = z17.object({
+      cpu: z17.string().optional(),
+      memory: z17.string().optional(),
+      memoryRequest: z17.string().optional(),
+      memoryLimit: z17.string().optional()
     }).optional();
-    addonSchema = z18.object({
-      name: z18.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
-      provider: z18.string().min(1, "provider is required"),
-      auth_secret: z18.string().min(1, "auth_secret is required"),
-      options: z18.record(z18.string(), z18.unknown()).default({})
-    });
-    branchConventionSchema = z18.discriminatedUnion("type", [
-      z18.object({ type: z18.literal("same_branch_name") }),
-      z18.object({
-        type: z18.literal("regex"),
-        pattern: z18.string().refine((pattern) => {
+    branchConventionSchema = z17.discriminatedUnion("type", [
+      z17.object({ type: z17.literal("same_branch_name") }),
+      z17.object({
+        type: z17.literal("regex"),
+        pattern: z17.string().refine((pattern) => {
           try {
             new RegExp(pattern);
             return true;
@@ -3486,121 +3761,145 @@ var init_previewkit_config = __esm({
             return false;
           }
         }, "Invalid regular expression pattern"),
-        replacement: z18.string()
+        replacement: z17.string()
       }),
-      z18.object({ type: z18.literal("manual") })
+      z17.object({ type: z17.literal("manual") })
     ]);
-    repoDependencySchema = z18.object({
-      name: z18.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
-      repo: z18.string(),
-      fallback_branch: z18.string().default("main"),
+    repositorySettingsSchema = z17.object({
+      repo: z17.string().regex(repoFullNameRegex, "Must be an owner/repo full name"),
+      fallback_branch: z17.string().default("main"),
       /**
-       * The concrete commit SHA the dependency was deployed at. Absent in
-       * user-authored config: previewkit resolves the dependency's branch to a
-       * commit at deploy time and records it here by enriching the stored
+       * The concrete commit SHA the repository was deployed at. Absent in
+       * user-authored config: previewkit resolves each dependency repo's branch to
+       * a commit at deploy time and records it here by enriching the stored
        * `resolvedConfig` (deploy provenance, not authored input). Multi-repo
        * grounding reads this back to inspect the exact code that was live.
        */
-      sha: z18.string().optional()
-    });
-    multirepoConfigSchema = z18.object({
-      branch_convention: branchConventionSchema.optional(),
-      repos: z18.array(repoDependencySchema).default([])
+      sha: z17.string().optional()
     });
-    configSchema = z18.object({
-      multirepo: multirepoConfigSchema.optional()
+    hookStepSchema = z17.object({
+      app: z17.string(),
+      command: z17.string()
     });
-    hookStepSchema = z18.object({
-      app: z18.string(),
-      command: z18.string()
-    });
-    hooksSchema = z18.object({
-      pre_deploy: z18.array(hookStepSchema).default([]),
-      post_deploy: z18.array(hookStepSchema).default([])
+    hooksSchema = z17.object({
+      pre_deploy: z17.array(hookStepSchema).default([]),
+      post_deploy: z17.array(hookStepSchema).default([])
     }).default({ pre_deploy: [], post_deploy: [] });
-    databaseSetupLocationSchema = z18.discriminatedUnion("type", [
-      z18.object({
-        type: z18.literal("in_build"),
-        app: z18.string().min(1, "an app is required for an in-build task"),
-        position: z18.enum(["before", "after"])
+    databaseSetupLocationSchema = z17.discriminatedUnion("type", [
+      z17.object({
+        type: z17.literal("in_build"),
+        app: z17.string().min(1, "an app is required for an in-build task"),
+        position: z17.enum(["before", "after"])
       }),
-      z18.object({
-        type: z18.literal("separate_job"),
-        repo: z18.string().optional()
+      z17.object({
+        type: z17.literal("separate_job"),
+        repo: z17.string().optional()
       })
     ]);
-    databaseSetupTaskSchema = z18.object({
-      command: z18.string(),
-      frequency: z18.enum(["on_create", "every_commit"]),
+    databaseSetupTaskSchema = z17.object({
+      command: z17.string(),
+      frequency: z17.enum(["on_create", "every_commit"]),
       location: databaseSetupLocationSchema
     });
     nodeVersionRegex = /^\d+(\.\d+)?(\.\d+)?$/;
-    buildContextSchema = z18.enum(["app", "root"]).default("app");
+    buildContextSchema = z17.enum(["app", "root"]).default("app");
     PREVIEWKIT_BUILD_SCRIPT_HEREDOC = "AUTONOMA_BUILD_EOF";
+    imageTagSchema = z17.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "must be a valid image tag");
     DEPRECATED_BUILD_FRAMEWORKS = ["node", "next", "vite", "bun"];
     UNSUPPORTED_BUILD_METHOD_MESSAGE = `Unsupported build method. Use "runtime" (pick a runtime, then write a bash build_script and a single-line entrypoint) or "dockerfile" (build a Dockerfile committed in the repo). The ${DEPRECATED_BUILD_FRAMEWORKS.join(" / ")} framework presets are retired and can no longer be saved - express them as "runtime" with the install and build commands in build_script and the start command as entrypoint.`;
     deprecatedBuildArms = [
       nodeFrameworkBuildSchema("node"),
       nodeFrameworkBuildSchema("next"),
       nodeFrameworkBuildSchema("vite"),
-      z18.object({
-        framework: z18.literal("bun"),
-        install_command: z18.string().min(1).optional(),
-        build_command: z18.string().min(1).optional(),
-        run_command: z18.string().min(1).optional(),
+      z17.object({
+        framework: z17.literal("bun"),
+        install_command: z17.string().min(1).optional(),
+        build_command: z17.string().min(1).optional(),
+        run_command: z17.string().min(1).optional(),
         build_context: buildContextSchema
       })
     ];
     authoredBuildArms = [
-      z18.object({
-        framework: z18.literal("dockerfile"),
-        dockerfile: z18.string().min(1, "dockerfile path is required"),
-        target: z18.string().min(1).optional(),
+      z17.object({
+        framework: z17.literal("dockerfile"),
+        dockerfile: z17.string().min(1, "dockerfile path is required"),
+        target: z17.string().min(1).optional(),
         build_context: buildContextSchema
       }),
-      z18.object({
-        framework: z18.literal("runtime"),
-        runtime: z18.enum(PREVIEWKIT_RUNTIME_IDS),
+      z17.object({
+        framework: z17.literal("runtime"),
+        runtime: z17.enum(PREVIEWKIT_RUNTIME_IDS),
         // Image tag version, e.g. "22" for node. Optional - defaults to the
         // catalog's default per runtime. The user picks it so a repo pinned to an
         // older toolchain is not forced onto our default (which would defeat the
         // escape hatch). Constrained to a safe tag charset so it can never break
         // out of the generated `FROM` line.
-        version: z18.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "must be a valid image tag").optional(),
+        version: imageTagSchema.optional(),
         // Both are raw bash. `build_script` bakes into the image (cached); the
         // entrypoint is the container start command. `build_script` is optional
         // (some apps need no build step); `entrypoint` is required - the
         // container has to start somehow. `app.command` still overrides it at
         // deploy time.
-        build_script: z18.string().min(1).refine(
-          (script) => !script.split("\n").includes(PREVIEWKIT_BUILD_SCRIPT_HEREDOC),
-          `build script cannot contain a line equal to "${PREVIEWKIT_BUILD_SCRIPT_HEREDOC}" (reserved heredoc delimiter)`
-        ).optional(),
-        // The entrypoint is baked verbatim into a single-line `CMD`, so a newline
-        // would break out of the CMD and inject a bogus Dockerfile instruction
-        // (e.g. "npm start\nnode server.js"). Constrain it to one line; use a
-        // start script referenced from here if you need multiple commands.
-        entrypoint: z18.string().min(1, "entrypoint is required").regex(/^[^\r\n]+$/, "entrypoint must be a single line (no line breaks)"),
+        build_script: heredocSafeScript("build script").optional(),
+        entrypoint: singleLineCommand("entrypoint"),
         build_context: buildContextSchema
       })
     ];
-    authoredBuildSchema = z18.discriminatedUnion("framework", authoredBuildArms, {
+    authoredBuildSchema = z17.discriminatedUnion("framework", authoredBuildArms, {
       error: () => UNSUPPORTED_BUILD_METHOD_MESSAGE
     });
-    storedBuildSchema = z18.discriminatedUnion("framework", [...authoredBuildArms, ...deprecatedBuildArms]);
-    connectionSchema = z18.object({
+    storedBuildSchema = z17.discriminatedUnion("framework", [...authoredBuildArms, ...deprecatedBuildArms]);
+    presetBlueprintSchema = z17.object({
+      preset: z17.enum(PREVIEWKIT_PRESET_IDS),
+      // Overridable per app; each defaults from the preset (version from the runtime catalog).
+      version: imageTagSchema.optional(),
+      // These overrides flow into the generated Dockerfile via blueprintToBuild, so they
+      // carry the same guards as the `runtime` build arm: install/build concatenate into
+      // the build_script heredoc; run_command and output_directory reach the single-line CMD.
+      install_command: heredocSafeScript("install_command").optional(),
+      build_command: heredocSafeScript("build_command").optional(),
+      run_command: singleLineCommand("run_command").optional(),
+      // For static presets: the built output directory to serve (defaults to the preset's).
+      output_directory: singleLineCommand("output_directory").optional(),
+      // Monorepo: `root` builds from the repo root so sibling workspace packages resolve.
+      // Works for every preset: commands run in the app directory; node installs at the
+      // repo root (workspace linking) and builds through turbo's `--filter` when the repo
+      // has turbo. Absent = app context; no default is stamped in.
+      build_context: buildContextSchema.removeDefault().optional()
+    }).strict().superRefine((blueprint, ctx) => {
+      const toolchain = previewkitPresetSpec(blueprint.preset).toolchain;
+      if (toolchain === "node" && blueprint.version != null && !nodeVersionRegex.test(blueprint.version)) {
+        ctx.addIssue({
+          code: z17.ZodIssueCode.custom,
+          message: "version must look like 22, 22.5, or 22.5.0 for a node preset",
+          path: ["version"]
+        });
+      }
+    });
+    dockerfileBlueprintSchema = z17.object({
+      // Path to a committed Dockerfile, built as-is - ALWAYS relative to the app dir,
+      // whatever the build context (the pipeline resolves it against the context).
+      // `target` selects a stage in a multi-stage build.
+      dockerfile: z17.string().min(1, "dockerfile path is required"),
+      target: z17.string().min(1).optional(),
+      // Monorepo: `root` builds from the repo root (so a workspace-aware Dockerfile can reach
+      // sibling packages); `app` (absent) builds from the app dir.
+      build_context: buildContextSchema.removeDefault().optional()
+    }).strict();
+    blueprintSchema = z17.union([presetBlueprintSchema, dockerfileBlueprintSchema]);
+    connectionSchema = z17.object({
       key: SecretKeySchema.superRefine((key, ctx) => {
         if (isReservedPreviewkitEnvKey(key)) {
           ctx.addIssue({
-            code: z18.ZodIssueCode.custom,
+            code: z17.ZodIssueCode.custom,
             message: `${key} is a reserved built-in variable and cannot be set.`
           });
         }
       }).describe("The env var name to inject into the app at runtime (e.g. DATABASE_URL)."),
-      value: z18.string().min(1, "value is required").describe(
-        "Template resolved at deploy time. {{name.property}} tokens reference apps/services/addons in this config by name. For a service: {{db.url}} = the full canonical connection string (postgres -> postgresql://preview:preview@<host>:<port>/preview; redis -> redis://...; mongodb -> mongodb://...), {{db.host}} = in-cluster DNS name, {{db.port}}. For an app: {{api.url}} = its public HTTPS URL, {{api.hostname}}. For an addon: {{name.<outputKey>}} (e.g. a Neon connectionString). Also available: {{pr}}, {{namespace}}, {{owner}}. Tokens can mix with literal text ('postgresql://user:pass@{{db.host}}:5432/mydb'), or be a plain literal ('production'). Prefer {{db.url}} to wire a database."
+      value: z17.string().min(1, "value is required").describe(
+        "Template resolved at deploy time. {{name.property}} tokens reference apps/services in this config by name. For a service: {{db.url}} = the full canonical connection string (postgres -> postgresql://preview:preview@<host>:<port>/preview; redis -> redis://...; mongodb -> mongodb://...), {{db.host}} = in-cluster DNS name, {{db.port}}. For an app: {{api.url}} = its public HTTPS URL, {{api.hostname}}. Also available: {{pr}}, {{namespace}}, {{owner}}. Tokens can mix with literal text ('postgresql://user:pass@{{db.host}}:5432/mydb'), or be a plain literal ('production'). Prefer {{db.url}} to wire a database."
       ),
-      build_time: z18.boolean().default(false).describe("Also pass the resolved value as a Docker build arg.")
+      build_time: z17.boolean().default(false).describe("Also pass the resolved value as a Docker build arg.")
     });
     previewConfigSchema = buildPreviewConfigSchema(storedBuildSchema, false);
     trustedPreviewConfigSchema = buildPreviewConfigSchema(storedBuildSchema, true);
@@ -3608,6 +3907,68 @@ var init_previewkit_config = __esm({
   }
 });
 
+// ../../packages/types/src/schemas/previewkit-job-spec.ts
+import { z as z18 } from "zod";
+var deployTargetSchema, redeployTargetSchema, teardownTargetSchema, previewJobSpecSchema;
+var init_previewkit_job_spec = __esm({
+  "../../packages/types/src/schemas/previewkit-job-spec.ts"() {
+    "use strict";
+    init_esm_shims();
+    deployTargetSchema = z18.object({
+      repoFullName: z18.string().min(1),
+      prNumber: z18.number().int().nonnegative(),
+      organizationId: z18.string().min(1),
+      githubRepositoryId: z18.number().int(),
+      headSha: z18.string().min(1),
+      headRef: z18.string().min(1),
+      branchId: z18.string().optional()
+    });
+    redeployTargetSchema = z18.object({
+      repoFullName: z18.string().min(1),
+      prNumber: z18.number().int().nonnegative(),
+      organizationId: z18.string().min(1),
+      githubRepositoryId: z18.number().int(),
+      headSha: z18.string().min(1),
+      headRef: z18.string().min(1)
+    });
+    teardownTargetSchema = z18.object({
+      repoFullName: z18.string().min(1),
+      prNumber: z18.number().int().nonnegative(),
+      organizationId: z18.string().min(1),
+      headSha: z18.string().min(1).optional()
+    });
+    previewJobSpecSchema = z18.discriminatedUnion("mode", [
+      z18.object({ mode: z18.literal("deploy"), target: deployTargetSchema }),
+      z18.object({ mode: z18.literal("teardown"), target: teardownTargetSchema }),
+      z18.object({
+        mode: z18.literal("redeploy-app"),
+        target: redeployTargetSchema,
+        namespace: z18.string().min(1),
+        appName: z18.string().min(1),
+        redeployMode: z18.enum(["rebuild", "restart"])
+      })
+    ]);
+  }
+});
+
+// ../../packages/types/src/schemas/previewkit-node-build.ts
+var init_previewkit_node_build = __esm({
+  "../../packages/types/src/schemas/previewkit-node-build.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_previewkit_node_pm();
+  }
+});
+
+// ../../packages/types/src/schemas/previewkit-authorable-config.ts
+var init_previewkit_authorable_config = __esm({
+  "../../packages/types/src/schemas/previewkit-authorable-config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_previewkit_node_build();
+  }
+});
+
 // ../../packages/types/src/schemas/previewkit-redeploy-app.ts
 import { z as z19 } from "zod";
 var RedeployPreviewkitAppInputSchema;
@@ -3769,138 +4130,15 @@ var init_snapshot_dependency_pin = __esm({
   }
 });
 
-// ../../packages/types/src/schemas/healing-actions.ts
-import { z as z24 } from "zod";
-var reviewSeveritySchema, primaryScreenshotRefSchema, evidenceItemSchema, healingReviewLinkSchema, updatePlanActionSchema, reportBugActionSchema, reportEngineLimitationActionSchema, reportUnknownIssueActionSchema, reportScenarioUnsupportedActionSchema, removeTestActionSchema, healingActionSchema, issueReportInputSchema, updatePlanInputSchema, reportBugInputSchema, reportEngineLimitationInputSchema, reportUnknownIssueInputSchema, reportScenarioUnsupportedInputSchema, removeTestInputSchema;
-var init_healing_actions = __esm({
-  "../../packages/types/src/schemas/healing-actions.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_issue_report();
-    init_suspected_cause();
-    reviewSeveritySchema = z24.enum(["critical", "high", "medium", "low"]);
-    primaryScreenshotRefSchema = z24.object({
-      stepOrder: z24.number().int().min(0).describe("The step order (from the failure's Execution steps / fetch_step_evidence) whose frame to feature."),
-      timing: z24.enum(["before", "after"]).describe("Which captured frame of that step best shows the bug: the screenshot before or after the step ran.")
-    });
-    evidenceItemSchema = z24.object({
-      type: z24.enum(["screenshot", "video", "conversation", "step_output"]),
-      description: z24.string(),
-      s3Key: z24.string().optional()
-    });
-    healingReviewLinkSchema = z24.object({ generationReviewId: z24.string() });
-    updatePlanActionSchema = z24.object({
-      kind: z24.literal("update_plan"),
-      planId: z24.string().describe("ID of the test plan to update"),
-      testCaseId: z24.string().describe("ID of the test case the plan belongs to"),
-      newPrompt: z24.string().describe("Replacement plan prompt - the natural language test instruction"),
-      reasoning: z24.string().describe("Why this rewrite addresses the failure")
-    });
-    reportBugActionSchema = z24.object({
-      kind: z24.literal("report_bug"),
-      testCaseId: z24.string().describe("ID of the test case that surfaced the bug"),
-      title: z24.string().describe("Short bug title"),
-      description: z24.string().describe("Full bug description with reproduction steps and root cause hypothesis"),
-      severity: reviewSeveritySchema,
-      evidence: z24.array(evidenceItemSchema).describe("Screenshots, videos, step outputs supporting the bug report"),
-      reasoning: z24.string().describe("Why this is an application bug rather than a test or engine issue"),
-      suspectedCause: suspectedCauseSchema.describe(
-        "The concrete code cause you re-grounded independently (>= 1 code reference). If you cannot reproduce the cause in the checked-out code, downgrade to report_unknown_issue instead of reporting a bug."
-      ),
-      // The persisted report carries the full shape (authored text + the
-      // system-derived evidenceManifest the report tool attaches from the agent's
-      // actual fetches). Optional so actions persisted without a report still parse
-      // (loadPriorActions / eval fixtures); the tool input (reportBugInputSchema)
-      // re-declares an authored (manifest-free) report as required, so every new
-      // report_bug carries one and the manifest is never model-authored.
-      report: issueReportSchema.optional().describe(
-        "The customer-facing, evidence-grounded report shown on the bug page: Expected vs Actual plus a rich narrative. Author it from the evidence you fetched with fetch_step_evidence, not from the plan text alone."
-      ),
-      reviewLink: healingReviewLinkSchema
-    });
-    reportEngineLimitationActionSchema = z24.object({
-      kind: z24.literal("report_engine_limitation"),
-      testCaseId: z24.string().describe("ID of the test case that surfaced the limitation"),
-      title: z24.string(),
-      description: z24.string().describe("What the engine/agent could not do, and why no workaround is feasible"),
-      severity: reviewSeveritySchema,
-      evidence: z24.array(evidenceItemSchema),
-      reasoning: z24.string(),
-      reviewLink: healingReviewLinkSchema
-    });
-    reportUnknownIssueActionSchema = z24.object({
-      kind: z24.literal("report_unknown_issue"),
-      testCaseId: z24.string().describe("ID of the test case that surfaced the suspected issue"),
-      title: z24.string(),
-      description: z24.string().describe("What the application appeared to do wrong, and why the cause could not be grounded in the code"),
-      severity: reviewSeveritySchema,
-      evidence: z24.array(evidenceItemSchema),
-      reasoning: z24.string().describe("Why this is a suspected issue you could not ground in code rather than a confirmed application bug"),
-      reviewLink: healingReviewLinkSchema
-    });
-    reportScenarioUnsupportedActionSchema = z24.object({
-      kind: z24.literal("report_scenario_unsupported"),
-      testCaseId: z24.string().describe("ID of the test case that is impossible given the current scenario data"),
-      title: z24.string(),
-      description: z24.string().describe(
-        "What the test needs that the scenario data cannot currently provide, with the proposed scenario extension woven in as prose - surfaced verbatim to a human, who decides whether to extend the scenario"
-      ),
-      severity: reviewSeveritySchema,
-      evidence: z24.array(evidenceItemSchema),
-      reasoning: z24.string().describe(
-        "Why this test is impossible given the current scenario data (a true data gap) rather than a stale plan that should be rewritten"
-      ),
-      reviewLink: healingReviewLinkSchema
-    });
-    removeTestActionSchema = z24.object({
-      kind: z24.literal("remove_test"),
-      testCaseId: z24.string().describe("ID of the test case to delete from the suite"),
-      reason: z24.string().describe(
-        "Why this test should be removed: either it is invalid (not a viable flow, never useful without becoming a different test) or its feature was deleted from the app"
-      ),
-      evidence: z24.array(evidenceItemSchema).optional().describe("Optional screenshots, videos, step outputs supporting the removal"),
-      reviewLink: healingReviewLinkSchema
-    });
-    healingActionSchema = z24.discriminatedUnion("kind", [
-      updatePlanActionSchema,
-      reportBugActionSchema,
-      reportEngineLimitationActionSchema,
-      reportUnknownIssueActionSchema,
-      reportScenarioUnsupportedActionSchema,
-      removeTestActionSchema
-    ]);
-    issueReportInputSchema = authoredIssueReportSchema.extend({
-      primaryScreenshot: primaryScreenshotRefSchema.optional().describe(
-        "Optional: the frame that best shows the bug, referenced by the step you inspected with fetch_step_evidence (its order + before/after). Designate one when a step's frame shows the bug more clearly than the mechanical failing step; omit it to let the page fall back to the failing-step screenshot. Do not invent a step you did not fetch."
-      )
-    });
-    updatePlanInputSchema = updatePlanActionSchema.omit({ kind: true });
-    reportBugInputSchema = reportBugActionSchema.omit({ kind: true, reviewLink: true }).extend({ report: issueReportInputSchema });
-    reportEngineLimitationInputSchema = reportEngineLimitationActionSchema.omit({
-      kind: true,
-      reviewLink: true
-    });
-    reportUnknownIssueInputSchema = reportUnknownIssueActionSchema.omit({
-      kind: true,
-      reviewLink: true
-    });
-    reportScenarioUnsupportedInputSchema = reportScenarioUnsupportedActionSchema.omit({
-      kind: true,
-      reviewLink: true
-    });
-    removeTestInputSchema = removeTestActionSchema.omit({ kind: true, reviewLink: true });
-  }
-});
-
 // ../../packages/types/src/schemas/checkpoint-summary.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 var checkpointToneSchema, checkpointExecutionStateSchema, checkpointTestCountsSchema, checkpointFailingByKindSchema, checkpointAnalysisSummarySchema, checkpointPresentationSummarySchema;
 var init_checkpoint_summary = __esm({
   "../../packages/types/src/schemas/checkpoint-summary.ts"() {
     "use strict";
     init_esm_shims();
-    checkpointToneSchema = z25.enum(["success", "critical", "warning", "neutral"]);
-    checkpointExecutionStateSchema = z25.enum([
+    checkpointToneSchema = z24.enum(["success", "critical", "warning", "neutral"]);
+    checkpointExecutionStateSchema = z24.enum([
       "not_started",
       "running",
       "stale",
@@ -3909,43 +4147,43 @@ var init_checkpoint_summary = __esm({
       "pipeline_failed",
       "unknown"
     ]);
-    checkpointTestCountsSchema = z25.object({
-      assigned: z25.number(),
-      run: z25.number(),
-      passed: z25.number(),
-      failed: z25.number(),
+    checkpointTestCountsSchema = z24.object({
+      assigned: z24.number(),
+      run: z24.number(),
+      passed: z24.number(),
+      failed: z24.number(),
       // Tests that never ran because their scenario setup failed.
-      setupFailed: z25.number(),
-      running: z25.number(),
-      notRun: z25.number()
+      setupFailed: z24.number(),
+      running: z24.number(),
+      notRun: z24.number()
     });
-    checkpointFailingByKindSchema = z25.object({
-      engine: z25.number(),
-      app: z25.number()
+    checkpointFailingByKindSchema = z24.object({
+      engine: z24.number(),
+      app: z24.number()
     });
-    checkpointAnalysisSummarySchema = z25.object({
+    checkpointAnalysisSummarySchema = z24.object({
       // The AnalysisJob lifecycle. Mirrors the `AnalysisJobStatus` db enum (types cannot import it).
-      jobStatus: z25.enum(["running", "completed", "failed"]),
+      jobStatus: z24.enum(["running", "completed", "failed"]),
       // Client-bug findings - the only plane that counts against the PR (turns the checkpoint red).
-      bugCount: z25.number().int().nonnegative(),
+      bugCount: z24.number().int().nonnegative(),
       // Findings that passed on the app-health plane.
-      passedCount: z25.number().int().nonnegative(),
+      passedCount: z24.number().int().nonnegative(),
       // Coverage-plane findings (engine_artifact / environment_failure / scenario_issue / delete) - never a
       // failure; surfaced as "couldn't confirm".
-      coverageCount: z25.number().int().nonnegative()
+      coverageCount: z24.number().int().nonnegative()
     });
-    checkpointPresentationSummarySchema = z25.object({
+    checkpointPresentationSummarySchema = z24.object({
       tone: checkpointToneSchema,
-      label: z25.string(),
-      reason: z25.string().optional(),
+      label: z24.string(),
+      reason: z24.string().optional(),
       executionState: checkpointExecutionStateSchema,
       // Unique open application bugs.
-      openBugCount: z25.number(),
+      openBugCount: z24.number(),
       // Raw application-issue occurrences.
-      issueOccurrenceCount: z25.number(),
+      issueOccurrenceCount: z24.number(),
       testCounts: checkpointTestCountsSchema,
       failingByKind: checkpointFailingByKindSchema,
-      suiteChangeCount: z25.number(),
+      suiteChangeCount: z24.number(),
       // Set only for authoritative-analysis snapshots; absent for legacy diffs/shadow snapshots.
       analysis: checkpointAnalysisSummarySchema.optional()
     });
@@ -3953,96 +4191,82 @@ var init_checkpoint_summary = __esm({
 });
 
 // ../../packages/types/src/schemas/snapshot-report.ts
-import { z as z26 } from "zod";
-var reportHealthSchema, reportTestStatusSchema, reportCommitFileSchema, snapshotReportTriggerSchema, snapshotReportSelectedTestSchema, snapshotReportSelectionSchema, snapshotReportTestResultSchema, snapshotReportResultsSchema, snapshotReportBugSchema, snapshotReportHealthCountsSchema, snapshotReportSchema;
+import { z as z25 } from "zod";
+var reportHealthSchema, reportTestStatusSchema, reportCommitFileSchema, snapshotReportTriggerSchema, snapshotReportTestResultSchema, snapshotReportResultsSchema, snapshotReportBugSchema, snapshotReportHealthCountsSchema, snapshotReportSchema;
 var init_snapshot_report = __esm({
   "../../packages/types/src/schemas/snapshot-report.ts"() {
     "use strict";
     init_esm_shims();
     init_checkpoint_summary();
-    reportHealthSchema = z26.enum(["healthy", "critical", "running", "unknown"]);
-    reportTestStatusSchema = z26.enum(["passed", "failed", "setup_failed", "running", "pending"]);
-    reportCommitFileSchema = z26.object({
-      filename: z26.string(),
-      status: z26.string(),
-      additions: z26.number(),
-      deletions: z26.number()
-    });
-    snapshotReportTriggerSchema = z26.object({
-      headSha: z26.string().optional(),
-      baseSha: z26.string().optional(),
-      source: z26.string(),
-      createdAt: z26.date(),
-      commit: z26.object({ message: z26.string(), authorLogin: z26.string().optional() }).optional(),
-      filesChanged: z26.array(reportCommitFileSchema),
-      filesChangedTruncated: z26.boolean()
-    });
-    snapshotReportSelectedTestSchema = z26.object({
-      testCaseId: z26.string(),
-      name: z26.string(),
-      slug: z26.string(),
-      affectedReason: z26.string().optional(),
-      reasoning: z26.string().optional()
-    });
-    snapshotReportSelectionSchema = z26.object({
-      totalSuiteTests: z26.number(),
-      selected: z26.array(snapshotReportSelectedTestSchema),
-      analysisReasoning: z26.string().optional()
-    });
-    snapshotReportTestResultSchema = z26.object({
-      testCaseId: z26.string(),
-      name: z26.string(),
-      slug: z26.string(),
+    reportHealthSchema = z25.enum(["healthy", "critical", "running", "unknown"]);
+    reportTestStatusSchema = z25.enum(["passed", "failed", "setup_failed", "running", "pending"]);
+    reportCommitFileSchema = z25.object({
+      filename: z25.string(),
+      status: z25.string(),
+      additions: z25.number(),
+      deletions: z25.number()
+    });
+    snapshotReportTriggerSchema = z25.object({
+      headSha: z25.string().optional(),
+      baseSha: z25.string().optional(),
+      source: z25.string(),
+      createdAt: z25.date(),
+      commit: z25.object({ message: z25.string(), authorLogin: z25.string().optional() }).optional(),
+      filesChanged: z25.array(reportCommitFileSchema),
+      filesChangedTruncated: z25.boolean()
+    });
+    snapshotReportTestResultSchema = z25.object({
+      testCaseId: z25.string(),
+      name: z25.string(),
+      slug: z25.string(),
       status: reportTestStatusSchema,
-      runId: z26.string().optional(),
-      durationMs: z26.number().optional()
-    });
-    snapshotReportResultsSchema = z26.object({
-      durationMs: z26.number().optional(),
-      passed: z26.number(),
-      failed: z26.number(),
-      setupFailed: z26.number(),
-      pending: z26.number(),
-      running: z26.number(),
-      total: z26.number(),
-      tests: z26.array(snapshotReportTestResultSchema)
-    });
-    snapshotReportBugSchema = z26.object({
-      bugId: z26.string(),
-      title: z26.string(),
-      description: z26.string(),
-      severity: z26.string(),
-      status: z26.string(),
-      occurrences: z26.number(),
-      testSlug: z26.string().optional(),
-      stepIndex: z26.number().optional(),
-      stepTotal: z26.number().optional(),
-      screenshotUrl: z26.string().optional(),
-      issueId: z26.string().optional()
-    });
-    snapshotReportHealthCountsSchema = z26.object({
-      failing: z26.number(),
-      passing: z26.number(),
-      running: z26.number(),
-      setupFailed: z26.number(),
-      notAffected: z26.number(),
-      totalTests: z26.number()
-    });
-    snapshotReportSchema = z26.object({
-      snapshot: z26.object({
-        id: z26.string(),
-        status: z26.string(),
-        source: z26.string(),
-        headSha: z26.string().optional(),
-        baseSha: z26.string().optional(),
-        createdAt: z26.date(),
-        branch: z26.object({ id: z26.string(), name: z26.string(), prNumber: z26.number().optional() })
+      runId: z25.string().optional(),
+      durationMs: z25.number().optional()
+    });
+    snapshotReportResultsSchema = z25.object({
+      durationMs: z25.number().optional(),
+      passed: z25.number(),
+      failed: z25.number(),
+      setupFailed: z25.number(),
+      pending: z25.number(),
+      running: z25.number(),
+      total: z25.number(),
+      tests: z25.array(snapshotReportTestResultSchema)
+    });
+    snapshotReportBugSchema = z25.object({
+      bugId: z25.string(),
+      title: z25.string(),
+      description: z25.string(),
+      severity: z25.string(),
+      status: z25.string(),
+      occurrences: z25.number(),
+      testSlug: z25.string().optional(),
+      stepIndex: z25.number().optional(),
+      stepTotal: z25.number().optional(),
+      screenshotUrl: z25.string().optional(),
+      issueId: z25.string().optional()
+    });
+    snapshotReportHealthCountsSchema = z25.object({
+      failing: z25.number(),
+      passing: z25.number(),
+      running: z25.number(),
+      setupFailed: z25.number(),
+      notAffected: z25.number(),
+      totalTests: z25.number()
+    });
+    snapshotReportSchema = z25.object({
+      snapshot: z25.object({
+        id: z25.string(),
+        status: z25.string(),
+        source: z25.string(),
+        headSha: z25.string().optional(),
+        baseSha: z25.string().optional(),
+        createdAt: z25.date(),
+        branch: z25.object({ id: z25.string(), name: z25.string(), prNumber: z25.number().optional() })
       }),
       trigger: snapshotReportTriggerSchema,
-      selection: snapshotReportSelectionSchema,
       results: snapshotReportResultsSchema,
-      bugs: z26.array(snapshotReportBugSchema),
-      firstIterationReasoning: z26.string().optional(),
+      bugs: z25.array(snapshotReportBugSchema),
       health: reportHealthSchema,
       healthCounts: snapshotReportHealthCountsSchema,
       summary: checkpointPresentationSummarySchema.optional()
@@ -4051,55 +4275,74 @@ var init_snapshot_report = __esm({
 });
 
 // ../../packages/types/src/schemas/pr-pipeline-status.ts
-import { z as z27 } from "zod";
+import { z as z26 } from "zod";
 var prPipelineStatusSchema;
 var init_pr_pipeline_status = __esm({
   "../../packages/types/src/schemas/pr-pipeline-status.ts"() {
     "use strict";
     init_esm_shims();
     init_checkpoint_summary();
-    prPipelineStatusSchema = z27.discriminatedUnion("kind", [
-      z27.object({ kind: z27.literal("checkpoint"), summary: checkpointPresentationSummarySchema }),
-      z27.object({ kind: z27.literal("building") }),
-      z27.object({ kind: z27.literal("pending_checks") }),
-      z27.object({ kind: z27.literal("analyzing") }),
-      z27.object({ kind: z27.literal("analysis_failed") }),
-      z27.object({ kind: z27.literal("build_failed") }),
-      z27.object({ kind: z27.literal("none") })
+    prPipelineStatusSchema = z26.discriminatedUnion("kind", [
+      z26.object({ kind: z26.literal("checkpoint"), summary: checkpointPresentationSummarySchema }),
+      z26.object({ kind: z26.literal("building") }),
+      z26.object({ kind: z26.literal("pending_checks") }),
+      z26.object({ kind: z26.literal("analyzing") }),
+      z26.object({ kind: z26.literal("analysis_failed") }),
+      z26.object({ kind: z26.literal("build_failed") }),
+      z26.object({ kind: z26.literal("none") })
     ]);
   }
 });
 
 // ../../packages/types/src/schemas/bug-detail.ts
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 var runAnalysisSchema, pointSchema2, stepOutputDataSchema, bugOccurrenceSchema;
 var init_bug_detail = __esm({
   "../../packages/types/src/schemas/bug-detail.ts"() {
     "use strict";
     init_esm_shims();
     init_generation_verdict();
-    runAnalysisSchema = z28.object({
+    runAnalysisSchema = z27.object({
       failurePoint: failurePointSchema.optional(),
-      evidence: z28.array(reviewEvidenceSchema).default([])
+      evidence: z27.array(reviewEvidenceSchema).default([])
     });
-    pointSchema2 = z28.object({ x: z28.number(), y: z28.number() });
-    stepOutputDataSchema = z28.object({
-      outcome: z28.string().optional(),
+    pointSchema2 = z27.object({ x: z27.number(), y: z27.number() });
+    stepOutputDataSchema = z27.object({
+      outcome: z27.string().optional(),
       point: pointSchema2.optional(),
       startPoint: pointSchema2.optional(),
       endPoint: pointSchema2.optional()
     });
-    bugOccurrenceSchema = z28.object({
-      issueId: z28.string(),
-      source: z28.enum(["run", "generation"]),
-      runId: z28.string().optional(),
-      generationId: z28.string().optional(),
-      createdAt: z28.date(),
-      isLatest: z28.boolean(),
-      snapshotId: z28.string().optional(),
-      sha: z28.string().optional(),
-      prNumber: z28.number().optional(),
-      branchName: z28.string().optional()
+    bugOccurrenceSchema = z27.object({
+      issueId: z27.string(),
+      source: z27.enum(["run", "generation"]),
+      runId: z27.string().optional(),
+      generationId: z27.string().optional(),
+      createdAt: z27.date(),
+      isLatest: z27.boolean(),
+      snapshotId: z27.string().optional(),
+      sha: z27.string().optional(),
+      prNumber: z27.number().optional(),
+      branchName: z27.string().optional()
+    });
+  }
+});
+
+// ../../packages/types/src/schemas/activation-triggers.ts
+import { z as z28 } from "zod";
+var MAX_LABEL_LENGTH, CONTROL_CHARS, AnalysisTriggerLabelSchema, TriggerConfigSchema;
+var init_activation_triggers = __esm({
+  "../../packages/types/src/schemas/activation-triggers.ts"() {
+    "use strict";
+    init_esm_shims();
+    MAX_LABEL_LENGTH = 50;
+    CONTROL_CHARS = /[\u0000-\u001F\u007F]/;
+    AnalysisTriggerLabelSchema = z28.string().trim().min(1, "Label cannot be empty").max(MAX_LABEL_LENGTH, `Label must be at most ${MAX_LABEL_LENGTH} characters`).refine((value) => !CONTROL_CHARS.test(value), "Label cannot contain control characters");
+    TriggerConfigSchema = z28.object({
+      /** Whether marking a PR ready-for-review automatically starts an analysis run. */
+      autoRunOnReadyForReview: z28.boolean(),
+      /** The PR label whose addition starts an analysis run. */
+      analysisTriggerLabel: AnalysisTriggerLabelSchema
     });
   }
 });
@@ -4254,21 +4497,25 @@ var init_schemas = __esm({
     init_generation();
     init_api_key();
     init_secrets();
-    init_org_secrets();
     init_previewkit_builtins();
     init_previewkit_config();
+    init_previewkit_job_spec();
+    init_previewkit_node_build();
+    init_previewkit_node_pm();
+    init_previewkit_presets();
+    init_previewkit_authorable_config();
     init_previewkit_runtimes();
     init_previewkit_redeploy_app();
     init_previewkit_service_suggestion();
     init_previewkit_env_suggestion();
     init_previewkit_diagnosis();
     init_snapshot_dependency_pin();
-    init_healing_actions();
     init_snapshot_report();
     init_checkpoint_summary();
     init_pr_pipeline_status();
     init_bug_detail();
     init_investigation_report();
+    init_activation_triggers();
     init_suite_health();
     init_suite_health_fix_plan();
     PlatformSchema = z31.enum(["web", "ios", "android"]);
@@ -4463,6 +4710,14 @@ var init_designated_run = __esm({
   }
 });
 
+// ../../packages/types/src/deployment-signal-template.ts
+var init_deployment_signal_template = __esm({
+  "../../packages/types/src/deployment-signal-template.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"() {
@@ -4497,6 +4752,32 @@ var init_previewkit = __esm({
   }
 });
 
+// ../../packages/types/src/types/parse-string-record.ts
+var init_parse_string_record = __esm({
+  "../../packages/types/src/types/parse-string-record.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/types/src/types/previewkit-manifest.ts
+var init_previewkit_manifest = __esm({
+  "../../packages/types/src/types/previewkit-manifest.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_previewkit_config();
+  }
+});
+
+// ../../packages/types/src/types/previewkit-preview-urls.ts
+var init_previewkit_preview_urls = __esm({
+  "../../packages/types/src/types/previewkit-preview-urls.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_previewkit_config();
+  }
+});
+
 // ../../packages/types/src/index.ts
 var init_src = __esm({
   "../../packages/types/src/index.ts"() {
@@ -4510,10 +4791,14 @@ var init_src = __esm({
     init_preview_url();
     init_app_links();
     init_designated_run();
+    init_deployment_signal_template();
     init_constants();
     init_architecture();
     init_step_overlay_points();
     init_previewkit();
+    init_parse_string_record();
+    init_previewkit_manifest();
+    init_previewkit_preview_urls();
   }
 });
 
@@ -4521,7 +4806,9 @@ var init_src = __esm({
 import { readFile as readFile2 } from "fs/promises";
 import { join as join6 } from "path";
 async function loadRecipe(outputDir) {
-  const path3 = join6(outputDir, RECIPE_FILE);
+  return await loadRecipeFile(join6(outputDir, RECIPE_FILE));
+}
+async function loadRecipeFile(path3) {
   let raw;
   try {
     raw = await readFile2(path3, "utf-8");
@@ -4535,19 +4822,35 @@ async function loadRecipe(outputDir) {
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     debugLog("recipe.json is not valid JSON", { path: path3, err });
-    return { status: "invalid", problems: [`${RECIPE_FILE} is not valid JSON: ${message}`] };
+    return { status: "invalid", problems: [`${path3} is not valid JSON: ${message}`] };
   }
-  const parsed = ScenarioRecipesFileSchema.safeParse(withValidationCeremony(json));
+  const normalized = withValidationCeremony(json);
+  const parsed = ScenarioRecipesFileSchema.safeParse(normalized);
   if (!parsed.success) {
-    const problems = parsed.error.issues.map((issue) => {
-      const path4 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-      return `${path4}: ${issue.message}`;
-    });
+    const problems = parsed.error.issues.map((issue) => describeIssue(issue, normalized));
     debugLog("recipe.json failed schema validation", { path: path3, problems });
     return { status: "invalid", problems };
   }
   return { status: "ok", recipe: parsed.data };
 }
+function describeIssue(issue, root) {
+  const field = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+  const found = valueAtPath(root, issue.path);
+  if (found === void 0) return `${field}: ${issue.message}`;
+  return `${field}: ${issue.message} (found: ${JSON.stringify(found)})`;
+}
+function valueAtPath(root, path3) {
+  let current = root;
+  for (const key of path3) {
+    if (Array.isArray(current) && typeof key === "number") {
+      current = current[key];
+      continue;
+    }
+    if (!isRecord(current)) return void 0;
+    current = current[String(key)];
+  }
+  return current;
+}
 function findRecipeUploadProblems(recipe) {
   return recipe.recipes.flatMap((entry) => {
     const declaredTokens = new Set(Object.keys(entry.variables ?? {}));
@@ -4569,14 +4872,18 @@ function withValidationCeremony(json) {
       ...entry,
       validation: {
         ...validation,
-        status: validation.status ?? VALIDATION_STATUS,
-        phase: validation.phase ?? VALIDATION_PHASE
+        status: VALIDATION_STATUS,
+        phase: VALIDATION_PHASE,
+        method: isKnownValidationMethod(validation.method) ? validation.method : VALIDATION_METHOD
       }
     };
   });
   return { ...json, recipes };
 }
-var RECIPE_FILE, VALIDATION_STATUS, VALIDATION_PHASE;
+function isKnownValidationMethod(method) {
+  return typeof method === "string" && VALIDATION_METHODS.has(method);
+}
+var RECIPE_FILE, VALIDATION_STATUS, VALIDATION_PHASE, VALIDATION_METHOD, VALIDATION_METHODS;
 var init_recipe = __esm({
   "src/agents/04-recipe-builder/recipe.ts"() {
     "use strict";
@@ -4586,6 +4893,8 @@ var init_recipe = __esm({
     RECIPE_FILE = "recipe.json";
     VALIDATION_STATUS = "validated";
     VALIDATION_PHASE = "ok";
+    VALIDATION_METHOD = "endpoint-up-down";
+    VALIDATION_METHODS = new Set(SCENARIO_VALIDATION_METHODS);
   }
 });
 
@@ -4700,6 +5009,11 @@ var init_submit = __esm({
 function resolveApiUrl(override) {
   return (override ?? DEFAULT_API_URL).replace(/\/+$/, "");
 }
+function resolveMcpUrl(apiUrl) {
+  const base = apiUrl.replace(/\/+$/, "");
+  if (base !== DEFAULT_API_URL) return `${base}/v1/mcp`;
+  return `https://api.${new URL(DEFAULT_API_URL).hostname}/v1/mcp`;
+}
 var DEFAULT_API_URL;
 var init_api_url = __esm({
   "src/core/api-url.ts"() {
@@ -4958,6 +5272,37 @@ var init_errors = __esm({
   }
 });
 
+// src/core/onboarding-phase.ts
+function isStepAtOrPast(step, target) {
+  return STEP_ORDER2.indexOf(step) >= STEP_ORDER2.indexOf(target);
+}
+function resolveEntryPhase(state) {
+  if (!isStepAtOrPast(state.step, PREVIEW_DONE_STEP)) return "preview";
+  if (!state.artifactsUploaded || !state.sdkConfigured) return "planner";
+  if (!state.dryRunPassed) return "dryRun";
+  return "done";
+}
+var STEP_ORDER2, PREVIEW_DONE_STEP, LIVE_STEP;
+var init_onboarding_phase = __esm({
+  "src/core/onboarding-phase.ts"() {
+    "use strict";
+    init_esm_shims();
+    STEP_ORDER2 = [
+      "github",
+      "preview_environment",
+      "previewkit_configuring",
+      "previewkit_deploying",
+      "existing_deploys_configuring",
+      "existing_deploys_waiting",
+      "preview_verified",
+      "diff_trigger",
+      "completed"
+    ];
+    PREVIEW_DONE_STEP = "preview_verified";
+    LIVE_STEP = "completed";
+  }
+});
+
 // src/replay/replay-transport.ts
 async function flushReplay(timeoutMs = 1500) {
   if (pending2.size === 0) return;
@@ -4993,52 +5338,520 @@ var init_replay_transport = __esm({
           this.buffer.push(event);
           this.bufferBytes += JSON.stringify(event).length;
         }
-        if (this.bufferBytes >= MAX_BATCH_BYTES) this.send();
+        if (this.bufferBytes >= MAX_BATCH_BYTES) this.send();
+      }
+      flush() {
+        this.send();
+      }
+      send() {
+        if (this.buffer.length === 0) return;
+        const events = this.buffer;
+        const bytes = this.bufferBytes;
+        this.buffer = [];
+        this.bufferBytes = 0;
+        this.sessionBytes += bytes;
+        if (this.sessionBytes > MAX_SESSION_BYTES) {
+          this.exhausted = true;
+          debugLog("Session replay cap reached; stopping capture", {
+            sessionBytes: this.sessionBytes,
+            cap: MAX_SESSION_BYTES
+          });
+          return;
+        }
+        const body = JSON.stringify([
+          {
+            api_key: this.config.apiKey,
+            event: "$snapshot",
+            distinct_id: this.config.distinctId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            properties: {
+              $session_id: this.config.sessionId,
+              $window_id: this.config.windowId,
+              $snapshot_data: events,
+              $snapshot_bytes: bytes,
+              // The player treats a recording as web; the synthesized DOM is
+              // a real DOM as far as it is concerned.
+              $lib: "web",
+              $lib_version: "1.0.0"
+            }
+          }
+        ]);
+        const promise = fetch(`${this.config.host}/s/`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body
+        }).catch((err) => {
+          debugLog("Session replay upload failed (ignored)", { err });
+        }).finally(() => pending2.delete(promise));
+        pending2.add(promise);
+      }
+    };
+  }
+});
+
+// src/core/autonoma-client.ts
+import { createTRPCClient, httpLink } from "@trpc/client";
+import superjson from "superjson";
+function buildClient(apiUrl, apiToken, timeoutMs) {
+  return createTRPCClient({
+    links: [
+      // httpLink, not httpBatchLink: the CLI makes a handful of calls minutes
+      // apart, so batching has nothing to batch and only widens the blast
+      // radius of one slow procedure.
+      httpLink({
+        url: `${apiUrl}${TRPC_PATH}`,
+        transformer: superjson,
+        headers: () => ({ Authorization: `Bearer ${apiToken}` }),
+        // AbortSignal.timeout rather than a manual controller: the timer is
+        // cleared with the signal, so a slow-but-successful call cannot leave
+        // a pending timeout holding the event loop open at exit.
+        fetch: (url, options) => fetch(url, { ...options, signal: AbortSignal.timeout(timeoutMs) })
+      })
+    ]
+  });
+}
+var TRPC_PATH, REQUEST_TIMEOUT_MS, SDK_REQUEST_TIMEOUT_MS, AutonomaClient;
+var init_autonoma_client = __esm({
+  "src/core/autonoma-client.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debug();
+    init_logs();
+    TRPC_PATH = "/v1/trpc";
+    REQUEST_TIMEOUT_MS = 15e3;
+    SDK_REQUEST_TIMEOUT_MS = 5 * 6e4;
+    AutonomaClient = class {
+      /** Status reads and other calls the API answers on its own. */
+      trpc;
+      /** Calls that reach through the API into the customer's deployed app. */
+      slowTrpc;
+      constructor(apiUrl, apiToken) {
+        this.trpc = buildClient(apiUrl, apiToken, REQUEST_TIMEOUT_MS);
+        this.slowTrpc = buildClient(apiUrl, apiToken, SDK_REQUEST_TIMEOUT_MS);
+      }
+      /** Onboarding state for the app, as the platform currently sees it. */
+      async getOnboardingState(applicationId) {
+        debugLog("Reading onboarding state", { applicationId });
+        const state = await this.trpc.onboarding.getState.query({ applicationId });
+        captureLog("info", "Read onboarding state", {
+          source: "onboarding",
+          step: state.step,
+          preview_mode: state.previewEnvironmentMode ?? "unset",
+          sdk_configured: state.sdkConfigured,
+          dry_run_passed: state.dryRunPassed
+        });
+        return state;
+      }
+      /**
+       * Re-check whether this app's preview environment is up.
+       *
+       * Called for its SIDE EFFECT as much as its answer: reading readiness is what
+       * stamps a preview that has come up as `preview_verified`, and nothing else does.
+       * `getOnboardingState` only reports the step someone else already stamped, so a
+       * preview that goes ready after the agent stops polling would never be noticed by
+       * a caller watching the step alone.
+       */
+      async refreshPreviewReadiness(applicationId) {
+        debugLog("Refreshing preview readiness", { applicationId });
+        await this.trpc.onboarding.getPreviewReadiness.query({ applicationId });
+      }
+      /**
+       * Take the app live: from a verified preview through to Autonoma reviewing its
+       * pull requests. Idempotent, and called without asking whether anyone already did.
+       *
+       * The CLI does this itself rather than leaving it to the coding agent, for the
+       * same reason it makes the SDK and dry-run calls itself: no judgement is involved,
+       * and asking an agent to make it is one more way for it not to happen. Here that
+       * is not hypothetical - the preview phase stops the agent as soon as the platform
+       * reports the preview verified, which is the exact moment the agent would have
+       * gone live. Left to the agent, an app finishes a whole run one step short.
+       */
+      async takeAppLive(applicationId) {
+        debugLog("Taking the app live", { applicationId });
+        const result = await this.trpc.onboarding.takeLive.mutate({ applicationId });
+        captureLog("info", "Took the app live", {
+          source: "onboarding",
+          step: result.step,
+          already_live: result.alreadyLive
+        });
+        return { alreadyLive: result.alreadyLive, step: result.step };
+      }
+      /**
+       * Mint a single-use pairing code for a coding agent this CLI is about to spawn.
+       * Codes expire, so mint one per handoff rather than reusing an earlier one.
+       */
+      async createAgentPairing(applicationId) {
+        debugLog("Minting agent pairing code", { applicationId });
+        const { code } = await this.trpc.onboarding.createAgentPairing.mutate({ applicationId });
+        captureLog("info", "Minted agent pairing code", { source: "onboarding" });
+        return code;
+      }
+      /**
+       * The preview environments the SDK validation and the dry run can run against:
+       * the app's main preview plus one per open pull request, each carrying whether it
+       * is deployed yet and which one the platform recognizes as the SDK handler's PR.
+       */
+      async listDryRunTargets(applicationId) {
+        debugLog("Listing SDK dry-run targets", { applicationId });
+        const targets = await this.trpc.onboarding.listSdkDryRunTargets.query({ applicationId });
+        captureLog("info", "Listed SDK dry-run targets", {
+          source: "dry_run",
+          target_count: targets.targets.length,
+          auto_detected: targets.autoDetectedTargetId != null
+        });
+        return targets;
+      }
+      /**
+       * Provision a managed preview's Autonoma secrets so it can be validated. Returns
+       * `redeploy_started` when mounting them changed the running app, in which case the
+       * preview has to come back up before anything else is worth trying.
+       */
+      async prepareSdkTarget(applicationId, targetId) {
+        debugLog("Preparing SDK target", { applicationId, targetId });
+        return this.slowTrpc.onboarding.prepareSdkTarget.mutate({ applicationId, targetId });
+      }
+      /**
+       * Call the app's SDK handler and store the schema it reports.
+       *
+       * `allowSelfHeal` lets the API redeploy once when the handler rejects our
+       * signature, which for a managed preview can only be the platform's own secret
+       * drift. Pass it on the first attempt and not on the retry, so a rejection that
+       * survives a redeploy surfaces instead of looping.
+       */
+      async configureAndDiscoverSdkTarget(applicationId, targetId, allowSelfHeal) {
+        debugLog("Discovering the SDK schema", { applicationId, targetId, allowSelfHeal });
+        return this.slowTrpc.onboarding.configureAndDiscoverSdkTarget.mutate({
+          applicationId,
+          targetId,
+          allowSelfHeal
+        });
+      }
+      /** The app's scenarios - the named states its tests depend on. */
+      async listScenarios(applicationId) {
+        debugLog("Listing scenarios", { applicationId });
+        return this.trpc.scenarios.list.query({ applicationId });
+      }
+      /**
+       * Provision a scenario against a preview and tear it back down. The platform
+       * records the app's dry run as passed once every scenario completes that cycle.
+       */
+      async runScenarioDryRun(applicationId, scenarioId, targetId) {
+        debugLog("Running a scenario dry run", { applicationId, scenarioId, targetId });
+        return this.slowTrpc.onboarding.runScenarioDryRun.mutate({ applicationId, scenarioId, targetId });
+      }
+      /**
+       * Take the onboarding config mutex for this run, so the web app stops offering the
+       * steps this run is about to do and points the user at their terminal instead.
+       *
+       * This is the same mutation behind the UI's "hand it back to the agent" control:
+       * handing the mutex over is one state change whoever asks for it, and a second
+       * procedure that set the same column would only be a way for the two to drift.
+       *
+       * Unconditional by design - a user starting this run IS the handoff, including
+       * after an earlier take-over. What makes take-over stick is that this is called
+       * once at the start of a run rather than polled, so a user who takes the config
+       * back mid-run keeps it.
+       */
+      async claimAgentHold(applicationId) {
+        debugLog("Claiming the onboarding config for this run", { applicationId });
+        await this.trpc.onboarding.resumeAgent.mutate({ applicationId });
+        captureLog("info", "Claimed the onboarding config for this run", { source: "onboarding" });
+      }
+    };
+  }
+});
+
+// src/core/coding-agent.ts
+var coding_agent_exports = {};
+__export(coding_agent_exports, {
+  BaseLauncher: () => BaseLauncher,
+  ClaudeLauncher: () => ClaudeLauncher,
+  CodexLauncher: () => CodexLauncher,
+  DEFAULT_PERMISSION_MODE: () => DEFAULT_PERMISSION_MODE,
+  PERMISSION_MODE_LABELS: () => PERMISSION_MODE_LABELS,
+  SPAWNED_BY_PLANNER_ENV: () => SPAWNED_BY_PLANNER_ENV,
+  buildAllLaunchers: () => buildAllLaunchers,
+  isSpawnedByPlanner: () => isSpawnedByPlanner,
+  parsePermissionMode: () => parsePermissionMode,
+  selectLauncher: () => selectLauncher,
+  selectPermissionMode: () => selectPermissionMode
+});
+import spawn from "cross-spawn";
+import which from "which";
+function isSpawnedByPlanner(env = process.env) {
+  return env[SPAWNED_BY_PLANNER_ENV] != null && env[SPAWNED_BY_PLANNER_ENV] !== "";
+}
+function buildAllLaunchers(opts) {
+  return [new ClaudeLauncher(opts), new CodexLauncher(opts)];
+}
+async function selectLauncher(launchers, presetId, interactive = true) {
+  const availability = await Promise.all(launchers.map((l) => l.isAvailable()));
+  const available = launchers.filter((_, i) => availability[i]);
+  debugLog("Detected available agents", { available: available.map((l) => l.id), presetId, interactive });
+  if (presetId != null) {
+    const preset = available.find((l) => l.id === presetId);
+    if (preset != null) return preset;
+    log.warn(`Requested agent "${presetId}" is not installed or not supported.`);
+  }
+  if (available.length === 0) return void 0;
+  if (available.length === 1) {
+    const only = available[0];
+    log.info(`Found ${only.label} - will use it for the integration.`);
+    return only;
+  }
+  if (!interactive) {
+    const first = available[0];
+    log.warn(
+      `Several coding agents are installed and there is nobody to ask - using ${first.label}. Pass --agent to choose.`
+    );
+    return first;
+  }
+  const selected = await select({
+    message: "Which agent should implement the integration?",
+    options: available.map((l) => ({ value: l.id, label: l.label }))
+  });
+  if (isCancel(selected)) throw new Error("Agent selection cancelled");
+  return available.find((l) => l.id === selected);
+}
+async function selectPermissionMode(preset) {
+  if (preset != null) return preset;
+  const selected = await select({
+    message: "How much autonomy should the agent have?",
+    options: [
+      { value: "bypassPermissions", label: PERMISSION_MODE_LABELS.bypassPermissions },
+      { value: "acceptEdits", label: PERMISSION_MODE_LABELS.acceptEdits },
+      { value: "default", label: PERMISSION_MODE_LABELS.default }
+    ],
+    initialValue: DEFAULT_PERMISSION_MODE
+  });
+  if (isCancel(selected)) throw new Error("Permission mode selection cancelled");
+  return selected;
+}
+function parsePermissionMode(value) {
+  if (value === "default" || value === "acceptEdits" || value === "bypassPermissions") return value;
+  return void 0;
+}
+function firstLine(output) {
+  return output.split("\n").find((line) => line.trim().length > 0)?.trim() ?? "";
+}
+var MCP_COMMAND_TIMEOUT_MS, SPAWNED_BY_PLANNER_ENV, CODEX_BEARER_TOKEN_ENV, CLAUDE_CONNECTED_MARKER, DEFAULT_PERMISSION_MODE, PERMISSION_MODE_LABELS, CLAUDE_ID, CODEX_ID, BaseLauncher, ClaudeLauncher, CodexLauncher;
+var init_coding_agent = __esm({
+  "src/core/coding-agent.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_debug();
+    MCP_COMMAND_TIMEOUT_MS = 6e4;
+    SPAWNED_BY_PLANNER_ENV = "AUTONOMA_PLANNER_SPAWNED_AGENT";
+    CODEX_BEARER_TOKEN_ENV = "AUTONOMA_MCP_TOKEN";
+    CLAUDE_CONNECTED_MARKER = "Connected";
+    DEFAULT_PERMISSION_MODE = "bypassPermissions";
+    PERMISSION_MODE_LABELS = {
+      default: "Approve each command",
+      acceptEdits: "Auto-edit files, approve commands",
+      bypassPermissions: "Fully autonomous"
+    };
+    CLAUDE_ID = "claude";
+    CODEX_ID = "codex";
+    BaseLauncher = class {
+      constructor(opts) {
+        this.opts = opts;
+      }
+      async isAvailable() {
+        const resolved = await which(this.command, { nothrow: true });
+        debugLog("Probed for agent on PATH", { command: this.command, found: resolved != null });
+        return resolved != null;
+      }
+      async launch(request) {
+        if (isSpawnedByPlanner(this.opts.env)) {
+          throw new Error(
+            `Refusing to launch ${this.label}: this planner run was itself started by an agent the planner spawned (${SPAWNED_BY_PLANNER_ENV} is set). Run the planner directly instead.`
+          );
+        }
+        debugLog(`Launching ${this.label}`, {
+          permissionMode: request.permissionMode,
+          interactive: request.interactive
+        });
+        const args = this.buildArgs(request.message, request.permissionMode, request.interactive);
+        const stdio = request.interactive ? "inherit" : ["ignore", "inherit", "inherit"];
+        return new Promise((resolve6) => {
+          const proc = spawn(this.command, args, {
+            cwd: this.opts.cwd,
+            env: this.spawnEnv(request.env),
+            stdio
+          });
+          const stopWatching = request.watch?.(proc) ?? (() => {
+          });
+          proc.on("error", (err) => {
+            debugLog(`${this.label} failed to spawn`, { err });
+            log.error(`Couldn't launch ${this.label}: ${err.message}`);
+            stopWatching();
+            resolve6(void 0);
+          });
+          proc.on("close", (code) => {
+            debugLog(`${this.label} exited`, { code });
+            stopWatching();
+            resolve6(code ?? void 0);
+          });
+        });
+      }
+      /**
+       * The env the agent runs with: what the CLI was given (so the canonical shared
+       * secret reaches the app and the signed `sdk` calls), whatever this run adds
+       * (an MCP registration's token), plus the recursion marker.
+       */
+      spawnEnv(extra) {
+        return { ...this.opts.env, ...extra, [SPAWNED_BY_PLANNER_ENV]: "1" };
+      }
+      /**
+       * Run one of this client's own subcommands and capture its output. Never attached
+       * to the terminal: these are configuration calls whose result the CLI inspects,
+       * not the handoff itself.
+       */
+      runCommand(args) {
+        debugLog(`Running ${this.command} ${args[0] ?? ""}`, { args });
+        return new Promise((resolve6) => {
+          const proc = spawn(this.command, args, {
+            cwd: this.opts.cwd,
+            env: this.opts.env,
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: MCP_COMMAND_TIMEOUT_MS
+          });
+          let stdout = "";
+          let stderr = "";
+          proc.stdout?.on("data", (chunk) => stdout += chunk.toString());
+          proc.stderr?.on("data", (chunk) => stderr += chunk.toString());
+          proc.on("error", (err) => {
+            debugLog(`${this.command} ${args[0] ?? ""} failed to spawn`, { err });
+            resolve6({ code: void 0, stdout, stderr: err.message });
+          });
+          proc.on("close", (code) => resolve6({ code: code ?? void 0, stdout, stderr }));
+        });
+      }
+      /**
+       * Sign this client in to a server through its own browser flow.
+       *
+       * Refused outright without a terminal. The flow prints a URL, opens a browser and
+       * blocks on the callback, so a run with nobody at the keyboard would not fail - it
+       * would hang, indefinitely, on a prompt nobody can see. A run without a terminal
+       * is meant to have passed an API token instead, and the error says so rather than
+       * describing the sign-in that could not happen.
+       */
+      async signIn(serverName) {
+        if (process.stdin.isTTY !== true) {
+          throw new Error(
+            `Cannot sign ${this.label} in to the ${serverName} MCP server without a terminal: that flow opens a browser and waits for it. Set AUTONOMA_API_TOKEN so the run authorizes with an API key instead.`
+          );
+        }
+        log.info(`Authorizing ${this.label} with Autonoma - approve it in the browser that opens.`);
+        const login = await this.runAttached(["mcp", "login", serverName]);
+        if (login !== 0) {
+          throw new Error(
+            `${this.label} could not sign in to the ${serverName} MCP server (exit ${login ?? "unknown"}).`
+          );
+        }
+      }
+      /**
+       * Run a subcommand that hands the terminal over - an interactive OAuth sign-in.
+       * The client prints a URL, opens a browser and waits on the callback, so it needs
+       * this process's stdio rather than pipes.
+       */
+      runAttached(args) {
+        debugLog(`Running ${this.command} ${args.join(" ")} attached`);
+        return new Promise((resolve6) => {
+          const proc = spawn(this.command, args, { cwd: this.opts.cwd, env: this.opts.env, stdio: "inherit" });
+          proc.on("error", (err) => {
+            debugLog(`${this.command} ${args[0] ?? ""} failed to spawn`, { err });
+            resolve6(void 0);
+          });
+          proc.on("close", (code) => resolve6(code ?? void 0));
+        });
+      }
+    };
+    ClaudeLauncher = class extends BaseLauncher {
+      id = CLAUDE_ID;
+      label = "Claude Code";
+      command = CLAUDE_ID;
+      buildArgs(message, permissionMode, interactive) {
+        return interactive ? ["--permission-mode", permissionMode, message] : ["-p", message, "--permission-mode", permissionMode, "--verbose"];
+      }
+      /**
+       * `--scope user` and not the default (`local`): the default binds the server to the
+       * directory the command ran in. The planner can be invoked from anywhere in a repo,
+       * and a server registered against the wrong directory looks exactly like one that
+       * was never authorized - the agent simply has no Autonoma tools.
+       *
+       * With a token the header goes into Claude's own config and there is nothing to
+       * sign in to. Without one, the browser sign-in runs attached to the terminal.
+       */
+      async registerMcpServer(spec) {
+        const add = ["mcp", "add", "--transport", "http", "--scope", "user", spec.name, spec.url];
+        if (spec.apiToken != null) add.push("--header", `Authorization: Bearer ${spec.apiToken}`);
+        const existing = await this.runCommand(["mcp", "get", spec.name]);
+        if (existing.code === 0 && !existing.stdout.includes(spec.url)) {
+          debugLog("Replacing an MCP registration that points elsewhere", { server: spec.name, url: spec.url });
+          await this.runCommand(["mcp", "remove", spec.name, "-s", "user"]);
+        }
+        await this.runCommand(add);
+        const registered = await this.runCommand(["mcp", "get", spec.name]);
+        if (registered.code !== 0) {
+          throw new Error(
+            `Could not register the ${spec.name} MCP server with ${this.label}: ${firstLine(registered.stderr) || firstLine(registered.stdout) || "unknown error"}`
+          );
+        }
+        if (spec.apiToken == null && !registered.stdout.includes(CLAUDE_CONNECTED_MARKER)) {
+          await this.signIn(spec.name);
+        }
+        return { env: {} };
       }
-      flush() {
-        this.send();
+    };
+    CodexLauncher = class extends BaseLauncher {
+      id = CODEX_ID;
+      label = "Codex CLI";
+      command = CODEX_ID;
+      /**
+       * Codex's autonomy is two orthogonal axes - `--sandbox` (what it may touch) and
+       * `--ask-for-approval` (when it pauses) - so we translate the shared,
+       * Claude-flavoured `PermissionMode` onto them.
+       *
+       * The handoff's whole job is to install the SDK, boot the app, and validate
+       * against a live DB, so the sandbox is always `danger-full-access` (Codex's
+       * `workspace-write` disables network, which breaks the install). The only real
+       * knob is approval strictness, which exists only interactively: headless `exec`
+       * can't prompt, so `default`/`acceptEdits` collapse to the same autonomous run.
+       */
+      buildArgs(message, permissionMode, interactive) {
+        if (permissionMode === "bypassPermissions") {
+          const bypass = ["--dangerously-bypass-approvals-and-sandbox"];
+          return interactive ? [...bypass, message] : ["exec", ...bypass, message];
+        }
+        const sandbox = ["--sandbox", "danger-full-access"];
+        if (!interactive) return ["exec", ...sandbox, message];
+        const approval = permissionMode === "acceptEdits" ? "on-failure" : "untrusted";
+        return [...sandbox, "--ask-for-approval", approval, message];
       }
-      send() {
-        if (this.buffer.length === 0) return;
-        const events = this.buffer;
-        const bytes = this.bufferBytes;
-        this.buffer = [];
-        this.bufferBytes = 0;
-        this.sessionBytes += bytes;
-        if (this.sessionBytes > MAX_SESSION_BYTES) {
-          this.exhausted = true;
-          debugLog("Session replay cap reached; stopping capture", {
-            sessionBytes: this.sessionBytes,
-            cap: MAX_SESSION_BYTES
-          });
-          return;
+      /**
+       * Codex speaks streamable HTTP natively, so this needs no `mcp-remote` bridge.
+       * `--bearer-token-env-var` stores the NAME of the variable rather than the token,
+       * which is why the registration hands an env back for the spawn to carry.
+       *
+       * `mcp add` is idempotent here in the way that matters: re-adding an existing
+       * server overwrites its entry, so a re-run cannot leave a stale URL behind.
+       */
+      async registerMcpServer(spec) {
+        const add = ["mcp", "add", spec.name, "--url", spec.url];
+        if (spec.apiToken != null) add.push("--bearer-token-env-var", CODEX_BEARER_TOKEN_ENV);
+        const added = await this.runCommand(add);
+        if (added.code !== 0) {
+          throw new Error(
+            `Could not register the ${spec.name} MCP server with ${this.label}: ${firstLine(added.stderr) || firstLine(added.stdout) || "unknown error"}`
+          );
         }
-        const body = JSON.stringify([
-          {
-            api_key: this.config.apiKey,
-            event: "$snapshot",
-            distinct_id: this.config.distinctId,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            properties: {
-              $session_id: this.config.sessionId,
-              $window_id: this.config.windowId,
-              $snapshot_data: events,
-              $snapshot_bytes: bytes,
-              // The player treats a recording as web; the synthesized DOM is
-              // a real DOM as far as it is concerned.
-              $lib: "web",
-              $lib_version: "1.0.0"
-            }
-          }
-        ]);
-        const promise = fetch(`${this.config.host}/s/`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body
-        }).catch((err) => {
-          debugLog("Session replay upload failed (ignored)", { err });
-        }).finally(() => pending2.delete(promise));
-        pending2.add(promise);
+        if (spec.apiToken == null) {
+          await this.signIn(spec.name);
+          return { env: {} };
+        }
+        return { env: { [CODEX_BEARER_TOKEN_ENV]: spec.apiToken } };
       }
     };
   }
@@ -5216,6 +6029,309 @@ var init_interrupt = __esm({
   }
 });
 
+// src/core/preview-phase.ts
+function previewPrompt(code, interactive) {
+  const instruction = `set up my preview environments with the ${MCP_SERVER_NAME} MCP, code ${code}`;
+  return interactive ? instruction : `${instruction}.${HEADLESS_GUIDANCE}`;
+}
+async function runPreviewPhase(deps) {
+  const timing = deps.timing ?? DEFAULT_PHASE_TIMING;
+  log.info(`Connecting ${deps.launcher.label} to Autonoma...`);
+  const registration = await deps.launcher.registerMcpServer({
+    name: MCP_SERVER_NAME,
+    url: deps.mcpUrl,
+    apiToken: deps.apiToken
+  });
+  const code = await deps.client.createAgentPairing(deps.applicationId);
+  captureLog("info", "Handing the preview environment to a coding agent", {
+    source: "preview_phase",
+    agent: deps.launcher.id
+  });
+  log.info("Your agent is setting up your preview environment - watch it work, and steer it if you want to.");
+  await deps.launcher.launch({
+    message: previewPrompt(code, deps.interactive),
+    permissionMode: deps.permissionMode,
+    interactive: deps.interactive,
+    env: registration.env,
+    // Both modes, not just interactive. An interactive session plainly never exits
+    // on its own - it sits open after its final message - but a headless one is no
+    // safer to wait on: observed in practice finishing the actual work and then
+    // continuing to potter, with the run blocked behind it. Onboarding state is
+    // what says "done", so it ends the handoff either way.
+    watch: (proc) => watchForPreviewPhase(deps.client, deps.applicationId, proc, timing)
+  });
+  const state = await readVerifiedState(deps.client, deps.applicationId);
+  if (isStepAtOrPast(state.step, PREVIEW_DONE_STEP)) {
+    log.success("Your preview environment is up.");
+    captureLog("info", "Preview phase complete", { source: "preview_phase", step: state.step });
+    return { kind: "verified" };
+  }
+  captureLog("warn", "Preview phase ended without a verified preview", {
+    source: "preview_phase",
+    step: state.step
+  });
+  return { kind: "incomplete", step: state.step };
+}
+function watchForPreviewPhase(client, applicationId, proc, timing = DEFAULT_PHASE_TIMING) {
+  let graceTimer;
+  let killTimer;
+  const poll = setInterval(() => {
+    void readVerifiedState(client, applicationId).then((state) => {
+      if (!isStepAtOrPast(state.step, PREVIEW_DONE_STEP) || graceTimer != null) return;
+      debugLog("Preview verified while the agent runs; scheduling terminal reclaim", { step: state.step });
+      clearInterval(poll);
+      graceTimer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        killTimer = setTimeout(() => proc.kill("SIGKILL"), timing.killMs);
+      }, timing.graceMs);
+    }).catch((err) => {
+      debugLog("Could not read onboarding state while the agent runs", { err });
+    });
+  }, timing.pollMs);
+  return () => {
+    clearInterval(poll);
+    if (graceTimer != null) clearTimeout(graceTimer);
+    if (killTimer != null) clearTimeout(killTimer);
+  };
+}
+async function readVerifiedState(client, applicationId) {
+  await client.refreshPreviewReadiness(applicationId).catch((err) => {
+    debugLog("Could not refresh preview readiness", { err });
+  });
+  return client.getOnboardingState(applicationId);
+}
+var MCP_SERVER_NAME, PHASE_POLL_MS, PHASE_EXIT_GRACE_MS, KILL_ESCALATION_MS, DEFAULT_PHASE_TIMING, HEADLESS_GUIDANCE;
+var init_preview_phase = __esm({
+  "src/core/preview-phase.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_debug();
+    init_logs();
+    init_onboarding_phase();
+    MCP_SERVER_NAME = "autonoma";
+    PHASE_POLL_MS = 5e3;
+    PHASE_EXIT_GRACE_MS = 15e3;
+    KILL_ESCALATION_MS = 1e4;
+    DEFAULT_PHASE_TIMING = {
+      pollMs: PHASE_POLL_MS,
+      graceMs: PHASE_EXIT_GRACE_MS,
+      killMs: KILL_ESCALATION_MS
+    };
+    HEADLESS_GUIDANCE = " You are running with no human to answer you, so where you would ask a question, choose the safer option and say which you chose. You are not finished when you have tried - you are finished when the preview is verified. If a deploy fails, read its logs, fix the cause and deploy again. Never report success you have not confirmed.";
+  }
+});
+
+// src/core/sdk-repair-phase.ts
+function repairPrompt(code, interactive) {
+  const instruction = `use the ${MCP_SERVER_NAME} MCP, code ${code}, to get my Autonoma SDK answering and my scenario dry run passing - fix whatever is in the way, in this repo or in the config, and keep going until Autonoma reports both`;
+  return interactive ? instruction : `${instruction}.${HEADLESS_GUIDANCE2}`;
+}
+function isDone(state) {
+  return state.sdkConfigured && state.dryRunPassed;
+}
+async function runSdkRepairPhase(deps) {
+  const timing = deps.timing ?? DEFAULT_PHASE_TIMING;
+  const before = await deps.client.getOnboardingState(deps.applicationId);
+  if (isDone(before)) return { kind: "passed" };
+  log.info(`Connecting ${deps.launcher.label} to Autonoma...`);
+  const registration = await deps.launcher.registerMcpServer({
+    name: MCP_SERVER_NAME,
+    url: deps.mcpUrl,
+    apiToken: deps.apiToken
+  });
+  const code = await deps.client.createAgentPairing(deps.applicationId);
+  captureLog("info", "Handing the SDK and dry run to a coding agent", {
+    source: "sdk_repair_phase",
+    agent: deps.launcher.id,
+    sdk_configured: before.sdkConfigured,
+    dry_run_passed: before.dryRunPassed
+  });
+  log.info("Your agent is getting your test data working - watch it, and steer it if you want to.");
+  await deps.launcher.launch({
+    message: repairPrompt(code, deps.interactive),
+    permissionMode: deps.permissionMode,
+    interactive: deps.interactive,
+    env: registration.env,
+    watch: (proc) => watchForSdkRepair(deps.client, deps.applicationId, proc, timing)
+  });
+  const after = await deps.client.getOnboardingState(deps.applicationId);
+  if (isDone(after)) {
+    log.success("Your test data provisions against your preview.");
+    captureLog("info", "SDK repair phase complete", { source: "sdk_repair_phase" });
+    return { kind: "passed" };
+  }
+  captureLog("warn", "SDK repair phase ended with work outstanding", {
+    source: "sdk_repair_phase",
+    sdk_configured: after.sdkConfigured,
+    dry_run_passed: after.dryRunPassed
+  });
+  return { kind: "incomplete", sdkConfigured: after.sdkConfigured, dryRunPassed: after.dryRunPassed };
+}
+function watchForSdkRepair(client, applicationId, proc, timing = DEFAULT_PHASE_TIMING) {
+  let graceTimer;
+  let killTimer;
+  const poll = setInterval(() => {
+    void client.getOnboardingState(applicationId).then((state) => {
+      if (!isDone(state) || graceTimer != null) return;
+      debugLog("SDK and dry run both good while the agent runs; scheduling terminal reclaim");
+      clearInterval(poll);
+      graceTimer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        killTimer = setTimeout(() => proc.kill("SIGKILL"), timing.killMs);
+      }, timing.graceMs);
+    }).catch((err) => {
+      debugLog("Could not read onboarding state while the agent runs", { err });
+    });
+  }, timing.pollMs);
+  return () => {
+    clearInterval(poll);
+    if (graceTimer != null) clearTimeout(graceTimer);
+    if (killTimer != null) clearTimeout(killTimer);
+  };
+}
+var HEADLESS_GUIDANCE2;
+var init_sdk_repair_phase = __esm({
+  "src/core/sdk-repair-phase.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_debug();
+    init_logs();
+    init_preview_phase();
+    HEADLESS_GUIDANCE2 = " You are running with no human to answer you, so where you would ask a question, choose the safer option and say which you chose. You are not finished when you have tried - you are finished when Autonoma reports the scenario dry run passed. Never report success you have not confirmed.";
+  }
+});
+
+// src/core/front-door.ts
+var front_door_exports = {};
+__export(front_door_exports, {
+  describeIncompletePreview: () => describeIncompletePreview,
+  planFrontDoor: () => planFrontDoor,
+  runPreviewHandoff: () => runPreviewHandoff,
+  runSdkRepairHandoff: () => runSdkRepairHandoff
+});
+async function planFrontDoor(config) {
+  const { autonomaApplicationId: applicationId, autonomaApiToken: apiToken } = config;
+  if (applicationId == null || apiToken == null) {
+    debugLog("No application id or token; running the pipeline standalone");
+    return void 0;
+  }
+  const client = new AutonomaClient(config.autonomaApiUrl, apiToken);
+  try {
+    const state = await client.getOnboardingState(applicationId);
+    const phase = resolveEntryPhase(state);
+    await claimHoldForRun(client, applicationId, phase);
+    return { client, applicationId, phase };
+  } catch (err) {
+    log.warn("Couldn't read your setup status from Autonoma - continuing with the test-suite run.");
+    debugLog("Front-door planning failed", { err });
+    captureLog("warn", "Could not resolve the onboarding entry phase", { source: "front_door" });
+    return void 0;
+  }
+}
+async function claimHoldForRun(client, applicationId, phase) {
+  if (phase === "preview" || phase === "done") return;
+  try {
+    await client.claimAgentHold(applicationId);
+  } catch (err) {
+    debugLog("Could not claim the onboarding config for this run", { err });
+    captureLog("warn", "Could not claim the onboarding config for this run", { source: "front_door" });
+  }
+}
+async function runPreviewHandoff(deps) {
+  const { plan, config, nonInteractive } = deps;
+  const interactive = !nonInteractive;
+  const launchers = deps.launchers ?? buildAllLaunchers({ cwd: config.projectRoot, env: process.env });
+  const launcher = await selectLauncher(launchers, config.agent, interactive);
+  if (launcher == null) {
+    captureLog("warn", "No coding agent available for the preview phase", { source: "front_door" });
+    return { kind: "no-agent" };
+  }
+  const preset = parsePermissionMode(config.permissionMode);
+  const permissionMode = interactive ? await selectPermissionMode(preset) : preset ?? DEFAULT_PERMISSION_MODE;
+  suspend();
+  let outcome;
+  try {
+    outcome = await runPreviewPhase({
+      client: plan.client,
+      applicationId: plan.applicationId,
+      launcher,
+      permissionMode,
+      apiToken: interactive ? void 0 : config.autonomaApiToken,
+      mcpUrl: resolveMcpUrl(config.autonomaApiUrl),
+      interactive
+    });
+  } finally {
+    resume();
+  }
+  if (outcome.kind === "verified") await takeAppLive(plan);
+  return outcome;
+}
+async function takeAppLive(plan) {
+  try {
+    const { alreadyLive } = await plan.client.takeAppLive(plan.applicationId);
+    log.success(
+      alreadyLive ? "Autonoma is reviewing your pull requests." : "Autonoma is now reviewing your pull requests."
+    );
+  } catch (err) {
+    debugLog("Could not take the app live", { err });
+    captureLog("warn", "Could not take the app live", { source: "front_door" });
+    log.warn(
+      "Your preview is up, but Autonoma is not reviewing your pull requests yet - take the app live in the Autonoma app to finish."
+    );
+  }
+}
+async function runSdkRepairHandoff(deps) {
+  const { plan, config, nonInteractive } = deps;
+  const interactive = !nonInteractive;
+  const launchers = deps.launchers ?? buildAllLaunchers({ cwd: config.projectRoot, env: process.env });
+  const launcher = await selectLauncher(launchers, config.agent, interactive);
+  if (launcher == null) {
+    captureLog("warn", "No coding agent available for the SDK repair phase", { source: "front_door" });
+    return void 0;
+  }
+  const preset = parsePermissionMode(config.permissionMode);
+  const permissionMode = interactive ? await selectPermissionMode(preset) : preset ?? DEFAULT_PERMISSION_MODE;
+  suspend();
+  try {
+    return await runSdkRepairPhase({
+      client: plan.client,
+      applicationId: plan.applicationId,
+      launcher,
+      permissionMode,
+      apiToken: interactive ? void 0 : config.autonomaApiToken,
+      mcpUrl: resolveMcpUrl(config.autonomaApiUrl),
+      interactive
+    });
+  } finally {
+    resume();
+  }
+}
+function describeIncompletePreview(result) {
+  if (result.kind === "verified") return void 0;
+  if (result.kind === "no-agent") {
+    return "No supported coding agent was found on your PATH, so the preview environment was skipped. Install Claude Code or the Codex CLI and run again, or set the preview up in the Autonoma app.";
+  }
+  return "Your preview environment isn't confirmed yet, so scenario dry runs will have nothing to run against. Finish it in the Autonoma app (or run again) - the rest of the run continues either way.";
+}
+var init_front_door = __esm({
+  "src/core/front-door.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_api_url();
+    init_autonoma_client();
+    init_coding_agent();
+    init_debug();
+    init_interrupt();
+    init_logs();
+    init_onboarding_phase();
+    init_preview_phase();
+    init_sdk_repair_phase();
+  }
+});
+
 // src/core/model.ts
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 function getProvider() {
@@ -8093,26 +9209,7 @@ var init_completion = __esm({
   }
 });
 
-// src/agents/04-recipe-builder/launcher.ts
-var launcher_exports = {};
-__export(launcher_exports, {
-  BaseLauncher: () => BaseLauncher,
-  ClaudeLauncher: () => ClaudeLauncher,
-  CodexLauncher: () => CodexLauncher,
-  DEFAULT_PERMISSION_MODE: () => DEFAULT_PERMISSION_MODE,
-  PERMISSION_MODE_LABELS: () => PERMISSION_MODE_LABELS,
-  buildAllLaunchers: () => buildAllLaunchers,
-  parsePermissionMode: () => parsePermissionMode,
-  selectLauncher: () => selectLauncher,
-  selectPermissionMode: () => selectPermissionMode,
-  watchForCompletion: () => watchForCompletion
-});
-import { dirname as dirname3 } from "path";
-import spawn from "cross-spawn";
-import which from "which";
-function launchMessage(promptFile) {
-  return `Read the file ${promptFile} and follow its instructions exactly to integrate Autonoma into this application. It is your complete spec. Do not stop until every item in it is done and you have written the completion marker it describes.`;
-}
+// src/agents/04-recipe-builder/completion-watch.ts
 function watchForCompletion(outputDir, proc, timing = DEFAULT_WATCH_TIMING) {
   let graceTimer;
   let killTimer;
@@ -8131,148 +9228,26 @@ function watchForCompletion(outputDir, proc, timing = DEFAULT_WATCH_TIMING) {
       }, timing.graceMs);
     });
   }, timing.pollMs);
-  return () => {
-    clearInterval(poll);
-    if (graceTimer != null) clearTimeout(graceTimer);
-    if (killTimer != null) clearTimeout(killTimer);
-  };
-}
-function buildAllLaunchers(opts) {
-  return [new ClaudeLauncher(opts), new CodexLauncher(opts)];
-}
-async function selectLauncher(launchers, presetId, interactive = true) {
-  const availability = await Promise.all(launchers.map((l) => l.isAvailable()));
-  const available = launchers.filter((_, i) => availability[i]);
-  debugLog("Detected available agents", { available: available.map((l) => l.id), presetId, interactive });
-  if (presetId != null) {
-    const preset = available.find((l) => l.id === presetId);
-    if (preset != null) return preset;
-    log.warn(`Requested agent "${presetId}" is not installed or not supported.`);
-  }
-  if (available.length === 0) return void 0;
-  if (available.length === 1) {
-    const only = available[0];
-    log.info(`Found ${only.label} - will use it for the integration.`);
-    return only;
-  }
-  if (!interactive) return void 0;
-  const selected = await select({
-    message: "Which agent should implement the integration?",
-    options: available.map((l) => ({ value: l.id, label: l.label }))
-  });
-  if (isCancel(selected)) throw new Error("Agent selection cancelled");
-  return available.find((l) => l.id === selected);
-}
-async function selectPermissionMode(preset) {
-  if (preset != null) return preset;
-  const selected = await select({
-    message: "How much autonomy should the agent have?",
-    options: [
-      { value: "bypassPermissions", label: PERMISSION_MODE_LABELS.bypassPermissions },
-      { value: "acceptEdits", label: PERMISSION_MODE_LABELS.acceptEdits },
-      { value: "default", label: PERMISSION_MODE_LABELS.default }
-    ],
-    initialValue: DEFAULT_PERMISSION_MODE
-  });
-  if (isCancel(selected)) throw new Error("Permission mode selection cancelled");
-  return selected;
-}
-function parsePermissionMode(value) {
-  if (value === "default" || value === "acceptEdits" || value === "bypassPermissions") return value;
-  return void 0;
+  return () => {
+    clearInterval(poll);
+    if (graceTimer != null) clearTimeout(graceTimer);
+    if (killTimer != null) clearTimeout(killTimer);
+  };
 }
-var MARKER_POLL_MS, MARKER_EXIT_GRACE_MS, KILL_ESCALATION_MS, DEFAULT_PERMISSION_MODE, PERMISSION_MODE_LABELS, CLAUDE_ID, CODEX_ID, BaseLauncher, ClaudeLauncher, CodexLauncher, DEFAULT_WATCH_TIMING;
-var init_launcher = __esm({
-  "src/agents/04-recipe-builder/launcher.ts"() {
+var MARKER_POLL_MS, MARKER_EXIT_GRACE_MS, KILL_ESCALATION_MS2, DEFAULT_WATCH_TIMING;
+var init_completion_watch = __esm({
+  "src/agents/04-recipe-builder/completion-watch.ts"() {
     "use strict";
     init_esm_shims();
     init_debug();
-    init_prompts();
     init_completion();
     MARKER_POLL_MS = 2e3;
     MARKER_EXIT_GRACE_MS = 3e4;
-    KILL_ESCALATION_MS = 1e4;
-    DEFAULT_PERMISSION_MODE = "bypassPermissions";
-    PERMISSION_MODE_LABELS = {
-      default: "Approve each command",
-      acceptEdits: "Auto-edit files, approve commands",
-      bypassPermissions: "Fully autonomous"
-    };
-    CLAUDE_ID = "claude";
-    CODEX_ID = "codex";
-    BaseLauncher = class {
-      constructor(opts) {
-        this.opts = opts;
-      }
-      async isAvailable() {
-        const resolved = await which(this.command, { nothrow: true });
-        debugLog("Probed for agent on PATH", { command: this.command, found: resolved != null });
-        return resolved != null;
-      }
-      launch(promptFile, permissionMode, interactive) {
-        debugLog(`Launching ${this.label}`, { promptFile, permissionMode, interactive });
-        const args = this.buildArgs(launchMessage(promptFile), permissionMode, interactive);
-        const stdio = interactive ? "inherit" : ["ignore", "inherit", "inherit"];
-        return new Promise((resolve6) => {
-          const proc = spawn(this.command, args, {
-            cwd: this.opts.cwd,
-            env: this.opts.env,
-            stdio
-          });
-          const stopWatching = interactive ? watchForCompletion(dirname3(promptFile), proc) : () => {
-          };
-          proc.on("error", (err) => {
-            debugLog(`${this.label} failed to spawn`, { err });
-            log.error(`Couldn't launch ${this.label}: ${err.message}`);
-            stopWatching();
-            resolve6(void 0);
-          });
-          proc.on("close", (code) => {
-            debugLog(`${this.label} exited`, { code });
-            stopWatching();
-            resolve6(code ?? void 0);
-          });
-        });
-      }
-    };
-    ClaudeLauncher = class extends BaseLauncher {
-      id = CLAUDE_ID;
-      label = "Claude Code";
-      command = CLAUDE_ID;
-      buildArgs(message, permissionMode, interactive) {
-        return interactive ? ["--permission-mode", permissionMode, message] : ["-p", message, "--permission-mode", permissionMode, "--verbose"];
-      }
-    };
-    CodexLauncher = class extends BaseLauncher {
-      id = CODEX_ID;
-      label = "Codex CLI";
-      command = CODEX_ID;
-      /**
-       * Codex's autonomy is two orthogonal axes - `--sandbox` (what it may touch) and
-       * `--ask-for-approval` (when it pauses) - so we translate the shared,
-       * Claude-flavoured `PermissionMode` onto them.
-       *
-       * The handoff's whole job is to install the SDK, boot the app, and validate
-       * against a live DB, so the sandbox is always `danger-full-access` (Codex's
-       * `workspace-write` disables network, which breaks the install). The only real
-       * knob is approval strictness, which exists only interactively: headless `exec`
-       * can't prompt, so `default`/`acceptEdits` collapse to the same autonomous run.
-       */
-      buildArgs(message, permissionMode, interactive) {
-        if (permissionMode === "bypassPermissions") {
-          const bypass = ["--dangerously-bypass-approvals-and-sandbox"];
-          return interactive ? [...bypass, message] : ["exec", ...bypass, message];
-        }
-        const sandbox = ["--sandbox", "danger-full-access"];
-        if (!interactive) return ["exec", ...sandbox, message];
-        const approval = permissionMode === "acceptEdits" ? "on-failure" : "untrusted";
-        return [...sandbox, "--ask-for-approval", approval, message];
-      }
-    };
+    KILL_ESCALATION_MS2 = 1e4;
     DEFAULT_WATCH_TIMING = {
       pollMs: MARKER_POLL_MS,
       graceMs: MARKER_EXIT_GRACE_MS,
-      killMs: KILL_ESCALATION_MS
+      killMs: KILL_ESCALATION_MS2
     };
   }
 });
@@ -8287,6 +9262,10 @@ ${params.priorFailure}
 Re-read your IMPLEMENTATION.md checklist, pick up at the first unfinished entity,
 and do NOT redo entities already validated. Finish every remaining item, then write
 the completion marker.
+` : "";
+  const userGuidanceSection = params.userGuidance != null ? `
+\u2550\u2550\u2550 THE DEVELOPER ASKED FOR THIS - IT OVERRIDES YOUR OWN PLAN \u2550\u2550\u2550
+${params.userGuidance}
 ` : "";
   return `<!-- Autonoma integration prompt v${INTEGRATION_PROMPT_VERSION} -->
 You are integrating Autonoma into THIS application, working in a LOCAL checkout of
@@ -8296,7 +9275,7 @@ the repo. The Autonoma planner has ALREADY run locally and produced its artifact
 You are the developer picking up exactly where the planner hands off: implement the
 test-data layer (the SDK integration), GENERATE the test-data recipe, and validate
 it. Do NOT re-run the planner; read its artifacts as your spec.
-${priorFailureSection}
+${priorFailureSection}${userGuidanceSection}
 Work without asking questions. Make reasonable, codebase-grounded decisions. Only
 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.
@@ -8448,7 +9427,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,
-the two-concurrent-instances proof, and the pushed branch + opened pull request.
+the concurrent-instances proof, a clean \`sdk check\` on the recipe file, 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
@@ -8459,6 +9439,12 @@ from the environment, so you never construct signatures yourself. The commands:
   \u2022 ${params.cliCommand} sdk up --url <endpoint-url> --recipe <file> [--test-run-id <id>] [--timeout <seconds>]
         (prints JSON; the response body includes a "refsToken")
   \u2022 ${params.cliCommand} sdk down --url <endpoint-url> --refs-token <token-from-up>
+  \u2022 ${params.cliCommand} sdk check --recipe <file>
+        (no url, no request: holds the FILE to the format Autonoma accepts and prints
+         every problem it finds. Run it whenever you edit the recipe.)
+  \u2022 ${params.cliCommand} sdk up --url <endpoint-url> --recipe <file> --repeat <n>
+        (seeds the recipe n times over WITHOUT tearing down in between, so every
+         instance is live at once - the concurrency proof below)
 The --recipe file may be your full recipe.json or a slice containing just the
 entities under test. Each request times out after 120s by default; a cold
 full-recipe up (first compile + many real-service inserts) can exceed that, so
@@ -8490,19 +9476,34 @@ Once every entity passes independently, run the FULL recipe as one pass:
   \u2022 confirm a WRONG signature is rejected (the SDK does this for you - do not disable it)
   \u2022 confirm the up response's auth payload contains real credentials, not a placeholder
 
-\u2550\u2550\u2550 PROVE TWO INSTANCES CAN COEXIST - MANDATORY, LAST \u2550\u2550\u2550
+\u2550\u2550\u2550 CHECK THE RECIPE FILE - THE GATE YOU CANNOT SKIP \u2550\u2550\u2550
+A recipe that seeds a database perfectly can still be a file Autonoma refuses, because
+\`sdk up\` only ever reads the "create" graph out of it - it never looks at the envelope
+around it. The planner DOES, the moment you exit, and a file it rejects there costs a
+whole re-launch. So before you write the completion marker, run:
+    ${params.cliCommand} sdk check --recipe ${params.recipePath}
+It exits 0 and prints "ok": true only when the file is submittable. Anything else prints
+a "problems" array naming the exact field and what is wrong with it - fix each one in
+${params.recipePath} and run it again. Do NOT write the completion marker until it is
+clean; a passing \`up\` is not a substitute for it.
+
+\u2550\u2550\u2550 PROVE MANY INSTANCES CAN COEXIST - MANDATORY, LAST \u2550\u2550\u2550
 Every check above tears down before the next up, so a recipe whose unique columns hold
-hardcoded values passes all of them. Real test runs OVERLAP: the customer runs two tests
-at once and the second seed hits the first one's rows. Prove yours survives that:
-  1. ${params.cliCommand} sdk up --url <url> --recipe ${params.recipePath} --test-run-id concurrent-a
-  2. ${params.cliCommand} sdk up --url <url> --recipe ${params.recipePath} --test-run-id concurrent-b
-     (do NOT tear down A first - both instances must be up at the same time)
-  3. BOTH must succeed. Then down A, then down B, and confirm in the DB that each
-     teardown removed only its own rows and that nothing is left behind.
-A failure here is a unique-constraint violation, and it names the exact column that is
-not per-run. Fix it where it lives: put a token in that field if the recipe supplies it,
-or derive it from the "testRunId" your handler receives if your factory generates it.
-Then repeat from step 1. Do not weaken the constraint and do not disable the check.
+hardcoded values passes all of them. Real test runs OVERLAP: the customer runs several
+tests at once and the second seed hits the first one's rows. Prove yours survives that:
+    ${params.cliCommand} sdk up --url <url> --recipe ${params.recipePath} --repeat 3
+It seeds the recipe three times over WITHOUT tearing down in between, so all three are
+live at once, then removes every instance it created and reports the teardown. It exits 0
+and prints "ok": true only when every instance came up.
+A failure here is a unique-constraint violation, and the endpoint's error names the exact
+column that is not per-run. Fix it where it lives: put a token in that field if the recipe
+supplies it, or derive it from the "testRunId" your handler receives if your factory
+generates it. Then run it again, and keep going until it passes - each run surfaces the
+next reused value. Do not weaken the constraint and do not disable the check.
+
+If the teardown it reports did NOT complete, go clean those rows out of the database by
+hand before re-running: leftovers from a failed attempt collide with the next one and
+look like a defect in whatever you just changed.
 
 Escape hatch, only after honest attempts: if an entity truly cannot be seeded twice
 concurrently because the app's own schema forces a global singleton, write that in
@@ -8533,9 +9534,10 @@ sitting uncommitted in the working tree:
 
 \u2550\u2550\u2550 FINISH - THE LAST THING YOU DO \u2550\u2550\u2550
 Write the completion marker once ALL of these hold:
-  \u2022 every entity, the full-recipe pass, and the two-concurrent-instances proof are green
+  \u2022 every entity, the full-recipe pass, and the concurrent-instances proof are green
     - or the blocking constraint is documented in IMPLEMENTATION.md
-  \u2022 ${params.recipePath} holds the recipe you validated
+  \u2022 ${params.recipePath} holds the recipe you validated, and \`sdk check\` on it prints
+    "ok": true - this one has no escape hatch; a rejected file blocks the whole setup
   \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
@@ -8564,7 +9566,7 @@ var init_integration_prompt = __esm({
     init_esm_shims();
     init_src();
     init_completion();
-    INTEGRATION_PROMPT_VERSION = 9;
+    INTEGRATION_PROMPT_VERSION = 10;
     INTEGRATION_PROMPT_FILE = "integration-prompt.md";
     DEFAULT_ENDPOINT_PATH = "/api/autonoma";
     INTEGRATION_BRANCH = "autonoma-integration";
@@ -8605,6 +9607,9 @@ var init_state2 = __esm({
 // src/agents/04-recipe-builder/phases/handoff.ts
 import { rm as rm2 } from "fs/promises";
 import { join as join27 } from "path";
+function launchMessage(promptFile) {
+  return `Read the file ${promptFile} and follow its instructions exactly to integrate Autonoma into this application. It is your complete spec. Do not stop until every item in it is done and you have written the completion marker it describes.`;
+}
 async function runHandoffPhase(state, deps, outputDir) {
   const recipePath = state.recipePath ?? join27(outputDir, RECIPE_FILE);
   state.recipePath = recipePath;
@@ -8626,7 +9631,9 @@ async function runHandoffPhase(state, deps, outputDir) {
     outputDir,
     recipePath,
     cliCommand: deps.cliCommand,
-    interactive: deps.interactive
+    interactive: deps.interactive,
+    priorFailure: state.priorFailure,
+    userGuidance: state.userGuidance
   });
   state.launchAttempts = (state.launchAttempts ?? 0) + 1;
   await saveRecipeState(outputDir, state);
@@ -8642,7 +9649,7 @@ async function runCompletionPhase(state, deps, outputDir) {
       log.success("The agent reported the integration complete and validated.");
       return { kind: "advance" };
     }
-    const failure = describeIncompleteRecipe(read, uploadProblems);
+    const failure = describeIncompleteRecipe(read, uploadProblems, recipePath, deps.cliCommand);
     const launcher = await selectLauncher(deps.launchers, state.agentId ?? deps.presetAgentId, deps.interactive);
     if (launcher != null && (state.launchAttempts ?? 0) < MAX_LAUNCH_ATTEMPTS) {
       log.warn("The integration isn't complete yet. Launching the agent to finish it...");
@@ -8654,7 +9661,8 @@ async function runCompletionPhase(state, deps, outputDir) {
         recipePath,
         cliCommand: deps.cliCommand,
         interactive: deps.interactive,
-        priorFailure: failure
+        priorFailure: failure,
+        userGuidance: state.userGuidance
       });
       state.launchAttempts = (state.launchAttempts ?? 0) + 1;
       await saveRecipeState(outputDir, state);
@@ -8673,7 +9681,8 @@ async function launchAgent(launcher, permissionMode, target) {
     outputDir: target.outputDir,
     recipePath: target.recipePath,
     cliCommand: target.cliCommand,
-    priorFailure: target.priorFailure
+    priorFailure: target.priorFailure,
+    userGuidance: target.userGuidance
   });
   await rm2(join27(target.outputDir, COMPLETION_MARKER_FILE), { force: true }).catch((err) => {
     debugLog("Could not clear a stale completion marker", { err });
@@ -8693,23 +9702,35 @@ async function launchAgent(launcher, permissionMode, target) {
   }
   suspend();
   try {
-    const exitCode = await launcher.launch(promptFile, permissionMode, target.interactive);
+    const exitCode = await launcher.launch({
+      message: launchMessage(promptFile),
+      permissionMode,
+      interactive: target.interactive,
+      // An interactive session sits open after its final message, so the marker
+      // the agent writes is the real "done" signal. A headless run exits on its
+      // own and needs no watcher.
+      watch: target.interactive ? (proc) => watchForCompletion(target.outputDir, proc) : void 0
+    });
     log.info(`${launcher.label} exited (code ${exitCode ?? "unknown"}). Back to the planner.`);
   } finally {
     resume();
   }
 }
-function describeIncompleteRecipe(read, uploadProblems) {
+function describeIncompleteRecipe(read, uploadProblems, recipePath, cliCommand) {
+  const recheck = `Fix ${recipePath}, then re-check it with:
+  ${cliCommand} sdk check --recipe ${recipePath}`;
   if (read.status === "absent") {
-    return "No completed recipe.json was produced, so there is nothing validated to submit.";
+    return `No completed recipe.json was produced, so there is nothing validated to submit. It belongs at ${recipePath}.`;
   }
   if (read.status === "invalid") {
-    return `${RECIPE_FILE} does not match the recipe format Autonoma accepts:
-` + read.problems.map((problem) => `  - ${problem}`).join("\n");
+    return `${recipePath} does not match the recipe format Autonoma accepts:
+` + read.problems.map((problem) => `  - ${problem}`).join("\n") + `
+${recheck}`;
   }
   if (uploadProblems.length > 0) {
-    return `recipe.json will be rejected on upload:
-` + uploadProblems.map((problem) => `  - ${problem}`).join("\n");
+    return `${RECIPE_FILE} will be rejected on upload:
+` + uploadProblems.map((problem) => `  - ${problem}`).join("\n") + `
+${recheck}`;
   }
   return "The agent exited without marking the integration complete (see its IMPLEMENTATION.md for what's left).";
 }
@@ -8732,13 +9753,14 @@ var init_handoff = __esm({
   "src/agents/04-recipe-builder/phases/handoff.ts"() {
     "use strict";
     init_esm_shims();
+    init_coding_agent();
     init_debug();
     init_interrupt();
     init_notify();
     init_prompts();
     init_completion();
+    init_completion_watch();
     init_integration_prompt();
-    init_launcher();
     init_recipe();
     init_state2();
     MAX_LAUNCH_ATTEMPTS = 2;
@@ -8771,6 +9793,9 @@ function outcomeToResult(outcome) {
 async function runRecipeBuilder(input) {
   const { outputDir } = input;
   const state = await loadRecipeState(outputDir) ?? initialRecipeState();
+  state.launchAttempts = 0;
+  if (input.retryGuidance != null) state.userGuidance = input.retryGuidance;
+  await saveRecipeState(outputDir, state);
   if (state.sharedSecret == null) {
     state.sharedSecret = input.config.sharedSecret ?? generateSharedSecret();
     await saveRecipeState(outputDir, state);
@@ -8839,9 +9864,9 @@ var init_recipe_builder = __esm({
   "src/agents/04-recipe-builder/index.ts"() {
     "use strict";
     init_esm_shims();
+    init_coding_agent();
     init_prompts();
     init_entity_order();
-    init_launcher();
     init_handoff();
     init_submit();
     init_state2();
@@ -9707,7 +10732,7 @@ var init_recipe_context = __esm({
 
 // 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";
+import { dirname as dirname3 } from "path";
 async function restoreDeletedTest(testPath, originalContent) {
   try {
     await access(testPath);
@@ -9716,7 +10741,7 @@ async function restoreDeletedTest(testPath, originalContent) {
     debugLog("Test absent after its fix pass - restoring the pre-review content", { testPath, err });
   }
   try {
-    await mkdir3(dirname4(testPath), { recursive: true });
+    await mkdir3(dirname3(testPath), { recursive: true });
     await writeFile11(testPath, originalContent, "utf-8");
     return true;
   } catch (err) {
@@ -10454,7 +11479,7 @@ var init_test_spec = __esm({
 
 // 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 { dirname as dirname4, 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) {
@@ -10489,7 +11514,7 @@ function buildWriteTestTool(state, outputDir, onWritten) {
         };
       }
       try {
-        await mkdir4(dirname5(absPath), { recursive: true });
+        await mkdir4(dirname4(absPath), { recursive: true });
         await writeFile12(absPath, content, "utf-8");
         state.markTested(nodeId, [relPath]);
         await saveBfsState(outputDir, state);
@@ -11878,7 +12903,7 @@ var init_countdown = __esm({
 });
 
 // src/ui/draw/help.ts
-function wrap(text2, maxW) {
+function wrap2(text2, maxW) {
   const words = text2.split(/\s+/);
   const lines = [];
   let cur = "";
@@ -11900,7 +12925,7 @@ function drawHelpModal(g, state) {
   const innerW = w - 6;
   const step = state.currentStep;
   const intro2 = step != null ? STEP_INTROS[step] : "The run has no active step right now.";
-  const introLines = wrap(intro2, innerW);
+  const introLines = wrap2(intro2, innerW);
   const docsUrl = step != null ? STEP_DOCS[step] : void 0;
   const pipelineLines = state.stepOrder.length;
   const keys = [
@@ -13577,6 +14602,114 @@ function shortHash(seed) {
 // src/agents/04-recipe-builder/sdk-command.ts
 import { z as z35 } from "zod";
 
+// src/core/cli-args.ts
+init_esm_shims();
+var CliArgs = class _CliArgs {
+  /** Absent value means the flag was given with no value at all. */
+  constructor(flags) {
+    this.flags = flags;
+  }
+  static parse(argv) {
+    const flags = /* @__PURE__ */ new Map();
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i] ?? "";
+      if (!arg.startsWith("--")) continue;
+      const body = arg.slice(2);
+      const equals = body.indexOf("=");
+      if (equals !== -1) {
+        push(flags, body.slice(0, equals), body.slice(equals + 1));
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next != null && next.length > 0 && !next.startsWith("--")) {
+        push(flags, body, next);
+        i++;
+        continue;
+      }
+      push(flags, body, void 0);
+    }
+    return new _CliArgs(flags);
+  }
+  /** Whether any of these spellings was given at all, with or without a value. */
+  has(...names) {
+    return names.some((name) => this.flags.has(name));
+  }
+  /**
+   * The value of the first of these spellings that carries one. A flag given with
+   * no value has none - `--project` alone means the caller forgot the path, not
+   * that the path is "true".
+   */
+  value(...names) {
+    for (const name of names) {
+      const values = this.flags.get(name);
+      if (values != null && values.length > 0) return values[values.length - 1];
+    }
+    return void 0;
+  }
+  /**
+   * Every value given across these spellings, comma-separated lists expanded. So
+   * `--backend api --backend db` and `--backends api,db` mean the same thing, and
+   * neither has to be the one the caller happened to guess.
+   *
+   * Undefined when the flag was never given - which is different from given-empty,
+   * because a caller who explicitly asked for no backends should get none rather
+   * than the ones something else inferred.
+   */
+  list(...names) {
+    const given = names.flatMap((name) => this.flags.get(name) ?? []);
+    if (!this.has(...names)) return void 0;
+    return given.flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+  }
+  /**
+   * Flags that are not in `known`, with the closest thing that is.
+   *
+   * A misspelled `--non-interactive` is the worst kind of typo here: nothing
+   * refuses it, and the run instead waits on questions nobody will answer. Naming
+   * it back turns a silent stall into one line of output.
+   */
+  unrecognized(known) {
+    const found = [];
+    for (const name of this.flags.keys()) {
+      if (known.has(name)) continue;
+      const meant = closestMatch(name, known);
+      found.push(meant != null ? { given: name, meant } : { given: name });
+    }
+    return found;
+  }
+};
+function push(flags, name, value) {
+  const existing = flags.get(name) ?? [];
+  if (value != null) existing.push(value);
+  flags.set(name, existing);
+}
+var MAX_TYPO_DISTANCE = 3;
+function closestMatch(name, known) {
+  let best;
+  let bestDistance = MAX_TYPO_DISTANCE + 1;
+  for (const candidate of known) {
+    const distance = editDistance(name, candidate);
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return bestDistance <= MAX_TYPO_DISTANCE ? best : void 0;
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+      const deletion = (previous[j] ?? 0) + 1;
+      const insertion = (current[j - 1] ?? 0) + 1;
+      current.push(Math.min(substitution, deletion, insertion));
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+
 // src/agents/04-recipe-builder/http-client.ts
 init_esm_shims();
 import { createHmac } from "crypto";
@@ -13623,7 +14756,9 @@ async function down(config, refsToken) {
 }
 
 // src/agents/04-recipe-builder/sdk-command.ts
+init_recipe();
 var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+var MIN_REPEAT_INSTANCES = 2;
 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) });
@@ -13632,16 +14767,40 @@ var flagsSchema = z35.object({
   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();
+  timeout: z35.coerce.number().int().positive().optional(),
+  repeat: z35.coerce.number().int().min(MIN_REPEAT_INSTANCES).optional()
+});
+var SDK_FLAGS = new Set(Object.keys(flagsSchema.shape));
 async function runSdkCommand(argv, io) {
   const action = argv[0];
+  const args = CliArgs.parse(argv.slice(1));
+  const unknown = args.unrecognized(SDK_FLAGS);
+  if (unknown.length > 0) {
+    io.stderr(`Unknown flag(s): ${unknown.map(describeUnknownFlag).join("; ")}
+`);
+    return 2;
+  }
+  if (action === "check") {
+    const recipe = args.value("recipe");
+    if (recipe == null || recipe === "") {
+      io.stderr("--recipe <file> is required for `check`.\n");
+      return 2;
+    }
+    return await runCheck(recipe, io);
+  }
   const sharedSecret = io.env.AUTONOMA_SHARED_SECRET;
   if (sharedSecret == null || sharedSecret === "") {
     io.stderr("AUTONOMA_SHARED_SECRET is not set in the environment.\n");
     return 2;
   }
-  const parsedFlags = flagsSchema.safeParse(tokenizeFlags(argv.slice(1)));
+  const parsedFlags = flagsSchema.safeParse({
+    url: args.value("url"),
+    recipe: args.value("recipe"),
+    "refs-token": args.value("refs-token"),
+    "test-run-id": args.value("test-run-id"),
+    timeout: args.value("timeout"),
+    repeat: args.value("repeat")
+  });
   if (!parsedFlags.success) {
     io.stderr(`Invalid flags: ${formatIssues(parsedFlags.error)}
 `);
@@ -13661,16 +14820,17 @@ async function runSdkCommand(argv, io) {
         io.stderr("--recipe <file> is required for `up`.\n");
         return 2;
       }
-      const testRunId = flags["test-run-id"] ?? `cli-${Date.now()}`;
+      const baseRunId = flags["test-run-id"] ?? `cli-${Date.now()}`;
       const slice = await loadRecipeSlice(flags.recipe);
+      if (flags.repeat != null) return await runRepeatedUps(config, slice, baseRunId, flags.repeat, io);
       const resolution = resolveRecipeCreateGraph({
         create: slice.create,
         variables: slice.variables,
-        testRunId
+        testRunId: baseRunId
       });
       const create = createSchema.parse(resolution.createPayload);
-      return emit2(io, await up(config, create, testRunId), {
-        testRunId,
+      return emit2(io, await up(config, create, baseRunId), {
+        testRunId: baseRunId,
         resolvedVariables: resolution.resolvedVariables
       });
     }
@@ -13681,7 +14841,7 @@ async function runSdkCommand(argv, io) {
       }
       return emit2(io, await down(config, flags["refs-token"]));
     }
-    io.stderr(`Unknown sdk action "${action ?? ""}". Use one of: discover | up | down.
+    io.stderr(`Unknown sdk action "${action ?? ""}". Use one of: discover | up | down | check.
 `);
     return 2;
   } catch (err) {
@@ -13693,6 +14853,116 @@ async function runSdkCommand(argv, io) {
     return 1;
   }
 }
+async function runRepeatedUps(config, slice, baseRunId, instances, io) {
+  const seeded = [];
+  for (let index = 1; index <= instances; index++) {
+    const testRunId = `${baseRunId}-${index}`;
+    const resolution = resolveRecipeCreateGraph({
+      create: slice.create,
+      variables: slice.variables,
+      testRunId
+    });
+    const create = createSchema.parse(resolution.createPayload);
+    const res = await up(config, create, testRunId);
+    const refsToken = readRefsToken(res.body);
+    seeded.push({
+      instance: index,
+      testRunId,
+      ok: res.ok,
+      status: res.status,
+      refsToken,
+      body: res.ok ? void 0 : res.body
+    });
+    if (!res.ok) break;
+  }
+  const failed = seeded.find((instance) => !instance.ok);
+  const teardown2 = await tearDownInstances(config, seeded);
+  io.stdout(
+    JSON.stringify(
+      {
+        ok: failed == null,
+        action: "up",
+        repeat: instances,
+        instances: seeded,
+        teardown: teardown2,
+        hint: repeatHint(failed, instances, teardown2)
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  return failed == null && teardown2.every((result) => result.ok) ? 0 : 1;
+}
+async function tearDownInstances(config, seeded) {
+  const results = [];
+  for (const instance of [...seeded].reverse()) {
+    if (instance.refsToken == null) {
+      results.push({
+        testRunId: instance.testRunId,
+        ok: false,
+        detail: "no refsToken in the up response - anything it wrote before failing is still there"
+      });
+      continue;
+    }
+    try {
+      const res = await down(config, instance.refsToken);
+      results.push({
+        testRunId: instance.testRunId,
+        ok: res.ok,
+        detail: res.ok ? void 0 : `down returned HTTP ${res.status}`
+      });
+    } catch (err) {
+      results.push({
+        testRunId: instance.testRunId,
+        ok: false,
+        detail: `down failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return results;
+}
+function repeatHint(failed, instances, teardown2) {
+  const leaked = teardown2.filter((result) => !result.ok).map((result) => result.testRunId);
+  const leakNote = leaked.length > 0 ? ` Teardown did NOT complete for ${leaked.join(", ")} - check the database by hand.` : "";
+  if (failed == null) {
+    return `All ${instances} instances were live at the same time, so nothing in this recipe is single-instance.${leakNote}`;
+  }
+  return `Instance ${failed.instance} failed to seed while instance ${failed.instance - 1} was still up (HTTP ${failed.status}). That is a value this recipe reuses across runs: read the error above for the constraint it violated, then put {{testRunId}} or {{testRunShortId}} inside that field - or derive it from the testRunId your factory receives. Do not weaken the constraint.${leakNote}`;
+}
+function readRefsToken(body) {
+  if (!isRecord(body)) return void 0;
+  return typeof body.refsToken === "string" ? body.refsToken : void 0;
+}
+async function runCheck(recipePath, io) {
+  const read = await loadRecipeFile(recipePath);
+  if (read.status === "absent") {
+    io.stdout(
+      JSON.stringify(
+        { ok: false, recipe: recipePath, problems: [`${recipePath} does not exist - write it first.`] },
+        null,
+        2
+      ) + "\n"
+    );
+    return 1;
+  }
+  if (read.status === "invalid") {
+    io.stdout(JSON.stringify({ ok: false, recipe: recipePath, problems: read.problems }, null, 2) + "\n");
+    return 1;
+  }
+  const problems = findRecipeUploadProblems(read.recipe);
+  const summary = read.recipe.recipes.map((entry) => ({
+    name: entry.name,
+    entities: Object.keys(entry.create).length,
+    records: Object.values(entry.create).reduce(
+      (total, rows) => total + (Array.isArray(rows) ? rows.length : 0),
+      0
+    )
+  }));
+  io.stdout(
+    JSON.stringify({ ok: problems.length === 0, recipe: recipePath, problems, recipes: summary }, null, 2) + "\n"
+  );
+  return problems.length === 0 ? 0 : 1;
+}
 function emit2(io, res, resolution) {
   const output = resolution == null ? { ok: res.ok, status: res.status, body: res.body } : {
     ok: res.ok,
@@ -13722,26 +14992,8 @@ async function loadRecipeSlice(file) {
     `${file} is not a valid recipe: expected a full recipe envelope, a { create } object, or a bare { Entity: [records] } map.`
   );
 }
-function tokenizeFlags(argv) {
-  const flags = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg.startsWith("--")) continue;
-    const body = arg.slice(2);
-    const eq = body.indexOf("=");
-    if (eq !== -1) {
-      flags[body.slice(0, eq)] = body.slice(eq + 1);
-      continue;
-    }
-    const next = argv[i + 1];
-    if (next != null && !next.startsWith("--")) {
-      flags[body] = next;
-      i++;
-    } else {
-      flags[body] = "true";
-    }
-  }
-  return flags;
+function describeUnknownFlag(unknown) {
+  return unknown.meant != null ? `--${unknown.given} (did you mean --${unknown.meant}?)` : `--${unknown.given}`;
 }
 function formatIssues(error) {
   return error.issues.map((i) => i.path.length > 0 ? `--${i.path.join(".")}: ${i.message}` : i.message).join("; ");
@@ -13833,6 +15085,7 @@ function loadConfig(args) {
     autonomaApiUrl: resolveApiUrl(env.AUTONOMA_API_URL),
     autonomaApiToken: env.AUTONOMA_API_TOKEN,
     autonomaGenerationId: env.AUTONOMA_GENERATION_ID,
+    autonomaApplicationId: env.AUTONOMA_APPLICATION_ID,
     agent: args.agent,
     permissionMode: args.permissionMode
   };
@@ -13841,8 +15094,228 @@ function loadConfig(args) {
 // src/index.ts
 init_analytics();
 init_colors();
+
+// src/core/dry-run-phase.ts
+init_esm_shims();
+init_prompts();
+init_debug();
+init_errors();
+init_logs();
+var TARGET_POLL_MS = 1e4;
+var TARGET_READY_TIMEOUT_MS = 20 * 6e4;
+var NO_PREVIEW_GRACE_MS = 6e4;
+var MAX_QUOTED_FAILURES = 3;
+var DEFAULT_TIMING = {
+  pollMs: TARGET_POLL_MS,
+  readyTimeoutMs: TARGET_READY_TIMEOUT_MS,
+  noPreviewGraceMs: NO_PREVIEW_GRACE_MS
+};
+async function runDryRunPhase(deps) {
+  const timing = deps.timing ?? DEFAULT_TIMING;
+  const { client, applicationId } = deps;
+  const [scenarios, listing] = await Promise.all([
+    client.listScenarios(applicationId),
+    client.listDryRunTargets(applicationId)
+  ]);
+  if (scenarios.length === 0) {
+    captureLog("info", "No scenarios to dry run", { source: "dry_run" });
+    return { kind: "no-scenarios" };
+  }
+  const chosen = pickDryRunTarget(listing, deps.checkedOutBranch);
+  if (chosen == null) {
+    return {
+      kind: "no-target",
+      reason: "Autonoma has no preview environment to run your scenarios against yet. Open a pull request (or wait for your main preview to deploy) and run again."
+    };
+  }
+  const unsupported = describeUnsupportedTarget(chosen);
+  if (unsupported != null) return { kind: "unsupported-target", reason: unsupported };
+  log.info(`Checking your Autonoma SDK against the "${chosen.label}" preview...`);
+  const target = await waitForReadyTarget(client, applicationId, chosen, timing);
+  if (target.kind === "gone") return { kind: "no-target", reason: target.reason };
+  const discovery = await discoverSdk(client, applicationId, target.target, timing);
+  if (discovery != null) return { kind: "discovery-failed", reason: discovery };
+  return await dryRunScenarios(client, applicationId, target.target.id, scenarios);
+}
+function pickDryRunTarget(listing, checkedOutBranch) {
+  const onCheckedOutBranch = checkedOutBranch == null ? void 0 : listing.targets.find((target) => target.branchName === checkedOutBranch);
+  if (onCheckedOutBranch != null) return onCheckedOutBranch;
+  const detected = listing.targets.find((target) => target.id === listing.autoDetectedTargetId);
+  if (detected != null) return detected;
+  return listing.targets.find((target) => target.availability === "ready");
+}
+function describeUnsupportedTarget(target) {
+  if (target.source === "previewkit") return void 0;
+  if (target.source === "vercel") {
+    return `Your previews are built by Vercel, so the scenario dry run runs against the deployment you pick. Choose it on the SDK step in the Autonoma app and validate there - everything else in this run is done.`;
+  }
+  return `Your previews come from your own pipeline, and validating one needs the signing secret your pipeline signs with - which never leaves your side. Enter it on the SDK step in the Autonoma app to finish - everything else in this run is done.`;
+}
+async function waitForReadyTarget(client, applicationId, initial, timing) {
+  const startedAt = Date.now();
+  const deadline = startedAt + timing.readyTimeoutMs;
+  const noPreviewDeadline = startedAt + Math.min(timing.noPreviewGraceMs, timing.readyTimeoutMs);
+  let target = initial;
+  while (true) {
+    if (target.availability === "ready") return { kind: "ready", target };
+    if (target.availability === "failed") {
+      return {
+        kind: "gone",
+        reason: `The "${target.label}" preview failed to deploy, so there is nothing to run your scenarios against${target.error != null ? `: ${target.error}` : "."}`
+      };
+    }
+    if (target.availability === "no_preview" && Date.now() >= noPreviewDeadline) {
+      return {
+        kind: "gone",
+        reason: `The "${target.label}" pull request has no preview environment, so there is nothing to run your scenarios against. A draft pull request does not get one - mark it ready for review so a preview builds, then run again.`
+      };
+    }
+    if (Date.now() >= deadline) {
+      return {
+        kind: "gone",
+        reason: `The "${target.label}" preview was still building after ${Math.round(timing.readyTimeoutMs / 6e4)} minutes, so the scenario dry run was skipped. Run again once it is up.`
+      };
+    }
+    debugLog("Waiting for the dry-run preview to deploy", {
+      target: target.id,
+      availability: target.availability
+    });
+    await sleep(timing.pollMs);
+    const listing = await client.listDryRunTargets(applicationId).catch((err) => {
+      debugLog("Could not re-read the dry-run targets", { err });
+      return void 0;
+    });
+    const refreshed = listing?.targets.find((candidate) => candidate.id === target.id);
+    if (refreshed != null) target = refreshed;
+  }
+}
+async function discoverSdk(client, applicationId, target, timing) {
+  try {
+    const prepared = await client.prepareSdkTarget(applicationId, target.id);
+    if (prepared.status === "redeploy_started") {
+      log.info(`Redeploying the "${target.label}" preview with its Autonoma secrets...`);
+      const back = await waitForRedeploy(client, applicationId, target, timing);
+      if (back != null) return back;
+    }
+    for (const allowSelfHeal of [true, false]) {
+      const result = await client.configureAndDiscoverSdkTarget(applicationId, target.id, allowSelfHeal);
+      if (result.status === "discovered") {
+        log.success("Your Autonoma SDK answered - Autonoma knows your data models.");
+        captureLog("info", "SDK discovery succeeded", { source: "dry_run", target: target.id });
+        return void 0;
+      }
+      log.info(`Refreshing the "${target.label}" preview's Autonoma secrets...`);
+      const back = await waitForRedeploy(client, applicationId, target, timing);
+      if (back != null) return back;
+    }
+    return `The "${target.label}" preview kept redeploying instead of answering. Try again from the Autonoma app.`;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    captureLog("warn", "SDK discovery failed", { source: "dry_run", target: target.id });
+    return `Your Autonoma SDK endpoint didn't answer, so the scenario dry run was skipped: ${message}
+Its own logs are on the SDK step in the Autonoma app, which is also where you can retry.`;
+  }
+}
+async function waitForRedeploy(client, applicationId, target, timing) {
+  const back = await waitForReadyTarget(client, applicationId, { ...target, availability: "building" }, timing);
+  return back.kind === "ready" ? void 0 : back.reason;
+}
+async function dryRunScenarios(client, applicationId, targetId, scenarios) {
+  log.info(`Running ${scenarios.length} scenario${scenarios.length === 1 ? "" : "s"} against your preview...`);
+  const failures = [];
+  for (const scenario of scenarios) {
+    const result = await client.runScenarioDryRun(applicationId, scenario.id, targetId).catch((err) => ({ success: false, phase: void 0, error: err }));
+    if (result.success) {
+      log.success(`${scenario.name} - provisioned and torn down.`);
+      continue;
+    }
+    const failure = {
+      scenario: scenario.name,
+      phase: result.phase,
+      reason: formatDryRunError(result.error)
+    };
+    failures.push(failure);
+    log.warn(`${scenario.name} - failed${failure.reason != null ? `: ${failure.reason}` : "."}`);
+  }
+  const passed = scenarios.length - failures.length;
+  captureLog(failures.length > 0 ? "warn" : "info", "Scenario dry run finished", {
+    source: "dry_run",
+    scenario_count: scenarios.length,
+    passed_count: passed
+  });
+  if (failures.length === 0) return { kind: "passed", scenarios: scenarios.length };
+  return { kind: "failed", passed, failures };
+}
+function formatDryRunError(error) {
+  if (error == null) return void 0;
+  if (typeof error === "string") return error.length > 0 ? error : void 0;
+  if (error instanceof Error) return error.message;
+  return JSON.stringify(error);
+}
+function describeDryRunOutcome(outcome) {
+  if (outcome.kind === "passed") return void 0;
+  if (outcome.kind === "no-scenarios") {
+    return "There were no scenarios to provision, so nothing was dry run. Autonoma's tests will run against whatever state your app is already in.";
+  }
+  if (outcome.kind === "no-target" || outcome.kind === "unsupported-target") return outcome.reason;
+  if (outcome.kind === "discovery-failed") return outcome.reason;
+  const quoted = outcome.failures.slice(0, MAX_QUOTED_FAILURES).map((failure) => {
+    const where = failure.phase != null ? ` (${failure.phase})` : "";
+    return `  - ${failure.scenario}${where}${failure.reason != null ? `: ${failure.reason}` : ""}`;
+  }).join("\n");
+  const rest = outcome.failures.length - MAX_QUOTED_FAILURES;
+  return `${outcome.failures.length} of ${outcome.failures.length + outcome.passed} scenarios could not be provisioned:
+${quoted}${rest > 0 ? `
+  ...and ${rest} more` : ""}
+Fix them on the dry-run step in the Autonoma app, where a coding agent can read your SDK's own logs.`;
+}
+
+// src/index.ts
 init_errors();
 
+// src/core/finish-phase.ts
+init_esm_shims();
+init_debug();
+init_logs();
+init_onboarding_phase();
+async function runFinishPhase(deps) {
+  const dryRun = await runDryRunPhase({
+    client: deps.client,
+    applicationId: deps.applicationId,
+    checkedOutBranch: deps.checkedOutBranch,
+    timing: deps.timing
+  });
+  const repair = dryRun.kind === "passed" ? void 0 : await deps.repair?.(dryRun);
+  const state = await deps.client.getOnboardingState(deps.applicationId);
+  const live = isStepAtOrPast(state.step, LIVE_STEP);
+  debugLog("Finish phase complete", { dryRun: dryRun.kind, repair: repair?.kind, step: state.step, live });
+  captureLog("info", "Front-door run finished", {
+    source: "finish_phase",
+    dry_run: dryRun.kind,
+    repair: repair?.kind ?? "not_needed",
+    step: state.step,
+    live,
+    artifacts_uploaded: state.artifactsUploaded,
+    sdk_configured: state.sdkConfigured,
+    dry_run_passed: state.dryRunPassed
+  });
+  return { dryRun, state, live };
+}
+function describeFinishPhase(result) {
+  const { state } = result;
+  return [
+    `Test suite: ${state.artifactsUploaded ? "uploaded to Autonoma" : "not uploaded yet"}`,
+    `Autonoma SDK: ${state.sdkConfigured ? "connected to your app" : "not answering yet"}`,
+    `Scenario data: ${describeDryRunState(result)}`,
+    result.live ? "Autonoma is reviewing your pull requests." : "Autonoma is not reviewing your pull requests yet - take your app live in the Autonoma app to finish."
+  ];
+}
+function describeDryRunState(result) {
+  if (result.state.dryRunPassed) return "provisions against your preview";
+  if (result.dryRun.kind === "no-scenarios") return "no scenarios to provision";
+  return "not confirmed yet";
+}
+
 // src/core/flush-telemetry.ts
 init_esm_shims();
 init_replay_transport();
@@ -13852,6 +15325,176 @@ async function flushTelemetry() {
   await Promise.all([flushAnalytics(), flushLogs(), flushReplay()]);
 }
 
+// src/index.ts
+init_front_door();
+
+// src/core/help.ts
+init_esm_shims();
+init_colors();
+var DOCS_URL = "https://docs.autonoma.app/test-planner/";
+var LLMS_URL = "https://docs.autonoma.app/llms.txt";
+var LLMS_FULL_URL = "https://docs.autonoma.app/llms-full.txt";
+var FLAGS = [
+  {
+    names: ["project"],
+    argument: "<path>",
+    summary: "The repository to plan tests for. Defaults to the current directory."
+  },
+  {
+    names: ["non-interactive"],
+    summary: "Never ask a question. Every input has to be a flag, the coding agent runs headless and autonomous, and the run authorizes with an API key instead of a browser."
+  },
+  {
+    names: ["frontend"],
+    argument: "<path>",
+    summary: "The one frontend directory to plan tests for. Only needed in a repository with more than one - a single-app repository resolves itself."
+  },
+  {
+    names: ["backend", "backends"],
+    argument: "<path>",
+    summary: "A backend or data layer that frontend talks to. Repeatable, and also accepts a comma-separated list. Omit to use the dependencies the run infers."
+  },
+  {
+    names: ["agent", "coding-agent"],
+    argument: "<claude|codex>",
+    summary: "Which coding agent to hand the preview environment and the SDK integration to. Omit to use whichever is installed; required when both are and nobody can be asked."
+  },
+  {
+    names: ["permission-mode"],
+    argument: "<default|acceptEdits|bypassPermissions>",
+    summary: "How much autonomy that agent runs with. Defaults to bypassPermissions, which is the only one that means anything without a human at the keyboard."
+  },
+  {
+    names: ["resume"],
+    summary: "Continue a previous run from where it stopped instead of starting over."
+  },
+  {
+    names: ["fresh"],
+    summary: "Discard a previous run's output and start over. The opposite of --resume."
+  },
+  {
+    names: ["step"],
+    argument: "<name>",
+    summary: "Run a single step and stop. For debugging one step in isolation - it is not how a caller sequences a run, which happens in one invocation."
+  },
+  {
+    names: ["model"],
+    argument: "<id>",
+    summary: "Override the model the analysis runs on."
+  },
+  {
+    names: ["slug"],
+    argument: "<name>",
+    summary: "Override the output folder name under ~/.autonoma/."
+  },
+  {
+    names: ["help"],
+    summary: "Print this."
+  }
+];
+var KNOWN_FLAGS = new Set(FLAGS.flatMap((flag) => flag.names));
+var FLAG_COLUMN = 34;
+var WHAT_IT_DOES = [
+  "Autonoma's planner reads a codebase and produces the end-to-end test suite for it - the pages,",
+  "the data models, the flows a user actually takes - and hands the parts that need judgement to a",
+  "coding agent you already have installed. One invocation does the whole thing:",
+  "",
+  "  1. Preview environment   Your coding agent sets up a real deployment of your app, built per",
+  "                           pull request, that Autonoma tests against. Skipped when you already",
+  "                           have one.",
+  "  2. Project map           Which directories are frontends, which are backends, which to ignore.",
+  "  3. Pages and flows       What your app can do, read from its source rather than guessed.",
+  "  4. Knowledge base        A written account of the app the later steps plan against.",
+  "  5. Data models           An audit of the entities your test data has to create.",
+  "  6. Test scenarios        The named app states your tests depend on.",
+  "  7. Test data             Your coding agent wires the Autonoma SDK into your repo and writes a",
+  "                           factory per entity, validating each against your running app.",
+  "  8. Test suite            The test cases themselves, then uploaded to Autonoma.",
+  "",
+  "Nothing here is a step list to run one at a time. There is one command, it runs to the end, and",
+  "it resumes from where it stopped if it is interrupted."
+];
+var HEADLESS = [
+  "With --non-interactive there is nobody to answer a question, so anything that would have been",
+  "asked has to arrive as a flag. What the run does about that:",
+  "",
+  "  - It never opens a browser. The coding agent's Autonoma connection is authorized with the",
+  "    AUTONOMA_API_TOKEN this run already holds.",
+  "  - It never blocks on a question. Where it has to assume an answer it says so on stdout,",
+  "    naming what was asked and what it took.",
+  "  - It reports each step as it starts and finishes, with how long it took, so the process that",
+  "    launched it can follow along.",
+  "  - It refuses rather than guesses when a choice would be arbitrary - two coding agents",
+  "    installed and no --agent, several frontends and no --frontend."
+];
+var ENVIRONMENT = [
+  "  AUTONOMA_API_TOKEN        Required. The run's credential. Create one in Settings -> API keys.",
+  "  AUTONOMA_APPLICATION_ID   The Autonoma app this run belongs to. Set it and the run also sets",
+  "                            up the preview environment and validates the result; leave it unset",
+  "                            and the planner runs standalone against any repository.",
+  "  AUTONOMA_API_URL          Point at a non-production Autonoma. Defaults to production.",
+  "  AUTONOMA_DEBUG            Set to anything for verbose diagnostics on stderr.",
+  "  DONT_TRACK                Set to anything to turn off analytics, logs and session replay."
+];
+function renderHelp() {
+  return [
+    `${BOLD}autonoma-planner${RESET} - generate an end-to-end test suite from your codebase`,
+    "",
+    `${BOLD}USAGE${RESET}`,
+    "  autonoma-planner [run] [flags]      Plan and generate the suite. `run` may be omitted.",
+    "  autonoma-planner status             Show what a previous run completed.",
+    "  autonoma-planner upload             Re-upload an already-generated suite.",
+    "  autonoma-planner help               Print this.",
+    "",
+    `${BOLD}WHAT IT DOES${RESET}`,
+    ...WHAT_IT_DOES.map(indent),
+    "",
+    `${BOLD}FLAGS${RESET}`,
+    ...FLAGS.map(renderFlag),
+    "",
+    `${BOLD}RUNNING WITHOUT A HUMAN${RESET}`,
+    ...HEADLESS.map(indent),
+    "",
+    `${BOLD}ENVIRONMENT${RESET}`,
+    ...ENVIRONMENT,
+    "",
+    `${BOLD}DOCUMENTATION${RESET}`,
+    `  ${DOCS_URL}`,
+    `  ${DIM}${LLMS_URL} - every page, as a list, for an agent to read${RESET}`,
+    `  ${DIM}${LLMS_FULL_URL} - all of it in one file${RESET}`,
+    ""
+  ].join("\n");
+}
+function indent(line) {
+  return line.length > 0 ? `  ${line}` : line;
+}
+function renderFlag(flag) {
+  const spellings = flag.names.map((name) => `--${name}`).join(", ");
+  const left = `  ${spellings}${flag.argument != null ? ` ${flag.argument}` : ""}`;
+  const indented = wrap(flag.summary, 92 - FLAG_COLUMN).map((line) => `${" ".repeat(FLAG_COLUMN)}${line}`);
+  if (left.length >= FLAG_COLUMN) return [left, ...indented].join("\n");
+  const [first, ...rest] = indented;
+  return [`${left}${(first ?? "").slice(left.length)}`, ...rest].join("\n");
+}
+function wrap(text2, width) {
+  const lines = [];
+  let current = "";
+  for (const word of text2.split(" ")) {
+    if (current.length === 0) {
+      current = word;
+      continue;
+    }
+    if (current.length + 1 + word.length > width) {
+      lines.push(current);
+      current = word;
+      continue;
+    }
+    current = `${current} ${word}`;
+  }
+  if (current.length > 0) lines.push(current);
+  return lines;
+}
+
 // src/index.ts
 init_interrupt();
 init_logs();
@@ -14033,12 +15676,13 @@ async function uploadArtifacts(config, outputDir) {
   await postJson(`${setupUrl}/artifacts`, autonomaApiToken, { testCases, artifacts, commitSha: gitInfo?.sha });
   await patchJson(setupUrl, autonomaApiToken, { status: "completed" });
   log.success(
-    `Uploaded ${testCases.length} test case${testCases.length === 1 ? "" : "s"} and ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"}. Return to your browser to continue onboarding.`
+    `Uploaded ${testCases.length} test case${testCases.length === 1 ? "" : "s"} and ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"}.`
   );
 }
 
 // src/index.ts
 init_version();
+init_eta();
 init_steps();
 init_store();
 process.env.NODE_ENV ??= "production";
@@ -14074,26 +15718,10 @@ async function collectRunStats(outputDir) {
     stat3(tests, "E2E test", "E2E tests")
   ];
 }
-function parseArgs(argv) {
-  const args = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg.startsWith("--")) {
-      const key = arg.slice(2);
-      const next = argv[i + 1];
-      if (next && !next.startsWith("--")) {
-        args[key] = next;
-        i++;
-      } else {
-        args[key] = true;
-      }
-    }
+function warnAboutUnknownFlags(args) {
+  for (const { given, meant } of args.unrecognized(KNOWN_FLAGS)) {
+    log.warn(`Unknown flag --${given}${meant != null ? `. Did you mean --${meant}?` : "."} Ignoring it.`);
   }
-  return args;
-}
-function strArg(args, key) {
-  const value = args[key];
-  return typeof value === "string" ? value : void 0;
 }
 var STEP_LABELS = {
   projectMapper: "Map your project structure",
@@ -14140,8 +15768,9 @@ async function promptScopeSelection(map) {
 }
 async function runStep(step, outputDir, state, config, nonInteractive, retryGuidance) {
   const label = STEP_LABELS[step];
-  note(STEP_INTROS[step], `Step: ${label}`);
+  note(STEP_INTROS[step], `Step ${STEP_ORDER.indexOf(step) + 1}/${STEP_ORDER.length}: ${label}`);
   const stepStartedAt = Date.now();
+  const elapsed = () => formatClock(Date.now() - stepStartedAt);
   track("cli_step_started", { step });
   captureLog("info", `Step started: ${label}`, {
     source: "pipeline",
@@ -14251,7 +15880,7 @@ async function runStep(step, outputDir, state, config, nonInteractive, retryGuid
       }
       case "recipeBuilder": {
         const { runRecipeBuilder: runRecipeBuilder2 } = await Promise.resolve().then(() => (init_recipe_builder(), recipe_builder_exports));
-        const { parsePermissionMode: parsePermissionMode2 } = await Promise.resolve().then(() => (init_launcher(), launcher_exports));
+        const { parsePermissionMode: parsePermissionMode2 } = await Promise.resolve().then(() => (init_coding_agent(), coding_agent_exports));
         result = await runRecipeBuilder2({
           projectRoot: config.projectRoot,
           outputDir,
@@ -14283,26 +15912,26 @@ async function runStep(step, outputDir, state, config, nonInteractive, retryGuid
     if (result && !result.success) {
       if (result.paused) {
         state = await markStep(outputDir, state, step, "paused");
-        log.info(`Paused: ${label} - ${result.summary}`);
+        log.info(`Paused after ${elapsed()}: ${label} - ${result.summary}`);
       } else {
         state = await markStep(outputDir, state, step, "failed");
-        log.error(`Failed: ${label} - ${result.summary}`);
+        log.error(`Failed after ${elapsed()}: ${label} - ${result.summary}`);
         trackError(new Error(result.summary), { step, source: "step_result" });
       }
     } else {
       state = await markStep(outputDir, state, step, "done");
-      log.success(`Completed: ${label}`);
+      log.success(`Completed in ${elapsed()}: ${label}`);
     }
   } catch (err) {
     if (isUserCancellation(err)) throw err;
     state = await markStep(outputDir, state, step, "failed");
     const known = describeKnownError(err);
     if (known) {
-      log.error(`Failed: ${label} - ${known.title}`);
+      log.error(`Failed after ${elapsed()}: ${label} - ${known.title}`);
       log.info(known.hint);
     } else {
       const message = err instanceof Error ? err.message : String(err);
-      log.error(`Failed: ${label} - ${message}`);
+      log.error(`Failed after ${elapsed()}: ${label} - ${message}`);
       console.error(`\x1B[2m${formatException(err)}\x1B[0m`);
       console.error(`\x1B[2m${supportReference({ step })}\x1B[0m`);
       log.info("If you report this, please include the error output above.");
@@ -14416,16 +16045,45 @@ function ensureAutonomaAuth() {
   );
   return false;
 }
+async function finishFrontDoorRun(frontDoor, config, nonInteractive) {
+  try {
+    const gitInfo = await readGitInfo(config.projectRoot);
+    const result = await runFinishPhase({
+      client: frontDoor.client,
+      applicationId: frontDoor.applicationId,
+      checkedOutBranch: gitInfo?.branch,
+      // Only reached when the direct calls did not pass. What is wrong then needs
+      // the repo and a decision, which is an agent's job rather than an API call's.
+      repair: () => runSdkRepairHandoff({ plan: frontDoor, config, nonInteractive })
+    });
+    track("cli_dry_run_finished", { outcome: result.dryRun.kind, live: result.live });
+    const problem = describeDryRunOutcome(result.dryRun);
+    if (problem != null) log.warn(problem);
+    note(describeFinishPhase(result).join("\n"), "Where your app stands");
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.warn(`Couldn't confirm your scenarios against a preview: ${message}`);
+    log.info("Your test suite is uploaded either way - finish the dry run in the Autonoma app.");
+    trackError(err, { source: "finish_phase" });
+    return void 0;
+  }
+}
+function nextStepLine(finish, nonInteractive) {
+  if (finish?.live === true) return "Autonoma is reviewing your pull requests - open one to see it work.";
+  if (nonInteractive) return "Setup is not finished - the steps above that are still outstanding say why.";
+  return "Next: continue on autonoma.app";
+}
 async function main() {
   installTerminationDiagnostics();
-  const args = parseArgs(process.argv.slice(2));
+  const args = CliArgs.parse(process.argv.slice(2));
   const command = process.argv[2];
   if (command === "status") {
     const config2 = loadConfig({
-      project: strArg(args, "project"),
-      slug: strArg(args, "slug")
+      project: args.value("project"),
+      slug: args.value("slug")
     });
-    if (!args.project) {
+    if (!args.has("project")) {
       console.log(`No --project flag passed; using current working directory: ${config2.projectRoot}`);
     }
     const outputDir2 = await ensureOutputDir(config2.projectSlug);
@@ -14434,8 +16092,8 @@ async function main() {
   }
   if (command === "upload") {
     const config2 = loadConfig({
-      project: strArg(args, "project"),
-      slug: strArg(args, "slug")
+      project: args.value("project"),
+      slug: args.value("slug")
     });
     const outputDir2 = await ensureOutputDir(config2.projectSlug);
     const recipeUploaded = await uploadRecipeFromDisk(outputDir2, config2);
@@ -14451,19 +16109,13 @@ async function main() {
     });
     process.exit(exitCode);
   }
-  if (command === "help" || args.help) {
-    console.log("Usage:");
-    console.log(
-      "  test-planner [run] [--project <path>] [--frontend <path>] [--backends <path,path>] [--model <id>] [--step <name>] [--resume] [--non-interactive] [--agent <claude|codex>] [--permission-mode <default|acceptEdits|bypassPermissions>]"
-    );
-    console.log("  test-planner status [--project <path>]");
-    console.log("  test-planner upload [--project <path>]   # re-upload already-generated recipe + artifacts");
-    console.log("");
-    console.log("`run` is the default command; it may be omitted.");
+  if (command === "help" || args.has("help")) {
+    console.log(renderHelp());
     return;
   }
   console.log(BANNER);
-  const resumeCommand = `autonoma-planner --resume` + (args.project ? ` --project ${args.project}` : "");
+  const projectArg = args.value("project");
+  const resumeCommand = `autonoma-planner --resume` + (projectArg != null ? ` --project ${projectArg}` : "");
   let mountedUi;
   installInterruptHandler({
     // exitCode defaults to 0 for a user-initiated Ctrl+C (progress saved, a clean stop);
@@ -14481,24 +16133,24 @@ async function main() {
       void flushTelemetry().finally(() => process.exit(exitCode));
     }
   });
-  const backendsArg = strArg(args, "backends");
   const config = loadConfig({
-    project: strArg(args, "project"),
-    model: strArg(args, "model"),
-    slug: strArg(args, "slug"),
-    frontend: strArg(args, "frontend"),
-    backends: backendsArg != null ? backendsArg.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : void 0,
-    agent: strArg(args, "agent"),
-    permissionMode: strArg(args, "permission-mode")
+    project: projectArg,
+    model: args.value("model"),
+    slug: args.value("slug"),
+    frontend: args.value("frontend"),
+    backends: args.list("backend", "backends"),
+    agent: args.value("agent", "coding-agent"),
+    permissionMode: args.value("permission-mode")
   });
   initSession({ generationId: config.autonomaGenerationId, projectSlug: config.projectSlug });
   intro("Let's generate your test suite");
   if (!ensureAutonomaAuth()) {
     return;
   }
-  const nonInteractive = !!args["non-interactive"];
+  warnAboutUnknownFlags(args);
+  const nonInteractive = args.has("non-interactive");
   const modelName = config.modelId ?? readEnv().OPENROUTER_MODEL ?? DEFAULT_MODEL;
-  if (!args.project) {
+  if (projectArg == null) {
     log.info(`No --project flag passed; using current working directory.`);
   }
   log.info(`Project: ${config.projectRoot}`);
@@ -14519,12 +16171,26 @@ async function main() {
     }
   }
   if (!nonInteractive) mountedUi = await mountDashboard(outputDir, config.projectSlug);
-  let isResuming = !!(args.resume || args.step);
+  if (args.has("fresh") && args.has("resume")) {
+    mountedUi?.unmount();
+    mountedUi = void 0;
+    log.error("--fresh and --resume ask for opposite things. Pass one of them, not both.");
+    process.exitCode = 1;
+    return;
+  }
+  let isResuming = args.has("resume") || args.has("step");
   const hasProgress = Object.values(state.steps).some((s) => s === "done" || s === "running");
+  const { planFrontDoor: planFrontDoor2 } = await Promise.resolve().then(() => (init_front_door(), front_door_exports));
+  const frontDoor = await planFrontDoor2(config);
+  const previewPending = frontDoor?.phase === "preview";
   if (!nonInteractive && !isResuming && !hasProgress) {
     await welcome({
-      title: "Let's build your test suite.",
-      lines: [
+      title: previewPending ? "Let's get Autonoma running on your app." : "Let's build your test suite.",
+      lines: previewPending ? [
+        "First your coding agent sets up a preview environment - a real deployment of your app, built per pull request, that Autonoma tests against. It reads your repo and works out how to build and run it.",
+        "Then Autonoma analyzes your codebase - its pages, data models, and user flows - and generates a full suite of end-to-end test cases that cover them.",
+        "It all happens right here, in this terminal, so you can watch and steer it."
+      ] : [
         "Autonoma analyzes your codebase - its pages, data models, and user flows - and generates a full suite of end-to-end test cases that cover them, so you get real test coverage without writing a single test yourself.",
         "It takes a little while, and the whole run happens right here so you can watch it work.",
         "This analysis is free for new accounts."
@@ -14532,7 +16198,23 @@ async function main() {
       cta: "Press enter to begin"
     });
   }
-  if (!isResuming && !nonInteractive && hasProgress) {
+  if (frontDoor != null && previewPending) {
+    const { runPreviewHandoff: runPreviewHandoff2, describeIncompletePreview: describeIncompletePreview2 } = await Promise.resolve().then(() => (init_front_door(), front_door_exports));
+    const result = await runPreviewHandoff2({ plan: frontDoor, config, nonInteractive });
+    track("cli_preview_phase_finished", { outcome: result.kind });
+    const problem = describeIncompletePreview2(result);
+    if (problem != null) log.warn(problem);
+  }
+  if (args.has("fresh") && hasProgress) {
+    await clearOutputDir(config.projectSlug);
+    state = initialState();
+    await saveState(outputDir, state);
+    log.info(`Cleared ${displayPath(outputDir)} - starting from scratch.`);
+  } else if (!isResuming && nonInteractive && hasProgress) {
+    log.info(
+      "A previous run left output in this folder and no flag said what to do with it, so this run continues from it. Pass --fresh to discard it, or --resume to say so deliberately."
+    );
+  } else if (!isResuming && !nonInteractive && hasProgress) {
     const completedSteps = Object.entries(state.steps).filter(([, s]) => s === "done").map(([name]) => isStepName(name) ? STEP_LABELS[name] : name).join(", ");
     const resume2 = await confirm({
       message: `Found a previous run${completedSteps ? ` (completed: ${completedSteps})` : ""}. Resume from where you left off?`,
@@ -14561,7 +16243,7 @@ It's a hidden folder in your home directory - in Finder/Explorer use "Go to fold
 or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
     "Output folder"
   );
-  const stepArg = strArg(args, "step");
+  const stepArg = args.value("step");
   const targetStep = stepArg != null && isStepName(stepArg) ? stepArg : void 0;
   if (stepArg != null && targetStep == null) {
     mountedUi?.unmount();
@@ -14580,7 +16262,7 @@ or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
     mountedUi?.unmount();
     mountedUi = void 0;
     if (state.steps[targetStep] === "failed") {
-      const retryCommand = `autonoma-planner --step ${targetStep}` + (args.project ? ` --project ${args.project}` : "");
+      const retryCommand = `autonoma-planner --step ${targetStep}` + (projectArg != null ? ` --project ${projectArg}` : "");
       log.warn(`Your progress is saved. To retry this step, run:
   ${retryCommand}`);
       process.exitCode = 1;
@@ -14597,7 +16279,12 @@ or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
   }
   const steps = STEP_ORDER;
   const startIdx = steps.indexOf(startStep);
-  note(steps.map((s, idx) => `${idx + 1}. ${STEP_LABELS[s]} - ${STEP_SUMMARIES[s]}`).join("\n"), "Here's the plan");
+  note(
+    `${steps.map((s, idx) => `${idx + 1}. ${STEP_LABELS[s]} - ${STEP_SUMMARIES[s]}`).join("\n")}
+
+All of it runs from this one command - there is nothing to launch step by step.`,
+    "Here's the plan"
+  );
   try {
     for (let i = startIdx; i < steps.length; i++) {
       const step = steps[i];
@@ -14643,13 +16330,14 @@ or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
       trackError(err, { source: "artifact_upload" });
     }
   }
+  const finish = frontDoor != null && allStepsDone ? await finishFrontDoorRun(frontDoor, config, nonInteractive) : void 0;
   const anyFailed = Object.values(state.steps).some((s) => s === "failed");
   getActiveStore()?.finish({ kind: allStepsDone ? "complete" : anyFailed ? "failed" : "paused" });
   if (allStepsDone) {
     const choice = await completion({
       title: "Your test suite is ready.",
       stats: await collectRunStats(outputDir),
-      lines: [`Saved in ${displayPath(outputDir)}`, "Next: continue on autonoma.app"]
+      lines: [`Saved in ${displayPath(outputDir)}`, nextStepLine(finish, nonInteractive)]
     });
     track("cli_completion_choice", { choice });
     if (choice === "browse") {
@@ -14662,7 +16350,8 @@ or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
   if (allStepsDone) {
     log.success("Your test suite is ready.");
     log.info(`Saved in ${displayPath(outputDir)}`);
-    log.info("Next: continue on autonoma.app");
+    if (finish != null) for (const line of describeFinishPhase(finish)) log.info(line);
+    log.info(nextStepLine(finish, nonInteractive));
   }
   outro("Done");
 }