deepline 0.1.211 → 0.1.212

package/dist/cli/index.mjs

@@ -608,10 +608,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.211",
+  version: "0.1.212",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.211",
+    latest: "0.1.212",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -1344,9 +1344,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) {
@@ -1428,6 +1510,8 @@ function createEmptyPlayRunLedgerSnapshot(input2) {
     durationMs: startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : null,
     orderedStepIds: [],
     stepsById: {},
+    orderedDatasetIds: [],
+    datasetsById: {},
     logTail: [],
     totalLogCount: 0,
     logsTruncated: false,
@@ -1437,21 +1521,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),
@@ -1466,6 +1550,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;
@@ -1485,6 +1586,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.
@@ -1579,18 +1684,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(
@@ -1646,6 +1751,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 } : {}
@@ -2322,8 +2430,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) {
@@ -2480,7 +2589,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);
@@ -2595,9 +2704,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;
@@ -2646,7 +2755,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,
@@ -3580,7 +3689,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.
@@ -3731,6 +3879,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;
@@ -3794,6 +3943,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)) {
@@ -3843,6 +3993,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}`
@@ -3876,6 +4057,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 } : {}
     };
   }
@@ -7179,14 +7361,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);
@@ -7194,7 +7376,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];
@@ -7202,17 +7384,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;
 }
@@ -7236,7 +7418,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);
@@ -7326,7 +7508,7 @@ function collectDatasetCandidates(input2) {
     });
     return;
   }
-  if (!isRecord4(input2.value)) {
+  if (!isRecord5(input2.value)) {
     return;
   }
   for (const [key, child] of Object.entries(input2.value)) {
@@ -7343,12 +7525,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 = [
     {
@@ -7372,8 +7554,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(
       {
@@ -7400,14 +7582,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)
       });
     });
   }
@@ -7417,7 +7599,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) {
@@ -7434,37 +7616,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)) {
+  for (const output2 of datasets) {
+    if (!isRecord5(output2) || !isPackagedDatasetOutput(output2)) {
       continue;
     }
-    const output2 = step.output;
-    if (!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({
@@ -7472,7 +7650,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       path: "result",
       output: candidates
     });
-    if (isRecord4(result.output)) {
+    if (isRecord5(result.output)) {
       collectDatasetCandidates({
         value: result.output,
         path: "result",
@@ -7480,7 +7658,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       });
     }
   }
-  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
+  candidates.push(...collectPackagedDatasetCandidates(statusOrResult));
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
@@ -7544,13 +7722,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)) {
@@ -7581,7 +7759,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]);
@@ -8644,17 +8822,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 {
@@ -9216,7 +9394,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);
@@ -9249,16 +9427,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) : [];
@@ -9279,10 +9457,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 [];
 }
@@ -9296,7 +9474,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(" | ");
@@ -9326,7 +9504,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;
@@ -9502,14 +9680,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));
   }
@@ -9690,7 +9868,7 @@ function validateBootstrapRoutes(input2) {
   }
 }
 function staticPipelineSubsteps(pipeline) {
-  if (!isRecord5(pipeline)) return [];
+  if (!isRecord6(pipeline)) return [];
   return [
     ...extractionEntries(pipeline.stages),
     ...extractionEntries(pipeline.substeps)
@@ -9698,7 +9876,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;
@@ -9707,7 +9885,7 @@ function playUsesMapBackedRuntime(play) {
       aliases: [],
       runCommand: "",
       examples: [],
-      staticPipeline: isRecord5(substep.pipeline) ? substep.pipeline : null
+      staticPipeline: isRecord6(substep.pipeline) ? substep.pipeline : null
     });
   });
 }
@@ -12444,6 +12622,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;
@@ -12469,13 +12648,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;
@@ -12552,7 +12742,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",
@@ -12924,6 +13118,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.`;
   }
@@ -13075,7 +13273,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(
@@ -13275,15 +13473,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);
@@ -13306,6 +13533,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) } : {},
@@ -13313,6 +13541,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 : {};
 }
@@ -13432,6 +13670,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`;
@@ -13439,6 +13685,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;
@@ -13488,13 +13738,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) {
@@ -13503,6 +13774,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}`);
@@ -13527,12 +13799,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) {
@@ -13542,8 +13851,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")}
 `
@@ -13570,6 +13880,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));
@@ -13612,20 +13937,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;
 }
@@ -13760,37 +14092,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) {
@@ -13970,7 +14281,7 @@ function extractPlayValidationErrors(value) {
   if (value instanceof DeeplineError) {
     return extractPlayValidationErrors(value.details);
   }
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     return [];
   }
   const directErrors = stringArrayField(value, "errors");
@@ -14338,7 +14649,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) {
@@ -14348,14 +14659,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),
@@ -14373,12 +14684,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);
@@ -14392,9 +14703,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) => ({
@@ -14834,14 +15145,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",
@@ -14850,7 +15164,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(
@@ -14998,14 +15312,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",
@@ -15014,7 +15332,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(
@@ -15075,7 +15393,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;
       }
@@ -15092,7 +15410,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);
@@ -15102,7 +15420,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")
@@ -15191,7 +15510,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(
@@ -15204,7 +15553,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);
@@ -15214,6 +15563,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]) {
@@ -15224,6 +15574,12 @@ async function handleRunLogs(args) {
       outPath = resolve8(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 });
@@ -15255,7 +15611,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,
@@ -15267,18 +15624,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;
@@ -16177,8 +16549,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:
 
@@ -16487,13 +16859,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(
@@ -16537,13 +16914,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"] : [],
@@ -16560,17 +16941,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"] : []
     ]);
   });
@@ -18483,7 +18866,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();
@@ -18742,6 +19125,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) {
@@ -19199,7 +19603,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 = {}) {
@@ -19486,13 +19890,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()) {
@@ -19545,7 +19949,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) {
@@ -19614,11 +20018,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, {});
@@ -20156,7 +20560,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() : "";
@@ -20176,7 +20580,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)) {
@@ -20420,7 +20824,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
@@ -20428,12 +20832,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;
@@ -20503,7 +20907,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;
@@ -20667,10 +21071,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"]
       );
@@ -20700,7 +21104,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) {
@@ -20714,7 +21118,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;
@@ -20723,7 +21127,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"]);
@@ -20765,11 +21169,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(
@@ -20876,10 +21280,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);
@@ -20891,12 +21295,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"]),
@@ -20923,14 +21327,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 } : {},
@@ -20939,8 +21343,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,
@@ -20953,11 +21357,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,
@@ -20976,14 +21380,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) {
@@ -21595,7 +21999,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)) {
@@ -21609,7 +22013,7 @@ function compactArrayEnvelopeCompleteValue(value) {
 }
 function disambiguateCompactAiInferencePayload(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (!isRecord7(parsed) || !cellFailureError(parsed)) {
+  if (!isRecord8(parsed) || !cellFailureError(parsed)) {
     return value;
   }
   return {
@@ -21618,14 +22022,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);
@@ -21642,12 +22046,12 @@ 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")) {
@@ -21788,11 +22192,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"]);
@@ -21809,7 +22213,7 @@ function legacyMetadataFromRow(row) {
 }
 function parseLegacyMetadataCell(value) {
   const parsed = parseMaybeJsonObject(value);
-  if (isRecord7(parsed)) {
+  if (isRecord8(parsed)) {
     return parsed;
   }
   if (typeof value !== "string") {
@@ -21826,12 +22230,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;
         }
       }
@@ -21841,8 +22245,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
@@ -22112,11 +22516,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,
@@ -26350,7 +26758,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 }] : [];
@@ -26358,8 +26766,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 : [];
@@ -26376,7 +26784,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 ? "*" : "";
@@ -26389,7 +26797,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("");
@@ -26403,14 +26811,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)}`
         );
@@ -26423,7 +26831,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";
@@ -26443,7 +26851,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 ? "*" : "";
@@ -26473,10 +26881,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");
@@ -26512,7 +26920,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}`);
@@ -26525,7 +26933,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)}`
         );
@@ -26534,7 +26942,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)}`
         );
@@ -26560,7 +26968,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)]];
@@ -26678,12 +27086,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",
@@ -26712,15 +27120,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 [];
@@ -26736,7 +27144,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) {
@@ -26763,7 +27171,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 {};
 }
@@ -26829,7 +27237,7 @@ function parseJsonObjectArgument(raw, flagName) {
     }
     throw invalidJsonError(flagName, message);
   }
-  if (!isRecord8(parsed)) {
+  if (!isRecord9(parsed)) {
     throw invalidJsonError(flagName, "expected an object.");
   }
   return parsed;
@@ -26975,7 +27383,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"
@@ -27194,7 +27602,7 @@ async function executeTool(args) {
       {
         ...baseEnvelope,
         local: {
-          ...isRecord8(baseEnvelope.local) ? baseEnvelope.local : {},
+          ...isRecord9(baseEnvelope.local) ? baseEnvelope.local : {},
           payload_file: jsonPath
         }
       },