deepline 0.3.312 → 0.3.314

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

@@ -200,7 +200,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.312',
+  version: '0.3.314',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/shared_libs/play-runtime/play-run-recovery-policy.ts

@@ -95,6 +95,56 @@ export function isPlayRunRecoveryError(
   );
 }
 
+const RECOVERY_LOG_DETAIL_MAX_KEYS = 24;
+const RECOVERY_LOG_DETAIL_MAX_KEY_CHARS = 64;
+const RECOVERY_LOG_DETAIL_MAX_STRING_CHARS = 200;
+
+export type PlayRunRecoveryLogDetail = Readonly<
+  Record<string, string | number | boolean | null>
+>;
+
+/**
+ * Provider facts an adapter attached to the cause of a recovery error, for the
+ * scheduler's defer log only. The decision's `reason` stays the single durable
+ * recovery fact: this detail is never persisted, never returned to a caller,
+ * and never read to choose a recovery action. It is bounded here, at the edge
+ * that logs it, whatever the adapter supplied. Total by construction, because
+ * a failure to describe a deferral must not alter the deferral.
+ */
+export function playRunRecoveryLogDetail(
+  error: unknown,
+): PlayRunRecoveryLogDetail | null {
+  try {
+    if (!isPlayRunRecoveryError(error)) return null;
+    const cause: unknown = error.cause;
+    if (!cause || typeof cause !== 'object') return null;
+    const supplied = (cause as { recoveryLogDetail?: unknown })
+      .recoveryLogDetail;
+    if (!supplied || typeof supplied !== 'object' || Array.isArray(supplied)) {
+      return null;
+    }
+    const detail: Record<string, string | number | boolean | null> = {};
+    for (const [key, value] of Object.entries(supplied).slice(
+      0,
+      RECOVERY_LOG_DETAIL_MAX_KEYS,
+    )) {
+      const name = key.slice(0, RECOVERY_LOG_DETAIL_MAX_KEY_CHARS);
+      if (typeof value === 'string') {
+        detail[name] = value.slice(0, RECOVERY_LOG_DETAIL_MAX_STRING_CHARS);
+      } else if (
+        value === null ||
+        typeof value === 'boolean' ||
+        (typeof value === 'number' && Number.isFinite(value))
+      ) {
+        detail[name] = value;
+      }
+    }
+    return Object.keys(detail).length > 0 ? detail : null;
+  } catch {
+    return null;
+  }
+}
+
 function errorCode(error: unknown): string | number | null {
   if (!error || typeof error !== 'object') return null;
   const code = (error as { code?: unknown }).code;

package/dist/bundling-sources/shared_libs/play-runtime/run-event-query.ts

@@ -535,8 +535,21 @@ function parseDsl(input: string): RunEventPredicate {
       /^(==|!=|>=|<=|>|<|\b(?:eq|ne|gte|gt|lte|lt|in|exists)\b)/.exec(
         input.slice(position),
       );
-    if (!operation)
-      fail('Run event DSL requires a supported comparison operator.');
+    if (!operation) {
+      const token =
+        /^(?:[=!<>~]+|[A-Za-z_]+)/.exec(input.slice(position))?.[0] ??
+        input[position] ??
+        '<end>';
+      if (token === '=') {
+        const corrected = `${input.slice(0, position)}==${input.slice(position + 1)}`;
+        fail(
+          `Run event DSL does not support "=" at character ${position + 1}. For equality, replace this "=" with "==": ${JSON.stringify(corrected)}.`,
+        );
+      }
+      fail(
+        `Run event DSL does not support ${JSON.stringify(token)} after ${JSON.stringify(match[0])} at character ${position + 1}. Use ==, !=, >, >=, <, <=, in or exists.`,
+      );
+    }
     position += operation[0].length;
     const symbols: Record<string, string> = {
       '==': 'eq',

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

@@ -22,14 +22,216 @@ import {
   DaytonaControlTimeoutError,
 } from './daytona-control-transport';
 
+// Diagnostics below are log-only. They never select an error, a retry, or a
+// recovery decision, and they stay out of every persisted run document.
+const DAYTONA_LOGGED_SANDBOX_STATES: ReadonlySet<string> = new Set([
+  'creating',
+  'restoring',
+  'destroyed',
+  'destroying',
+  'started',
+  'stopped',
+  'starting',
+  'stopping',
+  'error',
+  'build_failed',
+  'pending_build',
+  'building_snapshot',
+  'unknown',
+  'pulling_snapshot',
+  'archived',
+  'archiving',
+  'resizing',
+  'snapshotting',
+  'forking',
+]);
+const DAYTONA_LOGGED_ERROR_NAMES: ReadonlySet<string> = new Set([
+  'DaytonaError',
+  'DaytonaNotFoundError',
+  'DaytonaRateLimitError',
+  'DaytonaAuthenticationError',
+  'DaytonaAuthorizationError',
+  'DaytonaConflictError',
+  'DaytonaValidationError',
+  'DaytonaTimeoutError',
+  'DaytonaConnectionError',
+  'DaytonaControlTimeoutError',
+  'AbortError',
+  'TimeoutError',
+  'TypeError',
+  'Error',
+]);
+const DAYTONA_LOGGED_PROVIDER_TEXT_MAX_CHARS = 160;
+
+/** A provider state from Daytona's published enum, or `unrecognized`. */
+export function daytonaSandboxStateForLog(state: unknown): string | null {
+  if (state === undefined || state === null) return null;
+  return typeof state === 'string' && DAYTONA_LOGGED_SANDBOX_STATES.has(state)
+    ? state
+    : 'unrecognized';
+}
+
+/** A known error class name, or `other`; never a provider-authored string. */
+export function daytonaErrorClassForLog(error: unknown): string {
+  const name = error instanceof Error ? error.name : null;
+  return name !== null && DAYTONA_LOGGED_ERROR_NAMES.has(name) ? name : 'other';
+}
+
+/** The HTTP status carried by a Daytona error, when it has a plausible one. */
+export function daytonaErrorStatusForLog(error: unknown): number | null {
+  if (!error || typeof error !== 'object') return null;
+  const status = (error as { statusCode?: unknown }).statusCode;
+  return typeof status === 'number' &&
+    Number.isInteger(status) &&
+    status >= 100 &&
+    status <= 599
+    ? status
+    : null;
+}
+
+/**
+ * The machine-readable code on a Daytona or transport error (`ERR_CANCELED`,
+ * `ECONNRESET`, ...). Only the conventional constant shape is logged, so a
+ * provider-authored sentence in that field is dropped rather than copied.
+ */
+export function daytonaErrorCodeForLog(error: unknown): string | null {
+  if (!error || typeof error !== 'object') return null;
+  const record = error as { errorCode?: unknown; code?: unknown };
+  const code = record.errorCode ?? record.code;
+  return typeof code === 'string' && /^[A-Z][A-Z0-9_]{1,39}$/.test(code)
+    ? code
+    : null;
+}
+
+/**
+ * Credential redaction for a Daytona control-plane error message. Shared by
+ * the backend's lookup-failure description and the provider text below.
+ */
+export function redactDaytonaErrorDetail(value: string): string {
+  return value
+    .replace(
+      /authorization\s*[=:]\s*bearer\s+[^\s,;]+/gi,
+      'Authorization=Bearer [redacted]',
+    )
+    .replace(
+      /(authorization\s*[=:]\s*)(?!bearer\s+\[redacted\])[^\s,;]+/gi,
+      '$1[redacted]',
+    )
+    .replace(/(bearer\s+)[^\s,;]+/gi, '$1[redacted]')
+    .replace(/((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi, '$1[redacted]')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 1_000);
+}
+
+/**
+ * Provider free text (for example a sandbox `errorReason`) for logs. This
+ * field is written by the provider, so it is redacted more strictly than the
+ * shared function alone: URL userinfo, any authorization scheme, password,
+ * secret, token, signature, credential and key pairs in query, header or JSON
+ * form, email addresses, and opaque identifiers such as organization ids. It
+ * is then cut to one short fixed bound so an upstream response is never
+ * copied wholesale.
+ */
+export function boundedDaytonaProviderTextForLog(
+  value: unknown,
+): string | null {
+  if (typeof value !== 'string') return null;
+  const strict = value
+    .replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, '$1[redacted]@')
+    .replace(
+      /(authorization\s*[=:]\s*["']?)(?:[a-z]+\s+)?[^\s,;"']+/gi,
+      '$1[redacted]',
+    )
+    .replace(/\b(basic|bearer)\s+[A-Za-z0-9+/=._~-]{8,}/gi, '$1 [redacted]')
+    .replace(
+      /(["']?[\w.-]*(?:password|passwd|secret|token|signature|credential|api[_-]?key|access[_-]?key)[\w.-]*["']?\s*[=:]\s*)(?:"[^"]*"|'[^']*'|[^\s&,;"'}\]]+)/gi,
+      '$1[redacted]',
+    )
+    .replace(
+      /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/g,
+      '[redacted-email]',
+    )
+    .replace(
+      /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi,
+      '[redacted-id]',
+    )
+    .replace(
+      /\b(?=[A-Za-z0-9_-]*\d)(?=[A-Za-z0-9_-]*[A-Za-z])[A-Za-z0-9_-]{24,}\b/g,
+      '[redacted-id]',
+    );
+  const bounded = redactDaytonaErrorDetail(strict).slice(
+    0,
+    DAYTONA_LOGGED_PROVIDER_TEXT_MAX_CHARS,
+  );
+  return bounded || null;
+}
+
+/** 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. */
+  createResponseReceived: boolean;
+  /**
+   * Provider sandbox id from the create response, when one was returned. It
+   * is not named `sandboxId`: lifecycle tooling reads that key on a stage
+   * event as an acquired sandbox, and this one never started.
+   */
+  createResponseSandboxId: string | null;
+  /** Last provider state this client saw while waiting for `started`. */
+  lastObservedState: string | null;
+  providerErrorReason: string | null;
+  causeClass: string;
+  /** The cause's machine code, such as `ERR_CANCELED` or `ECONNRESET`. */
+  causeErrno: string | null;
+  causeStatus: number | null;
+};
+
+/**
+ * Describe an unknown create outcome for logs. Total by construction: if the
+ * description cannot be built, the caller still throws the same error without
+ * one, because a different error here would release the reservation and send
+ * a second create.
+ */
+function describeUnknownLaunchOutcome(input: {
+  data: SandboxData | undefined;
+  waiting: Sandbox | undefined;
+  error: unknown;
+}): DaytonaLaunchOutcomeDiagnostic | null {
+  try {
+    const { data, waiting, error } = input;
+    return {
+      createResponseReceived: data !== undefined,
+      createResponseSandboxId: data?.id ? String(data.id).slice(0, 64) : null,
+      lastObservedState: daytonaSandboxStateForLog(
+        waiting?.state ?? data?.state,
+      ),
+      providerErrorReason: boundedDaytonaProviderTextForLog(
+        waiting?.errorReason ?? data?.errorReason,
+      ),
+      causeClass: daytonaErrorClassForLog(error),
+      causeErrno: daytonaErrorCodeForLog(error),
+      causeStatus: daytonaErrorStatusForLog(error),
+    };
+  } catch {
+    return null;
+  }
+}
+
 /** A sent create may have committed even when no response reached the worker. */
 export class DaytonaLaunchOutcomeUnknownError extends Error {
-  constructor(cause: unknown) {
+  /** Log-only; absent when the error was not raised by the launch client. */
+  readonly diagnostic: DaytonaLaunchOutcomeDiagnostic | null;
+
+  constructor(
+    cause: unknown,
+    diagnostic: DaytonaLaunchOutcomeDiagnostic | null = null,
+  ) {
     super(
       'Daytona named create outcome is unknown; reconcile the same operation before another launch.',
       { cause },
     );
     this.name = 'DaytonaLaunchOutcomeUnknownError';
+    this.diagnostic = diagnostic;
   }
 }
 
@@ -208,6 +410,8 @@ export function createDaytonaLaunchClient(
       const phase = deadline(timeoutMs, cancellation);
       let sent = false;
       let data: SandboxData | undefined;
+      // Read only to describe an unknown outcome in logs.
+      let waiting: Sandbox | undefined;
       try {
         phase.signal.throwIfAborted();
         const api = new SandboxApi(
@@ -244,6 +448,7 @@ export function createDaytonaLaunchClient(
         );
         data = response.data;
         const sandbox = makeSandbox(data, () => phase.signal);
+        waiting = sandbox;
         await sandbox.waitUntilStarted(options.timeout ?? 60);
         // Future phases own fresh deadlines; none inherits this create scope.
         return makeSandbox(
@@ -270,7 +475,10 @@ export function createDaytonaLaunchClient(
           error instanceof DaytonaError &&
           [400, 401, 403, 429].includes(error.statusCode ?? 0);
         if (sent && !confirmedRejection)
-          throw new DaytonaLaunchOutcomeUnknownError(error);
+          throw new DaytonaLaunchOutcomeUnknownError(
+            error,
+            describeUnknownLaunchOutcome({ data, waiting, error }),
+          );
         throw error;
       } finally {
         phase.dispose();

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

@@ -1,5 +1,13 @@
 import type { CreateSandboxFromSnapshotParams, Sandbox } from '@daytonaio/sdk';
-import { DaytonaLaunchOutcomeUnknownError } from './daytona-launch-transport';
+import {
+  boundedDaytonaProviderTextForLog,
+  type DaytonaLaunchOutcomeDiagnostic,
+  DaytonaLaunchOutcomeUnknownError,
+  daytonaErrorClassForLog,
+  daytonaErrorCodeForLog,
+  daytonaErrorStatusForLog,
+  daytonaSandboxStateForLog,
+} from './daytona-launch-transport';
 import type {
   PlayRunnerExecutionConfig,
   PlayRunnerResult,
@@ -110,7 +118,15 @@ export class DaytonaSandboxAcquisitionUnavailableError extends Error {
  * creating another sandbox could execute the Play twice.
  */
 export class DaytonaSandboxTransitionPendingError extends Error {
-  constructor(readonly sandboxName: string) {
+  constructor(
+    readonly sandboxName: string,
+    /**
+     * What Daytona reported when this decision was made. Log-only: a 404, a
+     * lookup error, and every non-started state all reach this same error, so
+     * the scheduler logs this to tell them apart. It never changes recovery.
+     */
+    readonly recoveryLogDetail: DaytonaSandboxTransitionPendingLogDetail | null = null,
+  ) {
     super(
       `Daytona sandbox ${sandboxName} is still transitioning after create timed out.`,
     );
@@ -118,6 +134,140 @@ export class DaytonaSandboxTransitionPendingError extends Error {
   }
 }
 
+/** One provider lookup of the named sandbox, reduced to bounded log facts. */
+type DaytonaNamedSandboxObservation = {
+  lookup: 'found' | 'not_found' | 'error' | 'unsupported';
+  sandboxState: string | null;
+  /** Not `sandboxId`: that key means an acquired sandbox to lifecycle tooling. */
+  observedSandboxId: string | null;
+  providerErrorReason: string | null;
+  lookupErrorClass: string | null;
+  lookupErrno: string | null;
+  lookupErrorStatus: number | null;
+};
+
+/**
+ * Flat, bounded scalars only: enumerated states and classes, one provider
+ * sandbox id, counts, durations, and one capped provider text field.
+ */
+export type DaytonaSandboxTransitionPendingLogDetail =
+  DaytonaNamedSandboxObservation & {
+    phase: 'create_reconcile' | 'resume';
+    /** Names the case; all of them map to the same recovery decision. */
+    reasonDetail: string;
+    providerAttempt: number;
+    /** Lookups issued by this decision's reconcile ladder (at most 7). */
+    lookups: number;
+    lookupErrors: number;
+    deleteConflicts: number;
+    elapsedMs: number;
+    /** Known only in the process that sent the create. */
+    createResponseReceived: boolean | null;
+    createLastObservedState: string | null;
+  };
+
+const NO_DAYTONA_NAMED_SANDBOX_LOOKUP: DaytonaNamedSandboxObservation = {
+  lookup: 'unsupported',
+  sandboxState: null,
+  observedSandboxId: null,
+  providerErrorReason: null,
+  lookupErrorClass: null,
+  lookupErrno: null,
+  lookupErrorStatus: null,
+};
+
+// Both observers are total: they run between a provider lookup and the
+// decision it feeds, so a failure to describe the lookup must not surface.
+function observeDaytonaNamedSandbox(
+  sandbox: DaytonaSandbox,
+): DaytonaNamedSandboxObservation {
+  try {
+    const record = sandbox as { id?: unknown; errorReason?: unknown };
+    return {
+      ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP,
+      lookup: 'found',
+      sandboxState: daytonaSandboxStateForLog(sandbox.state) ?? 'missing',
+      observedSandboxId:
+        typeof record.id === 'string' && record.id
+          ? record.id.slice(0, 64)
+          : null,
+      providerErrorReason: boundedDaytonaProviderTextForLog(record.errorReason),
+    };
+  } catch {
+    return {
+      ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP,
+      lookup: 'found',
+      sandboxState: 'unreadable',
+    };
+  }
+}
+
+function observeDaytonaNamedSandboxLookupFailure(
+  error: unknown,
+): DaytonaNamedSandboxObservation {
+  try {
+    return {
+      ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP,
+      lookup: isDaytonaSandboxNotFound(error) ? 'not_found' : 'error',
+      lookupErrorClass: daytonaErrorClassForLog(error),
+      lookupErrno: daytonaErrorCodeForLog(error),
+      lookupErrorStatus: daytonaErrorStatusForLog(error),
+    };
+  } catch {
+    return { ...NO_DAYTONA_NAMED_SANDBOX_LOOKUP, lookup: 'error' };
+  }
+}
+
+function daytonaTransitionPendingReasonDetail(
+  phase: DaytonaSandboxTransitionPendingLogDetail['phase'],
+  observation: DaytonaNamedSandboxObservation,
+  deleteConflicts: number,
+): string {
+  if (observation.lookup !== 'found') {
+    return `${phase}:lookup_${observation.lookup}`;
+  }
+  // Reconcile reaches a pending decision with a visible sandbox only after
+  // every delete of it reported an in-progress state change.
+  return deleteConflicts > 0
+    ? `${phase}:delete_conflict:${observation.sandboxState}`
+    : `${phase}:sandbox_state:${observation.sandboxState}`;
+}
+
+/**
+ * The log detail for one pending decision. Total by construction: failing to
+ * describe a decision must never replace the decision.
+ */
+function daytonaTransitionPendingLogDetail(input: {
+  phase: DaytonaSandboxTransitionPendingLogDetail['phase'];
+  observed: TimedOutDaytonaSandboxReconcileObserved;
+  providerAttempt: number;
+  launchOutcome: DaytonaLaunchOutcomeDiagnostic | null;
+}): DaytonaSandboxTransitionPendingLogDetail | null {
+  try {
+    const { last, lookups, lookupErrors, deleteConflicts, elapsedMs } =
+      input.observed;
+    return {
+      ...last,
+      phase: input.phase,
+      reasonDetail: daytonaTransitionPendingReasonDetail(
+        input.phase,
+        last,
+        deleteConflicts,
+      ),
+      providerAttempt: input.providerAttempt,
+      lookups,
+      lookupErrors,
+      deleteConflicts,
+      elapsedMs,
+      createResponseReceived:
+        input.launchOutcome?.createResponseReceived ?? null,
+      createLastObservedState: input.launchOutcome?.lastObservedState ?? null,
+    };
+  } catch {
+    return null;
+  }
+}
+
 export function resolveDaytonaSandboxAcquisitionUnavailableReason(
   errors: readonly string[],
 ): DaytonaSandboxAcquisitionUnavailableReason | null {
@@ -369,11 +519,21 @@ async function createOneShotDaytonaSandbox(input: {
   });
 }
 
-type TimedOutDaytonaSandboxReconciliation =
+/** Log-only tally of one reconcile ladder; it never selects the result. */
+type TimedOutDaytonaSandboxReconcileObserved = {
+  last: DaytonaNamedSandboxObservation;
+  lookups: number;
+  lookupErrors: number;
+  deleteConflicts: number;
+  elapsedMs: number;
+};
+
+type TimedOutDaytonaSandboxReconciliation = (
   | { kind: 'started'; sandbox: DaytonaSandbox }
   | { kind: 'deleted' }
   | { kind: 'not_found' }
-  | { kind: 'transition_pending' };
+  | { kind: 'transition_pending' }
+) & { observed: TimedOutDaytonaSandboxReconcileObserved };
 
 async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
   daytona: DaytonaClient;
@@ -386,7 +546,19 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     runId?: string;
   };
 }): Promise<TimedOutDaytonaSandboxReconciliation> {
-  if (!input.daytona.get) return { kind: 'not_found' };
+  const reconcileStartedAt = Date.now();
+  let last = NO_DAYTONA_NAMED_SANDBOX_LOOKUP;
+  let lookups = 0;
+  let lookupErrors = 0;
+  let deleteConflicts = 0;
+  const observed = (): TimedOutDaytonaSandboxReconcileObserved => ({
+    last,
+    lookups,
+    lookupErrors,
+    deleteConflicts,
+    elapsedMs: Date.now() - reconcileStartedAt,
+  });
+  if (!input.daytona.get) return { kind: 'not_found', observed: observed() };
   let lastDeleteConflict: unknown = null;
   for (const delayMs of DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS) {
     input.cancellationSignal?.throwIfAborted();
@@ -394,9 +566,11 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
       await waitForAcquisitionRetry(delayMs, input.cancellationSignal);
     }
     let sandbox: DaytonaSandbox;
+    lookups += 1;
     try {
       sandbox = await input.daytona.get(input.sandboxName);
     } catch (error) {
+      last = observeDaytonaNamedSandboxLookupFailure(error);
       const providerStatus =
         error && typeof error === 'object' && 'statusCode' in error
           ? error.statusCode
@@ -410,7 +584,10 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
       // A current absence is not proof that the sent create cannot commit.
       // Return it to the durable operation owner without another create or
       // releasing capacity; later recovery re-reads the same identity.
-      if (isDaytonaSandboxNotFound(error)) return { kind: 'not_found' };
+      if (isDaytonaSandboxNotFound(error)) {
+        return { kind: 'not_found', observed: observed() };
+      }
+      lookupErrors += 1;
       continue;
     }
     input.emitStage?.('create:reconcile_state', {
@@ -423,8 +600,9 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     // is safer and faster than attempting a conflicting delete or creating a
     // second sandbox.
     if (sandbox.state === 'started') {
-      return { kind: 'started', sandbox };
+      return { kind: 'started', sandbox, observed: observed() };
     }
+    last = observeDaytonaNamedSandbox(sandbox);
     if (input.operationIdentity) {
       const expected = input.operationIdentity;
       const configuredOrganizationId =
@@ -455,6 +633,7 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
       // sandbox while the first one is still becoming ready.
       if (isDaytonaSandboxStateChangeConflict(error)) {
         lastDeleteConflict = error;
+        deleteConflicts += 1;
         continue;
       }
       throw new Error(
@@ -462,12 +641,12 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
         { cause: error },
       );
     }
-    return { kind: 'deleted' };
+    return { kind: 'deleted', observed: observed() };
   }
   if (lastDeleteConflict) {
-    return { kind: 'transition_pending' };
+    return { kind: 'transition_pending', observed: observed() };
   }
-  return { kind: 'not_found' };
+  return { kind: 'not_found', observed: observed() };
 }
 
 function daytonaSandboxName(providerOperationToken?: string | null): string {
@@ -553,8 +732,17 @@ async function createRetriedOneShotDaytonaSandbox(input: {
         );
       }
       // Neither absence nor an ongoing transition proves that create cannot
-      // commit. Retain the durable identity and its capacity reservation.
-      throw new DaytonaSandboxTransitionPendingError(sandboxName);
+      // commit. Retain the durable identity and its capacity reservation. The
+      // detail only records which of the two Daytona reported, for the log.
+      throw new DaytonaSandboxTransitionPendingError(
+        sandboxName,
+        daytonaTransitionPendingLogDetail({
+          phase: 'resume',
+          observed: reconciliation.observed,
+          providerAttempt: attempt,
+          launchOutcome: null,
+        }),
+      );
     }
     let sandbox: DaytonaSandbox;
     try {
@@ -579,17 +767,29 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           errorClass: daytonaCreateErrorClass(error),
         });
       errors.push(message);
+      // Log-only: whether the create request returned before the deadline and
+      // what Daytona last reported, so an unknown outcome is attributable.
+      const launchOutcome =
+        error instanceof DaytonaLaunchOutcomeUnknownError
+          ? error.diagnostic
+          : null;
+      const createFailureLogDetail = {
+        createErrorClass: daytonaCreateErrorClass(error),
+        ...(launchOutcome ?? {}),
+      };
       input.emitStage('create:attempt_failed', {
         attempt,
         elapsedMs: Date.now() - input.startedAt,
         attemptElapsedMs: Date.now() - attemptStartedAt,
         error: message,
+        ...createFailureLogDetail,
       });
       console.warn('[play-runner.daytona.create_attempt_failed]', {
         workflowId: input.context.workflowId ?? null,
         runId: input.context.runId ?? null,
         attempt,
         error: message,
+        ...createFailureLogDetail,
       });
       const immediateFallbackReason =
         resolveDaytonaSandboxAcquisitionUnavailableReason([message]);
@@ -640,9 +840,21 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           };
         }
         await recordCreateFailure();
+        // Same decision as before; the detail records what the ladder saw.
+        const reconcileObserved = reconciliation.observed;
+        const reconcilePending = (): DaytonaSandboxTransitionPendingError =>
+          new DaytonaSandboxTransitionPendingError(
+            sandboxName,
+            daytonaTransitionPendingLogDetail({
+              phase: 'create_reconcile',
+              observed: reconcileObserved,
+              providerAttempt: attempt,
+              launchOutcome,
+            }),
+          );
         if (reconciliation.kind === 'transition_pending') {
           if (reservation?.providerOperationToken) {
-            throw new DaytonaSandboxTransitionPendingError(sandboxName);
+            throw reconcilePending();
           }
           throw new Error(
             `Daytona timed-out sandbox ${sandboxName} remained in a state transition across the bounded cleanup window. Modal fallback suppressed.`,
@@ -663,7 +875,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           );
         }
         if (reservation?.providerOperationToken) {
-          throw new DaytonaSandboxTransitionPendingError(sandboxName);
+          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.`,