deadbyte-mcp 0.15.0 → 0.15.1

package/test/r33-finalization.test.mjs

@@ -19,9 +19,9 @@ test('R34 public parity catalog is exact, unique, and includes production coding
 
 test('release parity and final verifier are package entry points', async () => {
   const pkg = JSON.parse(await text('package.json'));
-  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r44.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r44.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r44.mjs');
+  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r45.mjs');
+  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r45.mjs');
+  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r45.mjs');
   assert.equal(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });

package/test/r45-autonomous-quick-test.test.mjs

@@ -0,0 +1,10 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+test('R45 autonomous quick-test is fixture-scoped and does not invoke legacy npm test matrix', async () => {
+  const text=await readFile(new URL('../scripts/autonomous-tests.ps1',import.meta.url),'utf8');
+  assert.match(text,/node\.exe --test test\/autonomous-live-fixture\.test\.mjs/);
+  assert.doesNotMatch(text,/npm\.cmd test/);
+  assert.match(text,/R24 QUICK TEST PASS/);
+});

package/test/r45-finalization.test.mjs

@@ -0,0 +1,84 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateFinalizerAuthorityStatus, validateWindowsGateEvidence } from '../scripts/finalize-r45.mjs';
+import { R45_PREDECESSOR_RELEASE_ID, R45_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r45.mjs';
+
+const manifest='a'.repeat(64);
+const parent={
+  release_id:'v0.15.0-c15fa41719be61b3',
+  manifest_sha256:'c15fa41719be61b3186e49b2367a5f4c057365cfb465102dbefb7d7355f45483',
+  generation_manifest_sha256:'6d7429c050b7fe893492e102f00282019116e0c9e54e4f25a5791defa1661d30',
+  closure_sha256:'533b7e0ff9ded04086dd90ed34e3b87bc427acc3c55c25bb9f4ec66cb448e667'
+};
+const features=()=>({
+  skill_integrity:true,agent_backend_persistence:true,codex_protocol_contract:true,
+  remote_device_identity:true,durable_job_supervisor:true,real_external_supervisor_smoke:true,
+  full_regression_required:true,codex_live_binary_required:false,
+  host_inline_native:true,native_hardware_observation:true,doctor_release_truth:true
+});
+const valid=()=>({
+  schema:'deadbyte.r45-windows-gate.v1',status:'passed',exit_code:0,version:'0.15.1',
+  marker:'DEADBYTE V0.15.1 / R45 MACHINE FREEDOM WINDOWS BATCH GATE: PASS',
+  manifest_sha256:manifest,
+  parent:{release_id:parent.release_id,manifest_sha256:parent.manifest_sha256,
+    generation_manifest_sha256:parent.generation_manifest_sha256,final_closure_sha256:parent.closure_sha256},
+  features:features()
+});
+
+test('R45 detached finalizer requires Process+Coding+Autonomous and Desktop+Host DISARMED',()=>{
+  assert.equal(validateFinalizerAuthorityStatus({process_armed:true,coding_armed:true,autonomous_armed:true,desktop_armed:false,host_armed:false}),true);
+  assert.throws(()=>validateFinalizerAuthorityStatus({process_armed:false,coding_armed:true,autonomous_armed:true,desktop_armed:false,host_armed:false}),/Process standing grant/);
+  assert.throws(()=>validateFinalizerAuthorityStatus({process_armed:true,coding_armed:true,autonomous_armed:true,desktop_armed:true,host_armed:false}),/Desktop DISARMED/);
+  assert.throws(()=>validateFinalizerAuthorityStatus({process_armed:true,coding_armed:true,autonomous_armed:true,desktop_armed:false,host_armed:true}),/Host DISARMED/);
+});
+
+test('R45 finalizer binds exact R44 parent and all Machine Freedom gate proofs',()=>{
+  assert.equal(validateWindowsGateEvidence(valid(),manifest,parent),true);
+  for(const key of ['host_inline_native','native_hardware_observation','doctor_release_truth']){
+    assert.throws(()=>validateWindowsGateEvidence({...valid(),features:{...features(),[key]:false}},manifest,parent),new RegExp(key));
+  }
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),manifest_sha256:'b'.repeat(64)},manifest,parent),/candidate mismatch/);
+});
+
+test('R45 release machinery binds 0.15.1, 82/43 surfaces, Host v2 bootstrap and FINAL closure',async()=>{
+  const root=new URL('../',import.meta.url);
+  const text=rel=>readFile(new URL(rel,root),'utf8');
+  const [gate,parity,compactClient,writer,verifier,finalizer,evidence,manifestSource]=await Promise.all([
+    text('scripts/gate-windows-r45.ps1'),text('scripts/release-parity-r45.mjs'),text('src/remote-mcp-r45-parity-client.mjs'),text('scripts/final-closure-r45.mjs'),
+    text('scripts/final-closure-verify-r45.mjs'),text('scripts/finalize-r45.mjs'),text('scripts/windows-gate-evidence-r45.mjs'),text('scripts/release-manifest.mjs')
+  ]);
+  assert.equal(R45_PREDECESSOR_RELEASE_ID,parent.release_id);
+  assert.equal(R45_PREDECESSOR_MANIFEST,parent.manifest_sha256);
+  assert.match(gate,/host-policy-refresh/);assert.match(gate,/doctor/);assert.match(gate,/hardware-build/);
+  const hermetic=gate.indexOf('host-policy-hermetic-clean');
+  const focused=gate.indexOf('r45-feature-focused');
+  const regression=gate.indexOf("Invoke-GateStep -Name 'full-regression'");
+  const agentSmoke=gate.indexOf("Invoke-GateStep -Name 'mcp-agent-smoke'");
+  const containedSmoke=gate.indexOf("Invoke-GateStep -Name 'mcp-contained-smoke'");
+  const hostRefresh=gate.indexOf("Invoke-GateStep -Name 'host-policy-refresh'");
+  const manifestWrite=gate.indexOf("Invoke-GateStep -Name 'release-manifest-write'");
+  const hostSmoke=gate.indexOf("Invoke-GateStep -Name 'mcp-host-smoke'");
+  assert.ok(hermetic>=0&&focused>hermetic&&regression>focused&&agentSmoke>regression&&containedSmoke>agentSmoke&&hostRefresh>containedSmoke&&manifestWrite>hostRefresh&&hostSmoke>manifestWrite,'R45 gate must keep generated Host policy out of hermetic regression and non-Host smoke surfaces');
+  assert.match(gate,/DEADBYTE V0\.15\.1 \/ R45 MACHINE FREEDOM WINDOWS BATCH GATE: PASS/);
+  assert.match(parity,/tool_count===82/);assert.match(parity,/tool_count===43/);assert.match(compactClient,/hardware_query/);
+  assert.match(parity,/waitForExactPointer/);
+  assert.match(parity,/rollbackPair\.completed\.active_release===R45_PREDECESSOR_RELEASE_ID/);
+  assert.match(parity,/version:'0\.15\.0',manifestSha256:R45_PREDECESSOR_MANIFEST/);
+  assert.match(parity,/restorePair\.completed\.active_release===active\.release_id/);
+  assert.match(parity,/version:'0\.15\.1',manifestSha256:candidateManifest/);
+  assert.match(parity,/predecessor_disarmed\?\.tool_count===43/);
+  assert.doesNotMatch(parity,/predecessor_disarmed\?\.tool_count===42/);
+  assert.doesNotMatch(parity,/R45 exact R44 predecessor identity mismatch[^\n]*0\.14\.1/);
+  for(const source of [writer,verifier]){
+    assert.match(source,/DEADBYTE-R45-FINAL-CLOSURE-V1/);
+    assert.match(source,/deadbyte\.r45-final-closure\.v1/);
+    assert.match(source,/R45 MACHINE FREEDOM FINAL BASELINE/);
+  }
+  assert.match(finalizer,/--host-policy/);assert.match(finalizer,/--host-policy-sha256/);
+  assert.match(finalizer,/host_inline_native/);assert.match(finalizer,/native_hardware_observation/);assert.match(finalizer,/doctor_release_truth/);
+  assert.match(evidence,/host_inline_native:true/);assert.match(evidence,/native_hardware_observation:true/);assert.match(evidence,/doctor_release_truth:true/);
+  assert.match(manifestSource,/excludedPackagePrefixes = \[[^\]]*'tmp\/'[^\]]*'\.deadbyte-machine-fs-recovery\/'[^\]]*\]/);
+  assert.match(manifestSource,/excludedPackagePaths = new Set\(\['controller\/deadbyte-host-policy\.json'\]\)/);
+  assert.match(manifestSource,/excludedPackagePrefixes\.some\(prefix => rel\.startsWith\(prefix\)\)/);
+});

package/test/release-generation.test.mjs

@@ -92,6 +92,7 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.equal(generatedAuto.profiles.gate.script_sha256,sha(Buffer.from('Write-Output gate\n')));
   assert.equal(generatedAuto.profiles['windows-release'].script_path,'scripts/gate-windows-current.ps1');
   assert.equal(generatedAuto.profiles['windows-release'].script_sha256,sha(Buffer.from('Write-Output current-gate\n')));
+  assert.equal(generatedAuto.profiles['windows-release'].timeout_ms,600000);
   assert.equal(generatedAuto.profiles['windows-release'].description,'Full Windows target release gate; runs only when finish is requested.');
   const generatedHost=JSON.parse(await readFile(result.host_policy_path,'utf8'));
   assert.equal(generatedHost.roots.core.path,path.resolve(development));

package/test/release-version.test.mjs

@@ -2,58 +2,69 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
-const root=new URL('../',import.meta.url);const text=rel=>readFile(new URL(rel,root),'utf8');
-const PARENT_RELEASE='v0.14.1-0a5a833892593283';
-const PARENT_MANIFEST='0a5a8338925932830986421dda60ec5643f62f600404de4992fda2a5e79d09a9';
-const PARENT_CLOSURE='2f29e94dd726638c23b2e520a608dcf2a6919e43348855be3940599d557f920b';
 
-test('R44 current authority agrees on V0.15.0 and preserves exact sealed R43 parent',async()=>{
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+const PARENT_RELEASE='v0.15.0-c15fa41719be61b3';
+const PARENT_MANIFEST='c15fa41719be61b3186e49b2367a5f4c057365cfb465102dbefb7d7355f45483';
+const PARENT_GENERATION='6d7429c050b7fe893492e102f00282019116e0c9e54e4f25a5791defa1661d30';
+const PARENT_CLOSURE='533b7e0ff9ded04086dd90ed34e3b87bc427acc3c55c25bb9f4ec66cb448e667';
+
+test('R45 current authority agrees on V0.15.1 and preserves exact sealed R44 parent',async()=>{
   const pkg=JSON.parse(await text('package.json'));
-  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,parent,r43Gate,r43Parity,r43Closure]=await Promise.all([
-    text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r44.ps1'),text('README.txt'),
-    text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r44.mjs'),
-    text('scripts/release-parity-r44.mjs'),text('scripts/final-closure-r44.mjs'),text('scripts/final-closure-verify-r44.mjs'),
-    text('scripts/windows-gate-evidence-r44.mjs'),text('R44-PARENT.json'),
-    text('scripts/gate-windows-r43.ps1'),text('scripts/release-parity-r43.mjs'),text('scripts/final-closure-r43.mjs')
+  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,parent,r44Gate,r44Parity,r44Closure]=await Promise.all([
+    text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r45.ps1'),text('README.txt'),
+    text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r45.mjs'),
+    text('scripts/release-parity-r45.mjs'),text('scripts/final-closure-r45.mjs'),text('scripts/final-closure-verify-r45.mjs'),
+    text('scripts/windows-gate-evidence-r45.mjs'),text('R45-PARENT.json'),
+    text('scripts/gate-windows-r44.ps1'),text('scripts/release-parity-r44.mjs'),text('scripts/final-closure-r44.mjs')
   ]);
-  assert.equal(pkg.version,'0.15.0');
-  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r44.ps1');
-  assert.equal(pkg.scripts['r44:parent:verify'],'node scripts/verify-r44-parent.mjs');
-  assert.equal(pkg.scripts['r44:full:test'],'node scripts/full-regression-r44.mjs');
-  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r44.mjs');
-  assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r44.mjs');
-  assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r44.mjs');
-  assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r44.mjs');
-  assert.equal(pkg.scripts['finalize:r44'],'node scripts/finalize-r44.mjs');
-  assert.match(version,/DEADBYTE_VERSION = '0\.15\.0'/);
-  assert.match(controller,/CONTROLLER V0\.15\.0 \/ R44/);
-  assert.match(gate,/DEADBYTE V0\.15\.0 \/ R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS/);
-  assert.match(readme,/^DEADBYTE MCP V0\.15\.0 \/ R44 REMOTE AGENT \+ SKILL BASELINE$/m);
-  assert.match(architecture,/^# DEADBYTE MCP V0\.15\.0 \/ R44 ARCHITECTURE$/m);
-  assert.match(controllerReadme,/^DEADBYTE MCP V0\.15\.0 \/ R44 CONTROLLER$/m);
-  assert.match(deferred,/--expected-version','0\.15\.0'/);
-  assert.match(parity,/R44_PREDECESSOR_RELEASE_ID='v0\.14\.1-0a5a833892593283'/);assert.match(parity,new RegExp(PARENT_MANIFEST));
-  assert.match(parity,/tool_count===81/);assert.match(parity,/tool_count===43/);
-  assert.match(closure,/version:'0\.15\.0'/);assert.match(closure,/DEADBYTE-R44-FINAL-CLOSURE-V1/);
-  assert.match(closureVerify,/R44_FULL_TOOL_COUNT=81/);assert.match(closureVerify,/R44_COMPACT_TOOL_COUNT=43/);
-  assert.match(windowsGate,/deadbyte\.r44-windows-gate\.v1/);
+  assert.equal(pkg.version,'0.15.1');
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r45.ps1');
+  assert.equal(pkg.scripts['r45:parent:verify'],'node scripts/verify-r45-parent.mjs');
+  assert.equal(pkg.scripts['r45:full:test'],'node scripts/full-regression-r45.mjs');
+  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r45.mjs');
+  assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r45.mjs');
+  assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r45.mjs');
+  assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r45.mjs');
+  assert.equal(pkg.scripts['finalize:r45'],'node scripts/finalize-r45.mjs');
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.1'/);
+  assert.match(controller,/CONTROLLER V0\.15\.1 \/ R45/);
+  assert.match(gate,/DEADBYTE V0\.15\.1 \/ R45 MACHINE FREEDOM WINDOWS BATCH GATE: PASS/);
+  assert.match(readme,/^DEADBYTE MCP V0\.15\.1 \/ R45 MACHINE FREEDOM FINAL BASELINE$/m);
+  assert.match(architecture,/^# DEADBYTE MCP V0\.15\.1 \/ R45 ARCHITECTURE$/m);
+  assert.match(controllerReadme,/^DEADBYTE MCP V0\.15\.1 \/ R45 CONTROLLER$/m);
+  assert.match(deferred,/--expected-version','0\.15\.1'/);
+  assert.match(parity,/R45_PREDECESSOR_RELEASE_ID='v0\.15\.0-c15fa41719be61b3'/);
+  assert.match(parity,new RegExp(PARENT_MANIFEST));
+  assert.match(parity,/tool_count===82/);assert.match(parity,/tool_count===43/);
+  assert.match(closure,/version:'0\.15\.1'/);assert.match(closure,/DEADBYTE-R45-FINAL-CLOSURE-V1/);
+  assert.match(closureVerify,/R45_FULL_TOOL_COUNT=82/);assert.match(closureVerify,/R45_COMPACT_TOOL_COUNT=43/);
+  assert.match(windowsGate,/deadbyte\.r45-windows-gate\.v1/);
   const parentRecord=JSON.parse(parent);
-  assert.equal(parentRecord.parent_release_id,PARENT_RELEASE);assert.equal(parentRecord.parent_manifest_sha256,PARENT_MANIFEST);
+  assert.equal(parentRecord.parent_release_id,PARENT_RELEASE);
+  assert.equal(parentRecord.parent_manifest_sha256,PARENT_MANIFEST);
+  assert.equal(parentRecord.parent_generation_manifest_sha256,PARENT_GENERATION);
   assert.equal(parentRecord.parent_final_closure_sha256,PARENT_CLOSURE);
-  assert.match(r43Gate,/DEADBYTE V0\.14\.1 \/ R43 AUTHORITY HARDENING WINDOWS BATCH GATE: PASS/);
-  assert.match(r43Parity,/deadbyte\.r43-parity\.v1/);assert.match(r43Closure,/version:'0\.14\.1'/);
+  assert.match(r44Gate,/DEADBYTE V0\.15\.0 \/ R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS/);
+  assert.match(r44Parity,/deadbyte\.r44-parity\.v1/);
+  assert.match(r44Closure,/version:'0\.15\.0'/);
 });
 
-test('R44 keeps ONLINE reuse and explicit Desktop authority',async()=>{
+test('R45 keeps ONLINE reuse and explicit Desktop authority',async()=>{
   const [cli,controller]=await Promise.all([text('src/deadbyte-cli.mjs'),text('controller/deadbyte-controller.ps1')]);
-  assert.match(cli,/controllerRuntimeReady/);assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
+  assert.match(cli,/controllerRuntimeReady/);
+  assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
   const start=controller.indexOf('function Recover-AutonomousSupervisor'),end=controller.indexOf('function Show-State',start);
-  assert.ok(start>=0&&end>start);const block=controller.slice(start,end);
-  assert.doesNotMatch(block,/\$host\s*=/i);assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);
-  assert.match(controller,/armdesktop/);assert.match(controller,/disarmdesktop/);
+  assert.ok(start>=0&&end>start);
+  const block=controller.slice(start,end);
+  assert.doesNotMatch(block,/\$host\s*=/i);
+  assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);
+  assert.match(controller,/armdesktop/);
+  assert.match(controller,/disarmdesktop/);
 });
 
-test('semantic config remains byte-pinned across R44 feature work',async()=>{
+test('semantic config remains byte-pinned across R45 machine-freedom work',async()=>{
   const semantic=await text('controller/deadbyte-semantic-lsp-config.json');
   assert.equal(createHash('sha256').update(Buffer.from(semantic,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
 });

package/test/runtime-host-bootstrap-r45.test.mjs

@@ -0,0 +1,46 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { parseUpdateArgs, prepareHostPolicyBootstrap } from '../scripts/runtime-self-update.mjs';
+
+const hex=ch=>ch.repeat(64);
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+test('R45 slot-update CLI binds Host policy bootstrap as one exact path plus SHA-256 pair',()=>{
+  const base=['--stage','stage','--development-root','dev','--expected-version','0.15.1','--expected-manifest',hex('a')];
+  assert.throws(()=>parseUpdateArgs([...base,'--host-policy','C:/candidate/host.json']),/host policy.*pair/i);
+  assert.throws(()=>parseUpdateArgs([...base,'--host-policy-sha256',hex('b')]),/host policy.*pair/i);
+  const parsed=parseUpdateArgs([...base,'--host-policy','C:/candidate/host.json','--host-policy-sha256',hex('b')]);
+  assert.equal(parsed.hostPolicyBootstrap.path,path.resolve('C:/candidate/host.json'));
+  assert.equal(parsed.hostPolicyBootstrap.sha256,hex('b'));
+});
+
+test('R45 Host policy bootstrap accepts exact v2 bytes and rejects hash or native contract drift',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r45-host-bootstrap-'));
+  const file=path.join(root,'host.json');
+  const policy={
+    schema:'deadbyte.host-policy.v2',enabled:true,arm_file:'C:/state/host-grant.json',
+    roots:{core:{path:'C:/core',read:true,write:true,exec:true}},
+    commands:{node_inline:{kind:'inline',executable:'C:/node.exe',executable_sha256:hex('1'),root_ids:['core'],prefix_args:['-e'],timeout_ms:1000,max_output_bytes:4096,max_command_chars:1024}},
+    native_exec:{enabled:true,root_ids:['core'],timeout_ms:1000,max_output_bytes:4096,max_args:8,max_arg_chars:1024}
+  };
+  const bytes=Buffer.from(JSON.stringify(policy)+'\n','utf8'); await writeFile(file,bytes);
+  const accepted=await prepareHostPolicyBootstrap({path:file,sha256:sha(bytes)});
+  assert.equal(accepted.sha256,sha(bytes)); assert.deepEqual(accepted.policy,policy);
+  await assert.rejects(prepareHostPolicyBootstrap({path:file,sha256:hex('f')}),/host policy.*SHA-256 mismatch/i);
+  const bad=path.join(root,'bad.json');
+  const badBytes=Buffer.from(JSON.stringify({...policy,native_exec:{...policy.native_exec,enabled:false}})+'\n','utf8');
+  await writeFile(bad,badBytes);
+  await assert.rejects(prepareHostPolicyBootstrap({path:bad,sha256:sha(await readFile(bad))}),/native_exec contract/i);
+});
+
+test('R45 updater threads the bootstrapped Host v2 policy into successor generation',async()=>{
+  const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
+  assert.match(source,/prepareHostPolicyBootstrap\(hostPolicyBootstrap\)/);
+  assert.match(source,/control\.hostPolicy=hostBootstrap\.policy/);
+  assert.match(source,/hostPolicy:control\.hostPolicy/);
+  assert.match(source,/hostPolicyBootstrap:args\.hostPolicyBootstrap/);
+});