deepline 0.1.93 → 0.1.94

package/dist/cli/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile5 } from "fs/promises";
-import { join as join13 } from "path";
+import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { join as join14 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 import { Command as Command3 } from "commander";
 
@@ -206,10 +206,10 @@ import { join as join2 } from "path";
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.93",
+  version: "0.1.94",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.93",
+    latest: "0.1.94",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -561,7 +561,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 
 // src/stream-reconnect.ts
@@ -1177,7 +1177,7 @@ async function* observeRunEvents(options) {
   const logPageQuery = convexServer.makeFunctionReference(
     OBSERVER_LOG_PAGE_QUERY
   );
-  const client = new convexBrowser.ConvexClient(grant.convexUrl, {
+  const client2 = new convexBrowser.ConvexClient(grant.convexUrl, {
     ...webSocketConstructor ? { webSocketConstructor } : {},
     unsavedChangesWarning: false
   });
@@ -1189,7 +1189,7 @@ async function* observeRunEvents(options) {
     wake = null;
   };
   let lastForcedRefreshAt = 0;
-  client.setAuth(async ({ forceRefreshToken }) => {
+  client2.setAuth(async ({ forceRefreshToken }) => {
     const now = Date.now();
     if (!forceRefreshToken && grant.expiresAt - now > GRANT_REFRESH_MARGIN_MS) {
       return grant.token;
@@ -1216,7 +1216,7 @@ async function* observeRunEvents(options) {
       return null;
     }
   });
-  const unsubscribe = client.onUpdate(
+  const unsubscribe = client2.onUpdate(
     snapshotQuery,
     { workflowId: runId },
     (run) => push({ kind: "run", run: run ?? null }),
@@ -1230,7 +1230,7 @@ async function* observeRunEvents(options) {
   const watchdog = setInterval(() => {
     const now = Date.now();
     try {
-      const connectionState = client.connectionState();
+      const connectionState = client2.connectionState();
       if (connectionState.isWebSocketConnected) {
         disconnectedSince = null;
         warnedReconnecting = false;
@@ -1268,14 +1268,14 @@ async function* observeRunEvents(options) {
   try {
     for (; ; ) {
       if (queue.length === 0) {
-        const waitForItem = new Promise((resolve14) => {
-          wake = resolve14;
+        const waitForItem = new Promise((resolve15) => {
+          wake = resolve15;
         });
         if (!sawFirstSnapshot) {
           const timedOut = await Promise.race([
             waitForItem.then(() => false),
             new Promise(
-              (resolve14) => setTimeout(() => resolve14(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
+              (resolve15) => setTimeout(() => resolve15(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
             )
           ]);
           if (timedOut && queue.length === 0) {
@@ -1311,7 +1311,7 @@ async function* observeRunEvents(options) {
       const gap = resolvePlayRunLogGap(snapshot, diffState.lastLogSeq);
       if (gap && diffState.lastLogSeq > 0) {
         const backfilled = await backfillLogGap({
-          queryLogPage: (afterSeq, limit) => client.query(logPageQuery, {
+          queryLogPage: (afterSeq, limit) => client2.query(logPageQuery, {
             workflowId: runId,
             afterSeq,
             limit
@@ -1361,7 +1361,7 @@ async function* observeRunEvents(options) {
       unsubscribe();
     } catch {
     }
-    await client.close().catch(() => void 0);
+    await client2.close().catch(() => void 0);
   }
 }
 
@@ -1372,7 +1372,7 @@ var EXECUTE_RESPONSE_CONTRACT_HEADER = "x-deepline-execute-response-contract";
 var V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-response";
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 function sleep2(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -2275,6 +2275,93 @@ var DeeplineClient = class {
     );
     return response.runs ?? [];
   }
+  // ---------------------------------------------------------------------------
+  // Legacy workflows (double-shipped). Thin pass-throughs over the live cloud
+  // `/api/v2/workflows/*` API so the SDK CLI keeps existing cloud workflows
+  // working while users migrate them to plays via `workflows transform`. Kept
+  // intentionally minimal — workflows are a deprecated surface.
+  // ---------------------------------------------------------------------------
+  /** List the org's workflows. `GET /api/v2/workflows`. */
+  async listWorkflows(options) {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === "number") {
+      params.set("limit", String(options.limit));
+    }
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return this.http.get(`/api/v2/workflows${query}`);
+  }
+  /**
+   * Fetch a single workflow (including its published-revision config — the
+   * input to `compileWorkflowConfigToPlay`). `GET /api/v2/workflows/:id`.
+   */
+  async getWorkflow(id) {
+    return this.http.get(`/api/v2/workflows/${encodeURIComponent(id)}`);
+  }
+  /** Delete a workflow. `DELETE /api/v2/workflows/:id`. */
+  async deleteWorkflow(id) {
+    return this.http.delete(`/api/v2/workflows/${encodeURIComponent(id)}`);
+  }
+  /** Turn a workflow off. `POST /api/v2/workflows/:id/disable`. */
+  async disableWorkflow(id) {
+    return this.http.post(
+      `/api/v2/workflows/${encodeURIComponent(id)}/disable`,
+      {}
+    );
+  }
+  /** Turn a workflow back on. `POST /api/v2/workflows/:id/enable`. */
+  async enableWorkflow(id) {
+    return this.http.post(
+      `/api/v2/workflows/${encodeURIComponent(id)}/enable`,
+      {}
+    );
+  }
+  /** Create/update a workflow from config. `POST /api/v2/workflows/apply`. */
+  async applyWorkflow(body) {
+    return this.http.post("/api/v2/workflows/apply", body);
+  }
+  /** Validate a workflow config without saving. `POST /api/v2/workflows/lint`. */
+  async lintWorkflow(body) {
+    return this.http.post("/api/v2/workflows/lint", body);
+  }
+  /** Fetch live workflow request schemas. `GET /api/v2/workflows/schema`. */
+  async getWorkflowSchema(subject) {
+    const params = new URLSearchParams();
+    if (subject) params.set("subject", subject);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return this.http.get(`/api/v2/workflows/schema${query}`);
+  }
+  /** Queue a workflow run. `POST /api/v2/workflows/call`. */
+  async callWorkflow(body) {
+    return this.http.post("/api/v2/workflows/call", body);
+  }
+  /** List a workflow's runs. `GET /api/v2/workflows/:id/runs`. */
+  async listWorkflowRuns(id, options) {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === "number") {
+      params.set("limit", String(options.limit));
+    }
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return this.http.get(
+      `/api/v2/workflows/${encodeURIComponent(id)}/runs${query}`
+    );
+  }
+  /** Fetch one workflow run. `GET /api/v2/workflows/:id/runs/:runId`. */
+  async getWorkflowRun(id, runId) {
+    return this.http.get(
+      `/api/v2/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(
+        runId
+      )}`
+    );
+  }
+  /** Cancel a workflow run. `POST /api/v2/workflows/:id/runs/:runId/cancel`. */
+  async cancelWorkflowRun(id, runId) {
+    return this.http.post(
+      `/api/v2/workflows/${encodeURIComponent(id)}/runs/${encodeURIComponent(
+        runId
+      )}/cancel`,
+      {}
+    );
+  }
   /**
    * Get a run by id using the public runs resource model.
    *
@@ -3174,6 +3261,9 @@ function openInBrowser(url) {
   } catch {
   }
 }
+function sleep3(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
 function collectLocalEnvInfo() {
   return {
     os: `${process.platform} ${process.arch}`,
@@ -3211,14 +3301,38 @@ function parseMaybeJsonObject(value) {
     return value;
   }
 }
+function failureMessageFromRecord(value) {
+  const status = typeof value.status === "string" ? value.status.trim().toLowerCase() : "";
+  const directError = typeof value.error === "string" ? value.error.trim() : typeof value.last_error === "string" ? value.last_error.trim() : "";
+  const result = value.result && typeof value.result === "object" && !Array.isArray(value.result) ? value.result : null;
+  const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
+  if (!directError && !resultError && status !== "error" && status !== "failed") {
+    return null;
+  }
+  return directError || resultError || `Column status: ${status}`;
+}
 function flattenObjectColumns(row) {
   const flattened = {};
   for (const [key, rawValue] of Object.entries(row)) {
     const value = parseMaybeJsonObject(rawValue);
+    if (key === "_metadata") {
+      flattened[key] = value && typeof value === "object" ? JSON.stringify(value) : value;
+      continue;
+    }
     if (value && typeof value === "object" && !Array.isArray(value)) {
-      for (const [nestedKey, nestedValue] of Object.entries(
-        value
-      )) {
+      const record = value;
+      const hasMatchedEnvelope = Object.prototype.hasOwnProperty.call(record, "matched_result") || Object.prototype.hasOwnProperty.call(record, "matchedResult");
+      if (hasMatchedEnvelope) {
+        flattened[key] = JSON.stringify(record);
+      } else {
+        const failureMessage = failureMessageFromRecord(record);
+        if (failureMessage) {
+          flattened[key] = failureMessage;
+        } else if (Object.prototype.hasOwnProperty.call(record, "result")) {
+          flattened[key] = JSON.stringify(record);
+        }
+      }
+      for (const [nestedKey, nestedValue] of Object.entries(record)) {
         flattened[`${key}.${nestedKey}`] = nestedValue && typeof nestedValue === "object" ? JSON.stringify(nestedValue) : nestedValue;
       }
       continue;
@@ -3474,8 +3588,8 @@ function buildCandidateUrls2(url) {
     return [url];
   }
 }
-function sleep3(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+function sleep4(ms) {
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -3578,7 +3692,7 @@ async function handleRegister(args) {
       return EXIT_AUTH;
     }
     if (s >= 500 || s === 0 || s === 400) {
-      await sleep3(2e3);
+      await sleep4(2e3);
       continue;
     }
     if (s >= 400) {
@@ -3608,7 +3722,7 @@ async function handleRegister(args) {
       );
       return EXIT_AUTH;
     }
-    await sleep3(2e3);
+    await sleep4(2e3);
   }
 }
 async function handleWait(args) {
@@ -3645,7 +3759,7 @@ async function handleWait(args) {
       return EXIT_AUTH;
     }
     if (status >= 500 || status === 0 || status === 400) {
-      await sleep3(2e3);
+      await sleep4(2e3);
       continue;
     }
     if (status >= 400) {
@@ -3673,7 +3787,7 @@ async function handleWait(args) {
       console.error("That approval link expired. Run: deepline auth register");
       return EXIT_AUTH;
     }
-    await sleep3(2e3);
+    await sleep4(2e3);
   }
   console.error(
     "Still pending. Approve the browser link, then run: deepline auth wait"
@@ -4489,6 +4603,9 @@ function isRecord3(value) {
 function isSerializedDataset(value) {
   return isRecord3(value) && value.kind === "dataset" && typeof value.count === "number" && Array.isArray(value.preview);
 }
+function isPackagedDatasetOutput(value) {
+  return isRecord3(value) && value.kind === "dataset" && isRecord3(value.preview) && Array.isArray(value.preview.rows);
+}
 function pathParts(path) {
   return path.split(".").map((part) => part.trim()).filter(Boolean);
 }
@@ -4536,6 +4653,12 @@ function inferColumns(rows) {
   }
   return columns;
 }
+function columnsFromDatasetSummary(summary) {
+  if (!isRecord3(summary) || !isRecord3(summary.columnStats)) {
+    return [];
+  }
+  return Object.keys(summary.columnStats).filter((column) => column);
+}
 function canonicalRowsInfoFromCandidate(input2) {
   const candidate = input2;
   if (isSerializedDataset(candidate.value)) {
@@ -4558,6 +4681,28 @@ function canonicalRowsInfoFromCandidate(input2) {
       tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null
     };
   }
+  if (isPackagedDatasetOutput(candidate.value)) {
+    const rawRows = rowArray(candidate.value.preview?.rows) ?? [];
+    const totalRows2 = readNumber(candidate.value.preview?.totalRows) ?? readNumber(candidate.value.rowCount) ?? rawRows.length;
+    const explicitColumns = Array.isArray(candidate.value.columns) ? candidate.value.columns.filter(
+      (column) => typeof column === "string"
+    ) : [];
+    const rawColumns = explicitColumns.length > 0 ? explicitColumns : columnsFromDatasetSummary(candidate.value.summary);
+    const { rows: rows2, columns } = sanitizeCsvProjectionInfo({
+      rows: rawRows,
+      columns: rawColumns.length > 0 ? rawColumns : inferColumns(rawRows)
+    });
+    return {
+      rows: rows2,
+      totalRows: totalRows2,
+      columns,
+      columnsExplicit: rawColumns.length > 0,
+      complete: rows2.length === totalRows2,
+      source: candidate.source,
+      datasetId: typeof candidate.value.datasetId === "string" ? candidate.value.datasetId : null,
+      tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null
+    };
+  }
   if (candidate.serializedOnly) {
     return null;
   }
@@ -4590,6 +4735,14 @@ function collectDatasetCandidates(input2) {
     });
     return;
   }
+  if (isPackagedDatasetOutput(input2.value)) {
+    input2.output.push({
+      source: input2.path,
+      value: input2.value,
+      total: input2.total
+    });
+    return;
+  }
   if (!isRecord3(input2.value)) {
     return;
   }
@@ -4662,6 +4815,19 @@ function collectCanonicalRowsInfos(statusOrResult) {
       }
     );
   }
+  if (Array.isArray(result.steps)) {
+    result.steps.forEach((step, index) => {
+      if (!isRecord3(step) || !isRecord3(step.output)) {
+        return;
+      }
+      const source = typeof step.output.path === "string" ? step.output.path : typeof step.id === "string" ? `steps.${step.id}.output` : `steps.${index}.output`;
+      candidates.push({
+        source,
+        value: step.output,
+        total: step.output.rowCount ?? (isRecord3(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord3(step.progress) ? step.progress.total : void 0)
+      });
+    });
+  }
   collectDatasetCandidates({
     value: result,
     path: "result",
@@ -4671,12 +4837,14 @@ function collectCanonicalRowsInfos(statusOrResult) {
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
-    if (seen.has(candidate.source)) {
-      continue;
-    }
-    seen.add(candidate.source);
     const info = canonicalRowsInfoFromCandidate(candidate);
     if (info) {
+      if (info.source) {
+        if (seen.has(info.source)) {
+          continue;
+        }
+        seen.add(info.source);
+      }
       infos.push(info);
     }
   }
@@ -4697,15 +4865,17 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
-    if (seen.has(candidate.source)) {
-      continue;
-    }
-    seen.add(candidate.source);
     const info = canonicalRowsInfoFromCandidate({
       ...candidate,
       serializedOnly: true
     });
     if (info) {
+      if (info.source) {
+        if (seen.has(info.source)) {
+          continue;
+        }
+        seen.add(info.source);
+      }
       infos.push(info);
     }
   }
@@ -5215,10 +5385,10 @@ async function handleDbQuery(args) {
   }
   const jsonOutput = argsWantJson(args);
   const explicitJsonOutput = args.includes("--json");
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   let result;
   try {
-    result = await client.queryCustomerDb({ sql, maxRows });
+    result = await client2.queryCustomerDb({ sql, maxRows });
   } catch (error) {
     console.error(formatDbQueryError(sql, error));
     return 1;
@@ -5372,7 +5542,14 @@ Examples:
 }
 
 // src/cli/commands/enrich.ts
-import { mkdtemp, readFile as readFile3, rm, stat as stat3, writeFile as writeFile4 } from "fs/promises";
+import {
+  mkdir as mkdir4,
+  mkdtemp,
+  readFile as readFile3,
+  rm,
+  stat as stat3,
+  writeFile as writeFile4
+} from "fs/promises";
 import { homedir as homedir4, tmpdir as tmpdir3 } from "os";
 import { join as join8, resolve as resolve11 } from "path";
 
@@ -5474,23 +5651,28 @@ function shannonEntropy(value) {
     return entropy - p * Math.log2(p);
   }, 0);
 }
-function validatePlaySourceHasNoInlineSecrets(input2) {
+function collectInlineSecretFindings(sourceCode) {
   const findings = [];
-  for (const match of input2.sourceCode.matchAll(SECRET_ENV_PATTERN)) {
+  for (const match of sourceCode.matchAll(SECRET_ENV_PATTERN)) {
     findings.push(`process.env.${match[1]}`);
   }
-  if (PRIVATE_KEY_PATTERN.test(input2.sourceCode)) findings.push("private key block");
-  if (BEARER_LITERAL_PATTERN.test(input2.sourceCode)) findings.push("bearer token literal");
-  if (ASSIGNMENT_SECRET_LITERAL_PATTERN.test(input2.sourceCode)) {
+  if (PRIVATE_KEY_PATTERN.test(sourceCode)) findings.push("private key block");
+  if (BEARER_LITERAL_PATTERN.test(sourceCode))
+    findings.push("bearer token literal");
+  if (ASSIGNMENT_SECRET_LITERAL_PATTERN.test(sourceCode)) {
     findings.push("secret-looking assignment literal");
   }
-  for (const match of input2.sourceCode.matchAll(HIGH_ENTROPY_LITERAL_PATTERN)) {
+  for (const match of sourceCode.matchAll(HIGH_ENTROPY_LITERAL_PATTERN)) {
     const literal = match[1] ?? "";
     if (literal.length >= 40 && shannonEntropy(literal) >= 4.2) {
       findings.push("high-entropy string literal");
       break;
     }
   }
+  return [...new Set(findings)];
+}
+function validatePlaySourceHasNoInlineSecrets(input2) {
+  const findings = collectInlineSecretFindings(input2.sourceCode);
   if (!findings.length) return;
   throw new Error(
     [
@@ -8438,13 +8620,13 @@ export default definePlay(${jsString(input2.options.name)}, async (ctx, input: I
 
 `;
 }
-async function describePlayMaybe(client, playRef) {
-  return playRef ? client.describePlay(playRef, { compact: true }) : null;
+async function describePlayMaybe(client2, playRef) {
+  return playRef ? client2.describePlay(playRef, { compact: true }) : null;
 }
-function loadTools(client, providers) {
-  return Promise.all(providers.map((provider) => client.getTool(provider)));
+function loadTools(client2, providers) {
+  return Promise.all(providers.map((provider) => client2.getTool(provider)));
 }
-async function loadBootstrapContracts(client, options) {
+async function loadBootstrapContracts(client2, options) {
   const [
     sourceTools,
     sourcePlay,
@@ -8454,13 +8636,13 @@ async function loadBootstrapContracts(client, options) {
     emailTools,
     phoneTools
   ] = await Promise.all([
-    loadTools(client, sourceProviders(options)),
-    describePlayMaybe(client, sourcePlayRef(options)),
-    describePlayMaybe(client, stagePlayRef(options.people)),
-    describePlayMaybe(client, stagePlayRef(options.email)),
-    describePlayMaybe(client, stagePlayRef(options.phone)),
-    loadTools(client, stageProviders(options.email)),
-    loadTools(client, stageProviders(options.phone))
+    loadTools(client2, sourceProviders(options)),
+    describePlayMaybe(client2, sourcePlayRef(options)),
+    describePlayMaybe(client2, stagePlayRef(options.people)),
+    describePlayMaybe(client2, stagePlayRef(options.email)),
+    describePlayMaybe(client2, stagePlayRef(options.phone)),
+    loadTools(client2, stageProviders(options.email)),
+    loadTools(client2, stageProviders(options.phone))
   ]);
   const contracts = {
     sourceTools,
@@ -8509,8 +8691,8 @@ function renderPlayBootstrapError(error) {
 }
 async function runPlayBootstrap(args) {
   const options = parsePlayBootstrapOptions(args);
-  const client = new DeeplineClient();
-  const contracts = await loadBootstrapContracts(client, options);
+  const client2 = new DeeplineClient();
+  const contracts = await loadBootstrapContracts(client2, options);
   const csvContext = loadCsvContext(options.from);
   const source = generateBootstrapPlaySource({
     options,
@@ -8916,8 +9098,8 @@ function traceCliSync(phase, fields, run) {
     throw error;
   }
 }
-function sleep4(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+function sleep5(ms) {
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -8939,9 +9121,9 @@ function buildBarePrebuiltReferenceError(input2) {
     `Prebuilt play "${input2.requested}" must be referenced as "${input2.reference}". Use the prebuilt/ namespace anywhere you run, describe, get, or link to Deepline-managed plays.`
   );
 }
-async function assertCanonicalNamedPlayReference(client, target) {
+async function assertCanonicalNamedPlayReference(client2, target) {
   const parsed = parseReferencedPlayTarget2(target);
-  const detail = await client.getPlay(parsed.playName);
+  const detail = await client2.getPlay(parsed.playName);
   if (detail.play.ownerType === "deepline" && !isPrebuiltReferenceTarget(target)) {
     throw buildBarePrebuiltReferenceError({
       requested: target,
@@ -9019,9 +9201,9 @@ To make your own version:
 5. Your play will then live under your workspace namespace.`
   );
 }
-async function ensureEditableRemotePlay(client, target) {
+async function ensureEditableRemotePlay(client2, target) {
   const parsed = parseReferencedPlayTarget2(target);
-  const detail = await client.getPlay(parsed.playName);
+  const detail = await client2.getPlay(parsed.playName);
   if (detail.play.ownerType === "deepline") {
     throw buildReadonlyPrebuiltPlayError(formatPlayReference(detail.play));
   }
@@ -9300,7 +9482,7 @@ async function collectBundledPlayGraph(entryFile, profile = null) {
   const root = await visit(entryFile);
   return { root, nodes };
 }
-async function compileBundledPlayGraphManifests(client, graph) {
+async function compileBundledPlayGraphManifests(client2, graph) {
   const compiling = /* @__PURE__ */ new Map();
   const compileNode = (node) => {
     const existing = compiling.get(node.filePath);
@@ -9316,7 +9498,7 @@ async function compileBundledPlayGraphManifests(client, graph) {
         await compileNode(child);
       }
       const name = node.playName ?? extractPlayName(node.sourceCode, node.filePath);
-      node.compilerManifest = await client.compilePlayManifest({
+      node.compilerManifest = await client2.compilePlayManifest({
         name,
         sourceCode: node.sourceCode,
         sourceFiles: node.sourceFiles,
@@ -9350,7 +9532,7 @@ function requireCompilerManifest(node) {
   }
   return node.compilerManifest;
 }
-async function publishImportedPlayDependencies(client, graph) {
+async function publishImportedPlayDependencies(client2, graph) {
   const published = /* @__PURE__ */ new Set();
   const publishNode = async (filePath, skipPublish) => {
     const absolutePath = normalizePlayPath(filePath);
@@ -9369,7 +9551,7 @@ async function publishImportedPlayDependencies(client, graph) {
         `Imported play ${absolutePath} must export definePlay(...) so it can be published for runtime composition.`
       );
     }
-    await client.registerPlayArtifact({
+    await client2.registerPlayArtifact({
       name: node.playName,
       sourceCode: node.sourceCode,
       sourceFiles: node.sourceFiles,
@@ -9945,7 +10127,7 @@ async function waitForPlayCompletionByStream(input2) {
       reason
     });
     const remainingBeforeSleep = remainingWaitMs();
-    await sleep4(
+    await sleep5(
       remainingBeforeSleep === null ? delayMs : Math.min(delayMs, Math.max(1, remainingBeforeSleep))
     );
   }
@@ -9970,7 +10152,7 @@ async function startAndWaitForPlayCompletionByStream(input2) {
       attempt: attempt + 1,
       reason: playStatusErrorText(status)
     });
-    await sleep4(retryDelayMs);
+    await sleep5(retryDelayMs);
   }
   throw new DeeplineError(
     `Play ${input2.playName} did not start after retrying transient start failures.`,
@@ -11019,7 +11201,7 @@ async function resolvePlayRunOutputStatus(input2) {
     full: input2.fullJson
   });
   for (let attempt = 0; attempt < 3 && streamedTextPackageIncomplete && refreshedStatus.status === "completed" && playRunPackageStepCount(getPlayRunPackage(refreshedStatus)) === 0; attempt += 1) {
-    await sleep4(250);
+    await sleep5(250);
     refreshedStatus = await input2.client.getPlayStatus(runId, {
       billing: false,
       full: input2.fullJson
@@ -11142,7 +11324,7 @@ async function fetchBackingDatasetRows(input2) {
     source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
   };
 }
-async function exportPlayStatusRows(client, status, outPath, options = {}) {
+async function exportPlayStatusRows(client2, status, outPath, options = {}) {
   if (!outPath) {
     return null;
   }
@@ -11177,7 +11359,7 @@ async function exportPlayStatusRows(client, status, outPath, options = {}) {
     let fetchedRowsInfo = null;
     try {
       fetchedRowsInfo = await fetchBackingDatasetRows({
-        client,
+        client: client2,
         status,
         rowsInfo
       });
@@ -11196,7 +11378,7 @@ async function exportPlayStatusRows(client, status, outPath, options = {}) {
       return { path: writeCanonicalRowsCsv(rowsInfo, outPath), rowsInfo };
     }
     if (attempt < attempts && retryDelayMs > 0) {
-      await sleep4(retryDelayMs);
+      await sleep5(retryDelayMs);
     }
   }
   if (!rowsInfo.complete) {
@@ -11714,12 +11896,12 @@ function toolGetterHintFromMetadata(toolId, tool) {
     raw: checkHintExpression(toolResponse.raw) || "result.toolResponse.raw"
   };
 }
-async function buildToolGetterHints(client, staticPipeline) {
+async function buildToolGetterHints(client2, staticPipeline) {
   const toolIds = collectStaticPipelineToolIds(staticPipeline);
   return Promise.all(
     toolIds.map(async (toolId) => {
       try {
-        const tool = await client.getTool(toolId);
+        const tool = await client2.getTool(toolId);
         return toolGetterHintFromMetadata(toolId, tool);
       } catch (error) {
         return {
@@ -11759,10 +11941,10 @@ function printToolGetterHints(hints) {
 async function handlePlayCheck(args) {
   const options = parsePlayCheckOptions(args);
   if (!isFileTarget(options.target)) {
-    const client2 = new DeeplineClient();
+    const client3 = new DeeplineClient();
     try {
-      await assertCanonicalNamedPlayReference(client2, options.target);
-      const play = await client2.describePlay(
+      await assertCanonicalNamedPlayReference(client3, options.target);
+      const play = await client3.describePlay(
         parseReferencedPlayTarget2(options.target).playName,
         { compact: true }
       );
@@ -11844,8 +12026,8 @@ async function handlePlayCheck(args) {
     }
     return 0;
   }
-  const client = new DeeplineClient();
-  const result = await client.checkPlayArtifact({
+  const client2 = new DeeplineClient();
+  const result = await client2.checkPlayArtifact({
     name: playName,
     sourceCode: graph.root.sourceCode,
     sourceFiles: graph.root.sourceFiles,
@@ -11857,7 +12039,7 @@ async function handlePlayCheck(args) {
       errors: result.errors,
       sourceCode: graph.root.sourceCode
     }),
-    toolGetterHints: result.toolGetterHints ?? await buildToolGetterHints(client, result.staticPipeline)
+    toolGetterHints: result.toolGetterHints ?? await buildToolGetterHints(client2, result.staticPipeline)
   };
   if (options.jsonOutput) {
     process.stdout.write(
@@ -11883,7 +12065,7 @@ async function handleFileBackedRun(options) {
   if (options.target.kind !== "file") {
     throw new Error("Expected a file-backed play run target.");
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = resolve10(options.target.path);
   progress.phase("compiling play");
@@ -11903,7 +12085,7 @@ async function handleFileBackedRun(options) {
     await traceCliSpan(
       "cli.play_file_compile_manifests",
       { targetKind: "file" },
-      () => compileBundledPlayGraphManifests(client, graph)
+      () => compileBundledPlayGraphManifests(client2, graph)
     );
     progress.phase("compiled play");
   } catch (error) {
@@ -11921,7 +12103,7 @@ async function handleFileBackedRun(options) {
     await traceCliSpan(
       "cli.play_file_publish_imports",
       { targetKind: "file" },
-      () => publishImportedPlayDependencies(client, graph)
+      () => publishImportedPlayDependencies(client2, graph)
     );
   } catch (error) {
     progress.fail();
@@ -11942,7 +12124,7 @@ async function handleFileBackedRun(options) {
       bindingCount: fileInputBindings.length
     },
     () => stageFileInputArgs({
-      client,
+      client: client2,
       runtimeInput,
       bindings: fileInputBindings,
       progress
@@ -11967,7 +12149,7 @@ async function handleFileBackedRun(options) {
       "cli.play_start_watch",
       { targetKind: "file", playName },
       () => startAndWaitForPlayCompletionByStream({
-        client,
+        client: client2,
         request: startRequest,
         playName,
         jsonOutput: options.jsonOutput,
@@ -11986,7 +12168,7 @@ async function handleFileBackedRun(options) {
     }
     const outputStatus = withTerminalPlayIdentity(
       await resolvePlayRunOutputStatus({
-        client,
+        client: client2,
         status: finalStatus,
         fullJson: options.fullJson,
         jsonOutput: options.jsonOutput
@@ -12006,11 +12188,11 @@ async function handleFileBackedRun(options) {
   const started = await traceCliSpan(
     "cli.play_start_unwatched",
     { targetKind: "file", playName },
-    () => client.startPlayRun(startRequest).catch((error) => {
+    () => client2.startPlayRun(startRequest).catch((error) => {
       throw normalizePlayStartError(error, playName);
     })
   );
-  const resolvedDashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
+  const resolvedDashboardUrl = buildPlayDashboardUrl(client2.baseUrl, playName);
   openPlayDashboard({
     dashboardUrl: resolvedDashboardUrl,
     noOpen: options.noOpen
@@ -12046,7 +12228,7 @@ async function handleNamedRun(options) {
   if (options.target.kind !== "name") {
     throw new Error("Expected a named play run target.");
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const playName = options.target.name;
   const runtimeInput = options.input ? { ...options.input } : {};
@@ -12059,7 +12241,7 @@ async function handleNamedRun(options) {
     return traceCliSpan(
       "cli.play_load_definition",
       { targetKind: "name", playName, skipped: false },
-      () => assertCanonicalNamedPlayReference(client, playName)
+      () => assertCanonicalNamedPlayReference(client2, playName)
     );
   })() : (recordCliTrace({
     phase: "cli.play_load_definition",
@@ -12079,7 +12261,7 @@ async function handleNamedRun(options) {
       hasExplicitRevisionId: Boolean(options.revisionId)
     },
     () => resolveNamedRunRevisionId({
-      client,
+      client: client2,
       playName,
       revisionId: options.revisionId,
       selector: options.revisionSelector
@@ -12097,7 +12279,7 @@ async function handleNamedRun(options) {
       bindingCount: fileInputBindings.length
     },
     () => stageFileInputArgs({
-      client,
+      client: client2,
       runtimeInput,
       bindings: fileInputBindings,
       progress
@@ -12118,7 +12300,7 @@ async function handleNamedRun(options) {
       "cli.play_start_watch",
       { targetKind: "name", playName },
       () => startAndWaitForPlayCompletionByStream({
-        client,
+        client: client2,
         request: startRequest,
         playName,
         jsonOutput: options.jsonOutput,
@@ -12137,7 +12319,7 @@ async function handleNamedRun(options) {
     }
     const outputStatus = withTerminalPlayIdentity(
       await resolvePlayRunOutputStatus({
-        client,
+        client: client2,
         status: finalStatus,
         fullJson: options.fullJson,
         jsonOutput: options.jsonOutput
@@ -12157,11 +12339,11 @@ async function handleNamedRun(options) {
   const started = await traceCliSpan(
     "cli.play_start_unwatched",
     { targetKind: "name", playName },
-    () => client.startPlayRun(startRequest).catch((error) => {
+    () => client2.startPlayRun(startRequest).catch((error) => {
       throw normalizePlayStartError(error, playName);
     })
   );
-  const resolvedDashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
+  const resolvedDashboardUrl = buildPlayDashboardUrl(client2.baseUrl, playName);
   openPlayDashboard({
     dashboardUrl: resolvedDashboardUrl,
     noOpen: options.noOpen
@@ -12235,8 +12417,8 @@ async function handleRunGet(args) {
     console.error(error instanceof Error ? error.message : usage);
     return 1;
   }
-  const client = new DeeplineClient();
-  const status = await client.runs.get(runId, {
+  const client2 = new DeeplineClient();
+  const status = await client2.runs.get(runId, {
     full: args.includes("--full")
   });
   writePlayResult(status, argsWantJson(args), {
@@ -12266,8 +12448,8 @@ async function handleRunsList(args) {
     console.error(usage);
     return 1;
   }
-  const client = new DeeplineClient();
-  const runs = (await client.runs.list({
+  const client2 = new DeeplineClient();
+  const runs = (await client2.runs.list({
     play: playName,
     ...statusFilter ? { status: statusFilter } : {}
   })).map((run) => ({
@@ -12320,9 +12502,9 @@ async function handleRunTail(args) {
       return 1;
     }
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   const jsonOutput = argsWantJson(args);
-  const status = await client.runs.tail(runId, {
+  const status = await client2.runs.tail(runId, {
     // Human mode only: in --json mode emit nothing non-protocol.
     onReconnect: jsonOutput ? void 0 : ({ reason }) => {
       process.stderr.write(
@@ -12355,9 +12537,9 @@ async function handleRunLogs(args) {
       outPath = resolve10(args[++index]);
     }
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   if (outPath) {
-    const result2 = await client.runs.logs(runId, { all: true });
+    const result2 = await client2.runs.logs(runId, { all: true });
     const logs = result2.entries;
     writeFileSync7(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
@@ -12386,7 +12568,7 @@ async function handleRunLogs(args) {
     );
     return 0;
   }
-  const result = await client.runs.logs(runId, { limit });
+  const result = await client2.runs.logs(runId, { limit });
   printCommandEnvelope(
     {
       runId: result.runId,
@@ -12426,8 +12608,8 @@ async function handleRunStop(args) {
       reason = args[++index];
     }
   }
-  const client = new DeeplineClient();
-  const result = await client.runs.stop(runId, { reason });
+  const client2 = new DeeplineClient();
+  const result = await client2.runs.stop(runId, { reason });
   const stopNotConfirmed = result.stopped === false || result.staleSchedulerState === true;
   if (stopNotConfirmed) {
     const detail = typeof result.error === "string" && result.error.trim() ? result.error.trim() : result.staleSchedulerState === true ? "scheduler state for the run is stale" : "the server did not confirm the stop";
@@ -12499,9 +12681,9 @@ async function handleRunExport(args) {
     console.error(usage);
     return 1;
   }
-  const client = new DeeplineClient();
-  const status = await client.getPlayStatus(runId, { full: true });
-  const exportResult = await exportPlayStatusRows(client, status, outPath, {
+  const client2 = new DeeplineClient();
+  const status = await client2.getPlayStatus(runId, { full: true });
+  const exportResult = await exportPlayStatusRows(client2, status, outPath, {
     datasetPath
   });
   const source = exportResult?.rowsInfo.source ?? datasetPath ?? null;
@@ -12554,7 +12736,7 @@ async function handlePlayGet(args) {
     );
     return 2;
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   const explicitJson = args.includes("--json");
   const sourceOutput = args.includes("--source");
   const jsonOutput = sourceOutput ? explicitJson : argsWantJson(args);
@@ -12566,7 +12748,7 @@ async function handlePlayGet(args) {
     }
   }
   const playName = isFileTarget(target) ? extractPlayName(readFileSync6(resolve10(target), "utf-8"), resolve10(target)) : parseReferencedPlayTarget2(target).playName;
-  const detail = isFileTarget(target) ? await client.getPlay(playName) : await assertCanonicalNamedPlayReference(client, target);
+  const detail = isFileTarget(target) ? await client2.getPlay(playName) : await assertCanonicalNamedPlayReference(client2, target);
   const resolvedSource = detail.play.workingRevision?.sourceCode ?? detail.play.liveRevision?.sourceCode ?? detail.play.currentRevision?.sourceCode ?? detail.play.sourceCode ?? "";
   const materializedFile = outPath ? materializeRemotePlaySource({
     target,
@@ -12646,10 +12828,10 @@ async function handlePlayVersions(args) {
     console.error("Usage: deepline play versions --name <name> [--json]");
     return 1;
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   const jsonOutput = argsWantJson(args);
-  await assertCanonicalNamedPlayReference(client, playName);
-  const versions = await client.listPlayVersions(
+  await assertCanonicalNamedPlayReference(client2, playName);
+  const versions = await client2.listPlayVersions(
     parseReferencedPlayTarget2(playName).playName
   );
   if (jsonOutput) {
@@ -12668,8 +12850,8 @@ async function handlePlayVersions(args) {
 }
 async function handlePlayList(args) {
   const jsonOutput = argsWantJson(args);
-  const client = new DeeplineClient();
-  const plays = await client.listPlays();
+  const client2 = new DeeplineClient();
+  const plays = await client2.listPlays();
   if (jsonOutput) {
     process.stdout.write(`${JSON.stringify(plays)}
 `);
@@ -12852,8 +13034,8 @@ async function handlePlaySearch(args) {
     console.error(error instanceof Error ? error.message : String(error));
     return 1;
   }
-  const client = new DeeplineClient();
-  const plays = await client.searchPlays({
+  const client2 = new DeeplineClient();
+  const plays = await client2.searchPlays({
     query: options.query,
     compact: options.compact,
     scope: options.scope
@@ -12945,8 +13127,8 @@ async function handlePlayGrep(args) {
     }
   }
   const compact = args.includes("--compact");
-  const client = new DeeplineClient();
-  const plays = (await client.listPlays({
+  const client2 = new DeeplineClient();
+  const plays = (await client2.listPlays({
     grep: query,
     grepMode: mode
   })).filter(
@@ -13003,9 +13185,9 @@ async function handlePlayDescribe(args) {
     );
     return 2;
   }
-  const client = new DeeplineClient();
-  await assertCanonicalNamedPlayReference(client, playName);
-  const play = await client.describePlay(
+  const client2 = new DeeplineClient();
+  await assertCanonicalNamedPlayReference(client2, playName);
+  const play = await client2.describePlay(
     parseReferencedPlayTarget2(playName).playName,
     {
       compact: args.includes("--compact")
@@ -13042,7 +13224,7 @@ async function handlePlayPublish(args) {
     console.error("Choose only one live target: --latest or --revision-id.");
     return 1;
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   if (isFileTarget(playName)) {
     if (revisionId || useLatest) {
       console.error(
@@ -13060,12 +13242,12 @@ async function handlePlayPublish(args) {
       await traceCliSpan(
         "cli.play_publish_compile_manifests",
         { targetKind: "file", nodeCount: graph.nodes.size },
-        () => compileBundledPlayGraphManifests(client, graph)
+        () => compileBundledPlayGraphManifests(client2, graph)
       );
       await traceCliSpan(
         "cli.play_publish_imports",
         { targetKind: "file", nodeCount: graph.nodes.size },
-        () => publishImportedPlayDependencies(client, graph)
+        () => publishImportedPlayDependencies(client2, graph)
       );
     } catch (error) {
       console.error(error instanceof Error ? error.message : String(error));
@@ -13079,7 +13261,7 @@ async function handlePlayPublish(args) {
         playName: rootPlayName,
         artifactHash: graph.root.artifact.artifactHash
       },
-      () => client.registerPlayArtifact({
+      () => client2.registerPlayArtifact({
         name: rootPlayName,
         sourceCode: graph.root.sourceCode,
         sourceFiles: graph.root.sourceFiles,
@@ -13103,7 +13285,7 @@ async function handlePlayPublish(args) {
   }
   const resolvedName = parseReferencedPlayTarget2(playName).playName;
   if (useLatest) {
-    const versions = await client.listPlayVersions(resolvedName);
+    const versions = await client2.listPlayVersions(resolvedName);
     const latest = versions[0];
     if (!latest?._id) {
       console.error(`No saved revisions found for ${resolvedName}.`);
@@ -13112,12 +13294,12 @@ async function handlePlayPublish(args) {
     revisionId = latest._id;
   }
   try {
-    await ensureEditableRemotePlay(client, resolvedName);
+    await ensureEditableRemotePlay(client2, resolvedName);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     return 1;
   }
-  const result = await client.publishPlayVersion(
+  const result = await client2.publishPlayVersion(
     resolvedName,
     revisionId ? { revisionId } : {}
   );
@@ -13138,10 +13320,10 @@ async function handlePlayDelete(args) {
     );
     return 1;
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   let detail;
   try {
-    detail = await client.getPlay(parseReferencedPlayTarget2(playName).playName);
+    detail = await client2.getPlay(parseReferencedPlayTarget2(playName).playName);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     return 1;
@@ -13152,7 +13334,7 @@ async function handlePlayDelete(args) {
     );
     return 1;
   }
-  const result = await client.deletePlay(
+  const result = await client2.deletePlay(
     parseReferencedPlayTarget2(formatPlayReference(detail.play)).playName
   );
   if (argsWantJson(args)) {
@@ -13817,11 +13999,11 @@ async function handlePlaySharePublish(args) {
     return 2;
   }
   const name = parseReferencedPlayTarget2(target).playName;
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   let revisionId = shareFlagValue(args, "--revision-id");
   let resolvedVersion;
   if (!revisionId) {
-    const versions = await client.listPlayVersions(name);
+    const versions = await client2.listPlayVersions(name);
     if (versions.length === 0) {
       console.error(
         `No saved revisions for ${name}. Run \`deepline plays set-live ${name}\` first.`
@@ -13842,7 +14024,7 @@ async function handlePlaySharePublish(args) {
     resolvedVersion = chosen.version;
   }
   if (!args.includes("--no-run-check")) {
-    const runs = await client.listRuns({ play: name });
+    const runs = await client2.listRuns({ play: name });
     const hasCompleted = runs.some(
       (r) => String(r.status).toLowerCase() === "completed"
     );
@@ -13881,7 +14063,7 @@ async function handlePlaySharePublish(args) {
     }
     return 0;
   }
-  const status = await client.publishSharePage(name, request);
+  const status = await client2.publishSharePage(name, request);
   if (argsWantJson(args)) {
     process.stdout.write(`${JSON.stringify(status)}
 `);
@@ -13929,11 +14111,11 @@ async function handlePlayShareRegenerate(args) {
     return 2;
   }
   const name = parseReferencedPlayTarget2(target).playName;
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   let revisionId = shareFlagValue(args, "--revision-id");
   const versionFlag = shareFlagValue(args, "--version");
   if (!revisionId && versionFlag) {
-    const versions = await client.listPlayVersions(name);
+    const versions = await client2.listPlayVersions(name);
     const chosen = versions.find((r) => r.version === Number(versionFlag));
     if (!chosen?._id) {
       console.error(`Version ${versionFlag} not found for ${name}.`);
@@ -13941,7 +14123,7 @@ async function handlePlayShareRegenerate(args) {
     }
     revisionId = chosen._id;
   }
-  const status = await client.regenerateSharePage(
+  const status = await client2.regenerateSharePage(
     name,
     revisionId ? { revisionId } : {}
   );
@@ -13978,52 +14160,158 @@ async function handlePlayShareUnpublish(args) {
   return 0;
 }
 
-// src/cli/enrich-play-compiler.ts
-var RESERVED_WORDS = /* @__PURE__ */ new Set([
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "export",
-  "extends",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield"
+// ../shared_libs/plays/tool-codegen.ts
+var KNOWN_GETTER_NAMES = /* @__PURE__ */ new Set([
+  "company_domain",
+  "company_linkedin_url",
+  "company_name",
+  "domain",
+  "email",
+  "email_status",
+  "first_name",
+  "full_name",
+  "job_change",
+  "job_change_status",
+  "job_changed",
+  "last_name",
+  "linkedin",
+  "personal_email",
+  "phone",
+  "phone_status",
+  "status",
+  "title"
 ]);
+function renderToolCodegenString(value) {
+  return JSON.stringify(value);
+}
+function renderToolRowPathExpression(path, rowName = "row") {
+  const parts = String(path || "").replace(/\[(\d+)\]/g, ".$1").split(".").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) return rowName;
+  return parts.reduce((expr, part, index) => {
+    if (index === 0) return `${rowName}[${renderToolCodegenString(part)}]`;
+    return `(${expr} as Record<string, unknown> | null | undefined)?.[${renderToolCodegenString(part)}]`;
+  }, rowName);
+}
+function renderToolPayloadExpression(value, rowName = "row") {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => renderToolPayloadExpression(entry, rowName)).join(", ")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([left], [right]) => left.localeCompare(right)
+    );
+    return `{ ${entries.map(
+      ([key, entry]) => `${renderToolCodegenString(key)}: ${renderToolPayloadExpression(entry, rowName)}`
+    ).join(", ")} }`;
+  }
+  if (typeof value !== "string") return JSON.stringify(value);
+  const exact = value.match(/^\{\{\s*([^{}]+?)\s*\}\}$/);
+  if (exact) return renderToolRowPathExpression(exact[1] ?? "", rowName);
+  const pieces = [];
+  let cursor = 0;
+  for (const match of value.matchAll(/\{\{\s*([^{}]+?)\s*\}\}/g)) {
+    const index = match.index ?? 0;
+    if (index > cursor) {
+      pieces.push(renderToolCodegenString(value.slice(cursor, index)));
+    }
+    pieces.push(
+      `String(${renderToolRowPathExpression(match[1] ?? "", rowName)} ?? '')`
+    );
+    cursor = index + match[0].length;
+  }
+  if (pieces.length === 0) return renderToolCodegenString(value);
+  if (cursor < value.length) {
+    pieces.push(renderToolCodegenString(value.slice(cursor)));
+  }
+  return pieces.join(" + ");
+}
+function renderExtractedValueGetterExpression(toolResultVar, targetKey) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(targetKey) ? `${toolResultVar}.extractedValues.${targetKey}?.get()` : `${toolResultVar}.extractedValues[${renderToolCodegenString(targetKey)}]?.get()`;
+}
+function getterFromLegacyPath(path) {
+  const last = String(path || "").replace(/\[(\d+)\]/g, ".$1").split(".").map((part) => part.trim()).filter(Boolean).at(-1);
+  if (!last) return null;
+  const normalized = last.replace(/[^A-Za-z0-9_]/g, "_");
+  return KNOWN_GETTER_NAMES.has(normalized) ? normalized : null;
+}
+function getterFromLegacyExtractJs(extractJs, fallbackAlias) {
+  const source = extractJs?.trim();
+  if (!source) {
+    const aliasGetter = fallbackAlias?.replace(/[^A-Za-z0-9_]/g, "_");
+    return aliasGetter && KNOWN_GETTER_NAMES.has(aliasGetter) ? aliasGetter : null;
+  }
+  const directExtract = source.match(
+    /\bextract\(\s*["'][^"']+["']\s*,\s*output_data\s*,\s*["']([^"']+)["']\s*\)/
+  );
+  if (directExtract?.[1]) {
+    return getterFromLegacyPath(
+      directExtract[1] === "linkedin_url" ? "linkedin" : directExtract[1]
+    );
+  }
+  const pick = source.match(
+    /\b(?:pick|extract|target)\(\s*(\[[\s\S]*?\]|["'][^"']+["'])\s*\)/
+  );
+  if (!pick?.[1]) return null;
+  try {
+    const parsed = JSON.parse(pick[1].replace(/'/g, '"'));
+    const paths = Array.isArray(parsed) ? parsed : [parsed];
+    for (const path of paths) {
+      if (typeof path !== "string") continue;
+      const getter = getterFromLegacyPath(path);
+      if (getter) return getter;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+// src/cli/user-code-safety.ts
+var FORBIDDEN = [
+  // Non-deterministic — breaks replay.
+  { pattern: /\bMath\s*\.\s*random\b/, reason: "Math.random()" },
+  { pattern: /\bDate\s*\.\s*now\b/, reason: "Date.now()" },
+  { pattern: /\bnew\s+Date\s*\(\s*\)/, reason: "new Date() with no argument" },
+  { pattern: /\bperformance\s*\.\s*now\b/, reason: "performance.now()" },
+  {
+    pattern: /\bcrypto\s*\.\s*(?:randomUUID|getRandomValues)\b/,
+    reason: "crypto random"
+  },
+  // Sandbox escape / I/O.
+  { pattern: /(?<!\.)\bfetch\s*\(/, reason: "fetch()" },
+  { pattern: /(?<!\.)\bimport\s*\(/, reason: "dynamic import()" },
+  { pattern: /(?<!\.)\brequire\s*\(/, reason: "require()" },
+  { pattern: /(?<!\.)\beval\s*\(/, reason: "eval()" },
+  {
+    pattern: /(?<!\.)\bnew\s+Function\b|(?<!\.)\bFunction\s*\(/,
+    reason: "the Function constructor"
+  },
+  { pattern: /(?<!\.)\bprocess\b/, reason: "process" },
+  { pattern: /(?<!\.)\bglobalThis\b/, reason: "globalThis" },
+  { pattern: /(?<!\.)\b(?:window|self)\b/, reason: "window/self" },
+  { pattern: /(?<!\.)\bXMLHttpRequest\b/, reason: "XMLHttpRequest" },
+  { pattern: /(?<!\.)\bWebAssembly\b/, reason: "WebAssembly" }
+];
+function assertUserCodeIsSafe(code, label) {
+  if (typeof code !== "string" || !code.trim()) return;
+  for (const { pattern, reason } of FORBIDDEN) {
+    if (pattern.test(code)) {
+      throw new Error(
+        `${label} uses ${reason}, which is not allowed in play code: it breaks deterministic replay or escapes the sandbox. Remove it and compute the value from the row/result instead.`
+      );
+    }
+  }
+}
+
+// src/cli/enrich-play-compiler.ts
 function isWaterfall(command) {
   return "with_waterfall" in command;
 }
-function safeIdentifier2(value, fallback) {
-  const cleaned = value.replace(/[^A-Za-z0-9_$]/g, "_");
-  const prefixed = /^[A-Za-z_$]/.test(cleaned) ? cleaned : `_${cleaned}`;
-  if (!prefixed || RESERVED_WORDS.has(prefixed)) {
-    return fallback;
-  }
-  return prefixed;
+function configHasRunJavascript(config) {
+  const walk = (commands) => commands.some(
+    (command) => isWaterfall(command) ? walk(command.commands) : command.tool === "run_javascript"
+  );
+  return walk(config.commands ?? []);
 }
 function stringLiteral(value) {
   return JSON.stringify(value);
@@ -14050,12 +14338,23 @@ function commandCallId(command) {
 function normalizeAlias(value) {
   return value.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function renderExecuteStep(command, options = { force: false }) {
+function renderExecuteStep(command, options = {
+  force: false
+}) {
+  if (command.play) {
+    return renderPlayStep(command, options);
+  }
+  if (command.tool === "run_javascript" && options.inlineRunJavascript) {
+    return renderInlineJavascriptStep(command, options);
+  }
+  if (options.idiomaticGetters) {
+    return renderIdiomaticExecuteStep(command, options);
+  }
   const alias = stringLiteral(command.alias);
   const callId = stringLiteral(commandCallId(command));
   const tool = stringLiteral(command.tool);
   const payload = stableJson(command.payload ?? {});
-  const extractJs = command.extract_js ? `({ row, result, data, raw, pick, extract, target }) => { const input = row; const context = row;
+  const extractJs = command.extract_js ? `({ row, result, data, raw, pick, extract, extractList, target, get }) => { const input = row; const context = row;
 ${indent(renderJavascriptBody(command.extract_js), 6)}
     }` : "null";
   const runIfJs = command.run_if_js ? `(row) => { const input = row; const context = row;
@@ -14065,6 +14364,8 @@ ${indent(renderJavascriptBody(command.run_if_js), 6)}
       description: ${stringLiteral(command.description)}` : "";
   const force = options.force ? `,
     force: true` : "";
+  const legacyEnvelope = options.legacyEnvelope ? `,
+    legacyEnvelope: true` : "";
   return [
     `async (row, stepCtx) => {`,
     ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
@@ -14076,253 +14377,842 @@ ${indent(renderJavascriptBody(command.run_if_js), 6)}
     `    extract: ${extractJs},`,
     `    runIf: ${runIfJs},`,
     `    row,`,
-    `    stepCtx${description}${force}`,
+    `    stepCtx${description}${force}${legacyEnvelope}`,
+    `  });`,
+    `}`
+  ].join("\n");
+}
+function renderIdiomaticExecuteStep(command, options) {
+  const callId = stringLiteral(commandCallId(command));
+  const tool = stringLiteral(command.tool);
+  const input2 = renderToolPayloadExpression(command.payload ?? {});
+  const getter = getterFromLegacyExtractJs(command.extract_js, command.alias);
+  const extraction = getter ? `${renderExtractedValueGetterExpression("result", getter)} ?? null` : "result";
+  const runIfLines = command.run_if_js ? [
+    `  if (`,
+    `    !((row: Record<string, any>) => {`,
+    `      const input = row;`,
+    `      const context = row;`,
+    indent(renderJavascriptBody(command.run_if_js), 6),
+    `    })(row as Record<string, any>)`,
+    `  ) return null;`
+  ] : [];
+  return [
+    `async (row, ctx) => {`,
+    ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
+    ...runIfLines,
+    `  const result: any = await ctx.tools.execute({`,
+    `    id: ${callId},`,
+    `    tool: ${tool},`,
+    `    input: ${input2} as any,`,
+    `    description: ${stringLiteral((command.description ?? "").trim() || `Run ${command.alias} via ${command.tool}.`)},`,
+    ...options.force ? [`    staleAfterSeconds: 1,`] : [],
+    `  });`,
+    `  return ${extraction};`,
+    `}`
+  ].join("\n");
+}
+function renderInlineJavascriptStep(command, options) {
+  const code = typeof command.payload?.code === "string" ? command.payload.code : "return null;";
+  const runIfLines = command.run_if_js ? [
+    `  if (!((row: Record<string, any>) => { const input = row; const context = row;`,
+    indent(renderJavascriptBody(command.run_if_js), 4),
+    `  })(row as Record<string, any>)) return null;`
+  ] : [];
+  return [
+    `async (row) => {`,
+    ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
+    ...runIfLines,
+    `  return ((row: Record<string, any>, input: Record<string, any>, context: Record<string, any>) => {`,
+    indent(renderJavascriptBody(code), 4),
+    `  })(row as Record<string, any>, row as Record<string, any>, row as Record<string, any>);`,
+    `}`
+  ].join("\n");
+}
+function renderPlayStep(command, options) {
+  const alias = stringLiteral(command.alias);
+  const callId = stringLiteral(commandCallId(command));
+  const playRef = stringLiteral(command.play?.ref ?? command.tool);
+  const payload = stableJson(command.payload ?? {});
+  const runIfJs = command.run_if_js ? `(row) => { const input = row; const context = row;
+${indent(renderJavascriptBody(command.run_if_js), 6)}
+    }` : "null";
+  const runIfLines = command.run_if_js ? [`  const __dlRunIf = ${runIfJs};`, `  if (!__dlRunIf(row)) return null;`] : [];
+  const playOptions = [
+    `      description: ${stringLiteral(command.description ?? command.alias)}`,
+    ...options.force ? [`      staleAfterSeconds: 1`] : []
+  ].join(",\n");
+  return [
+    `async (row, stepCtx) => {`,
+    ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
+    ...runIfLines,
+    `  const payload = __dlTemplate(${payload}, row) as Record<string, unknown>;`,
+    `  const result = await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
+    playOptions,
     `  });`,
+    `  return __dlPlayResultValue(${alias}, result);`,
     `}`
   ].join("\n");
 }
 function renderJavascriptBody(source) {
+  assertUserCodeIsSafe(source, "play step code");
   const trimmed = source.trim();
+  if (/^(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(trimmed)) {
+    return `return (${trimmed});`;
+  }
   if (trimmed && !trimmed.includes("\n") && !trimmed.includes(";") && !/\breturn\b/.test(trimmed)) {
     return `return (${trimmed});`;
   }
   return source;
 }
-function renderWaterfallProgram(command, index, forceAliases) {
-  const variableName = safeIdentifier2(
-    `${command.with_waterfall}_${index}_waterfall`,
-    `waterfall_${index}`
+function renderColumnStep(alias, resolverSource, force) {
+  const resolver = indent(resolverSource, 8);
+  return [
+    `      .withColumn(${stringLiteral(alias)},`,
+    force ? `${resolver},` : resolver,
+    ...force ? [`        { staleAfterSeconds: 1 }`] : [],
+    `      )`
+  ].join("\n");
+}
+function metadataMode(command) {
+  return /\bextractList\s*\(/.test(command.extract_js ?? "") ? "list" : "scalar";
+}
+function metadataEntryForCommand(command, waterfallGroupId) {
+  const entry = {
+    tool_id: command.tool
+  };
+  if (command.play?.ref) {
+    entry.play_ref = command.play.ref;
+    entry.kind = "play_call";
+  }
+  if (command.operation) {
+    entry.operation = command.operation;
+  }
+  if (command.extract_js?.trim()) {
+    entry.extract_js = command.extract_js.trim();
+  }
+  if (waterfallGroupId) {
+    entry.waterfall = {
+      group_id: waterfallGroupId,
+      mode: metadataMode(command)
+    };
+  }
+  return entry;
+}
+function collectMetadataColumns(commands, waterfallGroupId) {
+  const columns = {};
+  for (const command of commands) {
+    if (isWaterfall(command)) {
+      Object.assign(
+        columns,
+        collectMetadataColumns(command.commands, command.with_waterfall)
+      );
+      continue;
+    }
+    if (command.disabled) {
+      continue;
+    }
+    columns[normalizeAlias(command.alias)] = metadataEntryForCommand(
+      command,
+      waterfallGroupId
+    );
+  }
+  return columns;
+}
+function renderMetadataColumnStep(config) {
+  const columns = collectMetadataColumns(config.commands);
+  if (Object.keys(columns).length === 0) {
+    return "";
+  }
+  return [
+    `      .withColumn('_metadata',`,
+    `        (row) => __dlMergeMetadata(row._metadata, ${stableJson({ columns })}),`,
+    `        { staleAfterSeconds: 1 }`,
+    `      )`
+  ].join("\n");
+}
+function renderWaterfallColumns(command, forceAliases, inlineRunJavascript, idiomaticGetters) {
+  const activeChildren = command.commands.filter(
+    (nested) => !isWaterfall(nested) && !nested.disabled
   );
-  const stepLines = command.commands.map((nested, stepIndex) => {
+  const minResults = typeof command.min_results === "number" ? Math.max(1, Math.trunc(command.min_results)) : 1;
+  const columnSteps = activeChildren.map((nested, stepIndex) => {
     if (isWaterfall(nested)) {
       throw new Error("Nested with_waterfall blocks are not supported.");
     }
     if (nested.disabled) {
       return null;
     }
-    const priorAliases = command.commands.slice(0, stepIndex).filter((prior) => !isWaterfall(prior)).filter((prior) => !prior.disabled).map((prior) => prior.alias);
-    const minResults = typeof command.min_results === "number" ? Math.max(1, Math.trunc(command.min_results)) : 1;
-    return [
-      `  .step(${stringLiteral(nested.alias)},`,
-      indent(
-        renderExecuteStep(nested, {
-          force: forceAliases.has(normalizeAlias(nested.alias)),
-          precheck: priorAliases.length > 0 ? `__dlWaterfallSatisfied(row, ${stableJson(priorAliases)}, ${minResults})` : void 0
-        }),
-        4
-      ),
-      `  )`
-    ].join("\n");
+    const priorAliases = activeChildren.slice(0, stepIndex).map((prior) => prior.alias);
+    const force = forceAliases.has(normalizeAlias(nested.alias));
+    return renderColumnStep(
+      nested.alias,
+      renderExecuteStep(nested, {
+        force,
+        precheck: priorAliases.length > 0 ? `__dlWaterfallSatisfied(row, ${stableJson(priorAliases)}, ${minResults})` : void 0,
+        legacyEnvelope: Boolean(nested.extract_js),
+        inlineRunJavascript,
+        idiomaticGetters
+      }),
+      force
+    );
   }).filter((line) => line !== null);
-  const aliases = command.commands.filter((nested) => !isWaterfall(nested)).filter((nested) => !nested.disabled).map((nested) => nested.alias);
+  const aliases = activeChildren.map((nested) => nested.alias);
+  const forceParent = forceAliases.has(normalizeAlias(command.with_waterfall)) || activeChildren.some(
+    (nested) => forceAliases.has(normalizeAlias(nested.alias))
+  );
   const returnExpr = typeof command.min_results === "number" ? `__dlFirstMinResults(row, ${stableJson(aliases)}, ${Math.max(
     1,
     Math.trunc(command.min_results)
   )})` : `__dlFirstMeaningful(row, ${stableJson(aliases)})`;
-  return {
-    variableName,
-    hasSteps: stepLines.length > 0,
-    source: [
-      `const ${variableName} = steps<Record<string, unknown>>()`,
-      ...stepLines,
-      `  .return((row) => ${returnExpr});`
-    ].join("\n")
-  };
+  if (columnSteps.length === 0) {
+    return [];
+  }
+  return [
+    ...columnSteps,
+    renderColumnStep(
+      command.with_waterfall,
+      `(row) => ${returnExpr}`,
+      forceParent
+    ),
+    renderColumnStep(
+      `${command.with_waterfall}_source`,
+      typeof command.min_results === "number" ? `(row) => __dlContributingAliases(row, ${stableJson(aliases)})` : `(row) => __dlFirstMeaningfulAlias(row, ${stableJson(aliases)})`,
+      forceParent
+    )
+  ];
 }
 function compileEnrichConfigToPlaySource(config, options = {}) {
   const playName = options.playName ?? "deepline-enrich-v1-compat";
   const mapName = options.mapName ?? "deepline_enrich_rows";
+  const inlineRunJavascript = options.inlineRunJavascript ?? false;
+  const idiomaticGetters = options.idiomaticGetters ?? false;
   const forceAliases = new Set(
     [...options.forceAliases ?? []].map((alias) => normalizeAlias(alias))
   );
-  const waterfalls = [];
-  const mapSteps = [];
-  config.commands.forEach((command, index) => {
+  const columnSteps = [];
+  config.commands.forEach((command) => {
     if (isWaterfall(command)) {
-      const rendered = renderWaterfallProgram(command, index, forceAliases);
-      if (!rendered.hasSteps) {
-        return;
-      }
-      waterfalls.push({
-        alias: command.with_waterfall,
-        variableName: rendered.variableName,
-        source: rendered.source
-      });
-      mapSteps.push(
-        `      .step(${stringLiteral(command.with_waterfall)}, ${rendered.variableName})`
+      columnSteps.push(
+        ...renderWaterfallColumns(
+          command,
+          forceAliases,
+          inlineRunJavascript,
+          idiomaticGetters
+        )
       );
       return;
     }
     if (command.disabled) {
       return;
     }
-    mapSteps.push(
-      [
-        `      .step(${stringLiteral(command.alias)},`,
-        indent(
-          renderExecuteStep(command, {
-            force: forceAliases.has(normalizeAlias(command.alias))
-          }),
-          8
-        ),
-        `      )`
-      ].join("\n")
+    const force = forceAliases.has(normalizeAlias(command.alias));
+    columnSteps.push(
+      renderColumnStep(
+        command.alias,
+        renderExecuteStep(command, {
+          force,
+          inlineRunJavascript,
+          idiomaticGetters
+        }),
+        force
+      )
     );
   });
-  const waterfallSource = waterfalls.map((entry) => indent(entry.source, 4));
-  const mapStepSource = mapSteps.length > 0 ? mapSteps.join("\n") : `      .step('noop', (row) => row)`;
+  const columnStepSource = columnSteps.length > 0 ? columnSteps.join("\n") : `      .withColumn('noop', () => null)`;
+  const metadataColumnSource = renderMetadataColumnStep(config);
+  const body = [
+    `export default definePlay(${stringLiteral(playName)}, async (ctx, input: EnrichInput) => {`,
+    `  const sourceRows = await ctx.csv<Record<string, unknown>>(input.file);`,
+    `  const rowStart = __dlNonNegativeInteger(input.rowStart, 0);`,
+    `  const rowEndExclusive = Number.isFinite(input.rowEnd) ? Math.max(rowStart, __dlWholeNumber(input.rowEnd, rowStart) + 1) : undefined;`,
+    `  const rows = sourceRows.slice(rowStart, rowEndExclusive, { key: 'deepline_enrich_selected_rows', sourceLabel: 'Selected enrich rows' });`,
+    `  const enriched = await ctx`,
+    `    .dataset(${stringLiteral(mapName)}, rows)`,
+    columnStepSource,
+    ...metadataColumnSource ? [metadataColumnSource] : [],
+    `    .run({ key: (row, index) => __dlStableRowKey(row, index + rowStart) });`,
+    `  return { rows: enriched, count: await enriched.count() };`,
+    `});`
+  ];
+  const helpers = idiomaticGetters ? selectUsedHelpers(helperSource(), body.join("\n")) : helperSource();
   return [
-    `import { definePlay, steps } from 'deepline';`,
+    ...inlineRunJavascript && configHasRunJavascript(config) ? ["// @ts-nocheck", "/* eslint-disable */", ""] : [],
+    `import { definePlay } from 'deepline';`,
     ``,
     `type EnrichInput = { file: string; rowStart?: number | null; rowEnd?: number | null };`,
     ``,
-    helperSource(),
+    helpers,
     ``,
-    `export default definePlay(${stringLiteral(playName)}, async (ctx, input: EnrichInput) => {`,
-    `  const allRows = await ctx.csv<Record<string, unknown>>(input.file);`,
-    `  const rowStart = Number.isFinite(input.rowStart) ? Math.max(0, Math.trunc(Number(input.rowStart))) : 0;`,
-    `  const rowEnd = Number.isFinite(input.rowEnd) ? Math.max(rowStart, Math.trunc(Number(input.rowEnd))) : allRows.length;`,
-    `  const rows = allRows.slice(rowStart, rowEnd);`,
-    ...waterfallSource,
-    `  const enriched = await ctx`,
-    `    .map(${stringLiteral(mapName)}, rows)`,
-    mapStepSource,
-    `    .run({ key: (row, index) => __dlStableRowKey(row, index + rowStart) });`,
-    `  return { rows: enriched, count: await enriched.count() };`,
-    `});`,
+    ...body,
     ``
   ].join("\n");
 }
+function selectUsedHelpers(helperBlock, referenceSource) {
+  const referencesSymbol = (source, symbol) => new RegExp(`\\b${symbol}\\b`).test(source);
+  const blocks = helperBlock.split("\n\n").map((source) => source.trim()).filter(Boolean).map((source) => ({
+    name: source.match(/(?:function|type|const)\s+(__[A-Za-z]\w*)/)?.[1] ?? "",
+    source
+  }));
+  const used = /* @__PURE__ */ new Set();
+  for (const { name } of blocks) {
+    if (name && referencesSymbol(referenceSource, name)) used.add(name);
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const usedSource = blocks.filter((block) => used.has(block.name)).map((block) => block.source).join("\n");
+    for (const { name } of blocks) {
+      if (!name || used.has(name)) continue;
+      if (referencesSymbol(usedSource, name)) {
+        used.add(name);
+        changed = true;
+      }
+    }
+  }
+  return blocks.filter((block) => used.has(block.name)).map((block) => block.source).join("\n\n");
+}
 function helperSource() {
   return [
-    `function __dlGetByPath(root: unknown, path: string): unknown {`,
-    `  return String(path || '')`,
-    `    .replace(/\\[(\\d+)\\]/g, '.$1')`,
-    `    .split('.')`,
-    `    .map((part) => part.trim())`,
-    `    .filter(Boolean)`,
-    `    .reduce((cursor: unknown, part: string) => {`,
-    `      if (!cursor || typeof cursor !== 'object') return undefined;`,
-    `      const record = cursor as Record<string, unknown>;`,
-    `      if (part in record) return record[part];`,
-    `      const data = record.data;`,
-    `      return data && typeof data === 'object' ? (data as Record<string, unknown>)[part] : undefined;`,
-    `    }, root);`,
+    `function __dlWholeNumber(value: unknown, fallback: number): number {`,
+    `  const numeric = Number(value);`,
+    `  if (!Number.isFinite(numeric)) return fallback;`,
+    `  return Math.floor(numeric);`,
     `}`,
     ``,
-    `function __dlMeaningful(value: unknown): boolean {`,
-    `  return value !== null && value !== undefined && !(typeof value === 'string' && value.trim() === '') && !(Array.isArray(value) && value.length === 0);`,
+    `function __dlNonNegativeInteger(value: unknown, fallback: number): number {`,
+    `  return Math.max(0, __dlWholeNumber(value, fallback));`,
     `}`,
     ``,
-    `function __dlRawToolOutput(result: unknown): unknown {`,
-    `  if (!result || typeof result !== 'object') return result;`,
-    `  const record = result as Record<string, unknown>;`,
-    `  return __dlGetByPath(record, 'toolOutput.raw') ?? __dlGetByPath(record, 'toolResponse.raw') ?? record.result ?? record.output ?? result;`,
+    `function __dlAtLeastOneInteger(value: number): number {`,
+    `  return Math.max(1, Math.floor(Number(value)));`,
     `}`,
     ``,
-    `function __dlTemplate(value: unknown, row: Record<string, unknown>): unknown {`,
-    `  if (Array.isArray(value)) return value.map((entry) => __dlTemplate(entry, row));`,
-    `  if (value && typeof value === 'object') {`,
-    `    return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([key, entry]) => [key, __dlTemplate(entry, row)]));`,
-    `  }`,
-    `  if (typeof value !== 'string') return value;`,
-    `  const exact = value.match(/^\\{\\{\\s*([^{}]+?)\\s*\\}\\}$/);`,
-    `  if (exact) return __dlGetByPath(row, exact[1] || '');`,
-    `  return value.replace(/\\{\\{\\s*([^{}]+?)\\s*\\}\\}/g, (_match, path) => {`,
-    `    const replacement = __dlGetByPath(row, String(path || ''));`,
-    `    return replacement === null || replacement === undefined ? '' : String(replacement);`,
-    `  });`,
+    `function __dlRecord(value: unknown): value is Record<string, unknown> {`,
+    `  return Boolean(value && typeof value === 'object' && !Array.isArray(value));`,
     `}`,
     ``,
-    `function __dlStableRowKey(row: Record<string, unknown>, index: number): string {`,
-    `  for (const key of ['id', 'ID', 'email', 'Email', 'linkedin_url', 'LINKEDIN_URL', 'domain', 'DOMAIN']) {`,
-    `    const value = row[key];`,
-    `    if (__dlMeaningful(value)) return String(value);`,
+    `function __dlParseMetadata(value: unknown): Record<string, unknown> | null {`,
+    `  if (__dlRecord(value)) return value;`,
+    `  if (typeof value !== 'string') return null;`,
+    `  const trimmed = value.trim();`,
+    `  if (!trimmed) return null;`,
+    `  const candidates = [trimmed];`,
+    `  if (trimmed.includes('\\\\"')) candidates.push(trimmed.replace(/\\\\"/g, '"'));`,
+    `  for (const candidate of candidates) {`,
+    `    try {`,
+    `      const parsed = JSON.parse(candidate);`,
+    `      if (__dlRecord(parsed)) return parsed;`,
+    `      if (typeof parsed === 'string') {`,
+    `        const nested = JSON.parse(parsed);`,
+    `        if (__dlRecord(nested)) return nested;`,
+    `      }`,
+    `    } catch {}`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlMergeMetadata(existing: unknown, patch: Record<string, unknown>): Record<string, unknown> {`,
+    `  const base = __dlParseMetadata(existing) ?? {};`,
+    `  const baseColumns = __dlRecord(base.columns) ? base.columns : {};`,
+    `  const patchColumns = __dlRecord(patch.columns) ? patch.columns : {};`,
+    `  return {`,
+    `    ...base,`,
+    `    ...patch,`,
+    `    columns: {`,
+    `      ...baseColumns,`,
+    `      ...patchColumns,`,
+    `    },`,
+    `  };`,
+    `}`,
+    ``,
+    `function __dlPathParts(path: string): string[] {`,
+    `  const source = String(path || '');`,
+    `  const parts: string[] = [];`,
+    `  let current = '';`,
+    `  for (let index = 0; index < source.length; index += 1) {`,
+    `    const char = source.slice(index, index + 1);`,
+    `    if (char === '.' || char === '[' || char === ']') {`,
+    `      const trimmed = current.trim();`,
+    `      if (trimmed) parts.push(trimmed);`,
+    `      current = '';`,
+    `      continue;`,
+    `    }`,
+    `    current += char;`,
+    `  }`,
+    `  const trimmed = current.trim();`,
+    `  if (trimmed) parts.push(trimmed);`,
+    `  return parts;`,
+    `}`,
+    ``,
+    `function __dlGetByPath(root: unknown, path: string): unknown {`,
+    `  let cursor = root;`,
+    `  for (const part of __dlPathParts(path)) {`,
+    `    if (!cursor || typeof cursor !== 'object') return undefined;`,
+    `    const record = cursor as Record<string, unknown>;`,
+    `    if (part in record) {`,
+    `      cursor = record[part];`,
+    `      continue;`,
+    `    }`,
+    `    const data = record.data;`,
+    `    cursor = data && typeof data === 'object' ? (data as Record<string, unknown>)[part] : undefined;`,
+    `  }`,
+    `  return cursor;`,
+    `}`,
+    ``,
+    `function __dlMeaningful(value: unknown): boolean {`,
+    `  if (value && typeof value === 'object' && !Array.isArray(value)) {`,
+    `    const record = value as Record<string, unknown>;`,
+    `    const status = typeof record.status === 'string' ? record.status.toLowerCase() : '';`,
+    `    if (status === 'error' || status === 'failed') return false;`,
+    `    if (typeof record.error === 'string' && record.error.trim()) return false;`,
+    `    const result = record.result;`,
+    `    if (result && typeof result === 'object' && !Array.isArray(result)) {`,
+    `      const resultRecord = result as Record<string, unknown>;`,
+    `      if (typeof resultRecord.error === 'string' && resultRecord.error.trim()) return false;`,
+    `      if (typeof resultRecord.message === 'string' && resultRecord.message.trim()) return false;`,
+    `    }`,
+    `    if ('matched_result' in record) return __dlMeaningful(record.matched_result);`,
+    `  }`,
+    `  return value !== null && value !== undefined && !(typeof value === 'string' && value.trim() === '') && !(Array.isArray(value) && value.length === 0);`,
+    `}`,
+    ``,
+    `function __dlErrorPayload(value: unknown): boolean {`,
+    `  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;`,
+    `  const record = value as Record<string, unknown>;`,
+    `  const status = typeof record.status === 'string' ? record.status.toLowerCase() : '';`,
+    `  const result = record.result;`,
+    `  const resultError = result && typeof result === 'object' && !Array.isArray(result) ? (result as Record<string, unknown>).error : null;`,
+    `  return status === 'error' || status === 'failed' || (typeof record.error === 'string' && record.error.trim() !== '') || (typeof resultError === 'string' && resultError.trim() !== '');`,
+    `}`,
+    ``,
+    `function __dlRawToolOutput(result: unknown): unknown {`,
+    `  if (!result || typeof result !== 'object') return result;`,
+    `  const record = result as Record<string, unknown>;`,
+    `  return __dlGetByPath(record, 'toolOutput.raw') ?? __dlGetByPath(record, 'toolResponse.raw') ?? record.result ?? record.output ?? result;`,
+    `}`,
+    ``,
+    `function __dlPushCandidate(candidates: unknown[], value: unknown): void {`,
+    `  if (value === null || value === undefined) return;`,
+    `  if (!candidates.includes(value)) candidates.push(value);`,
+    `}`,
+    ``,
+    `function __dlRawToolCandidates(raw: unknown): unknown[] {`,
+    `  const candidates: unknown[] = [raw];`,
+    `  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return candidates;`,
+    `  const record = raw as Record<string, unknown>;`,
+    `  __dlPushCandidate(candidates, record.data);`,
+    `  __dlPushCandidate(candidates, record.result);`,
+    `  __dlPushCandidate(candidates, record.output);`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'result.data'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'output.body'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'toolResponse.raw'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'toolOutput.raw'));`,
+    `  return candidates;`,
+    `}`,
+    ``,
+    `function __dlLegacyResultData(value: unknown): unknown {`,
+    `  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;`,
+    `  const record = value as Record<string, unknown>;`,
+    `  return 'data' in record ? record.data : value;`,
+    `}`,
+    ``,
+    `function __dlLegacyOutputData(result: unknown, raw: unknown): unknown {`,
+    `  const rawRecord = raw && typeof raw === 'object' && !Array.isArray(raw) ? (raw as Record<string, unknown>) : null;`,
+    `  const data = rawRecord && 'data' in rawRecord ? rawRecord.data : raw;`,
+    `  const existingResult = rawRecord && rawRecord.result && typeof rawRecord.result === 'object' && !Array.isArray(rawRecord.result) ? (rawRecord.result as Record<string, unknown>) : null;`,
+    `  const resultData = existingResult && 'data' in existingResult ? __dlLegacyResultData(existingResult.data) : __dlLegacyResultData(data);`,
+    `  const resultObject = resultData && typeof resultData === 'object' && !Array.isArray(resultData) ? (resultData as Record<string, unknown>) : {};`,
+    `  return {`,
+    `    ...(rawRecord ?? {}),`,
+    `    data,`,
+    `    result: { ...resultObject, ...(existingResult ?? {}), data: resultData },`,
+    `    raw,`,
+    `    toolResponse: { raw },`,
+    `    originalResult: result,`,
+    `  };`,
+    `}`,
+    ``,
+    `function __dlTemplate(value: unknown, row: Record<string, unknown>): unknown {`,
+    `  if (Array.isArray(value)) return value.map((entry) => __dlTemplate(entry, row));`,
+    `  if (value && typeof value === 'object') {`,
+    `    return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([key, entry]) => [key, __dlTemplate(entry, row)]));`,
+    `  }`,
+    `  if (typeof value !== 'string') return value;`,
+    `  const exact = value.match(/^\\{\\{\\s*([^{}]+?)\\s*\\}\\}$/);`,
+    `  if (exact) return __dlGetByPath(row, exact[1] || '');`,
+    `  let rendered = '';`,
+    `  let cursor = 0;`,
+    `  while (cursor < value.length) {`,
+    `    const open = value.indexOf('{{', cursor);`,
+    `    if (open < 0) {`,
+    `      rendered += value.slice(cursor);`,
+    `      break;`,
+    `    }`,
+    `    const close = value.indexOf('}}', open + 2);`,
+    `    if (close < 0) {`,
+    `      rendered += value.slice(cursor);`,
+    `      break;`,
+    `    }`,
+    `    rendered += value.slice(cursor, open);`,
+    `    const path = value.slice(open + 2, close).trim();`,
+    `    const replacement = __dlGetByPath(row, path);`,
+    `    rendered += replacement === null || replacement === undefined ? '' : String(replacement);`,
+    `    cursor = close + 2;`,
+    `  }`,
+    `  return rendered;`,
+    `}`,
+    ``,
+    `function __dlStableRowKey(row: Record<string, unknown>, index: number): string {`,
+    `  for (const key of ['id', 'ID', 'row_key', 'ROW_KEY', 'email', 'Email', 'linkedin_url', 'LINKEDIN_URL', 'domain', 'DOMAIN', 'name', 'Name']) {`,
+    `    const value = row[key];`,
+    `    if (__dlMeaningful(value)) return String(value);`,
     `  }`,
     `  return String(index);`,
     `}`,
     ``,
+    `function __dlScalarValue(value: unknown): unknown {`,
+    `  if (value && typeof value === 'object' && !Array.isArray(value)) {`,
+    `    const record = value as Record<string, unknown>;`,
+    `    if ('matched_result' in record) return __dlScalarValue(record.matched_result);`,
+    `    for (const key of ['value', 'email', 'output', 'result', 'data']) {`,
+    `      const nested = record[key];`,
+    `      if (__dlMeaningful(nested)) return __dlScalarValue(nested);`,
+    `    }`,
+    `  }`,
+    `  return value;`,
+    `}`,
+    ``,
     `function __dlFirstMeaningful(row: Record<string, unknown>, aliases: string[]): unknown {`,
     `  for (const alias of aliases) {`,
     `    const value = row[alias];`,
-    `    if (__dlMeaningful(value)) return value;`,
+    `    if (__dlMeaningful(value)) return __dlScalarValue(value);`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlFirstMeaningfulAlias(row: Record<string, unknown>, aliases: string[]): string | null {`,
+    `  for (const alias of aliases) {`,
+    `    if (__dlMeaningful(row[alias])) return alias;`,
     `  }`,
     `  return null;`,
     `}`,
     ``,
+    `function __dlListValue(value: unknown): unknown[] {`,
+    `  if (Array.isArray(value)) return value.filter(__dlMeaningful);`,
+    `  if (value && typeof value === 'object') {`,
+    `    const record = value as Record<string, unknown>;`,
+    `    if ('matched_result' in record) return __dlListValue(record.matched_result);`,
+    `    for (const key of ['result', 'value', 'data']) {`,
+    `      const nested = record[key];`,
+    `      const nestedList = __dlListValue(nested);`,
+    `      if (nestedList.length > 0) return nestedList;`,
+    `    }`,
+    `    return __dlMeaningful(value) ? [value] : [];`,
+    `  }`,
+    `  return __dlMeaningful(value) ? [value] : [];`,
+    `}`,
+    ``,
     `function __dlFirstMinResults(row: Record<string, unknown>, aliases: string[], minResults: number): unknown {`,
     `  const values: unknown[] = [];`,
     `  for (const alias of aliases) {`,
-    `    const value = row[alias];`,
-    `    if (Array.isArray(value)) values.push(...value.filter(__dlMeaningful));`,
-    `    else if (__dlMeaningful(value)) values.push(value);`,
-    `    if (values.length >= minResults) return values.slice(0, minResults);`,
+    `    values.push(...__dlListValue(row[alias]));`,
+    `    if (values.length >= minResults) return values;`,
     `  }`,
     `  return values.length > 0 ? values : null;`,
     `}`,
     ``,
+    `function __dlContributingAliases(row: Record<string, unknown>, aliases: string[]): string[] | null {`,
+    `  const sources: string[] = [];`,
+    `  for (const alias of aliases) {`,
+    `    if (__dlListValue(row[alias]).length > 0) sources.push(alias);`,
+    `  }`,
+    `  return sources.length > 0 ? sources : null;`,
+    `}`,
+    ``,
     `function __dlWaterfallSatisfied(row: Record<string, unknown>, aliases: string[], minResults: number): boolean {`,
     `  let count = 0;`,
     `  for (const alias of aliases) {`,
-    `    const value = row[alias];`,
-    `    if (Array.isArray(value)) count += value.filter(__dlMeaningful).length;`,
-    `    else if (__dlMeaningful(value)) count += 1;`,
-    `    if (count >= Math.max(1, Math.trunc(minResults))) return true;`,
+    `    count += __dlListValue(row[alias]).length;`,
+    `    if (count >= __dlAtLeastOneInteger(minResults)) return true;`,
     `  }`,
     `  return false;`,
     `}`,
     ``,
-    `function __dlExtract(alias: string, result: unknown, row: Record<string, unknown>, extractor: ((args: { row: Record<string, unknown>; result: unknown; data: unknown; raw: unknown; pick: (paths: string[] | string) => unknown; extract: (paths: string[] | string) => unknown; target: (paths: string[] | string) => unknown }) => unknown) | null): unknown {`,
+    `function __dlKeyPaths(key: string): string[] {`,
+    `  const normalized = String(key || '').trim();`,
+    `  if (normalized === 'email') return ['email', 'email_address', 'person.email', 'contact.email', 'data.email', 'result.data.email'];`,
+    `  if (normalized === 'personal_email') return ['personal_email', 'email', 'email_address', 'data.personal_email', 'data.email'];`,
+    `  if (normalized === 'phone') return ['phone', 'phone_number', 'mobile_phone', 'mobile_phone_number', 'data.phone'];`,
+    `  if (normalized === 'linkedin') return ['linkedin', 'linkedin_url', 'linkedin_profile', 'profile_url', 'person.linkedin', 'person.linkedin_url'];`,
+    `  if (normalized === 'full_name') return ['full_name', 'name', 'person.full_name', 'person.name'];`,
+    `  if (normalized === 'first_name') return ['first_name', 'person.first_name'];`,
+    `  if (normalized === 'last_name') return ['last_name', 'person.last_name'];`,
+    `  if (normalized === 'title') return ['title', 'job_title', 'current_title', 'headline', 'person.title'];`,
+    `  if (normalized === 'company_name') return ['company_name', 'company.name', 'organization.name'];`,
+    `  if (normalized === 'company_domain') return ['company_domain', 'domain', 'company.domain', 'organization.domain'];`,
+    `  if (normalized === 'status') return ['status', 'verdict', 'state'];`,
+    `  if (normalized === 'email_status') return ['email_status', 'status', 'verdict', 'data.email_status'];`,
+    `  return [normalized];`,
+    `}`,
+    ``,
+    `function __dlSelectorKeys(selector: unknown): string[] | null {`,
+    `  if (!selector || typeof selector !== 'object' || Array.isArray(selector)) return null;`,
+    `  const keys = (selector as { keys?: unknown }).keys;`,
+    `  if (!Array.isArray(keys) || keys.length === 0) return null;`,
+    `  const out: string[] = [];`,
+    `  for (const key of keys) {`,
+    `    if (typeof key === 'string' && key.trim()) out.push(key.trim());`,
+    `  }`,
+    `  return out.length > 0 ? out : null;`,
+    `}`,
+    ``,
+    `function __dlFirstByPaths(payload: unknown, paths: string[] | string): unknown {`,
+    `  const candidates = Array.isArray(paths) ? paths : [paths];`,
+    `  for (const path of candidates) {`,
+    `    for (const candidate of __dlRawToolCandidates(payload)) {`,
+    `      const value = __dlGetByPath(candidate, String(path));`,
+    `      if (__dlMeaningful(value)) return value;`,
+    `    }`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlExtractTarget(payload: unknown, key: string): unknown {`,
+    `  return __dlFirstByPaths(payload, __dlKeyPaths(key));`,
+    `}`,
+    ``,
+    `function __dlExtractedValue(result: unknown, key: string): unknown {`,
+    `  if (!result || typeof result !== 'object' || Array.isArray(result)) return undefined;`,
+    `  const extractedValues = (result as Record<string, unknown>).extractedValues;`,
+    `  if (!extractedValues || typeof extractedValues !== 'object' || Array.isArray(extractedValues)) return undefined;`,
+    `  const accessor = (extractedValues as Record<string, unknown>)[key];`,
+    `  if (!accessor || typeof accessor !== 'object' || Array.isArray(accessor)) return undefined;`,
+    `  const record = accessor as Record<string, unknown>;`,
+    `  const get = record.get;`,
+    `  if (typeof get === 'function') {`,
+    `    try {`,
+    `      return (get as () => unknown)();`,
+    `    } catch {`,
+    `      return undefined;`,
+    `    }`,
+    `  }`,
+    `  return record.value;`,
+    `}`,
+    ``,
+    `function __dlLegacyExtractorPayload(payload: unknown, raw: unknown): unknown {`,
+    `  if (payload === undefined || payload === null) return raw;`,
+    `  if (payload && typeof payload === 'object' && !Array.isArray(payload) && Object.keys(payload as Record<string, unknown>).length === 0) return raw;`,
+    `  return payload;`,
+    `}`,
+    ``,
+    `function __dlLegacyMatchedEnvelope(value: unknown, raw: unknown): unknown {`,
+    `  if (value && typeof value === 'object' && !Array.isArray(value) && 'matched_result' in (value as Record<string, unknown>)) return value;`,
+    `  const legacyOutput = __dlLegacyOutputData(undefined, raw) as Record<string, unknown>;`,
+    `  const legacyResult = legacyOutput.result && typeof legacyOutput.result === 'object' && !Array.isArray(legacyOutput.result) ? legacyOutput.result : raw;`,
+    `  return { matched_result: value, result: legacyResult };`,
+    `}`,
+    ``,
+    `function __dlString(value: unknown): string | null {`,
+    `  return typeof value === 'string' && value.trim() ? value.trim() : null;`,
+    `}`,
+    ``,
+    `// NOTE: email_status is NOT normalized here. It is materialized once by the`,
+    `// provider's emailStatus({...}) contract via buildEmailStatus and read back`,
+    `// through __dlExtractedValue(result, 'email_status') below. There is no`,
+    `// legacy string coarsening \u2014 see CONTEXT.md "Provider Email Status Contract".`,
+    ``,
+    `function __dlListPathCandidates(selector: unknown): string[] {`,
+    `  const paths: string[] = [];`,
+    `  const push = (path: string) => { if (path && !paths.includes(path)) paths.push(path); };`,
+    `  if (Array.isArray(selector)) {`,
+    `    for (const path of selector) push(String(path));`,
+    `  } else if (typeof selector === 'string') {`,
+    `    push(selector);`,
+    `  }`,
+    `  for (const path of ['data', 'data.people', 'data.persons', 'data.contacts', 'data.results', 'data.leads', 'data.items', 'result.data', 'result.people', 'result.persons', 'result.contacts', 'result.results', 'result.leads', 'result.items', 'people', 'persons', 'contacts', 'results', 'leads', 'items', 'output.body', 'body']) push(path);`,
+    `  return paths;`,
+    `}`,
+    ``,
+    `function __dlFindList(payload: unknown, selector: unknown): unknown[] {`,
+    `  if (Array.isArray(payload)) return payload;`,
+    `  for (const path of __dlListPathCandidates(selector)) {`,
+    `    for (const candidate of __dlRawToolCandidates(payload)) {`,
+    `      const value = __dlGetByPath(candidate, path);`,
+    `      if (Array.isArray(value)) return value;`,
+    `    }`,
+    `  }`,
+    `  const queue = __dlRawToolCandidates(payload);`,
+    `  const seen: unknown[] = [];`,
+    `  for (let index = 0; index < queue.length; index += 1) {`,
+    `    const current = queue[index];`,
+    `    if (!current || typeof current !== 'object' || seen.includes(current)) continue;`,
+    `    seen.push(current);`,
+    `    for (const value of Object.values(current as Record<string, unknown>)) {`,
+    `      if (Array.isArray(value)) return value;`,
+    `      if (value && typeof value === 'object') queue.push(value);`,
+    `    }`,
+    `  }`,
+    `  return [];`,
+    `}`,
+    ``,
+    `function __dlDeriveFullName(row: Record<string, unknown>): string | null {`,
+    `  const existing = __dlFirstByPaths(row, ['full_name', 'name']);`,
+    `  if (typeof existing === 'string' && existing.trim()) return existing.trim();`,
+    `  const first = __dlFirstByPaths(row, ['first_name', 'firstName']);`,
+    `  const last = __dlFirstByPaths(row, ['last_name', 'lastName']);`,
+    `  const parts = [first, last].filter((part): part is string => typeof part === 'string').map((part) => part.trim()).filter(Boolean);`,
+    `  return parts.length > 0 ? parts.join(' ') : null;`,
+    `}`,
+    ``,
+    `function __dlProjectListRows(rows: unknown[], keys: string[], payload: unknown): Array<Record<string, unknown>> {`,
+    `  const projected: Array<Record<string, unknown>> = [];`,
+    `  for (const row of rows) {`,
+    `    const record = row && typeof row === 'object' && !Array.isArray(row) ? (row as Record<string, unknown>) : { value: row };`,
+    `    const out: Record<string, unknown> = {};`,
+    `    for (const key of keys) {`,
+    `      let value = __dlExtractTarget(record, key);`,
+    `      if (!__dlMeaningful(value) && key === 'full_name') value = __dlDeriveFullName(record);`,
+    `      if (!__dlMeaningful(value)) value = __dlExtractTarget(payload, key);`,
+    `      out[key] = value === undefined ? null : value;`,
+    `    }`,
+    `    if (Object.values(out).some(__dlMeaningful)) projected.push(out);`,
+    `  }`,
+    `  return projected;`,
+    `}`,
+    ``,
+    `type __DlExtractorHelpers = { row: Record<string, unknown>; result: unknown; data: unknown; raw: unknown; pick: (paths: string[] | string) => unknown; extract: (...args: unknown[]) => unknown; extractList: (...args: unknown[]) => unknown[]; target: (paths: string[] | string) => unknown; get: (path: string) => unknown };`,
+    ``,
+    `function __dlErrorMessage(error: unknown): string {`,
+    `  if (error instanceof Error && error.message) return error.message;`,
+    `  if (typeof error === 'string' && error.trim()) return error.trim();`,
+    `  return 'Extractor failed';`,
+    `}`,
+    ``,
+    `function __dlExtractorFailure(error: unknown): unknown {`,
+    `  const message = __dlErrorMessage(error);`,
+    `  return { matched_result: null, result: { error: message, message } };`,
+    `}`,
+    ``,
+    `function __dlExtract(alias: string, result: unknown, row: Record<string, unknown>, extractor: ((args: __DlExtractorHelpers) => unknown) | null, legacyEnvelope = false): unknown {`,
     `  const raw = __dlRawToolOutput(result);`,
     `  if (!extractor) return raw;`,
     `  const pick = (paths: string[] | string) => {`,
     `    const candidates = Array.isArray(paths) ? paths : [paths];`,
     `    for (const path of candidates) {`,
-    `      const value = __dlGetByPath(raw, String(path));`,
-    `      if (__dlMeaningful(value)) return value;`,
+    `      if (typeof path === 'string') {`,
+    `        const extractedValue = __dlExtractedValue(result, path);`,
+    `        if (__dlMeaningful(extractedValue)) return extractedValue;`,
+    `      }`,
+    `      for (const candidate of __dlRawToolCandidates(raw)) {`,
+    `        const value = __dlGetByPath(candidate, String(path));`,
+    `        if (__dlMeaningful(value)) return value;`,
+    `      }`,
     `    }`,
     `    return null;`,
     `  };`,
-    `  const extracted = extractor({ row, result, data: raw, raw, pick, extract: pick, target: pick });`,
-    `  if (extracted && typeof extracted === 'object' && !Array.isArray(extracted) && alias in (extracted as Record<string, unknown>)) {`,
-    `    return (extracted as Record<string, unknown>)[alias];`,
+    `  const extract = (...args: unknown[]): unknown => {`,
+    `    const payload = args.length >= 3 ? __dlLegacyExtractorPayload(args[1], raw) : raw;`,
+    `    const selector = args.length >= 3 ? args[2] : args[0];`,
+    `    if (selector === undefined) return payload;`,
+    `    const keys = __dlSelectorKeys(selector);`,
+    `    if (keys) return Object.fromEntries(keys.map((key) => [key, __dlExtractTarget(payload, key) ?? null]));`,
+    `    if (Array.isArray(selector)) return __dlFirstByPaths(payload, selector.map(String));`,
+    `    if (typeof selector === 'string') {`,
+    `      const extractedValue = __dlExtractedValue(result, selector);`,
+    `      if (__dlMeaningful(extractedValue)) return __dlLegacyMatchedEnvelope(extractedValue, payload);`,
+    `      return __dlExtractTarget(payload, selector) ?? __dlFirstByPaths(payload, selector);`,
+    `    }`,
+    `    return selector;`,
+    `  };`,
+    `  const extractList = (...args: unknown[]): unknown[] => {`,
+    `    const payload = args.length >= 3 ? __dlLegacyExtractorPayload(args[1], raw) : raw;`,
+    `    const selector = args.length >= 3 ? args[2] : args[0];`,
+    `    const rows = __dlFindList(payload, selector);`,
+    `    const keys = __dlSelectorKeys(selector);`,
+    `    return keys ? __dlProjectListRows(rows, keys, payload) : rows;`,
+    `  };`,
+    `  const get = (path: string): unknown => __dlExtractedValue(result, path) ?? __dlFirstByPaths(raw, path);`,
+    `  let resolved: unknown;`,
+    `  try {`,
+    `    const extracted = extractor({ row, result, data: raw, raw, pick, extract, extractList, target: pick, get });`,
+    `    resolved = typeof extracted === 'function' ? (extracted as (outputData: unknown) => unknown)(__dlLegacyOutputData(result, raw)) : extracted;`,
+    `  } catch (error) {`,
+    `    return __dlExtractorFailure(error);`,
+    `  }`,
+    `  if (resolved && typeof resolved === 'object' && !Array.isArray(resolved) && alias in (resolved as Record<string, unknown>)) {`,
+    `    const aliasValue = (resolved as Record<string, unknown>)[alias];`,
+    `    return legacyEnvelope && __dlMeaningful(aliasValue) ? __dlLegacyMatchedEnvelope(aliasValue, raw) : aliasValue;`,
+    `  }`,
+    `  if (Array.isArray(resolved)) return __dlLegacyMatchedEnvelope(resolved, raw);`,
+    `  if ((resolved === null || resolved === undefined) && __dlErrorPayload(raw)) return raw;`,
+    `  if (legacyEnvelope && __dlMeaningful(resolved)) return __dlLegacyMatchedEnvelope(resolved, raw);`,
+    `  return resolved === undefined ? raw : resolved;`,
+    `}`,
+    ``,
+    `function __dlMergeContextRecord(existing: unknown, defaults: Record<string, unknown>): Record<string, unknown> {`,
+    `  if (!existing || typeof existing !== 'object' || Array.isArray(existing)) return { ...defaults };`,
+    `  return { ...defaults, ...(existing as Record<string, unknown>) };`,
+    `}`,
+    ``,
+    `function __dlRuntimePayload(tool: string, payload: Record<string, unknown>, row: Record<string, unknown>): Record<string, unknown> {`,
+    `  if (tool !== 'run_javascript') return payload;`,
+    `  return {`,
+    `    ...payload,`,
+    `    row: __dlMergeContextRecord(payload.row, row),`,
+    `    input: __dlMergeContextRecord(payload.input, row),`,
+    `    context: __dlMergeContextRecord(payload.context, row),`,
+    `  };`,
+    `}`,
+    ``,
+    `function __dlAliasCandidates(alias: string): string[] {`,
+    `  const aliases: string[] = [];`,
+    `  for (const candidate of [alias, alias.replace(/-/g, '_'), alias.replace(/_/g, '-')]) {`,
+    `    if (candidate && !aliases.includes(candidate)) aliases.push(candidate);`,
+    `  }`,
+    `  return aliases;`,
+    `}`,
+    ``,
+    `function __dlPlayResultValue(alias: string, result: unknown): unknown {`,
+    `  if (!result || typeof result !== 'object' || Array.isArray(result)) return result;`,
+    `  const record = result as Record<string, unknown>;`,
+    `  const aliases = __dlAliasCandidates(alias);`,
+    `  for (const key of aliases) {`,
+    `    if (key in record && __dlMeaningful(record[key])) return __dlScalarValue(record[key]);`,
     `  }`,
-    `  return extracted === undefined ? raw : extracted;`,
+    `  const values = Object.values(record).filter(__dlMeaningful);`,
+    `  if (values.length === 1) return __dlScalarValue(values[0]);`,
+    `  return result;`,
     `}`,
     ``,
-    `async function __dlRunCommand(input: { alias: string; callId: string; tool: string; payload: Record<string, unknown>; extract: ((args: { row: Record<string, unknown>; result: unknown; data: unknown; raw: unknown; pick: (paths: string[] | string) => unknown; extract: (paths: string[] | string) => unknown; target: (paths: string[] | string) => unknown }) => unknown) | null; runIf: ((row: Record<string, unknown>) => unknown) | null; row: Record<string, unknown>; stepCtx: { tools: { execute: (request: Record<string, unknown>) => Promise<unknown> } }; description?: string; force?: boolean }): Promise<unknown> {`,
+    `async function __dlRunCommand(input: { alias: string; callId: string; tool: string; payload: Record<string, unknown>; extract: ((args: __DlExtractorHelpers) => unknown) | null; runIf: ((row: Record<string, unknown>) => unknown) | null; row: Record<string, unknown>; stepCtx: { tools: { execute: (request: Record<string, unknown>) => Promise<unknown> } }; description?: string; force?: boolean; legacyEnvelope?: boolean }): Promise<unknown> {`,
     `  if (input.runIf) {`,
     `    const shouldRun = input.runIf(input.row);`,
     `    if (!shouldRun) return null;`,
     `  }`,
+    `  const payload = __dlRuntimePayload(input.tool, __dlTemplate(input.payload, input.row) as Record<string, unknown>, input.row);`,
     `  const result = await input.stepCtx.tools.execute({`,
     `    id: input.callId,`,
     `    tool: input.tool,`,
-    `    input: __dlTemplate(input.payload, input.row) as Record<string, unknown>,`,
+    `    input: payload,`,
     `    ...(input.description ? { description: input.description } : {}),`,
-    `    ...(input.force ? { staleAfterSeconds: 0 } : {}),`,
+    `    ...(input.force ? { staleAfterSeconds: 1 } : {}),`,
     `  });`,
-    `  return __dlExtract(input.alias, result, input.row, input.extract);`,
+    `  return __dlExtract(input.alias, result, input.row, input.extract, Boolean(input.legacyEnvelope));`,
     `}`
   ].join("\n");
 }
 
 // src/cli/commands/enrich.ts
+var ENRICH_EXPORT_PAGE_SIZE = 5e3;
+var EXIT_SERVER2 = 5;
+var ENRICH_DEBUG_T0 = Date.now();
 var PLAN_SHAPING_OPTION_NAMES = [
   "with",
   "withWaterfall",
   "minResults",
   "endWaterfall"
 ];
-var ENRICH_DEPRECATION_NOTICE = {
-  status: "deprecated",
-  message: "The enrich compatibility command is deprecated. This run generates a temporary .play.ts file and executes it through plays run.",
-  generatedPlayFile: "Temporary compatibility play file; deleted after the command exits.",
-  printGeneratedPlayCommand: "deepline enrich <same args> --dry-run > enrich.play.ts",
-  recommendedCommand: `deepline plays run enrich.play.ts --input '{"file":"<input.csv>"}'`
-};
-var ENRICH_DEPRECATION_TEXT = `${ENRICH_DEPRECATION_NOTICE.message} Print the generated play with: ${ENRICH_DEPRECATION_NOTICE.printGeneratedPlayCommand}. Then run: ${ENRICH_DEPRECATION_NOTICE.recommendedCommand}
-`;
 function optionWasProvided(args, ...flags) {
   return args.some(
     (arg) => flags.some((flag) => arg === flag || arg.startsWith(`${flag}=`))
@@ -14334,9 +15224,103 @@ function normalizeAlias2(value) {
 function hasPlanShapingArgs(args) {
   return optionWasProvided(args, "--with") || optionWasProvided(args, "--with-waterfall") || optionWasProvided(args, "--min-results") || optionWasProvided(args, "--end-waterfall");
 }
-function printDeprecationNotice(options) {
-  if (!options.json) {
-    process.stderr.write(ENRICH_DEPRECATION_TEXT);
+function enrichDebugEnabled(env = process.env) {
+  const raw = String(env.DEEPLINE_DEBUG_ENRICH ?? "").trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(raw)) {
+    return true;
+  }
+  const nodeEnv = String(env.NODE_ENV ?? "").trim().toLowerCase();
+  const deeplineEnv = String(env.DEEPLINE_ENV ?? "").trim().toLowerCase();
+  return nodeEnv === "development" || ["dev", "development"].includes(deeplineEnv);
+}
+function decodeStringLiteral(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "string" ? parsed : null;
+  } catch {
+    const quote = raw[0];
+    if ((quote === "'" || quote === '"') && raw[raw.length - 1] === quote) {
+      return raw.slice(1, -1).replace(/\\'/g, "'").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    return null;
+  }
+}
+function addStringArrayLiteralTargets(targets, arrayLiteral) {
+  for (const match of arrayLiteral.matchAll(/(["'])(?:\\.|(?!\1).)*\1/g)) {
+    const parsed = decodeStringLiteral(match[0] ?? "");
+    if (parsed?.trim()) {
+      targets.add(parsed.trim());
+    }
+  }
+}
+function extractExtractorTargetKeys(source) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const match of source.matchAll(/\bkeys\s*:\s*(\[[^\]]*\])/g)) {
+    addStringArrayLiteralTargets(targets, match[1] ?? "");
+  }
+  for (const match of source.matchAll(
+    /\btarget\s*\(\s*(["'][^"']+["'])\s*\)/g
+  )) {
+    const parsed = decodeStringLiteral(match[1] ?? "");
+    if (parsed?.trim()) {
+      targets.add(parsed.trim());
+    }
+  }
+  for (const match of source.matchAll(
+    /\bextract\s*\(\s*["'][^"']+["']\s*,[^,]*,\s*(["'][^"']+["'])\s*\)/g
+  )) {
+    const parsed = decodeStringLiteral(match[1] ?? "");
+    if (parsed?.trim()) {
+      targets.add(parsed.trim());
+    }
+  }
+  return [...targets].sort();
+}
+function flattenEnrichStepCommands(commands) {
+  const steps = [];
+  for (const command of commands) {
+    if ("with_waterfall" in command) {
+      steps.push(...flattenEnrichStepCommands(command.commands));
+      continue;
+    }
+    if (!command.disabled) {
+      steps.push(command);
+    }
+  }
+  return steps;
+}
+function buildEnrichDebugValidationLines(config) {
+  return flattenEnrichStepCommands(config.commands).filter(
+    (command) => typeof command.extract_js === "string" && command.extract_js.trim()
+  ).map((command) => {
+    const source = command.extract_js ?? "";
+    const targets = extractExtractorTargetKeys(source);
+    const mode = /\bextractList\s*\(/.test(source) ? "list" : "scalar";
+    return [
+      "validate extractor",
+      `column=${command.alias}`,
+      `tool_id=${command.tool || "(none)"}`,
+      `mode=${mode}`,
+      "has_result_sample=false",
+      "sample_keys=<none>",
+      `targets=${JSON.stringify(targets)}`
+    ].join(" ");
+  });
+}
+function emitEnrichDebug(message) {
+  if (!enrichDebugEnabled()) {
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const elapsedMs = Date.now() - ENRICH_DEBUG_T0;
+  process.stderr.write(
+    `[deepline:enrich] ${now.toISOString()} +${elapsedMs}ms ${message}
+`
+  );
+}
+function emitEnrichDebugValidationLines(config) {
+  for (const line of buildEnrichDebugValidationLines(config)) {
+    emitEnrichDebug(line);
   }
 }
 function expandAtFilePath(rawPath) {
@@ -14473,15 +15457,18 @@ async function buildPlanArgs(args) {
     "--csv",
     "--output",
     "--config",
+    "--name",
     "--rows",
-    "--with-force"
+    "--with-force",
+    "--timeout"
   ]);
   const localBooleanOptions = /* @__PURE__ */ new Set([
     "--dry-run",
     "--json",
     "--force",
     "--all",
-    "--in-place"
+    "--in-place",
+    "--no-open"
   ]);
   const planArgs = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -14547,7 +15534,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
   const output2 = resolve11(outputPath);
   if (input2 === output2) {
     throw new Error(
-      "--output must be a different path from --input. --in-place is not supported by this V2 enrich runner yet."
+      "--input and --output must be different files when not using --in-place."
     );
   }
   try {
@@ -14557,7 +15544,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
     ]);
     if (inputInfo.dev === outputInfo.dev && inputInfo.ino === outputInfo.ino) {
       throw new Error(
-        "--output must be a different file from --input. --in-place is not supported by this V2 enrich runner yet."
+        "--input and --output must be different files when not using --in-place."
       );
     }
   } catch (error) {
@@ -14571,6 +15558,18 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
     throw error;
   }
 }
+async function regularFileExists(path) {
+  try {
+    const info = await stat3(resolve11(path));
+    return info.isFile();
+  } catch (error) {
+    const code = error && typeof error === "object" ? error.code : void 0;
+    if (code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
 async function readConfig(path) {
   const source = await readFile3(resolve11(path), "utf8");
   let parsed;
@@ -14593,27 +15592,30 @@ function parseRows(value, all) {
   const trimmed = value.trim();
   const range = trimmed.match(/^(\d*)\s*:\s*(\d*)$/);
   if (range) {
-    if (!range[1] && !range[2]) {
+    if (!range[1]) {
       throw new Error(
-        "--rows must be a zero-based row number or end-exclusive range like 0:10."
+        "--rows must be a zero-based row number or inclusive range like 0:10."
       );
     }
     const start = range[1] ? Number.parseInt(range[1], 10) : 0;
     const end = range[2] ? Number.parseInt(range[2], 10) : null;
+    if (end !== null && end < start) {
+      throw new Error("Invalid --rows range: end must be >= start.");
+    }
     return { rowStart: start, rowEnd: end };
   }
   if (!/^\d+$/.test(trimmed)) {
     throw new Error(
-      "--rows must be a zero-based row number or end-exclusive range like 0:10."
+      "--rows must be a zero-based row number or inclusive range like 0:10."
     );
   }
   const single = Number.parseInt(trimmed, 10);
   if (!Number.isFinite(single) || single < 0) {
     throw new Error(
-      "--rows must be a zero-based row number or end-exclusive range like 0:10."
+      "--rows must be a zero-based row number or inclusive range like 0:10."
     );
   }
-  return { rowStart: single, rowEnd: single + 1 };
+  return { rowStart: single, rowEnd: single };
 }
 function summarizePlan(config, playSource) {
   const steps = [];
@@ -14692,76 +15694,715 @@ function parseWithForceAliases(values) {
       }
     }
   }
-  return aliases;
+  return aliases;
+}
+function resolveForceAliases(config, options) {
+  const { allAliases, waterfallGroups } = collectCommandAliases(config);
+  if (options.force) {
+    return new Set(allAliases);
+  }
+  const requested = parseWithForceAliases(options.withForce);
+  const unknown = [...requested].filter((alias) => !allAliases.has(alias));
+  if (unknown.length > 0) {
+    throw new Error(
+      `--with-force references unknown --with column alias(es): ${unknown.sort().join(", ")}.`
+    );
+  }
+  const resolved = /* @__PURE__ */ new Set();
+  for (const alias of requested) {
+    const children = waterfallGroups.get(alias);
+    if (children) {
+      resolved.add(alias);
+      for (const child of children) {
+        resolved.add(child);
+      }
+    } else {
+      resolved.add(alias);
+    }
+  }
+  return resolved;
+}
+function isPersistedFailureCell(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) {
+    return false;
+  }
+  if (cellFailureError(value)) {
+    return true;
+  }
+  return raw.includes("Error:") || raw.includes("Traceback");
+}
+function isPersistedFailureStatusCell(value) {
+  const raw = String(value ?? "").trim().toLowerCase();
+  return raw === "error" || raw === "failed" || raw === "failure";
+}
+function stripFailureCompanionSuffix(key) {
+  const lowerKey = key.toLowerCase();
+  for (const suffix of [".error", "__error"]) {
+    if (lowerKey.endsWith(suffix)) {
+      return { alias: key.slice(0, -suffix.length), kind: "error" };
+    }
+  }
+  for (const suffix of [".status", "__status"]) {
+    if (lowerKey.endsWith(suffix)) {
+      return { alias: key.slice(0, -suffix.length), kind: "status" };
+    }
+  }
+  return null;
+}
+function collectFailedInputAliases(config, sourceCsvPath, rows) {
+  const { scalarAliases } = collectCommandAliases(config);
+  if (scalarAliases.size === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const inputRows = readCsvRows(sourceCsvPath);
+  if (inputRows.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const start = rows.rowStart ?? 0;
+  const maxEnd = Math.max(start, inputRows.length - 1);
+  const inclusiveEnd = rows.rowEnd === null || rows.rowEnd === void 0 ? maxEnd : Math.min(maxEnd, rows.rowEnd);
+  const failedAliases = /* @__PURE__ */ new Set();
+  for (let index = start; index <= inclusiveEnd; index += 1) {
+    const row = inputRows[index];
+    if (!row) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(row)) {
+      const alias = normalizeAlias2(key);
+      if (scalarAliases.has(alias) && isPersistedFailureCell(value)) {
+        failedAliases.add(alias);
+        continue;
+      }
+      const companion = stripFailureCompanionSuffix(key);
+      if (!companion) {
+        continue;
+      }
+      const companionAlias = normalizeAlias2(companion.alias);
+      if (!scalarAliases.has(companionAlias)) {
+        continue;
+      }
+      if (companion.kind === "error" ? isPersistedFailureCell(value) : isPersistedFailureStatusCell(value)) {
+        failedAliases.add(companionAlias);
+      }
+    }
+  }
+  return failedAliases;
+}
+function parseJsonOutput(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const start = trimmed.lastIndexOf("\n{");
+    if (start >= 0) {
+      return JSON.parse(trimmed.slice(start + 1));
+    }
+    throw new Error(
+      "The generated play completed but did not emit parseable JSON."
+    );
+  }
+}
+function extractRunIdFromPlayOutput(stdout) {
+  const runIdLine = stdout.match(/^\s*run id:\s*(play\/\S+\/run\/\S+)\s*$/im);
+  if (runIdLine?.[1]) {
+    return runIdLine[1];
+  }
+  return stdout.match(/\b(play\/\S+\/run\/\S+)/)?.[1] ?? null;
+}
+async function resolveWatchedGeneratedPlayStatus(input2) {
+  const runId = extractRunIdFromPlayOutput(input2.stdout);
+  if (!runId) {
+    if (input2.exitCode === 0) {
+      throw new Error(
+        "The generated play completed but did not print a run id to inspect."
+      );
+    }
+    return null;
+  }
+  return input2.client.runs.get(runId, { full: true });
+}
+function isRecord6(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function captureStdout(run, options = {}) {
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  let stdout = "";
+  process.stdout.write = ((chunk, ..._args) => {
+    stdout += typeof chunk === "string" ? chunk : String(chunk);
+    if (options.passthrough) {
+      return originalWrite(typeof chunk === "string" ? chunk : String(chunk));
+    }
+    return true;
+  });
+  try {
+    const result = await run();
+    return { result, stdout };
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+}
+function isPlayStartStreamEndedError(error) {
+  return error instanceof DeeplineError && error.code === "PLAY_START_STREAM_ENDED" || error instanceof Error && error.message.includes(
+    "Play start stream ended before a terminal status"
+  );
+}
+async function runGeneratedEnrichPlay(runArgs, options = {}) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      return await captureStdout(() => handlePlayRun(runArgs), {
+        passthrough: options.passthroughStdout
+      });
+    } catch (error) {
+      if (attempt === 0 && isPlayStartStreamEndedError(error)) {
+        await new Promise((resolve15) => setTimeout(resolve15, 250));
+        continue;
+      }
+      throw error;
+    }
+  }
+  return captureStdout(() => handlePlayRun(runArgs), {
+    passthrough: options.passthroughStdout
+  });
+}
+async function writeOutputCsv(outputPath, status, options) {
+  let rowsInfo = extractCanonicalRowsInfo(status);
+  if (!rowsInfo) {
+    throw new Error("The generated play did not return row-shaped output.");
+  }
+  if (!rowsInfo.complete && options?.client) {
+    rowsInfo = await fetchBackingRowsForCsvExport({
+      client: options.client,
+      status,
+      rowsInfo
+    }) ?? rowsInfo;
+  }
+  assertCompleteRowsForCsvExport(rowsInfo, status, outputPath);
+  const merged = mergeRowsForCsvExport(rowsInfo.rows, options);
+  const columns = orderEnrichCsvColumns(
+    dataExportColumns(merged.rows, [
+      ...merged.preferredColumns,
+      ...rowsInfo.columns
+    ]),
+    options?.config
+  );
+  await writeFile4(
+    resolve11(outputPath),
+    csvStringFromRows(merged.rows, columns),
+    "utf8"
+  );
+  return {
+    rows: merged.rows.length,
+    path: resolve11(outputPath),
+    enrichedRows: rowsInfo.rows
+  };
+}
+function recordField(value, key) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value[key] : void 0;
+}
+function extractRunId(status) {
+  const candidates = [
+    recordField(status, "runId"),
+    recordField(recordField(status, "run"), "id")
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return null;
+}
+function extractPlayName2(status) {
+  const run = recordField(status, "run");
+  const candidates = [
+    recordField(status, "playName"),
+    recordField(status, "name"),
+    recordField(run, "playName"),
+    recordField(run, "name")
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return null;
+}
+function exportableSheetRow2(row) {
+  if (!row || typeof row !== "object" || Array.isArray(row)) {
+    return null;
+  }
+  const record = row;
+  const data = record.data;
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    return data;
+  }
+  const fallback = { ...record };
+  for (const key of [
+    "key",
+    "status",
+    "cellMeta",
+    "inputIndex",
+    "runId",
+    "error",
+    "stage",
+    "provider",
+    "seq",
+    "createdAt",
+    "updatedAt"
+  ]) {
+    delete fallback[key];
+  }
+  return fallback;
+}
+function collectHardFailureAliases(config) {
+  const aliases = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const command of config.commands) {
+    if ("with_waterfall" in command) {
+      continue;
+    }
+    if (command.disabled) {
+      continue;
+    }
+    const alias = command.alias.trim();
+    if (!alias || seen.has(alias)) {
+      continue;
+    }
+    seen.add(alias);
+    aliases.push(alias);
+  }
+  return aliases;
+}
+function cellFailureError(value) {
+  const parsed = parseMaybeJsonObject(value);
+  if (!isRecord6(parsed)) {
+    return null;
+  }
+  const status = typeof parsed.status === "string" ? parsed.status.trim().toLowerCase() : "";
+  const directError = typeof parsed.error === "string" ? parsed.error.trim() : typeof parsed.last_error === "string" ? parsed.last_error.trim() : "";
+  const result = isRecord6(parsed.result) ? parsed.result : null;
+  const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
+  if (!directError && !resultError && status !== "error" && status !== "failed") {
+    return null;
+  }
+  const message = directError || resultError || `Column status: ${status}`;
+  return {
+    message,
+    ...typeof parsed.operation === "string" && parsed.operation.trim() ? { operation: parsed.operation.trim() } : {},
+    ...typeof parsed.provider === "string" && parsed.provider.trim() ? { provider: parsed.provider.trim() } : {}
+  };
+}
+function buildEnrichWaterfallSummaryLines(config, rows) {
+  if (rows.length === 0) {
+    return [];
+  }
+  const lines = [];
+  for (const command of config.commands) {
+    if (!("with_waterfall" in command)) {
+      continue;
+    }
+    for (const child of command.commands) {
+      if ("with_waterfall" in child || child.disabled) {
+        continue;
+      }
+      const failures = rows.filter(
+        (row) => cellFailureError(row[child.alias])
+      ).length;
+      if (failures > 0) {
+        lines.push(
+          `Column '${child.alias}' had high failure rate (${failures}/${rows.length}); continuing waterfall group '${command.with_waterfall}'.`
+        );
+      }
+    }
+  }
+  return lines;
+}
+function collectEnrichFailureJobs(input2) {
+  const aliases = collectHardFailureAliases(input2.config);
+  if (aliases.length === 0 || input2.rows.length === 0) {
+    return [];
+  }
+  const rowOffset = input2.rowStart ?? 0;
+  const jobs = [];
+  input2.rows.forEach((row, rowIndex) => {
+    aliases.forEach((alias, aliasIndex) => {
+      const failure = cellFailureError(row[alias]);
+      if (!failure) {
+        return;
+      }
+      const rowId = rowOffset + rowIndex;
+      jobs.push({
+        job_id: `row-${rowId}-${alias}`,
+        row_id: rowId,
+        col_index: aliasIndex,
+        column: alias,
+        status: "failed",
+        last_error: failure.message,
+        error: failure.message,
+        ...failure.operation ? { operation: failure.operation } : {},
+        ...failure.provider ? { provider: failure.provider } : {}
+      });
+    });
+  });
+  return jobs;
+}
+function summarizeFailedJobError(value) {
+  const text = String(value ?? "").trim();
+  return text.length > 500 ? `${text.slice(0, 497)}...` : text;
+}
+function formatFailureReportCommand(reportPath) {
+  const quoted = reportPath.replace(/'/g, `'\\''`);
+  return `Inspect failed jobs: jq -r '.jobs[] | [.job_id,.row_id,.col_index,.column,.status,.last_error] | @tsv' '${quoted}'`;
+}
+async function persistEnrichFailureReport(input2) {
+  if (input2.jobs.length === 0) {
+    return null;
+  }
+  const stateDir = join8(homedir4(), ".local", "deepline", "runtime", "state");
+  await mkdir4(stateDir, { recursive: true });
+  const reportPath = join8(
+    stateDir,
+    `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
+  );
+  const report = {
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    api_url: input2.apiUrl,
+    output_csv: input2.outputPath ?? "",
+    summary: {
+      failed_count: input2.jobs.length,
+      canceled_count: 0,
+      pending_count: 0,
+      missing_count: 0,
+      total_jobs: input2.jobs.length
+    },
+    jobs: input2.jobs,
+    failed_jobs: input2.jobs,
+    canceled_jobs: [],
+    pending_jobs: [],
+    missing_job_ids: []
+  };
+  if (input2.rows.rowStart !== null && input2.rows.rowEnd !== null) {
+    report.rows = { start: input2.rows.rowStart, end: input2.rows.rowEnd };
+  }
+  await writeFile4(reportPath, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  return reportPath;
+}
+async function maybeEmitEnrichFailureReport(input2) {
+  const jobs = collectEnrichFailureJobs({
+    config: input2.config,
+    rows: input2.rows,
+    rowStart: input2.rowRange.rowStart
+  });
+  if (jobs.length === 0) {
+    return null;
+  }
+  const reportPath = await persistEnrichFailureReport({
+    jobs,
+    apiUrl: input2.client.baseUrl,
+    outputPath: input2.outputPath,
+    rows: input2.rowRange
+  });
+  process.stderr.write("Execution failed.\n");
+  process.stderr.write("Failure preview (up to 5 failed jobs):\n");
+  process.stderr.write("job_id	row_id	col_index	column	status	error\n");
+  for (const job of jobs.slice(0, 5)) {
+    process.stderr.write(
+      `${job.job_id}	${job.row_id}	${job.col_index}	${job.column}	${job.status}	${summarizeFailedJobError(job.last_error)}
+`
+    );
+  }
+  if (jobs.length > 5) {
+    process.stderr.write(`Showing 5 of ${jobs.length} failed jobs.
+`);
+  }
+  if (reportPath) {
+    process.stderr.write(`Full failure report: ${reportPath}
+`);
+    process.stderr.write(`${formatFailureReportCommand(reportPath)}
+`);
+    process.stderr.write("Enrichment failed. See failure report above.\n");
+    return { path: reportPath, jobs };
+  }
+  process.stderr.write("Enrichment failed.\n");
+  return { path: "", jobs };
+}
+function mergePreferredColumns(preferredColumns, rows) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const column of preferredColumns) {
+    if (!column || seen.has(column)) {
+      continue;
+    }
+    seen.add(column);
+    columns.push(column);
+  }
+  for (const row of rows) {
+    for (const column of Object.keys(row)) {
+      if (seen.has(column)) {
+        continue;
+      }
+      seen.add(column);
+      columns.push(column);
+    }
+  }
+  return columns;
+}
+async function fetchBackingRowsForCsvExport(input2) {
+  const runId = extractRunId(input2.status);
+  const playName = extractPlayName2(input2.status);
+  const tableNamespace = input2.rowsInfo.tableNamespace?.trim();
+  if (!runId || !playName || !tableNamespace) {
+    return null;
+  }
+  const sheetRows = [];
+  let offset = 0;
+  let expectedTotal = input2.rowsInfo.totalRows;
+  while (true) {
+    const page = await input2.client.runs.exportDatasetRows({
+      playName,
+      tableNamespace,
+      runId,
+      limit: ENRICH_EXPORT_PAGE_SIZE,
+      offset
+    });
+    sheetRows.push(...page.rows);
+    const summaryTotal = page.summary?.stats?.total;
+    if (typeof summaryTotal === "number" && Number.isFinite(summaryTotal)) {
+      expectedTotal = Math.max(expectedTotal, Math.trunc(summaryTotal));
+    }
+    if (page.rows.length < ENRICH_EXPORT_PAGE_SIZE || sheetRows.length >= expectedTotal) {
+      break;
+    }
+    offset += page.rows.length;
+  }
+  const rows = sheetRows.map(exportableSheetRow2).filter((row) => Boolean(row));
+  if (rows.length < input2.rowsInfo.totalRows) {
+    return null;
+  }
+  return {
+    ...input2.rowsInfo,
+    rows,
+    columns: mergePreferredColumns(
+      input2.rowsInfo.columnsExplicit ? input2.rowsInfo.columns : [],
+      rows
+    ),
+    totalRows: rows.length,
+    complete: true,
+    source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
+  };
+}
+function mergeRowsForCsvExport(enrichedRows, options) {
+  const rows = dataExportRows(normalizeEnrichRowsForCsvExport(enrichedRows));
+  const range = options?.rows;
+  if (range?.rowStart === null || range?.rowStart === void 0) {
+    return { rows, preferredColumns: [] };
+  }
+  if (!options?.sourceCsvPath) {
+    return { rows, preferredColumns: [] };
+  }
+  const parsedBaseRows = readCsvRows(options.sourceCsvPath);
+  const preferredColumns = Object.keys(parsedBaseRows[0] ?? {});
+  const baseRows = parsedBaseRows.map(
+    (row) => ({ ...row })
+  );
+  const start = Math.max(0, range.rowStart);
+  const maxEnd = Math.max(start, baseRows.length - 1);
+  const inclusiveEnd = range.rowEnd === null ? maxEnd : Math.min(maxEnd, range.rowEnd);
+  const merged = [...baseRows];
+  let selectedIndex = 0;
+  for (let rowIndex = start; rowIndex <= inclusiveEnd; rowIndex += 1) {
+    const enriched = rows[selectedIndex++];
+    if (!enriched) {
+      break;
+    }
+    const base = merged[rowIndex] ?? {};
+    merged[rowIndex] = {
+      ...base,
+      ...enriched
+    };
+    const metadata = mergeLegacyMetadataCell(
+      base._metadata,
+      enriched._metadata
+    );
+    if (metadata !== void 0) {
+      merged[rowIndex]._metadata = metadata;
+    }
+  }
+  return { rows: merged, preferredColumns };
+}
+function collectConfigScalarAliasOrder(config) {
+  const aliases = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addAlias = (alias) => {
+    const normalized = normalizeAlias2(alias);
+    if (!normalized || seen.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    aliases.push(alias);
+  };
+  for (const command of config.commands) {
+    if ("with_waterfall" in command) {
+      for (const child of command.commands) {
+        if ("with_waterfall" in child || child.disabled) {
+          continue;
+        }
+        addAlias(child.alias);
+      }
+      continue;
+    }
+    if (!command.disabled) {
+      addAlias(command.alias);
+    }
+  }
+  return aliases;
+}
+function orderEnrichCsvColumns(columns, config) {
+  if (!config || columns.length < 2) {
+    return columns;
+  }
+  const aliasOrder = collectConfigScalarAliasOrder(config);
+  if (aliasOrder.length < 2) {
+    return columns;
+  }
+  const normalizedAliasOrder = aliasOrder.map(normalizeAlias2);
+  const requestedColumnByAlias = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    const normalizedColumn = normalizeAlias2(column);
+    if (normalizedAliasOrder.includes(normalizedColumn) && !requestedColumnByAlias.has(normalizedColumn)) {
+      requestedColumnByAlias.set(normalizedColumn, column);
+    }
+  }
+  const requestedColumns = normalizedAliasOrder.map((alias) => requestedColumnByAlias.get(alias)).filter((column) => Boolean(column));
+  if (requestedColumns.length < 2) {
+    return columns;
+  }
+  const requestedSet = new Set(requestedColumns);
+  const firstRequestedIndex = columns.findIndex(
+    (column) => requestedSet.has(column)
+  );
+  if (firstRequestedIndex < 0) {
+    return columns;
+  }
+  const withoutRequested = columns.filter(
+    (column) => !requestedSet.has(column)
+  );
+  withoutRequested.splice(firstRequestedIndex, 0, ...requestedColumns);
+  return withoutRequested;
+}
+function isNonEmptyCsvCell(value) {
+  return value !== null && value !== void 0 && String(value).trim() !== "";
+}
+function normalizeEnrichRowsForCsvExport(rows) {
+  return rows.map((row) => {
+    const metadata = legacyMetadataFromRow(row);
+    if (!metadata) {
+      return row;
+    }
+    const normalized = { ...row, _metadata: metadata };
+    delete normalized.metadata;
+    delete normalized["metadata.columns"];
+    delete normalized.metadata__columns;
+    for (const key of Object.keys(normalized)) {
+      if (key.startsWith("metadata.columns.") || key.startsWith("metadata__columns.")) {
+        delete normalized[key];
+      }
+    }
+    return normalized;
+  });
+}
+function legacyMetadataFromRow(row) {
+  const direct = parseLegacyMetadataCell(row._metadata);
+  if (direct && isRecord6(direct.columns)) {
+    return direct;
+  }
+  const relocated = parseLegacyMetadataCell(row.metadata);
+  if (relocated && isRecord6(relocated.columns)) {
+    return relocated;
+  }
+  const flattenedColumns = parseLegacyMetadataCell(row["metadata.columns"]);
+  if (flattenedColumns) {
+    return { columns: flattenedColumns };
+  }
+  const flattenedUnderscoreColumns = parseLegacyMetadataCell(
+    row.metadata__columns
+  );
+  if (flattenedUnderscoreColumns) {
+    return { columns: flattenedUnderscoreColumns };
+  }
+  return null;
+}
+function parseLegacyMetadataCell(value) {
+  const parsed = parseMaybeJsonObject(value);
+  if (isRecord6(parsed)) {
+    return parsed;
+  }
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const candidates = [trimmed];
+  if (trimmed.includes('\\"')) {
+    candidates.push(trimmed.replace(/\\"/g, '"'));
+  }
+  for (const candidate of candidates) {
+    try {
+      const decoded = JSON.parse(candidate);
+      if (isRecord6(decoded)) {
+        return decoded;
+      }
+      if (typeof decoded === "string") {
+        const nested = JSON.parse(decoded);
+        if (isRecord6(nested)) {
+          return nested;
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
 }
-function resolveForceAliases(config, options) {
-  const { allAliases, scalarAliases, waterfallGroups } = collectCommandAliases(config);
-  if (options.force) {
-    return new Set(scalarAliases);
+function mergeLegacyMetadataRecords(base, enriched) {
+  const baseColumns = isRecord6(base.columns) ? base.columns : null;
+  const enrichedColumns = isRecord6(enriched.columns) ? enriched.columns : null;
+  const merged = {
+    ...base,
+    ...enriched
+  };
+  if (baseColumns || enrichedColumns) {
+    merged.columns = {
+      ...baseColumns ?? {},
+      ...enrichedColumns ?? {}
+    };
   }
-  const requested = parseWithForceAliases(options.withForce);
-  const unknown = [...requested].filter((alias) => !allAliases.has(alias));
-  if (unknown.length > 0) {
-    throw new Error(
-      `--with-force references unknown --with column alias(es): ${unknown.sort().join(", ")}.`
+  return merged;
+}
+function mergeLegacyMetadataCell(base, enriched) {
+  const baseRecord = parseLegacyMetadataCell(base);
+  const enrichedRecord = parseLegacyMetadataCell(enriched);
+  if (baseRecord && enrichedRecord) {
+    return JSON.stringify(
+      mergeLegacyMetadataRecords(baseRecord, enrichedRecord)
     );
   }
-  const resolved = /* @__PURE__ */ new Set();
-  for (const alias of requested) {
-    const children = waterfallGroups.get(alias);
-    if (children) {
-      for (const child of children) {
-        resolved.add(child);
-      }
-    } else {
-      resolved.add(alias);
-    }
+  if (enrichedRecord) {
+    return JSON.stringify(enrichedRecord);
   }
-  return resolved;
-}
-function parseJsonOutput(stdout) {
-  const trimmed = stdout.trim();
-  if (!trimmed) return null;
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    const start = trimmed.lastIndexOf("\n{");
-    if (start >= 0) {
-      return JSON.parse(trimmed.slice(start + 1));
-    }
-    throw new Error(
-      "The generated play completed but did not emit parseable JSON."
-    );
+  if (baseRecord) {
+    return JSON.stringify(baseRecord);
   }
-}
-async function captureStdout(run) {
-  const originalWrite = process.stdout.write.bind(process.stdout);
-  let stdout = "";
-  process.stdout.write = ((chunk, ..._args) => {
-    stdout += typeof chunk === "string" ? chunk : String(chunk);
-    return true;
-  });
-  try {
-    const result = await run();
-    return { result, stdout };
-  } finally {
-    process.stdout.write = originalWrite;
+  if (isNonEmptyCsvCell(enriched)) {
+    return enriched;
   }
-}
-async function writeOutputCsv(outputPath, status) {
-  const rowsInfo = extractCanonicalRowsInfo(status);
-  if (!rowsInfo) {
-    throw new Error("The generated play did not return row-shaped output.");
+  if (isNonEmptyCsvCell(base)) {
+    return base;
   }
-  assertCompleteRowsForCsvExport(rowsInfo, status, outputPath);
-  const rows = dataExportRows(rowsInfo.rows);
-  const columns = dataExportColumns(rows, rowsInfo.columns);
-  await writeFile4(
-    resolve11(outputPath),
-    csvStringFromRows(rows, columns),
-    "utf8"
-  );
-  return { rows: rows.length, path: resolve11(outputPath) };
+  return void 0;
 }
 function assertCompleteRowsForCsvExport(rowsInfo, status, outputPath) {
   if (rowsInfo.complete) {
@@ -14782,13 +16423,26 @@ async function compileConfig(input2) {
       );
     }
     const config = await readConfig(input2.options.config);
-    return (await input2.client.compileEnrichPlan({ config })).config;
+    return (await input2.client.compileEnrichPlan({
+      config,
+      native_play_materialization: "inline_prebuilt"
+    })).config;
   }
   const planArgs = await buildPlanArgs(input2.args);
-  return (await input2.client.compileEnrichPlan({ plan_args: planArgs })).config;
+  return (await input2.client.compileEnrichPlan({
+    plan_args: planArgs,
+    native_play_materialization: "inline_prebuilt"
+  })).config;
 }
 function registerEnrichCommand(program) {
-  program.command("enrich").allowUnknownOption(true).description("Run v1-style CSV enrichment through the V2 play runner.").option("--input <path>", "Input CSV path.").option("--csv <path>", "Alias for --input.").option("--output <path>", "Output CSV path.").option("--config <path>", "JSON enrich config.").option(
+  program.command("enrich").allowUnknownOption(true).description("Run v1-style CSV enrichment through the V2 play runner.").configureHelp({
+    optionTerm(option) {
+      return option.long === "--timeout" ? "--timeout SECONDS" : option.flags;
+    }
+  }).option("--input <path>", "Input CSV path.").option("--csv <path>", "Alias for --input.").option("--output <path>", "Output CSV path.").option("--config <path>", "JSON enrich config.").requiredOption(
+    "--name <name>",
+    "Name for the compiled enrich play. Reuse a name to keep iterating on the same play; use a new name for a distinct enrichment so runs stay separate in the run ledger and share URLs."
+  ).option(
     "--with <json>",
     "Add a scalar enrich command.",
     (value, previous = []) => [...previous, value]
@@ -14801,70 +16455,77 @@ function registerEnrichCommand(program) {
     "Minimum list results for the current waterfall."
   ).option("--end-waterfall", "End the current waterfall group.").option(
     "--rows <range>",
-    "Zero-based row number or end-exclusive range, e.g. 0:10."
+    "Zero-based row number or inclusive range, e.g. 0:10."
   ).option("--all", "Run all rows.").option(
     "--dry-run",
     "Compile and print the generated plan without starting a run."
-  ).option("--json", "Emit JSON.").option("--force", "Force rerun for all enrich aliases.").option(
+  ).option("--json", "Emit JSON.").option("--no-open", "Do not open the play page in a browser.").option("--force", "Force rerun for all enrich aliases.").option(
     "--with-force <aliases>",
     "Force rerun for selected aliases.",
     (value, previous = []) => [...previous, value]
-  ).option(
-    "--in-place",
-    "Not supported by the V2 enrich compatibility runner yet."
+  ).option("--in-place", "Write enriched output back to the input CSV.").option(
+    "--timeout <SECONDS>",
+    "API read timeout for enrich status/API requests."
   ).action(async (options, _command) => {
-    if (options.inPlace) {
-      throw new Error(
-        "--in-place is not supported by this V2 enrich runner yet. Use --output instead."
-      );
+    if (options.inPlace && options.dryRun) {
+      throw new Error("--in-place is not supported with --dry-run.");
     }
     const inputCsv = options.input ?? options.csv;
     if (!inputCsv) {
       throw new Error("Missing required --input <csv> (or --csv <csv>).");
     }
     await assertInputCsvExists(inputCsv);
-    if (options.output) {
+    if (options.output && !options.inPlace) {
       await assertSafeOutputPath(inputCsv, options.output);
     }
     if (!options.config && !hasPlanShapingArgs(currentEnrichArgs())) {
       throw new Error("Pass --config or at least one --with enrich spec.");
     }
-    const client = new DeeplineClient();
+    const client2 = new DeeplineClient();
     const args = currentEnrichArgs();
-    const config = await compileConfig({ client, args, options });
-    const forceAliases = resolveForceAliases(config, options);
-    const playSource = compileEnrichConfigToPlaySource(config, {
-      forceAliases
-    });
-    const summary = summarizePlan(config, playSource);
-    printDeprecationNotice(options);
+    const config = await compileConfig({ client: client2, args, options });
+    emitEnrichDebugValidationLines(config);
     if (options.dryRun) {
+      const forceAliases2 = resolveForceAliases(config, options);
+      const playSource2 = compileEnrichConfigToPlaySource(config, {
+        forceAliases: forceAliases2,
+        playName: options.name
+      });
+      const summary = summarizePlan(config, playSource2);
       if (options.json) {
         printJson({
           dryRun: true,
-          deprecation: ENRICH_DEPRECATION_NOTICE,
           input: resolve11(inputCsv),
           output: options.output ? resolve11(options.output) : null,
           plan: summary
         });
         return;
       }
-      process.stdout.write(`${playSource}
+      process.stdout.write(`${playSource2}
 `);
       return;
     }
     const rows = parseRows(options.rows, options.all);
-    if (options.output && options.rows) {
-      throw new Error(
-        "CSV export with --rows is not supported yet because it would write only the selected rows. Run without --rows or omit --output."
-      );
+    const outputPath = options.inPlace ? inputCsv : options.output;
+    const sourceCsvPath = !options.inPlace && outputPath && await regularFileExists(outputPath) ? outputPath : inputCsv;
+    const forceAliases = resolveForceAliases(config, options);
+    for (const alias of collectFailedInputAliases(
+      config,
+      sourceCsvPath,
+      rows
+    )) {
+      forceAliases.add(alias);
     }
+    const playSource = compileEnrichConfigToPlaySource(config, {
+      forceAliases,
+      playName: options.name
+    });
     const tempDir = await mkdtemp(join8(tmpdir3(), "deepline-enrich-play-"));
     const tempPlay = join8(tempDir, "deepline-enrich.play.ts");
     try {
       await writeFile4(tempPlay, playSource, "utf8");
       const runtimeInput = {
-        file: resolve11(inputCsv),
+        file: resolve11(sourceCsvPath),
         ...rows.rowStart !== null ? { rowStart: rows.rowStart } : {},
         ...rows.rowEnd !== null ? { rowEnd: rows.rowEnd } : {}
       };
@@ -14873,40 +16534,91 @@ function registerEnrichCommand(program) {
         tempPlay,
         "--input",
         JSON.stringify(runtimeInput),
-        "--watch",
-        "--no-open",
-        "--json"
+        "--watch"
       ];
-      const captured = await captureStdout(() => handlePlayRun(runArgs));
-      const status = parseJsonOutput(captured.stdout);
+      if (options.noOpen) {
+        runArgs.push("--no-open");
+      }
+      if (options.json) {
+        runArgs.push("--json");
+      } else {
+        runArgs.push("--logs");
+      }
+      const timeoutSeconds = options.timeout ? Number.parseInt(options.timeout, 10) : null;
+      if (timeoutSeconds !== null && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0) {
+        runArgs.push("--tail-timeout-ms", String(timeoutSeconds * 1e3));
+      }
+      const captured = await runGeneratedEnrichPlay(runArgs, {
+        passthroughStdout: !options.json
+      });
+      const status = options.json ? parseJsonOutput(captured.stdout) : await resolveWatchedGeneratedPlayStatus({
+        client: client2,
+        stdout: captured.stdout,
+        exitCode: captured.result
+      });
       if (captured.result !== 0) {
         if (options.json) {
           printJson({
-            deprecation: ENRICH_DEPRECATION_NOTICE,
             result: status
           });
-        } else {
-          process.stdout.write(captured.stdout);
         }
         process.exitCode = captured.result;
         return;
       }
-      const exportResult = options.output ? await writeOutputCsv(options.output, status) : null;
+      const exportResult = outputPath ? await writeOutputCsv(outputPath, status, {
+        client: client2,
+        config,
+        sourceCsvPath,
+        rows
+      }) : null;
+      const rowsForFailureReport = exportResult?.enrichedRows ?? extractCanonicalRowsInfo(status)?.rows ?? [];
       if (options.json) {
+        const failureReport2 = await maybeEmitEnrichFailureReport({
+          config,
+          rows: rowsForFailureReport,
+          rowRange: rows,
+          client: client2,
+          outputPath: exportResult?.path ?? outputPath ?? null
+        });
         printJson({
-          ok: true,
-          deprecation: ENRICH_DEPRECATION_NOTICE,
+          ok: !failureReport2,
           run: status,
-          output: exportResult
+          output: exportResult ? { rows: exportResult.rows, path: exportResult.path } : null,
+          ...failureReport2 ? {
+            failure_report: {
+              path: failureReport2.path,
+              jobs: failureReport2.jobs.length
+            }
+          } : {}
         });
+        if (failureReport2) {
+          process.exitCode = EXIT_SERVER2;
+        }
         return;
       }
-      process.stdout.write(captured.stdout);
       if (exportResult) {
         process.stderr.write(
           `Wrote ${exportResult.rows} row(s) to ${exportResult.path}
 `
         );
+        const waterfallSummaryLines = buildEnrichWaterfallSummaryLines(
+          config,
+          exportResult.enrichedRows
+        );
+        if (waterfallSummaryLines.length > 0) {
+          process.stdout.write(`${waterfallSummaryLines.join("\n")}
+`);
+        }
+      }
+      const failureReport = await maybeEmitEnrichFailureReport({
+        config,
+        rows: rowsForFailureReport,
+        rowRange: rows,
+        client: client2,
+        outputPath: exportResult?.path ?? outputPath ?? null
+      });
+      if (failureReport) {
+        process.exitCode = EXIT_SERVER2;
       }
     } finally {
       await rm(tempDir, { recursive: true, force: true });
@@ -15146,7 +16858,7 @@ async function readHiddenLine(prompt) {
   if (typeof input.setRawMode === "function") input.setRawMode(true);
   let value = "";
   input.resume();
-  return await new Promise((resolve14, reject) => {
+  return await new Promise((resolve15, reject) => {
     let settled = false;
     const cleanup = () => {
       input.off("data", onData);
@@ -15161,7 +16873,7 @@ async function readHiddenLine(prompt) {
       settled = true;
       output.write("\n");
       cleanup();
-      resolve14(line);
+      resolve15(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -15225,8 +16937,8 @@ function preventShellHistoryLeak(forbidden) {
   }
 }
 async function handleList(options) {
-  const client = new DeeplineClient();
-  const secrets = await client.listSecrets();
+  const client2 = new DeeplineClient();
+  const secrets = await client2.listSecrets();
   printCommandEnvelope(
     {
       secrets,
@@ -15245,8 +16957,8 @@ async function handleList(options) {
 }
 async function handleCheck(nameInput, options) {
   const name = normalizeSecretName(nameInput);
-  const client = new DeeplineClient();
-  const secret = await client.checkSecret(name);
+  const client2 = new DeeplineClient();
+  const secret = await client2.checkSecret(name);
   printCommandEnvelope(
     {
       ok: Boolean(secret),
@@ -15560,12 +17272,12 @@ function matchesGrepQuery(value, query, mode) {
   return terms.every((term) => haystack.includes(term));
 }
 async function listTools(args) {
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   const categoryArgIndex = args.findIndex((arg) => arg === "--categories");
   const categoryFilter = categoryArgIndex >= 0 ? args[categoryArgIndex + 1] : "";
   const compact = !args.includes("--full");
   const requestedCategories = categoryFilter ? categoryFilter.split(",").map((item) => item.trim()).filter(Boolean) : [];
-  const items = (await client.listTools({
+  const items = (await client2.listTools({
     ...categoryFilter ? { categories: categoryFilter } : {},
     compact
   })).map(toListedTool).filter(
@@ -15612,8 +17324,8 @@ async function searchTools(queryInput, options = {}) {
     console.error("Usage: deepline tools search <query> [--json]");
     return 1;
   }
-  const client = new DeeplineClient();
-  const result = await client.searchTools({
+  const client2 = new DeeplineClient();
+  const result = await client2.searchTools({
     query,
     categories: options.categories,
     searchTerms: options.searchTerms,
@@ -15636,10 +17348,10 @@ async function grepTools(queryInput, options = {}) {
     console.error("Usage: deepline tools grep <query> [--json]");
     return 1;
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   const requestedCategories = options.categories ? options.categories.split(",").map((item) => item.trim()).filter(Boolean) : [];
   const mode = options.mode ?? "all";
-  const tools = (await client.listTools({
+  const tools = (await client2.listTools({
     grep: query,
     grepMode: mode,
     ...options.categories ? { categories: options.categories } : {},
@@ -15709,12 +17421,12 @@ function compactTool(tool) {
 function playIdentifiers(play) {
   return [play.name, play.reference, ...play.aliases ?? []].filter((value) => Boolean(value?.trim())).map((value) => value.trim());
 }
-async function findPlayForToolId(client, toolId) {
+async function findPlayForToolId(client2, toolId) {
   const requested = toolId.trim();
   if (!requested) {
     return null;
   }
-  const plays = await client.searchPlays({ query: requested, compact: true });
+  const plays = await client2.searchPlays({ query: requested, compact: true });
   return plays.find((play) => playIdentifiers(play).includes(requested)) ?? null;
 }
 function playAliasToolErrorMessage(toolId, play) {
@@ -15729,7 +17441,7 @@ function printPlayAliasToolError(toolId, play) {
 function isPlayLikeTool(tool) {
   const record = tool;
   if (record.isPlay === true || record.is_play === true) return true;
-  const playExpansion = recordField(record, "playExpansion", "play_expansion");
+  const playExpansion = recordField2(record, "playExpansion", "play_expansion");
   if (Object.keys(playExpansion).length > 0) return true;
   const toolId = typeof record.toolId === "string" ? record.toolId : "";
   return toolId.endsWith("_waterfall");
@@ -15963,12 +17675,12 @@ async function getTool(toolId, options = {}) {
     console.error("Usage: deepline tools get <toolId> [--json]");
     return 1;
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   let tool;
   try {
-    tool = await client.getTool(toolId);
+    tool = await client2.getTool(toolId);
   } catch (error) {
-    const play = await findPlayForToolId(client, toolId);
+    const play = await findPlayForToolId(client2, toolId);
     if (play) {
       printPlayAliasToolError(toolId, play);
       return 2;
@@ -16035,10 +17747,10 @@ async function getTool(toolId, options = {}) {
 function toolContractJsonForDescribe(tool, requestedToolId) {
   const toolId = String(tool.toolId || requestedToolId);
   const inputFields = toolInputFieldsForDisplay(
-    recordField(tool, "inputSchema", "input_schema")
+    recordField2(tool, "inputSchema", "input_schema")
   );
-  const usageGuidance = recordField(tool, "usageGuidance", "usage_guidance");
-  const toolExecutionResult = recordField(
+  const usageGuidance = recordField2(tool, "usageGuidance", "usage_guidance");
+  const toolExecutionResult = recordField2(
     usageGuidance,
     "toolExecutionResult",
     "tool_execution_result"
@@ -16049,7 +17761,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
   const extractedValues = extractionContractEntries(
     arrayField(toolExecutionResult, "extractedValues", "extracted_values")
   );
-  const cost = recordField(tool, "cost");
+  const cost = recordField2(tool, "cost");
   const deeplineCredits = numberField(
     tool,
     "deeplineCreditsPerPricingUnit",
@@ -16103,7 +17815,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
 }
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
-    if (!isRecord6(entry)) return [];
+    if (!isRecord7(entry)) return [];
     const name = stringField(entry, "name");
     const expression = stringField(entry, "expression");
     return name && expression ? [{ name, expression }] : [];
@@ -16111,8 +17823,8 @@ function extractionContractEntries(entries) {
 }
 function printCompactToolContract(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord6(contract.cost) ? contract.cost : {};
-  const getters = isRecord6(contract.getters) ? contract.getters : {};
+  const cost = isRecord7(contract.cost) ? contract.cost : {};
+  const getters = isRecord7(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const inputFields = Array.isArray(contract.inputFields) ? contract.inputFields : [];
@@ -16129,7 +17841,7 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("");
     console.log("Inputs:");
     for (const field of inputFields) {
-      if (!isRecord6(field)) continue;
+      if (!isRecord7(field)) continue;
       const name = stringField(field, "name");
       if (!name) continue;
       const required = field.required ? "*" : "";
@@ -16142,7 +17854,7 @@ function printCompactToolContract(tool, requestedToolId) {
   }
   console.log("");
   printToolExamplesOnly(tool, requestedToolId, { includeSamples: false });
-  const starterScript = isRecord6(contract.starterScript) ? contract.starterScript : {};
+  const starterScript = isRecord7(contract.starterScript) ? contract.starterScript : {};
   const starterPath = stringField(starterScript, "path");
   if (starterPath) {
     console.log("");
@@ -16156,14 +17868,14 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("Getters:");
     if (listGetters.length) console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord6(entry))
+      if (isRecord7(entry))
         console.log(
           `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
         );
     }
     if (valueGetters.length) console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord6(entry))
+      if (isRecord7(entry))
         console.log(
           `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -16176,7 +17888,7 @@ function printCompactToolContract(tool, requestedToolId) {
 }
 function printToolPricingOnly(tool, requestedToolId, options = {}) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord6(contract.cost) ? contract.cost : {};
+  const cost = isRecord7(contract.cost) ? contract.cost : {};
   const pricingModel = stringField(cost, "pricingModel") || "unknown";
   const billingMode = stringField(cost, "billingMode") || "unknown";
   const unit = pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit";
@@ -16196,7 +17908,7 @@ function printToolSchemaOnly(tool, requestedToolId) {
   }
   console.log("Inputs:");
   for (const field of inputFields) {
-    if (!isRecord6(field)) continue;
+    if (!isRecord7(field)) continue;
     const name = stringField(field, "name");
     if (!name) continue;
     const required = field.required ? "*" : "";
@@ -16222,27 +17934,27 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
     `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
   );
   console.log("});");
-  const getters = isRecord6(contract.getters) ? contract.getters : {};
+  const getters = isRecord7(contract.getters) ? contract.getters : {};
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
-  const firstGetter = [...valueGetters, ...listGetters].find(isRecord6);
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord7);
   if (firstGetter) {
     const name = stringField(firstGetter, "name") || "value";
     const expression = stringField(firstGetter, "expression");
     if (expression)
       console.log(
-        `const ${safeIdentifier3(name)} = ${expression.replace(/^toolExecutionResult\./, "result.")};`
+        `const ${safeIdentifier2(name)} = ${expression.replace(/^toolExecutionResult\./, "result.")};`
       );
   }
   console.log("```");
   if (options.includeSamples !== false) {
-    const samples = recordField(tool, "samples");
+    const samples = recordField2(tool, "samples");
     printSamples(samples);
   }
 }
 function printToolGettersOnly(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const getters = isRecord6(contract.getters) ? contract.getters : {};
+  const getters = isRecord7(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   console.log(`Getters: ${contract.toolId}`);
@@ -16255,7 +17967,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (listGetters.length) {
     console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord6(entry))
+      if (isRecord7(entry))
         console.log(
           `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -16264,7 +17976,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (valueGetters.length) {
     console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord6(entry))
+      if (isRecord7(entry))
         console.log(
           `- ${stringField(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -16290,7 +18002,7 @@ function sampleValueForField(field) {
 function samplePayloadForInputFields(fields) {
   return Object.fromEntries(
     fields.slice(0, 4).flatMap((field) => {
-      if (!isRecord6(field)) return [];
+      if (!isRecord7(field)) return [];
       const name = stringField(field, "name");
       if (!name) return [];
       return [[name, sampleValueForField(field)]];
@@ -16300,7 +18012,7 @@ function samplePayloadForInputFields(fields) {
 function stableStepIdForTool(toolId) {
   return toolId.replace(/^[a-z0-9]+_/, "").replace(/[^a-z0-9_]+/gi, "_") || "tool_call";
 }
-function safeIdentifier3(name) {
+function safeIdentifier2(name) {
   const cleaned = name.replace(/[^a-zA-Z0-9_$]+/g, "_").replace(/^[^a-zA-Z_$]+/, "");
   return cleaned || "value";
 }
@@ -16313,7 +18025,7 @@ function playResultExpression(entry) {
 function toolMetadataJsonForDescribe(tool, requestedToolId) {
   const toolId = String(tool.toolId || requestedToolId);
   const inputFields = toolInputFieldsForDisplay(
-    recordField(tool, "inputSchema", "input_schema")
+    recordField2(tool, "inputSchema", "input_schema")
   );
   const starterScript = seedToolListScript({
     toolId,
@@ -16340,7 +18052,7 @@ function toolMetadataJsonForDescribe(tool, requestedToolId) {
     provider: tool.provider,
     displayName: tool.displayName,
     usageGuidance: usageGuidanceWithAccessDefaults(
-      recordField(tool, "usageGuidance", "usage_guidance")
+      recordField2(tool, "usageGuidance", "usage_guidance")
     ),
     runtimeOutputHelp: {
       contract: "tools describe shows declared schema and Deepline getters; it is not an observed provider response.",
@@ -16365,7 +18077,7 @@ function toolMetadataJsonForDescribe(tool, requestedToolId) {
 }
 function usageGuidanceWithAccessDefaults(usageGuidance) {
   if (Object.keys(usageGuidance).length === 0) return usageGuidance;
-  const existingAccess = recordField(usageGuidance, "access");
+  const existingAccess = recordField2(usageGuidance, "access");
   return {
     ...usageGuidance,
     access: {
@@ -16398,18 +18110,18 @@ function listedToolDescription(tool) {
 }
 function formatListedToolCost(tool) {
   const record = tool;
-  const pricing = recordField(record, "pricing");
+  const pricing = recordField2(record, "pricing");
   const displayText = stringField(pricing, "displayText", "display_text");
   return displayText ? `Cost: ${displayText}` : "";
 }
 function toolInputFieldsForDisplay(inputSchema) {
   if (Array.isArray(inputSchema.fields))
-    return inputSchema.fields.filter(isRecord6);
-  const jsonSchema = isRecord6(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord6(jsonSchema.properties) ? jsonSchema.properties : {};
+    return inputSchema.fields.filter(isRecord7);
+  const jsonSchema = isRecord7(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord7(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 = isRecord6(value) ? value : {};
+    const property = isRecord7(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
@@ -16438,15 +18150,15 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord6(entry)) return void 0;
+  if (!isRecord7(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function commandEnvelopeFromRawResponse(rawResponse) {
-  return isRecord6(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+  return isRecord7(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
 function listExtractorPathsFromUsageGuidance(tool) {
   const toolExecutionResult = tool.usageGuidance?.toolExecutionResult;
-  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord6(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
+  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord7(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
   return extractedLists.flatMap((entry) => {
     const paths = entry.details?.candidatePaths ?? entry.details?.rawToolOutputPaths;
     if (!Array.isArray(paths)) return [];
@@ -16462,7 +18174,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField(source, ...keys) {
@@ -16486,10 +18198,10 @@ function arrayField(source, ...keys) {
   }
   return [];
 }
-function recordField(source, ...keys) {
+function recordField2(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord6(value)) return value;
+    if (isRecord7(value)) return value;
   }
   return {};
 }
@@ -16555,7 +18267,7 @@ function parseJsonObjectArgument(raw, flagName) {
     }
     throw invalidJsonError(flagName, message);
   }
-  if (!isRecord6(parsed)) {
+  if (!isRecord7(parsed)) {
     throw invalidJsonError(flagName, "expected an object.");
   }
   return parsed;
@@ -16678,7 +18390,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     kind: summaryEntries.length > 0 ? "object" : "raw",
     summary: input2.summary
   };
-  const envelopeHasCanonicalOutput = isRecord6(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasCanonicalOutput = isRecord7(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
   const inspectCommand = `deepline tools execute ${input2.toolId} --input ${shellQuote(JSON.stringify(input2.params))} --json`;
   const actions = input2.listConversion ? [
     {
@@ -16733,12 +18445,12 @@ async function executeTool(args) {
     }
     return 1;
   }
-  const client = new DeeplineClient();
+  const client2 = new DeeplineClient();
   let metadata;
   try {
-    metadata = await client.getTool(parsed.toolId);
+    metadata = await client2.getTool(parsed.toolId);
   } catch (error) {
-    const play = await findPlayForToolId(client, parsed.toolId);
+    const play = await findPlayForToolId(client2, parsed.toolId);
     if (play) {
       if (argsWantJson(args)) {
         printJsonError(
@@ -16762,7 +18474,7 @@ async function executeTool(args) {
     }
     return 2;
   }
-  const rawResponse = await client.executeTool(parsed.toolId, parsed.params);
+  const rawResponse = await client2.executeTool(parsed.toolId, parsed.params);
   const listConversion = tryConvertToList(rawResponse, {
     listExtractorPaths: listExtractorPathsFromUsageGuidance(metadata)
   });
@@ -16787,7 +18499,7 @@ async function executeTool(args) {
       {
         ...baseEnvelope,
         local: {
-          ...isRecord6(baseEnvelope.local) ? baseEnvelope.local : {},
+          ...isRecord7(baseEnvelope.local) ? baseEnvelope.local : {},
           payload_file: jsonPath
         }
       },
@@ -16908,10 +18620,499 @@ async function executeTool(args) {
   return 0;
 }
 
+// src/cli/commands/workflow.ts
+import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname9, join as join11, resolve as resolve13 } from "path";
+
+// src/cli/workflow-to-play.ts
+import { createHash as createHash4 } from "crypto";
+var HITL_WAIT_FOR_SIGNAL_TOOL = "deepline_workflow_wait_for_signal";
+var HITL_SLACK_TOOL = "slack_message_with_hitl";
+var SUB_WORKFLOW_TOOL_PREFIX = "deepline_workflow_";
+var UNSUPPORTED_REASON_HINT = {
+  unsafe_user_code: "a step's JavaScript (extract_js / run_if_js / run_javascript) uses non-deterministic or sandbox-escaping code (e.g. new Date(), Date.now(), Math.random(), fetch, require). Plays replay deterministically inside a sandbox, so the compiler rejects it \u2014 rewrite it to compute from the row/result before migrating.",
+  hitl: "human-in-the-loop / wait-for-signal steps have no play-runtime equivalent yet.",
+  sub_workflow: "sub-workflow calls have no play-runtime equivalent yet (a future ctx.runPlay bridge).",
+  nested_waterfall: "nested with_waterfall blocks are not supported by the play compiler.",
+  inline_secret: 'a step inlines a hardcoded secret (API key / token / private key). Plays forbid inline secrets \u2014 move it to a dashboard secret and read it with ctx.secrets.get("NAME") before migrating.'
+};
+var UnsupportedWorkflowCommandError = class extends Error {
+  status = 400;
+  unsupported;
+  constructor(unsupported) {
+    super(
+      `Workflow uses ${unsupported.length} command${unsupported.length === 1 ? "" : "s"} that cannot run as a play yet: ${unsupported.map((entry) => `${entry.alias} (${entry.reason})`).join(", ")}.`
+    );
+    this.name = "UnsupportedWorkflowCommandError";
+    this.unsupported = unsupported;
+  }
+};
+function isWaterfall2(command) {
+  return "with_waterfall" in command;
+}
+function stepInlinedText(command) {
+  return [
+    JSON.stringify(command.payload ?? {}),
+    command.extract_js ?? "",
+    command.run_if_js ?? ""
+  ].join("\n");
+}
+function stepUserCode(command) {
+  const code = [];
+  if (command.extract_js) code.push(command.extract_js);
+  if (command.run_if_js) code.push(command.run_if_js);
+  if (command.tool === "run_javascript" && typeof command.payload?.code === "string") {
+    code.push(command.payload.code);
+  }
+  return code;
+}
+function hasUnsafeUserCode(command) {
+  return stepUserCode(command).some((code) => {
+    try {
+      assertUserCodeIsSafe(code, "play step code");
+      return false;
+    } catch {
+      return true;
+    }
+  });
+}
+function classifyUnsupportedCommand(command) {
+  const { tool } = command;
+  if (tool === HITL_SLACK_TOOL || tool === HITL_WAIT_FOR_SIGNAL_TOOL) {
+    return "hitl";
+  }
+  if (tool.startsWith(SUB_WORKFLOW_TOOL_PREFIX)) return "sub_workflow";
+  if (collectInlineSecretFindings(stepInlinedText(command)).length > 0) {
+    return "inline_secret";
+  }
+  if (hasUnsafeUserCode(command)) return "unsafe_user_code";
+  return null;
+}
+function collectStepOffenders(command, offenders) {
+  if (command.disabled) return;
+  const reason = classifyUnsupportedCommand(command);
+  if (reason) {
+    offenders.push({ alias: command.alias, tool: command.tool, reason });
+  }
+}
+function findUnsupportedWorkflowCommands(config) {
+  const offenders = [];
+  for (const command of config.commands ?? []) {
+    if (!isWaterfall2(command)) {
+      collectStepOffenders(command, offenders);
+      continue;
+    }
+    for (const child of command.commands ?? []) {
+      if (isWaterfall2(child)) {
+        offenders.push({
+          alias: command.with_waterfall,
+          tool: "with_waterfall",
+          reason: "nested_waterfall"
+        });
+        continue;
+      }
+      collectStepOffenders(child, offenders);
+    }
+  }
+  return offenders;
+}
+function validateWorkflowConfigForPlay(config) {
+  const offenders = findUnsupportedWorkflowCommands(config);
+  if (offenders.length > 0) {
+    throw new UnsupportedWorkflowCommandError(offenders);
+  }
+}
+function describeUnsupportedReason(reason) {
+  return UNSUPPORTED_REASON_HINT[reason];
+}
+var MAX_PLAY_NAME_LENGTH = 39;
+function sanitizePlayNameSegment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function deriveWorkflowPlayName(workflowName) {
+  const base = sanitizePlayNameSegment(workflowName) || "workflow";
+  const suffix = createHash4("sha256").update(workflowName).digest("hex").slice(0, 8);
+  const reserved = suffix.length + 1;
+  const allowedBase = Math.max(1, MAX_PLAY_NAME_LENGTH - reserved);
+  let name = `${base.slice(0, allowedBase)}_${suffix}`;
+  if (name.startsWith("prebuilt")) {
+    name = `wf_${name}`.slice(0, MAX_PLAY_NAME_LENGTH);
+  }
+  return name;
+}
+function compileWorkflowConfigToPlay(config, options) {
+  validateWorkflowConfigForPlay(config);
+  const playName = deriveWorkflowPlayName(options.workflowName);
+  const sourceCode = compileEnrichConfigToPlaySource(config, {
+    playName,
+    inlineRunJavascript: true,
+    idiomaticGetters: true
+  });
+  const warnings = [];
+  if (typeof config.cost_cap_usd_per_run === "number") {
+    warnings.push(
+      `cost_cap_usd_per_run ($${config.cost_cap_usd_per_run}) was not carried into the play \u2014 credits are not USD. Set billing.maxCreditsPerRun manually after checking your credit conversion.`
+    );
+  }
+  return { playName, sourceCode, warnings };
+}
+
+// src/cli/commands/workflow.ts
+var PLAY_EQUIVALENT = {
+  list: "deepline plays list",
+  get: "deepline plays get <name>",
+  call: "deepline plays run <name>",
+  apply: "deepline plays publish <file>",
+  lint: "deepline plays check <file>",
+  schema: "deepline plays describe <name>",
+  runs: "deepline runs list --play <name>",
+  run: "deepline runs get <run-id>",
+  tail: "deepline runs tail <run-id>",
+  cancel: "deepline runs stop <run-id>",
+  delete: "deepline plays delete <name>"
+};
+var MIGRATE_HINT = "deepline workflows transform <id>";
+var JSON_OPTION_DESCRIPTION = "Emit JSON output. Also automatic when stdout is piped";
+function withJsonOption(command) {
+  return command.option("--json", JSON_OPTION_DESCRIPTION);
+}
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "succeeded",
+  "success",
+  "failed",
+  "error",
+  "errored",
+  "cancelled",
+  "canceled",
+  "done"
+]);
+function migrationDeprecation(command) {
+  const use = PLAY_EQUIVALENT[command];
+  if (!use) return null;
+  return { use, migrate: MIGRATE_HINT };
+}
+function noticeToStderr(command) {
+  const deprecation = migrationDeprecation(command);
+  if (!deprecation) return;
+  process.stderr.write(
+    `note: \`deepline workflows ${command}\` is a legacy surface \u2014 workflows are becoming plays.
+      equivalent: \`${deprecation.use}\`
+      migrate this workflow: \`${MIGRATE_HINT}\`
+`
+  );
+}
+function emitPassThrough(command, payload, options) {
+  const json = shouldEmitJson(options.json);
+  const deprecation = migrationDeprecation(command);
+  if (json) {
+    const enriched = payload && typeof payload === "object" && !Array.isArray(payload) ? { ...payload, deprecation } : { result: payload, deprecation };
+    printJson(enriched);
+    return;
+  }
+  printJson(payload);
+  noticeToStderr(command);
+}
+function client() {
+  return new DeeplineClient();
+}
+function readStatus(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const record = payload;
+  if (typeof record.status === "string") return record.status;
+  const run = record.run;
+  if (run && typeof run === "object") {
+    const status = run.status;
+    if (typeof status === "string") return status;
+  }
+  return null;
+}
+async function readJsonOption(payload, file) {
+  if (file) {
+    const raw = await readFile4(resolve13(file), "utf8");
+    return JSON.parse(raw);
+  }
+  if (payload) {
+    return JSON.parse(payload);
+  }
+  throw new Error("Provide --payload <json> or --file <path>.");
+}
+async function transformOne(api, workflowId, outDir, publish) {
+  const { workflow } = await api.getWorkflow(workflowId);
+  if (!workflow) {
+    return {
+      ok: false,
+      workflowId,
+      workflowName: workflowId,
+      reason: "Workflow not found."
+    };
+  }
+  const revision = workflow.current_published_revision;
+  if (!revision) {
+    return {
+      ok: false,
+      workflowId,
+      workflowName: workflow.name,
+      reason: "Workflow has no published revision to transform."
+    };
+  }
+  try {
+    const compiled = compileWorkflowConfigToPlay(
+      // The API returns the config as `unknown`; it is structurally the
+      // EnrichCompiledConfig the compiler expects. Cast at this single boundary.
+      revision.config,
+      { workflowName: workflow.name, version: revision.version }
+    );
+    const file = join11(resolve13(outDir), `${compiled.playName}.play.ts`);
+    await mkdir5(dirname9(file), { recursive: true });
+    await writeFile5(file, compiled.sourceCode, "utf8");
+    let published = false;
+    if (publish) {
+      const code = await handlePlayPublish([file]);
+      if (code !== 0) {
+        return {
+          ok: false,
+          workflowId,
+          workflowName: workflow.name,
+          reason: `Wrote ${file} but publish failed (exit ${code}).`
+        };
+      }
+      published = true;
+    }
+    return {
+      ok: true,
+      workflowId,
+      workflowName: workflow.name,
+      playName: compiled.playName,
+      file,
+      warnings: compiled.warnings,
+      published
+    };
+  } catch (error) {
+    if (error instanceof UnsupportedWorkflowCommandError) {
+      return {
+        ok: false,
+        workflowId,
+        workflowName: workflow.name,
+        reason: error.unsupported.map((u) => `${u.alias} (${describeUnsupportedReason(u.reason)})`).join("; "),
+        unsupported: error.unsupported
+      };
+    }
+    throw error;
+  }
+}
+function renderTransformReport(outcomes) {
+  const lines = [];
+  for (const outcome of outcomes) {
+    if (outcome.ok) {
+      lines.push(
+        `\u2705 ${outcome.workflowName} \u2192 ${outcome.file}` + (outcome.published ? "  (published)" : `  (next: deepline plays publish ${outcome.file})`)
+      );
+      for (const warning of outcome.warnings) {
+        lines.push(`   \u26A0\uFE0F  ${warning}`);
+      }
+    } else {
+      lines.push(`\u26A0\uFE0F  ${outcome.workflowName} \u2014 skipped: ${outcome.reason}`);
+    }
+  }
+  const ok = outcomes.filter((o) => o.ok).length;
+  const total = outcomes.length;
+  const manual = total - ok;
+  lines.push("");
+  lines.push(
+    `${ok}/${total} transformed` + (manual > 0 ? `, ${manual} need manual attention` : "")
+  );
+  return `${lines.join("\n")}
+`;
+}
+async function handleTransform(id, options) {
+  const api = client();
+  const outDir = options.out ?? "./plays";
+  const publish = options.publish === true;
+  let ids;
+  if (options.all) {
+    const { workflows } = await api.listWorkflows();
+    ids = workflows.map((w) => w.id);
+  } else if (id) {
+    ids = [id];
+  } else {
+    throw new Error("Provide a workflow <id> or --all.");
+  }
+  const outcomes = [];
+  for (const workflowId of ids) {
+    outcomes.push(await transformOne(api, workflowId, outDir, publish));
+  }
+  printCommandEnvelope(
+    { outcomes, deprecation: null },
+    {
+      json: shouldEmitJson(options.json),
+      text: renderTransformReport(outcomes)
+    }
+  );
+  return outcomes.every((o) => o.ok) ? 0 : 1;
+}
+async function handleList2(options) {
+  const limit = options.limit ? Number(options.limit) : void 0;
+  const result = await client().listWorkflows({
+    limit: Number.isFinite(limit) ? limit : void 0
+  });
+  emitPassThrough("list", result, options);
+}
+async function handleGet(id, options) {
+  emitPassThrough("get", await client().getWorkflow(id), options);
+}
+async function handleDelete(id, options) {
+  emitPassThrough("delete", await client().deleteWorkflow(id), options);
+}
+async function handleDisable(id, options) {
+  const result = await client().disableWorkflow(id);
+  printJson(result);
+}
+async function handleEnable(id, options) {
+  const result = await client().enableWorkflow(id);
+  printJson(result);
+}
+async function handleApply(options) {
+  const body = await readJsonOption(options.payload, options.file);
+  emitPassThrough("apply", await client().applyWorkflow(body), options);
+}
+async function handleLint(options) {
+  const body = await readJsonOption(options.payload, options.file);
+  emitPassThrough("lint", await client().lintWorkflow(body), options);
+}
+async function handleSchema(options) {
+  emitPassThrough(
+    "schema",
+    await client().getWorkflowSchema(options.subject),
+    options
+  );
+}
+async function handleCall(options) {
+  const body = {};
+  if (options.workflowId) body.workflow_id = options.workflowId;
+  if (options.workflowName) body.workflow_name = options.workflowName;
+  const input2 = options.payload ? JSON.parse(options.payload) : {};
+  if (options.mode) input2.__execution_mode = options.mode;
+  body.input = input2;
+  emitPassThrough("call", await client().callWorkflow(body), options);
+}
+async function handleRuns(id, options) {
+  const limit = options.limit ? Number(options.limit) : void 0;
+  emitPassThrough(
+    "runs",
+    await client().listWorkflowRuns(id, {
+      limit: Number.isFinite(limit) ? limit : void 0
+    }),
+    options
+  );
+}
+async function handleRun(id, runId, options) {
+  emitPassThrough("run", await client().getWorkflowRun(id, runId), options);
+}
+async function handleCancel(id, runId, options) {
+  emitPassThrough(
+    "cancel",
+    await client().cancelWorkflowRun(id, runId),
+    options
+  );
+}
+async function handleTail(id, runId, options) {
+  const api = client();
+  const intervalMs = Math.max(500, Number(options.intervalMs ?? 2e3) || 2e3);
+  const deadline = Date.now() + 10 * 6e4;
+  for (; ; ) {
+    const run = await api.getWorkflowRun(id, runId);
+    emitPassThrough("tail", run, options);
+    const status = readStatus(run);
+    if (status && TERMINAL_RUN_STATUSES.has(status) || Date.now() > deadline) {
+      return;
+    }
+    await sleep3(intervalMs);
+  }
+}
+function registerWorkflowCommands(program) {
+  const workflows = program.command("workflows").description(
+    "Legacy cloud workflows (now becoming plays). Commands still work; use `workflows transform` to migrate one to a play."
+  ).addHelpText(
+    "after",
+    `
+Workflows are a legacy surface. They still run in the cloud and these commands
+keep working, but new work belongs in plays. Migrate a workflow with:
+
+  deepline workflows transform <id>            # write a reviewable .play.ts
+  deepline workflows transform --all --publish # migrate + publish them all
+
+Equivalents: list\u2192plays list \xB7 call\u2192plays run \xB7 apply\u2192plays publish \xB7
+lint\u2192plays check \xB7 runs\u2192runs list.
+`
+  );
+  withJsonOption(
+    workflows.command("transform [id]").description("Compile a workflow into a reviewable V2 play (.play.ts).").option("--all", "Transform every workflow in the workspace").option("--out <dir>", "Output directory for generated plays", "./plays").option("--publish", "Publish each clean play immediately")
+  ).addHelpText(
+    "after",
+    `
+Examples:
+  deepline workflows transform wf_123 --out ./plays
+  deepline workflows transform --all
+  deepline workflows transform --all --publish --json
+
+Notes:
+  HITL, run_javascript steps, and sub-workflow calls cannot run as a play yet;
+  those workflows are reported as needing manual attention and skipped.
+`
+  ).action(async (id, options) => {
+    process.exitCode = await handleTransform(id, options);
+  });
+  withJsonOption(
+    workflows.command("list").description("List workspace workflows.").option("--limit <n>", "Max workflows to return")
+  ).action(handleList2);
+  withJsonOption(
+    workflows.command("get <id>").description(
+      "Fetch a workflow, including its published-revision config."
+    )
+  ).action(handleGet);
+  withJsonOption(
+    workflows.command("disable <id>").description("Turn a workflow off.")
+  ).action(handleDisable);
+  withJsonOption(
+    workflows.command("enable <id>").description("Turn a workflow back on.")
+  ).action(handleEnable);
+  withJsonOption(
+    workflows.command("delete <id>").description("Delete a workflow and its revisions/runs.")
+  ).action(handleDelete);
+  withJsonOption(
+    workflows.command("apply").description("Create or update a workflow from config.").option("--payload <json>", "Inline config JSON").option("--file <path>", "Path to a config JSON file")
+  ).action(handleApply);
+  withJsonOption(
+    workflows.command("lint").description("Validate a workflow config without saving.").option("--payload <json>", "Inline config JSON").option("--file <path>", "Path to a config JSON file")
+  ).action(handleLint);
+  withJsonOption(
+    workflows.command("schema").description("Fetch live workflow request schemas.").option(
+      "--subject <subject>",
+      "Schema subject (apply|call|trigger|all|\u2026)"
+    )
+  ).action(handleSchema);
+  withJsonOption(
+    workflows.command("call").description("Queue a workflow run.").option("--workflow-id <id>", "Workflow id").option("--workflow-name <name>", "Workflow name").option("--payload <json>", "Run input JSON").option("--mode <mode>", "live | dry_run | smoke_test")
+  ).action(handleCall);
+  withJsonOption(
+    workflows.command("runs <id>").description("List a workflow\u2019s runs.").option("--limit <n>", "Max runs to return")
+  ).action(handleRuns);
+  withJsonOption(
+    workflows.command("run <id> <runId>").description("Fetch a single workflow run.")
+  ).action(handleRun);
+  withJsonOption(
+    workflows.command("tail <id> <runId>").description("Poll a workflow run until it reaches a terminal status.").option("--interval-ms <n>", "Poll interval in ms (default 2000)")
+  ).action(handleTail);
+  withJsonOption(
+    workflows.command("cancel <id> <runId>").description("Cancel a running workflow run.")
+  ).action(handleCancel);
+}
+
 // src/cli/commands/update.ts
 import { spawn } from "child_process";
 import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname9, join as join11, resolve as resolve13 } from "path";
+import { dirname as dirname10, join as join12, resolve as resolve14 } from "path";
 function posixShellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -16930,19 +19131,19 @@ function buildSourceUpdateCommand(sourceRoot) {
   return `${cdCommand} && git fetch origin main --tags && git merge --ff-only origin/main`;
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve13(startPath);
+  let current = resolve14(startPath);
   while (true) {
-    if (existsSync9(join11(current, "sdk", "package.json")) && existsSync9(join11(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync9(join12(current, "sdk", "package.json")) && existsSync9(join12(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = dirname9(current);
+    const parent = dirname10(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveUpdatePlan() {
-  const entrypoint = process.argv[1] ? resolve13(process.argv[1]) : "";
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname9(entrypoint)) : null;
+  const entrypoint = process.argv[1] ? resolve14(process.argv[1]) : "";
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname10(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -17214,7 +19415,7 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname10, join as join12 } from "path";
+import { dirname as dirname11, join as join13 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
 var SDK_SKILL_NAME = "deepline-plays";
 var attemptedSync = false;
@@ -17234,14 +19435,14 @@ function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return readFileSync8(join12(dir, ".version"), "utf-8").trim();
+    return readFileSync8(join13(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
   const home = process.env.HOME?.trim() || homedir6();
-  return join12(
+  return join13(
     home,
     ".local",
     "deepline",
@@ -17263,16 +19464,16 @@ function readLocalSkillsVersion(baseUrl) {
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync5(dirname10(path), { recursive: true });
+  mkdirSync5(dirname11(path), { recursive: true });
   writeFileSync10(path, `${version}
 `, "utf-8");
 }
 function installedSdkSkillHasStalePositionalExecuteExamples() {
   const home = process.env.HOME?.trim() || homedir6();
   const pluginSkillsDir = activePluginSkillsDir();
-  const roots = pluginSkillsDir ? [join12(pluginSkillsDir, SDK_SKILL_NAME)] : [
-    join12(home, ".claude", "skills", SDK_SKILL_NAME),
-    join12(home, ".agents", "skills", SDK_SKILL_NAME)
+  const roots = pluginSkillsDir ? [join13(pluginSkillsDir, SDK_SKILL_NAME)] : [
+    join13(home, ".claude", "skills", SDK_SKILL_NAME),
+    join13(home, ".agents", "skills", SDK_SKILL_NAME)
   ];
   const staleMarkers = [
     "ctx.tools.execute(key",
@@ -17283,7 +19484,7 @@ function installedSdkSkillHasStalePositionalExecuteExamples() {
   ];
   const scan = (dir) => {
     for (const entry of readdirSync2(dir)) {
-      const path = join12(dir, entry);
+      const path = join13(dir, entry);
       const stat4 = statSync2(path);
       if (stat4.isDirectory()) {
         if (scan(path)) return true;
@@ -17369,7 +19570,7 @@ function resolveSkillsInstallCommands(baseUrl) {
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     const child = spawn2(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
@@ -17379,7 +19580,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve14({
+      resolve15({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -17387,11 +19588,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve14({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve15({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve14({
+      resolve15({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -17479,10 +19680,10 @@ function shouldDeferSkillsSyncForCommand() {
   return (command === "play" || command === "plays") && subcommand === "run" && args.includes("--json");
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join13(tmpdir5(), "deepline-health-play-"));
-  const file = join13(dir, "health-check.play.ts");
+  const dir = await mkdtemp2(join14(tmpdir5(), "deepline-health-play-"));
+  const file = join14(dir, "health-check.play.ts");
   try {
-    await writeFile5(
+    await writeFile6(
       file,
       [
         "import { definePlay } from 'deepline';",
@@ -17579,14 +19780,12 @@ async function runPreflightCheck() {
       connected: false,
       error: preflightErrorMessage(error)
     })),
-    http.get("/api/v2/billing/balance").catch(
-      (error) => ({
-        balance: null,
-        balance_display: "unavailable",
-        balance_status: "unknown",
-        error: preflightErrorMessage(error)
-      })
-    )
+    http.get("/api/v2/billing/balance").catch((error) => ({
+      balance: null,
+      balance_display: "unavailable",
+      balance_status: "unknown",
+      error: preflightErrorMessage(error)
+    }))
   ]) : [
     {
       status: "not_connected",
@@ -17722,6 +19921,7 @@ Exit codes:
   registerAuthCommands(program);
   registerToolsCommands(program);
   registerPlayCommands(program);
+  registerWorkflowCommands(program);
   registerSecretsCommands(program);
   registerBillingCommands(program);
   registerOrgCommands(program);
@@ -17774,8 +19974,8 @@ Examples:
 `);
         return;
       }
-      const client = new DeeplineClient();
-      const data = await client.health();
+      const client2 = new DeeplineClient();
+      const data = await client2.health();
       process.stdout.write(`${JSON.stringify(data, null, 2)}
 `);
     } catch (error) {