deadbyte-mcp 0.15.15 → 0.15.17

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,33 @@
+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);
+    assert.equal(client.getProtocolEra(),'modern');
+    assert.equal(client.getNegotiatedProtocolVersion(),'2026-07-28');
+    assert.ok(client.getDiscoverResult()?.supportedVersions?.includes('2026-07-28'));
+    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}); }
+});

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

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { registerCommanderRemoteBridge } from '../src/commander-remote-bridge-r47.mjs';
+
+function fakeServer(){
+  const tools=new Map();
+  return {tools,registerTool(name,meta,handler){tools.set(name,{meta,handler});}};
+}
+function fakePlane(){
+  const calls=[];
+  const result=(op,value)=>{calls.push({op,value});return {status:'ok',op,value};};
+  return {calls,pair:async value=>result('pair',value),status:async value=>result('status',value),reportOnline:async value=>result('report_online',value),probe:async value=>result('probe',value),dispatch:async value=>result('dispatch',value),revoke:async value=>result('revoke',value),rotateCredential:async value=>result('rotate_credential',value),list:async()=>result('list',{})};
+}
+
+test('R47 remote Commander bridge routes remote_device directly to remote-device-r44 plane',async()=>{
+  const server=fakeServer(),plane=fakePlane();
+  registerCommanderRemoteBridge(server,{remoteDevicePlane:plane});
+  assert.ok(server.tools.has('remote_device'));assert.ok(server.tools.has('remote_mcp'));
+  const tool=server.tools.get('remote_device').handler;const id='a'.repeat(64);
+  await tool({op:'pair',public_key_spki_base64:'ZmFrZQ==',display_name:'lab'});
+  await tool({op:'status',device_id:id});await tool({op:'report_online',device_id:id,epoch:1,connection_id:'c'});
+  await tool({op:'probe',device_id:id,epoch:1});await tool({op:'dispatch',device_id:id,epoch:1,capability_id:'machine.status',payload:{},request_id:'b'.repeat(64)});
+  await tool({op:'revoke',device_id:id,epoch:1});await tool({op:'rotate_credential',device_id:id,epoch:1,encrypted_bundle_base64:'dG9rZW4=',expected_previous_sha256:null});await tool({op:'list'});
+  assert.deepEqual(plane.calls.map(x=>x.op),['pair','status','report_online','probe','dispatch','revoke','rotate_credential','list']);
+});
+
+test('R47 remote_mcp is a thin dispatch surface and never shells out to Commander',async()=>{
+  const server=fakeServer(),plane=fakePlane();registerCommanderRemoteBridge(server,{remoteDevicePlane:plane});
+  const id='c'.repeat(64),request='d'.repeat(64);
+  const result=await server.tools.get('remote_mcp').handler({device_id:id,epoch:7,capability_id:'coding.file_read',payload:{path:'README.md'},request_id:request});
+  assert.equal(result.status,'ok');
+  assert.deepEqual(plane.calls,[{op:'dispatch',value:{deviceId:id,epoch:7,capabilityId:'coding.file_read',payload:{path:'README.md'},requestId:request}}]);
+});
+
+test('R47 remote surfaces fail closed as unavailable when no remote-device-r44 plane is wired',async()=>{
+  const server=fakeServer();registerCommanderRemoteBridge(server,{});
+  const result=await server.tools.get('remote_device').handler({op:'list'});
+  assert.equal(result.status,'unavailable');assert.match(result.error,/remote-device-r44 plane is not configured/);
+});

package/test/commander-remote-plane-r47.test.mjs

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+
+const sha=value=>createHash('sha256').update(value).digest('hex');
+
+test('R47 production server wires native remote device plane',async()=>{
+  const server=await readFile(new URL('../src/mcp-server.mjs',import.meta.url),'utf8');
+  assert.match(server,/createRemoteDevicePlaneR44/);
+  assert.match(server,/createCommanderRemoteRelayR47/);
+  assert.match(server,/registerCommanderRemoteBridge/);
+  assert.match(server,/DEADBYTE_REMOTE_RELAY_ENDPOINT\|\|process\.env\.DEADBYTE_REMOTE_ENDPOINT/);
+  assert.match(server,/DEADBYTE_REMOTE_CAPABILITIES/);
+  assert.match(server,/remote-device-r44/);
+  assert.equal((server.match(/commander-remote-relay-r47\.mjs/g)??[]).length,1);
+});
+
+test('R47 relay is native MCP client and contains no Desktop Commander dependency',async()=>{
+  const relay=await readFile(new URL('../src/commander-remote-relay-r47.mjs',import.meta.url),'utf8');
+  assert.match(relay,/StreamableHTTPClientTransport/);
+  assert.match(relay,/client\.callTool/);
+  assert.doesNotMatch(relay,/@wonderwhy-er\/desktop-commander/);
+  assert.equal(sha(relay).length,64);
+});

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

@@ -0,0 +1,146 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+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 } 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';
+import { createHash } from 'node:crypto';
+
+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-torture-fs-')), project=path.join(root,'project');
+  await mkdir(project);
+  const policyPath=path.join(root,'policy.json'), grantPath=path.join(root,'grant.json');
+  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}));
+  const policy=await loadCodingPolicy(policyPath);
+  await writeFile(grantPath,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,instance_nonce:'c'.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,runtime:createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
+}
+
+async function processFixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-torture-proc-')), 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 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:sha(await readFile(host))},roots:{core:{path:project,deny_paths:[]}},profiles:{
+    echo:{executable:exe,executable_sha256:sha(await readFile(exe)),root_ids:['core'],prefix_args:['/d','/c'],max_args:4,max_arg_bytes:256,max_sessions:8,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}},
+    hold:{executable:exe,executable_sha256:sha(await readFile(exe)),root_ids:['core'],transport:'pipe',prefix_args:['/d','/q'],max_args:0,max_arg_bytes:256,max_sessions:8,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:'d'.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,runtime:createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
+}
+
+test('torture: concurrent stale writers permit exactly one winner per version',async()=>{
+  const f=await fsFixture();
+  try{
+    let expected='absent', winners=0, conflicts=0;
+    for(let round=0;round<12;round++){
+      const target='race.txt';
+      const before=await f.runtime.state({rootId:'project',relativePath:target});
+      expected=before.exists?before.sha256:'absent';
+      const results=await Promise.allSettled(Array.from({length:8},(_,i)=>f.runtime.write({rootId:'project',relativePath:target,content:`round=${round};writer=${i}`,expectedSha256:expected})));
+      const ok=results.filter(x=>x.status==='fulfilled'&&x.value.status==='committed');
+      winners+=ok.length; conflicts+=results.filter(x=>x.status==='rejected').length;
+      assert.equal(ok.length,1);
+      assert.equal(conflicts>=round+7,true);
+      const current=await f.runtime.stat({rootId:'project',relativePath:target,hash:true});
+      assert.equal(current.sha256,ok[0].value.sha256);
+    }
+    assert.equal(winners,12);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('torture: move/delete races cannot duplicate or silently lose an object',async()=>{
+  const f=await fsFixture();
+  try{
+    await f.runtime.write({rootId:'project',relativePath:'source.txt',content:'immutable',expectedSha256:'absent'});
+    const s=await f.runtime.stat({rootId:'project',relativePath:'source.txt',hash:true});
+    const [a,b]=await Promise.allSettled([
+      f.runtime.move({rootId:'project',sourcePath:'source.txt',destinationPath:'a.txt',expectedSourceIdentity:s.identity_sha256}),
+      f.runtime.move({rootId:'project',sourcePath:'source.txt',destinationPath:'b.txt',expectedSourceIdentity:s.identity_sha256})
+    ]);
+    assert.equal([a,b].filter(x=>x.status==='fulfilled').length,1);
+    const stateA=await f.runtime.state({rootId:'project',relativePath:'a.txt'});
+    const stateB=await f.runtime.state({rootId:'project',relativePath:'b.txt'});
+    assert.equal(Number(stateA.exists)+Number(stateB.exists),1);
+    const winner=stateA.exists?stateA:stateB;
+    assert.equal(winner.sha256,sha(Buffer.from('immutable')));
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('torture: pagination remains deterministic under concurrent directory churn',async()=>{
+  const f=await fsFixture();
+  try{
+    for(let i=0;i<40;i++) await writeFile(path.join(f.project,`f${String(i).padStart(2,'0')}.txt`),String(i));
+    let cursor=null;
+    const first=await f.runtime.list({rootId:'project',relativePath:'.',limit:7,cursor});
+    assert.equal(first.entries.length,7);
+    cursor=first.next_cursor;
+    const churn=(async()=>{for(let i=0;i<20;i++){
+      const p=path.join(f.project,"z"+i+".tmp");
+      await writeFile(p,'z');
+      await rm(p,{force:true});
+    }
+    await writeFile(path.join(f.project,'persistent-churn.txt'),'changed');})(); 
+    await churn;
+    await assert.rejects(
+      ()=>f.runtime.list({rootId:'project',relativePath:'.',limit:7,cursor}),
+      /cursor snapshot changed/i
+    );
+  } finally {
+    for (let i=0;i<20;i++) {
+      try { await rm(f.root,{recursive:true,force:true}); break; }
+      catch (error) { if (error?.code!=='EBUSY' && error?.code!=='ENOTEMPTY') throw error; await sleep(50); }
+    }
+  }
+});
+
+test('torture: process cancellation race converges to one verified terminal state', {skip:process.platform!=='win32'}, async()=>{
+  const f=await processFixture();
+  try{
+    const s=await f.runtime.start({profileId:'hold',rootId:'core',cwd:'.',args:[]});
+    const results=await Promise.allSettled([
+      f.runtime.cancel({sessionId:s.session_id,reason:'race-a'}),
+      f.runtime.cancel({sessionId:s.session_id,reason:'race-b'}),
+      f.runtime.status({sessionId:s.session_id})
+    ]);
+    const cancels=results.filter(x=>x.status==='fulfilled'&&x.value.termination);
+    assert.ok(cancels.length>=1);
+    const deadline=Date.now()+5000; let status=await f.runtime.status({sessionId:s.session_id});
+    while(status.state==='running'&&Date.now()<deadline){await sleep(20);status=await f.runtime.status({sessionId:s.session_id});}
+    assert.notEqual(status.state,'running');
+    assert.ok(status.operation_receipt); assert.ok(status.operation_id);
+    assert.equal((await f.runtime.verifyEventJournal({sessionId:s.session_id})).ok,true);
+    assert.equal((await f.runtime.verifyOperationEvidence({sessionId:s.session_id})).ok,true);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('torture: process session identity cannot be replaced by a foreign session id', {skip:process.platform!=='win32'}, async()=>{
+  const f=await processFixture();
+  try{
+    const a=await f.runtime.start({profileId:'echo',rootId:'core',cwd:'.',args:['echo','A']});
+    const b=await f.runtime.start({profileId:'echo',rootId:'core',cwd:'.',args:['echo','B']});
+    await assert.rejects(()=>f.runtime.read({sessionId:'f'.repeat(64),offset:0,maxBytes:64}),/session|not found|unknown/i);
+    await f.runtime.cancel({sessionId:a.session_id,reason:'cleanup'});
+    await f.runtime.cancel({sessionId:b.session_id,reason:'cleanup'});
+    for (const id of [a.session_id,b.session_id]) {
+      let s=await f.runtime.status({sessionId:id});
+      for(let i=0;i<100&&s.state==='running';i++){await sleep(20);s=await f.runtime.status({sessionId:id});}
+      assert.notEqual(s.state,'running');
+    }
+    for(let i=0;i<20;i++){
+      try { await rm(f.root,{recursive:true,force:true}); return; }
+      catch(error){ if(error?.code!=='EBUSY') throw error; await sleep(50); }
+    }
+    await rm(f.root,{recursive:true,force:true});
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});