deepline 0.1.119 → 0.1.121

package/dist/cli/index.mjs

@@ -158,9 +158,9 @@ function configureProxyFromEnv() {
 configureProxyFromEnv();
 
 // src/cli/index.ts
-import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import { join as join17 } from "path";
-import { tmpdir as tmpdir5 } from "os";
+import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import { join as join14 } from "path";
+import { tmpdir as tmpdir3 } from "os";
 import { Command as Command3 } from "commander";
 
 // src/config.ts
@@ -380,10 +380,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: [
@@ -896,7 +896,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)) {
@@ -1653,14 +1653,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) {
@@ -1760,7 +1760,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") {
@@ -2877,20 +2877,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
@@ -2906,7 +2991,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)) {
@@ -4210,7 +4296,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) {
@@ -4245,10 +4331,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(`
@@ -6162,38 +6246,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,
@@ -6679,1938 +6763,123 @@ Examples:
 
 // src/cli/commands/enrich.ts
 import {
-  mkdir as mkdir4,
+  mkdir as mkdir3,
   mkdtemp,
-  readFile as readFile3,
+  readFile,
   rm,
-  stat as stat3,
-  writeFile as writeFile4
+  stat,
+  writeFile as writeFile3
 } from "fs/promises";
-import { homedir as homedir6, tmpdir as tmpdir3 } from "os";
-import { join as join9, resolve as resolve11 } from "path";
+import { homedir as homedir6, tmpdir } from "os";
+import { join as join6, resolve as resolve8 } from "path";
 
 // src/cli/commands/play.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash } from "crypto";
 import {
-  existsSync as existsSync8,
-  readFileSync as readFileSync7,
+  existsSync as existsSync6,
+  readFileSync as readFileSync6,
   readdirSync,
   realpathSync,
   statSync as statSync2,
   writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename3, dirname as dirname9, join as join8, resolve as resolve10 } from "path";
+import { basename, dirname as dirname6, join as join5, resolve as resolve7 } from "path";
 import { parse as parseCsvSync2 } from "csv-parse/sync";
 
-// src/plays/bundle-play-file.ts
-import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname8, join as join7, resolve as resolve8 } from "path";
-import { fileURLToPath } from "url";
-import { existsSync as existsSync7 } from "fs";
-
-// ../shared_libs/plays/bundling/index.ts
-import { createHash } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
-import { mkdir as mkdir3, readFile, realpath, stat, writeFile as writeFile3 } from "fs/promises";
-import { tmpdir } from "os";
-import {
-  basename,
-  dirname as dirname6,
-  extname,
-  isAbsolute,
-  join as join5,
-  relative,
-  resolve as resolve6
-} from "path";
-import { builtinModules } from "module";
-import { build } from "esbuild";
+// src/cli/commands/plays/bootstrap.ts
+import { closeSync, openSync, readSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { isAbsolute, relative, resolve as resolve6 } from "path";
+import { parse as parseCsvSync } from "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 = join5(
-  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(
-  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 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 realpath(filePath);
-  } catch {
-    return resolve6(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: dirname6(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.`
-    );
+};
+var PlayBootstrapValidationError = class extends PlayBootstrapError {
+  constructor(message) {
+    super(message, 7);
   }
-  return references.sort(
-    (left, right) => left.line === right.line ? left.column - right.column : left.line - right.line
-  );
+};
+var CSV_HEADER_SAMPLE_BYTES = 64 * 1024;
+function parseCsvList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
-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 parseProviderList(value, flag) {
+  const providers = parseCsvList(value);
+  if (providers.length === 0) {
+    throw new PlayBootstrapUsageError(`${flag} provider list cannot be empty.`);
   }
-}
-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 = relative(dirname6(input2.entryFile), input2.filePath);
-  if (entryRelative && !entryRelative.startsWith("..")) {
-    return entryRelative.replaceAll("\\", "/");
-  }
-  return `<project>/${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(readFileSync6(packageJsonPath, "utf-8"));
-    if (packageJson.name === packageName && typeof packageJson.version === "string") {
-      return packageJson.version;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-function findPackageJsonPathFrom(startDir, packageName) {
-  if (!isAbsolute(startDir)) {
-    throw new Error(
-      `Package resolution requires an absolute start directory, got ${startDir}`
-    );
-  }
-  let current = startDir;
-  while (true) {
-    const packageJsonPath = join5(
-      current,
-      "node_modules",
-      packageName,
-      "package.json"
-    );
-    if (existsSync6(packageJsonPath)) {
-      return packageJsonPath;
-    }
-    const parent = dirname6(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function findPackageJsonPath(packageName, fromFile, adapter) {
-  const startDirs = [
-    resolve6(dirname6(fromFile)),
-    resolve6(adapter.projectRoot),
-    resolve6(dirname6(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 = join5(
-    adapter.nodeModulesDir,
-    packageName,
-    "package.json"
-  );
-  return existsSync6(adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
-}
-function localSdkAliasPlugin(adapter, options) {
-  const entryFile = options?.workersRuntime ? adapter.sdkWorkersEntryFile : adapter.sdkEntryFile;
-  if (!existsSync6(entryFile)) {
-    return null;
-  }
-  return {
-    name: "deepline-sdk-local-alias",
-    setup(buildContext) {
-      buildContext.onResolve({ filter: /^deepline$/ }, () => ({
-        path: entryFile
-      }));
-      buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
-        path: join5(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: dirname6(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: dirname6(args.path)
-          };
-        }
-      );
-    }
-  };
-}
-async function fileExists(filePath) {
-  try {
-    await stat(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolveLocalImport(fromFile, specifier) {
-  if (specifier.startsWith("file:")) {
-    return normalizeLocalPath(new URL(specifier).pathname);
-  }
-  const base = isAbsolute(specifier) ? resolve6(specifier) : resolve6(dirname6(fromFile), specifier);
-  const candidates = [base];
-  const explicitExtension = extname(base).toLowerCase();
-  if (!explicitExtension) {
-    candidates.push(
-      ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
-    );
-    candidates.push(
-      ...SOURCE_EXTENSIONS.map((extension) => join5(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" && existsSync6(adapter.sdkPackageJson)) {
-    const packageJson = JSON.parse(
-      readFileSync6(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 readFile(absolutePath, "utf-8");
-    localFiles.set(absolutePath, sourceCode2);
-    if (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 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 readFile(filePath, "utf-8");
-    parts2.push({
-      name: `${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, join5(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(join5(rootDir, entry.name));
-      }
-      if (entry.isDirectory()) {
-        const batchingFile = join5(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,
-      join5(adapter.workersHarnessFilesDir, name)
-    );
-  }
-  for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
-    if (basename(dir) === "integrations") {
-      await collectIntegrationBatchingFiles(dir, parts);
-    } else {
-      await collectTopLevelTsFiles(dir, parts);
-    }
-  }
-  return sha256(JSON.stringify(parts));
-}
-function artifactCachePath(graphHash, artifactKind, adapter) {
-  return join5(
-    adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR,
-    `${graphHash}.${artifactKind}.json`
-  );
-}
-async function readArtifactCache(graphHash, artifactKind, adapter) {
-  try {
-    const serialized = await 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 mkdir3(cacheDir, { recursive: true });
-  await writeFile3(
-    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 join5(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 build({
-    ...namedExportShim ? {
-      stdin: {
-        contents: namedExportShim,
-        resolveDir: dirname6(entryFile),
-        sourcefile: `${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 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,
-      resolve6(adapter.projectRoot)
-    );
-    const virtualBaseName = exportName === "default" ? basename(absolutePath).replace(/\.[^.]+$/, "") : `${basename(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
-    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
-    const executableCode = `${bundledCode}
-//# sourceMappingURL=${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
-import { createHash as createHash2 } from "crypto";
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import {
-  basename as basename2,
-  dirname as dirname7,
-  extname as extname2,
-  isAbsolute as isAbsolute2,
-  join as join6,
-  relative as relative2,
-  resolve as resolve7
-} from "path";
-var SOURCE_EXTENSIONS2 = [
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".json"
-];
-function sha2562(buffer) {
-  return createHash2("sha256").update(buffer).digest("hex");
-}
-function contentTypeForFile(filePath) {
-  const extension = extname2(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 stat2(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isPathInsideDirectory2(filePath, directory) {
-  const relativePath = relative2(directory, filePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute2(relativePath);
-}
-async function resolveLocalImport2(fromFile, specifier) {
-  const base = isAbsolute2(specifier) ? resolve7(specifier) : resolve7(dirname7(fromFile), specifier);
-  const candidates = [base];
-  const explicitExtension = extname2(base).toLowerCase();
-  if (!explicitExtension) {
-    candidates.push(
-      ...SOURCE_EXTENSIONS2.map((extension) => `${base}${extension}`)
-    );
-    candidates.push(
-      ...SOURCE_EXTENSIONS2.map((extension) => join6(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 = resolve7(entryFile);
-  const packagingRoot = dirname7(absoluteEntryFile);
-  const files = /* @__PURE__ */ new Map();
-  const unresolved = [];
-  const visitedFiles = /* @__PURE__ */ new Set();
-  const visitSourceFile = async (filePath) => {
-    const absolutePath = resolve7(filePath);
-    if (visitedFiles.has(absolutePath)) {
-      return;
-    }
-    visitedFiles.add(absolutePath);
-    const sourceCode = await readFile2(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 = resolve7(dirname7(absolutePath), resolvedPath);
-          if (isAbsolute2(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 readFile2(absoluteCsvPath);
-          const stats = await stat2(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 PLAY_BUNDLE_CACHE_VERSION2 = 30;
-var MODULE_DIR = dirname8(fileURLToPath(import.meta.url));
-var SDK_PACKAGE_ROOT = resolve8(MODULE_DIR, "..", "..");
-var SOURCE_REPO_ROOT = resolve8(SDK_PACKAGE_ROOT, "..");
-var HAS_SOURCE_BUNDLING_SOURCES = existsSync7(
-  resolve8(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
-);
-var PACKAGED_REPO_ROOT = resolve8(SDK_PACKAGE_ROOT, "dist", "repo");
-var HAS_PACKAGED_BUNDLING_SOURCES = existsSync7(
-  resolve8(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 : resolve8(SDK_PACKAGE_ROOT, "..");
-var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? resolve8(SOURCE_REPO_ROOT, "sdk", "src") : HAS_PACKAGED_BUNDLING_SOURCES ? resolve8(PACKAGED_REPO_ROOT, "sdk", "src") : resolve8(SDK_PACKAGE_ROOT, "src");
-var SDK_PACKAGE_JSON = resolve8(SDK_PACKAGE_ROOT, "package.json");
-var SDK_ENTRY_FILE = resolve8(SDK_SOURCE_ROOT, "index.ts");
-var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : resolve8(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
-var SDK_WORKERS_ENTRY_FILE = resolve8(SDK_SOURCE_ROOT, "worker-play-entry.ts");
-var WORKERS_HARNESS_ENTRY_FILE = resolve8(
-  PROJECT_ROOT,
-  "apps",
-  "play-runner-workers",
-  "src",
-  "entry.ts"
-);
-var WORKERS_HARNESS_FILES_DIR = resolve8(
-  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: resolve8(PROJECT_ROOT, "node_modules"),
-    cacheDir: join7(
-      tmpdir2(),
-      `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 || !existsSync7(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: [
-      resolve8(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
-import { closeSync, openSync, readSync, statSync, writeFileSync as writeFileSync7 } from "fs";
-import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve9 } from "path";
-import { parse as parseCsvSync } from "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 CSV_HEADER_SAMPLE_BYTES = 64 * 1024;
-function parseCsvList(value) {
-  return value.split(",").map((item) => item.trim()).filter(Boolean);
-}
-function parseProviderList(value, flag) {
-  const providers = parseCsvList(value);
-  if (providers.length === 0) {
-    throw new PlayBootstrapUsageError(`${flag} provider list cannot be empty.`);
-  }
-  return providers;
+  return providers;
 }
 function parseBootstrapPrefixedRef(value, flag) {
   const separatorIndex = value.indexOf(":");
@@ -8948,7 +7217,7 @@ function inferCsvColumnSpecs(headers, rows) {
   }));
 }
 function readCsvSample(csvPath) {
-  const resolvedPath = resolve9(csvPath);
+  const resolvedPath = resolve6(csvPath);
   const size = statSync(resolvedPath).size;
   const fd = openSync(resolvedPath, "r");
   const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
@@ -9023,9 +7292,9 @@ ${properties}
 }
 function packagedCsvPathForPlay(csvPath) {
   const playDir = process.cwd();
-  const absoluteCsvPath = resolve9(csvPath);
-  const relativePath = relative3(playDir, absoluteCsvPath);
-  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute3(relativePath)) {
+  const absoluteCsvPath = resolve6(csvPath);
+  const relativePath = relative(playDir, absoluteCsvPath);
+  if (relativePath === "" || relativePath.startsWith("..") || 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.`
     );
@@ -9944,8 +8213,8 @@ async function runPlayBootstrap(args) {
     ...csvContext
   });
   if (options.out) {
-    writeFileSync7(resolve9(options.out), source, "utf-8");
-    process.stdout.write(`Wrote ${resolve9(options.out)}
+    writeFileSync7(resolve6(options.out), source, "utf-8");
+    process.stdout.write(`Wrote ${resolve6(options.out)}
 `);
     return 0;
   }
@@ -10211,110 +8480,390 @@ async function traceCliSpan(phase, fields, run) {
   if (!isCliTraceEnabled()) {
     return run();
   }
-  const startedAt = Date.now();
+  const startedAt = Date.now();
+  try {
+    const result = await run();
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: true,
+      ...fields
+    });
+    return result;
+  } catch (error) {
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ...fields
+    });
+    throw error;
+  }
+}
+
+// src/cli/play-check-hints.ts
+var EXTRACTED_GETTER_ERROR_HINT = "Deepline hint: extractedValues/extractedLists .get() only works for declared Deepline getters listed by `deepline tools describe <tool> --json`. Use `toolExecutionResult.toolResponse.raw` for provider/tool-specific fields.";
+var DATASET_API_HINT = "Deepline hint: PlayDataset is lazy and durable. Use `.peek(n)` for a small preview or `.materialize()` when you intentionally need rows in memory; do not use `.rows`, `.toArray()`, or array methods directly on the dataset handle.";
+var ROW_PROPERTY_HINT = "Deepline hint: this row type only contains fields produced by the CSV/schema and previous map steps. Check source column casing and the exact output field names from earlier steps before scaling.";
+var TOOLS_EXECUTE_SIGNATURE_HINT = "Deepline hint: ctx.tools.execute requires a request object: `ctx.tools.execute({ id, tool, input, description })`. The stable `id` is required for replay-safe receipts.";
+var RUN_PLAY_SIGNATURE_HINT = "Deepline hint: ctx.runPlay uses a stable key plus a composable child play reference. Direct-run-only or map-backed batch plays must be run directly, exported, then consumed by a separate play.";
+var MAP_BACKED_CHILD_HINT = "Deepline hint: map-backed child plays own durable table state and cannot be called from another play. Run that play directly, export its dataset, then pass the CSV to the next play.";
+function sourceLineForError(sourceCode, error) {
+  const match = error.match(/:(\d+):(\d+)\s/);
+  const lineNumber = match?.[1] ? Number(match[1]) : NaN;
+  if (!Number.isInteger(lineNumber) || lineNumber < 1) return "";
+  return sourceCode.split(/\r?\n/)[lineNumber - 1] ?? "";
+}
+function looksLikeInvalidExtractedGetter(error, sourceLine) {
+  if (!/Property '[^']+' does not exist on type/.test(error)) return false;
+  return /\bextracted(?:Values|Lists)\s*\./.test(sourceLine);
+}
+function looksLikeDatasetApiMisuse(error, sourceLine) {
+  return /Property '(?:rows|toArray|forEach|map|filter|reduce)' does not exist on type '[^']*PlayDataset/.test(
+    error
+  ) || /\b(?:\.rows|\.toArray\(\)|\.forEach\(|\.map\(|\.filter\(|\.reduce\()/.test(
+    sourceLine
+  );
+}
+function looksLikeRowPropertyMismatch(error, sourceLine) {
+  if (!/Property '[^']+' does not exist on type/.test(error)) return false;
+  if (looksLikeInvalidExtractedGetter(error, sourceLine)) return false;
+  return /\brow\.[A-Za-z_][A-Za-z0-9_]*/.test(sourceLine);
+}
+function looksLikeToolsExecuteSignature(error, sourceLine) {
+  return /ctx\.tools\.execute requires a request object/i.test(error) || /Expected 1 arguments?, but got [2-9]/.test(error) && /\btools\.execute\(/.test(sourceLine);
+}
+function looksLikeRunPlaySignature(error, sourceLine) {
+  return /ctx\.runPlay/i.test(error) || /(?:Expected|Argument of type|No overload matches)/.test(error) && /\brunPlay\(/.test(sourceLine);
+}
+function looksLikeMapBackedChild(error) {
+  return /map-backed child play|direct-run-only|cannot call a map-backed|own durable table/i.test(
+    error
+  );
+}
+function hintForError(error, sourceLine) {
+  if (looksLikeInvalidExtractedGetter(error, sourceLine)) {
+    return EXTRACTED_GETTER_ERROR_HINT;
+  }
+  if (looksLikeDatasetApiMisuse(error, sourceLine)) {
+    return DATASET_API_HINT;
+  }
+  if (looksLikeToolsExecuteSignature(error, sourceLine)) {
+    return TOOLS_EXECUTE_SIGNATURE_HINT;
+  }
+  if (looksLikeMapBackedChild(error)) {
+    return MAP_BACKED_CHILD_HINT;
+  }
+  if (looksLikeRunPlaySignature(error, sourceLine)) {
+    return RUN_PLAY_SIGNATURE_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 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 {
-    const result = await run();
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: true,
-      ...fields
-    });
-    return result;
+    return resolvePlayRuntimeProvider(override);
   } catch (error) {
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-      ...fields
-    });
+    if (override?.trim()) {
+      throw new Error(
+        `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
+          PLAY_EXECUTION_PROFILES
+        ).join(", ")}.`
+      );
+    }
     throw error;
   }
 }
 
-// src/cli/play-check-hints.ts
-var EXTRACTED_GETTER_ERROR_HINT = "Deepline hint: extractedValues/extractedLists .get() only works for declared Deepline getters listed by `deepline tools describe <tool> --json`. Use `toolExecutionResult.toolResponse.raw` for provider/tool-specific fields.";
-var DATASET_API_HINT = "Deepline hint: PlayDataset is lazy and durable. Use `.peek(n)` for a small preview or `.materialize()` when you intentionally need rows in memory; do not use `.rows`, `.toArray()`, or array methods directly on the dataset handle.";
-var ROW_PROPERTY_HINT = "Deepline hint: this row type only contains fields produced by the CSV/schema and previous map steps. Check source column casing and the exact output field names from earlier steps before scaling.";
-var TOOLS_EXECUTE_SIGNATURE_HINT = "Deepline hint: ctx.tools.execute requires a request object: `ctx.tools.execute({ id, tool, input, description })`. The stable `id` is required for replay-safe receipts.";
-var RUN_PLAY_SIGNATURE_HINT = "Deepline hint: ctx.runPlay uses a stable key plus a composable child play reference. Direct-run-only or map-backed batch plays must be run directly, exported, then consumed by a separate play.";
-var MAP_BACKED_CHILD_HINT = "Deepline hint: map-backed child plays own durable table state and cannot be called from another play. Run that play directly, export its dataset, then pass the CSV to the next play.";
-function sourceLineForError(sourceCode, error) {
-  const match = error.match(/:(\d+):(\d+)\s/);
-  const lineNumber = match?.[1] ? Number(match[1]) : NaN;
-  if (!Number.isInteger(lineNumber) || lineNumber < 1) return "";
-  return sourceCode.split(/\r?\n/)[lineNumber - 1] ?? "";
-}
-function looksLikeInvalidExtractedGetter(error, sourceLine) {
-  if (!/Property '[^']+' does not exist on type/.test(error)) return false;
-  return /\bextracted(?:Values|Lists)\s*\./.test(sourceLine);
-}
-function looksLikeDatasetApiMisuse(error, sourceLine) {
-  return /Property '(?:rows|toArray|forEach|map|filter|reduce)' does not exist on type '[^']*PlayDataset/.test(
-    error
-  ) || /\b(?:\.rows|\.toArray\(\)|\.forEach\(|\.map\(|\.filter\(|\.reduce\()/.test(
-    sourceLine
-  );
-}
-function looksLikeRowPropertyMismatch(error, sourceLine) {
-  if (!/Property '[^']+' does not exist on type/.test(error)) return false;
-  if (looksLikeInvalidExtractedGetter(error, sourceLine)) return false;
-  return /\brow\.[A-Za-z_][A-Za-z0-9_]*/.test(sourceLine);
-}
-function looksLikeToolsExecuteSignature(error, sourceLine) {
-  return /ctx\.tools\.execute requires a request object/i.test(error) || /Expected 1 arguments?, but got [2-9]/.test(error) && /\btools\.execute\(/.test(sourceLine);
-}
-function looksLikeRunPlaySignature(error, sourceLine) {
-  return /ctx\.runPlay/i.test(error) || /(?:Expected|Argument of type|No overload matches)/.test(error) && /\brunPlay\(/.test(sourceLine);
+// ../shared_libs/play-runtime/internal-step-ids.ts
+var INTERNAL_GLUE_NODE_ID_PREFIX = "run_javascript:";
+function isInternalGlueStepId(stepId) {
+  return typeof stepId === "string" && stepId.startsWith(INTERNAL_GLUE_NODE_ID_PREFIX);
 }
-function looksLikeMapBackedChild(error) {
-  return /map-backed child play|direct-run-only|cannot call a map-backed|own durable table/i.test(
-    error
-  );
+
+// 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 hintForError(error, sourceLine) {
-  if (looksLikeInvalidExtractedGetter(error, sourceLine)) {
-    return EXTRACTED_GETTER_ERROR_HINT;
-  }
-  if (looksLikeDatasetApiMisuse(error, sourceLine)) {
-    return DATASET_API_HINT;
-  }
-  if (looksLikeToolsExecuteSignature(error, sourceLine)) {
-    return TOOLS_EXECUTE_SIGNATURE_HINT;
-  }
-  if (looksLikeMapBackedChild(error)) {
-    return MAP_BACKED_CHILD_HINT;
-  }
-  if (looksLikeRunPlaySignature(error, sourceLine)) {
-    return RUN_PLAY_SIGNATURE_HINT;
+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;
   }
-  if (looksLikeRowPropertyMismatch(error, sourceLine)) {
-    return ROW_PROPERTY_HINT;
+  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;
   }
-  return null;
+  if (quote === "`" && value.includes("${")) return null;
+  return value;
 }
-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;
+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;
     }
-    addedHints.add(hint);
-    return `${error}
-${hint}`;
-  });
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
 }
-
-// ../shared_libs/play-runtime/internal-step-ids.ts
-var INTERNAL_GLUE_NODE_ID_PREFIX = "run_javascript:";
-function isInternalGlueStepId(stepId) {
-  return typeof stepId === "string" && stepId.startsWith(INTERNAL_GLUE_NODE_ID_PREFIX);
+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;
 }
-
-// src/cli/commands/play.ts
 var PLAY_RUN_RESERVED_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "--json",
   "--wait",
@@ -10349,7 +8898,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();
@@ -10393,7 +8942,7 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return resolve10(defaultStarterPlayPath(reference));
+  return resolve7(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
   const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
@@ -10419,8 +8968,8 @@ function materializeRemotePlaySource(input2) {
     return null;
   }
   const outputPath = input2.outPath ?? defaultMaterializedPlayPath(input2.playName);
-  if (existsSync8(outputPath)) {
-    const existingSource = readFileSync7(outputPath, "utf-8");
+  if (existsSync6(outputPath)) {
+    const existingSource = readFileSync6(outputPath, "utf-8");
     if (existingSource === input2.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
@@ -10472,7 +9021,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return existsSync8(resolve10(target));
+  return existsSync6(resolve7(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -10501,7 +9050,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? readFileSync7(resolve10(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? readFileSync6(resolve7(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.");
@@ -10603,7 +9152,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 existsSync8(resolve10(value));
+  return existsSync6(resolve7(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -10650,7 +9199,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 && existsSync8(resolve10(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && existsSync6(resolve7(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -10692,8 +9241,8 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = resolve10(ref.value);
-    if (!existsSync8(absolutePath)) {
+    const absolutePath = resolve7(ref.value);
+    if (!existsSync6(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,
@@ -10701,9 +9250,9 @@ function preflightLocalFileInputs(runtimeInput) {
         { inputPath: ref.inputPath, path: ref.value, resolved: absolutePath }
       );
     }
-    let stat4;
+    let stat2;
     try {
-      stat4 = statSync2(absolutePath);
+      stat2 = statSync2(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.`,
@@ -10712,7 +9261,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,
@@ -10729,7 +9278,7 @@ function preflightLocalFileInputs(runtimeInput) {
 function preflightCsvDataInput(ref, absolutePath) {
   let content;
   try {
-    content = readFileSync7(absolutePath, "utf-8");
+    content = readFileSync6(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.`,
@@ -10811,8 +9360,8 @@ async function stageFileInputArgs(input2) {
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input2.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = resolve10(value);
-    return [{ binding, absolutePath, logicalPath: basename3(absolutePath) }];
+    const absolutePath = resolve7(value);
+    return [{ binding, absolutePath, logicalPath: basename(absolutePath) }];
   });
   if (localFiles.length === 0) {
     return { inputFile: null, packagedFiles: [] };
@@ -10844,20 +9393,20 @@ async function stageFileInputArgs(input2) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = readFileSync7(absolutePath);
+  const buffer = readFileSync6(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
-    contentHash: createHash3("sha256").update(buffer).digest("hex"),
+    contentHash: 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 realpathSync.native(resolve10(filePath));
+    return realpathSync.native(resolve7(filePath));
   } catch {
-    return resolve10(filePath);
+    return resolve7(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -10868,6 +9417,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;
@@ -10884,7 +9434,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) {
@@ -11508,6 +10058,7 @@ async function waitForPlayCompletionByStream(input2) {
         input2.workflowId,
         {
           signal: controller.signal,
+          fallback: "none",
           onNotice: input2.jsonOutput ? void 0 : (message) => input2.progress.writeLine(message)
         }
       )) {
@@ -12521,15 +11072,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;
@@ -12842,7 +11393,7 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve10(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve7(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -13646,7 +12197,7 @@ async function handlePlayCheck(args) {
       }
       return 0;
     } catch (error) {
-      const resolved = resolve10(options.target);
+      const resolved = resolve7(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         process.stdout.write(
@@ -13663,8 +12214,8 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = resolve10(options.target);
-  const sourceCode = readFileSync7(absolutePlayPath, "utf-8");
+  const absolutePlayPath = resolve7(options.target);
+  const sourceCode = readFileSync6(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -13743,12 +12294,12 @@ async function handleFileBackedRun(options) {
   }
   const client2 = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = resolve10(options.target.path);
+  const absolutePlayPath = resolve7(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => readFileSync7(absolutePlayPath, "utf-8")
+    () => readFileSync6(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   try {
@@ -14067,11 +12618,11 @@ async function handlePlayRun(args) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options);
     }
-    const resolved = resolve10(options.target.path);
+    const resolved = resolve7(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = dirname9(resolved);
-    if (existsSync8(dir)) {
-      const base = basename3(resolved);
+    const dir = dirname6(resolved);
+    if (existsSync6(dir)) {
+      const base = basename(resolved);
       try {
         const siblings = readdirSync(dir).filter(
           (f) => f.includes(base.replace(/\.(play\.)?ts$/, "")) || f.endsWith(".play.ts")
@@ -14079,7 +12630,7 @@ async function handlePlayRun(args) {
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${join8(dir, s)}`);
+            console.error(`  ${join5(dir, s)}`);
           }
         }
       } catch {
@@ -14234,7 +12785,7 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve10(args[++index]);
+      outPath = resolve7(args[++index]);
     }
   }
   const client2 = new DeeplineClient();
@@ -14366,7 +12917,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 = resolve10(args[++index]);
+      outPath = resolve7(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -14374,7 +12925,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = resolve10(args[++index]);
+      metadataOutPath = resolve7(args[++index]);
     }
   }
   if (!outPath) {
@@ -14446,10 +12997,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 = resolve10(args[++index]);
+      outPath = resolve7(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName(readFileSync7(resolve10(target), "utf-8"), resolve10(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName(readFileSync6(resolve7(target), "utf-8"), resolve7(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({
@@ -14892,7 +13443,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          readFileSync7(resolve10(playName), "utf-8"),
+          readFileSync6(resolve7(playName), "utf-8"),
           playName
         );
       } catch {
@@ -14973,7 +13524,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph(resolve10(playName))
+        () => collectBundledPlayGraph(resolve7(playName))
       );
       await traceCliSpan(
         "cli.play_publish_compile_manifests",
@@ -15093,14 +13644,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
 `
   );
@@ -15108,14 +13660,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) => {
@@ -15124,11 +13676,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.
@@ -15168,11 +13719,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>
 `
@@ -15365,20 +13916,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,
@@ -15389,7 +13941,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([
@@ -17264,7 +15816,7 @@ function expandAtFilePath(rawPath) {
     return homedir6();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return join9(homedir6(), expanded.slice(2));
+    return join6(homedir6(), expanded.slice(2));
   }
   return expanded;
 }
@@ -17277,7 +15829,7 @@ async function readAtFileReference(value, argumentName, strip = true) {
     throw new Error(`Invalid ${argumentName} value: empty @file path.`);
   }
   try {
-    const text = await readFile3(filePath, "utf8");
+    const text = await readFile(filePath, "utf8");
     const normalized = text.replace(/^\uFEFF/, "");
     return strip ? normalized.trim() : normalized;
   } catch (error) {
@@ -17448,9 +16000,9 @@ async function buildPlanArgs(args) {
   return planArgs;
 }
 async function assertInputCsvExists(inputCsv) {
-  const path = resolve11(inputCsv);
+  const path = resolve8(inputCsv);
   try {
-    const info = await stat3(path);
+    const info = await stat(path);
     if (info.isFile()) {
       return;
     }
@@ -17462,8 +16014,8 @@ async function assertInputCsvExists(inputCsv) {
   }
 }
 async function assertSafeOutputPath(inputCsv, outputPath) {
-  const input2 = resolve11(inputCsv);
-  const output2 = resolve11(outputPath);
+  const input2 = resolve8(inputCsv);
+  const output2 = resolve8(outputPath);
   if (input2 === output2) {
     throw new Error(
       "--input and --output must be different files when not using --in-place."
@@ -17471,8 +16023,8 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
   }
   try {
     const [inputInfo, outputInfo] = await Promise.all([
-      stat3(input2),
-      stat3(output2)
+      stat(input2),
+      stat(output2)
     ]);
     if (inputInfo.dev === outputInfo.dev && inputInfo.ino === outputInfo.ino) {
       throw new Error(
@@ -17492,7 +16044,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await stat3(resolve11(path));
+    const info = await stat(resolve8(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -17503,7 +16055,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await readFile3(resolve11(path), "utf8");
+  const source = await readFile(resolve8(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -17788,7 +16340,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;
@@ -17819,8 +16371,8 @@ async function writeOutputCsv(outputPath, status, options) {
     ]),
     options?.config
   );
-  await writeFile4(
-    resolve11(outputPath),
+  await writeFile3(
+    resolve8(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
   );
@@ -17830,7 +16382,7 @@ async function writeOutputCsv(outputPath, status, options) {
     selectedRows: rowsInfo.totalRows,
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
-    path: resolve11(outputPath),
+    path: resolve8(outputPath),
     enrichedDataRows: rowsInfo.rows
   };
 }
@@ -18019,12 +16571,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"]),
@@ -18084,11 +16636,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(
@@ -18125,9 +16677,9 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0) {
     return null;
   }
-  const stateDir = join9(homedir6(), ".local", "deepline", "runtime", "state");
-  await mkdir4(stateDir, { recursive: true });
-  const reportPath = join9(
+  const stateDir = join6(homedir6(), ".local", "deepline", "runtime", "state");
+  await mkdir3(stateDir, { recursive: true });
+  const reportPath = join6(
     stateDir,
     `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -18151,7 +16703,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 writeFile4(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile3(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   return reportPath;
 }
@@ -18564,8 +17116,8 @@ function registerEnrichCommand(program) {
       if (options.json) {
         printJson({
           dryRun: true,
-          input: resolve11(inputCsv),
-          output: options.output ? resolve11(options.output) : null,
+          input: resolve8(inputCsv),
+          output: options.output ? resolve8(options.output) : null,
           plan: summary
         });
         return;
@@ -18589,12 +17141,12 @@ function registerEnrichCommand(program) {
       forceAliases,
       playName: options.name
     });
-    const tempDir = await mkdtemp(join9(tmpdir3(), "deepline-enrich-play-"));
-    const tempPlay = join9(tempDir, "deepline-enrich.play.ts");
+    const tempDir = await mkdtemp(join6(tmpdir(), "deepline-enrich-play-"));
+    const tempPlay = join6(tempDir, "deepline-enrich.play.ts");
     try {
-      await writeFile4(tempPlay, playSource, "utf8");
+      await writeFile3(tempPlay, playSource, "utf8");
       const runtimeInput = {
-        file: resolve11(sourceCsvPath),
+        file: resolve8(sourceCsvPath),
         ...rows.rowStart !== null ? { rowStart: rows.rowStart } : {},
         ...rows.rowEnd !== null ? { rowEnd: rows.rowEnd } : {}
       };
@@ -18756,15 +17308,15 @@ Examples:
 
 // src/cli/commands/sessions.ts
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync7,
   statSync as statSync3,
   writeFileSync as writeFileSync9
 } from "fs";
 import { homedir as homedir7, platform } from "os";
-import { basename as basename4, dirname as dirname10, join as join10, resolve as resolve12 } from "path";
+import { basename as basename2, dirname as dirname7, join as join7, resolve as resolve9 } from "path";
 import { gzipSync } from "zlib";
 import { randomUUID } from "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;
@@ -18783,36 +17335,36 @@ function homeDir() {
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
   return {
-    shell: shellPath ? basename4(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell: shellPath ? basename2(shellPath).replace(/\.exe$/i, "") : "unknown",
     shell_path: shellPath || null,
     os: platform(),
     cwd: process.cwd()
   };
 }
 function claudeProjectsRoot() {
-  return join10(homeDir(), ".claude", "projects");
+  return join7(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return join10(homeDir(), ".codex", "sessions");
+  return join7(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
-  if (!existsSync9(root)) return [];
+  if (!existsSync7(root)) return [];
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = join10(root, projectDir);
+    const fullProjectDir = join7(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = join10(fullProjectDir, fileName);
+        const filePath = join7(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
           });
         }
       }
@@ -18822,14 +17374,14 @@ function listClaudeSessionFiles() {
 }
 function listCodexSessionFiles() {
   const root = codexSessionsRoot();
-  if (!existsSync9(root)) return [];
+  if (!existsSync7(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;
 }
@@ -18861,7 +17413,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join10(dir, entry.name);
+      const fullPath = join7(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -18889,15 +17441,15 @@ function newestSessionFile(agent) {
   return newest;
 }
 function sessionIdFromClaudeFilePath(filePath) {
-  return basename4(filePath, ".jsonl");
+  return basename2(filePath, ".jsonl");
 }
 function sessionIdFromCodexFilePath(filePath) {
-  const match = basename4(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  const match = basename2(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
   return match?.[0] ?? null;
 }
 function readCodexSessionId(filePath) {
   try {
-    for (const line of normalizedJsonLines(readFileSync8(filePath)).slice(
+    for (const line of normalizedJsonLines(readFileSync7(filePath)).slice(
       0,
       20
     )) {
@@ -19174,25 +17726,25 @@ async function uploadChunkedSessions(sessions, options) {
 }
 async function handleSessionsSend(options) {
   if (options.file) {
-    const filePath = resolve12(options.file);
-    if (!existsSync9(filePath)) {
+    const filePath = resolve9(options.file);
+    if (!existsSync7(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
-      file: readFileSync8(filePath).toString("base64"),
-      filename: basename4(filePath)
+      file: readFileSync7(filePath).toString("base64"),
+      filename: basename2(filePath)
     });
     printCommandEnvelope(
       {
         ...response2,
         ok: true,
-        filename: basename4(filePath),
+        filename: basename2(filePath),
         render: {
           sections: [
             {
               title: "sessions send",
               lines: [
-                `File '${basename4(filePath)}' uploaded to #internal-reports.`
+                `File '${basename2(filePath)}' uploaded to #internal-reports.`
               ]
             }
           ]
@@ -19209,7 +17761,7 @@ async function handleSessionsSend(options) {
     agent: options.agent
   });
   const built = targets.map((target) => {
-    const upload = buildSessionUploadContent(readFileSync8(target.filePath));
+    const upload = buildSessionUploadContent(readFileSync7(target.filePath));
     return { ...target, ...upload };
   });
   if (built.some((session) => session.needsChunking)) {
@@ -19273,28 +17825,28 @@ function fallbackViewerAssets() {
   };
 }
 function loadViewerAssets() {
-  const cliEntry = process.argv[1]?.trim() ? resolve12(process.argv[1]) : null;
+  const cliEntry = process.argv[1]?.trim() ? resolve9(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      join10(dirname10(dirname10(cliEntry)), "viewer"),
-      join10(
-        dirname10(dirname10(dirname10(cliEntry))),
+      join7(dirname7(dirname7(cliEntry)), "viewer"),
+      join7(
+        dirname7(dirname7(dirname7(cliEntry))),
         "src",
         "lib",
         "cli",
         "viewer"
       )
     ] : [],
-    join10(process.cwd(), "src", "lib", "cli", "viewer")
+    join7(process.cwd(), "src", "lib", "cli", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = join10(root, "viewer.css");
-      const jsPath = join10(root, "viewer.js");
-      if (!existsSync9(cssPath) || !existsSync9(jsPath)) continue;
+      const cssPath = join7(root, "viewer.css");
+      const jsPath = join7(root, "viewer.js");
+      if (!existsSync7(cssPath) || !existsSync7(jsPath)) continue;
       return {
-        css: readFileSync8(cssPath, "utf8"),
-        js: readFileSync8(jsPath, "utf8")
+        css: readFileSync7(cssPath, "utf8"),
+        js: readFileSync7(jsPath, "utf8")
       };
     } catch {
       continue;
@@ -19318,21 +17870,21 @@ async function handleSessionsRender(options) {
     currentSession: options.currentSession,
     agent: options.agent
   });
-  let outputPath = options.output ? resolve12(options.output) : "";
+  let outputPath = options.output ? resolve9(options.output) : "";
   if (!outputPath) {
-    const outputDir = join10(process.cwd(), "deepline", "data");
+    const outputDir = join7(process.cwd(), "deepline", "data");
     mkdirSync5(outputDir, { recursive: true });
-    outputPath = join10(
+    outputPath = join7(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    mkdirSync5(dirname10(outputPath), { recursive: true });
+    mkdirSync5(dirname7(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
     events: parsePreparedEvents(
-      prepareSessionBuffer(readFileSync8(target.filePath))
+      prepareSessionBuffer(readFileSync7(target.filePath))
     )
   }));
   const { css, js } = loadViewerAssets();
@@ -19795,17 +18347,17 @@ function hasClaudeBinary() {
   }
 }
 function launchClaude(prompt) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve13) => {
     const child = 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) => {
@@ -19815,7 +18367,7 @@ function readBody(req) {
         req.destroy();
       }
     });
-    req.on("end", () => resolve16(raw));
+    req.on("end", () => resolve13(raw));
     req.on("error", reject);
   });
 }
@@ -19870,7 +18422,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();
@@ -19878,7 +18430,7 @@ function startCallbackServer(input2) {
         reject(new Error("Failed to bind quickstart callback server."));
         return;
       }
-      resolve16({ server, port: address.port });
+      resolve13({ server, port: address.port });
     });
   });
 }
@@ -19904,8 +18456,8 @@ async function handleQuickstart(options) {
   }
   const state = randomBytes(32).toString("hex");
   let resolveSelection;
-  const selectionPromise = new Promise((resolve16) => {
-    resolveSelection = resolve16;
+  const selectionPromise = new Promise((resolve13) => {
+    resolveSelection = resolve13;
   });
   let callback;
   try {
@@ -20039,7 +18591,7 @@ async function readHiddenLine(prompt) {
   if (typeof input.setRawMode === "function") input.setRawMode(true);
   let value = "";
   input.resume();
-  return await new Promise((resolve16, reject) => {
+  return await new Promise((resolve13, reject) => {
     let settled = false;
     const cleanup = () => {
       input.off("data", onData);
@@ -20054,7 +18606,7 @@ async function readHiddenLine(prompt) {
       settled = true;
       output.write("\n");
       cleanup();
-      resolve16(line);
+      resolve13(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -20225,9 +18777,9 @@ Examples:
 }
 
 // src/cli/commands/switch.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname11, join as join11 } from "path";
+import { dirname as dirname8, join as join8 } from "path";
 function hostSlugFromBaseUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
@@ -20248,7 +18800,7 @@ function resolveConfigScope() {
 }
 function activeFamilyPath() {
   const home = process.env.HOME || process.env.USERPROFILE || homedir8();
-  return join11(
+  return join8(
     home,
     ".local",
     "deepline",
@@ -20260,14 +18812,14 @@ function activeFamilyPath() {
 function readActiveFamily() {
   const path = activeFamilyPath();
   try {
-    return readFileSync9(path, "utf-8").trim() || "sdk";
+    return readFileSync8(path, "utf-8").trim() || "sdk";
   } catch {
     return "sdk";
   }
 }
 function writeActiveFamily(family) {
   const path = activeFamilyPath();
-  mkdirSync6(dirname11(path), { recursive: true });
+  mkdirSync6(dirname8(path), { recursive: true });
   writeFileSync10(path, `${family}
 `, "utf-8");
   return path;
@@ -20285,7 +18837,7 @@ function handleSwitch(action, options) {
         ok: true,
         active_family: activeFamily,
         active_family_path: path,
-        active_family_file_exists: existsSync10(path),
+        active_family_file_exists: existsSync8(path),
         render: {
           sections: [
             {
@@ -20387,18 +18939,18 @@ Examples:
 import { Option } from "commander";
 import {
   chmodSync,
-  existsSync as existsSync11,
+  existsSync as existsSync9,
   mkdtempSync,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync9,
   writeFileSync as writeFileSync12
 } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-import { join as join13, resolve as resolve13 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join10, resolve as resolve10 } from "path";
 
 // src/tool-output.ts
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join12 } from "path";
+import { join as join9 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20494,19 +19046,19 @@ function tryConvertToList(payload, options) {
   return null;
 }
 function ensureOutputDir() {
-  const outputDir = join12(homedir9(), ".local", "share", "deepline", "data");
+  const outputDir = join9(homedir9(), ".local", "share", "deepline", "data");
   mkdirSync7(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join12(outputDir, `${stem}_${Date.now()}.json`);
+  const outputPath = join9(outputDir, `${stem}_${Date.now()}.json`);
   writeFileSync11(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join12(outputDir, `${stem}_${Date.now()}.csv`);
+  const outputPath = join9(outputDir, `${stem}_${Date.now()}.csv`);
   const seen = /* @__PURE__ */ new Set();
   const columns = [];
   for (const row of rows) {
@@ -21583,11 +20135,11 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = resolve13(trimmed);
-  if (existsSync11(resolved)) return resolved;
+  const resolved = resolve10(trimmed);
+  if (existsSync9(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = resolve13(trimmed.replace(/\\/g, "/"));
-    if (existsSync11(normalized)) return normalized;
+    const normalized = resolve10(trimmed.replace(/\\/g, "/"));
+    if (existsSync9(normalized)) return normalized;
   }
   return resolved;
 }
@@ -21598,7 +20150,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return readFileSync10(resolveAtFilePath(filePath), "utf8").replace(
+    return readFileSync9(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -21700,9 +20252,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = mkdtempSync(join13(tmpdir4(), "deepline-workflow-seed-"));
+  const scriptDir = mkdtempSync(join10(tmpdir2(), "deepline-workflow-seed-"));
   chmodSync(scriptDir, 448);
-  const scriptPath = join13(scriptDir, fileName);
+  const scriptPath = join10(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(/\]$/, "")}, ...]` : "[]";
@@ -22002,11 +20554,48 @@ async function executeTool(args) {
 }
 
 // src/cli/commands/workflow.ts
-import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname12, join as join14, resolve as resolve14 } from "path";
+import { mkdir as mkdir4, readFile as readFile2, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname9, join as join11, resolve as resolve11 } from "path";
+
+// src/cli/workflow-to-play.ts
+import { createHash as createHash2 } from "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
-import { createHash as createHash4 } from "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_";
@@ -22112,7 +20701,7 @@ function sanitizePlayNameSegment(value) {
 }
 function deriveWorkflowPlayName(workflowName) {
   const base = sanitizePlayNameSegment(workflowName) || "workflow";
-  const suffix = createHash4("sha256").update(workflowName).digest("hex").slice(0, 8);
+  const suffix = createHash2("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}`;
@@ -22210,7 +20799,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await readFile4(resolve14(file), "utf8");
+    const raw = await readFile2(resolve11(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -22244,9 +20833,9 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join14(resolve14(outDir), `${compiled.playName}.play.ts`);
-    await mkdir5(dirname12(file), { recursive: true });
-    await writeFile5(file, compiled.sourceCode, "utf8");
+    const file = join11(resolve11(outDir), `${compiled.playName}.play.ts`);
+    await mkdir4(dirname9(file), { recursive: true });
+    await writeFile4(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
       const code = await handlePlayPublish([file]);
@@ -22493,15 +21082,15 @@ Notes:
 // src/cli/commands/update.ts
 import { spawn as spawn2 } from "child_process";
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync10,
   renameSync,
   rmSync as rmSync3,
   writeFileSync as writeFileSync13
 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname13, isAbsolute as isAbsolute4, join as join15, relative as relative4, resolve as resolve15 } from "path";
+import { dirname as dirname10, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve12 } from "path";
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -22524,11 +21113,11 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return join15(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return join12(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function readOptionalText(path) {
   try {
-    return readFileSync11(path, "utf8").trim();
+    return readFileSync10(path, "utf8").trim();
   } catch {
     return "";
   }
@@ -22536,26 +21125,26 @@ function readOptionalText(path) {
 function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
-  const relativeEntrypoint = relative4(
-    resolve15(stateDir),
-    resolve15(options.entrypoint)
+  const relativeEntrypoint = relative2(
+    resolve12(stateDir),
+    resolve12(options.entrypoint)
   );
-  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute4(relativeEntrypoint)) {
+  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute2(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText(join15(stateDir, ".install-method"));
+  const installMethod = readOptionalText(join12(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(join15(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText(join15(stateDir, ".command-path")) || join15(
+  const nodeBin = readOptionalText(join12(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText(join12(stateDir, ".command-path")) || join12(
     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(join15(stateDir, "versions", "<version>"))} --no-audit --no-fund ${shellQuote3(packageSpec)}`;
+  const manualCommand = `${npmCommand} install --prefix ${shellQuote3(join12(stateDir, "versions", "<version>"))} --no-audit --no-fund ${shellQuote3(packageSpec)}`;
   return {
     kind: "python-sidecar",
     stateDir,
@@ -22569,12 +21158,12 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve15(startPath);
+  let current = resolve12(startPath);
   while (true) {
-    if (existsSync12(join15(current, "sdk", "package.json")) && existsSync12(join15(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync10(join12(current, "sdk", "package.json")) && existsSync10(join12(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = dirname13(current);
+    const parent = dirname10(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -22582,8 +21171,8 @@ function findRepoBackedSdkRoot(startPath) {
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
   const homeDir2 = options.homeDir ?? homedir10();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve15(process.argv[1]) : "");
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname13(entrypoint)) : null;
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve12(process.argv[1]) : "");
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname10(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -22613,7 +21202,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return join15(
+  return join12(
     versionDir,
     "node_modules",
     "deepline",
@@ -22623,14 +21212,14 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = join15(
+  const packageJsonPath = join12(
     versionDir,
     "node_modules",
     "deepline",
     "package.json"
   );
   try {
-    const parsed = JSON.parse(readFileSync11(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" ? safeVersionSegment(parsed.version) : "";
   } catch {
     return "";
@@ -22654,7 +21243,7 @@ function runCommand(command, args, env = process.env) {
   });
 }
 function writeSidecarLauncher(input2) {
-  mkdirSync8(dirname13(input2.path), { recursive: true });
+  mkdirSync8(dirname10(input2.path), { recursive: true });
   if (process.platform === "win32") {
     writeFileSync13(
       input2.path,
@@ -22681,17 +21270,17 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan) {
-  const versionsDir = join15(plan.stateDir, "versions");
-  const tempDir = join15(
+  const versionsDir = join12(plan.stateDir, "versions");
+  const tempDir = join12(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
   rmSync3(tempDir, { recursive: true, force: true });
   mkdirSync8(tempDir, { recursive: true });
-  writeFileSync13(join15(tempDir, "package.json"), '{"private":true}\n', "utf8");
+  writeFileSync13(join12(tempDir, "package.json"), '{"private":true}\n', "utf8");
   const env = {
     ...process.env,
-    PATH: `${dirname13(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
+    PATH: `${dirname10(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
   };
   const installExitCode = await runCommand(
     plan.npmCommand,
@@ -22717,9 +21306,9 @@ async function runPythonSidecarUpdatePlan(plan) {
     rmSync3(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = join15(versionsDir, installedVersion);
+  const finalDir = join12(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
-  if (existsSync12(finalEntryPath)) {
+  if (existsSync10(finalEntryPath)) {
     rmSync3(tempDir, { recursive: true, force: true });
   } else {
     rmSync3(finalDir, { recursive: true, force: true });
@@ -22734,7 +21323,7 @@ async function runPythonSidecarUpdatePlan(plan) {
       return 1;
     }
   }
-  if (!existsSync12(finalEntryPath)) {
+  if (!existsSync10(finalEntryPath)) {
     process.stderr.write(
       `Updated Deepline SDK CLI entrypoint missing: ${finalEntryPath}
 `
@@ -22749,27 +21338,27 @@ async function runPythonSidecarUpdatePlan(plan) {
     entryPath: finalEntryPath
   });
   writeFileSync13(
-    join15(plan.stateDir, ".version"),
+    join12(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
   writeFileSync13(
-    join15(plan.stateDir, ".install-method"),
+    join12(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
   writeFileSync13(
-    join15(plan.stateDir, ".command-path"),
+    join12(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  writeFileSync13(join15(plan.stateDir, ".runner"), "node\n", "utf8");
-  writeFileSync13(join15(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  writeFileSync13(join12(plan.stateDir, ".runner"), "node\n", "utf8");
+  writeFileSync13(join12(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
   writeFileSync13(
-    join15(plan.stateDir, ".entry-path"),
+    join12(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -23056,7 +21645,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 = spawn3(command, args, {
@@ -23072,9 +21661,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) {
@@ -23113,9 +21702,9 @@ async function maybeAutoUpdateAndRelaunch(response) {
 
 // src/cli/skills-sync.ts
 import { spawn as spawn4, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname14, join as join16 } from "path";
+import { dirname as dirname11, join as join13 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_PLAY_SKILL_NAME = "deepline-plays";
 var attemptedSync = false;
@@ -23129,20 +21718,20 @@ function activePluginSkillsDir() {
     return "";
   }
   const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && existsSync13(dir) ? dir : "";
+  return dir && existsSync11(dir) ? dir : "";
 }
 function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return readFileSync12(join16(dir, ".version"), "utf-8").trim();
+    return readFileSync11(join13(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
   const home = process.env.HOME?.trim() || homedir11();
-  return join16(
+  return join13(
     home,
     ".local",
     "deepline",
@@ -23155,16 +21744,16 @@ function readLocalSkillsVersion(baseUrl) {
   const pluginVersion = readPluginSkillsVersion();
   if (pluginVersion) return pluginVersion;
   const path = sdkSkillsVersionPath(baseUrl);
-  if (!existsSync13(path)) return "";
+  if (!existsSync11(path)) return "";
   try {
-    return readFileSync12(path, "utf-8").trim();
+    return readFileSync11(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync9(dirname14(path), { recursive: true });
+  mkdirSync9(dirname11(path), { recursive: true });
   writeFileSync14(path, `${version}
 `, "utf-8");
 }
@@ -23263,7 +21852,7 @@ function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NA
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve16) => {
+  return new Promise((resolve13) => {
     const child = spawn4(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
@@ -23273,7 +21862,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
@@ -23281,11 +21870,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
@@ -23631,10 +22220,10 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join17(tmpdir5(), "deepline-health-play-"));
-  const file = join17(dir, "health-check.play.ts");
+  const dir = await mkdtemp2(join14(tmpdir3(), "deepline-health-play-"));
+  const file = join14(dir, "health-check.play.ts");
   try {
-    await writeFile6(
+    await writeFile5(
       file,
       [
         "import { definePlay } from 'deepline';",