deadbyte-mcp 0.15.14 → 0.15.16

package/docs/R47-FULL-TOOL-CATALOG.json

@@ -0,0 +1,123 @@
+{
+  "schema": "deadbyte.r47-full-catalog.v1",
+  "train": "R47",
+  "source": "runtime.tools/list",
+  "tool_count": 115,
+  "tools": [
+    "agent_task_approve",
+    "agent_task_cancel",
+    "agent_task_events",
+    "agent_task_run",
+    "agent_task_status",
+    "agent_task_submit",
+    "agent_task_verify",
+    "autonomous_goal_approve",
+    "autonomous_goal_cancel",
+    "autonomous_goal_events",
+    "autonomous_goal_run",
+    "autonomous_goal_status",
+    "autonomous_goal_submit",
+    "autonomous_goal_verify",
+    "autonomous_release_gate",
+    "autonomous_session_status",
+    "coding_benchmark_run",
+    "coding_command_run",
+    "coding_file_read",
+    "coding_file_write",
+    "coding_files_read",
+    "coding_receipt_verify",
+    "coding_search",
+    "coding_session_status",
+    "coding_stat",
+    "coding_symbol_definition",
+    "coding_symbol_diagnostics",
+    "coding_symbol_implementations",
+    "coding_symbol_outline",
+    "coding_symbol_references",
+    "coding_symbol_rename_preview",
+    "coding_symbol_replace",
+    "coding_task_approve",
+    "coding_task_cancel",
+    "coding_task_events",
+    "coding_task_run",
+    "coding_task_status",
+    "coding_task_submit",
+    "coding_task_verify",
+    "coding_text_replace",
+    "coding_tree",
+    "contained_transform",
+    "create_directory",
+    "desktop_action",
+    "desktop_observe",
+    "desktop_status",
+    "desktop_target",
+    "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",
+    "machine_fs_delete",
+    "machine_fs_edit_exact",
+    "machine_fs_list",
+    "machine_fs_mkdir",
+    "machine_fs_move",
+    "machine_fs_read",
+    "machine_fs_stat",
+    "machine_fs_write",
+    "machine_hardware_query",
+    "machine_list",
+    "machine_ping",
+    "machine_process_list",
+    "machine_revoke",
+    "machine_search_cancel",
+    "machine_search_page",
+    "machine_search_start",
+    "machine_search_status",
+    "machine_status",
+    "machine_system_status",
+    "markdown_editor",
+    "move_file",
+    "native_diff_apply",
+    "native_diff_preview",
+    "native_diff_verify",
+    "process_session_action",
+    "process_session_cancel",
+    "process_session_list",
+    "process_session_read",
+    "process_session_start",
+    "process_session_status",
+    "process_session_terminate",
+    "process_session_write",
+    "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.14",
+  "version": "0.15.16",
   "private": false,
   "type": "module",
   "description": "Authenticated MCP agentic runtime with signed skills, persistent model backends, identity-bound remote devices, durable job supervision, immutable release slots, and separately revocable machine authority.",
@@ -65,7 +65,10 @@
     "r45:full:test": "node scripts/full-regression-r45.mjs",
     "finalize:r45": "node scripts/finalize-r45.mjs",
     "r46:fileless:test": "node --test --test-concurrency=1 test/process-policy.test.mjs test/process-policy-refresh.test.mjs test/release-generation.test.mjs test/process-runtime.test.mjs test/process-mcp-tools.test.mjs test/compact-gateway-r36.test.mjs test/capability-ledger-r36.test.mjs test/remote-device-r44.test.mjs test/observation-runtime.test.mjs test/observation-mcp-tools.test.mjs",
-    "r46:full:test": "node scripts/full-regression-r46.mjs"
+    "r46:full:test": "node scripts/full-regression-r46.mjs",
+    "r47:full:test": "node scripts/full-regression-r47.mjs",
+    "r47:catalog:test": "node --test --test-concurrency=1 test/full-max-catalog-r47.test.mjs",
+    "r47:hardening:test": "node scripts/commander-hardening-gate-r47.mjs"
   },
   "bundleDependencies": [
     "@modelcontextprotocol/server",

package/scripts/commander-hardening-gate-r47.mjs

@@ -0,0 +1,35 @@
+import { spawnSync } from 'node:child_process';
+
+const suites = [
+  'test/commander-compat-runtime.test.mjs',
+  'test/commander-parity-gate-r47.test.mjs',
+  'test/commander-real-parity-r47.test.mjs',
+  'test/commander-torture-r47.test.mjs',
+  'test/machine-fs-runtime.test.mjs',
+  'test/coding-search-r36.test.mjs',
+  'test/process-runtime.test.mjs',
+  'test/commander-observability-r47.test.mjs',
+  'test/commander-extended-runtime-r47.test.mjs',
+  'test/commander-exhaustive-surface-r47.test.mjs',
+  'test/commander-core-bridge-r47.test.mjs',
+  'test/commander-protocol-r47.test.mjs'
+];
+
+const startedAt = new Date().toISOString();
+const result = spawnSync(process.execPath, ['--test', '--test-concurrency=1', ...suites], {
+  cwd: process.cwd(),
+  stdio: 'inherit',
+  windowsHide: true
+});
+const exitCode = result.status ?? 1;
+const signal = result.signal ?? null;
+console.log(JSON.stringify({
+  schema: 'deadbyte.commander-hardening-gate.v1',
+  started_at_utc: startedAt,
+  completed_at_utc: new Date().toISOString(),
+  suites,
+  exit_code: exitCode,
+  signal,
+  passed: exitCode === 0
+}, null, 2));
+process.exit(exitCode);

package/scripts/commander-parity-benchmark.mjs

@@ -0,0 +1,6 @@
+import { performance } from 'node:perf_hooks';
+import { commanderCompatibilityCoverage, commanderCompatibilityContract, validateCommanderRequest } from '../src/commander-compat-runtime.mjs';
+const N=5000;
+const workloads=[['read_file',{root_id:'projects',path:'x'}],['list_directory',{root_id:'projects',path:'.'}],['get_file_info',{root_id:'projects',path:'x'}],['read_multiple_files',{root_id:'projects',paths:['a','b','c']}],['start_search',{root_id:'projects',path:'.',pattern:'*.mjs'}],['list_searches',{}],['start_process',{profile_id:'node_script',root_id:'projects'}],['read_process_output',{session_id:'0'.repeat(64)}],['write_file',{root_id:'projects',path:'x',content:'x',expected_sha256:'absent'}],['move_file',{root_id:'projects',source_path:'a',destination_path:'b',expected_source_identity:'0'.repeat(64)}]];
+const rows=[]; for(const [name,args] of workloads){const t0=performance.now();for(let i=0;i<N;i++)validateCommanderRequest(name,args);const ms=performance.now()-t0;rows.push({name,iterations:N,elapsed_ms:+ms.toFixed(3),ops_per_sec:Math.round(N/(ms/1000)),native:commanderCompatibilityContract(name).native});}
+console.log(JSON.stringify({schema:'deadbyte.commander-parity-benchmark.v1',coverage:commanderCompatibilityCoverage(),workloads:rows,total_iterations:N*workloads.length},null,2));

package/scripts/commander-real-performance-benchmark-r47.mjs

@@ -0,0 +1,41 @@
+import { performance } from 'node:perf_hooks';
+import { mkdtemp, writeFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { loadCodingPolicy } from '../src/coding-plane.mjs';
+import { createMachineFsRuntime } from '../src/machine-fs.mjs';
+
+const N=50;
+const commanderFs=await import(pathToFileURL('D:/Projects/desktop-commander-stage-20260922/desktop-commander/dist/tools/filesystem.js').href);
+const { readFileFromDisk, readMultipleFiles, listDirectory, getFileInfo }=commanderFs;
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-commander-bench-'));
+const fixture=path.join(root,'fixture');
+await (await import('node:fs/promises')).mkdir(fixture);
+await writeFile(path.join(fixture,'a.txt'),'alpha\\n'.repeat(64));
+await writeFile(path.join(fixture,'b.txt'),'bravo\\n'.repeat(64));
+await writeFile(path.join(fixture,'c.txt'),'charlie\\n'.repeat(64));
+const policyPath=path.join(root,'policy.json'), grantPath=path.join(root,'grant.json');
+const policyDoc={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:grantPath,evidence_dir:path.join(root,'evidence'),roots:{bench:{path:fixture,read:true,write:false,exec:false,deny_paths:[]}},commands:{},max_read_bytes:65536,max_write_bytes:65536};
+await writeFile(policyPath,JSON.stringify(policyDoc));
+const policy=await loadCodingPolicy(policyPath);
+await writeFile(grantPath,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,instance_nonce:'e'.repeat(64),root_ids:['bench'],granted_at_utc:new Date().toISOString()}));
+const keys=await generateTrustKeypair({privateKeyPath:path.join(root,'private.pem'),publicKeyPath:path.join(root,'public.pem')});
+const db=createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+const commanderFile=path.join(fixture,'a.txt');
+const commanderDir=fixture;
+const t=async(label,fn,n=N)=>{const t0=performance.now();for(let i=0;i<n;i++)await fn();return {label,iterations:n,elapsed_ms:+(performance.now()-t0).toFixed(3),ops_per_sec:Math.round(n/((performance.now()-t0)/1000))};};
+const rows=[];
+rows.push(await t('Commander read_file',()=>readFileFromDisk(commanderFile,{offset:0,length:4096})));
+rows.push(await t('DEADBYTE read_file',()=>db.read({rootId:'bench',relativePath:'a.txt',offset:0,maxBytes:4096})));
+rows.push(await t('Commander list_directory',()=>listDirectory(commanderDir,1)));
+rows.push(await t('DEADBYTE list_directory',()=>db.list({rootId:'bench',relativePath:'.',limit:100})));
+rows.push(await t('Commander get_file_info',()=>getFileInfo(commanderFile)));
+rows.push(await t('DEADBYTE get_file_info',()=>db.stat({rootId:'bench',relativePath:'a.txt',hash:true})));
+rows.push(await t('Commander read_multiple_files',()=>readMultipleFiles([path.join(commanderDir,'a.txt'),path.join(commanderDir,'b.txt')])));
+rows.push(await t('DEADBYTE read_multiple_files', async()=>{ await db.read({rootId:'bench',relativePath:'a.txt',offset:0,maxBytes:4096}); await db.read({rootId:'bench',relativePath:'b.txt',offset:0,maxBytes:4096}); }));
+console.log(JSON.stringify({schema:'deadbyte.commander-real-performance-benchmark.v1',reference:'@wonderwhy-er/desktop-commander dist local stage',iterations:N,rows},null,2));
+await rm(root,{recursive:true,force:true});

package/scripts/deploy-r47.mjs

@@ -1,13 +1,61 @@
 import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
+import { readFile, access } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { loadPowerShellDataFile, runSlotUpdateCli } from '../src/runtime-update.mjs';
+import { parseActivePointer } from '../src/release-slot.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 const state=path.join(os.homedir(),'.deadbyte-mcp');
 const sha=async f=>createHash('sha256').update(await readFile(f)).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+
+async function waitForActivation({handoffPath,expectedVersion,expectedManifest,timeoutMs=900000,pollMs=1000}){
+  const evidenceDir=path.dirname(path.resolve(handoffPath));
+  const statePath=path.join(evidenceDir,'state.json');
+  const receiptPath=path.join(evidenceDir,'receipt.json');
+  const failurePath=path.join(evidenceDir,'failure-receipt.json');
+  const deadline=Date.now()+timeoutMs;
+  let lastPhase='unknown';
+
+  while(Date.now()<deadline){
+    // Do not poll state.json during activation: the detached supervisor atomically replaces it,
+    // and Windows can reject that rename while a read handle is still open. Final receipt/failure
+    // files are the synchronization boundary and avoid a cross-process read/write race.
+    try{
+      const receipt=JSON.parse(await readFile(receiptPath,'utf8'));
+      const body=receipt?.body;
+      const pointer=body?.active_pointer;
+      if(body?.schema!=='deadbyte.r27-slot-update-receipt.v1') throw new Error('activation receipt schema mismatch');
+      if(body?.rollback_performed!==false) throw new Error('activation receipt reports rollback');
+      if(pointer?.version!==expectedVersion||pointer?.manifest_sha256!==expectedManifest) {
+        throw new Error('activation receipt target mismatch');
+      }
+      parseActivePointer(JSON.stringify(pointer));
+
+      const activePath=path.join(state,'active-release.json');
+      const active=parseActivePointer(await readFile(activePath,'utf8'));
+      if(active.version!==expectedVersion||active.manifest_sha256!==expectedManifest) {
+        throw new Error('active pointer does not match expected release');
+      }
+      return {receiptPath,statePath,phase:lastPhase,release_id:active.release_id};
+    }catch(error){
+      if(error?.code!=='ENOENT') throw error;
+    }
+
+    try{
+      await access(failurePath);
+      throw new Error('slot activation failure receipt detected');
+    }catch(error){
+      if(error?.code!=='ENOENT') throw error;
+    }
+    await sleep(pollMs);
+  }
+  throw new Error(`slot activation timed out after ${timeoutMs}ms; last_phase=${lastPhase}`);
+}
+
 const manifest=await sha(path.join(root,'MANIFEST.SHA256'));
 const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
 const cfg=await loadPowerShellDataFile(pointer.config_path);
@@ -16,12 +64,23 @@ const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs');
 const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
 const expectedVersion=pkg.version;
 const args=[
-'--stage',root,'--development-root',root,'--expected-version',expectedVersion,'--expected-manifest',manifest,
-'--process-policy',path.join(root,'controller','deadbyte-process-policy.json'),'--process-policy-sha256',await sha(path.join(root,'controller','deadbyte-process-policy.json')),
-'--desktop-policy',path.join(root,'controller','deadbyte-desktop-policy.json'),'--desktop-policy-sha256',await sha(path.join(root,'controller','deadbyte-desktop-policy.json')),
-'--semantic-lsp-config',path.join(root,'controller','deadbyte-semantic-lsp-config.json'),'--semantic-lsp-config-sha256',await sha(path.join(root,'controller','deadbyte-semantic-lsp-config.json')),
-'--bridge-root',bridgeRoot,'--bridge-script-sha256',await sha(bridgeScript),
-'--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor','--restore-standing-grants','--recover-offline-predecessor'
+  '--stage',root,'--development-root',root,'--expected-version',expectedVersion,'--expected-manifest',manifest,
+  '--process-policy',path.join(root,'controller','deadbyte-process-policy.json'),'--process-policy-sha256',await sha(path.join(root,'controller','deadbyte-process-policy.json')),
+  '--desktop-policy',path.join(root,'controller','deadbyte-desktop-policy.json'),'--desktop-policy-sha256',await sha(path.join(root,'controller','deadbyte-desktop-policy.json')),
+  '--semantic-lsp-config',path.join(root,'controller','deadbyte-semantic-lsp-config.json'),'--semantic-lsp-config-sha256',await sha(path.join(root,'controller','deadbyte-semantic-lsp-config.json')),
+  '--bridge-root',bridgeRoot,'--bridge-script-sha256',await sha(bridgeScript),
+  '--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor','--recover-offline-predecessor'
 ];
 const result=await runSlotUpdateCli(args,{stateRoot:state});
-console.log(JSON.stringify({status:'deployed',manifest_sha256:manifest,previous_release:pointer.release_id,result}));
+if(!result.handed_off) throw new Error('release activation unexpectedly completed inline; refusing to skip post-activation verification');
+const verification=await waitForActivation({handoffPath:result.handoff_path,expectedVersion,expectedManifest:manifest});
+console.log(JSON.stringify({
+  status:'activated',
+  manifest_sha256:manifest,
+  previous_release:pointer.release_id,
+  update_id:result.update_id,
+  supervisor_pid:result.supervisor_pid,
+  release_id:verification.release_id,
+  receipt_path:verification.receiptPath,
+  state_path:verification.statePath
+},null,2));

package/scripts/full-regression-r47.mjs

@@ -0,0 +1,28 @@
+import { spawnSync } from 'node:child_process';
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const testDir=path.join(root,'test');
+const excluded=new Set(['full-max-catalog-r44.test.mjs','full-max-catalog-r45.test.mjs','full-max-catalog-r46.test.mjs']);
+const files=(await readdir(testDir,{withFileTypes:true}))
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs')&&!excluded.has(entry.name));
+const weighted=[];
+for(const entry of files) weighted.push({path:path.join('test',entry.name),size:(await stat(path.join(testDir,entry.name))).size});
+weighted.sort((a,b)=>b.size-a.size||a.path.localeCompare(b.path,'en'));
+const batchCount=8;
+const batches=Array.from({length:batchCount},()=>[]);
+weighted.forEach((entry,index)=>batches[index%batchCount].push(entry.path));
+let total=0;
+for(let index=0;index<batchCount;index++){
+  const batch=batches[index].sort((a,b)=>a.localeCompare(b,'en'));
+  console.log(`R47-BOUNDED-REGRESSION batch=${index+1}/${batchCount} files=${batch.length}`);
+  const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...batch],{cwd:root,stdio:'inherit',windowsHide:true,shell:false});
+  if(result.error) throw result.error;
+  if(result.signal) throw new Error(`regression batch ${index} terminated by ${result.signal}`);
+  if(result.status!==0) throw new Error(`regression batch ${index} failed with exit code ${result.status}`);
+  total+=batch.length;
+}
+console.log(`R47-BOUNDED-REGRESSION PASS files=${total} batches=${batchCount}`);

package/scripts/inventory-reference-dist.mjs

@@ -0,0 +1,17 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+const target=process.argv[2];
+if(!target) throw new Error('target path required');
+async function walk(dir,out=[]){
+  for(const e of await readdir(dir,{withFileTypes:true})){
+    const p=path.join(dir,e.name);
+    if(e.isDirectory()) await walk(p,out);
+    else { const s=await stat(p); out.push({path:path.relative(target,p).replaceAll('\\\\','/'),bytes:s.size}); }
+  }
+  return out;
+}
+const files=await walk(target);
+const groups=new Map();
+for(const f of files){const ext=path.extname(f.path).toLowerCase()||'<none>'; groups.set(ext,(groups.get(ext)||0)+1);}
+console.log(JSON.stringify({target,file_count:files.length,total_bytes:files.reduce((n,f)=>n+f.bytes,0),extensions:Object.fromEntries([...groups].sort((a,b)=>a[0].localeCompare(b[0]))),files:files.sort((a,b)=>a.path.localeCompare(b.path))},null,2));

package/scripts/npm-release-r47.mjs

@@ -1,4 +1,4 @@
-import { spawnSync } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
 import { mkdtemp, readFile, rm, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -64,6 +64,27 @@ async function main() {
   const version = pkg.version;
   if (pkg.name !== 'deadbyte-mcp') throw new Error(`unexpected package name: ${pkg.name}`);
 
+  const releaseBytes = await readFile(path.join(root, 'RELEASE.json'));
+  if (releaseBytes.subarray(0, 3).equals(Buffer.from([0xEF, 0xBB, 0xBF]))) {
+    throw new Error('RELEASE.json must be UTF-8 without BOM');
+  }
+  const release = JSON.parse(releaseBytes.toString('utf8'));
+  const provenance = JSON.parse(await readFile(path.join(root, 'PROVENANCE.json'), 'utf8'));
+  if (release.schema !== 'deadbyte.release.v1' || release.name !== pkg.name) {
+    throw new Error('RELEASE.json schema/package identity mismatch');
+  }
+  if (release.version !== version) {
+    throw new Error(`RELEASE.json version mismatch: package=${version} release=${release.version}`);
+  }
+  if (provenance.version !== version) {
+    throw new Error(`PROVENANCE.json version mismatch: package=${version} provenance=${provenance.version}`);
+  }
+  if (release.parent?.release_id !== provenance.parent_release_id ||
+      release.parent?.manifest_sha256 !== provenance.parent_manifest_sha256 ||
+      release.parent?.generation_manifest_sha256 !== provenance.parent_generation_manifest_sha256) {
+    throw new Error('RELEASE.json parent identity does not match sealed PROVENANCE.json lineage');
+  }
+
   const existing = spawnSync(node, [npmCli, 'view', `deadbyte-mcp@${version}`, 'version', '--json'], {
     cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], shell: false, windowsHide: true,
   });
@@ -189,6 +210,9 @@ async function main() {
       timeout: 300000,
     });
 
+    console.log('[8/8] Activating the published release into the live immutable slot and waiting for verified handoff...');
+    run(node, [path.join(root, 'scripts', 'deploy-r47.mjs')], { cwd: root, timeout: 900000 });
+
     releaseSucceeded = true;
     console.log('\nRELEASE SUCCESSFUL:');
     console.log(JSON.stringify({

package/scripts/r47-syntax-check.mjs

@@ -0,0 +1,6 @@
+import { spawnSync } from 'node:child_process';
+for(const file of ['src/mcp-server.mjs','src/commander-remote-relay-r47.mjs','src/commander-remote-bridge-r47.mjs']){
+  const result=spawnSync(process.execPath,['--check',file],{encoding:'utf8',windowsHide:true});
+  if(result.status!==0) throw new Error(`${file} syntax check failed: ${result.stderr||result.stdout}`);
+}
+console.log('R47 syntax PASS');

package/scripts/r47-wire-remote-plane.mjs

@@ -0,0 +1,23 @@
+import { createHash } from 'node:crypto';
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const file=path.resolve('src/mcp-server.mjs');
+const source=await readFile(file,'utf8');
+const sha=createHash('sha256').update(source).digest('hex');
+const expectedLength=64;
+if(sha.length!==expectedLength) throw new Error(`source hash length invalid: ${sha.length}`);
+const importNeedle="import { registerCommanderCoreBridge } from './commander-core-bridge.mjs';\n";
+const importReplacement=importNeedle+"import { registerCommanderRemoteBridge } from './commander-remote-bridge-r47.mjs';\nimport { createCommanderRemoteRelayR47 } from './commander-remote-relay-r47.mjs';\nimport { createRemoteDevicePlaneR44 } from './remote-device-r44.mjs';\n";
+const planeNeedle="const skillRoot=path.join(runtimeStateRoot,'skills');\nawait mkdir(skillRoot,{recursive:true});\nconst skillRuntime=await createSkillPlane({root:skillRoot,verifyKeyPath});\n";
+const planeReplacement=planeNeedle+"\nconst remoteRelayEndpoint=process.env.DEADBYTE_REMOTE_RELAY_ENDPOINT||process.env.DEADBYTE_REMOTE_ENDPOINT||'';\nconst remoteRelayCapabilities=new Set(String(process.env.DEADBYTE_REMOTE_CAPABILITIES||'').split(',').map(value=>value.trim()).filter(Boolean));\nconst remoteRelay=remoteRelayEndpoint ? await createCommanderRemoteRelayR47({endpoint:remoteRelayEndpoint}) : null;\nconst remoteDevicePlane=remoteRelay\n  ? await createRemoteDevicePlaneR44({\n      stateDir:path.join(runtimeStateRoot,'remote-device-r44'),\n      relay:remoteRelay,\n      authorizeCapability:async({capabilityId})=>remoteRelayCapabilities.has(capabilityId)\n    })\n  : null;\n";
+const registerNeedle="  if (surfaceProfile === 'full') registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null});\n  return server;\n";
+const registerReplacement="  if (surfaceProfile === 'full') {\n    registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null});\n    registerCommanderRemoteBridge(toolServer,{remoteDevicePlane});\n  }\n  return server;\n";
+if(source.includes("commander-remote-relay-r47.mjs")) throw new Error('R47 remote relay already wired');
+if(source.split(importNeedle).length!==2) throw new Error('import anchor mismatch');
+if(source.split(planeNeedle).length!==2) throw new Error('plane anchor mismatch');
+if(source.split(registerNeedle).length!==2) throw new Error('registration anchor mismatch');
+const next=source.replace(importNeedle,importReplacement).replace(planeNeedle,planeReplacement).replace(registerNeedle,registerReplacement);
+await writeFile(file,next,'utf8');
+const verify=createHash('sha256').update(await readFile(file)).digest('hex');
+console.log(JSON.stringify({status:'committed',source_sha256:sha,source_sha256_length:sha.length,result_sha256:verify,result_sha256_length:verify.length}));

package/src/atomic-mutation.mjs

@@ -1,8 +1,35 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { open, rename, rm } from 'node:fs/promises';
+import { open, rename, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+const LOCK_WAIT_MS = 10;
+const LOCK_TIMEOUT_MS = 30000;
+const LOCK_STALE_MS = 120000;
+
+async function acquireMutationLock(target) {
+  const lock = `${target}.deadbyte-mutation.lock`;
+  const started = Date.now();
+  while (true) {
+    try {
+      const handle = await open(lock, 'wx', 0o600);
+      await handle.writeFile(`${process.pid}\\n${Date.now()}\\n`);
+      await handle.sync();
+      await handle.close();
+      return async () => { await rm(lock, { force: true }).catch(() => {}); };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      if (Date.now() - started >= LOCK_TIMEOUT_MS) throw new Error('atomic mutation lock timed out');
+      try {
+        const info = await stat(lock);
+        if (Date.now() - info.mtimeMs > LOCK_STALE_MS) await rm(lock, { force: true }).catch(() => {});
+      } catch (statError) {
+        if (statError?.code !== 'ENOENT') throw statError;
+      }
+      await new Promise(resolve => setTimeout(resolve, LOCK_WAIT_MS));
+    }
+  }
+}
 
 export async function atomicMutation({
   target,
@@ -19,37 +46,40 @@ export async function atomicMutation({
   if (typeof readState !== 'function' || typeof assertExpected !== 'function') {
     throw new Error('atomic mutation requires readState and assertExpected');
   }
-  const before = await readState(target);
-  assertExpected(before, expected);
-  const temp = path.join(
-    path.dirname(target),
-    `.\${path.basename(target)}.\${tempTag}-\${process.pid}-\${randomBytes(8).toString('hex')}.tmp`
-  );
-  let handle;
+  const releaseLock = await acquireMutationLock(target);
   try {
-    if (authorityCheck) await authorityCheck();
-    handle = await open(temp, 'wx', 0o600);
-    await handle.writeFile(bytes);
-    await handle.sync();
-    await handle.close();
-    handle = null;
+    const before = await readState(target);
+    assertExpected(before, expected);
+    const temp = path.join(
+      path.dirname(target),
+      `.${path.basename(target)}.${tempTag}-${process.pid}-${randomBytes(8).toString('hex')}.tmp`
+    );
+    let handle;
+    try {
+      if (authorityCheck) await authorityCheck();
+      handle = await open(temp, 'wx', 0o600);
+      await handle.writeFile(bytes);
+      await handle.sync();
+      await handle.close();
+      handle = null;
 
-    const race = await readState(target);
-    assertExpected(race, expected);
-    if (authorityCheck) await authorityCheck();
+      const race = await readState(target);
+      assertExpected(race, expected);
+      if (authorityCheck) await authorityCheck();
 
-    await rename(temp, target);
-  } catch (error) {
-    if (handle) await handle.close().catch(() => {});
-    await rm(temp, { force: true }).catch(() => {});
-    throw error;
-  }
+      await rename(temp, target);
+    } catch (error) {
+      if (handle) await handle.close().catch(() => {});
+      await rm(temp, { force: true }).catch(() => {});
+      throw error;
+    }
 
-  const after = await readState(target);
-  const expectedAfter = sha256Bytes(bytes);
-  if (!after.exists || after.sha256 !== expectedAfter) {
-    throw new Error('atomic mutation post-commit hash mismatch');
+    const after = await readState(target);
+    const expectedAfter = sha256Bytes(bytes);
+    if (!after.exists || after.sha256 !== expectedAfter) throw new Error('atomic mutation post-commit hash mismatch');
+    if (verifyPostcondition) await verifyPostcondition({ before, after, expected_after_sha256: expectedAfter });
+    return { before, after, expected_after_sha256: expectedAfter };
+  } finally {
+    await releaseLock();
   }
-  if (verifyPostcondition) await verifyPostcondition({ before, after, expected_after_sha256: expectedAfter });
-  return { before, after, expected_after_sha256: expectedAfter };
 }

package/src/commander-compat-contracts.mjs

@@ -0,0 +1,90 @@
+import { createHash } from 'node:crypto';
+
+export const COMMANDER_COMPAT_SCHEMA = 'deadbyte.commander-compat.v2';
+
+const sha256 = value => createHash('sha256').update(JSON.stringify(value), 'utf8').digest('hex');
+
+// Behavioral/interface surface observed from the local reference package.
+// Implementations are independent DEADBYTE native planes.
+export const COMMANDER_COMPAT_TOOLS = Object.freeze([
+  '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'
+]);
+
+export const DEADBYTE_NATIVE_TOOLS = Object.freeze({
+  contained_transform: 'contained.transform',
+  create_directory: 'machine_fs.mkdir',
+  edit_block: 'native_diff',
+  evidence_verify: 'evidence.verify',
+  file_preview: 'commander.file_preview',
+  file_read: 'machine_fs.read',
+  force_terminate: 'process.terminate',
+  get_config: 'commander.config.get',
+  get_file_info: 'machine_fs.stat',
+  get_more_search_results: 'machine_search.page',
+  get_prompts: 'commander.prompts',
+  get_recent_tool_calls: 'operation_history.recent',
+  get_usage_stats: 'operation_history.stats',
+  give_feedback_to_desktop_commander: 'commander.feedback',
+  host_exec: 'host.exec',
+  host_file_read: 'host.file_read',
+  host_file_write: 'host.file_write',
+  interact_with_process: 'process.input',
+  kill_process: 'process.terminate',
+  list_directory: 'machine_fs.list',
+  list_processes: 'process.sessions',
+  list_searches: 'machine_search.list',
+  list_sessions: 'process.sessions',
+  markdown_editor: 'native_diff',
+  move_file: 'machine_fs.move',
+  proof_execute: 'proof.execute',
+  read_file: 'machine_fs.read',
+  read_multiple_files: 'machine_fs.read_many',
+  read_process_output: 'process.output',
+  remote_device: 'remote_device',
+  remote_mcp: 'remote_mcp',
+  resources: 'commander.resources',
+  set_config_value: 'commander.config.set',
+  skill_catalog: 'skill.catalog',
+  start_process: 'process.start',
+  start_search: 'machine_search.start',
+  stop_search: 'machine_search.cancel',
+  workspace_open: 'workspace.open',
+  write_file: 'machine_fs.write',
+  write_pdf: 'document.write_pdf'
+});
+
+export function commanderCompatibilitySnapshot() {
+  const tools = COMMANDER_COMPAT_TOOLS.map(name => ({
+    name,
+    native: DEADBYTE_NATIVE_TOOLS[name] ?? null
+  }));
+  return {
+    schema: COMMANDER_COMPAT_SCHEMA,
+    tools,
+    coverage: tools.filter(x => x.native).length,
+    total: tools.length,
+    snapshot_sha256: sha256(tools)
+  };
+}
+
+export function assertCommanderCompatibilitySnapshot(snapshot) {
+  if (!snapshot || snapshot.schema !== COMMANDER_COMPAT_SCHEMA || !Array.isArray(snapshot.tools)) {
+    throw new Error('commander compatibility snapshot invalid');
+  }
+  if (snapshot.total !== COMMANDER_COMPAT_TOOLS.length) throw new Error('commander compatibility total mismatch');
+  if (snapshot.coverage !== snapshot.tools.filter(x => x.native).length) throw new Error('commander compatibility coverage mismatch');
+  if (snapshot.tools.length !== COMMANDER_COMPAT_TOOLS.length) throw new Error('commander compatibility surface length mismatch');
+  for (const item of snapshot.tools) {
+    if (!COMMANDER_COMPAT_TOOLS.includes(item.name)) throw new Error(`unknown commander compatibility tool: ${item.name}`);
+    if (typeof item.native !== 'string' || !item.native) throw new Error(`missing native mapping: ${item.name}`);
+  }
+  return true;
+}