deepline 0.1.12 → 0.1.19

package/dist/cli/index.mjs

@@ -47,6 +47,16 @@ var ConfigError = class extends DeeplineError {
 var PROD_URL = "https://code.deepline.com";
 var DEFAULT_TIMEOUT = 6e4;
 var DEFAULT_MAX_RETRIES = 3;
+var ACTIVE_DEEPLINE_ENV_FILE = ".env.deepline";
+function isProdBaseUrl(baseUrl) {
+  return baseUrl.trim().replace(/\/$/, "") === PROD_URL;
+}
+function profileNameForBaseUrl(baseUrl) {
+  return isProdBaseUrl(baseUrl) ? "prod" : "dev";
+}
+function projectEnvStartDir() {
+  return process.env.DEEPLINE_PROJECT_ENV_DIR?.trim() || process.cwd();
+}
 function baseUrlSlug(baseUrl) {
   let url;
   try {
@@ -82,16 +92,52 @@ function parseEnvFile(filePath) {
   }
   return env;
 }
-function findNearestWorktreeEnv(startDir = process.cwd()) {
+function findNearestEnvFile(names, startDir = process.cwd()) {
   let current = resolve(startDir);
   while (true) {
-    const values = parseEnvFile(join(current, ".env.worktree"));
-    if (Object.keys(values).length > 0) return values;
+    for (const name of names) {
+      const filePath = join(current, name);
+      if (existsSync(filePath)) return filePath;
+    }
     const parent = dirname(current);
-    if (parent === current) return {};
+    if (parent === current) return null;
     current = parent;
   }
 }
+function findNearestEnv(names, startDir = process.cwd()) {
+  const filePath = findNearestEnvFile(names, startDir);
+  return filePath ? parseEnvFile(filePath) : {};
+}
+function findNearestWorktreeEnv(startDir = process.cwd()) {
+  return findNearestEnv([".env.worktree"], startDir);
+}
+function resolveProfileEnvFileNames() {
+  const explicitProfile = process.env.DEEPLINE_ENV_PROFILE?.trim() || process.env.DEEPLINE_PROFILE?.trim() || "";
+  const names = [];
+  if (explicitProfile) names.push(`.env.deepline.${explicitProfile}`);
+  const nodeEnv = process.env.NODE_ENV?.trim();
+  if (nodeEnv === "production") names.push(".env.deepline.prod");
+  else if (nodeEnv === "staging") names.push(".env.deepline.staging");
+  names.push(ACTIVE_DEEPLINE_ENV_FILE);
+  return names;
+}
+function resolveProjectAppEnvFileNames() {
+  const nodeEnv = process.env.NODE_ENV?.trim();
+  const names = [];
+  if (nodeEnv === "production") names.push(".env.prod");
+  if (nodeEnv === "staging") names.push(".env.staging");
+  names.push(".env.local", ".env");
+  return names;
+}
+function resolveBaseUrlFromEnvValues(env) {
+  return env.DEEPLINE_ORIGIN_URL?.trim() || env.DEEPLINE_API_BASE_URL?.trim() || "";
+}
+function loadProjectDeeplineEnv() {
+  return findNearestEnv(resolveProfileEnvFileNames(), projectEnvStartDir());
+}
+function loadProjectAppEnv() {
+  return findNearestEnv(resolveProjectAppEnvFileNames(), projectEnvStartDir());
+}
 function normalizeWorktreeBaseUrl(baseUrl, worktreeEnv = findNearestWorktreeEnv()) {
   const trimmed = baseUrl.trim().replace(/\/$/, "");
   if (!trimmed) return trimmed;
@@ -143,6 +189,10 @@ function autoDetectBaseUrl() {
   if (envOrigin) return normalizeWorktreeBaseUrl(envOrigin);
   const envBase = process.env.DEEPLINE_API_BASE_URL?.trim();
   if (envBase) return normalizeWorktreeBaseUrl(envBase);
+  const projectDeeplineBaseUrl = resolveBaseUrlFromEnvValues(loadProjectDeeplineEnv());
+  if (projectDeeplineBaseUrl) return normalizeWorktreeBaseUrl(projectDeeplineBaseUrl);
+  const projectAppBaseUrl = resolveBaseUrlFromEnvValues(loadProjectAppEnv());
+  if (projectAppBaseUrl) return normalizeWorktreeBaseUrl(projectAppBaseUrl);
   const worktreeBaseUrl = resolveWorktreeBaseUrl();
   if (worktreeBaseUrl) return worktreeBaseUrl;
   const globalEnv = loadGlobalCliEnv();
@@ -154,7 +204,9 @@ function resolveConfig(options) {
   const requestedBaseUrl = options?.baseUrl?.trim() || autoDetectBaseUrl();
   const baseUrl = normalizeWorktreeBaseUrl(requestedBaseUrl);
   const cliEnv = loadCliEnv(baseUrl);
-  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || cliEnv.DEEPLINE_API_KEY || "";
+  const projectDeeplineEnv = loadProjectDeeplineEnv();
+  const projectAppEnv = loadProjectAppEnv();
+  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || projectDeeplineEnv.DEEPLINE_API_KEY || projectAppEnv.DEEPLINE_API_KEY || cliEnv.DEEPLINE_API_KEY || "";
   if (!apiKey) {
     throw new ConfigError(
       `No API key found. Set DEEPLINE_API_KEY env var, pass apiKey option, or run: deepline auth register`
@@ -167,10 +219,32 @@ function resolveConfig(options) {
     maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES
   };
 }
+function mergeEnvFile(filePath, values) {
+  const existing = existsSync(filePath) ? parseEnvFile(filePath) : {};
+  const merged = { ...existing, ...values };
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const lines = Object.entries(merged).filter(([, value]) => value !== "").map(([key, value]) => `${key}=${value}`);
+  writeFileSync(filePath, `${lines.join("\n")}
+`, "utf-8");
+}
+function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStartDir()) {
+  const root = resolve(startDir);
+  const profile = profileNameForBaseUrl(baseUrl);
+  const files = [
+    join(root, ACTIVE_DEEPLINE_ENV_FILE),
+    join(root, `.env.deepline.${profile}`)
+  ];
+  if (profile === "dev") files.push(join(root, ".env"));
+  for (const filePath of files) {
+    mergeEnvFile(filePath, values);
+  }
+  return files;
+}
 
 // src/version.ts
-var SDK_VERSION = "0.1.12";
-var SDK_API_CONTRACT = "2026-04-plays-v1";
+var SDK_VERSION = "0.1.19";
+var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
@@ -363,8 +437,12 @@ var HttpClient = class {
    * @param path - API path
    * @param body - Request body (will be JSON-serialized)
    */
-  async post(path, body) {
-    return this.request(path, { method: "POST", body });
+  async post(path, body, headers) {
+    return this.request(path, {
+      method: "POST",
+      body,
+      headers
+    });
   }
   /**
    * Send a DELETE request.
@@ -444,6 +522,7 @@ function sleep(ms) {
 
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -476,6 +555,7 @@ function mapLegacyTemporalStatus(status) {
 var DeeplineClient = class {
   http;
   config;
+  runs;
   /**
    * @param options - Optional overrides for API key, base URL, timeout, and retries.
    * @throws {@link ConfigError} if no API key can be resolved from any source.
@@ -483,6 +563,13 @@ var DeeplineClient = class {
   constructor(options) {
     this.config = resolveConfig(options);
     this.http = new HttpClient(this.config);
+    this.runs = {
+      get: (runId) => this.getRunStatus(runId),
+      list: (options2) => this.listRuns(options2),
+      tail: (runId, options2) => this.tailRun(runId, options2),
+      logs: (runId, options2) => this.getRunLogs(runId, options2),
+      stop: (runId, options2) => this.stopRun(runId, options2)
+    };
   }
   /** The resolved base URL this client is targeting (e.g. `"http://localhost:3000"`). */
   get baseUrl() {
@@ -571,6 +658,31 @@ var DeeplineClient = class {
     );
     return res.tools;
   }
+  /**
+   * Search available tools using Deepline's ranked backend search.
+   *
+   * This is the same discovery surface used by the legacy CLI: it ranks across
+   * tool metadata, categories, agent guidance, and input schema fields.
+   */
+  async searchTools(options = {}) {
+    const params = new URLSearchParams();
+    const query = options.query?.trim() ?? "";
+    params.set("q", query);
+    params.set(
+      "include_search_debug",
+      options.includeSearchDebug ? "true" : "false"
+    );
+    params.set("search_mode", options.searchMode ?? "v2");
+    if (options.categories?.trim()) {
+      params.set("categories", options.categories.trim());
+    }
+    if (options.searchTerms?.trim()) {
+      params.set("search_terms", options.searchTerms.trim());
+    }
+    return this.http.get(
+      `/api/v2/integrations/list?${params.toString()}`
+    );
+  }
   /**
    * Get detailed metadata for a single tool.
    *
@@ -606,12 +718,17 @@ var DeeplineClient = class {
    * Top-level fields such as `status`, `job_id`, and `billing` describe the
    * Deepline execution.
    */
-  async executeTool(toolId, input) {
+  async executeTool(toolId, input, options) {
+    const headers = options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : void 0;
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
-      { payload: input }
+      { payload: input },
+      headers
     );
   }
+  async executeToolRaw(toolId, input, options) {
+    return this.executeTool(toolId, input, options);
+  }
   async queryCustomerDb(input) {
     return this.http.post("/api/v2/db/query", {
       sql: input.sql,
@@ -660,6 +777,7 @@ var DeeplineClient = class {
       ...request.revisionId ? { revisionId: request.revisionId } : {},
       ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
       ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+      ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
       ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
       ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
       ...request.graphHash ? { graphHash: request.graphHash } : {},
@@ -684,6 +802,7 @@ var DeeplineClient = class {
       ...request.revisionId ? { revisionId: request.revisionId } : {},
       ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
       ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+      ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
       ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
       ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
       ...request.graphHash ? { graphHash: request.graphHash } : {},
@@ -720,6 +839,7 @@ var DeeplineClient = class {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact
     });
     return this.http.post("/api/v2/plays/artifacts", {
@@ -734,6 +854,7 @@ var DeeplineClient = class {
         compilerManifest: artifact.compilerManifest ?? await this.compilePlayManifest({
           name: artifact.name,
           sourceCode: artifact.sourceCode,
+          sourceFiles: artifact.sourceFiles,
           artifact: artifact.artifact
         })
       }))
@@ -760,11 +881,13 @@ var DeeplineClient = class {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact
     });
     const registeredArtifact = await this.registerPlayArtifact({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact,
       compilerManifest,
       publish: false
@@ -824,11 +947,13 @@ var DeeplineClient = class {
     const compilerManifest = options?.compilerManifest ?? await this.compilePlayManifest({
       name,
       sourceCode,
+      sourceFiles: options?.sourceFiles,
       artifact
     });
     const registeredArtifact = await this.registerPlayArtifact({
       name,
       sourceCode,
+      sourceFiles: options?.sourceFiles,
       artifact,
       compilerManifest,
       publish: false
@@ -1012,6 +1137,112 @@ var DeeplineClient = class {
     );
     return response.runs ?? [];
   }
+  /**
+   * Get a run by id using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs get <run-id> --json
+   * ```
+   */
+  async getRunStatus(runId) {
+    const response = await this.http.get(
+      `/api/v2/runs/${encodeURIComponent(runId)}`
+    );
+    return normalizePlayStatus(response);
+  }
+  /**
+   * List play runs using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs list --play <play-name> --status failed --json
+   * ```
+   */
+  async listRuns(options) {
+    const playName = options.play.trim();
+    if (!playName) {
+      throw new Error("runs.list requires options.play.");
+    }
+    const params = new URLSearchParams({ play: playName });
+    const status = options.status?.trim();
+    if (status) {
+      params.set("status", status);
+    }
+    const response = await this.http.get(
+      `/api/v2/runs?${params.toString()}`
+    );
+    return response.runs ?? [];
+  }
+  /**
+   * Fetch the lightweight tail status for a run using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs tail <run-id> --json
+   * ```
+   */
+  async tailRun(runId, options) {
+    const afterLogIndex = typeof options?.afterLogIndex === "number" ? options.afterLogIndex : typeof options?.cursor === "number" ? options.cursor : typeof options?.cursor === "string" && options.cursor.trim() ? Number(options.cursor) : void 0;
+    const params = new URLSearchParams();
+    if (Number.isFinite(afterLogIndex)) {
+      params.set("afterLogIndex", String(Number(afterLogIndex)));
+    }
+    if (typeof options?.waitMs === "number") {
+      params.set("waitMs", String(options.waitMs));
+    }
+    if (options?.terminalOnly) {
+      params.set("terminalOnly", "true");
+    }
+    const suffix = params.toString() ? `?${params.toString()}` : "";
+    const response = await this.http.get(
+      `/api/v2/runs/${encodeURIComponent(runId)}/tail${suffix}`
+    );
+    return normalizePlayStatus(response);
+  }
+  /**
+   * Fetch persisted logs for a run using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs logs <run-id> --limit 200 --json
+   * ```
+   */
+  async getRunLogs(runId, options) {
+    const status = await this.getRunStatus(runId);
+    const logs = status.progress?.logs ?? [];
+    const limit = typeof options?.limit === "number" && Number.isFinite(options.limit) ? Math.max(0, Math.trunc(options.limit)) : 200;
+    const entries = logs.slice(Math.max(0, logs.length - limit));
+    return {
+      runId: status.runId,
+      totalCount: logs.length,
+      returnedCount: entries.length,
+      firstSequence: logs.length === 0 ? null : logs.length - entries.length + 1,
+      lastSequence: logs.length === 0 ? null : logs.length,
+      truncated: logs.length > entries.length,
+      hasMore: logs.length > entries.length,
+      entries
+    };
+  }
+  /**
+   * Stop a run by id using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs stop <run-id> --reason "stale lock" --json
+   * ```
+   */
+  async stopRun(runId, options) {
+    return this.http.post(
+      `/api/v2/runs/${encodeURIComponent(runId)}/stop`,
+      options?.reason ? { reason: options.reason } : {}
+    );
+  }
   async listPlays() {
     const response = await this.http.get(
       "/api/v2/plays"
@@ -1398,6 +1629,7 @@ function saveEnvValues(values, baseUrl) {
   const merged = { ...existing, ...values };
   const lines = Object.entries(merged).filter(([, v]) => v !== "").map(([k, v]) => `${k}=${v}`);
   writeFileSync2(filePath, lines.join("\n") + "\n", "utf-8");
+  saveProjectDeeplineEnvValues(baseUrl, values);
 }
 async function httpJson(method, url, apiKey, body) {
   const headers = { "Content-Type": "application/json" };
@@ -1998,6 +2230,9 @@ function rowArray(value) {
 function readNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
 }
+function numericStat(value) {
+  return readNumber(value) ?? 0;
+}
 function inferColumns(rows) {
   const columns = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2077,6 +2312,31 @@ function extractCanonicalRowsInfo(statusOrResult) {
 function percentText(numerator, denominator) {
   return denominator > 0 ? `${numerator}/${denominator} (${Math.round(100 * numerator / denominator)}%)` : "0/0 (0%)";
 }
+function isDatasetExecutionStatsInput(value) {
+  return isRecord2(value) && isRecord2(value.columnStats) && Object.values(value.columnStats).every(isRecord2);
+}
+function extractDatasetExecutionStats(statusOrResult) {
+  if (!isRecord2(statusOrResult)) {
+    return null;
+  }
+  const direct = statusOrResult.dataset_execution_stats;
+  if (isDatasetExecutionStatsInput(direct)) {
+    return direct;
+  }
+  const nested = isRecord2(statusOrResult.result) ? statusOrResult.result.dataset_execution_stats : null;
+  return isDatasetExecutionStatsInput(nested) ? nested : null;
+}
+function formatExecutionStats(raw, denominator) {
+  return {
+    queued: percentText(numericStat(raw.queued), denominator),
+    running: percentText(numericStat(raw.running), denominator),
+    "completed:executed": percentText(numericStat(raw.completed), denominator),
+    "completed:reused": percentText(numericStat(raw.cached), denominator),
+    "skipped:condition": percentText(numericStat(raw.skipped), denominator),
+    "skipped:missed": percentText(numericStat(raw.missed), denominator),
+    failed: percentText(numericStat(raw.failed), denominator)
+  };
+}
 function countPercentText(count, denominator) {
   return denominator > 0 ? `${count} (${Math.round(100 * count / denominator)}%)` : "0 (0%)";
 }
@@ -2169,7 +2429,7 @@ function compactCell(value) {
   }
   return compactScalar(parsed, 120);
 }
-function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns(rows)) {
+function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns(rows), executionStats) {
   const sanitized = sanitizeCsvProjectionInfo({ rows, columns });
   const columnStats = {};
   for (const column of sanitized.columns) {
@@ -2197,6 +2457,10 @@ function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns
       non_empty: percentText(nonEmpty, denominator),
       unique: valueCounts.size
     };
+    const rawExecutionStats = executionStats?.columnStats[column];
+    if (rawExecutionStats) {
+      stat3.execution = formatExecutionStats(rawExecutionStats, totalRows);
+    }
     if (sampleValue !== void 0 && sampleValueType) {
       stat3.sample_value = sampleValue;
       stat3.sample_type = sampleValueType;
@@ -2549,7 +2813,6 @@ import { tmpdir } from "os";
 import { basename, dirname as dirname3, extname, isAbsolute, join as join3, resolve as resolve4 } from "path";
 import { builtinModules, createRequire } from "module";
 import { build } from "esbuild";
-import ts from "typescript";
 
 // ../shared_libs/play-runtime/backend.ts
 var PLAY_RUNTIME_BACKENDS = {
@@ -2633,56 +2896,6 @@ function formatEsbuildMessage(message) {
   const location = message.location ? `${message.location.file}:${message.location.line}:${message.location.column}` : null;
   return location ? `${location} ${message.text}` : message.text;
 }
-function formatTypeScriptDiagnostic(diagnostic) {
-  if (!diagnostic.file) {
-    const message2 = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n").trim();
-    return message2 || null;
-  }
-  const start = diagnostic.start ?? 0;
-  const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(start);
-  const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n").trim();
-  if (!message) {
-    return null;
-  }
-  return `${diagnostic.file.fileName}:${line + 1}:${character + 1} ${message}`;
-}
-function resolveBundledTypeRoots() {
-  try {
-    return [dirname3(dirname3(playArtifactRequire.resolve("@types/node/package.json")))];
-  } catch {
-    return [];
-  }
-}
-function typecheckPlaySource(input, adapter) {
-  const rootNames = Array.from(
-    /* @__PURE__ */ new Set([
-      ...input.importPolicy.localFiles,
-      ...input.importedPlayDependencies.map((dependency) => dependency.filePath)
-    ])
-  );
-  const sdkTypesPath = adapter.sdkTypesEntryFile ?? adapter.sdkEntryFile;
-  const program = ts.createProgram(rootNames, {
-    target: ts.ScriptTarget.ES2023,
-    // SDK source uses fetch/RequestInit/URL and node-aware config helpers.
-    // The play runtime import policy below still bans Node modules from play
-    // source for workers_edge bundles.
-    lib: ["lib.es2023.d.ts", "lib.dom.d.ts"],
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    paths: { deepline: [sdkTypesPath] },
-    strict: true,
-    skipLibCheck: true,
-    noEmit: true,
-    esModuleInterop: true,
-    allowSyntheticDefaultImports: true,
-    allowImportingTsExtensions: true,
-    allowJs: true,
-    resolveJsonModule: true,
-    types: ["node"],
-    typeRoots: resolveBundledTypeRoots()
-  });
-  return ts.getPreEmitDiagnostics(program).map(formatTypeScriptDiagnostic).filter((message) => Boolean(message));
-}
 function isLocalSpecifier(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || specifier.startsWith("file:");
 }
@@ -2706,11 +2919,8 @@ function assertWithinPlayWorkspace(input) {
   if (isPathInsideDirectory(input.resolvedPath, input.workspace.rootDir)) {
     return;
   }
-  const position = input.sourceFile.getLineAndCharacterOfPosition(
-    input.node.getStart(input.sourceFile)
-  );
   throw new Error(
-    `${input.importer}:${position.line + 1}:${position.character + 1} Local play imports must stay inside the play workspace (${input.workspace.rootDir}). Import "${input.specifier}" resolved to ${input.resolvedPath}, which crosses into app/backend code. Use the public SDK/API surface or move shared helpers into the play workspace.`
+    `${input.importer}:${input.line}:${input.column} Local play imports must stay inside the play workspace (${input.workspace.rootDir}). Import "${input.specifier}" resolved to ${input.resolvedPath}, which crosses into app/backend code. Use the public SDK/API surface or move shared helpers into the play workspace.`
   );
 }
 function getPackageName(specifier) {
@@ -2720,72 +2930,135 @@ function getPackageName(specifier) {
   }
   return specifier.split("/")[0] ?? specifier;
 }
-function scriptKindForFile(filePath) {
-  const extension = extname(filePath).toLowerCase();
-  switch (extension) {
-    case ".tsx":
-      return ts.ScriptKind.TSX;
-    case ".jsx":
-      return ts.ScriptKind.JSX;
-    case ".js":
-    case ".mjs":
-    case ".cjs":
-      return ts.ScriptKind.JS;
-    case ".json":
-      return ts.ScriptKind.JSON;
-    default:
-      return ts.ScriptKind.TS;
-  }
-}
 function isPlaySourceFile(filePath) {
   return PLAY_SOURCE_FILE_PATTERN.test(filePath);
 }
-function extractStringLiteralProperty(objectLiteral, propertyName) {
-  for (const property of objectLiteral.properties) {
-    if (!ts.isPropertyAssignment(property)) {
+function stripCommentsToSpaces(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
+    /(^|[^:])\/\/.*$/gm,
+    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
+  );
+}
+function lineAndColumnAt(source, index) {
+  const prefix = source.slice(0, index);
+  const lines = prefix.split("\n");
+  return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+}
+function findSourceImportReferences(sourceCode) {
+  const source = stripCommentsToSpaces(sourceCode);
+  const references = [];
+  const addReference = (specifier, specifierIndex, kind) => {
+    if (!specifier) return;
+    const position = lineAndColumnAt(sourceCode, specifierIndex);
+    references.push({
+      specifier,
+      line: position.line,
+      column: position.column,
+      kind
+    });
+  };
+  const staticImportPattern = /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(staticImportPattern)) {
+    addReference(match[2], match.index + match[0].lastIndexOf(match[1]), "static");
+  }
+  const dynamicImportPattern = /\bimport\s*\(\s*(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(dynamicImportPattern)) {
+    addReference(match[2], match.index + match[0].lastIndexOf(match[1]), "dynamic-import");
+  }
+  const requirePattern = /\brequire\s*\(\s*(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(requirePattern)) {
+    addReference(match[2], match.index + match[0].lastIndexOf(match[1]), "require");
+  }
+  const literalDynamicImportIndexes = new Set(
+    [...source.matchAll(dynamicImportPattern)].map((match) => match.index)
+  );
+  for (const match of source.matchAll(/\bimport\s*\(/g)) {
+    if (literalDynamicImportIndexes.has(match.index)) continue;
+    const position = lineAndColumnAt(sourceCode, match.index);
+    throw new Error(
+      `:${position.line}:${position.column} Dynamic import() is not allowed in plays. Use static imports instead.`
+    );
+  }
+  const literalRequireIndexes = new Set(
+    [...source.matchAll(requirePattern)].map((match) => match.index)
+  );
+  for (const match of source.matchAll(/\brequire\s*\(/g)) {
+    if (literalRequireIndexes.has(match.index)) continue;
+    const position = lineAndColumnAt(sourceCode, match.index);
+    throw new Error(
+      `:${position.line}:${position.column} Dynamic require() is not allowed in plays. Use static imports or require("literal") only.`
+    );
+  }
+  return references.sort(
+    (left, right) => left.line === right.line ? left.column - right.column : left.line - right.line
+  );
+}
+function unquoteStringLiteral(literal) {
+  const trimmed = literal.trim();
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
+    return null;
+  }
+  try {
+    return JSON.parse(quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`);
+  } catch {
+    return trimmed.slice(1, -1);
+  }
+}
+function findMatchingBrace(source, openIndex) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
       continue;
     }
-    const name = property.name;
-    const matches = ts.isIdentifier(name) && name.text === propertyName || ts.isStringLiteralLike(name) && name.text === propertyName;
-    if (!matches) {
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
       continue;
     }
-    return ts.isStringLiteralLike(property.initializer) ? property.initializer.text.trim() : null;
-  }
-  return null;
-}
-function extractDefinedPlayName(sourceCode, filePath) {
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    sourceCode,
-    ts.ScriptTarget.Latest,
-    true,
-    scriptKindForFile(filePath)
-  );
-  let detectedPlayName = null;
-  const visit = (node) => {
-    if (detectedPlayName) {
-      return;
-    }
-    if (ts.isCallExpression(node)) {
-      const expression = node.expression;
-      const isDefinePlayCall = ts.isIdentifier(expression) && (expression.text === "definePlay" || expression.text === "defineWorkflow") || ts.isPropertyAccessExpression(expression) && (expression.name.text === "definePlay" || expression.name.text === "defineWorkflow");
-      if (isDefinePlayCall) {
-        const firstArgument = node.arguments[0];
-        if (firstArgument && ts.isStringLiteralLike(firstArgument)) {
-          detectedPlayName = firstArgument.text.trim() || null;
-          return;
-        }
-        if (firstArgument && ts.isObjectLiteralExpression(firstArgument)) {
-          detectedPlayName = extractStringLiteralProperty(firstArgument, "id");
-          return;
-        }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function extractDefinedPlayName(sourceCode, _filePath) {
+  const source = stripCommentsToSpaces(sourceCode);
+  const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
+  for (const match of source.matchAll(callPattern)) {
+    const openParen = match.index + match[0].length - 1;
+    const firstArgStart = openParen + 1;
+    const firstNonSpace = source.slice(firstArgStart).search(/\S/);
+    if (firstNonSpace < 0) continue;
+    const argIndex = firstArgStart + firstNonSpace;
+    const quote = source[argIndex];
+    if (quote === '"' || quote === "'") {
+      const literalMatch = source.slice(argIndex).match(/^(['"])(?:\\.|(?!\1)[\s\S])*\1/);
+      const value = literalMatch ? unquoteStringLiteral(literalMatch[0]) : null;
+      if (value?.trim()) return value.trim();
+    }
+    if (quote === "{") {
+      const closeBrace = findMatchingBrace(source, argIndex);
+      if (closeBrace < 0) continue;
+      const objectSource = source.slice(argIndex + 1, closeBrace);
+      const idMatch = objectSource.match(/(?:^|[,{\s])(?:id|['"]id['"])\s*:\s*(['"])([\s\S]*?)\1/);
+      if (idMatch?.[2]?.trim()) {
+        return idMatch[2].trim();
       }
     }
-    ts.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return detectedPlayName;
+  }
+  return null;
 }
 function getPackageRequireCandidates(fromFile) {
   const candidates = [
@@ -3095,18 +3368,10 @@ async function analyzeSourceGraph(entryFile, adapter) {
     if (extname(absolutePath).toLowerCase() === ".json") {
       return;
     }
-    const sourceFile = ts.createSourceFile(
-      absolutePath,
-      sourceCode2,
-      ts.ScriptTarget.Latest,
-      true,
-      scriptKindForFile(absolutePath)
-    );
-    const handleSpecifier = async (specifier, node, kind) => {
+    const handleSpecifier = async (specifier, line, column, kind) => {
       if (kind === "dynamic-import") {
-        const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
         throw new Error(
-          `${absolutePath}:${position.line + 1}:${position.character + 1} Dynamic import() is not allowed in plays. Use static imports instead.`
+          `${absolutePath}:${line}:${column} Dynamic import() is not allowed in plays. Use static imports instead.`
         );
       }
       if (NODE_BUILTIN_SET.has(specifier)) {
@@ -3120,16 +3385,15 @@ async function analyzeSourceGraph(entryFile, adapter) {
           specifier,
           resolvedPath: resolved,
           workspace,
-          sourceFile,
-          node
+          line,
+          column
         });
         if (resolved !== absoluteEntryFile && isPlaySourceFile(resolved)) {
           const importedSource = await readFile(resolved, "utf-8");
           const importedPlayName = extractDefinedPlayName(importedSource, resolved);
           if (!importedPlayName) {
-            const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
             throw new Error(
-              `${absolutePath}:${position.line + 1}:${position.character + 1} Imported play file "${specifier}" must export definePlay(...) so it can be runtime-composed.`
+              `${absolutePath}:${line}:${column} Imported play file "${specifier}" must export definePlay(...) so it can be runtime-composed.`
             );
           }
           importedPlayDependencies.set(resolved, {
@@ -3142,44 +3406,28 @@ async function analyzeSourceGraph(entryFile, adapter) {
         return;
       }
       if (specifier.includes(":")) {
-        const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
         throw new Error(
-          `${absolutePath}:${position.line + 1}:${position.character + 1} Unsupported import specifier "${specifier}". Allowed imports are relative files, Node builtins, and installed packages.`
+          `${absolutePath}:${line}:${column} Unsupported import specifier "${specifier}". Allowed imports are relative files, Node builtins, and installed packages.`
         );
       }
       const packageImport = resolvePackageImport(specifier, absolutePath, adapter);
       packages.set(packageImport.name, packageImport.version);
     };
-    const walk = async (node) => {
-      if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && !(ts.isImportDeclaration(node) && node.importClause?.isTypeOnly || ts.isExportDeclaration(node) && node.isTypeOnly) && ts.isStringLiteralLike(node.moduleSpecifier)) {
-        await handleSpecifier(node.moduleSpecifier.text, node, "static");
-      }
-      if (ts.isCallExpression(node)) {
-        if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-          if (node.arguments.length !== 1 || !ts.isStringLiteralLike(node.arguments[0])) {
-            const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-            throw new Error(
-              `${absolutePath}:${position.line + 1}:${position.character + 1} Dynamic import() is not allowed in plays. Use static imports instead.`
-            );
-          }
-          await handleSpecifier(node.arguments[0].text, node, "dynamic-import");
-        }
-        if (ts.isIdentifier(node.expression) && node.expression.text === "require") {
-          const firstArgument = node.arguments[0];
-          if (node.arguments.length !== 1 || !firstArgument || !ts.isStringLiteralLike(firstArgument)) {
-            const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-            throw new Error(
-              `${absolutePath}:${position.line + 1}:${position.character + 1} Dynamic require() is not allowed in plays. Use static imports or require("literal") only.`
-            );
-          }
-          await handleSpecifier(firstArgument.text, node, "require");
-        }
+    try {
+      for (const reference of findSourceImportReferences(sourceCode2)) {
+        await handleSpecifier(
+          reference.specifier,
+          reference.line,
+          reference.column,
+          reference.kind
+        );
       }
-      for (const child of node.getChildren(sourceFile)) {
-        await walk(child);
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith(":")) {
+        throw new Error(`${absolutePath}${error.message}`);
       }
-    };
-    await walk(sourceFile);
+      throw error;
+    }
   };
   await visitFile(absoluteEntryFile);
   const sourceCode = localFiles.get(absoluteEntryFile) ?? "";
@@ -3199,6 +3447,11 @@ async function analyzeSourceGraph(entryFile, adapter) {
   const playName = extractDefinedPlayName(sourceCode, absoluteEntryFile);
   return {
     sourceCode,
+    sourceFiles: Object.fromEntries(
+      [...localFiles.entries()].sort(
+        (left, right) => left[0].localeCompare(right[0])
+      )
+    ),
     sourceHash,
     graphHash,
     importPolicy: {
@@ -3262,8 +3515,7 @@ function normalizeSourceMapForRuntime(sourceMapText) {
   parsed.sourceRoot = void 0;
   return JSON.stringify(parsed);
 }
-function getBundleSizeError(filePath, bundledCode, artifactKind) {
-  const bundleBytes = Buffer.byteLength(bundledCode, "utf8");
+function getBundleSizeErrorForBytes(filePath, bundleBytes, artifactKind) {
   if (bundleBytes > MAX_PLAY_BUNDLE_BYTES) {
     return `${filePath} Play bundle exceeds the 30 MiB limit (${bundleBytes} bytes > ${MAX_PLAY_BUNDLE_BYTES} bytes).`;
   }
@@ -3274,6 +3526,13 @@ function getBundleSizeError(filePath, bundledCode, artifactKind) {
   }
   return null;
 }
+function getBundleSizeError(filePath, bundledCode, artifactKind) {
+  return getBundleSizeErrorForBytes(
+    filePath,
+    Buffer.byteLength(bundledCode, "utf8"),
+    artifactKind
+  );
+}
 async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter, exportName) {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter);
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
@@ -3406,6 +3665,23 @@ entry-export:${exportName}`
 workers-harness:${harnessFingerprint}`
       );
     }
+    const typecheckErrors = [
+      ...await adapter.typecheckPlaySource?.({
+        sourceCode: analysis.sourceCode,
+        sourcePath: absolutePath,
+        importedFilePaths: [
+          ...analysis.importPolicy.localFiles,
+          ...analysis.importedPlayDependencies.map((dependency) => dependency.filePath)
+        ]
+      }) ?? []
+    ];
+    if (typecheckErrors.length > 0) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: typecheckErrors
+      };
+    }
     const cachedArtifact = await readArtifactCache(analysis.graphHash, target, adapter);
     const discoveredFiles = await adapter.discoverPackagedLocalFiles(absolutePath);
     if (cachedArtifact) {
@@ -3425,6 +3701,7 @@ workers-harness:${harnessFingerprint}`
         success: true,
         artifact: { ...cachedArtifact, cacheHit: true },
         sourceCode: analysis.sourceCode,
+        sourceFiles: analysis.sourceFiles,
         filePath: absolutePath,
         playName: analysis.playName,
         packagedFiles: discoveredFiles.files,
@@ -3432,24 +3709,6 @@ workers-harness:${harnessFingerprint}`
         importedPlayDependencies: analysis.importedPlayDependencies
       };
     }
-    const typecheckErrors = [
-      ...adapter.typecheckSdkTypes === false ? [] : typecheckPlaySource(analysis, adapter),
-      ...await adapter.typecheckPlaySource?.({
-        sourceCode: analysis.sourceCode,
-        sourcePath: absolutePath,
-        importedFilePaths: [
-          ...analysis.importPolicy.localFiles,
-          ...analysis.importedPlayDependencies.map((dependency) => dependency.filePath)
-        ]
-      }) ?? []
-    ];
-    if (typecheckErrors.length > 0) {
-      return {
-        success: false,
-        filePath: absolutePath,
-        errors: typecheckErrors
-      };
-    }
     const buildOutcome = target === PLAY_ARTIFACT_KINDS.esmWorkers ? await runEsbuildForEsmWorkers(absolutePath, analysis.importedPlayDependencies, adapter, exportName) : await runEsbuildForCjsNode(absolutePath, analysis.importedPlayDependencies, adapter, exportName);
     if (Array.isArray(buildOutcome)) {
       return {
@@ -3499,6 +3758,7 @@ workers-harness:${harnessFingerprint}`
       success: true,
       artifact,
       sourceCode: analysis.sourceCode,
+      sourceFiles: analysis.sourceFiles,
       filePath: absolutePath,
       playName: analysis.playName,
       packagedFiles: discoveredFiles.files,
@@ -3580,7 +3840,6 @@ function resolveExecutionProfile(override) {
 import { createHash as createHash2 } from "crypto";
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { basename as basename2, dirname as dirname4, extname as extname2, isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve5 } from "path";
-import ts2 from "typescript";
 var SOURCE_EXTENSIONS2 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
 function sha2562(buffer) {
   return createHash2("sha256").update(buffer).digest("hex");
@@ -3592,94 +3851,181 @@ function contentTypeForFile(filePath) {
   if (extension === ".txt") return "text/plain";
   return "application/octet-stream";
 }
-function isCtxCsvCall(node) {
-  if (!ts2.isPropertyAccessExpression(node.expression)) {
-    return false;
-  }
-  const target = node.expression.expression;
-  return ts2.isIdentifier(target) && (target.text === "ctx" || target.text.endsWith("Ctx")) && node.expression.name.text === "csv";
-}
-function extractSourceFragment(source, node) {
-  return source.slice(node.getStart(), node.getEnd()).trim();
-}
-function referencesInputIdentifier(node) {
-  if (ts2.isIdentifier(node) && node.text === "input") {
-    return true;
-  }
-  return node.getChildren().some((child) => referencesInputIdentifier(child));
+function stripCommentsToSpaces2(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
+    /(^|[^:])\/\/.*$/gm,
+    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
+  );
 }
-function isRuntimeInputExpression(node) {
-  if (ts2.isPropertyAccessExpression(node)) {
-    return ts2.isIdentifier(node.expression) && node.expression.text === "input";
-  }
-  if (ts2.isElementAccessExpression(node)) {
-    return ts2.isIdentifier(node.expression) && node.expression.text === "input";
-  }
-  if (ts2.isIdentifier(node)) {
-    return node.text === "input";
-  }
-  if (ts2.isParenthesizedExpression(node)) {
-    return isRuntimeInputExpression(node.expression);
+function unquoteStringLiteral2(literal) {
+  const trimmed = literal.trim();
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
+    return null;
   }
-  if (ts2.isBinaryExpression(node) && (node.operatorToken.kind === ts2.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === ts2.SyntaxKind.BarBarToken)) {
-    return isRuntimeInputExpression(node.left) || isRuntimeInputExpression(node.right);
+  try {
+    return JSON.parse(quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`);
+  } catch {
+    return trimmed.slice(1, -1);
   }
-  if (ts2.isConditionalExpression(node)) {
-    return isRuntimeInputExpression(node.condition) || isRuntimeInputExpression(node.whenTrue) || isRuntimeInputExpression(node.whenFalse);
+}
+function splitTopLevelPlus(expression) {
+  const parts = [];
+  let start = 0;
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < expression.length; index += 1) {
+    const char = expression[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth += 1;
+    if (char === ")" || char === "]" || char === "}") depth -= 1;
+    if (char === "+" && depth === 0) {
+      parts.push(expression.slice(start, index));
+      start = index + 1;
+    }
   }
-  return referencesInputIdentifier(node);
+  if (parts.length === 0) return null;
+  parts.push(expression.slice(start));
+  return parts;
 }
-function resolveStringExpression(node, constants) {
-  if (ts2.isStringLiteralLike(node) || ts2.isNoSubstitutionTemplateLiteral(node)) {
-    return node.text;
+function stripOuterParens(expression) {
+  let value = expression.trim();
+  while (value.startsWith("(") && value.endsWith(")")) {
+    value = value.slice(1, -1).trim();
   }
-  if (ts2.isParenthesizedExpression(node)) {
-    return resolveStringExpression(node.expression, constants);
+  return value;
+}
+function isRuntimeInputExpression(expression) {
+  return /(^|[^\w$])input([^\w$]|$)/.test(expression);
+}
+function resolveStringExpression(expression, constants) {
+  const value = stripOuterParens(expression);
+  if (/^(['"])(?:\\.|(?!\1)[\s\S])*\1$/.test(value)) {
+    return unquoteStringLiteral2(value);
   }
-  if (ts2.isIdentifier(node)) {
-    return constants.get(node.text) ?? null;
+  if (/^`(?:\\.|[^`$]|\$(?!\{))*`$/.test(value)) {
+    return value.slice(1, -1);
   }
-  if (ts2.isTemplateExpression(node)) {
-    let value = node.head.text;
-    for (const span of node.templateSpans) {
-      const resolved = resolveStringExpression(span.expression, constants);
-      if (resolved == null) {
-        return null;
-      }
-      value += resolved + span.literal.text;
-    }
-    return value;
+  if (/^[A-Za-z_$][\w$]*$/.test(value)) {
+    return constants.get(value) ?? null;
   }
-  if (ts2.isBinaryExpression(node) && node.operatorToken.kind === ts2.SyntaxKind.PlusToken) {
-    const left = resolveStringExpression(node.left, constants);
-    const right = resolveStringExpression(node.right, constants);
-    if (left == null || right == null) {
-      return null;
-    }
-    return left + right;
+  const parts = splitTopLevelPlus(value);
+  if (parts) {
+    const resolved = parts.map((part) => resolveStringExpression(part, constants));
+    return resolved.every((part) => part != null) ? resolved.join("") : null;
   }
   return null;
 }
-function collectTopLevelStringConstants(sourceFile) {
+function collectTopLevelStringConstants(sourceCode) {
   const constants = /* @__PURE__ */ new Map();
-  for (const statement of sourceFile.statements) {
-    if (!ts2.isVariableStatement(statement)) {
+  const source = stripCommentsToSpaces2(sourceCode);
+  for (const match of source.matchAll(/(?:^|\n)\s*const\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/g)) {
+    const resolved = resolveStringExpression(match[2], constants);
+    if (resolved != null) {
+      constants.set(match[1], resolved);
+    }
+  }
+  return constants;
+}
+function findMatchingGenericEnd(source, openIndex) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
       continue;
     }
-    if (!(statement.declarationList.flags & ts2.NodeFlags.Const)) {
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
       continue;
     }
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts2.isIdentifier(declaration.name) || !declaration.initializer) {
-        continue;
-      }
-      const resolved = resolveStringExpression(declaration.initializer, constants);
-      if (resolved != null) {
-        constants.set(declaration.name.text, resolved);
+    if (char === "<") depth += 1;
+    if (char === ">") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function findCallOpenParen(source, afterCsvIndex) {
+  let index = afterCsvIndex;
+  while (/\s/.test(source[index] ?? "")) index += 1;
+  if (source[index] === "<") {
+    const genericEnd = findMatchingGenericEnd(source, index);
+    if (genericEnd < 0) return -1;
+    index = genericEnd + 1;
+    while (/\s/.test(source[index] ?? "")) index += 1;
+  }
+  return source[index] === "(" ? index : -1;
+}
+function firstCallArgument(source, openParen) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  const start = openParen + 1;
+  for (let index = start; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
       }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth += 1;
+    if (char === ")" && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
     }
+    if (char === "," && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
+    }
+    if (char === ")" || char === "]" || char === "}") depth -= 1;
   }
-  return constants;
+  return null;
+}
+function localImportSpecifiers(sourceCode) {
+  const source = stripCommentsToSpaces2(sourceCode);
+  const specifiers = [];
+  for (const match of source.matchAll(
+    /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]/g
+  )) {
+    if (match[1]?.startsWith(".")) specifiers.push(match[1]);
+  }
+  for (const match of source.matchAll(/\brequire\s*\(\s*(['"])(\.[^'"]*)\1\s*\)/g)) {
+    specifiers.push(match[2]);
+  }
+  return specifiers;
 }
 async function fileExists2(filePath) {
   try {
@@ -3724,69 +4070,60 @@ async function discoverPackagedLocalFiles(entryFile) {
     }
     visitedFiles.add(absolutePath);
     const sourceCode = await readFile2(absolutePath, "utf-8");
-    const sourceFile = ts2.createSourceFile(
-      absolutePath,
-      sourceCode,
-      ts2.ScriptTarget.Latest,
-      true,
-      ts2.ScriptKind.TS
-    );
-    const constants = collectTopLevelStringConstants(sourceFile);
+    const scanSource = stripCommentsToSpaces2(sourceCode);
+    const constants = collectTopLevelStringConstants(sourceCode);
     const childVisits = [];
-    const visitNode = async (node) => {
-      if (ts2.isCallExpression(node) && isCtxCsvCall(node)) {
-        const argument = node.arguments[0];
-        if (!argument) {
+    for (const match of scanSource.matchAll(/\b([A-Za-z_$][\w$]*)\s*\.\s*csv\b/g)) {
+      const target = match[1];
+      if (target !== "ctx" && !target.endsWith("Ctx")) {
+        continue;
+      }
+      const openParen = findCallOpenParen(scanSource, match.index + match[0].length);
+      if (openParen < 0) {
+        continue;
+      }
+      const argument = firstCallArgument(scanSource, openParen);
+      if (!argument) {
+        unresolved.push({
+          sourceFragment: "ctx.csv()",
+          message: "ctx.csv() requires a file path string or input reference."
+        });
+      } else if (!isRuntimeInputExpression(argument.text)) {
+        const resolvedPath = resolveStringExpression(argument.text, constants);
+        if (resolvedPath == null) {
           unresolved.push({
-            sourceFragment: "ctx.csv()",
-            message: "ctx.csv() requires a file path string or input reference."
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            message: "Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file."
           });
-        } else if (!isRuntimeInputExpression(argument)) {
-          const resolvedPath = resolveStringExpression(argument, constants);
-          if (resolvedPath == null) {
+        } else {
+          const absoluteCsvPath = resolve5(dirname4(absolutePath), resolvedPath);
+          if (isAbsolute2(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
             unresolved.push({
-              sourceFragment: extractSourceFragment(sourceCode, argument),
-              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 = resolve5(dirname4(absolutePath), resolvedPath);
-            if (isAbsolute2(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
-              unresolved.push({
-                sourceFragment: extractSourceFragment(sourceCode, argument),
-                message: "ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead."
-              });
-              return;
-            }
-            const buffer = await readFile2(absoluteCsvPath);
-            const stats = await stat2(absoluteCsvPath);
-            files.set(absoluteCsvPath, {
-              sourceFragment: extractSourceFragment(sourceCode, argument),
-              logicalPath: resolvedPath,
-              absolutePath: absoluteCsvPath,
-              bytes: stats.size,
-              contentHash: sha2562(buffer),
-              contentType: contentTypeForFile(absoluteCsvPath)
+              sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+              message: "ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead."
             });
+            continue;
           }
+          const buffer = await readFile2(absoluteCsvPath);
+          const stats = await stat2(absoluteCsvPath);
+          files.set(absoluteCsvPath, {
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            logicalPath: resolvedPath,
+            absolutePath: absoluteCsvPath,
+            bytes: stats.size,
+            contentHash: sha2562(buffer),
+            contentType: contentTypeForFile(absoluteCsvPath)
+          });
         }
       }
-      if (ts2.isImportDeclaration(node) && !node.importClause?.isTypeOnly && ts2.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.startsWith(".")) {
-        childVisits.push(
-          resolveLocalImport2(absolutePath, node.moduleSpecifier.text).then(
-            (resolvedImport) => visitSourceFile(resolvedImport)
-          )
-        );
-      }
-      if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1 && ts2.isStringLiteral(node.arguments[0]) && node.arguments[0].text.startsWith(".")) {
-        childVisits.push(
-          resolveLocalImport2(absolutePath, node.arguments[0].text).then(
-            (resolvedImport) => visitSourceFile(resolvedImport)
-          )
-        );
-      }
-      await Promise.all(node.getChildren(sourceFile).map((child) => visitNode(child)));
-    };
-    await visitNode(sourceFile);
+    }
+    for (const specifier of localImportSpecifiers(sourceCode)) {
+      childVisits.push(
+        resolveLocalImport2(absolutePath, specifier).then(
+          (resolvedImport) => visitSourceFile(resolvedImport)
+        )
+      );
+    }
     await Promise.all(childVisits);
   };
   await visitSourceFile(absoluteEntryFile);
@@ -3797,7 +4134,7 @@ async function discoverPackagedLocalFiles(entryFile) {
 }
 
 // src/plays/bundle-play-file.ts
-var PLAY_BUNDLE_CACHE_VERSION2 = 24;
+var PLAY_BUNDLE_CACHE_VERSION2 = 26;
 var MODULE_DIR = dirname5(fileURLToPath(import.meta.url));
 var SDK_PACKAGE_ROOT = resolve6(MODULE_DIR, "..", "..");
 var SOURCE_REPO_ROOT = resolve6(SDK_PACKAGE_ROOT, "..");
@@ -3812,7 +4149,7 @@ var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED
 var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? resolve6(SOURCE_REPO_ROOT, "sdk", "src") : HAS_PACKAGED_BUNDLING_SOURCES ? resolve6(PACKAGED_REPO_ROOT, "sdk", "src") : resolve6(SDK_PACKAGE_ROOT, "src");
 var SDK_PACKAGE_JSON = resolve6(SDK_PACKAGE_ROOT, "package.json");
 var SDK_ENTRY_FILE = resolve6(SDK_SOURCE_ROOT, "index.ts");
-var SDK_TYPES_ENTRY_FILE = resolve6(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
+var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : resolve6(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
 var SDK_WORKERS_ENTRY_FILE = resolve6(SDK_SOURCE_ROOT, "worker-play-entry.ts");
 var WORKERS_HARNESS_ENTRY_FILE = resolve6(PROJECT_ROOT, "apps", "play-runner-workers", "src", "entry.ts");
 var WORKERS_HARNESS_FILES_DIR = resolve6(PROJECT_ROOT, "apps", "play-runner-workers", "src");
@@ -3844,7 +4181,7 @@ function createSdkPlayBundlingAdapter() {
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : existsSync3(SDK_TYPES_ENTRY_FILE) ? SDK_TYPES_ENTRY_FILE : SDK_ENTRY_FILE,
+    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync3(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,
@@ -4081,13 +4418,15 @@ function formatLoadedPlayMessage(materializedFile) {
   return `Loaded play here: ${materializedFile.path}`;
 }
 function buildReadonlyPrebuiltPlayError(reference) {
+  const localName = reference.split("/").slice(1).join("/") || "custom-play";
   return new Error(
     `Cannot edit or push ${reference} because Deepline prebuilt plays are read-only.
 To make your own version:
-1. Copy the source into a new local file.
-2. Change definePlay('${reference.split("/").slice(1).join("/")}', ...) to a new play name you own.
-3. Run: deepline plays publish <your-file.play.ts>
-4. Your play will then live under your workspace namespace.`
+1. Run: deepline plays get ${reference} --source --out ./${localName}.play.ts
+2. Change definePlay('${localName}', ...) to a new play name you own.
+3. Run: deepline plays check ./${localName}.play.ts
+4. Run: deepline plays publish ./${localName}.play.ts
+5. Your play will then live under your workspace namespace.`
   );
 }
 async function ensureEditableRemotePlay(client, target) {
@@ -4228,6 +4567,15 @@ function fileInputBindingsFromStaticPipeline(staticPipeline) {
   );
   return inputField ? [{ inputPath: inputField }] : [];
 }
+function applyCsvShortcutInput(input) {
+  const csvValue = getDottedInputValue(input.runtimeInput, "csv");
+  if (csvValue == null || csvValue === "") return;
+  const candidate = input.bindings.find((binding) => binding.inputPath !== "csv")?.inputPath ?? input.fallbackInputPath ?? null;
+  if (!candidate || candidate === "csv") return;
+  const existing = getDottedInputValue(input.runtimeInput, candidate);
+  if (existing != null && existing !== "") return;
+  setDottedInputValue(input.runtimeInput, candidate, csvValue);
+}
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
@@ -4351,6 +4699,7 @@ async function compileBundledPlayGraphManifests(client, graph) {
       node.compilerManifest = await client.compilePlayManifest({
         name,
         sourceCode: node.sourceCode,
+        sourceFiles: node.sourceFiles,
         artifact: node.artifact,
         importedPlayDependencies: node.importedPlayDependencies.map(
           (dependency) => {
@@ -4400,6 +4749,7 @@ async function publishImportedPlayDependencies(client, graph) {
     await client.registerPlayArtifact({
       name: node.playName,
       sourceCode: node.sourceCode,
+      sourceFiles: node.sourceFiles,
       artifact: node.artifact,
       compilerManifest: requireCompilerManifest(node),
       publish: true
@@ -4417,67 +4767,6 @@ function formatTimestamp(value) {
 function formatRunLine(run) {
   return `${run.workflowId} ${run.status} ${formatTimestamp(run.startTime)}`;
 }
-function parsePlayRunTarget(input) {
-  const { args, usage } = input;
-  let runId = null;
-  let playName = null;
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--json") {
-      continue;
-    }
-    if (arg === "--reason" || arg === "--interval-ms" || arg === "--poll-interval-ms") {
-      index += 1;
-      continue;
-    }
-    if (arg === "--run-id" && args[index + 1]) {
-      runId = args[++index].trim();
-      continue;
-    }
-    if (arg === "--name" && args[index + 1] && input.allowName) {
-      playName = parseReferencedPlayTarget(args[++index]).playName;
-      continue;
-    }
-    if (arg.startsWith("--")) {
-      continue;
-    }
-    throw new DeeplineError(
-      `Unexpected positional target "${arg}". Use --run-id for run ids.
-${usage}`
-    );
-  }
-  const explicitTargets = [runId, playName].filter(Boolean).length;
-  if (explicitTargets > 1) {
-    throw new DeeplineError(`Choose exactly one play run target.
-${usage}`);
-  }
-  if (runId) {
-    return { kind: "run", runId };
-  }
-  if (playName) {
-    return { kind: "name", name: playName };
-  }
-  throw new DeeplineError(usage);
-}
-async function resolvePlayRunId(client, target) {
-  if (target.kind === "run") {
-    try {
-      const status = await client.getPlayStatus(target.runId);
-      return status.runId;
-    } catch (error) {
-      if (!(error instanceof DeeplineError) || error.statusCode !== 404) {
-        throw error;
-      }
-      throw new DeeplineError(`No play run found for run id: ${target.runId}`);
-    }
-  }
-  const runs = await client.listPlayRuns(target.name);
-  const workflowId = runs[0]?.workflowId ?? "";
-  if (!workflowId) {
-    throw new DeeplineError(`No runs found for play: ${target.name}`);
-  }
-  return workflowId;
-}
 function isTransientPlayStatusPollError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
     return error.statusCode >= 500 && error.statusCode < 600;
@@ -4581,7 +4870,7 @@ function assertPlayWaitNotTimedOut(input) {
   if (input.waitTimeoutMs !== null && Date.now() - input.startedAt >= input.waitTimeoutMs) {
     const hasRealRunId = input.workflowId.length > 0 && input.workflowId !== "pending";
     const phaseSuffix = input.lastPhase && input.lastPhase.trim() ? ` (last observed phase: ${input.lastPhase.trim()})` : "";
-    const tailHint = hasRealRunId ? ` Run 'deepline play tail --run-id ${input.workflowId} --json' to inspect it, or rerun with a larger --tail-timeout-ms.` : ` The run never reported a workflow id \u2014 the start request likely failed before reaching the scheduler. Check server logs and rerun with a larger --tail-timeout-ms.`;
+    const tailHint = hasRealRunId ? ` Run 'deepline runs tail ${input.workflowId} --json' to inspect it, or rerun with a larger --tail-timeout-ms.` : ` The run never reported a workflow id \u2014 the start request likely failed before reaching the scheduler. Check server logs and rerun with a larger --tail-timeout-ms.`;
     throw new DeeplineError(
       `Timed out waiting for play ${hasRealRunId ? input.workflowId : "<no run id>"} after ${Math.ceil(input.waitTimeoutMs / 1e3)}s${phaseSuffix}.${tailHint}`,
       void 0,
@@ -4594,66 +4883,6 @@ function assertPlayWaitNotTimedOut(input) {
     );
   }
 }
-async function waitForPlayCompletionByStream(input) {
-  const controller = new AbortController();
-  let timedOut = false;
-  let lastPhase = null;
-  const timeout = input.waitTimeoutMs === null ? null : setTimeout(
-    () => {
-      timedOut = true;
-      controller.abort();
-    },
-    Math.max(1, input.waitTimeoutMs - (Date.now() - input.startedAt))
-  );
-  try {
-    for await (const event of input.client.streamPlayRunEvents(
-      input.workflowId,
-      { signal: controller.signal }
-    )) {
-      assertPlayWaitNotTimedOut({ ...input, lastPhase });
-      const phase = describeLiveEventPhase(event);
-      if (phase) {
-        lastPhase = phase;
-        input.progress.phase(phase);
-      }
-      printPlayLogLines({
-        lines: getLogLinesFromLiveEvent(event),
-        status: null,
-        jsonOutput: input.jsonOutput,
-        emitLogs: input.emitLogs,
-        state: input.state,
-        progress: input.progress
-      });
-      const status = getStatusFromLiveEvent(event);
-      if (status && TERMINAL_PLAY_STATUSES2.has(status)) {
-        const finalStatus = await input.client.getPlayStatus(input.workflowId);
-        if (TERMINAL_PLAY_STATUSES2.has(finalStatus.status)) {
-          return finalStatus;
-        }
-      }
-    }
-  } catch (error) {
-    if (timedOut) {
-      assertPlayWaitNotTimedOut({ ...input, lastPhase });
-    }
-    throw error;
-  } finally {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-  }
-  const phaseSuffix = lastPhase && lastPhase.trim() ? ` (last observed phase: ${lastPhase.trim()})` : "";
-  throw new DeeplineError(
-    `Play live stream ended before the run reached a terminal state runId=${input.workflowId}${phaseSuffix}.`,
-    void 0,
-    "PLAY_LIVE_STREAM_ENDED",
-    {
-      runId: input.workflowId,
-      workflowId: input.workflowId,
-      ...lastPhase ? { phase: lastPhase } : {}
-    }
-  );
-}
 async function startAndWaitForPlayCompletionByStream(input) {
   const startedAt = Date.now();
   const state = {
@@ -4733,10 +4962,12 @@ async function startAndWaitForPlayCompletionByStream(input) {
         clearTimeout(timeout);
       }
       const reason = error instanceof Error ? error.message : String(error);
-      process.stderr.write(
-        `[play watch] start stream failed after run ${lastKnownWorkflowId}; falling back to polling (${reason})
+      if (!input.jsonOutput) {
+        process.stderr.write(
+          `[play watch] start stream failed after run ${lastKnownWorkflowId}; falling back to polling (${reason})
 `
-      );
+        );
+      }
       return waitForPlayCompletionByPolling({
         client: input.client,
         workflowId: lastKnownWorkflowId,
@@ -4755,6 +4986,24 @@ async function startAndWaitForPlayCompletionByStream(input) {
       clearTimeout(timeout);
     }
   }
+  if (lastKnownWorkflowId) {
+    if (!input.jsonOutput) {
+      input.progress.writeLine(
+        `[play watch] start stream ended after run ${lastKnownWorkflowId}; falling back to polling`
+      );
+    }
+    return waitForPlayCompletionByPolling({
+      client: input.client,
+      workflowId: lastKnownWorkflowId,
+      pollIntervalMs: 500,
+      jsonOutput: input.jsonOutput,
+      emitLogs: input.emitLogs,
+      waitTimeoutMs: input.waitTimeoutMs,
+      startedAt,
+      state,
+      progress: input.progress
+    });
+  }
   const phaseSuffix = lastPhase && lastPhase.trim() ? ` (last observed phase: ${lastPhase.trim()})` : "";
   const idSuffix = lastKnownWorkflowId ? ` runId=${lastKnownWorkflowId}` : "";
   throw new DeeplineError(
@@ -4832,38 +5081,6 @@ async function waitForPlayCompletionByPolling(input) {
     }
   }
 }
-async function waitForPlayCompletion(input) {
-  const startedAt = Date.now();
-  const state = {
-    lastLogIndex: 0,
-    emittedRunnerStarted: false
-  };
-  try {
-    return await waitForPlayCompletionByStream({
-      ...input,
-      startedAt,
-      state,
-      progress: input.progress
-    });
-  } catch (error) {
-    assertPlayWaitNotTimedOut({
-      workflowId: input.workflowId,
-      startedAt,
-      waitTimeoutMs: input.waitTimeoutMs
-    });
-    const reason = error instanceof Error ? error.message : String(error);
-    process.stderr.write(
-      `[play watch] SSE stream failed; falling back to polling (${reason})
-`
-    );
-    return waitForPlayCompletionByPolling({
-      ...input,
-      startedAt,
-      state,
-      progress: input.progress
-    });
-  }
-}
 function formatInteger(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toLocaleString("en-US") : String(value ?? "-");
 }
@@ -4992,17 +5209,153 @@ function buildRunWarnings(status, rowsInfo) {
 }
 function buildRunNextCommands(runId) {
   return {
-    exportCsv: `deepline runs export ${runId} --out output.csv`,
-    status: `deepline runs status ${runId} --json`,
-    logs: `deepline runs logs ${runId}`
+    get: `deepline runs get ${runId} --json`,
+    tail: `deepline runs tail ${runId} --json`,
+    stop: `deepline runs stop ${runId} --reason "stale lock" --json`,
+    logs: `deepline runs logs ${runId} --out run.log --json`,
+    exportCsv: `deepline runs export ${runId} --out output.csv`
+  };
+}
+var RUN_LOG_PREVIEW_LIMIT = 20;
+function getRecordField(value, key) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value[key] : void 0;
+}
+function getNumericField(value, key) {
+  const field = getRecordField(value, key);
+  return typeof field === "number" && Number.isFinite(field) ? field : null;
+}
+function getStringField(value, key) {
+  const field = getRecordField(value, key);
+  return typeof field === "string" && field.trim() ? field : null;
+}
+function normalizeRunStatusForEnvelope(status) {
+  const run = status.run ?? null;
+  return {
+    id: status.runId,
+    playName: status.playName ?? status.name ?? getStringField(run, "playName") ?? null,
+    status: status.status,
+    runtime: getStringField(status, "runtime") ?? getStringField(status, "runtimeBackend") ?? getStringField(run, "runtime") ?? null,
+    startedAt: getStringField(run, "startTime") ?? getStringField(run, "startedAt") ?? null,
+    updatedAt: getStringField(status, "updatedAt") ?? getStringField(run, "updatedAt") ?? null,
+    finishedAt: getStringField(run, "closeTime") ?? getStringField(run, "finishedAt") ?? null,
+    source: getRecordField(status, "source") ?? getRecordField(status, "artifact") ?? null
+  };
+}
+function normalizeProgressForEnvelope(status, rowsInfo) {
+  const progress = status.progress;
+  const total = getNumericField(progress, "totalRows") ?? getNumericField(progress, "total") ?? rowsInfo?.totalRows ?? null;
+  const failed = getNumericField(progress, "failed") ?? getNumericField(progress, "failedRows") ?? null;
+  const completed = getNumericField(progress, "completed") ?? getNumericField(progress, "completedRows") ?? (status.status === "completed" ? total : null);
+  const pending = getNumericField(progress, "pending") ?? (typeof total === "number" && typeof completed === "number" && typeof failed === "number" ? Math.max(0, total - completed - failed) : null);
+  return {
+    total,
+    completed,
+    pending,
+    failed,
+    executed: getNumericField(progress, "executed"),
+    reused: getNumericField(progress, "reused"),
+    skipped: getNumericField(progress, "skipped"),
+    retried: getNumericField(progress, "retried"),
+    degraded: typeof getRecordField(progress, "degraded") === "boolean" ? getRecordField(progress, "degraded") : null,
+    duplicates: getRecordField(progress, "duplicates") ?? null,
+    active: getStringField(progress, "status") ?? getStringField(status, "activeStep") ?? getStringField(status, "activeNodeId") ?? null,
+    wait: status.wait ?? null
+  };
+}
+function normalizeOutputsForEnvelope(rowsInfo, exportedPath) {
+  if (!rowsInfo) {
+    return exportedPath ? [{ name: "output", kind: "file", path: exportedPath }] : [];
+  }
+  return [
+    {
+      name: "rows",
+      kind: "dataset",
+      rowCount: rowsInfo.totalRows,
+      columns: rowsInfo.columns,
+      preview: rowsInfo.rows.slice(0, 5),
+      previewRowCount: Math.min(rowsInfo.rows.length, 5),
+      previewLimit: 5,
+      complete: rowsInfo.complete,
+      source: rowsInfo.source,
+      ...exportedPath ? { csv_path: exportedPath } : {}
+    }
+  ];
+}
+function normalizeStepsForEnvelope(status) {
+  const directSteps = getRecordField(status, "steps");
+  if (Array.isArray(directSteps)) {
+    return directSteps;
+  }
+  const timeline = getRecordField(status, "timeline");
+  if (Array.isArray(timeline)) {
+    return timeline;
+  }
+  return [];
+}
+function normalizeErrorsForEnvelope(status, error) {
+  const directErrors = getRecordField(status, "errors");
+  if (Array.isArray(directErrors)) {
+    return directErrors.filter(
+      (entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)
+    );
+  }
+  if (!error) {
+    return [];
+  }
+  return [
+    {
+      code: getStringField(status, "errorCode") ?? "RUN_FAILED",
+      phase: getStringField(status, "errorPhase") ?? "runtime",
+      message: error,
+      retryable: typeof getRecordField(status, "retryable") === "boolean" ? getRecordField(status, "retryable") : null,
+      nextAction: `deepline runs get ${status.runId} --json`
+    }
+  ];
+}
+function normalizeLogsForEnvelope(status) {
+  const logs = Array.isArray(status.progress?.logs) ? status.progress.logs : [];
+  const offset = typeof status.progress?.logOffset === "number" && Number.isFinite(status.progress.logOffset) ? Math.max(0, Math.trunc(status.progress.logOffset)) : 0;
+  const totalCount = offset + logs.length;
+  const entries = logs.slice(Math.max(0, logs.length - RUN_LOG_PREVIEW_LIMIT));
+  const firstSequence = entries.length === 0 ? null : offset + logs.length - entries.length + 1;
+  const lastSequence = totalCount === 0 ? null : totalCount;
+  return {
+    totalCount,
+    returnedCount: entries.length,
+    firstSequence,
+    lastSequence,
+    truncated: totalCount > entries.length,
+    hasMore: totalCount > entries.length,
+    entries,
+    nextCursor: lastSequence
   };
 }
+function stripProviderSpendFromBilling(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const next = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (key === "providerCostUsd" || key === "totalProviderCostUsd") {
+      continue;
+    }
+    next[key] = item;
+  }
+  return next;
+}
 function compactPlayStatus(status, options) {
   const rowsInfo = extractCanonicalRowsInfo(status);
   const result = status && typeof status === "object" ? status.result : null;
   const warnings = buildRunWarnings(status, rowsInfo);
-  const datasetStats = rowsInfo && rowsInfo.complete ? buildDatasetStats(rowsInfo.rows, rowsInfo.totalRows, rowsInfo.columns) : null;
-  const billing = status && typeof status === "object" ? status.billing : null;
+  const datasetStats = rowsInfo && rowsInfo.complete ? buildDatasetStats(
+    rowsInfo.rows,
+    rowsInfo.totalRows,
+    rowsInfo.columns,
+    extractDatasetExecutionStats(status)
+  ) : null;
+  const billing = status && typeof status === "object" ? stripProviderSpendFromBilling(
+    status.billing
+  ) : null;
   const progressError = status.progress?.error;
   const error = typeof progressError === "string" ? progressError : typeof status.error === "string" ? String(status.error) : null;
   return {
@@ -5011,6 +5364,12 @@ function compactPlayStatus(status, options) {
     ...typeof status.name === "string" ? { name: status.name } : {},
     ...typeof status.playName === "string" ? { playName: status.playName } : {},
     status: status.status,
+    run: normalizeRunStatusForEnvelope(status),
+    progress: normalizeProgressForEnvelope(status, rowsInfo),
+    outputs: normalizeOutputsForEnvelope(rowsInfo, options?.exportedPath),
+    steps: normalizeStepsForEnvelope(status),
+    errors: normalizeErrorsForEnvelope(status, error),
+    logs: normalizeLogsForEnvelope(status),
     ...error ? { error } : {},
     ...warnings.length > 0 ? { warnings } : {},
     output: buildOutputSummary(rowsInfo, options?.exportedPath) ?? result ?? null,
@@ -5019,7 +5378,6 @@ function compactPlayStatus(status, options) {
     ...datasetStats ? { dataset_stats: datasetStats } : {},
     ...rowsInfo ? { previewRows: rowsInfo.rows.slice(0, 5) } : {},
     ...billing ? { billing } : {},
-    ...status.run ? { run: status.run } : {},
     next: buildRunNextCommands(status.runId)
   };
 }
@@ -5033,7 +5391,8 @@ function enrichPlayStatusWithDatasetStats(status) {
     dataset_stats: buildDatasetStats(
       rowsInfo.rows,
       rowsInfo.totalRows,
-      rowsInfo.columns
+      rowsInfo.columns,
+      extractDatasetExecutionStats(status)
     )
   };
 }
@@ -5048,8 +5407,9 @@ function formatDatasetStatsLines(datasetStats) {
   )) {
     const topValues = stat3.top_values ? `, top_values=${Object.entries(stat3.top_values).slice(0, 3).map(([value, count]) => `${value}=${count}`).join(", ")}` : "";
     const sample = stat3.sample_value !== void 0 ? `, sample_value=${JSON.stringify(stat3.sample_value)}` : "";
+    const execution = stat3.execution ? `, execution=${Object.entries(stat3.execution).map(([bucket, count]) => `${bucket}=${count}`).join(", ")}` : "";
     lines.push(
-      `    ${column}: non_empty=${stat3.non_empty}, unique=${stat3.unique}${topValues}${sample}`
+      `    ${column}: non_empty=${stat3.non_empty}, unique=${stat3.unique}${topValues}${sample}${execution}`
     );
   }
   return lines;
@@ -5072,7 +5432,12 @@ function writePlayResult(status, jsonOutput, options) {
   lines.push(`${success ? "\u2713" : "\u2717"} ${publicStatus}  ${runId}`);
   const rowsInfo = extractCanonicalRowsInfo(status);
   const warnings = buildRunWarnings(status, rowsInfo);
-  const datasetStats = rowsInfo && rowsInfo.complete ? buildDatasetStats(rowsInfo.rows, rowsInfo.totalRows, rowsInfo.columns) : null;
+  const datasetStats = rowsInfo && rowsInfo.complete ? buildDatasetStats(
+    rowsInfo.rows,
+    rowsInfo.totalRows,
+    rowsInfo.columns,
+    extractDatasetExecutionStats(status)
+  ) : null;
   const outputSummary = buildOutputSummary(rowsInfo, options?.exportedPath);
   if (outputSummary) {
     const columns = Array.isArray(outputSummary.columns) ? outputSummary.columns.length : 0;
@@ -5191,10 +5556,10 @@ function writeStartedPlayRun(input) {
   const lines = [
     `Started ${input.playName}`,
     `  run id: ${input.runId}`,
-    `  check status: deepline play status --run-id ${input.runId}`,
-    `  tail logs: deepline play tail --run-id ${input.runId}`,
-    `  stop run: deepline play stop --run-id ${input.runId}`,
-    `  result JSON: deepline play status --run-id ${input.runId} --json`
+    `  get status: deepline runs get ${input.runId} --json`,
+    `  tail logs: deepline runs tail ${input.runId} --json`,
+    `  stop run: deepline runs stop ${input.runId} --reason "stale lock" --json`,
+    `  result JSON: deepline runs get ${input.runId} --json`
   ];
   if (input.dashboardUrl) {
     lines.push(`  play page: ${input.dashboardUrl}`);
@@ -5341,6 +5706,10 @@ function parsePlayCheckOptions(args) {
   const jsonOutput = argsWantJson(args);
   return { target, jsonOutput };
 }
+function shouldUseLocalOnlyPlayCheck() {
+  const value = process.env.DEEPLINE_PLAY_CHECK_LOCAL_ONLY?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
 async function handlePlayCheck(args) {
   const options = parsePlayCheckOptions(args);
   if (!isFileTarget(options.target)) {
@@ -5366,10 +5735,28 @@ async function handlePlayCheck(args) {
     return 1;
   }
   const playName = graph.root.playName ?? extractPlayName(sourceCode, absolutePlayPath);
+  if (shouldUseLocalOnlyPlayCheck()) {
+    const result2 = {
+      valid: true,
+      errors: [],
+      staticPipeline: graph.root.compilerManifest?.staticPipeline ?? null,
+      artifactHash: graph.root.artifact.artifactHash,
+      graphHash: graph.root.artifact.graphHash
+    };
+    if (options.jsonOutput) {
+      process.stdout.write(`${JSON.stringify({ name: playName, ...result2 })}
+`);
+    } else {
+      console.log(`\u2713 ${playName} passed local play check`);
+      console.log(`  artifact: ${result2.artifactHash.slice(0, 12)}`);
+    }
+    return 0;
+  }
   const client = new DeeplineClient();
   const result = await client.checkPlayArtifact({
     name: playName,
     sourceCode: graph.root.sourceCode,
+    sourceFiles: graph.root.sourceFiles,
     artifact: graph.root.artifact
   });
   if (options.jsonOutput) {
@@ -5421,17 +5808,24 @@ async function handleFileBackedRun(options) {
   const packagedFileUploads = bundleResult.packagedFiles.map(
     (file) => stageFile(file.logicalPath, file.absolutePath)
   );
+  const fileInputBindings = fileInputBindingsFromStaticPipeline(
+    requireCompilerManifest(bundleResult).staticPipeline
+  );
+  applyCsvShortcutInput({
+    runtimeInput,
+    bindings: fileInputBindings,
+    fallbackInputPath: "file"
+  });
   const stagedFileInputs = await stageFileInputArgs({
     client,
     runtimeInput,
-    bindings: fileInputBindingsFromStaticPipeline(
-      requireCompilerManifest(bundleResult).staticPipeline
-    ),
+    bindings: fileInputBindings,
     progress
   });
   const startRequest = {
     name: playName,
     sourceCode: bundleResult.sourceCode,
+    sourceFiles: bundleResult.sourceFiles,
     runtimeArtifact: bundleResult.artifact,
     compilerManifest: requireCompilerManifest(bundleResult),
     packagedFileUploads,
@@ -5506,13 +5900,18 @@ async function handleNamedRun(options) {
     selector: options.revisionSelector
   });
   const runtimeInput = options.input ? { ...options.input } : {};
+  const fileInputBindings = [
+    ...fileInputBindingsFromPlaySchema(playDetail.play.inputSchema),
+    ...fileInputBindingsFromStaticPipeline(playDetail.play.staticPipeline)
+  ];
+  applyCsvShortcutInput({
+    runtimeInput,
+    bindings: fileInputBindings
+  });
   const stagedFileInputs = await stageFileInputArgs({
     client,
     runtimeInput,
-    bindings: [
-      ...fileInputBindingsFromPlaySchema(playDetail.play.inputSchema),
-      ...fileInputBindingsFromStaticPipeline(playDetail.play.staticPipeline)
-    ],
+    bindings: fileInputBindings,
     progress
   });
   const startRequest = {
@@ -5590,80 +5989,101 @@ async function handlePlayRun(args) {
   }
   return handleNamedRun(options);
 }
-async function handlePlayTail(args) {
-  const usage = "Usage: deepline play tail --run-id <run-id> [--interval-ms 1000] [--json]\n       deepline play tail --name <name> [--interval-ms 1000] [--json]";
-  let target;
-  try {
-    target = parsePlayRunTarget({ args, usage, allowName: true });
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : usage);
-    return 1;
-  }
-  const client = new DeeplineClient();
-  const jsonOutput = argsWantJson(args);
-  const emitLogs = !jsonOutput || args.includes("--logs");
-  let intervalMs = 500;
+function parseRunIdPositional(args, usage) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if ((arg === "--interval-ms" || arg === "--poll-interval-ms") && args[index + 1]) {
-      intervalMs = parsePositiveInteger2(args[++index], arg);
+    if (arg === "--json" || arg === "--full" || arg === "--logs" || arg === "--compact" || arg === "--limit") {
+      if (arg === "--limit" && args[index + 1]) {
+        index += 1;
+      }
+      continue;
+    }
+    if ((arg === "--out" || arg === "--cursor" || arg === "--reason" || arg === "--interval-ms" || arg === "--poll-interval-ms") && args[index + 1]) {
+      index += 1;
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      return arg;
     }
   }
-  const workflowId = await resolvePlayRunId(client, target);
-  const progress = getActiveCliProgress() ?? createCliProgress(!jsonOutput);
-  progress.phase(`tailing ${workflowId}`);
-  const finalStatus = await waitForPlayCompletion({
-    client,
-    workflowId,
-    pollIntervalMs: intervalMs,
-    jsonOutput,
-    emitLogs,
-    waitTimeoutMs: null,
-    progress
-  });
-  if (finalStatus.status === "completed") {
-    progress.complete();
-  } else {
-    progress.fail();
-  }
-  writePlayResult(finalStatus, jsonOutput);
-  return finalStatus.status === "completed" ? 0 : 1;
+  throw new DeeplineError(usage);
 }
-async function handlePlayStatus(args) {
-  const usage = "Usage: deepline play status --run-id <run-id> [--json] [--full]\n       deepline play status --name <name> [--json] [--full]";
-  let target;
+async function handleRunGet(args) {
+  const usage = "Usage: deepline runs get <run-id> [--json] [--full]";
+  let runId;
   try {
-    target = parsePlayRunTarget({ args, usage, allowName: true });
+    runId = parseRunIdPositional(args, usage);
   } catch (error) {
     console.error(error instanceof Error ? error.message : usage);
     return 1;
   }
   const client = new DeeplineClient();
-  const workflowId = await resolvePlayRunId(client, target);
-  const status = await client.getPlayStatus(workflowId);
+  const status = await client.runs.get(runId);
   writePlayResult(status, argsWantJson(args), {
     fullJson: args.includes("--full")
   });
   return 0;
 }
-function parseRunIdPositional(args, usage) {
+async function handleRunsList(args) {
+  const usage = "Usage: deepline runs list --play <play-name> [--status <status>] [--json]";
+  let playName = null;
+  let statusFilter = null;
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--json" || arg === "--full" || arg === "--logs") {
+    if ((arg === "--play" || arg === "--name") && args[index + 1]) {
+      playName = parseReferencedPlayTarget(args[++index]).playName;
       continue;
     }
-    if (arg === "--out" && args[index + 1]) {
-      index += 1;
+    if (arg === "--status" && args[index + 1]) {
+      statusFilter = args[++index].trim().toLowerCase();
       continue;
     }
-    if (!arg.startsWith("--")) {
-      return arg;
+    if (arg === "--json" || arg === "--compact") {
+      continue;
     }
   }
-  throw new DeeplineError(usage);
+  if (!playName) {
+    console.error(usage);
+    return 1;
+  }
+  const client = new DeeplineClient();
+  const runs = (await client.runs.list({
+    play: playName,
+    ...statusFilter ? { status: statusFilter } : {}
+  })).map((run) => ({
+    runId: run.workflowId,
+    workflowId: run.workflowId,
+    temporalRunId: run.runId,
+    status: String(run.status ?? "").toLowerCase(),
+    startedAt: run.startTime,
+    finishedAt: run.closeTime,
+    executionTime: run.executionTime,
+    playName: run.memo?.playName ?? playName
+  }));
+  if (argsWantJson(args)) {
+    process.stdout.write(
+      `${JSON.stringify({
+        runs,
+        count: runs.length,
+        next: {
+          get: runs[0]?.runId ? `deepline runs get ${runs[0].runId} --json` : null
+        }
+      })}
+`
+    );
+  } else {
+    if (runs.length === 0) {
+      console.log(`No runs found for ${playName}.`);
+    } else {
+      for (const run of runs) {
+        console.log(`${run.runId} ${run.status} ${formatTimestamp(run.startedAt)}`);
+      }
+    }
+  }
+  return 0;
 }
-async function handleRunStatus(args) {
-  const usage = "Usage: deepline runs status <run-id> [--json] [--full]";
+async function handleRunTail(args) {
+  const usage = "Usage: deepline runs tail <run-id> [--json] [--compact] [--cursor <cursor>]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage);
@@ -5672,14 +6092,24 @@ async function handleRunStatus(args) {
     return 1;
   }
   const client = new DeeplineClient();
-  const status = await client.getPlayStatus(runId);
-  writePlayResult(status, argsWantJson(args), {
-    fullJson: args.includes("--full")
+  let afterLogIndex;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--cursor" && args[index + 1]) {
+      const parsed = Number(args[++index]);
+      if (Number.isInteger(parsed) && parsed >= 0) {
+        afterLogIndex = parsed;
+      }
+    }
+  }
+  const status = await client.runs.tail(runId, {
+    ...afterLogIndex !== void 0 ? { afterLogIndex } : {}
   });
-  return 0;
+  writePlayResult(status, argsWantJson(args));
+  return status.status === "failed" ? 1 : 0;
 }
 async function handleRunLogs(args) {
-  const usage = "Usage: deepline runs logs <run-id> [--json]";
+  const usage = "Usage: deepline runs logs <run-id> [--limit 200] [--out run.log] [--json]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage);
@@ -5687,14 +6117,86 @@ async function handleRunLogs(args) {
     console.error(error instanceof Error ? error.message : usage);
     return 1;
   }
+  let limit = 200;
+  let outPath = null;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--limit" && args[index + 1]) {
+      limit = parsePositiveInteger2(args[++index], "--limit");
+      continue;
+    }
+    if (arg === "--out" && args[index + 1]) {
+      outPath = resolve7(args[++index]);
+    }
+  }
   const client = new DeeplineClient();
-  const status = await client.getPlayStatus(runId);
+  const status = await client.runs.get(runId);
   const logs = status.progress?.logs ?? [];
+  if (outPath) {
+    writeFileSync4(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    if (argsWantJson(args)) {
+      process.stdout.write(
+        `${JSON.stringify({
+          runId: status.runId,
+          log_path: outPath,
+          lineCount: logs.length
+        })}
+`
+      );
+    } else {
+      console.log(`Wrote ${logs.length} log lines to ${outPath}`);
+    }
+    return 0;
+  }
+  const entries = logs.slice(Math.max(0, logs.length - limit));
+  if (argsWantJson(args)) {
+    process.stdout.write(
+      `${JSON.stringify({
+        runId: status.runId,
+        totalCount: logs.length,
+        returnedCount: entries.length,
+        firstSequence: logs.length === 0 ? null : logs.length - entries.length + 1,
+        lastSequence: logs.length === 0 ? null : logs.length,
+        truncated: logs.length > entries.length,
+        hasMore: logs.length > entries.length,
+        entries,
+        next: {
+          export: `deepline runs logs ${status.runId} --out run.log --json`
+        }
+      })}
+`
+    );
+  } else {
+    process.stdout.write(`${entries.join("\n")}${entries.length > 0 ? "\n" : ""}`);
+  }
+  return 0;
+}
+async function handleRunStop(args) {
+  const usage = 'Usage: deepline runs stop <run-id> [--reason "text"] [--json]';
+  let runId;
+  try {
+    runId = parseRunIdPositional(args, usage);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : usage);
+    return 1;
+  }
+  let reason;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--reason" && args[index + 1]) {
+      reason = args[++index];
+    }
+  }
+  const client = new DeeplineClient();
+  const result = await client.runs.stop(runId, { reason });
   if (argsWantJson(args)) {
-    process.stdout.write(`${JSON.stringify({ runId: status.runId, logs })}
+    process.stdout.write(`${JSON.stringify(result)}
 `);
   } else {
-    process.stdout.write(`${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    console.log(`Stopped ${result.runId}`);
+    if (result.hitlCancelledCount > 0) {
+      console.log(`  cancelled HITL waits: ${result.hitlCancelledCount}`);
+    }
   }
   return 0;
 }
@@ -5737,37 +6239,6 @@ async function handleRunExport(args) {
   }
   return 0;
 }
-async function handlePlayStop(args) {
-  const usage = 'Usage: deepline play stop --run-id <run-id> [--reason "text"] [--json]';
-  let target;
-  try {
-    target = parsePlayRunTarget({ args, usage, allowName: false });
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : usage);
-    return 1;
-  }
-  const client = new DeeplineClient();
-  const jsonOutput = argsWantJson(args);
-  let reason;
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--reason" && args[index + 1]) {
-      reason = args[++index];
-    }
-  }
-  const workflowId = await resolvePlayRunId(client, target);
-  const result = await client.stopPlay(workflowId, { reason });
-  if (jsonOutput) {
-    process.stdout.write(`${JSON.stringify(result)}
-`);
-  } else {
-    console.log(`Stopped ${result.runId}`);
-    if (result.hitlCancelledCount > 0) {
-      console.log(`  cancelled HITL waits: ${result.hitlCancelledCount}`);
-    }
-  }
-  return 0;
-}
 async function handlePlayGet(args) {
   const target = args[0];
   if (!target) {
@@ -5855,33 +6326,6 @@ async function handlePlayGet(args) {
   }
   return 0;
 }
-async function handlePlayRuns(args) {
-  const nameIndex = args.indexOf("--name");
-  const name = nameIndex >= 0 ? args[nameIndex + 1] : void 0;
-  if (!name) {
-    console.error("Usage: deepline play runs --name <name> [--json]");
-    return 1;
-  }
-  const client = new DeeplineClient();
-  const jsonOutput = argsWantJson(args);
-  await assertCanonicalNamedPlayReference(client, name);
-  const runs = await client.listPlayRuns(
-    parseReferencedPlayTarget(name).playName
-  );
-  if (jsonOutput) {
-    process.stdout.write(`${JSON.stringify({ runs })}
-`);
-    return 0;
-  }
-  if (runs.length === 0) {
-    console.log(`No runs found for ${name}.`);
-    return 0;
-  }
-  for (const run of runs) {
-    console.log(formatRunLine(run));
-  }
-  return 0;
-}
 function formatVersionLine(version) {
   const revisionLabel = version.artifactHash?.slice(0, 12) ?? "unknown-revision";
   return `v${version.version} ${revisionLabel} ${formatTimestamp(version.createdAt)}`;
@@ -6013,6 +6457,11 @@ function printPlayDescription(play) {
     }
   }
   console.log(`  Run: ${play.runCommand}`);
+  if (play.origin === "prebuilt" && !play.canEdit) {
+    console.log(
+      `  Customize: deepline plays get ${reference} --source --out ./my-play.play.ts`
+    );
+  }
 }
 async function handlePlaySearch(args) {
   let options;
@@ -6110,6 +6559,7 @@ async function handlePlayPublish(args) {
     const published = await client.registerPlayArtifact({
       name: rootPlayName,
       sourceCode: graph.root.sourceCode,
+      sourceFiles: graph.root.sourceFiles,
       artifact: graph.root.artifact,
       compilerManifest: requireCompilerManifest(graph.root),
       publish: true
@@ -6330,50 +6780,12 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  play.command("runs").description("List runs for a named play.").option("--name <name>", "Saved play name").option("--json", "Emit JSON output").action(async (options) => {
-    process.exitCode = await handlePlayRuns([
-      ...options.name ? ["--name", options.name] : [],
-      ...options.json ? ["--json"] : []
-    ]);
-  });
   play.command("versions").description("List revisions for a named play.").option("--name <name>", "Saved play name").option("--json", "Emit JSON output").action(async (options) => {
     process.exitCode = await handlePlayVersions([
       ...options.name ? ["--name", options.name] : [],
       ...options.json ? ["--json"] : []
     ]);
   });
-  play.command("tail").description("Tail events for a play run.").option("--run-id <runId>", "Run id to tail").option("--name <name>", "Tail the latest run for a named play").option("--interval-ms <ms>", "Polling interval while tailing").option("--logs", "With --json, stream play logs to stderr while waiting").option("--json", "Emit JSON output").action(async (options) => {
-    process.exitCode = await handlePlayTail([
-      ...options.runId ? ["--run-id", options.runId] : [],
-      ...options.name ? ["--name", options.name] : [],
-      ...options.intervalMs ? ["--interval-ms", options.intervalMs] : [],
-      ...options.logs ? ["--logs"] : [],
-      ...options.json ? ["--json"] : []
-    ]);
-  });
-  play.command("status").description("Show status for a play run.").option("--run-id <runId>", "Run id to inspect").option("--name <name>", "Inspect the latest run for a named play").option("--json", "Emit JSON output").option("--full", "Debug only: with --json, emit the raw status payload").action(async (options) => {
-    process.exitCode = await handlePlayStatus([
-      ...options.runId ? ["--run-id", options.runId] : [],
-      ...options.name ? ["--name", options.name] : [],
-      ...options.json ? ["--json"] : [],
-      ...options.full ? ["--full"] : []
-    ]);
-  });
-  play.command("export").description("Export a completed play run to CSV.").requiredOption("--run-id <runId>", "Run id to export").requiredOption("--out <path>", "Output CSV path").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (options) => {
-    process.exitCode = await handleRunExport([
-      options.runId,
-      "--out",
-      options.out,
-      ...options.json ? ["--json"] : []
-    ]);
-  });
-  play.command("stop").description("Stop a play run.").option("--run-id <runId>", "Run id to stop").option("--reason <text>", "Reason to include with the stop request").option("--json", "Emit JSON output").action(async (options) => {
-    process.exitCode = await handlePlayStop([
-      ...options.runId ? ["--run-id", options.runId] : [],
-      ...options.reason ? ["--reason", options.reason] : [],
-      ...options.json ? ["--json"] : []
-    ]);
-  });
   play.command("publish <target>").description("Bundle, validate, save, and publish a play.").option("--latest", "Promote the newest saved revision").option("--revision-id <id>", "Revision to promote").option("--json", "Emit JSON output").action(async (target, options) => {
     process.exitCode = await handlePlayPublish([
       target,
@@ -6389,38 +6801,72 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  const runs = program.command("runs").description("Inspect and export play runs.").addHelpText(
+  const runs = program.command("runs").description("Inspect, tail, stop, and export play runs.").addHelpText(
     "after",
     `
 Examples:
-  deepline runs status play/my-play/run/20260501t000000-000
+  deepline runs get play/my-play/run/20260501t000000-000 --json
+  deepline runs tail play/my-play/run/20260501t000000-000
+  deepline runs logs play/my-play/run/20260501t000000-000 --out run.log --json
+  deepline runs list --play my-play --status failed --json
+  deepline runs stop play/my-play/run/20260501t000000-000 --reason "stale lock" --json
   deepline runs export play/my-play/run/20260501t000000-000 --out output.csv
-  deepline runs logs play/my-play/run/20260501t000000-000
 `
   );
-  runs.command("status <runId>").description("Show compact status for a play run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--full", "Debug only: with --json, emit the raw status payload").action(async (runId, options) => {
-    process.exitCode = await handleRunStatus([
+  runs.command("get <runId>").description("Get status, progress, outputs, errors, and recovery metadata for a play run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--full", "Debug only: with --json, emit the raw status payload").action(async (runId, options) => {
+    process.exitCode = await handleRunGet([
       runId,
       ...options.json ? ["--json"] : [],
       ...options.full ? ["--full"] : []
     ]);
   });
-  runs.command("export <runId>").description("Export the completed row output for a play run to CSV.").requiredOption("--out <path>", "Output CSV path").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
-    process.exitCode = await handleRunExport([
-      runId,
-      "--out",
-      options.out,
+  runs.command("list").description("List play runs.").requiredOption("--play <name>", "Play name to filter runs").option("--status <status>", "Filter by run status").option("--compact", "Drop verbose fields from JSON output").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (options) => {
+    process.exitCode = await handleRunsList([
+      "--play",
+      options.play,
+      ...options.status ? ["--status", options.status] : [],
+      ...options.compact ? ["--compact"] : [],
       ...options.json ? ["--json"] : []
     ]);
   });
-  runs.command("logs <runId>").description("Print logs for a play run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+  runs.command("tail <runId>").description("Tail or fetch recent live events for a play run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--compact", "Drop verbose fields from JSON output").option("--cursor <cursor>", "Resume after a previously returned event cursor").action(async (runId, options) => {
+    process.exitCode = await handleRunTail([
+      runId,
+      ...options.json ? ["--json"] : [],
+      ...options.compact ? ["--compact"] : [],
+      ...options.cursor ? ["--cursor", options.cursor] : []
+    ]);
+  });
+  runs.command("logs <runId>").description("Fetch persisted logs for a play run.").option("--limit <count>", "Maximum recent log lines to print without --out", "200").option("--out <path>", "Write the full persisted log stream to a file").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
     process.exitCode = await handleRunLogs([
       runId,
+      ...options.limit ? ["--limit", options.limit] : [],
+      ...options.out ? ["--out", options.out] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  runs.command("stop <runId>").description("Stop a play run.").option("--reason <text>", "Reason to include with the stop request").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+    process.exitCode = await handleRunStop([
+      runId,
+      ...options.reason ? ["--reason", options.reason] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  runs.command("export <runId>").description("Export the completed row output for a play run to CSV.").requiredOption("--out <path>", "Output CSV path").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+    process.exitCode = await handleRunExport([
+      runId,
+      "--out",
+      options.out,
       ...options.json ? ["--json"] : []
     ]);
   });
 }
 
+// src/cli/commands/tools.ts
+import { chmodSync, mkdtempSync, writeFileSync as writeFileSync6 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join8 } from "path";
+
 // src/tool-output.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -6589,31 +7035,23 @@ async function listTools(args) {
   }
   return 0;
 }
-function toolMatchesQuery(tool, terms) {
-  const haystack = [
-    tool.toolId,
-    tool.provider,
-    tool.displayName,
-    tool.description,
-    tool.operation,
-    tool.operationId,
-    ...tool.operationAliases ?? [],
-    ...tool.categories ?? [],
-    tool.inputSchema ? JSON.stringify(tool.inputSchema) : ""
-  ].filter(Boolean).join(" ").toLowerCase();
-  return terms.every((term) => haystack.includes(term));
-}
-async function searchTools(args) {
-  const query = args[0]?.trim();
+async function searchTools(queryInput, options = {}) {
+  const query = queryInput.trim();
   if (!query) {
     console.error("Usage: deepline tools search <query> [--json]");
     return 1;
   }
-  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
   const client = new DeeplineClient();
-  const items = (await client.listTools()).filter((tool) => toolMatchesQuery(tool, terms)).map(toListedTool);
-  if (argsWantJson(args)) {
-    process.stdout.write(`${JSON.stringify({ tools: items })}
+  const result = await client.searchTools({
+    query,
+    categories: options.categories,
+    searchTerms: options.searchTerms,
+    searchMode: options.searchMode,
+    includeSearchDebug: options.includeSearchDebug
+  });
+  const items = result.tools.map(toListedTool);
+  if (options.json || shouldEmitJson()) {
+    process.stdout.write(`${JSON.stringify({ ...result, tools: items })}
 `);
     return 0;
   }
@@ -6667,11 +7105,14 @@ Common commands:
       ...options.json ? ["--json"] : []
     ]);
   });
-  tools.command("search <query>").description("Search available tools.").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
-    process.exitCode = await searchTools([
-      query,
-      ...options.json ? ["--json"] : []
-    ]);
+  tools.command("search <query>").description("Search available tools.").option("--categories <categories>", "Comma-separated categories to filter ranked search").option("--search_terms <terms>", "Structured search terms for ranked search").option("--search-terms <terms>", "Structured search terms for ranked search").option("--search-mode <mode>", "Ranked search mode: v1 or v2").option("--include-search-debug", "Include ranked search debug metadata").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (query, options) => {
+    process.exitCode = await searchTools(query, {
+      json: options.json,
+      categories: options.categories,
+      searchTerms: options.searchTerms ?? options.search_terms,
+      searchMode: options.searchMode === "v1" || options.searchMode === "v2" ? options.searchMode : void 0,
+      includeSearchDebug: Boolean(options.includeSearchDebug)
+    });
   });
   tools.command("get <toolId>").alias("describe").description("Show metadata for a tool.").addHelpText(
     "after",
@@ -7029,6 +7470,61 @@ function parseExecuteOptions(args) {
   }
   return { toolId, params, outputFormat, noPreview };
 }
+function safeFileStem(value) {
+  return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "tool";
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function powerShellQuote(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function seedToolListScript(input) {
+  const stem = safeFileStem(input.toolId);
+  const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
+  const scriptDir = mkdtempSync(join8(tmpdir3(), "deepline-workflow-seed-"));
+  chmodSync(scriptDir, 448);
+  const scriptPath = join8(scriptDir, fileName);
+  const projectDir = `deepline/projects/${stem}-workflow`;
+  const playName = `${stem}-workflow`;
+  const sampleRows = input.rows.length > 0 ? `${JSON.stringify(input.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
+  const columns = Object.keys(input.rows[0] ?? {}).join(", ");
+  const rowKey = Object.prototype.hasOwnProperty.call(input.rows[0] ?? {}, "id") ? '"id"' : "(row) => JSON.stringify(row)";
+  const script = `import { definePlay } from 'deepline';
+
+export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
+  const result = await ctx.tools.execute({
+    id: ${JSON.stringify(input.toolId)},
+    tool: ${JSON.stringify(input.toolId)},
+    input: ${JSON.stringify(input.payload)},
+    description: ${JSON.stringify(`Seed ${input.toolId} rows for workflow expansion.`)},
+  });
+
+  const list = Object.values(result.lists)[0];
+  const rows = (list?.get() ?? []).slice(0, 100);
+  // ${sampleRows}
+  // columns: ${columns}
+  // .step('email_waterfall', (row, rowCtx) => rowCtx.runPlay('name_domain_email', 'name-and-domain-to-email', { first_name: String(row.first_name ?? ''), last_name: String(row.last_name ?? ''), domain: String(row.domain ?? '') }, { description: 'Resolve email.' }))
+  // .step('phone_waterfall', (row, rowCtx) => rowCtx.runPlay('contact_phone', 'contact-to-phone', { first_name: String(row.first_name ?? ''), last_name: String(row.last_name ?? ''), email: String(row.email ?? '') }, { description: 'Resolve phone.' }))
+  // ctx.map is idempotent by map key + row key; reruns reuse completed rows.
+  const enrichedData = await ctx
+    .map('enriched_data', rows, { key: ${rowKey} })
+    .run({ description: 'Enrich seeded rows.' });
+
+  return {
+    rows: enrichedData,
+    count: await enrichedData.count(),
+  };
+});
+`;
+  writeFileSync6(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  return {
+    path: scriptPath,
+    projectDir,
+    macCopyCommand: `mkdir -p ${shellQuote(projectDir)} && cp ${shellQuote(scriptPath)} ${shellQuote(`${projectDir}/${fileName}`)}`,
+    windowsCopyCommand: `New-Item -ItemType Directory -Force -Path ${powerShellQuote(projectDir.replace(/\//g, "\\"))} | Out-Null; Copy-Item -LiteralPath ${powerShellQuote(scriptPath)} -Destination ${powerShellQuote(`${projectDir.replace(/\//g, "\\")}\\${fileName}`)}`
+  };
+}
 async function executeTool(args) {
   let parsed;
   try {
@@ -7082,6 +7578,11 @@ async function executeTool(args) {
     return 0;
   }
   const csv = writeCsvOutputFile(listConversion.rows, `${parsed.toolId}_output`);
+  const seededScript = seedToolListScript({
+    toolId: parsed.toolId,
+    payload: parsed.params,
+    rows: listConversion.rows
+  });
   if (parsed.outputFormat === "csv_file") {
     process.stdout.write(`${JSON.stringify({
       extracted_csv: csv.path,
@@ -7090,6 +7591,12 @@ async function executeTool(args) {
       preview: csv.preview,
       list_strategy: listConversion.strategy,
       list_source_path: listConversion.sourcePath,
+      starter_script: seededScript.path,
+      project_dir: seededScript.projectDir,
+      copy_to_project: {
+        macos_linux: seededScript.macCopyCommand,
+        windows_powershell: seededScript.windowsCopyCommand
+      },
       summary
     })}
 `);
@@ -7107,14 +7614,20 @@ async function executeTool(args) {
     console.log(`summary: ${Object.entries(summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`);
   }
   console.log(`preview: ${JSON.stringify(csv.preview)}`);
+  console.log(`starter script: ${seededScript.path}`);
+  console.log(
+    "next: Move the script into a project folder and expand it into a Deepline play. Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
+  );
+  console.log(`macOS/Linux: ${seededScript.macCopyCommand}`);
+  console.log(`Windows PowerShell: ${seededScript.windowsCopyCommand}`);
   return 0;
 }
 
 // src/cli/skills-sync.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync6 } from "fs";
+import { spawn, spawnSync } from "child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname7, join as join8 } from "path";
+import { dirname as dirname7, join as join9 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_SKILL_NAME = "deepline-sdk";
 var SKILL_AGENTS = ["codex", "claude-code", "cursor"];
@@ -7125,7 +7638,7 @@ function shouldSkipSkillsSync() {
 }
 function sdkSkillsVersionPath(baseUrl) {
   const home = process.env.HOME?.trim() || homedir4();
-  return join8(home, ".local", "deepline", baseUrlSlug(baseUrl), "sdk-skills", ".version");
+  return join9(home, ".local", "deepline", baseUrlSlug(baseUrl), "sdk-skills", ".version");
 }
 function readLocalSkillsVersion(baseUrl) {
   const path = sdkSkillsVersionPath(baseUrl);
@@ -7139,7 +7652,7 @@ function readLocalSkillsVersion(baseUrl) {
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
   mkdirSync4(dirname7(path), { recursive: true });
-  writeFileSync6(path, `${version}
+  writeFileSync7(path, `${version}
 `, "utf-8");
 }
 async function fetchSkillsUpdate(baseUrl, localVersion) {
@@ -7170,9 +7683,26 @@ async function fetchSkillsUpdate(baseUrl, localVersion) {
     clearTimeout(timeout);
   }
 }
-function runSkillsInstall(baseUrl) {
+function buildSkillsInstallArgs(baseUrl) {
+  const packageUrl = new URL("/.well-known/skills/index.json", baseUrl).toString();
+  return [
+    "--yes",
+    "skills",
+    "add",
+    packageUrl,
+    "--agents",
+    ...SKILL_AGENTS,
+    "--global",
+    "--yes",
+    "--skill",
+    SDK_SKILL_NAME,
+    "--full-depth"
+  ];
+}
+function buildBunxSkillsInstallArgs(baseUrl) {
   const packageUrl = new URL("/.well-known/skills/index.json", baseUrl).toString();
-  const args = [
+  return [
+    "--bun",
     "skills",
     "add",
     packageUrl,
@@ -7184,8 +7714,40 @@ function runSkillsInstall(baseUrl) {
     SDK_SKILL_NAME,
     "--full-depth"
   ];
+}
+function hasCommand(command) {
+  const result = spawnSync(command, ["--version"], {
+    stdio: "ignore",
+    shell: process.platform === "win32"
+  });
+  return result.status === 0;
+}
+function shellQuote2(arg) {
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function resolveSkillsInstallCommands(baseUrl) {
+  const npxArgs = buildSkillsInstallArgs(baseUrl);
+  const npxInstall = {
+    command: "npx",
+    args: npxArgs,
+    manualCommand: `npx ${npxArgs.map(shellQuote2).join(" ")}`
+  };
+  if (hasCommand("bunx")) {
+    const bunxArgs = buildBunxSkillsInstallArgs(baseUrl);
+    return [
+      {
+        command: "bunx",
+        args: bunxArgs,
+        manualCommand: `bunx ${bunxArgs.map(shellQuote2).join(" ")}`
+      },
+      npxInstall
+    ];
+  }
+  return [npxInstall];
+}
+function runOneSkillsInstall(install) {
   return new Promise((resolve8) => {
-    const child = spawn("npx", args, {
+    const child = spawn(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
     });
@@ -7194,37 +7756,63 @@ function runSkillsInstall(baseUrl) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      process.stderr.write(`SDK skills sync failed to start: ${error.message}
-`);
-      resolve8(false);
+      resolve8({
+        ok: false,
+        detail: `failed to start ${install.command}: ${error.message}`,
+        manualCommand: install.manualCommand
+      });
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve8(true);
+        resolve8({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      process.stderr.write(
-        `SDK skills sync failed${detail ? `: ${detail}` : ""}
-Run manually: npx ${args.map((arg) => arg.includes(" ") ? JSON.stringify(arg) : arg).join(" ")}
-`
-      );
-      resolve8(false);
+      resolve8({
+        ok: false,
+        detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
+        manualCommand: install.manualCommand
+      });
     });
   });
 }
+async function runSkillsInstall(baseUrl) {
+  const failures = [];
+  for (const install of resolveSkillsInstallCommands(baseUrl)) {
+    const result = await runOneSkillsInstall(install);
+    if (result.ok) return true;
+    failures.push(result);
+  }
+  const details = failures.map((failure) => failure.detail).filter(Boolean).join("\n");
+  const manualCommand = failures.at(-1)?.manualCommand;
+  process.stderr.write(
+    `SDK skills sync failed${details ? `:
+${details}` : ""}
+` + (manualCommand ? `Run manually: ${manualCommand}
+` : "")
+  );
+  return false;
+}
+function writeSdkSkillsStatusLine(line) {
+  const progress = getActiveCliProgress();
+  if (progress) {
+    progress.writeLine(line);
+    return;
+  }
+  process.stderr.write(`${line}
+`);
+}
 async function syncSdkSkillsIfNeeded(baseUrl) {
   if (attemptedSync || shouldSkipSkillsSync()) return;
   attemptedSync = true;
   const localVersion = readLocalSkillsVersion(baseUrl);
   const update = await fetchSkillsUpdate(baseUrl, localVersion);
   if (!update?.needsUpdate || !update.remoteVersion) return;
-  const progress = getActiveCliProgress();
-  progress?.writeLine("SDK skills changed; syncing deepline-sdk skill...") ?? process.stderr.write("SDK skills changed; syncing deepline-sdk skill...\n");
+  writeSdkSkillsStatusLine("SDK skills changed; syncing deepline-sdk skill...");
   const installed = await runSkillsInstall(baseUrl);
   if (!installed) return;
   writeLocalSkillsVersion(baseUrl, update.remoteVersion);
-  progress?.writeLine("SDK skills are up to date.") ?? process.stderr.write("SDK skills are up to date.\n");
+  writeSdkSkillsStatusLine("SDK skills are up to date.");
 }
 
 // src/cli/trace.ts
@@ -7386,4 +7974,3 @@ Output:
   process.exit(process.exitCode ?? 0);
 }
 main();
-//# sourceMappingURL=index.mjs.map