@agent-native/core 0.90.3 → 0.90.5

package/bin/agent-native.js

@@ -1,17 +1,39 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 const binDir = dirname(fileURLToPath(import.meta.url));
 const distEntry = join(binDir, "../dist/cli/index.js");
+const sourceEntry = join(binDir, "../src/cli/index.ts");
+const freshnessChecks = [
+  [sourceEntry, distEntry],
+  [
+    join(binDir, "../src/cli/design-connect.ts"),
+    join(binDir, "../dist/cli/design-connect.js"),
+  ],
+];
 
-if (existsSync(distEntry)) {
+function shouldUseSourceFallback() {
+  if (!existsSync(sourceEntry)) return false;
+  if (!existsSync(distEntry)) return true;
+  try {
+    return freshnessChecks.some(
+      ([source, dist]) =>
+        existsSync(source) &&
+        existsSync(dist) &&
+        statSync(source).mtimeMs > statSync(dist).mtimeMs,
+    );
+  } catch {
+    return false;
+  }
+}
+
+if (!shouldUseSourceFallback() && existsSync(distEntry)) {
   await import(pathToFileURL(distEntry).href);
 } else {
-  const sourceEntry = join(binDir, "../src/cli/index.ts");
   if (!existsSync(sourceEntry)) {
     console.error(
       "agent-native CLI build output is missing. Run `pnpm --filter @agent-native/core build` and try again.",

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2144
-- template files: 4806
+- template files: 4822

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @agent-native/core
 
+## 0.90.5
+
+### Patch Changes
+
+- 3da78df: Classify BYO-provider rate limits (HTTP 429) as retryable. The native Anthropic and AI-SDK engines now forward the provider HTTP status as a structured `http_<status>` errorCode + `statusCode` for every failure (not just 401), so a bare "429 status code (no body)" surfaces as `http_429`. `isRetryableError` also matches `http_429` and bare `429` messages. Previously a directly-connected provider key that Anthropic rate-limited failed hard instead of backing off and retrying like the Builder gateway path does, and rate-limited runs can now auto-continue.
+- 3da78df: Fix localhost Design bridge self-registration so capability payloads match the Design server action and bridge tokens can be persisted.
+- 3da78df: Make hosted foreground agent turns continue from the server by default, so switching tabs or closing the browser no longer leaves long runs dependent on a client-side auto-continue POST.
+
+## 0.90.4
+
+### Patch Changes
+
+- 9f396bc: Fail closed for unregistered History/Review resource types, allocate unique version numbers atomically, verify resolve/consume update counts, and prefer server snapshots over client-supplied ones.
+- 9f396bc: Add live visual-edit bridge support for localhost apps so Design can render editable live iframes instead of static HTML snapshots.
+- 9f396bc: Expire sticky provider auth-failure markers, skip rejected deploy env keys during engine auto-detect, and clear failure markers from the legacy save-key path.
+- 9f396bc: Keep React Router build packages installed for scaffolded app builds and report missing build dependencies before spawning the CLI.
+
 ## 0.90.3
 
 ### Patch Changes

package/corpus/core/bin/agent-native.js

@@ -1,17 +1,39 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 const binDir = dirname(fileURLToPath(import.meta.url));
 const distEntry = join(binDir, "../dist/cli/index.js");
+const sourceEntry = join(binDir, "../src/cli/index.ts");
+const freshnessChecks = [
+  [sourceEntry, distEntry],
+  [
+    join(binDir, "../src/cli/design-connect.ts"),
+    join(binDir, "../dist/cli/design-connect.js"),
+  ],
+];
 
-if (existsSync(distEntry)) {
+function shouldUseSourceFallback() {
+  if (!existsSync(sourceEntry)) return false;
+  if (!existsSync(distEntry)) return true;
+  try {
+    return freshnessChecks.some(
+      ([source, dist]) =>
+        existsSync(source) &&
+        existsSync(dist) &&
+        statSync(source).mtimeMs > statSync(dist).mtimeMs,
+    );
+  } catch {
+    return false;
+  }
+}
+
+if (!shouldUseSourceFallback() && existsSync(distEntry)) {
   await import(pathToFileURL(distEntry).href);
 } else {
-  const sourceEntry = join(binDir, "../src/cli/index.ts");
   if (!existsSync(sourceEntry)) {
     console.error(
       "agent-native CLI build output is missing. Run `pnpm --filter @agent-native/core build` and try again.",

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.90.3",
+  "version": "0.90.5",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/agent/durable-background.ts

@@ -340,17 +340,17 @@ export function isAgentChatDurableBackgroundEnabled(options?: {
 }
 
 /**
- * Env flag for the FOREGROUND server-driven self-chain. DEFAULT-OFF (opt-in):
- * unset means disabled; an app opts IN with an explicit truthy value
- * (`true`/`1`/`yes`/`on`) — same parsing convention as
- * `AGENT_CHAT_DURABLE_BACKGROUND`, deliberately kept as a separate flag so
- * this narrower capability can be enabled/disabled independently of the full
- * durable-background worker path.
+ * Env flag for the FOREGROUND server-driven self-chain. DEFAULT-ON for hosted
+ * deployments with `A2A_SECRET`: unset/empty/unknown means enabled, and an app
+ * opts OUT with an explicit falsy value (`false`/`0`/`no`/`off`). Deliberately
+ * kept separate from `AGENT_CHAT_DURABLE_BACKGROUND` so this narrower
+ * capability can be disabled independently of the full durable-background
+ * worker path.
  */
 export const AGENT_CHAT_FOREGROUND_SELF_CHAIN_ENV =
   "AGENT_CHAT_FOREGROUND_SELF_CHAIN";
 
-function isForegroundSelfChainFlagEnabled(): boolean {
+function isForegroundSelfChainExplicitlyDisabled(): boolean {
   // Read the literal key (not `process.env[CONST]`) so guard:no-env-credentials
   // can statically verify it against the allowlisted `AGENT_*` prefix. Keep this
   // in sync with AGENT_CHAT_FOREGROUND_SELF_CHAIN_ENV.
@@ -358,26 +358,26 @@ function isForegroundSelfChainFlagEnabled(): boolean {
   if (raw == null) return false;
   const normalized = raw.trim().toLowerCase();
   return (
-    normalized === "1" ||
-    normalized === "true" ||
-    normalized === "yes" ||
-    normalized === "on"
+    normalized === "0" ||
+    normalized === "false" ||
+    normalized === "no" ||
+    normalized === "off"
   );
 }
 
 /**
- * Gate for the OPT-IN foreground self-chain: a normal (non-durable-background)
+ * Gate for the foreground self-chain: a normal (non-durable-background)
  * agent-chat turn that hits its soft-timeout chunk boundary continues via a
  * server-side self-dispatch on the REGULAR function (not a Netlify
  * `-background` function) instead of depending on the client to re-POST
  * `auto_continue`. Composes exactly like `isAgentChatDurableBackgroundEnabled`:
- * true only when the env flag is explicitly truthy AND the runtime is hosted
- * AND `A2A_SECRET` is configured (the HMAC handoff authenticates the
- * self-dispatch). False otherwise — and false means the existing
- * client-driven `auto_continue` re-POST path is used unchanged, byte-for-byte.
+ * true when the runtime is hosted AND `A2A_SECRET` is configured (the HMAC
+ * handoff authenticates the self-dispatch), unless the env flag is explicitly
+ * falsy. False otherwise — and false means the existing client-driven
+ * `auto_continue` re-POST path is used unchanged, byte-for-byte.
  *
  * Deliberately independent of `isAgentChatDurableBackgroundEnabled`: an app can
- * enable this narrower capability without opting into the full 15-min
+ * use this narrower capability without opting into the full 15-min
  * background-function worker path, and the two gates never need to agree.
  * When BOTH would be true for a given run, the durable-background dispatch
  * decision in `production-agent.ts` is evaluated first and takes precedence —
@@ -386,7 +386,7 @@ function isForegroundSelfChainFlagEnabled(): boolean {
  */
 export function isAgentChatForegroundSelfChainEnabled(): boolean {
   return (
-    isForegroundSelfChainFlagEnabled() &&
+    !isForegroundSelfChainExplicitlyDisabled() &&
     isHostedRuntimeForDurableBackground() &&
     hasConfiguredA2ASecret()
   );

package/corpus/core/src/agent/engine/ai-sdk-engine.ts

@@ -384,8 +384,14 @@ class AISDKEngine implements AgentEngine {
         type: "stop",
         reason: "error",
         error: err?.message ?? String(err),
-        ...(statusCode === 401 ? { errorCode: "http_401" } : {}),
-        ...(statusCode !== undefined ? { statusCode } : {}),
+        // Tag every known status with `http_<status>` (not just 401) so a
+        // rate limit surfaces as `http_429`. The structured statusCode
+        // already drives turn-level retries, but the run-level continuation
+        // logic keys off the errorCode, so this lets a rate-limited turn
+        // auto-resume too — matching the Builder gateway path.
+        ...(statusCode !== undefined
+          ? { errorCode: `http_${statusCode}`, statusCode }
+          : {}),
         ...(providerRetryable !== undefined ? { providerRetryable } : {}),
       };
       throw err;

package/corpus/core/src/agent/engine/anthropic-engine.ts

@@ -227,7 +227,17 @@ class AnthropicEngine implements AgentEngine {
         type: "stop",
         reason: "error",
         error: err?.message ?? String(err),
-        ...(statusCode === 401 ? { errorCode: "http_401", statusCode } : {}),
+        // Forward the provider HTTP status for EVERY known status, not just
+        // 401. The Anthropic SDK reports empty-body failures as a bare
+        // "429 status code (no body)" message, so without a structured
+        // statusCode/errorCode `isRetryableError` couldn't classify a rate
+        // limit (it matches "529"/"502" substrings but not "429") and the
+        // run failed hard instead of backing off + retrying like the Builder
+        // gateway path does. `http_429`/`http_529` also let the run-level
+        // continuation logic auto-resume a rate-limited turn.
+        ...(statusCode !== undefined
+          ? { errorCode: `http_${statusCode}`, statusCode }
+          : {}),
       };
       throw err;
     }

package/corpus/core/src/agent/engine/index.ts

@@ -25,6 +25,7 @@ export {
   getStoredModelForEngine,
   normalizeModelForEngine,
   detectEngineFromEnv,
+  detectEngineFromEnvForRequest,
   detectEngineFromUserSecrets,
   isAgentEngineSettingConfigured,
   isAgentEnginePackageInstalled,

package/corpus/core/src/agent/engine/registry.ts

@@ -156,6 +156,10 @@ function assertAgentEnginePackageInstalled(entry: AgentEngineEntry): void {
  * on the first pass, so an explicit provider key (ANTHROPIC_API_KEY etc.)
  * is picked instead. Builder is still used as the fallback when no other
  * provider key is set.
+ *
+ * This sync helper is for CLI/status callers that cannot await settings. Prefer
+ * {@link detectEngineFromEnvForRequest} at request time so sticky auth-failure
+ * markers can skip rejected deploy keys.
  */
 export function detectEngineFromEnv(): AgentEngineEntry | null {
   const preferByo = /^(1|true)$/i.test(
@@ -196,6 +200,59 @@ export function detectEngineFromEnv(): AgentEngineEntry | null {
   return null;
 }
 
+async function envKeyUsableForEntry(
+  entry: AgentEngineEntry,
+  key: string,
+): Promise<boolean> {
+  if (
+    !(
+      canUseDeployCredentialFallbackForRequest(key) &&
+      !!readDeployCredentialEnv(key)
+    )
+  ) {
+    return false;
+  }
+  if (entry.name === "builder") {
+    return true;
+  }
+  const value = readDeployCredentialEnv(key);
+  if (!value) return false;
+  return !(await getProviderCredentialAuthFailure({ key, value }));
+}
+
+async function hasUsableEnvKeys(entry: AgentEngineEntry): Promise<boolean> {
+  if (!isAgentEnginePackageInstalled(entry)) return false;
+  if (entry.requiredEnvVars.length === 0) return false;
+  for (const key of entry.requiredEnvVars) {
+    if (!(await envKeyUsableForEntry(entry, key))) return false;
+  }
+  return true;
+}
+
+/**
+ * Request-aware env auto-detect. Same priority as {@link detectEngineFromEnv},
+ * but skips provider keys that currently have an auth-failure marker so a
+ * rejected deploy key does not permanently win selection and leave chat stuck
+ * on `missing_credentials`.
+ */
+export async function detectEngineFromEnvForRequest(): Promise<AgentEngineEntry | null> {
+  const preferByo = /^(1|true)$/i.test(
+    process.env.AGENT_ENGINE_PREFER_BYO_KEY ?? "",
+  );
+
+  if (preferByo) {
+    for (const entry of _registry.values()) {
+      if (entry.name === "builder") continue;
+      if (await hasUsableEnvKeys(entry)) return entry;
+    }
+  }
+
+  for (const entry of _registry.values()) {
+    if (await hasUsableEnvKeys(entry)) return entry;
+  }
+  return null;
+}
+
 function shouldTraceEngineDetection(): boolean {
   return /^(1|true)$/i.test(
     process.env.AGENT_NATIVE_DEBUG_AGENT_ENGINE_DETECT ??
@@ -399,6 +456,9 @@ async function engineCreateConfigForEntry(
  * AND an API key for it is reachable via the engine's required env vars.
  * Inline keys on the global settings row are ignored; see
  * `isAgentEngineSettingConfigured`.
+ *
+ * Sync helper for CLI/status. Prefer {@link isStoredEngineUsableForRequest}
+ * so sticky auth-failure markers are respected.
  */
 export function isStoredEngineUsable(
   stored: unknown,
@@ -618,8 +678,9 @@ export async function resolveEngine(
   }
 
   // 8. Auto-detect from any provider env var — so just dropping a key in
-  // .env works without also setting AGENT_ENGINE.
-  const detected = detectEngineFromEnv();
+  // .env works without also setting AGENT_ENGINE. Skip keys with active
+  // auth-failure markers so a rejected deploy key cannot permanently win.
+  const detected = await detectEngineFromEnvForRequest();
   if (detected) {
     return detected.create(await engineCreateConfigForEntry(detected, apiKey));
   }

package/corpus/core/src/agent/production-agent.ts

@@ -1132,6 +1132,7 @@ export function isRetryableError(err: unknown): boolean {
   return (
     code === "builder_gateway_error" ||
     code === "builder_gateway_network_error" ||
+    code === "http_429" ||
     code === "http_500" ||
     code === "http_502" ||
     code === "http_503" ||
@@ -1140,6 +1141,9 @@ export function isRetryableError(err: unknown): boolean {
     // Anthropic
     msg.includes("overloaded") ||
     msg.includes("rate_limit") ||
+    // Bare provider rate-limit messages that carry no structured status,
+    // e.g. the Anthropic/AI-SDK "429 status code (no body)" format.
+    /\b429\b/.test(msg) ||
     msg.includes("529") ||
     // OpenAI phrasing
     msg.includes("rate limit reached") ||
@@ -4620,8 +4624,8 @@ export const MAX_BACKGROUND_RUN_CONTINUATIONS = 20;
  * budget:
  *   - a durable-background WORKER run (`isBackgroundWorker`) — unconditional,
  *     unchanged from before; or
- *   - a FOREGROUND run when the opt-in `foregroundSelfChainEligible` flag is
- *     set (see `isAgentChatForegroundSelfChainEnabled` in
+ *   - a FOREGROUND run when the resolved `foregroundSelfChainEligible` gate is
+ *     true (see `isAgentChatForegroundSelfChainEnabled` in
  *     `durable-background.ts`) AND this specific run was never dispatched to
  *     the durable background worker (`dispatchedToBackground` false) — a run
  *     already headed to the durable background path chains via the
@@ -6189,12 +6193,12 @@ export function createProductionAgentHandler(
           turnId: effectiveTurnId,
         }
       : null;
-    // Opt-in (default-OFF) foreground self-chain: gated on the env flag AND
-    // this specific run never having been routed to the durable background
-    // worker. A run that WAS dispatched to background (`dispatchToBackground`)
-    // already has its recovery owned by the background circuit-breaker /
-    // `isBackgroundWorker` chain above — this flag must never double up with
-    // that path, only stand in for it on plain foreground turns. A persistent
+    // Foreground self-chain: gated on hosted runtime + A2A_SECRET, with an
+    // explicit env opt-out, AND this specific run never having been routed to
+    // the durable background worker. A run that WAS dispatched to background
+    // (`dispatchToBackground`) already has its recovery owned by the background
+    // circuit-breaker / `isBackgroundWorker` chain above — this flag must never
+    // double up with that path, only stand in for it on plain foreground turns. A persistent
     // threadId is required: the client discovers the pre-inserted successor
     // via `/runs/active?threadId` and the successor chunk resumes from the
     // thread's persisted thread_data — without a thread there is neither a
@@ -6302,8 +6306,8 @@ export function createProductionAgentHandler(
 
     // Wrap so the background worker is unblocked even when there is no app
     // onRunComplete / tracked-progress callback configured. Also installed for
-    // a foreground run eligible for the opt-in self-chain — that path needs
-    // this same wrapper to fire the continuation dispatch below.
+    // a foreground run eligible for self-chain — that path needs this same
+    // wrapper to fire the continuation dispatch below.
     const handleRunComplete =
       isBackgroundWorker || foregroundSelfChainEligible || baseHandleRunComplete
         ? async (run: ActiveRun) => {
@@ -6897,6 +6901,9 @@ export function createProductionAgentHandler(
         // assistant message. Falls back to the runId (turn == run) when the
         // client doesn't supply a turnId.
         turnId: effectiveTurnId,
+        dispatchMode: foregroundSelfChainEligible
+          ? "foreground-self-chain"
+          : "foreground",
       },
     );
 
@@ -6920,7 +6927,11 @@ export function createProductionAgentHandler(
     setResponseHeader(event, "Cache-Control", "no-cache");
     setResponseHeader(event, "Connection", "keep-alive");
     setResponseHeader(event, "X-Run-Id", runId);
-    setResponseHeader(event, "X-Dispatch-Mode", "foreground");
+    setResponseHeader(
+      event,
+      "X-Dispatch-Mode",
+      foregroundSelfChainEligible ? "foreground-self-chain" : "foreground",
+    );
 
     return stream;
   });

package/corpus/core/src/agent/run-manager.ts

@@ -264,6 +264,12 @@ export interface StartRunOptions {
    * and to disabled otherwise (local dev stays unbounded).
    */
   noProgressTimeoutMs?: number;
+  /**
+   * Lifecycle metadata persisted to `agent_runs.dispatch_mode` and surfaced to
+   * clients through `/runs/active`. This does not change run-manager behavior;
+   * callers use it to describe who owns continuation at hosted chunk boundaries.
+   */
+  dispatchMode?: "foreground" | "foreground-self-chain";
 }
 
 export interface ResolveRunSoftTimeoutOptions {
@@ -480,11 +486,16 @@ export function startRun(
   // Persist run to SQL without blocking the response. Keep the promise so
   // final status cannot race ahead of a slow initial INSERT and then get
   // overwritten by a late row stuck at status='running'.
-  const insertRunPromise = insertRun(runId, threadId, options?.turnId).catch(
-    (error) => {
-      captureRunPersistenceError(error, "insert-run");
-    },
-  );
+  const insertOptions = options?.dispatchMode
+    ? { dispatchMode: options.dispatchMode }
+    : undefined;
+  const insertRunPromise = (
+    insertOptions
+      ? insertRun(runId, threadId, options?.turnId, insertOptions)
+      : insertRun(runId, threadId, options?.turnId)
+  ).catch((error) => {
+    captureRunPersistenceError(error, "insert-run");
+  });
 
   // Per-run event persistence chain: events are chained so SQL inserts commit
   // in seq order. Without this, a fast seq=5 commit before a slow seq=4 means
@@ -1356,7 +1367,7 @@ export async function getActiveRunForThreadAsync(threadId: string): Promise<{
   status: string;
   heartbeatAt: number;
   lastProgressAt: number | null;
-  /** How the run was dispatched (NULL/foreground, background, background-processing). */
+  /** How the run was dispatched/continued (foreground, foreground-self-chain, background...). */
   dispatchMode?: string | null;
   /** Compact terminal classification, e.g. done, run_timeout, stale_run. */
   terminalReason?: string | null;

package/corpus/core/src/agent/run-store.ts

@@ -183,9 +183,11 @@ async function ensureRunTables(): Promise<void> {
           //                at completion so errored/cut-off runs are queryable for
           //                pattern analysis (see listErroredRuns).
           // dispatch_mode marks how a run was started: NULL/"foreground" for the
-          // normal synchronous path, "background" for a run dispatched into a
-          // Netlify background function. The reaper/claim widen the stale window
-          // for background rows so a slow cold-start isn't falsely reaped.
+          // normal client-continued synchronous path, "foreground-self-chain" for
+          // a foreground run whose continuation boundary is server-driven, and
+          // "background" for a run dispatched into a Netlify background function.
+          // The reaper/claim widen the stale window for background rows so a slow
+          // cold-start isn't falsely reaped.
           // diag_stage records the last reached pipeline stage (+ any error) for a
           // background-dispatched run so a silent worker death is DIAGNOSABLE from
           // the client (/runs/active surfaces it) without reading the unreadable
@@ -273,9 +275,11 @@ async function ensureRunTables(): Promise<void> {
       //                at completion so errored/cut-off runs are queryable for
       //                pattern analysis (see listErroredRuns).
       // dispatch_mode marks how a run was started: NULL/"foreground" for the
-      // normal synchronous path, "background" for a run dispatched into a
-      // Netlify background function. The reaper/claim widen the stale window
-      // for background rows so a slow cold-start isn't falsely reaped.
+      // normal client-continued synchronous path, "foreground-self-chain" for
+      // a foreground run whose continuation boundary is server-driven, and
+      // "background" for a run dispatched into a Netlify background function.
+      // The reaper/claim widen the stale window for background rows so a slow
+      // cold-start isn't falsely reaped.
       // diag_stage records the last reached pipeline stage (+ any error) for a
       // background-dispatched run so a silent worker death is DIAGNOSABLE from
       // the client (/runs/active surfaces it) without reading the unreadable
@@ -420,7 +424,7 @@ export async function insertRun(
   threadId: string,
   turnId?: string,
   options?: {
-    dispatchMode?: "foreground" | "background";
+    dispatchMode?: "foreground" | "foreground-self-chain" | "background";
     /**
      * JSON-serialized request body for a background dispatch. Persisted on the
      * run row so the self-POST to the background function carries only the
@@ -456,10 +460,11 @@ export async function insertRun(
  * subtracted by the resolved window so the comparison is
  * `COALESCE(heartbeat_at, started_at) < (now - window)`.
  *
- * `dispatch_mode` is one of NULL/"foreground" (normal sync path), "background"
- * (foreground inserted the row for a background dispatch), or
- * "background-processing" (the background worker claimed it). Both background
- * states get the wider window via a LIKE-prefix match.
+ * `dispatch_mode` is one of NULL/"foreground" (normal client-continued sync
+ * path), "foreground-self-chain" (server-driven continuation at the foreground
+ * chunk boundary), "background" (foreground inserted the row for a background
+ * dispatch), or "background-processing" (the background worker claimed it). Both
+ * background states get the wider window via a LIKE-prefix match.
  */
 function backgroundAwareStaleCutoffSql(): string {
   // `CAST(? AS BIGINT)` is required: without it Postgres infers the param as

package/corpus/core/src/cli/create.ts

@@ -27,6 +27,12 @@ const STANDALONE_EXACT_DEPENDENCY_OVERRIDES: Record<string, string> = {
   "@react-router/fs-routes": "8.1.0",
   "react-router": "8.1.0",
 };
+const REACT_ROUTER_BUILD_DEPENDENCIES = [
+  "@react-router/dev",
+  "@react-router/fs-routes",
+  "react-router",
+  "vite",
+] as const;
 const SENTRY_MINIMUM_RELEASE_AGE_EXCLUDES = ['"@sentry/*"'];
 const FIRST_PARTY_TARBALL_SYMLINK_EXCLUDES = [
   "*/CLAUDE.md",
@@ -1045,6 +1051,7 @@ function postProcessStandalone(
       // under pnpm 10+ without prompting for `pnpm approve-builds`.
       pkg.dependencies = pkg.dependencies ?? {};
       pkg.dependencies.postgres ??= POSTGRES_DEPENDENCY_VERSION;
+      ensureReactRouterBuildDependencies(pkg);
 
       const requiredBuilt = ["better-sqlite3", "esbuild", "node-pty"];
       if (!pkg.pnpm || typeof pkg.pnpm !== "object") {
@@ -1105,6 +1112,34 @@ function postProcessStandalone(
   setupAgentSymlinks(targetDir);
 }
 
+function ensureReactRouterBuildDependencies(pkg: Record<string, any>): void {
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies,
+  };
+  if (
+    !allDeps["@react-router/dev"] &&
+    !allDeps["react-router"] &&
+    !allDeps["@react-router/fs-routes"]
+  ) {
+    return;
+  }
+
+  pkg.dependencies = pkg.dependencies ?? {};
+  for (const key of REACT_ROUTER_BUILD_DEPENDENCIES) {
+    const existing =
+      pkg.dependencies[key] ??
+      pkg.devDependencies?.[key] ??
+      pkg.peerDependencies?.[key];
+    if (!existing) continue;
+    pkg.dependencies[key] =
+      STANDALONE_EXACT_DEPENDENCY_OVERRIDES[key] ?? existing;
+    delete pkg.devDependencies?.[key];
+    delete pkg.peerDependencies?.[key];
+  }
+}
+
 function fixStandaloneTsconfig(targetDir: string, templateName?: string): void {
   const tsconfigPath = path.join(targetDir, "tsconfig.json");
   if (!fs.existsSync(tsconfigPath)) return;