deadbyte-mcp 0.15.52 → 0.15.54

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

@@ -14,12 +14,13 @@ function fakePlane(){
 
 test('R47 remote Commander bridge routes remote_device directly to remote-device-r44 plane',async()=>{
   const server=fakeServer(),plane=fakePlane();
+  plane.probe=async value=>{plane.calls.push({op:'probe',value});return {device_id:value.deviceId,epoch:value.epoch,connection_id:'c',reachable:true};};
   registerCommanderRemoteBridge(server,{remoteDevicePlane:plane});
   assert.ok(server.tools.has('remote_device'));assert.ok(server.tools.has('remote_mcp'));
   const tool=server.tools.get('remote_device').handler;const id='a'.repeat(64);
   await tool({op:'pair',public_key_spki_base64:'ZmFrZQ==',display_name:'lab'});
   await tool({op:'status',device_id:id});await tool({op:'report_online',device_id:id,epoch:1,connection_id:'c'});
-  await tool({op:'probe',device_id:id,epoch:1});await tool({op:'dispatch',device_id:id,epoch:1,capability_id:'machine.status',payload:{},request_id:'b'.repeat(64)});
+  await tool({op:'probe',device_id:id,epoch:1,connection_id:'c',nonce:'f'.repeat(64)});await tool({op:'dispatch',device_id:id,epoch:1,capability_id:'machine.status',payload:{},request_id:'b'.repeat(64)});
   await tool({op:'revoke',device_id:id,epoch:1});await tool({op:'rotate_credential',device_id:id,epoch:1,encrypted_bundle_base64:'dG9rZW4=',expected_previous_sha256:null});await tool({op:'list'});
   assert.deepEqual(plane.calls.map(x=>x.op),['pair','status','report_online','probe','dispatch','revoke','rotate_credential','list']);
 });
@@ -37,3 +38,21 @@ test('R47 remote surfaces fail closed as unavailable when no remote-device-r44 p
   const result=await server.tools.get('remote_device').handler({op:'list'});
   assert.equal(result.status,'unavailable');assert.match(result.error,/remote-device-r44 plane is not configured/);
 });
+
+test('R146 remote readiness bridge binds the caller nonce and exact live connection',async()=>{
+  const server=fakeServer(),id='e'.repeat(64),nonce='f'.repeat(64),calls=[];
+  const plane={
+    async probe(value){calls.push(value);return {device_id:id,epoch:3,connection_id:'conn-3',reachable:true};}
+  };
+  registerCommanderRemoteBridge(server,{remoteDevicePlane:plane});
+  const registered=server.tools.get('remote_device');
+  const parsed=registered.meta.inputSchema.safeParse({op:'probe',device_id:id,epoch:3,connection_id:'conn-3',nonce});
+  assert.equal(parsed.success,true,'strict remote_device schema must accept the readiness challenge');
+  const result=await registered.handler(parsed.data);
+  assert.deepEqual(calls,[{deviceId:id,epoch:3}]);
+  assert.equal(result.device_id,id);assert.equal(result.epoch,3);
+  assert.equal(result.connection_id,'conn-3');assert.equal(result.nonce,nonce);assert.equal(result.ready,true);
+
+  plane.probe=async()=>({device_id:id,epoch:3,connection_id:'superseded',reachable:true});
+  await assert.rejects(registered.handler(parsed.data),/connection identity mismatch/i);
+});

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

@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
+import { validateRemoteProbeResponseR47 } from '../src/commander-remote-relay-r47.mjs';
 
 const sha=value=>createHash('sha256').update(value).digest('hex');
 
@@ -23,3 +24,13 @@ test('R47 relay is native MCP client and contains no Desktop Commander dependenc
   assert.doesNotMatch(relay,/@wonderwhy-er\/desktop-commander/);
   assert.equal(sha(relay).length,64);
 });
+
+test('R146 remote relay rejects fabricated or stale readiness acknowledgments',()=>{
+  const deviceId='a'.repeat(64),nonce='b'.repeat(64),connectionId='conn-live';
+  const good={device_id:deviceId,epoch:4,connection_id:connectionId,nonce,ready:true};
+  assert.deepEqual(validateRemoteProbeResponseR47(good,{deviceId,epoch:4,connectionId,nonce}),good);
+  assert.throws(()=>validateRemoteProbeResponseR47({...good,nonce:'c'.repeat(64)},{deviceId,epoch:4,connectionId,nonce}),/nonce mismatch/i);
+  assert.throws(()=>validateRemoteProbeResponseR47({...good,connection_id:'conn-stale'},{deviceId,epoch:4,connectionId,nonce}),/connection identity mismatch/i);
+  assert.throws(()=>validateRemoteProbeResponseR47({...good,device_id:'d'.repeat(64)},{deviceId,epoch:4,connectionId,nonce}),/device identity mismatch/i);
+  assert.throws(()=>validateRemoteProbeResponseR47({...good,ready:false},{deviceId,epoch:4,connectionId,nonce}),/not ready/i);
+});

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.52');
-  assert.equal(release.train,'R143');
-  assert.equal(matrix.train,'R143');
-  assert.equal(release.source_predecessor.version,'0.15.51');
-  assert.match(release.source_predecessor.source_path,/0\.15\.51/);
+    assert.equal(actual,'0.15.54');
+  assert.equal(release.train,'R146');
+  assert.equal(matrix.train,'R146');
+  assert.equal(release.source_predecessor.version,'0.15.53');
+  assert.match(release.source_predecessor.source_path,/0\.15\.53/);
   assert.equal(release.runtime_predecessor.version,'0.15.45');
-  assert.equal(provenance.source_predecessor_version,'0.15.51');
-  assert.equal(provenance.source_predecessor_manifest_file_sha256,'ef27d35d0d3102b356fcb17478abefa82fae2375df27f913ce3b0ff0e5815a7e');
+  assert.equal(provenance.source_predecessor_version,'0.15.53');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'04722504077844bbddb069aee72bfb7336b9ebfee8b6dd4733f48a82f4762cad');
   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('R143 package identities, R132 historic evidence and published 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.52');
+    assert.equal(value,'0.15.54');
   }
-  assert.equal(release.train,'R143');
-  assert.equal(matrix.train,'R143');
-  assert.equal(release.source_predecessor.version,'0.15.51');
-  assert.match(release.source_predecessor.source_path,/0\.15\.51/);
-  assert.equal(prov.source_predecessor_version,'0.15.51');
-  assert.equal(prov.source_predecessor_manifest_file_sha256,'ef27d35d0d3102b356fcb17478abefa82fae2375df27f913ce3b0ff0e5815a7e');
-  assert.equal(prov.parent_tarball_sha256,'69586dc07dc7a3025ec44f08e6b0eab60c1f9e75287da77c850b49e320b201ff');
+  assert.equal(release.train,'R146');
+  assert.equal(matrix.train,'R146');
+  assert.equal(release.source_predecessor.version,'0.15.53');
+  assert.match(release.source_predecessor.source_path,/0\.15\.53/);
+  assert.equal(prov.source_predecessor_version,'0.15.53');
+  assert.equal(prov.source_predecessor_manifest_file_sha256,'04722504077844bbddb069aee72bfb7336b9ebfee8b6dd4733f48a82f4762cad');
+  assert.equal(prov.parent_tarball_sha256,'596aba2aefdb6d55824302e5aa2ca0e8ca2ea30eb2a6a13da4ec6ab036bd2a2c');
   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/r144-claim-terminal-history.test.mjs

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,rm,readFile,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {performance} from 'node:perf_hooks';
+import {openRemoteCallClaims} from '../bridge/src/remote-call-claims-r60.mjs';
+
+const now=Date.parse('2029-01-01T00:00:00Z');
+const base={device_id:'device-1',session_id:'session-1',request_id:'init',
+  tool:'coding_file_write',arguments:{root_id:'fixture',path:'a.txt',content:'A'},
+  expires_at_utc:'2030-01-01T00:00:00.000Z',release_id:'v-test',
+  generation_manifest_sha256:'a'.repeat(64),machine_id:'b'.repeat(64),
+  online_epoch:'c'.repeat(64),classification:'mutating'};
+
+test('R144 terminal-heavy recovery ignores closed history and keeps live interruption fail-closed',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'r144-terminal-'));
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>now});
+    for(let i=0;i<200;i++){
+      const rec=await store.claim({...base,request_id:'terminal-'+i});
+      await store.dispatch(rec.claim_id);
+      await store.terminal(rec.claim_id,{status:'ok',value:i});
+    }
+    const pending=await store.claim({...base,request_id:'pending'});
+    const inflight=await store.claim({...base,request_id:'inflight'});
+    await store.dispatch(inflight.claim_id);
+    const start=performance.now(), recovered=await store.recover({limit:100});
+    const elapsed_ms=Math.round(performance.now()-start);
+    assert.deepEqual(new Set(recovered.records.map(x=>x.claim_id)),new Set([pending.claim_id,inflight.claim_id]));
+    assert.equal(recovered.next_cursor,null);
+    assert.equal((await store.state(inflight.claim_id)).state,'INTERRUPTED');
+    assert.equal((await store.state(inflight.claim_id)).side_effect_state,'unknown');
+    const replay=await store.claim({...base,request_id:'terminal-77'});
+    assert.equal(replay.owner,false);
+    assert.equal(replay.state,'TERMINAL');
+    console.log('R144_TERMINAL_HISTORY_BENCH',{terminal_count:200,elapsed_ms});
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+test('R144 terminal marker cannot enable replay when its bytes are forged',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'r144-forged-'));
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>now});
+    const claim=await store.claim(base);
+    await store.dispatch(claim.claim_id);
+    await store.terminal(claim.claim_id,{status:'ok'});
+    const f=path.join(dir,claim.claim_id.slice(0,2),claim.claim_id+'.terminal.json');
+    const bytes=await readFile(f,'utf8');
+    await writeFile(f,bytes.replace('"status":"ok"','"status":"forged"'));
+    assert.equal((await store.recover({limit:100})).records.length,0);
+    await assert.rejects(store.claim(base),/terminal hash corrupt|remote claim state unreadable/);
+    await assert.rejects(store.dispatch(claim.claim_id),/already dispatched/);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});

package/test/r144-controller-broad-roots-cleanup.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile,writeFile,mkdtemp,mkdir,rm,access} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+
+const q=x=>"'"+String(x).replaceAll("'","''")+"'";
+const section=(src,start,end)=>{
+  const a=src.indexOf('function '+start+'('),b=src.indexOf('function '+end+'(',a);
+  assert.ok(a>=0&&b>a,start+' boundaries missing');
+  return src.slice(a,b);
+};
+
+test('R144 broad Coding roots with no leases permit isolated cleanup without changing grants',async()=>{
+  const home='C:/Users/DEADBYTE/.deadbyte-mcp';
+  const cfgRoot=path.join(home,'generations','v0.15.45-34aa8d1241cfb8bf-ga9de1c56d5e65fa4');
+  const tmp=await mkdtemp(path.join(os.tmpdir(),'r144-broad-policy-cleanup-'));
+  try{
+    const runtime=path.join(tmp,'runtime');await mkdir(runtime);
+    const coding=JSON.parse(await readFile(path.join(cfgRoot,'coding-policy.json'),'utf8'));
+    const autonomous=JSON.parse(await readFile(path.join(cfgRoot,'autonomous-policy.json'),'utf8'));
+    assert.equal(coding.roots.local_c.path,'C:\\');
+    assert.equal(coding.roots.local_d.path,'D:\\');
+    coding.lease_file=path.join(runtime,'coding-grant.json');
+    const codingFile=path.join(tmp,'coding.json');
+    await writeFile(codingFile,JSON.stringify(coding));
+    autonomous.lease_file=path.join(runtime,'autonomous-grant.json');
+    autonomous.coding_policy_sha256=createHash('sha256').update(await readFile(codingFile)).digest('hex');
+    const autonomousFile=path.join(tmp,'autonomous.json');
+    await writeFile(autonomousFile,JSON.stringify(autonomous));
+    const src=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+    const code=[
+      "$ErrorActionPreference='Stop';",'$RuntimeDir='+q(runtime)+';',
+      'function Fail([string]$m){throw $m}',
+      'function Invoke-AuthorityEpochCommand{throw "UNEXPECTED_EPOCH_MUTATION"}',
+      section(src,'Assert-PolicyRootsAvailable','Get-AuthorityEpochStatus'),
+      section(src,'Read-ControllerPolicySnapshot','Get-CodingPolicyMetadata'),
+      section(src,'Get-CodingPolicyMetadata','Get-CodingLeaseStatus'),
+      section(src,'Disarm-Coding','Show-CodingStatus'),
+      section(src,'Get-AutonomousRevocationLeaseFile','Show-AutonomousStatus'),
+      '$cfg=@{CodingPolicyFile='+q(codingFile)+';AutonomousPolicyFile='+q(autonomousFile)+'};',
+      'Disarm-Coding $cfg; Disarm-Autonomous $cfg; Write-Output "R144_NO_GRANT_REVOKE_OK"'
+    ].join('\n');
+    const run=spawnSync('powershell.exe',['-NoLogo','-NoProfile','-NonInteractive','-Command',code],{
+      encoding:'utf8',timeout:30000,maxBuffer:1024*1024
+    });
+    assert.equal(run.status,0,run.stderr+'\n'+run.stdout);
+    assert.match(run.stdout,/R144_NO_GRANT_REVOKE_OK/);
+    for(const f of ['coding-grant.json','autonomous-grant.json'])
+      await assert.rejects(access(path.join(runtime,f)),{code:'ENOENT'});
+  }finally{await rm(tmp,{recursive:true,force:true});}
+});

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/);
+});