deepline 0.1.119 → 0.1.121

package/dist/cli/index.js

@@ -181,9 +181,9 @@ function configureProxyFromEnv() {
 configureProxyFromEnv();
 
 // src/cli/index.ts
-var import_promises7 = require("fs/promises");
-var import_node_path22 = require("path");
-var import_node_os17 = require("os");
+var import_promises5 = require("fs/promises");
+var import_node_path19 = require("path");
+var import_node_os15 = require("os");
 var import_commander3 = require("commander");
 
 // src/config.ts
@@ -403,10 +403,10 @@ var SDK_RELEASE = {
   // skill on the sdk sync surface, and the people-search-to-email prebuilt.
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
-  version: "0.1.119",
+  version: "0.1.121",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.119",
+    latest: "0.1.121",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -919,7 +919,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 function withCoworkNetworkHint(message) {
   if (!isCoworkLikeSandbox() || message.includes(COWORK_NETWORK_HINT)) {
@@ -1676,14 +1676,14 @@ async function* observeRunEvents(options) {
   try {
     for (; ; ) {
       if (queue.length === 0) {
-        const waitForItem = new Promise((resolve16) => {
-          wake = resolve16;
+        const waitForItem = new Promise((resolve13) => {
+          wake = resolve13;
         });
         if (!sawFirstSnapshot) {
           const timedOut = await Promise.race([
             waitForItem.then(() => false),
             new Promise(
-              (resolve16) => setTimeout(() => resolve16(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
+              (resolve13) => setTimeout(() => resolve13(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
             )
           ]);
           if (timedOut && queue.length === 0) {
@@ -1783,7 +1783,7 @@ var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES = 25e5;
 function sleep2(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -2900,20 +2900,105 @@ var DeeplineClient = class {
     return response.runs ?? [];
   }
   /**
-   * Observe one run's live events through the Convex Run Snapshot
-   * subscription transport (ADR-0008). Yields the same `play.*` event
-   * envelopes as {@link streamPlayRunEvents} and ends after the terminal
-   * snapshot. Throws {@link RunObserveTransportUnavailableError} when this
-   * server cannot serve the transport (older server, unconfigured grants, or
-   * unreachable Convex) — callers fall back to the SSE stream with a notice.
+   * Observe one run's live events. Uses the Convex Run Snapshot subscription
+   * transport first (ADR-0008), then falls back to the canonical SSE stream
+   * when the subscription transport or its optional client modules are not
+   * available. Pass `fallback: 'none'` to receive
+   * {@link RunObserveTransportUnavailableError} instead.
    */
-  observeRunEvents(runId, options) {
-    return observeRunEvents({
-      http: this.http,
+  async *observeRunEvents(runId, options) {
+    let yieldedObserveEvent = false;
+    try {
+      for await (const event of observeRunEvents({
+        http: this.http,
+        runId,
+        signal: options?.signal,
+        onNotice: options?.onNotice
+      })) {
+        yieldedObserveEvent = true;
+        yield event;
+      }
+    } catch (error) {
+      if (!(error instanceof RunObserveTransportUnavailableError) || yieldedObserveEvent || options?.fallback === "none") {
+        throw error;
+      }
+      options?.onNotice?.(
+        `[observe] live subscription unavailable (${error.reason}); falling back to SSE tail (support window, ADR-0008)`
+      );
+      yield* this.streamPlayRunEventsUntilTerminal(runId, options);
+    }
+  }
+  async *streamPlayRunEventsUntilTerminal(runId, options) {
+    const state = {
       runId,
-      signal: options?.signal,
-      onNotice: options?.onNotice
-    });
+      status: "running",
+      logs: [],
+      lastLogSeq: 0,
+      latest: null
+    };
+    let lastEventId;
+    let reconnectAttempt = 0;
+    for (; ; ) {
+      if (options?.signal?.aborted) {
+        return;
+      }
+      const connectedAt = Date.now();
+      let sawEvent = false;
+      let endedReason = "stream window ended before a terminal event";
+      try {
+        for await (const event of this.streamPlayRunEvents(runId, {
+          mode: "cli",
+          signal: options?.signal,
+          ...lastEventId ? { lastEventId } : {}
+        })) {
+          sawEvent = true;
+          if (event.cursor?.trim()) {
+            lastEventId = event.cursor;
+          }
+          yield event;
+          const status = updatePlayLiveStatusState(state, event);
+          if (status && TERMINAL_PLAY_STATUSES.has(status.status)) {
+            return;
+          }
+        }
+      } catch (error) {
+        if (options?.signal?.aborted) {
+          return;
+        }
+        if (!isTransientPlayStreamError(error)) {
+          throw error;
+        }
+        endedReason = error instanceof Error ? error.message : String(error);
+      }
+      let refreshed = null;
+      try {
+        refreshed = await this.getRunStatus(runId);
+      } catch (error) {
+        if (!isTransientPlayStreamError(error)) {
+          throw error;
+        }
+      }
+      if (refreshed && TERMINAL_PLAY_STATUSES.has(refreshed.status)) {
+        yield {
+          cursor: String(Date.now()),
+          streamId: `sse-fallback:${runId}`,
+          scope: "play",
+          type: "play.run.status",
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: refreshed
+        };
+        return;
+      }
+      if (sawEvent || Date.now() - connectedAt >= STREAM_HEALTHY_CONNECTION_MS) {
+        reconnectAttempt = 0;
+      }
+      const delayMs = streamReconnectDelayMs(reconnectAttempt);
+      reconnectAttempt += 1;
+      options?.onNotice?.(
+        `[observe] SSE tail window ended before terminal status (${endedReason}); reconnecting to run ${runId}`
+      );
+      await sleep2(delayMs);
+    }
   }
   /**
    * Tail one run through the subscription transport until terminal, then
@@ -2929,7 +3014,8 @@ var DeeplineClient = class {
     };
     for await (const event of this.observeRunEvents(runId, {
       signal: options?.signal,
-      onNotice: options?.onNotice
+      onNotice: options?.onNotice,
+      fallback: "none"
     })) {
       const status = updatePlayLiveStatusState(state, event);
       if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
@@ -4221,7 +4307,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -4256,10 +4342,8 @@ async function claimInstallBonus(baseUrl, apiKey) {
       apiKey,
       {}
     );
-    if (status !== 200) {
-      return;
-    }
-    const granted = Number(data.credits_granted ?? 0);
+    if (status !== 200) return;
+    const granted = typeof data.credits_granted === "number" ? data.credits_granted : 0;
     const alreadyGranted = data.already_granted === true;
     if (granted > 0) {
       console.log(`
@@ -6173,38 +6257,38 @@ function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns
       }
     }
     const denominator = nonEmpty + empty;
-    const stat4 = {
+    const stat2 = {
       non_empty: percentText(nonEmpty, denominator),
       unique: valueCounts.size
     };
     const rawExecutionStats = executionStats?.columnStats[column];
     if (rawExecutionStats) {
-      stat4.execution = formatDatasetExecutionStats(
+      stat2.execution = formatDatasetExecutionStats(
         rawExecutionStats,
         totalRows
       );
     }
     if (sampleValue !== void 0 && sampleValueType) {
-      stat4.sample_value = sampleValue;
-      stat4.sample_type = sampleValueType;
+      stat2.sample_value = sampleValue;
+      stat2.sample_type = sampleValueType;
     }
     if (valueCounts.size > 0 && valueCounts.size < nonEmpty) {
       const top = [...valueCounts.entries()].sort((left, right) => right[1] - left[1]).slice(0, 3);
       const topKeys = new Set(top.map(([key]) => key));
       const otherCount = [...valueCounts.entries()].filter(([key]) => !topKeys.has(key)).reduce((sum, [, count]) => sum + count, 0);
-      stat4.top_values = Object.fromEntries(
+      stat2.top_values = Object.fromEntries(
         top.map(([key, count]) => [key, countPercentText(count, denominator)])
       );
       if (otherCount > 0) {
-        stat4.top_values["(other)"] = countPercentText(otherCount, denominator);
+        stat2.top_values["(other)"] = countPercentText(otherCount, denominator);
       }
       if (empty > 0) {
-        stat4.top_values["(null)"] = countPercentText(empty, denominator);
+        stat2.top_values["(null)"] = countPercentText(empty, denominator);
       }
     } else if (empty > 0 && nonEmpty > 0) {
-      stat4.top_values = { "(null)": countPercentText(empty, denominator) };
+      stat2.top_values = { "(null)": countPercentText(empty, denominator) };
     }
-    columnStats[column] = stat4;
+    columnStats[column] = stat2;
   }
   return {
     total_rows: totalRows,
@@ -6689,1898 +6773,98 @@ Examples:
 }
 
 // src/cli/commands/enrich.ts
-var import_promises5 = require("fs/promises");
-var import_node_os9 = require("os");
-var import_node_path14 = require("path");
+var import_promises3 = require("fs/promises");
+var import_node_os7 = require("os");
+var import_node_path11 = require("path");
 
 // src/cli/commands/play.ts
-var import_node_crypto3 = require("crypto");
-var import_node_fs11 = require("fs");
-var import_node_path13 = require("path");
-var import_sync5 = require("csv-parse/sync");
-
-// src/plays/bundle-play-file.ts
-var import_node_os8 = require("os");
-var import_node_path11 = require("path");
-var import_node_url = require("url");
+var import_node_crypto = require("crypto");
 var import_node_fs9 = require("fs");
+var import_node_path10 = require("path");
+var import_sync5 = require("csv-parse/sync");
 
-// ../shared_libs/plays/bundling/index.ts
-var import_node_crypto = require("crypto");
+// src/cli/commands/plays/bootstrap.ts
 var import_node_fs8 = require("fs");
-var import_promises3 = require("fs/promises");
-var import_node_os7 = require("os");
 var import_node_path9 = require("path");
-var import_node_module = require("module");
-var import_esbuild = require("esbuild");
+var import_sync4 = require("csv-parse/sync");
 
-// ../shared_libs/play-runtime/backend.ts
-var PLAY_RUNTIME_BACKENDS = {
-  localProcess: "local_process",
-  daytona: "daytona",
-  // Artifact/runtime contract for Cloudflare Dynamic Workers. This is no
-  // longer a standalone runner backend; use profile=workers_edge so the
-  // cf-workflows scheduler owns loading and execution.
-  cloudflareWorkers: "cloudflare_workers"
-};
-var PLAY_ARTIFACT_KINDS = {
-  cjsNode20: "cjs_node20",
-  esmWorkers: "esm_workers"
+// ../shared_libs/plays/bootstrap-routes.ts
+var PLAY_BOOTSTRAP_TEMPLATES = [
+  "people-list",
+  "company-list",
+  "people-email",
+  "people-phone",
+  "company-people",
+  "company-people-email",
+  "company-people-phone"
+];
+var PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY = "company_search";
+var PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY = "people_search";
+var PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER = {
+  email_finder: "email_finder",
+  phone_finder: "phone_finder"
 };
-var PLAY_BACKEND_DESCRIPTORS = {
-  [PLAY_RUNTIME_BACKENDS.localProcess]: {
-    id: PLAY_RUNTIME_BACKENDS.localProcess,
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: "Local node subprocess"
-  },
-  [PLAY_RUNTIME_BACKENDS.daytona]: {
-    id: PLAY_RUNTIME_BACKENDS.daytona,
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: "Daytona sandbox"
-  },
-  [PLAY_RUNTIME_BACKENDS.cloudflareWorkers]: {
-    id: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
-    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
-    label: "Cloudflare Dynamic Workers"
-  }
+var PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER = {
+  email_finder: "email",
+  phone_finder: "phone"
 };
-
-// ../shared_libs/plays/contracts.ts
-var PLAY_PUBLIC_API_VERSION = 1;
-var PLAY_ARTIFACT_VERSION = 1;
-var PLAY_MIN_RUNNER_VERSION = 1;
-var PLAY_RUNTIME_FEATURES = [
-  "artifact_storage",
-  "checkpoint_resume",
-  "durable_sleep",
-  "packaged_files"
-];
-function buildPlayContractCompatibility(input2) {
-  return {
-    apiVersion: PLAY_PUBLIC_API_VERSION,
-    artifactVersion: PLAY_ARTIFACT_VERSION,
-    minRunnerVersion: PLAY_MIN_RUNNER_VERSION,
-    runtimeFeatures: [...PLAY_RUNTIME_FEATURES],
-    runtimeBackend: input2?.runtimeBackend ?? null
-  };
-}
-
-// ../shared_libs/plays/secret-guardrails.ts
-var SECRET_ENV_PATTERN = /\bprocess(?:\.env|\[['"]env['"]\])(?:\.|\[['"])([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PRIVATE[_-]?KEY|ACCESS[_-]?KEY)[A-Z0-9_]*)(?:['"]\])?/g;
-var PRIVATE_KEY_PATTERN = /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/;
-var BEARER_LITERAL_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/i;
-var ASSIGNMENT_SECRET_LITERAL_PATTERN = /\b(?:api[_-]?key|token|secret|password)\b\s*[:=]\s*['"][^'"]{12,}['"]/i;
-var HIGH_ENTROPY_LITERAL_PATTERN = /['"]([A-Za-z0-9+/=_-]{32,})['"]/g;
-function shannonEntropy(value) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);
-  return [...counts.values()].reduce((entropy, count) => {
-    const p = count / value.length;
-    return entropy - p * Math.log2(p);
-  }, 0);
-}
-function collectInlineSecretFindings(sourceCode) {
-  const findings = [];
-  for (const match of sourceCode.matchAll(SECRET_ENV_PATTERN)) {
-    findings.push(`process.env.${match[1]}`);
-  }
-  if (PRIVATE_KEY_PATTERN.test(sourceCode)) findings.push("private key block");
-  if (BEARER_LITERAL_PATTERN.test(sourceCode))
-    findings.push("bearer token literal");
-  if (ASSIGNMENT_SECRET_LITERAL_PATTERN.test(sourceCode)) {
-    findings.push("secret-looking assignment literal");
-  }
-  for (const match of sourceCode.matchAll(HIGH_ENTROPY_LITERAL_PATTERN)) {
-    const literal = match[1] ?? "";
-    if (literal.length >= 40 && shannonEntropy(literal) >= 4.2) {
-      findings.push("high-entropy string literal");
-      break;
-    }
-  }
-  return [...new Set(findings)];
-}
-function validatePlaySourceHasNoInlineSecrets(input2) {
-  const findings = collectInlineSecretFindings(input2.sourceCode);
-  if (!findings.length) return;
-  throw new Error(
-    [
-      `Play source ${input2.filePath} appears to contain inline secret material: ${[
-        ...new Set(findings)
-      ].join(", ")}.`,
-      'Author secrets in the dashboard and use ctx.secrets.get("NAME") with an approved helper such as ctx.secrets.bearer(handle).'
-    ].join(" ")
-  );
+function isPlayBootstrapTemplate(value) {
+  return PLAY_BOOTSTRAP_TEMPLATES.includes(value);
 }
-function validatePlaySourceFilesHaveNoInlineSecrets(sourceFiles) {
-  for (const [filePath, sourceCode] of Object.entries(sourceFiles)) {
-    validatePlaySourceHasNoInlineSecrets({ filePath, sourceCode });
-  }
+function formatPlayBootstrapTemplates() {
+  return PLAY_BOOTSTRAP_TEMPLATES.join("|");
 }
 
-// ../shared_libs/plays/bundling/limits.ts
-var MAX_PLAY_BUNDLE_BYTES = 30 * 1024 * 1024;
-var MAX_ESM_WORKERS_BUNDLE_BYTES = 115e4;
-
-// ../shared_libs/plays/bundling/index.ts
-var PLAY_BUNDLE_CACHE_VERSION = 24;
-var PLAY_ARTIFACT_CACHE_DIR = (0, import_node_path9.join)(
-  (0, import_node_os7.tmpdir)(),
-  `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`
-);
-var PLAY_PROXY_NAMESPACE = "deepline-play-runtime-ref";
-var SOURCE_EXTENSIONS = [
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".json"
-];
-var WORKERS_PLAY_ENTRY_VIRTUAL = "deepline-play-entry";
-var PLAY_SOURCE_FILE_PATTERN = /\.play\.(?:[cm]?[jt]sx?)$/i;
-var NODE_BUILTIN_SET = new Set(
-  import_node_module.builtinModules.flatMap(
-    (name) => name.startsWith("node:") ? [name, name.slice(5)] : [name, `node:${name}`]
-  )
-);
-function assertValidExportName(exportName) {
-  if (exportName === "default") return;
-  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
-    throw new Error(
-      `Invalid play export name "${exportName}". Named prebuilt exports must be valid JavaScript identifiers.`
-    );
-  }
-}
-function sha256(value) {
-  return (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
-}
-function formatEsbuildMessage(message) {
-  const location = message.location ? `${message.location.file}:${message.location.line}:${message.location.column}` : null;
-  return location ? `${location} ${message.text}` : message.text;
-}
-function isLocalSpecifier(specifier) {
-  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || specifier.startsWith("file:");
-}
-async function normalizeLocalPath(filePath) {
-  try {
-    return await (0, import_promises3.realpath)(filePath);
-  } catch {
-    return (0, import_node_path9.resolve)(filePath);
+// src/cli/commands/plays/bootstrap.ts
+function parseReferencedPlayTarget(target) {
+  const trimmed = target.trim();
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
+    return { ownerSlug: null, playName: trimmed, unqualifiedPlayName: trimmed };
   }
-}
-function createPlayWorkspace(entryFile) {
   return {
-    entryFile,
-    rootDir: (0, import_node_path9.dirname)(entryFile)
+    ownerSlug: trimmed.slice(0, slashIndex),
+    playName: trimmed,
+    unqualifiedPlayName: trimmed.slice(slashIndex + 1)
   };
 }
-function isPathInsideDirectory(filePath, directory) {
-  return filePath === directory || filePath.startsWith(`${directory}/`);
-}
-function assertWithinPlayWorkspace(input2) {
-  if (isPathInsideDirectory(input2.resolvedPath, input2.workspace.rootDir)) {
-    return;
+function parsePositiveInteger2(value, flagName) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new PlayBootstrapUsageError(
+      `${flagName} must be a positive integer.`
+    );
   }
-  throw new Error(
-    `${input2.importer}:${input2.line}:${input2.column} Local play imports must stay inside the play workspace (${input2.workspace.rootDir}). Import "${input2.specifier}" resolved to ${input2.resolvedPath}, which crosses into app/backend code. Use the public SDK/API surface or move shared helpers into the play workspace.`
-  );
+  return parsed;
 }
-function getPackageName(specifier) {
-  if (specifier.startsWith("@")) {
-    const [scope, name] = specifier.split("/");
-    return scope && name ? `${scope}/${name}` : specifier;
-  }
-  return specifier.split("/")[0] ?? specifier;
+function isRecord5(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function isPlaySourceFile(filePath) {
-  return PLAY_SOURCE_FILE_PATTERN.test(filePath);
+function stringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
 }
-function stripCommentsToSpaces(source) {
-  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
-    /(^|[^:])\/\/.*$/gm,
-    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
+function extractionEntries(value) {
+  if (Array.isArray(value)) return value.filter(isRecord5);
+  if (!isRecord5(value)) return [];
+  return Object.entries(value).map(
+    ([name, entry]) => isRecord5(entry) ? { name, ...entry } : { name }
   );
 }
-function lineAndColumnAt(source, index) {
-  const prefix = source.slice(0, index);
-  const lines = prefix.split("\n");
-  return { line: lines.length, column: lines[lines.length - 1].length + 1 };
-}
-function findSourceImportReferences(sourceCode) {
-  const source = stripCommentsToSpaces(sourceCode);
-  const references = [];
-  const addReference = (specifier, specifierIndex, kind) => {
-    if (!specifier) return;
-    const position = lineAndColumnAt(sourceCode, specifierIndex);
-    references.push({
-      specifier,
-      line: position.line,
-      column: position.column,
-      kind
-    });
-  };
-  const staticImportPattern = /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?(['"])([^'"\n]+)\1/g;
-  for (const match of source.matchAll(staticImportPattern)) {
-    addReference(
-      match[2],
-      match.index + match[0].lastIndexOf(match[1]),
-      "static"
-    );
-  }
-  const dynamicImportPattern = /\bimport\s*\(\s*(['"])([^'"\n]+)\1/g;
-  for (const match of source.matchAll(dynamicImportPattern)) {
-    addReference(
-      match[2],
-      match.index + match[0].lastIndexOf(match[1]),
-      "dynamic-import"
-    );
-  }
-  const requirePattern = /\brequire\s*\(\s*(['"])([^'"\n]+)\1/g;
-  for (const match of source.matchAll(requirePattern)) {
-    addReference(
-      match[2],
-      match.index + match[0].lastIndexOf(match[1]),
-      "require"
-    );
+var PlayBootstrapError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
   }
-  const literalDynamicImportIndexes = new Set(
-    [...source.matchAll(dynamicImportPattern)].map((match) => match.index)
-  );
-  for (const match of source.matchAll(/\bimport\s*\(/g)) {
-    if (literalDynamicImportIndexes.has(match.index)) continue;
-    const position = lineAndColumnAt(sourceCode, match.index);
-    throw new Error(
-      `:${position.line}:${position.column} Dynamic import() is not allowed in plays. Use static imports instead.`
-    );
+  exitCode;
+};
+var PlayBootstrapUsageError = class extends PlayBootstrapError {
+  constructor(message) {
+    super(message, 2);
   }
-  const literalRequireIndexes = new Set(
-    [...source.matchAll(requirePattern)].map((match) => match.index)
-  );
-  for (const match of source.matchAll(/\brequire\s*\(/g)) {
-    if (literalRequireIndexes.has(match.index)) continue;
-    const position = lineAndColumnAt(sourceCode, match.index);
-    throw new Error(
-      `:${position.line}:${position.column} Dynamic require() is not allowed in plays. Use static imports or require("literal") only.`
-    );
-  }
-  return references.sort(
-    (left, right) => left.line === right.line ? left.column - right.column : left.line - right.line
-  );
-}
-function unquoteStringLiteral(literal) {
-  const trimmed = literal.trim();
-  const quote = trimmed[0];
-  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
-    return null;
-  }
-  try {
-    return JSON.parse(
-      quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`
-    );
-  } catch {
-    return trimmed.slice(1, -1);
-  }
-}
-function findMatchingBrace(source, openIndex) {
-  let depth = 0;
-  let quote = null;
-  let escaped = false;
-  for (let index = openIndex; index < source.length; index += 1) {
-    const char = source[index];
-    if (quote) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === quote) {
-        quote = null;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "{") depth += 1;
-    if (char === "}") {
-      depth -= 1;
-      if (depth === 0) return index;
-    }
-  }
-  return -1;
-}
-function extractDefinedPlayName(sourceCode) {
-  const source = stripCommentsToSpaces(sourceCode);
-  const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
-  for (const match of source.matchAll(callPattern)) {
-    const openParen = match.index + match[0].length - 1;
-    const firstArgStart = openParen + 1;
-    const firstNonSpace = source.slice(firstArgStart).search(/\S/);
-    if (firstNonSpace < 0) continue;
-    const argIndex = firstArgStart + firstNonSpace;
-    const quote = source[argIndex];
-    if (quote === '"' || quote === "'") {
-      const literalMatch = source.slice(argIndex).match(/^(['"])(?:\\.|(?!\1)[\s\S])*\1/);
-      const value = literalMatch ? unquoteStringLiteral(literalMatch[0]) : null;
-      if (value?.trim()) return value.trim();
-    }
-    if (quote === "{") {
-      const closeBrace = findMatchingBrace(source, argIndex);
-      if (closeBrace < 0) continue;
-      const objectSource = source.slice(argIndex + 1, closeBrace);
-      const idMatch = objectSource.match(
-        /(?:^|[,{\s])(?:id|['"]id['"])\s*:\s*(['"])([\s\S]*?)\1/
-      );
-      if (idMatch?.[2]?.trim()) {
-        return idMatch[2].trim();
-      }
-    }
-  }
-  return null;
-}
-function canonicalizeRootPlayNameForWorkersRuntimeHash(sourceCode) {
-  const source = stripCommentsToSpaces(sourceCode);
-  const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
-  const match = callPattern.exec(source);
-  if (!match) return sourceCode;
-  const openParen = match.index + match[0].length - 1;
-  const firstArgStart = openParen + 1;
-  const firstNonSpace = source.slice(firstArgStart).search(/\S/);
-  if (firstNonSpace < 0) return sourceCode;
-  const argIndex = firstArgStart + firstNonSpace;
-  const quote = source[argIndex];
-  if (quote === '"' || quote === "'") {
-    const literalMatch = source.slice(argIndex).match(/^(['"])(?:\\.|(?!\1)[\s\S])*\1/);
-    if (!literalMatch) return sourceCode;
-    const replacement = `${quote}__deepline_runtime_play_name__${quote}`;
-    return `${sourceCode.slice(0, argIndex)}${replacement}${sourceCode.slice(argIndex + literalMatch[0].length)}`;
-  }
-  if (quote !== "{") return sourceCode;
-  const closeBrace = findMatchingBrace(source, argIndex);
-  if (closeBrace < 0) return sourceCode;
-  const objectSource = source.slice(argIndex + 1, closeBrace);
-  const idMatch = objectSource.match(
-    /(^|[,{\s])((?:id|['"]id['"])\s*:\s*)(['"])([\s\S]*?)\3/
-  );
-  if (!idMatch || idMatch.index === void 0) return sourceCode;
-  const idValueStart = argIndex + 1 + idMatch.index + idMatch[1].length + idMatch[2].length + idMatch[3].length;
-  return `${sourceCode.slice(0, idValueStart)}__deepline_runtime_play_name__${sourceCode.slice(idValueStart + idMatch[4].length)}`;
-}
-function workersRuntimeGraphFilePath(input2) {
-  if (input2.filePath === input2.entryFile) return "<entry>";
-  const entryRelative = (0, import_node_path9.relative)((0, import_node_path9.dirname)(input2.entryFile), input2.filePath);
-  if (entryRelative && !entryRelative.startsWith("..")) {
-    return entryRelative.replaceAll("\\", "/");
-  }
-  return `<project>/${(0, import_node_path9.relative)(input2.adapter.projectRoot, input2.filePath).replaceAll("\\", "/")}`;
-}
-function buildWorkersRuntimeGraphHash(input2) {
-  const sourceFiles = Object.entries(input2.analysis.sourceFiles).map(([filePath, contents]) => ({
-    filePath: workersRuntimeGraphFilePath({
-      entryFile: input2.entryFile,
-      filePath,
-      adapter: input2.adapter
-    }),
-    hash: sha256(
-      filePath === input2.entryFile ? canonicalizeRootPlayNameForWorkersRuntimeHash(contents) : contents
-    )
-  })).sort((left, right) => left.filePath.localeCompare(right.filePath));
-  return sha256(
-    JSON.stringify({
-      entryFile: "<entry>",
-      entryExport: input2.exportName,
-      localFiles: sourceFiles,
-      nodeBuiltins: [...input2.analysis.importPolicy.nodeBuiltins].sort(),
-      packages: input2.analysis.importPolicy.packages.map(({ name, version }) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name)),
-      importedPlayDependencies: input2.analysis.importedPlayDependencies.map((dependency) => ({
-        filePath: workersRuntimeGraphFilePath({
-          entryFile: input2.entryFile,
-          filePath: dependency.filePath,
-          adapter: input2.adapter
-        }),
-        playName: dependency.playName
-      })).sort((left, right) => left.filePath.localeCompare(right.filePath))
-    })
-  );
-}
-function readPackageVersionFromPackageJson(packageJsonPath, packageName) {
-  try {
-    const packageJson = JSON.parse((0, import_node_fs8.readFileSync)(packageJsonPath, "utf-8"));
-    if (packageJson.name === packageName && typeof packageJson.version === "string") {
-      return packageJson.version;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-function findPackageJsonPathFrom(startDir, packageName) {
-  if (!(0, import_node_path9.isAbsolute)(startDir)) {
-    throw new Error(
-      `Package resolution requires an absolute start directory, got ${startDir}`
-    );
-  }
-  let current = startDir;
-  while (true) {
-    const packageJsonPath = (0, import_node_path9.join)(
-      current,
-      "node_modules",
-      packageName,
-      "package.json"
-    );
-    if ((0, import_node_fs8.existsSync)(packageJsonPath)) {
-      return packageJsonPath;
-    }
-    const parent = (0, import_node_path9.dirname)(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function findPackageJsonPath(packageName, fromFile, adapter) {
-  const startDirs = [
-    (0, import_node_path9.resolve)((0, import_node_path9.dirname)(fromFile)),
-    (0, import_node_path9.resolve)(adapter.projectRoot),
-    (0, import_node_path9.resolve)((0, import_node_path9.dirname)(adapter.sdkPackageJson))
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  for (const startDir of startDirs) {
-    if (seen.has(startDir)) continue;
-    seen.add(startDir);
-    const packageJsonPath = findPackageJsonPathFrom(startDir, packageName);
-    if (packageJsonPath) return packageJsonPath;
-  }
-  const adapterNodeModulesPackageJson = (0, import_node_path9.join)(
-    adapter.nodeModulesDir,
-    packageName,
-    "package.json"
-  );
-  return (0, import_node_fs8.existsSync)(adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
-}
-function localSdkAliasPlugin(adapter, options) {
-  const entryFile = options?.workersRuntime ? adapter.sdkWorkersEntryFile : adapter.sdkEntryFile;
-  if (!(0, import_node_fs8.existsSync)(entryFile)) {
-    return null;
-  }
-  return {
-    name: "deepline-sdk-local-alias",
-    setup(buildContext) {
-      buildContext.onResolve({ filter: /^deepline$/ }, () => ({
-        path: entryFile
-      }));
-      buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
-        path: (0, import_node_path9.join)(adapter.sdkSourceRoot, "helpers.ts")
-      }));
-    }
-  };
-}
-function workersPlayEntryAliasPlugin(playFilePath) {
-  return {
-    name: "deepline-workers-play-entry-alias",
-    setup(buildContext) {
-      buildContext.onResolve(
-        { filter: new RegExp(`^${WORKERS_PLAY_ENTRY_VIRTUAL}$`) },
-        () => ({ path: playFilePath })
-      );
-    }
-  };
-}
-function workersNamedPlayEntryAliasPlugin(playFilePath, exportName) {
-  return {
-    name: "deepline-workers-named-play-entry-alias",
-    setup(buildContext) {
-      buildContext.onResolve(
-        { filter: new RegExp(`^${WORKERS_PLAY_ENTRY_VIRTUAL}$`) },
-        () => ({
-          path: `${playFilePath}.${exportName}.entry.ts`,
-          namespace: "deepline-named-play-entry"
-        })
-      );
-      buildContext.onLoad(
-        { filter: /.*/, namespace: "deepline-named-play-entry" },
-        () => ({
-          contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};
-`,
-          loader: "ts",
-          resolveDir: (0, import_node_path9.dirname)(playFilePath)
-        })
-      );
-    }
-  };
-}
-function workersNodeBuiltinStubPlugin() {
-  const UNSUPPORTED = /* @__PURE__ */ new Set([
-    "node:fs",
-    "node:fs/promises",
-    "node:os",
-    "node:child_process"
-  ]);
-  return {
-    name: "deepline-workers-node-builtin-stub",
-    setup(buildContext) {
-      buildContext.onResolve({ filter: /^node:/ }, (args) => {
-        if (!UNSUPPORTED.has(args.path)) return null;
-        return { path: args.path, namespace: "deepline-workers-node-stub" };
-      });
-      buildContext.onLoad(
-        { filter: /.*/, namespace: "deepline-workers-node-stub" },
-        (args) => {
-          const builtinName = args.path;
-          const stubSource = `
-const message = ${JSON.stringify(
-            `Workers backend: ${builtinName} is not available in Cloudflare Workers (no filesystem / no OS). Run this play on Daytona or local-process backend if it needs node builtins.`
-          )};
-function makeThrower(name) {
-  return new Proxy(function() { throw new Error(message + ' (called: ' + name + ')'); }, {
-    get(_t, prop) {
-      if (prop === '__esModule') return true;
-      if (typeof prop === 'symbol') return undefined;
-      return makeThrower(name + '.' + String(prop));
-    },
-    apply() { throw new Error(message + ' (called: ' + name + ')'); },
-    construct() { throw new Error(message + ' (constructed: ' + name + ')'); },
-  });
-}
-module.exports = makeThrower(${JSON.stringify(builtinName)});
-`;
-          return { contents: stubSource, loader: "js" };
-        }
-      );
-    }
-  };
-}
-function zodNonEnglishLocaleStubPlugin() {
-  const LOCALE_PATH_FILTER = /[\\/]zod[\\/]v4[\\/]locales[\\/][^\\/]+\.(?:c?js|mjs)$/;
-  const NAMESPACE = "deepline-zod-locale-stub";
-  return {
-    name: "deepline-zod-non-english-locale-stub",
-    setup(buildContext) {
-      buildContext.onResolve({ filter: LOCALE_PATH_FILTER }, (args) => {
-        const norm = args.path.replace(/\\/g, "/");
-        const file = norm.slice(norm.lastIndexOf("/") + 1);
-        if (/^en(?:[-_][A-Za-z]+)?\.(?:c?js|mjs)$/.test(file)) {
-          return null;
-        }
-        return { path: args.path, namespace: NAMESPACE };
-      });
-      buildContext.onLoad({ filter: /.*/, namespace: NAMESPACE }, () => ({
-        // zod locales export a default object literal. Empty object is
-        // structurally compatible — accessing any locale key returns
-        // undefined and zod falls back to its built-in English.
-        contents: "export default {};",
-        loader: "js"
-      }));
-    }
-  };
-}
-var WORKERS_BANNED_NODE_MODULES = /* @__PURE__ */ new Set([
-  "node:fs",
-  "node:fs/promises",
-  "node:net",
-  "node:child_process",
-  "node:cluster",
-  "node:tls",
-  "node:dgram",
-  "node:dns",
-  "node:dns/promises",
-  "node:repl",
-  "node:vm",
-  "node:worker_threads"
-]);
-function workersNodeImportBanlistPlugin(adapter) {
-  return {
-    name: "deepline-workers-node-import-banlist",
-    setup(buildContext) {
-      buildContext.onResolve({ filter: /^node:/ }, (args) => {
-        if (!WORKERS_BANNED_NODE_MODULES.has(args.path)) return null;
-        const importer = args.importer ?? "";
-        if (importer.startsWith(adapter.sdkSourceRoot)) {
-          return null;
-        }
-        return {
-          errors: [
-            {
-              text: `Module "${args.path}" is not allowed in workers_edge plays. See AGENTS.md for the V8 isolate boundary.`,
-              detail: { importer: args.importer, kind: args.kind }
-            }
-          ]
-        };
-      });
-    }
-  };
-}
-function buildImportedPlayProxyModule(playName) {
-  const serializedName = JSON.stringify(playName);
-  return `
-const PLAY_METADATA_SYMBOL = Symbol.for('deepline.play.metadata');
-const importedPlayRef = async function importedPlayRef(ctx, input) {
-  return ctx.runPlay(${JSON.stringify(`imported_${playName.replace(/[^A-Za-z0-9_]+/g, "_")}`)}, importedPlayRef, input, {
-    description: 'Run the imported Deepline play dependency.',
-  });
-};
-Object.defineProperty(importedPlayRef, 'playName', {
-  value: ${serializedName},
-  enumerable: true,
-  configurable: false,
-  writable: false,
-});
-Object.defineProperty(importedPlayRef, PLAY_METADATA_SYMBOL, {
-  value: { name: ${serializedName} },
-  enumerable: false,
-  configurable: false,
-  writable: false,
-});
-export const playName = ${serializedName};
-export const name = ${serializedName};
-export default importedPlayRef;
-`;
-}
-function importedPlayProxyPlugin(importedPlayDependencies) {
-  if (importedPlayDependencies.length === 0) {
-    return null;
-  }
-  const dependenciesByPath = new Map(
-    importedPlayDependencies.map((dependency) => [
-      dependency.filePath,
-      dependency
-    ])
-  );
-  return {
-    name: "deepline-imported-play-proxy",
-    setup(buildContext) {
-      buildContext.onResolve({ filter: /.*/ }, async (args) => {
-        if (!args.importer || !isLocalSpecifier(args.path)) {
-          return null;
-        }
-        const resolvedPath = await resolveLocalImport(args.importer, args.path);
-        const dependency = dependenciesByPath.get(resolvedPath);
-        if (!dependency) {
-          return null;
-        }
-        return {
-          path: dependency.filePath,
-          namespace: PLAY_PROXY_NAMESPACE,
-          pluginData: dependency
-        };
-      });
-      buildContext.onLoad(
-        { filter: /.*/, namespace: PLAY_PROXY_NAMESPACE },
-        async (args) => {
-          const dependency = args.pluginData ?? dependenciesByPath.get(args.path);
-          if (!dependency) {
-            return null;
-          }
-          return {
-            contents: buildImportedPlayProxyModule(dependency.playName),
-            loader: "ts",
-            resolveDir: (0, import_node_path9.dirname)(args.path)
-          };
-        }
-      );
-    }
-  };
-}
-async function fileExists(filePath) {
-  try {
-    await (0, import_promises3.stat)(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolveLocalImport(fromFile, specifier) {
-  if (specifier.startsWith("file:")) {
-    return normalizeLocalPath(new URL(specifier).pathname);
-  }
-  const base = (0, import_node_path9.isAbsolute)(specifier) ? (0, import_node_path9.resolve)(specifier) : (0, import_node_path9.resolve)((0, import_node_path9.dirname)(fromFile), specifier);
-  const candidates = [base];
-  const explicitExtension = (0, import_node_path9.extname)(base).toLowerCase();
-  if (!explicitExtension) {
-    candidates.push(
-      ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
-    );
-    candidates.push(
-      ...SOURCE_EXTENSIONS.map((extension) => (0, import_node_path9.join)(base, `index${extension}`))
-    );
-  } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
-    const stem = base.slice(0, -explicitExtension.length);
-    candidates.push(
-      ...SOURCE_EXTENSIONS.map((extension) => `${stem}${extension}`)
-    );
-  }
-  for (const candidate of candidates) {
-    if (await fileExists(candidate)) {
-      return normalizeLocalPath(candidate);
-    }
-  }
-  throw new Error(
-    `Could not resolve local import "${specifier}" from ${fromFile}`
-  );
-}
-function resolvePackageImport(specifier, fromFile, adapter) {
-  const packageName = getPackageName(specifier);
-  if (packageName === "deepline" && (0, import_node_fs8.existsSync)(adapter.sdkPackageJson)) {
-    const packageJson = JSON.parse(
-      (0, import_node_fs8.readFileSync)(adapter.sdkPackageJson, "utf-8")
-    );
-    return {
-      name: "deepline",
-      version: packageJson.version ?? null
-    };
-  }
-  const packageJsonPath = findPackageJsonPath(packageName, fromFile, adapter);
-  if (!packageJsonPath) {
-    throw new Error(`Could not resolve "${specifier}" from ${fromFile}`);
-  }
-  return {
-    name: packageName,
-    version: readPackageVersionFromPackageJson(packageJsonPath, packageName)
-  };
-}
-async function analyzeSourceGraph(entryFile, adapter) {
-  const absoluteEntryFile = await normalizeLocalPath(entryFile);
-  const workspace = createPlayWorkspace(absoluteEntryFile);
-  const localFiles = /* @__PURE__ */ new Map();
-  const nodeBuiltins = /* @__PURE__ */ new Set();
-  const packages = /* @__PURE__ */ new Map();
-  const importedPlayDependencies = /* @__PURE__ */ new Map();
-  const visited = /* @__PURE__ */ new Set();
-  const visitFile = async (filePath) => {
-    const absolutePath = await normalizeLocalPath(filePath);
-    if (visited.has(absolutePath)) {
-      return;
-    }
-    visited.add(absolutePath);
-    const sourceCode2 = await (0, import_promises3.readFile)(absolutePath, "utf-8");
-    localFiles.set(absolutePath, sourceCode2);
-    if ((0, import_node_path9.extname)(absolutePath).toLowerCase() === ".json") {
-      return;
-    }
-    const handleSpecifier = async (specifier, line, column, kind) => {
-      if (kind === "dynamic-import") {
-        throw new Error(
-          `${absolutePath}:${line}:${column} Dynamic import() is not allowed in plays. Use static imports instead.`
-        );
-      }
-      if (NODE_BUILTIN_SET.has(specifier)) {
-        nodeBuiltins.add(
-          specifier.startsWith("node:") ? specifier : `node:${specifier}`
-        );
-        return;
-      }
-      if (isLocalSpecifier(specifier)) {
-        const resolved = await resolveLocalImport(absolutePath, specifier);
-        assertWithinPlayWorkspace({
-          importer: absolutePath,
-          specifier,
-          resolvedPath: resolved,
-          workspace,
-          line,
-          column
-        });
-        if (resolved !== absoluteEntryFile && isPlaySourceFile(resolved)) {
-          const importedSource = await (0, import_promises3.readFile)(resolved, "utf-8");
-          const importedPlayName = extractDefinedPlayName(importedSource);
-          if (!importedPlayName) {
-            throw new Error(
-              `${absolutePath}:${line}:${column} Imported play file "${specifier}" must export definePlay(...) so it can be runtime-composed.`
-            );
-          }
-          importedPlayDependencies.set(resolved, {
-            filePath: resolved,
-            playName: importedPlayName
-          });
-          return;
-        }
-        await visitFile(resolved);
-        return;
-      }
-      if (specifier.includes(":")) {
-        throw new Error(
-          `${absolutePath}:${line}:${column} Unsupported import specifier "${specifier}". Allowed imports are relative files, Node builtins, and installed packages.`
-        );
-      }
-      const packageImport = resolvePackageImport(
-        specifier,
-        absolutePath,
-        adapter
-      );
-      packages.set(packageImport.name, packageImport.version);
-    };
-    try {
-      for (const reference of findSourceImportReferences(sourceCode2)) {
-        await handleSpecifier(
-          reference.specifier,
-          reference.line,
-          reference.column,
-          reference.kind
-        );
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.startsWith(":")) {
-        throw new Error(`${absolutePath}${error.message}`);
-      }
-      throw error;
-    }
-  };
-  await visitFile(absoluteEntryFile);
-  const sourceCode = localFiles.get(absoluteEntryFile) ?? "";
-  const sourceHash = sha256(sourceCode);
-  const graphHash = sha256(
-    JSON.stringify({
-      entryFile: absoluteEntryFile,
-      localFiles: [...localFiles.entries()].map(([filePath, contents]) => ({ filePath, hash: sha256(contents) })).sort((left, right) => left.filePath.localeCompare(right.filePath)),
-      nodeBuiltins: [...nodeBuiltins].sort(),
-      packages: [...packages.entries()].map(([name, version]) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name)),
-      importedPlayDependencies: [...importedPlayDependencies.values()].map((dependency) => ({
-        filePath: dependency.filePath,
-        playName: dependency.playName
-      })).sort((left, right) => left.filePath.localeCompare(right.filePath))
-    })
-  );
-  const playName = extractDefinedPlayName(sourceCode);
-  return {
-    sourceCode,
-    sourceFiles: Object.fromEntries(
-      [...localFiles.entries()].sort(
-        (left, right) => left[0].localeCompare(right[0])
-      )
-    ),
-    sourceHash,
-    graphHash,
-    importPolicy: {
-      localFiles: [...localFiles.keys()].sort(),
-      nodeBuiltins: [...nodeBuiltins].sort(),
-      packages: [...packages.entries()].map(([name, version]) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name))
-    },
-    playName,
-    importedPlayDependencies: [...importedPlayDependencies.values()].sort(
-      (left, right) => left.filePath.localeCompare(right.filePath)
-    )
-  };
-}
-async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
-  const { readdir } = await import("fs/promises");
-  const addFilePart = async (parts2, rootDir, filePath) => {
-    const contents = await (0, import_promises3.readFile)(filePath, "utf-8");
-    parts2.push({
-      name: `${(0, import_node_path9.basename)(rootDir)}:${filePath.slice(rootDir.length + 1)}`,
-      hash: sha256(contents)
-    });
-  };
-  const collectTopLevelTsFiles = async (rootDir, parts2) => {
-    if (!await fileExists(rootDir)) return;
-    const entries2 = await readdir(rootDir, { withFileTypes: true });
-    const tsFiles2 = entries2.filter((entry) => entry.isFile() && /\.[cm]?ts$/.test(entry.name)).map((entry) => entry.name).sort();
-    for (const name of tsFiles2) {
-      await addFilePart(parts2, rootDir, (0, import_node_path9.join)(rootDir, name));
-    }
-  };
-  const collectIntegrationBatchingFiles = async (rootDir, parts2) => {
-    if (!await fileExists(rootDir)) return;
-    const entries2 = await readdir(rootDir, { withFileTypes: true });
-    const filePaths = [];
-    for (const entry of entries2) {
-      if (entry.isFile() && (entry.name === "play-runtime-batching-registry.ts" || /^batching.*\.ts$/.test(entry.name))) {
-        filePaths.push((0, import_node_path9.join)(rootDir, entry.name));
-      }
-      if (entry.isDirectory()) {
-        const batchingFile = (0, import_node_path9.join)(rootDir, entry.name, "batching.ts");
-        if (await fileExists(batchingFile)) {
-          filePaths.push(batchingFile);
-        }
-      }
-    }
-    for (const filePath of filePaths.sort()) {
-      await addFilePart(parts2, rootDir, filePath);
-    }
-  };
-  const entries = await readdir(adapter.workersHarnessFilesDir, {
-    withFileTypes: true
-  });
-  const tsFiles = entries.filter((e) => e.isFile() && /\.[cm]?ts$/.test(e.name)).map((e) => e.name).sort();
-  const parts = [];
-  for (const name of tsFiles) {
-    await addFilePart(
-      parts,
-      adapter.workersHarnessFilesDir,
-      (0, import_node_path9.join)(adapter.workersHarnessFilesDir, name)
-    );
-  }
-  for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
-    if ((0, import_node_path9.basename)(dir) === "integrations") {
-      await collectIntegrationBatchingFiles(dir, parts);
-    } else {
-      await collectTopLevelTsFiles(dir, parts);
-    }
-  }
-  return sha256(JSON.stringify(parts));
-}
-function artifactCachePath(graphHash, artifactKind, adapter) {
-  return (0, import_node_path9.join)(
-    adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR,
-    `${graphHash}.${artifactKind}.json`
-  );
-}
-async function readArtifactCache(graphHash, artifactKind, adapter) {
-  try {
-    const serialized = await (0, import_promises3.readFile)(
-      artifactCachePath(graphHash, artifactKind, adapter),
-      "utf-8"
-    );
-    return JSON.parse(serialized);
-  } catch {
-    return null;
-  }
-}
-async function writeArtifactCache(artifact, adapter) {
-  const cacheDir = adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR;
-  await (0, import_promises3.mkdir)(cacheDir, { recursive: true });
-  await (0, import_promises3.writeFile)(
-    artifactCachePath(
-      artifact.graphHash,
-      artifact.artifactKind ?? PLAY_ARTIFACT_KINDS.cjsNode20,
-      adapter
-    ),
-    JSON.stringify(artifact),
-    "utf-8"
-  );
-}
-function normalizeSourceMapForRuntime(sourceMapText, projectRoot) {
-  const parsed = JSON.parse(sourceMapText);
-  parsed.sources = (parsed.sources ?? []).map((sourcePath) => {
-    if (sourcePath.startsWith("data:") || sourcePath.startsWith("node:") || sourcePath.startsWith("/") || /^[a-zA-Z]+:\/\//.test(sourcePath)) {
-      return sourcePath;
-    }
-    return (0, import_node_path9.join)(projectRoot, sourcePath);
-  });
-  parsed.sourceRoot = void 0;
-  return JSON.stringify(parsed);
-}
-function getBundleSizeErrorForBytes(filePath, bundleBytes, artifactKind) {
-  if (bundleBytes > MAX_PLAY_BUNDLE_BYTES) {
-    return `${filePath} Play bundle exceeds the 30 MiB limit (${bundleBytes} bytes > ${MAX_PLAY_BUNDLE_BYTES} bytes).`;
-  }
-  if (artifactKind === PLAY_ARTIFACT_KINDS.esmWorkers && bundleBytes > MAX_ESM_WORKERS_BUNDLE_BYTES) {
-    const mib = (bundleBytes / 1024 / 1024).toFixed(2);
-    const limitMib = (MAX_ESM_WORKERS_BUNDLE_BYTES / 1024 / 1024).toFixed(2);
-    return `${filePath} Cloudflare Workers bundle is ${mib} MiB, above the workerd local-mode threshold of ${limitMib} MiB. Bundles past this size silently hang without executing the workflow body. Reduce dependencies (top offenders are usually date-fns, lodash, large schema libs) or split the play into smaller pieces with ctx.runPlay.`;
-  }
-  return null;
-}
-function getBundleSizeError(filePath, bundledCode, artifactKind) {
-  return getBundleSizeErrorForBytes(
-    filePath,
-    Buffer.byteLength(bundledCode, "utf8"),
-    artifactKind
-  );
-}
-async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter, exportName) {
-  const sdkAliasPlugin = localSdkAliasPlugin(adapter);
-  const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
-  const namedExportShim = exportName === "default" ? null : `export { ${exportName} as default } from ${JSON.stringify(entryFile)};
-`;
-  const result = await (0, import_esbuild.build)({
-    ...namedExportShim ? {
-      stdin: {
-        contents: namedExportShim,
-        resolveDir: (0, import_node_path9.dirname)(entryFile),
-        sourcefile: `${(0, import_node_path9.basename)(entryFile)}.${exportName}.entry.ts`,
-        loader: "ts"
-      }
-    } : { entryPoints: [entryFile] },
-    absWorkingDir: adapter.projectRoot,
-    bundle: true,
-    format: "cjs",
-    nodePaths: [adapter.nodeModulesDir],
-    platform: "node",
-    target: ["node20"],
-    outfile: "play-artifact.cjs",
-    write: false,
-    sourcemap: "external",
-    sourcesContent: false,
-    logLevel: "silent",
-    legalComments: "none",
-    plugins: [sdkAliasPlugin, playProxyPlugin].filter(
-      (plugin) => plugin != null
-    )
-  });
-  const codeFile = result.outputFiles?.find((f) => f.path.endsWith(".cjs"));
-  const mapFile = result.outputFiles?.find((f) => f.path.endsWith(".cjs.map"));
-  if (!codeFile?.text || !mapFile?.text) {
-    return ["Play bundling produced incomplete output."];
-  }
-  return {
-    bundledCode: codeFile.text,
-    sourceMapText: mapFile.text,
-    outputExtension: "cjs"
-  };
-}
-async function runEsbuildForEsmWorkers(playEntryFile, importedPlayDependencies, adapter, exportName) {
-  const sdkAliasPlugin = localSdkAliasPlugin(adapter, { workersRuntime: true });
-  const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
-  const playEntryAlias = exportName === "default" ? workersPlayEntryAliasPlugin(playEntryFile) : workersNamedPlayEntryAliasPlugin(playEntryFile, exportName);
-  const result = await (0, import_esbuild.build)({
-    // Entry is the Workers harness; it imports the play via the virtual
-    // `deepline-play-entry` alias resolved by workersPlayEntryAliasPlugin.
-    entryPoints: [adapter.workersHarnessEntryFile],
-    absWorkingDir: adapter.projectRoot,
-    bundle: true,
-    format: "esm",
-    nodePaths: [adapter.nodeModulesDir],
-    // Browser platform with workerd + worker conditions matches Cloudflare's
-    // V8-isolate runtime. Avoids accidentally pulling node-only branches of
-    // dual-publish packages.
-    platform: "browser",
-    conditions: ["workerd", "worker", "browser", "import", "default"],
-    mainFields: ["module", "main"],
-    target: ["es2022"],
-    outfile: "play-worker.mjs",
-    write: false,
-    sourcemap: "external",
-    sourcesContent: false,
-    logLevel: "silent",
-    legalComments: "none",
-    // Aggressive minify + treeshake: a tiny play (<1KB source) was producing
-    // an ~870KB bundle, dominated by zod's locale files (~260KB unused) and
-    // dead-code branches across `shared_libs/play-runtime/*` and the SDK.
-    // Both DCE on with these flags. workerd compiles each unique-graphHash
-    // bundle on first dispatch, so bundle bytes translate ~linearly into
-    // per-play cold latency on workers_edge. External sourcemap remains
-    // unchanged (`sourcemap: 'external'`), so debugging is unaffected.
-    minify: true,
-    treeShaking: true,
-    // Most node:* builtins are provided by Cloudflare's `nodejs_compat` flag.
-    // The unsupported subset (fs, fs/promises, os, child_process) gets
-    // replaced with throwing stubs by workersNodeBuiltinStubPlugin so deploy
-    // validation passes; anything supported (path, crypto, buffer, etc.) is
-    // marked external and resolved at runtime by the Workers runtime.
-    external: ["node:*", "cloudflare:workers"],
-    plugins: [
-      // Banlist runs first so a forbidden import errors out before any other
-      // resolver (esp. the workersNodeBuiltinStubPlugin which would silently
-      // turn it into a throwing-stub).
-      workersNodeImportBanlistPlugin(adapter),
-      sdkAliasPlugin,
-      playProxyPlugin,
-      playEntryAlias,
-      workersNodeBuiltinStubPlugin(),
-      // Strip non-English zod locale data from the bundle. zod's locales
-      // are re-exported as a static namespace from `zod/v4/core`, so
-      // tree-shaking can't drop them; this plugin replaces each
-      // non-English locale module with an empty default export at bundle
-      // time. ~150–200 KB savings on every per-play bundle, with no
-      // behavior change (we only surface English messages anyway).
-      // If the bundle suddenly grows back, check whether a new dep added
-      // its own zod copy or whether zod's locale layout changed.
-      zodNonEnglishLocaleStubPlugin()
-    ].filter((plugin) => plugin != null)
-  });
-  const codeFile = result.outputFiles?.find((f) => f.path.endsWith(".mjs"));
-  const mapFile = result.outputFiles?.find((f) => f.path.endsWith(".mjs.map"));
-  if (!codeFile?.text || !mapFile?.text) {
-    return ["Workers play bundling produced incomplete output."];
-  }
-  return {
-    bundledCode: codeFile.text,
-    sourceMapText: mapFile.text,
-    outputExtension: "mjs"
-  };
-}
-var PLAY_ARTIFACT_TARGET_ADAPTERS = {
-  [PLAY_ARTIFACT_KINDS.cjsNode20]: {
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    codeFormat: "cjs_module",
-    includeWorkersHarnessInGraphHash: false,
-    runEsbuild: ({
-      entryFile,
-      importedPlayDependencies,
-      adapter,
-      exportName
-    }) => runEsbuildForCjsNode(
-      entryFile,
-      importedPlayDependencies,
-      adapter,
-      exportName
-    )
-  },
-  [PLAY_ARTIFACT_KINDS.esmWorkers]: {
-    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
-    codeFormat: "esm_module",
-    includeWorkersHarnessInGraphHash: true,
-    runEsbuild: ({
-      entryFile,
-      importedPlayDependencies,
-      adapter,
-      exportName
-    }) => runEsbuildForEsmWorkers(
-      entryFile,
-      importedPlayDependencies,
-      adapter,
-      exportName
-    )
-  }
-};
-function resolvePlayArtifactTargetAdapter(artifactKind) {
-  return PLAY_ARTIFACT_TARGET_ADAPTERS[artifactKind];
-}
-async function bundlePlayFile(filePath, options) {
-  const adapter = options.adapter;
-  const target = options.target ?? PLAY_ARTIFACT_KINDS.cjsNode20;
-  const targetAdapter = resolvePlayArtifactTargetAdapter(target);
-  const exportName = options.exportName?.trim() || "default";
-  assertValidExportName(exportName);
-  const absolutePath = await normalizeLocalPath(filePath);
-  adapter.warnAboutNonDevelopmentBundling?.(absolutePath);
-  try {
-    const analysis = await analyzeSourceGraph(absolutePath, adapter);
-    analysis.graphHash = target === PLAY_ARTIFACT_KINDS.esmWorkers ? buildWorkersRuntimeGraphHash({
-      analysis,
-      entryFile: absolutePath,
-      adapter,
-      exportName
-    }) : sha256(`${analysis.graphHash}
-entry-export:${exportName}`);
-    if (targetAdapter.includeWorkersHarnessInGraphHash) {
-      const harnessFingerprint = await computeWorkersHarnessFingerprintWithAdapter(adapter);
-      analysis.graphHash = sha256(
-        `${analysis.graphHash}
-workers-harness:${harnessFingerprint}`
-      );
-    }
-    try {
-      validatePlaySourceFilesHaveNoInlineSecrets(analysis.sourceFiles);
-    } catch (error) {
-      return {
-        success: false,
-        filePath: absolutePath,
-        errors: [error instanceof Error ? error.message : String(error)]
-      };
-    }
-    const typecheckErrors = [
-      ...await adapter.typecheckPlaySource?.({
-        sourceCode: analysis.sourceCode,
-        sourcePath: absolutePath,
-        importedFilePaths: [
-          ...analysis.importPolicy.localFiles,
-          ...analysis.importedPlayDependencies.map(
-            (dependency) => dependency.filePath
-          )
-        ]
-      }) ?? []
-    ];
-    if (typecheckErrors.length > 0) {
-      return {
-        success: false,
-        filePath: absolutePath,
-        errors: typecheckErrors
-      };
-    }
-    const canUseArtifactCache = target !== PLAY_ARTIFACT_KINDS.esmWorkers;
-    const cachedArtifact = canUseArtifactCache ? await readArtifactCache(analysis.graphHash, target, adapter) : null;
-    const discoveredFiles = await adapter.discoverPackagedLocalFiles(absolutePath);
-    if (cachedArtifact) {
-      const cachedArtifactSizeError = getBundleSizeError(
-        absolutePath,
-        cachedArtifact.bundledCode,
-        target
-      );
-      if (cachedArtifactSizeError) {
-        return {
-          success: false,
-          filePath: absolutePath,
-          errors: [cachedArtifactSizeError]
-        };
-      }
-      return {
-        success: true,
-        artifact: {
-          ...cachedArtifact,
-          entryFile: absolutePath,
-          sourceHash: analysis.sourceHash,
-          importPolicy: analysis.importPolicy,
-          cacheHit: true
-        },
-        sourceCode: analysis.sourceCode,
-        sourceFiles: analysis.sourceFiles,
-        filePath: absolutePath,
-        playName: analysis.playName,
-        packagedFiles: discoveredFiles.files,
-        unresolvedFileReferences: discoveredFiles.unresolved,
-        importedPlayDependencies: analysis.importedPlayDependencies
-      };
-    }
-    const buildOutcome = await targetAdapter.runEsbuild({
-      entryFile: absolutePath,
-      importedPlayDependencies: analysis.importedPlayDependencies,
-      adapter,
-      exportName
-    });
-    if (Array.isArray(buildOutcome)) {
-      return {
-        success: false,
-        filePath: absolutePath,
-        errors: buildOutcome
-      };
-    }
-    const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
-    const normalizedSourceMap = normalizeSourceMapForRuntime(
-      sourceMapText,
-      (0, import_node_path9.resolve)(adapter.projectRoot)
-    );
-    const virtualBaseName = exportName === "default" ? (0, import_node_path9.basename)(absolutePath).replace(/\.[^.]+$/, "") : `${(0, import_node_path9.basename)(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
-    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
-    const executableCode = `${bundledCode}
-//# sourceMappingURL=${(0, import_node_path9.basename)(virtualFilename)}.map
-`;
-    const bundleSizeError = getBundleSizeError(
-      absolutePath,
-      executableCode,
-      target
-    );
-    if (bundleSizeError) {
-      return {
-        success: false,
-        filePath: absolutePath,
-        errors: [bundleSizeError]
-      };
-    }
-    const artifact = {
-      codeFormat: targetAdapter.codeFormat,
-      artifactKind: target,
-      entryFile: absolutePath,
-      virtualFilename,
-      sourceHash: analysis.sourceHash,
-      graphHash: analysis.graphHash,
-      artifactHash: sha256(executableCode),
-      sourceMapHash: sha256(normalizedSourceMap),
-      bundledCode: executableCode,
-      sourceMap: normalizedSourceMap,
-      importPolicy: analysis.importPolicy,
-      compatibility: buildPlayContractCompatibility(),
-      generatedAt: Date.now(),
-      cacheHit: false
-    };
-    if (canUseArtifactCache) {
-      await writeArtifactCache(artifact, adapter);
-    }
-    return {
-      success: true,
-      artifact,
-      sourceCode: analysis.sourceCode,
-      sourceFiles: analysis.sourceFiles,
-      filePath: absolutePath,
-      playName: analysis.playName,
-      packagedFiles: discoveredFiles.files,
-      unresolvedFileReferences: discoveredFiles.unresolved,
-      importedPlayDependencies: analysis.importedPlayDependencies
-    };
-  } catch (error) {
-    if (error && typeof error === "object" && "errors" in error) {
-      const errors = Array.isArray(error.errors) ? error.errors.map(formatEsbuildMessage) : ["Play bundling failed."];
-      return {
-        success: false,
-        filePath: absolutePath,
-        errors
-      };
-    }
-    return {
-      success: false,
-      filePath: absolutePath,
-      errors: [error instanceof Error ? error.message : String(error)]
-    };
-  }
-}
-
-// ../shared_libs/play-runtime/dedup-backend.ts
-var PLAY_DEDUP_BACKENDS = {
-  inMemory: "in_memory",
-  neonTable: "neon_table",
-  durableObject: "durable_object"
-};
-
-// ../shared_libs/play-runtime/scheduler-backend.ts
-var PLAY_SCHEDULER_BACKENDS = {
-  temporal: "temporal",
-  cfWorkflows: "cf-workflows",
-  /**
-   * Private legacy id retained only so old persisted rows can be interpreted.
-   * It is not a selectable scheduler backend after the Hatchet hard cutover.
-   */
-  postgres: "postgres",
-  hatchet: "hatchet",
-  inProcess: "in-process"
-};
-
-// ../shared_libs/play-runtime/providers.ts
-var PLAY_RUNTIME_PROVIDER_IDS = {
-  workersEdge: "workers_edge",
-  hatchet: "hatchet",
-  local: "local"
-};
-var PLAY_RUNTIME_PROVIDERS = {
-  workers_edge: {
-    id: PLAY_RUNTIME_PROVIDER_IDS.workersEdge,
-    scheduler: PLAY_SCHEDULER_BACKENDS.cfWorkflows,
-    runner: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
-    dedup: PLAY_DEDUP_BACKENDS.durableObject,
-    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
-    label: "Cloudflare Dynamic Workflows + Dynamic Workers + DO dedup"
-  },
-  hatchet: {
-    id: PLAY_RUNTIME_PROVIDER_IDS.hatchet,
-    scheduler: PLAY_SCHEDULER_BACKENDS.hatchet,
-    runner: PLAY_RUNTIME_BACKENDS.daytona,
-    dedup: PLAY_DEDUP_BACKENDS.durableObject,
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: "Hatchet scheduler + one-shot Daytona runner + DO dedup"
-  },
-  local: {
-    id: PLAY_RUNTIME_PROVIDER_IDS.local,
-    scheduler: PLAY_SCHEDULER_BACKENDS.temporal,
-    runner: PLAY_RUNTIME_BACKENDS.localProcess,
-    dedup: PLAY_DEDUP_BACKENDS.inMemory,
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: "Local Temporal scheduler + local subprocess runner (tests)"
-  }
-};
-function defaultPlayRuntimeProvider() {
-  return PLAY_RUNTIME_PROVIDERS.workers_edge;
-}
-function resolvePlayRuntimeProvider(override) {
-  if (override?.trim()) {
-    const id = override.trim();
-    if (id in PLAY_RUNTIME_PROVIDERS) {
-      return PLAY_RUNTIME_PROVIDERS[id];
-    }
-    throw new Error(
-      `Unknown play runtime provider "${id}". Expected one of: ${Object.keys(
-        PLAY_RUNTIME_PROVIDERS
-      ).join(", ")}.`
-    );
-  }
-  return defaultPlayRuntimeProvider();
-}
-
-// ../shared_libs/play-runtime/profiles.ts
-var PLAY_EXECUTION_PROFILE_IDS = {
-  ...PLAY_RUNTIME_PROVIDER_IDS
-};
-var PLAY_EXECUTION_PROFILES = PLAY_RUNTIME_PROVIDERS;
-function resolveExecutionProfile(override) {
-  try {
-    return resolvePlayRuntimeProvider(override);
-  } catch (error) {
-    if (override?.trim()) {
-      throw new Error(
-        `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
-          PLAY_EXECUTION_PROFILES
-        ).join(", ")}.`
-      );
-    }
-    throw error;
-  }
-}
-
-// src/plays/local-file-discovery.ts
-var import_node_crypto2 = require("crypto");
-var import_promises4 = require("fs/promises");
-var import_node_path10 = require("path");
-var SOURCE_EXTENSIONS2 = [
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".json"
-];
-function sha2562(buffer) {
-  return (0, import_node_crypto2.createHash)("sha256").update(buffer).digest("hex");
-}
-function contentTypeForFile(filePath) {
-  const extension = (0, import_node_path10.extname)(filePath).toLowerCase();
-  if (extension === ".csv") return "text/csv";
-  if (extension === ".json") return "application/json";
-  if (extension === ".txt") return "text/plain";
-  return "application/octet-stream";
-}
-function stripCommentsToSpaces2(source) {
-  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
-    /(^|[^:])\/\/.*$/gm,
-    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
-  );
-}
-function unquoteStringLiteral2(literal) {
-  const trimmed = literal.trim();
-  const quote = trimmed[0];
-  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
-    return null;
-  }
-  try {
-    return JSON.parse(
-      quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`
-    );
-  } catch {
-    return trimmed.slice(1, -1);
-  }
-}
-function splitTopLevelPlus(expression) {
-  const parts = [];
-  let start = 0;
-  let depth = 0;
-  let quote = null;
-  let escaped = false;
-  for (let index = 0; index < expression.length; index += 1) {
-    const char = expression[index];
-    if (quote) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === quote) {
-        quote = null;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "(" || char === "[" || char === "{") depth += 1;
-    if (char === ")" || char === "]" || char === "}") depth -= 1;
-    if (char === "+" && depth === 0) {
-      parts.push(expression.slice(start, index));
-      start = index + 1;
-    }
-  }
-  if (parts.length === 0) return null;
-  parts.push(expression.slice(start));
-  return parts;
-}
-function stripOuterParens(expression) {
-  let value = expression.trim();
-  while (value.startsWith("(") && value.endsWith(")")) {
-    value = value.slice(1, -1).trim();
-  }
-  return value;
-}
-function isRuntimeInputExpression(expression) {
-  return /(^|[^\w$])input([^\w$]|$)/.test(expression);
-}
-function resolveStringExpression(expression, constants) {
-  const value = stripOuterParens(expression);
-  if (/^(['"])(?:\\.|(?!\1)[\s\S])*\1$/.test(value)) {
-    return unquoteStringLiteral2(value);
-  }
-  if (/^`(?:\\.|[^`$]|\$(?!\{))*`$/.test(value)) {
-    return value.slice(1, -1);
-  }
-  if (/^[A-Za-z_$][\w$]*$/.test(value)) {
-    return constants.get(value) ?? null;
-  }
-  const parts = splitTopLevelPlus(value);
-  if (parts) {
-    const resolved = parts.map(
-      (part) => resolveStringExpression(part, constants)
-    );
-    return resolved.every((part) => part != null) ? resolved.join("") : null;
-  }
-  return null;
-}
-function collectTopLevelStringConstants(sourceCode) {
-  const constants = /* @__PURE__ */ new Map();
-  const source = stripCommentsToSpaces2(sourceCode);
-  for (const match of source.matchAll(
-    /(?:^|\n)\s*const\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/g
-  )) {
-    const resolved = resolveStringExpression(match[2], constants);
-    if (resolved != null) {
-      constants.set(match[1], resolved);
-    }
-  }
-  return constants;
-}
-function findMatchingGenericEnd(source, openIndex) {
-  let depth = 0;
-  let quote = null;
-  let escaped = false;
-  for (let index = openIndex; index < source.length; index += 1) {
-    const char = source[index];
-    if (quote) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === quote) {
-        quote = null;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "<") depth += 1;
-    if (char === ">") {
-      depth -= 1;
-      if (depth === 0) return index;
-    }
-  }
-  return -1;
-}
-function findCallOpenParen(source, afterCsvIndex) {
-  let index = afterCsvIndex;
-  while (/\s/.test(source[index] ?? "")) index += 1;
-  if (source[index] === "<") {
-    const genericEnd = findMatchingGenericEnd(source, index);
-    if (genericEnd < 0) return -1;
-    index = genericEnd + 1;
-    while (/\s/.test(source[index] ?? "")) index += 1;
-  }
-  return source[index] === "(" ? index : -1;
-}
-function firstCallArgument(source, openParen) {
-  let depth = 0;
-  let quote = null;
-  let escaped = false;
-  const start = openParen + 1;
-  for (let index = start; index < source.length; index += 1) {
-    const char = source[index];
-    if (quote) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === quote) {
-        quote = null;
-      }
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      quote = char;
-      continue;
-    }
-    if (char === "(" || char === "[" || char === "{") depth += 1;
-    if (char === ")" && depth === 0) {
-      const text = source.slice(start, index).trim();
-      return text ? { text, start, end: index } : null;
-    }
-    if (char === "," && depth === 0) {
-      const text = source.slice(start, index).trim();
-      return text ? { text, start, end: index } : null;
-    }
-    if (char === ")" || char === "]" || char === "}") depth -= 1;
-  }
-  return null;
-}
-function localImportSpecifiers(sourceCode) {
-  const source = stripCommentsToSpaces2(sourceCode);
-  const specifiers = [];
-  for (const match of source.matchAll(
-    /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]/g
-  )) {
-    if (match[1]?.startsWith(".")) specifiers.push(match[1]);
-  }
-  for (const match of source.matchAll(
-    /\brequire\s*\(\s*(['"])(\.[^'"]*)\1\s*\)/g
-  )) {
-    specifiers.push(match[2]);
-  }
-  return specifiers;
-}
-async function fileExists2(filePath) {
-  try {
-    await (0, import_promises4.stat)(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isPathInsideDirectory2(filePath, directory) {
-  const relativePath = (0, import_node_path10.relative)(directory, filePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !(0, import_node_path10.isAbsolute)(relativePath);
-}
-async function resolveLocalImport2(fromFile, specifier) {
-  const base = (0, import_node_path10.isAbsolute)(specifier) ? (0, import_node_path10.resolve)(specifier) : (0, import_node_path10.resolve)((0, import_node_path10.dirname)(fromFile), specifier);
-  const candidates = [base];
-  const explicitExtension = (0, import_node_path10.extname)(base).toLowerCase();
-  if (!explicitExtension) {
-    candidates.push(
-      ...SOURCE_EXTENSIONS2.map((extension) => `${base}${extension}`)
-    );
-    candidates.push(
-      ...SOURCE_EXTENSIONS2.map((extension) => (0, import_node_path10.join)(base, `index${extension}`))
-    );
-  } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
-    const stem = base.slice(0, -explicitExtension.length);
-    candidates.push(
-      ...SOURCE_EXTENSIONS2.map((extension) => `${stem}${extension}`)
-    );
-  }
-  for (const candidate of candidates) {
-    if (await fileExists2(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(
-    `Could not resolve local import "${specifier}" from ${fromFile}`
-  );
-}
-async function discoverPackagedLocalFiles(entryFile) {
-  const absoluteEntryFile = (0, import_node_path10.resolve)(entryFile);
-  const packagingRoot = (0, import_node_path10.dirname)(absoluteEntryFile);
-  const files = /* @__PURE__ */ new Map();
-  const unresolved = [];
-  const visitedFiles = /* @__PURE__ */ new Set();
-  const visitSourceFile = async (filePath) => {
-    const absolutePath = (0, import_node_path10.resolve)(filePath);
-    if (visitedFiles.has(absolutePath)) {
-      return;
-    }
-    visitedFiles.add(absolutePath);
-    const sourceCode = await (0, import_promises4.readFile)(absolutePath, "utf-8");
-    const scanSource = stripCommentsToSpaces2(sourceCode);
-    const constants = collectTopLevelStringConstants(sourceCode);
-    const childVisits = [];
-    for (const match of scanSource.matchAll(
-      /\b([A-Za-z_$][\w$]*)\s*\.\s*csv\b/g
-    )) {
-      const target = match[1];
-      if (target !== "ctx" && !target.endsWith("Ctx")) {
-        continue;
-      }
-      const openParen = findCallOpenParen(
-        scanSource,
-        match.index + match[0].length
-      );
-      if (openParen < 0) {
-        continue;
-      }
-      const argument = firstCallArgument(scanSource, openParen);
-      if (!argument) {
-        unresolved.push({
-          sourceFragment: "ctx.csv()",
-          message: "ctx.csv() requires a file path string or input reference."
-        });
-      } else if (!isRuntimeInputExpression(argument.text)) {
-        const resolvedPath = resolveStringExpression(argument.text, constants);
-        if (resolvedPath == null) {
-          unresolved.push({
-            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
-            message: "Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file."
-          });
-        } else {
-          const absoluteCsvPath = (0, import_node_path10.resolve)((0, import_node_path10.dirname)(absolutePath), resolvedPath);
-          if ((0, import_node_path10.isAbsolute)(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
-            unresolved.push({
-              sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
-              message: "ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead."
-            });
-            continue;
-          }
-          const buffer = await (0, import_promises4.readFile)(absoluteCsvPath);
-          const stats = await (0, import_promises4.stat)(absoluteCsvPath);
-          files.set(absoluteCsvPath, {
-            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
-            logicalPath: resolvedPath,
-            absolutePath: absoluteCsvPath,
-            bytes: stats.size,
-            contentHash: sha2562(buffer),
-            contentType: contentTypeForFile(absoluteCsvPath)
-          });
-        }
-      }
-    }
-    for (const specifier of localImportSpecifiers(sourceCode)) {
-      childVisits.push(
-        resolveLocalImport2(absolutePath, specifier).then(
-          (resolvedImport) => visitSourceFile(resolvedImport)
-        )
-      );
-    }
-    await Promise.all(childVisits);
-  };
-  await visitSourceFile(absoluteEntryFile);
-  return {
-    files: [...files.values()],
-    unresolved
-  };
-}
-
-// src/plays/bundle-play-file.ts
-var import_meta = {};
-var PLAY_BUNDLE_CACHE_VERSION2 = 30;
-var MODULE_DIR = (0, import_node_path11.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-var SDK_PACKAGE_ROOT = (0, import_node_path11.resolve)(MODULE_DIR, "..", "..");
-var SOURCE_REPO_ROOT = (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "..");
-var HAS_SOURCE_BUNDLING_SOURCES = (0, import_node_fs9.existsSync)(
-  (0, import_node_path11.resolve)(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
-);
-var PACKAGED_REPO_ROOT = (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "dist", "repo");
-var HAS_PACKAGED_BUNDLING_SOURCES = (0, import_node_fs9.existsSync)(
-  (0, import_node_path11.resolve)(PACKAGED_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
-);
-var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_REPO_ROOT : (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "..");
-var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? (0, import_node_path11.resolve)(SOURCE_REPO_ROOT, "sdk", "src") : HAS_PACKAGED_BUNDLING_SOURCES ? (0, import_node_path11.resolve)(PACKAGED_REPO_ROOT, "sdk", "src") : (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "src");
-var SDK_PACKAGE_JSON = (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "package.json");
-var SDK_ENTRY_FILE = (0, import_node_path11.resolve)(SDK_SOURCE_ROOT, "index.ts");
-var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
-var SDK_WORKERS_ENTRY_FILE = (0, import_node_path11.resolve)(SDK_SOURCE_ROOT, "worker-play-entry.ts");
-var WORKERS_HARNESS_ENTRY_FILE = (0, import_node_path11.resolve)(
-  PROJECT_ROOT,
-  "apps",
-  "play-runner-workers",
-  "src",
-  "entry.ts"
-);
-var WORKERS_HARNESS_FILES_DIR = (0, import_node_path11.resolve)(
-  PROJECT_ROOT,
-  "apps",
-  "play-runner-workers",
-  "src"
-);
-var hasWarnedAboutNonDevelopmentBundling = false;
-function warnAboutNonDevelopmentBundling(filePath) {
-  if (hasWarnedAboutNonDevelopmentBundling) {
-    return;
-  }
-  const nodeEnv = String(process.env.NODE_ENV ?? "").trim().toLowerCase();
-  if (!nodeEnv || nodeEnv === "development" || nodeEnv === "test") {
-    return;
-  }
-  hasWarnedAboutNonDevelopmentBundling = true;
-  console.warn(
-    `[deepline] Warning: live play bundling was invoked while NODE_ENV=${nodeEnv} for ${filePath}. This source-first SDK path is intended for local development. For preview/production, run a published or prebuilt play reference instead of bundling source at runtime.`
-  );
-  console.warn(
-    '[deepline] Preferred production call pattern: client.play("person-to-email").run(...) or run a previously registered/published org play.'
-  );
-}
-function defaultPlayBundleTarget() {
-  return resolveExecutionProfile(null).artifactKind;
-}
-function createSdkPlayBundlingAdapter() {
-  return {
-    projectRoot: PROJECT_ROOT,
-    nodeModulesDir: (0, import_node_path11.resolve)(PROJECT_ROOT, "node_modules"),
-    cacheDir: (0, import_node_path11.join)(
-      (0, import_node_os8.tmpdir)(),
-      `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION2}`
-    ),
-    sdkSourceRoot: SDK_SOURCE_ROOT,
-    sdkPackageJson: SDK_PACKAGE_JSON,
-    sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !(0, import_node_fs9.existsSync)(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
-    sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
-    workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
-    workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
-    workersRuntimeFingerprintDirs: [
-      (0, import_node_path11.resolve)(PROJECT_ROOT, "shared_libs", "play-runtime")
-    ],
-    discoverPackagedLocalFiles,
-    warnAboutNonDevelopmentBundling
-  };
-}
-async function bundlePlayFile2(filePath, options = {}) {
-  const result = await bundlePlayFile(filePath, {
-    target: options.target ?? defaultPlayBundleTarget(),
-    exportName: options.exportName,
-    adapter: createSdkPlayBundlingAdapter()
-  });
-  if (result.success)
-    validatePlaySourceFilesHaveNoInlineSecrets(result.sourceFiles);
-  return result;
-}
-
-// src/cli/commands/plays/bootstrap.ts
-var import_node_fs10 = require("fs");
-var import_node_path12 = require("path");
-var import_sync4 = require("csv-parse/sync");
-
-// ../shared_libs/plays/bootstrap-routes.ts
-var PLAY_BOOTSTRAP_TEMPLATES = [
-  "people-list",
-  "company-list",
-  "people-email",
-  "people-phone",
-  "company-people",
-  "company-people-email",
-  "company-people-phone"
-];
-var PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY = "company_search";
-var PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY = "people_search";
-var PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER = {
-  email_finder: "email_finder",
-  phone_finder: "phone_finder"
-};
-var PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER = {
-  email_finder: "email",
-  phone_finder: "phone"
-};
-function isPlayBootstrapTemplate(value) {
-  return PLAY_BOOTSTRAP_TEMPLATES.includes(value);
-}
-function formatPlayBootstrapTemplates() {
-  return PLAY_BOOTSTRAP_TEMPLATES.join("|");
-}
-
-// src/cli/commands/plays/bootstrap.ts
-function parseReferencedPlayTarget(target) {
-  const trimmed = target.trim();
-  const slashIndex = trimmed.indexOf("/");
-  if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
-    return { ownerSlug: null, playName: trimmed, unqualifiedPlayName: trimmed };
-  }
-  return {
-    ownerSlug: trimmed.slice(0, slashIndex),
-    playName: trimmed,
-    unqualifiedPlayName: trimmed.slice(slashIndex + 1)
-  };
-}
-function parsePositiveInteger2(value, flagName) {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new PlayBootstrapUsageError(
-      `${flagName} must be a positive integer.`
-    );
-  }
-  return parsed;
-}
-function isRecord5(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function stringValue(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord5);
-  if (!isRecord5(value)) return [];
-  return Object.entries(value).map(
-    ([name, entry]) => isRecord5(entry) ? { name, ...entry } : { name }
-  );
-}
-var PlayBootstrapError = class extends Error {
-  constructor(message, exitCode) {
-    super(message);
-    this.exitCode = exitCode;
-  }
-  exitCode;
-};
-var PlayBootstrapUsageError = class extends PlayBootstrapError {
-  constructor(message) {
-    super(message, 2);
-  }
-};
-var PlayBootstrapValidationError = class extends PlayBootstrapError {
-  constructor(message) {
-    super(message, 7);
+};
+var PlayBootstrapValidationError = class extends PlayBootstrapError {
+  constructor(message) {
+    super(message, 7);
   }
 };
 var CSV_HEADER_SAMPLE_BYTES = 64 * 1024;
@@ -8930,13 +7214,13 @@ function inferCsvColumnSpecs(headers, rows) {
   }));
 }
 function readCsvSample(csvPath) {
-  const resolvedPath = (0, import_node_path12.resolve)(csvPath);
-  const size = (0, import_node_fs10.statSync)(resolvedPath).size;
-  const fd = (0, import_node_fs10.openSync)(resolvedPath, "r");
+  const resolvedPath = (0, import_node_path9.resolve)(csvPath);
+  const size = (0, import_node_fs8.statSync)(resolvedPath).size;
+  const fd = (0, import_node_fs8.openSync)(resolvedPath, "r");
   const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
   const buffer = Buffer.alloc(byteLength);
-  const bytesRead = (0, import_node_fs10.readSync)(fd, buffer, 0, byteLength, 0);
-  (0, import_node_fs10.closeSync)(fd);
+  const bytesRead = (0, import_node_fs8.readSync)(fd, buffer, 0, byteLength, 0);
+  (0, import_node_fs8.closeSync)(fd);
   if (bytesRead === 0) {
     throw new PlayBootstrapUsageError(`--from csv:${csvPath} is empty.`);
   }
@@ -9005,9 +7289,9 @@ ${properties}
 }
 function packagedCsvPathForPlay(csvPath) {
   const playDir = process.cwd();
-  const absoluteCsvPath = (0, import_node_path12.resolve)(csvPath);
-  const relativePath = (0, import_node_path12.relative)(playDir, absoluteCsvPath);
-  if (relativePath === "" || relativePath.startsWith("..") || (0, import_node_path12.isAbsolute)(relativePath)) {
+  const absoluteCsvPath = (0, import_node_path9.resolve)(csvPath);
+  const relativePath = (0, import_node_path9.relative)(playDir, absoluteCsvPath);
+  if (relativePath === "" || relativePath.startsWith("..") || (0, import_node_path9.isAbsolute)(relativePath)) {
     throw new PlayBootstrapUsageError(
       `--from csv:${csvPath} must point to a file inside the directory where you run plays bootstrap. Run bootstrap from the intended play directory and write the play with --out there.`
     );
@@ -9926,8 +8210,8 @@ async function runPlayBootstrap(args) {
     ...csvContext
   });
   if (options.out) {
-    (0, import_node_fs10.writeFileSync)((0, import_node_path12.resolve)(options.out), source, "utf-8");
-    process.stdout.write(`Wrote ${(0, import_node_path12.resolve)(options.out)}
+    (0, import_node_fs8.writeFileSync)((0, import_node_path9.resolve)(options.out), source, "utf-8");
+    process.stdout.write(`Wrote ${(0, import_node_path9.resolve)(options.out)}
 `);
     return 0;
   }
@@ -10271,23 +8555,144 @@ function hintForError(error, sourceLine) {
   if (looksLikeRunPlaySignature(error, sourceLine)) {
     return RUN_PLAY_SIGNATURE_HINT;
   }
-  if (looksLikeRowPropertyMismatch(error, sourceLine)) {
-    return ROW_PROPERTY_HINT;
+  if (looksLikeRowPropertyMismatch(error, sourceLine)) {
+    return ROW_PROPERTY_HINT;
+  }
+  return null;
+}
+function addPlayCheckRepairHints(input2) {
+  const addedHints = /* @__PURE__ */ new Set();
+  return input2.errors.map((error) => {
+    const line = sourceLineForError(input2.sourceCode, error);
+    const hint = hintForError(error, line);
+    if (!hint || addedHints.has(hint) || error.includes(hint)) {
+      return error;
+    }
+    addedHints.add(hint);
+    return `${error}
+${hint}`;
+  });
+}
+
+// ../shared_libs/play-runtime/backend.ts
+var PLAY_RUNTIME_BACKENDS = {
+  localProcess: "local_process",
+  daytona: "daytona",
+  // Artifact/runtime contract for Cloudflare Dynamic Workers. This is no
+  // longer a standalone runner backend; use profile=workers_edge so the
+  // cf-workflows scheduler owns loading and execution.
+  cloudflareWorkers: "cloudflare_workers"
+};
+var PLAY_ARTIFACT_KINDS = {
+  cjsNode20: "cjs_node20",
+  esmWorkers: "esm_workers"
+};
+var PLAY_BACKEND_DESCRIPTORS = {
+  [PLAY_RUNTIME_BACKENDS.localProcess]: {
+    id: PLAY_RUNTIME_BACKENDS.localProcess,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Local node subprocess"
+  },
+  [PLAY_RUNTIME_BACKENDS.daytona]: {
+    id: PLAY_RUNTIME_BACKENDS.daytona,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Daytona sandbox"
+  },
+  [PLAY_RUNTIME_BACKENDS.cloudflareWorkers]: {
+    id: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
+    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
+    label: "Cloudflare Dynamic Workers"
+  }
+};
+
+// ../shared_libs/play-runtime/dedup-backend.ts
+var PLAY_DEDUP_BACKENDS = {
+  inMemory: "in_memory",
+  neonTable: "neon_table",
+  durableObject: "durable_object"
+};
+
+// ../shared_libs/play-runtime/scheduler-backend.ts
+var PLAY_SCHEDULER_BACKENDS = {
+  temporal: "temporal",
+  cfWorkflows: "cf-workflows",
+  /**
+   * Private legacy id retained only so old persisted rows can be interpreted.
+   * It is not a selectable scheduler backend after the Hatchet hard cutover.
+   */
+  postgres: "postgres",
+  hatchet: "hatchet",
+  inProcess: "in-process"
+};
+
+// ../shared_libs/play-runtime/providers.ts
+var PLAY_RUNTIME_PROVIDER_IDS = {
+  workersEdge: "workers_edge",
+  hatchet: "hatchet",
+  local: "local"
+};
+var PLAY_RUNTIME_PROVIDERS = {
+  workers_edge: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.workersEdge,
+    scheduler: PLAY_SCHEDULER_BACKENDS.cfWorkflows,
+    runner: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
+    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
+    label: "Cloudflare Dynamic Workflows + Dynamic Workers + DO dedup"
+  },
+  hatchet: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.hatchet,
+    scheduler: PLAY_SCHEDULER_BACKENDS.hatchet,
+    runner: PLAY_RUNTIME_BACKENDS.daytona,
+    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Hatchet scheduler + one-shot Daytona runner + DO dedup"
+  },
+  local: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.local,
+    scheduler: PLAY_SCHEDULER_BACKENDS.temporal,
+    runner: PLAY_RUNTIME_BACKENDS.localProcess,
+    dedup: PLAY_DEDUP_BACKENDS.inMemory,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Local Temporal scheduler + local subprocess runner (tests)"
+  }
+};
+function defaultPlayRuntimeProvider() {
+  return PLAY_RUNTIME_PROVIDERS.workers_edge;
+}
+function resolvePlayRuntimeProvider(override) {
+  if (override?.trim()) {
+    const id = override.trim();
+    if (id in PLAY_RUNTIME_PROVIDERS) {
+      return PLAY_RUNTIME_PROVIDERS[id];
+    }
+    throw new Error(
+      `Unknown play runtime provider "${id}". Expected one of: ${Object.keys(
+        PLAY_RUNTIME_PROVIDERS
+      ).join(", ")}.`
+    );
   }
-  return null;
+  return defaultPlayRuntimeProvider();
 }
-function addPlayCheckRepairHints(input2) {
-  const addedHints = /* @__PURE__ */ new Set();
-  return input2.errors.map((error) => {
-    const line = sourceLineForError(input2.sourceCode, error);
-    const hint = hintForError(error, line);
-    if (!hint || addedHints.has(hint) || error.includes(hint)) {
-      return error;
+
+// ../shared_libs/play-runtime/profiles.ts
+var PLAY_EXECUTION_PROFILE_IDS = {
+  ...PLAY_RUNTIME_PROVIDER_IDS
+};
+var PLAY_EXECUTION_PROFILES = PLAY_RUNTIME_PROVIDERS;
+function resolveExecutionProfile(override) {
+  try {
+    return resolvePlayRuntimeProvider(override);
+  } catch (error) {
+    if (override?.trim()) {
+      throw new Error(
+        `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
+          PLAY_EXECUTION_PROFILES
+        ).join(", ")}.`
+      );
     }
-    addedHints.add(hint);
-    return `${error}
-${hint}`;
-  });
+    throw error;
+  }
 }
 
 // ../shared_libs/play-runtime/internal-step-ids.ts
@@ -10297,6 +8702,165 @@ function isInternalGlueStepId(stepId) {
 }
 
 // src/cli/commands/play.ts
+var PLAY_BUNDLER_MODULE_PATHS = [
+  // Built CLI bundle: dist/cli/index.mjs -> dist/plays/bundle-play-file.mjs.
+  ["..", "plays", "bundle-play-file.mjs"].join("/"),
+  // Source CLI: src/cli/commands/play.ts -> src/plays/bundle-play-file.ts.
+  ["..", "..", "plays", "bundle-play-file.js"].join("/")
+];
+var playBundlerPromise = null;
+async function loadPlayBundler() {
+  playBundlerPromise ??= (async () => {
+    const errors = [];
+    for (const modulePath of PLAY_BUNDLER_MODULE_PATHS) {
+      try {
+        return await import(modulePath);
+      } catch (error) {
+        errors.push(
+          `${modulePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    playBundlerPromise = null;
+    throw new Error(
+      `Local play-file bundling is unavailable in this Deepline SDK install. Reinstall the package, or run a saved/prebuilt play by name while you repair the install. Bundler load failed: ${errors.join("; ")}`
+    );
+  })();
+  return playBundlerPromise;
+}
+function stripCommentsToSpaces(source) {
+  let output2 = "";
+  let quote = null;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (lineComment) {
+      if (char === "\n" || char === "\r") {
+        lineComment = false;
+        output2 += char;
+      } else {
+        output2 += " ";
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        output2 += "  ";
+        index += 1;
+        blockComment = false;
+      } else {
+        output2 += char === "\n" || char === "\r" ? char : " ";
+      }
+      continue;
+    }
+    if (quote) {
+      output2 += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      output2 += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      output2 += "  ";
+      index += 1;
+      lineComment = true;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      output2 += "  ";
+      index += 1;
+      blockComment = true;
+      continue;
+    }
+    output2 += char;
+  }
+  return output2;
+}
+function unquotePlayNameLiteral(raw) {
+  if (raw.length < 2) return null;
+  const quote = raw[0];
+  let value = "";
+  for (let index = 1; index < raw.length - 1; index += 1) {
+    const char = raw[index];
+    if (char !== "\\") {
+      value += char;
+      continue;
+    }
+    index += 1;
+    const escaped = raw[index];
+    if (escaped === void 0) return null;
+    value += escaped === "n" ? "\n" : escaped === "r" ? "\r" : escaped === "t" ? "	" : escaped;
+  }
+  if (quote === "`" && value.includes("${")) return null;
+  return value;
+}
+function findMatchingBrace(source, openIndex) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function extractDefinedPlayName(code) {
+  const source = stripCommentsToSpaces(code);
+  const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
+  for (const match of source.matchAll(callPattern)) {
+    const openParen = match.index + match[0].length - 1;
+    const firstArgStart = openParen + 1;
+    const firstNonSpace = source.slice(firstArgStart).search(/\S/);
+    if (firstNonSpace < 0) continue;
+    const argIndex = firstArgStart + firstNonSpace;
+    const quote = source[argIndex];
+    if (quote === '"' || quote === "'" || quote === "`") {
+      const literalMatch = source.slice(argIndex).match(/^(['"`])(?:\\.|(?!\1)[\s\S])*\1/);
+      const value2 = literalMatch ? unquotePlayNameLiteral(literalMatch[0]) : null;
+      if (value2?.trim()) return value2.trim();
+    }
+    if (quote !== "{") continue;
+    const closeBrace = findMatchingBrace(source, argIndex);
+    if (closeBrace < 0) continue;
+    const objectSource = source.slice(argIndex + 1, closeBrace);
+    const idMatch = objectSource.match(
+      /(?:^|[,{\s])(?:id|name|['"](?:id|name)['"])\s*:\s*(['"`])((?:\\.|(?!\1)[\s\S])*)\1/
+    );
+    const value = idMatch ? unquotePlayNameLiteral(`${idMatch[1]}${idMatch[2]}${idMatch[1]}`) : null;
+    if (value?.trim()) return value.trim();
+  }
+  return null;
+}
 var PLAY_RUN_RESERVED_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "--json",
   "--wait",
@@ -10331,7 +8895,7 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep5(ms) {
-  return new Promise((resolve16) => setTimeout(resolve16, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -10375,7 +8939,7 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return (0, import_node_path13.resolve)(defaultStarterPlayPath(reference));
+  return (0, import_node_path10.resolve)(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
   const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
@@ -10401,15 +8965,15 @@ function materializeRemotePlaySource(input2) {
     return null;
   }
   const outputPath = input2.outPath ?? defaultMaterializedPlayPath(input2.playName);
-  if ((0, import_node_fs11.existsSync)(outputPath)) {
-    const existingSource = (0, import_node_fs11.readFileSync)(outputPath, "utf-8");
+  if ((0, import_node_fs9.existsSync)(outputPath)) {
+    const existingSource = (0, import_node_fs9.readFileSync)(outputPath, "utf-8");
     if (existingSource === input2.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    (0, import_node_fs11.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
+    (0, import_node_fs9.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  (0, import_node_fs11.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
+  (0, import_node_fs9.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -10454,7 +9018,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return (0, import_node_fs11.existsSync)((0, import_node_path13.resolve)(target));
+  return (0, import_node_fs9.existsSync)((0, import_node_path10.resolve)(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -10483,7 +9047,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? (0, import_node_fs11.readFileSync)((0, import_node_path13.resolve)(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? (0, import_node_fs9.readFileSync)((0, import_node_path10.resolve)(raw.slice(1)), "utf-8") : raw;
   const parsed = JSON.parse(source);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("--input must be a JSON object.");
@@ -10585,7 +9149,7 @@ function fileInputBindingsFromStaticPipeline(staticPipeline) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return (0, import_node_fs11.existsSync)((0, import_node_path13.resolve)(value));
+  return (0, import_node_fs9.existsSync)((0, import_node_path10.resolve)(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -10632,7 +9196,7 @@ function collectLocalFileInputRefs(value, inputPath, key, out) {
     const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
     if (keyIsCsvData) {
       out.push({ inputPath, value: trimmed, isCsvData: true });
-    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs11.existsSync)((0, import_node_path13.resolve)(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs9.existsSync)((0, import_node_path10.resolve)(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -10674,8 +9238,8 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = (0, import_node_path13.resolve)(ref.value);
-    if (!(0, import_node_fs11.existsSync)(absolutePath)) {
+    const absolutePath = (0, import_node_path10.resolve)(ref.value);
+    if (!(0, import_node_fs9.existsSync)(absolutePath)) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
         void 0,
@@ -10683,9 +9247,9 @@ function preflightLocalFileInputs(runtimeInput) {
         { inputPath: ref.inputPath, path: ref.value, resolved: absolutePath }
       );
     }
-    let stat4;
+    let stat2;
     try {
-      stat4 = (0, import_node_fs11.statSync)(absolutePath);
+      stat2 = (0, import_node_fs9.statSync)(absolutePath);
     } catch (error) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that is not readable: ${ref.value} (${error instanceof Error ? error.message : String(error)}). No run was created.`,
@@ -10694,7 +9258,7 @@ function preflightLocalFileInputs(runtimeInput) {
         { inputPath: ref.inputPath, path: ref.value }
       );
     }
-    if (!stat4.isFile()) {
+    if (!stat2.isFile()) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references ${ref.value}, which is not a file. No run was created.`,
         void 0,
@@ -10711,7 +9275,7 @@ function preflightLocalFileInputs(runtimeInput) {
 function preflightCsvDataInput(ref, absolutePath) {
   let content;
   try {
-    content = (0, import_node_fs11.readFileSync)(absolutePath, "utf-8");
+    content = (0, import_node_fs9.readFileSync)(absolutePath, "utf-8");
   } catch (error) {
     throw new DeeplineError(
       `Input ${ref.inputPath} CSV ${ref.value} is not readable: ${error instanceof Error ? error.message : String(error)}. No run was created.`,
@@ -10793,8 +9357,8 @@ async function stageFileInputArgs(input2) {
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input2.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = (0, import_node_path13.resolve)(value);
-    return [{ binding, absolutePath, logicalPath: (0, import_node_path13.basename)(absolutePath) }];
+    const absolutePath = (0, import_node_path10.resolve)(value);
+    return [{ binding, absolutePath, logicalPath: (0, import_node_path10.basename)(absolutePath) }];
   });
   if (localFiles.length === 0) {
     return { inputFile: null, packagedFiles: [] };
@@ -10826,20 +9390,20 @@ async function stageFileInputArgs(input2) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = (0, import_node_fs11.readFileSync)(absolutePath);
+  const buffer = (0, import_node_fs9.readFileSync)(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
-    contentHash: (0, import_node_crypto3.createHash)("sha256").update(buffer).digest("hex"),
+    contentHash: (0, import_node_crypto.createHash)("sha256").update(buffer).digest("hex"),
     contentType: absolutePath.toLowerCase().endsWith(".csv") ? "text/csv" : absolutePath.toLowerCase().endsWith(".json") ? "application/json" : "application/octet-stream",
     bytes: buffer.byteLength
   };
 }
 function normalizePlayPath(filePath) {
   try {
-    return import_node_fs11.realpathSync.native((0, import_node_path13.resolve)(filePath));
+    return import_node_fs9.realpathSync.native((0, import_node_path10.resolve)(filePath));
   } catch {
-    return (0, import_node_path13.resolve)(filePath);
+    return (0, import_node_path10.resolve)(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -10850,6 +9414,7 @@ function formatUnresolvedPackagedFiles(filePath, unresolvedFileReferences) {
   return `Failed to package local ctx.csv(...) files in ${filePath}: ${details}`;
 }
 async function collectBundledPlayGraph(entryFile, profile = null) {
+  const playBundler = await loadPlayBundler();
   const nodes = /* @__PURE__ */ new Map();
   const visiting = /* @__PURE__ */ new Set();
   const artifactKind = resolveExecutionProfile(profile).artifactKind;
@@ -10866,7 +9431,7 @@ async function collectBundledPlayGraph(entryFile, profile = null) {
     }
     visiting.add(absolutePath);
     try {
-      const bundleResult = await bundlePlayFile2(absolutePath, {
+      const bundleResult = await playBundler.bundlePlayFile(absolutePath, {
         target: artifactKind
       });
       if (bundleResult.success === false) {
@@ -11490,6 +10055,7 @@ async function waitForPlayCompletionByStream(input2) {
         input2.workflowId,
         {
           signal: controller.signal,
+          fallback: "none",
           onNotice: input2.jsonOutput ? void 0 : (message) => input2.progress.writeLine(message)
         }
       )) {
@@ -12503,15 +11069,15 @@ function formatDatasetStatsLines(datasetStats, indent2 = "  ") {
     return [];
   }
   const lines = [`${indent2}summary:`];
-  for (const [column, stat4] of Object.entries(datasetStats.columnStats).slice(
+  for (const [column, stat2] of Object.entries(datasetStats.columnStats).slice(
     0,
     12
   )) {
-    const topValues = stat4.top_values ? `, top_values=${Object.entries(stat4.top_values).slice(0, 3).map(([value, count]) => `${value}=${count}`).join(", ")}` : "";
-    const sample = stat4.sample_value !== void 0 ? `, sample_value=${JSON.stringify(stat4.sample_value)}` : "";
-    const execution = stat4.execution ? `, execution=${Object.entries(stat4.execution).map(([bucket, count]) => `${bucket}=${count}`).join(", ")}` : "";
+    const topValues = stat2.top_values ? `, top_values=${Object.entries(stat2.top_values).slice(0, 3).map(([value, count]) => `${value}=${count}`).join(", ")}` : "";
+    const sample = stat2.sample_value !== void 0 ? `, sample_value=${JSON.stringify(stat2.sample_value)}` : "";
+    const execution = stat2.execution ? `, execution=${Object.entries(stat2.execution).map(([bucket, count]) => `${bucket}=${count}`).join(", ")}` : "";
     lines.push(
-      `${indent2}  ${column}: non_empty=${stat4.non_empty}, unique=${stat4.unique}${topValues}${sample}${execution}`
+      `${indent2}  ${column}: non_empty=${stat2.non_empty}, unique=${stat2.unique}${topValues}${sample}${execution}`
     );
   }
   return lines;
@@ -12824,7 +11390,7 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path13.resolve)(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path10.resolve)(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -13628,7 +12194,7 @@ async function handlePlayCheck(args) {
       }
       return 0;
     } catch (error) {
-      const resolved = (0, import_node_path13.resolve)(options.target);
+      const resolved = (0, import_node_path10.resolve)(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         process.stdout.write(
@@ -13645,8 +12211,8 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = (0, import_node_path13.resolve)(options.target);
-  const sourceCode = (0, import_node_fs11.readFileSync)(absolutePlayPath, "utf-8");
+  const absolutePlayPath = (0, import_node_path10.resolve)(options.target);
+  const sourceCode = (0, import_node_fs9.readFileSync)(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -13725,12 +12291,12 @@ async function handleFileBackedRun(options) {
   }
   const client2 = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = (0, import_node_path13.resolve)(options.target.path);
+  const absolutePlayPath = (0, import_node_path10.resolve)(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => (0, import_node_fs11.readFileSync)(absolutePlayPath, "utf-8")
+    () => (0, import_node_fs9.readFileSync)(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   try {
@@ -14049,19 +12615,19 @@ async function handlePlayRun(args) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options);
     }
-    const resolved = (0, import_node_path13.resolve)(options.target.path);
+    const resolved = (0, import_node_path10.resolve)(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = (0, import_node_path13.dirname)(resolved);
-    if ((0, import_node_fs11.existsSync)(dir)) {
-      const base = (0, import_node_path13.basename)(resolved);
+    const dir = (0, import_node_path10.dirname)(resolved);
+    if ((0, import_node_fs9.existsSync)(dir)) {
+      const base = (0, import_node_path10.basename)(resolved);
       try {
-        const siblings = (0, import_node_fs11.readdirSync)(dir).filter(
+        const siblings = (0, import_node_fs9.readdirSync)(dir).filter(
           (f) => f.includes(base.replace(/\.(play\.)?ts$/, "")) || f.endsWith(".play.ts")
         );
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${(0, import_node_path13.join)(dir, s)}`);
+            console.error(`  ${(0, import_node_path10.join)(dir, s)}`);
           }
         }
       } catch {
@@ -14216,14 +12782,14 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path13.resolve)(args[++index]);
+      outPath = (0, import_node_path10.resolve)(args[++index]);
     }
   }
   const client2 = new DeeplineClient();
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
     const logs = result2.entries;
-    (0, import_node_fs11.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    (0, import_node_fs9.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
       {
         runId: result2.runId,
@@ -14348,7 +12914,7 @@ async function handleRunExport(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path13.resolve)(args[++index]);
+      outPath = (0, import_node_path10.resolve)(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -14356,7 +12922,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = (0, import_node_path13.resolve)(args[++index]);
+      metadataOutPath = (0, import_node_path10.resolve)(args[++index]);
     }
   }
   if (!outPath) {
@@ -14396,7 +12962,7 @@ async function handleRunExport(args) {
     }
   };
   if (metadataOutPath) {
-    (0, import_node_fs11.writeFileSync)(
+    (0, import_node_fs9.writeFileSync)(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -14428,10 +12994,10 @@ async function handlePlayGet(args) {
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path13.resolve)(args[++index]);
+      outPath = (0, import_node_path10.resolve)(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs11.readFileSync)((0, import_node_path13.resolve)(target), "utf-8"), (0, import_node_path13.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs9.readFileSync)((0, import_node_path10.resolve)(target), "utf-8"), (0, import_node_path10.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
   const detail = isFileTarget(target) ? await client2.getPlay(playName) : await assertCanonicalNamedPlayReference(client2, target);
   const resolvedSource = detail.play.workingRevision?.sourceCode ?? detail.play.liveRevision?.sourceCode ?? detail.play.currentRevision?.sourceCode ?? detail.play.sourceCode ?? "";
   const materializedFile = outPath ? materializeRemotePlaySource({
@@ -14874,7 +13440,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          (0, import_node_fs11.readFileSync)((0, import_node_path13.resolve)(playName), "utf-8"),
+          (0, import_node_fs9.readFileSync)((0, import_node_path10.resolve)(playName), "utf-8"),
           playName
         );
       } catch {
@@ -14955,7 +13521,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph((0, import_node_path13.resolve)(playName))
+        () => collectBundledPlayGraph((0, import_node_path10.resolve)(playName))
       );
       await traceCliSpan(
         "cli.play_publish_compile_manifests",
@@ -15075,14 +13641,15 @@ Concepts:
   Stable ctx.tools.execute({ id, tool, input }) calls are replay-safe.
   ctx.dataset adds row keys and row progress.
   Named play runs use the live revision unless --latest or --revision-id is set.
-  Running a local file does not make it live; use set-live/publish explicitly.
+  Installed npm and repo-local CLIs can run saved/prebuilt plays by name or
+  bundle local .play.ts files for development workflows.
+  Running a local file does not make it live; use publish or set-live for that.
 
 Common commands:
   deepline plays search email --json
   deepline plays describe prebuilt/person-linkedin-to-email --json
-  deepline plays check my.play.ts
-  deepline plays run my.play.ts --input '{"domain":"stripe.com"}'
-  deepline plays set-live my.play.ts --json
+  deepline plays check prebuilt/name-and-domain-to-email-waterfall-batch
+  deepline plays run prebuilt/person-linkedin-to-email --input '{"linkedin_url":"..."}'
   deepline plays get prebuilt/person-linkedin-to-email --json
 `
   );
@@ -15090,14 +13657,14 @@ Common commands:
     "after",
     `
 Notes:
-  Validates a local play without storing it, promoting it, or starting a run.
-  This uses the authoritative cloud preflight path.
   For named or prebuilt plays, validates that the contract is discoverable
   without starting a run or spending Deepline credits.
+  Local .play.ts checks bundle the play, validate its artifact, and stop before
+  any cloud run is created.
 
 Examples:
-  deepline plays check my.play.ts
   deepline plays check prebuilt/name-and-domain-to-email-waterfall-batch
+  deepline plays check my-play --json
   deepline plays check my.play.ts --json
 `
   ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
@@ -15106,11 +13673,10 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  play.command("run [target]").description("Run a play file or named play.").allowUnknownOption(true).allowExcessArguments(true).addHelpText(
+  play.command("run [target]").description("Run a named/prebuilt play or local play file.").allowUnknownOption(true).allowExcessArguments(true).addHelpText(
     "after",
     `
 Notes:
-  Local files are bundled, preflighted, then run in Deepline cloud.
   Named plays run the live saved revision.
   Unknown --foo value and --foo.bar value flags are passed into play input.
   Example: --limit 5 becomes input.limit = 5.
@@ -15150,11 +13716,11 @@ Idempotent execution:
     .run({ key: 'domain' })
 
 Examples:
+  deepline plays run prebuilt/person-linkedin-to-email --input '{"linkedin_url":"..."}'
+  deepline plays run long-background-play --no-wait
   deepline plays run my.play.ts --input '{"domain":"stripe.com"}'
   deepline plays run my.play.ts --input @input.json --json
-  deepline plays run prebuilt/person-linkedin-to-email --input '{"linkedin_url":"..."}'
   deepline plays run cto-search.play.ts --limit 5
-  deepline plays run long-background-play --no-wait
   deepline runs export <run-id> --out output.csv
   deepline runs get <run-id>
 `
@@ -15347,20 +13913,21 @@ Examples:
     "after",
     `
 Notes:
-  Mutates cloud state. For a local file, this bundles, validates, saves a new
-  revision, and promotes that revision live. For a saved play, --latest or
-  --revision-id promotes an existing saved revision live.
+  Mutates cloud state. For a saved play, --latest or --revision-id promotes an
+  existing saved revision live.
+  Local .play.ts publishing bundles the file, validates it, saves a revision,
+  and promotes that revision live.
   Running a local file with plays run does not publish it.
 
 Examples:
-  deepline plays set-live my.play.ts --json
   deepline plays set-live my-play --latest --json
   deepline plays set-live my-play --revision-id <revision-id> --json
+  deepline plays set-live my.play.ts --json
   deepline plays publish my.play.ts --json
 `
   );
   addPublishHelp(
-    play.command("publish <target>").description("Bundle, validate, save, and promote a play revision live.")
+    play.command("publish <target>").description("Promote a saved play revision or publish a local play file.")
   ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
       target,
@@ -15371,7 +13938,7 @@ Examples:
   });
   addPublishHelp(
     play.command("set-live <target>").description(
-      "Promote a local file or saved revision as the live play revision."
+      "Promote a saved revision or publish a local play file."
     )
   ).option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
@@ -17243,10 +15810,10 @@ function expandAtFilePath(rawPath) {
     (_match, bareName, bracedName) => process.env[bareName ?? bracedName ?? ""] ?? ""
   );
   if (expanded === "~") {
-    return (0, import_node_os9.homedir)();
+    return (0, import_node_os7.homedir)();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return (0, import_node_path14.join)((0, import_node_os9.homedir)(), expanded.slice(2));
+    return (0, import_node_path11.join)((0, import_node_os7.homedir)(), expanded.slice(2));
   }
   return expanded;
 }
@@ -17259,7 +15826,7 @@ async function readAtFileReference(value, argumentName, strip = true) {
     throw new Error(`Invalid ${argumentName} value: empty @file path.`);
   }
   try {
-    const text = await (0, import_promises5.readFile)(filePath, "utf8");
+    const text = await (0, import_promises3.readFile)(filePath, "utf8");
     const normalized = text.replace(/^\uFEFF/, "");
     return strip ? normalized.trim() : normalized;
   } catch (error) {
@@ -17430,9 +15997,9 @@ async function buildPlanArgs(args) {
   return planArgs;
 }
 async function assertInputCsvExists(inputCsv) {
-  const path = (0, import_node_path14.resolve)(inputCsv);
+  const path = (0, import_node_path11.resolve)(inputCsv);
   try {
-    const info = await (0, import_promises5.stat)(path);
+    const info = await (0, import_promises3.stat)(path);
     if (info.isFile()) {
       return;
     }
@@ -17444,8 +16011,8 @@ async function assertInputCsvExists(inputCsv) {
   }
 }
 async function assertSafeOutputPath(inputCsv, outputPath) {
-  const input2 = (0, import_node_path14.resolve)(inputCsv);
-  const output2 = (0, import_node_path14.resolve)(outputPath);
+  const input2 = (0, import_node_path11.resolve)(inputCsv);
+  const output2 = (0, import_node_path11.resolve)(outputPath);
   if (input2 === output2) {
     throw new Error(
       "--input and --output must be different files when not using --in-place."
@@ -17453,8 +16020,8 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
   }
   try {
     const [inputInfo, outputInfo] = await Promise.all([
-      (0, import_promises5.stat)(input2),
-      (0, import_promises5.stat)(output2)
+      (0, import_promises3.stat)(input2),
+      (0, import_promises3.stat)(output2)
     ]);
     if (inputInfo.dev === outputInfo.dev && inputInfo.ino === outputInfo.ino) {
       throw new Error(
@@ -17474,7 +16041,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await (0, import_promises5.stat)((0, import_node_path14.resolve)(path));
+    const info = await (0, import_promises3.stat)((0, import_node_path11.resolve)(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -17485,7 +16052,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await (0, import_promises5.readFile)((0, import_node_path14.resolve)(path), "utf8");
+  const source = await (0, import_promises3.readFile)((0, import_node_path11.resolve)(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -17770,7 +16337,7 @@ async function runGeneratedEnrichPlay(runArgs, options = {}) {
       });
     } catch (error) {
       if (attempt === 0 && isPlayStartStreamEndedError(error)) {
-        await new Promise((resolve16) => setTimeout(resolve16, 250));
+        await new Promise((resolve13) => setTimeout(resolve13, 250));
         continue;
       }
       throw error;
@@ -17801,8 +16368,8 @@ async function writeOutputCsv(outputPath, status, options) {
     ]),
     options?.config
   );
-  await (0, import_promises5.writeFile)(
-    (0, import_node_path14.resolve)(outputPath),
+  await (0, import_promises3.writeFile)(
+    (0, import_node_path11.resolve)(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
   );
@@ -17812,7 +16379,7 @@ async function writeOutputCsv(outputPath, status, options) {
     selectedRows: rowsInfo.totalRows,
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
-    path: (0, import_node_path14.resolve)(outputPath),
+    path: (0, import_node_path11.resolve)(outputPath),
     enrichedDataRows: rowsInfo.rows
   };
 }
@@ -18001,12 +16568,12 @@ function firstAliasExecutionCounts(input2) {
   const aliases = collectConfigScalarAliasOrder(input2.config);
   const summaries = collectColumnStats(input2.status);
   for (const alias of aliases) {
-    const stat4 = summaries.map((summary) => summary[alias]).find(isRecord7);
-    if (!stat4) continue;
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord7);
+    if (!stat2) continue;
     if (input2.forceAliases.has(normalizeAlias2(alias))) {
       return { executed: input2.selectedRows, reused: 0 };
     }
-    const execution = isRecord7(stat4.execution) ? stat4.execution : null;
+    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
     if (!execution) continue;
     return {
       executed: parseExecutionCount(execution["completed:executed"]),
@@ -18066,11 +16633,11 @@ function rewriteEnrichJsonStatus(input2) {
     if (isRecord7(next.columnStats) && selectedRows > 0) {
       const columnStats = { ...next.columnStats };
       for (const alias of forcedAliases) {
-        const stat4 = isRecord7(columnStats[alias]) ? columnStats[alias] : null;
-        const execution = isRecord7(stat4?.execution) ? stat4.execution : null;
-        if (!stat4 || !execution) continue;
+        const stat2 = isRecord7(columnStats[alias]) ? columnStats[alias] : null;
+        const execution = isRecord7(stat2?.execution) ? stat2.execution : null;
+        if (!stat2 || !execution) continue;
         columnStats[alias] = {
-          ...stat4,
+          ...stat2,
           execution: {
             ...execution,
             "completed:executed": executionSummaryText(
@@ -18107,9 +16674,9 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0) {
     return null;
   }
-  const stateDir = (0, import_node_path14.join)((0, import_node_os9.homedir)(), ".local", "deepline", "runtime", "state");
-  await (0, import_promises5.mkdir)(stateDir, { recursive: true });
-  const reportPath = (0, import_node_path14.join)(
+  const stateDir = (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".local", "deepline", "runtime", "state");
+  await (0, import_promises3.mkdir)(stateDir, { recursive: true });
+  const reportPath = (0, import_node_path11.join)(
     stateDir,
     `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -18133,7 +16700,7 @@ async function persistEnrichFailureReport(input2) {
   if (input2.rows.rowStart !== null && input2.rows.rowEnd !== null) {
     report.rows = { start: input2.rows.rowStart, end: input2.rows.rowEnd };
   }
-  await (0, import_promises5.writeFile)(reportPath, `${JSON.stringify(report, null, 2)}
+  await (0, import_promises3.writeFile)(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   return reportPath;
 }
@@ -18546,8 +17113,8 @@ function registerEnrichCommand(program) {
       if (options.json) {
         printJson({
           dryRun: true,
-          input: (0, import_node_path14.resolve)(inputCsv),
-          output: options.output ? (0, import_node_path14.resolve)(options.output) : null,
+          input: (0, import_node_path11.resolve)(inputCsv),
+          output: options.output ? (0, import_node_path11.resolve)(options.output) : null,
           plan: summary
         });
         return;
@@ -18571,12 +17138,12 @@ function registerEnrichCommand(program) {
       forceAliases,
       playName: options.name
     });
-    const tempDir = await (0, import_promises5.mkdtemp)((0, import_node_path14.join)((0, import_node_os9.tmpdir)(), "deepline-enrich-play-"));
-    const tempPlay = (0, import_node_path14.join)(tempDir, "deepline-enrich.play.ts");
+    const tempDir = await (0, import_promises3.mkdtemp)((0, import_node_path11.join)((0, import_node_os7.tmpdir)(), "deepline-enrich-play-"));
+    const tempPlay = (0, import_node_path11.join)(tempDir, "deepline-enrich.play.ts");
     try {
-      await (0, import_promises5.writeFile)(tempPlay, playSource, "utf8");
+      await (0, import_promises3.writeFile)(tempPlay, playSource, "utf8");
       const runtimeInput = {
-        file: (0, import_node_path14.resolve)(sourceCsvPath),
+        file: (0, import_node_path11.resolve)(sourceCsvPath),
         ...rows.rowStart !== null ? { rowStart: rows.rowStart } : {},
         ...rows.rowEnd !== null ? { rowEnd: rows.rowEnd } : {}
       };
@@ -18687,7 +17254,7 @@ function registerEnrichCommand(program) {
         process.exitCode = EXIT_SERVER2;
       }
     } finally {
-      await (0, import_promises5.rm)(tempDir, { recursive: true, force: true });
+      await (0, import_promises3.rm)(tempDir, { recursive: true, force: true });
     }
   });
 }
@@ -18737,11 +17304,11 @@ Examples:
 }
 
 // src/cli/commands/sessions.ts
-var import_node_fs12 = require("fs");
-var import_node_os10 = require("os");
-var import_node_path15 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_os8 = require("os");
+var import_node_path12 = require("path");
 var import_node_zlib = require("zlib");
-var import_node_crypto4 = require("crypto");
+var import_node_crypto2 = require("crypto");
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var UUID_IN_TEXT_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 var MAX_SESSION_UPLOAD_BYTES = 35e5;
@@ -18753,41 +17320,41 @@ var MAX_EVENT_OBJECT_KEYS = 80;
 var TRUNCATION_MARKER = "...[truncated]";
 var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set(["progress", "file-history-snapshot"]);
 function homeDir() {
-  return process.env.HOME?.trim() || (0, import_node_os10.homedir)();
+  return process.env.HOME?.trim() || (0, import_node_os8.homedir)();
 }
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
   return {
-    shell: shellPath ? (0, import_node_path15.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell: shellPath ? (0, import_node_path12.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
     shell_path: shellPath || null,
-    os: (0, import_node_os10.platform)(),
+    os: (0, import_node_os8.platform)(),
     cwd: process.cwd()
   };
 }
 function claudeProjectsRoot() {
-  return (0, import_node_path15.join)(homeDir(), ".claude", "projects");
+  return (0, import_node_path12.join)(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return (0, import_node_path15.join)(homeDir(), ".codex", "sessions");
+  return (0, import_node_path12.join)(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
-  if (!(0, import_node_fs12.existsSync)(root)) return [];
+  if (!(0, import_node_fs10.existsSync)(root)) return [];
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = (0, import_node_path15.join)(root, projectDir);
+    const fullProjectDir = (0, import_node_path12.join)(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = (0, import_node_path15.join)(fullProjectDir, fileName);
+        const filePath = (0, import_node_path12.join)(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
-        const stat4 = statIfReadable(filePath);
-        if (sessionId && stat4) {
+        const stat2 = statIfReadable(filePath);
+        if (sessionId && stat2) {
           files.push({
             agent: "claude",
             sessionId,
             filePath,
-            mtimeMs: stat4.mtimeMs
+            mtimeMs: stat2.mtimeMs
           });
         }
       }
@@ -18797,14 +17364,14 @@ function listClaudeSessionFiles() {
 }
 function listCodexSessionFiles() {
   const root = codexSessionsRoot();
-  if (!(0, import_node_fs12.existsSync)(root)) return [];
+  if (!(0, import_node_fs10.existsSync)(root)) return [];
   const files = [];
   for (const filePath of listJsonlFilesRecursive(root, 5)) {
-    const stat4 = statIfReadable(filePath);
-    if (!stat4) continue;
+    const stat2 = statIfReadable(filePath);
+    if (!stat2) continue;
     const sessionId = sessionIdFromCodexFilePath(filePath) ?? readCodexSessionId(filePath);
     if (!sessionId) continue;
-    files.push({ agent: "codex", sessionId, filePath, mtimeMs: stat4.mtimeMs });
+    files.push({ agent: "codex", sessionId, filePath, mtimeMs: stat2.mtimeMs });
   }
   return files;
 }
@@ -18820,7 +17387,7 @@ function listSessionFiles(agent) {
 }
 function readDirectoryNames(dir) {
   try {
-    return (0, import_node_fs12.readdirSync)(dir);
+    return (0, import_node_fs10.readdirSync)(dir);
   } catch {
     return [];
   }
@@ -18831,12 +17398,12 @@ function listJsonlFilesRecursive(root, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = (0, import_node_path15.join)(dir, entry.name);
+      const fullPath = (0, import_node_path12.join)(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -18849,7 +17416,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
 }
 function statIfReadable(filePath) {
   try {
-    return (0, import_node_fs12.statSync)(filePath);
+    return (0, import_node_fs10.statSync)(filePath);
   } catch {
     return null;
   }
@@ -18864,15 +17431,15 @@ function newestSessionFile(agent) {
   return newest;
 }
 function sessionIdFromClaudeFilePath(filePath) {
-  return (0, import_node_path15.basename)(filePath, ".jsonl");
+  return (0, import_node_path12.basename)(filePath, ".jsonl");
 }
 function sessionIdFromCodexFilePath(filePath) {
-  const match = (0, import_node_path15.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  const match = (0, import_node_path12.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
   return match?.[0] ?? null;
 }
 function readCodexSessionId(filePath) {
   try {
-    for (const line of normalizedJsonLines((0, import_node_fs12.readFileSync)(filePath)).slice(
+    for (const line of normalizedJsonLines((0, import_node_fs10.readFileSync)(filePath)).slice(
       0,
       20
     )) {
@@ -19103,7 +17670,7 @@ async function uploadPayload(path, payload) {
   return await http.post(path, payload);
 }
 async function uploadChunkedSessions(sessions, options) {
-  const uploadId = (0, import_node_crypto4.randomUUID)();
+  const uploadId = (0, import_node_crypto2.randomUUID)();
   for (const session of sessions) {
     const bytes = Buffer.from(session.encodedContent, "base64");
     const chunks = [];
@@ -19149,25 +17716,25 @@ async function uploadChunkedSessions(sessions, options) {
 }
 async function handleSessionsSend(options) {
   if (options.file) {
-    const filePath = (0, import_node_path15.resolve)(options.file);
-    if (!(0, import_node_fs12.existsSync)(filePath)) {
+    const filePath = (0, import_node_path12.resolve)(options.file);
+    if (!(0, import_node_fs10.existsSync)(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
-      file: (0, import_node_fs12.readFileSync)(filePath).toString("base64"),
-      filename: (0, import_node_path15.basename)(filePath)
+      file: (0, import_node_fs10.readFileSync)(filePath).toString("base64"),
+      filename: (0, import_node_path12.basename)(filePath)
     });
     printCommandEnvelope(
       {
         ...response2,
         ok: true,
-        filename: (0, import_node_path15.basename)(filePath),
+        filename: (0, import_node_path12.basename)(filePath),
         render: {
           sections: [
             {
               title: "sessions send",
               lines: [
-                `File '${(0, import_node_path15.basename)(filePath)}' uploaded to #internal-reports.`
+                `File '${(0, import_node_path12.basename)(filePath)}' uploaded to #internal-reports.`
               ]
             }
           ]
@@ -19184,7 +17751,7 @@ async function handleSessionsSend(options) {
     agent: options.agent
   });
   const built = targets.map((target) => {
-    const upload = buildSessionUploadContent((0, import_node_fs12.readFileSync)(target.filePath));
+    const upload = buildSessionUploadContent((0, import_node_fs10.readFileSync)(target.filePath));
     return { ...target, ...upload };
   });
   if (built.some((session) => session.needsChunking)) {
@@ -19248,28 +17815,28 @@ function fallbackViewerAssets() {
   };
 }
 function loadViewerAssets() {
-  const cliEntry = process.argv[1]?.trim() ? (0, import_node_path15.resolve)(process.argv[1]) : null;
+  const cliEntry = process.argv[1]?.trim() ? (0, import_node_path12.resolve)(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      (0, import_node_path15.join)((0, import_node_path15.dirname)((0, import_node_path15.dirname)(cliEntry)), "viewer"),
-      (0, import_node_path15.join)(
-        (0, import_node_path15.dirname)((0, import_node_path15.dirname)((0, import_node_path15.dirname)(cliEntry))),
+      (0, import_node_path12.join)((0, import_node_path12.dirname)((0, import_node_path12.dirname)(cliEntry)), "viewer"),
+      (0, import_node_path12.join)(
+        (0, import_node_path12.dirname)((0, import_node_path12.dirname)((0, import_node_path12.dirname)(cliEntry))),
         "src",
         "lib",
         "cli",
         "viewer"
       )
     ] : [],
-    (0, import_node_path15.join)(process.cwd(), "src", "lib", "cli", "viewer")
+    (0, import_node_path12.join)(process.cwd(), "src", "lib", "cli", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = (0, import_node_path15.join)(root, "viewer.css");
-      const jsPath = (0, import_node_path15.join)(root, "viewer.js");
-      if (!(0, import_node_fs12.existsSync)(cssPath) || !(0, import_node_fs12.existsSync)(jsPath)) continue;
+      const cssPath = (0, import_node_path12.join)(root, "viewer.css");
+      const jsPath = (0, import_node_path12.join)(root, "viewer.js");
+      if (!(0, import_node_fs10.existsSync)(cssPath) || !(0, import_node_fs10.existsSync)(jsPath)) continue;
       return {
-        css: (0, import_node_fs12.readFileSync)(cssPath, "utf8"),
-        js: (0, import_node_fs12.readFileSync)(jsPath, "utf8")
+        css: (0, import_node_fs10.readFileSync)(cssPath, "utf8"),
+        js: (0, import_node_fs10.readFileSync)(jsPath, "utf8")
       };
     } catch {
       continue;
@@ -19293,21 +17860,21 @@ async function handleSessionsRender(options) {
     currentSession: options.currentSession,
     agent: options.agent
   });
-  let outputPath = options.output ? (0, import_node_path15.resolve)(options.output) : "";
+  let outputPath = options.output ? (0, import_node_path12.resolve)(options.output) : "";
   if (!outputPath) {
-    const outputDir = (0, import_node_path15.join)(process.cwd(), "deepline", "data");
-    (0, import_node_fs12.mkdirSync)(outputDir, { recursive: true });
-    outputPath = (0, import_node_path15.join)(
+    const outputDir = (0, import_node_path12.join)(process.cwd(), "deepline", "data");
+    (0, import_node_fs10.mkdirSync)(outputDir, { recursive: true });
+    outputPath = (0, import_node_path12.join)(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    (0, import_node_fs12.mkdirSync)((0, import_node_path15.dirname)(outputPath), { recursive: true });
+    (0, import_node_fs10.mkdirSync)((0, import_node_path12.dirname)(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
     events: parsePreparedEvents(
-      prepareSessionBuffer((0, import_node_fs12.readFileSync)(target.filePath))
+      prepareSessionBuffer((0, import_node_fs10.readFileSync)(target.filePath))
     )
   }));
   const { css, js } = loadViewerAssets();
@@ -19330,7 +17897,7 @@ ${refreshMeta}
 <script>${js}</script>
 </body>
 </html>`;
-  (0, import_node_fs12.writeFileSync)(outputPath, html, "utf8");
+  (0, import_node_fs10.writeFileSync)(outputPath, html, "utf8");
   printCommandEnvelope(
     {
       ok: true,
@@ -19748,7 +18315,7 @@ Examples:
 
 // src/cli/commands/quickstart.ts
 var import_node_child_process = require("child_process");
-var import_node_crypto5 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_node_http = require("http");
 var EXIT_OK2 = 0;
 var EXIT_AUTH2 = 1;
@@ -19770,17 +18337,17 @@ function hasClaudeBinary() {
   }
 }
 function launchClaude(prompt) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve13) => {
     const child = (0, import_node_child_process.spawn)("claude", [prompt], {
       stdio: "inherit",
       shell: process.platform === "win32"
     });
-    child.on("error", () => resolve16(EXIT_SERVER3));
-    child.on("close", (status) => resolve16(status ?? EXIT_OK2));
+    child.on("error", () => resolve13(EXIT_SERVER3));
+    child.on("close", (status) => resolve13(status ?? EXIT_OK2));
   });
 }
 function readBody(req) {
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve13, reject) => {
     let raw = "";
     req.setEncoding("utf8");
     req.on("data", (chunk) => {
@@ -19790,7 +18357,7 @@ function readBody(req) {
         req.destroy();
       }
     });
-    req.on("end", () => resolve16(raw));
+    req.on("end", () => resolve13(raw));
     req.on("error", reject);
   });
 }
@@ -19845,7 +18412,7 @@ function startCallbackServer(input2) {
       writeJson(res, 400, { error: "Invalid request body." });
     });
   });
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve13, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const address = server.address();
@@ -19853,7 +18420,7 @@ function startCallbackServer(input2) {
         reject(new Error("Failed to bind quickstart callback server."));
         return;
       }
-      resolve16({ server, port: address.port });
+      resolve13({ server, port: address.port });
     });
   });
 }
@@ -19877,10 +18444,10 @@ async function handleQuickstart(options) {
       return EXIT_AUTH2;
     }
   }
-  const state = (0, import_node_crypto5.randomBytes)(32).toString("hex");
+  const state = (0, import_node_crypto3.randomBytes)(32).toString("hex");
   let resolveSelection;
-  const selectionPromise = new Promise((resolve16) => {
-    resolveSelection = resolve16;
+  const selectionPromise = new Promise((resolve13) => {
+    resolveSelection = resolve13;
   });
   let callback;
   try {
@@ -20014,7 +18581,7 @@ async function readHiddenLine(prompt) {
   if (typeof import_node_process.stdin.setRawMode === "function") import_node_process.stdin.setRawMode(true);
   let value = "";
   import_node_process.stdin.resume();
-  return await new Promise((resolve16, reject) => {
+  return await new Promise((resolve13, reject) => {
     let settled = false;
     const cleanup = () => {
       import_node_process.stdin.off("data", onData);
@@ -20029,7 +18596,7 @@ async function readHiddenLine(prompt) {
       settled = true;
       import_node_process.stdout.write("\n");
       cleanup();
-      resolve16(line);
+      resolve13(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -20200,9 +18767,9 @@ Examples:
 }
 
 // src/cli/commands/switch.ts
-var import_node_fs13 = require("fs");
-var import_node_os11 = require("os");
-var import_node_path16 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_os9 = require("os");
+var import_node_path13 = require("path");
 function hostSlugFromBaseUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
@@ -20222,8 +18789,8 @@ function resolveConfigScope() {
   return hostSlugFromBaseUrl(autoDetectBaseUrl());
 }
 function activeFamilyPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os11.homedir)();
-  return (0, import_node_path16.join)(
+  const home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os9.homedir)();
+  return (0, import_node_path13.join)(
     home,
     ".local",
     "deepline",
@@ -20235,15 +18802,15 @@ function activeFamilyPath() {
 function readActiveFamily() {
   const path = activeFamilyPath();
   try {
-    return (0, import_node_fs13.readFileSync)(path, "utf-8").trim() || "sdk";
+    return (0, import_node_fs11.readFileSync)(path, "utf-8").trim() || "sdk";
   } catch {
     return "sdk";
   }
 }
 function writeActiveFamily(family) {
   const path = activeFamilyPath();
-  (0, import_node_fs13.mkdirSync)((0, import_node_path16.dirname)(path), { recursive: true });
-  (0, import_node_fs13.writeFileSync)(path, `${family}
+  (0, import_node_fs11.mkdirSync)((0, import_node_path13.dirname)(path), { recursive: true });
+  (0, import_node_fs11.writeFileSync)(path, `${family}
 `, "utf-8");
   return path;
 }
@@ -20260,7 +18827,7 @@ function handleSwitch(action, options) {
         ok: true,
         active_family: activeFamily,
         active_family_path: path,
-        active_family_file_exists: (0, import_node_fs13.existsSync)(path),
+        active_family_file_exists: (0, import_node_fs11.existsSync)(path),
         render: {
           sections: [
             {
@@ -20360,14 +18927,14 @@ Examples:
 
 // src/cli/commands/tools.ts
 var import_commander2 = require("commander");
-var import_node_fs15 = require("fs");
-var import_node_os13 = require("os");
-var import_node_path18 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_os11 = require("os");
+var import_node_path15 = require("path");
 
 // src/tool-output.ts
-var import_node_fs14 = require("fs");
-var import_node_os12 = require("os");
-var import_node_path17 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_os10 = require("os");
+var import_node_path14 = require("path");
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20463,19 +19030,19 @@ function tryConvertToList(payload, options) {
   return null;
 }
 function ensureOutputDir() {
-  const outputDir = (0, import_node_path17.join)((0, import_node_os12.homedir)(), ".local", "share", "deepline", "data");
-  (0, import_node_fs14.mkdirSync)(outputDir, { recursive: true });
+  const outputDir = (0, import_node_path14.join)((0, import_node_os10.homedir)(), ".local", "share", "deepline", "data");
+  (0, import_node_fs12.mkdirSync)(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path17.join)(outputDir, `${stem}_${Date.now()}.json`);
-  (0, import_node_fs14.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  const outputPath = (0, import_node_path14.join)(outputDir, `${stem}_${Date.now()}.json`);
+  (0, import_node_fs12.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path17.join)(outputDir, `${stem}_${Date.now()}.csv`);
+  const outputPath = (0, import_node_path14.join)(outputDir, `${stem}_${Date.now()}.csv`);
   const seen = /* @__PURE__ */ new Set();
   const columns = [];
   for (const row of rows) {
@@ -20498,7 +19065,7 @@ function writeCsvOutputFile(rows, stem) {
   for (const row of rows) {
     lines.push(columns.map((column) => escapeCell(row[column])).join(","));
   }
-  (0, import_node_fs14.writeFileSync)(outputPath, `${lines.join("\n")}
+  (0, import_node_fs12.writeFileSync)(outputPath, `${lines.join("\n")}
 `, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
@@ -21552,11 +20119,11 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = (0, import_node_path18.resolve)(trimmed);
-  if ((0, import_node_fs15.existsSync)(resolved)) return resolved;
+  const resolved = (0, import_node_path15.resolve)(trimmed);
+  if ((0, import_node_fs13.existsSync)(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = (0, import_node_path18.resolve)(trimmed.replace(/\\/g, "/"));
-    if ((0, import_node_fs15.existsSync)(normalized)) return normalized;
+    const normalized = (0, import_node_path15.resolve)(trimmed.replace(/\\/g, "/"));
+    if ((0, import_node_fs13.existsSync)(normalized)) return normalized;
   }
   return resolved;
 }
@@ -21567,7 +20134,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return (0, import_node_fs15.readFileSync)(resolveAtFilePath(filePath), "utf8").replace(
+    return (0, import_node_fs13.readFileSync)(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -21669,9 +20236,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = (0, import_node_fs15.mkdtempSync)((0, import_node_path18.join)((0, import_node_os13.tmpdir)(), "deepline-workflow-seed-"));
-  (0, import_node_fs15.chmodSync)(scriptDir, 448);
-  const scriptPath = (0, import_node_path18.join)(scriptDir, fileName);
+  const scriptDir = (0, import_node_fs13.mkdtempSync)((0, import_node_path15.join)((0, import_node_os11.tmpdir)(), "deepline-workflow-seed-"));
+  (0, import_node_fs13.chmodSync)(scriptDir, 448);
+  const scriptPath = (0, import_node_path15.join)(scriptDir, fileName);
   const projectDir = `deepline/projects/${stem}-workflow`;
   const playName = `${stem}-workflow`;
   const sampleRows = input2.rows.length > 0 ? `${JSON.stringify(input2.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
@@ -21707,7 +20274,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   };
 });
 `;
-  (0, import_node_fs15.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  (0, import_node_fs13.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -21971,11 +20538,48 @@ async function executeTool(args) {
 }
 
 // src/cli/commands/workflow.ts
-var import_promises6 = require("fs/promises");
-var import_node_path19 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_path16 = require("path");
+
+// src/cli/workflow-to-play.ts
+var import_node_crypto4 = require("crypto");
+
+// ../shared_libs/plays/secret-guardrails.ts
+var SECRET_ENV_PATTERN = /\bprocess(?:\.env|\[['"]env['"]\])(?:\.|\[['"])([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PRIVATE[_-]?KEY|ACCESS[_-]?KEY)[A-Z0-9_]*)(?:['"]\])?/g;
+var PRIVATE_KEY_PATTERN = /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/;
+var BEARER_LITERAL_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/i;
+var ASSIGNMENT_SECRET_LITERAL_PATTERN = /\b(?:api[_-]?key|token|secret|password)\b\s*[:=]\s*['"][^'"]{12,}['"]/i;
+var HIGH_ENTROPY_LITERAL_PATTERN = /['"]([A-Za-z0-9+/=_-]{32,})['"]/g;
+function shannonEntropy(value) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);
+  return [...counts.values()].reduce((entropy, count) => {
+    const p = count / value.length;
+    return entropy - p * Math.log2(p);
+  }, 0);
+}
+function collectInlineSecretFindings(sourceCode) {
+  const findings = [];
+  for (const match of sourceCode.matchAll(SECRET_ENV_PATTERN)) {
+    findings.push(`process.env.${match[1]}`);
+  }
+  if (PRIVATE_KEY_PATTERN.test(sourceCode)) findings.push("private key block");
+  if (BEARER_LITERAL_PATTERN.test(sourceCode))
+    findings.push("bearer token literal");
+  if (ASSIGNMENT_SECRET_LITERAL_PATTERN.test(sourceCode)) {
+    findings.push("secret-looking assignment literal");
+  }
+  for (const match of sourceCode.matchAll(HIGH_ENTROPY_LITERAL_PATTERN)) {
+    const literal = match[1] ?? "";
+    if (literal.length >= 40 && shannonEntropy(literal) >= 4.2) {
+      findings.push("high-entropy string literal");
+      break;
+    }
+  }
+  return [...new Set(findings)];
+}
 
 // src/cli/workflow-to-play.ts
-var import_node_crypto6 = require("crypto");
 var HITL_WAIT_FOR_SIGNAL_TOOL = "deepline_workflow_wait_for_signal";
 var HITL_SLACK_TOOL = "slack_message_with_hitl";
 var SUB_WORKFLOW_TOOL_PREFIX = "deepline_workflow_";
@@ -22081,7 +20685,7 @@ function sanitizePlayNameSegment(value) {
 }
 function deriveWorkflowPlayName(workflowName) {
   const base = sanitizePlayNameSegment(workflowName) || "workflow";
-  const suffix = (0, import_node_crypto6.createHash)("sha256").update(workflowName).digest("hex").slice(0, 8);
+  const suffix = (0, import_node_crypto4.createHash)("sha256").update(workflowName).digest("hex").slice(0, 8);
   const reserved = suffix.length + 1;
   const allowedBase = Math.max(1, MAX_PLAY_NAME_LENGTH - reserved);
   let name = `${base.slice(0, allowedBase)}_${suffix}`;
@@ -22179,7 +20783,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await (0, import_promises6.readFile)((0, import_node_path19.resolve)(file), "utf8");
+    const raw = await (0, import_promises4.readFile)((0, import_node_path16.resolve)(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -22213,9 +20817,9 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = (0, import_node_path19.join)((0, import_node_path19.resolve)(outDir), `${compiled.playName}.play.ts`);
-    await (0, import_promises6.mkdir)((0, import_node_path19.dirname)(file), { recursive: true });
-    await (0, import_promises6.writeFile)(file, compiled.sourceCode, "utf8");
+    const file = (0, import_node_path16.join)((0, import_node_path16.resolve)(outDir), `${compiled.playName}.play.ts`);
+    await (0, import_promises4.mkdir)((0, import_node_path16.dirname)(file), { recursive: true });
+    await (0, import_promises4.writeFile)(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
       const code = await handlePlayPublish([file]);
@@ -22461,9 +21065,9 @@ Notes:
 
 // src/cli/commands/update.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs16 = require("fs");
-var import_node_os14 = require("os");
-var import_node_path20 = require("path");
+var import_node_fs14 = require("fs");
+var import_node_os12 = require("os");
+var import_node_path17 = require("path");
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -22486,11 +21090,11 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return (0, import_node_path20.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return (0, import_node_path17.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function readOptionalText(path) {
   try {
-    return (0, import_node_fs16.readFileSync)(path, "utf8").trim();
+    return (0, import_node_fs14.readFileSync)(path, "utf8").trim();
   } catch {
     return "";
   }
@@ -22498,26 +21102,26 @@ function readOptionalText(path) {
 function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
-  const relativeEntrypoint = (0, import_node_path20.relative)(
-    (0, import_node_path20.resolve)(stateDir),
-    (0, import_node_path20.resolve)(options.entrypoint)
+  const relativeEntrypoint = (0, import_node_path17.relative)(
+    (0, import_node_path17.resolve)(stateDir),
+    (0, import_node_path17.resolve)(options.entrypoint)
   );
-  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path20.isAbsolute)(relativeEntrypoint)) {
+  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path17.isAbsolute)(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText((0, import_node_path20.join)(stateDir, ".install-method"));
+  const installMethod = readOptionalText((0, import_node_path17.join)(stateDir, ".install-method"));
   if (installMethod !== "python-sidecar") return null;
   const scope = options.env.DEEPLINE_CONFIG_SCOPE?.trim() || "";
   const hostUrl = options.env.DEEPLINE_HOST_URL?.trim() || "";
-  const nodeBin = readOptionalText((0, import_node_path20.join)(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText((0, import_node_path20.join)(stateDir, ".command-path")) || (0, import_node_path20.join)(
+  const nodeBin = readOptionalText((0, import_node_path17.join)(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText((0, import_node_path17.join)(stateDir, ".command-path")) || (0, import_node_path17.join)(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
   );
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
-  const manualCommand = `${npmCommand} install --prefix ${shellQuote3((0, import_node_path20.join)(stateDir, "versions", "<version>"))} --no-audit --no-fund ${shellQuote3(packageSpec)}`;
+  const manualCommand = `${npmCommand} install --prefix ${shellQuote3((0, import_node_path17.join)(stateDir, "versions", "<version>"))} --no-audit --no-fund ${shellQuote3(packageSpec)}`;
   return {
     kind: "python-sidecar",
     stateDir,
@@ -22531,21 +21135,21 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = (0, import_node_path20.resolve)(startPath);
+  let current = (0, import_node_path17.resolve)(startPath);
   while (true) {
-    if ((0, import_node_fs16.existsSync)((0, import_node_path20.join)(current, "sdk", "package.json")) && (0, import_node_fs16.existsSync)((0, import_node_path20.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if ((0, import_node_fs14.existsSync)((0, import_node_path17.join)(current, "sdk", "package.json")) && (0, import_node_fs14.existsSync)((0, import_node_path17.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = (0, import_node_path20.dirname)(current);
+    const parent = (0, import_node_path17.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir2 = options.homeDir ?? (0, import_node_os14.homedir)();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path20.resolve)(process.argv[1]) : "");
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path20.dirname)(entrypoint)) : null;
+  const homeDir2 = options.homeDir ?? (0, import_node_os12.homedir)();
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path17.resolve)(process.argv[1]) : "");
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path17.dirname)(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -22575,7 +21179,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return (0, import_node_path20.join)(
+  return (0, import_node_path17.join)(
     versionDir,
     "node_modules",
     "deepline",
@@ -22585,14 +21189,14 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = (0, import_node_path20.join)(
+  const packageJsonPath = (0, import_node_path17.join)(
     versionDir,
     "node_modules",
     "deepline",
     "package.json"
   );
   try {
-    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(packageJsonPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" ? safeVersionSegment(parsed.version) : "";
   } catch {
     return "";
@@ -22616,9 +21220,9 @@ function runCommand(command, args, env = process.env) {
   });
 }
 function writeSidecarLauncher(input2) {
-  (0, import_node_fs16.mkdirSync)((0, import_node_path20.dirname)(input2.path), { recursive: true });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path17.dirname)(input2.path), { recursive: true });
   if (process.platform === "win32") {
-    (0, import_node_fs16.writeFileSync)(
+    (0, import_node_fs14.writeFileSync)(
       input2.path,
       [
         `@set DEEPLINE_HOST_URL=${input2.hostUrl.replace(/\r?\n/g, "")}`,
@@ -22630,7 +21234,7 @@ function writeSidecarLauncher(input2) {
     );
     return;
   }
-  (0, import_node_fs16.writeFileSync)(
+  (0, import_node_fs14.writeFileSync)(
     input2.path,
     [
       "#!/usr/bin/env sh",
@@ -22643,17 +21247,17 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan) {
-  const versionsDir = (0, import_node_path20.join)(plan.stateDir, "versions");
-  const tempDir = (0, import_node_path20.join)(
+  const versionsDir = (0, import_node_path17.join)(plan.stateDir, "versions");
+  const tempDir = (0, import_node_path17.join)(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
-  (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
-  (0, import_node_fs16.mkdirSync)(tempDir, { recursive: true });
-  (0, import_node_fs16.writeFileSync)((0, import_node_path20.join)(tempDir, "package.json"), '{"private":true}\n', "utf8");
+  (0, import_node_fs14.rmSync)(tempDir, { recursive: true, force: true });
+  (0, import_node_fs14.mkdirSync)(tempDir, { recursive: true });
+  (0, import_node_fs14.writeFileSync)((0, import_node_path17.join)(tempDir, "package.json"), '{"private":true}\n', "utf8");
   const env = {
     ...process.env,
-    PATH: `${(0, import_node_path20.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
+    PATH: `${(0, import_node_path17.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
   };
   const installExitCode = await runCommand(
     plan.npmCommand,
@@ -22668,7 +21272,7 @@ async function runPythonSidecarUpdatePlan(plan) {
     env
   );
   if (installExitCode !== 0) {
-    (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs14.rmSync)(tempDir, { recursive: true, force: true });
     return installExitCode;
   }
   const installedVersion = installedPackageVersion(tempDir);
@@ -22676,19 +21280,19 @@ async function runPythonSidecarUpdatePlan(plan) {
     process.stderr.write(
       "Updated Deepline SDK package did not report a version.\n"
     );
-    (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs14.rmSync)(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = (0, import_node_path20.join)(versionsDir, installedVersion);
+  const finalDir = (0, import_node_path17.join)(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
-  if ((0, import_node_fs16.existsSync)(finalEntryPath)) {
-    (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
+  if ((0, import_node_fs14.existsSync)(finalEntryPath)) {
+    (0, import_node_fs14.rmSync)(tempDir, { recursive: true, force: true });
   } else {
-    (0, import_node_fs16.rmSync)(finalDir, { recursive: true, force: true });
+    (0, import_node_fs14.rmSync)(finalDir, { recursive: true, force: true });
     try {
-      (0, import_node_fs16.renameSync)(tempDir, finalDir);
+      (0, import_node_fs14.renameSync)(tempDir, finalDir);
     } catch (error) {
-      (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs14.rmSync)(tempDir, { recursive: true, force: true });
       process.stderr.write(
         `Failed to publish Deepline SDK sidecar update: ${error.message}
 `
@@ -22696,7 +21300,7 @@ async function runPythonSidecarUpdatePlan(plan) {
       return 1;
     }
   }
-  if (!(0, import_node_fs16.existsSync)(finalEntryPath)) {
+  if (!(0, import_node_fs14.existsSync)(finalEntryPath)) {
     process.stderr.write(
       `Updated Deepline SDK CLI entrypoint missing: ${finalEntryPath}
 `
@@ -22710,28 +21314,28 @@ async function runPythonSidecarUpdatePlan(plan) {
     nodeBin: plan.nodeBin,
     entryPath: finalEntryPath
   });
-  (0, import_node_fs16.writeFileSync)(
-    (0, import_node_path20.join)(plan.stateDir, ".version"),
+  (0, import_node_fs14.writeFileSync)(
+    (0, import_node_path17.join)(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
-  (0, import_node_fs16.writeFileSync)(
-    (0, import_node_path20.join)(plan.stateDir, ".install-method"),
+  (0, import_node_fs14.writeFileSync)(
+    (0, import_node_path17.join)(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
-  (0, import_node_fs16.writeFileSync)(
-    (0, import_node_path20.join)(plan.stateDir, ".command-path"),
+  (0, import_node_fs14.writeFileSync)(
+    (0, import_node_path17.join)(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  (0, import_node_fs16.writeFileSync)((0, import_node_path20.join)(plan.stateDir, ".runner"), "node\n", "utf8");
-  (0, import_node_fs16.writeFileSync)((0, import_node_path20.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  (0, import_node_fs14.writeFileSync)((0, import_node_path17.join)(plan.stateDir, ".runner"), "node\n", "utf8");
+  (0, import_node_fs14.writeFileSync)((0, import_node_path17.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
-  (0, import_node_fs16.writeFileSync)(
-    (0, import_node_path20.join)(plan.stateDir, ".entry-path"),
+  (0, import_node_fs14.writeFileSync)(
+    (0, import_node_path17.join)(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -23018,7 +21622,7 @@ function shouldSkipSelfUpdate() {
   return envTruthy("DEEPLINE_SKIP_SELF_UPDATE") || envTruthy("DEEPLINE_NO_AUTO_UPDATE") || envTruthy("DEEPLINE_SKIP_SDK_AUTO_UPDATE") || envTruthy("DEEPLINE_DISABLE_AUTO_UPDATE") || isCi();
 }
 function relaunchCurrentCommand(plan) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve13) => {
     const command = plan.kind === "python-sidecar" ? plan.sidecarPath : process.execPath;
     const args = plan.kind === "python-sidecar" ? process.argv.slice(2) : process.argv.slice(1);
     const child = (0, import_node_child_process3.spawn)(command, args, {
@@ -23034,9 +21638,9 @@ function relaunchCurrentCommand(plan) {
         `Deepline SDK/CLI updated, but relaunch failed: ${error.message}
 `
       );
-      resolve16(1);
+      resolve13(1);
     });
-    child.on("close", (code) => resolve16(code ?? 1));
+    child.on("close", (code) => resolve13(code ?? 1));
   });
 }
 async function maybeAutoUpdateAndRelaunch(response) {
@@ -23075,9 +21679,9 @@ async function maybeAutoUpdateAndRelaunch(response) {
 
 // src/cli/skills-sync.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs17 = require("fs");
-var import_node_os15 = require("os");
-var import_node_path21 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_os13 = require("os");
+var import_node_path18 = require("path");
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_PLAY_SKILL_NAME = "deepline-plays";
 var attemptedSync = false;
@@ -23091,20 +21695,20 @@ function activePluginSkillsDir() {
     return "";
   }
   const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && (0, import_node_fs17.existsSync)(dir) ? dir : "";
+  return dir && (0, import_node_fs15.existsSync)(dir) ? dir : "";
 }
 function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return (0, import_node_fs17.readFileSync)((0, import_node_path21.join)(dir, ".version"), "utf-8").trim();
+    return (0, import_node_fs15.readFileSync)((0, import_node_path18.join)(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
-  const home = process.env.HOME?.trim() || (0, import_node_os15.homedir)();
-  return (0, import_node_path21.join)(
+  const home = process.env.HOME?.trim() || (0, import_node_os13.homedir)();
+  return (0, import_node_path18.join)(
     home,
     ".local",
     "deepline",
@@ -23117,17 +21721,17 @@ function readLocalSkillsVersion(baseUrl) {
   const pluginVersion = readPluginSkillsVersion();
   if (pluginVersion) return pluginVersion;
   const path = sdkSkillsVersionPath(baseUrl);
-  if (!(0, import_node_fs17.existsSync)(path)) return "";
+  if (!(0, import_node_fs15.existsSync)(path)) return "";
   try {
-    return (0, import_node_fs17.readFileSync)(path, "utf-8").trim();
+    return (0, import_node_fs15.readFileSync)(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  (0, import_node_fs17.mkdirSync)((0, import_node_path21.dirname)(path), { recursive: true });
-  (0, import_node_fs17.writeFileSync)(path, `${version}
+  (0, import_node_fs15.mkdirSync)((0, import_node_path18.dirname)(path), { recursive: true });
+  (0, import_node_fs15.writeFileSync)(path, `${version}
 `, "utf-8");
 }
 function sortedUniqueSkillNames(names) {
@@ -23225,7 +21829,7 @@ function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NA
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve13) => {
     const child = (0, import_node_child_process4.spawn)(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
@@ -23235,7 +21839,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve16({
+      resolve13({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -23243,11 +21847,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve16({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve13({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve16({
+      resolve13({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -23306,7 +21910,7 @@ async function syncSdkSkillsIfNeeded(baseUrl) {
 }
 
 // src/cli/failure-reporting.ts
-var import_node_os16 = require("os");
+var import_node_os14 = require("os");
 var FAILURE_REPORT_DISABLE_ENV = "DEEPLINE_DISABLE_FAILURE_REPORTING";
 var REPORT_FAILURE_TIMEOUT_MS = 1e4;
 var MAX_FAILURE_TEXT_CHARS = 4e3;
@@ -23408,12 +22012,12 @@ function isNetworkFailure(error) {
 }
 function buildEnvironmentContext() {
   const context = {
-    os: (0, import_node_os16.platform)(),
-    os_release: (0, import_node_os16.release)(),
-    platform: `${(0, import_node_os16.platform)()}-${(0, import_node_os16.release)()}-${process.arch}`,
+    os: (0, import_node_os14.platform)(),
+    os_release: (0, import_node_os14.release)(),
+    platform: `${(0, import_node_os14.platform)()}-${(0, import_node_os14.release)()}-${process.arch}`,
     node_version: process.version,
     runtime: "Node.js",
-    hostname: (0, import_node_os16.hostname)(),
+    hostname: (0, import_node_os14.hostname)(),
     agent_runtime: detectAgentRuntime()
   };
   for (const key of ["CLAUDE_CODE_REMOTE", "DEEPLINE_PLUGIN_MODE"]) {
@@ -23593,10 +22197,10 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await (0, import_promises7.mkdtemp)((0, import_node_path22.join)((0, import_node_os17.tmpdir)(), "deepline-health-play-"));
-  const file = (0, import_node_path22.join)(dir, "health-check.play.ts");
+  const dir = await (0, import_promises5.mkdtemp)((0, import_node_path19.join)((0, import_node_os15.tmpdir)(), "deepline-health-play-"));
+  const file = (0, import_node_path19.join)(dir, "health-check.play.ts");
   try {
-    await (0, import_promises7.writeFile)(
+    await (0, import_promises5.writeFile)(
       file,
       [
         "import { definePlay } from 'deepline';",
@@ -23644,7 +22248,7 @@ async function runPlayRunnerHealthCheck() {
       }
     };
   } finally {
-    await (0, import_promises7.rm)(dir, { recursive: true, force: true });
+    await (0, import_promises5.rm)(dir, { recursive: true, force: true });
   }
 }
 function pickString(value, ...keys) {