harness-everything 0.47.1 → 0.47.3

package/ci/lib/opencode-verification-loader.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const acorn = require('acorn');
+const childProcess = require('child_process');
+
+// Load the private runner without adding exports to the portable plugin's
+// host-discovery surface. Parsing preserves async declarations and boundaries.
+module.exports = function loadRunner(root, overrides = {}) {
+  const source = fs.readFileSync(path.join(root, 'opencode-plugin/index.mjs'), 'utf8');
+  const names = new Set(['FAILURE_MARKER_PATTERNS', 'CONTEXT_MARKER_PATTERNS',
+    'VERIFY_TIMEOUT_ENV', 'DEFAULT_VERIFY_TIMEOUT_MS', 'VERIFY_OUTPUT_LIMIT',
+    'VERIFY_LINE_LIMIT', 'VERIFY_KILL_GRACE_MS', 'normalizeFailureLine',
+    'firstFailureMarker', 'buildFailureSignature', 'getAvailableScripts',
+    'verifyTimeoutMs', 'createVerificationCapture', 'terminateVerificationChild',
+    'runVerificationCommand', 'runVerification']);
+  const ast = acorn.parse(source, { ecmaVersion: 'latest', sourceType: 'module' });
+  const declarations = ast.body.filter(node => names.has(node.id?.name || node.declarations?.[0]?.id?.name));
+  const context = { process, Buffer, setTimeout, clearTimeout, setInterval, clearInterval,
+    createHash: require('crypto').createHash, spawn: childProcess.spawn,
+    existsSync: fs.existsSync, readFileSync: fs.readFileSync, join: path.join, ...overrides };
+  return vm.runInNewContext(declarations.map(node => source.slice(node.start, node.end)).join('\n')
+    + '\n;({ runVerification, runVerificationCommand, createVerificationCapture, buildFailureSignature, verifyTimeoutMs })', context);
+};

package/ci/mechanism-2p-opencode-v2-entrypoint.test.js

@@ -77,6 +77,13 @@ helper.check(
 
   const push = (event) => eventQueue.push(event);
   const settle = () => new Promise((resolve) => setTimeout(resolve, 50));
+  const waitFor = async (predicate) => {
+    const deadline = Date.now() + 5000;
+    while (!predicate()) {
+      if (Date.now() > deadline) throw new Error('V2 async verification did not settle');
+      await new Promise(resolve => setTimeout(resolve, 20));
+    }
+  };
 
   const mod = await import(pathToFileURL(path.join(helper.root, 'opencode-plugin', 'index.mjs')).href);
   const definition = mod.default;
@@ -113,7 +120,7 @@ helper.check(
   for (let i = 1; i <= 3; i++) {
     await after({ tool: 'edit', sessionID: 's1', id: `c${i}`, input: {} });
     push({ type: 'session.idle', sessionID: 's1' });
-    await settle();
+    await waitFor(() => prompts.length === i);
   }
 
   helper.check(

package/ci/mechanism-325-f3-derived-views.test.js

@@ -228,7 +228,7 @@ function caseD4(leg) {
   fs.writeFileSync(candidate, differing);
   const before = sha256(path.join(ws, 'docs', 'index.md'));
   const result = runCompare(leg.dir, { workspace: ws, config: CONFIG, view: 'docs/index.md', candidate, status: 'ok' });
-  same(result.status, 1, 'exit');
+  same(result.status, 1, `exit; stdout=${truncate(result.stdout)}; stderr=${truncate(result.stderr)}`);
   if (!JSON.stringify(jsonOut(result)).includes('stale')) throw new Error(`result state is not stale: ${truncate(result.stdout)}`);
   same(sha256(path.join(ws, 'docs', 'index.md')), before, 'target preserved');
 }
@@ -364,6 +364,46 @@ function caseD13(leg) {
 }
 assertPerLeg('case-d13:crlf-candidate-not-normalized', leg => caseD13(leg));
 
+// Windows file IDs can exceed Number's exact integer range. Exercise the real
+// CLI with deterministic stat identities so runner allocation cannot hide it.
+assertPerLeg('case-d13b:64-bit-file-identities-remain-distinct', leg => {
+  const { ws } = viewWorkspace();
+  writeTarget(ws);
+  const dir = candidateDir();
+  const candidate = path.join(dir, 'candidate.md');
+  const target = path.join(ws, 'docs', 'index.md');
+  fs.writeFileSync(candidate, 'different bytes\n');
+  const large = 2n ** 60n;
+  same(Number(large), Number(large + 1n), 'fixture must collide as Number');
+  for (const scenario of ['distinct-inode', 'distinct-device', 'alias']) {
+    const preload = path.join(dir, `${scenario}.cjs`);
+    fs.writeFileSync(preload, `
+      const fs = require('fs');
+      const path = require('path');
+      const original = fs.statSync;
+      fs.statSync = (file, options) => {
+        const result = original(file, options);
+        const name = path.resolve(String(file));
+        if (name === ${JSON.stringify(candidate)} || name === ${JSON.stringify(target)}) {
+          const candidate = name === ${JSON.stringify(candidate)};
+          const convert = value => options && options.bigint ? value : Number(value);
+          result.ino = convert(${large}n + (candidate && ${JSON.stringify(scenario)} === 'distinct-inode' ? 1n : 0n));
+          result.dev = convert(${large}n + (candidate && ${JSON.stringify(scenario)} === 'distinct-device' ? 1n : 0n));
+        }
+        return result;
+      };
+    `);
+    const result = runCompare(leg.dir, {
+      workspace: ws, config: CONFIG, view: 'docs/index.md', candidate, status: 'ok',
+      extra: { env: { ...process.env, NODE_OPTIONS: `--require "${preload.replace(/\\/g, '/')}"` } }
+    });
+    const alias = scenario === 'alias';
+    same(result.status, alias ? 2 : 1, `${scenario} exit`);
+    same(jsonOut(result).result, alias ? 'comparison-unavailable' : 'stale', `${scenario} verdict`);
+    if (alias) same(jsonOut(result).reason, 'candidate aliases the target', 'alias protection retained');
+  }
+});
+
 // D14: every compare-derived lane above (plus D1) printed exactly one JSON object on stdout.
 {
   const id = 'case-d14:stdout-single-json-object';
@@ -487,7 +527,7 @@ function mp3Apply() {
   const dir = scriptCopy('f3 derived mp3 ');
   // The guard's only decision line — elsewhere in the mutant the script stays intact, so the
   // aliased run proceeds to a real byte comparison (exit 0, equal) instead of crashing.
-  applyMutation(dir, 'return x.ino > 0 && x.ino === y.ino && x.dev === y.dev;', 'return false;', 'mp3 sameFile identity guard');
+  applyMutation(dir, 'return x.ino > 0n && x.ino === y.ino && x.dev === y.dev;', 'return false;', 'mp3 sameFile identity guard');
   return dir;
 }
 

package/ci/mechanism-338-opencode-async.test.js

@@ -0,0 +1,229 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+const { pathToFileURL } = require('url');
+const helper = require('./test-helper');
+
+(async () => {
+  const workspace = helper.tempDir('.mechanism-test-338-async');
+  fs.mkdirSync(workspace, { recursive: true });
+  execFileSync('git', ['init', '-q'], { cwd: workspace });
+  const prompts = [];
+  const client = { session: { prompt: async value => { prompts.push(value.body.parts[0].text); } } };
+  const mod = await import(pathToFileURL(path.join(helper.root, 'opencode-plugin/index.mjs')).href);
+  const { HarnessEnforcement } = mod;
+  const hooks = await HarnessEnforcement({ client, directory: workspace });
+  const runner = require('./lib/opencode-verification-loader')(helper.root);
+  const configure = scripts => fs.writeFileSync(path.join(workspace, 'package.json'), JSON.stringify({ name: 'async-fixture', scripts }));
+  // npm uses cmd.exe on Windows: JSON string escaping is not shell quoting.
+  // Keep source out of shell commands. setup-node places this Node on PATH;
+  // a quoted absolute executable adds another cmd.exe /s quoting boundary.
+  const nodeFile = file => `node "${file}"`;
+  let fixtureID = 0;
+  const node = program => {
+    const file = `program-${++fixtureID}.cjs`;
+    fs.writeFileSync(path.join(workspace, file), `require('fs').writeFileSync('${file}.started', 'yes');\n${program}`);
+    return nodeFile(file);
+  };
+  let calls = 0;
+  const edit = sessionID => hooks['tool.execute.after']({ tool: 'edit', sessionID, callID: `338-${++calls}`, args: { filePath: 'code.js' } }, {});
+  const idle = sessionID => hooks.event({ event: { type: 'session.idle', properties: { sessionID } } });
+  const waitFor = async predicate => {
+    const deadline = Date.now()+5000;
+    while (!predicate()) {
+      if (Date.now() > deadline) throw new Error('fixture did not become ready');
+      await new Promise(resolve => setTimeout(resolve, 20));
+    }
+  };
+
+  const slowCommand = node('setTimeout(() => {}, 600)');
+  configure({ test: slowCommand });
+  await edit('heartbeat');
+  let heartbeats = 0;
+  const ticker = setInterval(() => { heartbeats++; }, 20);
+  await idle('heartbeat');
+  clearInterval(ticker);
+  helper.check('338. slow verification leaves the plugin event loop responsive', heartbeats >= 3 && fs.existsSync(path.join(workspace, 'program-1.cjs.started')), `heartbeats=${heartbeats}; ${prompts.at(-1) || ''}`);
+
+  const largeBytes = 320 * 65536;
+  const largeCommand = node("for(let i=0;i<320;i++)process.stdout.write('x'.repeat(65536)); process.stdout.write('',()=>require('fs').writeFileSync('large-output-bytes.txt',String(320*65536))); console.error('AssertionError: large-output-check');process.exitCode=1");
+  configure({ test: largeCommand });
+  await edit('large-output');
+  await idle('large-output');
+  helper.check('338. output beyond the former 16 MiB cap preserves a real test verdict', fs.existsSync(path.join(workspace, 'large-output-bytes.txt')) && fs.readFileSync(path.join(workspace, 'large-output-bytes.txt'), 'utf8') === String(largeBytes) && /verification failed/.test(prompts.at(-1)) && /large-output-check/.test(prompts.at(-1)), prompts.at(-1));
+  // A producer receipt proves the npm script ran; an independent expected
+  // stream digest additionally proves the runner consumed every emitted byte.
+  const largeResult = await runner.runVerificationCommand(workspace, largeCommand, 10000);
+  const stdoutDigest = crypto.createHash('sha256').update('x'.repeat(largeBytes)).digest('hex');
+  const stderrDigest = crypto.createHash('sha256').update('AssertionError: large-output-check').digest('hex');
+  const expectedDigest = crypto.createHash('sha256').update(`stdout:${stdoutDigest}\nstderr:${stderrDigest}`).digest('hex').slice(0, 16);
+  helper.check('338. the complete >16 MiB producer stream reaches the runner',
+    largeBytes > 16*1024*1024 && largeResult.outcome === 'test_failure' && largeResult.exitCode === 1
+      && largeResult.failureMarker === 'AssertionError: large-output-check' && largeResult.evidenceDigest === expectedDigest,
+    JSON.stringify(largeResult));
+  helper.check('338. streamed diagnostics stay bounded', prompts.at(-1).length < 2600, `prompt bytes=${prompts.at(-1).length}`);
+
+  configure({ test: node("setTimeout(() => require('fs').writeFileSync('budget-test-finished.txt','yes'), 2200)"), lint: node("require('fs').writeFileSync('budget-lint-started.txt','yes');setTimeout(() => {}, 2200)"), build: node("require('fs').writeFileSync('must-not-build.txt','ran')") });
+  process.env.HARNESS_VERIFY_TIMEOUT_MS = '4000';
+  await edit('total-budget');
+  const started = Date.now();
+  const previous = prompts.length;
+  await idle('total-budget');
+  delete process.env.HARNESS_VERIFY_TIMEOUT_MS;
+  helper.check('338. all scripts share one verification budget', prompts.length === previous+1 && /timed out/.test(prompts.at(-1)) && fs.existsSync(path.join(workspace, 'budget-test-finished.txt')) && fs.existsSync(path.join(workspace, 'budget-lint-started.txt')), `duration=${Date.now()-started}; ${prompts.at(-1)}`);
+  helper.check('338. an expired sequence never launches later scripts', !fs.existsSync(path.join(workspace, 'must-not-build.txt')));
+
+  const missing = await runner.runVerificationCommand(path.join(workspace, 'missing-cwd'), 'npm test', 2000);
+  helper.check('338. spawn ENOENT is an execution error with no verdict', missing.outcome === 'execution_error' && missing.exitCode === null && /ENOENT/.test(missing.error), JSON.stringify(missing));
+  const pass = await runner.runVerificationCommand(workspace, node('process.exit(0)'), 2000);
+  helper.check('338. actual exit zero is pass', pass.success && pass.outcome === 'pass' && pass.exitCode === 0, JSON.stringify(pass));
+  const failed = await runner.runVerificationCommand(workspace, node("console.log('FAIL parser.test.js');console.error('AssertionError: parse alpha');process.exitCode=2"), 2000);
+  helper.check('338. nonzero exit preserves stderr marker and stdout suite context', failed.outcome === 'test_failure' && failed.exitCode === 2 && failed.failureMarker === 'FAIL parser.test.js: AssertionError: parse alpha' && /parse alpha/.test(failed.error), JSON.stringify(failed));
+
+  const signature = (out, err, chunks = 10000) => {
+    const stdout = runner.createVerificationCapture(), stderr = runner.createVerificationCapture();
+    for (let i=0; i<out.length; i+=chunks) stdout.write(out.slice(i, i+chunks));
+    for (let i=0; i<err.length; i+=chunks) stderr.write(err.slice(i, i+chunks));
+    const a = stdout.finish(), b = stderr.finish();
+    const marker = a.unsafeIdentity || b.unsafeIdentity ? null : a.marker
+      ? `${a.markerContext ? `${a.markerContext}: ` : ''}${a.marker}`
+      : b.marker ? `${b.markerContext || a.context ? `${b.markerContext || a.context}: ` : ''}${b.marker}` : null;
+    return runner.buildFailureSignature({ command: 'npm test', outcome: 'test_failure', exitCode: 1,
+      failureMarker: marker, evidenceDigest: crypto.createHash('sha256').update(`stdout:${a.digest}\nstderr:${b.digest}`).digest('hex').slice(0,16) });
+  };
+  const longPrefix = `not ok 1 - ${'same'.repeat(1500)}`;
+  helper.check('338. truncated test identities use complete stream digests', signature(`${longPrefix} ALPHA\n`, '') !== signature(`${longPrefix} BETA\n`, ''));
+  const observedLong = [];
+  for (const name of ['ALPHA', 'BETA']) {
+    fs.writeFileSync(path.join(workspace, 'long-marker.js'), `console.log(${JSON.stringify(longPrefix+name)});process.exitCode=1`);
+    observedLong.push(await runner.runVerificationCommand(workspace, nodeFile('long-marker.js'), 2000));
+  }
+  helper.check('338. real long-marker child verdicts cannot collide after truncation', observedLong.every(value => value.outcome === 'test_failure' && value.failureMarker === null) && runner.buildFailureSignature(observedLong[0]) !== runner.buildFailureSignature(observedLong[1]));
+  helper.check('338. truncated suite contexts cannot merge distinct failures', signature(`FAIL ${longPrefix}ALPHA\n`, 'AssertionError: same assertion\n') !== signature(`FAIL ${longPrefix}BETA\n`, 'AssertionError: same assertion\n'));
+  const stableFailures = [];
+  for (const banner of ['ALPHA', 'BETA']) {
+    fs.writeFileSync(path.join(workspace, 'volatile-banner.js'), `process.stdout.write('${banner}'+'x'.repeat(17*1024*1024));console.error('AssertionError: stable failure');process.exitCode=1`);
+    stableFailures.push(await runner.runVerificationCommand(workspace, nodeFile('volatile-banner.js'), 3000));
+  }
+  helper.check('338. huge volatile non-marker banners preserve a later stable failure identity', stableFailures.every(value => value.failureMarker === 'AssertionError: stable failure') && runner.buildFailureSignature(stableFailures[0]) === runner.buildFailureSignature(stableFailures[1]));
+  const context = 'FAIL parser.test.js\n  ● Console\n    console.log\n      ● payload\n';
+  const stderr = '  ● parser › alpha (1.2ms)\n';
+  helper.check('338. chunk boundaries preserve marker and stream context', signature(context, stderr, 1) === signature(context, stderr, 10000) && /FAIL parser.test.js: ● parser › alpha/.test(signature(context, stderr, 1)));
+  helper.check('338. markerless whitespace normalization survives chunk boundaries', signature('  progress \n still running   ', '   last  line ', 1) === signature('progress still running', 'last line', 10000));
+
+  // Both shell and nested child remain in the inherited process group.
+  fs.writeFileSync(path.join(workspace, 'grandchild.js'), "const fs=require('fs');process.on('SIGTERM',()=>{});setInterval(()=>fs.appendFileSync('heartbeat.txt','x'),20)");
+  fs.writeFileSync(path.join(workspace, 'worker.js'), "require('child_process').spawn(process.execPath,['grandchild.js'],{stdio:'inherit'});setInterval(()=>{},1000)");
+  const cleanupResult = await runner.runVerificationCommand(workspace, nodeFile('worker.js'), 700);
+  const heartbeat = path.join(workspace, 'heartbeat.txt');
+  const size = fs.existsSync(heartbeat) ? fs.statSync(heartbeat).size : -1;
+  await new Promise(resolve => setTimeout(resolve, 200));
+  helper.check('338. timeout stops nested SIGTERM-ignoring child output', cleanupResult.outcome === 'timeout' && size > 0 && fs.statSync(heartbeat).size === size, JSON.stringify({ cleanupResult, size }));
+  if (process.platform !== 'win32') {
+    const externalRunner = require('./lib/opencode-verification-loader')(helper.root, { spawn: (command, options) => {
+      const child = require('child_process').spawn(command, options);
+      setTimeout(() => { try { child.kill('SIGTERM'); } catch {} }, 300);
+      return child;
+    } });
+    const signalled = await externalRunner.runVerificationCommand(workspace, nodeFile('worker.js'), 3000);
+    const afterSignal = fs.statSync(heartbeat).size;
+    await new Promise(resolve => setTimeout(resolve, 200));
+    helper.check('338. early external signals are execution errors and also clean the group', signalled.outcome === 'execution_error' && signalled.signal === 'SIGTERM' && !signalled.timedOut && fs.statSync(heartbeat).size === afterSignal, JSON.stringify(signalled));
+  }
+
+  fs.writeFileSync(path.join(workspace, 'ready.js'), "require('fs').writeFileSync('ready.txt','yes');setInterval(()=>{},1000)");
+  configure({ test: nodeFile('ready.js') });
+  await edit('edited-during-run');
+  const beforeConcurrent = prompts.length;
+  const active = idle('edited-during-run');
+  await waitFor(() => fs.existsSync(path.join(workspace, 'ready.txt')));
+  await Promise.all([idle('edited-during-run'), edit('edited-during-run')]);
+  await active;
+  const real = fs.realpathSync(workspace);
+  const slug = path.basename(real).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'workspace';
+  const hash = crypto.createHash('sha1').update(process.platform === 'win32' ? real.toLowerCase() : real).digest('hex').slice(0,12);
+  const sessions = path.join(process.env.HARNESS_STATE_HOME, 'workspaces', `${slug}-${hash}`, 'state/sessions');
+  const editedState = JSON.parse(fs.readFileSync(path.join(sessions, 'edited-during-run/edit-state.json')));
+  helper.check('338. a concurrent edit cancels stale verification without duplicate follow-ups', editedState.verificationPending === true && editedState.editsSinceVerification === 2 && prompts.length === beforeConcurrent, JSON.stringify(editedState));
+  configure({ test: node('process.exit(0)') });
+  await idle('edited-during-run');
+  helper.check('338. a fresh idle verifies the newer edits', JSON.parse(fs.readFileSync(path.join(sessions, 'edited-during-run/edit-state.json'))).verificationPending === false);
+
+  fs.unlinkSync(path.join(workspace, 'ready.txt'));
+  configure({ test: nodeFile('ready.js') });
+  await edit('deleted-during-run');
+  const deleting = idle('deleted-during-run');
+  await waitFor(() => fs.existsSync(path.join(workspace, 'ready.txt')));
+  await hooks.event({ event: { type: 'session.deleted', properties: { sessionID: 'deleted-during-run' } } });
+  await deleting;
+  helper.check('338. session deletion aborts the runner without resurrecting state', !fs.existsSync(path.join(sessions, 'deleted-during-run')) && prompts.length === beforeConcurrent);
+
+  // The V2 adapter must keep consuming reset/delete events while idle
+  // verification is pending, and its disposer must await child cleanup.
+  const queue = [], registrations = new Map();
+  const dispose = await mod.default.setup({
+    location: { directory: workspace },
+    tool: { hook: async (name, callback) => { registrations.set(name, callback); } },
+    session: { prompt: async value => { prompts.push(value.text); } },
+    event: { subscribe: async function* ({ signal }) {
+      while (!signal.aborted) {
+        if (queue.length) yield queue.shift();
+        else await new Promise(resolve => setTimeout(resolve, 5));
+      }
+    } },
+  });
+  fs.writeFileSync(path.join(workspace, 'v2.js'), "const fs=require('fs');fs.writeFileSync('v2-ready.txt','yes');setInterval(()=>fs.appendFileSync('v2-heartbeat.txt','x'),20)");
+  configure({ test: nodeFile('v2.js') });
+  const v2Edit = sessionID => registrations.get('execute.after')({ tool: 'edit', sessionID, id: `338-v2-${++calls}`, input: { filePath: 'code.js' } });
+  const v2Ready = path.join(workspace, 'v2-ready.txt');
+  const v2Heartbeat = path.join(workspace, 'v2-heartbeat.txt');
+  for (const type of ['session.deleted', 'session.created']) {
+    const sessionID = `v2-${type}`;
+    if (fs.existsSync(v2Ready)) fs.unlinkSync(v2Ready);
+    await v2Edit(sessionID);
+    queue.push({ type: 'session.idle', sessionID });
+    await waitFor(() => fs.existsSync(v2Ready) && fs.existsSync(v2Heartbeat));
+    queue.push({ type, sessionID });
+    await waitFor(() => !fs.existsSync(path.join(sessions, sessionID)));
+    await new Promise(resolve => setTimeout(resolve, 250));
+    const stopped = fs.statSync(v2Heartbeat).size;
+    await new Promise(resolve => setTimeout(resolve, 100));
+    helper.check(`338. V2 consumes ${type} during verification and stops its child`, fs.statSync(v2Heartbeat).size === stopped && prompts.length === beforeConcurrent);
+  }
+  fs.unlinkSync(v2Ready);
+  await v2Edit('v2-disposed');
+  queue.push({ type: 'session.idle', sessionID: 'v2-disposed' });
+  await waitFor(() => fs.existsSync(v2Ready));
+  await dispose();
+  const stopped = fs.statSync(v2Heartbeat).size;
+  await new Promise(resolve => setTimeout(resolve, 150));
+  helper.check('338. V2 disposal waits for active child cleanup without a stale follow-up', fs.statSync(v2Heartbeat).size === stopped && prompts.length === beforeConcurrent);
+  // A new idle can arrive while an edit-cancelled child is still being reaped.
+  // That idle must verify the newer revision after cleanup, rather than vanish.
+  fs.unlinkSync(path.join(workspace, 'ready.txt'));
+  configure({ test: nodeFile('ready.js') });
+  await edit('idle-during-cleanup');
+  const cancellingIdle = idle('idle-during-cleanup');
+  await waitFor(() => fs.existsSync(path.join(workspace, 'ready.txt')));
+  await edit('idle-during-cleanup');
+  configure({ test: node('process.exit(0)') });
+  await Promise.all([cancellingIdle, idle('idle-during-cleanup')]);
+  const afterCleanup = JSON.parse(fs.readFileSync(path.join(sessions, 'idle-during-cleanup/edit-state.json')));
+  helper.check('338. idle arriving during cancellation verifies the latest edit after cleanup',
+    afterCleanup.verificationPending === false && afterCleanup.editsSinceVerification === 0 && prompts.length === beforeConcurrent,
+    JSON.stringify(afterCleanup));
+
+  fs.unlinkSync(path.join(workspace, 'ready.txt'));
+  configure({ test: nodeFile('ready.js') });
+  await edit('deleted-while-waiting');
+  const runningBeforeDelete = idle('deleted-while-waiting');
+  await waitFor(() => fs.existsSync(path.join(workspace, 'ready.txt')));
+  await edit('deleted-while-waiting');
+  const waitingDuringDelete = idle('deleted-while-waiting');
+  await hooks.event({ event: { type: 'session.deleted', properties: { sessionID: 'deleted-while-waiting' } } });
+  await Promise.all([runningBeforeDelete, waitingDuringDelete]);
+  helper.check('338. deletion invalidates an idle waiting for cancelled-child cleanup',
+    !fs.existsSync(path.join(sessions, 'deleted-while-waiting')) && prompts.length === beforeConcurrent);
+  helper.finish();
+})().catch(error => { console.error(error); process.exit(1); });

package/ci/mechanism-341-opencode-lane.test.js

@@ -153,6 +153,14 @@ async function startPlugin(workspace) {
   return { registered, stream, dispose };
 }
 
+async function waitForIdleConsumer(predicate) {
+  const deadline = Date.now() + 5000;
+  while (!predicate()) {
+    assert.ok(Date.now() < deadline, 'asynchronous idle consumer did not complete');
+    await new Promise(resolve => setTimeout(resolve, 20));
+  }
+}
+
 function canonicalJson(value) {
   if (Array.isArray(value)) return value.map(canonicalJson);
   if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort().map(key => [key, canonicalJson(value[key])]));
@@ -235,6 +243,7 @@ test('OpenCode capture → idle Stop whole path is refused without live qualific
     }
 
     await plugin.stream.dispatch({ type: 'session.idle', sessionID: sessionId });
+    await waitForIdleConsumer(() => assessmentSessions.filter(id => id === sessionId).length === 1);
     const reportPath = path.join(sessionDir, 'doc-reconciliation-pilot.json');
     const report = fs.existsSync(reportPath) ? JSON.parse(fs.readFileSync(reportPath, 'utf8')) : null;
     if (assessmentSessions.filter(id => id === sessionId).length !== 1) {
@@ -245,7 +254,7 @@ test('OpenCode capture → idle Stop whole path is refused without live qualific
     }
     assert.deepEqual(findings, []);
   } finally {
-    if (dispose) dispose();
+    if (dispose) await dispose();
     if (originalAssess) require(PILOT).assess = originalAssess;
     fixture.cleanup();
     restoreEnv();
@@ -277,6 +286,7 @@ test('session idle dispatches the real consumer once across every existing early
       const { sessionDir } = seedWorkflow(fixture, sessionId);
       writeEditState(sessionDir, state);
       await plugin.stream.dispatch({ type: 'session.idle', sessionID: sessionId });
+      await waitForIdleConsumer(() => assessmentSessions.filter(id => id === sessionId).length === 1);
       const reportPath = path.join(sessionDir, 'doc-reconciliation-pilot.json');
       const report = fs.existsSync(reportPath) ? JSON.parse(fs.readFileSync(reportPath, 'utf8')) : null;
       if (assessmentSessions.filter(id => id === sessionId).length !== 1) {
@@ -288,12 +298,13 @@ test('session idle dispatches the real consumer once across every existing early
     }
     const cleanupSession = 'idle-no-verification-pending';
     await plugin.stream.dispatch({ type: 'session.idle', sessionID: cleanupSession });
+    await waitForIdleConsumer(() => assessmentSessions.filter(id => id === cleanupSession).length === 2);
     if (assessmentSessions.filter(id => id === cleanupSession).length !== 2) {
       findings.push(`finally did not release the per-session idle guard for a second event: ${assessmentSessions.filter(id => id === cleanupSession).length} assessments`);
     }
     assert.deepEqual(findings, []);
   } finally {
-    if (dispose) dispose();
+    if (dispose) await dispose();
     pilot.assess = originalAssess;
     fixture.cleanup();
     restoreEnv();
@@ -332,7 +343,7 @@ test('V1/no-status, pilot-OFF, no-workflow, and Claude host controls stay fail-c
     assert.equal(claudeContext.status, 'unavailable', 'OpenCode must not enter through Claude provider semantics');
     assert.ok(claudeContext.diagnostics.some(item => item.code === 'unsupported-host'));
   } finally {
-    if (dispose) dispose();
+    if (dispose) await dispose();
     fixture.cleanup();
     restoreEnv();
   }

package/ci/mechanism-36-verify-timeout.test.js

@@ -79,7 +79,7 @@ for (let i = 0; i < DEFAULTS.length; i += 1) {
   assert.ok(/timed out after/.test(source), `${label} labels timeout failures as timeouts`);
   assert.ok(/test_failure/.test(source), `${label} classifies confirmed failing checks`);
   assert.ok(/execution_error/.test(source), `${label} classifies spawn-level execution errors`);
-  assert.ok(/maxBuffer/.test(source), `${label} bounds captured output instead of using the 1 MiB default`);
+  assert.ok(i === 0 ? /VERIFY_LINE_LIMIT = 4096/.test(source) : /maxBuffer/.test(source), `${label} bounds retained output`);
   const declared = Number(source.match(/^const DEFAULT_VERIFY_TIMEOUT_MS = (\d+);?$/m)[1]);
   assert.ok(declared >= 300000, `${label} default budget (${declared}ms) clears a several-minute suite`);
 }
@@ -95,15 +95,12 @@ assert.strictEqual(
   extractConst(cliSource, 'VERIFY_TIMEOUT_ENV').match(/'([^']*)'/)[1],
   'the plugin and the manual CLI read the same env override',
 );
-assert.strictEqual(
-  extractConst(pluginSource, 'VERIFY_MAX_BUFFER').match(/= (\d+ \* \d+ \* \d+)/)[1],
-  extractConst(cliSource, 'VERIFY_MAX_BUFFER').match(/= (\d+ \* \d+ \* \d+)/)[1],
-  'the plugin and the manual CLI allow the same output buffer',
-);
+// The plugin now streams output; the standalone CLI retains its 16 MiB
+// synchronous capture. Actual async runner contracts are exercised in 338.
 
 // Behavior: budget resolution.
 {
-  const context = loadVerificationLogic(pluginSource);
+  const context = loadVerificationLogic(cliSource);
   assert.strictEqual(context.verifyTimeoutMs(), 600000, 'unset env uses the default budget');
   for (const value of ['abc', '0', '-5', '']) {
     context.process.env.HARNESS_VERIFY_TIMEOUT_MS = value;
@@ -114,167 +111,9 @@ assert.strictEqual(
   assert.ok(!Number.isNaN(Number(context.verifyTimeoutMs())), 'the resolved budget is numeric');
 }
 
-// Behavior: outcome classification per failure kind.
-{
-  const context = loadVerificationLogic(pluginSource);
-  const calls = [];
-  context.execSync = (command, options) => {
-    calls.push({ command, options });
-    return '';
-  };
-  let result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.allPassed, true, 'a passing script verifies');
-  assert.strictEqual(result.results[0].outcome, 'pass', 'a passing script is classified pass');
-  assert.strictEqual(calls.length, 1, 'one command ran');
-  assert.strictEqual(calls[0].command, 'npm test', 'the test script is the command');
-  assert.strictEqual(calls[0].options.timeout, 600000, 'execSync receives the default budget');
-  assert.strictEqual(calls[0].options.maxBuffer, 16 * 1024 * 1024, 'execSync receives the raised output buffer');
-
-  context.process.env.HARNESS_VERIFY_TIMEOUT_MS = '120';
-  calls.length = 0;
-  context.execSync = (command, options) => {
-    calls.push({ command, options });
-    return '';
-  };
-  context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(calls[0].options.timeout, 120, 'execSync receives the overridden budget');
-
-  delete context.process.env.HARNESS_VERIFY_TIMEOUT_MS;
-  context.execSync = () => {
-    const error = new Error('spawnSync npm test ETIMEDOUT');
-    error.code = 'ETIMEDOUT';
-    error.signal = 'SIGTERM'; // the live execSync timeout kill shape
-    error.stdout = 'Harness OS - Self-Regression Test Suite\n';
-    throw error;
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.allPassed, false, 'a timeout is a verification failure');
-  assert.strictEqual(result.results[0].timedOut, true, 'the timeout is recorded as a timeout');
-  assert.strictEqual(result.results[0].outcome, 'timeout', 'a timeout is classified as timeout, not test_failure');
-  assert.ok(/timed out after 600s/.test(result.results[0].error), 'the failure names the budget');
-  assert.ok(/HARNESS_VERIFY_TIMEOUT_MS/.test(result.results[0].error), 'the failure names the override');
-  assert.ok(/Self-Regression/.test(result.results[0].error), 'the failure keeps the last output for diagnosis');
-
-  context.process.env.HARNESS_VERIFY_TIMEOUT_MS = '50';
-  context.execSync = () => {
-    const started = Date.now();
-    while (Date.now() - started < 120) { /* simulate a kill at the budget without an error code */ }
-    const error = new Error('Command failed: npm test');
-    error.stdout = 'partial output';
-    throw error;
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.results[0].timedOut, true, 'a kill at the budget is recognized without an ETIMEDOUT code');
-  assert.strictEqual(result.results[0].outcome, 'timeout', 'a kill at the budget is classified as timeout');
-
-  // P2: a signal is external termination; only budget expiry is a timeout.
-  context.process.env.HARNESS_VERIFY_TIMEOUT_MS = '600000';
-  context.execSync = () => {
-    const error = new Error('Command failed: npm test');
-    error.signal = 'SIGTERM'; // killed early by a user, host, or process manager
-    throw error; // status stays null: no verdict from the suite
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.results[0].outcome, 'execution_error', 'an early external SIGTERM is an execution error, not a timeout');
-  assert.strictEqual(result.results[0].timedOut, false, 'an early external SIGTERM does not claim a timeout');
-  assert.strictEqual(result.results[0].signal, 'SIGTERM', 'the signal is retained for diagnostics');
-  assert.ok(/signal SIGTERM/.test(result.results[0].error), 'the execution error names the signal');
-
-  context.process.env.HARNESS_VERIFY_TIMEOUT_MS = '50';
-  context.execSync = () => {
-    const started = Date.now();
-    while (Date.now() - started < 80) { /* killed once the budget already elapsed, like execSync's own timeout */ }
-    const error = new Error('spawnSync npm test SIGTERM');
-    error.signal = 'SIGTERM';
-    throw error;
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.results[0].outcome, 'timeout', 'a signal kill with no exit status once the budget elapsed is a timeout');
-
-  context.execSync = () => {
-    const started = Date.now();
-    while (Date.now() - started < 80) { /* slow, but it still produced a verdict */ }
-    const error = new Error('Command failed: npm test');
-    error.status = 1;
-    error.stdout = 'confirmed failure after a slow run';
-    throw error;
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.results[0].outcome, 'test_failure', 'a real exit status stays a confirmed failure even past the budget');
-  assert.strictEqual(result.results[0].timedOut, false, 'a confirmed verdict is not a timeout');
-
-  context.process.env.HARNESS_VERIFY_TIMEOUT_MS = '600000';
-  context.execSync = () => {
-    const error = new Error('Command failed: npm test');
-    error.status = 1;
-    error.stdout = 'real assertion failure';
-    throw error;
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.results[0].timedOut, false, 'a fast failure is not mislabeled as a timeout');
-  assert.strictEqual(result.results[0].outcome, 'test_failure', 'a non-zero exit is a confirmed test failure');
-  assert.strictEqual(result.results[0].error, 'real assertion failure', 'a fast failure reports its output');
-
-  context.execSync = () => {
-    const error = new Error('spawnSync npm test ENOBUFS');
-    error.code = 'ENOBUFS';
-    error.stdout = 'x'.repeat(300);
-    throw error;
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.results[0].outcome, 'execution_error', 'ENOBUFS is an execution error, not a test failure');
-  assert.ok(/execution error: ENOBUFS/.test(result.results[0].error), 'the execution error names its cause');
-  assert.ok(!/timed out/.test(result.results[0].error), 'ENOBUFS is not reported as a timeout');
-
-  context.execSync = () => {
-    const error = new Error('spawnSync npm test ENOENT');
-    error.code = 'ENOENT';
-    throw error;
-  };
-  result = context.runVerification('/nonexistent-workspace');
-  assert.strictEqual(result.results[0].outcome, 'execution_error', 'a missing executable is an execution error');
-  assert.strictEqual(result.results[0].exitCode, null, 'a spawn-level error has no exit status');
-}
-
-// Behavior: test_failure evidence spans both streams in full (P1).
-{
-  const context = loadVerificationLogic(pluginSource);
-  context.process.env.HARNESS_VERIFY_TIMEOUT_MS = '600000';
-  context.execSync = () => {
-    const error = new Error('Command failed: npm test');
-    error.status = 1;
-    error.stdout = '> fixture@0.0.0 test\n> node fixture.js\n';
-    error.stderr = 'AssertionError [ERR_ASSERTION]: alpha boom\n';
-    throw error;
-  };
-  const bothStreams = context.runVerification('/nonexistent-workspace').results[0];
-  assert.strictEqual(bothStreams.outcome, 'test_failure', 'a both-stream failure is a confirmed test failure');
-  assert.ok(/alpha boom/.test(bothStreams.error), 'the user-visible diagnostic includes the stderr assertion');
-  assert.ok(/node fixture\.js/.test(bothStreams.error), 'the user-visible diagnostic keeps the stdout banner');
-  assert.ok(/alpha boom/.test(bothStreams.evidence), 'the kept evidence includes stderr');
-  assert.ok(/node fixture\.js/.test(bothStreams.evidence), 'the kept evidence includes stdout');
-
-  context.execSync = () => {
-    const error = new Error('Command failed: npm test');
-    error.status = 1;
-    error.stdout = `${'A'.repeat(2000)}TAIL-MARKER`;
-    throw error;
-  };
-  const longOutput = context.runVerification('/nonexistent-workspace').results[0];
-  assert.ok(longOutput.error.length < 2200, 'the user-visible diagnostic stays bounded');
-  assert.ok(/TAIL-MARKER/.test(longOutput.error), 'the trailing failure evidence survives diagnostic truncation');
-  assert.ok(/chars omitted/.test(longOutput.error), 'the elision is explicit in the diagnostic');
-  assert.ok(longOutput.evidence.length > 2000 && /TAIL-MARKER/.test(longOutput.evidence), 'the full evidence is retained untruncated for signature analysis');
-
-  context.execSync = () => {
-    const error = new Error('Command failed: npm test');
-    error.code = 'ENOBUFS';
-    error.stdout = `${'A'.repeat(2000)}TAIL-MARKER`;
-    throw error;
-  };
-  const spawnError = context.runVerification('/nonexistent-workspace').results[0];
-  assert.strictEqual(spawnError.evidence, undefined, 'only confirmed test failures keep full evidence');
-}
+// Plugin outcome, evidence and cleanup behavior is covered with real child
+// processes in mechanism-338-opencode-async.test.js, and downstream Rule-of-3
+// behavior remains in mechanism-39-opencode-verify-outcomes.test.js.
 
 // Behavior: the manual CLI mirror classifies the same way.
 {

package/docs/platform-capabilities.md

@@ -183,6 +183,14 @@ evidence supports project-scope `.js` loading and edit/verification state on
 OpenCode 1.18.31 (macOS): [live-host evidence](../benchmarks/results/live-host/opencode-2026-09-16/README.md). The
 retained snapshot predates #190 and remains historical evidence only. Current OpenCode removes the permanent post-reflection hard lock; only the third-failure reflection boundary pauses edits. Reflection was operator-seeded, then agent-rewritten, so do not promote this into a behavioral-effectiveness claim. `.mjs` auto-discovery is broken on this host version (issue #127). npm-package installation and behavioral V2-hook fire remain unverified.
 
+The plugin verification runner uses asynchronous child processes with a shared
+sequence budget and bounded streamed diagnostics. Deterministic mechanism
+coverage checks event-loop responsiveness, large-output verdicts, timeout/process
+cleanup, and concurrent edit/session reset handling. The standalone manual CLI
+retains its synchronous per-command runner. This change supplies no additional
+live-host evidence; the historical installation and behavior boundaries above
+remain unchanged.
+
 ## Official sources
 
 The matrix records the official documentation reviewed for each platform. Important source families include [OpenAI plugin packaging](https://developers.openai.com/plugins/build/plugins), [OpenAI public submission](https://developers.openai.com/plugins/deploy/submission), [Codex skills](https://learn.chatgpt.com/docs/build-skills), [Codex hooks](https://learn.chatgpt.com/docs/hooks), [Claude skills](https://code.claude.com/docs/en/skills), [OpenCode skills](https://opencode.ai/docs/skills), [GitHub Copilot Agent Skills](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/add-skills), [Cursor skills](https://cursor.com/docs/skills), [Continue rules](https://docs.continue.dev/customize/rules), and [Hermes skills](https://hermes-agent.nousresearch.com/docs/user-guide/features/skills).

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.47.1
+  version: 0.47.3
 ---
 
 # Harness Everything