deadbyte-mcp 0.15.27 → 0.15.29

package/src/coding-plane.mjs

@@ -11,6 +11,7 @@ import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { createCodingSearch } from './coding-search.mjs';
 import { createSearchCursorCodec } from './search-cursor.mjs';
 import { atomicMutation } from './atomic-mutation.mjs';
+import { fileURLToPath } from 'node:url';
 
 export const CODING_POLICY_SCHEMA = 'deadbyte.coding-policy.v1';
 export const CODING_LEASE_SCHEMA = 'deadbyte.coding-lease.v1';
@@ -368,6 +369,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);
@@ -504,7 +592,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request };
   }
   async function runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
-    executionDeadlineUtc = null, preExecutionCheck = null }) {
+    executionDeadlineUtc = null, preExecutionCheck = null, cancellationCheck = null }) {
     const lease = await assertCodingArmed(policy, rootId);
     if (!ID_RE.test(commandId ?? '')) throw new Error('invalid coding command id');
     const command = policy.commands[commandId];
@@ -546,28 +634,58 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
     if (deadlineBound < 100) throw new Error('coding execution deadline expires too soon to execute command');
     const effectiveTimeout = Math.min(requestedTimeout, command.timeout_ms, grantBound, deadlineBound);
     const argv = [...command.prefix_args, script.resolved, ...args];
+    // The internal Windows host owns a kill-on-close Job Object. Its identity
+    // is package-pinned, never selected by a caller or granted public PID input.
+    let executable=command.executable, launchArgs=argv;
+    if(process.platform==='win32'){
+      const host=fileURLToPath(new URL('../bin/deadbyte-process-host.exe',import.meta.url));
+      const hostPolicy=JSON.parse(await readFile(new URL('../controller/deadbyte-process-policy.json',import.meta.url),'utf8'));
+      if(await sha256File(host)!==hostPolicy.native_host?.sha256) throw new Error('coding process host hash changed');
+      executable=host;
+      launchArgs=[command.executable,cwdResolved,randomBytes(32).toString('hex'),'--deadbyte-transport=pipe-quiet',...argv];
+    }
+    if(cancellationCheck!==null&&typeof cancellationCheck!=='function') throw new Error('cancellation check must be internal function');
+    if(cancellationCheck&&await cancellationCheck()) throw new Error('coding command cancelled before dispatch');
+    await recheckCodingAuthority(policy,activeLease,rootId);
     const startMs = performance.now();
-    const child = spawn(command.executable, argv, {
+    const child = spawn(executable, launchArgs, {
       cwd: cwdResolved, env: codingEnvironment(), shell: false, windowsHide: true,
-      detached: false, stdio: ['ignore', 'pipe', 'pipe']
+      detached: process.platform!=='win32', stdio: ['ignore', 'pipe', 'pipe']
     });
+    const killOwned=()=>{
+      if(child.exitCode!==null||child.signalCode!==null)return;
+      if(process.platform==='win32') child.kill('SIGKILL');
+      else {try{process.kill(-child.pid,'SIGKILL');}catch(error){if(error.code!=='ESRCH')throw error;}}
+    };
     const stdoutState = { chunks: [], bytes: 0, exceeded: null };
     const stderrState = { chunks: [], bytes: 0, exceeded: null };
-    collectBounded(child.stdout, command.max_output_bytes, stdoutState, 'stdout', () => child.kill('SIGKILL'));
-    collectBounded(child.stderr, command.max_output_bytes, stderrState, 'stderr', () => child.kill('SIGKILL'));
+    collectBounded(child.stdout, command.max_output_bytes, stdoutState, 'stdout', killOwned);
+    collectBounded(child.stderr, command.max_output_bytes, stderrState, 'stderr', killOwned);
     let timedOut = false;
     let timer;
+    let cancelTimer,checking=false,cancellationError=null,finished=false;
+    if(cancellationCheck){
+      cancelTimer=setInterval(async()=>{
+        if(checking||finished)return;
+        checking=true;
+        try{if(await cancellationCheck())killOwned();}
+        catch(error){cancellationError=error;killOwned();}
+        finally{checking=false;}
+      },50);
+      cancelTimer.unref?.();
+    }
     const timerDelay = deadlineAtMs === null
       ? effectiveTimeout
       : Math.max(1, Math.min(effectiveTimeout, Math.floor(deadlineAtMs - Date.now())));
     const completion = new Promise((resolve, reject) => {
       child.once('error', reject);
       child.once('close', (code, signal) => resolve({ code, signal }));
-      timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timerDelay);
+      timer = setTimeout(() => { timedOut = true; killOwned(); }, timerDelay);
       timer.unref?.();
     });
     let result;
-    try { result = await completion; } finally { if (timer) clearTimeout(timer); }
+    try { result = await completion; } finally { finished=true;if (timer) clearTimeout(timer);if(cancelTimer)clearInterval(cancelTimer); }
+    if(cancellationError)throw cancellationError;
     if (stdoutState.exceeded || stderrState.exceeded) throw new Error(stdoutState.exceeded ?? stderrState.exceeded);
     const stdoutBytes = Buffer.concat(stdoutState.chunks);
     const stderrBytes = Buffer.concat(stderrState.chunks);
@@ -582,28 +700,72 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
   }
 
   async function commandRun({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
-    executionDeadlineUtc = null, preExecutionCheck = null, receiptId = null, requestSha256 = null }) {
+    executionDeadlineUtc = null, preExecutionCheck = null, cancellationCheck = null, receiptId = null, requestSha256 = null }) {
     const request = requestSha256 ?? requestSha('coding_command_run', {
       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, cancellationCheck });
+      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) {
@@ -620,7 +782,7 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
 
   async function benchmarkRun({ rootId, commandId, scriptPath, scriptSha256, args = [], cwd = '.', timeoutMs = null,
     executionDeadlineUtc = null, preExecutionCheck = null, warmups = 1, iterations = 5, baselineMedianMs = null, maxRegressionPct = 5,
-    receiptId = null, requestSha256 = null }) {
+    receiptId = null, requestSha256 = null, cancellationCheck = null }) {
     if (!Number.isInteger(warmups) || warmups < 0 || warmups > 3) throw new Error('warmups must be in [0, 3]');
     if (!Number.isInteger(iterations) || iterations < 1 || iterations > 20) throw new Error('iterations must be in [1, 20]');
     if (baselineMedianMs !== null && (!Number.isFinite(baselineMedianMs) || baselineMedianMs <= 0)) throw new Error('baseline_median_ms must be positive or null');
@@ -631,13 +793,13 @@ export function createCodingRuntime({ policy, signingKeyPath, verifyKeyPath }) {
       max_regression_pct: maxRegressionPct
     });
     for (let i = 0; i < warmups; i += 1) {
-      const warm = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      const warm = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       if (warm.timed_out || warm.exit_code !== 0) throw new Error(`benchmark warmup failed exit=${String(warm.exit_code)} timed_out=${warm.timed_out}`);
     }
     const samples = [];
     let last = null;
     for (let i = 0; i < iterations; i += 1) {
-      last = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck });
+      last = await runCommandOnce({ rootId, commandId, scriptPath, scriptSha256, args, cwd, timeoutMs, executionDeadlineUtc, preExecutionCheck, cancellationCheck });
       if (last.timed_out || last.exit_code !== 0) throw new Error(`benchmark iteration ${i + 1} failed exit=${String(last.exit_code)} timed_out=${last.timed_out}`);
       samples.push(last.elapsed_ms);
     }

package/src/coding-task-runtime.mjs

@@ -474,7 +474,7 @@ async function reconcileInterrupted(ctx, plan, events, derived, codingRuntime, s
   return deriveState(plan, events);
 }
 
-async function executeStep(codingRuntime, plan, step, attempt) {
+async function executeStep(codingRuntime, plan, step, attempt, cancellationCheck = null) {
   const receiptId = receiptIdFor(plan.task_id, step.step_id, attempt, plan.plan_sha256);
   const requestSha256 = expectedRequest(codingRuntime, step);
   if (step.kind === 'write') {
@@ -486,12 +486,12 @@ async function executeStep(codingRuntime, plan, step, attempt) {
   } else if (step.kind === 'command') {
     await codingRuntime.commandRun({ rootId: step.root_id, commandId: step.command_id, scriptPath: step.script_path,
       scriptSha256: step.script_sha256, args: step.args, cwd: step.cwd, timeoutMs: step.timeout_ms,
-      receiptId, requestSha256 });
+      receiptId, requestSha256, cancellationCheck });
   } else if (step.kind === 'benchmark') {
     await codingRuntime.benchmarkRun({ rootId: step.root_id, commandId: step.command_id, scriptPath: step.script_path,
       scriptSha256: step.script_sha256, args: step.args, cwd: step.cwd, timeoutMs: step.timeout_ms,
       warmups: step.warmups, iterations: step.iterations, baselineMedianMs: step.baseline_median_ms,
-      maxRegressionPct: step.max_regression_pct, receiptId, requestSha256 });
+      maxRegressionPct: step.max_regression_pct, receiptId, requestSha256, cancellationCheck });
   } else {
     throw new Error(`coding step '${step.step_id}' is not executable`);
   }
@@ -670,7 +670,10 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
         try {
           const remainingMs = timeoutMs === null ? null : Math.max(100, Math.floor(deadlineState(deadline).remaining_ms));
           const boundedStep = remainingMs === null ? next : { ...next, timeout_ms: next.timeout_ms === null || next.timeout_ms === undefined ? remainingMs : Math.min(next.timeout_ms, remainingMs) };
-          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt);
+          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt,()=>readCancel(ctx,verifyKeyPath));
+          if(await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)){
+            derived=deriveState(plan,journal);return {status:'cancelled',task_id:taskId,...derived};
+          }
           if (!executed.outcome.valid) {
             await appendEvent(ctx, journal, signingKeyPath, 'task_paused', {
               stepId: next.step_id, payload: { reason: 'post_execute_receipt_mismatch', detail: executed.outcome.reason }
@@ -700,6 +703,9 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
           }
           derived = deriveState(plan, journal);
         } catch (error) {
+          if(await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)){
+            derived=deriveState(plan,journal);return {status:'cancelled',task_id:taskId,...derived};
+          }
           if (deadlineExpired()) {
             derived = await failDeadline(ctx, journal, plan, next.step_id);
             return { status: 'failed', task_id: taskId, ...derived, deadline };

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={};