deadbyte-mcp 0.15.27 → 0.15.28

package/scripts/deploy-r48.mjs

@@ -8,7 +8,7 @@ import { loadPowerShellDataFile, runSlotUpdateCli } from '../src/runtime-update.
 import { parseActivePointer } from '../src/release-slot.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
-const state=path.join(os.homedir(),'.deadbyte-mcp');
+const state=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
 const sha=async f=>createHash('sha256').update(await readFile(f)).digest('hex');
 const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
 

package/scripts/gate-windows-r51.ps1

@@ -0,0 +1,58 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 3.0
+
+function Invoke-GateStep {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$NpmArgs)
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.28 / R51 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+function Invoke-NodeTest {
+    param([Parameter(Mandatory)][string]$Name,[Parameter(Mandatory)][string[]]$TestFiles)
+    Write-Host "==== $Name ===="
+    & node.exe --test --test-concurrency=1 @TestFiles
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE 0.15.28 / R51 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+
+Invoke-NodeTest 'r51-package-boundary' @('test/package-boundary.test.mjs')
+Invoke-NodeTest 'r51-release-smoke-isolation' @('test/release-smoke-isolation.test.mjs')
+Invoke-GateStep 'r51-focused-contracts' @('run','r51:focused:test')
+Invoke-GateStep 'containment-build' @('run','containment:build')
+Invoke-GateStep 'process-policy-refresh' @('run','process:policy:refresh')
+Write-Host "==== desktop-policy-refresh ===="
+& (Join-Path $PSScriptRoot 'init-desktop-policy-r40.ps1')
+Invoke-GateStep 'hardware-build' @('run','hardware:build')
+
+$hostPolicy = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\controller\deadbyte-host-policy.json'))
+Remove-Item -LiteralPath $hostPolicy -Force -ErrorAction SilentlyContinue
+if (Test-Path -LiteralPath $hostPolicy) { throw 'could not establish hermetic Host policy absence' }
+
+Invoke-GateStep 'r51-release-focused' @('run','r48:release:test')
+Invoke-NodeTest 'r49-donor-proof' @('test/r49-remote-control-donors.test.mjs')
+Invoke-NodeTest 'r49-desktop-wait' @('test/desktop-runtime-r40.test.mjs','test/desktop-mcp-tools-r40.test.mjs','test/autonomous-desktop-r40.test.mjs')
+Invoke-GateStep 'r49-catalog' @('run','r48:catalog:test')
+Invoke-GateStep 'commander-hardening' @('run','r47:hardening:test')
+Invoke-GateStep 'full-regression' @('run','r48:full:test')
+Invoke-GateStep 'mcp-smoke' @('run','mcp:smoke')
+Invoke-GateStep 'mcp-agent-smoke' @('run','mcp:agent:smoke')
+Invoke-GateStep 'mcp-coding-smoke' @('run','mcp:coding:smoke')
+Invoke-GateStep 'mcp-machine-fs-smoke' @('run','mcp:machine-fs:smoke')
+Invoke-GateStep 'mcp-observation-smoke' @('run','mcp:observation:smoke')
+Invoke-GateStep 'mcp-process-smoke' @('run','mcp:process:smoke')
+Invoke-GateStep 'mcp-autonomous-smoke' @('run','mcp:autonomous:smoke')
+Invoke-GateStep 'tunnel-stdio-compat-smoke' @('run','mcp:tunnel-compat:smoke')
+Invoke-GateStep 'containment-smoke' @('run','containment:smoke')
+Invoke-GateStep 'contained-smoke' @('run','contained:smoke')
+Invoke-GateStep 'mcp-contained-smoke' @('run','mcp:contained:smoke')
+Invoke-GateStep 'host-policy-refresh' @('run','host:policy:init')
+Invoke-GateStep 'manifest-write' @('run','manifest:write')
+Invoke-GateStep 'manifest-verify' @('run','manifest:verify')
+Invoke-GateStep 'doctor' @('run','doctor')
+Invoke-GateStep 'mcp-host-smoke' @('run','mcp:host:smoke')
+Invoke-GateStep 'authority-smoke' @('run','authority:smoke')
+Invoke-GateStep 'manifest-final-verify' @('run','manifest:verify')
+
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r51.mjs')
+if ($LASTEXITCODE -ne 0) { throw "R51 evidence writer failed with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE 0.15.28 / R51 WINDOWS GATE: PASS ===='

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

@@ -0,0 +1,84 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const stateRoot = path.resolve(process.env.DEADBYTE_STATE_ROOT || path.join(os.homedir(), '.deadbyte-mcp'));
+const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+const insist = (ok, message) => { if (!ok) throw new Error(message); };
+const pkg = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
+const release = JSON.parse(await readFile(path.join(root, 'RELEASE.json'), 'utf8'));
+const active = JSON.parse(await readFile(path.join(stateRoot, 'active-release.json'), 'utf8'));
+const manifestSha256 = sha256(await readFile(path.join(root, 'MANIFEST.SHA256')));
+
+insist(pkg.version === '0.15.28' && release.version === pkg.version && release.train === 'R51', 'R51 candidate identity mismatch');
+insist(
+  active.release_id === release.parent.release_id &&
+  active.manifest_sha256 === release.parent.manifest_sha256 &&
+  active.generation_manifest_sha256 === release.parent.generation_manifest_sha256,
+  'active runtime is not the exact sealed R51 parent'
+);
+
+const health = await doctor();
+insist(health.status === 'ok' && health.package_version === pkg.version && health.manifest?.verified === true, 'R51 doctor evidence invalid');
+insist(health.policy?.host_v2_ready === true, 'R51 Host policy v2 is not ready');
+
+const evidence = {
+  schema: 'deadbyte.r51-windows-gate.v1',
+  status: 'passed',
+  exit_code: 0,
+  version: pkg.version,
+  train: 'R51',
+  completed_at_utc: new Date().toISOString(),
+  manifest_sha256: manifestSha256,
+  parent: release.parent,
+  active_predecessor: {
+    release_id: active.release_id,
+    version: active.version,
+    manifest_sha256: active.manifest_sha256,
+    generation_manifest_sha256: active.generation_manifest_sha256
+  },
+  doctor: { verified_entries: health.manifest.verified_entries, host_v2_ready: true },
+  gates: {
+    package_boundary: true,
+    release_smoke_isolation: true,
+    runtime_coherence: true,
+    coding_command_singleflight: true,
+    foreground_desktop_host_fail_closed: true,
+    livelog_optimizer: true,
+    full_regression: true,
+    commander_hardening: true,
+    donor_proof: true,
+    desktop_wait: true,
+    exact_catalog: true,
+    stdio_smokes: true,
+    manifest_final_verify: true
+  }
+};
+
+const bytes = Buffer.from(`${JSON.stringify(evidence, null, 2)}\n`);
+const dir = path.join(stateRoot, 'evidence', 'release');
+await mkdir(dir, { recursive: true });
+const target = path.join(dir, `r51-windows-gate-${manifestSha256.slice(0, 16)}.json`);
+
+try {
+  const handle = await open(target, 'wx', 0o600);
+  try { await handle.writeFile(bytes); await handle.sync(); }
+  finally { await handle.close(); }
+} catch (error) {
+  if (error?.code !== 'EEXIST') throw error;
+  const prior = JSON.parse(await readFile(target, 'utf8'));
+  insist(
+    prior.schema === evidence.schema &&
+    prior.status === 'passed' &&
+    prior.version === evidence.version &&
+    prior.manifest_sha256 === manifestSha256 &&
+    prior.parent?.release_id === release.parent.release_id,
+    'conflicting R51 gate evidence identity'
+  );
+}
+
+console.log(JSON.stringify({ status: 'passed', path: target, sha256: sha256(bytes), manifest_sha256: manifestSha256 }));

package/src/coding-plane.mjs

@@ -368,6 +368,93 @@ function requestSha(operation, args) {
 export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
   if (!policy) throw new Error('coding runtime requires policy');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('coding runtime requires trust key paths');
+  const commandFlights = new Map();
+  const commandResults = new Map();
+  const COMMAND_RESULT_TTL_MS = 5 * 60 * 1000;
+  const COMMAND_RESULT_CACHE_MAX = 16;
+  const COMMAND_FLIGHT_SCHEMA = 'deadbyte.coding-command-flight.v1';
+  const COMMAND_RESULT_SCHEMA = 'deadbyte.coding-command-result.v1';
+  const commandFlightDir = path.join(policy.evidence_dir, 'command-flights');
+  function pruneCommandResults(now = Date.now()) {
+    for (const [key, entry] of commandResults) if (now - entry.completed_at_ms > COMMAND_RESULT_TTL_MS) commandResults.delete(key);
+    while (commandResults.size > COMMAND_RESULT_CACHE_MAX) commandResults.delete(commandResults.keys().next().value);
+  }
+  function commandFlightPaths(executionKey) {
+    const executionKeySha256 = sha256Bytes(Buffer.from(executionKey, 'utf8'));
+    return {
+      executionKeySha256,
+      claimPath: path.join(commandFlightDir, `${executionKeySha256}.claim.json`),
+      resultPath: path.join(commandFlightDir, `${executionKeySha256}.result.json`)
+    };
+  }
+  async function readDurableCommandResult(resultPath, executionKeySha256, request) {
+    let raw;
+    try { raw = JSON.parse(decodeUtf8Strict(await readFile(resultPath))); }
+    catch (error) {
+      if (error?.code === 'ENOENT') return null;
+      throw new Error(`coding command durable result invalid: ${String(error?.message ?? error)}`);
+    }
+    if (raw?.schema !== COMMAND_RESULT_SCHEMA || raw.execution_key_sha256 !== executionKeySha256 || raw.request_sha256 !== request ||
+        !Number.isInteger(raw.completed_at_ms) || !raw.result || typeof raw.result !== 'object' || Array.isArray(raw.result)) {
+      throw new Error('coding command durable result identity invalid');
+    }
+    if (Date.now() - raw.completed_at_ms > COMMAND_RESULT_TTL_MS) {
+      await rm(resultPath, { force: true });
+      return null;
+    }
+    const value = raw.result;
+    if (value.request_sha256 !== request || !RECEIPT_ID_RE.test(value.receipt_id ?? '') || !SHA256_RE.test(value.receipt_sha256 ?? '')) {
+      throw new Error('coding command durable result receipt identity invalid');
+    }
+    const verified = await verifyCodingReceiptFile(policy, verifyKeyPath, value.receipt_id);
+    if (!verified.ok || verified.request_sha256 !== request || verified.receipt_sha256 !== value.receipt_sha256) {
+      throw new Error(`coding command durable result receipt verification failed: ${verified.reason ?? 'identity mismatch'}`);
+    }
+    return { ...value };
+  }
+  async function writeDurableCommandResult(resultPath, executionKeySha256, request, value) {
+    const body = Buffer.from(`${JSON.stringify({ schema:COMMAND_RESULT_SCHEMA, execution_key_sha256:executionKeySha256,
+      request_sha256:request, completed_at_ms:Date.now(), result:value })}\n`, 'utf8');
+    try {
+      const handle = await open(resultPath, 'wx', 0o600);
+      try { await handle.writeFile(body); await handle.sync(); }
+      finally { await handle.close(); }
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      const prior = await readDurableCommandResult(resultPath, executionKeySha256, request);
+      if (!prior || prior.receipt_id !== value.receipt_id || prior.receipt_sha256 !== value.receipt_sha256) {
+        throw new Error('coding command durable result conflict');
+      }
+    }
+  }
+  async function acquireDurableCommandFlight(executionKey, request, waitMs) {
+    await mkdir(commandFlightDir, { recursive: true });
+    const paths = commandFlightPaths(executionKey);
+    const cached = await readDurableCommandResult(paths.resultPath, paths.executionKeySha256, request);
+    if (cached) return { ...paths, owned:false, cached };
+    try {
+      const handle = await open(paths.claimPath, 'wx', 0o600);
+      try {
+        await handle.writeFile(Buffer.from(`${JSON.stringify({ schema:COMMAND_FLIGHT_SCHEMA, execution_key_sha256:paths.executionKeySha256,
+          request_sha256:request, owner_pid:process.pid, started_at_ms:Date.now() })}\n`, 'utf8'));
+        await handle.sync();
+      } finally { await handle.close(); }
+      return { ...paths, owned:true, cached:null };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+    }
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+      const result = await readDurableCommandResult(paths.resultPath, paths.executionKeySha256, request);
+      if (result) return { ...paths, owned:false, cached:result };
+      let claimExists = true;
+      try { await stat(paths.claimPath); }
+      catch (error) { if (error?.code === 'ENOENT') claimExists = false; else throw error; }
+      if (!claimExists) return acquireDurableCommandFlight(executionKey, request, Math.max(100, deadline - Date.now()));
+      if (Date.now() >= deadline) throw new Error('identical coding command is still running in another runtime instance');
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
 
   async function sessionStatus() {
     const status = await codingSessionStatus(policy);
@@ -587,23 +674,67 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       root_id: rootId, command_id: commandId, script_path: scriptPath, script_sha256: scriptSha256,
       args, cwd, timeout_ms: timeoutMs
     });
-    const started = new Date().toISOString();
-    const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
-    const signed = await signCodingReceipt(policy, signingKeyPath, result.lease, {
-      operation: 'coding_command_run', request_sha256: request, root_id: rootId, command_id: commandId,
-      script_path: scriptPath, executable_sha256: result.executable_sha256, script_sha256: result.script_sha256,
-      started_at_utc: started, completed_at_utc: new Date().toISOString(), exit_code: result.exit_code,
-      signal: result.signal, timed_out: result.timed_out, elapsed_ms: result.elapsed_ms,
-      stdout_sha256: result.stdout_sha256, stderr_sha256: result.stderr_sha256
-    }, receiptId);
-    return {
-      status: result.timed_out || result.exit_code !== 0 ? 'observed_failure' : 'passed',
-      root_id: rootId, command_id: commandId, executable_sha256: result.executable_sha256,
-      script_sha256: result.script_sha256, exit_code: result.exit_code, signal: result.signal,
-      timed_out: result.timed_out, timeout_ms: result.timeout_ms, elapsed_ms: result.elapsed_ms,
-      stdout: result.stdout, stderr: result.stderr,
-      receipt_id: signed.receipt.receipt_id, receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request
-    };
+    const executionKey = receiptId === null ? request : `${request}:${receiptId}`;
+    pruneCommandResults();
+    const cached = commandResults.get(executionKey);
+    if (cached) {
+      await assertCodingArmed(policy, rootId);
+      return { ...cached.result };
+    }
+    const inFlight = commandFlights.get(executionKey);
+    if (inFlight) {
+      await assertCodingArmed(policy, rootId);
+      return { ...(await inFlight) };
+    }
+    if (!ID_RE.test(commandId ?? '')) throw new Error('invalid coding command id');
+    const command = policy.commands[commandId];
+    if (!command) throw new Error(`coding command '${commandId}' is not allowed`);
+    if (!command.root_ids.includes(rootId)) throw new Error(`coding command '${commandId}' is not allowed for root '${rootId}'`);
+    if (!Array.isArray(args) || args.length > 64 || args.some(item => typeof item !== 'string' || item.length > 2048 || item.includes('\0'))) {
+      throw new Error('coding command args must be <=64 strings of <=2048 characters');
+    }
+    if (!SHA256_RE.test(scriptSha256 ?? '')) throw new Error('script_sha256 must be lowercase SHA-256');
+    const requestedTimeout = timeoutMs === null ? command.timeout_ms : finiteInteger(timeoutMs, 'timeout_ms', 100, command.timeout_ms, command.timeout_ms);
+    const durable = await acquireDurableCommandFlight(executionKey, request, Math.min(900_000, requestedTimeout + 10_000));
+    if (durable.cached) {
+      await assertCodingArmed(policy, rootId);
+      commandResults.set(executionKey, { completed_at_ms: Date.now(), result: durable.cached });
+      pruneCommandResults();
+      return { ...durable.cached };
+    }
+    const execution = (async () => {
+      const started = new Date().toISOString();
+      const result = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      const signed = await signCodingReceipt(policy, signingKeyPath, result.lease, {
+        operation: 'coding_command_run', request_sha256: request, root_id: rootId, command_id: commandId,
+        script_path: scriptPath, executable_sha256: result.executable_sha256, script_sha256: result.script_sha256,
+        started_at_utc: started, completed_at_utc: new Date().toISOString(), exit_code: result.exit_code,
+        signal: result.signal, timed_out: result.timed_out, elapsed_ms: result.elapsed_ms,
+        stdout_sha256: result.stdout_sha256, stderr_sha256: result.stderr_sha256
+      }, receiptId);
+      const value = {
+        status: result.timed_out || result.exit_code !== 0 ? 'observed_failure' : 'passed',
+        root_id: rootId, command_id: commandId, executable_sha256: result.executable_sha256,
+        script_sha256: result.script_sha256, exit_code: result.exit_code, signal: result.signal,
+        timed_out: result.timed_out, timeout_ms: result.timeout_ms, elapsed_ms: result.elapsed_ms,
+        stdout: result.stdout, stderr: result.stderr,
+        receipt_id: signed.receipt.receipt_id, receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request
+      };
+      await writeDurableCommandResult(durable.resultPath, durable.executionKeySha256, request, value);
+      return value;
+    })();
+    commandFlights.set(executionKey, execution);
+    let completedDurably = false;
+    try {
+      const value = await execution;
+      completedDurably = true;
+      commandResults.set(executionKey, { completed_at_ms: Date.now(), result: value });
+      pruneCommandResults();
+      return { ...value };
+    } finally {
+      if (completedDurably && durable.owned) await rm(durable.claimPath, { force: true });
+      if (commandFlights.get(executionKey) === execution) commandFlights.delete(executionKey);
+    }
   }
 
   function percentile(samples, fraction) {

package/src/deadbyte-cli.mjs

@@ -13,8 +13,9 @@ import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-resul
 import { DEADBYTE_VERSION } from './version.mjs';
 import { parseActivePointer } from './release-slot.mjs';
 import { printDoctor } from './doctor-r45.mjs';
-import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
+import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
+import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -29,12 +30,17 @@ const SESSION_STATUS=[
   ['processstatus',/^Process plane\s*:\s*ARMED\b/m],
   ['codingstatus',/^Coding plane\s*:\s*ARMED\b/m],
   ['autonomousstatus',/^Autonomous\s*:\s*ARMED\b/m],
+  ['desktopstatus',/^Desktop plane\s*:\s*DISARMED\b/m],
   ['hoststatus',/^Host plane\s*:\s*DISARMED\b/m]
 ];
-const SESSION_CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park'];
+const SESSION_CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
 const SUPERVISOR_COMMANDS=Object.freeze({
   start:'supervisorstart',stop:'supervisorstop',status:'supervisorstatus',recover:'supervisorrecover'
 });
+const CURRENT_PACKAGE_ROOT=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const CURRENT_DEPLOY_SCRIPT=path.join(CURRENT_PACKAGE_ROOT,'scripts','deploy-r48.mjs');
+const REMOTE_UPDATE_TIMEOUT_MS=900000;
+const LIVE_LOG_DISCOVERY_INTERVAL_MS=1000;
 
 function stateRoot(){return path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));}
 async function requireRegular(file,label){const info=await lstat(file);if(!info.isFile()||info.isSymbolicLink()) throw new Error(`${label} must be a regular non-symlink file`);return file;}
@@ -94,6 +100,43 @@ async function reportVersionCoherence(root,{displayMode='ascii'}={}){
   writeRemote(process.stderr,`${remoteTag('warn',displayMode)} VERSION SKEW: CLI package ${DEADBYTE_VERSION}; active runtime ${active.version} (${active.release_id})\n`,displayMode);
   return active;
 }
+async function synchronizeForegroundRuntime(ctx,{displayMode='unicode'}={}){
+  const packageManifestSha256=createHash('sha256').update(await readFile(path.join(CURRENT_PACKAGE_ROOT,'MANIFEST.SHA256'))).digest('hex');
+  return ensureRuntimeCoherence({
+    cliVersion:DEADBYTE_VERSION,
+    packageManifestSha256,
+    readActive:()=>readActiveRuntimeBinding(ctx.root),
+    disarmPrivileged:async()=>{
+      for(const command of ['disarmhost','disarmdesktop']){
+        const result=invokeController(ctx,command,{capture:true,allowFailure:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+        if(result.status!==0) throw new Error(`runtime coherence '${command}' failed exit=${result.status}`);
+      }
+    },
+    activateCurrentPackage:async()=>{
+      const result=spawnSync(process.execPath,[CURRENT_DEPLOY_SCRIPT],{
+        cwd:CURRENT_PACKAGE_ROOT,
+        env:{...process.env,DEADBYTE_STATE_ROOT:ctx.root},
+        encoding:'utf8',
+        windowsHide:true,
+        shell:false,
+        timeout:REMOTE_UPDATE_TIMEOUT_MS,
+        maxBuffer:16*1024*1024
+      });
+      if(result.error){
+        if(result.error?.code==='ETIMEDOUT') throw new Error(`runtime coherence activation timed out after ${REMOTE_UPDATE_TIMEOUT_MS}ms`);
+        throw result.error;
+      }
+      if(result.status!==0){
+        const detail=boundedSingleLine(result.stderr||result.stdout||'no deployment output',2048);
+        throw new Error(`runtime coherence activation failed exit=${String(result.status)}: ${detail}`);
+      }
+    },
+    onEvent:event=>{
+      if(event.phase==='upgrade_start') writeRemote(process.stdout,`[UPDATE] Runtime ${event.from_version} -> ${event.to_version}; activating current package...\n`,displayMode);
+      else if(event.phase==='upgrade_complete') writeRemote(process.stdout,`[UPDATE] Runtime synchronized: ${event.release_id||event.to_version}\n`,displayMode);
+    }
+  });
+}
 async function readControllerStartFailure(root,command,{maxChars=2048}={}){
   const file=path.join(root,'runtime','controller-start-failure.json');
   let raw;
@@ -158,32 +201,34 @@ function controllerRuntimeDegraded(text){
   return /^DEADBYTE MCP\s*=\s*DEGRADED\s*$/m.test(String(text||''));
 }
 async function listLogFiles(root){
-  const files=[];
-  const audit=path.join(root,'audit');
-  const runtimeLogs=path.join(root,'runtime','logs');
-  for(const [dir,accept] of [
-    [audit,name=>/^segment-\d{8}\.jsonl$/.test(name)],
-    [runtimeLogs,name=>/\.log$/i.test(name)]
-  ]){
-    let names=[];try{names=await readdir(dir);}catch(error){if(error?.code==='ENOENT') continue;throw error;}
-    for(const name of names.sort()) if(accept(name)) files.push(path.join(dir,name));
-  }
-  return files;
+  const auditDir=path.join(root,'audit');
+  const runtimeDir=path.join(root,'runtime','logs');
+  let auditNames=[],runtimeNames=[];
+  try{auditNames=await readdir(auditDir);}catch(error){if(error?.code!=='ENOENT') throw error;}
+  try{runtimeNames=await readdir(runtimeDir);}catch(error){if(error?.code!=='ENOENT') throw error;}
+  const selected=selectLiveLogNames({auditNames,runtimeNames});
+  return [
+    ...selected.audit.map(name=>path.join(auditDir,name)),
+    ...selected.runtime.map(name=>path.join(runtimeDir,name))
+  ];
+}
+function parseAuditLogLine(file,line){
+  if(!/^segment-\d{8}\.jsonl$/.test(path.basename(file))||!line) return null;
+  try{return JSON.parse(line);}catch{return null;}
 }
-function formatLogLine(file,line,{activityTracker=null,sequence=null,verbose=false,displayMode='unicode'}={}){
+function formatLogLine(file,line,{auditEvent=null,activityTracker=null,sequence=null,verbose=false,displayMode='unicode'}={}){
   if(!line) return null;
   if(/^segment-\d{8}\.jsonl$/.test(path.basename(file))){
-    try{
-      const event=JSON.parse(line);
-      return activityTracker?activityTracker.observe(event,{sequence}):formatCompactAuditEvent(event);
-    }catch{return null;}
+    const event=auditEvent??parseAuditLogLine(file,line);
+    if(!event) return null;
+    return activityTracker?activityTracker.observe(event,{sequence}):formatCompactAuditEvent(event);
   }
   return formatRuntimeDiagnosticLine(file,line,{verbose,displayMode});
 }
 function remoteResultJournalPath(root,sessionId){return path.join(root,'runtime','remote-results',`${sessionId}.json`);}
-function auditTimelineRecord(file,line){
-  if(!/^segment-\d{8}\.jsonl$/.test(path.basename(file))||!line) return null;
-  let event;try{event=JSON.parse(line);}catch{return null;}
+function auditTimelineRecord(file,line,auditEvent=null){
+  const event=auditEvent??parseAuditLogLine(file,line);
+  if(!event) return null;
   if(typeof event?.request_id!=='string'||!event.request_id||typeof event.tool!=='string'||!event.tool) return null;
   const stamp=[event.ts,event.created_at_utc,event.observed_at_utc].find(value=>typeof value==='string'&&Number.isFinite(Date.parse(value)));
   const observed=stamp?new Date(Date.parse(stamp)).toISOString():new Date().toISOString();
@@ -239,7 +284,8 @@ async function readAppend(file,offset){
 }
 async function snapshotRemoteLogOffsets(root){
   const offsets=new Map();
-  for(const file of await listLogFiles(root)){
+  const files=await listLogFiles(root);
+  for(const file of files){
     try{offsets.set(file,(await stat(file)).size);}catch{}
   }
   return offsets;
@@ -264,20 +310,28 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
     ? '[LOG] Verbose live timeline. Full sanitized request detail enabled; Ctrl+C disconnects and revokes authority.\n'
     : '[LOG] Human live timeline. Transport IN/OUT hidden; full replay/audit detail remains on disk. Ctrl+C disconnects and revokes authority.\n');
   const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
+  let liveFiles=[...activeOffsets.keys()];
+  let nextDiscoveryAt=0;
   while(!signal.aborted){
-    for(const file of await listLogFiles(root)){
+    const now=Date.now();
+    if(now>=nextDiscoveryAt){
+      liveFiles=await listLogFiles(root);
+      nextDiscoveryAt=now+LIVE_LOG_DISCOVERY_INTERVAL_MS;
+    }
+    for(const file of liveFiles){
       const prior=activeOffsets.has(file)?activeOffsets.get(file):0;
       const next=await readAppend(file,prior);
       activeOffsets.set(file,next.offset);
       for(const line of next.text.split(/\r?\n/)){
-        const timeline=auditTimelineRecord(file,line);
+        const auditEvent=parseAuditLogLine(file,line);
+        const timeline=auditTimelineRecord(file,line,auditEvent);
         let recorded=null;
         if(timeline&&journal) recorded=timeline.event_type==='tool.call'
           ? await journal.recordCall(timeline)
           : await journal.recordTerminal(timeline);
         if(recorded?.duplicate) continue;
         const accepted=timelineFilter&&timeline?timelineFilter.accept(timelineFilterEvent(timeline)):true;
-        const formatted=formatLogLine(file,line,{activityTracker,sequence:recorded?.event?.seq??null,verbose,displayMode});
+        const formatted=formatLogLine(file,line,{auditEvent,activityTracker,sequence:recorded?.event?.seq??null,verbose,displayMode});
         if(!formatted||!accepted) continue;
         const output=Array.isArray(formatted)?formatted:[formatted];
         for(const item of output) if(item){
@@ -381,11 +435,17 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   const display=prepareRemoteConsole();
   const displayMode=display.mode;
   const ctx=await remoteContext();
-  await reportVersionCoherence(ctx.root,{displayMode});
   if(displayMode==='ascii') writeRemote(process.stdout,`[DISPLAY] ASCII fallback: ${display.reason}\n`,displayMode);
   if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{displayMode});
   await recoverRemoteSession(ctx,{displayMode});
   const marker=await claimRemoteSession(ctx);
+  try{
+    await synchronizeForegroundRuntime(ctx,{displayMode});
+  }catch(error){
+    await cleanupRemoteSession(ctx,{displayMode});
+    await releaseRemoteSession(ctx,marker,{displayMode});
+    throw error;
+  }
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
@@ -442,13 +502,13 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     process.stdout.write('[OK] ONLINE\n');
     process.stdout.write(`${formatRemoteLifecycle('ready',{displayMode})}\n`);
     if(url) writeRemote(process.stdout,`URL: ${url}\n`,displayMode);
-    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Verifying process, coding, autonomous; host must stay DISARMED...\n`,displayMode);
+    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Verifying process, coding, autonomous; desktop + host must stay DISARMED...\n`,displayMode);
     for(const [command,pattern] of SESSION_STATUS){
       const result=invokeController(ctx,command,{capture:true,echoCaptured:false});
       if(!pattern.test(result.stdout)) throw new Error(`remote session authority verification failed: ${command} state mismatch`);
     }
     ready=true;
-    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} ARMED: process, coding, autonomous | host DISARMED\n`,displayMode);
+    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} ARMED: process, coding, autonomous | desktop, host DISARMED\n`,displayMode);
     await logTask;
   }finally{
     const wasAborted=aborter.signal.aborted;

package/src/remote-live-log.mjs

@@ -53,6 +53,13 @@ const TOOL_ICONS_ASCII=Object.freeze({read:'R',write:'W',edit:'E',run:'>',verify
 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 selectLiveLogNames({auditNames=[],runtimeNames=[]}={}){
+  if(!Array.isArray(auditNames)||!Array.isArray(runtimeNames)) throw new Error('live log names must be arrays');
+  const audit=auditNames.filter(name=>typeof name==='string'&&/^segment-\d{8}\.jsonl$/.test(name)).sort().slice(-2);
+  const runtime=runtimeNames.filter(name=>typeof name==='string'&&/\.log$/i.test(name)).sort();
+  return Object.freeze({audit:Object.freeze(audit),runtime:Object.freeze(runtime)});
+}
+
 export function truncateUtf8(value,maxBytes,{ellipsis='…'}={}){
   if(typeof value!=='string'||!Number.isInteger(maxBytes)||maxBytes<1) return '';
   const bytes=new TextEncoder().encode(value);
@@ -312,18 +319,19 @@ export function createLiveTimelineWriter({stream=process.stdout,displayMode='uni
   return Object.freeze({write,flush,pending(){return active?{...active}:null;}});
 }
 
-export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false}={}){
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000}={}){
   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');
   if(!rootPaths||typeof rootPaths!=='object'||Array.isArray(rootPaths)) throw new Error('live timeline rootPaths invalid');
   if(typeof trace!=='boolean') throw new Error('live timeline trace invalid');
+  if(!Number.isInteger(slowCallMs)||slowCallMs<100||slowCallMs>600000) throw new Error('live timeline slowCallMs invalid');
   const pending=new Map();
   const completed=new Set();
   const toolCounts=new Map();
   const durationSamples=[];
-  let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0;
+  let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0,peakInFlight=0;
 
   function eventPrefix(event,sequence,{displayTool=null,icon=null}={}){
     const seq=Number.isSafeInteger(sequence)&&sequence>0?'#'+sequence+'  ':'';
@@ -336,9 +344,11 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     const error=event.outcome?.is_error===true;
     const unknown=event.outcome?.side_effect_state==='unknown';
     const displayTool=span?.display_tool||event.tool;
-    const duration=Number.isFinite(Number(event.outcome?.duration_ms))
-      ?formatDuration(event.outcome.duration_ms)
+    const rawDuration=Number(event.outcome?.duration_ms);
+    const duration=Number.isFinite(rawDuration)
+      ?formatDuration(rawDuration)
       :span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
+    const slow=Number.isFinite(rawDuration)&&rawDuration>=slowCallMs?'  [SLOW]':'';
     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:'');
@@ -353,7 +363,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     const prefixIcon=unknown?(displayMode==='ascii'?'WARN':'⚠️'):null;
     const evidence=receipt?'  '+(displayMode==='ascii'?'RECEIPT':'🧾 receipt')+(displayMode==='ascii'?'=':'=')+receipt:'';
     const reasonSep=displayMode==='ascii'?' - ':' — ';
-    return remoteDisplayText(eventPrefix(event,sequence,{displayTool,icon:prefixIcon})+traceSuffix(span?.trace_meta)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+'  '+marker+evidence+(reason?reasonSep+reason:''),displayMode);
+    return remoteDisplayText(eventPrefix(event,sequence,{displayTool,icon:prefixIcon})+traceSuffix(span?.trace_meta)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+slow+'  '+marker+evidence+(reason?reasonSep+reason:''),displayMode);
   }
   function burstLine(value){
     if(!value) return null;
@@ -396,6 +406,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
       const summary=summarizeLiveToolArgs(displayTool,args,{rootPaths});
       const traceMeta=traceIdentity(event,args);
       pending.set(requestId,{request_id:requestId,tool,display_tool:displayTool,summary,trace_meta:traceMeta,started_at_ms:clock()});
+      peakInFlight=Math.max(peakInFlight,pending.size);
       if(verbose) return formatRemoteToolCall({...event,tool:displayTool},{clock,displayMode})+traceSuffix(traceMeta);
       if(visibleStart(displayTool)) return eventPrefix(event,sequence,{displayTool})+traceSuffix(traceMeta)+(summary?'  '+summary:'')+'  …';
       return null;
@@ -453,6 +464,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
       ' | tool time '+(formatDuration(totalDurationMs)||'0ms')+
       (p50!==null?' | p50 '+formatDuration(p50)+' | p95 '+formatDuration(p95):'')+
       (slowest?' | slowest '+slowest.tool+' '+formatDuration(slowest.duration_ms):'')+
+      ' | peak in-flight '+peakInFlight+
       (foldedHeartbeatLines?' | folded '+foldedHeartbeatLines+' heartbeat lines':'')+
       (top?' | top: '+top:''),displayMode);
   }

package/src/remote-session-guardian.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 
-const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park'];
+const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
 
 function parseArgs(argv){
   const out={};