harness-everything 0.22.0 → 0.22.1

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

@@ -5,6 +5,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { createHash } = require('node:crypto');
+const net = require('node:net');
 const { spawn } = require('node:child_process');
 const { Worker } = require('node:worker_threads');
 const { validateRequest } = require('./contract');
@@ -81,6 +82,20 @@ function callSync(port, message, timeoutMs = CALL_TIMEOUT_MS) {
   try { return { reply: JSON.parse(Buffer.from(out, 0, Atomics.load(signal, 1)).toString('utf8')) }; }
   catch (_) { return { error: 'json' }; }
 }
+// The same round trip for async callers (the hook entry): no worker thread to bootstrap.
+function callAsync(port, message, timeoutMs = CALL_TIMEOUT_MS) {
+  return new Promise(resolve => {
+    const chunks = []; let size = 0; let done = false; let socket = null;
+    const finish = value => { if (done) return; done = true; clearTimeout(timer); if (socket) socket.destroy(); resolve(value); };
+    const timer = setTimeout(() => finish({ error: 'timeout' }), timeoutMs);
+    socket = net.connect({ port, host: '127.0.0.1' }, () => socket.end(`${JSON.stringify(message)}\n`));
+    socket.on('data', c => { size += c.length; if (size > MAX_REPLY_BYTES) finish({ error: 'limit' }); else chunks.push(c); });
+    socket.on('end', () => {
+      try { finish({ reply: JSON.parse(Buffer.concat(chunks).toString('utf8')) }); } catch (_) { finish({ error: 'json' }); }
+    });
+    socket.on('error', e => finish({ error: e.code === 'ECONNREFUSED' ? 'refused' : 'io' }));
+  });
+}
 
 function start(manifest, files, deps) {
   const lock = lockInfo(files.lock);
@@ -114,7 +129,16 @@ function score(request, manifest, manifestPath, deps = {}) {
   const files = stateFiles(manifest, manifestPath);
   const state = liveState(files);
   if (!state) return start(manifest, files, deps);
-  const result = callSync(state.port, { token: state.token, op: 'score', request });
+  return outcome(callSync(state.port, { token: state.token, op: 'score', request }), files, state, manifest, deps);
+}
+async function scoreAsync(request, manifest, manifestPath, deps = {}) {
+  validateRequest(request);
+  const files = stateFiles(manifest, manifestPath);
+  const state = liveState(files);
+  if (!state) return start(manifest, files, deps);
+  return outcome(await callAsync(state.port, { token: state.token, op: 'score', request }), files, state, manifest, deps);
+}
+function outcome(result, files, state, manifest, deps) {
   if (result.reply) {
     if (result.reply.ok === true && Object.hasOwn(result.reply, 'response')) return { status: 'scored', response: result.reply.response };
     if (result.reply.ok === false) return unavailable(result.reply.reason === 'unauthorized' ? 'provider-unavailable' : 'provider-exit');
@@ -173,4 +197,4 @@ if (require.main === module) {
   if (op === 'stop') stop(manifest, manifestPath);
   process.stdout.write(`${JSON.stringify(status(manifest, manifestPath))}\n`);
 }
-module.exports = { stateFiles, readState, callSync, score, ensureReady, status, stop, LOCK_TTL_MS, CALL_TIMEOUT_MS };
+module.exports = { stateFiles, readState, callSync, callAsync, score, scoreAsync, ensureReady, status, stop, LOCK_TTL_MS, CALL_TIMEOUT_MS };

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

@@ -34,4 +34,20 @@ function selectTier(input, env = process.env, scorer = provider.score) {
   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 };
+// Hook entry: score the same fixed-catalog request asynchronously before routing (no sync worker bridge).
+// Returns a scorer for selectTier, or null when System One is off/invalid; nothing is called then.
+async function prescoreTier(prompt, env = process.env, scoreAsync = provider.scoreAsync) {
+  if (!['shadow', 'prefer'].includes(env.HARNESS_SYSTEM_ONE_MODE)) return null;
+  let request;
+  try { request = createRequest('tier', prompt, TIER_OPTIONS); }
+  catch (_) { return null; }
+  let result; let failed = false;
+  try { result = await scoreAsync(request, env.HARNESS_SYSTEM_ONE_CONFIG); }
+  catch (_) { failed = true; }
+  return (req, config) => {
+    if (req.requestHash !== request.requestHash) return provider.score(req, config);
+    if (failed) throw new Error('provider-unavailable');
+    return result;
+  };
+}
+module.exports = { selectTier, prescoreTier, TIER_OPTIONS };

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

@@ -231,7 +231,7 @@ function emitDynamicSkills(promptLower, context, recommendedGuides) {
   }
 }
 
-function run(userPrompt, context) {
+function run(userPrompt, context, options = {}) {
   console.log(`[Tier Routing Pre-check]`);
 
   const promptLower = userPrompt.toLowerCase();
@@ -317,7 +317,7 @@ function run(userPrompt, context) {
   const structuralFloor = hasMacroSignal ? 'tier3'
     : !isTrivialDocsEdit && hasMultipleTasks && hasMultipleSentences ? 'tier2' : null;
   const semantic = selectTier({ prompt: userPrompt, tier: recommendedTier, floor: structuralFloor,
-    explicit: Boolean(detectExplicitStrategy(userPrompt, detectFableModel(userPrompt))) });
+    explicit: Boolean(detectExplicitStrategy(userPrompt, detectFableModel(userPrompt))) }, process.env, options.systemOneScorer || undefined);
   if (semantic.diagnostic) console.log(`\n=> SYSTEM ONE: ${JSON.stringify(semantic.diagnostic)}`);
   if (semantic.diagnostic?.applied) {
     recommendedTier = semantic.tier;
@@ -460,12 +460,21 @@ function run(userPrompt, context) {
   return contract;
 }
 
+// Entry point: pre-score System One asynchronously so routing never needs the sync worker bridge.
+async function main(prompt, context) {
+  let systemOneScorer = null;
+  if (['shadow', 'prefer'].includes(process.env.HARNESS_SYSTEM_ONE_MODE)) {
+    try { systemOneScorer = await require('./system-one/router').prescoreTier(prompt); } catch (_) { /* the sync path still scores */ }
+  }
+  run(prompt, context, { systemOneScorer });
+}
+
 if (require.main === module) {
 let userPrompt = process.argv[2] || '';
 let hookContext = null;
 
 if (process.argv[2]) {
-  run(userPrompt);
+  main(userPrompt);
 } else if (process.stdin.isTTY) {
   run('');
 } else {
@@ -482,7 +491,7 @@ if (process.argv[2]) {
     } catch (err) {
       // Not valid JSON on stdin - fall back to argv/manual behavior.
     }
-    run(userPrompt, hookContext);
+    main(userPrompt, hookContext);
   });
 }
 }

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:0f18cc7a-103c-5369-a33b-bdbe1bf12efb",
+  "serialNumber": "urn:uuid:3cb9e1e8-a9f0-5bc4-87ab-794acb1e79c3",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-23T05:03:30.779Z",
+    "timestamp": "2026-09-23T11:35:56.699Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.22.0"
+        "version": "0.22.1"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.22.0",
+      "bom-ref": "pkg:npm/harness-everything@0.22.1",
       "name": "harness-everything",
-      "version": "0.22.0",
-      "purl": "pkg:npm/harness-everything@0.22.0"
+      "version": "0.22.1",
+      "purl": "pkg:npm/harness-everything@0.22.1"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.22.0",
+      "ref": "pkg:npm/harness-everything@0.22.1",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",

package/scripts/evaluate-system-one.js

@@ -4,12 +4,12 @@ const fs = require('node:fs');
 const os = require('node:os');
 const { performance } = require('node:perf_hooks');
 const { validateCorpus, evaluate } = require('../harness-everything/scripts/system-one/evaluate');
-const { score, provenance, readManifest } = require('../harness-everything/scripts/system-one/provider');
+const { scoreAsync, provenance, readManifest } = require('../harness-everything/scripts/system-one/provider');
 const resident = require('../harness-everything/scripts/system-one/resident');
 const { decide } = require('../harness-everything/scripts/system-one/contract');
 const { run: route } = require('../harness-everything/scripts/tier-router');
 
-function run(corpus, manifest) {
+async function run(corpus, manifest) {
   validateCorpus(corpus);
   let config = null;
   try { config = readManifest(manifest); } catch (_) { /* Missing provider remains an explicit unavailable measurement. */ }
@@ -28,7 +28,7 @@ function run(corpus, manifest) {
       const runs = [];
       for (let i = 0; i < 2; i++) {
         const start = performance.now();
-        const result = score(c.request, manifest);
+        const result = await scoreAsync(c.request, manifest);
         const decision = result.status === 'scored' ? decide(c.request, result.response) : result;
         if (decision.selectedId === 'unclassified') Object.assign(decision, { status: 'abstain', reason: 'unclassified', selectedId: null });
         const scores = ['accepted', 'abstain'].includes(decision.status) ? result.response.scores.map(s => s.probability) : null;
@@ -55,12 +55,12 @@ function run(corpus, manifest) {
     limitations: ['No independently verified holdout review', ...(warm ? [] : ['No warm inference measurement']), 'No live-host or policy evidence'] }, records };
 }
 if (require.main === module) {
-  try {
+  (async () => {
     const [input, manifest, output, extra] = process.argv.slice(2);
     if (!input || !manifest || !output || extra) throw new Error('usage');
-    const report = run(JSON.parse(fs.readFileSync(input, 'utf8')), manifest);
+    const report = await run(JSON.parse(fs.readFileSync(input, 'utf8')), manifest);
     fs.writeFileSync(output, JSON.stringify(report, null, 2) + '\n');
     console.log(JSON.stringify({ cases: report.cases, coverage: report.model.coverage, rolloutReady: report.rolloutReady }));
-  } catch (_) { console.error('System One evaluation failed: invalid corpus, arguments, or output path.'); process.exitCode = 1; }
+  })().catch(() => { console.error('System One evaluation failed: invalid corpus, arguments, or output path.'); process.exitCode = 1; });
 }
 module.exports = { run };