deadbyte-mcp 0.15.33 → 0.15.35

package/TEST-MATRIX.json

@@ -1,7 +1,7 @@
 {
   "schema": "deadbyte.test-matrix.v1",
-  "version": "0.15.33",
-  "train": "R56",
+  "version": "0.15.35",
+  "train": "R58",
   "primary_platform": "win32-x64",
   "reference": {
     "package": "@wonderwhy-er/desktop-commander",
@@ -11,93 +11,170 @@
   },
   "required": [
     {
-      "id": "r56-focused",
-      "command": "npm run r56:focused:test",
-      "expected": "PASS signed rollback handoff launcher restore, ordering, activation recovery regressions, runtime update/slot contracts"
+      "id": "r58-focused",
+      "command": "npm run r58:focused:test",
+      "expected": "PASS frontend/backend/bridge consolidation and inherited update/rollback contracts"
+    },
+    {
+      "id": "performance",
+      "command": "R58 performance benchmark suite",
+      "expected": "No material common-path regression and >=20% aggregate warm p95 improvement where DEADBYTE-owned latency dominates, or evidence-backed external-latency limitation"
+    },
+    {
+      "id": "cross-plane",
+      "command": "R58 cross-plane acceptance",
+      "expected": "PASS isolated frontend/controller/bridge/core lifecycle, stale-session, durable-job, interruption and recovery cases"
     },
     {
       "id": "full-regression",
       "command": "npm run r48:full:test",
-      "expected": "PASS current R56 successor"
+      "expected": "PASS current R58 candidate after final relevant source mutation"
     },
     {
       "id": "package-boundary",
       "command": "node --test test/package-boundary.test.mjs",
-      "expected": "PASS"
+      "expected": "PASS bundled Bridge and canonical launchers/package surface"
     },
     {
       "id": "windows-gate",
       "command": "npm run gate:windows",
-      "expected": "PASS R56 focused + recorded full regression + manifest/doctor evidence"
+      "expected": "PASS R58 focused/performance/cross-plane/full/package/manifest/doctor evidence"
     },
     {
       "id": "package-verify",
       "command": "node scripts/npm-release-r48.mjs --verify-only",
-      "expected": "PASS exact packaged surface and isolated doctor"
+      "expected": "PASS isolated exact packaged surface and doctor"
     },
     {
       "id": "activation",
-      "command": "npx --yes deadbyte-mcp@0.15.33 remote",
-      "expected": "activate exact R56 from exact active 0.15.32"
+      "command": "npx --yes deadbyte-mcp@0.15.35 remote",
+      "expected": "activate exact R58 from exact active 0.15.34"
     },
     {
       "id": "rollback",
-      "command": "runtime-update --rollback-receipt <signed R56 activation receipt>",
-      "expected": "restore exact signed 0.15.32 pointer, signed predecessor launcher snapshot, ONLINE runtime, all authority DISARMED"
+      "command": "runtime-update --rollback-receipt <signed R58 activation receipt>",
+      "expected": "restore exact signed 0.15.34 pointer/runtime, ONLINE, all authority DISARMED"
     },
     {
       "id": "restore",
-      "command": "npx --yes deadbyte-mcp@0.15.33 remote",
-      "expected": "restore same exact R56 release/generation and foreground authority contract"
+      "command": "npx --yes deadbyte-mcp@0.15.35 remote",
+      "expected": "restore exact same immutable R58 release/generation and foreground authority contract"
     }
   ],
   "observed_pre_release_evidence": {
-    "red_parent_0_15_32": {
+    "bridge_dependency_first_red": {
+      "status": "FAIL_EXPECTED",
+      "tests": 3,
+      "failed": 3,
+      "receipt_id": "9ccae28950a898ed6303953f",
+      "receipt_sha256": "81c77105679581b927bd874d74456c057901c05578c8baeb055311bdde668339"
+    },
+    "bridge_dependency_green": {
+      "status": "PASS",
+      "tests": 3,
+      "failed": 0,
+      "receipt_id": "58e4aefc717b305ea95bb719",
+      "receipt_sha256": "46f66b52eb9a761ef1260c15bee618ecda3944a3df3767057aabf0541da3fd9b"
+    },
+    "bundled_bridge_first_red": {
       "status": "FAIL_EXPECTED",
-      "tests": 5,
-      "failed": 5,
-      "receipt_id": "483a2b5bbda756dc85954752",
-      "receipt_sha256": "f3b446306691d61e97896ab4d237abaa20d1243237299812e790233c46451dba"
+      "tests": 2,
+      "failed": 2,
+      "receipt_id": "184fba94cec5527ca276dfb6",
+      "receipt_sha256": "f261242a1d007ee54a233dcb755c7b80db00b0bb1dc7825aed2c6ee3a6fe6d52"
     },
-    "green_r56_candidate": {
+    "bundled_bridge_green": {
       "status": "PASS",
-      "tests": 5,
+      "tests": 2,
       "failed": 0,
-      "receipt_id": "7bf8f8dd93f175f5d7de118a",
-      "receipt_sha256": "4198930f38a3fc4b7978cfc94ca4509127561c170b05f7566bdf79513e449a8b"
+      "receipt_id": "fe63b8ef6299469b4d722e23",
+      "receipt_sha256": "32c8b4b5c4569928b90945d069dbc9fd46008d11114ab421d5ba72c5a117d197"
     },
-    "parent_activation": {
+    "isolated_live_lifecycle": {
       "status": "PASS",
-      "release_id": "v0.15.32-e7223f467777f5df",
-      "manifest_sha256": "e7223f467777f5dfeb20fd2cc7a6eca22619a44ed95e5bc0b32d9c7aabba361b",
-      "generation_manifest_sha256": "740443fd207c5e6ffd5952079214bf6e81e9281a6ec880de9bbe3b8ce1deb00e",
-      "activation_receipt_sha256": "6518a04154f485cfae42e582269634d69a8b05a0183149d5e10006fbdd9d933c"
+      "tests": 1,
+      "failed": 0,
+      "receipt_id": "891a8004a121eba1feb374e1",
+      "receipt_sha256": "1c8454baee9c36ebefc49318a4d31d14cd91644bd91f92ef77ffa4d857788555"
     },
-    "parent_rollback": {
-      "status": "FAIL_EXPECTED",
-      "error": "active pointer launcher digest mismatch",
-      "command_receipt_sha256": "00cbd497e4902c67ab39313a378e2fcf32159113b46339ad1d54b5e5a7714205"
+    "focused_current": {
+      "status": "PASS",
+      "tests": 98,
+      "failed": 0,
+      "receipt_id": "f7571557a3faeafea4af755a",
+      "receipt_sha256": "2225e2506b3a714359194fcb2657d22911eaef34904ab0a031c1e35419f293e7",
+      "request_sha256": "4bd1ac94df92661a950ad7c6b52b062b2c873581ea72868ce411a770b7ab3e67"
+    },
+    "performance": {
+      "status": "PASS_BOUNDED_PREPUBLISH",
+      "summary_sha256": "4586d8462ce1ae643d255315d4b4febfdd3f731dd8728e4b37b5636b622b756c",
+      "stdio_parent_p95_ms": 1.0380999999997584,
+      "stdio_candidate_p95_ms": 1.0587000000000444,
+      "stdio_p95_delta_pct": 1.984392678457768,
+      "bridge_candidate_first_reduction_pct": 63.632445348471286,
+      "bridge_baseline_first_reduction_pct": 43.06594367803213,
+      "receipts": [
+        "63d921dc746b3070ce359a5307d0117bbb2327fa6317bb71ab1906a925b3aa97",
+        "4d3aac8c4bad143dd82a1d2f8b3904fd01862708e24cb11a01285b74548cebe6",
+        "cf8450e1cecbdfb41cf546b8818181c4f5c141e6b050d694af87920c7f7612de",
+        "eff9d7e55cec4d6a778afdda3bb3b8e2e24f7a4addd9bb6ace6eaa2839f2372d"
+      ]
+    },
+    "cross_plane": {
+      "status": "PASS",
+      "tests": 126,
+      "failures": 0,
+      "receipts": [
+        "b57c8c1051655f36116a5bea4d2c6818001daede3e6cc5689049f44495f11153",
+        "e9aef5b21f8bfd4b4737964aa275045383540fc0569bffb57f0b7a1974dda967",
+        "ea1df2285e27758517259195de743ea186817888809c91f7998772acb2ad58c7",
+        "d6d80921d04ccbc7e1ede7ebc63a50157ee33e3f7529f2e75c8120285cbcfd52",
+        "27385e3e27cf7952b89bca8660369f09559f028606cd9e53c5275a178ad5057b"
+      ]
     },
     "full_regression": {
       "status": "PASS",
-      "files": 233,
+      "files": 258,
       "batches": 8,
-      "elapsed_ms": 245761.429,
-      "receipt_id": "3dce7b1649f489fc02b8f055",
-      "receipt_sha256": "35da0a6a0a7d98c08f32f24b5f06df434d353018089acfaf51b9dd51693b7083",
-      "request_sha256": "af035b60299d84e743aa2babaa2321e89555bea4bbb2cd95036f6dc9fe086010"
+      "elapsed_ms": 336694.69,
+      "receipt_id": "bb121ac3ce6b6806f7f46fff",
+      "receipt_sha256": "2d38483435dfc05a30682cd28df80d479f8e2590c636dde5ff3e278372d7463e",
+      "request_sha256": "130a418b22b2aef396a1aa0021bdfa0ba9a57d09af9497dcd2522adbca47aecd"
+    },
+    "package": {
+      "status": "PENDING"
+    },
+    "public_surface": {
+      "status": "PASS",
+      "production_tool_count": 43,
+      "candidate_tool_count": 43,
+      "drift": [],
+      "baseline_catalog_sha256": "ceabd441cc774d03322041155052a28c8fb1c63ae9847199e0278d05c4bd1b28",
+      "names_sha256": "dde7d10e85c52beb285e3adf41b69dece11162ab0bc8233f056e471f653776d6",
+      "schema_sha256": "8efb5cbcd24f1a46ef4588c92d913fa1fd72d7c71a9ad243b151f2b483a7f5cb",
+      "receipt_sha256": "58eefdebe2c456b171eaebf585687bf111ee81f84c92ae968091f4eb056d4c91"
+    },
+    "pre_full_package_process": {
+      "status": "PASS",
+      "tests": 17,
+      "failed": 0,
+      "receipt_id": "f1aa5d06775113d734b94149",
+      "receipt_sha256": "d0dce46d897422f0db690b0cd523e5ab740ffd967e4dc8e265d436d888ccff9f"
     }
   },
   "inherited_parent_evidence": {
-    "version": "0.15.32",
-    "parent_full_regression": "PASS",
-    "parent_manifest_sha256": "e7223f467777f5dfeb20fd2cc7a6eca22619a44ed95e5bc0b32d9c7aabba361b",
-    "parent_tarball_sha256": "c9e1f5875dd2177cee0089305b40321c128c54ce7f5522e34e507d4ecfb22638",
+    "version": "0.15.34",
+    "parent_manifest_sha256": "2199bb59f0e0fc205d470d11f990d3ce3df444be5eba2a7d8dbc60d5f5b790bb",
+    "parent_generation_manifest_sha256": "1a20a62aaeb324a9b5c03d158952f35092d58fedf2ac7725820ba2b094a4a88f",
+    "parent_tarball_sha256": "a6f7b21faf34793ca17dfb6d0e9ec03320f1468d011e75d8349098df82fc2639",
     "parent_registry_identity": "PASS",
-    "four_hour_soak": "NOT_COMPLETED_OPERATOR_BYPASS"
+    "parent_activation_rollback_restore": "PASS",
+    "parent_rollback_receipt_sha256": "2f8aa5784fe6629c25af776b247b22b8e84d1a51c3420339ddd7a7445cf6ff9b",
+    "four_hour_soak": "NOT_COMPLETED"
   },
   "operator_override": {
     "four_hour_soak": "NOT_COMPLETED",
+    "clean_machine": "NOT_COMPLETED",
     "stable_final_claim": false
   },
   "performance": {
@@ -131,6 +208,21 @@
       "signed_handoff_launcher_snapshot_required": true,
       "predecessor_launcher_restored_before_pointer_commit": true,
       "successor_launcher_restored_before_recovery_pointer": true
+    },
+    "r57": {
+      "core_startup_wait_timeout_ms": 10000,
+      "core_startup_poll_ms": 100,
+      "retry_only_zero_child": true,
+      "ambiguous_topology_fail_closed": true
+    },
+    "r58": {
+      "baseline_version": "0.15.34",
+      "candidate_version": "0.15.35",
+      "aggregate_warm_p95_target_reduction_pct": 20,
+      "status": "PASS_BOUNDED_PREPUBLISH",
+      "bridge_baseline_first_p95_reduction_pct": 43.06594367803213,
+      "bridge_candidate_first_p95_reduction_pct": 63.632445348471286,
+      "stdio_p95_delta_pct": 1.984392678457768
     }
   },
   "non_win32": {

package/bridge/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "deadbyte-chatgpt-bridge",
+  "version": "0.15.35",
+  "private": true,
+  "type": "module",
+  "engines": { "node": ">=22" },
+  "dependencies": {
+    "@modelcontextprotocol/client": "2.1.0",
+    "@modelcontextprotocol/server": "2.1.0"
+  }
+}

package/bridge/src/bridge.mjs

@@ -0,0 +1,412 @@
+import { createHash } from 'node:crypto';
+import { createServer } from 'node:http';
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { McpServer, createMcpHandler, createRequestStateCodec, inputRequired, inputResponse } from '@modelcontextprotocol/server';
+import {preparePublicToolDefinitions} from './public-tool-definitions.mjs';
+import {createDeadbyteNodeHandler} from './node-http-adapter.mjs';
+import { bridgeCatalogSha256, bridgeDeadlineForTool, createBridgeGovernor, enforceDesktopBridgeResult, verifyCompactCatalogAttestation } from './r40-governor.mjs';
+
+const coreRoot = path.resolve(process.env.DEADBYTE_CORE_ROOT ?? 'C:/Users/DEADBYTE/Downloads/deadbyte-mcp-v0.6.0');
+const coreServer = path.join(coreRoot, 'src', 'mcp-server.mjs');
+const workspaceRoot = path.resolve(process.env.DEADBYTE_WORKSPACE_ROOT ?? path.join(coreRoot, 'workspaces'));
+const port = Number(process.env.DEADBYTE_BRIDGE_PORT ?? '8787');
+const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'workspace_open'];
+const privilegedTools = ['host_exec', 'host_file_read', 'host_file_write'];
+const agentTools = [
+  'agent_task_approve', 'agent_task_cancel', 'agent_task_events', 'agent_task_run',
+  'agent_task_status', 'agent_task_submit', 'agent_task_verify'
+];
+const codingTools = [
+  'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write',
+  'coding_receipt_verify', 'coding_session_status', 'coding_task_approve', 'coding_task_cancel',
+  'coding_task_events', 'coding_task_run', 'coding_task_status', 'coding_task_submit',
+  'coding_task_verify', 'coding_text_replace', 'coding_tree'
+];
+const autonomousTools = [
+  'autonomous_goal_approve', 'autonomous_goal_cancel', 'autonomous_goal_events',
+  'autonomous_goal_run', 'autonomous_goal_status', 'autonomous_goal_submit',
+  'autonomous_goal_verify', 'autonomous_release_gate', 'autonomous_session_status',
+  'native_diff_apply', 'native_diff_preview', 'native_diff_verify'
+];
+const r35FullTools = [
+  'agent_task_approve','agent_task_cancel','agent_task_events','agent_task_run','agent_task_status','agent_task_submit','agent_task_verify',
+  'autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_events','autonomous_goal_run','autonomous_goal_status','autonomous_goal_submit','autonomous_goal_verify','autonomous_release_gate','autonomous_session_status',
+  'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_files_read','coding_receipt_verify','coding_search','coding_session_status','coding_stat',
+  'coding_symbol_definition','coding_symbol_outline','coding_symbol_references','coding_symbol_replace',
+  'coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run','coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree',
+  'contained_transform','evidence_verify','file_read',
+  'host_exec','host_file_read','host_file_write',
+  'machine_fs_delete','machine_fs_edit_exact','machine_fs_list','machine_fs_mkdir','machine_fs_move','machine_fs_read','machine_fs_stat','machine_fs_write',
+  'machine_list','machine_ping','machine_process_list','machine_revoke','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_status','machine_system_status',
+  'native_diff_apply','native_diff_preview','native_diff_verify',
+  'process_session_action','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate',
+  'proof_execute','workspace_open'
+].sort();
+const r36CompactTools = [
+  'autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_events','autonomous_goal_run','autonomous_goal_status','autonomous_goal_submit','autonomous_goal_verify','autonomous_release_gate','autonomous_session_status',
+  'capability_manifest',
+  'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_inspect','coding_receipt_verify','coding_session_status','coding_symbol_replace',
+  'coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run','coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree',
+  'evidence_verify',
+  'host_exec','host_file_read','host_file_write',
+  'machine_fs','machine_list','machine_observe','machine_ping','machine_revoke','machine_status',
+  'native_diff_apply','native_diff_preview','native_diff_verify',
+  'process_session'
+].sort();
+if (r35FullTools.length !== 73) throw new Error(`R35 production catalog constant drift: ${r35FullTools.length}`);
+if (r36CompactTools.length !== 41) throw new Error(`R36 compact catalog constant drift: ${r36CompactTools.length}`);
+const AUTONOMOUS_DOWNSTREAM_TIMEOUT_MS = 900000;
+const AUTONOMOUS_DOWNSTREAM_TOTAL_MS = 1200000;
+const AUDIT_MAX_STRING_BYTES = 512;
+const AUDIT_MAX_ARRAY_ITEMS = 24;
+const AUDIT_MAX_OBJECT_KEYS = 48;
+const SENSITIVE_AUDIT_KEY = /(token|secret|password|authorization|cookie|recovery|private[_-]?key)/i;
+const PAYLOAD_AUDIT_KEY = /^(content|raw_text|text)$/i;
+let auditSequence = 0;
+const bridgeGovernor = createBridgeGovernor();
+
+function auditDigest(text) {
+  return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+function auditString(value, key = '') {
+  const bytes = Buffer.byteLength(value, 'utf8');
+  if (SENSITIVE_AUDIT_KEY.test(key)) return `<redacted bytes=${bytes} sha256=${auditDigest(value)}>`;
+  if (PAYLOAD_AUDIT_KEY.test(key)) return `<payload bytes=${bytes} sha256=${auditDigest(value)}>`;
+  if (/^(?:Bearer\s+|Basic\s+|sk-[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{12,})/i.test(value)) {
+    return `<redacted bytes=${bytes} sha256=${auditDigest(value)}>`;
+  }
+  if (bytes <= AUDIT_MAX_STRING_BYTES) return value;
+  const prefix = value.slice(0, 256);
+  return `${prefix}<truncated bytes=${bytes} sha256=${auditDigest(value)}>`;
+}
+
+function auditSanitize(value, key = '', depth = 0) {
+  if (value === null || value === undefined) return value ?? null;
+  if (depth > 6) return '<depth-limit>';
+  if (typeof value === 'string') return auditString(value, key);
+  if (typeof value === 'number' || typeof value === 'boolean') return value;
+  if (typeof value === 'bigint') return value.toString();
+  if (Array.isArray(value)) {
+    const out = value.slice(0, AUDIT_MAX_ARRAY_ITEMS).map(item => auditSanitize(item, key, depth + 1));
+    if (value.length > AUDIT_MAX_ARRAY_ITEMS) out.push(`<${value.length - AUDIT_MAX_ARRAY_ITEMS} more items>`);
+    return out;
+  }
+  if (typeof value === 'object') {
+    const entries = Object.entries(value).slice(0, AUDIT_MAX_OBJECT_KEYS);
+    const out = {};
+    for (const [childKey, childValue] of entries) out[childKey] = auditSanitize(childValue, childKey, depth + 1);
+    if (Object.keys(value).length > AUDIT_MAX_OBJECT_KEYS) out._truncated_keys = Object.keys(value).length - AUDIT_MAX_OBJECT_KEYS;
+    return out;
+  }
+  return String(value);
+}
+
+const BRIDGE_LOG_LEVEL = process.env.DEADBYTE_BRIDGE_LOG_LEVEL === 'debug' ? 'debug' : 'human';
+
+function auditWrite(kind, call, payload) {
+  const stamp = new Date().toISOString();
+  const id = String(call.id).padStart(6, '0');
+  console.log(`[TOOL ${kind}] ${stamp} #${id} ${call.name} ${JSON.stringify(auditSanitize(payload))}`);
+}
+
+function compactDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '0ms';
+  if (ms < 10) return `${ms.toFixed(1)}ms`;
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`;
+}
+
+function auditShortReason(result, error = null) {
+  const structured = result?.structuredContent;
+  const candidates = error
+    ? [error?.message ?? String(error)]
+    : [
+        structured?.error, structured?.message, structured?.reason,
+        structured?.result?.error, structured?.result?.message,
+        ...(Array.isArray(result?.content) ? result.content.filter(item => item?.type === 'text').map(item => item.text) : [])
+      ];
+  for (const candidate of candidates) {
+    if (typeof candidate !== 'string' || !candidate) continue;
+    const sanitized = auditString(candidate);
+    const text = String(sanitized).replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+    if (text) return text.length <= 180 ? text : `${text.slice(0, 179)}…`;
+  }
+  return '';
+}
+
+function auditCompactResult(call, { result = null, error = null } = {}) {
+  const elapsedMs = Number(process.hrtime.bigint() - call.started) / 1e6;
+  const failed = error !== null || result?.isError === true;
+  const reason = failed ? auditShortReason(result, error) : '';
+  const stamp = new Date().toISOString();
+  const id = String(call.id).padStart(6, '0');
+  console.log(`[TOOL] ${stamp} #${id} ${failed ? '✗' : '✓'} ${call.name} ${compactDuration(elapsedMs)}${reason ? ` — ${reason}` : ''}`);
+  return elapsedMs;
+}
+
+function auditToolStart(name, args) {
+  const call = { id: ++auditSequence, name, started: process.hrtime.bigint() };
+  if (BRIDGE_LOG_LEVEL === 'debug') auditWrite('IN ', call, args);
+  return call;
+}
+
+function auditToolFinish(call, result) {
+  const elapsedMs = auditCompactResult(call, { result });
+  if (BRIDGE_LOG_LEVEL === 'debug') {
+    auditWrite('OUT', call, {
+      elapsed_ms: Number(elapsedMs.toFixed(3)),
+      is_error: result?.isError === true,
+      structured: result?.structuredContent ?? null,
+      content: result?.content ?? null
+    });
+  }
+}
+
+function auditToolFail(call, error) {
+  const elapsedMs = auditCompactResult(call, { error });
+  if (BRIDGE_LOG_LEVEL === 'debug') {
+    auditWrite('ERR', call, {
+      elapsed_ms: Number(elapsedMs.toFixed(3)),
+      name: error?.name ?? 'Error',
+      message: error?.message ?? String(error)
+    });
+  }
+}
+
+const allowedCatalogs = [];
+for (const host of [false, true]) {
+  for (const agent of [false, true]) {
+    for (const coding of [false, true]) {
+      for (const autonomous of [false, true]) {
+        if (autonomous && !coding) continue;
+        const items = [...baseTools];
+        if (host) items.push(...privilegedTools);
+        if (agent) items.push(...agentTools);
+        if (coding) items.push(...codingTools);
+        if (autonomous) items.push(...autonomousTools);
+        allowedCatalogs.push(items.sort());
+      }
+    }
+  }
+}
+
+function loadToken() {
+  const fromEnv = process.env.DEADBYTE_BRIDGE_PATH_TOKEN ?? '';
+  if (/^[a-f0-9]{64}$/.test(fromEnv)) return fromEnv;
+  const tokenFile = process.env.DEADBYTE_BRIDGE_TOKEN_FILE ?? path.join(os.homedir(), '.deadbyte-mcp', 'bridge', 'path-token.txt');
+  const value = readFileSync(tokenFile, 'utf8').trim();
+  if (!/^[a-f0-9]{64}$/.test(value)) throw new Error(`invalid bridge path token file: ${tokenFile}`);
+  return value;
+}
+
+const token = loadToken();
+const requestStateKey = createHash('sha256')
+  .update('DEADBYTE-R24-MRTR-V1\0', 'utf8')
+  .update(token, 'utf8')
+  .digest();
+const requestStateCodec = createRequestStateCodec({ key: requestStateKey, ttlSeconds: 600 });
+if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('invalid DEADBYTE_BRIDGE_PORT');
+const endpointPath = `/mcp/${token}`;
+
+process.on('uncaughtExceptionMonitor', error => {
+  console.error(`[bridge-fatal-monitor] ${error?.stack ?? String(error)}`);
+});
+process.on('exit', code => {
+  console.error(`[bridge-exit] code=${code}`);
+});
+
+const downstream = new Client(
+  { name: 'deadbyte-chatgpt-bridge', version: '0.2.0' },
+  { versionNegotiation: { mode: { pin: '2026-07-28' } } }
+);
+const downstreamTransport = new StdioClientTransport({
+  command: process.execPath,
+  args: [coreServer],
+  cwd: coreRoot,
+  env: {
+    ...getDefaultEnvironment(),
+    ...process.env,
+    DEADBYTE_WORKSPACE_ROOT: workspaceRoot
+  },
+  stderr: 'pipe'
+});
+
+downstreamTransport.stderr?.on('data', chunk => process.stderr.write(`[deadbyte-core] ${chunk}`));
+await downstream.connect(downstreamTransport);
+if (downstream.getProtocolEra() !== 'modern') throw new Error('DEADBYTE downstream is not modern MCP');
+
+const listed = await downstream.listTools();
+const actualNames = listed.tools.map(tool => tool.name).sort();
+const exactR36Compact = JSON.stringify(actualNames) === JSON.stringify(r36CompactTools);
+let compactCatalogAttestation = null;
+let compactCatalogLegacy = false;
+if (actualNames.includes('capability_manifest')) {
+  const manifestResult = await downstream.callTool(
+    { name:'capability_manifest', arguments:{} },
+    bridgeDeadlineForTool('capability_manifest')
+  );
+  const manifestSchema = manifestResult?.structuredContent?.result?.schema ?? null;
+  if (manifestSchema === 'deadbyte.capability-manifest.v2' || manifestSchema === 'deadbyte.capability-manifest.v3') {
+    compactCatalogAttestation = verifyCompactCatalogAttestation(actualNames, manifestResult);
+  } else if (manifestSchema === 'deadbyte.capability-manifest.v1' && exactR36Compact) {
+    compactCatalogLegacy = true;
+  } else {
+    throw new Error(`DEADBYTE compact catalog attestation unavailable or invalid schema: ${String(manifestSchema)}`);
+  }
+}
+const catalogOk = compactCatalogAttestation?.ok === true || compactCatalogLegacy ||
+  allowedCatalogs.some(expected => JSON.stringify(actualNames) === JSON.stringify(expected)) ||
+  JSON.stringify(actualNames) === JSON.stringify(r35FullTools);
+if (!catalogOk) throw new Error(`DEADBYTE tool catalog mismatch: ${JSON.stringify(actualNames)}`);
+const hostConfigured = privilegedTools.every(name => actualNames.includes(name));
+const agentConfigured = agentTools.every(name => actualNames.includes(name));
+const codingConfigured = codingTools.every(name => actualNames.includes(name));
+const autonomousConfigured = autonomousTools.every(name => actualNames.includes(name));
+const bridgeCatalogDigest = bridgeCatalogSha256(actualNames);
+
+function plannerTextFromInput(ctx) {
+  const response = inputResponse(ctx.mcpReq.inputResponses, 'planner');
+  if (!response || response.kind !== 'sampling') throw new Error('planner sampling response missing');
+  const content = response.result?.content;
+  const block = Array.isArray(content) ? content.find(item => item?.type === 'text') : content;
+  if (!block || block.type !== 'text' || typeof block.text !== 'string') throw new Error('planner sampling response missing text');
+  return { raw_text: block.text, model: typeof response.result?.model === 'string' ? response.result.model.slice(0, 128) : 'client-model' };
+}
+
+const publicToolDefinitions=preparePublicToolDefinitions(listed.tools);
+
+function buildFrontServer() {
+  const front = new McpServer(
+    { name: 'deadbyte-chatgpt-bridge', version: '0.2.0' },
+    { requestState: { verify: requestStateCodec.verify } }
+  );
+  for (const tool of publicToolDefinitions) {
+    const {inputSchema,outputSchema}=tool;
+    front.registerTool(tool.name, {
+      title: tool.title,
+      description: tool.description,
+      inputSchema,
+      outputSchema,
+      annotations: tool.annotations
+    }, async (args, ctx) => {
+      if (tool.name !== 'autonomous_goal_run') {
+        const audit = auditToolStart(tool.name, args);
+        const ticket = await bridgeGovernor.acquire(tool.name);
+        try {
+          const budget = bridgeDeadlineForTool(tool.name);
+          const result = await downstream.callTool({ name: tool.name, arguments: args }, budget);
+          enforceDesktopBridgeResult(tool.name, result);
+          auditToolFinish(audit, result);
+          return result;
+        } catch (error) {
+          auditToolFail(audit, error);
+          throw error;
+        } finally {
+          ticket.release();
+        }
+      }
+      const state = ctx.mcpReq.requestState();
+      const callArgs = { ...args };
+      if (state) {
+        if (state.goal_id !== args.goal_id || typeof state.request_id !== 'string') throw new Error('autonomous planner requestState binding mismatch');
+        const planner = plannerTextFromInput(ctx);
+        callArgs.planner_response = { request_id: state.request_id, raw_text: planner.raw_text, model: planner.model };
+      }
+      const audit = auditToolStart(tool.name, callArgs);
+      const ticket = await bridgeGovernor.acquire(tool.name);
+      let result;
+      try {
+        const budget = bridgeDeadlineForTool(tool.name);
+        result = await downstream.callTool({ name: tool.name, arguments: callArgs }, budget);
+        auditToolFinish(audit, result);
+      } catch (error) {
+        auditToolFail(audit, error);
+        throw error;
+      } finally {
+        ticket.release();
+      }
+      const plannerRequest = result?.structuredContent?.status === 'input_required' ? result.structuredContent.planner_request : null;
+      if (!plannerRequest) return result;
+      if (plannerRequest.request_id === undefined || typeof plannerRequest.prompt !== 'string') throw new Error('autonomous planner request malformed');
+      return inputRequired({
+        inputRequests: {
+          planner: inputRequired.createMessage({
+            messages: [{ role: 'user', content: { type: 'text', text: plannerRequest.prompt } }],
+            maxTokens: 4096,
+            temperature: 0,
+            includeContext: 'none'
+          })
+        },
+        requestState: await requestStateCodec.mint({ goal_id: args.goal_id, request_id: plannerRequest.request_id })
+      });
+    });
+  }
+  return front;
+}
+
+const mcpHandler = createMcpHandler(() => buildFrontServer(), {
+  legacy: 'reject',
+  responseMode: 'json',
+  onerror: error => console.error(`[mcp-http] ${error.stack ?? String(error)}`)
+});
+const nodeMcpHandler = createDeadbyteNodeHandler(mcpHandler);
+const httpServer = createServer(async (req, res) => {
+  try {
+    const pathname = new URL(req.url ?? '/', 'http://127.0.0.1').pathname;
+    if (pathname === '/healthz') {
+      res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+      return res.end('ok');
+    }
+    if (pathname === '/healthz/r40') {
+      res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+      return res.end(JSON.stringify({
+        status:'ok',catalog_sha256:bridgeCatalogDigest,
+        catalog_attestation:compactCatalogAttestation?.ok===true?'verified':compactCatalogLegacy?'legacy-r39':'not-applicable',
+        ledger_sha256:compactCatalogAttestation?.ledger_sha256??null,
+        governor:bridgeGovernor.snapshot()
+      }));
+    }
+    if (pathname !== endpointPath) {
+      res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+      return res.end('not found');
+    }
+    const contentLength = Number(req.headers['content-length'] ?? '0');
+    if (Number.isFinite(contentLength) && contentLength > 1024 * 1024) {
+      res.writeHead(413, { 'content-type': 'text/plain; charset=utf-8' });
+      return res.end('request too large');
+    }
+    await nodeMcpHandler(req, res);
+  } catch (error) {
+    if (!res.headersSent) res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
+    if (!res.writableEnded) res.end('bridge error');
+    console.error(error instanceof Error ? error.stack : String(error));
+  }
+});
+
+await new Promise((resolve, reject) => {
+  httpServer.once('error', reject);
+  httpServer.listen(port, '127.0.0.1', resolve);
+});
+console.log(`BRIDGE_READY http://127.0.0.1:${port}${endpointPath}`);
+console.log(`BRIDGE_TOOLS ${actualNames.join(',')}`);
+console.log(`BRIDGE_CATALOG_SHA256 ${bridgeCatalogDigest}`);
+console.log(`BRIDGE_CATALOG_ATTESTATION ${compactCatalogAttestation?.ok===true?'VERIFIED':compactCatalogLegacy?'LEGACY_R39':'NOT_APPLICABLE'}`);
+console.log(`BRIDGE_HOST_PLANE ${hostConfigured ? 'CONFIGURED_DISARMED_OR_ARMED_BY_LOCAL_LEASE' : 'UNCONFIGURED'}`);
+console.log(`BRIDGE_AGENT_RUNTIME ${agentConfigured ? 'ENABLED' : 'DISABLED'}`);
+console.log(`BRIDGE_CODING_RUNTIME ${codingConfigured ? 'ENABLED' : 'DISABLED'}`);
+console.log(`BRIDGE_AUTONOMOUS_RUNTIME ${autonomousConfigured ? 'ENABLED' : 'DISABLED'}`);
+
+async function shutdown() {
+  httpServer.close();
+  await mcpHandler.close().catch(() => {});
+  await downstream.close().catch(() => {});
+  process.exit(0);
+}
+process.once('SIGINT', shutdown);
+process.once('SIGTERM', shutdown);
+