deepline 0.1.110 → 0.1.111

package/dist/cli/index.mjs

@@ -159,7 +159,7 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 import { Command as Command3 } from "commander";
 
@@ -380,10 +380,10 @@ var SDK_RELEASE = {
   // skill on the sdk sync surface, and the people-search-to-email prebuilt.
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
-  version: "0.1.110",
+  version: "0.1.111",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.110",
+    latest: "0.1.111",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -3439,11 +3439,57 @@ var DeeplineClient = class {
 };
 
 // src/compat.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3 } from "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 join3(homedir3(), ".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 (!existsSync3(path)) {
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync3(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 = existsSync3(path) ? JSON.parse(readFileSync3(path, "utf8")) : {};
+    const entries = existing.entries ?? {};
+    entries[compatibilityCacheKey(baseUrl, command)] = {
+      savedAt: Date.now(),
+      response
+    };
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync2(path, `${JSON.stringify({ entries }, null, 2)}
+`);
+  } catch {
+  }
+}
 async function checkSdkCompatibility(baseUrl, options = {}) {
   if (shouldSkipCompatibilityCheck()) {
     return { response: null, error: null };
@@ -3466,8 +3512,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))
@@ -3491,26 +3544,26 @@ function enforceSdkCompatibilityResponse(response) {
 
 // src/cli/commands/auth.ts
 import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 
 // src/cli/utils.ts
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync4,
   rmSync,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 import * as childProcess from "child_process";
 import { parse } from "csv-parse/sync";
 import { stringify } from "csv-stringify/sync";
@@ -3523,13 +3576,13 @@ function getAuthedHttpClient() {
 async function writeOutputFile(filename, content) {
   const outputDir = resolve2(process.cwd(), "deepline", "data");
   await mkdir(outputDir, { recursive: true });
-  const fullPath = join3(outputDir, filename);
+  const fullPath = join4(outputDir, filename);
   await writeFile(fullPath, content, "utf-8");
   return fullPath;
 }
 function browserOpenStateFile() {
-  const homeDir2 = process.env.HOME || homedir3();
-  return join3(
+  const homeDir2 = process.env.HOME || homedir4();
+  return join4(
     homeDir2,
     ".local",
     "deepline",
@@ -3543,16 +3596,16 @@ function claimBrowserOpen(now = Date.now()) {
   const lockPath = `${statePath}.lock`;
   let locked = false;
   try {
-    mkdirSync2(dirname2(statePath), { recursive: true });
+    mkdirSync3(dirname3(statePath), { recursive: true });
     try {
-      mkdirSync2(lockPath);
+      mkdirSync3(lockPath);
       locked = true;
     } catch {
       return false;
     }
     let lastOpenedAt = 0;
-    if (existsSync3(statePath)) {
-      const payload = JSON.parse(readFileSync3(statePath, "utf-8"));
+    if (existsSync4(statePath)) {
+      const payload = JSON.parse(readFileSync4(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;
@@ -3564,7 +3617,7 @@ function claimBrowserOpen(now = Date.now()) {
     if (now - lastOpenedAt < BROWSER_OPEN_COOLDOWN_MS) {
       return false;
     }
-    writeFileSync2(statePath, JSON.stringify({ lastOpenedAt: now }), "utf-8");
+    writeFileSync3(statePath, JSON.stringify({ lastOpenedAt: now }), "utf-8");
     return true;
   } catch {
     return true;
@@ -3605,7 +3658,7 @@ function readDefaultMacBrowserBundleId(runner = defaultBrowserCommandRunner) {
         "json",
         "-o",
         "-",
-        `${homedir3()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`
+        `${homedir4()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`
       ],
       { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     );
@@ -3776,7 +3829,7 @@ function collectLocalEnvInfo() {
   const info = {
     os: `${process.platform} ${process.arch}`,
     node_version: process.version,
-    home_dir: homedir3(),
+    home_dir: homedir4(),
     agent_runtime: detectAgentRuntime2()
   };
   const env = process.env;
@@ -3805,7 +3858,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() || homedir3()).startsWith(
+  const sessionHome = (process.env.HOME?.trim() || homedir4()).startsWith(
     "/sessions/"
   );
   if (["1", "true", "yes", "on"].includes(pluginMode ?? "") && (["1", "true", "yes", "on"].includes(claudeRemote ?? "") || Boolean(process.env.CLAUDE_PROJECT_DIR?.trim()) || sessionHome)) {
@@ -3822,7 +3875,7 @@ function detectAgentRuntime2() {
   return "unknown";
 }
 function readCsvRows(csvPath) {
-  const raw = readFileSync3(resolve2(csvPath), "utf-8");
+  const raw = readFileSync4(resolve2(csvPath), "utf-8");
   return parse(raw, {
     columns: true,
     skip_empty_lines: true
@@ -4056,18 +4109,18 @@ function pendingClaimTokenPath(baseUrl) {
 }
 function savePendingClaimToken(baseUrl, claimToken) {
   const filePath = pendingClaimTokenPath(baseUrl);
-  const dir = dirname3(filePath);
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = dirname4(filePath);
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
-  writeFileSync3(filePath, `${claimToken}
+  writeFileSync4(filePath, `${claimToken}
 `, "utf-8");
 }
 function readPendingClaimToken(baseUrl) {
   const filePath = pendingClaimTokenPath(baseUrl);
-  if (!existsSync4(filePath)) return "";
+  if (!existsSync5(filePath)) return "";
   try {
-    return readFileSync4(filePath, "utf-8").trim();
+    return readFileSync5(filePath, "utf-8").trim();
   } catch {
     return "";
   }
@@ -4604,7 +4657,7 @@ Examples:
 // src/cli/commands/billing.ts
 import { Command } from "commander";
 import { appendFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { dirname as dirname5, resolve as resolve3 } from "path";
 import { stringify as stringify2 } from "csv-stringify/sync";
 var SUBSCRIPTION_STATUS_NEXT_COMMAND = "deepline billing subscription status --json";
 var SUBSCRIPTION_CANCEL_PATH = "/api/v2/billing/subscription/cancel";
@@ -4893,7 +4946,7 @@ async function handleLedgerExportAll(options) {
     const entries = Array.isArray(payload.entries) ? payload.entries : [];
     const rows = entries.map(ledgerApiEntryToRow);
     if (!initializedOutput) {
-      await mkdir2(dirname4(outputPath), { recursive: true });
+      await mkdir2(dirname5(outputPath), { recursive: true });
       await writeFile2(outputPath, ledgerRowsToCsv([], true), "utf-8");
       initializedOutput = true;
     }
@@ -5517,7 +5570,7 @@ Examples:
 }
 
 // src/cli/dataset-stats.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve4 } from "path";
 
 // ../shared_libs/plays/dataset-summary.ts
@@ -6126,7 +6179,7 @@ function writeCanonicalRowsCsv(rowsInfo, outPath) {
   const rows = dataExportRows(sanitized.rows);
   const columns = dataExportColumns(rows, sanitized.columns);
   const resolved = resolve4(outPath);
-  writeFileSync4(resolved, csvStringFromRows(rows, columns), "utf-8");
+  writeFileSync5(resolved, csvStringFromRows(rows, columns), "utf-8");
   return resolved;
 }
 
@@ -6262,7 +6315,7 @@ Examples:
 }
 
 // src/cli/commands/db.ts
-import { writeFileSync as writeFileSync5 } from "fs";
+import { writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve5 } from "path";
 var CUSTOMER_DB_QUERY_FORMATS = /* @__PURE__ */ new Set(["table", "json", "csv", "markdown"]);
 function parsePositiveInteger(value, flagName) {
@@ -6377,7 +6430,7 @@ function formatDbQueryError(sql, error) {
 }
 function writeCustomerDbCsv(result, outPath) {
   const resolved = resolve5(outPath);
-  writeFileSync5(
+  writeFileSync6(
     resolved,
     dataExportCsvString(customerDbRows(result), customerDbColumnNames(result)),
     "utf-8"
@@ -6490,7 +6543,7 @@ async function handleDbQuery(args) {
     );
     if (outPath) {
       const exportedPath = resolve5(outPath);
-      writeFileSync5(exportedPath, content, "utf-8");
+      writeFileSync6(exportedPath, content, "utf-8");
       printCommandEnvelope(
         dbQueryExportEnvelope({
           result,
@@ -6599,39 +6652,40 @@ import {
   stat as stat3,
   writeFile as writeFile4
 } from "fs/promises";
-import { homedir as homedir4, tmpdir as tmpdir3 } from "os";
-import { join as join8, resolve as resolve11 } from "path";
+import { homedir as homedir5, tmpdir as tmpdir3 } from "os";
+import { join as join9, resolve as resolve11 } from "path";
 
 // src/cli/commands/play.ts
 import { createHash as createHash3 } from "crypto";
 import {
-  existsSync as existsSync7,
-  readFileSync as readFileSync6,
+  existsSync as existsSync8,
+  readFileSync as readFileSync7,
   readdirSync,
   realpathSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename3, dirname as dirname8, join as join7, resolve as resolve10 } from "path";
+import { basename as basename3, dirname as dirname9, join as join8, resolve as resolve10 } from "path";
 import { parse as parseCsvSync2 } from "csv-parse/sync";
 
 // src/plays/bundle-play-file.ts
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname7, join as join6, resolve as resolve8 } from "path";
+import { dirname as dirname8, join as join7, resolve as resolve8 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 // ../shared_libs/plays/bundling/index.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
 import { mkdir as mkdir3, readFile, realpath, stat, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir } from "os";
 import {
   basename,
-  dirname as dirname5,
+  dirname as dirname6,
   extname,
   isAbsolute,
-  join as join4,
+  join as join5,
+  relative,
   resolve as resolve6
 } from "path";
 import { builtinModules } from "module";
@@ -6746,7 +6800,7 @@ var MAX_ESM_WORKERS_BUNDLE_BYTES = 115e4;
 
 // ../shared_libs/plays/bundling/index.ts
 var PLAY_BUNDLE_CACHE_VERSION = 24;
-var PLAY_ARTIFACT_CACHE_DIR = join4(
+var PLAY_ARTIFACT_CACHE_DIR = join5(
   tmpdir(),
   `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`
 );
@@ -6797,7 +6851,7 @@ async function normalizeLocalPath(filePath) {
 function createPlayWorkspace(entryFile) {
   return {
     entryFile,
-    rootDir: dirname5(entryFile)
+    rootDir: dirname6(entryFile)
   };
 }
 function isPathInsideDirectory(filePath, directory) {
@@ -6964,9 +7018,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 = relative(dirname6(input2.entryFile), input2.filePath);
+  if (entryRelative && !entryRelative.startsWith("..")) {
+    return entryRelative.replaceAll("\\", "/");
+  }
+  return `<project>/${relative(input2.adapter.projectRoot, input2.filePath).replaceAll("\\", "/")}`;
+}
+function buildWorkersRuntimeGraphHash(input2) {
+  const sourceFiles = Object.entries(input2.analysis.sourceFiles).map(([filePath, contents]) => ({
+    filePath: workersRuntimeGraphFilePath({
+      entryFile: input2.entryFile,
+      filePath,
+      adapter: input2.adapter
+    }),
+    hash: sha256(
+      filePath === input2.entryFile ? canonicalizeRootPlayNameForWorkersRuntimeHash(contents) : contents
+    )
+  })).sort((left, right) => left.filePath.localeCompare(right.filePath));
+  return sha256(
+    JSON.stringify({
+      entryFile: "<entry>",
+      entryExport: input2.exportName,
+      localFiles: sourceFiles,
+      nodeBuiltins: [...input2.analysis.importPolicy.nodeBuiltins].sort(),
+      packages: input2.analysis.importPolicy.packages.map(({ name, version }) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name)),
+      importedPlayDependencies: input2.analysis.importedPlayDependencies.map((dependency) => ({
+        filePath: workersRuntimeGraphFilePath({
+          entryFile: input2.entryFile,
+          filePath: dependency.filePath,
+          adapter: input2.adapter
+        }),
+        playName: dependency.playName
+      })).sort((left, right) => left.filePath.localeCompare(right.filePath))
+    })
+  );
+}
 function readPackageVersionFromPackageJson(packageJsonPath, packageName) {
   try {
-    const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
     if (packageJson.name === packageName && typeof packageJson.version === "string") {
       return packageJson.version;
     }
@@ -6983,16 +7102,16 @@ function findPackageJsonPathFrom(startDir, packageName) {
   }
   let current = startDir;
   while (true) {
-    const packageJsonPath = join4(
+    const packageJsonPath = join5(
       current,
       "node_modules",
       packageName,
       "package.json"
     );
-    if (existsSync5(packageJsonPath)) {
+    if (existsSync6(packageJsonPath)) {
       return packageJsonPath;
     }
-    const parent = dirname5(current);
+    const parent = dirname6(current);
     if (parent === current) {
       return null;
     }
@@ -7001,9 +7120,9 @@ function findPackageJsonPathFrom(startDir, packageName) {
 }
 function findPackageJsonPath(packageName, fromFile, adapter) {
   const startDirs = [
-    resolve6(dirname5(fromFile)),
+    resolve6(dirname6(fromFile)),
     resolve6(adapter.projectRoot),
-    resolve6(dirname5(adapter.sdkPackageJson))
+    resolve6(dirname6(adapter.sdkPackageJson))
   ];
   const seen = /* @__PURE__ */ new Set();
   for (const startDir of startDirs) {
@@ -7012,16 +7131,16 @@ function findPackageJsonPath(packageName, fromFile, adapter) {
     const packageJsonPath = findPackageJsonPathFrom(startDir, packageName);
     if (packageJsonPath) return packageJsonPath;
   }
-  const adapterNodeModulesPackageJson = join4(
+  const adapterNodeModulesPackageJson = join5(
     adapter.nodeModulesDir,
     packageName,
     "package.json"
   );
-  return existsSync5(adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
+  return existsSync6(adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
 }
 function localSdkAliasPlugin(adapter, options) {
   const entryFile = options?.workersRuntime ? adapter.sdkWorkersEntryFile : adapter.sdkEntryFile;
-  if (!existsSync5(entryFile)) {
+  if (!existsSync6(entryFile)) {
     return null;
   }
   return {
@@ -7031,7 +7150,7 @@ function localSdkAliasPlugin(adapter, options) {
         path: entryFile
       }));
       buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
-        path: join4(adapter.sdkSourceRoot, "helpers.ts")
+        path: join5(adapter.sdkSourceRoot, "helpers.ts")
       }));
     }
   };
@@ -7064,7 +7183,7 @@ function workersNamedPlayEntryAliasPlugin(playFilePath, exportName) {
           contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};
 `,
           loader: "ts",
-          resolveDir: dirname5(playFilePath)
+          resolveDir: dirname6(playFilePath)
         })
       );
     }
@@ -7235,7 +7354,7 @@ function importedPlayProxyPlugin(importedPlayDependencies) {
           return {
             contents: buildImportedPlayProxyModule(dependency.playName),
             loader: "ts",
-            resolveDir: dirname5(args.path)
+            resolveDir: dirname6(args.path)
           };
         }
       );
@@ -7254,7 +7373,7 @@ async function resolveLocalImport(fromFile, specifier) {
   if (specifier.startsWith("file:")) {
     return normalizeLocalPath(new URL(specifier).pathname);
   }
-  const base = isAbsolute(specifier) ? resolve6(specifier) : resolve6(dirname5(fromFile), specifier);
+  const base = isAbsolute(specifier) ? resolve6(specifier) : resolve6(dirname6(fromFile), specifier);
   const candidates = [base];
   const explicitExtension = extname(base).toLowerCase();
   if (!explicitExtension) {
@@ -7262,7 +7381,7 @@ async function resolveLocalImport(fromFile, specifier) {
       ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
     );
     candidates.push(
-      ...SOURCE_EXTENSIONS.map((extension) => join4(base, `index${extension}`))
+      ...SOURCE_EXTENSIONS.map((extension) => join5(base, `index${extension}`))
     );
   } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
     const stem = base.slice(0, -explicitExtension.length);
@@ -7281,9 +7400,9 @@ async function resolveLocalImport(fromFile, specifier) {
 }
 function resolvePackageImport(specifier, fromFile, adapter) {
   const packageName = getPackageName(specifier);
-  if (packageName === "deepline" && existsSync5(adapter.sdkPackageJson)) {
+  if (packageName === "deepline" && existsSync6(adapter.sdkPackageJson)) {
     const packageJson = JSON.parse(
-      readFileSync5(adapter.sdkPackageJson, "utf-8")
+      readFileSync6(adapter.sdkPackageJson, "utf-8")
     );
     return {
       name: "deepline",
@@ -7435,7 +7554,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, join4(rootDir, name));
+      await addFilePart(parts2, rootDir, join5(rootDir, name));
     }
   };
   const collectIntegrationBatchingFiles = async (rootDir, parts2) => {
@@ -7444,10 +7563,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(join4(rootDir, entry.name));
+        filePaths.push(join5(rootDir, entry.name));
       }
       if (entry.isDirectory()) {
-        const batchingFile = join4(rootDir, entry.name, "batching.ts");
+        const batchingFile = join5(rootDir, entry.name, "batching.ts");
         if (await fileExists(batchingFile)) {
           filePaths.push(batchingFile);
         }
@@ -7466,7 +7585,7 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
     await addFilePart(
       parts,
       adapter.workersHarnessFilesDir,
-      join4(adapter.workersHarnessFilesDir, name)
+      join5(adapter.workersHarnessFilesDir, name)
     );
   }
   for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
@@ -7479,7 +7598,7 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
   return sha256(JSON.stringify(parts));
 }
 function artifactCachePath(graphHash, artifactKind, adapter) {
-  return join4(
+  return join5(
     adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR,
     `${graphHash}.${artifactKind}.json`
   );
@@ -7514,7 +7633,7 @@ function normalizeSourceMapForRuntime(sourceMapText, projectRoot) {
     if (sourcePath.startsWith("data:") || sourcePath.startsWith("node:") || sourcePath.startsWith("/") || /^[a-zA-Z]+:\/\//.test(sourcePath)) {
       return sourcePath;
     }
-    return join4(projectRoot, sourcePath);
+    return join5(projectRoot, sourcePath);
   });
   parsed.sourceRoot = void 0;
   return JSON.stringify(parsed);
@@ -7546,7 +7665,7 @@ async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter
     ...namedExportShim ? {
       stdin: {
         contents: namedExportShim,
-        resolveDir: dirname5(entryFile),
+        resolveDir: dirname6(entryFile),
         sourcefile: `${basename(entryFile)}.${exportName}.entry.ts`,
         loader: "ts"
       }
@@ -7696,10 +7815,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(
@@ -7735,11 +7857,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(
@@ -7756,7 +7875,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,
@@ -7817,7 +7942,9 @@ workers-harness:${harnessFingerprint}`
       generatedAt: Date.now(),
       cacheHit: false
     };
-    await writeArtifactCache(artifact, adapter);
+    if (canUseArtifactCache) {
+      await writeArtifactCache(artifact, adapter);
+    }
     return {
       success: true,
       artifact,
@@ -7941,11 +8068,11 @@ import { createHash as createHash2 } from "crypto";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import {
   basename as basename2,
-  dirname as dirname6,
+  dirname as dirname7,
   extname as extname2,
   isAbsolute as isAbsolute2,
-  join as join5,
-  relative,
+  join as join6,
+  relative as relative2,
   resolve as resolve7
 } from "path";
 var SOURCE_EXTENSIONS2 = [
@@ -8162,11 +8289,11 @@ async function fileExists2(filePath) {
   }
 }
 function isPathInsideDirectory2(filePath, directory) {
-  const relativePath = relative(directory, filePath);
+  const relativePath = relative2(directory, filePath);
   return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute2(relativePath);
 }
 async function resolveLocalImport2(fromFile, specifier) {
-  const base = isAbsolute2(specifier) ? resolve7(specifier) : resolve7(dirname6(fromFile), specifier);
+  const base = isAbsolute2(specifier) ? resolve7(specifier) : resolve7(dirname7(fromFile), specifier);
   const candidates = [base];
   const explicitExtension = extname2(base).toLowerCase();
   if (!explicitExtension) {
@@ -8174,7 +8301,7 @@ async function resolveLocalImport2(fromFile, specifier) {
       ...SOURCE_EXTENSIONS2.map((extension) => `${base}${extension}`)
     );
     candidates.push(
-      ...SOURCE_EXTENSIONS2.map((extension) => join5(base, `index${extension}`))
+      ...SOURCE_EXTENSIONS2.map((extension) => join6(base, `index${extension}`))
     );
   } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
     const stem = base.slice(0, -explicitExtension.length);
@@ -8193,7 +8320,7 @@ async function resolveLocalImport2(fromFile, specifier) {
 }
 async function discoverPackagedLocalFiles(entryFile) {
   const absoluteEntryFile = resolve7(entryFile);
-  const packagingRoot = dirname6(absoluteEntryFile);
+  const packagingRoot = dirname7(absoluteEntryFile);
   const files = /* @__PURE__ */ new Map();
   const unresolved = [];
   const visitedFiles = /* @__PURE__ */ new Set();
@@ -8235,7 +8362,7 @@ 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 = resolve7(dirname6(absolutePath), resolvedPath);
+          const absoluteCsvPath = resolve7(dirname7(absolutePath), resolvedPath);
           if (isAbsolute2(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
             unresolved.push({
               sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
@@ -8274,14 +8401,14 @@ async function discoverPackagedLocalFiles(entryFile) {
 
 // src/plays/bundle-play-file.ts
 var PLAY_BUNDLE_CACHE_VERSION2 = 30;
-var MODULE_DIR = dirname7(fileURLToPath(import.meta.url));
+var MODULE_DIR = dirname8(fileURLToPath(import.meta.url));
 var SDK_PACKAGE_ROOT = resolve8(MODULE_DIR, "..", "..");
 var SOURCE_REPO_ROOT = resolve8(SDK_PACKAGE_ROOT, "..");
-var HAS_SOURCE_BUNDLING_SOURCES = existsSync6(
+var HAS_SOURCE_BUNDLING_SOURCES = existsSync7(
   resolve8(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
 var PACKAGED_REPO_ROOT = resolve8(SDK_PACKAGE_ROOT, "dist", "repo");
-var HAS_PACKAGED_BUNDLING_SOURCES = existsSync6(
+var HAS_PACKAGED_BUNDLING_SOURCES = existsSync7(
   resolve8(PACKAGED_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
 var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_REPO_ROOT : resolve8(SDK_PACKAGE_ROOT, "..");
@@ -8327,14 +8454,14 @@ function createSdkPlayBundlingAdapter() {
   return {
     projectRoot: PROJECT_ROOT,
     nodeModulesDir: resolve8(PROJECT_ROOT, "node_modules"),
-    cacheDir: join6(
+    cacheDir: join7(
       tmpdir2(),
       `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION2}`
     ),
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync6(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
+    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync7(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
     sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
     workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
     workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
@@ -8357,8 +8484,8 @@ async function bundlePlayFile2(filePath, options = {}) {
 }
 
 // src/cli/commands/plays/bootstrap.ts
-import { closeSync, openSync, readSync, statSync, writeFileSync as writeFileSync6 } from "fs";
-import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve9 } from "path";
+import { closeSync, openSync, readSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve9 } from "path";
 import { parse as parseCsvSync } from "csv-parse/sync";
 
 // ../shared_libs/plays/bootstrap-routes.ts
@@ -8863,7 +8990,7 @@ ${properties}
 function packagedCsvPathForPlay(csvPath) {
   const playDir = process.cwd();
   const absoluteCsvPath = resolve9(csvPath);
-  const relativePath = relative2(playDir, absoluteCsvPath);
+  const relativePath = relative3(playDir, absoluteCsvPath);
   if (relativePath === "" || relativePath.startsWith("..") || isAbsolute3(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.`
@@ -9783,7 +9910,7 @@ async function runPlayBootstrap(args) {
     ...csvContext
   });
   if (options.out) {
-    writeFileSync6(resolve9(options.out), source, "utf-8");
+    writeFileSync7(resolve9(options.out), source, "utf-8");
     process.stdout.write(`Wrote ${resolve9(options.out)}
 `);
     return 0;
@@ -10258,15 +10385,15 @@ function materializeRemotePlaySource(input2) {
     return null;
   }
   const outputPath = input2.outPath ?? defaultMaterializedPlayPath(input2.playName);
-  if (existsSync7(outputPath)) {
-    const existingSource = readFileSync6(outputPath, "utf-8");
+  if (existsSync8(outputPath)) {
+    const existingSource = readFileSync7(outputPath, "utf-8");
     if (existingSource === input2.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    writeFileSync7(outputPath, input2.sourceCode, "utf-8");
+    writeFileSync8(outputPath, input2.sourceCode, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  writeFileSync7(outputPath, input2.sourceCode, "utf-8");
+  writeFileSync8(outputPath, input2.sourceCode, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -10311,7 +10438,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return existsSync7(resolve10(target));
+  return existsSync8(resolve10(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -10340,7 +10467,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? readFileSync6(resolve10(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? readFileSync7(resolve10(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.");
@@ -10442,7 +10569,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 existsSync7(resolve10(value));
+  return existsSync8(resolve10(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -10458,6 +10585,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());
 }
@@ -10480,7 +10616,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 && existsSync7(resolve10(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && existsSync8(resolve10(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -10523,7 +10659,7 @@ function preflightLocalFileInputs(runtimeInput) {
   }
   for (const ref of refs) {
     const absolutePath = resolve10(ref.value);
-    if (!existsSync7(absolutePath)) {
+    if (!existsSync8(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,
@@ -10559,7 +10695,7 @@ function preflightLocalFileInputs(runtimeInput) {
 function preflightCsvDataInput(ref, absolutePath) {
   let content;
   try {
-    content = readFileSync6(absolutePath, "utf-8");
+    content = readFileSync7(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.`,
@@ -10674,7 +10810,7 @@ async function stageFileInputArgs(input2) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = readFileSync6(absolutePath);
+  const buffer = readFileSync7(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
@@ -13465,7 +13601,7 @@ async function handlePlayCheck(args) {
     }
   }
   const absolutePlayPath = resolve10(options.target);
-  const sourceCode = readFileSync6(absolutePlayPath, "utf-8");
+  const sourceCode = readFileSync7(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -13549,7 +13685,7 @@ async function handleFileBackedRun(options) {
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => readFileSync6(absolutePlayPath, "utf-8")
+    () => readFileSync7(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   try {
@@ -13565,11 +13701,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();
@@ -13596,9 +13744,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",
@@ -13618,7 +13766,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 } : {},
@@ -13858,8 +14006,8 @@ async function handlePlayRun(args) {
     }
     const resolved = resolve10(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = dirname8(resolved);
-    if (existsSync7(dir)) {
+    const dir = dirname9(resolved);
+    if (existsSync8(dir)) {
       const base = basename3(resolved);
       try {
         const siblings = readdirSync(dir).filter(
@@ -13868,7 +14016,7 @@ async function handlePlayRun(args) {
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${join7(dir, s)}`);
+            console.error(`  ${join8(dir, s)}`);
           }
         }
       } catch {
@@ -14030,7 +14178,7 @@ async function handleRunLogs(args) {
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
     const logs = result2.entries;
-    writeFileSync7(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    writeFileSync8(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
       {
         runId: result2.runId,
@@ -14203,7 +14351,7 @@ async function handleRunExport(args) {
     }
   };
   if (metadataOutPath) {
-    writeFileSync7(
+    writeFileSync8(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -14238,7 +14386,7 @@ async function handlePlayGet(args) {
       outPath = resolve10(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName(readFileSync6(resolve10(target), "utf-8"), resolve10(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName(readFileSync7(resolve10(target), "utf-8"), resolve10(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({
@@ -14681,7 +14829,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          readFileSync6(resolve10(playName), "utf-8"),
+          readFileSync7(resolve10(playName), "utf-8"),
           playName
         );
       } catch {
@@ -17011,10 +17159,10 @@ function expandAtFilePath(rawPath) {
     (_match, bareName, bracedName) => process.env[bareName ?? bracedName ?? ""] ?? ""
   );
   if (expanded === "~") {
-    return homedir4();
+    return homedir5();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return join8(homedir4(), expanded.slice(2));
+    return join9(homedir5(), expanded.slice(2));
   }
   return expanded;
 }
@@ -17875,9 +18023,9 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0) {
     return null;
   }
-  const stateDir = join8(homedir4(), ".local", "deepline", "runtime", "state");
+  const stateDir = join9(homedir5(), ".local", "deepline", "runtime", "state");
   await mkdir4(stateDir, { recursive: true });
-  const reportPath = join8(
+  const reportPath = join9(
     stateDir,
     `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -18339,8 +18487,8 @@ function registerEnrichCommand(program) {
       forceAliases,
       playName: options.name
     });
-    const tempDir = await mkdtemp(join8(tmpdir3(), "deepline-enrich-play-"));
-    const tempPlay = join8(tempDir, "deepline-enrich.play.ts");
+    const tempDir = await mkdtemp(join9(tmpdir3(), "deepline-enrich-play-"));
+    const tempPlay = join9(tempDir, "deepline-enrich.play.ts");
     try {
       await writeFile4(tempPlay, playSource, "utf8");
       const runtimeInput = {
@@ -18506,15 +18654,15 @@ Examples:
 
 // src/cli/commands/sessions.ts
 import {
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   statSync as statSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir5, platform } from "os";
-import { basename as basename4, dirname as dirname9, join as join9, resolve as resolve12 } from "path";
+import { homedir as homedir6, platform } from "os";
+import { basename as basename4, dirname as dirname10, join as join10, resolve as resolve12 } from "path";
 import { gzipSync } from "zlib";
 import { randomUUID } from "crypto";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -18528,7 +18676,7 @@ 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() || homedir5();
+  return process.env.HOME?.trim() || homedir6();
 }
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
@@ -18540,21 +18688,21 @@ function detectShellContext() {
   };
 }
 function claudeProjectsRoot() {
-  return join9(homeDir(), ".claude", "projects");
+  return join10(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return join9(homeDir(), ".codex", "sessions");
+  return join10(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
-  if (!existsSync8(root)) return [];
+  if (!existsSync9(root)) return [];
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = join9(root, projectDir);
+    const fullProjectDir = join10(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = join9(fullProjectDir, fileName);
+        const filePath = join10(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
         const stat4 = statIfReadable(filePath);
         if (sessionId && stat4) {
@@ -18572,7 +18720,7 @@ function listClaudeSessionFiles() {
 }
 function listCodexSessionFiles() {
   const root = codexSessionsRoot();
-  if (!existsSync8(root)) return [];
+  if (!existsSync9(root)) return [];
   const files = [];
   for (const filePath of listJsonlFilesRecursive(root, 5)) {
     const stat4 = statIfReadable(filePath);
@@ -18611,7 +18759,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join9(dir, entry.name);
+      const fullPath = join10(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -18647,7 +18795,7 @@ function sessionIdFromCodexFilePath(filePath) {
 }
 function readCodexSessionId(filePath) {
   try {
-    for (const line of normalizedJsonLines(readFileSync7(filePath)).slice(
+    for (const line of normalizedJsonLines(readFileSync8(filePath)).slice(
       0,
       20
     )) {
@@ -18925,11 +19073,11 @@ async function uploadChunkedSessions(sessions, options) {
 async function handleSessionsSend(options) {
   if (options.file) {
     const filePath = resolve12(options.file);
-    if (!existsSync8(filePath)) {
+    if (!existsSync9(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
-      file: readFileSync7(filePath).toString("base64"),
+      file: readFileSync8(filePath).toString("base64"),
       filename: basename4(filePath)
     });
     printCommandEnvelope(
@@ -18959,7 +19107,7 @@ async function handleSessionsSend(options) {
     agent: options.agent
   });
   const built = targets.map((target) => {
-    const upload = buildSessionUploadContent(readFileSync7(target.filePath));
+    const upload = buildSessionUploadContent(readFileSync8(target.filePath));
     return { ...target, ...upload };
   });
   if (built.some((session) => session.needsChunking)) {
@@ -19026,25 +19174,25 @@ function loadViewerAssets() {
   const cliEntry = process.argv[1]?.trim() ? resolve12(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      join9(dirname9(dirname9(cliEntry)), "viewer"),
-      join9(
-        dirname9(dirname9(dirname9(cliEntry))),
+      join10(dirname10(dirname10(cliEntry)), "viewer"),
+      join10(
+        dirname10(dirname10(dirname10(cliEntry))),
         "src",
         "lib",
         "cli",
         "viewer"
       )
     ] : [],
-    join9(process.cwd(), "src", "lib", "cli", "viewer")
+    join10(process.cwd(), "src", "lib", "cli", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = join9(root, "viewer.css");
-      const jsPath = join9(root, "viewer.js");
-      if (!existsSync8(cssPath) || !existsSync8(jsPath)) continue;
+      const cssPath = join10(root, "viewer.css");
+      const jsPath = join10(root, "viewer.js");
+      if (!existsSync9(cssPath) || !existsSync9(jsPath)) continue;
       return {
-        css: readFileSync7(cssPath, "utf8"),
-        js: readFileSync7(jsPath, "utf8")
+        css: readFileSync8(cssPath, "utf8"),
+        js: readFileSync8(jsPath, "utf8")
       };
     } catch {
       continue;
@@ -19070,19 +19218,19 @@ async function handleSessionsRender(options) {
   });
   let outputPath = options.output ? resolve12(options.output) : "";
   if (!outputPath) {
-    const outputDir = join9(process.cwd(), "deepline", "data");
-    mkdirSync4(outputDir, { recursive: true });
-    outputPath = join9(
+    const outputDir = join10(process.cwd(), "deepline", "data");
+    mkdirSync5(outputDir, { recursive: true });
+    outputPath = join10(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    mkdirSync4(dirname9(outputPath), { recursive: true });
+    mkdirSync5(dirname10(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
     events: parsePreparedEvents(
-      prepareSessionBuffer(readFileSync7(target.filePath))
+      prepareSessionBuffer(readFileSync8(target.filePath))
     )
   }));
   const { css, js } = loadViewerAssets();
@@ -19105,7 +19253,7 @@ ${refreshMeta}
 <script>${js}</script>
 </body>
 </html>`;
-  writeFileSync8(outputPath, html, "utf8");
+  writeFileSync9(outputPath, html, "utf8");
   printCommandEnvelope(
     {
       ok: true,
@@ -19972,9 +20120,9 @@ Examples:
 }
 
 // src/cli/commands/switch.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname10, join as join10 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname11, join as join11 } from "path";
 function hostSlugFromBaseUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
@@ -19994,8 +20142,8 @@ function resolveConfigScope() {
   return hostSlugFromBaseUrl(autoDetectBaseUrl());
 }
 function activeFamilyPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || homedir6();
-  return join10(
+  const home = process.env.HOME || process.env.USERPROFILE || homedir7();
+  return join11(
     home,
     ".local",
     "deepline",
@@ -20007,15 +20155,15 @@ function activeFamilyPath() {
 function readActiveFamily() {
   const path = activeFamilyPath();
   try {
-    return readFileSync8(path, "utf-8").trim() || "sdk";
+    return readFileSync9(path, "utf-8").trim() || "sdk";
   } catch {
     return "sdk";
   }
 }
 function writeActiveFamily(family) {
   const path = activeFamilyPath();
-  mkdirSync5(dirname10(path), { recursive: true });
-  writeFileSync9(path, `${family}
+  mkdirSync6(dirname11(path), { recursive: true });
+  writeFileSync10(path, `${family}
 `, "utf-8");
   return path;
 }
@@ -20029,7 +20177,7 @@ function handleSwitch(action, options) {
         ok: true,
         active_family: activeFamily,
         active_family_path: path,
-        active_family_file_exists: existsSync9(path),
+        active_family_file_exists: existsSync10(path),
         render: {
           sections: [
             {
@@ -20131,18 +20279,18 @@ Examples:
 import { Option } from "commander";
 import {
   chmodSync,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdtempSync,
-  readFileSync as readFileSync9,
-  writeFileSync as writeFileSync11
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync12
 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join12, resolve as resolve13 } from "path";
+import { join as join13, resolve as resolve13 } from "path";
 
 // src/tool-output.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join11 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join12 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20238,19 +20386,19 @@ function tryConvertToList(payload, options) {
   return null;
 }
 function ensureOutputDir() {
-  const outputDir = join11(homedir7(), ".local", "share", "deepline", "data");
-  mkdirSync6(outputDir, { recursive: true });
+  const outputDir = join12(homedir8(), ".local", "share", "deepline", "data");
+  mkdirSync7(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join11(outputDir, `${stem}_${Date.now()}.json`);
-  writeFileSync10(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  const outputPath = join12(outputDir, `${stem}_${Date.now()}.json`);
+  writeFileSync11(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join11(outputDir, `${stem}_${Date.now()}.csv`);
+  const outputPath = join12(outputDir, `${stem}_${Date.now()}.csv`);
   const seen = /* @__PURE__ */ new Set();
   const columns = [];
   for (const row of rows) {
@@ -20273,7 +20421,7 @@ function writeCsvOutputFile(rows, stem) {
   for (const row of rows) {
     lines.push(columns.map((column) => escapeCell(row[column])).join(","));
   }
-  writeFileSync10(outputPath, `${lines.join("\n")}
+  writeFileSync11(outputPath, `${lines.join("\n")}
 `, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
@@ -21328,10 +21476,10 @@ function normalizeOutputFormat(raw) {
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
   const resolved = resolve13(trimmed);
-  if (existsSync10(resolved)) return resolved;
+  if (existsSync11(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
     const normalized = resolve13(trimmed.replace(/\\/g, "/"));
-    if (existsSync10(normalized)) return normalized;
+    if (existsSync11(normalized)) return normalized;
   }
   return resolved;
 }
@@ -21342,7 +21490,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return readFileSync9(resolveAtFilePath(filePath), "utf8").replace(
+    return readFileSync10(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -21444,9 +21592,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = mkdtempSync(join12(tmpdir4(), "deepline-workflow-seed-"));
+  const scriptDir = mkdtempSync(join13(tmpdir4(), "deepline-workflow-seed-"));
   chmodSync(scriptDir, 448);
-  const scriptPath = join12(scriptDir, fileName);
+  const scriptPath = join13(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(/\]$/, "")}, ...]` : "[]";
@@ -21482,7 +21630,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   };
 });
 `;
-  writeFileSync11(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  writeFileSync12(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -21747,7 +21895,7 @@ async function executeTool(args) {
 
 // src/cli/commands/workflow.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname11, join as join13, resolve as resolve14 } from "path";
+import { dirname as dirname12, join as join14, resolve as resolve14 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash4 } from "crypto";
@@ -21988,8 +22136,8 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join13(resolve14(outDir), `${compiled.playName}.play.ts`);
-    await mkdir5(dirname11(file), { recursive: true });
+    const file = join14(resolve14(outDir), `${compiled.playName}.play.ts`);
+    await mkdir5(dirname12(file), { recursive: true });
     await writeFile5(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
@@ -22236,8 +22384,8 @@ Notes:
 
 // src/cli/commands/update.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync11 } from "fs";
-import { dirname as dirname12, join as join14, resolve as resolve15 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { dirname as dirname13, join as join15, resolve as resolve15 } from "path";
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -22258,17 +22406,17 @@ function buildSourceUpdateCommand(sourceRoot) {
 function findRepoBackedSdkRoot(startPath) {
   let current = resolve15(startPath);
   while (true) {
-    if (existsSync11(join14(current, "sdk", "package.json")) && existsSync11(join14(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync12(join15(current, "sdk", "package.json")) && existsSync12(join15(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = dirname12(current);
+    const parent = dirname13(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveUpdatePlan() {
   const entrypoint = process.argv[1] ? resolve15(process.argv[1]) : "";
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname12(entrypoint)) : null;
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname13(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -22621,9 +22769,9 @@ async function maybeAutoUpdateAndRelaunch(response) {
 
 // src/cli/skills-sync.ts
 import { spawn as spawn4, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync12 } from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname13, join as join15 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname14, join as join16 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_PLAY_SKILL_NAME = "deepline-plays";
 var attemptedSync = false;
@@ -22637,20 +22785,20 @@ function activePluginSkillsDir() {
     return "";
   }
   const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && existsSync12(dir) ? dir : "";
+  return dir && existsSync13(dir) ? dir : "";
 }
 function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return readFileSync10(join15(dir, ".version"), "utf-8").trim();
+    return readFileSync11(join16(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
-  const home = process.env.HOME?.trim() || homedir8();
-  return join15(
+  const home = process.env.HOME?.trim() || homedir9();
+  return join16(
     home,
     ".local",
     "deepline",
@@ -22663,17 +22811,17 @@ function readLocalSkillsVersion(baseUrl) {
   const pluginVersion = readPluginSkillsVersion();
   if (pluginVersion) return pluginVersion;
   const path = sdkSkillsVersionPath(baseUrl);
-  if (!existsSync12(path)) return "";
+  if (!existsSync13(path)) return "";
   try {
-    return readFileSync10(path, "utf-8").trim();
+    return readFileSync11(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync7(dirname13(path), { recursive: true });
-  writeFileSync12(path, `${version}
+  mkdirSync8(dirname14(path), { recursive: true });
+  writeFileSync13(path, `${version}
 `, "utf-8");
 }
 function sortedUniqueSkillNames(names) {
@@ -23159,8 +23307,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join16(tmpdir5(), "deepline-health-play-"));
-  const file = join16(dir, "health-check.play.ts");
+  const dir = await mkdtemp2(join17(tmpdir5(), "deepline-health-play-"));
+  const file = join17(dir, "health-check.play.ts");
   try {
     await writeFile6(
       file,