deadbyte-mcp 0.15.27 → 0.15.28

package/src/runtime-coherence.mjs

@@ -0,0 +1,50 @@
+const SEMVER=/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+const HEX64=/^[0-9a-f]{64}$/;
+
+function parseSemver(value){
+  const match=SEMVER.exec(String(value??''));
+  if(!match) throw new Error(`runtime version invalid: ${String(value)}`);
+  return {major:Number(match[1]),minor:Number(match[2]),patch:Number(match[3]),prerelease:match[4]??null};
+}
+export function compareRuntimeVersions(a,b){
+  const left=parseSemver(a),right=parseSemver(b);
+  for(const key of ['major','minor','patch']) if(left[key]!==right[key]) return left[key]<right[key]?-1:1;
+  if(left.prerelease===right.prerelease) return 0;
+  if(left.prerelease===null) return 1;
+  if(right.prerelease===null) return -1;
+  return left.prerelease.localeCompare(right.prerelease,'en',{numeric:true,sensitivity:'case'});
+}
+function assertManifest(value,label){
+  if(!HEX64.test(String(value??''))) throw new Error(`${label} must be lowercase SHA-256`);
+  return value;
+}
+export async function ensureRuntimeCoherence({
+  cliVersion,packageManifestSha256,readActive,disarmPrivileged,activateCurrentPackage,onEvent=()=>{}
+}={}){
+  parseSemver(cliVersion);assertManifest(packageManifestSha256,'package manifest');
+  if(typeof readActive!=='function'||typeof disarmPrivileged!=='function'||typeof activateCurrentPackage!=='function'||typeof onEvent!=='function') {
+    throw new Error('runtime coherence callbacks invalid');
+  }
+  const initial=await readActive();
+  if(!initial) return {status:'unbound',active:null};
+  const activeVersion=String(initial.version??'');
+  const relation=compareRuntimeVersions(cliVersion,activeVersion);
+  if(relation===0){
+    if(String(initial.manifest_sha256??'')!==packageManifestSha256) {
+      throw new Error(`runtime manifest skew for ${cliVersion}: package ${packageManifestSha256}; active ${String(initial.manifest_sha256??'missing')}`);
+    }
+    return {status:'coherent',active:initial};
+  }
+  if(relation<0) throw new Error(`active runtime ${activeVersion} is newer than CLI package ${cliVersion}; refusing automatic downgrade`);
+  onEvent({phase:'upgrade_start',from_version:activeVersion,to_version:cliVersion,from_release_id:initial.release_id??null});
+  await disarmPrivileged();
+  await activateCurrentPackage();
+  const active=await readActive();
+  if(!active) throw new Error('runtime coherence activation completed without active release pointer');
+  if(String(active.version??'')!==cliVersion) throw new Error(`runtime coherence activation version mismatch: expected ${cliVersion}, found ${String(active.version??'missing')}`);
+  if(String(active.manifest_sha256??'')!==packageManifestSha256) {
+    throw new Error(`runtime coherence activation manifest mismatch: expected ${packageManifestSha256}, found ${String(active.manifest_sha256??'missing')}`);
+  }
+  onEvent({phase:'upgrade_complete',from_version:activeVersion,to_version:cliVersion,release_id:active.release_id??null});
+  return {status:'upgraded',active};
+}

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.27';
+export const DEADBYTE_VERSION = '0.15.28';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/coding-runtime.test.mjs

@@ -39,7 +39,7 @@ async function fixture({ armed = true } = {}) {
   }
   const runtime = createCodingRuntime({ policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath });
   const tasks = createCodingTaskRuntime({ codingRuntime: runtime, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath });
-  return { root, project, policy, runtime, tasks };
+  return { root, project, policy, runtime, tasks, keys };
 }
 test('coding plane edits files under lease and verifies signed action receipts', async () => {
   const f = await fixture();
@@ -233,3 +233,37 @@ test('coding task rejects recomputed journal content without the private signing
     await assert.rejects(() => f.tasks.status({ taskId: submitted.task_id }), /signature verification failed|hash-chain mismatch/);
   } finally { await rm(f.root, { recursive: true, force: true }); }
 });
+
+
+test('R51 coding command retries reuse one in-flight execution and completed receipt', async () => {
+  const f = await fixture();
+  try {
+    const script = path.join(f.project, 'dedup.mjs');
+    await writeFile(script, "import { appendFileSync } from 'node:fs'; appendFileSync('runs.txt', process.pid+'\\n'); await new Promise(r=>setTimeout(r,250)); process.stdout.write('dedup-ok');");
+    const args={rootId:'project',commandId:'node_script',scriptPath:'dedup.mjs',scriptSha256:await sha256File(script),timeoutMs:5000};
+    const [a,b]=await Promise.all([f.runtime.commandRun(args),f.runtime.commandRun(args)]);
+    assert.equal(a.status,'passed',a.stderr);assert.equal(b.status,'passed',b.stderr);
+    assert.equal(a.request_sha256,b.request_sha256);
+    assert.equal(a.receipt_id,b.receipt_id,'same logical request must reuse the same signed execution receipt');
+    const c=await f.runtime.commandRun(args);
+    assert.equal(c.receipt_id,a.receipt_id,'completed retry must reuse bounded cached execution result');
+    const runs=(await readFile(path.join(f.project,'runs.txt'),'utf8')).trim().split(/\\r?\\n/).filter(Boolean);
+    assert.equal(runs.length,1,'retry spawned duplicate child process');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R51 coding command single-flight spans independent runtime instances sharing evidence state', async () => {
+  const f = await fixture();
+  try {
+    const script = path.join(f.project, 'cross-runtime-dedup.mjs');
+    await writeFile(script, "import { appendFileSync } from 'node:fs'; appendFileSync('cross-runs.txt', process.pid+'\\n'); await new Promise(r=>setTimeout(r,500)); process.stdout.write('cross-ok');");
+    const second = createCodingRuntime({ policy:f.policy, signingKeyPath:f.keys.privateKeyPath, verifyKeyPath:f.keys.publicKeyPath });
+    const args={rootId:'project',commandId:'node_script',scriptPath:'cross-runtime-dedup.mjs',scriptSha256:await sha256File(script),timeoutMs:5000};
+    const [a,b]=await Promise.all([f.runtime.commandRun(args),second.commandRun(args)]);
+    assert.equal(a.status,'passed',a.stderr);assert.equal(b.status,'passed',b.stderr);
+    assert.equal(a.request_sha256,b.request_sha256);
+    assert.equal(a.receipt_id,b.receipt_id,'shared evidence state must converge on one signed execution receipt');
+    const runs=(await readFile(path.join(f.project,'cross-runs.txt'),'utf8')).trim().split(/\\r?\\n/).filter(Boolean);
+    assert.equal(runs.length,1,'independent runtime instances spawned duplicate child processes');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});

package/test/production-docs.test.mjs

@@ -3,15 +3,17 @@ import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { DEADBYTE_VERSION } from '../src/version.mjs';
 
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
+const versionPattern=DEADBYTE_VERSION.replace(/[.*+?^$()|[\]\\]/g,'\\$&');
 
 test('production README documents one-command stdio configs for major MCP clients',async()=>{
   const text=await readme();
-  assert.match(text,/npx -y deadbyte-mcp@0\.15\.5 mcp/);
+  assert.match(text,new RegExp(`npx -y deadbyte-mcp@${versionPattern} mcp`));
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.15\.5"[\s\S]*?"mcp"/);
+  assert.match(text,new RegExp(`"mcpServers"[\\s\\S]*?"command"\\s*:\\s*"npx"[\\s\\S]*?"-y"[\\s\\S]*?"deadbyte-mcp@${versionPattern}"[\\s\\S]*?"mcp"`));
   assert.match(text,/CURSOR/);
   assert.match(text,/\.cursor\/mcp\.json/);
   assert.match(text,/VS CODE/);
@@ -20,7 +22,7 @@ test('production README documents one-command stdio configs for major MCP client
   assert.match(text,/CODEX/);
   assert.match(text,/\[mcp_servers\.deadbyte\]/);
   assert.match(text,/command\s*=\s*"npx"/);
-  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.15\.5",\s*"mcp"\]/);
+  assert.match(text,new RegExp(`args\\s*=\\s*\\["-y",\\s*"deadbyte-mcp@${versionPattern}",\\s*"mcp"\\]`));
 });
 
 test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{

package/test/r48-release-contract.test.mjs

@@ -5,37 +5,18 @@ import { DEADBYTE_VERSION } from '../src/version.mjs';
 
 const root = new URL('../', import.meta.url);
 const read = rel => readFile(new URL(rel, root), 'utf8');
+const json = rel => read(rel).then(JSON.parse);
 
-test('R50 0.15.27 successor binds exact published immutable 0.15.26 parent', async () => {
+test('R48 compatibility release contract remains coherent in the current successor', async () => {
   const [pkg, lock, release, provenance, matrix] = await Promise.all([
-    read('package.json').then(JSON.parse),
-    read('package-lock.json').then(JSON.parse),
-    read('RELEASE.json').then(JSON.parse),
-    read('PROVENANCE.json').then(JSON.parse),
-    read('TEST-MATRIX.json').then(JSON.parse)
+    json('package.json'), json('package-lock.json'), json('RELEASE.json'),
+    json('PROVENANCE.json'), json('TEST-MATRIX.json')
   ]);
 
   for (const value of [
-    pkg.version,
-    lock.version,
-    lock.packages[''].version,
-    DEADBYTE_VERSION,
-    release.version,
-    provenance.version,
-    matrix.version
-  ]) assert.equal(value, '0.15.27');
-
-  assert.equal(release.train, 'R50');
-  assert.equal(release.label, 'PUBLIC PACKAGE BOUNDARY HOTFIX');
-  assert.equal(release.parent.release_id, 'v0.15.26-669ea65d2307ee2c');
-  assert.equal(release.parent.manifest_sha256, '669ea65d2307ee2cce06be960e0a8c7243dc6135f7f129a88d99f53096433cc8');
-  assert.equal(release.parent.generation_manifest_sha256, '08364adaf1dab9730c314e29121632c6371ed76fc677e83cb7f6aa6b244eab94');
-
-  assert.equal(release.source_predecessor.version, '0.15.26');
-  assert.equal(release.source_predecessor.tarball_sha256, '3272679e3a18610d47e83dc8d3161e949d75a57da145a43c2ab50c865a83bb86');
-  assert.equal(release.source_predecessor.manifest_file_sha256, '669ea65d2307ee2cce06be960e0a8c7243dc6135f7f129a88d99f53096433cc8');
-  assert.equal(release.source_predecessor.reference_server_sha256, 'dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305');
-  assert.equal(release.source_predecessor.reference_schemas_sha256, 'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140');
+    pkg.version, lock.version, lock.packages[''].version, DEADBYTE_VERSION,
+    release.version, provenance.version, matrix.version
+  ]) assert.equal(value, DEADBYTE_VERSION);
 
   assert.equal(release.capabilities.full_tool_count, 117);
   assert.equal(release.capabilities.desktop_bounded_semantic_wait, true);
@@ -50,8 +31,4 @@ test('R50 0.15.27 successor binds exact published immutable 0.15.26 parent', asy
   assert.equal(provenance.parent_manifest_sha256, release.parent.manifest_sha256);
   assert.equal(provenance.parent_generation_manifest_sha256, release.parent.generation_manifest_sha256);
   assert.equal(provenance.source_predecessor_tarball_sha256, release.source_predecessor.tarball_sha256);
-
-  assert.equal(matrix.train, 'R50');
-  assert.equal(matrix.predecessor_r48_full_regression_partition_proof.files, 211);
-  assert.equal(matrix.predecessor_r48_full_regression_partition_proof.not_valid_as_r50_proof, true);
 });

package/test/r49-windows-gate.test.mjs

@@ -4,27 +4,28 @@ import test from 'node:test';
 
 const read = path => readFile(new URL(`../${path}`, import.meta.url), 'utf8');
 
-test('R50 canonical Windows gate is successor-bound and preserves R49/R48 historical gates', async () => {
-  const [pkgText, gate, evidence, historicalR49, historicalR48, deferred] = await Promise.all([
+test('R51 canonical Windows gate is successor-bound and preserves R50/R49 historical gates', async () => {
+  const [pkgText, gate, evidence, historicalR50, historicalR49, deferred] = await Promise.all([
     read('package.json'),
+    read('scripts/gate-windows-r51.ps1'),
+    read('scripts/windows-gate-evidence-r51.mjs'),
     read('scripts/gate-windows-r50.ps1'),
-    read('scripts/windows-gate-evidence-r50.mjs'),
     read('scripts/gate-windows-r49.ps1'),
-    read('scripts/gate-windows-r48.ps1'),
     read('scripts/deferred-slot-operation-r46.mjs')
   ]);
   const pkg = JSON.parse(pkgText);
-  assert.match(pkg.scripts['gate:windows'], /gate-windows-r50\.ps1$/);
-  assert.match(gate, /DEADBYTE 0\.15\.27 \/ R50 WINDOWS GATE: PASS/);
-  assert.match(gate, /r50-package-boundary/);
+  assert.match(pkg.scripts['gate:windows'], /gate-windows-r51\.ps1$/);
+  assert.match(gate, /DEADBYTE 0\.15\.28 \/ R51 WINDOWS GATE: PASS/);
+  assert.match(gate, /r51-package-boundary/);
+  assert.match(gate, /r51-focused-contracts/);
   assert.match(gate, /r49-remote-control-donors\.test\.mjs/);
   assert.match(gate, /desktop-runtime-r40\.test\.mjs/);
   assert.match(gate, /manifest-final-verify/);
-  assert.match(evidence, /deadbyte\.r50-windows-gate\.v1/);
-  assert.match(evidence, /pkg\.version === '0\.15\.27'/);
-  assert.match(evidence, /release\.train === 'R50'/);
+  assert.match(evidence, /deadbyte\.r51-windows-gate\.v1/);
+  assert.match(evidence, /pkg\.version === '0\.15\.28'/);
+  assert.match(evidence, /release\.train === 'R51'/);
+  assert.match(historicalR50, /DEADBYTE 0\.15\.27 \/ R50 WINDOWS GATE: PASS/);
   assert.match(historicalR49, /DEADBYTE 0\.15\.26 \/ R49 WINDOWS GATE: PASS/);
-  assert.match(historicalR48, /DEADBYTE 0\.15\.25 \/ R48 WINDOWS GATE: PASS/);
   assert.match(deferred, /const expectedVersion=packageIdentity\.version/);
   assert.match(deferred, /'--expected-version',expectedVersion/);
   assert.match(deferred, /async function awaitHandoffCompletion/);

package/test/r51-live-log-polling.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { selectLiveLogNames } from '../src/remote-live-log.mjs';
+import { readFile } from 'node:fs/promises';
+
+test('R51 live log discovery tails only current and previous audit segments plus runtime logs',()=>{
+  const selected=selectLiveLogNames({
+    auditNames:['segment-00000001.jsonl','junk.txt','segment-00000003.jsonl','segment-00000002.jsonl'],
+    runtimeNames:['bridge.stdout.log','bridge.stderr.log','note.txt']
+  });
+  assert.deepEqual(selected.audit,['segment-00000002.jsonl','segment-00000003.jsonl']);
+  assert.deepEqual(selected.runtime,['bridge.stderr.log','bridge.stdout.log']);
+});
+
+test('R51 live tail caches directory discovery instead of rescanning every 250ms poll',async()=>{
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(cli,/LIVE_LOG_DISCOVERY_INTERVAL_MS\s*=\s*1000/);
+  assert.match(cli,/nextDiscoveryAt/);
+  assert.doesNotMatch(cli,/for\(const file of await listLogFiles\(root\)\)/);
+});
+
+test('R51 live tail parses each audit line once and reuses the decoded event',async()=>{
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(cli,/parseAuditLogLine/);
+  assert.match(cli,/auditEvent/);
+  assert.match(cli,/auditTimelineRecord\(file,line,auditEvent\)/);
+  assert.match(cli,/formatLogLine\(file,line,\{auditEvent,/);
+});

package/test/r51-release-contract.test.mjs

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const root=new URL('../',import.meta.url);
+const read=rel=>readFile(new URL(rel,root),'utf8');
+const json=rel=>read(rel).then(JSON.parse);
+
+test('R51 release identity is coherent across package lock source metadata SBOM and gate',async()=>{
+  const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs')
+  ]);
+  assert.equal(pkg.version,'0.15.28');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.28'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R51');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R51');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r51:0.15.28');
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r51\.ps1/);
+});
+
+test('R51 lineage binds exact immutable published 0.15.27 parent',async()=>{
+  const [release,provenance]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json')]);
+  const expected={
+    release_id:'v0.15.27-1b1dbe24b45ad06a',
+    manifest_sha256:'1b1dbe24b45ad06a62771d15f510662952f3d7c3e5aa08053c6c61511c523e47',
+    generation_manifest_sha256:'f87a1637b3c55ba050d079d8a5e0862a2244b306be7e985880708e0d8ded3db0'
+  };
+  assert.deepEqual(release.parent,expected);
+  assert.equal(release.source_predecessor.version,'0.15.27');
+  assert.equal(release.source_predecessor.tarball_sha256,'e728031d097d8678dfef80f8648cce65e72a96611052c31969c80f884506d1d7');
+  assert.equal(release.source_predecessor.manifest_file_sha256,expected.manifest_sha256);
+  assert.equal(provenance.parent_release_id,expected.release_id);
+  assert.equal(provenance.parent_manifest_sha256,expected.manifest_sha256);
+  assert.equal(provenance.parent_generation_manifest_sha256,expected.generation_manifest_sha256);
+  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+});
+
+test('R51 release advertises only implemented coherence single-flight authority and livelog hardening',async()=>{
+  const release=await json('RELEASE.json');
+  for(const key of [
+    'runtime_package_auto_coherence',
+    'coding_command_singleflight',
+    'coding_command_result_dedup_cache',
+    'foreground_desktop_host_fail_closed',
+    'human_livelog_slow_call_marker',
+    'human_livelog_peak_inflight',
+    'human_livelog_bounded_discovery',
+    'human_livelog_single_parse'
+  ]) assert.equal(release.capabilities[key],true,key);
+});

package/test/r51-runtime-coherence.test.mjs

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { ensureRuntimeCoherence } from '../src/runtime-coherence.mjs';
+
+const hex=value=>value.repeat(64).slice(0,64);
+
+test('R51 runtime coherence upgrades older active slot exactly once and verifies final identity',async()=>{
+  let active={version:'0.15.27',manifest_sha256:hex('1'),release_id:'old'};
+  let disarms=0,activations=0;
+  const events=[];
+  const result=await ensureRuntimeCoherence({
+    cliVersion:'0.15.28',packageManifestSha256:hex('2'),
+    readActive:async()=>active,
+    disarmPrivileged:async()=>{disarms++;},
+    activateCurrentPackage:async()=>{activations++;active={version:'0.15.28',manifest_sha256:hex('2'),release_id:'new'};},
+    onEvent:event=>events.push(event)
+  });
+  assert.equal(result.status,'upgraded');
+  assert.equal(result.active.version,'0.15.28');
+  assert.equal(disarms,1);assert.equal(activations,1);
+  assert.deepEqual(events.map(event=>event.phase),['upgrade_start','upgrade_complete']);
+});
+
+test('R51 runtime coherence is non-mutating when version and manifest already match',async()=>{
+  let mutations=0;
+  const active={version:'0.15.28',manifest_sha256:hex('a'),release_id:'same'};
+  const result=await ensureRuntimeCoherence({cliVersion:'0.15.28',packageManifestSha256:hex('a'),readActive:async()=>active,
+    disarmPrivileged:async()=>{mutations++;},activateCurrentPackage:async()=>{mutations++;}});
+  assert.equal(result.status,'coherent');assert.equal(mutations,0);
+});
+
+test('R51 runtime coherence refuses downgrade and same-version manifest drift',async()=>{
+  await assert.rejects(()=>ensureRuntimeCoherence({cliVersion:'0.15.28',packageManifestSha256:hex('a'),
+    readActive:async()=>({version:'0.15.29',manifest_sha256:hex('b')}),disarmPrivileged:async()=>{},activateCurrentPackage:async()=>{}}),/newer than CLI/i);
+  await assert.rejects(()=>ensureRuntimeCoherence({cliVersion:'0.15.28',packageManifestSha256:hex('a'),
+    readActive:async()=>({version:'0.15.28',manifest_sha256:hex('b')}),disarmPrivileged:async()=>{},activateCurrentPackage:async()=>{}}),/manifest skew/i);
+});
+
+
+test('R51 bare remote wires coherence before live generation binding and deploy honors state root override',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  const deploy=await readFile(new URL('../scripts/deploy-r48.mjs',import.meta.url),'utf8');
+  assert.match(cli,/ensureRuntimeCoherence/);
+  assert.match(cli,/synchronizeForegroundRuntime/);
+  const syncAt=cli.indexOf('await synchronizeForegroundRuntime');
+  const rootsAt=cli.indexOf('await readLiveRootPaths');
+  assert.ok(syncAt>=0&&rootsAt>syncAt,'runtime coherence must complete before binding generation root paths');
+  assert.match(deploy,/process\.env\.DEADBYTE_STATE_ROOT/);
+});
+
+
+test('R51 foreground authority contract explicitly verifies and cleans desktop plus host',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(cli,/\['desktopstatus',\/\^Desktop plane/);
+  assert.match(cli,/SESSION_CLEANUP=.*disarmdesktop.*disarmhost/s);
+  assert.match(cli,/desktop, host DISARMED/);
+});

package/test/remote-live-log-r37.test.mjs

@@ -204,3 +204,17 @@ test('expanded session summary reports outcome classes latency and slowest tool'
   assert.match(summary,/p50 75ms \| p95 200ms/);
   assert.match(summary,/slowest host_exec 200ms/);
 });
+
+
+test('R51 live timeline marks slow calls and reports peak in-flight concurrency',()=>{
+  let now=1000;
+  const tracker=createLiveTimelineTracker({clock:()=>now,slowCallMs:1000});
+  tracker.observe({event_type:'tool.request',tool:'coding_command_run',request_id:'slow-a-12345678',args:{root_id:'core',command_id:'node_script',script_path:'a.mjs'}});
+  tracker.observe({event_type:'tool.request',tool:'coding_file_read',request_id:'slow-b-12345678',args:{root_id:'core',path:'b.txt'}});
+  now=2500;
+  const line=tracker.observe({event_type:'tool.result',tool:'coding_command_run',request_id:'slow-a-12345678',outcome:{is_error:false,duration_ms:1500}});
+  assert.match(line,/1500ms|1\.50s/);
+  assert.match(line,/\[SLOW\]/);
+  tracker.observe({event_type:'tool.result',tool:'coding_file_read',request_id:'slow-b-12345678',outcome:{is_error:false,duration_ms:5}});
+  assert.match(tracker.summary(),/peak in-flight 2/);
+});

package/test/remote-session-cli.test.mjs

@@ -23,7 +23,7 @@ async function fixture({failCommand='',statusOnline=false}={}){
   const spawnedPid=path.join(dir,'spawned.pid');
   await mkdir(bin,{recursive:true});
   const launcher=path.join(bin,'DEADBYTE-MCP.ps1');
-  const ps1=`param([string]$Command)\n$ErrorActionPreference='Stop'\nfor($i=0;$i -lt 20;$i++){ try { [IO.File]::AppendAllText($env:DEADBYTE_REMOTE_TEST_TRACE,(\"$Command\" + [Environment]::NewLine),[Text.Encoding]::UTF8); break } catch { if($i -eq 19){ throw }; Start-Sleep -Milliseconds 10 } }\nif ($env:DEADBYTE_REMOTE_TEST_FAIL -and $Command -eq $env:DEADBYTE_REMOTE_TEST_FAIL) { $runtime=Join-Path $env:DEADBYTE_STATE_ROOT 'runtime'; New-Item -ItemType Directory -Path $runtime -Force | Out-Null; $failure=@{ schema='deadbyte.controller-start-failure.v1'; command=$Command; failed_at_utc='2026-09-26T00:00:00.000Z'; message='fixture controller evidence detail' } | ConvertTo-Json -Compress; [IO.File]::WriteAllText((Join-Path $runtime 'controller-start-failure.json'),$failure,[Text.Encoding]::UTF8); Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { if ($env:DEADBYTE_REMOTE_TEST_SPAWN_CHILD -eq '1') { $node=(Get-Command node.exe).Source; $spawned=Start-Process -FilePath $node -ArgumentList @('-e','setTimeout(()=>process.exit(0),10000)') -PassThru -WindowStyle Hidden -RedirectStandardOutput $env:DEADBYTE_REMOTE_TEST_SPAWN_STDOUT -RedirectStandardError $env:DEADBYTE_REMOTE_TEST_SPAWN_STDERR; if ($env:DEADBYTE_REMOTE_TEST_SPAWN_PID) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_SPAWN_PID,[string]$spawned.Id,[Text.Encoding]::UTF8) } }; if ($env:DEADBYTE_REMOTE_TEST_STARTED) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_STARTED,'1',[Text.Encoding]::UTF8) }; Write-Host 'DEADBYTE MCP = ONLINE' }\n  'status' { if ($env:DEADBYTE_REMOTE_TEST_STATUS_ONLINE -eq '1' -or ($env:DEADBYTE_REMOTE_TEST_STARTED -and (Test-Path -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED))) { Write-Host 'DEADBYTE MCP = ONLINE'; Write-Host 'Bridge PID   : 1001 [verified]'; Write-Host 'Cloud PID    : 1002 [verified]'; Write-Host 'Local ready  : True'; Write-Host 'Loop supervisor: RUNNING [verified]' } else { Write-Host 'DEADBYTE MCP = OFFLINE' } }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'hoststatus' { Write-Host 'Host plane    : DISARMED [disarmed]' }\n  'park' { if ($env:DEADBYTE_REMOTE_TEST_STARTED) { Remove-Item -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED -Force -ErrorAction SilentlyContinue }; Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
+  const ps1=`param([string]$Command)\n$ErrorActionPreference='Stop'\nfor($i=0;$i -lt 20;$i++){ try { [IO.File]::AppendAllText($env:DEADBYTE_REMOTE_TEST_TRACE,(\"$Command\" + [Environment]::NewLine),[Text.Encoding]::UTF8); break } catch { if($i -eq 19){ throw }; Start-Sleep -Milliseconds 10 } }\nif ($env:DEADBYTE_REMOTE_TEST_FAIL -and $Command -eq $env:DEADBYTE_REMOTE_TEST_FAIL) { $runtime=Join-Path $env:DEADBYTE_STATE_ROOT 'runtime'; New-Item -ItemType Directory -Path $runtime -Force | Out-Null; $failure=@{ schema='deadbyte.controller-start-failure.v1'; command=$Command; failed_at_utc='2026-09-26T00:00:00.000Z'; message='fixture controller evidence detail' } | ConvertTo-Json -Compress; [IO.File]::WriteAllText((Join-Path $runtime 'controller-start-failure.json'),$failure,[Text.Encoding]::UTF8); Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { if ($env:DEADBYTE_REMOTE_TEST_SPAWN_CHILD -eq '1') { $node=(Get-Command node.exe).Source; $spawned=Start-Process -FilePath $node -ArgumentList @('-e','setTimeout(()=>process.exit(0),10000)') -PassThru -WindowStyle Hidden -RedirectStandardOutput $env:DEADBYTE_REMOTE_TEST_SPAWN_STDOUT -RedirectStandardError $env:DEADBYTE_REMOTE_TEST_SPAWN_STDERR; if ($env:DEADBYTE_REMOTE_TEST_SPAWN_PID) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_SPAWN_PID,[string]$spawned.Id,[Text.Encoding]::UTF8) } }; if ($env:DEADBYTE_REMOTE_TEST_STARTED) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_STARTED,'1',[Text.Encoding]::UTF8) }; Write-Host 'DEADBYTE MCP = ONLINE' }\n  'status' { if ($env:DEADBYTE_REMOTE_TEST_STATUS_ONLINE -eq '1' -or ($env:DEADBYTE_REMOTE_TEST_STARTED -and (Test-Path -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED))) { Write-Host 'DEADBYTE MCP = ONLINE'; Write-Host 'Bridge PID   : 1001 [verified]'; Write-Host 'Cloud PID    : 1002 [verified]'; Write-Host 'Local ready  : True'; Write-Host 'Loop supervisor: RUNNING [verified]' } else { Write-Host 'DEADBYTE MCP = OFFLINE' } }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'desktopstatus' { Write-Host 'Desktop plane : DISARMED [disarmed]' }\n  'hoststatus' { Write-Host 'Host plane    : DISARMED [disarmed]' }\n  'park' { if ($env:DEADBYTE_REMOTE_TEST_STARTED) { Remove-Item -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED -Force -ErrorAction SilentlyContinue }; Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
   await writeFile(launcher,ps1,'utf8');
   return {dir,state,trace,env:{...process.env,DEADBYTE_STATE_ROOT:state,DEADBYTE_REMOTE_TEST_TRACE:trace,DEADBYTE_REMOTE_TEST_FAIL:failCommand,DEADBYTE_REMOTE_TEST_STATUS_ONLINE:statusOnline?'1':'0',DEADBYTE_REMOTE_TEST_STARTED:startedMarker,DEADBYTE_REMOTE_TEST_SPAWN_STDOUT:spawnedStdout,DEADBYTE_REMOTE_TEST_SPAWN_STDERR:spawnedStderr,DEADBYTE_REMOTE_TEST_SPAWN_PID:spawnedPid},spawnedPid};
 }
@@ -77,17 +77,17 @@ winTest('bare remote reuses a fully verified ONLINE runtime without invoking blo
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
     const ready=await waitFor(fx.trace,commands=>commands.includes('hoststatus'),{timeoutMs:8000});
-    assert.deepEqual(ready.slice(0,8),[
+    assert.deepEqual(ready.slice(0,9),[
       'status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','hoststatus'
+      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
     ]);
     assert.doesNotMatch(ready.join(','),/(^|,)start(,|$)/);
     assert.equal(child.exitCode,null,'remote session must remain foreground after reusing ONLINE runtime');
     assert.match(output.stdout,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
     const authDeadline=Date.now()+3000;
-    while(Date.now()<authDeadline&&!/\[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/.test(output.stdout)) await sleep(50);
+    while(Date.now()<authDeadline&&!/\[AUTH\] ARMED: process, coding, autonomous \| desktop, host DISARMED/.test(output.stdout)) await sleep(50);
     assert.match(output.stdout,/\[DISPLAY\] ASCII fallback: stdout_not_tty/);
-    assert.match(output.stdout,/\[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/);
+    assert.match(output.stdout,/\[AUTH\] ARMED: process, coding, autonomous \| desktop, host DISARMED/);
     child.kill('SIGINT');
     await output.closed;
   }finally{
@@ -106,9 +106,9 @@ winTest('bare remote PARKED startup does not wait for a long-lived child holding
     const output=await collect(child);
     const ready=await waitFor(fx.trace,commands=>commands.includes('hoststatus'),{timeoutMs:8000});
     const elapsed=Date.now()-startedAt;
-    assert.deepEqual(ready.slice(0,10),[
+    assert.deepEqual(ready.slice(0,11),[
       'status','start','status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','hoststatus'
+      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
     ]);
     assert.ok(elapsed<7000,`PARKED startup waited on inherited child pipe handles: ${elapsed}ms`);
     assert.equal(child.exitCode,null,'remote session must remain foreground after PARKED startup');
@@ -133,13 +133,13 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
     const ready=await waitFor(fx.trace,commands=>commands.slice(0,10).join(',')==='status,start,status,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,10),[
+    assert.deepEqual(ready.slice(0,11),[
       'status','start','status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','hoststatus'
+      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
     ]);
     assert.equal(child.exitCode,null,'remote session must remain foreground after becoming ready');
     const tailDeadline=Date.now()+3000;
-    while(Date.now()<tailDeadline&&!/\[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/.test(output.stdout)) await sleep(50);
+    while(Date.now()<tailDeadline&&!/\[AUTH\] ARMED: process, coding, autonomous \| desktop, host DISARMED/.test(output.stdout)) await sleep(50);
     assert.match(output.stdout,/\[DISPLAY\] ASCII fallback: stdout_not_tty/);
     assert.match(output.stdout,/\[DEVICE\] Starting DEADBYTE MCP/);
     assert.match(output.stdout,/\[BRIDGE\] Local bridge connected/);
@@ -148,7 +148,7 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     assert.match(output.stdout,/\[BOOT\] Starting local \+ remote runtime/);
     assert.match(output.stdout,/\[OK\] ONLINE/);
     assert.match(output.stdout,/\[READY\] DEADBYTE MCP online/);
-    assert.match(output.stdout,/\[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/);
+    assert.match(output.stdout,/\[AUTH\] ARMED: process, coding, autonomous \| desktop, host DISARMED/);
     assert.match(output.stdout,/\[LOG\] Human live timeline\. Transport IN\/OUT hidden; full replay\/audit detail remains on disk\./);
     assert.doesNotMatch(output.stdout,/Process plane\s*:/);
     assert.doesNotMatch(output.stdout,/Coding plane\s*:/);
@@ -172,10 +172,10 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
       '[TOOL OUT] 2026-09-16T00:00:00.002Z #000002 coding_file_read {"is_error":true}'
     ].join('\n')+'\n','utf8');
     const logDeadline=Date.now()+3000;
-    while(Date.now()<logDeadline&&!/^R  .*#4  \[fedcba98\]  coding_file_read  projects:src\/deadbyte-cli\.mjs  1\.73s  ERR$/m.test(output.stdout)) await sleep(50);
+    while(Date.now()<logDeadline&&!/^R  .*#4  \[fedcba98\]  coding_file_read  projects:src\/deadbyte-cli\.mjs  1\.73s  \[SLOW\]  ERR$/m.test(output.stdout)) await sleep(50);
     assert.doesNotMatch(output.stdout,/\| Arguments:/,'default human view must not print request JSON');
     assert.match(output.stdout,/^S  .*#2  \[abcdef12\]  coding_tree  projects:src  42ms  OK$/m);
-    assert.match(output.stdout,/^R  .*#4  \[fedcba98\]  coding_file_read  projects:src\/deadbyte-cli\.mjs  1\.73s  ERR$/m);
+    assert.match(output.stdout,/^R  .*#4  \[fedcba98\]  coding_file_read  projects:src\/deadbyte-cli\.mjs  1\.73s  \[SLOW\]  ERR$/m);
     assert.equal((output.stdout.match(/\[abcdef12\].*coding_tree.*42ms.*OK/g)||[]).length,1,'duplicate terminal result must print once');
     assert.doesNotMatch(output.stdout,/\[cursor r1:/,'full replay cursor belongs in the journal, not every human line');
     const resultJournal=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-results',`${marker.result_session_id}.json`),'utf8'));
@@ -194,11 +194,11 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
     assert.equal(ended.timeout,undefined,'remote session did not exit after foreground input closed');
     const commands=await traceCommands(fx.trace);
-    assert.deepEqual(commands.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
+    assert.deepEqual(commands.slice(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
     assert.match(output.stdout,/^DEADBYTE MCP$/m);
     assert.match(output.stdout,/Human live timeline/i);
     assert.match(output.stdout,/\[AUTH\] Revoking session authority/);
-    assert.doesNotMatch(output.stdout,/disarmautonomous OK|disarmcoding OK|disarmprocess OK|disarmhost OK|DEADBYTE MCP = PARKED/);
+    assert.doesNotMatch(output.stdout,/disarmautonomous OK|disarmcoding OK|disarmprocess OK|disarmdesktop OK|disarmhost OK|DEADBYTE MCP = PARKED/);
     assert.doesNotMatch(output.stdout,/\p{Extended_Pictographic}/u,'piped Windows fallback must remain ASCII-safe');
   }finally{
     if(child?.exitCode===null) child.kill();
@@ -293,7 +293,7 @@ winTest('remote --verbose enables sanitized request detail while preserving fore
     assert.equal(ended.timeout,undefined);
     assert.equal(ended.code,0,output.stderr);
     const commands=await traceCommands(fx.trace);
-    assert.deepEqual(commands.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
+    assert.deepEqual(commands.slice(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
     await rm(fx.dir,{recursive:true,force:true});
@@ -307,9 +307,9 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
     const ready=await waitFor(fx.trace,commands=>commands.slice(0,10).join(',')==='status,start,status,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,10),[
+    assert.deepEqual(ready.slice(0,11),[
       'status','start','status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','hoststatus'
+      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
     ]);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
     const markerDeadline=Date.now()+3000;
@@ -327,8 +327,8 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
     assert.equal(killed,true,'failed to hard-kill remote owner');
     await Promise.race([output.closed,sleep(3000)]);
 
-    const cleaned=await waitFor(fx.trace,commands=>commands.slice(-5).join(',')==='disarmautonomous,disarmcoding,disarmprocess,disarmhost,park',{timeoutMs:10000});
-    assert.deepEqual(cleaned.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
+    const cleaned=await waitFor(fx.trace,commands=>commands.slice(-6).join(',')==='disarmautonomous,disarmcoding,disarmprocess,disarmhost,park',{timeoutMs:10000});
+    assert.deepEqual(cleaned.slice(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
     const markerGoneDeadline=Date.now()+3000;
     let markerGone=false;
     while(Date.now()<markerGoneDeadline){
@@ -352,7 +352,7 @@ winTest('bare remote rolls back authority and parks if one plane fails to arm',a
     assert.notEqual(ended.code,0);
     const commands=await traceCommands(fx.trace);
     assert.deepEqual(commands.slice(0,5),['status','start','status','armprocess','armcoding']);
-    assert.deepEqual(commands.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
+    assert.deepEqual(commands.slice(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
     assert.doesNotMatch(output.stdout,/Live logs/i);
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });
@@ -367,9 +367,9 @@ winTest('bare remote recovers a stale crashed session before arming a new one',a
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
     const ready=await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
-    assert.deepEqual(ready.slice(0,5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
-    assert.equal(ready[5],'status');
-    assert.equal(ready[6],'start');
+    assert.deepEqual(ready.slice(0,6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
+    assert.equal(ready[6],'status');
+    assert.equal(ready[7],'start');
     assert.match(output.stdout,/\[RECOVERY\] Stale remote session pid=2147483000; revoking authority before restart\./);
     child.stdin.end();
     const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);