deadbyte-mcp 0.15.34 → 0.15.35

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

package/bridge/src/node-http-adapter.mjs

@@ -0,0 +1,56 @@
+import {once} from 'node:events';
+
+function requestHeaders(headers){
+  const out=new Headers();
+  for(const [name,value] of Object.entries(headers??{})){
+    if(value===undefined) continue;
+    if(Array.isArray(value)){for(const item of value) out.append(name,String(item));}
+    else out.append(name,String(value));
+  }
+  return out;
+}
+async function requestBody(req,maxBodyBytes){
+  const method=String(req.method??'GET').toUpperCase();
+  if(method==='GET'||method==='HEAD') return undefined;
+  const chunks=[];let total=0;
+  for await(const chunk of req){
+    const bytes=Buffer.isBuffer(chunk)?chunk:Buffer.from(chunk);
+    total+=bytes.length;
+    if(total>maxBodyBytes) throw new Error(`bridge request body exceeds ${maxBodyBytes} bytes`);
+    chunks.push(bytes);
+  }
+  return Buffer.concat(chunks,total);
+}
+async function writeResponse(res,response){
+  const headers={};
+  for(const [name,value] of response.headers.entries()) headers[name]=value;
+  res.writeHead(response.status,headers);
+  if(!response.body){res.end();return;}
+  const reader=response.body.getReader();
+  try{
+    while(true){
+      const {done,value}=await reader.read();
+      if(done) break;
+      if(res.destroyed){await reader.cancel().catch(()=>{});return;}
+      if(!res.write(value)) await once(res,'drain');
+    }
+  }finally{reader.releaseLock();}
+  if(!res.destroyed) res.end();
+}
+
+export function createDeadbyteNodeHandler(handler,{maxBodyBytes=1024*1024}={}){
+  if(!handler||typeof handler.fetch!=='function') throw new Error('bridge node adapter requires fetch-shaped MCP handler');
+  if(!Number.isInteger(maxBodyBytes)||maxBodyBytes<1024||maxBodyBytes>4*1024*1024) throw new Error('bridge node adapter maxBodyBytes invalid');
+  return async function nodeHandler(req,res){
+    const method=String(req.method??'GET').toUpperCase();
+    const url=new URL(String(req.url??'/'),'http://127.0.0.1');
+    const body=await requestBody(req,maxBodyBytes);
+    const init={method,headers:requestHeaders(req.headers)};
+    if(body!==undefined) init.body=body;
+    const request=new Request(url,init);
+    const options=req.auth?{authInfo:req.auth}:undefined;
+    const response=await handler.fetch(request,options);
+    if(!(response instanceof Response)) throw new Error('bridge MCP handler returned non-Response');
+    await writeResponse(res,response);
+  };
+}

package/bridge/src/public-tool-definitions.mjs

@@ -0,0 +1,14 @@
+import {fromJsonSchema} from '@modelcontextprotocol/server';
+
+// Catalog is fixed by the existing downstream startup attestation. Only schema
+// definitions/validators are shared; servers, callbacks and requestState aren't.
+export function preparePublicToolDefinitions(tools){
+ return Object.freeze(tools.map(tool=>{
+  const input=structuredClone(tool.inputSchema??{type:'object',properties:{},additionalProperties:false});
+  if(tool.name==='autonomous_goal_run'){
+   if(input.properties&&typeof input.properties==='object')delete input.properties.planner_response;
+   if(Array.isArray(input.required))input.required=input.required.filter(name=>name!=='planner_response');
+  }
+  return Object.freeze({...tool,inputSchema:fromJsonSchema(input),outputSchema:tool.outputSchema?fromJsonSchema(tool.outputSchema):undefined});
+ }));
+}

package/bridge/src/r40-governor.mjs

@@ -0,0 +1,160 @@
+import { createHash } from 'node:crypto';
+
+const DESKTOP_RAW_KEYS=new Set([
+  'pixels','pixel_bytes','frame_bytes','raw_bgra','raw_rgba','raw_image','screenshot_bytes','bitmap_bytes'
+]);
+const DEFAULT_LIMITS=Object.freeze({
+  normal:Object.freeze({max_active:8,max_queue:32,queue_timeout_ms:30000}),
+  autonomous:Object.freeze({max_active:2,max_queue:8,queue_timeout_ms:60000}),
+  desktop_observe:Object.freeze({max_active:2,max_queue:4,queue_timeout_ms:10000}),
+  desktop_action:Object.freeze({max_active:1,max_queue:2,queue_timeout_ms:5000})
+});
+const DEADLINES=Object.freeze({
+  normal:Object.freeze({timeout:120000,maxTotalTimeout:180000}),
+  autonomous:Object.freeze({timeout:900000,maxTotalTimeout:1200000}),
+  desktop_observe:Object.freeze({timeout:30000,maxTotalTimeout:60000}),
+  desktop_action:Object.freeze({timeout:30000,maxTotalTimeout:45000})
+});
+
+function insist(condition,message){ if(!condition) throw new Error(message); }
+function toolClass(name){
+  const value=String(name??'');
+  if(value==='autonomous_goal_run') return 'autonomous';
+  if(value==='desktop_action') return 'desktop_action';
+  if(value.startsWith('desktop_')) return 'desktop_observe';
+  return 'normal';
+}
+function estimateBase64Bytes(value){
+  if(typeof value!=='string') return 0;
+  const clean=value.replace(/\s/g,'');
+  if(clean.length===0) return 0;
+  const padding=clean.endsWith('==')?2:clean.endsWith('=')?1:0;
+  return Math.floor(clean.length*3/4)-padding;
+}
+function scanDesktopPayload(value,{maxPreviewBytes},path='result',seen=new Set()){
+  if(value===null||value===undefined) return;
+  if(typeof value==='string'||typeof value==='number'||typeof value==='boolean') return;
+  if(typeof value!=='object') return;
+  if(seen.has(value)) throw new Error('bridge desktop result contains cyclic value');
+  seen.add(value);
+  if(Array.isArray(value)){
+    for(let i=0;i<value.length;i++) scanDesktopPayload(value[i],{maxPreviewBytes},`${path}[${i}]`,seen);
+    seen.delete(value); return;
+  }
+  for(const [key,child] of Object.entries(value)){
+    const lower=key.toLowerCase();
+    if(DESKTOP_RAW_KEYS.has(lower)) throw new Error(`bridge desktop result contains forbidden raw frame field '${path}.${key}'`);
+    if((lower==='preview_png_base64'||lower==='preview_jpeg_base64')&&typeof child==='string'){
+      const bytes=estimateBase64Bytes(child);
+      if(bytes>maxPreviewBytes) throw new Error(`bridge desktop preview exceeds ${maxPreviewBytes} byte limit`);
+    }
+    if(lower==='data'&&value.type==='image'&&typeof child==='string'){
+      const bytes=estimateBase64Bytes(child);
+      if(bytes>maxPreviewBytes) throw new Error(`bridge MCP image content exceeds ${maxPreviewBytes} byte limit`);
+    }
+    scanDesktopPayload(child,{maxPreviewBytes},`${path}.${key}`,seen);
+  }
+  seen.delete(value);
+}
+
+export function bridgeToolClass(name){ return toolClass(name); }
+export function bridgeDeadlineForTool(name){ return DEADLINES[toolClass(name)]; }
+export function bridgeCatalogSha256(toolNames){
+  insist(Array.isArray(toolNames)&&toolNames.every(x=>typeof x==='string'),'bridge catalog names invalid');
+  const sorted=[...new Set(toolNames)].sort();
+  insist(sorted.length===toolNames.length,'bridge catalog contains duplicate tool name');
+  return createHash('sha256').update(JSON.stringify(sorted),'utf8').digest('hex');
+}
+export function verifyCompactCatalogAttestation(actualNames,toolResult){
+  insist(Array.isArray(actualNames)&&actualNames.every(x=>typeof x==='string'&&x.length>0),'actual bridge catalog invalid');
+  const actual=[...actualNames].sort();
+  insist(new Set(actual).size===actual.length,'actual bridge catalog contains duplicate tool name');
+  const envelope=toolResult?.structuredContent;
+  insist(envelope?.status==='ok'&&envelope?.op==='manifest','capability manifest tool result invalid');
+  const manifest=envelope.result;
+  insist(manifest?.schema==='deadbyte.capability-manifest.v2'||manifest?.schema==='deadbyte.capability-manifest.v3','capability manifest schema mismatch');
+  insist(manifest.profile==='compact','capability manifest profile mismatch');
+  insist(typeof manifest.ledger_sha256==='string'&&/^[0-9a-f]{64}$/.test(manifest.ledger_sha256),'capability manifest ledger hash invalid');
+  insist(Array.isArray(manifest.tool_catalog)&&manifest.tool_catalog.every(x=>typeof x==='string'&&x.length>0),'capability manifest tool_catalog invalid');
+  const declared=[...manifest.tool_catalog];
+  insist(declared.length===manifest.tool_count,'capability manifest tool_count mismatch');
+  insist(new Set(declared).size===declared.length,'capability manifest catalog contains duplicate tool name');
+  insist(JSON.stringify(declared)===JSON.stringify([...declared].sort()),'capability manifest catalog must be sorted');
+  const declaredSha=bridgeCatalogSha256(declared);
+  insist(declaredSha===manifest.catalog_sha256,'capability manifest catalog hash mismatch');
+  insist(JSON.stringify(actual)===JSON.stringify(declared),'bridge listTools/catalog attestation mismatch');
+  return Object.freeze({
+    ok:true,profile:'compact',tool_count:declared.length,catalog_sha256:declaredSha,ledger_sha256:manifest.ledger_sha256
+  });
+}
+
+export function enforceDesktopBridgeResult(toolName,result,{maxPreviewBytes=1024*1024}={}){
+  if(!String(toolName??'').startsWith('desktop_')) return result;
+  insist(Number.isInteger(maxPreviewBytes)&&maxPreviewBytes>=16*1024&&maxPreviewBytes<=4*1024*1024,'maxPreviewBytes invalid');
+  scanDesktopPayload(result,{maxPreviewBytes});
+  return result;
+}
+
+export function createBridgeGovernor({limits=DEFAULT_LIMITS}={}){
+  const classes=['normal','autonomous','desktop_observe','desktop_action'];
+  for(const name of classes){
+    const cfg=limits[name];
+    insist(cfg&&Number.isInteger(cfg.max_active)&&cfg.max_active>=1&&cfg.max_active<=64,`bridge limit ${name}.max_active invalid`);
+    insist(Number.isInteger(cfg.max_queue)&&cfg.max_queue>=0&&cfg.max_queue<=256,`bridge limit ${name}.max_queue invalid`);
+    insist(Number.isInteger(cfg.queue_timeout_ms)&&cfg.queue_timeout_ms>=100&&cfg.queue_timeout_ms<=120000,`bridge limit ${name}.queue_timeout_ms invalid`);
+  }
+  const state=new Map(classes.map(name=>[name,{active:0,queue:[]}]));
+  let sequence=0;
+
+  function dispatch(name){
+    const cfg=limits[name],s=state.get(name);
+    while(s.active<cfg.max_active&&s.queue.length){
+      const waiter=s.queue.shift();
+      if(waiter.done) continue;
+      waiter.done=true; clearTimeout(waiter.timer); s.active++;
+      waiter.resolve(makeTicket(name,waiter.tool,waiter.id,waiter.queuedAt));
+    }
+  }
+  function makeTicket(name,tool,id,queuedAt){
+    let released=false;
+    return Object.freeze({
+      id,class:name,tool,queued_ms:Math.max(0,Date.now()-queuedAt),
+      release(){
+        if(released) return false;
+        released=true;
+        const s=state.get(name);
+        s.active=Math.max(0,s.active-1);
+        dispatch(name);
+        return true;
+      }
+    });
+  }
+  async function acquire(tool){
+    const name=toolClass(tool),cfg=limits[name],s=state.get(name),id=++sequence,queuedAt=Date.now();
+    if(s.active<cfg.max_active){
+      s.active++;
+      return makeTicket(name,String(tool),id,queuedAt);
+    }
+    if(s.queue.length>=cfg.max_queue) throw new Error(`bridge backpressure queue full for ${name}`);
+    return await new Promise((resolve,reject)=>{
+      const waiter={id,tool:String(tool),queuedAt,resolve,reject,done:false,timer:null};
+      waiter.timer=setTimeout(()=>{
+        if(waiter.done)return;
+        waiter.done=true;
+        const index=s.queue.indexOf(waiter); if(index>=0)s.queue.splice(index,1);
+        reject(new Error(`bridge backpressure queue timeout for ${name}`));
+      },cfg.queue_timeout_ms);
+      s.queue.push(waiter);
+    });
+  }
+  function snapshot(){
+    return Object.freeze(Object.fromEntries(classes.map(name=>{
+      const s=state.get(name),cfg=limits[name];
+      return [name,Object.freeze({active:s.active,queued:s.queue.filter(x=>!x.done).length,max_active:cfg.max_active,max_queue:cfg.max_queue})];
+    })));
+  }
+  return Object.freeze({acquire,snapshot});
+}
+
+export const BRIDGE_R40_DEFAULT_LIMITS=DEFAULT_LIMITS;
+