deadbyte-mcp 0.15.33 → 0.15.35

package/scripts/performance-r58.mjs

@@ -0,0 +1,57 @@
+import { performance } from 'node:perf_hooks';
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { generateTrustKeypair } from '../src/trust.mjs';
+
+// Stage-one stdio measurements only. Never substitutes for bridge/public,
+// machine-bound, mutating or durable-job release acceptance measurements.
+const [targetArg,runArg]=process.argv.slice(2);
+if(!targetArg||!runArg) throw new Error('usage: performance-r58.mjs <package-root> <new-D-testing-run-root>');
+const target=path.resolve(targetArg), run=path.resolve(runArg);
+const allowed=path.resolve('D:/Projects/deadbyte-mcp/testing/0.15.35');
+const relative=path.relative(allowed,run);
+if(!relative||relative.startsWith('..')||path.isAbsolute(relative)) throw new Error('benchmark run must be inside R58 D: testing root');
+await mkdir(run); // Exclusive run identity; never rerun into existing evidence.
+const state=path.join(run,'state'),workspace=path.join(run,'workspace'),demo=path.join(workspace,'demo');
+await mkdir(demo,{recursive:true});await mkdir(state,{recursive:true});
+const fixture='alpha benchmark fixture\n'.repeat(100);
+await writeFile(path.join(demo,'input.txt'),fixture,{flag:'wx'});
+const keys=await generateTrustKeypair({privateKeyPath:path.join(run,'private.pem'),publicKeyPath:path.join(run,'public.pem')});
+const policyPath=path.join(run,'coding-policy.json');
+await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(state,'coding-grant.json'),evidence_dir:path.join(state,'evidence'),roots:{bench:{path:demo,read:true,write:false,exec:false,deny_paths:[]}},commands:{},max_read_bytes:65536,max_write_bytes:65536}),{flag:'wx'});
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sourceHashes={};
+for(const file of ['package.json','MANIFEST.SHA256','src/mcp-server.mjs','src/coding-plane.mjs','src/compact-gateway-mcp-tools.mjs']) sourceHashes[file]=sha(await readFile(path.join(target,file)));
+const workload=[
+ {name:'workspace_open',arguments:{workspace_id:'demo'}},
+ {name:'file_read',arguments:{workspace_id:'demo',path:'input.txt'}},
+ {name:'coding_session_status',arguments:{}}
+];
+const samples=[],cold=[];
+let catalog;
+const start=new Date().toISOString();
+for(let batch=0;batch<3;batch++){
+ const client=new Client({name:'deadbyte-r58-performance',version:'1.0.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+ const transport=new StdioClientTransport({command:process.execPath,args:[path.join(target,'src/mcp-server.mjs')],cwd:target,stderr:'pipe',env:{...getDefaultEnvironment(),DEADBYTE_STATE_ROOT:state,DEADBYTE_WORKSPACE_ROOT:workspace,DEADBYTE_SIGNING_KEY:keys.privateKeyPath,DEADBYTE_VERIFY_KEY:keys.publicKeyPath,DEADBYTE_PRIVILEGED_POLICY:'',DEADBYTE_CODING_RUNTIME:'1',DEADBYTE_CODING_POLICY:policyPath,DEADBYTE_MACHINE_RUNTIME:'0',DEADBYTE_PROCESS_RUNTIME:'0',DEADBYTE_AUTONOMOUS_RUNTIME:'0',DEADBYTE_DESKTOP_RUNTIME:'0',DEADBYTE_CAPABILITY_PROFILE:'full'}});
+ const errors=[];transport.stderr?.on('data',b=>errors.push(b.toString()));
+ try{
+  const connectStart=performance.now();await client.connect(transport);cold.push({batch,connect_ms:performance.now()-connectStart});
+  const tools=(await client.listTools()).tools;
+  if(!catalog){catalog=tools;await writeFile(path.join(run,'catalog.json'),JSON.stringify(tools,null,2),{flag:'wx'});}
+  for(let i=0;i<220;i++)for(const request of workload){
+   const t=performance.now();const result=await client.callTool(request);const elapsed=performance.now()-t;
+   if(result.isError) throw new Error(`benchmark ${request.name} error: ${JSON.stringify(result.structuredContent??result.content)}`);
+   if(request.name==='file_read'&&result.structuredContent?.text!==fixture)throw new Error('file read behavioral oracle failed');
+   if(i>=20)samples.push({batch,iteration:i-20,tool:request.name,total_stdio_roundtrip_ms:elapsed});
+  }
+ }finally{await client.close();await writeFile(path.join(run,`stderr-${batch}.log`),errors.join(''),{flag:'wx'});}
+}
+function summary(values){const v=[...values].sort((a,b)=>a-b);const q=p=>v[Math.ceil(p*v.length)-1];return {n:v.length,min:v[0],p50:q(.5),p90:q(.9),p95:q(.95),p99:q(.99),max:v.at(-1)};}
+const rows=Object.fromEntries(workload.map(w=>[w.name,summary(samples.filter(s=>s.tool===w.name).map(s=>s.total_stdio_roundtrip_ms))]));
+const result={schema:'deadbyte.r58.performance-stage1.v1',status:'MEASURED_NOT_RELEASE_ACCEPTANCE',start,end:new Date().toISOString(),target,node:process.version,sourceHashes,workload_sha256:sha(JSON.stringify(workload)),fixture_sha256:sha(fixture),cold_start:cold,rows,aggregate:summary(samples.map(s=>s.total_stdio_roundtrip_ms)),failures:0,timeouts:0,scope:'stdio client through MCP dispatch/core/response; coding disarmed; no live bridge/cloud or active machine binding',missing:['capability_manifest (compact profile)','machine_status','machine_ping','mutating actions','durable jobs','bridge/cloud','latency decomposition','contention','candidate comparison']};
+await writeFile(path.join(run,'raw.json'),JSON.stringify(samples),{flag:'wx'});
+await writeFile(path.join(run,'summary.json'),JSON.stringify(result,null,2),{flag:'wx'});
+console.log(JSON.stringify(result,null,2));

package/scripts/public-baseline-r58.mjs

@@ -0,0 +1,72 @@
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import { createHash, randomBytes } from 'node:crypto';
+import { performance } from 'node:perf_hooks';
+import path from 'node:path';
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { verifyMachinePingPublic } from '../src/machine-identity.mjs';
+
+const run=path.resolve(process.argv[2]||'');
+const mode=process.argv[3]||'public';
+if(!['public','local'].includes(mode))throw new Error('transport must be public or local');
+const base=path.resolve('D:/Projects/deadbyte-mcp/testing/0.15.35');
+const rel=path.relative(base,run);
+if(!rel||rel.startsWith('..')||path.isAbsolute(rel))throw new Error('new R58 testing run root required');
+await mkdir(run);
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const prod='C:/Users/DEADBYTE/.deadbyte-mcp';
+const before=await readFile(path.join(prod,'active-release.json'));
+const pointer=JSON.parse(before);
+if(pointer.release_id!=='v0.15.34-2199bb59f0e0fc20'||pointer.manifest_sha256!=='2199bb59f0e0fc205d470d11f990d3ce3df444be5eba2a7d8dbc60d5f5b790bb')throw new Error('production baseline changed');
+const config=await readFile(pointer.config_path,'utf8');
+const urlPath=config.match(/McpUrlFile\s*=\s*'([^']+)'/)?.[1];
+const urlHash=config.match(/McpUrlFileSha256\s*=\s*'([0-9a-f]{64})'/)?.[1];
+if(!urlPath||!urlHash)throw new Error('pinned public endpoint metadata missing');
+const bytes=await readFile(urlPath);
+if(sha(bytes)!==urlHash)throw new Error('public endpoint metadata hash mismatch');
+const endpoint=new URL(bytes.toString().trim());
+if(endpoint.protocol!=='https:')throw new Error('HTTPS endpoint required');
+let transportEndpoint=endpoint;
+if(mode==='local'){
+ const readyText=config.match(/LocalReadyUri\s*=\s*'([^']+)'/)?.[1];
+ if(!readyText)throw new Error('pinned loopback readiness address missing');
+ const ready=new URL(readyText);
+ if(ready.protocol!=='http:'||ready.hostname!=='127.0.0.1')throw new Error('local benchmark must use configured loopback only');
+ transportEndpoint=new URL(endpoint.pathname+endpoint.search,ready.origin);
+}
+const client=new Client({name:'deadbyte-r58-public-readonly-baseline',version:'1.0.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+const traceFetch=process.argv[4]==='--trace-fetch';
+const httpEvents=[];
+const measuredFetch=async(input,init)=>{
+ let request;try{request=JSON.parse(init?.body||'null');}catch{}
+ const event={method:request?.method??init?.method??'GET',tool:request?.params?.name??null,started_ms:performance.now()};
+ httpEvents.push(event);
+ const response=await fetch(input,init);
+ event.headers_ms=performance.now();event.fetch_to_headers_ms=event.headers_ms-event.started_ms;
+ event.http_status=response.status;event.content_type=response.headers.get('content-type');
+ const json=response.json.bind(response);
+ response.json=async()=>{const t=performance.now();try{return await json();}finally{event.json_body_ms=performance.now()-t;event.body_finished_ms=performance.now();}};
+ return response;
+};
+const transport=new StreamableHTTPClientTransport(transportEndpoint,traceFetch?{fetch:measuredFetch}:undefined);
+const samples=[];const start=new Date().toISOString();
+function body(result){if(result.isError)throw new Error('public read-only call failed');const s=result.structuredContent;if(!s||typeof s!=='object')throw new Error('structured response missing');return s.result??s;}
+try{
+ await client.connect(transport);
+ const catalog=(await client.listTools()).tools;
+ await writeFile(path.join(run,'catalog.json'),JSON.stringify(catalog,null,2),{flag:'wx'});
+ const status=body(await client.callTool({name:'machine_observe',arguments:{op:'machine_status'}}));
+ if(status.release_id!==pointer.release_id||status.release_manifest_sha256!==pointer.manifest_sha256||status.generation_manifest_sha256!==pointer.generation_manifest_sha256)throw new Error('public machine baseline binding mismatch');
+ for(let i=0;i<100;i++){
+  const nonce=randomBytes(24).toString('hex');const t=performance.now();const eventOffset=httpEvents.length;
+  const ping=body(await client.callTool({name:'machine_observe',arguments:{op:'machine_ping',nonce}}));
+  const elapsed=performance.now()-t;
+  if(ping.nonce!==nonce||ping.release_id!==pointer.release_id||ping.generation_manifest_sha256!==pointer.generation_manifest_sha256||!await verifyMachinePingPublic({ping,publicKeySpkiBase64:status.public_key_spki_base64}))throw new Error('public signed ping independent verification failed');
+  samples.push({tool:'machine_ping',iteration:i,public_roundtrip_ms:elapsed,...(traceFetch?{http_requests:httpEvents.slice(eventOffset).map(e=>({...e,after_body_to_client_ms:e.body_finished_ms===undefined?null:t+elapsed-e.body_finished_ms}))}:{})});
+ }
+ if(!before.equals(await readFile(path.join(prod,'active-release.json'))))throw new Error('production pointer changed during snapshot');
+ const v=samples.map(x=>x.public_roundtrip_ms).sort((a,b)=>a-b),q=p=>v[Math.ceil(v.length*p)-1];
+ const result={schema:'deadbyte.r58.public-baseline.v1',status:'OBSERVED_BASELINE_NOT_CANDIDATE_ACCEPTANCE',transport_scope:mode==='local'?'LOOPBACK_BRIDGE':'HTTPS_PUBLIC',start,end:new Date().toISOString(),pointer,endpoint_metadata_sha256:urlHash,catalog_count:catalog.length,catalog_sha256:sha(JSON.stringify(catalog)),signed_ping_count:samples.length,latency:{n:v.length,min:v[0],p50:q(.5),p90:q(.9),p95:q(.95),p99:q(.99),max:v.at(-1)},limitations:['100 samples only','transport difference is not exact causal layer decomposition','no candidate comparison','read-only observation not authority lifecycle acceptance']};
+ await writeFile(path.join(run,'raw.json'),JSON.stringify(samples),{flag:'wx'});
+ await writeFile(path.join(run,'summary.json'),JSON.stringify(result,null,2),{flag:'wx'});
+ console.log(JSON.stringify({status:result.status,catalog_count:catalog.length,signed_ping_count:samples.length,latency:result.latency}));
+} finally {await client.close();}

package/scripts/public-surface-r58.mjs

@@ -0,0 +1,84 @@
+import {createHash,randomBytes} from 'node:crypto';
+import {createServer} from 'node:net';
+import {mkdir,readFile,writeFile} from 'node:fs/promises';
+import {spawn} from 'node:child_process';
+import {setTimeout as delay} from 'node:timers/promises';
+import path from 'node:path';
+import {Client,StreamableHTTPClientTransport} from '@modelcontextprotocol/client';
+import {generateTrustKeypair} from '../src/trust.mjs';
+
+const [generationArg,baselineArg,runArg]=process.argv.slice(2);
+if(!generationArg||!baselineArg||!runArg) throw new Error('usage: public-surface-r58.mjs <generation-root> <baseline-catalog-json> <new-run-root>');
+const root=path.resolve(new URL('..',import.meta.url).pathname.replace(/^\/(?:[A-Za-z]:)/,m=>m.slice(1)));
+const gen=path.resolve(generationArg),baselinePath=path.resolve(baselineArg),run=path.resolve(runArg);
+const allowed=path.resolve('D:/Projects/deadbyte-mcp/testing/0.15.35'),rel=path.relative(allowed,run);
+if(!rel||rel.startsWith('..')||path.isAbsolute(rel)) throw new Error('run root must be inside R58 testing root');
+await mkdir(run);
+const state=path.join(run,'state');await mkdir(state);
+const keys=await generateTrustKeypair({privateKeyPath:path.join(run,'private.pem'),publicKeyPath:path.join(run,'public.pem')});
+const semanticPath=path.join(gen,'semantic-lsp-config.json');
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const semanticSha=sha(await readFile(semanticPath));
+const baseline=JSON.parse(await readFile(baselinePath,'utf8'));
+const baseSurface=baseline.map(x=>({name:x.name,inputSchema:x.inputSchema,outputSchema:x.outputSchema})).sort((a,b)=>a.name.localeCompare(b.name));
+const reservation=createServer();await new Promise(resolve=>reservation.listen(0,'127.0.0.1',resolve));const port=reservation.address().port;await new Promise(resolve=>reservation.close(resolve));
+const token=randomBytes(32).toString('hex');
+const env={...process.env};for(const key of Object.keys(env))if(key.startsWith('DEADBYTE_'))delete env[key];
+Object.assign(env,{
+ DEADBYTE_CORE_ROOT:root,
+ DEADBYTE_STATE_ROOT:state,
+ DEADBYTE_WORKSPACE_ROOT:path.join(root,'workspaces'),
+ DEADBYTE_BRIDGE_PORT:String(port),
+ DEADBYTE_BRIDGE_PATH_TOKEN:token,
+ DEADBYTE_SIGNING_KEY:keys.privateKeyPath,
+ DEADBYTE_VERIFY_KEY:keys.publicKeyPath,
+ DEADBYTE_CAPABILITY_PROFILE:'compact',
+ DEADBYTE_AUDIT_RUNTIME:'0',
+ DEADBYTE_MACHINE_RUNTIME:'1',
+ DEADBYTE_AGENT_RUNTIME:'1',
+ DEADBYTE_PROCESS_RUNTIME:'1',
+ DEADBYTE_PROCESS_POLICY:path.join(gen,'process-policy.json'),
+ DEADBYTE_CODING_RUNTIME:'1',
+ DEADBYTE_CODING_POLICY:path.join(gen,'coding-policy.json'),
+ DEADBYTE_MACHINE_FS_RUNTIME:'1',
+ DEADBYTE_OBSERVATION_RUNTIME:'1',
+ DEADBYTE_DESKTOP_RUNTIME:'1',
+ DEADBYTE_DESKTOP_POLICY:path.join(gen,'desktop-policy.json'),
+ DEADBYTE_SEMANTIC_LSP_CONFIG:semanticPath,
+ DEADBYTE_SEMANTIC_LSP_CONFIG_SHA256:semanticSha,
+ DEADBYTE_AUTONOMOUS_RUNTIME:'1',
+ DEADBYTE_AUTONOMOUS_POLICY:path.join(gen,'autonomous-policy.json'),
+ DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external',
+ DEADBYTE_PRIVILEGED_POLICY:path.join(gen,'host-policy.json')
+});
+const bridge=path.join(root,'bridge','src','bridge.mjs');
+const child=spawn(process.execPath,[bridge],{cwd:path.join(root,'bridge'),env,windowsHide:true,stdio:['ignore','pipe','pipe']});
+let stdout='',stderr='';child.stdout.on('data',b=>stdout+=b);child.stderr.on('data',b=>stderr+=b);
+const exited=new Promise(resolve=>child.once('exit',code=>resolve(code)));
+try{
+ const deadline=Date.now()+20000;while(!stdout.includes('BRIDGE_READY')&&child.exitCode===null&&Date.now()<deadline)await delay(20);
+ if(!stdout.includes('BRIDGE_READY')) throw new Error('candidate bridge failed startup: '+stderr);
+ const client=new Client({name:'deadbyte-r58-public-surface',version:'1.0.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+ try{
+  await client.connect(new StreamableHTTPClientTransport(new URL(`http://127.0.0.1:${port}/mcp/${token}`)));
+  const listed=(await client.listTools()).tools;
+  const candidate=listed.map(x=>({name:x.name,inputSchema:x.inputSchema,outputSchema:x.outputSchema})).sort((a,b)=>a.name.localeCompare(b.name));
+  const baseNames=baseSurface.map(x=>x.name),candidateNames=candidate.map(x=>x.name);
+  if(JSON.stringify(candidateNames)!==JSON.stringify(baseNames)) throw new Error(`public compact name drift baseline=${baseNames.length} candidate=${candidateNames.length}`);
+  const drift=[];
+  for(let i=0;i<baseSurface.length;i++){
+    if(JSON.stringify(baseSurface[i].inputSchema)!==JSON.stringify(candidate[i].inputSchema)||JSON.stringify(baseSurface[i].outputSchema)!==JSON.stringify(candidate[i].outputSchema)) drift.push(baseSurface[i].name);
+  }
+  if(drift.length) throw new Error('public schema drift: '+drift.join(','));
+  const result={schema:'deadbyte.r58.public-surface-compat.v1',status:'PASS',tool_count:candidate.length,names_sha256:sha(Buffer.from(JSON.stringify(candidateNames))),schema_sha256:sha(Buffer.from(JSON.stringify(candidate))),baseline_catalog_sha256:sha(await readFile(baselinePath)),candidate_bridge_sha256:sha(await readFile(bridge)),drift:[]};
+  await writeFile(path.join(run,'candidate-catalog.json'),JSON.stringify(listed,null,2));
+  await writeFile(path.join(run,'summary.json'),JSON.stringify(result,null,2));
+  console.log(JSON.stringify(result,null,2));
+ }finally{await client.close().catch(()=>{});}
+}finally{
+ child.kill('SIGTERM');
+ await Promise.race([exited,delay(5000)]);
+ if(child.exitCode===null) child.kill();
+ await writeFile(path.join(run,'bridge.stdout.log'),stdout);
+ await writeFile(path.join(run,'bridge.stderr.log'),stderr);
+}

package/scripts/r58-cross-plane.ps1

@@ -0,0 +1,6 @@
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version 3.0
+$root=Split-Path $PSScriptRoot -Parent
+Set-Location -LiteralPath $root
+& node.exe --test --test-concurrency=1 test/r58-concurrent-recovery.test.mjs test/r58-controller-core-observation.test.mjs test/r58-controller-state-coherence.test.mjs test/r58-guardian-channel.test.mjs test/r58-owner-identity.test.mjs test/r58-session-lock.test.mjs test/r58-stale-owner.test.mjs test/remote-session-cli.test.mjs test/coding-runtime.test.mjs test/durable-job-r44.test.mjs test/external-job-provider-r44.test.mjs test/autonomous-local-supervisor.test.mjs test/autonomous-supervisor-integration.test.mjs test/runtime-self-update.test.mjs test/release-slot.test.mjs test/release-activation-gate.test.mjs test/named-tunnel-host.test.mjs test/r56-rollback-launcher-restore.test.mjs test/r57-core-startup-race.test.mjs
+exit $LASTEXITCODE

package/scripts/r58-focused.ps1

@@ -0,0 +1,6 @@
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version 3.0
+$root=Split-Path $PSScriptRoot -Parent
+Set-Location -LiteralPath $root
+& node.exe --test --test-concurrency=1 test/r58-*.test.mjs test/release-generation.test.mjs test/runtime-self-update.test.mjs test/r57-core-startup-race.test.mjs test/r56-rollback-launcher-restore.test.mjs test/r51-runtime-coherence.test.mjs test/production-docs.test.mjs
+exit $LASTEXITCODE

package/scripts/windows-gate-evidence-r57.mjs

@@ -0,0 +1,81 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+const provenance=JSON.parse(await readFile(path.join(root,'PROVENANCE.json'),'utf8'));
+const matrix=JSON.parse(await readFile(path.join(root,'TEST-MATRIX.json'),'utf8'));
+const active=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+const manifestSha256=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+
+insist(pkg.version==='0.15.34'&&release.version===pkg.version&&release.train==='R57','R57 candidate identity mismatch');
+insist(release.parent.version==='0.15.33','R57 parent mismatch');
+insist(release.parent.manifest_sha256==='776a51cb916e28ddc3cbb2ecd3857151a0e73e0aaf83d4e6308e6674125dd01c','R57 parent manifest mismatch');
+insist(release.parent.generation_manifest_sha256==='20ccc5e4bbf8470b61e0a6d2ad181dad5e8533da980ceba7749e1d6f48d9dbd3','R57 parent generation mismatch');
+insist(release.parent.tarball_sha256==='d84a6df0a972a43c50d5e31242d9217f59858b2d73c4284af296da76d2048e5f','R57 parent tarball mismatch');
+insist(
+  active.release_id===release.runtime_predecessor.release_id&&
+  active.manifest_sha256===release.runtime_predecessor.manifest_sha256&&
+  active.generation_manifest_sha256===release.runtime_predecessor.generation_manifest_sha256,
+  'active runtime is not exact sealed 0.15.33 predecessor'
+);
+insist(release.hotfix?.bounded_core_discovery_after_online===true,'R57 bounded core discovery missing');
+insist(release.hotfix?.retry_only_missing_core===true,'R57 zero-child-only retry contract missing');
+insist(release.hotfix?.ambiguous_core_fail_closed===true,'R57 ambiguous-core fail-closed contract missing');
+insist(release.hotfix?.timeout_fail_closed===true,'R57 timeout fail-closed contract missing');
+insist(release.hotfix?.full_regression==='PASS','R57 full regression metadata is not PASS');
+insist(matrix.observed_pre_release_evidence?.full_regression?.status==='PASS','R57 full regression evidence is not PASS');
+insist(provenance.operator_override?.stable_final_claim===false,'R57 must not claim stable/final');
+insist(matrix.operator_override?.four_hour_soak==='NOT_COMPLETED','R57 matrix must preserve soak bypass');
+
+const health=await doctor();
+insist(health.status==='ok'&&health.package_version===pkg.version&&health.manifest?.verified===true,'R57 doctor evidence invalid');
+
+const evidenceBody={
+ schema:'deadbyte.r57-windows-gate.v1',
+ status:'passed',
+ exit_code:0,
+ version:pkg.version,
+ train:'R57',
+ completed_at_utc:new Date().toISOString(),
+ manifest_sha256:manifestSha256,
+ parent:release.parent,
+ runtime_predecessor:release.runtime_predecessor,
+ hotfix:release.hotfix,
+ operator_override:provenance.operator_override,
+ active_predecessor:{
+  release_id:active.release_id,
+  version:active.version,
+  manifest_sha256:active.manifest_sha256,
+  generation_manifest_sha256:active.generation_manifest_sha256
+ },
+ doctor:{verified_entries:health.manifest.verified_entries},
+ gates:{
+  r57_focused:true,
+  package_boundary:true,
+  full_regression:true,
+  manifest_final_verify:true,
+  four_hour_soak_completed:false
+ }
+};
+const bytes=Buffer.from(JSON.stringify(evidenceBody,null,2)+'\n');
+const dir=path.join(stateRoot,'evidence','release');
+await mkdir(dir,{recursive:true});
+const target=path.join(dir,`r57-windows-gate-${manifestSha256.slice(0,16)}.json`);
+try{
+ const handle=await open(target,'wx',0o600);
+ try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+}catch(error){
+ if(error?.code!=='EEXIST')throw error;
+ const prior=JSON.parse(await readFile(target,'utf8'));
+ insist(prior.schema===evidenceBody.schema&&prior.status==='passed'&&prior.version===evidenceBody.version&&prior.manifest_sha256===manifestSha256,'conflicting R57 gate evidence identity');
+}
+console.log(JSON.stringify({status:'passed',path:target,sha256:sha256(bytes),manifest_sha256:manifestSha256}));

package/scripts/windows-gate-evidence-r58.mjs

@@ -0,0 +1,93 @@
+import {createHash} from 'node:crypto';
+import {mkdir,open,readFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {doctor} from '../src/doctor-r45.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const [pkg,release,provenance,matrix,active]=await Promise.all([
+  readFile(path.join(root,'package.json'),'utf8').then(JSON.parse),
+  readFile(path.join(root,'RELEASE.json'),'utf8').then(JSON.parse),
+  readFile(path.join(root,'PROVENANCE.json'),'utf8').then(JSON.parse),
+  readFile(path.join(root,'TEST-MATRIX.json'),'utf8').then(JSON.parse),
+  readFile(path.join(stateRoot,'active-release.json'),'utf8').then(JSON.parse)
+]);
+const manifestSha256=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+
+insist(pkg.version==='0.15.35'&&release.version===pkg.version&&release.train==='R58','R58 candidate identity mismatch');
+insist(provenance.version===pkg.version&&matrix.version===pkg.version&&matrix.train==='R58','R58 release metadata identity mismatch');
+insist(release.parent?.version==='0.15.34','R58 parent version mismatch');
+insist(release.parent?.release_id==='v0.15.34-2199bb59f0e0fc20','R58 parent release mismatch');
+insist(release.parent?.manifest_sha256==='2199bb59f0e0fc205d470d11f990d3ce3df444be5eba2a7d8dbc60d5f5b790bb','R58 parent manifest mismatch');
+insist(release.parent?.generation_manifest_sha256==='1a20a62aaeb324a9b5c03d158952f35092d58fedf2ac7725820ba2b094a4a88f','R58 parent generation mismatch');
+insist(release.parent?.tarball_sha256==='a6f7b21faf34793ca17dfb6d0e9ec03320f1468d011e75d8349098df82fc2639','R58 parent tarball mismatch');
+insist(
+  active.release_id===release.runtime_predecessor.release_id&&
+  active.manifest_sha256===release.runtime_predecessor.manifest_sha256&&
+  active.generation_manifest_sha256===release.runtime_predecessor.generation_manifest_sha256,
+  'active runtime is not exact sealed 0.15.34 predecessor'
+);
+insist(release.consolidation?.bridge_bundled_inside_release===true,'R58 bundled bridge contract missing');
+insist(release.consolidation?.bridge_recursive_local_dependency_binding===true,'R58 recursive bridge dependency contract missing');
+insist(release.consolidation?.performance_acceptance==='PASS_BOUNDED_PREPUBLISH','R58 performance acceptance metadata not green');
+insist(release.consolidation?.cross_plane_acceptance==='PASS','R58 cross-plane acceptance metadata not green');
+insist(release.consolidation?.public_surface_compatibility==='PASS_43_TOOLS_NO_SCHEMA_DRIFT','R58 public surface contract not green');
+insist(matrix.observed_pre_release_evidence?.full_regression?.status==='PASS','R58 fresh full regression evidence not green');
+insist(matrix.observed_pre_release_evidence?.performance?.status==='PASS_BOUNDED_PREPUBLISH','R58 performance evidence not green');
+insist(matrix.observed_pre_release_evidence?.cross_plane?.status==='PASS','R58 cross-plane evidence not green');
+insist(matrix.observed_pre_release_evidence?.public_surface?.status==='PASS','R58 public surface evidence not green');
+insist(provenance.operator_override?.four_hour_soak==='NOT_COMPLETED','R58 must preserve incomplete soak truth');
+insist(provenance.operator_override?.clean_machine==='NOT_COMPLETED','R58 must preserve incomplete clean-machine truth');
+insist(provenance.operator_override?.stable_final_claim===false,'R58 must not claim stable/final before external evidence');
+
+const health=await doctor();
+insist(health.assessment!=='FAIL'&&['ok','warn'].includes(health.status)&&health.package_version===pkg.version&&health.manifest?.verified===true,'R58 doctor evidence invalid');
+
+const evidenceBody={
+ schema:'deadbyte.r58-windows-gate.v1',
+ status:'passed',
+ exit_code:0,
+ version:pkg.version,
+ train:'R58',
+ completed_at_utc:new Date().toISOString(),
+ manifest_sha256:manifestSha256,
+ parent:release.parent,
+ runtime_predecessor:release.runtime_predecessor,
+ consolidation:release.consolidation,
+ operator_override:provenance.operator_override,
+ active_predecessor:{
+   release_id:active.release_id,
+   version:active.version,
+   manifest_sha256:active.manifest_sha256,
+   generation_manifest_sha256:active.generation_manifest_sha256
+ },
+ doctor:{status:health.status,assessment:health.assessment,verified_entries:health.manifest.verified_entries,warnings:health.findings.filter(item=>item.level==='WARN').length},
+ gates:{
+   r58_focused:true,
+   package_boundary:true,
+   process_policy:true,
+   performance_recorded:true,
+   cross_plane_recorded:true,
+   public_surface_recorded:true,
+   full_regression_recorded:true,
+   manifest_final_verify:true,
+   four_hour_soak_completed:false,
+   clean_machine_completed:false
+ }
+};
+const bytes=Buffer.from(JSON.stringify(evidenceBody,null,2)+'\n');
+const dir=path.join(stateRoot,'evidence','release');await mkdir(dir,{recursive:true});
+const target=path.join(dir,`r58-windows-gate-${manifestSha256.slice(0,16)}.json`);
+try{
+ const handle=await open(target,'wx',0o600);
+ try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+}catch(error){
+ if(error?.code!=='EEXIST')throw error;
+ const prior=JSON.parse(await readFile(target,'utf8'));
+ insist(prior.schema===evidenceBody.schema&&prior.status==='passed'&&prior.version===evidenceBody.version&&prior.manifest_sha256===manifestSha256,'conflicting R58 gate evidence identity');
+}
+console.log(JSON.stringify({status:'passed',path:target,sha256:sha256(bytes),manifest_sha256:manifestSha256}));

package/src/deadbyte-cli.mjs

@@ -18,6 +18,8 @@ import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
 import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
 import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
+import {foregroundIdentityMatches,queryForegroundIdentity,validForegroundIdentity} from './foreground-process-identity.mjs';
+import {acquireForegroundSessionLock} from './foreground-session-lock.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -200,7 +202,7 @@ function controllerRuntimeReady(text){
     /^Loop supervisor:\s*RUNNING\s+\[verified\]\s*$/m.test(value);
 }
 function controllerRuntimeDegraded(text){
-  return /^DEADBYTE MCP\s*=\s*DEGRADED\s*$/m.test(String(text||''));
+  return /^DEADBYTE MCP\s*=\s*(?:DEGRADED|FAILED)\s*$/m.test(String(text||''));
 }
 async function listLogFiles(root){
   const auditDir=path.join(root,'audit');
@@ -352,17 +354,20 @@ function remoteTag(kind,displayMode){
 }
 function writeRemote(stream,text,displayMode){stream.write(remoteDisplayText(text,displayMode));}
 async function cleanupRemoteSession(ctx,{displayMode='unicode'}={}){
+  const failed=[];
   for(const command of SESSION_CLEANUP){
     try{
-      const result=invokeController(ctx,command,{allowFailure:true,capture:true,echoCaptured:false});
-      if(result.status!==0) writeRemote(process.stderr,`${remoteTag('warn',displayMode)} cleanup ${command} exit=${result.status}\n`,displayMode);
+      const result=invokeController(ctx,command,{allowFailure:true,capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+      if(result.status!==0){failed.push(command);writeRemote(process.stderr,`${remoteTag('warn',displayMode)} cleanup ${command} exit=${result.status}\n`,displayMode);}
     }
-    catch(error){writeRemote(process.stderr,`${remoteTag('warn',displayMode)} cleanup ${command}: ${String(error?.message||error)}\n`,displayMode);}
+    catch(error){failed.push(command);writeRemote(process.stderr,`${remoteTag('warn',displayMode)} cleanup ${command}: ${String(error?.message||error)}\n`,displayMode);}
   }
+  if(failed.length) throw new Error(`remote session cleanup failed; ownership marker retained: ${failed.join(',')}`);
 }
 const GUARDIAN_SCRIPT=fileURLToPath(new URL('./remote-session-guardian.mjs',import.meta.url));
 function remoteSessionMarker(root){return path.join(root,'runtime','remote-session.json');}
 function pidAlive(pid){
+  if(!Number.isInteger(pid)||pid<1)return false;
   try{process.kill(pid,0);return true;}
   catch(error){return error?.code!=='ESRCH';}
 }
@@ -376,9 +381,10 @@ async function readRemoteSessionMarker(root){
     return value;
   }
   if(value?.schema==='deadbyte.remote-session.v2'){
+    for(const key of ['owner_identity','guardian_identity'])if(value[key]!==undefined&&!validForegroundIdentity(value[key]))throw new Error('remote session ownership identity invalid');
     if(!Number.isInteger(value?.owner_pid)||value.owner_pid<1||
        !/^[0-9a-f]{64}$/.test(String(value?.session_nonce||''))||
-       !Number.isInteger(value?.guardian_pid)||value.guardian_pid<1||
+       !Number.isInteger(value?.guardian_pid)||value.guardian_pid<0||
        (value.result_session_id!==undefined&&!/^[0-9a-f]{24}$/.test(String(value.result_session_id)))) throw new Error('remote session marker schema invalid');
     return value;
   }
@@ -388,8 +394,18 @@ async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
   let prior=await readRemoteSessionMarker(ctx.root);
   if(!prior) return;
   const ownerPid=remoteOwnerPid(prior);
-  if(pidAlive(ownerPid)) throw new Error(`remote session already active pid=${ownerPid}`);
-  if(prior.schema==='deadbyte.remote-session.v2'&&pidAlive(prior.guardian_pid)){
+  if(pidAlive(ownerPid)){
+    if(!prior.owner_identity)throw new Error(`remote session ownership unverified for legacy pid=${ownerPid}; marker retained`);
+    if(prior.owner_identity.pid!==ownerPid)throw new Error('remote session owner identity PID binding mismatch');
+    if(foregroundIdentityMatches(prior.owner_identity,queryForegroundIdentity(ownerPid)))throw new Error(`remote session already active pid=${ownerPid}`);
+  }
+  let guardianAlive=prior.schema==='deadbyte.remote-session.v2'&&pidAlive(prior.guardian_pid);
+  if(guardianAlive){
+    if(!prior.guardian_identity)throw new Error('remote guardian ownership unverified; marker retained');
+    if(prior.guardian_identity.pid!==prior.guardian_pid)throw new Error('remote guardian identity PID binding mismatch');
+    guardianAlive=foregroundIdentityMatches(prior.guardian_identity,queryForegroundIdentity(prior.guardian_pid));
+  }
+  if(guardianAlive){
     const deadline=Date.now()+3000;
     while(Date.now()<deadline){
       await sleep(100);
@@ -409,18 +425,23 @@ async function claimRemoteSession(ctx){
   const resultSessionId=randomBytes(12).toString('hex');
   const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:0,session_nonce:nonce,
     result_session_id:resultSessionId,started_at_utc:new Date().toISOString()};
+  marker.owner_identity=queryForegroundIdentity(process.pid);
+  if(!marker.owner_identity)throw new Error('remote foreground identity unavailable');
   const markerPath=remoteSessionMarker(ctx.root);
   try{await writeFile(markerPath,`${JSON.stringify(marker)}\n`,{encoding:'utf8',flag:'wx'});}
   catch(error){if(error?.code==='EEXIST') throw new Error('remote session already claimed');throw error;}
   let guardian=null;
   try{
-    guardian=spawn(process.execPath,[GUARDIAN_SCRIPT,'--state-root',ctx.root,'--owner-pid',String(process.pid),'--session-nonce',nonce],{
-      detached:true,stdio:'ignore',windowsHide:true,shell:false,env:process.env
+    guardian=spawn(process.execPath,[GUARDIAN_SCRIPT,'--state-root',ctx.root,'--owner-pid',String(process.pid),'--session-nonce',nonce,'--owner-channel','ipc'],{
+      detached:true,stdio:['ignore','ignore','ignore','ipc'],windowsHide:true,shell:false,env:process.env
     });
     if(!Number.isInteger(guardian.pid)||guardian.pid<1) throw new Error('remote session guardian did not start');
     marker.guardian_pid=guardian.pid;
+    marker.guardian_identity=queryForegroundIdentity(guardian.pid);
+    if(!marker.guardian_identity||marker.guardian_identity.parent_pid!==process.pid)throw new Error('remote guardian parent identity mismatch');
     await writeFile(markerPath,`${JSON.stringify(marker)}\n`,'utf8');
     guardian.unref();
+    guardian.channel?.unref();
     return marker;
   }catch(error){
     try{guardian?.kill();}catch{}
@@ -439,8 +460,15 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   const ctx=await remoteContext();
   if(displayMode==='ascii') writeRemote(process.stdout,`[DISPLAY] ASCII fallback: ${display.reason}\n`,displayMode);
   if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{displayMode});
-  await recoverRemoteSession(ctx,{displayMode});
-  const marker=await claimRemoteSession(ctx);
+  const startupLock=await acquireForegroundSessionLock({root:ctx.root,powershell:ctx.powershell});
+  let marker;
+  try{
+    startupLock.assertHeld();
+    await recoverRemoteSession(ctx,{displayMode});
+    startupLock.assertHeld();
+    marker=await claimRemoteSession(ctx);
+    startupLock.assertHeld();
+  }finally{await startupLock.release();}
   try{
     await synchronizeForegroundRuntime(ctx,{displayMode});
   }catch(error){
@@ -475,7 +503,7 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
       process.stdout.write('[BOOT] Runtime already ONLINE; reusing verified bridge/cloud/supervisor.\n');
     }else{
       const recovery=preflight.status===0&&controllerRuntimeDegraded(preflight.stdout);
-      process.stdout.write(recovery?'[RECOVERY] Runtime DEGRADED; restarting verified owned components...\n':'[BOOT] Starting bridge/runtime...\n');
+      process.stdout.write(recovery?'[RECOVERY] Runtime failed readiness; restarting verified owned components...\n':'[BOOT] Starting bridge/runtime...\n');
       const startCommand=recovery?'restart':'start';
       const controllerLogDir=path.join(ctx.root,'runtime','logs');
       await mkdir(controllerLogDir,{recursive:true});

package/src/doctor-foreground-r58.mjs

@@ -0,0 +1,44 @@
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {resolveStateRoot} from './state-root.mjs';
+import {validForegroundIdentity,foregroundIdentityMatches,queryForegroundIdentity} from './foreground-process-identity.mjs';
+
+export async function inspectDoctorForeground(explicitRoot,{queryIdentity=queryForegroundIdentity}={}){
+ const state=resolveStateRoot(explicitRoot),runtime=path.join(state,'runtime');
+ const markerPath=path.join(runtime,'remote-session.json');
+ const findings=[];
+ const add=(id,level,what,evidence,next_action=null)=>findings.push({id,level,what,evidence,next_action});
+ const inspect='Retain ownership evidence; inspect the foreground session and use supported remote lifecycle commands. Do not kill or re-arm based on PID alone.';
+ let marker;
+ try{
+  for(const dir of [state,runtime]){const info=await lstat(dir);if(!info.isDirectory()||info.isSymbolicLink())throw new Error('unsafe marker parent');}
+  const info=await lstat(markerPath);
+  if(!info.isFile()||info.isSymbolicLink()||info.size>16384)throw new Error('invalid marker file');
+  marker=JSON.parse(await readFile(markerPath,'utf8'));
+ }catch(error){
+  if(error?.code==='ENOENT')add('foreground_marker','PASS','No foreground session marker in this state root.',{present:false});
+  else add('foreground_marker','FAIL','Foreground marker cannot be safely read or parsed.',{check:'regular_bounded_json',error_code:error?.code??'VALIDATION_FAILED'},inspect);
+  return {status:findings[0].level,findings};
+ }
+ if(marker?.schema==='deadbyte.remote-session.v1'&&Number.isSafeInteger(marker.pid)&&marker.pid>0){
+  add('foreground_marker','WARN','Legacy foreground marker has no verified owner/guardian binding.',{schema:marker.schema,pid:marker.pid},inspect);
+  return {status:'WARN',findings};
+ }
+ if(marker?.schema!=='deadbyte.remote-session.v2'||!Number.isSafeInteger(marker.owner_pid)||marker.owner_pid<1||!Number.isSafeInteger(marker.guardian_pid)||marker.guardian_pid<0||typeof marker.session_nonce!=='string'||!/^[0-9a-f]{64}$/.test(marker.session_nonce)||(marker.result_session_id!==undefined&&!/^[0-9a-f]{24}$/.test(marker.result_session_id))){
+  add('foreground_marker','FAIL','Foreground marker schema, nonce or PID fields are invalid.',{check:'foreground_marker_schema'},inspect);
+  return {status:'FAIL',findings};
+ }
+ add('foreground_marker','PASS','Foreground marker fields are valid.',{schema:marker.schema,owner_pid:marker.owner_pid,guardian_pid:marker.guardian_pid});
+ for(const [role,pid,identity]of [['owner',marker.owner_pid,marker.owner_identity],['guardian',marker.guardian_pid,marker.guardian_identity]]){
+  const id='foreground_'+role;
+  if(identity===undefined){add(id,'WARN',`${role} identity is unverified; PID alone is insufficient.`,{pid,binding_present:false},inspect);continue;}
+  if(!validForegroundIdentity(identity)||identity.pid!==pid){add(id,'FAIL',`${role} identity is malformed or disagrees with the marker PID.`,{pid,check:'identity_pid_binding'},inspect);continue;}
+  if(role==='guardian'&&identity.parent_pid!==marker.owner_pid){add(id,'FAIL','Guardian identity does not bind to the declared owner.',{pid,check:'guardian_parent_binding'},inspect);continue;}
+  try{
+   const observed=await queryIdentity(pid);
+   if(foregroundIdentityMatches(identity,observed))add(id,'PASS',`${role} process matches the recorded birth/executable/command identity.`,{pid,creation_utc:identity.creation_utc,identity_verified:true});
+   else add(id,'WARN',`${role} binding is stale; process is absent or its identity changed.`,{pid,observed_present:observed!==null,identity_verified:false},inspect);
+  }catch(error){add(id,'FAIL',`${role} process identity observation failed; liveness is unknown.`,{pid,check:'process_identity',error_code:error?.code??'OBSERVATION_FAILED'},inspect);}
+ }
+ return {status:findings.some(f=>f.level==='FAIL')?'FAIL':findings.some(f=>f.level==='WARN')?'WARN':'PASS',findings};
+}