deepline 0.1.138 → 0.1.140

package/README.md

@@ -65,8 +65,8 @@ Do not route the SDK CLI through `.env`, `.env.local`, or `.env.worktree`.
 Config resolution order:
 
 ```text
-host: explicit SDK option -> DEEPLINE_HOST_URL -> nearest .env.deepline -> Cowork workspace .env.deepline -> saved production auth -> https://code.deepline.com
-key:  explicit SDK option -> DEEPLINE_API_KEY -> matching nearest .env.deepline -> matching Cowork workspace .env.deepline -> saved auth for the resolved host
+host: explicit SDK option -> DEEPLINE_HOST_URL -> nearest .env.deepline -> saved production auth -> https://code.deepline.com
+key:  explicit SDK option -> DEEPLINE_API_KEY -> matching nearest .env.deepline -> saved auth for the resolved host
 ```
 
 ## CLI commands

package/dist/bundling-sources/apps/play-runner-workers/src/coordinator-entry.ts

@@ -53,6 +53,7 @@ import {
 import {
   decideWorkflowPlatformRetry,
   PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
+  shouldPublishWorkflowRuntimeFailure,
 } from './workflow-retry';
 import {
   WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES,
@@ -274,6 +275,7 @@ interface CoordinatorEnv {
   DEEPLINE_INTERNAL_TOKEN?: string;
   DEEPLINE_TAIL_LOG_TOKEN?: string;
   DEEPLINE_COORDINATOR_DEPLOY_MARKER?: string;
+  CF_VERSION_METADATA?: WorkerVersionMetadata;
   VERCEL_PROTECTION_BYPASS_TOKEN?: string;
   DEEPLINE_PLAY_PREVIEW_SLUG?: string;
   /**
@@ -3038,27 +3040,44 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                         : null,
                   },
                 );
-                await markWorkflowRuntimeFailure({
-                  env,
-                  event: innerEvent,
-                  error: innerError,
-                }).catch((markError) => {
-                  console.error(
-                    '[coordinator] failed to forward DynamicWorkflow runner error',
+                if (
+                  shouldPublishWorkflowRuntimeFailure({
+                    error: innerError,
+                    retryAttempts: 0,
+                  })
+                ) {
+                  await markWorkflowRuntimeFailure({
+                    env,
+                    event: innerEvent,
+                    error: innerError,
+                  }).catch((markError) => {
+                    console.error(
+                      '[coordinator] failed to forward DynamicWorkflow runner error',
+                      {
+                        graphHash,
+                        message:
+                          markError instanceof Error
+                            ? markError.message
+                            : String(markError),
+                      },
+                    );
+                  });
+                  await writeCoordinatorTerminalState(env, {
+                    runId: runIdForTrace,
+                    status: 'failed',
+                    error: failure.message,
+                  }).catch(() => undefined);
+                } else {
+                  console.warn(
+                    '[coordinator] DynamicWorkflow platform reset will be retried; not publishing durable run.failed',
                     {
                       graphHash,
-                      message:
-                        markError instanceof Error
-                          ? markError.message
-                          : String(markError),
+                      runId: runIdForTrace,
+                      errorCode: failure.code,
+                      retryLimit: PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
                     },
                   );
-                });
-                await writeCoordinatorTerminalState(env, {
-                  runId: runIdForTrace,
-                  status: 'failed',
-                  error: failure.message,
-                }).catch(() => undefined);
+                }
                 throw innerError;
               }
             },
@@ -3136,7 +3155,20 @@ async function coordinatorRouteFetch(
 ): Promise<Response> {
   const url = new URL(request.url);
   if (url.pathname === '/health') {
-    return new Response('ok', { status: 200 });
+    const headers = new Headers();
+    headers.set(
+      'x-deepline-runtime-deploy-version',
+      env.CF_VERSION_METADATA?.id ??
+        env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
+        '',
+    );
+    if (env.DEEPLINE_COORDINATOR_DEPLOY_MARKER) {
+      headers.set(
+        'x-deepline-deploy-marker',
+        env.DEEPLINE_COORDINATOR_DEPLOY_MARKER,
+      );
+    }
+    return new Response('ok', { status: 200, headers });
   }
   if (url.pathname === '/warmup/submit') {
     const authError = authorizeCoordinatorControlRequest({ request, env });
@@ -3174,6 +3206,10 @@ async function coordinatorRouteFetch(
     return Response.json({
       ok: true,
       deployMarker: env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ?? null,
+      runtimeDeployVersion:
+        env.CF_VERSION_METADATA?.id ??
+        env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
+        null,
     });
   }
   if (url.pathname === '/staged-files/put') {
@@ -3683,6 +3719,10 @@ async function handleWorkflowRoute(input: {
         status: 'submitted',
         workflowInstanceId: instance.id,
         instanceState,
+        runtimeDeployVersion:
+          env.CF_VERSION_METADATA?.id ??
+          env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
+          null,
         coordinatorTimings,
       });
     } finally {

package/dist/bundling-sources/apps/play-runner-workers/src/workflow-retry.ts

@@ -1,6 +1,6 @@
 import { normalizePlayRunFailure } from '../../../shared_libs/play-runtime/run-failure';
 
-export const PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT = 1;
+export const PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT = 5;
 
 export type WorkflowRetryDecision =
   | {
@@ -44,3 +44,17 @@ export function decideWorkflowPlatformRetry(input: {
     message: failure.message,
   };
 }
+
+export function shouldPublishWorkflowRuntimeFailure(input: {
+  error: unknown;
+  retryAttempts: number;
+}): boolean {
+  const message =
+    input.error instanceof Error ? input.error.message : String(input.error);
+  const decision = decideWorkflowPlatformRetry({
+    workflowStatus: 'errored',
+    error: message,
+    retryAttempts: input.retryAttempts,
+  });
+  return decision.action !== 'retry';
+}

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

@@ -15,31 +15,21 @@
  * 1. `options.baseUrl`
  * 2. `DEEPLINE_HOST_URL`
  * 3. nearest project `.env.deepline`
- * 4. Cowork mounted workspace `.env.deepline`
- * 5. production host auth file
- * 6. production fallback: `https://code.deepline.com`
+ * 4. production host auth file
+ * 5. production fallback: `https://code.deepline.com`
  *
  * API key:
  * 1. `options.apiKey`
  * 2. `DEEPLINE_API_KEY`
  * 3. nearest project `.env.deepline`
- * 4. Cowork mounted workspace `.env.deepline`
- * 5. host auth file for the resolved base URL
+ * 4. host auth file for the resolved base URL
  *
  * App/runtime env files such as `.env`, `.env.local`, and `.env.worktree` do
  * not route the SDK CLI. Put CLI routing in `.env.deepline`.
  *
  * @module
  */
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  realpathSync,
-  readFileSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import type { DeeplineClientOptions, ResolvedConfig } from './types.js';
@@ -58,41 +48,8 @@ const DEFAULT_TIMEOUT = 60_000;
 const DEFAULT_MAX_RETRIES = 3;
 
 const PROJECT_DEEPLINE_ENV_FILE = '.env.deepline';
-const COWORK_IGNORED_WORKSPACE_DIRS = new Set([
-  '.auto-memory',
-  '.claude',
-  '.remote-plugins',
-  'outputs',
-  'plugins',
-  'uploads',
-]);
-const COWORK_PROJECT_MARKERS = [
-  '.deepline',
-  '.env.deepline',
-  '.git',
-  'AGENTS.md',
-  'package.json',
-  'pyproject.toml',
-];
 
 type EnvValues = Record<string, string>;
-type ProjectEnvCandidate = {
-  filePath: string;
-  env: EnvValues;
-  source: 'nearest' | 'cowork';
-};
-export type ProjectAuthSource = ProjectEnvCandidate;
-export type ProjectPinTarget =
-  | {
-      ok: true;
-      dir: string;
-      source: 'nearest' | 'cowork' | 'cwd';
-    }
-  | {
-      ok: false;
-      reason: 'ambiguous_cowork_project';
-      candidates: string[];
-    };
 
 /**
  * Convert a base URL to a filesystem-safe slug for per-host config storage.
@@ -162,161 +119,9 @@ function findNearestEnvFile(
   }
 }
 
-function isDirectory(path: string): boolean {
-  try {
-    return statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-function canonicalPath(path: string): string {
-  try {
-    return realpathSync(path);
-  } catch {
-    return resolve(path);
-  }
-}
-
-function isTruthy(value: string | undefined): boolean {
-  return /^(1|true|yes|on)$/i.test(value?.trim() ?? '');
-}
-
-function sessionRootFromPath(path: string | undefined): string | null {
-  const trimmed = path?.trim();
-  if (!trimmed) return null;
-  const match = /^\/sessions\/[^/]+(?=\/|$)/.exec(trimmed);
-  return match?.[0] ?? null;
-}
-
-function coworkSessionRoot(): string | null {
-  const home = process.env.HOME?.trim();
-  const homeSessionRoot = sessionRootFromPath(home);
-  if (homeSessionRoot && isDirectory(join(homeSessionRoot, 'mnt'))) {
-    return homeSessionRoot;
-  }
-
-  const cwdSessionRoot = sessionRootFromPath(process.cwd());
-  if (cwdSessionRoot && isDirectory(join(cwdSessionRoot, 'mnt'))) {
-    return cwdSessionRoot;
-  }
-
-  if (isTruthy(process.env.CLAUDE_CODE_REMOTE) && home) {
-    const mountedRoot = join(home, 'mnt');
-    if (isDirectory(mountedRoot)) return resolve(home);
-  }
-
-  return null;
-}
-
-function isCoworkLikeSandbox(): boolean {
-  const home = process.env.HOME?.trim();
-  return (
-    isTruthy(process.env.CLAUDE_CODE_REMOTE) ||
-    sessionRootFromPath(home) !== null ||
-    sessionRootFromPath(process.cwd()) !== null
-  );
-}
-
-function coworkProjectScore(path: string): number {
-  let score = 0;
-  for (const marker of COWORK_PROJECT_MARKERS) {
-    if (existsSync(join(path, marker))) score += 1;
-  }
-  return score;
-}
-
-function listCoworkWorkspaceDirCandidates(): string[] {
-  if (!isCoworkLikeSandbox()) {
-    return [];
-  }
-
-  const explicitProjectDir = process.env.CLAUDE_PROJECT_DIR?.trim();
-  if (explicitProjectDir && isDirectory(explicitProjectDir)) {
-    return [resolve(explicitProjectDir)];
-  }
-
-  const sessionRoot = coworkSessionRoot();
-  if (!sessionRoot) return [];
-
-  const mountedRoot = join(sessionRoot, 'mnt');
-  if (!isDirectory(mountedRoot)) return [];
-
-  let names: string[];
-  try {
-    names = readdirSync(mountedRoot).sort();
-  } catch {
-    return [];
-  }
-
-  const candidates: string[] = [];
-  for (const name of names) {
-    if (name.startsWith('.') || COWORK_IGNORED_WORKSPACE_DIRS.has(name)) {
-      continue;
-    }
-    const candidate = join(mountedRoot, name);
-    if (isDirectory(candidate)) candidates.push(candidate);
-  }
-
-  if (candidates.length <= 1) return candidates;
-
-  const projectLike = candidates.filter(
-    (candidate) => coworkProjectScore(candidate) > 0,
-  );
-  return projectLike.length > 0 ? projectLike : candidates;
-}
-
-function isInIgnoredCoworkMount(path: string): boolean {
-  const sessionRoot = coworkSessionRoot();
-  if (!sessionRoot) return false;
-  const mountedRoot = canonicalPath(join(sessionRoot, 'mnt'));
-  const resolvedPath = canonicalPath(path);
-  const prefix = `${mountedRoot}/`;
-  if (!resolvedPath.startsWith(prefix)) return false;
-  const relativePath = resolvedPath.slice(prefix.length);
-  const mountName = relativePath.split('/')[0];
-  return (
-    mountName.startsWith('.') || COWORK_IGNORED_WORKSPACE_DIRS.has(mountName)
-  );
-}
-
-function detectCoworkWorkspaceDir(): string | null {
-  const candidates = listCoworkWorkspaceDirCandidates();
-  return candidates.length === 1 ? candidates[0] : null;
-}
-
-function loadProjectEnvCandidates(
-  startDir: string = process.cwd(),
-): ProjectEnvCandidate[] {
-  const filePaths: string[] = [];
-  const sources = new Map<string, ProjectEnvCandidate['source']>();
-  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
-  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
-    filePaths.push(nearestFile);
-    sources.set(resolve(nearestFile), 'nearest');
-  }
-
-  const coworkWorkspaceDir = detectCoworkWorkspaceDir();
-  if (coworkWorkspaceDir) {
-    const coworkFile = join(coworkWorkspaceDir, PROJECT_DEEPLINE_ENV_FILE);
-    if (
-      existsSync(coworkFile) &&
-      !filePaths.some((filePath) => resolve(filePath) === resolve(coworkFile))
-    ) {
-      filePaths.push(coworkFile);
-      sources.set(resolve(coworkFile), 'cowork');
-    }
-  }
-
-  return filePaths.map((filePath) => ({
-    filePath,
-    env: parseEnvFile(filePath),
-    source: sources.get(resolve(filePath)) ?? 'nearest',
-  }));
-}
-
 function loadProjectDeeplineEnv(startDir = process.cwd()): EnvValues {
-  return loadProjectEnvCandidates(startDir)[0]?.env ?? {};
+  const filePath = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
+  return filePath ? parseEnvFile(filePath) : {};
 }
 
 function normalizeBaseUrl(baseUrl: string): string {
@@ -399,13 +204,11 @@ function loadGlobalCliEnv(): EnvValues {
  * Auto-detect the best base URL when none is explicitly provided.
  */
 function autoDetectBaseUrl(): string {
-  const projectEnvs = loadProjectEnvCandidates();
+  const projectEnv = loadProjectDeeplineEnv();
   const globalEnv = loadGlobalCliEnv();
   return (
     normalizeBaseUrl(process.env[HOST_URL_ENV] ?? '') ||
-    firstNonEmpty(
-      ...projectEnvs.map(({ env }) => normalizeBaseUrl(env[HOST_URL_ENV])),
-    ) ||
+    normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? '') ||
     normalizeBaseUrl(globalEnv[HOST_URL_ENV] ?? '') ||
     PROD_URL
   );
@@ -416,38 +219,18 @@ export function resolveApiKeyForBaseUrl(
   explicitApiKey?: string | null,
 ): string {
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-  const projectEnvs = loadProjectEnvCandidates();
+  const projectEnv = loadProjectDeeplineEnv();
   const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
+  const projectBaseUrl = normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? '');
+  const projectKeyApplies = projectBaseUrl === normalizedBaseUrl;
   return firstNonEmpty(
     explicitApiKey,
     process.env[API_KEY_ENV],
-    ...projectEnvs.map(({ env }) => {
-      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? '');
-      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : '';
-    }),
+    projectKeyApplies ? projectEnv[API_KEY_ENV] : '',
     cliEnv[API_KEY_ENV],
   );
 }
 
-function getResolvedProjectAuthSource(
-  baseUrl: string,
-  apiKey: string,
-  startDir: string = process.cwd(),
-): ProjectAuthSource | null {
-  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-  const normalizedApiKey = apiKey.trim();
-  if (!normalizedBaseUrl || !normalizedApiKey) return null;
-  return (
-    loadProjectEnvCandidates(startDir).find(({ env }) => {
-      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? '');
-      return (
-        projectBaseUrl === normalizedBaseUrl &&
-        (env[API_KEY_ENV] ?? '').trim() === normalizedApiKey
-      );
-    }) ?? null
-  );
-}
-
 /**
  * Resolve SDK configuration from the public SDK CLI env contract.
  */
@@ -482,7 +265,6 @@ function mergeProjectEnvFile(filePath: string, values: EnvValues): void {
   const merged = { ...existing, ...values };
   const dir = dirname(filePath);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  ensureProjectEnvIsIgnored(dir);
   const allowedKeys = new Set([HOST_URL_ENV, API_KEY_ENV]);
   const lines = Object.entries(merged)
     .filter(([key, value]) => allowedKeys.has(key) && value !== '')
@@ -490,99 +272,20 @@ function mergeProjectEnvFile(filePath: string, values: EnvValues): void {
   writeFileSync(filePath, `${lines.join('\n')}\n`, 'utf-8');
 }
 
-function ensureProjectEnvIsIgnored(dir: string): void {
-  const gitignorePath = join(dir, '.gitignore');
-  const entry = PROJECT_DEEPLINE_ENV_FILE;
-  const existing = existsSync(gitignorePath)
-    ? readFileSync(gitignorePath, 'utf-8')
-    : '';
-  const alreadyIgnored = existing
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .some((line) => line === entry || line === `/${entry}`);
-  if (alreadyIgnored) return;
-  const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
-  writeFileSync(gitignorePath, `${existing}${prefix}${entry}\n`, 'utf-8');
-}
-
 export function saveProjectDeeplineEnvValues(
   values: EnvValues,
   startDir: string = process.cwd(),
 ): string[] {
-  const target = resolveProjectPinTarget(startDir);
-  if (!target.ok) {
-    throw new ConfigError(
-      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
-        ', ',
-      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder before running this command.`,
-    );
-  }
-  const filePath = join(target.dir, PROJECT_DEEPLINE_ENV_FILE);
+  const filePath = join(resolve(startDir), PROJECT_DEEPLINE_ENV_FILE);
   mergeProjectEnvFile(filePath, values);
   return [filePath];
 }
 
-export function resolveProjectPinDir(startDir: string = process.cwd()): string {
-  const target = resolveProjectPinTarget(startDir);
-  if (!target.ok) {
-    throw new ConfigError(
-      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
-        ', ',
-      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder before running this command.`,
-    );
-  }
-  return target.dir;
-}
-
-export function resolveProjectPinTarget(
-  startDir: string = process.cwd(),
-): ProjectPinTarget {
-  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
-  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
-    return { ok: true, dir: dirname(nearestFile), source: 'nearest' };
-  }
-
-  const coworkCandidates = listCoworkWorkspaceDirCandidates();
-  if (coworkCandidates.length === 1) {
-    return { ok: true, dir: coworkCandidates[0], source: 'cowork' };
-  }
-  if (coworkCandidates.length > 1) {
-    const resolvedStartDir = canonicalPath(startDir);
-    const cwdCandidate = coworkCandidates.find((candidate) => {
-      const resolvedCandidate = canonicalPath(candidate);
-      return (
-        resolvedStartDir === resolvedCandidate ||
-        resolvedStartDir.startsWith(`${resolvedCandidate}/`)
-      );
-    });
-    if (cwdCandidate) {
-      return { ok: true, dir: cwdCandidate, source: 'cowork' };
-    }
-    return {
-      ok: false,
-      reason: 'ambiguous_cowork_project',
-      candidates: coworkCandidates,
-    };
-  }
-
-  return { ok: true, dir: resolve(startDir), source: 'cwd' };
-}
-
-export function getActiveProjectAuthSource(
-  startDir: string = process.cwd(),
-): ProjectAuthSource | null {
-  return loadProjectEnvCandidates(startDir)[0] ?? null;
-}
-
 export {
   baseUrlSlug,
   loadCliEnv,
   loadGlobalCliEnv,
-  loadProjectDeeplineEnv,
-  getResolvedProjectAuthSource,
-  listCoworkWorkspaceDirCandidates,
   parseEnvFile,
-  detectCoworkWorkspaceDir,
   autoDetectBaseUrl,
   PROD_URL,
 };

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

@@ -101,10 +101,10 @@ export const SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: '0.1.138',
+  version: '0.1.140',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.138',
+    latest: '0.1.140',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/play-runtime/coordinator-headers.ts

@@ -13,6 +13,8 @@
  * The header is harmless when there is only one active version (the default).
  */
 export const COORDINATOR_VERSION_KEY_HEADER = 'Cloudflare-Workers-Version-Key';
+export const COORDINATOR_VERSION_OVERRIDES_HEADER =
+  'Cloudflare-Workers-Version-Overrides';
 /**
  * Shared secret the coordinator uses to authenticate dispatcher (Vercel app)
  * traffic. The coordinator also sanity-checks `x-deepline-run-scope` matches
@@ -65,6 +67,8 @@ export function coordinatorRequestHeaders(input: {
   runId: string;
   contentType?: string | null;
   internalToken?: string | null;
+  runtimeDeployVersion?: string | null;
+  coordinatorWorkerName?: string | null;
   /**
    * When set, the coordinator validates this matches the runId in the URL.
    * Pass the runId on `/cancel` / `/signal` calls so a leaked dispatcher
@@ -80,6 +84,19 @@ export function coordinatorRequestHeaders(input: {
   if (trimmed) {
     headers[COORDINATOR_VERSION_KEY_HEADER] = trimmed;
   }
+  const runtimeDeployVersion = input.runtimeDeployVersion?.trim();
+  const coordinatorWorkerName = input.coordinatorWorkerName?.trim();
+  if (
+    runtimeDeployVersion &&
+    coordinatorWorkerName &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+      runtimeDeployVersion,
+    ) &&
+    /^[A-Za-z0-9_-]+$/.test(coordinatorWorkerName)
+  ) {
+    headers[COORDINATOR_VERSION_OVERRIDES_HEADER] =
+      `${coordinatorWorkerName}="${runtimeDeployVersion}"`;
+  }
   const internalToken =
     input.internalToken?.trim() || resolveInternalCoordinatorToken();
   if (internalToken) {

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

@@ -2,7 +2,7 @@ const CLOUDFLARE_DURABLE_OBJECT_RESET_RE =
   /Durable Object.*(?:code was updated|storage caused object)/;
 
 export const PLATFORM_DEPLOY_INTERRUPTED_MESSAGE =
-  'Run interrupted by a platform deploy and was not retried automatically. Re-run the same command; the input is unchanged.';
+  'Run interrupted by a platform deploy. Deepline retries this automatically when possible; if this error is still visible, re-run the same command.';
 
 export const INTERNAL_RUNTIME_STORAGE_ERROR_MESSAGE =
   'Internal play runtime storage failed. Please retry the run; if this keeps happening, contact Deepline support with the run ID.';

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

@@ -1,3 +1,5 @@
+import { normalizePlayRunFailure } from './run-failure';
+
 export type PlayRunLedgerStatus =
   | 'queued'
   | 'running'
@@ -560,6 +562,7 @@ function conflictingTerminalSnapshot(
   base: PlayRunLedgerSnapshot,
   eventType: keyof typeof TERMINAL_STATUS_BY_EVENT_TYPE,
   occurredAt: number,
+  eventError?: string | null,
 ): PlayRunLedgerSnapshot | null {
   if (!isTerminalPlayRunLedgerStatus(base.status)) {
     return null;
@@ -567,6 +570,18 @@ function conflictingTerminalSnapshot(
   if (TERMINAL_STATUS_BY_EVENT_TYPE[eventType] === base.status) {
     return null;
   }
+  if (
+    base.status === 'completed' &&
+    eventType === 'run.failed' &&
+    eventError &&
+    normalizePlayRunFailure(eventError).code === 'PLATFORM_DEPLOY_INTERRUPTED'
+  ) {
+    return withTiming(
+      appendLogLines(base, [
+        `[ledger] platform deploy terminal event ${eventType} ignored; status already ${base.status}`,
+      ]),
+    );
+  }
   const terminalAt = base.finishedAt ?? base.updatedAt ?? 0;
   if (occurredAt > terminalAt) {
     // Newer terminal evidence reconciles the run. This covers replay/receipt
@@ -683,7 +698,12 @@ export function reducePlayRunLedgerEvent(
       );
     case 'run.failed':
       return (
-        conflictingTerminalSnapshot(base, event.type, occurredAt) ??
+        conflictingTerminalSnapshot(
+          base,
+          event.type,
+          occurredAt,
+          event.error,
+        ) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'failed', occurredAt),
           status: 'failed',
@@ -697,7 +717,12 @@ export function reducePlayRunLedgerEvent(
       );
     case 'run.cancelled':
       return (
-        conflictingTerminalSnapshot(base, event.type, occurredAt) ??
+        conflictingTerminalSnapshot(
+          base,
+          event.type,
+          occurredAt,
+          event.error,
+        ) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'failed', occurredAt),
           status: 'cancelled',