deadbyte-mcp 0.15.1 → 0.15.2

package/src/release-generation.mjs

@@ -105,7 +105,7 @@ function rebindHostPolicy(raw,{developmentRoot,stateRoot}){
   return policy;
 }
 
-async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot}){
+async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot,systemRoot}){
   if(!raw) return null;
   const policy=clone(raw);
   policy.grant_file=path.join(stateRoot,'runtime','process-grant.json');
@@ -116,6 +116,25 @@ async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot}){
   const nativeHostStat=await lstat(nativeHostPath);
   if(!nativeHostStat.isFile()||nativeHostStat.isSymbolicLink()) throw new Error('process native host invalid in release slot');
   policy.native_host={path:nativeHostPath,sha256:sha256(await readFile(nativeHostPath))};
+
+  const systemProfiles=[
+    ['ping_hold',['System32','cmd.exe']],
+    ['powershell',['System32','WindowsPowerShell','v1.0','powershell.exe']],
+    ['powershell_repl',['System32','WindowsPowerShell','v1.0','powershell.exe']]
+  ];
+  const needsSystemRoot=systemProfiles.some(([id])=>policy.profiles?.[id]);
+  if(needsSystemRoot&&(typeof systemRoot!=='string'||systemRoot.length<1)) {
+    throw new Error('process system profiles require SystemRoot/WINDIR');
+  }
+  for(const [id,parts] of systemProfiles){
+    const profile=policy.profiles?.[id];
+    if(!profile) continue;
+    const executable=path.join(path.resolve(systemRoot),...parts);
+    const stat=await lstat(executable);
+    if(!stat.isFile()||stat.isSymbolicLink()) throw new Error(`process profile '${id}' system executable invalid`);
+    profile.executable=executable;
+    profile.executable_sha256=sha256(await readFile(executable));
+  }
   return policy;
 }
 
@@ -199,7 +218,7 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     '}',''
   ].join('\r\n');
 }
-export async function createGenerationBundle({stateRoot,releaseRoot,developmentRoot,workspaceRoot,releaseId,currentConfig,processPolicy,desktopPolicy,codingPolicy,autonomousPolicy,hostPolicy}){
+export async function createGenerationBundle({stateRoot,releaseRoot,developmentRoot,workspaceRoot,releaseId,currentConfig,processPolicy,desktopPolicy,codingPolicy,autonomousPolicy,hostPolicy,systemRoot=process.env.SystemRoot??process.env.WINDIR??null}){
   const state=path.resolve(stateRoot),release=path.resolve(releaseRoot),development=path.resolve(developmentRoot),workspace=path.resolve(workspaceRoot);
   if(typeof releaseId!=='string'||!/^[A-Za-z0-9._-]{1,96}$/.test(releaseId)) throw new Error('generation release id invalid');
   if(typeof currentConfig?.Bridge?.FileSha256!=='string'||!HEX64.test(currentConfig.Bridge.FileSha256)) throw new Error('generation Bridge FileSha256 invalid');
@@ -255,7 +274,7 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const autonomousBytes=jsonBytes(autonomous);
   const host=rebindHostPolicy(hostPolicy,{developmentRoot:development,stateRoot:state});
   const hostBytes=host?jsonBytes(host):null;
-  const processBound=await rebindProcessPolicy(processPolicy,{developmentRoot:development,stateRoot:state,releaseRoot:release});
+  const processBound=await rebindProcessPolicy(processPolicy,{developmentRoot:development,stateRoot:state,releaseRoot:release,systemRoot});
   const processBytes=processBound?jsonBytes(processBound):null;
   const desktopBound=await rebindDesktopPolicy(desktopPolicy,{stateRoot:state,releaseRoot:release});
   const desktopBytes=desktopBound?jsonBytes(desktopBound):null;

package/src/remote-device-r44.mjs

@@ -57,19 +57,34 @@ function parseDeviceKey(spki){
   insist(key.asymmetricKeyType==='ed25519','remote device key must be Ed25519');
   return {deviceId:sha(der),spki};
 }
-function publicDevice(d){
+function publicDevice(d,reachableTtlMs=Infinity){
+  const lastOk=typeof d.last_probe_ok_at_utc==='string'?Date.parse(d.last_probe_ok_at_utc):NaN;
+  const fresh=d.reachable===true&&(reachableTtlMs===Infinity||(Number.isFinite(lastOk)&&Date.now()-lastOk<=reachableTtlMs));
   return {device_id:d.device_id,display_name:d.display_name,epoch:d.epoch,revoked:d.revoked,
-    reported_online:d.reported_online,reachable:d.reachable,connection_id:d.connection_id,updated_at_utc:d.updated_at_utc};
+    reported_online:d.reported_online,reachable:fresh,connection_id:d.connection_id,
+    last_probe_ok_at_utc:d.last_probe_ok_at_utc??null,updated_at_utc:d.updated_at_utc};
+}
+async function withTimeout(operation,timeoutMs,label){
+  let timer;
+  try{
+    return await Promise.race([
+      Promise.resolve().then(operation),
+      new Promise((_,reject)=>{timer=setTimeout(()=>reject(new Error(`${label} timed out after ${timeoutMs}ms`)),timeoutMs);timer.unref?.();})
+    ]);
+  }finally{if(timer)clearTimeout(timer);}
 }
 function payloadHash({deviceId,epoch,capabilityId,payload}){
   return sha(Buffer.from(canonicalJson({device_id:deviceId,epoch,capability_id:capabilityId,payload}),'utf8'));
 }
 
-export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapability,onCredentialSuperseded=null}={}){
+export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapability,onCredentialSuperseded=null,relayTimeoutMs=15000,probeRetries=1,reachableTtlMs=75000}={}){
   insist(typeof stateDir==='string'&&path.isAbsolute(stateDir),'remote stateDir must be absolute');
   insist(relay&&typeof relay.probe==='function'&&typeof relay.request==='function','remote relay contract invalid');
   insist(typeof authorizeCapability==='function','remote capability authorizer required');
   insist(onCredentialSuperseded===null||typeof onCredentialSuperseded==='function','remote credential supersede callback invalid');
+  insist(Number.isInteger(relayTimeoutMs)&&relayTimeoutMs>=100&&relayTimeoutMs<=120000,'remote relayTimeoutMs invalid');
+  insist(Number.isInteger(probeRetries)&&probeRetries>=0&&probeRetries<=3,'remote probeRetries invalid');
+  insist(Number.isInteger(reachableTtlMs)&&reachableTtlMs>=1000&&reachableTtlMs<=10*60*1000,'remote reachableTtlMs invalid');
   await mkdir(stateDir,{recursive:true});const root=await realpath(stateDir);
   const stateFile=path.join(root,'remote-devices.json'),credentialsDir=path.join(root,'credentials');
   await mkdir(credentialsDir,{recursive:true});
@@ -79,6 +94,8 @@ export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapabi
     const run=lock.then(fn,fn);lock=run.catch(()=>{});return run;
   };
   const persist=()=>{state.updated_at_utc=now();return atomicJson(stateFile,state);};
+  const pub=d=>publicDevice(d,reachableTtlMs);
+  const fresh=d=>pub(d).reachable;
   const getDevice=(deviceId,epoch=null)=>{
     insist(HEX64.test(deviceId??''),'device id invalid');
     const d=state.devices[deviceId];insist(d,'unknown remote device');
@@ -95,21 +112,21 @@ export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapabi
       if(existing){
         insist(!existing.revoked,'remote device revoked');
         insist(existing.public_key_spki_base64===spki,'remote device key drift');
-        return publicDevice(existing);
+        return pub(existing);
       }
       const d={device_id:deviceId,public_key_spki_base64:spki,display_name:displayName,epoch:1,revoked:false,
         reported_online:false,reachable:false,connection_id:null,last_probe_nonce:null,updated_at_utc:now()};
-      state.devices[deviceId]=d;await persist();return publicDevice(d);
+      state.devices[deviceId]=d;await persist();return pub(d);
     });
   }
   async function status({deviceId}={}){
-    const d=getDevice(deviceId);return publicDevice(d);
+    const d=getDevice(deviceId);return pub(d);
   }
   async function reportOnline({deviceId,epoch,connectionId}={}){
     insist(typeof connectionId==='string'&&connectionId.length>=1&&connectionId.length<=256,'connection id invalid');
     return withLock(async()=>{
       const d=getDevice(deviceId,epoch);d.reported_online=true;d.reachable=false;d.connection_id=connectionId;
-      d.last_probe_nonce=null;d.updated_at_utc=now();await persist();return publicDevice(d);
+      d.last_probe_nonce=null;d.updated_at_utc=now();await persist();return pub(d);
     });
   }
   async function probe({deviceId,epoch}={}){
@@ -119,12 +136,25 @@ export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapabi
       const d=getDevice(deviceId,epoch);insist(d.reported_online&&d.connection_id,'remote device is not reported online');
       connectionId=d.connection_id;d.reachable=false;d.last_probe_nonce=nonce;d.updated_at_utc=now();await persist();
     });
-    const response=await relay.probe({device_id:deviceId,epoch,connection_id:connectionId,nonce});
+    let response=null,lastError=null;
+    for(let attempt=0;attempt<=probeRetries;attempt+=1){
+      try{
+        response=await withTimeout(
+          ()=>relay.probe({device_id:deviceId,epoch,connection_id:connectionId,nonce}),
+          relayTimeoutMs,'remote readiness probe'
+        );
+        lastError=null;break;
+      }catch(error){lastError=error;}
+    }
+    if(lastError){
+      await withLock(async()=>{const d=getDevice(deviceId,epoch);if(d.connection_id===connectionId){d.reachable=false;d.updated_at_utc=now();await persist();}});
+      throw lastError;
+    }
     return withLock(async()=>{
       const d=getDevice(deviceId,epoch);
       insist(response&&response.device_id===deviceId&&response.epoch===epoch&&response.nonce===nonce&&response.ready===true,'remote readiness probe acknowledgment invalid');
       insist(d.connection_id===connectionId&&d.last_probe_nonce===nonce,'remote connection changed during readiness probe');
-      d.reachable=true;d.updated_at_utc=now();await persist();return {...publicDevice(d),probe_nonce:nonce};
+      d.reachable=true;d.last_probe_ok_at_utc=now();d.updated_at_utc=now();await persist();return {...pub(d),probe_nonce:nonce};
     });
   }
   async function dispatch({deviceId,epoch,capabilityId,payload={},requestId}={}){
@@ -141,7 +171,7 @@ export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapabi
     const allowed=await authorizeCapability({deviceId,epoch,capabilityId});
     insist(allowed===true,'remote capability denied by local policy');
     await withLock(async()=>{
-      const d=getDevice(deviceId,epoch);insist(d.reported_online&&d.reachable,'remote device not reachable');
+      const d=getDevice(deviceId,epoch);insist(d.reported_online&&fresh(d),'remote device not reachable or readiness probe is stale');
       const again=state.requests[requestId];
       if(again){insist(again.request_sha256===requestSha,'remote request id conflict');return;}
       state.requests[requestId]={request_id:requestId,request_sha256:requestSha,device_id:deviceId,epoch,capability_id:capabilityId,
@@ -150,9 +180,17 @@ export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapabi
     });
     if(state.requests[requestId].state!=='accepted')return {...structuredClone(state.requests[requestId]),replay:true};
     let response=null;
-    try{response=await relay.request({device_id:deviceId,epoch,capability_id:capabilityId,payload,request_id:requestId,request_sha256:requestSha});}
-    catch(error){
-      return withLock(async()=>{const rec=state.requests[requestId];rec.state='failed';rec.error_code='transport_error';rec.error=String(error?.message??error);rec.updated_at_utc=now();await persist();return structuredClone(rec);});
+    try{
+      response=await withTimeout(
+        ()=>relay.request({device_id:deviceId,epoch,capability_id:capabilityId,payload,request_id:requestId,request_sha256:requestSha}),
+        relayTimeoutMs,'remote dispatch'
+      );
+    }catch(error){
+      return withLock(async()=>{
+        const rec=state.requests[requestId];rec.state='failed';rec.error_code='transport_error';rec.error=String(error?.message??error);rec.updated_at_utc=now();
+        const d=state.devices[deviceId];if(d&&d.epoch===epoch){d.reachable=false;d.updated_at_utc=now();}
+        await persist();return structuredClone(rec);
+      });
     }
     if(!response||response.ack!=='accepted'||response.request_id!==requestId){
       return withLock(async()=>{const rec=state.requests[requestId];rec.state='failed';rec.error_code='transport_no_ack';rec.updated_at_utc=now();await persist();return structuredClone(rec);});
@@ -172,7 +210,7 @@ export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapabi
   async function revoke({deviceId,epoch}={}){
     return withLock(async()=>{
       const d=getDevice(deviceId,epoch);d.revoked=true;d.reported_online=false;d.reachable=false;d.connection_id=null;d.updated_at_utc=now();await persist();
-      return {...publicDevice(d),revoked:true};
+      return {...pub(d),revoked:true};
     });
   }
   async function rotateCredential({deviceId,epoch,encryptedBundleBase64,expectedPreviousSha256}={}){
@@ -200,6 +238,6 @@ export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapabi
     }
     return {status:'committed',device_id:deviceId,epoch,credential_sha256:credentialSha,previous_credential_sha256:previous?.credential_sha256??null};
   }
-  async function list(){return {status:'ok',devices:Object.values(state.devices).map(publicDevice).sort((a,b)=>a.device_id.localeCompare(b.device_id)),requests:structuredClone(state.requests)};}
+  async function list(){return {status:'ok',devices:Object.values(state.devices).map(pub).sort((a,b)=>a.device_id.localeCompare(b.device_id)),requests:structuredClone(state.requests)};}
   return Object.freeze({pair,status,reportOnline,probe,dispatch,revoke,rotateCredential,list,state_file:stateFile});
 }

package/src/remote-mcp-smoke-client.mjs

@@ -13,7 +13,7 @@ const privilegedTools = ['host_exec', 'host_file_read', 'host_file_write'];
 const machineTools = ['machine_list', 'machine_ping', 'machine_revoke', 'machine_status'];
 const processTools = [
   'process_session_action', 'process_session_list', 'process_session_read', 'process_session_start',
-  'process_session_status', 'process_session_terminate'
+  'process_session_status', 'process_session_terminate', 'process_session_write'
 ];
 const machineFsTools = [
   'machine_fs_delete', 'machine_fs_edit_exact', 'machine_fs_list', 'machine_fs_mkdir',

package/src/stdio-console-guard.mjs

@@ -0,0 +1,24 @@
+import { format } from 'node:util';
+
+export function installStdioConsoleGuard({ stderr = process.stderr } = {}) {
+  if (!stderr || typeof stderr.write !== 'function') throw new Error('stdio console guard requires writable stderr');
+  const original = {
+    log: console.log,
+    info: console.info,
+    debug: console.debug
+  };
+  const write = (level, args) => {
+    const text = format(...args);
+    stderr.write(`DEADBYTE MCP ${level.toUpperCase()} ${text}${text.endsWith('\n') ? '' : '\n'}`);
+  };
+  console.log = (...args) => write('log', args);
+  console.info = (...args) => write('info', args);
+  console.debug = (...args) => write('debug', args);
+  return Object.freeze({
+    restore() {
+      console.log = original.log;
+      console.info = original.info;
+      console.debug = original.debug;
+    }
+  });
+}

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.1';
+export const DEADBYTE_VERSION = '0.15.2';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/cli-entrypoint.test.mjs

@@ -21,7 +21,7 @@ test('npx CLI reports the canonical package version through --version, -v and ve
   for(const arg of ['--version','-v','version']){
     const result=spawnSync(process.execPath,[cliPath,arg],{cwd:root,encoding:'utf8',windowsHide:true});
     assert.equal(result.status,0,result.stderr);
-    assert.equal(result.stdout.trim(),'0.15.1');
+    assert.equal(result.stdout.trim(),'0.15.2');
   }
 });
 
@@ -50,6 +50,6 @@ test('npx CLI exposes local supervisor lifecycle without any supervisor arm comm
 
 test('README makes npx the primary operator UX',async()=>{
   const readme=await readFile(path.join(root,'README.txt'),'utf8');
-  assert.match(readme,/npx -y deadbyte-mcp@0\.15\.1 remote/);
-  assert.match(readme,/npx -y deadbyte-mcp@0\.15\.1 audit verify/);
+  assert.match(readme,/npx -y deadbyte-mcp@0\.15\.2 remote/);
+  assert.match(readme,/npx -y deadbyte-mcp@0\.15\.2 audit verify/);
 });

package/test/compact-gateway-r36.test.mjs

@@ -24,6 +24,8 @@ test('R36 compact gateway schemas reject generic arbitrary dispatch',()=>{
   assert.equal(codingInspectInputSchema.safeParse({op:'call',tool_name:'host_exec',args:{}}).success,false);
   assert.equal(machineFsGatewayInputSchema.safeParse({op:'exec',command:'whoami'}).success,false);
   assert.equal(processSessionGatewayInputSchema.safeParse({op:'stdin',session_id:'0'.repeat(64),input:'raw'}).success,false);
+  assert.equal(processSessionGatewayInputSchema.safeParse({op:'write',session_id:'0'.repeat(64),input:'raw',append_newline:true}).success,true);
+  assert.equal(processSessionGatewayInputSchema.safeParse({op:'write',session_id:'0'.repeat(64),input:'raw',pid:1234}).success,false);
   assert.equal(machineObserveInputSchema.safeParse({op:'revoke',reason:'no'}).success,false);
   assert.equal(desktopControlInputSchema.safeParse({op:'call',tool_name:'host_exec'}).success,false);
 });
@@ -36,6 +38,7 @@ test('R36 compact schemas preserve representative preconditions',()=>{
     op:'move',root_id:'core',source_path:'a.txt',destination_path:'b.txt'
   }).success,false);
   assert.equal(processSessionGatewayInputSchema.safeParse({op:'action',session_id:'b'.repeat(64),action_id:'ping'}).success,true);
+  assert.equal(processSessionGatewayInputSchema.safeParse({op:'read',session_id:'b'.repeat(64),offset:-4096,max_bytes:4096,wait_ms:5000,wait_for:'READY>'}).success,true);
 });
 
 test('R40 registers exactly six compact gateway names including desktop_control',()=>{
@@ -116,3 +119,28 @@ test('R40 desktop_control is stable when runtime is absent and routes typed read
   assert.equal(unavailable.isError,true);
   assert.equal(unavailable.structuredContent.status,'unavailable');
 });
+
+
+test('R46 compact process_session routes guarded write and wait/tail read without adding a tool name',async()=>{
+  const calls=[];
+  const processRuntime={
+    write:async args=>{calls.push(['write',args]);return {logical_bytes:4,logical_sha256:'d'.repeat(64),append_newline:true,session:{session_id:'a'.repeat(64)}};},
+    read:async args=>{calls.push(['read',args]);return {session_id:'a'.repeat(64),offset:0,next_offset:0,earliest_offset:0,stream_head:0,stream_sha256:'b'.repeat(64),truncated:false,wait_satisfied:true,data_base64:'',state:'running',exit_code:null};}
+  };
+  const server=fakeServer();
+  registerCompactGatewayTools(server,{
+    profile:'compact',ledger:{schema:'deadbyte.capability-ledger.v1',entries:[],ledger_sha256:'0'.repeat(64)},
+    codingRuntime:null,semanticRuntime:null,machineFsRuntime:null,processRuntime,observationRuntime:null,machineRuntime:null,desktopRuntime:null,
+    catalogProvider:()=>[...server.tools.keys()]
+  });
+  const tool=server.tools.get('process_session');
+  const wrote=await tool.handler({op:'write',session_id:'a'.repeat(64),input:'x=1',append_newline:true});
+  assert.equal(wrote.isError,false);
+  const read=await tool.handler({op:'read',session_id:'a'.repeat(64),offset:-1024,max_bytes:4096,wait_ms:250,wait_for:'done'});
+  assert.equal(read.isError,false);
+  assert.deepEqual(calls,[
+    ['write',{sessionId:'a'.repeat(64),input:'x=1',appendNewline:true}],
+    ['read',{sessionId:'a'.repeat(64),offset:-1024,maxBytes:4096,waitMs:250,waitFor:'done'}]
+  ]);
+  assert.equal(server.tools.size,6);
+});

package/test/core.test.mjs

@@ -105,7 +105,7 @@ test('proof execution creates deterministic output and signed verifiable receipt
   assert.equal(result.receipt.request.schema, 'deadbyte.request.v1');
   assert.match(result.receipt.request.nonce, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.request.sha256, /^[0-9a-f]{64}$/);
-  assert.equal(result.receipt.runtime.package_version, '0.15.1');
+  assert.equal(result.receipt.runtime.package_version, '0.15.2');
   assert.match(result.receipt.runtime.mcp_ingress_adapter, /^(?:none|tunnel-stdio-probe-compat-v1)$/);
   assert.match(result.receipt.runtime.mcp_ingress_adapter_sha256, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.runtime.mcp_ingress_mode_source_sha256, /^[0-9a-f]{64}$/);

package/test/full-max-catalog-r46.test.mjs

@@ -0,0 +1,92 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy.json');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
+
+test('R46 real max-runtime full stdio catalog is exactly 83 with skill and four Desktop primitives while authority remains disarmed',async()=>{
+  const f=await createR34Fixture({authority:'disarmed'});
+  const processPolicyPath=path.join(f.root,'process-policy.json');
+  const processGrant=path.join(f.root,'process-grant.json');
+  const processState=path.join(f.root,'process-state');
+  const hostPolicyPath=path.join(f.root,'host-policy.json');
+  const hostArm=path.join(f.root,'host-arm.json');
+  const nodeSha=sha(await readFile(process.execPath));
+  await mkdir(processState,{recursive:true});
+  await writeFile(processPolicyPath,JSON.stringify({
+    schema:'deadbyte.process-policy.v1',enabled:true,grant_file:processGrant,state_dir:processState,
+    native_host:{path:process.execPath,sha256:nodeSha},
+    roots:{core:{path:f.project,deny_paths:[]}},
+    profiles:{node:{executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],
+      prefix_args:[],transport:'pipe',max_args:8,max_arg_bytes:1024,max_sessions:2,
+      max_input_bytes:65536,max_retained_output_bytes:262144,env_allow:['PATH','TEMP','TMP'],
+      input_actions:{ping:'PING\r\n'}}}
+  },null,2));
+  await writeFile(hostPolicyPath,JSON.stringify({
+    schema:'deadbyte.host-policy.v1',enabled:true,arm_file:hostArm,max_read_bytes:262144,max_write_bytes:1048576,
+    roots:{core:{path:f.project,read:true,write:true,exec:true}},
+    commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:nodeSha,
+      root_ids:['core'],prefix_args:[],extensions:['.mjs'],timeout_ms:5000,max_output_bytes:65536}}
+  },null,2));
+
+  const desktopRaw=JSON.parse(await readFile(desktopPolicyPath,'utf8'));
+  const desktopGrant=desktopRaw.grant_file;
+  const codingLease=f.codingPolicy.lease_file;
+  const autonomousLease=f.policy.lease_file;
+  for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority unexpectedly armed before start: '+q);
+
+  const client=new Client({name:'deadbyte-r46-full-catalog',version:'0.15.2'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const env={
+    ...getDefaultEnvironment(),
+    DEADBYTE_CAPABILITY_PROFILE:'full',
+    DEADBYTE_AUDIT_RUNTIME:'0',
+    DEADBYTE_STATE_ROOT:path.join(f.root,'state'),
+    DEADBYTE_WORKSPACE_ROOT:f.root,
+    DEADBYTE_SIGNING_KEY:f.keys.privateKeyPath,
+    DEADBYTE_VERIFY_KEY:f.keys.publicKeyPath,
+    DEADBYTE_PRIVILEGED_POLICY:hostPolicyPath,
+    DEADBYTE_MACHINE_RUNTIME:'1',
+    DEADBYTE_AGENT_RUNTIME:'1',
+    DEADBYTE_PROCESS_RUNTIME:'1',
+    DEADBYTE_PROCESS_POLICY:processPolicyPath,
+    DEADBYTE_CODING_RUNTIME:'1',
+    DEADBYTE_CODING_POLICY:path.join(f.root,'coding-policy.json'),
+    DEADBYTE_MACHINE_FS_RUNTIME:'1',
+    DEADBYTE_OBSERVATION_RUNTIME:'1',
+    DEADBYTE_DESKTOP_RUNTIME:'1',
+    DEADBYTE_DESKTOP_POLICY:desktopPolicyPath,
+    DEADBYTE_AUTONOMOUS_RUNTIME:'1',
+    DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
+    DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
+  };
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(t=>t.name).sort();
+    const {R45_EXPECTED_TOOLS}=await import('../src/remote-mcp-r45-parity-client.mjs');
+    const R46_EXPECTED_TOOLS=[...R45_EXPECTED_TOOLS,'process_session_write'].sort();
+    assert.equal(names.length,83,'expected exact full R46 catalog 83, got '+names.length+': '+names.join(','));
+    assert.deepEqual(names,R46_EXPECTED_TOOLS);
+    for(const name of ['machine_hardware_query','desktop_status','desktop_observe','desktop_target','desktop_action',
+      'host_file_read','host_file_write','host_exec','skill_catalog']) assert.ok(names.includes(name),'missing '+name);
+    for(const tool of listed.tools) assert.equal(tool.outputSchema?.additionalProperties,false,'non-strict output '+tool.name);
+    const catalog_sha256=sha(Buffer.from(JSON.stringify(names),'utf8'));
+    console.log(JSON.stringify({tool_count:names.length,catalog_sha256,desktop_tools:4,skill:true,authority:'DISARMED'}));
+  } finally {
+    await client.close().catch(()=>{});
+    for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority file appeared during catalog probe: '+q);
+    await f.cleanup();
+  }
+});

package/test/machine-fs-mcp-tools.test.mjs

@@ -11,7 +11,7 @@ function runtime() {
   return {
     stat: async () => ({ status:'ok', root_id:'core', path:'a.txt', kind:'file', bytes:1, mtime_utc:new Date(0).toISOString(), sha256:hex('a'), identity_sha256:hex('b') }),
     list: async () => ({ status:'ok', root_id:'core', path:'.', entries:[], next_cursor:null }),
-    read: async () => ({ status:'ok', root_id:'core', path:'a.txt', offset:0, next_offset:1, file_size:1, eof:true, data_base64:'YQ==', data_sha256:hex('a'), file_sha256:hex('a') }),
+    read: async () => ({ status:'ok', root_id:'core', path:'a.txt', offset:0, next_offset:1, file_size:1, eof:true, data_base64:'YQ==', data_sha256:hex('a'), file_sha256:hex('a'), timeout_ms:30000 }),
     write: async () => ({ status:'committed', root_id:'core', path:'a.txt', previous_sha256:null, sha256:hex('a'), bytes:1, created:true, receipt_id:'a'.repeat(24), receipt_sha256:hex('b'), request_sha256:hex('c') }),
     editExact: async () => ({ status:'committed', root_id:'core', path:'a.txt', previous_sha256:hex('a'), sha256:hex('b'), bytes:1, replacements:1, receipt_id:'a'.repeat(24), receipt_sha256:hex('b'), request_sha256:hex('c') }),
     mkdir: async () => ({ status:'committed', root_id:'core', path:'d', identity_sha256:hex('a'), receipt_id:'a'.repeat(24), receipt_sha256:hex('b'), request_sha256:hex('c') }),
@@ -35,6 +35,9 @@ test('R31 registers exactly eight bounded machine filesystem tools', () => {
 test('R31 machine filesystem schemas expose root-relative IDs/preconditions only', () => {
   const server = new FakeServer();
   registerMachineFsTools(server, { runtime: runtime() });
+  const read = server.tools.get('machine_fs_read').spec.inputSchema;
+  assert.equal(read.safeParse({ root_id:'core', path:'a.txt', offset:0, max_bytes:65536, hash_file:false, timeout_ms:30000 }).success, true);
+  assert.equal(read.safeParse({ root_id:'core', path:'a.txt', timeout_ms:99 }).success, false);
   const write = server.tools.get('machine_fs_write').spec.inputSchema;
   const move = server.tools.get('machine_fs_move').spec.inputSchema;
   const del = server.tools.get('machine_fs_delete').spec.inputSchema;

package/test/machine-fs-runtime.test.mjs

@@ -10,7 +10,7 @@ import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machi
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
-async function fixture() {
+async function fixture({ readWorkerPath = undefined } = {}) {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-machine-fs-'));
   const project = path.join(root, 'project');
   await mkdir(project);
@@ -30,7 +30,7 @@ async function fixture() {
     privateKeyPath: path.join(root, 'private.pem'), publicKeyPath: path.join(root, 'public.pem')
   });
   const runtime = createMachineFsRuntime({
-    policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath
+    policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath, readWorkerPath
   });
   return { root, project, policy, keys, runtime };
 }
@@ -52,6 +52,7 @@ test('R31 machine fs supports exact mkdir/write/stat/list/range-read/edit/move/d
   const read = await f.runtime.read({ rootId: 'project', relativePath: 'dir/a.txt', offset: 6, maxBytes: 4 });
   assert.equal(Buffer.from(read.data_base64, 'base64').toString('utf8'), 'beta');
   assert.equal(read.next_offset, 10);
+  assert.equal(read.timeout_ms, 30000);
   const edited = await f.runtime.editExact({
     rootId: 'project', relativePath: 'dir/a.txt', expectedSha256: written.sha256,
     oldString: 'beta', newString: 'BETA', expectedReplacements: 1
@@ -103,3 +104,18 @@ test('R31 machine fs fails closed on traversal, denied paths and stale source id
   assert.equal(verified.signature_valid, true);
   assert.equal(verified.operation, 'machine_fs_mkdir');
 });
+
+
+test('R46 machine fs read timeout kills a hung read worker instead of abandoning live I/O', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-machine-fs-hang-worker-'));
+  const worker = path.join(root, 'hang-worker.mjs');
+  await writeFile(worker, "setInterval(()=>{},1000);\n");
+  const f = await fixture({ readWorkerPath: worker });
+  await writeFile(path.join(f.project, 'hang.txt'), 'never read');
+  const started = Date.now();
+  await assert.rejects(
+    () => f.runtime.read({ rootId:'project', relativePath:'hang.txt', offset:0, maxBytes:16, timeoutMs:100 }),
+    /timed out after 100ms/
+  );
+  assert.ok(Date.now() - started < 3000, 'hung worker was not terminated promptly');
+});

package/test/observation-runtime.test.mjs

@@ -7,7 +7,7 @@ import { generateTrustKeypair } from '../src/trust.mjs';
 import { loadCodingPolicy } from '../src/coding-plane.mjs';
 import { createObservationRuntime, verifyObservationReceiptFile } from '../src/observation-runtime.mjs';
 
-async function fixture() {
+async function fixture(runtimeOptions={}) {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-observation-'));
   const project = path.join(root, 'project');
   await mkdir(project); await mkdir(path.join(project, 'blocked'));
@@ -36,7 +36,8 @@ async function fixture() {
   const runtime = createObservationRuntime({
     policy, signingKeyPath:keys.privateKeyPath, verifyKeyPath:keys.publicKeyPath,
     processRuntime, stateRoot:root, processSnapshotProvider, systemSnapshotProvider,
-    ownedRuntimePidProvider: async () => new Set([111])
+    ownedRuntimePidProvider: async () => new Set([111]),
+    ...runtimeOptions
   });
   return { root, project, policy, keys, runtime, getProcessCalls:() => processCalls };
 }
@@ -121,3 +122,29 @@ test('R32 system observation is timestamped and signed without mutation authorit
   assert.equal(verified.ok,true);
   assert.equal(verified.result_head_sha256,status.result_head_sha256);
 });
+
+
+test('R46 observation search sessions expire after bounded terminal TTL and free capacity', async () => {
+  let now=1000;
+  const f=await fixture({searchSessionTtlMs:50,maxSearchSessions:1,clockMs:()=>now});
+  await writeFile(path.join(f.project,'ttl.txt'),'needle\n');
+  const first=await f.runtime.searchStart({rootId:'project',relativePath:'.',pattern:'needle',maxResults:10,maxFiles:10,maxBytes:65536});
+  const done=await waitTerminal(f.runtime,first.search_id);
+  assert.equal(done.state,'completed');
+  now+=60;
+  await assert.rejects(f.runtime.searchStatus({searchId:first.search_id}),/unknown or expired search/);
+  const second=await f.runtime.searchStart({rootId:'project',relativePath:'.',pattern:'needle',maxResults:10,maxFiles:10,maxBytes:65536});
+  assert.match(second.search_id,/^[0-9a-f]{64}$/);
+});
+
+test('R46 observation search hard cap fails closed while all retained sessions are active', async () => {
+  const f=await fixture({searchSessionTtlMs:5000,maxSearchSessions:2});
+  await writeFile(path.join(f.project,'cap.txt'),'needle\n');
+  const a=await f.runtime.searchStart({rootId:'project',relativePath:'.',pattern:'needle'});
+  const b=await f.runtime.searchStart({rootId:'project',relativePath:'.',pattern:'needle'});
+  assert.match(a.search_id,/^[0-9a-f]{64}$/);
+  assert.match(b.search_id,/^[0-9a-f]{64}$/);
+  await assert.rejects(f.runtime.searchStart({rootId:'project',relativePath:'.',pattern:'needle'}),/session limit reached/);
+  await waitTerminal(f.runtime,a.search_id).catch(()=>{});
+  await waitTerminal(f.runtime,b.search_id).catch(()=>{});
+});

package/test/process-mcp-tools.test.mjs

@@ -1,4 +1,4 @@
-import test from 'node:test';
+import test from 'node:test';
 import assert from 'node:assert/strict';
 import { registerProcessTools } from '../src/process-mcp-tools.mjs';
 
@@ -20,18 +20,19 @@ function runtime() {
   return {
     start: async () => session(), read: async () => ({
       session_id: hex('a'), offset: 0, next_offset: 4, earliest_offset: 0, stream_head: 4,
-      stream_sha256: hex('b'), truncated: false, data_base64: 'VEVTVA==', state: 'running', exit_code: null
+      stream_sha256: hex('b'), truncated: false, wait_satisfied: true, data_base64: 'VEVTVA==', state: 'running', exit_code: null
     }),
     status: async () => session(), list: async () => ({ sessions: [session()] }),
+    write: async ({ input, appendNewline }) => ({ logical_bytes: Buffer.byteLength(input + (appendNewline ? '\r\n' : '')), logical_sha256: hex('e'), append_newline: appendNewline, session: session() }),
     action: async ({ actionId }) => ({ action_id: actionId, logical_bytes: 4, logical_sha256: hex('d'), session: session() }),
     terminate: async () => session('terminated')
   };
 }
-test('R32 registers exactly six bounded process supervision tools', () => {
+test('R46 registers exactly seven bounded process supervision tools', () => {
   const server = new FakeServer();
   registerProcessTools(server, { runtime: runtime() });
   assert.deepEqual([...server.tools.keys()].sort(), [
-    'process_session_action','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate'
+    'process_session_action','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate','process_session_write'
   ]);
   for (const [name, tool] of server.tools) {
     assert.ok(tool.spec.inputSchema, `${name} input schema missing`);
@@ -41,7 +42,7 @@ test('R32 registers exactly six bounded process supervision tools', () => {
   }
 });
 
-test('R32 process tool inputs expose IDs and bounds but no executable or raw input field', () => {
+test('R46 process tool inputs expose guarded raw input only through process_session_write', () => {
   const server = new FakeServer();
   registerProcessTools(server, { runtime: runtime() });
   const start = server.tools.get('process_session_start').spec.inputSchema;
@@ -52,6 +53,10 @@ test('R32 process tool inputs expose IDs and bounds but no executable or raw inp
   assert.equal(start.safeParse({ profile_id: 'hold', root_id: 'core', input: 'whoami' }).success, false);
   assert.equal(terminate.safeParse({ session_id: hex('a') }).success, true);
   assert.equal(terminate.safeParse({ pid: 1234 }).success, false);
+  const write = server.tools.get('process_session_write').spec.inputSchema;
+  assert.equal(write.safeParse({ session_id: hex('a'), input: 'Write-Output 42', append_newline: true }).success, true);
+  assert.equal(write.safeParse({ session_id: hex('a'), input: '' }).success, false);
+  assert.equal(write.safeParse({ session_id: hex('a'), input: 'x', pid: 1234 }).success, false);
   assert.equal(action.safeParse({ session_id: hex('a'), action_id: 'ping' }).success, true);
   for (const forbidden of ['input','command','executable','environment','pid']) {
     assert.equal(action.safeParse({ session_id: hex('a'), action_id: 'ping', [forbidden]: 'forbidden' }).success, false);
@@ -69,3 +74,16 @@ test('R32 process action handler returns only strict logical identity and update
   assert.equal(result.structuredContent.session.state, 'running');
   assert.equal(tool.spec.outputSchema.safeParse({ ...result.structuredContent, raw_input: 'forbidden' }).success, false);
 });
+
+
+test('R46 process write handler returns only input identity and session state', async () => {
+  const server = new FakeServer();
+  registerProcessTools(server, { runtime: runtime() });
+  const tool = server.tools.get('process_session_write');
+  const result = await tool.handler({ session_id: hex('a'), input: 'Write-Output 42', append_newline: true });
+  assert.equal(result.isError, false);
+  assert.deepEqual(Object.keys(result.structuredContent).sort(), ['append_newline','logical_bytes','logical_sha256','session','status']);
+  assert.equal(result.structuredContent.append_newline, true);
+  assert.equal(result.structuredContent.session.state, 'running');
+  assert.equal(tool.spec.outputSchema.safeParse({ ...result.structuredContent, raw_input: 'forbidden' }).success, false);
+});