deadbyte-mcp 0.15.43 → 0.15.45

package/src/tool-audit.mjs

@@ -21,7 +21,7 @@ const secretExactKeys=new Set([
 ]);
 const secretSuffixes=['_password','_passwd','_secret','_token','_credential','_credentials','_cookie','_cookies','_private_key','_recovery_code','_api_key'];
 const payloadKeys=new Set(['content','file_text','text','body','new_string','old_string','raw_input','raw_text','data_base64']);
-const secretValuePattern=/(?:^|[^a-z])(bearer\s+\S+|(?:api[-_]?key|access[-_]?token|refresh[-_]?token|token|password|secret)\s*[=:]\s*\S+|-----BEGIN [^-]*PRIVATE KEY-----)/i;
+const secretValuePattern=/(?:^|[^a-z])(bearer\s+\S+|(?:api[-_]?key|access[-_]?token|refresh[-_]?token|token|password|secret)\s*[=:]\s*\S+|sk-(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{12,}|github_pat_[A-Za-z0-9_]{12,}|-----BEGIN [^-]*PRIVATE KEY-----)/i;
 const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
 const utf8Bytes=value=>Buffer.from(typeof value==='string'?value:canonicalJson(value),'utf8');
 const byteCount=value=>utf8Bytes(value).length;
@@ -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.43';
+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/agent-runtime.test.mjs

@@ -69,7 +69,7 @@ async function cleanup(f, client) {
   await rm(f.trust, { recursive: true, force: true }).catch(() => {});
 }
 
-test.skip('R44 historical agent catalog contract is frozen; current R47 runtime supersedes its base surface', async () => {
+test('R44 historical agent catalog contract is frozen; current R47 runtime supersedes its base surface',{skip:'Historical R44 13-tool catalog deliberately superseded by R47; not applicable to current release'}, async () => {
   const f = await fixture();
   let client;
   try {

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-loop.test.mjs

@@ -123,7 +123,7 @@ test('R24 autonomous goal diagnoses a failing test, replans with native diff, be
       maxIterations:10 });
     assert.equal(submitted.status,'accepted');
     const result = await f.runtime.run({ goalId:submitted.goal_id, maxCycles:16 });
-    assert.equal(result.status,'completed');
+    assert.equal(result.status,'completed',JSON.stringify({status:result.status,reason:result.reason??null,loop_phase:result.loop?.phase??null}));
     assert.equal(await readFile(f.program,'utf8'),"export const value = 'fixed';\n");
     const status = await f.runtime.status({ goalId:submitted.goal_id });
     assert.equal(status.state,'succeeded');
@@ -154,7 +154,7 @@ test('historical autonomous release verification survives source drift and disar
       title:'repair program', goal:'make exported value equal fixed', acceptance:'release evidence must remain verifiable',
       maxIterations:10 });
     const result = await f.runtime.run({ goalId:submitted.goal_id, maxCycles:16 });
-    assert.equal(result.status,'completed');
+    assert.equal(result.status,'completed',JSON.stringify({status:result.status,reason:result.reason??null,loop_phase:result.loop?.phase??null}));
     assert.equal((await f.runtime.verify({ goalId:submitted.goal_id })).ok,true);
 
     await writeFile(f.program,"export const value = 'rolled-back';\n");
@@ -196,7 +196,7 @@ test('autonomous profile execution is capped by the absolute autonomous lease wi
       title:'deadline-bound profiles',goal:'make exported value equal fixed',
       acceptance:'build, test, and benchmark must pass',maxIterations:10});
     const result=await f.runtime.run({goalId:submitted.goal_id,maxCycles:16});
-    assert.equal(result.status,'completed');
+    assert.equal(result.status,'completed',JSON.stringify({status:result.status,reason:result.reason??null,loop_phase:result.loop?.phase??null}));
     assert.ok(calls.length>=3);
     assert.ok(calls.every(call=>typeof call.deadline==='string'&&Number.isFinite(Date.parse(call.deadline))));
     assert.ok(calls.every(call=>call.has_precheck===true));
@@ -239,7 +239,12 @@ test('autonomous profile nonce rotation immediately before spawn fails closed wi
     const started=journal.events.find(event=>event.type==='profile_started'&&event.payload?.profile_id==='build');
     assert.ok(started);
     assert.match(started.payload.authority_instance_nonce,/^[0-9a-f]{64}$/);
-    assert.ok(journal.events.some(event=>event.type==='goal_paused'&&event.payload?.reason==='profile_execution_without_receipt'));
+    const pause=journal.events.find(event=>event.type==='goal_paused'&&event.payload?.reason==='profile_execution_without_receipt');
+    assert.ok(pause);
+    assert.equal(pause.payload.receipt_id,started.payload.receipt_id);
+    assert.equal(pause.payload.request_sha256,started.payload.request_sha256);
+    assert.equal(typeof pause.payload.detail,'string');
+    assert.ok(pause.payload.detail.length>0&&pause.payload.detail.length<=512);
     assert.equal(journal.events.some(event=>event.type==='profile_completed'&&event.payload?.profile_id==='build'),false);
     assert.equal((await f.codingRuntime.verifyReceiptDetailed(started.payload.receipt_id)).ok,false);
   } finally {
@@ -255,7 +260,7 @@ test('provider planner repairs an invalid structured decision inside the same ru
       title:'repair after planner contract error', goal:'make exported value equal fixed',
       acceptance:'build, test, and benchmark must pass', maxIterations:10 });
     const result = await f.runtime.run({ goalId:submitted.goal_id, maxCycles:16 });
-    assert.equal(result.status,'completed');
+    assert.equal(result.status,'completed',JSON.stringify({status:result.status,reason:result.reason??null,loop_phase:result.loop?.phase??null}));
     assert.equal(await readFile(f.program,'utf8'),"export const value = 'fixed';\n");
     assert.equal(f.planner.prompts.length,6);
     assert.match(f.planner.prompts[1],/PREVIOUS_RESPONSE_REJECTED/);
@@ -337,7 +342,7 @@ test('provider supervisor adopts an OPEN circuit after restart and resumes only
       if(status.state==='cancelled') throw new Error('provider circuit supervisor cancelled goal');
       await new Promise(resolve=>setTimeout(resolve,25));
     } while(Date.now()<deadline);
-    assert.equal(status.state,'succeeded');
+    assert.equal(status.state,'succeeded',JSON.stringify({state:status.state,reason:status.reason??null,loop_phase:status.loop?.phase??null}));
     assert.ok(f.planner.prompts.length>3);
     const journal=await f.runtime.events({goalId:submitted.goal_id,fromSeq:1,limit:200});
     assert.equal(journal.events.filter(event=>event.type==='provider_probe_started').length,1);

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-runtime.test.mjs

@@ -76,7 +76,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test.skip('R44 historical hermetic autonomous catalog is frozen at 50; current R47 runtime supersedes it', async () => {
+test('R44 historical hermetic autonomous catalog is frozen at 50; current R47 runtime supersedes it',{skip:'Historical R44 autonomous catalog frozen at 50; current R47+ has a different catalog'}, async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

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/coding-plane.test.mjs

@@ -70,7 +70,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test.skip('R44 historical hermetic coding catalog is frozen at 38; current R47 runtime supersedes it', async () => {
+test('R44 historical hermetic coding catalog is frozen at 38; current R47 runtime supersedes it',{skip:'Historical R44 coding catalog frozen at 38; current R47+ supersedes it'}, async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

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/full-max-catalog-r46.test.mjs

@@ -15,7 +15,7 @@ const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
 const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
 
-test.skip('R46 historical max-runtime full stdio catalog contract is frozen at 84; current R47 runtime intentionally supersedes it',async()=>{
+test('R46 historical max-runtime full stdio catalog contract is frozen at 84; current R47 runtime intentionally supersedes it',{skip:'Historical R46 max-runtime catalog frozen at 84; current R47+ intentionally supersedes it'},async()=>{
   const f=await createR34Fixture({authority:'disarmed'});
   const processPolicyPath=path.join(f.root,'process-policy.json');
   const processGrant=path.join(f.root,'process-grant.json');

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/output-schema.test.mjs

@@ -48,7 +48,7 @@ async function fixture() {
   return { trust, client, transport };
 }
 
-test.skip('R44 historical base-plus-agent catalog is frozen at 13; current R47 runtime supersedes it', async () => {
+test('R44 historical base-plus-agent catalog is frozen at 13; current R47 runtime supersedes it',{skip:'Historical R44 base-plus-agent catalog frozen at 13; current R47+ supersedes it'}, async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

package/test/r51-live-log-polling.test.mjs

@@ -26,3 +26,15 @@ test('R51 live tail parses each audit line once and reuses the decoded event',as
   assert.match(cli,/auditTimelineRecord\(file,line,auditEvent\)/);
   assert.match(cli,/formatLogLine\(file,line,\{auditEvent,/);
 });
+
+test('R67 live log selection is bounded, deduplicated and rejects path traversal/drive prefixes',()=>{
+ const runtimeNames=['bridge.stdout.log','bridge.stdout.log','../private.log','..\\private.log','C:\\token.log','.hidden.log',
+  ...Array.from({length:180},(_,i)=>'remote-'+String(i).padStart(3,'0')+'.log')];
+ const auditNames=['segment-00000001.jsonl','segment-00000002.jsonl','segment-00000002.jsonl','segment-00000003.jsonl'];
+ const selected=selectLiveLogNames({auditNames,runtimeNames});
+ assert.deepEqual(selected.audit,['segment-00000002.jsonl','segment-00000003.jsonl']);
+ assert.ok(selected.runtime.length<=64,'cap runtime readers to a finite budget');
+ assert.equal(new Set(selected.runtime).size,selected.runtime.length);
+ assert.ok(selected.runtime.every(name=>/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.log$/.test(name)));
+ assert.ok(selected.runtime.includes('remote-179.log'));
+});

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

@@ -6,7 +6,7 @@ const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 const json=rel=>read(rel).then(JSON.parse);
 const currentPackage=await json('package.json');
-const r53test=currentPackage.version==='0.15.30'?test:test.skip;
+const r53test=currentPackage.version==='0.15.30'?test:(name,fn)=>test(name,{skip:'Historical R53 release contract requires 0.15.30; current '+currentPackage.version},fn);
 
 r53test('R53 current release identity is coherent across package lock source metadata SBOM and gate',async()=>{
   const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([

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

@@ -6,7 +6,7 @@ const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 const json=rel=>read(rel).then(JSON.parse);
 const currentPackage=await json('package.json');
-const r54test=currentPackage.version==='0.15.31'?test:test.skip;
+const r54test=currentPackage.version==='0.15.31'?test:(name,fn)=>test(name,{skip:'Historical R54 release contract requires 0.15.31; current '+currentPackage.version},fn);
 
 r54test('R54 release identity is coherent across package lock source metadata SBOM and gate',async()=>{
   const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([

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

@@ -6,7 +6,7 @@ const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 const json=rel=>read(rel).then(JSON.parse);
 const currentPackage=await json('package.json');
-const r55test=currentPackage.version==='0.15.32'?test:test.skip;
+const r55test=currentPackage.version==='0.15.32'?test:(name,fn)=>test(name,{skip:'Historical R55 release contract requires 0.15.32; current '+currentPackage.version},fn);
 
 r55test('R55 release identity is coherent across package lock source metadata SBOM and gate',async()=>{
   const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([

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

@@ -6,7 +6,7 @@ const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 const json=rel=>read(rel).then(JSON.parse);
 const currentPackage=await json('package.json');
-const r56test=currentPackage.version==='0.15.33'?test:test.skip;
+const r56test=currentPackage.version==='0.15.33'?test:(name,fn)=>test(name,{skip:'Historical R56 release contract requires 0.15.33; current '+currentPackage.version},fn);
 
 r56test('R56 release identity is coherent across package lock source metadata SBOM and gate',async()=>{
   const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([

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

@@ -6,7 +6,7 @@ const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 const json=rel=>read(rel).then(JSON.parse);
 const currentPackage=await json('package.json');
-const r57test=currentPackage.version==='0.15.34'?test:test.skip;
+const r57test=currentPackage.version==='0.15.34'?test:(name,fn)=>test(name,{skip:'Historical R57 release contract requires 0.15.34; current '+currentPackage.version},fn);
 
 r57test('R57 release identity is coherent across package lock source metadata SBOM and gate',async()=>{
   const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([

package/test/r58-bundled-bridge.test.mjs

@@ -11,7 +11,7 @@ test('R58 deployment activates the bridge bundled inside the candidate release,
   assert.match(deploy,/const bridgeScript=path\.join\(bridgeRoot,'src','bridge\.mjs'\)/);
 });
 
-test('R58 bundled bridge package is present and version-bound to 0.15.35',{skip:currentPackage.version!=='0.15.35'},async()=>{
+test('R58 bundled bridge package is present and version-bound to 0.15.35',{skip:currentPackage.version!=='0.15.35' ? 'Historical R58 bridge artifact requires 0.15.35; current '+currentPackage.version : false},async()=>{
   const [pkg,bridgePkg,bridge]=await Promise.all([
     readFile(new URL('../package.json',import.meta.url),'utf8').then(JSON.parse),
     readFile(new URL('../bridge/package.json',import.meta.url),'utf8').then(JSON.parse),

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

@@ -6,7 +6,7 @@ const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
 const json=rel=>read(rel).then(JSON.parse);
 const currentPackage=await json('package.json');
 
-test('R58 identity is coherent and parent is exact production-accepted 0.15.34',{skip:currentPackage.version!=='0.15.35'},async()=>{
+test('R58 identity is coherent and parent is exact production-accepted 0.15.34',{skip:currentPackage.version!=='0.15.35' ? 'Historical R58 release contract requires 0.15.35; current '+currentPackage.version : false},async()=>{
   const [pkg,lock,release,prov,matrix,sbom,version,bridgePkg]=await Promise.all([
     json('package.json'),json('package-lock.json'),json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs'),json('bridge/package.json')
   ]);
@@ -29,7 +29,7 @@ test('R58 identity is coherent and parent is exact production-accepted 0.15.34',
   assert.equal(release.parent.tarball_sha256,'a6f7b21faf34793ca17dfb6d0e9ec03320f1468d011e75d8349098df82fc2639');
 });
 
-test('R58 consolidation evidence preserves fail-closed and non-final claims',{skip:currentPackage.version!=='0.15.35'},async()=>{
+test('R58 consolidation evidence preserves fail-closed and non-final claims',{skip:currentPackage.version!=='0.15.35' ? 'Historical R58 release contract requires 0.15.35; current '+currentPackage.version : false},async()=>{
   const [release,prov,matrix]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json')]);
   assert.equal(release.consolidation.bridge_bundled_inside_release,true);
   assert.equal(release.consolidation.bridge_recursive_local_dependency_binding,true);

package/test/r58-windows-gate.test.mjs

@@ -5,7 +5,7 @@ import {readFile} from 'node:fs/promises';
 const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
 const currentPackage=JSON.parse(await read('package.json'));
 
-test('R58 canonical Windows gate is final-candidate bound and leaves historical gates immutable',{skip:currentPackage.version!=='0.15.35'},async()=>{
+test('R58 canonical Windows gate is final-candidate bound and leaves historical gates immutable',{skip:currentPackage.version!=='0.15.35' ? 'Historical R58 Windows gate requires 0.15.35; current '+currentPackage.version : false},async()=>{
   const [pkgText,gate,evidence,r57Gate,r57Evidence]=await Promise.all([
     read('package.json'),read('scripts/gate-windows-r58.ps1'),read('scripts/windows-gate-evidence-r58.mjs'),
     read('scripts/gate-windows-r57.ps1'),read('scripts/windows-gate-evidence-r57.mjs')

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