deadbyte-mcp 0.15.35 → 0.15.37

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

@@ -0,0 +1,90 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+import { snapshotToolsListResult, diffToolSurface } from '../src/tool-surface-ledger.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const fixturePath=path.join(here,'fixtures','r59-compact-surface-v0.15.35.json');
+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;}};
+
+async function captureCurrentSurface(){
+  const f=await createR34Fixture({authority:'disarmed'});
+  const processPolicyPath=path.join(f.root,'process-policy.json');
+  const processGrant=path.join(f.root,'process-grant.json');
+  const processState=path.join(f.root,'process-state');
+  const hostPolicyPath=path.join(f.root,'host-policy.json');
+  const hostArm=path.join(f.root,'host-arm.json');
+  const desktopPolicyPath=path.join(f.root,'desktop-policy.json');
+  const desktopGrant=path.join(f.root,'desktop-grant.json');
+  const nodeSha=sha(await readFile(process.execPath));
+  await mkdir(processState,{recursive:true});
+  await writeFile(processPolicyPath,JSON.stringify({
+    schema:'deadbyte.process-policy.v1',enabled:true,grant_file:processGrant,state_dir:processState,
+    native_host:{path:process.execPath,sha256:nodeSha},roots:{core:{path:f.project,deny_paths:[]}},
+    profiles:{node:{executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],prefix_args:[],
+      transport:'pipe',max_args:8,max_arg_bytes:1024,max_sessions:2,max_input_bytes:65536,
+      max_retained_output_bytes:262144,env_allow:['PATH','TEMP','TMP'],input_actions:{ping:'PING\\r\\n'}}}
+  },null,2));
+  await writeFile(hostPolicyPath,JSON.stringify({
+    schema:'deadbyte.host-policy.v1',enabled:true,arm_file:hostArm,max_read_bytes:262144,max_write_bytes:1048576,
+    roots:{core:{path:f.project,read:true,write:true,exec:true}},commands:{node_script:{kind:'script',
+      executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],prefix_args:[],extensions:['.mjs'],
+      timeout_ms:5000,max_output_bytes:65536}}
+  },null,2));
+  const desktopTemplate=JSON.parse(await readFile(path.join(repoRoot,'controller','deadbyte-desktop-policy.json'),'utf8'));
+  desktopTemplate.grant_file=desktopGrant;
+  desktopTemplate.evidence_dir=path.join(f.root,'desktop-evidence');
+  await writeFile(desktopPolicyPath,JSON.stringify(desktopTemplate,null,2));
+
+  const authorityFiles=[processGrant,hostArm,desktopGrant,f.codingPolicy.lease_file,f.policy.lease_file];
+  for(const p of authorityFiles) assert.equal(await absent(p),true,'authority unexpectedly armed: '+p);
+
+  const client=new Client({name:'deadbyte-r59-surface-compat',version:'0.15.35'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const env={...getDefaultEnvironment(),DEADBYTE_CAPABILITY_PROFILE:'compact',DEADBYTE_AUDIT_RUNTIME:'0',
+    DEADBYTE_STATE_ROOT:path.join(f.root,'state'),DEADBYTE_WORKSPACE_ROOT:f.root,
+    DEADBYTE_SIGNING_KEY:f.keys.privateKeyPath,DEADBYTE_VERIFY_KEY:f.keys.publicKeyPath,
+    DEADBYTE_PRIVILEGED_POLICY:hostPolicyPath,DEADBYTE_MACHINE_RUNTIME:'1',DEADBYTE_AGENT_RUNTIME:'0',
+    DEADBYTE_PROCESS_RUNTIME:'1',DEADBYTE_PROCESS_POLICY:processPolicyPath,DEADBYTE_CODING_RUNTIME:'1',
+    DEADBYTE_CODING_POLICY:path.join(f.root,'coding-policy.json'),DEADBYTE_MACHINE_FS_RUNTIME:'1',
+    DEADBYTE_OBSERVATION_RUNTIME:'1',DEADBYTE_DESKTOP_RUNTIME:'1',DEADBYTE_DESKTOP_POLICY:desktopPolicyPath,
+    DEADBYTE_AUTONOMOUS_RUNTIME:'1',DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
+    DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'};
+  const transport=new StdioClientTransport({command:process.execPath,args:[path.join(repoRoot,'src','mcp-server.mjs')],
+    cwd:repoRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    assert.equal(listed.tools.length,43,'candidate expected compact 43-tool surface');
+    return snapshotToolsListResult(listed);
+  } finally {
+    await client.close().catch(()=>{});
+    for(const p of authorityFiles) assert.equal(await absent(p),true,'authority file appeared: '+p);
+    await f.cleanup();
+  }
+}
+
+test('R59 compact client-visible tool names and schemas match sealed 0.15.35 baseline',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');
+  assert.match(raw.surface_sha256,/^[0-9a-f]{64}$/);
+  assert.equal(raw.tools.length,43);
+  const baseline={schema:'deadbyte.tool-surface.v1',tools:raw.tools,surface_sha256:raw.surface_sha256};
+  const current=await captureCurrentSurface();
+  const diff=diffToolSurface(baseline,current);
+  assert.deepEqual(diff.added,[]);
+  assert.deepEqual(diff.removed,[]);
+  assert.deepEqual(diff.schema_changed,[]);
+  assert.equal(diff.unchanged.length,43);
+  assert.equal(current.surface_sha256,baseline.surface_sha256);
+  console.log(JSON.stringify({baseline_release:raw.release_id,surface_sha256:current.surface_sha256,
+    unchanged:diff.unchanged.length,added:diff.added,removed:diff.removed,schema_changed:diff.schema_changed}));
+});

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

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { authorityVector, parseAuthorityObservation, assertAuthorityVector, assertRuntimeReadyObservation } from '../src/remote-authority.mjs';
+
+const observed = (armed={}) => ({
+  schema:'deadbyte.controller-observation.v1',
+  authority:Object.fromEntries(['process','coding','autonomous','desktop','host'].map(name=>[
+    name,{configured:true,armed:Boolean(armed[name]),reason:armed[name]?'standing-grant':'disarmed'}
+  ]))
+});
+
+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('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});
+});
+
+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/);
+});
+
+test('malformed or incomplete controller observation fails closed',()=>{
+  assert.throws(()=>parseAuthorityObservation('{}'),/observation/);
+  assert.throws(()=>parseAuthorityObservation(JSON.stringify({schema:'deadbyte.controller-observation.v1',authority:{process:{armed:true}}})),/authority/);
+});
+
+test('readiness requires verified Bridge Core Cloud and local MCP, not just ONLINE text',()=>{
+  const value={...observed({process:true,coding:true,autonomous:true}),state:'ONLINE',local_ready:true,
+    bridge:{alive:true,reason:'verified'},core:{alive:true,reason:'verified'},cloud:{alive:true,reason:'verified'},
+    supervisor:{running:true},core_root:'D:\\exact-release'};
+  assertRuntimeReadyObservation(value,{coreRoot:'D:\\exact-release'});
+  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/);
+});

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

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { probeRemoteEnforcement } from '../src/remote-enforcement-probe-r60.mjs';
+
+function client({hostArmed=false,desktopArmed=false}={}){
+  return {callTool:async ({name})=>name==='desktop_control'
+    ? {isError:false,structuredContent:{status:'ok',op:'status',result:{armed:desktopArmed}}}
+    : hostArmed
+      ? {isError:false,structuredContent:{status:'ok',content:'{}',sha256:'a'.repeat(64)}}
+      : {isError:true,structuredContent:{status:'denied'}}};
+}
+
+test('default remote verifies Host denial and Desktop disarm through actual MCP tools',async()=>{
+  await probeRemoteEnforcement({client:client(),mode:'default'});
+  await assert.rejects(probeRemoteEnforcement({client:client({hostArmed:true}),mode:'default'}),/Host.*enforcement/);
+  await assert.rejects(probeRemoteEnforcement({client:client({desktopArmed:true}),mode:'default'}),/Desktop.*enforcement/);
+});
+
+test('full remote requires both Host read and Desktop armed state',async()=>{
+  await probeRemoteEnforcement({client:client({hostArmed:true,desktopArmed:true}),mode:'full'});
+  await assert.rejects(probeRemoteEnforcement({client:client({hostArmed:false,desktopArmed:true}),mode:'full'}),/Host.*enforcement/);
+});
+
+test('post-session revoked probe independently rejects lingering Host and Desktop grants',async()=>{
+  await probeRemoteEnforcement({client:client(),mode:'revoked'});
+  await assert.rejects(probeRemoteEnforcement({client:client({hostArmed:true}),mode:'revoked'}),/Host.*enforcement/);
+  await assert.rejects(probeRemoteEnforcement({client:client({desktopArmed:true}),mode:'revoked'}),/Desktop.*enforcement/);
+});

package/test/r60-bridge-dispatch.test.mjs

@@ -0,0 +1,119 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {openRemoteCallClaims} from '../bridge/src/remote-call-claims-r60.mjs';
+import {dispatchBridgeCall,classifyRemoteOperation} from '../bridge/src/remote-dispatch-r60.mjs';
+import {createCapabilitySnapshotTracker} from '../src/capability-snapshot.mjs';
+
+const base={device_id:'device-1',session_id:'stateless',request_id:'call-1',tool:'coding_file_write',
+  arguments:{root_id:'fixture',path:'a.txt',content:'A'},expires_at_utc:'2030-01-01T00:00:00.000Z',
+  release_id:'v0.15.37-test',generation_manifest_sha256:'a'.repeat(64),machine_id:'d'.repeat(64),online_epoch:'c'.repeat(64),classification:'mutating'};
+
+async function fixture(run){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-bridge-dispatch-'));
+  try{await run(openRemoteCallClaims({root,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')}));}
+  finally{await rm(root,{recursive:true,force:true});}
+}
+
+test('remote operation classifier marks only pinned read-only forms safe for recovery',()=>{
+  assert.equal(classifyRemoteOperation({name:'machine_status'},{}),'read_only');
+  assert.equal(classifyRemoteOperation({name:'machine_fs'},{op:'read',root_id:'fixture',path:'a.txt'}),'read_only');
+  assert.equal(classifyRemoteOperation({name:'machine_fs'},{op:'write',root_id:'fixture',path:'a.txt'}),'mutating');
+  assert.equal(classifyRemoteOperation({name:'coding_file_write'},{}),'mutating');
+  assert.equal(classifyRemoteOperation({name:'unknown_future_tool'},{}),'unknown');
+});
+
+test('capability snapshot describes the Bridge idempotency boundary without adding signed capabilities',()=>{
+  const snapshot=createCapabilitySnapshotTracker({clock:()=>1000}).snapshot({profile:'compact',
+    ledger:{ledger_sha256:'a'.repeat(64),entries:[]},toolCatalog:['capability_manifest'],catalogSha256:'b'.repeat(64),
+    resolution:{capabilities:[]},bindings:{},planes:{}});
+  assert.equal(snapshot.remote_dispatch_contract.scope,'bridge_ingress_only');
+  assert.equal(snapshot.remote_dispatch_contract.keyed_mutation,'same stable key and canonical payload: no duplicate dispatch; unknown post-dispatch outcome is not retried');
+  assert.equal(snapshot.remote_dispatch_contract.keyless_mutation,'cross-reconnect logical retry safety unavailable; ambiguous outcome is not auto-replayed');
+  assert.deepEqual(snapshot.capabilities,[]);
+});
+
+test('Bridge keyed mutation duplicate executes the downstream side effect once and replays result',async()=>fixture(async claims=>{
+  let effects=0;
+  const binding={...base,idempotency_key:'stable-write-1'};
+  const invoke=async()=>{effects++;return {structuredContent:{status:'ok',receipt_sha256:'b'.repeat(64)}};};
+  const first=await dispatchBridgeCall({claims,binding,classification:'mutating',invoke});
+  const duplicate=await dispatchBridgeCall({claims,binding:{...binding,session_id:'new-session',request_id:'call-99'},classification:'mutating',invoke});
+  assert.deepEqual(duplicate,first);
+  assert.equal(effects,1);
+  await assert.rejects(dispatchBridgeCall({claims,binding:{...binding,arguments:{...binding.arguments,content:'B'}},classification:'mutating',invoke}),/idempotency_key_conflict/);
+  assert.equal(effects,1);
+}));
+
+test('Bridge keyless exact duplicate does not replay and uncertain post-dispatch mutation stays unknown',async()=>fixture(async claims=>{
+  let effects=0;
+  const first=await dispatchBridgeCall({claims,binding:base,classification:'mutating',invoke:async()=>{effects++;throw new Error('transport lost');}}).catch(error=>error);
+  assert.match(first.message,/unknown/i);
+  const second=await dispatchBridgeCall({claims,binding:base,classification:'mutating',invoke:async()=>{effects++;}}).catch(error=>error);
+  assert.match(second.message,/unknown/i);
+  assert.equal(effects,1);
+}));
+
+test('keyless JSON-RPC ids do not become cross-delivery mutation identities',async()=>fixture(async claims=>{
+  let effects=0;
+  const invoke=async()=>({structuredContent:{status:'ok',effect_number:++effects}});
+  const first=await dispatchBridgeCall({claims,binding:{...base,session_id:'delivery-a'},classification:'mutating',invoke});
+  const second=await dispatchBridgeCall({claims,binding:{...base,session_id:'delivery-b'},classification:'mutating',invoke});
+  assert.equal(first.structuredContent.effect_number,1);
+  assert.equal(second.structuredContent.effect_number,2);
+  assert.equal(effects,2,'legacy calls do not acquire exactly-once semantics from a reused JSON-RPC id');
+}));
+
+test('concurrent Bridge deliveries race one durable dispatch marker and one side effect',async()=>fixture(async claims=>{
+  let effects=0;
+  const binding={...base,idempotency_key:'concurrent-write-1'};
+  const outcomes=await Promise.allSettled(Array.from({length:12},()=>dispatchBridgeCall({claims,binding,classification:'mutating',invoke:async()=>{
+    effects++;
+    return {structuredContent:{status:'ok',receipt_sha256:'b'.repeat(64)}};
+  }})));
+  assert.equal(effects,1);
+  assert.ok(outcomes.some(item=>item.status==='fulfilled'));
+  assert.ok(outcomes.every(item=>item.status==='fulfilled'||/in flight|unknown|no replay/i.test(item.reason.message)));
+}));
+
+test('two Bridge claim-store instances sharing one root still allow only one keyed side effect',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-two-bridges-'));
+  try{
+    const one=openRemoteCallClaims({root,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')});
+    const two=openRemoteCallClaims({root,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')});
+    const binding={...base,idempotency_key:'two-bridge-race'};
+    let effects=0;
+    const invoke=async()=>{effects++;return {structuredContent:{status:'ok'}};};
+    const outcomes=await Promise.allSettled([
+      dispatchBridgeCall({claims:one,binding,classification:'mutating',invoke}),
+      dispatchBridgeCall({claims:two,binding:{...binding,session_id:'second',request_id:'second'},classification:'mutating',invoke})
+    ]);
+    assert.equal(effects,1);
+    assert.ok(outcomes.some(item=>item.status==='fulfilled'));
+    assert.ok(outcomes.every(item=>item.status==='fulfilled'||/in flight|unknown|no replay/i.test(item.reason.message)));
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('a keyed result is replayable after the reply is lost, without invoking Core again',async()=>fixture(async claims=>{
+  const binding={...base,idempotency_key:'lost-reply'};
+  let effects=0;
+  await dispatchBridgeCall({claims,binding,classification:'mutating',invoke:async()=>({structuredContent:{status:'ok',ordinal:++effects}})});
+  const replay=await dispatchBridgeCall({claims,binding:{...binding,session_id:'reattached',request_id:'new-rpc-id'},classification:'mutating',
+    invoke:async()=>{throw new Error('must not reach Core');}});
+  assert.equal(replay.structuredContent.ordinal,1);
+  assert.equal(effects,1);
+}));
+
+test('read-only post-crash claim can re-execute after recovery without mutating retry',async()=>fixture(async claims=>{
+  const binding={...base,tool:'machine_status',classification:'read_only',arguments:{},idempotency_key:'read-status-1'};
+  const first=await claims.claim(binding);
+  await claims.dispatch(first.claim_id);
+  await claims.recover({limit:100});
+  let calls=0;
+  const result=await dispatchBridgeCall({claims,binding,classification:'read_only',invoke:async()=>{calls++;return {structuredContent:{status:'ok'}};}});
+  assert.equal(result.structuredContent.status,'ok');
+  assert.equal(calls,1);
+  assert.equal((await claims.state(first.claim_id)).state,'TERMINAL');
+}));

package/test/r60-clock-discipline.test.mjs

@@ -0,0 +1,15 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createBridgeHealth } from '../bridge/src/bridge-health-r59.mjs';
+
+test('backward wall-clock jump cannot extend capability freshness',()=>{
+  let wall=100000,elapsed=0;
+  const health=createBridgeHealth({clock:()=>wall,elapsedClock:()=>elapsed,maxCapabilityAgeMs:15000});
+  health.coreConnected({childIdentity:'core',protocolEra:'modern',catalogSha256:'a'.repeat(64)});
+  health.capabilityObserved({schema:'deadbyte.capability-manifest.v3',snapshot_id:'b'.repeat(64),state_epoch:1,
+    observed_at_utc:new Date(wall).toISOString(),valid_until_utc:new Date(wall+60000).toISOString(),planes:{}});
+  assert.equal(health.snapshot().state,'READY');
+  wall-=60000;
+  elapsed+=16000;
+  assert.equal(health.snapshot().state,'DEGRADED');
+});

package/test/r60-live-timeline.test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createLiveTimelineTracker } from '../src/remote-live-log.mjs';
+
+test('capability polling prints initial/changed identity and suppresses only unchanged observations',()=>{
+  let now=1000;
+  const tracker=createLiveTimelineTracker({clock:()=>now,heartbeatBurstLimit:3,heartbeatWindowMs:3000});
+  const lines=[];
+  for(let i=0;i<3;i++){
+    const request_id=`cap-${i}`;
+    lines.push(tracker.observe({event_type:'tool.request',tool:'capability_manifest',request_id,args:{}},{sequence:i*2+1}));
+    now+=10;
+    lines.push(tracker.observe({event_type:'tool.result',tool:'capability_manifest',request_id,outcome:{is_error:false,duration_ms:2,
+      snapshot_id:i===2?'b'.repeat(64):'a'.repeat(64),state_epoch:i===2?2:1}},{sequence:i*2+2}));
+  }
+  assert.match(lines[1],/capability_manifest.*epoch=1/);
+  assert.equal(lines[3],null);
+  assert.match(lines[5],/capability_manifest.*epoch=2/);
+  assert.match(tracker.reconcileInterrupted().join('\n'),/capability_manifest ×1 unchanged suppressed/);
+  assert.match(tracker.summary(),/3 calls \| 3 ok/);
+});
+
+test('machine status and ping remain visible in R60 human timeline',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  for(const tool of ['machine_status','machine_ping']){
+    tracker.observe({event_type:'tool.request',tool,request_id:tool,args:{}},{});
+    assert.match(tracker.observe({event_type:'tool.result',tool,request_id:tool,outcome:{is_error:false,duration_ms:1}},{}),new RegExp(tool));
+  }
+});

package/test/r60-reconnect-errors.test.mjs

@@ -0,0 +1,21 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { classifyReconnectFailure } from '../bridge/src/reconnect-delay-r60.mjs';
+
+test('identity, catalog and protocol drift terminate reconnect budget immediately',()=>{
+  for(const message of ['core script identity drift','replacement core catalog drift','replacement core protocol is not modern'])
+    assert.equal(classifyReconnectFailure(new Error(message)),'TERMINAL');
+  assert.equal(classifyReconnectFailure(Object.assign(new Error('connection reset'),{code:'ECONNRESET'})),'TRANSIENT');
+  assert.equal(classifyReconnectFailure(Object.assign(new Error('permission denied'),{code:'EACCES'})),'TERMINAL');
+});
+
+test('typed terminal and transient failures are not inferred from incidental message text',()=>{
+  assert.equal(classifyReconnectFailure(Object.assign(new Error('connection reset'),{kind:'terminal',code:'DEADBYTE_GENERATION_MISMATCH'})),'TERMINAL');
+  assert.equal(classifyReconnectFailure(Object.assign(new Error('generation mismatch'),{kind:'transient',code:'ECONNRESET'})),'TRANSIENT');
+  for(const code of ['DEADBYTE_AUTHORITY_REVOKED','DEADBYTE_POLICY_DENIED','DEADBYTE_SCHEMA_INVALID',
+    'DEADBYTE_RELEASE_MISMATCH','DEADBYTE_GENERATION_MISMATCH','DEADBYTE_IDEMPOTENCY_CONFLICT',
+    'DEADBYTE_CLAIM_CORRUPT','DEADBYTE_CREDENTIAL_EXPIRED'])
+    assert.equal(classifyReconnectFailure(Object.assign(new Error('arbitrary'),{code})),'TERMINAL');
+  for(const code of ['ECONNRESET','ECONNREFUSED','EPIPE','ETIMEDOUT','EHOSTUNREACH'])
+    assert.equal(classifyReconnectFailure(Object.assign(new Error('arbitrary'),{code})),'TRANSIENT');
+});

package/test/r60-reconnect-jitter.test.mjs

@@ -0,0 +1,18 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { reconnectDelayMs, waitForReconnect } from '../bridge/src/reconnect-delay-r60.mjs';
+
+test('bounded reconnect delays jitter each attempt without exceeding the restart budget',()=>{
+  const low=[0,1,2,3,4].map(index=>reconnectDelayMs(index,()=>0));
+  const high=[0,1,2,3,4].map(index=>reconnectDelayMs(index,()=>1));
+  assert.deepEqual(low,[188,375,750,1500,3000]);
+  assert.deepEqual(high,[313,625,1250,2500,5000]);
+  assert.throws(()=>reconnectDelayMs(5),/attempt/);
+});
+
+test('shutdown aborts a scheduled reconnect before another child can start',async()=>{
+  const controller=new AbortController();
+  const pending=waitForReconnect(5000,controller.signal);
+  controller.abort();
+  assert.equal(await pending,false);
+});

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

@@ -0,0 +1,81 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=rel=>read(rel).then(raw=>JSON.parse(raw.replace(/^\uFEFF/,'')));
+
+const PARENT=Object.freeze({
+  version:'0.15.36',
+  release_id:'v0.15.36-090d9db3e0679c0d',
+  manifest_sha256:'090d9db3e0679c0d4943f3229ecab7b9fcccbe4f767348a568c9f3bb60d1b431',
+  generation_manifest_sha256:'6134f9f26b680e13ed545da4ab5f3020f411ea2569062fb9c154c8a7e036c9dc'
+});
+
+test('R60 identity is coherent and binds the exact production-accepted 0.15.36 predecessor',async()=>{
+  const [pkg,lock,release,prov,matrix,sbom,version,bridgePkg,contract]=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'),
+    read('docs/R60-TASK-CONTRACT.md')
+  ]);
+  assert.equal(pkg.version,'0.15.37');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.37'/);
+  assert.equal(bridgePkg.version,pkg.version);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R60');
+  assert.equal(release.label,'REMOTE TRUTH + RESILIENCE HARDENING');
+  assert.equal(prov.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R60');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r60:0.15.37');
+  assert.equal(release.parent.version,PARENT.version);
+  assert.equal(release.parent.release_id,PARENT.release_id);
+  assert.equal(release.parent.manifest_sha256,PARENT.manifest_sha256);
+  assert.equal(release.parent.generation_manifest_sha256,PARENT.generation_manifest_sha256);
+  assert.equal(release.runtime_predecessor.release_id,PARENT.release_id);
+  assert.equal(release.runtime_predecessor.manifest_sha256,PARENT.manifest_sha256);
+  assert.equal(release.runtime_predecessor.generation_manifest_sha256,PARENT.generation_manifest_sha256);
+  assert.equal(prov.runtime_predecessor.release_id,PARENT.release_id);
+  assert.equal(prov.runtime_predecessor.manifest_sha256,PARENT.manifest_sha256);
+  assert.equal(prov.runtime_predecessor.generation_manifest_sha256,PARENT.generation_manifest_sha256);
+  assert.match(contract,/TASK_ID: deadbyte-r60-remote-truth-resilience/);
+  assert.match(contract,/0\.15\.36/);
+  assert.match(contract,/0\.15\.37/);
+});
+
+test('R60 release contract exposes the proven remote truth semantics without widening dependencies',async()=>{
+  const [pkg,release,matrix]=await Promise.all([json('package.json'),json('RELEASE.json'),json('TEST-MATRIX.json')]);
+  assert.equal(Object.keys(pkg.dependencies??{}).length,4);
+  assert.equal(release.r60_remote_hardening.authority_truth_coherence,true);
+  assert.equal(release.r60_remote_hardening.execution_backed_readiness,true);
+  assert.equal(release.r60_remote_hardening.keyed_mutation_dedup,true);
+  assert.equal(release.r60_remote_hardening.keyless_ambiguous_mutation_fail_closed,true);
+  assert.equal(release.r60_remote_hardening.read_only_recovery,true);
+  assert.equal(release.r60_remote_hardening.bounded_reconnect_jitter,true);
+  assert.equal(release.r60_remote_hardening.terminal_transient_failure_taxonomy,true);
+  assert.equal(release.r60_remote_hardening.capability_manifest_human_suppression,true);
+  assert.equal(release.r60_remote_hardening.windows_log_bom_decode,true);
+  assert.equal(release.r60_remote_hardening.public_surface_tool_count,43);
+  assert.equal(release.r60_remote_hardening.stable_final_claim,false);
+  assert.equal(matrix.observed_pre_release_evidence.r60_behavioral_regression.status,'PASS');
+  assert.equal(matrix.observed_pre_release_evidence.r60_behavioral_regression.tests,1241);
+  assert.equal(matrix.observed_pre_release_evidence.r60_behavioral_regression.passed,1210);
+  assert.equal(matrix.observed_pre_release_evidence.r60_behavioral_regression.skipped,31);
+  assert.equal(matrix.observed_pre_release_evidence.r60_behavioral_regression.failed,0);
+  assert.equal(matrix.observed_pre_release_evidence.r60_windows_gate.status,'PASS_STAGED_WINDOWS_DOCTOR_WARN');
+  assert.equal(matrix.observed_pre_release_evidence.r60_package.status,'PASS_VERIFY_ONLY_PRE_FINAL_SEAL');
+});
+
+test('R60 package scripts bind the new focused, full-regression and Windows-gate entrypoints',async()=>{
+  const [pkg,gate]=await Promise.all([json('package.json'),read('scripts/gate-windows-r60-prepublish.ps1')]);
+  assert.match(pkg.scripts['r60:focused:test'],/r60-authority-coherence\.test\.mjs/);
+  assert.match(pkg.scripts['r60:focused:test'],/r60-remote-call-recovery\.test\.mjs/);
+  assert.equal(pkg.scripts['r60:full:test'],'node scripts/full-regression-r60.mjs');
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r60-prepublish.ps1');
+  assert.match(gate,/ValidateSet\('all','preflight','focused','full-batch','manifest','doctor'\)/);
+  assert.match(gate,/R60 PREPUBLISH WINDOWS GATE STAGE: PASS/);
+  assert.match(gate,/--batch=\$Batch/);
+});

package/test/r60-remote-call-recovery.test.mjs

@@ -0,0 +1,170 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { openRemoteCallClaims } from '../bridge/src/remote-call-claims-r60.mjs';
+import {canonicalJson as bridgeCanonicalJson} from '../bridge/src/canonical-json-r60.mjs';
+import {canonicalJson as coreCanonicalJson} from '../src/canonical-json.mjs';
+
+const binding={device_id:'device-1',session_id:'session-1',request_id:'call-1',tool:'coding_file_write',
+  arguments:{root_id:'fixture',path:'a.txt',content:'A'},expires_at_utc:'2030-01-01T00:00:00.000Z',
+  release_id:'v0.15.37-test',generation_manifest_sha256:'a'.repeat(64),machine_id:'d'.repeat(64),online_epoch:'c'.repeat(64),classification:'mutating'};
+
+async function withStore(fn){
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-claims-'));
+  try{await fn(openRemoteCallClaims({root:dir,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')}));}
+  finally{await rm(dir,{recursive:true,force:true});}
+}
+
+test('Bridge and Core canonical argument encoding remain byte-identical',()=>{
+  const value={z:[{b:2,a:1}],a:{thai:'ทดสอบ',x:null}};
+  assert.equal(bridgeCanonicalJson(value),coreCanonicalJson(value));
+});
+
+test('claim refuses missing machine/epoch/classification identity before execution',async()=>withStore(async store=>{
+  await assert.rejects(store.claim({...binding,machine_id:undefined}),/machine_id/);
+  await assert.rejects(store.claim({...binding,online_epoch:undefined}),/online epoch/);
+  await assert.rejects(store.claim({...binding,classification:undefined}),/classification/);
+}));
+
+test('duplicate request identity with same canonical payload never receives a second execution claim',async()=>withStore(async store=>{
+  const first=await store.claim(binding);
+  assert.equal(first.owner,true);
+  const second=await store.claim({...binding,arguments:{content:'A',path:'a.txt',root_id:'fixture'}});
+  assert.equal(second.owner,false);
+  assert.equal(second.state,'CLAIMED');
+  await store.dispatch(first.claim_id);
+  const uncertain=await store.claim(binding);
+  assert.equal(uncertain.owner,false);
+  assert.equal(uncertain.state,'EXECUTING');
+  assert.equal(uncertain.side_effect_state,'may_have_started');
+}));
+
+test('changed payload and expired request fail closed',async()=>withStore(async store=>{
+  await store.claim(binding);
+  await assert.rejects(store.claim({...binding,arguments:{...binding.arguments,content:'B'}}),/request_id_conflict/);
+  await assert.rejects(store.claim({...binding,request_id:'expired',expires_at_utc:'2020-01-01T00:00:00.000Z'}),/expired/);
+}));
+
+test('same JSON-RPC request id in a distinct session is not a duplicate',async()=>withStore(async store=>{
+  const first=await store.claim(binding);
+  const second=await store.claim({...binding,session_id:'session-2'});
+  assert.equal(first.owner,true);
+  assert.equal(second.owner,true);
+  assert.notEqual(first.claim_id,second.claim_id);
+}));
+
+test('an already claimed call cannot acquire a fresh deadline after its original expiry',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-expiry-'));
+  let now=Date.parse('2029-01-01T00:00:00.000Z');
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>now});
+    await store.claim({...binding,expires_at_utc:'2029-01-01T00:00:01.000Z'});
+    now+=2000;
+    await assert.rejects(store.claim({...binding,expires_at_utc:'2029-01-02T00:00:00.000Z'}),/expired/);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+test('stable idempotency key survives transport session and JSON-RPC id changes',async()=>withStore(async store=>{
+  const first=await store.claim({...binding,idempotency_key:'goal-write-1'});
+  await store.dispatch(first.claim_id);
+  await store.terminal(first.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  const replay=await store.claim({...binding,idempotency_key:'goal-write-1',session_id:'session-2',request_id:'call-99'});
+  assert.equal(replay.owner,false);
+  assert.equal(replay.state,'TERMINAL');
+  assert.equal(replay.claim_id,first.claim_id);
+  assert.deepEqual(replay.result,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  await assert.rejects(store.claim({...binding,idempotency_key:'goal-write-1',session_id:'session-3',request_id:'call-100',arguments:{...binding.arguments,content:'B'}}),/idempotency_key_conflict/);
+}));
+
+test('same JSON-RPC id with a different stable key is a distinct logical mutation',async()=>withStore(async store=>{
+  const first=await store.claim({...binding,idempotency_key:'goal-write-1'});
+  const second=await store.claim({...binding,idempotency_key:'goal-write-2'});
+  assert.equal(first.owner,true);
+  assert.equal(second.owner,true);
+  assert.notEqual(first.claim_id,second.claim_id);
+}));
+
+test('concurrent duplicate claims have one owner and terminal result is replayable without dispatch',async()=>withStore(async store=>{
+  const claims=await Promise.all(Array.from({length:12},()=>store.claim(binding)));
+  assert.equal(claims.filter(item=>item.owner).length,1);
+  const id=claims[0].claim_id;
+  await store.dispatch(id);
+  await assert.rejects(store.dispatch(id),/already dispatched/);
+  await store.terminal(id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  const replay=await store.claim(binding);
+  assert.equal(replay.owner,false);
+  assert.equal(replay.state,'TERMINAL');
+  assert.deepEqual(replay.result,{status:'ok',receipt_sha256:'b'.repeat(64)});
+}));
+
+test('corrupted terminal bytes fail closed instead of replaying altered success',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-corrupt-'));
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')});
+    const first=await store.claim(binding);
+    await store.dispatch(first.claim_id);
+    await store.terminal(first.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+    const file=path.join(dir,first.claim_id.slice(0,2),`${first.claim_id}.terminal.json`);
+    const original=await readFile(file,'utf8');
+    await writeFile(file,original.replace('"status":"ok"','"status":"forged"'));
+    await assert.rejects(store.claim(binding),/terminal.*hash|corrupt/i);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+test('corrupted required claim record fails closed before any duplicate dispatch',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-corrupt-'));
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')});
+    const first=await store.claim(binding);
+    const file=path.join(dir,first.claim_id.slice(0,2),`${first.claim_id}.claim.json`);
+    const original=await readFile(file,'utf8');
+    await writeFile(file,original.replace('"tool":"coding_file_write"','"tool":"host_exec"'));
+    await assert.rejects(store.claim(binding),/claim.*hash|corrupt/i);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+test('startup recovery marks only post-dispatch mutations interrupted and leaves pre-effect claims recoverable',async()=>withStore(async store=>{
+  const pending=await store.claim({...binding,request_id:'pre-effect'});
+  const uncertain=await store.claim({...binding,request_id:'post-dispatch'});
+  await store.dispatch(uncertain.claim_id);
+  const batch=await store.recover({limit:100});
+  assert.equal(batch.records.length,2);
+  assert.equal((await store.state(pending.claim_id)).state,'CLAIMED');
+  const after=await store.state(uncertain.claim_id);
+  assert.equal(after.state,'INTERRUPTED');
+  assert.equal(after.side_effect_state,'unknown');
+}));
+
+
+test('recovery inventory excludes terminal and expired claims while retaining eligible pre-effect work',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-recovery-filter-'));
+  let now=Date.parse('2029-01-01T00:00:00.000Z');
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>now});
+    const terminal=await store.claim({...binding,request_id:'terminal-history',expires_at_utc:'2030-01-01T00:00:00.000Z'});
+    await store.dispatch(terminal.claim_id);
+    await store.terminal(terminal.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+    const expired=await store.claim({...binding,request_id:'expired-history',expires_at_utc:'2029-01-01T00:00:01.000Z'});
+    const pending=await store.claim({...binding,request_id:'eligible-pending',expires_at_utc:'2030-01-01T00:00:00.000Z'});
+    now+=2000;
+    const batch=await store.recover({limit:100});
+    const ids=new Set(batch.records.map(item=>item.claim_id));
+    assert.equal(ids.has(terminal.claim_id),false,'terminal history is not recovery work');
+    assert.equal(ids.has(expired.claim_id),false,'expired work must not consume recovery budget');
+    assert.equal(ids.has(pending.claim_id),true,'eligible pre-effect claim must remain recoverable');
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+
+test('stable idempotency key cannot replay execution evidence across machine online epoch rotation',async()=>withStore(async store=>{
+  const keyed={...binding,idempotency_key:'epoch-bound-write'};
+  const first=await store.claim(keyed);
+  await store.dispatch(first.claim_id);
+  await store.terminal(first.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  await assert.rejects(
+    store.claim({...keyed,session_id:'session-after-revoke',request_id:'retry-after-revoke',online_epoch:'e'.repeat(64)}),
+    /epoch|identity drift/i
+  );
+}));