harness-everything 0.27.0 → 0.29.0

package/docs/system-one-routing.md

@@ -103,6 +103,52 @@ responses are checked by Phase 0. Transport fixtures prove IPC and failure
 handling only. Real checkpoint inference and measured CPU latency remain a
 separate gate, with explicit unavailable evidence if dependencies are absent.
 
+## N-gram provider (Phase 4)
+
+`transport: "ngram"` scores in the Node process itself. It needs no Python, no
+torch, no resident server and no subprocess. It exists because a byte-level
+transformer trained from scratch learned little beyond class priors on the
+owner's data. A linear model over character n-grams learned more from the same
+labels at about 1 MB. See
+[harness-routing-v1-cpu-2026-09-24](../benchmarks/results/system-one/harness-routing-v1-cpu-2026-09-24/README.md).
+
+**Artifact.** The manifest `checkpoint` is an absolute path to `<name>.bin`, and
+`weightsSha256` is that file's hash. A `<name>.json` sidecar beside it has the
+hash `configSha256`. `python` is not required for this transport. The sidecar
+holds exactly:
+
+| Field | Value |
+| --- | --- |
+| `format` | `harness-ngram` |
+| `formatVersion` | `1` |
+| `dim` | Feature buckets, a power of two between 2^10 and 2^20 |
+| `nmax` | Longest n-gram, 1–4 |
+| `hash` | `fnv1a32` |
+| `catalog` | The option IDs in catalog order |
+| `bias` | One number per option |
+| `metadata` | An object with training provenance |
+
+`.bin` holds `dim × catalog.length` little-endian float32 weights in row-major
+order (feature, then option), so its size must equal `dim × options × 4` bytes.
+Both files are hash-checked before use. Any mismatch in hash, shape or field
+returns `provider-config` and never scores.
+
+**Features.** Featurization is identical in the trainer and the provider, and a
+cross-language test proves it.
+
+1. Lowercase the text and join its whitespace-separated parts with one space.
+2. For each n from 1 to `nmax`, take every n-gram of Unicode code points that is
+   not only spaces. Add it to bucket `fnv1a32("<n>:<gram>" as UTF-8) mod dim`.
+3. Add one length feature, bucket `fnv1a32("len:<k>") mod dim`, where
+   `k = min(8, floor(log2(utf8Bytes + 1)))`.
+4. Weight each bucket as `log(1 + count)` and L2-normalize the vector.
+
+**Scoring.** The probabilities are `softmax(x·W + bias)` in catalog order. The
+request's option IDs must equal `catalog`, or the result is `provider-config`.
+The response has the Phase 0 shape, and the manifest `acceptance` thresholds
+apply as for any transport. The Phase 0 context limit (64 KiB) is the only
+length limit.
+
 ## Resident provider (Phase 4 prerequisite)
 
 The one-shot bridge pays Python start, `import torch` and checkpoint load on every
@@ -262,6 +308,15 @@ The latter evidence is not supplied by this offline runner, so it always reports
 those gates pending. With the one-shot adapter, all latency is cold and the warm
 gate also remains pending. Exporting a report never changes router defaults.
 
+For the `ngram` transport, samples are recorded with `coldStart: false`, because
+scoring happens in process. The evaluator loads and verifies the artifact once
+before any timed sample, so that load is not part of the warm latency. The
+source check does not run the Python `cua_s1` probe, which this transport does
+not use. It records `{status: "recorded", transport: "ngram", artifactVerified}`,
+where `artifactVerified` is true only when both artifact files load and match
+their SHA-256 values. For this transport, the `sourceProvenance` gate passes
+when `artifactVerified` is true.
+
 ## Model suitability
 
 The [CUA-S1-FORMS model card](https://huggingface.co/cua-ai/cua-s1-forms)
@@ -286,11 +341,38 @@ unversioned download during a prompt hook.
 Phase 4 training data, labeling, calibration and release are defined in
 [system-one-training.md](system-one-training.md).
 
+## Staged classification
+
+System One answers three narrow questions in sequence instead of one broad
+question. Each stage is its own fixed catalog, scorer request and holdout, so a
+small model only has to separate a few options at a time.
+
+1. **Tier**: `tier1`, `tier2`, `tier3` or `unclassified`, following
+   [system-one-corpus.md](system-one-corpus.md).
+2. **Intent**: the kind of work the prompt asks for, drawn from a small fixed
+   catalog (for example: ask or explain, discuss or decide, Git/GitHub
+   operation, fix a bug, build a feature, refactor, review or audit, test or
+   verify, write docs, plan or spec, investigate). The intent catalog is the
+   owner's and is recorded in the corpus document before any intent labels.
+3. **Skills**: which canonical skills fit the prompt, scored against skill
+   descriptions. Only skills above the stage's calibrated threshold are
+   suggested, and they are suggestions, never required reads.
+
+Each stage has its own gates, and a stage ships only when it passes them. Tier
+comes first because the reviewed holdout exists for it. Later stages reuse the
+same collector, labeler, trainer and evaluator with a different catalog.
+Suggestions are advisory: explicit workflow requests, action gates, memory
+ownership, the Rule of 3 and deterministic policy always take precedence.
+
 ## Rollout gates
 
 Phase 4 requires a separately reviewed, family-disjoint holdout of at least 200
-cases, at least 50 each in English and Traditional Chinese. Accepted precision
-must be ≥98%, coverage ≥80%, and macro-F1 at least the lexical baseline.
+cases, at least 50 each in English and Traditional Chinese. System One output is
+advisory: it informs the agent and suggests skills. It never grants or removes
+policy. The owner therefore set the target at accepted precision ≥85% (the
+80–90% band), coverage ≥80%, and macro-F1 at least the lexical baseline. A
+probabilistic scorer small enough to ship inside a skills plugin (a few MB, not
+hundreds) is not expected to reach 98%.
 Policy invariants must remain intact in every case; repeat decisions twice with
 100% agreement. Record checkpoint/source hashes, CPU, OS, runtime, thread count,
 cold latency and warm p95 (target ≤100ms). Synthetic fixtures and mock providers

package/docs/system-one-training.md

@@ -104,7 +104,19 @@ prompts written by an agent, not by the owner. VS Code terminal notifications
 
 ## Training and calibration
 
-- **Model**: a new `cua_s1` `tinyx` scorer built with `make_system`.
+- **Tier engine**: `scripts/system-one-train-ngram.py` trains the `ngram` transport, a
+  multinomial logistic regression over hashed character n-gram features. Featurization
+  follows [system-one-routing.md](system-one-routing.md#n-gram-provider-phase-4).
+  - The trainer uses torch for the optimizer only. The features are stdlib Python and match
+    the Node provider exactly.
+  - The configuration (`nmax`, class weighting, weight decay) is chosen on validation
+    macro-F1. The first exploration picked `nmax` 3, square-root inverse-frequency class
+    weights and a weight decay of 1e-4.
+  - The output is the `.bin` weights, the `.json` sidecar and validation scores for
+    calibration.
+- The `tinyx` path below is kept for comparison. Its first checkpoint learned little beyond
+  class priors.
+- **Model** (`tinyx`): a new `cua_s1` `tinyx` scorer built with `make_system`.
   - Config: `width` 128, `rank` 128, `layers` 2, `heads` 4, `context_tokens` 1024 and
     `option_tokens` 96.
   - Weights are initialized fresh, not from the forms checkpoint, whose domain and
@@ -116,7 +128,7 @@ prompts written by an agent, not by the owner. VS Code terminal notifications
   - The epoch with the lowest validation negative log-likelihood is kept.
   - The checkpoint metadata records the dataset hashes, the config and the validation metrics.
 - **Calibration**: `minConfidence` and `minMargin` are chosen on validation to maximize
-  coverage, subject to an accepted precision of at least 98%. The router currently uses the
+  coverage, subject to an accepted precision of at least 85% (the owner's advisory target). The router currently uses the
   Phase 0 defaults (0.9 and 0.2). Carrying calibrated thresholds into the manifest is a
   separate contract change.
 

package/harness-everything/SKILL.md

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

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

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

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

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

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

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

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

package/package.json

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

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

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

package/plugins/harness-everything/plugin.json

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

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

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

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

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

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

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

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

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

package/sbom.cdx.json

@@ -2,23 +2,23 @@
   "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.7",
-  "serialNumber": "urn:uuid:0c1f9661-62c2-51a0-93aa-e317473be0d8",
+  "serialNumber": "urn:uuid:03c78df6-955e-5903-b3d9-620c6be8e2d4",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-27T17:23:19.452Z",
+    "timestamp": "2026-09-28T01:49:53.842Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.27.0"
+        "version": "0.29.0"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.27.0",
+      "bom-ref": "pkg:npm/harness-everything@0.29.0",
       "name": "harness-everything",
-      "version": "0.27.0",
-      "purl": "pkg:npm/harness-everything@0.27.0"
+      "version": "0.29.0",
+      "purl": "pkg:npm/harness-everything@0.29.0"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.27.0",
+      "ref": "pkg:npm/harness-everything@0.29.0",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",

package/scripts/evaluate-system-one.js

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

package/scripts/system-one-calibrate.js

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