harness-everything 0.28.0 → 0.29.0

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.28.0",
+  "version": "0.29.0",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.28.0",
+  "version": "0.29.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.28.0",
+  "version": "0.29.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.28.0",
+  "version": "0.29.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/skills/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through Harness: classify tier/topolog
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.26.0
+  version: 0.29.0
 ---
 
 # Harness Everything

package/plugins/harness-everything/skills/harness-everything/scripts/system-one/evaluate.js

@@ -84,12 +84,13 @@ function evaluate(corpus, records, sourceEvidence = null) {
   const gates = {
     reviewedHoldout: cases.length >= 200 && cases.every(c => c.reviewed)
       && ['en', 'zh-TW'].every(lang => cases.filter(c => c.language === lang).length >= 50),
-    acceptedPrecision: model.acceptedPrecision !== null && model.acceptedPrecision >= 0.98,
+    acceptedPrecision: model.acceptedPrecision !== null && model.acceptedPrecision >= 0.85,
     coverage: model.coverage >= 0.8,
     macroF1: model.macroF1 >= baseline.macroF1,
     repeatability: agreement === 1,
     warmLatency: warm.length >= cases.length && latency.warmP95Ms <= 100,
-    sourceProvenance: sourceEvidence?.status === 'recorded' && sourceEvidence.provenance?.cuaS1?.sourceRevisionStatus === 'pinned',
+    sourceProvenance: sourceEvidence?.status === 'recorded' && (sourceEvidence.provenance?.cuaS1?.sourceRevisionStatus === 'pinned'
+      || (sourceEvidence.transport === 'ngram' && sourceEvidence.artifactVerified === true)),
     policyEvidence: false,
     liveHostEvidence: false,
   };

package/plugins/harness-everything/skills/harness-everything/scripts/system-one/ngram.js

@@ -0,0 +1,84 @@
+'use strict';
+// In-process System One scorer: hashed character n-grams + a linear layer (docs/system-one-routing.md, "N-gram provider").
+// Featurization must match scripts/system-one-train-ngram.py exactly; ci/mechanism-system-one-ngram.test.js proves it.
+const fs = require('node:fs');
+const { createHash } = require('node:crypto');
+
+const SIDE_KEYS = ['format', 'formatVersion', 'dim', 'nmax', 'hash', 'catalog', 'bias', 'metadata'];
+const cache = new Map();
+const configError = () => Object.assign(new Error('provider-config'), { code: 'provider-config' });
+const sha = buf => createHash('sha256').update(buf).digest('hex');
+
+function fnv1a32(text) {
+  let h = 0x811c9dc5;
+  for (const byte of Buffer.from(text, 'utf8')) { h ^= byte; h = Math.imul(h, 0x01000193) >>> 0; }
+  return h >>> 0;
+}
+// Map of bucket -> weight: log(1 + count) per code-point n-gram, one length bucket, L2-normalized.
+function featurize(text, nmax, dim) {
+  const t = text.toLowerCase().split(/\s+/).filter(Boolean).join(' ');
+  const cps = Array.from(t);
+  const counts = new Map();
+  for (let n = 1; n <= nmax; n++) {
+    for (let i = 0; i + n <= cps.length; i++) {
+      const gram = cps.slice(i, i + n).join('');
+      if (!gram.trim()) continue;
+      const b = fnv1a32(`${n}:${gram}`) % dim;
+      counts.set(b, (counts.get(b) || 0) + 1);
+    }
+  }
+  const k = Math.min(8, Math.floor(Math.log2(Buffer.byteLength(t, 'utf8') + 1)));
+  counts.set(fnv1a32(`len:${k}`) % dim, 1);
+  const feats = new Map();
+  let norm = 0;
+  for (const [b, c] of counts) { const v = Math.log1p(c); feats.set(b, v); norm += v * v; }
+  norm = Math.sqrt(norm);
+  for (const [b, v] of feats) feats.set(b, v / norm);
+  return feats;
+}
+function validSidecar(s) {
+  const isPow2 = n => Number.isInteger(n) && n >= 1024 && n <= 1 << 20 && (n & (n - 1)) === 0;
+  return s && typeof s === 'object' && !Array.isArray(s) && Object.keys(s).length === SIDE_KEYS.length && SIDE_KEYS.every(k => Object.hasOwn(s, k))
+    && s.format === 'harness-ngram' && s.formatVersion === 1 && isPow2(s.dim) && Number.isInteger(s.nmax) && s.nmax >= 1 && s.nmax <= 4
+    && s.hash === 'fnv1a32' && Array.isArray(s.catalog) && s.catalog.length >= 2 && new Set(s.catalog).size === s.catalog.length
+    && s.catalog.every(id => typeof id === 'string' && /^[a-z0-9._-]{1,80}$/.test(id))
+    && Array.isArray(s.bias) && s.bias.length === s.catalog.length && s.bias.every(Number.isFinite)
+    && s.metadata && typeof s.metadata === 'object' && !Array.isArray(s.metadata);
+}
+// Loads and verifies the artifact once per process; any mismatch throws provider-config.
+function loadModel(manifest) {
+  const key = `${manifest.checkpoint}|${manifest.weightsSha256}|${manifest.configSha256}`;
+  if (cache.has(key)) return cache.get(key);
+  const sidecarPath = manifest.checkpoint.replace(/\.bin$/, '.json');
+  let side; let bin;
+  try {
+    const raw = fs.readFileSync(sidecarPath);
+    if (raw.length > 65536 || sha(raw) !== manifest.configSha256) throw configError();
+    side = JSON.parse(raw.toString('utf8'));
+    bin = fs.readFileSync(manifest.checkpoint);
+  } catch (_) { throw configError(); }
+  if (sha(bin) !== manifest.weightsSha256 || !validSidecar(side) || bin.length !== side.dim * side.catalog.length * 4) throw configError();
+  const W = new Float32Array(side.dim * side.catalog.length);
+  for (let i = 0; i < W.length; i++) W[i] = bin.readFloatLE(i * 4);
+  const model = { dim: side.dim, nmax: side.nmax, catalog: side.catalog, bias: side.bias, W };
+  cache.set(key, model);
+  return model;
+}
+function score(request, manifest) {
+  const model = loadModel(manifest);
+  const C = model.catalog.length;
+  if (request.options.length !== C || request.options.some((o, i) => o.id !== model.catalog[i])) throw configError();
+  const logits = model.bias.slice();
+  for (const [b, v] of featurize(request.context, model.nmax, model.dim)) {
+    for (let c = 0; c < C; c++) logits[c] += v * model.W[b * C + c];
+  }
+  const max = Math.max(...logits);
+  const exps = logits.map(z => Math.exp(z - max));
+  const sum = exps.reduce((s, x) => s + x, 0);
+  return {
+    schemaVersion: 1, requestHash: request.requestHash, catalogHash: request.catalogHash,
+    model: { id: manifest.modelId, revision: manifest.revision, domain: manifest.domain },
+    scores: request.options.map((o, i) => ({ id: o.id, probability: exps[i] / sum })),
+  };
+}
+module.exports = { fnv1a32, featurize, loadModel, score };

package/plugins/harness-everything/skills/harness-everything/scripts/system-one/provider.js

@@ -17,15 +17,18 @@ const validAcceptance = a => exact(a, ['minConfidence', 'minMargin']) && inRange
 const withAcceptance = (result, manifest) => (result && result.status === 'scored' && manifest.acceptance
   ? { ...result, acceptance: { ...manifest.acceptance } } : result);
 function validateManifest(m) {
-  const required = ['schemaVersion', 'python', 'checkpoint', 'weightsSha256', 'configSha256', 'modelId', 'revision', 'domain'];
+  // The in-process ngram transport needs no Python and loads a .bin; the others run the CUA-S1 adapter.
+  const ngram = !!m && m.transport === 'ngram';
+  const required = ['schemaVersion', ...(ngram ? [] : ['python']), 'checkpoint', 'weightsSha256', 'configSha256', 'modelId', 'revision', 'domain'];
+  const strings = ['modelId', 'revision', 'domain', ...(ngram && !Object.hasOwn(m, 'python') ? [] : ['python'])];
   if (!m || typeof m !== 'object' || Array.isArray(m) || required.some(k => !Object.hasOwn(m, k))
-    || Object.keys(m).some(k => ![...required, 'timeoutMs', 'transport', 'idleTimeoutMs', 'acceptance'].includes(k)) || m.schemaVersion !== 1
+    || Object.keys(m).some(k => ![...required, 'python', 'timeoutMs', 'transport', 'idleTimeoutMs', 'acceptance'].includes(k)) || m.schemaVersion !== 1
     || (m.acceptance !== undefined && !validAcceptance(m.acceptance))
-    || ['python', 'modelId', 'revision', 'domain'].some(k => typeof m[k] !== 'string' || !m[k].trim() || m[k].length > 4096 || m[k].includes('\0'))
-    || typeof m.checkpoint !== 'string' || !path.isAbsolute(m.checkpoint) || path.extname(m.checkpoint) !== '.safetensors'
+    || strings.some(k => typeof m[k] !== 'string' || !m[k].trim() || m[k].length > 4096 || m[k].includes('\0'))
+    || typeof m.checkpoint !== 'string' || !path.isAbsolute(m.checkpoint) || path.extname(m.checkpoint) !== (ngram ? '.bin' : '.safetensors')
     || ['weightsSha256', 'configSha256'].some(k => typeof m[k] !== 'string' || !/^[a-f0-9]{64}$/.test(m[k]))
     || (m.timeoutMs !== undefined && (!Number.isInteger(m.timeoutMs) || m.timeoutMs < 1 || m.timeoutMs > 10000))
-    || (m.transport !== undefined && !['oneshot', 'resident'].includes(m.transport))
+    || (m.transport !== undefined && !['oneshot', 'resident', 'ngram'].includes(m.transport))
     || (m.idleTimeoutMs !== undefined && (!Number.isInteger(m.idleTimeoutMs) || m.idleTimeoutMs < 60000 || m.idleTimeoutMs > 14400000))
     || (m.modelId === 'cua-ai/cua-s1-forms' && m.domain !== 'forms-v1')) throw new TypeError('invalid-manifest');
   return true;
@@ -57,15 +60,22 @@ function score(request, manifestPath) {
   validateRequest(request);
   let manifest;
   try { manifest = readManifest(manifestPath); } catch (_) { return unavailable('provider-config'); }
+  if (manifest.transport === 'ngram') return withAcceptance(inProcess(request, manifest), manifest);
   if (manifest.transport === 'resident') return withAcceptance(require('./resident').score({ ...request }, manifest, manifestPath), manifest);
   return withAcceptance(oneShot(request, manifest), manifest);
 }
+// The ngram transport scores in this process; an artifact mismatch is a configuration error, never a score.
+function inProcess(request, manifest) {
+  try { return { status: 'scored', response: require('./ngram').score({ ...request }, manifest) }; }
+  catch (_) { return unavailable('provider-config'); }
+}
 // Async callers (the hook entry) reach a resident server without the sync worker bridge.
 // One-shot has no server to overlap with, so it runs the same child synchronously.
 async function scoreAsync(request, manifestPath) {
   validateRequest(request);
   let manifest;
   try { manifest = readManifest(manifestPath); } catch (_) { return unavailable('provider-config'); }
+  if (manifest.transport === 'ngram') return withAcceptance(inProcess(request, manifest), manifest);
   if (manifest.transport === 'resident') return withAcceptance(await require('./resident').scoreAsync({ ...request }, manifest, manifestPath), manifest);
   return withAcceptance(oneShot(request, manifest), manifest);
 }

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:a9471ff7-cd1e-58b8-b661-a6231462bdd7",
+  "serialNumber": "urn:uuid:03c78df6-955e-5903-b3d9-620c6be8e2d4",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-27T17:31:25.591Z",
+    "timestamp": "2026-09-28T01:49:53.842Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.28.0"
+        "version": "0.29.0"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.28.0",
+      "bom-ref": "pkg:npm/harness-everything@0.29.0",
       "name": "harness-everything",
-      "version": "0.28.0",
-      "purl": "pkg:npm/harness-everything@0.28.0"
+      "version": "0.29.0",
+      "purl": "pkg:npm/harness-everything@0.29.0"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.28.0",
+      "ref": "pkg:npm/harness-everything@0.29.0",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",

package/scripts/evaluate-system-one.js

@@ -13,10 +13,15 @@ async function run(corpus, manifest) {
   validateCorpus(corpus);
   let config = null;
   try { config = readManifest(manifest); } catch (_) { /* Missing provider remains an explicit unavailable measurement. */ }
-  // Resident runs are measured only after readiness, so every sample is warm; one-shot samples are cold.
-  const warm = config?.transport === 'resident';
-  const wasRunning = warm && resident.status(config, manifest).running;
-  const ready = warm && resident.ensureReady(config, manifest, 60000);
+  // Resident runs are measured only after readiness and ngram scores in process after one verified load,
+  // so their samples are warm; one-shot samples are cold.
+  const isResident = config?.transport === 'resident';
+  const isNgram = config?.transport === 'ngram';
+  const warm = isResident || isNgram;
+  const wasRunning = isResident && resident.status(config, manifest).running;
+  const ready = isResident && resident.ensureReady(config, manifest, 60000);
+  let artifactVerified = false;
+  if (isNgram) { try { require('../harness-everything/scripts/system-one/ngram').loadModel(config); artifactVerified = true; } catch (_) { /* recorded below */ } }
   const records = [];
   const originalMode = process.env.HARNESS_SYSTEM_ONE_MODE;
   const originalLog = console.log;
@@ -37,7 +42,7 @@ async function run(corpus, manifest) {
       records.push({ id: c.id, baseline: tier === 'unclassified' ? null : tier, runs });
     }
   } finally {
-    if (warm && !wasRunning) resident.stop(config, manifest);
+    if (isResident && !wasRunning) resident.stop(config, manifest);
     console.log = originalLog;
     if (originalMode === undefined) delete process.env.HARNESS_SYSTEM_ONE_MODE;
     else process.env.HARNESS_SYSTEM_ONE_MODE = originalMode;
@@ -47,11 +52,13 @@ async function run(corpus, manifest) {
     const m = JSON.parse(fs.readFileSync(manifest, 'utf8'));
     artifact = { declaredModelId: m.modelId, declaredRevision: m.revision, weightsSha256: m.weightsSha256, configSha256: m.configSha256 };
   } catch (_) { /* Missing provider remains an explicit unavailable measurement. */ }
-  const source = provenance(manifest);
-  return { ...evaluate(corpus, records, source), evidence: { kind: warm ? 'offline-resident' : 'offline-one-shot', artifact, source,
-    residentReady: warm ? ready : null,
+  // The ngram transport has no Python package to probe; its provenance is the hash-verified artifact.
+  const source = isNgram ? { status: 'recorded', transport: 'ngram', artifactVerified } : provenance(manifest);
+  const kind = isNgram ? 'offline-ngram' : isResident ? 'offline-resident' : 'offline-one-shot';
+  return { ...evaluate(corpus, records, source), evidence: { kind, artifact, source,
+    residentReady: isResident ? ready : null,
     environment: { cpu: os.cpus()[0]?.model || 'unknown', os: `${os.platform()} ${os.release()} ${os.arch()}`, node: process.version,
-      python: source.status === 'recorded' ? source.provenance.python : null, threads: 1 },
+      python: source.status === 'recorded' && source.provenance ? source.provenance.python : null, threads: 1 },
     limitations: ['No independently verified holdout review', ...(warm ? [] : ['No warm inference measurement']), 'No live-host or policy evidence'] }, records };
 }
 if (require.main === module) {

package/scripts/system-one-calibrate.js

@@ -13,7 +13,7 @@ function decideRow(probs, { minConfidence, minMargin }) {
   if (margin === 0 || top[0] < minConfidence || margin < minMargin || IDS[top[1]] === 'unclassified') return null;
   return IDS[top[1]];
 }
-function calibrate(rows, { minPrecision = 0.98 } = {}) {
+function calibrate(rows, { minPrecision = 0.85 } = {}) {
   let best = null;
   for (let c = 50; c <= 99; c++) {
     for (let m = 0; m <= 90; m += 5) {

package/scripts/system-one-label.js

@@ -3,6 +3,7 @@
 // Labels System One training prompts with an LLM against the owner's rules (docs/system-one-corpus.md).
 // See docs/system-one-training.md. Labels stay local; only the holdout agreement report may be committed.
 const fs = require('node:fs');
+const os = require('node:os');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
 const { createHash } = require('node:crypto');
@@ -105,6 +106,32 @@ function commandRunner(model) {
     child.stdin.end(prompt);
   });
 }
+// One stateless `codex exec` per batch: prompt on stdin, schema-checked last message in a temp file,
+// read-only sandbox, no session files and no user config (plugins/hooks), so nothing accumulates across batches.
+function codexRunner(model) {
+  const base = process.env.HARNESS_S1_LABEL_COMMAND ? JSON.parse(process.env.HARNESS_S1_LABEL_COMMAND) : ['codex'];
+  const work = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-codex-'));
+  const schemaFile = path.join(work, 'schema.json');
+  fs.writeFileSync(schemaFile, SCHEMA);
+  let n = 0;
+  return prompt => new Promise((resolve, reject) => {
+    const outFile = path.join(work, `reply-${process.pid}-${n++}.json`);
+    const args = ['exec', '--model', model, '-c', 'model_reasoning_effort=medium', '--sandbox', 'read-only', '--skip-git-repo-check',
+      '--ephemeral', '--ignore-user-config', '--output-schema', schemaFile, '-o', outFile, '-C', work, '-'];
+    const child = spawn(base[0], [...base.slice(1), ...args], { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true,
+      shell: process.platform === 'win32' && !process.env.HARNESS_S1_LABEL_COMMAND });
+    const timer = setTimeout(() => child.kill(), 600000);
+    child.on('error', err => { clearTimeout(timer); reject(err); });
+    child.on('close', code => {
+      clearTimeout(timer);
+      let reply = null;
+      try { reply = JSON.parse(fs.readFileSync(outFile, 'utf8')); } catch (_) { reject(new Error(`codex-exit-${code}: no reply`)); return; }
+      try { fs.unlinkSync(outFile); } catch (_) { /* temp file */ }
+      resolve(reply);
+    });
+    child.stdin.end(prompt);
+  });
+}
 function outsideRepo(file) {
   const rel = path.relative(REPO, path.resolve(file));
   if (!rel.startsWith('..') && !path.isAbsolute(rel)) throw new Error('refusing to write labels inside the repository');
@@ -113,10 +140,12 @@ function outsideRepo(file) {
 async function main(argv) {
   const [op, ...rest] = argv;
   const opt = (name, fallback) => { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : fallback; };
-  const model = opt('--model', 'sonnet');
+  const engine = opt('--engine', 'claude');
+  if (!['claude', 'codex'].includes(engine)) throw new Error('--engine must be claude or codex');
+  const model = opt('--model', engine === 'codex' ? 'gpt-5.6-luna' : 'sonnet');
   const rules = rulesFromDoc(fs.readFileSync(path.join(REPO, 'docs', 'system-one-corpus.md'), 'utf8'));
-  const labeler = { model, rulesSha256: sha(rules).slice(0, 16) };
-  const run = commandRunner(model);
+  const labeler = { model, rulesSha256: sha(rules).slice(0, 16), ...(engine === 'codex' ? { engine } : {}) };
+  const run = engine === 'codex' ? codexRunner(model) : commandRunner(model);
   const concurrency = Number(opt('--concurrency', '4')); const batchSize = Number(opt('--batch', '100'));
   if (op === 'label') {
     const input = opt('--in'); const out = opt('--out');

package/scripts/system-one-train-ngram.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""Train the System One ngram tier scorer (docs/system-one-training.md, docs/system-one-routing.md "N-gram provider").
+
+Featurization is stdlib-only and must match harness-everything/scripts/system-one/ngram.js exactly
+(ci/mechanism-system-one-ngram.test.js compares them). torch is imported only inside train() for the optimizer.
+"""
+import argparse
+import hashlib
+import json
+import math
+from pathlib import Path
+import struct
+import sys
+
+sys.dont_write_bytecode = True
+REPO = Path(__file__).resolve().parents[1]
+DEFAULT_HOLDOUT = REPO / 'benchmarks' / 'fixtures' / 'system-one-holdout.json'
+
+
+def fnv1a32(text):
+    h = 0x811c9dc5
+    for byte in text.encode('utf-8'):
+        h ^= byte
+        h = (h * 0x01000193) & 0xFFFFFFFF
+    return h
+
+
+def featurize(text, nmax, dim):
+    """bucket -> weight: log(1 + count) per code-point n-gram, one length bucket, L2-normalized."""
+    t = ' '.join(text.lower().split())
+    counts = {}
+    for n in range(1, nmax + 1):
+        for i in range(len(t) - n + 1):
+            gram = t[i:i + n]
+            if not gram.strip():
+                continue
+            b = fnv1a32(f'{n}:{gram}') % dim
+            counts[b] = counts.get(b, 0) + 1
+    k = min(8, int(math.floor(math.log2(len(t.encode('utf-8')) + 1))))
+    counts[fnv1a32(f'len:{k}') % dim] = 1
+    feats = {b: math.log1p(c) for b, c in counts.items()}
+    norm = math.sqrt(sum(v * v for v in feats.values()))
+    return {b: v / norm for b, v in feats.items()}
+
+
+def load_jsonl(path):
+    return [json.loads(line) for line in Path(path).read_text(encoding='utf-8').splitlines() if line.strip()]
+
+
+def sha256_file(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def train(args):
+    import torch
+
+    torch.manual_seed(args.seed)
+    data = Path(args.data_dir)
+    corpus = json.loads(Path(args.holdout).read_text(encoding='utf-8'))
+    catalog = [o['id'] for o in corpus['cases'][0]['request']['options']]
+    gold = {r['id']: r['gold'] for r in load_jsonl(data / 'labels.jsonl')}
+    overrides = data / 'owner-overrides.jsonl'
+    if overrides.exists():
+        gold.update({r['id']: r['gold'] for r in load_jsonl(overrides)})
+    excluded = data / 'owner-excluded.jsonl'
+    skip = {r['id'] for r in load_jsonl(excluded)} if excluded.exists() else set()
+    rows = [p for p in load_jsonl(data / 'prompts.jsonl') if p['id'] in gold and p['id'] not in skip]
+    index = lambda g: catalog.index('unclassified' if g is None else g)
+    split = {name: [r for r in rows if r['split'] == name] for name in ('train', 'validation')}
+
+    def matrix(items):
+        ii, jj, vv = [], [], []
+        for r, item in enumerate(items):
+            for b, v in featurize(item['text'], args.nmax, args.dim).items():
+                ii.append(r); jj.append(b); vv.append(v)
+        return torch.sparse_coo_tensor([ii, jj], vv, (len(items), args.dim), dtype=torch.float32).coalesce()
+
+    x_train, x_val = matrix(split['train']), matrix(split['validation'])
+    y_train = torch.tensor([index(gold[r['id']]) for r in split['train']])
+    counts = torch.bincount(y_train, minlength=len(catalog)).float()
+    inverse = torch.where(counts > 0, counts.sum() / (len(catalog) * counts.clamp_min(1)), torch.zeros_like(counts))
+    weight = {'none': None, 'sqrt': inverse.sqrt(), 'full': inverse}[args.balance]
+    W = torch.zeros(args.dim, len(catalog), requires_grad=True)
+    bias = torch.zeros(len(catalog), requires_grad=True)
+    optimizer = torch.optim.Adam([W, bias], lr=args.lr)
+    for _ in range(args.epochs):
+        optimizer.zero_grad()
+        loss = torch.nn.functional.cross_entropy(torch.sparse.mm(x_train, W) + bias, y_train, weight=weight) + args.weight_decay * (W ** 2).sum()
+        loss.backward()
+        optimizer.step()
+    with torch.no_grad():
+        probs = torch.softmax(torch.sparse.mm(x_val, W) + bias, 1)
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    weights = W.detach().contiguous().view(-1).tolist()
+    (out / 'harness-routing-v1.bin').write_bytes(struct.pack(f'<{len(weights)}f', *weights))
+    datasets = {name: sha256_file(data / name) for name in ('prompts.jsonl', 'labels.jsonl')}
+    if overrides.exists():
+        datasets['owner-overrides.jsonl'] = sha256_file(overrides)
+    sidecar = {'format': 'harness-ngram', 'formatVersion': 1, 'dim': args.dim, 'nmax': args.nmax, 'hash': 'fnv1a32', 'catalog': catalog,
+               'bias': [float(v) for v in bias.detach().tolist()],
+               'metadata': {'domain': 'harness-routing-v1', 'balance': args.balance, 'weightDecay': args.weight_decay, 'epochs': args.epochs,
+                            'seed': args.seed, 'datasets': datasets, 'counts': {k: len(v) for k, v in split.items()}}}
+    (out / 'harness-routing-v1.json').write_text(json.dumps(sidecar), encoding='utf-8')
+    with (out / 'val-scores.jsonl').open('w', encoding='utf-8') as fh:
+        for r, p in zip(split['validation'], probs.tolist()):
+            fh.write(json.dumps({'id': r['id'], 'gold': gold[r['id']], 'probs': p}) + '\n')
+    y_val = torch.tensor([index(gold[r['id']]) for r in split['validation']])
+    accuracy = (probs.argmax(1) == y_val).float().mean().item() if len(y_val) else 0.0
+    print(json.dumps({'counts': sidecar['metadata']['counts'], 'validationAccuracy': accuracy}))
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--data-dir', required=True)
+    parser.add_argument('--out', required=True)
+    parser.add_argument('--holdout', default=str(DEFAULT_HOLDOUT), help='source of the fixed catalog only; holdout rows are never trained on')
+    parser.add_argument('--dim', type=int, default=1 << 16)
+    parser.add_argument('--nmax', type=int, default=3)
+    parser.add_argument('--balance', choices=['none', 'sqrt', 'full'], default='sqrt')
+    parser.add_argument('--weight-decay', type=float, default=1e-4)
+    parser.add_argument('--epochs', type=int, default=60)
+    parser.add_argument('--lr', type=float, default=0.01)
+    parser.add_argument('--seed', type=int, default=7)
+    train(parser.parse_args(argv))
+
+
+if __name__ == '__main__':
+    main()

package/scripts/system-one-train.py

@@ -50,6 +50,16 @@ def join(prompts, labels, overrides):
     return [{'id': p['id'], 'split': p['split'], 'text': p['text'], 'gold': gold[p['id']]} for p in prompts if p['id'] in gold]
 
 
+def class_weights(label_indices, num_classes):
+    """Inverse-frequency weights that average to 1 over the examples; absent classes get 0."""
+    counts = [0] * num_classes
+    for i in label_indices:
+        counts[i] += 1
+    present = sum(1 for c in counts if c)
+    total = len(label_indices)
+    return [total / (present * c) if c else 0.0 for c in counts]
+
+
 def make_batches(lengths, token_budget):
     """Length-bucketed batches: each batch's size times its longest item stays within the budget."""
     order = sorted(range(len(lengths)), key=lambda i: (lengths[i], i))
@@ -94,6 +104,8 @@ def train(args):
     train_batches = make_batches(lengths(split['train']), args.token_budget)
     val_batches = make_batches(lengths(split['validation']), args.token_budget)
     optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=0.01)
+    # Class balance counters the tier2-heavy labels; validation NLL stays unweighted so epochs remain comparable.
+    weight = torch.tensor(class_weights([e.label for e in train_x], len(catalog)), dtype=torch.float) if args.balance else None
 
     def evaluate():
         model.eval()
@@ -118,7 +130,7 @@ def train(args):
         total = 0.0
         for b in order:
             tensors = collator([train_x[i] for i in train_batches[b]])
-            loss = torch.nn.functional.cross_entropy(model(tensors), tensors['labels'])
+            loss = torch.nn.functional.cross_entropy(model(tensors), tensors['labels'], weight=weight)
             optimizer.zero_grad()
             loss.backward()
             torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
@@ -161,6 +173,7 @@ def main(argv=None):
     parser.add_argument('--threads', type=int, default=4)
     parser.add_argument('--context-tokens', type=int, default=1024)
     parser.add_argument('--token-budget', type=int, default=16384)
+    parser.add_argument('--balance', action='store_true', help='inverse-frequency class weights in the training loss')
     train(parser.parse_args(argv))