deepline 0.1.175 → 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.175",
+  // 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.175",
+    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",
@@ -886,9 +887,10 @@ var HttpClient = class {
       headers["Content-Type"] = "application/json";
     }
     let lastError = null;
-    const candidateUrls = buildCandidateUrls(url);
+    const candidateUrls = options?.exactUrlOnly ? [url] : buildCandidateUrls(url);
     let retryAfterDelayMs = null;
-    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+    const maxRetries = options?.maxRetries ?? this.config.maxRetries;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
       if (attempt > 0) {
         const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
         const delayMs = retryAfterDelayMs === null ? backoffMs : Math.max(backoffMs, retryAfterDelayMs);
@@ -915,7 +917,7 @@ var HttpClient = class {
           if (response.status === 429) {
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
-            if (attempt < this.config.maxRetries) {
+            if (attempt < maxRetries) {
               retryAfterDelayMs = retryAfter;
               break;
             }
@@ -945,7 +947,7 @@ var HttpClient = class {
                   ...htmlError.workerThrewException ? { workerThrewException: true } : {}
                 }
               );
-              if (retryableApiError && attempt < this.config.maxRetries) {
+              if (retryableApiError && attempt < maxRetries) {
                 retryAfterDelayMs = parseOptionalRetryAfter(response);
                 break;
               }
@@ -957,7 +959,7 @@ var HttpClient = class {
             lastError = new DeeplineError(msg, response.status, apiErrorCode, {
               response: parsed
             });
-            if (retryableApiError && attempt < this.config.maxRetries) {
+            if (retryableApiError && attempt < maxRetries) {
               retryAfterDelayMs = parseOptionalRetryAfter(response);
               break;
             }
@@ -976,7 +978,7 @@ var HttpClient = class {
           lastError = error instanceof Error ? error : new Error(String(error));
         }
       }
-      if (attempt < this.config.maxRetries) continue;
+      if (attempt < maxRetries) continue;
     }
     if (lastError instanceof DeeplineError) {
       throw lastError;
@@ -2111,6 +2113,7 @@ var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES = 25e5;
+var DEEPLINEAGENT_EXECUTE_TIMEOUT_MS = 15 * 60 * 1e3;
 function normalizePlayRunIntegrationMode(value) {
   if (value === "live" || value === "eval_stub" || value === "fixture") {
     return value;
@@ -2185,6 +2188,10 @@ function chunkRegisterPlayArtifacts(artifacts) {
   }
   return chunks;
 }
+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 RUN_LOGS_PAGE_LIMIT = 1e3;
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -2624,7 +2631,12 @@ var DeeplineClient = class {
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       { payload: input2 },
       headers,
-      { forbiddenAsApiError: true }
+      {
+        forbiddenAsApiError: true,
+        timeout: options?.timeout ?? resolveToolExecuteTimeoutMs(toolId),
+        maxRetries: options?.maxRetries ?? 0,
+        exactUrlOnly: true
+      }
     );
   }
   /**
@@ -4572,10 +4584,21 @@ function failureMessageFromRecord(value) {
   }
   return directError || resultError || `Column status: ${status}`;
 }
-function flattenObjectColumns(row) {
+function shouldPreserveJsonStringColumn(columns, key) {
+  if (!columns) {
+    return false;
+  }
+  if (columns.has(key)) {
+    return true;
+  }
+  const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return normalizedKey ? columns.has(normalizedKey) : false;
+}
+function flattenObjectColumns(row, options = {}) {
   const flattened = {};
   for (const [key, rawValue] of Object.entries(row)) {
     const value = parseMaybeJsonObject(rawValue);
+    const parsedFromString = typeof rawValue === "string" && value !== rawValue;
     if (key === "_metadata") {
       flattened[key] = value && typeof value === "object" ? JSON.stringify(value) : value;
       continue;
@@ -4586,6 +4609,10 @@ function flattenObjectColumns(row) {
       if (hasMatchedEnvelope) {
         flattened[key] = JSON.stringify(record);
         continue;
+      }
+      if (parsedFromString && shouldPreserveJsonStringColumn(options.preserveJsonStringColumns, key)) {
+        flattened[key] = rawValue;
+        continue;
       } else {
         const failureMessage = failureMessageFromRecord(record);
         if (failureMessage) {
@@ -4610,8 +4637,8 @@ function recordRows(value) {
     (row) => Boolean(row) && typeof row === "object" && !Array.isArray(row)
   );
 }
-function dataExportRows(rows) {
-  return rows.map((row) => flattenObjectColumns(row));
+function dataExportRows(rows, options = {}) {
+  return rows.map((row) => flattenObjectColumns(row, options));
 }
 function dataExportColumns(rows, preferredColumns = []) {
   const discoveredColumns = [
@@ -16883,7 +16910,8 @@ function helperSource() {
 // src/cli/commands/enrich.ts
 var ENRICH_EXPORT_PAGE_SIZE = 5e3;
 var ENRICH_AUTO_BATCH_ROWS = 250;
-var ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS = 40;
+var ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS = 25;
+var ENRICH_NESTED_PROVIDER_AUTO_BATCH_ROWS = 50;
 var ENRICH_EXPORT_BACKING_ROWS_WAIT_MS = 6e4;
 var ENRICH_EXPORT_BACKING_ROWS_POLL_MS = 1e3;
 var ENRICH_SOURCE_ROW_INDEX_COLUMN = "__deeplineSourceRowIndex";
@@ -16898,6 +16926,12 @@ var HEAVY_ENRICH_AUTO_BATCH_PLAYS = /* @__PURE__ */ new Set([
   "company-to-contact-by-role-waterfall",
   "company_to_contact_by_role_waterfall"
 ]);
+var HEAVY_ENRICH_AUTO_BATCH_TOOLS = /* @__PURE__ */ new Set([
+  "ai_inference",
+  "aiinference",
+  "deeplineagent"
+]);
+var ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER = "__deeplineTestAiInference";
 var PLAN_SHAPING_OPTION_NAMES = [
   "with",
   "withWaterfall",
@@ -16915,6 +16949,15 @@ function normalizeAlias2(value) {
 function hasPlanShapingArgs(args) {
   return optionWasProvided(args, "--with") || optionWasProvided(args, "--with-waterfall") || optionWasProvided(args, "--min-results") || optionWasProvided(args, "--end-waterfall");
 }
+function isMarkedTestAiInferenceCommand(command) {
+  if ("with_waterfall" in command) {
+    return false;
+  }
+  if (normalizeEnrichPlayRef(command.tool) !== "run_javascript") {
+    return false;
+  }
+  return isRecord7(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();
   if (["1", "true", "yes", "on"].includes(raw)) {
@@ -17682,8 +17725,6 @@ function normalizeEnrichPlayRef(value) {
   return normalized || null;
 }
 function configContainsHeavyEnrichPlay(config) {
-  let hasNestedPlayStep = false;
-  let hasSubrequestProviderStep = false;
   const visit = (commands) => {
     for (const command of commands) {
       if ("with_waterfall" in command) {
@@ -17707,18 +17748,67 @@ function configContainsHeavyEnrichPlay(config) {
         return true;
       }
       const normalizedTool = normalizeEnrichPlayRef(command.tool);
+      const normalizedOperation = normalizeEnrichPlayRef(command.operation);
+      if (isMarkedTestAiInferenceCommand(command) || normalizedTool && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedTool) || normalizedOperation && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedOperation)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  return visit(config.commands);
+}
+function configContainsNestedProviderEnrichWorkload(config) {
+  let hasNestedPlayStep = false;
+  let hasSubrequestProviderStep = false;
+  const visit = (commands) => {
+    for (const command of commands) {
+      if ("with_waterfall" in command) {
+        visit(command.commands);
+        continue;
+      }
+      if (command.disabled) {
+        continue;
+      }
+      const normalizedTool = normalizeEnrichPlayRef(command.tool);
       if (command.play || normalizedTool === "test-play") {
         hasNestedPlayStep = true;
       } else if (normalizedTool !== null && normalizedTool !== "run_javascript") {
         hasSubrequestProviderStep = true;
       }
     }
-    return false;
   };
-  return visit(config.commands) || hasNestedPlayStep && hasSubrequestProviderStep;
+  visit(config.commands);
+  return hasNestedPlayStep && hasSubrequestProviderStep;
 }
 function enrichAutoBatchRowsForConfig(config) {
-  return configContainsHeavyEnrichPlay(config) ? ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS : ENRICH_AUTO_BATCH_ROWS;
+  if (configContainsHeavyEnrichPlay(config)) {
+    return ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS;
+  }
+  if (configContainsNestedProviderEnrichWorkload(config)) {
+    return ENRICH_NESTED_PROVIDER_AUTO_BATCH_ROWS;
+  }
+  return ENRICH_AUTO_BATCH_ROWS;
+}
+function enrichAiRuntimeCompactAliases(config) {
+  const aliases = /* @__PURE__ */ new Set();
+  const visit = (commands) => {
+    for (const command of commands) {
+      if ("with_waterfall" in command) {
+        visit(command.commands);
+        continue;
+      }
+      if (command.disabled) {
+        continue;
+      }
+      const normalizedTool = normalizeEnrichPlayRef(command.tool);
+      const normalizedOperation = normalizeEnrichPlayRef(command.operation);
+      if (isMarkedTestAiInferenceCommand(command) || normalizedTool && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedTool) || normalizedOperation && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedOperation)) {
+        aliases.add(normalizeAlias2(command.alias));
+      }
+    }
+  };
+  visit(config.commands);
+  return aliases;
 }
 async function maybeWriteOutputCsv(input2) {
   if (!input2.outputPath) return null;
@@ -17750,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) {
@@ -17814,6 +17929,52 @@ function selectedSourceCsvRange(sourceCsvPath, rows) {
     sourceRows
   };
 }
+function compactRuntimeCsvCell(value) {
+  const parsed = parseMaybeJsonObject(value);
+  const compacted = compactAiInferenceCellForCsv(parsed);
+  return materializeCsvCellValue(compacted);
+}
+async function writeSlimBatchedRuntimeCsv(input2) {
+  const cleanRows = readCsvRows(input2.cleanSourceCsvPath).map(
+    (row) => ({ ...row })
+  );
+  const mergeRows = readCsvRows(input2.mergeSourceCsvPath);
+  const preserveJsonStringColumns = /* @__PURE__ */ new Set([
+    ...cleanRows.flatMap((row) => Object.keys(row)),
+    ...mergeRows.flatMap((row) => Object.keys(row))
+  ]);
+  const selectedRange = selectedSourceCsvRange(
+    input2.mergeSourceCsvPath,
+    input2.rows
+  );
+  for (let rowIndex = selectedRange.start; rowIndex <= selectedRange.end; rowIndex += 1) {
+    const mergeRow = mergeRows[rowIndex];
+    if (!mergeRow) {
+      continue;
+    }
+    const baseRow = cleanRows[rowIndex] ?? {};
+    const compactOverlayCell = ([key, value]) => {
+      return [
+        key,
+        input2.compactAliases.has(normalizeAlias2(key)) ? compactRuntimeCsvCell(value) : value
+      ];
+    };
+    cleanRows[rowIndex] = {
+      ...baseRow,
+      ...Object.fromEntries(
+        Object.entries(mergeRow).map(compactOverlayCell)
+      )
+    };
+  }
+  const columns = dataExportColumns(
+    dataExportRows(cleanRows, { preserveJsonStringColumns })
+  );
+  await (0, import_promises3.writeFile)(
+    input2.outputPath,
+    csvStringFromRows(cleanRows, columns),
+    "utf8"
+  );
+}
 function selectedSourceCsvRowCount(options) {
   if (!options?.sourceCsvPath) {
     return null;
@@ -17988,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}
@@ -18120,6 +18281,22 @@ function mergeExportedSheetRow(target, next) {
     target._metadata = metadata;
   }
 }
+function countEnrichedRowsInSourceRange(exportResult, rows) {
+  const start = Math.max(0, rows.rowStart ?? 0);
+  const end = rows.rowEnd === null || rows.rowEnd === void 0 ? Number.MAX_SAFE_INTEGER : Math.max(start, rows.rowEnd);
+  const rowIndexes = /* @__PURE__ */ new Set();
+  for (const row of exportResult.enrichedDataRows) {
+    const rowIndex = sourceRowIndexFromEnrichRow(row, start, end);
+    if (rowIndex !== null) {
+      rowIndexes.add(rowIndex);
+    }
+  }
+  if (rowIndexes.size > 0) {
+    return rowIndexes.size;
+  }
+  const selectedRows = end === Number.MAX_SAFE_INTEGER ? exportResult.enrichedRows : end - start + 1;
+  return Math.min(exportResult.enrichedRows, Math.max(0, selectedRows));
+}
 function coalesceExportableSheetRows(rows, sourceRowStart = 0) {
   const mergedRows = [];
   const bySourceRowIndex = /* @__PURE__ */ new Map();
@@ -18188,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) {
@@ -18200,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)) {
@@ -18345,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) {
@@ -18438,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;
@@ -18571,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(),
@@ -18598,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: []
@@ -18610,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 = [];
@@ -18751,10 +19308,12 @@ async function fetchBackingRowsForCsvExport(input2) {
   };
 }
 function mergeRowsForCsvExport(enrichedRows, options) {
+  const compactAliases = options?.config ? enrichAiRuntimeCompactAliases(options.config) : /* @__PURE__ */ new Set();
   const rows = dataExportRows(
     normalizeEnrichRowsForCsvExport(enrichedRows, options?.config, {
       statusFailureMessages: options?.statusFailureMessages
-    })
+    }),
+    { preserveJsonStringColumns: compactAliases }
   );
   const range = options?.rows;
   if (!options?.sourceCsvPath) {
@@ -18774,16 +19333,16 @@ function mergeRowsForCsvExport(enrichedRows, options) {
   const maxEnd = Math.max(start, baseRows.length - 1);
   const inclusiveEnd = range?.rowEnd === null || range?.rowEnd === void 0 ? maxEnd : Math.min(maxEnd, range.rowEnd);
   const expectedSelectedRows = baseRows.length === 0 ? 0 : Math.max(0, inclusiveEnd - start + 1);
-  const canMergeSparseBySourceIndex = rows.length > 0 && rows.every(
+  const hasRowsInSelectedRange = rows.some(
     (row) => sourceRowIndexFromEnrichRow(row, start, inclusiveEnd) !== null
   );
-  if (options.inPlace && rows.length < expectedSelectedRows && !options.allowPartial && !canMergeSparseBySourceIndex) {
+  if (options.inPlace && rows.length < expectedSelectedRows && !options.allowPartial && !hasRowsInSelectedRange) {
     throw new Error(
       `Refusing to write a partial in-place CSV export: the run returned ${rows.length} row(s) for ${expectedSelectedRows} selected source row(s).`
     );
   }
   const merged = [...baseRows];
-  if (canMergeSparseBySourceIndex) {
+  if (hasRowsInSelectedRange) {
     for (const rawEnriched of rows) {
       const rowIndex = sourceRowIndexFromEnrichRow(
         rawEnriched,
@@ -18918,9 +19477,45 @@ function materializeCsvCellValue(value) {
   }
   return value;
 }
-function materializeAliasSuccessCell(row, alias) {
+function disambiguateCompactAiInferencePayload(value) {
+  const parsed = parseMaybeJsonObject(value);
+  if (!isRecord7(parsed) || !cellFailureError(parsed)) {
+    return value;
+  }
+  return {
+    status: "completed",
+    extracted_json: parsed
+  };
+}
+function compactAiInferenceCellForCsv(value) {
+  if (!isRecord7(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 object = result?.object;
+  if (object !== null && object !== void 0) {
+    return disambiguateCompactAiInferencePayload(object);
+  }
+  const text = result?.text;
+  if (typeof text === "string" && text.trim()) {
+    return disambiguateCompactAiInferencePayload(text);
+  }
+  const output2 = value.output;
+  if (typeof output2 === "string" && output2.trim()) {
+    return disambiguateCompactAiInferencePayload(output2);
+  }
+  return value;
+}
+function materializeEnrichAliasCellForCsv(row, alias, options) {
   const direct = row[alias];
   if (isRecord7(direct)) {
+    if (options?.compactAiCell && direct.status === "completed" && (isRecord7(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
+      return materializeCsvCellValue(compactAiInferenceCellForCsv(direct));
+    }
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
       return materializeCsvCellValue(direct);
     }
@@ -18979,6 +19574,7 @@ function materializeAliasSuccessCell(row, alias) {
 }
 function normalizeEnrichRowsForCsvExport(rows, config, options) {
   const aliases = config ? collectConfigScalarAliasOrder(config) : [];
+  const aiCompactAliases = config ? enrichAiRuntimeCompactAliases(config) : null;
   const failureOperationByAlias = hardFailureOperationByAlias(config);
   return rows.map((row) => {
     const metadata = legacyMetadataFromRow(row);
@@ -19021,7 +19617,9 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
       }
     }
     for (const alias of aliases) {
-      const value = materializeAliasSuccessCell(normalized, alias);
+      const value = materializeEnrichAliasCellForCsv(normalized, alias, {
+        compactAiCell: aiCompactAliases?.has(normalizeAlias2(alias)) ?? false
+      });
       if (value !== void 0) {
         normalized[alias] = value;
         continue;
@@ -19276,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) {
@@ -19346,7 +19945,7 @@ function registerEnrichCommand(program) {
           capturedResult: captured2.result,
           client: client2,
           config,
-          sourceCsvPath: input2.sourceCsvPath,
+          sourceCsvPath: input2.mergeSourceCsvPath ?? input2.sourceCsvPath,
           rows: input2.rows,
           inPlace: Boolean(options.inPlace)
         });
@@ -19362,11 +19961,13 @@ function registerEnrichCommand(program) {
 `
           );
         }
-        let workingSourceCsvPath = sourceCsvPath;
+        let workingMergeSourceCsvPath = sourceCsvPath;
         let lastStatus = null;
+        const batchStatuses = [];
         let finalExportResult = null;
         let totalEnrichedRows = 0;
         const batchFailureRows = [];
+        const runtimeCompactAliases = enrichAiRuntimeCompactAliases(config);
         for (let chunkStart = selectedRange.start, chunkIndex = 0; chunkStart <= selectedRange.end; chunkStart += autoBatchRows, chunkIndex += 1) {
           const chunkRows = {
             rowStart: chunkStart,
@@ -19381,18 +19982,33 @@ function registerEnrichCommand(program) {
 `
             );
           }
+          const runtimeSourceCsvPath = options.inPlace ? sourceCsvPath : workingMergeSourceCsvPath === inputCsv ? inputCsv : (0, import_node_path12.join)(tempDir, `runtime-batch-${chunkIndex}.csv`);
+          if (!options.inPlace && runtimeSourceCsvPath !== inputCsv) {
+            await writeSlimBatchedRuntimeCsv({
+              cleanSourceCsvPath: inputCsv,
+              mergeSourceCsvPath: workingMergeSourceCsvPath,
+              rows: chunkRows,
+              compactAliases: runtimeCompactAliases,
+              outputPath: runtimeSourceCsvPath
+            });
+          }
           const chunk = await runOne({
-            sourceCsvPath: workingSourceCsvPath,
+            sourceCsvPath: runtimeSourceCsvPath,
+            mergeSourceCsvPath: workingMergeSourceCsvPath,
             rows: chunkRows,
             json: true,
             passthroughStdout: false,
             suppressOpen: true
           });
           lastStatus = chunk.status;
+          batchStatuses.push(chunk.status);
           if (chunk.captured.result !== 0) {
             if (chunk.exportResult) {
               finalExportResult = chunk.exportResult;
-              totalEnrichedRows += chunk.exportResult.enrichedRows;
+              totalEnrichedRows += countEnrichedRowsInSourceRange(
+                chunk.exportResult,
+                chunkRows
+              );
               batchFailureRows.push(...chunk.exportResult.enrichedDataRows);
             }
             const failureReport3 = await maybeEmitEnrichFailureReport({
@@ -19405,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) {
@@ -19427,12 +20046,7 @@ function registerEnrichCommand(program) {
                     partial: true
                   } : {}
                 } : null,
-                ...failureReport3 ? {
-                  failure_report: {
-                    path: failureReport3.path,
-                    jobs: failureReport3.jobs.length
-                  }
-                } : {}
+                ...enrichReportJson(failureReport3)
               });
             } else {
               if (committedExportResult2) {
@@ -19453,9 +20067,12 @@ function registerEnrichCommand(program) {
           }
           if (chunk.exportResult) {
             finalExportResult = chunk.exportResult;
-            totalEnrichedRows += chunk.exportResult.enrichedRows;
+            totalEnrichedRows += countEnrichedRowsInSourceRange(
+              chunk.exportResult,
+              chunkRows
+            );
             batchFailureRows.push(...chunk.exportResult.enrichedDataRows);
-            workingSourceCsvPath = outputPath;
+            workingMergeSourceCsvPath = outputPath;
           }
         }
         const outputRows = readCsvRows(outputPath);
@@ -19468,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) {
@@ -19500,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) {
@@ -19536,6 +20151,7 @@ function registerEnrichCommand(program) {
           exportResult: committedExportResult2,
           outputPath,
           reportOutputPath: failureReportOutputPath,
+          followUpOutputPath: enrichIssueFollowUpOutputPath,
           status
         });
         if (options.json) {
@@ -19543,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;
@@ -19563,6 +20174,7 @@ function registerEnrichCommand(program) {
           exportResult,
           outputPath,
           reportOutputPath: failureReportOutputPath,
+          followUpOutputPath: enrichIssueFollowUpOutputPath,
           status
         });
         const committedExportResult2 = await commitInPlaceOutput(exportResult);
@@ -19577,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;
@@ -19595,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) {