deepline 0.1.160 → 0.1.162

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -64,11 +64,13 @@ import {
 import { RECEIPT_STATUS_CODE, receiptStatusFromCode } from './receipt-status';
 import type { MapRowOutcome } from './durability-store';
 import {
+  normalizeRuntimeMapInputIndex,
   prepareRuntimeSheetRowTransitions,
   type RuntimePreparedCompletedRow,
   type RuntimePreparedFailedRow,
 } from './runtime-sheet-row-transition';
 import {
+  MAP_ROW_OUTCOME_RUNTIME_FIELDS,
   mapRowOutcomeRuntimeFields,
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
@@ -2251,6 +2253,21 @@ async function prepareRuntimeSheetDatasetRows(
             AND (${targetMissingOutputSql})
           RETURNING target._key
         ),
+        claimed_existing_rows AS (
+          UPDATE ${sheetTable(session)} AS target
+          SET _run_id = $4::text,
+              _input_index = input_rows._input_index,
+              _updated_at = now(),
+              _version = ${nextRuntimeSheetVersionExpression(session)}
+          FROM input_rows
+          WHERE target._key = input_rows._key
+            AND target._status IN ('pending', 'running', 'failed')
+            AND (
+              target._run_id IS DISTINCT FROM $4::text
+              OR target._input_index IS DISTINCT FROM input_rows._input_index
+            )
+          RETURNING target._key
+        ),
         pending_rows AS (
           SELECT _key
           FROM inserted_rows
@@ -2258,6 +2275,9 @@ async function prepareRuntimeSheetDatasetRows(
           SELECT _key
           FROM missing_output_rows
           UNION
+          SELECT _key
+          FROM claimed_existing_rows
+          UNION
           SELECT existing._key
           FROM ${sheetTable(session)} AS existing
           JOIN input_rows ON input_rows._key = existing._key
@@ -3206,7 +3226,10 @@ export async function startRuntimeSheetDataset(
     rows: input.rows.length,
   });
   const normalizeStartedAt = Date.now();
-  const uniqueRows = new Map<string, Record<string, unknown>>();
+  const uniqueRows = new Map<
+    string,
+    { row: Record<string, unknown>; inputIndex: number | null }
+  >();
   for (const row of input.rows) {
     // Materializes projected CSV aliases as visible cells and drops internal
     // __deepline* keys — a plain spread would silently lose the
@@ -3216,15 +3239,20 @@ export async function startRuntimeSheetDataset(
       resolveMapRowOutcomeKey(row) ??
       derivePlayRowIdentity(cleanedRow, input.tableNamespace);
     if (key && !uniqueRows.has(key)) {
-      uniqueRows.set(key, cleanedRow);
+      uniqueRows.set(key, {
+        row: cleanedRow,
+        inputIndex: normalizeRuntimeMapInputIndex(
+          row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.inputIndex],
+        ),
+      });
     }
   }
   const inputOffset = Math.max(0, Math.floor(input.inputOffset ?? 0));
   const rowEntries = [...uniqueRows.entries()].map(
-    ([key, row], inputIndex) => ({
+    ([key, entry], inputIndex) => ({
       key,
-      row,
-      inputIndex: inputOffset + inputIndex,
+      row: entry.row,
+      inputIndex: entry.inputIndex ?? inputOffset + inputIndex,
     }),
   );
   timings.push({
@@ -3409,6 +3437,7 @@ async function completeRuntimeMapRowChunks(
            AND (target._run_id IS NULL OR target._run_id <= $5::text)
            AND (
              target._status <> 'enriched'
+             OR target._run_id IS DISTINCT FROM $5::text
              OR (${targetChangedPatchedCellSql})
              OR EXISTS (
                SELECT 1
@@ -3608,6 +3637,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
            AND (target._run_id IS NULL OR target._run_id <= $5::text)
            AND (
              target._status <> 'enriched'
+             OR target._run_id IS DISTINCT FROM $5::text
              OR (${targetChangedPatchedCellSql})
              OR EXISTS (
                SELECT 1
@@ -3722,6 +3752,148 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
   return { updated };
 }
 
+async function insertMissingCompletedMapRowChunks(
+  client: RuntimeQueryClient,
+  session: RuntimePostgresSession,
+  input: CompleteRuntimeMapRowChunksInput,
+): Promise<{ inserted: number }> {
+  let inserted = 0;
+  const physicalInsertColumnsSql =
+    input.physicalColumnProjections.length > 0
+      ? `, ${input.physicalColumnProjections
+          .map((column) => quoteIdentifier(column.sqlName))
+          .join(', ')}`
+      : '';
+  const physicalInsertValuesSql =
+    input.physicalColumnProjections.length > 0
+      ? `, ${input.physicalColumnProjections
+          .map(
+            (column) =>
+              `missing_rows.data_patch -> ${quoteLiteral(column.fieldName)}`,
+          )
+          .join(', ')}`
+      : '';
+
+  for (const chunk of input.chunks) {
+    const chunkKeys = chunk.map((row) => row.key);
+    const chunkInputIndexes = chunk.map((row) => row.input_index);
+    const chunkDataPatches = chunk.map((row) =>
+      stringifyPostgresJson(row.data_patch),
+    );
+    const chunkCellMetaPatches = chunk.map((row) =>
+      stringifyPostgresJson(row.cell_meta_patch),
+    );
+    const { rows } = await client.query<{ inserted: number }>(
+      `WITH input_rows AS (
+         SELECT key_values._key,
+                input_index_values.input_index,
+                data_values.data_patch,
+                cell_meta_values.cell_meta_patch
+         FROM unnest($1::text[]) WITH ORDINALITY AS key_values(_key, ord)
+         JOIN unnest($2::bigint[]) WITH ORDINALITY AS input_index_values(input_index, ord)
+           ON input_index_values.ord = key_values.ord
+         JOIN unnest($3::jsonb[]) WITH ORDINALITY AS data_values(data_patch, ord)
+           ON data_values.ord = key_values.ord
+         JOIN unnest($4::jsonb[]) WITH ORDINALITY AS cell_meta_values(cell_meta_patch, ord)
+           ON cell_meta_values.ord = key_values.ord
+       ),
+       missing_rows AS (
+         SELECT input_rows.*
+           FROM input_rows
+          WHERE NOT EXISTS (
+            SELECT 1
+              FROM ${sheetTable(session)} AS target
+             WHERE target._key = input_rows._key
+                OR (
+                  input_rows.input_index IS NOT NULL
+                  AND target._run_id = $5::text
+                  AND target._input_index = input_rows.input_index
+                )
+          )
+       ),
+       inserted_rows AS (
+         INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index, _cell_meta${physicalInsertColumnsSql})
+         SELECT _key, 'enriched', $5::text, input_index, cell_meta_patch${physicalInsertValuesSql}
+           FROM missing_rows
+         ON CONFLICT (_key) DO NOTHING
+         RETURNING _key
+       ),
+       inserted_count AS (
+         SELECT count(*)::bigint AS c FROM inserted_rows
+       ),
+       summary_delta AS (
+         INSERT INTO ${summaryTable(session)} AS target (
+           play_name,
+           table_namespace,
+           total,
+           queued,
+           running,
+           completed,
+           failed
+         )
+         SELECT $6::text,
+                $7::text,
+                c::int,
+                0,
+                0,
+                c::int,
+                0
+           FROM inserted_count
+          WHERE c > 0
+         ON CONFLICT (play_name, table_namespace) DO UPDATE SET
+           total = ${runtimeSummaryTotalSql({
+             currentTotal: 'target.total',
+             totalDelta: 'EXCLUDED.total',
+             queued: 'target.queued',
+             running: 'target.running',
+             completed: 'target.completed + EXCLUDED.completed',
+             failed: 'target.failed',
+           })},
+           completed = target.completed + EXCLUDED.completed,
+           _updated_at = now()
+         RETURNING 1
+       ),
+       completed_cell_delta AS (
+         SELECT field_values.field, (SELECT c FROM inserted_count) AS c
+           FROM unnest($8::text[]) AS field_values(field)
+          WHERE (SELECT c FROM inserted_count) > 0
+       ),
+       column_delta AS (
+         INSERT INTO ${columnSummaryTable(session)} AS target (
+           play_name,
+           table_namespace,
+           field,
+           completed,
+           failed
+         )
+         SELECT $6::text,
+                $7::text,
+                field,
+                c::int,
+                0
+           FROM completed_cell_delta
+         ON CONFLICT (play_name, table_namespace, field) DO UPDATE SET
+           completed = target.completed + EXCLUDED.completed,
+           _updated_at = now()
+         RETURNING 1
+       )
+       SELECT c::int AS inserted FROM inserted_count`,
+      [
+        chunkKeys,
+        chunkInputIndexes,
+        chunkDataPatches,
+        chunkCellMetaPatches,
+        input.runId,
+        input.normalizedPlayName,
+        input.normalizedTableNamespace,
+        [...new Set(input.outputFields)],
+      ],
+    );
+    inserted += Number(rows[0]?.inserted ?? 0);
+  }
+  return { inserted };
+}
+
 /**
  * Mark map rows FAILED in the per-run scoped Postgres sheet table by key.
  *
@@ -4003,17 +4175,30 @@ export async function completeRuntimeMapRows(
     async (client) => {
       const completed =
         completedRows.length > 0
-          ? await completeRuntimeMapRowChunks(client, session, {
-              chunks,
-              physicalUpdateSetSql,
-              physicalColumnProjections: projections,
-              runId: input.runId,
-              normalizedPlayName: normalizePlayNameForSheet(session.playName),
-              normalizedTableNamespace: normalizeTableNamespace(
-                input.tableNamespace,
-              ),
-              outputFields,
-            })
+          ? await (async () => {
+              const chunkInput = {
+                chunks,
+                physicalUpdateSetSql,
+                physicalColumnProjections: projections,
+                runId: input.runId,
+                normalizedPlayName: normalizePlayNameForSheet(session.playName),
+                normalizedTableNamespace: normalizeTableNamespace(
+                  input.tableNamespace,
+                ),
+                outputFields,
+              };
+              const updated = await completeRuntimeMapRowChunks(
+                client,
+                session,
+                chunkInput,
+              );
+              const inserted = await insertMissingCompletedMapRowChunks(
+                client,
+                session,
+                chunkInput,
+              );
+              return { updated: updated.updated + inserted.inserted };
+            })()
           : { updated: 0 };
       const failed =
         failedRows.length > 0
@@ -4075,6 +4260,65 @@ export async function readRuntimeSheetDatasetRows(
   };
 }
 
+export async function readRuntimeSheetDatasetRowKeys(
+  context: RuntimeApiContext & { playName: string },
+  input: {
+    tableNamespace: string;
+    runId: string;
+    keys: string[];
+    rowMode?: 'output' | 'all';
+  },
+): Promise<{ keys: string[] }> {
+  const keys = [
+    ...new Set(
+      input.keys
+        .map((key) => key.trim())
+        .filter((key) => key.length > 0),
+    ),
+  ];
+  if (keys.length === 0) {
+    return { keys: [] };
+  }
+  const session = requireRuntimePostgresSession(
+    await getRuntimeDbSession(
+      {
+        ...context,
+        playName: context.playName,
+        runId: context.runId ?? input.runId,
+      },
+      {
+        tableNamespace: input.tableNamespace,
+        logicalTable: 'sheet_rows',
+        operations: ['rows.read'],
+        limits: { maxRows: runtimeDbSessionRowLimit(keys.length) },
+      },
+    ),
+  );
+  const rows = await withRuntimePostgres(session, async (client) => {
+    if (input.rowMode === 'all') {
+      const { rows: matchedRows } = await client.query<{ _key: string }>(
+        `SELECT _key
+           FROM ${sheetTable(session)}
+          WHERE _run_id = $1::text
+            AND _key = ANY($2::text[])
+            AND _status IN ('enriched', 'failed')`,
+        [input.runId, keys],
+      );
+      return matchedRows;
+    }
+    const { rows: matchedRows } = await client.query<{ _key: string }>(
+      `SELECT _key
+         FROM ${sheetTable(session)}
+        WHERE _run_id = $1::text
+          AND _key = ANY($2::text[])
+          AND _status = 'enriched'`,
+      [input.runId, keys],
+    );
+    return matchedRows;
+  });
+  return { keys: rows.map((row) => row._key) };
+}
+
 export async function persistRuntimeCsvDataset(
   context: RuntimeApiContext & { playName: string },
   input: {

package/dist/cli/index.js

@@ -237,8 +237,6 @@ 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",
@@ -553,18 +551,6 @@ function ensureProjectEnvIsIgnored(dir) {
   (0, import_node_fs.writeFileSync)(gitignorePath, `${existing}${prefix}${entry}
 `, "utf-8");
 }
-function ensureWorkspaceRestoreEnvIsIgnored(workspaceDir) {
-  const gitignorePath = (0, import_node_path.join)(workspaceDir, ".gitignore");
-  const entry = `${WORKSPACE_RESTORE_ENV_DIR}/`;
-  const existing = (0, import_node_fs.existsSync)(gitignorePath) ? (0, import_node_fs.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" : "";
-  (0, import_node_fs.writeFileSync)(gitignorePath, `${existing}${prefix}${entry}
-`, "utf-8");
-}
 function saveProjectDeeplineEnvValues(values, startDir = process.cwd()) {
   const target = resolveProjectPinTarget(startDir);
   if (!target.ok) {
@@ -578,27 +564,6 @@ 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 = (0, import_node_path.join)(
-    workspaceDir,
-    WORKSPACE_RESTORE_ENV_DIR,
-    WORKSPACE_RESTORE_ENV_FILE
-  );
-  const existing = parseEnvFile(filePath);
-  const merged = { ...existing, ...values };
-  const dir = (0, import_node_path.dirname)(filePath);
-  if (!(0, import_node_fs.existsSync)(dir)) (0, import_node_fs.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}`);
-  (0, import_node_fs.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)) {
@@ -657,10 +622,10 @@ 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.160",
+  version: "0.1.162",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.160",
+    latest: "0.1.162",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -4748,9 +4713,6 @@ 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 = {
@@ -17780,7 +17742,7 @@ function fallbackRowsInfoForGeneratedEnrichExport(status, options) {
     columns: [],
     columnsExplicit: false,
     complete: false,
-    source: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE,
+    source: null,
     tableNamespace: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE
   };
 }
@@ -17801,10 +17763,45 @@ function hasLossyPreviewPlaceholder(value, depth = 0) {
   }
   return false;
 }
+function statusReferencesGeneratedEnrichRows(value, depth = 0) {
+  if (depth > 12 || value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim() === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  }
+  if (Array.isArray(value)) {
+    return value.some(
+      (item) => statusReferencesGeneratedEnrichRows(item, depth + 1)
+    );
+  }
+  if (typeof value === "object") {
+    return Object.values(value).some(
+      (item) => statusReferencesGeneratedEnrichRows(item, depth + 1)
+    );
+  }
+  return false;
+}
+function generatedEnrichRowsTableNamespaceForExport(rowsInfo, status) {
+  const tableNamespace = rowsInfo.tableNamespace?.trim() || null;
+  if (tableNamespace === "result.rows") {
+    return GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  }
+  if (!tableNamespace && statusReferencesGeneratedEnrichRows(status)) {
+    return GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  }
+  return tableNamespace;
+}
 function shouldFetchBackingRowsForEnrichExport(rowsInfo, status, options = {}) {
   const terminalStatus = readEnrichRunStatus(status);
-  const tableNamespace = rowsInfo.tableNamespace?.trim();
+  const tableNamespace = generatedEnrichRowsTableNamespaceForExport(
+    rowsInfo,
+    status
+  );
   if (terminalStatus === "failed" || terminalStatus === "cancelled") {
+    if (tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && rowsInfo.source !== null && typeof options.selectedSourceRows === "number" && rowsInfo.rows.length < options.selectedSourceRows) {
+      return true;
+    }
     return tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && (rowsInfo.recovered === true || hasPartialRunOutputWarning(status));
   }
   if (tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && typeof options.selectedSourceRows === "number" && rowsInfo.rows.length < options.selectedSourceRows) {
@@ -17932,6 +17929,45 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   }
   return fallback;
 }
+function mergeExportedSheetRow(target, next) {
+  const baseMetadata = target._metadata;
+  const nextMetadata = next._metadata;
+  for (const [key, value] of Object.entries(next)) {
+    const existing = target[key];
+    if (isNonEmptyCsvCell(existing) && !isNonEmptyCsvCell(value)) {
+      continue;
+    }
+    target[key] = value;
+  }
+  const metadata = mergeLegacyMetadataCell(baseMetadata, nextMetadata);
+  if (metadata !== void 0) {
+    target._metadata = metadata;
+  }
+}
+function coalesceExportableSheetRows(rows, sourceRowStart = 0) {
+  const mergedRows = [];
+  const bySourceRowIndex = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const rowIndex = sourceRowIndexFromEnrichRow(
+      row,
+      sourceRowStart,
+      Number.MAX_SAFE_INTEGER
+    );
+    if (rowIndex === null) {
+      mergedRows.push(row);
+      continue;
+    }
+    const existing = bySourceRowIndex.get(rowIndex);
+    if (existing) {
+      mergeExportedSheetRow(existing, row);
+      continue;
+    }
+    const next = { ...row };
+    bySourceRowIndex.set(rowIndex, next);
+    mergedRows.push(next);
+  }
+  return mergedRows;
+}
 function sourceRowIndexFromEnrichRow(row, start, end) {
   const value = row[ENRICH_SOURCE_ROW_INDEX_COLUMN];
   const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
@@ -18036,7 +18072,11 @@ function aliasFailureCellCandidates(row, alias) {
     if (key.startsWith(dottedPrefix)) {
       assignFlattenedFailurePath(nested, key.slice(dottedPrefix.length), value);
     } else if (key.startsWith(underscorePrefix)) {
-      assignFlattenedFailurePath(nested, key.slice(underscorePrefix.length), value);
+      assignFlattenedFailurePath(
+        nested,
+        key.slice(underscorePrefix.length),
+        value
+      );
     }
   }
   if (Object.keys(nested).length > 0) {
@@ -18414,13 +18454,14 @@ function mergePreferredColumns(preferredColumns, rows) {
 async function fetchBackingRowsForCsvExport(input2) {
   const runId = extractRunId(input2.status);
   const playName = extractPlayName2(input2.status);
-  const tableNamespace = input2.rowsInfo.tableNamespace?.trim() || GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  const tableNamespace = generatedEnrichRowsTableNamespaceForExport(input2.rowsInfo, input2.status) || GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
   if (!runId || !playName || !tableNamespace) {
     return null;
   }
   const deadline = Date.now() + enrichExportBackingRowsWaitMs();
   let lastRows = [];
-  const minimumExpectedRows = typeof input2.expectedRows === "number" && input2.expectedRows > 0 ? Math.trunc(input2.expectedRows) : input2.rowsInfo.totalRows;
+  const hasExplicitExpectedRows = typeof input2.expectedRows === "number" && input2.expectedRows > 0;
+  const minimumExpectedRows = hasExplicitExpectedRows ? Math.trunc(Number(input2.expectedRows)) : input2.rowsInfo.totalRows;
   let lastExpectedTotal = minimumExpectedRows;
   for (; ; ) {
     const sheetRows = [];
@@ -18445,10 +18486,15 @@ async function fetchBackingRowsForCsvExport(input2) {
       }
       offset += page.rows.length;
     }
-    const rows = sheetRows.map((row) => exportableSheetRow2(row, input2.sourceRowStart ?? 0)).filter((row) => Boolean(row));
+    const rawRows = sheetRows.map((row) => exportableSheetRow2(row, input2.sourceRowStart ?? 0)).filter((row) => Boolean(row));
+    const rows = coalesceExportableSheetRows(
+      rawRows,
+      input2.sourceRowStart ?? 0
+    );
     lastRows = rows;
     lastExpectedTotal = expectedTotal;
-    if (expectedTotal > 0 && rows.length >= expectedTotal || expectedTotal === 0 && rows.length > 0) {
+    const requiredExportRows = hasExplicitExpectedRows ? minimumExpectedRows : expectedTotal;
+    if (requiredExportRows > 0 && rows.length >= requiredExportRows || requiredExportRows === 0 && rows.length > 0) {
       return {
         ...input2.rowsInfo,
         rows,
@@ -18456,7 +18502,7 @@ async function fetchBackingRowsForCsvExport(input2) {
           input2.rowsInfo.columnsExplicit ? input2.rowsInfo.columns : [],
           rows
         ),
-        totalRows: Math.max(rows.length, expectedTotal),
+        totalRows: hasExplicitExpectedRows ? Math.max(rows.length, minimumExpectedRows) : Math.max(rows.length, expectedTotal),
         complete: true,
         source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
       };
@@ -18476,7 +18522,7 @@ async function fetchBackingRowsForCsvExport(input2) {
       input2.rowsInfo.columnsExplicit ? input2.rowsInfo.columns : [],
       lastRows
     ),
-    totalRows: Math.max(lastExpectedTotal, input2.rowsInfo.totalRows),
+    totalRows: hasExplicitExpectedRows ? Math.max(lastRows.length, minimumExpectedRows) : Math.max(lastExpectedTotal, input2.rowsInfo.totalRows),
     complete: false,
     source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
   };
@@ -18664,8 +18710,13 @@ function materializeAliasSuccessCell(row, alias) {
         directCells.push({ field, value });
       }
     }
-    for (const preferredField of [alias, ...ENRICH_FLATTENED_SUCCESS_FIELD_PRIORITY]) {
-      const preferred = directCells.find(({ field }) => field === preferredField);
+    for (const preferredField of [
+      alias,
+      ...ENRICH_FLATTENED_SUCCESS_FIELD_PRIORITY
+    ]) {
+      const preferred = directCells.find(
+        ({ field }) => field === preferredField
+      );
       if (preferred) {
         return materializeCsvCellValue(preferred.value);
       }
@@ -18867,7 +18918,7 @@ function assertCompleteRowsForCsvExport(rowsInfo, status, outputPath, options =
     return;
   }
   const runId = status && typeof status === "object" && !Array.isArray(status) && typeof status.runId === "string" ? status.runId : null;
-  const dataset = rowsInfo.source ?? "result.rows";
+  const dataset = rowsInfo.source ?? rowsInfo.tableNamespace ?? "result.rows";
   const retry = runId ? ` Retry after the run finalizes its backing dataset with: deepline runs export ${runId} --dataset ${dataset} --out ${outputPath}` : "";
   throw new Error(
     `Refusing to write a partial CSV export: the run returned ${rowsInfo.rows.length} preview row(s) out of ${rowsInfo.totalRows}.${retry}`
@@ -20502,7 +20553,9 @@ async function handleOrgStatus(options) {
   const config = resolveConfig();
   const http = new HttpClient(config);
   const payload = await fetchOrganizations(http, config.apiKey);
-  const current = payload.organizations.find((org) => org.is_current) ?? payload.organizations.find((org) => org.org_id === payload.current_org_id) ?? null;
+  const current = payload.organizations.find((org) => org.is_current) ?? payload.organizations.find(
+    (org) => org.org_id === payload.current_org_id
+  ) ?? null;
   const projectCandidate = getActiveProjectAuthSource();
   const activeProject = getResolvedProjectAuthSource(
     config.baseUrl,
@@ -20634,15 +20687,14 @@ async function handleOrgSwitch(selection, options) {
     } else {
       saveHostEnvValues(config.baseUrl, authValues2);
     }
-    if (authTarget.kind === "folder") {
-      saveCoworkWorkspaceRestoreEnvValues(authValues2);
-    }
     const renderLines2 = [`Already on ${target.name}.`];
     for (const projectPath of project_env_paths2) {
       renderLines2.push(`Saved folder auth in ${projectPath}`);
     }
     if (authTarget.kind === "global") {
-      renderLines2.push(`Saved global auth in ${hostEnvFilePath(config.baseUrl)}`);
+      renderLines2.push(
+        `Saved global auth in ${hostEnvFilePath(config.baseUrl)}`
+      );
     }
     renderLines2.push(
       `Scope: ${authTarget.requested_scope} -> ${authTarget.effective_scope} (${authTarget.reason})`
@@ -20697,9 +20749,6 @@ async function handleOrgSwitch(selection, options) {
       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") {
@@ -20764,7 +20813,6 @@ async function handleOrgCreate(name, options) {
     DEEPLINE_ACTIVE_ORG_ID: created.org_id,
     DEEPLINE_ACTIVE_ORG_NAME: created.org_name
   });
-  saveCoworkWorkspaceRestoreEnvValues(authValues);
   const { api_key: _apiKey, ...publicCreated } = created;
   printCommandEnvelope(
     {
@@ -20873,7 +20921,10 @@ Examples:
     "--auth-scope <scope>",
     "Where to save auth: auto, folder, or global",
     "auto"
-  ).option("--json", "Emit JSON output. Also automatic when stdout is piped");
+  ).option(
+    "--json",
+    "Emit JSON output. Also automatic when stdout is piped"
+  );
   addOrgSetOptions(
     org.command("set [selection]").description("Set the organization for the selected auth scope.").addHelpText(
       "after",