harness-everything 0.21.0 → 0.22.1

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:8d95a5fe-dcbc-5aa9-8dc9-f8d6eae221da",
+  "serialNumber": "urn:uuid:3cb9e1e8-a9f0-5bc4-87ab-794acb1e79c3",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-23T03:35:45.203Z",
+    "timestamp": "2026-09-23T11:35:56.699Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.21.0"
+        "version": "0.22.1"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.21.0",
+      "bom-ref": "pkg:npm/harness-everything@0.22.1",
       "name": "harness-everything",
-      "version": "0.21.0",
-      "purl": "pkg:npm/harness-everything@0.21.0"
+      "version": "0.22.1",
+      "purl": "pkg:npm/harness-everything@0.22.1"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.21.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/build-openai-submission.js

@@ -4,6 +4,7 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { isPackagingNoise } = require('./lib/packaging-noise');
 
 const ROOT = path.resolve(__dirname, '..');
 const SKILLS_ROOT = path.join(ROOT, 'plugins', 'harness-everything', 'skills');
@@ -24,6 +25,7 @@ function parseArgs(argv) {
 
 function filesUnder(root, base = root, out = []) {
   for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (isPackagingNoise(entry.name)) continue;
     const full = path.join(root, entry.name);
     if (entry.isDirectory()) filesUnder(full, base, out);
     else if (entry.isFile()) out.push(path.relative(base, full).replace(/\\/g, '/'));

package/scripts/evaluate-system-one.js

@@ -4,12 +4,19 @@ 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 } = 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. */ }
+  // 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);
   const records = [];
   const originalMode = process.env.HARNESS_SYSTEM_ONE_MODE;
   const originalLog = console.log;
@@ -21,15 +28,16 @@ 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;
-        runs.push({ decision, scores, latencyMs: performance.now() - start, coldStart: true });
+        runs.push({ decision, scores, latencyMs: performance.now() - start, coldStart: !warm });
       }
       records.push({ id: c.id, baseline: tier === 'unclassified' ? null : tier, runs });
     }
   } finally {
+    if (warm && !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;
@@ -40,18 +48,19 @@ function run(corpus, manifest) {
     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: 'offline-one-shot', artifact, source,
+  return { ...evaluate(corpus, records, source), evidence: { kind: warm ? 'offline-resident' : 'offline-one-shot', artifact, source,
+    residentReady: warm ? 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 },
-    limitations: ['No independently verified holdout review', 'No warm inference measurement', 'No live-host or policy evidence'] }, records };
+    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 };

package/scripts/lib/packaging-noise.js

@@ -0,0 +1,6 @@
+'use strict';
+// Untracked local/CI build artifacts that no distribution (installer copy, plugin mirror,
+// public submission) may ship, even when they exist in the working tree.
+const isPackagingNoise = name => name === '__pycache__' || /\.py[co]$/.test(name);
+
+module.exports = { isPackagingNoise };

package/scripts/lib/skills.js

@@ -2,11 +2,13 @@
 const fs = require('fs');
 const path = require('path');
 const manifest = require('./manifest');
+const { isPackagingNoise } = require('./packaging-noise');
 
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
   const entries = fs.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
+    if (isPackagingNoise(entry.name)) continue;
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
     if (entry.isDirectory()) copyDir(srcPath, destPath);

package/scripts/sync-openai-plugin.js

@@ -3,6 +3,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { isPackagingNoise } = require('./lib/packaging-noise');
 
 const ROOT = path.resolve(__dirname, '..');
 const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, '.claude-plugin', 'plugin.json'), 'utf8'));
@@ -32,7 +33,7 @@ function syncTree(source, destination) {
   fs.rmSync(destination, { recursive: true, force: true });
   fs.mkdirSync(path.dirname(destination), { recursive: true });
   if (fs.statSync(source).isDirectory()) {
-    fs.cpSync(source, destination, { recursive: true });
+    fs.cpSync(source, destination, { recursive: true, filter: src => !isPackagingNoise(path.basename(src)) });
     normalizeTree(destination);
   } else {
     fs.copyFileSync(source, destination);