deepline 0.3.449 → 0.3.451

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.449',
+  version: '0.3.451',
   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/runner-app/runtime-terminal-push.ts

@@ -64,6 +64,14 @@ const TERMINAL_TRANSPORT_OUTPUT_WARNINGS_MAX_BYTES = 32 * 1024;
 const TERMINAL_TRANSPORT_RUNTIME_DIAGNOSTICS_MAX_BYTES = 16 * 1024;
 const TERMINAL_TRANSPORT_ERROR_MAX_BYTES = 64 * 1024;
 const TERMINAL_TRANSPORT_TABLE_NAMESPACE_MAX_BYTES = 8 * 1024;
+/**
+ * Leaves room in the gateway body for the action, run ID and log offset around
+ * the result. `terminalRequestBody` drops progress events to fit on its own.
+ */
+const TERMINAL_SUSPENDED_RESULT_MAX_BYTES =
+  RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES - 4 * 1024;
+const RUNTIME_SUSPENDED_CHECKPOINT_TOO_LARGE_CODE =
+  'RUNTIME_SUSPENDED_CHECKPOINT_TOO_LARGE';
 
 type CompletedRunnerResult = Extract<PlayRunnerResult, { status: 'completed' }>;
 type SuspendedRunnerResult = Extract<PlayRunnerResult, { status: 'suspended' }>;
@@ -288,6 +296,7 @@ function appendTerminalDiagnosticsMarker(
   logContexts?: Array<PlayLogContext | null>,
   logIds?: string[],
   logMetadata?: Array<PlayLogMetadata | null>,
+  completeness = 'the authored play output is complete.',
 ): {
   logs: string[];
   logContexts?: Array<PlayLogContext | null>;
@@ -296,7 +305,7 @@ function appendTerminalDiagnosticsMarker(
 } {
   const marker =
     `[deepline] terminal diagnostic metadata was bounded (${truncatedFields.join(', ')}); ` +
-    'the authored play output is complete.';
+    completeness;
   const marked = [marker, ...logs];
   const markedContexts = logContexts ? [null, ...logContexts] : undefined;
   const markedMetadata = logMetadata ? [null, ...logMetadata] : undefined;
@@ -495,6 +504,126 @@ function boundSettledTerminalTransportDiagnostics(
   };
 }
 
+/**
+ * The gateway rejects a body over its ceiling before reading the action, and
+ * that line is also too long for the crash pusher's output tail, so an oversized
+ * suspended result surfaces only as an unexplained "exited with code 0". Keep
+ * ordinary suspensions byte-identical. When one would not fit, drop runner
+ * diagnostics first. The checkpoint is never sliced: without it the run cannot
+ * resume, so a checkpoint that alone exceeds the ceiling is an explicit failure.
+ */
+function suspendedResultWithinGatewayBody(
+  result: SuspendedRunnerResult & IncludedResumeCheckpoint,
+): PlayRunnerTerminalTransportResult {
+  if (fitsJsonByteLimit(result, TERMINAL_SUSPENDED_RESULT_MAX_BYTES)) {
+    return result;
+  }
+  const logProjection = retainTerminalLogTailWithRuntimeDiagnostics(
+    result.logs,
+    result.logContexts,
+    result.logMetadata,
+    result.logIds,
+  );
+  const stats =
+    result.stats.runtimeWorkCounterSegment === undefined
+      ? result.stats
+      : {
+          // The worker reads this to number the resumed segment, so it must
+          // be the first key retained rather than whichever one fits.
+          runtimeWorkCounterSegment: result.stats.runtimeWorkCounterSegment,
+          ...result.stats,
+        };
+  const statsProjection = retainRecordWithinJsonByteLimit(
+    stats,
+    TERMINAL_TRANSPORT_STATS_MAX_BYTES,
+  );
+  const stepsProjection = retainArrayWithinJsonByteLimit(
+    result.steps,
+    TERMINAL_TRANSPORT_STEPS_MAX_BYTES,
+    'head',
+  );
+  const truncatedFields = [
+    ...(logProjection.truncated ? ['logs'] : []),
+    ...(statsProjection.truncated ? ['stats'] : []),
+    ...(stepsProjection.truncated ? ['steps'] : []),
+  ];
+  const projectAligned = <T>(values: readonly T[] | undefined) =>
+    values?.length
+      ? logProjection.indexes.map((index) => values[index]!)
+      : undefined;
+  const boundedLogs =
+    truncatedFields.length > 0
+      ? appendTerminalDiagnosticsMarker(
+          logProjection.values,
+          truncatedFields,
+          projectAligned(result.logContexts),
+          projectAligned(result.logIds),
+          projectAligned(result.logMetadata),
+          'the resume checkpoint is complete.',
+        )
+      : {
+          logs: logProjection.values,
+          logContexts: projectAligned(result.logContexts),
+          logIds: projectAligned(result.logIds),
+          logMetadata: projectAligned(result.logMetadata),
+        };
+  const bounded = {
+    ...result,
+    logs: boundedLogs.logs,
+    logContexts: boundedLogs.logContexts,
+    logMetadata: boundedLogs.logMetadata,
+    logIds: boundedLogs.logIds,
+    stats: statsProjection.value,
+    steps: stepsProjection.values,
+  };
+  if (fitsJsonByteLimit(bounded, TERMINAL_SUSPENDED_RESULT_MAX_BYTES)) {
+    return bounded;
+  }
+  // A run that can still resume must not fail over diagnostics, so keep only
+  // what the worker needs before giving up on the checkpoint.
+  const segment = result.stats.runtimeWorkCounterSegment;
+  const withoutDiagnostics = {
+    ...result,
+    logs: [
+      '[deepline] terminal diagnostic metadata was dropped (logs, stats, steps); the resume checkpoint is complete.',
+    ],
+    logContexts: undefined,
+    logMetadata: undefined,
+    logIds: undefined,
+    stats: segment === undefined ? {} : { runtimeWorkCounterSegment: segment },
+    steps: [],
+  };
+  if (
+    fitsJsonByteLimit(withoutDiagnostics, TERMINAL_SUSPENDED_RESULT_MAX_BYTES)
+  ) {
+    return withoutDiagnostics;
+  }
+  const { checkpoint: _checkpoint, suspension, ...diagnostics } = bounded;
+  const checkpointMiB = (result.checkpointBytes / (1024 * 1024)).toFixed(2);
+  const limitMiB = RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES / (1024 * 1024);
+  const message =
+    `The play paused (${suspension.kind}) with a ${checkpointMiB} MiB resume checkpoint, which does not fit the ${limitMiB} MiB limit, so it cannot resume. ` +
+    'Split the work into smaller runs, or finish fewer tool calls before the pause.';
+  const error = `${RUNTIME_SUSPENDED_CHECKPOINT_TOO_LARGE_CODE}: ${message}`;
+  return {
+    ...diagnostics,
+    status: 'failed',
+    error,
+    errors: [
+      {
+        code: RUNTIME_SUSPENDED_CHECKPOINT_TOO_LARGE_CODE,
+        phase: 'runtime',
+        message,
+        retryable: false,
+        cause: error,
+      },
+    ],
+    checkpointDisposition:
+      RUNNER_TERMINAL_CHECKPOINT_DISPOSITION.OMITTED_TERMINAL_REPLAY,
+    checkpointBytes: result.checkpointBytes,
+  };
+}
+
 export function runnerTerminalResultForTransport(
   result: PlayRunnerResult | PlayRunnerTerminalTransportResult,
 ): PlayRunnerTerminalTransportResult {
@@ -534,7 +663,9 @@ export function runnerTerminalResultForTransport(
   if (transportResult.status === 'suspended') {
     // A suspended result retains its exact checkpoint because it is needed to
     // resume. Its checkpoint follows the dedicated receipt transport contract.
-    return transportResult;
+    return suspendedResultWithinGatewayBody(
+      transportResult as SuspendedRunnerResult & IncludedResumeCheckpoint,
+    );
   }
   const bounded = boundSettledTerminalTransportDiagnostics(transportResult);
   if (!fitsJsonByteLimit(bounded, TERMINAL_RUN_RESULT_MAX_BYTES)) {

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;

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

@@ -137,6 +137,7 @@ import {
   isCtxFetchHttpFailureDiagnostic,
   parseCtxFetchHttpFailureDiagnostic,
   readProvenanceTag,
+  tagLogEntry,
   type CtxFetchHttpFailureDiagnostic,
 } from '../log-provenance';
 import {
@@ -473,7 +474,10 @@ export type PostgresSchedulerAttemptExecutor = (
 
 type PostgresSchedulerCompletionLogMetadata = 'attach' | 'omit';
 
-type PostgresSchedulerTerminalLogOutbox = 'omit' | 'ctx_log_tail';
+type PostgresSchedulerTerminalLogOutbox =
+  | 'omit'
+  | 'ctx_log_tail'
+  | 'failure_reason';
 
 export type PostgresSchedulerSandboxCrashDiagnosticRequest = {
   schemaVersion: 1;
@@ -506,7 +510,12 @@ type PostgresSchedulerClaimExecutionOptions = Pick<
    * Detached runners push their complete result into Postgres before a worker
    * wakes to finalize it. Put their authored log tail in the terminal outbox
    * so a worker can exit immediately without losing that tail to a detached
-   * HTTP projection.
+   * HTTP projection. `failure_reason` is for a failure no runner delivered: a
+   * failed run gets one error line stating why, so a run that failed before
+   * Play code started has a reason in its logs. Never use it for a runner's own
+   * terminal. An empty `logs` there proves nothing, because the accept trigger
+   * moves a pushed tail out of the result, and the CLI shows the last log line
+   * as the customer's recent logs.
    */
   terminalLogOutbox?: PostgresSchedulerTerminalLogOutbox;
   /** Internal provider-read coordinates which must survive terminal-worker
@@ -15120,6 +15129,36 @@ function sanitizeTerminalLogBody(line: string): string {
   return sanitizeLedgerLogLine(body, !runtimeDiagnostic);
 }
 
+/**
+ * One error line stating why a run failed. `message` must be the public failure
+ * text. The line ID keeps it out of the envelope's position space, where a
+ * pushed runner tail may already own position 0: a different line there would
+ * abort the terminal write and strand the run.
+ */
+function terminalFailureReasonLogProjection(input: {
+  attempt: number;
+  message: string;
+}): {
+  lines: string[];
+  lineContexts: Array<PlayLogContext | null>;
+  lineMetadata: Array<PlayLogMetadata | null>;
+  lineIds: Array<string | null>;
+} {
+  const occurredAt = Date.now();
+  return {
+    lines: [
+      tagLogEntry(
+        'diagnostic',
+        'error',
+        `[${new Date(occurredAt).toISOString()}] [runtime.failure] ${input.message}`,
+      ),
+    ],
+    lineContexts: [null],
+    lineMetadata: [{ level: 'error', occurredAt }],
+    lineIds: [`runtime-failure:${input.attempt}`],
+  };
+}
+
 function terminalLogProjectionForOutbox(
   runnerResult: unknown,
   mode: PostgresSchedulerTerminalLogOutbox | undefined,
@@ -15512,10 +15551,19 @@ export async function executePostgresSchedulerClaim(
       checkpoint: null,
       tableNamespace: null,
     };
-    const terminalLogProjection = terminalLogProjectionForOutbox(
-      terminalFailureResult,
-      options.terminalLogOutbox,
-    );
+    const publicFailure = terminalFailureResult.errors?.[0]?.message;
+    const terminalLogProjection: ReturnType<
+      typeof terminalLogProjectionForOutbox
+    > =
+      options.terminalLogOutbox === 'failure_reason'
+        ? terminalFailureReasonLogProjection({
+            attempt: claim.attempt,
+            message: publicFailure?.trim() ? publicFailure : message,
+          })
+        : terminalLogProjectionForOutbox(
+            terminalFailureResult,
+            options.terminalLogOutbox,
+          );
     const failed = await failPostgresSchedulerAttempt(
       client,
       {