deepline 0.3.450 → 0.3.452

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.450',
+  version: '0.3.452',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/index.ts

@@ -303,7 +303,11 @@ function createPlayRuntimeRequire(): ReturnType<typeof createRequire> {
 }
 const WAIT_CONFIG_POLL_MS = 25;
 const WAIT_CONFIG_TIMEOUT_MS = 120_000;
-export const RUNNER_EXECUTION_ACK_TIMEOUT_MS = 75_000;
+// Outlasts the claim lease, because an unanswered heartbeat says nothing about
+// the park. A stall shorter than the lease keeps this sandbox, and a longer one
+// reaches the heartbeat loop's own guard and is reported as an outage.
+export const RUNNER_EXECUTION_ACK_TIMEOUT_MS =
+  (RUNTIME_RELIABILITY_POLICY.worker.claimLeaseSeconds + 30) * 1_000;
 const RUNNER_RUNTIME_CONTROL_MAX_ATTEMPTS =
   RUNTIME_RELIABILITY_POLICY.gateway.runnerControlMaxAttempts;
 const RUNNER_RUNTIME_CONTROL_RETRY_DELAYS_MS = [100, 250] as const;

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-lifecycle.ts

@@ -37,6 +37,12 @@ const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
 const DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS = [
   0, 1_000, 3_000, 6_000, 12_000, 24_000, 36_000,
 ] as const;
+// A reservation can outlive a create that was refused, or one never sent because
+// the scheduler stalled between committing the reservation and acknowledging it.
+// This delay lets a healthy owner finish its create and reconcile ladder first.
+// It is not a fence: a stalled owner can outlast it, so name uniqueness and the
+// attempt fences on abandon and promotion keep custody safe.
+const DAYTONA_ABSENT_OPERATION_RECREATE_AFTER_MS = 3 * 60_000;
 // Explicit runner deadline + scheduler GC own the normal lifecycle. Daytona's
 // inactivity stop is a wider crash backstop measured from sandbox creation, so
 // setup time cannot consume the terminal-flush grace.
@@ -671,6 +677,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
     leaseId: string;
     providerOperationToken: string | null;
     resumeExistingProviderOperation?: boolean;
+    existingProviderOperationAgeMs?: number;
   }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   nextProviderAttempt: () => number;
@@ -700,6 +707,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
     });
     const reservation = await input.reserveSandboxCapacity?.(attempt);
     const sandboxName = daytonaSandboxName(reservation?.providerOperationToken);
+    let recreatedAfter: TimedOutDaytonaSandboxReconcileObserved | null = null;
     if (reservation?.resumeExistingProviderOperation) {
       if (!reservation.providerOperationToken) {
         throw new DaytonaSandboxTransitionPendingError(sandboxName);
@@ -740,17 +748,32 @@ async function createRetriedOneShotDaytonaSandbox(input: {
         );
       }
       // Neither absence nor an ongoing transition proves that create cannot
-      // 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,
-        }),
-      );
+      // commit, so inside the create window retain the durable identity and
+      // its capacity reservation. The detail only records which of the two
+      // Daytona reported, for the log.
+      const operationAgeMs = reservation.existingProviderOperationAgeMs ?? 0;
+      if (
+        reconciliation.observed.last.lookup !== 'not_found' ||
+        operationAgeMs < DAYTONA_ABSENT_OPERATION_RECREATE_AFTER_MS
+      ) {
+        throw new DaytonaSandboxTransitionPendingError(
+          sandboxName,
+          daytonaTransitionPendingLogDetail({
+            phase: 'resume',
+            observed: reconciliation.observed,
+            providerAttempt: attempt,
+            launchOutcome: null,
+          }),
+        );
+      }
+      // Daytona's own name uniqueness fences this: the same identity under the
+      // same reservation cannot become a second sandbox. A create that lands
+      // first surfaces as a conflict, which the reconcile below adopts by name.
+      input.emitStage('create:recreate_absent_operation', {
+        attempt,
+        operationAgeMs,
+      });
+      recreatedAfter = reconciliation.observed;
     }
     let sandbox: DaytonaSandbox;
     try {
@@ -895,6 +918,20 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           { cause: error },
         );
       }
+      if (recreatedAfter) {
+        // Refusing this send says nothing about an earlier send of the identity,
+        // so keep its reservation and resume the same name.
+        await recordCreateFailure();
+        throw new DaytonaSandboxTransitionPendingError(
+          sandboxName,
+          daytonaTransitionPendingLogDetail({
+            phase: 'resume',
+            observed: recreatedAfter,
+            providerAttempt: attempt,
+            launchOutcome: null,
+          }),
+        );
+      }
       if (reservation) {
         await input.releaseSandboxCapacity?.(reservation.leaseId);
       }
@@ -1098,6 +1135,7 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
     leaseId: string;
     providerOperationToken: string | null;
     resumeExistingProviderOperation?: boolean;
+    existingProviderOperationAgeMs?: number;
   }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   startAdmission?: DaytonaSandboxStartAdmission;

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/contract.ts

@@ -245,6 +245,8 @@ export type SandboxExecutionAdmission = {
         providerOperationToken?: string | null;
         /** Resume the existing durable provider operation before any new create. */
         resumeExistingProviderOperation?: boolean;
+        /** Scheduler-clock age of the operation being resumed. */
+        existingProviderOperationAgeMs?: number;
       }
     | { kind: 'pre_code_deferred'; reason: SandboxPreCodeDeferralReason }
   >;
@@ -310,6 +312,8 @@ export type SandboxExecutionLifecycle = {
         providerOperationToken?: string | null;
         /** Resume the existing durable provider operation before any new create. */
         resumeExistingProviderOperation?: boolean;
+        /** Scheduler-clock age of the operation being resumed. */
+        existingProviderOperationAgeMs?: number;
       }
     | { kind: 'pre_code_deferred'; reason: SandboxPreCodeDeferralReason }
   >;

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/runner-backend-adapter.ts

@@ -188,6 +188,12 @@ function createRunnerCallbacks(input: {
         ...(outcome.resumeExistingProviderOperation === true
           ? { resumeExistingProviderOperation: true }
           : {}),
+        ...(outcome.existingProviderOperationAgeMs === undefined
+          ? {}
+          : {
+              existingProviderOperationAgeMs:
+                outcome.existingProviderOperationAgeMs,
+            }),
       };
     },
     releaseSandboxCapacity: async (leaseId) => {

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

@@ -4338,13 +4338,15 @@ async function executeAssignedAbsurdAttempt(input: {
                     providerOperationToken: reserved.providerOperationToken,
                     resumeExistingProviderOperation:
                       reserved.resumeExistingProviderOperation,
+                    existingProviderOperationAgeMs:
+                      reserved.existingProviderOperationAgeMs,
                   };
                 },
                 async releaseCapacity({ leaseId }) {
                   await deps.runWithClient((client) =>
                     abandonRuntimeSandboxOperationReservation(
                       client,
-                      { operationKey: leaseId },
+                      { operationKey: leaseId, attempt: generation },
                       options,
                     ),
                   );

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

@@ -286,6 +286,11 @@ export async function reserveRuntimeSandboxCapacityLease(
       activeLeases: number;
       wouldDefer: boolean;
       resumeExistingProviderOperation: boolean;
+      /**
+       * Database-clock age of a resumed operation. Absent on a same-key race and
+       * once the lease expires, when a new sandbox could no longer be promoted.
+       */
+      existingProviderOperationAgeMs?: number;
     }
   | { granted: false; limit: number; activeLeases: number }
 > {
@@ -316,6 +321,7 @@ export async function reserveRuntimeSandboxCapacityLease(
       provider_operation_token: string | null;
       attempt: number;
       environment: 'preview' | 'production';
+      age_ms: number | null;
     }>;
     existing_operation: {
       org_id: string;
@@ -361,7 +367,10 @@ export async function reserveRuntimeSandboxCapacityLease(
           SELECT jsonb_agg(pending)
           FROM (
             SELECT lease.lease_id, operation.provider_operation_token,
-                   operation.attempt, operation.environment
+                   operation.attempt, operation.environment,
+                   CASE WHEN lease.expires_at > clock_timestamp() THEN
+                     extract(epoch FROM clock_timestamp() - operation.created_at) * 1000
+                   END AS age_ms
             FROM ${operations} AS operation
             JOIN ${leases} AS lease ON lease.lease_id = operation.operation_key
             WHERE $6::boolean
@@ -503,6 +512,9 @@ export async function reserveRuntimeSandboxCapacityLease(
         activeLeases,
         wouldDefer,
         resumeExistingProviderOperation: true,
+        ...(pendingOperation.age_ms === null
+          ? {}
+          : { existingProviderOperationAgeMs: Number(pendingOperation.age_ms) }),
       };
     }
   }
@@ -874,7 +886,8 @@ export async function releaseRuntimeSandboxCapacityLease(
  */
 export async function abandonRuntimeSandboxOperationReservation(
   client: PostgresSchedulerQueryClient,
-  input: { operationKey: string },
+  /** With `attempt`, an operation a newer attempt has adopted is left alone. */
+  input: { operationKey: string; attempt?: number },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<boolean> {
   const { leases, operations, runs } = schemaTables(options);
@@ -899,6 +912,7 @@ export async function abandonRuntimeSandboxOperationReservation(
             updated_at = clock_timestamp()
         WHERE operation.operation_key = $1
           AND operation.state = $3
+          AND ($4::integer IS NULL OR operation.attempt <= $4)
           AND EXISTS (SELECT 1 FROM eligible_lease)
         RETURNING operation.operation_key
       ), released AS (
@@ -915,6 +929,7 @@ export async function abandonRuntimeSandboxOperationReservation(
       assertId(input.operationKey, 'operationKey'),
       RuntimeSandboxOperationState.Abandoned,
       RuntimeSandboxOperationState.Reserved,
+      input.attempt ?? null,
     ],
   );
   return result.rows.length === 1;

package/dist/cli/auth-36DQP46D.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkM4FFNUF4js = require('./chunk-M4FFNUF4.js');
+require('./chunk-ZKGK2JU3.js');
+require('./chunk-ETFVH7PO.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-7JSZOUNU.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkM4FFNUF4js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkM4FFNUF4js.authStatusLine; exports.clearPendingClaim = _chunkM4FFNUF4js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkM4FFNUF4js.clearSatisfiedPendingClaim; exports.handleRegister = _chunkM4FFNUF4js.handleRegister; exports.handleStatus = _chunkM4FFNUF4js.handleStatus; exports.handleWait = _chunkM4FFNUF4js.handleWait; exports.httpJson = _chunkM4FFNUF4js.httpJson; exports.readPendingAuthClaim = _chunkM4FFNUF4js.readPendingAuthClaim; exports.readStatusBanner = _chunkM4FFNUF4js.readStatusBanner; exports.registerAuthCommands = _chunkM4FFNUF4js.registerAuthCommands; exports.reportSetupCompleted = _chunkM4FFNUF4js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkM4FFNUF4js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkM4FFNUF4js.statusBannerLine;

package/dist/cli/{auth-CHYW6BU3.mjs → auth-DKZLB6GN.mjs}

@@ -13,13 +13,13 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-N42KCXPD.mjs";
-import "./chunk-4Z356NPN.mjs";
-import "./chunk-5R7YPB5X.mjs";
+} from "./chunk-KQUDU3ZE.mjs";
+import "./chunk-PBQSX6ES.mjs";
+import "./chunk-SM5RZ5JC.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-AJUNUE32.mjs";
+import "./chunk-RFDIXLRX.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {