harness-everything 0.22.1 → 0.23.0

package/ci/mechanism-system-one-corpus.test.js

@@ -0,0 +1,154 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { createHash } = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const { validateDraft, validateReviews, build, promptHash } = require('../scripts/system-one-corpus');
+const { validateCorpus } = require('../harness-everything/scripts/system-one/evaluate');
+const root = path.resolve(__dirname, '..');
+const draftPath = path.join(root, 'benchmarks/fixtures/system-one-holdout-draft.json');
+
+const draftCase = (id, language = 'en', proposedGold = 'tier1', prompt = `commit the change for case ${id}`) => ({
+  id, family: `family-${id}`, language, source: 'synthetic:authored', prompt, proposedGold, rationale: 'bounded git operation' });
+const draft = () => ({ schemaVersion: 1, cases: [draftCase('a'), draftCase('b', 'zh-TW', null, '繼續'), draftCase('c', 'en', 'tier2', 'fix the failing parser test and rerun it')] });
+const decision = (c, kind = 'accept', gold = c.proposedGold) => ({ id: c.id, promptHash: promptHash(c.prompt), decision: kind, gold, reviewer: 'human:repository-owner' });
+const reviews = decisions => ({ schemaVersion: 1, decisions });
+
+test('S1-K01 an unreviewed draft assembles into a valid corpus that cannot pass the review gate', () => {
+  const { corpus, summary } = build(draft(), null);
+  assert.equal(validateCorpus(corpus), true);
+  assert.ok(corpus.cases.every(c => c.reviewed === false && c.split === 'holdout'));
+  assert.deepEqual(corpus.cases.map(c => c.gold), ['tier1', null, 'tier2']);
+  assert.equal(corpus.cases[1].request.context, '繼續');
+  assert.equal(summary.unreviewed, 3);
+  assert.equal(summary.reviewedHoldoutGate, false);
+  assert.equal(promptHash('繼續'), createHash('sha256').update('繼續', 'utf8').digest('hex'));
+  assert.deepEqual(build(draft(), null), build(draft(), null));
+});
+
+test('S1-K02 accept, relabel and reject apply exactly; the reviewer gold wins', () => {
+  const d = draft();
+  const { corpus, summary } = build(d, reviews([decision(d.cases[0]), decision(d.cases[1], 'relabel', 'tier1'), decision(d.cases[2], 'reject', null)]));
+  assert.deepEqual(corpus.cases.map(c => [c.id, c.gold, c.reviewed]), [['a', 'tier1', true], ['b', 'tier1', true]]);
+  assert.equal(summary.rejected, 1);
+  assert.equal(summary.reviewed, 2);
+});
+
+test('S1-K03 a decision for changed prompt text is stale and never counts as review', () => {
+  const d = draft();
+  const r = reviews([decision(d.cases[0], 'relabel', 'tier2')]);
+  d.cases[0].prompt = 'commit and push the change for case a';
+  const { corpus, summary } = build(d, r);
+  assert.equal(corpus.cases[0].reviewed, false);
+  assert.equal(corpus.cases[0].gold, 'tier1');
+  assert.equal(summary.stale, 1);
+});
+
+test('S1-K04 malformed reviews are rejected instead of silently applied', () => {
+  const d = draft();
+  const bad = [
+    r => { r.decisions.push({ ...r.decisions[0] }); },
+    r => { r.decisions[0].id = 'unknown'; },
+    r => { r.decisions[0].decision = 'approve'; },
+    r => { r.decisions[0].gold = 'tier3'; },
+    r => { r.decisions[0] = decision(d.cases[0], 'relabel', 'tier1'); },
+    r => { r.decisions[0] = decision(d.cases[0], 'reject', 'tier1'); },
+    r => { r.decisions[0].reviewer = 'claude'; },
+    r => { r.decisions[0].reviewer = 'human:someone@example.com'; },
+    r => { r.decisions[0].extra = true; },
+    r => { r.decisions[0].promptHash = 'abc'; },
+    r => { r.schemaVersion = 2; },
+  ];
+  for (const mutate of bad) {
+    const r = reviews([decision(d.cases[0])]);
+    mutate(r);
+    assert.throws(() => build(d, r));
+  }
+  assert.equal(validateReviews(reviews([decision(d.cases[0])])), true);
+});
+
+test('S1-K05 draft validation: exact fields, unique ids and prompts, known sources, no private data', () => {
+  assert.equal(validateDraft(draft()), true);
+  const bad = [
+    d => { d.cases[1].id = 'a'; },
+    d => { d.cases[1].prompt = d.cases[0].prompt; },
+    d => { d.cases[0].source = 'real:history'; },
+    d => { d.cases[0].language = 'ja'; },
+    d => { d.cases[0].proposedGold = 'unclassified'; },
+    d => { d.cases[0].rationale = ''; },
+    d => { d.cases[0].extra = 1; },
+    d => { d.cases = []; },
+    d => { d.cases[0].prompt = 'mail the report to dev.lead@example.com'; },
+    d => { d.cases[0].prompt = 'open C:\\Users\\alice\\repo\\notes.md and fix it'; },
+    d => { d.cases[0].prompt = 'read /home/alice/project/config.yaml'; },
+    d => { d.cases[0].prompt = 'read /Users/alice/project/config.yaml'; },
+  ];
+  for (const mutate of bad) { const d = draft(); mutate(d); assert.throws(() => validateDraft(d)); }
+});
+
+test('S1-K06 the gate passes only with >=200 reviewed cases and >=50 per language', () => {
+  const make = (en, zh) => ({ schemaVersion: 1, cases: [
+    ...Array.from({ length: en }, (_, i) => draftCase(`en-${i}`, 'en', 'tier1', `rename variable number ${i} in the parser`)),
+    ...Array.from({ length: zh }, (_, i) => draftCase(`zh-${i}`, 'zh-TW', 'tier1', `把第 ${i} 個變數改名`)),
+  ] });
+  const all = d => reviews(d.cases.map(c => decision(c)));
+  const pass = make(150, 50);
+  assert.equal(build(pass, all(pass)).summary.reviewedHoldoutGate, true);
+  const fewZh = make(160, 49);
+  assert.equal(build(fewZh, all(fewZh)).summary.reviewedHoldoutGate, false);
+  const partial = make(150, 50);
+  assert.equal(build(partial, reviews(all(partial).decisions.slice(1))).summary.reviewedHoldoutGate, false);
+});
+
+test('S1-K07 CLI builds a corpus file and fails closed on invalid input', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-corpus-'));
+  try {
+    const cli = path.join(root, 'scripts/system-one-corpus.js');
+    const input = path.join(dir, 'draft.json'); const review = path.join(dir, 'reviews.json'); const out = path.join(dir, 'corpus.json');
+    const d = draft();
+    fs.writeFileSync(input, JSON.stringify(d));
+    fs.writeFileSync(review, JSON.stringify(reviews([decision(d.cases[0])])));
+    const ok = spawnSync(process.execPath, [cli, 'build', input, review, out], { encoding: 'utf8' });
+    assert.equal(ok.status, 0, ok.stderr);
+    assert.equal(JSON.parse(ok.stdout).reviewed, 1);
+    assert.equal(validateCorpus(JSON.parse(fs.readFileSync(out, 'utf8'))), true);
+    const none = spawnSync(process.execPath, [cli, 'build', input, '-', out], { encoding: 'utf8' });
+    assert.equal(none.status, 0, none.stderr);
+    assert.equal(JSON.parse(none.stdout).reviewed, 0);
+    fs.writeFileSync(review, '{"schemaVersion":1,"decisions":[{"id":"zzz"}]}');
+    assert.equal(spawnSync(process.execPath, [cli, 'build', input, review, out], { encoding: 'utf8' }).status, 1);
+    assert.equal(spawnSync(process.execPath, [cli, 'bogus'], { encoding: 'utf8' }).status, 1);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('S1-K08 the committed holdout draft meets size, language, class and length requirements', () => {
+  const d = JSON.parse(fs.readFileSync(draftPath, 'utf8'));
+  assert.equal(validateDraft(d), true);
+  const { corpus } = build(d, null);
+  assert.equal(validateCorpus(corpus), true);
+  assert.ok(d.cases.length >= 220, 'headroom above 200 for rejected cases');
+  for (const lang of ['en', 'zh-TW']) assert.ok(d.cases.filter(c => c.language === lang).length >= 60, lang);
+  for (const gold of ['tier1', 'tier2', 'tier3', null]) assert.ok(d.cases.filter(c => c.proposedGold === gold).length >= 40, String(gold));
+  const bytes = d.cases.map(c => Buffer.byteLength(c.prompt, 'utf8'));
+  assert.ok(bytes.filter(b => b > 224).length / bytes.length >= 0.15, 'long prompts are represented');
+  assert.ok(bytes.filter(b => b <= 40).length / bytes.length >= 0.1, 'short prompts are represented');
+  assert.ok(d.cases.some(c => c.source === 'derived:local-history') && d.cases.some(c => c.source === 'synthetic:authored'));
+  assert.ok(new Set(d.cases.map(c => c.family)).size >= 40, 'enough distinct families');
+});
+
+test('S1-K09 the committed reviewed holdout is reproducible from owner decisions and meets the gate', () => {
+  const read = name => JSON.parse(fs.readFileSync(path.join(root, 'benchmarks/fixtures', name), 'utf8'));
+  const d = read('system-one-holdout-draft.json');
+  const r = read('system-one-holdout-reviews.json');
+  assert.equal(validateReviews(r), true);
+  assert.deepEqual(r.decisions.map(x => x.id).sort(), d.cases.map(c => c.id).sort(), 'every draft case has exactly one owner decision');
+  const { corpus, summary } = build(d, r);
+  assert.equal(summary.stale, 0);
+  assert.equal(summary.unreviewed, 0);
+  assert.equal(summary.reviewedHoldoutGate, true);
+  assert.deepEqual(read('system-one-holdout.json'), corpus, 'committed corpus equals the rebuild');
+  for (const gold of ['tier1', 'tier2', 'tier3', null]) assert.ok(corpus.cases.filter(c => c.gold === gold).length >= 15, String(gold));
+});

package/docs/system-one-corpus.md

@@ -0,0 +1,103 @@
+# System One holdout corpus: labeling and review
+
+This document defines how the reviewed tier holdout for
+[System One](system-one-routing.md) is written, labeled, reviewed and
+assembled (issue [#233](https://github.com/dyphn1/Harness-everything/issues/233),
+Phase 3). The `reviewedHoldout` gate requires at least 200 holdout cases, at
+least 50 per language, and `reviewed: true` on every case.
+
+## Gold labels
+
+A gold label answers one question: **which tier should Harness route this prompt
+to, judged from the prompt alone?** The labels follow the tier model in
+[routing.md](routing.md#three-tier-routing-model) and the fixed tier catalog.
+
+| Gold | Use when the prompt asks for | Examples of shape |
+| --- | --- | --- |
+| `tier1` | Something answered or done without changing project behavior: Git/GitHub housekeeping (commit, push, open a PR, sync, tag, post given results as a comment), a status check, reading a log or searching and reporting, the smallest doc fix (a typo, a link, an ignore entry), or a reply the assistant can give directly, including non-engineering chores and discussion questions | "commit these changes", "is issue 88 still open?", "find every repo still using the old logging package", "close the other apps" |
+| `tier2` | A bounded change or investigation: any code, configuration or CI edit (a rename, a value, a revert), running tests or a build, filing an issue, explaining code that must be read first, most bug fixes, a focused review or benchmark, planning or synthesis that produces documents (phase plans, an ADR, an overview), and answers that settle open decisions for work in progress | "rename tmp to buffer", "run npm test", "the CLI fails with this error, fix it", "1. agree 2. keep the old name" |
+| `tier3` | New or changed behavior delivered with tests, and anything larger: a new flag or format, a behavior change across producers and tests, a large refactor, a dependency upgrade with breakage, a migration, a repository-wide change, a multi-phase implementation, or delegation to several agents | "add a --verbose flag with tests", "migrate to ESM", "dispatch agents to audit every repo" |
+| `null` | No actionable content: a bare continuation, "do what you said", a vague reaction, a question about what the assistant meant, or pasted status with no request | "go", "yes", "照剛剛說的改", "something is off here" |
+
+Rules:
+
+1. Label the work the prompt would start. A reply that settles decisions for
+   work in progress ("1. agree 2. use hash") is labeled by that work, not `null`.
+   Use `null` only when no work can be identified at all.
+2. Label the work requested, not the words used. Searching every repository and
+   reporting is `tier1`; changing every repository is `tier3`.
+3. Pick the smallest tier that covers the whole request.
+4. Explicit workflow words ("use fable", "no subagents") do not change the gold.
+   Precedence is a router policy, not a label.
+5. Never derive gold from the lexical router or any model output. A reviewer may
+   read the proposed gold, but the recorded gold is the reviewer's decision.
+
+These definitions are the repository owner's, recorded after the first review
+of the draft: the owner's labels moved many drafted cases one tier up, labeled
+context-dependent replies by their work, and gave non-engineering chores
+`tier1`. The draft's `proposedGold` values predate this and are only
+suggestions. Acknowledgements, reactions, host commands (`/compact`) and meeting
+notes were rejected from the holdout because they never reach routing as tasks.
+
+## Cases
+
+Each draft case has `id`, `family`, `language` (`en` or `zh-TW`), `source`,
+`prompt`, `proposedGold` and a one-line `rationale`.
+
+- **Family.** A family groups prompts that share one task scenario, such as
+  "commit and push" or "fix a CLI error from a pasted log". Paraphrases,
+  translations and variants of one scenario stay in one family, and a family
+  never spans splits. All families in this corpus are `holdout`. Later train or
+  validation data must use new families.
+- **Source.** `synthetic:authored` marks a prompt written for the corpus.
+  `derived:local-history` marks a prompt rewritten from the shape of a real
+  local prompt: same length class, task type and phrasing style, with every
+  name, path, product, customer, issue number and pasted log replaced. No real
+  prompt text, person, organization or local path is committed.
+- **Length.** The corpus follows the observed length profile of real local
+  prompts (median about 90 UTF-8 bytes, about one in five over 224 bytes, a
+  long tail with pasted logs), so that length limits are evaluated on realistic
+  input, not only short prompts.
+
+## Review
+
+A human reviewer decides every case on the review page. The possible decisions are:
+
+| Decision | Effect |
+| --- | --- |
+| `accept` | Gold is the proposed gold. |
+| `relabel` | Gold is the reviewer's chosen label. |
+| `reject` | The case is dropped: ambiguous even for a human, unrealistic, or it leaks private data. |
+
+Each decision records the case ID, the SHA-256 of the exact prompt text it
+reviewed (`promptHash`), the decision, the gold, and the reviewer role. The
+assembler `scripts/system-one-corpus.js` builds the evaluation corpus from the
+draft and the decisions:
+
+- A case with a valid decision becomes `reviewed: true` with the reviewer's gold.
+- A case without a decision, or whose prompt changed after review (hash
+  mismatch), stays `reviewed: false` with the proposed gold, so the gate cannot
+  pass on stale or missing review.
+- A rejected case is omitted.
+- The output passes `validateCorpus`, and the assembler reports per-language and
+  per-gold counts plus whether the `reviewedHoldout` gate would pass.
+
+The agent that drafts cases never records decisions. `reviewed: true` means a
+human reviewed that exact text. Review records store a role
+(`human:repository-owner`), not a name or account. When a decision contradicts
+the owner's decisions on sibling cases, the agent may ask the owner to confirm
+it. The owner's answer is recorded as the decision, and the agent never changes
+a decision on its own.
+
+## Committed files
+
+| File | Content |
+| --- | --- |
+| `benchmarks/fixtures/system-one-holdout-draft.json` | Draft cases with proposed gold |
+| `benchmarks/fixtures/system-one-holdout-reviews.json` | Owner decisions (ID, prompt hash, decision, gold, role) |
+| `benchmarks/fixtures/system-one-holdout.json` | Evaluation corpus, rebuilt with `node scripts/system-one-corpus.js build <draft> <reviews> <corpus>` |
+
+The reviewed holdout has 215 cases (11 rejected): en 93 and zh-TW 122; gold
+`tier1` 47, `tier2` 97, `tier3` 51 and `null` 20. It meets the `reviewedHoldout`
+gate. It says nothing about model quality until a `harness-routing-v1`
+checkpoint is evaluated on it.

package/docs/system-one-routing.md

@@ -227,7 +227,8 @@ The corpus is `{schemaVersion: 1, cases: [...]}`. Each case has exactly `id`,
 The complete fixed tier catalog must match. IDs and request hashes are unique;
 no family may span splits. Evaluation uses only holdout, never training labels.
 The committed seed corpus is a mechanism fixture, not an independently reviewed
-holdout. Expand and review it separately before making quality claims.
+holdout. The reviewed holdout is written, labeled and assembled as described in
+[system-one-corpus.md](system-one-corpus.md).
 
 The CLI runs the real lexical baseline and the configured provider twice per
 holdout case. Records contain IDs, baseline prediction, decision, model identity,

package/opencode-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-enforcement",
   "description": "Repository inventory for the opencode enforcement plugin and its standalone helper",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {

package/plugins/harness-everything/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/sbom.cdx.json

@@ -2,23 +2,23 @@
   "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.7",
-  "serialNumber": "urn:uuid:3cb9e1e8-a9f0-5bc4-87ab-794acb1e79c3",
+  "serialNumber": "urn:uuid:a1c20a4d-4ba9-561e-92d1-aae9c14cdc08",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-23T11:35:56.699Z",
+    "timestamp": "2026-09-23T11:44:30.450Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.22.1"
+        "version": "0.23.0"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.22.1",
+      "bom-ref": "pkg:npm/harness-everything@0.23.0",
       "name": "harness-everything",
-      "version": "0.22.1",
-      "purl": "pkg:npm/harness-everything@0.22.1"
+      "version": "0.23.0",
+      "purl": "pkg:npm/harness-everything@0.23.0"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.22.1",
+      "ref": "pkg:npm/harness-everything@0.23.0",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",

package/scripts/system-one-corpus.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+'use strict';
+// Assembles the System One tier holdout from a draft plus human review decisions.
+// See docs/system-one-corpus.md. A decision counts only for the exact prompt text it reviewed.
+const fs = require('node:fs');
+const { createHash } = require('node:crypto');
+const { createRequest } = require('../harness-everything/scripts/system-one/contract');
+const { TIER_OPTIONS } = require('../harness-everything/scripts/system-one/router');
+const { validateCorpus } = require('../harness-everything/scripts/system-one/evaluate');
+
+const SOURCES = ['synthetic:authored', 'derived:local-history'];
+const LANGUAGES = ['en', 'zh-TW'];
+const GOLD = ['tier1', 'tier2', 'tier3', null];
+const REVIEWER = 'human:repository-owner';
+// Drafts are committed publicly: no email addresses or user home paths.
+const PRIVATE = [/[\w.+-]+@[\w-]+\.[\w.-]+/, /[A-Za-z]:\\Users\\/i, /\/home\/[^/\s]+/, /\/Users\/[^/\s]+/];
+const exact = (v, keys) => v && typeof v === 'object' && !Array.isArray(v)
+  && Object.keys(v).length === keys.length && keys.every(k => Object.hasOwn(v, k));
+const nonempty = v => typeof v === 'string' && v.trim().length > 0;
+const fail = code => { throw new TypeError(code); };
+const promptHash = text => createHash('sha256').update(text, 'utf8').digest('hex');
+
+function validateDraft(draft) {
+  if (!exact(draft, ['schemaVersion', 'cases']) || draft.schemaVersion !== 1 || !Array.isArray(draft.cases) || !draft.cases.length) fail('invalid-draft');
+  const ids = new Set(); const prompts = new Set();
+  for (const c of draft.cases) {
+    if (!exact(c, ['id', 'family', 'language', 'source', 'prompt', 'proposedGold', 'rationale'])
+      || ![c.id, c.family, c.prompt, c.rationale].every(nonempty) || !/^[a-z0-9._-]{1,80}$/.test(c.id)
+      || !LANGUAGES.includes(c.language) || !SOURCES.includes(c.source) || !GOLD.includes(c.proposedGold)
+      || ids.has(c.id) || prompts.has(c.prompt) || PRIVATE.some(re => re.test(c.prompt))) fail('invalid-draft');
+    ids.add(c.id); prompts.add(c.prompt);
+  }
+  return true;
+}
+
+function validateReviews(reviews) {
+  if (!exact(reviews, ['schemaVersion', 'decisions']) || reviews.schemaVersion !== 1 || !Array.isArray(reviews.decisions)) fail('invalid-reviews');
+  const ids = new Set();
+  for (const d of reviews.decisions) {
+    if (!exact(d, ['id', 'promptHash', 'decision', 'gold', 'reviewer']) || !nonempty(d.id) || ids.has(d.id)
+      || typeof d.promptHash !== 'string' || !/^[0-9a-f]{64}$/.test(d.promptHash)
+      || !['accept', 'relabel', 'reject'].includes(d.decision) || !GOLD.includes(d.gold) || d.reviewer !== REVIEWER
+      || (d.decision === 'reject' && d.gold !== null)) fail('invalid-reviews');
+    ids.add(d.id);
+  }
+  return true;
+}
+
+function build(draft, reviews) {
+  validateDraft(draft);
+  const byId = new Map();
+  if (reviews !== null) {
+    validateReviews(reviews);
+    for (const d of reviews.decisions) {
+      const c = draft.cases.find(item => item.id === d.id);
+      if (!c) fail('unknown-review-case');
+      // Accept keeps the proposed gold; relabel must change it. Checked against the current proposal.
+      if ((d.decision === 'accept' && d.gold !== c.proposedGold) || (d.decision === 'relabel' && d.gold === c.proposedGold)) fail('invalid-reviews');
+      byId.set(d.id, d);
+    }
+  }
+  const summary = { cases: 0, reviewed: 0, rejected: 0, stale: 0, unreviewed: 0,
+    byLanguage: { en: 0, 'zh-TW': 0 }, byGold: { tier1: 0, tier2: 0, tier3: 0, unclassified: 0 }, reviewedHoldoutGate: false };
+  const cases = [];
+  for (const c of draft.cases) {
+    const d = byId.get(c.id);
+    const current = d && d.promptHash === promptHash(c.prompt);
+    if (d && !current) summary.stale += 1;
+    if (current && d.decision === 'reject') { summary.rejected += 1; continue; }
+    const reviewed = Boolean(current);
+    if (reviewed) summary.reviewed += 1; else if (!d) summary.unreviewed += 1;
+    const gold = reviewed ? d.gold : c.proposedGold;
+    cases.push({ id: c.id, family: c.family, split: 'holdout', language: c.language, source: c.source, reviewed,
+      request: createRequest('tier', c.prompt, TIER_OPTIONS), gold });
+    summary.byLanguage[c.language] += 1;
+    summary.byGold[gold === null ? 'unclassified' : gold] += 1;
+  }
+  summary.cases = cases.length;
+  const corpus = { schemaVersion: 1, cases };
+  validateCorpus(corpus);
+  summary.reviewedHoldoutGate = cases.length >= 200 && cases.every(c => c.reviewed)
+    && LANGUAGES.every(lang => summary.byLanguage[lang] >= 50);
+  return { corpus, summary };
+}
+
+if (require.main === module) {
+  try {
+    const [op, draftPath, reviewsPath, outPath, extra] = process.argv.slice(2);
+    if (op !== 'build' || !draftPath || !reviewsPath || !outPath || extra) throw new Error('usage');
+    const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+    const { corpus, summary } = build(read(draftPath), reviewsPath === '-' ? null : read(reviewsPath));
+    fs.writeFileSync(outPath, `${JSON.stringify(corpus, null, 2)}\n`);
+    console.log(JSON.stringify(summary));
+  } catch (_) {
+    console.error('Usage: system-one-corpus.js build <draft.json> <reviews.json|-> <corpus.json> (invalid draft, reviews, or path)');
+    process.exitCode = 1;
+  }
+}
+module.exports = { validateDraft, validateReviews, build, promptHash, REVIEWER };