deadbyte-mcp 0.15.51 → 0.15.53

package/src/scoped-observer-worker-r136.mjs

@@ -0,0 +1,65 @@
+import {readFile,lstat,realpath} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const digest=/^[0-9a-f]{64}$/;
+const eq=(a,b)=>process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+async function fileInside(state,filename,expected){
+ if(!digest.test(expected??''))throw new Error('policy digest invalid');
+ const root=path.resolve(state),file=path.resolve(filename);
+ const rel=path.relative(root,file);
+ if(rel===''||path.isAbsolute(rel)||rel==='..'||rel.startsWith('..'+path.sep))throw new Error('policy outside isolated state');
+ const item=await lstat(file);
+ if(!item.isFile()||item.isSymbolicLink()||!eq(await realpath(file),file))throw new Error('policy not regular');
+ const bytes=await readFile(file);
+ if(sha(bytes)!==expected)throw new Error('policy digest mismatch');
+ return JSON.parse(bytes.toString('utf8'));
+}
+async function boot(){
+ if(!process.send)throw new Error('IPC required');
+ const [state,codingFile,codingDigest,autoFile,autoDigest]=process.argv.slice(2);
+ if(!state||!path.isAbsolute(state))throw new Error('isolated state required');
+ const isolated=path.resolve(state);
+ if(!eq(await realpath(isolated),isolated))throw new Error('isolated state redirected');
+ const coding=await fileInside(isolated,codingFile,codingDigest);
+ const auto=await fileInside(isolated,autoFile,autoDigest);
+ if(coding?.schema!=='deadbyte.coding-policy.v1'||coding.enabled!==true)throw new Error('coding schema invalid');
+ if(auto?.schema!=='deadbyte.autonomous-policy.v1'||auto.enabled!==true)throw new Error('autonomous schema invalid');
+ if(auto.coding_policy_sha256!==codingDigest)throw new Error('autonomous binding invalid');
+ const ids=Object.keys(coding.roots??{}),selected=auto.root_ids;
+ if(!Array.isArray(selected)||selected.length!==1||ids.length!==1||ids[0]!==selected[0])throw new Error('root scope mismatch');
+ const id=ids[0],root=coding.roots[id]?.path;
+ if(!path.isAbsolute(root??'')||eq(path.resolve(root),path.parse(root).root))throw new Error('broad Coding root forbidden');
+ const stat=await lstat(root);
+ if(!stat.isDirectory()||stat.isSymbolicLink()||!eq(await realpath(root),path.resolve(root)))throw new Error('untrusted project root');
+ const commands=Object.entries(coding.commands??{});
+ for(const [,command] of commands){
+  if(!Array.isArray(command.root_ids)||command.root_ids.length!==1||command.root_ids[0]!==id)
+   throw new Error('command root scope mismatch');
+ }
+ for(const p of Object.values(auto.profiles??{})){
+  if(p?.root_id!==id||!Object.hasOwn(coding.commands,p.command_id))throw new Error('autonomous profile mismatch');
+ }
+ for(const lease of [coding.lease_file,auto.lease_file]){
+  if(typeof lease!=='string'||!path.isAbsolute(lease)||!eq(path.dirname(lease),path.join(isolated,'runtime')))
+   throw new Error('lease state isolation mismatch');
+  try{await lstat(lease);throw new Error('inherited grant present');}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+ }
+ const ambient=Object.keys(process.env).filter(k=>k.toUpperCase().startsWith('DEADBYTE_'));
+ const ready={pid:process.pid,status:'DISARMED',root_ids:ids,command_ids:commands.map(x=>x[0]),
+  coding_sha256:codingDigest,autonomous_sha256:autoDigest,ambient_deadbyte_keys:ambient.length,
+  node_options_present:Object.hasOwn(process.env,'NODE_OPTIONS'),
+  user_token_present:Object.keys(process.env).some(k=>/OPENAI_API_KEY|NPM_TOKEN|GITHUB_TOKEN|GH_TOKEN|AWS_SECRET_ACCESS_KEY/i.test(k)),
+  grant_files_present:false};
+ process.send({kind:'ready',result:ready});
+ process.on('message',msg=>{
+  if(!msg||msg.kind!=='request'||!Number.isSafeInteger(msg.id))return;
+  if(msg.op==='shutdown'){process.send({kind:'reply',id:msg.id,result:{status:'STOPPING'}});return process.exit(0);}
+  const result=msg.op==='status'?{status:'DISARMED',root_ids:ids}:
+    {status:'DENIED_UNAUTHORIZED',op:typeof msg.op==='string'?msg.op:''};
+  process.send({kind:'reply',id:msg.id,result});
+ });
+}
+boot().catch(err=>{process.send?.({kind:'boot-error',reason:String(err.message??err).slice(0,140)});process.exitCode=3;});

package/src/version.mjs

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

package/test/commander-wire-contract-r47.test.mjs

@@ -406,13 +406,14 @@ test('R48 read_file tails a large text file from the end without reading the who
     policy:{roots:{project:{real_path:'D:\\RDC-COMPAT-TEST'}},max_read_bytes:64},
     async read(args){
       calls.push({...args});
-      if(args.offset>=0) return {
-        data_base64:Buffer.from('HEAD-ONLY').toString('base64'),
-        file_sha256:null,file_size:1024,eof:false,offset:0,next_offset:9
+      if(args.offset===959) return {
+        data_base64:Buffer.from('x').toString('base64'),
+        file_sha256:null,file_size:1024,eof:false,offset:959,next_offset:960
       };
       assert.equal(args.offset,-64);
+      const suffix='older\nline7\nline8\nline9\n';
       return {
-        data_base64:Buffer.from('older\nline7\nline8\nline9\n').toString('base64'),
+        data_base64:Buffer.from('p'.repeat(64-Buffer.byteLength(suffix))+suffix).toString('base64'),
         file_sha256:null,file_size:1024,eof:true,offset:960,next_offset:1024
       };
     }
@@ -423,8 +424,10 @@ test('R48 read_file tails a large text file from the end without reading the who
   });
   assert.equal(result.isError,undefined,JSON.stringify(result));
   assert.equal(result.structuredContent.content,'line8\nline9');
-  assert.equal(calls.length,1);
+  assert.equal(calls.length,2);
   assert.equal(calls[0].offset,-64);
+  assert.equal(calls[1].offset,959);
+  assert.equal(calls[1].maxBytes,1);
 });
 
 test('R48 edit_block range mutates XLSX through native ZIP/XML writer with hash precondition',async()=>{

package/test/r130-release-security-contract.test.mjs

@@ -13,16 +13,16 @@ test('R130 security patch has a new immutable package identity and truthful sour
     read('SBOM.cdx.json'),read('package-lock.json'),read('TEST-MATRIX.json')]);
   assert.equal(pkg.name,'deadbyte-mcp');
   for(const actual of [pkg.version,release.version,provenance.version,matrix.version,bom.metadata.component.version,lock.version,lock.packages[''].version,DEADBYTE_VERSION])
-    assert.equal(actual,'0.15.51');
-  assert.equal(release.train,'R132');
-  assert.equal(matrix.train,'R132');
-  assert.equal(release.source_predecessor.version,'0.15.50');
-  assert.match(release.source_predecessor.source_path,/0\.15\.50/);
+    assert.equal(actual,'0.15.53');
+  assert.equal(release.train,'R144');
+  assert.equal(matrix.train,'R144');
+  assert.equal(release.source_predecessor.version,'0.15.52');
+  assert.match(release.source_predecessor.source_path,/0\.15\.52/);
   assert.equal(release.runtime_predecessor.version,'0.15.45');
-  assert.equal(provenance.source_predecessor_version,'0.15.50');
-  assert.equal(provenance.source_predecessor_manifest_file_sha256,'98dd37c71adae980856adc17b9c59d58d167a01d46c61106055956d0f306fede');
+  assert.equal(provenance.source_predecessor_version,'0.15.52');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'e00223a76ef6d0e0fa7e850de597fa44cd6113cd49725535492da73f1daf4244');
   assert.equal(pkg.dependencies['@modelcontextprotocol/client'],'2.3.1');
   assert.equal(pkg.dependencies['@modelcontextprotocol/server'],'2.3.1');
   for(const dep of ['@modelcontextprotocol/client','@modelcontextprotocol/server'])
     assert.equal(pkg.bundleDependencies.includes(dep),true);
-});
+});

package/test/r132-release-identity.test.mjs

@@ -8,20 +8,20 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 
-test('R132 candidate identities and published source predecessor are consistent',async()=>{
+test('R144 package identities, R132 historic evidence and published predecessor are consistent',async()=>{
   const [pkg,lock,release,prov,bom,matrix]=await Promise.all([
     read('package.json'),read('package-lock.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('SBOM.cdx.json'),read('TEST-MATRIX.json')]);
   for(const value of [pkg.version,lock.version,lock.packages[''].version,release.version,prov.version,bom.metadata.component.version,matrix.version,DEADBYTE_VERSION]){
-    assert.equal(value,'0.15.51');
+    assert.equal(value,'0.15.53');
   }
-  assert.equal(release.train,'R132');
-  assert.equal(matrix.train,'R132');
-  assert.equal(release.source_predecessor.version,'0.15.50');
-  assert.match(release.source_predecessor.source_path,/0\.15\.50/);
-  assert.equal(prov.source_predecessor_version,'0.15.50');
-  assert.equal(prov.source_predecessor_manifest_file_sha256,'98dd37c71adae980856adc17b9c59d58d167a01d46c61106055956d0f306fede');
-  assert.equal(prov.parent_tarball_sha256,'133b9f4adedee14a3e4f2fd1c9433f7ebf102742a73398161b238fd68eb42d84');
+  assert.equal(release.train,'R144');
+  assert.equal(matrix.train,'R144');
+  assert.equal(release.source_predecessor.version,'0.15.52');
+  assert.match(release.source_predecessor.source_path,/0\.15\.52/);
+  assert.equal(prov.source_predecessor_version,'0.15.52');
+  assert.equal(prov.source_predecessor_manifest_file_sha256,'e00223a76ef6d0e0fa7e850de597fa44cd6113cd49725535492da73f1daf4244');
+  assert.equal(prov.parent_tarball_sha256,'ec675df8885a0d96b1486607956b7091fe47088509b4756194a7e15004d8d97f');
   assert.equal(release.runtime_predecessor.version,'0.15.45');
   assert.equal(prov.runtime_predecessor.release_id,release.runtime_predecessor.release_id);
   assert.equal(prov.runtime_predecessor.manifest_sha256,release.runtime_predecessor.manifest_sha256);

package/test/r135-autonomous-scope.test.mjs

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,rm,readFile,writeFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import {deriveIsolatedAutonomousScope} from '../src/autonomous-scope-r135.mjs';
+import {assertAutonomousBootstrapRoots} from '../src/runtime-update.mjs';
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+async function fixture(run){
+ const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r135-scope-'));
+ try{
+  const core=path.join(base,'safe-project'),scratch=path.join(base,'child-state');
+  await mkdir(core);await mkdir(scratch);
+  const original={schema:'deadbyte.coding-policy.v1',enabled:true,
+   lease_file:path.join(base,'parent-coding-grant.json'),
+   evidence_dir:path.join(base,'parent-evidence'),
+   roots:{core:{path:core,read:true,write:true,exec:true,deny_paths:[]},
+    local_c:{path:path.parse(base).root,read:true,write:true,exec:true,deny_paths:[]},
+    downloads:{path:path.join(base,'downloads'),read:true,write:true,exec:true,deny_paths:[]}},
+   commands:{node_script:{executable:'node',args:[],root_ids:['core','local_c']},unused_command:{executable:'cmd',args:[],root_ids:['local_c']}}};
+  const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,
+    lease_file:path.join(base,'parent-autonomous-grant.json'),evidence_dir:path.join(base,'old-auto-evidence'),
+    coding_policy_sha256:'a'.repeat(64),root_ids:['core'],
+    planner:{backend:'client_sampling',max_tokens:2048},
+    profiles:{quick:{kind:'command',root_id:'core',command_id:'node_script',
+     script_path:'test.mjs',script_sha256:'b'.repeat(64)}}};
+  await run({base,core,scratch,original,autonomous});
+ }finally{await rm(base,{recursive:true,force:true})}
+}
+test('R135 projects only the chosen project root and its pinned commands without modifying manual Coding',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const before=JSON.stringify(original),beforeAutonomous=JSON.stringify(autonomous);
+  const result=deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:scratch});
+  assert.deepEqual(Object.keys(result.codingPolicy.roots),['core']);
+  assert.deepEqual(Object.keys(result.codingPolicy.commands),['node_script']);
+  assert.equal(result.autonomousPolicy.coding_policy_sha256,hash(result.codingBytes));
+  assert.deepEqual(result.autonomousPolicy.root_ids,['core']);
+  assert.deepEqual(assertAutonomousBootstrapRoots(result.autonomousPolicy,result.codingPolicy,hash(result.codingBytes)),['core']);
+  assert.equal(JSON.stringify(original),before);
+  assert.equal(JSON.stringify(autonomous),beforeAutonomous);
+  assert.notEqual(result.codingPolicy.lease_file,original.lease_file);
+  assert.notEqual(result.autonomousPolicy.lease_file,autonomous.lease_file);
+  await assert.rejects(()=>readFile(result.codingPolicy.lease_file),{code:'ENOENT'});
+  await assert.rejects(()=>readFile(result.autonomousPolicy.lease_file),{code:'ENOENT'});
+ });
+});
+test('R135 scope projector refuses direct whole-drive root and does not weaken R70 security gate',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const wide={...autonomous,root_ids:['local_c'],
+   profiles:{quick:{...autonomous.profiles.quick,root_id:'local_c'}}};
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:wide,
+   scopeRootId:'local_c',isolatedStateRoot:scratch}),/project-scoped root/);
+  assert.throws(()=>assertAutonomousBootstrapRoots(autonomous,original,'a'.repeat(64)),
+   /coding policy contains a broad filesystem root/);
+ });
+});
+test('R135 rejects Autonomous profiles targeting roots other than the approved scope',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const forged={...autonomous,profiles:{out:{...autonomous.profiles.quick,root_id:'downloads'}}};
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:forged,
+   scopeRootId:'core',isolatedStateRoot:scratch}),/profile.*outside/);
+ });
+});
+test('R135 rejects missing command referenced by approved profile',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const forged={...autonomous,profiles:{quick:{...autonomous.profiles.quick,command_id:'not_allowlisted'}}};
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:forged,
+   scopeRootId:'core',isolatedStateRoot:scratch}),/command.*missing/);
+ });
+});
+test('R135 refuses missing, redirected, and unsafe project root',async()=>{
+ await fixture(async({scratch,original,autonomous,base})=>{
+  original.roots.core.path=path.join(base,'not-present');
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:scratch}),/real project directory/);
+ });
+});
+test('R135 does not accept an isolated state ancestor of an existing manual lease',async()=>{
+ await fixture(async({scratch,original,autonomous,base})=>{
+  original.lease_file=path.join(base,'runtime','existing-coding-grant.json');
+  autonomous.lease_file=path.join(path.dirname(base),'other-autonomous-grant.json');
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+    scopeRootId:'core',isolatedStateRoot:base}),/isolated state root overlaps manual Coding lease/);
+ });
+});
+test('R135 does not inherit any existing grant file at the isolated destination',async()=>{
+ await fixture(async({scratch,original,autonomous})=>{
+  const runtime=path.join(scratch,'runtime');
+  await mkdir(runtime);
+  await writeFile(path.join(runtime,'coding-grant.json'),'{"legacy":true}\n');
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+    scopeRootId:'core',isolatedStateRoot:scratch}),/isolated grant file already present/);
+ });
+});
+
+test('R135 refuses using the manual lease root as the isolated runtime root',async()=>{
+ await fixture(async({original,autonomous,base})=>{
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:original,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:base}),/isolated state root overlaps manual Coding lease/);
+ });
+});

package/test/r136-scoped-command-rights.test.mjs

@@ -0,0 +1,39 @@
+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 {deriveIsolatedAutonomousScope} from '../src/autonomous-scope-r135.mjs';
+const fixture=async fn=>{
+ const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r136-command-'));
+ try{
+  const core=path.join(dir,'core'),state=path.join(dir,'isolated');
+  await mkdir(core);await mkdir(state);
+  const coding={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(dir,'manual','coding-grant.json'),
+   evidence_dir:path.join(dir,'manual','evidence'),roots:{core:{path:core,read:true,write:true,exec:true,deny_paths:[]},
+    local_c:{path:path.parse(dir).root,read:true,write:true,exec:true,deny_paths:[]}},
+   commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:'a'.repeat(64),
+    root_ids:['core','local_c'],prefix_args:[],extensions:['.mjs']}}};
+  const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,lease_file:path.join(dir,'manual','autonomous-grant.json'),
+   evidence_dir:path.join(dir,'manual','evidence-auto'),coding_policy_sha256:'b'.repeat(64),
+   root_ids:['core'],profiles:{quick:{root_id:'core',command_id:'node_script'}},
+   planner:{backend:'client_sampling'}};
+  await fn({coding,autonomous,state});
+ } finally {await rm(dir,{recursive:true,force:true})}
+};
+test('R136 projected command does not retain broad manual root_ids',async()=>{
+ await fixture(({coding,autonomous,state})=>{
+  const before=structuredClone(coding);
+  const result=deriveIsolatedAutonomousScope({manualCodingPolicy:coding,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:state});
+  assert.deepEqual(result.codingPolicy.commands.node_script.root_ids,['core']);
+  assert.deepEqual(coding,before);
+ });
+});
+test('R136 command with no access to approved scope fails closed',async()=>{
+ await fixture(({coding,autonomous,state})=>{
+  coding.commands.node_script.root_ids=['local_c'];
+  assert.throws(()=>deriveIsolatedAutonomousScope({manualCodingPolicy:coding,autonomousPolicy:autonomous,
+   scopeRootId:'core',isolatedStateRoot:state}),/command.*outside approved scope/);
+ });
+});

package/test/r136-scoped-observer.test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,writeFile,readFile,rm} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import os from 'node:os';
+import {startScopedObserver} from '../src/scoped-observer-launcher-r136.mjs';
+import {deriveIsolatedAutonomousScope} from '../src/autonomous-scope-r135.mjs';
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function prepared(run){
+ const temp=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r136-observer-'));
+ let observer=null;
+ try{
+  const project=path.join(temp,'project'),isolated=path.join(temp,'isolated');
+  await mkdir(project);await mkdir(isolated);
+  const manual={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(temp,'manual','coding-grant.json'),
+   evidence_dir:path.join(temp,'manual','evidence'),
+   roots:{core:{path:project,read:true,write:true,exec:true,deny_paths:[]},
+    local_d:{path:path.parse(temp).root,read:true,write:true,exec:true,deny_paths:[]}},
+   commands:{node_script:{kind:'script',root_ids:['core','local_d'],executable:process.execPath,
+    executable_sha256:'a'.repeat(64),prefix_args:[],extensions:['.mjs']}}};
+  const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,
+   lease_file:path.join(temp,'manual','autonomous-grant.json'),evidence_dir:path.join(temp,'manual','aevidence'),
+   coding_policy_sha256:'f'.repeat(64),root_ids:['core'],
+   planner:{backend:'client_sampling'},profiles:{quick:{kind:'command',root_id:'core',command_id:'node_script'}}};
+  const projected=deriveIsolatedAutonomousScope({manualCodingPolicy:manual,autonomousPolicy:autonomous,scopeRootId:'core',isolatedStateRoot:isolated});
+  const codingFile=path.join(isolated,'coding-policy.json'),autonomousFile=path.join(isolated,'autonomous-policy.json');
+  await writeFile(codingFile,projected.codingBytes);
+  await writeFile(autonomousFile,projected.autonomousBytes);
+  const options={stateRoot:isolated,codingPolicyFile:codingFile,autonomousPolicyFile:autonomousFile,
+   codingSha256:projected.coding_sha256,autonomousSha256:projected.autonomous_sha256};
+  await run({temp,isolated,options,projected,manual,autonomous,setObserver:v=>observer=v});
+ } finally {
+  if(observer)await observer.close();
+  await rm(temp,{recursive:true,force:true});
+ }
+}
+test('R136 observer starts in its own PID disarmed, with no inherited broad Coding policy or ambient secrets',async()=>{
+ await prepared(async({options,projected,setObserver})=>{
+  const obs=await startScopedObserver({...options, ambientEnv:{DEADBYTE_CODING_POLICY:'C:\\\\evil.json',
+   DEADBYTE_STATE_ROOT:'C:\\\\Users\\\\DEADBYTE\\\\.deadbyte-mcp',NODE_OPTIONS:'--inspect',
+   OPENAI_API_KEY:'DO_NOT_LEAK'}});
+  setObserver(obs);
+  const result=obs.ready;
+  assert.ok(Number.isInteger(result.pid)&&result.pid>0);
+  assert.notEqual(result.pid,process.pid);
+  assert.equal(result.status,'DISARMED');
+  assert.deepEqual(result.root_ids,['core']);
+  assert.deepEqual(result.command_ids,['node_script']);
+  assert.equal(result.coding_sha256,projected.coding_sha256);
+  assert.equal(result.autonomous_sha256,projected.autonomous_sha256);
+  assert.equal(result.ambient_deadbyte_keys,0);
+  assert.equal(result.node_options_present,false);
+  assert.equal(result.user_token_present,false);
+  assert.equal(result.grant_files_present,false);
+ });
+});
+test('R136 observer refuses execute, arm and privileged requests instead of invoking any host tool',async()=>{
+ await prepared(async({options,setObserver})=>{
+  const obs=await startScopedObserver(options);setObserver(obs);
+  for(const action of ['execute','arm','write','host_exec','unknown']){
+   const reply=await obs.request({op:action,root_id:'core',command_id:'node_script'});
+   assert.deepEqual(reply,{status:'DENIED_UNAUTHORIZED',op:action});
+  }
+  assert.deepEqual(await obs.request({op:'status'}),{status:'DISARMED',root_ids:['core']});
+ });
+});
+test('R136 client-controlled IPC envelope fields cannot override request identity',async()=>{
+ await prepared(async({options,setObserver})=>{
+  const obs=await startScopedObserver(options);setObserver(obs);
+  const result=await obs.request({kind:'reply',id:9999,op:'execute'});
+  assert.deepEqual(result,{status:'DENIED_UNAUTHORIZED',op:'execute'});
+ });
+});
+
+test('R136 observer rejects policy byte tampering against SHA-pinned startup',async()=>{
+ await prepared(async({options})=>{
+  await writeFile(options.codingPolicyFile,Buffer.concat([await readFile(options.codingPolicyFile),Buffer.from(' ')]));
+  await assert.rejects(startScopedObserver(options),/policy digest mismatch|observer boot failed/);
+ });
+});
+test('R136 observer refuses inherited grant bytes even when policy hashes match',async()=>{
+ await prepared(async({options,isolated})=>{
+  const dir=path.join(isolated,'runtime');await mkdir(dir,{recursive:true});
+  await writeFile(path.join(dir,'coding-grant.json'),Buffer.from('{"armed":true}\n'));
+  await assert.rejects(startScopedObserver(options),/grant present|observer boot failed/);
+ });
+});

package/test/r137-commander-config-recovery.test.mjs

@@ -0,0 +1,111 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,writeFile,readFile,readdir,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {createHash} from 'node:crypto';
+import {createCommanderExtendedRuntime} from '../src/commander-extended-runtime.mjs';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+async function fixture(run){
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r137-config-'));
+ try{await run({root,file:path.join(root,'commander-config.json')});}
+ finally{await rm(root,{recursive:true,force:true});}
+}
+test('R137 recovers bounded display limits from complete JSON prefix, not privileges or telemetry',async()=>{
+ await fixture(async({root,file})=>{
+  const corrupt=Buffer.from('{"fileReadLineLimit":200,"fileWriteLineLimit":20,"allowedDirectories":["C:\\\\","D:\\\\"],"telemetryEnabled":true,"defaultShell":"cmd.exe","theme":"light","blockedCommands":[],"damaged": [\n','utf8');
+  await writeFile(file,corrupt);
+  const runtime=createCommanderExtendedRuntime({stateRoot:root});
+  const cfg=await runtime.getConfig();
+  assert.equal(cfg.config.fileReadLineLimit,200);
+  assert.equal(cfg.config.fileWriteLineLimit,20);
+  assert.equal(cfg.config.telemetryEnabled,false);
+  assert.deepEqual(cfg.config.allowedDirectories,[]);
+  assert.equal(cfg.config.theme,undefined);
+  assert.equal(cfg.config.defaultShell,process.platform==='win32'?'powershell.exe':(process.env.SHELL||'/bin/sh'));
+  assert.equal(cfg.recovery?.status,'recovered');
+  assert.deepEqual(cfg.recovery?.salvaged_keys,['fileReadLineLimit','fileWriteLineLimit']);
+  const backups=(await readdir(root)).filter(f=>f.startsWith('commander-config.json.corrupt.'));
+  assert.equal(backups.length,1);
+  assert.equal(sha(await readFile(path.join(root,backups[0]))),sha(corrupt));
+  const stored=JSON.parse(await readFile(file,'utf8'));
+  assert.equal(stored.fileReadLineLimit,200);
+  assert.equal(stored.telemetryEnabled,false);
+  const next=await runtime.getConfig();
+  assert.equal(next.config_sha256,cfg.config_sha256);
+  assert.equal((await readdir(root)).filter(f=>f.startsWith('commander-config.json.corrupt.')).length,1);
+ });
+});
+test('R137 totally corrupt or oversized config recovers minimal defaults without inheriting blockedCommands/paths',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'garbled not JSON');
+  const config=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(config.recovery?.status,'recovered');
+  assert.deepEqual(config.recovery?.salvaged_keys,[]);
+  assert.deepEqual(config.config.allowedDirectories,[]);
+  assert.equal(config.config.telemetryEnabled,false);
+  assert.ok(!Object.hasOwn(config.config,'arbitraryAuthority'));
+ });
+});
+test('R137 ignores out-of-bounds limits in parseable prefix',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'{"fileReadLineLimit":999999,"fileWriteLineLimit":0,"allowedDirectories":["C:\\\\"],"broken":');
+  const config=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(config.config.fileReadLineLimit,1000);
+  assert.equal(config.config.fileWriteLineLimit,50);
+  assert.deepEqual(config.recovery?.salvaged_keys,[]);
+ });
+});
+test('R137 parallel configuration reads share one recovery and preserve original backup',async()=>{
+ await fixture(async({root,file})=>{
+  const raw=Buffer.from('{"fileReadLineLimit":210,"allowedDirectories":["C:\\\\"],"unfinished": [\n');
+  await writeFile(file,raw);
+  const rt=createCommanderExtendedRuntime({stateRoot:root});
+  const [a,b,c]=await Promise.all([rt.getConfig(),rt.getConfig(),rt.getConfig()]);
+  assert.deepEqual([a.config_sha256,b.config_sha256,c.config_sha256],[a.config_sha256,a.config_sha256,a.config_sha256]);
+  const backups=(await readdir(root)).filter(n=>n.startsWith('commander-config.json.corrupt.'));
+  assert.equal(backups.length,1);
+  assert.equal(sha(await readFile(path.join(root,backups[0]))),sha(raw));
+ });
+});
+test('R137 quoted commas and nested JSON do not spoof a recoverable top-level setting',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'{"description":"x, \\\"fileReadLineLimit\\\": 8","nested":{"fileReadLineLimit":1},"fileReadLineLimit":225,"bad": [');
+  const r=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(r.config.fileReadLineLimit,225);
+  assert.deepEqual(r.recovery?.salvaged_keys,['fileReadLineLimit']);
+ });
+});
+test('R137 valid non-object JSON is not trusted as configuration',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'["allowedDirectories","C:\\\\"]');
+  const r=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(r.recovery?.status,'recovered');
+  assert.deepEqual(r.config.allowedDirectories,[]);
+ });
+});
+
+test('R137 preserves the existing valid config without making recovery backup',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,JSON.stringify({theme:'classic',telemetryEnabled:false}));
+  const result=await createCommanderExtendedRuntime({stateRoot:root}).getConfig();
+  assert.equal(result.config.theme,'classic');
+  assert.equal(result.recovery,undefined);
+  assert.deepEqual(await readdir(root),['commander-config.json']);
+ });
+});
+test('R137 recovered config remains hash-preconditioned for subsequent edits',async()=>{
+ await fixture(async({root,file})=>{
+  await writeFile(file,'{"fileReadLineLimit":333,"bad":[');
+  const runtime=createCommanderExtendedRuntime({stateRoot:root});
+  const first=await runtime.getConfig();
+  await assert.rejects(runtime.setConfigValue({key:'theme',value:'classic',expected_sha256:'0'.repeat(64)}),/precondition/);
+  const done=await runtime.setConfigValue({key:'theme',value:'classic',expected_sha256:first.config_sha256});
+  assert.equal(done.status,'committed');
+  const fresh=createCommanderExtendedRuntime({stateRoot:root});
+  const now=await fresh.getConfig();
+  assert.equal(now.config.theme,'classic');
+  assert.equal(now.config.fileReadLineLimit,333);
+  assert.equal(now.recovery,undefined);
+ });
+});

package/test/r137-commander-three-version-contract.test.mjs

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import {pathToFileURL} from 'node:url';
+import path from 'node:path';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+import {registerCommanderExtendedBridge} from '../src/commander-extended-bridge-r47.mjs';
+
+const base='D:\\Projects\\deadbyte-mcp\\references';
+const fixtures=[
+ {version:'0.2.52',relative:'desktop-commander v0.2.52/dist/tools/schemas.js',sha256:'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140',tools:27},
+ {version:'0.3.0',relative:'desktop-commander v0.3.0/dist/tools/schemas.js',sha256:'7d4c62e2099d757d8fba68011cfe25d3088426f56c0b77d5b8fa3edb4ec49c2c',tools:26},
+ {version:'0.3.1-alpha.2',relative:'desktop-commander-0.3.1-alpha.2/static/dist/tools/schemas.js',sha256:'6a290497b29f9dc5f43d66008ea54fcf0c302edea5612af519ef52ab3816d29e',tools:27}
+];
+const known={
+ get_config:{},set_config_value:{key:'theme',value:'classic'},read_file:{path:'x'},read_multiple_files:{paths:['x']},
+ write_file:{path:'x',content:'v'},write_pdf:{path:'x',content:'# x'},create_directory:{path:'x'},
+ list_directory:{path:'x'},move_file:{source:'a',destination:'b'},start_search:{path:'.',pattern:'x'},
+ get_more_search_results:{sessionId:'s'},stop_search:{sessionId:'s'},list_searches:{},get_file_info:{path:'x'},
+ edit_block:{file_path:'x',old_string:'a',new_string:'b'},start_process:{command:'echo x',timeout_ms:10},
+ read_process_output:{pid:1},interact_with_process:{pid:1,input:'x'},force_terminate:{pid:1},list_sessions:{},
+ list_processes:{},kill_process:{pid:1},get_usage_stats:{},get_recent_tool_calls:{},
+ give_feedback_to_desktop_commander:{},get_prompts:{action:'get_prompt',promptId:'x'}
+};
+const sha=s=>createHash('sha256').update(s).digest('hex');
+const unwrap=o=>{while(o?._def?.schema)o=o._def.schema;return o};
+function candidate(){
+ const v={...createCommanderWireAdapter({}).schemas};
+ registerCommanderExtendedBridge({registerTool(name,def){v[name]=def.inputSchema;}},{extendedRuntime:{}});
+ return v;
+}
+async function reference(f){
+ const bytes=await readFile(path.join(base,f.relative));
+ assert.equal(sha(bytes),f.sha256,'reference source SHA drift: '+f.version);
+ const zod=pathToFileURL(path.resolve('node_modules/zod/v3/index.js')).href;
+ const source=bytes.toString('utf8').replace('from "zod"','from '+JSON.stringify(zod));
+ return (await import('data:text/javascript;base64,'+Buffer.from(source).toString('base64'))).toolArgSchemas;
+}
+for(const fixture of fixtures){
+ test('R137 pinned Desktop Commander '+fixture.version+' public tool schemas remain compatible',async()=>{
+  const r=await reference(fixture),c=candidate();
+  assert.equal(Object.keys(r).length,fixture.tools);
+  if(fixture.version==='0.3.0')assert.equal(Object.hasOwn(r,'get_prompts'),false);
+  for(const [name,refSchema] of Object.entries(r)){
+   // track_ui_event is a deliberately hidden UI dispatch, not a public MCP tool.
+   if(name==='track_ui_event')continue;
+   assert.ok(c[name],'DEADBYTE missing '+name);
+   assert.deepEqual(Object.keys(unwrap(c[name]).shape).sort(),Object.keys(unwrap(refSchema).shape).sort(),name+' property names');
+   const expected=refSchema.safeParse({...known[name],__future_extra:'strip'});
+   const actual=c[name].safeParse({...known[name],__future_extra:'strip'});
+   assert.equal(actual.success,expected.success,name+' input acceptance');
+   if(actual.success)assert.deepEqual(actual.data,expected.data,name+' normalized defaults');
+  }
+ });
+}

package/test/r138-commander-process-pagination.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createCommanderExternalProcessRuntime} from '../src/commander-external-process-r48.mjs';
+
+const snapshot='a'.repeat(64),stamp='2026-10-21T11:00:00.000Z';
+const row=(pid)=>({pid,parent_pid:1,name:'test'+pid+'.exe',ownership:'external',
+ creation_time_utc:stamp,executable_path:null,command_line:null});
+const page=(items,cursor=null,identity=snapshot)=>({status:'ok',snapshot_id:identity,observed_at_utc:stamp,
+ processes:items,next_cursor:cursor,receipt_id:'b'.repeat(24)});
+function fixture(sequence){
+ let index=0;
+ const observationRuntime={async processList(){return sequence[Math.min(index++,sequence.length-1)];}};
+ return {runtime:createCommanderExternalProcessRuntime({observationRuntime}),calls:()=>index};
+}
+test('R138 rejects a repeated external process cursor instead of polling forever',async()=>{
+ const f=fixture([page([row(1)],'repeat'),page([row(2)],'repeat')]);
+ await assert.rejects(f.runtime.list(),/cursor.*repeat|pagination.*cycle/i);
+ assert.equal(f.calls(),2);
+});
+test('R138 rejects duplicate PID across pages instead of creating ambiguous kill target',async()=>{
+ const f=fixture([page([row(42)],'next'),page([row(42)],null)]);
+ await assert.rejects(f.runtime.list(),/duplicate.*PID/i);
+ assert.equal(f.calls(),2);
+});
+test('R138 rejects contradictory observation timestamps across a single snapshot',async()=>{
+ const f=fixture([page([row(1)],'next'),{...page([row(2)]),observed_at_utc:'2026-10-21T12:00:00.000Z'}]);
+ await assert.rejects(f.runtime.list(),/observation time.*changed|timestamp.*changed/i);
+});
+test('R138 rejects invalid missing snapshot identity and unbounded cursor',async()=>{
+ const f=fixture([{...page([row(1)]),snapshot_id:null}]);
+ await assert.rejects(f.runtime.list(),/snapshot.*identity/i);
+ const oversized=fixture([page([row(1)],'x'.repeat(12000))]);
+ await assert.rejects(oversized.runtime.list(),/cursor.*invalid/i);
+});
+test('R138 normal two-page process observation preserves ordered identities and receipts',async()=>{
+ const f=fixture([page([row(1)],'next'),page([row(2)])]);
+ const r=await f.runtime.list();
+ assert.deepEqual(r.processes.map(x=>x.pid),[1,2]);
+ assert.equal(r.snapshot_id,snapshot);
+ assert.deepEqual(r.receipt_ids,['b'.repeat(24)]);
+ assert.equal(f.calls(),2);
+});

package/test/r138-commander-session-list.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
+test('R138 Commander sessions show PID, profile, root, and exit outcome in one line',async()=>{
+ const sessions=[
+  {session_id:'a'.repeat(64),child_pid:21138,state:'running',exit_code:null,profile_id:'powershell',root_id:'core',stream_head:17},
+  {session_id:'b'.repeat(64),child_pid:22138,state:'exited',exit_code:7,profile_id:'node',root_id:'build',stream_head:20}
+ ];
+ const a=createCommanderWireAdapter({processRuntime:{async list(){return {sessions}}}});
+ const r=await a.handlers.list_sessions({});
+ assert.equal(r.isError,undefined);
+ assert.deepEqual(r.structuredContent.sessions,sessions);
+ assert.match(r.content[0].text,/PID=21138/);
+ assert.match(r.content[0].text,/PID=22138/);
+ assert.match(r.content[0].text,/exit=7/);
+ assert.match(r.content[0].text,/profile=node/);
+ assert.match(r.content[0].text,/root=build/);
+});
+test('R138 no sessions returns a readable empty summary',async()=>{
+ const a=createCommanderWireAdapter({processRuntime:{async list(){return {sessions:[]}}}});
+ const r=await a.handlers.list_sessions({});
+ assert.match(r.content[0].text,/No managed sessions/);
+ assert.deepEqual(r.structuredContent.sessions,[]);
+});