deadbyte-mcp 0.8.10 → 0.10.0

package/src/process-runtime.mjs

@@ -1,5 +1,5 @@
 import { createHash, randomBytes, sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
-import { appendFile, lstat, mkdir, readFile, realpath } from 'node:fs/promises';
+import { appendFile, lstat, mkdir, readFile, readdir, realpath, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { canonicalJson } from './canonical-json.mjs';
@@ -13,6 +13,7 @@ const ZERO_SHA256 = '0'.repeat(64);
 const SHA256_RE = /^[0-9a-f]{64}$/;
 const READY_PREFIX = Buffer.from('DEADBYTE_PROCESS_HOST_READY ', 'utf8');
 const START_TIMEOUT_MS = 8000;
+const TERMINAL_RECOVERY_SCHEMA = 'deadbyte.process-terminal.v1';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const nowUtc = () => new Date().toISOString();
@@ -101,15 +102,85 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
   const sessions = new Map();
   let signingPromise = null;
   let verifyPromise = null;
+  let hydrationPromise = null;
   const runtime = {
     policy,
     signing: () => (signingPromise ??= loadPrivateSigningKey(signingKeyPath)),
     verifying: () => (verifyPromise ??= loadPublicVerifyKey(verifyKeyPath))
   };
 
-  function sessionFor(sessionId) {
+  async function readVerifiedJournal(sessionId, journalPath) {
+    const verifying = await runtime.verifying();
+    const text = await readFile(journalPath, 'utf8');
+    const records = text.split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));
+    let previous = ZERO_SHA256;
+    let sequence = 0;
+    for (const record of records) {
+      const { event_sha256: eventSha, key_id: keyId, signature, ...unsigned } = record;
+      if (unsigned.schema !== EVENT_SCHEMA || unsigned.session_id !== sessionId || unsigned.sequence !== sequence + 1 ||
+          unsigned.previous_event_sha256 !== previous || unsigned.policy_sha256 !== policy.policy_sha256) {
+        throw new Error('process event journal chain mismatch');
+      }
+      const canonical = Buffer.from(canonicalJson(unsigned), 'utf8');
+      const observedSha = sha256Bytes(canonical);
+      if (eventSha !== observedSha || keyId !== verifying.keyId || typeof signature !== 'string' || !cryptoVerify(null,
+          Buffer.concat([EVENT_DOMAIN, canonical]), verifying.publicKey, Buffer.from(signature, 'base64'))) {
+        throw new Error('process event journal signature mismatch');
+      }
+      previous = observedSha;
+      sequence += 1;
+    }
+    return { records, event_count: sequence, head_sha256: previous };
+  }
+
+  async function hydrateTerminalSessions() {
+    if (hydrationPromise) return hydrationPromise;
+    hydrationPromise = (async () => {
+      await mkdir(policy.state_dir, { recursive: true });
+      const names = (await readdir(policy.state_dir)).filter(name => /^[0-9a-f]{64}\.jsonl$/.test(name)).sort();
+      for (const name of names) {
+        const sessionId = name.slice(0, 64);
+        if (sessions.has(sessionId)) continue;
+        let checked;
+        try { checked = await readVerifiedJournal(sessionId, path.join(policy.state_dir, name)); }
+        catch { continue; }
+        const terminal = checked.records.at(-1);
+        if (!terminal || !['exited','terminated'].includes(terminal.type) || terminal.detail?.recovery_schema !== TERMINAL_RECOVERY_SCHEMA) continue;
+        const started = checked.records.find(record => record.type === 'started');
+        if (!started || !Number.isInteger(started.detail?.child_pid) || !/^[0-9]+$/.test(String(started.detail?.creation_filetime ?? ''))) continue;
+        const profile = policy.profiles[terminal.profile_id];
+        if (!profile || !policy.roots[terminal.root_id]) continue;
+        const outputFile = terminal.detail.output_file;
+        if (typeof outputFile !== 'string' || outputFile !== `${sessionId}.stream.bin`) continue;
+        let output;
+        try { output = await readFile(path.join(policy.state_dir, outputFile)); }
+        catch { continue; }
+        if (!Number.isInteger(terminal.detail.retained_output_bytes) || terminal.detail.retained_output_bytes !== output.length ||
+            !SHA256_RE.test(terminal.detail.retained_output_sha256 ?? '') || sha256Bytes(output) !== terminal.detail.retained_output_sha256 ||
+            !SHA256_RE.test(terminal.detail.stream_sha256 ?? '') || !Number.isInteger(terminal.detail.stream_head) ||
+            !Number.isInteger(terminal.detail.earliest_offset) || terminal.detail.earliest_offset < 0 ||
+            terminal.detail.stream_head < terminal.detail.earliest_offset || terminal.detail.stream_head - terminal.detail.earliest_offset !== output.length) continue;
+        sessions.set(sessionId, {
+          session_id:sessionId, job_id:null, profile_id:terminal.profile_id, root_id:terminal.root_id,
+          cwd_relative:typeof started.detail?.cwd === 'string' ? started.detail.cwd : '.',
+          child_pid:started.detail.child_pid, creation_filetime:String(started.detail.creation_filetime),
+          state:terminal.type, exit_code:Number.isInteger(terminal.detail.exit_code) ? terminal.detail.exit_code : null,
+          earliest_offset:terminal.detail.earliest_offset, stream_head:terminal.detail.stream_head,
+          stream_sha256:terminal.detail.stream_sha256, output, control_buffer:Buffer.alloc(0),
+          journal_head_sha256:checked.head_sha256, journal_path:path.join(policy.state_dir,name), event_count:checked.event_count,
+          max_retained_output_bytes:profile.max_retained_output_bytes, stderr:'', terminate_requested:terminal.type==='terminated',
+          protocol_error:null, transport:profile.transport, win32_input_mode:false, host:null, close_promise:Promise.resolve(),
+          recovered_terminal:true
+        });
+      }
+    })();
+    return hydrationPromise;
+  }
+
+  async function sessionFor(sessionId) {
     if (typeof sessionId !== 'string' || !SHA256_RE.test(sessionId)) throw new Error('invalid process session id');
-    const session = sessions.get(sessionId);
+    let session = sessions.get(sessionId);
+    if (!session) { await hydrateTerminalSessions(); session = sessions.get(sessionId); }
     if (!session) throw new Error(`unknown process session '${sessionId}'`);
     return session;
   }
@@ -172,6 +243,7 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
   }
 
   async function start({ profileId, rootId, cwd = '.', args = [] }) {
+    await hydrateTerminalSessions();
     const grant = await assertProcessArmed(policy, profileId, rootId);
     const profile = policy.profiles[profileId];
     if (!profile) throw new Error(`process profile '${profileId}' is not configured`);
@@ -209,8 +281,23 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
         parseHostOutput(session, null, true);
         if (session.state === 'starting') session.ready_reject?.(new Error(`process host exited before READY: ${session.stderr}`));
         session.exit_code ??= Number.isInteger(code) ? code : null;
-        session.state = session.terminate_requested ? 'terminated' : 'exited';
-        try { await appendEvent(runtime, session, session.state, { exit_code: session.exit_code }); } catch {}
+        const terminalState = session.terminate_requested ? 'terminated' : 'exited';
+        try {
+          const outputFile = `${session.session_id}.stream.bin`;
+          const retainedOutputSha256 = sha256Bytes(session.output);
+          await writeFile(path.join(policy.state_dir, outputFile), session.output, { flag:'wx' });
+          await appendEvent(runtime, session, terminalState, {
+            recovery_schema:TERMINAL_RECOVERY_SCHEMA,
+            exit_code:session.exit_code,
+            earliest_offset:session.earliest_offset,
+            stream_head:session.stream_head,
+            stream_sha256:session.stream_sha256,
+            retained_output_bytes:session.output.length,
+            retained_output_sha256:retainedOutputSha256,
+            output_file:outputFile
+          });
+          session.state = terminalState;
+        } catch {}
         resolve();
       });
     });
@@ -223,7 +310,7 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
   }
 
   async function read({ sessionId, offset = 0, maxBytes = 65536 }) {
-    const session = sessionFor(sessionId);
+    const session = await sessionFor(sessionId);
     if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > 262144) throw new Error('invalid process read bounds');
     if (offset > session.stream_head) throw new Error('process read offset is beyond stream head');
     const truncated = offset < session.earliest_offset;
@@ -235,10 +322,10 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
       truncated, data_base64: data.toString('base64'), state: session.state, exit_code: session.exit_code };
   }
 
-  async function status({ sessionId }) { return publicSession(sessionFor(sessionId)); }
-  async function list() { return { sessions: [...sessions.values()].map(publicSession).sort((a,b) => a.session_id.localeCompare(b.session_id)) }; }
+  async function status({ sessionId }) { return publicSession(await sessionFor(sessionId)); }
+  async function list() { await hydrateTerminalSessions(); return { sessions: [...sessions.values()].map(publicSession).sort((a,b) => a.session_id.localeCompare(b.session_id)) }; }
   async function action({ sessionId, actionId }) {
-    const session = sessionFor(sessionId);
+    const session = await sessionFor(sessionId);
     if (session.state !== 'running') throw new Error('process action requires a running session');
     await assertProcessArmed(policy, session.profile_id, session.root_id);
     const profile = policy.profiles[session.profile_id];
@@ -259,7 +346,7 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
     return { action_id: actionId, logical_bytes: logicalBytes.length, logical_sha256: logicalSha256, session: publicSession(session) };
   }
   async function terminate({ sessionId }) {
-    const session = sessionFor(sessionId);
+    const session = await sessionFor(sessionId);
     if (['exited','terminated'].includes(session.state)) return publicSession(session);
     session.terminate_requested = true;
     session.host.kill();
@@ -268,7 +355,7 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
   }
 
   async function verifyEventJournal({ sessionId }) {
-    const session = sessionFor(sessionId);
+    const session = await sessionFor(sessionId);
     const verifying = await runtime.verifying();
     const text = await readFile(session.journal_path, 'utf8');
     const records = text.split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));

package/src/process-smoke-client.mjs

@@ -14,10 +14,18 @@ const ZERO_SHA256 = '0'.repeat(64);
 const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(here, '..');
-const policyPath = path.join(repoRoot, 'controller', 'deadbyte-process-policy.json');
+const productionPolicyPath = path.join(repoRoot, 'controller', 'deadbyte-process-policy.json');
 const serverPath = path.join(repoRoot, 'src', 'mcp-server.mjs');
-const policy = await loadProcessPolicy(policyPath);
 const smokeTrust = await import('node:fs/promises').then(({ mkdtemp }) => mkdtemp(path.join(os.tmpdir(), 'deadbyte-process-smoke-')));
+const smokePolicyPath = path.join(smokeTrust, 'smoke-policy.json');
+const productionPolicy = JSON.parse(await readFile(productionPolicyPath, 'utf8'));
+const smokePolicy = {
+  ...productionPolicy,
+  grant_file: path.join(smokeTrust, 'process-grant.json'),
+  state_dir: path.join(smokeTrust, 'process-state')
+};
+await writeFile(smokePolicyPath, `${JSON.stringify(smokePolicy, null, 2)}\n`, { flag: 'wx' });
+const policy = await loadProcessPolicy(smokePolicyPath);
 const keys = await generateTrustKeypair({ privateKeyPath: path.join(smokeTrust, 'private.pem'), publicKeyPath: path.join(smokeTrust, 'public.pem') });
 await mkdir(path.dirname(policy.grant_file), { recursive: true });
 const grant = { schema: PROCESS_GRANT_SCHEMA, policy_sha256: policy.policy_sha256,
@@ -29,7 +37,7 @@ const client = new Client({ name: 'deadbyte-process-smoke', version: '0.8.0' },
   { versionNegotiation: { mode: { pin: '2026-07-28' } } });
 const transport = new StdioClientTransport({
   command: process.execPath, args: [serverPath], cwd: repoRoot,
-  env: { ...getDefaultEnvironment(), DEADBYTE_PROCESS_RUNTIME: '1', DEADBYTE_PROCESS_POLICY: policyPath,
+  env: { ...getDefaultEnvironment(), DEADBYTE_PROCESS_RUNTIME: '1', DEADBYTE_PROCESS_POLICY: smokePolicyPath,
     DEADBYTE_SIGNING_KEY: keys.privateKeyPath, DEADBYTE_VERIFY_KEY: keys.publicKeyPath },
   stderr: 'pipe'
 });

package/src/provider-circuit.mjs

@@ -0,0 +1,125 @@
+import { createHash } from 'node:crypto';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const PROVIDER_ID=/^[A-Za-z0-9._:/-]{1,160}$/;
+const FAILURE_CLASSES=new Set(['timeout','transport','rate_limit','auth','invalid_response','other']);
+export const PROVIDER_CIRCUIT_STATES=Object.freeze(['CLOSED','OPEN','HALF_OPEN','UNAVAILABLE']);
+
+function isoMs(value){
+  if(typeof value!=='string') return null;
+  const ms=Date.parse(value);
+  return Number.isFinite(ms)?ms:null;
+}
+function checkedPolicy(policy){
+  const threshold=policy?.failure_threshold;
+  const openMs=policy?.open_ms;
+  const probeLimit=policy?.half_open_probe_limit;
+  if(!Number.isInteger(threshold)||threshold<1||threshold>32) throw new Error('provider circuit failure_threshold invalid');
+  if(!Number.isInteger(openMs)||openMs<100||openMs>3_600_000) throw new Error('provider circuit open_ms invalid');
+  if(!Number.isInteger(probeLimit)||probeLimit<1||probeLimit>8) throw new Error('provider circuit half_open_probe_limit invalid');
+  return {failure_threshold:threshold,open_ms:openMs,half_open_probe_limit:probeLimit};
+}
+function publicState(state){
+  return Object.freeze({
+    state:state.state,
+    failure_count:state.failure_count,
+    opened_at_utc:state.opened_at_utc,
+    next_probe_at_utc:state.next_probe_at_utc,
+    last_success_at_utc:state.last_success_at_utc,
+    half_open_probes:state.half_open_probes
+  });
+}
+function unavailable(){
+  return publicState({state:'UNAVAILABLE',failure_count:0,opened_at_utc:null,next_probe_at_utc:null,last_success_at_utc:null,half_open_probes:0});
+}
+function advanceTime(state,ms){
+  if(state.state==='OPEN'&&state.next_probe_ms!==null&&ms>=state.next_probe_ms){
+    state.state='HALF_OPEN';
+    state.half_open_probes=0;
+  }
+}
+function openAt(state,ms,policy){
+  state.state='OPEN';
+  state.failure_count=Math.max(policy.failure_threshold,state.failure_count);
+  state.opened_at_utc=new Date(ms).toISOString();
+  state.next_probe_ms=ms+policy.open_ms;
+  state.next_probe_at_utc=new Date(state.next_probe_ms).toISOString();
+  state.half_open_probes=0;
+}
+
+export function providerCircuitId(planner){
+  if(planner?.backend!=='openai_compatible'||typeof planner.endpoint!=='string'||typeof planner.model!=='string') {
+    throw new Error('provider circuit planner identity invalid');
+  }
+  const digest=createHash('sha256').update(Buffer.from(`${planner.endpoint}\0${planner.model}`,'utf8')).digest('hex');
+  return `openai_compatible:${digest}`;
+}
+
+export function classifyProviderFailure(error){
+  const name=String(error?.name??'').toLowerCase();
+  const text=String(error?.message??error??'').toLowerCase();
+  if(name==='aborterror'||/\b(?:timed?\s*out|timeout|aborted)\b/.test(text)) return 'timeout';
+  if(/(?:http\s*429|rate[ _-]?limit|too many requests)/.test(text)) return 'rate_limit';
+  if(/(?:http\s*(?:401|403)|unauthori[sz]ed|forbidden|api key|authentication)/.test(text)) return 'auth';
+  if(/(?:not json|invalid json|missing choices|invalid response|response.*(?:schema|contract|content))/.test(text)) return 'invalid_response';
+  if(/(?:econnreset|econnrefused|enotfound|fetch failed|network|socket|transport|connection)/.test(text)) return 'transport';
+  return 'other';
+}
+
+export function deriveCircuit(events,providerId,rawPolicy,observedAtUtc){
+  if(typeof providerId!=='string'||!PROVIDER_ID.test(providerId)) throw new Error('provider circuit provider_id invalid');
+  if(!Array.isArray(events)) throw new Error('provider circuit events invalid');
+  const policy=checkedPolicy(rawPolicy);
+  const observedMs=isoMs(observedAtUtc);
+  if(observedMs===null) throw new Error('provider circuit observed time invalid');
+  const state={state:'CLOSED',failure_count:0,opened_at_utc:null,next_probe_at_utc:null,next_probe_ms:null,last_success_at_utc:null,half_open_probes:0};
+  for(const event of events){
+    const eventProvider=event?.payload?.provider_id;
+    if(eventProvider!==providerId) continue;
+    if(!HEX64.test(event?.event_sha256??'')) return unavailable();
+    const ms=isoMs(event?.created_at_utc);
+    if(ms===null||ms>observedMs) return unavailable();
+    advanceTime(state,ms);
+    if(event.type==='provider_call_failed'){
+      if(!FAILURE_CLASSES.has(event.payload?.failure_class)) return unavailable();
+      if(state.state==='HALF_OPEN'){
+        state.failure_count=policy.failure_threshold;
+        openAt(state,ms,policy);
+      }else if(state.state==='OPEN'){
+        return unavailable();
+      }else{
+        state.failure_count+=1;
+        if(state.failure_count>=policy.failure_threshold) openAt(state,ms,policy);
+      }
+    }else if(event.type==='provider_call_succeeded'){
+      if(state.state==='OPEN') return unavailable();
+      state.state='CLOSED';
+      state.failure_count=0;
+      state.opened_at_utc=null;
+      state.next_probe_at_utc=null;
+      state.next_probe_ms=null;
+      state.last_success_at_utc=new Date(ms).toISOString();
+      state.half_open_probes=0;
+    }else if(event.type==='provider_probe_started'){
+      if(state.state!=='HALF_OPEN'||state.half_open_probes>=policy.half_open_probe_limit) return unavailable();
+      state.half_open_probes+=1;
+    }else if(String(event.type??'').startsWith('provider_')){
+      return unavailable();
+    }
+  }
+  advanceTime(state,observedMs);
+  return publicState(state);
+}
+
+export function providerCallDisposition(circuit){
+  if(!circuit||!PROVIDER_CIRCUIT_STATES.includes(circuit.state)) return {allowed:false,probe:false,reason:'circuit_unavailable'};
+  if(circuit.state==='UNAVAILABLE') return {allowed:false,probe:false,reason:'circuit_unavailable'};
+  if(circuit.state==='OPEN') return {allowed:false,probe:false,reason:'circuit_open'};
+  if(circuit.state==='HALF_OPEN'){
+    if(!Number.isInteger(circuit.half_open_probes)||circuit.half_open_probes<0) return {allowed:false,probe:false,reason:'circuit_unavailable'};
+    return circuit.half_open_probes===0
+      ? {allowed:true,probe:true,reason:'half_open_probe'}
+      : {allowed:false,probe:false,reason:'half_open_probe_limit'};
+  }
+  return {allowed:true,probe:false,reason:'circuit_closed'};
+}

package/src/r36-compact-disarmed-probe.mjs

@@ -0,0 +1,50 @@
+import { createHash, randomBytes } from 'node:crypto';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { R36_COMPACT_GATEWAYS, R36_COMPACT_TOOL_LIMIT } from './remote-mcp-r36-parity-client.mjs';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+function structured(result,label){
+  if(result.isError) throw new Error(`${label} returned error: ${JSON.stringify(result.structuredContent??result.content)}`);
+  if(!result.structuredContent||typeof result.structuredContent!=='object') throw new Error(`${label} missing structured output`);
+  return result.structuredContent;
+}
+function gateway(result,label){
+  const value=structured(result,label);
+  if(value.status!=='ok'||!value.result||typeof value.result!=='object') throw new Error(`${label} gateway status=${String(value.status)}`);
+  return value.result;
+}
+export async function probeR36CompactDisarmed(endpointText){
+  const endpoint=new URL(endpointText);
+  if(endpoint.protocol!=='https:') throw new Error('R36 compact disarmed probe requires HTTPS');
+  const client=new Client({name:'deadbyte-r36-compact-disarmed-probe',version:'0.10.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StreamableHTTPClientTransport(endpoint);
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(tool=>tool.name).sort();
+    if(names.length>R36_COMPACT_TOOL_LIMIT) throw new Error(`R36 compact catalog exceeds ${R36_COMPACT_TOOL_LIMIT}: ${names.length}`);
+    for(const name of R36_COMPACT_GATEWAYS) if(!names.includes(name)) throw new Error(`R36 compact gateway missing ${name}`);
+    for(const tool of listed.tools) if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false||!tool.outputSchema?.properties) throw new Error(`tool ${tool.name} missing strict output schema`);
+    const manifest=gateway(await client.callTool({name:'capability_manifest',arguments:{}}),'capability_manifest');
+    if(manifest.profile!=='compact'||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R36 compact manifest malformed');
+    const required=manifest.capabilities.filter(item=>item?.production===true&&item?.host_only!==true);
+    for(const item of required) if(typeof item.compact_tool!=='string'||!names.includes(item.compact_tool)) throw new Error(`compact route missing ${String(item.id)}`);
+    const coding=structured(await client.callTool({name:'coding_session_status',arguments:{}}),'coding_session_status');
+    const autonomous=structured(await client.callTool({name:'autonomous_session_status',arguments:{}}),'autonomous_session_status');
+    if(coding.armed!==false||autonomous.coding_armed!==false||autonomous.autonomous_armed!==false) throw new Error('R36 compact authority must be DISARMED');
+    const machine=gateway(await client.callTool({name:'machine_observe',arguments:{op:'machine_status'}}),'machine_status');
+    const nonce=`r36-final-${randomBytes(16).toString('hex')}`;
+    const ping=gateway(await client.callTool({name:'machine_observe',arguments:{op:'machine_ping',nonce}}),'machine_ping');
+    if(ping.nonce!==nonce||ping.machine_id!==machine.machine_id||ping.release_id!==machine.release_id||ping.release_manifest_sha256!==machine.release_manifest_sha256) throw new Error('R36 compact machine ping binding mismatch');
+    return {status:'passed',profile:'compact',tool_count:names.length,tools:names,catalog_sha256:sha256(Buffer.from(JSON.stringify(names),'utf8')),strict_output_schemas:true,ledger_sha256:manifest.ledger_sha256,capability_count:manifest.capabilities.length,production_non_host_capabilities:required.length,capability_closure:true,coding_armed:false,autonomous_armed:false,release_id:machine.release_id,release_manifest_sha256:machine.release_manifest_sha256,machine_status:machine,machine_ping:ping,nonce,protocol_revision:client.getNegotiatedProtocolVersion()};
+  } finally {await client.close().catch(()=>{});}
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const endpoint=process.argv[2];
+  if(!endpoint) throw new Error('usage: node src/r36-compact-disarmed-probe.mjs https://host/mcp/path');
+  probeR36CompactDisarmed(endpoint).then(v=>console.log(JSON.stringify(v,null,2))).catch(e=>{console.error(e instanceof Error?e.stack:String(e));process.exitCode=1;});
+}

package/src/r36-full-surface-probe.mjs

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { fileURLToPath } from 'node:url';
+import { R36_EXPECTED_TOOLS } from './remote-mcp-r36-parity-client.mjs';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+export async function probeR36FullSurface({packageRoot,generationRoot,stateRoot=path.join(os.homedir(),'.deadbyte-mcp')}={}){
+  const pkgRoot=packageRoot?path.resolve(packageRoot):path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+  const gen=path.resolve(generationRoot);
+  const semanticPath=path.join(gen,'semantic-lsp-config.json');
+  const semanticSha=sha256(await readFile(semanticPath));
+  const env={
+    ...getDefaultEnvironment(),
+    DEADBYTE_STATE_ROOT:path.resolve(stateRoot),
+    DEADBYTE_CORE_ROOT:pkgRoot,
+    DEADBYTE_WORKSPACE_ROOT:path.join(pkgRoot,'workspaces'),
+    DEADBYTE_CAPABILITY_PROFILE:'full',
+    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_MACHINE_FS_RUNTIME:'1',
+    DEADBYTE_OBSERVATION_RUNTIME:'1',
+    DEADBYTE_CODING_POLICY:path.join(gen,'coding-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_PRIVILEGED_POLICY:path.join(gen,'host-policy.json')
+  };
+  const client=new Client({name:'deadbyte-r36-full-surface-probe',version:'0.10.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StdioClientTransport({command:process.execPath,args:[path.join(pkgRoot,'src','mcp-server.mjs')],cwd:pkgRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(tool=>tool.name).sort();
+    if(JSON.stringify(names)!==JSON.stringify(R36_EXPECTED_TOOLS)) throw new Error(`R36 full catalog mismatch count=${names.length}`);
+    for(const tool of listed.tools){
+      if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false||!tool.outputSchema?.properties) throw new Error(`R36 full tool ${tool.name} missing strict output schema`);
+    }
+    return {status:'passed',profile:'full',tool_count:names.length,tools:names,catalog_sha256:sha256(Buffer.from(JSON.stringify(names),'utf8')),strict_output_schemas:true,protocol_revision:client.getNegotiatedProtocolVersion()};
+  } finally {await client.close().catch(()=>{});}
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const [packageRoot,generationRoot]=process.argv.slice(2);
+  if(!packageRoot||!generationRoot) throw new Error('usage: node src/r36-full-surface-probe.mjs <package-root> <generation-root>');
+  probeR36FullSurface({packageRoot,generationRoot}).then(v=>console.log(JSON.stringify(v,null,2))).catch(e=>{console.error(e instanceof Error?e.stack:String(e));process.exitCode=1;});
+}

package/src/release-generation.mjs

@@ -101,8 +101,8 @@ async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot}){
   return policy;
 }
 
-function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,codingPolicyPath,autonomousPolicyPath,hostPolicyPath}){
-  const bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
+function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,codingPolicyPath,semanticConfigPath,semanticConfigSha256,autonomousPolicyPath,hostPolicyPath}){
+  const supervisor=currentConfig.Supervisor??{},bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
   return [
     '@{',"    Schema = 'deadbyte.controller.v1'",`    CoreRoot = ${psQuote(coreRoot)}`,
     `    WorkspaceRoot = ${psQuote(workspaceRoot)}`,
@@ -114,9 +114,22 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     `    MachineFsRuntimeEnabled = ${psBool(currentConfig.MachineFsRuntimeEnabled)}`,
     `    ObservationRuntimeEnabled = ${psBool(currentConfig.ObservationRuntimeEnabled)}`,
     `    CodingPolicyFile = ${psQuote(codingPolicyPath)}`,
+    `    SemanticLspConfigFile = ${psQuote(semanticConfigPath??'')}`,
+    `    SemanticLspConfigSha256 = ${psQuote(semanticConfigSha256??'')}`,
     `    AutonomousRuntimeEnabled = ${psBool(currentConfig.AutonomousRuntimeEnabled)}`,
     `    AutonomousPolicyFile = ${psQuote(autonomousPolicyPath)}`,
+    `    AutonomousSupervisorEnabled = ${psBool(currentConfig.AutonomousSupervisorEnabled===true)}`,
     `    HostPolicyFile = ${psQuote(hostPolicyPath??'')}`,
+    ...(currentConfig.AutonomousSupervisorEnabled===true?[
+      '    Supervisor = @{',
+      `        FilePath = ${psQuote(supervisor.FilePath)}`,
+      `        FileSha256 = ${psQuote(supervisor.FileSha256)}`,
+      `        Arguments = ${psQuote(supervisor.Arguments)}`,
+      `        WorkingDirectory = ${psQuote(supervisor.WorkingDirectory)}`,
+      `        ScriptPath = ${psQuote(supervisor.ScriptPath)}`,
+      `        ScriptSha256 = ${psQuote(supervisor.ScriptSha256)}`,
+      '    }'
+    ]:[]),
     '    Bridge = @{',
     `        FilePath = ${psQuote(bridge.FilePath)}`,
     `        FileSha256 = ${psQuote(bridge.FileSha256)}`,
@@ -147,6 +160,13 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   if(typeof releaseId!=='string'||!/^[A-Za-z0-9._-]{1,96}$/.test(releaseId)) throw new Error('generation release id invalid');
   if(typeof currentConfig?.Bridge?.FileSha256!=='string'||!HEX64.test(currentConfig.Bridge.FileSha256)) throw new Error('generation Bridge FileSha256 invalid');
   if(typeof currentConfig?.Cloud?.FileSha256!=='string'||!HEX64.test(currentConfig.Cloud.FileSha256)) throw new Error('generation Cloud FileSha256 invalid');
+  if(currentConfig.AutonomousSupervisorEnabled===true){
+    if(currentConfig.AutonomousRuntimeEnabled!==true) throw new Error('generation autonomous supervisor requires AutonomousRuntimeEnabled');
+    const supervisor=currentConfig.Supervisor;
+    if(!supervisor||typeof supervisor!=='object') throw new Error('generation Supervisor launch specification missing');
+    for(const key of ['FilePath','Arguments','WorkingDirectory','ScriptPath']) if(typeof supervisor[key]!=='string'||supervisor[key].length<1) throw new Error(`generation Supervisor ${key} invalid`);
+    if(!HEX64.test(String(supervisor.FileSha256??''))||!HEX64.test(String(supervisor.ScriptSha256??''))) throw new Error('generation Supervisor hash invalid');
+  }
   if(currentConfig.Cloud.Transport!==undefined){
     const transport=String(currentConfig.Cloud.Transport);
     const expectedDependencies=transport==='deadbyte.named-tunnel.v1'?3:transport==='deadbyte.named-tunnel.v2'?2:null;
@@ -167,6 +187,20 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   }
   if(typeof currentConfig?.Bridge?.ScriptPath!=='string'||!path.isAbsolute(currentConfig.Bridge.ScriptPath)) throw new Error('generation Bridge ScriptPath must be absolute');
   if(typeof currentConfig?.Bridge?.ScriptSha256!=='string'||!HEX64.test(currentConfig.Bridge.ScriptSha256)) throw new Error('generation Bridge ScriptSha256 invalid');
+  const semanticSource=String(currentConfig.SemanticLspConfigFile??'');
+  const semanticExpected=String(currentConfig.SemanticLspConfigSha256??'').toLowerCase();
+  if(Boolean(semanticSource)!==Boolean(semanticExpected)) throw new Error('generation semantic LSP config path/SHA must be supplied together');
+  let semanticBytes=null,semanticConfigSha256=null;
+  if(semanticSource){
+    if(currentConfig.CodingRuntimeEnabled!==true) throw new Error('generation semantic LSP config requires CodingRuntimeEnabled');
+    if(!path.isAbsolute(semanticSource)) throw new Error('generation semantic LSP config path must be absolute');
+    if(!HEX64.test(semanticExpected)) throw new Error('generation semantic LSP config SHA-256 invalid');
+    const semanticStat=await lstat(semanticSource);
+    if(!semanticStat.isFile()||semanticStat.isSymbolicLink()) throw new Error('generation semantic LSP config source must be a regular file');
+    semanticBytes=await readFile(semanticSource);
+    semanticConfigSha256=sha256(semanticBytes);
+    if(semanticConfigSha256!==semanticExpected) throw new Error(`generation semantic LSP config SHA-256 mismatch: expected ${semanticExpected}, found ${semanticConfigSha256}`);
+  }
   const parityScratchRoot=path.join(state,'runtime','r33-parity-scratch');
   await mkdir(parityScratchRoot,{recursive:true});
   const parityScratchStat=await lstat(parityScratchRoot);
@@ -188,10 +222,13 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     machine_fs_runtime_enabled:currentConfig.MachineFsRuntimeEnabled===true,
     observation_runtime_enabled:currentConfig.ObservationRuntimeEnabled===true,
     autonomous_runtime_enabled:currentConfig.AutonomousRuntimeEnabled===true,
+    autonomous_supervisor_enabled:currentConfig.AutonomousSupervisorEnabled===true,
+    supervisor:currentConfig.AutonomousSupervisorEnabled===true?(currentConfig.Supervisor??{}):null,
     bridge:currentConfig.Bridge??{},cloud:currentConfig.Cloud??{},
     local_ready_uri:currentConfig.LocalReadyUri??'',url_regex:currentConfig.UrlRegex??'',
     mcp_url_file:currentConfig.McpUrlFile??'',mcp_url_file_sha256:currentConfig.McpUrlFileSha256??'',mcp_path_file:currentConfig.McpPathFile??'',
     start_timeout_seconds:Number(currentConfig.StartTimeoutSeconds??30),probe_timeout_seconds:Number(currentConfig.ProbeTimeoutSeconds??3),
+    semantic_lsp_config_sha256:semanticConfigSha256,
     process_policy_sha256:processBytes?sha256(processBytes):null,
     coding_policy_sha256:sha256(codingBytes),autonomous_policy_sha256:sha256(autonomousBytes),host_policy_sha256:hostBytes?sha256(hostBytes):null
   });
@@ -201,20 +238,22 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const generationRoot=path.join(generationsRoot,generationId);
   const processPath=processBytes?path.join(generationRoot,'process-policy.json'):null;
   const codingPath=path.join(generationRoot,'coding-policy.json');
+  const semanticPath=semanticBytes?path.join(generationRoot,'semantic-lsp-config.json'):null;
   const autonomousPath=path.join(generationRoot,'autonomous-policy.json');
   const hostPath=host?path.join(generationRoot,'host-policy.json'):null;
   const configPath=path.join(generationRoot,'controller-config.psd1');
   const files=new Map([
     ['coding-policy.json',codingBytes],
     ['autonomous-policy.json',autonomousBytes],
-    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,codingPolicyPath:codingPath,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
+    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,codingPolicyPath:codingPath,semanticConfigPath:semanticPath,semanticConfigSha256,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
   ]);
+  if(semanticBytes) files.set('semantic-lsp-config.json',semanticBytes);
   if(processBytes) files.set('process-policy.json',processBytes);
   if(hostBytes) files.set('host-policy.json',hostBytes);
   const manifestBytes=generationManifest(files),manifestSha256=sha256(manifestBytes);
   if(existsSync(generationRoot)){
     const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
-    return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:true,...verified};
+    return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:true,...verified};
   }
   await mkdir(generationsRoot,{recursive:true});
   const staging=path.join(generationsRoot,`.staging-${generationId}-${process.pid}-${randomBytes(4).toString('hex')}`);
@@ -229,5 +268,5 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     throw error;
   }
   const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
-  return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
+  return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
 }

package/src/remote-live-log.mjs

@@ -0,0 +1,76 @@
+const SAFE_ARG_KEYS=Object.freeze(['root_id','path','pattern','command_id','profile_id','session_id','goal_id','task_id','step_id','mode']);
+const LIFECYCLE=Object.freeze({
+  device_start:'🚀 [DEVICE] Starting DEADBYTE MCP...',
+  bridge_connected:'🔌 [BRIDGE] Local bridge connected',
+  cloud_connected:'🔌 [CLOUD] Remote MCP connected',
+  session_new:'[SESSION] New foreground session',
+  session_restored:'♻️ [SESSION] Previous result stream replayed',
+  ready:'✅ [READY] DEADBYTE MCP online',
+  cleanup:'🔐 [AUTH] Revoking session authority...'
+});
+
+function safeAtom(value){
+  if(typeof value==='string'){
+    if(value.length<1||value.length>160||/[\r\n\0]/.test(value)) return null;
+    return value;
+  }
+  if(typeof value==='number'&&Number.isFinite(value)) return String(value);
+  if(typeof value==='boolean') return String(value);
+  return null;
+}
+
+function summarizeArgs(args){
+  if(!args||typeof args!=='object'||Array.isArray(args)) return '';
+  const parts=[];
+  for(const key of SAFE_ARG_KEYS){
+    if(!Object.hasOwn(args,key)) continue;
+    const value=safeAtom(args[key]);
+    if(value!==null) parts.push(`${key.replace(/_id$/,'')}=${value}`);
+  }
+  return parts.length?` ${parts.join(' ')}`:'';
+}
+
+function formatDuration(ms){
+  const value=Number(ms);
+  if(!Number.isFinite(value)||value<0) return '';
+  if(value<1000) return `${Math.round(value)}ms`;
+  return `${(value/1000).toFixed(2)}s`;
+}
+
+export function formatCompactAuditEvent(event){
+  if(!event||typeof event!=='object'||Array.isArray(event)||typeof event.tool!=='string'||!event.tool) return null;
+  if(event.event_type==='tool.request') return `▶ RUN ${event.tool}${summarizeArgs(event.args)}`;
+  if(event.event_type==='tool.result'){
+    const marker=event.outcome?.is_error===true?'❌ ERR':'✅ OK';
+    const duration=formatDuration(event.outcome?.duration_ms);
+    return `${marker} ${event.tool}${duration?` ${duration}`:''}`;
+  }
+  return null;
+}
+
+export function formatRemoteLifecycle(kind){
+  if(typeof kind!=='string'||!Object.hasOwn(LIFECYCLE,kind)) throw new Error(`unknown remote lifecycle '${String(kind)}'`);
+  return LIFECYCLE[kind];
+}
+
+export function createLiveActivityTracker(){
+  const pending=new Map();
+  return Object.freeze({
+    observe(event){
+      if(!event||typeof event!=='object'||Array.isArray(event)) return null;
+      if(event.event_type==='tool.request'&&typeof event.request_id==='string'&&event.request_id&&typeof event.tool==='string'&&event.tool){
+        pending.set(event.request_id,{request_id:event.request_id,tool:event.tool});
+      }else if(event.event_type==='tool.result'&&typeof event.request_id==='string'&&event.request_id){
+        pending.delete(event.request_id);
+      }
+      return formatCompactAuditEvent(event);
+    },
+    pending(){return [...pending.values()].map(item=>({...item}));},
+    reconcileInterrupted(reason='session_end'){
+      const suffix=reason==='session_end'?'session ended before result':reason==='recovery'?'session recovered before result':'result not observed before stream ended';
+      const lines=[...pending.values()].map(item=>`⚠️ INTERRUPTED ${item.tool} — ${suffix}`);
+      pending.clear();
+      return lines;
+    }
+  });
+}