@growthub/cli 0.9.18 → 0.10.1

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-schema.js

@@ -132,7 +132,13 @@ const WIDGET_SCHEMA_CONTRACTS = {
   },
   FieldSettingsConfig: {
     hidden: "string[] of column names hidden from preview",
-    order: "string[] of column names defining custom order"
+    order: "string[] of column names defining custom order",
+    sort: "SortClause[] optional",
+    filter: "FilterConfig optional",
+    types: "record<string,string> optional — client field-type hints",
+    views: "saved view snapshots optional",
+    activeViewId: "string optional",
+    favorite: "boolean optional"
   },
   SortClause: {
     fieldId: "non-empty string (column name)",
@@ -491,6 +497,45 @@ function validateFieldSettings(fieldSettings, path, errors) {
   }
   if (fieldSettings.hidden !== undefined) validateStringArray(fieldSettings.hidden, `${path}.hidden`, errors);
   if (fieldSettings.order !== undefined) validateStringArray(fieldSettings.order, `${path}.order`, errors);
+  validateSortClauses(fieldSettings.sort, `${path}.sort`, errors);
+  validateFilterClauses(fieldSettings.filter, `${path}.filter`, errors);
+  if (fieldSettings.types !== undefined) {
+    if (!isPlainObject(fieldSettings.types)) {
+      errors.push(`${path}.types must be a plain object`);
+    } else {
+      Object.entries(fieldSettings.types).forEach(([key, value]) => {
+        if (typeof key !== "string" || !key.trim()) errors.push(`${path}.types keys must be non-empty strings`);
+        if (typeof value !== "string" || !value.trim()) errors.push(`${path}.types.${key} must be a non-empty string`);
+      });
+    }
+  }
+  if (fieldSettings.activeViewId !== undefined && typeof fieldSettings.activeViewId !== "string") {
+    errors.push(`${path}.activeViewId must be a string`);
+  }
+  if (fieldSettings.favorite !== undefined && typeof fieldSettings.favorite !== "boolean") {
+    errors.push(`${path}.favorite must be a boolean`);
+  }
+  if (fieldSettings.views !== undefined) {
+    if (!Array.isArray(fieldSettings.views)) {
+      errors.push(`${path}.views must be an array`);
+    } else {
+      fieldSettings.views.forEach((view, index) => {
+        const prefix = `${path}.views[${index}]`;
+        if (!isPlainObject(view)) {
+          errors.push(`${prefix} must be a plain object`);
+          return;
+        }
+        if (typeof view.id !== "string" || !view.id.trim()) errors.push(`${prefix}.id must be a non-empty string`);
+        if (typeof view.name !== "string" || !view.name.trim()) errors.push(`${prefix}.name must be a non-empty string`);
+        if (view.favorite !== undefined && typeof view.favorite !== "boolean") errors.push(`${prefix}.favorite must be a boolean`);
+        if (view.locked !== undefined && typeof view.locked !== "boolean") errors.push(`${prefix}.locked must be a boolean`);
+        if (view.hidden !== undefined) validateStringArray(view.hidden, `${prefix}.hidden`, errors);
+        if (view.order !== undefined) validateStringArray(view.order, `${prefix}.order`, errors);
+        validateSortClauses(view.sort, `${prefix}.sort`, errors);
+        validateFilterClauses(view.filter, `${prefix}.filter`, errors);
+      });
+    }
+  }
 }
 
 function validateSortClauses(sort, path, errors) {
@@ -820,6 +865,65 @@ function validateCanvasConfig(canvas, errors) {
   }
 }
 
+function validateDataModelRelation(relation, path, errors) {
+  if (!isPlainObject(relation)) {
+    errors.push(`${path} must be a plain object`);
+    return;
+  }
+  for (const key of ["id", "name", "field", "targetObjectType", "type"]) {
+    if (typeof relation[key] !== "string" || !relation[key].trim()) {
+      errors.push(`${path}.${key} must be a non-empty string`);
+    }
+  }
+  if (relation.type !== undefined && !["belongs-to", "has-many"].includes(relation.type)) {
+    errors.push(`${path}.type must be belongs-to or has-many`);
+  }
+  for (const opt of ["valueField", "labelField", "secondaryLabelField", "statusField"]) {
+    if (relation[opt] !== undefined && relation[opt] !== null && typeof relation[opt] !== "string") {
+      errors.push(`${path}.${opt} must be a string when present`);
+    }
+  }
+  if (relation.statusAllowlist !== undefined) {
+    if (!Array.isArray(relation.statusAllowlist)) {
+      errors.push(`${path}.statusAllowlist must be an array of strings when present`);
+    } else {
+      relation.statusAllowlist.forEach((entry, i) => {
+        if (typeof entry !== "string" || !entry.trim()) {
+          errors.push(`${path}.statusAllowlist[${i}] must be a non-empty string`);
+        }
+      });
+    }
+  }
+  if (relation.searchable !== undefined && typeof relation.searchable !== "boolean") {
+    errors.push(`${path}.searchable must be a boolean when present`);
+  }
+  if (relation.pageSize !== undefined && relation.pageSize !== "") {
+    const ps = Number(relation.pageSize);
+    if (!Number.isFinite(ps) || ps < 1 || ps > 500) {
+      errors.push(`${path}.pageSize must be a number between 1 and 500 when present`);
+    }
+  }
+  if (relation.referenceSource !== undefined) {
+    const rs = String(relation.referenceSource).trim();
+    if (!["workspace-rows", "source-records"].includes(rs)) {
+      errors.push(`${path}.referenceSource must be workspace-rows or source-records when present`);
+    }
+  }
+  if (relation.sidecarSourceId !== undefined && typeof relation.sidecarSourceId !== "string") {
+    errors.push(`${path}.sidecarSourceId must be a string when present`);
+  }
+  if (relation.resolver !== undefined) {
+    if (!isPlainObject(relation.resolver)) {
+      errors.push(`${path}.resolver must be a plain object when present`);
+    } else if (
+      relation.resolver.integrationId !== undefined
+      && (typeof relation.resolver.integrationId !== "string" || !relation.resolver.integrationId.trim())
+    ) {
+      errors.push(`${path}.resolver.integrationId must be a non-empty string when present`);
+    }
+  }
+}
+
 function validateSandboxEnvironmentRow(row, path, errors) {
   if (!isPlainObject(row)) return;
   const lifecycleStatus = String(row.lifecycleStatus || "").trim().toLowerCase();
@@ -847,6 +951,18 @@ function validateSandboxEnvironmentRow(row, path, errors) {
   if (row.agentHost !== undefined && row.agentHost !== "" && !KNOWN_SANDBOX_AGENT_HOSTS.includes(row.agentHost)) {
     errors.push(`${path}.agentHost must be one of ${KNOWN_SANDBOX_AGENT_HOSTS.join(", ")}`);
   }
+  const INTELLIGENCE_ADAPTER_MODES = ["ollama", "lmstudio", "vllm", "custom-openai-compatible"];
+  for (const field of ["localModel", "localEndpoint", "intelligenceAdapterMode"]) {
+    if (row[field] !== undefined && row[field] !== null && row[field] !== "" && typeof row[field] !== "string") {
+      errors.push(`${path}.${field} must be a string when set`);
+    }
+  }
+  if (row.intelligenceAdapterMode !== undefined && String(row.intelligenceAdapterMode).trim() !== "") {
+    const im = String(row.intelligenceAdapterMode).trim().toLowerCase();
+    if (!INTELLIGENCE_ADAPTER_MODES.includes(im)) {
+      errors.push(`${path}.intelligenceAdapterMode must be one of ${INTELLIGENCE_ADAPTER_MODES.join(", ")}`);
+    }
+  }
   if (row.envRefs !== undefined && typeof row.envRefs !== "string" && !Array.isArray(row.envRefs)) {
     errors.push(`${path}.envRefs must be a comma-separated string or array of env-ref slugs (never values)`);
   }
@@ -877,6 +993,11 @@ function validateSandboxEnvironmentRow(row, path, errors) {
       errors.push(`${path}.timeoutMs must be a finite number between 0 and ${SANDBOX_MAX_TIMEOUT_MS}`);
     }
   }
+  for (const traceField of ["resolverTemplateId", "connectorKind", "executionLane"]) {
+    if (row[traceField] !== undefined && typeof row[traceField] !== "string") {
+      errors.push(`${path}.${traceField} must be a string when present`);
+    }
+  }
 }
 
 function validateDataModelConfig(dataModel, errors) {
@@ -925,6 +1046,15 @@ function validateDataModelConfig(dataModel, errors) {
     if (object.binding?.sourceStorage === "workspace-source-records" && typeof object.sourceId !== "string") {
       errors.push(`${prefix}.sourceId is required when binding.sourceStorage is "workspace-source-records"`);
     }
+    if (object.relations !== undefined) {
+      if (!Array.isArray(object.relations)) {
+        errors.push(`${prefix}.relations must be an array`);
+      } else {
+        object.relations.forEach((rel, relIndex) => {
+          validateDataModelRelation(rel, `${prefix}.relations[${relIndex}]`, errors);
+        });
+      }
+    }
     validateFieldSettings(object.fieldSettings, `${prefix}.fieldSettings`, errors);
   });
 }

package/assets/worker-kits/growthub-custom-workspace-starter-v1/helpers/export-training-traces.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * helpers/export-training-traces.mjs — Distillation Pipeline V1, Phase 3
+ *
+ * Reads `training-traces.rows` from the live workspace, filters rows where
+ * qualityScore >= --min-score AND exported == "false", emits an Unsloth-ready
+ * JSONL of {instruction, input, output} on disk, then PATCHes the same rows
+ * with exported = "true" so they are not re-exported on the next run.
+ *
+ * Output format (one JSON object per line):
+ *   {"instruction": "<system + task>", "input": "<user prompt>", "output": "<agent output>"}
+ *
+ * Usage:
+ *   node helpers/export-training-traces.mjs \
+ *     --workspace http://localhost:3000 \
+ *     --traces-object training-traces \
+ *     --min-score 4 \
+ *     --out ./antonio/distillation/unsloth-batch-001.jsonl \
+ *     --instruction "You are growthub-local-expert. Respect AWaC V2 invariants and the PATCH allowlist." \
+ *     [--dry-run]
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+function parseArgs(argv) {
+  const a = {
+    workspace: "http://localhost:3000",
+    tracesObject: "training-traces",
+    minScore: 4,
+    out: "",
+    instruction: "You are growthub-local-expert. Respect AWaC V2 invariants and the PATCH allowlist.",
+    dryRun: false,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const t = argv[i];
+    const next = () => String(argv[++i] || "").trim();
+    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 === "--out") a.out = next();
+    else if (t === "--instruction") a.instruction = next();
+    else if (t === "--dry-run") a.dryRun = true;
+    else if (t === "--help" || t === "-h") {
+      process.stdout.write(
+        "Usage: export-training-traces.mjs [--workspace URL] [--traces-object id] [--min-score N] --out <path> [--instruction TEXT] [--dry-run]\n",
+      );
+      process.exit(0);
+    }
+  }
+  if (!a.out) {
+    process.stderr.write("error: --out is required\n");
+    process.exit(2);
+  }
+  return a;
+}
+
+const args = parseArgs(process.argv.slice(2));
+const outAbs = path.resolve(args.out);
+fs.mkdirSync(path.dirname(outAbs), { recursive: true });
+
+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 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 allRows = Array.isArray(tracesObj.rows) ? tracesObj.rows : [];
+
+const eligible = allRows
+  .map((row, idx) => ({ row, idx }))
+  .filter(({ row }) =>
+    Number(row.qualityScore) >= args.minScore &&
+    String(row.exported || "false").toLowerCase() !== "true" &&
+    String(row.inputPrompt || "").trim() &&
+    String(row.agentOutput || "").trim(),
+  );
+
+if (eligible.length === 0) {
+  process.stdout.write(
+    JSON.stringify(
+      {
+        ok: true,
+        out: outAbs,
+        eligible: 0,
+        exported: 0,
+        totalRows: allRows.length,
+        reason: "no rows match score >= min-score AND exported == false",
+      },
+      null,
+      2,
+    ) + "\n",
+  );
+  process.exit(0);
+}
+
+const outStream = fs.createWriteStream(outAbs, { encoding: "utf8" });
+for (const { row } of eligible) {
+  const sample = {
+    instruction: args.instruction,
+    input: String(row.inputPrompt),
+    output: String(row.agentOutput),
+  };
+  outStream.write(`${JSON.stringify(sample)}\n`);
+}
+await new Promise((r) => outStream.end(r));
+
+if (!args.dryRun) {
+  const eligibleIdx = new Set(eligible.map((e) => e.idx));
+  const updatedRows = allRows.map((row, i) => (eligibleIdx.has(i) ? { ...row, exported: "true" } : row));
+  const nextObjects = objects.map((o, i) => (i !== tracesIdx ? o : { ...o, rows: updatedRows }));
+  await patchObjects(nextObjects);
+}
+
+process.stdout.write(
+  JSON.stringify(
+    {
+      ok: true,
+      out: outAbs,
+      totalRows: allRows.length,
+      eligible: eligible.length,
+      exported: args.dryRun ? 0 : eligible.length,
+      dryRun: args.dryRun,
+      format: "unsloth-jsonl-v1 ({instruction, input, output})",
+    },
+    null,
+    2,
+  ) + "\n",
+);

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",
+);