deadbyte-mcp 0.15.44 → 0.15.45

package/src/tool-audit.mjs

@@ -116,11 +116,13 @@ function summarizeOutcome(result,error,durationMs){
   const structured=result?.structuredContent;
   const status=typeof structured?.status==='string'?structured.status:(result?.isError===true?'error':'ok');
   const isError=result?.isError===true;
+  const unknownSideEffect=structured?.side_effect_state==='unknown'||structured?.result?.side_effect_state==='unknown';
   const capability=structured?.result;
   const snapshot=capability?.schema==='deadbyte.capability-manifest.v3'&&HEX64.test(String(capability.snapshot_id??''))&&
     Number.isInteger(capability.state_epoch)&&capability.state_epoch>0
     ?{snapshot_id:capability.snapshot_id,state_epoch:capability.state_epoch}:{};
   return {status:String(status).slice(0,128),is_error:isError,duration_ms:duration,receipt_sha256s:outcomeReceiptHashes(result),
+    ...(unknownSideEffect?{side_effect_state:'unknown'}:{}),
     ...snapshot,
     ...(isError?{reason:resultOutcomeReason(result)}:{})};
 }

package/src/version.mjs

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

package/test/autonomous-local-supervisor.test.mjs

@@ -53,7 +53,8 @@ async function createProviderHostFixture(){
     planner:{backend:'openai_compatible',endpoint:`http://127.0.0.1:${planner.address().port}/v1/chat/completions`,model:'r34-host-test',max_tokens:2048,timeout_ms:30000,max_response_bytes:262144},
     limits:{max_iterations:8,max_mutations:8,max_wall_ms:null,max_context_bytes:262144,max_diff_bytes:262144,max_files_per_diff:4},profiles:{}}));
   const autonomousPolicy=await loadAutonomousPolicy(autonomousPath,codingPolicy);
-  await writeBoundStandingGrant('autonomous', autonomousPolicy.lease_file, {schema:'deadbyte.autonomous-grant.v2',policy_sha256:autonomousPolicy.policy_sha256,
+  await writeBoundStandingGrant('autonomous', autonomousPolicy.lease_file, {schema:'deadbyte.autonomous-grant.v2',policy_sha256:autonomousPolicy.policy_sha256,
+    coding_policy_sha256:codingPolicy.policy_sha256,
     instance_nonce:nonce(),root_ids:['project'],granted_at_utc:new Date().toISOString()});
   const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   const nativeDiffRuntime=createNativeDiffRuntime({policy:autonomousPolicy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});

package/test/autonomous-output-contract.test.mjs

@@ -2,10 +2,26 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
   autonomousGoalApproveOutputSchema, autonomousGoalRunOutputSchema, autonomousGoalStatusOutputSchema,
-  autonomousGoalVerifyOutputSchema,
+  autonomousGoalVerifyOutputSchema, nativeDiffPreviewOutputSchema,
   autonomousStructuredResult
 } from '../src/autonomous-output-contracts.mjs';
 
+test('R71 preview-only MCP output cannot masquerade as a signed ready-to-apply diff',()=>{
+  const base={root_id:'preview',operation_count:1,payload_bytes:0,paths:['a.txt'],
+    operations:[{kind:'delete',path:'a.txt',expected_sha256:'a'.repeat(64)}]};
+  const unsigned=autonomousStructuredResult(nativeDiffPreviewOutputSchema,{
+    status:'preview_only',schema:'deadbyte.native-diff.v1',...base
+  });
+  assert.equal(unsigned.structuredContent.status,'preview_only');
+  assert.equal(unsigned.structuredContent.diff_id,undefined);
+  assert.throws(()=>autonomousStructuredResult(nativeDiffPreviewOutputSchema,{
+    status:'preview_only',diff_id:'b'.repeat(64),...base
+  }),/autonomous output contract violation/);
+  assert.throws(()=>autonomousStructuredResult(nativeDiffPreviewOutputSchema,{
+    status:'ready',...base
+  }),/autonomous output contract violation/);
+});
+
 test('autonomous_goal_verify structured contract preserves delegated action evidence count', () => {
   const value = {
     ok:true,

package/test/autonomous-supervisor-integration.test.mjs

@@ -73,7 +73,8 @@ async function startPlanner() {
   }));
   const autonomousSha = sha(await readFile(autonomousPath));
   await writeBoundStandingGrant('autonomous', path.join(root, 'runtime', 'autonomous-grant.json'), {
-    schema:'deadbyte.autonomous-grant.v2', policy_sha256:autonomousSha,
+    schema:'deadbyte.autonomous-grant.v2', policy_sha256:autonomousSha,
+    coding_policy_sha256:codingSha,
     instance_nonce:nonce(), root_ids:['project'], granted_at_utc:new Date().toISOString()
   });
   const client = new Client({ name:'deadbyte-supervisor-integration', version:'0.8.0' },

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/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/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('R71 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'].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/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);

package/test/r69-live-outcome.test.mjs

@@ -0,0 +1,137 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import {classifyRemoteAuditOutcome,createLiveTimelineTracker,createLiveTimelineFilter,createLiveTimelineWriter,formatCompactAuditEvent} from '../src/remote-live-log.mjs';
+
+function pair(status,is_error=false,side_effect_state=null){
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii',rootPaths:{local_d:'D:\\'}});
+  const args={root_id:'local_d',path:'TECHNICAL/ProgramingLangPJ/tmp/gfx_r3_dev/runtime/gfx/dbyte_gfx3d.dby'};
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-example-1',args});
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'r69-example-1',
+    outcome:{status,is_error,side_effect_state,duration_ms:1}});
+  return {tracker,start,done};
+}
+
+test('R69 failed, denied and observed_failure never produce a false SUCCEEDED line',()=>{
+  for(const status of ['failed','denied','rejected','blocked','observed_failure','cancelled']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/ERR  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED|\bOK\b/,status);
+    assert.match(tracker.summary(),/0 ok \| 1 error/,status);
+  }
+});
+
+test('R69 unavailable and unsupported result envelopes never print mutation SUCCEEDED',()=>{
+  for(const status of ['unavailable','unsupported']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/ERR  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED/,status);
+    assert.match(tracker.summary(),/0 ok \| 1 error/,status);
+  }
+});
+
+test('R69 pending tool result requires continuation, never implies effect committed',()=>{
+  for(const status of ['pending','running','input_required','paused','processing','accepted']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/PENDING  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED|\bOK\b/,status);
+    assert.match(tracker.summary(),/0 ok \| 0 errors \| 0 unknown \| 1 pending/,status);
+  }
+});
+
+test('R69 unknown side-effect outranks every status; no retry claim',()=>{
+  const {done,tracker}=pair('committed',false,'unknown');
+  assert.match(done,/FAILED_AFTER_UNKNOWN_EFFECT/);
+  assert.match(tracker.summary(),/1 unknown/);
+});
+
+test('R69 human console always retains the operation location in terminal result',()=>{
+  const {start,done}=pair('denied');
+  const absolute='D:\\TECHNICAL\\ProgramingLangPJ\\tmp\\gfx_r3_dev\\runtime\\gfx\\dbyte_gfx3d.dby [root=local_d]';
+  assert.ok(start.includes(absolute));
+  assert.ok(done.includes(absolute));
+  assert.match(done,/ERR  status=denied/);
+  assert.doesNotMatch(done,/SUCCEEDED/);
+});
+
+test('R69 compact audit flags status failure or pending even with is_error=false',()=>{
+  assert.match(formatCompactAuditEvent({event_type:'tool.result',tool:'host_exec',outcome:{is_error:false,status:'denied'}}),/ERR/);
+  assert.match(formatCompactAuditEvent({event_type:'tool.result',tool:'host_exec',outcome:{is_error:false,status:'input_required'}}),/PENDING/);
+});
+
+test('R69 TTY writer obeys runtime terminal resize without rewriting a wrapped start line',()=>{
+  const writes=[];
+  const stream={isTTY:true,columns:32,write(value){writes.push(value);return true;}};
+  const writer=createLiveTimelineWriter({stream,displayMode:'ascii'});
+  writer.write('START',{event_type:'tool.call',request_id:'resize'});
+  stream.columns=5;
+  writer.write('TOO LONG RESULT',{event_type:'tool.result',request_id:'resize'});
+  assert.deepEqual(writes,['START','\n','TOO LONG RESULT\n']);
+  assert.equal(writer.pending(),null);
+  stream.columns=80;
+  writer.write('RUN',{event_type:'tool.call',request_id:'wide'});
+  writer.write('OK',{event_type:'tool.result',request_id:'wide'});
+  assert.equal(writes.at(-1),'\r\x1b[2KOK\n');
+});
+
+
+test('R69 live latency uses fractional milliseconds instead of printing a false 0ms',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:'subms'});
+  const done=tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:'subms',
+    outcome:{is_error:false,duration_ms:0.125}});
+  assert.ok(done.includes('0.125ms'));
+  assert.doesNotMatch(done,/ 0ms /);
+});
+
+test('R69 latency summary includes p99 and discloses bounded sample coverage',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  for(let i=1;i<=100;i++){
+    const id='sample-'+i;
+    tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:id});
+    tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:id,
+      outcome:{is_error:false,duration_ms:i}});
+  }
+  const summary=tracker.summary();
+  assert.ok(summary.includes('p50 51ms'));
+  assert.ok(summary.includes('p95 95ms'));
+  assert.ok(summary.includes('p99 99ms'));
+  assert.ok(summary.includes('sample 100/100'));
+});
+
+test('R69 filter matches status-only errors independent of is_error=false',()=>{
+  const filter=createLiveTimelineFilter('status=error');
+  filter.accept({event_type:'tool.request',tool:'host_exec',request_id:'r69-e',args:{}});
+  assert.equal(filter.accept({event_type:'tool.result',tool:'host_exec',request_id:'r69-e',outcome:{status:'denied',is_error:false}}),true);
+});
+
+test('R69 mismatched terminal tool cannot inherit a mutating START or claim success',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-mismatch',args:{root_id:'core',path:'scratch.txt'}});
+  assert.match(start,/START/);
+  const terminal=tracker.observe({event_type:'tool.result',tool:'machine_ping',request_id:'r69-mismatch',
+    outcome:{status:'ok',is_error:false,duration_ms:1,receipt_sha256s:['a'.repeat(64)]}});
+  assert.match(terminal,/CORRELATION_MISMATCH/);
+  assert.doesNotMatch(terminal,/SUCCEEDED|RECEIPT=/);
+  assert.match(tracker.summary(),/0 ok \| 0 errors \| 1 unknown/);
+});
+
+test('R69 status filter cannot hide a mismatched terminal identity as successful',()=>{
+  const unknown=createLiveTimelineFilter('status=unknown');
+  unknown.accept({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-filter-mismatch',args:{}});
+  assert.equal(unknown.accept({event_type:'tool.result',tool:'machine_ping',request_id:'r69-filter-mismatch',
+    outcome:{status:'ok',is_error:false}}),true);
+});
+
+test('R69 remote replay projection does not record unavailable as ok or input_required as complete',async()=>{
+  const source=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  const start=source.indexOf('function auditTimelineRecord(');
+  const end=source.indexOf('async function replayRemoteResults(',start);
+  assert.ok(start>=0&&end>start);
+  const record=new Function('createHash','parseAuditLogLine','classifyRemoteAuditOutcome',`${source.slice(start,end)};return auditTimelineRecord;`)(createHash,()=>null,classifyRemoteAuditOutcome);
+  const base={event_type:'tool.result',request_id:'r69-projection',tool:'coding_file_write',ts:'2026-10-13T00:00:00.000Z'};
+  assert.equal(record('audit.log','bounded-line',{...base,outcome:{status:'unavailable',is_error:false}}).status,'error');
+  assert.equal(record('audit.log','bounded-line',{...base,outcome:{status:'input_required',is_error:false}}).status,'pending');
+});
+