deepline 0.1.238 → 0.1.240

package/dist/cli/index.js

@@ -627,10 +627,10 @@ var SDK_RELEASE = {
   // silently materializing them as unmatched results.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.238",
+  version: "0.1.240",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.238",
+    latest: "0.1.240",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -892,6 +892,7 @@ var HttpClient = class {
       "X-Deepline-CLI-Version": SDK_VERSION,
       "X-Deepline-SDK-Version": SDK_VERSION,
       "X-Deepline-API-Contract": SDK_API_CONTRACT,
+      "X-Deepline-Run-Result-Shape": "canonical",
       ...extra
     };
     const skillsVersion = this.readSkillsVersionHeader();
@@ -1370,7 +1371,7 @@ function normalizePlayRunLedgerTerminalSource(value) {
 var SECRET_REDACTION_PLACEHOLDER = "[REDACTED_SECRET]";
 var BEARER_TOKEN_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/g;
 var BASIC_CREDENTIAL_RE = /\bBasic\s+[A-Za-z0-9+/]{4,}={0,2}\b/g;
-var JWT_RE = /\b[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{1,}\.[A-Za-z0-9_-]{8,}\b/g;
+var JWT_RE = /\b[A-Za-z0-9_-]{8,16384}\.[A-Za-z0-9_-]{1,16384}\.[A-Za-z0-9_-]{8,16384}\b/g;
 var PRIVATE_KEY_RE = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g;
 var SENSITIVE_FIELD_NAME = "authorization|cookie|password|(?:client[_-]?)?secret|(?:access|refresh)[_-]?token|(?:x[_-]?)?api[_-]?key|private[_-]?key|token|credentials";
 var COMMON_SECRET_RE = /\b(?:[prs]k_(?:live|test)_|(?:pat|ghp|github_pat)_|xox[baprs]-)[A-Za-z0-9_./+=:-]{12,}\b/gi;
@@ -2705,6 +2706,8 @@ var DeeplineClient = class {
   config;
   /** Canonical run lifecycle namespace backed by `/api/v2/runs`. */
   runs;
+  /** Current mutable customer database namespace backed by `/api/v2/db/query`. */
+  db;
   /** Billing namespace: subscription status/cancel and invoice history. */
   billing;
   /**
@@ -2728,6 +2731,9 @@ var DeeplineClient = class {
       stop: (runId, options2) => this.stopRun(runId, options2),
       stopAll: (options2) => this.stopAllRuns(options2)
     };
+    this.db = {
+      query: (input2) => this.queryDb(input2)
+    };
     this.billing = {
       topUp: (options2) => this.topUpBillingBalance(options2),
       plans: () => this.getBillingPlans(),
@@ -2994,17 +3000,29 @@ var DeeplineClient = class {
   async executeToolRaw(toolId, input2, options) {
     return this.executeTool(toolId, input2, options);
   }
+  async queryDb(input2) {
+    const result = await this.http.post(
+      "/api/v2/db/query",
+      {
+        sql: input2.sql,
+        ...input2.maxRows ? { max_rows: input2.maxRows } : {}
+      }
+    );
+    return {
+      ...result,
+      scope: { kind: "database", mutability: "current" }
+    };
+  }
   /**
-   * Run a bounded SQL query against the customer data plane.
+   * Run a bounded SQL query against the current mutable customer database.
    *
-   * Use this from trusted backend or agent contexts only. The API enforces
-   * workspace scoping and row limits.
+   * This query is not scoped to one play run. Use `client.runs` export actions
+   * when the caller needs the rows produced by a specific run.
+   *
+   * @deprecated Use {@link DeeplineClient.db} `.query(...)`.
    */
   async queryCustomerDb(input2) {
-    return this.http.post("/api/v2/db/query", {
-      sql: input2.sql,
-      ...input2.maxRows ? { max_rows: input2.maxRows } : {}
-    });
+    return this.db.query(input2);
   }
   /**
    * Re-establish this workspace's tenant storage contract: role/DB connect
@@ -4135,9 +4153,35 @@ var DeeplineClient = class {
     if (input2.rowMode === "all") {
       params.set("rowMode", "all");
     }
-    return await this.http.get(
+    const result = await this.http.get(
       `/api/v2/plays/${encodeURIComponent(input2.playName)}/sheet?${params.toString()}`
     );
+    const requestedRunId = input2.runId?.trim() || "";
+    if (requestedRunId) {
+      const confirmedRunId = result.scope?.kind === "run" ? result.scope.runId.trim() : "";
+      const foreignRowRunIds = [
+        ...new Set(
+          result.rows.map(
+            (row) => typeof row.runId === "string" ? row.runId.trim() : ""
+          ).filter((runId) => runId && runId !== requestedRunId)
+        )
+      ];
+      if (result.scope?.kind !== "run" || confirmedRunId !== requestedRunId || foreignRowRunIds.length > 0) {
+        throw new DeeplineError(
+          `Run-scoped dataset export was not confirmed for ${requestedRunId}; no rows were returned to the caller. Update Deepline, then retry the same export command. Do not rerun the play.`,
+          void 0,
+          "RUN_EXPORT_SCOPE_MISMATCH",
+          {
+            requestedRunId,
+            confirmedScope: result.scope ?? null,
+            foreignRowRunIds,
+            playName: input2.playName,
+            tableNamespace: input2.tableNamespace
+          }
+        );
+      }
+    }
+    return result;
   }
   /**
    * Stop a run by id using the public runs resource model.
@@ -7386,6 +7430,33 @@ function formatDatasetExecutionStats(raw, _persistedRowTotal) {
 }
 
 // src/cli/dataset-stats.ts
+function mergeCanonicalRowsInfo(left, right) {
+  const preferred = right.rows.length > left.rows.length || right.complete && !left.complete && right.rows.length === left.rows.length ? right : left;
+  const fallback = preferred === left ? right : left;
+  const totalRows = Math.max(left.totalRows, right.totalRows);
+  const exportUnavailableReason = left.exportUnavailableReason === "shared_table_namespace" || right.exportUnavailableReason === "shared_table_namespace" ? "shared_table_namespace" : left.exportUnavailableReason ?? right.exportUnavailableReason;
+  const unavailableSource = left.exportUnavailableReason === exportUnavailableReason ? left : right.exportUnavailableReason === exportUnavailableReason ? right : null;
+  const columns = preferred.columns.length > 0 ? preferred.columns : fallback.columns;
+  return {
+    ...fallback,
+    ...preferred,
+    rows: preferred.rows,
+    totalRows,
+    columns,
+    columnsExplicit: columns === preferred.columns ? preferred.columnsExplicit : fallback.columnsExplicit,
+    complete: preferred.rows.length === totalRows,
+    source: preferred.source ?? fallback.source,
+    datasetId: preferred.datasetId ?? fallback.datasetId,
+    tableNamespace: preferred.tableNamespace ?? fallback.tableNamespace,
+    ...left.recovered || right.recovered ? { recovered: true } : {},
+    ...exportUnavailableReason ? {
+      exportUnavailableReason,
+      ...unavailableSource?.exportUnavailableMessage ? {
+        exportUnavailableMessage: unavailableSource.exportUnavailableMessage
+      } : {}
+    } : {}
+  };
+}
 var CSV_PROJECTED_FIELDS_KEY = "__deeplineCsvProjectedFields";
 function csvProjectedFields(row) {
   const serialized = row[CSV_PROJECTED_FIELDS_KEY];
@@ -7533,7 +7604,13 @@ function canonicalRowsInfoFromCandidate(input2) {
       source: candidate.source,
       datasetId: typeof candidate.value.datasetId === "string" ? candidate.value.datasetId : null,
       tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null,
-      ...candidate.value.recovered === true ? { recovered: true } : {}
+      ...candidate.value.recovered === true ? { recovered: true } : {},
+      ...isRecord4(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace") ? {
+        exportUnavailableReason: candidate.value.exportUnavailable.reason,
+        ...typeof candidate.value.exportUnavailable.message === "string" ? {
+          exportUnavailableMessage: candidate.value.exportUnavailable.message
+        } : {}
+      } : {}
     };
   }
   if (candidate.serializedOnly) {
@@ -7708,6 +7785,23 @@ function collectPackagedDatasetCandidates(statusOrResult) {
   }
   return candidates;
 }
+function collectPackagedStepDatasetCandidates(statusOrResult) {
+  const root = isRecord4(statusOrResult) ? statusOrResult : null;
+  if (!root) return [];
+  const pkg = isRecord4(root.package) ? root.package : root;
+  const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
+  return steps.flatMap((step) => {
+    if (!isRecord4(step) || !isPackagedDatasetOutput(step.output)) return [];
+    const source = typeof step.output.path === "string" && step.output.path.trim() ? step.output.path.trim() : null;
+    return source ? [
+      {
+        source,
+        value: step.output,
+        total: step.output.rowCount ?? step.output.preview?.totalRows ?? void 0
+      }
+    ] : [];
+  });
+}
 function collectSerializedDatasetRowsInfos(statusOrResult) {
   const root = isRecord4(statusOrResult) ? statusOrResult : null;
   const result = isRecord4(root?.result) ? root.result : root;
@@ -7726,8 +7820,9 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       });
     }
   }
+  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
   candidates.push(...collectPackagedDatasetCandidates(statusOrResult));
-  const seen = /* @__PURE__ */ new Set();
+  const sourceIndexes = /* @__PURE__ */ new Map();
   const infos = [];
   for (const candidate of candidates) {
     const info = canonicalRowsInfoFromCandidate({
@@ -7736,10 +7831,15 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
     });
     if (info) {
       if (info.source) {
-        if (seen.has(info.source)) {
+        const existingIndex = sourceIndexes.get(info.source);
+        if (existingIndex !== void 0) {
+          infos[existingIndex] = mergeCanonicalRowsInfo(
+            infos[existingIndex],
+            info
+          );
           continue;
         }
-        seen.add(info.source);
+        sourceIndexes.set(info.source, infos.length);
       }
       infos.push(info);
     }
@@ -8581,7 +8681,7 @@ async function handleDbQuery(args) {
   const client2 = new DeeplineClient();
   let result;
   try {
-    result = await client2.queryCustomerDb({ sql, maxRows });
+    result = await client2.db.query({ sql, maxRows });
   } catch (error) {
     console.error(formatDbQueryError(sql, error));
     return 1;
@@ -8793,7 +8893,13 @@ Examples:
   deepline db repair
   deepline db repair --json
 `
-  ).option("--provider <provider>", "Limit materialized-table repair to one provider").option("--json", "Emit raw JSON response. Also automatic when stdout is piped").action(async (options) => {
+  ).option(
+    "--provider <provider>",
+    "Limit materialized-table repair to one provider"
+  ).option(
+    "--json",
+    "Emit raw JSON response. Also automatic when stdout is piped"
+  ).action(async (options) => {
     process.exitCode = await handleDbRepair([
       ...options.provider ? ["--provider", options.provider] : [],
       ...options.json ? ["--json"] : []
@@ -13731,9 +13837,15 @@ function actionToCommand(action) {
     return null;
   }
   const record = action;
+  if (typeof record.command === "string" && record.command.trim()) {
+    return record.command.trim();
+  }
   if (record.kind === "deepline_run_inspect" && typeof record.runId === "string") {
     return `deepline runs get ${record.runId} --json`;
   }
+  if (record.kind === "deepline_run_full" && typeof record.runId === "string") {
+    return `deepline runs get ${record.runId} --full --json`;
+  }
   if (record.kind === "deepline_run_billing" && typeof record.runId === "string") {
     return `deepline runs get ${record.runId} --full --json | jq '.billing'`;
   }
@@ -13756,19 +13868,70 @@ function actionToCommand(action) {
   }
   return null;
 }
-function readFirstDatasetActions(packaged) {
-  for (const dataset of readRecordArray(packaged.datasets)) {
-    const actions = readRecord(dataset.actions);
-    if (actions) return actions;
+function packageDatasetRecords(packaged) {
+  const catalog = readRecordArray(packaged.datasets);
+  if (catalog.length > 0) return catalog;
+  return readRecordArray(packaged.steps).flatMap((step) => {
+    const output2 = readRecord(step.output);
+    return output2?.kind === "dataset" ? [output2] : [];
+  });
+}
+function packageReturnedDatasetIdentity(packaged) {
+  const datasetIds = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  const outputs = readRecord(packaged.outputs) ?? {};
+  for (const outputValue of Object.values(outputs)) {
+    const output2 = readRecord(outputValue);
+    if (output2?.kind !== "dataset") continue;
+    if (typeof output2.datasetId === "string" && output2.datasetId.trim()) {
+      datasetIds.add(output2.datasetId.trim());
+    }
+    for (const candidate of [output2.dataset, output2.path]) {
+      if (typeof candidate === "string" && candidate.trim()) {
+        paths.add(candidate.trim());
+      }
+    }
   }
-  for (const step of readRecordArray(packaged.steps)) {
-    const output2 = step.output && typeof step.output === "object" && !Array.isArray(step.output) ? step.output : null;
-    const actions = output2?.actions && typeof output2.actions === "object" && !Array.isArray(output2.actions) ? output2.actions : null;
-    if (actions) {
-      return actions;
+  return { datasetIds, paths };
+}
+function formatPackageDatasetActionLines(packaged) {
+  const returned = packageReturnedDatasetIdentity(packaged);
+  const lines = [];
+  for (const dataset of packageDatasetRecords(packaged)) {
+    const path = typeof dataset.path === "string" && dataset.path.trim() ? dataset.path.trim() : "dataset";
+    const datasetId = typeof dataset.datasetId === "string" ? dataset.datasetId.trim() : "";
+    const isReturned = datasetId && returned.datasetIds.has(datasetId) || returned.paths.has(path);
+    const category = isReturned ? "returned" : dataset.recovered === true ? "recovered" : "persisted";
+    const rowCount = typeof dataset.rowCount === "number" && Number.isFinite(dataset.rowCount) ? Math.max(0, Math.trunc(dataset.rowCount)) : null;
+    const actions = readRecord(dataset.actions) ?? {};
+    if (category === "recovered" && Object.keys(actions).length === 0) {
+      lines.push(
+        `  dataset ${path}: available, ${rowCount === null ? "persisted" : formatInteger(rowCount)} rows persisted; re-running reuses completed work`
+      );
+    } else {
+      lines.push(
+        `  ${category} dataset ${path}: ${rowCount === null ? "unknown rows" : `${formatInteger(rowCount)} ${rowCount === 1 ? "row" : "rows"}`}`
+      );
+    }
+    const exportCommand = actionToCommand(actions.exportCsv);
+    const currentQueryCommand = actionToCommand(actions.queryCurrentTable);
+    const legacyQueryCommand = actionToCommand(actions.query);
+    if (exportCommand) {
+      lines.push(`    export this run: ${exportCommand}`);
+    }
+    if (currentQueryCommand) {
+      lines.push(`    query current table: ${currentQueryCommand}`);
+    } else if (legacyQueryCommand) {
+      lines.push(`    query run rows (legacy): ${legacyQueryCommand}`);
+    }
+    const unavailable = readRecord(dataset.exportUnavailable);
+    if (typeof unavailable?.reason === "string" && typeof unavailable.message === "string") {
+      lines.push(
+        `    export unavailable (${unavailable.reason}): ${unavailable.message}`
+      );
     }
   }
-  return {};
+  return lines;
 }
 function formatInlinePackageValue(value) {
   const compacted = compactReturnValue(value);
@@ -13844,18 +14007,11 @@ function buildRunPackageTextLines(packaged) {
       failedLogAssociation === "retained_before_truncation" ? `  retained logs: ${failedLogNext.logs}` : `  retry failed logs: ${failedLogNext.logs}`
     );
   }
-  for (const output2 of readRecordArray(packaged.datasets)) {
-    if (output2.recovered !== true) continue;
-    const rowCount = typeof output2.rowCount === "number" ? formatInteger(output2.rowCount) : "persisted";
-    const datasetPath = typeof output2.path === "string" ? output2.path : "dataset";
-    lines.push(
-      `  dataset ${datasetPath}: available, ${rowCount} rows persisted; re-running reuses completed work`
-    );
-  }
   if (playName) {
     lines.push(`  play: ${playName}`);
   }
   lines.push(...formatPackageValueOutputLines(packaged));
+  lines.push(...formatPackageDatasetActionLines(packaged));
   const next = packaged.next && typeof packaged.next === "object" && !Array.isArray(packaged.next) ? packaged.next : {};
   const billingCommand = actionToCommand(next.billing);
   const logsCommand = actionToCommand(next.logs);
@@ -13879,16 +14035,20 @@ function buildRunPackageTextLines(packaged) {
       );
     }
   }
-  const datasetActions = readFirstDatasetActions(packaged);
   const inspectCommand = actionToCommand(next.inspect);
-  const queryCommand = actionToCommand(next.query) ?? actionToCommand(datasetActions.query);
-  const exportCommand = actionToCommand(next.export) ?? actionToCommand(datasetActions.exportCsv);
+  const fullResultCommand = actionToCommand(next.full);
+  const hasCatalogExportAction = packageDatasetRecords(packaged).some(
+    (dataset) => Boolean(actionToCommand(readRecord(dataset.actions)?.exportCsv))
+  );
+  const legacyExportCommand = hasCatalogExportAction ? null : actionToCommand(next.export);
   const runAgainCommand = typeof next.run === "string" && next.run.trim() ? next.run.trim() : null;
   if (inspectCommand) lines.push(`  inspect: ${inspectCommand}`);
+  if (fullResultCommand) lines.push(`  full result: ${fullResultCommand}`);
   if (logsCommand) lines.push(`  logs: ${logsCommand}`);
   if (billingCommand) lines.push(`  billing: ${billingCommand}`);
-  if (queryCommand) lines.push(`  query: ${queryCommand}`);
-  if (exportCommand) lines.push(`  export CSV: ${exportCommand}`);
+  if (legacyExportCommand) {
+    lines.push(`  export CSV: ${legacyExportCommand}`);
+  }
   if (runAgainCommand) {
     lines.push("  run again (completed work is reused):");
     lines.push(`    ${runAgainCommand}`);
@@ -14188,6 +14348,102 @@ function resolveDatasetByName(available, datasetPath) {
   }
   return null;
 }
+function canonicalRowsIdentity(info) {
+  return info.datasetId?.trim() ? `id:${info.datasetId.trim()}` : `path:${info.source ?? info.tableNamespace ?? "dataset"}`;
+}
+function distinctCanonicalRowsInfos(infos) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const info of infos) {
+    const identity = canonicalRowsIdentity(info);
+    const existing = byIdentity.get(identity);
+    byIdentity.set(
+      identity,
+      existing ? mergeCanonicalRowsInfo(existing, info) : info
+    );
+  }
+  return [...byIdentity.values()];
+}
+function packageForExportSelection(status) {
+  const root = status;
+  const nested = readRecord(root.package);
+  if (nested?.kind === "play_run") return nested;
+  return root.kind === "play_run" ? root : null;
+}
+function withReturnedDatasetAliases(status, available) {
+  const packaged = packageForExportSelection(status);
+  const outputs = readRecord(packaged?.outputs);
+  if (!outputs) return available;
+  const expanded = [...available];
+  for (const outputValue of Object.values(outputs)) {
+    const output2 = readRecord(outputValue);
+    if (output2?.kind !== "dataset") continue;
+    const alias = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
+    if (!alias) continue;
+    const datasetId = typeof output2.datasetId === "string" && output2.datasetId.trim() ? output2.datasetId.trim() : null;
+    const canonicalPath2 = typeof output2.dataset === "string" && output2.dataset.trim() ? output2.dataset.trim() : null;
+    const canonical = available.find(
+      (info) => datasetId && info.datasetId === datasetId || canonicalPath2 && info.source === canonicalPath2
+    );
+    if (canonical) {
+      const aliasIndex = expanded.findIndex((info) => info.source === alias);
+      if (aliasIndex >= 0) {
+        expanded[aliasIndex] = {
+          ...mergeCanonicalRowsInfo(expanded[aliasIndex], canonical),
+          source: alias
+        };
+      } else {
+        expanded.push({ ...canonical, source: alias });
+      }
+    }
+  }
+  return expanded;
+}
+function returnedRowsInfos(status, available) {
+  const packaged = packageForExportSelection(status);
+  const outputs = readRecord(packaged?.outputs);
+  if (outputs) {
+    const selected = /* @__PURE__ */ new Map();
+    for (const outputValue of Object.values(outputs)) {
+      const output2 = readRecord(outputValue);
+      if (output2?.kind !== "dataset") continue;
+      const datasetId = typeof output2.datasetId === "string" && output2.datasetId.trim() ? output2.datasetId.trim() : null;
+      const alias = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
+      const canonicalPath2 = typeof output2.dataset === "string" && output2.dataset.trim() ? output2.dataset.trim() : null;
+      const info = (alias ? available.find((candidate) => candidate.source === alias) : null) ?? (datasetId ? available.find((candidate) => candidate.datasetId === datasetId) : null) ?? (canonicalPath2 ? available.find((candidate) => candidate.source === canonicalPath2) : null);
+      if (!info) continue;
+      const identity = datasetId ? `id:${datasetId}` : `path:${canonicalPath2 ?? alias ?? info.source ?? "dataset"}`;
+      const aliased = { ...info, source: alias ?? info.source };
+      const existing = selected.get(identity);
+      selected.set(
+        identity,
+        existing ? mergeCanonicalRowsInfo(existing, aliased) : aliased
+      );
+    }
+    if (selected.size > 0) return [...selected.values()];
+  }
+  return distinctCanonicalRowsInfos(
+    available.filter(
+      (info) => Boolean(info.source?.startsWith("result.")) && !info.recovered
+    )
+  );
+}
+function exportDatasetCommand(input2) {
+  return `deepline runs export ${input2.runId} --dataset ${shellSingleQuote(
+    input2.datasetPath
+  )} --out ${shellSingleQuote((0, import_node_path11.resolve)(input2.outPath))}`;
+}
+function datasetChoiceLines(input2) {
+  return input2.datasets.flatMap((dataset) => {
+    const path = dataset.source ?? dataset.datasetId ?? dataset.tableNamespace;
+    return path ? [
+      exportDatasetCommand({
+        runId: input2.runId,
+        datasetPath: path,
+        outPath: input2.outPath
+      })
+    ] : [];
+  });
+}
 function assertDatasetHasExportableRows(input2) {
   if (input2.rowsInfo.rows.length > 0) {
     return input2.rowsInfo;
@@ -14208,28 +14464,93 @@ function assertDatasetHasExportableRows(input2) {
     }
   );
 }
+function assertDatasetExportAvailable(input2) {
+  if (input2.rowsInfo.exportUnavailableReason !== "shared_table_namespace") {
+    return;
+  }
+  throw new DeeplineError(
+    input2.rowsInfo.exportUnavailableMessage ?? "Run CSV export is unavailable because multiple Dataset Handles share one physical table.",
+    void 0,
+    "RUN_EXPORT_UNAVAILABLE",
+    {
+      runId: input2.status.runId,
+      dataset: input2.rowsInfo.source,
+      datasetId: input2.rowsInfo.datasetId ?? null,
+      tableNamespace: input2.rowsInfo.tableNamespace ?? null,
+      reason: input2.rowsInfo.exportUnavailableReason
+    }
+  );
+}
 async function exportPlayStatusRows(client2, status, outPath, options = {}) {
   if (!outPath) {
     return null;
   }
-  const availableRows = collectSerializedDatasetRowsInfos(status);
-  const rowsInfo = options.datasetPath ? resolveDatasetByName(availableRows, options.datasetPath) ?? null : availableRows.length === 1 ? availableRows[0] : null;
+  const availableRows = withReturnedDatasetAliases(
+    status,
+    distinctCanonicalRowsInfos(collectSerializedDatasetRowsInfos(status))
+  );
+  const returnedRows = returnedRowsInfos(status, availableRows);
+  const recoveredRows = distinctCanonicalRowsInfos(
+    availableRows.filter((info) => info.recovered)
+  );
+  const rowsInfo = options.datasetPath ? resolveDatasetByName(availableRows, options.datasetPath) ?? null : returnedRows.length === 1 ? returnedRows[0] : returnedRows.length === 0 && recoveredRows.length === 1 ? recoveredRows[0] : null;
   if (!rowsInfo && options.datasetPath) {
     const available = availableRows.map((info) => info.source).filter((source) => typeof source === "string");
+    const commands = datasetChoiceLines({
+      runId: status.runId,
+      datasets: availableRows,
+      outPath
+    });
     throw new DeeplineError(
-      `Run ${status.runId} did not return a dataset at ${options.datasetPath}.` + (available.length > 0 ? ` Available datasets: ${available.join(", ")}.` : ""),
+      `Run ${status.runId} did not return a dataset at ${options.datasetPath}.` + (available.length > 0 ? ` Available datasets: ${available.join(", ")}.
+${commands.join("\n")}` : ""),
       void 0,
       "RUN_EXPORT_DATASET_NOT_FOUND",
       { runId: status.runId, dataset: options.datasetPath, available }
     );
   }
-  if (!options.datasetPath && availableRows.length > 1) {
-    const available = availableRows.map((info) => info.source).filter((source) => typeof source === "string");
+  if (!options.datasetPath && returnedRows.length > 1) {
+    const available = returnedRows.map((info) => info.source).filter((source) => typeof source === "string");
+    const commands = datasetChoiceLines({
+      runId: status.runId,
+      datasets: returnedRows,
+      outPath
+    });
     throw new DeeplineError(
-      `Run ${status.runId} returned multiple datasets. Choose one with --dataset <path>: ${available.join(", ")}.`,
+      `Run ${status.runId} returned multiple datasets. Choose one:
+${commands.join("\n")}`,
       void 0,
       "RUN_EXPORT_DATASET_REQUIRED",
-      { runId: status.runId, available }
+      {
+        runId: status.runId,
+        available,
+        datasets: returnedRows.map((info, index) => ({
+          path: info.source,
+          rowCount: info.totalRows,
+          command: commands[index]
+        }))
+      }
+    );
+  }
+  if (!options.datasetPath && returnedRows.length === 0 && recoveredRows.length > 1) {
+    const commands = datasetChoiceLines({
+      runId: status.runId,
+      datasets: recoveredRows,
+      outPath
+    });
+    throw new DeeplineError(
+      `Run ${status.runId} has multiple recovered datasets. Choose one:
+${commands.join("\n")}`,
+      void 0,
+      "RUN_EXPORT_DATASET_REQUIRED",
+      {
+        runId: status.runId,
+        datasets: recoveredRows.map((info, index) => ({
+          path: info.source,
+          rowCount: info.totalRows,
+          command: commands[index]
+        }))
+      }
     );
   }
   if (!rowsInfo) {
@@ -14237,6 +14558,7 @@ async function exportPlayStatusRows(client2, status, outPath, options = {}) {
       `Run ${status.runId} did not expose a row-shaped final output to export.`
     );
   }
+  assertDatasetExportAvailable({ rowsInfo, status });
   const attempts = Math.max(1, Math.trunc(options.attempts ?? 1));
   const retryDelayMs = Math.max(0, Math.trunc(options.retryDelayMs ?? 0));
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
@@ -14248,6 +14570,9 @@ async function exportPlayStatusRows(client2, status, outPath, options = {}) {
         rowsInfo
       });
     } catch (error) {
+      if (error instanceof DeeplineError && error.code === "RUN_EXPORT_SCOPE_MISMATCH") {
+        throw error;
+      }
       if (!rowsInfo.complete) {
         throw error;
       }
@@ -20109,7 +20434,9 @@ function readFirstEnrichDatasetActions(value) {
     }
     const record = candidate;
     const actions = isRecord7(record.actions) ? record.actions : null;
-    const query = isRecord7(actions?.query) ? actions.query : null;
+    const currentQuery = isRecord7(actions?.queryCurrentTable) ? actions.queryCurrentTable : null;
+    const legacyQuery = isRecord7(actions?.query) ? actions.query : null;
+    const query = currentQuery?.kind === "deepline_db_query" ? currentQuery : legacyQuery?.kind === "deepline_db_query" ? legacyQuery : null;
     if (query?.kind === "deepline_db_query") {
       return {
         dataset: record,
@@ -20335,7 +20662,7 @@ async function collectCustomerDbFailureJobs(input2) {
   for (let attempt = 0; attempt <= retryDelays.length; attempt += 1) {
     try {
       attempts = attempt + 1;
-      result = await input2.client.queryCustomerDb({
+      result = await input2.client.db.query({
         sql,
         maxRows: 1e3
       });