harness-everything 0.47.2 → 0.47.3

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.47.2",
+      "version": "0.47.3",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.47.2",
+  "version": "0.47.3",
   "author": {
     "name": "Miya Daniel"
   },

package/.github/workflows/ci.yml

@@ -118,6 +118,8 @@ jobs:
           node-version: 24
       - name: Install dependencies for regression suite
         run: npm ci
+      - name: Verify OpenCode async process fixtures before the full suite
+        run: node ci/mechanism-338-opencode-async.test.js
       - name: Run hermetic self-regression suite
         run: npm test
       - name: Run focused mutation checks

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.47.3](https://github.com/dyphn1/Harness-everything/compare/v0.47.2...v0.47.3) (2026-10-31)
+
+### Bug Fixes
+
+* **docs:** preserve exact file identities in derived comparisons ([8bc3ddb](https://github.com/dyphn1/Harness-everything/commit/8bc3ddbac38eaffa7495e70922dc1240f9aa63eb))
+* **docs:** repin shipped verifier after exact file identity fix ([c24d0f1](https://github.com/dyphn1/Harness-everything/commit/c24d0f100ce392edd02275aa06b58f141ade6cdd))
+* **opencode:** invalidate idle waiters on session reset ([41b2663](https://github.com/dyphn1/Harness-everything/commit/41b2663f66edbe77188c3ca9fa3b0add6f7ab76d))
+* **opencode:** stream verification asynchronously within a shared budget ([1470247](https://github.com/dyphn1/Harness-everything/commit/1470247249548ec6ccf2acaf97463824e0268be4)), closes [#338](https://github.com/dyphn1/Harness-everything/issues/338)
+
 ## [0.47.2](https://github.com/dyphn1/Harness-everything/compare/v0.47.1...v0.47.2) (2026-10-31)
 
 ### Bug Fixes

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();
   }