harness-everything 0.21.0 → 0.22.1

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

@@ -1,9 +1,16 @@
 """Optional CPU CUA-S1 bridge. Stdout is protocol-only; never execute UI actions."""
 import hashlib
+import hmac
 import json
+import os
 from pathlib import Path
 import re
+import secrets
+import socket
+import subprocess
 import sys
+import threading
+import time
 
 
 def verify_artifacts(manifest):
@@ -25,18 +32,23 @@ def check_limits(request, config):
         raise ValueError('input-too-long')
 
 
-def infer(request, manifest):
-    weights = verify_artifacts(manifest)
+def load_scorer(weights, manifest):
+    """Load the verified checkpoint once; return (score(request) -> probabilities, config)."""
     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()
+
+    def score(request):
+        example = ChoiceExample(context=request['context'], options=tuple(o['text'] for o in request['options']), label=0)
+        with torch.inference_mode():
+            return model(collator([example])).softmax(-1)[0].tolist()
+    return score, config
+
+
+def build_response(request, manifest, probabilities):
     return {
         'schemaVersion': 1, 'requestHash': request['requestHash'], 'catalogHash': request['catalogHash'],
         'model': {'id': manifest['modelId'], 'revision': manifest['revision'], 'domain': manifest['domain']},
@@ -44,6 +56,251 @@ def infer(request, manifest):
     }
 
 
+def infer(request, manifest):
+    weights = verify_artifacts(manifest)
+    score, config = load_scorer(weights, manifest)
+    check_limits(request, config)
+    return build_response(request, manifest, score(request))
+
+
+MAX_REQUEST_BYTES = 2 * 1024 * 1024
+MAX_OPTIONS = 256
+MAX_CLIENTS = 64
+READ_DEADLINE_S = 1.0  # never longer than the Node client's 1000 ms call deadline
+STARTUP_REASONS = ('artifact-hash', 'checkpoint-format')
+ID_PATTERN = re.compile(r'[a-z0-9._-]{1,80}')
+HASH_PATTERN = re.compile(r'[0-9a-f]{64}')
+_USER_SID = []
+
+
+def _artifact_stamp(weights):
+    return [(p.stat().st_size, p.stat().st_mtime_ns) for p in (weights, weights.with_suffix('.json'))]
+
+
+def _restrict_to_current_user(path):
+    """Windows: replace the whole DACL with one protected full-control ACE for the current user.
+
+    Editing ACEs is not enough: some hosts create files with explicit (non-inherited) SYSTEM,
+    Administrators or OWNER RIGHTS entries that survive `icacls /inheritance:r /grant:r`.
+    """
+    if os.name != 'nt':
+        return
+    import ctypes
+    from ctypes import wintypes
+    if not _USER_SID:
+        tools = Path(os.environ.get('SystemRoot', 'C:/Windows')) / 'System32'
+        out = subprocess.run([str(tools / 'whoami.exe'), '/user', '/fo', 'csv', '/nh'],
+                             capture_output=True, text=True, timeout=10, check=True).stdout
+        sid = out.strip().split(',')[-1].strip().strip('"')
+        if not re.fullmatch(r'S-1-[0-9-]+', sid):
+            raise OSError('user-sid')
+        _USER_SID.append(sid)
+    advapi32 = ctypes.WinDLL('advapi32', use_last_error=True)
+    kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+    descriptor = ctypes.c_void_p()
+    if not advapi32.ConvertStringSecurityDescriptorToSecurityDescriptorW(
+            f'D:P(A;;FA;;;{_USER_SID[0]})', 1, ctypes.byref(descriptor), None):
+        raise OSError('dacl-build')
+    try:
+        present, defaulted, dacl = wintypes.BOOL(), wintypes.BOOL(), ctypes.c_void_p()
+        if not advapi32.GetSecurityDescriptorDacl(descriptor, ctypes.byref(present), ctypes.byref(dacl), ctypes.byref(defaulted)):
+            raise OSError('dacl-read')
+        SE_FILE_OBJECT, DACL_INFO, PROTECTED_DACL_INFO = 1, 0x4, 0x80000000
+        advapi32.SetNamedSecurityInfoW.argtypes = [wintypes.LPWSTR, ctypes.c_int, wintypes.DWORD,
+                                                   ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+        if advapi32.SetNamedSecurityInfoW(str(path), SE_FILE_OBJECT, DACL_INFO | PROTECTED_DACL_INFO, None, None, dacl, None) != 0:
+            raise OSError('dacl-set')
+    finally:
+        kernel32.LocalFree(descriptor)
+
+
+def _write_private_json(target, value):
+    """Atomic replace of an owner-only file (0600; explicit owner-only DACL on Windows) before the token is written."""
+    tmp = target.with_name(f'.{target.name}.{os.getpid()}.{secrets.token_hex(4)}.tmp')
+    os.close(os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600))
+    _restrict_to_current_user(tmp)
+    with open(tmp, 'w', encoding='utf-8') as handle:
+        json.dump(value, handle)
+    os.replace(tmp, target)
+
+
+def _read_request_line(conn):
+    buffer = bytearray()
+    while b'\n' not in buffer and len(buffer) <= MAX_REQUEST_BYTES:
+        chunk = conn.recv(65536)
+        if not chunk:
+            break
+        buffer.extend(chunk)
+    if len(buffer.split(b'\n', 1)[0]) > MAX_REQUEST_BYTES:
+        # Drain to EOF (bounded by size and the read deadline) so the reply is not lost to a reset.
+        drained = 0
+        try:
+            while drained < 8 * MAX_REQUEST_BYTES and conn.recv(65536):
+                drained += 65536
+        except OSError:
+            pass
+        raise ValueError('request-limit')
+    return bytes(buffer).split(b'\n', 1)[0]
+
+
+def _valid_score_request(request):
+    """Phase 0 request structure. Hashes are fingerprints, not authentication, so they are shape-checked only."""
+    if (not isinstance(request, dict)
+            or set(request) != {'schemaVersion', 'task', 'context', 'options', 'catalogHash', 'requestHash'}
+            or request['schemaVersion'] != 1 or not isinstance(request['task'], str) or not ID_PATTERN.fullmatch(request['task'])
+            or not isinstance(request['context'], str)
+            or not all(isinstance(request[k], str) and HASH_PATTERN.fullmatch(request[k]) for k in ('catalogHash', 'requestHash'))):
+        return False
+    options = request['options']
+    if not isinstance(options, list) or not 2 <= len(options) <= MAX_OPTIONS:
+        return False
+    if any(not isinstance(o, dict) or set(o) != {'id', 'text'} or not isinstance(o['id'], str)
+           or not ID_PATTERN.fullmatch(o['id']) or not isinstance(o['text'], str) for o in options):
+        return False
+    return len({o['id'] for o in options}) == len(options)
+
+
+def _handle(conn, token, manifest, weights, stamp, score, config):
+    """Return (reply, stop). Errors carry bounded reason codes only: no prompt, path, or traceback."""
+    invalid = {'ok': False, 'reason': 'invalid-request'}
+    try:
+        line = _read_request_line(conn)
+    except ValueError:
+        return {'ok': False, 'reason': 'request-limit'}, False
+    except OSError:
+        return invalid, False
+    try:
+        message = json.loads(line)
+    except ValueError:
+        return invalid, False
+    if not isinstance(message, dict):
+        return invalid, False
+    supplied = message.get('token')
+    if not isinstance(supplied, str) or not hmac.compare_digest(supplied.encode('utf-8'), token.encode('utf-8')):
+        return {'ok': False, 'reason': 'unauthorized'}, False
+    op = message.get('op')
+    if op == 'ping':
+        return {'ok': True, 'pid': os.getpid(), 'model': {'id': manifest['modelId'], 'revision': manifest['revision'], 'domain': manifest['domain']}}, False
+    if op == 'shutdown':
+        return {'ok': True}, True
+    if op != 'score' or not _valid_score_request(message.get('request')):
+        return invalid, False
+    try:
+        changed = _artifact_stamp(weights) != stamp
+    except OSError:
+        changed = True
+    if changed:
+        return {'ok': False, 'reason': 'artifact-changed'}, True
+    request = message['request']
+    try:
+        check_limits(request, config)
+    except ValueError:
+        return {'ok': False, 'reason': 'input-too-long'}, False
+    try:
+        return {'ok': True, 'response': build_response(request, manifest, score(request))}, False
+    except Exception:
+        return {'ok': False, 'reason': 'score-failed'}, False
+
+
+def serve(manifest, state_path, lock_path, scorer_factory=None, idle_timeout_s=None):
+    """Resident loopback scorer: verify, load once, publish state, serve until idle/shutdown/artifact change."""
+    state_path, lock_path = Path(state_path), Path(lock_path)
+    try:
+        weights = verify_artifacts(manifest)
+        stamp = _artifact_stamp(weights)
+        score, config = (scorer_factory or load_scorer)(weights, manifest)
+    except Exception as exc:
+        reason = str(exc) if str(exc) in STARTUP_REASONS else 'load-failed'
+        try:
+            _write_private_json(lock_path, {'failed': reason, 'at': time.time()})
+        except OSError:
+            pass
+        return 1
+    idle = idle_timeout_s if idle_timeout_s is not None else manifest.get('idleTimeoutMs', 1800000) / 1000
+    token = secrets.token_hex(32)
+    pid = os.getpid()
+    stop = threading.Event()
+    score_lock = threading.Lock()  # one model, one inference at a time; connections are handled concurrently
+    slots = threading.BoundedSemaphore(MAX_CLIENTS)
+
+    def guarded_score(request):
+        with score_lock:
+            return score(request)
+
+    def send(conn, reply):
+        try:
+            conn.sendall((json.dumps(reply, allow_nan=False) + '\n').encode('utf-8'))
+        except OSError:
+            pass
+
+    def worker(conn):
+        try:
+            with conn:
+                conn.settimeout(READ_DEADLINE_S)
+                reply, halt = _handle(conn, token, manifest, weights, stamp, guarded_score, config)
+                send(conn, reply)
+            if halt:
+                stop.set()
+        finally:
+            slots.release()
+
+    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        server.bind(('127.0.0.1', 0))
+        server.listen(MAX_CLIENTS)
+        server.settimeout(0.25)
+        _write_private_json(state_path, {'schemaVersion': 1, 'pid': pid, 'port': server.getsockname()[1], 'token': token, 'startedAt': time.time()})
+        try:
+            lock_path.unlink()
+        except FileNotFoundError:
+            pass
+        last = time.monotonic()
+        # A server whose state file no longer names it is undiscoverable (replaced or corrupted): exit, never orphan.
+        while not stop.is_set() and time.monotonic() - last <= idle and _owns_state(state_path, pid, token):
+            try:
+                conn, _ = server.accept()
+            except socket.timeout:
+                continue
+            last = time.monotonic()
+            if not slots.acquire(blocking=False):
+                with conn:
+                    conn.settimeout(0.2)
+                    try:
+                        _read_request_line(conn)
+                    except (OSError, ValueError):
+                        pass
+                    send(conn, {'ok': False, 'reason': 'busy'})
+                continue
+            threading.Thread(target=worker, args=(conn,), daemon=True).start()
+    finally:
+        server.close()
+        if _owns_state(state_path, pid, token, missing=False):
+            try:
+                state_path.unlink()
+            except OSError:
+                pass
+    return 0
+
+
+def _owns_state(state_path, pid, token, missing=False):
+    """True while the state file still names this server. A transient Windows sharing violation counts as owned."""
+    try:
+        data = json.loads(state_path.read_text(encoding='utf-8'))
+    except FileNotFoundError:
+        return missing
+    except OSError:
+        return True
+    except ValueError:
+        return False
+    return isinstance(data, dict) and data.get('pid') == pid and data.get('token') == token
+
+
+def serve_main(argv, scorer_factory=None):
+    if len(argv) != 3:
+        return 2
+    return serve(json.loads(argv[0]), argv[1], argv[2], scorer_factory=scorer_factory)
+
+
 def source_revision(direct_url_text):
     """Return the PEP 610 VCS commit recorded at install time, or None when unprovable."""
     try:
@@ -76,6 +333,8 @@ def main():
         if sys.argv[1:] == ['--provenance']:
             print(json.dumps(provenance(), allow_nan=False))
             return 0
+        if sys.argv[1:2] == ['--serve']:
+            return serve_main(sys.argv[2:])
         manifest = json.loads(sys.argv[1])
         raw = sys.stdin.buffer.read(2 * 1024 * 1024 + 1)
         if len(raw) > 2 * 1024 * 1024:

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

@@ -8,7 +8,8 @@ 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 { validateManifest, readManifest, provenance, score, PINNED_CUA_S1_REVISION } = require('./provider');
+const resident = require('./resident');
 const { createRequest, decide } = require('./contract');
 const { TIER_OPTIONS } = require('./router');
 
@@ -64,8 +65,8 @@ 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 };
+    // One-shot fallback budget (fresh Python + torch import per call); resident keeps the model loaded.
+    timeoutMs: 10000, transport: 'resident', idleTimeoutMs: 1800000 };
   validateManifest(manifest);
   return manifest;
 }
@@ -85,7 +86,8 @@ async function ensureFile(url, dest, spec, fetcher = httpFetch) {
   return 'downloaded';
 }
 function exec(cmd, args, capture = false) {
-  const result = spawnSync(cmd, args, { shell: false, windowsHide: true, encoding: 'utf8', stdio: capture ? 'pipe' : 'inherit' });
+  // Child progress goes to stderr (fd 2): stdout carries only the final JSON report.
+  const result = spawnSync(cmd, args, { shell: false, windowsHide: true, encoding: 'utf8', stdio: capture ? 'pipe' : ['ignore', 2, 2] });
   if (result.error || result.status !== 0) throw new Error(`command-failed: ${[cmd, ...args].join(' ')}`);
   return capture ? result.stdout.trim() : '';
 }
@@ -108,20 +110,27 @@ function plan(opts) {
       `${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',
+      'verify provenance (pinned revision), start the resident server, one warm CPU inference, stop it',
     ],
     env: { HARNESS_SYSTEM_ONE_MODE: 'shadow', HARNESS_SYSTEM_ONE_CONFIG: manifestPath } };
 }
+// Starts the resident server (if needed), scores once warm, then stops a server it started.
 function verify(manifestPath) {
   const source = provenance(manifestPath);
+  const manifest = readManifest(manifestPath);
+  const wasRunning = resident.status(manifest, manifestPath).running;
+  const startMs = performance.now();
+  const ready = resident.ensureReady(manifest, manifestPath, 60000);
+  const readyMs = Math.round(performance.now() - startMs);
   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);
+  if (!wasRunning) resident.stop(manifest, manifestPath);
   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 };
+  const ok = ready && source.status === 'recorded' && source.provenance.cuaS1.sourceRevisionStatus === 'pinned' && scores !== null;
+  return { ok, source, residentReady: ready, readyMs, decision, scores, latencyMs };
 }
 async function main(argv) {
   const opts = parseArgs(argv);
@@ -149,4 +158,4 @@ if (require.main === module) {
     console.error(`System One install failed: ${err.message}`); process.exitCode = 1;
   });
 }
-module.exports = { PINS, fileUrl, venvPython, supportedPython, pythonCandidates, parseArgs, buildManifest, ensureFile, plan, verify };
+module.exports = { PINS, fileUrl, venvPython, supportedPython, pythonCandidates, parseArgs, buildManifest, ensureFile, exec, plan, verify };

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

@@ -13,11 +13,13 @@ const label = value => typeof value === 'string' && value.length > 0 && value.le
 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
+    || Object.keys(m).some(k => ![...required, 'timeoutMs', 'transport', 'idleTimeoutMs'].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.transport !== undefined && !['oneshot', 'resident'].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;
 }
@@ -48,7 +50,20 @@ 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.
+  if (manifest.transport === 'resident') return require('./resident').score({ ...request }, manifest, manifestPath);
+  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.
@@ -73,4 +88,4 @@ function provenance(manifestPath) {
   try { return { status: 'recorded', provenance: validateProvenance(result.value) }; }
   catch (_) { return unavailable('provider-json'); }
 }
-module.exports = { score, runProvider, validateManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION };
+module.exports = { score, scoreAsync, runProvider, validateManifest, readManifest, provenance, validateProvenance, PINNED_CUA_S1_REVISION };

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

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+'use strict';
+// Resident System One client: one verified model stays loaded in a loopback server.
+// A score never blocks on model loading; a cold start returns provider-starting (lexical route wins).
+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');
+
+const ADAPTER = path.join(__dirname, 'cua_adapter.py');
+const LOCK_TTL_MS = 60000;
+const CALL_TIMEOUT_MS = 1000;
+const MAX_REPLY_BYTES = 1024 * 1024;
+const unavailable = reason => ({ status: 'unavailable', reason });
+const sleep = ms => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+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 defaultCommand = manifest => [manifest.python, [ADAPTER, '--serve']];
+
+function stateFiles(manifest, manifestPath) {
+  const digest = createHash('sha256').update(JSON.stringify(manifest)).digest('hex').slice(0, 16);
+  const base = path.join(path.dirname(manifestPath), `system-one-resident-${digest}`);
+  return { state: `${base}.json`, lock: `${base}.starting` };
+}
+function readState(file) {
+  try {
+    const s = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (exact(s, ['schemaVersion', 'pid', 'port', 'token', 'startedAt']) && s.schemaVersion === 1
+      && Number.isInteger(s.pid) && s.pid > 0 && Number.isInteger(s.port) && s.port > 0 && s.port < 65536
+      && typeof s.token === 'string' && /^[0-9a-f]{64}$/.test(s.token) && Number.isFinite(s.startedAt)) return s;
+  } catch (_) { /* absent or unreadable state means no usable server */ }
+  return null;
+}
+function lockInfo(file) {
+  try {
+    const ageMs = Date.now() - fs.statSync(file).mtimeMs;
+    let failed = null;
+    try { const body = JSON.parse(fs.readFileSync(file, 'utf8')); if (typeof body.failed === 'string') failed = body.failed; } catch (_) { /* partial write */ }
+    return { ageMs, failed };
+  } catch (_) { return null; }
+}
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (err) { return err.code === 'EPERM'; }
+}
+function removeIfSame(file, state) {
+  const current = readState(file);
+  if (current && current.pid === state.pid && current.token === state.token) { try { fs.unlinkSync(file); } catch (_) { /* raced */ } }
+}
+
+// One socket round trip on a worker thread; the caller blocks with Atomics.wait (router API is synchronous).
+const WORKER = `
+const net = require('node:net');
+const { workerData } = require('node:worker_threads');
+const { port, payload, signal, out } = workerData;
+const view = new Uint8Array(out); const chunks = []; let size = 0; let done = false;
+const finish = (code, buf) => {
+  if (done) return; done = true;
+  if (buf) { view.set(buf); Atomics.store(signal, 1, buf.length); }
+  Atomics.store(signal, 0, code); Atomics.notify(signal, 0);
+};
+const socket = net.connect({ port, host: '127.0.0.1' }, () => socket.end(payload));
+socket.on('data', c => { size += c.length; if (size > view.length) { finish(4); socket.destroy(); } else chunks.push(c); });
+socket.on('end', () => finish(1, Buffer.concat(chunks)));
+socket.on('error', e => finish(e.code === 'ECONNREFUSED' ? 2 : 3));
+`;
+function callSync(port, message, timeoutMs = CALL_TIMEOUT_MS) {
+  const signal = new Int32Array(new SharedArrayBuffer(8));
+  const out = new SharedArrayBuffer(MAX_REPLY_BYTES);
+  let worker;
+  try {
+    worker = new Worker(WORKER, { eval: true, workerData: { port, payload: `${JSON.stringify(message)}\n`, signal, out } });
+    worker.unref();
+  } catch (_) { return { error: 'io' }; }
+  Atomics.wait(signal, 0, 0, timeoutMs);
+  const code = Atomics.load(signal, 0);
+  worker.terminate();
+  if (code === 0) return { error: 'timeout' };
+  if (code !== 1) return { error: code === 2 ? 'refused' : code === 4 ? 'limit' : 'io' };
+  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);
+  if (lock && lock.ageMs < LOCK_TTL_MS) return unavailable(lock.failed ? 'provider-unavailable' : 'provider-starting');
+  if (lock) { try { fs.unlinkSync(files.lock); } catch (_) { /* another caller replaced it */ } }
+  try { fs.writeFileSync(files.lock, JSON.stringify({ createdAt: Date.now() }), { flag: 'wx', mode: 0o600 }); }
+  catch (_) { return unavailable('provider-starting'); }
+  let child = null;
+  try {
+    const [exe, prefix] = (deps.command || defaultCommand)(manifest);
+    child = spawn(exe, [...prefix, JSON.stringify(manifest), files.state, files.lock],
+      { detached: true, stdio: 'ignore', windowsHide: true, shell: false });
+    child.on('error', () => { /* recorded synchronously below: a failed spawn has no pid */ });
+    child.unref();
+  } catch (_) { child = null; }
+  // The async 'error' event cannot run while callers block in Atomics.wait, so record the failure now.
+  if (!child || !child.pid) {
+    try { fs.writeFileSync(files.lock, JSON.stringify({ createdAt: Date.now(), failed: 'spawn-failed' })); } catch (_) { /* best effort */ }
+    return unavailable('provider-unavailable');
+  }
+  return unavailable('provider-starting');
+}
+// Returns a live server state, or null after removing state that provably belongs to a dead server.
+function liveState(files) {
+  const state = readState(files.state);
+  if (state && !pidAlive(state.pid)) { removeIfSame(files.state, state); return null; }
+  return state;
+}
+function score(request, manifest, manifestPath, deps = {}) {
+  validateRequest(request);
+  const files = stateFiles(manifest, manifestPath);
+  const state = liveState(files);
+  if (!state) return start(manifest, files, deps);
+  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');
+    return unavailable('provider-json');
+  }
+  if (result.error === 'refused') { removeIfSame(files.state, state); return start(manifest, files, deps); }
+  return unavailable({ timeout: 'provider-timeout', limit: 'provider-output-limit', json: 'provider-json' }[result.error] || 'provider-unavailable');
+}
+function ping(state) {
+  const result = callSync(state.port, { token: state.token, op: 'ping' });
+  return result.reply && result.reply.ok === true ? result.reply : null;
+}
+function ensureReady(manifest, manifestPath, waitMs, deps = {}) {
+  const files = stateFiles(manifest, manifestPath);
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    const state = liveState(files);
+    if (state && ping(state)) return true;
+    if (!state) {
+      const lock = lockInfo(files.lock);
+      if (lock && lock.failed && lock.ageMs < LOCK_TTL_MS) return false;
+      if (!lock || lock.ageMs >= LOCK_TTL_MS) start(manifest, files, deps);
+    }
+    sleep(100);
+  }
+  return false;
+}
+function status(manifest, manifestPath) {
+  const state = liveState(stateFiles(manifest, manifestPath));
+  const reply = state && ping(state);
+  return reply ? { running: true, pid: state.pid, port: state.port, startedAt: state.startedAt, model: reply.model } : { running: false };
+}
+function stop(manifest, manifestPath) {
+  const files = stateFiles(manifest, manifestPath);
+  const state = liveState(files);
+  if (!state) return false;
+  const result = callSync(state.port, { token: state.token, op: 'shutdown' });
+  if (!(result.reply && result.reply.ok === true)) {
+    try { process.kill(state.pid); } catch (_) { /* already exited */ }
+    removeIfSame(files.state, state);
+  }
+  return true;
+}
+
+if (require.main === module) {
+  const [op, manifestPath, extra] = process.argv.slice(2);
+  let manifest = null;
+  try {
+    if (!['start', 'status', 'stop'].includes(op) || extra) throw new Error('usage');
+    manifest = require('./provider').readManifest(manifestPath);
+  } catch (_) {
+    console.error('Usage: resident.js start|status|stop <absolute manifest path>');
+    process.exit(2);
+  }
+  if (op === 'start') process.exitCode = ensureReady(manifest, manifestPath, 60000) ? 0 : 1;
+  if (op === 'stop') stop(manifest, manifestPath);
+  process.stdout.write(`${JSON.stringify(status(manifest, manifestPath))}\n`);
+}
+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

@@ -23,7 +23,7 @@ function selectTier(input, env = process.env, scorer = provider.score) {
   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'];
+    const allowed = ['provider-timeout', 'provider-output-limit', 'provider-exit', 'provider-json', 'provider-config', 'provider-unavailable', 'provider-starting'];
     return fallback(allowed.includes(result?.reason) ? result.reason : 'provider-unavailable');
   }
   const decision = decide(request, result.response);
@@ -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 };