@growthub/cli 0.10.0 → 0.10.1

package/assets/worker-kits/growthub-custom-workspace-starter-v1/helpers/grade-raw-pairs.mjs

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+/**
+ * helpers/grade-raw-pairs.mjs — Distillation Pipeline V1, Phase 2
+ *
+ * Grades pairs from `raw-pairs.jsonl` (Phase 1 output) by routing each one
+ * through the live `critic-grader` sandbox row (local-intelligence /
+ * gemma3:4b). The script never bypasses the workspace API: it PATCHes the
+ * critic row's `command`, calls `POST /api/workspace/sandbox-run`, then
+ * parses the strict-JSON `{score, reason}` envelope the grader returns.
+ *
+ * Quality boost: pairs whose `mergedToMain === true` (Phase 1 ground-truth
+ * signal that the work was squash-merged on `main`) get a floor of 4.
+ *
+ * Output: newline-delimited JSON with the original pair fields plus
+ *   - `qualityScore`     1-5 (string for downstream parity with training-traces)
+ *   - `qualityReason`    one-sentence rationale from the grader
+ *   - `criticRunMs`      latency
+ *   - `criticRunId`      run id for traceability
+ *   - `gradedAt`         ISO timestamp
+ *   - `boostedByMerge`   true if mergedToMain forced the floor
+ *
+ * Streams to disk after each pair so partial progress survives a kill.
+ *
+ * Usage:
+ *   node helpers/grade-raw-pairs.mjs \
+ *     --in        ./antonio/distillation/raw-pairs.jsonl \
+ *     --out       ./antonio/distillation/graded-batch-001.jsonl \
+ *     --workspace http://localhost:3000 \
+ *     --grader-row critic-grader \
+ *     --sandbox-object sandboxes-alignment-loop \
+ *     --limit 20 \
+ *     --offset 0 \
+ *     --max-input-chars 6000     # cap pair text to keep grader prompts safe
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+function parseArgs(argv) {
+  const a = {
+    in: "",
+    out: "",
+    workspace: "http://localhost:3000",
+    graderRow: "critic-grader",
+    sandboxObject: "sandboxes-alignment-loop",
+    limit: 20,
+    offset: 0,
+    maxInputChars: 6000,
+    mergedOnly: false,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    const next = () => String(argv[++i] || "").trim();
+    if (t === "--in") a.in = next();
+    else if (t === "--out") a.out = next();
+    else if (t === "--workspace") a.workspace = next().replace(/\/+$/, "");
+    else if (t === "--grader-row") a.graderRow = next();
+    else if (t === "--sandbox-object") a.sandboxObject = next();
+    else if (t === "--limit") a.limit = Number(next()) || 20;
+    else if (t === "--offset") a.offset = Number(next()) || 0;
+    else if (t === "--max-input-chars") a.maxInputChars = Number(next()) || 6000;
+    else if (t === "--merged-only") a.mergedOnly = true;
+    else if (t === "--help" || t === "-h") {
+      process.stdout.write(
+        "Usage: grade-raw-pairs.mjs --in <raw-pairs.jsonl> --out <graded.jsonl> [--workspace URL] [--grader-row name] [--sandbox-object id] [--limit N] [--offset N] [--max-input-chars N] [--merged-only]\n",
+      );
+      process.exit(0);
+    }
+  }
+  if (!a.in || !a.out) {
+    process.stderr.write("error: --in and --out are required\n");
+    process.exit(2);
+  }
+  return a;
+}
+
+const args = parseArgs(process.argv.slice(2));
+
+async function getWorkspaceObjects() {
+  const r = await fetch(`${args.workspace}/api/workspace`, { cache: "no-store" });
+  if (!r.ok) throw new Error(`GET /api/workspace ${r.status}`);
+  const j = await r.json();
+  return j.workspaceConfig.dataModel.objects;
+}
+
+async function patchObjects(objects) {
+  const r = await fetch(`${args.workspace}/api/workspace`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ dataModel: { objects } }),
+  });
+  if (!r.ok) {
+    const t = await r.text();
+    throw new Error(`PATCH /api/workspace ${r.status}: ${t.slice(0, 300)}`);
+  }
+}
+
+async function runGraderSandbox() {
+  const r = await fetch(`${args.workspace}/api/workspace/sandbox-run`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ objectId: args.sandboxObject, name: args.graderRow }),
+  });
+  return r.json();
+}
+
+function setRowCommand(objects, rowName, command) {
+  return objects.map((obj) => {
+    if (obj.id !== args.sandboxObject) return obj;
+    return {
+      ...obj,
+      rows: (obj.rows || []).map((row) => (row.Name === rowName ? { ...row, command } : row)),
+    };
+  });
+}
+
+function parseScoreFromGraderEnvelope(stdout) {
+  if (!stdout) return null;
+  try {
+    const env = JSON.parse(stdout);
+    if (env?.result?.json && typeof env.result.json.score === "number") {
+      return { score: env.result.json.score, reason: String(env.result.json.reason || "") };
+    }
+    if (typeof env?.rawText === "string") {
+      const outer = JSON.parse(env.rawText);
+      const content = outer?.choices?.[0]?.message?.content;
+      if (typeof content === "string") {
+        const inner = JSON.parse(content);
+        if (typeof inner?.score === "number") {
+          return { score: inner.score, reason: String(inner.reason || "") };
+        }
+      }
+    }
+  } catch {
+    // fall through
+  }
+  return null;
+}
+
+function buildGraderPrompt(pair, maxChars) {
+  const promptHead = pair.inputPrompt.slice(0, Math.floor(maxChars / 3));
+  const outputHead = pair.agentOutput.slice(0, maxChars - promptHead.length - 800);
+  const lines = [
+    "You are critic-grader for AWaC V2. Score this user→assistant pair from a Cursor session on the growthub-local repo.",
+    "Criteria:",
+    "  1) Clear understanding of the user request",
+    "  2) Used appropriate tools / primitives",
+    "  3) Respects AWaC V2 invariants (PATCH allowlist, no secret leaks, no protected-boundary edits)",
+    "  4) Output is correct and actionable",
+    "  5) Production-quality (would survive code review on this repo)",
+    "Return ONLY strict JSON: {\"score\": <1-5 integer>, \"reason\": \"one short sentence\"}.",
+    "",
+    "USER PROMPT (truncated):",
+    promptHead,
+    "",
+    "ASSISTANT RESPONSE (truncated):",
+    outputHead,
+  ];
+  return lines.join("\n");
+}
+
+// ---------- read pairs ----------
+const inAbs = path.resolve(args.in);
+const outAbs = path.resolve(args.out);
+fs.mkdirSync(path.dirname(outAbs), { recursive: true });
+
+const allLines = fs.readFileSync(inAbs, "utf8").split("\n").filter(Boolean);
+let pool = allLines;
+if (args.mergedOnly) {
+  pool = allLines.filter((ln) => {
+    try {
+      return JSON.parse(ln).mergedToMain === true;
+    } catch {
+      return false;
+    }
+  });
+}
+const slice = pool.slice(args.offset, args.offset + args.limit);
+
+process.stdout.write(
+  `[grade] in=${path.basename(inAbs)} totalLines=${allLines.length} pool=${pool.length}${args.mergedOnly ? " (mergedOnly)" : ""} offset=${args.offset} batch=${slice.length} -> ${path.basename(outAbs)}\n`,
+);
+
+const outStream = fs.createWriteStream(outAbs, { encoding: "utf8" });
+const summary = {
+  graded: 0,
+  parseFailures: 0,
+  scoreCounts: { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 0: 0 },
+  boostedByMerge: 0,
+  scoreSum: 0,
+  startedAt: new Date().toISOString(),
+};
+
+for (let i = 0; i < slice.length; i += 1) {
+  let pair;
+  try {
+    pair = JSON.parse(slice[i]);
+  } catch {
+    process.stderr.write(`[grade] skip line ${i}: not JSON\n`);
+    continue;
+  }
+
+  const command = buildGraderPrompt(pair, args.maxInputChars);
+  let parsedScore = null;
+  let runMs = 0;
+  let runId = "";
+  let boosted = false;
+
+  try {
+    const objects = await getWorkspaceObjects();
+    await patchObjects(setRowCommand(objects, args.graderRow, command));
+    const startedAt = Date.now();
+    const run = await runGraderSandbox();
+    runMs = Date.now() - startedAt;
+    runId = run?.runId || "";
+    parsedScore = parseScoreFromGraderEnvelope(run?.response?.stdout);
+  } catch (e) {
+    process.stderr.write(`[grade] pair ${i + args.offset} sandbox-run error: ${e.message}\n`);
+  }
+
+  if (!parsedScore) {
+    summary.parseFailures += 1;
+    parsedScore = { score: 0, reason: "grader did not return parseable JSON" };
+  }
+
+  // Apply mergedToMain floor=4 boost
+  if (pair.mergedToMain === true && parsedScore.score < 4) {
+    boosted = true;
+    summary.boostedByMerge += 1;
+    parsedScore = { score: 4, reason: `[boosted by squash-merge to main; original: ${parsedScore.score} - ${parsedScore.reason}]` };
+  }
+
+  summary.graded += 1;
+  summary.scoreCounts[parsedScore.score] = (summary.scoreCounts[parsedScore.score] || 0) + 1;
+  summary.scoreSum += parsedScore.score;
+
+  const out = {
+    ...pair,
+    qualityScore: String(parsedScore.score),
+    qualityReason: parsedScore.reason,
+    criticRunMs: runMs,
+    criticRunId: runId,
+    boostedByMerge: boosted,
+    gradedAt: new Date().toISOString(),
+  };
+  outStream.write(`${JSON.stringify(out)}\n`);
+
+  process.stdout.write(
+    `[grade] ${i + 1}/${slice.length} session=${pair.sessionId.slice(0, 8)} pair=${pair.pairIndex} score=${out.qualityScore}${boosted ? "*" : ""} ms=${runMs}\n`,
+  );
+}
+
+await new Promise((r) => outStream.end(r));
+
+const avg = summary.graded ? (summary.scoreSum / summary.graded).toFixed(2) : "0.00";
+const highCount = (summary.scoreCounts[4] || 0) + (summary.scoreCounts[5] || 0);
+const finishedAt = new Date().toISOString();
+
+process.stdout.write(
+  "\n" +
+    JSON.stringify(
+      {
+        ok: true,
+        out: outAbs,
+        startedAt: summary.startedAt,
+        finishedAt,
+        graded: summary.graded,
+        parseFailures: summary.parseFailures,
+        boostedByMerge: summary.boostedByMerge,
+        averageScore: Number(avg),
+        scoreCounts: summary.scoreCounts,
+        highQualityCount: highCount,
+        highQualityRatio: summary.graded ? Number((highCount / summary.graded).toFixed(3)) : 0,
+      },
+      null,
+      2,
+    ) +
+    "\n",
+);

package/assets/worker-kits/growthub-custom-workspace-starter-v1/helpers/harvest-cursor-traces.mjs

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+/**
+ * helpers/harvest-cursor-traces.mjs — Distillation Pipeline V1, Phase 1
+ *
+ * Reads Cursor agent transcript JSONL files (one folder per session, one
+ * `<uuid>.jsonl` inside it), pairs each user query with the assistant turn(s)
+ * that follow it, filters to pairs where the assistant actually executed work
+ * (≥1 `tool_use` block), and emits a single newline-delimited JSON file ready
+ * for Phase 2 (critic-grader scoring) and Phase 3 (Unsloth QLoRA export).
+ *
+ * Quality signals captured per pair (used by the grader, not graded here):
+ *   - `executedWork`     true ⇔ assistant turn produced ≥1 tool_use
+ *   - `toolUseCount`     how many tool calls were issued
+ *   - `toolNames`        deduped list of tool names invoked
+ *   - `branchesTouched`  branch names parsed out of git/gh shell commands
+ *   - `mergedToMain`     true if any branch matches a squash-merged PR on main
+ *   - `mergedPrNumbers`  PR numbers whose `headRefName` matched
+ *
+ * Squash-to-main is the highest-signal heuristic: it means the work was
+ * accepted by the maintainer and shipped. The grader can boost those rows.
+ *
+ * Usage:
+ *   node helpers/harvest-cursor-traces.mjs \
+ *     --in   /Users/antonio/.cursor/projects/Users-antonio-growthub-local/agent-transcripts \
+ *     --out  ./antonio/distillation/raw-pairs.jsonl \
+ *     --repo /Users/antonio/growthub-local            # optional: enables gh PR enrichment
+ *     --pr-limit 200                                  # optional: how many merged PRs to fetch
+ *     --min-prompt-chars 12                           # optional: drop trivial prompts
+ *
+ * No network calls beyond `gh pr list` (only when --repo is provided).
+ */
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+// ---------- arg parsing ----------
+function parseArgs(argv) {
+  const a = { in: "", out: "", repo: "", prLimit: 200, minPromptChars: 12 };
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    const next = () => String(argv[++i] || "").trim();
+    if (t === "--in") a.in = next();
+    else if (t === "--out") a.out = next();
+    else if (t === "--repo") a.repo = next();
+    else if (t === "--pr-limit") a.prLimit = Number(next()) || 200;
+    else if (t === "--min-prompt-chars") a.minPromptChars = Number(next()) || 0;
+    else if (t === "--help" || t === "-h") {
+      process.stdout.write(
+        "Usage: harvest-cursor-traces.mjs --in <transcripts-dir> --out <raw-pairs.jsonl> [--repo <git-repo>] [--pr-limit N] [--min-prompt-chars N]\n",
+      );
+      process.exit(0);
+    }
+  }
+  if (!a.in || !a.out) {
+    process.stderr.write("error: --in and --out are required\n");
+    process.exit(2);
+  }
+  return a;
+}
+
+const args = parseArgs(process.argv.slice(2));
+const transcriptsDir = path.resolve(args.in);
+const outPath = path.resolve(args.out);
+const repoDir = args.repo ? path.resolve(args.repo) : "";
+
+// ---------- gh squash-merge index ----------
+/** Map<branchName, { number, mergeSha, mergedAt, title }> */
+const mergedByBranch = new Map();
+if (repoDir) {
+  if (!fs.existsSync(path.join(repoDir, ".git"))) {
+    process.stderr.write(`warn: --repo ${repoDir} has no .git dir; skipping gh enrichment\n`);
+  } else {
+    const r = spawnSync(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--state",
+        "merged",
+        "--limit",
+        String(args.prLimit),
+        "--json",
+        "number,title,headRefName,mergeCommit,mergedAt",
+      ],
+      { cwd: repoDir, encoding: "utf8" },
+    );
+    if (r.status === 0) {
+      try {
+        const list = JSON.parse(r.stdout || "[]");
+        for (const pr of list) {
+          if (typeof pr.headRefName === "string" && pr.headRefName.trim()) {
+            mergedByBranch.set(pr.headRefName.trim(), {
+              number: pr.number,
+              mergeSha: pr.mergeCommit?.oid || null,
+              mergedAt: pr.mergedAt || null,
+              title: pr.title || "",
+            });
+          }
+        }
+      } catch (e) {
+        process.stderr.write(`warn: gh JSON parse failed: ${e.message}\n`);
+      }
+    } else {
+      process.stderr.write(`warn: gh pr list failed (${r.status}); continuing without merge index\n`);
+    }
+  }
+}
+
+// ---------- transcript walker ----------
+function listTranscriptFiles(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    process.stderr.write(`error: transcripts dir not found: ${rootDir}\n`);
+    process.exit(2);
+  }
+  const out = [];
+  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    const sessionDir = path.join(rootDir, entry.name);
+    if (!entry.isDirectory()) continue;
+    for (const child of fs.readdirSync(sessionDir, { withFileTypes: true })) {
+      if (child.isFile() && child.name.endsWith(".jsonl")) {
+        out.push({ sessionId: entry.name, file: path.join(sessionDir, child.name) });
+      }
+    }
+  }
+  return out.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+}
+
+// ---------- helpers ----------
+function flattenAssistantText(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  return blocks
+    .filter((b) => b && b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("\n\n")
+    .trim();
+}
+
+function extractToolNames(blocks) {
+  if (!Array.isArray(blocks)) return [];
+  return blocks
+    .filter((b) => b && b.type === "tool_use" && typeof b.name === "string")
+    .map((b) => b.name);
+}
+
+function extractToolInputs(blocks) {
+  if (!Array.isArray(blocks)) return [];
+  return blocks
+    .filter((b) => b && b.type === "tool_use")
+    .map((b) => ({ name: b.name, input: b.input ?? {} }));
+}
+
+const BRANCH_FROM_GH_PR = /(?:gh\s+pr\s+(?:create|merge|view|checkout)[^\n]*?)(?:--head|head\s*[:=])\s+([\w./-]+)/g;
+const BRANCH_FROM_GIT_PUSH = /git\s+push\s+(?:-u\s+)?(?:origin)\s+([\w./-]+)/g;
+const BRANCH_FROM_GIT_CHECKOUT = /git\s+checkout\s+(?:-b\s+)?([\w./-]+)/g;
+const BRANCH_FROM_BRANCH_FLAG = /(?:^|\s)(?:--branch|--head|--base)\s+([\w./-]+)/g;
+
+function extractBranchesFromShell(toolUses) {
+  const out = new Set();
+  for (const tu of toolUses) {
+    if (tu.name !== "Shell") continue;
+    const cmd = String(tu.input?.command || "");
+    if (!cmd) continue;
+    for (const re of [BRANCH_FROM_GH_PR, BRANCH_FROM_GIT_PUSH, BRANCH_FROM_GIT_CHECKOUT, BRANCH_FROM_BRANCH_FLAG]) {
+      let m;
+      re.lastIndex = 0;
+      while ((m = re.exec(cmd))) {
+        const name = (m[1] || "").trim();
+        if (name && name !== "main" && name !== "HEAD") out.add(name);
+      }
+    }
+  }
+  return [...out];
+}
+
+// ---------- main pairing pass ----------
+const files = listTranscriptFiles(transcriptsDir);
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+const outStream = fs.createWriteStream(outPath, { encoding: "utf8" });
+
+const stats = {
+  sessions: 0,
+  pairsConsidered: 0,
+  pairsKept: 0,
+  pairsDroppedNoTool: 0,
+  pairsDroppedShortPrompt: 0,
+  pairsMergedToMain: 0,
+  toolNameTotals: {},
+};
+
+for (const { sessionId, file } of files) {
+  stats.sessions += 1;
+  const lines = fs.readFileSync(file, "utf8").split("\n").filter(Boolean);
+
+  /** @type {Array<{role:string,content:any}>} */
+  const turns = [];
+  for (const ln of lines) {
+    try {
+      const j = JSON.parse(ln);
+      if (j && typeof j.role === "string" && j.message?.content) {
+        turns.push({ role: j.role, content: j.message.content });
+      }
+    } catch {
+      // skip malformed line
+    }
+  }
+
+  let pairIndex = 0;
+  for (let i = 0; i < turns.length; i += 1) {
+    if (turns[i].role !== "user") continue;
+    const userBlocks = Array.isArray(turns[i].content) ? turns[i].content : [];
+    const userText = userBlocks
+      .filter((b) => b && b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text)
+      .join("\n\n")
+      .trim();
+    if (!userText) continue;
+
+    // Collect every consecutive assistant turn until the next user turn.
+    const assistantBlocks = [];
+    let j = i + 1;
+    while (j < turns.length && turns[j].role !== "user") {
+      const c = turns[j].content;
+      if (Array.isArray(c)) assistantBlocks.push(...c);
+      j += 1;
+    }
+    if (assistantBlocks.length === 0) continue;
+
+    stats.pairsConsidered += 1;
+
+    if (userText.length < args.minPromptChars) {
+      stats.pairsDroppedShortPrompt += 1;
+      continue;
+    }
+
+    const toolUses = extractToolInputs(assistantBlocks);
+    if (toolUses.length === 0) {
+      stats.pairsDroppedNoTool += 1;
+      continue;
+    }
+
+    const assistantText = flattenAssistantText(assistantBlocks);
+    const toolNames = [...new Set(extractToolNames(assistantBlocks))];
+    for (const n of toolNames) stats.toolNameTotals[n] = (stats.toolNameTotals[n] || 0) + 1;
+
+    const branchesTouched = extractBranchesFromShell(toolUses);
+    const mergedPrNumbers = [];
+    for (const b of branchesTouched) {
+      const hit = mergedByBranch.get(b);
+      if (hit) mergedPrNumbers.push(hit.number);
+    }
+    const mergedToMain = mergedPrNumbers.length > 0;
+    if (mergedToMain) stats.pairsMergedToMain += 1;
+
+    const row = {
+      sessionId,
+      pairIndex,
+      inputPrompt: userText,
+      agentOutput: assistantText,
+      executedWork: true,
+      toolUseCount: toolUses.length,
+      toolNames,
+      branchesTouched,
+      mergedToMain,
+      mergedPrNumbers,
+    };
+    outStream.write(`${JSON.stringify(row)}\n`);
+    stats.pairsKept += 1;
+    pairIndex += 1;
+  }
+}
+
+await new Promise((resolve) => outStream.end(resolve));
+
+// ---------- summary ----------
+process.stdout.write(
+  JSON.stringify(
+    {
+      ok: true,
+      out: outPath,
+      transcriptsDir,
+      mergeIndexEntries: mergedByBranch.size,
+      ...stats,
+    },
+    null,
+    2,
+  ) + "\n",
+);

package/assets/worker-kits/growthub-custom-workspace-starter-v1/helpers/upload-graded-traces.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * helpers/upload-graded-traces.mjs — Distillation Pipeline V1, Phase 2.5
+ *
+ * Reads graded pairs JSONL (Phase 2 output) and appends rows whose
+ * qualityScore >= --min-score into the live workspace's `training-traces`
+ * dataModel object via PATCH /api/workspace.
+ *
+ * - Append-only. Existing rows are preserved.
+ * - Marks every uploaded row with `exported: "false"` so the export script
+ *   can pick them up later.
+ * - Truncates `agentOutput` to keep the workspace config file lean.
+ *
+ * Usage:
+ *   node helpers/upload-graded-traces.mjs \
+ *     --in        ./antonio/distillation/graded-batch-001.jsonl \
+ *     --workspace http://localhost:3000 \
+ *     --traces-object training-traces \
+ *     --min-score 4 \
+ *     --max-output-chars 4000
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+function parseArgs(argv) {
+  const a = {
+    in: "",
+    workspace: "http://localhost:3000",
+    tracesObject: "training-traces",
+    minScore: 4,
+    maxOutputChars: 4000,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    const next = () => String(argv[++i] || "").trim();
+    if (t === "--in") a.in = next();
+    else if (t === "--workspace") a.workspace = next().replace(/\/+$/, "");
+    else if (t === "--traces-object") a.tracesObject = next();
+    else if (t === "--min-score") a.minScore = Number(next()) || 4;
+    else if (t === "--max-output-chars") a.maxOutputChars = Number(next()) || 4000;
+    else if (t === "--help" || t === "-h") {
+      process.stdout.write(
+        "Usage: upload-graded-traces.mjs --in <graded.jsonl> [--workspace URL] [--traces-object id] [--min-score N] [--max-output-chars N]\n",
+      );
+      process.exit(0);
+    }
+  }
+  if (!a.in) {
+    process.stderr.write("error: --in is required\n");
+    process.exit(2);
+  }
+  return a;
+}
+
+const args = parseArgs(process.argv.slice(2));
+const inAbs = path.resolve(args.in);
+if (!fs.existsSync(inAbs)) {
+  process.stderr.write(`error: input not found: ${inAbs}\n`);
+  process.exit(2);
+}
+
+async function getObjects() {
+  const r = await fetch(`${args.workspace}/api/workspace`, { cache: "no-store" });
+  if (!r.ok) throw new Error(`GET /api/workspace ${r.status}`);
+  return (await r.json()).workspaceConfig.dataModel.objects;
+}
+async function patchObjects(objects) {
+  const r = await fetch(`${args.workspace}/api/workspace`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ dataModel: { objects } }),
+  });
+  if (!r.ok) throw new Error(`PATCH ${r.status}: ${(await r.text()).slice(0, 300)}`);
+}
+
+const lines = fs.readFileSync(inAbs, "utf8").split("\n").filter(Boolean);
+const candidates = [];
+for (const ln of lines) {
+  try {
+    const j = JSON.parse(ln);
+    if (Number(j.qualityScore) >= args.minScore) candidates.push(j);
+  } catch {
+    /* skip */
+  }
+}
+
+if (candidates.length === 0) {
+  process.stdout.write(JSON.stringify({ ok: true, uploaded: 0, reason: "no rows >= --min-score" }) + "\n");
+  process.exit(0);
+}
+
+const objects = await getObjects();
+const tracesIdx = objects.findIndex((o) => o.id === args.tracesObject);
+if (tracesIdx < 0) {
+  process.stderr.write(`error: object ${args.tracesObject} not found in workspace\n`);
+  process.exit(3);
+}
+const tracesObj = objects[tracesIdx];
+const newRows = candidates.map((p) => ({
+  sessionDate: p.gradedAt || new Date().toISOString(),
+  inputPrompt: String(p.inputPrompt || "").slice(0, args.maxOutputChars),
+  agentOutput: String(p.agentOutput || "").slice(0, args.maxOutputChars),
+  qualityScore: String(p.qualityScore),
+  reason: String(p.qualityReason || ""),
+  exported: "false",
+}));
+
+const nextObjects = objects.map((o, i) =>
+  i !== tracesIdx ? o : { ...o, rows: [...(o.rows || []), ...newRows] },
+);
+await patchObjects(nextObjects);
+
+const after = await getObjects();
+const finalCount = after.find((o) => o.id === args.tracesObject)?.rows?.length || 0;
+process.stdout.write(
+  JSON.stringify(
+    {
+      ok: true,
+      candidates: candidates.length,
+      uploaded: newRows.length,
+      tracesTotalRows: finalCount,
+      sourceFile: path.basename(inAbs),
+    },
+    null,
+    2,
+  ) + "\n",
+);