deadbyte-mcp 0.15.44 → 0.15.46

package/test/capability-resolver.test.mjs

@@ -37,6 +37,10 @@ test('R59 live plane state can only reduce signed capability availability', asyn
 });
 
 test('deriveCapabilityRequirements maps dependencies accurately', () => {
+  const preview=R36_CAPABILITY_LEDGER.entries.find(item=>item.id==='native_diff.preview');
+  assert.equal(preview.authority,'coding');
+  assert.equal(preview.mutating,false);
+  assert.deepEqual(deriveCapabilityRequirements(preview),['DEADBYTE_AUTONOMOUS_RUNTIME','coding_session.armed']);
   const reqCodingRead = deriveCapabilityRequirements({
     id: 'coding.search',
     authority: 'coding',
@@ -61,6 +65,19 @@ test('deriveCapabilityRequirements maps dependencies accurately', () => {
   assert.deepEqual(reqSkill, ['skill_plane.valid']);
 });
 
+test('Native Diff preview is available under Coding read while apply remains Autonomous denied',async()=>{
+  const preview=R36_CAPABILITY_LEDGER.entries.find(item=>item.id==='native_diff.preview');
+  const apply=R36_CAPABILITY_LEDGER.entries.find(item=>item.id==='native_diff.apply');
+  const result=await resolveCapabilityStates({ledger:{entries:[preview,apply]},
+    toolCatalog:['native_diff_preview','native_diff_apply'],profile:'full',
+    env:{DEADBYTE_AUTONOMOUS_RUNTIME:'1'},
+    codingRuntime:{sessionStatus:async()=>({armed:true,root_ids:['project']})},
+    autonomousRuntime:{sessionStatus:async()=>({armed:false,reason:'disarmed'})}});
+  const byId=id=>result.capabilities.find(item=>item.id===id);
+  assert.equal(byId('native_diff.preview').state,CAPABILITY_STATES.AVAILABLE);
+  assert.equal(byId('native_diff.apply').state,CAPABILITY_STATES.DENIED);
+});
+
 test('resolveCapabilityStates resolves all 5 states correctly', async () => {
   const allCompactTools = [
     'capability_manifest',

package/test/codex-autonomous-r44.test.mjs

@@ -38,7 +38,7 @@ async function fixture(){
   const policy=await loadAutonomousPolicy(autonomousPath,codingPolicy);
   await writeBoundStandingGrant('coding', codingPolicy.lease_file, {schema:'deadbyte.coding-grant.v2',policy_sha256:codingPolicy.policy_sha256,
     instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()});
-  await writeBoundStandingGrant('autonomous', policy.lease_file, {schema:'deadbyte.autonomous-grant.v2',policy_sha256:policy.policy_sha256,
+  await writeBoundStandingGrant('autonomous', policy.lease_file, {schema:'deadbyte.autonomous-grant.v2',policy_sha256:policy.policy_sha256,coding_policy_sha256:codingPolicy.policy_sha256,
     instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()});
   const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   const nativeDiffRuntime=createNativeDiffRuntime({policy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});

package/test/commander-compat-runtime.test.mjs

@@ -32,3 +32,45 @@ test('native source rejects a Commander package dependency', () => {
   assertNoCommanderDependency("import x from './machine-fs.mjs';");
   assert.throws(()=>assertNoCommanderDependency("import x from '@wonderwhy-er/desktop-commander';"),/must not depend/);
 });
+
+test('host_exec script, inline, and native have independent required fields', () => {
+  const sha='a'.repeat(64);
+  const script={root_id:'core',command_id:'powershell_script',script_path:'scripts/check.ps1',script_sha256:sha};
+  const inline={mode:'inline',root_id:'core',command_id:'powershell_inline',command:'Write-Output ok'};
+  const native={mode:'native',root_id:'core',executable:'C:\\Windows\\System32\\whoami.exe',executable_sha256:sha};
+  for(const args of [script,inline,native]){
+    const validated=validateCommanderRequest('host_exec',args);
+    assert.equal(validated.native_tool,'host.exec');
+    assert.deepEqual(validated.args,args);
+  }
+});
+
+test('compat adapter routes only validated host_exec modes to the native operation', async () => {
+  const calls=[];
+  const rt=createCommanderCompatibilityRuntime({
+    invoke:async(native,args)=>{calls.push({native,args});return {status:'passed',mode:args.mode};}
+  });
+  const inline={mode:'inline',root_id:'core',command_id:'powershell_inline',command:'Write-Output ok'};
+  const result=await rt.call('host_exec',inline);
+  assert.equal(result.status,'ok');
+  assert.equal(calls.length,1);
+  assert.deepEqual(calls[0],{native:'host.exec',args:inline});
+  await assert.rejects(()=>rt.call('host_exec',{...inline,script_path:'stray.ps1'}),/unexpected fields/);
+  assert.equal(calls.length,1,'rejected requests must never reach native invoke');
+});
+
+test('host_exec rejects cross-mode parameters and malformed authority inputs', () => {
+  const sha='a'.repeat(64);
+  const inline={mode:'inline',root_id:'core',command_id:'powershell_inline',command:'Write-Output ok'};
+  const native={mode:'native',root_id:'core',executable:'C:\\Windows\\System32\\whoami.exe',executable_sha256:sha};
+  const reject=args=>assert.throws(()=>validateCommanderRequest('host_exec',args));
+  reject({...inline,script_sha256:sha});
+  reject({...native,command_id:'powershell_inline'});
+  reject({...native,executable_sha256:'bad'});
+  reject({...inline,command:'a'+String.fromCharCode(0)+'b'});
+  reject({...inline,command:''});
+  reject({mode:'inline',root_id:'core',command_id:'powershell_inline'});
+  reject({mode:'native',root_id:'core',executable:'x.exe'});
+  reject({mode:'superuser',root_id:'core',command:'x'});
+  reject({root_id:'core',command_id:'powershell_script',script_path:'scripts/check.ps1',script_sha256:'bad'});
+});

package/test/controller-policy-preflight-r59.test.mjs

@@ -26,6 +26,7 @@ test('R59 controller refuses to arm process or coding policy with a missing root
     const source=await readFile(controllerPath,'utf8');
     const blocks=[functionBlock(source,'Assert-PolicyRootsAvailable','Get-HostPolicyMetadata'),
       functionBlock(source,'Get-ProcessPolicyMetadata','Get-ProcessGrantStatus'),
+      functionBlock(source,'Read-ControllerPolicySnapshot','Get-CodingPolicyMetadata'),
       functionBlock(source,'Get-CodingPolicyMetadata','Get-CodingLeaseStatus')].join('\n');
     const script=`$ErrorActionPreference='Stop';$RuntimeDir=${quote(runtime)};function Fail([string]$m){throw $m};function Get-ExecutableHash($p){return '${'a'.repeat(64)}'};${blocks};`+
       `$errors=@();foreach($case in @(@{kind='process';cfg=@{ProcessPolicyFile=${quote(processPolicy)}}},@{kind='coding';cfg=@{CodingPolicyFile=${quote(coding)}}})){try{if($case.kind -eq 'process'){Get-ProcessPolicyMetadata $case.cfg|Out-Null}else{Get-CodingPolicyMetadata $case.cfg|Out-Null};throw 'unexpected pass'}catch{$errors+=$_.Exception.Message}};$errors|ConvertTo-Json -Compress`;

package/test/deferred-slot-operation-behavior.test.mjs

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'node:url';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 test('R33 deferred worker survives scheduler exit and stays bound to explicit state root',
-  { skip: process.platform !== 'win32', timeout:15000 }, async()=>{
+  { skip: process.platform !== 'win32', timeout:30000 }, async()=>{
     const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-deferred-'));
     try {
       const child=spawn(process.execPath,['scripts/deferred-slot-operation.mjs','activate','0'.repeat(64)],{
@@ -22,7 +22,7 @@ test('R33 deferred worker survives scheduler exit and stays bound to explicit st
       assert.equal(scheduled.status,'scheduled');
       assert.ok(path.resolve(scheduled.state_path).startsWith(path.resolve(state)+path.sep));
       let record;
-      for(let i=0;i<30;i++){
+      for(let i=0;i<60;i++){
         await sleep(300);
         record=JSON.parse(await readFile(scheduled.state_path,'utf8'));
         if(record.state==='failed'||record.state==='passed') break;

package/test/native-diff-topology-r36.test.mjs

@@ -18,9 +18,9 @@ async function fixture(){
   await mkdir(project); await mkdir(trust);
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   const codingPath=path.join(root,'coding-policy.json');
-  await writeFile(codingPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(root,'coding-lease.json'),evidence_dir:path.join(root,'coding-evidence'),roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:[]}},commands:{},max_read_bytes:524288,max_write_bytes:2097152}));
+  await writeFile(codingPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(root,'coding-lease.json'),evidence_dir:path.join(root,'coding-evidence'),roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:[]},preview:{path:project,read:true,write:false,exec:false,deny_paths:[]}},commands:{},max_read_bytes:524288,max_write_bytes:2097152}));
   const codingPolicy=await loadCodingPolicy(codingPath);
-  await writeFile(codingPolicy.lease_file,JSON.stringify({schema:'deadbyte.coding-lease.v1',policy_sha256:codingPolicy.policy_sha256,instance_nonce:randomBytes(32).toString('hex'),root_ids:['project'],armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+3600000).toISOString()}));
+  await writeFile(codingPolicy.lease_file,JSON.stringify({schema:'deadbyte.coding-lease.v1',policy_sha256:codingPolicy.policy_sha256,instance_nonce:randomBytes(32).toString('hex'),root_ids:['project','preview'],armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+3600000).toISOString()}));
   const autoPath=path.join(root,'autonomous-policy.json');
   await writeFile(autoPath,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,lease_file:path.join(root,'auto-lease.json'),evidence_dir:path.join(root,'auto-evidence'),root_ids:['project'],coding_policy_sha256:codingPolicy.policy_sha256,planner:{backend:'client_sampling',max_tokens:2048},profiles:{},limits:{max_files_per_diff:12,max_diff_bytes:1048576}}));
   const policy=await loadAutonomousPolicy(autoPath,codingPolicy);
@@ -31,6 +31,39 @@ async function fixture(){
   return {root,project,keys,policy,codingRuntime,machineFsRuntime,nativeDiff};
 }
 
+test('R71 Native Diff V2 Coding-only topology preview is non-applicable',async()=>{
+  const f=await fixture();
+  try{
+    const preview=await f.nativeDiff.preview({rootId:'preview',title:'read-only topology',operations:[
+      {kind:'mkdir',path:'candidate/newdir'}
+    ]});
+    assert.equal(preview.status,'preview_only');
+    assert.equal(preview.schema,NATIVE_DIFF_V2_SCHEMA);
+    assert.equal(preview.diff_id,undefined);
+    assert.equal(preview.root_id,'preview');
+    assert.equal(preview.operation_count,1);
+    assert.equal(await exists(path.join(f.project,'candidate')),false);
+    assert.equal(await exists(path.join(f.policy.evidence_dir,'native-diffs')),false);
+    await assert.rejects(f.nativeDiff.apply({diffId:'0'.repeat(64)}));
+    await rm(f.codingRuntime.policy.lease_file);
+    await assert.rejects(f.nativeDiff.preview({rootId:'preview',operations:[
+      {kind:'mkdir',path:'after-revoke'}
+    ]}),/coding plane is disarmed/);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('V2 topology preview on an Autonomous root remains non-applicable after Autonomous revocation',async()=>{
+  const f=await fixture();
+  try{
+    await rm(f.policy.lease_file);
+    const preview=await f.nativeDiff.preview({rootId:'project',operations:[{kind:'mkdir',path:'still-read-only'}]});
+    assert.equal(preview.status,'preview_only');
+    assert.equal(preview.diff_id,undefined);
+    assert.equal(await exists(path.join(f.project,'still-read-only')),false);
+    assert.equal(await exists(path.join(f.policy.evidence_dir,'native-diffs')),false);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
 test('R36 Native Diff V2 commits mkdir write move and independently verifies mixed receipts',async()=>{
   const f=await fixture(); try{
     await writeFile(path.join(f.project,'seed.txt'),'seed\n');

package/test/native-diff.test.mjs

@@ -1,13 +1,14 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createHash, randomBytes } from 'node:crypto';
-import { access, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { access, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
 import { createCodingRuntime, loadCodingPolicy } from '../src/coding-plane.mjs';
 import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
 import { createNativeDiffRuntime } from '../src/native-diff.mjs';
+import { registerAutonomousTools } from '../src/autonomous-mcp-tools.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 const exists = file => access(file).then(() => true, () => false);
@@ -19,10 +20,11 @@ async function fixture() {
   const codingPolicyPath = path.join(root, 'coding-policy.json');
   await writeFile(codingPolicyPath, JSON.stringify({ schema:'deadbyte.coding-policy.v1', enabled:true,
     lease_file:path.join(root,'coding-lease.json'), evidence_dir:path.join(root,'coding-evidence'),
-    roots:{ project:{ path:project, read:true, write:true, exec:true, deny_paths:[] } }, commands:{} }, null, 2));
+    roots:{ project:{ path:project, read:true, write:true, exec:true, deny_paths:[] },
+      preview:{ path:project, read:true, write:false, exec:false, deny_paths:[] } }, commands:{} }, null, 2));
   const codingPolicy = await loadCodingPolicy(codingPolicyPath);
   await writeFile(codingPolicy.lease_file, JSON.stringify({ schema:'deadbyte.coding-lease.v1', policy_sha256:codingPolicy.policy_sha256,
-    instance_nonce:randomBytes(32).toString('hex'), root_ids:['project'], armed_at_utc:new Date().toISOString(),
+    instance_nonce:randomBytes(32).toString('hex'), root_ids:['project','preview'], armed_at_utc:new Date().toISOString(),
     expires_at_utc:new Date(Date.now()+3600000).toISOString() }));
   const autonomousPolicyPath = path.join(root, 'autonomous-policy.json');
   await writeFile(autonomousPolicyPath, JSON.stringify({ schema:'deadbyte.autonomous-policy.v1', enabled:true,
@@ -38,6 +40,84 @@ async function fixture() {
   return { root, project, keys, policy, codingRuntime, nativeDiff };
 }
 
+test('R71 Coding-only native_diff_preview does not create an applicable signed diff',async()=>{
+  const f=await fixture();
+  try{
+    const file=path.join(f.project,'only-preview.txt');
+    await writeFile(file,'original text\n');
+    const before=sha(await readFile(file));
+    const preview=await f.nativeDiff.preview({rootId:'preview',title:'read-only project preview',operations:[
+      {kind:'replace',path:'only-preview.txt',expected_sha256:before,old_string:'original',new_string:'updated',expected_replacements:1}
+    ]});
+    assert.equal(preview.status,'preview_only');
+    assert.equal(preview.diff_id,undefined);
+    assert.equal(preview.root_id,'preview');
+    assert.equal(preview.operation_count,1);
+    assert.equal((await readFile(file,'utf8')),'original text\n');
+    assert.equal(await exists(path.join(f.policy.evidence_dir,'native-diffs')),false);
+    await assert.rejects(f.nativeDiff.apply({diffId:'0'.repeat(64)}));
+    await assert.rejects(f.nativeDiff.preview({rootId:'ungranted',operations:[
+      {kind:'write',path:'not-allowed.txt',content:'abc',expected_sha256:'absent'}
+    ]}),/not allowed|disarmed|denied|root/);
+    await rm(f.codingRuntime.policy.lease_file);
+    await assert.rejects(f.nativeDiff.preview({rootId:'preview',operations:[
+      {kind:'replace',path:'only-preview.txt',expected_sha256:before,old_string:'original',new_string:'updated'}
+    ]}),/coding plane is disarmed/);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('MCP preview on an Autonomous-policy root remains read-only with only Coding authority',async()=>{
+  const f=await fixture();
+  try{
+    const file=path.join(f.project,'mcp-preview.txt');
+    await writeFile(file,'old\n');
+    const before=sha(await readFile(file));
+    await rm(f.policy.lease_file);
+    const handlers=new Map();
+    const contracts=new Map();
+    registerAutonomousTools({registerTool:(name,contract,handler)=>{handlers.set(name,handler);contracts.set(name,contract);}},
+      {autonomousRuntime:{},nativeDiffRuntime:f.nativeDiff});
+    assert.match(contracts.get('native_diff_preview').description,/Coding read authority/i);
+    assert.match(contracts.get('native_diff_preview').description,/preview.only/i);
+    const response=await handlers.get('native_diff_preview')({root_id:'project',title:'read only',operations:[
+      {kind:'replace',path:'mcp-preview.txt',expected_sha256:before,old_string:'old',new_string:'new',expected_replacements:1}
+    ]});
+    assert.equal(response.isError,false);
+    assert.equal(response.structuredContent.status,'preview_only');
+    assert.equal(response.structuredContent.diff_id,undefined);
+    assert.equal(sha(await readFile(file)),before);
+    assert.equal(await exists(path.join(f.policy.evidence_dir,'native-diffs')),false);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('Coding-only preview denies escaped, reparse, and expired authority without changing targets',async()=>{
+  const f=await fixture();
+  try{
+    await rm(f.policy.lease_file);
+    const outside=path.join(f.root,'outside.txt');
+    await writeFile(outside,'outside\n');
+    const outsideSha=sha(await readFile(outside));
+    await assert.rejects(f.nativeDiff.preview({rootId:'project',operations:[
+      {kind:'replace',path:'../outside.txt',expected_sha256:outsideSha,old_string:'outside',new_string:'changed'}
+    ]}),/path|escape|outside|relative/i);
+    const link=path.join(f.project,'linked');
+    const target=path.join(f.root,'external');
+    await mkdir(target);
+    await writeFile(path.join(target,'target.txt'),'outside\n');
+    await symlink(target,link,process.platform==='win32'?'junction':'dir');
+    await assert.rejects(f.nativeDiff.preview({rootId:'project',operations:[
+      {kind:'replace',path:'linked/target.txt',expected_sha256:outsideSha,old_string:'outside',new_string:'changed'}
+    ]}),/reparse|symlink|path|outside|root/i);
+    const lease=JSON.parse(await readFile(f.codingRuntime.policy.lease_file,'utf8'));
+    await writeFile(f.codingRuntime.policy.lease_file,JSON.stringify({...lease,expires_at_utc:new Date(Date.now()-1000).toISOString()}));
+    await assert.rejects(f.nativeDiff.preview({rootId:'project',operations:[
+      {kind:'write',path:'new.txt',content:'new',expected_sha256:'absent'}
+    ]}),/coding plane is disarmed: expired/);
+    assert.equal(sha(await readFile(outside)),outsideSha);
+    assert.equal(sha(await readFile(path.join(target,'target.txt'))),outsideSha);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
 test('native diff commits exact preconditioned edits and independently verifies coding receipts', async () => {
   const f = await fixture();
   try {

package/test/r58-cleanup-retention.test.mjs

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
 
-test('R58 foreground cleanup failure retains ownership evidence for recovery', {timeout:30000}, async () => {
+test('R58 foreground cleanup failure retains ownership evidence for recovery', {timeout:60000}, async () => {
   const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
   await mkdir(base,{recursive:true});
   const root=await mkdtemp(path.join(base,'cleanup-'));
@@ -29,12 +29,12 @@ switch ($Command) {
 }
 exit 0
 `);
-  const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+  const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote','--operator'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
   let stdout='',stderr='';
   child.stdout.on('data',b=>{stdout+=b;});child.stderr.on('data',b=>{stderr+=b;});
   const closed=new Promise(resolve=>child.once('close',code=>resolve(code)));
   try {
-    const deadline=Date.now()+12000;
+    const deadline=Date.now()+50000;
     while(!stdout.includes('[READY]')&&child.exitCode===null&&Date.now()<deadline) await delay(50);
     assert.match(stdout,/\[READY\]/,stderr);
     assert.match(stdout,/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/,stderr);

package/test/r58-concurrent-recovery.test.mjs

@@ -6,7 +6,7 @@ import {fileURLToPath} from 'node:url';
 import {spawn} from 'node:child_process';
 import {setTimeout as delay} from 'node:timers/promises';
 
-test('R58 simultaneous stale recovery cannot both revoke the shared authority', {timeout:25000},async()=>{
+test('R58 simultaneous stale recovery cannot both revoke the shared authority', {timeout:90000},async()=>{
  const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
  const root=await mkdtemp(path.join(base,'concurrent-recovery-'));await mkdir(path.join(root,'bin'));await mkdir(path.join(root,'runtime'));
  const trace=path.join(root,'trace.txt'),markerPath=path.join(root,'runtime','remote-session.json');
@@ -47,14 +47,14 @@ exit 0
    const c=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},stdio:['pipe','pipe','pipe'],windowsHide:true});
    const o={stdout:'',stderr:''};c.stdout.on('data',b=>{o.stdout+=b;});c.stderr.on('data',b=>{o.stderr+=b;});o.exit=new Promise(resolve=>c.once('exit',resolve));children.push(c);outputs.push(o);
   }
-  const until=Date.now()+12000;let commands=[];
+  const until=Date.now()+45000;let commands=[];
   while(Date.now()<until){try{commands=(await readFile(trace,'utf8')).trim().split(/\r?\n/);}catch{}if(outputs.some(o=>o.stdout.includes('[READY]')))break;await delay(50);}
   await writeFile(path.join(root,'observation.json'),JSON.stringify({commands,outputs:outputs.map(o=>({stdout:o.stdout,stderr:o.stderr})),simulation:'concurrent stale marker recovery with delayed second park'}),{flag:'wx'});
   assert.ok(outputs.some(o=>o.stdout.includes('[READY]')),'a recovered foreground must become ready');
   for(const cmd of ['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost'])assert.equal(commands.filter(x=>x===cmd).length,1,`stale recovery must serialize ${cmd}`);
  }finally{
   for(const c of children)if(c.exitCode===null)c.stdin.end();
-  await Promise.race([Promise.all(outputs.map(o=>o.exit)),delay(7000)]);
+  await Promise.race([Promise.all(outputs.map(o=>o.exit)),delay(30000)]);
   for(const c of children)if(c.exitCode===null&&c.signalCode===null)c.kill();
  }
 });

package/test/r58-stale-owner.test.mjs

@@ -46,7 +46,7 @@ test('R58 live unrelated PID is not accepted as a remote foreground owner', {tim
  assert.notEqual(code,0);
 });
 
-test('R58 bound stale birth identity reconciles on the first invocation without killing a reused PID', {timeout:20000}, async()=>{
+test('R58 bound stale birth identity reconciles on the first invocation without killing a reused PID', {timeout:60000}, async()=>{
  const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
  await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'stale-birth-'));
  await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));

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

@@ -71,7 +71,7 @@ async function captureCurrentSurface(){
   }
 }
 
-test('R59 compact baseline changes only at the explicitly authorized R64 read-offset bound',async()=>{
+test('R72 compact baseline permits only R64 read offset and authorized coding-only preview output',async()=>{
   const raw=JSON.parse(await readFile(fixturePath,'utf8'));
   assert.equal(raw.schema,'deadbyte.tool-surface-baseline.v1');
   assert.equal(raw.release_id,'v0.15.35-1b5715b276facbc0');
@@ -83,13 +83,17 @@ test('R59 compact baseline changes only at the explicitly authorized R64 read-of
   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'].includes(packageVersion)){
-    assert.deepEqual(diff.schema_changed,['machine_fs']);
-    assert.equal(diff.unchanged.length,42);
+  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46'].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');
     const present=current.tools.find(tool=>tool.name==='machine_fs');
-    assert.equal(present.output_sha256,prior.output_sha256,'output contract must remain unchanged');
+    assert.equal(present.output_sha256,prior.output_sha256,'machine_fs output contract must remain unchanged');
     assert.notEqual(present.input_sha256,prior.input_sha256,'R64 must expose the widened read offset');
+    const previewBefore=baseline.tools.find(tool=>tool.name==='native_diff_preview');
+    const previewAfter=current.tools.find(tool=>tool.name==='native_diff_preview');
+    assert.equal(previewAfter.input_sha256,previewBefore.input_sha256,'preview-only must not change input permissions or tool selection');
+    assert.notEqual(previewAfter.output_sha256,previewBefore.output_sha256,'preview-only output must be declared in MCP schema');
   }else{
     assert.deepEqual(diff.schema_changed,[]);
     assert.equal(diff.unchanged.length,43);

package/test/r60-authority-coherence.test.mjs

@@ -10,7 +10,8 @@ const observed = (armed={}) => ({
 });
 
 test('remote modes have exact non-widening authority vectors',()=>{
-  assert.deepEqual(authorityVector('default'),{process:true,coding:true,autonomous:true,desktop:false,host:false});
+  assert.deepEqual(authorityVector('default'),{process:false,coding:false,autonomous:false,desktop:false,host:false});
+  assert.deepEqual(authorityVector('operator'),{process:true,coding:true,autonomous:true,desktop:false,host:false});
   assert.deepEqual(authorityVector('desktop'),{process:true,coding:true,autonomous:true,desktop:true,host:false});
   assert.deepEqual(authorityVector('host'),{process:true,coding:true,autonomous:true,desktop:false,host:true});
   assert.deepEqual(authorityVector('full'),{process:true,coding:true,autonomous:true,desktop:true,host:true});
@@ -18,7 +19,7 @@ test('remote modes have exact non-widening authority vectors',()=>{
 
 test('observed standing Host grant rejects bounded READY',()=>{
   const snapshot=parseAuthorityObservation(JSON.stringify(observed({process:true,coding:true,autonomous:true,host:true})));
-  assert.throws(()=>assertAuthorityVector(snapshot,authorityVector('default')),/host.*expected DISARMED/);
+  assert.throws(()=>assertAuthorityVector(snapshot,authorityVector('operator')),/host.*expected DISARMED/);
 });
 
 test('malformed or incomplete controller observation fails closed',()=>{
@@ -34,3 +35,10 @@ test('readiness requires verified Bridge Core Cloud and local MCP, not just ONLI
   assert.throws(()=>assertRuntimeReadyObservation({...value,core:{alive:false,reason:'wrong-core-generation'}}),/core/);
   assert.throws(()=>assertRuntimeReadyObservation({...value,core_root:'D:\\wrong'} ,{coreRoot:'D:\\exact-release'}),/core root/);
 });
+
+test('safe default rejects a pre-existing grant in any plane, not only Host',()=>{
+  for(const plane of ['process','coding','autonomous','desktop','host']){
+    const snapshot=parseAuthorityObservation(JSON.stringify(observed({[plane]:true})));
+    assert.throws(()=>assertAuthorityVector(snapshot,authorityVector('default')),new RegExp(`${plane}.*expected DISARMED`));
+  }
+});

package/test/r65-authority-runtime-epoch.test.mjs

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {mkdtemp,mkdir,rm,writeFile,readFile} from 'node:fs/promises';
-import {createHash} from 'node:crypto';
+import {createHash,generateKeyPairSync} from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
 import {loadCodingPolicy,codingSessionStatus} from '../src/coding-plane.mjs';
@@ -37,6 +37,14 @@ test('R65 standing Coding grant is disarmed until the durable epoch binds the ex
     assert.equal(trusted.armed,true);
     assert.equal(trusted.reason,'standing-grant');
     assert.equal(trusted.instance_nonce,grant.instance_nonce);
+    const publicPath=path.join(root,'trust','ed25519-public.pem');
+    const originalPublic=await readFile(publicPath);
+    const rotated=generateKeyPairSync('ed25519').publicKey.export({format:'pem',type:'spki'});
+    await writeFile(publicPath,rotated);
+    const denied=await codingSessionStatus(policy);
+    assert.equal(denied.armed,false,'changed trust bytes must not reuse the cached parsed key');
+    await writeFile(publicPath,originalPublic);
+    assert.equal((await codingSessionStatus(policy)).armed,true);
   }finally{
     await rm(root,{recursive:true,force:true});
   }

package/test/r67-isolated-slot-rollback-restore.test.mjs

@@ -22,7 +22,8 @@ async function generation(state,label){
   return {root,manifest_sha256:sha(manifest),config_path:path.join(root,'controller-config.psd1')};
 }
 
-test('R67 isolated immutable slot activates, rolls back exact R66, and restores the same R67 bytes with no authority',async()=>{
+const historicalR67=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8')).version==='0.15.44';
+test('R67 isolated immutable slot activates, rolls back exact R66, and restores the same R67 bytes with no authority',{skip:historicalR67?false:'Historical R67 regression applies only to package version 0.15.44; R71 test is separate'},async()=>{
   const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r67-slot-parity-'));
   const state=path.join(base,'state');
   try{

package/test/r67-npm-publish-gate.test.mjs

@@ -3,10 +3,12 @@ import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import {fileURLToPath} from 'node:url';
 import path from 'node:path';
+import os from 'node:os';
 import {assertR67NpmPublishReady} from '../scripts/npm-release-readiness-r67.mjs';
 const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-test('R67 current sealed prepublish candidate satisfies the exact publish-readiness metadata gate',async()=>{
- const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+test('sealed R67 predecessor retains its exact npm publish-readiness metadata gate',async()=>{
+ const sealed=path.join(os.homedir(),'.deadbyte-mcp','releases','v0.15.44-9f500af433df3e77');
+ const release=JSON.parse(await readFile(path.join(sealed,'RELEASE.json'),'utf8'));
  assert.equal(release.r67_native_observation.status,'CANDIDATE_SEALED');
  assert.doesNotThrow(()=>assertR67NpmPublishReady(release));
 });

package/test/r67-release-contract.test.mjs

@@ -1,21 +1,22 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
-const get=async rel=>JSON.parse(await readFile(new URL('../'+rel,import.meta.url),'utf8'));
+import os from 'node:os';
+import path from 'node:path';
+const sealedRoot=path.join(os.homedir(),'.deadbyte-mcp','releases','v0.15.44-9f500af433df3e77');
+const get=async rel=>JSON.parse(await readFile(path.join(sealedRoot,rel),'utf8'));
 const parent={
  release_id:'v0.15.43-4c4a64a4c8e9f5a6',
  manifest_sha256:'4c4a64a4c8e9f5a6e9eecce85fd0007ebcac99121b29c07f1a1fc81d1643cd33',
  generation_manifest_sha256:'ef3b041e2a87c2e143d4733a98a52d9db80cd16ad7007e112fcb5202e70c77c3'
 };
-test('R67 release version, predecessor evidence, and observed prepublish seal are exact',async()=>{
- const [pkg,lock,bridge,release,prov,matrix,sbom,version]=await Promise.all([
-  get('package.json'),get('package-lock.json'),get('bridge/package.json'),
+test('sealed R67 predecessor preserves its release version, lineage and prepublish evidence',async()=>{
+ const [pkg,bridge,release,prov,matrix,sbom,version]=await Promise.all([
+  get('package.json'),get('bridge/package.json'),
   get('RELEASE.json'),get('PROVENANCE.json'),get('TEST-MATRIX.json'),get('SBOM.cdx.json'),
-  readFile(new URL('../src/version.mjs',import.meta.url),'utf8')
+  readFile(path.join(sealedRoot,'src','version.mjs'),'utf8')
  ]);
  assert.equal(pkg.version,'0.15.44');
- assert.equal(lock.version,pkg.version);
- assert.equal(lock.packages[''].version,pkg.version);
  assert.equal(bridge.version,pkg.version);
  assert.match(version,/DEADBYTE_VERSION = '0\.15\.44'/);
  assert.equal(release.version,pkg.version);