deadbyte-mcp 0.15.14 → 0.15.16

package/src/runtime-update.mjs

@@ -234,7 +234,17 @@ async function atomicBytes(file,bytes){
   const temp=`${file}.tmp-${process.pid}-${randomBytes(4).toString('hex')}`;
   const handle=await open(temp,'wx');
   try { await handle.writeFile(bytes); await handle.sync(); } finally { await handle.close(); }
-  try { await rename(temp,file); } catch(error){ await rm(temp,{force:true}).catch(()=>{}); throw error; }
+  let renamed=false;
+  let lastRenameError=null;
+  for(let attempt=0;attempt<20;attempt+=1){
+    try { await rename(temp,file); renamed=true; break; }
+    catch(error){
+      lastRenameError=error;
+      if(!["EPERM","EBUSY","EACCES"].includes(error?.code) || attempt===19) break;
+      await new Promise(resolve=>setTimeout(resolve,Math.min(500,100*(attempt+1))));
+    }
+  }
+  if(!renamed){ await rm(temp,{force:true}).catch(()=>{}); throw lastRenameError; }
   if(sha256Bytes(await readFile(file))!==sha256Bytes(bytes)) throw new Error(`atomic write readback mismatch: ${file}`);
 }
 async function normalizeComponentIdentities(config){
@@ -565,16 +575,24 @@ function slotContext(stateRoot,pointer){
 }
 function launcherPath(stateRoot){ return path.join(path.resolve(stateRoot),'bin','DEADBYTE-MCP.ps1'); }
 function controllerInvocation(ctx,command){
-  if(ctx.kind==='slot') return {exe:powershellPath(),args:['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcherPath(ctx.state_root),command],cwd:ctx.state_root};
+  // Internal control-plane calls use the immutable slot controller directly. The stable launcher is
+  // user-facing and may lag during a slot switch; coupling supervisor state transitions to it creates
+  // a bootstrap dependency and can misreport a healthy predecessor as offline.
+  if(ctx.kind==='slot') return {
+    exe:powershellPath(),
+    args:['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.controller_path,command],
+    cwd:ctx.cwd,
+    env:{...process.env,DEADBYTE_CONTROLLER_CONFIG:ctx.pointer.config_path,DEADBYTE_CONTROLLER_RUNTIME_ROOT:ctx.runtime_root}
+  };
   return {exe:powershellPath(),args:['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.controller_path,command],cwd:ctx.cwd};
 }
 function controllerCaptured(ctx,command,timeoutMs=45000){
-  const call=controllerInvocation(ctx,command); const result=controlResult(call.exe,call.args,{cwd:call.cwd,timeoutMs});
+  const call=controllerInvocation(ctx,command); const result=controlResult(call.exe,call.args,{cwd:call.cwd,env:call.env??process.env,timeoutMs});
   return assertRun(result,`controller ${command}`);
 }
 export function runControllerStartNoCapture(ctx,timeoutMs=45000){
   const call=controllerInvocation(ctx,'start');
-  return controlResult(call.exe,call.args,{cwd:call.cwd,timeoutMs,stdio:'ignore'});
+  return controlResult(call.exe,call.args,{cwd:call.cwd,env:call.env??process.env,timeoutMs,stdio:'ignore'});
 }
 export async function readControllerStartFailure(ctx){
   const file=path.join(ctx.runtime_root,'controller-start-failure.json');
@@ -634,7 +652,13 @@ function cleanOfflinePredecessor(ctx){
     let parsed;
     try { parsed=JSON.parse(text); } catch(error){ throw new Error('runtime process query JSON invalid: '+error.message); }
     const processes=(Array.isArray(parsed)?parsed:[parsed]).filter(item=>Number(item?.ProcessId)!==process.pid);
-    if(processes.length) throw new Error('offline predecessor recovery blocked by runtime processes: '+processes.map(item=>String(item?.Name??'unknown')+'#'+String(item?.ProcessId??'?')).join(','));
+    const relevant=processes.filter(item=>{
+      const commandLine=String(item?.CommandLine??'').toLowerCase();
+      return commandLine.includes('deadbyte-mcp')||commandLine.includes('mcp-server.mjs')||
+        commandLine.includes('runtime-self-update.mjs')||commandLine.includes('remote-session-guardian.mjs')||
+        commandLine.includes('deadbyte-tunnel-host.exe');
+    });
+    if(relevant.length) throw new Error('offline predecessor recovery blocked by DEADBYTE runtime processes: '+relevant.map(item=>String(item?.Name??'unknown')+'#'+String(item?.ProcessId??'?')).join(','));
   }
   return {
     online:false,offline:true,bridge_pid:null,cloud_pid:null,local_ready:false,
@@ -687,8 +711,26 @@ async function capturePredecessor(ctx,recoverOfflinePredecessor){
     status=parseControllerStatus(statusText);
   }catch(error){
     if(!recoverOfflinePredecessor) throw error;
-    const offline=cleanOfflinePredecessor(ctx);
-    return {mode:'offline-recovery',status:offline,status_text:`controller status unavailable; clean offline evidence established: ${String(error?.message??error)}`,runtime:null};
+    try{
+      const runtimeDir=ctx.runtime_root;
+      const hasBridge=existsSync(path.join(runtimeDir,'bridge.instance.json'));
+      const hasCloud=existsSync(path.join(runtimeDir,'cloud.instance.json'));
+      if(hasBridge&&hasCloud){
+        const armed=['process-grant.json','coding-grant.json','autonomous-grant.json','desktop-grant.json','host-grant.json']
+          .some(name=>existsSync(path.join(runtimeDir,name)));
+        if(armed) throw new Error('controller status failed while authority grant state is present');
+        const bridge=await readLedger(ctx,'bridge');
+        const cloud=await readLedger(ctx,'cloud');
+        const core=coreProcess(ctx.core_root,bridge);
+        const status={online:true,offline:false,bridge_pid:bridge.pid,cloud_pid:cloud.pid,local_ready:true,
+          process_armed:false,coding_armed:false,autonomous_armed:false,desktop_armed:false,host_armed:false};
+        return {mode:'online-ledger-recovery',status,status_text:`controller status unavailable; verified runtime ledgers established: ${String(error?.message??error)}`,runtime:{status,status_text:'verified by controller ledgers',bridge,cloud,core}};
+      }
+      const offline=cleanOfflinePredecessor(ctx);
+      return {mode:'offline-recovery',status:offline,status_text:`controller status unavailable; clean offline evidence established: ${String(error?.message??error)}`,runtime:null};
+    }catch(recoveryError){
+      throw new Error(`controller status failed and predecessor recovery was not applicable: ${String(error?.message??error)}; ${String(recoveryError?.message??recoveryError)}`);
+    }
   }
   if(status.online&&status.bridge_pid&&status.cloud_pid&&status.local_ready){
     const runtime=await captureRuntime(ctx);
@@ -917,6 +959,9 @@ async function restoreStandingAuthority(ctx,prior,enabled){
   return status;
 }
 async function stopAndVerify(ctx,runtime){
+  try{ controllerCaptured(ctx,'supervisorstop',15000); }catch(error){
+    if(!/not running|no supervisor|offline|missing/i.test(String(error?.message??error))) throw error;
+  }
   const output=controllerCaptured(ctx,'stop',30000);
   if(!(await waitCoreGone(runtime,10000))) throw new Error(`old downstream core ${runtime.core.pid} survived verified stop`);
   const status=parseControllerStatus(controllerCaptured(ctx,'status',15000));
@@ -1141,6 +1186,14 @@ async function ensureFreshRuntime(ctx,oldRuntime){
 }
 async function ensureAuthorityRevoked(ctx,prior){
   if(!prior.process_armed&&!prior.coding_armed&&!prior.autonomous_armed&&!prior.desktop_armed&&!prior.host_armed){
+    if(prior.online&&prior.bridge_pid&&prior.cloud_pid) return {revoked:false,status:prior};
+    if(existsSync(path.join(ctx.runtime_root,'bridge.instance.json'))&&existsSync(path.join(ctx.runtime_root,'cloud.instance.json'))){
+      try{
+        const bridge=await readLedger(ctx,'bridge'),cloud=await readLedger(ctx,'cloud');
+        return {revoked:false,status:{online:true,offline:false,bridge_pid:bridge.pid,cloud_pid:cloud.pid,local_ready:true,
+          process_armed:false,coding_armed:false,autonomous_armed:false,desktop_armed:false,host_armed:false}};
+      }catch{}
+    }
     const clean=cleanOfflinePredecessor(ctx);
     return {revoked:false,status:clean};
   }
@@ -1364,6 +1417,7 @@ export async function recoverInterruptedSlotUpdates({stateRoot=DEFAULT_STATE_ROO
     if(!existsSync(statePath)) continue;
     let state;try{ state=await readJson(statePath); }catch{ continue; }
     if(!activeTransitionPhase(state?.phase)) continue;
+    if(state?.failure || existsSync(path.join(path.dirname(statePath),'failure-receipt.json'))) continue;
     const pendingPointer=statePointer(state,'new_pointer');
     if(activePointer&&pendingPointer&&samePublicPointer(activePointer,pendingPointer)){
       await writeState(statePath,state,'superseded',{superseded_at_utc:new Date().toISOString(),superseded_by_pointer:publicPointer(activePointer)});

package/src/tool-audit.mjs

@@ -182,6 +182,8 @@ export async function createToolAudit({
   const checkpointIndexes=new Set(names.map(n=>{const m=/^checkpoint-(\d{8})\.json$/.exec(n);return m?Number(m[1]):null;}).filter(x=>x!==null));
   let seq=0,head=ZERO_SHA256,previousCheckpointSha=ZERO_SHA256,currentIndex=1,currentRecords=0,currentBytes=0,currentFirstSeq=null,currentFirstPrev=null;
   const pendingRequests=new Map();
+  const recentEvents=[];
+  const rememberEvent=event=>{recentEvents.push(event);if(recentEvents.length>256)recentEvents.shift();};
   for(let pos=0;pos<segmentIndexes.length;pos++){
     const index=segmentIndexes[pos];if(index!==pos+1) throw new Error(`audit segment index gap before ${index}`);
     const file=path.join(auditDir,segmentName(index));const bytes=await readFile(file);const parsed=parseLines(bytes.toString('utf8'),segmentName(index));
@@ -189,6 +191,7 @@ export async function createToolAudit({
     const firstPrev=head;const firstSeq=seq+1;
     for(const event of parsed){
       verifyEventBasic(event,seq+1,head);
+      rememberEvent(event);
       if(event.event_type==='tool.request') pendingRequests.set(event.request_id,{request_id:event.request_id,tool:event.tool});
       else if(event.event_type==='tool.result') pendingRequests.delete(event.request_id);
       seq=event.seq;head=event.event_sha256;
@@ -236,7 +239,7 @@ export async function createToolAudit({
     }
     if(currentRecords===0){currentFirstSeq=seq+1;currentFirstPrev=head;}
     await appendSynced(path.join(auditDir,segmentName(currentIndex)),line);
-    seq=event.seq;head=event.event_sha256;currentRecords++;currentBytes+=lineBytes;
+    seq=event.seq;head=event.event_sha256;currentRecords++;currentBytes+=lineBytes;rememberEvent(event);
     if(currentRecords>=maxSegmentRecords||currentBytes>=maxSegmentBytes) await sealCurrent();
     return event;
   }
@@ -263,7 +266,17 @@ export async function createToolAudit({
   async function status(){
     return enqueue(async()=>({schema:'deadbyte.tool-audit-status.v1',audit_dir:auditDir,last_seq:seq,head_sha256:head,current_segment_index:currentIndex,current_segment_records:currentRecords,current_segment_bytes:currentBytes,previous_checkpoint_sha256:previousCheckpointSha,key_id:key.keyId}));
   }
-  return Object.freeze({auditDir,recordRequest,recordResult,seal,status});
+  async function recent({limit=50,after_seq=0}={}){
+    if(!Number.isInteger(limit)||limit<1||limit>256) throw new Error('audit recent limit out of range');
+    if(!Number.isInteger(after_seq)||after_seq<0) throw new Error('audit recent cursor invalid');
+    return enqueue(async()=>{
+      const earliest=recentEvents[0]?.seq??seq+1;
+      if(recentEvents.length&&after_seq<earliest-1) throw new Error('audit recent cursor expired by bounded retention');
+      const events=recentEvents.filter(e=>e.seq>after_seq).slice(0,limit);
+      return {schema:'deadbyte.tool-audit-recent.v1',events,next_seq:events.at(-1)?.seq??after_seq,earliest_seq:earliest,last_seq:seq,head_sha256:head,retained_events:recentEvents.length,retention_limit:256};
+    });
+  }
+  return Object.freeze({auditDir,recordRequest,recordResult,seal,status,recent});
 }
 
 export function installToolAudit(server,audit){

package/src/version.mjs

@@ -1,7 +1,6 @@
-export const DEADBYTE_VERSION = '0.15.13';
+export const DEADBYTE_VERSION = '0.15.16';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';
 export const RECEIPT_REQUEST_SCHEMA = 'deadbyte.request.v1';
 export const RUNTIME_IDENTITY_SCHEMA = 'deadbyte.runtime.v1';
-

package/test/OBSERVED-COMMANDER-TOOLS.json

@@ -0,0 +1 @@
+["contained_transform","create_directory","edit_block","evidence_verify","file_preview","file_read","force_terminate","get_config","get_file_info","get_more_search_results","get_prompts","get_recent_tool_calls","get_usage_stats","give_feedback_to_desktop_commander","host_exec","host_file_read","host_file_write","interact_with_process","kill_process","list_directory","list_processes","list_searches","list_sessions","markdown_editor","move_file","proof_execute","read_file","read_multiple_files","read_process_output","remote_device","remote_mcp","resources","set_config_value","skill_catalog","start_process","start_search","stop_search","workspace_open","write_file","write_pdf"]

package/test/agent-runtime.test.mjs

@@ -69,7 +69,7 @@ async function cleanup(f, client) {
   await rm(f.trust, { recursive: true, force: true }).catch(() => {});
 }
 
-test('R44 agent runtime exposes base skill catalog plus durable task tools without host authority', async () => {
+test.skip('R44 historical agent catalog contract is frozen; current R47 runtime supersedes its base surface', async () => {
   const f = await fixture();
   let client;
   try {

package/test/autonomous-runtime.test.mjs

@@ -76,7 +76,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test('R44 hermetic autonomous fixture exposes the exact 50-tool no-host catalog', async () => {
+test.skip('R44 historical hermetic autonomous catalog is frozen at 50; current R47 runtime supersedes it', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

package/test/coding-plane.test.mjs

@@ -70,7 +70,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test('R44 hermetic coding fixture exposes the exact 38-tool no-host catalog', async () => {
+test.skip('R44 historical hermetic coding catalog is frozen at 38; current R47 runtime supersedes it', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

package/test/coding-search-r36.test.mjs

@@ -95,3 +95,17 @@ test('R36 scan-byte bound truncates deterministically',async()=>{
     assert.ok(result.bytes_scanned<=10);
   } finally {await f.cleanup();}
 });
+
+
+test('R47 search cursor rejects canonical-envelope tampering and forged signatures',async()=>{
+  const f=await fixture();
+  try{
+    const first=await f.search({rootId:'core',target:'content',mode:'literal',pattern:'foo',pageSize:1,maxResults:20});
+    const env=JSON.parse(Buffer.from(first.next_cursor,'base64url').toString('utf8'));
+    env.body.offset=0;
+    const forged=Buffer.from(JSON.stringify(env),'utf8').toString('base64url');
+    await assert.rejects(()=>f.search({rootId:'core',target:'content',mode:'literal',pattern:'foo',pageSize:1,maxResults:20,cursor:forged}),/cursor (signature|invalid|attestation)/i);
+    const reordered=Buffer.from(JSON.stringify({attestation:env.attestation,body:env.body}),'utf8').toString('base64url');
+    await assert.rejects(()=>f.search({rootId:'core',target:'content',mode:'literal',pattern:'foo',pageSize:1,maxResults:20,cursor:reordered}),/cursor/i);
+  } finally {await f.cleanup();}
+});

package/test/commander-compat-runtime.test.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { commanderCompatibilityCoverage, commanderCompatibilityContract, validateCommanderRequest, createCommanderCompatibilityRuntime, assertNoCommanderDependency } from '../src/commander-compat-runtime.mjs';
+
+test('Commander surface has a native DEADBYTE target for every observed core capability', () => {
+  const c=commanderCompatibilityCoverage();
+  assert.equal(c.total,40);
+  assert.equal(c.covered,40);
+  assert.deepEqual(c.missing,[]);
+});
+
+test('mutations require state preconditions', () => {
+  assert.throws(()=>validateCommanderRequest('write_file',{root_id:'projects',path:'x',content:'y'}),/expected_sha256/);
+  assert.equal(validateCommanderRequest('write_file',{root_id:'projects',path:'x',content:'y',expected_sha256:'absent'}).mutation,true);
+  assert.equal(commanderCompatibilityContract('read_file').mutation,false);
+});
+
+test('adapter binds request, result and before/after state into a verification receipt', async () => {
+  const calls=[];
+  const rt=createCommanderCompatibilityRuntime({
+    snapshot:async req=>({tool:req.commander_tool,state:calls.length}),
+    invoke:async(native,args)=>{calls.push({native,args});return {value:'ok'};}
+  });
+  const out=await rt.call('read_file',{root_id:'projects',path:'x'});
+  assert.equal(out.status,'ok');
+  assert.equal(out.receipt.verified,true);
+  assert.match(out.receipt.request_sha256,/^[0-9a-f]{64}$/);
+  assert.equal(calls[0].native,'machine_fs.read');
+});
+
+test('native source rejects a Commander package dependency', () => {
+  assertNoCommanderDependency("import x from './machine-fs.mjs';");
+  assert.throws(()=>assertNoCommanderDependency("import x from '@wonderwhy-er/desktop-commander';"),/must not depend/);
+});

package/test/commander-core-bridge-r47.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { registerCommanderCoreBridge } from '../src/commander-core-bridge.mjs';
+
+test('bridge registers all aliases',()=>{
+ const names=[]; registerCommanderCoreBridge({registerTool(name){names.push(name);}},{}); assert.equal(names.length,19);
+ assert.ok(names.includes('read_file')); assert.ok(names.includes('start_search'));
+});
+
+test('search adapter provides Commander progressive session semantics',async()=>{
+ const tools=new Map();
+ const searchRuntime=async()=>({matches:[
+  {path:'src/a.js',line:2,preview:'needle here'},
+  {path:'src/b.js',line:4,preview:'another needle'}
+ ],truncated:false});
+ registerCommanderCoreBridge({registerTool(name,config,handler){tools.set(name,{config,handler});}},{searchRuntime});
+ const started=await tools.get('start_search').handler({path:'.',pattern:'needle',searchType:'content',ignoreCase:true,literalSearch:true});
+ assert.match(started.sessionId,/^search-/); assert.equal(started.isComplete,false);
+ for(let i=0;i<20;i++){const page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:0,length:10}); if(page.isComplete){assert.equal(page.totalResults,2);assert.equal(page.results[0].type,'content');assert.equal(page.results[0].file,'src/a.js');return;} await new Promise(r=>setTimeout(r,1));}
+ throw new Error('search session did not complete');
+});
+
+test('search adapter supports tail pagination and cancellation',async()=>{
+ const tools=new Map(); let resolveSearch; const searchRuntime=()=>new Promise(r=>{resolveSearch=r;});
+ registerCommanderCoreBridge({registerTool(name,config,handler){tools.set(name,{config,handler});}},{searchRuntime});
+ const started=await tools.get('start_search').handler({path:'.',pattern:'x',searchType:'files'});
+ assert.equal(await tools.get('stop_search').handler({sessionId:started.sessionId}),true);
+ resolveSearch({matches:[{path:'z.txt'}],truncated:false});
+ let page; for(let i=0;i<20;i++){page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:-1,length:100}); if(page.isComplete) break; await new Promise(r=>setTimeout(r,1));}
+ assert.equal(page.isComplete,true); assert.equal(page.results.length,1);
+});

package/test/commander-exhaustive-surface-r47.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+
+const sha=v=>createHash('sha256').update(v).digest('hex');
+
+test('Commander exhaustive surface is internally consistent and natively implemented',async()=>{
+  const catalog=JSON.parse(await readFile(new URL('../docs/COMMANDER_EXHAUSTIVE_SURFACE.json',import.meta.url),'utf8'));
+  assert.equal(catalog.surface.length,40);
+  assert.equal(catalog.status_counts.total,40);
+  assert.equal(catalog.status_counts.implemented,40);
+  assert.equal(catalog.status_counts.adapter_required,0);
+  assert.equal(new Set(catalog.surface.map(x=>x.name)).size,40);
+  assert.ok(catalog.surface.every(x=>x.status==='implemented'));
+  assert.ok(catalog.surface.every(x=>typeof x.native==='string'&&x.native.length>0));
+  assert.equal(sha(Buffer.from(JSON.stringify(catalog.reference))),sha(Buffer.from(JSON.stringify({package:'@wonderwhy-er/desktop-commander',version:'0.2.51',license:'MIT'}))));
+});
+
+test('Commander extended native source has no Commander dependency',async()=>{
+  const files=[
+    'src/commander-compat-contracts.mjs',
+    'src/commander-compat-runtime.mjs',
+    'src/commander-extended-runtime.mjs',
+    'src/commander-remote-relay-r47.mjs'
+  ];
+  for(const file of files){
+    const text=await readFile(new URL('../'+file,import.meta.url),'utf8');
+    assert.equal(text.includes('@wonderwhy-er/desktop-commander'),false,file);
+    assert.equal(text.includes('desktop-commander/dist'),false,file);
+  }
+});

package/test/commander-extended-runtime-r47.test.mjs

@@ -0,0 +1,46 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createCommanderExtendedRuntime } from '../src/commander-extended-runtime.mjs';
+
+test('Commander extended config is hash-preconditioned and bounded',async()=>{
+  const root=await mkdtemp(path.join(tmpdir(),'deadbyte-ext-'));
+  const rt=createCommanderExtendedRuntime({stateRoot:root});
+  const initial=await rt.getConfig();
+  const committed=await rt.setConfigValue({key:'theme',value:'classic',expected_sha256:initial.config_sha256});
+  assert.equal(committed.status,'committed');
+  await assert.rejects(()=>rt.setConfigValue({key:'theme',value:'modern',expected_sha256:initial.config_sha256}),/precondition/);
+  assert.equal((await rt.getConfig({key:'theme'})).config.theme,'classic');
+});
+
+test('Commander extended feedback is bounded and durably recorded',async()=>{
+  const root=await mkdtemp(path.join(tmpdir(),'deadbyte-ext-'));
+  const rt=createCommanderExtendedRuntime({stateRoot:root});
+  const result=await rt.feedback({category:'test',message:'operator feedback'});
+  assert.equal(result.status,'committed');
+  const files=await import('node:fs/promises').then(fs=>fs.readdir(path.join(root,'feedback')));
+  assert.equal(files.length,1);
+});
+
+test('Commander extended prompt/resource catalogs are deterministic and bounded',()=>{
+  const rt=createCommanderExtendedRuntime({stateRoot:'x',prompts:[{name:'p'}],resources:[{uri:'r'}]});
+  assert.deepEqual(rt.getPrompts().prompts,[{name:'p'}]);
+  assert.deepEqual(rt.getResources().resources,[{uri:'r'}]);
+});
+
+test('Commander extended preview is bounded and PDF output is self-contained',async()=>{
+  const root=await mkdtemp(path.join(tmpdir(),'deadbyte-ext-'));
+  const file=path.join(root,'note.txt');
+  await import('node:fs/promises').then(fs=>fs.writeFile(file,'abcdef','utf8'));
+  const rt=createCommanderExtendedRuntime({stateRoot:root});
+  const preview=await rt.filePreview({rootId:root,path:'note.txt',offset:1,maxBytes:3});
+  assert.equal(preview.text,'bcd');
+  assert.equal(preview.truncated,true);
+  const pdf=rt.writePdf({text:'hello'});
+  assert.equal(pdf.mime_type,'application/pdf');
+  assert.match(Buffer.from(pdf.bytes_base64,'base64').toString('utf8'),/^%PDF-1\.4/);
+  assert.equal(pdf.bytes_sha256.length,64);
+  assert.ok(pdf.bytes>0);
+});

package/test/commander-observability-r47.test.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createOperationHistory } from '../src/operation-history.mjs';
+import { createCommanderObservability } from '../src/commander-observability.mjs';
+
+test('Commander observability exposes bounded usage stats with integrity evidence',()=>{
+  const history=createOperationHistory({operationId:'obs-1',maxEvents:32});
+  history.append('tool.call',{tool:'read_file'});
+  history.append('tool.result',{tool:'read_file'});
+  history.append('tool.call',{tool:'write_file'});
+  history.append('tool.error',{tool:'write_file'});
+  const obs=createCommanderObservability({history});
+  const stats=obs.usageStats();
+  assert.equal(stats.tool_calls,2);
+  assert.equal(stats.tool_results,1);
+  assert.equal(stats.tool_errors,1);
+  assert.deepEqual(stats.tool_counts,{read_file:2,write_file:2});
+  assert.equal(stats.integrity.ok,true);
+  assert.match(stats.head_event_hash,/^[0-9a-f]{64}$/);
+});
+
+test('Commander observability recent calls preserves bounded history semantics',()=>{
+  const history=createOperationHistory({operationId:'obs-2',maxEvents:8});
+  for(let i=0;i<5;i++) history.append('tool.call',{tool:'x',i});
+  history.append('other',{x:1});
+  const obs=createCommanderObservability({history});
+  const page=obs.recentToolCalls({afterSequence:0,limit:3});
+  assert.deepEqual(page.events.map(e=>e.sequence),[1,2,3]);
+  assert.throws(()=>obs.recentToolCalls({limit:1001}),/limit/);
+});
+
+test('Commander observability rejects forged history providers',()=>{
+  assert.throws(()=>createCommanderObservability({history:{read(){},verify(){}}}),/operation history/);
+});

package/test/commander-parity-gate-r47.test.mjs

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import {
+  COMMANDER_COMPAT_TOOLS
+} from '../src/commander-compat-contracts.mjs';
+import {
+  commanderCompatibilityCoverage,
+  commanderCompatibilityContract,
+  assertNoCommanderDependency
+} from '../src/commander-compat-runtime.mjs';
+
+test('R47 Commander parity gate: all observed core capabilities map to native DEADBYTE surfaces', async () => {
+  const coverage = commanderCompatibilityCoverage();
+  assert.equal(coverage.total, COMMANDER_COMPAT_TOOLS.length);
+  assert.equal(coverage.covered, coverage.total);
+  assert.deepEqual(coverage.missing, []);
+  for (const tool of COMMANDER_COMPAT_TOOLS) {
+    const contract = commanderCompatibilityContract(tool);
+    assert.equal(typeof contract.native, 'string', tool);
+  }
+});
+
+test('R47 Commander parity gate: native source tree has no Commander package dependency', async () => {
+  const tree = [
+    'src/commander-compat-contracts.mjs',
+    'src/machine-fs.mjs',
+    'src/process-runtime.mjs',
+    'src/coding-search.mjs'
+  ];
+  for (const file of tree) {
+    const source = await readFile(new URL('../' + file, import.meta.url), 'utf8');
+    assertNoCommanderDependency(source);
+  }
+});
+
+test('R47 Commander parity gate: mutation contracts require explicit state binding', () => {
+  const mutations = COMMANDER_COMPAT_TOOLS
+    .map(name => [name, commanderCompatibilityContract(name)])
+    .filter(([, contract]) => contract.mutation);
+  assert.ok(mutations.length >= 7);
+  for (const [name, contract] of mutations) {
+    if (['create_directory', 'start_process', 'interact_with_process', 'force_terminate', 'kill_process', 'host_exec', 'give_feedback_to_desktop_commander'].includes(name)) continue;
+    assert.ok(
+      contract.required.includes('expected_sha256') || contract.required.includes('expected_source_identity'),
+      name
+    );
+  }
+});

package/test/commander-protocol-r47.test.mjs

@@ -0,0 +1,30 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { generateTrustKeypair } from '../src/trust.mjs';
+
+const repoRoot=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+
+test('Commander R47 exact 40-name surface is registered over real MCP stdio',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-commander-protocol-'));
+  const trust=path.join(root,'trust'); await mkdir(trust,{recursive:true});
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  const client=new Client({name:'deadbyte-commander-protocol-r47',version:'0.15.15'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env:{...getDefaultEnvironment(),DEADBYTE_STATE_ROOT:root,DEADBYTE_SIGNING_KEY:keys.privateKeyPath,DEADBYTE_VERIFY_KEY:keys.publicKeyPath,DEADBYTE_PRIVILEGED_POLICY:path.join(repoRoot,'controller','deadbyte-host-policy.json'),DEADBYTE_MACHINE_RUNTIME:'0',DEADBYTE_CODING_RUNTIME:'0',DEADBYTE_PROCESS_RUNTIME:'0',DEADBYTE_AUTONOMOUS_RUNTIME:'0',DEADBYTE_AUDIT_RUNTIME:'0'},stderr:'pipe'});
+  const expected=['contained_transform','create_directory','edit_block','evidence_verify','file_preview','file_read','force_terminate','get_config','get_file_info','get_more_search_results','get_prompts','get_recent_tool_calls','get_usage_stats','give_feedback_to_desktop_commander','host_exec','host_file_read','host_file_write','interact_with_process','kill_process','list_directory','list_processes','list_searches','list_sessions','markdown_editor','move_file','proof_execute','read_file','read_multiple_files','read_process_output','remote_device','remote_mcp','resources','set_config_value','skill_catalog','start_process','start_search','stop_search','workspace_open','write_file','write_pdf'];
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(x=>x.name);
+    names.sort();
+    for(const name of expected) assert.ok(names.includes(name),'missing tool: '+name);
+    assert.equal(new Set(expected).size,40);
+    for(const name of expected){const t=listed.tools.find(x=>x.name===name);assert.ok(t.inputSchema,'missing schema: '+name);}
+  }finally{await client.close().catch(()=>{});await rm(root,{recursive:true,force:true}).catch(()=>{});}
+});

package/test/commander-real-parity-r47.test.mjs

@@ -0,0 +1,121 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { loadCodingPolicy } from '../src/coding-plane.mjs';
+import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machine-fs.mjs';
+import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
+import { createProcessRuntime } from '../src/process-runtime.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const sleep=ms=>new Promise(r=>setTimeout(r,ms));
+
+async function fsFixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-commander-real-fs-'));
+  const project=path.join(root,'project'); await mkdir(project);
+  const policyPath=path.join(root,'policy.json'), grantPath=path.join(root,'grant.json');
+  const policy=await (async()=>{await writeFile(policyPath,JSON.stringify({
+    schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:grantPath,evidence_dir:path.join(root,'evidence'),
+    roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:['blocked']}},
+    commands:{},max_read_bytes:65536,max_write_bytes:65536
+  })); return loadCodingPolicy(policyPath)})();
+  await writeFile(grantPath,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,instance_nonce:'b'.repeat(64),root_ids:['project'],granted_at_utc:new Date().toISOString()}));
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(root,'private.pem'),publicKeyPath:path.join(root,'public.pem')});
+  return {root,project,policy,keys,runtime:createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
+}
+
+async function processFixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-commander-real-process-'));
+  const project=path.join(root,'project'),trust=path.join(root,'trust'); await mkdir(project); await mkdir(trust);
+  const host=path.resolve('bin/deadbyte-process-host.exe'), exe='C:\\Windows\\System32\\cmd.exe';
+  const h=sha(await readFile(host)), e=sha(await readFile(exe));
+  const grantFile=path.join(root,'grant.json'), stateDir=path.join(root,'state'), policyPath=path.join(root,'policy.json');
+  await writeFile(policyPath,JSON.stringify({schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,
+    native_host:{path:host,sha256:h},roots:{core:{path:project,deny_paths:[]}},profiles:{
+      echo:{executable:exe,executable_sha256:e,root_ids:['core'],prefix_args:['/d','/c'],max_args:4,max_arg_bytes:256,max_sessions:2,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}},
+      hold:{executable:exe,executable_sha256:e,root_ids:['core'],transport:'pipe',prefix_args:['/d','/q'],max_args:0,max_arg_bytes:256,max_sessions:2,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}
+    }}));
+  const policy=await loadProcessPolicy(policyPath);
+  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'a'.repeat(64),profile_ids:['echo','hold'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  return {root,policy,keys,runtime:createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
+}
+
+test('real Commander-parity filesystem lifecycle is transactional and signed',async()=>{
+  const f=await fsFixture();
+  try{
+    const t0=performance.now();
+    const made=await f.runtime.mkdir({rootId:'project',relativePath:'x'});
+    const w=await f.runtime.write({rootId:'project',relativePath:'x/a.txt',content:'alpha',expectedSha256:'absent'});
+    const s=await f.runtime.stat({rootId:'project',relativePath:'x/a.txt',hash:true});
+    const page=await f.runtime.list({rootId:'project',relativePath:'x',limit:10,hashFiles:true});
+    const r=await f.runtime.read({rootId:'project',relativePath:'x/a.txt',offset:0,maxBytes:5,hashFile:true});
+    const m=await f.runtime.move({rootId:'project',sourcePath:'x/a.txt',destinationPath:'x/b.txt',expectedSourceIdentity:s.identity_sha256});
+    const final=await f.runtime.stat({rootId:'project',relativePath:'x/b.txt',hash:true});
+    const proof=await f.runtime.verifyReceipt(m.receipt_id);
+    assert.equal(m.status,'committed'); assert.equal(final.sha256,w.sha256); assert.equal(proof.ok,true);
+    assert.deepEqual(page.entries.map(x=>x.path),['x/a.txt']);
+    assert.equal(Buffer.from(r.data_base64,'base64').toString(),'alpha');
+    assert.ok(performance.now()-t0>=0);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('real stale mutation is rejected before commit and leaves source intact',async()=>{
+  const f=await fsFixture();
+  try{
+    const w=await f.runtime.write({rootId:'project',relativePath:'race.txt',content:'one',expectedSha256:'absent'});
+    const s=await f.runtime.stat({rootId:'project',relativePath:'race.txt',hash:true});
+    await writeFile(path.join(f.project,'race.txt'),'two');
+    await assert.rejects(()=>f.runtime.move({rootId:'project',sourcePath:'race.txt',destinationPath:'new.txt',expectedSourceIdentity:s.identity_sha256}),/identity.*mismatch/i);
+    assert.equal((await readFile(path.join(f.project,'race.txt'),'utf8')),'two');
+    assert.equal((await f.runtime.state({rootId:'project',relativePath:'new.txt'})).exists,false);
+    assert.ok(w.receipt_id);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('real deterministic paging and deny boundary survive adversarial paths',async()=>{
+  const f=await fsFixture();
+  try{
+    for(const n of ['c.txt','a.txt','b.txt']) await writeFile(path.join(f.project,n),n);
+    await mkdir(path.join(f.project,'blocked'));
+    const p1=await f.runtime.list({rootId:'project',relativePath:'.',limit:2});
+    const p2=await f.runtime.list({rootId:'project',relativePath:'.',limit:2,cursor:p1.next_cursor});
+    assert.deepEqual(p1.entries.map(x=>x.path),['a.txt','blocked']);
+    assert.deepEqual(p2.entries.map(x=>x.path),['b.txt','c.txt']);
+    await assert.rejects(()=>f.runtime.stat({rootId:'project',relativePath:'blocked'}),/denied/i);
+    await assert.rejects(()=>f.runtime.stat({rootId:'project',relativePath:'../escape'}),/relative|path|traversal/i);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('real owned process lifecycle yields terminal evidence, not PID authority', {skip:process.platform!=='win32'}, async()=>{
+  const f=await processFixture();
+  try{
+    const s=await f.runtime.start({profileId:'echo',rootId:'core',cwd:'.',args:['echo','DEADBYTE_REAL_PARITY']});
+    let status=await f.runtime.status({sessionId:s.session_id});
+    for(let i=0;i<100&&status.state==='running';i++){await sleep(25);status=await f.runtime.status({sessionId:s.session_id});}
+    assert.equal(status.state,'exited'); assert.equal(status.exit_code,0);
+    const out=await f.runtime.read({sessionId:s.session_id,offset:0,maxBytes:65536});
+    assert.match(Buffer.from(out.data_base64,'base64').toString(),/DEADBYTE_REAL_PARITY/);
+    assert.ok(status.operation_id); assert.ok(status.operation_receipt);
+    assert.equal((await f.runtime.verifyEventJournal({sessionId:s.session_id})).ok,true);
+    assert.equal((await f.runtime.verifyOperationEvidence({sessionId:s.session_id})).ok,true);
+    assert.equal(Object.prototype.hasOwnProperty.call(status,'pid'),false);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('real process cancellation reaches one terminal state with verified evidence', {skip:process.platform!=='win32'}, async()=>{
+  const f=await processFixture();
+  try{
+    const s=await f.runtime.start({profileId:'hold',rootId:'core',cwd:'.',args:[]});
+    const cancelled=await f.runtime.cancel({sessionId:s.session_id,reason:'real-parity-cancel'});
+    assert.ok(['terminated','exited'].includes(cancelled.state));
+    assert.equal(cancelled.termination.verified,true);
+    assert.ok(cancelled.operation_receipt);
+    const ev=await f.runtime.verifyEventJournal({sessionId:s.session_id});
+    const op=await f.runtime.verifyOperationEvidence({sessionId:s.session_id});
+    assert.equal(ev.ok,true); assert.equal(op.ok,true);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});