@agent-native/core 0.73.0 → 0.75.0

package/corpus/README.md

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

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,72 @@
 # @agent-native/core
 
+## 0.75.0
+
+### Minor Changes
+
+- 1272755: Durable background agent-chat runs now complete cleanly instead of looping at
+  the 60s Netlify wall.
+  - The Netlify `-background` function (15-min async budget) is now emitted by
+    default. The deploy gates (`isDurableBackgroundDeployEnabled` in
+    `deploy/build.ts` and `deploy/workspace-deploy.ts`) are inverted to default-ON
+    to match the runtime gate — unset/empty means enabled; opt out with a falsy
+    `AGENT_CHAT_DURABLE_BACKGROUND` (`false`/`0`/`no`/`off`). This makes the chat
+    `_process-run` self-dispatch land on the real 15-min async function, so the
+    worker runs with its full budget (and likely fixes the app-specific dispatch
+    fast-fail, since the self-POST now hits an instant-202 async function).
+  - The run soft-timeout is now tied to the REAL function budget rather than
+    merely "I am the background worker." A new `isInBackgroundFunctionRuntime()`
+    guard (the Lambda function name ends in `-background`) gates the ~13-min
+    soft-timeout. A worker that lands on the regular ~60s function — or the
+    graceful inline fallback running in the foreground ~60s function — keeps the
+    ~40s soft-timeout and checkpoints before the hard wall instead of overshooting
+    and re-dispatching in a loop.
+  - Server-driven continuation stays on for every durable worker so a run survives
+    the client disconnecting (closed tab): a worker on the regular ~60s function (a
+    Netlify routing miss, or a non-Netlify host with no `-background` function)
+    self-chains 40s chunks, while a worker in a real `-background` function chains
+    ~13-min chunks. Only the per-chunk budget differs by function type; the
+    continuation is always server-driven.
+
+## 0.74.0
+
+### Minor Changes
+
+- 4a0d3c4: Durable background agent runs are robust again, and **on by default** for hosted apps.
+  - **Graceful inline fallback (the safety fix).** When the foreground turn can't
+    hand off to a background worker — the HMAC self-dispatch self-POST fails fast,
+    e.g. a connection error or a non-2xx returned within the settle window — the
+    agent-chat handler no longer breaks the chat with
+    `Failed to dispatch background run`. It now degrades to a normal synchronous
+    (inline) run, reusing the already-inserted run row. The run is claimed
+    atomically (`claimBackgroundRun`, a conditional `dispatch_mode: background →
+background-processing` UPDATE) before running inline, so the SQL atomic claim
+    is the single owner — a delayed background delivery that arrives afterward
+    loses the claim and no-ops, and the run can never double-execute. A dispatch
+    that _did_ land (so a worker already owns the run) still streams the worker's
+    events instead of running a second copy.
+  - **Default-on, safely.** `AGENT_CHAT_DURABLE_BACKGROUND` is now opt-out for
+    hosted apps: unset/empty/unknown counts as enabled; opt a specific app back
+    out with an explicit falsy value (`false`/`0`/`no`/`off`). The gate still
+    composes with the existing guards, so a run only goes durable when the runtime
+    is hosted/serverless **and** `A2A_SECRET` is configured — local dev and
+    unconfigured apps stay on the synchronous inline path unchanged. Default-on is
+    safe precisely because a failed dispatch degrades to a working inline run. The
+    Netlify 15-min `-background` function emit (`isDurableBackgroundDeployEnabled`)
+    remains opt-in until its path is separately verified; with it off, the
+    default-on baseline runs the worker through the standard function and
+    server-chains continuations.
+  - **More diagnosable dispatch errors.** Self-dispatch failures now log the
+    resolved base URL so a failure tied to which host the self-POST targets
+    (custom domain vs deploy URL) is visible in logs. The URL resolution order is
+    unchanged (it matches the working A2A/agent-teams self-dispatch paths).
+
+### Patch Changes
+
+- 4a0d3c4: Show numbered annotation markers in the annotated-code gutter, matching the diff
+  annotation affordance while preserving the hover popover behavior.
+- 4a0d3c4: Clarify Builder code-change handoff fallbacks when cloud agents are unavailable.
+
 ## 0.73.0
 
 ### Minor Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.73.0",
+  "version": "0.75.0",
   "type": "module",
   "engines": {
     "node": ">=22"

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

@@ -19,12 +19,20 @@
  * agent-chat handler must behave byte-for-byte like the current synchronous
  * path. The gate is true only when ALL of these hold:
  *   1. `AGENT_CHAT_DURABLE_BACKGROUND` env is not explicitly disabled. It is
- *      DEFAULT-ON: unset/empty counts as enabled; set it to a falsy value
- *      (`false`/`0`/`no`/`off`) to opt a specific app back out.
+ *      DEFAULT-ON: unset/empty/unknown counts as enabled; set it to a falsy
+ *      value (`false`/`0`/`no`/`off`) to opt a specific app back out.
  *   2. The runtime is hosted/serverless (local dev keeps the inline path so SSE
  *      stays a single live stream and no second function is needed).
  *   3. `A2A_SECRET` is configured (the HMAC handoff is required to authenticate
  *      the background dispatch; without it the dispatch can't be trusted).
+ *
+ * Default-on is safe because a *dispatch failure degrades to an inline run*: if
+ * the self-dispatch self-POST can't be delivered (fast connection error or
+ * fast non-2xx), the foreground handler runs the turn synchronously instead of
+ * erroring (see `production-agent.ts` — the inline fallback claims the run row
+ * atomically so a delayed delivery can never double-execute). So an app where
+ * durable dispatch happens to fail still gets a working chat, just without the
+ * 15-min budget.
  */
 import {
   hasConfiguredA2ASecret,
@@ -88,16 +96,54 @@ export function isHostedRuntimeForDurableBackground(): boolean {
   );
 }
 
+/**
+ * True when THIS process is actually executing inside a Netlify *background*
+ * function (the long, 15-min-budget async function whose deployed name ends in
+ * `-background`). Netlify runs functions on AWS Lambda and sets
+ * `AWS_LAMBDA_FUNCTION_NAME` to the function's name, so a `-background` suffix is
+ * the runtime proof that the ~60s synchronous wall does NOT apply here.
+ *
+ * This is the SAFETY GUARD for the soft-timeout regime. The `_process-run`
+ * self-dispatch worker (`isBackgroundWorker`) is NOT enough on its own: if the
+ * `-background` function was never emitted (deploy gate off, or Netlify routed
+ * the path to the synchronous function), the self-POST lands on the regular
+ * ~60s `server` function. A worker there MUST use the 40s soft-timeout and
+ * checkpoint before the 60s wall — using the ~13min budget would overshoot the
+ * hard wall and get killed at 60s, then re-dispatch/resume in a wasteful loop.
+ * So the 13-min budget is taken ONLY when this returns true.
+ *
+ * Falls back to the explicit `AGENT_CHAT_FORCE_BACKGROUND_RUNTIME` env (truthy)
+ * for hosts that don't expose a `-background`-suffixed function name but where
+ * the operator has confirmed a long async budget. Off by default.
+ */
+export function isInBackgroundFunctionRuntime(): boolean {
+  const lambdaName = process.env.AWS_LAMBDA_FUNCTION_NAME;
+  if (
+    typeof lambdaName === "string" &&
+    lambdaName.toLowerCase().endsWith("-background")
+  ) {
+    return true;
+  }
+  const forced = process.env.AGENT_CHAT_FORCE_BACKGROUND_RUNTIME;
+  if (forced != null) {
+    const v = forced.trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+  }
+  return false;
+}
+
 function isFlagEnabled(): 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_DURABLE_BACKGROUND_ENV.
   //
   // DEFAULT-ON: durable background runs are the desired behavior for every
-  // hosted app (verified in prod — long multi-step runs complete past the 40s
-  // soft-timeout with no thrash). So an unset flag means ON; an app opts OUT
-  // only with an explicit falsy value. This still composes with the hosted +
+  // hosted app. So an unset/empty/unknown flag means ON; an app opts OUT only
+  // with an explicit falsy value. This still composes with the hosted +
   // A2A_SECRET gates below, so non-hosted / unconfigured apps stay synchronous.
+  // Safety net: a failed dispatch degrades to a synchronous inline run (see
+  // production-agent.ts), so default-on cannot break chat even if the
+  // self-dispatch can't be delivered on a given app.
   const raw = process.env.AGENT_CHAT_DURABLE_BACKGROUND;
   if (raw == null) return true;
   const normalized = raw.trim().toLowerCase();

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

@@ -68,6 +68,7 @@ import {
   AGENT_CHAT_PROCESS_RUN_PATH,
   AGENT_CHAT_BACKGROUND_RUN_FIELD,
   isAgentChatDurableBackgroundEnabled,
+  isInBackgroundFunctionRuntime,
 } from "./durable-background.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { readBody } from "../server/h3-helpers.js";
@@ -3735,6 +3736,13 @@ export function createProductionAgentHandler(
         ? body[AGENT_CHAT_BACKGROUND_RUN_FIELD]!
         : null;
     const isBackgroundWorker = backgroundRunMarker !== null;
+    // Whether this worker is REALLY executing inside a 15-min Netlify
+    // `-background` function (proven by the runtime function name), not merely a
+    // `_process-run` re-entry that may have landed on the ~60s synchronous
+    // function. Only a true value unlocks the ~13-min soft-timeout budget; a
+    // worker on the 60s function keeps the 40s clamp and checkpoints cleanly.
+    const runsInBackgroundFunction =
+      isBackgroundWorker && isInBackgroundFunctionRuntime();
     // How many server-driven background continuations have already chained into
     // this logical turn (0 on the first chunk). Used to bound the chain.
     const backgroundContinuationCount =
@@ -4363,6 +4371,7 @@ export function createProductionAgentHandler(
     // change. With the flag OFF this whole branch is skipped and the inline
     // `startRun` path below runs exactly as before (byte-for-byte).
     if (dispatchToBackground) {
+      let backgroundRowInserted = false;
       try {
         // Insert the run row up front so /runs/active sees it immediately and
         // the slot stays held while the background function cold-starts. Mark
@@ -4370,6 +4379,7 @@ export function createProductionAgentHandler(
         await insertRun(runId, effectiveThreadId, effectiveTurnId, {
           dispatchMode: "background",
         });
+        backgroundRowInserted = true;
       } catch (err) {
         // A duplicate-PK collision means the row already exists (ret­ried POST);
         // any other failure means we can't safely hand off — fall back to the
@@ -4418,14 +4428,59 @@ export function createProductionAgentHandler(
         setResponseStatus(event, 500);
         return { error: "Failed to subscribe to background run" };
       }
-      // Dispatch failed before any worker could claim the run. Fail loud: flip
-      // the row terminal so the held slot is released (and any reconnect sees a
-      // terminal status instead of spinning), then 500 so the client can retry.
-      // We do NOT silently fall through to inline here — that risks a later,
-      // delayed background delivery double-executing the same runId.
-      await updateRunStatusIfRunning(runId, "errored").catch(() => {});
-      setResponseStatus(event, 500);
-      return { error: "Failed to dispatch background run" };
+
+      // ─── Dispatch failed → degrade to a normal synchronous (inline) run ────
+      // `fireInternalDispatch` throws ONLY when the self-POST failed *fast*
+      // (rejected the connection, or returned a non-2xx within the ~250ms settle
+      // race). The `_process-run` route verifies the HMAC token and validates
+      // the body BEFORE it ever reaches the SQL atomic claim, so a fast throw
+      // means NO background worker claimed this run — there is nothing to
+      // double-execute. Rather than break the chat with "Failed to dispatch
+      // background run", we run the turn inline (the same synchronous path the
+      // flag-off branch below takes), reusing the already-inserted run row.
+      //
+      // Safety against a (very improbable) delayed background delivery: claim the
+      // run atomically here via `claimBackgroundRun`, which flips the row's
+      // dispatch_mode `background → background-processing` in one conditional
+      // UPDATE. If a delayed dispatch DID land and a worker already won the
+      // claim, our claim returns false and we must NOT run inline (that would
+      // double-execute) — fall back to subscribing to the worker's run instead.
+      // The SQL atomic claim is the single source of truth for ownership, so at
+      // most one of {inline fallback, background worker} ever executes this run.
+      if (backgroundRowInserted) {
+        let claimedInline = false;
+        try {
+          claimedInline = await claimBackgroundRun(runId);
+        } catch (err) {
+          console.error(
+            "[agent-chat] inline-fallback claim failed:",
+            err instanceof Error ? err.message : err,
+          );
+        }
+        if (!claimedInline) {
+          // A background worker already owns this run (a delayed delivery landed
+          // after our fast throw). Stream its events instead of running a second
+          // copy. If we somehow can't subscribe, surface an error rather than
+          // risk a double-run.
+          const stream = subscribeToRun(runId, 0);
+          if (stream) {
+            setResponseHeader(event, "Content-Type", "text/event-stream");
+            setResponseHeader(event, "Cache-Control", "no-cache");
+            setResponseHeader(event, "Connection", "keep-alive");
+            setResponseHeader(event, "X-Run-Id", runId);
+            return stream;
+          }
+          await updateRunStatusIfRunning(runId, "errored").catch(() => {});
+          setResponseStatus(event, 500);
+          return { error: "Failed to dispatch background run" };
+        }
+        // We own the run. `startRun` (below) calls `insertRun` again, but its
+        // duplicate-PK collision is swallowed (`insertRun(...).catch(() => {})`),
+        // so the existing `background-processing` row is reused — no double row.
+      }
+      // Fall through to the inline `startRun` path below (the same one the
+      // flag-off branch uses). If the row was never inserted, `startRun` inserts
+      // it fresh; if it was, the claim above made us the sole owner.
     }
 
     const trackedProgressOwner =
@@ -4550,6 +4605,23 @@ export function createProductionAgentHandler(
               // user-stopped runs do NOT chain.
               if (
                 shouldChainBackgroundContinuation({
+                  // Self-chain server-side for EVERY durable worker, not only the
+                  // ones inside a `-background` function. Server-driven
+                  // continuation is the whole point of durable background: the run
+                  // must survive the client disconnecting (closed tab), so it
+                  // cannot depend on the browser re-POSTing `auto_continue`. A
+                  // worker on the regular ~60s function — a Netlify routing miss,
+                  // or a non-Netlify host (Vercel/Cloudflare/Render/Fly) that
+                  // never emits a `-background` function — checkpoints at the 40s
+                  // soft-timeout and self-dispatches the next 40s chunk; a worker
+                  // in a real `-background` function chains ~13-min chunks. Only
+                  // the per-chunk BUDGET differs by function type (gated by
+                  // `runsInBackgroundFunction` at the startRun call below); the
+                  // continuation itself must stay server-driven on both. (The
+                  // self-chain is only reachable when the initial dispatch already
+                  // succeeded — a dispatch fast-fail degrades to the inline
+                  // foreground fallback, which is not a worker and rides the
+                  // connected client's auto_continue instead.)
                   isBackgroundWorker,
                   run,
                   continuationCount: backgroundContinuationCount,
@@ -5008,10 +5080,18 @@ export function createProductionAgentHandler(
       {
         softTimeoutMs: options.runSoftTimeoutMs,
         useHostedSoftTimeoutDefault: true,
-        // Inside the Netlify background function there is no ~60s wall, so lift
-        // the soft-timeout clamp to ~13min for THIS run only. Foreground runs
-        // never set this, so their 40s clamp is unchanged.
-        backgroundFunction: isBackgroundWorker,
+        // Lift the soft-timeout clamp to ~13min ONLY when this run is actually
+        // executing inside a real Netlify `-background` function (15-min budget,
+        // no ~60s wall). Being the `_process-run` worker (`isBackgroundWorker`)
+        // is NOT sufficient: if the `-background` function wasn't emitted, or
+        // Netlify routed the self-POST to the synchronous function, the worker
+        // landed on the regular ~60s `server` function — there it MUST keep the
+        // 40s clamp and checkpoint before the wall, or it overshoots the 60s
+        // hard kill and re-dispatches in a loop. `runsInBackgroundFunction`
+        // gates the 13-min budget on the proven runtime, not merely on "I'm the
+        // worker." Foreground runs never set this, so their 40s clamp is
+        // unchanged.
+        backgroundFunction: runsInBackgroundFunction,
         // Fold continuation runs of one logical turn onto a single durable
         // assistant message. Falls back to the runId (turn == run) when the
         // client doesn't supply a turnId.

package/corpus/core/src/client/ConnectBuilderCard.tsx

@@ -7,6 +7,9 @@ import { cn } from "./utils.js";
 import { agentNativePath } from "./api-path.js";
 
 const DESKTOP_DOWNLOAD_URL = "https://www.agent-native.com/download";
+const CODE_CHANGE_FALLBACK_DETAIL =
+  "Edit locally or use Builder.io to edit this code in the cloud and continue customizing the app any way you like.";
+const CODE_CHANGE_FALLBACK_TEXT = `This requires a code change. ${CODE_CHANGE_FALLBACK_DETAIL}`;
 
 function isLocalBrowserOutsideDesktop() {
   if (typeof window === "undefined" || typeof navigator === "undefined") {
@@ -200,7 +203,7 @@ export function ConnectBuilderCard({
   // so the render tree below stays flat.
   const connectedCapabilityText = builderEnabled
     ? "AI credits and cloud code changes are ready to use."
-    : "AI credits are ready to use. Builder Cloud Agents for code changes are not available for this workspace yet.";
+    : `AI credits are ready to use. ${CODE_CHANGE_FALLBACK_TEXT}`;
   let title: string;
   let subtitle: React.ReactNode;
   if (runResult) {
@@ -215,20 +218,17 @@ export function ConnectBuilderCard({
       </>
     );
   } else if (showWaitlist) {
-    title = waitlistJoined
-      ? "You're on the waitlist"
-      : "Builder Cloud Agents coming soon";
+    title = "This requires a code change";
     subtitle = waitlistJoined ? (
       <>
-        We'll let you know when Builder Cloud Agents are available for this
-        workspace.{" "}
+        You're on the waitlist. {CODE_CHANGE_FALLBACK_DETAIL}{" "}
         {localBrowser
           ? "Since this project is already running locally, open it in the desktop app for local coding tools or keep editing from your clone."
           : "You can still clone the project locally and use the desktop app for code changes."}
       </>
     ) : (
       <>
-        You don't have access to Builder Cloud Agents for this workspace yet.{" "}
+        {CODE_CHANGE_FALLBACK_DETAIL}{" "}
         {localBrowser
           ? "Since this project is already running locally, open it in the desktop app for local coding tools or keep editing from your clone."
           : "You can still clone the project locally and use the desktop app for code changes."}

package/corpus/core/src/client/NewWorkspaceAppFlow.tsx

@@ -294,7 +294,7 @@ export function NewWorkspaceAppFlow({
         } else {
           setStatusMessage(
             result?.message ||
-              "Builder app creation is coming soon here. Open this workspace in Builder to create an app from this prompt.",
+              "This requires a code change. Edit locally or use Builder.io to edit this code in the cloud and continue customizing the app any way you like.",
           );
         }
       }

package/corpus/core/src/client/blocks/library/AnnotatedCodeBlock.tsx

@@ -16,6 +16,7 @@ import {
   AnnotationHiddenStack,
   AnnotationHoverCard,
   AnnotationInlineOverlayStack,
+  AnnotationGutterMarker,
   anchorFromElements,
   buildLineMarkerMap,
   hasRailAnnotations,
@@ -42,9 +43,9 @@ import { DevInput, DevLabel, DevTextarea } from "./dev-doc-ui.js";
  * pairs, so it reads correctly in BOTH light and dark mode. Code lines render as
  * `<span>`s (never one `<pre>` per line) so they don't pick up document
  * code/pre chrome. Lives in core so any app can register the dev-doc block.
- * Each annotated range also gets a small sticky glowing indicator at the top
- * right of its first line, making the hover affordance visible without a note
- * column.
+ * Each annotated range also gets a numbered marker in the left gutter on the
+ * first line, matching the diff block's annotation affordance without adding a
+ * persistent note column.
  *
  * Editing is panel-driven (config-style, like the diff/HTML blocks): a monospace
  * code Textarea, filename/language Inputs, and add/remove-able annotation rows.
@@ -283,6 +284,7 @@ function AnnotatedCodeRead({
     );
     const rangeStartMarkers =
       markers?.filter((item) => item.range?.start === lineNo) ?? [];
+    const showMarkerColumn = hasAnnotations;
 
     const buildAnchorForItem = (
       item: ResolvedAnnotation<AnnotatedCodeAnnotation>,
@@ -373,14 +375,13 @@ function AnnotatedCodeRead({
         <span className="w-11 shrink-0 select-none px-3 text-right text-[11px] tabular-nums text-plan-muted/60">
           {lineNo}
         </span>
-        <span className="flex-1 whitespace-pre pr-4 text-plan-code-text">
-          {highlightedLines[lineNo - 1]}
-        </span>
-        {rangeStartMarkers.length > 0 && (
+        {showMarkerColumn && (
           <span
             aria-hidden
-            className="sticky right-0.5 z-10 ml-2 flex h-[22px] shrink-0 items-center gap-1 self-start pr-0.5"
-            data-annotated-code-marker-stack
+            className="flex w-6 shrink-0 select-none items-center justify-center gap-1 py-0"
+            data-annotated-code-marker-stack={
+              rangeStartMarkers.length > 0 ? "" : undefined
+            }
           >
             {rangeStartMarkers.map((item) => (
               <span
@@ -394,24 +395,35 @@ function AnnotatedCodeRead({
                     ) ?? event.currentTarget;
                   openAnnotation(item, row);
                 }}
-                className="group inline-flex size-3 cursor-pointer items-center justify-center rounded-full outline-none transition-transform hover:scale-110"
+                onClick={(event) => {
+                  event.stopPropagation();
+                  const row =
+                    event.currentTarget.closest<HTMLElement>(
+                      "[data-code-line]",
+                    ) ?? event.currentTarget;
+                  openAnnotation(item, row);
+                }}
+                className="inline-flex cursor-pointer outline-none transition-transform hover:scale-110"
               >
-                <span
-                  className={cn(
-                    "block rounded-full ring-1 transition-all duration-150",
-                    activeIndex === item.index
-                      ? "size-[6px] bg-yellow-300 ring-yellow-200 shadow-[0_0_0_3px_rgba(250,204,21,0.30),0_0_16px_rgba(250,204,21,0.92)] dark:bg-yellow-200 dark:ring-yellow-100/70 dark:shadow-[0_0_0_3px_rgba(253,224,71,0.26),0_0_16px_rgba(253,224,71,0.76)]"
-                      : "size-1 bg-yellow-300/95 ring-yellow-200/65 shadow-[0_0_0_2px_rgba(250,204,21,0.18),0_0_11px_rgba(250,204,21,0.56)] group-hover:size-[6px] group-hover:bg-yellow-300 group-hover:ring-yellow-200 group-hover:shadow-[0_0_0_3px_rgba(250,204,21,0.30),0_0_16px_rgba(250,204,21,0.90)] dark:bg-yellow-200/78 dark:ring-yellow-100/38 dark:shadow-[0_0_0_2px_rgba(253,224,71,0.16),0_0_11px_rgba(253,224,71,0.46)] dark:group-hover:bg-yellow-200 dark:group-hover:ring-yellow-100/68 dark:group-hover:shadow-[0_0_0_3px_rgba(253,224,71,0.26),0_0_16px_rgba(253,224,71,0.74)]",
-                  )}
+                <AnnotationGutterMarker
+                  marker={item.marker}
+                  active={
+                    activeIndex === item.index ||
+                    persistentAnnotationIndexes.has(item.index)
+                  }
                 />
               </span>
             ))}
           </span>
         )}
+        <span className="flex-1 whitespace-pre pr-4 text-plan-code-text">
+          {highlightedLines[lineNo - 1]}
+        </span>
         {overlayItems.length > 0 && (
           <AnnotationInlineOverlayStack
             items={overlayItems}
             ctx={ctx}
+            showMarker
             containerRef={codeRef}
             mode={showAnnotationOverlays ? "capture" : "margin"}
             side={showAnnotationOverlays ? "right" : annotationMarginSide}
@@ -503,7 +515,9 @@ function AnnotatedCodeRead({
           live in a visually-hidden stack (a11y + tests) and surface ONE at a
           time as an on-hover popover anchored to the right of the code. */}
       {codeSurface}
-      {hasAnnotations && <AnnotationHiddenStack items={resolved} ctx={ctx} />}
+      {hasAnnotations && (
+        <AnnotationHiddenStack items={resolved} ctx={ctx} showMarker />
+      )}
       {hasAnnotations &&
         !showAnnotationOverlays &&
         !activeItemIsPersistentlyVisible &&
@@ -513,6 +527,7 @@ function AnnotatedCodeRead({
             item={activeItem}
             anchor={hover.anchor}
             ctx={ctx}
+            showMarker
             preferredSide={annotationHoverSide}
             hoverFallbackSide={annotationHoverFallbackSide}
             onMouseEnter={hover.cancelClose}

package/corpus/core/src/client/blocks/library/annotation-rail.tsx

@@ -26,11 +26,10 @@ import type { BlockRenderContext } from "../types.js";
  *    into stable, marker-numbered, range-resolved records and a line→markers map.
  *  - `rangeLabel` — the human "Line 8" / "Lines 3–6" label.
  *  - `AnnotationGutterMarker` — the numbered amber pip placed on an annotated row
- *    (used by the diff grid; the annotated-code surface uses its own rail bar).
+ *    by both the diff grid and the annotated-code gutter.
  *  - `AnnotationNoteRail` — the responsive list of note cards with two-way hover.
- *    `showMarker` opts the diff block into a leading numbered pip on each card so
- *    a note can be matched to its `①`/`②` row marker; annotated-code omits it to
- *    keep its original card chrome.
+ *    `showMarker` opts blocks into a leading numbered pip on each card so a note
+ *    can be matched to its `①`/`②` row marker.
  *
  * `AnnotatedCodeBlock` annotates a single code surface; `DiffBlock` annotates a
  * before/after grid (each annotation also carries a `side`). The shared types

package/corpus/core/src/client/components/CodeRequiredDialog.tsx

@@ -12,6 +12,8 @@ import { trackEvent } from "../analytics.js";
 import { withBuilderConnectTrackingParams } from "../settings/useBuilderStatus.js";
 
 const DESKTOP_DOWNLOAD_URL = "https://www.agent-native.com/download";
+const CODE_CHANGE_FALLBACK_DETAIL =
+  "Edit locally or use Builder.io to edit this code in the cloud and continue customizing the app any way you like.";
 
 export interface CodeRequiredDialogProps {
   open: boolean;
@@ -219,15 +221,10 @@ export function CodeRequiredDialog({
                 <IconExternalLink size={24} />
               </div>
               <div style={s.optionText}>
-                <span style={s.optionTitle}>
-                  Builder Cloud Agents coming soon
-                </span>
-                <span style={s.optionDesc}>
-                  You don't have access yet. Use the desktop app or your local
-                  clone for this code change.
-                </span>
+                <span style={s.optionTitle}>This requires a code change</span>
+                <span style={s.optionDesc}>{CODE_CHANGE_FALLBACK_DETAIL}</span>
               </div>
-              <span style={s.badge}>Coming soon</span>
+              <span style={s.badge}>Code change</span>
             </div>
           ) : (
             <a

package/corpus/core/src/deploy/build.ts

@@ -1480,14 +1480,25 @@ export function findInstalledResvgPackages(
 /**
  * Deploy-time gate for emitting the second `-background` Netlify function.
  * Reads the same env flag the runtime gate uses
- * (`AGENT_CHAT_DURABLE_BACKGROUND`). Off by default — when off, the deploy
- * emits exactly one function (today's behavior, byte-for-byte).
+ * (`AGENT_CHAT_DURABLE_BACKGROUND`).
+ *
+ * DEFAULT-ON, matching the runtime gate (`isFlagEnabled` in
+ * durable-background.ts): unset/empty/unknown means enabled; an app opts OUT
+ * only with an explicit falsy value (`false`/`0`/`no`/`off`). This is what
+ * actually emits the 15-min `-background` function so the `_process-run`
+ * dispatch lands on it (async 202 → the worker runs with the real 15-min budget
+ * → its ~13-min soft-timeout fits). The deploy gate and runtime gate MUST agree:
+ * if the deploy emitted no `-background` function but the runtime still routed
+ * the worker into the ~13-min timeout regime, the worker would overshoot the
+ * ~60s synchronous wall and re-dispatch in a loop. (The runtime now also guards
+ * the ~13-min budget on the real function name via `isInBackgroundFunctionRuntime`,
+ * so a missing emit degrades to clean 40s-chunked runs rather than the loop.)
  */
 export function isDurableBackgroundDeployEnabled(): boolean {
   const raw = process.env.AGENT_CHAT_DURABLE_BACKGROUND;
-  if (raw == null) return false;
+  if (raw == null) return true;
   const v = raw.trim().toLowerCase();
-  return v === "1" || v === "true" || v === "yes" || v === "on";
+  return !(v === "0" || v === "false" || v === "no" || v === "off");
 }
 
 /**
@@ -2018,11 +2029,12 @@ export default bundle;
     copyInstalledFfmpegStaticPackage(nitro.options.output.serverDir);
   }
 
-  // Durable background agent runs (off by default). Additive ONLY: emits a
-  // SECOND Netlify function whose name ends in `-background` re-exporting the
-  // same handler bundle, so the chat `_process-run` POST lands on Netlify's
-  // async (15-min) function. When the flag is off this is a no-op and the
-  // single-function deploy is byte-for-byte unchanged.
+  // Durable background agent runs (default-ON; opt out with a falsy
+  // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify
+  // function whose name ends in `-background` re-exporting the same handler
+  // bundle, so the chat `_process-run` POST lands on Netlify's async (15-min)
+  // function. When explicitly opted out this is a no-op and the single-function
+  // deploy is byte-for-byte unchanged.
   if (preset === "netlify" && isDurableBackgroundDeployEnabled()) {
     try {
       emitSingleTemplateNetlifyBackgroundFunction(cwd);

package/corpus/core/src/deploy/workspace-deploy.ts

@@ -667,8 +667,9 @@ function copyNetlifyFunctionIntoWorkspace(
   copyDir(src, dest);
   patchNetlifyFunctionEntry(dest, app, workspaceApps, staticDir);
 
-  // Durable background agent runs (off by default). Additive ONLY: when the
-  // flag is off this emits nothing and the single-function deploy is unchanged.
+  // Durable background agent runs (default-ON; opt out with a falsy
+  // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: when explicitly opted out
+  // this emits nothing and the single-function deploy is unchanged.
   if (isDurableBackgroundDeployEnabled()) {
     emitNetlifyBackgroundFunction(workspaceRoot, app, src, workspaceApps);
   }
@@ -677,14 +678,19 @@ function copyNetlifyFunctionIntoWorkspace(
 /**
  * Deploy-time gate for emitting the second `-background` Netlify function. Reads
  * the same env flag the runtime gate uses (`AGENT_CHAT_DURABLE_BACKGROUND`).
- * Off by default — when off, the deploy emits exactly one function per app
- * (today's behavior, byte-for-byte).
+ *
+ * DEFAULT-ON, matching the runtime gate (`isFlagEnabled` in
+ * durable-background.ts) and the single-template gate
+ * (`isDurableBackgroundDeployEnabled` in deploy/build.ts): unset/empty/unknown
+ * means enabled; an app opts OUT only with an explicit falsy value
+ * (`false`/`0`/`no`/`off`). This emits the per-app 15-min `-background` function
+ * so the chat `_process-run` dispatch lands on it with the real long budget.
  */
 function isDurableBackgroundDeployEnabled(): boolean {
   const raw = process.env.AGENT_CHAT_DURABLE_BACKGROUND;
-  if (raw == null) return false;
+  if (raw == null) return true;
   const v = raw.trim().toLowerCase();
-  return v === "1" || v === "true" || v === "yes" || v === "on";
+  return !(v === "0" || v === "false" || v === "no" || v === "off");
 }
 
 /**