deepline 0.1.176 → 0.1.177

package/dist/cli/index.js

@@ -622,17 +622,18 @@ var SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: "0.1.176",
+  // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
+  version: "0.1.177",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.176",
+    latest: "0.1.177",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
       {
         command: "enrich",
-        minimumSupported: "0.1.154",
-        reason: "Older SDK CLI enrich generated stale play source; SDK CLI enrich 0.1.153 generated removed StepOptions fields in play source."
+        minimumSupported: "0.1.175",
+        reason: "Older SDK CLI enrich generated stale play source; SDK CLI enrich 0.1.153 generated removed StepOptions fields in play source; SDK CLI enrich before 0.1.175 could silently succeed on the empty-waterfall bug when a requested waterfall returned no values for selected rows."
       },
       {
         command: "plays",
@@ -17839,14 +17840,39 @@ function enrichOutputJson(exportResult) {
     ...exportResult.partial ? { rows: exportResult.rows, partial: true } : {}
   };
 }
+function enrichReportJson(report) {
+  if (!report) {
+    return {};
+  }
+  return {
+    ...report.jobs.length > 0 ? {
+      failure_report: {
+        path: report.path,
+        jobs: report.jobs.length
+      }
+    } : {},
+    ...report.issues.length > 0 ? {
+      enrich_issues: {
+        path: report.path,
+        issues: report.issues.length,
+        items: report.issues
+      }
+    } : {}
+  };
+}
 async function buildEnrichFailureReport(input2) {
+  const fallbackRowsInfo = input2.exportResult ? null : extractCanonicalRowsInfo(input2.status);
   return maybeEmitEnrichFailureReport({
     config: input2.config,
     rows: input2.rows,
     rowRange: input2.rowRange,
     client: input2.client,
     outputPath: input2.reportOutputPath ?? input2.exportResult?.path ?? input2.outputPath ?? null,
-    status: input2.status
+    followUpOutputPath: input2.followUpOutputPath,
+    status: input2.status,
+    rowSetComplete: input2.exportResult ? !input2.exportResult.partial : Boolean(
+      fallbackRowsInfo?.complete && input2.rows.length >= fallbackRowsInfo.totalRows
+    )
   });
 }
 function recordField(value, key) {
@@ -18123,7 +18149,7 @@ function emitPlainBatchRunFailure(input2) {
     `Batch ${input2.chunkIndex + 1}/${input2.chunkCount} failed for rows ${input2.rows.rowStart}:${input2.rows.rowEnd}.
 `
   );
-  const runId = extractRunId(input2.status);
+  const runId = extractRunId(input2.status) ?? firstCollectedStringField(input2.status, "runId");
   const error = firstCollectedStringField(input2.status, "error") ?? firstCollectedStringField(input2.status, "message");
   if (runId) {
     process.stderr.write(`Run id: ${runId}
@@ -18339,6 +18365,38 @@ function collectHardFailureAliasSpecs(config) {
   }
   return aliases;
 }
+function collectWaterfallAliasSpecs(config) {
+  const aliases = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const command of config.commands) {
+    if (!("with_waterfall" in command)) {
+      continue;
+    }
+    const alias = command.with_waterfall.trim();
+    if (!alias || seen.has(alias)) {
+      continue;
+    }
+    const activeChildren = command.commands.filter(
+      (child) => !("with_waterfall" in child) && !child.disabled
+    );
+    if (activeChildren.length === 0) {
+      continue;
+    }
+    seen.add(alias);
+    const childOperations = activeChildren.map((child) => child.operation?.trim() || child.tool.trim()).filter(Boolean);
+    aliases.push({
+      alias,
+      childAliases: activeChildren.map((child) => child.alias).filter(Boolean),
+      childToolsByAlias: new Map(
+        activeChildren.map(
+          (child) => [child.alias, child.tool.trim()]
+        )
+      ),
+      operation: childOperations.length > 0 ? childOperations.join(", ") : void 0
+    });
+  }
+  return aliases;
+}
 function hardFailureOperationByAlias(config) {
   const operations = /* @__PURE__ */ new Map();
   if (!config) {
@@ -18351,6 +18409,60 @@ function hardFailureOperationByAlias(config) {
   }
   return operations;
 }
+function isWaterfallResultMeaningful(value) {
+  if (Array.isArray(value)) {
+    return value.some(isWaterfallResultMeaningful);
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+    if (status === "error" || status === "failed") {
+      return false;
+    }
+    if (typeof record.error === "string" && record.error.trim()) {
+      return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(record, "matched_result")) {
+      return isWaterfallResultMeaningful(record.matched_result);
+    }
+    for (const key of [
+      "value",
+      "email",
+      "phone",
+      "phone_number",
+      "mobile_phone",
+      "mobile_phone_number",
+      "url",
+      "domain",
+      "name",
+      "result",
+      "data"
+    ]) {
+      if (isWaterfallResultMeaningful(record[key])) {
+        return true;
+      }
+    }
+    return Object.entries(record).some(
+      ([key, entry]) => !ENRICH_FLATTENED_CONTROL_FIELDS.has(key) && isWaterfallResultMeaningful(entry)
+    );
+  }
+  return isNonEmptyCsvCell(value);
+}
+function aliasHasMeaningfulResult(row, alias) {
+  return aliasFailureCellCandidates(row, alias).some(
+    isWaterfallResultMeaningful
+  );
+}
+function stableRowSnapshot(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableRowSnapshot).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableRowSnapshot(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
 function cellFailureError(value) {
   const parsed = parseMaybeJsonObject(value);
   if (!isRecord7(parsed)) {
@@ -18496,6 +18608,112 @@ function collectEnrichFailureJobs(input2) {
   });
   return jobs;
 }
+function collectEmptyWaterfallIssues(input2) {
+  const aliases = collectWaterfallAliasSpecs(input2.config);
+  if (aliases.length === 0 || input2.rows.length === 0 || !input2.rowSetComplete) {
+    return [];
+  }
+  const runId = extractRunId(input2.status) ?? firstCollectedStringField(input2.status, "runId");
+  const followUpCommands = collectEnrichFollowUpCommands({
+    status: input2.status,
+    runId,
+    outputPath: input2.followUpOutputPath ?? input2.outputPath
+  });
+  const issues = [];
+  aliases.forEach((spec) => {
+    if (waterfallExecutionSignal(input2.status, spec) === "all_condition_skipped") {
+      return;
+    }
+    const logicalRows = /* @__PURE__ */ new Map();
+    input2.rows.forEach((row, rowIndex) => {
+      const sourceRowId = sourceRowIndexFromEnrichRow(
+        row,
+        0,
+        Number.MAX_SAFE_INTEGER
+      );
+      const rowKey = sourceRowId !== null ? `source:${sourceRowId}` : `snapshot:${stableRowSnapshot(row)}`;
+      const existing = logicalRows.get(rowKey);
+      const hasMeaningfulResult = aliasHasMeaningfulResult(row, spec.alias);
+      logicalRows.set(rowKey, {
+        hasMeaningfulResult: (existing?.hasMeaningfulResult ?? false) || hasMeaningfulResult
+      });
+    });
+    const emptyRows = Array.from(logicalRows.values()).filter(
+      (row) => !row.hasMeaningfulResult
+    );
+    if (emptyRows.length !== logicalRows.size) {
+      return;
+    }
+    const selectedRows = logicalRows.size;
+    const message = `Waterfall ${spec.alias} produced 0 values for ${selectedRows} selected row(s).`;
+    issues.push({
+      issue_id: `${spec.alias}-empty-waterfall`,
+      kind: "empty_waterfall",
+      severity: "needs_attention",
+      column: spec.alias,
+      selected_rows: selectedRows,
+      rows_with_value: 0,
+      rows_without_value: selectedRows,
+      message,
+      next_steps: enrichIssueNextSteps({ runId }),
+      follow_up_commands: followUpCommands,
+      ...spec.operation ? { operation: spec.operation } : {},
+      ...runId ? { run_id: runId } : {}
+    });
+  });
+  return issues;
+}
+function waterfallExecutionSignal(status, spec) {
+  const childAliases = spec.childAliases ?? [];
+  if (childAliases.length === 0) {
+    return "unknown";
+  }
+  const summaries = collectColumnStats(status);
+  let sawChildStats = false;
+  let everyChildStatOnlyConditionSkipped = true;
+  const childAliasesWithStats = /* @__PURE__ */ new Set();
+  for (const childAlias of childAliases) {
+    for (const stat2 of summaries.map((summary) => summary[childAlias]).filter(isRecord7)) {
+      sawChildStats = true;
+      childAliasesWithStats.add(childAlias);
+      const execution = isRecord7(stat2.execution) ? stat2.execution : null;
+      const executedSummary = parseExecutionSummary(
+        execution?.["completed:executed"]
+      );
+      const skippedConditionSummary = parseExecutionSummary(
+        execution?.["skipped:condition"]
+      );
+      const executedCount = executedSummary?.count ?? 0;
+      const skippedConditionCount = skippedConditionSummary?.count ?? 0;
+      const totalCount = executedSummary?.total ?? skippedConditionSummary?.total;
+      const onlyConditionSkips = totalCount !== void 0 && skippedConditionCount >= totalCount && executedCount <= skippedConditionCount;
+      if (executedCount > 0 && !onlyConditionSkips || numericFailedRowSignal(execution?.failed) > 0 || numericFailedRowSignal(stat2.failed) > 0 || numericFailedRowSignal(stat2.failedRows) > 0) {
+        return "executed";
+      }
+      if (!onlyConditionSkips) {
+        everyChildStatOnlyConditionSkipped = false;
+      }
+    }
+  }
+  if (sawChildStats && childAliasesWithStats.size === childAliases.length && everyChildStatOnlyConditionSkipped) {
+    return "all_condition_skipped";
+  }
+  return "unknown";
+}
+function mergeEnrichFailureJobs(...jobGroups) {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const jobs of jobGroups) {
+    for (const job of jobs) {
+      if (seen.has(job.job_id)) {
+        continue;
+      }
+      seen.add(job.job_id);
+      merged.push(job);
+    }
+  }
+  return merged;
+}
 function collectStatusFailureJobs(input2) {
   const aliases = collectHardFailureAliasSpecs(input2.config);
   if (aliases.length === 0) {
@@ -18589,14 +18807,23 @@ function collectCompleteStatusFailureMessages(input2) {
   return complete;
 }
 function parseExecutionCount(value) {
+  return parseExecutionSummary(value)?.count ?? null;
+}
+function parseExecutionSummary(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
-    return Math.max(0, Math.trunc(value));
+    return { count: Math.max(0, Math.trunc(value)) };
   }
   if (typeof value !== "string") {
     return null;
   }
-  const match = value.trim().match(/^(\d+)\s*\//);
-  return match?.[1] ? Number.parseInt(match[1], 10) : null;
+  const match = value.trim().match(/^(\d+)(?:\s*\/\s*(\d+))?/);
+  if (!match?.[1]) {
+    return null;
+  }
+  return {
+    count: Number.parseInt(match[1], 10),
+    ...match[2] ? { total: Number.parseInt(match[2], 10) } : {}
+  };
 }
 function executionSummaryText(count, total) {
   const percent = total > 0 ? Math.round(count / total * 100) : 0;
@@ -18722,19 +18949,145 @@ function summarizeFailedJobError(value) {
   const text = String(value ?? "").trim();
   return text.length > 500 ? `${text.slice(0, 497)}...` : text;
 }
+function shellSingleQuote2(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function addEnrichFollowUpCommand(commands, seen, command) {
+  const normalized = command.command.trim();
+  if (!normalized || seen.has(normalized)) {
+    return;
+  }
+  seen.add(normalized);
+  commands.push({ ...command, command: normalized });
+}
+function datasetSelectorForEnrichCommand(record, fallbackPath) {
+  const candidates = [record.path, record.tableNamespace, fallbackPath];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return null;
+}
+function collectEnrichFollowUpCommands(input2) {
+  const commands = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (input2.runId) {
+    addEnrichFollowUpCommand(commands, seen, {
+      label: "inspect run",
+      command: `deepline runs get ${input2.runId} --full --json`
+    });
+  }
+  collectDatasetFollowUpCommands(input2.status, {
+    runId: input2.runId,
+    outputPath: input2.outputPath,
+    commands,
+    seen,
+    path: "result",
+    depth: 0
+  });
+  if (input2.runId && input2.outputPath && !commands.some((command) => command.label === "export enrich rows")) {
+    addEnrichFollowUpCommand(commands, seen, {
+      label: "export enrich rows",
+      path: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE,
+      command: `deepline runs export ${input2.runId} --dataset ${GENERATED_ENRICH_ROWS_TABLE_NAMESPACE} --out ${shellSingleQuote2(
+        (0, import_node_path12.resolve)(input2.outputPath)
+      )}`
+    });
+  }
+  return commands.slice(0, 8);
+}
+function sidecarEnrichRowsExportPath(outputPath) {
+  const resolved = (0, import_node_path12.resolve)(outputPath);
+  const ext = (0, import_node_path12.extname)(resolved) || ".csv";
+  const stem = (0, import_node_path12.basename)(resolved, ext);
+  return (0, import_node_path12.join)((0, import_node_path12.dirname)(resolved), `${stem}.deepline-enrich-rows${ext}`);
+}
+function collectDatasetFollowUpCommands(value, state) {
+  if (state.depth > 12 || !value || typeof value !== "object" || state.commands.length >= 8) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.slice(0, 50).forEach(
+      (entry, index) => collectDatasetFollowUpCommands(entry, {
+        ...state,
+        path: `${state.path}.${index}`,
+        depth: state.depth + 1
+      })
+    );
+    return;
+  }
+  const record = value;
+  const isDataset = record.kind === "dataset";
+  if (isDataset) {
+    const selector = datasetSelectorForEnrichCommand(record, state.path);
+    const labelPath = typeof record.path === "string" && record.path.trim() ? record.path.trim() : selector ?? state.path;
+    if (typeof record.queryDatasetCommand === "string") {
+      addEnrichFollowUpCommand(state.commands, state.seen, {
+        label: `query ${labelPath}`,
+        path: labelPath,
+        command: record.queryDatasetCommand
+      });
+    }
+    const exportCommand = typeof record.slowExportAsCsvCommand === "string" ? record.slowExportAsCsvCommand : typeof record.fullExportCommand === "string" ? record.fullExportCommand : null;
+    if (exportCommand) {
+      addEnrichFollowUpCommand(state.commands, state.seen, {
+        label: `export ${labelPath}`,
+        path: labelPath,
+        command: exportCommand
+      });
+    } else if (state.runId && state.outputPath && selector) {
+      addEnrichFollowUpCommand(state.commands, state.seen, {
+        label: selector === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE ? "export enrich rows" : `export ${labelPath}`,
+        path: selector,
+        command: `deepline runs export ${state.runId} --dataset ${shellSingleQuote2(
+          selector
+        )} --out ${shellSingleQuote2((0, import_node_path12.resolve)(state.outputPath))}`
+      });
+    }
+  }
+  for (const [key, child] of Object.entries(record)) {
+    if (key === "preview" || key === "access") {
+      continue;
+    }
+    collectDatasetFollowUpCommands(child, {
+      ...state,
+      path: `${state.path}.${key}`,
+      depth: state.depth + 1
+    });
+    if (state.commands.length >= 8) {
+      return;
+    }
+  }
+}
+function enrichIssueNextSteps(input2) {
+  const steps = [
+    "Inspect the run output and returned dataset handles.",
+    "If runs get returns queryDatasetCommand or slowExportAsCsvCommand, run that command to fetch durable rows from the customer DB.",
+    "For provider-backed waterfalls, execute the child provider tool on a sample row to confirm the provider returns the expected field."
+  ];
+  if (!input2.runId) {
+    return steps;
+  }
+  return [
+    `Inspect run output: deepline runs get ${input2.runId} --full --json`,
+    ...steps.slice(1)
+  ];
+}
 function formatFailureReportCommand(reportPath) {
   const quoted = reportPath.replace(/'/g, `'\\''`);
   return `Inspect failed jobs: jq -r '.jobs[] | [.job_id,.row_id,.col_index,.column,.status,.last_error] | @tsv' '${quoted}'`;
 }
 async function persistEnrichFailureReport(input2) {
-  if (input2.jobs.length === 0) {
+  if (input2.jobs.length === 0 && input2.issues.length === 0) {
     return null;
   }
   const stateDir = (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".local", "deepline", "runtime", "state");
+  const reportPrefix = input2.jobs.length > 0 ? "run-block-failures" : "enrich-issues";
   await (0, import_promises3.mkdir)(stateDir, { recursive: true });
   const reportPath = (0, import_node_path12.join)(
     stateDir,
-    `run-block-failures-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
+    `${reportPrefix}-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
   );
   const report = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18749,6 +19102,7 @@ async function persistEnrichFailureReport(input2) {
     },
     jobs: input2.jobs,
     failed_jobs: input2.jobs,
+    enrich_issues: input2.issues,
     canceled_jobs: [],
     pending_jobs: [],
     missing_job_ids: []
@@ -18761,48 +19115,100 @@ async function persistEnrichFailureReport(input2) {
   return reportPath;
 }
 async function maybeEmitEnrichFailureReport(input2) {
+  const fallbackRowsInfo = extractCanonicalRowsInfo(input2.status);
+  const rowSetComplete = input2.rowSetComplete ?? Boolean(
+    fallbackRowsInfo?.complete && input2.rows.length >= fallbackRowsInfo.totalRows
+  );
   const rowJobs = collectEnrichFailureJobs({
     config: input2.config,
     rows: input2.rows,
     rowStart: input2.rowRange.rowStart
   });
-  const jobs = rowJobs.length > 0 || input2.status === void 0 ? rowJobs : collectStatusFailureJobs({
+  const enrichIssues = collectEmptyWaterfallIssues({
+    config: input2.config,
+    rows: input2.rows,
+    status: input2.waterfallStatus ?? input2.status,
+    outputPath: input2.outputPath,
+    followUpOutputPath: input2.followUpOutputPath,
+    rowSetComplete
+  });
+  const statusJobs = input2.status === void 0 || rowJobs.length > 0 ? [] : collectStatusFailureJobs({
     config: input2.config,
     status: input2.status,
     rowRange: input2.statusRowRange ?? input2.rowRange
   });
-  if (jobs.length === 0) {
+  const jobs = rowJobs.length > 0 || statusJobs.length > 0 || input2.status === void 0 ? mergeEnrichFailureJobs(rowJobs, statusJobs) : [];
+  if (jobs.length === 0 && enrichIssues.length === 0) {
     return null;
   }
   const reportPath = await persistEnrichFailureReport({
     jobs,
+    issues: enrichIssues,
     apiUrl: input2.client.baseUrl,
     outputPath: input2.outputPath,
     rows: input2.rowRange
   });
-  process.stderr.write("Execution failed.\n");
-  process.stderr.write("Failure preview (up to 5 failed jobs):\n");
-  process.stderr.write("job_id	row_id	col_index	column	status	error\n");
-  for (const job of jobs.slice(0, 5)) {
-    process.stderr.write(
-      `${job.job_id}	${job.row_id}	${job.col_index}	${job.column}	${job.status}	${summarizeFailedJobError(job.last_error)}
+  if (jobs.length > 0) {
+    process.stderr.write("Execution failed.\n");
+    process.stderr.write("Failure preview (up to 5 failed jobs):\n");
+    process.stderr.write("job_id	row_id	col_index	column	status	error\n");
+    for (const job of jobs.slice(0, 5)) {
+      process.stderr.write(
+        `${job.job_id}	${job.row_id}	${job.col_index}	${job.column}	${job.status}	${summarizeFailedJobError(job.last_error)}
 `
-    );
+      );
+    }
+    if (jobs.length > 5) {
+      process.stderr.write(`Showing 5 of ${jobs.length} failed jobs.
+`);
+    }
   }
-  if (jobs.length > 5) {
-    process.stderr.write(`Showing 5 of ${jobs.length} failed jobs.
+  if (enrichIssues.length > 0) {
+    process.stderr.write("Enrichment needs attention.\n");
+    process.stderr.write("Issue preview (up to 5 enrichment issues):\n");
+    process.stderr.write(
+      "issue_id	column	severity	selected_rows	rows_with_value	message\n"
+    );
+    for (const issue of enrichIssues.slice(0, 5)) {
+      process.stderr.write(
+        `${issue.issue_id}	${issue.column}	${issue.severity}	${issue.selected_rows}	${issue.rows_with_value}	${issue.message}
+`
+      );
+      for (const step of issue.next_steps.slice(0, 2)) {
+        process.stderr.write(`Next: ${step}
+`);
+      }
+      for (const command of issue.follow_up_commands.slice(0, 4)) {
+        process.stderr.write(`Command: ${command.label}: ${command.command}
 `);
+      }
+    }
+    if (enrichIssues.length > 5) {
+      process.stderr.write(
+        `Showing 5 of ${enrichIssues.length} enrichment issues.
+`
+      );
+    }
   }
   if (reportPath) {
-    process.stderr.write(`Full failure report: ${reportPath}
+    if (jobs.length > 0) {
+      process.stderr.write(`Full failure report: ${reportPath}
 `);
-    process.stderr.write(`${formatFailureReportCommand(reportPath)}
+      process.stderr.write(`${formatFailureReportCommand(reportPath)}
 `);
-    process.stderr.write("Enrichment failed. See failure report above.\n");
-    return { path: reportPath, jobs };
+    } else {
+      process.stderr.write(`Full enrich report: ${reportPath}
+`);
+    }
+    process.stderr.write(
+      jobs.length > 0 ? "Enrichment failed. See report above.\n" : "Enrichment produced no values for at least one requested waterfall. See issue preview above.\n"
+    );
+    return { path: reportPath, jobs, issues: enrichIssues };
   }
-  process.stderr.write("Enrichment failed.\n");
-  return { path: "", jobs };
+  process.stderr.write(
+    jobs.length > 0 ? "Enrichment failed.\n" : "Enrichment needs attention.\n"
+  );
+  return { path: "", jobs, issues: enrichIssues };
 }
 function mergePreferredColumns(preferredColumns, rows) {
   const columns = [];
@@ -19468,6 +19874,7 @@ function registerEnrichCommand(program) {
     const inPlaceFinalOutputPath = options.inPlace ? (0, import_node_path12.resolve)(inputCsv) : null;
     const inPlaceCommitOutputPath = options.inPlace ? (await (0, import_promises3.lstat)(inputCsv)).isSymbolicLink() ? await (0, import_promises3.realpath)(inputCsv) : inPlaceFinalOutputPath : null;
     const failureReportOutputPath = options.inPlace ? inPlaceFinalOutputPath : null;
+    const enrichIssueFollowUpOutputPath = options.inPlace && inPlaceFinalOutputPath ? sidecarEnrichRowsExportPath(inPlaceFinalOutputPath) : null;
     let inPlaceCommitted = false;
     const commitInPlaceOutput = async (exportResult) => {
       if (!inPlaceTempOutputPath || !inPlaceCommitOutputPath || !inPlaceFinalOutputPath) {
@@ -19556,6 +19963,7 @@ function registerEnrichCommand(program) {
         }
         let workingMergeSourceCsvPath = sourceCsvPath;
         let lastStatus = null;
+        const batchStatuses = [];
         let finalExportResult = null;
         let totalEnrichedRows = 0;
         const batchFailureRows = [];
@@ -19593,6 +20001,7 @@ function registerEnrichCommand(program) {
             suppressOpen: true
           });
           lastStatus = chunk.status;
+          batchStatuses.push(chunk.status);
           if (chunk.captured.result !== 0) {
             if (chunk.exportResult) {
               finalExportResult = chunk.exportResult;
@@ -19612,7 +20021,10 @@ function registerEnrichCommand(program) {
               statusRowRange: chunkRows,
               client: client2,
               outputPath: failureReportOutputPath ?? finalExportResult?.path ?? outputPath,
-              status: chunk.status
+              followUpOutputPath: enrichIssueFollowUpOutputPath,
+              status: chunk.status,
+              waterfallStatus: batchStatuses,
+              ...finalExportResult ? { rowSetComplete: !finalExportResult.partial } : {}
             });
             const committedExportResult2 = finalExportResult ? await commitInPlaceOutput(finalExportResult) : null;
             if (options.json) {
@@ -19634,12 +20046,7 @@ function registerEnrichCommand(program) {
                     partial: true
                   } : {}
                 } : null,
-                ...failureReport3 ? {
-                  failure_report: {
-                    path: failureReport3.path,
-                    jobs: failureReport3.jobs.length
-                  }
-                } : {}
+                ...enrichReportJson(failureReport3)
               });
             } else {
               if (committedExportResult2) {
@@ -19678,7 +20085,10 @@ function registerEnrichCommand(program) {
           },
           client: client2,
           outputPath: failureReportOutputPath ?? finalExportResult?.path ?? outputPath,
-          status: lastStatus
+          followUpOutputPath: enrichIssueFollowUpOutputPath,
+          status: lastStatus,
+          waterfallStatus: batchStatuses,
+          ...finalExportResult ? { rowSetComplete: !finalExportResult.partial } : {}
         });
         finalExportResult = await commitInPlaceOutput(finalExportResult);
         if (options.json) {
@@ -19710,12 +20120,7 @@ function registerEnrichCommand(program) {
               enrichedRows: totalEnrichedRows,
               path: finalExportResult.path
             } : null,
-            ...failureReport2 ? {
-              failure_report: {
-                path: failureReport2.path,
-                jobs: failureReport2.jobs.length
-              }
-            } : {}
+            ...enrichReportJson(failureReport2)
           });
         }
         if (failureReport2) {
@@ -19746,6 +20151,7 @@ function registerEnrichCommand(program) {
           exportResult: committedExportResult2,
           outputPath,
           reportOutputPath: failureReportOutputPath,
+          followUpOutputPath: enrichIssueFollowUpOutputPath,
           status
         });
         if (options.json) {
@@ -19753,12 +20159,7 @@ function registerEnrichCommand(program) {
             ok: false,
             run: status,
             output: enrichOutputJson(committedExportResult2),
-            ...failureReport2 ? {
-              failure_report: {
-                path: failureReport2.path,
-                jobs: failureReport2.jobs.length
-              }
-            } : {}
+            ...enrichReportJson(failureReport2)
           });
         }
         process.exitCode = failureReport2 ? EXIT_SERVER2 : captured.result;
@@ -19773,6 +20174,7 @@ function registerEnrichCommand(program) {
           exportResult,
           outputPath,
           reportOutputPath: failureReportOutputPath,
+          followUpOutputPath: enrichIssueFollowUpOutputPath,
           status
         });
         const committedExportResult2 = await commitInPlaceOutput(exportResult);
@@ -19787,12 +20189,7 @@ function registerEnrichCommand(program) {
           ok: !failureReport2,
           run,
           output: enrichOutputJson(committedExportResult2),
-          ...failureReport2 ? {
-            failure_report: {
-              path: failureReport2.path,
-              jobs: failureReport2.jobs.length
-            }
-          } : {}
+          ...enrichReportJson(failureReport2)
         });
         if (failureReport2) {
           process.exitCode = EXIT_SERVER2;
@@ -19805,7 +20202,9 @@ function registerEnrichCommand(program) {
         rowRange: rows,
         client: client2,
         outputPath: failureReportOutputPath ?? exportResult?.path ?? null,
-        status
+        followUpOutputPath: enrichIssueFollowUpOutputPath,
+        status,
+        ...exportResult ? { rowSetComplete: !exportResult.partial } : {}
       });
       const committedExportResult = await commitInPlaceOutput(exportResult);
       if (committedExportResult) {