@agent-native/core 0.70.3 → 0.72.0

package/corpus/core/src/audit/types.ts

@@ -0,0 +1,125 @@
+/**
+ * Types for the framework audit log.
+ *
+ * The audit log is a durable, complete, access-scoped, append-only record of
+ * *who mutated what app data, when, from where, and — when it was the agent —
+ * in which run*. It is deliberately distinct from observability (sampled
+ * agent-run telemetry) and tracking (fire-and-forget product analytics): audit
+ * rows are complete, locally queryable, and scoped to the data they describe.
+ *
+ * Capture happens automatically at the action-execution seam (`defineAction`):
+ * every mutating action records an audit event after it runs. Read-only (GET /
+ * `readOnly`) actions are skipped unless they opt in via `audit.onRead`.
+ */
+
+/** Outcome of an audited action call. */
+export type AuditStatus = "success" | "error" | "denied";
+
+/**
+ * Who performed the mutation.
+ * - `agent` — the in-app assistant / sub-agents / A2A (caller `"tool"`).
+ * - `human` — a person via the UI, HTTP, CLI, or an external MCP client.
+ * - `system` — no resolved identity (background jobs, schedules).
+ */
+export type AuditActorKind = "agent" | "human" | "system";
+
+export type AuditVisibility = "private" | "org" | "public";
+
+/**
+ * The resource an action mutated, plus the ownership used to scope who can
+ * read the resulting audit event. Returned by an action's `audit.target`.
+ *
+ * `ownerEmail` / `orgId` / `visibility` default to the actor's identity when
+ * omitted, which is correct for the common case where a user mutates their own
+ * data. Provide them explicitly when a user edits a resource owned by someone
+ * else so the *owner* sees the change in their audit trail.
+ */
+export interface AuditTarget {
+  type?: string;
+  id?: string;
+  ownerEmail?: string | null;
+  orgId?: string | null;
+  visibility?: AuditVisibility;
+}
+
+/** Metadata about the call, passed to `audit.target` / `audit.summary`. */
+export interface AuditCallMeta {
+  status: AuditStatus;
+  caller: string;
+  userEmail?: string;
+  orgId?: string | null;
+}
+
+/**
+ * Per-action audit configuration, set on `defineAction({ audit })`.
+ *
+ * Audit is **default-on for mutating actions** — you only need this object to
+ * *tune* capture (declare the target, customize the summary) or to opt a
+ * read-only action in / a noisy action out.
+ */
+export interface ActionAuditConfig {
+  /**
+   * Force audit on (`true`) or off (`false`). Overrides every default,
+   * including the read-only skip and the high-frequency denylist. When
+   * omitted, mutating actions are audited and read-only actions are not.
+   */
+  enabled?: boolean;
+  /**
+   * Audit this action even though it is read-only (GET). Use for sensitive
+   * reads worth recording — secret access, bulk export. Ignored when
+   * `enabled` is set explicitly.
+   */
+  onRead?: boolean;
+  /** Capture the (redacted) call arguments. Default `true`. */
+  recordInputs?: boolean;
+  /** Resolve the mutated resource + its ownership for scoped reads. */
+  target?: (
+    args: any,
+    result: unknown,
+    meta: AuditCallMeta,
+  ) => AuditTarget | null | undefined;
+  /** Build a short human-readable summary line for the event. */
+  summary?: (args: any, result: unknown, meta: AuditCallMeta) => string;
+}
+
+/** A persisted audit event. */
+export interface AuditEvent {
+  id: string;
+  createdAt: number;
+  /** Action name (the registry key, e.g. `delete-recording`). */
+  action: string;
+  /** Invocation surface: tool | frontend | http | cli | mcp | a2a. */
+  caller: string;
+  actorKind: AuditActorKind;
+  /** Human on whose behalf it ran — populated even for agent calls. */
+  actorEmail: string | null;
+  orgId: string | null;
+  /** Agent conversation thread, when caller is the agent loop. */
+  threadId: string | null;
+  /** Agent turn that produced the mutation — the unit of one agent response. */
+  turnId: string | null;
+  targetType: string | null;
+  targetId: string | null;
+  status: AuditStatus;
+  summary: string | null;
+  /** Redacted JSON of the call arguments, or null. */
+  input: string | null;
+  errorCode: string | null;
+  /** Denormalized owner used to scope reads (defaults to the actor). */
+  ownerEmail: string | null;
+  visibility: AuditVisibility;
+}
+
+/** Filters for `queryAuditEvents`. */
+export interface AuditQueryFilters {
+  targetType?: string;
+  targetId?: string;
+  actorKind?: AuditActorKind;
+  actorEmail?: string;
+  status?: AuditStatus;
+  threadId?: string;
+  turnId?: string;
+  action?: string;
+  sinceMs?: number;
+  limit?: number;
+}

package/corpus/core/src/chat-threads/store.ts

@@ -1,5 +1,6 @@
 import crypto from "node:crypto";
 import { getDbExec, intType } from "../db/client.js";
+import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
 import {
   mergeThreadDataForClientSave,
   normalizeThreadRepository,
@@ -87,6 +88,15 @@ async function ensureTable(): Promise<void> {
           // Column already exists.
         }
       }
+      // Widen millisecond-timestamp columns that older deployments created as
+      // 32-bit `INTEGER`; on Postgres the `Date.now()` written on every turn
+      // overflows int4. No-op once widened / on fresh BIGINT databases.
+      await widenIntColumnsToBigInt("chat_threads", [
+        "created_at",
+        "updated_at",
+        "pinned_at",
+        "archived_at",
+      ]);
       // Indexes for the hot read paths. Both the sidebar list and the
       // scoped/per-resource list filter on owner_email (and optionally
       // scope) and sort by updated_at. Keep these dialect-agnostic (no

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

@@ -1072,6 +1072,18 @@ function AgentPanelInner({
             </button>
           </DropdownMenuTrigger>
           <DropdownMenuContent align="end" sideOffset={6} className="w-48">
+            {onCollapse && (
+              <>
+                <DropdownMenuItem onSelect={onCollapse}>
+                  <IconLayoutSidebarRightCollapse
+                    size={14}
+                    className="shrink-0"
+                  />
+                  Collapse sidebar
+                </DropdownMenuItem>
+                <DropdownMenuSeparator />
+              </>
+            )}
             {mode === "chat" && toggleHistory && (
               <DropdownMenuItem onSelect={toggleHistory}>
                 <IconHistory size={14} className="shrink-0" />
@@ -1133,15 +1145,6 @@ function AgentPanelInner({
                 {isFullscreen ? "Exit fullscreen" : "Fullscreen"}
               </DropdownMenuItem>
             )}
-            {onCollapse && (
-              <DropdownMenuItem onSelect={onCollapse}>
-                <IconLayoutSidebarRightCollapse
-                  size={14}
-                  className="shrink-0"
-                />
-                Collapse sidebar
-              </DropdownMenuItem>
-            )}
             {((mode === "chat" && activeTabId) ||
               (mode === "cli" && canUseCodeTools && activeCliTab)) && (
               <>

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

@@ -151,6 +151,7 @@ import {
   getRepoMessages,
   getRepoMessage,
   shouldImportServerThreadData,
+  dedupeRepoMessagesById,
 } from "./chat/repo-helpers.js";
 
 export {
@@ -829,6 +830,11 @@ export function clearChatStorage(tabId?: string) {
  * messages missing these fields crash.
  */
 function ensureMessageMetadata(repo: any): any {
+  // Drop duplicate message ids before import — assistant-ui's MessageRepository
+  // throws "performOp/link: A message with the same id already exists in the
+  // parent tree" (Sentry AGENT-NATIVE-BROWSER-2Q) when fed repeated ids. No-op
+  // for the normal no-duplicate case. See dedupeRepoMessagesById.
+  repo = dedupeRepoMessagesById(repo);
   if (!repo?.messages || !Array.isArray(repo.messages)) return repo;
   for (const entry of repo.messages) {
     // Handle both wrapped ({ message: { ... } }) and flat ({ role, ... }) formats

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

@@ -119,6 +119,10 @@ interface FolderNode {
   /** Full slash path of the folder, used as a stable key. */
   path: string;
   children: TreeNode[];
+  /** Present when the folder was authored as an explicit directory entry (a
+   * `path` ending in `/`), carrying its note/metadata + flat `entries` index. */
+  entry?: FileTreeEntry;
+  index?: number;
 }
 
 type TreeNode = FolderNode | FileLeaf;
@@ -136,6 +140,10 @@ interface FolderBuild {
   files: FileLeaf[];
   /** Insertion order of child names (folders + files) for stable rendering. */
   order: string[];
+  /** Set when an explicit directory entry (trailing slash) targets this folder,
+   * carrying its note/metadata + flat `entries` index. */
+  entry?: FileTreeEntry;
+  index?: number;
 }
 
 function makeFolder(name: string, path: string): FolderBuild {
@@ -154,8 +162,15 @@ function buildTree(entries: FileTreeEntry[]): TreeNode[] {
   entries.forEach((entry, index) => {
     const segments = entry.path.split("/").filter(Boolean);
     if (segments.length === 0) return;
-    const fileName = segments[segments.length - 1] as string;
-    const folderSegments = segments.slice(0, -1);
+
+    // A trailing slash marks a DIRECTORY entry: every segment is a folder and
+    // the entry's note/metadata attaches to the deepest folder (the last segment
+    // does NOT become a file leaf). Because folders are keyed by name, this also
+    // merges with any folder the sibling file paths already implied — so
+    // `packages/shared/` and `packages/shared/src/…` collapse onto one `shared`
+    // folder instead of a duplicate folder + file pair.
+    const isDir = /\/\s*$/.test(entry.path);
+    const folderSegments = isDir ? segments : segments.slice(0, -1);
 
     let cursor = root;
     let prefix = "";
@@ -170,6 +185,17 @@ function buildTree(entries: FileTreeEntry[]): TreeNode[] {
       cursor = next;
     }
 
+    if (isDir) {
+      // Attach metadata to the deepest folder (first declaration wins, so an
+      // explicit note isn't clobbered by a later bare prefix re-declaration).
+      if (!cursor.entry) {
+        cursor.entry = entry;
+        cursor.index = index;
+      }
+      return;
+    }
+
+    const fileName = segments[segments.length - 1] as string;
     cursor.files.push({
       kind: "file",
       name: fileName,
@@ -191,6 +217,8 @@ function buildTree(entries: FileTreeEntry[]): TreeNode[] {
           name: child.name,
           path: child.path,
           children: materialize(child),
+          entry: child.entry,
+          index: child.index,
         });
       } else {
         const file = folder.files[Number(key.slice(2))];
@@ -212,7 +240,16 @@ function compactFolderNode(folder: FolderNode): FolderNode {
   let path = folder.path;
   let children = folder.children;
 
-  while (children.length === 1 && children[0]?.kind === "folder") {
+  // Collapse single-child folder chains (a/b/c) into one row — but never across
+  // a folder that carries its own directory note, so an explicitly authored
+  // directory (e.g. `packages/shared/` with a note) keeps its own row instead of
+  // being folded into its parent or child and losing the note.
+  while (
+    !folder.entry &&
+    children.length === 1 &&
+    children[0]?.kind === "folder" &&
+    !children[0].entry
+  ) {
     const child = children[0];
     names.push(child.name);
     path = child.path;
@@ -223,6 +260,8 @@ function compactFolderNode(folder: FolderNode): FolderNode {
     kind: "folder",
     name: names.join("/"),
     path,
+    entry: folder.entry,
+    index: folder.index,
     children: compactTree(children),
   };
 }
@@ -353,30 +392,49 @@ export function FileTreeRead({
     const indent = depth * INDENT_STEP;
     if (node.kind === "folder") {
       const collapsed = collapsedFolders[node.path] ?? false;
+      // An explicit directory entry (trailing-slash path) can be a leaf folder
+      // with no children — e.g. `apps/mail/`. It still renders as a folder, just
+      // without a toggle chevron. Its authored note shows inline like a file's.
+      const expandable = node.children.length > 0;
+      const note = node.entry?.note?.trim();
+      const open = expandable && !collapsed;
       return (
         <div key={`d:${node.path}`}>
           <button
             type="button"
             data-plan-interactive
-            aria-expanded={!collapsed}
-            onClick={() => toggleFolder(node.path)}
+            disabled={!expandable}
+            aria-expanded={expandable ? !collapsed : undefined}
+            onClick={expandable ? () => toggleFolder(node.path) : undefined}
             style={{ paddingLeft: indent + 8 }}
-            className="flex w-full items-center gap-1.5 rounded-md py-1 pr-2 text-left text-[13px] transition-colors hover:bg-accent/40"
+            className={cn(
+              "flex w-full items-center gap-1.5 rounded-md py-1 pr-2 text-left text-[13px] transition-colors",
+              expandable ? "hover:bg-accent/40" : "cursor-default",
+            )}
           >
-            <IconChevronRight
-              className={cn(
-                "size-3.5 shrink-0 text-plan-muted transition-transform",
-                !collapsed && "rotate-90",
-              )}
-            />
-            {collapsed ? (
-              <IconFolder className="size-4 shrink-0 text-plan-muted" />
+            {expandable ? (
+              <IconChevronRight
+                className={cn(
+                  "size-3.5 shrink-0 text-plan-muted transition-transform",
+                  !collapsed && "rotate-90",
+                )}
+              />
             ) : (
+              <span className="size-3.5 shrink-0" aria-hidden />
+            )}
+            {open ? (
               <IconFolderOpen className="size-4 shrink-0 text-plan-muted" />
+            ) : (
+              <IconFolder className="size-4 shrink-0 text-plan-muted" />
             )}
             <span className="min-w-0 truncate font-medium text-plan-text">
               {node.name}
             </span>
+            {note && (
+              <span className="ml-1 min-w-0 flex-1 truncate text-xs text-plan-muted">
+                {note}
+              </span>
+            )}
           </button>
         </div>
       );

package/corpus/core/src/client/chat/repo-helpers.ts

@@ -56,6 +56,44 @@ export function getRepoMessage(entry: RepoEntry): RepoMessage | null {
   return (entry?.message ?? entry) as RepoMessage | null;
 }
 
+/**
+ * Collapse duplicate message ids before a repository is handed to
+ * `threadRuntime.import()`. assistant-ui's `MessageRepository` throws
+ * "MessageRepository(performOp/link): A message with the same id already exists
+ * in the parent tree" when the imported messages contain the same id more than
+ * once (Sentry AGENT-NATIVE-BROWSER-2Q). Duplicate ids are never valid thread
+ * data — they come from optimistic+echo races, streaming reconnect replays, or
+ * multi-tab merges — so keep only the LAST occurrence of each id (the most
+ * recent, most complete copy). parentId references stay valid because the
+ * surviving entry keeps the same id.
+ *
+ * Returns the input unchanged (same reference) when there are no duplicates, so
+ * the overwhelmingly common no-dupe case is a cheap no-op with zero behavioural
+ * change for normal threads.
+ */
+export function dedupeRepoMessagesById<T extends NormalizedRepo>(
+  repo: T | null | undefined,
+): T | null | undefined {
+  if (!repo || !Array.isArray(repo.messages)) return repo;
+  const entries = repo.messages;
+  const lastIndexById = new Map<string, number>();
+  let hasDuplicate = false;
+  entries.forEach((entry, index) => {
+    const id = getRepoMessage(entry)?.id;
+    if (typeof id !== "string" || !id) return;
+    if (lastIndexById.has(id)) hasDuplicate = true;
+    lastIndexById.set(id, index);
+  });
+  if (!hasDuplicate) return repo;
+  const deduped = entries.filter((entry, index) => {
+    const id = getRepoMessage(entry)?.id;
+    // Keep id-less entries untouched; for duplicated ids keep only the last.
+    if (typeof id !== "string" || !id) return true;
+    return lastIndexById.get(id) === index;
+  });
+  return { ...repo, messages: deduped };
+}
+
 export function isAssistantMessageTerminal(
   message: RepoMessage | null,
 ): boolean {

package/corpus/core/src/db/client.ts

@@ -318,6 +318,10 @@ export function intType(): string {
   return isPostgres() ? "BIGINT" : "INTEGER";
 }
 
+// `widenIntColumnsToBigInt` lives in `./widen-columns.js` (it depends only on
+// `isPostgres`/`getDbExec` from here) so stores can import it without every
+// `vi.mock("./client.js")` test having to stub the export.
+
 // ---------------------------------------------------------------------------
 // Parameter conversion: ? -> $1, $2, $3
 // ---------------------------------------------------------------------------

package/corpus/core/src/db/widen-columns.ts

@@ -0,0 +1,75 @@
+/**
+ * In-place widening of legacy 32-bit `integer` columns to 64-bit `BIGINT` on
+ * Postgres.
+ *
+ * Lives in its own module (rather than `client.js`) so that stores can import
+ * it without every `vi.mock("../db/client.js")` test needing to stub it: the
+ * helper resolves `isPostgres()` / `getDbExec()` through `client.js`, so a test
+ * that mocks the client to SQLite (`isPostgres: () => false`) makes this a
+ * no-op automatically.
+ */
+
+import { isPostgres, getDbExec, type DbExec } from "./client.js";
+
+const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * Widen pre-existing 32-bit `integer` columns to 64-bit `BIGINT` in place on
+ * Postgres. No-op on SQLite, whose `INTEGER` is already 64-bit.
+ *
+ * Several stores historically created millisecond-timestamp columns (e.g.
+ * `agent_runs.started_at`, `application_state.updated_at`) as a literal
+ * `INTEGER`. On Postgres that is int4 (max 2,147,483,647), so a millisecond
+ * epoch such as 1782269273204 overflows with:
+ *   `value "1782269273204" is out of range for type integer`
+ * The CREATE TABLE source was later switched to `intType()` (BIGINT on PG),
+ * but `CREATE TABLE IF NOT EXISTS` cannot re-type a column that already
+ * exists, so long-lived Neon databases keep the int4 column and every write
+ * into it fails. (Migrations don't hit this — the migration runner rewrites
+ * `INTEGER` → `BIGINT` for Postgres; only raw `ensureTable()` CREATE strings
+ * that predate `intType()` are affected.)
+ *
+ * This widens such columns once, then no-ops: it only ALTERs columns whose
+ * current type is `integer`, so already-bigint tables are never rewritten.
+ * Widening int4 → int8 is additive and non-destructive (no data loss, no
+ * narrowing), so it is safe to run unconditionally on every boot.
+ *
+ * Call from a store's `ensureTable()` right after its `CREATE TABLE IF NOT
+ * EXISTS`, passing the millisecond-timestamp columns for that table. Pass the
+ * UNQUALIFIED table name (the lookup is scoped to the `public` schema); the
+ * `ALTER` resolves the table through the search path.
+ */
+export async function widenIntColumnsToBigInt(
+  table: string,
+  columns: string[],
+  // Injectable for tests; production callers use the configured client.
+  injectedClient?: DbExec,
+): Promise<void> {
+  if (!isPostgres() || columns.length === 0) return;
+  if (!PLAIN_IDENTIFIER.test(table)) return;
+  const client = injectedClient ?? getDbExec();
+  let int4Columns: Set<string>;
+  try {
+    const { rows } = await client.execute({
+      sql: `SELECT column_name FROM information_schema.columns
+            WHERE table_schema = 'public' AND table_name = ? AND data_type = 'integer'`,
+      args: [table],
+    });
+    int4Columns = new Set(rows.map((r) => String(r.column_name)));
+  } catch {
+    // information_schema unreadable (permissions / non-standard backend) —
+    // skip silently and leave the pre-existing behaviour unchanged.
+    return;
+  }
+  for (const col of columns) {
+    if (!int4Columns.has(col) || !PLAIN_IDENTIFIER.test(col)) continue;
+    try {
+      await client.execute(
+        `ALTER TABLE ${table} ALTER COLUMN ${col} TYPE BIGINT`,
+      );
+    } catch {
+      // A concurrent boot already widened it, or the role lacks ALTER — both
+      // are safe to ignore; a later boot retries if still needed.
+    }
+  }
+}

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

@@ -34,6 +34,7 @@ import {
 } from "./workspace-core.js";
 import { generateActionRegistryForProject } from "../vite/action-types-plugin.js";
 import { mcpEmbedStaticAssetRouteRules } from "../shared/mcp-embed-headers.js";
+import { AGENT_CHAT_PROCESS_RUN_PATH } from "../agent/durable-background.js";
 import {
   AGENT_NATIVE_SOCIAL_IMAGE_ALT,
   AGENT_NATIVE_SOCIAL_IMAGE_CACHE_BUSTER,
@@ -1476,6 +1477,85 @@ export function findInstalledResvgPackages(
     .map(([packageName, packageDir]) => ({ packageName, packageDir }));
 }
 
+/**
+ * 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).
+ */
+export function isDurableBackgroundDeployEnabled(): boolean {
+  const raw = process.env.AGENT_CHAT_DURABLE_BACKGROUND;
+  if (raw == null) return false;
+  const v = raw.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+
+/**
+ * Single-template Netlify build: emit a SECOND function whose name ends in
+ * `-background`, re-exporting the same `main.mjs` handler bundle, so the chat
+ * `_process-run` POST lands on Netlify's async (15-min) function instead of the
+ * synchronous one. Additive + flag-gated (see `isDurableBackgroundDeployEnabled`).
+ *
+ * Nitro's `netlify` preset emits a single function at
+ * `.netlify/functions-internal/server` (`server.mjs` → `main.mjs`). We copy
+ * that directory to a sibling `<...>-background` function and write an entry
+ * with a `config.path` of the process-run route.
+ *
+ * ⚠️ REAL-DEPLOY VERIFICATION REQUIRED. Whether Netlify routes
+ * `/_agent-native/agent-chat/_process-run` to this `-background` function (and
+ * invokes it asynchronously with the 15-min budget) vs the synchronous Nitro
+ * function cannot be verified in this environment — Nitro owns the primary
+ * function's routing manifest, and the precedence between the two functions for
+ * that path is a Netlify runtime behavior. If routing resolves to the
+ * synchronous function, the run still completes via the existing 40s
+ * soft-timeout path (no durable win, no regression). See
+ * docs/design/durable-agent-runs.md (Open risks #1).
+ */
+export function emitSingleTemplateNetlifyBackgroundFunction(
+  projectCwd: string,
+): void {
+  const functionsDir = path.join(projectCwd, ".netlify", "functions-internal");
+  const serverDir = path.join(functionsDir, "server");
+  if (!fs.existsSync(path.join(serverDir, "main.mjs"))) {
+    // Nitro output layout differs from what we expected — skip rather than
+    // guess. The single-function deploy is unaffected.
+    console.warn(
+      "[build] Durable-background emit skipped: expected Nitro Netlify function " +
+        "at .netlify/functions-internal/server/main.mjs was not found.",
+    );
+    return;
+  }
+  const backgroundName = "server-agent-background";
+  const dest = path.join(functionsDir, backgroundName);
+  fs.rmSync(dest, { recursive: true, force: true });
+  copyDir(serverDir, dest);
+  // Drop the original Nitro entry so our background entry is the entrypoint.
+  fs.rmSync(path.join(dest, "server.mjs"), { force: true });
+
+  const entry = `let cachedHandler;
+
+export default async function handler(...args) {
+  cachedHandler ??= (await import("./main.mjs")).default;
+  return cachedHandler(...args);
+}
+
+export const config = {
+  name: "agent background handler",
+  generator: "agent-native build",
+  path: ${JSON.stringify([AGENT_CHAT_PROCESS_RUN_PATH])},
+  nodeBundler: "none",
+  includedFiles: ["**"],
+  preferStatic: false,
+};
+`;
+  fs.writeFileSync(path.join(dest, `${backgroundName}.mjs`), entry);
+  console.log(
+    `[build] Emitted durable-background function "${backgroundName}" ` +
+      `(path ${AGENT_CHAT_PROCESS_RUN_PATH}). REQUIRES real-deploy verification ` +
+      `of Netlify async routing — see docs/design/durable-agent-runs.md.`,
+  );
+}
+
 function copyInstalledLibsqlNativePackages(serverDir: string | undefined) {
   if (!serverDir || !fs.existsSync(serverDir)) return;
   const nodeModulesRoots = nodeModulesAncestors(cwd);
@@ -1938,6 +2018,22 @@ 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.
+  if (preset === "netlify" && isDurableBackgroundDeployEnabled()) {
+    try {
+      emitSingleTemplateNetlifyBackgroundFunction(cwd);
+    } catch (err) {
+      console.warn(
+        "[build] Failed to emit durable-background Netlify function (non-fatal):",
+        err instanceof Error ? err.message : err,
+      );
+    }
+  }
+
   // Resolve remaining bare npm imports by bundling them into _libs/.
   // Nitro sometimes leaves small packages as externals even with noExternals.
   if (preset.startsWith("cloudflare") || preset.startsWith("deno")) {