deepline 0.1.10 → 0.1.12

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";
@@ -169,7 +169,7 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.10";
+var SDK_VERSION = "0.1.12";
 var SDK_API_CONTRACT = "2026-04-plays-v1";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
@@ -444,6 +444,9 @@ function sleep(ms) {
 
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+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 : "";
@@ -496,12 +499,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 +531,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,
@@ -579,50 +599,14 @@ var DeeplineClient = class {
     );
   }
   /**
-   * Execute a tool and return the extracted result.
+   * Execute a tool and return the standard execution envelope.
    *
-   * 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", ... }
-   * ```
+   * 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 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.
-   *
-   * 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);
-   * ```
-   */
-  async executeToolRaw(toolId, input) {
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       { payload: input }
@@ -1953,18 +1937,61 @@ 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;
 }
@@ -1988,12 +2015,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 +2028,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 +2040,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 +2060,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
     };
@@ -2079,13 +2115,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 +2151,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]);
@@ -2134,14 +2170,15 @@ function compactCell(value) {
   return compactScalar(parsed, 120);
 }
 function buildDatasetStats(rows, totalRows = rows.length, columns = inferColumns(rows)) {
+  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) {
@@ -2193,10 +2230,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 +2529,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";
@@ -2579,6 +2618,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");
 }
@@ -2773,6 +2820,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 {
@@ -3204,11 +3274,20 @@ function getBundleSizeError(filePath, bundledCode, artifactKind) {
   }
   return null;
 }
-async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter) {
+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 +3315,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 +3389,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(
@@ -3365,7 +3450,7 @@ workers-harness:${harnessFingerprint}`
         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 +3460,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
 `;
@@ -3758,7 +3844,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 ? SDK_ENTRY_FILE : existsSync3(SDK_TYPES_ENTRY_FILE) ? SDK_TYPES_ENTRY_FILE : SDK_ENTRY_FILE,
     sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
     workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
     workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
@@ -3769,6 +3855,7 @@ function createSdkPlayBundlingAdapter() {
 async function bundlePlayFile2(filePath, options = {}) {
   return bundlePlayFile(filePath, {
     target: options.target ?? defaultPlayBundleTarget(),
+    exportName: options.exportName,
     adapter: createSdkPlayBundlingAdapter()
   });
 }
@@ -3918,54 +4005,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 +4052,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;
@@ -4139,7 +4117,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 +4137,133 @@ 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 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 {
@@ -4564,24 +4672,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 +4716,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;
       }
     }
@@ -4908,7 +4994,6 @@ 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}`
   };
 }
@@ -4932,12 +5017,26 @@ function compactPlayStatus(status, options) {
     ...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
+    )
+  };
+}
 function formatDatasetStatsLines(datasetStats) {
   if (!datasetStats) {
     return [];
@@ -4947,10 +5046,10 @@ 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)}` : "";
     lines.push(
-      `    ${column}: ${stat3.non_empty}, unique=${stat3.unique}${topValues}${sample}`
+      `    ${column}: non_empty=${stat3.non_empty}, unique=${stat3.unique}${topValues}${sample}`
     );
   }
   return lines;
@@ -4959,7 +5058,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)
       )}
 `
     );
@@ -5108,10 +5207,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 +5230,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 +5279,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 +5321,6 @@ ${usage}`);
   }
   return {
     target: filePath ? { kind: "file", path: filePath } : { kind: "name", name: playName },
-    csvPath,
     input,
     revisionId,
     revisionSelector,
@@ -5297,34 +5395,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 +5411,58 @@ 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 stagedFileInputs = await stageFileInputArgs({
+    client,
+    runtimeInput,
+    bindings: fileInputBindingsFromStaticPipeline(
+      requireCompilerManifest(bundleResult).staticPipeline
+    ),
+    progress
   });
   const startRequest = {
     name: playName,
     sourceCode: bundleResult.sourceCode,
     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 +5470,7 @@ async function handleFileBackedRun(options) {
     playName,
     status: started.status,
     statusUrl: started.statusUrl,
-    dashboardUrl,
+    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
     jsonOutput: options.jsonOutput,
     progress
   });
@@ -5449,9 +5496,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 +5505,22 @@ 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 stagedFileInputs = await stageFileInputArgs({
+    client,
+    runtimeInput,
+    bindings: [
+      ...fileInputBindingsFromPlaySchema(playDetail.play.inputSchema),
+      ...fileInputBindingsFromStaticPipeline(playDetail.play.staticPipeline)
+    ],
+    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 +5534,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 +5545,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 +5556,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
   });
@@ -5743,8 +5775,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 +5788,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 +5828,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"}`
@@ -5961,6 +5998,20 @@ 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}`);
 }
 async function handlePlaySearch(args) {
@@ -6100,6 +6151,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 +6223,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 +6248,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 +6273,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 +6288,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"] : [],
@@ -6251,7 +6351,7 @@ Examples:
       ...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) => {
+  play.command("status").description("Show status for a play run.").option("--run-id <runId>", "Run id to inspect").option("--name <name>", "Inspect the latest run for a named play").option("--json", "Emit JSON output").option("--full", "Debug only: with --json, emit the raw status payload").action(async (options) => {
     process.exitCode = await handlePlayStatus([
       ...options.runId ? ["--run-id", options.runId] : [],
       ...options.name ? ["--name", options.name] : [],
@@ -6282,6 +6382,13 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
+  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 and export play runs.").addHelpText(
     "after",
     `
@@ -6291,7 +6398,7 @@ Examples:
   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) => {
+  runs.command("status <runId>").description("Show compact status for a play run.").option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--full", "Debug only: with --json, emit the raw status payload").action(async (runId, options) => {
     process.exitCode = await handleRunStatus([
       runId,
       ...options.json ? ["--json"] : [],
@@ -6315,7 +6422,7 @@ Examples:
 }
 
 // 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 +6500,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) {
@@ -6646,7 +6753,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 +6798,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 +6885,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 +6917,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 +6938,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 +6965,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 {};
 }
@@ -6949,7 +7056,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 ?? []
   });
@@ -7005,7 +7112,7 @@ async function executeTool(args) {
 
 // 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 { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname7, join as join8 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
@@ -7031,7 +7138,7 @@ function readLocalSkillsVersion(baseUrl) {
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync5(dirname7(path), { recursive: true });
+  mkdirSync4(dirname7(path), { recursive: true });
   writeFileSync6(path, `${version}
 `, "utf-8");
 }
@@ -7120,6 +7227,54 @@ async function syncSdkSkillsIfNeeded(baseUrl) {
   progress?.writeLine("SDK skills are up to date.") ?? process.stderr.write("SDK skills are up to date.\n");
 }
 
+// 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
 function shouldPrintStartupPhase() {
   if (process.argv.includes("--json")) {
@@ -7141,7 +7296,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",
     `