deadbyte-mcp 0.15.36 → 0.15.37

package/test/r60-remote-call-recovery.test.mjs

@@ -0,0 +1,170 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { openRemoteCallClaims } from '../bridge/src/remote-call-claims-r60.mjs';
+import {canonicalJson as bridgeCanonicalJson} from '../bridge/src/canonical-json-r60.mjs';
+import {canonicalJson as coreCanonicalJson} from '../src/canonical-json.mjs';
+
+const binding={device_id:'device-1',session_id:'session-1',request_id:'call-1',tool:'coding_file_write',
+  arguments:{root_id:'fixture',path:'a.txt',content:'A'},expires_at_utc:'2030-01-01T00:00:00.000Z',
+  release_id:'v0.15.37-test',generation_manifest_sha256:'a'.repeat(64),machine_id:'d'.repeat(64),online_epoch:'c'.repeat(64),classification:'mutating'};
+
+async function withStore(fn){
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-claims-'));
+  try{await fn(openRemoteCallClaims({root:dir,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')}));}
+  finally{await rm(dir,{recursive:true,force:true});}
+}
+
+test('Bridge and Core canonical argument encoding remain byte-identical',()=>{
+  const value={z:[{b:2,a:1}],a:{thai:'ทดสอบ',x:null}};
+  assert.equal(bridgeCanonicalJson(value),coreCanonicalJson(value));
+});
+
+test('claim refuses missing machine/epoch/classification identity before execution',async()=>withStore(async store=>{
+  await assert.rejects(store.claim({...binding,machine_id:undefined}),/machine_id/);
+  await assert.rejects(store.claim({...binding,online_epoch:undefined}),/online epoch/);
+  await assert.rejects(store.claim({...binding,classification:undefined}),/classification/);
+}));
+
+test('duplicate request identity with same canonical payload never receives a second execution claim',async()=>withStore(async store=>{
+  const first=await store.claim(binding);
+  assert.equal(first.owner,true);
+  const second=await store.claim({...binding,arguments:{content:'A',path:'a.txt',root_id:'fixture'}});
+  assert.equal(second.owner,false);
+  assert.equal(second.state,'CLAIMED');
+  await store.dispatch(first.claim_id);
+  const uncertain=await store.claim(binding);
+  assert.equal(uncertain.owner,false);
+  assert.equal(uncertain.state,'EXECUTING');
+  assert.equal(uncertain.side_effect_state,'may_have_started');
+}));
+
+test('changed payload and expired request fail closed',async()=>withStore(async store=>{
+  await store.claim(binding);
+  await assert.rejects(store.claim({...binding,arguments:{...binding.arguments,content:'B'}}),/request_id_conflict/);
+  await assert.rejects(store.claim({...binding,request_id:'expired',expires_at_utc:'2020-01-01T00:00:00.000Z'}),/expired/);
+}));
+
+test('same JSON-RPC request id in a distinct session is not a duplicate',async()=>withStore(async store=>{
+  const first=await store.claim(binding);
+  const second=await store.claim({...binding,session_id:'session-2'});
+  assert.equal(first.owner,true);
+  assert.equal(second.owner,true);
+  assert.notEqual(first.claim_id,second.claim_id);
+}));
+
+test('an already claimed call cannot acquire a fresh deadline after its original expiry',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-expiry-'));
+  let now=Date.parse('2029-01-01T00:00:00.000Z');
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>now});
+    await store.claim({...binding,expires_at_utc:'2029-01-01T00:00:01.000Z'});
+    now+=2000;
+    await assert.rejects(store.claim({...binding,expires_at_utc:'2029-01-02T00:00:00.000Z'}),/expired/);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+test('stable idempotency key survives transport session and JSON-RPC id changes',async()=>withStore(async store=>{
+  const first=await store.claim({...binding,idempotency_key:'goal-write-1'});
+  await store.dispatch(first.claim_id);
+  await store.terminal(first.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  const replay=await store.claim({...binding,idempotency_key:'goal-write-1',session_id:'session-2',request_id:'call-99'});
+  assert.equal(replay.owner,false);
+  assert.equal(replay.state,'TERMINAL');
+  assert.equal(replay.claim_id,first.claim_id);
+  assert.deepEqual(replay.result,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  await assert.rejects(store.claim({...binding,idempotency_key:'goal-write-1',session_id:'session-3',request_id:'call-100',arguments:{...binding.arguments,content:'B'}}),/idempotency_key_conflict/);
+}));
+
+test('same JSON-RPC id with a different stable key is a distinct logical mutation',async()=>withStore(async store=>{
+  const first=await store.claim({...binding,idempotency_key:'goal-write-1'});
+  const second=await store.claim({...binding,idempotency_key:'goal-write-2'});
+  assert.equal(first.owner,true);
+  assert.equal(second.owner,true);
+  assert.notEqual(first.claim_id,second.claim_id);
+}));
+
+test('concurrent duplicate claims have one owner and terminal result is replayable without dispatch',async()=>withStore(async store=>{
+  const claims=await Promise.all(Array.from({length:12},()=>store.claim(binding)));
+  assert.equal(claims.filter(item=>item.owner).length,1);
+  const id=claims[0].claim_id;
+  await store.dispatch(id);
+  await assert.rejects(store.dispatch(id),/already dispatched/);
+  await store.terminal(id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  const replay=await store.claim(binding);
+  assert.equal(replay.owner,false);
+  assert.equal(replay.state,'TERMINAL');
+  assert.deepEqual(replay.result,{status:'ok',receipt_sha256:'b'.repeat(64)});
+}));
+
+test('corrupted terminal bytes fail closed instead of replaying altered success',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-corrupt-'));
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')});
+    const first=await store.claim(binding);
+    await store.dispatch(first.claim_id);
+    await store.terminal(first.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+    const file=path.join(dir,first.claim_id.slice(0,2),`${first.claim_id}.terminal.json`);
+    const original=await readFile(file,'utf8');
+    await writeFile(file,original.replace('"status":"ok"','"status":"forged"'));
+    await assert.rejects(store.claim(binding),/terminal.*hash|corrupt/i);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+test('corrupted required claim record fails closed before any duplicate dispatch',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-corrupt-'));
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>Date.parse('2029-01-01T00:00:00.000Z')});
+    const first=await store.claim(binding);
+    const file=path.join(dir,first.claim_id.slice(0,2),`${first.claim_id}.claim.json`);
+    const original=await readFile(file,'utf8');
+    await writeFile(file,original.replace('"tool":"coding_file_write"','"tool":"host_exec"'));
+    await assert.rejects(store.claim(binding),/claim.*hash|corrupt/i);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+test('startup recovery marks only post-dispatch mutations interrupted and leaves pre-effect claims recoverable',async()=>withStore(async store=>{
+  const pending=await store.claim({...binding,request_id:'pre-effect'});
+  const uncertain=await store.claim({...binding,request_id:'post-dispatch'});
+  await store.dispatch(uncertain.claim_id);
+  const batch=await store.recover({limit:100});
+  assert.equal(batch.records.length,2);
+  assert.equal((await store.state(pending.claim_id)).state,'CLAIMED');
+  const after=await store.state(uncertain.claim_id);
+  assert.equal(after.state,'INTERRUPTED');
+  assert.equal(after.side_effect_state,'unknown');
+}));
+
+
+test('recovery inventory excludes terminal and expired claims while retaining eligible pre-effect work',async()=>{
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r60-recovery-filter-'));
+  let now=Date.parse('2029-01-01T00:00:00.000Z');
+  try{
+    const store=openRemoteCallClaims({root:dir,clock:()=>now});
+    const terminal=await store.claim({...binding,request_id:'terminal-history',expires_at_utc:'2030-01-01T00:00:00.000Z'});
+    await store.dispatch(terminal.claim_id);
+    await store.terminal(terminal.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+    const expired=await store.claim({...binding,request_id:'expired-history',expires_at_utc:'2029-01-01T00:00:01.000Z'});
+    const pending=await store.claim({...binding,request_id:'eligible-pending',expires_at_utc:'2030-01-01T00:00:00.000Z'});
+    now+=2000;
+    const batch=await store.recover({limit:100});
+    const ids=new Set(batch.records.map(item=>item.claim_id));
+    assert.equal(ids.has(terminal.claim_id),false,'terminal history is not recovery work');
+    assert.equal(ids.has(expired.claim_id),false,'expired work must not consume recovery budget');
+    assert.equal(ids.has(pending.claim_id),true,'eligible pre-effect claim must remain recoverable');
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+
+
+test('stable idempotency key cannot replay execution evidence across machine online epoch rotation',async()=>withStore(async store=>{
+  const keyed={...binding,idempotency_key:'epoch-bound-write'};
+  const first=await store.claim(keyed);
+  await store.dispatch(first.claim_id);
+  await store.terminal(first.claim_id,{status:'ok',receipt_sha256:'b'.repeat(64)});
+  await assert.rejects(
+    store.claim({...keyed,session_id:'session-after-revoke',request_id:'retry-after-revoke',online_epoch:'e'.repeat(64)}),
+    /epoch|identity drift/i
+  );
+}));

package/test/r60-windows-log-decode.test.mjs

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { decodeRemoteLogBytes, boundedRemoteDiagnostic, safeRemoteLogPrefixLength } from '../src/remote-log-decode-r60.mjs';
+
+test('known Windows log source decodes UTF-16LE BOM without corrupting text',()=>{
+  const bytes=Buffer.concat([Buffer.from([0xff,0xfe]),Buffer.from('[TOOL] ✓ host_file_read\r\n','utf16le')]);
+  assert.equal(decodeRemoteLogBytes('controller-start.stdout.log',bytes),'[TOOL] ✓ host_file_read\r\n');
+  assert.notEqual(decodeRemoteLogBytes('segment-00000001.jsonl',bytes),'[TOOL] ✓ host_file_read\r\n');
+});
+
+test('diagnostic preview removes NUL/control injection and remains bounded',()=>{
+  const value=boundedRemoteDiagnostic('ok\0secret\r\n'+('x'.repeat(3000)),128);
+  assert.ok(!value.includes('\0'));
+  assert.ok(value.length<=131);
+  assert.equal(value.split('\n').length,1);
+});
+
+test('bounded log pages do not split UTF-8 or UTF-16 characters',()=>{
+  const utf8=Buffer.from('A😀','utf8');
+  assert.equal(safeRemoteLogPrefixLength(utf8.subarray(0,4),'utf8'),1);
+  assert.equal(safeRemoteLogPrefixLength(utf8,'utf8'),5);
+  const utf16=Buffer.from('A😀','utf16le');
+  assert.equal(safeRemoteLogPrefixLength(utf16.subarray(0,4),'utf16le'),2);
+  assert.equal(safeRemoteLogPrefixLength(utf16,'utf16le'),6);
+});

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

@@ -33,7 +33,7 @@ test('R40 long or mutating call gets start line and terminal error carries sanit
 
 test('R40 heartbeat burst folds repeated status calls instead of printing every round-trip',()=>{
   let now=1000;
-  const tracker=createLiveTimelineTracker({clock:()=>now,heartbeatBurstLimit:5,heartbeatWindowMs:3000});
+  const tracker=createLiveTimelineTracker({clock:()=>now,foldHeartbeats:true,heartbeatBurstLimit:5,heartbeatWindowMs:3000});
   for(let i=0;i<5;i++){
     const id='ping-'+String(i).padStart(12,'0');
     tracker.observe({event_type:'tool.request',tool:'machine_ping',request_id:id,args:{nonce:'mcpbench-'+i}},{sequence:30+i*2});

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

@@ -24,7 +24,12 @@ async function fixture({failCommand='',statusOnline=false}={}){
   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  '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');
+  const structured=`function PlaneArmed([string]$name,[bool]$default) { $base=Join-Path $env:DEADBYTE_STATE_ROOT ('runtime\\' + $name); if (Test-Path -LiteralPath ($base + '.disarmed')) { return $false }; if (Test-Path -LiteralPath ($base + '.armed')) { return $true }; return $default }
+if ($Command -eq 'status' -and $Json) { $names=@('process','coding','autonomous','desktop','host'); $authority=@{}; foreach($name in $names){ $initial=($name -in @('process','coding','autonomous')) -or (($name -eq 'host') -and ($env:DEADBYTE_REMOTE_TEST_HOST_ARMED -eq '1')) -or (($name -eq 'desktop') -and ($env:DEADBYTE_REMOTE_TEST_DESKTOP_ARMED -eq '1')); $armed=PlaneArmed $name $initial; if($name -eq 'host' -and (($env:DEADBYTE_REMOTE_TEST_JSON_HOST_LIE_ALWAYS -eq '1') -or (($env:DEADBYTE_REMOTE_TEST_JSON_HOST_LIE -eq '1') -and (Test-Path -LiteralPath (Join-Path $env:DEADBYTE_STATE_ROOT 'runtime\\host.disarm-attempt'))))){$armed=$false}; $authority[$name]=@{ configured=$true; armed=$armed; reason=$(if($armed){'standing-grant'}else{'disarmed'}) } }; @{schema='deadbyte.controller-observation.v1';state='ONLINE';local_ready=$true;core_root='fixture';bridge=@{alive=$true;reason='verified'};core=@{alive=$true;reason='verified'};cloud=@{alive=$true;reason='verified'};supervisor=@{running=$true};authority=$authority} | ConvertTo-Json -Depth 5 -Compress; exit 0 }
+if ($Command -eq 'machinetest' -and $env:DEADBYTE_REMOTE_PROBE_MODE) { $hostArmed=PlaneArmed 'host' ($env:DEADBYTE_REMOTE_TEST_HOST_ARMED -eq '1'); $desktopArmed=PlaneArmed 'desktop' ($env:DEADBYTE_REMOTE_TEST_DESKTOP_ARMED -eq '1'); $wantHost=$env:DEADBYTE_REMOTE_PROBE_MODE -in @('host','full'); $wantDesktop=$env:DEADBYTE_REMOTE_PROBE_MODE -in @('desktop','full'); if($hostArmed -ne $wantHost -or $desktopArmed -ne $wantDesktop){ Write-Error 'remote enforcement probe mismatch'; exit 9 } }
+if ($Command -match '^(arm|disarm)(process|coding|autonomous|desktop|host)$') { $name=$Matches[2]; $base=Join-Path $env:DEADBYTE_STATE_ROOT ('runtime\\' + $name); New-Item -ItemType Directory -Path (Split-Path $base) -Force | Out-Null; if ($Matches[1] -eq 'arm') { [IO.File]::WriteAllText(($base+'.armed'),'1'); Remove-Item -LiteralPath ($base+'.disarmed') -Force -ErrorAction SilentlyContinue } elseif ($env:DEADBYTE_REMOTE_TEST_DISARM_NOOP -ne $name) { [IO.File]::WriteAllText(($base+'.disarmed'),'1'); Remove-Item -LiteralPath ($base+'.armed') -Force -ErrorAction SilentlyContinue } else { [IO.File]::WriteAllText(($base+'.disarm-attempt'),'1') } }
+switch ($Command) {`;
+  await writeFile(launcher,ps1.replace('param([string]$Command)','param([string]$Command,[switch]$Json)').replace('switch ($Command) {',()=>structured),'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};
 }
 
@@ -76,18 +81,15 @@ winTest('bare remote reuses a fully verified ONLINE runtime without invoking blo
   try{
     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,9),[
-      'status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
-    ]);
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=3,{timeoutMs:8000});
+    assert.deepEqual(ready.slice(0,6),['status','status','armprocess','armcoding','armautonomous','status'],output.stderr);
     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 \| desktop, host DISARMED/.test(output.stdout)) await sleep(50);
+    while(Date.now()<authDeadline&&!/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| 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 \| desktop, host DISARMED/);
+    assert.match(output.stdout,/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/);
     child.kill('SIGINT');
     await output.closed;
   }finally{
@@ -96,6 +98,141 @@ winTest('bare remote reuses a fully verified ONLINE runtime without invoking blo
   }
 });
 
+winTest('bounded remote disarms a stale standing Host grant before READY',async()=>{
+  const fx=await fixture({statusOnline:true});
+  fx.env.DEADBYTE_REMOTE_TEST_HOST_ARMED='1';
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const commands=await waitFor(fx.trace,items=>items.filter(x=>x==='status').length>=3,{timeoutMs:8000});
+    assert.ok(commands.indexOf('disarmhost')>commands.indexOf('status'));
+    const deadline=Date.now()+3000;
+    while(Date.now()<deadline&&!/\[READY\]/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/\[READY\]/,output.stderr);
+    child.stdin.end();
+    assert.equal((await output.closed).code,0,output.stderr);
+  }finally{
+    if(child&&child.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('remote --full verifies all five planes before READY and revokes them on disconnect',async()=>{
+  const fx=await fixture({statusOnline:true});
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote','--full'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const deadline=Date.now()+8000;
+    while(Date.now()<deadline&&!/\[READY\]/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop ARMED \| host ARMED/,output.stderr);
+    assert.match(output.stdout,/\[READY\]/);
+    const before=await traceCommands(fx.trace);
+    assert.ok(before.includes('armdesktop')&&before.includes('armhost'));
+    child.stdin.end();
+    assert.equal((await output.closed).code,0,output.stderr);
+    const after=await traceCommands(fx.trace);
+    assert.deepEqual(after.slice(-8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
+  }finally{
+    if(child?.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+for(const [flag,armedPlane,disarmedPlane] of [['--desktop','desktop','host'],['--host','host','desktop']]){
+  winTest(`remote ${flag} arms only the requested extra plane`,async()=>{
+    const fx=await fixture({statusOnline:true});
+    let child=null;
+    try{
+      child=spawn(process.execPath,[cliPath,'remote',flag],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+      const output=await collect(child);
+      const deadline=Date.now()+8000;
+      while(Date.now()<deadline&&!new RegExp(`${armedPlane} ARMED`).test(output.stdout)) await sleep(50);
+      assert.match(output.stdout,/\[READY\]/,output.stderr);
+      assert.match(output.stdout,new RegExp(`${armedPlane} ARMED`));
+      assert.match(output.stdout,new RegExp(`${disarmedPlane} DISARMED`));
+      const commands=await traceCommands(fx.trace);
+      assert.ok(commands.includes(`arm${armedPlane}`));
+      assert.ok(!commands.includes(`arm${disarmedPlane}`));
+      child.stdin.end();
+      assert.equal((await output.closed).code,0,output.stderr);
+    }finally{
+      if(child?.exitCode===null) child.kill('SIGKILL');
+      await rm(fx.dir,{recursive:true,force:true});
+    }
+  });
+}
+
+winTest('conflicting remote authority modes fail before controller mutation',async()=>{
+  const fx=await fixture({statusOnline:true});
+  try{
+    const child=spawn(process.execPath,[cliPath,'remote','--host','--desktop'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    assert.notEqual((await output.closed).code,0);
+    assert.match(output.stderr,/mutually exclusive/);
+    assert.deepEqual(await traceCommands(fx.trace),[]);
+  }finally{await rm(fx.dir,{recursive:true,force:true});}
+});
+
+winTest('remote refuses READY when public signed MCP execution probe fails',async()=>{
+  const fx=await fixture({statusOnline:true,failCommand:'machinetest'});
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const ended=await Promise.race([output.closed,sleep(6500).then(()=>({timeout:true}))]);
+    assert.equal(ended.timeout,undefined,'remote did not fail closed after execution probe failure');
+    assert.notEqual(ended.code,0);
+    assert.doesNotMatch(output.stdout,/\[READY\]|\[OK\] ONLINE/);
+    assert.match(output.stderr,/machinetest|execution probe/i);
+  }finally{
+    if(child?.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('remote refuses READY when controller snapshot lies about Host enforcement',async()=>{
+  const fx=await fixture({statusOnline:true});
+  fx.env.DEADBYTE_REMOTE_TEST_HOST_ARMED='1';
+  fx.env.DEADBYTE_REMOTE_TEST_JSON_HOST_LIE_ALWAYS='1';
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const ended=await Promise.race([output.closed,sleep(6500).then(()=>({timeout:true}))]);
+    assert.equal(ended.timeout,undefined,'remote did not reject split authority truth');
+    assert.notEqual(ended.code,0);
+    assert.doesNotMatch(output.stdout,/\[READY\]|\[OK\] ONLINE/);
+    assert.match(output.stderr,/machinetest|enforcement/i);
+  }finally{
+    if(child?.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('foreground cleanup retains ownership when status lies about a no-op Host revoke',async()=>{
+  const fx=await fixture({statusOnline:true});
+  fx.env.DEADBYTE_REMOTE_TEST_DISARM_NOOP='host';
+  fx.env.DEADBYTE_REMOTE_TEST_JSON_HOST_LIE='1';
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote','--full'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const deadline=Date.now()+8000;
+    while(Date.now()<deadline&&!/\[READY\]/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/\[READY\]/,output.stderr);
+    child.stdin.end();
+    assert.notEqual((await output.closed).code,0,'cleanup must fail closed');
+    assert.match(output.stderr,/cleanup.*verification|enforcement/i);
+    assert.equal(JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8')).schema,'deadbyte.remote-session.v2');
+    assert.ok(!(await traceCommands(fx.trace)).includes('park'));
+  }finally{
+    if(child?.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
 winTest('bare remote PARKED startup does not wait for a long-lived child holding inherited pipe handles',async()=>{
   const fx=await fixture();
   fx.env.DEADBYTE_REMOTE_TEST_SPAWN_CHILD='1';
@@ -104,15 +241,14 @@ winTest('bare remote PARKED startup does not wait for a long-lived child holding
     const startedAt=Date.now();
     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});
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4,{timeoutMs:8000});
     const elapsed=Date.now()-startedAt;
-    assert.deepEqual(ready.slice(0,11),[
-      'status','start','status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
-    ]);
+    assert.deepEqual(ready.slice(0,8),['status','start','status','status','armprocess','armcoding','armautonomous','status']);
     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');
     assert.match(output.stdout,/\[BOOT\] Starting bridge\/runtime\.\.\./);
+    const readyDeadline=Date.now()+3000;
+    while(Date.now()<readyDeadline&&!/\[OK\] ONLINE/.test(output.stdout)) await sleep(50);
     assert.match(output.stdout,/\[OK\] ONLINE/);
     child.stdin.end();
     const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
@@ -132,14 +268,11 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
   try{
     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,11),[
-      'status','start','status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
-    ]);
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4);
+    assert.deepEqual(ready.slice(0,8),['status','start','status','status','armprocess','armcoding','armautonomous','status']);
     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 \| desktop, host DISARMED/.test(output.stdout)) await sleep(50);
+    while(Date.now()<tailDeadline&&!/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| 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 +281,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 \| desktop, host DISARMED/);
+    assert.match(output.stdout,/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| 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*:/);
@@ -194,7 +327,7 @@ 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(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
+    assert.deepEqual(commands.slice(-8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
     assert.match(output.stdout,/^DEADBYTE MCP$/m);
     assert.match(output.stdout,/Human live timeline/i);
     assert.match(output.stdout,/\[AUTH\] Revoking session authority/);
@@ -212,7 +345,7 @@ winTest('remote --resume replays sanitized tool-call and terminal result events
   try{
     first=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const firstOutput=await collect(first);
-    await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
+    await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4);
     const liveDeadline=Date.now()+3000;
     while(Date.now()<liveDeadline&&!/\[LOG\] Human live timeline/.test(firstOutput.stdout)) await sleep(50);
     const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
@@ -275,7 +408,7 @@ winTest('remote --verbose enables sanitized request detail while preserving fore
   try{
     child=spawn(process.execPath,[cliPath,'remote','--verbose'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
+    await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4);
     assert.equal(child.exitCode,null,'verbose remote remains a foreground session');
     assert.match(output.stdout,/\[LOG\] Verbose live timeline\. Full sanitized request detail enabled/);
     const auditDir=path.join(fx.state,'audit');await mkdir(auditDir,{recursive:true});
@@ -293,7 +426,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(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
+    assert.deepEqual(commands.slice(-8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
     await rm(fx.dir,{recursive:true,force:true});
@@ -306,11 +439,8 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
   try{
     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,11),[
-      'status','start','status','armprocess','armcoding','armautonomous',
-      'processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus'
-    ]);
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4);
+    assert.deepEqual(ready.slice(0,8),['status','start','status','status','armprocess','armcoding','armautonomous','status']);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
     const markerDeadline=Date.now()+3000;
     let marker=null;
@@ -327,8 +457,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(-6).join(',')==='disarmautonomous,disarmcoding,disarmprocess,disarmhost,park',{timeoutMs:10000});
-    assert.deepEqual(cleaned.slice(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
+    const cleaned=await waitFor(fx.trace,commands=>commands.slice(-8).join(',')==='disarmautonomous,disarmcoding,disarmprocess,disarmdesktop,disarmhost,status,machinetest,park',{timeoutMs:10000});
+    assert.deepEqual(cleaned.slice(-8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
     const markerGoneDeadline=Date.now()+3000;
     let markerGone=false;
     while(Date.now()<markerGoneDeadline){
@@ -342,6 +472,30 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
   }
 });
 
+winTest('guardian retains ownership marker when disarm exits zero but Host remains armed',async()=>{
+  const fx=await fixture({statusOnline:true});
+  fx.env.DEADBYTE_REMOTE_TEST_DISARM_NOOP='host';
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote','--full'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const deadline=Date.now()+8000;
+    while(Date.now()<deadline&&!/\[READY\]/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/\[READY\]/,output.stderr);
+    child.kill('SIGKILL');
+    await output.closed;
+    await waitFor(fx.trace,commands=>commands.includes('disarmhost'),{timeoutMs:8000});
+    await sleep(750);
+    const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
+    assert.equal(marker.schema,'deadbyte.remote-session.v2');
+    const commands=await traceCommands(fx.trace);
+    assert.ok(!commands.includes('park'),'guardian must not park after unverified revocation');
+  }finally{
+    if(child?.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
 winTest('bare remote rolls back authority and parks if one plane fails to arm',async()=>{
   const fx=await fixture({failCommand:'armcoding'});
   try{
@@ -351,8 +505,8 @@ winTest('bare remote rolls back authority and parks if one plane fails to arm',a
     assert.equal(ended.timeout,undefined,'failed startup did not terminate');
     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(-6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
+    assert.deepEqual(commands.slice(0,6),['status','start','status','status','armprocess','armcoding']);
+    assert.deepEqual(commands.slice(-8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
     assert.doesNotMatch(output.stdout,/Live logs/i);
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });
@@ -366,10 +520,10 @@ winTest('bare remote recovers a stale crashed session before arming a new one',a
     await writeFile(path.join(runtime,'remote-session.json'),JSON.stringify({schema:'deadbyte.remote-session.v1',pid:2147483000,started_at_utc:'2026-01-01T00:00:00.000Z'}),'utf8');
     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,6),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park']);
-    assert.equal(ready[6],'status');
-    assert.equal(ready[7],'start');
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=5);
+    assert.deepEqual(ready.slice(0,8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
+    assert.equal(ready[8],'status');
+    assert.equal(ready[9],'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}))]);
@@ -387,7 +541,7 @@ winTest('remote warning lines use deterministic ASCII fallback on piped Windows
   try{
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
+    await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
     await writeFile(markerPath,'{invalid-json\n','utf8');
     child.stdin.end();
@@ -408,8 +562,8 @@ winTest('R58 concurrent cold remote claims have one winner and no loser cleanup'
       const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
       children.push(child);outputs.push(await collect(child));
     }
-    const commands=await waitFor(fx.trace,items=>items.includes('hoststatus'));
-    assert.ok(commands.includes('hoststatus'),outputs.map(o=>o.stderr).join('\n'));
+    const commands=await waitFor(fx.trace,items=>items.filter(x=>x==='status').length>=3);
+    assert.ok(commands.filter(x=>x==='status').length>=3,outputs.map(o=>o.stderr).join('\n'));
     const deadline=Date.now()+5000;
     while(Date.now()<deadline&&children.filter(c=>c.exitCode===null).length>1)await sleep(50);
     const live=children.filter(c=>c.exitCode===null);
@@ -432,8 +586,11 @@ winTest('R58 duplicate remote verifies the real live owner and leaves its author
   try{
     first=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const firstOutput=await collect(first);
-    const commands=await waitFor(fx.trace,items=>items.includes('hoststatus'));
-    assert.ok(commands.includes('hoststatus'),firstOutput.stderr);
+    const commands=await waitFor(fx.trace,items=>items.filter(x=>x==='status').length>=3);
+    assert.ok(commands.filter(x=>x==='status').length>=3,firstOutput.stderr);
+    const ownerReadyDeadline=Date.now()+3000;
+    while(Date.now()<ownerReadyDeadline&&!/\[READY\]/.test(firstOutput.stdout)) await sleep(50);
+    assert.match(firstOutput.stdout,/\[READY\]/,firstOutput.stderr);
     const before=await traceCommands(fx.trace);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
     const marker=JSON.parse(await readFile(markerPath,'utf8'));
@@ -529,7 +686,7 @@ winTest('remote --trace --filter selects presentation without dropping journaled
       env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true
     });
     const output=await collect(child);
-    await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
+    await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4);
     const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
     const auditDir=path.join(fx.state,'audit');await mkdir(auditDir,{recursive:true});
     const audit=[