deadbyte-mcp 0.12.0 → 0.14.0

package/test/memory-projections-r41.test.mjs

@@ -0,0 +1,92 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, generateKeyPairSync, sign as cryptoSign } from 'node:crypto';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import {
+  deriveEpisodicMemory,verifyEpisode,
+  deriveDecisionMemory,verifyDecisionMemory,
+  deriveIncidentMemory,verifyIncidentMemory
+} from '../src/memory-r41.mjs';
+
+const DOMAIN=Buffer.from('DEADBYTE-AUTONOMOUS-EVENT-V1\0');
+const ZERO='0'.repeat(64);
+const sha=value=>createHash('sha256').update(Buffer.from(typeof value==='string'?value:canonicalJson(value),'utf8')).digest('hex');
+const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+const keyId=sha(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+const goalId=sha('projection-goal');
+const goal={schema:'deadbyte.autonomous-goal.v1',goal_id:goalId,goal_sha256:sha('projection-body'),root_id:'core',
+  title:'repair linker',goal:'repair LNK2019',acceptance:'build and tests pass'};
+
+function appendJournal(out,type,payload){
+    const index=out.length;
+    const body={schema:'deadbyte.autonomous-event.v1',seq:index+1,goal_id:goalId,
+      created_at_utc:`2026-09-20T02:00:${String(index).padStart(2,'0')}.000Z`,prev_sha256:out.at(-1)?.event_sha256??ZERO,type,payload};
+    const event_sha256=sha(body);const signed={...body,event_sha256};
+    const signature_base64=cryptoSign(null,Buffer.concat([DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64');
+    out.push({...signed,attestation:{algorithm:'ed25519',key_id:keyId,signature_base64}});
+}
+function journal(items){
+  const out=[];
+  for(const [type,payload] of items)appendJournal(out,type,payload);
+  return out;
+}
+
+const base=journal([
+  ['goal_created',{submission_id:'incident-1',acceptance:'build and tests pass'}],
+  ['planner_decision',{planner_round:1,decision:{action:'inspect',summary:'inspect linker output'}}],
+  ['profile_completed',{profile_id:'build',passed:false,tool:'msbuild',operation:'build',platform:'win32',architecture:'x64',
+    exit_code:1,diagnostic_codes:['LNK2019'],stderr_sha256:sha('stderr'),target:'release',symbols:['FooBar'],receipt_sha256:sha('build-fail')}],
+  ['planner_decision',{planner_round:2,decision:{action:'patch',summary:'add missing FooBar definition'}}],
+  ['native_diff_committed',{paths:['src/foo.cpp'],diff_receipt_sha256:sha('diff'),artifact_sha256:sha('foo-obj')}],
+  ['profile_completed',{profile_id:'build',passed:true,receipt_sha256:sha('build-pass')}],
+  ['release_completed',{receipt_sha256:sha('release')}]
+]);
+
+test('R41 episodic memory contains only canonical journal references and rejects nonexistent events',()=>{
+  const episode=deriveEpisodicMemory(goal,base,{publicKey,keyId});
+  assert.equal(episode.schema,'deadbyte.episode.v1');
+  assert.equal(episode.outcome,'succeeded');
+  assert.deepEqual(episode.event_range,{first_seq:1,last_seq:7,journal_head_sha256:base.at(-1).event_sha256});
+  assert.ok(episode.observations.every(item=>item.event_ref?.event_sha256));
+  assert.ok(episode.decisions.every(item=>item.event_ref?.event_sha256));
+  assert.ok(episode.receipt_refs.includes(sha('release')));
+  assert.equal(verifyEpisode(episode,{goal,events:base,publicKey,keyId}).ok,true);
+  const forged=structuredClone(episode);forged.actions[0].event_ref.event_sha256=sha('nonexistent');
+  assert.equal(verifyEpisode(forged,{goal,events:base,publicKey,keyId}).ok,false);
+});
+
+test('R41 decision memory preserves supersession edges and rejects cycles',()=>{
+  const events=journal([
+    ['goal_created',{submission_id:'decisions'}],
+    ['planner_decision',{planner_round:1,decision:{action:'inspect',summary:'inspect first'}}]
+  ]);
+  const firstId=sha({schema:'deadbyte.decision-id.v1',goal_id:goalId,event_sha256:events[1].event_sha256});
+  appendJournal(events,'planner_decision',{planner_round:2,decision:{action:'patch',summary:'patch after evidence',supersedes:firstId}});
+  const memory=deriveDecisionMemory(goal,events,{publicKey,keyId});
+  assert.equal(memory.decisions.length,2);
+  assert.equal(memory.decisions[0].status,'superseded');
+  assert.equal(memory.decisions[1].status,'active');
+  assert.equal(memory.decisions[1].supersedes,memory.decisions[0].decision_id);
+  assert.equal(memory.decisions[0].superseded_by,memory.decisions[1].decision_id);
+  assert.equal(verifyDecisionMemory(memory,{goal,events,publicKey,keyId}).ok,true);
+
+  const cyclic=structuredClone(memory);
+  cyclic.decisions[0].supersedes=cyclic.decisions[1].decision_id;
+  cyclic.decisions[1].superseded_by=cyclic.decisions[0].decision_id;
+  assert.equal(verifyDecisionMemory(cyclic,{goal,events,publicKey,keyId}).ok,false);
+});
+
+test('R41 incidents use deterministic structured fingerprints and reject spoofing',()=>{
+  const memory=deriveIncidentMemory(goal,base,{publicKey,keyId});
+  assert.equal(memory.schema,'deadbyte.incident-memory.v1');
+  assert.equal(memory.incidents.length,1);
+  const incident=memory.incidents[0];
+  assert.equal(incident.fingerprint.tool,'msbuild');
+  assert.deepEqual(incident.fingerprint.diagnostic_codes,['LNK2019']);
+  assert.deepEqual(incident.fingerprint.symbols,['FooBar']);
+  assert.equal(incident.status,'resolved');
+  assert.ok(incident.successful_fix.some(ref=>ref.event_sha256===base[4].event_sha256));
+  assert.equal(verifyIncidentMemory(memory,{goal,events:base,publicKey,keyId}).ok,true);
+  const forged=structuredClone(memory);forged.incidents[0].fingerprint.exit_code=0;
+  assert.equal(verifyIncidentMemory(forged,{goal,events:base,publicKey,keyId}).ok,false);
+});

package/test/memory-retrieval-r41.test.mjs

@@ -0,0 +1,124 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, generateKeyPairSync, sign as cryptoSign } from 'node:crypto';
+import { mkdtemp,readFile,rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import {
+  buildMemoryCorpus,buildRetrievalIndex,verifyRetrievalIndex,queryMemoryIndex,
+  buildWorkingMemory,verifyWorkingMemory,createSemanticMemoryAdapter,createR41MemoryProvider
+} from '../src/memory-r41.mjs';
+
+const DOMAIN=Buffer.from('DEADBYTE-AUTONOMOUS-EVENT-V1\0');
+const ZERO='0'.repeat(64);
+const sha=value=>createHash('sha256').update(Buffer.from(typeof value==='string'?value:canonicalJson(value),'utf8')).digest('hex');
+const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+const keyId=sha(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+const goalId=sha('retrieval-goal');
+const manifest=sha('r41-release');
+const goal={schema:'deadbyte.autonomous-goal.v1',goal_id:goalId,goal_sha256:sha('retrieval-body'),root_id:'core',
+  title:'repair parser',goal:'repair ParserSymbol timeout',acceptance:'build and tests pass'};
+
+function journal(items){
+  const out=[];
+  for(const [index,[type,payload]] of items.entries()){
+    const body={schema:'deadbyte.autonomous-event.v1',seq:index+1,goal_id:goalId,
+      created_at_utc:`2026-09-20T04:00:${String(index).padStart(2,'0')}.000Z`,prev_sha256:out.at(-1)?.event_sha256??ZERO,type,payload};
+    const event_sha256=sha(body);const signed={...body,event_sha256};
+    const signature_base64=cryptoSign(null,Buffer.concat([DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64');
+    out.push({...signed,attestation:{algorithm:'ed25519',key_id:keyId,signature_base64}});
+  }
+  return out;
+}
+
+const events=journal([
+  ['goal_created',{submission_id:'retrieval',acceptance:'build and tests pass'}],
+  ['planner_decision',{planner_round:1,decision:{action:'inspect',summary:'inspect ParserSymbol timeout'}}],
+  ['profile_completed',{profile_id:'test',passed:false,tool:'node',operation:'test',platform:'win32',architecture:'x64',
+    timeout_state:'expired',diagnostic_codes:['ERR_TEST_TIMEOUT'],stderr_sha256:sha('stderr'),symbols:['ParserSymbol'],receipt_sha256:sha('failed')}],
+  ['native_diff_committed',{paths:['src/parser.mjs'],diff_receipt_sha256:sha('diff'),artifact_sha256:sha('artifact')}],
+  ['profile_completed',{profile_id:'test',passed:true,receipt_sha256:sha('passed')}],
+  ['release_completed',{receipt_sha256:sha('release')}]
+]);
+
+function fixture(){
+  const corpus=buildMemoryCorpus({goal,events,publicKey,keyId,sourceReleaseManifest:manifest});
+  const index=buildRetrievalIndex(corpus,{sourceReleaseManifest:manifest});
+  return {corpus,index};
+}
+
+test('R41 retrieval indexes rebuild byte-identically and support exact token symbol artifact and incident lookup',()=>{
+  const {corpus,index}=fixture();
+  const rebuilt=buildRetrievalIndex(corpus,{sourceReleaseManifest:manifest});
+  assert.equal(canonicalJson(index),canonicalJson(rebuilt));
+  assert.equal(verifyRetrievalIndex(index,{corpus,sourceReleaseManifest:manifest}).ok,true);
+  assert.ok(queryMemoryIndex(index,{query:'ParserSymbol timeout',limit:8}).candidate_ids.length>=1);
+  assert.ok(queryMemoryIndex(index,{symbol:'ParserSymbol',limit:8}).candidate_ids.length>=1);
+  assert.ok(queryMemoryIndex(index,{artifact_sha256:sha('artifact'),limit:8}).candidate_ids.length>=1);
+  assert.ok(queryMemoryIndex(index,{incident_fingerprint:corpus.incidents.incidents[0].fingerprint_sha256,limit:8}).candidate_ids.includes(corpus.incidents.incidents[0].incident_id));
+  assert.deepEqual(queryMemoryIndex(index,{id:corpus.episode.episode_id,limit:1}).candidate_ids,[corpus.episode.episode_id]);
+});
+
+test('R41 poisoned or cross-release indexes fail closed',()=>{
+  const {corpus,index}=fixture();
+  const poisoned=structuredClone(index);
+  poisoned.token_index.timeout=[sha('forged-document')];
+  assert.equal(verifyRetrievalIndex(poisoned,{corpus,sourceReleaseManifest:manifest}).ok,false);
+  assert.equal(verifyRetrievalIndex(index,{corpus,sourceReleaseManifest:sha('other-release')}).ok,false);
+});
+
+test('R41 working memory is bounded provenance-bearing disposable state and rejects staleness',()=>{
+  const {corpus,index}=fixture();
+  const args={goal,events,corpus,index,publicKey,keyId,sourceReleaseManifest:manifest,byteBudget:16384,
+    currentPlan:{step:'verify'},currentFiles:[{path:'src/parser.mjs',sha256:sha('parser'),source_event_sha256:events[3].event_sha256}],
+    currentSymbols:['ParserSymbol'],currentAuthority:{coding:{armed:true,reason:'standing-grant',instance_nonce:sha('secret')}}};
+  const working=buildWorkingMemory(args);
+  assert.ok(Buffer.byteLength(canonicalJson(working),'utf8')<=16384);
+  assert.equal(working.source_release_manifest,manifest);
+  assert.equal(working.journal_head_sha256,events.at(-1).event_sha256);
+  assert.equal(working.current_authority.authorizes_execution,false);
+  assert.equal(JSON.stringify(working).includes('instance_nonce'),false);
+  assert.ok(working.relevant_incidents[0].source_event_ids.length>=1);
+  assert.equal(verifyWorkingMemory(working,args).ok,true);
+  const staleArgs={...args,events:events.slice(0,-1)};
+  assert.equal(verifyWorkingMemory(working,staleArgs).ok,false);
+  assert.equal(verifyWorkingMemory(working,{...args,sourceReleaseManifest:sha('wrong-release')}).ok,false);
+});
+
+test('R41 semantic retrieval is disabled by default and verifies candidate IDs against canonical memory',async()=>{
+  const {corpus,index}=fixture();
+  const disabled=createSemanticMemoryAdapter();
+  await assert.rejects(disabled.query({query:'parser',corpus,index,sourceReleaseManifest:manifest}),/disabled/);
+
+  const validId=corpus.incidents.incidents[0].incident_id;
+  const enabled=createSemanticMemoryAdapter({enabled:true,retrieveCandidates:async()=>[validId]});
+  const resolved=await enabled.query({query:'parser timeout',corpus,index,sourceReleaseManifest:manifest});
+  assert.deepEqual(resolved.candidate_ids,[validId]);
+  assert.equal(resolved.records[0].incident_id,validId);
+
+  const poisoned=createSemanticMemoryAdapter({enabled:true,retrieveCandidates:async()=>[sha('not-canonical')]});
+  await assert.rejects(poisoned.query({query:'parser',corpus,index,sourceReleaseManifest:manifest}),/canonical candidate/);
+});
+
+test('R41 content-addressed projections survive deletion and rebuild byte-identically',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r41-provider-'));
+  try{
+    const provider=createR41MemoryProvider({memoryRoot:root,sourceReleaseManifest:manifest,writerVersion:'0.13.0',
+      privateKey,publicKey,keyId,byteBudget:16384});
+    const input={goal,events,currentPlan:null,currentFiles:[],currentSymbols:['ParserSymbol'],currentAuthority:{}};
+    const first=await provider.refresh(input);
+    assert.equal(first.replay_mode,'full-replay');
+    const snapshotBytes=await readFile(first.snapshot_path);
+    const indexBytes=await readFile(first.index_path);
+    await rm(first.index_path);
+    const rebuilt=await provider.refresh(input);
+    assert.equal(rebuilt.replay_mode,'snapshot-suffix');
+    assert.equal(rebuilt.snapshot_sha256,first.snapshot_sha256);
+    assert.equal(rebuilt.index_sha256,first.index_sha256);
+    assert.deepEqual(await readFile(rebuilt.snapshot_path),snapshotBytes);
+    assert.deepEqual(await readFile(rebuilt.index_path),indexBytes);
+    assert.equal(provider.semantic_enabled,false);
+    assert.equal(Object.hasOwn(provider,'arm'),false);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/memory-snapshot-r41.test.mjs

@@ -0,0 +1,106 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, generateKeyPairSync, sign as cryptoSign } from 'node:crypto';
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import {
+  deriveMemoryState,
+  createMemorySnapshot,
+  verifyMemorySnapshot,
+  replayFromMemorySnapshot,
+  loadMemoryState,
+  writeMemorySnapshot
+} from '../src/memory-r41.mjs';
+
+const EVENT_DOMAIN=Buffer.from('DEADBYTE-AUTONOMOUS-EVENT-V1\0');
+const ZERO='0'.repeat(64);
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+const keyId=sha(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+const goalId=sha('goal');
+const manifest=sha('r41-manifest');
+const goal={schema:'deadbyte.autonomous-goal.v1',goal_id:goalId,goal_sha256:sha('goal-body'),title:'repair',goal:'repair source',acceptance:'tests pass'};
+
+function journal(types){
+  const events=[];
+  for(const [index,[type,payload]] of types.entries()){
+    const body={schema:'deadbyte.autonomous-event.v1',seq:index+1,goal_id:goalId,
+      created_at_utc:`2026-09-20T00:00:${String(index).padStart(2,'0')}.000Z`,
+      prev_sha256:events.at(-1)?.event_sha256??ZERO,type,payload};
+    const event_sha256=sha(body);
+    const signed={...body,event_sha256};
+    const signature_base64=cryptoSign(null,Buffer.concat([EVENT_DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64');
+    events.push({...signed,attestation:{algorithm:'ed25519',key_id:keyId,signature_base64}});
+  }
+  return events;
+}
+
+const events=journal([
+  ['goal_created',{submission_id:'r41',acceptance:'tests pass'}],
+  ['planner_decision',{planner_round:1,decision:{action:'inspect',summary:'inspect source'}}],
+  ['inspect_completed',{contexts:[{path:'src/a.mjs',sha256:sha('a'),bytes:1}]}],
+  ['profile_completed',{profile_id:'test',passed:false,receipt_sha256:sha('failed')}],
+  ['planner_decision',{planner_round:2,decision:{action:'patch',summary:'apply exact fix'}}],
+  ['native_diff_committed',{paths:['src/a.mjs'],mutation_epoch:1,diff_receipt_sha256:sha('diff')}],
+  ['profile_completed',{profile_id:'test',passed:true,receipt_sha256:sha('passed')}],
+  ['release_completed',{receipt_sha256:sha('release')}]
+]);
+
+function makeSnapshot(prefix=events.slice(0,5)){
+  return createMemorySnapshot({goal,events:prefix,snapshotSequence:1,sourceReleaseManifest:manifest,
+    writerVersion:'0.13.0',createdAtUtc:'2026-09-20T01:00:00.000Z',privateKey,keyId,publicKey});
+}
+
+test('R41 snapshot plus verified suffix is byte-equivalent to full replay',()=>{
+  const snapshot=makeSnapshot();
+  assert.equal(snapshot.schema,'deadbyte.memory-snapshot.v1');
+  assert.equal(snapshot.schema_version,1);
+  assert.equal(snapshot.last_event_seq,5);
+  assert.equal(snapshot.journal_prefix_hash,events[4].event_sha256);
+  assert.equal(snapshot.source_release_manifest,manifest);
+  assert.equal(verifyMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest:manifest}).ok,true);
+  const resumed=replayFromMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest:manifest});
+  assert.equal(canonicalJson(resumed),canonicalJson(deriveMemoryState(goal,events,{publicKey,keyId})));
+});
+
+test('R41 snapshot tampering fails closed for schema sequence prefix state hash and signature',()=>{
+  const base=makeSnapshot();
+  const mutations=[
+    value=>{value.schema='deadbyte.memory-snapshot.v0';},
+    value=>{value.snapshot_sequence=0;},
+    value=>{value.last_event_seq=6;},
+    value=>{value.journal_prefix_hash=sha('wrong-prefix');},
+    value=>{value.state.last_event_seq=4;},
+    value=>{value.state_hash=sha('wrong-state');},
+    value=>{value.attestation.signature_base64=Buffer.alloc(64).toString('base64');}
+  ];
+  for(const mutate of mutations){
+    const candidate=structuredClone(base);mutate(candidate);
+    const proof=verifyMemorySnapshot(candidate,{goal,events,publicKey,keyId,sourceReleaseManifest:manifest});
+    assert.equal(proof.ok,false,JSON.stringify(candidate));
+  }
+});
+
+test('R41 missing or corrupt snapshot falls back explicitly to full verified replay',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r41-snapshot-'));
+  const file=path.join(root,'memory.snapshot.json');
+  const missing=await loadMemoryState({snapshotPath:file,goal,events,publicKey,keyId,sourceReleaseManifest:manifest});
+  assert.equal(missing.mode,'full-replay');
+  assert.equal(missing.snapshot_reason,'missing');
+  assert.equal(canonicalJson(missing.state),canonicalJson(deriveMemoryState(goal,events,{publicKey,keyId})));
+
+  await writeFile(file,'{"broken":true}\n');
+  const corrupt=await loadMemoryState({snapshotPath:file,goal,events,publicKey,keyId,sourceReleaseManifest:manifest});
+  assert.equal(corrupt.mode,'full-replay');
+  assert.match(corrupt.snapshot_reason,/snapshot/i);
+
+  const snapshot=makeSnapshot();
+  await writeMemorySnapshot(file,snapshot);
+  const disk=JSON.parse(await readFile(file,'utf8'));
+  assert.equal(disk.snapshot_sha256,snapshot.snapshot_sha256);
+  const resumed=await loadMemoryState({snapshotPath:file,goal,events,publicKey,keyId,sourceReleaseManifest:manifest});
+  assert.equal(resumed.mode,'snapshot-suffix');
+  assert.equal(canonicalJson(resumed.state),canonicalJson(deriveMemoryState(goal,events,{publicKey,keyId})));
+});

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,40 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows current R40 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
-  const stateRoot=await temp('deadbyte-r33-windows-evidence-');
+test('Windows current R42 gate emits manifest-bound model-eval evidence outside the candidate tree', async()=>{
+  const stateRoot=await temp('deadbyte-r42-windows-evidence-');
   try{
-    const gate=await readFile(path.join(root,'scripts','gate-windows-r40.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence-r40\.mjs/,'gate-windows-r40.ps1 must invoke the evidence writer');
-    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence-r40.mjs')],{
-      cwd:root,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+    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 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(result.code,0,result.stderr||result.stdout);
-    const summary=JSON.parse(result.stdout.trim());
+    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 evidence=JSON.parse(await readFile(summary.path,'utf8'));
-    const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r40-windows-gate.v1');
+    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.12.0');
+    assert.equal(evidence.version,'0.14.0');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.12.0 / R40 WINDOWS BATCH GATE: PASS');
+    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.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }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-r40.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r40.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r40.mjs');
+  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(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
@@ -72,4 +72,4 @@ test('R34 parity isolates scratch mutation and search from the core release tree
   assert.match(parity, /machine_search_start[\s\S]*?root_id:scratchRoot/);
   assert.match(parity, /machine_fs_delete[\s\S]*?root_id:scratchRoot/);
   assert.doesNotMatch(parity, /machine_fs_(?:write|read|edit_exact|stat|delete)'[^\n]*root_id:'core'/);
-});
+});

package/test/r41-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,R41_PREDECESSOR_RELEASE_ID,R41_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r41.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r41.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.r41-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+  candidate:{release_id:`v0.13.0-${manifest.slice(0,16)}`,version:'0.13.0',manifest_sha256:manifest},
+  immutable_slot:{protected:true,release_root:'C:/immutable/r41',development_root:'D:/Projects/deadbyte-mcp-r41-memory-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:R41_PREDECESSOR_RELEASE_ID,version:'0.12.0',manifest_sha256:R41_PREDECESSOR_MANIFEST},predecessor_disarmed:{status:'passed',tool_count:42,capability_closure:true},
+  successor:{release_id:`v0.13.0-${manifest.slice(0,16)}`,version:'0.13.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'].map(key=>[key,true]))};}
+
+test('R41 parity requires exact R40 predecessor and immutable R41 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('R41 release machinery binds 0.13.0, R40 predecessor, memory gates and R41 domains',async()=>{const [gate,deferred,paritySource,writer,verifier,evidence,suite]=await Promise.all([
+  text('scripts/gate-windows-r41.ps1'),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('scripts/release-parity-tests-r41.ps1')]);
+  assert.equal(R41_PREDECESSOR_RELEASE_ID,'v0.12.0-70906ae0a7e4f062');assert.equal(R41_PREDECESSOR_MANIFEST,'70906ae0a7e4f0627efbb5087b40b85677c81ed6d64ed89c0ba2af846e390f39');
+  assert.match(gate,/r41-parent-verify/);assert.match(gate,/memory-history-r41\.test\.mjs/);assert.match(gate,/DEADBYTE V0\.13\.0 \/ R41 WINDOWS BATCH GATE: PASS/);
+  assert.match(deferred,/--expected-version','0\.13\.0'/);assert.match(paritySource,/deadbyte\.r41-parity\.v1/);
+  for(const source of [writer,verifier]){assert.match(source,/DEADBYTE-R41-FINAL-CLOSURE-V1/);assert.match(source,/deadbyte\.r41-final-closure\.v1/);assert.match(source,/R41 DETERMINISTIC MEMORY BASELINE/);}
+  assert.equal(typeof verifyFinalClosureObject,'function');assert.match(evidence,/deadbyte\.r41-windows-gate\.v1/);assert.match(suite,/memory-autonomous-integration-r41\.test\.mjs/);
+});
+
+
+test('R41 derived memory storage is namespaced by exact release manifest',async()=>{
+  const [server,paritySource]=await Promise.all([text('src/mcp-server.mjs'),text('scripts/release-parity-r41.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/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/release-version.test.mjs

@@ -3,21 +3,22 @@ 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 R40_PREDECESSOR_RELEASE_ID='v0.11.3-ce761dd6e014d42e';
-const R40_PREDECESSOR_MANIFEST='ce761dd6e014d42eddb635855038e0ce049c63c6e3af7e63c3005bbe198bcf7b';
-test('R40 authority agrees on V0.12.0 and preserves exact sealed public 0.11.3 predecessor',async()=>{
+const R42_PREDECESSOR_RELEASE_ID='v0.13.0-3255be10de4daf08';
+const R42_PREDECESSOR_MANIFEST='3255be10de4daf0837d67d1ab1913b785b8b8215bc7405823c2ff46968c4b98f';
+test('R42 authority agrees on V0.14.0 and preserves exact sealed public R41 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-r40.ps1'),text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r40.mjs'),text('scripts/release-parity-r40.mjs'),text('scripts/final-closure-r40.mjs'),text('scripts/final-closure-verify-r40.mjs'),text('scripts/windows-gate-evidence-r40.mjs'),text('controller/deadbyte-semantic-lsp-config.json')]);
- assert.equal(pkg.version,'0.12.0');assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r40.ps1');
- assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r40.mjs');assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r40.mjs');
- assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r40.mjs');assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r40.mjs');
+ 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-r42.ps1'),text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),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('R42-PARENT.json'),text('controller/deadbyte-semantic-lsp-config.json')]);
+ assert.equal(pkg.version,'0.14.0');assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r42.ps1');
+ assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r42.mjs');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['desktop:policy:refresh'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/init-desktop-policy-r40.ps1');
- assert.match(version,/DEADBYTE_VERSION = '0\.12\.0'/);assert.match(controller,/CONTROLLER V0\.12\.0 \/ R40/);assert.match(gate,/DEADBYTE V0\.12\.0 \/ R40 WINDOWS BATCH GATE: PASS/);
- assert.match(readme,/^DEADBYTE MCP V0\.12\.0 \/ R40 DESKTOP COMPUTER-USE BASELINE$/m);assert.match(architecture,/^# DEADBYTE MCP V0\.12\.0 \/ R40 ARCHITECTURE$/m);assert.match(controllerReadme,/^DEADBYTE MCP V0\.12\.0 \/ R40 CONTROLLER$/m);
- assert.match(deferred,/--expected-version','0\.12\.0'/);assert.match(deferred,/--enable-desktop/);assert.match(parity,/R40_PREDECESSOR_RELEASE_ID='v0\.11\.3-ce761dd6e014d42e'/);assert.match(parity,new RegExp(R40_PREDECESSOR_MANIFEST));
- assert.match(parity,/version==='0\.12\.0'|version:'0\.12\.0'/);assert.match(closure,/version:'0\.12\.0'/);assert.match(closureVerify,/DEADBYTE V0\.12\.0 \/ R40 WINDOWS BATCH GATE: PASS/);assert.match(windowsGate,/version:'0\.12\.0'/);
- assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');assert.equal(R40_PREDECESSOR_RELEASE_ID,'v0.11.3-ce761dd6e014d42e');
+ assert.match(version,/DEADBYTE_VERSION = '0\.14\.0'/);assert.match(controller,/CONTROLLER V0\.14\.0 \/ R42/);assert.match(gate,/DEADBYTE V0\.14\.0 \/ R42 WINDOWS BATCH GATE: PASS/);
+ assert.match(readme,/^DEADBYTE MCP V0\.14\.0 \/ R42 AGENTIC GOVERNANCE BASELINE$/m);assert.match(architecture,/^# DEADBYTE MCP V0\.14\.0 \/ R42 ARCHITECTURE$/m);assert.match(controllerReadme,/^DEADBYTE MCP V0\.14\.0 \/ R42 CONTROLLER$/m);
+ assert.match(deferred,/--expected-version','0\.14\.0'/);assert.match(deferred,/--enable-desktop/);assert.match(parity,/R42_PREDECESSOR_RELEASE_ID='v0\.13\.0-3255be10de4daf08'/);assert.match(parity,new RegExp(R42_PREDECESSOR_MANIFEST));
+ assert.match(parity,/version==='0\.14\.0'|version:'0\.14\.0'/);assert.match(closure,/version:'0\.14\.0'/);assert.match(closureVerify,/DEADBYTE V0\.14\.0 \/ R42 WINDOWS BATCH GATE: PASS/);assert.match(windowsGate,/version:'0\.14\.0'/);
+ assert.equal(JSON.parse(parent).parent_manifest_sha256,R42_PREDECESSOR_MANIFEST);
+ assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');assert.equal(R42_PREDECESSOR_RELEASE_ID,'v0.13.0-3255be10de4daf08');
 });
 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'/);});