@autonoma-ai/planner 0.1.28 → 0.1.29

package/dist/index.js

@@ -549,7 +549,7 @@ var init_theme = __esm({
 });
 
 // src/ui/components/render-content.ts
-import matter from "gray-matter";
+import matter from "@11ty/gray-matter";
 import { z as z2 } from "zod";
 function renderContent(text2, kind, name) {
   if (memo != null && memo.text === text2 && memo.kind === kind && memo.name === name) return memo.lines;
@@ -2101,6 +2101,14 @@ var init_prompts = __esm({
   }
 });
 
+// ../../packages/types/src/types/previewkit.ts
+var init_previewkit = __esm({
+  "../../packages/types/src/types/previewkit.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // ../../packages/types/src/types/step-overlay-points.ts
 import { z as z4 } from "zod";
 var overlayPointSchema, pointSchema, outputWithPointsSchema;
@@ -2288,11 +2296,12 @@ 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, mainOpenProblemSchema, analysisSnapshotIssueChangesSchema;
+var analysisVerdictSchema, ANALYSIS_VERDICT, VERDICT_TIER, coverageVerdicts, analysisFlowStatusSchema, analysisFlowOwnerSchema, analysisFlowSchema, analysisTestOriginSchema, coverageCategoryCountSchema, coverageSummarySchema, analysisClassificationReportSchema, analysisClassificationSummarySchema, analysisFindingViewSchema, analysisReportDataSchema, analysisIssueKindSchema, analysisIssueSeveritySchema, analysisIssueStatusSchema, resolvedPrimaryScreenshotSchema, analysisIssueSummarySchema, analysisIssueFindingInstanceSchema, analysisIssueDetailSchema, analysisPrCoveredTestSchema, analysisPrIssueSchema, analysisPrNewerRunSchema, analysisForPrSchema, mainOpenProblemSchema, analysisSnapshotIssueChangesSchema;
 var init_analysis = __esm({
   "../../packages/types/src/schemas/analysis.ts"() {
     "use strict";
     init_esm_shims();
+    init_previewkit();
     init_step_overlay_points();
     init_evidence_tokens();
     init_investigation_report();
@@ -2322,6 +2331,26 @@ var init_analysis = __esm({
     coverageVerdicts = analysisVerdictSchema.options.filter(
       (verdict) => analysisVerdictPlane(verdict) === "coverage"
     );
+    analysisFlowStatusSchema = z8.enum(["broken", "verified", "partial", "unverified"]);
+    analysisFlowOwnerSchema = z8.enum(["client", "autonoma", "none"]);
+    analysisFlowSchema = z8.object({
+      /** The reader-facing name, authored by the Reporter: "Guest checkout", not `checkout-guest-express-lane`. */
+      title: z8.string().min(1),
+      /** One sentence, authored by the Reporter: what was confirmed, or why it could not be. */
+      detail: z8.string(),
+      status: analysisFlowStatusSchema,
+      owner: analysisFlowOwnerSchema,
+      /** Cited tests whose last-known verdict confirmed the app. */
+      passedCount: z8.number().int().nonnegative(),
+      /** Cited tests whose last-known verdict is a coverage-plane gap. */
+      gapCount: z8.number().int().nonnegative(),
+      /** Cited tests whose last-known verdict is a client bug. */
+      bugCount: z8.number().int().nonnegative(),
+      /** How many cited verdicts came from the run being reported. Zero means the whole flow is carried from earlier. */
+      checkedThisRunCount: z8.number().int().nonnegative(),
+      /** The tests this flow covers. Every test in the branch's map lands in exactly one flow. */
+      testSlugs: z8.array(z8.string())
+    });
     analysisTestOriginSchema = z8.enum(["pre_existing", "proposed"]);
     coverageCategoryCountSchema = z8.object({
       category: analysisVerdictSchema,
@@ -2417,17 +2446,24 @@ var init_analysis = __esm({
       /** The Impact Analysis stage's account of why it selected the tests it did (admin-only on the snapshot page). */
       impactReasoning: z8.string().optional(),
       /**
-       * The Reporter's holistic PR report prose (Markdown), the hero of the PR page and the snapshot per-job view.
-       * Absent while a run is still authoring it (the page keeps polling) or when the run degraded to a
-       * finding-derived verdict with no prose. Its inline `evidence:` image tokens resolve against `reportEvidence`;
-       * `issue:`/`finding:` link tokens resolve against the branch's issues and this report's findings.
+       * The Reporter's holistic PR report prose (Markdown), the hero of the PR page and the snapshot per-job view. Its
+       * inline `evidence:` image tokens resolve against `reportEvidence`; `issue:`/`finding:` link tokens resolve
+       * against the branch's issues and this report's findings.
+       *
+       * Never empty: a report row exists only once the Reporter has authored one, and `finish` refuses prose that
+       * sanitizing emptied.
        */
-      reportMarkdown: z8.string().optional(),
+      reportMarkdown: z8.string(),
       /**
-       * The Reporter's one-paragraph summary of the run, for the surfaces that show prose but not a document: the PR
-       * page's verdict subtitle. Absent on a run that predates the Reporter (those rows were backfilled to empty).
+       * The Reporter's title for the PR as a whole (about eight words). EMPTY on a report written before the Reporter
+       * authored titles - `analysisPrTitle` is the one place that reads it as unauthored, and it also overrides the
+       * authored value for an open bug and for a run that needed no tests.
        */
-      summary: z8.string().optional(),
+      title: z8.string(),
+      /** The Reporter's headline: the CUMULATIVE state of the branch in 1-3 plain sentences. Never empty. */
+      headline: z8.string(),
+      /** The branch's flow itemization: what this PR has established and what it has not. Empty on a pre-flows run. */
+      flows: z8.array(analysisFlowSchema),
       /** The signed assets `reportMarkdown` may embed inline by `evidence:<assetId>` token (referenced ones only). */
       reportEvidence: z8.array(resolvedEvidenceAssetSchema),
       /** The persisted app-health verdict for the run (issue-derived at finalize): `client_bug` or `passed`. */
@@ -2526,8 +2562,16 @@ var init_analysis = __esm({
         status: z8.literal("complete"),
         /** The app-health verdict: `client_bug` when the branch has an open bug issue, else `passed`. */
         verdict: analysisVerdictSchema,
-        /** The Reporter's one-paragraph summary of the run. */
-        summary: z8.string().optional(),
+        /** The Reporter's title for the PR as a whole. Empty on a report written before the Reporter authored one. */
+        title: z8.string(),
+        /** The Reporter's headline: the cumulative state of the branch in 1-3 plain sentences. */
+        headline: z8.string(),
+        /**
+         * The branch's flow itemization: which parts of the app this PR has established and which it has not. A
+         * consumer reading `verdict` alone learns only whether a bug was found - these say how much was covered, which
+         * is the difference between "nothing broke" and "we checked".
+         */
+        flows: z8.array(analysisFlowSchema),
         /** The Reporter's holistic report prose. Its `evidence:` image tokens resolve against `reportEvidence`, and
          * its `issue:` tokens against the `issues` below. */
         reportMarkdown: z8.string().optional(),
@@ -3087,6 +3131,97 @@ var init_api_key = __esm({
   }
 });
 
+// ../../packages/types/src/schemas/organization.ts
+import { z as z14 } from "zod";
+var InvitationStatusSchema, InviteMemberInputSchema, RevokeInvitationInputSchema, RemoveMemberInputSchema, InvitationIdInputSchema, SetActiveOrganizationInputSchema, RenameOrganizationInputSchema, LeaveOrganizationInputSchema, InvitationOutcomeSchema, InvitationPreviewSchema, MyOrganizationSchema, AppSlugOwnerSchema, AppSlugOwnersInputSchema, OrganizationMemberSchema, PendingInvitationSchema;
+var init_organization = __esm({
+  "../../packages/types/src/schemas/organization.ts"() {
+    "use strict";
+    init_esm_shims();
+    InvitationStatusSchema = z14.enum(["pending", "accepted", "rejected", "canceled"]);
+    InviteMemberInputSchema = z14.object({
+      email: z14.email("Enter a valid email address").trim().toLowerCase()
+    });
+    RevokeInvitationInputSchema = z14.object({
+      invitationId: z14.string().min(1)
+    });
+    RemoveMemberInputSchema = z14.object({
+      userId: z14.string().min(1)
+    });
+    InvitationIdInputSchema = z14.object({
+      invitationId: z14.string().min(1)
+    });
+    SetActiveOrganizationInputSchema = z14.object({
+      organizationId: z14.string().min(1)
+    });
+    RenameOrganizationInputSchema = z14.object({
+      organizationId: z14.string().min(1),
+      name: z14.string().trim().min(1, "Enter a name").max(100, "Keep it under 100 characters")
+    });
+    LeaveOrganizationInputSchema = z14.object({
+      organizationId: z14.string().min(1)
+    });
+    InvitationOutcomeSchema = z14.enum([
+      "joinable",
+      "wrong-account",
+      "already-member",
+      "expired",
+      "revoked",
+      "accepted",
+      "declined"
+    ]);
+    InvitationPreviewSchema = z14.object({
+      invitationId: z14.string(),
+      organizationName: z14.string(),
+      inviterName: z14.string(),
+      invitedEmail: z14.string(),
+      outcome: InvitationOutcomeSchema
+    });
+    MyOrganizationSchema = z14.object({
+      id: z14.string(),
+      name: z14.string(),
+      slug: z14.string(),
+      /** Which one the current session is acting as. Session-scoped: switching does not persist. */
+      isActive: z14.boolean(),
+      memberCount: z14.number().int().positive(),
+      applicationCount: z14.number().int().nonnegative(),
+      joinedAt: z14.date(),
+      /**
+       * Why leaving is refused, if it is. `last-organization` - it is their only one, and an
+       * account with no organization cannot reach anything. `last-member` - nobody would be
+       * left who could reach the organization's applications.
+       */
+      leaveBlockedReason: z14.enum(["last-organization", "last-member"]).optional()
+    });
+    AppSlugOwnerSchema = z14.object({
+      organizationId: z14.string(),
+      organizationName: z14.string(),
+      organizationSlug: z14.string()
+    });
+    AppSlugOwnersInputSchema = z14.object({
+      appSlug: z14.string().min(1)
+    });
+    OrganizationMemberSchema = z14.object({
+      userId: z14.string(),
+      name: z14.string(),
+      email: z14.string(),
+      image: z14.string().optional(),
+      role: z14.string(),
+      joinedAt: z14.date(),
+      /** True for the member making the request - the row that can't be removed. */
+      isSelf: z14.boolean()
+    });
+    PendingInvitationSchema = z14.object({
+      id: z14.string(),
+      email: z14.string(),
+      inviterName: z14.string(),
+      expiresAt: z14.date(),
+      /** Where to send the invitee if the email never arrives and someone wants to paste the link. */
+      acceptUrl: z14.string()
+    });
+  }
+});
+
 // ../../packages/types/src/schemas/previewkit-builtins.ts
 function isReservedPreviewkitEnvKey(key) {
   return PREVIEWKIT_BUILTIN_ENV_KEYS.has(key);
@@ -3138,7 +3273,7 @@ var init_previewkit_builtins = __esm({
 });
 
 // ../../packages/types/src/schemas/secrets.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var SECRET_KEY_REGEX, APP_NAME_REGEX, SecretKeySchema, AppNameSchema, SecretItemSchema, ListSecretAppsInputSchema, ListSecretsInputSchema, UpsertSecretsInputSchema, DeleteSecretInputSchema, PreviewkitConfigAppSecretsSchema, PreviewkitConfigSecretsSchema;
 var init_secrets = __esm({
   "../../packages/types/src/schemas/secrets.ts"() {
@@ -3147,12 +3282,12 @@ var init_secrets = __esm({
     init_previewkit_builtins();
     SECRET_KEY_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
     APP_NAME_REGEX = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
-    SecretKeySchema = z14.string().min(1).max(256).regex(
+    SecretKeySchema = z15.string().min(1).max(256).regex(
       SECRET_KEY_REGEX,
       "Keys must start with a letter or underscore and contain only letters, numbers, and underscores"
     );
-    AppNameSchema = z14.string().min(2).max(63).regex(APP_NAME_REGEX, "App name must be lowercase alphanumeric with hyphens (Kubernetes label-compatible)");
-    SecretItemSchema = z14.object({
+    AppNameSchema = z15.string().min(2).max(63).regex(APP_NAME_REGEX, "App name must be lowercase alphanumeric with hyphens (Kubernetes label-compatible)");
+    SecretItemSchema = z15.object({
       key: SecretKeySchema.superRefine((key, ctx) => {
         if (isReservedPreviewkitEnvKey(key)) {
           ctx.addIssue({
@@ -3166,31 +3301,50 @@ var init_secrets = __esm({
           });
         }
       }),
-      value: z14.string().min(1).max(65536)
+      value: z15.string().min(1).max(65536)
     });
-    ListSecretAppsInputSchema = z14.object({
-      applicationId: z14.string()
+    ListSecretAppsInputSchema = z15.object({
+      applicationId: z15.string()
     });
-    ListSecretsInputSchema = z14.object({
-      applicationId: z14.string(),
+    ListSecretsInputSchema = z15.object({
+      applicationId: z15.string(),
       appName: AppNameSchema
     });
-    UpsertSecretsInputSchema = z14.object({
-      applicationId: z14.string(),
+    UpsertSecretsInputSchema = z15.object({
+      applicationId: z15.string(),
       appName: AppNameSchema,
-      items: z14.array(SecretItemSchema).min(1).max(200)
+      items: z15.array(SecretItemSchema).min(1).max(200)
     });
-    DeleteSecretInputSchema = z14.object({
-      applicationId: z14.string(),
+    DeleteSecretInputSchema = z15.object({
+      applicationId: z15.string(),
       appName: AppNameSchema,
       key: SecretKeySchema
     });
-    PreviewkitConfigAppSecretsSchema = z14.object({
+    PreviewkitConfigAppSecretsSchema = z15.object({
       appName: AppNameSchema,
-      upserts: z14.array(SecretItemSchema).max(200).default([]),
-      deletes: z14.array(SecretKeySchema).max(200).default([])
+      upserts: z15.array(SecretItemSchema).max(200).default([]),
+      deletes: z15.array(SecretKeySchema).max(200).default([])
     });
-    PreviewkitConfigSecretsSchema = z14.array(PreviewkitConfigAppSecretsSchema).max(50);
+    PreviewkitConfigSecretsSchema = z15.array(PreviewkitConfigAppSecretsSchema).max(50);
+  }
+});
+
+// ../../packages/types/src/parse-url.ts
+var init_parse_url = __esm({
+  "../../packages/types/src/parse-url.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/types/src/sdk-endpoint.ts
+var DEFAULT_SDK_PATH;
+var init_sdk_endpoint = __esm({
+  "../../packages/types/src/sdk-endpoint.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_parse_url();
+    DEFAULT_SDK_PATH = "/api/autonoma";
   }
 });
 
@@ -3619,7 +3773,7 @@ var init_previewkit_presets = __esm({
 });
 
 // ../../packages/types/src/schemas/previewkit-config.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function buildResourcesSchema(role, allowCustomResources) {
   return resourcesInput.transform((input) => {
     if (!allowCustomResources || input == null) {
@@ -3634,86 +3788,96 @@ function buildResourcesSchema(role, allowCustomResources) {
   });
 }
 function singleLineCommand(label) {
-  return z15.string().min(1).regex(/^[^\r\n]+$/, `${label} must be a single line (no line breaks)`);
+  return z16.string().min(1).regex(/^[^\r\n]+$/, `${label} must be a single line (no line breaks)`);
 }
 function heredocSafeScript(label) {
-  return z15.string().min(1).refine(
+  return z16.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 z15.object({
-    framework: z15.literal(framework),
-    package_manager: z15.enum(["npm", "pnpm", "yarn"]).default("pnpm"),
-    node_version: z15.string().regex(nodeVersionRegex, "must look like 22, 22.5, or 22.5.0").default("22"),
-    install_command: z15.string().min(1).optional(),
-    build_command: z15.string().min(1).optional(),
-    run_command: z15.string().min(1).optional(),
+  return z16.object({
+    framework: z16.literal(framework),
+    package_manager: z16.enum(["npm", "pnpm", "yarn"]).default("pnpm"),
+    node_version: z16.string().regex(nodeVersionRegex, "must look like 22, 22.5, or 22.5.0").default("22"),
+    install_command: z16.string().min(1).optional(),
+    build_command: z16.string().min(1).optional(),
+    run_command: z16.string().min(1).optional(),
     build_context: buildContextSchema
   });
 }
 function buildPreviewConfigSchema(build, allowCustomResources) {
-  const appSchema = z15.object({
-    name: z15.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
-    repository: z15.string().regex(repoFullNameRegex, "Must be an owner/repo full name").describe(
+  const appSchema = z16.object({
+    name: z16.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
+    repository: z16.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: z15.string().default("."),
-    build_context: z15.string().optional(),
-    dockerfile: z15.string().optional(),
+    path: z16.string().default("."),
+    build_context: z16.string().optional(),
+    dockerfile: z16.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: z15.array(z15.string()).default([]),
-    port: z15.number().int().positive(),
+    build_secrets: z16.array(z16.string()).default([]),
+    port: z16.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: z15.array(connectionSchema).default([]),
-    command: z15.string().optional(),
-    health_check: z15.string().optional(),
-    primary: z15.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: z15.boolean().optional(),
+    connections: z16.array(connectionSchema).default([]),
+    command: z16.string().optional(),
+    health_check: z16.string().optional(),
+    primary: z16.boolean().optional(),
+    // This app serves the Environment Factory handler, 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: z16.boolean().optional(),
+    // Where on that app the handler is mounted. Deliberately NO `.default()`:
+    // absent has to stay distinguishable from an explicit `/api/autonoma`,
+    // because it is what tells a caller to leave an already-stored endpoint
+    // URL alone (see `applySdkPath`). Give it a default and every endpoint a
+    // customer registered by hand at another path gets rewritten to the
+    // convention.
+    sdk_path: z16.string().regex(
+      SDK_PATH_PATTERN,
+      `Must be an absolute path with no query or fragment, like "${DEFAULT_SDK_PATH}"`
+    ).optional(),
     resources: buildResourcesSchema("app", allowCustomResources),
-    depends_on: z15.array(z15.string()).optional()
+    depends_on: z16.array(z16.string()).optional()
   }).superRefine((app, ctx) => {
     if (app.build != null && app.blueprint != null) {
       ctx.addIssue({
-        code: z15.ZodIssueCode.custom,
+        code: z16.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 = z15.object({
-    name: z15.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
-    recipe: z15.string(),
-    version: z15.string().optional(),
+  const serviceSchema = z16.object({
+    name: z16.string().regex(k8sNameRegex, "Must be a valid Kubernetes name"),
+    recipe: z16.string(),
+    version: z16.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: z15.record(z15.string(), z15.unknown()).default({}),
+    options: z16.record(z16.string(), z16.unknown()).default({}),
     // Guided setup for database-recipe services (schema, seed, migrations),
     // run with the repo checked out. Empty for non-database services.
-    setup_tasks: z15.array(databaseSetupTaskSchema).default([]),
+    setup_tasks: z16.array(databaseSetupTaskSchema).default([]),
     resources: buildResourcesSchema("service", allowCustomResources),
-    s3: z15.boolean().optional(),
-    sqs: z15.boolean().optional(),
-    sns: z15.boolean().optional()
+    s3: z16.boolean().optional(),
+    sqs: z16.boolean().optional(),
+    sns: z16.boolean().optional()
   });
-  return z15.object({
-    version: z15.literal(2),
-    domain: z15.string().optional(),
-    registry: z15.string().optional(),
+  return z16.object({
+    version: z16.literal(PREVIEW_CONFIG_VERSION),
+    domain: z16.string().optional(),
+    registry: z16.string().optional(),
     // Per-repository overrides + deploy provenance; the repo set itself
     // is derived from `apps[].repository`. See repositorySettingsSchema.
-    repositories: z15.array(repositorySettingsSchema).default([]).describe(
+    repositories: z16.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
@@ -3721,8 +3885,8 @@ function buildPreviewConfigSchema(build, allowCustomResources) {
     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: z15.array(appSchema).min(1, "At least one app is required"),
-    services: z15.array(serviceSchema).default([]),
+    apps: z16.array(appSchema).min(1, "At least one app is required"),
+    services: z16.array(serviceSchema).default([]),
     hooks: hooksSchema
   }).superRefine((cfg, ctx) => {
     const seen = /* @__PURE__ */ new Map();
@@ -3730,7 +3894,7 @@ function buildPreviewConfigSchema(build, allowCustomResources) {
       const existing = seen.get(name);
       if (existing != null) {
         ctx.addIssue({
-          code: z15.ZodIssueCode.custom,
+          code: z16.ZodIssueCode.custom,
           message: `Name "${name}" is used by both a ${existing} and an ${kind} - names must be unique across apps and services`
         });
         return;
@@ -3744,7 +3908,7 @@ function buildPreviewConfigSchema(build, allowCustomResources) {
       const key = settings.repo.toLowerCase();
       if (seenRepos.has(key)) {
         ctx.addIssue({
-          code: z15.ZodIssueCode.custom,
+          code: z16.ZodIssueCode.custom,
           path: ["repositories", index, "repo"],
           message: `Repository "${settings.repo}" has more than one settings entry`
         });
@@ -3761,11 +3925,12 @@ function standardResources(role) {
     memoryLimit: standard.memoryLimit
   };
 }
-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 STANDARD_RESOURCES, PREVIEW_CONFIG_VERSION, k8sNameRegex, SDK_PATH_PATTERN, repoFullNameRegex, DEFAULT_DEPENDENCY_FALLBACK_BRANCH, 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, appRoleSchema, sdkPathDocumentSchema;
 var init_previewkit_config = __esm({
   "../../packages/types/src/schemas/previewkit-config.ts"() {
     "use strict";
     init_esm_shims();
+    init_sdk_endpoint();
     init_previewkit_builtins();
     init_previewkit_node_pm();
     init_previewkit_presets();
@@ -3775,19 +3940,22 @@ var init_previewkit_config = __esm({
       app: { cpu: "250m", memoryRequest: "512Mi", memoryLimit: "1Gi" },
       service: { cpu: "100m", memoryRequest: "256Mi", memoryLimit: "1Gi" }
     };
+    PREVIEW_CONFIG_VERSION = 2;
     k8sNameRegex = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+    SDK_PATH_PATTERN = /^\/[^\s?#]*$/;
     repoFullNameRegex = /^[^/\s]+\/[^/\s]+$/;
-    resourcesInput = z15.object({
-      cpu: z15.string().optional(),
-      memory: z15.string().optional(),
-      memoryRequest: z15.string().optional(),
-      memoryLimit: z15.string().optional()
+    DEFAULT_DEPENDENCY_FALLBACK_BRANCH = "main";
+    resourcesInput = z16.object({
+      cpu: z16.string().optional(),
+      memory: z16.string().optional(),
+      memoryRequest: z16.string().optional(),
+      memoryLimit: z16.string().optional()
     }).optional();
-    branchConventionSchema = z15.discriminatedUnion("type", [
-      z15.object({ type: z15.literal("same_branch_name") }),
-      z15.object({
-        type: z15.literal("regex"),
-        pattern: z15.string().refine((pattern) => {
+    branchConventionSchema = z16.discriminatedUnion("type", [
+      z16.object({ type: z16.literal("same_branch_name") }),
+      z16.object({
+        type: z16.literal("regex"),
+        pattern: z16.string().refine((pattern) => {
           try {
             new RegExp(pattern);
             return true;
@@ -3795,13 +3963,13 @@ var init_previewkit_config = __esm({
             return false;
           }
         }, "Invalid regular expression pattern"),
-        replacement: z15.string()
+        replacement: z16.string()
       }),
-      z15.object({ type: z15.literal("manual") })
+      z16.object({ type: z16.literal("manual") })
     ]);
-    repositorySettingsSchema = z15.object({
-      repo: z15.string().regex(repoFullNameRegex, "Must be an owner/repo full name"),
-      fallback_branch: z15.string().default("main"),
+    repositorySettingsSchema = z16.object({
+      repo: z16.string().regex(repoFullNameRegex, "Must be an owner/repo full name"),
+      fallback_branch: z16.string().default(DEFAULT_DEPENDENCY_FALLBACK_BRANCH),
       /**
        * The concrete commit SHA the repository was deployed at. Absent in
        * user-authored config: previewkit resolves each dependency repo's branch to
@@ -3809,60 +3977,60 @@ var init_previewkit_config = __esm({
        * `resolvedConfig` (deploy provenance, not authored input). Multi-repo
        * grounding reads this back to inspect the exact code that was live.
        */
-      sha: z15.string().optional()
+      sha: z16.string().optional()
     });
-    hookStepSchema = z15.object({
-      app: z15.string(),
-      command: z15.string()
+    hookStepSchema = z16.object({
+      app: z16.string(),
+      command: z16.string()
     });
-    hooksSchema = z15.object({
-      pre_deploy: z15.array(hookStepSchema).default([]),
-      post_deploy: z15.array(hookStepSchema).default([])
+    hooksSchema = z16.object({
+      pre_deploy: z16.array(hookStepSchema).default([]),
+      post_deploy: z16.array(hookStepSchema).default([])
     }).default({ pre_deploy: [], post_deploy: [] });
-    databaseSetupLocationSchema = z15.discriminatedUnion("type", [
-      z15.object({
-        type: z15.literal("in_build"),
-        app: z15.string().min(1, "an app is required for an in-build task"),
-        position: z15.enum(["before", "after"])
+    databaseSetupLocationSchema = z16.discriminatedUnion("type", [
+      z16.object({
+        type: z16.literal("in_build"),
+        app: z16.string().min(1, "an app is required for an in-build task"),
+        position: z16.enum(["before", "after"])
       }),
-      z15.object({
-        type: z15.literal("separate_job"),
-        repo: z15.string().optional()
+      z16.object({
+        type: z16.literal("separate_job"),
+        repo: z16.string().optional()
       })
     ]);
-    databaseSetupTaskSchema = z15.object({
-      command: z15.string(),
-      frequency: z15.enum(["on_create", "every_commit"]),
+    databaseSetupTaskSchema = z16.object({
+      command: z16.string(),
+      frequency: z16.enum(["on_create", "every_commit"]),
       location: databaseSetupLocationSchema
     });
     nodeVersionRegex = /^\d+(\.\d+)?(\.\d+)?$/;
-    buildContextSchema = z15.enum(["app", "root"]).default("app");
+    buildContextSchema = z16.enum(["app", "root"]).default("app");
     PREVIEWKIT_BUILD_SCRIPT_HEREDOC = "AUTONOMA_BUILD_EOF";
-    imageTagSchema = z15.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "must be a valid image tag");
+    imageTagSchema = z16.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"),
-      z15.object({
-        framework: z15.literal("bun"),
-        install_command: z15.string().min(1).optional(),
-        build_command: z15.string().min(1).optional(),
-        run_command: z15.string().min(1).optional(),
+      z16.object({
+        framework: z16.literal("bun"),
+        install_command: z16.string().min(1).optional(),
+        build_command: z16.string().min(1).optional(),
+        run_command: z16.string().min(1).optional(),
         build_context: buildContextSchema
       })
     ];
     authoredBuildArms = [
-      z15.object({
-        framework: z15.literal("dockerfile"),
-        dockerfile: z15.string().min(1, "dockerfile path is required"),
-        target: z15.string().min(1).optional(),
+      z16.object({
+        framework: z16.literal("dockerfile"),
+        dockerfile: z16.string().min(1, "dockerfile path is required"),
+        target: z16.string().min(1).optional(),
         build_context: buildContextSchema
       }),
-      z15.object({
-        framework: z15.literal("runtime"),
-        runtime: z15.enum(PREVIEWKIT_RUNTIME_IDS),
+      z16.object({
+        framework: z16.literal("runtime"),
+        runtime: z16.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
@@ -3879,12 +4047,12 @@ var init_previewkit_config = __esm({
         build_context: buildContextSchema
       })
     ];
-    authoredBuildSchema = z15.discriminatedUnion("framework", authoredBuildArms, {
+    authoredBuildSchema = z16.discriminatedUnion("framework", authoredBuildArms, {
       error: () => UNSUPPORTED_BUILD_METHOD_MESSAGE
     });
-    storedBuildSchema = z15.discriminatedUnion("framework", [...authoredBuildArms, ...deprecatedBuildArms]);
-    presetBlueprintSchema = z15.object({
-      preset: z15.enum(PREVIEWKIT_PRESET_IDS),
+    storedBuildSchema = z16.discriminatedUnion("framework", [...authoredBuildArms, ...deprecatedBuildArms]);
+    presetBlueprintSchema = z16.object({
+      preset: z16.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
@@ -3904,82 +4072,98 @@ var init_previewkit_config = __esm({
       const toolchain = previewkitPresetSpec(blueprint.preset).toolchain;
       if (toolchain === "node" && blueprint.version != null && !nodeVersionRegex.test(blueprint.version)) {
         ctx.addIssue({
-          code: z15.ZodIssueCode.custom,
+          code: z16.ZodIssueCode.custom,
           message: "version must look like 22, 22.5, or 22.5.0 for a node preset",
           path: ["version"]
         });
       }
     });
-    dockerfileBlueprintSchema = z15.object({
+    dockerfileBlueprintSchema = z16.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: z15.string().min(1, "dockerfile path is required"),
-      target: z15.string().min(1).optional(),
+      dockerfile: z16.string().min(1, "dockerfile path is required"),
+      target: z16.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 = z15.union([presetBlueprintSchema, dockerfileBlueprintSchema]);
-    connectionSchema = z15.object({
+    blueprintSchema = z16.union([presetBlueprintSchema, dockerfileBlueprintSchema]);
+    connectionSchema = z16.object({
       key: SecretKeySchema.superRefine((key, ctx) => {
         if (isReservedPreviewkitEnvKey(key)) {
           ctx.addIssue({
-            code: z15.ZodIssueCode.custom,
+            code: z16.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: z15.string().min(1, "value is required").describe(
+      value: z16.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: z15.boolean().default(false).describe("Also pass the resolved value as a Docker build arg.")
+      build_time: z16.boolean().default(false).describe("Also pass the resolved value as a Docker build arg.")
     });
     previewConfigSchema = buildPreviewConfigSchema(storedBuildSchema, false);
     trustedPreviewConfigSchema = buildPreviewConfigSchema(storedBuildSchema, true);
     authoringPreviewConfigSchema = buildPreviewConfigSchema(authoredBuildSchema, false);
+    appRoleSchema = z16.object({
+      name: z16.string(),
+      primary: z16.boolean().nullish(),
+      sdk_implemented: z16.boolean().nullish(),
+      sdk_path: z16.string().nullish()
+    });
+    sdkPathDocumentSchema = z16.object({ apps: z16.array(appRoleSchema) });
+  }
+});
+
+// ../../packages/types/src/schemas/previewkit-config-rows.ts
+var init_previewkit_config_rows = __esm({
+  "../../packages/types/src/schemas/previewkit-config-rows.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_previewkit_config();
   }
 });
 
 // ../../packages/types/src/schemas/previewkit-job-spec.ts
-import { z as z16 } from "zod";
+import { z as z17 } 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 = z16.object({
-      repoFullName: z16.string().min(1),
-      prNumber: z16.number().int().nonnegative(),
-      organizationId: z16.string().min(1),
-      githubRepositoryId: z16.number().int(),
-      headSha: z16.string().min(1),
-      headRef: z16.string().min(1),
-      branchId: z16.string().optional()
+    deployTargetSchema = z17.object({
+      repoFullName: z17.string().min(1),
+      prNumber: z17.number().int().nonnegative(),
+      organizationId: z17.string().min(1),
+      githubRepositoryId: z17.number().int(),
+      headSha: z17.string().min(1),
+      headRef: z17.string().min(1),
+      branchId: z17.string().optional()
     });
-    redeployTargetSchema = z16.object({
-      repoFullName: z16.string().min(1),
-      prNumber: z16.number().int().nonnegative(),
-      organizationId: z16.string().min(1),
-      githubRepositoryId: z16.number().int(),
-      headSha: z16.string().min(1),
-      headRef: z16.string().min(1)
+    redeployTargetSchema = z17.object({
+      repoFullName: z17.string().min(1),
+      prNumber: z17.number().int().nonnegative(),
+      organizationId: z17.string().min(1),
+      githubRepositoryId: z17.number().int(),
+      headSha: z17.string().min(1),
+      headRef: z17.string().min(1)
     });
-    teardownTargetSchema = z16.object({
-      repoFullName: z16.string().min(1),
-      prNumber: z16.number().int().nonnegative(),
-      organizationId: z16.string().min(1),
-      headSha: z16.string().min(1).optional()
+    teardownTargetSchema = z17.object({
+      repoFullName: z17.string().min(1),
+      prNumber: z17.number().int().nonnegative(),
+      organizationId: z17.string().min(1),
+      headSha: z17.string().min(1).optional()
     });
-    previewJobSpecSchema = z16.discriminatedUnion("mode", [
-      z16.object({ mode: z16.literal("deploy"), target: deployTargetSchema }),
-      z16.object({ mode: z16.literal("teardown"), target: teardownTargetSchema }),
-      z16.object({
-        mode: z16.literal("redeploy-app"),
+    previewJobSpecSchema = z17.discriminatedUnion("mode", [
+      z17.object({ mode: z17.literal("deploy"), target: deployTargetSchema }),
+      z17.object({ mode: z17.literal("teardown"), target: teardownTargetSchema }),
+      z17.object({
+        mode: z17.literal("redeploy-app"),
         target: redeployTargetSchema,
-        namespace: z16.string().min(1),
-        appName: z16.string().min(1),
-        redeployMode: z16.enum(["rebuild", "restart"])
+        namespace: z17.string().min(1),
+        appName: z17.string().min(1),
+        redeployMode: z17.enum(["rebuild", "restart"])
       })
     ]);
   }
@@ -4004,29 +4188,29 @@ var init_previewkit_authorable_config = __esm({
 });
 
 // ../../packages/types/src/schemas/previewkit-redeploy-app.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var RedeployPreviewkitAppInputSchema;
 var init_previewkit_redeploy_app = __esm({
   "../../packages/types/src/schemas/previewkit-redeploy-app.ts"() {
     "use strict";
     init_esm_shims();
-    RedeployPreviewkitAppInputSchema = z17.object({
-      applicationId: z17.string().min(1),
-      environmentId: z17.string().min(1),
-      app: z17.string().min(1),
-      mode: z17.enum(["rebuild", "restart"])
+    RedeployPreviewkitAppInputSchema = z18.object({
+      applicationId: z18.string().min(1),
+      environmentId: z18.string().min(1),
+      app: z18.string().min(1),
+      mode: z18.enum(["rebuild", "restart"])
     });
   }
 });
 
 // ../../packages/types/src/schemas/previewkit-service-suggestion.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var SuggestableServiceRecipeSchema, SuggestionAppRefSchema, SuggestServicesInputSchema, SuggestedServiceSchema, SuggestServicesResultSchema;
 var init_previewkit_service_suggestion = __esm({
   "../../packages/types/src/schemas/previewkit-service-suggestion.ts"() {
     "use strict";
     init_esm_shims();
-    SuggestableServiceRecipeSchema = z18.enum([
+    SuggestableServiceRecipeSchema = z19.enum([
       "postgres",
       "redis",
       "valkey",
@@ -4035,144 +4219,133 @@ var init_previewkit_service_suggestion = __esm({
       "temporal",
       "docker-image"
     ]);
-    SuggestionAppRefSchema = z18.object({
-      name: z18.string(),
-      path: z18.string(),
-      primary: z18.boolean().optional()
+    SuggestionAppRefSchema = z19.object({
+      name: z19.string(),
+      path: z19.string(),
+      primary: z19.boolean().optional()
     });
-    SuggestServicesInputSchema = z18.object({
-      applicationId: z18.string(),
-      githubRepositoryId: z18.number().int().positive().optional(),
-      apps: z18.array(SuggestionAppRefSchema)
+    SuggestServicesInputSchema = z19.object({
+      applicationId: z19.string(),
+      githubRepositoryId: z19.number().int().positive().optional(),
+      apps: z19.array(SuggestionAppRefSchema)
     });
-    SuggestedServiceSchema = z18.object({
+    SuggestedServiceSchema = z19.object({
       recipe: SuggestableServiceRecipeSchema,
-      name: z18.string(),
-      version: z18.string().optional(),
-      confidence: z18.enum(["high", "medium", "low"]),
-      evidence: z18.array(z18.string())
+      name: z19.string(),
+      version: z19.string().optional(),
+      confidence: z19.enum(["high", "medium", "low"]),
+      evidence: z19.array(z19.string())
     });
-    SuggestServicesResultSchema = z18.object({
-      status: z18.enum(["ok", "unavailable"]),
-      reason: z18.string().optional(),
-      services: z18.array(SuggestedServiceSchema)
+    SuggestServicesResultSchema = z19.object({
+      status: z19.enum(["ok", "unavailable"]),
+      reason: z19.string().optional(),
+      services: z19.array(SuggestedServiceSchema)
     });
   }
 });
 
 // ../../packages/types/src/schemas/previewkit-env-suggestion.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var SuggestionServiceRefSchema, SuggestEnvVarsInputSchema, SuggestedEnvVarSchema, SuggestedEnvGroupSchema, SuggestEnvVarsResultSchema;
 var init_previewkit_env_suggestion = __esm({
   "../../packages/types/src/schemas/previewkit-env-suggestion.ts"() {
     "use strict";
     init_esm_shims();
     init_previewkit_service_suggestion();
-    SuggestionServiceRefSchema = z19.object({
-      name: z19.string(),
+    SuggestionServiceRefSchema = z20.object({
+      name: z20.string(),
       recipe: SuggestableServiceRecipeSchema
     });
-    SuggestEnvVarsInputSchema = z19.object({
-      applicationId: z19.string(),
-      githubRepositoryId: z19.number().int().positive().optional(),
-      apps: z19.array(SuggestionAppRefSchema),
-      services: z19.array(SuggestionServiceRefSchema)
+    SuggestEnvVarsInputSchema = z20.object({
+      applicationId: z20.string(),
+      githubRepositoryId: z20.number().int().positive().optional(),
+      apps: z20.array(SuggestionAppRefSchema),
+      services: z20.array(SuggestionServiceRefSchema)
     });
-    SuggestedEnvVarSchema = z19.object({
-      key: z19.string(),
-      value: z19.string().optional(),
-      reference: z19.string().optional(),
-      sensitive: z19.boolean(),
+    SuggestedEnvVarSchema = z20.object({
+      key: z20.string(),
+      value: z20.string().optional(),
+      reference: z20.string().optional(),
+      sensitive: z20.boolean(),
       /**
        * Whether the value must be present during the image BUILD (not just at
        * runtime) - e.g. framework vars inlined into the client bundle
        * (`NEXT_PUBLIC_*`, `VITE_*`) or values read by the build/install command.
        * Maps to the row's "also inject at build time" switch. Omitted = runtime-only.
        */
-      build_time: z19.boolean().optional(),
-      description: z19.string().optional(),
-      confidence: z19.enum(["high", "medium", "low"]),
-      evidence: z19.array(z19.string())
+      build_time: z20.boolean().optional(),
+      description: z20.string().optional(),
+      confidence: z20.enum(["high", "medium", "low"]),
+      evidence: z20.array(z20.string())
     });
-    SuggestedEnvGroupSchema = z19.object({
-      name: z19.string(),
-      vars: z19.array(SuggestedEnvVarSchema)
+    SuggestedEnvGroupSchema = z20.object({
+      name: z20.string(),
+      vars: z20.array(SuggestedEnvVarSchema)
     });
-    SuggestEnvVarsResultSchema = z19.object({
-      status: z19.enum(["ok", "unavailable"]),
-      reason: z19.string().optional(),
-      apps: z19.array(SuggestedEnvGroupSchema),
-      services: z19.array(SuggestedEnvGroupSchema)
+    SuggestEnvVarsResultSchema = z20.object({
+      status: z20.enum(["ok", "unavailable"]),
+      reason: z20.string().optional(),
+      apps: z20.array(SuggestedEnvGroupSchema),
+      services: z20.array(SuggestedEnvGroupSchema)
     });
   }
 });
 
 // ../../packages/types/src/schemas/previewkit-diagnosis.ts
-import { z as z20 } from "zod";
-var DiagnosePreviewkitDeployInputSchema, PreviewDiagnosisCategorySchema, PreviewDiagnosisActionSchema, PreviewDiagnosisFindingSchema, DiagnosePreviewkitDeployResultSchema, AiDiagnosisResultSchema;
+import { z as z21 } from "zod";
+var DiagnosePreviewkitDeployInputSchema, PreviewDiagnosisCategorySchema, PreviewDiagnosisActionSchema, PreviewDiagnosisFindingSchema;
 var init_previewkit_diagnosis = __esm({
   "../../packages/types/src/schemas/previewkit-diagnosis.ts"() {
     "use strict";
     init_esm_shims();
     init_previewkit_env_suggestion();
-    DiagnosePreviewkitDeployInputSchema = z20.object({
-      applicationId: z20.string(),
+    DiagnosePreviewkitDeployInputSchema = z21.object({
+      applicationId: z21.string(),
       /**
        * Which preview environment to diagnose. Omitted defaults (in the service) to
-       * 0 - the main-branch (onboarding) preview - so the original onboarding caller
-       * is unchanged; MCP / per-PR callers pass the real PR number.
+       * 0 - the main-branch preview; per-PR callers pass the real PR number.
        */
-      prNumber: z20.number().int().min(0).optional(),
-      deployFingerprint: z20.string().optional()
+      prNumber: z21.number().int().min(0).optional(),
+      deployFingerprint: z21.string().optional()
     });
-    PreviewDiagnosisCategorySchema = z20.enum(["missing_env_var", "user_setup", "autonoma_error", "unknown"]);
-    PreviewDiagnosisActionSchema = z20.enum(["edit_config", "edit_secrets", "redeploy", "contact_support"]);
-    PreviewDiagnosisFindingSchema = z20.object({
+    PreviewDiagnosisCategorySchema = z21.enum(["missing_env_var", "user_setup", "autonoma_error", "unknown"]);
+    PreviewDiagnosisActionSchema = z21.enum(["edit_config", "edit_secrets", "redeploy", "contact_support"]);
+    PreviewDiagnosisFindingSchema = z21.object({
       category: PreviewDiagnosisCategorySchema,
-      severity: z20.enum(["blocking", "warning", "info"]),
-      title: z20.string(),
-      explanation: z20.string(),
-      fixSteps: z20.array(z20.string()),
-      appName: z20.string().optional(),
-      fieldPath: z20.string().optional(),
+      severity: z21.enum(["blocking", "warning", "info"]),
+      title: z21.string(),
+      explanation: z21.string(),
+      fixSteps: z21.array(z21.string()),
+      appName: z21.string().optional(),
+      fieldPath: z21.string().optional(),
       action: PreviewDiagnosisActionSchema.optional(),
-      suggestedEnv: z20.array(SuggestedEnvVarSchema).optional(),
-      confidence: z20.enum(["high", "medium", "low"]),
-      evidence: z20.array(z20.string())
-    });
-    DiagnosePreviewkitDeployResultSchema = z20.object({
-      status: z20.enum(["ok", "unavailable"]),
-      reason: z20.string().optional(),
-      summary: z20.string().optional(),
-      findings: z20.array(PreviewDiagnosisFindingSchema)
-    });
-    AiDiagnosisResultSchema = z20.object({
-      summary: z20.string(),
-      findings: z20.array(PreviewDiagnosisFindingSchema)
+      suggestedEnv: z21.array(SuggestedEnvVarSchema).optional(),
+      confidence: z21.enum(["high", "medium", "low"]),
+      evidence: z21.array(z21.string())
     });
   }
 });
 
 // ../../packages/types/src/schemas/snapshot-dependency-pin.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var snapshotDependencyShaMapSchema;
 var init_snapshot_dependency_pin = __esm({
   "../../packages/types/src/schemas/snapshot-dependency-pin.ts"() {
     "use strict";
     init_esm_shims();
-    snapshotDependencyShaMapSchema = z21.record(z21.string(), z21.string());
+    snapshotDependencyShaMapSchema = z22.record(z22.string(), z22.string());
   }
 });
 
 // ../../packages/types/src/schemas/checkpoint-summary.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var checkpointToneSchema, checkpointExecutionStateSchema, checkpointTestCountsSchema, checkpointAnalysisSummarySchema, checkpointPresentationSummarySchema;
 var init_checkpoint_summary = __esm({
   "../../packages/types/src/schemas/checkpoint-summary.ts"() {
     "use strict";
     init_esm_shims();
-    checkpointToneSchema = z22.enum(["success", "critical", "warning", "neutral"]);
-    checkpointExecutionStateSchema = z22.enum([
+    checkpointToneSchema = z23.enum(["success", "critical", "warning", "neutral"]);
+    checkpointExecutionStateSchema = z23.enum([
       "not_started",
       "running",
       "stale",
@@ -4181,34 +4354,34 @@ var init_checkpoint_summary = __esm({
       "pipeline_failed",
       "unknown"
     ]);
-    checkpointTestCountsSchema = z22.object({
-      assigned: z22.number(),
-      run: z22.number(),
-      passed: z22.number(),
-      failed: z22.number(),
+    checkpointTestCountsSchema = z23.object({
+      assigned: z23.number(),
+      run: z23.number(),
+      passed: z23.number(),
+      failed: z23.number(),
       // Tests that never ran because their scenario setup failed.
-      setupFailed: z22.number(),
-      running: z22.number(),
-      notRun: z22.number()
+      setupFailed: z23.number(),
+      running: z23.number(),
+      notRun: z23.number()
     });
-    checkpointAnalysisSummarySchema = z22.object({
+    checkpointAnalysisSummarySchema = z23.object({
       // The AnalysisJob lifecycle. Mirrors the `AnalysisJobStatus` db enum (types cannot import it).
-      jobStatus: z22.enum(["running", "completed", "failed"]),
+      jobStatus: z23.enum(["running", "completed", "failed"]),
       // Client-bug findings - the only plane that counts against the PR (turns the checkpoint red).
-      bugCount: z22.number().int().nonnegative(),
+      bugCount: z23.number().int().nonnegative(),
       // Findings that passed on the app-health plane.
-      passedCount: z22.number().int().nonnegative(),
+      passedCount: z23.number().int().nonnegative(),
       // Coverage-plane findings (engine_artifact / environment_failure / scenario_issue / delete) - never a
       // failure; surfaced as "couldn't confirm".
-      coverageCount: z22.number().int().nonnegative()
+      coverageCount: z23.number().int().nonnegative()
     });
-    checkpointPresentationSummarySchema = z22.object({
+    checkpointPresentationSummarySchema = z23.object({
       tone: checkpointToneSchema,
-      label: z22.string(),
-      reason: z22.string().optional(),
+      label: z23.string(),
+      reason: z23.string().optional(),
       executionState: checkpointExecutionStateSchema,
       testCounts: checkpointTestCountsSchema,
-      suiteChangeCount: z22.number(),
+      suiteChangeCount: z23.number(),
       // Set only for authoritative-analysis snapshots; absent for legacy diffs/shadow snapshots.
       analysis: checkpointAnalysisSummarySchema.optional()
     });
@@ -4216,65 +4389,65 @@ var init_checkpoint_summary = __esm({
 });
 
 // ../../packages/types/src/schemas/snapshot-report.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var reportHealthSchema, reportTestStatusSchema, reportCommitFileSchema, snapshotReportTriggerSchema, snapshotReportTestResultSchema, snapshotReportResultsSchema, snapshotReportHealthCountsSchema, snapshotReportSchema;
 var init_snapshot_report = __esm({
   "../../packages/types/src/schemas/snapshot-report.ts"() {
     "use strict";
     init_esm_shims();
     init_checkpoint_summary();
-    reportHealthSchema = z23.enum(["healthy", "critical", "running", "unknown"]);
-    reportTestStatusSchema = z23.enum(["passed", "failed", "setup_failed", "running", "pending"]);
-    reportCommitFileSchema = z23.object({
-      filename: z23.string(),
-      status: z23.string(),
-      additions: z23.number(),
-      deletions: z23.number()
+    reportHealthSchema = z24.enum(["healthy", "critical", "running", "unknown"]);
+    reportTestStatusSchema = z24.enum(["passed", "failed", "setup_failed", "running", "pending"]);
+    reportCommitFileSchema = z24.object({
+      filename: z24.string(),
+      status: z24.string(),
+      additions: z24.number(),
+      deletions: z24.number()
     });
-    snapshotReportTriggerSchema = z23.object({
-      headSha: z23.string().optional(),
-      baseSha: z23.string().optional(),
-      source: z23.string(),
-      createdAt: z23.date(),
-      commit: z23.object({ message: z23.string(), authorLogin: z23.string().optional() }).optional(),
-      filesChanged: z23.array(reportCommitFileSchema),
-      filesChangedTruncated: z23.boolean()
+    snapshotReportTriggerSchema = z24.object({
+      headSha: z24.string().optional(),
+      baseSha: z24.string().optional(),
+      source: z24.string(),
+      createdAt: z24.date(),
+      commit: z24.object({ message: z24.string(), authorLogin: z24.string().optional() }).optional(),
+      filesChanged: z24.array(reportCommitFileSchema),
+      filesChangedTruncated: z24.boolean()
     });
-    snapshotReportTestResultSchema = z23.object({
-      testCaseId: z23.string(),
-      name: z23.string(),
-      slug: z23.string(),
+    snapshotReportTestResultSchema = z24.object({
+      testCaseId: z24.string(),
+      name: z24.string(),
+      slug: z24.string(),
       status: reportTestStatusSchema,
-      runId: z23.string().optional(),
-      durationMs: z23.number().optional()
+      runId: z24.string().optional(),
+      durationMs: z24.number().optional()
     });
-    snapshotReportResultsSchema = z23.object({
-      durationMs: z23.number().optional(),
-      passed: z23.number(),
-      failed: z23.number(),
-      setupFailed: z23.number(),
-      pending: z23.number(),
-      running: z23.number(),
-      total: z23.number(),
-      tests: z23.array(snapshotReportTestResultSchema)
+    snapshotReportResultsSchema = z24.object({
+      durationMs: z24.number().optional(),
+      passed: z24.number(),
+      failed: z24.number(),
+      setupFailed: z24.number(),
+      pending: z24.number(),
+      running: z24.number(),
+      total: z24.number(),
+      tests: z24.array(snapshotReportTestResultSchema)
     });
-    snapshotReportHealthCountsSchema = z23.object({
-      failing: z23.number(),
-      passing: z23.number(),
-      running: z23.number(),
-      setupFailed: z23.number(),
-      notAffected: z23.number(),
-      totalTests: z23.number()
+    snapshotReportHealthCountsSchema = z24.object({
+      failing: z24.number(),
+      passing: z24.number(),
+      running: z24.number(),
+      setupFailed: z24.number(),
+      notAffected: z24.number(),
+      totalTests: z24.number()
     });
-    snapshotReportSchema = z23.object({
-      snapshot: z23.object({
-        id: z23.string(),
-        status: z23.string(),
-        source: z23.string(),
-        headSha: z23.string().optional(),
-        baseSha: z23.string().optional(),
-        createdAt: z23.date(),
-        branch: z23.object({ id: z23.string(), name: z23.string(), prNumber: z23.number().optional() })
+    snapshotReportSchema = z24.object({
+      snapshot: z24.object({
+        id: z24.string(),
+        status: z24.string(),
+        source: z24.string(),
+        headSha: z24.string().optional(),
+        baseSha: z24.string().optional(),
+        createdAt: z24.date(),
+        branch: z24.object({ id: z24.string(), name: z24.string(), prNumber: z24.number().optional() })
       }),
       trigger: snapshotReportTriggerSchema,
       results: snapshotReportResultsSchema,
@@ -4286,35 +4459,35 @@ var init_snapshot_report = __esm({
 });
 
 // ../../packages/types/src/schemas/pr-pipeline-status.ts
-import { z as z24 } from "zod";
+import { z as z25 } 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 = z24.discriminatedUnion("kind", [
-      z24.object({ kind: z24.literal("checkpoint"), summary: checkpointPresentationSummarySchema }),
-      z24.object({ kind: z24.literal("building") }),
-      z24.object({ kind: z24.literal("pending_checks") }),
-      z24.object({ kind: z24.literal("analyzing") }),
-      z24.object({ kind: z24.literal("analysis_failed") }),
-      z24.object({ kind: z24.literal("build_failed") }),
-      z24.object({ kind: z24.literal("none") })
+    prPipelineStatusSchema = z25.discriminatedUnion("kind", [
+      z25.object({ kind: z25.literal("checkpoint"), summary: checkpointPresentationSummarySchema }),
+      z25.object({ kind: z25.literal("building") }),
+      z25.object({ kind: z25.literal("pending_checks") }),
+      z25.object({ kind: z25.literal("analyzing") }),
+      z25.object({ kind: z25.literal("analysis_failed") }),
+      z25.object({ kind: z25.literal("build_failed") }),
+      z25.object({ kind: z25.literal("none") })
     ]);
   }
 });
 
 // ../../packages/types/src/schemas/step-output.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var pointSchema2, stepOutputDataSchema;
 var init_step_output = __esm({
   "../../packages/types/src/schemas/step-output.ts"() {
     "use strict";
     init_esm_shims();
-    pointSchema2 = z25.object({ x: z25.number(), y: z25.number() });
-    stepOutputDataSchema = z25.object({
-      outcome: z25.string().optional(),
+    pointSchema2 = z26.object({ x: z26.number(), y: z26.number() });
+    stepOutputDataSchema = z26.object({
+      outcome: z26.string().optional(),
       point: pointSchema2.optional(),
       startPoint: pointSchema2.optional(),
       endPoint: pointSchema2.optional()
@@ -4323,7 +4496,7 @@ var init_step_output = __esm({
 });
 
 // ../../packages/types/src/schemas/activation-triggers.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var MAX_LABEL_LENGTH, CONTROL_CHARS, AnalysisTriggerLabelSchema, TriggerConfigSchema;
 var init_activation_triggers = __esm({
   "../../packages/types/src/schemas/activation-triggers.ts"() {
@@ -4331,10 +4504,10 @@ var init_activation_triggers = __esm({
     init_esm_shims();
     MAX_LABEL_LENGTH = 50;
     CONTROL_CHARS = /[\u0000-\u001F\u007F]/;
-    AnalysisTriggerLabelSchema = z26.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 = z26.object({
+    AnalysisTriggerLabelSchema = z27.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 = z27.object({
       /** Whether marking a PR ready-for-review automatically starts an analysis run. */
-      autoRunOnReadyForReview: z26.boolean(),
+      autoRunOnReadyForReview: z27.boolean(),
       /** The PR label whose addition starts an analysis run. */
       analysisTriggerLabel: AnalysisTriggerLabelSchema
     });
@@ -4342,67 +4515,67 @@ var init_activation_triggers = __esm({
 });
 
 // ../../packages/types/src/schemas/suite-health.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var SUITE_HEALTH_LEVELS, suiteHealthLevelSchema, suiteHealthDriverSchema, suiteHealthGateSchema, suiteHealthEvidenceSchema, suiteHealthBreakdownSchema, suiteHealthSchema;
 var init_suite_health = __esm({
   "../../packages/types/src/schemas/suite-health.ts"() {
     "use strict";
     init_esm_shims();
     SUITE_HEALTH_LEVELS = ["degraded", "at_risk", "calibrating", "steady", "proven"];
-    suiteHealthLevelSchema = z27.enum(SUITE_HEALTH_LEVELS);
-    suiteHealthDriverSchema = z27.enum(["environment", "scenario", "plan", "engine", "balanced", "none"]);
-    suiteHealthGateSchema = z27.enum(["runs", "pull_requests", "age", "stale_issues", "no_triage"]);
-    suiteHealthEvidenceSchema = z27.object({
+    suiteHealthLevelSchema = z28.enum(SUITE_HEALTH_LEVELS);
+    suiteHealthDriverSchema = z28.enum(["environment", "scenario", "plan", "engine", "balanced", "none"]);
+    suiteHealthGateSchema = z28.enum(["runs", "pull_requests", "age", "stale_issues", "no_triage"]);
+    suiteHealthEvidenceSchema = z28.object({
       /** Analysis runs in the window. A run that selected no tests is not one. */
-      runs: z27.number().int(),
+      runs: z28.number().int(),
       /** Distinct branches those runs covered. */
-      pullRequests: z27.number().int(),
+      pullRequests: z28.number().int(),
       /** Tests the agent re-planned and re-ran, that then passed. */
-      selfHeals: z27.number().int(),
+      selfHeals: z28.number().int(),
       /** Tests the agent re-planned and re-ran at all - the denominator of the self-heal rate. */
-      selfHealAttempts: z27.number().int(),
+      selfHealAttempts: z28.number().int(),
       /** Total findings in the window - the denominator of the trust rate. */
-      findings: z27.number().int(),
+      findings: z28.number().int(),
       /** Whole days since the app's first analysis run of any pipeline. */
-      ageDays: z27.number().int(),
+      ageDays: z28.number().int(),
       /** Whole days since its most recent run. Drives the inactivity decay. */
-      daysSinceLastRun: z27.number().int()
+      daysSinceLastRun: z28.number().int()
     });
-    suiteHealthBreakdownSchema = z27.object({
-      passed: z27.number().int(),
-      clientBug: z27.number().int(),
-      environmentFailure: z27.number().int(),
-      scenarioIssue: z27.number().int(),
-      planMismatch: z27.number().int(),
-      engineArtifact: z27.number().int(),
-      invalidTest: z27.number().int()
+    suiteHealthBreakdownSchema = z28.object({
+      passed: z28.number().int(),
+      clientBug: z28.number().int(),
+      environmentFailure: z28.number().int(),
+      scenarioIssue: z28.number().int(),
+      planMismatch: z28.number().int(),
+      engineArtifact: z28.number().int(),
+      invalidTest: z28.number().int()
     });
-    suiteHealthSchema = z27.object({
+    suiteHealthSchema = z28.object({
       level: suiteHealthLevelSchema,
       /** 1-5. Always `suiteHealthRank(level)`; sent so clients never re-derive it. */
-      rank: z27.number().int(),
+      rank: z28.number().int(),
       /** 0-100, after modifiers. Display-only - the level is what surfaces read. */
-      score: z27.number(),
+      score: z28.number(),
       /**
        * `(passed + client_bug) / findings`, 0-100, before modifiers. The headline fact: of the tests the agent
        * investigated, how many produced a verdict you can act on.
        */
-      trust: z27.number(),
+      trust: z28.number(),
       evidence: suiteHealthEvidenceSchema,
       breakdown: suiteHealthBreakdownSchema,
       driver: suiteHealthDriverSchema,
       /** Open issues older than a week on a branch that is still live. What DEGRADED is actually made of. */
-      staleIssues: z27.number().int(),
+      staleIssues: z28.number().int(),
       /** The gate holding the level down, if the score alone would have placed it higher. */
       gatedBy: suiteHealthGateSchema.optional(),
       /** False before the first analysis run ever - the meter shows "waiting for your first pull request". */
-      hasEverRun: z27.boolean()
+      hasEverRun: z28.boolean()
     });
   }
 });
 
 // ../../packages/types/src/schemas/suite-health-fix-plan.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var suiteHealthFixKindSchema, suiteHealthFixSeveritySchema, suiteHealthFixIssueSchema, suiteHealthFixBranchStateSchema, suiteHealthFixBranchSchema, suiteHealthFixClusterSchema, suiteHealthFixPlanSchema;
 var init_suite_health_fix_plan = __esm({
   "../../packages/types/src/schemas/suite-health-fix-plan.ts"() {
@@ -4411,70 +4584,70 @@ var init_suite_health_fix_plan = __esm({
     init_analysis();
     suiteHealthFixKindSchema = analysisIssueKindSchema;
     suiteHealthFixSeveritySchema = analysisIssueSeveritySchema;
-    suiteHealthFixIssueSchema = z28.object({
-      id: z28.string(),
+    suiteHealthFixIssueSchema = z29.object({
+      id: z29.string(),
       kind: suiteHealthFixKindSchema,
       severity: suiteHealthFixSeveritySchema,
-      title: z28.string(),
-      ageDays: z28.number().int()
+      title: z29.string(),
+      ageDays: z29.number().int()
     });
-    suiteHealthFixBranchStateSchema = z28.enum(["open", "merged", "closed", "main"]);
-    suiteHealthFixBranchSchema = z28.object({
-      branchId: z28.string(),
-      branchName: z28.string(),
+    suiteHealthFixBranchStateSchema = z29.enum(["open", "merged", "closed", "main"]);
+    suiteHealthFixBranchSchema = z29.object({
+      branchId: z29.string(),
+      branchName: z29.string(),
       state: suiteHealthFixBranchStateSchema,
-      prNumber: z28.number().int().optional(),
-      prTitle: z28.string().optional(),
-      prUrl: z28.string().optional(),
+      prNumber: z29.number().int().optional(),
+      prTitle: z29.string().optional(),
+      prUrl: z29.string().optional(),
       /** The findings shown. Capped - `issueCount` is the true total. */
-      issues: z28.array(suiteHealthFixIssueSchema),
-      issueCount: z28.number().int(),
+      issues: z29.array(suiteHealthFixIssueSchema),
+      issueCount: z29.number().int(),
       /** Kind tally over EVERY finding on the branch, not just the shown ones - those two routinely differ. */
-      byKind: z28.object({
-        bug: z28.number().int(),
-        environment: z28.number().int(),
-        scenario: z28.number().int()
+      byKind: z29.object({
+        bug: z29.number().int(),
+        environment: z29.number().int(),
+        scenario: z29.number().int()
       }),
       /** Age of the oldest unresolved finding on this branch, in whole days. */
-      oldestAgeDays: z28.number().int()
+      oldestAgeDays: z29.number().int()
     });
-    suiteHealthFixClusterSchema = z28.object({
-      title: z28.string(),
+    suiteHealthFixClusterSchema = z29.object({
+      title: z29.string(),
       kind: suiteHealthFixKindSchema,
       /** Distinct branches carrying it. */
-      branches: z28.number().int(),
+      branches: z29.number().int(),
       /** How many of those are still-open pull requests - the ones a fix unblocks today. */
-      openBranches: z28.number().int(),
-      findings: z28.number().int()
+      openBranches: z29.number().int(),
+      findings: z29.number().int()
     });
-    suiteHealthFixPlanSchema = z28.object({
+    suiteHealthFixPlanSchema = z29.object({
       /**
        * `owner/repo`, which every MCP tool is keyed by. Absent when it cannot be resolved without asking GitHub,
        * in which case the prompt tells the agent to read the git remote instead - which is what the MCP's own
        * instructions tell it to do anyway.
        */
-      repoFullName: z28.string().optional(),
+      repoFullName: z29.string().optional(),
       /** Unresolved findings across every branch. */
-      totalIssues: z28.number().int(),
-      byKind: z28.object({
-        bug: z28.number().int(),
-        environment: z28.number().int(),
-        scenario: z28.number().int()
+      totalIssues: z29.number().int(),
+      byKind: z29.object({
+        bug: z29.number().int(),
+        environment: z29.number().int(),
+        scenario: z29.number().int()
       }),
       /** Age of the oldest unresolved finding anywhere on the app, in whole days. */
-      oldestAgeDays: z28.number().int(),
+      oldestAgeDays: z29.number().int(),
       /** True when the scan hit its cap, so `totalIssues` is a floor rather than the count. Never hide this. */
-      truncated: z28.boolean(),
+      truncated: z29.boolean(),
       /** Repeated findings, most-shared first. Empty when nothing repeats. */
-      clusters: z28.array(suiteHealthFixClusterSchema),
+      clusters: z29.array(suiteHealthFixClusterSchema),
       /** The prompt the user copies. Authored from the rows above. */
-      prompt: z28.string()
+      prompt: z29.string()
     });
   }
 });
 
 // ../../packages/types/src/schemas/index.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var PlatformSchema, TestStatusSchema;
 var init_schemas = __esm({
   "../../packages/types/src/schemas/index.ts"() {
@@ -4488,9 +4661,11 @@ var init_schemas = __esm({
     init_evidence_tokens();
     init_generation();
     init_api_key();
+    init_organization();
     init_secrets();
     init_previewkit_builtins();
     init_previewkit_config();
+    init_previewkit_config_rows();
     init_previewkit_job_spec();
     init_previewkit_node_build();
     init_previewkit_node_pm();
@@ -4510,8 +4685,8 @@ var init_schemas = __esm({
     init_activation_triggers();
     init_suite_health();
     init_suite_health_fix_plan();
-    PlatformSchema = z29.enum(["web", "ios", "android"]);
-    TestStatusSchema = z29.enum(["pending", "running", "passed", "failed", "cancelled"]);
+    PlatformSchema = z30.enum(["web", "ios", "android"]);
+    TestStatusSchema = z30.enum(["pending", "running", "passed", "failed", "cancelled"]);
   }
 });
 
@@ -4546,16 +4721,16 @@ var init_billing = __esm({
 });
 
 // ../../packages/types/src/schemas/billing.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var BillingTransactionSchema, BillingStatusSchema, CreateCheckoutInputSchema, AutoTopUpInputSchema, RunCompletedSchema;
 var init_billing2 = __esm({
   "../../packages/types/src/schemas/billing.ts"() {
     "use strict";
     init_esm_shims();
     init_billing();
-    BillingTransactionSchema = z30.object({
-      id: z30.string(),
-      type: z30.enum([
+    BillingTransactionSchema = z31.object({
+      id: z31.string(),
+      type: z31.enum([
         "SUBSCRIPTION_GRANT",
         "SUBSCRIPTION_RESET",
         "TOPUP_PURCHASE",
@@ -4564,70 +4739,70 @@ var init_billing2 = __esm({
         "GENERATION_REFUND",
         "RUN_CONSUMPTION"
       ]),
-      amount: z30.number(),
-      balanceAfter: z30.number(),
-      generationId: z30.string().optional(),
-      runId: z30.string().optional(),
-      stripePaymentIntentId: z30.string().optional(),
-      stripeInvoiceId: z30.string().optional(),
-      stripeRefundId: z30.string().optional(),
-      createdAt: z30.date()
+      amount: z31.number(),
+      balanceAfter: z31.number(),
+      generationId: z31.string().optional(),
+      runId: z31.string().optional(),
+      stripePaymentIntentId: z31.string().optional(),
+      stripeInvoiceId: z31.string().optional(),
+      stripeRefundId: z31.string().optional(),
+      createdAt: z31.date()
     });
-    BillingStatusSchema = z30.object({
-      creditBalance: z30.number(),
-      subscriptionCreditBalance: z30.number(),
-      topupCreditBalance: z30.number(),
-      subscriptionStatus: z30.enum(["active", "canceled", "past_due", "unpaid", "trialing", "paused", "incomplete", "incomplete_expired"]).optional(),
-      currentPeriodEnd: z30.date().optional(),
-      cancelAtPeriodEnd: z30.boolean(),
-      gracePeriodEndsAt: z30.date().optional(),
-      autoTopUpEnabled: z30.boolean(),
-      autoTopUpThreshold: z30.number(),
-      transactions: z30.array(BillingTransactionSchema)
+    BillingStatusSchema = z31.object({
+      creditBalance: z31.number(),
+      subscriptionCreditBalance: z31.number(),
+      topupCreditBalance: z31.number(),
+      subscriptionStatus: z31.enum(["active", "canceled", "past_due", "unpaid", "trialing", "paused", "incomplete", "incomplete_expired"]).optional(),
+      currentPeriodEnd: z31.date().optional(),
+      cancelAtPeriodEnd: z31.boolean(),
+      gracePeriodEndsAt: z31.date().optional(),
+      autoTopUpEnabled: z31.boolean(),
+      autoTopUpThreshold: z31.number(),
+      transactions: z31.array(BillingTransactionSchema)
     });
-    CreateCheckoutInputSchema = z30.object({
-      type: z30.enum([BILLING_CHECKOUT_TYPES.SUBSCRIPTION, BILLING_CHECKOUT_TYPES.TOPUP])
+    CreateCheckoutInputSchema = z31.object({
+      type: z31.enum([BILLING_CHECKOUT_TYPES.SUBSCRIPTION, BILLING_CHECKOUT_TYPES.TOPUP])
     });
-    AutoTopUpInputSchema = z30.object({
-      enabled: z30.boolean(),
-      threshold: z30.number().int().min(0)
+    AutoTopUpInputSchema = z31.object({
+      enabled: z31.boolean(),
+      threshold: z31.number().int().min(0)
     });
-    RunCompletedSchema = z30.object({
-      generationId: z30.string()
+    RunCompletedSchema = z31.object({
+      generationId: z31.string()
     });
   }
 });
 
 // ../../packages/types/src/schemas/github.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var GitHubInstallationStatusSchema, GithubInstallationSchema;
 var init_github = __esm({
   "../../packages/types/src/schemas/github.ts"() {
     "use strict";
     init_esm_shims();
-    GitHubInstallationStatusSchema = z31.enum(["active", "suspended", "deleted"]);
-    GithubInstallationSchema = z31.object({
-      id: z31.string(),
-      installationId: z31.number(),
-      organizationId: z31.string(),
-      accountLogin: z31.string(),
-      accountId: z31.number(),
-      accountType: z31.string(),
+    GitHubInstallationStatusSchema = z32.enum(["active", "suspended", "deleted"]);
+    GithubInstallationSchema = z32.object({
+      id: z32.string(),
+      installationId: z32.number(),
+      organizationId: z32.string(),
+      accountLogin: z32.string(),
+      accountId: z32.number(),
+      accountType: z32.string(),
       status: GitHubInstallationStatusSchema,
-      createdAt: z31.date(),
-      updatedAt: z31.date()
+      createdAt: z32.date(),
+      updatedAt: z32.date()
     });
   }
 });
 
 // ../../packages/types/src/schemas/vercel.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var VercelInstallationWireStatusSchema;
 var init_vercel = __esm({
   "../../packages/types/src/schemas/vercel.ts"() {
     "use strict";
     init_esm_shims();
-    VercelInstallationWireStatusSchema = z32.enum([
+    VercelInstallationWireStatusSchema = z33.enum([
       "ready",
       "pending",
       "onboarding",
@@ -4683,6 +4858,15 @@ var init_preview_url = __esm({
   "../../packages/types/src/preview-url.ts"() {
     "use strict";
     init_esm_shims();
+    init_parse_url();
+  }
+});
+
+// ../../packages/types/src/org-domain.ts
+var init_org_domain = __esm({
+  "../../packages/types/src/org-domain.ts"() {
+    "use strict";
+    init_esm_shims();
   }
 });
 
@@ -4734,6 +4918,32 @@ var init_analytics_headers = __esm({
   }
 });
 
+// ../../packages/types/src/constants/application-instructions.ts
+var init_application_instructions = __esm({
+  "../../packages/types/src/constants/application-instructions.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/types/src/constants/auth-cookies.ts
+var init_auth_cookies = __esm({
+  "../../packages/types/src/constants/auth-cookies.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/types/src/constants/integration-branch.ts
+var INTEGRATION_BRANCH;
+var init_integration_branch = __esm({
+  "../../packages/types/src/constants/integration-branch.ts"() {
+    "use strict";
+    init_esm_shims();
+    INTEGRATION_BRANCH = "autonoma-integration";
+  }
+});
+
 // ../../packages/types/src/constants/pipeline-labels.ts
 var init_pipeline_labels = __esm({
   "../../packages/types/src/constants/pipeline-labels.ts"() {
@@ -4748,7 +4958,10 @@ var init_constants = __esm({
     "use strict";
     init_esm_shims();
     init_analytics_headers();
+    init_application_instructions();
+    init_auth_cookies();
     init_billing();
+    init_integration_branch();
     init_pipeline_labels();
   }
 });
@@ -4761,14 +4974,6 @@ var init_architecture = __esm({
   }
 });
 
-// ../../packages/types/src/types/previewkit.ts
-var init_previewkit = __esm({
-  "../../packages/types/src/types/previewkit.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
 // ../../packages/types/src/types/parse-string-record.ts
 var init_parse_string_record = __esm({
   "../../packages/types/src/types/parse-string-record.ts"() {
@@ -4805,7 +5010,10 @@ var init_src = __esm({
     init_github();
     init_vercel();
     init_sensitive_detection();
+    init_parse_url();
     init_preview_url();
+    init_sdk_endpoint();
+    init_org_domain();
     init_app_links();
     init_agent_handoff_links();
     init_sdk_error_signals();
@@ -5260,7 +5468,7 @@ var init_output = __esm({
 // src/core/preferences.ts
 import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { join as join12 } from "path";
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 async function readPreferences() {
   try {
     const raw = await readFile4(PREFERENCES_FILE, "utf-8");
@@ -5295,9 +5503,9 @@ var init_preferences = __esm({
     init_debug();
     init_output();
     PREFERENCES_FILE = join12(AUTONOMA_HOME3, "preferences.json");
-    PreferencesSchema = z34.object({
+    PreferencesSchema = z35.object({
       /** The coding agent id (`claude`, `codex`) last chosen from the picker. */
-      agentId: z34.string().optional()
+      agentId: z35.string().optional()
     });
   }
 });
@@ -5316,6 +5524,9 @@ __export(coding_agent_exports, {
   parsePermissionMode: () => parsePermissionMode,
   selectLauncher: () => selectLauncher
 });
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join13 } from "path";
 import spawn from "cross-spawn";
 import which from "which";
 function isSpawnedByPlanner2(env = process.env) {
@@ -5362,10 +5573,28 @@ function parsePermissionMode(value) {
   if (value === "default" || value === "acceptEdits" || value === "bypassPermissions") return value;
   return void 0;
 }
+function describeCommandFailure(result, label) {
+  return explainFailureReason(firstLine(result.stderr) || firstLine(result.stdout) || "unknown error", label);
+}
+function isClientNotExecutable(output) {
+  return CLIENT_NOT_EXECUTABLE_PATTERNS.some((pattern) => pattern.test(output));
+}
+function explainFailureReason(reason, label) {
+  if (!isClientNotExecutable(reason)) return reason;
+  return `${label} is on your PATH but could not be run (${reason}). Reinstall it, then run again.`;
+}
+function describeSignInFailure(login, label) {
+  const reason = firstLine(login.stderr);
+  const code = login.code ?? "unknown";
+  return reason.length > 0 ? ` (exit ${code}: ${explainFailureReason(reason, label)})` : ` (exit ${code})`;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function firstLine(output) {
   return output.split("\n").find((line) => line.trim().length > 0)?.trim() ?? "";
 }
-var MCP_COMMAND_TIMEOUT_MS, CODEX_BEARER_TOKEN_ENV, CLAUDE_CONNECTED_MARKER, DEFAULT_PERMISSION_MODE, PERMISSION_MODE_LABELS, CLAUDE_ID, CODEX_ID, BaseLauncher, ClaudeLauncher, CodexLauncher;
+var MCP_COMMAND_TIMEOUT_MS, ATTACHED_STDERR_CAP, CODEX_BEARER_TOKEN_ENV, CLAUDE_CONNECTED_MARKER, CLIENT_NOT_EXECUTABLE_PATTERNS, CLAUDE_AUTH_HEADER_MARKER, CLAUDE_NEEDS_AUTH_CACHE_FILE, CLAUDE_MODEL, CLAUDE_SUBAGENT_MODEL_ENV, 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";
@@ -5373,11 +5602,23 @@ var init_coding_agent = __esm({
     init_prompts();
     init_agent_env();
     init_debug();
+    init_logs();
     init_preferences();
     init_agent_env();
     MCP_COMMAND_TIMEOUT_MS = 6e4;
+    ATTACHED_STDERR_CAP = 4e3;
     CODEX_BEARER_TOKEN_ENV = "AUTONOMA_MCP_TOKEN";
     CLAUDE_CONNECTED_MARKER = "Connected";
+    CLIENT_NOT_EXECUTABLE_PATTERNS = [
+      /is not recognized as an internal or external command/i,
+      /command not found/i,
+      /\bENOENT\b/,
+      /no such file or directory/i
+    ];
+    CLAUDE_AUTH_HEADER_MARKER = "Authorization:";
+    CLAUDE_NEEDS_AUTH_CACHE_FILE = "mcp-needs-auth-cache.json";
+    CLAUDE_MODEL = "opus";
+    CLAUDE_SUBAGENT_MODEL_ENV = "CLAUDE_CODE_SUBAGENT_MODEL";
     DEFAULT_PERMISSION_MODE = "bypassPermissions";
     PERMISSION_MODE_LABELS = {
       default: "Approve each command",
@@ -5464,40 +5705,107 @@ var init_coding_agent = __esm({
       /**
        * 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.
+       * Never throws. A sign-in is a convenience over the credential the run is already
+       * holding, so every way it can fail - no terminal to open a browser from, a
+       * client that exits non-zero - resolves to a result the caller can fall back on.
+       * Refusing without a terminal is still the right call: the flow prints a URL and
+       * blocks on a callback, so with nobody at the keyboard it would not fail, it would
+       * hang indefinitely on a prompt nobody can see.
        */
       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.`
-          );
+          return { ok: false, detail: " (no terminal to run a browser sign-in from)", clientUnusable: false };
         }
         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) {
+        if (login.code === 0) return { ok: true, detail: "", clientUnusable: false };
+        debugLog(`${this.label} sign-in failed`, { serverName, code: login.code, stderr: login.stderr });
+        return {
+          ok: false,
+          detail: describeSignInFailure(login, this.label),
+          clientUnusable: isClientNotExecutable(login.stderr)
+        };
+      }
+      /**
+       * The credential a registration must have when no browser sign-in is on the table.
+       * Its absence is a configuration error worth stating now, rather than an
+       * unauthorized server the spawned agent discovers on its first tool call.
+       */
+      requireHeadlessToken(spec) {
+        if (spec.apiToken != null) return spec.apiToken;
+        throw new Error(
+          `Cannot authorize the ${spec.name} MCP server for ${this.label} without a terminal: a browser sign-in needs someone to approve it. Set AUTONOMA_API_TOKEN so the run authorizes with an API key instead.`
+        );
+      }
+      /**
+       * Authorize a server that a browser sign-in was preferred for, and say how it
+       * ended up authorized so the caller can register it accordingly.
+       *
+       * A failed sign-in is not the end of the run. The token that falls back here is
+       * the same one that already authorized every API call made to get this far, so
+       * refusing to use it loses the run to a browser that would not open. It also
+       * repairs what the attempt broke: a failed `mcp login` clears whatever stored
+       * credentials the client had, which is why a first failure used to make every
+       * later run fail too.
+       */
+      async authorizeInteractively(spec) {
+        const signIn = await this.signIn(spec.name);
+        if (signIn.ok) return { via: "sign-in" };
+        return { via: "token", ...this.fallBackToToken(spec, signIn) };
+      }
+      /**
+       * Switch to the run's own API token after a browser sign-in did not happen, for
+       * whatever reason - it was refused, it failed, or the client folded it into a
+       * registration that failed. Throws only when there is no token to switch to.
+       */
+      fallBackToToken(spec, signIn) {
+        const detail = signIn.detail;
+        if (signIn.clientUnusable) {
+          throw new Error(`Could not register the ${spec.name} MCP server with ${this.label}:${detail}`);
+        }
+        if (spec.apiToken == null) {
           throw new Error(
-            `${this.label} could not sign in to the ${serverName} MCP server (exit ${login ?? "unknown"}).`
+            `${this.label} could not sign in to the ${spec.name} MCP server${detail}, and this run has no API token to fall back on. Set AUTONOMA_API_TOKEN and run again.`
           );
         }
+        captureLog("warn", "Browser sign-in failed; authorizing the MCP server with the run's API token", {
+          source: "coding_agent",
+          agent: this.id,
+          detail
+        });
+        log.warn(
+          `${this.label} couldn't sign in to the ${spec.name} MCP server${detail}. Authorizing it with this run's API token instead.`
+        );
+        return { apiToken: spec.apiToken };
       }
       /**
        * 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.
+       * The client prints a URL, opens a browser and waits on the callback, so stdin and
+       * stdout stay attached to this process.
+       *
+       * stderr is the exception: it is piped so the client's own diagnosis can be quoted
+       * back and reported, and echoed as it arrives so the user still watches it live.
+       * Inheriting it would put that text on screen and nowhere else, which is what made
+       * every sign-in failure look identical from the outside.
        */
       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" });
+          const proc = spawn(this.command, args, {
+            cwd: this.opts.cwd,
+            env: this.opts.env,
+            stdio: ["inherit", "inherit", "pipe"]
+          });
+          let stderr = "";
+          proc.stderr?.on("data", (chunk) => {
+            process.stderr.write(chunk);
+            if (stderr.length < ATTACHED_STDERR_CAP) stderr += chunk.toString();
+          });
           proc.on("error", (err) => {
             debugLog(`${this.command} ${args[0] ?? ""} failed to spawn`, { err });
-            resolve6(void 0);
+            resolve6({ code: void 0, stderr: err.message });
           });
-          proc.on("close", (code) => resolve6(code ?? void 0));
+          proc.on("close", (code) => resolve6({ code: code ?? void 0, stderr }));
         });
       }
     };
@@ -5506,36 +5814,113 @@ var init_coding_agent = __esm({
       label = "Claude Code";
       command = CLAUDE_ID;
       buildArgs(message, permissionMode, interactive) {
-        return interactive ? ["--permission-mode", permissionMode, message] : ["-p", message, "--permission-mode", permissionMode, "--verbose"];
+        return interactive ? ["--permission-mode", permissionMode, "--model", CLAUDE_MODEL, message] : ["-p", message, "--permission-mode", permissionMode, "--model", CLAUDE_MODEL, "--verbose"];
+      }
+      /** Carry the model floor into the session's subagents, which read it from the env. */
+      spawnEnv(extra) {
+        return { ...super.spawnEnv(extra), [CLAUDE_SUBAGENT_MODEL_ENV]: CLAUDE_MODEL };
       }
       /**
-       * `--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.
+       * Headless registers with the bearer header outright - there is no browser to sign
+       * in with. Interactively the registration goes in without one so the client's own
+       * sign-in can claim it, and the header is applied only if that sign-in fails.
        */
       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"]);
+        const registration = await this.register(spec);
+        await this.forgetNeedsAuthVerdict(spec.name);
+        return registration;
+      }
+      /**
+       * Forget Claude's cached "this server needs authorization" verdict for this name.
+       *
+       * Claude caches that verdict per server NAME and then skips connecting on every
+       * later session - "Skipping connection (cached needs-auth)" in its own debug log -
+       * whatever the registration now holds. The health check this class runs to decide
+       * whether to sign in is itself what writes the entry, and a successful one does not
+       * clear it. Without this, a registration can report Connected, answer tool calls
+       * over HTTP, and still be invisible to the agent we spawn: no Autonoma tools, and
+       * nothing on screen saying why.
+       *
+       * Best effort by design. It reaches into another tool's internal state, so a missing
+       * file, a changed format or an unwritable home degrades to a debug line rather than
+       * failing a registration that is otherwise fine.
+       */
+      async forgetNeedsAuthVerdict(serverName) {
+        const configDir = this.opts.env.CLAUDE_CONFIG_DIR ?? join13(homedir5(), ".claude");
+        const cachePath = join13(configDir, CLAUDE_NEEDS_AUTH_CACHE_FILE);
+        try {
+          const parsed = JSON.parse(await readFile5(cachePath, "utf-8"));
+          if (!isRecord2(parsed) || !(serverName in parsed)) return;
+          const remaining = { ...parsed };
+          delete remaining[serverName];
+          await writeFile4(cachePath, JSON.stringify(remaining), "utf-8");
+          debugLog("Cleared a cached needs-auth verdict", { server: serverName });
+        } catch (err) {
+          debugLog("Could not clear the cached needs-auth verdict", { cachePath, err });
+        }
+      }
+      async register(spec) {
+        await this.dropRegistrationPointingElsewhere(spec);
+        if (!spec.browserSignIn) {
+          await this.addServer(spec, this.requireHeadlessToken(spec));
+          return { env: {} };
         }
+        const registered = await this.addServer(spec, void 0);
+        if (registered.includes(CLAUDE_CONNECTED_MARKER)) return { env: {} };
+        const authorizable = registered.includes(CLAUDE_AUTH_HEADER_MARKER) ? await this.clearBearerHeader(spec) : registered;
+        if (authorizable.includes(CLAUDE_CONNECTED_MARKER)) return { env: {} };
+        const authorization = await this.authorizeInteractively(spec);
+        if (authorization.via === "sign-in") return { env: {} };
+        await this.runCommand(["mcp", "remove", spec.name, "-s", "user"]);
+        await this.addServer(spec, authorization.apiToken);
+        return { env: {} };
+      }
+      /**
+       * An existing registration is only useful if it points where this run does. `mcp
+       * add` will not update one, so a registration left over from another environment
+       * would be reused in silence and the agent would work against the wrong Autonoma.
+       * Replace it rather than inherit it.
+       */
+      async dropRegistrationPointingElsewhere(spec) {
+        const existing = await this.runCommand(["mcp", "get", spec.name]);
+        if (existing.code !== 0 || existing.stdout.includes(spec.url)) return;
+        debugLog("Replacing an MCP registration that points elsewhere", { server: spec.name, url: spec.url });
+        await this.runCommand(["mcp", "remove", spec.name, "-s", "user"]);
+      }
+      /**
+       * Re-register without the bearer header, so a browser sign-in becomes possible
+       * again. Returns what `get` then reported - which may be Connected on its own, if
+       * the client still holds OAuth credentials the header had been masking.
+       */
+      async clearBearerHeader(spec) {
+        debugLog("Clearing a bearer header that would block the browser sign-in", { server: spec.name });
+        await this.runCommand(["mcp", "remove", spec.name, "-s", "user"]);
+        return await this.addServer(spec, void 0);
+      }
+      /**
+       * Add the server and confirm the client actually holds it, returning what `get`
+       * reported so the caller can also read whether it is authorized.
+       *
+       * `mcp add` exits non-zero when the server is already registered, which is the
+       * normal case on every run after the first, so its exit code is a hint and `get`
+       * is the verdict.
+       *
+       * `--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.
+       */
+      async addServer(spec, apiToken) {
+        const add = ["mcp", "add", "--transport", "http", "--scope", "user", spec.name, spec.url];
+        if (apiToken != null) add.push("--header", `Authorization: Bearer ${apiToken}`);
         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"}`
+            `Could not register the ${spec.name} MCP server with ${this.label}: ${describeCommandFailure(registered, this.label)}`
           );
         }
-        if (spec.apiToken == null && !registered.stdout.includes(CLAUDE_CONNECTED_MARKER)) {
-          await this.signIn(spec.name);
-        }
-        return { env: {} };
+        return registered.stdout;
       }
     };
     CodexLauncher = class extends BaseLauncher {
@@ -5572,19 +5957,53 @@ var init_coding_agent = __esm({
        * server overwrites its entry, so a re-run cannot leave a stale URL behind.
        */
       async registerMcpServer(spec) {
+        if (!spec.browserSignIn) {
+          const apiToken = this.requireHeadlessToken(spec);
+          await this.addServer(spec, apiToken);
+          return { env: { [CODEX_BEARER_TOKEN_ENV]: apiToken } };
+        }
+        const signIn = await this.addServerAndSignIn(spec);
+        if (signIn.ok) return { env: {} };
+        const authorization = this.fallBackToToken(spec, signIn);
+        await this.addServer(spec, authorization.apiToken);
+        return { env: { [CODEX_BEARER_TOKEN_ENV]: authorization.apiToken } };
+      }
+      /**
+       * Register the server the interactive way, which for Codex is one step rather than
+       * two: given a `--url` and no bearer token, `codex mcp add` detects the server's
+       * OAuth support, prints an authorization URL, opens a browser and waits on the
+       * callback - all inside the add.
+       *
+       * Two consequences. It needs the terminal: run through a pipe, the URL it tells the
+       * user to "copy above manually" when the browser fails to open goes into a buffer
+       * nobody reads, turning a recoverable prompt into a dead end. And a clean exit means
+       * the server is registered AND signed in, so following it with `mcp login` would
+       * only open a second browser flow for a session that is already authorized.
+       */
+      async addServerAndSignIn(spec) {
+        if (process.stdin.isTTY !== true) {
+          return { ok: false, detail: " (no terminal to run a browser sign-in from)", clientUnusable: false };
+        }
+        log.info(`Authorizing ${this.label} with Autonoma - approve it in the browser that opens.`);
+        const added = await this.runAttached(["mcp", "add", spec.name, "--url", spec.url]);
+        if (added.code === 0) return { ok: true, detail: "", clientUnusable: false };
+        debugLog(`${this.label} registration sign-in failed`, { code: added.code, stderr: added.stderr });
+        return {
+          ok: false,
+          detail: describeSignInFailure(added, this.label),
+          clientUnusable: isClientNotExecutable(added.stderr)
+        };
+      }
+      /** Add (or overwrite) the server, with the token read from an env var by name. */
+      async addServer(spec, apiToken) {
         const add = ["mcp", "add", spec.name, "--url", spec.url];
-        if (spec.apiToken != null) add.push("--bearer-token-env-var", CODEX_BEARER_TOKEN_ENV);
+        if (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"}`
+            `Could not register the ${spec.name} MCP server with ${this.label}: ${describeCommandFailure(added, this.label)}`
           );
         }
-        if (spec.apiToken == null) {
-          await this.signIn(spec.name);
-          return { env: {} };
-        }
-        return { env: { [CODEX_BEARER_TOKEN_ENV]: spec.apiToken } };
       }
     };
   }
@@ -6261,7 +6680,7 @@ var init_permission_mode = __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}`;
+  return interactive ? `${instruction}.${BRANCH_GUIDANCE}` : `${instruction}.${BRANCH_GUIDANCE}${HEADLESS_GUIDANCE}`;
 }
 async function runPreviewPhase(deps) {
   const timing = deps.timing ?? DEFAULT_PHASE_TIMING;
@@ -6269,7 +6688,8 @@ async function runPreviewPhase(deps) {
   const registration = await deps.launcher.registerMcpServer({
     name: MCP_SERVER_NAME,
     url: deps.mcpUrl,
-    apiToken: deps.apiToken
+    apiToken: deps.apiToken,
+    browserSignIn: deps.interactive
   });
   const code = await deps.client.createAgentPairing(deps.applicationId);
   captureLog("info", "Handing the preview environment to a coding agent", {
@@ -6329,11 +6749,12 @@ async function readVerifiedState(client, applicationId) {
   });
   return client.getOnboardingState(applicationId);
 }
-var MCP_SERVER_NAME, PHASE_POLL_MS, PHASE_EXIT_GRACE_MS, KILL_ESCALATION_MS, DEFAULT_PHASE_TIMING, HEADLESS_GUIDANCE;
+var MCP_SERVER_NAME, PHASE_POLL_MS, PHASE_EXIT_GRACE_MS, KILL_ESCALATION_MS, DEFAULT_PHASE_TIMING, HEADLESS_GUIDANCE, BRANCH_GUIDANCE;
 var init_preview_phase = __esm({
   "src/core/preview-phase.ts"() {
     "use strict";
     init_esm_shims();
+    init_src();
     init_prompts();
     init_debug();
     init_logs();
@@ -6348,6 +6769,7 @@ var init_preview_phase = __esm({
       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.";
+    BRANCH_GUIDANCE = ` Before you change any file: if you are not already on the \`${INTEGRATION_BRANCH}\` branch, create it off the repo's default branch and switch to it now - read the default branch from the remote (\`git symbolic-ref refs/remotes/origin/HEAD\`) rather than assuming it is called main, and never commit onto it. If the working tree already has uncommitted changes they are the developer's: branch off the current HEAD instead and keep them out of your commits. Push the branch before you name it to Autonoma.`;
   }
 });
 
@@ -6367,7 +6789,8 @@ async function runSdkRepairPhase(deps) {
   const registration = await deps.launcher.registerMcpServer({
     name: MCP_SERVER_NAME,
     url: deps.mcpUrl,
-    apiToken: deps.apiToken
+    apiToken: deps.apiToken,
+    browserSignIn: deps.interactive
   });
   const code = await deps.client.createAgentPairing(deps.applicationId);
   captureLog("info", "Handing the SDK and dry run to a coding agent", {
@@ -6489,7 +6912,7 @@ async function runPreviewHandoff(deps) {
       applicationId: plan.applicationId,
       launcher,
       permissionMode,
-      apiToken: interactive ? void 0 : config.autonomaApiToken,
+      apiToken: config.autonomaApiToken,
       mcpUrl: resolveMcpUrl(config.autonomaApiUrl),
       interactive
     });
@@ -6533,7 +6956,7 @@ async function runSdkRepairHandoff(deps) {
       applicationId: plan.applicationId,
       launcher,
       permissionMode,
-      apiToken: interactive ? void 0 : config.autonomaApiToken,
+      apiToken: config.autonomaApiToken,
       mcpUrl: resolveMcpUrl(config.autonomaApiUrl),
       interactive
     });
@@ -6619,16 +7042,16 @@ var init_notify = __esm({
 });
 
 // src/core/project-map.ts
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { join as join14 } from "path";
-import { z as z35 } from "zod";
+import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { join as join15 } from "path";
+import { z as z36 } from "zod";
 async function saveProjectMap(outputDir, map) {
-  await writeFile5(join14(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
+  await writeFile6(join15(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
 }
 async function loadProjectMap(outputDir) {
-  const path3 = join14(outputDir, PROJECT_MAP_FILE);
+  const path3 = join15(outputDir, PROJECT_MAP_FILE);
   try {
-    const raw = await readFile6(path3, "utf-8");
+    const raw = await readFile7(path3, "utf-8");
     const parsed = ProjectMapSchema.safeParse(JSON.parse(raw));
     if (parsed.success) return parsed.data;
     debugLog("project-map.json failed schema validation, ignoring it", { path: path3, issues: parsed.error.issues });
@@ -6730,34 +7153,34 @@ var init_project_map = __esm({
     "use strict";
     init_esm_shims();
     init_debug();
-    FrontendEntry = z35.object({
-      path: z35.string().min(1).describe("Repo-relative path to the frontend app/directory (the UI surface)."),
-      framework: z35.string().describe("Detected UI framework/stack, or 'unknown' if not obvious (e.g. next, react, vue, svelte)."),
-      dependsOn: z35.array(z35.string()).describe(
+    FrontendEntry = z36.object({
+      path: z36.string().min(1).describe("Repo-relative path to the frontend app/directory (the UI surface)."),
+      framework: z36.string().describe("Detected UI framework/stack, or 'unknown' if not obvious (e.g. next, react, vue, svelte)."),
+      dependsOn: z36.array(z36.string()).describe(
         "Repo-relative paths (each matching a backend in this map) that THIS frontend needs in order to function - the API/service(s) it calls and the data layer(s) that own the records it renders. These are pre-selected when the user picks this frontend, so only list backends this frontend actually depends on. Empty if it needs none."
       ),
-      why: z35.string().min(1).describe("One line: the evidence that made you classify this as a frontend.")
+      why: z36.string().min(1).describe("One line: the evidence that made you classify this as a frontend.")
     });
-    BackendEntry = z35.object({
-      path: z35.string().min(1).describe("Repo-relative path to the backend/API/service or the package that owns the data layer."),
-      language: z35.string().describe("Primary language, or 'unknown' (e.g. typescript, python, go, rust)."),
-      framework: z35.string().describe("Web/service framework or ORM stack, or 'unknown' (e.g. express, hono, fastapi, rails)."),
-      dataLayer: z35.object({
-        kind: z35.string().describe("How models are defined (e.g. prisma, drizzle, sqlalchemy, typeorm, raw-sql, unknown)."),
-        schemaPath: z35.string().optional().describe("Repo-relative path to the schema/models definition, if found.")
+    BackendEntry = z36.object({
+      path: z36.string().min(1).describe("Repo-relative path to the backend/API/service or the package that owns the data layer."),
+      language: z36.string().describe("Primary language, or 'unknown' (e.g. typescript, python, go, rust)."),
+      framework: z36.string().describe("Web/service framework or ORM stack, or 'unknown' (e.g. express, hono, fastapi, rails)."),
+      dataLayer: z36.object({
+        kind: z36.string().describe("How models are defined (e.g. prisma, drizzle, sqlalchemy, typeorm, raw-sql, unknown)."),
+        schemaPath: z36.string().optional().describe("Repo-relative path to the schema/models definition, if found.")
       }).optional().describe("Where this backend's database models live. Omit if this backend owns no data layer."),
-      why: z35.string().min(1).describe("One line: the evidence that made you classify this as a backend.")
+      why: z36.string().min(1).describe("One line: the evidence that made you classify this as a backend.")
     });
-    IgnoreEntry = z35.object({
-      path: z35.string().min(1).describe("Repo-relative path to a directory that is NOT relevant to testing this app."),
-      why: z35.string().min(1).describe("One line: why it is irrelevant (e.g. docs site, infra, tooling, examples, unrelated app).")
+    IgnoreEntry = z36.object({
+      path: z36.string().min(1).describe("Repo-relative path to a directory that is NOT relevant to testing this app."),
+      why: z36.string().min(1).describe("One line: why it is irrelevant (e.g. docs site, infra, tooling, examples, unrelated app).")
     });
-    ProjectMapSchema = z35.object({
-      frontends: z35.array(FrontendEntry).describe("The UI surface(s) whose pages/flows get tested. Usually 1; may be more."),
-      backends: z35.array(BackendEntry).describe(
+    ProjectMapSchema = z36.object({
+      frontends: z36.array(FrontendEntry).describe("The UI surface(s) whose pages/flows get tested. Usually 1; may be more."),
+      backends: z36.array(BackendEntry).describe(
         "The API/service(s) and data layer(s) that own the models we seed. May be 0 (frontend-only), 1, or many."
       ),
-      ignore: z35.array(IgnoreEntry).describe("Directories judged irrelevant to this app's tests, so later steps skip them.")
+      ignore: z36.array(IgnoreEntry).describe("Directories judged irrelevant to this app's tests, so later steps skip them.")
     });
     PROJECT_MAP_FILE = "project-map.json";
   }
@@ -6768,11 +7191,11 @@ var parse_entity_audit_exports = {};
 __export(parse_entity_audit_exports, {
   parseEntityNames: () => parseEntityNames
 });
-import { readFile as readFile8 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join17 } from "path";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile8(join16(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile9(join17(outputDir, "entity-audit.md"), "utf-8");
     const names = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^\s+-\s+name:\s+(.+)$/);
@@ -6807,7 +7230,7 @@ var init_count_generated_tests = __esm({
 });
 
 // src/core/display.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function formatArgs(input, keys) {
   const parts = [];
   for (const key of keys) {
@@ -6899,7 +7322,7 @@ function logToStore(store, agentId, info, stats) {
       const folder = String(tc.input.folder ?? "");
       const filename = String(tc.input.filename ?? "");
       if (folder && filename) {
-        store.noteWrite(join17(TESTS_DIR, folder, normalizeTestFilename(filename)));
+        store.noteWrite(join18(TESTS_DIR, folder, normalizeTestFilename(filename)));
       }
     }
     if (tc.name === "bash") {
@@ -7207,8 +7630,8 @@ var init_agent = __esm({
 });
 
 // src/core/gitignore.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join18, relative as relative2 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join19, relative as relative2 } from "path";
 import { glob as glob2 } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -7228,10 +7651,10 @@ async function loadGitignorePatterns(projectRoot) {
   ];
   const matches = await glob2("**/.gitignore", { cwd: projectRoot, dot: true });
   for (const match of matches) {
-    const fullPath = join18(projectRoot, match);
+    const fullPath = join19(projectRoot, match);
     try {
-      const content = await readFile9(fullPath, "utf-8");
-      const prefix = relative2(projectRoot, join18(projectRoot, match, ".."));
+      const content = await readFile10(fullPath, "utf-8");
+      const prefix = relative2(projectRoot, join19(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -7294,7 +7717,7 @@ var init_exec_error = __esm({
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { tool } from "ai";
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 function validateCommand(command, allowed) {
   const trimmed = command.trim();
   if (trimmed.length === 0) return "Empty command";
@@ -7360,8 +7783,8 @@ var init_bash = __esm({
     DEFAULT_ALLOWED = /* @__PURE__ */ new Set(["git", "wc", "sort", "head", "tail", "cat", "ls", "find", "diff", "echo"]);
     TIMEOUT_MS = 3e4;
     MAX_OUTPUT_BYTES = 1024 * 512;
-    inputSchema = z36.object({
-      command: z36.string().describe("Shell command to execute")
+    inputSchema = z37.object({
+      command: z37.string().describe("Shell command to execute")
     });
   }
 });
@@ -7369,7 +7792,7 @@ var init_bash = __esm({
 // src/tools/glob.ts
 import { tool as tool2 } from "ai";
 import { glob as glob3 } from "glob";
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 async function executeGlob(pattern, cwd, ignorePatterns = DEFAULT_IGNORE) {
   try {
     const matches = await glob3(pattern, {
@@ -7403,9 +7826,9 @@ var init_glob = __esm({
   "src/tools/glob.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema2 = z37.object({
-      pattern: z37.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
-      cwd: z37.string().optional().describe("Directory to search in. Defaults to working directory.")
+    inputSchema2 = z38.object({
+      pattern: z38.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
+      cwd: z38.string().optional().describe("Directory to search in. Defaults to working directory.")
     });
     DEFAULT_IGNORE = [
       "**/node_modules/**",
@@ -7423,7 +7846,7 @@ var init_glob = __esm({
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { tool as tool3 } from "ai";
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 function buildGrepTool(workingDirectory) {
   return tool3({
     description: "Search file contents with ripgrep. Returns matching lines with file paths and line numbers.",
@@ -7467,10 +7890,10 @@ var init_grep = __esm({
     init_esm_shims();
     init_exec_error();
     execFileAsync3 = promisify3(execFile4);
-    inputSchema3 = z38.object({
-      pattern: z38.string().describe("Regex pattern to search for in file contents"),
-      glob: z38.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
-      path: z38.string().optional().describe("File or directory to search in")
+    inputSchema3 = z39.object({
+      pattern: z39.string().describe("Regex pattern to search for in file contents"),
+      glob: z39.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
+      path: z39.string().optional().describe("File or directory to search in")
     });
   }
 });
@@ -7478,10 +7901,10 @@ var init_grep = __esm({
 // src/tools/list-directory.ts
 import { readdir } from "fs/promises";
 import { stat } from "fs/promises";
-import { join as join19, relative as relative3 } from "path";
+import { join as join20, relative as relative3 } from "path";
 import { tool as tool4 } from "ai";
 import { minimatch } from "minimatch";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function buildMatcher(patterns) {
   const positive = patterns.filter((p) => !p.startsWith("!"));
   const negative = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
@@ -7503,7 +7926,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
   const withTypes = [];
   for (const name of rawEntries) {
     try {
-      const s = await stat(join19(dirPath, name));
+      const s = await stat(join20(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -7523,7 +7946,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join19(dirPath, entry.name),
+        join20(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -7561,10 +7984,10 @@ async function buildListDirectoryTool(workingDirectory) {
   const isIgnored = buildMatcher(patterns);
   return tool4({
     description: "List directory structure as a tree. Use this for an overview of the project layout. Start at the root (path='.') with depth 3, then increase depth or narrow path if needed. Do NOT call this on every subdirectory - use glob to find specific files instead. Returns cached result if the same path+depth was already requested.",
-    inputSchema: z39.object({
-      path: z39.string().default(".").describe("Directory path relative to project root. Defaults to root."),
-      depth: z39.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
-      gitignore: z39.boolean().describe(
+    inputSchema: z40.object({
+      path: z40.string().default(".").describe("Directory path relative to project root. Defaults to root."),
+      depth: z40.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
+      gitignore: z40.boolean().describe(
         "Whether to respect the gitignore or to ignore it. true will respect it. false will ignore it. Default true"
       ).default(true)
     }),
@@ -7576,7 +7999,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join19(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join20(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -7612,10 +8035,10 @@ var init_list_directory = __esm({
 });
 
 // src/tools/read-file.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { relative as relative4, resolve as resolve2 } from "path";
 import { tool as tool5 } from "ai";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 function resolveSandboxedPath(workingDirectory, filePath) {
   const absolutePath = resolve2(workingDirectory, filePath);
   const relativePath = relative4(workingDirectory, absolutePath);
@@ -7640,7 +8063,7 @@ async function executeReadFile(workingDirectory, filePath, offset, limit) {
   const resolved2 = resolveSandboxedPath(workingDirectory, filePath);
   if ("error" in resolved2) return resolved2;
   try {
-    const content = await readFile10(resolved2.absolutePath, "utf-8");
+    const content = await readFile11(resolved2.absolutePath, "utf-8");
     const sliced = sliceLines(content, offset ?? 0, limit ?? MAX_LINES);
     if (sliced.numbered.length > MAX_OUTPUT_BYTES2) {
       sliced.numbered = sliced.numbered.slice(0, MAX_OUTPUT_BYTES2) + `
@@ -7673,10 +8096,10 @@ var init_read_file = __esm({
     init_esm_shims();
     MAX_LINES = 2e3;
     MAX_OUTPUT_BYTES2 = 256 * 1024;
-    inputSchema4 = z40.object({
-      filePath: z40.string().describe("Path to the file (absolute or relative to working directory)"),
-      offset: z40.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
-      limit: z40.number().int().min(1).optional().describe("Maximum number of lines to read")
+    inputSchema4 = z41.object({
+      filePath: z41.string().describe("Path to the file (absolute or relative to working directory)"),
+      offset: z41.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
+      limit: z41.number().int().min(1).optional().describe("Maximum number of lines to read")
     });
   }
 });
@@ -7699,10 +8122,10 @@ var init_pick_string = __esm({
 
 // src/tools/subagent.ts
 import { ToolLoopAgent as ToolLoopAgent2, hasToolCall as hasToolCall2, stepCountIs as stepCountIs2, tool as tool6 } from "ai";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 function buildSubagentTools(workingDirectory, onFileRead) {
   const baseReadFile = buildReadFileTool(workingDirectory);
-  const readFile26 = onFileRead ? tool6({
+  const readFile27 = onFileRead ? tool6({
     description: baseReadFile.description,
     inputSchema: baseReadFile.inputSchema,
     execute: async (input, options) => {
@@ -7715,7 +8138,7 @@ function buildSubagentTools(workingDirectory, onFileRead) {
     bash: buildBashTool(workingDirectory),
     glob: buildGlobTool(workingDirectory),
     grep: buildGrepTool(workingDirectory),
-    read_file: readFile26
+    read_file: readFile27
   };
 }
 function buildSubagentTool(model, workingDirectory, onHeartbeat, onFileRead) {
@@ -7772,11 +8195,11 @@ var init_subagent = __esm({
     init_glob();
     init_grep();
     init_read_file();
-    inputSchema5 = z41.object({
-      instruction: z41.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
+    inputSchema5 = z42.object({
+      instruction: z42.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
     });
-    resultSchema = z41.object({
-      findings: z41.string().describe("Summary of what was found")
+    resultSchema = z42.object({
+      findings: z42.string().describe("Summary of what was found")
     });
     SYSTEM_PROMPT = `You are a code research assistant. You have tools to explore a codebase: bash (shell commands, mainly git), glob (find files), grep (search content), and read_file (read files).
 
@@ -7787,10 +8210,10 @@ Be thorough but focused - only investigate what's relevant to your instruction.`
 });
 
 // src/tools/write-file.ts
-import { writeFile as writeFile6, mkdir as mkdir3 } from "fs/promises";
+import { writeFile as writeFile7, mkdir as mkdir3 } from "fs/promises";
 import { dirname as dirname3, relative as relative5, resolve as resolve3 } from "path";
 import { tool as tool7 } from "ai";
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 async function executeWriteFile(outputDirectory, filePath, content) {
   const cleaned = filePath.replace(/^autonoma\//, "");
   const absolutePath = resolve3(outputDirectory, cleaned);
@@ -7800,7 +8223,7 @@ async function executeWriteFile(outputDirectory, filePath, content) {
   }
   try {
     await mkdir3(dirname3(absolutePath), { recursive: true });
-    await writeFile6(absolutePath, content, "utf-8");
+    await writeFile7(absolutePath, content, "utf-8");
     return { path: relativePath, bytesWritten: content.length };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -7819,21 +8242,21 @@ var init_write_file = __esm({
   "src/tools/write-file.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema6 = z42.object({
-      filePath: z42.string().describe("Path to write (absolute or relative to output directory)"),
-      content: z42.string().describe("File content to write")
+    inputSchema6 = z43.object({
+      filePath: z43.string().describe("Path to write (absolute or relative to output directory)"),
+      content: z43.string().describe("File content to write")
     });
   }
 });
 
 // src/tools/ask-user.ts
 import { tool as tool8 } from "ai";
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 function buildAskUserTool() {
   return tool8({
     description: "Ask the user a question ONLY when the answer is truly unknowable from the codebase. Valid reasons: untyped JSON/JSONB field schemas, business rules not in code, config values not in source. NEVER ask about: field names (read the schema), field types (read the ORM model), enum values (read the code), relationships (read foreign keys), numeric values (read the seed data or defaults). If you can find it by reading a file, DO NOT ask - read the file instead.",
-    inputSchema: z43.object({
-      question: z43.string().describe(
+    inputSchema: z44.object({
+      question: z44.string().describe(
         "A clear, plain-language question. State exactly what you need to know and why you can't find it in code. BAD: 'What are the decimal values for checking_balance?' - GOOD: 'Your Account model has a metadata JSON column with no type definition. What fields go inside it?'"
       )
     }),
@@ -7893,7 +8316,7 @@ var init_tools = __esm({
 
 // src/agents/00-project-mapper/coverage.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 async function findUncoveredDirs(projectRoot, map) {
   const entries = [...map.frontends, ...map.backends, ...map.ignore].map(
     (e) => e.path.replace(/^\.\//, "").replace(/\/+$/, "")
@@ -7917,7 +8340,7 @@ async function findUncoveredDirs(projectRoot, map) {
       const childRel = rel === "" ? child.name : `${rel}/${child.name}`;
       if (underEntry(childRel)) continue;
       if (hasEntryWithin(childRel)) {
-        if (depth + 1 < MAX_DEPTH) await walk(join20(abs, child.name), childRel, depth + 1);
+        if (depth + 1 < MAX_DEPTH) await walk(join21(abs, child.name), childRel, depth + 1);
       } else {
         out.push(childRel);
       }
@@ -7944,7 +8367,7 @@ __export(project_mapper_exports, {
   runProjectMapper: () => runProjectMapper
 });
 import { tool as tool9 } from "ai";
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 async function runProjectMapper(input) {
   const model = getModel(input.modelId);
   const { logger, onStepFinish } = buildDefaultStepLogger("project-map", MAX_STEPS);
@@ -7978,7 +8401,7 @@ First build the full inventory (workspace/package manifests + top-level director
         }),
         finish: tool9({
           description: "End this step. Call once set_project_map has recorded a complete map.",
-          inputSchema: z44.object({}),
+          inputSchema: z45.object({}),
           execute: () => {
             if (captured == null) {
               return { error: "Cannot finish: no map recorded - call set_project_map first." };
@@ -8022,7 +8445,7 @@ __export(pages_finder_exports, {
 import { existsSync } from "fs";
 import * as path2 from "path";
 import { tool as tool10 } from "ai";
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 async function runPageFinder(input) {
   const model = getModel(input.modelId);
   const pageCollector = new PageCollector();
@@ -8057,12 +8480,12 @@ ${input.extraMessage}`;
         }),
         view_pages: tool10({
           description: "use this tool to view all the pages that you already added",
-          inputSchema: z45.object(),
+          inputSchema: z46.object(),
           execute: () => pageCollector.viewPages()
         }),
         finish: tool10({
           description: "End this step. Call once every page in the codebase has been added via add_page.",
-          inputSchema: z45.object({}),
+          inputSchema: z46.object({}),
           execute: () => {
             if (pageCollector.pages.size === 0) {
               return {
@@ -8089,10 +8512,10 @@ var init_pages_finder = __esm({
     init_agent();
     init_model();
     init_tools();
-    Page = z45.object({
-      route: z45.string().min(1),
-      path: z45.string().min(1),
-      description: z45.string().min(10)
+    Page = z46.object({
+      route: z46.string().min(1),
+      path: z46.string().min(1),
+      description: z46.string().min(10)
     });
     PageCollector = class {
       // the key is the path
@@ -8288,15 +8711,15 @@ var kb_generator_exports = {};
 __export(kb_generator_exports, {
   runKBGenerator: () => runKBGenerator
 });
-import { readFile as readFile11 } from "fs/promises";
-import { join as join21, resolve as resolve5 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join22, resolve as resolve5 } from "path";
 import { tool as tool11 } from "ai";
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 function buildRegisterPagesTool(tracker) {
   return tool11({
     description: "Register ALL page/route files discovered via glob. Call this ONCE after globbing for page files. The system will track which ones you've read and block finish until all are covered.",
-    inputSchema: z46.object({
-      pages: z46.array(z46.string()).describe("All page file paths found by glob")
+    inputSchema: z47.object({
+      pages: z47.array(z47.string()).describe("All page file paths found by glob")
     }),
     execute: async (input) => {
       tracker.register(input.pages);
@@ -8310,7 +8733,7 @@ function buildRegisterPagesTool(tracker) {
 function buildPageCoverageTool(tracker) {
   return tool11({
     description: "Check how many registered pages you've read vs how many remain.",
-    inputSchema: z46.object({}),
+    inputSchema: z47.object({}),
     execute: async () => tracker.coverage()
   });
 }
@@ -8321,9 +8744,9 @@ function requiredReads(total) {
 function buildFinishTool(tracker, onFinish) {
   return tool11({
     description: "Call when you have finished generating the knowledge base. BLOCKED until you have read enough of the registered routes (every route on a small app; a strong majority on a large one) - call page_coverage first to check how many remain.",
-    inputSchema: z46.object({
-      summary: z46.string().describe("Summary of what was generated"),
-      artifacts: z46.array(z46.string()).describe("List of files written")
+    inputSchema: z47.object({
+      summary: z47.string().describe("Summary of what was generated"),
+      artifacts: z47.array(z47.string()).describe("List of files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -8402,8 +8825,8 @@ Output files:
   const agentConfig = buildKbAgentConfig(tracker, model, input, onStepFinish, setResult);
   await runAgent(agentConfig, prompt, () => result);
   logger.summary();
-  const autonomaPath = join21(input.outputDir, "AUTONOMA.md");
-  const autonomaExists = await readFile11(autonomaPath, "utf-8").then(() => true).catch((err) => {
+  const autonomaPath = join22(input.outputDir, "AUTONOMA.md");
+  const autonomaExists = await readFile12(autonomaPath, "utf-8").then(() => true).catch((err) => {
     debugLog("AUTONOMA.md not found while checking step completion", { err });
     return false;
   });
@@ -8589,17 +9012,17 @@ var entity_audit_exports = {};
 __export(entity_audit_exports, {
   runEntityAudit: () => runEntityAudit
 });
-import { readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
+import { join as join23 } from "path";
 import { tool as tool12 } from "ai";
 import { glob as glob4 } from "glob";
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 function buildRegisterModelsTool(tracker) {
   return tool12({
     description: "Register ALL database models discovered via grep. Call this ONCE after grepping for model definitions. After registering, use next_model to process them one at a time.",
-    inputSchema: z47.object({
-      models: z47.array(z47.string()).describe("All model/table names found by grep"),
-      framework: z47.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
+    inputSchema: z48.object({
+      models: z48.array(z48.string()).describe("All model/table names found by grep"),
+      framework: z48.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
     }),
     execute: async (input) => {
       tracker.register(input.models);
@@ -8615,7 +9038,7 @@ function buildRegisterModelsTool(tracker) {
 function buildNextModelTool(tracker) {
   return tool12({
     description: "Get the next model to audit from the queue. If you called next_model before without calling mark_model_audited, the previous model is auto-skipped (marked as no creation path found). Returns done:true when all models are processed.",
-    inputSchema: z47.object({}),
+    inputSchema: z48.object({}),
     execute: async () => {
       const next = tracker.nextModel();
       if (!next) {
@@ -8635,17 +9058,17 @@ function buildNextModelTool(tracker) {
 function buildMarkModelAuditedTool(tracker) {
   return tool12({
     description: "Mark a model as audited after you have determined its creation paths. Call this for EACH model after reading its creation code and determining independently_created + created_by. Include creation_function (e.g. 'UserService.create'), side_effects (list of things the creation does beyond the model itself), and for each created_by entry include owner, via (function name), and why (one sentence explaining the relationship).",
-    inputSchema: z47.object({
-      model: z47.string().describe("Model name"),
-      independently_created: z47.boolean(),
-      creation_file: z47.string().optional().describe("File containing the creation function"),
-      creation_function: z47.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
-      side_effects: z47.array(z47.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
-      created_by: z47.array(
-        z47.object({
-          owner: z47.string().describe("Owner model name"),
-          via: z47.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
-          why: z47.string().optional().describe("One sentence explaining why this model is created as a side effect")
+    inputSchema: z48.object({
+      model: z48.string().describe("Model name"),
+      independently_created: z48.boolean(),
+      creation_file: z48.string().optional().describe("File containing the creation function"),
+      creation_function: z48.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
+      side_effects: z48.array(z48.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
+      created_by: z48.array(
+        z48.object({
+          owner: z48.string().describe("Owner model name"),
+          via: z48.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
+          why: z48.string().optional().describe("One sentence explaining why this model is created as a side effect")
         })
       ).describe("List of owner models that create this as a side effect, empty array if none")
     }),
@@ -8684,16 +9107,16 @@ function buildMarkModelAuditedTool(tracker) {
 function buildModelCoverageTool(tracker) {
   return tool12({
     description: "Check how many registered models you've audited vs how many remain.",
-    inputSchema: z47.object({}),
+    inputSchema: z48.object({}),
     execute: async () => tracker.coverage()
   });
 }
 function buildFinishTool2(tracker, onFinish) {
   return tool12({
     description: "Call when entity audit is complete. BLOCKED if there are unaudited models - call model_coverage first to check.",
-    inputSchema: z47.object({
-      summary: z47.string().describe("Summary of the audit"),
-      artifacts: z47.array(z47.string()).describe("Files written")
+    inputSchema: z48.object({
+      summary: z48.string().describe("Summary of the audit"),
+      artifacts: z48.array(z48.string()).describe("Files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -8721,7 +9144,7 @@ async function findPrismaSchema(projectRoot) {
   return candidates[0] ?? void 0;
 }
 async function extractPrismaModels(schemaPath) {
-  const content = await readFile12(schemaPath, "utf-8");
+  const content = await readFile13(schemaPath, "utf-8");
   return content.split("\n").filter((line) => line.startsWith("model ")).map((line) => line.split(/\s+/)[1]).filter((name) => name != null);
 }
 async function detectFrameworkAndModels(projectRoot) {
@@ -8808,8 +9231,8 @@ ${formatException(err)}`);
   logger.summary();
   const writeCanonicalAudit = async () => {
     if (tracker.auditedModels.size === 0) return void 0;
-    const auditPath = join22(input.outputDir, "entity-audit.md");
-    await writeFile7(auditPath, tracker.generateAuditMarkdown(), "utf-8");
+    const auditPath = join23(input.outputDir, "entity-audit.md");
+    await writeFile8(auditPath, tracker.generateAuditMarkdown(), "utf-8");
     return auditPath;
   };
   const canonicalPath = await writeCanonicalAudit();
@@ -8823,9 +9246,9 @@ ${formatException(err)}`);
   }
   const reviewed = result;
   if (!reviewed) {
-    const auditPath = join22(input.outputDir, "entity-audit.md");
+    const auditPath = join23(input.outputDir, "entity-audit.md");
     try {
-      await readFile12(auditPath, "utf-8");
+      await readFile13(auditPath, "utf-8");
       return {
         success: true,
         artifacts: ["entity-audit.md"],
@@ -9029,15 +9452,37 @@ anything the database will refuse a second copy of - must embed a token INSIDE a
 otherwise real-looking value ("admin+{{${TEST_RUN_ID_TOKEN}}}@acme.test",
 "acme-{{${TEST_RUN_SHORT_ID_TOKEN}}}"), never replace the value entirely. Two tests
 run at the same time seed this scenario twice; without the token the second one fails
-on a unique constraint. Everything else stays concrete and static, and no other
-{{token}} or bare {variable} exists - inventing one is rejected.`;
+on a unique constraint. No other {{token}} or bare {variable} exists - inventing one
+is rejected.
+
+## Data the app compares against the current time
+This scenario is written once and seeded again, unchanged, before every run for as long
+as it lives. So a value the application compares against the current time is not static
+data: a record meant to be upcoming, overdue, expiring soon, still valid, or recent is a
+fact about WHEN THE TEST RUNS. Written as a calendar date it is right on the day you
+write it and quietly wrong ever after, and the failure it causes reads as a broken
+product rather than as stale data.
+
+For every date or time you write, ask one question: does the app branch on this being
+before or after now? Look for the answer in its queries - a list split into current and
+past, a filter against an expiry, a state derived from a deadline. Do not guess from the
+field name.
+
+Where the answer is yes, write the value as an offset from the moment of seeding
+("starts 3 days after seeding, at 10:00", "ended 2 weeks before seeding") rather than a
+date. Where it is no - a recurring weekly schedule, a date of birth, a timestamp nothing
+filters on - a concrete date is correct and an offset would only obscure it.
+
+An offset is prose in your table, not a token: there is no {{token}} for time, and
+inventing one is rejected like any other. The recipe builder turns what you write into a
+value its factories compute at seeding time.`;
   }
 });
 
 // src/agents/03-scenario-recipe/scenario-table.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join23 } from "path";
-import matter2 from "gray-matter";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join24 } from "path";
+import matter2 from "@11ty/gray-matter";
 function validateScenarioIsConcrete(content) {
   const errors = findUnknownRecipeTokens(content).map(
     (token) => `unknown token "{{${token}}}" - scenario values must be concrete. Replace it with the exact static value; the only tokens Autonoma substitutes are ${BUILT_IN_RECIPE_TOKEN_LIST}.`
@@ -9071,22 +9516,22 @@ __export(scenario_recipe_exports, {
   feedbackToScenario: () => feedbackToScenario,
   runScenarioRecipe: () => runScenarioRecipe
 });
-import { readFile as readFile14 } from "fs/promises";
-import { join as join24 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join25 } from "path";
 import { tool as tool13 } from "ai";
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 function buildFinishTool3(requiredEntities, outputDir, onFinish) {
   return tool13({
     description: "Call when scenario design is complete and scenarios.md is written. BLOCKED if any required entities are missing from the scenario.",
-    inputSchema: z48.object({
-      summary: z48.string().describe("Summary of the scenario"),
-      entityCount: z48.number().describe("Number of entity types in the scenario"),
-      artifacts: z48.array(z48.string()).describe("Files written")
+    inputSchema: z49.object({
+      summary: z49.string().describe("Summary of the scenario"),
+      entityCount: z49.number().describe("Number of entity types in the scenario"),
+      artifacts: z49.array(z49.string()).describe("Files written")
     }),
     execute: async (input) => {
       let content;
       try {
-        content = await readFile14(join24(outputDir, "scenarios.md"), "utf-8");
+        content = await readFile15(join25(outputDir, "scenarios.md"), "utf-8");
       } catch {
         return { error: "Cannot finish: scenarios.md not found. Write it first." };
       }
@@ -9165,9 +9610,9 @@ When done, call finish.`;
   logger.summary();
   const reviewed = result;
   if (!reviewed) {
-    const scenariosPath = join24(input.outputDir, "scenarios.md");
+    const scenariosPath = join25(input.outputDir, "scenarios.md");
     try {
-      await readFile14(scenariosPath, "utf-8");
+      await readFile15(scenariosPath, "utf-8");
       return {
         success: true,
         artifacts: ["scenarios.md"],
@@ -9226,12 +9671,12 @@ var init_scenario_recipe = __esm({
 });
 
 // src/agents/04-recipe-builder/entity-order.ts
-import { readFile as readFile15 } from "fs/promises";
-import { join as join25 } from "path";
-import matter3 from "gray-matter";
-import { z as z49 } from "zod";
+import { readFile as readFile16 } from "fs/promises";
+import { join as join26 } from "path";
+import matter3 from "@11ty/gray-matter";
+import { z as z50 } from "zod";
 async function parseEntityAudit(outputDir) {
-  const raw = await readFile15(join25(outputDir, "entity-audit.md"), "utf-8");
+  const raw = await readFile16(join26(outputDir, "entity-audit.md"), "utf-8");
   try {
     const parsed = frontmatterSchema.safeParse(matter3(raw).data);
     if (parsed.success && parsed.data.models.length > 0) {
@@ -9392,34 +9837,34 @@ var init_entity_order = __esm({
   "src/agents/04-recipe-builder/entity-order.ts"() {
     "use strict";
     init_esm_shims();
-    createdBySchema = z49.object({
-      owner: z49.string(),
-      via: z49.string().optional(),
-      why: z49.string().optional()
+    createdBySchema = z50.object({
+      owner: z50.string(),
+      via: z50.string().optional(),
+      why: z50.string().optional()
     });
-    auditedModelSchema = z49.object({
-      name: z49.string(),
-      independently_created: z49.coerce.boolean().default(false),
-      creation_file: z49.string().optional(),
-      creation_function: z49.string().optional(),
-      side_effects: z49.array(z49.string()).optional(),
+    auditedModelSchema = z50.object({
+      name: z50.string(),
+      independently_created: z50.coerce.boolean().default(false),
+      creation_file: z50.string().optional(),
+      creation_function: z50.string().optional(),
+      side_effects: z50.array(z50.string()).optional(),
       // Tolerate a stray `created_by:` with no entries (parsed as null by YAML).
-      created_by: z49.array(createdBySchema).nullish().transform((v) => v ?? [])
+      created_by: z50.array(createdBySchema).nullish().transform((v) => v ?? [])
     });
-    frontmatterSchema = z49.object({
-      models: z49.array(auditedModelSchema).nullish().transform((v) => v ?? [])
+    frontmatterSchema = z50.object({
+      models: z50.array(auditedModelSchema).nullish().transform((v) => v ?? [])
     });
   }
 });
 
 // src/agents/04-recipe-builder/completion.ts
-import { readFile as readFile16 } from "fs/promises";
-import { join as join26 } from "path";
-import { z as z50 } from "zod";
+import { readFile as readFile17 } from "fs/promises";
+import { join as join27 } from "path";
+import { z as z51 } from "zod";
 async function readCompletion(outputDir) {
   let raw;
   try {
-    raw = await readFile16(join26(outputDir, COMPLETION_MARKER_FILE), "utf-8");
+    raw = await readFile17(join27(outputDir, COMPLETION_MARKER_FILE), "utf-8");
   } catch (err) {
     debugLog("No completion marker yet", { err });
     return false;
@@ -9445,7 +9890,7 @@ var init_completion = __esm({
     init_esm_shims();
     init_debug();
     COMPLETION_MARKER_FILE = ".sdk-integration-complete";
-    completionSchema = z50.object({ complete: z50.literal(true) });
+    completionSchema = z51.object({ complete: z51.literal(true) });
   }
 });
 
@@ -9453,9 +9898,10 @@ var init_completion = __esm({
 function watchForCompletion(outputDir, proc, timing = DEFAULT_WATCH_TIMING) {
   let graceTimer;
   let killTimer;
+  let stopped = false;
   const poll = setInterval(() => {
     void readCompletion(outputDir).then((complete) => {
-      if (!complete || graceTimer != null) return;
+      if (stopped || !complete || graceTimer != null) return;
       debugLog("Completion marker detected while the agent runs; scheduling terminal reclaim");
       clearInterval(poll);
       graceTimer = setTimeout(() => {
@@ -9469,6 +9915,7 @@ function watchForCompletion(outputDir, proc, timing = DEFAULT_WATCH_TIMING) {
     });
   }, timing.pollMs);
   return () => {
+    stopped = true;
     clearInterval(poll);
     if (graceTimer != null) clearTimeout(graceTimer);
     if (killTimer != null) clearTimeout(killTimer);
@@ -9493,8 +9940,8 @@ var init_completion_watch = __esm({
 });
 
 // src/agents/04-recipe-builder/integration-prompt.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import { join as join27 } from "path";
+import { writeFile as writeFile9 } from "fs/promises";
+import { join as join28 } from "path";
 function renderIntegrationPrompt(params) {
   const priorFailureSection = params.priorFailure != null ? `
 \u2550\u2550\u2550 A PRIOR SESSION DID NOT COMPLETE - READ THIS FIRST \u2550\u2550\u2550
@@ -9577,7 +10024,10 @@ STOP immediately and say EXACTLY what is missing and why you can't proceed.
    JavaScript/npm package.
 2. Implement ONE endpoint (prefer "${DEFAULT_ENDPOINT_PATH}" unless the repo has a
    clearly better convention) that handles the discover / up / down protocol through
-   the SDK handler. The signing secret AUTONOMA_SHARED_SECRET is ALREADY provisioned
+   the SDK handler. If you mount it anywhere OTHER than "${DEFAULT_ENDPOINT_PATH}",
+   say so on its own line in IMPLEMENTATION.md, exactly as
+   "SDK endpoint path: /your/path" - Autonoma assumes the default and the next step
+   of the setup has to be told the real one, or every scenario provision 404s. The signing secret AUTONOMA_SHARED_SECRET is ALREADY provisioned
    in the app's environment - verify the x-signature HMAC against that env value (the
    SDK reads it for you). Do NOT hardcode a secret or overwrite the env value.
 3. Implement a real factory for EVERY entity the entity audit says needs one:
@@ -9652,6 +10102,35 @@ value still reads as real: "admin+{{${TEST_RUN_ID_TOKEN}}}@acme.test", "acme-{{$
 Any OTHER {{token}} is rejected on upload: there is no general variable mechanism, so
 never invent one.
 
+\u2550\u2550\u2550 DATA THE APP COMPARES AGAINST THE CURRENT TIME \u2550\u2550\u2550
+Autonoma stores this recipe once and seeds it again, UNCHANGED, before every run for
+months. So a value the application compares against the current time is wrong the day
+after you write it. A row meant to be upcoming, overdue, expiring soon, still valid, or
+recent describes WHEN THE TEST RUNS, not a date on a calendar - and when it goes stale
+the suite fails in a way that reads as a product bug rather than as stale data. A seeded
+session or credential that has drifted past its expiry breaks every test at once.
+
+For every date/time field you seed, ask one question: does the app branch on this being
+before or after now? Find the answer in the app's own queries - a list partitioned into
+current and past, a filter against an expiry, a state derived from a deadline. Do not
+guess from the field name.
+
+Where the answer is YES, do not put an instant in the recipe. Take an OFFSET as the
+factory's input, and have the factory add it to the current time as it creates the row -
+the factory runs at seeding time, so its clock is the right one:
+    recipe:  { "startsInMinutes": 4320, "durationMinutes": 30 }
+    factory: reads startsInMinutes, writes the column as (now + 4320 minutes)
+A factory's input schema is YOUR interface and does not have to mirror its columns -
+converting an input into the column's real shape inside the factory is normal, and is
+how a factory already handles any column whose stored form differs from its input. Anchor
+or round the derived value when the app only accepts particular times.
+
+Where the answer is NO - a recurring weekly schedule, a date of birth, a timestamp
+nothing filters on - a concrete value is correct and an offset would only obscure it.
+
+There is no {{token}} for time. Do not invent one: it is rejected on upload exactly like
+any other unknown token, and the derivation belongs in the factory anyway.
+
 WHICH fields need a token is not a judgement call and not a guess from the field name.
 Before you write the recipe, ENUMERATE the uniqueness rules for every entity you seed:
 read the schema definitions and migrations, and query the live database you are already
@@ -9715,6 +10194,11 @@ Once every entity passes independently, run the FULL recipe as one pass:
   \u2022 confirm all rows created (DB), then down with the refsToken -> succeeds, rows gone (DB)
   \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
+  \u2022 for every field you identified as compared against the current time, confirm the
+    seeded row landed on the INTENDED side of now - run the app's own query or open the
+    screen that partitions by time, and see the row where it is supposed to be. A row
+    that exists in the right table but falls on the wrong side of now is the failure this
+    check exists to catch, and "up returned 200" will not reveal it.
 
 \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
@@ -9783,7 +10267,7 @@ Write the completion marker once ALL of these hold:
 A step you documented as genuinely blocked NEVER justifies withholding the marker; a
 checklist item you simply have not finished always does. The marker is how the CLI knows
 the session is done and can upload the recipe:
-    ${join27(params.outputDir, COMPLETION_MARKER_FILE)}
+    ${join28(params.outputDir, COMPLETION_MARKER_FILE)}
 Its contents MUST be exactly:
     { "complete": true }
 Writing it is not optional: the planner watches for this marker and takes the terminal
@@ -9795,27 +10279,45 @@ or the commit you left behind and what blocked the push - and then says:
 Nothing after that message - no further questions, summaries, or work.`;
 }
 async function writeIntegrationPrompt(params) {
-  const path3 = join27(params.outputDir, INTEGRATION_PROMPT_FILE);
-  await writeFile8(path3, renderIntegrationPrompt(params), "utf-8");
+  const path3 = join28(params.outputDir, INTEGRATION_PROMPT_FILE);
+  await writeFile9(path3, renderIntegrationPrompt(params), "utf-8");
   return path3;
 }
-var INTEGRATION_PROMPT_VERSION, INTEGRATION_PROMPT_FILE, DEFAULT_ENDPOINT_PATH, INTEGRATION_BRANCH;
+var INTEGRATION_PROMPT_VERSION, INTEGRATION_PROMPT_FILE, DEFAULT_ENDPOINT_PATH;
 var init_integration_prompt = __esm({
   "src/agents/04-recipe-builder/integration-prompt.ts"() {
     "use strict";
     init_esm_shims();
     init_src();
     init_completion();
-    INTEGRATION_PROMPT_VERSION = 10;
+    INTEGRATION_PROMPT_VERSION = 11;
     INTEGRATION_PROMPT_FILE = "integration-prompt.md";
     DEFAULT_ENDPOINT_PATH = "/api/autonoma";
-    INTEGRATION_BRANCH = "autonoma-integration";
+  }
+});
+
+// src/agents/04-recipe-builder/launch-outcome.ts
+function describeLaunchOutcome(launch) {
+  const ranTooBriefly = launch.durationMs < FAILED_TO_START_MS;
+  const exitedBadly = launch.exitCode != null && launch.exitCode !== 0;
+  if (!ranTooBriefly || !exitedBadly) return { kind: "ran" };
+  return {
+    kind: "failed-to-start",
+    summary: `${launch.agentLabel} exited immediately (code ${launch.exitCode}, after ${Math.round(launch.durationMs / 1e3)}s) without running the integration. That is the agent itself failing to start, not the integration failing - check that it runs on its own in this terminal.`
+  };
+}
+var FAILED_TO_START_MS;
+var init_launch_outcome = __esm({
+  "src/agents/04-recipe-builder/launch-outcome.ts"() {
+    "use strict";
+    init_esm_shims();
+    FAILED_TO_START_MS = 9e4;
   }
 });
 
 // src/agents/04-recipe-builder/state.ts
-import { readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
-import { join as join28 } from "path";
+import { readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
+import { join as join29 } from "path";
 function initialRecipeState() {
   return {
     phase: "tech-detect",
@@ -9825,7 +10327,7 @@ function initialRecipeState() {
 }
 async function loadRecipeState(outputDir) {
   try {
-    const raw = await readFile17(join28(outputDir, STATE_FILE2), "utf-8");
+    const raw = await readFile18(join29(outputDir, STATE_FILE2), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -9833,7 +10335,7 @@ async function loadRecipeState(outputDir) {
   }
 }
 async function saveRecipeState(outputDir, state) {
-  await writeFile9(join28(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
+  await writeFile10(join29(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
 }
 var STATE_FILE2;
 var init_state2 = __esm({
@@ -9846,12 +10348,12 @@ var init_state2 = __esm({
 
 // src/agents/04-recipe-builder/phases/handoff.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join30 } 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 ?? join29(outputDir, RECIPE_FILE);
+  const recipePath = state.recipePath ?? join30(outputDir, RECIPE_FILE);
   state.recipePath = recipePath;
   const launcher = await selectLauncher(deps.launchers, state.agentId ?? deps.presetAgentId, deps.interactive);
   if (launcher == null) {
@@ -9868,7 +10370,7 @@ async function runHandoffPhase(state, deps, outputDir) {
   state.agentId = launcher.id;
   state.permissionMode = permissionMode;
   await saveRecipeState(outputDir, state);
-  await launchAgent(launcher, permissionMode, {
+  state.lastLaunch = await launchAgent(launcher, permissionMode, {
     outputDir,
     recipePath,
     cliCommand: deps.cliCommand,
@@ -9881,7 +10383,7 @@ async function runHandoffPhase(state, deps, outputDir) {
   return { kind: "advance" };
 }
 async function runCompletionPhase(state, deps, outputDir) {
-  const recipePath = state.recipePath ?? join29(outputDir, RECIPE_FILE);
+  const recipePath = state.recipePath ?? join30(outputDir, RECIPE_FILE);
   while (true) {
     const [complete, read] = await Promise.all([readCompletion(outputDir), loadRecipe(outputDir)]);
     const uploadProblems = read.status === "ok" ? findRecipeUploadProblems(read.recipe) : [];
@@ -9897,30 +10399,59 @@ async function runCompletionPhase(state, deps, outputDir) {
       return await manualFallback(outputDir, recipePath, deps.cliCommand, NO_AGENT_FOUND);
     }
     const failure = describeIncompleteRecipe(read, uploadProblems, recipePath, deps.cliCommand);
-    if (launcher != null && (state.launchAttempts ?? 0) < MAX_LAUNCH_ATTEMPTS) {
-      log.warn("The integration isn't complete yet. Launching the agent to finish it...");
-      state.agentId = launcher.id;
-      state.priorFailure = failure;
-      await saveRecipeState(outputDir, state);
-      await launchAgent(launcher, state.permissionMode ?? "bypassPermissions", {
-        outputDir,
-        recipePath,
-        cliCommand: deps.cliCommand,
-        interactive: deps.interactive,
-        priorFailure: failure,
-        userGuidance: state.userGuidance
-      });
-      state.launchAttempts = (state.launchAttempts ?? 0) + 1;
-      await saveRecipeState(outputDir, state);
-      continue;
-    }
-    return { kind: "handback", summary: handbackSummary(failure, outputDir) };
+    const retry = await planRetry(state, launcher, deps, failure);
+    if (retry.kind === "give-up") return { kind: "handback", summary: handbackSummary(retry.summary, outputDir) };
+    log.warn(retry.announcement);
+    state.agentId = retry.launcher.id;
+    state.priorFailure = retry.priorFailure;
+    await saveRecipeState(outputDir, state);
+    state.lastLaunch = await launchAgent(retry.launcher, state.permissionMode ?? "bypassPermissions", {
+      outputDir,
+      recipePath,
+      cliCommand: deps.cliCommand,
+      interactive: deps.interactive,
+      priorFailure: retry.priorFailure,
+      userGuidance: state.userGuidance
+    });
+    state.launchAttempts = (state.launchAttempts ?? 0) + 1;
+    await saveRecipeState(outputDir, state);
+  }
+}
+async function planRetry(state, launcher, deps, failure) {
+  const lastLaunch = state.lastLaunch;
+  const outcome = lastLaunch == null ? void 0 : describeLaunchOutcome(lastLaunch);
+  const failedToStart = outcome?.kind === "failed-to-start" ? outcome.summary : void 0;
+  const summary = failedToStart ?? failure;
+  if (launcher == null) return { kind: "give-up", summary };
+  if ((state.launchAttempts ?? 0) >= MAX_LAUNCH_ATTEMPTS) return { kind: "give-up", summary };
+  if (failedToStart != null && lastLaunch != null) {
+    const alternative = await findOtherAvailableAgent(deps.launchers, lastLaunch.agentId);
+    if (alternative == null) return { kind: "give-up", summary: failedToStart };
+    return {
+      kind: "relaunch",
+      launcher: alternative,
+      // No prior failure: nothing was attempted, so telling a fresh agent that a
+      // prior session "did not complete" would send it hunting for work that was
+      // never started.
+      announcement: `${failedToStart} Trying ${alternative.label} instead...`
+    };
   }
+  return {
+    kind: "relaunch",
+    launcher,
+    priorFailure: failure,
+    announcement: "The integration isn't complete yet. Launching the agent to finish it..."
+  };
+}
+async function findOtherAvailableAgent(launchers, failedAgentId) {
+  const others = launchers.filter((l) => l.id !== failedAgentId);
+  const availability = await Promise.all(others.map((l) => l.isAvailable()));
+  return others.find((_, index) => availability[index]);
 }
 function handbackSummary(failure, outputDir) {
   return `${failure}
 
-Finish the integration (see the prompt at ${join29(outputDir, INTEGRATION_PROMPT_FILE)}), then re-run with --resume.`;
+Finish the integration (see the prompt at ${join30(outputDir, INTEGRATION_PROMPT_FILE)}), then re-run with --resume.`;
 }
 async function launchAgent(launcher, permissionMode, target) {
   const promptFile = await writeIntegrationPrompt({
@@ -9930,7 +10461,7 @@ async function launchAgent(launcher, permissionMode, target) {
     priorFailure: target.priorFailure,
     userGuidance: target.userGuidance
   });
-  await rm2(join29(target.outputDir, COMPLETION_MARKER_FILE), { force: true }).catch((err) => {
+  await rm2(join30(target.outputDir, COMPLETION_MARKER_FILE), { force: true }).catch((err) => {
     debugLog("Could not clear a stale completion marker", { err });
   });
   log.info(`Launching ${launcher.label}. It will implement the integration - watch and steer it as it works.`);
@@ -9947,6 +10478,7 @@ async function launchAgent(launcher, permissionMode, target) {
     });
   }
   suspend();
+  const startedAt = Date.now();
   try {
     const exitCode = await launcher.launch({
       message: launchMessage(promptFile),
@@ -9957,7 +10489,22 @@ async function launchAgent(launcher, permissionMode, target) {
       // 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.`);
+    const launch = {
+      agentLabel: launcher.label,
+      agentId: launcher.id,
+      exitCode,
+      durationMs: Date.now() - startedAt
+    };
+    log.info(
+      `${launcher.label} exited (code ${exitCode ?? "unknown"}) after ${Math.round(launch.durationMs / 1e3)}s. Back to the planner.`
+    );
+    track("cli_agent_launch_finished", {
+      agent: launcher.id,
+      exit_code: exitCode,
+      duration_ms: launch.durationMs,
+      outcome: describeLaunchOutcome(launch).kind
+    });
+    return launch;
   } finally {
     resume();
   }
@@ -10004,6 +10551,7 @@ var init_handoff = __esm({
   "src/agents/04-recipe-builder/phases/handoff.ts"() {
     "use strict";
     init_esm_shims();
+    init_analytics();
     init_coding_agent();
     init_debug();
     init_interrupt();
@@ -10013,6 +10561,7 @@ var init_handoff = __esm({
     init_completion();
     init_completion_watch();
     init_integration_prompt();
+    init_launch_outcome();
     init_recipe();
     init_state2();
     MAX_LAUNCH_ATTEMPTS = 2;
@@ -10129,17 +10678,17 @@ var init_recipe_builder = __esm({
 });
 
 // src/agents/00b-feature-discovery/index.ts
-import { readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
-import { join as join30 } from "path";
+import { readFile as readFile19, writeFile as writeFile11 } from "fs/promises";
+import { join as join31 } from "path";
 import { tool as tool14 } from "ai";
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 async function saveFeatures(outputDir, features) {
   const obj = Object.fromEntries(features);
-  await writeFile10(join30(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile11(join31(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadFeatures(outputDir) {
   try {
-    const raw = await readFile18(join30(outputDir, FEATURES_FILE), "utf-8");
+    const raw = await readFile19(join31(outputDir, FEATURES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -10173,7 +10722,7 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         add_feature: tool14({
           description: "Add a discovered sub-feature",
           inputSchema: Feature.extend({
-            id: z51.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
+            id: z52.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
           }),
           execute: (featureInput) => {
             const { id, ...rest } = featureInput;
@@ -10187,17 +10736,17 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         }),
         view_features: tool14({
           description: "View all discovered features so far",
-          inputSchema: z51.object({}),
+          inputSchema: z52.object({}),
           execute: () => collector.viewFeatures()
         }),
         view_pages: tool14({
           description: "View the pages list to know what to analyze",
-          inputSchema: z51.object({}),
+          inputSchema: z52.object({}),
           execute: () => pagesDescription
         }),
         finish: tool14({
           description: "Signal that feature discovery is complete",
-          inputSchema: z51.object({ summary: z51.string() }),
+          inputSchema: z52.object({ summary: z52.string() }),
           execute: async (finishInput) => {
             result = {
               success: true,
@@ -10228,13 +10777,13 @@ var init_b_feature_discovery = __esm({
     init_model();
     init_tools();
     FEATURES_FILE = "features.json";
-    Feature = z51.object({
-      name: z51.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
-      type: z51.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
-      parentPagePath: z51.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
-      sourceFiles: z51.array(z51.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
-      interactiveElements: z51.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
-      description: z51.string().min(10).describe("What this sub-feature does")
+    Feature = z52.object({
+      name: z52.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
+      type: z52.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
+      parentPagePath: z52.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
+      sourceFiles: z52.array(z52.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
+      interactiveElements: z52.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
+      description: z52.string().min(10).describe("What this sub-feature does")
     });
     FeatureCollector = class {
       features = /* @__PURE__ */ new Map();
@@ -10317,21 +10866,21 @@ Use kebab-case IDs that indicate the parent page and feature type:
 });
 
 // src/agents/05-test-generator/graph.ts
-import { readFile as readFile19, writeFile as writeFile11 } from "fs/promises";
-import { join as join31 } from "path";
+import { readFile as readFile20, writeFile as writeFile12 } from "fs/promises";
+import { join as join32 } from "path";
 function estimateExpectedTests(written, processed, totalNodes) {
   if (totalNodes <= 0) return written;
   const rate = written > 0 && processed >= LIVE_RATE_MIN_PROCESSED ? written / processed : TESTS_PER_NODE_PRIOR;
   return Math.max(written, Math.round(rate * totalNodes));
 }
 async function saveBfsState(outputDir, state) {
-  const path3 = join31(outputDir, state.stateFile);
-  await writeFile11(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
+  const path3 = join32(outputDir, state.stateFile);
+  await writeFile12(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
 }
 async function loadBfsState(outputDir) {
-  const path3 = join31(outputDir, BFS_STATE_FILE);
+  const path3 = join32(outputDir, BFS_STATE_FILE);
   try {
-    const raw = await readFile19(path3, "utf-8");
+    const raw = await readFile20(path3, "utf-8");
     return CoverageState.deserialize(JSON.parse(raw));
   } catch {
     return void 0;
@@ -10931,13 +11480,13 @@ When you finish, all dimensions are reported so the user knows what's covered an
 });
 
 // src/agents/05-test-generator/recipe-context.ts
-import { readFile as readFile20 } from "fs/promises";
-import { join as join32 } from "path";
-import { z as z52 } from "zod";
+import { readFile as readFile21 } from "fs/promises";
+import { join as join33 } from "path";
+import { z as z53 } from "zod";
 async function loadRecipeContext(outputDir) {
   let raw;
   try {
-    raw = await readFile20(join32(outputDir, "recipe.json"), "utf-8");
+    raw = await readFile21(join33(outputDir, "recipe.json"), "utf-8");
   } catch (err) {
     debugLog("recipe.json not present; test generation falls back to scenarios.md alone", { err });
     return "";
@@ -10995,13 +11544,13 @@ var init_recipe_context = __esm({
     init_debug();
     STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["_alias", "_ref"]);
     TEMPLATE_TOKEN = /\{\{\s*\w+\s*\}\}/;
-    recipeRowSchema = z52.record(z52.string(), z52.unknown());
-    recipeFileSchema = z52.object({
-      recipes: z52.array(
-        z52.object({
-          name: z52.string(),
-          description: z52.string().optional(),
-          create: z52.record(z52.string(), z52.array(recipeRowSchema)).optional()
+    recipeRowSchema = z53.record(z53.string(), z53.unknown());
+    recipeFileSchema = z53.object({
+      recipes: z53.array(
+        z53.object({
+          name: z53.string(),
+          description: z53.string().optional(),
+          create: z53.record(z53.string(), z53.array(recipeRowSchema)).optional()
         })
       )
     });
@@ -11009,7 +11558,7 @@ var init_recipe_context = __esm({
 });
 
 // src/agents/05-test-generator/restore-deleted-test.ts
-import { access, mkdir as mkdir4, writeFile as writeFile12 } from "fs/promises";
+import { access, mkdir as mkdir4, writeFile as writeFile13 } from "fs/promises";
 import { dirname as dirname4 } from "path";
 async function restoreDeletedTest(testPath, originalContent) {
   try {
@@ -11020,7 +11569,7 @@ async function restoreDeletedTest(testPath, originalContent) {
   }
   try {
     await mkdir4(dirname4(testPath), { recursive: true });
-    await writeFile12(testPath, originalContent, "utf-8");
+    await writeFile13(testPath, originalContent, "utf-8");
     return true;
   } catch (err) {
     console.warn(`  [fix] Could not restore ${testPath}: ${err instanceof Error ? err.message : String(err)}`);
@@ -11087,21 +11636,21 @@ var init_pool = __esm({
 });
 
 // src/agents/05-test-generator/rubrics.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 function reviewResultSchema(shape) {
-  return z53.object(shape);
+  return z54.object(shape);
 }
 var dimensionResultSchema, reviewResultRecordSchema, structuralIntentRubric, flowCompletenessRubric, uiTextRubric, dataAccuracyRubric, ALL_RUBRICS;
 var init_rubrics = __esm({
   "src/agents/05-test-generator/rubrics.ts"() {
     "use strict";
     init_esm_shims();
-    dimensionResultSchema = z53.object({
-      pass: z53.boolean(),
-      evidence: z53.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
-      suggestion: z53.string().optional().describe("What the planner agent should fix, if failing")
+    dimensionResultSchema = z54.object({
+      pass: z54.boolean(),
+      evidence: z54.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
+      suggestion: z54.string().optional().describe("What the planner agent should fix, if failing")
     });
-    reviewResultRecordSchema = z53.record(z53.string(), dimensionResultSchema);
+    reviewResultRecordSchema = z54.record(z54.string(), dimensionResultSchema);
     structuralIntentRubric = {
       name: "structural-intent",
       maxSteps: 8,
@@ -11347,12 +11896,12 @@ var init_review_pass = __esm({
 });
 
 // src/agents/05-test-generator/review.ts
-import { readFile as readFile21 } from "fs/promises";
-import { join as join33, relative as relative7, basename as basename6 } from "path";
+import { readFile as readFile22 } from "fs/promises";
+import { join as join34, relative as relative7, basename as basename6 } from "path";
 import "ai";
 import { glob as glob5 } from "glob";
 function markReview(relativePath, status) {
-  getActiveStore()?.setArtifactReview(join33(TESTS_DIR, relativePath), status);
+  getActiveStore()?.setArtifactReview(join34(TESTS_DIR, relativePath), status);
 }
 function mergeRubricResults(reported) {
   const merged = {};
@@ -11407,24 +11956,24 @@ async function readDataContract(outputDir) {
   const recipe = await loadRecipeContext(outputDir);
   if (recipe !== "") return recipe;
   try {
-    return await readFile21(join33(outputDir, "scenarios.md"), "utf-8");
+    return await readFile22(join34(outputDir, "scenarios.md"), "utf-8");
   } catch (err) {
     debugLog("No data contract available for review", { err });
     return void 0;
   }
 }
 async function runConsolidatedReview(outputDir, projectRoot, model, deadline, settled = /* @__PURE__ */ new Set(), precomputed = [], onProgress) {
-  const testsDir = join33(outputDir, TESTS_DIR);
+  const testsDir = join34(outputDir, TESTS_DIR);
   const logger = createStepLogger("review", 5);
   const scenarioData = await readDataContract(outputDir);
-  const testFiles = await glob5(join33(testsDir, TEST_FILE_GLOB));
+  const testFiles = await glob5(join34(testsDir, TEST_FILE_GLOB));
   const tests = [];
   for (const testPath of testFiles) {
     if (!isTestFile(testPath)) continue;
     if (testPath.includes("/_invalid/")) continue;
     const relativePath = relative7(testsDir, testPath);
     if (settled.has(relativePath)) continue;
-    const content = await readFile21(testPath, "utf-8");
+    const content = await readFile22(testPath, "utf-8");
     const flowMatch = content.match(/^---\n[\s\S]*?flow:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
     tests.push({ path: testPath, relativePath, content, flow: flowMatch?.[1]?.trim() ?? "unknown" });
   }
@@ -11619,7 +12168,7 @@ var init_review_pipeline = __esm({
 });
 
 // src/agents/05-test-generator/validation.ts
-import matter4 from "gray-matter";
+import matter4 from "@11ty/gray-matter";
 function isValidVerb(verb) {
   return VALID_VERBS.has(verb);
 }
@@ -11683,7 +12232,7 @@ var init_validation = __esm({
 });
 
 // src/agents/05-test-generator/test-spec.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 function hasPlaceholder(text2) {
   if (text2 == null) return false;
   return PLACEHOLDER_PATTERNS.some(({ pattern }) => pattern.test(text2));
@@ -11734,12 +12283,12 @@ var init_test_spec = __esm({
       { pattern: /(?<!\{)\{[a-z][a-zA-Z]*\}(?!\})/, name: "bare {variable}" },
       { pattern: /\be\.g\./i, name: '"e.g." example' }
     ];
-    stepSchema = z54.object({
-      verb: z54.enum(STEP_VERBS).describe("The action. Only these verbs exist."),
-      description: z54.string().min(1).describe(
+    stepSchema = z55.object({
+      verb: z55.enum(STEP_VERBS).describe("The action. Only these verbs exist."),
+      description: z55.string().min(1).describe(
         `What to do or check, naming the exact visible text. For assert, the thing expected on screen - e.g. 'text "Transfer Successful"'.`
       ),
-      location: z54.string().optional().describe(
+      location: z55.string().optional().describe(
         'WHERE on screen the target is - "in the modal", "in the toast notification", "on the Sony WH-1000XM5 product card", "in the dashboard header", "as a page heading". REQUIRED for click, type and assert: the same label routinely appears more than once (a header button and the modal button it opens, "Buy" on every card in a list), and acting on the wrong one fails confusingly. Not needed for scroll or refresh, which act on the page.'
       )
     }).refine((step) => !requiresLocation(step.verb) || (step.location?.trim() ?? "") !== "", {
@@ -11749,27 +12298,27 @@ var init_test_spec = __esm({
       message: "steps carry no variables - use the exact value from the test data, not a placeholder or example",
       path: ["description"]
     });
-    testSpecSchema = z54.object({
-      title: z54.string().min(1).describe("Short, descriptive test name."),
-      description: z54.string().min(1).describe("One sentence explaining what the test verifies."),
-      intent: z54.string().min(30).describe(
+    testSpecSchema = z55.object({
+      title: z55.string().min(1).describe("Short, descriptive test name."),
+      description: z55.string().min(1).describe("One sentence explaining what the test verifies."),
+      intent: z55.string().min(30).describe(
         "A specific, falsifiable claim derived from the node's mission: what the user does, what the feature produces, why it matters. Not the steps, not 'the page displays correctly'."
       ),
-      criticality: z54.enum(CRITICALITY_LEVELS),
-      scenario: z54.string().min(1).describe('Which scenario this test uses (usually "standard").'),
-      flow: z54.string().min(1).describe("Which feature/flow this belongs to (must match a flow from AUTONOMA.md)."),
-      verification: z54.string().min(20).describe(
+      criticality: z55.enum(CRITICALITY_LEVELS),
+      scenario: z55.string().min(1).describe('Which scenario this test uses (usually "standard").'),
+      flow: z55.string().min(1).describe("Which feature/flow this belongs to (must match a flow from AUTONOMA.md)."),
+      verification: z55.string().min(20).describe(
         "WHERE to navigate and WHAT to assert to prove the mutation worked. Must name the source of truth - a toast, a confirmation dialog or an inline success indicator is an acknowledgment, not proof."
       ),
-      setup: z54.string().min(1).describe(
+      setup: z55.string().min(1).describe(
         "Which page the user starts on and how they got there. Never authentication - the user is already signed in."
       ),
-      steps: z54.array(stepSchema).min(1).describe("The action sequence, in order."),
-      verificationSteps: z54.array(stepSchema).describe(
+      steps: z55.array(stepSchema).min(1).describe("The action sequence, in order."),
+      verificationSteps: z55.array(stepSchema).describe(
         "Steps that navigate to the source of truth and assert the mutation landed. Implements the `verification` field above."
       ),
-      expectedResult: z54.string().min(1).describe("What should be true when the test passes."),
-      notes: z54.string().optional().describe(
+      expectedResult: z55.string().min(1).describe("What should be true when the test passes."),
+      notes: z55.string().optional().describe(
         "Optional free text for anything you could not resolve or want to flag - an ambiguous default state, a element you could not find in the source, an assumption you had to make. Recorded for humans and NEVER written into the test file, so it will not affect execution. Use it instead of guessing silently."
       )
     }).refine((spec) => spec.steps.filter((step) => isInteractionVerb(step.verb)).length >= MIN_INTERACTIONS, {
@@ -11780,25 +12329,25 @@ var init_test_spec = __esm({
 });
 
 // src/agents/05-test-generator/tools.ts
-import { mkdir as mkdir5, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname5, join as join34 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname5, join as join35 } from "path";
 import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool16, ToolLoopAgent as ToolLoopAgent3 } from "ai";
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 function buildWriteTestTool(state, outputDir, onWritten) {
   return tool16({
     description: "Write one test to qa-tests/{folder}/{filename}.md. You supply the test's parts; the file is rendered for you, so do not write markdown or frontmatter yourself.",
-    inputSchema: z55.object({
-      folder: z55.string().describe("Subfolder name under qa-tests/"),
-      filename: z55.string().describe(`File name ending in ${TEST_FILE_EXT} (e.g. login-valid-credentials${TEST_FILE_EXT})`),
-      nodeId: z55.string().describe(
+    inputSchema: z56.object({
+      folder: z56.string().describe("Subfolder name under qa-tests/"),
+      filename: z56.string().describe(`File name ending in ${TEST_FILE_EXT} (e.g. login-valid-credentials${TEST_FILE_EXT})`),
+      nodeId: z56.string().describe(
         "The id next_node returned for this feature, copied verbatim. Not a re-slugged version of it, not a folder path, not the test filename."
       ),
       test: testSpecSchema
     }),
     execute: async (input) => {
       const content = renderTestMarkdown(input.test);
-      const relPath = join34(TESTS_DIR, input.folder, normalizeTestFilename(input.filename));
-      const absPath = join34(outputDir, relPath);
+      const relPath = join35(TESTS_DIR, input.folder, normalizeTestFilename(input.filename));
+      const absPath = join35(outputDir, relPath);
       const nodeId = state.resolveNodeId(input.nodeId, relPath);
       if (nodeId == null) {
         const stats = state.summary();
@@ -11817,7 +12366,7 @@ function buildWriteTestTool(state, outputDir, onWritten) {
       }
       try {
         await mkdir5(dirname5(absPath), { recursive: true });
-        await writeFile13(absPath, content, "utf-8");
+        await writeFile14(absPath, content, "utf-8");
         state.markTested(nodeId, [relPath]);
         await saveBfsState(outputDir, state);
         const notes = input.test.notes?.trim();
@@ -11830,7 +12379,7 @@ function buildWriteTestTool(state, outputDir, onWritten) {
           });
         }
         onWritten?.({
-          relativePath: join34(input.folder, normalizeTestFilename(input.filename)),
+          relativePath: join35(input.folder, normalizeTestFilename(input.filename)),
           content,
           flow: input.test.flow
         });
@@ -11868,14 +12417,14 @@ function buildWriteTestTool(state, outputDir, onWritten) {
 function buildCreateFolderTool(outputDir) {
   return tool16({
     description: "Create a folder under qa-tests/ for organizing tests.",
-    inputSchema: z55.object({
-      folder: z55.string().describe("Folder name (kebab-case)")
+    inputSchema: z56.object({
+      folder: z56.string().describe("Folder name (kebab-case)")
     }),
     execute: async (input) => {
-      const absPath = join34(outputDir, TESTS_DIR, input.folder);
+      const absPath = join35(outputDir, TESTS_DIR, input.folder);
       try {
         await mkdir5(absPath, { recursive: true });
-        return { path: join34(TESTS_DIR, input.folder) };
+        return { path: join35(TESTS_DIR, input.folder) };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `Failed to create folder: ${message}` };
@@ -11886,7 +12435,7 @@ function buildCreateFolderTool(outputDir) {
 function buildNextNodeTool(state, outputDir) {
   return tool16({
     description: "Get the next node to write tests for. If you called next_node before without writing any tests (via write_test), the previous node is auto-skipped. Returns done:true when all nodes are processed.",
-    inputSchema: z55.object({}),
+    inputSchema: z56.object({}),
     execute: async () => {
       const next = state.nextNode();
       await saveBfsState(outputDir, state);
@@ -11920,7 +12469,7 @@ function buildNextNodeTool(state, outputDir) {
 function buildGetProgressTool(state) {
   return tool16({
     description: "Check how many nodes have been tested vs how many remain.",
-    inputSchema: z55.object({}),
+    inputSchema: z56.object({}),
     execute: async () => {
       const stats = state.summary();
       const nodes = [...state.nodes.values()].map((n) => ({
@@ -11936,12 +12485,12 @@ function buildGetProgressTool(state) {
 function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
   return tool16({
     description: "Spawn a research subagent to read and analyze source files without polluting your context. Use for complex sub-features where you don't want to read 20 files yourself.",
-    inputSchema: z55.object({
-      instruction: z55.string().describe("What to research - be specific about files and what to look for")
+    inputSchema: z56.object({
+      instruction: z56.string().describe("What to research - be specific about files and what to look for")
     }),
     execute: async (input) => {
-      const resultSchema2 = z55.object({
-        findings: z55.string().describe("Summary of what was found")
+      const resultSchema2 = z56.object({
+        findings: z56.string().describe("Summary of what was found")
       });
       let result;
       const subagent = new ToolLoopAgent3({
@@ -11994,11 +12543,11 @@ var init_tools2 = __esm({
 });
 
 // src/agents/05-test-generator/write-index.ts
-import { readFile as readFile22, writeFile as writeFile14 } from "fs/promises";
-import { join as join35 } from "path";
+import { readFile as readFile23, writeFile as writeFile15 } from "fs/promises";
+import { join as join36 } from "path";
 async function scanTest(outputDir, path3) {
   try {
-    const content = await readFile22(join35(outputDir, path3), "utf-8");
+    const content = await readFile23(join36(outputDir, path3), "utf-8");
     return {
       criticality: content.match(/criticality:\s*(\w+)/)?.[1] ?? "",
       steps: content.match(STEP_VERBS2)?.length ?? 0,
@@ -12069,7 +12618,7 @@ ${folders.map((f) => `| ${f.name} | ${f.test_count} |`).join("\n")}
 
 ${[...testsByFolder.entries()].flatMap(([_folder, tests]) => tests.map((t) => `- \`${t}\``)).join("\n")}
 ${renderSection("Features with no tests", "the run walked these and produced no test for them - re-run the planner to cover them", untested)}${renderSection("Tests lost in review", "the review cycle removed these and nothing could put them back - re-run the planner to regenerate them", lost)}`;
-  await writeFile14(join35(outputDir, TESTS_DIR, TEST_INDEX_FILE), content, "utf-8");
+  await writeFile15(join36(outputDir, TESTS_DIR, TEST_INDEX_FILE), content, "utf-8");
 }
 function untestedFeatures(state) {
   const withTests = new Set(state.testsWritten.keys());
@@ -12104,11 +12653,11 @@ __export(test_generator_exports, {
   runTestGenerator: () => runTestGenerator
 });
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir6, readFile as readFile23, rmdir, unlink, writeFile as writeFile15 } from "fs/promises";
-import { basename as basename7, join as join36 } from "path";
+import { mkdir as mkdir6, readFile as readFile24, rmdir, unlink, writeFile as writeFile16 } from "fs/promises";
+import { basename as basename7, join as join37 } from "path";
 import { tool as tool17 } from "ai";
 import { glob as glob6 } from "glob";
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 async function preseedQueue(state, projectRoot, pages, features) {
   let seeded = 0;
   const pageIdByPath = /* @__PURE__ */ new Map();
@@ -12160,8 +12709,8 @@ async function runTestGenerator(input) {
   let result;
   const finishTool = tool17({
     description: "Call when the BFS queue is empty and all routes have been explored.",
-    inputSchema: z56.object({
-      summary: z56.string().describe("Coverage summary")
+    inputSchema: z57.object({
+      summary: z57.string().describe("Coverage summary")
     }),
     execute: async (finishInput) => {
       const stats = state.summary();
@@ -12189,7 +12738,7 @@ async function runTestGenerator(input) {
   });
   let kbContext = "";
   try {
-    const autonomaMd = await readFile23(join36(input.outputDir, "AUTONOMA.md"), "utf-8");
+    const autonomaMd = await readFile24(join37(input.outputDir, "AUTONOMA.md"), "utf-8");
     kbContext += `
 ## Knowledge Base (AUTONOMA.md)
 
@@ -12202,7 +12751,7 @@ ${autonomaMd}
     kbContext += recipeContext;
   } else {
     try {
-      const scenariosMd = await readFile23(join36(input.outputDir, "scenarios.md"), "utf-8");
+      const scenariosMd = await readFile24(join37(input.outputDir, "scenarios.md"), "utf-8");
       kbContext += `
 ## Scenarios
 
@@ -12500,20 +13049,20 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
     }
     state.clearReviewProgress();
     state.setPhase("checking every test");
-    const allTestFiles = await glob6(join36(input.outputDir, TESTS_DIR, TEST_FILE_GLOB));
+    const allTestFiles = await glob6(join37(input.outputDir, TESTS_DIR, TEST_FILE_GLOB));
     let markedInvalid = 0;
     for (const testPath of allTestFiles) {
       if (!isTestFile(testPath)) continue;
       if (testPath.includes(`/${INVALID_DIR}/`)) continue;
-      const content = await readFile23(testPath, "utf-8");
+      const content = await readFile24(testPath, "utf-8");
       const validation = validateTestContent(content);
       if (!validation.valid) {
-        const invalidDir = join36(input.outputDir, TESTS_DIR, INVALID_DIR);
+        const invalidDir = join37(input.outputDir, TESTS_DIR, INVALID_DIR);
         await mkdir6(invalidDir, { recursive: true });
-        const dest = join36(invalidDir, basename7(testPath));
+        const dest = join37(invalidDir, basename7(testPath));
         const annotated = `<!-- VALIDATION ERRORS: ${validation.errors.join("; ")} -->
 ${content}`;
-        await writeFile15(dest, annotated, "utf-8");
+        await writeFile16(dest, annotated, "utf-8");
         await unlink(testPath);
         markedInvalid++;
       }
@@ -12521,7 +13070,7 @@ ${content}`;
     if (markedInvalid > 0) {
       console.log(`  ${markedInvalid} tests still invalid after review cycles - moved to _invalid/`);
     }
-    const dirs = await glob6(join36(input.outputDir, TESTS_DIR, "**/"), {
+    const dirs = await glob6(join37(input.outputDir, TESTS_DIR, "**/"), {
       dot: false
     });
     for (const dir of dirs.sort((a, b) => b.length - a.length)) {
@@ -12574,21 +13123,21 @@ async function generateJourneyTests(outputDir, model, projectRoot) {
   let autonomaMd = "";
   let scenariosMd = "";
   try {
-    autonomaMd = await readFile23(join36(outputDir, "AUTONOMA.md"), "utf-8");
+    autonomaMd = await readFile24(join37(outputDir, "AUTONOMA.md"), "utf-8");
   } catch (err) {
     debugLog("AUTONOMA.md not present for journey generation", { err });
   }
   try {
-    scenariosMd = await readFile23(join36(outputDir, "scenarios.md"), "utf-8");
+    scenariosMd = await readFile24(join37(outputDir, "scenarios.md"), "utf-8");
   } catch (err) {
     debugLog("scenarios.md not present for journey generation", { err });
   }
   if (!autonomaMd) return 0;
-  const existingTests = await glob6(join36(outputDir, TESTS_DIR, TEST_FILE_GLOB));
+  const existingTests = await glob6(join37(outputDir, TESTS_DIR, TEST_FILE_GLOB));
   const existingTitles = [];
   for (const t of existingTests) {
     if (!isTestFile(t)) continue;
-    const content = await readFile23(t, "utf-8");
+    const content = await readFile24(t, "utf-8");
     const titleMatch = content.match(/title:\s*"([^"]+)"/);
     if (titleMatch) existingTitles.push(titleMatch[1]);
   }
@@ -12634,7 +13183,7 @@ Write 5-8 journey tests using the write_test tool with folder "${JOURNEY_NODE_ID
   let journeyResult;
   const journeyFinish = tool17({
     description: "Signal journey generation is complete.",
-    inputSchema: z56.object({ summary: z56.string() }),
+    inputSchema: z57.object({ summary: z57.string() }),
     execute: async (finishInput) => {
       journeyResult = {
         success: true,
@@ -14481,14 +15030,14 @@ var init_session_recorder = __esm({
 });
 
 // src/ui/artifacts/reader.ts
-import { open, readFile as readFile24, stat as stat2 } from "fs/promises";
+import { open, readFile as readFile25, stat as stat2 } from "fs/promises";
 async function readForLive(absPath) {
   try {
     const info = await stat2(absPath);
     if (!info.isFile()) return void 0;
     const kind = kindOf(absPath);
     if (info.size <= LARGE_BYTES) {
-      const text2 = await readFile24(absPath, "utf-8");
+      const text2 = await readFile25(absPath, "utf-8");
       return { text: text2, kind, truncated: false };
     }
     const fh = await open(absPath, "r");
@@ -14782,9 +15331,9 @@ ensureSupportedNode();
 
 // src/index.ts
 init_submit();
-import { readFile as readFile25, writeFile as writeFile16 } from "fs/promises";
+import { readFile as readFile26, writeFile as writeFile17 } from "fs/promises";
 import { freemem } from "os";
-import { delimiter, join as join37 } from "path";
+import { delimiter, join as join38 } from "path";
 
 // src/agents/04-recipe-builder/sdk-command.ts
 init_esm_shims();
@@ -14973,7 +15522,7 @@ function shortHash(seed) {
 }
 
 // src/agents/04-recipe-builder/sdk-command.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // src/core/cli-args.ts
 init_esm_shims();
@@ -15132,16 +15681,16 @@ async function down(config, refsToken) {
 init_recipe();
 var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
 var MIN_REPEAT_INSTANCES = 2;
-var createSchema = z33.record(z33.string(), z33.array(z33.unknown()));
-var recipeSliceSchema = z33.object({ create: createSchema, variables: ScenarioRecipeVariablesSchema.optional() });
-var envelopeSchema = z33.object({ recipes: z33.array(recipeSliceSchema).min(1) });
-var flagsSchema = z33.object({
-  url: z33.string().min(1).optional(),
-  recipe: z33.string().min(1).optional(),
-  "refs-token": z33.string().min(1).optional(),
-  "test-run-id": z33.string().min(1).optional(),
-  timeout: z33.coerce.number().int().positive().optional(),
-  repeat: z33.coerce.number().int().min(MIN_REPEAT_INSTANCES).optional()
+var createSchema = z34.record(z34.string(), z34.array(z34.unknown()));
+var recipeSliceSchema = z34.object({ create: createSchema, variables: ScenarioRecipeVariablesSchema.optional() });
+var envelopeSchema = z34.object({ recipes: z34.array(recipeSliceSchema).min(1) });
+var flagsSchema = z34.object({
+  url: z34.string().min(1).optional(),
+  recipe: z34.string().min(1).optional(),
+  "refs-token": z34.string().min(1).optional(),
+  "test-run-id": z34.string().min(1).optional(),
+  timeout: z34.coerce.number().int().positive().optional(),
+  repeat: z34.coerce.number().int().min(MIN_REPEAT_INSTANCES).optional()
 });
 var SDK_FLAGS = new Set(Object.keys(flagsSchema.shape));
 async function runSdkCommand(argv, io) {
@@ -15911,8 +16460,8 @@ init_prompts();
 // src/core/git.ts
 init_esm_shims();
 import { execFile } from "child_process";
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join14 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var GIT_INFO_FILE = ".git-info.json";
@@ -15936,11 +16485,11 @@ async function readGitInfo(projectRoot) {
   };
 }
 async function saveGitInfo(outputDir, info) {
-  await writeFile4(join13(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile5(join14(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 async function loadGitInfo(outputDir) {
   try {
-    const raw = await readFile5(join13(outputDir, GIT_INFO_FILE), "utf-8");
+    const raw = await readFile6(join14(outputDir, GIT_INFO_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed != null && "sha" in parsed && typeof parsed.sha === "string") {
       const branch = "branch" in parsed && typeof parsed.branch === "string" ? parsed.branch : void 0;
@@ -15962,15 +16511,15 @@ init_state();
 init_esm_shims();
 init_prompts();
 init_debug();
-import { readFile as readFile7 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join16 } from "path";
 init_test_files();
 var ARTIFACT_FILES = ["AUTONOMA.md", "scenarios.md", "entity-audit.md"];
 async function readArtifacts(outputDir) {
   const files = await Promise.all(
     ARTIFACT_FILES.map(async (name) => {
       try {
-        return { name, content: await readFile7(join15(outputDir, name), "utf-8") };
+        return { name, content: await readFile8(join16(outputDir, name), "utf-8") };
       } catch (err) {
         debugLog(`Artifact ${name} not on disk; skipping upload`, { err });
         return void 0;
@@ -15986,7 +16535,7 @@ async function readTestCases(outputDir) {
       const segments = testPath.split("/").slice(1);
       const name = segments[segments.length - 1];
       const folder = segments.slice(0, -1).join("/");
-      const content = await readFile7(join15(outputDir, testPath), "utf-8");
+      const content = await readFile8(join16(outputDir, testPath), "utf-8");
       return { name, content, folder: folder.length > 0 ? folder : void 0 };
     })
   );
@@ -16051,11 +16600,11 @@ process.setSourceMapsEnabled(true);
 var PAGES_FILE = "pages.json";
 async function savePages(outputDir, pages) {
   const obj = Object.fromEntries(pages);
-  await writeFile16(join37(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile17(join38(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadPages(outputDir) {
   try {
-    const raw = await readFile25(join37(outputDir, PAGES_FILE), "utf-8");
+    const raw = await readFile26(join38(outputDir, PAGES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -16424,6 +16973,23 @@ function ensureAutonomaAuth() {
   );
   return false;
 }
+async function runPreviewHandoffStep(frontDoor, config, nonInteractive) {
+  const { runPreviewHandoff: runPreviewHandoff2, describeIncompletePreview: describeIncompletePreview2 } = await Promise.resolve().then(() => (init_front_door(), front_door_exports));
+  try {
+    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);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    track("cli_preview_phase_finished", { outcome: "error" });
+    trackError(err, { source: "preview_phase" });
+    log.warn(`Couldn't set up your preview environment: ${message}`);
+    log.info(
+      "The rest of the run continues - finish the preview in the Autonoma app, or run again once it's sorted."
+    );
+  }
+}
 async function finishFrontDoorRun(frontDoor, config, nonInteractive) {
   try {
     const gitInfo = await readGitInfo(config.projectRoot);
@@ -16582,11 +17148,7 @@ async function main() {
     });
   }
   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);
+    await runPreviewHandoffStep(frontDoor, config, nonInteractive);
   }
   if (args.has("fresh") && hasProgress) {
     await clearOutputDir(config.projectSlug);