deadbyte-mcp 0.15.36 → 0.15.37

package/test/r58-controller-live-local.test.mjs

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import {mkdir,cp,readFile,writeFile} from 'node:fs/promises';
+import {mkdir,cp,readFile,readdir,writeFile} from 'node:fs/promises';
 import {spawnSync} from 'node:child_process';
 import {createServer} from 'node:net';
 import {createHash,randomBytes,generateKeyPairSync} from 'node:crypto';
@@ -8,6 +8,7 @@ import path from 'node:path';
 import {makeDoctorCliFixture} from './helpers/r58-doctor-fixture.mjs';
 import {prepareBridgeSpec,windowsPowerShellEnvironment} from '../src/runtime-update.mjs';
 import {queryForegroundIdentity as queryForegroundProcessIdentity,foregroundIdentityMatches as sameForegroundProcessIdentity} from '../src/foreground-process-identity.mjs';
+import {Client,StreamableHTTPClientTransport} from '@modelcontextprotocol/client';
 
 const sha=b=>createHash('sha256').update(b).digest('hex');
 const quote=s=>"'"+s.replaceAll("'","''")+"'";
@@ -31,7 +32,7 @@ test('R58 actual isolated controller/bridge/core reaches ONLINE and stops withou
  const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs'),nodeHash=sha(await readFile(process.execPath));
  const preparedBridge=await prepareBridgeSpec({Bridge:{FilePath:process.execPath,FileSha256:nodeHash,Arguments:'src\\bridge.mjs',WorkingDirectory:bridgeRoot},Cloud:{}},{root:bridgeRoot,scriptSha256:sha(await readFile(bridgeScript))});
  const dependencies=preparedBridge.Bridge.Dependencies.map(dependency=>`@{Name=${quote(dependency.Name)};Path=${quote(dependency.Path)};Sha256='${dependency.Sha256}'}`);
- assert.deepEqual(preparedBridge.Bridge.Dependencies.map(x=>x.Name),['bridge-health-r59.mjs','node-http-adapter.mjs','public-tool-definitions.mjs','r40-governor.mjs']);
+ assert.deepEqual(preparedBridge.Bridge.Dependencies.map(x=>x.Name),['bridge-health-r59.mjs','canonical-json-r60.mjs','node-http-adapter.mjs','public-tool-definitions.mjs','r40-governor.mjs','reconnect-delay-r60.mjs','remote-call-claims-r60.mjs','remote-dispatch-r60.mjs']);
  const config=path.join(f.root,'controller-config.psd1'),runtime=path.join(f.state,'runtime');
  await writeFile(config,`@{ Schema='deadbyte.controller.v1'; CoreRoot=${quote(f.pkg)}; WorkspaceRoot=${quote(workspace)}; Bridge=@{FilePath=${quote(process.execPath)};FileSha256='${nodeHash}';Arguments='src\\bridge.mjs';WorkingDirectory=${quote(bridgeRoot)};ScriptPath=${quote(bridgeScript)};ScriptSha256='${sha(await readFile(bridgeScript))}';Dependencies=@(${dependencies.join(';')})}; Cloud=@{FilePath=${quote(process.execPath)};FileSha256='${nodeHash}';Arguments=${quote('"'+cloud+'"')};WorkingDirectory=${quote(f.root)};Dependencies=@(@{Name='fixture-cloud';Path=${quote(cloud)};Sha256='${sha(await readFile(cloud))}'})}; MachineRuntimeEnabled=$false;AgentRuntimeEnabled=$false;ProcessRuntimeEnabled=$false;ProcessPolicyFile='';CodingRuntimeEnabled=$false;CodingPolicyFile='';MachineFsRuntimeEnabled=$false;ObservationRuntimeEnabled=$false;DesktopRuntimeEnabled=$false;DesktopPolicyFile='';AutonomousRuntimeEnabled=$false;AutonomousSupervisorEnabled=$false;AutonomousPolicyFile='';HostPolicyFile='';LocalReadyUri='http://127.0.0.1:${port}/healthz';UrlRegex='';McpUrlFile=${quote(url)};McpPathFile='';StartTimeoutSeconds=15;ProbeTimeoutSeconds=1 }`);
  // Controller's existing audit mode requires machine runtime. It is observation
@@ -61,7 +62,8 @@ test('R58 actual isolated controller/bridge/core reaches ONLINE and stops withou
    launcher_sha256:'0'.repeat(64),
    config_path:generationConfig
  },null,2)+'\n');
- const env=windowsPowerShellEnvironment({...f.env,DEADBYTE_CONTROLLER_CONFIG:config,DEADBYTE_CONTROLLER_RUNTIME_ROOT:runtime,DEADBYTE_BRIDGE_PORT:String(port),DEADBYTE_BRIDGE_PATH_TOKEN:randomBytes(32).toString('hex')});
+ const bridgeToken=randomBytes(32).toString('hex');
+ const env=windowsPowerShellEnvironment({...f.env,DEADBYTE_CONTROLLER_CONFIG:config,DEADBYTE_CONTROLLER_RUNTIME_ROOT:runtime,DEADBYTE_BRIDGE_PORT:String(port),DEADBYTE_BRIDGE_PATH_TOKEN:bridgeToken});
  const run=(command,json=false)=>spawnSync(path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoProfile','-File',controller,command,...(json?['-Json']:[])],{env,encoding:'utf8',timeout:45000});
  let coreIdentity=null;
  try{
@@ -70,6 +72,17 @@ test('R58 actual isolated controller/bridge/core reaches ONLINE and stops withou
   const status=run('status',true);assert.equal(status.status,0,status.stderr);const observed=JSON.parse(status.stdout);
   assert.equal(observed.state,'ONLINE');assert.equal(observed.local_ready,true);assert.equal(observed.core.alive,true);assert.equal(observed.core.parent_pid,observed.bridge.pid);
   for(const plane of Object.values(observed.authority))assert.equal(plane.armed,false);
+  const publicClient=new Client({name:'r60-isolated-ingress',version:'0.15.37'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  try{
+    await publicClient.connect(new StreamableHTTPClientTransport(new URL(`http://127.0.0.1:${port}/mcp/${bridgeToken}`)));
+    const publicStatus=await publicClient.callTool({name:'machine_status',arguments:{}});
+    assert.equal(publicStatus.structuredContent?.status,'ok','actual Bridge ingress must execute through the guarded dispatch');
+    const claimRoot=path.join(f.state,'runtime','remote-call-claims');
+    const shards=await readdir(claimRoot);
+    assert.equal(shards.length,1,'public ingress must create a durable claim');
+    const records=await readdir(path.join(claimRoot,shards[0]));
+    assert.equal(records.filter(name=>name.endsWith('.terminal.json')).length,1,'Core result must publish a terminal record');
+  }finally{await publicClient.close().catch(()=>{});}
   const firstCore=await queryForegroundProcessIdentity(observed.core.pid);assert.ok(firstCore);
   process.kill(firstCore.pid);
   let recovered=null;
@@ -83,6 +96,12 @@ test('R58 actual isolated controller/bridge/core reaches ONLINE and stops withou
   }
   assert.ok(recovered,'bridge did not recover a fresh Core within bounded restart budget');
   assert.equal(recovered.core.parent_pid,recovered.bridge.pid);
+  const reattached=new Client({name:'r60-recovered-execution',version:'0.15.37'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  try{
+    await reattached.connect(new StreamableHTTPClientTransport(new URL(`http://127.0.0.1:${port}/mcp/${bridgeToken}`)));
+    const proof=await reattached.callTool({name:'machine_status',arguments:{}});
+    assert.equal(proof.structuredContent?.status,'ok','recovered Core must execute a bounded MCP call');
+  }finally{await reattached.close().catch(()=>{});}
   coreIdentity=await queryForegroundProcessIdentity(recovered.core.pid);assert.ok(coreIdentity);
   const stopped=run('stop');assert.equal(stopped.status,0,stopped.stderr);
   const terminal=run('status',true);assert.equal(terminal.status,0,terminal.stderr);const end=JSON.parse(terminal.stdout);

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

@@ -51,7 +51,7 @@ test('R58 bound stale birth identity reconciles on the first invocation without
  await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'stale-birth-'));
  await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));
  const trace=path.join(root,'trace.txt');
- await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nexit 0\n`);
+ await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command,[switch]$Json)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nif ($Command -eq 'status' -and $Json) { $off=@{configured=$true;armed=$false;reason='disarmed'}; @{schema='deadbyte.controller-observation.v1';state='OFFLINE';authority=@{process=$off;coding=$off;autonomous=$off;desktop=$off;host=$off}} | ConvertTo-Json -Depth 5 -Compress }\nexit 0\n`);
  const current=queryForegroundIdentity(process.pid);
  const stale={...current,creation_utc:'2000-01-01T00:00:00.000Z'};
  const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:process.pid,session_nonce:'b'.repeat(64),owner_identity:stale,guardian_identity:stale};
@@ -63,7 +63,7 @@ test('R58 bound stale birth identity reconciles on the first invocation without
  await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stdout,stderr,simulation:'birth identity drift at a live unrelated numeric PID'}),{flag:'wx'});
  assert.match(stdout,/Stale remote session/);
  assert.doesNotMatch(stderr,/already active|ownership unverified/);
- assert.deepEqual((await readFile(trace,'utf8')).trim().split(/\r?\n/).slice(0,6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
+ assert.deepEqual((await readFile(trace,'utf8')).trim().split(/\r?\n/).slice(0,7),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','park']);
  assert.match(stderr,/without a verified ONLINE runtime/,'fixture deliberately has no real runtime; recovery must already have converged');
  await assert.rejects(readFile(markerPath),{code:'ENOENT'});
  assert.equal(foregroundAlive(),true,'unrelated live process must not be killed');

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

@@ -3,7 +3,7 @@ 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(JSON.parse);
+const json=rel=>read(rel).then(raw=>JSON.parse(raw.replace(/^\uFEFF/,'')));
 
 const PARENT={
   version:'0.15.35',
@@ -15,8 +15,8 @@ const PARENT={
 
 test('R59 identity is coherent and binds exact accepted 0.15.35 predecessor',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')
+    json('docs/R59-package.json'),json('docs/R59-package-lock.json'),json('docs/R59-RELEASE.json'),json('docs/R59-PROVENANCE.json'),
+    json('docs/R59-TEST-MATRIX.json'),json('docs/R59-SBOM.cdx.json'),read('docs/R59-version.mjs'),json('docs/R59-bridge-package.json')
   ]);
   assert.equal(pkg.version,'0.15.36');
   assert.equal(lock.version,pkg.version);
@@ -40,7 +40,7 @@ test('R59 identity is coherent and binds exact accepted 0.15.35 predecessor',asy
 });
 
 test('R59 release records runtime hardening without expanding public authority',async()=>{
-  const [release,prov,matrix]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json')]);
+  const [release,prov,matrix]=await Promise.all([json('docs/R59-RELEASE.json'),json('docs/R59-PROVENANCE.json'),json('docs/R59-TEST-MATRIX.json')]);
   assert.equal(release.r59_runtime_hardening.optional_plane_degradation,true);
   assert.equal(release.r59_runtime_hardening.capability_manifest_v3,true);
   assert.equal(release.r59_runtime_hardening.live_overlay_authority_ceiling,true);
@@ -53,8 +53,8 @@ test('R59 release records runtime hardening without expanding public authority',
   assert.equal(matrix.observed_pre_release_evidence.r59_contracts.tests,19);
   assert.equal(matrix.observed_pre_release_evidence.r59_public_surface.status,'PASS');
   assert.equal(matrix.observed_pre_release_evidence.r59_public_surface.tool_count,43);
-  assert.equal(prov.operator_override.four_hour_soak,'NOT_COMPLETED');
-  assert.equal(prov.operator_override.clean_machine,'NOT_COMPLETED');
+  assert.equal(prov.operator_override.four_hour_soak,'WAIVED_BY_OPERATOR');
+  assert.equal(prov.operator_override.clean_machine,'WAIVED_BY_OPERATOR');
   assert.equal(prov.operator_override.stable_final_claim,false);
   assert.equal(matrix.operator_override.stable_final_claim,false);
   assert.equal(release.stabilization.stable_final_claim,false);

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