harness-everything 0.20.6 → 0.21.0

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

@@ -0,0 +1,76 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { validateRequest } = require('./contract');
+// Upstream cua_s1 source revision documented in docs/system-one-routing.md.
+const PINNED_CUA_S1_REVISION = 'b7f7e2d8714609853a29c7d049140bc46aec0954';
+const ADAPTER = path.join(__dirname, 'cua_adapter.py');
+const unavailable = reason => ({ status: 'unavailable', reason });
+const exact = (value, keys) => value && typeof value === 'object' && !Array.isArray(value)
+  && Object.keys(value).length === keys.length && keys.every(k => Object.hasOwn(value, k));
+const label = value => typeof value === 'string' && value.length > 0 && value.length <= 128 && !/[\u0000-\u001f]/.test(value);
+function validateManifest(m) {
+  const required = ['schemaVersion', 'python', 'checkpoint', 'weightsSha256', 'configSha256', 'modelId', 'revision', 'domain'];
+  if (!m || typeof m !== 'object' || Array.isArray(m) || required.some(k => !Object.hasOwn(m, k))
+    || Object.keys(m).some(k => ![...required, 'timeoutMs'].includes(k)) || m.schemaVersion !== 1
+    || ['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'
+    || ['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.modelId === 'cua-ai/cua-s1-forms' && m.domain !== 'forms-v1')) throw new TypeError('invalid-manifest');
+  return true;
+}
+function readManifest(manifestPath) {
+  if (typeof manifestPath !== 'string' || !path.isAbsolute(manifestPath) || fs.statSync(manifestPath).size > 65536) throw new Error();
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  validateManifest(manifest);
+  return manifest;
+}
+function spawnJson(executable, args, input, timeoutMs) {
+  let result;
+  try {
+    result = spawnSync(executable, args, { input, encoding: 'utf8', shell: false,
+      timeout: timeoutMs, killSignal: 'SIGKILL', maxBuffer: 1024 * 1024, windowsHide: true });
+  } catch (_) { return unavailable('provider-unavailable'); }
+  if (result.error) return unavailable(result.error.code === 'ETIMEDOUT' ? 'provider-timeout'
+    : result.error.code === 'ENOBUFS' ? 'provider-output-limit' : 'provider-unavailable');
+  if (result.status !== 0) return unavailable('provider-exit');
+  try { return { status: 'ok', value: JSON.parse(result.stdout) }; }
+  catch (_) { return unavailable('provider-json'); }
+}
+function runProvider(request, executable, args, timeoutMs = 2000) {
+  validateRequest(request);
+  const result = spawnJson(executable, args, JSON.stringify(request), timeoutMs);
+  return result.status === 'ok' ? { status: 'scored', response: result.value } : result;
+}
+function score(request, manifestPath) {
+  validateRequest(request);
+  let manifest;
+  try { manifest = readManifest(manifestPath); } catch (_) { return unavailable('provider-config'); }
+  // Send the exact validated manifest to the child on stdin: no config reread race.
+  return runProvider({ ...request }, manifest.python, [ADAPTER, JSON.stringify(manifest)], manifest.timeoutMs || 2000);
+}
+// The probe reports what is installed; only a PEP 610 VCS commit counts as a source revision.
+function validateProvenance(p) {
+  if (!exact(p, ['schemaVersion', 'python', 'cuaS1', 'torch']) || p.schemaVersion !== 1
+    || !exact(p.python, ['implementation', 'version']) || !label(p.python.implementation) || !label(p.python.version)
+    || !exact(p.cuaS1, ['distribution', 'version', 'sourceRevision'])
+    || ![p.cuaS1.distribution, p.cuaS1.version, p.torch].every(v => v === null || label(v))
+    || (p.cuaS1.sourceRevision !== null && !(typeof p.cuaS1.sourceRevision === 'string' && /^[0-9a-f]{40}$/.test(p.cuaS1.sourceRevision)))) {
+    throw new TypeError('invalid-provenance');
+  }
+  const revision = p.cuaS1.sourceRevision;
+  return { python: { ...p.python }, torch: p.torch, cuaS1: { ...p.cuaS1, pinnedRevision: PINNED_CUA_S1_REVISION,
+    sourceRevisionStatus: revision === null ? 'unavailable' : revision === PINNED_CUA_S1_REVISION ? 'pinned' : 'mismatch' } };
+}
+function provenance(manifestPath) {
+  let manifest;
+  try { manifest = readManifest(manifestPath); } catch (_) { return unavailable('provider-config'); }
+  // Metadata scans can exceed the per-score budget; use the manifest cap. No model is loaded.
+  const result = spawnJson(manifest.python, [ADAPTER, '--provenance'], '', 10000);
+  if (result.status !== 'ok') return result;
+  try { return { status: 'recorded', provenance: validateProvenance(result.value) }; }
+  catch (_) { return unavailable('provider-json'); }
+}
+module.exports = { score, runProvider, validateManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION };

package/harness-everything/scripts/system-one/router.js

@@ -0,0 +1,37 @@
+'use strict';
+const { createRequest, decide } = require('./contract');
+const provider = require('./provider');
+const TIER_OPTIONS = Object.freeze([
+  { id: 'tier1', text: 'A small bounded edit or operation with clear scope.' },
+  { id: 'tier2', text: 'Implementation or bug fix needing iterative testing.' },
+  { id: 'tier3', text: 'Architecture, repository-wide change or multi-stage engineering.' },
+  { id: 'unclassified', text: 'Unclear intent, insufficient context or outside these categories.' },
+].map(Object.freeze));
+const LABELS = { tier1: 'Tier 1 (Trivial)', tier2: 'Tier 2 (Standard Task)', tier3: 'Tier 3 (Macro Task)' };
+const RANK = { tier1: 1, tier2: 2, tier3: 3 };
+// input.floor is the deterministic structural minimum; a scorer may raise the tier, never lower it below the floor.
+function selectTier(input, env = process.env, scorer = provider.score) {
+  const mode = env.HARNESS_SYSTEM_ONE_MODE || 'off';
+  if (mode === 'off') return { tier: input.tier, diagnostic: null };
+  const fallback = (reason, status = 'unavailable') => ({ tier: input.tier, diagnostic: { mode: ['shadow', 'prefer'].includes(mode) ? mode : 'invalid', status, reason } });
+  if (!['shadow', 'prefer'].includes(mode)) return fallback('invalid-mode');
+  if (input.floor != null && !Object.hasOwn(RANK, input.floor)) return fallback('invalid-request');
+  let request;
+  try { request = createRequest('tier', input.prompt, TIER_OPTIONS); }
+  catch (_) { return fallback('invalid-request'); }
+  let result;
+  try { result = scorer(request, env.HARNESS_SYSTEM_ONE_CONFIG); }
+  catch (_) { return fallback('provider-unavailable'); }
+  if (!result || result.status !== 'scored') {
+    const allowed = ['provider-timeout', 'provider-output-limit', 'provider-exit', 'provider-json', 'provider-config', 'provider-unavailable'];
+    return fallback(allowed.includes(result?.reason) ? result.reason : 'provider-unavailable');
+  }
+  const decision = decide(request, result.response);
+  if (decision.selectedId === 'unclassified') Object.assign(decision, { selectedId: null, status: 'abstain', reason: 'unclassified' });
+  const accepted = decision.status === 'accepted';
+  const belowFloor = accepted && input.floor != null && RANK[decision.selectedId] < RANK[input.floor];
+  const applied = mode === 'prefer' && accepted && !input.explicit && !belowFloor;
+  const reason = input.explicit && accepted ? 'explicit-precedence' : belowFloor ? 'structural-floor' : decision.reason;
+  return { tier: applied ? LABELS[decision.selectedId] : input.tier, diagnostic: { mode, ...decision, applied, reason } };
+}
+module.exports = { selectTier, TIER_OPTIONS };

package/harness-everything/scripts/tier-router.js

@@ -313,6 +313,19 @@ function run(userPrompt, context) {
     }
   }
 
+  const { selectTier } = require('./system-one/router');
+  const structuralFloor = hasMacroSignal ? 'tier3'
+    : !isTrivialDocsEdit && hasMultipleTasks && hasMultipleSentences ? 'tier2' : null;
+  const semantic = selectTier({ prompt: userPrompt, tier: recommendedTier, floor: structuralFloor,
+    explicit: Boolean(detectExplicitStrategy(userPrompt, detectFableModel(userPrompt))) });
+  if (semantic.diagnostic) console.log(`\n=> SYSTEM ONE: ${JSON.stringify(semantic.diagnostic)}`);
+  if (semantic.diagnostic?.applied) {
+    recommendedTier = semantic.tier;
+    rationale = 'System One selected a tier from the fixed catalog; deterministic policy remains authoritative.';
+    reasonCodes.splice(loadedConfig.reasonCodes.length);
+    addReason(reasonCodes, 'system-one-tier');
+  }
+
   console.log(`\n=> RECOMMENDED TIER: ${recommendedTier}`);
   console.log(`=> RATIONALE: ${rationale}`);
 
@@ -447,6 +460,7 @@ function run(userPrompt, context) {
   return contract;
 }
 
+if (require.main === module) {
 let userPrompt = process.argv[2] || '';
 let hookContext = null;
 
@@ -471,3 +485,5 @@ if (process.argv[2]) {
     run(userPrompt, hookContext);
   });
 }
+}
+module.exports = { run };

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.20.6",
+  "version": "0.21.0",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {
@@ -23,6 +23,7 @@
     "test:release": "node ci/release-consistency-check.js && node ci/mechanism-2x-release-automation.test.js && node ci/mechanism-2x-release-commit-message.test.js && node ci/mechanism-2ap-sbom.test.js",
     "test:release:semantics": "node ci/semantic-release-analyzer.test.mjs",
     "test:install": "node scripts/verify-install.js",
+    "system-one:install": "node harness-everything/scripts/system-one/install.js",
     "test:collision": "node ci/description-collision.js",
     "test:routing:skills": "node ci/skill-routing-check.js",
     "test:routing": "node ci/routing-check.js",

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

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.20.6",
+  "version": "0.21.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.20.6",
+  "version": "0.21.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.19.1
+  version: 0.21.0
 ---
 
 # Harness Everything

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

@@ -0,0 +1,45 @@
+'use strict';
+const { createHash } = require('node:crypto');
+const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const exact = (value, keys) => value && typeof value === 'object' && !Array.isArray(value)
+  && Object.keys(value).length === keys.length && keys.every(k => Object.hasOwn(value, k));
+const text = (value, max = 4096) => typeof value === 'string' && value.trim().length > 0 && Buffer.byteLength(value, 'utf8') <= max;
+const id = value => typeof value === 'string' && /^[a-z0-9._-]{1,80}$/.test(value);
+const probability = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
+function fail(code) { throw Object.assign(new TypeError(code), { code }); }
+function createRequest(task, context, options) {
+  if (!id(task) || !text(context, 65536) || !Array.isArray(options) || options.length < 2 || options.length > 256
+    || options.some(o => !exact(o, ['id', 'text']) || !id(o.id) || !text(o.text))
+    || new Set(options.map(o => o.id)).size !== options.length) fail('invalid-request');
+  const copy = options.map(o => ({ id: o.id, text: o.text }));
+  const catalogHash = hash({ task, options: copy });
+  return { schemaVersion: 1, task, context, options: copy, catalogHash, requestHash: hash({ catalogHash, context }) };
+}
+function validateRequest(req) {
+  if (!exact(req, ['schemaVersion', 'task', 'context', 'options', 'catalogHash', 'requestHash']) || req.schemaVersion !== 1) fail('invalid-request');
+  const rebuilt = createRequest(req.task, req.context, req.options);
+  if (req.catalogHash !== rebuilt.catalogHash || req.requestHash !== rebuilt.requestHash) fail('invalid-request');
+  return true;
+}
+function decide(req, res, policy = {}) {
+  validateRequest(req);
+  if (!policy || typeof policy !== 'object' || Array.isArray(policy)
+    || Object.keys(policy).some(k => !['domain', 'minConfidence', 'minMargin'].includes(k))) fail('invalid-policy');
+  const { domain = 'harness-routing-v1', minConfidence = 0.9, minMargin = 0.2 } = policy;
+  if (!text(domain) || !probability(minConfidence) || !probability(minMargin)) fail('invalid-policy');
+  const empty = { status: 'invalid-output', reason: 'invalid-response', selectedId: null, confidence: null, margin: null, model: null };
+  if (!exact(res, ['schemaVersion', 'requestHash', 'catalogHash', 'model', 'scores'])
+    || res.schemaVersion !== 1 || res.requestHash !== req.requestHash || res.catalogHash !== req.catalogHash
+    || !exact(res.model, ['id', 'revision', 'domain']) || !Object.values(res.model).every(v => text(v))
+    || !Array.isArray(res.scores) || res.scores.length !== req.options.length
+    || res.scores.some((s, i) => !exact(s, ['id', 'probability']) || s.id !== req.options[i].id || !probability(s.probability))
+    || Math.abs(res.scores.reduce((s, o) => s + o.probability, 0) - 1) > 1e-6) return empty;
+  const ranked = [...res.scores].sort((a, b) => b.probability - a.probability);
+  const confidence = ranked[0].probability;
+  const margin = confidence - ranked[1].probability;
+  const reason = res.model.domain !== domain ? 'domain-mismatch' : margin === 0 ? 'tie'
+    : confidence < minConfidence ? 'low-confidence' : margin < minMargin ? 'low-margin' : 'scored';
+  return { status: reason === 'scored' ? 'accepted' : 'abstain', reason,
+    selectedId: reason === 'scored' ? ranked[0].id : null, confidence, margin, model: { ...res.model } };
+}
+module.exports = { createRequest, validateRequest, decide };

package/plugins/harness-everything/skills/harness-everything/scripts/system-one/cua_adapter.py

@@ -0,0 +1,94 @@
+"""Optional CPU CUA-S1 bridge. Stdout is protocol-only; never execute UI actions."""
+import hashlib
+import json
+from pathlib import Path
+import re
+import sys
+
+
+def verify_artifacts(manifest):
+    weights = Path(manifest['checkpoint'])
+    if not weights.is_absolute() or weights.suffix != '.safetensors':
+        raise ValueError('checkpoint-format')
+    for file, key in [(weights, 'weightsSha256'), (weights.with_suffix('.json'), 'configSha256')]:
+        with file.open('rb') as handle:
+            digest = hashlib.file_digest(handle, 'sha256').hexdigest()
+        if digest != manifest[key]:
+            raise ValueError('artifact-hash')
+    return weights
+
+
+def check_limits(request, config):
+    if len(request['context'].encode('utf-8')) > config['context_tokens'] or any(
+        len(option['text'].encode('utf-8')) > config['option_tokens'] for option in request['options']
+    ):
+        raise ValueError('input-too-long')
+
+
+def infer(request, manifest):
+    weights = verify_artifacts(manifest)
+    import torch
+    from cua_s1.model import ChoiceExample, load_checkpoint
+
+    torch.set_num_threads(1)
+    torch.use_deterministic_algorithms(True)
+    model, collator, config = load_checkpoint(weights, 'cpu')
+    check_limits(request, config)
+    example = ChoiceExample(context=request['context'], options=tuple(o['text'] for o in request['options']), label=0)
+    with torch.inference_mode():
+        probabilities = model(collator([example])).softmax(-1)[0].tolist()
+    return {
+        'schemaVersion': 1, 'requestHash': request['requestHash'], 'catalogHash': request['catalogHash'],
+        'model': {'id': manifest['modelId'], 'revision': manifest['revision'], 'domain': manifest['domain']},
+        'scores': [{'id': option['id'], 'probability': probability} for option, probability in zip(request['options'], probabilities, strict=True)],
+    }
+
+
+def source_revision(direct_url_text):
+    """Return the PEP 610 VCS commit recorded at install time, or None when unprovable."""
+    try:
+        commit = json.loads(direct_url_text)['vcs_info']['commit_id']
+    except Exception:
+        return None
+    return commit if isinstance(commit, str) and re.fullmatch(r'[0-9a-f]{40}', commit) else None
+
+
+def provenance():
+    """Installed runtime/source facts only; never imports torch or loads a checkpoint."""
+    import importlib.metadata as metadata
+    import platform
+
+    cua = {'distribution': None, 'version': None, 'sourceRevision': None}
+    names = sorted(set(metadata.packages_distributions().get('cua_s1', [])))
+    if len(names) == 1:
+        dist = metadata.distribution(names[0])
+        cua = {'distribution': names[0], 'version': dist.version, 'sourceRevision': source_revision(dist.read_text('direct_url.json'))}
+    try:
+        torch = metadata.version('torch')
+    except metadata.PackageNotFoundError:
+        torch = None
+    return {'schemaVersion': 1, 'python': {'implementation': platform.python_implementation(), 'version': platform.python_version()},
+            'cuaS1': cua, 'torch': torch}
+
+
+def main():
+    try:
+        if sys.argv[1:] == ['--provenance']:
+            print(json.dumps(provenance(), allow_nan=False))
+            return 0
+        manifest = json.loads(sys.argv[1])
+        raw = sys.stdin.buffer.read(2 * 1024 * 1024 + 1)
+        if len(raw) > 2 * 1024 * 1024:
+            raise ValueError('request-limit')
+        request = json.loads(raw)
+        result = infer(request, manifest)
+        print(json.dumps(result, allow_nan=False))
+    except Exception:
+        # No raw prompt, selected values, artifact paths, or traceback on the wire.
+        print('cua-provider-unavailable', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

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

@@ -0,0 +1,98 @@
+'use strict';
+const { validateRequest } = require('./contract');
+const { TIER_OPTIONS } = require('./router');
+const exact = (obj, keys) => obj && typeof obj === 'object' && !Array.isArray(obj) && Object.keys(obj).length === keys.length && keys.every(k => Object.hasOwn(obj, k));
+const nonempty = v => typeof v === 'string' && v.trim().length > 0;
+const labels = ['tier1', 'tier2', 'tier3', null];
+const finite = v => typeof v === 'number' && Number.isFinite(v);
+const fail = () => { throw new TypeError('invalid-evaluation-input'); };
+function validateCorpus(corpus) {
+  if (!exact(corpus, ['schemaVersion', 'cases']) || corpus.schemaVersion !== 1 || !Array.isArray(corpus.cases) || !corpus.cases.length) fail();
+  const ids = new Set(); const hashes = new Set(); const families = new Map();
+  for (const c of corpus.cases) {
+    if (!exact(c, ['id', 'family', 'split', 'language', 'source', 'reviewed', 'request', 'gold'])
+      || ![c.id, c.family, c.source].every(nonempty) || !['train', 'validation', 'holdout'].includes(c.split)
+      || !['en', 'zh-TW'].includes(c.language) || typeof c.reviewed !== 'boolean' || !labels.includes(c.gold)) fail();
+    validateRequest(c.request);
+    if (c.request.task !== 'tier' || JSON.stringify(c.request.options) !== JSON.stringify(TIER_OPTIONS)
+      || ids.has(c.id) || hashes.has(c.request.requestHash) || (families.has(c.family) && families.get(c.family) !== c.split)) fail();
+    ids.add(c.id); hashes.add(c.request.requestHash); families.set(c.family, c.split);
+  }
+  return true;
+}
+function prediction(decision) {
+  if (exact(decision, ['status', 'reason']) && decision.status === 'unavailable' && nonempty(decision.reason)) return null;
+  if (!exact(decision, ['status', 'reason', 'selectedId', 'confidence', 'margin', 'model'])
+    || !['accepted', 'abstain', 'invalid-output'].includes(decision.status) || !nonempty(decision.reason)
+    || !labels.includes(decision.selectedId) || (decision.status === 'accepted') !== (decision.selectedId !== null)) fail();
+  for (const key of ['confidence', 'margin']) if (decision[key] !== null && (!finite(decision[key]) || decision[key] < 0 || decision[key] > 1)) fail();
+  if (decision.model !== null && (!exact(decision.model, ['id', 'revision', 'domain']) || !Object.values(decision.model).every(nonempty))) fail();
+  if (decision.status === 'accepted' && (decision.confidence === null || decision.margin === null || decision.model?.domain !== 'harness-routing-v1')) fail();
+  return decision.selectedId;
+}
+// Scored decisions carry the full catalog-order probability vector; unavailable/invalid outputs carry null.
+function checkScores(decision, scores) {
+  const scored = ['accepted', 'abstain'].includes(decision.status);
+  if (!scored) { if (scores !== null) fail(); return; }
+  if (!Array.isArray(scores) || scores.length !== TIER_OPTIONS.length
+    || scores.some(p => !finite(p) || p < 0 || p > 1) || Math.abs(scores.reduce((s, p) => s + p, 0) - 1) > 1e-6) fail();
+  const ranked = [...scores].sort((a, b) => b - a);
+  if (decision.confidence !== ranked[0] || decision.margin !== ranked[0] - ranked[1]) fail();
+}
+function metrics(gold, predicted) {
+  const count = gold.length;
+  const accepted = predicted.filter(x => x !== null).length;
+  const correct = predicted.filter((x, i) => x === gold[i]).length;
+  const acceptedCorrect = predicted.filter((x, i) => x !== null && x === gold[i]).length;
+  const macroF1 = labels.reduce((sum, label) => {
+    const tp = gold.filter((g, i) => g === label && predicted[i] === label).length;
+    const fp = gold.filter((g, i) => g !== label && predicted[i] === label).length;
+    const fn = gold.filter((g, i) => g === label && predicted[i] !== label).length;
+    return sum + (2 * tp + fp + fn ? 2 * tp / (2 * tp + fp + fn) : 0);
+  }, 0) / labels.length;
+  return { accuracy: correct / count, macroF1, coverage: accepted / count, abstentionRate: 1 - accepted / count,
+    acceptedPrecision: accepted ? acceptedCorrect / accepted : null,
+    acceptedErrorRate: accepted ? (accepted - acceptedCorrect) / accepted : null };
+}
+function p95(values) { return values.length ? [...values].sort((a, b) => a - b)[Math.ceil(values.length * 0.95) - 1] : null; }
+// sourceEvidence is the provider provenance result; only the pinned cua_s1 revision satisfies the gate.
+function evaluate(corpus, records, sourceEvidence = null) {
+  validateCorpus(corpus);
+  const cases = corpus.cases.filter(c => c.split === 'holdout');
+  if (!cases.length || !Array.isArray(records) || records.length !== cases.length) fail();
+  const byId = new Map(); const models = new Set(); const cold = []; const warm = [];
+  for (const record of records) {
+    if (!exact(record, ['id', 'baseline', 'runs']) || byId.has(record.id) || !cases.some(c => c.id === record.id)
+      || !labels.includes(record.baseline) || !Array.isArray(record.runs) || record.runs.length !== 2) fail();
+    for (const run of record.runs) {
+      if (!exact(run, ['decision', 'scores', 'latencyMs', 'coldStart']) || !finite(run.latencyMs) || run.latencyMs < 0 || typeof run.coldStart !== 'boolean') fail();
+      prediction(run.decision);
+      checkScores(run.decision, run.scores);
+      if (run.decision.model) models.add(JSON.stringify([run.decision.model.id, run.decision.model.revision, run.decision.model.domain]));
+      (run.coldStart ? cold : warm).push(run.latencyMs);
+    }
+    byId.set(record.id, record);
+  }
+  if (models.size > 1) fail();
+  const gold = cases.map(c => c.gold);
+  const baseline = metrics(gold, cases.map(c => byId.get(c.id).baseline));
+  const model = metrics(gold, cases.map(c => prediction(byId.get(c.id).runs[0].decision)));
+  const canonicalRun = ({ decision: d, scores }) => JSON.stringify([d.status, d.reason, d.selectedId ?? null, d.confidence ?? null, d.margin ?? null,
+    d.model ? [d.model.id, d.model.revision, d.model.domain] : null, scores]);
+  const agreement = records.filter(r => canonicalRun(r.runs[0]) === canonicalRun(r.runs[1])).length / cases.length;
+  const latency = { coldP95Ms: p95(cold), warmP95Ms: p95(warm), coldSamples: cold.length, warmSamples: warm.length };
+  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,
+    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',
+    policyEvidence: false,
+    liveHostEvidence: false,
+  };
+  return { schemaVersion: 1, cases: cases.length, baseline, model, agreement, latency, gates, rolloutReady: Object.values(gates).every(Boolean) };
+}
+module.exports = { validateCorpus, evaluate };

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

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+'use strict';
+// Opt-in System One installer: a dedicated venv, pinned cua_s1 source, and a pinned CPU checkpoint.
+// It is never run from hooks, and it never changes the router mode; it prints the environment to set.
+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 { performance } = require('node:perf_hooks');
+const { validateManifest, provenance, score, PINNED_CUA_S1_REVISION } = require('./provider');
+const { createRequest, decide } = require('./contract');
+const { TIER_OPTIONS } = require('./router');
+
+const PINS = Object.freeze({
+  cuaS1Revision: PINNED_CUA_S1_REVISION,
+  cuaS1Spec: `cua-s1 @ git+https://github.com/trycua/cua@${PINNED_CUA_S1_REVISION}#subdirectory=libs/cua-s1/python`,
+  torchSpec: 'torch>=2.2,<3',
+  torchIndex: 'https://download.pytorch.org/whl/cpu',
+  modelId: 'cua-ai/cua-s1-forms',
+  modelRevision: 'f54adbf447f4ca6ec259f529ee3f2e3e09f8cc71',
+  domain: 'forms-v1',
+  // sha256/size from the Hugging Face tree API at modelRevision (LFS oid for weights; the JSON
+  // sidecar's git blob id d8f8426a... was re-hashed to confirm these exact CRLF bytes).
+  files: Object.freeze({
+    weights: Object.freeze({ name: 'cua-s1-forms.safetensors', size: 2828784, sha256: '05954c1caf51c2fb6c13ea4acbfc88a2e7653dea192252bb51dc89e76a356ddc' }),
+    config: Object.freeze({ name: 'cua-s1-forms.json', size: 1053, sha256: '62d31e2f9a001a8e9b6f8534c5194d07ebdd3f9d62ef1ac281906622992650ca' }),
+  }),
+});
+const USAGE = 'Usage: install.js [--dir <absolute dir>] [--python <3.11-3.13 executable>] [--dry-run]';
+
+const defaultDir = () => path.join(os.homedir(), '.agents', 'harness-everything', 'system-one');
+const fileUrl = name => `https://huggingface.co/${PINS.modelId}/resolve/${PINS.modelRevision}/${name}`;
+const checkpointDir = dir => path.join(dir, 'checkpoints', PINS.modelRevision);
+const venvPython = (dir, platform = process.platform) => (platform === 'win32'
+  ? path.join(dir, 'venv', 'Scripts', 'python.exe') : path.join(dir, 'venv', 'bin', 'python'));
+function supportedPython(version) {
+  const match = typeof version === 'string' && /^3\.(\d+)\.\d+$/.exec(version);
+  return Boolean(match) && Number(match[1]) >= 11 && Number(match[1]) <= 13;
+}
+function pythonCandidates(platform = process.platform) {
+  return platform === 'win32'
+    ? [['py', '-3.13'], ['py', '-3.12'], ['py', '-3.11'], ['python'], ['python3']]
+    : [['python3.13'], ['python3.12'], ['python3.11'], ['python3'], ['python']];
+}
+function parseArgs(argv) {
+  const opts = { dir: defaultDir(), python: null, dryRun: false };
+  const seen = new Set();
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    if (seen.has(flag)) throw new Error('usage');
+    seen.add(flag);
+    if (flag === '--dry-run') opts.dryRun = true;
+    else if (flag === '--dir' || flag === '--python') {
+      const value = argv[++i];
+      if (!value || value.startsWith('--')) throw new Error('usage');
+      if (flag === '--dir' && !path.isAbsolute(value)) throw new Error('usage');
+      opts[flag.slice(2)] = flag === '--dir' ? path.resolve(value) : value;
+    } else throw new Error('usage');
+  }
+  return opts;
+}
+function buildManifest(dir, python) {
+  const manifest = { schemaVersion: 1, python, checkpoint: path.join(checkpointDir(dir), PINS.files.weights.name),
+    weightsSha256: PINS.files.weights.sha256, configSha256: PINS.files.config.sha256,
+    modelId: PINS.modelId, revision: PINS.modelRevision, domain: PINS.domain,
+    // Each score starts a fresh Python process that imports torch; cold start dominates latency.
+    timeoutMs: 10000 };
+  validateManifest(manifest);
+  return manifest;
+}
+const matches = (buf, spec) => buf.length === spec.size && createHash('sha256').update(buf).digest('hex') === spec.sha256;
+async function httpFetch(url) {
+  const res = await fetch(url, { redirect: 'follow' });
+  if (!res.ok) throw new Error(`download-failed:${res.status}`);
+  return Buffer.from(await res.arrayBuffer());
+}
+async function ensureFile(url, dest, spec, fetcher = httpFetch) {
+  if (fs.existsSync(dest) && matches(fs.readFileSync(dest), spec)) return 'verified-existing';
+  const bytes = await fetcher(url);
+  if (!Buffer.isBuffer(bytes) || !matches(bytes, spec)) throw new Error(`download-verification:${spec.name}`);
+  const tmp = `${dest}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, bytes);
+  fs.renameSync(tmp, dest);
+  return 'downloaded';
+}
+function exec(cmd, args, capture = false) {
+  const result = spawnSync(cmd, args, { shell: false, windowsHide: true, encoding: 'utf8', stdio: capture ? 'pipe' : 'inherit' });
+  if (result.error || result.status !== 0) throw new Error(`command-failed: ${[cmd, ...args].join(' ')}`);
+  return capture ? result.stdout.trim() : '';
+}
+const VERSION_PROBE = ['-c', 'import sys; print("%d.%d.%d" % sys.version_info[:3])'];
+function findPython(explicit) {
+  for (const [cmd, ...pre] of explicit ? [[explicit]] : pythonCandidates()) {
+    const result = spawnSync(cmd, [...pre, ...VERSION_PROBE], { shell: false, windowsHide: true, encoding: 'utf8' });
+    const version = result.status === 0 ? result.stdout.trim() : null;
+    if (supportedPython(version)) return { cmd, pre, version };
+  }
+  throw new Error(explicit ? 'python-unsupported: need Python 3.11-3.13' : 'python-not-found: install Python 3.11-3.13 or pass --python');
+}
+function plan(opts) {
+  const venvPy = venvPython(opts.dir);
+  const manifestPath = path.join(opts.dir, 'manifest.json');
+  return { dir: opts.dir, manifest: manifestPath,
+    steps: [
+      `create venv ${path.join(opts.dir, 'venv')} with ${opts.python || 'first Python 3.11-3.13 found'}`,
+      `${venvPy} -m pip install --index-url ${PINS.torchIndex} "${PINS.torchSpec}"`,
+      `${venvPy} -m pip install "${PINS.cuaS1Spec}"`,
+      ...Object.values(PINS.files).map(f => `download ${fileUrl(f.name)} (sha256 ${f.sha256})`),
+      `write ${manifestPath}`,
+      'verify provenance (pinned revision) and one real CPU inference',
+    ],
+    env: { HARNESS_SYSTEM_ONE_MODE: 'shadow', HARNESS_SYSTEM_ONE_CONFIG: manifestPath } };
+}
+function verify(manifestPath) {
+  const source = provenance(manifestPath);
+  const request = createRequest('tier', 'fix a typo in README', TIER_OPTIONS);
+  const start = performance.now();
+  const result = score(request, manifestPath);
+  const latencyMs = Math.round(performance.now() - start);
+  const decision = result.status === 'scored' ? decide(request, result.response) : result;
+  const scores = result.status === 'scored' && decision.status !== 'invalid-output' ? result.response.scores : null;
+  const ok = source.status === 'recorded' && source.provenance.cuaS1.sourceRevisionStatus === 'pinned' && scores !== null;
+  return { ok, source, decision, scores, latencyMs };
+}
+async function main(argv) {
+  const opts = parseArgs(argv);
+  const p = plan(opts);
+  if (opts.dryRun) { process.stdout.write(`${JSON.stringify({ dryRun: true, ...p }, null, 2)}\n`); return 0; }
+  const base = findPython(opts.python);
+  const venvPy = venvPython(opts.dir);
+  fs.mkdirSync(checkpointDir(opts.dir), { recursive: true });
+  if (!fs.existsSync(venvPy)) exec(base.cmd, [...base.pre, '-m', 'venv', path.join(opts.dir, 'venv')]);
+  const venvVersion = exec(venvPy, VERSION_PROBE, true);
+  if (!supportedPython(venvVersion)) throw new Error(`python-unsupported: existing venv uses ${venvVersion}`);
+  exec(venvPy, ['-m', 'pip', 'install', '--disable-pip-version-check', '--index-url', PINS.torchIndex, PINS.torchSpec]);
+  exec(venvPy, ['-m', 'pip', 'install', '--disable-pip-version-check', PINS.cuaS1Spec]);
+  for (const spec of Object.values(PINS.files)) {
+    console.error(`${spec.name}: ${await ensureFile(fileUrl(spec.name), path.join(checkpointDir(opts.dir), spec.name), spec)}`);
+  }
+  fs.writeFileSync(p.manifest, `${JSON.stringify(buildManifest(opts.dir, venvPy), null, 2)}\n`);
+  const check = verify(p.manifest);
+  process.stdout.write(`${JSON.stringify({ dryRun: false, ...p, verification: check }, null, 2)}\n`);
+  return check.ok ? 0 : 1;
+}
+if (require.main === module) {
+  main(process.argv.slice(2)).then(code => { process.exitCode = code; }, err => {
+    if (err.message === 'usage') { console.error(USAGE); process.exitCode = 2; return; }
+    console.error(`System One install failed: ${err.message}`); process.exitCode = 1;
+  });
+}
+module.exports = { PINS, fileUrl, venvPython, supportedPython, pythonCandidates, parseArgs, buildManifest, ensureFile, plan, verify };