deadbyte-mcp 0.11.2 → 0.12.0

package/scripts/final-closure-verify-r39.mjs

@@ -0,0 +1,208 @@
+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 HEX64=/^[0-9a-f]{64}$/;
+const UPDATE_DOMAIN=Buffer.from('DEADBYTE-R27-SLOT-UPDATE-V1\0','utf8');
+const CLOSURE_DOMAIN=Buffer.from('DEADBYTE-R39-FINAL-CLOSURE-V1\0','utf8');
+const PING_DOMAIN=Buffer.from('DEADBYTE-MACHINE-PING-V1\0','utf8');
+const R39_PREDECESSOR_RELEASE_ID='v0.11.2-058605dfccaa3035';
+const R39_PREDECESSOR_MANIFEST='058605dfccaa3035a57c6393d53f2421c14e5a92bd145c2334477ba24d7cab8b';
+const R39_FULL_TOOL_COUNT=76;
+const R39_COMPACT_TOOL_LIMIT=42;
+const REQUIRED_PARITY_KEYS=['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface'];
+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);
+function insist(ok,msg){if(!ok) throw new Error(msg);}
+function samePath(a,b){return path.resolve(String(a)).toLowerCase()===path.resolve(String(b)).toLowerCase();}
+function isCandidateIdentity(value,manifest){
+  return value?.version==='0.11.3'&&value?.manifest_sha256===manifest&&value?.release_id===`v0.11.3-${manifest.slice(0,16)}`;
+}
+function isR39PredecessorIdentity(value){
+  return value?.version==='0.11.2'&&value?.manifest_sha256===R39_PREDECESSOR_MANIFEST&&value?.release_id===R39_PREDECESSOR_RELEASE_ID;
+}
+
+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`);
+    insist(!path.posix.isAbsolute(m[2])&&!m[2].split('/').includes('..')&&!out.has(m[2]),`unsafe/duplicate manifest path ${m[2]}`);
+    out.set(m[2],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){
+  const manifestBytes=await readFile(path.join(root,manifestName));
+  insist(sha256(manifestBytes)===expectedDigest,`${manifestName} digest mismatch`);
+  const entries=parseManifest(manifestBytes.toString('utf8'));
+  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;
+}
+function publicKeyInfo(publicPem){
+  const key=createPublicKey(publicPem);insist(key.asymmetricKeyType==='ed25519','public key must be Ed25519');
+  const der=Buffer.from(key.export({type:'spki',format:'der'}));
+  return {key,key_id:sha256(der),spki_base64:der.toString('base64')};
+}
+function verifyUpdateEnvelope(env,keyInfo){
+  insist(env?.body&&env?.attestation,'update envelope malformed');
+  const bodyBytes=Buffer.from(canonicalJson(env.body),'utf8');
+  insist(sha256(bodyBytes)===env.body_sha256,'update body hash mismatch');
+  const {receipt_sha256,...unsigned}=env;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===receipt_sha256,'update receipt hash mismatch');
+  insist(env.attestation.algorithm==='ed25519'&&env.attestation.domain==='DEADBYTE-R27-SLOT-UPDATE-V1','update attestation contract mismatch');
+  insist(env.attestation.key_id===keyInfo.key_id,'update signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([UPDATE_DOMAIN,bodyBytes]),keyInfo.key,Buffer.from(env.attestation.signature_base64,'base64')),'update signature invalid');
+  return true;
+}
+function verifyPing(ping,status,pointer){
+  insist(ping?.status==='ok'&&ping.schema==='deadbyte.machine-ping.v1','machine ping malformed');
+  insist(status?.status==='ok'&&typeof status.public_key_spki_base64==='string','machine status malformed');
+  const der=Buffer.from(status.public_key_spki_base64,'base64');
+  insist(der.toString('base64')===status.public_key_spki_base64,'machine SPKI base64 non-canonical');
+  const machineKey=createPublicKey({key:der,format:'der',type:'spki'});insist(machineKey.asymmetricKeyType==='ed25519','machine key must be Ed25519');
+  const machineId=sha256(der);
+  insist(status.machine_id===machineId&&ping.machine_id===machineId&&ping.attestation?.key_id===machineId,'machine id/key mismatch');
+  insist(ping.release_id===pointer.release_id&&ping.release_manifest_sha256===pointer.manifest_sha256,'machine ping release binding mismatch');
+  insist(ping.generation_manifest_sha256===pointer.generation_manifest_sha256,'machine ping generation binding mismatch');
+  const {status:_s,attestation:_a,...body}=ping;
+  const bytes=Buffer.from(canonicalJson(body),'utf8');
+  insist(cryptoVerify(null,Buffer.concat([PING_DOMAIN,bytes]),machineKey,Buffer.from(ping.attestation.signature_base64,'base64')),'machine ping signature invalid');
+}
+
+export async function verifyFinalClosureObject(envelope,{stateRoot=path.join(os.homedir(),'.deadbyte-mcp')}={}){
+  insist(envelope?.body?.schema==='deadbyte.r39-final-closure.v1','closure schema mismatch');
+  insist(envelope.body.version==='0.11.3','closure version mismatch');
+  insist(envelope.body.release_label==='R39 FINAL MACHINE BASELINE','closure release label mismatch');
+  const keyInfo=publicKeyInfo(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(sha256(bodyBytes)===envelope.body_sha256,'closure body hash mismatch');
+  const {closure_sha256,...unsigned}=envelope;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===closure_sha256,'closure envelope hash mismatch');
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R39-FINAL-CLOSURE-V1','closure attestation contract mismatch');
+  insist(envelope.attestation.key_id===keyInfo.key_id,'closure signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([CLOSURE_DOMAIN,bodyBytes]),keyInfo.key,Buffer.from(envelope.attestation.signature_base64,'base64')),'closure signature invalid');
+
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  insist(same(pointer,envelope.body.active_pointer),'active pointer drift');
+  insist(pointer.version==='0.11.3','active pointer version mismatch');
+  insist(isCandidateIdentity(pointer,pointer.manifest_sha256),'release id/content address mismatch');
+  const releaseFiles=await verifyTree(pointer.release_root,'MANIFEST.SHA256',pointer.manifest_sha256);
+  const generationFiles=await verifyTree(pointer.generation_root,'GENERATION.SHA256',pointer.generation_manifest_sha256);
+  insist(sha256(await readFile(path.join(stateRoot,'bin','DEADBYTE-MCP.ps1')))===pointer.launcher_sha256,'launcher hash mismatch');
+
+  const predecessor=envelope.body.predecessor;
+  insist(isR39PredecessorIdentity(predecessor),'closure predecessor is not exact sealed R39 predecessor');
+  const immutable=envelope.body.immutable_slot;
+  insist(immutable?.protected===true,'closure immutable-slot protection missing');
+  insist(samePath(immutable.release_root,pointer.release_root),'closure immutable release_root mismatch');
+  insist(!samePath(immutable.development_root,immutable.release_root),'closure development_root aliases immutable release_root');
+
+  const surfaces=envelope.body.surfaces;
+  insist(surfaces?.local_full?.status==='passed'&&surfaces.local_full.tool_count===R39_FULL_TOOL_COUNT&&surfaces.local_full.strict_output_schemas===true,'closure local full 76-tool proof invalid');
+  insist(HEX64.test(surfaces.local_full.catalog_sha256??''),'closure local full catalog hash missing');
+  insist(surfaces?.public_compact?.status==='passed'&&surfaces.public_compact.tool_count<=R39_COMPACT_TOOL_LIMIT&&surfaces.public_compact.capability_closure===true,'closure public compact capability proof invalid');
+  insist(surfaces.public_compact.coding_armed===false&&surfaces.public_compact.autonomous_armed===false,'closure compact authority is not DISARMED');
+  insist(HEX64.test(surfaces.public_compact.catalog_sha256??'')&&HEX64.test(surfaces.public_compact.ledger_sha256??''),'closure compact catalog/ledger hash missing');
+
+  const evidence=envelope.body.evidence;
+  insist(evidence&&evidence.parity&&evidence.activation&&evidence.rollback&&evidence.restore&&evidence.windows_gate,'closure evidence set incomplete');
+  for(const [name,item] of Object.entries(evidence)){
+    insist(item?.path&&HEX64.test(item.sha256??''),`${name} evidence identity malformed`);
+    insist(sha256(await readFile(item.path))===item.sha256,`${name} evidence hash mismatch`);
+  }
+
+  const parity=JSON.parse(await readFile(evidence.parity.path,'utf8'));
+  insist(parity.schema==='deadbyte.r39-parity.v1'&&parity.status==='passed','R39 parity evidence invalid');
+  insist(parity.rdc_operation_count===0&&parity.execution_provider==='deadbyte_mcp','R39 parity execution provider mismatch');
+  insist(isCandidateIdentity(parity.candidate,pointer.manifest_sha256),'R39 parity candidate binding mismatch');
+  insist(isCandidateIdentity(parity.successor,pointer.manifest_sha256),'R39 parity successor binding mismatch');
+  insist(isR39PredecessorIdentity(parity.predecessor),'R39 parity predecessor binding mismatch');
+  insist(parity.local_full?.status==='passed'&&parity.local_full.tool_count===R39_FULL_TOOL_COUNT&&parity.local_full.strict_output_schemas===true,'R39 parity local full proof invalid');
+  insist(parity.local_full.catalog_sha256===surfaces.local_full.catalog_sha256,'R36 local full catalog drift between parity and closure');
+  insist(parity.public_compact?.status==='passed'&&parity.public_compact.tool_count<=R39_COMPACT_TOOL_LIMIT&&parity.public_compact.capability_closure===true&&parity.public_compact.gateway_count===5,'R39 parity public compact proof invalid');
+  insist(parity.successor_disarmed?.status==='passed'&&parity.successor_disarmed.tool_count<=R39_COMPACT_TOOL_LIMIT&&parity.successor_disarmed.capability_closure===true&&parity.successor_disarmed.coding_armed===false&&parity.successor_disarmed.autonomous_armed===false,'R39 parity successor disarmed proof invalid');
+  insist(parity.successor_disarmed.catalog_sha256===surfaces.public_compact.catalog_sha256,'R36 compact catalog drift between restore and closure');
+  insist(parity.successor_disarmed.ledger_sha256===surfaces.public_compact.ledger_sha256,'R36 capability ledger drift between restore and closure');
+  insist(parity.immutable_slot?.protected===true,'R39 parity immutable-slot proof missing');
+  insist(samePath(parity.immutable_slot.release_root,pointer.release_root),'R39 parity immutable release_root mismatch');
+  insist(samePath(parity.immutable_slot.development_root,immutable.development_root),'R39 parity/closure development_root mismatch');
+  insist(!samePath(parity.immutable_slot.development_root,pointer.release_root),'R36 mutable development_root aliases immutable release slot');
+  for(const key of REQUIRED_PARITY_KEYS) insist(parity.requirements?.[key]===true,`R39 parity requirement missing ${key}`);
+
+  const activation=JSON.parse(await readFile(evidence.activation.path,'utf8'));
+  const rollback=JSON.parse(await readFile(evidence.rollback.path,'utf8'));
+  const restore=JSON.parse(await readFile(evidence.restore.path,'utf8'));
+  verifyUpdateEnvelope(activation,keyInfo);verifyUpdateEnvelope(rollback,keyInfo);verifyUpdateEnvelope(restore,keyInfo);
+  insist(activation.body.schema==='deadbyte.r27-slot-update-receipt.v1'&&activation.body.rollback_performed===false,'R39 activation receipt invalid');
+  insist(activation.body.release_version==='0.11.3'&&activation.body.candidate_manifest_sha256===pointer.manifest_sha256,'R39 activation candidate identity invalid');
+  insist(isCandidateIdentity(activation.body.active_pointer,pointer.manifest_sha256),'R39 activation active pointer invalid');
+  insist(isR39PredecessorIdentity(activation.body.prior_pointer),'R39 activation predecessor is not exact 0.11.2 predecessor');
+  insist(samePath(activation.body.development_root,immutable.development_root),'R39 activation development_root mismatch');
+  insist(!samePath(activation.body.development_root,activation.body.active_pointer.release_root),'R39 activation development_root aliases release slot');
+
+  insist(rollback.body.schema==='deadbyte.r31-slot-rollback-receipt.v1'&&rollback.body.rollback_performed===true,'R39 rollback receipt invalid');
+  insist(isCandidateIdentity(rollback.body.from_pointer,pointer.manifest_sha256),'R39 rollback source is not exact candidate');
+  insist(isR39PredecessorIdentity(rollback.body.active_pointer),'R39 rollback target is not exact 0.11.2 predecessor');
+  insist(rollback.body.activation_receipt_sha256===activation.receipt_sha256,'R39 rollback not bound to activation receipt');
+
+  insist(restore.body.schema==='deadbyte.r27-slot-update-receipt.v1'&&restore.body.rollback_performed===false,'R39 restore receipt invalid');
+  insist(restore.body.release_version==='0.11.3'&&restore.body.candidate_manifest_sha256===pointer.manifest_sha256,'R39 restore candidate identity invalid');
+  insist(isR39PredecessorIdentity(restore.body.prior_pointer),'R39 restore predecessor is not exact 0.11.2 predecessor');
+  insist(isCandidateIdentity(restore.body.active_pointer,pointer.manifest_sha256)&&same(restore.body.active_pointer,pointer),'R39 restore/current pointer mismatch');
+  insist(samePath(restore.body.development_root,immutable.development_root),'R39 restore development_root mismatch');
+  insist(!samePath(restore.body.development_root,restore.body.active_pointer.release_root),'R39 restore development_root aliases release slot');
+
+  const windowsGate=JSON.parse(await readFile(evidence.windows_gate.path,'utf8'));
+  insist(windowsGate.schema==='deadbyte.r39-windows-gate.v1'&&windowsGate.status==='passed'&&windowsGate.exit_code===0,'R39 Windows gate evidence invalid');
+  insist(windowsGate.version==='0.11.3'&&windowsGate.manifest_sha256===pointer.manifest_sha256,'R39 Windows gate manifest/version binding mismatch');
+  insist(windowsGate.marker==='DEADBYTE V0.11.3 / R39 WINDOWS BATCH GATE: PASS','R39 Windows gate PASS marker mismatch');
+
+  const machine=envelope.body.machine;
+  insist(machine?.status?.release_id===pointer.release_id&&machine.status.release_manifest_sha256===pointer.manifest_sha256&&machine.status.generation_manifest_sha256===pointer.generation_manifest_sha256,'machine status binding mismatch');
+  verifyPing(machine.ping,machine.status,pointer);
+  insist(machine.ping.nonce===machine.nonce,'machine ping nonce binding mismatch');
+
+  const grantNames=['process-grant.json','coding-grant.json','autonomous-grant.json','host-grant.json'];
+  insist(envelope.body.authority?.all_disarmed===true,'closure authority not disarmed');
+  for(const name of grantNames){
+    let exists=true;try{await lstat(path.join(stateRoot,'runtime',name));}catch(error){if(error?.code==='ENOENT') exists=false;else throw error;}
+    insist(!exists,`authority grant still present: ${name}`);
+    insist(envelope.body.authority.grants_absent?.[name]===true,`closure grant absence not recorded: ${name}`);
+  }
+  return {ok:true,status:'passed',release_id:pointer.release_id,manifest_sha256:pointer.manifest_sha256,
+    generation_manifest_sha256:pointer.generation_manifest_sha256,release_files:releaseFiles,generation_files:generationFiles,
+    machine_id:machine.status.machine_id,parity_sha256:evidence.parity.sha256,closure_sha256:envelope.closure_sha256,
+    full_tool_count:R39_FULL_TOOL_COUNT,compact_tool_count:surfaces.public_compact.tool_count};
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const file=process.argv[2];
+  if(!file) throw new Error('usage: node scripts/final-closure-verify-r39.mjs <closure.json>');
+  try{
+    const envelope=JSON.parse(await readFile(path.resolve(file),'utf8'));
+    console.log(JSON.stringify(await verifyFinalClosureObject(envelope),null,2));
+  }catch(error){console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;}
+}

package/scripts/final-closure-verify-r40.mjs

@@ -0,0 +1,212 @@
+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 HEX64=/^[0-9a-f]{64}$/;
+const UPDATE_DOMAIN=Buffer.from('DEADBYTE-R27-SLOT-UPDATE-V1\0','utf8');
+const CLOSURE_DOMAIN=Buffer.from('DEADBYTE-R40-FINAL-CLOSURE-V1\0','utf8');
+const PING_DOMAIN=Buffer.from('DEADBYTE-MACHINE-PING-V1\0','utf8');
+const R40_PREDECESSOR_RELEASE_ID='v0.11.3-ce761dd6e014d42e';
+const R40_PREDECESSOR_MANIFEST='ce761dd6e014d42eddb635855038e0ce049c63c6e3af7e63c3005bbe198bcf7b';
+const R40_FULL_TOOL_COUNT=80;
+const R40_COMPACT_TOOL_COUNT=42;
+const REQUIRED_PARITY_KEYS=['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input'];
+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);
+function insist(ok,msg){if(!ok) throw new Error(msg);}
+function samePath(a,b){return path.resolve(String(a)).toLowerCase()===path.resolve(String(b)).toLowerCase();}
+function isCandidateIdentity(value,manifest){
+  return value?.version==='0.12.0'&&value?.manifest_sha256===manifest&&value?.release_id===`v0.12.0-${manifest.slice(0,16)}`;
+}
+function isR40PredecessorIdentity(value){
+  return value?.version==='0.11.3'&&value?.manifest_sha256===R40_PREDECESSOR_MANIFEST&&value?.release_id===R40_PREDECESSOR_RELEASE_ID;
+}
+
+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`);
+    insist(!path.posix.isAbsolute(m[2])&&!m[2].split('/').includes('..')&&!out.has(m[2]),`unsafe/duplicate manifest path ${m[2]}`);
+    out.set(m[2],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){
+  const manifestBytes=await readFile(path.join(root,manifestName));
+  insist(sha256(manifestBytes)===expectedDigest,`${manifestName} digest mismatch`);
+  const entries=parseManifest(manifestBytes.toString('utf8'));
+  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;
+}
+function publicKeyInfo(publicPem){
+  const key=createPublicKey(publicPem);insist(key.asymmetricKeyType==='ed25519','public key must be Ed25519');
+  const der=Buffer.from(key.export({type:'spki',format:'der'}));
+  return {key,key_id:sha256(der),spki_base64:der.toString('base64')};
+}
+function verifyUpdateEnvelope(env,keyInfo){
+  insist(env?.body&&env?.attestation,'update envelope malformed');
+  const bodyBytes=Buffer.from(canonicalJson(env.body),'utf8');
+  insist(sha256(bodyBytes)===env.body_sha256,'update body hash mismatch');
+  const {receipt_sha256,...unsigned}=env;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===receipt_sha256,'update receipt hash mismatch');
+  insist(env.attestation.algorithm==='ed25519'&&env.attestation.domain==='DEADBYTE-R27-SLOT-UPDATE-V1','update attestation contract mismatch');
+  insist(env.attestation.key_id===keyInfo.key_id,'update signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([UPDATE_DOMAIN,bodyBytes]),keyInfo.key,Buffer.from(env.attestation.signature_base64,'base64')),'update signature invalid');
+  return true;
+}
+function verifyPing(ping,status,pointer){
+  insist(ping?.status==='ok'&&ping.schema==='deadbyte.machine-ping.v1','machine ping malformed');
+  insist(status?.status==='ok'&&typeof status.public_key_spki_base64==='string','machine status malformed');
+  const der=Buffer.from(status.public_key_spki_base64,'base64');
+  insist(der.toString('base64')===status.public_key_spki_base64,'machine SPKI base64 non-canonical');
+  const machineKey=createPublicKey({key:der,format:'der',type:'spki'});insist(machineKey.asymmetricKeyType==='ed25519','machine key must be Ed25519');
+  const machineId=sha256(der);
+  insist(status.machine_id===machineId&&ping.machine_id===machineId&&ping.attestation?.key_id===machineId,'machine id/key mismatch');
+  insist(ping.release_id===pointer.release_id&&ping.release_manifest_sha256===pointer.manifest_sha256,'machine ping release binding mismatch');
+  insist(ping.generation_manifest_sha256===pointer.generation_manifest_sha256,'machine ping generation binding mismatch');
+  const {status:_s,attestation:_a,...body}=ping;
+  const bytes=Buffer.from(canonicalJson(body),'utf8');
+  insist(cryptoVerify(null,Buffer.concat([PING_DOMAIN,bytes]),machineKey,Buffer.from(ping.attestation.signature_base64,'base64')),'machine ping signature invalid');
+}
+
+export async function verifyFinalClosureObject(envelope,{stateRoot=path.join(os.homedir(),'.deadbyte-mcp')}={}){
+  insist(envelope?.body?.schema==='deadbyte.r40-final-closure.v1','closure schema mismatch');
+  insist(envelope.body.version==='0.12.0','closure version mismatch');
+  insist(envelope.body.release_label==='R40 FINAL MACHINE BASELINE','closure release label mismatch');
+  const keyInfo=publicKeyInfo(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(sha256(bodyBytes)===envelope.body_sha256,'closure body hash mismatch');
+  const {closure_sha256,...unsigned}=envelope;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===closure_sha256,'closure envelope hash mismatch');
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R40-FINAL-CLOSURE-V1','closure attestation contract mismatch');
+  insist(envelope.attestation.key_id===keyInfo.key_id,'closure signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([CLOSURE_DOMAIN,bodyBytes]),keyInfo.key,Buffer.from(envelope.attestation.signature_base64,'base64')),'closure signature invalid');
+
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  insist(same(pointer,envelope.body.active_pointer),'active pointer drift');
+  insist(pointer.version==='0.12.0','active pointer version mismatch');
+  insist(isCandidateIdentity(pointer,pointer.manifest_sha256),'release id/content address mismatch');
+  const releaseFiles=await verifyTree(pointer.release_root,'MANIFEST.SHA256',pointer.manifest_sha256);
+  const generationFiles=await verifyTree(pointer.generation_root,'GENERATION.SHA256',pointer.generation_manifest_sha256);
+  insist(sha256(await readFile(path.join(stateRoot,'bin','DEADBYTE-MCP.ps1')))===pointer.launcher_sha256,'launcher hash mismatch');
+
+  const predecessor=envelope.body.predecessor;
+  insist(isR40PredecessorIdentity(predecessor),'closure predecessor is not exact sealed R40 predecessor');
+  const immutable=envelope.body.immutable_slot;
+  insist(immutable?.protected===true,'closure immutable-slot protection missing');
+  insist(samePath(immutable.release_root,pointer.release_root),'closure immutable release_root mismatch');
+  insist(!samePath(immutable.development_root,immutable.release_root),'closure development_root aliases immutable release_root');
+
+  const surfaces=envelope.body.surfaces;
+  insist(surfaces?.local_full?.status==='passed'&&surfaces.local_full.tool_count===R40_FULL_TOOL_COUNT&&surfaces.local_full.strict_output_schemas===true,'closure local full 80-tool proof invalid');
+  insist(HEX64.test(surfaces.local_full.catalog_sha256??''),'closure local full catalog hash missing');
+  insist(surfaces?.public_compact?.status==='passed'&&surfaces.public_compact.tool_count===R40_COMPACT_TOOL_COUNT&&surfaces.public_compact.capability_closure===true,'closure public compact capability proof invalid');
+  insist(surfaces.public_compact.coding_armed===false&&surfaces.public_compact.autonomous_armed===false&&surfaces.public_compact.desktop_armed===false,'closure compact authority is not DISARMED');
+  insist(surfaces.public_compact.desktop_observation_receipt_verified===true&&surfaces.public_compact.desktop_grounding_receipt_verified===true,'closure Desktop read-only proof invalid');
+  insist(HEX64.test(surfaces.public_compact.catalog_sha256??'')&&HEX64.test(surfaces.public_compact.ledger_sha256??''),'closure compact catalog/ledger hash missing');
+
+  const evidence=envelope.body.evidence;
+  insist(evidence&&evidence.parity&&evidence.activation&&evidence.rollback&&evidence.restore&&evidence.windows_gate,'closure evidence set incomplete');
+  for(const [name,item] of Object.entries(evidence)){
+    insist(item?.path&&HEX64.test(item.sha256??''),`${name} evidence identity malformed`);
+    insist(sha256(await readFile(item.path))===item.sha256,`${name} evidence hash mismatch`);
+  }
+
+  const parity=JSON.parse(await readFile(evidence.parity.path,'utf8'));
+  insist(parity.schema==='deadbyte.r40-parity.v1'&&parity.status==='passed','R40 parity evidence invalid');
+  insist(parity.rdc_operation_count===0&&parity.execution_provider==='deadbyte_mcp','R40 parity execution provider mismatch');
+  insist(isCandidateIdentity(parity.candidate,pointer.manifest_sha256),'R40 parity candidate binding mismatch');
+  insist(isCandidateIdentity(parity.successor,pointer.manifest_sha256),'R40 parity successor binding mismatch');
+  insist(isR40PredecessorIdentity(parity.predecessor),'R40 parity predecessor binding mismatch');
+  insist(parity.local_full?.status==='passed'&&parity.local_full.tool_count===R40_FULL_TOOL_COUNT&&parity.local_full.strict_output_schemas===true,'R40 parity local full proof invalid');
+  insist(parity.local_full.catalog_sha256===surfaces.local_full.catalog_sha256,'R36 local full catalog drift between parity and closure');
+  insist(parity.public_compact?.status==='passed'&&parity.public_compact.tool_count===R40_COMPACT_TOOL_COUNT&&parity.public_compact.capability_closure===true&&parity.public_compact.gateway_count===6&&parity.public_compact.desktop_armed===false&&parity.public_compact.desktop_observation_receipt_verified===true&&parity.public_compact.desktop_grounding_receipt_verified===true,'R40 parity public compact/Desktop proof invalid');
+  insist(parity.desktop_guarded?.status==='passed'&&parity.desktop_guarded.native_injected===true&&parity.desktop_guarded.replay_performed===false&&parity.desktop_guarded.action_receipts_verified===3,'R40 parity guarded Desktop proof invalid');
+  insist(parity.successor_disarmed?.status==='passed'&&parity.successor_disarmed.tool_count===R40_COMPACT_TOOL_COUNT&&parity.successor_disarmed.capability_closure===true&&parity.successor_disarmed.coding_armed===false&&parity.successor_disarmed.autonomous_armed===false&&parity.successor_disarmed.desktop_armed===false,'R40 parity successor disarmed proof invalid');
+  insist(parity.successor_disarmed.catalog_sha256===surfaces.public_compact.catalog_sha256,'R36 compact catalog drift between restore and closure');
+  insist(parity.successor_disarmed.ledger_sha256===surfaces.public_compact.ledger_sha256,'R36 capability ledger drift between restore and closure');
+  insist(parity.immutable_slot?.protected===true,'R40 parity immutable-slot proof missing');
+  insist(samePath(parity.immutable_slot.release_root,pointer.release_root),'R40 parity immutable release_root mismatch');
+  insist(samePath(parity.immutable_slot.development_root,immutable.development_root),'R40 parity/closure development_root mismatch');
+  insist(!samePath(parity.immutable_slot.development_root,pointer.release_root),'R36 mutable development_root aliases immutable release slot');
+  for(const key of REQUIRED_PARITY_KEYS) insist(parity.requirements?.[key]===true,`R40 parity requirement missing ${key}`);
+
+  const activation=JSON.parse(await readFile(evidence.activation.path,'utf8'));
+  const rollback=JSON.parse(await readFile(evidence.rollback.path,'utf8'));
+  const restore=JSON.parse(await readFile(evidence.restore.path,'utf8'));
+  verifyUpdateEnvelope(activation,keyInfo);verifyUpdateEnvelope(rollback,keyInfo);verifyUpdateEnvelope(restore,keyInfo);
+  insist(activation.body.schema==='deadbyte.r27-slot-update-receipt.v1'&&activation.body.rollback_performed===false,'R40 activation receipt invalid');
+  insist(activation.body.release_version==='0.12.0'&&activation.body.candidate_manifest_sha256===pointer.manifest_sha256,'R40 activation candidate identity invalid');
+  insist(isCandidateIdentity(activation.body.active_pointer,pointer.manifest_sha256),'R40 activation active pointer invalid');
+  insist(isR40PredecessorIdentity(activation.body.prior_pointer),'R40 activation predecessor is not exact 0.11.3 predecessor');
+  insist(samePath(activation.body.development_root,immutable.development_root),'R40 activation development_root mismatch');
+  insist(!samePath(activation.body.development_root,activation.body.active_pointer.release_root),'R40 activation development_root aliases release slot');
+  insist(activation.body.authority?.final?.desktop_armed===false,'R40 activation restored Desktop authority unexpectedly');
+
+  insist(rollback.body.schema==='deadbyte.r31-slot-rollback-receipt.v1'&&rollback.body.rollback_performed===true,'R40 rollback receipt invalid');
+  insist(isCandidateIdentity(rollback.body.from_pointer,pointer.manifest_sha256),'R40 rollback source is not exact candidate');
+  insist(isR40PredecessorIdentity(rollback.body.active_pointer),'R40 rollback target is not exact 0.11.3 predecessor');
+  insist(rollback.body.activation_receipt_sha256===activation.receipt_sha256,'R40 rollback not bound to activation receipt');
+
+  insist(restore.body.schema==='deadbyte.r27-slot-update-receipt.v1'&&restore.body.rollback_performed===false,'R40 restore receipt invalid');
+  insist(restore.body.release_version==='0.12.0'&&restore.body.candidate_manifest_sha256===pointer.manifest_sha256,'R40 restore candidate identity invalid');
+  insist(isR40PredecessorIdentity(restore.body.prior_pointer),'R40 restore predecessor is not exact 0.11.3 predecessor');
+  insist(isCandidateIdentity(restore.body.active_pointer,pointer.manifest_sha256)&&same(restore.body.active_pointer,pointer),'R40 restore/current pointer mismatch');
+  insist(samePath(restore.body.development_root,immutable.development_root),'R40 restore development_root mismatch');
+  insist(!samePath(restore.body.development_root,restore.body.active_pointer.release_root),'R40 restore development_root aliases release slot');
+  insist(restore.body.authority?.final?.desktop_armed===false,'R40 restore restored Desktop authority unexpectedly');
+
+  const windowsGate=JSON.parse(await readFile(evidence.windows_gate.path,'utf8'));
+  insist(windowsGate.schema==='deadbyte.r40-windows-gate.v1'&&windowsGate.status==='passed'&&windowsGate.exit_code===0,'R40 Windows gate evidence invalid');
+  insist(windowsGate.version==='0.12.0'&&windowsGate.manifest_sha256===pointer.manifest_sha256,'R40 Windows gate manifest/version binding mismatch');
+  insist(windowsGate.marker==='DEADBYTE V0.12.0 / R40 WINDOWS BATCH GATE: PASS','R40 Windows gate PASS marker mismatch');
+
+  const machine=envelope.body.machine;
+  insist(machine?.status?.release_id===pointer.release_id&&machine.status.release_manifest_sha256===pointer.manifest_sha256&&machine.status.generation_manifest_sha256===pointer.generation_manifest_sha256,'machine status binding mismatch');
+  verifyPing(machine.ping,machine.status,pointer);
+  insist(machine.ping.nonce===machine.nonce,'machine ping nonce binding mismatch');
+
+  const grantNames=['process-grant.json','coding-grant.json','autonomous-grant.json','desktop-grant.json','host-grant.json'];
+  insist(envelope.body.authority?.all_disarmed===true,'closure authority not disarmed');
+  for(const name of grantNames){
+    let exists=true;try{await lstat(path.join(stateRoot,'runtime',name));}catch(error){if(error?.code==='ENOENT') exists=false;else throw error;}
+    insist(!exists,`authority grant still present: ${name}`);
+    insist(envelope.body.authority.grants_absent?.[name]===true,`closure grant absence not recorded: ${name}`);
+  }
+  return {ok:true,status:'passed',release_id:pointer.release_id,manifest_sha256:pointer.manifest_sha256,
+    generation_manifest_sha256:pointer.generation_manifest_sha256,release_files:releaseFiles,generation_files:generationFiles,
+    machine_id:machine.status.machine_id,parity_sha256:evidence.parity.sha256,closure_sha256:envelope.closure_sha256,
+    full_tool_count:R40_FULL_TOOL_COUNT,compact_tool_count:surfaces.public_compact.tool_count};
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const file=process.argv[2];
+  if(!file) throw new Error('usage: node scripts/final-closure-verify-r40.mjs <closure.json>');
+  try{
+    const envelope=JSON.parse(await readFile(path.resolve(file),'utf8'));
+    console.log(JSON.stringify(await verifyFinalClosureObject(envelope),null,2));
+  }catch(error){console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;}
+}

package/scripts/gate-windows-r39.ps1

@@ -0,0 +1,42 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+
+function Invoke-GateStep {
+    param(
+        [Parameter(Mandatory = $true)][string]$Name,
+        [Parameter(Mandatory = $true)][string[]]$NpmArgs
+    )
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) {
+        throw "DEADBYTE V0.11.3 / R39 gate failed at $Name with exit code $LASTEXITCODE"
+    }
+}
+
+Invoke-GateStep -Name 'containment-build' -NpmArgs @('run', 'containment:build')
+Invoke-GateStep -Name 'process-policy-refresh' -NpmArgs @('run', 'process:policy:refresh')
+Invoke-GateStep -Name 'release-manifest-write' -NpmArgs @('run', 'manifest:write')
+Invoke-GateStep -Name 'release-manifest' -NpmArgs @('run', 'manifest:verify')
+Invoke-GateStep -Name 'tests' -NpmArgs @('test')
+Invoke-GateStep -Name 'mcp-smoke' -NpmArgs @('run', 'mcp:smoke')
+Invoke-GateStep -Name 'mcp-agent-smoke' -NpmArgs @('run', 'mcp:agent:smoke')
+Invoke-GateStep -Name 'mcp-coding-smoke' -NpmArgs @('run', 'mcp:coding:smoke')
+Invoke-GateStep -Name 'mcp-machine-fs-smoke' -NpmArgs @('run', 'mcp:machine-fs:smoke')
+Invoke-GateStep -Name 'mcp-observation-smoke' -NpmArgs @('run', 'mcp:observation:smoke')
+Invoke-GateStep -Name 'mcp-process-smoke' -NpmArgs @('run', 'mcp:process:smoke')
+Invoke-GateStep -Name 'mcp-autonomous-smoke' -NpmArgs @('run', 'mcp:autonomous:smoke')
+Invoke-GateStep -Name 'tunnel-stdio-compat-smoke' -NpmArgs @('run', 'mcp:tunnel-compat:smoke')
+Invoke-GateStep -Name 'mcp-host-smoke' -NpmArgs @('run', 'mcp:host:smoke')
+Invoke-GateStep -Name 'authority-smoke' -NpmArgs @('run', 'authority:smoke')
+Invoke-GateStep -Name 'containment-smoke' -NpmArgs @('run', 'containment:smoke')
+Invoke-GateStep -Name 'contained-smoke' -NpmArgs @('run', 'contained:smoke')
+Invoke-GateStep -Name 'mcp-contained-smoke' -NpmArgs @('run', 'mcp:contained:smoke')
+Invoke-GateStep -Name 'release-manifest-final' -NpmArgs @('run', 'manifest:verify')
+
+Write-Host '==== windows-gate-evidence ===='
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r39.mjs')
+if ($LASTEXITCODE -ne 0) {
+    throw "DEADBYTE V0.11.3 / R39 gate failed at windows-gate-evidence with exit code $LASTEXITCODE"
+}
+
+Write-Host '==== DEADBYTE V0.11.3 / R39 WINDOWS BATCH GATE: PASS ===='

package/scripts/gate-windows-r40.ps1

@@ -0,0 +1,43 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+
+function Invoke-GateStep {
+    param(
+        [Parameter(Mandatory = $true)][string]$Name,
+        [Parameter(Mandatory = $true)][string[]]$NpmArgs
+    )
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) {
+        throw "DEADBYTE V0.12.0 / R40 gate failed at $Name with exit code $LASTEXITCODE"
+    }
+}
+
+Invoke-GateStep -Name 'containment-build' -NpmArgs @('run', 'containment:build')
+Invoke-GateStep -Name 'process-policy-refresh' -NpmArgs @('run', 'process:policy:refresh')
+Invoke-GateStep -Name 'desktop-policy-refresh' -NpmArgs @('run', 'desktop:policy:refresh')
+Invoke-GateStep -Name 'release-manifest-write' -NpmArgs @('run', 'manifest:write')
+Invoke-GateStep -Name 'release-manifest' -NpmArgs @('run', 'manifest:verify')
+Invoke-GateStep -Name 'tests' -NpmArgs @('test')
+Invoke-GateStep -Name 'mcp-smoke' -NpmArgs @('run', 'mcp:smoke')
+Invoke-GateStep -Name 'mcp-agent-smoke' -NpmArgs @('run', 'mcp:agent:smoke')
+Invoke-GateStep -Name 'mcp-coding-smoke' -NpmArgs @('run', 'mcp:coding:smoke')
+Invoke-GateStep -Name 'mcp-machine-fs-smoke' -NpmArgs @('run', 'mcp:machine-fs:smoke')
+Invoke-GateStep -Name 'mcp-observation-smoke' -NpmArgs @('run', 'mcp:observation:smoke')
+Invoke-GateStep -Name 'mcp-process-smoke' -NpmArgs @('run', 'mcp:process:smoke')
+Invoke-GateStep -Name 'mcp-autonomous-smoke' -NpmArgs @('run', 'mcp:autonomous:smoke')
+Invoke-GateStep -Name 'tunnel-stdio-compat-smoke' -NpmArgs @('run', 'mcp:tunnel-compat:smoke')
+Invoke-GateStep -Name 'mcp-host-smoke' -NpmArgs @('run', 'mcp:host:smoke')
+Invoke-GateStep -Name 'authority-smoke' -NpmArgs @('run', 'authority:smoke')
+Invoke-GateStep -Name 'containment-smoke' -NpmArgs @('run', 'containment:smoke')
+Invoke-GateStep -Name 'contained-smoke' -NpmArgs @('run', 'contained:smoke')
+Invoke-GateStep -Name 'mcp-contained-smoke' -NpmArgs @('run', 'mcp:contained:smoke')
+Invoke-GateStep -Name 'release-manifest-final' -NpmArgs @('run', 'manifest:verify')
+
+Write-Host '==== windows-gate-evidence ===='
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r40.mjs')
+if ($LASTEXITCODE -ne 0) {
+    throw "DEADBYTE V0.12.0 / R40 gate failed at windows-gate-evidence with exit code $LASTEXITCODE"
+}
+
+Write-Host '==== DEADBYTE V0.12.0 / R40 WINDOWS BATCH GATE: PASS ===='

package/scripts/init-desktop-policy-r40.ps1

@@ -0,0 +1,79 @@
+[CmdletBinding()]
+param(
+    [string]$RuntimeRoot = '',
+    [string]$OutputPath = '',
+    [string[]]$AllowedActions = @('pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input')
+)
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+
+$Root=Split-Path -Parent $PSScriptRoot
+$Controller=Join-Path $Root 'controller'
+if([string]::IsNullOrWhiteSpace($RuntimeRoot)){ $RuntimeRoot=Join-Path $Controller 'runtime' }
+if([string]::IsNullOrWhiteSpace($OutputPath)){ $OutputPath=Join-Path $Controller 'deadbyte-desktop-policy.json' }
+$RuntimeRoot=[System.IO.Path]::GetFullPath($RuntimeRoot)
+$OutputPath=[System.IO.Path]::GetFullPath($OutputPath)
+$Observer=[System.IO.Path]::GetFullPath((Join-Path $Root 'bin\deadbyte-desktop-observer-r40.exe'))
+$Input=[System.IO.Path]::GetFullPath((Join-Path $Root 'bin\deadbyte-desktop-input-r40.exe'))
+$Grounder=[System.IO.Path]::GetFullPath((Join-Path $Root 'bin\deadbyte-desktop-uia-r40.exe'))
+if(-not (Test-Path -LiteralPath $Observer -PathType Leaf)){throw "observer binary missing: $Observer"}
+if(-not (Test-Path -LiteralPath $Input -PathType Leaf)){throw "input binary missing: $Input"}
+if(-not (Test-Path -LiteralPath $Grounder -PathType Leaf)){throw "UIA grounder binary missing: $Grounder"}
+$Known=@('pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input')
+if($AllowedActions.Count -lt 1){throw 'AllowedActions cannot be empty'}
+$Unique=@($AllowedActions | Sort-Object -Unique)
+if($Unique.Count -ne $AllowedActions.Count -or @($AllowedActions | Where-Object { $_ -notin $Known }).Count -gt 0){throw 'AllowedActions invalid'}
+New-Item -ItemType Directory -Force -Path $RuntimeRoot | Out-Null
+$Evidence=Join-Path $RuntimeRoot 'desktop-evidence'
+New-Item -ItemType Directory -Force -Path $Evidence | Out-Null
+$Grant=Join-Path $RuntimeRoot 'desktop-grant.json'
+Remove-Item -LiteralPath $Grant -Force -ErrorAction SilentlyContinue
+$Policy=[ordered]@{
+    schema='deadbyte.desktop-policy.v1'
+    enabled=$true
+    grant_file=$Grant
+    evidence_dir=$Evidence
+    observer=[ordered]@{
+        executable=$Observer
+        sha256=(Get-FileHash -LiteralPath $Observer -Algorithm SHA256).Hash.ToLowerInvariant()
+        backend='gdi-bitblt-fallback'
+    }
+    input=[ordered]@{
+        executable=$Input
+        sha256=(Get-FileHash -LiteralPath $Input -Algorithm SHA256).Hash.ToLowerInvariant()
+    }
+    grounder=[ordered]@{
+        executable=$Grounder
+        sha256=(Get-FileHash -LiteralPath $Grounder -Algorithm SHA256).Hash.ToLowerInvariant()
+    }
+    allowed_input_desktops=@('Default')
+    allowed_actions=@($AllowedActions)
+    limits=[ordered]@{
+        max_frame_age_ms=2000
+        max_frame_bytes=134217728
+        capture_timeout_ms=10000
+        input_timeout_ms=5000
+        ground_timeout_ms=5000
+        post_observe_timeout_ms=10000
+        max_preview_bytes=1048576
+        max_text_bytes=4096
+    }
+}
+$Parent=Split-Path -Parent $OutputPath
+New-Item -ItemType Directory -Force -Path $Parent | Out-Null
+$Json=$Policy | ConvertTo-Json -Depth 8
+$Utf8=New-Object System.Text.UTF8Encoding($false)
+$Tmp=$OutputPath+'.tmp'
+[System.IO.File]::WriteAllText($Tmp,$Json,$Utf8)
+Move-Item -LiteralPath $Tmp -Destination $OutputPath -Force
+[pscustomobject]@{
+    status='created'
+    policy_path=$OutputPath
+    policy_sha256=(Get-FileHash -LiteralPath $OutputPath -Algorithm SHA256).Hash.ToLowerInvariant()
+    observer_sha256=$Policy.observer.sha256
+    input_sha256=$Policy.input.sha256
+    grounder_sha256=$Policy.grounder.sha256
+    grant_file=$Grant
+    grant_state='DISARMED'
+    action_kinds=@($AllowedActions)
+}|ConvertTo-Json -Depth 6

package/scripts/r40-compact-ledger-probe.mjs

@@ -0,0 +1,4 @@
+import { R36_CAPABILITY_LEDGER } from '../src/capability-ledger.mjs';
+const names=new Set(['capability_manifest']);
+for(const item of R36_CAPABILITY_LEDGER.entries) if(item.compact_tool) names.add(item.compact_tool);
+console.log(JSON.stringify({count:names.size,names:[...names].sort(),ledger_sha256:R36_CAPABILITY_LEDGER.ledger_sha256},null,2));