deadbyte-mcp 0.15.0 → 0.15.2

package/scripts/release-parity-r46.mjs

@@ -0,0 +1,187 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyGenerationBundle } from '../src/release-generation.mjs';
+import { loadProcessPolicy, processSessionStatus } from '../src/process-policy.mjs';
+import { createProcessRuntime } from '../src/process-runtime.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const packageRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+function insist(ok,message){if(!ok)throw new Error(message);}
+function samePath(a,b){return path.resolve(String(a)).toLowerCase()===path.resolve(String(b)).toLowerCase();}
+
+async function waitForExit(runtime,sessionId,timeoutMs=10000){
+  const deadline=Date.now()+timeoutMs;
+  let page=null,text='';
+  while(Date.now()<deadline){
+    page=await runtime.read({sessionId,offset:0,maxBytes:65536});
+    text=Buffer.from(page.data_base64,'base64').toString('utf8');
+    if(page.state==='exited'||page.state==='terminated') return {page,text};
+    await sleep(50);
+  }
+  throw new Error('R46 PowerShell parity timed out');
+}
+
+export async function runReleaseParity({
+  root=packageRoot,
+  runtimeStateRoot=stateRoot,
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(root);
+  const state=path.resolve(runtimeStateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.15.2','R46 parity requires package version 0.15.2');
+
+  const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+  insist(pointer.version==='0.15.2'&&pointer.manifest_sha256===manifestSha256,'R46 active pointer candidate mismatch');
+  insist(pointer.release_id===`v0.15.2-${manifestSha256.slice(0,16)}`,'R46 active release id mismatch');
+  const releaseManifest=await readFile(path.join(pointer.release_root,'MANIFEST.SHA256'));
+  insist(sha256(releaseManifest)===manifestSha256,'R46 immutable release manifest mismatch');
+
+  const generation=await verifyGenerationBundle(pointer.generation_root,pointer.generation_manifest_sha256);
+  const processPolicyPath=path.join(pointer.generation_root,'process-policy.json');
+  const policy=await loadProcessPolicy(processPolicyPath);
+  const status=await processSessionStatus(policy);
+  insist(status.armed===true&&status.reason==='standing-grant','R46 parity requires restored Process standing grant');
+  insist(status.profile_ids.includes('powershell')&&status.root_ids.includes('core'),'R46 parity Process grant missing powershell/core');
+
+  const systemRoot=process.env.SystemRoot||process.env.WINDIR;
+  insist(typeof systemRoot==='string'&&systemRoot.length>0,'R46 parity requires SystemRoot/WINDIR');
+  const expectedPowerShell=path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe');
+  const expectedCmd=path.join(systemRoot,'System32','cmd.exe');
+  insist(samePath(policy.profiles?.powershell?.executable,expectedPowerShell),'R46 generated PowerShell path is not target-bound');
+  insist(samePath(policy.profiles?.ping_hold?.executable,expectedCmd),'R46 generated cmd path is not target-bound');
+  insist(policy.profiles.powershell.executable_sha256===sha256(await readFile(expectedPowerShell)),'R46 generated PowerShell digest mismatch');
+  insist(policy.profiles.ping_hold.executable_sha256===sha256(await readFile(expectedCmd)),'R46 generated cmd digest mismatch');
+  insist(JSON.stringify(policy.profiles.powershell.prefix_args)===JSON.stringify(['-NoLogo','-NoProfile','-NonInteractive','-Command']),'R46 PowerShell prefix contract mismatch');
+  insist(policy.profiles.powershell.max_args===1&&policy.profiles.powershell.max_arg_bytes===8192,'R46 PowerShell argument bounds mismatch');
+
+  const runtime=createProcessRuntime({
+    policy,
+    signingKeyPath:path.join(state,'trust','ed25519-private.pem'),
+    verifyKeyPath:path.join(state,'trust','ed25519-public.pem')
+  });
+  const source="$ErrorActionPreference='Stop';$before=@(Get-ChildItem -LiteralPath $env:TEMP -Filter '*.ps1' -File -ErrorAction SilentlyContinue|ForEach-Object{$_.FullName});[Console]::WriteLine('DB_R46_FILELESS_PARITY');[Console]::WriteLine('PSCommandPath=' + [string]$PSCommandPath);[Console]::WriteLine('InvocationPath=' + [string]$MyInvocation.MyCommand.Path);$after=@(Get-ChildItem -LiteralPath $env:TEMP -Filter '*.ps1' -File -ErrorAction SilentlyContinue|ForEach-Object{$_.FullName});$new=@($after|Where-Object{$_ -notin $before});[Console]::WriteLine('NEW_TEMP_PS1_COUNT=' + $new.Count)";
+  const started=await runtime.start({profileId:'powershell',rootId:'core',cwd:'.',args:[source]});
+  const observed=await waitForExit(runtime,started.session_id);
+  insist(observed.page.state==='exited'&&observed.page.exit_code===0,'R46 PowerShell parity process did not exit cleanly');
+  insist(/DB_R46_FILELESS_PARITY/.test(observed.text),'R46 PowerShell parity marker missing');
+  insist(/PSCommandPath=\r?\n/.test(observed.text),'R46 PowerShell unexpectedly materialized PSCommandPath');
+  insist(/InvocationPath=\r?\n/.test(observed.text),'R46 PowerShell invocation path is not fileless');
+  insist(/NEW_TEMP_PS1_COUNT=0/.test(observed.text),'R46 PowerShell parity created a temp ps1');
+  const journal=await runtime.verifyEventJournal({sessionId:started.session_id});
+  insist(journal.ok===true,'R46 PowerShell process journal verification failed');
+
+
+  insist(status.profile_ids.includes('powershell_repl'),'R46 parity Process grant missing powershell_repl');
+  insist(samePath(policy.profiles?.powershell_repl?.executable,expectedPowerShell),'R46 generated PowerShell REPL path is not target-bound');
+  insist(policy.profiles.powershell_repl.executable_sha256===sha256(await readFile(expectedPowerShell)),'R46 generated PowerShell REPL digest mismatch');
+  insist(policy.profiles.powershell_repl.allow_raw_input===true&&policy.profiles.powershell_repl.transport==='pipe','R46 PowerShell REPL raw-input contract mismatch');
+
+  const repl=await runtime.start({profileId:'powershell_repl',rootId:'core',cwd:'.',args:[]});
+  const firstWrite=await runtime.write({sessionId:repl.session_id,input:"$x=41;[Console]::WriteLine('DB_R46_REPL_SET')",appendNewline:true});
+  insist(firstWrite.session.state==='running','R46 PowerShell REPL did not remain running after first write');
+  const firstRead=await runtime.read({sessionId:repl.session_id,offset:0,maxBytes:65536,waitMs:5000,waitFor:'DB_R46_REPL_SET'});
+  insist(firstRead.wait_satisfied===true,'R46 PowerShell REPL first wait was not satisfied');
+  const beforeSecond=(await runtime.status({sessionId:repl.session_id})).stream_head;
+  await runtime.write({sessionId:repl.session_id,input:"[Console]::WriteLine('DB_R46_REPL_VALUE=' + ($x+1))",appendNewline:true});
+  const secondRead=await runtime.read({sessionId:repl.session_id,offset:beforeSecond,maxBytes:65536,waitMs:5000,waitFor:'DB_R46_REPL_VALUE=42'});
+  const secondText=Buffer.from(secondRead.data_base64,'base64').toString('utf8');
+  insist(secondRead.wait_satisfied===true&&/DB_R46_REPL_VALUE=42/.test(secondText),'R46 PowerShell REPL state did not persist across writes');
+  const tailRead=await runtime.read({sessionId:repl.session_id,offset:-4096,maxBytes:4096});
+  insist(/DB_R46_REPL_VALUE=42/.test(Buffer.from(tailRead.data_base64,'base64').toString('utf8')),'R46 PowerShell REPL tail read missing state proof');
+  await runtime.terminate({sessionId:repl.session_id});
+  const replJournal=await runtime.verifyEventJournal({sessionId:repl.session_id});
+  insist(replJournal.ok===true,'R46 PowerShell REPL journal verification failed');
+  const replJournalText=await readFile(path.join(policy.state_dir,`${repl.session_id}.jsonl`),'utf8');
+  insist(!replJournalText.includes('$x=41')&&!replJournalText.includes('DB_R46_REPL_VALUE'),'R46 raw process input leaked into signed journal');
+
+  const ringSource="[Console]::Write(('A'*2097152));[Console]::WriteLine('DB_R46_RING_TAIL')";
+  const ring=await runtime.start({profileId:'powershell',rootId:'core',cwd:'.',args:[ringSource]});
+  const ringObserved=await waitForExit(runtime,ring.session_id,15000);
+  const ringStatus=await runtime.status({sessionId:ring.session_id});
+  insist(ringObserved.page.exit_code===0&&ringStatus.earliest_offset>0,'R46 retained-output ring did not evict under heavy output');
+  const ringTail=await runtime.read({sessionId:ring.session_id,offset:-4096,maxBytes:4096});
+  insist(/DB_R46_RING_TAIL/.test(Buffer.from(ringTail.data_base64,'base64').toString('utf8')),'R46 retained-output ring lost tail marker');
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'R46 parity clock invalid');
+  const evidence={
+    schema:'deadbyte.r46-parity.v1',
+    status:'passed',
+    version:'0.15.2',
+    completed_at_utc:completed.toISOString(),
+    candidate:{
+      release_id:pointer.release_id,
+      manifest_sha256:pointer.manifest_sha256,
+      generation_manifest_sha256:pointer.generation_manifest_sha256
+    },
+    generation:{files:generation.files,generation_manifest_sha256:generation.generation_manifest_sha256},
+    process_policy:{
+      sha256:policy.policy_sha256,
+      profile_ids:Object.keys(policy.profiles).sort(),
+      powershell_executable:policy.profiles.powershell.executable,
+      powershell_executable_sha256:policy.profiles.powershell.executable_sha256,
+      cmd_executable:policy.profiles.ping_hold.executable,
+      cmd_executable_sha256:policy.profiles.ping_hold.executable_sha256,
+      target_repin_verified:true
+    },
+    fileless_powershell:{
+      session_id:started.session_id,
+      child_pid:started.child_pid,
+      exit_code:observed.page.exit_code,
+      stream_sha256:observed.page.stream_sha256,
+      pscommandpath_empty:true,
+      invocation_path_empty:true,
+      new_temp_ps1_count:0,
+      journal_head_sha256:journal.head_sha256,
+      journal_event_count:journal.event_count
+    },
+    persistent_powershell_repl:{
+      session_id:repl.session_id,
+      child_pid:repl.child_pid,
+      state_persisted:true,
+      observed_value:42,
+      wait_for_verified:true,
+      tail_read_verified:true,
+      raw_input_not_journaled:true,
+      journal_head_sha256:replJournal.head_sha256,
+      journal_event_count:replJournal.event_count
+    },
+    retained_output_ring:{
+      session_id:ring.session_id,
+      stream_head:ringStatus.stream_head,
+      earliest_offset:ringStatus.earliest_offset,
+      eviction_verified:true,
+      tail_marker_verified:true
+    },
+    execution_provider:'deadbyte_mcp',
+    rdc_operation_count:0
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(state,'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r46-parity-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',evidence_path:file,evidence_sha256:sha256(bytes),evidence};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed','existing R46 parity evidence invalid');
+    insist(existing.candidate?.manifest_sha256===manifestSha256,'existing R46 parity candidate mismatch');
+    return {status:'existing',evidence_path:file,evidence_sha256:sha256(existingBytes),evidence:existing};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)runReleaseParity().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/release-parity-tests-r45.ps1

@@ -0,0 +1,8 @@
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version 2.0
+& node.exe --test --test-concurrency=1 test\host-inline-r45.test.mjs test\hardware-observation-r45.test.mjs test\runtime-host-bootstrap-r45.test.mjs test\full-max-catalog-r45.test.mjs test\compact-max-catalog-r45.test.mjs test\r45-finalization.test.mjs test\skill-plane-r44.test.mjs test\skill-mcp-r44.test.mjs test\agent-backend-r44.test.mjs test\codex-app-server-r44.test.mjs test\codex-autonomous-r44.test.mjs test\remote-device-r44.test.mjs test\durable-job-r44.test.mjs test\external-job-provider-r44.test.mjs test\coding-runtime.test.mjs test\host-plane.test.mjs test\process-policy.test.mjs test\process-runtime.test.mjs test\native-diff.test.mjs test\native-diff-topology-r36.test.mjs test\autonomous-loop.test.mjs test\autonomous-adversarial.test.mjs test\standing-grants.test.mjs test\runtime-self-update.test.mjs
+if($LASTEXITCODE -ne 0){exit $LASTEXITCODE}
+& node.exe --test --test-concurrency=1 test\r44-finalization.test.mjs test\r43-finalization.test.mjs test\provider-responses-r42.test.mjs test\task-contract-r42.test.mjs test\human-clarification-r42.test.mjs test\agent-governance-r42.test.mjs test\evidence-publisher-r42.test.mjs test\agent-eval-r42.test.mjs test\agent-eval-runner-r42.test.mjs test\r42-finalization.test.mjs
+if($LASTEXITCODE -ne 0){exit $LASTEXITCODE}
+& node.exe --test --test-concurrency=1 test\memory-snapshot-r41.test.mjs test\memory-projections-r41.test.mjs test\memory-retrieval-r41.test.mjs test\memory-history-r41.test.mjs test\memory-autonomous-integration-r41.test.mjs
+exit $LASTEXITCODE

package/scripts/verify-r45-parent.mjs

@@ -0,0 +1,142 @@
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const CLOSURE_DOMAIN=Buffer.from('DEADBYTE-R44-FINAL-CLOSURE-V1\0','utf8');
+const HEX64=/^[0-9a-f]{64}$/;
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+const same=(a,b)=>canonicalJson(a)===canonicalJson(b);
+const samePath=(a,b)=>path.resolve(String(a)).toLowerCase()===path.resolve(String(b)).toLowerCase();
+function insist(ok,message){if(!ok) throw new Error(message);}
+
+function parseManifest(text){
+  const out=new Map();
+  for(const [i,line] of text.split(/\r?\n/).entries()){
+    if(!line) continue;
+    const m=/^([0-9a-f]{64})  ([^\0]+)$/.exec(line);
+    insist(m,`manifest line ${i+1} malformed`);
+    const rel=m[2];
+    insist(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!out.has(rel),`unsafe/duplicate manifest path ${rel}`);
+    out.set(rel,m[1]);
+  }
+  return out;
+}
+async function walk(root,rel=''){
+  const dir=path.join(root,...(rel?rel.split('/'):[]));
+  const names=(await readdir(dir)).sort((a,b)=>a.localeCompare(b,'en'));
+  const files=[];
+  for(const name of names){
+    const childRel=rel?`${rel}/${name}`:name;
+    const full=path.join(root,...childRel.split('/'));
+    const st=await lstat(full);
+    insist(!st.isSymbolicLink(),`symlink forbidden: ${childRel}`);
+    if(st.isDirectory()) files.push(...await walk(root,childRel));
+    else { insist(st.isFile(),`non-file forbidden: ${childRel}`); files.push(childRel); }
+  }
+  return files;
+}
+async function verifyTree(root,manifestName,expectedDigest,expectedCount){
+  const manifestBytes=await readFile(path.join(root,manifestName));
+  insist(sha256(manifestBytes)===expectedDigest,`${manifestName} digest mismatch`);
+  const entries=parseManifest(manifestBytes.toString('utf8'));
+  insist(entries.size===expectedCount,`${manifestName} file count mismatch`);
+  const actual=(await walk(root)).filter(rel=>rel!==manifestName).sort((a,b)=>a.localeCompare(b,'en'));
+  const expected=[...entries.keys()].sort((a,b)=>a.localeCompare(b,'en'));
+  insist(same(actual,expected),`${manifestName} exact tree mismatch`);
+  for(const [rel,digest] of entries){
+    insist(sha256(await readFile(path.join(root,...rel.split('/'))))===digest,`${manifestName} file hash mismatch: ${rel}`);
+  }
+  return entries.size;
+}
+
+export async function verifyR45Parent(parentFile,{stateRoot=path.join(os.homedir(),'.deadbyte-mcp')}={}){
+  const parentPath=path.resolve(parentFile);
+  const parent=JSON.parse(await readFile(parentPath,'utf8'));
+  insist(parent?.schema==='deadbyte.r45-parent.v1','R45 parent schema mismatch');
+  insist(parent.parent_release_id==='v0.15.0-c15fa41719be61b3','R45 parent release id mismatch');
+  insist(parent.parent_version==='0.15.0','R45 parent version mismatch');
+  insist(parent.parent_manifest_sha256==='c15fa41719be61b3186e49b2367a5f4c057365cfb465102dbefb7d7355f45483','R45 parent manifest mismatch');
+  insist(parent.parent_manifest_file_count===1871,'R45 parent file count mismatch');
+  insist(parent.parent_generation_manifest_sha256==='6d7429c050b7fe893492e102f00282019116e0c9e54e4f25a5791defa1661d30','R45 parent generation mismatch');
+  insist(parent.parent_generation_file_count===7,'R45 parent generation file count mismatch');
+  insist(parent.parent_final_closure_file_sha256==='8aa9c31ab18dfde67275d7cd59295ba08099839d35d6c97ee277fb184c05cae0','R45 parent closure file hash mismatch');
+  insist(parent.parent_final_closure_sha256==='533b7e0ff9ded04086dd90ed34e3b87bc427acc3c55c25bb9f4ec66cb448e667','R45 parent closure hash mismatch');
+  insist(parent.parent_final_closure_signer_key_id==='c0727a7911e29a0f1edd3cd910e47f89f43edb484743988c89cd82bfd5e37936','R45 parent closure signer mismatch');
+  insist(parent.parent_proof==='immutable-slot+generation+signed-final-closure','R45 parent proof class mismatch');
+
+  const closureBytes=await readFile(path.resolve(parent.parent_final_closure_path));
+  insist(sha256(closureBytes)===parent.parent_final_closure_file_sha256,'R45 parent closure file bytes mismatch');
+  const envelope=JSON.parse(closureBytes.toString('utf8'));
+  insist(envelope?.body?.schema==='deadbyte.r44-final-closure.v1','R45 parent closure schema mismatch');
+  insist(envelope.body.version===parent.parent_version,'R45 parent closure version mismatch');
+  insist(envelope.body.release_label==='R44 REMOTE AGENT SKILL BASELINE','R45 parent closure label mismatch');
+
+  const publicKey=createPublicKey(await readFile(path.join(path.resolve(stateRoot),'trust','ed25519-public.pem')));
+  insist(publicKey.asymmetricKeyType==='ed25519','R45 parent trust key must be Ed25519');
+  const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  insist(keyId===parent.parent_final_closure_signer_key_id,'R45 parent trust key id mismatch');
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(sha256(bodyBytes)===envelope.body_sha256,'R45 parent closure body hash mismatch');
+  const {closure_sha256,...unsigned}=envelope;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===closure_sha256,'R45 parent closure envelope hash mismatch');
+  insist(closure_sha256===parent.parent_final_closure_sha256,'R45 parent closure content address mismatch');
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R44-FINAL-CLOSURE-V1','R45 parent closure attestation contract mismatch');
+  insist(envelope.attestation.key_id===keyId,'R45 parent closure attestation signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([CLOSURE_DOMAIN,bodyBytes]),publicKey,Buffer.from(envelope.attestation.signature_base64,'base64')),'R45 parent closure signature invalid');
+
+  const pointer=envelope.body.active_pointer;
+  insist(pointer?.release_id===parent.parent_release_id&&pointer?.version===parent.parent_version&&pointer?.manifest_sha256===parent.parent_manifest_sha256,'R45 parent closure release binding mismatch');
+  insist(pointer.generation_manifest_sha256===parent.parent_generation_manifest_sha256,'R45 parent closure generation binding mismatch');
+  insist(pointer.launcher_sha256===parent.parent_launcher_sha256,'R45 parent launcher binding mismatch');
+  insist(samePath(pointer.release_root,parent.parent_release_root),'R45 parent release root mismatch');
+  insist(samePath(pointer.generation_root,parent.parent_generation_root),'R45 parent generation root mismatch');
+  insist(envelope.body.immutable_slot?.protected===true,'R45 parent immutable slot proof missing');
+  insist(samePath(envelope.body.immutable_slot.release_root,parent.parent_release_root),'R45 parent immutable release root mismatch');
+  insist(!samePath(envelope.body.immutable_slot.development_root,parent.parent_release_root),'R45 parent development root aliases release slot');
+  insist(samePath(envelope.body.immutable_slot.development_root,parent.development_root),'R45 parent development root mismatch');
+  insist(envelope.body.authority?.all_disarmed===true,'R45 parent closure did not record all-disarmed state');
+  for(const name of ['process-grant.json','coding-grant.json','autonomous-grant.json','desktop-grant.json','host-grant.json']){
+    insist(envelope.body.authority.grants_absent?.[name]===true,`R45 parent closure grant absence missing: ${name}`);
+  }
+
+  const evidence=envelope.body.evidence;
+  insist(evidence&&evidence.parity&&evidence.activation&&evidence.rollback&&evidence.restore&&evidence.windows_gate,'R45 parent closure evidence set incomplete');
+  for(const [name,item] of Object.entries(evidence)){
+    insist(typeof item?.path==='string'&&HEX64.test(item?.sha256??''),`R45 parent ${name} evidence identity malformed`);
+    insist(sha256(await readFile(item.path))===item.sha256,`R45 parent ${name} evidence hash mismatch`);
+  }
+  const parity=JSON.parse(await readFile(evidence.parity.path,'utf8'));
+  insist(parity?.schema==='deadbyte.r44-parity.v1'&&parity.status==='passed','R45 parent parity status mismatch');
+  insist(parity.candidate?.release_id===parent.parent_release_id&&parity.candidate?.manifest_sha256===parent.parent_manifest_sha256,'R45 parent parity candidate mismatch');
+  insist(parity.successor?.release_id===parent.parent_release_id&&parity.successor?.manifest_sha256===parent.parent_manifest_sha256,'R45 parent parity successor mismatch');
+  insist(parity.successor_disarmed?.status==='passed','R45 parent successor-disarmed proof missing');
+
+  const releaseFiles=await verifyTree(parent.parent_release_root,'MANIFEST.SHA256',parent.parent_manifest_sha256,parent.parent_manifest_file_count);
+  const generationFiles=await verifyTree(parent.parent_generation_root,'GENERATION.SHA256',parent.parent_generation_manifest_sha256,parent.parent_generation_file_count);
+  return {
+    ok:true,
+    status:'passed',
+    proof_class:parent.parent_proof,
+    release_id:parent.parent_release_id,
+    manifest_sha256:parent.parent_manifest_sha256,
+    generation_manifest_sha256:parent.parent_generation_manifest_sha256,
+    release_files:releaseFiles,
+    generation_files:generationFiles,
+    closure_sha256:parent.parent_final_closure_sha256,
+    closure_file_sha256:parent.parent_final_closure_file_sha256,
+    signer_key_id:keyId,
+    recorded_all_disarmed:true
+  };
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const file=process.argv[2]??path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..','R45-PARENT.json');
+  verifyR45Parent(file).then(result=>console.log(JSON.stringify(result,null,2)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence-r45.mjs

@@ -0,0 +1,60 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyR45Parent } from './verify-r45-parent.mjs';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.15.1 / R45 MACHINE FREEDOM WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok)throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.15.1',`Windows gate evidence requires V0.15.1, found ${pkg.version}`);
+  const parent=await verifyR45Parent(path.join(candidate,'R45-PARENT.json'));
+  const doctorResult=await doctor();
+  insist(doctorResult?.status==='ok'&&doctorResult?.package_version==='0.15.1'&&doctorResult?.manifest?.verified===true,'R45 doctor evidence invalid');
+  insist(doctorResult?.policy?.host_v2_ready===true,'R45 doctor did not verify Host policy v2');
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r45-windows-gate.v1',status:'passed',exit_code:0,version:'0.15.1',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256,
+    doctor:{status:doctorResult.status,manifest_sha256:doctorResult.manifest.sha256,verified_entries:doctorResult.manifest.verified_entries,host_v2_ready:doctorResult.policy.host_v2_ready},
+    parent:{release_id:parent.release_id,manifest_sha256:parent.manifest_sha256,
+      generation_manifest_sha256:parent.generation_manifest_sha256,
+      final_closure_sha256:parent.closure_sha256,final_closure_file_sha256:parent.closure_file_sha256,
+      signer_key_id:parent.signer_key_id},
+    features:{skill_integrity:true,agent_backend_persistence:true,codex_protocol_contract:true,
+      remote_device_identity:true,durable_job_supervisor:true,real_external_supervisor_smoke:true,
+      full_regression_required:true,codex_live_binary_required:false,host_inline_native:true,native_hardware_observation:true,doctor_release_truth:true}
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r45-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256,parent:evidence.parent};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R45 Windows gate evidence invalid');
+    insist(existing.version==='0.15.1'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R45 Windows gate identity mismatch');
+    insist(existing.parent?.release_id===parent.release_id&&existing.parent?.final_closure_sha256===parent.closure_sha256,'existing R45 parent evidence mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,parent:existing.parent};
+  }
+}
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeWindowsGateEvidence().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/windows-gate-evidence-r46.mjs

@@ -0,0 +1,110 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.15.2 / R46 FILELESS POWERSHELL WINDOWS BATCH GATE: PASS';
+const PARENT_RELEASE_ID='v0.15.1-d55f00b5144dc31a';
+const PARENT_MANIFEST='d55f00b5144dc31a7fe39e4dc60d640a94780da6aaeca0918e87636b816d7854';
+const PARENT_GENERATION='00cde7bf540cc2804d679a39040d5b07193c5f8a0d49cac3b882402f8f4e6ad8';
+const REOPENED_RUNTIME_RELEASE_ID='v0.15.2-0fb46542f6a4345f';
+const REOPENED_RUNTIME_MANIFEST='0fb46542f6a4345f1c527565d06bf6e9b8e283260e47bf684fb70a60308fcf34';
+const REOPENED_RUNTIME_GENERATION='4717e0eb9c515ce4b1e90b8496c49c68abde765a6de7490176b803912385afe4';
+function insist(ok,message){if(!ok)throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.15.2',`R46 Windows gate evidence requires V0.15.2, found ${pkg.version}`);
+  const release=JSON.parse(await readFile(path.join(candidate,'RELEASE.json'),'utf8'));
+  insist(release.version==='0.15.2'&&release.train==='R46','R46 release metadata mismatch');
+  const active=JSON.parse(await readFile(path.join(path.resolve(stateRoot),'active-release.json'),'utf8'));
+  const originalParent=active.release_id===PARENT_RELEASE_ID&&active.manifest_sha256===PARENT_MANIFEST&&active.generation_manifest_sha256===PARENT_GENERATION;
+  const reopenedPredecessor=active.release_id===REOPENED_RUNTIME_RELEASE_ID&&active.manifest_sha256===REOPENED_RUNTIME_MANIFEST&&active.generation_manifest_sha256===REOPENED_RUNTIME_GENERATION;
+  insist(originalParent||reopenedPredecessor,'R46 runtime predecessor identity mismatch');
+  const parent={release_id:PARENT_RELEASE_ID,version:'0.15.1',manifest_sha256:PARENT_MANIFEST,generation_manifest_sha256:PARENT_GENERATION};
+
+  const doctorResult=await doctor();
+  insist(doctorResult?.status==='ok'&&doctorResult?.package_version==='0.15.2'&&doctorResult?.manifest?.verified===true,'R46 doctor evidence invalid');
+  insist(doctorResult?.policy?.host_v2_ready===true,'R46 doctor did not verify Host policy v2');
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'R46 Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r46-windows-gate.v1',
+    status:'passed',
+    exit_code:0,
+    version:'0.15.2',
+    train:'R46',
+    marker,
+    completed_at_utc:completed.toISOString(),
+    manifest_sha256:manifestSha256,
+    doctor:{
+      status:doctorResult.status,
+      manifest_sha256:doctorResult.manifest.sha256,
+      verified_entries:doctorResult.manifest.verified_entries,
+      host_v2_ready:doctorResult.policy.host_v2_ready
+    },
+    parent,
+    runtime_predecessor:{
+      release_id:active.release_id,
+      version:active.version,
+      manifest_sha256:active.manifest_sha256,
+      generation_manifest_sha256:active.generation_manifest_sha256,
+      mode:reopenedPredecessor?'reopened-unpublished-0.15.2':'sealed-0.15.1-parent'
+    },
+    features:{
+      fileless_powershell:true,
+      powershell_source_via_process_argv:true,
+      no_ps1_materialization_regression:true,
+      target_machine_process_profile_repin:true,
+      target_machine_cmd_repin:true,
+      target_machine_powershell_repin:true,
+      powershell_persistent_repl:true,
+      guarded_process_raw_input:true,
+      process_tail_reads:true,
+      process_wait_reads:true,
+      process_chunked_output_ring:true,
+      remote_reachability_ttl:true,
+      remote_probe_timeout_retry:true,
+      remote_dispatch_timeout_no_retry:true,
+      observation_search_terminal_ttl:true,
+      observation_search_hard_cap:128,
+      full_regression_required:true,
+      compact_tool_count:43,
+      full_tool_count:83
+    }
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r46-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256,parent:evidence.parent};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R46 Windows gate evidence invalid');
+    insist(existing.version==='0.15.2'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R46 Windows gate identity mismatch');
+    insist(existing.parent?.release_id===parent.release_id&&existing.parent?.manifest_sha256===parent.manifest_sha256,'existing R46 parent evidence mismatch');
+    insist(existing.runtime_predecessor?.release_id===active.release_id&&existing.runtime_predecessor?.manifest_sha256===active.manifest_sha256,'existing R46 runtime predecessor evidence mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,parent:existing.parent};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeWindowsGateEvidence().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/src/autonomous-runtime.mjs

@@ -1230,10 +1230,13 @@ async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, co
   return results;
 }
 
-async function collectNativeHead(state, nativeDiffRuntime, codingRuntime) {
+async function collectNativeHead(state, nativeDiffRuntime, codingRuntime, { requireCurrentState = true } = {}) {
   const diffBindings = []; const head = new Map();
   for (const item of state.diffs) {
-    const checked = await nativeDiffRuntime.verify({ diffId:item.diff_id });
+    const verifier = requireCurrentState
+      ? nativeDiffRuntime.verify.bind(nativeDiffRuntime)
+      : (nativeDiffRuntime.verifyEvidence ?? nativeDiffRuntime.verify).bind(nativeDiffRuntime);
+    const checked = await verifier({ diffId:item.diff_id });
     if (!checked.ok || !Array.isArray(checked.final_states)) throw new Error(`release diff '${item.diff_id}' verification failed`);
     diffBindings.push({ diff_id:item.diff_id, receipt_sha256:checked.receipt_sha256,
       coding_receipts_verified:checked.coding_receipts_verified });
@@ -1243,10 +1246,12 @@ async function collectNativeHead(state, nativeDiffRuntime, codingRuntime) {
     }
   }
   const finalSourceStates = [...head.values()].sort((a,b) => `${a.root_id}/${a.path}`.localeCompare(`${b.root_id}/${b.path}`));
-  for (const expected of finalSourceStates) {
-    const current = await codingRuntime.fileState({ rootId:expected.root_id, relativePath:expected.path });
-    if (current.exists !== expected.exists || current.sha256 !== expected.sha256) {
-      throw new Error(`release native HEAD mismatch '${expected.path}'`);
+  if (requireCurrentState) {
+    for (const expected of finalSourceStates) {
+      const current = await codingRuntime.fileState({ rootId:expected.root_id, relativePath:expected.path });
+      if (current.exists !== expected.exists || current.sha256 !== expected.sha256) {
+        throw new Error(`release native HEAD mismatch '${expected.path}'`);
+      }
     }
   }
   return { diffBindings, finalSourceStates };
@@ -1309,7 +1314,7 @@ async function verifyReleaseReceipt({ ctx, goal, events, policy, verifyKeyPath,
     return { ok:false, reason:'release profile evidence mismatch' };
   }
   let nativeHead;
-  try { nativeHead = await collectNativeHead(preCompletionState,nativeDiffRuntime,codingRuntime); }
+  try { nativeHead = await collectNativeHead(preCompletionState,nativeDiffRuntime,codingRuntime,{requireCurrentState:false}); }
   catch (error) { return { ok:false, reason:truncated(error) }; }
   if (canonicalJson(nativeHead.diffBindings) !== canonicalJson(body.native_diffs ?? [])) {
     return { ok:false, reason:'release native diff binding mismatch' };

package/src/capability-ledger.mjs

@@ -89,6 +89,7 @@ export const R36_CAPABILITY_ENTRIES=Object.freeze([
 
   gateway('process.start','process_session_start','process_session','start','DEADBYTE_PROCESS_RUNTIME','process',{mutating:true,receipt_class:'process'}),
   gateway('process.read','process_session_read','process_session','read','DEADBYTE_PROCESS_RUNTIME','process',{receipt_class:'process'}),
+  gateway('process.write','process_session_write','process_session','write','DEADBYTE_PROCESS_RUNTIME','process',{mutating:true,receipt_class:'process'}),
   gateway('process.status','process_session_status','process_session','status','DEADBYTE_PROCESS_RUNTIME','process',{receipt_class:'process'}),
   gateway('process.list','process_session_list','process_session','list','DEADBYTE_PROCESS_RUNTIME','process',{receipt_class:'process'}),
   gateway('process.action','process_session_action','process_session','action','DEADBYTE_PROCESS_RUNTIME','process',{mutating:true,receipt_class:'process'}),
@@ -135,6 +136,7 @@ export const R36_CAPABILITY_ENTRIES=Object.freeze([
   gateway('observation.search_cancel','machine_search_cancel','machine_observe','search_cancel','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
   gateway('observation.process_list','machine_process_list','machine_observe','process_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
   gateway('observation.system_status','machine_system_status','machine_observe','system_status','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.hardware_query','machine_hardware_query','machine_observe','hardware_query','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
 
   gateway('desktop.status','desktop_status','desktop_control','status','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),
   gateway('desktop.observe','desktop_observe','desktop_control','observe','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),