deadbyte-mcp 0.15.34 → 0.15.36

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

@@ -0,0 +1,50 @@
+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(JSON.parse);
+const currentPackage=await json('package.json');
+
+test('R58 identity is coherent and parent is exact production-accepted 0.15.34',{skip:currentPackage.version!=='0.15.35'},async()=>{
+  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')
+  ]);
+  assert.equal(pkg.version,'0.15.35');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.35'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R58');
+  assert.equal(prov.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R58');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(bridgePkg.version,pkg.version);
+  assert.deepEqual(release.runtime_predecessor,{
+    release_id:'v0.15.34-2199bb59f0e0fc20',
+    manifest_sha256:'2199bb59f0e0fc205d470d11f990d3ce3df444be5eba2a7d8dbc60d5f5b790bb',
+    generation_manifest_sha256:'1a20a62aaeb324a9b5c03d158952f35092d58fedf2ac7725820ba2b094a4a88f'
+  });
+  assert.equal(release.parent.tarball_sha256,'a6f7b21faf34793ca17dfb6d0e9ec03320f1468d011e75d8349098df82fc2639');
+});
+
+test('R58 consolidation evidence preserves fail-closed and non-final claims',{skip:currentPackage.version!=='0.15.35'},async()=>{
+  const [release,prov,matrix]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json')]);
+  assert.equal(release.consolidation.bridge_bundled_inside_release,true);
+  assert.equal(release.consolidation.bridge_recursive_local_dependency_binding,true);
+  assert.equal(release.consolidation.bridge_dynamic_relative_import_fail_closed,true);
+  assert.equal(release.consolidation.bridge_path_escape_fail_closed,true);
+  assert.equal(release.consolidation.performance_acceptance,'PASS_BOUNDED_PREPUBLISH');
+  assert.equal(release.consolidation.cross_plane_acceptance,'PASS');
+  assert.equal(release.consolidation.public_surface_compatibility,'PASS_43_TOOLS_NO_SCHEMA_DRIFT');
+  assert.equal(matrix.observed_pre_release_evidence.cross_plane.status,'PASS');
+  assert.equal(matrix.observed_pre_release_evidence.public_surface.candidate_tool_count,43);
+  assert.equal(matrix.observed_pre_release_evidence.performance.status,'PASS_BOUNDED_PREPUBLISH');
+  assert.ok(['PENDING_R58_FRESH','PASS'].includes(matrix.observed_pre_release_evidence.full_regression.status));
+  assert.equal(prov.operator_override.four_hour_soak,'NOT_COMPLETED');
+  assert.equal(prov.operator_override.clean_machine,'NOT_COMPLETED');
+  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/r58-session-lock.test.mjs

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp} from 'node:fs/promises';
+import path from 'node:path';
+import {spawn} from 'node:child_process';
+import {setTimeout as delay} from 'node:timers/promises';
+import {acquireForegroundSessionLock} from '../src/foreground-session-lock.mjs';
+
+test('R58 startup lock excludes competitors and releases after owner hard death without stale lockfiles',{timeout:15000},async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'session-lock-'));
+ const powershell=path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe');
+ const moduleUrl=new URL('../src/foreground-session-lock.mjs',import.meta.url).href;
+ const script=`const {acquireForegroundSessionLock}=await import(${JSON.stringify(moduleUrl)});await acquireForegroundSessionLock(${JSON.stringify({root,powershell})});console.log('OWNER_LOCK_READY');process.stdin.resume();`;
+ const owner=spawn(process.execPath,['--input-type=module','-e',script],{windowsHide:true,stdio:['pipe','pipe','pipe']});let stdout='',stderr='';
+ owner.stdout.on('data',b=>{stdout+=b;});owner.stderr.on('data',b=>{stderr+=b;});const exited=new Promise(resolve=>owner.once('exit',resolve));
+ let lock;
+ try{
+  const until=Date.now()+4000;while(!stdout.includes('OWNER_LOCK_READY')&&owner.exitCode===null&&Date.now()<until)await delay(20);
+  assert.match(stdout,/OWNER_LOCK_READY/,stderr);
+  await assert.rejects(acquireForegroundSessionLock({root,powershell}),/already claimed/);
+  owner.kill('SIGKILL');await exited;
+  const deadline=Date.now()+5000;
+  while(Date.now()<deadline){try{lock=await acquireForegroundSessionLock({root,powershell});break;}catch(error){if(!/already claimed/.test(error.message))throw error;await delay(20);}}
+  assert.ok(lock,'dead owner must not require manual lockfile removal');lock.assertHeld();await lock.release();lock=null;
+ }finally{if(owner.exitCode===null&&owner.signalCode===null)owner.kill();if(lock)await lock.release();}
+});

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

@@ -0,0 +1,71 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {spawn} from 'node:child_process';
+import {queryForegroundIdentity} from '../src/foreground-process-identity.mjs';
+
+test('R58 inconsistent owner PID binding cannot trigger stale-session authority cleanup', {timeout:20000}, async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'owner-binding-'));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`);
+ const identity=queryForegroundIdentity(process.pid);
+ const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:0,session_nonce:'c'.repeat(64),owner_identity:{...identity,pid:process.pid+1}};
+ const markerPath=path.join(root,'runtime','remote-session.json');const bytes=JSON.stringify(marker);await writeFile(markerPath,bytes);
+ const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+ let stderr='';child.stderr.on('data',b=>{stderr+=b;});child.stdout.resume();
+ const code=await new Promise(resolve=>child.once('close',resolve));
+ await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stderr}),{flag:'wx'});
+ assert.notEqual(code,0);assert.match(stderr,/ownership identity|binding/i);
+ assert.equal(await readFile(trace,'utf8').catch(e=>e.code==='ENOENT'?'':Promise.reject(e)),'','inconsistent marker must cause no controller actions');
+ assert.equal(await readFile(markerPath,'utf8'),bytes,'retain ambiguous ownership evidence');
+});
+
+test('R58 live unrelated PID is not accepted as a remote foreground owner', {timeout:20000}, async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
+ await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'stale-owner-'));
+ 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`);
+ // The test runner is alive but neither a remote CLI nor a guardian. This
+ // represents a stale numeric PID now occupied by an unrelated process.
+ const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:process.pid,session_nonce:'a'.repeat(64),started_at_utc:'2000-01-01T00:00:00.000Z'};
+ await writeFile(path.join(root,'runtime','remote-session.json'),JSON.stringify(marker));
+ const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+ let stdout='',stderr='';child.stdout.on('data',b=>{stdout+=b;});child.stderr.on('data',b=>{stderr+=b;});
+ const code=await new Promise(resolve=>child.once('close',resolve));
+ await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stdout,stderr}),{flag:'wx'});
+ assert.doesNotMatch(stderr,/remote session already active pid=/,'PID alone is not ownership proof');
+ // Fail-closed ambiguity is acceptable; do not kill the unrelated process or
+ // mutate authority based on unverified ownership. Automatic convergence still
+ // requires separately observed exact owner/guardian identity evidence.
+ assert.match(stderr,/identity|ownership|ambiguous|unverified/i);
+ assert.deepEqual(JSON.parse(await readFile(path.join(root,'runtime','remote-session.json'),'utf8')),marker);
+ assert.notEqual(code,0);
+});
+
+test('R58 bound stale birth identity reconciles on the first invocation without killing a reused PID', {timeout:20000}, async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
+ 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`);
+ 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};
+ const markerPath=path.join(root,'runtime','remote-session.json');
+ await writeFile(markerPath,JSON.stringify(marker));
+ const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+ let stdout='',stderr='';child.stdout.on('data',b=>{stdout+=b;});child.stderr.on('data',b=>{stderr+=b;});
+ const code=await new Promise(resolve=>child.once('close',resolve));
+ 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.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');
+ function foregroundAlive(){try{process.kill(process.pid,0);return true;}catch{return false;}}
+});

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

@@ -0,0 +1,32 @@
+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 currentPackage=JSON.parse(await read('package.json'));
+
+test('R58 canonical Windows gate is final-candidate bound and leaves historical gates immutable',{skip:currentPackage.version!=='0.15.35'},async()=>{
+  const [pkgText,gate,evidence,r57Gate,r57Evidence]=await Promise.all([
+    read('package.json'),read('scripts/gate-windows-r58.ps1'),read('scripts/windows-gate-evidence-r58.mjs'),
+    read('scripts/gate-windows-r57.ps1'),read('scripts/windows-gate-evidence-r57.mjs')
+  ]);
+  const pkg=JSON.parse(pkgText);
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r58\.ps1$/);
+  assert.match(pkg.scripts['r58:focused:test'],/scripts\/r58-focused\.ps1$/);
+  assert.match(pkg.scripts['r58:cross-plane:test'],/scripts\/r58-cross-plane\.ps1$/);
+  assert.match(gate,/DEADBYTE 0\.15\.35 \/ R58 WINDOWS GATE: PASS/);
+  assert.match(gate,/r58-package-boundary/);
+  assert.match(gate,/r58-process-policy/);
+  assert.match(gate,/r58-focused-contracts/);
+  assert.match(gate,/full_regression\.status -ne 'PASS'/);
+  assert.match(evidence,/deadbyte\.r58-windows-gate\.v1/);
+  assert.match(evidence,/pkg\.version==='0\.15\.35'/);
+  assert.match(evidence,/release\.train==='R58'/);
+  assert.match(evidence,/release\.parent\?\.version==='0\.15\.34'/);
+  assert.match(evidence,/health\.assessment!==['"]FAIL['"]/);
+  assert.match(evidence,/\['ok','warn'\]\.includes\(health\.status\)/);
+  assert.match(evidence,/four_hour_soak_completed:false/);
+  assert.match(evidence,/clean_machine_completed:false/);
+  assert.match(r57Gate,/DEADBYTE 0\.15\.34 \/ R57 WINDOWS GATE: PASS/);
+  assert.match(r57Evidence,/deadbyte\.r57-windows-gate\.v1/);
+});

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

@@ -0,0 +1,61 @@
+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(JSON.parse);
+
+const PARENT={
+  version:'0.15.35',
+  release_id:'v0.15.35-1b5715b276facbc0',
+  manifest_sha256:'1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4',
+  generation_manifest_sha256:'047e73b62d7b7819b84201a221a09b7e647cacf21f82101ebed4fbd7e23fc430',
+  tarball_sha256:'8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba'
+};
+
+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')
+  ]);
+  assert.equal(pkg.version,'0.15.36');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.36'/);
+  assert.equal(bridgePkg.version,pkg.version);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R59');
+  assert.equal(prov.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R59');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  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.parent.tarball_sha256,PARENT.tarball_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);
+});
+
+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')]);
+  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);
+  assert.equal(release.r59_runtime_hardening.bridge_bounded_reconciliation,true);
+  assert.equal(release.r59_runtime_hardening.mutation_unknown_outcome_no_replay,true);
+  assert.equal(release.r59_runtime_hardening.controller_policy_root_preflight,true);
+  assert.equal(release.r59_runtime_hardening.public_surface_compatibility,'PASS_43_TOOLS_NO_SCHEMA_DRIFT');
+  assert.equal(release.r59_runtime_hardening.frontdoor_signed_ping,'PASS');
+  assert.equal(matrix.observed_pre_release_evidence.r59_contracts.status,'PASS');
+  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.stable_final_claim,false);
+  assert.equal(matrix.operator_override.stable_final_claim,false);
+  assert.equal(release.stabilization.stable_final_claim,false);
+});

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/release-generation.test.mjs

@@ -35,7 +35,7 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   await writeFile(semanticConfigPath,semanticConfigBytes);
   const currentConfig={AgentRuntimeEnabled:true,ProcessRuntimeEnabled:true,CodingRuntimeEnabled:true,MachineFsRuntimeEnabled:true,ObservationRuntimeEnabled:true,DesktopRuntimeEnabled:true,AutonomousRuntimeEnabled:true,AutonomousSupervisorEnabled:true,SemanticLspConfigFile:semanticConfigPath,SemanticLspConfigSha256:sha(semanticConfigBytes),
     Supervisor:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'src\\autonomous-supervisor-host.mjs',WorkingDirectory:'C:/release',ScriptPath:'C:/release/src/autonomous-supervisor-host.mjs',ScriptSha256:'2'.repeat(64)},
-    Bridge:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'bridge.mjs',WorkingDirectory:'C:/bridge',ScriptPath:'C:/bridge/bridge.mjs',ScriptSha256:EXE},
+    Bridge:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'bridge.mjs',WorkingDirectory:'C:/bridge',ScriptPath:'C:/bridge/bridge.mjs',ScriptSha256:EXE,Dependencies:[{Name:'bridge-validator',Path:'C:/bridge/public-tool-definitions.mjs',Sha256:EXE}]},
     Cloud:{FilePath:'C:/deadbyte-tunnel-host.exe',FileSha256:EXE,Arguments:'"C:/cloudflared.exe" "C:/secret/tunnel-token.txt" "C:/bridge"',WorkingDirectory:'C:/release',Transport:'deadbyte.named-tunnel.v2',Dependencies:[
       {Name:'cloudflared',Path:'C:/cloudflared.exe',Sha256:EXE},{Name:'tunnel-token',Path:'C:/secret/tunnel-token.txt',Sha256:EXE}
     ]},
@@ -70,6 +70,9 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const build=args=>createGenerationBundle({...args,systemRoot});
   const result=await build({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   const verified=await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
+  const bridgeConfig=await readFile(result.config_path,'utf8');
+  const bridgeBlock=bridgeConfig.slice(bridgeConfig.indexOf('    Bridge = @{'),bridgeConfig.indexOf('    Cloud = @{'));
+  assert.match(bridgeBlock,/Name = 'bridge-validator'; Path = 'C:\/bridge\/public-tool-definitions.mjs'; Sha256 = '1{64}'/,'generation must not discard explicitly pinned Bridge dependencies');
   assert.equal(verified.files,7);
   const generatedProcess=JSON.parse(await readFile(result.process_policy_path,'utf8'));
   assert.equal(generatedProcess.grant_file,path.join(path.resolve(state),'runtime','process-grant.json'));

package/test/remote-session-cli.test.mjs

@@ -401,7 +401,60 @@ winTest('remote warning lines use deterministic ASCII fallback on piped Windows
   }
 });
 
-winTest('bare remote refuses a second live foreground session without touching authority',async()=>{
+winTest('R58 concurrent cold remote claims have one winner and no loser cleanup',async()=>{
+  const fx=await fixture({statusOnline:true});const children=[],outputs=[];
+  try{
+    for(let i=0;i<3;i++){
+      const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+      children.push(child);outputs.push(await collect(child));
+    }
+    const commands=await waitFor(fx.trace,items=>items.includes('hoststatus'));
+    assert.ok(commands.includes('hoststatus'),outputs.map(o=>o.stderr).join('\n'));
+    const deadline=Date.now()+5000;
+    while(Date.now()<deadline&&children.filter(c=>c.exitCode===null).length>1)await sleep(50);
+    const live=children.filter(c=>c.exitCode===null);
+    assert.equal(live.length,1,'exactly one verified foreground may survive');
+    const trace=await traceCommands(fx.trace);
+    for(const arm of ['armprocess','armcoding','armautonomous'])assert.equal(trace.filter(x=>x===arm).length,1);
+    assert.ok(!trace.some(x=>x.startsWith('disarm')||x==='park'),'losers must not revoke winner authority');
+    for(let i=0;i<children.length;i++)if(children[i]!==live[0])assert.match(outputs[i].stderr,/remote session already (claimed|active)/,'concurrent rejection must have deterministic ownership vocabulary');
+    const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
+    assert.equal(marker.owner_pid,live[0].pid);
+    live[0].stdin.end();assert.equal((await outputs[children.indexOf(live[0])].closed).code,0);
+  }finally{
+    for(const child of children)if(child.exitCode===null)child.kill();
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('R58 duplicate remote verifies the real live owner and leaves its authority untouched',async()=>{
+  const fx=await fixture({statusOnline:true});let first=null,second=null;
+  try{
+    first=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const firstOutput=await collect(first);
+    const commands=await waitFor(fx.trace,items=>items.includes('hoststatus'));
+    assert.ok(commands.includes('hoststatus'),firstOutput.stderr);
+    const before=await traceCommands(fx.trace);
+    const markerPath=path.join(fx.state,'runtime','remote-session.json');
+    const marker=JSON.parse(await readFile(markerPath,'utf8'));
+    assert.equal(marker.owner_identity.pid,first.pid);
+    assert.equal(marker.guardian_identity.parent_pid,first.pid);
+    second=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const secondOutput=await collect(second);
+    const stopped=await secondOutput.closed;
+    assert.notEqual(stopped.code,0);
+    assert.match(secondOutput.stderr,/remote session already active/);
+    assert.deepEqual(await traceCommands(fx.trace),before,'duplicate must not run any controller operation');
+    assert.deepEqual(JSON.parse(await readFile(markerPath,'utf8')),marker);
+    assert.equal(first.exitCode,null,'verified legitimate foreground must survive');
+    first.stdin.end();assert.equal((await firstOutput.closed).code,0,firstOutput.stderr);
+  }finally{
+    if(first?.exitCode===null)first.kill();if(second?.exitCode===null)second.kill();
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('bare remote refuses unverified legacy ownership without touching authority',async()=>{
   const fx=await fixture();
   let child=null;
   try{
@@ -416,7 +469,7 @@ winTest('bare remote refuses a second live foreground session without touching a
     assert.equal(ended.timeout,undefined);
     assert.notEqual(ended.code,0);
     assert.deepEqual(await traceCommands(fx.trace),[]);
-    assert.match(output.stderr,/remote session already active/i);
+    assert.match(output.stderr,/remote session ownership unverified/i);
   }finally{
     if(child?.exitCode===null) child.kill();
     await rm(fx.dir,{recursive:true,force:true});

package/test/runtime-plane-registry-r59.test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createRuntimePlaneRegistry, createUnavailableRuntime } from '../src/runtime-plane-registry.mjs';
+
+test('R59 optional plane failure is isolated and reported as DEGRADED', async () => {
+  const registry=createRuntimePlaneRegistry();
+  registry.define('coding',{configured:true,required:false,dependencies:[]});
+  const value=await registry.initialize('coding',async()=>{throw new Error('missing coding root');});
+  assert.equal(value,null);
+  const state=registry.state('coding');
+  assert.equal(state.state,'DEGRADED');
+  assert.equal(state.ready,false);
+  assert.equal(state.diagnostic.code,'INITIALIZATION_FAILED');
+  assert.match(state.diagnostic.reason,/missing coding root/);
+});
+
+test('R59 dependent plane becomes unavailable without invoking its initializer', async () => {
+  const registry=createRuntimePlaneRegistry();
+  registry.define('coding',{configured:true,required:false,dependencies:[]});
+  registry.define('autonomous',{configured:true,required:false,dependencies:['coding']});
+  await registry.initialize('coding',async()=>{throw new Error('coding down');});
+  let called=false;
+  const value=await registry.initialize('autonomous',async()=>{called=true;return {};});
+  assert.equal(value,null);
+  assert.equal(called,false);
+  assert.equal(registry.state('autonomous').state,'UNAVAILABLE');
+  assert.equal(registry.state('autonomous').diagnostic.code,'DEPENDENCY_UNAVAILABLE');
+});
+
+test('R59 mandatory plane failure remains fail closed', async () => {
+  const registry=createRuntimePlaneRegistry();
+  registry.define('machine',{configured:true,required:true,dependencies:[]});
+  await assert.rejects(registry.initialize('machine',async()=>{throw new Error('identity invalid');}),/identity invalid/);
+});
+
+test('R59 unavailable runtime never performs a delegated operation', async () => {
+  const runtime=createUnavailableRuntime('coding',{code:'INITIALIZATION_FAILED',reason:'missing root'});
+  await assert.rejects(runtime.fileRead({}),error=>error.code==='DEADBYTE_RUNTIME_UNAVAILABLE'&&/missing root/.test(error.message));
+});
+