deepline 0.1.210 → 0.1.212

package/dist/cli/index.js

@@ -623,10 +623,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.210",
+  version: "0.1.212",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.210",
+    latest: "0.1.212",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1359,9 +1359,91 @@ function normalizePlayRunLedgerTerminalSource(value) {
   ) ? value : null;
 }
 
+// ../shared_libs/play-runtime/secret-redaction.ts
+var SECRET_REDACTION_PLACEHOLDER = "[REDACTED_SECRET]";
+var BEARER_TOKEN_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/g;
+var JWT_RE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
+var PRIVATE_KEY_RE = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g;
+var COMMON_SECRET_RE = /\b(?:sk|pk|rk|pat|ghp|github_pat|xox[baprs]|key|token|secret|api[_-]?key)[A-Za-z0-9_./+=:-]{12,}\b/gi;
+var URL_SECRET_VALUE_RE = /\b(?:sk|pk|rk|pat|ghp|github_pat|xox)[A-Za-z0-9_./+=:-]{12,}\b/i;
+var HIGH_ENTROPY_ASSIGNMENT_RE = /\b(?:api[_-]?key|token|secret|password|authorization|access[_-]?token|refresh[_-]?token)\b\s*[:=]\s*["']?[^"',\s]{16,}["']?/gi;
+var SENSITIVE_URL_PARAM_RE = /[?#&](?:\w*(?:key|token)|secret|password|authorization|credential|signature|sig)(?:=|$)/i;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function redactSecretLikeString(value) {
+  const trimmed = value.trim();
+  if (/^https?:\/\/\S+$/i.test(trimmed)) {
+    if (/^https?:\/\/[^/?#@]+@/i.test(trimmed) || SENSITIVE_URL_PARAM_RE.test(trimmed)) {
+      return SECRET_REDACTION_PLACEHOLDER;
+    }
+    if (!URL_SECRET_VALUE_RE.test(value)) return value;
+  }
+  return value.replace(PRIVATE_KEY_RE, SECRET_REDACTION_PLACEHOLDER).replace(BEARER_TOKEN_RE, `Bearer ${SECRET_REDACTION_PLACEHOLDER}`).replace(JWT_RE, SECRET_REDACTION_PLACEHOLDER).replace(COMMON_SECRET_RE, SECRET_REDACTION_PLACEHOLDER).replace(HIGH_ENTROPY_ASSIGNMENT_RE, (match) => {
+    const separator = match.includes("=") ? "=" : ":";
+    const [key] = match.split(separator, 1);
+    return `${key.trim()}${separator}${SECRET_REDACTION_PLACEHOLDER}`;
+  });
+}
+function createSecretRedactionContext(initialValues = []) {
+  const exactSecrets = /* @__PURE__ */ new Set();
+  function register(value) {
+    if (value.length >= 4) exactSecrets.add(value);
+  }
+  for (const value of initialValues) register(value);
+  function redactString(value) {
+    let output2 = value;
+    for (const secret of exactSecrets) {
+      output2 = output2.replace(
+        new RegExp(escapeRegExp(secret), "g"),
+        SECRET_REDACTION_PLACEHOLDER
+      );
+      try {
+        const encoded = encodeURIComponent(secret);
+        if (encoded !== secret) {
+          output2 = output2.replace(
+            new RegExp(escapeRegExp(encoded), "g"),
+            SECRET_REDACTION_PLACEHOLDER
+          );
+        }
+      } catch {
+      }
+    }
+    return redactSecretLikeString(output2);
+  }
+  function redact(value) {
+    if (typeof value === "string") return redactString(value);
+    if (Array.isArray(value)) return value.map((entry) => redact(entry));
+    if (isRecord(value)) {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [key, redact(entry)])
+      );
+    }
+    return value;
+  }
+  return {
+    register,
+    redactString,
+    redact
+  };
+}
+
+// ../shared_libs/play-runtime/output-size-limits.ts
+var encoder = typeof TextEncoder === "undefined" ? null : new TextEncoder();
+var CUSTOMER_OUTPUT_VALUE_MAX_BYTES = 1 * 1024 * 1024;
+var CUSTOMER_OUTPUT_TOTAL_MAX_BYTES = 2 * 1024 * 1024;
+var RUNTIME_RECEIPT_OUTPUT_MAX_BYTES = 10 * 1024 * 1024;
+var RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES = 32 * 1024 * 1024;
+
+// ../shared_libs/play-runtime/ledger-safe-payload.ts
+var ledgerIngressRedactor = createSecretRedactionContext();
+
 // ../shared_libs/play-runtime/run-ledger.ts
 var LOG_TAIL_LIMIT = 100;
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber(value) {
@@ -1443,6 +1525,8 @@ function createEmptyPlayRunLedgerSnapshot(input2) {
     durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : null,
     orderedStepIds: [],
     stepsById: {},
+    orderedDatasetIds: [],
+    datasetsById: {},
     logTail: [],
     totalLogCount: 0,
     logsTruncated: false,
@@ -1452,21 +1536,21 @@ function createEmptyPlayRunLedgerSnapshot(input2) {
   };
 }
 function normalizePlayRunLedgerSnapshot(value, fallback) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return createEmptyPlayRunLedgerSnapshot(fallback);
   }
   const orderedStepIds = Array.isArray(value.orderedStepIds) ? value.orderedStepIds.filter(
     (entry) => typeof entry === "string" && Boolean(entry.trim())
   ) : [];
-  const rawSteps = isRecord(value.stepsById) ? value.stepsById : {};
+  const rawSteps = isRecord2(value.stepsById) ? value.stepsById : {};
   const stepsById = {};
   for (const [stepId, rawStep] of Object.entries(rawSteps)) {
-    if (!stepId.trim() || !isRecord(rawStep)) continue;
+    if (!stepId.trim() || !isRecord2(rawStep)) continue;
     const rawStatus = normalizeStepStatus(rawStep.status);
     if (!rawStatus) continue;
     const completedAt = finiteNumber(rawStep.completedAt);
     const status = rawStatus === "running" && completedAt !== null ? "completed" : rawStatus;
-    const rawProgress = isRecord(rawStep.progress) ? rawStep.progress : null;
+    const rawProgress = isRecord2(rawStep.progress) ? rawStep.progress : null;
     stepsById[stepId] = {
       stepId,
       label: optionalString(rawStep.label),
@@ -1481,6 +1565,23 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
       progress: rawProgress ? normalizeStepProgress(rawProgress) : null
     };
   }
+  const rawDatasets = isRecord2(value.datasetsById) ? value.datasetsById : {};
+  const datasetsById = {};
+  for (const [datasetId, rawDataset] of Object.entries(rawDatasets)) {
+    if (!datasetId.trim() || !isRecord2(rawDataset)) continue;
+    const phase = rawDataset.phase === "available" || rawDataset.phase === "failed" ? rawDataset.phase : "registered";
+    datasetsById[datasetId] = {
+      datasetId,
+      path: optionalString(rawDataset.path) ?? `datasets.${datasetId}`,
+      tableNamespace: optionalString(rawDataset.tableNamespace) ?? datasetId,
+      phase,
+      persistedRows: Math.max(0, finiteNumber(rawDataset.persistedRows) ?? 0),
+      succeededRows: Math.max(0, finiteNumber(rawDataset.succeededRows) ?? 0),
+      failedRows: Math.max(0, finiteNumber(rawDataset.failedRows) ?? 0),
+      complete: rawDataset.complete === true,
+      updatedAt: finiteNumber(rawDataset.updatedAt) ?? 0
+    };
+  }
   const createdAt = finiteNumber(value.createdAt) ?? fallback.createdAt ?? null;
   const startedAt = finiteNumber(value.startedAt) ?? fallback.startedAt ?? null;
   const finishedAt = finiteNumber(value.finishedAt) ?? fallback.finishedAt ?? null;
@@ -1500,6 +1601,10 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
     durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : finiteNumber(value.durationMs),
     orderedStepIds: orderedStepIds.filter((stepId) => stepsById[stepId]),
     stepsById,
+    orderedDatasetIds: (Array.isArray(value.orderedDatasetIds) ? value.orderedDatasetIds : Object.keys(datasetsById)).filter(
+      (datasetId) => typeof datasetId === "string" && Boolean(datasetsById[datasetId])
+    ),
+    datasetsById,
     logTail: logTail.slice(-LOG_TAIL_LIMIT),
     // Snapshots persisted before totalLogCount existed only know the retained
     // tail, so the best lower bound for the cumulative count is the tail size.
@@ -1594,18 +1699,18 @@ function normalizePlayRunLiveStatus(value) {
 function isTerminalPlayRunLiveStatus(status) {
   return isTerminalPlayRunLifecycleStatus(status);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function finiteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function extractTerminalRunLogTail(result) {
-  if (!isRecord2(result) || !isRecord2(result._metadata)) {
+  if (!isRecord3(result) || !isRecord3(result._metadata)) {
     return null;
   }
   const runLogTail = result._metadata.runLogTail;
-  if (!isRecord2(runLogTail) || !Array.isArray(runLogTail.tail)) {
+  if (!isRecord3(runLogTail) || !Array.isArray(runLogTail.tail)) {
     return null;
   }
   const logTail = runLogTail.tail.filter(
@@ -1661,6 +1766,9 @@ function buildSnapshotFromLedger(snapshot) {
     ...snapshot.logsTruncated ? { logsTruncated: true } : {},
     activeArtifactTableNamespace: snapshot.activeArtifactTableNamespace ?? null,
     resultTableNamespace: snapshot.resultTableNamespace ?? null,
+    datasets: snapshot.orderedDatasetIds.map((datasetId) => snapshot.datasetsById[datasetId]).filter(
+      (dataset) => Boolean(dataset)
+    ),
     nodeStates,
     activeNodeId: snapshot.activeStepId ?? null,
     ...rowOutcomes ? { rowOutcomes } : {}
@@ -2337,8 +2445,9 @@ function resolveToolExecuteTimeoutMs(toolId) {
   const normalized = toolId.trim().toLowerCase();
   return normalized === "deeplineagent" || normalized === "deeplineagent_deeplineagent" || normalized === "ai_inference" || normalized === "deeplineagent_ai_inference" || normalized === "aiinference" ? DEEPLINEAGENT_EXECUTE_TIMEOUT_MS : void 0;
 }
+var RUNS_FAILED_LOG_LIMIT = 20;
 var RUN_LOGS_PAGE_LIMIT = 1e3;
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isPrebuiltPlayDescription(play) {
@@ -2495,7 +2604,7 @@ function updatePlayLiveStatusState(state, event) {
   }
   const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : isPlayRunPackage(payload) ? payload.run.id : state.runId;
   const status = normalizeLiveStatus(payload.status) ?? (isPlayRunPackage(payload) ? normalizeLiveStatus(payload.run.status) : null) ?? state.status;
-  const progressPayload = isRecord3(payload.progress) ? payload.progress : {};
+  const progressPayload = isRecord4(payload.progress) ? payload.progress : {};
   if (event.type === "play.run.final_status" && state.logs.length === 0 && state.lastLogSeq === 0) {
     const payloadLogs = readStringArray(payload.logs);
     const progressLogs = readStringArray(progressPayload.logs);
@@ -2610,9 +2719,9 @@ var DeeplineClient = class {
     return fields.length > 0 ? { fields } : schema;
   }
   schemaMetadata(schema, key) {
-    if (!isRecord3(schema)) return null;
+    if (!isRecord4(schema)) return null;
     const value = schema[key];
-    return isRecord3(value) ? value : null;
+    return isRecord4(value) ? value : null;
   }
   playRunCommand(play, options) {
     const target = play.reference || play.name;
@@ -2661,7 +2770,7 @@ var DeeplineClient = class {
       aliases,
       inputSchema: options?.compact ? this.compactSchema(play.inputSchema) : play.inputSchema ?? null,
       outputSchema: options?.compact ? this.compactSchema(play.outputSchema) : play.outputSchema ?? null,
-      staticPipeline: isRecord3(play.staticPipeline) ? play.staticPipeline : isRecord3(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord3(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
+      staticPipeline: isRecord4(play.staticPipeline) ? play.staticPipeline : isRecord4(play.currentRevision?.staticPipeline) ? play.currentRevision.staticPipeline : isRecord4(play.liveRevision?.staticPipeline) ? play.liveRevision.staticPipeline : null,
       ...csvInput ? { csvInput } : {},
       ...rowOutputSchema ? { rowOutputSchema } : {},
       runCommand: runCommand2,
@@ -3595,7 +3704,46 @@ var DeeplineClient = class {
     const response = await this.http.get(
       `/api/v2/runs/${encodeURIComponent(runId)}${query}`
     );
-    return normalizePlayStatus(response);
+    const status = normalizePlayStatus(response);
+    if (options?.failedLogs !== true || status.status !== "failed") {
+      return status;
+    }
+    const requestedFailedLogLimit = typeof options.failedLogLimit === "number" && Number.isFinite(options.failedLogLimit) ? Math.max(1, Math.floor(options.failedLogLimit)) : RUNS_FAILED_LOG_LIMIT;
+    let failedLogs;
+    let failedLogsLoaded = true;
+    try {
+      failedLogs = await this.getRunLogs(runId, {
+        failed: true,
+        limit: Math.min(RUNS_FAILED_LOG_LIMIT, requestedFailedLogLimit)
+      });
+    } catch (error) {
+      failedLogsLoaded = false;
+      const retryCommand = `deepline runs get ${runId} --log-failed --json`;
+      const reason = error instanceof Error && error.message.trim() ? ` (${error.message.trim().slice(0, 500)})` : "";
+      failedLogs = {
+        runId,
+        totalCount: 0,
+        returnedCount: 0,
+        firstSequence: null,
+        lastSequence: null,
+        truncated: false,
+        hasMore: false,
+        entries: [],
+        view: "failed",
+        warning: `Failed logs could not be loaded${reason}. The run status and persisted datasets are still available.`,
+        next: { logs: retryCommand }
+      };
+    }
+    return {
+      ...status,
+      failedLogs: {
+        ...failedLogs,
+        view: "failed",
+        ...failedLogsLoaded ? {
+          association: failedLogs.association ?? "terminal_failure_window"
+        } : {}
+      }
+    };
   }
   /**
    * List play runs using the public runs resource model.
@@ -3746,6 +3894,7 @@ var DeeplineClient = class {
       onNotice: options?.onNotice,
       fallback: "none"
     })) {
+      options?.onEvent?.(event);
       const status = updatePlayLiveStatusState(state, event);
       if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
         continue;
@@ -3809,6 +3958,7 @@ var DeeplineClient = class {
           mode: "cli",
           signal: options?.signal
         })) {
+          options?.onEvent?.(event);
           sawEvent = true;
           const status = updatePlayLiveStatusState(state, event);
           if (!status || !TERMINAL_PLAY_STATUSES.has(status.status)) {
@@ -3858,6 +4008,37 @@ var DeeplineClient = class {
    * ```
    */
   async getRunLogs(runId, options) {
+    if (options?.all === true && options.failed === true) {
+      throw new DeeplineError(
+        "runs.logs cannot combine all and failed views.",
+        void 0,
+        "INVALID_RUN_LOG_VIEW"
+      );
+    }
+    if (options?.failed === true) {
+      const requestedLimit = typeof options.limit === "number" && Number.isFinite(options.limit) && options.limit > 0 ? Math.trunc(options.limit) : RUNS_FAILED_LOG_LIMIT;
+      const failedLimit = Math.min(RUNS_FAILED_LOG_LIMIT, requestedLimit);
+      const page = await this.http.get(
+        `/api/v2/runs/${encodeURIComponent(runId)}/logs?view=failed&limit=${failedLimit}`
+      );
+      return {
+        runId: page.runId,
+        totalCount: page.totalLogCount,
+        returnedCount: page.entries.length,
+        firstSequence: page.firstSeq,
+        lastSequence: page.lastSeq,
+        // The failed view is a complete designed window, not a pageable slice.
+        // `truncated` means retention loss here; association/warning explain it.
+        truncated: page.logsTruncated === true,
+        hasMore: false,
+        entries: page.entries.map((entry) => entry.line),
+        view: page.view ?? "failed",
+        association: page.association ?? "terminal_failure_window",
+        ...page.warning ? { warning: page.warning } : {},
+        ...page.next ? { next: page.next } : {},
+        ...page.logsTruncated ? { logsTruncated: true } : {}
+      };
+    }
     const limit = options?.all ? Number.MAX_SAFE_INTEGER : typeof options?.limit === "number" && Number.isFinite(options.limit) && options.limit > 0 ? Math.trunc(options.limit) : 200;
     const fetchPage = (afterSeq2, pageLimit) => this.http.get(
       `/api/v2/runs/${encodeURIComponent(runId)}/logs?afterSeq=${afterSeq2}&limit=${pageLimit}`
@@ -3891,6 +4072,7 @@ var DeeplineClient = class {
       truncated: entries.length < probe.totalLogCount,
       hasMore: lastSequence !== null && lastSequence < lastStoredSeq,
       entries: entries.map((entry) => entry.line),
+      view: options?.all ? "all" : "tail",
       ...probe.logsTruncated ? { logsTruncated: true } : {}
     };
   }
@@ -7174,14 +7356,14 @@ function sanitizeCsvProjectionInfo(input2) {
   const rows = input2.rows.map(stripCsvProjectionFields);
   return { rows, columns };
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSerializedDataset(value) {
-  return isRecord4(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
+  return isRecord5(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
 }
 function isPackagedDatasetOutput(value) {
-  return isRecord4(value) && value.kind === "dataset" && isRecord4(value.preview) && Array.isArray(value.preview.rows);
+  return isRecord5(value) && value.kind === "dataset" && isRecord5(value.preview) && Array.isArray(value.preview.rows);
 }
 function pathParts(path) {
   return path.split(".").map((part) => part.trim()).filter(Boolean);
@@ -7189,7 +7371,7 @@ function pathParts(path) {
 function valueAtPath(root, path) {
   let cursor = root;
   for (const part of pathParts(path)) {
-    if (!isRecord4(cursor)) {
+    if (!isRecord5(cursor)) {
       return void 0;
     }
     cursor = cursor[part];
@@ -7197,17 +7379,17 @@ function valueAtPath(root, path) {
   return cursor;
 }
 function totalRowsForDataset(result, datasetPath) {
-  const metadata = isRecord4(result._metadata) ? result._metadata : null;
+  const metadata = isRecord5(result._metadata) ? result._metadata : null;
   const parentPath = datasetPath.split(".").slice(0, -1).join(".");
   const parent = parentPath ? valueAtPath({ result }, parentPath) : result;
-  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord4(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
+  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord5(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
 }
 function rowArray(value) {
   if (!Array.isArray(value)) {
     return null;
   }
   const rows = value.filter(
-    (row) => isRecord4(row)
+    (row) => isRecord5(row)
   );
   return rows.length === value.length ? rows : null;
 }
@@ -7231,7 +7413,7 @@ function inferColumns(rows) {
   return columns;
 }
 function columnsFromDatasetSummary(summary) {
-  if (!isRecord4(summary) || !isRecord4(summary.columnStats)) {
+  if (!isRecord5(summary) || !isRecord5(summary.columnStats)) {
     return [];
   }
   return Object.keys(summary.columnStats).filter((column) => column);
@@ -7321,7 +7503,7 @@ function collectDatasetCandidates(input2) {
     });
     return;
   }
-  if (!isRecord4(input2.value)) {
+  if (!isRecord5(input2.value)) {
     return;
   }
   for (const [key, child] of Object.entries(input2.value)) {
@@ -7338,12 +7520,12 @@ function collectDatasetCandidates(input2) {
   }
 }
 function collectCanonicalRowsInfos(statusOrResult) {
-  const root = isRecord4(statusOrResult) ? statusOrResult : null;
-  const result = isRecord4(root?.result) ? root.result : root;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const result = isRecord5(root?.result) ? root.result : root;
   if (!result) {
     return [];
   }
-  const metadata = isRecord4(result._metadata) ? result._metadata : null;
+  const metadata = isRecord5(result._metadata) ? result._metadata : null;
   const totalFromMetadata = metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count;
   const candidates = [
     {
@@ -7367,8 +7549,8 @@ function collectCanonicalRowsInfos(statusOrResult) {
       total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count
     }
   ];
-  if (isRecord4(result.output)) {
-    const outputMetadata = isRecord4(result.output._metadata) ? result.output._metadata : null;
+  if (isRecord5(result.output)) {
+    const outputMetadata = isRecord5(result.output._metadata) ? result.output._metadata : null;
     const outputTotalFromMetadata = outputMetadata?.totalRows ?? outputMetadata?.rowCount ?? outputMetadata?.count;
     candidates.push(
       {
@@ -7395,14 +7577,14 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   if (Array.isArray(result.steps)) {
     result.steps.forEach((step, index) => {
-      if (!isRecord4(step) || !isRecord4(step.output)) {
+      if (!isRecord5(step) || !isRecord5(step.output)) {
         return;
       }
       const source = typeof step.output.path === "string" ? step.output.path : typeof step.id === "string" ? `steps.${step.id}.output` : `steps.${index}.output`;
       candidates.push({
         source,
         value: step.output,
-        total: step.output.rowCount ?? (isRecord4(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord4(step.progress) ? step.progress.total : void 0)
+        total: step.output.rowCount ?? (isRecord5(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord5(step.progress) ? step.progress.total : void 0)
       });
     });
   }
@@ -7412,7 +7594,7 @@ function collectCanonicalRowsInfos(statusOrResult) {
     total: totalFromMetadata,
     output: candidates
   });
-  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
+  candidates.push(...collectPackagedDatasetCandidates(statusOrResult));
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
@@ -7429,37 +7611,33 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   return infos;
 }
-function collectPackagedStepDatasetCandidates(statusOrResult) {
-  const root = isRecord4(statusOrResult) ? statusOrResult : null;
+function collectPackagedDatasetCandidates(statusOrResult) {
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
   if (!root) {
     return [];
   }
-  const pkg = isRecord4(root.package) ? root.package : root;
-  const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
+  const pkg = isRecord5(root.package) ? root.package : root;
+  const datasets = Array.isArray(pkg.datasets) ? pkg.datasets : [];
   const candidates = [];
-  for (const step of steps) {
-    if (!isRecord4(step) || !isRecord4(step.output)) {
-      continue;
-    }
-    const output2 = step.output;
-    if (!isPackagedDatasetOutput(output2)) {
+  for (const output2 of datasets) {
+    if (!isRecord5(output2) || !isPackagedDatasetOutput(output2)) {
       continue;
     }
-    const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : typeof step.id === "string" ? step.id : null;
+    const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : null;
     if (!source) {
       continue;
     }
     candidates.push({
       source,
       value: output2,
-      total: output2.rowCount ?? (isRecord4(output2.preview) ? output2.preview.totalRows : void 0) ?? (isRecord4(step.progress) ? step.progress.total : void 0)
+      total: output2.rowCount ?? (isRecord5(output2.preview) ? output2.preview.totalRows : void 0)
     });
   }
   return candidates;
 }
 function collectSerializedDatasetRowsInfos(statusOrResult) {
-  const root = isRecord4(statusOrResult) ? statusOrResult : null;
-  const result = isRecord4(root?.result) ? root.result : root;
+  const root = isRecord5(statusOrResult) ? statusOrResult : null;
+  const result = isRecord5(root?.result) ? root.result : root;
   const candidates = [];
   if (result) {
     collectDatasetCandidates({
@@ -7467,7 +7645,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       path: "result",
       output: candidates
     });
-    if (isRecord4(result.output)) {
+    if (isRecord5(result.output)) {
       collectDatasetCandidates({
         value: result.output,
         path: "result",
@@ -7475,7 +7653,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       });
     }
   }
-  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
+  candidates.push(...collectPackagedDatasetCandidates(statusOrResult));
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
@@ -7539,13 +7717,13 @@ function summarizeSampleValue(value, depth = 0) {
   if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
   if (depth >= 3) {
     if (Array.isArray(parsed)) return [];
-    if (isRecord4(parsed)) return {};
+    if (isRecord5(parsed)) return {};
     return compactScalar(parsed);
   }
   if (Array.isArray(parsed)) {
     return parsed.slice(0, 3).map((item) => summarizeSampleValue(item, depth + 1));
   }
-  if (isRecord4(parsed)) {
+  if (isRecord5(parsed)) {
     const out = {};
     for (const [key, nested] of Object.entries(parsed)) {
       if (["__dl", "meta", "metadata"].includes(key)) {
@@ -7576,7 +7754,7 @@ function compactCell(value) {
     }
     return `[${parsed.length} items]`;
   }
-  if (isRecord4(parsed)) {
+  if (isRecord5(parsed)) {
     for (const key of ["matched_result", "output"]) {
       if (parsed[key] !== null && parsed[key] !== void 0 && parsed[key] !== "") {
         return compactCell(parsed[key]);
@@ -8615,17 +8793,17 @@ function parsePositiveInteger2(value, flagName) {
   }
   return parsed;
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord5);
-  if (!isRecord5(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord6);
+  if (!isRecord6(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord5(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord6(entry) ? { name, ...entry } : { name }
   );
 }
 var PlayBootstrapError = class extends Error {
@@ -9187,7 +9365,7 @@ function readCsvSampleRows(sample) {
     relax_column_count: true,
     trim: true
   });
-  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord5) : [];
+  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord6) : [];
 }
 function readSourceCsvColumnSpecs(csvPath) {
   const sample = readCsvSample(csvPath);
@@ -9220,16 +9398,16 @@ function packagedCsvPathForPlay(csvPath) {
   return portablePath.startsWith(".") ? portablePath : `./${portablePath}`;
 }
 function getterNamesFromTool(tool, kind) {
-  const usageGuidance = isRecord5(tool?.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord5(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord5(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const usageGuidance = isRecord6(tool?.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord6(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord6(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
   const key = kind === "list" ? "extractedLists" : "extractedValues";
   const snakeKey = kind === "list" ? "extracted_lists" : "extracted_values";
   return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
 }
 function targetGettersFromTool(tool) {
-  const record = isRecord5(tool) ? tool : {};
+  const record = isRecord6(tool) ? tool : {};
   const raw = record.targetGetters ?? record.target_getters;
-  if (!isRecord5(raw)) return {};
+  if (!isRecord6(raw)) return {};
   const entries = [];
   for (const [target, value] of Object.entries(raw)) {
     const paths = Array.isArray(value) ? value.map((path) => typeof path === "string" ? path.trim() : "").filter(Boolean) : [];
@@ -9250,10 +9428,10 @@ function listRowCandidateKeysFromTool(tool) {
   return [...keys].sort();
 }
 function inputPropertyNames(schema) {
-  if (!isRecord5(schema)) return [];
-  if (isRecord5(schema.properties)) return Object.keys(schema.properties);
+  if (!isRecord6(schema)) return [];
+  if (isRecord6(schema.properties)) return Object.keys(schema.properties);
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord5).map((field) => stringValue(field.name)).filter(Boolean);
+    return schema.fields.filter(isRecord6).map((field) => stringValue(field.name)).filter(Boolean);
   }
   return [];
 }
@@ -9267,7 +9445,7 @@ function schemaFieldDetails(schema) {
   return { required, optional };
 }
 function jsonSchemaTypeExpression(schema) {
-  if (!isRecord5(schema)) return "unknown";
+  if (!isRecord6(schema)) return "unknown";
   const type = schema.type;
   if (Array.isArray(type)) {
     return type.map((entry) => jsonSchemaTypeExpression({ ...schema, type: entry })).join(" | ");
@@ -9297,7 +9475,7 @@ function jsonSchemaTypeExpression(schema) {
   }
 }
 function objectPropertySchema(schema, property) {
-  return isRecord5(schema) && isRecord5(schema.properties) ? schema.properties[property] : null;
+  return isRecord6(schema) && isRecord6(schema.properties) ? schema.properties[property] : null;
 }
 function playOutputHasField(schema, field) {
   return objectPropertySchema(schema, field) != null;
@@ -9473,14 +9651,14 @@ ${indent2.slice(2)}}`;
 }
 function requiredPlayInputFields(play) {
   const schema = play?.inputSchema;
-  if (!isRecord5(schema)) return [];
+  if (!isRecord6(schema)) return [];
   if (Array.isArray(schema.required)) {
     return schema.required.filter(
       (value) => typeof value === "string"
     );
   }
   if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord5).filter(
+    return schema.fields.filter(isRecord6).filter(
       (field) => field.required === true && typeof field.name === "string"
     ).map((field) => String(field.name));
   }
@@ -9661,7 +9839,7 @@ function validateBootstrapRoutes(input2) {
   }
 }
 function staticPipelineSubsteps(pipeline) {
-  if (!isRecord5(pipeline)) return [];
+  if (!isRecord6(pipeline)) return [];
   return [
     ...extractionEntries(pipeline.stages),
     ...extractionEntries(pipeline.substeps)
@@ -9669,7 +9847,7 @@ function staticPipelineSubsteps(pipeline) {
 }
 function playUsesMapBackedRuntime(play) {
   const pipeline = play?.staticPipeline;
-  if (!isRecord5(pipeline)) return false;
+  if (!isRecord6(pipeline)) return false;
   if (stringValue(pipeline.tableNamespace)) return true;
   return staticPipelineSubsteps(pipeline).some((substep) => {
     if (stringValue(substep.type) === "map") return true;
@@ -9678,7 +9856,7 @@ function playUsesMapBackedRuntime(play) {
       aliases: [],
       runCommand: "",
       examples: [],
-      staticPipeline: isRecord5(substep.pipeline) ? substep.pipeline : null
+      staticPipeline: isRecord6(substep.pipeline) ? substep.pipeline : null
     });
   });
 }
@@ -10826,7 +11004,8 @@ var PLAY_RUN_RESERVED_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "--logs",
   "--full",
   "--force",
-  "--no-open"
+  "--no-open",
+  "--debug-map-latency"
 ]);
 function traceCliSync(phase, fields, run) {
   const startedAt = Date.now();
@@ -12414,6 +12593,7 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
   let timedOut = false;
   let emittedDashboardUrl = false;
   let lastKnownWorkflowId = "";
+  let launchedRevisionId = input2.request.revisionId?.trim() || null;
   let eventCount = 0;
   let firstRunIdMs = null;
   let lastPhase = null;
@@ -12439,13 +12619,24 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
       }
       throw error;
     }
-    return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? { ...refreshed, dashboardUrl } : null;
+    return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? {
+      ...refreshed,
+      dashboardUrl,
+      ...launchedRevisionId ? { revisionId: launchedRevisionId } : {}
+    } : null;
   };
   try {
     for await (const event of input2.client.startPlayRunStream(input2.request, {
       signal: controller.signal
     })) {
       eventCount += 1;
+      const eventRevisionId = getStringField(
+        getEventPayload(event),
+        "revisionId"
+      );
+      if (eventRevisionId) {
+        launchedRevisionId = eventRevisionId;
+      }
       const eventRunId = getRunIdFromLiveEvent(event);
       if (typeof eventRunId === "string" && eventRunId && eventRunId !== "pending") {
         lastKnownWorkflowId = eventRunId;
@@ -12522,7 +12713,11 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
       const finalStatus = getFinalStatusFromLiveEvent(event);
       if (finalStatus) {
         lastKnownWorkflowId ||= finalStatus.runId ?? "";
-        const canonicalTerminal = input2.request.profile === "absurd" ? await fetchKnownTerminalStatus() : { ...finalStatus, dashboardUrl };
+        const canonicalTerminal = input2.request.profile === "absurd" ? await fetchKnownTerminalStatus() : {
+          ...finalStatus,
+          dashboardUrl,
+          ...launchedRevisionId ? { revisionId: launchedRevisionId } : {}
+        };
         if (!canonicalTerminal) {
           recordCliTrace({
             phase: "cli.play_start_stream_stale_terminal_ignored",
@@ -12894,6 +13089,10 @@ function buildRunNextCommands(status) {
     stop: `deepline runs stop ${runId} --reason "stale lock" --json`,
     logs: `deepline runs logs ${runId} --out run.log --json`
   };
+  if (status.status === "failed") {
+    commands.failedLogs = `deepline runs get ${runId} --log-failed --json`;
+    if (status.rerunCommand) commands.run = status.rerunCommand;
+  }
   if (status.dashboardUrl) {
     commands.open = `Open ${status.dashboardUrl} to see results.`;
   }
@@ -13045,7 +13244,7 @@ function buildInsufficientCreditsSummaryLines(input2) {
   const lines = [
     "  status: stopped_insufficient_credits",
     completed === null ? "  completed rows: unknown" : `  completed rows: ${formatInteger(completed)}${total !== null ? ` of ${formatInteger(total)}` : ""}`,
-    "  reusable receipts: yes; rerun after adding credits to continue from completed provider work"
+    "  completed provider work: reused automatically when you rerun after adding credits"
   ];
   const billingUrl = getStringField(input2.billing, "billing_url");
   const recommended = formatCreditAmount(
@@ -13245,15 +13444,44 @@ function withTerminalPlayIdentity(status, playName) {
 function compactPlayStatus(status) {
   const packaged = getPlayRunPackage(status);
   if (packaged) {
-    const error2 = selectRunErrorForDisplay(status) ?? (typeof status.error === "string" ? String(status.error) : null);
+    const packagedRun = readRecord(packaged.run);
+    const packagedError = typeof packagedRun?.error === "string" ? packagedRun.error : null;
+    const error2 = selectRunErrorForDisplay(status) ?? (typeof status.error === "string" ? String(status.error) : packagedError);
+    const compactError = error2 ? compactRunErrorForEnvelope(error2, status.runId) : null;
     if (!error2) {
-      return packaged;
+      return status.failedLogs || status.rerunCommand ? {
+        ...packaged,
+        ...status.failedLogs ? { failedLogs: status.failedLogs } : {},
+        next: {
+          ...readRecord(packaged.next) ?? {},
+          ...status.failedLogs ? {
+            failedLogs: `deepline runs get ${status.runId} --log-failed --json`
+          } : {},
+          ...status.rerunCommand ? { run: status.rerunCommand } : {}
+        }
+      } : packaged;
     }
-    const run = packaged.run && typeof packaged.run === "object" ? packaged.run : null;
+    const run = packagedRun;
     return {
       ...packaged,
-      error: error2,
-      ...run ? { run: { ...run, error: error2 } } : {}
+      ...status.failedLogs ? { failedLogs: status.failedLogs } : {},
+      ...status.failedLogs ? {
+        next: {
+          ...readRecord(packaged.next) ?? {},
+          failedLogs: `deepline runs get ${status.runId} --log-failed --json`
+        }
+      } : {},
+      ...status.rerunCommand ? {
+        next: {
+          ...readRecord(packaged.next) ?? {},
+          ...status.failedLogs ? {
+            failedLogs: `deepline runs get ${status.runId} --log-failed --json`
+          } : {},
+          run: status.rerunCommand
+        }
+      } : {},
+      error: compactError,
+      ...run ? { run: { ...run, error: compactError } } : {}
     };
   }
   const rowsInfo = extractCanonicalRowsInfo(status);
@@ -13276,6 +13504,7 @@ function compactPlayStatus(status) {
     steps: normalizeStepsForEnvelope(status),
     errors: normalizeErrorsForEnvelope(status, error),
     logs: normalizeLogsForEnvelope(status),
+    ...status.failedLogs ? { failedLogs: status.failedLogs } : {},
     ...displayError ? { error: displayError } : {},
     ...warnings.length > 0 ? { warnings } : {},
     ...result !== void 0 ? { result: defaultResultForEnvelope(result) } : {},
@@ -13283,6 +13512,16 @@ function compactPlayStatus(status) {
     next: buildRunNextCommands(status)
   };
 }
+function compactRunErrorForEnvelope(message, runId) {
+  const lines = message.split("\n");
+  const firstStackFrame = lines.findIndex(
+    (line, index) => index > 0 && /^\s*at\s+.*(?:\(?[^()\s]+:\d+:\d+\)?|native\)?|<anonymous>\)?)\s*$/u.test(
+      line
+    )
+  );
+  const headline = firstStackFrame >= 0 ? lines.slice(0, firstStackFrame).join("\n") : message;
+  return truncateErrorForDisplay(headline, runId, 1e3);
+}
 function readRunPackageRun(packaged) {
   return packaged.run && typeof packaged.run === "object" && !Array.isArray(packaged.run) ? packaged.run : {};
 }
@@ -13402,6 +13641,14 @@ function actionToCommand(action) {
       record.datasetPath
     )} --out ${shellSingleQuote(`${record.datasetPath.split(".").pop() || "dataset"}.csv`)}`;
   }
+  if (record.kind === "deepline_run_logs") {
+    if (typeof record.command === "string" && record.command.trim()) {
+      return record.command;
+    }
+    if (typeof record.runId === "string") {
+      return record.view === "failed" ? `deepline runs get ${record.runId} --log-failed --json` : `deepline runs logs ${record.runId} --json`;
+    }
+  }
   if (record.kind === "deepline_db_query" && typeof record.sql === "string") {
     const maxRows = typeof record.maxRows === "number" && Number.isFinite(record.maxRows) ? Math.trunc(record.maxRows) : 20;
     return `deepline db query --sql ${shellSingleQuote(record.sql)} --max-rows ${maxRows} --json`;
@@ -13409,6 +13656,10 @@ function actionToCommand(action) {
   return null;
 }
 function readFirstDatasetActions(packaged) {
+  for (const dataset of readRecordArray(packaged.datasets)) {
+    const actions = readRecord(dataset.actions);
+    if (actions) return actions;
+  }
   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;
@@ -13458,13 +13709,34 @@ function buildRunPackageTextLines(packaged) {
   if (runError && (status === "failed" || status === "cancelled")) {
     lines.push(`  error: ${truncateErrorForDisplay(runError, runId)}`);
   }
-  for (const step of readRecordArray(packaged.steps)) {
-    const output2 = step.output && typeof step.output === "object" && !Array.isArray(step.output) ? step.output : null;
-    if (!output2 || output2.recovered !== true) continue;
+  const failedLogs = readRecord(packaged.failedLogs);
+  const failedLogEntries = Array.isArray(failedLogs?.entries) ? failedLogs.entries.filter(
+    (entry) => typeof entry === "string"
+  ) : [];
+  const failedLogAssociation = typeof failedLogs?.association === "string" ? failedLogs.association : null;
+  const failedLogWarning = typeof failedLogs?.warning === "string" && failedLogs.warning.trim() ? failedLogs.warning.trim() : null;
+  if (failedLogEntries.length > 0) {
+    lines.push("  failed logs:");
+    lines.push(...failedLogEntries.map((entry) => `    ${entry}`));
+  }
+  if (failedLogAssociation === "retained_before_truncation") {
+    lines.push("  failed log context: last retained lines before truncation");
+  }
+  if (failedLogWarning) {
+    lines.push(`  warning: ${failedLogWarning}`);
+  }
+  const failedLogNext = readRecord(failedLogs?.next);
+  if (failedLogWarning && typeof failedLogNext?.logs === "string") {
+    lines.push(
+      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(
-      `  recoverable: ${rowCount} rows persisted in ${datasetPath} \u2014 re-running reuses them; export with the command below`
+      `  dataset ${datasetPath}: available, ${rowCount} rows persisted; re-running reuses completed work`
     );
   }
   if (playName) {
@@ -13473,6 +13745,7 @@ function buildRunPackageTextLines(packaged) {
   lines.push(...formatPackageValueOutputLines(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);
   if (billingCommand) {
     const costState = status === "completed" || status === "failed" || status === "cancelled" ? "settles asynchronously \u2014 run the billing command below for totals" : "pending";
     lines.push(`  cost: ${costState}`);
@@ -13497,12 +13770,49 @@ function buildRunPackageTextLines(packaged) {
   const inspectCommand = actionToCommand(next.inspect);
   const queryCommand = actionToCommand(next.query) ?? actionToCommand(datasetActions.query);
   const exportCommand = actionToCommand(next.export) ?? actionToCommand(datasetActions.exportCsv);
+  const runAgainCommand = typeof next.run === "string" && next.run.trim() ? next.run.trim() : null;
   if (inspectCommand) lines.push(`  inspect: ${inspectCommand}`);
+  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 (runAgainCommand) {
+    lines.push("  run again (completed work is reused):");
+    lines.push(`    ${runAgainCommand}`);
+  }
   return lines;
 }
+function buildOrdinaryPlayRunCommand(options, resolvedRevisionId) {
+  const target = options.target.kind === "file" ? options.target.path : options.target.name;
+  const parts = ["deepline", "plays", "run", shellSingleQuote(target)];
+  if (options.input && Object.keys(options.input).length > 0) {
+    parts.push("--input", shellSingleQuote(JSON.stringify(options.input)));
+  }
+  if (options.profile)
+    parts.push("--profile", shellSingleQuote(options.profile));
+  const pinnedRevisionId = options.target.kind === "name" ? resolvedRevisionId ?? options.revisionId : null;
+  if (pinnedRevisionId) {
+    parts.push("--revision-id", shellSingleQuote(pinnedRevisionId));
+  } else if (options.revisionSelector === "latest") {
+    parts.push("--latest");
+  } else if (options.revisionSelector === "live") {
+    parts.push("--live");
+  }
+  if (options.waitTimeoutMs !== null) {
+    parts.push("--tail-timeout-ms", String(options.waitTimeoutMs));
+  }
+  if (options.noOpen) parts.push("--no-open");
+  if (options.fullJson) parts.push("--full");
+  if (options.jsonOutput && options.emitLogs) parts.push("--logs");
+  if (options.jsonOutput) parts.push("--json");
+  return parts.join(" ");
+}
+function withOrdinaryRunAgainCommand(status, options, resolvedRevisionId) {
+  return status.status === "failed" ? {
+    ...status,
+    rerunCommand: buildOrdinaryPlayRunCommand(options, resolvedRevisionId)
+  } : status;
+}
 function writePlayResult(status, jsonOutput, options) {
   const packaged = getPlayRunPackage(status);
   if (jsonOutput) {
@@ -13512,8 +13822,9 @@ function writePlayResult(status, jsonOutput, options) {
     return;
   }
   if (packaged && !options?.fullJson) {
-    const lines2 = buildRunPackageTextLines(packaged);
-    printCommandEnvelope(packaged, {
+    const displayPackage = compactPlayStatus(status);
+    const lines2 = buildRunPackageTextLines(displayPackage);
+    printCommandEnvelope(displayPackage, {
       json: false,
       text: `${lines2.join("\n")}
 `
@@ -13540,6 +13851,21 @@ function writePlayResult(status, jsonOutput, options) {
     const displayError = formatPlayErrorForDisplay(status, progressError) ?? progressError;
     lines.push(`  error: ${truncateErrorForDisplay(displayError, runId)}`);
   }
+  if (status.status === "failed") {
+    const failedLogEntries = status.failedLogs?.entries ?? [];
+    if (failedLogEntries.length > 0) {
+      lines.push("  failed logs:");
+      lines.push(...failedLogEntries.map((entry) => `    ${entry}`));
+    } else {
+      lines.push(
+        `  failed logs: deepline runs get ${runId} --log-failed --json`
+      );
+    }
+    if (status.rerunCommand) {
+      lines.push("  run again (completed work is reused):");
+      lines.push(`    ${status.rerunCommand}`);
+    }
+  }
   const renderedServerView = renderServerResultView(status.resultView);
   if (result) {
     lines.push(...formatReturnValue(result));
@@ -13582,20 +13908,27 @@ async function resolvePlayRunOutputStatus(input2) {
   const streamedPackage = getPlayRunPackage(input2.status);
   const refreshForFullJson = input2.fullJson && streamedPackage !== null;
   const streamedTextPackageIncomplete = !input2.jsonOutput && input2.status.status === "completed" && playRunPackageTextLedgerIncomplete(streamedPackage);
-  if (!refreshForFullJson && !streamedTextPackageIncomplete) {
+  const refreshFailedTerminal = input2.status.status === "failed";
+  if (!refreshForFullJson && !streamedTextPackageIncomplete && !refreshFailedTerminal) {
     return input2.status;
   }
   let refreshedStatus = await input2.client.getPlayStatus(runId, {
     billing: false,
     full: input2.fullJson
   });
-  for (let attempt = 0; attempt < 3 && streamedTextPackageIncomplete && refreshedStatus.status === "completed" && playRunPackageTextLedgerIncomplete(getPlayRunPackage(refreshedStatus)); attempt += 1) {
+  for (let attempt = 0; attempt < 3 && (streamedTextPackageIncomplete && refreshedStatus.status === "completed" && playRunPackageTextLedgerIncomplete(getPlayRunPackage(refreshedStatus)) || refreshFailedTerminal && (refreshedStatus.status !== "failed" || getPlayRunPackage(refreshedStatus) === null)); attempt += 1) {
     await sleep5(250);
     refreshedStatus = await input2.client.getPlayStatus(runId, {
       billing: false,
       full: input2.fullJson
     });
   }
+  if (refreshFailedTerminal && (refreshedStatus.status !== "failed" || getPlayRunPackage(refreshedStatus) === null)) {
+    return input2.status;
+  }
+  if (input2.status.status === "completed" && refreshedStatus.status !== "completed") {
+    return input2.status;
+  }
   const dashboardUrl = input2.status.dashboardUrl;
   return typeof dashboardUrl === "string" ? { ...refreshedStatus, dashboardUrl } : refreshedStatus;
 }
@@ -13730,37 +14063,16 @@ function resolveDatasetByName(available, datasetPath) {
   if (exact) {
     return exact;
   }
+  const byDatasetId = available.find((info) => info.datasetId === target);
+  if (byDatasetId) {
+    return byDatasetId;
+  }
   const byNamespace = available.find(
     (info) => info.tableNamespace && info.tableNamespace === target
   );
   if (byNamespace) {
     return byNamespace;
   }
-  const trailing = target.split(".").filter(Boolean).at(-1);
-  if (!trailing) {
-    return null;
-  }
-  const byTrailing = available.find(
-    (info) => info.tableNamespace === trailing || typeof info.source === "string" && info.source.split(".").filter(Boolean).at(-1) === trailing
-  );
-  if (byTrailing) {
-    return byTrailing;
-  }
-  if (target.split(".").filter(Boolean)[0] === "result") {
-    const recovered = available.filter((info) => info.recovered);
-    if (recovered.length === 1) {
-      return recovered[0];
-    }
-    if (recovered.length > 1) {
-      const names = recovered.map((info) => info.tableNamespace ?? info.source).filter((name) => typeof name === "string");
-      throw new DeeplineError(
-        `Run returned multiple recovered datasets; '${target}' is ambiguous. Choose one with --dataset <path>: ${names.join(", ")}.`,
-        void 0,
-        "RUN_EXPORT_DATASET_AMBIGUOUS",
-        { dataset: target, available: names }
-      );
-    }
-  }
   return null;
 }
 function assertDatasetHasExportableRows(input2) {
@@ -13940,7 +14252,7 @@ function extractPlayValidationErrors(value) {
   if (value instanceof DeeplineError) {
     return extractPlayValidationErrors(value.details);
   }
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     return [];
   }
   const directErrors = stringArrayField(value, "errors");
@@ -14173,6 +14485,7 @@ function parsePlayRunOptions(args) {
   const emitLogs = !jsonOutput || args.includes("--logs");
   const force = args.includes("--force");
   const noOpen = args.includes("--no-open");
+  const debugMapLatency = args.includes("--debug-map-latency");
   let waitTimeoutMs = null;
   let profile = null;
   for (let index = 0; index < args.length; index += 1) {
@@ -14291,7 +14604,8 @@ function parsePlayRunOptions(args) {
     waitTimeoutMs,
     force,
     noOpen,
-    profile
+    profile,
+    debugMapLatency
   };
 }
 function parsePlayCheckOptions(args) {
@@ -14306,7 +14620,7 @@ function shouldUseLocalOnlyPlayCheck() {
   const value = process.env.DEEPLINE_PLAY_CHECK_LOCAL_ONLY?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringValue2(value) {
@@ -14316,14 +14630,14 @@ function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
 function extractionEntries2(value) {
-  if (Array.isArray(value)) return value.filter(isRecord6);
-  if (!isRecord6(value)) return [];
+  if (Array.isArray(value)) return value.filter(isRecord7);
+  if (!isRecord7(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord6(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord7(entry) ? { name, ...entry } : { name }
   );
 }
 function firstRawPath(entry) {
-  const details = isRecord6(entry.details) ? entry.details : {};
+  const details = isRecord7(entry.details) ? entry.details : {};
   const paths = [
     ...asArray(details.rawToolOutputPaths),
     ...asArray(details.raw_tool_output_paths),
@@ -14341,12 +14655,12 @@ function checkHintRawPath(value) {
 function collectStaticPipelineToolIds(staticPipeline) {
   const seen = /* @__PURE__ */ new Set();
   const visitPipeline = (pipeline) => {
-    if (!isRecord6(pipeline)) return;
+    if (!isRecord7(pipeline)) return;
     for (const step of [
       ...asArray(pipeline.stages),
       ...asArray(pipeline.substeps)
     ]) {
-      if (!isRecord6(step)) continue;
+      if (!isRecord7(step)) continue;
       if (step.type === "tool") {
         const toolId = stringValue2(step.toolId) || stringValue2(step.tool);
         if (toolId) seen.add(toolId);
@@ -14360,9 +14674,9 @@ function collectStaticPipelineToolIds(staticPipeline) {
   return [...seen].sort();
 }
 function toolGetterHintFromMetadata(toolId, tool) {
-  const usageGuidance = isRecord6(tool.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord6(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord6(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const toolResponse = isRecord6(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord6(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
+  const usageGuidance = isRecord7(tool.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord7(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord7(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const toolResponse = isRecord7(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord7(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
   const lists = extractionEntries2(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
@@ -14776,6 +15090,7 @@ async function handleFileBackedRun(options) {
     ...stagedFileInputs.packagedFiles.length ? { packagedFiles: stagedFileInputs.packagedFiles } : {},
     ...options.force ? { force: true } : {},
     ...options.profile ? { profile: options.profile } : {},
+    ...options.debugMapLatency ? { testPolicyOverrides: { mapLatencyProfile: true } } : {},
     ...integrationMode ? { integrationMode } : {}
   };
   if (options.watch) {
@@ -14801,14 +15116,17 @@ async function handleFileBackedRun(options) {
     } else {
       progress.fail();
     }
-    const outputStatus = withTerminalPlayIdentity(
-      await resolvePlayRunOutputStatus({
-        client: client2,
-        status: finalStatus,
-        fullJson: options.fullJson,
-        jsonOutput: options.jsonOutput
-      }),
-      playName
+    const outputStatus = withOrdinaryRunAgainCommand(
+      withTerminalPlayIdentity(
+        await resolvePlayRunOutputStatus({
+          client: client2,
+          status: finalStatus,
+          fullJson: options.fullJson,
+          jsonOutput: options.jsonOutput
+        }),
+        playName
+      ),
+      options
     );
     traceCliSync(
       "cli.play_write_result",
@@ -14817,7 +15135,7 @@ async function handleFileBackedRun(options) {
         fullJson: options.fullJson
       })
     );
-    return finalStatus.status === "completed" ? 0 : 1;
+    return outputStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
   const started = await traceCliSpan(
@@ -14937,6 +15255,7 @@ async function handleNamedRun(options) {
     ...stagedFileInputs.packagedFiles.length ? { packagedFiles: stagedFileInputs.packagedFiles } : {},
     ...options.force ? { force: true } : {},
     ...options.profile ? { profile: options.profile } : {},
+    ...options.debugMapLatency ? { testPolicyOverrides: { mapLatencyProfile: true } } : {},
     ...integrationMode ? { integrationMode } : {}
   };
   if (options.watch) {
@@ -14964,14 +15283,18 @@ async function handleNamedRun(options) {
     } else {
       progress.fail();
     }
-    const outputStatus = withTerminalPlayIdentity(
-      await resolvePlayRunOutputStatus({
-        client: client2,
-        status: finalStatus,
-        fullJson: options.fullJson,
-        jsonOutput: options.jsonOutput
-      }),
-      playName
+    const outputStatus = withOrdinaryRunAgainCommand(
+      withTerminalPlayIdentity(
+        await resolvePlayRunOutputStatus({
+          client: client2,
+          status: finalStatus,
+          fullJson: options.fullJson,
+          jsonOutput: options.jsonOutput
+        }),
+        playName
+      ),
+      options,
+      finalStatus.revisionId ?? selectedRevisionId
     );
     traceCliSync(
       "cli.play_write_result",
@@ -14980,7 +15303,7 @@ async function handleNamedRun(options) {
         fullJson: options.fullJson
       })
     );
-    return finalStatus.status === "completed" ? 0 : 1;
+    return outputStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
   const started = await traceCliSpan(
@@ -15041,7 +15364,7 @@ async function handlePlayRun(args) {
 function parseRunIdPositional(args, usage) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--json" || arg === "--full" || arg === "--logs" || arg === "--compact" || arg === "--limit") {
+    if (arg === "--json" || arg === "--full" || arg === "--logs" || arg === "--compact" || arg === "--log-failed" || arg === "--failed" || arg === "--limit") {
       if (arg === "--limit" && args[index + 1]) {
         index += 1;
       }
@@ -15058,7 +15381,7 @@ function parseRunIdPositional(args, usage) {
   throw new DeeplineError(usage);
 }
 async function handleRunGet(args) {
-  const usage = "Usage: deepline runs get <run-id> [--json] [--full]";
+  const usage = "Usage: deepline runs get <run-id> [--json] [--full] [--log-failed]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage);
@@ -15068,7 +15391,8 @@ async function handleRunGet(args) {
   }
   const client2 = new DeeplineClient();
   const status = await client2.runs.get(runId, {
-    full: args.includes("--full")
+    full: args.includes("--full"),
+    failedLogs: args.includes("--log-failed")
   });
   writePlayResult(status, argsWantJson(args), {
     fullJson: args.includes("--full")
@@ -15157,7 +15481,37 @@ async function handleRunTail(args) {
   }
   const client2 = new DeeplineClient();
   const jsonOutput = argsWantJson(args);
+  const compact = args.includes("--compact");
+  const compactState = {
+    lastLogIndex: 0,
+    emittedRunnerStarted: false,
+    lastProgressSignature: null,
+    lastProgressHeartbeatAt: 0,
+    lastStatusHeartbeatAt: 0
+  };
   const status = await client2.runs.tail(runId, {
+    onEvent: compact && !jsonOutput ? (event) => {
+      const transition = getStepTransitionLineFromLiveEvent(
+        event,
+        compactState
+      );
+      if (transition) process.stdout.write(`${transition}
+`);
+      for (const line of getProgressLinesFromLiveEvent(event)) {
+        const nowMs = Date.now();
+        if (shouldPrintPlayProgressLine({
+          signature: line,
+          lastProgressSignature: compactState.lastProgressSignature,
+          lastProgressHeartbeatAt: compactState.lastProgressHeartbeatAt,
+          nowMs
+        })) {
+          compactState.lastProgressSignature = line;
+          compactState.lastProgressHeartbeatAt = nowMs;
+          process.stdout.write(`${line}
+`);
+        }
+      }
+    } : void 0,
     // Human mode only: in --json mode emit nothing non-protocol.
     onReconnect: jsonOutput ? void 0 : ({ reason }) => {
       process.stderr.write(
@@ -15170,7 +15524,7 @@ async function handleRunTail(args) {
   return status.status === "failed" ? 1 : 0;
 }
 async function handleRunLogs(args) {
-  const usage = "Usage: deepline runs logs <run-id> [--limit 200] [--out run.log] [--json]";
+  const usage = "Usage: deepline runs logs <run-id> [--limit 200] [--failed] [--out run.log] [--json]";
   let runId;
   try {
     runId = parseRunIdPositional(args, usage);
@@ -15180,6 +15534,7 @@ async function handleRunLogs(args) {
   }
   let limit = 200;
   let outPath = null;
+  const failed = args.includes("--failed");
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--limit" && args[index + 1]) {
@@ -15190,6 +15545,12 @@ async function handleRunLogs(args) {
       outPath = (0, import_node_path11.resolve)(args[++index]);
     }
   }
+  if (failed && outPath) {
+    console.error(
+      "--failed cannot be combined with --out. Remove --failed to export the full persisted log stream."
+    );
+    return 1;
+  }
   const client2 = new DeeplineClient();
   if (outPath) {
     const result2 = await client2.runs.logs(runId, { all: true });
@@ -15221,7 +15582,8 @@ async function handleRunLogs(args) {
     );
     return 0;
   }
-  const result = await client2.runs.logs(runId, { limit });
+  const result = await client2.runs.logs(runId, { limit, failed });
+  const text = buildRunLogsText(result);
   printCommandEnvelope(
     {
       runId: result.runId,
@@ -15233,18 +15595,33 @@ async function handleRunLogs(args) {
       hasMore: result.hasMore,
       ...result.logsTruncated ? { logsTruncated: true } : {},
       entries: result.entries,
+      ...result.view ? { view: result.view } : {},
+      ...result.association ? { association: result.association } : {},
+      ...result.warning ? { warning: result.warning } : {},
       next: {
+        ...result.next ?? {},
         export: `deepline runs logs ${result.runId} --out run.log --json`
       },
       render: { sections: [{ title: "run logs", lines: result.entries }] }
     },
     {
       json: argsWantJson(args),
-      text: `${result.entries.join("\n")}${result.entries.length > 0 ? "\n" : ""}`
+      text
     }
   );
   return 0;
 }
+function buildRunLogsText(result) {
+  const lines = [...result.entries];
+  if (result.warning) {
+    if (lines.length > 0) lines.push("");
+    lines.push(`warning: ${result.warning}`);
+    lines.push(
+      `retained logs: ${result.next?.logs ?? `deepline runs logs ${result.runId} --out run.log --json`}`
+    );
+  }
+  return `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`;
+}
 async function handleRunStop(args) {
   const usage = 'Usage: deepline runs stop <run-id> [--reason "text"] [--json]';
   let runId;
@@ -16143,8 +16520,8 @@ Idempotent execution:
 
     await ctx.tools.execute({ id: 'company_lookup', tool, input });
 
-  The authored id is still required for readable logs, metadata, and receipt
-  attachment, but renaming it alone does not rebuy the same provider request.
+  The authored id is still required for readable logs and metadata, but
+  renaming it alone does not rebuy the same provider request.
 
   For rows, use ctx.dataset plus a stable row key:
 
@@ -16185,7 +16562,10 @@ Examples:
   ).option("--watch", "Compatibility alias; run waits by default").option("--wait", "Compatibility alias; run waits by default").option("--no-wait", "Start the run and return immediately").option(
     "--logs",
     "When output is non-interactive, stream play logs to stderr while waiting"
-  ).option("--tail-timeout-ms <ms>", "Timeout while watching the run stream").option("--force", "Start a fresh run graph").option("--no-open", "Print the play page URL without opening a browser").option("--json", "Emit JSON output").option("--full", "Debug only: with --json, emit the raw status payload").addHelpText(
+  ).option("--tail-timeout-ms <ms>", "Timeout while watching the run stream").option("--force", "Start a fresh run graph").option(
+    "--debug-map-latency",
+    "Internal diagnostics: emit one aggregate latency profile per dataset map"
+  ).option("--no-open", "Print the play page URL without opening a browser").option("--json", "Emit JSON output").option("--full", "Debug only: with --json, emit the raw status payload").addHelpText(
     "afterAll",
     `
 Pass-through input flags:
@@ -16221,6 +16601,7 @@ Pass-through input flags:
       ...options.logs ? ["--logs"] : [],
       ...options.tailTimeoutMs ? ["--tail-timeout-ms", options.tailTimeoutMs] : [],
       ...options.force ? ["--force"] : [],
+      ...options.debugMapLatency ? ["--debug-map-latency"] : [],
       ...options.noOpen || options.open === false ? ["--no-open"] : [],
       ...options.json ? ["--json"] : [],
       ...options.full ? ["--full"] : [],
@@ -16449,13 +16830,18 @@ Notes:
 Examples:
   deepline runs get play/my-play/run/20260501t000000-000
   deepline runs get play/my-play/run/20260501t000000-000 --json
+  deepline runs get play/my-play/run/20260501t000000-000 --log-failed --json
   deepline runs get play/my-play/run/20260501t000000-000 --full --json
 `
-  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--full", "Debug only: with --json, emit the raw status payload").action(async (runId, options) => {
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--full", "Debug only: with --json, emit the raw status payload").option(
+    "--log-failed",
+    "Attach a bounded terminal-failure log window for failed runs"
+  ).action(async (runId, options) => {
     process.exitCode = await handleRunGet([
       runId,
       ...options.json ? ["--json"] : [],
-      ...options.full ? ["--full"] : []
+      ...options.full ? ["--full"] : [],
+      ...options.logFailed ? ["--log-failed"] : []
     ]);
   });
   runs.command("list").description("List play runs.").addHelpText(
@@ -16499,13 +16885,17 @@ Examples:
     `
 Notes:
   Streams live run events until the stream ends. Use get for current status and
-  logs for persisted log history.
+  logs for persisted log history. In human output, --compact prints deduplicated
+  step transitions and progress instead of the full event stream.
 
 Examples:
   deepline runs tail play/my-play/run/20260501t000000-000
   deepline runs tail play/my-play/run/20260501t000000-000 --compact --json
 `
-  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option("--compact", "Drop verbose fields from JSON output").action(async (runId, options) => {
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").option(
+    "--compact",
+    "Show deduplicated step transitions and progress; compact JSON output"
+  ).action(async (runId, options) => {
     process.exitCode = await handleRunTail([
       runId,
       ...options.json ? ["--json"] : [],
@@ -16522,17 +16912,19 @@ Notes:
 Examples:
   deepline runs logs play/my-play/run/20260501t000000-000
   deepline runs logs play/my-play/run/20260501t000000-000 --limit 500
+  deepline runs logs play/my-play/run/20260501t000000-000 --failed --json
   deepline runs logs play/my-play/run/20260501t000000-000 --out run.log --json
 `
   ).option(
     "--limit <count>",
     "Maximum recent log lines to print without --out",
     "200"
-  ).option("--out <path>", "Write the full persisted log stream to a file").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
+  ).option("--out <path>", "Write the full persisted log stream to a file").option("--failed", "Show the bounded terminal-failure log window").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (runId, options) => {
     process.exitCode = await handleRunLogs([
       runId,
       ...options.limit ? ["--limit", options.limit] : [],
       ...options.out ? ["--out", options.out] : [],
+      ...options.failed ? ["--failed"] : [],
       ...options.json ? ["--json"] : []
     ]);
   });
@@ -17270,6 +17662,8 @@ function renderPlayStep(command, options) {
     `  const __dlRunIf = ${runIfJs};`,
     `  if (!__dlRunIf(templateRow)) return null;`
   ] : [];
+  const inline = command.play?.inline;
+  const inlineHandler = inline ? `__dlInlinePlay_${inline.sourceHash.slice(0, 16)}` : null;
   return [
     `async (row, stepCtx) => {`,
     ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
@@ -17279,9 +17673,16 @@ function renderPlayStep(command, options) {
     `  if (__dlShouldSkipBlankPlayPayload(payload)) return null;`,
     `  let result: unknown;`,
     `  try {`,
-    `    result = await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
-    `        description: ${stringLiteral(command.description ?? command.alias)}`,
-    `    });`,
+    ...inlineHandler ? [
+      // Enrich validates and normalizes this payload against the certified
+      // prebuilt contract before code generation. The attachment retains
+      // its concrete input type, while generated payloads are records.
+      `    result = await __dlRunInlinePlay(${inlineHandler}, stepCtx, payload as never, ${options.force});`
+    ] : [
+      `    result = await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
+      `        description: ${stringLiteral(command.description ?? command.alias)}`,
+      `    });`
+    ],
     `  } catch (error) {`,
     ...options.waterfallSoftFail ? [`    return __dlWaterfallToolFailure(error);`] : [`    throw error;`],
     `  }`,
@@ -17289,6 +17690,19 @@ function renderPlayStep(command, options) {
     `}`
   ].join("\n");
 }
+function collectInlinePlayHandlers(commands) {
+  const handlers = /* @__PURE__ */ new Map();
+  const visit = (command) => {
+    if (isWaterfall(command)) {
+      command.commands.forEach(visit);
+      return;
+    }
+    const inline = command.play?.inline;
+    if (inline) handlers.set(inline.sourceHash, inline);
+  };
+  commands.forEach(visit);
+  return [...handlers.values()];
+}
 function renderInlineJavascriptStep(command, options) {
   const alias = stringLiteral(command.alias);
   const extractJs = renderExtractFunction(command, 4);
@@ -17489,6 +17903,10 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
     [...options.forceAliases ?? []].map((alias) => normalizeAlias(alias))
   );
   const columnSteps = [];
+  const inlineHandlers = collectInlinePlayHandlers(config.commands);
+  const inlineTypeImports = [
+    ...new Set(inlineHandlers.flatMap((inline) => inline.typeImports ?? []))
+  ].sort();
   config.commands.forEach((command) => {
     if (isWaterfall(command)) {
       columnSteps.push(
@@ -17526,6 +17944,19 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
   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 = [
+    `function __dlRunInlinePlay<TContext, TInput, TOutput>(handler: (ctx: TContext, input: TInput) => Promise<TOutput>, scope: TContext, payload: TInput, force: boolean): Promise<TOutput> {`,
+    `  if (!force) return handler(scope, payload);`,
+    `  const runtimeScope = scope as TContext & { __deeplineRunWithForcedTools?: <T>(run: () => Promise<T>) => Promise<T> };`,
+    `  if (typeof runtimeScope.__deeplineRunWithForcedTools !== 'function') {`,
+    `    throw new Error('This runtime does not support forced certified inline play execution.');`,
+    `  }`,
+    `  return runtimeScope.__deeplineRunWithForcedTools(() => handler(scope, payload));`,
+    `}`,
+    ``,
+    ...inlineHandlers.flatMap((inline) => [
+      `const __dlInlinePlay_${inline.sourceHash.slice(0, 16)} = ${inline.functionExpressionSource};`,
+      ``
+    ]),
     `export default definePlay(${stringLiteral(playName)}, async (ctx, input: EnrichInput) => {`,
     `  const sourceRows = await ctx.csv<Record<string, unknown>>(input.file);`,
     `  const rowStart = __dlNonNegativeInteger(input.rowStart, 0);`,
@@ -17550,7 +17981,8 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
   const helpers = idiomaticGetters ? selectUsedHelpers(helperSource(), body.join("\n")) : helperSource();
   return [
     ...inlineRunJavascript && configHasRunJavascript(config) ? ["// @ts-nocheck", "/* eslint-disable */", ""] : [],
-    `import { definePlay } from 'deepline';`,
+    `import { definePlay, steps } from 'deepline';`,
+    ...inlineTypeImports.length > 0 ? [`import type { ${inlineTypeImports.join(", ")} } from 'deepline';`] : [],
     ``,
     `type EnrichInput = { file: string; rowStart?: number | null; rowEnd?: number | null };`,
     ``,
@@ -18405,7 +18837,7 @@ function isMarkedTestAiInferenceCommand(command) {
   if (normalizeEnrichPlayRef(command.tool) !== "run_javascript") {
     return false;
   }
-  return isRecord7(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
+  return isRecord8(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
 }
 function enrichDebugEnabled(env = process.env) {
   const raw = String(env.DEEPLINE_DEBUG_ENRICH ?? "").trim().toLowerCase();
@@ -18664,6 +19096,27 @@ function sdkEnrichCommandText(args) {
   }
   return `${command.slice(0, SDK_ENRICH_TELEMETRY_COMMAND_MAX_LENGTH - 3)}...`;
 }
+function rewriteGeneratedPlayRerunForEnrich(status, enrichCommand) {
+  const rewrite = (value) => {
+    if (Array.isArray(value)) {
+      return value.map(rewrite);
+    }
+    if (!isRecord8(value)) {
+      return value;
+    }
+    const next = Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        key === "rerunCommand" && typeof entry === "string" ? enrichCommand : rewrite(entry)
+      ])
+    );
+    if (isRecord8(next.next) && typeof next.next.run === "string") {
+      next.next = { ...next.next, run: enrichCommand };
+    }
+    return next;
+  };
+  return rewrite(status);
+}
 function countConfiguredEnrichColumns(config) {
   const count = (commands) => commands.reduce((total, command) => {
     if ("with_waterfall" in command) {
@@ -18765,7 +19218,8 @@ async function buildPlanArgs(args) {
     "--fail-fast",
     "--all",
     "--in-place",
-    "--no-open"
+    "--no-open",
+    "--debug-map-latency"
   ]);
   const planArgs = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -19120,7 +19574,7 @@ async function resolveWatchedGeneratedPlayStatus(input2) {
   }
   return input2.client.runs.get(runId, { full: true });
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 async function captureStdout(run, options = {}) {
@@ -19407,13 +19861,13 @@ function readFirstEnrichDatasetActions(value) {
       return null;
     }
     const record = candidate;
-    const actions = isRecord7(record.actions) ? record.actions : null;
-    const query = isRecord7(actions?.query) ? actions.query : null;
+    const actions = isRecord8(record.actions) ? record.actions : null;
+    const query = isRecord8(actions?.query) ? actions.query : null;
     if (query?.kind === "deepline_db_query") {
       return {
         dataset: record,
         query,
-        ...isRecord7(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
+        ...isRecord8(actions?.exportCsv) ? { exportCsv: actions.exportCsv } : {}
       };
     }
     if (options.allowLegacy && record.kind === "dataset" && typeof record.queryDatasetCommand === "string" && record.queryDatasetCommand.trim()) {
@@ -19466,7 +19920,7 @@ function enrichCustomerDbJson(input2) {
   const dataset = actions.dataset;
   const sql = actionStringField(query, "sql") ?? parseSqlFromDbQueryCommand(actions.queryDatasetCommand);
   const datasetPath = actionStringField(query, "datasetPath") ?? actionStringField(dataset, "path") ?? actionStringField(dataset, "tableNamespace");
-  const api = isRecord7(query.api) ? query.api : null;
+  const api = isRecord8(query.api) ? query.api : null;
   const apiPath = actionStringField(api ?? {}, "path") ?? "/api/v2/db/query";
   const apiMethod = actionStringField(api ?? {}, "method") ?? "POST";
   if (!datasetPath) {
@@ -19535,11 +19989,11 @@ function sqlStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function failureAliasFromCellMeta(cellMeta) {
-  if (!isRecord7(cellMeta)) {
+  if (!isRecord8(cellMeta)) {
     return null;
   }
   for (const [alias, meta] of Object.entries(cellMeta)) {
-    if (!isRecord7(meta)) {
+    if (!isRecord8(meta)) {
       continue;
     }
     const failure = failureCellFromMeta(meta, {});
@@ -20077,7 +20531,7 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   return fallback;
 }
 function failureCellFromMeta(meta, fallback) {
-  if (!isRecord7(meta)) {
+  if (!isRecord8(meta)) {
     return null;
   }
   const status = typeof meta.status === "string" ? meta.status.trim().toLowerCase() : "";
@@ -20097,7 +20551,7 @@ function failureCellFromMeta(meta, fallback) {
   };
 }
 function applyFailureCellMeta(row, cellMeta, fallback) {
-  if (!isRecord7(cellMeta)) {
+  if (!isRecord8(cellMeta)) {
     return;
   }
   for (const [field, meta] of Object.entries(cellMeta)) {
@@ -20341,7 +20795,7 @@ function stableRowSnapshot(value) {
 }
 function cellFailureError(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord7(parsed)) {
+  if (!isRecord8(parsed)) {
     const text = typeof parsed === "string" ? parsed.trim() : "";
     if (/^(?:[A-Za-z0-9_:-]+:\s*)?(?:Error|TypeError|ReferenceError|SyntaxError|RangeError):\s+/.test(
       text
@@ -20349,12 +20803,12 @@ function cellFailureError(value) {
       return { message: text };
     }
   }
-  if (!isRecord7(parsed)) {
+  if (!isRecord8(parsed)) {
     return null;
   }
   const status = typeof parsed.status === "string" ? parsed.status.trim().toLowerCase() : "";
   const directError = typeof parsed.error === "string" ? parsed.error.trim() : typeof parsed.last_error === "string" ? parsed.last_error.trim() : "";
-  const result = isRecord7(parsed.result) ? parsed.result : null;
+  const result = isRecord8(parsed.result) ? parsed.result : null;
   const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
   if (!directError && !resultError && status !== "error" && status !== "failed") {
     return null;
@@ -20424,7 +20878,7 @@ function assignFlattenedFailurePath(target, field, value) {
   let cursor = target;
   for (const part of normalized.slice(0, -1)) {
     const existing = cursor[part];
-    if (!isRecord7(existing)) {
+    if (!isRecord8(existing)) {
       const next = {};
       cursor[part] = next;
       cursor = next;
@@ -20588,10 +21042,10 @@ function waterfallExecutionSignal(status, spec) {
   let everyChildStatOnlyConditionSkipped = true;
   const childAliasesWithStats = /* @__PURE__ */ new Set();
   for (const childAlias of childAliases) {
-    for (const stat2 of summaries.map((summary) => summary[childAlias]).filter(isRecord7)) {
+    for (const stat2 of summaries.map((summary) => summary[childAlias]).filter(isRecord8)) {
       sawChildStats = true;
       childAliasesWithStats.add(childAlias);
-      const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+      const execution = isRecord8(stat2.execution) ? stat2.execution : null;
       const executedSummary = parseExecutionSummary(
         execution?.["completed:executed"]
       );
@@ -20621,7 +21075,7 @@ function waterfallExecutionSignal(status, spec) {
 }
 function emptyWaterfallStatsEvidence(status, spec) {
   const summaries = collectColumnStats(status);
-  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord7);
+  const parentStats = summaries.map((summary) => summary[spec.alias]).filter(isRecord8);
   for (const stat2 of parentStats) {
     const nonEmpty = parseExecutionSummary(stat2.non_empty);
     if (nonEmpty?.total && nonEmpty.count === 0) {
@@ -20635,7 +21089,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
   let selectedRows = 0;
   let sawStatsForEveryChild = true;
   for (const childAlias of childAliases) {
-    const stat2 = summaries.map((summary) => summary[childAlias]).find(isRecord7);
+    const stat2 = summaries.map((summary) => summary[childAlias]).find(isRecord8);
     if (!stat2) {
       sawStatsForEveryChild = false;
       break;
@@ -20644,7 +21098,7 @@ function emptyWaterfallStatsEvidence(status, spec) {
     if ((nonEmpty?.count ?? 0) > 0) {
       return null;
     }
-    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
     const executed = parseExecutionSummary(execution?.["completed:executed"]);
     const reused = parseExecutionSummary(execution?.["completed:reused"]);
     const skipped = parseExecutionSummary(execution?.["skipped:condition"]);
@@ -20686,11 +21140,11 @@ function collectStatusFailureJobs(input2) {
   const jobs = [];
   aliases.forEach((spec, aliasIndex) => {
     const { alias } = spec;
-    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord7);
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord8);
     if (!stat2) {
       return;
     }
-    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
     const failedCount = Math.min(
       selectedRows,
       Math.max(
@@ -20797,10 +21251,10 @@ function collectColumnStats(status) {
       value.forEach(visit);
       return;
     }
-    if (!isRecord7(value)) {
+    if (!isRecord8(value)) {
       return;
     }
-    if (isRecord7(value.columnStats)) {
+    if (isRecord8(value.columnStats)) {
       summaries.push(value.columnStats);
     }
     Object.values(value).forEach(visit);
@@ -20812,12 +21266,12 @@ function firstAliasExecutionCounts(input2) {
   const aliases = collectConfigScalarAliasOrder(input2.config);
   const summaries = collectColumnStats(input2.status);
   for (const alias of aliases) {
-    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord7);
+    const stat2 = summaries.map((summary) => summary[alias]).find(isRecord8);
     if (!stat2) continue;
     if (input2.forceAliases.has(normalizeAlias2(alias))) {
       return { executed: input2.selectedRows, reused: 0 };
     }
-    const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+    const execution = isRecord8(stat2.execution) ? stat2.execution : null;
     if (!execution) continue;
     return {
       executed: parseExecutionCount(execution["completed:executed"]),
@@ -20844,14 +21298,14 @@ function rewriteEnrichJsonStatus(input2) {
     if (Array.isArray(value)) {
       return value.map(rewrite);
     }
-    if (!isRecord7(value)) {
+    if (!isRecord8(value)) {
       return value;
     }
     const next = {};
     for (const [key, entry] of Object.entries(value)) {
       next[key] = rewrite(entry);
     }
-    if (isRecord7(next.progress)) {
+    if (isRecord8(next.progress)) {
       next.progress = {
         ...next.progress,
         ...selectedRows > 0 ? { total: selectedRows } : {},
@@ -20860,8 +21314,8 @@ function rewriteEnrichJsonStatus(input2) {
         ...failedRows > 0 ? { failed: failedRows, pending: 0 } : {}
       };
     }
-    if (isRecord7(next.summary)) {
-      const rowCounts = isRecord7(next.summary.rowCounts) ? next.summary.rowCounts : null;
+    if (isRecord8(next.summary)) {
+      const rowCounts = isRecord8(next.summary.rowCounts) ? next.summary.rowCounts : null;
       if (failedRows > 0) {
         next.summary = {
           ...next.summary,
@@ -20874,11 +21328,11 @@ function rewriteEnrichJsonStatus(input2) {
         };
       }
     }
-    if (isRecord7(next.columnStats) && selectedRows > 0) {
+    if (isRecord8(next.columnStats) && selectedRows > 0) {
       const columnStats = { ...next.columnStats };
       for (const alias of forcedAliases) {
-        const stat2 = isRecord7(columnStats[alias]) ? columnStats[alias] : null;
-        const execution = isRecord7(stat2?.execution) ? stat2.execution : null;
+        const stat2 = isRecord8(columnStats[alias]) ? columnStats[alias] : null;
+        const execution = isRecord8(stat2?.execution) ? stat2.execution : null;
         if (!stat2 || !execution) continue;
         columnStats[alias] = {
           ...stat2,
@@ -20897,14 +21351,14 @@ function rewriteEnrichJsonStatus(input2) {
     return next;
   };
   const rewritten = rewrite(input2.status);
-  if (failedRows === 0 || !isRecord7(rewritten)) {
+  if (failedRows === 0 || !isRecord8(rewritten)) {
     return rewritten;
   }
   const partialStatus = selectedRows > 0 && failedRows < selectedRows ? "partial_success" : "failed";
   return {
     ...rewritten,
     ...rewritten.status === "completed" || rewritten.status === "failed" ? { status: partialStatus } : {},
-    ...isRecord7(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
+    ...isRecord8(rewritten.run) && (rewritten.run.status === "completed" || rewritten.run.status === "failed") ? { run: { ...rewritten.run, status: partialStatus } } : {}
   };
 }
 function summarizeFailedJobError(value) {
@@ -21318,11 +21772,15 @@ async function fetchBackingRowsForCsvExport(input2) {
 }
 function mergeRowsForCsvExport(enrichedRows, options) {
   const compactAliases = options?.config ? enrichAiRuntimeCompactAliases(options.config) : /* @__PURE__ */ new Set();
+  const preservedAliases = /* @__PURE__ */ new Set([
+    ...compactAliases,
+    ...options?.config ? collectConfigPlayAliases(options.config) : []
+  ]);
   const rows = dataExportRows(
     normalizeEnrichRowsForCsvExport(enrichedRows, options?.config, {
       statusFailureMessages: options?.statusFailureMessages
     }),
-    { preserveJsonStringColumns: compactAliases }
+    { preserveJsonStringColumns: preservedAliases }
   );
   const range = options?.rows;
   if (!options?.sourceCsvPath) {
@@ -21399,6 +21857,22 @@ function mergeRowsForCsvExport(enrichedRows, options) {
   }
   return { rows: merged, preferredColumns };
 }
+function collectConfigPlayAliases(config) {
+  const aliases = /* @__PURE__ */ new Set();
+  const visit = (commands) => {
+    for (const command of commands) {
+      if ("with_waterfall" in command) {
+        visit(command.commands);
+        continue;
+      }
+      if (!command.disabled && command.play) {
+        aliases.add(normalizeAlias2(command.alias));
+      }
+    }
+  };
+  visit(config.commands);
+  return aliases;
+}
 function collectConfigScalarAliasOrder(config) {
   const aliases = [];
   const seen = /* @__PURE__ */ new Set();
@@ -21496,7 +21970,7 @@ function materializeCsvCellValue(value) {
   return value;
 }
 function compactArrayEnvelopeCompleteValue(value) {
-  if (!isRecord7(value) || value.kind !== "array") {
+  if (!isRecord8(value) || value.kind !== "array") {
     return null;
   }
   if (!Array.isArray(value.preview)) {
@@ -21510,7 +21984,7 @@ function compactArrayEnvelopeCompleteValue(value) {
 }
 function disambiguateCompactAiInferencePayload(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord7(parsed) || !cellFailureError(parsed)) {
+  if (!isRecord8(parsed) || !cellFailureError(parsed)) {
     return value;
   }
   return {
@@ -21519,14 +21993,14 @@ function disambiguateCompactAiInferencePayload(value) {
   };
 }
 function compactAiInferenceCellForCsv(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return value;
   }
   const extractedJson = value.extracted_json;
   if (extractedJson !== null && extractedJson !== void 0) {
     return disambiguateCompactAiInferencePayload(extractedJson);
   }
-  const result = isRecord7(value.result) ? value.result : null;
+  const result = isRecord8(value.result) ? value.result : null;
   const object = result?.object;
   if (object !== null && object !== void 0) {
     return disambiguateCompactAiInferencePayload(object);
@@ -21543,17 +22017,20 @@ function compactAiInferenceCellForCsv(value) {
 }
 function materializeEnrichAliasCellForCsv(row, alias, options) {
   const direct = row[alias];
-  if (isRecord7(direct)) {
+  if (isRecord8(direct)) {
     const completeArray = compactArrayEnvelopeCompleteValue(direct);
     if (completeArray) {
       return materializeCsvCellValue(completeArray);
     }
-    if (options?.compactAiCell && direct.status === "completed" && (isRecord7(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
+    if (options?.compactAiCell && direct.status === "completed" && (isRecord8(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
       return materializeCsvCellValue(compactAiInferenceCellForCsv(direct));
     }
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
       return materializeCsvCellValue(direct);
     }
+    if (options?.preservePlainObject && !Object.prototype.hasOwnProperty.call(direct, "_metadata")) {
+      return materializeCsvCellValue(direct);
+    }
     const directCells = [];
     for (const [field, value] of Object.entries(direct)) {
       if (!isEnrichAliasPayloadField(field)) {
@@ -21610,6 +22087,7 @@ function materializeEnrichAliasCellForCsv(row, alias, options) {
 function normalizeEnrichRowsForCsvExport(rows, config, options) {
   const aliases = config ? collectConfigScalarAliasOrder(config) : [];
   const aiCompactAliases = config ? enrichAiRuntimeCompactAliases(config) : null;
+  const playAliases = config ? collectConfigPlayAliases(config) : /* @__PURE__ */ new Set();
   const failureOperationByAlias = hardFailureOperationByAlias(config);
   return rows.map((row) => {
     const metadata = legacyMetadataFromRow(row);
@@ -21653,7 +22131,8 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
     }
     for (const alias of aliases) {
       const value = materializeEnrichAliasCellForCsv(normalized, alias, {
-        compactAiCell: aiCompactAliases?.has(normalizeAlias2(alias)) ?? false
+        compactAiCell: aiCompactAliases?.has(normalizeAlias2(alias)) ?? false,
+        preservePlainObject: playAliases.has(normalizeAlias2(alias))
       });
       if (value !== void 0) {
         normalized[alias] = value;
@@ -21684,11 +22163,11 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
 }
 function legacyMetadataFromRow(row) {
   const direct = parseLegacyMetadataCell(row._metadata);
-  if (direct && isRecord7(direct.columns)) {
+  if (direct && isRecord8(direct.columns)) {
     return direct;
   }
   const relocated = parseLegacyMetadataCell(row.metadata);
-  if (relocated && isRecord7(relocated.columns)) {
+  if (relocated && isRecord8(relocated.columns)) {
     return relocated;
   }
   const flattenedColumns = parseLegacyMetadataCell(row["metadata.columns"]);
@@ -21705,7 +22184,7 @@ function legacyMetadataFromRow(row) {
 }
 function parseLegacyMetadataCell(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (isRecord7(parsed)) {
+  if (isRecord8(parsed)) {
     return parsed;
   }
   if (typeof value !== "string") {
@@ -21722,12 +22201,12 @@ function parseLegacyMetadataCell(value) {
   for (const candidate of candidates) {
     try {
       const decoded = JSON.parse(candidate);
-      if (isRecord7(decoded)) {
+      if (isRecord8(decoded)) {
         return decoded;
       }
       if (typeof decoded === "string") {
         const nested = JSON.parse(decoded);
-        if (isRecord7(nested)) {
+        if (isRecord8(nested)) {
           return nested;
         }
       }
@@ -21737,8 +22216,8 @@ function parseLegacyMetadataCell(value) {
   return null;
 }
 function mergeLegacyMetadataRecords(base, enriched) {
-  const baseColumns = isRecord7(base.columns) ? base.columns : null;
-  const enrichedColumns = isRecord7(enriched.columns) ? enriched.columns : null;
+  const baseColumns = isRecord8(base.columns) ? base.columns : null;
+  const enrichedColumns = isRecord8(enriched.columns) ? enriched.columns : null;
   const merged = {
     ...base,
     ...enriched
@@ -21841,6 +22320,9 @@ function registerEnrichCommand(program) {
   ).option(
     "--profile <id>",
     "Internal/testing: override the execution profile for the generated play run."
+  ).option(
+    "--debug-map-latency",
+    "Internal diagnostics: emit one aggregate latency profile per dataset map."
   ).option(
     "--fail-fast",
     "Fail the generated play when any selected row errors, while preserving recovered runtime-sheet rows for export."
@@ -21986,6 +22468,9 @@ function registerEnrichCommand(program) {
         if (options.profile) {
           runArgs.push("--profile", options.profile);
         }
+        if (options.debugMapLatency) {
+          runArgs.push("--debug-map-latency");
+        }
         if (options.noOpen || input2.suppressOpen) {
           runArgs.push("--no-open");
         }
@@ -22002,11 +22487,15 @@ function registerEnrichCommand(program) {
         const captured2 = await runGeneratedEnrichPlay(client2, runArgs, {
           passthroughStdout: input2.passthroughStdout
         });
-        const status2 = input2.json ? parseJsonOutput(captured2.stdout) : await resolveWatchedGeneratedPlayStatus({
+        const generatedPlayStatus = input2.json ? parseJsonOutput(captured2.stdout) : await resolveWatchedGeneratedPlayStatus({
           client: client2,
           stdout: captured2.stdout,
           exitCode: captured2.result
         });
+        const status2 = rewriteGeneratedPlayRerunForEnrich(
+          generatedPlayStatus,
+          sdkEnrichCommandText(args)
+        );
         const exportResult2 = await maybeWriteOutputCsv({
           outputPath,
           status: status2,
@@ -26221,7 +26710,7 @@ function toolContractJsonForDescribe(tool, requestedToolId) {
 }
 function extractionContractEntries(entries) {
   return entries.flatMap((entry) => {
-    if (!isRecord8(entry)) return [];
+    if (!isRecord9(entry)) return [];
     const name = stringField2(entry, "name");
     const expression = stringField2(entry, "expression");
     return name && expression ? [{ name, expression }] : [];
@@ -26229,8 +26718,8 @@ function extractionContractEntries(entries) {
 }
 function printCompactToolContract(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord8(contract.cost) ? contract.cost : {};
-  const getters = isRecord8(contract.getters) ? contract.getters : {};
+  const cost = isRecord9(contract.cost) ? contract.cost : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const inputFields = Array.isArray(contract.inputFields) ? contract.inputFields : [];
@@ -26247,7 +26736,7 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("");
     console.log("Inputs:");
     for (const field of inputFields) {
-      if (!isRecord8(field)) continue;
+      if (!isRecord9(field)) continue;
       const name = stringField2(field, "name");
       if (!name) continue;
       const required = field.required ? "*" : "";
@@ -26260,7 +26749,7 @@ function printCompactToolContract(tool, requestedToolId) {
   }
   console.log("");
   printToolExamplesOnly(tool, requestedToolId, { includeSamples: false });
-  const starterScript = isRecord8(contract.starterScript) ? contract.starterScript : {};
+  const starterScript = isRecord9(contract.starterScript) ? contract.starterScript : {};
   const starterPath = stringField2(starterScript, "path");
   if (starterPath) {
     console.log("");
@@ -26274,14 +26763,14 @@ function printCompactToolContract(tool, requestedToolId) {
     console.log("Getters:");
     if (listGetters.length) console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
     }
     if (valueGetters.length) console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -26294,7 +26783,7 @@ function printCompactToolContract(tool, requestedToolId) {
 }
 function printToolPricingOnly(tool, requestedToolId, options = {}) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const cost = isRecord8(contract.cost) ? contract.cost : {};
+  const cost = isRecord9(contract.cost) ? contract.cost : {};
   const pricingModel = stringField2(cost, "pricingModel") || "unknown";
   const billingMode = stringField2(cost, "billingMode") || "unknown";
   const unit = pricingModel === "per_page" ? "page" : pricingModel === "per_result" ? "result" : pricingModel === "fixed" ? "call" : pricingModel.replace(/^per_/, "") || "unit";
@@ -26314,7 +26803,7 @@ function printToolSchemaOnly(tool, requestedToolId) {
   }
   console.log("Inputs:");
   for (const field of inputFields) {
-    if (!isRecord8(field)) continue;
+    if (!isRecord9(field)) continue;
     const name = stringField2(field, "name");
     if (!name) continue;
     const required = field.required ? "*" : "";
@@ -26344,10 +26833,10 @@ function printToolExamplesOnly(tool, requestedToolId, options = {}) {
     `  input: ${JSON.stringify(sampleInput || {}, null, 2).replace(/\n/g, "\n  ")},`
   );
   console.log("});");
-  const getters = isRecord8(contract.getters) ? contract.getters : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
-  const firstGetter = [...valueGetters, ...listGetters].find(isRecord8);
+  const firstGetter = [...valueGetters, ...listGetters].find(isRecord9);
   if (firstGetter) {
     const name = stringField2(firstGetter, "name") || "value";
     const expression = stringField2(firstGetter, "expression");
@@ -26383,7 +26872,7 @@ function printPlayLikeToolUsage(tool, requestedToolId) {
 }
 function printToolGettersOnly(tool, requestedToolId) {
   const contract = toolContractJsonForDescribe(tool, requestedToolId);
-  const getters = isRecord8(contract.getters) ? contract.getters : {};
+  const getters = isRecord9(contract.getters) ? contract.getters : {};
   const listGetters = Array.isArray(getters.extractedLists) ? getters.extractedLists : [];
   const valueGetters = Array.isArray(getters.extractedValues) ? getters.extractedValues : [];
   console.log(`Getters: ${contract.toolId}`);
@@ -26396,7 +26885,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (listGetters.length) {
     console.log("Lists:");
     for (const entry of listGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -26405,7 +26894,7 @@ function printToolGettersOnly(tool, requestedToolId) {
   if (valueGetters.length) {
     console.log("Values:");
     for (const entry of valueGetters) {
-      if (isRecord8(entry))
+      if (isRecord9(entry))
         console.log(
           `- ${stringField2(entry, "name")}: ${playResultExpression(entry)}`
         );
@@ -26431,7 +26920,7 @@ function sampleValueForField(field) {
 function samplePayloadForInputFields(fields) {
   return Object.fromEntries(
     fields.slice(0, 4).flatMap((field) => {
-      if (!isRecord8(field)) return [];
+      if (!isRecord9(field)) return [];
       const name = stringField2(field, "name");
       if (!name) return [];
       return [[name, sampleValueForField(field)]];
@@ -26549,12 +27038,12 @@ function formatListedToolCost(tool) {
 }
 function toolInputFieldsForDisplay(inputSchema) {
   if (Array.isArray(inputSchema.fields))
-    return inputSchema.fields.filter(isRecord8);
-  const jsonSchema = isRecord8(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
-  const properties = isRecord8(jsonSchema.properties) ? jsonSchema.properties : {};
+    return inputSchema.fields.filter(isRecord9);
+  const jsonSchema = isRecord9(inputSchema.jsonSchema) ? inputSchema.jsonSchema : inputSchema;
+  const properties = isRecord9(jsonSchema.properties) ? jsonSchema.properties : {};
   const required = Array.isArray(jsonSchema.required) ? new Set(jsonSchema.required.map(String)) : /* @__PURE__ */ new Set();
   return Object.entries(properties).map(([name, value]) => {
-    const property = isRecord8(value) ? value : {};
+    const property = isRecord9(value) ? value : {};
     return {
       name,
       type: typeof property.type === "string" ? property.type : "unknown",
@@ -26583,15 +27072,15 @@ function printJsonPreview(label, payload) {
 }
 function samplePayload(samples, key) {
   const entry = samples[key];
-  if (!isRecord8(entry)) return void 0;
+  if (!isRecord9(entry)) return void 0;
   return Object.prototype.hasOwnProperty.call(entry, "payload") ? entry.payload : entry;
 }
 function commandEnvelopeFromRawResponse(rawResponse) {
-  return isRecord8(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
+  return isRecord9(rawResponse) ? { ...rawResponse } : { status: "completed", result: rawResponse };
 }
 function listExtractorPathsFromUsageGuidance(tool) {
   const toolExecutionResult = tool.usageGuidance?.toolExecutionResult;
-  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord8(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
+  const extractedLists = Array.isArray(toolExecutionResult?.extractedLists) ? toolExecutionResult.extractedLists : isRecord9(toolExecutionResult?.extractedLists) ? Object.values(toolExecutionResult.extractedLists) : [];
   return extractedLists.flatMap((entry) => {
     const paths = entry.details?.candidatePaths ?? entry.details?.rawToolOutputPaths;
     if (!Array.isArray(paths)) return [];
@@ -26607,7 +27096,7 @@ function formatDecimal(value) {
 function formatUsd(value) {
   return `$${formatDecimal(value)}`;
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stringField2(source, ...keys) {
@@ -26634,7 +27123,7 @@ function arrayField2(source, ...keys) {
 function recordField2(source, ...keys) {
   for (const key of keys) {
     const value = source[key];
-    if (isRecord8(value)) return value;
+    if (isRecord9(value)) return value;
   }
   return {};
 }
@@ -26700,7 +27189,7 @@ function parseJsonObjectArgument(raw, flagName) {
     }
     throw invalidJsonError(flagName, message);
   }
-  if (!isRecord8(parsed)) {
+  if (!isRecord9(parsed)) {
     throw invalidJsonError(flagName, "expected an object.");
   }
   return parsed;
@@ -26846,7 +27335,7 @@ function buildToolExecuteBaseEnvelope(input2) {
     kind: summaryEntries.length > 0 ? "object" : "raw",
     summary: input2.summary
   };
-  const envelopeHasCanonicalOutput = isRecord8(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
+  const envelopeHasCanonicalOutput = isRecord9(envelope.toolResponse) && Object.prototype.hasOwnProperty.call(envelope.toolResponse, "raw");
   const envelopeHasDeclaredOutput = Object.prototype.hasOwnProperty.call(
     envelope,
     "output"
@@ -27065,7 +27554,7 @@ async function executeTool(args) {
       {
         ...baseEnvelope,
         local: {
-          ...isRecord8(baseEnvelope.local) ? baseEnvelope.local : {},
+          ...isRecord9(baseEnvelope.local) ? baseEnvelope.local : {},
           payload_file: jsonPath
         }
       },