@cursor/july 0.1.97 → 0.1.100

package/src/internal/cursor/hosted-store-secrets.ts

@@ -0,0 +1,72 @@
+/**
+ * Task-time bind paths for hosted deployment file-store source ids.
+ *
+ * Freeze v2 snapshots start `agent-serve serve` at bake time without a service
+ * account, so neither store id is in process env. Execute-from-freeze binds
+ * the deployment credential and store ids into `/run/cursor/secrets/` without
+ * restarting July — the same pattern as {@link DEFAULT_CURSOR_API_KEY_FILE}.
+ */
+
+import { readFileSync } from "node:fs";
+
+export const DEFAULT_AGENT_SERVE_STORE_SOURCE_ID_FILE =
+  "/run/cursor/secrets/AGENT_SERVE_STORE_SOURCE_ID";
+
+export const DEFAULT_AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID_FILE =
+  "/run/cursor/secrets/AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID";
+
+const STORE_SOURCE_ID_ENV = "AGENT_SERVE_STORE_SOURCE_ID";
+const FRAMEWORK_STORE_SOURCE_ID_ENV = "AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID";
+const STORE_SOURCE_ID_FILE_ENV = "AGENT_SERVE_STORE_SOURCE_ID_FILE";
+const FRAMEWORK_STORE_SOURCE_ID_FILE_ENV =
+  "AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID_FILE";
+
+function readTrimmedFile(path: string): string | undefined {
+  try {
+    const raw = readFileSync(path, "utf8").trim();
+    return raw === "" ? undefined : raw;
+  } catch {
+    return undefined;
+  }
+}
+
+function readBoundSecretFile(
+  fileEnvVar: string,
+  defaultPath: string,
+  env: NodeJS.ProcessEnv
+): string | undefined {
+  const configured = env[fileEnvVar]?.trim();
+  const path =
+    configured !== undefined && configured !== "" ? configured : defaultPath;
+  return readTrimmedFile(path);
+}
+
+/** Deployment user-land store: env, then task-bind file. */
+export function resolveDeploymentStoreSourceIdSync(
+  env: NodeJS.ProcessEnv = process.env
+): string | undefined {
+  const fromEnv = env[STORE_SOURCE_ID_ENV]?.trim();
+  if (fromEnv !== undefined && fromEnv !== "") {
+    return fromEnv;
+  }
+  return readBoundSecretFile(
+    STORE_SOURCE_ID_FILE_ENV,
+    DEFAULT_AGENT_SERVE_STORE_SOURCE_ID_FILE,
+    env
+  );
+}
+
+/** Engine framework store: env, then task-bind file. */
+export function resolveFrameworkStoreSourceIdSync(
+  env: NodeJS.ProcessEnv = process.env
+): string | undefined {
+  const fromEnv = env[FRAMEWORK_STORE_SOURCE_ID_ENV]?.trim();
+  if (fromEnv !== undefined && fromEnv !== "") {
+    return fromEnv;
+  }
+  return readBoundSecretFile(
+    FRAMEWORK_STORE_SOURCE_ID_FILE_ENV,
+    DEFAULT_AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID_FILE,
+    env
+  );
+}

package/src/internal/cursor-event-relay.ts

@@ -616,12 +616,11 @@ export class CursorEventRelay {
           events: [...subscription.events],
         })),
       }),
-      // Empty subscriptions drop this consumer's registration on clean stop
-      // instead of leaving it to lapse by TTL.
-      buildDeregistrationBody: (consumerId) => ({
-        consumerId,
-        subscriptions: [],
-      }),
+      // No deregistration on stop: the backend only records events for a
+      // repo that some consumer is subscribed to, so dropping the
+      // registration leaves a hole in the log until the next process
+      // registers, and the durable offset cannot replay what was never
+      // written. A consumer that does not come back lapses by TTL.
       applyRegistrationResponse: (json) => {
         const result = json as { repos?: SubscriptionStatus[] };
         const statuses = result.repos ?? [];

package/src/internal/deploy-client.ts

@@ -1,7 +1,7 @@
 /**
  * Thin client for the Agent Serve deployment management API
  * (`/internal/agent-serve/deployments` on the Cursor backend) and the v2
- * AgentSDK accept path (`/internal/agentkit/deployments`). Pure
+ * AgentSDK accept path (`/internal/agentsdk/deployments`). Pure
  * request/response + error mapping — no console I/O, no polling loops;
  * rendering lives in `cli-deploy.ts`.
  *
@@ -214,7 +214,7 @@ export interface StopAccepted {
 export type DeleteAccepted = StopAccepted;
 
 /**
- * `POST /internal/agentkit/deployments` 202 body. Distinct from v1
+ * `POST /internal/agentsdk/deployments` 202 body. Distinct from v1
  * {@link DeployAccepted}: the v2 control plane returns catalog ids, not
  * an engine alias or one-shot alias token.
  */
@@ -234,7 +234,7 @@ export interface AgentkitDeployComponent {
   agentPath?: string;
 }
 
-/** Customer-visible v2 deploy status (`GET /internal/agentkit/deployments/:slug`). */
+/** Customer-visible v2 deploy status (`GET /internal/agentsdk/deployments/:slug`). */
 export type AgentkitCustomerStatus =
   | "pending"
   | "deploying"
@@ -273,7 +273,7 @@ export const TERMINAL_AGENTKIT_DEPLOY_STATUSES: ReadonlySet<AgentkitCustomerStat
   new Set(["running", "failed", "stopped"]);
 
 /**
- * `POST /internal/agentkit/deployments/:slug/stop` 202 body. Like v1
+ * `POST /internal/agentsdk/deployments/:slug/stop` 202 body. Like v1
  * {@link StopAccepted} but keyed by catalog ids instead of the numeric
  * deployment row id.
  */
@@ -594,7 +594,7 @@ export class AgentServeDeployClient {
 
   /**
    * Create or redeploy onto the v2 control plane
-   * (`POST /internal/agentkit/deployments`). 202 means accepted; poll
+   * (`POST /internal/agentsdk/deployments`). 202 means accepted; poll
    * {@link getAgentkitDeploy} until a terminal status. `components` deploys
    * one application with several release components (one per agent
    * directory); it is mutually exclusive with `agentPath`.
@@ -625,7 +625,7 @@ export class AgentServeDeployClient {
     }
     const raw = await this.request({
       method: "POST",
-      path: "/internal/agentkit/deployments",
+      path: "/internal/agentsdk/deployments",
       body: {
         teamId: args.teamId,
         slug: args.slug,
@@ -650,14 +650,14 @@ export class AgentServeDeployClient {
   }): Promise<AgentkitDeployStatus> {
     const raw = await this.request({
       method: "GET",
-      path: `/internal/agentkit/deployments/${encodeURIComponent(args.slug)}?teamId=${args.teamId}`,
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}?teamId=${args.teamId}`,
       context: { verb: "get deployment", slug: args.slug },
     });
     return agentkitDeployStatusSchema.parse(raw);
   }
 
   /**
-   * Stop a v2 deployment (`POST /internal/agentkit/deployments/:slug/stop`).
+   * Stop a v2 deployment (`POST /internal/agentsdk/deployments/:slug/stop`).
    * 202 means accepted; poll {@link getAgentkitDeploy} until `stopped`.
    */
   async stopAgentkit(args: {
@@ -666,7 +666,7 @@ export class AgentServeDeployClient {
   }): Promise<AgentkitStopAccepted> {
     const raw = await this.request({
       method: "POST",
-      path: `/internal/agentkit/deployments/${encodeURIComponent(args.slug)}/stop?teamId=${args.teamId}`,
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/stop?teamId=${args.teamId}`,
       context: { verb: "stop", slug: args.slug },
     });
     return agentkitStopAcceptedSchema.parse(raw);
@@ -977,7 +977,7 @@ function mapErrorResponse(
       // (api2 vs api.cursor.com), not a missing deployment / closed gate.
       if (/Route \S+ not found/i.test(bodyText)) {
         return new DeployApiError(
-          `Agent Serve deploy API not found on this host — use the default api.cursor.com (unset CURSOR_API_BASE_URL), or point CURSOR_API_BASE_URL at a backend that mounts /internal/agent-serve/* and /internal/agentkit/*.`,
+          `Agent Serve deploy API not found on this host — use the default api.cursor.com (unset CURSOR_API_BASE_URL), or point CURSOR_API_BASE_URL at a backend that mounts /internal/agent-serve/* and /internal/agentsdk/*.`,
           404
         );
       }

package/src/internal/discovery.ts

@@ -1928,7 +1928,15 @@ async function loadChannels(
       });
       continue;
     }
-    channels.push({ id, definition: mod.default as ChannelDefinition });
+    const definition = mod.default as ChannelDefinition;
+    for (const notice of definition.meta?.deprecations ?? []) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        path: displayPath(ctx, entryPath),
+        message: notice,
+      });
+    }
+    channels.push({ id, definition });
   }
   return { channels, httpChannelDefinition };
 }

package/src/internal/framework-file-storage.ts

@@ -8,15 +8,16 @@
  *   is browsable from the dashboard and mountable on cloud-runtime VMs;
  * - the **framework-level** store (`AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID`)
  *   holds engine-owned session state — session records, event transcripts,
- *   the continuation index, and the SDK conversation mirror — and is never
- *   exposed to authors or models.
+ *   hosted-execution run logs, the continuation index, and the SDK
+ *   conversation mirror — and is never exposed to authors or models.
  *
  * This module puts framework session state on the framework store. The
  * {@link storageKeys} scheme was designed for exactly this: keys are a
  * stable versioned contract that sinks may route on, so
  * {@link composeFrameworkStorage} splits one {@link StorageConfig} by key
- * kind — `session` / `session-events` / `continuation` go to the framework
- * file store (file-shaped; the store accepts values up to 64 MiB per
+ * kind — `session` / `session-events` / `session-runs` / `continuation`
+ * go to the framework file store (file-shaped; the store accepts values
+ * up to 64 MiB per
  * object without chunking, versus the KV proxy's 1 MiB row cap), while
  * author `kv`, eval runs, A/B samples, and conditional writes stay on the
  * control-plane KV proxy (the dashboard reads them there, and CAS needs a
@@ -40,6 +41,7 @@ import { mapBounded } from "./bounded.js";
 const FRAMEWORK_FILE_KINDS: ReadonlySet<string> = new Set([
   "session",
   "session-events",
+  "session-runs",
   "continuation",
 ]);
 

package/src/internal/framework-storage-selection.ts

@@ -17,17 +17,19 @@
  *
  * - **Cursor-managed hosting** (the deployment-generation environment
  *   variable is set, same signal that registers `GET /v1/manifest`):
- *   the Cursor-hosted backend. When the deployment carries a
- *   **framework-level file store**
- *   (`AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID`), session records, event
- *   transcripts, and the continuation index live there — file-shaped state
- *   on file storage, apart from the author-facing user store — while
- *   `host.kv`, eval runs, A/B samples, and conditional writes stay on the
- *   control-plane KV proxy (see framework-file-storage.ts). Without one
- *   (a deploy predating framework-store provisioning), everything goes to
- *   the KV proxy as before. The API key resolves through the full
- *   credential chain on every call because hosted freeze snapshots listen
- *   unsigned and the binder drops the key file after restore.
+ *   the deployment's **framework-level file store**
+ *   (`AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID`, bound at task time) holds
+ *   session records, event transcripts, and the continuation index —
+ *   file-shaped state on file storage, apart from the author-facing user
+ *   store. Author `host.kv`, eval runs, A/B samples, and conditional writes
+ *   ride the AgentSDK v2 KV proxy (cursor-hosted-v2.ts), which resolves the
+ *   pod service account to the factorydb deployment row (the v1 Bugbot
+ *   proxy cannot resolve v2 pods at all). Framework session state never
+ *   routes to the KV proxy — the composite splits by key kind — so
+ *   transcripts stay off the author-reachable KV namespace. The API key
+ *   resolves through the full credential chain on every call because hosted
+ *   freeze snapshots listen unsigned and the binder drops the key file
+ *   after restore.
  * - **Self-hosted**: no mirror. `--state-root` is the durable copy, which
  *   is correct when the operator owns the disk.
  *
@@ -45,7 +47,7 @@ import {
   cursorHostedFiles,
 } from "../files-backends/cursor-hosted.js";
 import { defineStorage, type StorageDefinition } from "../storage.js";
-import { cursorHostedStorage } from "../storage-backends/cursor-hosted.js";
+import { cursorHostedStorageV2 } from "../storage-backends/cursor-hosted-v2.js";
 import type { AgentArchitecture } from "../types.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
 import { AGENT_SERVE_GENERATION_ENV_VAR } from "./cursor-relay-core.js";
@@ -96,20 +98,18 @@ export function selectFrameworkStorageDefinition(
   // comes up). Follow-ups restore lazily by continuation or session id;
   // GET /v1/sessions lists from the sink either way.
   const policy = { restore: "off" } as const;
-  // Full chain (env → key file → stored login): frozen engines listen
-  // unsigned and bind CURSOR_API_KEY_FILE at task time, after this
+  const envSnapshot = env as NodeJS.ProcessEnv;
+  // Full chain (env → bind file → stored login): frozen engines listen
+  // unsigned and bind store ids + CURSOR_API_KEY at task time, after this
   // definition is constructed.
   const resolveApiKey = (): string | undefined => resolveApiKeySync()?.apiKey;
-  const kv = cursorHostedStorage({ resolveApiKey });
-  const frameworkStoreId = cursorFrameworkStoreSourceId(
-    env as NodeJS.ProcessEnv
-  );
-  if (frameworkStoreId === undefined) {
-    return defineStorage({ name: "cursor-hosted", policy, ...kv });
-  }
-  // Framework session state on the framework-level file store; author kv,
-  // evals, and A/B tables stay on the KV proxy (spread from `kv`, which
-  // also carries the cursor-hosted marker for GET /v1/sessions).
+  // v2 pods carry a factorydb-bound service account, which the v1 Bugbot
+  // storage proxy cannot resolve; author KV, CAS coordination, and the
+  // eval/A-B tables speak the AgentSDK v2 KV proxy instead. It also carries
+  // the cursor-hosted marker, so GET /v1/sessions prefers the durable list
+  // (session records are on the framework store, which the composed core
+  // lists).
+  const kv = cursorHostedStorageV2({ resolveApiKey });
   return defineStorage({
     name: "cursor-hosted (framework files)",
     policy,
@@ -117,7 +117,10 @@ export function selectFrameworkStorageDefinition(
     ...composeFrameworkStorage({
       kv,
       files: fileSinkStorageCore(
-        cursorHostedFiles({ storeSourceId: frameworkStoreId, resolveApiKey })
+        cursorHostedFiles({
+          resolveStoreSourceId: () => cursorFrameworkStoreSourceId(envSnapshot),
+          resolveApiKey,
+        })
       ),
     }),
     // CAS stays on the KV proxy but must refuse framework-file keys, or a

package/src/internal/hosted-admission-adapter.ts

@@ -0,0 +1,42 @@
+import type { ChannelHandlerArgs } from "../types.js";
+
+/**
+ * Hosted-admission hook a channel pack attaches to its definition.
+ *
+ * Hosted delivery looks this up from the mounted definition — it does not
+ * switch on `channelKind`. A new forge implements `dispatch` / `getOutcome`
+ * next to its webhook handler and calls {@link attachHostedAdmissionAdapter}
+ * from the channel constructor.
+ */
+export type HostedAdmissionDispatchOutcome = "skip" | "task";
+
+export type HostedAdmissionAdapter = {
+  kind: string;
+  /**
+   * Optional wrap of the capturing `send` / `waitUntil` args (GitHub uses
+   * this to propagate background-task errors). Identity when omitted.
+   */
+  prepareArgs?(args: ChannelHandlerArgs): ChannelHandlerArgs;
+  dispatch(input: {
+    eventType: string;
+    payload: unknown;
+    deliveryId: string;
+    args: ChannelHandlerArgs;
+  }): Promise<Response>;
+  getOutcome(response: Response): HostedAdmissionDispatchOutcome | undefined;
+};
+
+const adapters = new WeakMap<object, HostedAdmissionAdapter>();
+
+export function attachHostedAdmissionAdapter(
+  definition: object,
+  adapter: HostedAdmissionAdapter
+): void {
+  adapters.set(definition, adapter);
+}
+
+export function getHostedAdmissionAdapter(
+  definition: object
+): HostedAdmissionAdapter | undefined {
+  return adapters.get(definition);
+}

package/src/internal/hosted-delivery-protocol.ts

@@ -18,7 +18,12 @@ export type HostedAdmissionManagedAutomation = {
 export type HostedAdmission = {
   v: 2;
   channelId: string;
-  channelKind: "github";
+  /**
+   * Mailbox / subscription channel kind (`github`, `origin`, …). The guest
+   * resolves dispatch from the mounted definition's hosted-admission
+   * adapter; this field is not an allowlist.
+   */
+  channelKind: string;
   eventType: string;
   deliveryId: string;
   sessionMode: "event" | "continuation";
@@ -107,7 +112,7 @@ export function parseHostedAdmission(
     !Object.hasOwn(body, "payload") ||
     body.v !== HOSTED_DELIVERY_PROTOCOL_VERSION ||
     !boundedString(body.channelId, 128) ||
-    body.channelKind !== "github" ||
+    !boundedString(body.channelKind, 128) ||
     !boundedString(body.eventType, 128) ||
     !boundedString(body.deliveryId, 256) ||
     (body.sessionMode !== "event" && body.sessionMode !== "continuation") ||

package/src/internal/hosted-delivery.ts

@@ -1,10 +1,4 @@
 import { randomBytes } from "node:crypto";
-import {
-  dispatchGitHubWebhook,
-  getGitHubChannelOptions,
-  getGitHubDispatchOutcome,
-  withPropagatingGitHubBackgroundErrors,
-} from "../channels/github/github-channel.js";
 import type {
   AuthPolicy,
   ChannelHandlerArgs,
@@ -14,6 +8,10 @@ import {
   createDeferredChannelSession,
   DeferredChannelSessionError,
 } from "./deferred-channel-session.js";
+import {
+  getHostedAdmissionAdapter,
+  type HostedAdmissionAdapter,
+} from "./hosted-admission-adapter.js";
 import {
   HostedAdmissionLocalSendError,
   runDuringHostedAdmission,
@@ -30,12 +28,19 @@ import {
 import {
   abortReasonFromTurnStatus,
   HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+  hostedErrorStackSnippet,
   hostedExecutionDiagId,
   writeHostedExecutionDiag,
 } from "./hosted-execution-diag.js";
 import { recordHostedManagedAutomation } from "./hosted-managed-automation.js";
 import { errorResponse, readJsonObject } from "./http-channel.js";
+import type { LogRingEntry } from "./log-ring.js";
 import type { Router } from "./router.js";
+import {
+  type SessionRunExecutionWrite,
+  serializeSessionRunError,
+  snapshotSessionRunLogs,
+} from "./session-run-log.js";
 
 type DispatchInput = {
   delivery: HostedAdmission;
@@ -115,17 +120,20 @@ function nonRetryableRejection(error: unknown): AdmissionDispatch | undefined {
 }
 
 /**
- * Run authored admission without creating a framework session. V1 GitHub
+ * Run authored admission without creating a framework session. Authored
  * `task` callbacks execute as sessionless work; the first `send` is captured
  * and executed only after the control plane allocates `ses_…`. Capturing
  * does not terminate the caller — `send` returns an inert deferred handle so
  * a task body runs to completion before the admission response is computed.
+ *
+ * Dispatch is the adapter the mounted channel attached. Hosted delivery
+ * does not switch on `channelKind`.
  */
 export async function dispatchHostedAdmission(
   input: DispatchInput
 ): Promise<AdmissionDispatch> {
-  const github = getGitHubChannelOptions(input.definition);
-  if (github === undefined) {
+  const adapter = getHostedAdmissionAdapter(input.definition);
+  if (adapter === undefined || adapter.kind !== input.delivery.channelKind) {
     return {
       response: Response.json(
         { ok: false, error: "channel_kind_mismatch" },
@@ -135,16 +143,16 @@ export async function dispatchHostedAdmission(
   }
   // The admission window marker follows the async graph into task bodies so
   // the engine can refuse local sends that would bypass the capture stub.
-  return runDuringHostedAdmission(() => runAdmission(input, github));
+  return runDuringHostedAdmission(() => runAdmission(input, adapter));
 }
 
 async function runAdmission(
   input: DispatchInput,
-  github: NonNullable<ReturnType<typeof getGitHubChannelOptions>>
+  adapter: HostedAdmissionAdapter
 ): Promise<AdmissionDispatch> {
   const background: Promise<unknown>[] = [];
   let captured: { message: string; options: SendMessageOptions } | undefined;
-  const args = withPropagatingGitHubBackgroundErrors({
+  const capturingArgs: ChannelHandlerArgs = {
     ...input.args,
     send: async (message, options = {}) => {
       if (captured !== undefined) {
@@ -156,12 +164,12 @@ async function runAdmission(
     waitUntil: (promise) => {
       background.push(promise);
     },
-  });
+  };
+  const args = adapter.prepareArgs?.(capturingArgs) ?? capturingArgs;
   let dispatched: Response;
   try {
-    dispatched = await dispatchGitHubWebhook({
-      options: github,
-      eventName: input.delivery.eventType,
+    dispatched = await adapter.dispatch({
+      eventType: input.delivery.eventType,
       payload: input.delivery.payload,
       deliveryId: input.delivery.deliveryId,
       args,
@@ -212,7 +220,7 @@ async function runAdmission(
       },
     };
   }
-  const outcome = getGitHubDispatchOutcome(dispatched);
+  const outcome = adapter.getOutcome(dispatched);
   if (outcome === undefined) {
     return {
       response: Response.json(
@@ -264,6 +272,15 @@ export function registerHostedDeliveryRoute(input: {
    * `hosted-execution.json` from that path after the POST returns.
    */
   stateRoot?: string;
+  /**
+   * Upsert this execution into the v2 session-level framework-store log.
+   * Called for the pre-turn `running` claim and every terminal outcome so
+   * a dead Node process still leaves a leftover. Soft-fail inside the
+   * store; this path still awaits so a parked pod cannot shed the write.
+   */
+  persistSessionRun?(write: SessionRunExecutionWrite): Promise<void>;
+  /** Snapshot of the process log ring at persist time. */
+  snapshotLogs?(): LogRingEntry[];
 }): void {
   const pending = new Map<
     string,
@@ -404,30 +421,64 @@ export function registerHostedDeliveryRoute(input: {
           abortReason?:
             | ReturnType<typeof abortReasonFromTurnStatus>
             | "execute_throw";
+          error?: unknown;
         }): Promise<void> => {
-          if (input.stateRoot === undefined) {
-            return;
-          }
+          const durationMs = Math.max(
+            0,
+            Math.round(performance.now() - startedAt)
+          );
           const message =
             fields.message === undefined
               ? undefined
               : boundedMessage(fields.message);
-          await writeHostedExecutionDiag(input.stateRoot, {
-            v: 1,
-            executionId,
-            writtenAt: new Date().toISOString(),
-            sessionPublicId: execution.sessionPublicId,
-            sessionId: fields.sessionId,
-            turnStatus: fields.turnStatus,
-            durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
-            ...(message === undefined ? {} : { message }),
-            ...(message !== undefined && /abort/i.test(message)
-              ? { signalAborted: true }
-              : {}),
-            ...(fields.abortReason === undefined
-              ? {}
-              : { abortReason: fields.abortReason }),
-          });
+          const stack =
+            fields.error === undefined
+              ? undefined
+              : hostedErrorStackSnippet(fields.error);
+          if (input.stateRoot !== undefined) {
+            await writeHostedExecutionDiag(input.stateRoot, {
+              v: 1,
+              executionId,
+              writtenAt: new Date().toISOString(),
+              sessionPublicId: execution.sessionPublicId,
+              sessionId: fields.sessionId,
+              turnStatus: fields.turnStatus,
+              durationMs,
+              ...(message === undefined ? {} : { message }),
+              ...(stack === undefined || stack.length === 0 ? {} : { stack }),
+              ...(message !== undefined && /abort/i.test(message)
+                ? { signalAborted: true }
+                : {}),
+              ...(fields.abortReason === undefined
+                ? {}
+                : { abortReason: fields.abortReason }),
+            });
+          }
+          if (input.persistSessionRun === undefined) {
+            return;
+          }
+          const error =
+            fields.error === undefined
+              ? undefined
+              : serializeSessionRunError(fields.error);
+          try {
+            await input.persistSessionRun({
+              executionId,
+              writtenAt: new Date().toISOString(),
+              sessionPublicId: execution.sessionPublicId,
+              sessionId: fields.sessionId,
+              turnStatus: fields.turnStatus,
+              durationMs,
+              ...(fields.abortReason === undefined
+                ? {}
+                : { abortReason: fields.abortReason }),
+              ...(message === undefined ? {} : { message }),
+              ...(error === undefined ? {} : { error }),
+              logs: snapshotSessionRunLogs(input.snapshotLogs?.() ?? []),
+            });
+          } catch {
+            // Soft-fail: a store outage must not change the HTTP reply.
+          }
         };
         // Claim the file before the turn runs. The host reads it after its
         // own POST returns, which for a 9-minute timeout is while this turn
@@ -486,6 +537,7 @@ export function registerHostedDeliveryRoute(input: {
             turnStatus: "error",
             message: error instanceof Error ? error.message : String(error),
             abortReason: "execute_throw",
+            error,
           });
           throw error;
         }