deadbyte-mcp 0.15.53 → 0.15.54

package/test/r146-generation-scope-narrowing.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {rebindCodingPolicy} from '../src/release-generation.mjs';
+
+const settings={
+  developmentRoot:'D:\\Projects\\deadbyte-mcp\\r146',
+  stateRoot:'C:\\Users\\DEADBYTE\\.deadbyte-mcp',
+  parityScratchRoot:'C:\\Users\\DEADBYTE\\.deadbyte-mcp\\runtime\\r33-parity-scratch'
+};
+const root=folder=>({path:folder,read:true,write:true,exec:true,deny_paths:[]});
+const base=()=>({
+  schema:'deadbyte.coding-policy.v1',
+  roots:{
+    core:root('D:\\Projects\\deadbyte-mcp\\old'),
+    projects:root('D:\\Projects'),
+    local_c:root('C:\\'),
+    local_d:root('D:\\')
+  },
+  commands:{
+    powershell_script:{root_ids:['core','local_c','local_d']},
+    cmd_script:{root_ids:['projects','local_d']},
+    node_script:{root_ids:['core','local_c']}
+  }
+});
+
+test('R146 never inherits historical C/D whole-drive authority',()=>{
+  const original=base();
+  const rewritten=rebindCodingPolicy(original,settings);
+  assert.deepEqual(Object.keys(rewritten.roots).sort(),['core','parity_scratch','projects']);
+  assert.equal(rewritten.roots.core.path,settings.developmentRoot);
+  assert.equal(rewritten.roots.parity_scratch.exec,false);
+  assert.deepEqual(rewritten.commands.powershell_script.root_ids,['core']);
+  assert.deepEqual(rewritten.commands.cmd_script.root_ids,['projects']);
+  assert.deepEqual(rewritten.commands.node_script.root_ids,['core']);
+  assert.equal(original.roots.local_c.path,'C:\\');
+  assert.equal(original.roots.local_d.path,'D:\\');
+  assert.deepEqual(original.commands.powershell_script.root_ids,['core','local_c','local_d']);
+});
+
+test('R146 unknown whole drive root is not silently adopted',()=>{
+  const raw=base();raw.roots.other=root('E:\\');
+  assert.throws(()=>rebindCodingPolicy(raw,settings),/unrecognized whole-drive Coding root/);
+});
+
+test('R146 fail closed if a command loses its last root',()=>{
+  const raw=base();raw.commands.powershell_script.root_ids=['local_c'];
+  assert.throws(()=>rebindCodingPolicy(raw,settings),/every scoped root/);
+});
+
+test('R146 preserves a separately scoped local root',()=>{
+  const raw=base();raw.roots.local_d.path='D:\\Projects\\scratch';
+  const result=rebindCodingPolicy(raw,settings);
+  assert.equal(result.roots.local_d.path,'D:\\Projects\\scratch');
+  assert.deepEqual(result.commands.cmd_script.root_ids,['projects','local_d']);
+});
+
+test('R146 ordinary scoped policies retain their command roots',()=>{
+  const raw=base();delete raw.roots.local_c;delete raw.roots.local_d;
+  raw.commands.powershell_script.root_ids=['core'];raw.commands.cmd_script.root_ids=['projects'];raw.commands.node_script.root_ids=['core'];
+  const result=rebindCodingPolicy(raw,settings);
+  assert.deepEqual(result.commands.powershell_script.root_ids,['core']);
+  assert.equal(result.roots.projects.path,'D:\\Projects');
+});

package/test/r146-legacy-offline-policy-proof.test.mjs

@@ -0,0 +1,199 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,sign} from 'node:crypto';
+import {mkdir,mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {proveLegacyOfflineScopeRepair} from '../src/legacy-offline-policy-proof-r146.mjs';
+import {canonicalJson} from '../src/canonical-json.mjs';
+
+const sha=x=>createHash('sha256').update(x).digest('hex');
+const PLANES=['process','coding','autonomous','desktop','host'];
+const GRANT={process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'};
+const APPROVAL_DOMAIN=Buffer.from('DEADBYTE-R146-POLICY-MIGRATION-APPROVAL\0','utf8');
+const mkRoot=p=>({path:p,read:true,write:true,exec:true,deny_paths:[]});
+async function fixture({thirdDrive=false,badBinding=false}={}){
+  const base=await mkdtemp(path.join(os.tmpdir(),'r146-offline-scope-'));
+  const stateRoot=path.join(base,'state'),runtime=path.join(stateRoot,'runtime');
+  const gen=path.join(stateRoot,'generations','predecessor');
+  await mkdir(runtime,{recursive:true});await mkdir(gen,{recursive:true});
+  const policyPaths={},policySha256={},files=[];
+  const coding={
+    schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(runtime,'coding-grant.json'),
+    roots:{core:mkRoot(path.join(base,'project')),local_c:mkRoot('C:\\'),local_d:mkRoot('D:\\')},
+    commands:{powershell_script:{root_ids:['core','local_c','local_d']}}
+  };
+  if(thirdDrive)coding.roots.other=mkRoot('E:\\');
+  const codingBytes=Buffer.from(JSON.stringify(coding)+'\n');
+  const autonomous={
+    schema:'deadbyte.autonomous-policy.v1',enabled:true,
+    lease_file:path.join(runtime,'autonomous-grant.json'),
+    coding_policy_sha256:badBinding?'a'.repeat(64):sha(codingBytes),
+    root_ids:['core'],profiles:{}
+  };
+  const policies={
+    coding,autonomous,
+    process:{schema:'deadbyte.process-policy.v1',enabled:true,grant_file:path.join(runtime,'process-grant.json')},
+    desktop:{schema:'deadbyte.desktop-policy.v1',enabled:true,grant_file:path.join(runtime,'desktop-grant.json')},
+    host:{schema:'deadbyte.host-policy.v2',enabled:true,arm_file:path.join(runtime,'host-grant.json')}
+  };
+  for(const plane of PLANES){
+    const file=path.join(gen,plane+'-policy.json');
+    const bytes=plane==='coding'?codingBytes:Buffer.from(JSON.stringify(policies[plane])+'\n');
+    await writeFile(file,bytes);
+    policyPaths[plane]=file;policySha256[plane]=sha(bytes);
+    files.push([plane+'-policy.json',sha(bytes)]);
+  }
+  const manifest=Buffer.from(files.sort((a,b)=>a[0].localeCompare(b[0],'en')).map(x=>x[1]+'  '+x[0]).join('\n')+'\n');
+  await writeFile(path.join(gen,'GENERATION.SHA256'),manifest);
+  const parent={release_id:'v0.15.45-34aa8d1241cfb8bf',version:'0.15.45',
+    manifest_sha256:'1'.repeat(64),generation_manifest_sha256:sha(manifest)};
+  const pointer={...parent,generation_root:gen};
+  await writeFile(path.join(stateRoot,'active-release.json'),JSON.stringify(pointer)+'\n');
+  const authority=Object.fromEntries(PLANES.map(p=>[p,{
+    configured:true,armed:false,reason:p==='autonomous'?'unverified':'disarmed'
+  }]));
+  const authority_proof=Object.fromEntries(PLANES.map(p=>[p,{
+    state:p==='autonomous'?'UNVERIFIED':'VERIFIED_DISARMED',
+    grant_absent:true,policy_sha256:policySha256[p]
+  }]));
+  const observation={state:'OFFLINE',local_ready:false,
+    bridge:{alive:false},core:{alive:false},cloud:{alive:false},supervisor:{running:false},
+    authority,authority_proof,policy_sha256:policySha256,
+    active_release_id:parent.release_id,active_manifest_sha256:parent.manifest_sha256,
+    active_generation_manifest_sha256:parent.generation_manifest_sha256};
+  const candidate={version:'0.15.54',manifest_sha256:'9'.repeat(64)};
+  const preflightSubjectSha256='8'.repeat(64);
+  const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+  const ownerKeyId=sha(publicKey.export({type:'spki',format:'der'}));
+  const trust=path.join(stateRoot,'trust');await mkdir(trust,{recursive:true});
+  const ownerPublicKeyPath=path.join(trust,'r70-owner-public.pem');
+  await writeFile(ownerPublicKeyPath,publicKey.export({type:'spki',format:'pem'}));
+  const subject={schema:'deadbyte.r146-policy-migration-subject.v1',action:'legacy_offline_scope_repair',
+    predecessor_release_id:parent.release_id,predecessor_version:parent.version,
+    predecessor_manifest_sha256:parent.manifest_sha256,
+    predecessor_generation_manifest_sha256:parent.generation_manifest_sha256,
+    candidate_version:candidate.version,candidate_manifest_sha256:candidate.manifest_sha256,
+    predecessor_policy_sha256:policySha256,preflight_subject_sha256:preflightSubjectSha256,
+    issued_at_utc:'2026-10-23T00:00:00.000Z',expires_at_utc:'2026-10-23T00:30:00.000Z'};
+  const subjectSha256=sha(Buffer.from(canonicalJson(subject),'utf8'));
+  const signed={schema:'deadbyte.r146-policy-migration-approval.v1',subject_sha256:subjectSha256,owner_key_id:ownerKeyId};
+  const approval={...signed,subject,signature_base64:sign(null,Buffer.concat([APPROVAL_DOMAIN,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64')};
+  const approvalPath=path.join(base,'approval.json'),approvalBytes=Buffer.from(JSON.stringify(approval));
+  await writeFile(approvalPath,approvalBytes);
+  return {
+    root:base,stateRoot,pointer,expectedParent:parent,observation,policyPaths,policySha256,
+    runtime,policies,candidate,expectedCandidate:candidate,preflightSubjectSha256,
+    approvalPath,approvalSha256:sha(approvalBytes),ownerPublicKeyPath,
+    now:new Date('2026-10-23T00:05:00.000Z'),async close(){await rm(base,{recursive:true,force:true});}
+  };
+}
+const invoke=x=>proveLegacyOfflineScopeRepair(x);
+test('R146 verifies exact inactive legacy scope only with manifest, direct grant absence and parent binding',async()=>{
+  const x=await fixture();
+  try{
+    const got=await invoke(x);
+    assert.equal(got.state,'VERIFIED_OFFLINE_LEGACY_SCOPE_REPAIR');
+    assert.equal(got.coding_policy_sha256,x.policySha256.coding);
+    assert.equal(got.generation_manifest_sha256,x.pointer.generation_manifest_sha256);
+    assert.equal(got.candidate_manifest_sha256,x.candidate.manifest_sha256);
+    assert.equal(got.preflight_subject_sha256,x.preflightSubjectSha256);
+    assert.equal(got.owner_approval_verified,true);
+    assert.match(got.subject_sha256,/^[0-9a-f]{64}$/);
+  }finally{await x.close();}
+});
+test('R146 proof rejects candidate or approval subject drift',async()=>{
+  const x=await fixture();
+  try{
+    await assert.rejects(invoke({...x,candidate:{...x.candidate,manifest_sha256:'7'.repeat(64)}}),/candidate|approval/i);
+    await assert.rejects(invoke({...x,preflightSubjectSha256:'7'.repeat(64)}),/preflight subject/i);
+  }finally{await x.close();}
+});
+test('R146 proof rejects an expired or not-yet-valid owner approval',async()=>{
+  const x=await fixture();
+  try{
+    await assert.rejects(invoke({...x,now:new Date('2026-10-23T00:30:00.000Z')}),/approval expired or invalid/);
+    await assert.rejects(invoke({...x,now:new Date('2026-10-22T23:59:59.999Z')}),/approval expired or invalid/);
+  }finally{await x.close();}
+});
+test('R146 proof rejects a forged approval even when its file hash is repinned',async()=>{
+  const x=await fixture();
+  try{
+    const approval=JSON.parse(await readFile(x.approvalPath,'utf8'));
+    approval.signature_base64=Buffer.alloc(64,0x5a).toString('base64');
+    const bytes=Buffer.from(JSON.stringify(approval));
+    await writeFile(x.approvalPath,bytes);
+    await assert.rejects(invoke({...x,approvalSha256:sha(bytes)}),/approval signature invalid/);
+  }finally{await x.close();}
+});
+test('R146 proof rejects an owner trust-key substitution',async()=>{
+  const x=await fixture();
+  try{
+    const {publicKey}=generateKeyPairSync('ed25519');
+    await writeFile(x.ownerPublicKeyPath,publicKey.export({type:'spki',format:'pem'}));
+    await assert.rejects(invoke(x),/owner key identity mismatch/);
+  }finally{await x.close();}
+});
+test('R146 proof rejects any unresolved authority epoch lock',async()=>{
+  const x=await fixture();
+  try{
+    const lock=path.join(x.runtime,'authority-epochs','coding','.lock');
+    await mkdir(path.dirname(lock),{recursive:true});await writeFile(lock,'ambiguous');
+    await assert.rejects(invoke(x),/authority epoch lock present/);
+  }finally{await x.close();}
+});
+test('R146 any real grant overrides apparent DISARMED observation',async()=>{
+  const x=await fixture();
+  try{
+    await writeFile(path.join(x.runtime,'autonomous-grant.json'),'active');
+    await assert.rejects(invoke(x),/autonomous grant present/);
+  }finally{await x.close();}
+});
+test('R146 foreground ownership marker blocks offline scope repair',async()=>{
+  const x=await fixture();
+  try{
+    await writeFile(path.join(x.runtime,'remote-session.json'),'retained');
+    await assert.rejects(invoke(x),/ownership marker present/);
+  }finally{await x.close();}
+});
+test('R146 active or uncertain runtime blocks offline scope repair',async()=>{
+  const x=await fixture();
+  try{
+    x.observation.bridge.alive=true;
+    await assert.rejects(invoke(x),/not cleanly offline/);
+  }finally{await x.close();}
+});
+test('R146 any unrelated unverified authority plane blocks scope repair',async()=>{
+  const x=await fixture();
+  try{
+    x.observation.authority.host.reason='unverified';
+    await assert.rejects(invoke(x),/not physically inactive: host/);
+  }finally{await x.close();}
+});
+test('R146 extra whole-drive root fails the special repair proof',async()=>{
+  const x=await fixture({thirdDrive:true});
+  try{
+    await assert.rejects(invoke(x),/unexpected drive root/);
+  }finally{await x.close();}
+});
+test('R146 autonomous coding policy digest mismatch blocks recovery',async()=>{
+  const x=await fixture({badBinding:true});
+  try{
+    await assert.rejects(invoke(x),/Coding\/Autonomous binding invalid/);
+  }finally{await x.close();}
+});
+test('R146 predecessor generation bytes drift blocks offline repair',async()=>{
+  const x=await fixture();
+  try{
+    await writeFile(x.policyPaths.coding,'{}');
+    await assert.rejects(invoke(x),/generation file hash mismatch/);
+  }finally{await x.close();}
+});
+test('R146 predecessor identity drift cannot be attested',async()=>{
+  const x=await fixture();
+  try{
+    x.expectedParent.manifest_sha256='a'.repeat(64);
+    await assert.rejects(invoke(x),/predecessor mismatch/);
+  }finally{await x.close();}
+});

package/test/r146-livelog-backpressure.test.mjs

@@ -0,0 +1,105 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {EventEmitter} from 'node:events';
+import {createLiveTimelineWriter} from '../src/remote-live-log.mjs';
+
+function blockedOutput(){
+  const stream=new EventEmitter();
+  const writes=[];
+  stream.isTTY=false;
+  let blockNext=false;
+  stream.write=chunk=>{
+    writes.push(chunk);
+    if(blockNext){blockNext=false;return false;}
+    return true;
+  };
+  return {stream,writes,block:()=>{blockNext=true;}};
+}
+test('R146 LiveLogs survives stdout backpressure without unbounded presentation writes',()=>{
+  const out=blockedOutput();
+  const writer=createLiveTimelineWriter({stream:out.stream,rewrite:false});
+  out.block();
+  writer.write('one');
+  for(let i=0;i<12000;i++)writer.write('status '+i);
+  assert.deepEqual(out.writes,['one\n']);
+  assert.equal(writer.retention().suppressed_since_drain,12000);
+  assert.equal(writer.retention().congested,true);
+  out.stream.emit('drain');
+  assert.match(out.writes[1],/LIVELOG.*12000.*suppressed.*audit/i);
+  assert.equal(writer.retention().suppressed_since_drain,0);
+  writer.write('after');
+  assert.equal(out.writes.at(-1),'after\n');
+  assert.equal(writer.retention().total_suppressed,12000);
+});
+test('R146 LiveLogs emits only one bounded warning for each backpressure window',()=>{
+  const out=blockedOutput();
+  const writer=createLiveTimelineWriter({stream:out.stream,rewrite:false});
+  out.block();writer.write('a');
+  writer.write('drop1');writer.write('drop2');
+  out.stream.emit('drain');
+  out.stream.emit('drain');
+  assert.equal(out.writes.length,2);
+  assert.match(out.writes[1],/2.*suppressed/);
+});
+test('R146 LiveLogs normal progress and TTY rewrite stay unchanged when drain never needed',()=>{
+  const out=blockedOutput();
+  out.stream.isTTY=true;
+  const writer=createLiveTimelineWriter({stream:out.stream,rewrite:true});
+  writer.write('RUN',{event_type:'tool.call',request_id:'a'});
+  writer.write('DONE',{event_type:'tool.result',request_id:'a'});
+  assert.deepEqual(out.writes,['RUN','\r\x1b[2KDONE\n']);
+  assert.equal(writer.retention().total_suppressed,0);
+});
+test('R146 LiveLogs refuses non-evented saturated stream instead of silently dropping output',()=>{
+  const sink={write(){return false;}};
+  const writer=createLiveTimelineWriter({stream:sink,rewrite:false});
+  assert.throws(()=>writer.write('line'),/drain-capable/);
+});
+
+test('R146 LiveLogs warns on a stalled TTY without leaving its partial START line attached',()=>{
+  const out=blockedOutput();
+  out.stream.isTTY=true;
+  const writer=createLiveTimelineWriter({stream:out.stream,rewrite:true});
+  out.block();
+  writer.write('RUN',{event_type:'tool.call',request_id:'a'});
+  writer.write('DONE',{event_type:'tool.result',request_id:'a'});
+  assert.equal(writer.retention().suppressed_since_drain,1);
+  out.stream.emit('drain');
+  assert.equal(out.writes[0],'RUN');
+  assert.equal(out.writes[1],'\n');
+  assert.match(out.writes[2],/1 presentation lines suppressed/);
+  writer.write('AFTER');
+  assert.equal(out.writes[3],'AFTER\n');
+});
+test('R146 LiveLogs repeated backpressure during warning remains bounded and recovers',()=>{
+  const out=blockedOutput();
+  const writer=createLiveTimelineWriter({stream:out.stream,rewrite:false});
+  out.block();writer.write('START');writer.write('hidden 1');
+  out.block();out.stream.emit('drain');
+  assert.equal(writer.retention().congested,true);
+  writer.write('hidden 2');
+  out.stream.emit('drain');
+  assert.equal(writer.retention().congested,false);
+  assert.equal(writer.retention().total_suppressed,2);
+  assert.match(out.writes[1],/1 presentation lines suppressed/);
+  assert.match(out.writes[2],/1 presentation lines suppressed/);
+});
+
+test('R146 LiveLogs session summary reports untracked overflow beyond its bounded in-flight cap',async()=>{
+  const {createLiveTimelineTracker}=await import('../src/remote-live-log.mjs');
+  const tracker=createLiveTimelineTracker({displayMode:'ascii'});
+  for(let i=0;i<4100;i++){
+    tracker.observe({event_type:'tool.request',tool:'coding_file_read',
+      request_id:'too-many-'+String(i).padStart(8,'0'),args:{root_id:'core',path:'readme'}},{sequence:i+1});
+  }
+  assert.equal(tracker.retention().pending,4096);
+  assert.equal(tracker.retention().pending_overflow,4);
+  assert.match(tracker.summary(),/4.*presentation spans.*(?:overflow|untracked)/i);
+});
+test('R146 CLI reports any still-congested output during final cleanup',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(cli,/timelineWriter\.retention\(\)/);
+  assert.match(cli,/suppressed_since_drain/);
+  assert.match(cli,/process\.stderr\.write/);
+});

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','0.15.53'].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

@@ -22,7 +22,7 @@ test('R74 prepublish contract: positive path succeeds and verifies identities',
   assert.equal(result.identities.package_name, 'deadbyte-mcp');
   // R74 component contract retains its train-specific source and predecessor assertions;
   // the containing R144 package must report its actual immutable package version.
-  assert.equal(result.identities.package_version, '0.15.53');
+  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);