deadbyte-mcp 0.12.0 → 0.13.0

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.12.0';
+export const DEADBYTE_VERSION = '0.13.0';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/cli-entrypoint.test.mjs

@@ -21,7 +21,7 @@ test('npx CLI reports the canonical package version through --version, -v and ve
   for(const arg of ['--version','-v','version']){
     const result=spawnSync(process.execPath,[cliPath,arg],{cwd:root,encoding:'utf8',windowsHide:true});
     assert.equal(result.status,0,result.stderr);
-    assert.equal(result.stdout.trim(),'0.12.0');
+    assert.equal(result.stdout.trim(),'0.13.0');
   }
 });
 

package/test/controller-desktop-r40.test.mjs

@@ -70,7 +70,8 @@ test('R40 policy initializer pins current native observer and input and starts D
   assert.match(source,/deadbyte-desktop-observer-r40\.exe/);
   assert.match(source,/deadbyte-desktop-input-r40\.exe/);
   assert.match(source,/deadbyte-desktop-uia-r40\.exe/);
-  assert.match(source,/Get-FileHash/);
+  assert.match(source,/System\.Security\.Cryptography\.SHA256/);
+  assert.match(source,/Get-Sha256Hex -Path \$Observer/);
   assert.match(source,/Remove-Item -LiteralPath \$Grant/);
   assert.match(source,/grant_state='DISARMED'/);
   assert.match(source,/deadbyte\.desktop-policy\.v1/);

package/test/core.test.mjs

@@ -105,7 +105,7 @@ test('proof execution creates deterministic output and signed verifiable receipt
   assert.equal(result.receipt.request.schema, 'deadbyte.request.v1');
   assert.match(result.receipt.request.nonce, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.request.sha256, /^[0-9a-f]{64}$/);
-  assert.equal(result.receipt.runtime.package_version, '0.12.0');
+  assert.equal(result.receipt.runtime.package_version, '0.13.0');
   assert.match(result.receipt.runtime.mcp_ingress_adapter, /^(?:none|tunnel-stdio-probe-compat-v1)$/);
   assert.match(result.receipt.runtime.mcp_ingress_adapter_sha256, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.runtime.mcp_ingress_mode_source_sha256, /^[0-9a-f]{64}$/);

package/test/helpers/autonomous-r34-fixture.mjs

@@ -12,7 +12,7 @@ import { createAutonomousRuntime } from '../../src/autonomous-runtime.mjs';
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 const nonce = () => randomBytes(32).toString('hex');
 
-export async function createR34Fixture({authority='armed',withFailingProfile=false,withStatefulProfile=false,codingRuntimeFactory=null,nativeDiffRuntimeFactory=null,desktopMemoryProvider=null,desktopRuntime=null}={}) {
+export async function createR34Fixture({authority='armed',withFailingProfile=false,withStatefulProfile=false,codingRuntimeFactory=null,nativeDiffRuntimeFactory=null,desktopMemoryProvider=null,memoryProvider=null,desktopRuntime=null}={}) {
   const root = await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-e2e-'));
   const project = path.join(root,'project');
   const trust = path.join(root,'trust');
@@ -73,8 +73,8 @@ export async function createR34Fixture({authority='armed',withFailingProfile=fal
   const machineFsRuntime = createMachineFsRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   const baseNativeDiffRuntime = createNativeDiffRuntime({policy,codingRuntime,machineFsRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   const nativeDiffRuntime = nativeDiffRuntimeFactory ? nativeDiffRuntimeFactory(baseNativeDiffRuntime) : baseNativeDiffRuntime;
-  const createRuntime = ({codingRuntimeOverride=codingRuntime,nativeDiffRuntimeOverride=nativeDiffRuntime,desktopMemoryProviderOverride=desktopMemoryProvider,desktopRuntimeOverride=desktopRuntime}={}) => createAutonomousRuntime({policy,codingRuntime:codingRuntimeOverride,nativeDiffRuntime:nativeDiffRuntimeOverride,machineFsRuntime,
-    desktopRuntime:desktopRuntimeOverride,desktopMemoryProvider:desktopMemoryProviderOverride,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const createRuntime = ({codingRuntimeOverride=codingRuntime,nativeDiffRuntimeOverride=nativeDiffRuntime,desktopMemoryProviderOverride=desktopMemoryProvider,memoryProviderOverride=memoryProvider,desktopRuntimeOverride=desktopRuntime}={}) => createAutonomousRuntime({policy,codingRuntime:codingRuntimeOverride,nativeDiffRuntime:nativeDiffRuntimeOverride,machineFsRuntime,
+    desktopRuntime:desktopRuntimeOverride,desktopMemoryProvider:desktopMemoryProviderOverride,memoryProvider:memoryProviderOverride,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   return {
     root,project,target,keys,codingPolicy,policy,baseCodingRuntime,codingRuntime,machineFsRuntime,nativeDiffRuntime,createRuntime,runtime:createRuntime(),
     initial_sha256:sha(await readFile(target)),arm,disarm,

package/test/memory-autonomous-integration-r41.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+import { loadPrivateSigningKey,loadPublicVerifyKey } from '../src/trust.mjs';
+import { createR41MemoryProvider } from '../src/memory-r41.mjs';
+
+const sha=value=>createHash('sha256').update(String(value)).digest('hex');
+
+test('R41 planner request binds verified bounded memory before a mutating decision',async()=>{
+  const f=await createR34Fixture();
+  try{
+    const signing=await loadPrivateSigningKey(f.keys.privateKeyPath);
+    const verify=await loadPublicVerifyKey(f.keys.publicKeyPath);
+    const provider=createR41MemoryProvider({memoryRoot:path.join(f.root,'memory'),sourceReleaseManifest:sha('r41-release'),
+      writerVersion:'0.13.0',privateKey:signing.privateKey,publicKey:verify.publicKey,keyId:signing.keyId,byteBudget:65536});
+    const runtime=f.createRuntime({memoryProviderOverride:provider});
+    const goal=await runtime.submit({submissionId:'r41-memory-binding',rootId:'project',title:'repair',goal:'repair x.txt',acceptance:'x is y'});
+    const run=await runtime.run({goalId:goal.goal_id,maxCycles:1});
+    assert.equal(run.status,'input_required');
+    assert.match(run.planner_request.prompt,/"long_term_memory"/);
+    assert.match(run.planner_request.prompt,/"working_memory_sha256":"[0-9a-f]{64}"/);
+    const journal=await runtime.events({goalId:goal.goal_id,fromSeq:1,limit:100});
+    const requested=journal.events.find(event=>event.type==='planner_requested');
+    assert.match(requested.payload.working_memory_sha256,/^[0-9a-f]{64}$/);
+    assert.match(requested.payload.memory_snapshot_sha256,/^[0-9a-f]{64}$/);
+    assert.match(requested.payload.memory_index_sha256,/^[0-9a-f]{64}$/);
+    assert.equal(requested.payload.memory_source_release_manifest,sha('r41-release'));
+  }finally{await f.cleanup();}
+});

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

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash,generateKeyPairSync,sign as cryptoSign } from 'node:crypto';
+import { mkdir,mkdtemp,rm,writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import { createR41MemoryProvider } from '../src/memory-r41.mjs';
+import { verifyR41Memory } from '../scripts/verify-memory-r41.mjs';
+
+const EVENT_DOMAIN=Buffer.from('DEADBYTE-AUTONOMOUS-EVENT-V1\0');
+const GOAL_DOMAIN=Buffer.from('DEADBYTE-AUTONOMOUS-GOAL-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=createHash('sha256').update(Buffer.from(publicKey.export({type:'spki',format:'der'}))).digest('hex');
+const manifest=sha('r41-history-release');
+
+function eventJournal(goalId,items){
+  const events=[];
+  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-20T08: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};
+    events.push({...signed,attestation:{algorithm:'ed25519',key_id:keyId,
+      signature_base64:cryptoSign(null,Buffer.concat([EVENT_DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64')}});
+  }
+  return events;
+}
+function signedGoal(goalId,title){
+  const identity={schema:'deadbyte.autonomous-goal.v1',policy_sha256:sha('policy'),root_id:'core',submission_id:title,
+    title,goal:`repair ${title}`,acceptance:'tests pass',max_iterations:8};
+  const body={...identity,goal_sha256:sha(identity),goal_id:goalId};
+  return {...body,attestation:{algorithm:'ed25519',key_id:keyId,
+    signature_base64:cryptoSign(null,Buffer.concat([GOAL_DOMAIN,Buffer.from(canonicalJson(body),'utf8')]),privateKey).toString('base64')}};
+}
+async function writeHistory(root,goal,events){
+  const dir=path.join(root,goal.goal_id);await mkdir(path.join(dir,'events'),{recursive:true});
+  await writeFile(path.join(dir,'goal.json'),`${canonicalJson(goal)}\n`);
+  for(const event of events)await writeFile(path.join(dir,'events',`${String(event.seq).padStart(6,'0')}.json`),`${canonicalJson(event)}\n`);
+}
+
+test('R41 provider retrieves verified prior-goal memory and excludes cross-release journals',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r41-history-'));
+  try{
+    const journalRoot=path.join(root,'goals');const memoryRoot=path.join(root,'memory');
+    const priorId=sha('prior-goal');const priorGoal=signedGoal(priorId,'ParserSymbol timeout');
+    const priorEvents=eventJournal(priorId,[
+      ['goal_created',{source_release_manifest:manifest}],
+      ['profile_completed',{profile_id:'test',passed:false,diagnostic_codes:['ERR_PARSER_TIMEOUT'],symbols:['ParserSymbol']}]
+    ]);
+    await writeHistory(journalRoot,priorGoal,priorEvents);
+    const foreignId=sha('foreign-goal');const foreignGoal=signedGoal(foreignId,'ParserSymbol foreign');
+    await writeHistory(journalRoot,foreignGoal,eventJournal(foreignId,[['goal_created',{source_release_manifest:sha('other-release')}]]));
+    const currentId=sha('current-goal');const signedCurrent=signedGoal(currentId,'ParserSymbol regression');
+    await writeHistory(journalRoot,signedCurrent,eventJournal(currentId,[['goal_created',{source_release_manifest:manifest}]]));
+    const currentGoal={...signedCurrent};delete currentGoal.attestation;
+    const currentEvents=eventJournal(currentId,[['goal_created',{source_release_manifest:manifest}]]);
+    const provider=createR41MemoryProvider({memoryRoot,journalRoot,sourceReleaseManifest:manifest,privateKey,publicKey,keyId,byteBudget:32768});
+    const result=await provider.refresh({goal:currentGoal,events:currentEvents,currentSymbols:['ParserSymbol']});
+    assert.equal(result.historical_goal_count,1);
+    assert.ok(result.planner_context.historical_memory.length>=1);
+    assert.equal(result.planner_context.historical_memory.some(item=>item.goal?.goal_id===foreignId||item.goal_id===foreignId),false);
+    assert.equal(result.planner_context.historical_archive_sha256,result.historical_archive_sha256);
+    const grownPriorEvents=eventJournal(priorId,[
+      ['goal_created',{source_release_manifest:manifest}],
+      ['profile_completed',{profile_id:'test',passed:false,diagnostic_codes:['ERR_PARSER_TIMEOUT'],symbols:['ParserSymbol']}],
+      ['planner_decision',{decision:{summary:'retry parser',action:'run_profile'}}],
+      ['profile_completed',{profile_id:'test',passed:true,symbols:['ParserSymbol']}],
+      ['release_completed',{receipt_sha256:sha('prior-release-grown')}]
+    ]);
+    await rm(path.join(journalRoot,priorId),{recursive:true,force:true});
+    await writeHistory(journalRoot,priorGoal,grownPriorEvents);
+    const refreshed=await provider.refresh({goal:currentGoal,events:currentEvents,currentSymbols:['ParserSymbol']});
+    assert.notEqual(refreshed.historical_archive_sha256,result.historical_archive_sha256);
+    const publicKeyPath=path.join(root,'public.pem');await writeFile(publicKeyPath,publicKey.export({type:'spki',format:'pem'}));
+    const verified=await verifyR41Memory({memoryRoot,journalRoot,sourceReleaseManifest:manifest,publicKeyPath});
+    assert.equal(verified.status,'passed');assert.equal(verified.goal_count,1);assert.equal(verified.archive_count,2);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R41 provider fails closed on a poisoned same-release historical chain',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r41-history-poison-'));
+  try{
+    const journalRoot=path.join(root,'goals');const goalId=sha('poisoned-goal');const historical=signedGoal(goalId,'poisoned');
+    const events=eventJournal(goalId,[['goal_created',{source_release_manifest:manifest}],['release_completed',{}]]);
+    events[1].prev_sha256=sha('forged');
+    await writeHistory(journalRoot,historical,events);
+    const currentId=sha('current-poison-check');const current={...signedGoal(currentId,'current')};delete current.attestation;
+    const provider=createR41MemoryProvider({memoryRoot:path.join(root,'memory'),journalRoot,sourceReleaseManifest:manifest,privateKey,publicKey,keyId});
+    await assert.rejects(provider.refresh({goal:current,events:eventJournal(currentId,[['goal_created',{source_release_manifest:manifest}]])}),/predecessor mismatch|hash mismatch/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+
+test('R41 verifier accepts content-addressed indexes from earlier verified snapshot prefixes',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r41-history-prefix-index-'));
+  try{
+    const journalRoot=path.join(root,'goals');const memoryRoot=path.join(root,'memory');
+    const goalId=sha('growing-goal');const signed=signedGoal(goalId,'growing journal');const goal={...signed};delete goal.attestation;
+    const firstEvents=eventJournal(goalId,[
+      ['goal_created',{source_release_manifest:manifest}],
+      ['profile_completed',{profile_id:'test',passed:false,diagnostic_codes:['ERR_FIRST']}]
+    ]);
+    await writeHistory(journalRoot,signed,firstEvents);
+    const provider=createR41MemoryProvider({memoryRoot,journalRoot,sourceReleaseManifest:manifest,privateKey,publicKey,keyId,byteBudget:32768});
+    const first=await provider.refresh({goal,events:firstEvents});
+    const grownEvents=eventJournal(goalId,[
+      ['goal_created',{source_release_manifest:manifest}],
+      ['profile_completed',{profile_id:'test',passed:false,diagnostic_codes:['ERR_FIRST']}],
+      ['planner_decision',{decision:{summary:'retry safely',action:'run_profile'}}],
+      ['profile_completed',{profile_id:'test',passed:true}],
+      ['release_completed',{receipt_sha256:sha('grown-release')}]
+    ]);
+    await rm(path.join(journalRoot,goalId),{recursive:true,force:true});
+    await writeHistory(journalRoot,signed,grownEvents);
+    const grown=await provider.refresh({goal,events:grownEvents});
+    assert.notEqual(first.memory_sha256,grown.memory_sha256);
+    assert.notEqual(first.index_sha256,grown.index_sha256);
+    const publicKeyPath=path.join(root,'public.pem');await writeFile(publicKeyPath,publicKey.export({type:'spki',format:'pem'}));
+    const verified=await verifyR41Memory({memoryRoot,journalRoot,sourceReleaseManifest:manifest,publicKeyPath});
+    assert.equal(verified.status,'passed');
+    assert.equal(verified.snapshot_count,2);
+    assert.equal(verified.index_count,2);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

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

@@ -86,12 +86,12 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows current R40 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
+test('Windows current R41 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
   const stateRoot=await temp('deadbyte-r33-windows-evidence-');
   try{
-    const gate=await readFile(path.join(root,'scripts','gate-windows-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')],{
+    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);
@@ -99,12 +99,12 @@ test('Windows current R40 gate emits manifest-bound machine-readable evidence ou
     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.r41-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.13.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.13.0 / R41 WINDOWS BATCH GATE: PASS');
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -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-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(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'/);
-});
+});