harness-everything 0.22.0 → 0.22.1

package/ci/fixtures/system-one-worker-probe.js

@@ -0,0 +1,15 @@
+'use strict';
+// Preload (NODE_OPTIONS --require) that proves which System One client path ran.
+// HARNESS_TEST_WORKER_MODE=deny makes every worker thread fail to start; =count records
+// how many were started into HARNESS_TEST_WORKER_COUNT_FILE when the process exits.
+const fs = require('node:fs');
+const threads = require('node:worker_threads');
+const mode = process.env.HARNESS_TEST_WORKER_MODE;
+const Original = threads.Worker;
+let count = 0;
+if (mode === 'deny') {
+  threads.Worker = class { constructor() { throw new Error('worker-disabled-by-test'); } };
+} else if (mode === 'count') {
+  threads.Worker = class extends Original { constructor(...args) { count += 1; super(...args); } };
+  process.on('exit', () => fs.writeFileSync(process.env.HARNESS_TEST_WORKER_COUNT_FILE, String(count)));
+}

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

@@ -33,6 +33,16 @@ function cleanup(f) {
   try { resident.stop(f.manifest, f.manifestPath); } catch (_) { /* best effort */ }
   fs.rmSync(f.dir, { recursive: true, force: true });
 }
+// A client view whose state file names the live server with a wrong token. The server polls only its own
+// state file and exits once that file stops naming it, so rewriting it would race the wrong-token request.
+function wrongTokenView(f) {
+  const good = JSON.parse(fs.readFileSync(resident.stateFiles(f.manifest, f.manifestPath).state, 'utf8'));
+  const viewDir = fs.mkdtempSync(path.join(f.dir, 'client-view-'));
+  const manifestPath = path.join(viewDir, 'manifest.json');
+  fs.writeFileSync(manifestPath, JSON.stringify(f.manifest));
+  fs.writeFileSync(resident.stateFiles(f.manifest, manifestPath).state, JSON.stringify({ ...good, token: 'b'.repeat(64) }));
+  return manifestPath;
+}
 
 test('S1-RS01 manifest transport fields and digest-bound file names', () => {
   const f = fixture();
@@ -80,10 +90,9 @@ test('S1-RS03 stale state is removed and replaced; a wrong token is rejected wit
     assert.equal(f.spawns.length, 1);
     assert.equal(resident.ensureReady(f.manifest, f.manifestPath, 20000, f.deps), true);
     const good = JSON.parse(fs.readFileSync(state, 'utf8'));
-    fs.writeFileSync(state, JSON.stringify({ ...good, token: 'b'.repeat(64) }));
-    assert.deepEqual(resident.score(request, f.manifest, f.manifestPath, f.deps), { status: 'unavailable', reason: 'provider-unavailable' });
+    assert.deepEqual(resident.score(request, f.manifest, wrongTokenView(f), f.deps), { status: 'unavailable', reason: 'provider-unavailable' });
     assert.equal(f.spawns.length, 1);
-    fs.writeFileSync(state, JSON.stringify(good));
+    assert.equal(resident.status(f.manifest, f.manifestPath).running, true, 'a wrong token does not stop the server');
     for (const bad of ['not-json', JSON.stringify({ ...good, extra: 1 }), JSON.stringify({ ...good, token: 'short' })]) {
       fs.writeFileSync(state, bad);
       assert.equal(resident.status(f.manifest, f.manifestPath).running, false);
@@ -183,3 +192,105 @@ test('S1-RS09 a corrupted state file never leaves an orphan server behind', () =
     assert.equal(resident.status(f.manifest, f.manifestPath).pid, fresh.pid);
   } finally { cleanup(f); }
 });
+
+test('S1-RS10 scoreAsync matches the sync client and keeps every start/failure mapping', async () => {
+  const f = fixture();
+  try {
+    assert.deepEqual(await resident.scoreAsync(request, f.manifest, f.manifestPath, f.deps), { status: 'unavailable', reason: 'provider-starting' });
+    assert.deepEqual(await resident.scoreAsync(request, f.manifest, f.manifestPath, f.deps), { status: 'unavailable', reason: 'provider-starting' });
+    assert.deepEqual(f.spawns, ['stub']);
+    assert.equal(resident.ensureReady(f.manifest, f.manifestPath, 20000, f.deps), true);
+    const sync = resident.score(request, f.manifest, f.manifestPath, f.deps);
+    assert.equal(sync.status, 'scored');
+    assert.deepEqual(await resident.scoreAsync(request, f.manifest, f.manifestPath, f.deps), sync);
+    assert.deepEqual(await resident.scoreAsync(request, f.manifest, f.manifestPath, f.deps), sync);
+    assert.deepEqual(await resident.scoreAsync(request, f.manifest, wrongTokenView(f), f.deps), { status: 'unavailable', reason: 'provider-unavailable' });
+    await assert.rejects(resident.scoreAsync({ ...request, extra: 1 }, f.manifest, f.manifestPath, f.deps));
+    assert.equal(f.spawns.length, 1);
+  } finally { cleanup(f); }
+});
+
+test('S1-RS10b scoreAsync removes refused state, restarts once, and times out slow servers', async () => {
+  const f = fixture();
+  // A live PID that is not this test process: cleanup may kill whatever the state file names.
+  const sleeper = require('node:child_process').spawn(process.execPath, ['-e', 'setTimeout(() => {}, 60000)'], { stdio: 'ignore' });
+  try {
+    const net = require('node:net');
+    const closed = net.createServer();
+    await new Promise(resolve => closed.listen(0, '127.0.0.1', resolve));
+    const port = closed.address().port;
+    await new Promise(resolve => closed.close(resolve));
+    const { state } = resident.stateFiles(f.manifest, f.manifestPath);
+    fs.writeFileSync(state, JSON.stringify({ schemaVersion: 1, pid: sleeper.pid, port, token: 'a'.repeat(64), startedAt: 1 }));
+    assert.deepEqual(await resident.scoreAsync(request, f.manifest, f.manifestPath, f.deps), { status: 'unavailable', reason: 'provider-starting' });
+    assert.deepEqual(f.spawns, ['stub']);
+  } finally { sleeper.kill(); cleanup(f); }
+  const slow = fixture('stub-slow');
+  try {
+    assert.equal(resident.ensureReady(slow.manifest, slow.manifestPath, 20000, slow.deps), true);
+    const start = Date.now();
+    assert.deepEqual(await resident.scoreAsync(request, slow.manifest, slow.manifestPath, slow.deps), { status: 'unavailable', reason: 'provider-timeout' });
+    assert.ok(Date.now() - start < 2500);
+    assert.equal(slow.spawns.length, 1);
+  } finally { cleanup(slow); }
+});
+
+test('S1-RS10c provider.scoreAsync dispatches by transport with the sync result shapes', async () => {
+  const f = fixture();
+  try {
+    assert.deepEqual(await provider.scoreAsync(request, path.join(f.dir, 'missing.json')), { status: 'unavailable', reason: 'provider-config' });
+    assert.deepEqual(await provider.scoreAsync(request, 'relative.json'), { status: 'unavailable', reason: 'provider-config' });
+    assert.equal(resident.ensureReady(f.manifest, f.manifestPath, 20000, f.deps), true);
+    assert.deepEqual(await provider.scoreAsync(request, f.manifestPath), provider.score(request, f.manifestPath));
+    const oneshot = path.join(f.dir, 'oneshot.json');
+    fs.writeFileSync(oneshot, JSON.stringify({ ...f.manifest, transport: 'oneshot' }));
+    assert.deepEqual(await provider.scoreAsync(request, oneshot), provider.score(request, oneshot));
+  } finally { cleanup(f); }
+});
+
+// The probe preload proves which client path ran inside a real child process.
+const probeEnv = (mode, extra = {}) => ({ ...process.env,
+  NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --require ./ci/fixtures/system-one-worker-probe.js`.trim(),
+  HARNESS_TEST_WORKER_MODE: mode, ...extra });
+
+test('S1-RS11 the hook entry pre-scores over async IPC: it still scores when worker threads cannot start', () => {
+  const f = fixture();
+  const root = path.resolve(__dirname, '..');
+  try {
+    assert.equal(resident.ensureReady(f.manifest, f.manifestPath, 20000, f.deps), true);
+    const env = probeEnv('deny', { HARNESS_SYSTEM_ONE_MODE: 'shadow', HARNESS_SYSTEM_ONE_CONFIG: f.manifestPath });
+    const kernel = path.join(root, 'harness-everything/scripts/kernel-router-core.js');
+    const diagnostic = out => JSON.parse(out.match(/=> SYSTEM ONE: (.*)/)[1]);
+    const argv = spawnSync(process.execPath, [kernel, 'fix a typo in README'], { cwd: root, encoding: 'utf8', env });
+    assert.equal(argv.status, 0, argv.stderr);
+    assert.equal(diagnostic(argv.stdout).status, 'accepted');
+    const hook = spawnSync(process.execPath, [kernel], { cwd: root, encoding: 'utf8', env, input: JSON.stringify({ prompt: 'fix a typo in README' }) });
+    assert.equal(hook.status, 0, hook.stderr);
+    assert.equal(diagnostic(hook.stdout).status, 'accepted');
+    const off = spawnSync(process.execPath, [kernel, 'fix a typo in README'], { cwd: root, encoding: 'utf8', env: { ...env, HARNESS_SYSTEM_ONE_MODE: 'off' } });
+    assert.equal(off.status, 0, off.stderr);
+    assert.doesNotMatch(off.stdout, /SYSTEM ONE/);
+    assert.equal(f.spawns.length, 1);
+  } finally { cleanup(f); }
+});
+
+test('S1-RS12 the evaluator times the async path: no worker thread per warm score', () => {
+  const f = fixture();
+  const root = path.resolve(__dirname, '..');
+  try {
+    assert.equal(resident.ensureReady(f.manifest, f.manifestPath, 20000, f.deps), true);
+    const countFile = path.join(f.dir, 'workers.txt');
+    const output = path.join(f.dir, 'report.json');
+    const corpus = path.join(root, 'benchmarks/fixtures/system-one-routing.json');
+    const child = spawnSync(process.execPath, [path.join(root, 'scripts/evaluate-system-one.js'), corpus, f.manifestPath, output],
+      { cwd: root, encoding: 'utf8', env: probeEnv('count', { HARNESS_TEST_WORKER_COUNT_FILE: countFile }) });
+    assert.equal(child.status, 0, child.stderr);
+    const report = JSON.parse(fs.readFileSync(output, 'utf8'));
+    assert.equal(report.evidence.residentReady, true);
+    // Every sample reached the warm server (the seed's one over-limit context is a declined provider-exit).
+    const runs = report.records.flatMap(r => r.runs);
+    assert.ok(runs.every(run => run.coldStart === false && ['accepted', 'provider-exit'].includes(run.decision.status === 'accepted' ? 'accepted' : run.decision.reason)));
+    assert.ok(runs.filter(run => run.decision.status === 'accepted').length >= runs.length - 2);
+    assert.ok(Number(fs.readFileSync(countFile, 'utf8')) < report.records.length * 2, 'warm scores must not start a worker thread each');
+  } finally { cleanup(f); }
+});

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

@@ -99,3 +99,28 @@ test('S1-R05 structural floor: a scorer can raise but never lower a deterministi
     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; }
 });
+test('S1-R06 prescoreTier: off loads nothing; a matching request reuses the async result; mismatch and failure keep sync semantics', async () => {
+  const { prescoreTier } = require('../harness-everything/scripts/system-one/router');
+  const provider = require('../harness-everything/scripts/system-one/provider');
+  const forbidden = () => { throw new Error('must not invoke'); };
+  for (const env of [{}, { HARNESS_SYSTEM_ONE_MODE: 'off' }, { HARNESS_SYSTEM_ONE_MODE: 'bogus' }]) assert.equal(await prescoreTier('實作功能', env, forbidden), null);
+  assert.equal(await prescoreTier('', { HARNESS_SYSTEM_ONE_MODE: 'shadow' }, forbidden), null);
+  const env = { HARNESS_SYSTEM_ONE_MODE: 'prefer', HARNESS_SYSTEM_ONE_CONFIG: '/abs/manifest.json' };
+  const input = { prompt: '實作功能', tier: 'Unclassified' };
+  const configs = [];
+  const pre = await prescoreTier(input.prompt, env, async (req, config) => { configs.push(config); return scorer('tier2')(req); });
+  assert.deepEqual(configs, ['/abs/manifest.json']);
+  assert.deepEqual(selectTier(input, env, pre), selectTier(input, env, scorer('tier2')));
+  const original = provider.score;
+  try {
+    let used = 0;
+    provider.score = req => { used += 1; return scorer('tier3')(req); };
+    assert.equal(selectTier({ ...input, prompt: 'different prompt' }, env, pre).tier, 'Tier 3 (Macro Task)');
+    assert.equal(used, 1);
+  } finally { provider.score = original; }
+  const failing = await prescoreTier(input.prompt, env, async () => { throw new Error('secret'); });
+  const failed = selectTier(input, env, failing);
+  assert.deepEqual(failed, selectTier(input, env, () => { throw new Error('secret'); }));
+  assert.equal(failed.diagnostic.reason, 'provider-unavailable');
+  assert.ok(!JSON.stringify(failed).includes('secret'));
+});

package/docs/platform-capabilities.md

@@ -130,7 +130,12 @@ 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.
 With `transport: "resident"`, an opted-in router hook may spawn one detached
-loopback-only Python server per manifest; host survival of that process after
-a hook exits is not live-verified.
+loopback-only Python server per manifest. One retained Windows + Claude Code
+headless session showed the hook-spawned server outliving the host; macOS/Linux
+and Codex hosts are not live-verified, and this does not change the matrix.
+Hooks read the mode from the host process environment: Claude Code settings
+`env` reaches hooks and every agent-run command, while a Codex started from an
+ordinary terminal sees it only when set at user/OS level. Keep the mode `off`
+until a Harness-trained checkpoint passes the rollout gates.
 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.

package/docs/system-one-routing.md

@@ -148,9 +148,21 @@ format, which Phase 0 validation still checks. Any other failure returns
 `{ok: false, reason}` with a bounded code; no prompt, traceback, path or score is
 echoed in errors. The server never executes actions and is not given a driver.
 
-**Client.** The router API is synchronous, so the client performs one socket
-round trip on a worker thread and waits with `Atomics.wait` (1000 ms deadline).
-Results map to the existing reasons: timeout → `provider-timeout` (no respawn);
+**Client.** The hook entry pre-scores asynchronously. When `tier-router.js` runs
+as a script (the kernel and packaged hooks spawn it) in `shadow` or `prefer`
+mode, it builds the fixed-catalog tier request before routing and makes one
+direct async loopback round trip (`scoreAsync`), with no worker thread. Start,
+lock, stale-state, deadline (1000 ms) and reply-limit (1 MiB) rules are the same
+as the synchronous path. The router uses the pre-scored result only when its
+request hash equals the request the router builds; otherwise it scores
+synchronously. A pre-score error is reported exactly as a synchronous scorer
+error would be. In `off` mode the entry neither pre-scores nor contacts a
+provider. The synchronous `score` API remains for programmatic callers: it
+makes the same round trip on a worker thread and waits with `Atomics.wait`.
+Starting that worker costs 29–41 ms per call on the reference host, which is why
+the hook avoids it. The paired measurements are in
+[cua-s1-forms-resident-async-cpu-2026-09-23](../benchmarks/results/system-one/cua-s1-forms-resident-async-cpu-2026-09-23/README.md).
+Both paths map results to the existing reasons: timeout → `provider-timeout` (no respawn);
 refused connection or dead PID → stale state removed and a new start
 (`provider-starting`); `unauthorized` → `provider-unavailable`; any other
 server-declined request → `provider-exit`; malformed replies → `provider-json`.
@@ -158,7 +170,9 @@ server-declined request → `provider-exit`; malformed replies → `provider-jso
 **Operators.** `node harness-everything/scripts/system-one/resident.js
 start|status|stop <absolute manifest>` controls a server explicitly; `start`
 waits up to 60 s for readiness. The evaluation CLI waits for readiness before
-measuring, so resident runs are recorded with `coldStart: false`. The installer
+measuring, so resident runs are recorded with `coldStart: false`. It times
+`scoreAsync`, the path the hook uses, so `warmLatency` measures what a prompt
+actually pays. The installer
 writes `transport: "resident"`, verifies one resident score, and stops the server
 it started. Repository tests use a stub scorer behind the real server/protocol
 code; they prove the mechanism, not host survival of detached processes or model
@@ -195,6 +209,11 @@ selected candidate, model identity, confidence and margin; it omits prompt text,
 score vectors and artifact paths. The existing router contract schema is unchanged.
 Kernel/packaged entry points inherit these host environment variables. Prompts
 and hook payload fields cannot set model configuration or launch executables.
+Claude Code settings `env` is hot-reloaded and reaches hooks and every command
+the agent runs; Codex hooks inherit the `codex` process environment, so a Codex
+started from an ordinary terminal needs user/OS-level variables (which then apply
+to every program the user starts). The recommended setting is `off` until a
+`harness-routing-v1` checkpoint passes the rollout gates.
 Repository tests establish mechanism/package evidence only; actual host loading
 and semantic quality remain unverified until retained sessions demonstrate them.
 

package/evals/pilot-router-nonsoftware/graders/no-tier-language.md

@@ -0,0 +1,6 @@
+---
+type: regex
+pattern: '(Tier 1|Tier 2|Tier 3|Routing Checkpoint)'
+match: not_contains
+weight: 1
+---

package/evals/pilot-router-nonsoftware/graders/skill-not-fired.md

@@ -0,0 +1,9 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?harness-everything"'
+min: 0
+max: 0
+arm: both
+weight: 1
+---

package/evals/pilot-router-nonsoftware/prompt.md

@@ -0,0 +1,8 @@
+---
+max_turns: 10
+allowed_tools: [Read, Glob, Grep, Skill]
+tags: [pilot, negative-trigger]
+description: "Casual non-software small talk must not engage the harness-everything router."
+---
+
+What's the difference between latte and cappuccino?

package/evals/pilot-router-tier3/graders/skill-fired.md

@@ -0,0 +1,6 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?harness-everything"'
+weight: 1
+---

package/evals/pilot-router-tier3/prompt.md

@@ -0,0 +1,8 @@
+---
+max_turns: 15
+allowed_tools: [Read, Glob, Grep, Skill]
+tags: [pilot, positive-trigger, tier-3]
+description: "Architectural, repo-wide request should route through the harness-everything router and land on Tier 3."
+---
+
+Route this coding request: split our monolith into two services (orders and billing) with an event bus between them; this touches deployment, data migration, and every team's code.

package/evals/pilot-tdd-bugfix/graders/skill-fired.md

@@ -0,0 +1,6 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?tdd"'
+weight: 1
+---

package/evals/pilot-tdd-bugfix/prompt.md

@@ -0,0 +1,8 @@
+---
+max_turns: 15
+allowed_tools: [Read, Glob, Grep, Skill]
+tags: [pilot, positive-trigger]
+description: "A bug-fix request that asks for a regression test should engage the tdd skill's RED/GREEN loop."
+---
+
+Fix a bug with a regression test: the discount calculation rounds wrong for prices ending in .99.

package/evals/pilot-tdd-trivia/graders/no-red-phase-claim.md

@@ -0,0 +1,7 @@
+---
+type: regex
+pattern: '(writing a failing test now|entering RED)'
+flags: i
+match: not_contains
+weight: 1
+---

package/evals/pilot-tdd-trivia/graders/skill-not-fired.md

@@ -0,0 +1,9 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?tdd"'
+min: 0
+max: 0
+arm: both
+weight: 1
+---

package/evals/pilot-tdd-trivia/prompt.md

@@ -0,0 +1,8 @@
+---
+max_turns: 10
+allowed_tools: [Read, Glob, Grep, Skill]
+tags: [pilot, negative-trigger]
+description: "A one-line trivia question about TDD terminology must not start a RED/GREEN test-writing loop."
+---
+
+In one sentence, what does the RED phase of test-driven development mean?

package/evals/pilot-verify-discussion/graders/no-verification-claim.md

@@ -0,0 +1,7 @@
+---
+type: regex
+pattern: '(running the verification report|verification passed)'
+flags: i
+match: not_contains
+weight: 1
+---

package/evals/pilot-verify-discussion/graders/skill-not-fired.md

@@ -0,0 +1,9 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?verification-loop"'
+min: 0
+max: 0
+arm: both
+weight: 1
+---

package/evals/pilot-verify-discussion/prompt.md

@@ -0,0 +1,8 @@
+---
+max_turns: 10
+allowed_tools: [Read, Glob, Grep, Skill]
+tags: [pilot, negative-trigger]
+description: "A design discussion with no completed work must not launch the verification-loop skill."
+---
+
+Sketch two possible approaches for caching API responses and list trade-offs. Don't write any code yet.

package/evals/pilot-verify-preship/graders/skill-fired.md

@@ -0,0 +1,6 @@
+---
+type: tool_used
+tool: Skill
+input_match: '"skill"\s*:\s*"(?:[\w-]+:)?verification-loop"'
+weight: 1
+---

package/evals/pilot-verify-preship/prompt.md

@@ -0,0 +1,8 @@
+---
+max_turns: 15
+allowed_tools: [Read, Glob, Grep, Skill]
+tags: [pilot, positive-trigger]
+description: "A pre-completion request to prove work is done should trigger the verification-loop skill."
+---
+
+You said the refactor is finished. Run the full verification loop and show me the evidence before we call this done.

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.22.0
+  version: 0.22.1
 ---
 
 # Harness Everything

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

@@ -51,7 +51,19 @@ function score(request, manifestPath) {
   let manifest;
   try { manifest = readManifest(manifestPath); } catch (_) { return unavailable('provider-config'); }
   if (manifest.transport === 'resident') return require('./resident').score({ ...request }, manifest, manifestPath);
-  // Send the exact validated manifest to the child on stdin: no config reread race.
+  return oneShot(request, manifest);
+}
+// 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 === 'resident') return require('./resident').scoreAsync({ ...request }, manifest, manifestPath);
+  return oneShot(request, manifest);
+}
+// Send the exact validated manifest to the child on stdin: no config reread race.
+function oneShot(request, manifest) {
   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.
@@ -76,4 +88,4 @@ function provenance(manifestPath) {
   try { return { status: 'recorded', provenance: validateProvenance(result.value) }; }
   catch (_) { return unavailable('provider-json'); }
 }
-module.exports = { score, runProvider, validateManifest, readManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION };
+module.exports = { score, scoreAsync, runProvider, validateManifest, readManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION };

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "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.22.0",
+  "version": "0.22.1",
   "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.22.0",
+  "version": "0.22.1",
   "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.22.0
+  version: 0.22.1
 ---
 
 # Harness Everything

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

@@ -51,7 +51,19 @@ function score(request, manifestPath) {
   let manifest;
   try { manifest = readManifest(manifestPath); } catch (_) { return unavailable('provider-config'); }
   if (manifest.transport === 'resident') return require('./resident').score({ ...request }, manifest, manifestPath);
-  // Send the exact validated manifest to the child on stdin: no config reread race.
+  return oneShot(request, manifest);
+}
+// 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 === 'resident') return require('./resident').scoreAsync({ ...request }, manifest, manifestPath);
+  return oneShot(request, manifest);
+}
+// Send the exact validated manifest to the child on stdin: no config reread race.
+function oneShot(request, manifest) {
   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.
@@ -76,4 +88,4 @@ function provenance(manifestPath) {
   try { return { status: 'recorded', provenance: validateProvenance(result.value) }; }
   catch (_) { return unavailable('provider-json'); }
 }
-module.exports = { score, runProvider, validateManifest, readManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION };
+module.exports = { score, scoreAsync, runProvider, validateManifest, readManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION };