deadbyte-mcp 0.15.43 → 0.15.44

package/scripts/r67-full-regression.mjs

@@ -0,0 +1,28 @@
+import {readdir,mkdir,open,rename,lstat} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const operationId=process.argv[2];
+if(!/^[a-z0-9][a-z0-9._-]{4,63}$/.test(operationId??''))throw new Error('unique operation ID required');
+const evidence=path.resolve(root,'..','..','testing','0.15.44-r67','regression');
+await mkdir(evidence,{recursive:true});
+const finalFile=path.join(evidence,operationId+'.json');
+try{await lstat(finalFile);throw new Error('operation already completed; reconcile receipt, never rerun');}
+catch(e){if(e.code!=='ENOENT')throw e;}
+const names=(await readdir(path.join(root,'test'))).filter(s=>s.endsWith('.test.mjs')).sort();
+const args=['--test','--test-concurrency=4',...names.map(n=>'test/'+n)];
+const started=Date.now();
+const r=spawnSync(process.execPath,args,{cwd:root,shell:false,windowsHide:true,encoding:'utf8',maxBuffer:32*1024*1024,timeout:220000});
+const out=String(r.stdout??''),err=String(r.stderr??'');
+const parse=k=>{const m=[...out.matchAll(new RegExp('(?:^|\n)[#ℹ ]*'+k+'\\s+(\\d+(?:\\.\\d+)?)','g'))];return m.length?Number(m[m.length-1][1]):null};
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const body={schema:'deadbyte.r67-full-source-regression.v1',status:r.status===0&&!r.error?'passed':'failed',tests_files:names.length,test_count:parse('tests'),passed:parse('pass'),failed:parse('fail'),skipped:parse('skipped'),exit_code:r.status,timed_out:r.error?.code==='ETIMEDOUT',elapsed_ms:Date.now()-started,stdout_sha256:sha(Buffer.from(out)),stderr_sha256:sha(Buffer.from(err))};
+const receipt={...body,operation_id:operationId,started_at_utc:new Date(started).toISOString(),finished_at_utc:new Date().toISOString(),test_names_sha256:sha(Buffer.from(JSON.stringify(names)))};
+const tmp=path.join(evidence,operationId+'.tmp-'+process.pid);
+const handle=await open(tmp,'wx');
+try{await handle.writeFile(JSON.stringify(receipt,null,2)+'\\n');await handle.sync();}finally{await handle.close();}
+await rename(tmp,finalFile);
+console.log(JSON.stringify({receipt,receipt_path:finalFile},null,2));
+if(body.status!=='passed'){console.error('FULL_TEST_OUTPUT_TAIL\n'+out.slice(-18000));console.error('FULL_TEST_ERROR_TAIL\n'+err.slice(-4000));process.exitCode=1;}

package/scripts/r67-independent-observation-verify.mjs

@@ -0,0 +1,36 @@
+import {createHash,createPublicKey,verify as edVerify} from 'node:crypto';
+const h=b=>createHash('sha256').update(b).digest('hex');
+function stable(v){
+ if(v===null||typeof v!=='object')return JSON.stringify(v);
+ if(Array.isArray(v))return '['+v.map(stable).join(',')+']';
+ return '{'+Object.keys(v).sort().map(k=>JSON.stringify(k)+':'+stable(v[k])).join(',')+'}';
+}
+const hex=x=>typeof x==='string'&&/^[a-f0-9]{64}$/.test(x);
+const canonicalHash=v=>h(Buffer.from(stable(v),'utf8'));
+export function independentlyVerifyR67Receipt({receipt,result,trustedPublicSpkiBase64,requestArgs,expectedExecutableSha256}){
+ try{
+  if(!receipt||receipt.schema!=='deadbyte.native-observation-receipt.r67.v1')return {ok:false,reason:'invalid receipt schema'};
+  if(typeof trustedPublicSpkiBase64!=='string')return {ok:false,reason:'trusted public key required'};
+  const spki=Buffer.from(trustedPublicSpkiBase64,'base64');
+  if(spki.toString('base64')!==trustedPublicSpkiBase64)return {ok:false,reason:'bad base64 public key'};
+  const trust=h(spki);
+  if(receipt.signer_key_id!==trust||receipt.attestation?.key_id!==trust||receipt.attestation.algorithm!=='ed25519')return {ok:false,reason:'signer is not trusted'};
+  if(!hex(receipt.request_sha256)||!hex(receipt.executable_sha256)||!hex(receipt.result_sha256)||!hex(receipt.receipt_sha256))return {ok:false,reason:'binding malformed'};
+  if(!['process','identity','map','pe'].includes(receipt.operation))return {ok:false,reason:'invalid operation'};
+  if(!Array.isArray(requestArgs)||requestArgs.some(x=>typeof x!=='string')||receipt.request_sha256!==h(Buffer.from(JSON.stringify(requestArgs),'utf8')))return {ok:false,reason:'request args mismatch'};
+  if(!hex(expectedExecutableSha256)||receipt.executable_sha256!==expectedExecutableSha256)return {ok:false,reason:'trusted executable mismatch'};
+  if(!['ok','failed'].includes(receipt.result_status)||receipt.result_status!==result?.status)return {ok:false,reason:'result status mismatch'};
+  if(result.schema!=='deadbyte.native-inspect.r67.v1'||(result.status==='ok'&&(result.operation!==receipt.operation||result.data_sha256!==h(Buffer.from(JSON.stringify(result.data),'utf8')))))return {ok:false,reason:'result invalid'};
+  if(receipt.result_sha256!==canonicalHash(result))return {ok:false,reason:'result SHA mismatch'};
+  const {attestation,...signed}=receipt;
+  const {receipt_sha256,...body}=signed;
+  if(canonicalHash(body)!==receipt_sha256)return {ok:false,reason:'receipt SHA mismatch'};
+  const signature=Buffer.from(attestation.signature_base64,'base64');
+  if(signature.length!==64||signature.toString('base64')!==attestation.signature_base64)return {ok:false,reason:'signature encoding invalid'};
+  const pub=createPublicKey({key:spki,format:'der',type:'spki'});
+  if(pub.asymmetricKeyType!=='ed25519')return {ok:false,reason:'not Ed25519'};
+  const message=Buffer.concat([Buffer.from('DEADBYTE-R67-OBSERVATION-V1\0','utf8'),Buffer.from(stable(signed),'utf8')]);
+  if(!edVerify(null,message,pub,signature))return {ok:false,reason:'signature invalid'};
+  return {ok:true,signature_valid:true,receipt_sha256,result_sha256:receipt.result_sha256,signer_key_id:trust};
+ }catch(error){return {ok:false,reason:String(error?.message||error)};}
+}

package/scripts/r67-independent-runtime-observation-verify.mjs

@@ -0,0 +1,63 @@
+import {createHash,createPublicKey,verify as ed25519Verify} from 'node:crypto';
+import {nativeInspectArgs} from '../src/native-inspector-r67.mjs';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const hex64=x=>typeof x==='string'&&/^[a-f0-9]{64}$/.test(x);
+const domain=Buffer.from('DEADBYTE-R67-MACHINE-OBSERVATION-V1\0','utf8');
+function serialize(v){
+ const canon=value=>Array.isArray(value)?value.map(canon):
+  value!==null&&typeof value==='object'?Object.fromEntries(Object.keys(value).sort().map(k=>[k,canon(value[k])])):value;
+ return JSON.stringify(canon(v));
+}
+export function independentlyVerifyR67RuntimeObservation({
+ receipt,result,requestArgs,machinePublicSpkiBase64,expectedMachineStatus,
+ expectedPolicySha256,expectedGrantId
+}={}){
+ try{
+  if(!receipt||!result||!Array.isArray(requestArgs)||!expectedMachineStatus)return {ok:false,reason:'missing binding'};
+  if(receipt.schema!=='deadbyte.native-observation-runtime-r67.v1')return {ok:false,reason:'schema'};
+  if(!hex64(receipt.machine_id)||!hex64(receipt.request_sha256)||!hex64(receipt.result_sha256)||
+   !hex64(receipt.executable_sha256)||!hex64(receipt.generation_manifest_sha256)||
+   !hex64(receipt.release_manifest_sha256)||!hex64(receipt.online_epoch))return {ok:false,reason:'digest or generation'};
+  if(!Number.isInteger(receipt.identity_generation)||receipt.identity_generation<1||
+    !Number.isFinite(new Date(receipt.observed_at_utc).getTime())||
+    new Date(receipt.observed_at_utc).toISOString()!==receipt.observed_at_utc)return {ok:false,reason:'identity generation or timestamp'};
+  if(typeof machinePublicSpkiBase64!=='string'||Buffer.from(machinePublicSpkiBase64,'base64').toString('base64')!==machinePublicSpkiBase64)
+    return {ok:false,reason:'public key encoding'};
+  const der=Buffer.from(machinePublicSpkiBase64,'base64');
+  const key=createPublicKey({key:der,format:'der',type:'spki'});
+  if(key.asymmetricKeyType!=='ed25519'||sha(der)!==receipt.machine_id)return {ok:false,reason:'wrong machine key'};
+  for(const field of ['machine_id','identity_generation','online_epoch','release_id','release_manifest_sha256','generation_manifest_sha256'])
+   if(receipt[field]!==expectedMachineStatus[field])return {ok:false,reason:'runtime identity, release or generation changed'};
+  if(expectedMachineStatus.public_key_spki_base64!==machinePublicSpkiBase64)return {ok:false,reason:'status key changed'};
+  if(!hex64(expectedPolicySha256)||receipt.authority?.policy_sha256!==expectedPolicySha256||
+   receipt.authority?.grant_id!==expectedGrantId||
+   receipt.authority?.scope!=='native-observe-readonly'||
+   !Number.isSafeInteger(receipt.authority?.authority_generation)||
+   receipt.authority.authority_generation<1)return {ok:false,reason:'authority'};
+  if(Object.keys(receipt.authority).sort().join('|')!==['authority_generation','grant_id','policy_sha256','scope'].sort().join('|'))
+   return {ok:false,reason:'unexpected authority fields'};
+  const nativeArgs=nativeInspectArgs(requestArgs);
+  if(receipt.operation!==nativeArgs[0]||receipt.request_sha256!==sha(Buffer.from(JSON.stringify(nativeArgs),'utf8')))
+   return {ok:false,reason:'wrong native request'};
+  if(result.schema!=='deadbyte.native-inspect.r67.v1'||!['ok','failed'].includes(result.status)||
+   receipt.result_status!==result.status||receipt.result_sha256!==sha(Buffer.from(serialize(result),'utf8')))
+   return {ok:false,reason:'native result hash'};
+  if(result.status==='ok'&&(result.operation!==nativeArgs[0]||!result.data||
+     result.data_sha256!==sha(Buffer.from(JSON.stringify(result.data),'utf8'))))
+   return {ok:false,reason:'invalid native data digest'};
+  const att=receipt.attestation;
+  if(att?.algorithm!=='ed25519'||att.key_id!==receipt.machine_id||
+    typeof att.signature_base64!=='string')return {ok:false,reason:'attestation'};
+  const signature=Buffer.from(att.signature_base64,'base64');
+  if(signature.length!==64||signature.toString('base64')!==att.signature_base64)return {ok:false,reason:'signature encoding'};
+  const {attestation,...body}=receipt;
+  const keys=['schema','observed_at_utc','machine_id','identity_generation','online_epoch','release_id',
+   'release_manifest_sha256','generation_manifest_sha256','authority','operation','request_sha256',
+   'executable_sha256','result_status','result_sha256'];
+  if(Object.keys(body).sort().join('|')!==keys.sort().join('|'))return {ok:false,reason:'unexpected body fields'};
+  const valid=ed25519Verify(null,Buffer.concat([domain,Buffer.from(serialize(body),'utf8')]),key,signature);
+  if(!valid)return {ok:false,reason:'signature invalid'};
+  return {ok:true,signature_valid:true,signer_key_id:receipt.machine_id,
+   release_id:receipt.release_id,generation_manifest_sha256:receipt.generation_manifest_sha256};
+ }catch(e){return {ok:false,reason:'verification failed: '+String(e?.message||e)};}
+}

package/scripts/r67-nonpass-adjudicate.mjs

@@ -0,0 +1,20 @@
+import {readFile,writeFile,mkdir} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+const base=process.cwd();
+const source=path.resolve(base,'..','..','testing','0.15.44-r67','R67-NONPASS-SOURCE-AUDIT-20261011.json');
+const output=path.resolve(base,'..','..','testing','0.15.44-r67','R67-NONPASS-ADJUDICATION-CANDIDATE.json');
+const x=JSON.parse(await readFile(source,'utf8'));
+if(x.schema!=='deadbyte.r67-nonpass-source-audit.v1'||x.count!==42||x.cases.length!==42)throw Error('Unexpected source audit');
+const rows=x.cases.map((item,index)=>{
+ const candidates=(item.source_matches??[]).filter(m=>typeof m.context==='string');
+ const conditions=candidates.map(m=>({file:m.file,line:m.line,version_guard:/skip:\s*currentPackage\.version\s*!==\s*['"]([0-9.]+)['"]/.exec(m.context)?.[1]??null,explicit_skip:/\btest\.skip\s*\(/.test(m.context),historical_skip:/skipHistorical\s*\(/.test(m.context)}));
+ const reason=item.reason?{kind:'SOURCE_REPORTED',text:item.reason}:{kind:'UNCLASSIFIED',text:null};
+ return {index,shard:item.shard,name:item.name,source_reported_reason:reason,source_matches:conditions,
+  evidence_level:item.reason?'SOURCE_LOG_REASON_ONLY':'NO_PER_CASE_REASON',
+  release_gate:'BLOCKED_UNTIL_CASE_LEVEL_PROVENANCE'};
+});
+const counts={cases:rows.length,source_reported_reasons:rows.filter(r=>r.source_reported_reason.kind==='SOURCE_REPORTED').length,unclassified:rows.filter(r=>r.source_reported_reason.kind==='UNCLASSIFIED').length,version_guard_candidates:rows.filter(r=>r.source_matches.some(m=>m.version_guard)).length,explicit_skip_candidates:rows.filter(r=>r.source_matches.some(m=>m.explicit_skip)).length};
+const data={schema:'deadbyte.r67-nonpass-adjudication.v1',status:'BLOCKED_NONPASS_CLASSIFICATION',source_audit_sha256:createHash('sha256').update(await readFile(source)).digest('hex'),counts,rows};
+await writeFile(output,JSON.stringify(data,null,2)+'\n',{flag:'wx'});
+console.log(JSON.stringify({status:data.status,counts,output}));

package/scripts/r67-publish-boundary-audit.mjs

@@ -0,0 +1,32 @@
+import {createHash} from 'node:crypto';
+import {readFile,lstat} from 'node:fs/promises';
+import {resolveStateRoot} from '../src/state-root.mjs';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const version=JSON.parse(await readFile(path.join(root,'package.json'),'utf8')).version;
+const basename='deadbyte-mcp-'+version+'.tgz';
+const pubDir=path.join(resolveStateRoot(),'evidence','npm-publication',version);
+const paths={
+ source:path.join(root,basename),
+ preserved:path.join(pubDir,basename),
+ claim:path.join(pubDir,'claim.json')
+};
+const outputs={};
+for(const [kind,p] of Object.entries(paths)){
+ try{
+  const s=await lstat(p);
+  if(!s.isFile()||s.isSymbolicLink()){outputs[kind]={state:'NON_REGULAR_OR_LINK'};continue;}
+  const bytes=await readFile(p);
+  outputs[kind]={state:'EXISTS',bytes:bytes.length,sha256:createHash('sha256').update(bytes).digest('hex')};
+  if(kind==='claim'){
+   try{const j=JSON.parse(bytes.toString('utf8'));outputs[kind].schema=j.schema;outputs[kind].version=j.version;outputs[kind].manifest_sha256=j.manifest_sha256;outputs[kind].tarball_sha256=j.tarball_sha256;}
+   catch{outputs[kind].parse_error=true;}
+  }
+ }catch(e){if(e?.code==='ENOENT')outputs[kind]={state:'ABSENT'};else throw e;}
+}
+console.log(JSON.stringify({schema:'deadbyte.r67-publication-boundary-audit.v1',
+ version,production_mutation:false,network_access:false,publication_dispatch:false,
+ artifacts:outputs,conclusion:outputs.claim.state==='EXISTS'?'CLAIM_EXISTS_RECONCILE_BEFORE_ANY_DISPATCH':
+ 'NO_LOCAL_CLAIM_OBSERVED_DO_NOT_ASSUME_REGISTRY_STATE'},null,2));

package/scripts/r67-regression-reconcile.mjs

@@ -0,0 +1,10 @@
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {reconcileR67Evidence} from '../src/r67-evidence-reconcile.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const operationId=process.argv[2];
+const evidenceRoot=path.resolve(root,'..','..','testing','0.15.44-r67','regression-shards');
+const result=await reconcileR67Evidence({root,evidenceRoot,operationId});
+console.log(JSON.stringify(result,null,2));
+if(result.status!=='PASS')process.exitCode=2;

package/scripts/r67-regression-shard-run.mjs

@@ -0,0 +1,70 @@
+import {readdir,mkdir,open,readFile,rename} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createR67ShardPlan,r67ShardTimeoutMs,r67RegressionTreeHash,parseR67TapSummary,parseR67NonpassCases,parseR67FailedCases} from '../src/r67-regression-shards.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const action=process.argv[2],operation=process.argv[3],number=process.argv[4];
+if(!['run','status'].includes(action)||!/^[a-z0-9][a-z0-9._-]{5,63}$/.test(operation??'')||!/^(?:0|[1-9][0-9]?)$/.test(number??''))throw new Error('usage: run|status uniqueOperationId index');
+const index=Number(number);
+if(index>=32)throw new Error('R67 shard index must be 0..31');
+const names=(await readdir(path.join(root,'test'))).filter(n=>n.endsWith('.test.mjs')).map(n=>'test/'+n).sort();
+const plan=createR67ShardPlan(names,32),shard=plan.shards[index];
+const hash=b=>createHash('sha256').update(b).digest('hex');
+const evidenceRoot=path.resolve(root,'..','..','testing','0.15.44-r67','regression-shards');
+const directory=path.join(evidenceRoot,operation+'-shard-'+String(index).padStart(2,'0'));
+const intentPath=path.join(directory,'intent.json'),resultPath=path.join(directory,'result.json');
+if(action==='status'){
+ let intent,result;
+ try{intent=JSON.parse(await readFile(intentPath,'utf8'));}catch(error){if(error.code==='ENOENT'){console.log(JSON.stringify({status:'NOT_STARTED',operation,shard_index:index}));process.exit(0);}throw error;}
+ try{result=JSON.parse(await readFile(resultPath,'utf8'));}catch(error){if(error.code==='ENOENT'){console.log(JSON.stringify({status:'RUNNING_OR_OUTCOME_UNKNOWN',operation,shard_index:index,intent}));process.exit(0);}throw error;}
+ const {receipt_sha256,...body}=result;
+ if(receipt_sha256!==hash(Buffer.from(JSON.stringify(body),'utf8')))throw new Error('durable result receipt hash mismatch');
+ console.log(JSON.stringify({status:'COMPLETED_RECORD',operation,shard_index:index,result},null,2));
+ process.exit(0);
+}
+await mkdir(evidenceRoot,{recursive:true});
+await mkdir(directory,{recursive:false}); // EEXIST means NEVER rerun: reconcile existing intent/result
+const startedAt=new Date().toISOString();
+const fileHashes=[];
+for(const name of names)fileHashes.push([name,hash(await readFile(path.join(root,name)))]);
+const test_tree_sha256=hash(Buffer.from(JSON.stringify(fileHashes),'utf8'));
+const sourceTree=await r67RegressionTreeHash(root);
+const intent={schema:'deadbyte.r67-shard-intent.v1',operation,shard_index:index,plan_sha256:plan.plan_sha256,
+ files_sha256:shard.files_sha256,test_tree_sha256,source_tree_sha256:sourceTree.sha256,
+ source_file_count:sourceTree.file_count,started_at_utc:startedAt,files:shard.files};
+const intentHandle=await open(intentPath,'wx',0o600);
+try{await intentHandle.writeFile(JSON.stringify(intent,null,2)+'\n');await intentHandle.sync();}finally{await intentHandle.close();}
+const began=Date.now();
+const configuredTimeoutMs=r67ShardTimeoutMs(shard);
+const child=spawnSync(process.execPath,['--test','--test-reporter=tap','--test-concurrency=2',...shard.files],{
+ cwd:root,encoding:'utf8',windowsHide:true,shell:false,timeout:configuredTimeoutMs,maxBuffer:16*1024*1024
+});
+const output=String(child.stdout||''),stderr=String(child.stderr||'');
+const tap=parseR67TapSummary(output);
+const nonpass=parseR67NonpassCases(output);
+const failures=parseR67FailedCases(output);
+const testCount=tap?.tests??null,passed=tap?.pass??null,failed=tap?.fail??null;
+let status='OUTCOME_UNKNOWN';
+if(!child.error&&Number.isInteger(child.status)&&tap!==null){
+ status=(child.status===0&&failed===0&&testCount>=shard.files.length)?'PASS':'FAILED';
+}
+const body={schema:'deadbyte.r67-shard-result.v2',operation_id:operation,shard_index:index,
+ plan_sha256:plan.plan_sha256,files_sha256:shard.files_sha256,test_tree_sha256,
+ source_tree_sha256:sourceTree.sha256,source_file_count:sourceTree.file_count,
+ status,exit_code:child.status,test_count:testCount,passed,failed,
+ skipped:tap?.skipped??null,cancelled:tap?.cancelled??null,todo:tap?.todo??null,
+ ...(nonpass?{nonpass_cases:nonpass.cases,nonpass_fully_classified:nonpass.fully_classified}:{}),
+ failure_cases:failures.cases,failure_cases_complete:failures.complete,
+ timed_out:child.error?.code==='ETIMEDOUT',failure_reason:child.error?.code??null,
+ elapsed_ms:Date.now()-began,configured_timeout_ms:configuredTimeoutMs,finished_at_utc:new Date().toISOString(),
+ stdout_sha256:hash(Buffer.from(output,'utf8')),stderr_sha256:hash(Buffer.from(stderr,'utf8'))};
+const receipt={...body,receipt_sha256:hash(Buffer.from(JSON.stringify(body),'utf8'))};
+const temporary=path.join(directory,'result.tmp-'+process.pid);
+const h=await open(temporary,'wx',0o600);
+try{await h.writeFile(JSON.stringify(receipt,null,2)+'\n');await h.sync();}finally{await h.close();}
+await rename(temporary,resultPath);
+console.log(JSON.stringify({status,receipt_path:resultPath,receipt},null,2));
+if(status!=='PASS')process.exitCode=1;

package/scripts/r67-run-shard-batch.mjs

@@ -0,0 +1,18 @@
+import {spawnSync} from 'node:child_process';
+import {readFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const op=process.argv[2],start=Number(process.argv[3]),end=Number(process.argv[4]);
+if(!/^[a-z0-9][a-z0-9._-]{5,63}$/.test(op??'')||!Number.isInteger(start)||!Number.isInteger(end)||start<0||end>32||end<=start||end-start>8)throw Error('usage: operation id, start, end (max eight)');
+const runner=path.join(root,'scripts','r67-regression-shard-run.mjs');
+const results=[];
+for(let i=start;i<end;i++){
+ const found=spawnSync(process.execPath,[runner,'run',op,String(i)],{cwd:root,encoding:'utf8',shell:false,windowsHide:true,timeout:220000,maxBuffer:256*1024});
+ const receiptPath=path.resolve(root,'..','..','testing','0.15.44-r67','regression-shards',op+'-shard-'+String(i).padStart(2,'0'),'result.json');
+ let body=null;try{body=JSON.parse(await readFile(receiptPath,'utf8'));}catch{}
+ results.push({shard_index:i,transport_exit:found.status,child_error:found.error?.code??null,recorded_status:body?.status??'MISSING',test_count:body?.test_count??null,passed:body?.passed??null,skipped:body?.skipped??null,nonpass_classified:body?.nonpass_fully_classified??null,source_tree_sha256:body?.source_tree_sha256??null,receipt_sha256:body?.receipt_sha256??null});
+ if(!body){break;}
+}
+console.log(JSON.stringify({schema:'deadbyte.r67-batch-progress.v1',operation_id:op,results},null,2));
+if(results.length!==end-start||results.some(r=>r.recorded_status!=='PASS'))process.exitCode=2;

package/scripts/r67-stage-candidate.mjs

@@ -0,0 +1,30 @@
+import {readFile,writeFile,stat,lstat,mkdir,copyFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const candidate=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const parent=path.join(path.dirname(candidate),'deadbyte-mcp-0.15.43-r66');
+const EXPECT='4c4a64a4c8e9f5a6e9eecce85fd0007ebcac99121b29c07f1a1fc81d1643cd33';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const manifest=await readFile(path.join(parent,'MANIFEST.SHA256'));
+if(sha(manifest)!==EXPECT)throw new Error('R67 parent manifest SHA mismatch');
+const rows=manifest.toString('utf8').trimEnd().split(/\r?\n/).map(line=>{const m=/^([a-f0-9]{64})  (.+)$/.exec(line);if(!m)throw new Error('bad manifest row');return {sha:m[1],rel:m[2]};});
+const seen=new Set();
+let copied=0,bytes=0;
+for(const {sha:want,rel} of rows){
+ if(rel.startsWith('/')||rel.includes('\\')||rel.split('/').some(x=>!x||x==='.'||x==='..')||seen.has(rel))throw new Error('unsafe or duplicate parent path: '+rel);
+ seen.add(rel);
+ const src=path.join(parent,...rel.split('/'));const info=await lstat(src);
+ if(!info.isFile()||info.isSymbolicLink())throw new Error('non-file predecessor: '+rel);
+ const data=await readFile(src);if(sha(data)!==want)throw new Error('source drift: '+rel);
+ const dst=path.join(candidate,...rel.split('/'));
+ await mkdir(path.dirname(dst),{recursive:true});
+ try{const existing=await readFile(dst);if(sha(existing)!==want)throw new Error('destination differs: '+rel);}catch(e){if(e.code!=='ENOENT')throw e;await copyFile(src,dst);}
+ if(sha(await readFile(dst))!==want)throw new Error('copy differs: '+rel);
+ copied++;bytes+=data.length;
+}
+await writeFile(path.join(candidate,'MANIFEST.SHA256'),manifest,{flag:'wx'});
+const proof={schema:'deadbyte.r67-candidate-parent.v1',parent_release_id:'v0.15.43-4c4a64a4c8e9f5a6',parent_manifest_sha256:EXPECT,source_directory:parent,candidate_directory:candidate,copied_files:copied,copied_bytes:bytes,mutation:false};
+await mkdir(path.join(candidate,'docs'),{recursive:true});
+await writeFile(path.join(candidate,'docs','R67-CANDIDATE-PARENT.json'),JSON.stringify(proof,null,2)+'\n',{flag:'wx'});
+console.log(JSON.stringify({status:'STAGED',copied_files:copied,copied_bytes:bytes,parent_manifest_sha256:EXPECT,candidate},null,2));

package/scripts/r67-verify-parent-ping.mjs

@@ -0,0 +1,22 @@
+import {readFile} from 'node:fs/promises';
+import {createHash,createPublicKey,verify as edVerify} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const root=path.resolve(fileURLToPath(new URL('../../..',import.meta.url)));
+const receiptFile=path.join(root,'testing','0.15.44-r67','R67-PRODUCTION-BASELINE.json');
+const receipt=JSON.parse(await readFile(receiptFile,'utf8'));
+const ping=receipt.signed_ping;
+const spki=Buffer.from(receipt.machine.public_key_spki_base64,'base64');
+const keyId=createHash('sha256').update(spki).digest('hex');
+const {attestation,...body}=ping;
+const sorted=v=>Array.isArray(v)?v.map(sorted):v!==null&&typeof v==='object'?Object.fromEntries(Object.keys(v).sort().map(k=>[k,sorted(v[k])])):v;
+const message=Buffer.concat([Buffer.from('DEADBYTE-MACHINE-PING-V1\0','utf8'),Buffer.from(JSON.stringify(sorted(body)),'utf8')]);
+const digest=createHash('sha256').update(message).digest('hex');
+const key=createPublicKey({key:spki,format:'der',type:'spki'});
+const signature=Buffer.from(attestation.signature_base64,'base64');
+const valid=key.asymmetricKeyType==='ed25519'&&signature.length===64&&attestation.key_id===keyId&&ping.machine_id===keyId&&receipt.machine.machine_id===keyId&&edVerify(null,message,key,signature);
+const prior=receipt.independent_verification?.signed_message_sha256??null;
+const ok=valid&&digest===prior;
+const result={schema:'deadbyte.r67-independent-baseline-check.v1',status:ok?'PASS':'FAIL',ed25519_valid:valid,key_identity_matches:keyId===ping.machine_id,message_sha256:digest,claimed_message_sha256:prior,release_id:ping.release_id};
+console.log(JSON.stringify(result,null,2));
+if(!ok)process.exitCode=1;

package/scripts/release-manifest.mjs

@@ -59,6 +59,7 @@ function npmPackFiles() {
     const raw = item?.path;
     if (typeof raw !== 'string' || raw.length < 1) throw new Error('npm pack file path invalid');
     const rel = raw.replaceAll('\\','/');
+    if (/\.tgz$/i.test(rel)) throw new Error(`npm archive self-inclusion forbidden: ${rel}; exclude existing tarballs from the npm package surface`);
     if (rel === manifestName || excludedPackagePaths.has(rel) || excludedPackagePrefixes.some(prefix => rel.startsWith(prefix))) continue;
     if (path.posix.isAbsolute(rel) || rel.split('/').includes('..') || rel.includes('\0')) {
       throw new Error(`unsafe package path '${rel}'`);

package/src/activation-continuity-engine-r65.mjs

@@ -2,6 +2,7 @@ import {createHash,randomBytes} from 'node:crypto';
 import {open,readFile,rm} from 'node:fs/promises';
 import path from 'node:path';
 import {canonicalJson} from './canonical-json.mjs';
+import {decodeUtf8Strict} from './text-policy.mjs';
 import {
   captureStandingGrant,compareSecurityEnvelopes,createAuthorityEpochStore,deriveSecurityEnvelope
 } from './authority-continuity-r65.mjs';
@@ -17,7 +18,7 @@ const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
 const plain=value=>value&&typeof value==='object'&&!Array.isArray(value);
 
 function parseJson(bytes,label){
-  try{return JSON.parse(bytes.toString('utf8'));}
+  try{return JSON.parse(decodeUtf8Strict(bytes));}
   catch{throw new Error(`${label} JSON invalid`);}
 }
 function inside(root,target){

package/src/autonomous-runtime.mjs

@@ -308,7 +308,7 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
       const r34Paused=await pauseR34Ambiguous(checked.reason ?? error);
       if (r34Paused) return r34Paused;
       await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'profile_execution_without_receipt', profile_id:profileId,
-        action_key:actionKey, detail:truncated(error) });
+        action_key:actionKey, receipt_id:receiptId, request_sha256:requestSha256, detail:truncated(error,512) });
       return { status:'paused', observation:null, existing:false };
     }
     result = null;

package/src/deadbyte-cli.mjs

@@ -11,6 +11,9 @@ import { defaultPublicKeyPath } from './trust.mjs';
 import { verifyAuditChain } from './audit-verify.mjs';
 import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-result-journal.mjs';
 import { DEADBYTE_VERSION } from './version.mjs';
+import { runNativeInspect } from './native-inspector-r67.mjs';
+import { exportOfflineDiagnostics } from './r67-diagnostic-export.mjs';
+import { verifyOfflineDiagnosticsZip } from './r67-diagnostics-verify.mjs';
 import { parseActivePointer } from './release-slot.mjs';
 import { printDoctor } from './doctor-r45.mjs';
 import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
@@ -60,7 +63,14 @@ function printHelp(){
     `  npx -y ${exact} supervisor status`,
     `  npx -y ${exact} supervisor recover`,
     `  npx -y ${exact} audit verify`,
-    `  npx -y ${exact} audit status`,''
+    `  npx -y ${exact} audit status`,
+    `  npx -y ${exact} diagnostics export --output <local.zip> # offline, never uploads`,
+    `  npx -y ${exact} diagnostics verify --input <local.zip>  # local structural/CRC verify`,
+    `  npx -y ${exact} inspect process [limit]       # local native process snapshot`,
+    `  npx -y ${exact} inspect identity PID          # native process creation token`,
+    `  npx -y ${exact} inspect memory self [limit]     # local VirtualQueryEx metadata only`,
+    `  npx -y ${exact} inspect memory PID <creation_filetime> [limit] # PID-reuse guarded`,
+    `  npx -y ${exact} inspect pe <file>            # local native PE32/PE32+ inspection`,''
   ].join('\n'));
 }
 async function remoteContext(){
@@ -681,6 +691,28 @@ async function main(argv){
   if(command==='remote'){await runRemote(rest);return;}
   if(command==='supervisor'){await runSupervisor(rest);return;}
   if(command==='audit'){await runAudit(rest);return;}
+  if(command==='diagnostics'){
+    if(rest.length!==3)throw new Error('diagnostics export --output or verify --input; no network upload supported');
+    if(rest[0]==='export'&&rest[1]==='--output'){
+      const report=await exportOfflineDiagnostics({stateRoot:stateRoot(),outputPath:rest[2]});
+      process.stdout.write(`${JSON.stringify(report)}\n`);
+      return;
+    }
+    if(rest[0]==='verify'&&rest[1]==='--input'){
+      const file=path.resolve(rest[2]);
+      await requireRegular(file,'diagnostic ZIP');
+      const report=verifyOfflineDiagnosticsZip(await readFile(file));
+      process.stdout.write(`${JSON.stringify(report)}\n`);
+      return;
+    }
+    throw new Error('unsupported diagnostics mode; network upload is forbidden');
+  }
+  if(command==='inspect'){
+    const result=await runNativeInspect(rest);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if(result.status!=='ok')process.exitCode=2;
+    return;
+  }
   throw new Error(`unknown command '${command}'`);
 }
 

package/src/machine-fs-smoke-client.mjs

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { Client } from '@modelcontextprotocol/client';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
 import { CODING_GRANT_SCHEMA, loadCodingPolicy } from './coding-plane.mjs';
+import { createAuthorityEpochStore } from './authority-continuity-r65.mjs';
 import { verifyMachineFsReceiptFile } from './machine-fs.mjs';
 import { generateTrustKeypair } from './trust.mjs';
 import { assertExactCatalog, expectedFullCatalogForEnv } from './runtime-catalog-expectation.mjs';
@@ -23,14 +24,16 @@ const structured = (result, label) => {
 const scratch = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-machine-fs-smoke-'));
 const coreRoot = path.join(scratch, 'core');
 const trustRoot = path.join(scratch, 'trust');
+const runtimeRoot = path.join(scratch, 'runtime');
 await mkdir(coreRoot, { recursive: true });
 await mkdir(trustRoot, { recursive: true });
+await mkdir(runtimeRoot, { recursive: true });
 const keys = await generateTrustKeypair({
-  privateKeyPath: path.join(trustRoot, 'private.pem'),
-  publicKeyPath: path.join(trustRoot, 'public.pem')
+  privateKeyPath: path.join(trustRoot, 'ed25519-private.pem'),
+  publicKeyPath: path.join(trustRoot, 'ed25519-public.pem')
 });
 const policyPath = path.join(scratch, 'coding-policy.json');
-const grantPath = path.join(scratch, 'coding-grant.json');
+const grantPath = path.join(runtimeRoot, 'coding-grant.json');
 const evidenceDir = path.join(scratch, 'evidence');
 const rawPolicy = {
   schema: 'deadbyte.coding-policy.v1', enabled: true,
@@ -41,11 +44,16 @@ const rawPolicy = {
 const policyBytes = Buffer.from(`${JSON.stringify(rawPolicy, null, 2)}\n`, 'utf8');
 await writeFile(policyPath, policyBytes, { flag: 'wx' });
 const policy = await loadCodingPolicy(policyPath);
-await writeFile(grantPath, `${JSON.stringify({
+const grantBytes = Buffer.from(`${JSON.stringify({
   schema: CODING_GRANT_SCHEMA, policy_sha256: policy.policy_sha256,
   instance_nonce: randomBytes(32).toString('hex'), root_ids: ['core'],
   granted_at_utc: new Date().toISOString()
-}, null, 2)}\n`, { flag: 'wx' });
+}, null, 2)}\n`, 'utf8');
+await writeFile(grantPath, grantBytes, { flag: 'wx' });
+const grant = JSON.parse(grantBytes.toString('utf8'));
+await createAuthorityEpochStore({ runtimeDir:runtimeRoot, policyBytes }).append({
+  plane:'coding', action:'grant', grantBytes, grantInstanceNonce:grant.instance_nonce, updateId:null
+});
 
 const client = new Client({ name: 'deadbyte-machine-fs-smoke', version: '0.8.0' },
   { versionNegotiation: { mode: { pin: '2026-07-28' } } });

package/src/machine-identity.mjs

@@ -11,11 +11,13 @@ import { lstat, mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/pro
 import os from 'node:os';
 import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
+import {nativeInspectArgs,runNativeInspect} from './native-inspector-r67.mjs';
 import { parseActivePointer } from './release-slot.mjs';
 
 export const MACHINE_IDENTITY_SCHEMA = 'deadbyte.machine-identity.v1';
 export const MACHINE_PING_SCHEMA = 'deadbyte.machine-ping.v1';
 const MACHINE_PING_DOMAIN = Buffer.from('DEADBYTE-MACHINE-PING-V1\0', 'utf8');
+export const R67_MACHINE_OBSERVATION_DOMAIN=Buffer.from('DEADBYTE-R67-MACHINE-OBSERVATION-V1\0','utf8');
 const HEX64 = /^[0-9a-f]{64}$/;
 
 const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
@@ -182,7 +184,8 @@ function statusBody(identity, pointer, onlineEpoch) {
 
 export async function createMachineRuntime({
   stateRoot = path.join(os.homedir(), '.deadbyte-mcp'),
-  activePointerPath = path.join(stateRoot, 'active-release.json')
+  activePointerPath = path.join(stateRoot, 'active-release.json'),
+  assertObservationAuthority = null
 } = {}) {
   await initializeMachineIdentity({ stateRoot });
   let identity = await loadIdentity(stateRoot);
@@ -238,7 +241,61 @@ export async function createMachineRuntime({
       identity_generation: identity.state.identity_generation, online_epoch: onlineEpoch };
   }
 
-  return Object.freeze({ list, status, ping, revoke });
+
+  // A non-public server-owned signing path: observer + machine identity stay in one process.
+  // The MCP bridge must never expose this as a caller-supplied signing oracle.
+  async function observeNative({args}){
+    if(typeof assertObservationAuthority!=='function')throw new Error('R67 observation authority callback required');
+    if(!Array.isArray(args))throw new Error('R67 observation args required');
+    const nativeArgs=nativeInspectArgs(args);
+    const operation=nativeArgs[0];
+    const before=await status();
+    const checkGrant=grant=>{
+      if(!grant||!/^[-a-zA-Z0-9._:]{1,128}$/.test(grant.grant_id??'')||
+         !HEX64.test(grant.policy_sha256??'')||grant.scope!=='native-observe-readonly'||
+         !Number.isSafeInteger(grant.authority_generation)||grant.authority_generation<1)
+        throw new Error('R67 authority grant invalid');
+      return {grant_id:grant.grant_id,policy_sha256:grant.policy_sha256,
+        scope:grant.scope,authority_generation:grant.authority_generation};
+    };
+    const first=checkGrant(await assertObservationAuthority({phase:'pre',operation,args:nativeArgs,machine:before}));
+    const result=await runNativeInspect(args);
+    const after=await status();
+    const second=checkGrant(await assertObservationAuthority({phase:'post',operation,args:nativeArgs,machine:after}));
+    if(canonicalJson(first)!==canonicalJson(second))throw new Error('R67 authority lease changed during observation');
+    for(const field of ['machine_id','identity_generation','online_epoch','release_id','release_manifest_sha256','generation_manifest_sha256'])
+      if(before[field]!==after[field])throw new Error('R67 machine or release generation changed during observation');
+    const pinned=JSON.parse(await readFile(new URL('../docs/R67-NATIVE-INSPECT-BINARY.json',import.meta.url),'utf8'));
+    if(pinned.schema!=='deadbyte.r67-native-inspector-binary.v1'||!HEX64.test(pinned.sha256??''))
+      throw new Error('R67 observer executable pin invalid');
+    // Trusted signer is loaded from the machine identity store by this runtime, never provided by a client.
+    identity=await loadIdentity(stateRoot);
+    if(identity.machine_id!==before.machine_id||identity.state.identity_generation!==before.identity_generation)
+      throw new Error('R67 identity revoked before signing');
+    const receiptBody={
+      schema:'deadbyte.native-observation-runtime-r67.v1',
+      observed_at_utc:new Date().toISOString(),
+      machine_id:before.machine_id,
+      identity_generation:before.identity_generation,
+      online_epoch:before.online_epoch,
+      release_id:before.release_id,
+      release_manifest_sha256:before.release_manifest_sha256,
+      generation_manifest_sha256:before.generation_manifest_sha256,
+      authority:first,
+      operation,
+      request_sha256:sha256(Buffer.from(JSON.stringify(nativeArgs),'utf8')),
+      executable_sha256:pinned.sha256,
+      result_status:result.status,
+      result_sha256:sha256(Buffer.from(canonicalJson(result),'utf8'))
+    };
+    const signature=cryptoSign(null,Buffer.concat([R67_MACHINE_OBSERVATION_DOMAIN,
+      Buffer.from(canonicalJson(receiptBody),'utf8')]),identity.privateKey);
+    return {result,receipt:{...receiptBody,attestation:{
+      algorithm:'ed25519',key_id:identity.machine_id,signature_base64:signature.toString('base64')
+    }}};
+  }
+
+  return Object.freeze({ list, status, ping, revoke, observeNative });
 }
 
 export async function verifyMachinePingPublic({ ping, publicKeySpkiBase64 }) {

package/src/machine-mcp-tools.mjs

@@ -7,6 +7,10 @@ import {
   machineStructuredResult
 } from './machine-output-contracts.mjs';
 
+const READ_HINTS = Object.freeze({ readOnlyHint:true, destructiveHint:false, idempotentHint:true, openWorldHint:false });
+const SIGNED_PING_HINTS = Object.freeze({ readOnlyHint:true, destructiveHint:false, idempotentHint:false, openWorldHint:false });
+const REVOKE_HINTS = Object.freeze({ readOnlyHint:false, destructiveHint:true, idempotentHint:false, openWorldHint:false });
+
 function ok(schema, value) { return machineStructuredResult(schema, value, false); }
 function fail(schema, status, error) { return machineStructuredResult(schema, { status, error: String(error) }, true); }
 
@@ -16,21 +20,25 @@ export function registerMachineTools(server, { runtime, assertRevokeAuthority })
 
   server.registerTool('machine_list', {
     description: 'List DEADBYTE machine identities visible to this runtime. Identity is public-key based; hostname is informational.',
+    annotations: READ_HINTS,
     inputSchema: z.strictObject({}), outputSchema: machineListOutputSchema
   }, async () => { try { return ok(machineListOutputSchema, await runtime.list()); } catch (error) { return fail(machineListOutputSchema, 'failed', error); } });
 
   server.registerTool('machine_status', {
     description: 'Read this machine identity, online epoch, active release/generation binding, and capability set.',
+    annotations: READ_HINTS,
     inputSchema: z.strictObject({}), outputSchema: machineStatusOutputSchema
   }, async () => { try { return ok(machineStatusOutputSchema, await runtime.status()); } catch (error) { return fail(machineStatusOutputSchema, 'failed', error); } });
 
   server.registerTool('machine_ping', {
     description: 'Return an Ed25519-signed nonce echo bound to machine identity, online epoch, release, and generation.',
+    annotations: SIGNED_PING_HINTS,
     inputSchema: z.strictObject({ nonce: z.string().min(1).max(256) }), outputSchema: machinePingOutputSchema
   }, async ({ nonce }) => { try { return ok(machinePingOutputSchema, await runtime.ping({ nonce })); } catch (error) { return fail(machinePingOutputSchema, 'failed', error); } });
 
   server.registerTool('machine_revoke', {
     description: 'Invalidate the current machine online epoch/generation. Requires independently armed local host authority and never expands authority.',
+    annotations: REVOKE_HINTS,
     inputSchema: z.strictObject({ reason: z.string().min(1).max(256) }), outputSchema: machineRevokeOutputSchema
   }, async ({ reason }) => {
     try {