deadbyte-mcp 0.15.36 → 0.15.38

package/src/runtime-update.mjs

@@ -394,6 +394,18 @@ export async function prepareBridgeSpec(config,bootstrap){
   return next;
 }
 
+export async function prepareReleaseBridgeSpec(config,bootstrap,releaseRoot){
+  if(!bootstrap) return structuredClone(config);
+  if(typeof releaseRoot!=='string'||!path.isAbsolute(releaseRoot))throw new Error('immutable release root required for Bridge binding');
+  // Verify the requested development input, then bind runtime paths only to
+  // the manifest-verified immutable slot produced from that same candidate.
+  const verifiedSource=await prepareBridgeSpec(config,bootstrap);
+  return prepareBridgeSpec(verifiedSource,{
+    root:path.join(path.resolve(releaseRoot),'bridge'),
+    scriptSha256:verifiedSource.Bridge.ScriptSha256
+  });
+}
+
 export async function prepareAutonomousSupervisorSpec(config,{releaseRoot,enable=false}={}){
   const next=structuredClone(config);
   if(!enable) return next;
@@ -1682,7 +1694,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       if(!control.desktopPolicy) throw new Error('DesktopRuntimeEnabled requires pinned desktop policy bootstrap or existing policy');
       control.config.DesktopRuntimeEnabled=true;
     }
-    control.config=await prepareBridgeSpec(control.config,bridgeBootstrap);
+    control.config=await prepareReleaseBridgeSpec(control.config,bridgeBootstrap,slot.release_root);
     control.config=await prepareNamedTunnelCloudSpec(control.config,{releaseRoot:slot.release_root,bootstrap:cloudTransport});
     control.config=await prepareAutonomousSupervisorSpec(control.config,{releaseRoot:slot.release_root,enable:enableAutonomousSupervisor});
     authorityPreparation=await prepareAuthorityPolicies({hostPolicy:control.hostPolicy,codingPolicy:control.codingPolicy},{commandPins:hostCommandPins});

package/src/tool-audit.mjs

@@ -116,7 +116,12 @@ 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 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),
+    ...snapshot,
     ...(isError?{reason:resultOutcomeReason(result)}:{})};
 }
 

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.36';
+export const DEADBYTE_VERSION = '0.15.38';
 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/bridge-runtime-r59.test.mjs

@@ -12,21 +12,21 @@ const limits={
 
 test('R59 bridge governor removes cancelled queued work and drains without replay',async()=>{
   const governor=createBridgeGovernor({limits});
-  const first=await governor.acquire('machine_status');
+  const first=await governor.acquire('coding_file_read');
   const abort=new AbortController();
-  const queued=governor.acquire('machine_ping',{signal:abort.signal});
+  const queued=governor.acquire('coding_file_read',{signal:abort.signal});
   abort.abort(new Error('caller disconnected'));
   await assert.rejects(queued,/caller disconnected|aborted/);
   assert.equal(governor.snapshot().normal.queued,0);
   assert.equal(governor.snapshot().normal.cancelled,1);
-  const queuedDuringRecovery=governor.acquire('machine_ping');
+  const queuedDuringRecovery=governor.acquire('coding_file_read');
   assert.equal(governor.reconcile('core generation changed'),1);
   await assert.rejects(queuedDuringRecovery,/core generation changed/);
   first.release();
-  const after=await governor.acquire('machine_status');
+  const after=await governor.acquire('coding_file_read');
   after.release();
   const drain=governor.close('bridge reconciling');
-  await assert.rejects(governor.acquire('machine_status'),/closed/);
+  await assert.rejects(governor.acquire('coding_file_read'),/closed/);
   await drain;
   assert.equal(governor.snapshot().normal.active,0);
 });

package/test/commander-schema-differential-r48.test.mjs

@@ -5,7 +5,7 @@ import {readFile} from 'node:fs/promises';
 import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
 import {registerCommanderExtendedBridge} from '../src/commander-extended-bridge-r47.mjs';
 
-const referencePath='D:\\Projects\\desktop-commander-stage-20260922\\desktop-commander\\dist\\tools\\schemas.js';
+const referencePath='D:\\Projects\\deadbyte-mcp\\references\\desktop-commander\\dist\\tools\\schemas.js';
 const expectedHash='f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140';
 async function referenceSchemas(){
   let source=await readFile(referencePath,'utf8');

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

@@ -5,7 +5,7 @@ import { DEADBYTE_VERSION } from '../src/version.mjs';
 
 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 json = rel => read(rel).then(raw => JSON.parse(raw.replace(/^\uFEFF/,'')));
 
 test('R48 compatibility release contract remains coherent in the current successor', async () => {
   const [pkg, lock, release, provenance, matrix] = await Promise.all([

package/test/r51-runtime-coherence.test.mjs

@@ -53,7 +53,7 @@ test('R51 bare remote wires coherence before live generation binding and deploy
 test('R51 foreground authority contract explicitly verifies and cleans desktop plus host',async()=>{
   const {readFile}=await import('node:fs/promises');
   const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
-  assert.match(cli,/\['desktopstatus',\/\^Desktop plane/);
+  assert.match(cli,/assertAuthorityVector\(assertRuntimeReadyObservation\(observedAuthority/);
   assert.match(cli,/SESSION_CLEANUP=.*disarmdesktop.*disarmhost/s);
-  assert.match(cli,/desktop, host DISARMED/);
+  assert.match(cli,/authorityBanner\(authority\)/);
 });

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

@@ -11,7 +11,12 @@ test('R58 foreground cleanup failure retains ownership evidence for recovery', {
   await mkdir(base,{recursive:true});
   const root=await mkdtemp(path.join(base,'cleanup-'));
   await mkdir(path.join(root,'bin'));
-  await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)
+  await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command,[switch]$Json)
+if ($Command -eq 'status' -and $Json) {
+ $on=@{configured=$true;armed=$true;reason='standing-grant'}; $off=@{configured=$true;armed=$false;reason='disarmed'}
+ @{schema='deadbyte.controller-observation.v1';state='ONLINE';core_root='fixture';local_ready=$true;bridge=@{alive=$true;reason='verified'};core=@{alive=$true;reason='verified'};cloud=@{alive=$true;reason='verified'};supervisor=@{running=$true};authority=@{process=$on;coding=$on;autonomous=$on;desktop=$off;host=$off}} | ConvertTo-Json -Depth 5 -Compress
+ exit 0
+}
 switch ($Command) {
  'status' { Write-Output 'DEADBYTE MCP = ONLINE'; Write-Output 'Bridge PID   : 1001 [verified]'; Write-Output 'Cloud PID    : 1002 [verified]'; Write-Output 'Local ready  : True'; Write-Output 'Loop supervisor: RUNNING [verified]' }
  'processstatus' { Write-Output 'Process plane  : ARMED [standing-grant]' }
@@ -30,8 +35,9 @@ exit 0
   const closed=new Promise(resolve=>child.once('close',code=>resolve(code)));
   try {
     const deadline=Date.now()+12000;
-    while(!stdout.includes('ARMED: process, coding, autonomous')&&child.exitCode===null&&Date.now()<deadline) await delay(50);
-    assert.match(stdout,/ARMED: process, coding, autonomous/,stderr);
+    while(!stdout.includes('[READY]')&&child.exitCode===null&&Date.now()<deadline) await delay(50);
+    assert.match(stdout,/\[READY\]/,stderr);
+    assert.match(stdout,/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/,stderr);
     child.stdin.end();
     assert.notEqual(await closed,0,'cleanup failure must not report a successful foreground exit');
     assert.match(stderr,/cleanup disarmprocess exit=9/);

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

@@ -11,9 +11,15 @@ test('R58 simultaneous stale recovery cannot both revoke the shared authority',
  const root=await mkdtemp(path.join(base,'concurrent-recovery-'));await mkdir(path.join(root,'bin'));await mkdir(path.join(root,'runtime'));
  const trace=path.join(root,'trace.txt'),markerPath=path.join(root,'runtime','remote-session.json');
  await writeFile(markerPath,JSON.stringify({schema:'deadbyte.remote-session.v1',pid:2147483000,started_at_utc:'2000-01-01T00:00:00.000Z'}));
- await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)
+ await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command,[switch]$Json)
 $ErrorActionPreference='Stop'
 for($i=0;$i -lt 40;$i++){try{[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine);break}catch{if($i -eq 39){throw};Start-Sleep -Milliseconds 10}}
+if ($Command -match '^(arm|disarm)(process|coding|autonomous|desktop|host)$') { $file=Join-Path $env:DEADBYTE_STATE_ROOT ('runtime/' + $Matches[2] + '.armed'); if ($Matches[1] -eq 'arm') { [IO.File]::WriteAllText($file,'1') } else { Remove-Item -LiteralPath $file -Force -ErrorAction SilentlyContinue } }
+if ($Command -eq 'status' -and $Json) {
+ $authority=@{};foreach($name in @('process','coding','autonomous','desktop','host')) { $armed=Test-Path -LiteralPath (Join-Path $env:DEADBYTE_STATE_ROOT ('runtime/' + $name + '.armed'));$authority[$name]=@{configured=$true;armed=[bool]$armed;reason=$(if($armed){'standing-grant'}else{'disarmed'})} }
+ @{schema='deadbyte.controller-observation.v1';state='ONLINE';core_root='fixture';local_ready=$true;bridge=@{alive=$true;reason='verified'};core=@{alive=$true;reason='verified'};cloud=@{alive=$true;reason='verified'};supervisor=@{running=$true};authority=$authority} | ConvertTo-Json -Depth 5 -Compress
+ exit 0
+}
 switch($Command){
  'status' {Write-Output 'DEADBYTE MCP = ONLINE';Write-Output 'Bridge PID   : 1001 [verified]';Write-Output 'Cloud PID    : 1002 [verified]';Write-Output 'Local ready  : True';Write-Output 'Loop supervisor: RUNNING [verified]'}
  'processstatus' {Write-Output 'Process plane  : ARMED [standing-grant]'}
@@ -42,9 +48,9 @@ exit 0
    const o={stdout:'',stderr:''};c.stdout.on('data',b=>{o.stdout+=b;});c.stderr.on('data',b=>{o.stderr+=b;});o.exit=new Promise(resolve=>c.once('exit',resolve));children.push(c);outputs.push(o);
   }
   const until=Date.now()+12000;let commands=[];
-  while(Date.now()<until){try{commands=(await readFile(trace,'utf8')).trim().split(/\r?\n/);}catch{}if(commands.includes('hoststatus'))break;await delay(50);}
+  while(Date.now()<until){try{commands=(await readFile(trace,'utf8')).trim().split(/\r?\n/);}catch{}if(outputs.some(o=>o.stdout.includes('[READY]')))break;await delay(50);}
   await writeFile(path.join(root,'observation.json'),JSON.stringify({commands,outputs:outputs.map(o=>({stdout:o.stdout,stderr:o.stderr})),simulation:'concurrent stale marker recovery with delayed second park'}),{flag:'wx'});
-  assert.ok(commands.includes('hoststatus'),'a recovered foreground must become ready');
+  assert.ok(outputs.some(o=>o.stdout.includes('[READY]')),'a recovered foreground must become ready');
   for(const cmd of ['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost'])assert.equal(commands.filter(x=>x===cmd).length,1,`stale recovery must serialize ${cmd}`);
  }finally{
   for(const c of children)if(c.exitCode===null)c.stdin.end();

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