deadbyte-mcp 0.15.15 → 0.15.16

package/src/commander-extended-runtime.mjs

@@ -0,0 +1,74 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const COMMANDER_EXTENDED_SCHEMA='deadbyte.commander-extended.v1';
+const MAX_VALUE=16384,MAX_FEEDBACK=4096,MAX_PREVIEW=65536;
+const sha256=v=>createHash('sha256').update(Buffer.isBuffer(v)?v:Buffer.from(typeof v==='string'?v:canonicalJson(v),'utf8')).digest('hex');
+const keyOk=k=>typeof k==='string'&&/^[A-Za-z0-9._-]{1,128}$/.test(k);
+
+function pdfEscape(s){return String(s).replaceAll('\\\\','\\\\\\\\').replaceAll('(','\\\\(').replaceAll(')','\\\\)');}
+function makePdf(text){
+  const nl=String.fromCharCode(10),lines=String(text).replaceAll(String.fromCharCode(13),'').split(nl).slice(0,200);
+  const stream=['BT','/F1 11 Tf','50 790 14 TL',...lines.map(line=>'('+pdfEscape(line).slice(0,180)+') Tj 0 -14 Td'),'ET'].join(nl);
+  const objs=['<< /Type /Catalog /Pages 2 0 R >>','<< /Type /Pages /Kids [3 0 R] /Count 1 >>','<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 4 0 R >> /Contents 5 0 R >>','<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>','<< /Length '+Buffer.byteLength(stream)+' >>'+nl+'stream'+nl+stream+nl+'endstream'];
+  let out='%PDF-1.4'+nl,offsets=[0];
+  for(let i=0;i<objs.length;i++){offsets.push(Buffer.byteLength(out));out+=(i+1)+' 0 obj'+nl+objs[i]+nl+'endobj'+nl;}
+  const xref=Buffer.byteLength(out);
+  out+='xref'+nl+'0 6'+nl+'0000000000 65535 f '+nl+offsets.slice(1).map(o=>String(o).padStart(10,'0')+' 00000 n ').join(nl)+nl+'trailer'+nl+'<< /Size 6 /Root 1 0 R >>'+nl+'startxref'+nl+xref+nl+'%%EOF'+nl;
+  return Buffer.from(out,'utf8');
+}
+
+export function createCommanderExtendedRuntime({stateRoot,history=null,prompts=[],resources=[]}={}){
+  if(typeof stateRoot!=='string'||!stateRoot)throw new Error('extended runtime stateRoot required');
+  const configPath=path.join(stateRoot,'commander-config.json'),feedbackDir=path.join(stateRoot,'feedback');
+  let configCache=null;
+  async function loadConfig(){
+    if(configCache)return configCache;
+    try{configCache=JSON.parse(await readFile(configPath,'utf8'));}
+    catch(e){if(e?.code!=='ENOENT')throw e;configCache={};}
+    return configCache;
+  }
+  async function getConfig({key=null}={}){
+    const cfg=await loadConfig();
+    if(key!==null&&!keyOk(key))throw new Error('config key invalid');
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',config:key===null?structuredClone(cfg):{[key]:cfg[key]},config_sha256:sha256(cfg)};
+  }
+  async function setConfigValue({key,value,expected_sha256}){
+    if(!keyOk(key))throw new Error('config key invalid');
+    if(!['string','number','boolean'].includes(typeof value)&&value!==null)throw new Error('config value must be scalar');
+    if(Buffer.byteLength(typeof value==='string'?value:canonicalJson(value))>MAX_VALUE)throw new Error('config value exceeds byte limit');
+    const cfg=await loadConfig(),beforeSha=sha256(cfg);
+    if(expected_sha256!==beforeSha)throw new Error('config precondition mismatch');
+    const next={...cfg,[key]:value};
+    await mkdir(stateRoot,{recursive:true});
+    const tmp=configPath+'.tmp-'+process.pid+'-'+randomUUID();
+    await writeFile(tmp,canonicalJson(next),{encoding:'utf8',flag:'wx',mode:0o600});
+    await rename(tmp,configPath); configCache=next;
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'committed',key,previous_sha256:beforeSha,config_sha256:sha256(next)};
+  }
+  async function feedback({message,category='general'}){
+    if(typeof message!=='string'||!message.trim()||Buffer.byteLength(message)>MAX_FEEDBACK)throw new Error('feedback message invalid');
+    if(!/^[A-Za-z0-9._-]{1,64}$/.test(category))throw new Error('feedback category invalid');
+    await mkdir(feedbackDir,{recursive:true});
+    const id=randomUUID(),record={schema:COMMANDER_EXTENDED_SCHEMA,id,category,message:message.trim(),created_at_utc:new Date().toISOString()};
+    await writeFile(path.join(feedbackDir,id+'.json'),canonicalJson(record),{encoding:'utf8',flag:'wx',mode:0o600});
+    return {status:'committed',feedback_id:id,feedback_sha256:sha256(record)};
+  }
+  function getPrompts(){return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',prompts:prompts.map(x=>({...x})).slice(0,128)};}
+  function getResources(){return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',resources:resources.map(x=>({...x})).slice(0,128)};}
+  async function filePreview({rootId,path:relativePath,offset=0,maxBytes=MAX_PREVIEW,mimeType='text/plain'}){
+    if(!Number.isInteger(offset)||offset<0||offset>64*1024*1024)throw new Error('preview offset invalid');
+    if(!Number.isInteger(maxBytes)||maxBytes<1||maxBytes>MAX_PREVIEW)throw new Error('preview maxBytes invalid');
+    if(typeof rootId!=='string'||typeof relativePath!=='string'||path.isAbsolute(relativePath))throw new Error('preview target invalid');
+    const data=await readFile(path.resolve(rootId,relativePath)),slice=data.subarray(offset,offset+maxBytes);
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',root_id:rootId,path:relativePath,mime_type:mimeType,offset,bytes:slice.length,total_bytes:data.length,truncated:offset+slice.length<data.length,sha256:sha256(slice),text:mimeType.startsWith('text/')?slice.toString('utf8'):null};
+  }
+  function writePdf({text,metadata={}}){
+    if(typeof text!=='string'||Buffer.byteLength(text)>MAX_PREVIEW)throw new Error('PDF text exceeds byte limit');
+    const bytes=makePdf(text);
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',mime_type:'application/pdf',bytes_base64:bytes.toString('base64'),bytes_sha256:sha256(bytes),bytes:bytes.length,metadata};
+  }
+  return Object.freeze({getConfig,setConfigValue,feedback,getPrompts,getResources,filePreview,writePdf,history});
+}

package/src/commander-observability.mjs

@@ -0,0 +1,33 @@
+import { canonicalJson } from './canonical-json.mjs';
+
+const MAX_LIMIT=1000;
+const SCHEMA='deadbyte.commander-observability.v1';
+
+function boundLimit(limit){if(!Number.isInteger(limit)||limit<1||limit>MAX_LIMIT)throw new Error('observability limit out of range');return limit;}
+
+export function createCommanderObservability({history}={}){
+  if(!history||typeof history.read!=='function'||typeof history.verify!=='function'||typeof history.operationId!=='string'||history.operationId.length<1) throw new Error('observability requires operation history');
+  function recentToolCalls({afterSequence=0,limit=100}={}){
+    boundLimit(limit);
+    const page=history.read({afterSequence,limit});
+    const events=page.events.filter(e=>e.event_type==='tool.call'||e.event_type==='tool.result'||e.event_type==='tool.error');
+    return {schema:SCHEMA,operation_id:page.operation_id,events,next_sequence:page.next_sequence,head_event_hash:page.head_event_hash,earliest_sequence:page.earliest_sequence,overflow:page.overflow};
+  }
+  function usageStats(){
+    const page=history.read({afterSequence:0,limit:MAX_LIMIT});
+    const counts={};
+    let toolCalls=0,toolResults=0,toolErrors=0;
+    for(const event of page.events){
+      if(event.event_type==='tool.call') toolCalls++;
+      else if(event.event_type==='tool.result') toolResults++;
+      else if(event.event_type==='tool.error') toolErrors++;
+      else continue;
+      const name=event.payload?.tool;
+      if(typeof name==='string'&&name.length) counts[name]=(counts[name]??0)+1;
+    }
+    return {schema:SCHEMA,operation_id:page.operation_id,events_visible:page.events.length,tool_calls:toolCalls,tool_results:toolResults,tool_errors:toolErrors,tool_counts:Object.fromEntries(Object.entries(counts).sort(([a],[b])=>a.localeCompare(b))),head_event_hash:page.head_event_hash,earliest_sequence:page.earliest_sequence,overflow:page.overflow,integrity:history.verify()};
+  }
+  return Object.freeze({usageStats,recentToolCalls});
+}
+
+export const COMMANDER_OBSERVABILITY_SCHEMA=SCHEMA;

package/src/commander-remote-bridge-r47.mjs

@@ -0,0 +1,41 @@
+import * as z from 'zod/v4';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const CAP=/^[A-Za-z0-9._-]{1,128}$/;
+function register(server,name,schema,handler){
+  server.registerTool(name,{description:'Native remote Commander-compatible bridge backed directly by DEADBYTE remote-device-r44. No Commander runtime is invoked.',inputSchema:schema},handler);
+}
+function requirePlane(plane,name){
+  if(!plane) return {status:'unavailable',tool:name,error:'remote-device-r44 plane is not configured'};
+  return null;
+}
+export function registerCommanderRemoteBridge(server,{remoteDevicePlane=null}={}){
+  register(server,'remote_device',z.strictObject({
+    op:z.enum(['pair','status','report_online','probe','dispatch','revoke','rotate_credential','list']),
+    device_id:z.string().regex(HEX64).optional(),epoch:z.number().int().min(1).optional(),
+    public_key_spki_base64:z.string().min(1).max(4096).optional(),display_name:z.string().min(1).max(128).optional(),
+    connection_id:z.string().min(1).max(256).optional(),capability_id:z.string().regex(CAP).optional(),
+    payload:z.record(z.string(),z.unknown()).optional(),request_id:z.string().regex(HEX64).optional(),
+    encrypted_bundle_base64:z.string().min(1).max(1024*1024).optional(),expected_previous_sha256:z.string().regex(HEX64).nullable().optional()
+  }),async a=>{
+    const unavailable=requirePlane(remoteDevicePlane,'remote_device');if(unavailable)return unavailable;
+    switch(a.op){
+      case 'pair': return remoteDevicePlane.pair({publicKeySpkiBase64:a.public_key_spki_base64,displayName:a.display_name});
+      case 'status': return remoteDevicePlane.status({deviceId:a.device_id});
+      case 'report_online': return remoteDevicePlane.reportOnline({deviceId:a.device_id,epoch:a.epoch,connectionId:a.connection_id});
+      case 'probe': return remoteDevicePlane.probe({deviceId:a.device_id,epoch:a.epoch});
+      case 'dispatch': return remoteDevicePlane.dispatch({deviceId:a.device_id,epoch:a.epoch,capabilityId:a.capability_id,payload:a.payload??{},requestId:a.request_id});
+      case 'revoke': return remoteDevicePlane.revoke({deviceId:a.device_id,epoch:a.epoch});
+      case 'rotate_credential': return remoteDevicePlane.rotateCredential({deviceId:a.device_id,epoch:a.epoch,encryptedBundleBase64:a.encrypted_bundle_base64,expectedPreviousSha256:a.expected_previous_sha256??null});
+      case 'list': return remoteDevicePlane.list();
+      default: throw new Error(`unsupported remote_device operation: ${String(a.op)}`);
+    }
+  });
+  register(server,'remote_mcp',z.strictObject({
+    device_id:z.string().regex(HEX64),epoch:z.number().int().min(1),capability_id:z.string().regex(CAP),
+    payload:z.record(z.string(),z.unknown()).default({}),request_id:z.string().regex(HEX64)
+  }),async a=>{
+    const unavailable=requirePlane(remoteDevicePlane,'remote_mcp');if(unavailable)return unavailable;
+    return remoteDevicePlane.dispatch({deviceId:a.device_id,epoch:a.epoch,capabilityId:a.capability_id,payload:a.payload,requestId:a.request_id});
+  });
+}

package/src/commander-remote-relay-r47.mjs

@@ -0,0 +1,44 @@
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+
+function insist(ok,message){if(!ok)throw new Error(message);}
+function structured(result,label){
+  if(result?.isError) throw new Error(`${label} returned MCP error`);
+  const value=result?.structuredContent;
+  insist(value&&typeof value==='object',`${label} missing structured output`);
+  return value;
+}
+
+export async function createCommanderRemoteRelayR47({endpoint,protocolVersion='2026-07-28',timeoutMs=15000}={}){
+  const url=new URL(String(endpoint??''));
+  insist(url.protocol==='https:','remote relay endpoint must use HTTPS');
+  insist(Number.isInteger(timeoutMs)&&timeoutMs>=100&&timeoutMs<=120000,'remote relay timeout invalid');
+  const client=new Client({name:'deadbyte-r47-remote-relay',version:'0.15.15'},{versionNegotiation:{mode:{pin:protocolVersion}}});
+  const transport=new StreamableHTTPClientTransport(url);
+  let connected=false;
+  let connecting=null;
+  async function ensureConnected(){
+    if(connected)return;
+    if(!connecting){connecting=client.connect(transport).then(()=>{connected=true;}).finally(()=>{connecting=null;});}
+    await connecting;
+  }
+  async function call(name,arguments_,label){await ensureConnected();return structured(await client.callTool({name,arguments:arguments_}),label);}
+  async function probe({device_id,epoch,connection_id,nonce}){
+    const value=await call('remote_device',{op:'probe',device_id,epoch,connection_id,nonce},'remote readiness probe');
+    const result=value.result??value;
+    return {device_id,epoch,nonce,ready:result.ready===true||result.reachable===true};
+  }
+  async function request({device_id,epoch,capability_id,payload,request_id,request_sha256}){
+    insist(typeof request_sha256==='string'&&/^[0-9a-f]{64}$/.test(request_sha256),'remote request hash invalid');
+    const value=await call('remote_mcp',{device_id,epoch,capability_id,payload,request_id,request_sha256},'remote dispatch');
+    const result=value.result??value;
+    if(result?.request_id!==undefined) insist(result.request_id===request_id,'remote request identity mismatch');
+    if(result?.status==='completed'||result?.state==='completed'){
+      insist(typeof result.result_sha256==='string'&&/^[0-9a-f]{64}$/.test(result.result_sha256),'remote terminal result hash invalid');
+      return {ack:'accepted',request_id,terminal:{status:'completed',result_sha256:result.result_sha256}};
+    }
+    if(result?.status==='failed'||result?.state==='failed') return {ack:'accepted',request_id,terminal:{status:'failed',error_code:result.error_code??'remote_failed'}};
+    throw new Error('remote dispatch returned non-terminal state');
+  }
+  async function close(){connected=false;await client.close().catch(()=>{});}
+  return Object.freeze({probe,request,close,endpoint:url.toString()});
+}

package/src/machine-fs.mjs

@@ -33,7 +33,36 @@ async function sha256File(file) {
 }
 
 const machineFsReadWorkerPath = fileURLToPath(new URL('./machine-fs-read-worker.mjs', import.meta.url));
+async function boundedReadInProcess({ file, offset, length, hashFile, timeoutMs }) {
+  const handle = await open(file, 'r');
+  let timer;
+  let settled = false;
+  const abort = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      settled = true;
+      void handle.close().catch(() => {});
+      reject(new Error(`machine fs read timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    const operation = (async () => {
+      const buffer = Buffer.alloc(length);
+      const result = length ? await handle.read(buffer, 0, length, offset) : { bytesRead: 0 };
+      let fileSha256 = null;
+      if (hashFile) fileSha256 = await sha256File(file);
+      return { schema: 'deadbyte.machine-fs-read-worker.v1', bytes_read: result.bytesRead,
+        data_base64: buffer.subarray(0, result.bytesRead).toString('base64'), file_sha256: fileSha256 };
+    })();
+    operation.catch(() => {});
+    return await Promise.race([operation, abort]);
+  } finally {
+    if (!settled) { clearTimeout(timer); await handle.close().catch(() => {}); }
+  }
+}
+
 async function boundedReadWorker({ file, offset, length, hashFile, timeoutMs, workerPath = machineFsReadWorkerPath }) {
+  if (workerPath === machineFsReadWorkerPath) return boundedReadInProcess({ file, offset, length, hashFile, timeoutMs });
   return await new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [workerPath, file, String(offset), String(length), hashFile ? '1' : '0'], {
       windowsHide: true, shell: false, stdio: ['ignore','pipe','pipe']
@@ -103,20 +132,27 @@ function assertNotDenied(root, relativePath) {
 }
 async function assertNoReparse(rootPath, target, allowMissingLeaf = false) {
   const relative = path.relative(rootPath, target);
-  if (relative === '') return;
+  if (relative === '') {
+    const info = await lstat(rootPath);
+    if (info.isSymbolicLink()) throw new Error('machine fs root reparse point denied');
+    return info;
+  }
   if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('machine fs path escapes allowed root');
   const parts = relative.split(path.sep).filter(Boolean);
   let cursor = rootPath;
+  let targetInfo = null;
   for (let i = 0; i < parts.length; i += 1) {
     cursor = path.join(cursor, parts[i]);
     try {
       const info = await lstat(cursor);
       if (info.isSymbolicLink()) throw new Error(`machine fs reparse point denied at '${parts.slice(0, i + 1).join('/')}'`);
+      targetInfo = info;
     } catch (error) {
-      if (allowMissingLeaf && i === parts.length - 1 && error?.code === 'ENOENT') return;
+      if (allowMissingLeaf && i === parts.length - 1 && error?.code === 'ENOENT') return null;
       throw error;
     }
   }
+  return targetInfo;
 }
 
 async function resolveExisting(policy, grant, rootId, relativePath, permission, allowDot = false) {
@@ -126,10 +162,10 @@ async function resolveExisting(policy, grant, rootId, relativePath, permission,
   if (normalized !== '.') assertNotDenied(root, normalized);
   const lexical = normalized === '.' ? root.real_path : path.resolve(root.real_path, normalized);
   if (!isInside(root.real_path, lexical) && lexical !== root.real_path) throw new Error('machine fs path escapes allowed root');
-  await assertNoReparse(root.real_path, lexical, false);
-  const resolved = await realpath(lexical);
+  const targetInfo = await assertNoReparse(root.real_path, lexical, false);
+  const resolved = lexical === root.real_path ? lexical : await realpath(lexical);
   if (!isInside(root.real_path, resolved) && resolved !== root.real_path) throw new Error('machine fs path resolves outside allowed root');
-  return { root, lexical, resolved, relative: normalized };
+  return { root, lexical, resolved, relative: normalized, targetInfo };
 }
 async function resolveTarget(policy, grant, rootId, relativePath, permission) {
   const normalized = normalizeRelative(relativePath, false);
@@ -208,15 +244,41 @@ async function objectIdentity(target, budget = { remaining: MAX_DIRECTORY_IDENTI
   return { ...core, identity_sha256: sha256Object(core) };
 }
 
-function decodeCursor(cursor) {
+const LIST_CURSOR_DOMAIN = Buffer.from('DEADBYTE-MACHINE-FS-LIST-CURSOR-V3\\0', 'utf8');
+async function encodeListCursor({ path: relativePath, snapshot_sha256, after_name, signingKeyPath }) {
+  const signing = await loadPrivateSigningKey(signingKeyPath);
+  const body = { schema: 'deadbyte.machine-fs-list-cursor.v3', path: relativePath, snapshot_sha256, after_name };
+  const payload = Buffer.from(canonicalJson(body), 'utf8');
+  const signature_base64 = cryptoSign(null, Buffer.concat([LIST_CURSOR_DOMAIN, payload]), signing.privateKey).toString('base64');
+  return Buffer.from(canonicalJson({
+    ...body,
+    attestation: { algorithm: 'ed25519', key_id: signing.keyId, signature_base64 }
+  }), 'utf8').toString('base64url');
+}
+async function decodeListCursor(cursor, verifyKeyPath) {
   if (cursor === null || cursor === undefined) return null;
-  if (typeof cursor !== 'string' || cursor.length < 1 || cursor.length > 2048) throw new Error('machine fs cursor invalid');
+  if (typeof cursor !== 'string' || cursor.length < 1 || cursor.length > 4096) throw new Error('machine fs cursor invalid');
   let decoded;
-  try { decoded = Buffer.from(cursor, 'base64url').toString('utf8'); }
+  try { decoded = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8')); }
   catch { throw new Error('machine fs cursor invalid'); }
-  if (!decoded || Buffer.from(decoded, 'utf8').toString('base64url') !== cursor) throw new Error('machine fs cursor invalid');
+  if (!decoded || decoded.schema !== 'deadbyte.machine-fs-list-cursor.v3' ||
+      typeof decoded.path !== 'string' || !SHA256_RE.test(decoded.snapshot_sha256 ?? '') ||
+      typeof decoded.after_name !== 'string' || decoded.after_name.length < 1 ||
+      decoded.attestation?.algorithm !== 'ed25519' || typeof decoded.attestation?.key_id !== 'string' ||
+      typeof decoded.attestation?.signature_base64 !== 'string') throw new Error('machine fs cursor invalid');
+  if (Buffer.from(canonicalJson(decoded), 'utf8').toString('base64url') !== cursor) throw new Error('machine fs cursor invalid');
+  const { attestation, ...body } = decoded;
+  const verifyKey = await loadPublicVerifyKey(verifyKeyPath);
+  if (attestation.key_id !== verifyKey.keyId) throw new Error('machine fs cursor key mismatch');
+  const signature = Buffer.from(attestation.signature_base64, 'base64');
+  const valid = signature.length === 64 &&
+    cryptoVerify(null, Buffer.concat([LIST_CURSOR_DOMAIN, Buffer.from(canonicalJson(body), 'utf8')]), verifyKey.publicKey, signature);
+  if (!valid) throw new Error('machine fs cursor signature mismatch');
   return decoded;
 }
+function directoryListingSnapshot(children) {
+  return sha256Object(children.map(child => ({ name: child.name, kind: child.isSymbolicLink() ? 'reparse' : child.isDirectory() ? 'directory' : child.isFile() ? 'file' : 'other' })));
+}
 
 function encodeCursor(name) { return Buffer.from(name, 'utf8').toString('base64url'); }
 
@@ -286,7 +348,14 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
     const info = await lstat(found.resolved);
     const kind = kindOf(info);
     if (kind === 'reparse') throw new Error('machine fs reparse target denied');
-    const identity = await objectIdentity(found.resolved);
+    let identity;
+    if (kind === 'file') {
+      const contentSha256 = await sha256File(found.resolved);
+      const core = { kind: 'file', bytes: info.size, content_sha256: contentSha256 };
+      identity = { ...core, identity_sha256: sha256Object(core) };
+    } else {
+      identity = await objectIdentity(found.resolved);
+    }
     return {
       status: 'ok', root_id: rootId, path: found.relative, kind,
       bytes: kind === 'file' ? info.size : 0,
@@ -300,27 +369,29 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
     if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIST_LIMIT) throw new Error(`machine fs list limit must be in [1, ${MAX_LIST_LIMIT}]`);
     const grant = await assertCodingArmed(policy, rootId);
     const found = await resolveExisting(policy, grant, rootId, relativePath, 'read', true);
-    const info = await lstat(found.resolved);
-    if (!info.isDirectory()) throw new Error('machine fs list path must be a directory');
-    const afterName = decodeCursor(cursor);
+    const info = found.targetInfo;
+    if (!info?.isDirectory()) throw new Error('machine fs list path must be a directory');
+    const decodedCursor = await decodeListCursor(cursor, verifyKeyPath);
+    if (decodedCursor && decodedCursor.path !== found.relative) throw new Error('machine fs cursor path mismatch');
     const children = await readdir(found.resolved, { withFileTypes: true });
     children.sort((a, b) => a.name.localeCompare(b.name));
+    const snapshot_sha256 = directoryListingSnapshot(children);
+    if (decodedCursor && decodedCursor.snapshot_sha256 !== snapshot_sha256) throw new Error('machine fs cursor snapshot changed');
+    const afterName = decodedCursor?.after_name ?? null;
     const filtered = children.filter(child => afterName === null || child.name.localeCompare(afterName) > 0);
     const selected = filtered.slice(0, limit);
-    const entries = [];
-    for (const child of selected) {
+    const entries = await Promise.all(selected.map(async child => {
       const rel = found.relative === '.' ? child.name : `${found.relative}/${child.name}`;
-      if (child.isSymbolicLink()) {
-        entries.push({ path: rel, kind: 'reparse', bytes: 0, mtime_utc: null, sha256: null });
-        continue;
-      }
+      if (child.isSymbolicLink()) return { path: rel, kind: 'reparse', bytes: 0, mtime_utc: null, sha256: null };
       const childPath = path.join(found.resolved, child.name);
       const childInfo = await lstat(childPath);
       const kind = kindOf(childInfo);
       const digest = hashFiles && kind === 'file' ? await sha256File(childPath) : null;
-      entries.push({ path: rel, kind, bytes: kind === 'file' ? childInfo.size : 0, mtime_utc: childInfo.mtime.toISOString(), sha256: digest });
-    }
-    const nextCursor = filtered.length > selected.length && selected.length ? encodeCursor(selected.at(-1).name) : null;
+      return { path: rel, kind, bytes: kind === 'file' ? childInfo.size : 0, mtime_utc: childInfo.mtime.toISOString(), sha256: digest };
+    }));
+    const nextCursor = filtered.length > selected.length && selected.length
+      ? await encodeListCursor({ path: found.relative, snapshot_sha256, after_name: selected.at(-1).name, signingKeyPath })
+      : null;
     return { status: 'ok', root_id: rootId, path: found.relative, entries, next_cursor: nextCursor };
   }
   async function readRange({ rootId, relativePath, offset = 0, maxBytes = 65536, hashFile = false, timeoutMs = 30000 }) {
@@ -348,6 +419,20 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
     };
   }
 
+  async function readMany({ rootId, paths, maxBytes = 65536, timeoutMs = 30000 }) {
+    if (!Array.isArray(paths) || paths.length < 1 || paths.length > 64) throw new Error('machine fs read_many paths must contain 1-64 entries');
+    if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > policy.max_read_bytes) throw new Error(`machine fs read_many max_bytes must be in [1, ${policy.max_read_bytes}]`);
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 180000) throw new Error('machine fs read_many timeout_ms must be in [100, 180000]');
+    const unique = new Set();
+    for (const relativePath of paths) {
+      if (typeof relativePath !== 'string' || relativePath.length < 1 || relativePath.length > 512) throw new Error('machine fs read_many path invalid');
+      if (unique.has(relativePath)) throw new Error(`machine fs read_many duplicate path '${relativePath}'`);
+      unique.add(relativePath);
+    }
+    const results = await Promise.all(paths.map(relativePath => readRange({ rootId, relativePath, offset: 0, maxBytes, timeoutMs })));
+    return { status: 'ok', root_id: rootId, count: results.length, results };
+  }
+
   async function writePath({ rootId, relativePath, content, encoding = 'utf8', expectedSha256, receiptId = null }) {
     const grant = await assertCodingArmed(policy, rootId);
     const target = await resolveTarget(policy, grant, rootId, relativePath, 'write');
@@ -551,6 +636,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
     stat: statPath,
     list: listPage,
     read: readRange,
+    readMany,
     write: writePath,
     editExact,
     move: movePath,

package/src/mcp-server.mjs

@@ -51,6 +51,11 @@ import { registerAutonomousTools } from './autonomous-mcp-tools.mjs';
 import { createToolAudit, installToolAudit } from './tool-audit.mjs';
 import { createAuditContextProvider } from './audit-context.mjs';
 import { registerOperatorSurface } from './operator-surface.mjs';
+import { createCommanderExtendedRuntime } from './commander-extended-runtime.mjs';
+import { registerCommanderCoreBridge } from './commander-core-bridge.mjs';
+import { registerCommanderRemoteBridge } from './commander-remote-bridge-r47.mjs';
+import { createCommanderRemoteRelayR47 } from './commander-remote-relay-r47.mjs';
+import { createRemoteDevicePlaneR44 } from './remote-device-r44.mjs';
 import { capabilityProfileFromEnv, COMPACT_SURFACE_TOOL_LIMIT, R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
 import { registerCompactGatewayTools } from './compact-gateway-mcp-tools.mjs';
 import { createSkillPlane } from './skill-plane-r44.mjs';
@@ -238,6 +243,17 @@ const skillRoot=path.join(runtimeStateRoot,'skills');
 await mkdir(skillRoot,{recursive:true});
 const skillRuntime=await createSkillPlane({root:skillRoot,verifyKeyPath});
 
+const remoteRelayEndpoint=process.env.DEADBYTE_REMOTE_RELAY_ENDPOINT||process.env.DEADBYTE_REMOTE_ENDPOINT||'';
+const remoteRelayCapabilities=new Set(String(process.env.DEADBYTE_REMOTE_CAPABILITIES||'').split(',').map(value=>value.trim()).filter(Boolean));
+const remoteRelay=remoteRelayEndpoint ? await createCommanderRemoteRelayR47({endpoint:remoteRelayEndpoint}) : null;
+const remoteDevicePlane=remoteRelay
+  ? await createRemoteDevicePlaneR44({
+      stateDir:path.join(runtimeStateRoot,'remote-device-r44'),
+      relay:remoteRelay,
+      authorizeCapability:async({capabilityId})=>remoteRelayCapabilities.has(capabilityId)
+    })
+  : null;
+
 installStdioConsoleGuard();
 if (process.env.DEADBYTE_STDIO_CONSOLE_GUARD_PROBE === '1') console.log('DEADBYTE_STDIO_CONSOLE_GUARD_PROBE');
 
@@ -276,9 +292,83 @@ serveStdio(() => {
     return server.registerTool(name,...args);
   }};
   registerOperatorSurface(server,{packageRoot,surfaceProfile,compactToolLimit:COMPACT_SURFACE_TOOL_LIMIT});
+  const commanderExtendedRuntime=createCommanderExtendedRuntime({
+    stateRoot:runtimeStateRoot,
+    history:null,
+    prompts:[
+      {name:'deadbyte.review',title:'Review'},
+      {name:'deadbyte.patch',title:'Patch'},
+      {name:'deadbyte.diagnose',title:'Diagnose'},
+      {name:'deadbyte.run-tests',title:'Run tests'}
+    ],
+    resources:[
+      {uri:'deadbyte://context',mime_type:'text/markdown'},
+      {uri:'deadbyte://architecture',mime_type:'text/markdown'},
+      {uri:'deadbyte://surface-profile',mime_type:'application/json'}
+    ]
+  });
   if (toolAudit) installToolAudit(server,toolAudit);
 
   if (surfaceProfile === 'full') {
+  toolServer.registerTool('get_config',{
+    description:'Read bounded DEADBYTE Commander-compatible configuration.',
+    inputSchema:z.strictObject({key:z.string().min(1).max(128).nullable().default(null)})
+  },async args=>commanderExtendedRuntime.getConfig(args));
+
+  toolServer.registerTool('set_config_value',{
+    description:'Atomically update one bounded configuration scalar with an exact hash precondition.',
+    inputSchema:z.strictObject({key:z.string().min(1).max(128),value:z.union([z.string().max(16384),z.number(),z.boolean(),z.null()]),expected_sha256:z.string().regex(/^[0-9a-f]{64}$/)})
+  },async args=>commanderExtendedRuntime.setConfigValue(args));
+
+  toolServer.registerTool('give_feedback_to_desktop_commander',{
+    description:'Persist bounded operator feedback locally; no external network transmission.',
+    inputSchema:z.strictObject({message:z.string().min(1).max(4096),category:z.string().min(1).max(64).default('general')})
+  },async args=>commanderExtendedRuntime.feedback(args));
+
+  toolServer.registerTool('get_prompts',{
+    description:'Return the bounded native prompt catalog.',
+    inputSchema:z.strictObject({})
+  },async()=>commanderExtendedRuntime.getPrompts());
+
+  toolServer.registerTool('resources',{
+    description:'Return the bounded native resource catalog.',
+    inputSchema:z.strictObject({})
+  },async()=>commanderExtendedRuntime.getResources());
+
+  toolServer.registerTool('file_preview',{
+    description:'Return a bounded preview slice from an explicitly rooted file.',
+    inputSchema:z.strictObject({root_id:z.string().min(1).max(512),path:z.string().min(1).max(512),offset:z.number().int().min(0).default(0),max_bytes:z.number().int().min(1).max(65536).default(65536),mime_type:z.string().max(128).default('text/plain')})
+  },async({root_id,path:relativePath,offset,max_bytes,mime_type})=>commanderExtendedRuntime.filePreview({rootId:root_id,path:relativePath,offset,maxBytes:max_bytes,mimeType:mime_type}));
+
+  toolServer.registerTool('write_pdf',{
+    description:'Generate a bounded self-contained PDF document from text.',
+    inputSchema:z.strictObject({text:z.string().max(65536),metadata:z.record(z.string(),z.unknown()).default({})})
+  },async args=>commanderExtendedRuntime.writePdf(args));
+
+  toolServer.registerTool('markdown_editor',{
+    description:'Hash-preconditioned bounded Markdown exact edit using the native machine filesystem transaction.',
+    inputSchema:z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(512),expected_sha256:z.string().regex(/^[0-9a-f]{64}$/),old_string:z.string().min(1).max(262144),new_string:z.string().max(524288),expected_replacements:z.number().int().min(1).max(64).default(1)})
+  },async args=>{
+    if(!machineFsRuntime) return textResult(z.any(),{status:'denied',error:'machine filesystem runtime is disabled'},true);
+    return machineFsRuntime.editExact({rootId:args.root_id,relativePath:args.path,expectedSha256:args.expected_sha256,oldString:args.old_string,newString:args.new_string,expectedReplacements:args.expected_replacements});
+  });
+
+  toolServer.registerTool('get_usage_stats',{
+    description:'Return bounded audit/runtime usage status.',
+    inputSchema:z.strictObject({})
+  },async()=>{
+    if(!toolAudit) return {status:'unavailable',reason:'audit runtime is disabled'};
+    return {status:'ok',audit:await toolAudit.status()};
+  });
+
+  toolServer.registerTool('get_recent_tool_calls',{
+    description:'Return a bounded, cursorable recent signed audit event window.',
+    inputSchema:z.strictObject({limit:z.number().int().min(1).max(256).default(50),after_seq:z.number().int().min(0).default(0)})
+  },async({limit,after_seq})=>{
+    if(!toolAudit) return {status:'unavailable',reason:'audit runtime is disabled'};
+    return {status:'ok',audit:await toolAudit.recent({limit,after_seq})};
+  });
+
   toolServer.registerTool(
     'workspace_open',
     {
@@ -589,5 +679,9 @@ serveStdio(() => {
     );
   }
 
+  if (surfaceProfile === 'full') {
+    registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null});
+    registerCommanderRemoteBridge(toolServer,{remoteDevicePlane});
+  }
   return server;
 }, { legacy: 'reject' });

package/src/release-slot.mjs

@@ -288,7 +288,9 @@ export function renderStableLauncherPs1(){
     "$env:DEADBYTE_CONTROLLER_RUNTIME_ROOT = Join-Path $StateRoot 'runtime'",
     "$powershell = Join-Path $PSHOME 'powershell.exe'",
     '& $powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -File $controller @ControllerArgs',
-    'exit $LASTEXITCODE',
+    '$exitCode = (Get-Variable -Name LASTEXITCODE -ValueOnly -ErrorAction SilentlyContinue)',
+    'if ($null -eq $exitCode) { $exitCode = 0 }',
+    'exit ([int]$exitCode)',
     ''
   ].join('\r\n');
 }