@tuned-tensor/cli 0.4.19 → 0.4.21

package/dist/index.js

@@ -122,6 +122,9 @@ function post(path, body, opts) {
 function put(path, body, opts) {
   return request("PUT", path, { body, opts });
 }
+function patch(path, body, opts) {
+  return request("PATCH", path, { body, opts });
+}
 function del(path, opts) {
   return request("DELETE", path, { opts });
 }
@@ -297,10 +300,10 @@ var ResolveError = class extends Error {
 function isFullUuid(value) {
   return UUID_RE.test(value);
 }
-async function resolvePrefix(prefix, kind, listPath, describe, opts) {
+async function resolvePrefix(prefix, kind, listPath, describe, opts, listCmdOverride) {
   if (isFullUuid(prefix)) return prefix;
   const noun = kind;
-  const listCmd = `tt ${kind}s list --json`;
+  const listCmd = listCmdOverride ?? `tt ${kind}s list --json`;
   if (prefix.length < MIN_PREFIX_LEN) {
     throw new ResolveError(
       `${capitalize(noun)} ID prefix "${prefix}" is too short \u2014 provide at least ${MIN_PREFIX_LEN} characters or the full UUID.`
@@ -368,12 +371,23 @@ function resolveModelId(prefix, opts) {
     opts
   );
 }
+function resolveLabelingJobId(prefix, opts) {
+  return resolvePrefix(
+    prefix,
+    "labeling job",
+    "/labeling-jobs",
+    (j) => `${j.id}${j.name ? `  (${j.name})` : ""}`,
+    opts,
+    "tt label list --json"
+  );
+}
 
 // src/base-models.ts
 var SUPPORTED_BASE_MODELS = [
   "google/gemma-4-E2B-it",
   "google/gemma-4-E4B-it",
   "Qwen/Qwen3.5-2B",
+  "Qwen/Qwen3-VL-2B-Instruct",
   "Qwen/Qwen3.5-4B",
   "meta-llama/Llama-3.2-3B-Instruct",
   "microsoft/Phi-4-mini-instruct",
@@ -394,6 +408,9 @@ for (const [alias, model] of [
   ["qwen/qwen3.5-2b", "Qwen/Qwen3.5-2B"],
   ["Qwen/Qwen3.5-2B-Base", "Qwen/Qwen3.5-2B"],
   ["qwen/qwen3.5-2b-base", "Qwen/Qwen3.5-2B"],
+  ["qwen/qwen3-vl-2b-instruct", "Qwen/Qwen3-VL-2B-Instruct"],
+  ["Qwen/Qwen3-VL-2B", "Qwen/Qwen3-VL-2B-Instruct"],
+  ["qwen/qwen3-vl-2b", "Qwen/Qwen3-VL-2B-Instruct"],
   ["qwen/qwen3.5-4b", "Qwen/Qwen3.5-4B"],
   ["Qwen/Qwen3.5-4B-Base", "Qwen/Qwen3.5-4B"],
   ["qwen/qwen3.5-4b-base", "Qwen/Qwen3.5-4B"],
@@ -946,6 +963,7 @@ Eval Results (${data._evals.length}):`);
 
 // src/commands/datasets.ts
 import { existsSync as existsSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+var DOCUMENT_OCR_MIME_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp"]);
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -999,10 +1017,85 @@ function findControlChar(value) {
 function formatCodepoint(code) {
   return `U+${code.toString(16).toUpperCase().padStart(4, "0")}`;
 }
-function validateDatasetFile(file) {
+function detectRowFormat(record) {
+  const input = record.input;
+  if (input && typeof input === "object" && typeof input.prompt === "string" && Array.isArray(input.assets) && input.assets.length > 0 && typeof record.output === "string") {
+    return "document_ocr_jsonl";
+  }
+  if (typeof record.input === "string" || typeof record.output === "string" || !("input" in record) || !("output" in record)) {
+    return "jsonl";
+  }
+  return null;
+}
+function validateDocumentOcrRow(record, rowNumber, errors) {
+  const input = record.input;
+  const assets = input.assets;
+  if (typeof input.prompt !== "string" || input.prompt.trim().length === 0) {
+    errors.push(`Row ${rowNumber}: OCR input.prompt must be a non-empty string`);
+  } else {
+    const hit = findControlChar(input.prompt);
+    if (hit) {
+      errors.push(
+        `Row ${rowNumber}: OCR input.prompt contains invisible control character ${formatCodepoint(hit.codepoint)} (${hit.name}) at offset ${hit.offset} \u2014 strip or escape before uploading; some training paths split on it`
+      );
+    }
+  }
+  if (typeof record.output !== "string" || record.output.trim().length === 0) {
+    errors.push(`Row ${rowNumber}: OCR output must be a non-empty string`);
+  } else {
+    const hit = findControlChar(record.output);
+    if (hit) {
+      errors.push(
+        `Row ${rowNumber}: OCR output contains invisible control character ${formatCodepoint(hit.codepoint)} (${hit.name}) at offset ${hit.offset} \u2014 strip or escape before uploading; some training paths split on it`
+      );
+    }
+  }
+  if (assets.length > 8) {
+    errors.push(`Row ${rowNumber}: OCR rows support at most 8 image assets`);
+  }
+  for (const [assetIndex, asset] of assets.entries()) {
+    if (!asset || typeof asset !== "object" || Array.isArray(asset)) {
+      errors.push(`Row ${rowNumber}: asset ${assetIndex + 1} must be an object`);
+      continue;
+    }
+    const a = asset;
+    if (a.type !== void 0 && a.type !== "image") {
+      errors.push(`Row ${rowNumber}: asset ${assetIndex + 1} type must be "image"`);
+    }
+    if (a.mime_type !== void 0 && (typeof a.mime_type !== "string" || !DOCUMENT_OCR_MIME_TYPES.has(a.mime_type))) {
+      errors.push(
+        `Row ${rowNumber}: asset ${assetIndex + 1} mime_type must be one of image/png, image/jpeg, image/webp`
+      );
+    }
+    if (a.page !== void 0 && (typeof a.page !== "number" || !Number.isInteger(a.page) || a.page < 1)) {
+      errors.push(`Row ${rowNumber}: asset ${assetIndex + 1} page must be a positive integer`);
+    }
+    const hasReference = typeof a.data_uri === "string" && a.data_uri.trim().length > 0 || typeof a.uri === "string" && a.uri.trim().length > 0 || typeof a.path === "string" && a.path.trim().length > 0;
+    if (!hasReference) {
+      errors.push(`Row ${rowNumber}: asset ${assetIndex + 1} must include data_uri, uri, or path`);
+    }
+    if (typeof a.data_uri === "string") {
+      const match = /^data:(image\/(?:png|jpeg|webp));base64,[A-Za-z0-9+/=\s]+$/.exec(a.data_uri);
+      if (!match) {
+        errors.push(
+          `Row ${rowNumber}: asset ${assetIndex + 1} data_uri must be a base64 image/png, image/jpeg, or image/webp data URI`
+        );
+      } else if (typeof a.mime_type === "string" && a.mime_type !== match[1]) {
+        errors.push(`Row ${rowNumber}: asset ${assetIndex + 1} mime_type does not match data_uri media type`);
+      }
+    }
+  }
+}
+function parseDatasetFormat(value) {
+  if (!value) return void 0;
+  if (value === "jsonl" || value === "document_ocr_jsonl") return value;
+  throw new Error("--format must be one of: jsonl, document_ocr_jsonl");
+}
+function validateDatasetFile(file, requestedFormat) {
   const lines = readFileSync4(file, "utf8").split(/\r?\n/);
   const errors = [];
   let rowCount = 0;
+  let detectedFormat = null;
   for (const [index, rawLine] of lines.entries()) {
     const line = rawLine.trim();
     if (!line) continue;
@@ -1026,6 +1119,26 @@ function validateDatasetFile(file) {
       );
       continue;
     }
+    const rowFormat = detectRowFormat(record);
+    if (!rowFormat) {
+      errors.push(
+        `Row ${rowNumber}: expected text {"input": string, "output": string} or OCR {"input":{"prompt": string, "assets": [...]}, "output": string}`
+      );
+      continue;
+    }
+    detectedFormat ??= rowFormat;
+    if (requestedFormat && rowFormat !== requestedFormat) {
+      errors.push(`Row ${rowNumber}: expected ${requestedFormat} row, found ${rowFormat}`);
+      continue;
+    }
+    if (detectedFormat !== rowFormat) {
+      errors.push(`Row ${rowNumber}: cannot mix ${detectedFormat} and ${rowFormat} rows in one dataset`);
+      continue;
+    }
+    if (rowFormat === "document_ocr_jsonl") {
+      validateDocumentOcrRow(record, rowNumber, errors);
+      continue;
+    }
     if (typeof record.input !== "string") {
       errors.push(`Row ${rowNumber}: missing string "input" field`);
     }
@@ -1051,10 +1164,11 @@ function validateDatasetFile(file) {
     const suffix = errors.length > 5 ? `
 ...and ${errors.length - 5} more error(s)` : "";
     throw new Error(
-      `Invalid dataset format. Each JSONL row must be {"input": "...", "output": "..."}.
+      `Invalid dataset format. Each JSONL row must be a valid text or document OCR example.
 ${preview}${suffix}`
     );
   }
+  return detectedFormat ?? requestedFormat ?? "jsonl";
 }
 function registerDatasetsCommands(parent) {
   const datasets = parent.command("datasets").description("Manage datasets");
@@ -1102,13 +1216,13 @@ function registerDatasetsCommands(parent) {
       }
     }
   });
-  datasets.command("upload").description("Upload a JSONL dataset file").argument("<file>", "Path to JSONL file").option("-n, --name <name>", "Dataset name (defaults to filename)").option("-d, --description <desc>", "Dataset description").action(async (file, cmdOpts) => {
+  datasets.command("upload").description("Upload a JSONL dataset file").argument("<file>", "Path to JSONL file").option("-n, --name <name>", "Dataset name (defaults to filename)").option("-d, --description <desc>", "Dataset description").option("--format <format>", "Dataset format: jsonl or document_ocr_jsonl").action(async (file, cmdOpts) => {
     const opts = parent.opts();
     if (!existsSync2(file)) {
       printError(`File not found: ${file}`);
       process.exit(1);
     }
-    validateDatasetFile(file);
+    const format = validateDatasetFile(file, parseDatasetFormat(cmdOpts.format));
     const name = cmdOpts.name || file.split("/").pop().replace(/\.jsonl?$/, "");
     const fileBytes = readFileSync4(file);
     const uploadUrl = await post(
@@ -1118,7 +1232,8 @@ function registerDatasetsCommands(parent) {
         description: cmdOpts.description ?? null,
         filename: file.split("/").pop(),
         size: statSync2(file).size,
-        contentType: "application/jsonl"
+        contentType: "application/jsonl",
+        format
       },
       opts
     );
@@ -1153,27 +1268,425 @@ function registerDatasetsCommands(parent) {
   });
 }
 
+// src/commands/label.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+function formatCents2(cents) {
+  return `$${(cents / 100).toFixed(2)}`;
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function parseCsvHeader(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"') {
+      inQuotes = true;
+    } else if (ch === ",") {
+      fields.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  fields.push(current);
+  return fields.map((f) => f.trim());
+}
+function validateUnlabeledFile(file, inputColumn) {
+  const lower = file.toLowerCase();
+  if (lower.endsWith(".csv")) {
+    if (!inputColumn) {
+      throw new Error(
+        "CSV uploads need --input-column <name> to say which column holds the input text."
+      );
+    }
+    const firstLine = readFileSync5(file, "utf8").split(/\r?\n/, 1)[0] ?? "";
+    const columns = parseCsvHeader(firstLine);
+    if (!columns.includes(inputColumn)) {
+      throw new Error(
+        `Column "${inputColumn}" not found in CSV header. Available columns: ${columns.join(", ")}`
+      );
+    }
+    return { format: "csv" };
+  }
+  if (!lower.endsWith(".jsonl") && !lower.endsWith(".json")) {
+    throw new Error("Labeling source file must be .jsonl or .csv");
+  }
+  const lines = readFileSync5(file, "utf8").split(/\r?\n/);
+  const errors = [];
+  let rowCount = 0;
+  for (const [index, rawLine] of lines.entries()) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    rowCount += 1;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      errors.push(`Row ${index + 1}: invalid JSON`);
+      continue;
+    }
+    if (!row || typeof row !== "object" || Array.isArray(row) || typeof row.input !== "string") {
+      errors.push(`Row ${index + 1}: expected an object with a string "input" field`);
+    }
+  }
+  if (rowCount === 0) {
+    errors.push("File contains no JSONL rows");
+  }
+  if (errors.length > 0) {
+    const preview = errors.slice(0, 5).join("\n");
+    const suffix = errors.length > 5 ? `
+...and ${errors.length - 5} more error(s)` : "";
+    throw new Error(
+      `Invalid labeling source. Each JSONL row must be {"input": "..."}.
+${preview}${suffix}`
+    );
+  }
+  return { format: "jsonl" };
+}
+function printJobDetail(job, counts) {
+  printDetail([
+    ["ID", job.id],
+    ["Name", job.name],
+    ["Status", formatStatus(job.status)],
+    ["Spec", shortId(job.behavior_spec_id)],
+    ["Teacher", job.teacher_model],
+    ["Rows", String(job.row_count)],
+    ["Labeled", String(job.labeled_count)],
+    ["Failed", String(job.failed_count)],
+    [
+      "Cost",
+      job.actual_cost_cents !== null ? formatCents2(job.actual_cost_cents) : `~${formatCents2(job.est_cost_cents)} (estimated)`
+    ],
+    ["Dataset", job.promoted_dataset_id ? shortId(job.promoted_dataset_id) : void 0],
+    ["Error", job.error ?? void 0],
+    ["Created", formatDate(job.created_at)]
+  ]);
+  if (counts) {
+    console.log(
+      `
+Review: ${counts.labeled} awaiting \xB7 ${counts.accepted} accepted \xB7 ${counts.edited} edited \xB7 ${counts.rejected} rejected \xB7 ${counts.failed} failed`
+    );
+  }
+}
+async function watchJob(jobId, opts) {
+  for (; ; ) {
+    const { data } = await get(
+      `/labeling-jobs/${jobId}`,
+      void 0,
+      opts
+    );
+    if (!isJsonMode()) {
+      if (data.status === "preparing") {
+        process.stdout.write("\rPreparing - parsing the source file...   ");
+      } else {
+        const done = data.counts.total - data.counts.pending;
+        process.stdout.write(`\rLabeling ${done}/${data.counts.total} rows   `);
+      }
+    }
+    if (data.status !== "preparing" && data.status !== "labeling") {
+      if (!isJsonMode()) process.stdout.write("\n");
+      return data;
+    }
+    await sleep(5e3);
+  }
+}
+async function resolveRowIds(jobId, indexes, opts) {
+  const PER_PAGE = 100;
+  const byPage = /* @__PURE__ */ new Map();
+  for (const index of indexes) {
+    const page = Math.floor(index / PER_PAGE) + 1;
+    byPage.set(page, [...byPage.get(page) ?? [], index]);
+  }
+  const found = /* @__PURE__ */ new Map();
+  for (const [page, wanted] of byPage) {
+    const { data } = await get(
+      `/labeling-jobs/${jobId}/rows`,
+      { page, per_page: PER_PAGE },
+      opts
+    );
+    for (const row of data) {
+      if (wanted.includes(row.row_index)) {
+        found.set(row.row_index, row.id);
+      }
+    }
+  }
+  const missing = indexes.filter((i) => !found.has(i));
+  if (missing.length > 0) {
+    throw new Error(`Row index(es) not found: ${missing.join(", ")}`);
+  }
+  return found;
+}
+function parseIndexList(value) {
+  const indexes = value.split(",").map((part) => Number.parseInt(part.trim(), 10));
+  if (indexes.some((n) => Number.isNaN(n) || n < 0)) {
+    throw new Error(`Invalid row index list: "${value}" (expected e.g. "0,3,12")`);
+  }
+  return indexes;
+}
+function registerLabelCommands(parent) {
+  const label = parent.command("label").description("Teacher-label real data into training datasets");
+  label.command("upload").description("Upload unlabeled inputs (.jsonl or .csv) and start a labeling job").argument("<file>", 'Path to JSONL ({"input": ...} per line) or CSV file').requiredOption("-s, --spec <id>", "Behaviour spec the teacher labels under").option("-c, --input-column <name>", "CSV column that holds the input text").option("-n, --name <name>", "Job name (defaults to filename)").option("--watch", "Block and show progress until labeling finishes").action(async (file, cmdOpts) => {
+    const opts = parent.opts();
+    if (!existsSync3(file)) {
+      printError(`File not found: ${file}`);
+      process.exit(1);
+    }
+    const { format } = validateUnlabeledFile(file, cmdOpts.inputColumn);
+    const specId = await resolveSpecId(cmdOpts.spec, opts);
+    const name = cmdOpts.name || file.split("/").pop().replace(/\.(jsonl|json|csv)$/, "");
+    const fileBytes = readFileSync5(file);
+    const contentType = format === "csv" ? "text/csv" : "application/jsonl";
+    const { data: uploadUrl } = await post(
+      "/labeling-jobs/upload-url",
+      {
+        filename: file.split("/").pop(),
+        size: statSync3(file).size,
+        contentType
+      },
+      opts
+    );
+    const uploadRes = await fetch(uploadUrl.upload_url, {
+      method: uploadUrl.method,
+      headers: uploadUrl.headers ?? { "Content-Type": contentType },
+      body: new Blob([fileBytes], { type: contentType })
+    });
+    if (!uploadRes.ok) {
+      throw new Error(`Upload failed: ${uploadRes.status} ${uploadRes.statusText}`);
+    }
+    const { data: job } = await post(
+      "/labeling-jobs",
+      {
+        path: uploadUrl.path,
+        name,
+        behavior_spec_id: specId,
+        source_format: format,
+        input_column: cmdOpts.inputColumn ?? null
+      },
+      opts
+    );
+    if (!cmdOpts.watch) {
+      if (isJsonMode()) return printJson(job);
+      printSuccess(
+        `Labeling started: ${job.name} (${shortId(job.id)}) \u2014 est. ${formatCents2(job.est_cost_cents)}. Runs in the cloud; no need to stay connected.`
+      );
+      console.log(`Follow progress with \`tt label watch ${shortId(job.id)}\`.`);
+      return;
+    }
+    const finished = await watchJob(job.id, opts);
+    if (isJsonMode()) return printJson(finished);
+    printSuccess(
+      `Labeling ${finished.status === "awaiting_review" ? "complete" : finished.status}: ${finished.labeled_count}/${finished.row_count} rows labeled.`
+    );
+    console.log(
+      `Review with \`tt label rows ${shortId(job.id)} --status labeled\`, then \`tt label promote ${shortId(job.id)} --name <dataset-name>\`.`
+    );
+  });
+  label.command("watch").description("Watch a labeling job until it is ready for review").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").action(async (id) => {
+    const opts = parent.opts();
+    const jobId = await resolveLabelingJobId(id, opts);
+    const job = await watchJob(jobId, opts);
+    if (isJsonMode()) return printJson(job);
+    if (job.status === "awaiting_review") {
+      printSuccess(
+        `Labeling complete: ${job.labeled_count}/${job.row_count} rows labeled, cost ${job.actual_cost_cents !== null ? formatCents2(job.actual_cost_cents) : "n/a"}.`
+      );
+    } else {
+      printError(`Labeling ended with status: ${job.status}${job.error ? ` \u2014 ${job.error}` : ""}`);
+      process.exitCode = 1;
+    }
+  });
+  label.command("list").description("List labeling jobs").option("-p, --page <n>", "Page number", "1").option("--per-page <n>", "Results per page", "20").action(async (cmdOpts) => {
+    const opts = parent.opts();
+    const { data, meta } = await get(
+      "/labeling-jobs",
+      { page: cmdOpts.page, per_page: cmdOpts.perPage },
+      opts
+    );
+    if (isJsonMode()) return printJson({ data, meta });
+    printTable(
+      ["ID", "Name", "Status", "Progress", "Cost", "Created"],
+      data.map((j) => [
+        shortId(j.id),
+        truncate(j.name, 30),
+        formatStatus(j.status),
+        `${j.labeled_count}/${j.row_count}`,
+        j.actual_cost_cents !== null ? formatCents2(j.actual_cost_cents) : `~${formatCents2(j.est_cost_cents)}`,
+        formatDate(j.created_at)
+      ]),
+      meta
+    );
+  });
+  label.command("status").description("Show labeling job details and review progress").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").action(async (id) => {
+    const opts = parent.opts();
+    const jobId = await resolveLabelingJobId(id, opts);
+    const { data } = await get(
+      `/labeling-jobs/${jobId}`,
+      void 0,
+      opts
+    );
+    if (isJsonMode()) return printJson(data);
+    printJobDetail(data, data.counts);
+  });
+  label.command("rows").description("List rows in a labeling job").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").option(
+    "--status <status>",
+    "Filter by row status (pending|labeled|accepted|edited|rejected|failed)"
+  ).option("-p, --page <n>", "Page number", "1").option("--per-page <n>", "Results per page", "50").action(async (id, cmdOpts) => {
+    const opts = parent.opts();
+    const jobId = await resolveLabelingJobId(id, opts);
+    const query = {
+      page: cmdOpts.page,
+      per_page: cmdOpts.perPage
+    };
+    if (cmdOpts.status) query.status = cmdOpts.status;
+    const { data, meta } = await get(
+      `/labeling-jobs/${jobId}/rows`,
+      query,
+      opts
+    );
+    if (isJsonMode()) return printJson({ data, meta });
+    printTable(
+      ["Row", "Status", "Input", "Output"],
+      data.map((row) => [
+        String(row.row_index),
+        formatStatus(row.status),
+        truncate(row.input.replace(/\s+/g, " "), 40),
+        truncate(
+          (row.final_output ?? row.teacher_output ?? "\u2014").replace(/\s+/g, " "),
+          40
+        )
+      ]),
+      meta
+    );
+  });
+  label.command("accept").description("Accept teacher-labeled rows").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").option("--all", "Accept all unreviewed labeled rows").option("--rows <indexes>", "Comma-separated row indexes (e.g. 0,3,12)").action(async (id, cmdOpts) => {
+    const opts = parent.opts();
+    if (!cmdOpts.all && !cmdOpts.rows) {
+      printError("Provide --all or --rows <indexes>.");
+      process.exit(1);
+    }
+    const jobId = await resolveLabelingJobId(id, opts);
+    if (cmdOpts.all) {
+      const { data } = await post(
+        `/labeling-jobs/${jobId}/rows/bulk`,
+        { action: "accept", all_labeled: true },
+        opts
+      );
+      if (isJsonMode()) return printJson(data);
+      return printSuccess(`Accepted ${data.accepted} rows.`);
+    }
+    const indexes = parseIndexList(cmdOpts.rows);
+    const rowIds = await resolveRowIds(jobId, indexes, opts);
+    for (const index of indexes) {
+      await patch(
+        `/labeling-jobs/${jobId}/rows/${rowIds.get(index)}`,
+        { action: "accept" },
+        opts
+      );
+    }
+    if (isJsonMode()) return printJson({ accepted: indexes.length });
+    printSuccess(`Accepted ${indexes.length} row(s).`);
+  });
+  label.command("reject").description("Reject rows so they are excluded from promotion").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").requiredOption("--rows <indexes>", "Comma-separated row indexes (e.g. 0,3,12)").action(async (id, cmdOpts) => {
+    const opts = parent.opts();
+    const jobId = await resolveLabelingJobId(id, opts);
+    const indexes = parseIndexList(cmdOpts.rows);
+    const rowIds = await resolveRowIds(jobId, indexes, opts);
+    for (const index of indexes) {
+      await patch(
+        `/labeling-jobs/${jobId}/rows/${rowIds.get(index)}`,
+        { action: "reject" },
+        opts
+      );
+    }
+    if (isJsonMode()) return printJson({ rejected: indexes.length });
+    printSuccess(`Rejected ${indexes.length} row(s).`);
+  });
+  label.command("edit").description("Replace a row's output with your own").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").requiredOption("--row <index>", "Row index to edit").option("-o, --output <text>", "Replacement output text").option("-f, --file <path>", "Read replacement output from a file").action(async (id, cmdOpts) => {
+    const opts = parent.opts();
+    if (!cmdOpts.output && !cmdOpts.file) {
+      printError("Provide --output <text> or --file <path>.");
+      process.exit(1);
+    }
+    const output = cmdOpts.output ?? readFileSync5(cmdOpts.file, "utf8");
+    const jobId = await resolveLabelingJobId(id, opts);
+    const indexes = parseIndexList(cmdOpts.row);
+    const rowIds = await resolveRowIds(jobId, indexes, opts);
+    await patch(
+      `/labeling-jobs/${jobId}/rows/${rowIds.get(indexes[0])}`,
+      { action: "edit", output },
+      opts
+    );
+    if (isJsonMode()) return printJson({ edited: indexes[0] });
+    printSuccess(`Row ${indexes[0]} edited.`);
+  });
+  label.command("promote").description("Promote reviewed rows into a validated dataset").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").requiredOption("-n, --name <name>", "Name for the new dataset").option("-d, --description <desc>", "Dataset description").option("--include-unreviewed", "Also include unreviewed labeled rows").action(async (id, cmdOpts) => {
+    const opts = parent.opts();
+    const jobId = await resolveLabelingJobId(id, opts);
+    const { data } = await post(
+      `/labeling-jobs/${jobId}/promote`,
+      {
+        name: cmdOpts.name,
+        description: cmdOpts.description ?? null,
+        include_unreviewed_labeled: Boolean(cmdOpts.includeUnreviewed)
+      },
+      opts
+    );
+    if (isJsonMode()) return printJson(data);
+    printSuccess(
+      `Dataset created: ${data.name} (${shortId(data.id)}) \u2014 ${data.row_count} rows.`
+    );
+    console.log(
+      `Start a run with \`tt runs start <spec-id> --dataset ${shortId(data.id)}\`.`
+    );
+  });
+  label.command("cancel").description("Cancel a labeling job and release unused credits").argument("<id>", "Labeling job ID (full UUID or 4+ char prefix)").action(async (id) => {
+    const opts = parent.opts();
+    const jobId = await resolveLabelingJobId(id, opts);
+    const { data } = await post(
+      `/labeling-jobs/${jobId}/cancel`,
+      {},
+      opts
+    );
+    if (isJsonMode()) return printJson(data);
+    printSuccess(`Labeling job cancelled: ${shortId(jobId)}`);
+  });
+}
+
 // src/commands/models.ts
 import { spawn as spawn2, execFileSync } from "child_process";
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync3,
-  statSync as statSync3,
+  statSync as statSync4,
   createWriteStream,
   unlinkSync,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   writeFileSync as writeFileSync3,
   readdirSync,
   rmSync
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2, resolve as resolve2, basename as basename2 } from "path";
+import { dirname as dirname2, join as join2, resolve as resolve2, basename as basename2, normalize, isAbsolute } from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 
 // src/commands/init.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 var DEFAULT_SPEC_FILE = "tunedtensor.json";
 var SCAFFOLD = {
@@ -1191,7 +1704,7 @@ var SCAFFOLD = {
 function registerInitCommand(parent) {
   parent.command("init").description("Create a local behaviour spec file").option("-n, --name <name>", "Spec name").option("--model <model>", "Base model ID").option("-f, --file <path>", "Output file path", DEFAULT_SPEC_FILE).action(async (cmdOpts) => {
     const filePath = resolve(cmdOpts.file);
-    if (existsSync3(filePath)) {
+    if (existsSync4(filePath)) {
       printWarning(`${cmdOpts.file} already exists. Use tt eval to validate it or edit it directly.`);
       return;
     }
@@ -1208,14 +1721,14 @@ function registerInitCommand(parent) {
 }
 function loadSpec(filePath) {
   const resolved = resolve(filePath || DEFAULT_SPEC_FILE);
-  if (!existsSync3(resolved)) {
+  if (!existsSync4(resolved)) {
     printError(
       `Spec file not found: ${filePath || DEFAULT_SPEC_FILE}
 Run \`tt init\` to create one.`
     );
     process.exit(1);
   }
-  const raw = JSON.parse(readFileSync5(resolved, "utf-8"));
+  const raw = JSON.parse(readFileSync6(resolved, "utf-8"));
   return raw;
 }
 
@@ -1230,7 +1743,7 @@ var COMPLETION_ROUTES = /* @__PURE__ */ new Set(["/v1/chat/completions", "/chat/
 function parsePositiveInteger(value, fallback) {
   return Number.isInteger(value) && value >= 0 ? value : fallback;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function readRequestBody(req) {
@@ -1552,7 +2065,7 @@ var ManagedModelServer = class {
       child.kill("SIGTERM");
       await Promise.race([
         new Promise((resolve4) => child.once("exit", () => resolve4())),
-        sleep(5e3).then(() => {
+        sleep2(5e3).then(() => {
           if (child.exitCode == null && child.signalCode == null) child.kill("SIGKILL");
         })
       ]);
@@ -1582,7 +2095,7 @@ var ManagedModelServer = class {
       const health = await this.checkHealth();
       if (health.ok) return;
       if (!this.child) break;
-      await sleep(50);
+      await sleep2(50);
     }
     throw new Error("Model server did not become healthy within 120 seconds");
   }
@@ -1663,7 +2176,10 @@ import json
 import os
 import time
 import uuid
+import base64
+from io import BytesIO
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.request import urlopen
 
 MODEL_PATH = os.environ["TT_MODEL_PATH"]
 MODEL_NAME = os.environ.get("TT_MODEL_NAME", os.path.basename(MODEL_PATH.rstrip("/")) or "tuned-tensor-model")
@@ -1714,9 +2230,9 @@ def load_model():
         ) from exc
 
     try:
-        processor = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=TRUST_REMOTE_CODE)
-    except Exception:
         processor = AutoProcessor.from_pretrained(MODEL_PATH, trust_remote_code=TRUST_REMOTE_CODE)
+    except Exception:
+        processor = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=TRUST_REMOTE_CODE)
     tokenizer = getattr(processor, "tokenizer", processor)
     if getattr(tokenizer, "pad_token", None) is None:
         tokenizer.pad_token = tokenizer.eos_token
@@ -1733,22 +2249,43 @@ def load_model():
         kwargs["torch_dtype"] = torch.float16
 
     try:
-        model = AutoModelForCausalLM.from_pretrained(MODEL_PATH, **kwargs)
-    except Exception:
         model = AutoModelForImageTextToText.from_pretrained(MODEL_PATH, **kwargs)
+    except Exception:
+        model = AutoModelForCausalLM.from_pretrained(MODEL_PATH, **kwargs)
     if device != "cuda":
         model.to(device)
     model.eval()
-    return torch, tokenizer, model, device
+    return torch, processor, tokenizer, model, device
+
+
+torch, processor, tokenizer, model, DEVICE = load_model()
 
 
-torch, tokenizer, model, DEVICE = load_model()
+def normalize_content_part(part):
+    if not isinstance(part, dict):
+        return {"type": "text", "text": str(part)}
+    part_type = part.get("type")
+    if part_type == "text":
+        return {"type": "text", "text": str(part.get("text", ""))}
+    if part_type in {"image", "image_url"}:
+        image_url = part.get("image_url")
+        url = None
+        if isinstance(image_url, dict):
+            url = image_url.get("url")
+        elif isinstance(image_url, str):
+            url = image_url
+        url = url or part.get("image") or part.get("data_uri") or part.get("uri") or part.get("path")
+        if isinstance(url, str) and url.strip():
+            return {"type": "image", "image": url.strip()}
+    return {"type": "text", "text": json.dumps(part, ensure_ascii=False)}
 
 
-def content_to_text(content):
+def normalize_content(content):
     if isinstance(content, str):
         return content
-    return json.dumps(content, ensure_ascii=False)
+    if isinstance(content, list):
+        return [normalize_content_part(part) for part in content]
+    return str(content) if content is not None else ""
 
 
 def normalize_messages(raw_messages):
@@ -1759,7 +2296,7 @@ def normalize_messages(raw_messages):
         role = item.get("role")
         if role not in {"system", "user", "assistant", "tool"}:
             continue
-        messages.append({"role": role, "content": content_to_text(item.get("content", ""))})
+        messages.append({"role": role, "content": normalize_content(item.get("content", ""))})
 
     if SYSTEM_PROMPT and not any(message["role"] == "system" for message in messages):
         messages.insert(0, {"role": "system", "content": SYSTEM_PROMPT})
@@ -1803,7 +2340,10 @@ def with_json_contract(messages, mode, schema):
     contracted = [dict(message) for message in messages]
     for message in contracted:
         if message["role"] == "system":
-            message["content"] = (message["content"].rstrip() + "\n\n" + contract).strip()
+            content = message.get("content", "")
+            if not isinstance(content, str):
+                content = json.dumps(content, ensure_ascii=False)
+            message["content"] = (content.rstrip() + "\n\n" + contract).strip()
             return contracted
 
     contracted.insert(0, {"role": "system", "content": contract})
@@ -1822,13 +2362,71 @@ def render_prompt(messages):
     return "\n".join(rendered)
 
 
-def generate_completion(messages, max_tokens, temperature):
-    prompt = render_prompt(messages)
-    inputs = tokenizer(prompt, return_tensors="pt")
+def load_image(value):
+    try:
+        from PIL import Image
+    except Exception as exc:
+        raise RuntimeError(
+            "Multimodal requests require Pillow. Install the serving runtime with "
+            "'tt models setup-runtime --force' or install pillow in the selected Python environment."
+        ) from exc
+
+    if value.startswith("data:image/"):
+        _, payload = value.split(",", 1)
+        return Image.open(BytesIO(base64.b64decode(payload))).convert("RGB")
+    if value.startswith("http://") or value.startswith("https://"):
+        with urlopen(value, timeout=30) as response:
+            return Image.open(BytesIO(response.read())).convert("RGB")
+    return Image.open(value).convert("RGB")
+
+
+def resolve_message_images(messages):
+    resolved = []
+    images = []
+    for message in messages:
+        content = message.get("content")
+        if not isinstance(content, list):
+            resolved.append(message)
+            continue
+
+        parts = []
+        for part in content:
+            if not isinstance(part, dict) or part.get("type") != "image":
+                parts.append(part)
+                continue
+            image_ref = part.get("image") or part.get("data_uri") or part.get("uri") or part.get("path")
+            if not isinstance(image_ref, str) or not image_ref.strip():
+                raise RuntimeError("Image content part must include image, image_url.url, data_uri, uri, or path")
+            images.append(load_image(image_ref.strip()))
+            parts.append({"type": "image"})
+        resolved.append({**message, "content": parts})
+    return resolved, images
+
+
+def move_inputs_to_device(inputs, device):
+    moved = {}
+    for key, value in inputs.items():
+        moved[key] = value.to(device) if hasattr(value, "to") else value
+    return moved
+
+
+def prepare_generation_inputs(messages):
+    resolved_messages, images = resolve_message_images(messages)
+    prompt = render_prompt(resolved_messages)
     input_device = getattr(model, "device", None)
     if input_device is None:
         input_device = next(model.parameters()).device
-    inputs = {key: value.to(input_device) for key, value in inputs.items()}
+    if images:
+        if processor is tokenizer:
+            raise RuntimeError("This model artifact did not load a multimodal processor, so image inputs are not supported.")
+        inputs = processor(text=[prompt], images=images, return_tensors="pt")
+    else:
+        inputs = tokenizer(prompt, return_tensors="pt")
+    return move_inputs_to_device(inputs, input_device)
+
+
+def generate_completion(messages, max_tokens, temperature):
+    inputs = prepare_generation_inputs(messages)
 
     generate_kwargs = {
         **inputs,
@@ -2091,7 +2689,7 @@ if __name__ == "__main__":
 `;
 function resolveOutputPath(output, filename) {
   if (!output) return filename;
-  if (existsSync4(output) && statSync3(output).isDirectory()) {
+  if (existsSync5(output) && statSync4(output).isDirectory()) {
     return join2(output, filename);
   }
   return output;
@@ -2212,7 +2810,7 @@ function runtimePythonPath(cacheDir) {
 function resolveServePython(cacheDir, explicitPython) {
   if (explicitPython) return explicitPython;
   const managedPython = runtimePythonPath(cacheDir);
-  return existsSync4(managedPython) ? managedPython : "python3";
+  return existsSync5(managedPython) ? managedPython : "python3";
 }
 function commandExists(command) {
   try {
@@ -2256,7 +2854,7 @@ function ensureServingRuntime(python, cacheDir) {
   const check = `
 import importlib.util
 import json
-required = ["torch", "transformers", "accelerate", "safetensors"]
+required = ["torch", "transformers", "accelerate", "safetensors", "PIL"]
 missing = [name for name in required if importlib.util.find_spec(name) is None]
 print(json.dumps({"missing": missing}))
 `;
@@ -2291,11 +2889,28 @@ function safeSegment(value) {
   return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "model";
 }
 function directoryHasFiles(path) {
-  return existsSync4(path) && statSync3(path).isDirectory() && readdirSync(path).length > 0;
+  return existsSync5(path) && statSync4(path).isDirectory() && readdirSync(path).length > 0;
+}
+function validateArchiveEntryPath(entry) {
+  const normalized = normalize(entry).replace(/^[\\/]+/, "");
+  if (!entry.trim() || isAbsolute(entry) || normalized === ".." || normalized.startsWith(`..${"/"}`) || normalized.startsWith(`..${"\\"}`)) {
+    throw new Error(`Unsafe archive entry path: ${entry}`);
+  }
+  return normalized;
+}
+function validateArchiveEntries(archivePath) {
+  const listing = execFileSync("tar", ["-tzf", archivePath], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  for (const entry of listing.split(/\r?\n/)) {
+    if (entry.trim()) validateArchiveEntryPath(entry);
+  }
 }
 function extractArchive(archivePath, targetDir, force) {
   if (directoryHasFiles(targetDir) && !force) return targetDir;
-  if (existsSync4(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+  validateArchiveEntries(archivePath);
+  if (existsSync5(targetDir)) rmSync(targetDir, { recursive: true, force: true });
   mkdirSync3(targetDir, { recursive: true });
   execFileSync("tar", ["-xzf", archivePath, "-C", targetDir], { stdio: "inherit" });
   return targetDir;
@@ -2322,21 +2937,21 @@ function findSpecPath(explicitPath, modelPath) {
   const candidates = explicitPath ? [explicitPath] : [join2(process.cwd(), DEFAULT_SPEC_FILE), join2(modelPath, DEFAULT_SPEC_FILE)];
   for (const candidate of candidates) {
     const resolved = resolve2(candidate);
-    if (existsSync4(resolved) && statSync3(resolved).isFile()) return resolved;
+    if (existsSync5(resolved) && statSync4(resolved).isFile()) return resolved;
   }
   return null;
 }
 function loadSystemPromptFromSpec(specPath) {
-  const spec = JSON.parse(readFileSync6(specPath, "utf8"));
+  const spec = JSON.parse(readFileSync7(specPath, "utf8"));
   return buildSystemPrompt(spec);
 }
 function loadJsonSchemaForServe(schemaPath) {
   const resolved = resolve2(schemaPath);
-  if (!existsSync4(resolved) || !statSync3(resolved).isFile()) {
+  if (!existsSync5(resolved) || !statSync4(resolved).isFile()) {
     throw new Error(`JSON schema file not found: ${schemaPath}`);
   }
   try {
-    const schema = JSON.parse(readFileSync6(resolved, "utf8"));
+    const schema = JSON.parse(readFileSync7(resolved, "utf8"));
     return JSON.stringify(schema);
   } catch (err) {
     throw new Error(`JSON schema file is not valid JSON: ${schemaPath}`);
@@ -2350,9 +2965,9 @@ function writeReferenceServerScript(cacheDir) {
   return scriptPath;
 }
 async function resolveServeTarget(target, opts, cacheDir, forceDownload) {
-  if (existsSync4(target)) {
+  if (existsSync5(target)) {
     const resolved = resolve2(target);
-    const stats = statSync3(resolved);
+    const stats = statSync4(resolved);
     if (stats.isDirectory()) {
       return {
         modelPath: resolved,
@@ -2376,7 +2991,7 @@ async function resolveServeTarget(target, opts, cacheDir, forceDownload) {
   const modelCacheDir = join2(cacheDir, fullId);
   const archivePath = join2(modelCacheDir, data.filename);
   const extractDir = join2(modelCacheDir, "model");
-  if (!existsSync4(archivePath) || forceDownload) {
+  if (!existsSync5(archivePath) || forceDownload) {
     await downloadUrlToFile(data.url, archivePath);
   }
   extractArchive(archivePath, extractDir, forceDownload);
@@ -2480,7 +3095,7 @@ function ollamaSlug(name) {
 }
 function firstExisting(candidates) {
   for (const candidate of candidates) {
-    if (candidate && existsSync4(candidate) && statSync3(candidate).isFile()) {
+    if (candidate && existsSync5(candidate) && statSync4(candidate).isFile()) {
       return resolve2(candidate);
     }
   }
@@ -2492,7 +3107,7 @@ function llamaCppDir(explicit) {
 function resolveConvertScript(opts, required) {
   if (opts.convertScript) {
     const resolved = resolve2(opts.convertScript);
-    if (required && !existsSync4(resolved)) {
+    if (required && !existsSync5(resolved)) {
       throw new Error(`Conversion script not found: ${opts.convertScript}`);
     }
     return resolved;
@@ -2511,7 +3126,7 @@ function resolveConvertScript(opts, required) {
 function resolveQuantizeBin(opts, required) {
   if (opts.quantizeBin) {
     const resolved = resolve2(opts.quantizeBin);
-    if (required && !existsSync4(resolved)) {
+    if (required && !existsSync5(resolved)) {
       throw new Error(`llama-quantize binary not found: ${opts.quantizeBin}`);
     }
     return resolved;
@@ -2646,7 +3261,7 @@ function registerModelsCommands(parent) {
       opts
     );
     const outputPath = resolveOutputPath(cmdOpts.output, data.filename);
-    if (existsSync4(outputPath) && !cmdOpts.force) {
+    if (existsSync5(outputPath) && !cmdOpts.force) {
       throw new Error(`Output file already exists: ${outputPath}. Use --force to overwrite.`);
     }
     const bytes = await downloadUrlToFile(data.url, outputPath);
@@ -2755,7 +3370,7 @@ function registerModelsCommands(parent) {
       ollama: ollamaInfo
     };
     if (printOnly) return printExportPlan(plan);
-    if (existsSync4(finalPath) && !cmdOpts.force) {
+    if (existsSync5(finalPath) && !cmdOpts.force) {
       throw new Error(`Output already exists: ${finalPath}. Use --force to overwrite.`);
     }
     mkdirSync3(outputDir, { recursive: true });
@@ -2776,7 +3391,7 @@ function registerModelsCommands(parent) {
         finalPath,
         quantPlan.quantizeType
       ]);
-      if (!cmdOpts.keepIntermediate && intermediatePath && existsSync4(intermediatePath)) {
+      if (!cmdOpts.keepIntermediate && intermediatePath && existsSync5(intermediatePath)) {
         rmSync(intermediatePath, { force: true });
       }
     }
@@ -2810,7 +3425,7 @@ function registerModelsCommands(parent) {
     const venvDir = runtimeDir(cacheDir);
     const venvPython = runtimePythonPath(cacheDir);
     const python = pickRuntimePython(cmdOpts.python);
-    const deps = ["torch", "transformers", "accelerate", "safetensors"];
+    const deps = ["torch", "transformers", "accelerate", "safetensors", "pillow"];
     const commands = setupRuntimeCommands(python, venvDir, deps);
     if (cmdOpts.printCommand) {
       const commandLines = commands.map((cmd) => cmd.map(quoteCommandPart).join(" "));
@@ -2829,10 +3444,10 @@ function registerModelsCommands(parent) {
       ]);
       return;
     }
-    if (existsSync4(venvDir) && cmdOpts.force) {
+    if (existsSync5(venvDir) && cmdOpts.force) {
       rmSync(venvDir, { recursive: true, force: true });
     }
-    if (!existsSync4(venvPython)) {
+    if (!existsSync5(venvPython)) {
       mkdirSync3(cacheDir, { recursive: true });
       execFileSync(commands[0][0], commands[0].slice(1), { stdio: "inherit" });
     }
@@ -2973,15 +3588,15 @@ var KIND_LABELS = {
   refund: "Refund",
   adjustment: "Adjustment"
 };
-function formatCents2(cents) {
+function formatCents3(cents) {
   const sign = cents < 0 ? "-" : "";
   const abs = Math.abs(cents);
   return `${sign}$${(abs / 100).toFixed(2)}`;
 }
 function formatSigned(cents) {
-  if (cents > 0) return chalk3.green(`+${formatCents2(cents)}`);
-  if (cents < 0) return chalk3.red(formatCents2(cents));
-  return formatCents2(cents);
+  if (cents > 0) return chalk3.green(`+${formatCents3(cents)}`);
+  if (cents < 0) return chalk3.red(formatCents3(cents));
+  return formatCents3(cents);
 }
 function registerBalanceCommands(parent) {
   parent.command("balance").description("Show credit balance and recent transactions").option("-n, --limit <n>", "Number of transactions to show (default 10)", "10").action(async (options) => {
@@ -2995,10 +3610,18 @@ function registerBalanceCommands(parent) {
       return printJson({ balance, transactions });
     }
     const lowBalance = balance.balance_cents < 100;
-    const balanceLine = lowBalance ? chalk3.red(formatCents2(balance.balance_cents)) + chalk3.dim(" (low)") : chalk3.bold.green(formatCents2(balance.balance_cents));
+    const balanceLine = lowBalance ? chalk3.red(formatCents3(balance.balance_cents)) + chalk3.dim(" (low)") : chalk3.bold.green(formatCents3(balance.balance_cents));
     printDetail([
       ["Credits", balanceLine],
-      ["Lifetime top-ups", formatCents2(balance.lifetime_topup_cents)]
+      [
+        "Reserved",
+        balance.reserved_cents > 0 ? formatCents3(balance.reserved_cents) : void 0
+      ],
+      [
+        "Available",
+        balance.reserved_cents > 0 ? formatCents3(balance.available_cents) : void 0
+      ],
+      ["Lifetime top-ups", formatCents3(balance.lifetime_topup_cents)]
     ]);
     if (transactions && transactions.length > 0) {
       console.log(`
@@ -3009,7 +3632,7 @@ ${chalk3.bold("Recent transactions")}`);
           formatDate(row.created_at),
           KIND_LABELS[row.kind] ?? row.kind,
           formatSigned(row.amount_cents),
-          formatCents2(row.balance_after_cents),
+          formatCents3(row.balance_after_cents),
           row.reference_id ? shortId(row.reference_id) : chalk3.dim("\u2014")
         ])
       );
@@ -3307,7 +3930,7 @@ function printValidation(checks) {
 }
 
 // src/commands/push.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve3 } from "path";
 function registerPushCommand(parent) {
   parent.command("push").description("Push local spec to the Tuned Tensor API").option("-f, --file <path>", "Spec file path", DEFAULT_SPEC_FILE).action(async (cmdOpts) => {
@@ -3327,7 +3950,7 @@ function registerPushCommand(parent) {
     } else {
       const res = await post("/behavior-specs", body, opts);
       data = res.data;
-      const raw = JSON.parse(readFileSync7(filePath, "utf-8"));
+      const raw = JSON.parse(readFileSync8(filePath, "utf-8"));
       raw.id = data.id;
       writeFileSync4(filePath, JSON.stringify(raw, null, 2) + "\n");
     }
@@ -3340,7 +3963,7 @@ function registerPushCommand(parent) {
 
 // src/index.ts
 var program = new Command();
-program.name("tt").description("Tuned Tensor CLI \u2014 fine-tune and evaluate LLMs").version("0.4.19").option("-k, --api-key <key>", "API key (overrides stored key)").option(
+program.name("tt").description("Tuned Tensor CLI \u2014 fine-tune and evaluate LLMs").version("0.4.21").option("-k, --api-key <key>", "API key (overrides stored key)").option(
   "-u, --base-url <url>",
   "API base URL (default: https://tunedtensor.com)"
 ).option("--json", "Output raw JSON").option("--no-color", "Disable colors").hook("preAction", (_thisCommand, actionCommand) => {
@@ -3354,6 +3977,7 @@ registerAuthCommands(program);
 registerSpecsCommands(program);
 registerRunsCommands(program);
 registerDatasetsCommands(program);
+registerLabelCommands(program);
 registerModelsCommands(program);
 registerBalanceCommands(program);
 registerTopupCommands(program);