deadbyte-mcp 0.11.3 → 0.13.0

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

@@ -0,0 +1,71 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { R40_COMPACT_GATEWAYS,R40_COMPACT_TOOL_LIMIT } from './remote-mcp-r40-parity-client.mjs';
+import { loadDesktopPolicy } from './desktop-policy-r40.mjs';
+import { verifyDesktopReceiptObject } from './desktop-runtime-r40.mjs';
+import { loadPublicVerifyKey } from './trust.mjs';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const verifyKeyPath=path.join(stateRoot,'trust','ed25519-public.pem');
+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;
+}
+async function verifyDesktop(policy,verifyKey,id,sha,kind){
+  const receipt=JSON.parse(await readFile(path.join(policy.evidence_dir,id+'.json'),'utf8'));
+  const proof=verifyDesktopReceiptObject(receipt,{policySha256:policy.policy_sha256,publicKey:verifyKey.publicKey,keyId:verifyKey.keyId});
+  if(!proof.ok||proof.receipt_sha256!==sha||proof.kind!==kind) throw new Error('R40 desktop '+kind+' receipt verification failed');
+}
+export async function probeR40CompactDisarmed(endpointText){
+  const endpoint=new URL(endpointText);if(endpoint.protocol!=='https:')throw new Error('R40 compact disarmed probe requires HTTPS');
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  const desktopPolicy=await loadDesktopPolicy(path.join(pointer.generation_root,'desktop-policy.json'));
+  const verifyKey=await loadPublicVerifyKey(verifyKeyPath);
+  const client=new Client({name:'deadbyte-r40-compact-disarmed-probe',version:'0.12.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StreamableHTTPClientTransport(endpoint);
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools(),names=listed.tools.map(t=>t.name).sort();
+    if(names.length!==R40_COMPACT_TOOL_LIMIT)throw new Error('R40 compact disarmed catalog must be exactly '+R40_COMPACT_TOOL_LIMIT+', got '+names.length);
+    for(const name of R40_COMPACT_GATEWAYS)if(!names.includes(name))throw new Error('R40 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.schema!=='deadbyte.capability-manifest.v2'||manifest.profile!=='compact'||manifest.tool_count!==names.length||
+       JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names))throw new Error('R40 compact manifest malformed');
+    const required=manifest.capabilities.filter(x=>x?.production===true&&x?.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 status');
+    const autonomous=structured(await client.callTool({name:'autonomous_session_status',arguments:{}}),'autonomous status');
+    const desktop=gateway(await client.callTool({name:'desktop_control',arguments:{op:'status'}}),'desktop status');
+    if(coding.armed!==false||autonomous.coding_armed!==false||autonomous.autonomous_armed!==false||desktop.armed!==false)throw new Error('R40 closure requires Coding/Autonomous/Desktop DISARMED');
+    const observed=gateway(await client.callTool({name:'desktop_control',arguments:{op:'observe',preview:false}}),'desktop observe');
+    await verifyDesktop(desktopPolicy,verifyKey,observed.receipt_id,observed.receipt_sha256,'desktop_observation');
+    const grounded=gateway(await client.callTool({name:'desktop_control',arguments:{op:'target',frame_id:observed.frame.frame_id,uia_query:{kind:'root',value:'',max_results:1,ordinal:0}}}),'desktop target');
+    await verifyDesktop(desktopPolicy,verifyKey,grounded.grounding.receipt_id,grounded.grounding.receipt_sha256,'desktop_grounding');
+    const machine=gateway(await client.callTool({name:'machine_observe',arguments:{op:'machine_status'}}),'machine status');
+    const nonce='r40-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.release_id!==machine.release_id||ping.release_manifest_sha256!==machine.release_manifest_sha256)throw new Error('R40 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,desktop_armed:false,
+      desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true,
+      desktop_frame_id:observed.frame.frame_id,desktop_target_id:grounded.target.target_id,
+      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/r40-compact-disarmed-probe.mjs https://host/mcp/path');
+probeR40CompactDisarmed(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/r40-full-surface-probe.mjs

@@ -0,0 +1,34 @@
+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 { R40_EXPECTED_TOOLS } from './remote-mcp-r40-parity-client.mjs';
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function probeR40FullSurface({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),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_DESKTOP_RUNTIME:'1',DEADBYTE_DESKTOP_POLICY:path.join(gen,'desktop-policy.json'),
+    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_AUTONOMOUS_SUPERVISOR_MODE:'external',DEADBYTE_PRIVILEGED_POLICY:path.join(gen,'host-policy.json')};
+  const client=new Client({name:'deadbyte-r40-full-surface-probe',version:'0.12.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(),names=listed.tools.map(t=>t.name).sort();
+    if(JSON.stringify(names)!==JSON.stringify(R40_EXPECTED_TOOLS))throw new Error('R40 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('R40 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,desktop_tools:['desktop_status','desktop_observe','desktop_target','desktop_action'],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/r40-full-surface-probe.mjs <package-root> <generation-root>');
+probeR40FullSurface({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

@@ -118,7 +118,31 @@ async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot}){
   return policy;
 }
 
-function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,codingPolicyPath,semanticConfigPath,semanticConfigSha256,autonomousPolicyPath,hostPolicyPath}){
+async function rebindDesktopPolicy(raw,{stateRoot,releaseRoot}){
+  if(!raw) return null;
+  const policy=clone(raw);
+  if(policy.schema!=='deadbyte.desktop-policy.v1'||policy.enabled!==true) throw new Error('desktop policy schema/enabled mismatch');
+  policy.grant_file=path.join(stateRoot,'runtime','desktop-grant.json');
+  policy.evidence_dir=path.join(stateRoot,'runtime','desktop-evidence');
+  const providers={
+    observer:'deadbyte-desktop-observer-r40.exe',
+    input:'deadbyte-desktop-input-r40.exe',
+    grounder:'deadbyte-desktop-uia-r40.exe'
+  };
+  for(const [name,file] of Object.entries(providers)){
+    const provider=policy[name];
+    if(!provider||typeof provider.sha256!=='string'||!HEX64.test(provider.sha256)) throw new Error(`desktop ${name} policy pin invalid`);
+    const providerPath=path.join(releaseRoot,'bin',file);
+    const stat=await lstat(providerPath);
+    if(!stat.isFile()||stat.isSymbolicLink()) throw new Error(`desktop ${name} helper invalid in release slot`);
+    const actual=sha256(await readFile(providerPath));
+    if(actual!==provider.sha256) throw new Error(`desktop ${name} helper SHA-256 mismatch: policy=${provider.sha256} release=${actual}`);
+    provider.executable=providerPath;
+  }
+  return policy;
+}
+
+function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,desktopPolicyPath,codingPolicyPath,semanticConfigPath,semanticConfigSha256,autonomousPolicyPath,hostPolicyPath}){
   const supervisor=currentConfig.Supervisor??{},bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
   return [
     '@{',"    Schema = 'deadbyte.controller.v1'",`    CoreRoot = ${psQuote(coreRoot)}`,
@@ -130,6 +154,8 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     `    CodingRuntimeEnabled = ${psBool(currentConfig.CodingRuntimeEnabled)}`,
     `    MachineFsRuntimeEnabled = ${psBool(currentConfig.MachineFsRuntimeEnabled)}`,
     `    ObservationRuntimeEnabled = ${psBool(currentConfig.ObservationRuntimeEnabled)}`,
+    `    DesktopRuntimeEnabled = ${psBool(currentConfig.DesktopRuntimeEnabled)}`,
+    `    DesktopPolicyFile = ${psQuote(desktopPolicyPath??'')}`,
     `    CodingPolicyFile = ${psQuote(codingPolicyPath)}`,
     `    SemanticLspConfigFile = ${psQuote(semanticConfigPath??'')}`,
     `    SemanticLspConfigSha256 = ${psQuote(semanticConfigSha256??'')}`,
@@ -172,7 +198,7 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     '}',''
   ].join('\r\n');
 }
-export async function createGenerationBundle({stateRoot,releaseRoot,developmentRoot,workspaceRoot,releaseId,currentConfig,processPolicy,codingPolicy,autonomousPolicy,hostPolicy}){
+export async function createGenerationBundle({stateRoot,releaseRoot,developmentRoot,workspaceRoot,releaseId,currentConfig,processPolicy,desktopPolicy,codingPolicy,autonomousPolicy,hostPolicy}){
   const state=path.resolve(stateRoot),release=path.resolve(releaseRoot),development=path.resolve(developmentRoot),workspace=path.resolve(workspaceRoot);
   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');
@@ -230,6 +256,9 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const hostBytes=host?jsonBytes(host):null;
   const processBound=await rebindProcessPolicy(processPolicy,{developmentRoot:development,stateRoot:state,releaseRoot:release});
   const processBytes=processBound?jsonBytes(processBound):null;
+  const desktopBound=await rebindDesktopPolicy(desktopPolicy,{stateRoot:state,releaseRoot:release});
+  const desktopBytes=desktopBound?jsonBytes(desktopBound):null;
+  if(currentConfig.DesktopRuntimeEnabled===true&&!desktopBytes) throw new Error('DesktopRuntimeEnabled requires desktop policy');
   const seedBody=canonical({
     release_id:releaseId,core_root:release,development_root:development,workspace_root:workspace,
     machine_runtime_enabled:currentConfig.MachineRuntimeEnabled!==false,
@@ -238,6 +267,7 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     coding_runtime_enabled:currentConfig.CodingRuntimeEnabled===true,
     machine_fs_runtime_enabled:currentConfig.MachineFsRuntimeEnabled===true,
     observation_runtime_enabled:currentConfig.ObservationRuntimeEnabled===true,
+    desktop_runtime_enabled:currentConfig.DesktopRuntimeEnabled===true,
     autonomous_runtime_enabled:currentConfig.AutonomousRuntimeEnabled===true,
     autonomous_supervisor_enabled:currentConfig.AutonomousSupervisorEnabled===true,
     supervisor:currentConfig.AutonomousSupervisorEnabled===true?(currentConfig.Supervisor??{}):null,
@@ -247,6 +277,7 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     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,
+    desktop_policy_sha256:desktopBytes?sha256(desktopBytes):null,
     coding_policy_sha256:sha256(codingBytes),autonomous_policy_sha256:sha256(autonomousBytes),host_policy_sha256:hostBytes?sha256(hostBytes):null
   });
   const generationSeed=sha256(Buffer.from(JSON.stringify(seedBody),'utf8'));
@@ -254,6 +285,7 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const generationsRoot=path.join(state,'generations');
   const generationRoot=path.join(generationsRoot,generationId);
   const processPath=processBytes?path.join(generationRoot,'process-policy.json'):null;
+  const desktopPath=desktopBytes?path.join(generationRoot,'desktop-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');
@@ -262,15 +294,16 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   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,semanticConfigPath:semanticPath,semanticConfigSha256,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
+    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,desktopPolicyPath:desktopPath,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(desktopBytes) files.set('desktop-policy.json',desktopBytes);
   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,semantic_config_path:semanticPath,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,desktop_policy_path:desktopPath,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')}`);
@@ -285,5 +318,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,semantic_config_path:semanticPath,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,desktop_policy_path:desktopPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
 }

package/src/remote-console.mjs

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export const REMOTE_DISPLAY_MODES=Object.freeze(['unicode','ascii']);
+
+function checkedMode(mode){
+  if(!REMOTE_DISPLAY_MODES.includes(mode)) throw new Error(`remote display mode invalid: ${String(mode)}`);
+  return mode;
+}
+
+export function remoteDisplayText(value,mode='unicode'){
+  checkedMode(mode);
+  const text=String(value??'');
+  if(mode==='unicode') return text;
+  let out='';
+  for(const ch of text){
+    const cp=ch.codePointAt(0);
+    if(cp===9||cp===10||cp===13||(cp>=0x20&&cp<=0x7e)) out+=ch;
+    else out+=`\\u{${cp.toString(16).toUpperCase()}}`;
+  }
+  return out;
+}
+
+export function prepareRemoteConsole({
+  platform=process.platform,
+  isTTY=Boolean(process.stdout?.isTTY),
+  env=process.env,
+  spawnSyncFn=spawnSync
+}={}){
+  if(String(env?.DEADBYTE_REMOTE_ASCII??'')==='1') return Object.freeze({mode:'ascii',code_page:null,reason:'forced_ascii'});
+  if(platform!=='win32') return Object.freeze({mode:'unicode',code_page:null,reason:'non_windows'});
+  if(!isTTY) return Object.freeze({mode:'ascii',code_page:null,reason:'stdout_not_tty'});
+  const systemRoot=env?.SystemRoot||env?.WINDIR;
+  if(typeof systemRoot!=='string'||!systemRoot) return Object.freeze({mode:'ascii',code_page:null,reason:'system_root_missing'});
+  const chcp=path.win32.join(systemRoot,'System32','chcp.com');
+  let result;
+  try{ result=spawnSyncFn(chcp,['65001'],{stdio:'ignore',windowsHide:true,shell:false}); }
+  catch{ return Object.freeze({mode:'ascii',code_page:null,reason:'codepage_probe_threw'}); }
+  if(result?.error||result?.status!==0) return Object.freeze({mode:'ascii',code_page:null,reason:'codepage_65001_unavailable'});
+  return Object.freeze({mode:'unicode',code_page:65001,reason:'codepage_65001'});
+}

package/src/remote-live-log.mjs

@@ -1,5 +1,6 @@
 import { canonicalJson } from './canonical-json.mjs';
 import { sanitizeAuditArgs } from './tool-audit.mjs';
+import { remoteDisplayText, REMOTE_DISPLAY_MODES } from './remote-console.mjs';
 
 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({
@@ -11,6 +12,15 @@ const LIFECYCLE=Object.freeze({
   ready:'✅ [READY] DEADBYTE MCP online',
   cleanup:'🔐 [AUTH] Revoking session authority...'
 });
+const LIFECYCLE_ASCII=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'){
@@ -36,27 +46,97 @@ function summarizeArgs(args){
 const TOOL_COLUMN_WIDTH=32;
 const DISPLAY_UTC_OFFSET_MINUTES=7*60;
 const DISPLAY_UTC_OFFSET_LABEL='+07:00';
+const HEARTBEAT_TOOLS=new Set(['machine_ping','machine_status','machine_system_status','machine_list']);
+const TOOL_ICONS=Object.freeze({read:'📖',write:'📝',edit:'✏️',run:'🏃',verify:'🧾',search:'🔍',heartbeat:'📡',desktop:'🖥️',autonomous:'🤖',process:'⚙️',generic:'•'});
+const TOOL_ICONS_ASCII=Object.freeze({read:'R',write:'W',edit:'E',run:'>',verify:'V',search:'S',heartbeat:'H',desktop:'D',autonomous:'A',process:'P',generic:'*'});
+const START_VISIBLE_PATTERNS=[/(?:^|_)file_write$/,/text_replace$/,/symbol_replace$/,/native_diff_(?:apply|preview)$/,
+  /(?:command|benchmark)_run$/,/task_run$/,/goal_run$/,/goal_submit$/,/goal_approve$/,/process_session_(?:start|action|terminate)$/,/^desktop_action$/];
+
+export function truncateUtf8(value,maxBytes,{ellipsis='…'}={}){
+  if(typeof value!=='string'||!Number.isInteger(maxBytes)||maxBytes<1) return '';
+  const bytes=new TextEncoder().encode(value);
+  if(bytes.length<=maxBytes) return value;
+  const suffix=new TextEncoder().encode(ellipsis);
+  const budget=Math.max(0,maxBytes-suffix.length);
+  let end=Math.min(budget,bytes.length);
+  while(end>0&&(bytes[end]&0xc0)===0x80) end--;
+  return new TextDecoder('utf-8',{fatal:false}).decode(bytes.subarray(0,end))+(suffix.length<=maxBytes?ellipsis:'');
+}
+function clipped(value,max=72){
+  if(typeof value!=='string') return '';
+  const one=value.replace(/[\r\n\t]+/g,' ').replace(/\s{2,}/g,' ').trim();
+  return truncateUtf8(one,max);
+}
+function shortValue(value,max=12){
+  if(typeof value!=='string'||!value) return '';
+  return value.length<=max?value:value.slice(0,max)+'…';
+}
+function payloadByteCount(value){
+  return value&&typeof value==='object'&&value.redacted===true&&Number.isFinite(Number(value.byte_count))?Number(value.byte_count):null;
+}
+function rootPath(args){
+  const root=safeAtom(args?.root_id);const p=safeAtom(args?.path);
+  if(root&&p) return root+':'+p;
+  return root||p||'';
+}
+export function summarizeLiveToolArgs(tool,rawArgs){
+  const args=sanitizeAuditArgs(rawArgs??{});const where=rootPath(args);
+  if(/(?:file_read|files_read)$/.test(tool)) return where;
+  if(/file_write$/.test(tool)){const bytes=payloadByteCount(args.content);return [where,bytes!==null?'('+bytes+'B)':''].filter(Boolean).join(' ');}
+  if(/text_replace$|symbol_replace$/.test(tool)){const bytes=payloadByteCount(args.new_string);return [where,bytes!==null?'('+bytes+'B new)':''].filter(Boolean).join(' ');}
+  if(/coding_tree$/.test(tool)) return where;
+  if(/coding_(?:search|inspect)$/.test(tool)) return [where,args.pattern?'\"'+clipped(String(args.pattern),36)+'\"':'',args.op?String(args.op):''].filter(Boolean).join(' ');
+  if(/(?:command|benchmark)_run$/.test(tool)) return [safeAtom(args.root_id),safeAtom(args.command_id),safeAtom(args.script_path)].filter(Boolean).join(' ');
+  if(/^machine_(?:ping|status|system_status|list)$/.test(tool)) return safeAtom(args.nonce)?'nonce='+shortValue(String(args.nonce),24):'';
+  if(/^process_session/.test(tool)) return [safeAtom(args.profile_id),shortValue(safeAtom(args.session_id)||'',12),safeAtom(args.op)].filter(Boolean).join(' ');
+  if(/^desktop_/.test(tool)) return [shortValue(safeAtom(args.frame_id)||'',10),shortValue(safeAtom(args.target_id)||'',10),safeAtom(args.op)].filter(Boolean).join(' ');
+  if(/^autonomous_/.test(tool)) return [shortValue(safeAtom(args.goal_id)||'',12),safeAtom(args.step_id)].filter(Boolean).join(' ');
+  return summarizeArgs(args).trim();
+}
+function categoryForTool(tool){
+  if(/^desktop_/.test(tool)) return 'desktop';
+  if(/^autonomous_/.test(tool)) return 'autonomous';
+  if(HEARTBEAT_TOOLS.has(tool)) return 'heartbeat';
+  if(/(?:receipt_verify|evidence_verify|goal_verify|task_verify|audit|release_gate|native_diff_verify)/.test(tool)) return 'verify';
+  if(/(?:search|inspect|symbol_(?:definition|references|implementations|outline|diagnostics)|_stat$|_tree$)/.test(tool)) return 'search';
+  if(/(?:file_read|files_read|machine_fs_read|process_session_read)/.test(tool)) return 'read';
+  if(/(?:file_write|machine_fs_write|mkdir|move|delete)/.test(tool)) return 'write';
+  if(/(?:replace|edit_exact|native_diff_apply)/.test(tool)) return 'edit';
+  if(/(?:command_run|benchmark_run|task_run|goal_run|process_session_(?:start|action|terminate))/.test(tool)) return 'run';
+  if(/^process_/.test(tool)) return 'process';
+  return 'generic';
+}
+function iconForTool(tool,displayMode='unicode'){
+  const icons=displayMode==='ascii'?TOOL_ICONS_ASCII:TOOL_ICONS;
+  return icons[categoryForTool(tool)]??icons.generic;
+}
+function visibleStart(tool){return START_VISIBLE_PATTERNS.some(pattern=>pattern.test(tool));}
 
 function displayTimestamp(ms){
   const shifted=new Date(ms+DISPLAY_UTC_OFFSET_MINUTES*60*1000).toISOString();
   return `${shifted.slice(0,-1)}${DISPLAY_UTC_OFFSET_LABEL}`;
 }
 
-function eventTimestamp(event,clock){
-  for(const value of [event?.created_at_utc,event?.observed_at_utc]){
+function eventMs(event,clock){
+  for(const value of [event?.ts,event?.created_at_utc,event?.observed_at_utc]){
     const parsed=Date.parse(value);
-    if(typeof value==='string'&&Number.isFinite(parsed)) return displayTimestamp(parsed);
+    if(typeof value==='string'&&Number.isFinite(parsed)) return parsed;
   }
   const value=Number(clock());
-  return displayTimestamp(Number.isFinite(value)?value:Date.now());
+  return Number.isFinite(value)?value:Date.now();
+}
+function eventTimestamp(event,clock){return displayTimestamp(eventMs(event,clock));}
+function displayClock(ms){
+  const shifted=new Date(ms+DISPLAY_UTC_OFFSET_MINUTES*60*1000).toISOString();
+  return shifted.slice(11,23);
 }
 
-export function formatRemoteToolCall(event,{clock=()=>Date.now()}={}){
+export function formatRemoteToolCall(event,{clock=()=>Date.now(),displayMode='unicode'}={}){
   if(!event||typeof event!=='object'||Array.isArray(event)||event.event_type!=='tool.request'||
      typeof event.tool!=='string'||!event.tool) return null;
   if(typeof clock!=='function') throw new Error('remote tool-call clock must be a function');
   const args=sanitizeAuditArgs(event.args??{});
-  return `${eventTimestamp(event,clock)} | ${event.tool.padEnd(TOOL_COLUMN_WIDTH)} | Arguments: ${canonicalJson(args)}`;
+  return remoteDisplayText(`${eventTimestamp(event,clock)} | ${event.tool.padEnd(TOOL_COLUMN_WIDTH)} | Arguments: ${canonicalJson(args)}`,displayMode);
 }
 
 function formatDuration(ms){
@@ -77,9 +157,10 @@ export function formatCompactAuditEvent(event){
   return null;
 }
 
-export function formatRemoteLifecycle(kind){
+export function formatRemoteLifecycle(kind,{displayMode='unicode'}={}){
   if(typeof kind!=='string'||!Object.hasOwn(LIFECYCLE,kind)) throw new Error(`unknown remote lifecycle '${String(kind)}'`);
-  return LIFECYCLE[kind];
+  if(!REMOTE_DISPLAY_MODES.includes(displayMode)) throw new Error('remote display mode invalid');
+  return displayMode==='ascii'?LIFECYCLE_ASCII[kind]:LIFECYCLE[kind];
 }
 
 export function createLiveActivityTracker(){
@@ -109,56 +190,138 @@ function shortSpanId(requestId){
   return typeof requestId==='string'&&requestId.length?requestId.slice(0,8):'????????';
 }
 
-export function createLiveTimelineTracker({clock=()=>Date.now()}={}){
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode'}={}){
   if(typeof clock!=='function') throw new Error('live timeline clock must be a function');
+  if(!REMOTE_DISPLAY_MODES.includes(displayMode)) throw new Error('remote display mode invalid');
+  if(!Number.isInteger(heartbeatBurstLimit)||heartbeatBurstLimit<2||heartbeatBurstLimit>100) throw new Error('heartbeatBurstLimit invalid');
+  if(!Number.isInteger(heartbeatWindowMs)||heartbeatWindowMs<250||heartbeatWindowMs>60000) throw new Error('heartbeatWindowMs invalid');
   const pending=new Map();
   const completed=new Set();
-  return Object.freeze({
-    observe(event){
-      if(!event||typeof event!=='object'||Array.isArray(event)) return null;
-      const requestId=typeof event.request_id==='string'&&event.request_id?event.request_id:null;
-      const tool=typeof event.tool==='string'&&event.tool?event.tool:null;
-      if(event.event_type==='tool.request'&&requestId&&tool){
-        if(pending.has(requestId)||completed.has(requestId)) return null;
-        pending.set(requestId,{request_id:requestId,tool,started_at_ms:clock()});
-        return formatRemoteToolCall(event,{clock});
-      }
-      if(event.event_type==='tool.result'&&requestId&&tool){
-        if(completed.has(requestId)) return null;
-        const span=pending.get(requestId)??null;
-        pending.delete(requestId);completed.add(requestId);
-        const error=event.outcome?.is_error===true;
-        const duration=Number.isFinite(Number(event.outcome?.duration_ms))
-          ? formatDuration(event.outcome.duration_ms)
-          : span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
-        const marker=span?(error?'✗':'✓'):'↩';
-        const status=error?'ERR':'OK ';
-        const suffix=span?'':' (request before live window)';
-        return `${marker} [${shortSpanId(requestId)}] ${status} ${tool}${duration?` ${duration}`:''}${suffix}`;
-      }
+  const toolCounts=new Map();
+  let resultCount=0,errorCount=0,totalDurationMs=0,burst=null,foldedHeartbeatLines=0;
+
+  function eventPrefix(event,sequence){
+    const seq=Number.isSafeInteger(sequence)&&sequence>0?'#'+sequence+'  ':'';
+    return iconForTool(event.tool,displayMode)+'  '+displayClock(eventMs(event,clock))+'  '+seq+'['+shortSpanId(event.request_id)+']  '+event.tool;
+  }
+  function resultLine(event,span,sequence){
+    const error=event.outcome?.is_error===true;
+    const unknown=event.outcome?.side_effect_state==='unknown';
+    const duration=Number.isFinite(Number(event.outcome?.duration_ms))
+      ?formatDuration(event.outcome.duration_ms)
+      :span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
+    const summary=span?.summary||'';
+    const rawReason=typeof event.outcome?.reason==='string'&&event.outcome.reason?event.outcome.reason:
+      (unknown&&typeof event.outcome?.recovery?.reason==='string'?event.outcome.recovery.reason:'');
+    const reason=rawReason?clipped(rawReason,180):(unknown?'terminal result unavailable; inspect state before retry':'');
+    const marker=unknown?'OUTCOME_UNKNOWN':error?(displayMode==='ascii'?'ERR':'✗'):(displayMode==='ascii'?'OK':'✓');
+    return remoteDisplayText(eventPrefix(event,sequence)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+'  '+marker+(reason?' — '+reason:''),displayMode);
+  }
+  function burstLine(value){
+    if(!value) return null;
+    const avg=value.count?value.total_ms/value.count:0;
+    const seq=Number.isSafeInteger(value.last_sequence)&&value.last_sequence>0?'#'+value.last_sequence+'  ':'';
+    const startClock=displayClock(value.first_ms);
+    const endClock=displayClock(value.last_ms);
+    const range=value.first_ms===value.last_ms?endClock:startClock.slice(0,8)+'–'+endClock.slice(0,8);
+    if(value.count>1) foldedHeartbeatLines+=value.count-1;
+    const marker=displayMode==='ascii'?'OK':'✓';
+    return remoteDisplayText(iconForTool(value.tool,displayMode)+'  '+range+'  '+seq+value.tool+' ×'+value.count+'  avg '+formatDuration(avg)+'  '+marker,displayMode);
+  }
+  function flushBurst(){
+    const line=burstLine(burst);
+    burst=null;
+    return line;
+  }
+  function addStats(event){
+    resultCount++;
+    toolCounts.set(event.tool,(toolCounts.get(event.tool)??0)+1);
+    const duration=Number(event.outcome?.duration_ms);
+    if(Number.isFinite(duration)&&duration>=0) totalDurationMs+=duration;
+    if(event.outcome?.is_error===true) errorCount++;
+  }
+  function observe(event,{sequence=null}={}){
+    if(!event||typeof event!=='object'||Array.isArray(event)) return null;
+    const requestId=typeof event.request_id==='string'&&event.request_id?event.request_id:null;
+    const tool=typeof event.tool==='string'&&event.tool?event.tool:null;
+    if(event.event_type==='tool.request'&&requestId&&tool){
+      if(pending.has(requestId)||completed.has(requestId)) return null;
+      const summary=summarizeLiveToolArgs(tool,event.args??{});
+      pending.set(requestId,{request_id:requestId,tool,summary,started_at_ms:clock()});
+      if(verbose) return formatRemoteToolCall(event,{clock,displayMode});
+      if(visibleStart(tool)) return eventPrefix(event,sequence)+(summary?'  '+summary:'')+'  …';
       return null;
-    },
-    pending(){return [...pending.values()].map(({request_id,tool})=>({request_id,tool}));},
-    reconcileInterrupted(reason='session_end'){
-      const suffix=reason==='recovery'?'recovery ended before terminal result':
-        reason==='session_end'?'session ended before terminal result':'stream ended before terminal result';
-      const lines=[...pending.values()].map(item=>`⚠ [${shortSpanId(item.request_id)}] INTERRUPTED ${item.tool} — ${suffix}`);
-      pending.clear();
-      return lines;
     }
+    if(event.event_type==='tool.result'&&requestId&&tool){
+      if(completed.has(requestId)) return null;
+      const span=pending.get(requestId)??null;
+      pending.delete(requestId);
+      completed.add(requestId);
+      addStats(event);
+      const error=event.outcome?.is_error===true;
+      const nowMs=eventMs(event,clock);
+      if(HEARTBEAT_TOOLS.has(tool)&&!error){
+        const duration=Number(event.outcome?.duration_ms);
+        if(burst&&burst.tool===tool&&nowMs-burst.last_ms<=heartbeatWindowMs){
+          burst.count++;
+          burst.last_ms=nowMs;
+          burst.last_sequence=sequence;
+          if(Number.isFinite(duration)&&duration>=0) burst.total_ms+=duration;
+        }else{
+          const prior=flushBurst();
+          burst={tool,count:1,total_ms:Number.isFinite(duration)&&duration>=0?duration:0,
+            first_ms:nowMs,last_ms:nowMs,first_sequence:sequence,last_sequence:sequence};
+          return prior;
+        }
+        if(burst.count>=heartbeatBurstLimit) return flushBurst();
+        return null;
+      }
+      const lines=[];
+      const prior=flushBurst();
+      if(prior) lines.push(prior);
+      lines.push(resultLine(event,span,sequence));
+      return lines.length===1?lines[0]:lines;
+    }
+    return null;
+  }
+  function reconcileInterrupted(reason='session_end'){
+    const suffix=reason==='recovery'?'recovery ended before terminal result':
+      reason==='session_end'?'session ended before terminal result':'stream ended before terminal result';
+    const lines=[];
+    const folded=flushBurst();
+    if(folded) lines.push(folded);
+    for(const item of pending.values()) lines.push(remoteDisplayText((displayMode==='ascii'?'[WARN]':'⚠')+' ['+shortSpanId(item.request_id)+'] OUTCOME_UNKNOWN '+item.tool+' — '+suffix+'; inspect state before retry',displayMode));
+    pending.clear();
+    return lines;
+  }
+  function summary(){
+    const top=[...toolCounts.entries()].sort((a,b)=>b[1]-a[1]||a[0].localeCompare(b[0])).slice(0,3)
+      .map(([tool,count])=>tool+'×'+count).join(', ');
+    return remoteDisplayText((displayMode==='ascii'?'[SUMMARY]':'📊 [SUMMARY]')+' '+resultCount+' calls | '+errorCount+' error'+(errorCount===1?'':'s')+
+      ' | tool time '+(formatDuration(totalDurationMs)||'0ms')+
+      (foldedHeartbeatLines?' | folded '+foldedHeartbeatLines+' heartbeat lines':'')+
+      (top?' | top: '+top:''),displayMode);
+  }
+  return Object.freeze({
+    observe,
+    pending(){return [...pending.values()].map(({request_id,tool})=>({request_id,tool}));},
+    reconcileInterrupted,
+    summary
   });
 }
 
-
-export function formatRuntimeDiagnosticLine(file,line){
+export function formatRuntimeDiagnosticLine(file,line,{verbose=false,displayMode='unicode'}={}){
   if(typeof file!=='string'||typeof line!=='string'||!line) return null;
   const label=file.split(/[\\/]/).at(-1).replace(/\.log$/i,'').toUpperCase();
   const input=line.match(/\[TOOL IN \]\s+\S+\s+#\d+\s+([A-Za-z0-9_.-]+)/);
-  if(input) return `[${label}] IN  ${input[1]}`;
+  if(input) return verbose?remoteDisplayText('['+label+'.DEBUG] IN  '+input[1],displayMode):null;
   const output=line.match(/\[TOOL OUT\]\s+\S+\s+#\d+\s+([A-Za-z0-9_.-]+)/);
   if(output){
-    if(/"is_error"\s*:\s*true/.test(line)) return `[${label}] ERR ${output[1]}`;
-    return `[${label}] OUT ${output[1]}`;
+    if(!verbose) return null;
+    if(/"is_error"\s*:\s*true/.test(line)) return remoteDisplayText('['+label+'.DEBUG] ERR '+output[1],displayMode);
+    return remoteDisplayText('['+label+'.DEBUG] OUT '+output[1],displayMode);
   }
+  const compact=line.match(/^\[TOOL\]\s+(\S+)\s+#(\d+)\s+(✓|✗|OK|ERR)\s+([A-Za-z0-9_.-]+)\s+([^\s]+)(?:\s+—\s+(.+))?$/u);
+  if(compact) return verbose?remoteDisplayText('['+label+'.DEBUG] #'+compact[2]+' '+compact[3]+' '+compact[4]+' '+compact[5]+(compact[6]?' — '+compact[6]:''),displayMode):null;
   return null;
 }