harness-everything 0.20.7 → 0.21.0

package/ci/fixtures/system-one-provider.cjs

@@ -0,0 +1,13 @@
+'use strict';
+// Deliberately synthetic transport fixture, never model-quality evidence.
+const mode = process.argv[2];
+if (mode === 'timeout') setInterval(() => {}, 1000);
+else if (mode === 'overflow') process.stdout.write('x'.repeat(2 * 1024 * 1024));
+else if (mode === 'exit') process.exit(3);
+else if (mode === 'invalid') console.log('not-json');
+else { let input = ''; process.stdin.on('data', c => { input += c; }); process.stdin.on('end', () => {
+  const req = JSON.parse(input);
+  console.log(JSON.stringify({ schemaVersion: 1, requestHash: req.requestHash, catalogHash: req.catalogHash,
+    model: { id: 'fixture', revision: 'fixture-v1', domain: mode === 'forms' ? 'forms-v1' : 'harness-routing-v1' },
+    scores: req.options.map((o, i) => ({ id: o.id, probability: i === 0 ? 1 : 0 })) }));
+}); }

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

@@ -0,0 +1,48 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { createRequest, validateRequest, decide } = require('../harness-everything/scripts/system-one/contract');
+const options = [{ id: 'tier1', text: 'Bounded edit' }, { id: 'tier3', text: 'Architecture' }];
+const request = () => createRequest('tier', '修正 typo', options);
+function response(req, p = [0.95, 0.05]) {
+  return { schemaVersion: 1, requestHash: req.requestHash, catalogHash: req.catalogHash,
+    model: { id: 'test', revision: 'test-v1', domain: 'harness-routing-v1' },
+    scores: req.options.map((o, i) => ({ id: o.id, probability: p[i] })) };
+}
+test('S1-C01 complete response, no mutation and repeatability', () => {
+  const req = request(); const res = response(req); const before = JSON.stringify({ req, res });
+  assert.deepEqual(decide(req, res), { status: 'accepted', reason: 'scored', selectedId: 'tier1', confidence: 0.95, margin: 0.8999999999999999, model: res.model });
+  assert.deepEqual(decide(req, res), decide(req, res));
+  assert.equal(JSON.stringify({ req, res }), before);
+  assert.deepEqual(req, request());
+  assert.equal(validateRequest(req), true);
+  assert.notEqual(req.requestHash, createRequest('tier', 'other', options).requestHash);
+  assert.notEqual(req.catalogHash, createRequest('tier', 'other', [...options].reverse()).catalogHash);
+});
+test('S1-C02 rejected input partitions and byte boundaries', () => {
+  for (const context of ['', ' ', null, 1, {}, 'x'.repeat(65537)]) assert.throws(() => createRequest('tier', context, options), { code: 'invalid-request' });
+  for (const task of ['', null, 'A', 'a'.repeat(81)]) assert.throws(() => createRequest(task, 'x', options));
+  for (const opts of [null, [], [options[0]], [options[0], options[0]], [{ id: 'x', text: '' }, options[1]], [{ ...options[0], extra: true }, options[1]], [{ id: 1, text: 'x' }, options[1]], [{ id: 'x', text: '中'.repeat(1366) }, options[1]], Array.from({ length: 257 }, (_, i) => ({ id: 'a' + i, text: 'x' }))]) assert.throws(() => createRequest('tier', 'x', opts));
+  const max = createRequest('a'.repeat(80), 'x'.repeat(65536), Array.from({ length: 256 }, (_, i) => ({ id: 'a' + i, text: 'x'.repeat(4096) })));
+  assert.equal(validateRequest(max), true);
+  for (const mutate of [r => { r.extra = 1; }, r => { delete r.context; }, r => { r.schemaVersion = 2; }, r => { r.options.reverse(); }, r => { r.context = 'replay'; }]) {
+    const r = request(); mutate(r); assert.throws(() => validateRequest(r));
+  }
+});
+test('S1-C03 complete output validation and no raw-data leakage', () => {
+  const req = request();
+  for (const mutate of [r => { r.schemaVersion = 2; }, r => { r.requestHash = 'stale'; }, r => { r.catalogHash = 'stale'; }, r => { r.scores.pop(); }, r => { r.scores.push(r.scores[0]); }, r => { r.scores.reverse(); }, r => { r.scores[1].id = r.scores[0].id; }, r => { r.scores[0].probability = NaN; }, r => { r.scores[0].probability = Infinity; }, r => { r.scores[0].probability = -1; }, r => { r.scores[0].probability = 1.1; }, r => { r.scores[0].probability = '0.95'; }, r => { r.scores[0].probability = 0.8; }, r => { r.scores[0].extra = 'secret'; }, r => { r.model.extra = 'secret'; }, r => { r.model.revision = ''; }, r => { delete r.model; }, r => { r.extra = 'secret'; }]) {
+    const res = response(req); mutate(res);
+    assert.deepEqual(decide(req, res), { status: 'invalid-output', reason: 'invalid-response', selectedId: null, confidence: null, margin: null, model: null });
+  }
+  for (const value of [null, [], 'invalid']) assert.equal(decide(req, value).status, 'invalid-output');
+});
+test('S1-C04 abstention and policy boundaries', () => {
+  const req = request(); const res = response(req);
+  res.model.domain = 'forms-v1'; assert.equal(decide(req, res).reason, 'domain-mismatch');
+  assert.equal(decide(req, response(req, [0.5, 0.5]), { minConfidence: 0, minMargin: 0 }).reason, 'tie');
+  assert.equal(decide(req, response(req, [0.8, 0.2])).reason, 'low-confidence');
+  assert.equal(decide(req, response(req, [0.6, 0.4]), { minConfidence: 0.5, minMargin: 0.3 }).reason, 'low-margin');
+  assert.equal(decide(req, response(req, [1, 0]), { minConfidence: 1, minMargin: 1 }).status, 'accepted');
+  for (const policy of [null, { minConfidence: NaN }, { minMargin: -1 }, { minConfidence: 2 }, { extra: 1 }, { domain: '' }]) assert.throws(() => decide(req, response(req), policy), { code: 'invalid-policy' });
+});

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

@@ -0,0 +1,87 @@
+'use strict';
+const { test } = require('node:test');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const assert = require('node:assert/strict');
+const { createRequest } = require('../harness-everything/scripts/system-one/contract');
+const { TIER_OPTIONS } = require('../harness-everything/scripts/system-one/router');
+const { validateCorpus, evaluate } = require('../harness-everything/scripts/system-one/evaluate');
+const make = () => ({ schemaVersion: 1, cases: [
+  { id: 'a', family: 'typo', split: 'holdout', language: 'en', source: 'human:fixture', reviewed: false, request: createRequest('tier', 'fix typo', TIER_OPTIONS), gold: 'tier1' },
+  { id: 'b', family: 'unclear', split: 'holdout', language: 'zh-TW', source: 'human:fixture', reviewed: false, request: createRequest('tier', '看看這個', TIER_OPTIONS), gold: null },
+] });
+const decision = id => ({ status: id ? 'accepted' : 'abstain', reason: id ? 'scored' : 'unclassified', selectedId: id, confidence: 1, margin: 1, model: { id: 'fixture', revision: 'v1', domain: 'harness-routing-v1' } });
+const oneHot = id => TIER_OPTIONS.map(o => (o.id === (id || 'unclassified') ? 1 : 0));
+function records() { return make().cases.map(c => ({ id: c.id, baseline: 'tier2', runs: [0, 1].map(() => ({ decision: decision(c.gold), scores: oneHot(c.gold), latencyMs: 20, coldStart: true })) })); }
+test('S1-E01 exact paired metrics, no promotion from fixtures or cold timing', () => {
+  const result = evaluate(make(), records());
+  assert.equal(result.model.accuracy, 1); assert.equal(result.model.coverage, 0.5);
+  assert.equal(result.model.acceptedPrecision, 1); assert.equal(result.model.acceptedErrorRate, 0);
+  assert.equal(result.model.macroF1, 0.5); assert.equal(result.baseline.accuracy, 0);
+  assert.equal(result.agreement, 1); assert.equal(result.latency.coldP95Ms, 20); assert.equal(result.latency.warmP95Ms, null);
+  assert.equal(result.rolloutReady, false); assert.equal(result.gates.reviewedHoldout, false);
+  assert.equal(result.gates.policyEvidence, false); assert.equal(result.gates.liveHostEvidence, false);
+  assert.deepEqual(evaluate(make(), records()), evaluate(make(), records()));
+});
+test('S1-E02 corpus completeness, family leakage and no duplicated prompts', () => {
+  assert.equal(validateCorpus(make()), true);
+  for (const mutate of [c => { c.schemaVersion = 2; }, c => { c.extra = true; }, c => { c.cases = []; }, c => { c.cases[1].id = 'a'; }, c => { c.cases[1].family = 'typo'; c.cases[1].split = 'train'; }, c => { c.cases[1].request = c.cases[0].request; }, c => { c.cases[0].gold = 'unknown'; }, c => { c.cases[0].language = 'unknown'; }, c => { c.cases[0].reviewed = 'yes'; }, c => { c.cases[0].source = ''; }, c => { c.cases[0].request = createRequest('tier', 'x', [{ id: 'x', text: 'x' }, { id: 'y', text: 'y' }]); }, c => { delete c.cases[0].family; }, c => { c.cases[0].extra = 1; }]) { const c = make(); mutate(c); assert.throws(() => validateCorpus(c)); }
+});
+test('S1-E03 missing/extra/invalid predictions cannot silently improve scores', () => {
+  for (const mutate of [r => r.pop(), r => r.push(r[0]), r => { r[0].id = 'unknown'; }, r => { r[0].runs.pop(); }, r => { r[0].runs[0].decision.selectedId = 'unknown'; }, r => { r[0].runs[0].latencyMs = NaN; }, r => { r[0].runs[0].latencyMs = -1; }, r => { r[0].runs[0].coldStart = 'false'; }, r => { r[0].runs[0].decision.status = 'abstain'; }, r => { r[0].baseline = 'unknown'; }, r => { r[0].runs[0].decision.model.revision = 'v2'; }]) { const r = records(); mutate(r); assert.throws(() => evaluate(make(), r)); }
+  for (const mutate of [r => { delete r[0].runs[0].scores; }, r => { r[0].runs[0].scores = [1, 0, 0]; }, r => { r[0].runs[0].scores = [0.5, 0.5, 0, 0]; }, r => { r[0].runs[0].scores = [1, 0, 0, NaN]; }, r => { r[0].runs[0].scores = null; }, r => { r[0].runs[0].decision = { status: 'unavailable', reason: 'provider-timeout' }; }]) { const r = records(); mutate(r); assert.throws(() => evaluate(make(), r)); }
+  const r = records(); r[0].runs[1].decision = decision('tier3'); r[0].runs[1].scores = oneHot('tier3');
+  assert.equal(evaluate(make(), r).agreement, 0.5);
+});
+test('S1-E06 repeatability compares the full score vector, not only top-2 summaries', () => {
+  const r = records();
+  const accepted = { status: 'accepted', reason: 'scored', selectedId: 'tier1', confidence: 0.9, margin: 0.85, model: { id: 'fixture', revision: 'v1', domain: 'harness-routing-v1' } };
+  r[0].runs[0] = { decision: { ...accepted }, scores: [0.9, 0.05, 0.03, 0.02], latencyMs: 20, coldStart: true };
+  r[0].runs[1] = { decision: { ...accepted }, scores: [0.9, 0.05, 0.02, 0.03], latencyMs: 20, coldStart: true };
+  const report = evaluate(make(), r);
+  assert.equal(report.agreement, 0.5); assert.equal(report.gates.repeatability, false);
+  r[0].runs[1].scores = [0.9, 0.05, 0.03, 0.02];
+  assert.equal(evaluate(make(), r).agreement, 1);
+  r.forEach(x => x.runs.forEach(v => { v.decision = { status: 'unavailable', reason: 'provider-config' }; v.scores = null; }));
+  assert.equal(evaluate(make(), r).agreement, 1);
+});
+test('S1-E04 zero coverage and wrong accepted predictions fail quality gates', () => {
+  const r = records(); r.forEach(x => x.runs.forEach(v => { v.decision = { status: 'unavailable', reason: 'provider-config' }; v.scores = null; }));
+  const report = evaluate(make(), r);
+  assert.equal(report.model.coverage, 0); assert.equal(report.model.acceptedPrecision, null); assert.equal(report.rolloutReady, false);
+  const wrong = records(); wrong.forEach(x => x.runs.forEach(v => { v.decision = decision('tier3'); v.scores = oneHot('tier3'); }));
+  assert.equal(evaluate(make(), wrong).model.acceptedErrorRate, 1);
+});
+test('S1-E05 real evaluation CLI repeats with only documented timing volatility', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-eval-'));
+  try {
+    const root = path.resolve(__dirname, '..');
+    const input = path.join(dir, 'corpus.json'); fs.writeFileSync(input, JSON.stringify(make()));
+    const run = () => {
+      const output = path.join(dir, 'report.json');
+      const child = spawnSync(process.execPath, [path.join(root, 'scripts/evaluate-system-one.js'), input, path.join(dir, 'missing.json'), output], { encoding: 'utf8', cwd: root });
+      assert.equal(child.status, 0, child.stderr);
+      const report = JSON.parse(fs.readFileSync(output, 'utf8'));
+      assert.equal(report.model.coverage, 0); assert.equal(report.rolloutReady, false);
+      assert.equal(report.records[0].runs[0].decision.reason, 'provider-config');
+      assert.equal(report.records[0].runs[0].scores, null);
+      assert.deepEqual(report.evidence.source, { status: 'unavailable', reason: 'provider-config' });
+      assert.equal(report.evidence.environment.python, null);
+      assert.equal(report.gates.sourceProvenance, false);
+      report.records.forEach(r => r.runs.forEach(v => { v.latencyMs = 0; }));
+      report.latency.coldP95Ms = 0;
+      return { status: child.status, stdout: child.stdout, stderr: child.stderr, report, files: fs.readdirSync(dir).sort() };
+    };
+    assert.deepEqual(run(), run());
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+test('S1-E07 source provenance gate requires the pinned cua_s1 revision', () => {
+  const recorded = status => ({ status: 'recorded', provenance: { python: { implementation: 'CPython', version: '3.12.4' }, cuaS1: { distribution: 'cua-s1', version: '0.1.0', sourceRevision: null, pinnedRevision: 'b'.repeat(40), sourceRevisionStatus: status }, torch: null } });
+  assert.equal(evaluate(make(), records()).gates.sourceProvenance, false);
+  assert.equal(evaluate(make(), records(), { status: 'unavailable', reason: 'provider-exit' }).gates.sourceProvenance, false);
+  for (const status of ['unavailable', 'mismatch']) assert.equal(evaluate(make(), records(), recorded(status)).gates.sourceProvenance, false);
+  assert.equal(evaluate(make(), records(), recorded('pinned')).gates.sourceProvenance, true);
+  assert.equal(evaluate(make(), records(), recorded('pinned')).rolloutReady, false);
+});

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

@@ -0,0 +1,95 @@
+'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 install = require('../harness-everything/scripts/system-one/install');
+const { validateManifest, PINNED_CUA_S1_REVISION } = require('../harness-everything/scripts/system-one/provider');
+const script = path.join(__dirname, '../harness-everything/scripts/system-one/install.js');
+const sha = buf => createHash('sha256').update(buf).digest('hex');
+
+test('S1-I01 pins stay consistent with the provider contract', () => {
+  const { PINS } = install;
+  assert.equal(PINS.cuaS1Revision, PINNED_CUA_S1_REVISION);
+  assert.ok(PINS.cuaS1Spec.includes(`@${PINNED_CUA_S1_REVISION}#subdirectory=libs/cua-s1/python`));
+  assert.match(PINS.modelRevision, /^[0-9a-f]{40}$/);
+  assert.equal(PINS.modelId, 'cua-ai/cua-s1-forms'); assert.equal(PINS.domain, 'forms-v1');
+  for (const file of Object.values(PINS.files)) {
+    assert.match(file.sha256, /^[0-9a-f]{64}$/); assert.ok(Number.isInteger(file.size) && file.size > 0);
+    assert.equal(install.fileUrl(file.name), `https://huggingface.co/cua-ai/cua-s1-forms/resolve/${PINS.modelRevision}/${file.name}`);
+  }
+  assert.equal(path.basename(PINS.files.config.name, '.json'), path.basename(PINS.files.weights.name, '.safetensors'));
+  const dir = path.resolve(os.tmpdir(), 'system-one');
+  const manifest = install.buildManifest(dir, path.join(dir, 'venv', 'python'));
+  assert.equal(validateManifest(manifest), true);
+  assert.equal(manifest.checkpoint, path.join(dir, 'checkpoints', PINS.modelRevision, PINS.files.weights.name));
+  assert.equal(manifest.weightsSha256, PINS.files.weights.sha256); assert.equal(manifest.configSha256, PINS.files.config.sha256);
+  assert.equal(manifest.revision, PINS.modelRevision); assert.equal(manifest.timeoutMs, 10000);
+});
+
+test('S1-I02 interpreter selection accepts only the upstream-supported Python range', () => {
+  for (const v of ['3.11.0', '3.12.4', '3.13.6']) assert.equal(install.supportedPython(v), true);
+  for (const v of ['3.10.9', '3.14.0', '2.7.18', '3.13', '', 'x', null]) assert.equal(install.supportedPython(v), false);
+  const win = install.pythonCandidates('win32');
+  assert.deepEqual(win[0], ['py', '-3.13']);
+  assert.ok(win.every(c => !c.includes('-3.14')));
+  assert.deepEqual(install.pythonCandidates('linux')[0], ['python3.13']);
+  assert.equal(install.venvPython('/x', 'win32'), path.join('/x', 'venv', 'Scripts', 'python.exe'));
+  assert.equal(install.venvPython('/x', 'linux'), path.join('/x', 'venv', 'bin', 'python'));
+});
+
+test('S1-I03 argument parsing is explicit and rejects ambiguous input', () => {
+  const home = install.parseArgs([]);
+  assert.equal(home.dir, path.join(os.homedir(), '.agents', 'harness-everything', 'system-one'));
+  assert.equal(home.python, null); assert.equal(home.dryRun, false);
+  const dir = path.resolve(os.tmpdir(), 's1');
+  assert.deepEqual(install.parseArgs(['--dir', dir, '--python', 'py', '--dry-run']), { dir, python: 'py', dryRun: true });
+  for (const argv of [['--dir', 'relative'], ['--dir'], ['--python'], ['--unknown'], ['extra'], ['--dry-run', '--dry-run']]) {
+    assert.throws(() => install.parseArgs(argv), { message: 'usage' });
+  }
+});
+
+test('S1-I04 downloads are verified before an atomic write; a valid file is reused', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-install-'));
+  try {
+    const good = Buffer.from('pinned-bytes\r\n');
+    const spec = { name: 'x.json', sha256: sha(good), size: good.length };
+    const dest = path.join(dir, 'x.json');
+    let calls = 0;
+    const fetcher = bytes => async () => { calls++; return bytes; };
+    for (const bad of [Buffer.from('tampered-bytes'), Buffer.concat([good, Buffer.from('x')]), Buffer.alloc(0)]) {
+      await assert.rejects(install.ensureFile('https://example.invalid/x', dest, spec, fetcher(bad)), /download-verification/);
+      assert.equal(fs.existsSync(dest), false);
+      assert.deepEqual(fs.readdirSync(dir), []);
+    }
+    assert.equal(await install.ensureFile('https://example.invalid/x', dest, spec, fetcher(good)), 'downloaded');
+    assert.ok(fs.readFileSync(dest).equals(good));
+    const before = calls;
+    assert.equal(await install.ensureFile('https://example.invalid/x', dest, spec, fetcher(good)), 'verified-existing');
+    assert.equal(calls, before);
+    fs.writeFileSync(dest, 'corrupted');
+    assert.equal(await install.ensureFile('https://example.invalid/x', dest, spec, fetcher(good)), 'downloaded');
+    assert.ok(fs.readFileSync(dest).equals(good));
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('S1-I05 dry run prints the pinned plan and changes nothing, repeatably', () => {
+  const dir = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-dry-')), 'target');
+  try {
+    const run = () => spawnSync(process.execPath, [script, '--dir', dir, '--python', 'python-not-used', '--dry-run'], { encoding: 'utf8' });
+    const one = run(); const two = run();
+    assert.equal(one.status, 0, one.stderr); assert.equal(one.stdout, two.stdout);
+    const plan = JSON.parse(one.stdout);
+    assert.equal(plan.dryRun, true); assert.equal(plan.dir, dir);
+    assert.equal(plan.manifest, path.join(dir, 'manifest.json'));
+    assert.ok(plan.steps.some(s => s.includes(install.PINS.cuaS1Spec)));
+    assert.ok(plan.steps.some(s => s.includes(install.PINS.torchIndex)));
+    assert.deepEqual(plan.env, { HARNESS_SYSTEM_ONE_MODE: 'shadow', HARNESS_SYSTEM_ONE_CONFIG: path.join(dir, 'manifest.json') });
+    assert.equal(fs.existsSync(dir), false);
+    const bad = spawnSync(process.execPath, [script, '--dir', 'relative'], { encoding: 'utf8' });
+    assert.equal(bad.status, 2); assert.match(bad.stderr, /Usage/);
+  } finally { fs.rmSync(path.dirname(dir), { recursive: true, force: true }); }
+});

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

@@ -0,0 +1,63 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const fs = require('node:fs');
+const os = require('node:os');
+const { spawnSync } = require('node:child_process');
+const { createRequest, decide } = require('../harness-everything/scripts/system-one/contract');
+const { score, runProvider, validateManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION } = require('../harness-everything/scripts/system-one/provider');
+const fixture = path.join(__dirname, 'fixtures/system-one-provider.cjs');
+const request = createRequest('tier', '修正 typo; $(never execute)', [{ id: 'tier1', text: 'Small' }, { id: 'tier3', text: 'Large' }]);
+const manifest = () => ({ schemaVersion: 1, python: 'python3', checkpoint: path.resolve('model.safetensors'), weightsSha256: 'a'.repeat(64), configSha256: 'b'.repeat(64), modelId: 'test', revision: 'v1', domain: 'harness-routing-v1' });
+test('S1-P01 real IPC exact input/output repeated in clean child processes', () => {
+  const one = runProvider(request, process.execPath, [fixture, 'ok']);
+  const two = runProvider(request, process.execPath, [fixture, 'ok']);
+  assert.deepEqual(one, two); assert.equal(one.status, 'scored');
+  assert.equal(decide(request, one.response).selectedId, 'tier1');
+  assert.deepEqual(Object.keys(one).sort(), ['response', 'status']);
+});
+test('S1-P02 unavailable, timeout, output bounds, malformed output and repeatability', () => {
+  for (const [mode, reason] of [['timeout', 'provider-timeout'], ['overflow', 'provider-output-limit'], ['exit', 'provider-exit'], ['invalid', 'provider-json']]) {
+    // Only the timeout case uses a short budget; child startup under parallel CI load can exceed 300ms.
+    const call = () => runProvider(request, process.execPath, [fixture, mode], mode === 'timeout' ? 300 : 10000);
+    assert.deepEqual(call(), { status: 'unavailable', reason }); assert.deepEqual(call(), call());
+  }
+  assert.deepEqual(runProvider(request, path.join(os.tmpdir(), 'absent-system-one-python'), []), { status: 'unavailable', reason: 'provider-unavailable' });
+  assert.deepEqual(score(request, '/missing/system-one-manifest.json'), { status: 'unavailable', reason: 'provider-config' });
+});
+test('S1-P03 trusted manifest validation', () => {
+  assert.equal(validateManifest(manifest()), true);
+  assert.equal(validateManifest({ ...manifest(), timeoutMs: 1 }), true);
+  assert.equal(validateManifest({ ...manifest(), timeoutMs: 10000 }), true);
+  for (const change of [{ schemaVersion: 2 }, { python: '' }, { checkpoint: 'relative.safetensors' }, { checkpoint: path.resolve('model.pt') }, { weightsSha256: 'abc' }, { configSha256: null }, { modelId: '' }, { revision: null }, { domain: '' }, { timeoutMs: 0 }, { timeoutMs: 10001 }, { timeoutMs: '100' }, { unexpected: true }, { modelId: 'cua-ai/cua-s1-forms' }]) assert.throws(() => validateManifest({ ...manifest(), ...change }));
+  for (const key of Object.keys(manifest())) { const m = manifest(); delete m[key]; assert.throws(() => validateManifest(m)); }
+});
+test('S1-P04 Python artifact validation and byte-limit rejection without ML dependency', () => {
+  const python = process.env.PYTHON || (process.platform === 'win32' ? 'python' : 'python3');
+  const result = spawnSync(python, [path.join(__dirname, 'system-one-adapter-test.py')], { encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr || String(result.error));
+  assert.match(result.stderr, /OK/);
+});
+test('S1-P05 runtime/source provenance is recorded, and a missing or mismatched revision stays visible', () => {
+  const probe = rev => ({ schemaVersion: 1, python: { implementation: 'CPython', version: '3.12.4' }, cuaS1: { distribution: 'cua-s1', version: '0.1.0', sourceRevision: rev }, torch: '2.5.1' });
+  assert.equal(validateProvenance(probe(PINNED_CUA_S1_REVISION)).cuaS1.sourceRevisionStatus, 'pinned');
+  assert.equal(validateProvenance(probe('0'.repeat(40))).cuaS1.sourceRevisionStatus, 'mismatch');
+  assert.equal(validateProvenance(probe(null)).cuaS1.sourceRevisionStatus, 'unavailable');
+  assert.equal(validateProvenance(probe(null)).cuaS1.pinnedRevision, PINNED_CUA_S1_REVISION);
+  for (const mutate of [p => { p.schemaVersion = 2; }, p => { p.extra = 1; }, p => { delete p.torch; }, p => { p.python.version = ''; }, p => { p.python.extra = 1; }, p => { p.cuaS1.sourceRevision = 'abc'; }, p => { p.cuaS1.sourceRevision = 'A'.repeat(40); }, p => { p.cuaS1.version = 1; }, p => { p.cuaS1.extra = 1; }, p => { p.torch = 'x'.repeat(129); }, p => { p.python.version = '3.12\n'; }]) {
+    const p = probe(null); mutate(p); assert.throws(() => validateProvenance(p));
+  }
+  assert.deepEqual(provenance('/missing/system-one-manifest.json'), { status: 'unavailable', reason: 'provider-config' });
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-s1-prov-'));
+  try {
+    const python = process.env.PYTHON || (process.platform === 'win32' ? 'python' : 'python3');
+    const file = path.join(dir, 'manifest.json');
+    fs.writeFileSync(file, JSON.stringify({ ...manifest(), python, checkpoint: path.join(dir, 'absent.safetensors') }));
+    const one = provenance(file); const two = provenance(file);
+    assert.deepEqual(one, two);
+    assert.equal(one.status, 'recorded', JSON.stringify(one));
+    assert.match(one.provenance.python.version, /^3\.\d+\.\d+/);
+    if (one.provenance.cuaS1.distribution === null) assert.equal(one.provenance.cuaS1.sourceRevisionStatus, 'unavailable');
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});

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

@@ -0,0 +1,101 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const path = require('node:path');
+const { selectTier, TIER_OPTIONS } = require('../harness-everything/scripts/system-one/router');
+const root = path.resolve(__dirname, '..');
+function scorer(id = 'tier2', domain = 'harness-routing-v1') {
+  return req => ({ status: 'scored', response: { schemaVersion: 1, requestHash: req.requestHash, catalogHash: req.catalogHash,
+    model: { id: 'fixture', revision: 'v1', domain }, scores: req.options.map(o => ({ id: o.id, probability: o.id === id ? 1 : 0 })) } });
+}
+test('S1-R01 off/shadow/prefer and rollback', () => {
+  const input = { prompt: '實作功能', tier: 'Unclassified' };
+  const forbidden = () => { throw new Error('must not invoke'); };
+  assert.deepEqual(selectTier(input, {}, forbidden), { tier: input.tier, diagnostic: null });
+  assert.equal(selectTier(input, { HARNESS_SYSTEM_ONE_MODE: 'off' }, forbidden).tier, input.tier);
+  for (const mode of ['shadow', 'prefer']) {
+    let captured;
+    const result = selectTier(input, { HARNESS_SYSTEM_ONE_MODE: mode }, req => { captured = req; return scorer()(req); });
+    assert.deepEqual(captured.options, TIER_OPTIONS);
+    assert.equal(result.tier, mode === 'prefer' ? 'Tier 2 (Standard Task)' : input.tier);
+    assert.equal(result.diagnostic.status, 'accepted');
+    assert.ok(!JSON.stringify(result.diagnostic).includes(input.prompt));
+  }
+  assert.equal(selectTier(input, { HARNESS_SYSTEM_ONE_MODE: 'unknown' }, forbidden).diagnostic.reason, 'invalid-mode');
+});
+test('S1-R02 explicit precedence, abstention and every failure leave fallback intact', () => {
+  const env = { HARNESS_SYSTEM_ONE_MODE: 'prefer' };
+  const input = { prompt: 'use fable architecture', tier: 'Tier 3 (Macro Task)' };
+  assert.equal(selectTier({ ...input, explicit: true }, env, scorer('tier1')).tier, input.tier);
+  for (const provider of [scorer('unclassified'), scorer('tier1', 'forms-v1'), () => ({ status: 'unavailable', reason: 'provider-timeout' }), () => ({ status: 'scored', response: null }), () => { throw new Error('secret'); }]) {
+    const result = selectTier(input, env, provider);
+    assert.equal(result.tier, input.tier);
+    assert.ok(!JSON.stringify(result).includes('secret'));
+  }
+  assert.equal(selectTier({ ...input, prompt: '' }, env, scorer()).diagnostic.reason, 'invalid-request');
+});
+test('S1-R03 real CLI/kernel off parity and shadow failure repeated', () => {
+  const script = path.join(root, 'harness-everything/scripts/kernel-router-core.js');
+  const run = mode => spawnSync(process.execPath, [script, 'deploy to production'], { cwd: root, encoding: 'utf8', env: { ...process.env, HARNESS_SYSTEM_ONE_MODE: mode, HARNESS_SYSTEM_ONE_CONFIG: '' } });
+  const off = run('off'); assert.equal(off.status, 0);
+  const baseline = run(''); assert.equal(off.stdout, baseline.stdout);
+  const one = run('shadow'); const two = run('shadow');
+  assert.equal(one.status, 0); assert.equal(one.stdout, two.stdout); assert.equal(one.stderr, two.stderr);
+  assert.match(one.stdout, /SYSTEM ONE.*provider-config/);
+  const parse = text => JSON.parse(text.match(/ROUTER WORKFLOW PLAN \(JSON\): (.*)/)[1]);
+  assert.deepEqual(parse(one.stdout), parse(off.stdout));
+  assert.equal(parse(one.stdout).actionGate.required, true);
+});
+test('S1-R04 integrated accepted route preserves policy and explicit model choice', () => {
+  const provider = require('../harness-everything/scripts/system-one/provider');
+  const original = provider.score; const log = console.log; const env = process.env.HARNESS_SYSTEM_ONE_MODE;
+  try {
+    process.env.HARNESS_SYSTEM_ONE_MODE = 'prefer'; console.log = () => {};
+    provider.score = scorer('tier1');
+    const { run } = require('../harness-everything/scripts/tier-router');
+    const risky = run('deploy to production; save lesson to memory');
+    assert.equal(risky.workflowPlan.actionGate.required, true);
+    assert.notEqual(risky.workflowPlan.memory.write, 'none');
+    const explicit = run('use fable-staged without subagents');
+    assert.notEqual(explicit.workflowPlan.strategy, 'direct-single');
+    assert.ok(explicit.workflowPlan.requiredInvariants.includes('replan-after-repeated-failure'));
+    const normal = run('unusual bounded wording');
+    assert.equal(normal.workflowPlan.tier, 'tier1');
+  } finally { provider.score = original; console.log = log; if (env === undefined) delete process.env.HARNESS_SYSTEM_ONE_MODE; else process.env.HARNESS_SYSTEM_ONE_MODE = env; }
+});
+test('S1-R05 structural floor: a scorer can raise but never lower a deterministic macro/multi-task tier', () => {
+  const env = { HARNESS_SYSTEM_ONE_MODE: 'prefer' };
+  const macro = { prompt: 'audit every skill in the repository', tier: 'Tier 3 (Macro Task)', floor: 'tier3' };
+  for (const id of ['tier1', 'tier2']) {
+    const result = selectTier(macro, env, scorer(id));
+    assert.equal(result.tier, macro.tier);
+    assert.equal(result.diagnostic.applied, false);
+    assert.equal(result.diagnostic.reason, 'structural-floor');
+    assert.equal(result.diagnostic.selectedId, id);
+  }
+  const multi = { prompt: 'x', tier: 'Tier 2 (Standard Task)', floor: 'tier2' };
+  assert.equal(selectTier(multi, env, scorer('tier1')).tier, multi.tier);
+  assert.equal(selectTier(multi, env, scorer('tier3')).tier, 'Tier 3 (Macro Task)');
+  assert.equal(selectTier({ ...multi, floor: null }, env, scorer('tier1')).tier, 'Tier 1 (Trivial)');
+  assert.equal(selectTier({ ...multi, floor: 'tier9' }, env, () => { throw new Error('must not invoke'); }).diagnostic.reason, 'invalid-request');
+
+  const provider = require('../harness-everything/scripts/system-one/provider');
+  const original = provider.score; const log = console.log; const mode = process.env.HARNESS_SYSTEM_ONE_MODE;
+  try {
+    console.log = () => {};
+    const { run } = require('../harness-everything/scripts/tier-router');
+    for (const prompt of ['audit every skill in the repository', 'Refactor the parser. Then update the tests and also the docs. Finally rerun CI.']) {
+      process.env.HARNESS_SYSTEM_ONE_MODE = 'off';
+      const lexical = run(prompt).workflowPlan;
+      process.env.HARNESS_SYSTEM_ONE_MODE = 'prefer'; provider.score = scorer('tier1');
+      assert.deepEqual(run(prompt).workflowPlan, lexical);
+      provider.score = original;
+    }
+    process.env.HARNESS_SYSTEM_ONE_MODE = 'prefer'; provider.score = scorer('tier1');
+    const plan = run('audit every skill in the repository').workflowPlan;
+    assert.equal(plan.tier, 'tier3');
+    assert.notEqual(plan.strategy, 'direct-single');
+    assert.equal(plan.verification.independent, true);
+  } finally { provider.score = original; console.log = log; if (mode === undefined) delete process.env.HARNESS_SYSTEM_ONE_MODE; else process.env.HARNESS_SYSTEM_ONE_MODE = mode; }
+});

package/ci/system-one-adapter-test.py

@@ -0,0 +1,56 @@
+"""Stdlib adapter tests: no claim of real checkpoint inference."""
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+path = Path(__file__).resolve().parents[1] / 'harness-everything/scripts/system-one/cua_adapter.py'
+spec = importlib.util.spec_from_file_location('adapter', path)
+adapter = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(adapter)
+
+
+class AdapterTests(unittest.TestCase):
+    def test_artifact_hash_and_pickle_rejection(self):
+        with tempfile.TemporaryDirectory() as root:
+            weights = Path(root) / 'model.safetensors'
+            weights.write_bytes(b'synthetic-not-real-weights')
+            sidecar = weights.with_suffix('.json')
+            sidecar.write_text('{}', encoding='utf-8')
+            manifest = {'checkpoint': str(weights), 'weightsSha256': hashlib.sha256(weights.read_bytes()).hexdigest(), 'configSha256': hashlib.sha256(sidecar.read_bytes()).hexdigest()}
+            self.assertEqual(adapter.verify_artifacts(manifest), weights)
+            sidecar.write_text('{"changed":true}', encoding='utf-8')
+            with self.assertRaisesRegex(ValueError, 'artifact-hash'):
+                adapter.verify_artifacts(manifest)
+            manifest['checkpoint'] = str(weights.with_suffix('.pt'))
+            with self.assertRaisesRegex(ValueError, 'checkpoint-format'):
+                adapter.verify_artifacts(manifest)
+
+    def test_byte_limits_no_truncation(self):
+        request = {'context': '中文', 'options': [{'text': 'abc'}, {'text': 'x'}]}
+        adapter.check_limits(request, {'context_tokens': 6, 'option_tokens': 3})
+        for config in [{'context_tokens': 5, 'option_tokens': 3}, {'context_tokens': 6, 'option_tokens': 2}]:
+            with self.assertRaisesRegex(ValueError, 'input-too-long'):
+                adapter.check_limits(request, config)
+
+    def test_source_revision_only_from_recorded_vcs_commit(self):
+        commit = 'b7f7e2d8714609853a29c7d049140bc46aec0954'
+        vcs = {'url': 'https://github.com/trycua/cua', 'vcs_info': {'vcs': 'git', 'commit_id': commit}, 'subdirectory': 'libs/cua-s1/python'}
+        self.assertEqual(adapter.source_revision(json.dumps(vcs)), commit)
+        for text in ['', 'not-json', '[]', json.dumps({'url': 'file:///src', 'dir_info': {'editable': True}}),
+                     json.dumps({'vcs_info': {'commit_id': 'main'}}), json.dumps({'vcs_info': {'commit_id': commit.upper()}}), json.dumps({'vcs_info': []})]:
+            self.assertIsNone(adapter.source_revision(text))
+        self.assertIsNone(adapter.source_revision(None))
+
+    def test_provenance_shape_without_ml_dependency(self):
+        result = adapter.provenance()
+        self.assertEqual(set(result), {'schemaVersion', 'python', 'cuaS1', 'torch'})
+        self.assertEqual(set(result['python']), {'implementation', 'version'})
+        self.assertEqual(set(result['cuaS1']), {'distribution', 'version', 'sourceRevision'})
+        self.assertEqual(json.loads(json.dumps(result)), result)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/docs/platform-capabilities.md

@@ -120,3 +120,14 @@ The OpenCode adapter uses the documented plugin API and has deterministic mechan
 The matrix records the official documentation reviewed for each platform. Important source families include [OpenAI plugin packaging](https://developers.openai.com/plugins/build/plugins), [OpenAI public submission](https://developers.openai.com/plugins/deploy/submission), [Codex skills](https://learn.chatgpt.com/docs/build-skills), [Codex hooks](https://learn.chatgpt.com/docs/hooks), [Claude skills](https://code.claude.com/docs/en/skills), [OpenCode skills](https://opencode.ai/docs/skills), [GitHub Copilot Agent Skills](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/add-skills), [Cursor skills](https://cursor.com/docs/skills), [Continue rules](https://docs.continue.dev/customize/rules), and [Hermes skills](https://hermes-agent.nousresearch.com/docs/user-guide/features/skills).
 
 When a platform behavior changes, update this page, `docs/platform-compatibility.json`, and every affected current-state surface in the same change. `npm run test:docs:capabilities` and the compatibility mechanism suite enforce the repository-side contract; they do not replace manual live-host evidence.
+# Experimental System One routing
+
+The shared tier router supports opt-in `HARNESS_SYSTEM_ONE_MODE=shadow|prefer`
+with a local CUA-S1 provider manifest (`HARNESS_SYSTEM_ONE_CONFIG`). Default `off`
+retains existing behavior; `prefer` never lowers a tier below the deterministic
+structural floor. Canonical and packaged runtime copies use the same
+contract; this establishes no new live-host capability. Python, PyTorch and a
+compatible local checkpoint are optional external dependencies, not npm payloads;
+the explicit `npm run system-one:install` sets them up and hooks never run it.
+Public Skills-only artifacts do not acquire lifecycle hooks from this feature.
+See [System One routing](system-one-routing.md) for limits, rollback and evidence.