harness-everything 0.28.0 → 0.30.0

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

@@ -0,0 +1,161 @@
+'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 ngram = require('../harness-everything/scripts/system-one/ngram');
+const provider = require('../harness-everything/scripts/system-one/provider');
+const { createRequest, decide } = require('../harness-everything/scripts/system-one/contract');
+const { TIER_OPTIONS } = require('../harness-everything/scripts/system-one/router');
+const root = path.resolve(__dirname, '..');
+const python = process.env.PYTHON || (process.platform === 'win32' ? 'python' : 'python3');
+const sha = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const IDS = TIER_OPTIONS.map(o => o.id);
+
+// A tiny model whose weights push any text containing the "commit" trigram toward tier1.
+function artifact(dir, { dim = 1024, nmax = 3, catalog = IDS, sidecar = {}, bytes } = {}) {
+  const W = new Float32Array(dim * catalog.length);
+  const hot = ngram.fnv1a32('3:com') % dim;
+  W[hot * catalog.length + 0] = 40;
+  const bin = path.join(dir, 'tier.bin'); const json = path.join(dir, 'tier.json');
+  fs.writeFileSync(bin, bytes || Buffer.from(W.buffer));
+  fs.writeFileSync(json, JSON.stringify({ format: 'harness-ngram', formatVersion: 1, dim, nmax, hash: 'fnv1a32', catalog, bias: catalog.map(() => 0), metadata: { fixture: true }, ...sidecar }));
+  return { bin, json };
+}
+function manifest(dir, files, extra = {}) {
+  const m = { schemaVersion: 1, transport: 'ngram', checkpoint: files.bin, weightsSha256: sha(files.bin), configSha256: sha(files.json),
+    modelId: 'fixture/ngram', revision: 'v1', domain: 'harness-routing-v1', ...extra };
+  const p = path.join(dir, 'manifest.json'); fs.writeFileSync(p, JSON.stringify(m)); return { m, p };
+}
+const tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-ngram-'));
+
+test('S1-N01 fnv1a32 matches the published test vectors', () => {
+  assert.equal(ngram.fnv1a32(''), 0x811c9dc5);
+  assert.equal(ngram.fnv1a32('a'), 0xe40c292c);
+  assert.equal(ngram.fnv1a32('foobar'), 0xbf9cf968);
+});
+
+test('S1-N02 featurization follows the pinned rules', () => {
+  const f = ngram.featurize('  Commit   ALL\tchanges ', 3, 1 << 16);
+  assert.deepEqual(f, ngram.featurize('commit all changes', 3, 1 << 16), 'lowercase and whitespace normalization');
+  const norm = Math.sqrt([...f.values()].reduce((s, v) => s + v * v, 0));
+  assert.ok(Math.abs(norm - 1) < 1e-12);
+  assert.ok(f.has(ngram.fnv1a32('len:4') % (1 << 16)), 'length bucket for 18 UTF-8 bytes');
+  const cjk = ngram.featurize('修正😀', 2, 1 << 16);
+  assert.ok(cjk.has(ngram.fnv1a32('2:正😀') % (1 << 16)), 'n-grams are over code points, not UTF-16 units');
+  assert.ok(!ngram.featurize('a b', 3, 1 << 16).has(ngram.fnv1a32('1: ') % (1 << 16)), 'space-only grams are skipped');
+});
+
+test('S1-N03 the Python trainer and the Node provider produce identical features', () => {
+  const texts = ['commit all changes', '幫我修正 parser 的錯誤並補測試', '  MIXED Case\ttext 😀 ', 'x', '重構 plugin 介面，跨兩個 repo'];
+  const hashes = ['', 'a', 'foobar', '3:修正測'];
+  const r = spawnSync(python, [path.join(__dirname, 'system-one-ngram-parity.py')], { input: JSON.stringify({ texts, hashes, nmax: 3, dim: 1 << 16 }), encoding: 'utf8', env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1', PYTHONIOENCODING: 'utf-8' } });
+  assert.equal(r.status, 0, r.stderr);
+  const py = JSON.parse(r.stdout);
+  assert.deepEqual(py.hash, hashes.map(h => ngram.fnv1a32(h)));
+  texts.forEach((t, i) => {
+    const node = ngram.featurize(t, 3, 1 << 16);
+    assert.deepEqual(Object.keys(py.features[i]).map(Number).sort((a, b) => a - b), [...node.keys()].sort((a, b) => a - b), t);
+    for (const [k, v] of Object.entries(py.features[i])) assert.ok(Math.abs(v - node.get(Number(k))) < 1e-12, t);
+  });
+});
+
+test('S1-N04 the ngram transport scores in process with the Phase 0 response shape', async () => {
+  const dir = tmp();
+  try {
+    const { m, p } = manifest(dir, artifact(dir), { acceptance: { minConfidence: 0.5, minMargin: 0 } });
+    assert.equal(provider.validateManifest(m), true);
+    const request = createRequest('tier', 'please commit these changes', TIER_OPTIONS);
+    const result = provider.score(request, p);
+    assert.equal(result.status, 'scored');
+    assert.deepEqual(result.acceptance, { minConfidence: 0.5, minMargin: 0 });
+    assert.deepEqual(result.response.model, { id: 'fixture/ngram', revision: 'v1', domain: 'harness-routing-v1' });
+    assert.ok(Math.abs(result.response.scores.reduce((s, x) => s + x.probability, 0) - 1) < 1e-9);
+    const d = decide(request, result.response, result.acceptance);
+    assert.equal(d.status, 'accepted'); assert.equal(d.selectedId, 'tier1');
+    assert.deepEqual(await provider.scoreAsync(request, p), result);
+    const other = provider.score(createRequest('tier', 'unrelated words only', TIER_OPTIONS), p);
+    assert.ok(other.response.scores.every(s => Math.abs(s.probability - 0.25) < 1e-9), 'no active weights gives a uniform vector');
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('S1-N05 any artifact mismatch is provider-config and never scores', () => {
+  const request = createRequest('tier', 'commit it', TIER_OPTIONS);
+  const cases = [
+    dir => { const f = artifact(dir); const { m, p } = manifest(dir, f); fs.appendFileSync(f.bin, Buffer.alloc(4)); return p; },
+    dir => { const f = artifact(dir, { bytes: Buffer.alloc(8) }); return manifest(dir, f).p; },
+    dir => manifest(dir, artifact(dir, { catalog: ['tier1', 'tier2', 'tier3', 'other'] })).p,
+    dir => manifest(dir, artifact(dir, { sidecar: { format: 'other' } })).p,
+    dir => manifest(dir, artifact(dir, { sidecar: { extra: 1 } })).p,
+    dir => manifest(dir, artifact(dir, { dim: 1000 })).p,
+    dir => manifest(dir, artifact(dir, { nmax: 9 })).p,
+    dir => manifest(dir, artifact(dir, { sidecar: { bias: [0, 0] } })).p,
+  ];
+  for (const make of cases) {
+    const dir = tmp();
+    try { assert.deepEqual(provider.score(request, make(dir)), { status: 'unavailable', reason: 'provider-config' }); }
+    finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  }
+});
+
+test('S1-N06 manifest rules: ngram needs a .bin and no python; other transports still need python', () => {
+  const dir = tmp();
+  try {
+    const { m } = manifest(dir, artifact(dir));
+    assert.equal(provider.validateManifest(m), true);
+    assert.throws(() => provider.validateManifest({ ...m, checkpoint: m.checkpoint.replace(/\.bin$/, '.safetensors') }));
+    assert.throws(() => provider.validateManifest({ ...m, transport: 'resident' }), 'resident requires python and a .safetensors checkpoint');
+    assert.throws(() => provider.validateManifest({ ...m, transport: 'bogus' }));
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('S1-N08 the evaluator records ngram samples warm and verifies the artifact as provenance', () => {
+  const dir = tmp();
+  try {
+    const { p } = manifest(dir, artifact(dir));
+    const output = path.join(dir, 'report.json');
+    const corpus = path.join(root, 'benchmarks/fixtures/system-one-routing.json');
+    const r = spawnSync(process.execPath, [path.join(root, 'scripts/evaluate-system-one.js'), corpus, p, output], { encoding: 'utf8', cwd: root });
+    assert.equal(r.status, 0, r.stderr);
+    const report = JSON.parse(fs.readFileSync(output, 'utf8'));
+    assert.ok(report.records.every(x => x.runs.every(run => run.coldStart === false)));
+    assert.equal(report.latency.coldSamples, 0);
+    assert.equal(report.gates.warmLatency, true);
+    assert.deepEqual(report.evidence.source, { status: 'recorded', transport: 'ngram', artifactVerified: true });
+    assert.equal(report.gates.sourceProvenance, true);
+    assert.equal(report.evidence.kind, 'offline-ngram');
+    fs.appendFileSync(path.join(dir, 'tier.bin'), Buffer.alloc(4));
+    const tampered = spawnSync(process.execPath, [path.join(root, 'scripts/evaluate-system-one.js'), corpus, p, output], { encoding: 'utf8', cwd: root });
+    assert.equal(tampered.status, 0, tampered.stderr);
+    const bad = JSON.parse(fs.readFileSync(output, 'utf8'));
+    assert.equal(bad.evidence.source.artifactVerified, false);
+    assert.equal(bad.gates.sourceProvenance, false);
+    assert.equal(bad.model.coverage, 0);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('S1-N07 a real ngram training run produces an artifact the provider scores (skipped without torch)', t => {
+  if (spawnSync(python, ['-c', 'import torch'], { encoding: 'utf8' }).status !== 0) { t.skip('torch not installed'); return; }
+  const dir = tmp();
+  try {
+    const data = path.join(dir, 'data'); fs.mkdirSync(data);
+    const texts = [['commit all changes', 'tier1'], ['push and open a pr', 'tier1'], ['add a new flag with tests', 'tier3'], ['migrate every service', 'tier3'], ['fix the failing parser test', 'tier2'], ['go', null]];
+    const prompts = []; const labels = [];
+    for (let k = 0; k < 10; k++) texts.forEach(([x, g], i) => { const id = `p${k}-${i}`; prompts.push({ id, family: `f${k}`, source: 'claude', split: k < 8 ? 'train' : 'validation', text: `${x} ${k}` }); labels.push({ id, gold: g }); });
+    fs.writeFileSync(path.join(data, 'prompts.jsonl'), prompts.map(x => JSON.stringify(x)).join('\n') + '\n');
+    fs.writeFileSync(path.join(data, 'labels.jsonl'), labels.map(x => JSON.stringify(x)).join('\n') + '\n');
+    const out = path.join(dir, 'model');
+    const r = spawnSync(python, [path.join(root, 'scripts/system-one-train-ngram.py'), '--data-dir', data, '--out', out, '--dim', '4096', '--epochs', '40'], { encoding: 'utf8' });
+    assert.equal(r.status, 0, r.stdout + r.stderr);
+    const files = { bin: path.join(out, 'harness-routing-v1.bin'), json: path.join(out, 'harness-routing-v1.json') };
+    assert.equal(fs.statSync(files.bin).size, 4096 * 4 * 4);
+    assert.equal(fs.readFileSync(path.join(out, 'val-scores.jsonl'), 'utf8').trim().split('\n').length, 12);
+    const { p } = manifest(dir, files);
+    const scored = provider.score(createRequest('tier', 'commit all changes now', TIER_OPTIONS), p);
+    assert.equal(scored.status, 'scored');
+    assert.equal(decide(createRequest('tier', 'commit all changes now', TIER_OPTIONS), scored.response, { minConfidence: 0.5, minMargin: 0 }).selectedId, 'tier1');
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});

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

@@ -0,0 +1,112 @@
+'use strict';
+// Relevance-native intent contract (#233 decision): per-intent Bernoulli
+// decisions beside the untouched single-winner path.
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { createRequest, decide, decideIntents } = require('../harness-everything/scripts/system-one/contract');
+const { INTENT_OPTIONS } = require('../harness-everything/scripts/system-one/catalogs');
+const { gradeRelevance } = require('../harness-everything/scripts/system-one/evaluate');
+const { relevanceGates } = require('../harness-everything/scripts/system-one/evaluate');
+
+const IDS = INTENT_OPTIONS.map(o => o.id);
+const request = createRequest('intent', 'fix the crash and add a test', INTENT_OPTIONS);
+const responseFor = masses => ({ schemaVersion: 1, requestHash: request.requestHash, catalogHash: request.catalogHash,
+  model: { id: 'm', revision: 'v1', domain: 'harness-routing-v1' },
+  scores: IDS.map(id => ({ id, probability: masses[id] ?? 0.05 })) });
+const thresholds = (tau = 0.4) => Object.fromEntries(IDS.filter(id => id !== 'unclassified').map(id => [id, tau]));
+
+test('S1-R01 independent intents fire on their own thresholds', () => {
+  const d = decideIntents(request, responseFor({ fix: 0.9, test: 0.5 }), { thresholds: thresholds() });
+  assert.equal(d.status, 'accepted');
+  assert.equal(d.reason, 'scored');
+  assert.equal(d.selectedId, 'fix');
+  assert.equal(d.confidence, 0.9);
+  assert.equal(d.margin, 0.4);
+  assert.deepEqual(d.model, { id: 'm', revision: 'v1', domain: 'harness-routing-v1' });
+  assert.equal(d.intents.fix.fired, true);
+  assert.equal(d.intents.test.fired, true);
+  assert.equal(d.intents.docs.fired, false);
+  assert.equal(Object.keys(d.intents).length, 12);
+});
+
+test('S1-R02 silence abstains and unclassified never fires', () => {
+  const quiet = decideIntents(request, responseFor({}), { thresholds: thresholds() });
+  assert.deepEqual([quiet.status, quiet.reason, quiet.selectedId], ['abstain', 'no-intent-fired', null]);
+  assert.ok(Object.values(quiet.intents).every(i => i.fired === false));
+  const loudNull = decideIntents(request, responseFor({ unclassified: 0.95 }), { thresholds: thresholds() });
+  assert.equal(loudNull.status, 'abstain');
+});
+
+test('S1-R03 the simplex rule does not apply to relevance vectors', () => {
+  const res = responseFor({ fix: 0.9, test: 0.8, docs: 0.7 });
+  assert.ok(res.scores.reduce((s, o) => s + o.probability, 0) > 2, 'independent scores sum past one');
+  assert.equal(decideIntents(request, res, { thresholds: thresholds() }).status, 'accepted');
+  assert.equal(decide(request, res, {}).status, 'invalid-output', 'single-winner still demands the simplex');
+});
+
+test('S1-R04 malformed relevance inputs fail closed', () => {
+  const good = responseFor({ fix: 0.9 });
+  const tau = thresholds();
+  for (const mutate of [
+    r => { r.scores = r.scores.slice(0, 12); },
+    r => { r.scores[0] = { ...r.scores[0], id: 'nope' }; },
+    r => { r.scores[0] = { ...r.scores[0], probability: 1.5 }; },
+    r => { r.scores[0] = { ...r.scores[0], probability: NaN }; },
+  ]) { const bad = JSON.parse(JSON.stringify(good)); mutate(bad);
+    assert.equal(decideIntents(request, bad, { thresholds: tau }).status, 'invalid-output'); }
+  for (const policy of [{}, { thresholds: {} }, { thresholds: { ...tau, fix: 2 } },
+    { thresholds: { ...tau, unclassified: 0.5 } }, { thresholds: tau, extra: 1 }]) {
+    assert.throws(() => decideIntents(request, good, policy), JSON.stringify(policy));
+  }
+});
+
+const relevanceCase = (id, gold, secondary) => ({ id, family: `f-${id}`, split: 'holdout', language: 'en',
+  source: 'human:fixture', reviewed: true, request: createRequest('intent', `prompt ${id}`, INTENT_OPTIONS), gold, secondary });
+const byId = entries => new Map(entries.map(([id, scores]) => [id, { scores }]));
+const probs = masses => IDS.map(id => masses[id] ?? 0.0);
+
+test('S1-R05 relevance grading reports micro, macro, cardinality and abstain', () => {
+  const cases = [relevanceCase('a', 'fix', ['test']), relevanceCase('b', 'docs', []), relevanceCase('c', null, [])];
+  const runs = byId([['a', probs({ fix: 0.9, test: 0.5 })], ['b', probs({ docs: 0.8, fix: 0.5 })], ['c', probs({})]]);
+  const g = gradeRelevance(cases, runs, [...IDS.slice(0, 12), null], thresholds());
+  assert.deepEqual([g.micro.precision, g.micro.recall], [0.75, 1]);
+  assert.ok(Math.abs(g.micro.f1 - 0.857) < 0.001);
+  assert.ok(Math.abs(g.macroF1 - 0.889) < 0.001, 'fix 0.667, test 1, docs 1; unsupported intents skipped');
+  assert.deepEqual([g.cardinality.predicted, g.cardinality.gold], [4 / 3, 1]);
+  assert.deepEqual([g.abstainRate, g.exactSetMatch, g.weakPrecision], [1 / 3, 2 / 3, 0.5]);
+  assert.equal(g.perIntent.fix.support, 1);
+  assert.equal(g.perIntent.git.support, 0);
+});
+
+const goodMulti = () => ({ micro: { precision: 0.6, recall: 0.6, f1: 0.6 }, macroF1: 0.55,
+  perIntent: Object.fromEntries(['fix', 'test'].map(id => [id, { support: 20, f1: 0.5, precision: 0.5 }])),
+  cardinality: { predicted: 2.0, gold: 1.8 }, abstainRate: 0.1, exactSetMatch: 0.3, weakPrecision: 0.5 });
+const goodEvidence = () => ({ family: { gold: { rate: 0.8 }, model: { rate: 0.85 } },
+  agreement: 1, warmP95Ms: 179, structural: { unchanged: true, rollbackLive: true } });
+
+test('S1-R06 relevance gates follow the reviewed promotion contract', () => {
+  const pass = relevanceGates(goodMulti(), goodEvidence());
+  assert.ok(pass.rolloutReady === false, 'policy/live-host evidence keeps rollout red pre-production');
+  for (const k of ['microF1', 'macroF1', 'perIntentFloors', 'weakPrecision', 'cardinality',
+    'abstainRate', 'familyConsistency', 'repeatability', 'warmLatency', 'structuralControls']) {
+    assert.equal(pass[k], true, k);
+  }
+  const cases = [
+    [g => { g.micro.f1 = 0.54; }, 'microF1'],
+    [g => { g.macroF1 = 0.49; }, 'macroF1'],
+    [g => { g.perIntent.fix.f1 = 0.29; g.perIntent.fix.support = 12; }, 'perIntentFloors'],
+    [g => { g.weakPrecision = 0.29; }, 'weakPrecision'],
+    [g => { g.cardinality.predicted = 3.0; }, 'cardinality'],
+    [g => { g.abstainRate = 0.21; }, 'abstainRate'],
+  ];
+  for (const [mutate, key] of cases) {
+    const g = goodMulti(); mutate(g);
+    assert.equal(relevanceGates(g, goodEvidence())[key], false, key);
+  }
+  const ev = goodEvidence();
+  assert.equal(relevanceGates(goodMulti(), { ...ev, family: { gold: { rate: 0.9 }, model: { rate: 0.8 } } }).familyConsistency, false);
+  assert.equal(relevanceGates(goodMulti(), { ...ev, agreement: 0.99 }).repeatability, false);
+  assert.equal(relevanceGates(goodMulti(), { ...ev, warmP95Ms: 251 }).warmLatency, false);
+  assert.equal(relevanceGates(goodMulti(), { ...ev, warmP95Ms: 250 }).warmLatency, true);
+  assert.equal(relevanceGates(goodMulti(), { ...ev, structural: { unchanged: true, rollbackLive: false } }).structuralControls, false);
+});

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

@@ -328,3 +328,19 @@ test('S1-RS13 manifest acceptance thresholds are validated, carried by scored re
     assert.ok(evaluateWith(strict).every(r => r.decision.status === 'abstain' && r.decision.reason === 'low-confidence'));
   } finally { cleanup(strict); }
 });
+
+test('S1-RS14 resident transport names its adapter and stays inside the scripts dir', () => {
+  const f = fixture();
+  try {
+    assert.equal(provider.validateManifest({ ...f.manifest, adapter: 'laya_adapter.py' }), true);
+    for (const bad of ['../evil.py', '/abs/evil.py', '', 'ADAPTER.PY', 'a'.repeat(65) + '.py']) {
+      assert.throws(() => provider.validateManifest({ ...f.manifest, adapter: bad }), String(bad));
+    }
+    const [exe, prefix] = resident.defaultCommand(f.manifest);
+    assert.equal(exe, f.manifest.python);
+    assert.deepEqual(prefix, [path.join(__dirname, '..', 'harness-everything', 'scripts', 'system-one', 'cua_adapter.py'), '--serve']);
+    const [, layaPrefix] = resident.defaultCommand({ ...f.manifest, adapter: 'laya_adapter.py' });
+    assert.ok(layaPrefix[0].endsWith(path.join('system-one', 'laya_adapter.py')));
+    assert.throws(() => resident.defaultCommand({ ...f.manifest, adapter: '../evil.py' }));
+  } finally { cleanup(f); }
+});

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

@@ -41,6 +41,18 @@ test('S1-T03 calibration maximizes coverage subject to accepted precision on val
   assert.deepEqual(calibrate(rows, { minPrecision: 0.98 }), c, 'deterministic');
 });
 
+test('S1-T06 the default calibration target is the owner advisory 85%', () => {
+  const rows = [
+    ...Array.from({ length: 86 }, () => row('tier1', [0.9, 0.05, 0.03, 0.02])),
+    ...Array.from({ length: 14 }, () => row('tier2', [0.9, 0.05, 0.03, 0.02])),
+  ];
+  const c = calibrate(rows);
+  assert.equal(c.minPrecision, 0.85);
+  assert.equal(c.feasible, true);
+  assert.equal(c.coverage, 1);
+  assert.equal(calibrate(rows, { minPrecision: 0.9 }).feasible, false);
+});
+
 test('S1-T04 calibration CLI reads validation scores and writes thresholds', () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-cal-'));
   try {

package/ci/system-one-laya-calibrate-test.py

@@ -0,0 +1,65 @@
+"""Stdlib tests for the Laya zero-shot calibration (#255 Phase 3 prep).
+
+No model dependency. Run with:
+    python3 ci/system-one-laya-calibrate-test.py
+"""
+import importlib.util
+import sys
+import unittest
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # never leave __pycache__ in the source tree that packaging copies
+path = Path(__file__).resolve().parents[1] / 'scripts/system-one-calibrate-laya.py'
+spec = importlib.util.spec_from_file_location('laya_calibrate', path)
+laya_calibrate = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(laya_calibrate)
+
+
+class IsotonicTests(unittest.TestCase):
+    def test_exact_staircase_on_separable_data(self):
+        knots = laya_calibrate.isotonic_fit([0.1, 0.2, 0.8, 0.9], [0.0, 0.0, 1.0, 1.0])
+        self.assertEqual([laya_calibrate.isotonic_predict(knots, x) for x in (0.1, 0.2, 0.8, 0.9)],
+                         [0.0, 0.0, 1.0, 1.0])
+
+    def test_predictions_are_monotone(self):
+        xs = [0.05, 0.4, 0.35, 0.7, 0.6, 0.9, 0.2, 0.5]
+        ys = [0.0, 1.0, 0.0, 0.6, 1.0, 0.8, 0.2, 0.4]
+        knots = laya_calibrate.isotonic_fit(xs, ys)
+        grid = [i / 20 for i in range(21)]
+        preds = [laya_calibrate.isotonic_predict(knots, x) for x in grid]
+        self.assertTrue(all(b >= a for a, b in zip(preds, preds[1:])), 'monotone non-decreasing')
+
+    def test_duplicate_x_averages_y(self):
+        knots = laya_calibrate.isotonic_fit([0.5, 0.5, 0.5], [0.0, 0.6, 0.3])
+        self.assertAlmostEqual(laya_calibrate.isotonic_predict(knots, 0.5), 0.3)
+
+    def test_clamps_outside_range(self):
+        knots = laya_calibrate.isotonic_fit([0.2, 0.8], [0.3, 0.9])
+        self.assertEqual(laya_calibrate.isotonic_predict(knots, 0.0), 0.3)
+        self.assertEqual(laya_calibrate.isotonic_predict(knots, 1.0), 0.9)
+
+    def test_knots_are_json_serializable(self):
+        import json
+        knots = laya_calibrate.isotonic_fit([0.1, 0.9, 0.4], [0.2, 0.8, 0.5])
+        self.assertEqual(json.loads(json.dumps(knots)), knots)
+
+
+class DeriveCalibratedTests(unittest.TestCase):
+    def scores(self, **over):
+        base = {i: 0.0 for i in
+                ['explain', 'discuss', 'git', 'fix', 'edit', 'feature', 'refactor',
+                 'review', 'test', 'docs', 'plan', 'investigate']}
+        base.update(over)
+        return base
+
+    def test_null_cutoff_abstains_low_max(self):
+        out = laya_calibrate.derive_calibrated(self.scores(fix=0.5, test=0.3), {}, 0.6)
+        self.assertIsNone(out['gold'])
+
+    def test_identity_mapping_keeps_bands(self):
+        out = laya_calibrate.derive_calibrated(self.scores(fix=0.9, test=0.5), {}, 0.2)
+        self.assertEqual((out['gold'], out['secondary']), ('fix', ['test']))
+
+
+if __name__ == '__main__':
+    unittest.main()

package/ci/system-one-laya-export-test.py

@@ -0,0 +1,155 @@
+"""Stdlib contract tests for the Laya soft-target exporter (#255 Phase 3).
+
+The exporter converts teacher relevance scores to upstream RLCD training
+items without loading any model: sequence building is injected. Run with:
+    python3 ci/system-one-laya-export-test.py
+"""
+import importlib.util
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # never leave __pycache__ in the source tree that packaging copies
+path = Path(__file__).resolve().parents[1] / 'scripts/system-one-export-laya.py'
+spec = importlib.util.spec_from_file_location('laya_exporter', path)
+laya_exporter = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(laya_exporter)
+
+INTENTS = ['explain', 'discuss', 'git', 'fix', 'edit', 'feature', 'refactor',
+           'review', 'test', 'docs', 'plan', 'investigate']
+
+
+def fake_builder(state, instructions, probs):
+    """Deterministic stub: token ids derive from the text, markers fixed."""
+    ids = [len(state) % 251 + 1, len(instructions) % 251 + 1, 7]
+    return {'ids': ids, 'markers': [0, 1], 'target': [probs['false'], probs['true']]}
+
+
+class ItemTests(unittest.TestCase):
+    def test_noul_target_is_false_true_pair(self):
+        item = laya_exporter.build_item('fix it', 'repair?', {'true': 0.8, 'false': 0.2}, fake_builder)
+        self.assertEqual(item['qtype'], 2, 'noul qtype follows laya.common.QTYPES')
+        self.assertEqual(item['target'], [0.2, 0.8])
+        self.assertEqual(item['label'], 1)
+
+    def test_relevance_p_maps_to_true_p(self):
+        item = laya_exporter.build_item('x', 'y', {'true': 0.0, 'false': 1.0}, fake_builder)
+        self.assertEqual((item['target'], item['label']), ([1.0, 0.0], 0))
+
+    def test_target_distribution_is_conserved(self):
+        for p in (0.0, 0.25, 0.6, 1.0):
+            item = laya_exporter.build_item('x', 'y', {'true': p, 'false': 1 - p}, fake_builder)
+            self.assertAlmostEqual(sum(item['target']), 1.0, msg=f'p={p}')
+
+    def test_bad_probabilities_fail(self):
+        with self.assertRaisesRegex(ValueError, 'probabilities'):
+            laya_exporter.build_item('x', 'y', {'true': 0.8, 'false': 0.8}, fake_builder)
+
+
+class ExportTests(unittest.TestCase):
+    def write_data(self, data, prompts, teacher):
+        (data / 'prompts.jsonl').write_text(
+            '\n'.join(json.dumps(p) for p in prompts) + '\n', encoding='utf-8')
+        (data / 'labels-intent-scores.jsonl').write_text(
+            '\n'.join(json.dumps(t) for t in teacher) + '\n', encoding='utf-8')
+
+    def teacher_row(self, id, scores):
+        return {'id': id, 'gold': 'fix', 'secondary': [], 'scores': scores}
+
+    def test_exports_train_only_in_id_order(self):
+        prompts = [{'id': 'b', 'split': 'train', 'text': 'commit'},
+                   {'id': 'a', 'split': 'train', 'text': 'fix it'},
+                   {'id': 'c', 'split': 'validation', 'text': 'skip me'}]
+        scores = {i: (0.9 if i == 'fix' else 0.0) for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores), self.teacher_row('b', scores)])
+            out = Path(d) / 'train_items.json'
+            manifest = Path(d) / 'manifest.json'
+            summary = laya_exporter.export(data, 'train', out, manifest, fake_builder, seed=0)
+            self.assertEqual(summary['items'], 24, '2 prompts x 12 intents')
+            rows = [json.loads(line) for line in out.read_text(encoding='utf-8').strip().split('\n')]
+            self.assertEqual([r['promptId'] for r in rows[::12]], ['a', 'b'], 'deterministic id order')
+            self.assertTrue(all(set(r) >= {'promptId', 'intent', 'ids', 'markers', 'qtype', 'target', 'label'} for r in rows))
+            self.assertEqual(summary['manifest']['seed'], 0)
+
+    def test_seed_controls_order(self):
+        prompts = [{'id': c, 'split': 'train', 'text': c * 20} for c in 'abcd']
+        scores = {i: 0.1 for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row(p['id'], scores) for p in prompts])
+            outs = []
+            for seed in (11, 11, 12):
+                out = Path(d) / f'o{seed}.json'
+                laya_exporter.export(data, 'train', out, Path(d) / f'm{seed}.json', fake_builder, seed=seed)
+                outs.append([json.loads(line)['promptId'] for line in out.read_text(encoding='utf-8').strip().split('\n')][::12])
+        self.assertEqual(outs[0], outs[1], 'same seed replays the order')
+        self.assertNotEqual(outs[0], outs[2], 'a different seed shuffles')
+
+    def test_overlap_with_forbidden_ids_fails(self):
+        prompts = [{'id': 'a', 'split': 'train', 'text': 'fix it'}]
+        scores = {i: 0.1 for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores)])
+            forbid = Path(d) / 'forbid.json'
+            forbid.write_text(json.dumps(['a']), encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'overlap'):
+                laya_exporter.export(data, 'train', Path(d) / 'o.json', Path(d) / 'm.json',
+                                     fake_builder, seed=7, forbid_path=forbid)
+
+    def test_missing_teacher_row_is_skipped_and_counted(self):
+        prompts = [{'id': 'a', 'split': 'train', 'text': 'fix it'},
+                   {'id': 'b', 'split': 'train', 'text': 'no teacher'}]
+        scores = {i: 0.1 for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores)])
+            out = Path(d) / 'o.json'
+            summary = laya_exporter.export(data, 'train', out, Path(d) / 'm.json', fake_builder, seed=7)
+        self.assertEqual((summary['items'], summary['skippedNoTeacher']), (12, 1))
+
+    def test_oversample_repeats_only_selected_positive_intent(self):
+        prompts = [{'id': 'a', 'split': 'train', 'text': 'restructure'},
+                   {'id': 'b', 'split': 'train', 'text': 'fix it'}]
+        scores_a = {i: (0.9 if i == 'refactor' else 0.0) for i in INTENTS}
+        scores_b = {i: (0.9 if i == 'fix' else 0.0) for i in INTENTS}
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, prompts, [self.teacher_row('a', scores_a), self.teacher_row('b', scores_b)])
+            out = Path(d) / 'o.json'
+            summary = laya_exporter.export(data, 'train', out, Path(d) / 'm.json', fake_builder,
+                                           seed=0, oversample={'refactor': 3})
+            rows = [json.loads(line) for line in out.read_text(encoding='utf-8').strip().split('\n')]
+            keys = [(r['promptId'], r['intent']) for r in rows]
+            self.assertEqual(summary['items'], 26, '24 base items plus two refactor repeats')
+            self.assertEqual(keys.count(('a', 'refactor')), 3)
+            self.assertTrue(all(keys.count(('a', intent)) == 1 for intent in INTENTS if intent != 'refactor'),
+                            'sibling intents must not be reweighted')
+            self.assertTrue(all(keys.count(('b', intent)) == 1 for intent in INTENTS),
+                            'non-positive prompt must remain at base multiplicity')
+            self.assertEqual(summary['manifest']['oversample'], {'refactor': 3})
+
+    def test_bad_oversample_spec_fails(self):
+        with tempfile.TemporaryDirectory() as d:
+            data = Path(d) / 'data'
+            data.mkdir()
+            self.write_data(data, [], [])
+            with self.assertRaisesRegex(ValueError, 'oversample'):
+                laya_exporter.export(data, 'train', Path(d) / 'o.json', Path(d) / 'm.json',
+                                     fake_builder, oversample={'nope': 2})
+            with self.assertRaisesRegex(ValueError, 'oversample'):
+                laya_exporter.export(data, 'train', Path(d) / 'o.json', Path(d) / 'm.json',
+                                     fake_builder, oversample={'fix': 1})
+
+
+if __name__ == '__main__':
+    unittest.main()