deadbyte-mcp 0.13.0 → 0.15.0

package/test/process-policy.test.mjs

@@ -9,7 +9,8 @@ import {
   PROCESS_POLICY_SCHEMA,
   assertProcessArmed,
   loadProcessPolicy,
-  processSessionStatus
+  processSessionStatus,
+  recheckProcessAuthority
 } from '../src/process-policy.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
@@ -69,6 +70,26 @@ test('process policy loads pinned native host, profile and root while grant is a
   await assert.rejects(() => assertProcessArmed(policy, 'other', 'core'), /profile 'other' is not included/);
 });
 
+test('process authority recheck rejects grant generation or scope drift before side effects', async () => {
+  const f = await fixture();
+  const policy = await loadProcessPolicy(f.policyPath);
+  const grant = {
+    schema: PROCESS_GRANT_SCHEMA,
+    policy_sha256: policy.policy_sha256,
+    instance_nonce: 'a'.repeat(64),
+    profile_ids: ['node'],
+    root_ids: ['core'],
+    granted_at_utc: '2026-09-14T00:00:00Z'
+  };
+  await writeFile(f.grantFile, JSON.stringify(grant));
+  const initial = await assertProcessArmed(policy, 'node', 'core');
+  await writeFile(f.grantFile, JSON.stringify({ ...grant, instance_nonce: 'b'.repeat(64) }));
+  await assert.rejects(() => recheckProcessAuthority(policy, initial, 'node', 'core'), /process authority changed during operation/);
+  await writeFile(f.grantFile, JSON.stringify({ ...grant, profile_ids: ['node', 'node'] }));
+  const deduped = await recheckProcessAuthority(policy, initial, 'node', 'core');
+  assert.equal(deduped.instance_nonce, initial.instance_nonce);
+});
+
 test('process grant with wrong policy digest is disarmed', async () => {
   const f = await fixture();
   const policy = await loadProcessPolicy(f.policyPath);

package/test/prompts-resources.test.mjs

@@ -30,7 +30,7 @@ test('MCP exposes compact workflow prompts and source-of-truth context resources
     const surfaceState=JSON.parse(surfaceText);
     assert.equal(surfaceState.schema,'deadbyte.surface-profile.v1');
     assert.equal(surfaceState.profile,'full');
-    assert.equal(surfaceState.compact_tool_limit,42);
+    assert.equal(surfaceState.compact_tool_limit,43);
     const context=await client.readResource({uri:'deadbyte://context'});
     const contextText=context.contents.map(c=>'text' in c?c.text:'').join('\n');
     assert.match(contextText,/Machine truth/i); assert.match(contextText,/Authority plane/i); assert.match(contextText,/Loop Supervisor/i);

package/test/provider-responses-r42.test.mjs

@@ -0,0 +1,90 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
+import { requestProviderDecision } from '../src/autonomous-planner.mjs';
+import { providerCircuitId } from '../src/provider-circuit.mjs';
+
+const H = value => String(value).repeat(64).slice(0,64);
+
+async function policyFixture(planner) {
+  const root = await mkdtemp(path.join(os.tmpdir(),'deadbyte-r42-provider-'));
+  const project = path.join(root,'project');
+  await mkdir(project);
+  const codingPolicy = {
+    policy_sha256:H('c'), roots:{project:{path:project}}, commands:{}
+  };
+  const policyPath = path.join(root,'autonomous-policy.json');
+  await writeFile(policyPath,JSON.stringify({
+    schema:'deadbyte.autonomous-policy.v1', enabled:true,
+    lease_file:path.join(root,'grant.json'), evidence_dir:path.join(root,'evidence'),
+    coding_policy_sha256:codingPolicy.policy_sha256, root_ids:['project'], planner,
+    profiles:{}, limits:{max_wall_ms:null}
+  }));
+  const policy = await loadAutonomousPolicy(policyPath,codingPolicy);
+  return {root,policy,cleanup:()=>rm(root,{recursive:true,force:true})};
+}
+
+test('R42 policy accepts bounded OpenAI Responses planner configuration',async()=>{
+  const f=await policyFixture({
+    backend:'openai_responses', endpoint:'https://api.openai.com/v1/responses',
+    model:'gpt-5', api_key_env:'OPENAI_API_KEY', max_tokens:4096,
+    reasoning_effort:'medium', timeout_ms:45000, max_response_bytes:131072,
+    circuit:{failure_threshold:2,open_ms:1000,half_open_probe_limit:1}
+  });
+  try {
+    assert.equal(f.policy.planner.backend,'openai_responses');
+    assert.equal(f.policy.planner.reasoning_effort,'medium');
+    assert.equal(f.policy.planner.store,false);
+    assert.match(providerCircuitId(f.policy.planner),/^openai_responses:[0-9a-f]{64}$/);
+  } finally { await f.cleanup(); }
+});
+
+test('R42 Responses adapter sends JSON mode and extracts bounded output with provenance',async()=>{
+  const old=process.env.DEADBYTE_R42_TEST_KEY;
+  process.env.DEADBYTE_R42_TEST_KEY='test-only-token';
+  const policy={planner:{
+    backend:'openai_responses', endpoint:'https://api.openai.com/v1/responses', model:'gpt-5',
+    api_key_env:'DEADBYTE_R42_TEST_KEY', max_tokens:2048, reasoning_effort:'high', store:false,
+    timeout_ms:30000, max_response_bytes:65536
+  }};
+  let captured;
+  const fetchImpl=async(url,options)=>{
+    captured={url,options,body:JSON.parse(options.body)};
+    return new Response(JSON.stringify({
+      id:'resp_test_123', status:'completed', model:'gpt-5-2026-01-01',
+      output:[{type:'message',role:'assistant',content:[{type:'output_text',text:'{"schema":"deadbyte.autonomous-decision.v2","kind":"pause","reason":"need fixture"}'}]}],
+      usage:{input_tokens:111,output_tokens:22,total_tokens:133}
+    }),{status:200,headers:{'content-type':'application/json'}});
+  };
+  try {
+    const result=await requestProviderDecision(policy,'bounded prompt',fetchImpl);
+    assert.equal(captured.url,policy.planner.endpoint);
+    assert.equal(captured.options.headers.authorization,'Bearer test-only-token');
+    assert.deepEqual(captured.body.text,{format:{type:'json_object'}});
+    assert.equal(captured.body.store,false);
+    assert.equal(captured.body.max_output_tokens,2048);
+    assert.deepEqual(captured.body.reasoning,{effort:'high'});
+    assert.equal(captured.body.input[0].role,'system');
+    assert.equal(captured.body.input[1].role,'user');
+    assert.equal(result.backend,'openai_responses');
+    assert.equal(result.response_id,'resp_test_123');
+    assert.deepEqual(result.usage,{input_tokens:111,output_tokens:22,total_tokens:133});
+    assert.match(result.raw_text,/deadbyte\.autonomous-decision\.v2/);
+  } finally {
+    if(old===undefined) delete process.env.DEADBYTE_R42_TEST_KEY; else process.env.DEADBYTE_R42_TEST_KEY=old;
+  }
+});
+
+test('R42 Responses adapter fails closed on refusal and incomplete response',async()=>{
+  const policy={planner:{backend:'openai_responses',endpoint:'https://api.openai.com/v1/responses',model:'gpt-5',
+    api_key_env:null,max_tokens:2048,reasoning_effort:null,store:false,timeout_ms:30000,max_response_bytes:65536}};
+  const refusal=async()=>new Response(JSON.stringify({id:'resp_refuse',status:'completed',model:'gpt-5',
+    output:[{type:'message',content:[{type:'refusal',refusal:'cannot comply'}]}]}),{status:200});
+  await assert.rejects(requestProviderDecision(policy,'x',refusal),/refusal|output_text/i);
+  const incomplete=async()=>new Response(JSON.stringify({id:'resp_incomplete',status:'incomplete',model:'gpt-5',output:[],
+    incomplete_details:{reason:'max_output_tokens'}}),{status:200});
+  await assert.rejects(requestProviderDecision(policy,'x',incomplete),/not completed|incomplete/i);
+});

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

@@ -86,25 +86,23 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows current R41 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
-  const stateRoot=await temp('deadbyte-r33-windows-evidence-');
+test('Windows current R44 gate emits signed-R43-parent feature evidence outside the candidate tree', async()=>{
+  const stateRoot=await temp('deadbyte-r44-windows-evidence-');
   try{
-    const gate=await readFile(path.join(root,'scripts','gate-windows-r41.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence-r41\.mjs/,'gate-windows-r41.ps1 must invoke the evidence writer');
-    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence-r41.mjs')],{
-      cwd:root,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
-    });
-    assert.equal(result.code,0,result.stderr||result.stdout);
-    const summary=JSON.parse(result.stdout.trim());
-    assert.equal(summary.status,'written');
-    const evidence=JSON.parse(await readFile(summary.path,'utf8'));
+    const gate=await readFile(path.join(root,'scripts','gate-windows-r44.ps1'),'utf8');
+    assert.match(gate,/windows-gate-evidence-r44\.mjs/);assert.match(gate,/r44-parent-verify/);
     const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r41-windows-gate.v1');
-    assert.equal(evidence.status,'passed');
-    assert.equal(evidence.exit_code,0);
-    assert.equal(evidence.version,'0.13.0');
+    const {writeWindowsGateEvidence}=await import('../scripts/windows-gate-evidence-r44.mjs');
+    const summary=await writeWindowsGateEvidence({candidateRoot:root,stateRoot,clock:()=>new Date('2026-09-21T00:01:00.000Z')});
+    const evidence=JSON.parse(await readFile(summary.path,'utf8'));
+    assert.equal(evidence.schema,'deadbyte.r44-windows-gate.v1');assert.equal(evidence.version,'0.15.0');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.13.0 / R41 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.15.0 / R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.parent.release_id,'v0.14.1-0a5a833892593283');
+    assert.equal(evidence.parent.final_closure_sha256,'2f29e94dd726638c23b2e520a608dcf2a6919e43348855be3940599d557f920b');
+    for(const key of ['skill_integrity','agent_backend_persistence','codex_protocol_contract','remote_device_identity','durable_job_supervisor','real_external_supervisor_smoke','full_regression_required']) assert.equal(evidence.features[key],true,key);
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
+    const historical=await readFile(path.join(root,'scripts','windows-gate-evidence-r43.mjs'),'utf8');
+    assert.match(historical,/version:'0\.14\.1'/);assert.match(historical,/deadbyte\.r43-windows-gate\.v1/);
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

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-r41.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r41.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r41.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(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
@@ -45,11 +45,11 @@ test('final closure verifier canonicalizes traversal order before exact-tree com
   assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
 });
 
-test('R36 autonomous live gate binds the compact gateway contract instead of the historical 73-tool public catalog', async () => {
+test('R44 autonomous live gate binds the current compact gateway contract instead of the historical 73-tool public catalog', async () => {
   const autonomous = await text('src/remote-mcp-autonomous-smoke-client.mjs');
-  assert.match(autonomous, /R36_COMPACT_GATEWAYS/);
-  assert.match(autonomous, /R36_COMPACT_TOOL_LIMIT/);
-  assert.match(autonomous, /names\.length > R36_COMPACT_TOOL_LIMIT/);
+  assert.match(autonomous, /R44_COMPACT_GATEWAYS/);
+  assert.match(autonomous, /R44_COMPACT_TOOL_LIMIT/);
+  assert.match(autonomous, /names\.length > R44_COMPACT_TOOL_LIMIT/);
   for (const name of ['autonomous_goal_submit','autonomous_goal_run','autonomous_goal_verify','autonomous_release_gate','native_diff_apply','native_diff_verify']) {
     assert.match(autonomous,new RegExp(name));
   }

package/test/r42-finalization.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence,R42_PREDECESSOR_RELEASE_ID,R42_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r42.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r42.mjs';
+
+const root=new URL('../',import.meta.url);const text=rel=>readFile(new URL(rel,root),'utf8');
+function parity(){const manifest='a'.repeat(64);return {schema:'deadbyte.r42-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+  candidate:{release_id:`v0.14.0-${manifest.slice(0,16)}`,version:'0.14.0',manifest_sha256:manifest},
+  immutable_slot:{protected:true,release_root:'C:/immutable/r42',development_root:'D:/Projects/deadbyte-mcp/development/deadbyte-mcp-r42-agentic-dev'},
+  local_full:{status:'passed',tool_count:80,strict_output_schemas:true},
+  public_compact:{status:'passed',tool_count:42,capability_closure:true,gateway_count:6,desktop_armed:false,desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true},
+  autonomous:{status:'passed',signed_release_verified:true},desktop_guarded:{status:'passed',native_injected:true,replay_performed:false,predispatch_retry_count:0,observation_receipts_verified:1,action_receipts_verified:3},
+  deterministic_memory:{status:'passed',goal_count:1,snapshot_count:1,index_count:1},model_eval:{status:'passed',path:'C:/evidence/eval.json',evidence_sha256:'e'.repeat(64),payload_sha256:'f'.repeat(64),suite_sha256:'d'.repeat(64),case_count:3},
+  before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},rollback:{state:'completed'},restore:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},
+  predecessor:{release_id:R42_PREDECESSOR_RELEASE_ID,version:'0.13.0',manifest_sha256:R42_PREDECESSOR_MANIFEST},predecessor_disarmed:{status:'passed',tool_count:42,capability_closure:true},
+  successor:{release_id:`v0.14.0-${manifest.slice(0,16)}`,version:'0.14.0',manifest_sha256:manifest},successor_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},
+  requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input','deterministic_memory','model_eval'].map(key=>[key,true]))};}
+
+test('R42 parity requires exact R41 predecessor and immutable R42 slot',()=>{const value=parity();assert.equal(validateParityEvidence(value),true);
+  assert.throws(()=>validateParityEvidence({...value,predecessor:{...value.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...value,immutable_slot:{...value.immutable_slot,development_root:value.immutable_slot.release_root}}),/immutable-slot/i);});
+
+test('R42 release machinery binds 0.14.0, R41 predecessor, memory gates and R42 domains',async()=>{const [gate,deferred,paritySource,writer,verifier,evidence,suite]=await Promise.all([
+  text('scripts/gate-windows-r42.ps1'),text('scripts/deferred-slot-operation-r42.mjs'),text('scripts/release-parity-r42.mjs'),text('scripts/final-closure-r42.mjs'),text('scripts/final-closure-verify-r42.mjs'),text('scripts/windows-gate-evidence-r42.mjs'),text('scripts/release-parity-tests-r42.ps1')]);
+  assert.equal(R42_PREDECESSOR_RELEASE_ID,'v0.13.0-3255be10de4daf08');assert.equal(R42_PREDECESSOR_MANIFEST,'3255be10de4daf0837d67d1ab1913b785b8b8215bc7405823c2ff46968c4b98f');
+  assert.match(gate,/r42-parent-verify/);assert.match(gate,/r42-model-backed-eval/);assert.match(gate,/memory-history-r41\.test\.mjs/);assert.match(gate,/DEADBYTE V0\.14\.0 \/ R42 WINDOWS BATCH GATE: PASS/);
+  assert.match(deferred,/--expected-version','0\.14\.0'/);assert.match(paritySource,/deadbyte\.r42-parity\.v1/);
+  for(const source of [writer,verifier]){assert.match(source,/DEADBYTE-R42-FINAL-CLOSURE-V1/);assert.match(source,/deadbyte\.r42-final-closure\.v1/);assert.match(source,/R42 AGENTIC GOVERNANCE BASELINE/);}
+  assert.equal(typeof verifyFinalClosureObject,'function');assert.match(evidence,/deadbyte\.r42-windows-gate\.v1/);assert.match(suite,/memory-autonomous-integration-r41\.test\.mjs/);
+});
+
+
+test('R42 preserves release-namespaced deterministic memory storage',async()=>{
+  const [server,paritySource]=await Promise.all([text('src/mcp-server.mjs'),text('scripts/release-parity-r42.mjs')]);
+  assert.match(server,/memoryRoot:path\.join\(autonomousPolicy\.evidence_dir,'memory-r41',packageManifestSha256\)/);
+  assert.match(paritySource,/memoryRoot:path\.join\(stateRoot,'evidence','autonomous','memory-r41',candidateManifest\)/);
+});

package/test/r43-finalization.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence,R43_PREDECESSOR_RELEASE_ID,R43_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r43.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r43.mjs';
+
+const root=new URL('../',import.meta.url);const text=rel=>readFile(new URL(rel,root),'utf8');
+function parity(){const manifest='a'.repeat(64);return {schema:'deadbyte.r43-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+  candidate:{release_id:`v0.14.1-${manifest.slice(0,16)}`,version:'0.14.1',manifest_sha256:manifest},
+  immutable_slot:{protected:true,release_root:'C:/immutable/r43',development_root:'D:/Projects/deadbyte-mcp/development/deadbyte-mcp-r42-agentic-dev'},
+  local_full:{status:'passed',tool_count:80,strict_output_schemas:true},
+  public_compact:{status:'passed',tool_count:42,capability_closure:true,gateway_count:6,desktop_armed:false,desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true},
+  autonomous:{status:'passed',signed_release_verified:true},desktop_guarded:{status:'passed',native_injected:true,replay_performed:false,predispatch_retry_count:0,observation_receipts_verified:1,action_receipts_verified:3},
+  deterministic_memory:{status:'passed',goal_count:1,snapshot_count:1,index_count:1},
+  before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},rollback:{state:'completed'},restore:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},
+  predecessor:{release_id:R43_PREDECESSOR_RELEASE_ID,version:'0.14.0',manifest_sha256:R43_PREDECESSOR_MANIFEST},predecessor_disarmed:{status:'passed',tool_count:42,capability_closure:true},
+  successor:{release_id:`v0.14.1-${manifest.slice(0,16)}`,version:'0.14.1',manifest_sha256:manifest},successor_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},
+  requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input','deterministic_memory'].map(key=>[key,true]))};}
+
+test('R43 parity requires exact R42 predecessor and immutable R43 slot',()=>{const value=parity();assert.equal(validateParityEvidence(value),true);
+  assert.throws(()=>validateParityEvidence({...value,predecessor:{...value.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...value,immutable_slot:{...value.immutable_slot,development_root:value.immutable_slot.release_root}}),/immutable-slot/i);});
+
+test('R43 release machinery binds 0.14.1 exact R42 predecessor and no fresh model credential dependency',async()=>{const [gate,deferred,paritySource,writer,verifier,evidence,suite,finalizer]=await Promise.all([
+  text('scripts/gate-windows-r43.ps1'),text('scripts/deferred-slot-operation-r43.mjs'),text('scripts/release-parity-r43.mjs'),text('scripts/final-closure-r43.mjs'),text('scripts/final-closure-verify-r43.mjs'),text('scripts/windows-gate-evidence-r43.mjs'),text('scripts/release-parity-tests-r43.ps1'),text('scripts/finalize-r43.mjs')]);
+  assert.equal(R43_PREDECESSOR_RELEASE_ID,'v0.14.0-08cd8f3b98c90e0e');assert.equal(R43_PREDECESSOR_MANIFEST,'08cd8f3b98c90e0e250cf506ff396515065ff5457909f850b75b0b6e8ecc2dd1');
+  assert.match(gate,/r43-parent-verify/);assert.doesNotMatch(gate,/model-backed-eval|OPENAI_API_KEY/);assert.match(gate,/full-regression/);assert.match(gate,/r43:full:test/);assert.match(gate,/DEADBYTE V0\.14\.1 \/ R43 AUTHORITY HARDENING WINDOWS BATCH GATE: PASS/);
+  assert.match(deferred,/--expected-version','0\.14\.1'/);assert.match(paritySource,/deadbyte\.r43-parity\.v1/);assert.doesNotMatch(paritySource,/verifyR42ModelEval|model_eval/);
+  for(const source of [writer,verifier]){assert.match(source,/DEADBYTE-R43-FINAL-CLOSURE-V1/);assert.match(source,/deadbyte\.r43-final-closure\.v1/);assert.match(source,/R43 AUTHORITY HARDENING PATCH/);assert.doesNotMatch(source,/model_eval/);}
+  assert.equal(typeof verifyFinalClosureObject,'function');assert.match(evidence,/deadbyte\.r43-windows-gate\.v1/);assert.match(evidence,/parent_activation_receipt_sha256/);assert.match(suite,/autonomous-loop\.test\.mjs/);assert.match(suite,/runtime-self-update\.test\.mjs/);assert.match(suite,/r43-finalizer\.test\.mjs/);assert.match(finalizer,/--restore-standing-grants/);assert.match(finalizer,/final_authority\?\.process_armed===true/);assert.match(finalizer,/requires Process standing grant/);assert.match(finalizer,/runReleaseParity/);assert.match(finalizer,/writeFinalClosure/);assert.match(finalizer,/verifyFinalClosureObject/);assert.match(finalizer,/--rollback-receipt/);assert.match(finalizer,/parity_scratch/);
+});

package/test/r43-finalizer.test.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateFinalizerAuthorityStatus, validateWindowsGateEvidence } from '../scripts/finalize-r43.mjs';
+
+const manifest='a'.repeat(64);
+const parent={parent_release_id:'v0.14.0-08cd8f3b98c90e0e',
+  parent_manifest_sha256:'08cd8f3b98c90e0e250cf506ff396515065ff5457909f850b75b0b6e8ecc2dd1',
+  parent_generation_manifest_sha256:'df8ca9894a3e2ca9a9f145cfa3e4e23fd71f42c1988266a1591fc16261ab18a5'};
+const valid=()=>({schema:'deadbyte.r43-windows-gate.v1',status:'passed',exit_code:0,version:'0.14.1',
+  marker:'DEADBYTE V0.14.1 / R43 AUTHORITY HARDENING WINDOWS BATCH GATE: PASS',manifest_sha256:manifest,
+  parent:{release_id:parent.parent_release_id,manifest_sha256:parent.parent_manifest_sha256,
+    generation_manifest_sha256:parent.parent_generation_manifest_sha256,
+    activation_receipt_sha256:'074140ad8b94501e0a095a7fa132dc5d6e2c57102c9eeaaa2ac9e4ea93b9b187'},
+  hardening:{authority_toctou:true,absolute_execution_deadline:true,pre_spawn_authority_recheck:true,
+    full_regression_required:true,model_path_changed:false}});
+
+test('R43 detached finalizer requires explicit Process+Coding+Autonomous grants and keeps 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:false,host_armed:true
+  }),/Host DISARMED/);
+});
+
+test('R43 detached finalizer accepts only exact parent-bound hardening gate evidence',()=>{
+  assert.equal(validateWindowsGateEvidence(valid(),manifest,parent),true);
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),manifest_sha256:'b'.repeat(64)},manifest,parent),/candidate mismatch/);
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),hardening:{...valid().hardening,authority_toctou:false}},manifest,parent),/hardening contract/);
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),parent:{...valid().parent,release_id:'v0.14.0-bad'}},manifest,parent),/parent mismatch/);
+});

package/test/r43-parent.test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { verifyR43Parent } from '../scripts/verify-r43-parent.mjs';
+
+const root=new URL('../',import.meta.url);
+
+test('R43 parent contract binds exact immutable R42 release and signed activation evidence', async()=>{
+  const record=JSON.parse(await readFile(new URL('../R43-PARENT.json',import.meta.url),'utf8'));
+  assert.equal(record.schema,'deadbyte.r43-parent.v1');
+  assert.equal(record.parent_release_id,'v0.14.0-08cd8f3b98c90e0e');
+  assert.equal(record.parent_version,'0.14.0');
+  assert.equal(record.parent_manifest_sha256,'08cd8f3b98c90e0e250cf506ff396515065ff5457909f850b75b0b6e8ecc2dd1');
+  assert.equal(record.parent_generation_manifest_sha256,'df8ca9894a3e2ca9a9f145cfa3e4e23fd71f42c1988266a1591fc16261ab18a5');
+  assert.equal(record.parent_manifest_file_count,1820);
+  assert.equal(record.parent_generation_file_count,7);
+  assert.equal(record.parent_final_closure_present,false);
+  const verified=await verifyR43Parent(new URL('../R43-PARENT.json',import.meta.url));
+  assert.equal(verified.status,'passed');
+  assert.equal(verified.release_files,1820);
+  assert.equal(verified.generation_files,7);
+  assert.equal(verified.parent_activation_receipt_sha256,'074140ad8b94501e0a095a7fa132dc5d6e2c57102c9eeaaa2ac9e4ea93b9b187');
+});
+
+test('R43 parent record explicitly refuses to invent missing R42 final closure evidence', async()=>{
+  const record=JSON.parse(await readFile(new URL('../R43-PARENT.json',import.meta.url),'utf8'));
+  assert.equal(record.parent_final_closure_present,false);
+  assert.equal(Object.prototype.hasOwnProperty.call(record,'parent_final_closure_path'),false);
+});

package/test/r44-finalization.test.mjs

@@ -0,0 +1,58 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence,R44_PREDECESSOR_RELEASE_ID,R44_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r44.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r44.mjs';
+
+const root=new URL('../',import.meta.url);const text=rel=>readFile(new URL(rel,root),'utf8');
+const featureGate=manifest=>({schema:'deadbyte.r44-windows-gate.v1',status:'passed',exit_code:0,version:'0.15.0',
+  marker:'DEADBYTE V0.15.0 / R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS',manifest_sha256:manifest,
+  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}});
+function parity(){
+  const manifest='a'.repeat(64),gate=featureGate(manifest);
+  const requirements=Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy',
+    'interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input','deterministic_memory',
+    'skill_integrity','agent_backend_persistence','codex_protocol_contract','remote_device_identity','durable_job_supervisor','real_external_supervisor_smoke'].map(key=>[key,true]));
+  return {schema:'deadbyte.r44-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:`v0.15.0-${manifest.slice(0,16)}`,version:'0.15.0',manifest_sha256:manifest},
+    immutable_slot:{protected:true,release_root:'C:/immutable/r44',development_root:'D:/Projects/deadbyte-mcp/development/deadbyte-mcp-r42-agentic-dev'},
+    local_full:{status:'passed',tool_count:81,strict_output_schemas:true},
+    public_compact:{status:'passed',tool_count:43,capability_closure:true,gateway_count:6,skill_catalog_verified:true,
+      desktop_armed:false,desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true},
+    autonomous:{status:'passed',signed_release_verified:true},desktop_guarded:{status:'passed',native_injected:true,replay_performed:false,
+      predispatch_retry_count:0,observation_receipts_verified:1,action_receipts_verified:3},
+    deterministic_memory:{status:'passed',goal_count:1,snapshot_count:1,index_count:1},
+    feature_gate:gate,feature_gate_sha256:'f'.repeat(64),
+    before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},
+    rollback:{state:'completed'},restore:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},
+    predecessor:{release_id:R44_PREDECESSOR_RELEASE_ID,version:'0.14.1',manifest_sha256:R44_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:42,capability_closure:true},
+    successor:{release_id:`v0.15.0-${manifest.slice(0,16)}`,version:'0.15.0',manifest_sha256:manifest},
+    successor_disarmed:{status:'passed',tool_count:43,capability_closure:true,skill_catalog_verified:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},
+    requirements};
+}
+
+test('R44 parity requires exact R43 predecessor, 81/43 surface and feature contract',()=>{
+  const value=parity();assert.equal(validateParityEvidence(value),true);
+  assert.throws(()=>validateParityEvidence({...value,predecessor:{...value.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...value,local_full:{...value.local_full,tool_count:80}}),/81-tool/i);
+  assert.throws(()=>validateParityEvidence({...value,public_compact:{...value.public_compact,tool_count:42}}),/compact/i);
+  assert.throws(()=>validateParityEvidence({...value,feature_gate:{...value.feature_gate,features:{...value.feature_gate.features,codex_protocol_contract:false}}}),/codex_protocol_contract/);
+});
+
+test('R44 release machinery is isolated from R43 and binds 0.15.0 signed closure domains',async()=>{
+  const [gate,deferred,paritySource,writer,verifier,evidence,suite,finalizer,parent]=await Promise.all([
+    text('scripts/gate-windows-r44.ps1'),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('scripts/release-parity-tests-r44.ps1'),text('scripts/finalize-r44.mjs'),text('R44-PARENT.json')]);
+  assert.equal(R44_PREDECESSOR_RELEASE_ID,'v0.14.1-0a5a833892593283');
+  assert.equal(R44_PREDECESSOR_MANIFEST,'0a5a8338925932830986421dda60ec5643f62f600404de4992fda2a5e79d09a9');
+  assert.match(gate,/r44-parent-verify/);assert.match(gate,/r44:full:test/);assert.match(gate,/DEADBYTE V0\.15\.0 \/ R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS/);
+  assert.match(deferred,/--expected-version','0\.15\.0'/);assert.match(paritySource,/deadbyte\.r44-parity\.v1/);assert.match(paritySource,/tool_count===81/);assert.match(paritySource,/tool_count===43/);
+  for(const source of [writer,verifier]){assert.match(source,/DEADBYTE-R44-FINAL-CLOSURE-V1/);assert.match(source,/deadbyte\.r44-final-closure\.v1/);assert.match(source,/R44 REMOTE AGENT SKILL BASELINE/);}
+  assert.equal(typeof verifyFinalClosureObject,'function');assert.match(evidence,/deadbyte\.r44-windows-gate\.v1/);assert.match(evidence,/final_closure_sha256/);
+  assert.match(suite,/skill-plane-r44\.test\.mjs/);assert.match(suite,/codex-app-server-r44\.test\.mjs/);assert.match(suite,/external-job-provider-r44\.test\.mjs/);
+  assert.match(finalizer,/--restore-standing-grants/);assert.match(finalizer,/runReleaseParity/);assert.match(finalizer,/writeFinalClosure/);assert.match(finalizer,/verifyFinalClosureObject/);assert.match(finalizer,/--rollback-receipt/);
+  const parentRecord=JSON.parse(parent);assert.equal(parentRecord.parent_final_closure_sha256,'2f29e94dd726638c23b2e520a608dcf2a6919e43348855be3940599d557f920b');
+});

package/test/r44-finalizer.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateFinalizerAuthorityStatus, validateWindowsGateEvidence } from '../scripts/finalize-r44.mjs';
+import { windowsPowerShellEnvironment } from '../src/runtime-update.mjs';
+
+const manifest='a'.repeat(64);
+const parent={
+  release_id:'v0.14.1-0a5a833892593283',
+  manifest_sha256:'0a5a8338925932830986421dda60ec5643f62f600404de4992fda2a5e79d09a9',
+  generation_manifest_sha256:'fcfcb5a47d55039b7bb5d42faa0739b57b13d8a420d4418ae09d96d2862967cb',
+  closure_sha256:'2f29e94dd726638c23b2e520a608dcf2a6919e43348855be3940599d557f920b'
+};
+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});
+const valid=()=>({schema:'deadbyte.r44-windows-gate.v1',status:'passed',exit_code:0,version:'0.15.0',
+  marker:'DEADBYTE V0.15.0 / R44 REMOTE AGENT SKILL 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('R44 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('R44 detached finalizer accepts only exact signed-R43-parent feature gate evidence',()=>{
+  assert.equal(validateWindowsGateEvidence(valid(),manifest,parent),true);
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),manifest_sha256:'b'.repeat(64)},manifest,parent),/candidate mismatch/);
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),parent:{...valid().parent,release_id:'v0.14.1-bad'}},manifest,parent),/parent mismatch/);
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),parent:{...valid().parent,final_closure_sha256:'b'.repeat(64)}},manifest,parent),/parent/);
+  assert.throws(()=>validateWindowsGateEvidence({...valid(),features:{...features(),skill_integrity:false}},manifest,parent),/skill_integrity/);
+});
+
+test('R44 detached finalizer isolates Windows PowerShell modules from the parent runtime',()=>{
+  const env=windowsPowerShellEnvironment({
+    SystemRoot:'C:\\Windows',USERPROFILE:'C:\\Users\\operator',ProgramFiles:'C:\\Program Files',
+    PSModulePath:'C:\\poisoned-runtime-modules'
+  });
+  assert.equal(env.PSModulePath,[
+    'C:\\Users\\operator\\Documents\\WindowsPowerShell\\Modules',
+    'C:\\Program Files\\WindowsPowerShell\\Modules',
+    'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\Modules'
+  ].join(';'));
+  assert.doesNotMatch(env.PSModulePath,/poisoned-runtime-modules/);
+});

package/test/r44-parent.test.mjs

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyR44Parent } from '../scripts/verify-r44-parent.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+
+test('R44 parent is exact sealed R43 final baseline',async()=>{
+  const result=await verifyR44Parent(path.join(root,'R44-PARENT.json'));
+  assert.equal(result.ok,true);
+  assert.equal(result.release_id,'v0.14.1-0a5a833892593283');
+  assert.equal(result.manifest_sha256,'0a5a8338925932830986421dda60ec5643f62f600404de4992fda2a5e79d09a9');
+  assert.equal(result.generation_manifest_sha256,'fcfcb5a47d55039b7bb5d42faa0739b57b13d8a420d4418ae09d96d2862967cb');
+  assert.equal(result.release_files,1834);
+  assert.equal(result.generation_files,7);
+  assert.equal(result.closure_sha256,'2f29e94dd726638c23b2e520a608dcf2a6919e43348855be3940599d557f920b');
+  assert.equal(result.recorded_all_disarmed,true);
+});
+
+test('R44 parent proof is historical and does not require current grants to remain absent',async()=>{
+  const result=await verifyR44Parent(path.join(root,'R44-PARENT.json'));
+  assert.equal(result.proof_class,'immutable-slot+generation+signed-final-closure');
+});

package/test/release-version.test.mjs

@@ -3,23 +3,57 @@ 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 R41_PREDECESSOR_RELEASE_ID='v0.12.0-70906ae0a7e4f062';
-const R41_PREDECESSOR_MANIFEST='70906ae0a7e4f0627efbb5087b40b85677c81ed6d64ed89c0ba2af846e390f39';
-test('R41 authority agrees on V0.13.0 and preserves exact sealed public R40 predecessor',async()=>{
- const pkg=JSON.parse(await text('package.json'));
- const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,parent,semanticConfig]=await Promise.all([
- text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r41.ps1'),text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r41.mjs'),text('scripts/release-parity-r41.mjs'),text('scripts/final-closure-r41.mjs'),text('scripts/final-closure-verify-r41.mjs'),text('scripts/windows-gate-evidence-r41.mjs'),text('R41-PARENT.json'),text('controller/deadbyte-semantic-lsp-config.json')]);
- assert.equal(pkg.version,'0.13.0');assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r41.ps1');
- assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r41.mjs');assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r41.mjs');
- assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r41.mjs');assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r41.mjs');
- assert.equal(pkg.scripts['desktop:policy:refresh'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/init-desktop-policy-r40.ps1');
- assert.match(version,/DEADBYTE_VERSION = '0\.13\.0'/);assert.match(controller,/CONTROLLER V0\.13\.0 \/ R41/);assert.match(gate,/DEADBYTE V0\.13\.0 \/ R41 WINDOWS BATCH GATE: PASS/);
- assert.match(readme,/^DEADBYTE MCP V0\.13\.0 \/ R41 DETERMINISTIC MEMORY BASELINE$/m);assert.match(architecture,/^# DEADBYTE MCP V0\.13\.0 \/ R41 ARCHITECTURE$/m);assert.match(controllerReadme,/^DEADBYTE MCP V0\.13\.0 \/ R41 CONTROLLER$/m);
- assert.match(deferred,/--expected-version','0\.13\.0'/);assert.match(deferred,/--enable-desktop/);assert.match(parity,/R41_PREDECESSOR_RELEASE_ID='v0\.12\.0-70906ae0a7e4f062'/);assert.match(parity,new RegExp(R41_PREDECESSOR_MANIFEST));
- assert.match(parity,/version==='0\.13\.0'|version:'0\.13\.0'/);assert.match(closure,/version:'0\.13\.0'/);assert.match(closureVerify,/DEADBYTE V0\.13\.0 \/ R41 WINDOWS BATCH GATE: PASS/);assert.match(windowsGate,/version:'0\.13\.0'/);
- assert.equal(JSON.parse(parent).parent_manifest_sha256,R41_PREDECESSOR_MANIFEST);
- assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');assert.equal(R41_PREDECESSOR_RELEASE_ID,'v0.12.0-70906ae0a7e4f062');
+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 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')
+  ]);
+  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/);
+  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_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'/);
+});
+
+test('R44 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/);
+  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/);
+});
+
+test('semantic config remains byte-pinned across R44 feature work',async()=>{
+  const semantic=await text('controller/deadbyte-semantic-lsp-config.json');
+  assert.equal(createHash('sha256').update(Buffer.from(semantic,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
 });
-test('R40 keeps ONLINE reuse and PowerShell Host collision fix while Desktop stays explicit',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/);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/);});
-test('sealed R39 tooling remains historical 0.11.3 authority with exact 0.11.2 predecessor',async()=>{const [parity,gate,closure]=await Promise.all([text('scripts/release-parity-r39.mjs'),text('scripts/gate-windows-r39.ps1'),text('scripts/final-closure-r39.mjs')]);assert.match(parity,/R39_PREDECESSOR_RELEASE_ID='v0\.11\.2-058605dfccaa3035'/);assert.match(parity,/version==='0\.11\.3'|version:'0\.11\.3'/);assert.match(gate,/DEADBYTE V0\.11\.3 \/ R39 WINDOWS BATCH GATE: PASS/);assert.match(closure,/version:'0\.11\.3'/);});
-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'/);});