deepline 0.3.448 → 0.3.450

package/dist/bundling-sources/sdk/src/play.ts

@@ -181,7 +181,7 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  *   row to its output stream. This is how you build a play "on top of" a monitor
  *   (e.g. run enrichment every time a watched company posts a new job). Each
  *   listener binds to a monitor tool id + one of its output stream keys (see
- *   `deepline monitors available <id>` for a tool's streams and row columns).
+ *   `deepline describe <id>` for a tool's streams and row columns).
  *   The changed row is delivered as the listener event's `after` in the play function's input.
  *
  * The default Play runtime is 30 minutes. For bounded long-running batches, add

package/dist/bundling-sources/sdk/src/release.ts

@@ -205,7 +205,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.448',
+  version: '0.3.450',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/monitors/http-error-response.ts

@@ -127,10 +127,10 @@ export function monitorErrorNextAction(payload: MonitorErrorPayload): string {
     return 'Stop monitor work and contact the Deepline team to request access; then rerun `deepline monitors status`.';
   }
   if (code === 'monitor_tool_not_found' || code === 'unknown_monitor_tool') {
-    return 'Run `deepline monitors available`, choose a returned tool id, then retry with that exact id.';
+    return 'Run `deepline tools list --categories monitors`, choose a returned tool id, then retry with that exact id.';
   }
   if (code === 'monitor_provider_not_offered') {
-    return 'This provider monitor is retired for new deployments. Run `deepline monitors available` to choose a supported monitor. Existing retired-provider monitors can still be inspected and deleted.';
+    return 'This provider monitor is retired for new deployments. Run `deepline tools list --categories monitors` to choose a supported monitor. Existing retired-provider monitors can still be inspected and deleted.';
   }
   if (code === 'deployed_monitor_not_found' || code === 'monitor_not_found') {
     return 'Run `deepline monitors list --status all`, choose a returned public monitor key, then retry with that key.';
@@ -183,7 +183,7 @@ export function monitorErrorNextAction(payload: MonitorErrorPayload): string {
     return 'Fix every returned issue using its path and suggestion. Rerun `deepline monitors check` for definitions or the relevant dry-run for delete/reactivate; do not mutate until validation passes.';
   }
   if (code === 'monitor_tool_unavailable') {
-    return 'Run `deepline monitors available`; choose a tool returned for this workspace, or stop and request access to the unavailable capability.';
+    return 'Run `deepline tools list --categories monitors`; choose a tool returned for this workspace, or stop and request access to the unavailable capability.';
   }
   if (code === 'monitor_entitlement_limit_exceeded') {
     return 'Run `deepline monitors list --status all`; reuse or disable an existing monitor, or ask the user to change entitlement before retrying.';

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-capability.ts

@@ -447,7 +447,7 @@ export function defineProviderMonitorCapability(input: {
       fields,
       pricing: {
         presentation:
-          'Use the Deepline pricing returned by describe, monitors available, check, or deploy --dry-run. Provider spend is not exposed.',
+          'Use the Deepline pricing returned by describe, check, or deploy --dry-run. Provider spend is not exposed.',
       },
       identity: {
         semantics: input.upstreamCollision

package/dist/bundling-sources/shared_libs/observability/telemetry.ts

@@ -332,9 +332,10 @@ function errorFields(
 export function createConsoleTelemetryAdapter(input?: {
   console?: Pick<Console, 'debug' | 'info' | 'warn' | 'error'>;
 }): TelemetryAdapter {
-  const target = input?.console ?? console;
   return {
     emit(event) {
+      // Convex Node actions replace console for each invocation in a warm process.
+      const target = input?.console ?? console;
       const line = JSON.stringify(event);
       if (event.telemetryKind === 'log' || event.telemetryKind === 'span')
         target[event.telemetryLevel](line);

package/dist/bundling-sources/shared_libs/play-runtime/deployment/commands/roll-execution-relay.ts

@@ -24,6 +24,7 @@ import {
 } from '../fly-gateway-route-probe';
 import {
   gatewayMachineConfig,
+  productionGatewayImageEnsureArgs,
   productionGatewayTopology,
   RUNTIME_GATEWAY_AUTOSCALED_METADATA_KEY,
   RUNTIME_TOPOLOGY,
@@ -307,19 +308,7 @@ async function assertExactReady(machineId: string): Promise<void> {
   });
 }
 async function prepare(sha: string): Promise<void> {
-  run('bun', [
-    'scripts/ensure-runtime-image.ts',
-    '--kind',
-    'gateway',
-    '--app',
-    app,
-    '--config',
-    RUNTIME_TOPOLOGY.production.components.executionRelay.image.config,
-    '--dockerfile',
-    RUNTIME_TOPOLOGY.production.components.executionRelay.image.dockerfile,
-    '--sha',
-    sha,
-  ]);
+  run('bun', productionGatewayImageEnsureArgs('executionRelay', sha));
   const client = new FlyMachinesClient(app, requireFlyToken(), fetch);
   const initial = await inventory(client);
   const existing = candidates(initial, sha);

package/dist/bundling-sources/shared_libs/play-runtime/deployment/commands/roll-receipt-gateway.ts

@@ -35,6 +35,7 @@ import {
 import { reconcileGatewaySourceDrain } from '../../deployment/runtime-gateway-drain';
 import {
   gatewayMachineConfig,
+  productionGatewayImageEnsureArgs,
   productionGatewayTopology,
   RUNTIME_TOPOLOGY,
 } from '../../deployment/runtime-topology';
@@ -42,9 +43,6 @@ import {
 const topology = productionGatewayTopology('receipt');
 const fleet = {
   app: RUNTIME_TOPOLOGY.production.components.receiptGateway.app,
-  config: RUNTIME_TOPOLOGY.production.components.receiptGateway.image.config,
-  dockerfile:
-    RUNTIME_TOPOLOGY.production.components.receiptGateway.image.dockerfile,
   minimumMachines: topology.minimumMachines,
   primaryRegion: topology.region,
   processGroup: topology.processGroup,
@@ -886,19 +884,7 @@ async function prepare(operationId: string): Promise<void> {
       return;
     }
   }
-  run('bun', [
-    'scripts/ensure-runtime-image.ts',
-    '--kind',
-    'gateway',
-    '--app',
-    fleet.app,
-    '--config',
-    fleet.config,
-    '--dockerfile',
-    fleet.dockerfile,
-    '--sha',
-    operationId,
-  ]);
+  run('bun', productionGatewayImageEnsureArgs('receiptGateway', operationId));
   const blue = serving();
   if (existing.length > 0) {
     assertCandidateSourceGeneration({ candidates: existing, serving: blue });

package/dist/bundling-sources/shared_libs/play-runtime/deployment/commands/runtime-topology.ts

@@ -20,7 +20,12 @@ import {
   readFileSync,
   writeFileSync,
 } from 'node:fs';
-import { productionGatewayTopology } from '../../deployment/runtime-topology';
+import {
+  productionGatewayImageEnsureArgs,
+  productionGatewayTopology,
+  RUNTIME_TOPOLOGY,
+  type ProductionGatewayComponent,
+} from '../../deployment/runtime-topology';
 import {
   shouldCreateDetachedProcessGroup,
   terminateChildProcessTree,
@@ -499,6 +504,23 @@ export async function prepareProductionTopologyPlan(
       description: 'Reconcile declared Fly apps',
     });
     await stageSecrets({ ...input, environment, command: input.command });
+    // One sequential publish, so the parallel prepares below find their
+    // release tags and never push the same image concurrently.
+    const gatewayImageComponents: ProductionGatewayComponent[] = [
+      'receiptGateway',
+      'executionRelay',
+    ];
+    for (const component of gatewayImageComponents) {
+      await input.command({
+        command: 'bun',
+        args: productionGatewayImageEnsureArgs(
+          component,
+          input.plan.releaseSha,
+        ),
+        environment,
+        description: `Ensure runtime gateway image for ${RUNTIME_TOPOLOGY.production.components[component].app}`,
+      });
+    }
     const executionRelayArgs = [
       'scripts/roll-execution-relay.ts',
       'prepare',

package/dist/bundling-sources/shared_libs/play-runtime/deployment/runtime-topology.ts

@@ -144,6 +144,11 @@ const previewGateways: Record<RuntimeGatewayRole, GatewayTopology> = {
   },
 };
 
+// Both gateways run the same image. Concurrent pushes of one Depot build to
+// two repos left a shared blob upload hanging (2026-10-27 releases), so the
+// image is built once into this repo and re-tagged into the other.
+const productionGatewayImageCacheApp = productionGateways.receipt.app;
+
 export const RUNTIME_TOPOLOGY = {
   production: {
     components: {
@@ -153,6 +158,7 @@ export const RUNTIME_TOPOLOGY = {
         publicIngress: true,
         image: {
           kind: 'gateway',
+          cacheApp: productionGatewayImageCacheApp,
           config: 'deploy/fly/runtime-worker/receipt-gateway.toml',
           dockerfile: 'deploy/fly/runtime-worker/receipt-gateway.Dockerfile',
         },
@@ -163,6 +169,7 @@ export const RUNTIME_TOPOLOGY = {
         publicIngress: true,
         image: {
           kind: 'gateway',
+          cacheApp: productionGatewayImageCacheApp,
           config: 'deploy/fly/runtime-worker/execution-relay.toml',
           dockerfile: 'deploy/fly/runtime-worker/receipt-gateway.Dockerfile',
         },
@@ -253,16 +260,33 @@ export function productionSingletonComponents(): SingletonComponent[] {
   );
 }
 
-export function assertRuntimeTopologyInvariants(): void {
-  const components = Object.values(
-    RUNTIME_TOPOLOGY.production.components,
-  ) as Array<{ app: string; release: string; publicIngress: boolean }>;
+export function assertRuntimeTopologyInvariants(
+  declared: Record<string, unknown> = RUNTIME_TOPOLOGY.production.components,
+): void {
+  const components = Object.values(declared) as Array<{
+    app: string;
+    release: string;
+    publicIngress: boolean;
+    image?: { kind: string; cacheApp?: string };
+  }>;
   const apps = components.map((component) => component.app);
   if (new Set(apps).size !== apps.length) {
     throw new Error(
       'Every production runtime component requires a unique app.',
     );
   }
+  const imageRepos = new Map<string, string>();
+  for (const { app, image } of components) {
+    if (!image) continue;
+    const repo = image.cacheApp ?? app;
+    const declaredRepo = imageRepos.get(image.kind);
+    if (declaredRepo !== undefined && declaredRepo !== repo) {
+      throw new Error(
+        `Production components with image kind ${image.kind} must share one cacheApp so the image is built once; found ${declaredRepo} and ${repo}.`,
+      );
+    }
+    imageRepos.set(image.kind, repo);
+  }
   for (const component of components) {
     if (component.release === 'machine-set' && !component.publicIngress) {
       throw new Error(
@@ -279,6 +303,30 @@ export function assertRuntimeTopologyInvariants(): void {
 
 assertRuntimeTopologyInvariants();
 
+export type ProductionGatewayComponent = 'receiptGateway' | 'executionRelay';
+
+export function productionGatewayImageEnsureArgs(
+  component: ProductionGatewayComponent,
+  sha: string,
+): string[] {
+  const { app, image } = RUNTIME_TOPOLOGY.production.components[component];
+  return [
+    'scripts/ensure-runtime-image.ts',
+    '--kind',
+    image.kind,
+    '--app',
+    app,
+    '--cache-app',
+    image.cacheApp,
+    '--config',
+    image.config,
+    '--dockerfile',
+    image.dockerfile,
+    '--sha',
+    sha,
+  ];
+}
+
 export function runtimeGatewayTopology(
   profile: RuntimeGatewayTopologyProfile,
   role: RuntimeGatewayRole,

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-launch-transport.ts

@@ -62,6 +62,27 @@ const DAYTONA_LOGGED_ERROR_NAMES: ReadonlySet<string> = new Set([
   'Error',
 ]);
 const DAYTONA_LOGGED_PROVIDER_TEXT_MAX_CHARS = 160;
+// Deliberately unanchored: `insufficient_credits` and `billingError` must match,
+// and withholding an innocent word costs only one message. `suspended` is a
+// sandbox state and `load balancer` is infrastructure, so they stay readable.
+const DAYTONA_PROVIDER_ACCOUNT_TEXT_PATTERN =
+  /\$\s*\d|credit|billing|invoice|payment|(?<!su)spen[dt]|charge|cost|\busd\b|balance(?!r)|fund|wallet|top.?up|subscription|upgrade your/i;
+const DAYTONA_PROVIDER_PAYMENT_REQUIRED_STATUS = 402;
+// By name: the SDK ships CJS and ESM builds, and `instanceof` fails across them.
+// Deepline's own `Daytona*` errors carry diagnostics classifiers read in full.
+const DAYTONA_SDK_ERROR_NAMES: ReadonlySet<string> = new Set([
+  'DaytonaError',
+  'DaytonaNotFoundError',
+  'DaytonaRateLimitError',
+  'DaytonaAuthenticationError',
+  'DaytonaAuthorizationError',
+  'DaytonaConflictError',
+  'DaytonaValidationError',
+  'DaytonaTimeoutError',
+  'DaytonaConnectionError',
+]);
+const DAYTONA_PROVIDER_ERROR_CODE_PATTERN = /^[A-Za-z][A-Za-z0-9_.-]{1,63}$/;
+const DAYTONA_PROVIDER_DETAIL_PATTERN = / \[provider [^\]]*\]/g;
 
 /** A provider state from Daytona's published enum, or `unrecognized`. */
 export function daytonaSandboxStateForLog(state: unknown): string | null {
@@ -167,6 +188,60 @@ export function boundedDaytonaProviderTextForLog(
   return bounded || null;
 }
 
+/**
+ * Provider text for a run's error, which customers read. Same bounds as the
+ * log form, and text about the provider account is withheld so provider spend
+ * never reaches a customer. Status and code still identify the failure.
+ */
+export function daytonaProviderTextForRunError(value: string): string | null {
+  return DAYTONA_PROVIDER_ACCOUNT_TEXT_PATTERN.test(value)
+    ? 'provider account detail withheld'
+    : boundedDaytonaProviderTextForLog(value);
+}
+
+/** A provider-authored error, with or without an HTTP status. */
+export function isDaytonaProviderError(error: unknown): error is DaytonaError {
+  return error instanceof Error && DAYTONA_SDK_ERROR_NAMES.has(error.name);
+}
+
+/** A provider error's message as a run's error states it. */
+export function daytonaProviderMessageForRunError(
+  error: DaytonaError,
+): string | null {
+  return daytonaErrorStatusForLog(error) ===
+    DAYTONA_PROVIDER_PAYMENT_REQUIRED_STATUS
+    ? 'provider account detail withheld'
+    : daytonaProviderTextForRunError(error.message);
+}
+
+/**
+ * The provider's status and code as a suffix for a run's error text. The key is
+ * `errorCode=` because failure taxonomies read a bare `code=` as Deepline's own.
+ */
+export function daytonaProviderDetailForRunError(error: unknown): string {
+  const status = daytonaErrorStatusForLog(error);
+  const errorCode = (error as { errorCode?: unknown } | null)?.errorCode;
+  const fields = [
+    ...(status === null ? [] : [`status=${status}`]),
+    ...(typeof errorCode === 'string' &&
+    status !== DAYTONA_PROVIDER_PAYMENT_REQUIRED_STATUS &&
+    DAYTONA_PROVIDER_ERROR_CODE_PATTERN.test(errorCode) &&
+    !DAYTONA_PROVIDER_ACCOUNT_TEXT_PATTERN.test(errorCode)
+      ? [`errorCode=${errorCode}`]
+      : []),
+  ];
+  return fields.length > 0 ? ` [provider ${fields.join(' ')}]` : '';
+}
+
+/**
+ * The run error as retry classification reads it. A diagnostic must not choose
+ * a retry: `errorCode=ETIMEDOUT` here would re-run a start whose outcome is
+ * unknown.
+ */
+export function withoutDaytonaProviderDetail(error: string): string {
+  return error.replace(DAYTONA_PROVIDER_DETAIL_PATTERN, '');
+}
+
 /** What this client knew when a sent create ended without a verdict. */
 export type DaytonaLaunchOutcomeDiagnostic = {
   /** Whether the create request returned a response before the deadline. */
@@ -239,12 +314,16 @@ function providerError(error: unknown): unknown {
   if (!axios.isAxiosError(error)) return error;
   const status = error.response?.status;
   const data = error.response?.data;
-  const message =
+  const providerMessage =
     typeof data === 'string'
       ? data
       : typeof data?.message === 'string'
         ? data.message
         : error.message;
+  // Not axios's "Request failed with status code" wording: retry classification
+  // matches that text, and this change only explains the failure.
+  const message =
+    providerMessage.trim() || 'Daytona returned an empty response body';
   const errorClasses: Record<number, typeof DaytonaError> = {
     400: DaytonaValidationError,
     401: DaytonaAuthenticationError,

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -6,7 +6,11 @@ import {
   daytonaErrorClassForLog,
   daytonaErrorCodeForLog,
   daytonaErrorStatusForLog,
+  daytonaProviderDetailForRunError,
+  daytonaProviderMessageForRunError,
+  daytonaProviderTextForRunError,
   daytonaSandboxStateForLog,
+  isDaytonaProviderError,
 } from './daytona-launch-transport';
 import type {
   PlayRunnerExecutionConfig,
@@ -349,7 +353,9 @@ async function rejectAcquiredSandbox(
   try {
     await deleteSandbox();
   } catch (error) {
-    const cleanupError = error instanceof Error ? error.message : String(error);
+    const cleanupError = daytonaProviderTextForRunError(
+      error instanceof Error ? error.message : String(error),
+    );
     throw new Error(
       `${reason} Defensive deletion of Daytona sandbox ${sandbox.id} also failed: ${cleanupError}`,
       { cause: error },
@@ -672,6 +678,8 @@ async function createRetriedOneShotDaytonaSandbox(input: {
   cancellationSignal?: AbortSignal;
 }): Promise<DaytonaCreateResult> {
   const errors: string[] = [];
+  // Customers read these; acquisition classification reads the raw `errors`.
+  const runErrors: string[] = [];
   for (const [index, delayMs] of DAYTONA_CREATE_RETRY_DELAYS_MS.entries()) {
     input.cancellationSignal?.throwIfAborted();
     const attempt = input.nextProviderAttempt();
@@ -767,6 +775,11 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           errorClass: daytonaCreateErrorClass(error),
         });
       errors.push(message);
+      runErrors.push(
+        isDaytonaProviderError(error)
+          ? `${daytonaProviderMessageForRunError(error) ?? ''}${daytonaProviderDetailForRunError(error)}`.trim()
+          : (daytonaProviderTextForRunError(message) ?? ''),
+      );
       // Log-only: whether the create request returned before the deadline and
       // what Daytona last reported, so an unknown outcome is attributable.
       const launchOutcome =
@@ -878,7 +891,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           throw reconcilePending();
         }
         throw new Error(
-          `${message} Daytona did not return a cleanup-addressable sandbox identity; Modal fallback suppressed. The named ephemeral sandbox retains Daytona's auto-delete-on-stop backstop.`,
+          `${daytonaProviderTextForRunError(message)} Daytona did not return a cleanup-addressable sandbox identity; Modal fallback suppressed. The named ephemeral sandbox retains Daytona's auto-delete-on-stop backstop.`,
           { cause: error },
         );
       }
@@ -926,7 +939,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
       ...(reservation ? { sandboxCapacityLeaseId: reservation.leaseId } : {}),
     };
   }
-  const message = `Daytona sandbox create failed across ${errors.length} bounded attempts: ${errors.join('; ')}`;
+  const message = `Daytona sandbox create failed across ${errors.length} bounded attempts: ${runErrors.join('; ')}`;
   const fallbackReason =
     resolveDaytonaSandboxAcquisitionUnavailableReason(errors);
   if (fallbackReason) {

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona.ts

@@ -1,6 +1,13 @@
 import {
+  boundedDaytonaProviderTextForLog,
   createDaytonaLaunchClient,
+  daytonaErrorCodeForLog,
+  daytonaErrorStatusForLog,
+  daytonaProviderDetailForRunError,
+  daytonaProviderMessageForRunError,
+  isDaytonaProviderError,
   redactDaytonaErrorDetail,
+  withoutDaytonaProviderDetail,
 } from './daytona-launch-transport';
 import type { DaytonaClientOptions } from '../../daytona-runtime-config';
 import {
@@ -1112,7 +1119,7 @@ export async function deleteDaytonaSandboxById(input: {
   return outcome.kind === 'deleted' || outcome.kind === 'already_absent';
 }
 
-function formatDaytonaError(error: unknown): string {
+export function formatDaytonaError(error: unknown): string {
   if (!(error instanceof Error)) {
     return String(error);
   }
@@ -1122,11 +1129,20 @@ function formatDaytonaError(error: unknown): string {
     error.cause && error.cause !== error
       ? ` cause=${formatDaytonaError(error.cause)}`
       : '';
+  const message = isDaytonaProviderError(error)
+    ? daytonaProviderMessageForRunError(error)
+    : error.message;
   const details =
     error.name && error.name !== 'Error'
-      ? [error.name, error.message].filter(Boolean).join(': ')
-      : error.message || error.name || 'Error';
-  return `${details || 'Error'}${code}${cause}`;
+      ? [error.name, message].filter(Boolean).join(': ')
+      : message || error.name || 'Error';
+  return `${details || 'Error'}${code}${daytonaProviderDetailForRunError(error)}${cause}`;
+}
+
+/** A thrown error's message for a run error, keeping provider text bounded. */
+export function runErrorMessage(error: unknown): string {
+  if (isDaytonaProviderError(error)) return formatDaytonaError(error);
+  return error instanceof Error ? error.message : String(error);
 }
 
 function sleep(ms: number): Promise<void> {
@@ -1264,38 +1280,39 @@ export function retryableRuntimeInitializationFailureReason(
   | 'daytona_infrastructure'
   | null {
   if (result.status !== 'failed') return null;
-  if (RUNTIME_POSTGRES_CONNECT_RETRY_PATTERN.test(result.error)) {
+  const error = withoutDaytonaProviderDetail(result.error);
+  if (RUNTIME_POSTGRES_CONNECT_RETRY_PATTERN.test(error)) {
     return 'runtime_postgres_connect';
   }
-  if (RUNTIME_RECEIPT_GATEWAY_TRANSPORT_RETRY_PATTERN.test(result.error)) {
+  if (RUNTIME_RECEIPT_GATEWAY_TRANSPORT_RETRY_PATTERN.test(error)) {
     return 'runtime_receipt_gateway_transport';
   }
   const rowsProcessed = Number(result.stats?.rowsProcessed ?? 0);
   if (
     rowsProcessed === 0 &&
     result.steps.length === 0 &&
-    DAYTONA_RUNNER_STARTUP_TRANSPORT_RETRY_PATTERN.test(result.error)
+    DAYTONA_RUNNER_STARTUP_TRANSPORT_RETRY_PATTERN.test(error)
   ) {
     return 'daytona_runner_startup_transport';
   }
   if (
     rowsProcessed === 0 &&
     result.steps.length === 0 &&
-    DAYTONA_PUBLIC_STATUS_TRANSIENT_RETRY_PATTERN.test(result.error)
+    DAYTONA_PUBLIC_STATUS_TRANSIENT_RETRY_PATTERN.test(error)
   ) {
     return 'daytona_public_status';
   }
   if (
     rowsProcessed === 0 &&
     result.steps.length === 0 &&
-    RUNTIME_API_TRANSPORT_RETRY_PATTERN.test(result.error)
+    RUNTIME_API_TRANSPORT_RETRY_PATTERN.test(error)
   ) {
     return 'runtime_api_transport';
   }
   if (
     rowsProcessed === 0 &&
     result.steps.length === 0 &&
-    DAYTONA_INFRASTRUCTURE_RETRY_PATTERN.test(result.error)
+    DAYTONA_INFRASTRUCTURE_RETRY_PATTERN.test(error)
   ) {
     return 'daytona_infrastructure';
   }
@@ -1916,6 +1933,13 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
         runnerAttempt: Math.max(0, Math.floor(config.context.runAttempt ?? 0)),
         error: formatDaytonaError(error),
         operation: 'runner_backend',
+        // Operator evidence: the run error withholds some of this from customers.
+        providerStatus: daytonaErrorStatusForLog(error),
+        providerCode: daytonaErrorCodeForLog(error),
+        providerText:
+          error instanceof Error
+            ? boundedDaytonaProviderTextForLog(error.message)
+            : null,
         elapsedMs: Date.now() - startedAt,
       });
       return withCleanup(

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-runtime-worker.ts

@@ -92,7 +92,10 @@ import {
   resolveRuntimeSandboxPlacementBackend,
   type PlayRunnerBackend,
 } from '../runner-backends';
-import { retryableRuntimeInitializationFailureReason } from '../runner-backends/backends/daytona';
+import {
+  retryableRuntimeInitializationFailureReason,
+  runErrorMessage,
+} from '../runner-backends/backends/daytona';
 import {
   isRuntimeSandboxCanaryProduction,
   resolveLaunchRuntimeSandboxPlacementPolicy,
@@ -2321,12 +2324,10 @@ async function terminalizeSandboxCapacityRejection(input: {
     limit: input.error.limit,
   });
   const terminal = await input.deps.runWithClient((client) =>
-    executePostgresSchedulerClaim(
-      client,
-      claim,
-      async () => failedResult,
-      input.options,
-    ),
+    executePostgresSchedulerClaim(client, claim, async () => failedResult, {
+      ...input.options,
+      terminalLogOutbox: 'failure_reason',
+    }),
   );
   if (terminal.status === 'failed') {
     const reporter = input.deps.createProgressReporter(
@@ -3261,7 +3262,9 @@ async function executeAssignedAbsurdAttempt(input: {
         async () => runnerResult,
         {
           ...options,
-          terminalLogOutbox: input.fromDetachedRunner ? 'ctx_log_tail' : 'omit',
+          terminalLogOutbox: input.fromDetachedRunner
+            ? 'ctx_log_tail'
+            : 'failure_reason',
           sandboxCrashDiagnostic,
           ...(observedTerminalProgressEvents.length > 0 ||
           failedTerminalProgressEvents.length > 0
@@ -5686,8 +5689,7 @@ async function salvageAbsurdFinalAttemptTerminal(input: {
     );
   }
   if (!input.force && attempt < maxAttempts) return;
-  const message =
-    input.error instanceof Error ? input.error.message : String(input.error);
+  const message = runErrorMessage(input.error);
   const failedResult: PlayRunnerResult = {
     status: 'failed',
     error:
@@ -5757,10 +5759,11 @@ async function salvageAbsurdFinalAttemptTerminal(input: {
             input.detachedRecovery
               ? {
                   ...input.options,
+                  terminalLogOutbox: 'failure_reason',
                   preserveRunnerTerminal: true,
                   protectWaitingSuspensionFailure,
                 }
-              : input.options,
+              : { ...input.options, terminalLogOutbox: 'failure_reason' },
           );
         });
         break;