deepline 0.1.152 → 0.1.154

package/dist/cli/index.js

@@ -182,8 +182,8 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 var import_promises5 = require("fs/promises");
-var import_node_path19 = require("path");
-var import_node_os14 = require("os");
+var import_node_path20 = require("path");
+var import_node_os15 = require("os");
 var import_commander3 = require("commander");
 
 // src/config.ts
@@ -655,10 +655,10 @@ var SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: "0.1.152",
+  version: "0.1.154",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.152",
+    latest: "0.1.154",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1252,7 +1252,7 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function withCoworkNetworkHint(message) {
   if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
@@ -1462,8 +1462,15 @@ function normalizeStepProgress(value) {
   };
 }
 
-// ../shared_libs/play-runtime/run-snapshot-stream.ts
-function normalizePlayRunLiveStatus(value) {
+// ../shared_libs/play-runtime/run-lifecycle-policy.ts
+var TERMINAL_PLAY_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled",
+  "terminated",
+  "timed_out"
+]);
+function normalizePlayRunLifecycleStatus(value) {
   const normalized = String(value ?? "").trim().toLowerCase();
   switch (normalized) {
     case "queued":
@@ -1471,6 +1478,7 @@ function normalizePlayRunLiveStatus(value) {
       return "running";
     case "running":
     case "started":
+    case "waiting":
       return "running";
     case "completed":
     case "complete":
@@ -1491,8 +1499,16 @@ function normalizePlayRunLiveStatus(value) {
       return "unknown";
   }
 }
+function isTerminalPlayRunLifecycleStatus(status) {
+  return TERMINAL_PLAY_RUN_STATUSES.has(normalizePlayRunLifecycleStatus(status));
+}
+
+// ../shared_libs/play-runtime/run-snapshot-stream.ts
+function normalizePlayRunLiveStatus(value) {
+  return normalizePlayRunLifecycleStatus(value);
+}
 function isTerminalPlayRunLiveStatus(status) {
-  return status === "completed" || status === "failed" || status === "cancelled" || status === "terminated" || status === "timed_out";
+  return isTerminalPlayRunLifecycleStatus(status);
 }
 function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -2021,14 +2037,14 @@ async function* observeRunEvents(options) {
   try {
     for (; ; ) {
       if (queue.length === 0) {
-        const waitForItem = new Promise((resolve13) => {
-          wake = resolve13;
+        const waitForItem = new Promise((resolve14) => {
+          wake = resolve14;
         });
         if (!sawFirstSnapshot) {
           const timedOut = await Promise.race([
             waitForItem.then(() => false),
             new Promise(
-              (resolve13) => setTimeout(() => resolve13(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
+              (resolve14) => setTimeout(() => resolve14(true), OBSERVE_BOOTSTRAP_TIMEOUT_MS)
             )
           ]);
           if (timedOut && queue.length === 0) {
@@ -2129,7 +2145,7 @@ var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES = 25e5;
 function sleep2(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function isTransientCompileManifestError(error) {
   if (error instanceof DeeplineError && typeof error.statusCode === "number") {
@@ -4795,7 +4811,7 @@ function buildCandidateUrls2(url) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function printDeeplineLogo() {
   if (process.stdout.isTTY && (process.stdout.columns ?? 80) >= 70) {
@@ -6214,6 +6230,13 @@ Examples:
   ).requiredOption("--code <code>", "Code to redeem").option("--no-open", "Do not open a browser").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(({ code, ...options }) => handleRedeemCode(code, options));
 }
 
+// src/cli/commands/csv.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto2 = require("crypto");
+var import_node_fs7 = require("fs");
+var import_node_os7 = require("os");
+var import_node_path8 = require("path");
+
 // src/cli/dataset-stats.ts
 var import_node_fs6 = require("fs");
 var import_node_path7 = require("path");
@@ -6553,6 +6576,7 @@ function collectCanonicalRowsInfos(statusOrResult) {
     total: totalFromMetadata,
     output: candidates
   });
+  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
@@ -6931,6 +6955,311 @@ async function handleCsvShow(options) {
 `
   );
 }
+function csvRenderStatePath() {
+  return (0, import_node_path8.join)((0, import_node_os7.homedir)(), ".local", "deepline", "runtime", "csv-render.json");
+}
+function csvRenderLogPath() {
+  return (0, import_node_path8.join)((0, import_node_os7.homedir)(), ".local", "deepline", "runtime", "csv-render.log");
+}
+function ensureCsvRenderStateDir() {
+  (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)((0, import_node_os7.homedir)(), ".local", "deepline", "runtime"), {
+    recursive: true
+  });
+}
+function readCsvRenderState() {
+  try {
+    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(csvRenderStatePath(), "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeCsvRenderState(state) {
+  ensureCsvRenderStateDir();
+  (0, import_node_fs7.writeFileSync)(csvRenderStatePath(), `${JSON.stringify(state, null, 2)}
+`);
+}
+function parseCsvRenderPort(raw) {
+  const value = Number.parseInt(String(raw ?? "4174").replace(/^:/, ""), 10);
+  if (!Number.isInteger(value) || value <= 0 || value > 65535) {
+    throw new Error(`Invalid --port value: ${raw ?? ""}`);
+  }
+  return value;
+}
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isOwnedCsvRenderHealth(health, state) {
+  return Boolean(health?.ok) && Number.isInteger(state.pid) && health?.pid === state.pid && Boolean(state.token) && health?.token === state.token;
+}
+async function fetchCsvRenderHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`);
+    if (!response.ok) {
+      return null;
+    }
+    const parsed = await response.json();
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function waitForRenderHealth(url, state) {
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (isOwnedCsvRenderHealth(await fetchCsvRenderHealth(url), state)) {
+      return true;
+    }
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 100));
+  }
+  return false;
+}
+async function waitForRenderStopped(url) {
+  const deadline = Date.now() + 2e3;
+  while (Date.now() < deadline) {
+    try {
+      await fetch(`${url}/health`);
+    } catch {
+      return;
+    }
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 100));
+  }
+}
+var CSV_RENDER_SERVER_SOURCE = String.raw`
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const port = Number.parseInt(process.env.DEEPLINE_CSV_RENDER_PORT || '4174', 10);
+const csvPath = process.env.DEEPLINE_CSV_RENDER_CSV || '';
+const token = process.env.DEEPLINE_CSV_RENDER_TOKEN || '';
+
+function send(res, status, contentType, body) {
+  res.writeHead(status, {
+    'content-type': contentType,
+    'cache-control': 'no-store',
+  });
+  res.end(body);
+}
+
+function readCsvText() {
+  if (!csvPath) return '';
+  try {
+    return fs.readFileSync(csvPath, 'utf8');
+  } catch (error) {
+    return 'Unable to read CSV: ' + (error && error.message ? error.message : String(error));
+  }
+}
+
+const server = http.createServer((req, res) => {
+  const url = new URL(req.url || '/', 'http://127.0.0.1:' + port);
+  if (url.pathname === '/health') {
+    send(res, 200, 'application/json', JSON.stringify({ ok: true, pid: process.pid, csvPath, token }));
+    return;
+  }
+  if (url.pathname === '/csv.txt') {
+    send(res, 200, 'text/plain; charset=utf-8', readCsvText());
+    return;
+  }
+  if (url.pathname === '/csv.json') {
+    send(res, 200, 'application/json', JSON.stringify({ csvPath, text: readCsvText() }));
+    return;
+  }
+  const title = csvPath ? path.basename(csvPath) : 'CSV renderer';
+  const escapedTitle = title.replace(/[&<>"]/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[ch]));
+  const escapedCsv = readCsvText().replace(/[&<>]/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[ch]));
+  send(res, 200, 'text/html; charset=utf-8', '<!doctype html><html><head><meta charset="utf-8"><title>' + escapedTitle + '</title><style>body{font:14px system-ui,sans-serif;margin:24px}pre{white-space:pre-wrap;border:1px solid #ddd;padding:16px;border-radius:8px}</style></head><body><h1>' + escapedTitle + '</h1><pre>' + escapedCsv + '</pre></body></html>');
+});
+
+server.listen(port, '127.0.0.1');
+process.on('SIGTERM', () => server.close(() => process.exit(0)));
+process.on('SIGINT', () => server.close(() => process.exit(0)));
+`;
+async function openBrowser(url) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = (0, import_node_child_process.spawn)(opener, args, { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+async function handleCsvRenderStart(options) {
+  const port = parseCsvRenderPort(options.port);
+  const csvPath = options.csv ? (0, import_node_path8.resolve)(options.csv) : "";
+  if (csvPath && !(0, import_node_fs7.existsSync)(csvPath)) {
+    throw new Error(`CSV not found: ${csvPath}`);
+  }
+  const url = `http://127.0.0.1:${port}`;
+  const existing = readCsvRenderState();
+  if (processAlive(existing.pid) && existing.url) {
+    const existingOwned = isOwnedCsvRenderHealth(
+      await fetchCsvRenderHealth(existing.url),
+      existing
+    );
+    const sameUrl = existing.url === url;
+    const sameCsv = !csvPath || existing.csvPath === csvPath;
+    if (existingOwned && (!sameUrl || !sameCsv)) {
+      try {
+        process.kill(existing.pid, "SIGTERM");
+      } catch {
+      }
+      await waitForRenderStopped(existing.url);
+      if (processAlive(existing.pid)) {
+        try {
+          process.kill(existing.pid, "SIGKILL");
+        } catch {
+        }
+      }
+      (0, import_node_fs7.rmSync)(csvRenderStatePath(), { force: true });
+    } else if (existingOwned) {
+      process.stdout.write(
+        "Playground render is already running; reusing current process.\n"
+      );
+      process.stdout.write(`Render URL: ${existing.url}
+`);
+      if (options.open) {
+        await openBrowser(existing.url);
+      }
+      return;
+    } else {
+      (0, import_node_fs7.rmSync)(csvRenderStatePath(), { force: true });
+    }
+  }
+  ensureCsvRenderStateDir();
+  const logPath = csvRenderLogPath();
+  const token = (0, import_node_crypto2.randomUUID)();
+  const child = (0, import_node_child_process.spawn)(process.execPath, ["-e", CSV_RENDER_SERVER_SOURCE], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
+    env: {
+      ...process.env,
+      DEEPLINE_CSV_RENDER_PORT: String(port),
+      DEEPLINE_CSV_RENDER_CSV: csvPath,
+      DEEPLINE_CSV_RENDER_TOKEN: token
+    }
+  });
+  child.unref();
+  const state = {
+    pid: child.pid ?? null,
+    port,
+    url,
+    csvPath,
+    logPath,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    token
+  };
+  const started = await waitForRenderHealth(url, state);
+  if (!started) {
+    if (processAlive(child.pid)) {
+      process.kill(child.pid, "SIGTERM");
+    }
+    throw new Error(`Timed out waiting for CSV render to start at ${url}.`);
+  }
+  writeCsvRenderState(state);
+  (0, import_node_fs7.writeFileSync)(
+    logPath,
+    `CSV render started at ${state.startedAt} on ${url}
+`
+  );
+  process.stdout.write("Playground render is running.\n");
+  process.stdout.write(`Render PID: ${child.pid}
+`);
+  process.stdout.write(`Render URL: ${url}
+`);
+  if (options.open) {
+    await openBrowser(url);
+  }
+}
+async function handleCsvRenderStatus(options) {
+  const state = readCsvRenderState();
+  const processExists = processAlive(state.pid);
+  const url = state.url ?? "";
+  let health = "unknown";
+  let owned = false;
+  if (processExists && url) {
+    const renderHealth = await fetchCsvRenderHealth(url);
+    owned = isOwnedCsvRenderHealth(renderHealth, state);
+    health = owned ? "healthy" : "unhealthy";
+  }
+  const status = processExists && owned ? "running" : processExists ? "unhealthy" : "stopped";
+  const payload = {
+    status,
+    pid: owned ? state.pid : null,
+    process_alive: owned,
+    url,
+    log_path: state.logPath ?? "",
+    mode: "background",
+    started_at: owned ? state.startedAt ?? "" : "",
+    health_status: health,
+    health_checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+    stale_cleaned: true
+  };
+  const lines = [`Render Status: ${payload.status}`];
+  if (payload.pid) lines.push(`Render PID: ${payload.pid}`);
+  if (payload.url) lines.push(`Render URL: ${payload.url}`);
+  lines.push(`Render Health: ${payload.health_status}`);
+  printCommandEnvelope(payload, {
+    json: options.json,
+    text: `${lines.join("\n")}
+`
+  });
+}
+function terminateRenderProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  return true;
+}
+async function handleCsvRenderStop(options) {
+  const state = readCsvRenderState();
+  const stopped = [];
+  const failed = [];
+  const owned = processAlive(state.pid) && Boolean(state.url) && isOwnedCsvRenderHealth(await fetchCsvRenderHealth(state.url), state);
+  if (owned && processAlive(state.pid)) {
+    if (terminateRenderProcess(state.pid)) {
+      stopped.push(state.pid);
+    } else {
+      failed.push(state.pid);
+    }
+  }
+  (0, import_node_fs7.rmSync)(csvRenderStatePath(), { force: true });
+  const payload = {
+    ok: failed.length === 0,
+    stopped_count: stopped.length,
+    failed_count: failed.length,
+    stopped_pids: stopped,
+    failed_pids: failed
+  };
+  const text = stopped.length > 0 ? `Stopped playground render process(es): ${stopped.join(" ")}
+` : "No running playground render process found.\n";
+  printCommandEnvelope(payload, { json: options.json, text });
+}
+async function handleCsvRender(action, options) {
+  const normalized = action ?? "start";
+  if (normalized === "start") {
+    await handleCsvRenderStart(options);
+    return;
+  }
+  if (normalized === "status") {
+    await handleCsvRenderStatus(options);
+    return;
+  }
+  if (normalized === "stop") {
+    await handleCsvRenderStop(options);
+    return;
+  }
+  throw new Error(`Unknown csv render action: ${normalized}`);
+}
 function registerCsvCommands(program) {
   const csv = program.command("csv").description("Inspect local CSV files.").addHelpText(
     "after",
@@ -6957,11 +7286,13 @@ Examples:
   deepline csv show --csv leads.csv --summary
 `
   ).requiredOption("--csv <path>", "Input CSV path").option("--format <format>", "Output format: json, csv, or table", "json").option("--rows <range>", "Row range start:end", "0:19").option("--columns <names>", "Comma-separated column names to include").option("--summary", "Print a summary payload instead of row output").option("--verbose", "Do not truncate long values in table output").action(handleCsvShow);
+  const render = csv.command("render").description("Start, inspect, or stop a local CSV renderer.").argument("[action]", "start, status, or stop", "start").option("--port <port>", "Local renderer port.", "4174").option("--csv <path>", "CSV path to display.").option("--open", "Open the renderer in a browser.").option("--json", "Emit JSON for status/stop.").action(handleCsvRender);
+  render.showHelpAfterError();
 }
 
 // src/cli/commands/db.ts
-var import_node_fs7 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path9 = require("path");
 var CUSTOMER_DB_QUERY_FORMATS = /* @__PURE__ */ new Set(["table", "json", "csv", "markdown"]);
 var CUSTOMER_DB_QUERY_MAX_ROWS = 1e3;
 function parsePositiveInteger(value, flagName) {
@@ -7084,8 +7415,8 @@ function formatDbQueryError(sql, error) {
   return errorMessage(error);
 }
 function writeCustomerDbCsv(result, outPath) {
-  const resolved = (0, import_node_path8.resolve)(outPath);
-  (0, import_node_fs7.writeFileSync)(
+  const resolved = (0, import_node_path9.resolve)(outPath);
+  (0, import_node_fs8.writeFileSync)(
     resolved,
     dataExportCsvString(customerDbRows(result), customerDbColumnNames(result)),
     "utf-8"
@@ -7197,8 +7528,8 @@ async function handleDbQuery(args) {
       customerDbColumnNames(result)
     );
     if (outPath) {
-      const exportedPath = (0, import_node_path8.resolve)(outPath);
-      (0, import_node_fs7.writeFileSync)(exportedPath, content, "utf-8");
+      const exportedPath = (0, import_node_path9.resolve)(outPath);
+      (0, import_node_fs8.writeFileSync)(exportedPath, content, "utf-8");
       printCommandEnvelope(
         dbQueryExportEnvelope({
           result,
@@ -7300,18 +7631,18 @@ Examples:
 
 // src/cli/commands/enrich.ts
 var import_promises3 = require("fs/promises");
-var import_node_os7 = require("os");
-var import_node_path11 = require("path");
+var import_node_os8 = require("os");
+var import_node_path12 = require("path");
 
 // src/cli/commands/play.ts
-var import_node_crypto2 = require("crypto");
-var import_node_fs9 = require("fs");
-var import_node_path10 = require("path");
+var import_node_crypto3 = require("crypto");
+var import_node_fs10 = require("fs");
+var import_node_path11 = require("path");
 var import_sync5 = require("csv-parse/sync");
 
 // src/cli/commands/plays/bootstrap.ts
-var import_node_fs8 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path10 = require("path");
 var import_sync4 = require("csv-parse/sync");
 
 // ../shared_libs/plays/bootstrap-routes.ts
@@ -7740,13 +8071,13 @@ function inferCsvColumnSpecs(headers, rows) {
   }));
 }
 function readCsvSample(csvPath) {
-  const resolvedPath = (0, import_node_path9.resolve)(csvPath);
-  const size = (0, import_node_fs8.statSync)(resolvedPath).size;
-  const fd = (0, import_node_fs8.openSync)(resolvedPath, "r");
+  const resolvedPath = (0, import_node_path10.resolve)(csvPath);
+  const size = (0, import_node_fs9.statSync)(resolvedPath).size;
+  const fd = (0, import_node_fs9.openSync)(resolvedPath, "r");
   const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
   const buffer = Buffer.alloc(byteLength);
-  const bytesRead = (0, import_node_fs8.readSync)(fd, buffer, 0, byteLength, 0);
-  (0, import_node_fs8.closeSync)(fd);
+  const bytesRead = (0, import_node_fs9.readSync)(fd, buffer, 0, byteLength, 0);
+  (0, import_node_fs9.closeSync)(fd);
   if (bytesRead === 0) {
     throw new PlayBootstrapUsageError(`--from csv:${csvPath} is empty.`);
   }
@@ -7815,9 +8146,9 @@ ${properties}
 }
 function packagedCsvPathForPlay(csvPath) {
   const playDir = process.cwd();
-  const absoluteCsvPath = (0, import_node_path9.resolve)(csvPath);
-  const relativePath = (0, import_node_path9.relative)(playDir, absoluteCsvPath);
-  if (relativePath === "" || relativePath.startsWith("..") || (0, import_node_path9.isAbsolute)(relativePath)) {
+  const absoluteCsvPath = (0, import_node_path10.resolve)(csvPath);
+  const relativePath = (0, import_node_path10.relative)(playDir, absoluteCsvPath);
+  if (relativePath === "" || relativePath.startsWith("..") || (0, import_node_path10.isAbsolute)(relativePath)) {
     throw new PlayBootstrapUsageError(
       `--from csv:${csvPath} must point to a file inside the directory where you run plays bootstrap. Run bootstrap from the intended play directory and write the play with --out there.`
     );
@@ -8739,8 +9070,8 @@ async function runPlayBootstrap(args) {
     ...csvContext
   });
   if (options.out) {
-    (0, import_node_fs8.writeFileSync)((0, import_node_path9.resolve)(options.out), source, "utf-8");
-    process.stdout.write(`Wrote ${(0, import_node_path9.resolve)(options.out)}
+    (0, import_node_fs9.writeFileSync)((0, import_node_path10.resolve)(options.out), source, "utf-8");
+    process.stdout.write(`Wrote ${(0, import_node_path10.resolve)(options.out)}
 `);
     return 0;
   }
@@ -9424,7 +9755,7 @@ function traceCliSync(phase, fields, run) {
   }
 }
 function sleep5(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
@@ -9468,7 +9799,7 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return (0, import_node_path10.resolve)(defaultStarterPlayPath(reference));
+  return (0, import_node_path11.resolve)(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
   const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
@@ -9494,15 +9825,15 @@ function materializeRemotePlaySource(input2) {
     return null;
   }
   const outputPath = input2.outPath ?? defaultMaterializedPlayPath(input2.playName);
-  if ((0, import_node_fs9.existsSync)(outputPath)) {
-    const existingSource = (0, import_node_fs9.readFileSync)(outputPath, "utf-8");
+  if ((0, import_node_fs10.existsSync)(outputPath)) {
+    const existingSource = (0, import_node_fs10.readFileSync)(outputPath, "utf-8");
     if (existingSource === input2.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    (0, import_node_fs9.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
+    (0, import_node_fs10.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  (0, import_node_fs9.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
+  (0, import_node_fs10.writeFileSync)(outputPath, input2.sourceCode, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -9547,7 +9878,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return (0, import_node_fs9.existsSync)((0, import_node_path10.resolve)(target));
+  return (0, import_node_fs10.existsSync)((0, import_node_path11.resolve)(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -9576,7 +9907,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? (0, import_node_fs9.readFileSync)((0, import_node_path10.resolve)(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? (0, import_node_fs10.readFileSync)((0, import_node_path11.resolve)(raw.slice(1)), "utf-8") : raw;
   const parsed = JSON.parse(source);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("--input must be a JSON object.");
@@ -9678,7 +10009,7 @@ function fileInputBindingsFromStaticPipeline(staticPipeline) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return (0, import_node_fs9.existsSync)((0, import_node_path10.resolve)(value));
+  return (0, import_node_fs10.existsSync)((0, import_node_path11.resolve)(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -9725,7 +10056,7 @@ function collectLocalFileInputRefs(value, inputPath, key, out) {
     const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
     if (keyIsCsvData) {
       out.push({ inputPath, value: trimmed, isCsvData: true });
-    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs9.existsSync)((0, import_node_path10.resolve)(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs10.existsSync)((0, import_node_path11.resolve)(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -9767,8 +10098,8 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = (0, import_node_path10.resolve)(ref.value);
-    if (!(0, import_node_fs9.existsSync)(absolutePath)) {
+    const absolutePath = (0, import_node_path11.resolve)(ref.value);
+    if (!(0, import_node_fs10.existsSync)(absolutePath)) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
         void 0,
@@ -9778,7 +10109,7 @@ function preflightLocalFileInputs(runtimeInput) {
     }
     let stat2;
     try {
-      stat2 = (0, import_node_fs9.statSync)(absolutePath);
+      stat2 = (0, import_node_fs10.statSync)(absolutePath);
     } catch (error) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that is not readable: ${ref.value} (${error instanceof Error ? error.message : String(error)}). No run was created.`,
@@ -9804,7 +10135,7 @@ function preflightLocalFileInputs(runtimeInput) {
 function preflightCsvDataInput(ref, absolutePath) {
   let content;
   try {
-    content = (0, import_node_fs9.readFileSync)(absolutePath, "utf-8");
+    content = (0, import_node_fs10.readFileSync)(absolutePath, "utf-8");
   } catch (error) {
     throw new DeeplineError(
       `Input ${ref.inputPath} CSV ${ref.value} is not readable: ${error instanceof Error ? error.message : String(error)}. No run was created.`,
@@ -9886,8 +10217,8 @@ async function stageFileInputArgs(input2) {
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input2.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = (0, import_node_path10.resolve)(value);
-    return [{ binding, absolutePath, logicalPath: (0, import_node_path10.basename)(absolutePath) }];
+    const absolutePath = (0, import_node_path11.resolve)(value);
+    return [{ binding, absolutePath, logicalPath: (0, import_node_path11.basename)(absolutePath) }];
   });
   if (localFiles.length === 0) {
     return { inputFile: null, packagedFiles: [] };
@@ -9919,20 +10250,20 @@ async function stageFileInputArgs(input2) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = (0, import_node_fs9.readFileSync)(absolutePath);
+  const buffer = (0, import_node_fs10.readFileSync)(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
-    contentHash: (0, import_node_crypto2.createHash)("sha256").update(buffer).digest("hex"),
+    contentHash: (0, import_node_crypto3.createHash)("sha256").update(buffer).digest("hex"),
     contentType: absolutePath.toLowerCase().endsWith(".csv") ? "text/csv" : absolutePath.toLowerCase().endsWith(".json") ? "application/json" : "application/octet-stream",
     bytes: buffer.byteLength
   };
 }
 function normalizePlayPath(filePath) {
   try {
-    return import_node_fs9.realpathSync.native((0, import_node_path10.resolve)(filePath));
+    return import_node_fs10.realpathSync.native((0, import_node_path11.resolve)(filePath));
   } catch {
-    return (0, import_node_path10.resolve)(filePath);
+    return (0, import_node_path11.resolve)(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -11999,7 +12330,7 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path10.resolve)(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote((0, import_node_path11.resolve)(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -12804,7 +13135,7 @@ async function handlePlayCheck(args) {
       }
       return 0;
     } catch (error) {
-      const resolved = (0, import_node_path10.resolve)(options.target);
+      const resolved = (0, import_node_path11.resolve)(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         process.stdout.write(
@@ -12821,8 +13152,8 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = (0, import_node_path10.resolve)(options.target);
-  const sourceCode = (0, import_node_fs9.readFileSync)(absolutePlayPath, "utf-8");
+  const absolutePlayPath = (0, import_node_path11.resolve)(options.target);
+  const sourceCode = (0, import_node_fs10.readFileSync)(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -12922,12 +13253,12 @@ async function handleFileBackedRun(options) {
   }
   const client2 = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = (0, import_node_path10.resolve)(options.target.path);
+  const absolutePlayPath = (0, import_node_path11.resolve)(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => (0, import_node_fs9.readFileSync)(absolutePlayPath, "utf-8")
+    () => (0, import_node_fs10.readFileSync)(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   try {
@@ -13248,19 +13579,19 @@ async function handlePlayRun(args) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options);
     }
-    const resolved = (0, import_node_path10.resolve)(options.target.path);
+    const resolved = (0, import_node_path11.resolve)(options.target.path);
     console.error(`File not found: ${resolved}`);
-    const dir = (0, import_node_path10.dirname)(resolved);
-    if ((0, import_node_fs9.existsSync)(dir)) {
-      const base = (0, import_node_path10.basename)(resolved);
+    const dir = (0, import_node_path11.dirname)(resolved);
+    if ((0, import_node_fs10.existsSync)(dir)) {
+      const base = (0, import_node_path11.basename)(resolved);
       try {
-        const siblings = (0, import_node_fs9.readdirSync)(dir).filter(
+        const siblings = (0, import_node_fs10.readdirSync)(dir).filter(
           (f) => f.includes(base.replace(/\.(play\.)?ts$/, "")) || f.endsWith(".play.ts")
         );
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${(0, import_node_path10.join)(dir, s)}`);
+            console.error(`  ${(0, import_node_path11.join)(dir, s)}`);
           }
         }
       } catch {
@@ -13419,14 +13750,14 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path10.resolve)(args[++index]);
+      outPath = (0, import_node_path11.resolve)(args[++index]);
     }
   }
   const client2 = new DeeplineClient();
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
     const logs = result2.entries;
-    (0, import_node_fs9.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    (0, import_node_fs10.writeFileSync)(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
       {
         runId: result2.runId,
@@ -13576,7 +13907,7 @@ async function handleRunExport(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path10.resolve)(args[++index]);
+      outPath = (0, import_node_path11.resolve)(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -13584,7 +13915,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = (0, import_node_path10.resolve)(args[++index]);
+      metadataOutPath = (0, import_node_path11.resolve)(args[++index]);
     }
   }
   if (!outPath) {
@@ -13624,7 +13955,7 @@ async function handleRunExport(args) {
     }
   };
   if (metadataOutPath) {
-    (0, import_node_fs9.writeFileSync)(
+    (0, import_node_fs10.writeFileSync)(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -13656,10 +13987,10 @@ async function handlePlayGet(args) {
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = (0, import_node_path10.resolve)(args[++index]);
+      outPath = (0, import_node_path11.resolve)(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs9.readFileSync)((0, import_node_path10.resolve)(target), "utf-8"), (0, import_node_path10.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName((0, import_node_fs10.readFileSync)((0, import_node_path11.resolve)(target), "utf-8"), (0, import_node_path11.resolve)(target)) : parseReferencedPlayTarget2(target).playName;
   const detail = isFileTarget(target) ? await client2.getPlay(playName) : await assertCanonicalNamedPlayReference(client2, target);
   const resolvedSource = detail.play.workingRevision?.sourceCode ?? detail.play.liveRevision?.sourceCode ?? detail.play.currentRevision?.sourceCode ?? detail.play.sourceCode ?? "";
   const materializedFile = outPath ? materializeRemotePlaySource({
@@ -14108,7 +14439,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          (0, import_node_fs9.readFileSync)((0, import_node_path10.resolve)(playName), "utf-8"),
+          (0, import_node_fs10.readFileSync)((0, import_node_path11.resolve)(playName), "utf-8"),
           playName
         );
       } catch {
@@ -14189,7 +14520,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph((0, import_node_path10.resolve)(playName))
+        () => collectBundledPlayGraph((0, import_node_path11.resolve)(playName))
       );
       assertBundledPlayGraphDescriptions(graph);
       await traceCliSpan(
@@ -14378,12 +14709,15 @@ Idempotent execution:
       }))
       .run({ key: 'domain' });
 
-  Reuse needs the same play, tool id, dataset name, row key, and compatible logic.
-  To recompute a visible cell on a later cron/user run after a window, put
-  staleAfterSeconds on the cell-producing column:
+  Reuse needs the same play, call id, semantic input, auth scope, and cache
+  policy. Dataset cells are storage; put freshness on the actual call:
 
-    .withColumn('cto', resolver, { staleAfterSeconds: 86400 })
-    .run({ key: 'domain' })
+    await ctx.tools.execute({
+      id: 'find_cto',
+      tool: 'dropleads_search_people',
+      input: { filters: { companyDomains: [row.domain], jobTitles: ['CTO'] }, pagination: { page: 1, limit: 1 } },
+      staleAfterSeconds: 86400,
+    });
 
 Examples:
   deepline plays run prebuilt/person-linkedin-to-email --input '{"linkedin_url":"..."}'
@@ -15240,12 +15574,10 @@ function getterFromLegacyExtractJs(extractJs, fallbackAlias) {
 // src/cli/enrich-compat-adapter.ts
 var ENRICH_COMPAT_DEFAULT_PLAY_NAME = "deepline-enrich-v1-compat";
 var ENRICH_COMPAT_DEFAULT_MAP_NAME = "deepline_enrich_rows";
-var ENRICH_COMPAT_METADATA_CELL_POLICY_SOURCE = "{ recompute: true }";
 function buildEnrichCompatibilityPlan(options = {}) {
   return {
     playName: options.playName?.trim() || ENRICH_COMPAT_DEFAULT_PLAY_NAME,
-    mapName: options.mapName?.trim() || ENRICH_COMPAT_DEFAULT_MAP_NAME,
-    metadataCellPolicySource: ENRICH_COMPAT_METADATA_CELL_POLICY_SOURCE
+    mapName: options.mapName?.trim() || ENRICH_COMPAT_DEFAULT_MAP_NAME
   };
 }
 
@@ -15327,7 +15659,7 @@ function renderExecuteStep(command, options = {
   if (command.play) {
     return renderPlayStep(command, options);
   }
-  if (command.tool === "run_javascript" && options.inlineRunJavascript) {
+  if (command.tool === "run_javascript" && options.inlineRunJavascript && canInlineRunJavascript(command)) {
     return renderInlineJavascriptStep(command, options);
   }
   if (options.idiomaticGetters) {
@@ -15337,9 +15669,7 @@ function renderExecuteStep(command, options = {
   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, extractList, target, get }) => { const input = row; const context = row;
-${indent(renderJavascriptBody(command.extract_js), 6)}
-    }` : "null";
+  const extractJs = renderExtractFunction(command, 6);
   const runIfJs = options.nativeRunIf ? "null" : renderRunIfFunction(command) ?? "null";
   const description = command.description ? `,
       description: ${stringLiteral(command.description)}` : "";
@@ -15365,6 +15695,23 @@ ${indent(renderJavascriptBody(command.extract_js), 6)}
     `}`
   ].join("\n");
 }
+function canInlineRunJavascript(command) {
+  const code = typeof command.payload?.code === "string" ? command.payload.code : "";
+  if (/\btriggerWorkflow\b/.test(code)) {
+    return false;
+  }
+  try {
+    assertUserCodeIsSafe(code, `run_javascript step "${command.alias}"`);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function renderExtractFunction(command, indentSpaces) {
+  return command.extract_js ? `({ row, result, data, raw, pick, extract, extractList, target, get }) => { const input = row; const context = row;
+${indent(renderJavascriptBody(command.extract_js), indentSpaces)}
+    }` : "null";
+}
 function renderRunIfFunction(command) {
   return command.run_if_js ? `(row) => { const input = row; const context = row;
 ${indent(renderJavascriptBody(command.run_if_js), 6)}
@@ -15452,6 +15799,11 @@ function renderPlayStep(command, options) {
   ].join("\n");
 }
 function renderInlineJavascriptStep(command, options) {
+  const alias = stringLiteral(command.alias);
+  const extractJs = renderExtractFunction(command, 4);
+  const legacyEnvelope = options.legacyEnvelope ? "true" : "false";
+  const resultExpression = command.extract_js ? `__dlExtract(${alias}, result, row as Record<string, unknown>, ${extractJs}, ${legacyEnvelope})` : "result";
+  const payload = stableJson(command.payload ?? {});
   const code = typeof command.payload?.code === "string" ? command.payload.code : "return null;";
   const runIfLines = command.run_if_js && !options.nativeRunIf ? [
     `  if (!((row: Record<string, any>) => { const input = row; const context = row;`,
@@ -15462,9 +15814,23 @@ function renderInlineJavascriptStep(command, options) {
     `async (row) => {`,
     ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
     ...runIfLines,
-    `  return ((row: Record<string, any>, input: Record<string, any>, context: Record<string, any>) => {`,
+    ...options.waterfallSoftFail ? [`  try {`] : [],
+    `${options.waterfallSoftFail ? "    " : "  "}const __dlPayload = __dlRuntimePayload('run_javascript', __dlTemplate(${payload}, row as Record<string, unknown>) as Record<string, unknown>, row as Record<string, unknown>);`,
+    `${options.waterfallSoftFail ? "    " : "  "}const rawResult = ((row: Record<string, any>, input: Record<string, any>, context: Record<string, any>) => {`,
+    `${options.waterfallSoftFail ? "    " : "  "}  const payload = __dlPayload as Record<string, any>;`,
+    `${options.waterfallSoftFail ? "    " : "  "}  const extract = __dlInlineExtract;`,
+    `${options.waterfallSoftFail ? "    " : "  "}  const extractList = __dlInlineExtractList;`,
+    `${options.waterfallSoftFail ? "    " : "  "}  return (() => {`,
     indent(renderJavascriptBody(code), 4),
-    `  })(row as Record<string, any>, row as Record<string, any>, row as Record<string, any>);`,
+    `${options.waterfallSoftFail ? "    " : "  "}  })();`,
+    `${options.waterfallSoftFail ? "    " : "  "}})(row as Record<string, any>, row as Record<string, any>, row as Record<string, any>);`,
+    `${options.waterfallSoftFail ? "    " : "  "}const result = await Promise.resolve(rawResult);`,
+    `${options.waterfallSoftFail ? "    " : "  "}return ${resultExpression};`,
+    ...options.waterfallSoftFail ? [
+      `  } catch (error) {`,
+      `    return __dlExtractorFailure(error);`,
+      `  }`
+    ] : [],
     `}`
   ].join("\n");
 }
@@ -15474,18 +15840,16 @@ function renderJavascriptBody(source) {
   if (/^(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(trimmed)) {
     return `return (${trimmed});`;
   }
-  if (trimmed && !trimmed.includes("\n") && !trimmed.includes(";") && !/\breturn\b/.test(trimmed)) {
+  if (trimmed && !trimmed.includes("\n") && !trimmed.includes(";") && !/\breturn\b/.test(trimmed) && !/^(?:throw|if|for|while|switch|try|catch|const|let|var|class|function)\b/.test(
+    trimmed
+  )) {
     return `return (${trimmed});`;
   }
   return source;
 }
 function renderColumnStep(alias, resolverSource, options = {}) {
   const resolver = indent(resolverSource, 8);
-  const optionFields = [
-    ...options.recompute === true ? ["recompute: true"] : [],
-    ...options.recomputeOnError === true ? ["recomputeOnError: true"] : [],
-    ...options.runIfSource ? [`runIf: ${options.runIfSource}`] : []
-  ];
+  const optionFields = options.runIfSource ? [`runIf: ${options.runIfSource}`] : [];
   const optionSource = optionFields.length > 0 ? `{ ${optionFields.join(", ")} }` : null;
   return [
     `      .withColumn(${stringLiteral(alias)},`,
@@ -15562,7 +15926,7 @@ function collectGeneratedAliases(commands) {
   }
   return aliases;
 }
-function renderMetadataColumnStep(config, policySource) {
+function renderMetadataColumnStep(config) {
   const columns = collectMetadataColumns(config.commands);
   if (Object.keys(columns).length === 0) {
     return "";
@@ -15570,7 +15934,6 @@ function renderMetadataColumnStep(config, policySource) {
   return [
     `      .withColumn('_metadata',`,
     `        (row) => __dlMergeMetadata(__dlMetadataFromRow(row), ${stableJson({ columns })}),`,
-    `        ${policySource},`,
     `      )`
   ].join("\n");
 }
@@ -15605,16 +15968,11 @@ function renderWaterfallColumns(command, forceAliases, inlineRunJavascript, idio
         nativeRunIf: Boolean(runIfSource)
       }),
       {
-        recompute: force,
-        recomputeOnError: true,
         runIfSource
       }
     );
   }).filter((line) => line !== null);
   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)
@@ -15624,13 +15982,10 @@ function renderWaterfallColumns(command, forceAliases, inlineRunJavascript, idio
   }
   return [
     ...columnSteps,
-    renderColumnStep(command.with_waterfall, `(row) => ${returnExpr}`, {
-      recompute: forceParent
-    }),
+    renderColumnStep(command.with_waterfall, `(row) => ${returnExpr}`),
     renderColumnStep(
       `${command.with_waterfall}_source`,
-      typeof command.min_results === "number" ? `(row) => __dlContributingAliases(row, ${stableJson(aliases)})` : `(row) => __dlFirstMeaningfulAlias(row, ${stableJson(aliases)})`,
-      { recompute: forceParent }
+      typeof command.min_results === "number" ? `(row) => __dlContributingAliases(row, ${stableJson(aliases)})` : `(row) => __dlFirstMeaningfulAlias(row, ${stableJson(aliases)})`
     )
   ];
 }
@@ -15670,19 +16025,15 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
           nativeRunIf: Boolean(runIfSource)
         }),
         {
-          recompute: force,
-          recomputeOnError: true,
           runIfSource
         }
       )
     );
   });
   const columnStepSource = columnSteps.length > 0 ? columnSteps.join("\n") : `      .withColumn('noop', () => null)`;
-  const metadataColumnSource = renderMetadataColumnStep(
-    config,
-    compatibility.metadataCellPolicySource
-  );
+  const metadataColumnSource = renderMetadataColumnStep(config);
   const generatedAliases = collectGeneratedAliases(config.commands);
+  const runOptionsSource = options.failFast ? `{ key: (row, index) => __dlEnrichRowKey(row, index + rowStart), onRowError: 'fail' as const }` : `{ key: (row, index) => __dlEnrichRowKey(row, index + rowStart) }`;
   const body = [
     `export default definePlay(${stringLiteral(playName)}, async (ctx, input: EnrichInput) => {`,
     `  const sourceRows = await ctx.csv<Record<string, unknown>>(input.file);`,
@@ -15693,7 +16044,7 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
     `  for await (const row of sourceRows) {`,
     `    if (rowEndExclusive !== undefined && sourceRowIndex >= rowEndExclusive) break;`,
     `    if (sourceRowIndex >= rowStart) {`,
-    `      rows.push(__dlPrepareEnrichRow(row, ${stableJson(generatedAliases)}));`,
+    `      rows.push(__dlPrepareEnrichRow(row, ${stableJson(generatedAliases)}, sourceRowIndex));`,
     `    }`,
     `    sourceRowIndex += 1;`,
     `  }`,
@@ -15701,7 +16052,7 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
     `    .dataset(${stringLiteral(mapName)}, rows)`,
     columnStepSource,
     ...metadataColumnSource ? [metadataColumnSource] : [],
-    `    .run({ key: (row, index) => __dlStableRowKey(row, index + rowStart) });`,
+    `    .run(${runOptionsSource});`,
     `  return { rows: enriched, count: await enriched.count() };`,
     `}, { description: ${stringLiteral("Read a CSV file, run the configured Deepline enrich commands, and return enriched rows.")} });`
   ];
@@ -15910,6 +16261,7 @@ function helperSource() {
     `  if (typeof value === 'string') {`,
     `    const lower = value.trim().toLowerCase();`,
     `    if (!lower) return false;`,
+    `    if (/^column\\s+.+\\s+failed\\b/.test(lower)) return true;`,
     `    if (lower.startsWith('error:') || lower.includes(': error:') || lower.includes('"error"')) return true;`,
     `    try {`,
     `      return __dlGeneratedCellError(JSON.parse(value));`,
@@ -15953,12 +16305,14 @@ function helperSource() {
     `  return context;`,
     `}`,
     ``,
-    `function __dlPrepareEnrichRow(row: Record<string, unknown>, aliases: string[]): Record<string, unknown> {`,
+    `function __dlPrepareEnrichRow(row: Record<string, unknown>, aliases: string[], sourceRowIndex?: number): Record<string, unknown> {`,
     `  const cleaned = __dlStripErroredGeneratedColumns(row, aliases);`,
     `  const templateContext = __dlTemplateContext(cleaned);`,
     `  return {`,
     `    ...templateContext,`,
     `    ...cleaned,`,
+    `    ...(typeof sourceRowIndex === 'number' && '__deeplineSourceRowIndex' in cleaned ? { __deeplineOriginalSourceRowIndex: cleaned.__deeplineSourceRowIndex } : {}),`,
+    `    ...(typeof sourceRowIndex === 'number' ? { __deeplineSourceRowIndex: sourceRowIndex } : {}),`,
     `    __deeplineCsvProjectedFields: Object.keys(templateContext),`,
     `    __deeplineCsvProjectedValues: templateContext,`,
     `  };`,
@@ -16049,6 +16403,10 @@ function helperSource() {
     `  return String(index);`,
     `}`,
     ``,
+    `function __dlEnrichRowKey(row: Record<string, unknown>, index: number): string {`,
+    "  return `${__dlStableRowKey(row, index)}:${index}`;",
+    `}`,
+    ``,
     `function __dlScalarValue(value: unknown): unknown {`,
     `  if (value && typeof value === 'object' && !Array.isArray(value)) {`,
     `    const record = value as Record<string, unknown>;`,
@@ -16261,6 +16619,29 @@ function helperSource() {
     ``,
     `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 __dlInlineExtractorArgs(args: unknown[]): { payload: unknown; selector: unknown } {`,
+    `  if (args.length >= 3) return { payload: args[1], selector: args[2] };`,
+    `  if (args.length >= 2) return { payload: args[0], selector: args[1] };`,
+    `  return { payload: args[0], selector: undefined };`,
+    `}`,
+    ``,
+    `function __dlInlineExtract(...args: unknown[]): unknown {`,
+    `  const { payload, selector } = __dlInlineExtractorArgs(args);`,
+    `  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') return __dlExtractTarget(payload, selector) ?? __dlFirstByPaths(payload, selector);`,
+    `  return selector;`,
+    `}`,
+    ``,
+    `function __dlInlineExtractList(...args: unknown[]): unknown[] {`,
+    `  const { payload, selector } = __dlInlineExtractorArgs(args);`,
+    `  const rows = __dlFindList(payload, selector);`,
+    `  const keys = __dlSelectorKeys(selector);`,
+    `  return keys ? __dlProjectListRows(rows, keys, payload) : rows;`,
+    `}`,
+    ``,
     `function __dlErrorMessage(error: unknown): string {`,
     `  if (error instanceof Error && error.message) return error.message;`,
     `  if (typeof error === 'string' && error.trim()) return error.trim();`,
@@ -16282,8 +16663,8 @@ function helperSource() {
     `  return /\\b5\\d\\d\\b/.test(detail) || detail.includes('upstream_failure') || detail.includes('"error_category":"upstream"') || (detail.includes('"failure_origin":"provider"') && detail.includes('"status":5')) || detail.includes('bad gateway') || detail.includes('gateway time-out') || detail.includes('gateway timeout') || detail.includes('service unavailable');`,
     `}`,
     ``,
-    `function __dlWaterfallToolFailure(error: unknown): unknown {`,
-    `  if (__dlRecoverableWaterfallToolError(error)) return __dlExtractorFailure(error);`,
+    `function __dlWaterfallToolFailure(error: unknown, tool?: string): unknown {`,
+    `  if (tool === 'run_javascript' || __dlRecoverableWaterfallToolError(error)) return __dlExtractorFailure(error);`,
     `  throw error;`,
     `}`,
     ``,
@@ -16420,7 +16801,7 @@ function helperSource() {
     `      ...(input.force ? { force: true } : {}),`,
     `    });`,
     `  } catch (error) {`,
-    `    if (input.waterfallSoftFail) return __dlWaterfallToolFailure(error);`,
+    `    if (input.waterfallSoftFail) return __dlWaterfallToolFailure(error, input.tool);`,
     `    throw error;`,
     `  }`,
     `  return __dlExtract(input.alias, result, input.row, input.extract, Boolean(input.legacyEnvelope));`,
@@ -16431,6 +16812,10 @@ function helperSource() {
 // src/cli/commands/enrich.ts
 var ENRICH_EXPORT_PAGE_SIZE = 5e3;
 var ENRICH_AUTO_BATCH_ROWS = 250;
+var ENRICH_EXPORT_BACKING_ROWS_WAIT_MS = 6e4;
+var ENRICH_EXPORT_BACKING_ROWS_POLL_MS = 1e3;
+var ENRICH_SOURCE_ROW_INDEX_COLUMN = "__deeplineSourceRowIndex";
+var ENRICH_ORIGINAL_SOURCE_ROW_INDEX_COLUMN = "__deeplineOriginalSourceRowIndex";
 var EXIT_SERVER2 = 5;
 var ENRICH_DEBUG_T0 = Date.now();
 var GENERATED_ENRICH_ROWS_TABLE_NAMESPACE = "deepline_enrich_rows";
@@ -16545,6 +16930,17 @@ function emitEnrichDebug(message) {
 `
   );
 }
+function sleep6(ms) {
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
+}
+function enrichExportBackingRowsWaitMs() {
+  const raw = process.env.DEEPLINE_ENRICH_EXPORT_BACKING_ROWS_WAIT_MS?.trim();
+  if (!raw) {
+    return ENRICH_EXPORT_BACKING_ROWS_WAIT_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : ENRICH_EXPORT_BACKING_ROWS_WAIT_MS;
+}
 function emitEnrichDebugValidationLines(config) {
   for (const line of buildEnrichDebugValidationLines(config)) {
     emitEnrichDebug(line);
@@ -16557,10 +16953,10 @@ function expandAtFilePath(rawPath) {
     (_match, bareName, bracedName) => process.env[bareName ?? bracedName ?? ""] ?? ""
   );
   if (expanded === "~") {
-    return (0, import_node_os7.homedir)();
+    return (0, import_node_os8.homedir)();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return (0, import_node_path11.join)((0, import_node_os7.homedir)(), expanded.slice(2));
+    return (0, import_node_path12.join)((0, import_node_os8.homedir)(), expanded.slice(2));
   }
   return expanded;
 }
@@ -16694,6 +17090,7 @@ async function buildPlanArgs(args) {
     "--dry-run",
     "--json",
     "--force",
+    "--fail-fast",
     "--all",
     "--in-place",
     "--no-open"
@@ -16744,7 +17141,7 @@ async function buildPlanArgs(args) {
   return planArgs;
 }
 async function assertInputCsvExists(inputCsv) {
-  const path = (0, import_node_path11.resolve)(inputCsv);
+  const path = (0, import_node_path12.resolve)(inputCsv);
   try {
     const info = await (0, import_promises3.stat)(path);
     if (info.isFile()) {
@@ -16758,8 +17155,8 @@ async function assertInputCsvExists(inputCsv) {
   }
 }
 async function assertSafeOutputPath(inputCsv, outputPath) {
-  const input2 = (0, import_node_path11.resolve)(inputCsv);
-  const output2 = (0, import_node_path11.resolve)(outputPath);
+  const input2 = (0, import_node_path12.resolve)(inputCsv);
+  const output2 = (0, import_node_path12.resolve)(outputPath);
   if (input2 === output2) {
     throw new Error(
       "--input and --output must be different files when not using --in-place."
@@ -16788,7 +17185,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await (0, import_promises3.stat)((0, import_node_path11.resolve)(path));
+    const info = await (0, import_promises3.stat)((0, import_node_path12.resolve)(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -16799,7 +17196,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await (0, import_promises3.readFile)((0, import_node_path11.resolve)(path), "utf8");
+  const source = await (0, import_promises3.readFile)((0, import_node_path12.resolve)(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -17076,15 +17473,47 @@ function isPlayStartStreamEndedError(error) {
     "Play start stream ended before a terminal status"
   );
 }
-async function runGeneratedEnrichPlay(runArgs, options = {}) {
+function runIdFromGeneratedEnrichWatchError(error) {
+  if (error instanceof DeeplineError) {
+    const detailRunId = typeof error.details?.runId === "string" ? error.details.runId : typeof error.details?.workflowId === "string" ? error.details.workflowId : null;
+    if (detailRunId?.trim()) {
+      return detailRunId.trim();
+    }
+  }
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return message.match(/\b(play\/\S+\/run\/\S+)/)?.[1] ?? null;
+}
+function shouldStopGeneratedEnrichRunAfterWatchError(error) {
+  if (error instanceof DeeplineError) {
+    return error.code === "PLAY_WAIT_TIMEOUT" || error.code === "PLAY_START_STREAM_ENDED" || error.code === "PLAY_LIVE_STREAM_ENDED";
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("Timed out waiting for play") || error.message.includes("ended before a terminal status");
+}
+async function stopGeneratedEnrichRunAfterWatchError(client2, error) {
+  if (!shouldStopGeneratedEnrichRunAfterWatchError(error)) {
+    return;
+  }
+  const runId = runIdFromGeneratedEnrichWatchError(error);
+  if (!runId) {
+    return;
+  }
+  await client2.runs.stop(runId, {
+    reason: "deepline enrich watch exited before terminal status"
+  }).catch(() => void 0);
+}
+async function runGeneratedEnrichPlay(client2, runArgs, options = {}) {
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
       return await captureStdout(() => handlePlayRun(runArgs), {
         passthrough: options.passthroughStdout
       });
     } catch (error) {
+      await stopGeneratedEnrichRunAfterWatchError(client2, error);
       if (attempt === 0 && isPlayStartStreamEndedError(error)) {
-        await new Promise((resolve13) => setTimeout(resolve13, 250));
+        await sleep6(250);
         continue;
       }
       throw error;
@@ -17104,20 +17533,41 @@ async function writeOutputCsv(outputPath, status, options) {
       "The generated play did not return row-shaped output, and no durable enrich rows were available to export."
     );
   }
-  if (options?.client) {
-    rowsInfo = await fetchBackingRowsForCsvExport({
-      client: options.client,
-      status,
-      rowsInfo
-    }).catch(() => null) ?? rowsInfo;
+  const selectedSourceRows = selectedSourceCsvRowCount(options);
+  const shouldFetchBackingRows = options?.client && shouldFetchBackingRowsForEnrichExport(rowsInfo, status, {
+    selectedSourceRows
+  });
+  if (options?.client && shouldFetchBackingRows) {
+    let fetchedRowsInfo = null;
+    try {
+      fetchedRowsInfo = await fetchBackingRowsForCsvExport({
+        client: options.client,
+        status,
+        rowsInfo,
+        sourceRowStart: options.rows?.rowStart ?? 0,
+        expectedRows: selectedSourceRows
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch durable generated enrich rows for CSV export: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    rowsInfo = fetchedRowsInfo ?? rowsInfo;
   }
   const allowPartial = options?.allowPartial === true && !rowsInfo.complete && rowsInfo.rows.length > 0 && Boolean(options?.sourceCsvPath);
   assertCompleteRowsForCsvExport(rowsInfo, status, outputPath, {
     allowPartial
   });
+  const statusFailureMessages = options?.config && rowsInfo.rows.length > 0 ? collectCompleteStatusFailureMessages({
+    config: options.config,
+    status,
+    rowRange: options.rows ?? { rowStart: 0, rowEnd: null },
+    rowCount: rowsInfo.rows.length
+  }) : /* @__PURE__ */ new Map();
   const merged = mergeRowsForCsvExport(rowsInfo.rows, {
     ...options,
-    allowPartial
+    allowPartial,
+    statusFailureMessages
   });
   const columns = orderEnrichCsvColumns(
     dataExportColumns(merged.rows, [
@@ -17127,7 +17577,7 @@ async function writeOutputCsv(outputPath, status, options) {
     options?.config
   );
   await (0, import_promises3.writeFile)(
-    (0, import_node_path11.resolve)(outputPath),
+    (0, import_node_path12.resolve)(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
   );
@@ -17137,7 +17587,7 @@ async function writeOutputCsv(outputPath, status, options) {
     selectedRows: rowsInfo.totalRows,
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
-    path: (0, import_node_path11.resolve)(outputPath),
+    path: (0, import_node_path12.resolve)(outputPath),
     partial: !rowsInfo.complete,
     enrichedDataRows: rowsInfo.rows
   };
@@ -17181,16 +17631,23 @@ async function buildEnrichFailureReport(input2) {
     rows: input2.rows,
     rowRange: input2.rowRange,
     client: input2.client,
-    outputPath: input2.exportResult?.path ?? input2.outputPath ?? null
+    outputPath: input2.exportResult?.path ?? input2.outputPath ?? null,
+    status: input2.status
   });
 }
 function recordField(value, key) {
   return value && typeof value === "object" && !Array.isArray(value) ? value[key] : void 0;
 }
 function extractRunId(status) {
+  const run = recordField(status, "run");
+  const nestedRun = recordField(run, "run");
   const candidates = [
     recordField(status, "runId"),
-    recordField(recordField(status, "run"), "id")
+    recordField(status, "id"),
+    recordField(run, "runId"),
+    recordField(run, "id"),
+    recordField(nestedRun, "runId"),
+    recordField(nestedRun, "id")
   ];
   for (const candidate of candidates) {
     if (typeof candidate === "string" && candidate.trim()) {
@@ -17265,20 +17722,102 @@ function fallbackRowsInfoForGeneratedEnrichExport(status, options) {
   if (totalRows === null) {
     return null;
   }
-  const tableNamespaces = /* @__PURE__ */ new Set();
-  collectStringFields(status, "tableNamespace", tableNamespaces);
-  collectStringFields(status, "artifactTableNamespace", tableNamespaces);
-  const tableNamespace = tableNamespaces.values().next().value ?? GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
   return {
     rows: [],
     totalRows,
     columns: [],
     columnsExplicit: false,
     complete: false,
-    source: tableNamespace,
-    tableNamespace
+    source: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE,
+    tableNamespace: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE
   };
 }
+function hasLossyPreviewPlaceholder(value, depth = 0) {
+  if (depth > 8) {
+    return false;
+  }
+  if (value === "[Array]" || value === "[Object]") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some((item) => hasLossyPreviewPlaceholder(item, depth + 1));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some(
+      (item) => hasLossyPreviewPlaceholder(item, depth + 1)
+    );
+  }
+  return false;
+}
+function shouldFetchBackingRowsForEnrichExport(rowsInfo, status, options = {}) {
+  const terminalStatus = readEnrichRunStatus(status);
+  const tableNamespace = rowsInfo.tableNamespace?.trim();
+  if (terminalStatus === "failed" || terminalStatus === "cancelled") {
+    return tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && (rowsInfo.recovered === true || hasPartialRunOutputWarning(status));
+  }
+  if (tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && typeof options.selectedSourceRows === "number" && rowsInfo.rows.length < options.selectedSourceRows) {
+    return true;
+  }
+  if (tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && hasFailedRowSignal(status)) {
+    return true;
+  }
+  if (!rowsInfo.complete) {
+    return tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  }
+  return rowsInfo.rows.some((row) => hasLossyPreviewPlaceholder(row));
+}
+function hasPartialRunOutputWarning(status) {
+  const warningLists = [
+    recordField(status, "warnings"),
+    recordField(recordField(status, "run"), "warnings")
+  ];
+  return warningLists.some(
+    (warnings) => Array.isArray(warnings) && warnings.some(
+      (warning) => typeof warning === "string" && warning.includes("Run output is partial: showing") && warning.includes("preview row(s)")
+    )
+  );
+}
+function numericFailedRowSignal(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return 0;
+  }
+  const match = value.match(/^\s*(\d+)/);
+  return match ? Number(match[1]) : 0;
+}
+function hasFailedRowSignal(value, depth = 0) {
+  if (depth > 16 || !value || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.some((item) => hasFailedRowSignal(item, depth + 1));
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if ((normalizedKey === "failed" || normalizedKey === "failedrows" || normalizedKey === "failedcount") && numericFailedRowSignal(child) > 0) {
+      return true;
+    }
+    if (hasFailedRowSignal(child, depth + 1)) {
+      return true;
+    }
+  }
+  return false;
+}
+function readEnrichRunStatus(status) {
+  const candidates = [
+    recordField(status, "status"),
+    recordField(recordField(status, "run"), "status"),
+    recordField(recordField(status, "progress"), "status")
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim().toLowerCase();
+    }
+  }
+  return null;
+}
 function firstCollectedStringField(value, key) {
   const fields = /* @__PURE__ */ new Set();
   collectStringFields(value, key, fields);
@@ -17306,14 +17845,22 @@ function emitPlainBatchRunFailure(input2) {
     );
   }
 }
-function exportableSheetRow2(row) {
+function exportableSheetRow2(row, sourceRowStart = 0) {
   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 exported = { ...data };
+    const inputIndex = typeof record.inputIndex === "number" ? record.inputIndex : typeof record.inputIndex === "string" && record.inputIndex.trim() ? Number(record.inputIndex) : Number.NaN;
+    if (Number.isInteger(inputIndex) && inputIndex >= 0) {
+      if (ENRICH_SOURCE_ROW_INDEX_COLUMN in exported) {
+        exported[ENRICH_ORIGINAL_SOURCE_ROW_INDEX_COLUMN] = exported[ENRICH_SOURCE_ROW_INDEX_COLUMN];
+      }
+      exported[ENRICH_SOURCE_ROW_INDEX_COLUMN] = sourceRowStart + inputIndex;
+    }
+    return exported;
   }
   const fallback = { ...record };
   for (const key of [
@@ -17333,6 +17880,28 @@ function exportableSheetRow2(row) {
   }
   return fallback;
 }
+function sourceRowIndexFromEnrichRow(row, start, end) {
+  const value = row[ENRICH_SOURCE_ROW_INDEX_COLUMN];
+  const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  if (!Number.isInteger(parsed) || parsed < start || parsed > end) {
+    return null;
+  }
+  return parsed;
+}
+function stripEnrichSourceRowIndex(row) {
+  if (!(ENRICH_SOURCE_ROW_INDEX_COLUMN in row)) {
+    return row;
+  }
+  const stripped = { ...row };
+  const hadOriginal = ENRICH_ORIGINAL_SOURCE_ROW_INDEX_COLUMN in stripped;
+  const originalSourceRowIndex = stripped[ENRICH_ORIGINAL_SOURCE_ROW_INDEX_COLUMN];
+  delete stripped[ENRICH_SOURCE_ROW_INDEX_COLUMN];
+  delete stripped[ENRICH_ORIGINAL_SOURCE_ROW_INDEX_COLUMN];
+  if (hadOriginal) {
+    stripped[ENRICH_SOURCE_ROW_INDEX_COLUMN] = originalSourceRowIndex;
+  }
+  return stripped;
+}
 function collectHardFailureAliases(config) {
   const aliases = [];
   const seen = /* @__PURE__ */ new Set();
@@ -17354,6 +17923,14 @@ function collectHardFailureAliases(config) {
 }
 function cellFailureError(value) {
   const parsed = parseMaybeJsonObject(value);
+  if (!isRecord7(parsed)) {
+    const text = typeof parsed === "string" ? parsed.trim() : "";
+    if (/^(?:[A-Za-z0-9_:-]+:\s*)?(?:Error|TypeError|ReferenceError|SyntaxError|RangeError):\s+/.test(
+      text
+    ) || /^(?:[A-Za-z0-9_:-]+:\s*)?Column status:\s*(?:error|failed)\b/i.test(text)) {
+      return { message: text };
+    }
+  }
   if (!isRecord7(parsed)) {
     return null;
   }
@@ -17385,7 +17962,9 @@ function buildEnrichWaterfallSummaryLines(config, rows) {
         continue;
       }
       const failures = rows.filter(
-        (row) => cellFailureError(row[child.alias])
+        (row) => aliasFailureCellCandidates(row, child.alias).some(
+          (candidate) => Boolean(cellFailureError(candidate))
+        )
       ).length;
       if (failures > 0) {
         lines.push(
@@ -17396,6 +17975,56 @@ function buildEnrichWaterfallSummaryLines(config, rows) {
   }
   return lines;
 }
+function aliasFailureCellCandidates(row, alias) {
+  const candidates = [row[alias]];
+  const nested = {};
+  const dottedPrefix = `${alias}.`;
+  const underscorePrefix = `${alias}__`;
+  for (const [key, value] of Object.entries(row)) {
+    if (key.startsWith(dottedPrefix)) {
+      assignFlattenedFailurePath(nested, key.slice(dottedPrefix.length), value);
+    } else if (key.startsWith(underscorePrefix)) {
+      assignFlattenedFailurePath(nested, key.slice(underscorePrefix.length), value);
+    }
+  }
+  if (Object.keys(nested).length > 0) {
+    candidates.push(nested);
+  }
+  return candidates;
+}
+function assignFlattenedFailurePath(target, field, value) {
+  const parts = field.includes(".") ? field.split(".") : field.split("__");
+  const normalized = parts.map((part) => part.trim()).filter(Boolean);
+  if (normalized.length <= 1) {
+    target[field] = value;
+    return;
+  }
+  let cursor = target;
+  for (const part of normalized.slice(0, -1)) {
+    const existing = cursor[part];
+    if (!isRecord7(existing)) {
+      const next = {};
+      cursor[part] = next;
+      cursor = next;
+    } else {
+      cursor = existing;
+    }
+  }
+  cursor[normalized[normalized.length - 1] ?? field] = value;
+}
+function aliasFlattenedCells(row, alias) {
+  const cells = [];
+  const dottedPrefix = `${alias}.`;
+  const underscorePrefix = `${alias}__`;
+  for (const [key, value] of Object.entries(row)) {
+    if (key.startsWith(dottedPrefix)) {
+      cells.push({ field: key.slice(dottedPrefix.length), value });
+    } else if (key.startsWith(underscorePrefix)) {
+      cells.push({ field: key.slice(underscorePrefix.length), value });
+    }
+  }
+  return cells;
+}
 function collectEnrichFailureJobs(input2) {
   const aliases = collectHardFailureAliases(input2.config);
   if (aliases.length === 0 || input2.rows.length === 0) {
@@ -17405,11 +18034,13 @@ function collectEnrichFailureJobs(input2) {
   const jobs = [];
   input2.rows.forEach((row, rowIndex) => {
     aliases.forEach((alias, aliasIndex) => {
-      const failure = cellFailureError(row[alias]);
+      const failure = aliasFailureCellCandidates(row, alias).map(cellFailureError).find(
+        (candidate) => Boolean(candidate)
+      );
       if (!failure) {
         return;
       }
-      const rowId = rowOffset + rowIndex;
+      const rowId = sourceRowIndexFromEnrichRow(row, 0, Number.MAX_SAFE_INTEGER) ?? rowOffset + rowIndex;
       jobs.push({
         job_id: `row-${rowId}-${alias}`,
         row_id: rowId,
@@ -17425,6 +18056,72 @@ function collectEnrichFailureJobs(input2) {
   });
   return jobs;
 }
+function collectStatusFailureJobs(input2) {
+  const aliases = collectHardFailureAliases(input2.config);
+  if (aliases.length === 0) {
+    return [];
+  }
+  const summaries = collectColumnStats(input2.status);
+  const rowStart = input2.rowRange.rowStart ?? 0;
+  const selectedRows = input2.rowRange.rowEnd !== null && input2.rowRange.rowEnd >= rowStart ? input2.rowRange.rowEnd - rowStart + 1 : Number.MAX_SAFE_INTEGER;
+  const jobs = [];
+  aliases.forEach((alias, aliasIndex) => {
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord7);
+    if (!stat2) {
+      return;
+    }
+    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+    const failedCount = Math.min(
+      selectedRows,
+      Math.max(
+        numericFailedRowSignal(stat2.failed),
+        numericFailedRowSignal(stat2.failedRows),
+        numericFailedRowSignal(execution?.failed)
+      )
+    );
+    if (!Number.isFinite(failedCount) || failedCount <= 0) {
+      return;
+    }
+    const message = firstCollectedStringField(stat2, "error") ?? firstCollectedStringField(stat2, "message") ?? `Column ${alias} failed for ${failedCount} row(s).`;
+    for (let offset = 0; offset < failedCount; offset += 1) {
+      const rowId = rowStart + offset;
+      jobs.push({
+        job_id: `row-${rowId}-${alias}`,
+        row_id: rowId,
+        col_index: aliasIndex,
+        column: alias,
+        status: "failed",
+        last_error: message,
+        error: message
+      });
+    }
+  });
+  return jobs;
+}
+function collectCompleteStatusFailureMessages(input2) {
+  const requiredCount = Math.max(1, Math.trunc(input2.rowCount));
+  const jobs = collectStatusFailureJobs({
+    config: input2.config,
+    status: input2.status,
+    rowRange: input2.rowRange
+  });
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const job of jobs) {
+    const alias = normalizeAlias2(job.column);
+    const existing = byAlias.get(alias);
+    byAlias.set(alias, {
+      count: (existing?.count ?? 0) + 1,
+      message: existing?.message ?? job.last_error
+    });
+  }
+  const complete = /* @__PURE__ */ new Map();
+  for (const [alias, value] of byAlias) {
+    if (value.count >= requiredCount) {
+      complete.set(alias, value.message);
+    }
+  }
+  return complete;
+}
 function parseExecutionCount(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return Math.max(0, Math.trunc(value));
@@ -17567,9 +18264,9 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0) {
     return null;
   }
-  const stateDir = (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".local", "deepline", "runtime", "state");
+  const stateDir = (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".local", "deepline", "runtime", "state");
   await (0, import_promises3.mkdir)(stateDir, { recursive: true });
-  const reportPath = (0, import_node_path11.join)(
+  const reportPath = (0, import_node_path12.join)(
     stateDir,
     `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -17598,11 +18295,16 @@ async function persistEnrichFailureReport(input2) {
   return reportPath;
 }
 async function maybeEmitEnrichFailureReport(input2) {
-  const jobs = collectEnrichFailureJobs({
+  const rowJobs = collectEnrichFailureJobs({
     config: input2.config,
     rows: input2.rows,
     rowStart: input2.rowRange.rowStart
   });
+  const jobs = rowJobs.length > 0 || input2.status === void 0 ? rowJobs : collectStatusFailureJobs({
+    config: input2.config,
+    status: input2.status,
+    rowRange: input2.rowRange
+  });
   if (jobs.length === 0) {
     return null;
   }
@@ -17660,75 +18362,139 @@ function mergePreferredColumns(preferredColumns, rows) {
 async function fetchBackingRowsForCsvExport(input2) {
   const runId = extractRunId(input2.status);
   const playName = extractPlayName2(input2.status);
-  const tableNamespace = input2.rowsInfo.tableNamespace?.trim();
+  const tableNamespace = input2.rowsInfo.tableNamespace?.trim() || GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
   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,
-      rowMode: "all"
-    });
-    sheetRows.push(...page.rows);
-    const summaryTotal = page.summary?.stats?.total;
-    if (typeof summaryTotal === "number" && Number.isFinite(summaryTotal)) {
-      expectedTotal = Math.max(expectedTotal, Math.trunc(summaryTotal));
+  const deadline = Date.now() + enrichExportBackingRowsWaitMs();
+  let lastRows = [];
+  const minimumExpectedRows = typeof input2.expectedRows === "number" && input2.expectedRows > 0 ? Math.trunc(input2.expectedRows) : input2.rowsInfo.totalRows;
+  let lastExpectedTotal = minimumExpectedRows;
+  for (; ; ) {
+    const sheetRows = [];
+    let offset = 0;
+    let expectedTotal = minimumExpectedRows;
+    while (true) {
+      const page = await input2.client.runs.exportDatasetRows({
+        playName,
+        tableNamespace,
+        runId,
+        limit: ENRICH_EXPORT_PAGE_SIZE,
+        offset,
+        rowMode: "all"
+      });
+      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;
     }
-    if (page.rows.length < ENRICH_EXPORT_PAGE_SIZE || sheetRows.length >= expectedTotal) {
+    const rows = sheetRows.map((row) => exportableSheetRow2(row, input2.sourceRowStart ?? 0)).filter((row) => Boolean(row));
+    lastRows = rows;
+    lastExpectedTotal = expectedTotal;
+    if (expectedTotal > 0 && rows.length >= expectedTotal || expectedTotal === 0 && rows.length > 0) {
+      return {
+        ...input2.rowsInfo,
+        rows,
+        columns: mergePreferredColumns(
+          input2.rowsInfo.columnsExplicit ? input2.rowsInfo.columns : [],
+          rows
+        ),
+        totalRows: Math.max(rows.length, expectedTotal),
+        complete: true,
+        source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
+      };
+    }
+    if (Date.now() >= deadline) {
       break;
     }
-    offset += page.rows.length;
+    await sleep6(ENRICH_EXPORT_BACKING_ROWS_POLL_MS);
   }
-  const rows = sheetRows.map(exportableSheetRow2).filter((row) => Boolean(row));
-  if (rows.length < input2.rowsInfo.totalRows) {
+  if (lastRows.length <= input2.rowsInfo.rows.length) {
     return null;
   }
   return {
     ...input2.rowsInfo,
-    rows,
+    rows: lastRows,
     columns: mergePreferredColumns(
       input2.rowsInfo.columnsExplicit ? input2.rowsInfo.columns : [],
-      rows
+      lastRows
     ),
-    totalRows: rows.length,
-    complete: true,
+    totalRows: Math.max(lastExpectedTotal, input2.rowsInfo.totalRows),
+    complete: false,
     source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
   };
 }
 function mergeRowsForCsvExport(enrichedRows, options) {
-  const rows = dataExportRows(normalizeEnrichRowsForCsvExport(enrichedRows));
+  const rows = dataExportRows(
+    normalizeEnrichRowsForCsvExport(enrichedRows, options?.config, {
+      statusFailureMessages: options?.statusFailureMessages
+    })
+  );
   const range = options?.rows;
-  if (!options?.sourceCsvPath || !options.inPlace && !options.allowPartial && (range?.rowStart === null || range?.rowStart === void 0)) {
-    return { rows, preferredColumns: [] };
+  if (!options?.sourceCsvPath) {
+    return {
+      rows: rows.map(stripEnrichSourceRowIndex),
+      preferredColumns: []
+    };
   }
   const parsedBaseRows = readCsvRows(options.sourceCsvPath);
   const preferredColumns = Object.keys(parsedBaseRows[0] ?? {});
   const baseRows = parsedBaseRows.map(
-    (row) => ({ ...row })
+    (row) => ({
+      ...row
+    })
   );
   const start = Math.max(0, range?.rowStart ?? 0);
   const maxEnd = Math.max(start, baseRows.length - 1);
   const inclusiveEnd = range?.rowEnd === null || range?.rowEnd === void 0 ? maxEnd : Math.min(maxEnd, range.rowEnd);
   const expectedSelectedRows = baseRows.length === 0 ? 0 : Math.max(0, inclusiveEnd - start + 1);
-  if (rows.length < expectedSelectedRows && !options.allowPartial) {
+  const canMergeSparseBySourceIndex = rows.length > 0 && rows.every(
+    (row) => sourceRowIndexFromEnrichRow(row, start, inclusiveEnd) !== null
+  );
+  if (rows.length < expectedSelectedRows && !options.allowPartial && !canMergeSparseBySourceIndex) {
     throw new Error(
       `Refusing to write a partial in-place CSV export: the run returned ${rows.length} row(s) for ${expectedSelectedRows} selected source row(s).`
     );
   }
   const merged = [...baseRows];
+  if (canMergeSparseBySourceIndex) {
+    for (const rawEnriched of rows) {
+      const rowIndex = sourceRowIndexFromEnrichRow(
+        rawEnriched,
+        start,
+        inclusiveEnd
+      );
+      if (rowIndex === null) {
+        continue;
+      }
+      const enriched = stripEnrichSourceRowIndex(rawEnriched);
+      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 };
+  }
   let selectedIndex = 0;
   for (let rowIndex = start; rowIndex <= inclusiveEnd; rowIndex += 1) {
-    const enriched = rows[selectedIndex++];
-    if (!enriched) {
+    const rawEnriched = rows[selectedIndex++];
+    if (!rawEnriched) {
       break;
     }
+    const enriched = stripEnrichSourceRowIndex(rawEnriched);
     const base = merged[rowIndex] ?? {};
     merged[rowIndex] = {
       ...base,
@@ -17807,21 +18573,146 @@ function orderEnrichCsvColumns(columns, config) {
 function isNonEmptyCsvCell(value) {
   return value !== null && value !== void 0 && String(value).trim() !== "";
 }
-function normalizeEnrichRowsForCsvExport(rows) {
+var ENRICH_FLATTENED_SUCCESS_FIELD_PRIORITY = [
+  "matched_result",
+  "matchedResult",
+  "value",
+  "email",
+  "url",
+  "domain",
+  "name",
+  "result"
+];
+var ENRICH_FLATTENED_CONTROL_FIELDS = /* @__PURE__ */ new Set([
+  "error",
+  "last_error",
+  "message",
+  "operation",
+  "provider",
+  "status"
+]);
+function materializeCsvCellValue(value) {
+  if (value && typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function materializeAliasSuccessCell(row, alias) {
+  const direct = row[alias];
+  if (isRecord7(direct)) {
+    if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
+      return materializeCsvCellValue(direct);
+    }
+    const directCells = [];
+    for (const [field, value] of Object.entries(direct)) {
+      if (ENRICH_FLATTENED_CONTROL_FIELDS.has(field)) {
+        continue;
+      }
+      if (isNonEmptyCsvCell(value)) {
+        directCells.push({ field, value });
+      }
+    }
+    for (const preferredField of [alias, ...ENRICH_FLATTENED_SUCCESS_FIELD_PRIORITY]) {
+      const preferred = directCells.find(({ field }) => field === preferredField);
+      if (preferred) {
+        return materializeCsvCellValue(preferred.value);
+      }
+    }
+    if (directCells.length === 1) {
+      return materializeCsvCellValue(directCells[0].value);
+    }
+    if (directCells.length > 1) {
+      return JSON.stringify(
+        Object.fromEntries(
+          directCells.map(({ field, value }) => [field, value])
+        )
+      );
+    }
+  }
+  const cells = aliasFlattenedCells(row, alias).filter(({ field, value }) => {
+    if (ENRICH_FLATTENED_CONTROL_FIELDS.has(field)) {
+      return false;
+    }
+    return isNonEmptyCsvCell(value);
+  });
+  if (cells.length === 0) {
+    return void 0;
+  }
+  for (const preferredField of ENRICH_FLATTENED_SUCCESS_FIELD_PRIORITY) {
+    const preferred = cells.find(({ field }) => field === preferredField);
+    if (preferred) {
+      return materializeCsvCellValue(preferred.value);
+    }
+  }
+  if (cells.length === 1) {
+    return materializeCsvCellValue(cells[0].value);
+  }
+  return JSON.stringify(
+    Object.fromEntries(cells.map(({ field, value }) => [field, value]))
+  );
+}
+function normalizeEnrichRowsForCsvExport(rows, config, options) {
+  const aliases = config ? collectConfigScalarAliasOrder(config) : [];
   return rows.map((row) => {
     const metadata = legacyMetadataFromRow(row);
-    if (!metadata) {
-      return row;
+    const normalized = metadata ? { ...row, _metadata: metadata } : { ...row };
+    if (metadata) {
+      delete normalized.metadata;
+      delete normalized["metadata.columns"];
+      delete normalized.metadata__columns;
     }
-    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];
       }
     }
+    const failureAliases = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(normalized)) {
+      const dotted = key.match(
+        /^(.+)\.(?:error|last_error|message|operation|provider|result|status)$/
+      );
+      const underscored = key.match(
+        /^(.+)__(?:error|last_error|message|operation|provider|result|status)$/
+      );
+      const alias = dotted?.[1] ?? underscored?.[1] ?? null;
+      if (alias) {
+        failureAliases.add(alias);
+      }
+    }
+    for (const alias of failureAliases) {
+      if (isNonEmptyCsvCell(normalized[alias])) {
+        continue;
+      }
+      const failure = aliasFailureCellCandidates(normalized, alias).map(cellFailureError).find(
+        (candidate) => Boolean(candidate)
+      );
+      if (failure) {
+        normalized[alias] = failure.message;
+      }
+    }
+    for (const alias of aliases) {
+      const value = materializeAliasSuccessCell(normalized, alias);
+      if (value !== void 0) {
+        normalized[alias] = value;
+        continue;
+      }
+      if (isNonEmptyCsvCell(normalized[alias])) {
+        continue;
+      }
+      const failure = aliasFailureCellCandidates(normalized, alias).map(cellFailureError).find(
+        (candidate) => Boolean(candidate)
+      );
+      if (failure) {
+        normalized[alias] = failure.message;
+        continue;
+      }
+      const statusFailureMessage = options?.statusFailureMessages?.get(
+        normalizeAlias2(alias)
+      );
+      if (statusFailureMessage) {
+        normalized[alias] = statusFailureMessage;
+      }
+    }
     return normalized;
   });
 }
@@ -17984,6 +18875,9 @@ function registerEnrichCommand(program) {
   ).option(
     "--profile <id>",
     "Internal/testing: override the execution profile for the generated play run."
+  ).option(
+    "--fail-fast",
+    "Fail the generated play when any selected row errors, while preserving recovered runtime-sheet rows for export."
   ).action(async (options, _command) => {
     if (options.inPlace && options.dryRun) {
       throw new Error("--in-place is not supported with --dry-run.");
@@ -18007,14 +18901,16 @@ function registerEnrichCommand(program) {
       const forceAliases2 = resolveForceAliases(config, options);
       const playSource2 = compileEnrichConfigToPlaySource(config, {
         forceAliases: forceAliases2,
-        playName: options.name
+        playName: options.name,
+        inlineRunJavascript: true,
+        failFast: options.failFast
       });
       const summary = summarizePlan(config, playSource2);
       if (options.json) {
         printJson({
           dryRun: true,
-          input: (0, import_node_path11.resolve)(inputCsv),
-          output: options.output ? (0, import_node_path11.resolve)(options.output) : null,
+          input: (0, import_node_path12.resolve)(inputCsv),
+          output: options.output ? (0, import_node_path12.resolve)(options.output) : null,
           plan: summary
         });
         return;
@@ -18036,15 +18932,17 @@ function registerEnrichCommand(program) {
     }
     const playSource = compileEnrichConfigToPlaySource(config, {
       forceAliases,
-      playName: options.name
+      playName: options.name,
+      inlineRunJavascript: true,
+      failFast: options.failFast
     });
-    const tempDir = await (0, import_promises3.mkdtemp)((0, import_node_path11.join)((0, import_node_os7.tmpdir)(), "deepline-enrich-play-"));
-    const tempPlay = (0, import_node_path11.join)(tempDir, "deepline-enrich.play.ts");
+    const tempDir = await (0, import_promises3.mkdtemp)((0, import_node_path12.join)((0, import_node_os8.tmpdir)(), "deepline-enrich-play-"));
+    const tempPlay = (0, import_node_path12.join)(tempDir, "deepline-enrich.play.ts");
     try {
       await (0, import_promises3.writeFile)(tempPlay, playSource, "utf8");
       const runOne = async (input2) => {
         const runtimeInput = {
-          file: (0, import_node_path11.resolve)(input2.sourceCsvPath),
+          file: (0, import_node_path12.resolve)(input2.sourceCsvPath),
           ...input2.rows.rowStart !== null ? { rowStart: input2.rows.rowStart } : {},
           ...input2.rows.rowEnd !== null ? { rowEnd: input2.rows.rowEnd } : {}
         };
@@ -18070,7 +18968,7 @@ function registerEnrichCommand(program) {
         if (timeoutSeconds !== null && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0) {
           runArgs.push("--tail-timeout-ms", String(timeoutSeconds * 1e3));
         }
-        const captured2 = await runGeneratedEnrichPlay(runArgs, {
+        const captured2 = await runGeneratedEnrichPlay(client2, runArgs, {
           passthroughStdout: input2.passthroughStdout
         });
         const status2 = input2.json ? parseJsonOutput(captured2.stdout) : await resolveWatchedGeneratedPlayStatus({
@@ -18097,7 +18995,7 @@ function registerEnrichCommand(program) {
         );
         if (!options.json) {
           process.stderr.write(
-            `Large enrich input selected ${selectedRange.count.toLocaleString()} rows. Running ${chunkCount.toLocaleString()} sequential batch runs of up to ${ENRICH_AUTO_BATCH_ROWS.toLocaleString()} rows and merging ${(0, import_node_path11.resolve)(outputPath)}.
+            `Large enrich input selected ${selectedRange.count.toLocaleString()} rows. Running ${chunkCount.toLocaleString()} sequential batch runs of up to ${ENRICH_AUTO_BATCH_ROWS.toLocaleString()} rows and merging ${(0, import_node_path12.resolve)(outputPath)}.
 `
           );
         }
@@ -18173,7 +19071,8 @@ function registerEnrichCommand(program) {
             rowEnd: selectedRange.end
           },
           client: client2,
-          outputPath
+          outputPath,
+          status: lastStatus
         });
         if (options.json) {
           const run = rewriteEnrichJsonStatus({
@@ -18237,7 +19136,8 @@ function registerEnrichCommand(program) {
           rowRange: rows,
           client: client2,
           exportResult,
-          outputPath
+          outputPath,
+          status
         });
         if (options.json) {
           printJson({
@@ -18262,7 +19162,8 @@ function registerEnrichCommand(program) {
           rowRange: rows,
           client: client2,
           exportResult,
-          outputPath
+          outputPath,
+          status
         });
         const run = rewriteEnrichJsonStatus({
           status,
@@ -18306,7 +19207,8 @@ function registerEnrichCommand(program) {
         rows: rowsForFailureReport,
         rowRange: rows,
         client: client2,
-        outputPath: exportResult?.path ?? outputPath ?? null
+        outputPath: exportResult?.path ?? outputPath ?? null,
+        status
       });
       if (failureReport) {
         process.exitCode = EXIT_SERVER2;
@@ -18362,11 +19264,11 @@ Examples:
 }
 
 // src/cli/commands/sessions.ts
-var import_node_fs10 = require("fs");
-var import_node_os8 = require("os");
-var import_node_path12 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_os9 = require("os");
+var import_node_path13 = require("path");
 var import_node_zlib = require("zlib");
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var UUID_IN_TEXT_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 var MAX_SESSION_UPLOAD_BYTES = 35e5;
@@ -18378,33 +19280,33 @@ var MAX_EVENT_OBJECT_KEYS = 80;
 var TRUNCATION_MARKER = "...[truncated]";
 var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set(["progress", "file-history-snapshot"]);
 function homeDir() {
-  return process.env.HOME?.trim() || (0, import_node_os8.homedir)();
+  return process.env.HOME?.trim() || (0, import_node_os9.homedir)();
 }
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
   return {
-    shell: shellPath ? (0, import_node_path12.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell: shellPath ? (0, import_node_path13.basename)(shellPath).replace(/\.exe$/i, "") : "unknown",
     shell_path: shellPath || null,
-    os: (0, import_node_os8.platform)(),
+    os: (0, import_node_os9.platform)(),
     cwd: process.cwd()
   };
 }
 function claudeProjectsRoot() {
-  return (0, import_node_path12.join)(homeDir(), ".claude", "projects");
+  return (0, import_node_path13.join)(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return (0, import_node_path12.join)(homeDir(), ".codex", "sessions");
+  return (0, import_node_path13.join)(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
-  if (!(0, import_node_fs10.existsSync)(root)) return [];
+  if (!(0, import_node_fs11.existsSync)(root)) return [];
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = (0, import_node_path12.join)(root, projectDir);
+    const fullProjectDir = (0, import_node_path13.join)(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = (0, import_node_path12.join)(fullProjectDir, fileName);
+        const filePath = (0, import_node_path13.join)(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
         const stat2 = statIfReadable(filePath);
         if (sessionId && stat2) {
@@ -18422,7 +19324,7 @@ function listClaudeSessionFiles() {
 }
 function listCodexSessionFiles() {
   const root = codexSessionsRoot();
-  if (!(0, import_node_fs10.existsSync)(root)) return [];
+  if (!(0, import_node_fs11.existsSync)(root)) return [];
   const files = [];
   for (const filePath of listJsonlFilesRecursive(root, 5)) {
     const stat2 = statIfReadable(filePath);
@@ -18445,7 +19347,7 @@ function listSessionFiles(agent) {
 }
 function readDirectoryNames(dir) {
   try {
-    return (0, import_node_fs10.readdirSync)(dir);
+    return (0, import_node_fs11.readdirSync)(dir);
   } catch {
     return [];
   }
@@ -18456,12 +19358,12 @@ function listJsonlFilesRecursive(root, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = (0, import_node_path12.join)(dir, entry.name);
+      const fullPath = (0, import_node_path13.join)(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -18474,7 +19376,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
 }
 function statIfReadable(filePath) {
   try {
-    return (0, import_node_fs10.statSync)(filePath);
+    return (0, import_node_fs11.statSync)(filePath);
   } catch {
     return null;
   }
@@ -18489,15 +19391,15 @@ function newestSessionFile(agent) {
   return newest;
 }
 function sessionIdFromClaudeFilePath(filePath) {
-  return (0, import_node_path12.basename)(filePath, ".jsonl");
+  return (0, import_node_path13.basename)(filePath, ".jsonl");
 }
 function sessionIdFromCodexFilePath(filePath) {
-  const match = (0, import_node_path12.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  const match = (0, import_node_path13.basename)(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
   return match?.[0] ?? null;
 }
 function readCodexSessionId(filePath) {
   try {
-    for (const line of normalizedJsonLines((0, import_node_fs10.readFileSync)(filePath)).slice(
+    for (const line of normalizedJsonLines((0, import_node_fs11.readFileSync)(filePath)).slice(
       0,
       20
     )) {
@@ -18728,7 +19630,7 @@ async function uploadPayload(path, payload) {
   return await http.post(path, payload);
 }
 async function uploadChunkedSessions(sessions, options) {
-  const uploadId = (0, import_node_crypto3.randomUUID)();
+  const uploadId = (0, import_node_crypto4.randomUUID)();
   for (const session of sessions) {
     const bytes = Buffer.from(session.encodedContent, "base64");
     const chunks = [];
@@ -18774,25 +19676,25 @@ async function uploadChunkedSessions(sessions, options) {
 }
 async function handleSessionsSend(options) {
   if (options.file) {
-    const filePath = (0, import_node_path12.resolve)(options.file);
-    if (!(0, import_node_fs10.existsSync)(filePath)) {
+    const filePath = (0, import_node_path13.resolve)(options.file);
+    if (!(0, import_node_fs11.existsSync)(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
-      file: (0, import_node_fs10.readFileSync)(filePath).toString("base64"),
-      filename: (0, import_node_path12.basename)(filePath)
+      file: (0, import_node_fs11.readFileSync)(filePath).toString("base64"),
+      filename: (0, import_node_path13.basename)(filePath)
     });
     printCommandEnvelope(
       {
         ...response2,
         ok: true,
-        filename: (0, import_node_path12.basename)(filePath),
+        filename: (0, import_node_path13.basename)(filePath),
         render: {
           sections: [
             {
               title: "sessions send",
               lines: [
-                `File '${(0, import_node_path12.basename)(filePath)}' uploaded to #internal-reports.`
+                `File '${(0, import_node_path13.basename)(filePath)}' uploaded to #internal-reports.`
               ]
             }
           ]
@@ -18809,7 +19711,7 @@ async function handleSessionsSend(options) {
     agent: options.agent
   });
   const built = targets.map((target) => {
-    const upload = buildSessionUploadContent((0, import_node_fs10.readFileSync)(target.filePath));
+    const upload = buildSessionUploadContent((0, import_node_fs11.readFileSync)(target.filePath));
     return { ...target, ...upload };
   });
   if (built.some((session) => session.needsChunking)) {
@@ -18873,28 +19775,28 @@ function fallbackViewerAssets() {
   };
 }
 function loadViewerAssets() {
-  const cliEntry = process.argv[1]?.trim() ? (0, import_node_path12.resolve)(process.argv[1]) : null;
+  const cliEntry = process.argv[1]?.trim() ? (0, import_node_path13.resolve)(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      (0, import_node_path12.join)((0, import_node_path12.dirname)((0, import_node_path12.dirname)(cliEntry)), "viewer"),
-      (0, import_node_path12.join)(
-        (0, import_node_path12.dirname)((0, import_node_path12.dirname)((0, import_node_path12.dirname)(cliEntry))),
+      (0, import_node_path13.join)((0, import_node_path13.dirname)((0, import_node_path13.dirname)(cliEntry)), "viewer"),
+      (0, import_node_path13.join)(
+        (0, import_node_path13.dirname)((0, import_node_path13.dirname)((0, import_node_path13.dirname)(cliEntry))),
         "src",
         "lib",
         "cli",
         "viewer"
       )
     ] : [],
-    (0, import_node_path12.join)(process.cwd(), "src", "lib", "cli", "viewer")
+    (0, import_node_path13.join)(process.cwd(), "src", "lib", "cli", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = (0, import_node_path12.join)(root, "viewer.css");
-      const jsPath = (0, import_node_path12.join)(root, "viewer.js");
-      if (!(0, import_node_fs10.existsSync)(cssPath) || !(0, import_node_fs10.existsSync)(jsPath)) continue;
+      const cssPath = (0, import_node_path13.join)(root, "viewer.css");
+      const jsPath = (0, import_node_path13.join)(root, "viewer.js");
+      if (!(0, import_node_fs11.existsSync)(cssPath) || !(0, import_node_fs11.existsSync)(jsPath)) continue;
       return {
-        css: (0, import_node_fs10.readFileSync)(cssPath, "utf8"),
-        js: (0, import_node_fs10.readFileSync)(jsPath, "utf8")
+        css: (0, import_node_fs11.readFileSync)(cssPath, "utf8"),
+        js: (0, import_node_fs11.readFileSync)(jsPath, "utf8")
       };
     } catch {
       continue;
@@ -18918,21 +19820,21 @@ async function handleSessionsRender(options) {
     currentSession: options.currentSession,
     agent: options.agent
   });
-  let outputPath = options.output ? (0, import_node_path12.resolve)(options.output) : "";
+  let outputPath = options.output ? (0, import_node_path13.resolve)(options.output) : "";
   if (!outputPath) {
-    const outputDir = (0, import_node_path12.join)(process.cwd(), "deepline", "data");
-    (0, import_node_fs10.mkdirSync)(outputDir, { recursive: true });
-    outputPath = (0, import_node_path12.join)(
+    const outputDir = (0, import_node_path13.join)(process.cwd(), "deepline", "data");
+    (0, import_node_fs11.mkdirSync)(outputDir, { recursive: true });
+    outputPath = (0, import_node_path13.join)(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    (0, import_node_fs10.mkdirSync)((0, import_node_path12.dirname)(outputPath), { recursive: true });
+    (0, import_node_fs11.mkdirSync)((0, import_node_path13.dirname)(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
     events: parsePreparedEvents(
-      prepareSessionBuffer((0, import_node_fs10.readFileSync)(target.filePath))
+      prepareSessionBuffer((0, import_node_fs11.readFileSync)(target.filePath))
     )
   }));
   const { css, js } = loadViewerAssets();
@@ -18955,7 +19857,7 @@ ${refreshMeta}
 <script>${js}</script>
 </body>
 </html>`;
-  (0, import_node_fs10.writeFileSync)(outputPath, html, "utf8");
+  (0, import_node_fs11.writeFileSync)(outputPath, html, "utf8");
   printCommandEnvelope(
     {
       ok: true,
@@ -19939,8 +20841,8 @@ Examples:
 }
 
 // src/cli/commands/quickstart.ts
-var import_node_child_process = require("child_process");
-var import_node_crypto4 = require("crypto");
+var import_node_child_process2 = require("child_process");
+var import_node_crypto5 = require("crypto");
 var import_node_http = require("http");
 var EXIT_OK2 = 0;
 var EXIT_AUTH2 = 1;
@@ -19952,7 +20854,7 @@ function shellQuote(arg) {
 }
 function hasClaudeBinary() {
   try {
-    const result = (0, import_node_child_process.spawnSync)("claude", ["--version"], {
+    const result = (0, import_node_child_process2.spawnSync)("claude", ["--version"], {
       stdio: "ignore",
       shell: process.platform === "win32"
     });
@@ -19962,17 +20864,17 @@ function hasClaudeBinary() {
   }
 }
 function launchClaude(prompt) {
-  return new Promise((resolve13) => {
-    const child = (0, import_node_child_process.spawn)("claude", [prompt], {
+  return new Promise((resolve14) => {
+    const child = (0, import_node_child_process2.spawn)("claude", [prompt], {
       stdio: "inherit",
       shell: process.platform === "win32"
     });
-    child.on("error", () => resolve13(EXIT_SERVER3));
-    child.on("close", (status) => resolve13(status ?? EXIT_OK2));
+    child.on("error", () => resolve14(EXIT_SERVER3));
+    child.on("close", (status) => resolve14(status ?? EXIT_OK2));
   });
 }
 function readBody(req) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve14, reject) => {
     let raw = "";
     req.setEncoding("utf8");
     req.on("data", (chunk) => {
@@ -19982,7 +20884,7 @@ function readBody(req) {
         req.destroy();
       }
     });
-    req.on("end", () => resolve13(raw));
+    req.on("end", () => resolve14(raw));
     req.on("error", reject);
   });
 }
@@ -20037,7 +20939,7 @@ function startCallbackServer(input2) {
       writeJson(res, 400, { error: "Invalid request body." });
     });
   });
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve14, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const address = server.address();
@@ -20045,7 +20947,7 @@ function startCallbackServer(input2) {
         reject(new Error("Failed to bind quickstart callback server."));
         return;
       }
-      resolve13({ server, port: address.port });
+      resolve14({ server, port: address.port });
     });
   });
 }
@@ -20069,10 +20971,10 @@ async function handleQuickstart(options) {
       return EXIT_AUTH2;
     }
   }
-  const state = (0, import_node_crypto4.randomBytes)(32).toString("hex");
+  const state = (0, import_node_crypto5.randomBytes)(32).toString("hex");
   let resolveSelection;
-  const selectionPromise = new Promise((resolve13) => {
-    resolveSelection = resolve13;
+  const selectionPromise = new Promise((resolve14) => {
+    resolveSelection = resolve14;
   });
   let callback;
   try {
@@ -20211,7 +21113,7 @@ async function readHiddenLine(prompt, streams = {}) {
   }
   let value = "";
   inputStream.resume();
-  return await new Promise((resolve13, reject) => {
+  return await new Promise((resolve14, reject) => {
     let settled = false;
     const cleanup = () => {
       inputStream.off("data", onData);
@@ -20229,7 +21131,7 @@ async function readHiddenLine(prompt, streams = {}) {
       settled = true;
       outputStream.write("\n");
       cleanup();
-      resolve13(line);
+      resolve14(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -20400,9 +21302,9 @@ Examples:
 }
 
 // src/cli/commands/switch.ts
-var import_node_fs11 = require("fs");
-var import_node_os9 = require("os");
-var import_node_path13 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_os10 = require("os");
+var import_node_path14 = require("path");
 function hostSlugFromBaseUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
@@ -20422,8 +21324,8 @@ function resolveConfigScope() {
   return hostSlugFromBaseUrl(autoDetectBaseUrl());
 }
 function activeFamilyPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os9.homedir)();
-  return (0, import_node_path13.join)(
+  const home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os10.homedir)();
+  return (0, import_node_path14.join)(
     home,
     ".local",
     "deepline",
@@ -20435,15 +21337,15 @@ function activeFamilyPath() {
 function readActiveFamily() {
   const path = activeFamilyPath();
   try {
-    return (0, import_node_fs11.readFileSync)(path, "utf-8").trim() || "sdk";
+    return (0, import_node_fs12.readFileSync)(path, "utf-8").trim() || "sdk";
   } catch {
     return "sdk";
   }
 }
 function writeActiveFamily(family) {
   const path = activeFamilyPath();
-  (0, import_node_fs11.mkdirSync)((0, import_node_path13.dirname)(path), { recursive: true });
-  (0, import_node_fs11.writeFileSync)(path, `${family}
+  (0, import_node_fs12.mkdirSync)((0, import_node_path14.dirname)(path), { recursive: true });
+  (0, import_node_fs12.writeFileSync)(path, `${family}
 `, "utf-8");
   return path;
 }
@@ -20460,7 +21362,7 @@ function handleSwitch(action, options) {
         ok: true,
         active_family: activeFamily,
         active_family_path: path,
-        active_family_file_exists: (0, import_node_fs11.existsSync)(path),
+        active_family_file_exists: (0, import_node_fs12.existsSync)(path),
         render: {
           sections: [
             {
@@ -20560,14 +21462,14 @@ Examples:
 
 // src/cli/commands/tools.ts
 var import_commander2 = require("commander");
+var import_node_fs14 = require("fs");
+var import_node_os12 = require("os");
+var import_node_path16 = require("path");
+
+// src/tool-output.ts
 var import_node_fs13 = require("fs");
 var import_node_os11 = require("os");
 var import_node_path15 = require("path");
-
-// src/tool-output.ts
-var import_node_fs12 = require("fs");
-var import_node_os10 = require("os");
-var import_node_path14 = require("path");
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20694,19 +21596,19 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = (0, import_node_path14.join)((0, import_node_os10.homedir)(), ".local", "share", "deepline", "data");
-  (0, import_node_fs12.mkdirSync)(outputDir, { recursive: true });
+  const outputDir = (0, import_node_path15.join)((0, import_node_os11.homedir)(), ".local", "share", "deepline", "data");
+  (0, import_node_fs13.mkdirSync)(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path14.join)(outputDir, `${stem}_${Date.now()}.json`);
-  (0, import_node_fs12.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  const outputPath = (0, import_node_path15.join)(outputDir, `${stem}_${Date.now()}.json`);
+  (0, import_node_fs13.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
-  const outputPath = options?.outPath ? options.outPath : (0, import_node_path14.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
-  (0, import_node_fs12.mkdirSync)((0, import_node_path14.dirname)(outputPath), { recursive: true });
+  const outputPath = options?.outPath ? options.outPath : (0, import_node_path15.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  (0, import_node_fs13.mkdirSync)((0, import_node_path15.dirname)(outputPath), { recursive: true });
   const columns = columnsForRows(rows);
   const escapeCell = (value) => {
     const normalized = value == null ? "" : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
@@ -20715,19 +21617,19 @@ function writeCsvOutputFile(rows, stem, options) {
     }
     return normalized;
   };
-  const fd = (0, import_node_fs12.openSync)(outputPath, "w");
+  const fd = (0, import_node_fs13.openSync)(outputPath, "w");
   try {
-    (0, import_node_fs12.writeSync)(fd, `${columns.map(escapeCell).join(",")}
+    (0, import_node_fs13.writeSync)(fd, `${columns.map(escapeCell).join(",")}
 `);
     for (const row of rows) {
-      (0, import_node_fs12.writeSync)(
+      (0, import_node_fs13.writeSync)(
         fd,
         `${columns.map((column) => escapeCell(row[column])).join(",")}
 `
       );
     }
   } finally {
-    (0, import_node_fs12.closeSync)(fd);
+    (0, import_node_fs13.closeSync)(fd);
   }
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
@@ -21872,11 +22774,11 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = (0, import_node_path15.resolve)(trimmed);
-  if ((0, import_node_fs13.existsSync)(resolved)) return resolved;
+  const resolved = (0, import_node_path16.resolve)(trimmed);
+  if ((0, import_node_fs14.existsSync)(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = (0, import_node_path15.resolve)(trimmed.replace(/\\/g, "/"));
-    if ((0, import_node_fs13.existsSync)(normalized)) return normalized;
+    const normalized = (0, import_node_path16.resolve)(trimmed.replace(/\\/g, "/"));
+    if ((0, import_node_fs14.existsSync)(normalized)) return normalized;
   }
   return resolved;
 }
@@ -21887,7 +22789,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return (0, import_node_fs13.readFileSync)(resolveAtFilePath(filePath), "utf8").replace(
+    return (0, import_node_fs14.readFileSync)(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -21964,7 +22866,7 @@ function parseExecuteOptions(args) {
       continue;
     }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
-      outPath = (0, import_node_path15.resolve)(args[++index]);
+      outPath = (0, import_node_path16.resolve)(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -21994,9 +22896,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = (0, import_node_fs13.mkdtempSync)((0, import_node_path15.join)((0, import_node_os11.tmpdir)(), "deepline-workflow-seed-"));
-  (0, import_node_fs13.chmodSync)(scriptDir, 448);
-  const scriptPath = (0, import_node_path15.join)(scriptDir, fileName);
+  const scriptDir = (0, import_node_fs14.mkdtempSync)((0, import_node_path16.join)((0, import_node_os12.tmpdir)(), "deepline-workflow-seed-"));
+  (0, import_node_fs14.chmodSync)(scriptDir, 448);
+  const scriptPath = (0, import_node_path16.join)(scriptDir, fileName);
   const projectDir = `deepline/projects/${stem}-workflow`;
   const playName = `${stem}-workflow`;
   const sampleRows = input2.rows.length > 0 ? `${JSON.stringify(input2.rows.slice(0, 2)).replace(/\]$/, "")}, ...]` : "[]";
@@ -22039,7 +22941,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   description: ${JSON.stringify(`Seed ${input2.toolId} rows into a Deepline workflow-ready dataset.`)},
 });
 `;
-  (0, import_node_fs13.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  (0, import_node_fs14.writeFileSync)(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -22370,10 +23272,10 @@ async function executeTool(args) {
 
 // src/cli/commands/workflow.ts
 var import_promises4 = require("fs/promises");
-var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 
 // src/cli/workflow-to-play.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 
 // ../shared_libs/plays/secret-guardrails.ts
 var SECRET_ENV_PATTERN = /\bprocess(?:\.env|\[['"]env['"]\])(?:\.|\[['"])([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PRIVATE[_-]?KEY|ACCESS[_-]?KEY)[A-Z0-9_]*)(?:['"]\])?/g;
@@ -22516,7 +23418,7 @@ function sanitizePlayNameSegment(value) {
 }
 function deriveWorkflowPlayName(workflowName) {
   const base = sanitizePlayNameSegment(workflowName) || "workflow";
-  const suffix = (0, import_node_crypto5.createHash)("sha256").update(workflowName).digest("hex").slice(0, 8);
+  const suffix = (0, import_node_crypto6.createHash)("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}`;
@@ -22614,7 +23516,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await (0, import_promises4.readFile)((0, import_node_path16.resolve)(file), "utf8");
+    const raw = await (0, import_promises4.readFile)((0, import_node_path17.resolve)(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -22648,8 +23550,8 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = (0, import_node_path16.join)((0, import_node_path16.resolve)(outDir), `${compiled.playName}.play.ts`);
-    await (0, import_promises4.mkdir)((0, import_node_path16.dirname)(file), { recursive: true });
+    const file = (0, import_node_path17.join)((0, import_node_path17.resolve)(outDir), `${compiled.playName}.play.ts`);
+    await (0, import_promises4.mkdir)((0, import_node_path17.dirname)(file), { recursive: true });
     await (0, import_promises4.writeFile)(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
@@ -22895,16 +23797,16 @@ Notes:
 }
 
 // src/cli/commands/update.ts
+var import_node_child_process4 = require("child_process");
+var import_node_fs16 = require("fs");
+var import_node_os13 = require("os");
+var import_node_path19 = require("path");
+
+// src/cli/skills-sync.ts
 var import_node_child_process3 = require("child_process");
 var import_node_fs15 = require("fs");
-var import_node_os12 = require("os");
 var import_node_path18 = require("path");
 
-// src/cli/skills-sync.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs14 = require("fs");
-var import_node_path17 = require("path");
-
 // ../shared_libs/cli/install-commands.json
 var install_commands_default = {
   skills: {
@@ -23022,38 +23924,38 @@ function activePluginSkillsDir() {
     return "";
   }
   const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && (0, import_node_fs14.existsSync)(dir) ? dir : "";
+  return dir && (0, import_node_fs15.existsSync)(dir) ? dir : "";
 }
 function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return (0, import_node_fs14.readFileSync)((0, import_node_path17.join)(dir, ".version"), "utf-8").trim();
+    return (0, import_node_fs15.readFileSync)((0, import_node_path18.join)(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
-  return (0, import_node_path17.join)(sdkCliStateDirPath(baseUrl), "skills-version");
+  return (0, import_node_path18.join)(sdkCliStateDirPath(baseUrl), "skills-version");
 }
 function legacySdkSkillsVersionPath(baseUrl) {
-  return (0, import_node_path17.join)((0, import_node_path17.dirname)(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
+  return (0, import_node_path18.join)((0, import_node_path18.dirname)(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
 }
 function readSdkSkillsLocalVersion(baseUrl) {
   const pluginVersion = readPluginSkillsVersion();
   if (pluginVersion) return pluginVersion;
-  const path = (0, import_node_fs14.existsSync)(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
-  if (!(0, import_node_fs14.existsSync)(path)) return "";
+  const path = (0, import_node_fs15.existsSync)(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
+  if (!(0, import_node_fs15.existsSync)(path)) return "";
   try {
-    return (0, import_node_fs14.readFileSync)(path, "utf-8").trim();
+    return (0, import_node_fs15.readFileSync)(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  (0, import_node_fs14.mkdirSync)((0, import_node_path17.dirname)(path), { recursive: true });
-  (0, import_node_fs14.writeFileSync)(path, `${version}
+  (0, import_node_fs15.mkdirSync)((0, import_node_path18.dirname)(path), { recursive: true });
+  (0, import_node_fs15.writeFileSync)(path, `${version}
 `, "utf-8");
 }
 function sortedUniqueSkillNames(names) {
@@ -23121,7 +24023,7 @@ function buildBunxSkillsInstallArgs(baseUrl, skillNames) {
   });
 }
 function hasCommand(command) {
-  const result = (0, import_node_child_process2.spawnSync)(command, ["--version"], {
+  const result = (0, import_node_child_process3.spawnSync)(command, ["--version"], {
     stdio: "ignore",
     shell: process.platform === "win32"
   });
@@ -23151,8 +24053,8 @@ function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NA
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve13) => {
-    const child = (0, import_node_child_process2.spawn)(install.command, install.args, {
+  return new Promise((resolve14) => {
+    const child = (0, import_node_child_process3.spawn)(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
     });
@@ -23161,7 +24063,7 @@ function runOneSkillsInstall(install) {
       stderr += chunk.toString("utf-8");
     });
     child.on("error", (error) => {
-      resolve13({
+      resolve14({
         ok: false,
         detail: `failed to start ${install.command}: ${error.message}`,
         manualCommand: install.manualCommand
@@ -23169,11 +24071,11 @@ function runOneSkillsInstall(install) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve13({ ok: true, detail: "", manualCommand: install.manualCommand });
+        resolve14({ ok: true, detail: "", manualCommand: install.manualCommand });
         return;
       }
       const detail = stderr.trim();
-      resolve13({
+      resolve14({
         ok: false,
         detail: detail ? `${install.command}: ${detail}` : `${install.command} exited ${code}`,
         manualCommand: install.manualCommand
@@ -23236,7 +24138,7 @@ function runLegacySkillsCleanup() {
     }
   ];
   for (const candidate of candidates) {
-    const result = (0, import_node_child_process2.spawnSync)(candidate.command, candidate.args, {
+    const result = (0, import_node_child_process3.spawnSync)(candidate.command, candidate.args, {
       stdio: "ignore",
       shell: process.platform === "win32"
     });
@@ -23330,11 +24232,11 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return (0, import_node_path18.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return (0, import_node_path19.join)(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function readOptionalText(path) {
   try {
-    return (0, import_node_fs15.readFileSync)(path, "utf8").trim();
+    return (0, import_node_fs16.readFileSync)(path, "utf8").trim();
   } catch {
     return "";
   }
@@ -23342,26 +24244,26 @@ function readOptionalText(path) {
 function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
-  const relativeEntrypoint = (0, import_node_path18.relative)(
-    (0, import_node_path18.resolve)(stateDir),
-    (0, import_node_path18.resolve)(options.entrypoint)
+  const relativeEntrypoint = (0, import_node_path19.relative)(
+    (0, import_node_path19.resolve)(stateDir),
+    (0, import_node_path19.resolve)(options.entrypoint)
   );
-  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path18.isAbsolute)(relativeEntrypoint)) {
+  if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || (0, import_node_path19.isAbsolute)(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText((0, import_node_path18.join)(stateDir, ".install-method"));
+  const installMethod = readOptionalText((0, import_node_path19.join)(stateDir, ".install-method"));
   if (installMethod !== "python-sidecar") return null;
   const scope = options.env.DEEPLINE_CONFIG_SCOPE?.trim() || "";
   const hostUrl = options.env.DEEPLINE_HOST_URL?.trim() || "";
-  const nodeBin = readOptionalText((0, import_node_path18.join)(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText((0, import_node_path18.join)(stateDir, ".command-path")) || (0, import_node_path18.join)(
+  const nodeBin = readOptionalText((0, import_node_path19.join)(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText((0, import_node_path19.join)(stateDir, ".command-path")) || (0, import_node_path19.join)(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
   );
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
-  const versionDir = (0, import_node_path18.join)(stateDir, "versions", "<version>");
+  const versionDir = (0, import_node_path19.join)(stateDir, "versions", "<version>");
   const manualCommand = `${buildSidecarProjectConfigCommand(versionDir, nodeBin)} && ${npmCommand} install --prefix ${shellQuote4(versionDir)} ${NPM_SDK_INSTALL_COMMON_FLAGS.map(shellQuote4).join(" ")} ${shellQuote4(packageSpec)}`;
   return {
     kind: "python-sidecar",
@@ -23376,12 +24278,12 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = (0, import_node_path18.resolve)(startPath);
+  let current = (0, import_node_path19.resolve)(startPath);
   while (true) {
-    if ((0, import_node_fs15.existsSync)((0, import_node_path18.join)(current, "sdk", "package.json")) && (0, import_node_fs15.existsSync)((0, import_node_path18.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if ((0, import_node_fs16.existsSync)((0, import_node_path19.join)(current, "sdk", "package.json")) && (0, import_node_fs16.existsSync)((0, import_node_path19.join)(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
-    const parent = (0, import_node_path18.dirname)(current);
+    const parent = (0, import_node_path19.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -23389,9 +24291,9 @@ function findRepoBackedSdkRoot(startPath) {
 function inferNpmGlobalPrefixFromEntrypoint(entrypoint) {
   const normalized = (() => {
     try {
-      return (0, import_node_fs15.realpathSync)(entrypoint);
+      return (0, import_node_fs16.realpathSync)(entrypoint);
     } catch {
-      return (0, import_node_path18.resolve)(entrypoint);
+      return (0, import_node_path19.resolve)(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -23409,9 +24311,9 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint) {
 }
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir2 = options.homeDir ?? (0, import_node_os12.homedir)();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path18.resolve)(process.argv[1]) : "");
-  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path18.dirname)(entrypoint)) : null;
+  const homeDir2 = options.homeDir ?? (0, import_node_os13.homedir)();
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? (0, import_node_path19.resolve)(process.argv[1]) : "");
+  const sourceRoot = entrypoint ? findRepoBackedSdkRoot((0, import_node_path19.dirname)(entrypoint)) : null;
   if (sourceRoot) {
     return {
       kind: "source",
@@ -23449,10 +24351,10 @@ var AUTO_UPDATE_FAILURE_FILE = ".auto-update-failure.json";
 function autoUpdateFailurePath(plan) {
   if (plan.kind === "source") return null;
   if (plan.kind === "python-sidecar") {
-    return (0, import_node_path18.join)(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
+    return (0, import_node_path19.join)(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
-  return (0, import_node_path18.join)(
-    (0, import_node_os12.homedir)(),
+  return (0, import_node_path19.join)(
+    (0, import_node_os13.homedir)(),
     ".local",
     "deepline",
     "sdk-cli",
@@ -23469,7 +24371,7 @@ function readAutoUpdateFailure(plan) {
   if (!path) return null;
   try {
     const parsed = JSON.parse(
-      (0, import_node_fs15.readFileSync)(path, "utf8")
+      (0, import_node_fs16.readFileSync)(path, "utf8")
     );
     if ((parsed.kind === "npm-global" || parsed.kind === "python-sidecar") && typeof parsed.packageSpec === "string" && typeof parsed.failedAt === "string" && typeof parsed.exitCode === "number" && typeof parsed.manualCommand === "string") {
       return parsed;
@@ -23490,8 +24392,8 @@ function writeAutoUpdateFailure(plan, exitCode) {
     manualCommand: plan.manualCommand
   };
   try {
-    (0, import_node_fs15.mkdirSync)((0, import_node_path18.dirname)(path), { recursive: true });
-    (0, import_node_fs15.writeFileSync)(path, `${JSON.stringify(marker, null, 2)}
+    (0, import_node_fs16.mkdirSync)((0, import_node_path19.dirname)(path), { recursive: true });
+    (0, import_node_fs16.writeFileSync)(path, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -23500,7 +24402,7 @@ function clearAutoUpdateFailure(plan) {
   const path = autoUpdateFailurePath(plan);
   if (!path) return;
   try {
-    (0, import_node_fs15.unlinkSync)(path);
+    (0, import_node_fs16.unlinkSync)(path);
   } catch {
   }
 }
@@ -23536,7 +24438,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return (0, import_node_path18.join)(
+  return (0, import_node_path19.join)(
     versionDir,
     "node_modules",
     "deepline",
@@ -23546,14 +24448,14 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = (0, import_node_path18.join)(
+  const packageJsonPath = (0, import_node_path19.join)(
     versionDir,
     "node_modules",
     "deepline",
     "package.json"
   );
   try {
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(packageJsonPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" ? safeVersionSegment(parsed.version) : "";
   } catch {
     return "";
@@ -23561,7 +24463,7 @@ function installedPackageVersion(versionDir) {
 }
 function runCommand(command, args, env = process.env, options = {}) {
   return new Promise((resolveExitCode) => {
-    const child = (0, import_node_child_process3.spawn)(command, args, {
+    const child = (0, import_node_child_process4.spawn)(command, args, {
       stdio: options.stdio === "stderr" ? ["inherit", "pipe", "pipe"] : "inherit",
       shell: process.platform === "win32",
       env
@@ -23585,9 +24487,9 @@ function runCommand(command, args, env = process.env, options = {}) {
   });
 }
 function writeSidecarLauncher(input2) {
-  (0, import_node_fs15.mkdirSync)((0, import_node_path18.dirname)(input2.path), { recursive: true });
+  (0, import_node_fs16.mkdirSync)((0, import_node_path19.dirname)(input2.path), { recursive: true });
   if (process.platform === "win32") {
-    (0, import_node_fs15.writeFileSync)(
+    (0, import_node_fs16.writeFileSync)(
       input2.path,
       [
         `@set DEEPLINE_HOST_URL=${input2.hostUrl.replace(/\r?\n/g, "")}`,
@@ -23599,7 +24501,7 @@ function writeSidecarLauncher(input2) {
     );
     return;
   }
-  (0, import_node_fs15.writeFileSync)(
+  (0, import_node_fs16.writeFileSync)(
     input2.path,
     [
       "#!/usr/bin/env sh",
@@ -23612,17 +24514,17 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan, options = {}) {
-  const versionsDir = (0, import_node_path18.join)(plan.stateDir, "versions");
-  const tempDir = (0, import_node_path18.join)(
+  const versionsDir = (0, import_node_path19.join)(plan.stateDir, "versions");
+  const tempDir = (0, import_node_path19.join)(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
-  (0, import_node_fs15.rmSync)(tempDir, { recursive: true, force: true });
-  (0, import_node_fs15.mkdirSync)(tempDir, { recursive: true });
-  (0, import_node_fs15.writeFileSync)((0, import_node_path18.join)(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
+  (0, import_node_fs16.mkdirSync)(tempDir, { recursive: true });
+  (0, import_node_fs16.writeFileSync)((0, import_node_path19.join)(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
-    PATH: `${(0, import_node_path18.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
+    PATH: `${(0, import_node_path19.dirname)(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
   };
   const installExitCode = await runCommand(
     plan.npmCommand,
@@ -23637,7 +24539,7 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
     options
   );
   if (installExitCode !== 0) {
-    (0, import_node_fs15.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
     return installExitCode;
   }
   const installedVersion = installedPackageVersion(tempDir);
@@ -23645,19 +24547,19 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
     process.stderr.write(
       "Updated Deepline SDK package did not report a version.\n"
     );
-    (0, import_node_fs15.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = (0, import_node_path18.join)(versionsDir, installedVersion);
+  const finalDir = (0, import_node_path19.join)(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
-  if ((0, import_node_fs15.existsSync)(finalEntryPath)) {
-    (0, import_node_fs15.rmSync)(tempDir, { recursive: true, force: true });
+  if ((0, import_node_fs16.existsSync)(finalEntryPath)) {
+    (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
   } else {
-    (0, import_node_fs15.rmSync)(finalDir, { recursive: true, force: true });
+    (0, import_node_fs16.rmSync)(finalDir, { recursive: true, force: true });
     try {
-      (0, import_node_fs15.renameSync)(tempDir, finalDir);
+      (0, import_node_fs16.renameSync)(tempDir, finalDir);
     } catch (error) {
-      (0, import_node_fs15.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs16.rmSync)(tempDir, { recursive: true, force: true });
       process.stderr.write(
         `Failed to publish Deepline SDK sidecar update: ${error.message}
 `
@@ -23665,7 +24567,7 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
       return 1;
     }
   }
-  if (!(0, import_node_fs15.existsSync)(finalEntryPath)) {
+  if (!(0, import_node_fs16.existsSync)(finalEntryPath)) {
     process.stderr.write(
       `Updated Deepline SDK CLI entrypoint missing: ${finalEntryPath}
 `
@@ -23679,28 +24581,28 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
     nodeBin: plan.nodeBin,
     entryPath: finalEntryPath
   });
-  (0, import_node_fs15.writeFileSync)(
-    (0, import_node_path18.join)(plan.stateDir, ".version"),
+  (0, import_node_fs16.writeFileSync)(
+    (0, import_node_path19.join)(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
-  (0, import_node_fs15.writeFileSync)(
-    (0, import_node_path18.join)(plan.stateDir, ".install-method"),
+  (0, import_node_fs16.writeFileSync)(
+    (0, import_node_path19.join)(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
-  (0, import_node_fs15.writeFileSync)(
-    (0, import_node_path18.join)(plan.stateDir, ".command-path"),
+  (0, import_node_fs16.writeFileSync)(
+    (0, import_node_path19.join)(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  (0, import_node_fs15.writeFileSync)((0, import_node_path18.join)(plan.stateDir, ".runner"), "node\n", "utf8");
-  (0, import_node_fs15.writeFileSync)((0, import_node_path18.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  (0, import_node_fs16.writeFileSync)((0, import_node_path19.join)(plan.stateDir, ".runner"), "node\n", "utf8");
+  (0, import_node_fs16.writeFileSync)((0, import_node_path19.join)(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
-  (0, import_node_fs15.writeFileSync)(
-    (0, import_node_path18.join)(plan.stateDir, ".entry-path"),
+  (0, import_node_fs16.writeFileSync)(
+    (0, import_node_path19.join)(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -23889,7 +24791,7 @@ function unknownCommandNameFromMessage(message) {
 }
 
 // src/cli/self-update.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 function envTruthy(name) {
   const value = process.env[name]?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes";
@@ -23935,10 +24837,10 @@ function isDowngradeAutoUpdateResponse(response) {
   return compareSemver(target, current) < 0;
 }
 function relaunchCurrentCommand(plan) {
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const command = plan.kind === "python-sidecar" ? plan.sidecarPath : process.execPath;
     const args = plan.kind === "python-sidecar" ? process.argv.slice(2) : process.argv.slice(1);
-    const child = (0, import_node_child_process4.spawn)(command, args, {
+    const child = (0, import_node_child_process5.spawn)(command, args, {
       stdio: "inherit",
       shell: process.platform === "win32",
       env: {
@@ -23951,9 +24853,9 @@ function relaunchCurrentCommand(plan) {
         `Deepline SDK/CLI updated, but relaunch failed: ${error.message}
 `
       );
-      resolve13(1);
+      resolve14(1);
     });
-    child.on("close", (code) => resolve13(code ?? 1));
+    child.on("close", (code) => resolve14(code ?? 1));
   });
 }
 async function maybeAutoUpdateAndRelaunch(response) {
@@ -24003,7 +24905,7 @@ async function maybeAutoUpdateAndRelaunch(response) {
 }
 
 // src/cli/failure-reporting.ts
-var import_node_os13 = require("os");
+var import_node_os14 = require("os");
 var FAILURE_REPORT_DISABLE_ENV = "DEEPLINE_DISABLE_FAILURE_REPORTING";
 var REPORT_FAILURE_TIMEOUT_MS = 1e4;
 var MAX_FAILURE_TEXT_CHARS = 4e3;
@@ -24105,12 +25007,12 @@ function isNetworkFailure(error) {
 }
 function buildEnvironmentContext() {
   const context = {
-    os: (0, import_node_os13.platform)(),
-    os_release: (0, import_node_os13.release)(),
-    platform: `${(0, import_node_os13.platform)()}-${(0, import_node_os13.release)()}-${process.arch}`,
+    os: (0, import_node_os14.platform)(),
+    os_release: (0, import_node_os14.release)(),
+    platform: `${(0, import_node_os14.platform)()}-${(0, import_node_os14.release)()}-${process.arch}`,
     node_version: process.version,
     runtime: "Node.js",
-    hostname: (0, import_node_os13.hostname)(),
+    hostname: (0, import_node_os14.hostname)(),
     agent_runtime: detectAgentRuntime()
   };
   for (const key of ["CLAUDE_CODE_REMOTE", "DEEPLINE_PLUGIN_MODE"]) {
@@ -24303,8 +25205,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await (0, import_promises5.mkdtemp)((0, import_node_path19.join)((0, import_node_os14.tmpdir)(), "deepline-health-play-"));
-  const file = (0, import_node_path19.join)(dir, "health-check.play.ts");
+  const dir = await (0, import_promises5.mkdtemp)((0, import_node_path20.join)((0, import_node_os15.tmpdir)(), "deepline-health-play-"));
+  const file = (0, import_node_path20.join)(dir, "health-check.play.ts");
   try {
     await (0, import_promises5.writeFile)(
       file,