deepline 0.1.153 → 0.1.154

package/dist/cli/index.mjs

@@ -159,7 +159,7 @@ configureProxyFromEnv();
 
 // src/cli/index.ts
 import { mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile5 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { Command as Command3 } from "commander";
 
@@ -640,10 +640,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.153",
+  version: "0.1.154",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.153",
+    latest: "0.1.154",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1237,7 +1237,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)) {
@@ -1447,8 +1447,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":
@@ -1456,6 +1463,7 @@ function normalizePlayRunLiveStatus(value) {
       return "running";
     case "running":
     case "started":
+    case "waiting":
       return "running";
     case "completed":
     case "complete":
@@ -1476,8 +1484,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));
@@ -2006,14 +2022,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) {
@@ -2114,7 +2130,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") {
@@ -4792,7 +4808,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) {
@@ -6211,6 +6227,19 @@ 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
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync6,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join5, resolve as resolve5 } from "path";
+
 // src/cli/dataset-stats.ts
 import { writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve4 } from "path";
@@ -6550,6 +6579,7 @@ function collectCanonicalRowsInfos(statusOrResult) {
     total: totalFromMetadata,
     output: candidates
   });
+  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
@@ -6928,6 +6958,311 @@ async function handleCsvShow(options) {
 `
   );
 }
+function csvRenderStatePath() {
+  return join5(homedir6(), ".local", "deepline", "runtime", "csv-render.json");
+}
+function csvRenderLogPath() {
+  return join5(homedir6(), ".local", "deepline", "runtime", "csv-render.log");
+}
+function ensureCsvRenderStateDir() {
+  mkdirSync5(join5(homedir6(), ".local", "deepline", "runtime"), {
+    recursive: true
+  });
+}
+function readCsvRenderState() {
+  try {
+    const parsed = JSON.parse(readFileSync6(csvRenderStatePath(), "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeCsvRenderState(state) {
+  ensureCsvRenderStateDir();
+  writeFileSync6(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 = 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 ? resolve5(options.csv) : "";
+  if (csvPath && !existsSync6(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 {
+        }
+      }
+      rmSync3(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 {
+      rmSync3(csvRenderStatePath(), { force: true });
+    }
+  }
+  ensureCsvRenderStateDir();
+  const logPath = csvRenderLogPath();
+  const token = randomUUID();
+  const child = 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);
+  writeFileSync6(
+    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);
+    }
+  }
+  rmSync3(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",
@@ -6954,11 +7289,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
-import { writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve5 } from "path";
+import { writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve6 } from "path";
 var CUSTOMER_DB_QUERY_FORMATS = /* @__PURE__ */ new Set(["table", "json", "csv", "markdown"]);
 var CUSTOMER_DB_QUERY_MAX_ROWS = 1e3;
 function parsePositiveInteger(value, flagName) {
@@ -7081,8 +7418,8 @@ function formatDbQueryError(sql, error) {
   return errorMessage(error);
 }
 function writeCustomerDbCsv(result, outPath) {
-  const resolved = resolve5(outPath);
-  writeFileSync6(
+  const resolved = resolve6(outPath);
+  writeFileSync7(
     resolved,
     dataExportCsvString(customerDbRows(result), customerDbColumnNames(result)),
     "utf-8"
@@ -7194,8 +7531,8 @@ async function handleDbQuery(args) {
       customerDbColumnNames(result)
     );
     if (outPath) {
-      const exportedPath = resolve5(outPath);
-      writeFileSync6(exportedPath, content, "utf-8");
+      const exportedPath = resolve6(outPath);
+      writeFileSync7(exportedPath, content, "utf-8");
       printCommandEnvelope(
         dbQueryExportEnvelope({
           result,
@@ -7304,20 +7641,20 @@ import {
   stat,
   writeFile as writeFile3
 } from "fs/promises";
-import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
-import { join as join6, resolve as resolve8 } from "path";
+import { homedir as homedir7, tmpdir as tmpdir2 } from "os";
+import { join as join7, resolve as resolve9 } from "path";
 
 // src/cli/commands/play.ts
 import { createHash as createHash2 } from "crypto";
 import {
-  existsSync as existsSync6,
-  readFileSync as readFileSync6,
+  existsSync as existsSync7,
+  readFileSync as readFileSync7,
   readdirSync as readdirSync2,
   realpathSync as realpathSync2,
   statSync as statSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import { basename, dirname as dirname6, join as join5, resolve as resolve7 } from "path";
+import { basename, dirname as dirname6, join as join6, resolve as resolve8 } from "path";
 import { parse as parseCsvSync2 } from "csv-parse/sync";
 
 // src/cli/commands/plays/bootstrap.ts
@@ -7326,9 +7663,9 @@ import {
   openSync,
   readSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { isAbsolute, relative, resolve as resolve6 } from "path";
+import { isAbsolute, relative, resolve as resolve7 } from "path";
 import { parse as parseCsvSync } from "csv-parse/sync";
 
 // ../shared_libs/plays/bootstrap-routes.ts
@@ -7757,7 +8094,7 @@ function inferCsvColumnSpecs(headers, rows) {
   }));
 }
 function readCsvSample(csvPath) {
-  const resolvedPath = resolve6(csvPath);
+  const resolvedPath = resolve7(csvPath);
   const size = statSync2(resolvedPath).size;
   const fd = openSync(resolvedPath, "r");
   const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
@@ -7832,7 +8169,7 @@ ${properties}
 }
 function packagedCsvPathForPlay(csvPath) {
   const playDir = process.cwd();
-  const absoluteCsvPath = resolve6(csvPath);
+  const absoluteCsvPath = resolve7(csvPath);
   const relativePath = relative(playDir, absoluteCsvPath);
   if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath)) {
     throw new PlayBootstrapUsageError(
@@ -8756,8 +9093,8 @@ async function runPlayBootstrap(args) {
     ...csvContext
   });
   if (options.out) {
-    writeFileSync7(resolve6(options.out), source, "utf-8");
-    process.stdout.write(`Wrote ${resolve6(options.out)}
+    writeFileSync8(resolve7(options.out), source, "utf-8");
+    process.stdout.write(`Wrote ${resolve7(options.out)}
 `);
     return 0;
   }
@@ -9441,7 +9778,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();
@@ -9485,7 +9822,7 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return resolve7(defaultStarterPlayPath(reference));
+  return resolve8(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
   const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
@@ -9511,15 +9848,15 @@ function materializeRemotePlaySource(input2) {
     return null;
   }
   const outputPath = input2.outPath ?? defaultMaterializedPlayPath(input2.playName);
-  if (existsSync6(outputPath)) {
-    const existingSource = readFileSync6(outputPath, "utf-8");
+  if (existsSync7(outputPath)) {
+    const existingSource = readFileSync7(outputPath, "utf-8");
     if (existingSource === input2.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    writeFileSync8(outputPath, input2.sourceCode, "utf-8");
+    writeFileSync9(outputPath, input2.sourceCode, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  writeFileSync8(outputPath, input2.sourceCode, "utf-8");
+  writeFileSync9(outputPath, input2.sourceCode, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -9564,7 +9901,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return existsSync6(resolve7(target));
+  return existsSync7(resolve8(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -9593,7 +9930,7 @@ function parsePositiveInteger3(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? readFileSync6(resolve7(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? readFileSync7(resolve8(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.");
@@ -9695,7 +10032,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 existsSync6(resolve7(value));
+  return existsSync7(resolve8(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -9742,7 +10079,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 && existsSync6(resolve7(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && existsSync7(resolve8(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -9784,8 +10121,8 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = resolve7(ref.value);
-    if (!existsSync6(absolutePath)) {
+    const absolutePath = resolve8(ref.value);
+    if (!existsSync7(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,
@@ -9821,7 +10158,7 @@ function preflightLocalFileInputs(runtimeInput) {
 function preflightCsvDataInput(ref, absolutePath) {
   let content;
   try {
-    content = readFileSync6(absolutePath, "utf-8");
+    content = readFileSync7(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.`,
@@ -9903,7 +10240,7 @@ async function stageFileInputArgs(input2) {
   const localFiles = uniqueBindings.flatMap((binding) => {
     const value = getDottedInputValue(input2.runtimeInput, binding.inputPath);
     if (!isLocalFilePathValue(value)) return [];
-    const absolutePath = resolve7(value);
+    const absolutePath = resolve8(value);
     return [{ binding, absolutePath, logicalPath: basename(absolutePath) }];
   });
   if (localFiles.length === 0) {
@@ -9936,7 +10273,7 @@ async function stageFileInputArgs(input2) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = readFileSync6(absolutePath);
+  const buffer = readFileSync7(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
@@ -9947,9 +10284,9 @@ function stageFile(logicalPath, absolutePath) {
 }
 function normalizePlayPath(filePath) {
   try {
-    return realpathSync2.native(resolve7(filePath));
+    return realpathSync2.native(resolve8(filePath));
   } catch {
-    return resolve7(filePath);
+    return resolve8(filePath);
   }
 }
 function formatBundlingErrors(filePath, errors) {
@@ -12016,7 +12353,7 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function runExportRetryCommand(runId, outPath, datasetPath) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve7(outPath))}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellSingleQuote(datasetPath)}` : ""} --out ${shellSingleQuote(resolve8(outPath))}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -12821,7 +13158,7 @@ async function handlePlayCheck(args) {
       }
       return 0;
     } catch (error) {
-      const resolved = resolve7(options.target);
+      const resolved = resolve8(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         process.stdout.write(
@@ -12838,8 +13175,8 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = resolve7(options.target);
-  const sourceCode = readFileSync6(absolutePlayPath, "utf-8");
+  const absolutePlayPath = resolve8(options.target);
+  const sourceCode = readFileSync7(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -12939,12 +13276,12 @@ async function handleFileBackedRun(options) {
   }
   const client2 = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = resolve7(options.target.path);
+  const absolutePlayPath = resolve8(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => readFileSync6(absolutePlayPath, "utf-8")
+    () => readFileSync7(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   try {
@@ -13265,10 +13602,10 @@ async function handlePlayRun(args) {
     if (isFileTarget(options.target.path)) {
       return handleFileBackedRun(options);
     }
-    const resolved = resolve7(options.target.path);
+    const resolved = resolve8(options.target.path);
     console.error(`File not found: ${resolved}`);
     const dir = dirname6(resolved);
-    if (existsSync6(dir)) {
+    if (existsSync7(dir)) {
       const base = basename(resolved);
       try {
         const siblings = readdirSync2(dir).filter(
@@ -13277,7 +13614,7 @@ async function handlePlayRun(args) {
         if (siblings.length > 0) {
           console.error(`Did you mean one of these?`);
           for (const s of siblings.slice(0, 5)) {
-            console.error(`  ${join5(dir, s)}`);
+            console.error(`  ${join6(dir, s)}`);
           }
         }
       } catch {
@@ -13436,14 +13773,14 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve7(args[++index]);
+      outPath = resolve8(args[++index]);
     }
   }
   const client2 = new DeeplineClient();
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
     const logs = result2.entries;
-    writeFileSync8(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    writeFileSync9(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
       {
         runId: result2.runId,
@@ -13593,7 +13930,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 = resolve7(args[++index]);
+      outPath = resolve8(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -13601,7 +13938,7 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = resolve7(args[++index]);
+      metadataOutPath = resolve8(args[++index]);
     }
   }
   if (!outPath) {
@@ -13641,7 +13978,7 @@ async function handleRunExport(args) {
     }
   };
   if (metadataOutPath) {
-    writeFileSync8(
+    writeFileSync9(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -13673,10 +14010,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 = resolve7(args[++index]);
+      outPath = resolve8(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName(readFileSync6(resolve7(target), "utf-8"), resolve7(target)) : parseReferencedPlayTarget2(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName(readFileSync7(resolve8(target), "utf-8"), resolve8(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({
@@ -14125,7 +14462,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget(playName) ? (() => {
       try {
         return extractPlayName(
-          readFileSync6(resolve7(playName), "utf-8"),
+          readFileSync7(resolve8(playName), "utf-8"),
           playName
         );
       } catch {
@@ -14206,7 +14543,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph(resolve7(playName))
+        () => collectBundledPlayGraph(resolve8(playName))
       );
       assertBundledPlayGraphDescriptions(graph);
       await traceCliSpan(
@@ -14395,12 +14732,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":"..."}'
@@ -15257,12 +15597,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
   };
 }
 
@@ -15344,7 +15682,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) {
@@ -15354,9 +15692,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)}` : "";
@@ -15382,6 +15718,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)}
@@ -15469,6 +15822,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;`,
@@ -15479,9 +15837,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");
 }
@@ -15491,18 +15863,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)},`,
@@ -15579,7 +15949,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 "";
@@ -15587,7 +15957,6 @@ function renderMetadataColumnStep(config, policySource) {
   return [
     `      .withColumn('_metadata',`,
     `        (row) => __dlMergeMetadata(__dlMetadataFromRow(row), ${stableJson({ columns })}),`,
-    `        ${policySource},`,
     `      )`
   ].join("\n");
 }
@@ -15622,16 +15991,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)
@@ -15641,13 +16005,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)})`
     )
   ];
 }
@@ -15687,19 +16048,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);`,
@@ -15710,7 +16067,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;`,
     `  }`,
@@ -15718,7 +16075,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.")} });`
   ];
@@ -15927,6 +16284,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));`,
@@ -15970,12 +16328,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,`,
     `  };`,
@@ -16066,6 +16426,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>;`,
@@ -16278,6 +16642,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();`,
@@ -16299,8 +16686,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;`,
     `}`,
     ``,
@@ -16437,7 +16824,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));`,
@@ -16448,6 +16835,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";
@@ -16562,6 +16953,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);
@@ -16574,10 +16976,10 @@ function expandAtFilePath(rawPath) {
     (_match, bareName, bracedName) => process.env[bareName ?? bracedName ?? ""] ?? ""
   );
   if (expanded === "~") {
-    return homedir6();
+    return homedir7();
   }
   if (expanded.startsWith("~/") || expanded.startsWith("~\\")) {
-    return join6(homedir6(), expanded.slice(2));
+    return join7(homedir7(), expanded.slice(2));
   }
   return expanded;
 }
@@ -16711,6 +17113,7 @@ async function buildPlanArgs(args) {
     "--dry-run",
     "--json",
     "--force",
+    "--fail-fast",
     "--all",
     "--in-place",
     "--no-open"
@@ -16761,7 +17164,7 @@ async function buildPlanArgs(args) {
   return planArgs;
 }
 async function assertInputCsvExists(inputCsv) {
-  const path = resolve8(inputCsv);
+  const path = resolve9(inputCsv);
   try {
     const info = await stat(path);
     if (info.isFile()) {
@@ -16775,8 +17178,8 @@ async function assertInputCsvExists(inputCsv) {
   }
 }
 async function assertSafeOutputPath(inputCsv, outputPath) {
-  const input2 = resolve8(inputCsv);
-  const output2 = resolve8(outputPath);
+  const input2 = resolve9(inputCsv);
+  const output2 = resolve9(outputPath);
   if (input2 === output2) {
     throw new Error(
       "--input and --output must be different files when not using --in-place."
@@ -16805,7 +17208,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await stat(resolve8(path));
+    const info = await stat(resolve9(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -16816,7 +17219,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await readFile(resolve8(path), "utf8");
+  const source = await readFile(resolve9(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -17093,15 +17496,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;
@@ -17121,20 +17556,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, [
@@ -17144,7 +17600,7 @@ async function writeOutputCsv(outputPath, status, options) {
     options?.config
   );
   await writeFile3(
-    resolve8(outputPath),
+    resolve9(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
   );
@@ -17154,7 +17610,7 @@ async function writeOutputCsv(outputPath, status, options) {
     selectedRows: rowsInfo.totalRows,
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
-    path: resolve8(outputPath),
+    path: resolve9(outputPath),
     partial: !rowsInfo.complete,
     enrichedDataRows: rowsInfo.rows
   };
@@ -17198,16 +17654,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()) {
@@ -17282,20 +17745,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);
@@ -17323,14 +17868,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 [
@@ -17350,6 +17903,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();
@@ -17371,6 +17946,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;
   }
@@ -17402,7 +17985,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(
@@ -17413,6 +17998,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) {
@@ -17422,11 +18057,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,
@@ -17442,6 +18079,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));
@@ -17584,9 +18287,9 @@ async function persistEnrichFailureReport(input2) {
   if (input2.jobs.length === 0) {
     return null;
   }
-  const stateDir = join6(homedir6(), ".local", "deepline", "runtime", "state");
+  const stateDir = join7(homedir7(), ".local", "deepline", "runtime", "state");
   await mkdir3(stateDir, { recursive: true });
-  const reportPath = join6(
+  const reportPath = join7(
     stateDir,
     `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
@@ -17615,11 +18318,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;
   }
@@ -17677,75 +18385,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,
@@ -17824,21 +18596,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;
   });
 }
@@ -18001,6 +18898,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.");
@@ -18024,14 +18924,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: resolve8(inputCsv),
-          output: options.output ? resolve8(options.output) : null,
+          input: resolve9(inputCsv),
+          output: options.output ? resolve9(options.output) : null,
           plan: summary
         });
         return;
@@ -18053,15 +18955,17 @@ function registerEnrichCommand(program) {
     }
     const playSource = compileEnrichConfigToPlaySource(config, {
       forceAliases,
-      playName: options.name
+      playName: options.name,
+      inlineRunJavascript: true,
+      failFast: options.failFast
     });
-    const tempDir = await mkdtemp(join6(tmpdir2(), "deepline-enrich-play-"));
-    const tempPlay = join6(tempDir, "deepline-enrich.play.ts");
+    const tempDir = await mkdtemp(join7(tmpdir2(), "deepline-enrich-play-"));
+    const tempPlay = join7(tempDir, "deepline-enrich.play.ts");
     try {
       await writeFile3(tempPlay, playSource, "utf8");
       const runOne = async (input2) => {
         const runtimeInput = {
-          file: resolve8(input2.sourceCsvPath),
+          file: resolve9(input2.sourceCsvPath),
           ...input2.rows.rowStart !== null ? { rowStart: input2.rows.rowStart } : {},
           ...input2.rows.rowEnd !== null ? { rowEnd: input2.rows.rowEnd } : {}
         };
@@ -18087,7 +18991,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({
@@ -18114,7 +19018,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 ${resolve8(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 ${resolve9(outputPath)}.
 `
           );
         }
@@ -18190,7 +19094,8 @@ function registerEnrichCommand(program) {
             rowEnd: selectedRange.end
           },
           client: client2,
-          outputPath
+          outputPath,
+          status: lastStatus
         });
         if (options.json) {
           const run = rewriteEnrichJsonStatus({
@@ -18254,7 +19159,8 @@ function registerEnrichCommand(program) {
           rowRange: rows,
           client: client2,
           exportResult,
-          outputPath
+          outputPath,
+          status
         });
         if (options.json) {
           printJson({
@@ -18279,7 +19185,8 @@ function registerEnrichCommand(program) {
           rowRange: rows,
           client: client2,
           exportResult,
-          outputPath
+          outputPath,
+          status
         });
         const run = rewriteEnrichJsonStatus({
           status,
@@ -18323,7 +19230,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;
@@ -18380,17 +19288,17 @@ Examples:
 
 // src/cli/commands/sessions.ts
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync6,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   statSync as statSync4,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
-import { homedir as homedir7, platform } from "os";
-import { basename as basename2, dirname as dirname7, join as join7, resolve as resolve9 } from "path";
+import { homedir as homedir8, platform } from "os";
+import { basename as basename2, dirname as dirname7, join as join8, resolve as resolve10 } from "path";
 import { gzipSync } from "zlib";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "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;
@@ -18402,7 +19310,7 @@ 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() || homedir7();
+  return process.env.HOME?.trim() || homedir8();
 }
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
@@ -18414,21 +19322,21 @@ function detectShellContext() {
   };
 }
 function claudeProjectsRoot() {
-  return join7(homeDir(), ".claude", "projects");
+  return join8(homeDir(), ".claude", "projects");
 }
 function codexSessionsRoot() {
-  return join7(homeDir(), ".codex", "sessions");
+  return join8(homeDir(), ".codex", "sessions");
 }
 function listClaudeSessionFiles() {
   const root = claudeProjectsRoot();
-  if (!existsSync7(root)) return [];
+  if (!existsSync8(root)) return [];
   const projectDirs = readDirectoryNames(root);
   const files = [];
   for (const projectDir of projectDirs) {
-    const fullProjectDir = join7(root, projectDir);
+    const fullProjectDir = join8(root, projectDir);
     for (const fileName of readDirectoryNames(fullProjectDir)) {
       if (fileName.endsWith(".jsonl")) {
-        const filePath = join7(fullProjectDir, fileName);
+        const filePath = join8(fullProjectDir, fileName);
         const sessionId = sessionIdFromClaudeFilePath(filePath);
         const stat2 = statIfReadable(filePath);
         if (sessionId && stat2) {
@@ -18446,7 +19354,7 @@ function listClaudeSessionFiles() {
 }
 function listCodexSessionFiles() {
   const root = codexSessionsRoot();
-  if (!existsSync7(root)) return [];
+  if (!existsSync8(root)) return [];
   const files = [];
   for (const filePath of listJsonlFilesRecursive(root, 5)) {
     const stat2 = statIfReadable(filePath);
@@ -18485,7 +19393,7 @@ function listJsonlFilesRecursive(root, maxDepth) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join7(dir, entry.name);
+      const fullPath = join8(dir, entry.name);
       if (entry.isDirectory()) {
         visit(fullPath, depth + 1);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -18521,7 +19429,7 @@ function sessionIdFromCodexFilePath(filePath) {
 }
 function readCodexSessionId(filePath) {
   try {
-    for (const line of normalizedJsonLines(readFileSync7(filePath)).slice(
+    for (const line of normalizedJsonLines(readFileSync8(filePath)).slice(
       0,
       20
     )) {
@@ -18752,7 +19660,7 @@ async function uploadPayload(path, payload) {
   return await http.post(path, payload);
 }
 async function uploadChunkedSessions(sessions, options) {
-  const uploadId = randomUUID();
+  const uploadId = randomUUID2();
   for (const session of sessions) {
     const bytes = Buffer.from(session.encodedContent, "base64");
     const chunks = [];
@@ -18798,12 +19706,12 @@ async function uploadChunkedSessions(sessions, options) {
 }
 async function handleSessionsSend(options) {
   if (options.file) {
-    const filePath = resolve9(options.file);
-    if (!existsSync7(filePath)) {
+    const filePath = resolve10(options.file);
+    if (!existsSync8(filePath)) {
       throw new Error(`File not found: ${options.file}`);
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
-      file: readFileSync7(filePath).toString("base64"),
+      file: readFileSync8(filePath).toString("base64"),
       filename: basename2(filePath)
     });
     printCommandEnvelope(
@@ -18833,7 +19741,7 @@ async function handleSessionsSend(options) {
     agent: options.agent
   });
   const built = targets.map((target) => {
-    const upload = buildSessionUploadContent(readFileSync7(target.filePath));
+    const upload = buildSessionUploadContent(readFileSync8(target.filePath));
     return { ...target, ...upload };
   });
   if (built.some((session) => session.needsChunking)) {
@@ -18897,11 +19805,11 @@ function fallbackViewerAssets() {
   };
 }
 function loadViewerAssets() {
-  const cliEntry = process.argv[1]?.trim() ? resolve9(process.argv[1]) : null;
+  const cliEntry = process.argv[1]?.trim() ? resolve10(process.argv[1]) : null;
   const candidateRoots2 = [
     ...cliEntry ? [
-      join7(dirname7(dirname7(cliEntry)), "viewer"),
-      join7(
+      join8(dirname7(dirname7(cliEntry)), "viewer"),
+      join8(
         dirname7(dirname7(dirname7(cliEntry))),
         "src",
         "lib",
@@ -18909,16 +19817,16 @@ function loadViewerAssets() {
         "viewer"
       )
     ] : [],
-    join7(process.cwd(), "src", "lib", "cli", "viewer")
+    join8(process.cwd(), "src", "lib", "cli", "viewer")
   ];
   for (const root of candidateRoots2) {
     try {
-      const cssPath = join7(root, "viewer.css");
-      const jsPath = join7(root, "viewer.js");
-      if (!existsSync7(cssPath) || !existsSync7(jsPath)) continue;
+      const cssPath = join8(root, "viewer.css");
+      const jsPath = join8(root, "viewer.js");
+      if (!existsSync8(cssPath) || !existsSync8(jsPath)) continue;
       return {
-        css: readFileSync7(cssPath, "utf8"),
-        js: readFileSync7(jsPath, "utf8")
+        css: readFileSync8(cssPath, "utf8"),
+        js: readFileSync8(jsPath, "utf8")
       };
     } catch {
       continue;
@@ -18942,21 +19850,21 @@ async function handleSessionsRender(options) {
     currentSession: options.currentSession,
     agent: options.agent
   });
-  let outputPath = options.output ? resolve9(options.output) : "";
+  let outputPath = options.output ? resolve10(options.output) : "";
   if (!outputPath) {
-    const outputDir = join7(process.cwd(), "deepline", "data");
-    mkdirSync5(outputDir, { recursive: true });
-    outputPath = join7(
+    const outputDir = join8(process.cwd(), "deepline", "data");
+    mkdirSync6(outputDir, { recursive: true });
+    outputPath = join8(
       outputDir,
       targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
     );
   } else {
-    mkdirSync5(dirname7(outputPath), { recursive: true });
+    mkdirSync6(dirname7(outputPath), { recursive: true });
   }
   const sessions = targets.map((target) => ({
     label: target.label,
     events: parsePreparedEvents(
-      prepareSessionBuffer(readFileSync7(target.filePath))
+      prepareSessionBuffer(readFileSync8(target.filePath))
     )
   }));
   const { css, js } = loadViewerAssets();
@@ -18979,7 +19887,7 @@ ${refreshMeta}
 <script>${js}</script>
 </body>
 </html>`;
-  writeFileSync9(outputPath, html, "utf8");
+  writeFileSync10(outputPath, html, "utf8");
   printCommandEnvelope(
     {
       ok: true,
@@ -19963,7 +20871,7 @@ Examples:
 }
 
 // src/cli/commands/quickstart.ts
-import { spawn, spawnSync } from "child_process";
+import { spawn as spawn2, spawnSync } from "child_process";
 import { randomBytes } from "crypto";
 import { createServer } from "http";
 var EXIT_OK2 = 0;
@@ -19986,17 +20894,17 @@ function hasClaudeBinary() {
   }
 }
 function launchClaude(prompt) {
-  return new Promise((resolve13) => {
-    const child = spawn("claude", [prompt], {
+  return new Promise((resolve14) => {
+    const child = spawn2("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) => {
@@ -20006,7 +20914,7 @@ function readBody(req) {
         req.destroy();
       }
     });
-    req.on("end", () => resolve13(raw));
+    req.on("end", () => resolve14(raw));
     req.on("error", reject);
   });
 }
@@ -20061,7 +20969,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();
@@ -20069,7 +20977,7 @@ function startCallbackServer(input2) {
         reject(new Error("Failed to bind quickstart callback server."));
         return;
       }
-      resolve13({ server, port: address.port });
+      resolve14({ server, port: address.port });
     });
   });
 }
@@ -20095,8 +21003,8 @@ async function handleQuickstart(options) {
   }
   const state = randomBytes(32).toString("hex");
   let resolveSelection;
-  const selectionPromise = new Promise((resolve13) => {
-    resolveSelection = resolve13;
+  const selectionPromise = new Promise((resolve14) => {
+    resolveSelection = resolve14;
   });
   let callback;
   try {
@@ -20235,7 +21143,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);
@@ -20253,7 +21161,7 @@ async function readHiddenLine(prompt, streams = {}) {
       settled = true;
       outputStream.write("\n");
       cleanup();
-      resolve13(line);
+      resolve14(line);
     };
     const fail = (error) => {
       if (settled) return;
@@ -20424,9 +21332,9 @@ Examples:
 }
 
 // src/cli/commands/switch.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname8, join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname8, join as join9 } from "path";
 function hostSlugFromBaseUrl(baseUrl) {
   try {
     const url = new URL(baseUrl);
@@ -20446,8 +21354,8 @@ function resolveConfigScope() {
   return hostSlugFromBaseUrl(autoDetectBaseUrl());
 }
 function activeFamilyPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || homedir8();
-  return join8(
+  const home = process.env.HOME || process.env.USERPROFILE || homedir9();
+  return join9(
     home,
     ".local",
     "deepline",
@@ -20459,15 +21367,15 @@ function activeFamilyPath() {
 function readActiveFamily() {
   const path = activeFamilyPath();
   try {
-    return readFileSync8(path, "utf-8").trim() || "sdk";
+    return readFileSync9(path, "utf-8").trim() || "sdk";
   } catch {
     return "sdk";
   }
 }
 function writeActiveFamily(family) {
   const path = activeFamilyPath();
-  mkdirSync6(dirname8(path), { recursive: true });
-  writeFileSync10(path, `${family}
+  mkdirSync7(dirname8(path), { recursive: true });
+  writeFileSync11(path, `${family}
 `, "utf-8");
   return path;
 }
@@ -20484,7 +21392,7 @@ function handleSwitch(action, options) {
         ok: true,
         active_family: activeFamily,
         active_family_path: path,
-        active_family_file_exists: existsSync8(path),
+        active_family_file_exists: existsSync9(path),
         render: {
           sections: [
             {
@@ -20586,24 +21494,24 @@ Examples:
 import { Option } from "commander";
 import {
   chmodSync,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdtempSync,
-  readFileSync as readFileSync9,
-  writeFileSync as writeFileSync12
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync13
 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join10, resolve as resolve10 } from "path";
+import { join as join11, resolve as resolve11 } from "path";
 
 // src/tool-output.ts
 import {
   closeSync as closeSync2,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   openSync as openSync2,
-  writeFileSync as writeFileSync11,
+  writeFileSync as writeFileSync12,
   writeSync
 } from "fs";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname9, join as join9 } from "path";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname9, join as join10 } from "path";
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20730,19 +21638,19 @@ function projectRowOutput(conversion) {
   };
 }
 function ensureOutputDir() {
-  const outputDir = join9(homedir9(), ".local", "share", "deepline", "data");
-  mkdirSync7(outputDir, { recursive: true });
+  const outputDir = join10(homedir10(), ".local", "share", "deepline", "data");
+  mkdirSync8(outputDir, { recursive: true });
   return outputDir;
 }
 function writeJsonOutputFile(payload, stem) {
   const outputDir = ensureOutputDir();
-  const outputPath = join9(outputDir, `${stem}_${Date.now()}.json`);
-  writeFileSync11(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  const outputPath = join10(outputDir, `${stem}_${Date.now()}.json`);
+  writeFileSync12(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
 function writeCsvOutputFile(rows, stem, options) {
-  const outputPath = options?.outPath ? options.outPath : join9(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
-  mkdirSync7(dirname9(outputPath), { recursive: true });
+  const outputPath = options?.outPath ? options.outPath : join10(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  mkdirSync8(dirname9(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);
@@ -21908,11 +22816,11 @@ function normalizeOutputFormat(raw) {
 }
 function resolveAtFilePath(rawPath) {
   const trimmed = rawPath.trim();
-  const resolved = resolve10(trimmed);
-  if (existsSync9(resolved)) return resolved;
+  const resolved = resolve11(trimmed);
+  if (existsSync10(resolved)) return resolved;
   if (process.platform !== "win32" && trimmed.includes("\\")) {
-    const normalized = resolve10(trimmed.replace(/\\/g, "/"));
-    if (existsSync9(normalized)) return normalized;
+    const normalized = resolve11(trimmed.replace(/\\/g, "/"));
+    if (existsSync10(normalized)) return normalized;
   }
   return resolved;
 }
@@ -21923,7 +22831,7 @@ function readJsonArgument(raw, flagName) {
     throw new Error(`Invalid ${flagName} value: empty @file path.`);
   }
   try {
-    return readFileSync9(resolveAtFilePath(filePath), "utf8").replace(
+    return readFileSync10(resolveAtFilePath(filePath), "utf8").replace(
       /^\uFEFF/,
       ""
     );
@@ -22000,7 +22908,7 @@ function parseExecuteOptions(args) {
       continue;
     }
     if ((arg === "--out" || arg === "-o") && args[index + 1]) {
-      outPath = resolve10(args[++index]);
+      outPath = resolve11(args[++index]);
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -22030,9 +22938,9 @@ function starterScriptJson(script) {
 function seedToolListScript(input2) {
   const stem = safeFileStem(input2.toolId);
   const fileName = `${stem}-workflow-seed-${Date.now()}.play.ts`;
-  const scriptDir = mkdtempSync(join10(tmpdir3(), "deepline-workflow-seed-"));
+  const scriptDir = mkdtempSync(join11(tmpdir3(), "deepline-workflow-seed-"));
   chmodSync(scriptDir, 448);
-  const scriptPath = join10(scriptDir, fileName);
+  const scriptPath = join11(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(/\]$/, "")}, ...]` : "[]";
@@ -22075,7 +22983,7 @@ export default definePlay(${JSON.stringify(playName)}, async (ctx) => {
   description: ${JSON.stringify(`Seed ${input2.toolId} rows into a Deepline workflow-ready dataset.`)},
 });
 `;
-  writeFileSync12(scriptPath, script, { encoding: "utf-8", mode: 384 });
+  writeFileSync13(scriptPath, script, { encoding: "utf-8", mode: 384 });
   return {
     path: scriptPath,
     sourceCode: script,
@@ -22406,7 +23314,7 @@ async function executeTool(args) {
 
 // src/cli/commands/workflow.ts
 import { mkdir as mkdir4, readFile as readFile2, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname10, join as join11, resolve as resolve11 } from "path";
+import { dirname as dirname10, join as join12, resolve as resolve12 } from "path";
 
 // src/cli/workflow-to-play.ts
 import { createHash as createHash3 } from "crypto";
@@ -22650,7 +23558,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await readFile2(resolve11(file), "utf8");
+    const raw = await readFile2(resolve12(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -22684,7 +23592,7 @@ async function transformOne(api, workflowId, outDir, publish) {
       revision.config,
       { workflowName: workflow.name, version: revision.version }
     );
-    const file = join11(resolve11(outDir), `${compiled.playName}.play.ts`);
+    const file = join12(resolve12(outDir), `${compiled.playName}.play.ts`);
     await mkdir4(dirname10(file), { recursive: true });
     await writeFile4(file, compiled.sourceCode, "utf8");
     let published = false;
@@ -22931,24 +23839,24 @@ Notes:
 }
 
 // src/cli/commands/update.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import {
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync9,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync10,
   realpathSync as realpathSync3,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   renameSync,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   unlinkSync,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "fs";
-import { homedir as homedir10 } from "os";
-import { dirname as dirname12, isAbsolute as isAbsolute2, join as join13, relative as relative2, resolve as resolve12 } from "path";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname12, isAbsolute as isAbsolute2, join as join14, relative as relative2, resolve as resolve13 } from "path";
 
 // src/cli/skills-sync.ts
-import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname11, join as join12 } from "path";
+import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname11, join as join13 } from "path";
 
 // ../shared_libs/cli/install-commands.json
 var install_commands_default = {
@@ -23067,38 +23975,38 @@ function activePluginSkillsDir() {
     return "";
   }
   const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && existsSync10(dir) ? dir : "";
+  return dir && existsSync11(dir) ? dir : "";
 }
 function readPluginSkillsVersion() {
   const dir = activePluginSkillsDir();
   if (!dir) return "";
   try {
-    return readFileSync10(join12(dir, ".version"), "utf-8").trim();
+    return readFileSync11(join13(dir, ".version"), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function sdkSkillsVersionPath(baseUrl) {
-  return join12(sdkCliStateDirPath(baseUrl), "skills-version");
+  return join13(sdkCliStateDirPath(baseUrl), "skills-version");
 }
 function legacySdkSkillsVersionPath(baseUrl) {
-  return join12(dirname11(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
+  return join13(dirname11(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
 }
 function readSdkSkillsLocalVersion(baseUrl) {
   const pluginVersion = readPluginSkillsVersion();
   if (pluginVersion) return pluginVersion;
-  const path = existsSync10(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
-  if (!existsSync10(path)) return "";
+  const path = existsSync11(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
+  if (!existsSync11(path)) return "";
   try {
-    return readFileSync10(path, "utf-8").trim();
+    return readFileSync11(path, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeLocalSkillsVersion(baseUrl, version) {
   const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync8(dirname11(path), { recursive: true });
-  writeFileSync13(path, `${version}
+  mkdirSync9(dirname11(path), { recursive: true });
+  writeFileSync14(path, `${version}
 `, "utf-8");
 }
 function sortedUniqueSkillNames(names) {
@@ -23196,8 +24104,8 @@ function resolveSkillsInstallCommands(baseUrl, skillNames = DEFAULT_SDK_SKILL_NA
   return [npxInstall];
 }
 function runOneSkillsInstall(install) {
-  return new Promise((resolve13) => {
-    const child = spawn2(install.command, install.args, {
+  return new Promise((resolve14) => {
+    const child = spawn3(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
     });
@@ -23206,7 +24114,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
@@ -23214,11 +24122,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
@@ -23375,11 +24283,11 @@ function sidecarStateDir(input2) {
   if (!scope || scope.includes("/") || scope.includes("\\")) {
     return null;
   }
-  return join13(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
+  return join14(input2.homeDir, ".local", "deepline", scope, "sdk-cli");
 }
 function readOptionalText(path) {
   try {
-    return readFileSync11(path, "utf8").trim();
+    return readFileSync12(path, "utf8").trim();
   } catch {
     return "";
   }
@@ -23388,25 +24296,25 @@ function resolvePythonSidecarUpdatePlan(options) {
   const stateDir = sidecarStateDir(options);
   if (!stateDir) return null;
   const relativeEntrypoint = relative2(
-    resolve12(stateDir),
-    resolve12(options.entrypoint)
+    resolve13(stateDir),
+    resolve13(options.entrypoint)
   );
   if (!relativeEntrypoint || relativeEntrypoint.startsWith("..") || isAbsolute2(relativeEntrypoint)) {
     return null;
   }
-  const installMethod = readOptionalText(join13(stateDir, ".install-method"));
+  const installMethod = readOptionalText(join14(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(join13(stateDir, ".node-bin")) || process.execPath;
-  const sidecarPath = readOptionalText(join13(stateDir, ".command-path")) || join13(
+  const nodeBin = readOptionalText(join14(stateDir, ".node-bin")) || process.execPath;
+  const sidecarPath = readOptionalText(join14(stateDir, ".command-path")) || join14(
     stateDir,
     "bin",
     process.platform === "win32" ? "deepline-sdk.cmd" : "deepline-sdk"
   );
   const packageSpec = options.packageSpec || "deepline@latest";
   const npmCommand = "npm";
-  const versionDir = join13(stateDir, "versions", "<version>");
+  const versionDir = join14(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",
@@ -23421,9 +24329,9 @@ function resolvePythonSidecarUpdatePlan(options) {
   };
 }
 function findRepoBackedSdkRoot(startPath) {
-  let current = resolve12(startPath);
+  let current = resolve13(startPath);
   while (true) {
-    if (existsSync11(join13(current, "sdk", "package.json")) && existsSync11(join13(current, "sdk", "bin", "deepline-dev.ts"))) {
+    if (existsSync12(join14(current, "sdk", "package.json")) && existsSync12(join14(current, "sdk", "bin", "deepline-dev.ts"))) {
       return current;
     }
     const parent = dirname12(current);
@@ -23436,7 +24344,7 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint) {
     try {
       return realpathSync3(entrypoint);
     } catch {
-      return resolve12(entrypoint);
+      return resolve13(entrypoint);
     }
   })();
   const parts = normalized.split(/[\\/]+/);
@@ -23454,8 +24362,8 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint) {
 }
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir2 = options.homeDir ?? homedir10();
-  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve12(process.argv[1]) : "");
+  const homeDir2 = options.homeDir ?? homedir11();
+  const entrypoint = options.entrypoint ?? (process.argv[1] ? resolve13(process.argv[1]) : "");
   const sourceRoot = entrypoint ? findRepoBackedSdkRoot(dirname12(entrypoint)) : null;
   if (sourceRoot) {
     return {
@@ -23494,10 +24402,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 join13(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
+    return join14(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
-  return join13(
-    homedir10(),
+  return join14(
+    homedir11(),
     ".local",
     "deepline",
     "sdk-cli",
@@ -23514,7 +24422,7 @@ function readAutoUpdateFailure(plan) {
   if (!path) return null;
   try {
     const parsed = JSON.parse(
-      readFileSync11(path, "utf8")
+      readFileSync12(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;
@@ -23535,8 +24443,8 @@ function writeAutoUpdateFailure(plan, exitCode) {
     manualCommand: plan.manualCommand
   };
   try {
-    mkdirSync9(dirname12(path), { recursive: true });
-    writeFileSync14(path, `${JSON.stringify(marker, null, 2)}
+    mkdirSync10(dirname12(path), { recursive: true });
+    writeFileSync15(path, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -23581,7 +24489,7 @@ function safeVersionSegment(value) {
   return /^[0-9A-Za-z._-]+$/.test(normalized) ? normalized : "";
 }
 function entryPathInVersionDir(versionDir) {
-  return join13(
+  return join14(
     versionDir,
     "node_modules",
     "deepline",
@@ -23591,14 +24499,14 @@ function entryPathInVersionDir(versionDir) {
   );
 }
 function installedPackageVersion(versionDir) {
-  const packageJsonPath = join13(
+  const packageJsonPath = join14(
     versionDir,
     "node_modules",
     "deepline",
     "package.json"
   );
   try {
-    const parsed = JSON.parse(readFileSync11(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(readFileSync12(packageJsonPath, "utf8"));
     return typeof parsed.version === "string" ? safeVersionSegment(parsed.version) : "";
   } catch {
     return "";
@@ -23606,7 +24514,7 @@ function installedPackageVersion(versionDir) {
 }
 function runCommand(command, args, env = process.env, options = {}) {
   return new Promise((resolveExitCode) => {
-    const child = spawn3(command, args, {
+    const child = spawn4(command, args, {
       stdio: options.stdio === "stderr" ? ["inherit", "pipe", "pipe"] : "inherit",
       shell: process.platform === "win32",
       env
@@ -23630,9 +24538,9 @@ function runCommand(command, args, env = process.env, options = {}) {
   });
 }
 function writeSidecarLauncher(input2) {
-  mkdirSync9(dirname12(input2.path), { recursive: true });
+  mkdirSync10(dirname12(input2.path), { recursive: true });
   if (process.platform === "win32") {
-    writeFileSync14(
+    writeFileSync15(
       input2.path,
       [
         `@set DEEPLINE_HOST_URL=${input2.hostUrl.replace(/\r?\n/g, "")}`,
@@ -23644,7 +24552,7 @@ function writeSidecarLauncher(input2) {
     );
     return;
   }
-  writeFileSync14(
+  writeFileSync15(
     input2.path,
     [
       "#!/usr/bin/env sh",
@@ -23657,14 +24565,14 @@ function writeSidecarLauncher(input2) {
   );
 }
 async function runPythonSidecarUpdatePlan(plan, options = {}) {
-  const versionsDir = join13(plan.stateDir, "versions");
-  const tempDir = join13(
+  const versionsDir = join14(plan.stateDir, "versions");
+  const tempDir = join14(
     versionsDir,
     `.tmp-sdk-update-${process.pid}-${Date.now()}`
   );
-  rmSync3(tempDir, { recursive: true, force: true });
-  mkdirSync9(tempDir, { recursive: true });
-  writeFileSync14(join13(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
+  rmSync4(tempDir, { recursive: true, force: true });
+  mkdirSync10(tempDir, { recursive: true });
+  writeFileSync15(join14(tempDir, "package.json"), NPM_SDK_SIDECAR_PACKAGE_JSON);
   const env = {
     ...process.env,
     PATH: `${dirname12(plan.nodeBin)}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`
@@ -23682,7 +24590,7 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
     options
   );
   if (installExitCode !== 0) {
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return installExitCode;
   }
   const installedVersion = installedPackageVersion(tempDir);
@@ -23690,19 +24598,19 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
     process.stderr.write(
       "Updated Deepline SDK package did not report a version.\n"
     );
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
     return 1;
   }
-  const finalDir = join13(versionsDir, installedVersion);
+  const finalDir = join14(versionsDir, installedVersion);
   const finalEntryPath = entryPathInVersionDir(finalDir);
-  if (existsSync11(finalEntryPath)) {
-    rmSync3(tempDir, { recursive: true, force: true });
+  if (existsSync12(finalEntryPath)) {
+    rmSync4(tempDir, { recursive: true, force: true });
   } else {
-    rmSync3(finalDir, { recursive: true, force: true });
+    rmSync4(finalDir, { recursive: true, force: true });
     try {
       renameSync(tempDir, finalDir);
     } catch (error) {
-      rmSync3(tempDir, { recursive: true, force: true });
+      rmSync4(tempDir, { recursive: true, force: true });
       process.stderr.write(
         `Failed to publish Deepline SDK sidecar update: ${error.message}
 `
@@ -23710,7 +24618,7 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
       return 1;
     }
   }
-  if (!existsSync11(finalEntryPath)) {
+  if (!existsSync12(finalEntryPath)) {
     process.stderr.write(
       `Updated Deepline SDK CLI entrypoint missing: ${finalEntryPath}
 `
@@ -23724,28 +24632,28 @@ async function runPythonSidecarUpdatePlan(plan, options = {}) {
     nodeBin: plan.nodeBin,
     entryPath: finalEntryPath
   });
-  writeFileSync14(
-    join13(plan.stateDir, ".version"),
+  writeFileSync15(
+    join14(plan.stateDir, ".version"),
     `${installedVersion}
 `,
     "utf8"
   );
-  writeFileSync14(
-    join13(plan.stateDir, ".install-method"),
+  writeFileSync15(
+    join14(plan.stateDir, ".install-method"),
     "python-sidecar\n",
     "utf8"
   );
-  writeFileSync14(
-    join13(plan.stateDir, ".command-path"),
+  writeFileSync15(
+    join14(plan.stateDir, ".command-path"),
     `${plan.sidecarPath}
 `,
     "utf8"
   );
-  writeFileSync14(join13(plan.stateDir, ".runner"), "node\n", "utf8");
-  writeFileSync14(join13(plan.stateDir, ".node-bin"), `${plan.nodeBin}
+  writeFileSync15(join14(plan.stateDir, ".runner"), "node\n", "utf8");
+  writeFileSync15(join14(plan.stateDir, ".node-bin"), `${plan.nodeBin}
 `, "utf8");
-  writeFileSync14(
-    join13(plan.stateDir, ".entry-path"),
+  writeFileSync15(
+    join14(plan.stateDir, ".entry-path"),
     `${finalEntryPath}
 `,
     "utf8"
@@ -23934,7 +24842,7 @@ function unknownCommandNameFromMessage(message) {
 }
 
 // src/cli/self-update.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 function envTruthy(name) {
   const value = process.env[name]?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes";
@@ -23980,10 +24888,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 = spawn4(command, args, {
+    const child = spawn5(command, args, {
       stdio: "inherit",
       shell: process.platform === "win32",
       env: {
@@ -23996,9 +24904,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) {
@@ -24348,8 +25256,8 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await mkdtemp2(join14(tmpdir4(), "deepline-health-play-"));
-  const file = join14(dir, "health-check.play.ts");
+  const dir = await mkdtemp2(join15(tmpdir4(), "deepline-health-play-"));
+  const file = join15(dir, "health-check.play.ts");
   try {
     await writeFile5(
       file,