orizu 0.5.39 → 0.5.41

package/src/task-commands.ts

@@ -26,20 +26,6 @@ import type { TaskStatusPayload } from './account-directory.js'
 
 
 
-interface TaskReportPayload {
-  task: {
-    id: string
-    title?: string | null
-    status?: string | null
-    report: {
-      markdown: string
-      sourceName: string | null
-      createdAt: string | null
-      updatedAt?: string | null
-    }
-  }
-}
-
 function readTaskReportInput(): { markdown: string; sourceName: string | null } | null {
   return readMarkdownReportInput(cliArgs, 'Task')
 }
@@ -619,30 +605,14 @@ async function setTaskReport() {
     )
   }
 
-  const response = await authedFetch(`/api/cli/tasks/${encodeURIComponent(taskId)}/report`, {
-    method: 'PATCH',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      reportMarkdown: report.markdown,
-      reportSourceName: report.sourceName,
-    }),
-  })
-
-  if (!response.ok) {
-    throw new Error(`Failed to update task report: ${await response.text()}`)
+  // Loaded lazily: the workflow pulls in Effect (ORI-2408).
+  const workflow = await import('./task-report-workflow.js')
+  const outcome = await workflow.setTaskReport(taskId, report)
+  if (outcome.kind === 'interrupted') {
+    process.exitCode = outcome.exitCode
+    return
   }
-
-  const data = await parseJsonResponse<{
-    task: {
-      id: string
-      status: string
-      report: {
-        markdown: string
-        sourceName: string | null
-        createdAt: string | null
-      }
-    }
-  }>(response, 'Task report update')
+  const data = outcome.reply
 
   if (hasJsonFlag()) {
     printJson(data)
@@ -662,12 +632,8 @@ async function getTaskReport() {
     throw new Error('Usage: orizu tasks report get --task <taskId> [--json]')
   }
 
-  const response = await authedFetch(`/api/cli/tasks/${encodeURIComponent(taskId)}/report`)
-  if (!response.ok) {
-    throw new Error(`Failed to read task report: ${await response.text()}`)
-  }
-
-  const data = await parseJsonResponse<TaskReportPayload>(response, 'Task report get')
+  const workflow = await import('./task-report-workflow.js')
+  const data = await workflow.getTaskReport(taskId)
   if (hasJsonFlag()) {
     printJson(data as unknown as Record<string, unknown>)
     return

package/src/task-export-workflow.ts

@@ -0,0 +1,56 @@
+import { Effect, Exit, Result } from 'effect'
+import { renameSync, rmSync, writeFileSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+
+import { authedFetch } from './http.js'
+
+export type TaskExportFormat = 'csv' | 'json' | 'jsonl'
+
+// Node's "CODE: description, syscall 'path'" without the syscall and path, so a
+// failed save names the user's target rather than the temp file.
+function saveFailureReason(cause: unknown): string {
+  const message = cause instanceof Error ? cause.message : String(cause)
+  return message.replace(/, \w+( '.*')?$/, '')
+}
+
+/**
+ * Writes the export beside `target` and renames it over the target, so a failed
+ * or interrupted save never touches the file the user already has. The temp file
+ * is removed whenever the save does not finish.
+ */
+function saveExportFile(target: string, bytes: Uint8Array) {
+  const temp = join(dirname(target), `.${basename(target)}.${process.pid}.tmp`)
+  return Effect.acquireUseRelease(
+    Effect.succeed(temp),
+    path => Effect.try({
+      try: () => {
+        writeFileSync(path, bytes, { flag: 'wx' })
+        renameSync(path, target)
+      },
+      catch: cause => new Error(`Could not save export to ${target}: ${saveFailureReason(cause)}`, { cause }),
+    }),
+    (path, exit) => Exit.isSuccess(exit) ? Effect.void : Effect.sync(() => rmSync(path, { force: true }))
+  )
+}
+
+/**
+ * `orizu tasks export`: one GET of the export, never retried, then a safe save.
+ * A refused export fails with `Download failed: <body>` before anything is written.
+ */
+function downloadTaskExport(taskId: string, format: TaskExportFormat, target: string) {
+  return Effect.gen(function* () {
+    const response = yield* Effect.promise(() => authedFetch(`/api/cli/tasks/${taskId}/export?format=${format}`))
+    if (!response.ok) {
+      const body = yield* Effect.promise(() => response.text())
+      return yield* Effect.fail(new Error(`Download failed: ${body}`))
+    }
+    const bytes = new Uint8Array(yield* Effect.promise(() => response.arrayBuffer()))
+    yield* saveExportFile(target, bytes)
+  })
+}
+
+/** Promise runner for the command: rejects with the message the CLI prints. */
+export async function runTaskExportDownload(taskId: string, format: TaskExportFormat, target: string): Promise<void> {
+  const result = await Effect.runPromise(Effect.result(downloadTaskExport(taskId, format, target)))
+  if (Result.isFailure(result)) throw result.failure
+}

package/src/task-report-workflow.ts

@@ -0,0 +1,179 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect'
+
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js'
+import { isJsonErrorResponsePayload } from './error-response.js'
+import { authedFetch } from './http.js'
+import { parseJsonResponse } from './json-response.js'
+
+// Loaded only through `await import(...)` from task-commands. One request per
+// command, never retried, with the same deadline as the dataset workflows.
+
+const mayBeSaved = (taskId: string) =>
+  `The task report may already be saved: check with \`orizu tasks report get --task ${taskId}\` before setting it again.`
+
+const SetReply = Schema.Struct({
+  task: Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    report: Schema.Struct({
+      markdown: Schema.String,
+      sourceName: Schema.NullOr(Schema.String),
+      createdAt: Schema.NullOr(Schema.String),
+    }),
+  }),
+})
+
+// title, status and updatedAt stay optional, as in the payload type this replaced.
+const GetReply = Schema.Struct({
+  task: Schema.Struct({
+    id: Schema.String,
+    title: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    status: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    report: Schema.Struct({
+      markdown: Schema.String,
+      sourceName: Schema.NullOr(Schema.String),
+      createdAt: Schema.NullOr(Schema.String),
+      updatedAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    }),
+  }),
+})
+
+type TaskReportSetReply = typeof SetReply.Type
+export type TaskReportGetReply = typeof GetReply.Type
+
+// `mayBeSaved` (the #2164 rule): an error reply in the app's own `{ error }`
+// shape is reported plainly, whatever its status. A lost, stalled or unreadable
+// reply, a 5xx that did not come from the app (a gateway giving up while the
+// app kept working), or a reply of the wrong shape means it may have been saved.
+class ReportRequestFailure extends Error {
+  constructor(message: string, readonly mayBeSaved: boolean, cause?: unknown) { super(message, { cause }) }
+}
+
+function isAppError(response: Response, text: string): boolean {
+  try {
+    return isJsonErrorResponsePayload(response, JSON.parse(text))
+  } catch {
+    return false
+  }
+}
+
+/** One request with a deadline. Returns the reply as parsed once `accepts` agrees with its shape. */
+function reportRequest(input: {
+  taskId: string
+  init: RequestInit
+  failurePrefix: string
+  label: string
+  accepts: (data: unknown) => boolean
+  deadlineMessage: string
+  timeoutMs: number
+  onSent?: () => void
+}) {
+  return Effect.suspend(() => {
+    let sent = false
+    let timedOut = false
+    return Effect.tryPromise({
+      try: async signal => {
+        const request = new AbortController()
+        const abort = () => request.abort()
+        const timer = setTimeout(() => { timedOut = true; request.abort() }, input.timeoutMs)
+        if (signal.aborted) abort()
+        else signal.addEventListener('abort', abort, { once: true })
+        try {
+          const response = await authedFetch(
+            `/api/cli/tasks/${encodeURIComponent(input.taskId)}/report`,
+            { ...input.init, signal: request.signal },
+            () => { sent = true; input.onSent?.() }
+          )
+          if (!response.ok) {
+            const text = await response.text()
+            const fromApp = isAppError(response, text)
+            throw new ReportRequestFailure(`${input.failurePrefix}: ${text}`, response.status < 400 || (response.status >= 500 && !fromApp))
+          }
+          const data = await parseJsonResponse<unknown>(response, input.label)
+          if (!input.accepts(data)) {
+            throw new ReportRequestFailure(`${input.label} returned an unexpected response (status ${response.status}).`, true)
+          }
+          return data
+        } finally {
+          clearTimeout(timer)
+          signal.removeEventListener('abort', abort)
+          request.abort()
+        }
+      },
+      catch: cause => {
+        if (timedOut) return new ReportRequestFailure(input.deadlineMessage, sent, cause)
+        if (cause instanceof ReportRequestFailure) return cause
+        return new ReportRequestFailure(cause instanceof Error ? cause.message : String(cause), sent, cause)
+      },
+    })
+  })
+}
+
+const accepts = (schema: typeof SetReply | typeof GetReply) => (data: unknown) => Result.isSuccess(Schema.decodeUnknownResult(schema)(data))
+
+export type TaskReportSetOutcome =
+  | { kind: 'saved'; reply: TaskReportSetReply }
+  | { kind: 'interrupted'; exitCode: 130 | 143 }
+
+/**
+ * `orizu tasks report set`. Ctrl-C or SIGTERM aborts the request and, once it
+ * was sent, says the report may already be saved: the server finishes on its
+ * own. Other failures throw, adding the same line when the outcome is unknown.
+ */
+export async function setTaskReport(taskId: string, report: { markdown: string; sourceName: string | null }): Promise<TaskReportSetOutcome> {
+  const timeoutMs = datasetTransferTimeoutMs()
+  const controller = new AbortController()
+  let interrupted: 130 | 143 | undefined
+  let sent = false
+  const interrupt = () => { interrupted ??= 130; controller.abort() }
+  const terminate = () => { interrupted ??= 143; controller.abort() }
+  process.on('SIGINT', interrupt)
+  process.on('SIGTERM', terminate)
+  try {
+    const exit = await Effect.runPromiseExit(reportRequest({
+      taskId,
+      init: {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ reportMarkdown: report.markdown, reportSourceName: report.sourceName }),
+      },
+      failurePrefix: 'Failed to update task report',
+      label: 'Task report update',
+      accepts: accepts(SetReply),
+      deadlineMessage: 'Task report save exceeded its deadline',
+      timeoutMs,
+      onSent: () => { sent = true },
+    }), { signal: controller.signal })
+    if (interrupted !== undefined) {
+      process.stderr.write(sent ? `Task report save interrupted. ${mayBeSaved(taskId)}\n` : 'Task report save interrupted.\n')
+      return { kind: 'interrupted', exitCode: interrupted }
+    }
+    if (Exit.isSuccess(exit)) return { kind: 'saved', reply: exit.value as TaskReportSetReply }
+    throw withMayBeSaved(Cause.squash(exit.cause), taskId)
+  } finally {
+    process.removeListener('SIGINT', interrupt)
+    process.removeListener('SIGTERM', terminate)
+  }
+}
+
+function withMayBeSaved(failure: unknown, taskId: string): unknown {
+  if (!(failure instanceof ReportRequestFailure)) return failure
+  const message = failure.mayBeSaved ? `${failure.message}\n${mayBeSaved(taskId)}` : failure.message
+  return new Error(message, { cause: failure.cause })
+}
+
+/** `orizu tasks report get`: one read with a deadline. Signals keep Node's default handling. */
+export async function getTaskReport(taskId: string): Promise<TaskReportGetReply> {
+  const exit = await Effect.runPromiseExit(reportRequest({
+    taskId,
+    init: {},
+    failurePrefix: 'Failed to read task report',
+    label: 'Task report get',
+    accepts: accepts(GetReply),
+    deadlineMessage: 'Task report read exceeded its deadline',
+    timeoutMs: datasetTransferTimeoutMs(),
+  }))
+  if (Exit.isSuccess(exit)) return exit.value as TaskReportGetReply
+  const failure = Cause.squash(exit.cause)
+  throw failure instanceof ReportRequestFailure ? new Error(failure.message, { cause: failure.cause }) : failure
+}

package/src/workbench-cli.ts

@@ -1176,7 +1176,7 @@ function formatSessionFinishOutcome(result: SessionFinishResult): string {
 // The web page's failed line, with the reason the server mapped (ORI-2264).
 function failedRunLine(run: { status: string; failureReason?: unknown }): string | null {
   return run.status === 'failed' && typeof run.failureReason === 'string' && run.failureReason
-    ? `The agent stopped: ${run.failureReason}.`
+    ? run.failureReason === 'The selected model is unavailable in this session.' ? run.failureReason : `The agent stopped: ${run.failureReason}.`
     : null
 }
 

package/vendor/skills/orizu/references/cli-reference.md

@@ -351,6 +351,40 @@ orizu datasets lock --dataset <datasetId|datasetUrl> --reason "Finalize for labe
 orizu datasets clone --dataset <datasetId|datasetUrl> --name "Batch 1 Copy"
 ```
 
+For validation-first enrichment, start with an explicit immutable version ID
+returned by upload or version creation. Discover the saved names, export the
+assignments, then download only the selected partition:
+
+```bash
+orizu datasets splits list DATASET_VERSION_ID --json
+orizu datasets splits show SPLIT_SET_ID --json > split.json
+orizu datasets download --dataset-version DATASET_VERSION_ID --split-set SPLIT_SET_ID --split validation --format jsonl --out validation.jsonl
+```
+
+The download retains canonical `id` values and existing fields in saved partition
+order; `--format json` is also supported. Custom partition names and empty splits
+are valid. Pinned reads remain unchanged after live row edits and require no
+prompt, runner, scorer or optimization. Unknown/inaccessible or mismatched
+selectors and incomplete artifacts fail without live-data fallback.
+
+For saved split names beginning with `--`, use the unambiguous equals spelling:
+`orizu datasets download --dataset-version DATASET_VERSION_ID --split-set SPLIT_SET_ID --split=--validation --format jsonl --out validation.jsonl`.
+The same spelling supports `--split=--json` and `--split=--help`; all pinned selectors remain required.
+
+Enrich rows outside Orizu, preserving every canonical `id`. Assemble the complete
+enriched dataset, including other partitions, and upload or version it. Import
+assignments into the explicit new version:
+
+```bash
+orizu datasets splits create TARGET_DATASET_VERSION_ID --from-file split.json --json
+```
+
+Show JSON preserves `name`, `strategy`, `seed`, `metadata`, and
+`partitions: [{name, row_ids, metadata}]`. Set and partition metadata retain
+their JSON values, including arrays, scalars and null. Source identity never overrides the command's
+target. Every referenced ID must exist in the target; missing IDs fail rather
+than being dropped or remapped. Reads follow existing project permissions.
+
 Dataset version and split-set commands used by prompt runs are covered in `prompt-control-plane.md`.
 
 ### Model configs

package/vendor/skills/orizu/references/dataset-design.md

@@ -73,7 +73,7 @@ orizu datasets splits create <upload-returned-dataset-version-id> --from-file ./
 
 Reserve `orizu datasets versions create` for a subsequent snapshot, and give it a new label such as `v2`; labels are unique within a dataset. The dataset README should record source approval, source locators, sampling decisions, deduplication rules, the coverage table, ground-truth status, and the split rationale.
 
-The dataset version freezes its rows. Server-side split membership is mutable, but the CLI exposes no split-set read operation, so membership cannot be re-read through the CLI. Treat the independently reviewed local split file plus the returned split-set ID as the canonical record available to this workflow. Do not mutate that server-side split set; pass the recorded `--dataset-version-id` and `--split-set-id` to `orizu optimizations run-gepa`, and record the CLI verification gap explicitly rather than claiming the server membership was re-verified.
+The dataset version freezes its rows. After creating the split set, re-read its saved membership with `orizu datasets splits show <split-set-id> --json` and confirm it matches the reviewed local split file before relying on it; the saved split set, not the local file, is the canonical record. Do not mutate that server-side split set; pass the recorded `--dataset-version-id` and `--split-set-id` to `orizu optimizations run-gepa`.
 
 ## Guard live rows before annotation and version later data
 

package/dist/dataset-edit-rows.d.ts

@@ -1,10 +0,0 @@
-export interface DatasetEditRowsOptions {
-    datasetId: string;
-    file: string;
-    json: boolean;
-    printJson: (value: Record<string, unknown>) => void;
-    printLine: (value: string) => void;
-    sanitize: (value: string) => string;
-}
-export declare function editDatasetRows(options: DatasetEditRowsOptions): Promise<void>;
-//# sourceMappingURL=dataset-edit-rows.d.ts.map

package/dist/dataset-edit-rows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataset-edit-rows.d.ts","sourceRoot":"","sources":["../src/dataset-edit-rows.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACnD,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;CACpC;AAsDD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+CpF"}

package/dist/dataset-edit-rows.js

@@ -1,90 +0,0 @@
-import { extractErrorMessage } from './error-response.js';
-import { parseDatasetFile } from './file-parser.js';
-import { authedFetch } from './http.js';
-const MAX_REQUEST_BYTES = 3 * 1024 * 1024;
-const MAX_CHUNK_ROWS = 10;
-const EMPTY_REQUEST_BYTES = Buffer.byteLength('{"rows":[]}', 'utf8');
-function normalizeRows(rows) {
-    if (rows.length === 0) {
-        throw new Error('Dataset edit file must contain at least one row');
-    }
-    const seenRowIds = new Set();
-    return rows.map((row, index) => {
-        const rowId = typeof row.id === 'string' ? row.id.trim() : '';
-        if (!rowId) {
-            throw new Error(`Dataset edit file rows[${index}] must include a non-empty string id`);
-        }
-        if (seenRowIds.has(rowId)) {
-            throw new Error(`Dataset edit file rows[${index}].id duplicates a previous row id`);
-        }
-        seenRowIds.add(rowId);
-        return { ...row, id: rowId };
-    });
-}
-function chunkRows(rows, sanitize) {
-    const chunks = [];
-    let currentChunk = [];
-    let currentBytes = EMPTY_REQUEST_BYTES;
-    for (const row of rows) {
-        const rowBytes = Buffer.byteLength(JSON.stringify(row), 'utf8');
-        const framedRowBytes = rowBytes + (currentChunk.length > 0 ? 1 : 0);
-        if (currentChunk.length > 0 &&
-            (currentChunk.length >= MAX_CHUNK_ROWS || currentBytes + framedRowBytes > MAX_REQUEST_BYTES)) {
-            chunks.push(currentChunk);
-            currentChunk = [];
-            currentBytes = EMPTY_REQUEST_BYTES;
-        }
-        const singleRowRequestBytes = EMPTY_REQUEST_BYTES + rowBytes;
-        if (singleRowRequestBytes > MAX_REQUEST_BYTES) {
-            throw new Error(`Dataset edit row ${sanitize(row.id)} is ${singleRowRequestBytes} bytes, ` +
-                `which exceeds the ${MAX_REQUEST_BYTES}-byte edit request limit`);
-        }
-        currentChunk.push(row);
-        currentBytes += rowBytes + (currentChunk.length > 1 ? 1 : 0);
-    }
-    if (currentChunk.length > 0)
-        chunks.push(currentChunk);
-    return chunks;
-}
-export async function editDatasetRows(options) {
-    const { rows } = parseDatasetFile(options.file);
-    const chunks = chunkRows(normalizeRows(rows), options.sanitize);
-    let totalUpdated = 0;
-    let lastResult = null;
-    for (let index = 0; index < chunks.length; index += 1) {
-        const chunk = chunks[index];
-        if (!options.json && chunks.length > 1) {
-            options.printLine(`Updating chunk ${index + 1}/${chunks.length} (${chunk.length} rows)...`);
-        }
-        try {
-            const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(options.datasetId)}/rows`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ rows: chunk }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${await extractErrorMessage(response)}`);
-            }
-            const data = await response.json();
-            if (!Number.isInteger(data.updatedCount) || data.updatedCount !== chunk.length) {
-                throw new Error(`Server reported ${String(data.updatedCount)} updated rows for a ${chunk.length}-row chunk`);
-            }
-            totalUpdated += data.updatedCount;
-            lastResult = data;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Chunk ${index + 1}/${chunks.length} failed: ${message}\n` +
-                `${totalUpdated} rows from ${index} chunk(s) were already updated. ` +
-                'Retry with a file containing only the remaining row edits.');
-        }
-    }
-    if (!lastResult)
-        throw new Error('Dataset edit file must contain at least one row');
-    if (options.json) {
-        options.printJson({ dataset: lastResult.dataset, updatedCount: totalUpdated });
-        return;
-    }
-    options.printLine(`Updated ${totalUpdated} rows in dataset ${options.sanitize(lastResult.dataset.name)} ` +
-        `(${options.sanitize(lastResult.dataset.id)}). Current row count: ${lastResult.dataset.rowCount}`);
-}

package/src/dataset-edit-rows.ts

@@ -1,124 +0,0 @@
-import { extractErrorMessage } from './error-response.js'
-import { parseDatasetFile } from './file-parser.js'
-import { authedFetch } from './http.js'
-
-const MAX_REQUEST_BYTES = 3 * 1024 * 1024
-const MAX_CHUNK_ROWS = 10
-const EMPTY_REQUEST_BYTES = Buffer.byteLength('{"rows":[]}', 'utf8')
-
-type DatasetRowEdit = Record<string, unknown> & { id: string }
-
-type EditRowsResponse = {
-  dataset: { id: string; name: string; rowCount: number }
-  updatedCount: number
-}
-
-export interface DatasetEditRowsOptions {
-  datasetId: string
-  file: string
-  json: boolean
-  printJson: (value: Record<string, unknown>) => void
-  printLine: (value: string) => void
-  sanitize: (value: string) => string
-}
-
-function normalizeRows(rows: Array<Record<string, unknown>>): DatasetRowEdit[] {
-  if (rows.length === 0) {
-    throw new Error('Dataset edit file must contain at least one row')
-  }
-
-  const seenRowIds = new Set<string>()
-  return rows.map((row, index) => {
-    const rowId = typeof row.id === 'string' ? row.id.trim() : ''
-    if (!rowId) {
-      throw new Error(`Dataset edit file rows[${index}] must include a non-empty string id`)
-    }
-    if (seenRowIds.has(rowId)) {
-      throw new Error(`Dataset edit file rows[${index}].id duplicates a previous row id`)
-    }
-    seenRowIds.add(rowId)
-    return { ...row, id: rowId }
-  })
-}
-
-function chunkRows(rows: DatasetRowEdit[], sanitize: (value: string) => string): DatasetRowEdit[][] {
-  const chunks: DatasetRowEdit[][] = []
-  let currentChunk: DatasetRowEdit[] = []
-  let currentBytes = EMPTY_REQUEST_BYTES
-
-  for (const row of rows) {
-    const rowBytes = Buffer.byteLength(JSON.stringify(row), 'utf8')
-    const framedRowBytes = rowBytes + (currentChunk.length > 0 ? 1 : 0)
-    if (
-      currentChunk.length > 0 &&
-      (currentChunk.length >= MAX_CHUNK_ROWS || currentBytes + framedRowBytes > MAX_REQUEST_BYTES)
-    ) {
-      chunks.push(currentChunk)
-      currentChunk = []
-      currentBytes = EMPTY_REQUEST_BYTES
-    }
-
-    const singleRowRequestBytes = EMPTY_REQUEST_BYTES + rowBytes
-    if (singleRowRequestBytes > MAX_REQUEST_BYTES) {
-      throw new Error(
-        `Dataset edit row ${sanitize(row.id)} is ${singleRowRequestBytes} bytes, ` +
-        `which exceeds the ${MAX_REQUEST_BYTES}-byte edit request limit`
-      )
-    }
-
-    currentChunk.push(row)
-    currentBytes += rowBytes + (currentChunk.length > 1 ? 1 : 0)
-  }
-
-  if (currentChunk.length > 0) chunks.push(currentChunk)
-  return chunks
-}
-
-export async function editDatasetRows(options: DatasetEditRowsOptions): Promise<void> {
-  const { rows } = parseDatasetFile(options.file)
-  const chunks = chunkRows(normalizeRows(rows), options.sanitize)
-  let totalUpdated = 0
-  let lastResult: EditRowsResponse | null = null
-
-  for (let index = 0; index < chunks.length; index += 1) {
-    const chunk = chunks[index]
-    if (!options.json && chunks.length > 1) {
-      options.printLine(`Updating chunk ${index + 1}/${chunks.length} (${chunk.length} rows)...`)
-    }
-
-    try {
-      const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(options.datasetId)}/rows`, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ rows: chunk }),
-      })
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${await extractErrorMessage(response)}`)
-      }
-
-      const data = await response.json() as EditRowsResponse
-      if (!Number.isInteger(data.updatedCount) || data.updatedCount !== chunk.length) {
-        throw new Error(`Server reported ${String(data.updatedCount)} updated rows for a ${chunk.length}-row chunk`)
-      }
-      totalUpdated += data.updatedCount
-      lastResult = data
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      throw new Error(
-        `Chunk ${index + 1}/${chunks.length} failed: ${message}\n` +
-        `${totalUpdated} rows from ${index} chunk(s) were already updated. ` +
-        'Retry with a file containing only the remaining row edits.'
-      )
-    }
-  }
-
-  if (!lastResult) throw new Error('Dataset edit file must contain at least one row')
-  if (options.json) {
-    options.printJson({ dataset: lastResult.dataset, updatedCount: totalUpdated })
-    return
-  }
-  options.printLine(
-    `Updated ${totalUpdated} rows in dataset ${options.sanitize(lastResult.dataset.name)} ` +
-    `(${options.sanitize(lastResult.dataset.id)}). Current row count: ${lastResult.dataset.rowCount}`
-  )
-}