deepline 0.1.110 → 0.1.112

package/dist/cli/index.js

@@ -182,8 +182,8 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 var import_promises7 = require("fs/promises");
-var import_node_path21 = require("path");
-var import_node_os14 = require("os");
+var import_node_path22 = require("path");
+var import_node_os15 = require("os");
 var import_commander3 = require("commander");
 
 // src/config.ts
@@ -403,10 +403,10 @@ var SDK_RELEASE = {
   // skill on the sdk sync surface, and the people-search-to-email prebuilt.
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
-  version: "0.1.110",
+  version: "0.1.112",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.110",
+    latest: "0.1.112",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -3462,11 +3462,57 @@ var DeeplineClient = class {
 };
 
 // src/compat.ts
+var import_node_fs3 = require("fs");
+var import_node_os3 = require("os");
+var import_node_path3 = require("path");
 var CHECK_TIMEOUT_MS = 2e3;
+var COMPAT_CACHE_TTL_MS = 5 * 60 * 1e3;
 function shouldSkipCompatibilityCheck() {
   const value = process.env.DEEPLINE_SKIP_SDK_COMPAT_CHECK?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes";
 }
+function compatibilityCachePath() {
+  return (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".cache", "deepline", "sdk-compat-cache.json");
+}
+function compatibilityCacheKey(baseUrl, command) {
+  return JSON.stringify({
+    baseUrl: baseUrl.replace(/\/$/, ""),
+    version: SDK_VERSION,
+    apiContract: SDK_API_CONTRACT,
+    command: command?.trim() || null
+  });
+}
+function readCachedCompatibility(baseUrl, command) {
+  try {
+    const path = compatibilityCachePath();
+    if (!(0, import_node_fs3.existsSync)(path)) {
+      return null;
+    }
+    const parsed = JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
+    const entry = parsed.entries?.[compatibilityCacheKey(baseUrl, command)];
+    if (!entry || Date.now() - entry.savedAt > COMPAT_CACHE_TTL_MS) {
+      return null;
+    }
+    return entry.response;
+  } catch {
+    return null;
+  }
+}
+function writeCachedCompatibility(baseUrl, command, response) {
+  try {
+    const path = compatibilityCachePath();
+    const existing = (0, import_node_fs3.existsSync)(path) ? JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8")) : {};
+    const entries = existing.entries ?? {};
+    entries[compatibilityCacheKey(baseUrl, command)] = {
+      savedAt: Date.now(),
+      response
+    };
+    (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(path), { recursive: true });
+    (0, import_node_fs3.writeFileSync)(path, `${JSON.stringify({ entries }, null, 2)}
+`);
+  } catch {
+  }
+}
 async function checkSdkCompatibility(baseUrl, options = {}) {
   if (shouldSkipCompatibilityCheck()) {
     return { response: null, error: null };
@@ -3489,8 +3535,15 @@ async function checkSdkCompatibility(baseUrl, options = {}) {
       signal: controller.signal
     });
     const data = await response.json().catch(() => null);
+    if (data) {
+      writeCachedCompatibility(baseUrl, options.command, data);
+    }
     return { response: data, error: null };
   } catch (error) {
+    const cached = readCachedCompatibility(baseUrl, options.command);
+    if (cached?.ok === false || cached?.status === "unsupported") {
+      return { response: cached, error: null };
+    }
     return {
       response: null,
       error: error instanceof Error ? error : new Error(String(error))
@@ -3513,15 +3566,15 @@ function enforceSdkCompatibilityResponse(response) {
 }
 
 // src/cli/commands/auth.ts
-var import_node_fs4 = require("fs");
-var import_node_os4 = require("os");
-var import_node_path4 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path5 = require("path");
 
 // src/cli/utils.ts
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_os3 = require("os");
-var import_node_path3 = require("path");
+var import_node_os4 = require("os");
+var import_node_path4 = require("path");
 var childProcess = __toESM(require("child_process"));
 var import_sync = require("csv-parse/sync");
 var import_sync2 = require("csv-stringify/sync");
@@ -3532,15 +3585,15 @@ function getAuthedHttpClient() {
   return { config, http: new HttpClient(config) };
 }
 async function writeOutputFile(filename, content) {
-  const outputDir = (0, import_node_path3.resolve)(process.cwd(), "deepline", "data");
+  const outputDir = (0, import_node_path4.resolve)(process.cwd(), "deepline", "data");
   await (0, import_promises.mkdir)(outputDir, { recursive: true });
-  const fullPath = (0, import_node_path3.join)(outputDir, filename);
+  const fullPath = (0, import_node_path4.join)(outputDir, filename);
   await (0, import_promises.writeFile)(fullPath, content, "utf-8");
   return fullPath;
 }
 function browserOpenStateFile() {
-  const homeDir2 = process.env.HOME || (0, import_node_os3.homedir)();
-  return (0, import_node_path3.join)(
+  const homeDir2 = process.env.HOME || (0, import_node_os4.homedir)();
+  return (0, import_node_path4.join)(
     homeDir2,
     ".local",
     "deepline",
@@ -3554,16 +3607,16 @@ function claimBrowserOpen(now = Date.now()) {
   const lockPath = `${statePath}.lock`;
   let locked = false;
   try {
-    (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(statePath), { recursive: true });
+    (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(statePath), { recursive: true });
     try {
-      (0, import_node_fs3.mkdirSync)(lockPath);
+      (0, import_node_fs4.mkdirSync)(lockPath);
       locked = true;
     } catch {
       return false;
     }
     let lastOpenedAt = 0;
-    if ((0, import_node_fs3.existsSync)(statePath)) {
-      const payload = JSON.parse((0, import_node_fs3.readFileSync)(statePath, "utf-8"));
+    if ((0, import_node_fs4.existsSync)(statePath)) {
+      const payload = JSON.parse((0, import_node_fs4.readFileSync)(statePath, "utf-8"));
       const value = payload.lastOpenedAt ?? payload.last_opened_at ?? payload.lastFocusedAt ?? payload.last_focused_at;
       if (typeof value === "number" && Number.isFinite(value)) {
         lastOpenedAt = value;
@@ -3575,13 +3628,13 @@ function claimBrowserOpen(now = Date.now()) {
     if (now - lastOpenedAt < BROWSER_OPEN_COOLDOWN_MS) {
       return false;
     }
-    (0, import_node_fs3.writeFileSync)(statePath, JSON.stringify({ lastOpenedAt: now }), "utf-8");
+    (0, import_node_fs4.writeFileSync)(statePath, JSON.stringify({ lastOpenedAt: now }), "utf-8");
     return true;
   } catch {
     return true;
   } finally {
     if (locked) {
-      (0, import_node_fs3.rmSync)(lockPath, { recursive: true, force: true });
+      (0, import_node_fs4.rmSync)(lockPath, { recursive: true, force: true });
     }
   }
 }
@@ -3616,7 +3669,7 @@ function readDefaultMacBrowserBundleId(runner = defaultBrowserCommandRunner) {
         "json",
         "-o",
         "-",
-        `${(0, import_node_os3.homedir)()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`
+        `${(0, import_node_os4.homedir)()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`
       ],
       { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     );
@@ -3787,7 +3840,7 @@ function collectLocalEnvInfo() {
   const info = {
     os: `${process.platform} ${process.arch}`,
     node_version: process.version,
-    home_dir: (0, import_node_os3.homedir)(),
+    home_dir: (0, import_node_os4.homedir)(),
     agent_runtime: detectAgentRuntime2()
   };
   const env = process.env;
@@ -3816,7 +3869,7 @@ function detectAgentRuntime2() {
   if (process.env.CODEX_THREAD_ID?.trim()) return "codex";
   const pluginMode = process.env.DEEPLINE_PLUGIN_MODE?.trim().toLowerCase();
   const claudeRemote = process.env.CLAUDE_CODE_REMOTE?.trim().toLowerCase();
-  const sessionHome = (process.env.HOME?.trim() || (0, import_node_os3.homedir)()).startsWith(
+  const sessionHome = (process.env.HOME?.trim() || (0, import_node_os4.homedir)()).startsWith(
     "/sessions/"
   );
   if (["1", "true", "yes", "on"].includes(pluginMode ?? "") && (["1", "true", "yes", "on"].includes(claudeRemote ?? "") || Boolean(process.env.CLAUDE_PROJECT_DIR?.trim()) || sessionHome)) {
@@ -3833,7 +3886,7 @@ function detectAgentRuntime2() {
   return "unknown";
 }
 function readCsvRows(csvPath) {
-  const raw = (0, import_node_fs3.readFileSync)((0, import_node_path3.resolve)(csvPath), "utf-8");
+  const raw = (0, import_node_fs4.readFileSync)((0, import_node_path4.resolve)(csvPath), "utf-8");
   return (0, import_sync.parse)(raw, {
     columns: true,
     skip_empty_lines: true
@@ -4067,25 +4120,25 @@ function pendingClaimTokenPath(baseUrl) {
 }
 function savePendingClaimToken(baseUrl, claimToken) {
   const filePath = pendingClaimTokenPath(baseUrl);
-  const dir = (0, import_node_path4.dirname)(filePath);
-  if (!(0, import_node_fs4.existsSync)(dir)) {
-    (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.dirname)(filePath);
+  if (!(0, import_node_fs5.existsSync)(dir)) {
+    (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs4.writeFileSync)(filePath, `${claimToken}
+  (0, import_node_fs5.writeFileSync)(filePath, `${claimToken}
 `, "utf-8");
 }
 function readPendingClaimToken(baseUrl) {
   const filePath = pendingClaimTokenPath(baseUrl);
-  if (!(0, import_node_fs4.existsSync)(filePath)) return "";
+  if (!(0, import_node_fs5.existsSync)(filePath)) return "";
   try {
-    return (0, import_node_fs4.readFileSync)(filePath, "utf-8").trim();
+    return (0, import_node_fs5.readFileSync)(filePath, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function clearPendingClaimToken(baseUrl) {
   try {
-    (0, import_node_fs4.rmSync)(pendingClaimTokenPath(baseUrl), { force: true });
+    (0, import_node_fs5.rmSync)(pendingClaimTokenPath(baseUrl), { force: true });
   } catch {
   }
 }
@@ -4204,7 +4257,7 @@ async function handleRegister(args) {
   }
   if (!agentName) {
     try {
-      agentName = (0, import_node_os4.hostname)() || "Deepline CLI (TS)";
+      agentName = (0, import_node_os5.hostname)() || "Deepline CLI (TS)";
     } catch {
       agentName = "Deepline CLI (TS)";
     }
@@ -4615,7 +4668,7 @@ Examples:
 // src/cli/commands/billing.ts
 var import_commander = require("commander");
 var import_promises2 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 var import_sync3 = require("csv-stringify/sync");
 var SUBSCRIPTION_STATUS_NEXT_COMMAND = "deepline billing subscription status --json";
 var SUBSCRIPTION_CANCEL_PATH = "/api/v2/billing/subscription/cancel";
@@ -4726,7 +4779,7 @@ function ledgerRowsToCsv(rows, header) {
   });
 }
 function defaultLedgerExportPath() {
-  return (0, import_node_path5.resolve)(
+  return (0, import_node_path6.resolve)(
     process.cwd(),
     "deepline",
     "data",
@@ -4891,7 +4944,7 @@ async function handleHistory(options) {
 }
 async function handleLedgerExportAll(options) {
   const { http } = getAuthedHttpClient();
-  const outputPath = options.output ? (0, import_node_path5.resolve)(String(options.output)) : defaultLedgerExportPath();
+  const outputPath = options.output ? (0, import_node_path6.resolve)(String(options.output)) : defaultLedgerExportPath();
   let summary = { row_count: 0, net_delta_credits: 0 };
   let cursor = null;
   let initializedOutput = false;
@@ -4904,7 +4957,7 @@ async function handleLedgerExportAll(options) {
     const entries = Array.isArray(payload.entries) ? payload.entries : [];
     const rows = entries.map(ledgerApiEntryToRow);
     if (!initializedOutput) {
-      await (0, import_promises2.mkdir)((0, import_node_path5.dirname)(outputPath), { recursive: true });
+      await (0, import_promises2.mkdir)((0, import_node_path6.dirname)(outputPath), { recursive: true });
       await (0, import_promises2.writeFile)(outputPath, ledgerRowsToCsv([], true), "utf-8");
       initializedOutput = true;
     }
@@ -5528,8 +5581,8 @@ Examples:
 }
 
 // src/cli/dataset-stats.ts
-var import_node_fs5 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
 
 // ../shared_libs/plays/dataset-summary.ts
 function formatDatasetRowCountsLine(counts) {
@@ -6136,8 +6189,8 @@ function writeCanonicalRowsCsv(rowsInfo, outPath) {
   });
   const rows = dataExportRows(sanitized.rows);
   const columns = dataExportColumns(rows, sanitized.columns);
-  const resolved = (0, import_node_path6.resolve)(outPath);
-  (0, import_node_fs5.writeFileSync)(resolved, csvStringFromRows(rows, columns), "utf-8");
+  const resolved = (0, import_node_path7.resolve)(outPath);
+  (0, import_node_fs6.writeFileSync)(resolved, csvStringFromRows(rows, columns), "utf-8");
   return resolved;
 }
 
@@ -6273,8 +6326,8 @@ Examples:
 }
 
 // src/cli/commands/db.ts
-var import_node_fs6 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path8 = require("path");
 var CUSTOMER_DB_QUERY_FORMATS = /* @__PURE__ */ new Set(["table", "json", "csv", "markdown"]);
 function parsePositiveInteger(value, flagName) {
   const parsed = Number.parseInt(value, 10);
@@ -6387,8 +6440,8 @@ function formatDbQueryError(sql, error) {
   return errorMessage(error);
 }
 function writeCustomerDbCsv(result, outPath) {
-  const resolved = (0, import_node_path7.resolve)(outPath);
-  (0, import_node_fs6.writeFileSync)(
+  const resolved = (0, import_node_path8.resolve)(outPath);
+  (0, import_node_fs7.writeFileSync)(
     resolved,
     dataExportCsvString(customerDbRows(result), customerDbColumnNames(result)),
     "utf-8"
@@ -6500,8 +6553,8 @@ async function handleDbQuery(args) {
       customerDbColumnNames(result)
     );
     if (outPath) {
-      const exportedPath = (0, import_node_path7.resolve)(outPath);
-      (0, import_node_fs6.writeFileSync)(exportedPath, content, "utf-8");
+      const exportedPath = (0, import_node_path8.resolve)(outPath);
+      (0, import_node_fs7.writeFileSync)(exportedPath, content, "utf-8");
       printCommandEnvelope(
         dbQueryExportEnvelope({
           result,
@@ -6603,27 +6656,27 @@ Examples:
 
 // src/cli/commands/enrich.ts
 var import_promises5 = require("fs/promises");
-var import_node_os7 = require("os");
-var import_node_path13 = require("path");
+var import_node_os8 = require("os");
+var import_node_path14 = require("path");
 
 // src/cli/commands/play.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs10 = require("fs");
-var import_node_path12 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path13 = require("path");
 var import_sync5 = require("csv-parse/sync");
 
 // src/plays/bundle-play-file.ts
-var import_node_os6 = require("os");
-var import_node_path10 = require("path");
+var import_node_os7 = require("os");
+var import_node_path11 = require("path");
 var import_node_url = require("url");
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 
 // ../shared_libs/plays/bundling/index.ts
 var import_node_crypto = require("crypto");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_promises3 = require("fs/promises");
-var import_node_os5 = require("os");
-var import_node_path8 = require("path");
+var import_node_os6 = require("os");
+var import_node_path9 = require("path");
 var import_node_module = require("module");
 var import_esbuild = require("esbuild");
 
@@ -6736,8 +6789,8 @@ var MAX_ESM_WORKERS_BUNDLE_BYTES = 115e4;
 
 // ../shared_libs/plays/bundling/index.ts
 var PLAY_BUNDLE_CACHE_VERSION = 24;
-var PLAY_ARTIFACT_CACHE_DIR = (0, import_node_path8.join)(
-  (0, import_node_os5.tmpdir)(),
+var PLAY_ARTIFACT_CACHE_DIR = (0, import_node_path9.join)(
+  (0, import_node_os6.tmpdir)(),
   `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`
 );
 var PLAY_PROXY_NAMESPACE = "deepline-play-runtime-ref";
@@ -6781,13 +6834,13 @@ async function normalizeLocalPath(filePath) {
   try {
     return await (0, import_promises3.realpath)(filePath);
   } catch {
-    return (0, import_node_path8.resolve)(filePath);
+    return (0, import_node_path9.resolve)(filePath);
   }
 }
 function createPlayWorkspace(entryFile) {
   return {
     entryFile,
-    rootDir: (0, import_node_path8.dirname)(entryFile)
+    rootDir: (0, import_node_path9.dirname)(entryFile)
   };
 }
 function isPathInsideDirectory(filePath, directory) {
@@ -6954,9 +7007,74 @@ function extractDefinedPlayName(sourceCode) {
   }
   return null;
 }
+function canonicalizeRootPlayNameForWorkersRuntimeHash(sourceCode) {
+  const source = stripCommentsToSpaces(sourceCode);
+  const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
+  const match = callPattern.exec(source);
+  if (!match) return sourceCode;
+  const openParen = match.index + match[0].length - 1;
+  const firstArgStart = openParen + 1;
+  const firstNonSpace = source.slice(firstArgStart).search(/\S/);
+  if (firstNonSpace < 0) return sourceCode;
+  const argIndex = firstArgStart + firstNonSpace;
+  const quote = source[argIndex];
+  if (quote === '"' || quote === "'") {
+    const literalMatch = source.slice(argIndex).match(/^(['"])(?:\\.|(?!\1)[\s\S])*\1/);
+    if (!literalMatch) return sourceCode;
+    const replacement = `${quote}__deepline_runtime_play_name__${quote}`;
+    return `${sourceCode.slice(0, argIndex)}${replacement}${sourceCode.slice(argIndex + literalMatch[0].length)}`;
+  }
+  if (quote !== "{") return sourceCode;
+  const closeBrace = findMatchingBrace(source, argIndex);
+  if (closeBrace < 0) return sourceCode;
+  const objectSource = source.slice(argIndex + 1, closeBrace);
+  const idMatch = objectSource.match(
+    /(^|[,{\s])((?:id|['"]id['"])\s*:\s*)(['"])([\s\S]*?)\3/
+  );
+  if (!idMatch || idMatch.index === void 0) return sourceCode;
+  const idValueStart = argIndex + 1 + idMatch.index + idMatch[1].length + idMatch[2].length + idMatch[3].length;
+  return `${sourceCode.slice(0, idValueStart)}__deepline_runtime_play_name__${sourceCode.slice(idValueStart + idMatch[4].length)}`;
+}
+function workersRuntimeGraphFilePath(input2) {
+  if (input2.filePath === input2.entryFile) return "<entry>";
+  const entryRelative = (0, import_node_path9.relative)((0, import_node_path9.dirname)(input2.entryFile), input2.filePath);
+  if (entryRelative && !entryRelative.startsWith("..")) {
+    return entryRelative.replaceAll("\\", "/");
+  }
+  return `<project>/${(0, import_node_path9.relative)(input2.adapter.projectRoot, input2.filePath).replaceAll("\\", "/")}`;
+}
+function buildWorkersRuntimeGraphHash(input2) {
+  const sourceFiles = Object.entries(input2.analysis.sourceFiles).map(([filePath, contents]) => ({
+    filePath: workersRuntimeGraphFilePath({
+      entryFile: input2.entryFile,
+      filePath,
+      adapter: input2.adapter
+    }),
+    hash: sha256(
+      filePath === input2.entryFile ? canonicalizeRootPlayNameForWorkersRuntimeHash(contents) : contents
+    )
+  })).sort((left, right) => left.filePath.localeCompare(right.filePath));
+  return sha256(
+    JSON.stringify({
+      entryFile: "<entry>",
+      entryExport: input2.exportName,
+      localFiles: sourceFiles,
+      nodeBuiltins: [...input2.analysis.importPolicy.nodeBuiltins].sort(),
+      packages: input2.analysis.importPolicy.packages.map(({ name, version }) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name)),
+      importedPlayDependencies: input2.analysis.importedPlayDependencies.map((dependency) => ({
+        filePath: workersRuntimeGraphFilePath({
+          entryFile: input2.entryFile,
+          filePath: dependency.filePath,
+          adapter: input2.adapter
+        }),
+        playName: dependency.playName
+      })).sort((left, right) => left.filePath.localeCompare(right.filePath))
+    })
+  );
+}
 function readPackageVersionFromPackageJson(packageJsonPath, packageName) {
   try {
-    const packageJson = JSON.parse((0, import_node_fs7.readFileSync)(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse((0, import_node_fs8.readFileSync)(packageJsonPath, "utf-8"));
     if (packageJson.name === packageName && typeof packageJson.version === "string") {
       return packageJson.version;
     }
@@ -6966,23 +7084,23 @@ function readPackageVersionFromPackageJson(packageJsonPath, packageName) {
   return null;
 }
 function findPackageJsonPathFrom(startDir, packageName) {
-  if (!(0, import_node_path8.isAbsolute)(startDir)) {
+  if (!(0, import_node_path9.isAbsolute)(startDir)) {
     throw new Error(
       `Package resolution requires an absolute start directory, got ${startDir}`
     );
   }
   let current = startDir;
   while (true) {
-    const packageJsonPath = (0, import_node_path8.join)(
+    const packageJsonPath = (0, import_node_path9.join)(
       current,
       "node_modules",
       packageName,
       "package.json"
     );
-    if ((0, import_node_fs7.existsSync)(packageJsonPath)) {
+    if ((0, import_node_fs8.existsSync)(packageJsonPath)) {
       return packageJsonPath;
     }
-    const parent = (0, import_node_path8.dirname)(current);
+    const parent = (0, import_node_path9.dirname)(current);
     if (parent === current) {
       return null;
     }
@@ -6991,9 +7109,9 @@ function findPackageJsonPathFrom(startDir, packageName) {
 }
 function findPackageJsonPath(packageName, fromFile, adapter) {
   const startDirs = [
-    (0, import_node_path8.resolve)((0, import_node_path8.dirname)(fromFile)),
-    (0, import_node_path8.resolve)(adapter.projectRoot),
-    (0, import_node_path8.resolve)((0, import_node_path8.dirname)(adapter.sdkPackageJson))
+    (0, import_node_path9.resolve)((0, import_node_path9.dirname)(fromFile)),
+    (0, import_node_path9.resolve)(adapter.projectRoot),
+    (0, import_node_path9.resolve)((0, import_node_path9.dirname)(adapter.sdkPackageJson))
   ];
   const seen = /* @__PURE__ */ new Set();
   for (const startDir of startDirs) {
@@ -7002,16 +7120,16 @@ function findPackageJsonPath(packageName, fromFile, adapter) {
     const packageJsonPath = findPackageJsonPathFrom(startDir, packageName);
     if (packageJsonPath) return packageJsonPath;
   }
-  const adapterNodeModulesPackageJson = (0, import_node_path8.join)(
+  const adapterNodeModulesPackageJson = (0, import_node_path9.join)(
     adapter.nodeModulesDir,
     packageName,
     "package.json"
   );
-  return (0, import_node_fs7.existsSync)(adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
+  return (0, import_node_fs8.existsSync)(adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
 }
 function localSdkAliasPlugin(adapter, options) {
   const entryFile = options?.workersRuntime ? adapter.sdkWorkersEntryFile : adapter.sdkEntryFile;
-  if (!(0, import_node_fs7.existsSync)(entryFile)) {
+  if (!(0, import_node_fs8.existsSync)(entryFile)) {
     return null;
   }
   return {
@@ -7021,7 +7139,7 @@ function localSdkAliasPlugin(adapter, options) {
         path: entryFile
       }));
       buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
-        path: (0, import_node_path8.join)(adapter.sdkSourceRoot, "helpers.ts")
+        path: (0, import_node_path9.join)(adapter.sdkSourceRoot, "helpers.ts")
       }));
     }
   };
@@ -7054,7 +7172,7 @@ function workersNamedPlayEntryAliasPlugin(playFilePath, exportName) {
           contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};
 `,
           loader: "ts",
-          resolveDir: (0, import_node_path8.dirname)(playFilePath)
+          resolveDir: (0, import_node_path9.dirname)(playFilePath)
         })
       );
     }
@@ -7225,7 +7343,7 @@ function importedPlayProxyPlugin(importedPlayDependencies) {
           return {
             contents: buildImportedPlayProxyModule(dependency.playName),
             loader: "ts",
-            resolveDir: (0, import_node_path8.dirname)(args.path)
+            resolveDir: (0, import_node_path9.dirname)(args.path)
           };
         }
       );
@@ -7244,15 +7362,15 @@ async function resolveLocalImport(fromFile, specifier) {
   if (specifier.startsWith("file:")) {
     return normalizeLocalPath(new URL(specifier).pathname);
   }
-  const base = (0, import_node_path8.isAbsolute)(specifier) ? (0, import_node_path8.resolve)(specifier) : (0, import_node_path8.resolve)((0, import_node_path8.dirname)(fromFile), specifier);
+  const base = (0, import_node_path9.isAbsolute)(specifier) ? (0, import_node_path9.resolve)(specifier) : (0, import_node_path9.resolve)((0, import_node_path9.dirname)(fromFile), specifier);
   const candidates = [base];
-  const explicitExtension = (0, import_node_path8.extname)(base).toLowerCase();
+  const explicitExtension = (0, import_node_path9.extname)(base).toLowerCase();
   if (!explicitExtension) {
     candidates.push(
       ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
     );
     candidates.push(
-      ...SOURCE_EXTENSIONS.map((extension) => (0, import_node_path8.join)(base, `index${extension}`))
+      ...SOURCE_EXTENSIONS.map((extension) => (0, import_node_path9.join)(base, `index${extension}`))
     );
   } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
     const stem = base.slice(0, -explicitExtension.length);
@@ -7271,9 +7389,9 @@ async function resolveLocalImport(fromFile, specifier) {
 }
 function resolvePackageImport(specifier, fromFile, adapter) {
   const packageName = getPackageName(specifier);
-  if (packageName === "deepline" && (0, import_node_fs7.existsSync)(adapter.sdkPackageJson)) {
+  if (packageName === "deepline" && (0, import_node_fs8.existsSync)(adapter.sdkPackageJson)) {
     const packageJson = JSON.parse(
-      (0, import_node_fs7.readFileSync)(adapter.sdkPackageJson, "utf-8")
+      (0, import_node_fs8.readFileSync)(adapter.sdkPackageJson, "utf-8")
     );
     return {
       name: "deepline",
@@ -7305,7 +7423,7 @@ async function analyzeSourceGraph(entryFile, adapter) {
     visited.add(absolutePath);
     const sourceCode2 = await (0, import_promises3.readFile)(absolutePath, "utf-8");
     localFiles.set(absolutePath, sourceCode2);
-    if ((0, import_node_path8.extname)(absolutePath).toLowerCase() === ".json") {
+    if ((0, import_node_path9.extname)(absolutePath).toLowerCase() === ".json") {
       return;
     }
     const handleSpecifier = async (specifier, line, column, kind) => {
@@ -7416,7 +7534,7 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
   const addFilePart = async (parts2, rootDir, filePath) => {
     const contents = await (0, import_promises3.readFile)(filePath, "utf-8");
     parts2.push({
-      name: `${(0, import_node_path8.basename)(rootDir)}:${filePath.slice(rootDir.length + 1)}`,
+      name: `${(0, import_node_path9.basename)(rootDir)}:${filePath.slice(rootDir.length + 1)}`,
       hash: sha256(contents)
     });
   };
@@ -7425,7 +7543,7 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
     const entries2 = await readdir(rootDir, { withFileTypes: true });
     const tsFiles2 = entries2.filter((entry) => entry.isFile() && /\.[cm]?ts$/.test(entry.name)).map((entry) => entry.name).sort();
     for (const name of tsFiles2) {
-      await addFilePart(parts2, rootDir, (0, import_node_path8.join)(rootDir, name));
+      await addFilePart(parts2, rootDir, (0, import_node_path9.join)(rootDir, name));
     }
   };
   const collectIntegrationBatchingFiles = async (rootDir, parts2) => {
@@ -7434,10 +7552,10 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
     const filePaths = [];
     for (const entry of entries2) {
       if (entry.isFile() && (entry.name === "play-runtime-batching-registry.ts" || /^batching.*\.ts$/.test(entry.name))) {
-        filePaths.push((0, import_node_path8.join)(rootDir, entry.name));
+        filePaths.push((0, import_node_path9.join)(rootDir, entry.name));
       }
       if (entry.isDirectory()) {
-        const batchingFile = (0, import_node_path8.join)(rootDir, entry.name, "batching.ts");
+        const batchingFile = (0, import_node_path9.join)(rootDir, entry.name, "batching.ts");
         if (await fileExists(batchingFile)) {
           filePaths.push(batchingFile);
         }
@@ -7456,11 +7574,11 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
     await addFilePart(
       parts,
       adapter.workersHarnessFilesDir,
-      (0, import_node_path8.join)(adapter.workersHarnessFilesDir, name)
+      (0, import_node_path9.join)(adapter.workersHarnessFilesDir, name)
     );
   }
   for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
-    if ((0, import_node_path8.basename)(dir) === "integrations") {
+    if ((0, import_node_path9.basename)(dir) === "integrations") {
       await collectIntegrationBatchingFiles(dir, parts);
     } else {
       await collectTopLevelTsFiles(dir, parts);
@@ -7469,7 +7587,7 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
   return sha256(JSON.stringify(parts));
 }
 function artifactCachePath(graphHash, artifactKind, adapter) {
-  return (0, import_node_path8.join)(
+  return (0, import_node_path9.join)(
     adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR,
     `${graphHash}.${artifactKind}.json`
   );
@@ -7504,7 +7622,7 @@ function normalizeSourceMapForRuntime(sourceMapText, projectRoot) {
     if (sourcePath.startsWith("data:") || sourcePath.startsWith("node:") || sourcePath.startsWith("/") || /^[a-zA-Z]+:\/\//.test(sourcePath)) {
       return sourcePath;
     }
-    return (0, import_node_path8.join)(projectRoot, sourcePath);
+    return (0, import_node_path9.join)(projectRoot, sourcePath);
   });
   parsed.sourceRoot = void 0;
   return JSON.stringify(parsed);
@@ -7536,8 +7654,8 @@ async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter
     ...namedExportShim ? {
       stdin: {
         contents: namedExportShim,
-        resolveDir: (0, import_node_path8.dirname)(entryFile),
-        sourcefile: `${(0, import_node_path8.basename)(entryFile)}.${exportName}.entry.ts`,
+        resolveDir: (0, import_node_path9.dirname)(entryFile),
+        sourcefile: `${(0, import_node_path9.basename)(entryFile)}.${exportName}.entry.ts`,
         loader: "ts"
       }
     } : { entryPoints: [entryFile] },
@@ -7686,10 +7804,13 @@ async function bundlePlayFile(filePath, options) {
   adapter.warnAboutNonDevelopmentBundling?.(absolutePath);
   try {
     const analysis = await analyzeSourceGraph(absolutePath, adapter);
-    analysis.graphHash = sha256(
-      `${analysis.graphHash}
-entry-export:${exportName}`
-    );
+    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(
@@ -7725,11 +7846,8 @@ workers-harness:${harnessFingerprint}`
         errors: typecheckErrors
       };
     }
-    const cachedArtifact = await readArtifactCache(
-      analysis.graphHash,
-      target,
-      adapter
-    );
+    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(
@@ -7746,7 +7864,13 @@ workers-harness:${harnessFingerprint}`
       }
       return {
         success: true,
-        artifact: { ...cachedArtifact, cacheHit: true },
+        artifact: {
+          ...cachedArtifact,
+          entryFile: absolutePath,
+          sourceHash: analysis.sourceHash,
+          importPolicy: analysis.importPolicy,
+          cacheHit: true
+        },
         sourceCode: analysis.sourceCode,
         sourceFiles: analysis.sourceFiles,
         filePath: absolutePath,
@@ -7772,12 +7896,12 @@ workers-harness:${harnessFingerprint}`
     const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
     const normalizedSourceMap = normalizeSourceMapForRuntime(
       sourceMapText,
-      (0, import_node_path8.resolve)(adapter.projectRoot)
+      (0, import_node_path9.resolve)(adapter.projectRoot)
     );
-    const virtualBaseName = exportName === "default" ? (0, import_node_path8.basename)(absolutePath).replace(/\.[^.]+$/, "") : `${(0, import_node_path8.basename)(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
+    const virtualBaseName = exportName === "default" ? (0, import_node_path9.basename)(absolutePath).replace(/\.[^.]+$/, "") : `${(0, import_node_path9.basename)(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
     const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
     const executableCode = `${bundledCode}
-//# sourceMappingURL=${(0, import_node_path8.basename)(virtualFilename)}.map
+//# sourceMappingURL=${(0, import_node_path9.basename)(virtualFilename)}.map
 `;
     const bundleSizeError = getBundleSizeError(
       absolutePath,
@@ -7807,7 +7931,9 @@ workers-harness:${harnessFingerprint}`
       generatedAt: Date.now(),
       cacheHit: false
     };
-    await writeArtifactCache(artifact, adapter);
+    if (canUseArtifactCache) {
+      await writeArtifactCache(artifact, adapter);
+    }
     return {
       success: true,
       artifact,
@@ -7929,7 +8055,7 @@ function resolveExecutionProfile(override) {
 // src/plays/local-file-discovery.ts
 var import_node_crypto2 = require("crypto");
 var import_promises4 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 var SOURCE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -7945,7 +8071,7 @@ function sha2562(buffer) {
   return (0, import_node_crypto2.createHash)("sha256").update(buffer).digest("hex");
 }
 function contentTypeForFile(filePath) {
-  const extension = (0, import_node_path9.extname)(filePath).toLowerCase();
+  const extension = (0, import_node_path10.extname)(filePath).toLowerCase();
   if (extension === ".csv") return "text/csv";
   if (extension === ".json") return "application/json";
   if (extension === ".txt") return "text/plain";
@@ -8144,19 +8270,19 @@ async function fileExists2(filePath) {
   }
 }
 function isPathInsideDirectory2(filePath, directory) {
-  const relativePath = (0, import_node_path9.relative)(directory, filePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !(0, import_node_path9.isAbsolute)(relativePath);
+  const relativePath = (0, import_node_path10.relative)(directory, filePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !(0, import_node_path10.isAbsolute)(relativePath);
 }
 async function resolveLocalImport2(fromFile, specifier) {
-  const base = (0, import_node_path9.isAbsolute)(specifier) ? (0, import_node_path9.resolve)(specifier) : (0, import_node_path9.resolve)((0, import_node_path9.dirname)(fromFile), specifier);
+  const base = (0, import_node_path10.isAbsolute)(specifier) ? (0, import_node_path10.resolve)(specifier) : (0, import_node_path10.resolve)((0, import_node_path10.dirname)(fromFile), specifier);
   const candidates = [base];
-  const explicitExtension = (0, import_node_path9.extname)(base).toLowerCase();
+  const explicitExtension = (0, import_node_path10.extname)(base).toLowerCase();
   if (!explicitExtension) {
     candidates.push(
       ...SOURCE_EXTENSIONS2.map((extension) => `${base}${extension}`)
     );
     candidates.push(
-      ...SOURCE_EXTENSIONS2.map((extension) => (0, import_node_path9.join)(base, `index${extension}`))
+      ...SOURCE_EXTENSIONS2.map((extension) => (0, import_node_path10.join)(base, `index${extension}`))
     );
   } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
     const stem = base.slice(0, -explicitExtension.length);
@@ -8174,13 +8300,13 @@ async function resolveLocalImport2(fromFile, specifier) {
   );
 }
 async function discoverPackagedLocalFiles(entryFile) {
-  const absoluteEntryFile = (0, import_node_path9.resolve)(entryFile);
-  const packagingRoot = (0, import_node_path9.dirname)(absoluteEntryFile);
+  const absoluteEntryFile = (0, import_node_path10.resolve)(entryFile);
+  const packagingRoot = (0, import_node_path10.dirname)(absoluteEntryFile);
   const files = /* @__PURE__ */ new Map();
   const unresolved = [];
   const visitedFiles = /* @__PURE__ */ new Set();
   const visitSourceFile = async (filePath) => {
-    const absolutePath = (0, import_node_path9.resolve)(filePath);
+    const absolutePath = (0, import_node_path10.resolve)(filePath);
     if (visitedFiles.has(absolutePath)) {
       return;
     }
@@ -8217,8 +8343,8 @@ async function discoverPackagedLocalFiles(entryFile) {
             message: "Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file."
           });
         } else {
-          const absoluteCsvPath = (0, import_node_path9.resolve)((0, import_node_path9.dirname)(absolutePath), resolvedPath);
-          if ((0, import_node_path9.isAbsolute)(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
+          const absoluteCsvPath = (0, import_node_path10.resolve)((0, import_node_path10.dirname)(absolutePath), resolvedPath);
+          if ((0, import_node_path10.isAbsolute)(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
             unresolved.push({
               sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
               message: "ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead."
@@ -8257,30 +8383,30 @@ async function discoverPackagedLocalFiles(entryFile) {
 // src/plays/bundle-play-file.ts
 var import_meta = {};
 var PLAY_BUNDLE_CACHE_VERSION2 = 30;
-var MODULE_DIR = (0, import_node_path10.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-var SDK_PACKAGE_ROOT = (0, import_node_path10.resolve)(MODULE_DIR, "..", "..");
-var SOURCE_REPO_ROOT = (0, import_node_path10.resolve)(SDK_PACKAGE_ROOT, "..");
-var HAS_SOURCE_BUNDLING_SOURCES = (0, import_node_fs8.existsSync)(
-  (0, import_node_path10.resolve)(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
+var MODULE_DIR = (0, import_node_path11.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+var SDK_PACKAGE_ROOT = (0, import_node_path11.resolve)(MODULE_DIR, "..", "..");
+var SOURCE_REPO_ROOT = (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "..");
+var HAS_SOURCE_BUNDLING_SOURCES = (0, import_node_fs9.existsSync)(
+  (0, import_node_path11.resolve)(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
-var PACKAGED_REPO_ROOT = (0, import_node_path10.resolve)(SDK_PACKAGE_ROOT, "dist", "repo");
-var HAS_PACKAGED_BUNDLING_SOURCES = (0, import_node_fs8.existsSync)(
-  (0, import_node_path10.resolve)(PACKAGED_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
+var PACKAGED_REPO_ROOT = (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "dist", "repo");
+var HAS_PACKAGED_BUNDLING_SOURCES = (0, import_node_fs9.existsSync)(
+  (0, import_node_path11.resolve)(PACKAGED_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
-var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_REPO_ROOT : (0, import_node_path10.resolve)(SDK_PACKAGE_ROOT, "..");
-var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? (0, import_node_path10.resolve)(SOURCE_REPO_ROOT, "sdk", "src") : HAS_PACKAGED_BUNDLING_SOURCES ? (0, import_node_path10.resolve)(PACKAGED_REPO_ROOT, "sdk", "src") : (0, import_node_path10.resolve)(SDK_PACKAGE_ROOT, "src");
-var SDK_PACKAGE_JSON = (0, import_node_path10.resolve)(SDK_PACKAGE_ROOT, "package.json");
-var SDK_ENTRY_FILE = (0, import_node_path10.resolve)(SDK_SOURCE_ROOT, "index.ts");
-var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : (0, import_node_path10.resolve)(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
-var SDK_WORKERS_ENTRY_FILE = (0, import_node_path10.resolve)(SDK_SOURCE_ROOT, "worker-play-entry.ts");
-var WORKERS_HARNESS_ENTRY_FILE = (0, import_node_path10.resolve)(
+var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_REPO_ROOT : (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "..");
+var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? (0, import_node_path11.resolve)(SOURCE_REPO_ROOT, "sdk", "src") : HAS_PACKAGED_BUNDLING_SOURCES ? (0, import_node_path11.resolve)(PACKAGED_REPO_ROOT, "sdk", "src") : (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "src");
+var SDK_PACKAGE_JSON = (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "package.json");
+var SDK_ENTRY_FILE = (0, import_node_path11.resolve)(SDK_SOURCE_ROOT, "index.ts");
+var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : (0, import_node_path11.resolve)(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
+var SDK_WORKERS_ENTRY_FILE = (0, import_node_path11.resolve)(SDK_SOURCE_ROOT, "worker-play-entry.ts");
+var WORKERS_HARNESS_ENTRY_FILE = (0, import_node_path11.resolve)(
   PROJECT_ROOT,
   "apps",
   "play-runner-workers",
   "src",
   "entry.ts"
 );
-var WORKERS_HARNESS_FILES_DIR = (0, import_node_path10.resolve)(
+var WORKERS_HARNESS_FILES_DIR = (0, import_node_path11.resolve)(
   PROJECT_ROOT,
   "apps",
   "play-runner-workers",
@@ -8309,20 +8435,20 @@ function defaultPlayBundleTarget() {
 function createSdkPlayBundlingAdapter() {
   return {
     projectRoot: PROJECT_ROOT,
-    nodeModulesDir: (0, import_node_path10.resolve)(PROJECT_ROOT, "node_modules"),
-    cacheDir: (0, import_node_path10.join)(
-      (0, import_node_os6.tmpdir)(),
+    nodeModulesDir: (0, import_node_path11.resolve)(PROJECT_ROOT, "node_modules"),
+    cacheDir: (0, import_node_path11.join)(
+      (0, import_node_os7.tmpdir)(),
       `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION2}`
     ),
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !(0, import_node_fs8.existsSync)(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
+    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !(0, import_node_fs9.existsSync)(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
     sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
     workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
     workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
     workersRuntimeFingerprintDirs: [
-      (0, import_node_path10.resolve)(PROJECT_ROOT, "shared_libs", "play-runtime")
+      (0, import_node_path11.resolve)(PROJECT_ROOT, "shared_libs", "play-runtime")
     ],
     discoverPackagedLocalFiles,
     warnAboutNonDevelopmentBundling
@@ -8340,8 +8466,8 @@ async function bundlePlayFile2(filePath, options = {}) {
 }
 
 // src/cli/commands/plays/bootstrap.ts
-var import_node_fs9 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path12 = require("path");
 var import_sync4 = require("csv-parse/sync");
 
 // ../shared_libs/plays/bootstrap-routes.ts
@@ -8770,13 +8896,13 @@ function inferCsvColumnSpecs(headers, rows) {
   }));
 }
 function readCsvSample(csvPath) {
-  const resolvedPath = (0, import_node_path11.resolve)(csvPath);
-  const size = (0, import_node_fs9.statSync)(resolvedPath).size;
-  const fd = (0, import_node_fs9.openSync)(resolvedPath, "r");
+  const resolvedPath = (0, import_node_path12.resolve)(csvPath);
+  const size = (0, import_node_fs10.statSync)(resolvedPath).size;
+  const fd = (0, import_node_fs10.openSync)(resolvedPath, "r");
   const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
   const buffer = Buffer.alloc(byteLength);
-  const bytesRead = (0, import_node_fs9.readSync)(fd, buffer, 0, byteLength, 0);
-  (0, import_node_fs9.closeSync)(fd);
+  const bytesRead = (0, import_node_fs10.readSync)(fd, buffer, 0, byteLength, 0);
+  (0, import_node_fs10.closeSync)(fd);
   if (bytesRead === 0) {
     throw new PlayBootstrapUsageError(`--from csv:${csvPath} is empty.`);
   }
@@ -8845,9 +8971,9 @@ ${properties}
 }
 function packagedCsvPathForPlay(csvPath) {
   const playDir = process.cwd();
-  const absoluteCsvPath = (0, import_node_path11.resolve)(csvPath);
-  const relativePath = (0, import_node_path11.relative)(playDir, absoluteCsvPath);
-  if (relativePath === "" || relativePath.startsWith("..") || (0, import_node_path11.isAbsolute)(relativePath)) {
+  const absoluteCsvPath = (0, import_node_path12.resolve)(csvPath);
+  const relativePath = (0, import_node_path12.relative)(playDir, absoluteCsvPath);
+  if (relativePath === "" || relativePath.startsWith("..") || (0, import_node_path12.isAbsolute)(relativePath)) {
     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.`
     );
@@ -9766,8 +9892,8 @@ async function runPlayBootstrap(args) {
     ...csvContext
   });
   if (options.out) {
-    (0, import_node_fs9.writeFileSync)((0, import_node_path11.resolve)(options.out), source, "utf-8");
-    process.stdout.write(`Wrote ${(0, import_node_path11.resolve)(options.out)}
+    (0, import_node_fs10.writeFileSync)((0, import_node_path12.resolve)(options.out), source, "utf-8");
+    process.stdout.write(`Wrote ${(0, import_node_path12.resolve)(options.out)}
 `);
     return 0;
   }
@@ -10215,7 +10341,7 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return (0, import_node_path12.resolve)(defaultStarterPlayPath(reference));
+  return (0, import_node_path13.resolve)(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
   const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
@@ -10241,15 +10367,15 @@ function materializeRemotePlaySource(input2) {
     return null;
   }
   const outputPath = input2.outPath ?? defaultMaterializedPlayPath(input2.playName);
-  if ((0, import_node_fs10.existsSync)(outputPath)) {
-    const existingSource = (0, import_node_fs10.readFileSync)(outputPath, "utf-8");
+  if ((0, import_node_fs11.existsSync)(outputPath)) {
+    const existingSource = (0, import_node_fs11.readFileSync)(outputPath, "utf-8");
     if (existingSource === input2.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    (0, import_node_fs10.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
+    (0, import_node_fs11.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  (0, import_node_fs10.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
+  (0, import_node_fs11.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -10294,7 +10420,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return (0, import_node_fs10.existsSync)((0, import_node_path12.resolve)(target));
+  return (0, import_node_fs11.existsSync)((0, import_node_path13.resolve)(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -10323,7 +10449,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? (0, import_node_fs10.readFileSync)((0, import_node_path12.resolve)(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? (0, import_node_fs11.readFileSync)((0, import_node_path13.resolve)(raw.slice(1)), "utf-8") : raw;
   const parsed = JSON.parse(source);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("--input must be a JSON object.");
@@ -10425,7 +10551,7 @@ function fileInputBindingsFromStaticPipeline(staticPipeline) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return (0, import_node_fs10.existsSync)((0, import_node_path12.resolve)(value));
+  return (0, import_node_fs11.existsSync)((0, import_node_path13.resolve)(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -10441,6 +10567,15 @@ function inputContainsLocalFilePath(value) {
   }
   return false;
 }
+function sourceGraphMentionsRunPlay(node) {
+  const runPlayCallPattern = /\brunPlay\b/;
+  if (runPlayCallPattern.test(node.sourceCode)) {
+    return true;
+  }
+  return Object.values(node.sourceFiles).some(
+    (source) => runPlayCallPattern.test(source)
+  );
+}
 function isUrlValue(value) {
   return /^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim());
 }
@@ -10463,7 +10598,7 @@ function collectLocalFileInputRefs(value, inputPath, key, out) {
     const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
     if (keyIsCsvData) {
       out.push({ inputPath, value: trimmed, isCsvData: true });
-    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs10.existsSync)((0, import_node_path12.resolve)(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs11.existsSync)((0, import_node_path13.resolve)(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -10505,8 +10640,8 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = (0, import_node_path12.resolve)(ref.value);
-    if (!(0, import_node_fs10.existsSync)(absolutePath)) {
+    const absolutePath = (0, import_node_path13.resolve)(ref.value);
+    if (!(0, import_node_fs11.existsSync)(absolutePath)) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
         void 0,
@@ -10516,7 +10651,7 @@ function preflightLocalFileInputs(runtimeInput) {
     }
     let stat4;
     try {
-      stat4 = (0, import_node_fs10.statSync)(absolutePath);
+      stat4 = (0, import_node_fs11.statSync)(absolutePath);
     } catch (error) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that is not readable: ${ref.value} (${error instanceof Error ? error.message : String(error)}). No run was created.`,
@@ -10542,7 +10677,7 @@ function preflightLocalFileInputs(runtimeInput) {
 function preflightCsvDataInput(ref, absolutePath) {
   let content;
   try {
-    content = (0, import_node_fs10.readFileSync)(absolutePath, "utf-8");
+    content = (0, import_node_fs11.readFileSync)(absolutePath, "utf-8");
   } catch (error) {
     throw new DeeplineError(
       `Input ${ref.inputPath} CSV ${ref.value} is not readable: ${error instanceof Error ? error.message : String(error)}. No run was created.`,
@@ -10624,8 +10759,8 @@ async function stageFileInputArgs(input2) {
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input2.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = (0, import_node_path12.resolve)(value);
-    return [{ binding, absolutePath, logicalPath: (0, import_node_path12.basename)(absolutePath) }];
+    const absolutePath = (0, import_node_path13.resolve)(value);
+    return [{ binding, absolutePath, logicalPath: (0, import_node_path13.basename)(absolutePath) }];
   });
   if (localFiles.length === 0) {
     return { inputFile: null, packagedFiles: [] };
@@ -10657,7 +10792,7 @@ async function stageFileInputArgs(input2) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = (0, import_node_fs10.readFileSync)(absolutePath);
+  const buffer = (0, import_node_fs11.readFileSync)(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
@@ -10668,9 +10803,9 @@ function stageFile(logicalPath, absolutePath) {
 }
 function normalizePlayPath(filePath) {
   try {
-    return import_node_fs10.realpathSync.native((0, import_node_path12.resolve)(filePath));
+    return import_node_fs11.realpathSync.native((0, import_node_path13.resolve)(filePath));
   } catch {
-    return (0, import_node_path12.resolve)(filePath);
+    return (0, import_node_path13.resolve)(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -12626,7 +12761,7 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path12.resolve)(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path13.resolve)(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -13430,7 +13565,7 @@ async function handlePlayCheck(args) {
       }
       return 0;
     } catch (error) {
-      const resolved = (0, import_node_path12.resolve)(options.target);
+      const resolved = (0, import_node_path13.resolve)(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         process.stdout.write(
@@ -13447,8 +13582,8 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = (0, import_node_path12.resolve)(options.target);
-  const sourceCode = (0, import_node_fs10.readFileSync)(absolutePlayPath, "utf-8");
+  const absolutePlayPath = (0, import_node_path13.resolve)(options.target);
+  const sourceCode = (0, import_node_fs11.readFileSync)(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -13527,12 +13662,12 @@ async function handleFileBackedRun(options) {
   }
   const client2 = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = (0, import_node_path12.resolve)(options.target.path);
+  const absolutePlayPath = (0, import_node_path13.resolve)(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => (0, import_node_fs10.readFileSync)(absolutePlayPath, "utf-8")
+    () => (0, import_node_fs11.readFileSync)(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   try {
@@ -13548,11 +13683,23 @@ async function handleFileBackedRun(options) {
       { targetKind: "file" },
       () => collectBundledPlayGraph(absolutePlayPath, options.profile)
     );
-    await traceCliSpan(
-      "cli.play_file_compile_manifests",
-      { targetKind: "file" },
-      () => compileBundledPlayGraphManifests(client2, graph)
-    );
+    const canDeferCompilerManifest = graph.root.importedPlayDependencies.length === 0 && !sourceGraphMentionsRunPlay(graph.root) && !inputContainsLocalFilePath(runtimeInput);
+    if (canDeferCompilerManifest) {
+      recordCliTrace({
+        phase: "cli.play_file_compile_manifests",
+        ms: 0,
+        ok: true,
+        targetKind: "file",
+        skipped: true,
+        reason: "validated_by_run_route"
+      });
+    } else {
+      await traceCliSpan(
+        "cli.play_file_compile_manifests",
+        { targetKind: "file", skipped: false },
+        () => compileBundledPlayGraphManifests(client2, graph)
+      );
+    }
     progress.phase("compiled play");
   } catch (error) {
     progress.fail();
@@ -13579,9 +13726,9 @@ async function handleFileBackedRun(options) {
   const packagedFileUploads = bundleResult.packagedFiles.map(
     (file) => stageFile(file.logicalPath, file.absolutePath)
   );
-  const compilerManifest = requireCompilerManifest(bundleResult);
+  const compilerManifest = bundleResult.compilerManifest ?? null;
   const fileInputBindings = fileInputBindingsFromStaticPipeline(
-    compilerManifest.staticPipeline
+    compilerManifest?.staticPipeline
   );
   const stagedFileInputs = await traceCliSpan(
     "cli.play_stage_inputs",
@@ -13601,7 +13748,7 @@ async function handleFileBackedRun(options) {
     sourceCode: bundleResult.sourceCode,
     sourceFiles: bundleResult.sourceFiles,
     runtimeArtifact: bundleResult.artifact,
-    compilerManifest,
+    ...compilerManifest ? { compilerManifest } : {},
     packagedFileUploads,
     ...Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {},
     ...stagedFileInputs.inputFile ? { inputFile: stagedFileInputs.inputFile } : {},
@@ -13839,19 +13986,19 @@ async function handlePlayRun(args) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options);
     }
-    const resolved = (0, import_node_path12.resolve)(options.target.path);
+    const resolved = (0, import_node_path13.resolve)(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = (0, import_node_path12.dirname)(resolved);
-    if ((0, import_node_fs10.existsSync)(dir)) {
-      const base = (0, import_node_path12.basename)(resolved);
+    const dir = (0, import_node_path13.dirname)(resolved);
+    if ((0, import_node_fs11.existsSync)(dir)) {
+      const base = (0, import_node_path13.basename)(resolved);
       try {
-        const siblings = (0, import_node_fs10.readdirSync)(dir).filter(
+        const siblings = (0, import_node_fs11.readdirSync)(dir).filter(
           (f) => f.includes(base.replace(/\.(play\.)?ts$/, "")) || f.endsWith(".play.ts")
         );
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${(0, import_node_path12.join)(dir, s)}`);
+            console.error(`  ${(0, import_node_path13.join)(dir, s)}`);
           }
         }
       } catch {
@@ -14006,14 +14153,14 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path12.resolve)(args[++index]);
+      outPath = (0, import_node_path13.resolve)(args[++index]);
     }
   }
   const client2 = new DeeplineClient();
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
     const logs = result2.entries;
-    (0, import_node_fs10.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    (0, import_node_fs11.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
       {
         runId: result2.runId,
@@ -14138,7 +14285,7 @@ async function handleRunExport(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path12.resolve)(args[++index]);
+      outPath = (0, import_node_path13.resolve)(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -14146,7 +14293,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = (0, import_node_path12.resolve)(args[++index]);
+      metadataOutPath = (0, import_node_path13.resolve)(args[++index]);
     }
   }
   if (!outPath) {
@@ -14186,7 +14333,7 @@ async function handleRunExport(args) {
     }
   };
   if (metadataOutPath) {
-    (0, import_node_fs10.writeFileSync)(
+    (0, import_node_fs11.writeFileSync)(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -14218,10 +14365,10 @@ async function handlePlayGet(args) {
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path12.resolve)(args[++index]);
+      outPath = (0, import_node_path13.resolve)(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs10.readFileSync)((0, import_node_path12.resolve)(target), "utf-8"), (0, import_node_path12.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs11.readFileSync)((0, import_node_path13.resolve)(target), "utf-8"), (0, import_node_path13.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
   const 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({
@@ -14664,7 +14811,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          (0, import_node_fs10.readFileSync)((0, import_node_path12.resolve)(playName), "utf-8"),
+          (0, import_node_fs11.readFileSync)((0, import_node_path13.resolve)(playName), "utf-8"),
           playName
         );
       } catch {
@@ -14745,7 +14892,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph((0, import_node_path12.resolve)(playName))
+        () => collectBundledPlayGraph((0, import_node_path13.resolve)(playName))
       );
       await traceCliSpan(
         "cli.play_publish_compile_manifests",
@@ -16994,10 +17141,10 @@ function expandAtFilePath(rawPath) {
     (_match, bareName, bracedName) => process.env[bareName ?? bracedName ?? ""] ?? ""
   );
   if (expanded === "~") {
-    return (0, import_node_os7.homedir)();
+    return (0, import_node_os8.homedir)();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return (0, import_node_path13.join)((0, import_node_os7.homedir)(), expanded.slice(2));
+    return (0, import_node_path14.join)((0, import_node_os8.homedir)(), expanded.slice(2));
   }
   return expanded;
 }
@@ -17181,7 +17328,7 @@ async function buildPlanArgs(args) {
   return planArgs;
 }
 async function assertInputCsvExists(inputCsv) {
-  const path = (0, import_node_path13.resolve)(inputCsv);
+  const path = (0, import_node_path14.resolve)(inputCsv);
   try {
     const info = await (0, import_promises5.stat)(path);
     if (info.isFile()) {
@@ -17195,8 +17342,8 @@ async function assertInputCsvExists(inputCsv) {
   }
 }
 async function assertSafeOutputPath(inputCsv, outputPath) {
-  const input2 = (0, import_node_path13.resolve)(inputCsv);
-  const output2 = (0, import_node_path13.resolve)(outputPath);
+  const input2 = (0, import_node_path14.resolve)(inputCsv);
+  const output2 = (0, import_node_path14.resolve)(outputPath);
   if (input2 === output2) {
     throw new Error(
       "--input and --output must be different files when not using --in-place."
@@ -17225,7 +17372,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await (0, import_promises5.stat)((0, import_node_path13.resolve)(path));
+    const info = await (0, import_promises5.stat)((0, import_node_path14.resolve)(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -17236,7 +17383,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await (0, import_promises5.readFile)((0, import_node_path13.resolve)(path), "utf8");
+  const source = await (0, import_promises5.readFile)((0, import_node_path14.resolve)(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -17553,7 +17700,7 @@ async function writeOutputCsv(outputPath, status, options) {
     options?.config
   );
   await (0, import_promises5.writeFile)(
-    (0, import_node_path13.resolve)(outputPath),
+    (0, import_node_path14.resolve)(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
   );
@@ -17563,7 +17710,7 @@ async function writeOutputCsv(outputPath, status, options) {
     selectedRows: rowsInfo.totalRows,
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
-    path: (0, import_node_path13.resolve)(outputPath),
+    path: (0, import_node_path14.resolve)(outputPath),
     enrichedDataRows: rowsInfo.rows
   };
 }
@@ -17858,9 +18005,9 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0) {
     return null;
   }
-  const stateDir = (0, import_node_path13.join)((0, import_node_os7.homedir)(), ".local", "deepline", "runtime", "state");
+  const stateDir = (0, import_node_path14.join)((0, import_node_os8.homedir)(), ".local", "deepline", "runtime", "state");
   await (0, import_promises5.mkdir)(stateDir, { recursive: true });
-  const reportPath = (0, import_node_path13.join)(
+  const reportPath = (0, import_node_path14.join)(
     stateDir,
     `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -18297,8 +18444,8 @@ function registerEnrichCommand(program) {
       if (options.json) {
         printJson({
           dryRun: true,
-          input: (0, import_node_path13.resolve)(inputCsv),
-          output: options.output ? (0, import_node_path13.resolve)(options.output) : null,
+          input: (0, import_node_path14.resolve)(inputCsv),
+          output: options.output ? (0, import_node_path14.resolve)(options.output) : null,
           plan: summary
         });
         return;
@@ -18322,12 +18469,12 @@ function registerEnrichCommand(program) {
       forceAliases,
       playName: options.name
     });
-    const tempDir = await (0, import_promises5.mkdtemp)((0, import_node_path13.join)((0, import_node_os7.tmpdir)(), "deepline-enrich-play-"));
-    const tempPlay = (0, import_node_path13.join)(tempDir, "deepline-enrich.play.ts");
+    const tempDir = await (0, import_promises5.mkdtemp)((0, import_node_path14.join)((0, import_node_os8.tmpdir)(), "deepline-enrich-play-"));
+    const tempPlay = (0, import_node_path14.join)(tempDir, "deepline-enrich.play.ts");
     try {
       await (0, import_promises5.writeFile)(tempPlay, playSource, "utf8");
       const runtimeInput = {
-        file: (0, import_node_path13.resolve)(sourceCsvPath),
+        file: (0, import_node_path14.resolve)(sourceCsvPath),
         ...rows.rowStart !== null ? { rowStart: rows.rowStart } : {},
         ...rows.rowEnd !== null ? { rowEnd: rows.rowEnd } : {}
       };
@@ -18488,9 +18635,9 @@ Examples:
 }
 
 // src/cli/commands/sessions.ts
-var import_node_fs11 = require("fs");
-var import_node_os8 = require("os");
-var import_node_path14 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_os9 = require("os");
+var import_node_path15 = require("path");
 var import_node_zlib = require("zlib");
 var import_node_crypto4 = require("crypto");
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -18504,33 +18651,33 @@ var MAX_EVENT_OBJECT_KEYS = 80;
 var TRUNCATION_MARKER = "...[truncated]";
 var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set(["progress", "file-history-snapshot"]);
 function homeDir() {
-  return process.env.HOME?.trim() || (0, import_node_os8.homedir)();
+  return process.env.HOME?.trim() || (0, import_node_os9.homedir)();
 }
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
   return {
-    shell: shellPath ? (0, import_node_path14.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell: shellPath ? (0, import_node_path15.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
     shell_path: shellPath || null,
-    os: (0, import_node_os8.platform)(),
+    os: (0, import_node_os9.platform)(),
     cwd: process.cwd()
   };
 }
 function claudeProjectsRoot() {
-  return (0, import_node_path14.join)(homeDir(), ".claude", "projects");
+  return (0, import_node_path15.join)(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return (0, import_node_path14.join)(homeDir(), ".codex", "sessions");
+  return (0, import_node_path15.join)(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
-  if (!(0, import_node_fs11.existsSync)(root)) return [];
+  if (!(0, import_node_fs12.existsSync)(root)) return [];
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = (0, import_node_path14.join)(root, projectDir);
+    const fullProjectDir = (0, import_node_path15.join)(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = (0, import_node_path14.join)(fullProjectDir, fileName);
+        const filePath = (0, import_node_path15.join)(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
         const stat4 = statIfReadable(filePath);
         if (sessionId && stat4) {
@@ -18548,7 +18695,7 @@ function listClaudeSessionFiles() {
 }
 function listCodexSessionFiles() {
   const root = codexSessionsRoot();
-  if (!(0, import_node_fs11.existsSync)(root)) return [];
+  if (!(0, import_node_fs12.existsSync)(root)) return [];
   const files = [];
   for (const filePath of listJsonlFilesRecursive(root, 5)) {
     const stat4 = statIfReadable(filePath);
@@ -18571,7 +18718,7 @@ function listSessionFiles(agent) {
 }
 function readDirectoryNames(dir) {
   try {
-    return (0, import_node_fs11.readdirSync)(dir);
+    return (0, import_node_fs12.readdirSync)(dir);
   } catch {
     return [];
   }
@@ -18582,12 +18729,12 @@ function listJsonlFilesRecursive(root, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = (0, import_node_path14.join)(dir, entry.name);
+      const fullPath = (0, import_node_path15.join)(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -18600,7 +18747,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
 }
 function statIfReadable(filePath) {
   try {
-    return (0, import_node_fs11.statSync)(filePath);
+    return (0, import_node_fs12.statSync)(filePath);
   } catch {
     return null;
   }
@@ -18615,15 +18762,15 @@ function newestSessionFile(agent) {
   return newest;
 }
 function sessionIdFromClaudeFilePath(filePath) {
-  return (0, import_node_path14.basename)(filePath, ".jsonl");
+  return (0, import_node_path15.basename)(filePath, ".jsonl");
 }
 function sessionIdFromCodexFilePath(filePath) {
-  const match = (0, import_node_path14.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  const match = (0, import_node_path15.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
   return match?.[0] ?? null;
 }
 function readCodexSessionId(filePath) {
   try {
-    for (const line of normalizedJsonLines((0, import_node_fs11.readFileSync)(filePath)).slice(
+    for (const line of normalizedJsonLines((0, import_node_fs12.readFileSync)(filePath)).slice(
       0,
       20
     )) {
@@ -18900,25 +19047,25 @@ async function uploadChunkedSessions(sessions, options) {
 }
 async function handleSessionsSend(options) {
   if (options.file) {
-    const filePath = (0, import_node_path14.resolve)(options.file);
-    if (!(0, import_node_fs11.existsSync)(filePath)) {
+    const filePath = (0, import_node_path15.resolve)(options.file);
+    if (!(0, import_node_fs12.existsSync)(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
-      file: (0, import_node_fs11.readFileSync)(filePath).toString("base64"),
-      filename: (0, import_node_path14.basename)(filePath)
+      file: (0, import_node_fs12.readFileSync)(filePath).toString("base64"),
+      filename: (0, import_node_path15.basename)(filePath)
     });
     printCommandEnvelope(
       {
         ...response2,
         ok: true,
-        filename: (0, import_node_path14.basename)(filePath),
+        filename: (0, import_node_path15.basename)(filePath),
         render: {
           sections: [
             {
               title: "sessions send",
               lines: [
-                `File '${(0, import_node_path14.basename)(filePath)}' uploaded to #internal-reports.`
+                `File '${(0, import_node_path15.basename)(filePath)}' uploaded to #internal-reports.`
               ]
             }
           ]
@@ -18935,7 +19082,7 @@ async function handleSessionsSend(options) {
     agent: options.agent
   });
   const built = targets.map((target) => {
-    const upload = buildSessionUploadContent((0, import_node_fs11.readFileSync)(target.filePath));
+    const upload = buildSessionUploadContent((0, import_node_fs12.readFileSync)(target.filePath));
     return { ...target, ...upload };
   });
   if (built.some((session) => session.needsChunking)) {
@@ -18999,28 +19146,28 @@ function fallbackViewerAssets() {
   };
 }
 function loadViewerAssets() {
-  const cliEntry = process.argv[1]?.trim() ? (0, import_node_path14.resolve)(process.argv[1]) : null;
+  const cliEntry = process.argv[1]?.trim() ? (0, import_node_path15.resolve)(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      (0, import_node_path14.join)((0, import_node_path14.dirname)((0, import_node_path14.dirname)(cliEntry)), "viewer"),
-      (0, import_node_path14.join)(
-        (0, import_node_path14.dirname)((0, import_node_path14.dirname)((0, import_node_path14.dirname)(cliEntry))),
+      (0, import_node_path15.join)((0, import_node_path15.dirname)((0, import_node_path15.dirname)(cliEntry)), "viewer"),
+      (0, import_node_path15.join)(
+        (0, import_node_path15.dirname)((0, import_node_path15.dirname)((0, import_node_path15.dirname)(cliEntry))),
         "src",
         "lib",
         "cli",
         "viewer"
       )
     ] : [],
-    (0, import_node_path14.join)(process.cwd(), "src", "lib", "cli", "viewer")
+    (0, import_node_path15.join)(process.cwd(), "src", "lib", "cli", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = (0, import_node_path14.join)(root, "viewer.css");
-      const jsPath = (0, import_node_path14.join)(root, "viewer.js");
-      if (!(0, import_node_fs11.existsSync)(cssPath) || !(0, import_node_fs11.existsSync)(jsPath)) continue;
+      const cssPath = (0, import_node_path15.join)(root, "viewer.css");
+      const jsPath = (0, import_node_path15.join)(root, "viewer.js");
+      if (!(0, import_node_fs12.existsSync)(cssPath) || !(0, import_node_fs12.existsSync)(jsPath)) continue;
       return {
-        css: (0, import_node_fs11.readFileSync)(cssPath, "utf8"),
-        js: (0, import_node_fs11.readFileSync)(jsPath, "utf8")
+        css: (0, import_node_fs12.readFileSync)(cssPath, "utf8"),
+        js: (0, import_node_fs12.readFileSync)(jsPath, "utf8")
       };
     } catch {
       continue;
@@ -19044,21 +19191,21 @@ async function handleSessionsRender(options) {
     currentSession: options.currentSession,
     agent: options.agent
   });
-  let outputPath = options.output ? (0, import_node_path14.resolve)(options.output) : "";
+  let outputPath = options.output ? (0, import_node_path15.resolve)(options.output) : "";
   if (!outputPath) {
-    const outputDir = (0, import_node_path14.join)(process.cwd(), "deepline", "data");
-    (0, import_node_fs11.mkdirSync)(outputDir, { recursive: true });
-    outputPath = (0, import_node_path14.join)(
+    const outputDir = (0, import_node_path15.join)(process.cwd(), "deepline", "data");
+    (0, import_node_fs12.mkdirSync)(outputDir, { recursive: true });
+    outputPath = (0, import_node_path15.join)(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    (0, import_node_fs11.mkdirSync)((0, import_node_path14.dirname)(outputPath), { recursive: true });
+    (0, import_node_fs12.mkdirSync)((0, import_node_path15.dirname)(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
     events: parsePreparedEvents(
-      prepareSessionBuffer((0, import_node_fs11.readFileSync)(target.filePath))
+      prepareSessionBuffer((0, import_node_fs12.readFileSync)(target.filePath))
     )
   }));
   const { css, js } = loadViewerAssets();
@@ -19081,7 +19228,7 @@ ${refreshMeta}
 <script>${js}</script>
 </body>
 </html>`;
-  (0, import_node_fs11.writeFileSync)(outputPath, html, "utf8");
+  (0, import_node_fs12.writeFileSync)(outputPath, html, "utf8");
   printCommandEnvelope(
     {
       ok: true,
@@ -19948,9 +20095,9 @@ Examples:
 }
 
 // src/cli/commands/switch.ts
-var import_node_fs12 = require("fs");
-var import_node_os9 = require("os");
-var import_node_path15 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_os10 = require("os");
+var import_node_path16 = require("path");
 function hostSlugFromBaseUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
@@ -19970,8 +20117,8 @@ function resolveConfigScope() {
   return hostSlugFromBaseUrl(autoDetectBaseUrl());
 }
 function activeFamilyPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os9.homedir)();
-  return (0, import_node_path15.join)(
+  const home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os10.homedir)();
+  return (0, import_node_path16.join)(
     home,
     ".local",
     "deepline",
@@ -19983,18 +20130,21 @@ function activeFamilyPath() {
 function readActiveFamily() {
   const path = activeFamilyPath();
   try {
-    return (0, import_node_fs12.readFileSync)(path, "utf-8").trim() || "sdk";
+    return (0, import_node_fs13.readFileSync)(path, "utf-8").trim() || "sdk";
   } catch {
     return "sdk";
   }
 }
 function writeActiveFamily(family) {
   const path = activeFamilyPath();
-  (0, import_node_fs12.mkdirSync)((0, import_node_path15.dirname)(path), { recursive: true });
-  (0, import_node_fs12.writeFileSync)(path, `${family}
+  (0, import_node_fs13.mkdirSync)((0, import_node_path16.dirname)(path), { recursive: true });
+  (0, import_node_fs13.writeFileSync)(path, `${family}
 `, "utf-8");
   return path;
 }
+function forcePythonCliFamily() {
+  return writeActiveFamily("python");
+}
 function handleSwitch(action, options) {
   const normalized = (action || "status").trim().toLowerCase();
   if (normalized === "status") {
@@ -20005,7 +20155,7 @@ function handleSwitch(action, options) {
         ok: true,
         active_family: activeFamily,
         active_family_path: path,
-        active_family_file_exists: (0, import_node_fs12.existsSync)(path),
+        active_family_file_exists: (0, import_node_fs13.existsSync)(path),
         render: {
           sections: [
             {
@@ -20105,14 +20255,14 @@ Examples:
 
 // src/cli/commands/tools.ts
 var import_commander2 = require("commander");
+var import_node_fs15 = require("fs");
+var import_node_os12 = require("os");
+var import_node_path18 = require("path");
+
+// src/tool-output.ts
 var import_node_fs14 = require("fs");
 var import_node_os11 = require("os");
 var import_node_path17 = require("path");
-
-// src/tool-output.ts
-var import_node_fs13 = require("fs");
-var import_node_os10 = require("os");
-var import_node_path16 = require("path");
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20208,19 +20358,19 @@ function tryConvertToList(payload, options) {
   return null;
 }
 function ensureOutputDir() {
-  const outputDir = (0, import_node_path16.join)((0, import_node_os10.homedir)(), ".local", "share", "deepline", "data");
-  (0, import_node_fs13.mkdirSync)(outputDir, { recursive: true });
+  const outputDir = (0, import_node_path17.join)((0, import_node_os11.homedir)(), ".local", "share", "deepline", "data");
+  (0, import_node_fs14.mkdirSync)(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path16.join)(outputDir, `${stem}_${Date.now()}.json`);
-  (0, import_node_fs13.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  const outputPath = (0, import_node_path17.join)(outputDir, `${stem}_${Date.now()}.json`);
+  (0, import_node_fs14.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path16.join)(outputDir, `${stem}_${Date.now()}.csv`);
+  const outputPath = (0, import_node_path17.join)(outputDir, `${stem}_${Date.now()}.csv`);
   const seen = /* @__PURE__ */ new Set();
   const columns = [];
   for (const row of rows) {
@@ -20243,7 +20393,7 @@ function writeCsvOutputFile(rows, stem) {
   for (const row of rows) {
     lines.push(columns.map((column) => escapeCell(row[column])).join(","));
   }
-  (0, import_node_fs13.writeFileSync)(outputPath, `${lines.join("\n")}
+  (0, import_node_fs14.writeFileSync)(outputPath, `${lines.join("\n")}
 `, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
@@ -21297,11 +21447,11 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = (0, import_node_path17.resolve)(trimmed);
-  if ((0, import_node_fs14.existsSync)(resolved)) return resolved;
+  const resolved = (0, import_node_path18.resolve)(trimmed);
+  if ((0, import_node_fs15.existsSync)(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = (0, import_node_path17.resolve)(trimmed.replace(/\\/g, "/"));
-    if ((0, import_node_fs14.existsSync)(normalized)) return normalized;
+    const normalized = (0, import_node_path18.resolve)(trimmed.replace(/\\/g, "/"));
+    if ((0, import_node_fs15.existsSync)(normalized)) return normalized;
   }
   return resolved;
 }
@@ -21312,7 +21462,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return (0, import_node_fs14.readFileSync)(resolveAtFilePath(filePath), "utf8").replace(
+    return (0, import_node_fs15.readFileSync)(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -21414,9 +21564,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = (0, import_node_fs14.mkdtempSync)((0, import_node_path17.join)((0, import_node_os11.tmpdir)(), "deepline-workflow-seed-"));
-  (0, import_node_fs14.chmodSync)(scriptDir, 448);
-  const scriptPath = (0, import_node_path17.join)(scriptDir, fileName);
+  const scriptDir = (0, import_node_fs15.mkdtempSync)((0, import_node_path18.join)((0, import_node_os12.tmpdir)(), "deepline-workflow-seed-"));
+  (0, import_node_fs15.chmodSync)(scriptDir, 448);
+  const scriptPath = (0, import_node_path18.join)(scriptDir, fileName);
   const projectDir = `deepline/projects/${stem}-workflow`;
   const playName = `${stem}-workflow`;
   const sampleRows = input2.rows.length > 0 ? `${JSON.stringify(input2.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
@@ -21452,7 +21602,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   };
 });
 `;
-  (0, import_node_fs14.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  (0, import_node_fs15.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -21717,7 +21867,7 @@ async function executeTool(args) {
 
 // src/cli/commands/workflow.ts
 var import_promises6 = require("fs/promises");
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 
 // src/cli/workflow-to-play.ts
 var import_node_crypto6 = require("crypto");
@@ -21924,7 +22074,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await (0, import_promises6.readFile)((0, import_node_path18.resolve)(file), "utf8");
+    const raw = await (0, import_promises6.readFile)((0, import_node_path19.resolve)(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -21958,8 +22108,8 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = (0, import_node_path18.join)((0, import_node_path18.resolve)(outDir), `${compiled.playName}.play.ts`);
-    await (0, import_promises6.mkdir)((0, import_node_path18.dirname)(file), { recursive: true });
+    const file = (0, import_node_path19.join)((0, import_node_path19.resolve)(outDir), `${compiled.playName}.play.ts`);
+    await (0, import_promises6.mkdir)((0, import_node_path19.dirname)(file), { recursive: true });
     await (0, import_promises6.writeFile)(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
@@ -22206,8 +22356,8 @@ Notes:
 
 // src/cli/commands/update.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs15 = require("fs");
-var import_node_path19 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path20 = require("path");
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -22226,19 +22376,19 @@ function buildSourceUpdateCommand(sourceRoot) {
   return `${cdCommand} && git fetch origin main --tags && git merge --ff-only origin/main`;
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = (0, import_node_path19.resolve)(startPath);
+  let current = (0, import_node_path20.resolve)(startPath);
   while (true) {
-    if ((0, import_node_fs15.existsSync)((0, import_node_path19.join)(current, "sdk", "package.json")) && (0, import_node_fs15.existsSync)((0, import_node_path19.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if ((0, import_node_fs16.existsSync)((0, import_node_path20.join)(current, "sdk", "package.json")) && (0, import_node_fs16.existsSync)((0, import_node_path20.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = (0, import_node_path19.dirname)(current);
+    const parent = (0, import_node_path20.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveUpdatePlan() {
-  const entrypoint = process.argv[1] ? (0, import_node_path19.resolve)(process.argv[1]) : "";
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path19.dirname)(entrypoint)) : null;
+  const entrypoint = process.argv[1] ? (0, import_node_path20.resolve)(process.argv[1]) : "";
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path20.dirname)(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -22565,7 +22715,7 @@ async function maybeAutoUpdateAndRelaunch(response) {
   if (plan.kind !== "npm-global") {
     return false;
   }
-  const label = autoUpdate.required ? "requires an update" : "is more than the supported auto-update lag behind";
+  const label = autoUpdate.reason === "rollback_forced" ? "has a server rollback pending and needs the latest rollback-aware CLI" : autoUpdate.required ? "requires an update" : "is more than the supported auto-update lag behind";
   process.stderr.write(
     `Deepline SDK/CLI ${label}; running ${plan.manualCommand}
 `
@@ -22591,9 +22741,9 @@ async function maybeAutoUpdateAndRelaunch(response) {
 
 // src/cli/skills-sync.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs16 = require("fs");
-var import_node_os12 = require("os");
-var import_node_path20 = require("path");
+var import_node_fs17 = require("fs");
+var import_node_os13 = require("os");
+var import_node_path21 = require("path");
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_PLAY_SKILL_NAME = "deepline-plays";
 var attemptedSync = false;
@@ -22607,20 +22757,20 @@ function activePluginSkillsDir() {
     return "";
   }
   const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && (0, import_node_fs16.existsSync)(dir) ? dir : "";
+  return dir && (0, import_node_fs17.existsSync)(dir) ? dir : "";
 }
 function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return (0, import_node_fs16.readFileSync)((0, import_node_path20.join)(dir, ".version"), "utf-8").trim();
+    return (0, import_node_fs17.readFileSync)((0, import_node_path21.join)(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
-  const home = process.env.HOME?.trim() || (0, import_node_os12.homedir)();
-  return (0, import_node_path20.join)(
+  const home = process.env.HOME?.trim() || (0, import_node_os13.homedir)();
+  return (0, import_node_path21.join)(
     home,
     ".local",
     "deepline",
@@ -22633,17 +22783,17 @@ function readLocalSkillsVersion(baseUrl) {
   const pluginVersion = readPluginSkillsVersion();
   if (pluginVersion) return pluginVersion;
   const path = sdkSkillsVersionPath(baseUrl);
-  if (!(0, import_node_fs16.existsSync)(path)) return "";
+  if (!(0, import_node_fs17.existsSync)(path)) return "";
   try {
-    return (0, import_node_fs16.readFileSync)(path, "utf-8").trim();
+    return (0, import_node_fs17.readFileSync)(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  (0, import_node_fs16.mkdirSync)((0, import_node_path20.dirname)(path), { recursive: true });
-  (0, import_node_fs16.writeFileSync)(path, `${version}
+  (0, import_node_fs17.mkdirSync)((0, import_node_path21.dirname)(path), { recursive: true });
+  (0, import_node_fs17.writeFileSync)(path, `${version}
 `, "utf-8");
 }
 function sortedUniqueSkillNames(names) {
@@ -22822,7 +22972,7 @@ async function syncSdkSkillsIfNeeded(baseUrl) {
 }
 
 // src/cli/failure-reporting.ts
-var import_node_os13 = require("os");
+var import_node_os14 = require("os");
 var FAILURE_REPORT_DISABLE_ENV = "DEEPLINE_DISABLE_FAILURE_REPORTING";
 var REPORT_FAILURE_TIMEOUT_MS = 1e4;
 var MAX_FAILURE_TEXT_CHARS = 4e3;
@@ -22944,12 +23094,12 @@ function detectAgentRuntime3() {
 }
 function buildEnvironmentContext() {
   const context = {
-    os: (0, import_node_os13.platform)(),
-    os_release: (0, import_node_os13.release)(),
-    platform: `${(0, import_node_os13.platform)()}-${(0, import_node_os13.release)()}-${process.arch}`,
+    os: (0, import_node_os14.platform)(),
+    os_release: (0, import_node_os14.release)(),
+    platform: `${(0, import_node_os14.platform)()}-${(0, import_node_os14.release)()}-${process.arch}`,
     node_version: process.version,
     runtime: "Node.js",
-    hostname: (0, import_node_os13.hostname)(),
+    hostname: (0, import_node_os14.hostname)(),
     agent_runtime: detectAgentRuntime3()
   };
   for (const key of ["CLAUDE_CODE_REMOTE", "DEEPLINE_PLUGIN_MODE"]) {
@@ -23129,8 +23279,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await (0, import_promises7.mkdtemp)((0, import_node_path21.join)((0, import_node_os14.tmpdir)(), "deepline-health-play-"));
-  const file = (0, import_node_path21.join)(dir, "health-check.play.ts");
+  const dir = await (0, import_promises7.mkdtemp)((0, import_node_path22.join)((0, import_node_os15.tmpdir)(), "deepline-health-play-"));
+  const file = (0, import_node_path22.join)(dir, "health-check.play.ts");
   try {
     await (0, import_promises7.writeFile)(
       file,
@@ -23368,6 +23518,18 @@ Exit codes:
     if (relaunched) {
       return;
     }
+    if (compatibility.response?.cli_family?.action === "force_python") {
+      forcePythonCliFamily();
+      process.stderr.write(
+        "Deepline SDK CLI rollback is active; switched installer-managed `deepline` back to the Python CLI. Re-run your command.\n"
+      );
+      const error = new Error(
+        "SDK CLI rollback is active"
+      );
+      error.code = "deepline.sdk_cli_rollback";
+      error.exitCode = 7;
+      throw error;
+    }
     enforceSdkCompatibilityResponse(compatibility.response);
     if (printStartupPhase) {
       progress?.phase("checking sdk skills");