deadbyte-mcp 0.14.0 → 0.15.0

package/test/durable-job-r44.test.mjs

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createDurableJobSupervisorR44 } from '../src/durable-job-r44.mjs';
+
+class FakeProvider{
+  constructor({external=true}={}){this.external=external;this.handles=new Map();this.starts=0;}
+  descriptor(){return {kind:this.external?'external-supervisor':'controller-local',instance_id:'sup-1'};}
+  async start(spec){
+    const handle={handle_id:`h-${++this.starts}`,pid:1000+this.starts,creation_id:`c-${this.starts}`,profile_id:spec.profile_id};
+    const running={...handle,state:'running'};this.handles.set(handle.handle_id,running);return {...running};
+  }
+  async reattach(handle){
+    const current=this.handles.get(handle.handle_id);return current?{...current}:null;
+  }
+  async status(handle){return this.handles.get(handle.handle_id)??null;}
+  async terminate(handle){const current=this.handles.get(handle.handle_id);if(current){current.state='terminated';return {...current};}return null;}
+}
+
+test('R44 controller/session jobs never masquerade as persistent after owner restart',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-job-'));const provider=new FakeProvider();
+  try{
+    const one=await createDurableJobSupervisorR44({stateDir:root,provider,ownerInstanceId:'owner-1'});
+    const c=await one.start({lifetime:'controller',profileId:'build',rootId:'core',cwd:'.',args:[]});
+    const s=await one.start({lifetime:'session',profileId:'test',rootId:'core',cwd:'.',args:[]});
+    assert.equal(c.state,'running');assert.equal(s.state,'running');
+    const two=await createDurableJobSupervisorR44({stateDir:root,provider,ownerInstanceId:'owner-2'});
+    assert.equal((await two.status({jobId:c.job_id})).state,'interrupted');
+    assert.equal((await two.status({jobId:s.job_id})).state,'interrupted');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 persistent job reattaches only through external supervisor with exact process identity',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-job-persist-'));const provider=new FakeProvider();
+  try{
+    const one=await createDurableJobSupervisorR44({stateDir:root,provider,ownerInstanceId:'owner-1'});
+    const job=await one.start({lifetime:'persistent',profileId:'watch',rootId:'core',cwd:'.',args:[]});
+    const two=await createDurableJobSupervisorR44({stateDir:root,provider,ownerInstanceId:'owner-2'});
+    const recovered=await two.status({jobId:job.job_id});
+    assert.equal(recovered.state,'running');assert.equal(recovered.recovered,true);
+    assert.equal(recovered.pid,job.pid);assert.equal(recovered.creation_id,job.creation_id);
+
+    const live=provider.handles.get(job.handle_id);live.creation_id='spoofed';
+    const three=await createDurableJobSupervisorR44({stateDir:root,provider,ownerInstanceId:'owner-3'});
+    assert.equal((await three.status({jobId:job.job_id})).state,'orphaned');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 persistent lifetime rejects controller-local provider and state corruption',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-job-local-'));
+  try{
+    const local=await createDurableJobSupervisorR44({stateDir:root,provider:new FakeProvider({external:false}),ownerInstanceId:'owner'});
+    await assert.rejects(local.start({lifetime:'persistent',profileId:'x',rootId:'core',cwd:'.',args:[]}),/external supervisor/);
+  }finally{await rm(root,{recursive:true,force:true});}
+
+  const corrupt=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-job-corrupt-'));
+  try{
+    await writeFile(path.join(corrupt,'jobs.json'),'{"schema":','utf8');
+    await assert.rejects(createDurableJobSupervisorR44({stateDir:corrupt,provider:new FakeProvider(),ownerInstanceId:'owner'}),/state JSON invalid/);
+  }finally{await rm(corrupt,{recursive:true,force:true});}
+});
+
+test('R44 terminate binds exact supervisor handle and becomes durable terminal state',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-job-term-'));const provider=new FakeProvider();
+  try{
+    const sup=await createDurableJobSupervisorR44({stateDir:root,provider,ownerInstanceId:'owner'});
+    const job=await sup.start({lifetime:'persistent',profileId:'watch',rootId:'core',cwd:'.',args:[]});
+    const ended=await sup.terminate({jobId:job.job_id});
+    assert.equal(ended.state,'terminated');
+    const restarted=await createDurableJobSupervisorR44({stateDir:root,provider,ownerInstanceId:'owner-2'});
+    assert.equal((await restarted.status({jobId:job.job_id})).state,'terminated');
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/external-job-provider-r44.test.mjs

@@ -0,0 +1,46 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, rm, writeFile, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createDurableJobSupervisorR44 } from '../src/durable-job-r44.mjs';
+import { createExternalJobProviderR44 } from '../src/external-job-provider-r44.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const workerPath=path.join(repoRoot,'src','job-supervisor-host-r44.mjs');
+
+test('R44 real external supervisor preserves persistent job identity across controller recreation',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-real-supervisor-'));
+  const supervisorState=path.join(root,'host'),jobsState=path.join(root,'jobs'),project=path.join(root,'project');
+  await mkdir(project,{recursive:true});
+  const script=path.join(project,'hold.mjs');
+  await writeFile(script,`process.stdout.write('READY\\n');setInterval(()=>{},1000);\n`,'utf8');
+  const nodeSha=sha(await readFile(process.execPath)), workerSha=sha(await readFile(workerPath));
+  const config={stateDir:supervisorState,nodeExecutable:process.execPath,nodeExecutableSha256:nodeSha,
+    workerPath,workerSha256:workerSha,roots:{core:project},profiles:{
+      hold:{executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],prefix_args:[script],max_args:4,max_arg_bytes:1024}
+    }};
+  let providerA=null,providerB=null;
+  try{
+    providerA=await createExternalJobProviderR44(config);
+    const one=await createDurableJobSupervisorR44({stateDir:jobsState,provider:providerA,ownerInstanceId:'controller-a'});
+    const started=await one.start({lifetime:'persistent',profileId:'hold',rootId:'core',cwd:'.',args:[]});
+    assert.equal(started.state,'running');assert.ok(started.pid>0);assert.match(started.creation_id,/^[0-9a-f]{64}$/);
+
+    providerB=await createExternalJobProviderR44(config);
+    assert.equal(providerB.descriptor().instance_id,providerA.descriptor().instance_id,'must reconnect same external supervisor');
+    const two=await createDurableJobSupervisorR44({stateDir:jobsState,provider:providerB,ownerInstanceId:'controller-b'});
+    const recovered=await two.status({jobId:started.job_id});
+    assert.equal(recovered.state,'running');assert.equal(recovered.recovered,true);
+    assert.equal(recovered.handle_id,started.handle_id);assert.equal(recovered.pid,started.pid);assert.equal(recovered.creation_id,started.creation_id);
+    const ended=await two.terminate({jobId:started.job_id});assert.equal(ended.state,'terminated');
+  }finally{
+    if(providerB)await providerB.shutdown().catch(()=>{});
+    else if(providerA)await providerA.shutdown().catch(()=>{});
+    await rm(root,{recursive:true,force:true});
+  }
+});

package/test/full-max-catalog-r40.test.mjs

@@ -10,8 +10,10 @@ import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
 
 const here=path.dirname(fileURLToPath(import.meta.url));
 const repoRoot=path.resolve(here,'..');
-const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
-const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy.json');
+const parent=JSON.parse(await readFile(path.join(repoRoot,'R44-PARENT.json'),'utf8'));
+const parentRoot=parent.parent_release_root;
+const serverPath=path.join(parentRoot,'src','mcp-server.mjs');
+const desktopPolicyPath=path.join(parentRoot,'controller','deadbyte-desktop-policy.json');
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
 const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
 
@@ -70,7 +72,7 @@ test('R40 real max-runtime full stdio catalog is exactly 80 with four Desktop pr
     DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
     DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
   };
-  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:parentRoot,env,stderr:'pipe'});
   try{
     await client.connect(transport);
     const listed=await client.listTools();

package/test/full-max-catalog-r44.test.mjs

@@ -0,0 +1,91 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy.json');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
+
+test('R44 real max-runtime full stdio catalog is exactly 81 with skill and four Desktop primitives while authority remains disarmed',async()=>{
+  const f=await createR34Fixture({authority:'disarmed'});
+  const processPolicyPath=path.join(f.root,'process-policy.json');
+  const processGrant=path.join(f.root,'process-grant.json');
+  const processState=path.join(f.root,'process-state');
+  const hostPolicyPath=path.join(f.root,'host-policy.json');
+  const hostArm=path.join(f.root,'host-arm.json');
+  const nodeSha=sha(await readFile(process.execPath));
+  await mkdir(processState,{recursive:true});
+  await writeFile(processPolicyPath,JSON.stringify({
+    schema:'deadbyte.process-policy.v1',enabled:true,grant_file:processGrant,state_dir:processState,
+    native_host:{path:process.execPath,sha256:nodeSha},
+    roots:{core:{path:f.project,deny_paths:[]}},
+    profiles:{node:{executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],
+      prefix_args:[],transport:'pipe',max_args:8,max_arg_bytes:1024,max_sessions:2,
+      max_input_bytes:65536,max_retained_output_bytes:262144,env_allow:['PATH','TEMP','TMP'],
+      input_actions:{ping:'PING\r\n'}}}
+  },null,2));
+  await writeFile(hostPolicyPath,JSON.stringify({
+    schema:'deadbyte.host-policy.v1',enabled:true,arm_file:hostArm,max_read_bytes:262144,max_write_bytes:1048576,
+    roots:{core:{path:f.project,read:true,write:true,exec:true}},
+    commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:nodeSha,
+      root_ids:['core'],prefix_args:[],extensions:['.mjs'],timeout_ms:5000,max_output_bytes:65536}}
+  },null,2));
+
+  const desktopRaw=JSON.parse(await readFile(desktopPolicyPath,'utf8'));
+  const desktopGrant=desktopRaw.grant_file;
+  const codingLease=f.codingPolicy.lease_file;
+  const autonomousLease=f.policy.lease_file;
+  for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority unexpectedly armed before start: '+q);
+
+  const client=new Client({name:'deadbyte-r44-full-catalog',version:'0.15.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const env={
+    ...getDefaultEnvironment(),
+    DEADBYTE_CAPABILITY_PROFILE:'full',
+    DEADBYTE_AUDIT_RUNTIME:'0',
+    DEADBYTE_STATE_ROOT:path.join(f.root,'state'),
+    DEADBYTE_WORKSPACE_ROOT:f.root,
+    DEADBYTE_SIGNING_KEY:f.keys.privateKeyPath,
+    DEADBYTE_VERIFY_KEY:f.keys.publicKeyPath,
+    DEADBYTE_PRIVILEGED_POLICY:hostPolicyPath,
+    DEADBYTE_MACHINE_RUNTIME:'1',
+    DEADBYTE_AGENT_RUNTIME:'1',
+    DEADBYTE_PROCESS_RUNTIME:'1',
+    DEADBYTE_PROCESS_POLICY:processPolicyPath,
+    DEADBYTE_CODING_RUNTIME:'1',
+    DEADBYTE_CODING_POLICY:path.join(f.root,'coding-policy.json'),
+    DEADBYTE_MACHINE_FS_RUNTIME:'1',
+    DEADBYTE_OBSERVATION_RUNTIME:'1',
+    DEADBYTE_DESKTOP_RUNTIME:'1',
+    DEADBYTE_DESKTOP_POLICY:desktopPolicyPath,
+    DEADBYTE_AUTONOMOUS_RUNTIME:'1',
+    DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
+    DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
+  };
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(t=>t.name).sort();
+    const {R44_EXPECTED_TOOLS}=await import('../src/remote-mcp-r44-parity-client.mjs');
+    assert.equal(names.length,81,'expected exact full R44 catalog 81, got '+names.length+': '+names.join(','));
+    assert.deepEqual(names,R44_EXPECTED_TOOLS);
+    for(const name of ['desktop_status','desktop_observe','desktop_target','desktop_action',
+      'host_file_read','host_file_write','host_exec','skill_catalog']) assert.ok(names.includes(name),'missing '+name);
+    for(const tool of listed.tools) assert.equal(tool.outputSchema?.additionalProperties,false,'non-strict output '+tool.name);
+    const catalog_sha256=sha(Buffer.from(JSON.stringify(names),'utf8'));
+    console.log(JSON.stringify({tool_count:names.length,catalog_sha256,desktop_tools:4,skill:true,authority:'DISARMED'}));
+  } finally {
+    await client.close().catch(()=>{});
+    for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority file appeared during catalog probe: '+q);
+    await f.cleanup();
+  }
+});

package/test/host-plane.test.mjs

@@ -11,7 +11,8 @@ import {
   hostExec,
   hostFileRead,
   hostFileWrite,
-  loadHostPolicy
+  loadHostPolicy,
+  recheckHostAuthority
 } from '../src/host-plane.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
@@ -66,6 +67,19 @@ test('privileged host plane requires a live policy-bound arm lease', async () =>
   await assert.rejects(() => assertHostArmed(expired.policy), /arm expired/);
 });
 
+test('host authority recheck rejects arm generation or expiry drift before side effects', async () => {
+  const f = await fixture();
+  const initial = await assertHostArmed(f.policy);
+  const arm = JSON.parse(await readFile(f.arm, 'utf8'));
+  await writeFile(f.arm, JSON.stringify({ ...arm, instance_nonce: 'b'.repeat(64) }));
+  await assert.rejects(() => recheckHostAuthority(f.policy, initial), /host authority changed during operation/);
+  await writeFile(f.arm, JSON.stringify({
+    ...arm,
+    expires_at_utc: new Date(Date.parse(arm.expires_at_utc) + 60000).toISOString()
+  }));
+  await assert.rejects(() => recheckHostAuthority(f.policy, initial), /host authority changed during operation/);
+});
+
 test('host_file_write is root-scoped hash-precondition and host_file_read returns a verified digest', async () => {
   const f = await fixture();
   const first = await hostFileWrite(f.policy, {

package/test/native-diff.test.mjs

@@ -79,6 +79,34 @@ test('native diff rolls back earlier operations when a later operation fails', a
   } finally { await rm(f.root,{recursive:true,force:true}); }
 });
 
+test('native diff revocation between operations rolls back to preimage without autonomous rollback authority', async () => {
+  const f = await fixture();
+  try {
+    let writes = 0;
+    const revokingCoding = Object.freeze({
+      ...f.codingRuntime,
+      fileWrite: async args => {
+        const result = await f.codingRuntime.fileWrite(args);
+        writes += 1;
+        if (writes === 1) {
+          const lease = JSON.parse(await readFile(f.policy.lease_file, 'utf8'));
+          await writeFile(f.policy.lease_file, JSON.stringify({ ...lease, instance_nonce:'e'.repeat(64) }));
+        }
+        return result;
+      }
+    });
+    const runtime = createNativeDiffRuntime({ policy:f.policy, codingRuntime:revokingCoding,
+      signingKeyPath:f.keys.privateKeyPath, verifyKeyPath:f.keys.publicKeyPath });
+    const preview = await runtime.preview({ rootId:'project', title:'revoke mid transaction', operations:[
+      { kind:'write', path:'first.txt', expected_sha256:'absent', encoding:'utf8', content:'first\n' },
+      { kind:'write', path:'second.txt', expected_sha256:'absent', encoding:'utf8', content:'second\n' }
+    ] });
+    await assert.rejects(runtime.apply({ diffId:preview.diff_id }), /rolled back.*autonomous authority changed/i);
+    assert.equal(await exists(path.join(f.project,'first.txt')), false);
+    assert.equal(await exists(path.join(f.project,'second.txt')), false);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
 test('autonomous application scope isolates repeated identical native diffs across goals', async () => {
   const f = await fixture();
   try {

package/test/output-schema.test.mjs

@@ -19,7 +19,7 @@ const EXPECTED_TOOLS = [
   'agent_task_run', 'agent_task_status', 'agent_task_submit',
   'agent_task_verify', 'contained_transform', 'evidence_verify',
   'file_read',
-  'proof_execute', 'workspace_open'
+  'proof_execute', 'skill_catalog', 'workspace_open'
 ];
 
 async function fixture() {
@@ -47,7 +47,7 @@ async function fixture() {
   return { trust, client, transport };
 }
 
-test('R27 hermetic base-plus-agent catalog advertises 12 strict output schemas', async () => {
+test('R44 hermetic base-plus-agent catalog advertises 13 strict output schemas', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

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/r33-closeout-regression.test.mjs

@@ -86,40 +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 R42 gate emits manifest-bound model-eval evidence outside the candidate tree', async()=>{
-  const stateRoot=await temp('deadbyte-r42-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-r42.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence-r42\.mjs/,'gate-windows-r42.ps1 must invoke the evidence writer');
-    assert.match(gate,/r42-model-backed-eval/,'R42 gate must require model-backed eval before evidence writer');
-
-    const suite=JSON.parse(await readFile(path.join(root,'harness','r42-agent-evals.json'),'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')));
-    const { runAgentEvalSuiteR42 }=await import('../src/agent-eval-runner-r42.mjs');
-    const { writeWindowsGateEvidence }=await import('../scripts/windows-gate-evidence-r42.mjs');
-    const evaluation=await runAgentEvalSuiteR42({
-      suite,subjectManifestSha256:manifestSha,
-      evidenceRoot:path.join(stateRoot,'evidence','release','r42-agent-evals'),
-      clock:()=>new Date('2026-09-20T02:00:00.000Z'),
-      requestModel:async call=>call.role==='generator'
-        ?{backend:'fixture',model:'fixture',response_id:`g-${call.case_id}`,raw_text:JSON.stringify({artifact:{plan:['inspect','verify','fail_closed']}})}
-        :{backend:'fixture',model:'fixture',response_id:`j-${call.case_id}`,raw_text:JSON.stringify({
-          schema:'deadbyte.agent-eval-judge-result.v1',verdict:'pass',advisory:true,findings:[],evidence_refs:['1'.repeat(64)]
-        })}
-    });
-    assert.equal(evaluation.payload.status,'passed');
-
-    const summary=await writeWindowsGateEvidence({candidateRoot:root,stateRoot,clock:()=>new Date('2026-09-20T02:01:00.000Z')});
-    assert.equal(summary.status,'written');
+    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.r42-windows-gate.v1');
-    assert.equal(evidence.status,'passed');
-    assert.equal(evidence.exit_code,0);
-    assert.equal(evidence.version,'0.14.0');
+    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.14.0 / R42 WINDOWS BATCH GATE: PASS');
-    assert.equal(evidence.model_eval.evidence_sha256,evaluation.publication.evidence_sha256);
-    assert.equal(evidence.model_eval.case_count,suite.cases.length);
+    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-r42.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r42.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r42.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/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');
+});