deadbyte-mcp 0.15.42 → 0.15.44

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/doctor-runtime-r58.mjs

@@ -28,8 +28,10 @@ export function validateDoctorControllerObservation(value,expectedCoreRoot){
  if(typeof value.supervisor.configured!=='boolean'||typeof value.supervisor.running!=='boolean'||!reason(value.supervisor.reason)||(!value.supervisor.configured&&value.supervisor.running))throw new Error('supervisor observation invalid');
  object(value.authority,['process','coding','autonomous','desktop','host']);
  for(const item of Object.values(value.authority)){
-  object(item,['configured','armed','reason']);
+  const hasEpoch=Object.hasOwn(item,'epoch_seq')||Object.hasOwn(item,'epoch_sha256');
+  object(item,hasEpoch?['configured','armed','reason','epoch_seq','epoch_sha256']:['configured','armed','reason']);
   if(typeof item.configured!=='boolean'||typeof item.armed!=='boolean'||!reason(item.reason)||(!item.configured&&item.armed)||(item.armed&&item.reason!=='standing-grant'))throw new Error('authority observation invalid');
+  if(hasEpoch&&(!item.armed||!Number.isSafeInteger(item.epoch_seq)||item.epoch_seq<1||typeof item.epoch_sha256!=='string'||!/^[0-9a-f]{64}$/.test(item.epoch_sha256)))throw new Error('authority epoch observation invalid');
  }
  return value;
 }

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 {

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};
+}