deepline 0.1.11 → 0.1.19

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command2 } from "commander";
+import { Command } from "commander";
 
 // src/config.ts
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
@@ -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.11";
-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,10 @@ 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));
+}
 function normalizePlayStatus(raw) {
   const status = typeof raw.status === "string" ? raw.status : typeof raw.temporalStatus === "string" ? mapLegacyTemporalStatus(raw.temporalStatus) : "running";
   const runId = typeof raw.runId === "string" ? raw.runId : typeof raw.workflowId === "string" ? raw.workflowId : "";
@@ -473,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.
@@ -480,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() {
@@ -496,12 +586,27 @@ var DeeplineClient = class {
     ).filter((field) => Boolean(field?.name)) : [];
     return fields.length > 0 ? { fields } : schema;
   }
-  playRunCommand(name) {
-    return `deepline plays run ${name} --input '{...}' --watch`;
+  schemaMetadata(schema, key) {
+    if (!isRecord(schema)) return null;
+    const value = schema[key];
+    return isRecord(value) ? value : null;
+  }
+  playRunCommand(play, options) {
+    const target = play.reference || play.name;
+    if (options?.csvInput) {
+      const inputField = typeof options.csvInput.inputField === "string" && options.csvInput.inputField.trim() ? options.csvInput.inputField.trim() : "csv";
+      return `deepline plays run ${target} --${inputField} leads.csv --watch`;
+    }
+    return `deepline plays run ${target} --input '{...}' --watch`;
   }
   summarizePlayListItem(play, options) {
     const aliases = play.aliases?.length ? play.aliases : [play.name];
-    const runCommand = this.playRunCommand(play.name);
+    const csvInput = this.schemaMetadata(play.inputSchema, "csvInput");
+    const rowOutputSchema = this.schemaMetadata(
+      play.outputSchema,
+      "rowOutputSchema"
+    );
+    const runCommand = this.playRunCommand(play, { csvInput });
     return {
       name: play.name,
       ...play.reference ? { reference: play.reference } : {},
@@ -513,6 +618,8 @@ var DeeplineClient = class {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
+      ...csvInput ? { csvInput } : {},
+      ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand,
       examples: [runCommand],
       currentPublishedVersion: play.currentPublishedVersion ?? null,
@@ -551,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.
    *
@@ -579,55 +711,24 @@ var DeeplineClient = class {
     );
   }
   /**
-   * Execute a tool and return the extracted result.
-   *
-   * Sends the input payload to the tool and returns the `.result` field from the
-   * response. For the full response envelope (including job_id, credits, etc.),
-   * use {@link executeToolRaw}.
-   *
-   * @param toolId - Tool identifier (e.g. `"test_company_search"`)
-   * @param input - Tool-specific input parameters
-   * @returns The tool's output (shape varies by tool)
-   * @throws {@link DeeplineError} if the tool execution fails
-   *
-   * @example
-   * ```typescript
-   * const company = await client.executeTool('test_company_search', {
-   *   domain: 'stripe.com',
-   * });
-   * console.log(company); // { name: "Stripe", industry: "Financial Services", ... }
-   * ```
-   */
-  async executeTool(toolId, input) {
-    const res = await this.http.post(
-      `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
-      { payload: input }
-    );
-    return res.result ?? res;
-  }
-  /**
-   * Execute a tool and return the full response envelope.
+   * Execute a tool and return the standard execution envelope.
    *
-   * Unlike {@link executeTool}, this returns the complete API response including
-   * `job_id`, `status`, `credits`, and the raw `result` object.
-   *
-   * @param toolId - Tool identifier
-   * @param input - Tool-specific input parameters
-   * @returns Full response with job metadata and result
-   *
-   * @example
-   * ```typescript
-   * const raw = await client.executeToolRaw('test_company_search', { domain: 'stripe.com' });
-   * console.log(`Job: ${raw.job_id}, Credits: ${raw.credits}`);
-   * console.log(`Result:`, raw.result);
-   * ```
+   * The `result.data` field contains the provider payload. `result.meta`
+   * contains provider/upstream metadata such as HTTP status or paging details.
+   * Top-level fields such as `status`, `job_id`, and `billing` describe the
+   * Deepline execution.
    */
-  async executeToolRaw(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,
@@ -676,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 } : {},
@@ -700,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 } : {},
@@ -736,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", {
@@ -750,6 +854,7 @@ var DeeplineClient = class {
         compilerManifest: artifact.compilerManifest ?? await this.compilePlayManifest({
           name: artifact.name,
           sourceCode: artifact.sourceCode,
+          sourceFiles: artifact.sourceFiles,
           artifact: artifact.artifact
         })
       }))
@@ -776,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
@@ -840,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
@@ -1028,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"
@@ -1414,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" };
@@ -1953,24 +2169,70 @@ function registerBillingCommands(program) {
 // src/cli/dataset-stats.ts
 import { writeFileSync as writeFileSync3 } from "fs";
 import { resolve as resolve3 } from "path";
-function isRecord(value) {
+var CSV_PROJECTED_FIELDS_KEY = "__deeplineCsvProjectedFields";
+function csvProjectedFields(row) {
+  const serialized = row[CSV_PROJECTED_FIELDS_KEY];
+  if (!Array.isArray(serialized)) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(
+    serialized.filter((field) => typeof field === "string")
+  );
+}
+function stripCsvProjectionFields(row) {
+  const projectedFields = csvProjectedFields(row);
+  if (projectedFields.size === 0 && !(CSV_PROJECTED_FIELDS_KEY in row)) {
+    return row;
+  }
+  const stripped = { ...row };
+  for (const field of projectedFields) {
+    delete stripped[field];
+  }
+  delete stripped[CSV_PROJECTED_FIELDS_KEY];
+  return stripped;
+}
+function stripCsvProjectionColumns(columns, rows) {
+  const projectedFields = /* @__PURE__ */ new Set();
+  let hasProjectionMetadata = false;
+  for (const row of rows) {
+    for (const field of csvProjectedFields(row)) {
+      projectedFields.add(field);
+    }
+    hasProjectionMetadata ||= CSV_PROJECTED_FIELDS_KEY in row;
+  }
+  if (!hasProjectionMetadata && projectedFields.size === 0) {
+    return columns;
+  }
+  return columns.filter(
+    (column) => column !== CSV_PROJECTED_FIELDS_KEY && !projectedFields.has(column)
+  );
+}
+function sanitizeCsvProjectionInfo(input) {
+  const columns = stripCsvProjectionColumns(input.columns, input.rows);
+  const rows = input.rows.map(stripCsvProjectionFields);
+  return { rows, columns };
+}
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSerializedDataset(value) {
-  return isRecord(value) && value.kind === "dataset" && typeof value.count === "number" && Array.isArray(value.preview);
+  return isRecord2(value) && value.kind === "dataset" && typeof value.count === "number" && Array.isArray(value.preview);
 }
 function rowArray(value) {
   if (!Array.isArray(value)) {
     return null;
   }
   const rows = value.filter(
-    (row) => isRecord(row)
+    (row) => isRecord2(row)
   );
   return rows.length === value.length ? rows : null;
 }
 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();
@@ -1988,12 +2250,12 @@ function inferColumns(rows) {
   return columns;
 }
 function extractCanonicalRowsInfo(statusOrResult) {
-  const root = isRecord(statusOrResult) ? statusOrResult : null;
-  const result = isRecord(root?.result) ? root.result : root;
+  const root = isRecord2(statusOrResult) ? statusOrResult : null;
+  const result = isRecord2(root?.result) ? root.result : root;
   if (!result) {
     return null;
   }
-  const metadata = isRecord(result._metadata) ? result._metadata : null;
+  const metadata = isRecord2(result._metadata) ? result._metadata : null;
   const totalFromMetadata = metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count;
   const candidates = [
     { source: "result.contacts", value: result.contacts, total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count },
@@ -2001,8 +2263,8 @@ function extractCanonicalRowsInfo(statusOrResult) {
     { source: "result.rows", value: result.rows, total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count },
     { source: "result.results", value: result.results, total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count }
   ];
-  if (isRecord(result.output)) {
-    const outputMetadata = isRecord(result.output._metadata) ? result.output._metadata : null;
+  if (isRecord2(result.output)) {
+    const outputMetadata = isRecord2(result.output._metadata) ? result.output._metadata : null;
     const outputTotalFromMetadata = outputMetadata?.totalRows ?? outputMetadata?.rowCount ?? outputMetadata?.count;
     candidates.push(
       { source: "result.output.contacts", value: result.output.contacts, total: outputTotalFromMetadata ?? result.output.totalRows ?? result.output.rowCount ?? result.output.count },
@@ -2013,12 +2275,17 @@ function extractCanonicalRowsInfo(statusOrResult) {
   }
   for (const candidate of candidates) {
     if (isSerializedDataset(candidate.value)) {
-      const rows2 = rowArray(candidate.value.preview) ?? [];
-      const totalRows2 = readNumber(candidate.value.count) ?? rows2.length;
+      const rawRows = rowArray(candidate.value.preview) ?? [];
+      const totalRows2 = readNumber(candidate.value.count) ?? rawRows.length;
+      const rawColumns = Array.isArray(candidate.value.columns) && candidate.value.columns.every((column) => typeof column === "string") ? candidate.value.columns : inferColumns(rawRows);
+      const { rows: rows2, columns } = sanitizeCsvProjectionInfo({
+        rows: rawRows,
+        columns: rawColumns
+      });
       return {
         rows: rows2,
         totalRows: totalRows2,
-        columns: Array.isArray(candidate.value.columns) && candidate.value.columns.every((column) => typeof column === "string") ? candidate.value.columns : inferColumns(rows2),
+        columns,
         complete: rows2.length === totalRows2,
         source: candidate.source
       };
@@ -2028,10 +2295,14 @@ function extractCanonicalRowsInfo(statusOrResult) {
       continue;
     }
     const totalRows = readNumber(candidate.total) ?? rows.length;
-    return {
+    const sanitized = sanitizeCsvProjectionInfo({
       rows,
+      columns: inferColumns(rows)
+    });
+    return {
+      rows: sanitized.rows,
       totalRows,
-      columns: inferColumns(rows),
+      columns: sanitized.columns,
       complete: rows.length === totalRows,
       source: candidate.source
     };
@@ -2041,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%)";
 }
@@ -2079,13 +2375,13 @@ function summarizeSampleValue(value, depth = 0) {
   if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
   if (depth >= 3) {
     if (Array.isArray(parsed)) return [];
-    if (isRecord(parsed)) return {};
+    if (isRecord2(parsed)) return {};
     return compactScalar(parsed);
   }
   if (Array.isArray(parsed)) {
     return parsed.slice(0, 3).map((item) => summarizeSampleValue(item, depth + 1));
   }
-  if (isRecord(parsed)) {
+  if (isRecord2(parsed)) {
     const out = {};
     for (const [key, nested] of Object.entries(parsed)) {
       if (["__dl", "meta", "metadata"].includes(key)) {
@@ -2115,7 +2411,7 @@ function compactCell(value) {
     }
     return `[${parsed.length} items]`;
   }
-  if (isRecord(parsed)) {
+  if (isRecord2(parsed)) {
     for (const key of ["matched_result", "output"]) {
       if (parsed[key] !== null && parsed[key] !== void 0 && parsed[key] !== "") {
         return compactCell(parsed[key]);
@@ -2133,15 +2429,16 @@ 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 columns) {
+  for (const column of sanitized.columns) {
     let nonEmpty = 0;
     let empty = 0;
     let sampleValue;
     let sampleValueType = null;
     const valueCounts = /* @__PURE__ */ new Map();
-    for (const row of rows) {
+    for (const row of sanitized.rows) {
       const raw = row[column];
       const value = compactCell(raw);
       if (value) {
@@ -2160,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;
@@ -2193,10 +2494,14 @@ function writeCanonicalRowsCsv(rowsInfo, outPath) {
       `Run output only includes ${rowsInfo.rows.length} preview row(s) of ${rowsInfo.totalRows}; cannot export a complete CSV from this status payload yet.`
     );
   }
+  const sanitized = sanitizeCsvProjectionInfo({
+    rows: rowsInfo.rows,
+    columns: rowsInfo.columns
+  });
   const resolved = resolve3(outPath);
   writeFileSync3(
     resolved,
-    csvStringFromRows(rowsInfo.rows, rowsInfo.columns),
+    csvStringFromRows(sanitized.rows, sanitized.columns),
     "utf-8"
   );
   return resolved;
@@ -2488,14 +2793,12 @@ function registerOrgCommands(program) {
 import { createHash as createHash3 } from "crypto";
 import {
   existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
   readFileSync as readFileSync3,
   readdirSync,
   realpathSync,
   writeFileSync as writeFileSync4
 } from "fs";
 import { basename as basename3, dirname as dirname6, join as join6, resolve as resolve7 } from "path";
-import { Option } from "commander";
 
 // src/plays/bundle-play-file.ts
 import { tmpdir as tmpdir2 } from "os";
@@ -2510,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 = {
@@ -2579,6 +2881,14 @@ var PLAY_SOURCE_FILE_PATTERN = /\.play\.(?:[cm]?[jt]sx?)$/i;
 var NODE_BUILTIN_SET = new Set(
   builtinModules.flatMap((name) => name.startsWith("node:") ? [name, name.slice(5)] : [name, `node:${name}`])
 );
+function assertValidExportName(exportName) {
+  if (exportName === "default") return;
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
+    throw new Error(
+      `Invalid play export name "${exportName}". Named prebuilt exports must be valid JavaScript identifiers.`
+    );
+  }
+}
 function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -2586,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:");
 }
@@ -2659,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) {
@@ -2673,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 = [
@@ -2773,6 +3093,29 @@ function workersPlayEntryAliasPlugin(playFilePath) {
     }
   };
 }
+function workersNamedPlayEntryAliasPlugin(playFilePath, exportName) {
+  return {
+    name: "deepline-workers-named-play-entry-alias",
+    setup(buildContext) {
+      buildContext.onResolve(
+        { filter: new RegExp(`^${WORKERS_PLAY_ENTRY_VIRTUAL}$`) },
+        () => ({
+          path: `${playFilePath}.${exportName}.entry.ts`,
+          namespace: "deepline-named-play-entry"
+        })
+      );
+      buildContext.onLoad(
+        { filter: /.*/, namespace: "deepline-named-play-entry" },
+        () => ({
+          contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};
+`,
+          loader: "ts",
+          resolveDir: dirname3(playFilePath)
+        })
+      );
+    }
+  };
+}
 function workersNodeBuiltinStubPlugin() {
   const UNSUPPORTED = /* @__PURE__ */ new Set(["node:fs", "node:fs/promises", "node:os", "node:child_process"]);
   return {
@@ -3025,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)) {
@@ -3050,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, {
@@ -3072,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) ?? "";
@@ -3129,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: {
@@ -3192,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).`;
   }
@@ -3204,11 +3526,27 @@ function getBundleSizeError(filePath, bundledCode, artifactKind) {
   }
   return null;
 }
-async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter) {
+function getBundleSizeError(filePath, bundledCode, artifactKind) {
+  return getBundleSizeErrorForBytes(
+    filePath,
+    Buffer.byteLength(bundledCode, "utf8"),
+    artifactKind
+  );
+}
+async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter, exportName) {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter);
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
+  const namedExportShim = exportName === "default" ? null : `export { ${exportName} as default } from ${JSON.stringify(entryFile)};
+`;
   const result = await build({
-    entryPoints: [entryFile],
+    ...namedExportShim ? {
+      stdin: {
+        contents: namedExportShim,
+        resolveDir: dirname3(entryFile),
+        sourcefile: `${basename(entryFile)}.${exportName}.entry.ts`,
+        loader: "ts"
+      }
+    } : { entryPoints: [entryFile] },
     absWorkingDir: adapter.projectRoot,
     bundle: true,
     format: "cjs",
@@ -3236,10 +3574,10 @@ async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter
     outputExtension: "cjs"
   };
 }
-async function runEsbuildForEsmWorkers(playEntryFile, importedPlayDependencies, adapter) {
+async function runEsbuildForEsmWorkers(playEntryFile, importedPlayDependencies, adapter, exportName) {
   const sdkAliasPlugin = localSdkAliasPlugin(adapter, { workersRuntime: true });
   const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
-  const playEntryAlias = workersPlayEntryAliasPlugin(playEntryFile);
+  const playEntryAlias = exportName === "default" ? workersPlayEntryAliasPlugin(playEntryFile) : workersNamedPlayEntryAliasPlugin(playEntryFile, exportName);
   const result = await build({
     // Entry is the Workers harness; it imports the play via the virtual
     // `deepline-play-entry` alias resolved by workersPlayEntryAliasPlugin.
@@ -3310,10 +3648,16 @@ async function runEsbuildForEsmWorkers(playEntryFile, importedPlayDependencies,
 async function bundlePlayFile(filePath, options) {
   const adapter = options.adapter;
   const target = options.target ?? PLAY_ARTIFACT_KINDS.cjsNode20;
+  const exportName = options.exportName?.trim() || "default";
+  assertValidExportName(exportName);
   const absolutePath = await normalizeLocalPath(filePath);
   adapter.warnAboutNonDevelopmentBundling?.(absolutePath);
   try {
     const analysis = await analyzeSourceGraph(absolutePath, adapter);
+    analysis.graphHash = sha256(
+      `${analysis.graphHash}
+entry-export:${exportName}`
+    );
     if (target === PLAY_ARTIFACT_KINDS.esmWorkers) {
       const harnessFingerprint = await computeWorkersHarnessFingerprintWithAdapter(adapter);
       analysis.graphHash = sha256(
@@ -3321,6 +3665,23 @@ async function bundlePlayFile(filePath, options) {
 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) {
@@ -3340,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,
@@ -3347,25 +3709,7 @@ 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) : await runEsbuildForCjsNode(absolutePath, analysis.importedPlayDependencies, adapter);
+    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 {
         success: false,
@@ -3375,7 +3719,8 @@ workers-harness:${harnessFingerprint}`
     }
     const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
     const normalizedSourceMap = normalizeSourceMapForRuntime(sourceMapText);
-    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${basename(absolutePath).replace(/\.[^.]+$/, "")}.${outputExtension}`;
+    const virtualBaseName = exportName === "default" ? basename(absolutePath).replace(/\.[^.]+$/, "") : `${basename(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
+    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
     const executableCode = `${bundledCode}
 //# sourceMappingURL=${basename(virtualFilename)}.map
 `;
@@ -3413,6 +3758,7 @@ workers-harness:${harnessFingerprint}`
       success: true,
       artifact,
       sourceCode: analysis.sourceCode,
+      sourceFiles: analysis.sourceFiles,
       filePath: absolutePath,
       playName: analysis.playName,
       packagedFiles: discoveredFiles.files,
@@ -3494,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");
@@ -3506,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 {
@@ -3638,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);
@@ -3711,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, "..");
@@ -3726,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");
@@ -3758,7 +4181,7 @@ function createSdkPlayBundlingAdapter() {
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
-    sdkTypesEntryFile: 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,
@@ -3769,6 +4192,7 @@ function createSdkPlayBundlingAdapter() {
 async function bundlePlayFile2(filePath, options = {}) {
   return bundlePlayFile(filePath, {
     target: options.target ?? defaultPlayBundleTarget(),
+    exportName: options.exportName,
     adapter: createSdkPlayBundlingAdapter()
   });
 }
@@ -3918,54 +4342,6 @@ function createCliProgress(enabled) {
   return progress;
 }
 
-// src/cli/trace.ts
-var cliTraceStartedAt = Date.now();
-function isTruthyEnv(value) {
-  return value === "1" || value === "true" || value === "yes";
-}
-function isCliTraceEnabled() {
-  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
-}
-function recordCliTrace(event) {
-  if (!isCliTraceEnabled()) {
-    return;
-  }
-  const now = Date.now();
-  const payload = {
-    ts: now,
-    source: "cli",
-    sinceStartMs: now - cliTraceStartedAt,
-    ...event
-  };
-  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
-`);
-}
-async function traceCliSpan(phase, fields, run) {
-  if (!isCliTraceEnabled()) {
-    return run();
-  }
-  const startedAt = Date.now();
-  try {
-    const result = await run();
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: true,
-      ...fields
-    });
-    return result;
-  } catch (error) {
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-      ...fields
-    });
-    throw error;
-  }
-}
-
 // src/cli/commands/play.ts
 function parseReferencedPlayTarget(target) {
   const trimmed = target.trim();
@@ -4013,67 +4389,6 @@ function defaultMaterializedPlayPath(reference) {
   const safeName = playName.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   return resolve7(`${safeName || "play"}.play.ts`);
 }
-function sanitizeGeneratedPlayName(value) {
-  return value.trim().toLowerCase().replace(/^prebuilt\//, "").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "play";
-}
-function buildGeneratedCsvWrapperSource(input) {
-  return `import { definePlay } from 'deepline';
-
-export default definePlay(
-  ${JSON.stringify(input.wrapperName)},
-  async (ctx, input: Record<string, unknown> & { file: string }) => {
-    const rows = await ctx.csv<Record<string, unknown>>(input.file);
-    const constants = Object.fromEntries(
-      Object.entries(input).filter(([key]) => key !== 'file'),
-    );
-
-    const mappedRows = await ctx
-      .map('csv_rows', rows, {
-        key: (row, index) =>
-          String(
-            row.id ??
-              row.lead_id ??
-              row.email ??
-              row.linkedin_url ??
-              row.domain ??
-              index,
-          ),
-      })
-      .step('result', (row, rowCtx) =>
-        rowCtx.runPlay(
-          'row_play',
-          ${JSON.stringify(input.playRef)},
-          {
-            ...constants,
-            ...row,
-          },
-          {
-            description: 'Run the source play for this CSV row.',
-          },
-        ),
-      )
-      .run({ description: 'Run the source play once per CSV row.' });
-
-    return { rows: mappedRows };
-  },
-);
-`;
-}
-function writeGeneratedCsvWrapperPlay(playRef) {
-  const baseName = sanitizeGeneratedPlayName(
-    parseReferencedPlayTarget(playRef).unqualifiedPlayName
-  );
-  const wrapperName = `${baseName}-csv`;
-  const outputDir = resolve7(".deepline", "generated");
-  const outputPath = join6(outputDir, `${wrapperName}.play.ts`);
-  mkdirSync3(outputDir, { recursive: true });
-  writeFileSync4(
-    outputPath,
-    buildGeneratedCsvWrapperSource({ wrapperName, playRef }),
-    "utf-8"
-  );
-  return outputPath;
-}
 function materializeRemotePlaySource(input) {
   if (isFileTarget(input.target)) {
     return null;
@@ -4103,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) {
@@ -4139,7 +4456,10 @@ function looksLikeFilePath(target) {
   if (target.trim().toLowerCase().startsWith("prebuilt/")) {
     return false;
   }
-  return target.includes("/") || target.includes("\\") || /\.(ts|js|mjs|play\.ts)$/.test(target);
+  if (target.startsWith("./") || target.startsWith("../") || target.startsWith("/") || target.startsWith("~/")) {
+    return true;
+  }
+  return target.includes("\\") || /\.(ts|js|mjs|play\.ts)$/.test(target);
 }
 function parsePositiveInteger2(value, flagName) {
   const parsed = Number.parseInt(value, 10);
@@ -4156,6 +4476,142 @@ function parseJsonInput(raw) {
   }
   return parsed;
 }
+function parseInputFieldFlag(rawFlag, nextArg) {
+  const flag = rawFlag.slice(2);
+  const equalsIndex = flag.indexOf("=");
+  if (equalsIndex > 0) {
+    const path = flag.slice(0, equalsIndex).trim();
+    const value = flag.slice(equalsIndex + 1);
+    if (!path) {
+      throw new Error(`Invalid play input flag: ${rawFlag}`);
+    }
+    return { path, value };
+  }
+  if (!nextArg || nextArg.startsWith("--")) {
+    throw new Error(`Play input flag ${rawFlag} requires a value.`);
+  }
+  return { path: flag, value: nextArg };
+}
+function parseInputFlagValue(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  if (trimmed === "true" || trimmed === "false" || trimmed === "null" || trimmed.startsWith("{") || trimmed.startsWith("[") || /^-?\d+(\.\d+)?$/.test(trimmed)) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function getDottedInputValue(input, path) {
+  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
+  let cursor = input;
+  for (const part of parts) {
+    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function setDottedInputValue(input, path, value) {
+  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error(`Invalid play input flag path: ${path}`);
+  }
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const existing = cursor[part];
+    if (existing !== void 0 && (!existing || typeof existing !== "object" || Array.isArray(existing))) {
+      throw new Error(
+        `Cannot set --${path}; input.${part} is already a non-object value.`
+      );
+    }
+    if (!existing) {
+      cursor[part] = {};
+    }
+    cursor = cursor[part];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+function schemaMetadata(schema, key) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return null;
+  const value = schema[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringMetadata(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function inputFieldFromCsvArg(csvArg) {
+  if (typeof csvArg !== "string") return null;
+  const match = /^input\.([A-Za-z_$][\w$]*)$/.exec(csvArg.trim());
+  return match?.[1] ?? null;
+}
+function fileInputBindingsFromPlaySchema(inputSchema) {
+  const csvInput = schemaMetadata(inputSchema, "csvInput");
+  if (!csvInput) return [];
+  return [
+    {
+      inputPath: stringMetadata(csvInput, "inputField") ?? "csv"
+    }
+  ];
+}
+function fileInputBindingsFromStaticPipeline(staticPipeline) {
+  if (!staticPipeline || typeof staticPipeline !== "object" || Array.isArray(staticPipeline)) {
+    return [];
+  }
+  const inputField = inputFieldFromCsvArg(
+    staticPipeline.csvArg
+  );
+  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;
+  return existsSync4(resolve7(value));
+}
+async function stageFileInputArgs(input) {
+  const uniqueBindings = [
+    ...new Map(input.bindings.map((binding) => [binding.inputPath, binding])).values()
+  ];
+  const localFiles = uniqueBindings.flatMap((binding) => {
+    const value = getDottedInputValue(input.runtimeInput, binding.inputPath);
+    if (!isLocalFilePathValue(value)) return [];
+    const absolutePath = resolve7(value);
+    return [{ binding, absolutePath, logicalPath: basename3(absolutePath) }];
+  });
+  if (localFiles.length === 0) {
+    return { inputFile: null, packagedFiles: [] };
+  }
+  input.progress.phase(
+    localFiles.length === 1 ? "staging input file" : "staging input files"
+  );
+  const staged = await input.client.stagePlayFiles(
+    localFiles.map((file) => stageFile(file.logicalPath, file.absolutePath))
+  );
+  for (const [index, file] of localFiles.entries()) {
+    setDottedInputValue(input.runtimeInput, file.binding.inputPath, file.logicalPath);
+    const stagedFile = staged[index];
+    if (stagedFile && stagedFile.logicalPath !== file.logicalPath) {
+      setDottedInputValue(input.runtimeInput, file.binding.inputPath, stagedFile.logicalPath);
+    }
+  }
+  return {
+    inputFile: staged[0] ?? null,
+    packagedFiles: staged.slice(1)
+  };
+}
 function stageFile(logicalPath, absolutePath) {
   const buffer = readFileSync3(absolutePath);
   return {
@@ -4243,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) => {
@@ -4292,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
@@ -4309,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;
@@ -4473,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,
@@ -4483,68 +4880,8 @@ function assertPlayWaitNotTimedOut(input) {
         ...input.lastPhase ? { phase: input.lastPhase } : {},
         timeoutMs: input.waitTimeoutMs
       }
-    );
-  }
-}
-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();
@@ -4564,24 +4901,10 @@ async function startAndWaitForPlayCompletionByStream(input) {
     },
     Math.max(1, input.waitTimeoutMs)
   );
-  recordCliTrace({
-    phase: "cli.start_stream_request",
-    playName: input.playName
-  });
   try {
-    let eventCount = 0;
     for await (const event of input.client.startPlayRunStream(input.request, {
       signal: controller.signal
     })) {
-      eventCount += 1;
-      if (eventCount === 1) {
-        recordCliTrace({
-          phase: "cli.start_stream_first_event",
-          ms: Date.now() - startedAt,
-          playName: input.playName,
-          eventType: event.type
-        });
-      }
       const eventRunId = getEventPayload(event).runId;
       if (typeof eventRunId === "string" && eventRunId && eventRunId !== "pending") {
         lastKnownWorkflowId = eventRunId;
@@ -4622,14 +4945,6 @@ async function startAndWaitForPlayCompletionByStream(input) {
       });
       const finalStatus = getFinalStatusFromLiveEvent(event);
       if (finalStatus) {
-        recordCliTrace({
-          phase: "cli.start_stream_final_event",
-          ms: Date.now() - startedAt,
-          playName: input.playName,
-          runId: finalStatus.runId,
-          status: finalStatus.status,
-          eventCount
-        });
         return finalStatus;
       }
     }
@@ -4647,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,
@@ -4669,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(
@@ -4746,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 ?? "-");
 }
@@ -4906,18 +5209,153 @@ function buildRunWarnings(status, rowsInfo) {
 }
 function buildRunNextCommands(runId) {
   return {
-    exportCsv: `deepline runs export ${runId} --out output.csv`,
-    status: `deepline runs status ${runId} --json`,
-    fullStatus: `deepline runs status ${runId} --json --full`,
-    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 {
@@ -4926,18 +5364,38 @@ 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,
     ...result !== void 0 ? { result } : {},
     ...status.resultView ? { resultView: status.resultView } : {},
     ...datasetStats ? { dataset_stats: datasetStats } : {},
-    ...rowsInfo ? { previewRows: rowsInfo.rows.slice(0, 10) } : {},
+    ...rowsInfo ? { previewRows: rowsInfo.rows.slice(0, 5) } : {},
     ...billing ? { billing } : {},
-    ...status.run ? { run: status.run } : {},
     next: buildRunNextCommands(status.runId)
   };
 }
+function enrichPlayStatusWithDatasetStats(status) {
+  const rowsInfo = extractCanonicalRowsInfo(status);
+  if (!rowsInfo?.complete) {
+    return status;
+  }
+  return {
+    ...status,
+    dataset_stats: buildDatasetStats(
+      rowsInfo.rows,
+      rowsInfo.totalRows,
+      rowsInfo.columns,
+      extractDatasetExecutionStats(status)
+    )
+  };
+}
 function formatDatasetStatsLines(datasetStats) {
   if (!datasetStats) {
     return [];
@@ -4947,10 +5405,11 @@ function formatDatasetStatsLines(datasetStats) {
     0,
     12
   )) {
-    const topValues = stat3.top_values ? `, ${Object.entries(stat3.top_values).slice(0, 3).map(([value, count]) => `${value}=${count}`).join(", ")}` : "";
-    const sample = stat3.sample_value !== void 0 ? `, sample=${JSON.stringify(stat3.sample_value)}` : "";
+    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}: ${stat3.non_empty}, unique=${stat3.unique}${topValues}${sample}`
+      `    ${column}: non_empty=${stat3.non_empty}, unique=${stat3.unique}${topValues}${sample}${execution}`
     );
   }
   return lines;
@@ -4959,7 +5418,7 @@ function writePlayResult(status, jsonOutput, options) {
   if (jsonOutput) {
     process.stdout.write(
       `${JSON.stringify(
-        options?.fullJson ? status : compactPlayStatus(status, options)
+        options?.fullJson ? enrichPlayStatusWithDatasetStats(status) : compactPlayStatus(status, options)
       )}
 `
     );
@@ -4973,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;
@@ -5092,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}`);
@@ -5108,10 +5572,9 @@ function writeStartedPlayRun(input) {
   console.log(output);
 }
 function parsePlayRunOptions(args) {
-  const usage = "Usage: deepline plays run <play-name> [--input '{...}'] [--csv file.csv] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force]\n       deepline plays run <play-file.ts> [--input '{...}'] [--csv file.csv] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force]\n       deepline plays run --file <play-file.ts> [--input '{...}'] [--csv file.csv] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force]\n       deepline plays run --name <name> [--input '{...}'] [--csv file.csv] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--json]";
+  const usage = "Usage: deepline plays run <play-name> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run --file <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n       deepline plays run --name <name> [--input '{...}'] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--json] [--<input> value]";
   let filePath = null;
   let playName = null;
-  let csvPath = null;
   let input = null;
   let revisionId = null;
   let revisionSelector = null;
@@ -5132,10 +5595,6 @@ function parsePlayRunOptions(args) {
       playName = parseReferencedPlayTarget(args[++index]).playName;
       continue;
     }
-    if (arg === "--csv" && args[index + 1]) {
-      csvPath = resolve7(args[++index]);
-      continue;
-    }
     if ((arg === "--input" || arg === "-i") && args[index + 1]) {
       input = parseJsonInput(args[++index]);
       continue;
@@ -5185,8 +5644,13 @@ function parsePlayRunOptions(args) {
       continue;
     }
     if (arg.startsWith("--")) {
-      throw new Error(`Unexpected flag: ${arg}
-${usage}`);
+      const { path, value } = parseInputFieldFlag(arg, args[index + 1]);
+      input ??= {};
+      setDottedInputValue(input, path, parseInputFlagValue(value));
+      if (!arg.includes("=")) {
+        index += 1;
+      }
+      continue;
     }
     if (!arg.startsWith("--") && !filePath && !playName) {
       if (isFileTarget(arg) || looksLikeFilePath(arg)) {
@@ -5222,7 +5686,6 @@ ${usage}`);
   }
   return {
     target: filePath ? { kind: "file", path: filePath } : { kind: "name", name: playName },
-    csvPath,
     input,
     revisionId,
     revisionSelector,
@@ -5243,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)) {
@@ -5268,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) {
@@ -5297,34 +5782,12 @@ async function handleFileBackedRun(options) {
   const client = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = resolve7(options.target.path);
-  recordCliTrace({
-    phase: "cli.play_run_file_start",
-    playPath: absolutePlayPath,
-    watch: options.watch,
-    hasCsv: Boolean(options.csvPath),
-    force: options.force
-  });
   progress.phase("compiling play");
-  const readSourceStartedAt = Date.now();
   const sourceCode = readFileSync3(absolutePlayPath, "utf-8");
-  recordCliTrace({
-    phase: "cli.read_play_source",
-    ms: Date.now() - readSourceStartedAt,
-    bytes: sourceCode.length,
-    playPath: absolutePlayPath
-  });
   let graph;
   try {
-    graph = await traceCliSpan(
-      "cli.bundle_play_graph",
-      { playPath: absolutePlayPath },
-      () => collectBundledPlayGraph(absolutePlayPath)
-    );
-    await traceCliSpan(
-      "cli.compile_play_manifest",
-      { playPath: absolutePlayPath, nodeCount: graph.nodes.size },
-      () => compileBundledPlayGraphManifests(client, graph)
-    );
+    graph = await collectBundledPlayGraph(absolutePlayPath);
+    await compileBundledPlayGraphManifests(client, graph);
     progress.phase("compiled play");
   } catch (error) {
     progress.fail();
@@ -5335,87 +5798,65 @@ async function handleFileBackedRun(options) {
   const playName = bundleResult.playName ?? extractPlayName(sourceCode, absolutePlayPath);
   try {
     progress.phase("publishing imported plays");
-    await traceCliSpan(
-      "cli.publish_imported_plays",
-      { playName, nodeCount: graph.nodes.size },
-      () => publishImportedPlayDependencies(client, graph)
-    );
+    await publishImportedPlayDependencies(client, graph);
   } catch (error) {
     progress.fail();
     console.error(error instanceof Error ? error.message : String(error));
     return 1;
   }
   const runtimeInput = options.input ? { ...options.input } : {};
-  const prepareFilesStartedAt = Date.now();
   const packagedFileUploads = bundleResult.packagedFiles.map(
     (file) => stageFile(file.logicalPath, file.absolutePath)
   );
-  const inputFileUpload = options.csvPath ? stageFile(basename3(options.csvPath), options.csvPath) : packagedFileUploads[0] ?? null;
-  if (options.csvPath && typeof runtimeInput.file !== "string" && typeof runtimeInput.csv !== "string") {
-    runtimeInput.file = basename3(options.csvPath);
-  }
-  recordCliTrace({
-    phase: "cli.prepare_input_files",
-    ms: Date.now() - prepareFilesStartedAt,
-    playName,
-    packagedFileCount: packagedFileUploads.length,
-    hasInputFile: Boolean(inputFileUpload)
+  const fileInputBindings = fileInputBindingsFromStaticPipeline(
+    requireCompilerManifest(bundleResult).staticPipeline
+  );
+  applyCsvShortcutInput({
+    runtimeInput,
+    bindings: fileInputBindings,
+    fallbackInputPath: "file"
+  });
+  const stagedFileInputs = await stageFileInputArgs({
+    client,
+    runtimeInput,
+    bindings: fileInputBindings,
+    progress
   });
   const startRequest = {
     name: playName,
     sourceCode: bundleResult.sourceCode,
+    sourceFiles: bundleResult.sourceFiles,
     runtimeArtifact: bundleResult.artifact,
     compilerManifest: requireCompilerManifest(bundleResult),
-    inputFileUpload,
     packagedFileUploads,
     ...Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {},
+    ...stagedFileInputs.inputFile ? { inputFile: stagedFileInputs.inputFile } : {},
+    ...stagedFileInputs.packagedFiles.length ? { packagedFiles: stagedFileInputs.packagedFiles } : {},
     ...options.force ? { force: true } : {}
   };
   if (options.watch) {
     progress.phase("starting run");
-    const finalStatus = await traceCliSpan(
-      "cli.start_and_watch",
-      { playName },
-      () => startAndWaitForPlayCompletionByStream({
-        client,
-        request: startRequest,
-        playName,
-        jsonOutput: options.jsonOutput,
-        emitLogs: options.emitLogs,
-        waitTimeoutMs: options.waitTimeoutMs,
-        progress
-      })
-    );
-    const exportStartedAt = Date.now();
-    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
-    recordCliTrace({
-      phase: "cli.export_rows",
-      ms: Date.now() - exportStartedAt,
+    const finalStatus = await startAndWaitForPlayCompletionByStream({
+      client,
+      request: startRequest,
       playName,
-      exported: Boolean(exportedPath)
+      jsonOutput: options.jsonOutput,
+      emitLogs: options.emitLogs,
+      waitTimeoutMs: options.waitTimeoutMs,
+      progress
     });
+    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
     if (finalStatus.status === "completed") {
       progress.complete();
     } else {
       progress.fail();
     }
-    recordCliTrace({
-      phase: "cli.write_play_result",
-      playName,
-      status: finalStatus.status,
-      runId: finalStatus.runId
-    });
     writePlayResult(finalStatus, options.jsonOutput, { exportedPath });
     return finalStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
-  const started = await traceCliSpan(
-    "cli.start_run",
-    { playName },
-    () => client.startPlayRun(startRequest)
-  );
-  const fallbackDashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
-  const dashboardUrl = started.dashboardUrl ?? fallbackDashboardUrl;
+  const started = await client.startPlayRun(startRequest);
+  const dashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
   writeStartedPlayRun({
@@ -5423,7 +5864,7 @@ async function handleFileBackedRun(options) {
     playName,
     status: started.status,
     statusUrl: started.statusUrl,
-    dashboardUrl,
+    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
     jsonOutput: options.jsonOutput,
     progress
   });
@@ -5449,9 +5890,8 @@ async function handleNamedRun(options) {
   }
   const client = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  let stagedInputFile = null;
   progress.phase("loading play definition");
-  await assertCanonicalNamedPlayReference(client, options.target.name);
+  const playDetail = await assertCanonicalNamedPlayReference(client, options.target.name);
   progress.phase("selecting revision");
   const selectedRevisionId = await resolveNamedRunRevisionId({
     client,
@@ -5459,19 +5899,27 @@ async function handleNamedRun(options) {
     revisionId: options.revisionId,
     selector: options.revisionSelector
   });
-  if (options.csvPath) {
-    progress.phase("staging input file");
-    const [staged] = await client.stagePlayFiles([
-      stageFile(basename3(options.csvPath), options.csvPath)
-    ]);
-    stagedInputFile = staged ?? null;
-  }
   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: fileInputBindings,
+    progress
+  });
   const startRequest = {
     name: options.target.name,
     ...selectedRevisionId ? { revisionId: selectedRevisionId } : {},
     ...Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {},
-    ...stagedInputFile ? { inputFile: stagedInputFile } : {},
+    ...stagedFileInputs.inputFile ? { inputFile: stagedFileInputs.inputFile } : {},
+    ...stagedFileInputs.packagedFiles.length ? { packagedFiles: stagedFileInputs.packagedFiles } : {},
     ...options.force ? { force: true } : {}
   };
   if (options.watch) {
@@ -5485,22 +5933,6 @@ async function handleNamedRun(options) {
       waitTimeoutMs: options.waitTimeoutMs,
       progress
     });
-    if (finalStatus.status !== "completed" && options.csvPath) {
-      progress.phase("generating csv wrapper play");
-      const generatedPlayPath = writeGeneratedCsvWrapperPlay(
-        options.target.name
-      );
-      progress.writeLogLine(
-        `Generated CSV wrapper play: ${generatedPlayPath}`
-      );
-      progress.phase("running generated csv wrapper play");
-      return handleFileBackedRun({
-        ...options,
-        target: { kind: "file", path: generatedPlayPath },
-        revisionId: null,
-        revisionSelector: null
-      });
-    }
     const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
     if (finalStatus.status === "completed") {
       progress.complete();
@@ -5512,11 +5944,10 @@ async function handleNamedRun(options) {
   }
   progress.phase("starting run");
   const started = await client.startPlayRun(startRequest);
-  const fallbackDashboardUrl = buildPlayDashboardUrl(
+  const dashboardUrl = buildPlayDashboardUrl(
     client.baseUrl,
     options.target.name
   );
-  const dashboardUrl = started.dashboardUrl ?? fallbackDashboardUrl;
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
   writeStartedPlayRun({
@@ -5524,7 +5955,7 @@ async function handleNamedRun(options) {
     playName: started.name ?? options.target.name,
     status: started.status,
     statusUrl: started.statusUrl,
-    dashboardUrl,
+    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
     jsonOutput: options.jsonOutput,
     progress
   });
@@ -5558,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);
@@ -5640,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);
@@ -5655,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;
 }
@@ -5705,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) {
@@ -5743,8 +6246,9 @@ async function handlePlayGet(args) {
     return 1;
   }
   const client = new DeeplineClient();
-  const jsonOutput = argsWantJson(args);
+  const explicitJson = args.includes("--json");
   const sourceOutput = args.includes("--source");
+  const jsonOutput = sourceOutput ? explicitJson : argsWantJson(args);
   let outPath = null;
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
@@ -5755,7 +6259,7 @@ async function handlePlayGet(args) {
   const playName = isFileTarget(target) ? extractPlayName(readFileSync3(resolve7(target), "utf-8"), resolve7(target)) : parseReferencedPlayTarget(target).playName;
   const detail = isFileTarget(target) ? await client.getPlay(playName) : await assertCanonicalNamedPlayReference(client, target);
   const resolvedSource = detail.play.workingRevision?.sourceCode ?? detail.play.liveRevision?.sourceCode ?? detail.play.currentRevision?.sourceCode ?? detail.play.sourceCode ?? "";
-  const materializedFile = sourceOutput || outPath ? materializeRemotePlaySource({
+  const materializedFile = outPath ? materializeRemotePlaySource({
     target,
     playName,
     sourceCode: resolvedSource,
@@ -5795,6 +6299,10 @@ async function handlePlayGet(args) {
     }
     return 0;
   }
+  if (outPath && loadedMessage) {
+    console.log(loadedMessage);
+    return 0;
+  }
   console.log(`Play: ${formatPlayReference(detail.play)}`);
   console.log(
     `Working version: ${detail.play.workingRevision?.version ?? "\u2014"}`
@@ -5818,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)}`;
@@ -5961,7 +6442,26 @@ function printPlayDescription(play) {
       console.log(`    ${line}`);
     }
   }
+  if (play.csvInput) {
+    console.log("  CSV input:");
+    const rendered = JSON.stringify(play.csvInput, null, 2);
+    for (const line of rendered.split("\n")) {
+      console.log(`    ${line}`);
+    }
+  }
+  if (play.rowOutputSchema) {
+    console.log("  Row output schema:");
+    const rendered = JSON.stringify(play.rowOutputSchema, null, 2);
+    for (const line of rendered.split("\n")) {
+      console.log(`    ${line}`);
+    }
+  }
   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;
@@ -6059,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
@@ -6100,6 +6601,45 @@ async function handlePlayPublish(args) {
 `);
   return result.success ? 0 : 1;
 }
+async function handlePlayDelete(args) {
+  const playName = args[0];
+  if (!playName) {
+    console.error("Usage: deepline plays delete <play-name> --yes [--json]");
+    return 1;
+  }
+  const confirmed = args.includes("--yes") || args.includes("-y") || args.includes("--force");
+  if (!confirmed) {
+    console.error(
+      "Refusing to delete without --yes. This deletes the org-owned play, its revisions, trigger bindings, and local run records."
+    );
+    return 1;
+  }
+  const client = new DeeplineClient();
+  let detail;
+  try {
+    detail = await client.getPlay(parseReferencedPlayTarget(playName).playName);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (detail.play.ownerType === "deepline" || detail.play.origin === "prebuilt") {
+    console.error(`Cannot delete prebuilt play: ${formatPlayReference(detail.play)}`);
+    return 1;
+  }
+  const result = await client.deletePlay(
+    parseReferencedPlayTarget(formatPlayReference(detail.play)).playName
+  );
+  if (argsWantJson(args)) {
+    process.stdout.write(`${JSON.stringify(result)}
+`);
+    return result.deleted ? 0 : 1;
+  }
+  process.stdout.write(
+    `Deleted ${result.name}: revisions=${result.deletedRevisionCount}, bindings=${result.deletedBindingCount}, runs=${result.deletedRunCount}
+`
+  );
+  return result.deleted ? 0 : 1;
+}
 function registerPlayCommands(program) {
   const play = program.command("plays").alias("play").description("Search, validate, run, and manage cloud plays.").addHelpText(
     "after",
@@ -6133,21 +6673,23 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  play.command("run [target]").description("Run a play file or named play.").addHelpText(
+  play.command("run [target]").description("Run a play file or named play.").allowUnknownOption(true).allowExcessArguments(true).addHelpText(
     "after",
     `
 Notes:
-  Local play files are bundled locally, then validated and executed in Deepline cloud.
-  Named plays run the stored live cloud revision.
-  Run performs server preflight automatically. Use \`deepline plays check <file>\`
-  to validate without starting a run.
+	  Local play files are bundled locally, then validated and executed in Deepline cloud.
+	  Named plays run the stored live cloud revision.
+	  Unknown --foo and --foo.bar flags are treated as play input args.
+	  File-like input args accept local paths; the CLI stages those files before submit.
+	  Run performs server preflight automatically. Use \`deepline plays check <file>\`
+	  to validate without starting a run.
 
 Examples:
   deepline plays run my.play.ts --input '{"domain":"stripe.com"}' --watch
   deepline plays run person-linkedin-to-email --input '{"linkedin_url":"..."}' --watch
   deepline plays run enrich.play.ts --csv leads.csv --watch --out leads-enriched.csv
 `
-  ).option("--file <path>", "Local play file to run").option("--name <name>", "Saved play name to run").option("--csv <path>", "Attach a CSV file").option("-i, --input <json>", "Input JSON object or @file path").option("--live", "Run the current live revision explicitly").option("--latest", "Run the newest saved revision, even if it is not live").option(
+  ).option("--file <path>", "Local play file to run").option("--name <name>", "Saved play name to run").option("-i, --input <json>", "Input JSON object or @file path").option("--live", "Run the current live revision explicitly").option("--latest", "Run the newest saved revision, even if it is not live").option(
     "--revision-id <id>",
     "Run a specific saved revision instead of the live revision"
   ).option(
@@ -6156,12 +6698,21 @@ Examples:
   ).option("--watch", "Stream logs until completion").option(
     "--logs",
     "When output is non-interactive, stream play logs to stderr while waiting"
-  ).option("--poll-interval-ms <ms>", "Polling interval while tailing").option("--tail-timeout-ms <ms>", "Timeout while tailing").option("--force", "Supersede any active runs for this play").option("--json", "Emit JSON output").action(async (target, options) => {
+  ).option("--poll-interval-ms <ms>", "Polling interval while tailing").option("--tail-timeout-ms <ms>", "Timeout while tailing").option("--force", "Supersede any active runs for this play").option("--json", "Emit JSON output").action(async (target, options, command) => {
+    const passthroughArgs = [...command.args];
+    const explicitTarget = options.file || options.name;
+    const targetIsInputFlag = typeof target === "string" && target.startsWith("--");
+    const effectiveTarget = explicitTarget || targetIsInputFlag ? null : target;
+    if (explicitTarget && typeof target === "string" && !targetIsInputFlag && !passthroughArgs.includes(target)) {
+      passthroughArgs.push(target);
+    }
+    if (effectiveTarget && passthroughArgs[0] === effectiveTarget) {
+      passthroughArgs.shift();
+    }
     process.exitCode = await handlePlayRun([
-      ...target ? [target] : [],
+      ...effectiveTarget ? [effectiveTarget] : [],
       ...options.file ? ["--file", options.file] : [],
       ...options.name ? ["--name", options.name] : [],
-      ...options.csv ? ["--csv", options.csv] : [],
       ...options.input ? ["--input", options.input] : [],
       ...options.live ? ["--live"] : [],
       ...options.latest ? ["--latest"] : [],
@@ -6172,7 +6723,8 @@ Examples:
       ...options.pollIntervalMs ? ["--poll-interval-ms", options.pollIntervalMs] : [],
       ...options.tailTimeoutMs ? ["--tail-timeout-ms", options.tailTimeoutMs] : [],
       ...options.force ? ["--force"] : [],
-      ...options.json ? ["--json"] : []
+      ...options.json ? ["--json"] : [],
+      ...passthroughArgs
     ]);
   });
   play.command("get <target>").description("Fetch full play details.").addHelpText(
@@ -6186,12 +6738,10 @@ Notes:
 Examples:
   deepline plays get person-linkedin-to-email
   deepline plays get person-linkedin-to-email --json | jq '.play.liveRevision'
+  deepline plays get prebuilt/name-and-domain-to-email-waterfall-batch --source > email-waterfall.play.ts
+  deepline plays get prebuilt/name-and-domain-to-email-waterfall-batch --source --out ./email-waterfall.play.ts
 `
-  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").addOption(
-    new Option("--source", "Materialize or print the source code").hideHelp()
-  ).addOption(
-    new Option("--out <path>", "Write source to a specific path").hideHelp()
-  ).action(async (target, options) => {
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--source", "Print raw source code; combine with --out to write a file").option("--out <path>", "Write source to a specific path").action(async (target, options) => {
     process.exitCode = await handlePlayGet([
       target,
       ...options.json ? ["--json"] : [],
@@ -6230,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", "With --json, emit the full 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,
@@ -6282,40 +6794,81 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
-  const runs = program.command("runs").description("Inspect and export play runs.").addHelpText(
+  play.command("delete <target>").description("Delete an org-owned play and its saved revisions/runs.").option("-y, --yes", "Confirm deletion").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (target, options) => {
+    process.exitCode = await handlePlayDelete([
+      target,
+      ...options.yes ? ["--yes"] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  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", "With --json, emit the full 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 mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join7 } from "path";
 function isPlainObject(value) {
@@ -6393,7 +6946,7 @@ function tryConvertToList(payload, options) {
 }
 function ensureOutputDir() {
   const outputDir = join7(homedir3(), ".local", "share", "deepline", "data");
-  mkdirSync4(outputDir, { recursive: true });
+  mkdirSync3(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
@@ -6482,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;
   }
@@ -6560,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",
@@ -6646,7 +7194,7 @@ function printToolDetails(tool, requestedToolId) {
   const operation = typeof tool.operation === "string" ? tool.operation : "";
   const displayBase = operation && operation.startsWith(`${tool.provider}_`) ? operation.slice(String(tool.provider).length + 1) : operation ? `${tool.provider} ${operation}`.trim() : toolId;
   const displayName = titleCase(displayBase || String(tool.displayName || toolId));
-  const cost = isRecord2(tool.cost) ? tool.cost : null;
+  const cost = isRecord3(tool.cost) ? tool.cost : null;
   const deeplineCredits = numberField(tool, "deeplineCreditsPerPricingUnit", "deepline_credits_per_pricing_unit");
   const deeplineUsdPerPricingUnit = numberField(tool, "deeplineUsdPerPricingUnit", "deepline_usd_per_pricing_unit");
   const deeplineUsdPerCredit = numberField(tool, "deeplineUsdPerCredit", "deepline_usd_per_credit");
@@ -6691,7 +7239,7 @@ function printToolDetails(tool, requestedToolId) {
     if (stepContributions.length) {
       console.log("    step contributions:");
       for (const item of stepContributions) {
-        if (!isRecord2(item)) continue;
+        if (!isRecord3(item)) continue;
         const stepTool = typeof item.tool === "string" ? item.tool.trim() : "";
         const low = typeof item.lowCredits === "number" ? item.lowCredits : null;
         const high = typeof item.highCredits === "number" ? item.highCredits : null;
@@ -6778,12 +7326,12 @@ function printToolCost(input) {
   return false;
 }
 function toolInputFieldsForDisplay(inputSchema) {
-  if (Array.isArray(inputSchema.fields)) return inputSchema.fields.filter(isRecord2);
-  const jsonSchema = isRecord2(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord2(jsonSchema.properties) ? jsonSchema.properties : {};
+  if (Array.isArray(inputSchema.fields)) return inputSchema.fields.filter(isRecord3);
+  const jsonSchema = isRecord3(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord3(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
   return Object.entries(properties).map(([name, value]) => {
-    const property = isRecord2(value) ? value : {};
+    const property = isRecord3(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
@@ -6810,7 +7358,7 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord2(entry)) return void 0;
+  if (!isRecord3(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function isPlayTool(tool) {
@@ -6831,7 +7379,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField(source, ...keys) {
@@ -6858,7 +7406,7 @@ function arrayField(source, ...keys) {
 function recordField(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord2(value)) return value;
+    if (isRecord3(value)) return value;
   }
   return {};
 }
@@ -6922,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 {
@@ -6949,7 +7552,7 @@ async function executeTool(args) {
     }
     throw error;
   }
-  const rawResponse = await client.executeToolRaw(parsed.toolId, parsed.params);
+  const rawResponse = await client.executeTool(parsed.toolId, parsed.params);
   const listConversion = tryConvertToList(rawResponse, {
     listExtractorPaths: metadata.listExtractorPaths ?? []
   });
@@ -6975,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,
@@ -6983,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
     })}
 `);
@@ -7000,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 mkdirSync5, 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"];
@@ -7018,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);
@@ -7031,8 +7651,8 @@ function readLocalSkillsVersion(baseUrl) {
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync5(dirname7(path), { recursive: true });
-  writeFileSync6(path, `${version}
+  mkdirSync4(dirname7(path), { recursive: true });
+  writeFileSync7(path, `${version}
 `, "utf-8");
 }
 async function fetchSkillsUpdate(baseUrl, localVersion) {
@@ -7063,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,
@@ -7077,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
     });
@@ -7087,37 +7756,111 @@ 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
+var cliTraceStartedAt = Date.now();
+function isTruthyEnv(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function isCliTraceEnabled() {
+  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
+}
+function recordCliTrace(event) {
+  if (!isCliTraceEnabled()) {
+    return;
+  }
+  const now = Date.now();
+  const payload = {
+    ts: now,
+    source: "cli",
+    sinceStartMs: now - cliTraceStartedAt,
+    ...event
+  };
+  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
+`);
+}
+async function traceCliSpan(phase, fields, run) {
+  if (!isCliTraceEnabled()) {
+    return run();
+  }
+  const startedAt = Date.now();
+  try {
+    const result = await run();
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: true,
+      ...fields
+    });
+    return result;
+  } catch (error) {
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ...fields
+    });
+    throw error;
+  }
 }
 
 // src/cli/index.ts
@@ -7141,7 +7884,7 @@ async function main() {
   if (printStartupPhase) {
     progress?.phase("loading deepline cli");
   }
-  const program = new Command2();
+  const program = new Command();
   program.name("deepline").description("Deepline CLI (TypeScript SDK)").version(SDK_VERSION, "-v, --version", "Show version").showHelpAfterError().showSuggestionAfterError(true).addHelpText(
     "after",
     `
@@ -7231,4 +7974,3 @@ Output:
   process.exit(process.exitCode ?? 0);
 }
 main();
-//# sourceMappingURL=index.mjs.map