deepline 0.1.175 → 0.1.177

package/dist/cli/index.mjs

@@ -607,17 +607,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",
@@ -871,9 +872,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);
@@ -900,7 +902,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;
             }
@@ -930,7 +932,7 @@ var HttpClient = class {
                   ...htmlError.workerThrewException ? { workerThrewException: true } : {}
                 }
               );
-              if (retryableApiError && attempt < this.config.maxRetries) {
+              if (retryableApiError && attempt < maxRetries) {
                 retryAfterDelayMs = parseOptionalRetryAfter(response);
                 break;
               }
@@ -942,7 +944,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;
             }
@@ -961,7 +963,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;
@@ -2096,6 +2098,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;
@@ -2170,6 +2173,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));
@@ -2609,7 +2616,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
+      }
     );
   }
   /**
@@ -4569,10 +4581,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;
@@ -4583,6 +4606,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) {
@@ -4607,8 +4634,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 = [
@@ -7717,7 +7744,7 @@ import {
   writeFile as writeFile3
 } from "fs/promises";
 import { homedir as homedir7, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname7, join as join7, resolve as resolve9 } from "path";
+import { basename as basename2, dirname as dirname7, extname, join as join7, resolve as resolve9 } from "path";
 
 // src/cli/commands/play.ts
 import { createHash as createHash2 } from "crypto";
@@ -16910,7 +16937,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";
@@ -16925,6 +16953,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",
@@ -16942,6 +16976,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)) {
@@ -17709,8 +17752,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) {
@@ -17734,18 +17775,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;
@@ -17777,14 +17867,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) {
@@ -17841,6 +17956,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 writeFile3(
+    input2.outputPath,
+    csvStringFromRows(cleanRows, columns),
+    "utf8"
+  );
+}
 function selectedSourceCsvRowCount(options) {
   if (!options?.sourceCsvPath) {
     return null;
@@ -18015,7 +18176,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}
@@ -18147,6 +18308,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();
@@ -18215,6 +18392,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) {
@@ -18227,6 +18436,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)) {
@@ -18372,6 +18635,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) {
@@ -18465,14 +18834,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;
@@ -18598,19 +18976,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(
+        resolve9(input2.outputPath)
+      )}`
+    });
+  }
+  return commands.slice(0, 8);
+}
+function sidecarEnrichRowsExportPath(outputPath) {
+  const resolved = resolve9(outputPath);
+  const ext = extname(resolved) || ".csv";
+  const stem = basename2(resolved, ext);
+  return join7(dirname7(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(resolve9(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 = join7(homedir7(), ".local", "deepline", "runtime", "state");
+  const reportPrefix = input2.jobs.length > 0 ? "run-block-failures" : "enrich-issues";
   await mkdir3(stateDir, { recursive: true });
   const reportPath = join7(
     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(),
@@ -18625,6 +19129,7 @@ async function persistEnrichFailureReport(input2) {
     },
     jobs: input2.jobs,
     failed_jobs: input2.jobs,
+    enrich_issues: input2.issues,
     canceled_jobs: [],
     pending_jobs: [],
     missing_job_ids: []
@@ -18637,48 +19142,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 = [];
@@ -18778,10 +19335,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) {
@@ -18801,16 +19360,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,
@@ -18945,9 +19504,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);
     }
@@ -19006,6 +19601,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);
@@ -19048,7 +19644,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;
@@ -19303,6 +19901,7 @@ function registerEnrichCommand(program) {
     const inPlaceFinalOutputPath = options.inPlace ? resolve9(inputCsv) : null;
     const inPlaceCommitOutputPath = options.inPlace ? (await lstat(inputCsv)).isSymbolicLink() ? await 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) {
@@ -19373,7 +19972,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)
         });
@@ -19389,11 +19988,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,
@@ -19408,18 +20009,33 @@ function registerEnrichCommand(program) {
 `
             );
           }
+          const runtimeSourceCsvPath = options.inPlace ? sourceCsvPath : workingMergeSourceCsvPath === inputCsv ? inputCsv : join7(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({
@@ -19432,7 +20048,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) {
@@ -19454,12 +20073,7 @@ function registerEnrichCommand(program) {
                     partial: true
                   } : {}
                 } : null,
-                ...failureReport3 ? {
-                  failure_report: {
-                    path: failureReport3.path,
-                    jobs: failureReport3.jobs.length
-                  }
-                } : {}
+                ...enrichReportJson(failureReport3)
               });
             } else {
               if (committedExportResult2) {
@@ -19480,9 +20094,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);
@@ -19495,7 +20112,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) {
@@ -19527,12 +20147,7 @@ function registerEnrichCommand(program) {
               enrichedRows: totalEnrichedRows,
               path: finalExportResult.path
             } : null,
-            ...failureReport2 ? {
-              failure_report: {
-                path: failureReport2.path,
-                jobs: failureReport2.jobs.length
-              }
-            } : {}
+            ...enrichReportJson(failureReport2)
           });
         }
         if (failureReport2) {
@@ -19563,6 +20178,7 @@ function registerEnrichCommand(program) {
           exportResult: committedExportResult2,
           outputPath,
           reportOutputPath: failureReportOutputPath,
+          followUpOutputPath: enrichIssueFollowUpOutputPath,
           status
         });
         if (options.json) {
@@ -19570,12 +20186,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;
@@ -19590,6 +20201,7 @@ function registerEnrichCommand(program) {
           exportResult,
           outputPath,
           reportOutputPath: failureReportOutputPath,
+          followUpOutputPath: enrichIssueFollowUpOutputPath,
           status
         });
         const committedExportResult2 = await commitInPlaceOutput(exportResult);
@@ -19604,12 +20216,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;
@@ -19622,7 +20229,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) {
@@ -19707,7 +20316,7 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir8, platform } from "os";
-import { basename as basename2, dirname as dirname8, join as join8, resolve as resolve10 } from "path";
+import { basename as basename3, dirname as dirname8, join as join8, resolve as resolve10 } from "path";
 import { gzipSync } from "zlib";
 import { randomUUID as randomUUID2 } from "crypto";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -19726,7 +20335,7 @@ function homeDir() {
 function detectShellContext() {
   const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
   return {
-    shell: shellPath ? basename2(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell: shellPath ? basename3(shellPath).replace(/\.exe$/i, "") : "unknown",
     shell_path: shellPath || null,
     os: platform(),
     cwd: process.cwd()
@@ -19832,10 +20441,10 @@ function newestSessionFile(agent) {
   return newest;
 }
 function sessionIdFromClaudeFilePath(filePath) {
-  return basename2(filePath, ".jsonl");
+  return basename3(filePath, ".jsonl");
 }
 function sessionIdFromCodexFilePath(filePath) {
-  const match = basename2(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  const match = basename3(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
   return match?.[0] ?? null;
 }
 function readCodexSessionId(filePath) {
@@ -20123,19 +20732,19 @@ async function handleSessionsSend(options) {
     }
     const response2 = await uploadPayload("/api/v2/cli/send-session", {
       file: readFileSync8(filePath).toString("base64"),
-      filename: basename2(filePath)
+      filename: basename3(filePath)
     });
     printCommandEnvelope(
       {
         ...response2,
         ok: true,
-        filename: basename2(filePath),
+        filename: basename3(filePath),
         render: {
           sections: [
             {
               title: "sessions send",
               lines: [
-                `File '${basename2(filePath)}' uploaded to #internal-reports.`
+                `File '${basename3(filePath)}' uploaded to #internal-reports.`
               ]
             }
           ]