deepline 0.1.148 → 0.1.150

package/dist/cli/index.mjs

@@ -222,6 +222,8 @@ var PROD_URL = "https://code.deepline.com";
 var DEFAULT_TIMEOUT = 6e4;
 var DEFAULT_MAX_RETRIES = 3;
 var PROJECT_DEEPLINE_ENV_FILE = ".env.deepline";
+var WORKSPACE_RESTORE_ENV_DIR = ".deepline";
+var WORKSPACE_RESTORE_ENV_FILE = ".env";
 var COWORK_IGNORED_WORKSPACE_DIRS = /* @__PURE__ */ new Set([
   ".auto-memory",
   ".claude",
@@ -536,6 +538,18 @@ function ensureProjectEnvIsIgnored(dir) {
   writeFileSync(gitignorePath, `${existing}${prefix}${entry}
 `, "utf-8");
 }
+function ensureWorkspaceRestoreEnvIsIgnored(workspaceDir) {
+  const gitignorePath = join(workspaceDir, ".gitignore");
+  const entry = `${WORKSPACE_RESTORE_ENV_DIR}/`;
+  const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
+  const alreadyIgnored = existing.split(/\r?\n/).map((line) => line.trim()).some(
+    (line) => line === entry || line === `/${entry}` || line === WORKSPACE_RESTORE_ENV_DIR || line === `/${WORKSPACE_RESTORE_ENV_DIR}`
+  );
+  if (alreadyIgnored) return;
+  const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+  writeFileSync(gitignorePath, `${existing}${prefix}${entry}
+`, "utf-8");
+}
 function saveProjectDeeplineEnvValues(values, startDir = process.cwd()) {
   const target = resolveProjectPinTarget(startDir);
   if (!target.ok) {
@@ -549,6 +563,27 @@ function saveProjectDeeplineEnvValues(values, startDir = process.cwd()) {
   mergeProjectEnvFile(filePath, values);
   return [filePath];
 }
+function saveCoworkWorkspaceRestoreEnvValues(values, startDir = process.cwd()) {
+  if (!isCoworkLikeSandbox()) return [];
+  const target = resolveProjectPinTarget(startDir);
+  if (!target.ok || target.source === "cwd") return [];
+  const workspaceDir = target.dir;
+  const filePath = join(
+    workspaceDir,
+    WORKSPACE_RESTORE_ENV_DIR,
+    WORKSPACE_RESTORE_ENV_FILE
+  );
+  const existing = parseEnvFile(filePath);
+  const merged = { ...existing, ...values };
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  ensureWorkspaceRestoreEnvIsIgnored(workspaceDir);
+  const allowedKeys = /* @__PURE__ */ new Set([HOST_URL_ENV, API_KEY_ENV]);
+  const lines = Object.entries(merged).filter(([key, value]) => allowedKeys.has(key) && value !== "").map(([key, value]) => `${key}=${value}`);
+  writeFileSync(filePath, `${lines.join("\n")}
+`, "utf-8");
+  return [filePath];
+}
 function resolveProjectPinTarget(startDir = process.cwd()) {
   const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
   if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
@@ -605,10 +640,10 @@ var SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: "0.1.148",
+  version: "0.1.150",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.148",
+    latest: "0.1.150",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -2072,6 +2107,7 @@ async function* observeRunEvents(options) {
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
 var EXECUTE_RESPONSE_CONTRACT_HEADER = "x-deepline-execute-response-contract";
+var EXECUTE_RESPONSE_INTENT_HEADER = "x-deepline-execute-response-intent";
 var V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-response";
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
@@ -2556,7 +2592,8 @@ var DeeplineClient = class {
   async executeTool(toolId, input2, options) {
     const headers = {
       [EXECUTE_RESPONSE_CONTRACT_HEADER]: V2_EXECUTE_RESPONSE_CONTRACT,
-      ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {}
+      ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {},
+      ...options?.responseIntent ? { [EXECUTE_RESPONSE_INTENT_HEADER]: options.responseIntent } : {}
     };
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
@@ -4690,6 +4727,9 @@ function saveEnvValues(values, baseUrl) {
     ...values[API_KEY_ENV] ? { [API_KEY_ENV]: values[API_KEY_ENV] } : {}
   };
   saveHostEnvValues(baseUrl, filtered);
+  if (filtered[API_KEY_ENV]) {
+    saveCoworkWorkspaceRestoreEnvValues(filtered);
+  }
 }
 async function httpJson(method, url, apiKey, body) {
   const headers = {
@@ -6920,6 +6960,7 @@ Examples:
 import { writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve5 } from "path";
 var CUSTOMER_DB_QUERY_FORMATS = /* @__PURE__ */ new Set(["table", "json", "csv", "markdown"]);
+var CUSTOMER_DB_QUERY_MAX_ROWS = 1e3;
 function parsePositiveInteger(value, flagName) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
@@ -6927,6 +6968,15 @@ function parsePositiveInteger(value, flagName) {
   }
   return parsed;
 }
+function parseMaxRows(value) {
+  const parsed = parsePositiveInteger(value, "--max-rows");
+  if (parsed > CUSTOMER_DB_QUERY_MAX_ROWS) {
+    throw new Error(
+      `--max-rows must be ${CUSTOMER_DB_QUERY_MAX_ROWS} or less. Add LIMIT/OFFSET to page larger exports.`
+    );
+  }
+  return parsed;
+}
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   const text = typeof value === "object" ? JSON.stringify(value) : String(value);
@@ -7072,7 +7122,7 @@ async function handleDbQuery(args) {
     return 1;
   }
   const maxRowsIndex = args.indexOf("--max-rows");
-  const maxRows = maxRowsIndex >= 0 && args[maxRowsIndex + 1] ? parsePositiveInteger(args[maxRowsIndex + 1], "--max-rows") : void 0;
+  const maxRows = maxRowsIndex >= 0 && args[maxRowsIndex + 1] ? parseMaxRows(args[maxRowsIndex + 1]) : void 0;
   const formatIndex = args.indexOf("--format");
   const format = formatIndex >= 0 ? args[formatIndex + 1]?.trim().toLowerCase() : "";
   if (format && !CUSTOMER_DB_QUERY_FORMATS.has(format)) {
@@ -17046,8 +17096,14 @@ async function writeOutputCsv(outputPath, status, options) {
       rowsInfo
     }).catch(() => null) ?? rowsInfo;
   }
-  assertCompleteRowsForCsvExport(rowsInfo, status, outputPath);
-  const merged = mergeRowsForCsvExport(rowsInfo.rows, options);
+  const allowPartial = options?.allowPartial === true && !rowsInfo.complete && rowsInfo.rows.length > 0 && Boolean(options?.sourceCsvPath);
+  assertCompleteRowsForCsvExport(rowsInfo, status, outputPath, {
+    allowPartial
+  });
+  const merged = mergeRowsForCsvExport(rowsInfo.rows, {
+    ...options,
+    allowPartial
+  });
   const columns = orderEnrichCsvColumns(
     dataExportColumns(merged.rows, [
       ...merged.preferredColumns,
@@ -17067,9 +17123,52 @@ async function writeOutputCsv(outputPath, status, options) {
     enrichedRows: rowsInfo.rows.length,
     rows: merged.rows.length,
     path: resolve8(outputPath),
+    partial: !rowsInfo.complete,
     enrichedDataRows: rowsInfo.rows
   };
 }
+function isMissingRowsForCsvExportError(error) {
+  return error instanceof Error && (error.message.includes("did not return row-shaped output") || error.message.includes("run returned 0 preview row(s)"));
+}
+async function maybeWriteOutputCsv(input2) {
+  if (!input2.outputPath) return null;
+  try {
+    return await writeOutputCsv(input2.outputPath, input2.status, {
+      client: input2.client,
+      config: input2.config,
+      sourceCsvPath: input2.sourceCsvPath,
+      rows: input2.rows,
+      inPlace: input2.inPlace,
+      allowPartial: input2.capturedResult !== 0
+    });
+  } catch (error) {
+    if (input2.capturedResult !== 0 && isMissingRowsForCsvExportError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function enrichOutputJson(exportResult) {
+  if (!exportResult) {
+    return null;
+  }
+  return {
+    sourceCsvRows: exportResult.sourceCsvRows,
+    selectedRows: exportResult.selectedRows,
+    enrichedRows: exportResult.enrichedRows,
+    path: exportResult.path,
+    ...exportResult.partial ? { rows: exportResult.rows, partial: true } : {}
+  };
+}
+async function buildEnrichFailureReport(input2) {
+  return maybeEmitEnrichFailureReport({
+    config: input2.config,
+    rows: input2.rows,
+    rowRange: input2.rowRange,
+    client: input2.client,
+    outputPath: input2.exportResult?.path ?? input2.outputPath ?? null
+  });
+}
 function recordField(value, key) {
   return value && typeof value === "object" && !Array.isArray(value) ? value[key] : void 0;
 }
@@ -17591,10 +17690,7 @@ async function fetchBackingRowsForCsvExport(input2) {
 function mergeRowsForCsvExport(enrichedRows, options) {
   const rows = dataExportRows(normalizeEnrichRowsForCsvExport(enrichedRows));
   const range = options?.rows;
-  if (!options?.inPlace && (range?.rowStart === null || range?.rowStart === void 0)) {
-    return { rows, preferredColumns: [] };
-  }
-  if (!options?.sourceCsvPath) {
+  if (!options?.sourceCsvPath || !options.inPlace && !options.allowPartial && (range?.rowStart === null || range?.rowStart === void 0)) {
     return { rows, preferredColumns: [] };
   }
   const parsedBaseRows = readCsvRows(options.sourceCsvPath);
@@ -17606,7 +17702,7 @@ 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);
-  if (rows.length < expectedSelectedRows) {
+  if (rows.length < expectedSelectedRows && !options.allowPartial) {
     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).`
     );
@@ -17805,10 +17901,13 @@ function mergeLegacyMetadataCell(base, enriched) {
   }
   return void 0;
 }
-function assertCompleteRowsForCsvExport(rowsInfo, status, outputPath) {
+function assertCompleteRowsForCsvExport(rowsInfo, status, outputPath, options = {}) {
   if (rowsInfo.complete) {
     return;
   }
+  if (options.allowPartial) {
+    return;
+  }
   const runId = status && typeof status === "object" && !Array.isArray(status) && typeof status.runId === "string" ? status.runId : null;
   const dataset = rowsInfo.source ?? "result.rows";
   const retry = runId ? ` Retry after the run finalizes its backing dataset with: deepline runs export ${runId} --dataset ${dataset} --out ${outputPath}` : "";
@@ -17964,13 +18063,16 @@ function registerEnrichCommand(program) {
           stdout: captured2.stdout,
           exitCode: captured2.result
         });
-        const exportResult2 = captured2.result === 0 && outputPath ? await writeOutputCsv(outputPath, status2, {
+        const exportResult2 = await maybeWriteOutputCsv({
+          outputPath,
+          status: status2,
+          capturedResult: captured2.result,
           client: client2,
           config,
           sourceCsvPath: input2.sourceCsvPath,
           rows: input2.rows,
           inPlace: Boolean(options.inPlace)
-        }) : null;
+        });
         return { captured: captured2, status: status2, exportResult: exportResult2 };
       };
       const selectedRange = selectedSourceCsvRange(sourceCsvPath, rows);
@@ -18020,9 +18122,16 @@ function registerEnrichCommand(program) {
                   chunks: chunkCount,
                   rows: chunkRows
                 },
-                result: chunk.status
+                result: chunk.status,
+                output: enrichOutputJson(chunk.exportResult)
               });
             } else {
+              if (chunk.exportResult) {
+                process.stderr.write(
+                  `Wrote ${chunk.exportResult.rows} row(s) to ${chunk.exportResult.path}${chunk.exportResult.partial ? " (partial run output)" : ""}
+`
+                );
+              }
               emitPlainBatchRunFailure({
                 chunkIndex,
                 chunkCount,
@@ -18099,23 +18208,46 @@ function registerEnrichCommand(program) {
         json: Boolean(options.json),
         passthroughStdout: !options.json
       });
+      const rowsForFailureReport = exportResult?.enrichedDataRows ?? extractCanonicalRowsInfo(status)?.rows ?? [];
       if (captured.result !== 0) {
+        if (exportResult) {
+          process.stderr.write(
+            `Wrote ${exportResult.rows} row(s) to ${exportResult.path}${exportResult.partial ? " (partial run output)" : ""}
+`
+          );
+        }
+        const failureReport2 = await buildEnrichFailureReport({
+          config,
+          rows: rowsForFailureReport,
+          rowRange: rows,
+          client: client2,
+          exportResult,
+          outputPath
+        });
         if (options.json) {
           printJson({
-            result: status
+            ok: false,
+            run: status,
+            output: enrichOutputJson(exportResult),
+            ...failureReport2 ? {
+              failure_report: {
+                path: failureReport2.path,
+                jobs: failureReport2.jobs.length
+              }
+            } : {}
           });
         }
-        process.exitCode = captured.result;
+        process.exitCode = failureReport2 ? EXIT_SERVER2 : captured.result;
         return;
       }
-      const rowsForFailureReport = exportResult?.enrichedDataRows ?? extractCanonicalRowsInfo(status)?.rows ?? [];
       if (options.json) {
-        const failureReport2 = await maybeEmitEnrichFailureReport({
+        const failureReport2 = await buildEnrichFailureReport({
           config,
           rows: rowsForFailureReport,
           rowRange: rows,
           client: client2,
-          outputPath: exportResult?.path ?? outputPath ?? null
+          exportResult,
+          outputPath
         });
         const run = rewriteEnrichJsonStatus({
           status,
@@ -18127,12 +18259,7 @@ function registerEnrichCommand(program) {
         printJson({
           ok: !failureReport2,
           run,
-          output: exportResult ? {
-            sourceCsvRows: exportResult.sourceCsvRows,
-            selectedRows: exportResult.selectedRows,
-            enrichedRows: exportResult.enrichedRows,
-            path: exportResult.path
-          } : null,
+          output: enrichOutputJson(exportResult),
           ...failureReport2 ? {
             failure_report: {
               path: failureReport2.path,
@@ -19493,16 +19620,17 @@ async function handleOrgSwitch(selection, options) {
   const authTarget = resolveOrgSwitchAuthTarget(authScope, config);
   if (target.is_current) {
     let project_env_paths2 = [];
+    const authValues2 = {
+      [HOST_URL_ENV]: config.baseUrl,
+      [API_KEY_ENV]: config.apiKey
+    };
     if (authTarget.kind === "folder") {
-      project_env_paths2 = saveProjectDeeplineEnvValues({
-        DEEPLINE_HOST_URL: config.baseUrl,
-        DEEPLINE_API_KEY: config.apiKey
-      });
+      project_env_paths2 = saveProjectDeeplineEnvValues(authValues2);
     } else {
-      saveHostEnvValues(config.baseUrl, {
-        DEEPLINE_HOST_URL: config.baseUrl,
-        DEEPLINE_API_KEY: config.apiKey
-      });
+      saveHostEnvValues(config.baseUrl, authValues2);
+    }
+    if (authTarget.kind === "folder") {
+      saveCoworkWorkspaceRestoreEnvValues(authValues2);
     }
     const renderLines2 = [`Already on ${target.name}.`];
     for (const projectPath of project_env_paths2) {
@@ -19551,19 +19679,22 @@ async function handleOrgSwitch(selection, options) {
     org_id: target.org_id
   });
   let project_env_paths = [];
+  const authValues = {
+    [HOST_URL_ENV]: config.baseUrl,
+    [API_KEY_ENV]: switched.api_key
+  };
   if (authTarget.kind === "folder") {
-    project_env_paths = saveProjectDeeplineEnvValues({
-      DEEPLINE_HOST_URL: config.baseUrl,
-      DEEPLINE_API_KEY: switched.api_key
-    });
+    project_env_paths = saveProjectDeeplineEnvValues(authValues);
   } else {
     saveHostEnvValues(config.baseUrl, {
-      DEEPLINE_HOST_URL: config.baseUrl,
-      DEEPLINE_API_KEY: switched.api_key,
+      ...authValues,
       DEEPLINE_ACTIVE_ORG_ID: switched.org_id,
       DEEPLINE_ACTIVE_ORG_NAME: switched.org_name
     });
   }
+  if (authTarget.kind === "folder") {
+    saveCoworkWorkspaceRestoreEnvValues(authValues);
+  }
   const { api_key: _apiKey, ...publicSwitched } = switched;
   const renderLines = [`Switched to ${switched.org_name}.`];
   if (authTarget.kind === "folder") {
@@ -19619,12 +19750,16 @@ async function handleOrgCreate(name, options) {
     api_key: config.apiKey,
     name
   });
+  const authValues = {
+    [HOST_URL_ENV]: config.baseUrl,
+    [API_KEY_ENV]: created.api_key
+  };
   saveHostEnvValues(config.baseUrl, {
-    DEEPLINE_HOST_URL: config.baseUrl,
-    DEEPLINE_API_KEY: created.api_key,
+    ...authValues,
     DEEPLINE_ACTIVE_ORG_ID: created.org_id,
     DEEPLINE_ACTIVE_ORG_NAME: created.org_name
   });
+  saveCoworkWorkspaceRestoreEnvValues(authValues);
   const { api_key: _apiKey, ...publicCreated } = created;
   printCommandEnvelope(
     {
@@ -20428,7 +20563,13 @@ import { tmpdir as tmpdir3 } from "os";
 import { join as join10, resolve as resolve10 } from "path";
 
 // src/tool-output.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "fs";
+import {
+  closeSync as closeSync2,
+  mkdirSync as mkdirSync7,
+  openSync as openSync2,
+  writeFileSync as writeFileSync11,
+  writeSync
+} from "fs";
 import { homedir as homedir9 } from "os";
 import { dirname as dirname9, join as join9 } from "path";
 function isPlainObject(value) {
@@ -20451,6 +20592,19 @@ function normalizeRows(value) {
     return { value: entry };
   });
 }
+function columnsForRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const columns = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  return columns;
+}
 function candidateRoots(payload) {
   const roots = [
     { path: null, value: payload }
@@ -20533,6 +20687,16 @@ function tryConvertToList(payload, options) {
   }
   return null;
 }
+function projectRowOutput(conversion) {
+  return {
+    rows: conversion.rows,
+    rowCount: conversion.rows.length,
+    columns: columnsForRows(conversion.rows),
+    previewRows: conversion.rows.slice(0, 5),
+    strategy: conversion.strategy,
+    sourcePath: conversion.sourcePath
+  };
+}
 function ensureOutputDir() {
   const outputDir = join9(homedir9(), ".local", "share", "deepline", "data");
   mkdirSync7(outputDir, { recursive: true });
@@ -20547,16 +20711,7 @@ function writeJsonOutputFile(payload, stem) {
 function writeCsvOutputFile(rows, stem, options) {
   const outputPath = options?.outPath ? options.outPath : join9(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
   mkdirSync7(dirname9(outputPath), { recursive: true });
-  const seen = /* @__PURE__ */ new Set();
-  const columns = [];
-  for (const row of rows) {
-    for (const key of Object.keys(row)) {
-      if (!seen.has(key)) {
-        seen.add(key);
-        columns.push(key);
-      }
-    }
-  }
+  const columns = columnsForRows(rows);
   const escapeCell = (value) => {
     const normalized = value == null ? "" : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
     if (/[",\n]/.test(normalized)) {
@@ -20564,13 +20719,20 @@ function writeCsvOutputFile(rows, stem, options) {
     }
     return normalized;
   };
-  const lines = [];
-  lines.push(columns.map(escapeCell).join(","));
-  for (const row of rows) {
-    lines.push(columns.map((column) => escapeCell(row[column])).join(","));
+  const fd = openSync2(outputPath, "w");
+  try {
+    writeSync(fd, `${columns.map(escapeCell).join(",")}
+`);
+    for (const row of rows) {
+      writeSync(
+        fd,
+        `${columns.map((column) => escapeCell(row[column])).join(",")}
+`
+      );
+    }
+  } finally {
+    closeSync2(fd);
   }
-  writeFileSync11(outputPath, `${lines.join("\n")}
-`, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
   const preview = [
@@ -21097,10 +21259,7 @@ Examples:
   ).option(
     "--output-format <format>",
     "Output format: auto, csv, csv_file, json, or json_file"
-  ).option(
-    "-o, --out <path>",
-    "Write row-shaped tool output to this CSV path"
-  ).option(
+  ).option("-o, --out <path>", "Write row-shaped tool output to this CSV path").option(
     "--no-preview",
     "Only print the extracted output path when applicable"
   ).action(async (toolId, options) => {
@@ -21954,6 +22113,100 @@ function buildToolExecuteBaseEnvelope(input2) {
     }
   };
 }
+function buildToolExecuteRowArtifactEnvelope(input2) {
+  const {
+    toolResponse: _toolResponse,
+    result: _result,
+    output: _output,
+    output_preview: _outputPreview,
+    render: _render,
+    next: _next,
+    local: _local,
+    ...base
+  } = input2.baseEnvelope;
+  void _toolResponse;
+  void _result;
+  void _output;
+  void _outputPreview;
+  void _render;
+  void _next;
+  void _local;
+  return {
+    ...base,
+    status: typeof base.status === "string" ? base.status : "completed",
+    output_preview: {
+      kind: "list",
+      rowCount: input2.rowOutput.rowCount,
+      columns: input2.rowOutput.columns,
+      preview: input2.rowOutput.previewRows,
+      listStrategy: input2.rowOutput.strategy,
+      listSourcePath: input2.rowOutput.sourcePath
+    },
+    csv_path: input2.csv.path,
+    row_count: input2.csv.rowCount,
+    row_count_returned: input2.csv.rowCount,
+    columns: input2.csv.columns,
+    extracted_csv: input2.csv.path,
+    extracted_csv_rows: input2.csv.rowCount,
+    extracted_csv_columns: input2.csv.columns,
+    preview: input2.csv.preview,
+    list_strategy: input2.rowOutput.strategy,
+    list_source_path: input2.rowOutput.sourcePath,
+    summary: input2.summary,
+    local: {
+      extracted_csv: input2.csv.path,
+      extracted_csv_rows: input2.csv.rowCount,
+      extracted_csv_columns: input2.csv.columns,
+      preview: input2.csv.preview,
+      starter_script: input2.seededScript.path,
+      project_dir: input2.seededScript.projectDir,
+      copy_to_project: {
+        macos_linux: input2.seededScript.macCopyCommand,
+        windows_powershell: input2.seededScript.windowsCopyCommand
+      }
+    },
+    starter_script: input2.seededScript.path,
+    project_dir: input2.seededScript.projectDir,
+    copy_to_project: {
+      macos_linux: input2.seededScript.macCopyCommand,
+      windows_powershell: input2.seededScript.windowsCopyCommand
+    },
+    next: {
+      inspect: "Re-run with --json only when you need the raw provider/tool response.",
+      listSourcePath: input2.rowOutput.sourcePath,
+      expandToPlay: "Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
+    },
+    render: {
+      sections: [
+        {
+          title: `${input2.csv.path} (${input2.csv.rowCount} rows)`,
+          lines: [
+            ...input2.csv.columns.length > 0 ? [`columns: ${JSON.stringify(input2.csv.columns)}`] : [],
+            ...Object.keys(input2.summary).length > 0 ? [
+              `summary: ${Object.entries(input2.summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`
+            ] : [],
+            `preview: ${JSON.stringify(input2.rowOutput.previewRows)}`,
+            `starter script: ${input2.seededScript.path}`
+          ]
+        }
+      ],
+      actions: [
+        {
+          label: "next",
+          command: "Move the script into a project folder and expand it into a Deepline play. Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
+        },
+        {
+          label: "macOS/Linux",
+          command: input2.seededScript.macCopyCommand
+        },
+        {
+          label: "Windows PowerShell",
+          command: input2.seededScript.windowsCopyCommand
+        }
+      ]
+    }
+  };
+}
 async function executeTool(args) {
   let parsed;
   try {
@@ -22005,7 +22258,9 @@ async function executeTool(args) {
     }
     return 2;
   }
-  const rawResponse = await client2.executeTool(parsed.toolId, parsed.params);
+  const rawResponse = await client2.executeTool(parsed.toolId, parsed.params, {
+    responseIntent: parsed.outPath || parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file" ? "row_artifact" : "raw"
+  });
   const listConversion = tryConvertToList(rawResponse, {
     listExtractorPaths: listExtractorPathsFromUsageGuidance(metadata)
   });
@@ -22069,6 +22324,7 @@ async function executeTool(args) {
     printCommandEnvelope(baseEnvelope, { json: false });
     return 0;
   }
+  const rowOutput = projectRowOutput(listConversion);
   const csv = writeCsvOutputFile(
     listConversion.rows,
     `${parsed.toolId}_output`,
@@ -22079,91 +22335,23 @@ async function executeTool(args) {
     payload: parsed.params,
     rows: listConversion.rows
   });
-  const materializedEnvelope = {
-    ...baseEnvelope,
-    local: {
-      extracted_csv: csv.path,
-      extracted_csv_rows: csv.rowCount,
-      extracted_csv_columns: csv.columns,
-      preview: csv.preview,
-      starter_script: seededScript.path,
-      project_dir: seededScript.projectDir,
-      copy_to_project: {
-        macos_linux: seededScript.macCopyCommand,
-        windows_powershell: seededScript.windowsCopyCommand
-      }
-    },
-    render: {
-      sections: [
-        {
-          title: `${csv.path} (${csv.rowCount} rows)`,
-          lines: [
-            ...csv.columns.length > 0 ? [`columns: ${JSON.stringify(csv.columns)}`] : [],
-            ...Object.keys(summary).length > 0 ? [
-              `summary: ${Object.entries(summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`
-            ] : [],
-            `preview: ${JSON.stringify(csv.preview)}`,
-            `starter script: ${seededScript.path}`
-          ]
-        }
-      ],
-      actions: [
-        {
-          label: "next",
-          command: "Move the script into a project folder and expand it into a Deepline play. Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
-        },
-        {
-          label: "macOS/Linux",
-          command: seededScript.macCopyCommand
-        },
-        {
-          label: "Windows PowerShell",
-          command: seededScript.windowsCopyCommand
-        }
-      ]
-    }
-  };
+  const materializedEnvelope = buildToolExecuteRowArtifactEnvelope({
+    baseEnvelope,
+    csv,
+    rowOutput,
+    summary,
+    seededScript
+  });
   if (parsed.outputFormat === "csv_file") {
-    printCommandEnvelope(
-      {
-        ...materializedEnvelope,
-        extracted_csv: csv.path,
-        extracted_csv_rows: csv.rowCount,
-        extracted_csv_columns: csv.columns,
-        preview: csv.preview,
-        list_strategy: listConversion.strategy,
-        list_source_path: listConversion.sourcePath,
-        starter_script: seededScript.path,
-        project_dir: seededScript.projectDir,
-        copy_to_project: {
-          macos_linux: seededScript.macCopyCommand,
-          windows_powershell: seededScript.windowsCopyCommand
-        },
-        summary
-      },
-      { json: true }
-    );
+    printCommandEnvelope(materializedEnvelope, { json: true });
     return 0;
   }
   if (parsed.outPath) {
-    printCommandEnvelope(
-      {
-        ...materializedEnvelope,
-        csv_path: csv.path,
-        row_count: csv.rowCount,
-        row_count_returned: csv.rowCount,
-        columns: csv.columns,
-        preview: csv.preview,
-        list_strategy: listConversion.strategy,
-        list_source_path: listConversion.sourcePath,
-        summary
-      },
-      {
-        json: argsWantJson(args) || shouldEmitJson(),
-        text: `Wrote ${csv.rowCount} row(s) to ${csv.path}
+    printCommandEnvelope(materializedEnvelope, {
+      json: argsWantJson(args) || shouldEmitJson(),
+      text: `Wrote ${csv.rowCount} row(s) to ${csv.path}
 `
-      }
-    );
+    });
     return 0;
   }
   if (parsed.noPreview) {
@@ -23353,7 +23541,7 @@ async function runAutomaticUpdatePlan(plan) {
       previousFailure
     };
   }
-  const exitCode = await runUpdatePlan(plan);
+  const exitCode = await runUpdatePlan(plan, { stdio: "stderr" });
   return exitCode === 0 ? { status: "updated", exitCode: 0 } : { status: "failed", exitCode };
 }
 function safeVersionSegment(value) {
@@ -23384,13 +23572,21 @@ function installedPackageVersion(versionDir) {
     return "";
   }
 }
-function runCommand(command, args, env = process.env) {
+function runCommand(command, args, env = process.env, options = {}) {
   return new Promise((resolveExitCode) => {
     const child = spawn3(command, args, {
-      stdio: "inherit",
+      stdio: options.stdio === "stderr" ? ["inherit", "pipe", "pipe"] : "inherit",
       shell: process.platform === "win32",
       env
     });
+    if (options.stdio === "stderr") {
+      child.stdout?.on("data", (chunk) => {
+        process.stderr.write(chunk);
+      });
+      child.stderr?.on("data", (chunk) => {
+        process.stderr.write(chunk);
+      });
+    }
     child.on("error", (error) => {
       process.stderr.write(`Failed to start ${command}: ${error.message}
 `);
@@ -23428,7 +23624,7 @@ function writeSidecarLauncher(input2) {
     { encoding: "utf8", mode: 493 }
   );
 }
-async function runPythonSidecarUpdatePlan(plan) {
+async function runPythonSidecarUpdatePlan(plan, options = {}) {
   const versionsDir = join13(plan.stateDir, "versions");
   const tempDir = join13(
     versionsDir,
@@ -23450,7 +23646,8 @@ async function runPythonSidecarUpdatePlan(plan) {
       ...NPM_SDK_INSTALL_COMMON_FLAGS,
       plan.packageSpec
     ],
-    env
+    env,
+    options
   );
   if (installExitCode !== 0) {
     rmSync3(tempDir, { recursive: true, force: true });
@@ -23523,12 +23720,12 @@ async function runPythonSidecarUpdatePlan(plan) {
   );
   return 0;
 }
-async function runUpdatePlan(plan) {
+async function runUpdatePlan(plan, options = {}) {
   let exitCode = 1;
   if (plan.kind === "npm-global") {
-    exitCode = await runCommand(plan.command, plan.args);
+    exitCode = await runCommand(plan.command, plan.args, process.env, options);
   } else if (plan.kind === "python-sidecar") {
-    exitCode = await runPythonSidecarUpdatePlan(plan);
+    exitCode = await runPythonSidecarUpdatePlan(plan, options);
   }
   if (exitCode === 0) {
     clearAutoUpdateFailure(plan);