deadbyte-mcp 0.14.0 → 0.15.1

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

@@ -0,0 +1,220 @@
+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-R45-FINAL-CLOSURE-V1\0','utf8');
+const PING_DOMAIN=Buffer.from('DEADBYTE-MACHINE-PING-V1\0','utf8');
+const R45_PREDECESSOR_RELEASE_ID='v0.15.0-c15fa41719be61b3';
+const R45_PREDECESSOR_MANIFEST='c15fa41719be61b3186e49b2367a5f4c057365cfb465102dbefb7d7355f45483';
+const R45_FULL_TOOL_COUNT=82;
+const R45_COMPACT_TOOL_COUNT=43;
+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','deterministic_memory','skill_integrity','agent_backend_persistence','codex_protocol_contract','remote_device_identity','durable_job_supervisor','real_external_supervisor_smoke'];
+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.15.1'&&value?.manifest_sha256===manifest&&value?.release_id===`v0.15.1-${manifest.slice(0,16)}`;
+}
+function isR44PredecessorIdentity(value){
+  return value?.version==='0.15.0'&&value?.manifest_sha256===R45_PREDECESSOR_MANIFEST&&value?.release_id===R45_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.r45-final-closure.v1','closure schema mismatch');
+  insist(envelope.body.version==='0.15.1','closure version mismatch');
+  insist(envelope.body.release_label==='R45 MACHINE FREEDOM FINAL 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-R45-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.15.1','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(isR44PredecessorIdentity(predecessor),'closure predecessor is not exact sealed R44 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===R45_FULL_TOOL_COUNT&&surfaces.local_full.strict_output_schemas===true,'closure local full 82-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===R45_COMPACT_TOOL_COUNT&&surfaces.public_compact.capability_closure===true&&surfaces.public_compact.skill_catalog_verified===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.r45-parity.v1'&&parity.status==='passed','R45 parity evidence invalid');
+  insist(parity.rdc_operation_count===0&&parity.execution_provider==='deadbyte_mcp','R45 parity execution provider mismatch');
+  insist(isCandidateIdentity(parity.candidate,pointer.manifest_sha256),'R45 parity candidate binding mismatch');
+  insist(isCandidateIdentity(parity.successor,pointer.manifest_sha256),'R45 parity successor binding mismatch');
+  insist(isR44PredecessorIdentity(parity.predecessor),'R45 parity predecessor binding mismatch');
+  insist(parity.local_full?.status==='passed'&&parity.local_full.tool_count===R45_FULL_TOOL_COUNT&&parity.local_full.strict_output_schemas===true,'R45 parity local full proof invalid');
+  insist(parity.local_full.catalog_sha256===surfaces.local_full.catalog_sha256,'R45 local full catalog drift between parity and closure');
+  insist(parity.public_compact?.status==='passed'&&parity.public_compact.tool_count===R45_COMPACT_TOOL_COUNT&&parity.public_compact.capability_closure===true&&parity.public_compact.skill_catalog_verified===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,'R45 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,'R45 parity guarded Desktop proof invalid');
+  insist(parity.deterministic_memory?.status==='passed'&&parity.deterministic_memory.goal_count>=1&&parity.deterministic_memory.snapshot_count>=1&&parity.deterministic_memory.index_count>=1,'R41 deterministic memory proof invalid');
+  insist(same(surfaces.deterministic_memory,parity.deterministic_memory),'R41 closure deterministic memory binding mismatch');
+  insist(parity.successor_disarmed?.status==='passed'&&parity.successor_disarmed.tool_count===R45_COMPACT_TOOL_COUNT&&parity.successor_disarmed.capability_closure===true&&parity.successor_disarmed.skill_catalog_verified===true&&parity.successor_disarmed.coding_armed===false&&parity.successor_disarmed.autonomous_armed===false&&parity.successor_disarmed.desktop_armed===false,'R45 parity successor disarmed proof invalid');
+  insist(parity.successor_disarmed.catalog_sha256===surfaces.public_compact.catalog_sha256,'R45 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,'R45 parity immutable-slot proof missing');
+  insist(samePath(parity.immutable_slot.release_root,pointer.release_root),'R45 parity immutable release_root mismatch');
+  insist(samePath(parity.immutable_slot.development_root,immutable.development_root),'R45 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,`R45 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,'R45 activation receipt invalid');
+  insist(activation.body.release_version==='0.15.1'&&activation.body.candidate_manifest_sha256===pointer.manifest_sha256,'R45 activation candidate identity invalid');
+  insist(isCandidateIdentity(activation.body.active_pointer,pointer.manifest_sha256),'R45 activation active pointer invalid');
+  insist(isR44PredecessorIdentity(activation.body.prior_pointer),'R45 activation predecessor is not exact R44 predecessor');
+  insist(samePath(activation.body.development_root,immutable.development_root),'R45 activation development_root mismatch');
+  insist(!samePath(activation.body.development_root,activation.body.active_pointer.release_root),'R45 activation development_root aliases release slot');
+  insist(activation.body.authority?.final?.desktop_armed===false,'R45 activation restored Desktop authority unexpectedly');
+
+  insist(rollback.body.schema==='deadbyte.r31-slot-rollback-receipt.v1'&&rollback.body.rollback_performed===true,'R45 rollback receipt invalid');
+  insist(isCandidateIdentity(rollback.body.from_pointer,pointer.manifest_sha256),'R45 rollback source is not exact candidate');
+  insist(isR44PredecessorIdentity(rollback.body.active_pointer),'R45 rollback target is not exact R44 predecessor');
+  insist(rollback.body.activation_receipt_sha256===activation.receipt_sha256,'R45 rollback not bound to activation receipt');
+
+  insist(restore.body.schema==='deadbyte.r27-slot-update-receipt.v1'&&restore.body.rollback_performed===false,'R45 restore receipt invalid');
+  insist(restore.body.release_version==='0.15.1'&&restore.body.candidate_manifest_sha256===pointer.manifest_sha256,'R45 restore candidate identity invalid');
+  insist(isR44PredecessorIdentity(restore.body.prior_pointer),'R45 restore predecessor is not exact R44 predecessor');
+  insist(isCandidateIdentity(restore.body.active_pointer,pointer.manifest_sha256)&&same(restore.body.active_pointer,pointer),'R45 restore/current pointer mismatch');
+  insist(samePath(restore.body.development_root,immutable.development_root),'R45 restore development_root mismatch');
+  insist(!samePath(restore.body.development_root,restore.body.active_pointer.release_root),'R45 restore development_root aliases release slot');
+  insist(restore.body.authority?.final?.desktop_armed===false,'R45 restore restored Desktop authority unexpectedly');
+
+  const windowsGate=JSON.parse(await readFile(evidence.windows_gate.path,'utf8'));
+  insist(windowsGate.schema==='deadbyte.r45-windows-gate.v1'&&windowsGate.status==='passed'&&windowsGate.exit_code===0,'R45 Windows gate evidence invalid');
+  insist(windowsGate.version==='0.15.1'&&windowsGate.manifest_sha256===pointer.manifest_sha256,'R45 Windows gate manifest/version binding mismatch');
+  insist(windowsGate.marker==='DEADBYTE V0.15.1 / R45 MACHINE FREEDOM WINDOWS BATCH GATE: PASS','R45 Windows gate PASS marker mismatch');
+
+  const featureContract=surfaces.feature_contract;
+  insist(featureContract?.schema==='deadbyte.r45-windows-gate.v1'&&featureContract.manifest_sha256===pointer.manifest_sha256,'closure feature contract invalid');
+  insist(parity.feature_gate_sha256===evidence.windows_gate.sha256,'parity feature gate hash mismatch');
+  for(const key of ['skill_integrity','agent_backend_persistence','codex_protocol_contract','remote_device_identity','durable_job_supervisor','real_external_supervisor_smoke','full_regression_required','host_inline_native','native_hardware_observation','doctor_release_truth']) {
+    insist(windowsGate.features?.[key]===true&&featureContract.features?.[key]===true,`R45 feature proof missing ${key}`);
+  }
+
+  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:R45_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-r45.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/finalize-r43.mjs

@@ -0,0 +1,217 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { spawn, spawnSync } from 'node:child_process';
+import { lstat, mkdir, readFile, realpath, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseActivePointer } from '../src/release-slot.mjs';
+import { loadPowerShellDataFile, parseControllerStatus, runSlotUpdateCli } from '../src/runtime-update.mjs';
+import { verifyR43Parent } from './verify-r43-parent.mjs';
+import { runReleaseParity } from './release-parity-r43.mjs';
+import { writeFinalClosure } from './final-closure-r43.mjs';
+import { verifyFinalClosureObject } from './final-closure-verify-r43.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const EXPECTED_VERSION='0.14.1';
+const PARENT_RELEASE_ID='v0.14.0-08cd8f3b98c90e0e';
+const PARENT_MANIFEST='08cd8f3b98c90e0e250cf506ff396515065ff5457909f850b75b0b6e8ecc2dd1';
+const PARENT_ACTIVATION_RECEIPT='074140ad8b94501e0a095a7fa132dc5d6e2c57102c9eeaaa2ac9e4ea93b9b187';
+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 evidenceRoot=path.join(stateRoot,'evidence','release','r43-finalization');
+const launcher=path.join(stateRoot,'bin','DEADBYTE-MCP.ps1');
+const ps=path.join(process.env.SystemRoot||'C:\\Windows','System32','WindowsPowerShell','v1.0','powershell.exe');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+
+async function atomicJson(file,value){
+  await mkdir(path.dirname(file),{recursive:true});
+  const bytes=Buffer.from(`${JSON.stringify(value,null,2)}\n`,'utf8');
+  const temp=`${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  await writeFile(temp,bytes,{flag:'wx'});
+  await rename(temp,file);
+  return {path:file,sha256:sha256(bytes)};
+}
+async function activePointer(){
+  return parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+}
+async function bridgeArgs(){
+  const pointer=await activePointer();
+  const config=await loadPowerShellDataFile(pointer.config_path);
+  const raw=config?.Bridge?.WorkingDirectory;
+  insist(typeof raw==='string'&&path.isAbsolute(raw),'active Bridge.WorkingDirectory must be absolute');
+  const root=await realpath(path.resolve(raw));
+  const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+  insist(pkg?.name==='deadbyte-chatgpt-bridge','active Bridge package identity mismatch');
+  const script=path.join(root,'src','bridge.mjs');
+  return ['--bridge-root',root,'--bridge-script-sha256',sha256(await readFile(script))];
+}
+async function activationArgs(manifestSha256){
+  insist(HEX64.test(manifestSha256??''),'R43 finalizer manifest must be lowercase SHA-256');
+  const processPolicy=path.join(packageRoot,'controller','deadbyte-process-policy.json');
+  const desktopPolicy=path.join(packageRoot,'controller','deadbyte-desktop-policy.json');
+  const semantic=path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json');
+  return [
+    '--stage',packageRoot,'--development-root',packageRoot,'--expected-version',EXPECTED_VERSION,
+    '--expected-manifest',manifestSha256,
+    '--process-policy',processPolicy,'--process-policy-sha256',sha256(await readFile(processPolicy)),
+    '--desktop-policy',desktopPolicy,'--desktop-policy-sha256',sha256(await readFile(desktopPolicy)),
+    '--semantic-lsp-config',semantic,'--semantic-lsp-config-sha256',sha256(await readFile(semantic)),
+    '--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor',
+    '--restore-standing-grants',
+    ...await bridgeArgs()
+  ];
+}
+export function validateFinalizerAuthorityStatus(status){
+  insist(status?.process_armed===true,'R43 finalizer requires Process standing grant');
+  insist(status?.coding_armed===true,'R43 finalizer requires Coding standing grant');
+  insist(status?.autonomous_armed===true,'R43 finalizer requires Autonomous standing grant');
+  insist(status?.desktop_armed===false,'R43 finalizer requires Desktop DISARMED');
+  insist(status?.host_armed===false,'R43 finalizer requires Host DISARMED');
+  return true;
+}
+function currentAuthorityStatus(){
+  const result=spawnSync(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,'status'],
+    {encoding:'utf8',windowsHide:true,timeout:20000});
+  if(result.error) throw result.error;
+  if(result.status!==0) throw new Error(`R43 finalizer controller status failed: ${result.stderr||result.stdout}`);
+  return parseControllerStatus(result.stdout??'');
+}
+export function validateWindowsGateEvidence(value,manifestSha256,parent){
+  insist(value?.schema==='deadbyte.r43-windows-gate.v1'&&value.status==='passed'&&value.exit_code===0,'R43 Windows gate evidence invalid');
+  insist(value.version===EXPECTED_VERSION&&value.manifest_sha256===manifestSha256,'R43 Windows gate candidate mismatch');
+  insist(value.marker==='DEADBYTE V0.14.1 / R43 AUTHORITY HARDENING WINDOWS BATCH GATE: PASS','R43 Windows gate marker mismatch');
+  insist(value.parent?.release_id===parent.parent_release_id&&value.parent?.manifest_sha256===parent.parent_manifest_sha256,'R43 Windows gate parent mismatch');
+  insist(value.parent?.generation_manifest_sha256===parent.parent_generation_manifest_sha256,'R43 Windows gate parent generation mismatch');
+  insist(value.parent?.activation_receipt_sha256===PARENT_ACTIVATION_RECEIPT,'R43 Windows gate parent activation mismatch');
+  insist(value.hardening?.authority_toctou===true&&value.hardening?.absolute_execution_deadline===true&&
+    value.hardening?.pre_spawn_authority_recheck===true&&value.hardening?.full_regression_required===true&&
+    value.hardening?.model_path_changed===false,'R43 Windows gate hardening contract mismatch');
+  return true;
+}
+function disarmFailClosed(){
+  const results=[];
+  for(const command of ['disarmdesktop','disarmautonomous','disarmcoding','disarmprocess','disarmhost']){
+    const result=spawnSync(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,command],
+      {encoding:'utf8',windowsHide:true,timeout:20000});
+    results.push({command,status:result.status,signal:result.signal??null});
+  }
+  return results;
+}
+async function mirrorRoot(){
+  const pointer=await activePointer();
+  const policy=JSON.parse(await readFile(path.join(pointer.generation_root,'coding-policy.json'),'utf8'));
+  const raw=policy?.roots?.parity_scratch?.path??policy?.roots?.parity_scratch?.real_path;
+  if(typeof raw!=='string'||!path.isAbsolute(raw)) throw new Error('active generation parity_scratch root unavailable');
+  const stat=await lstat(raw);
+  if(!stat.isDirectory()||stat.isSymbolicLink()) throw new Error('parity_scratch root must be a real directory');
+  return raw;
+}
+async function writeMirror(manifestSha256,value){
+  const root=await mirrorRoot();
+  const file=path.join(root,`r43-final-${manifestSha256.slice(0,16)}.json`);
+  return atomicJson(file,value);
+}
+async function verifyInputs(manifestSha256){
+  insist(HEX64.test(manifestSha256??''),'R43 finalizer manifest invalid');
+  const manifestBytes=await readFile(path.join(packageRoot,'MANIFEST.SHA256'));
+  insist(sha256(manifestBytes)===manifestSha256,'R43 finalizer manifest drift');
+  const pkg=JSON.parse(await readFile(path.join(packageRoot,'package.json'),'utf8'));
+  insist(pkg?.name==='deadbyte-mcp'&&pkg?.version===EXPECTED_VERSION,'R43 finalizer package identity mismatch');
+  const parent=await verifyR43Parent(path.join(packageRoot,'R43-PARENT.json'));
+  const authorityStatus=currentAuthorityStatus();
+  validateFinalizerAuthorityStatus(authorityStatus);
+  const before=await activePointer();
+  insist(before.release_id===PARENT_RELEASE_ID&&before.manifest_sha256===PARENT_MANIFEST,'R43 finalizer must start from exact sealed R42 parent');
+  const windowsGatePath=path.join(stateRoot,'evidence','release',`r43-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  const windowsGateBytes=await readFile(windowsGatePath);
+  const windowsGate=JSON.parse(windowsGateBytes.toString('utf8').replace(/^\uFEFF/,''));
+  validateWindowsGateEvidence(windowsGate,manifestSha256,parent);
+  return {parent,before,authorityStatus,windowsGatePath,windowsGateFileSha256:sha256(windowsGateBytes)};
+}
+async function runWorker(manifestSha256,operationId){
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  let activation=null;
+  let parity=null;
+  try{
+    await atomicJson(statePath,{schema:'deadbyte.r43-finalization-state.v1',operation_id:operationId,status:'running',
+      manifest_sha256:manifestSha256,started_at_utc:new Date().toISOString()});
+    const inputs=await verifyInputs(manifestSha256);
+    activation=await runSlotUpdateCli(await activationArgs(manifestSha256),{stateRoot});
+    insist(activation?.pointer?.version===EXPECTED_VERSION&&activation.pointer.manifest_sha256===manifestSha256,'R43 activation result mismatch');
+    insist(activation?.final_authority?.process_armed===true&&activation?.final_authority?.coding_armed===true&&activation?.final_authority?.autonomous_armed===true,
+      'R43 activation must restore prior Process+Coding+Autonomous standing grants for detached parity');
+    insist(activation?.final_authority?.desktop_armed===false&&activation?.final_authority?.host_armed===false,
+      'R43 activation must keep Desktop+Host disarmed');
+
+    parity=await runReleaseParity(activation.receipt_path);
+    insist(parity?.evidence?.status==='passed'&&parity.evidence?.candidate?.manifest_sha256===manifestSha256,'R43 parity result mismatch');
+
+    const closure=await writeFinalClosure({parityPath:parity.evidence_path,activationPath:activation.receipt_path,
+      windowsGatePath:inputs.windowsGatePath});
+    const envelope=JSON.parse(await readFile(closure.path,'utf8'));
+    const verified=await verifyFinalClosureObject(envelope,{stateRoot});
+    insist(verified?.ok===true&&verified.status==='passed'&&verified.manifest_sha256===manifestSha256,'R43 independent final closure verification failed');
+
+    const pointer=await activePointer();
+    const result={schema:'deadbyte.r43-finalization-result.v1',status:'passed',verified:true,
+      completed_at_utc:new Date().toISOString(),release_id:pointer.release_id,version:pointer.version,
+      manifest_sha256:pointer.manifest_sha256,generation_manifest_sha256:pointer.generation_manifest_sha256,
+      activation_receipt_sha256:activation.receipt_sha256,
+      parity_sha256:parity.evidence_sha256,windows_gate_sha256:inputs.windowsGateFileSha256,
+      closure_file_sha256:closure.sha256,closure_sha256:closure.closure_sha256,
+      full_tool_count:verified.full_tool_count,compact_tool_count:verified.compact_tool_count,
+      parent_release_id:inputs.parent.parent_release_id,parent_manifest_sha256:inputs.parent.parent_manifest_sha256};
+    const mirror=await writeMirror(manifestSha256,result);
+    await atomicJson(statePath,{...result,operation_id:operationId,mirror_path:mirror.path,mirror_sha256:mirror.sha256,
+      activation_receipt_path:activation.receipt_path,parity_path:parity.evidence_path,closure_path:closure.path});
+    return result;
+  }catch(error){
+    let rollback=null;
+    try{
+      if(activation?.receipt_path){
+        const pointer=await activePointer().catch(()=>null);
+        if(pointer?.version===EXPECTED_VERSION&&pointer?.manifest_sha256===manifestSha256){
+          rollback=await runSlotUpdateCli(['--rollback-receipt',activation.receipt_path],{stateRoot});
+        }
+      }
+    }catch(rollbackError){rollback={error:String(rollbackError?.message??rollbackError)};}
+    const disarm=disarmFailClosed();
+    const failed={schema:'deadbyte.r43-finalization-result.v1',status:'failed',verified:false,
+      completed_at_utc:new Date().toISOString(),manifest_sha256:manifestSha256,
+      error:String(error?.message??error),rollback:rollback?{ok:rollback?.ok===true,error:rollback?.error??null}:null,disarm};
+    await atomicJson(statePath,{...failed,operation_id:operationId}).catch(()=>{});
+    await writeMirror(manifestSha256,failed).catch(()=>{});
+    throw error;
+  }
+}
+export async function scheduleFinalization(manifestSha256){
+  insist(HEX64.test(manifestSha256??''),'R43 finalizer manifest invalid');
+  const operationId=`r43-${manifestSha256.slice(0,16)}-${randomBytes(8).toString('hex')}`;
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  await atomicJson(statePath,{schema:'deadbyte.r43-finalization-state.v1',operation_id:operationId,status:'scheduled',
+    manifest_sha256:manifestSha256,scheduled_at_utc:new Date().toISOString()});
+  const child=spawn(process.execPath,[fileURLToPath(import.meta.url),manifestSha256,'--worker',operationId],{
+    cwd:packageRoot,detached:true,stdio:'ignore',windowsHide:true,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+  });
+  child.unref();
+  return {status:'scheduled',operation_id:operationId,state_path:statePath,manifest_sha256:manifestSha256,
+    execution_provider:'deadbyte_mcp',rdc_operation_count:0};
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const [manifestSha256,flag,operationId]=process.argv.slice(2);
+  try{
+    if(flag==='--worker'){
+      insist(/^r43-[0-9a-f]{16}-[0-9a-f]{16}$/.test(operationId??''),'R43 finalizer worker operation id invalid');
+      await sleep(4000);
+      await runWorker(manifestSha256,operationId);
+    }else{
+      insist(flag===undefined&&operationId===undefined,'usage: node scripts/finalize-r43.mjs <manifest_sha256>');
+      console.log(JSON.stringify(await scheduleFinalization(manifestSha256)));
+    }
+  }catch(error){console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;}
+}