deadbyte-mcp 0.11.1 → 0.11.2

package/test/r33-closeout-regression.test.mjs

@@ -5,7 +5,7 @@ import { mkdtemp, mkdir, readFile, rm, writeFile, readdir } from 'node:fs/promis
 import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import * as parity from '../scripts/release-parity.mjs';
+import * as parity from '../scripts/release-parity-r38.mjs';
 import { createToolAudit } from '../src/tool-audit.mjs';
 import { verifyAuditChain } from '../src/audit-verify.mjs';
 import { generateTrustKeypair } from '../src/trust.mjs';
@@ -86,12 +86,12 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows R37 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
+test('Windows R38 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
   const stateRoot=await temp('deadbyte-r33-windows-evidence-');
   try{
-    const gate=await readFile(path.join(root,'scripts','gate-windows.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence\.mjs/,'gate-windows.ps1 must invoke the evidence writer');
-    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence.mjs')],{
+    const gate=await readFile(path.join(root,'scripts','gate-windows-r38.ps1'),'utf8');
+    assert.match(gate,/windows-gate-evidence-r38\.mjs/,'gate-windows-r38.ps1 must invoke the evidence writer');
+    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence-r38.mjs')],{
       cwd:root,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
     });
     assert.equal(result.code,0,result.stderr||result.stdout);
@@ -99,12 +99,12 @@ test('Windows R37 gate emits manifest-bound machine-readable evidence outside th
     assert.equal(summary.status,'written');
     const evidence=JSON.parse(await readFile(summary.path,'utf8'));
     const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r37-windows-gate.v1');
+    assert.equal(evidence.schema,'deadbyte.r38-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
-    assert.equal(evidence.version,'0.11.1');
+    assert.equal(evidence.version,'0.11.2');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.11.1 / R37 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.11.2 / R38 WINDOWS BATCH GATE: PASS');
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -2,8 +2,8 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { R34_EXPECTED_TOOLS } from '../src/remote-mcp-r34-parity-client.mjs';
-import { validateParityEvidence } from '../scripts/release-parity.mjs';
-import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
+import { validateParityEvidence } from '../scripts/release-parity-r38.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r38.mjs';
 
 const root = new URL('../', import.meta.url);
 const text = rel => readFile(new URL(rel, root), 'utf8');
@@ -19,28 +19,28 @@ 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.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify.mjs');
+  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r38.mjs');
+  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r38.mjs');
+  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r38.mjs');
   assert.equal(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
 
-test('R37 final closure verifier is implementation-independent from production helpers', async () => {
-  const verifier = await text('scripts/final-closure-verify.mjs');
-  const writer = await text('scripts/final-closure.mjs');
+test('R38 final closure verifier is implementation-independent from production helpers', async () => {
+  const verifier = await text('scripts/final-closure-verify-r38.mjs');
+  const writer = await text('scripts/final-closure-r38.mjs');
   assert.doesNotMatch(verifier, /from ['"]\.\.\/src\//);
   assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
   assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
-  assert.match(verifier, /DEADBYTE-R37-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.11\.1'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.11\.1'/);
-  assert.match(verifier, /release_label==='R37 FINAL MACHINE BASELINE'/);
-  assert.match(verifier, /08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
+  assert.match(verifier, /DEADBYTE-R38-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.11\.2'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.11\.2'/);
+  assert.match(verifier, /release_label==='R38 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /220fac89dd82cdcdddb82cd7d0b71b768f84a5c87d57ebaca0f5383f33d97a76/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
-  const verifier = await text('scripts/final-closure-verify.mjs');
+  const verifier = await text('scripts/final-closure-verify-r38.mjs');
   assert.match(verifier, /const actual=\(await walk\(root\)\)\.filter\(rel=>rel!==manifestName\)\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
   assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
 });

package/test/r38-finalization.test.mjs

@@ -0,0 +1,74 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence, R38_PREDECESSOR_RELEASE_ID, R38_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r38.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r38.mjs';
+
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+
+function parityFixture(){
+  const manifest='a'.repeat(64);
+  return {
+    schema:'deadbyte.r38-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:`v0.11.2-${manifest.slice(0,16)}`,version:'0.11.2',manifest_sha256:manifest},
+    immutable_slot:{protected:true,release_root:'C:/immutable/r38',development_root:'D:/Projects/deadbyte-mcp-r36-dev'},
+    local_full:{status:'passed',tool_count:76,strict_output_schemas:true},
+    public_compact:{status:'passed',tool_count:41,capability_closure:true,gateway_count:5},
+    autonomous:{status:'passed',signed_release_verified:true,observed_failure_before_replan:true},
+    before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
+    rollback:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},restore:{state:'completed'},
+    predecessor:{release_id:R38_PREDECESSOR_RELEASE_ID,version:'0.11.1',manifest_sha256:R38_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:41,capability_closure:true},
+    successor:{release_id:`v0.11.2-${manifest.slice(0,16)}`,version:'0.11.2',manifest_sha256:manifest},
+    successor_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
+    requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface'].map(key=>[key,true]))
+  };
+}
+
+test('R38 parity validator requires full-76, compact closure, exact public 0.11.1 predecessor and immutable-slot separation',()=>{
+  const good=parityFixture();
+  assert.equal(validateParityEvidence(good),true);
+  assert.throws(()=>validateParityEvidence({...good,local_full:{...good.local_full,tool_count:75}}),/full 76/i);
+  assert.throws(()=>validateParityEvidence({...good,public_compact:{...good.public_compact,capability_closure:false}}),/compact closure/i);
+  assert.throws(()=>validateParityEvidence({...good,predecessor:{...good.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...good,immutable_slot:{...good.immutable_slot,development_root:good.immutable_slot.release_root}}),/immutable-slot/i);
+  assert.throws(()=>validateParityEvidence({...good,stage_restore:{status:'missing',manifest_sha256:good.candidate.manifest_sha256}}),/stage restore/i);
+});
+
+test('R38 parity captures R38 bridge, exact public 0.11.1 predecessor, stage reseed and successor restore',async()=>{
+  const parity=await text('scripts/release-parity-r38.mjs');
+  assert.match(parity,/R38_PREDECESSOR_RELEASE_ID='v0\.11\.1-220fac89dd82cdcd'/);
+  assert.match(parity,/220fac89dd82cdcdddb82cd7d0b71b768f84a5c87d57ebaca0f5383f33d97a76/);
+  assert.match(parity,/const stageRestore=await restoreFrozenStage/);
+  assert.match(parity,/publicR38Disarmed/);
+  assert.match(parity,/scheduleDeferred\('activate',candidateManifest,\{bridgeRoot:successorBridge\.root,bridgeScriptSha256:successorBridge\.sha256\}\)/);
+});
+
+test('R38 current final closure writer and independent verifier bind R38 domains and public 0.11.1 predecessor',async()=>{
+  const [writer,verifier]=await Promise.all([text('scripts/final-closure-r38.mjs'),text('scripts/final-closure-verify-r38.mjs')]);
+  assert.equal(typeof verifyFinalClosureObject,'function');
+  assert.match(writer,/DEADBYTE-R38-FINAL-CLOSURE-V1/);
+  assert.match(writer,/deadbyte\.r38-final-closure\.v1/);
+  assert.match(writer,/pointer\.version==='0\.11\.2'/);
+  assert.match(writer,/R38 FINAL MACHINE BASELINE/);
+  assert.match(writer,/deadbyte\.r38-parity\.v1/);
+  assert.match(writer,/deadbyte\.r38-windows-gate\.v1/);
+  assert.match(writer,/R38_PREDECESSOR_RELEASE_ID/);
+  assert.doesNotMatch(verifier,/from ['"]\.\.\/src\//);
+  assert.match(verifier,/DEADBYTE-R38-FINAL-CLOSURE-V1/);
+  assert.match(verifier,/deadbyte\.r38-final-closure\.v1/);
+  assert.match(verifier,/envelope\.body\.version==='0\.11\.2'/);
+  assert.match(verifier,/R38 FINAL MACHINE BASELINE/);
+  assert.match(verifier,/deadbyte\.r38-parity\.v1/);
+  assert.match(verifier,/deadbyte\.r38-windows-gate\.v1/);
+  assert.match(verifier,/220fac89dd82cdcdddb82cd7d0b71b768f84a5c87d57ebaca0f5383f33d97a76/);
+});
+
+test('R38 bounded public parity suite covers current release identity and agent fabric',async()=>{
+  const script=await text('scripts/release-parity-tests-r38.ps1');
+  assert.match(script,/r38-finalization\.test\.mjs/);
+  assert.match(script,/release-version\.test\.mjs/);
+  assert.match(script,/r37-agent-fabric\.test\.mjs/);
+  assert.match(script,/remote-live-log-r37\.test\.mjs/);
+});

package/test/release-generation.test.mjs

@@ -30,16 +30,23 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
     ]},
     LocalReadyUri:'http://127.0.0.1:8787/healthz',UrlRegex:'https://x',McpUrlFile:'C:/mcp-url.txt',McpUrlFileSha256:EXE,McpPathFile:'C:/token.txt',StartTimeoutSeconds:30,ProbeTimeoutSeconds:3};
   const coding={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:'C:/old/coding.json',evidence_dir:'C:/old/evidence',
-    roots:{core:{path:'C:/old/core',read:true,write:true,exec:true,deny_paths:['node_modules']}},commands:{tests:command()},max_read_bytes:524288,max_write_bytes:2097152};
+    roots:{core:{path:'C:/old/core',read:true,write:true,exec:true,deny_paths:['node_modules']}},commands:{tests:command(),powershell_script:command()},max_read_bytes:524288,max_write_bytes:2097152};
   const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,lease_file:'C:/old/auto.json',evidence_dir:'C:/old/auto-evidence',coding_policy_sha256:'0'.repeat(64),root_ids:['core'],planner:{backend:'client_sampling',max_tokens:4096},
-    profiles:{gate:{kind:'command',root_id:'core',command_id:'tests',script_path:'scripts/gate.ps1',script_sha256:'0'.repeat(64),args:[],cwd:'.',timeout_ms:120000,expect_exit_code:0,required_for_release:true,run_after_mutation:true,description:'gate'}},
+    profiles:{
+      gate:{kind:'command',root_id:'core',command_id:'tests',script_path:'scripts/gate.ps1',script_sha256:'0'.repeat(64),args:[],cwd:'.',timeout_ms:120000,expect_exit_code:0,required_for_release:true,run_after_mutation:true,description:'gate'},
+      'windows-release':{kind:'command',root_id:'core',command_id:'powershell_script',script_path:'scripts/gate-windows-old.ps1',script_sha256:'0'.repeat(64),args:[],cwd:'.',timeout_ms:300000,expect_exit_code:0,required_for_release:true,run_after_mutation:false,description:'historical Windows release gate'}
+    },
     limits:{max_iterations:12,max_mutations:24,max_wall_ms:1800000,max_context_bytes:1048576,max_diff_bytes:1048576,max_files_per_diff:8}};
   const host={schema:'deadbyte.host-policy.v1',enabled:true,arm_file:'C:/old/host.json',roots:{core:{path:'C:/old/core',read:true,write:true,exec:true}},commands:{tests:command()},max_read_bytes:262144,max_write_bytes:1048576};
   const processPolicy={schema:'deadbyte.process-policy.v1',enabled:true,grant_file:'C:/old/process-grant.json',state_dir:'C:/old/process-state',
     native_host:{path:'C:/old/deadbyte-process-host.exe',sha256:'0'.repeat(64)},
     roots:{core:{path:'C:/old/core',deny_paths:['node_modules']}},
     profiles:{probe:{executable:'C:/Windows/System32/ping.exe',executable_sha256:EXE,root_ids:['core'],prefix_args:['127.0.0.1','-n','2'],max_args:0,max_arg_bytes:256,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}}};
-  const development=path.join(base,'development'); await mkdir(development,{recursive:true}); await mkdir(path.join(development,'scripts'),{recursive:true}); await writeFile(path.join(development,'scripts','gate.ps1'),'Write-Output gate\n');
+  const development=path.join(base,'development'); await mkdir(development,{recursive:true}); await mkdir(path.join(development,'scripts'),{recursive:true});
+  await writeFile(path.join(development,'scripts','gate.ps1'),'Write-Output gate\n');
+  await writeFile(path.join(development,'scripts','gate-windows-old.ps1'),'Write-Output old-gate\n');
+  await writeFile(path.join(development,'scripts','gate-windows-current.ps1'),'Write-Output current-gate\n');
+  await writeFile(path.join(development,'package.json'),JSON.stringify({scripts:{'gate:windows':'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-current.ps1'}}));
   const result=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
   const verified=await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
   assert.equal(verified.files,6);
@@ -62,6 +69,9 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.equal(generatedAuto.coding_policy_sha256,sha(codingBytes));
   assert.equal(generatedAuto.lease_file,path.join(path.resolve(state),'runtime','autonomous-grant.json'));
   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'].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));
   assert.notEqual(generatedHost.roots.core.path,path.resolve(release));

package/test/release-version.test.mjs

@@ -5,40 +5,59 @@ import { createHash } from 'node:crypto';
 
 const root=new URL('../',import.meta.url);
 const text=rel=>readFile(new URL(rel,root),'utf8');
-const R37_PREDECESSOR_RELEASE_ID='v0.11.0-08c2a0008b1f84c9';
-const R37_PREDECESSOR_MANIFEST='08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8';
+const R38_PREDECESSOR_RELEASE_ID='v0.11.1-220fac89dd82cdcd';
+const R38_PREDECESSOR_MANIFEST='220fac89dd82cdcdddb82cd7d0b71b768f84a5c87d57ebaca0f5383f33d97a76';
 
-test('R37 patch release authority agrees on V0.11.1 and preserves exact public 0.11.0 predecessor',async()=>{
+test('R38 hotfix authority agrees on V0.11.2 and preserves exact public 0.11.1 predecessor',async()=>{
   const pkg=JSON.parse(await text('package.json'));
   const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,semanticConfig]=await Promise.all([
-    text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows.ps1'),
+    text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r38.ps1'),
     text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),
-    text('scripts/deferred-slot-operation.mjs'),text('scripts/release-parity.mjs'),text('scripts/final-closure.mjs'),
-    text('scripts/final-closure-verify.mjs'),text('scripts/windows-gate-evidence.mjs'),
+    text('scripts/deferred-slot-operation-r38.mjs'),text('scripts/release-parity-r38.mjs'),text('scripts/final-closure-r38.mjs'),
+    text('scripts/final-closure-verify-r38.mjs'),text('scripts/windows-gate-evidence-r38.mjs'),
     text('controller/deadbyte-semantic-lsp-config.json')
   ]);
-  assert.equal(pkg.version,'0.11.1');
-  assert.match(version,/DEADBYTE_VERSION = '0\.11\.1'/);
-  assert.match(controller,/CONTROLLER V0\.11\.1 \/ R37/);
-  assert.match(gate,/DEADBYTE V0\.11\.1 \/ R37 WINDOWS BATCH GATE: PASS/);
-  assert.match(readme,/^DEADBYTE MCP V0\.11\.1 \/ R37 PRODUCTION BASELINE$/m);
-  assert.match(architecture,/^# DEADBYTE MCP V0\.11\.1 \/ R37 ARCHITECTURE$/m);
-  assert.match(controllerReadme,/^DEADBYTE MCP V0\.11\.1 \/ R37 CONTROLLER$/m);
-  assert.match(deferred,/--expected-version','0\.11\.1'/);
-  assert.match(parity,/R37_PREDECESSOR_RELEASE_ID='v0\.11\.0-08c2a0008b1f84c9'/);
-  assert.match(parity,new RegExp(R37_PREDECESSOR_MANIFEST));
-  assert.match(parity,/version==='0\.11\.1'|version:'0\.11\.1'/);
-  assert.match(closure,/version:'0\.11\.1'/);
-  assert.match(closureVerify,/DEADBYTE V0\.11\.1 \/ R37 WINDOWS BATCH GATE: PASS/);
-  assert.match(windowsGate,/version:'0\.11\.1'/);
+  assert.equal(pkg.version,'0.11.2');
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r38.ps1');
+  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r38.mjs');
+  assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r38.mjs');
+  assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r38.mjs');
+  assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r38.mjs');
+  assert.match(version,/DEADBYTE_VERSION = '0\.11\.2'/);
+  assert.match(controller,/CONTROLLER V0\.11\.2 \/ R38/);
+  assert.match(gate,/DEADBYTE V0\.11\.2 \/ R38 WINDOWS BATCH GATE: PASS/);
+  assert.match(readme,/^DEADBYTE MCP V0\.11\.2 \/ R38 HOTFIX BASELINE$/m);
+  assert.match(architecture,/^# DEADBYTE MCP V0\.11\.2 \/ R38 ARCHITECTURE$/m);
+  assert.match(controllerReadme,/^DEADBYTE MCP V0\.11\.2 \/ R38 CONTROLLER$/m);
+  assert.match(deferred,/--expected-version','0\.11\.2'/);
+  assert.match(parity,/R38_PREDECESSOR_RELEASE_ID='v0\.11\.1-220fac89dd82cdcd'/);
+  assert.match(parity,new RegExp(R38_PREDECESSOR_MANIFEST));
+  assert.match(parity,/version==='0\.11\.2'|version:'0\.11\.2'/);
+  assert.match(closure,/version:'0\.11\.2'/);
+  assert.match(closureVerify,/DEADBYTE V0\.11\.2 \/ R38 WINDOWS BATCH GATE: PASS/);
+  assert.match(windowsGate,/version:'0\.11\.2'/);
   assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
+  assert.equal(R38_PREDECESSOR_RELEASE_ID,'v0.11.1-220fac89dd82cdcd');
 });
 
-test('R37 patch keeps capability surface and fixes ONLINE remote startup without restoring verbose mode',async()=>{
-  const [parity,cli]=await Promise.all([text('src/remote-mcp-r36-parity-client.mjs'),text('src/deadbyte-cli.mjs')]);
-  assert.match(parity,/R36_EXPECTED_TOOLS\.length !== 76/);
-  assert.match(parity,/R36_COMPACT_TOOL_LIMIT=42/);
+test('R38 hotfix keeps ONLINE reuse and fixes PowerShell $Host recovery collision',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.doesNotMatch(cli,/remote --verbose/);
+  const start=controller.indexOf('function Recover-AutonomousSupervisor');
+  const end=controller.indexOf('function Show-State',start);
+  assert.ok(start>=0&&end>start,'supervisor recovery block missing');
+  const block=controller.slice(start,end);
+  assert.doesNotMatch(block,/\$host\s*=/i);
+  assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);
+});
+
+test('sealed R37 tooling remains historical 0.11.1 authority',async()=>{
+  const [parity,gate,closure]=await Promise.all([
+    text('scripts/release-parity.mjs'),text('scripts/gate-windows.ps1'),text('scripts/final-closure.mjs')
+  ]);
+  assert.match(parity,/R37_PREDECESSOR_RELEASE_ID='v0\.11\.0-08c2a0008b1f84c9'/);
+  assert.match(parity,/version==='0\.11\.1'|version:'0\.11\.1'/);
+  assert.match(gate,/DEADBYTE V0\.11\.1 \/ R37 WINDOWS BATCH GATE: PASS/);
+  assert.match(closure,/version:'0\.11\.1'/);
 });