deadbyte-mcp 0.15.43 → 0.15.45

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-diff-v2.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
-import { assertAutonomousArmed, recheckAutonomousAuthority } from './autonomous-policy.mjs';
+import { assertAutonomousArmed, autonomousSessionStatus, recheckAutonomousAuthority } from './autonomous-policy.mjs';
 
 export const NATIVE_DIFF_V2_SCHEMA='deadbyte.native-diff.v2';
 export const NATIVE_DIFF_V2_PREIMAGE_SCHEMA='deadbyte.native-diff-preimage.v2';
@@ -107,9 +107,16 @@ export function createNativeDiffV2Runtime({policy,codingRuntime,machineFsRuntime
   if(!machineFsRuntime?.state||!machineFsRuntime?.removeEmptyDir) throw new Error('native diff V2 requires machine fs topology runtime');
   if(!signingKeyPath||!verifyKeyPath) throw new Error('native diff V2 requires trust keys');
 
-  async function materializeOperations(rootId,rawOperations){
-    if(!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
-    await assertAutonomousArmed(policy,rootId);
+  async function materializeOperations(rootId,rawOperations,{codingOnly=false}={}){
+    if(codingOnly){
+      const lease=await codingRuntime.sessionStatus();
+      if(!lease.armed) throw new Error(`coding plane is disarmed: ${lease.reason}`);
+      if(!lease.root_ids.includes(rootId)||codingRuntime.policy.roots[rootId]?.read!==true)
+        throw new Error(`native diff preview root '${rootId}' is not allowed by Coding lease`);
+    } else {
+      if(!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
+      await assertAutonomousArmed(policy,rootId);
+    }
     const {normalized,payloadBytes}=normalizeRawOperations(rawOperations,policy);
     const operations=[];
     for(const op of normalized){
@@ -168,7 +175,13 @@ export function createNativeDiffV2Runtime({policy,codingRuntime,machineFsRuntime
   async function preview({rootId,operations:rawOperations,title='',applicationScope=null}){
     if(typeof title!=='string'||title.length>160) throw new Error('native diff title must be <=160 characters');
     if(applicationScope!==null&&!SHA256_RE.test(applicationScope)) throw new Error('native diff application_scope must be SHA-256 or null');
-    const {operations,payloadBytes}=await materializeOperations(rootId,rawOperations);
+    const autonomous=policy.root_ids.includes(rootId)?await autonomousSessionStatus(policy):null;
+    const codingOnly=autonomous?.armed!==true||!autonomous.root_ids?.includes(rootId);
+    const {operations,payloadBytes}=await materializeOperations(rootId,rawOperations,{codingOnly});
+    if(codingOnly) return {status:'preview_only',schema:NATIVE_DIFF_V2_SCHEMA,root_id:rootId,
+      operation_count:operations.length,payload_bytes:payloadBytes,
+      paths:operations.map(op=>op.path??op.source_path),
+      operations:operations.map(({content,old_string,new_string,...op})=>op)};
     const identity={schema:NATIVE_DIFF_V2_SCHEMA,policy_sha256:policy.policy_sha256,coding_policy_sha256:policy.coding_policy_sha256,root_id:rootId,title,operations,...(applicationScope===null?{}:{application_scope:applicationScope})};
     const diffId=sha256Object(identity); const ctx=diffContext(policy,diffId); const signing=await loadPrivateSigningKey(signingKeyPath);
     const envelope=signEnvelope(signing,DIFF_DOMAIN,{...identity,diff_id:diffId,created_at_utc:new Date().toISOString()});

package/src/native-diff.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
-import { assertAutonomousArmed, recheckAutonomousAuthority } from './autonomous-policy.mjs';
+import { assertAutonomousArmed, autonomousSessionStatus, recheckAutonomousAuthority } from './autonomous-policy.mjs';
 import { createNativeDiffV2Runtime, NATIVE_DIFF_V2_SCHEMA } from './native-diff-v2.mjs';
 
 export const NATIVE_DIFF_SCHEMA = 'deadbyte.native-diff.v1';
@@ -102,9 +102,19 @@ function createNativeDiffRuntimeV1({ policy, codingRuntime, signingKeyPath, veri
   if (!policy || !codingRuntime?.policy) throw new Error('native diff runtime requires autonomous and coding policy');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('native diff runtime requires trust keys');
 
-  async function materializeOperations(rootId, rawOperations) {
-    if (!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
-    await assertAutonomousArmed(policy, rootId);
+  async function materializeOperations(rootId, rawOperations, {codingOnly=false} = {}) {
+    if (codingOnly) {
+      // Preview authorization delegates ONLY to the existing, locally armed
+      // Coding read lease. No Autonomous grant, signer, or target mutation.
+      const lease=await codingRuntime.sessionStatus();
+      if (!lease.armed) throw new Error(`coding plane is disarmed: ${lease.reason}`);
+      if (!lease.root_ids.includes(rootId) || codingRuntime.policy.roots[rootId]?.read !== true) {
+        throw new Error(`native diff preview root '${rootId}' is not allowed by Coding lease`);
+      }
+    } else {
+      if (!policy.root_ids.includes(rootId)) throw new Error(`native diff root '${rootId}' is not allowed`);
+      await assertAutonomousArmed(policy, rootId);
+    }
     const { normalized, payloadBytes } = normalizeRawOperations(rawOperations, policy);
     const operations = [];
     for (const op of normalized) {
@@ -132,7 +142,13 @@ function createNativeDiffRuntimeV1({ policy, codingRuntime, signingKeyPath, veri
   async function preview({ rootId, operations:rawOperations, title = '', applicationScope = null }) {
     if (typeof title !== 'string' || title.length > 160) throw new Error('native diff title must be <=160 characters');
     if (applicationScope !== null && !SHA256_RE.test(applicationScope)) throw new Error('native diff application_scope must be SHA-256 or null');
-    const { operations, payloadBytes } = await materializeOperations(rootId, rawOperations);
+    const autonomous=policy.root_ids.includes(rootId)?await autonomousSessionStatus(policy):null;
+    const codingOnly=autonomous?.armed!==true||!autonomous.root_ids?.includes(rootId);
+    const { operations, payloadBytes } = await materializeOperations(rootId, rawOperations, {codingOnly});
+    if (codingOnly) return {status:'preview_only',schema:NATIVE_DIFF_SCHEMA,root_id:rootId,
+      operation_count:operations.length,payload_bytes:payloadBytes,
+      paths:operations.map(op=>op.path),
+      operations:operations.map(({content,old_string,new_string,...op})=>op)};
     const identity = { schema:NATIVE_DIFF_SCHEMA, policy_sha256:policy.policy_sha256,
       coding_policy_sha256:policy.coding_policy_sha256, root_id:rootId, title, operations,
       ...(applicationScope === null ? {} : { application_scope:applicationScope }) };

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