deadbyte-mcp 0.11.3 → 0.13.0

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 R39 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-r39.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence-r39\.mjs/,'gate-windows-r39.ps1 must invoke the evidence writer');
-    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence-r39.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 R39 gate emits manifest-bound machine-readable evidence outside th
     assert.equal(summary.status,'written');
     const evidence=JSON.parse(await readFile(summary.path,'utf8'));
     const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r39-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.11.3');
+    assert.equal(evidence.version,'0.13.0');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.11.3 / R39 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

@@ -2,8 +2,8 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { R34_EXPECTED_TOOLS } from '../src/remote-mcp-r34-parity-client.mjs';
-import { validateParityEvidence } from '../scripts/release-parity-r39.mjs';
-import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r39.mjs';
+import { validateParityEvidence } from '../scripts/release-parity-r40.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r40.mjs';
 
 const root = new URL('../', import.meta.url);
 const text = rel => readFile(new URL(rel, root), 'utf8');
@@ -19,28 +19,28 @@ test('R34 public parity catalog is exact, unique, and includes production coding
 
 test('release parity and final verifier are package entry points', async () => {
   const pkg = JSON.parse(await text('package.json'));
-  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r39.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r39.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r39.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');
 });
 
-test('R39 final closure verifier is implementation-independent from production helpers', async () => {
-  const verifier = await text('scripts/final-closure-verify-r39.mjs');
-  const writer = await text('scripts/final-closure-r39.mjs');
+test('R40 final closure verifier is implementation-independent from production helpers', async () => {
+  const verifier = await text('scripts/final-closure-verify-r40.mjs');
+  const writer = await text('scripts/final-closure-r40.mjs');
   assert.doesNotMatch(verifier, /from ['"]\.\.\/src\//);
   assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
   assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
-  assert.match(verifier, /DEADBYTE-R39-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.11\.3'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.11\.3'/);
-  assert.match(verifier, /release_label==='R39 FINAL MACHINE BASELINE'/);
-  assert.match(verifier, /058605dfccaa3035a57c6393d53f2421c14e5a92bd145c2334477ba24d7cab8b/);
+  assert.match(verifier, /DEADBYTE-R40-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.12\.0'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.12\.0'/);
+  assert.match(verifier, /release_label==='R40 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /ce761dd6e014d42eddb635855038e0ce049c63c6e3af7e63c3005bbe198bcf7b/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
-  const verifier = await text('scripts/final-closure-verify-r39.mjs');
+  const verifier = await text('scripts/final-closure-verify-r40.mjs');
   assert.match(verifier, /const actual=\(await walk\(root\)\)\.filter\(rel=>rel!==manifestName\)\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
   assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
 });
@@ -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/r37-remote-tool-call-timeline.test.mjs

@@ -32,15 +32,16 @@ test('R37 unified timeline renders one sanitized tool-call line with ISO timesta
   assert.doesNotMatch(line,/TOP_SECRET_PAYLOAD|TOP_SECRET_TOKEN|Bearer abc\.def\.ghi/);
 });
 
-test('R37 live tracker uses the tool-call line for request and keeps correlated terminal result',()=>{
+test('R40 default live tracker keeps legacy formatter separate and emits one compact result line',()=>{
   let now=Date.parse('2026-09-18T16:24:30.125Z');
   const tracker=createLiveTimelineTracker({clock:()=>now});
   const call=tracker.observe({event_type:'tool.request',request_id:'abcdef1234567890',tool:'coding_tree',
-    created_at_utc:'2026-09-18T16:24:30.125Z',args:{root_id:'projects',path:'src'}});
-  assert.match(call,/^2026-09-18T23:24:30\.125\+07:00 \| coding_tree\s+\| Arguments: \{"path":"src","root_id":"projects"\}$/);
+    created_at_utc:'2026-09-18T16:24:30.125Z',args:{root_id:'projects',path:'src'}},{sequence:1});
+  assert.equal(call,null);
   now+=250;
-  assert.equal(tracker.observe({event_type:'tool.result',request_id:'abcdef1234567890',tool:'coding_tree',
-    outcome:{is_error:false,duration_ms:250}}),'✓ [abcdef12] OK  coding_tree 250ms');
+  const done=tracker.observe({event_type:'tool.result',request_id:'abcdef1234567890',tool:'coding_tree',
+    observed_at_utc:'2026-09-18T16:24:30.375Z',outcome:{is_error:false,duration_ms:250}},{sequence:2});
+  assert.match(done,/^🔍  23:24:30\.375  #2  \[abcdef12\]  coding_tree  projects:src  250ms  ✓$/);
 });
 
 test('R37 remote result journal persists sanitized tool-call and result in one monotonic cursor stream',async()=>{