deadbyte-mcp 0.15.52 → 0.15.54

package/test/r147-remote-request-hash.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {registerCommanderRemoteBridge} from '../src/commander-remote-bridge-r47.mjs';
+
+function canonical(value) {
+  if(Array.isArray(value)) return value.map(canonical);
+  if(value&&typeof value==='object')
+    return Object.fromEntries(Object.keys(value).sort((a,b)=>a.localeCompare(b,'en')).map(key=>[key,canonical(value[key])]));
+  return value;
+}
+const hashRequest=v=>createHash('sha256').update(JSON.stringify(canonical(v)),'utf8').digest('hex');
+function server(){
+  const tools=new Map();
+  return {tools,registerTool(name,meta,handler){tools.set(name,{meta,handler});}};
+}
+const id='a'.repeat(64),request='b'.repeat(64),epoch=4,cap='machine.status';
+const payload={z:4,a:{inner:1}};
+const digest=hashRequest({device_id:id,epoch,capability_id:cap,payload});
+
+test('R147 native relay request_sha256 passes strict remote_mcp schema',()=>{
+  const app=server();registerCommanderRemoteBridge(app,{});
+  const validation=app.tools.get('remote_mcp').meta.inputSchema.safeParse({
+    device_id:id,epoch,capability_id:cap,payload,request_id:request,request_sha256:digest
+  });
+  assert.equal(validation.success,true,'native relay sends request_sha256 and strict server must accept it');
+});
+
+test('R147 remote_mcp rejects a conflicting claimed payload hash before dispatch',async()=>{
+  const app=server(),calls=[];
+  registerCommanderRemoteBridge(app,{remoteDevicePlane:{async dispatch(value){calls.push(value);return {state:'completed',result_sha256:digest};}}});
+  const input={device_id:id,epoch,capability_id:cap,payload,request_id:request,request_sha256:'f'.repeat(64)};
+  await assert.rejects(app.tools.get('remote_mcp').handler(input),/request.*hash.*mismatch/i);
+  assert.equal(calls.length,0);
+});
+
+test('R147 remote_mcp binds matching digest and retains original dispatch contract',async()=>{
+  const app=server(),calls=[];
+  registerCommanderRemoteBridge(app,{remoteDevicePlane:{async dispatch(value){calls.push(value);return {state:'completed',result_sha256:digest};}}});
+  const input={device_id:id,epoch,capability_id:cap,payload,request_id:request,request_sha256:digest};
+  const result=await app.tools.get('remote_mcp').handler(input);
+  assert.equal(result.state,'completed');
+  assert.deepEqual(calls,[{deviceId:id,epoch,capabilityId:cap,payload,requestId:request}]);
+});
+
+test('R147 remote_mcp remains backward-compatible with correctly scoped legacy call',async()=>{
+  const app=server(),calls=[];
+  registerCommanderRemoteBridge(app,{remoteDevicePlane:{async dispatch(v){calls.push(v);return {state:'completed'};}}});
+  const result=await app.tools.get('remote_mcp').handler({
+    device_id:id,epoch,capability_id:cap,payload,request_id:request
+  });
+  assert.equal(result.state,'completed');
+  assert.equal(calls.length,1);
+});

package/test/r59-tool-surface-compat.test.mjs

@@ -83,7 +83,7 @@ test('R72 compact baseline permits only R64 read offset and authorized coding-on
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
   const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
-  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52'].includes(packageVersion)){
+  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54'].includes(packageVersion)){
     assert.deepEqual([...diff.schema_changed].sort(),['machine_fs','native_diff_preview']);
     assert.equal(diff.unchanged.length,41);
     const prior=baseline.tools.find(tool=>tool.name==='machine_fs');

package/test/r65-activation-orchestration.test.mjs

@@ -178,3 +178,56 @@ test('terminal activation outcome is persisted before activation claim release',
   assert.equal(result.state,'ACTIVATED');
   assert.deepEqual(order,['claim','activate-start','activate-end','record','release']);
 });
+
+test('R146 legacy offline scope repair is claimed, owner-bound and reproved immediately before activation',async()=>{
+  const order=[];
+  const disarmed=plane=>({configured:true,armed:false,reason:plane==='autonomous'?'unverified':'disarmed'});
+  const proof=plane=>({state:plane==='autonomous'?'UNVERIFIED':'VERIFIED_DISARMED',policy_sha256:policies[plane],grant_absent:true});
+  let current={state:'OFFLINE',local_ready:false,bridge:{alive:false},core:{alive:false},cloud:{alive:false},supervisor:{running:false},
+    authority:Object.fromEntries(Object.keys(policies).map(plane=>[plane,disarmed(plane)])),
+    authority_proof:Object.fromEntries(Object.keys(policies).map(plane=>[plane,proof(plane)])),policy_sha256:policies,
+    active_release_id:parent.release_id,active_manifest_sha256:parent.manifest_sha256,
+    active_generation_manifest_sha256:parent.generation_manifest_sha256};
+  const observe=async()=>current;
+  const claim=async subject=>{order.push('claim:'+subject);return async()=>order.push('release');};
+  const legacyOfflineRecovery=async({phase,preflight_subject_sha256,candidate:boundCandidate})=>{
+    order.push('proof:'+phase);
+    assert.match(preflight_subject_sha256,/^[0-9a-f]{64}$/);
+    assert.equal(boundCandidate.manifest_sha256,candidate.manifest_sha256);
+    return {state:'VERIFIED_OFFLINE_LEGACY_SCOPE_REPAIR',preflight_subject_sha256,
+      candidate_manifest_sha256:candidate.manifest_sha256,owner_approval_verified:true,subject_sha256:'7'.repeat(64)};
+  };
+  const activate=async()=>{
+    order.push('activate');
+    current={...current,state:'ONLINE',local_ready:true,...ids,supervisor:{running:true},
+      authority:Object.fromEntries(Object.keys(policies).map(plane=>[plane,legacyEntry(false)])),
+      authority_proof:Object.fromEntries(Object.keys(policies).map(plane=>[plane,{state:'VERIFIED_DISARMED',policy_sha256:policies[plane],grant_absent:true}]))};
+    return {verified:true,release_id:'v0.15.42-new'};
+  };
+  const recordOutcome=async outcome=>{order.push('record:'+outcome.state);};
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,
+    observe,command:async()=>{throw new Error('no authority command expected');},activate,claim,recordOutcome,legacyOfflineRecovery});
+  assert.equal(result.state,'ACTIVATED');
+  assert.equal(result.authority_continuity,'LEGACY_SCOPE_REPAIRED_DISARMED');
+  assert.deepEqual(order.map(x=>x.replace(/:.*$/,'')),['claim','proof','proof','activate','record','release']);
+});
+
+test('R146 legacy offline scope proof drift after claim never dispatches activation',async()=>{
+  const authority=Object.fromEntries(Object.keys(policies).map(plane=>[plane,{configured:true,armed:false,reason:plane==='autonomous'?'unverified':'disarmed'}]));
+  const authority_proof=Object.fromEntries(Object.keys(policies).map(plane=>[plane,{state:plane==='autonomous'?'UNVERIFIED':'VERIFIED_DISARMED',policy_sha256:policies[plane],grant_absent:true}]));
+  const observation={state:'OFFLINE',local_ready:false,bridge:{alive:false},core:{alive:false},cloud:{alive:false},supervisor:{running:false},authority,authority_proof,policy_sha256:policies,
+    active_release_id:parent.release_id,active_manifest_sha256:parent.manifest_sha256,active_generation_manifest_sha256:parent.generation_manifest_sha256};
+  let proofs=0,activated=false,released=false;
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,
+    observe:async()=>observation,command:async()=>{},activate:async()=>{activated=true;return {verified:true};},
+    claim:async()=>async()=>{released=true;},recordOutcome:async()=>{},
+    legacyOfflineRecovery:async({preflight_subject_sha256})=>{
+      proofs++;
+      if(proofs===2)throw new Error('legacy policy bytes changed');
+      return {state:'VERIFIED_OFFLINE_LEGACY_SCOPE_REPAIR',preflight_subject_sha256,
+        candidate_manifest_sha256:candidate.manifest_sha256,owner_approval_verified:true,subject_sha256:'7'.repeat(64)};
+    }});
+  assert.equal(result.state,'ACTIVATION_REJECTED');
+  assert.equal(activated,false);
+  assert.equal(released,true);
+});

package/test/r74-prepublish-contract.test.mjs

@@ -21,8 +21,8 @@ test('R74 prepublish contract: positive path succeeds and verifies identities',
   assert.equal(result.checks.no_self_referential_tarball_hash, true);
   assert.equal(result.identities.package_name, 'deadbyte-mcp');
   // R74 component contract retains its train-specific source and predecessor assertions;
-  // the containing R143 package must report its actual immutable package version.
-  assert.equal(result.identities.package_version, '0.15.52');
+  // the containing R144 package must report its actual immutable package version.
+  assert.equal(result.identities.package_version, '0.15.54');
   assert.equal(result.identities.target_train, 'R74');
   assert.equal(result.identities.published_source_predecessor, '0.15.46');
   assert.notEqual(result.identities.published_source_predecessor, result.identities.runtime_predecessor);

package/test/release-generation.test.mjs

@@ -41,7 +41,10 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
     ]},
     LocalReadyUri:'http://127.0.0.1:8787/healthz',UrlRegex:'https://x',McpUrlFile:'C:/mcp-url.txt',McpUrlFileSha256:EXE,McpPathFile:'C:/token.txt',StartTimeoutSeconds:30,ProbeTimeoutSeconds:3};
   const coding={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:'C:/old/coding.json',evidence_dir:'C:/old/evidence',
-    roots:{core:{path:'C:/old/core',read:true,write:true,exec:true,deny_paths:['node_modules']}},commands:{tests:command(),powershell_script:command()},max_read_bytes:524288,max_write_bytes:2097152};
+    roots:{core:{path:'C:/old/core',read:true,write:true,exec:true,deny_paths:['node_modules']},
+      local_c:{path:'C:\\',read:true,write:true,exec:true,deny_paths:[]},
+      local_d:{path:'D:\\',read:true,write:true,exec:true,deny_paths:[]}},
+    commands:{tests:command(),powershell_script:{...command(),root_ids:['core','local_c','local_d']}},max_read_bytes:524288,max_write_bytes:2097152};
   const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,lease_file:'C:/old/auto.json',evidence_dir:'C:/old/auto-evidence',coding_policy_sha256:'0'.repeat(64),root_ids:['core'],planner:{backend:'client_sampling',max_tokens:4096},
     profiles:{
       gate:{kind:'command',root_id:'core',command_id:'tests',script_path:'scripts/gate.ps1',script_sha256:'0'.repeat(64),args:[],cwd:'.',timeout_ms:120000,expect_exit_code:0,required_for_release:true,run_after_mutation:true,description:'gate'},
@@ -97,6 +100,10 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const generatedCoding=JSON.parse(await readFile(result.coding_policy_path,'utf8'));
   assert.equal(generatedCoding.roots.core.path,path.resolve(development));
   assert.notEqual(generatedCoding.roots.core.path,path.resolve(release));
+  assert.equal(Object.hasOwn(generatedCoding.roots,'local_c'),false);
+  assert.equal(Object.hasOwn(generatedCoding.roots,'local_d'),false);
+  assert.deepEqual(generatedCoding.commands.powershell_script.root_ids,['core']);
+  assert.ok(Object.hasOwn(coding.roots,'local_c'),'predecessor policy must remain untouched');
   const parityScratch=path.join(path.resolve(state),'runtime','r33-parity-scratch');
   assert.deepEqual(generatedCoding.roots.parity_scratch,{path:parityScratch,read:true,write:true,exec:false,deny_paths:[]});
   await access(parityScratch);