deadbyte-mcp 0.12.0 → 0.13.0

package/src/memory-r41.mjs

@@ -0,0 +1,692 @@
+import { createHash, randomBytes, sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
+import { mkdir, open, readFile, readdir, rename, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const MEMORY_STATE_SCHEMA='deadbyte.memory-state.v1';
+export const MEMORY_SNAPSHOT_SCHEMA='deadbyte.memory-snapshot.v1';
+const EVENT_SCHEMA='deadbyte.autonomous-event.v1';
+const EVENT_DOMAIN=Buffer.from('DEADBYTE-AUTONOMOUS-EVENT-V1\0');
+const GOAL_DOMAIN=Buffer.from('DEADBYTE-AUTONOMOUS-GOAL-V1\0');
+const SNAPSHOT_DOMAIN=Buffer.from('DEADBYTE-MEMORY-SNAPSHOT-V1\0');
+const HEX64=/^[0-9a-f]{64}$/;
+const ZERO='0'.repeat(64);
+const shaBytes=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sha=value=>shaBytes(Buffer.from(canonicalJson(value),'utf8'));
+
+function insist(ok,message){if(!ok)throw new Error(message);}
+function object(value,label){insist(value&&typeof value==='object'&&!Array.isArray(value),`${label} invalid`);return value;}
+function hex(value,label){insist(typeof value==='string'&&HEX64.test(value),`${label} invalid`);return value;}
+function canonicalTime(value,label){
+  insist(typeof value==='string'&&value.length>=20&&value.length<=64,`${label} invalid`);
+  const time=Date.parse(value);insist(Number.isFinite(time),`${label} invalid`);return new Date(time).toISOString();
+}
+function uniqSorted(values){return [...new Set(values.filter(value=>typeof value==='string'&&value.length>0))].sort((a,b)=>a.localeCompare(b,'en'));}
+function reference(event){return Object.freeze({goal_id:event.goal_id,seq:event.seq,event_sha256:event.event_sha256,type:event.type});}
+
+export function verifyMemoryGoal(goal,{publicKey,keyId,expectedGoalId=null}={}){
+  object(goal,'memory goal envelope');
+  const {attestation,...body}=goal;
+  const {goal_sha256:claimed,goal_id:goalId,...identity}=body;
+  hex(goalId,'memory goal_id');hex(claimed,'memory goal_sha256');
+  if(expectedGoalId!==null)insist(goalId===expectedGoalId,'memory goal directory identity mismatch');
+  insist(sha(identity)===claimed,'memory goal hash mismatch');
+  insist(attestation?.algorithm==='ed25519'&&attestation.key_id===keyId,'memory goal attestation mismatch');
+  const signature=Buffer.from(attestation.signature_base64??'','base64');
+  insist(signature.length===64&&signature.toString('base64')===attestation.signature_base64,'memory goal signature encoding mismatch');
+  insist(cryptoVerify(null,Buffer.concat([GOAL_DOMAIN,Buffer.from(canonicalJson(body),'utf8')]),publicKey,signature),'memory goal signature invalid');
+  return goal;
+}
+
+export function verifyMemoryJournal(events,{goalId,publicKey,keyId}={}){
+  insist(Array.isArray(events),'memory journal events invalid');
+  hex(goalId,'memory journal goal_id');
+  insist(publicKey,'memory journal public key missing');
+  insist(typeof keyId==='string'&&keyId.length>=1&&keyId.length<=128,'memory journal key id invalid');
+  let previous=ZERO;
+  for(let index=0;index<events.length;index+=1){
+    const event=object(events[index],`memory event ${index+1}`);
+    const {attestation,...signed}=event;
+    const {event_sha256:claimed,...body}=signed;
+    insist(body.schema===EVENT_SCHEMA,`memory event ${index+1} schema mismatch`);
+    insist(body.goal_id===goalId,`memory event ${index+1} goal mismatch`);
+    insist(body.seq===index+1,`memory event ${index+1} sequence mismatch`);
+    insist(body.prev_sha256===previous,`memory event ${index+1} predecessor mismatch`);
+    canonicalTime(body.created_at_utc,`memory event ${index+1} created_at_utc`);
+    insist(typeof body.type==='string'&&body.type.length>=1&&body.type.length<=128,`memory event ${index+1} type invalid`);
+    object(body.payload??{},`memory event ${index+1} payload`);
+    hex(claimed,`memory event ${index+1} hash`);
+    insist(sha(body)===claimed,`memory event ${index+1} hash mismatch`);
+    insist(attestation?.algorithm==='ed25519'&&attestation.key_id===keyId,`memory event ${index+1} attestation mismatch`);
+    const signature=Buffer.from(attestation.signature_base64??'','base64');
+    insist(signature.length===64&&signature.toString('base64')===attestation.signature_base64,`memory event ${index+1} signature encoding mismatch`);
+    insist(cryptoVerify(null,Buffer.concat([EVENT_DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),publicKey,signature),`memory event ${index+1} signature invalid`);
+    previous=claimed;
+  }
+  return Object.freeze({ok:true,event_count:events.length,journal_head_sha256:previous});
+}
+
+function initialState(goal){
+  object(goal,'memory goal');
+  const goalId=hex(goal.goal_id,'memory goal_id');
+  return {
+    schema:MEMORY_STATE_SCHEMA,goal_id:goalId,goal_sha256:hex(goal.goal_sha256,'memory goal_sha256'),
+    last_event_seq:0,journal_head_sha256:ZERO,status:'open',event_refs:[],receipt_refs:[],artifact_refs:[],
+    touched_files:[],failed_profiles:[],passed_profiles:[],planner_round:0,last_decision:null
+  };
+}
+
+function reduceEvent(state,event){
+  insist(event.seq===state.last_event_seq+1,'memory reducer sequence mismatch');
+  insist(event.prev_sha256===state.journal_head_sha256,'memory reducer predecessor mismatch');
+  const payload=event.payload??{};
+  state.last_event_seq=event.seq;
+  state.journal_head_sha256=event.event_sha256;
+  state.event_refs.push(reference(event));
+  for(const [key,value] of Object.entries(payload)){
+    if((key==='receipt_sha256'||key.endsWith('_receipt_sha256'))&&HEX64.test(value??'')) state.receipt_refs.push(value);
+    if((key==='artifact_sha256'||key.endsWith('_artifact_sha256')||key==='output_sha256')&&HEX64.test(value??'')) state.artifact_refs.push(value);
+  }
+  if(event.type==='planner_decision'){
+    state.planner_round=Math.max(state.planner_round,Number.isInteger(payload.planner_round)?payload.planner_round:state.planner_round);
+    state.last_decision={event_ref:reference(event),decision:structuredClone(payload.decision??null)};
+  }
+  if(event.type==='native_diff_committed') for(const file of payload.paths??[]) if(typeof file==='string'&&file.length>0) state.touched_files.push(file);
+  if(event.type==='profile_completed'&&typeof payload.profile_id==='string'){
+    if(payload.passed===true){state.passed_profiles.push(payload.profile_id);state.failed_profiles=state.failed_profiles.filter(id=>id!==payload.profile_id);}
+    else if(payload.passed===false&&!state.failed_profiles.includes(payload.profile_id))state.failed_profiles.push(payload.profile_id);
+  }
+  if(event.type==='release_completed')state.status='succeeded';
+  else if(event.type==='goal_cancelled')state.status='cancelled';
+  else if(event.type==='goal_failed')state.status='failed';
+  else if(event.type==='goal_paused'&&state.status==='open')state.status='paused';
+  else if(event.type==='goal_resumed'&&state.status==='paused')state.status='open';
+  state.receipt_refs=uniqSorted(state.receipt_refs);
+  state.artifact_refs=uniqSorted(state.artifact_refs);
+  state.touched_files=uniqSorted(state.touched_files);
+  state.failed_profiles=uniqSorted(state.failed_profiles);
+  state.passed_profiles=uniqSorted(state.passed_profiles);
+  return state;
+}
+
+function validateState(state,goal){
+  object(state,'memory state');
+  insist(state.schema===MEMORY_STATE_SCHEMA,'memory state schema mismatch');
+  insist(state.goal_id===goal.goal_id&&state.goal_sha256===goal.goal_sha256,'memory state goal mismatch');
+  insist(Number.isInteger(state.last_event_seq)&&state.last_event_seq>=0,'memory state sequence invalid');
+  hex(state.journal_head_sha256,'memory state journal head');
+  insist(Array.isArray(state.event_refs)&&state.event_refs.length===state.last_event_seq,'memory state event references invalid');
+  return state;
+}
+
+export function deriveMemoryState(goal,events,{publicKey,keyId}={}){
+  verifyMemoryJournal(events,{goalId:goal?.goal_id,publicKey,keyId});
+  const state=initialState(goal);
+  for(const event of events)reduceEvent(state,event);
+  return Object.freeze(structuredClone(state));
+}
+
+function snapshotCore(snapshot){
+  const {attestation:_attestation,snapshot_sha256:_snapshotSha,...core}=snapshot??{};
+  return core;
+}
+
+export function createMemorySnapshot({goal,events,snapshotSequence,sourceReleaseManifest,writerVersion,createdAtUtc,privateKey,publicKey,keyId}={}){
+  insist(Number.isInteger(snapshotSequence)&&snapshotSequence>=1,'memory snapshot sequence invalid');
+  hex(sourceReleaseManifest,'memory snapshot source release manifest');
+  insist(typeof writerVersion==='string'&&/^[0-9]+\.[0-9]+\.[0-9]+(?:-[A-Za-z0-9.-]+)?$/.test(writerVersion),'memory snapshot writer version invalid');
+  insist(privateKey&&publicKey,'memory snapshot signing keys missing');
+  insist(typeof keyId==='string'&&keyId.length>=1&&keyId.length<=128,'memory snapshot key id invalid');
+  const state=deriveMemoryState(goal,events,{publicKey,keyId});
+  const core={schema:MEMORY_SNAPSHOT_SCHEMA,schema_version:1,snapshot_sequence:snapshotSequence,
+    goal_id:goal.goal_id,last_event_seq:state.last_event_seq,journal_prefix_hash:state.journal_head_sha256,
+    state:structuredClone(state),state_hash:sha(state),created_at_utc:canonicalTime(createdAtUtc,'memory snapshot created_at_utc'),
+    source_release_manifest:sourceReleaseManifest,writer_version:writerVersion};
+  const snapshot_sha256=sha(core);
+  const signed={...core,snapshot_sha256};
+  const signature_base64=cryptoSign(null,Buffer.concat([SNAPSHOT_DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64');
+  return Object.freeze({...signed,attestation:Object.freeze({algorithm:'ed25519',key_id:keyId,signature_base64})});
+}
+
+export function verifyMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest}={}){
+  try{
+    object(snapshot,'memory snapshot');object(goal,'memory snapshot goal');
+    insist(snapshot.schema===MEMORY_SNAPSHOT_SCHEMA&&snapshot.schema_version===1,'memory snapshot schema mismatch');
+    insist(Number.isInteger(snapshot.snapshot_sequence)&&snapshot.snapshot_sequence>=1,'memory snapshot sequence invalid');
+    insist(snapshot.goal_id===goal.goal_id,'memory snapshot goal mismatch');
+    insist(Number.isInteger(snapshot.last_event_seq)&&snapshot.last_event_seq>=0&&snapshot.last_event_seq<=events.length,'memory snapshot event sequence invalid');
+    hex(snapshot.journal_prefix_hash,'memory snapshot journal prefix');
+    hex(snapshot.state_hash,'memory snapshot state hash');hex(snapshot.snapshot_sha256,'memory snapshot hash');
+    canonicalTime(snapshot.created_at_utc,'memory snapshot created_at_utc');
+    insist(snapshot.source_release_manifest===sourceReleaseManifest,'memory snapshot release manifest mismatch');
+    insist(typeof snapshot.writer_version==='string'&&snapshot.writer_version.length>=1,'memory snapshot writer version invalid');
+    validateState(snapshot.state,goal);
+    insist(snapshot.state.last_event_seq===snapshot.last_event_seq&&snapshot.state.journal_head_sha256===snapshot.journal_prefix_hash,'memory snapshot state binding mismatch');
+    insist(sha(snapshot.state)===snapshot.state_hash,'memory snapshot state hash mismatch');
+    const core=snapshotCore(snapshot);insist(sha(core)===snapshot.snapshot_sha256,'memory snapshot self hash mismatch');
+    insist(snapshot.attestation?.algorithm==='ed25519'&&snapshot.attestation.key_id===keyId,'memory snapshot attestation mismatch');
+    const signature=Buffer.from(snapshot.attestation.signature_base64??'','base64');
+    insist(signature.length===64&&signature.toString('base64')===snapshot.attestation.signature_base64,'memory snapshot signature encoding mismatch');
+    insist(cryptoVerify(null,Buffer.concat([SNAPSHOT_DOMAIN,Buffer.from(canonicalJson({...core,snapshot_sha256:snapshot.snapshot_sha256}),'utf8')]),publicKey,signature),'memory snapshot signature invalid');
+    verifyMemoryJournal(events,{goalId:goal.goal_id,publicKey,keyId});
+    const prefix=events.slice(0,snapshot.last_event_seq);
+    const expectedHead=prefix.at(-1)?.event_sha256??ZERO;
+    insist(expectedHead===snapshot.journal_prefix_hash,'memory snapshot journal prefix mismatch');
+    const expectedState=deriveMemoryState(goal,prefix,{publicKey,keyId});
+    insist(canonicalJson(expectedState)===canonicalJson(snapshot.state),'memory snapshot derived state mismatch');
+    return Object.freeze({ok:true,snapshot_sha256:snapshot.snapshot_sha256,state_hash:snapshot.state_hash,last_event_seq:snapshot.last_event_seq});
+  }catch(error){return Object.freeze({ok:false,reason:String(error?.message??error)});}
+}
+
+export function replayFromMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest}={}){
+  const proof=verifyMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest});
+  insist(proof.ok,`memory snapshot verification failed: ${proof.reason}`);
+  const state=structuredClone(snapshot.state);
+  for(const event of events.slice(snapshot.last_event_seq))reduceEvent(state,event);
+  return Object.freeze(state);
+}
+
+export async function writeMemorySnapshot(file,snapshot){
+  insist(typeof file==='string'&&path.isAbsolute(file),'memory snapshot path must be absolute');
+  insist(snapshot?.schema===MEMORY_SNAPSHOT_SCHEMA,'memory snapshot invalid');
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.tmp-${process.pid}-${randomBytes(4).toString('hex')}`;
+  const handle=await open(temp,'wx',0o600);
+  try{await handle.writeFile(`${canonicalJson(snapshot)}\n`,'utf8');await handle.sync();}finally{await handle.close();}
+  try{await rename(temp,file);}catch(error){await rm(temp,{force:true}).catch(()=>{});throw error;}
+  return Object.freeze({path:file,snapshot_sha256:snapshot.snapshot_sha256,state_hash:snapshot.state_hash});
+}
+
+export async function loadMemoryState({snapshotPath,goal,events,publicKey,keyId,sourceReleaseManifest}={}){
+  let snapshot;
+  try{snapshot=JSON.parse(await readFile(snapshotPath,'utf8'));}
+  catch(error){
+    const reason=error?.code==='ENOENT'?'missing':`snapshot read failed: ${String(error?.message??error)}`;
+    return Object.freeze({mode:'full-replay',snapshot_reason:reason,state:deriveMemoryState(goal,events,{publicKey,keyId})});
+  }
+  const proof=verifyMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest});
+  if(!proof.ok)return Object.freeze({mode:'full-replay',snapshot_reason:proof.reason,state:deriveMemoryState(goal,events,{publicKey,keyId})});
+  return Object.freeze({mode:'snapshot-suffix',snapshot_reason:null,snapshot_sha256:snapshot.snapshot_sha256,
+    state:replayFromMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest})});
+}
+
+function collectNamedHashes(value,matcher,{depth=0,nodes={count:0},out=[]}={}){
+  if(depth>10||nodes.count++>10000)return out;
+  if(Array.isArray(value)){for(const item of value)collectNamedHashes(item,matcher,{depth:depth+1,nodes,out});return out;}
+  if(!value||typeof value!=='object')return out;
+  for(const [name,item] of Object.entries(value)){
+    if(matcher(name)&&HEX64.test(item??''))out.push(item);
+    else collectNamedHashes(item,matcher,{depth:depth+1,nodes,out});
+  }
+  return out;
+}
+function receiptHashes(payload){return uniqSorted(collectNamedHashes(payload,name=>name==='receipt_sha256'||name.endsWith('_receipt_sha256')));}
+function artifactHashes(payload){return uniqSorted(collectNamedHashes(payload,name=>name==='artifact_sha256'||name.endsWith('_artifact_sha256')||name==='output_sha256'));}
+function referenced(type,payload,event){return Object.freeze({kind:type,event_ref:reference(event),...payload});}
+function validateProjectionInputs(goal,events,options){
+  object(goal,'memory projection goal');
+  verifyMemoryJournal(events,{goalId:goal.goal_id,publicKey:options?.publicKey,keyId:options?.keyId});
+}
+function projectionProof(derive,value,args,label){
+  try{
+    const expected=derive(args.goal,args.events,{publicKey:args.publicKey,keyId:args.keyId});
+    insist(canonicalJson(expected)===canonicalJson(value),`${label} does not match canonical journal projection`);
+    return Object.freeze({ok:true,memory_sha256:value.memory_sha256});
+  }catch(error){return Object.freeze({ok:false,reason:String(error?.message??error)});}
+}
+
+export function deriveEpisodicMemory(goal,events,{publicKey,keyId}={}){
+  validateProjectionInputs(goal,events,{publicKey,keyId});
+  const observations=[],decisions=[],actions=[],results=[],verification=[];
+  const receipts=[],artifacts=[];
+  for(const event of events){
+    const payload=event.payload??{};
+    receipts.push(...receiptHashes(payload));artifacts.push(...artifactHashes(payload));
+    if(event.type==='planner_decision')decisions.push(referenced('decision',{summary:String(payload.decision?.summary??''),action:String(payload.decision?.action??'')},event));
+    if(['inspect_completed','profile_completed','delegated_action_completed','desktop_observation','observation_completed'].includes(event.type))
+      observations.push(referenced('observation',{event_type:event.type},event));
+    if(['native_diff_committed','delegated_action_started','delegated_action_completed','patch_started','patch_committed'].includes(event.type))
+      actions.push(referenced('action',{event_type:event.type},event));
+    if(['profile_completed','delegated_action_completed','native_diff_committed','goal_failed','release_completed'].includes(event.type))
+      results.push(referenced('result',{event_type:event.type,status:payload.passed===true?'passed':payload.passed===false?'failed':null},event));
+    if(event.type==='release_completed'||(event.type==='profile_completed'&&payload.passed===true))
+      verification.push(referenced('verification',{event_type:event.type},event));
+  }
+  const terminal=[...events].reverse().find(event=>['release_completed','goal_failed','goal_cancelled'].includes(event.type));
+  const outcome=terminal?.type==='release_completed'?'succeeded':terminal?.type==='goal_cancelled'?'cancelled':terminal?.type==='goal_failed'?'failed':'open';
+  const head=events.at(-1)?.event_sha256??ZERO;
+  const body={schema:'deadbyte.episode.v1',episode_id:sha({schema:'deadbyte.episode-id.v1',goal_id:goal.goal_id,journal_head_sha256:head}),
+    goal:{goal_id:goal.goal_id,title:String(goal.title??''),goal:String(goal.goal??''),acceptance:String(goal.acceptance??'')},
+    observations,decisions,actions,results,verification,outcome,
+    event_range:{first_seq:events.length?1:0,last_seq:events.length,journal_head_sha256:head},
+    artifact_refs:uniqSorted(artifacts),receipt_refs:uniqSorted(receipts),
+    created_at_utc:events[0]?.created_at_utc??null,closed_at_utc:terminal?.created_at_utc??null};
+  return Object.freeze({...body,memory_sha256:sha(body)});
+}
+
+export function verifyEpisode(episode,{goal,events,publicKey,keyId}={}){
+  return projectionProof(deriveEpisodicMemory,episode,{goal,events,publicKey,keyId},'episode');
+}
+
+function validateDecisionEdges(decisions){
+  const byId=new Map(decisions.map(item=>[item.decision_id,item]));
+  insist(byId.size===decisions.length,'decision memory duplicate id');
+  for(const item of decisions){
+    if(item.supersedes===null)continue;
+    insist(byId.has(item.supersedes),'decision supersedes missing target');
+    insist(item.supersedes!==item.decision_id,'decision cannot supersede itself');
+    const previous=byId.get(item.supersedes);
+    insist(previous.superseded_by===null||previous.superseded_by===item.decision_id,'decision has ambiguous supersession');
+    previous.superseded_by=item.decision_id;previous.status='superseded';
+  }
+  for(const start of decisions){
+    const seen=new Set();let cursor=start;
+    while(cursor?.supersedes!==null){
+      insist(!seen.has(cursor.decision_id),'decision supersession cycle');seen.add(cursor.decision_id);cursor=byId.get(cursor.supersedes);
+    }
+  }
+}
+
+export function deriveDecisionMemory(goal,events,{publicKey,keyId}={}){
+  validateProjectionInputs(goal,events,{publicKey,keyId});
+  const decisions=[];
+  for(const event of events){
+    if(event.type!=='planner_decision'&&event.type!=='decision_recorded')continue;
+    const payload=event.payload??{};const value=payload.decision??payload;
+    const decisionId=sha({schema:'deadbyte.decision-id.v1',goal_id:goal.goal_id,event_sha256:event.event_sha256});
+    const supersedes=HEX64.test(value.supersedes??'')?value.supersedes:null;
+    decisions.push({decision_id:decisionId,scope:String(value.scope??goal.root_id??goal.goal_id),
+      decision:structuredClone(value),reason:String(value.reason??value.summary??''),
+      constraints:uniqSorted([goal.acceptance,...(Array.isArray(value.constraints)?value.constraints:[])]),status:'active',
+      supersedes,superseded_by:null,source_event_ids:[event.event_sha256],
+      receipt_refs:receiptHashes(payload),artifact_refs:artifactHashes(payload),created_at_utc:event.created_at_utc});
+  }
+  validateDecisionEdges(decisions);
+  const body={schema:'deadbyte.decision-memory.v1',goal_id:goal.goal_id,
+    journal_head_sha256:events.at(-1)?.event_sha256??ZERO,decisions};
+  return Object.freeze({...body,memory_sha256:sha(body)});
+}
+
+export function verifyDecisionMemory(memory,{goal,events,publicKey,keyId}={}){
+  return projectionProof(deriveDecisionMemory,memory,{goal,events,publicKey,keyId},'decision memory');
+}
+
+function incidentFingerprint(payload){
+  const text=(value,max=128)=>typeof value==='string'?value.slice(0,max):null;
+  const integer=value=>Number.isSafeInteger(value)?value:null;
+  const list=(value,max=32)=>uniqSorted(Array.isArray(value)?value.filter(item=>typeof item==='string').map(item=>item.slice(0,256)):[]).slice(0,max);
+  return {
+    tool:text(payload.tool),operation:text(payload.operation),platform:text(payload.platform),architecture:text(payload.architecture),
+    exit_code:integer(payload.exit_code),signal:text(payload.signal),timeout_state:text(payload.timeout_state),
+    diagnostic_codes:list(payload.diagnostic_codes),stderr_hash:HEX64.test(payload.stderr_sha256??'')?payload.stderr_sha256:null,
+    stdout_hash:HEX64.test(payload.stdout_sha256??'')?payload.stdout_sha256:null,
+    top_stack_frames:list(payload.top_stack_frames,16),compiler_identity:text(payload.compiler_identity,256),
+    runtime_identity:text(payload.runtime_identity,256),target:text(payload.target,256),profile_id:text(payload.profile_id),
+    symbols:list(payload.symbols),artifact_hashes:artifactHashes(payload),
+    environment_fingerprint:HEX64.test(payload.environment_fingerprint??'')?payload.environment_fingerprint:null
+  };
+}
+function failureEvent(event){
+  const payload=event.payload??{};
+  return (event.type==='profile_completed'&&payload.passed===false)||event.type==='goal_failed'||event.type.endsWith('_failed');
+}
+
+export function deriveIncidentMemory(goal,events,{publicKey,keyId}={}){
+  validateProjectionInputs(goal,events,{publicKey,keyId});
+  const incidents=[];
+  for(let index=0;index<events.length;index+=1){
+    const event=events[index];if(!failureEvent(event))continue;
+    const payload=event.payload??{};const fingerprint=incidentFingerprint(payload);
+    const fingerprintSha=sha({schema:'deadbyte.incident-fingerprint.v1',fingerprint});
+    const profile=typeof payload.profile_id==='string'?payload.profile_id:null;
+    let resolvedAt=-1;
+    if(profile)resolvedAt=events.findIndex((candidate,next)=>next>index&&candidate.type==='profile_completed'&&candidate.payload?.profile_id===profile&&candidate.payload?.passed===true);
+    const end=resolvedAt>=0?resolvedAt:events.length-1;
+    const window=events.slice(index,end+1);
+    const fixes=window.filter(candidate=>candidate.type==='native_diff_committed'||candidate.type==='repair_completed').map(reference);
+    const attempts=window.filter(candidate=>candidate.type==='planner_decision'||candidate.type==='profile_completed'||candidate.type==='native_diff_committed').map(reference);
+    const root=window.find(candidate=>candidate.type==='critic_classified'||candidate.type==='repair_started');
+    const body={incident_id:sha({schema:'deadbyte.incident-id.v1',goal_id:goal.goal_id,fingerprint_sha256:fingerprintSha,first_event_sha256:event.event_sha256}),
+      fingerprint_sha256:fingerprintSha,fingerprint,symptoms:[reference(event)],
+      root_cause:root?{event_ref:reference(root),detail:String(root.payload?.detail??root.payload?.hypothesis??'')}:null,
+      attempts,successful_fix:fixes,event_range:{first_seq:event.seq,last_seq:events[end]?.seq??event.seq},
+      receipt_refs:uniqSorted(window.flatMap(candidate=>receiptHashes(candidate.payload??{}))),
+      artifact_refs:uniqSorted(window.flatMap(candidate=>artifactHashes(candidate.payload??{}))),
+      status:resolvedAt>=0?'resolved':'open'};
+    incidents.push(body);
+  }
+  const body={schema:'deadbyte.incident-memory.v1',goal_id:goal.goal_id,
+    journal_head_sha256:events.at(-1)?.event_sha256??ZERO,incidents};
+  return Object.freeze({...body,memory_sha256:sha(body)});
+}
+
+export function verifyIncidentMemory(memory,{goal,events,publicKey,keyId}={}){
+  return projectionProof(deriveIncidentMemory,memory,{goal,events,publicKey,keyId},'incident memory');
+}
+
+export function buildMemoryCorpus({goal,events,publicKey,keyId,sourceReleaseManifest}={}){
+  hex(sourceReleaseManifest,'memory corpus source release manifest');
+  const state=deriveMemoryState(goal,events,{publicKey,keyId});
+  const episode=deriveEpisodicMemory(goal,events,{publicKey,keyId});
+  const decisions=deriveDecisionMemory(goal,events,{publicKey,keyId});
+  const incidents=deriveIncidentMemory(goal,events,{publicKey,keyId});
+  const body={schema:'deadbyte.memory-corpus.v1',source_release_manifest:sourceReleaseManifest,
+    goal_id:goal.goal_id,journal_head_sha256:state.journal_head_sha256,state,episode,decisions,incidents};
+  return Object.freeze({...body,memory_sha256:sha(body)});
+}
+
+export function buildMemoryArchive(corpora,{sourceReleaseManifest}={}){
+  insist(Array.isArray(corpora),'memory archive corpora invalid');
+  hex(sourceReleaseManifest,'memory archive source release manifest');
+  const ordered=[...corpora].sort((a,b)=>String(a?.goal_id).localeCompare(String(b?.goal_id),'en'));
+  const seen=new Set();
+  for(const corpus of ordered){
+    object(corpus,'memory archive corpus');hex(corpus.memory_sha256,'memory archive corpus hash');
+    insist(corpus.source_release_manifest===sourceReleaseManifest,'memory archive cross-release corpus rejected');
+    insist(!seen.has(corpus.goal_id),'memory archive duplicate goal');seen.add(corpus.goal_id);
+  }
+  const body={schema:'deadbyte.memory-archive.v1',source_release_manifest:sourceReleaseManifest,
+    corpus_refs:ordered.map(corpus=>({goal_id:corpus.goal_id,journal_head_sha256:corpus.journal_head_sha256,memory_sha256:corpus.memory_sha256})),
+    corpora:ordered.map(corpus=>structuredClone(corpus))};
+  return Object.freeze({...body,memory_sha256:sha(body)});
+}
+
+function validateCorpus(corpus,{goal,events,publicKey,keyId,sourceReleaseManifest}={}){
+  const expected=buildMemoryCorpus({goal,events,publicKey,keyId,sourceReleaseManifest});
+  insist(canonicalJson(expected)===canonicalJson(corpus),'memory corpus does not match canonical journal');
+  return expected;
+}
+function tokens(value){
+  return uniqSorted(String(value??'').toLowerCase().split(/[^a-z0-9_.\/-]+/).filter(token=>token.length>1)).slice(0,4096);
+}
+function addPosting(map,key,id){if(!key)return;const values=map.get(key)??new Set();values.add(id);map.set(key,values);}
+function mapObject(map){return Object.fromEntries([...map.entries()].sort(([a],[b])=>a.localeCompare(b,'en')).map(([key,values])=>[key,[...values].sort((a,b)=>a.localeCompare(b,'en'))]));}
+function sourceIds(record){
+  const ids=[];
+  const visit=value=>{
+    if(Array.isArray(value)){for(const item of value)visit(item);return;}
+    if(!value||typeof value!=='object')return;
+    if(HEX64.test(value.event_sha256??''))ids.push(value.event_sha256);
+    if(value.event_ref)visit(value.event_ref);
+    for(const [key,item] of Object.entries(value))if(key!=='event_ref'&&key!=='event_sha256')visit(item);
+  };
+  visit(record);return uniqSorted(ids);
+}
+function canonicalRecords(corpus){
+  const records=new Map();
+  if(corpus.schema==='deadbyte.memory-archive.v1'){
+    for(const child of corpus.corpora??[]){
+      for(const [id,value] of canonicalRecords(child)){
+        const existing=records.get(id);
+        insist(!existing||canonicalJson(existing)===canonicalJson(value),`memory archive record collision: ${id}`);
+        records.set(id,value);
+      }
+    }
+    return records;
+  }
+  records.set(corpus.episode.episode_id,{kind:'episode',record:corpus.episode});
+  for(const item of corpus.decisions.decisions)records.set(item.decision_id,{kind:'decision',record:item});
+  for(const item of corpus.incidents.incidents)records.set(item.incident_id,{kind:'incident',record:item});
+  for(const item of corpus.state.event_refs)records.set(item.event_sha256,{kind:'event',record:item});
+  for(const digest of uniqSorted([...corpus.state.artifact_refs,...corpus.episode.artifact_refs]))records.set(`artifact:${digest}`,{kind:'artifact',record:{artifact_sha256:digest}});
+  return records;
+}
+
+export function buildRetrievalIndex(corpus,{sourceReleaseManifest}={}){
+  object(corpus,'memory retrieval corpus');
+  hex(corpus.memory_sha256,'memory retrieval corpus hash');
+  insist(corpus.source_release_manifest===sourceReleaseManifest,'memory retrieval release manifest mismatch');
+  const tokenIndex=new Map(),symbolIndex=new Map(),artifactIndex=new Map(),incidentIndex=new Map(),decisionIndex=new Map();
+  const documents=[];
+  for(const [id,{kind,record}] of [...canonicalRecords(corpus).entries()].sort(([a],[b])=>a.localeCompare(b,'en'))){
+    const text=canonicalJson(record);const documentTokens=tokens(text);
+    const symbols=kind==='incident'?uniqSorted(record.fingerprint?.symbols??[]):[];
+    const artifacts=kind==='incident'?uniqSorted(record.artifact_refs??[]):kind==='episode'?uniqSorted(record.artifact_refs??[]):kind==='artifact'?[record.artifact_sha256]:[];
+    const source_event_ids=sourceIds(record);
+    const doc={id,kind,record_sha256:sha(record),source_event_ids,tokens:documentTokens,symbols,artifact_hashes:artifacts};
+    documents.push(doc);
+    for(const token of documentTokens)addPosting(tokenIndex,token,id);
+    for(const symbol of symbols)addPosting(symbolIndex,symbol,id);
+    for(const digest of artifacts)addPosting(artifactIndex,digest,id);
+    if(kind==='incident')addPosting(incidentIndex,record.fingerprint_sha256,id);
+    if(kind==='decision')addPosting(decisionIndex,record.scope,id);
+  }
+  const body={schema:'deadbyte.memory-index.v1',source_memory_sha256:corpus.memory_sha256,
+    source_release_manifest:sourceReleaseManifest,documents,
+    exact_ids:Object.fromEntries(documents.map((doc,index)=>[doc.id,index])),
+    token_index:mapObject(tokenIndex),symbol_index:mapObject(symbolIndex),artifact_index:mapObject(artifactIndex),
+    decision_index:mapObject(decisionIndex),incident_index:mapObject(incidentIndex)};
+  return Object.freeze({...body,index_sha256:sha(body)});
+}
+
+export function verifyRetrievalIndex(index,{corpus,sourceReleaseManifest}={}){
+  try{
+    object(index,'memory index');
+    insist(index.source_release_manifest===sourceReleaseManifest,'memory index release manifest mismatch');
+    insist(index.source_memory_sha256===corpus?.memory_sha256,'memory index source hash mismatch');
+    const expected=buildRetrievalIndex(corpus,{sourceReleaseManifest});
+    insist(canonicalJson(expected)===canonicalJson(index),'memory index projection mismatch');
+    return Object.freeze({ok:true,index_sha256:index.index_sha256,document_count:index.documents.length});
+  }catch(error){return Object.freeze({ok:false,reason:String(error?.message??error)});}
+}
+function posting(index,name,key){const values=index[name]?.[key];return Array.isArray(values)?values:[];}
+export function queryMemoryIndex(index,{id=null,query=null,symbol=null,artifact_sha256=null,decision_scope=null,incident_fingerprint=null,limit=16}={}){
+  object(index,'memory query index');
+  insist(Number.isInteger(limit)&&limit>=1&&limit<=128,'memory query limit invalid');
+  const scores=new Map();const add=(candidate,score)=>scores.set(candidate,(scores.get(candidate)??0)+score);
+  if(typeof id==='string'&&Object.hasOwn(index.exact_ids??{},id))add(id,1000);
+  for(const token of tokens(query))for(const candidate of posting(index,'token_index',token))add(candidate,10);
+  if(typeof symbol==='string')for(const candidate of posting(index,'symbol_index',symbol))add(candidate,100);
+  if(HEX64.test(artifact_sha256??''))for(const candidate of posting(index,'artifact_index',artifact_sha256))add(candidate,100);
+  if(typeof decision_scope==='string')for(const candidate of posting(index,'decision_index',decision_scope))add(candidate,100);
+  if(HEX64.test(incident_fingerprint??''))for(const candidate of posting(index,'incident_index',incident_fingerprint))add(candidate,100);
+  const candidate_ids=[...scores.entries()].sort((a,b)=>b[1]-a[1]||a[0].localeCompare(b[0],'en')).slice(0,limit).map(([candidate])=>candidate);
+  return Object.freeze({schema:'deadbyte.memory-query.v1',index_sha256:index.index_sha256,candidate_ids});
+}
+
+function resolveCandidates(candidateIds,{corpus,index,sourceReleaseManifest}){
+  const proof=verifyRetrievalIndex(index,{corpus,sourceReleaseManifest});
+  insist(proof.ok,`memory canonical index invalid: ${proof.reason}`);
+  insist(Array.isArray(candidateIds)&&candidateIds.length<=128,'memory candidate ids invalid');
+  const records=canonicalRecords(corpus),seen=new Set(),resolved=[];
+  for(const id of candidateIds){
+    insist(typeof id==='string'&&!seen.has(id),'memory canonical candidate duplicate/invalid');seen.add(id);
+    const value=records.get(id);insist(value,`memory canonical candidate not found: ${id}`);
+    const doc=index.documents[index.exact_ids[id]];
+    insist(doc?.record_sha256===sha(value.record),'memory canonical candidate record hash mismatch');
+    resolved.push(structuredClone(value.record));
+  }
+  return resolved;
+}
+
+function safeAuthority(value){
+  const planes={};
+  for(const name of ['process','coding','autonomous','desktop','host']){
+    const item=value?.[name];if(!item||typeof item!=='object')continue;
+    planes[name]={armed:item.armed===true,reason:String(item.reason??'unknown').slice(0,128)};
+  }
+  return {observed:planes,authorizes_execution:false};
+}
+function incidentWithSources(item){return {...structuredClone(item),source_event_ids:sourceIds(item)};}
+function decisionWithSources(item){return {...structuredClone(item),source_event_ids:uniqSorted(item.source_event_ids??[])};}
+
+export function buildWorkingMemory({goal,events,corpus,index,publicKey,keyId,sourceReleaseManifest,byteBudget=65536,
+  currentPlan=null,currentFiles=[],currentSymbols=[],currentAuthority={},historicalArchive=null,historicalIndex=null}={}){
+  insist(Number.isInteger(byteBudget)&&byteBudget>=4096&&byteBudget<=4*1024*1024,'working memory byte budget invalid');
+  validateCorpus(corpus,{goal,events,publicKey,keyId,sourceReleaseManifest});
+  const indexProof=verifyRetrievalIndex(index,{corpus,sourceReleaseManifest});insist(indexProof.ok,`working memory index invalid: ${indexProof.reason}`);
+  const eventIds=new Set(events.map(event=>event.event_sha256));
+  const files=currentFiles.map(item=>{
+    object(item,'working memory file');hex(item.sha256,'working memory file hash');hex(item.source_event_sha256,'working memory file source event');
+    insist(eventIds.has(item.source_event_sha256),'working memory file source event missing');
+    return {path:String(item.path??''),sha256:item.sha256,source_event_sha256:item.source_event_sha256};
+  }).sort((a,b)=>a.path.localeCompare(b.path,'en'));
+  const queryText=[goal.title,goal.goal,goal.acceptance,...currentSymbols].filter(Boolean).join(' ');
+  const candidates=queryMemoryIndex(index,{query:queryText,limit:64}).candidate_ids;
+  const candidateSet=new Set(candidates);
+  const relevantDecisions=corpus.decisions.decisions.filter(item=>item.status==='active'||candidateSet.has(item.decision_id)).map(decisionWithSources);
+  const relevantIncidents=corpus.incidents.incidents.filter(item=>item.status==='open'||candidateSet.has(item.incident_id)).map(incidentWithSources);
+  let historical=[];let historicalArchiveSha256=null;let historicalIndexSha256=null;
+  if(historicalArchive!==null||historicalIndex!==null){
+    insist(historicalArchive?.schema==='deadbyte.memory-archive.v1','working memory historical archive invalid');
+    insist(historicalArchive.source_release_manifest===sourceReleaseManifest,'working memory historical archive release mismatch');
+    const rebuilt=buildMemoryArchive(historicalArchive.corpora,{sourceReleaseManifest});
+    insist(canonicalJson(rebuilt)===canonicalJson(historicalArchive),'working memory historical archive noncanonical');
+    const historyProof=verifyRetrievalIndex(historicalIndex,{corpus:historicalArchive,sourceReleaseManifest});
+    insist(historyProof.ok,`working memory historical index invalid: ${historyProof.reason}`);
+    const historyIds=queryMemoryIndex(historicalIndex,{query:queryText,limit:16}).candidate_ids;
+    historical=resolveCandidates(historyIds,{corpus:historicalArchive,index:historicalIndex,sourceReleaseManifest});
+    historicalArchiveSha256=historicalArchive.memory_sha256;historicalIndexSha256=historicalIndex.index_sha256;
+  }
+  const body={schema:'deadbyte.working-memory.v1',source_release_manifest:sourceReleaseManifest,
+    source_memory_sha256:corpus.memory_sha256,source_index_sha256:index.index_sha256,
+    journal_head_sha256:events.at(-1)?.event_sha256??ZERO,
+    current_goal:{goal_id:goal.goal_id,title:String(goal.title??''),goal:String(goal.goal??''),acceptance:String(goal.acceptance??'')},
+    current_plan:structuredClone(currentPlan),current_files:files,current_symbols:uniqSorted(currentSymbols),
+    recent_events:events.slice(-32).map(reference),open_failures:relevantIncidents.filter(item=>item.status==='open'),
+    known_constraints:uniqSorted([goal.acceptance,...relevantDecisions.flatMap(item=>item.constraints??[])]),
+    current_authority:safeAuthority(currentAuthority),relevant_decisions:relevantDecisions,
+    relevant_incidents:relevantIncidents,historical_memory:historical,
+    historical_archive_sha256:historicalArchiveSha256,historical_index_sha256:historicalIndexSha256,
+    active_episode:structuredClone(corpus.episode)};
+  const shrink=()=>{
+    if(body.recent_events.length>8){body.recent_events.shift();return true;}
+    const resolved=body.relevant_incidents.findIndex(item=>item.status!=='open');if(resolved>=0){body.relevant_incidents.splice(resolved,1);return true;}
+    if(body.relevant_decisions.length>8){body.relevant_decisions.shift();return true;}
+    if(body.historical_memory.length>4){body.historical_memory.pop();return true;}
+    if(body.current_files.length>8){body.current_files.shift();return true;}
+    if(body.current_symbols.length>16){body.current_symbols.pop();return true;}
+    return false;
+  };
+  while(Buffer.byteLength(canonicalJson(body),'utf8')>byteBudget){insist(shrink(),'working memory exceeds byte budget after deterministic compaction');}
+  return Object.freeze({...body,working_memory_sha256:sha(body)});
+}
+
+export function verifyWorkingMemory(memory,args={}){
+  try{
+    insist(memory?.source_release_manifest===args.sourceReleaseManifest,'working memory release mismatch');
+    const expected=buildWorkingMemory(args);insist(canonicalJson(expected)===canonicalJson(memory),'working memory stale or noncanonical');
+    return Object.freeze({ok:true,working_memory_sha256:memory.working_memory_sha256});
+  }catch(error){return Object.freeze({ok:false,reason:String(error?.message??error)});}
+}
+
+export function createSemanticMemoryAdapter({enabled=false,retrieveCandidates=null}={}){
+  insist(typeof enabled==='boolean','semantic memory enabled invalid');
+  if(enabled)insist(typeof retrieveCandidates==='function','semantic memory candidate provider missing');
+  return Object.freeze({enabled,async query({query,corpus,index,sourceReleaseManifest,limit=16}={}){
+    insist(enabled,'semantic memory is disabled');
+    insist(typeof query==='string'&&query.length>=1&&query.length<=4096,'semantic memory query invalid');
+    insist(Number.isInteger(limit)&&limit>=1&&limit<=128,'semantic memory limit invalid');
+    const raw=await retrieveCandidates({query,limit});
+    insist(Array.isArray(raw),'semantic memory candidates invalid');
+    const candidate_ids=raw.slice(0,limit);
+    const records=resolveCandidates(candidate_ids,{corpus,index,sourceReleaseManifest});
+    return Object.freeze({schema:'deadbyte.semantic-memory-result.v1',query,candidate_ids:[...candidate_ids],records,
+      source_memory_sha256:corpus.memory_sha256,source_index_sha256:index.index_sha256,canonical_verified:true,authorizes_execution:false});
+  }});
+}
+
+async function writeProjectionOnce(file,value){
+  const bytes=Buffer.from(`${canonicalJson(value)}\n`,'utf8');
+  try{
+    const existing=await readFile(file);
+    insist(existing.equals(bytes),'memory projection path already contains different bytes');
+    return {path:file,sha256:shaBytes(existing),existing:true};
+  }catch(error){if(error?.code!=='ENOENT')throw error;}
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.tmp-${process.pid}-${randomBytes(4).toString('hex')}`;
+  const handle=await open(temp,'wx',0o600);
+  try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+  try{await rename(temp,file);}catch(error){
+    await rm(temp,{force:true}).catch(()=>{});
+    if(error?.code==='EEXIST'||error?.code==='EPERM'){
+      const existing=await readFile(file);insist(existing.equals(bytes),'memory projection concurrent write mismatch');
+      return {path:file,sha256:shaBytes(existing),existing:true};
+    }
+    throw error;
+  }
+  return {path:file,sha256:shaBytes(bytes),existing:false};
+}
+
+async function readJson(file){return JSON.parse((await readFile(file,'utf8')).replace(/^\uFEFF/,''));}
+async function latestSnapshotPath(goalRoot){
+  try{const names=(await readdir(path.join(goalRoot,'snapshots'))).filter(name=>/^\d{12}-[0-9a-f]{64}\.json$/.test(name)).sort();
+    return names.length?path.join(goalRoot,'snapshots',names.at(-1)):path.join(goalRoot,'snapshots','missing.json');
+  }catch(error){if(error?.code==='ENOENT')return path.join(goalRoot,'snapshots','missing.json');throw error;}
+}
+async function loadHistoricalCorpora({journalRoot,currentGoalId,sourceReleaseManifest,publicKey,keyId,maxHistoricalGoals,maxEventsPerGoal}){
+  if(journalRoot===null)return [];
+  let entries;
+  try{entries=await readdir(journalRoot,{withFileTypes:true});}catch(error){if(error?.code==='ENOENT')return [];throw error;}
+  const goalIds=entries.filter(entry=>entry.isDirectory()&&HEX64.test(entry.name)&&entry.name!==currentGoalId)
+    .map(entry=>entry.name).sort((a,b)=>a.localeCompare(b,'en'));
+  insist(goalIds.length<=maxHistoricalGoals,'R41 historical goal bound exceeded');
+  const corpora=[];
+  for(const goalId of goalIds){
+    const goalRoot=path.join(journalRoot,goalId);const eventsRoot=path.join(goalRoot,'events');
+    const goal=verifyMemoryGoal(await readJson(path.join(goalRoot,'goal.json')),{publicKey,keyId,expectedGoalId:goalId});
+    const names=(await readdir(eventsRoot)).filter(name=>/^\d{6}\.json$/.test(name)).sort();
+    insist(names.length>=1&&names.length<=maxEventsPerGoal,`R41 historical event bound invalid for ${goalId}`);
+    insist(names.every((name,index)=>name===`${String(index+1).padStart(6,'0')}.json`),`R41 historical event gap for ${goalId}`);
+    const first=await readJson(path.join(eventsRoot,names[0]));
+    verifyMemoryJournal([first],{goalId,publicKey,keyId});
+    if(first.type!=='goal_created'||first.payload?.source_release_manifest!==sourceReleaseManifest)continue;
+    const events=[first];
+    for(const name of names.slice(1))events.push(await readJson(path.join(eventsRoot,name)));
+    verifyMemoryJournal(events,{goalId,publicKey,keyId});
+    corpora.push(buildMemoryCorpus({goal,events,publicKey,keyId,sourceReleaseManifest}));
+  }
+  return corpora;
+}
+
+export function createR41MemoryProvider({memoryRoot,sourceReleaseManifest,writerVersion='0.13.0',privateKey,publicKey,keyId,
+  byteBudget=65536,semantic={enabled:false},journalRoot=null,maxHistoricalGoals=256,maxEventsPerGoal=10000}={}){
+  insist(typeof memoryRoot==='string'&&path.isAbsolute(memoryRoot),'R41 memory root must be absolute');
+  hex(sourceReleaseManifest,'R41 memory source release manifest');
+  insist(privateKey&&publicKey,'R41 memory provider trust keys missing');
+  insist(typeof keyId==='string'&&keyId.length>=1&&keyId.length<=128,'R41 memory provider key id invalid');
+  insist(Number.isInteger(byteBudget)&&byteBudget>=4096&&byteBudget<=4*1024*1024,'R41 memory provider byte budget invalid');
+  insist(journalRoot===null||(typeof journalRoot==='string'&&path.isAbsolute(journalRoot)),'R41 memory journal root invalid');
+  insist(Number.isInteger(maxHistoricalGoals)&&maxHistoricalGoals>=0&&maxHistoricalGoals<=4096,'R41 historical goal bound invalid');
+  insist(Number.isInteger(maxEventsPerGoal)&&maxEventsPerGoal>=1&&maxEventsPerGoal<=100000,'R41 historical event bound invalid');
+  insist(semantic?.enabled===false,'R41 semantic memory must remain disabled unless a verified adapter is explicitly configured');
+  async function refresh({goal,events,currentPlan=null,currentFiles=[],currentSymbols=[],currentAuthority={}}={}){
+    insist(Array.isArray(events)&&events.length>=1,'R41 memory provider requires journal events');
+    const goalRoot=path.join(memoryRoot,'goals',goal.goal_id);
+    const loadedState=await loadMemoryState({snapshotPath:await latestSnapshotPath(goalRoot),goal,events,publicKey,keyId,sourceReleaseManifest});
+    const corpus=buildMemoryCorpus({goal,events,publicKey,keyId,sourceReleaseManifest});
+    insist(canonicalJson(loadedState.state)===canonicalJson(corpus.state),'R41 snapshot replay diverged from full replay');
+    const index=buildRetrievalIndex(corpus,{sourceReleaseManifest});
+    const historicalCorpora=await loadHistoricalCorpora({journalRoot,currentGoalId:goal.goal_id,sourceReleaseManifest,
+      publicKey,keyId,maxHistoricalGoals,maxEventsPerGoal});
+    const historicalArchive=buildMemoryArchive(historicalCorpora,{sourceReleaseManifest});
+    const historicalIndex=buildRetrievalIndex(historicalArchive,{sourceReleaseManifest});
+    const snapshot=createMemorySnapshot({goal,events,snapshotSequence:events.length,sourceReleaseManifest,writerVersion,
+      createdAtUtc:events.at(-1).created_at_utc,privateKey,publicKey,keyId});
+    const snapshotPath=path.join(goalRoot,'snapshots',`${String(events.length).padStart(12,'0')}-${snapshot.journal_prefix_hash}.json`);
+    const indexPath=path.join(goalRoot,'indexes',`${index.index_sha256}.json`);
+    const archivePath=path.join(memoryRoot,'archives',`${historicalArchive.memory_sha256}.json`);
+    const archiveIndexPath=path.join(memoryRoot,'archive-indexes',`${historicalIndex.index_sha256}.json`);
+    const [snapshotFile,indexFile,archiveFile,archiveIndexFile]=await Promise.all([writeProjectionOnce(snapshotPath,snapshot),
+      writeProjectionOnce(indexPath,index),writeProjectionOnce(archivePath,historicalArchive),writeProjectionOnce(archiveIndexPath,historicalIndex)]);
+    const snapshotProof=verifyMemorySnapshot(snapshot,{goal,events,publicKey,keyId,sourceReleaseManifest});
+    insist(snapshotProof.ok,`R41 memory snapshot self-verification failed: ${snapshotProof.reason}`);
+    const indexProof=verifyRetrievalIndex(index,{corpus,sourceReleaseManifest});
+    insist(indexProof.ok,`R41 memory index self-verification failed: ${indexProof.reason}`);
+    const working=buildWorkingMemory({goal,events,corpus,index,publicKey,keyId,sourceReleaseManifest,byteBudget,
+      currentPlan,currentFiles,currentSymbols,currentAuthority,historicalArchive,historicalIndex});
+    return Object.freeze({status:'ok',source_release_manifest:sourceReleaseManifest,
+      journal_head_sha256:events.at(-1).event_sha256,snapshot_path:snapshotFile.path,
+      snapshot_sha256:snapshot.snapshot_sha256,snapshot_file_sha256:snapshotFile.sha256,
+      index_path:indexFile.path,index_sha256:index.index_sha256,index_file_sha256:indexFile.sha256,
+      historical_archive_path:archiveFile.path,historical_archive_sha256:historicalArchive.memory_sha256,
+      historical_archive_file_sha256:archiveFile.sha256,historical_index_path:archiveIndexFile.path,
+      historical_index_sha256:historicalIndex.index_sha256,historical_index_file_sha256:archiveIndexFile.sha256,
+      historical_goal_count:historicalCorpora.length,
+      replay_mode:loadedState.mode,replay_snapshot_reason:loadedState.snapshot_reason,
+      memory_sha256:corpus.memory_sha256,working_memory_sha256:working.working_memory_sha256,
+      semantic_enabled:false,planner_context:working});
+  }
+  async function plannerContext(input){return (await refresh(input)).planner_context;}
+  return Object.freeze({refresh,plannerContext,source_release_manifest:sourceReleaseManifest,semantic_enabled:false});
+}