deadbyte-mcp 0.15.43 → 0.15.44

package/src/mcp-server.mjs

@@ -20,6 +20,7 @@ import { recoverInterruptedSlotUpdates } from './runtime-update.mjs';
 import { decodeUtf8Strict } from './text-policy.mjs';
 import { assertHostArmed, hostExec, hostExecInline, hostExecNative, hostFileRead, hostFileWrite, loadHostPolicy } from './host-plane.mjs';
 import { createMachineRuntime } from './machine-identity.mjs';
+import { createR67NativeObservationAuthority } from './r67-native-observation-authority.mjs';
 import { registerMachineTools } from './machine-mcp-tools.mjs';
 import { createAgentRuntime } from './agent-runtime.mjs';
 import { registerAgentTools } from './agent-mcp-tools.mjs';
@@ -107,10 +108,19 @@ if (!privilegedPolicyExplicit) {
 }
 planeRegistry.define('host',{configured:Boolean(privilegedPolicyPath),required:false});
 const hostPolicy=await planeRegistry.initialize('host',async()=>loadHostPolicy(privilegedPolicyPath));
+// The machine runtime is initialized before Coding. Authority is resolved lazily
+// from the trusted Coding plane at the moment of each observation and rechecked
+// after the native read, never from a client-supplied permission object.
+let codingPolicy=null;
+const nativeObserveMode=process.env.DEADBYTE_R67_NATIVE_OBSERVE ?? '0';
+if(!['0','1'].includes(nativeObserveMode))throw new Error('DEADBYTE_R67_NATIVE_OBSERVE must be 0 or 1');
+const assertNativeObservationAuthority=createR67NativeObservationAuthority({
+  getCodingPolicy:()=>codingPolicy,enabled:nativeObserveMode==='1'
+});
 const machineRuntimeMode = process.env.DEADBYTE_MACHINE_RUNTIME ?? '0';
 if (!['0', '1'].includes(machineRuntimeMode)) throw new Error('DEADBYTE_MACHINE_RUNTIME must be 0 or 1');
 planeRegistry.define('machine',{configured:machineRuntimeMode==='1',required:true});
-const machineRuntime=await planeRegistry.initialize('machine',async()=>createMachineRuntime({stateRoot:runtimeStateRoot}));
+const machineRuntime=await planeRegistry.initialize('machine',async()=>createMachineRuntime({stateRoot:runtimeStateRoot,assertObservationAuthority:assertNativeObservationAuthority}));
 const agentRuntimeMode = process.env.DEADBYTE_AGENT_RUNTIME ?? '0';
 if (!['0', '1'].includes(agentRuntimeMode)) throw new Error('DEADBYTE_AGENT_RUNTIME must be 0 or 1');
 planeRegistry.define('agent',{configured:agentRuntimeMode==='1',required:false});
@@ -142,7 +152,6 @@ if (codingRuntimeMode === '1' && !codingPolicyPath) {
   catch (error) { if (error?.code !== 'ENOENT') throw error; }
 }
 planeRegistry.define('coding',{configured:codingRuntimeMode==='1',required:false});
-let codingPolicy=null;
 const codingRuntime=await planeRegistry.initialize('coding',async()=>{
   if(!codingPolicyPath) throw new Error('DEADBYTE_CODING_RUNTIME=1 requires a coding policy');
   codingPolicy=await loadCodingPolicy(codingPolicyPath);

package/src/native-inspector-r67.mjs

@@ -0,0 +1,66 @@
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {signR67Observation} from './r67-observation-receipt.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const exe=path.join(root,'bin','deadbyte-native-inspect-r67.exe');
+const metaFile=path.join(root,'docs','R67-NATIVE-INSPECT-BINARY.json');
+const hash=b=>createHash('sha256').update(b).digest('hex');
+const validLimit=(s,min,max)=>{if(!/^[1-9][0-9]*$/.test(s))throw new Error('invalid positive limit');const n=Number(s);if(!Number.isSafeInteger(n)||n<min||n>max)throw new Error('limit out of range');return String(n);};
+export function nativeInspectArgs(rest){
+ const [kind,...args]=rest;
+ if(kind==='process'){if(args.length>1)throw new Error('inspect process [1..256]');return ['process',...(args.length?[validLimit(args[0],1,256)]:[])];}
+ if(kind==='identity'){
+  if(args.length!==1)throw new Error('inspect identity <PID>');
+  return ['identity',validLimit(args[0],1,4294967295)];
+ }
+ if(kind==='memory'){
+  if(args[0]==='self'){
+   if(args.length>2)throw new Error('inspect memory self [limit]');
+   return ['map','self',...(args.length===2?[validLimit(args[1],1,512)]:[])];
+  }
+  if(args.length<2||args.length>3)throw new Error('inspect memory PID <creation_filetime> [limit]');
+  const pid=validLimit(args[0],1,4294967295);
+  const token=args[1];
+  if(!/^[1-9][0-9]*$/.test(token)||BigInt(token)>18446744073709551615n)throw new Error('invalid process creation FILETIME');
+  return ['map',pid,token,...(args.length===3?[validLimit(args[2],1,512)]:[])];
+ }
+ if(kind==='pe'){
+  if(args.length!==1||!args[0]||args[0].includes('\0'))throw new Error('inspect pe <file>');
+  return ['pe',path.resolve(args[0])];
+ }
+ throw new Error('inspect expects process, memory, or pe');
+}
+export async function runNativeInspect(rest,{trustedSigner=null}={}){
+ if(process.platform!=='win32')throw new Error('native inspector requires win32');
+ const args=nativeInspectArgs(rest);
+ const meta=JSON.parse(await readFile(metaFile,'utf8'));
+ if(meta?.schema!=='deadbyte.r67-native-inspector-binary.v1'||meta.exe!=='bin/deadbyte-native-inspect-r67.exe'||!/^[a-f0-9]{64}$/.test(meta.sha256))throw new Error('R67 native executable authority invalid');
+ const info=await lstat(exe);
+ if(!info.isFile()||info.isSymbolicLink())throw new Error('R67 executable is not a regular non-symlink');
+ const before=hash(await readFile(exe));
+ if(before!==meta.sha256)throw new Error('R67 executable hash pin mismatch');
+ const result=spawnSync(exe,args,{encoding:'utf8',windowsHide:true,shell:false,timeout:15000,maxBuffer:2097152});
+ const after=hash(await readFile(exe));
+ if(after!==before)throw new Error('R67 executable drift after execution; outcome uncertain');
+ if(result.error)throw new Error('native inspector execution failed: '+result.error.message);
+ const stdout=String(result.stdout||'');
+ if(Buffer.byteLength(stdout,'utf8')>2097152)throw new Error('native inspector output exceeded limit');
+ let parsed;try{parsed=JSON.parse(stdout);}catch{throw new Error('native inspector output invalid JSON');}
+ if(parsed?.schema!=='deadbyte.native-inspect.r67.v1')throw new Error('native inspector output schema mismatch');
+ if(parsed.status==='ok'){
+  if(result.status!==0||parsed.operation!==args[0]||!parsed.data||parsed.data_sha256!==hash(Buffer.from(JSON.stringify(parsed.data),'utf8')))throw new Error('native inspector result digest mismatch');
+ }else if(parsed.status!=='failed'||result.status!==2||typeof parsed.error!=='string')throw new Error('native inspector failure contract mismatch');
+ if(trustedSigner!==null){
+  if(!trustedSigner||!trustedSigner.privateKey||!trustedSigner.publicKey)throw new Error('R67 signed observation requires an explicit trusted signer');
+  const receipt=signR67Observation({
+   ...trustedSigner,operation:args[0],requestSha256:hash(Buffer.from(JSON.stringify(args),'utf8')),
+   executableSha256:before,result:parsed
+  });
+  return {result:parsed,receipt};
+ }
+ return parsed;
+}

package/src/r67-diagnostic-export.mjs

@@ -0,0 +1,118 @@
+import {createHash} from 'node:crypto';
+import {lstat,readFile,readdir,open} from 'node:fs/promises';
+import path from 'node:path';
+
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+const allowedLog=/^controller-(?:start|restart)\.(?:stdout|stderr)\.log$/;
+const releasePattern=/^v[0-9]+\.[0-9]+\.[0-9]+-[a-f0-9]{16}$/;
+const hex64=/^[a-f0-9]{64}$/;
+const events=['reconnect','connected','disconnect','timeout','cancel','rollback','restore','revoked','ready','start','restart','failed','success'];
+const EVENT_RX=new RegExp('\\b('+events.join('|')+')\\b','i');
+const timestampRx=/^(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z)\b/;
+
+export function redactDiagnosticLine(text){
+ if(typeof text!=='string'||text.length>8192)return null;
+ const level=/\b(ERROR|WARN|INFO|DEBUG)\b/i.exec(text)?.[1]?.toUpperCase();
+ const event=EVENT_RX.exec(text)?.[1]?.toLowerCase();
+ if(!level||!event)return null;
+ const result={};
+ const stamp=timestampRx.exec(text)?.[1];
+ if(stamp&&!Number.isNaN(Date.parse(stamp)))result.timestamp=stamp;
+ result.level=level;result.event=event;
+ const error=/\bwin32=(\d{1,5})\b/i.exec(text)?.[1];
+ if(error!==undefined&&Number(error)<=65535)result.win32_error=Number(error);
+ return result;
+}
+function crc32(data){
+ let crc=0xffffffff;
+ for(const value of data){
+  crc^=value;
+  for(let i=0;i<8;i++)crc=(crc>>>1)^((crc&1)?0xedb88320:0);
+ }
+ return (crc^0xffffffff)>>>0;
+}
+function zipStore(entries){
+ const locals=[],centrals=[];
+ let offset=0;
+ for(const [name,contents] of entries){
+  if(!/^[a-z0-9.-]+\.json$/.test(name))throw new Error('noncanonical archive entry');
+  const nameBytes=Buffer.from(name),data=Buffer.from(contents,'utf8'),crc=crc32(data);
+  if(data.length>1024*1024)throw new Error('archive payload too large');
+  const local=Buffer.alloc(30);
+  local.writeUInt32LE(0x04034b50,0);
+  local.writeUInt16LE(20,4);
+  local.writeUInt32LE(crc,14);
+  local.writeUInt32LE(data.length,18);local.writeUInt32LE(data.length,22);
+  local.writeUInt16LE(nameBytes.length,26);
+  locals.push(local,nameBytes,data);
+  const central=Buffer.alloc(46);
+  central.writeUInt32LE(0x02014b50,0);
+  central.writeUInt16LE(20,4);central.writeUInt16LE(20,6);
+  central.writeUInt32LE(crc,16);
+  central.writeUInt32LE(data.length,20);central.writeUInt32LE(data.length,24);
+  central.writeUInt16LE(nameBytes.length,28);
+  central.writeUInt32LE(offset,42);
+  centrals.push(central,nameBytes);
+  offset+=local.length+nameBytes.length+data.length;
+ }
+ const directory=Buffer.concat(centrals);
+ const end=Buffer.alloc(22);
+ end.writeUInt32LE(0x06054b50,0);
+ end.writeUInt16LE(entries.length,8);end.writeUInt16LE(entries.length,10);
+ end.writeUInt32LE(directory.length,12);end.writeUInt32LE(offset,16);
+ return Buffer.concat([...locals,directory,end]);
+}
+export function makeOfflineDiagnosticBundle({releaseId,manifestSha256,logs=[]}={}){
+ if(!releasePattern.test(releaseId??'')||!hex64.test(manifestSha256??''))throw new Error('trusted release identity invalid');
+ if(!Array.isArray(logs)||logs.length>8)throw new Error('log source budget exceeded');
+ const redacted=[];
+ const sources=new Set();
+ for(const source of logs){
+  if(!source||!allowedLog.test(source.source)||typeof source.content!=='string'||Buffer.byteLength(source.content)>65536||sources.has(source.source))
+   throw new Error('unsupported diagnostic source');
+  sources.add(source.source);
+  const lines=source.content.split(/\r?\n/).slice(0,512);
+  for(const line of lines){
+   if(redacted.length===256)break;
+   const record=redactDiagnosticLine(line);
+   if(record)redacted.push({source:source.source,...record});
+  }
+ }
+ const summary={schema:'deadbyte.r67-offline-diagnostics.v1',release_id:releaseId,release_manifest_sha256:manifestSha256,
+  network_upload:'NEVER',redaction:'FIXED_FIELDS_ONLY',source_count:sources.size,redacted_event_count:redacted.length,
+  raw_log_lines_exported:0,private_memory_exported:false};
+ const zip=zipStore([
+  ['diagnostics.json',JSON.stringify(summary,null,2)+'\n'],
+  ['redacted-events.json',JSON.stringify(redacted,null,2)+'\n']
+ ]);
+ return {zip,summary,archive_sha256:hash(zip)};
+}
+async function regularBounded(file,maxBytes){
+ const info=await lstat(file);
+ if(!info.isFile()||info.isSymbolicLink()||info.size>maxBytes)throw new Error('invalid or oversized diagnostic source');
+ const b=await readFile(file);
+ if(b.length>maxBytes)throw new Error('source size changed');
+ return b.toString('utf8');
+}
+export async function exportOfflineDiagnostics({stateRoot,outputPath,upload=false}={}){
+ if(upload!==false)throw new Error('network upload disabled unconditionally');
+ if(typeof outputPath!=='string'||!outputPath||/^[a-z]+:\/\//i.test(outputPath))throw new Error('explicit local outputPath required');
+ if(typeof stateRoot!=='string'||!stateRoot)throw new Error('local stateRoot required');
+ const root=path.resolve(stateRoot);
+ const pointer=JSON.parse(await regularBounded(path.join(root,'active-release.json'),131072));
+ const logDir=path.join(root,'runtime','logs');
+ let names=[];
+ try{names=(await readdir(logDir)).filter(n=>allowedLog.test(n)).sort().slice(0,8);}catch(error){if(error.code!=='ENOENT')throw error;}
+ const logs=[];
+ for(const name of names){
+  const file=path.join(logDir,name);
+  try{logs.push({source:name,content:await regularBounded(file,65536)});}
+  catch(error){if(error.code!=='ENOENT')throw error;}
+ }
+ const bundle=makeOfflineDiagnosticBundle({releaseId:pointer.release_id,manifestSha256:pointer.manifest_sha256,logs});
+ const target=path.resolve(outputPath);
+ const h=await open(target,'wx',0o600);
+ try{await h.writeFile(bundle.zip);await h.sync();}finally{await h.close();}
+ return {status:'written_local_only',uploaded:false,archive_sha256:bundle.archive_sha256,bytes:bundle.zip.length,
+  source_count:bundle.summary.source_count,redacted_event_count:bundle.summary.redacted_event_count};
+}

package/src/r67-diagnostics-verify.mjs

@@ -0,0 +1,82 @@
+import {createHash} from 'node:crypto';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const MAX=4*1024*1024;
+function crc32(bytes){
+ let crc=0xffffffff;
+ for(const value of bytes){crc^=value;for(let i=0;i<8;i++)crc=(crc>>>1)^((crc&1)?0xedb88320:0);}
+ return (crc^0xffffffff)>>>0;
+}
+function fail(what){throw new Error('ZIP integrity: '+what);}
+function read16(b,o){if(o<0||o+2>b.length)fail('boundary');return b.readUInt16LE(o);}
+function read32(b,o){if(o<0||o+4>b.length)fail('boundary');return b.readUInt32LE(o);}
+export function verifyOfflineDiagnosticsZip(input){
+ if(!Buffer.isBuffer(input))throw new Error('ZIP input must be Buffer');
+ const b=input;
+ if(b.length<22||b.length>MAX)throw new Error('ZIP too large or truncated size');
+ const end=b.length-22;
+ if(read32(b,end)!==0x06054b50)fail('missing terminal EOCD or trailing data');
+ if(read16(b,end+4)||read16(b,end+6)||read16(b,end+20))fail('multidisk/comments forbidden');
+ const count=read16(b,end+10);
+ if(count!==2||read16(b,end+8)!==2)fail('exactly two entries required');
+ const centralSize=read32(b,end+12),centralOffset=read32(b,end+16);
+ if(centralOffset+centralSize!==end)fail('central directory boundary invalid');
+ const expected=['diagnostics.json','redacted-events.json'];
+ let position=centralOffset;
+ let localEnd=0;
+ const files={};
+ for(let i=0;i<2;i++){
+  if(read32(b,position)!==0x02014b50)fail('bad central file header');
+  if(read16(b,position+8)||read16(b,position+10))fail('unsafe ZIP flags or compressed method');
+  const crc=read32(b,position+16),stored=read32(b,position+20),raw=read32(b,position+24);
+  const n=read16(b,position+28),extra=read16(b,position+30),comment=read16(b,position+32);
+  const off=read32(b,position+42);
+  if(stored!==raw||stored>1048576||extra||comment||read16(b,position+34))fail('unsupported entry');
+  if(position+46+n>centralOffset+centralSize)fail('central filename boundary');
+  const name=b.toString('utf8',position+46,position+46+n);
+  if(name!==expected[i])fail('unexpected entry name/order');
+  if(read32(b,off)!==0x04034b50||read16(b,off+6)||read16(b,off+8))fail('local header unsafe flags');
+  if(read32(b,off+14)!==crc||read32(b,off+18)!==stored||read32(b,off+22)!==raw)fail('local versus central mismatch');
+  const ln=read16(b,off+26),le=read16(b,off+28);
+  if(ln!==n||le!==0||b.toString('utf8',off+30,off+30+ln)!==name)fail('local filename mismatch');
+  const start=off+30+n,endByte=start+stored;
+  if(endByte>centralOffset||off!==localEnd)fail('local file bounds or gap');
+  const data=b.subarray(start,endByte);
+  if(crc32(data)!==crc)fail('CRC mismatch');
+  files[name]=data;
+  localEnd=endByte;
+  position+=46+n;
+ }
+ if(position!==centralOffset+centralSize||localEnd!==centralOffset)fail('file/directory overlap or padding');
+ let summary,events;
+ try{
+  summary=JSON.parse(files['diagnostics.json'].toString('utf8'));
+  events=JSON.parse(files['redacted-events.json'].toString('utf8'));
+ }catch{fail('invalid JSON');}
+ if(!summary||typeof summary!=='object'||Array.isArray(summary)||
+  summary.schema!=='deadbyte.r67-offline-diagnostics.v1'||
+  !/^v\d+\.\d+\.\d+-[a-f0-9]{16}$/.test(summary.release_id)||
+  !/^[a-f0-9]{64}$/.test(summary.release_manifest_sha256)||
+  summary.redaction!=='FIXED_FIELDS_ONLY'||summary.network_upload!=='NEVER'||
+  summary.raw_log_lines_exported!==0||summary.private_memory_exported!==false||
+  !Number.isInteger(summary.source_count)||summary.source_count<0||summary.source_count>8||
+  !Number.isInteger(summary.redacted_event_count)||summary.redacted_event_count<0||summary.redacted_event_count>256)
+  fail('unsafe diagnostic summary');
+ const allowedSummary=['schema','release_id','release_manifest_sha256','network_upload','redaction','source_count','redacted_event_count','raw_log_lines_exported','private_memory_exported'];
+ if(Object.keys(summary).sort().join('|')!==allowedSummary.sort().join('|'))fail('unexpected summary fields');
+ if(!Array.isArray(events)||events.length!==summary.redacted_event_count)fail('event count mismatch');
+ const sources=new Set();
+ const validLevels=new Set(['ERROR','WARN','INFO','DEBUG']);
+ const validEvents=new Set(['reconnect','connected','disconnect','timeout','cancel','rollback','restore','revoked','ready','start','restart','failed','success']);
+ for(const event of events){
+  if(!event||typeof event!=='object'||Array.isArray(event))fail('malformed event');
+  const keys=Object.keys(event).sort();
+  if(keys.some(x=>!['source','timestamp','level','event','win32_error'].includes(x)))fail('unexpected event fields');
+  if(!/^controller-(?:start|restart)\.(?:stdout|stderr)\.log$/.test(event.source)||
+     !validLevels.has(event.level)||!validEvents.has(event.event))fail('non-allowlisted event value');
+  if(event.timestamp!==undefined&&(!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(event.timestamp)||Number.isNaN(Date.parse(event.timestamp))))fail('bad event time');
+  if(event.win32_error!==undefined&&(!Number.isInteger(event.win32_error)||event.win32_error<0||event.win32_error>65535))fail('bad Win32 code');
+  sources.add(event.source);
+ }
+ if(sources.size>summary.source_count)fail('event sources exceed declared sources');
+ return {status:'VERIFIED_LOCAL_STRUCTURE',uploaded:false,archive_sha256:sha(b),entry_count:2,summary};
+}

package/src/r67-evidence-reconcile.mjs

@@ -0,0 +1,128 @@
+import {createHash} from 'node:crypto';
+import {readFile,readdir} from 'node:fs/promises';
+import path from 'node:path';
+import {createR67ShardPlan,reconcileR67Shards,r67RegressionTreeHash,r67ShardTimeoutMs} from './r67-regression-shards.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const hex=x=>typeof x==='string'&&/^[a-f0-9]{64}$/.test(x);
+const equal=(a,b)=>JSON.stringify(a)===JSON.stringify(b);
+const idPattern=/^[a-z0-9][a-z0-9._-]{5,63}$/;
+async function jsonAt(file){
+ try{return {value:JSON.parse(await readFile(file,'utf8'))};}
+ catch(e){return {error:e.code==='ENOENT'?'MISSING':'INVALID_OR_UNREADABLE'};}
+}
+
+/**
+ * Independent evaluator. No processes executed, no mutations. Test can inject a
+ * disposable root; production CLI passes the actual candidate + evidence root.
+ * Result hashes are integrity checks, NOT signatures.
+ */
+export async function reconcileR67Evidence({root,evidenceRoot,operationId,sourceHashOptions}){
+ if(!idPattern.test(operationId??'')||typeof root!=='string'||!root||typeof evidenceRoot!=='string'||!evidenceRoot)
+  throw new Error('bounded root, evidence directory and operation identity required');
+ const testNames=(await readdir(path.join(root,'test'))).filter(n=>n.endsWith('.test.mjs')).map(n=>'test/'+n).sort();
+ const plan=createR67ShardPlan(testNames,32);
+ const hashes=[];
+ for(const name of testNames)hashes.push([name,sha(await readFile(path.join(root,name)))]);
+ const testTreeSha=sha(Buffer.from(JSON.stringify(hashes)));
+ const tree=await r67RegressionTreeHash(root,sourceHashOptions);
+ const verified=[],faults=[],stale=[],unknown=[],unclassified=[],classified=[];
+ for(const shard of plan.shards){
+  const dir=path.join(evidenceRoot,operationId+'-shard-'+String(shard.index).padStart(2,'0'));
+  const inFile=await jsonAt(path.join(dir,'intent.json'));
+  if(inFile.error==='MISSING')continue;
+  if(inFile.error){faults.push({index:shard.index,reason:'INTENT_'+inFile.error});continue;}
+  const outFile=await jsonAt(path.join(dir,'result.json'));
+  if(outFile.error==='MISSING'){unknown.push(shard.index);continue;}
+  if(outFile.error){faults.push({index:shard.index,reason:'RESULT_'+outFile.error});continue;}
+  const intent=inFile.value,result=outFile.value;
+  if(!result||typeof result!=='object'||Array.isArray(result)||!intent||typeof intent!=='object'||Array.isArray(intent)){
+   faults.push({index:shard.index,reason:'NOT_OBJECT'});continue;
+  }
+  const {receipt_sha256,...receiptBody}=result;
+  const v1=result.schema==='deadbyte.r67-shard-result.v1';
+  if((!v1&&result.schema!=='deadbyte.r67-shard-result.v2')||
+     intent.schema!=='deadbyte.r67-shard-intent.v1'||
+     intent.operation!==operationId||result.operation_id!==operationId||
+     intent.shard_index!==shard.index||result.shard_index!==shard.index||
+     !hex(receipt_sha256)||receipt_sha256!==sha(Buffer.from(JSON.stringify(receiptBody)))||
+     !hex(intent.plan_sha256)||!hex(result.plan_sha256)||
+     !hex(intent.files_sha256)||!hex(result.files_sha256)||
+     !hex(intent.test_tree_sha256)||!hex(result.test_tree_sha256)||
+     !Array.isArray(intent.files)||intent.files_sha256!==sha(Buffer.from(JSON.stringify(intent.files)))||
+     intent.plan_sha256!==result.plan_sha256||
+     intent.files_sha256!==result.files_sha256||
+     intent.test_tree_sha256!==result.test_tree_sha256||
+     (intent.source_tree_sha256!==undefined&&intent.source_tree_sha256!==result.source_tree_sha256)||
+     (intent.source_file_count!==undefined&&intent.source_file_count!==result.source_file_count)){
+    faults.push({index:shard.index,reason:'RESULT_DIGEST_OR_IDENTITY_INVALID'});continue;
+  }
+  if(v1){stale.push(shard.index);continue;}
+  if(!hex(result.source_tree_sha256)||!hex(intent.source_tree_sha256)||
+    !Number.isSafeInteger(result.source_file_count)||!Number.isSafeInteger(intent.source_file_count)||
+    !Number.isSafeInteger(result.configured_timeout_ms)||result.configured_timeout_ms<1000||
+    !hex(result.stdout_sha256)||!hex(result.stderr_sha256)||
+    typeof result.timed_out!=='boolean'||!Number.isFinite(result.elapsed_ms)||result.elapsed_ms<0||
+    !(result.failure_reason===null||(typeof result.failure_reason==='string'&&result.failure_reason.length>0))||
+    !['PASS','FAILED','OUTCOME_UNKNOWN'].includes(result.status)||
+    (result.status==='PASS'&&(result.timed_out||result.failure_reason!==null||result.exit_code!==0))){
+    faults.push({index:shard.index,reason:'V2_CONTRACT_INVALID'});continue;
+  }
+  if(result.nonpass_cases!==undefined){
+    const cases=result.nonpass_cases;
+    const valid=Array.isArray(cases)&&cases.length<=10000&&
+      cases.every(c=>c&&typeof c==='object'&&!Array.isArray(c)&&
+        ['SKIP','TODO'].includes(c.kind)&&typeof c.name==='string'&&
+        c.name.length>=1&&c.name.length<=256&&!/[\x00-\x1f\x7f-\x9f]/u.test(c.name)&&
+        (c.reason===null||(typeof c.reason==='string'&&c.reason.length>=1&&c.reason.length<=256&&!/[\x00-\x1f\x7f-\x9f]/u.test(c.reason))))&&
+      cases.filter(c=>c.kind==='SKIP').length===result.skipped&&
+      cases.filter(c=>c.kind==='TODO').length===result.todo&&
+      result.nonpass_fully_classified===cases.every(c=>c.reason!==null);
+    if(!valid){faults.push({index:shard.index,reason:'NONPASS_LEDGER_INVALID'});continue;}
+  }
+  if(intent.test_tree_sha256!==testTreeSha||result.source_tree_sha256!==tree.sha256||
+     result.source_file_count!==tree.file_count||
+     result.configured_timeout_ms!==r67ShardTimeoutMs(shard)||
+     intent.plan_sha256!==plan.plan_sha256||intent.files_sha256!==shard.files_sha256){
+    stale.push(shard.index);continue;
+  }
+  // New failure identity extension applies only to current-source receipts; pre-extension
+  // historical v2 receipts stay STALE_SOURCE rather than a fabricated tampering charge.
+  if(result.failure_cases!==undefined||result.failure_cases_complete!==undefined||result.failed>0){
+   const cases=result.failure_cases;
+   const valid=Array.isArray(cases)&&cases.length<=128&&
+     typeof result.failure_cases_complete==='boolean'&&
+     cases.every(c=>c&&typeof c==='object'&&!Array.isArray(c)&&
+       Object.keys(c).sort().join('|')==='name|name_sha256'&&
+       typeof c.name==='string'&&c.name.length>0&&c.name.length<=256&&
+       !/[\x00-\x1f\x7f-\x9f]/u.test(c.name)&&hex(c.name_sha256)&&
+       (c.name==='[redacted]'||sha(Buffer.from(c.name,'utf8'))===c.name_sha256))&&
+     (result.failure_cases_complete?cases.length===result.failed:cases.length<=result.failed);
+   if(!valid){faults.push({index:shard.index,reason:'FAILED_CASE_LEDGER_INVALID'});continue;}
+  }
+  verified.push(result);
+  if(result.status==='OUTCOME_UNKNOWN')unknown.push(shard.index);
+  if(result.skipped>0||result.todo>0||result.cancelled>0){
+   const caseEvidence={index:shard.index,skipped:result.skipped,todo:result.todo,cancelled:result.cancelled,...(Array.isArray(result.nonpass_cases)?{cases:result.nonpass_cases}:{}),...(typeof result.nonpass_fully_classified==='boolean'?{fully_classified:result.nonpass_fully_classified}:{})};
+   if(result.cancelled===0&&result.todo===0&&result.nonpass_fully_classified===true&&
+      Array.isArray(result.nonpass_cases)&&result.nonpass_cases.length===result.skipped&&
+      result.nonpass_cases.every(c=>c.kind==='SKIP'&&typeof c.reason==='string'&&c.reason.trim().length>0))classified.push(caseEvidence);
+   else unclassified.push(caseEvidence);
+  }
+ }
+ const verdict=reconcileR67Shards(plan,verified);
+ const status=faults.length?'FAILED_INTEGRITY':
+  stale.length?'STALE_SOURCE':
+  unknown.length?'OUTCOME_UNKNOWN':
+  verdict.status!=='PASS'?verdict.status:
+  unclassified.length?'BLOCKED_NONPASS_CLASSIFICATION':'PASS';
+ return {
+  schema:'deadbyte.r67-persistent-regression-reconciliation.v2',
+  operation_id:operationId,status,plan_sha256:plan.plan_sha256,
+  test_tree_sha256:testTreeSha,source_tree_sha256:tree.sha256,
+  source_file_count:tree.file_count,test_file_count:plan.file_count,
+  verified_receipts:verified.length,integrity_faults:faults,
+  stale_indices:stale,unknown_indices:unknown,unclassified_nonpass:unclassified,classified_nonpass:classified,
+  verdict,production_mutation_performed:false
+ };
+}

package/src/r67-native-observation-authority.mjs

@@ -0,0 +1,45 @@
+import {createHash} from 'node:crypto';
+import {codingSessionStatus} from './coding-plane.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const hash=s=>createHash('sha256').update(s,'utf8').digest('hex');
+
+/**
+ * A server-owned callback, never a model-supplied permission.
+ * Opt-in is separate from the coding standing grant; every request and its
+ * completion re-reads the live epoch and checks revocation.
+ */
+export function createR67NativeObservationAuthority({
+  getCodingPolicy,
+  enabled=false,
+  sessionStatus=codingSessionStatus,
+  rootId='projects'
+}={}){
+ if(typeof getCodingPolicy!=='function'||typeof sessionStatus!=='function')throw new TypeError('trusted runtime authority providers required');
+ if(typeof enabled!=='boolean')throw new TypeError('native observer opt-in must be boolean');
+ return async ({operation,args}={})=>{
+  if(!enabled)throw new Error('R67_NATIVE_OBSERVATION_DISABLED');
+  if(!['process','identity','map'].includes(operation)||!Array.isArray(args)||args[0]!==operation)
+   throw new Error('R67_NATIVE_OBSERVATION_SCOPE_DENIED');
+  if(operation==='map'&&args[1]!=='self')throw new Error('R67_NATIVE_OBSERVATION_OTHER_PID_DENIED');
+  if(operation==='identity'&&args[1]!=='self')throw new Error('R67_NATIVE_OBSERVATION_OTHER_PID_DENIED');
+  const policy=getCodingPolicy();
+  if(!policy||!HEX64.test(policy.policy_sha256??'')||!policy.roots?.[rootId]?.read)
+   throw new Error('R67_NATIVE_OBSERVATION_POLICY_MISSING');
+  const lease=await sessionStatus(policy);
+  const epoch=lease?.authority_epoch;
+  if(!lease?.armed||lease.standing!==true||lease.reason!=='standing-grant'||
+     !Array.isArray(lease.root_ids)||!lease.root_ids.includes(rootId)||
+     !HEX64.test(lease.instance_nonce??'')||
+     epoch?.trusted!==true||!Number.isSafeInteger(epoch.seq)||epoch.seq<1||
+     !HEX64.test(epoch.event_sha256??''))
+   throw new Error('R67_NATIVE_OBSERVATION_AUTHORITY_REVOKED');
+  const grantId='coding.r67.'+hash(lease.instance_nonce+':'+epoch.event_sha256).slice(0,32);
+  return Object.freeze({
+    grant_id:grantId,
+    policy_sha256:policy.policy_sha256,
+    scope:'native-observe-readonly',
+    authority_generation:epoch.seq
+  });
+ };
+}

package/src/r67-observation-receipt.mjs

@@ -0,0 +1,43 @@
+import {createHash,createPublicKey,sign as edSign} from 'node:crypto';
+
+export const R67_OBSERVATION_DOMAIN=Buffer.from('DEADBYTE-R67-OBSERVATION-V1\0','utf8');
+const isHex64=s=>typeof s==='string'&&/^[a-f0-9]{64}$/.test(s);
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const canonical=value=>JSON.stringify(
+  Array.isArray(value)?value.map(v=>JSON.parse(canonical(v))):
+  value!==null&&typeof value==='object'?
+    Object.fromEntries(Object.keys(value).sort().map(k=>[k,JSON.parse(canonical(value[k]))])):
+    value
+);
+export const hashR67Result=result=>sha(Buffer.from(canonical(result),'utf8'));
+
+export function signR67Observation({privateKey,publicKey,operation,requestSha256,executableSha256,result,observedAtUtc=new Date().toISOString()}){
+  if(!privateKey||!publicKey)throw new Error('R67 receipt signer must be supplied by trusted runtime; no implicit key generation');
+  if(!['process','identity','map','pe'].includes(operation)||!isHex64(requestSha256)||!isHex64(executableSha256))
+    throw new Error('R67 observation operation and 256-bit bindings required');
+  if(!result||result.schema!=='deadbyte.native-inspect.r67.v1'||!['ok','failed'].includes(result.status))
+    throw new Error('R67 result contract invalid');
+  if(result.status==='ok'&&(result.operation!==operation||!isHex64(result.data_sha256)||!result.data||
+    result.data_sha256!==sha(Buffer.from(JSON.stringify(result.data),'utf8'))))throw new Error('R67 result data digest invalid');
+  const timestamp=new Date(observedAtUtc);
+  if(!Number.isFinite(timestamp.getTime())||timestamp.toISOString()!==observedAtUtc)throw new Error('R67 observation timestamp invalid');
+  const key=publicKey?.type==='public'?publicKey:createPublicKey(publicKey);
+  const derived=createPublicKey(privateKey);
+  const spki=Buffer.from(key.export({type:'spki',format:'der'}));
+  const derivedSpki=Buffer.from(derived.export({type:'spki',format:'der'}));
+  if(key.asymmetricKeyType!=='ed25519'||!spki.equals(derivedSpki))throw new Error('R67 signer public/private identity mismatch');
+  const body={
+    schema:'deadbyte.native-observation-receipt.r67.v1',
+    observed_at_utc:observedAtUtc,
+    operation,
+    request_sha256:requestSha256,
+    executable_sha256:executableSha256,
+    result_status:result.status,
+    result_sha256:hashR67Result(result),
+    signer_key_id:sha(spki)
+  };
+  const receipt_sha256=sha(Buffer.from(canonical(body),'utf8'));
+  const signed={...body,receipt_sha256};
+  const signature=edSign(null,Buffer.concat([R67_OBSERVATION_DOMAIN,Buffer.from(canonical(signed),'utf8')]),privateKey);
+  return {...signed,attestation:{algorithm:'ed25519',key_id:body.signer_key_id,signature_base64:signature.toString('base64')}};
+}