deadbyte-mcp 0.15.68 → 0.15.70

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

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { DEADBYTE_VERSION } from '../src/version.mjs';
+import {installExactActivePointer} from './helpers/r175-active-pointer.mjs';
 
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const cliPath=path.join(root,'src','deadbyte-cli.mjs');
@@ -35,12 +36,13 @@ async function fixture({failCommand='',statusOnline=false}={}){
   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 -in ($env:DEADBYTE_REMOTE_TEST_FAIL -split ',')) { $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`;
   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 'status' -and $Json) { $names=@('process','coding','autonomous','desktop','host'); $authority=@{}; foreach($name in $names){ $initial=(($name -eq 'process') -and ($env:DEADBYTE_REMOTE_TEST_PROCESS_ARMED -eq '1')) -or (($name -eq 'coding') -and ($env:DEADBYTE_REMOTE_TEST_CODING_ARMED -eq '1')) -or (($name -eq 'autonomous') -and ($env:DEADBYTE_REMOTE_TEST_AUTONOMOUS_ARMED -eq '1')) -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=$env:DEADBYTE_REMOTE_TEST_CORE_ROOT;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};
+  await installExactActivePointer({stateRoot:state,packageRoot:root,launcherPath:launcher});
+  return {dir,state,trace,env:{...process.env,DEADBYTE_STATE_ROOT:state,DEADBYTE_REMOTE_TEST_CORE_ROOT:root,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};
 }
 
 async function traceCommands(file,{read=readFile,retryDelayMs=10,maxAttempts=20}={}){
@@ -98,21 +100,23 @@ const winTest=isWindows?test:test.skip;
 
 winTest('bare remote reuses a fully verified ONLINE runtime without invoking blocking start',async()=>{
   const fx=await fixture({failCommand:'start',statusOnline:true});
+  fx.env.DEADBYTE_REMOTE_TEST_PROCESS_ARMED='1';
+  fx.env.DEADBYTE_REMOTE_TEST_CODING_ARMED='1';
+  fx.env.DEADBYTE_REMOTE_TEST_AUTONOMOUS_ARMED='1';
   let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    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.filter(x=>x==='status').length>=3,{timeoutMs:fixtureTimeoutMs});
-    assert.deepEqual(ready.slice(0,6),['status','status','armprocess','armcoding','armautonomous','status'],output.stderr);
-    assert.doesNotMatch(ready.join(','),/(^|,)start(,|$)/);
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=2,{timeoutMs:fixtureTimeoutMs});
+    assert.equal(ready.filter(x=>/^(?:arm|disarm|start|park)/.test(x)).length,0,output.stderr);
     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()+fixtureTimeoutMs;
     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\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/);
-    child.kill('SIGINT');
-    await output.closed;
+    child.stdin.end();
+    assert.equal((await output.closed).code,0,output.stderr);
   }finally{
     if(child&&child.exitCode===null) child.kill('SIGKILL');
     await safeRm(fx.dir);
@@ -130,28 +134,28 @@ winTest('R72 bare remote reaches READY with every authority disarmed and never a
     assert.match(output.stdout,/\[READY\]/,output.stderr);
     assert.match(output.stdout,/\[AUTH\] process DISARMED \| coding DISARMED \| autonomous DISARMED \| desktop DISARMED \| host DISARMED/);
     const before=await traceCommands(fx.trace);
-    assert.deepEqual(before.slice(0,6),['status','status','disarmautonomous','disarmcoding','disarmprocess','status']);
-    assert.equal(before.filter(x=>/^arm(?:process|coding|autonomous|host|desktop)$/.test(x)).length,0,'bare remote must issue zero ARM commands');
+    assert.deepEqual(before.slice(0,3),['status','status','machinetest']);
+    assert.equal(before.filter(x=>/^(?:arm|disarm)(?:process|coding|autonomous|host|desktop)$/.test(x)).length,0,'bare remote must issue zero authority commands');
     child.stdin.end();
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined,'bare remote did not stop');
     assert.equal(ended.code,0,output.stderr);
-    assert.equal((await traceCommands(fx.trace)).at(-1),'park');
+    assert.equal((await traceCommands(fx.trace)).includes('park'),false);
   }finally{
     if(child?.exitCode===null)child.kill('SIGKILL');
     await safeRm(fx.dir);
   }
 });
 
-winTest('bounded remote disarms a stale standing Host grant before READY',async()=>{
+winTest('observation-only remote preserves a stale standing Host grant without mutation',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:fixtureTimeoutMs});
-    assert.ok(commands.indexOf('disarmhost')>commands.indexOf('status'));
+    const commands=await waitFor(fx.trace,items=>items.filter(x=>x==='status').length>=2,{timeoutMs:fixtureTimeoutMs});
+    assert.equal(commands.some(x=>x==='disarmhost'||x==='armhost'||x==='machinetest'),false);
     const deadline=Date.now()+fixtureTimeoutMs;
     while(Date.now()<deadline&&!/\[READY\]/.test(output.stdout)) await sleep(50);
     assert.match(output.stdout,/\[READY\]/,output.stderr);
@@ -163,45 +167,31 @@ winTest('bounded remote disarms a stale standing Host grant before READY',async(
   }
 });
 
-winTest('remote --full verifies all five planes before READY and revokes them on disconnect',async()=>{
+winTest('remote --full refuses implicit authority before controller mutation',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()+fixtureTimeoutMs;
-    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']);
+    assert.notEqual((await output.closed).code,0);
+    assert.match(output.stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
+    assert.deepEqual(await traceCommands(fx.trace),[]);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
     await safeRm(fx.dir);
   }
 });
 
-for(const [flag,armedPlane,disarmedPlane] of [['--desktop','desktop','host'],['--host','host','desktop']]){
-  winTest(`remote ${flag} arms only the requested extra plane`,async()=>{
+for(const flag of ['--desktop','--host']){
+  winTest(`remote ${flag} refuses implicit authority before controller mutation`,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()+fixtureTimeoutMs;
-      while(Date.now()<deadline&&!/\[READY\]/.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);
+      assert.notEqual((await output.closed).code,0);
+      assert.match(output.stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
+      assert.deepEqual(await traceCommands(fx.trace),[]);
     }finally{
       if(child?.exitCode===null) child.kill('SIGKILL');
       await safeRm(fx.dir);
@@ -256,7 +246,7 @@ winTest('remote refuses READY when controller snapshot lies about Host enforceme
   }
 });
 
-winTest('foreground cleanup retains ownership when status lies about a no-op Host revoke',async()=>{
+winTest('foreground --full rejection cannot create cleanup ownership evidence',async()=>{
   const fx=await fixture({statusOnline:true});
   fx.env.DEADBYTE_REMOTE_TEST_DISARM_NOOP='host';
   fx.env.DEADBYTE_REMOTE_TEST_JSON_HOST_LIE='1';
@@ -264,43 +254,28 @@ winTest('foreground cleanup retains ownership when status lies about a no-op Hos
   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()+fixtureTimeoutMs;
-    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'));
+    assert.notEqual((await output.closed).code,0,'elevated foreground must fail closed');
+    assert.match(output.stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
+    await assert.rejects(()=>readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'),{code:'ENOENT'});
+    assert.deepEqual(await traceCommands(fx.trace),[]);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
     await safeRm(fx.dir);
   }
 });
 
-winTest('bare remote PARKED startup does not wait for a long-lived child holding inherited pipe handles',async()=>{
+winTest('observation-only remote never starts a PARKED runtime or inherited child',async()=>{
   const fx=await fixture();
   fx.env.DEADBYTE_REMOTE_TEST_SPAWN_CHILD='1';
   let child=null;
   try{
-    const startedAt=Date.now();
-    child=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const afterStart=await waitFor(fx.trace,commands=>commands.length>=3,{timeoutMs:15000});
-    const elapsed=Date.now()-startedAt;
-    assert.deepEqual(afterStart.slice(0,3),['status','start','status']);
-    assert.ok(elapsed<12000,`PARKED startup waited on inherited child pipe handles: ${elapsed}ms`);
-    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4,{timeoutMs:fixtureTimeoutMs});
-    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 PARKED startup');
-    assert.match(output.stdout,/\[BOOT\] Starting bridge\/runtime\.\.\./);
-    const readyDeadline=Date.now()+fixtureTimeoutMs;
-    while(Date.now()<readyDeadline&&!/\[OK\] ONLINE/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/\[OK\] ONLINE/);
-    child.stdin.end();
     const ended=await boundedCompletion(output.closed);
-    assert.equal(ended.timeout,undefined,'remote session did not exit after PARKED startup proof');
-    assert.equal(ended.code,0,output.stderr);
+    assert.equal(ended.timeout,undefined);
+    assert.notEqual(ended.code,0);
+    assert.match(output.stderr,/R175_FOREGROUND_RUNTIME_NOT_READY/);
+    assert.equal((await traceCommands(fx.trace)).includes('start'),false);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
     try{const pid=Number((await readFile(fx.spawnedPid,'utf8')).trim());if(Number.isInteger(pid)&&pid>0) process.kill(pid,'SIGKILL');}catch{}
@@ -309,17 +284,17 @@ winTest('bare remote PARKED startup does not wait for a long-lived child holding
   }
 });
 
-winTest('bare remote uses one unified live timeline, keeps authority semantics, then disarms and parks when the foreground session ends',async()=>{
-  const fx=await fixture();
+winTest('bare remote uses one live timeline and preserves authority on disconnect',async()=>{
+  const fx=await fixture({statusOnline:true});
   let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    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.filter(x=>x==='status').length>=4);
-    assert.deepEqual(ready.slice(0,8),['status','start','status','status','armprocess','armcoding','armautonomous','status']);
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=2);
+    assert.deepEqual(ready.slice(0,2),['status','status']);
     assert.equal(child.exitCode,null,'remote session must remain foreground after becoming ready');
     const tailDeadline=Date.now()+fixtureTimeoutMs;
-    while(Date.now()<tailDeadline&&(!/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/.test(output.stdout)||
+    while(Date.now()<tailDeadline&&(!/\[AUTH\] process DISARMED \| coding DISARMED \| autonomous DISARMED \| desktop DISARMED \| host DISARMED/.test(output.stdout)||
       !/\[READY\] DEADBYTE MCP online/.test(output.stdout))) await sleep(50);
     assert.match(output.stdout,/\[DISPLAY\] ASCII fallback: stdout_not_tty/);
     assert.match(output.stdout,/\[DEVICE\] Starting DEADBYTE MCP/);
@@ -329,7 +304,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\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/);
+    assert.match(output.stdout,/\[AUTH\] process DISARMED \| coding DISARMED \| autonomous DISARMED \| desktop DISARMED \| host DISARMED/);
     assert.match(output.stdout,/\[LOG\] Live tool calls with individual START\/DONE, sanitized arguments and results\. Transport hidden; signed audit remains on disk\./);
     assert.doesNotMatch(output.stdout,/Process plane\s*:/);
     assert.doesNotMatch(output.stdout,/Coding plane\s*:/);
@@ -354,10 +329,9 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     ].join('\n')+'\n','utf8');
     const logDeadline=Date.now()+fixtureTimeoutMs;
     while(Date.now()<logDeadline&&!/^\[.*\] \[FAIL\] Tool call coding_file_read failed \[fedcba98\] 1\.73s$/m.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/\[CALL\] Received tool call \[abcdef12\] coding_tree Arguments:/,'default human view must show bounded sanitized arguments');
-    assert.match(output.stdout,/^\[.*\] \[DONE\] Tool call coding_tree completed \[abcdef12\] 42ms$/m);
-    assert.match(output.stdout,/^\[.*\] \[FAIL\] Tool call coding_file_read failed \[fedcba98\] 1\.73s$/m);
-    assert.equal((output.stdout.match(/\[DONE\] Tool call coding_tree completed \[abcdef12\] 42ms/g)||[]).length,1,'duplicate terminal result must print once');
+    assert.match(output.stdout,/\+ PASS\s+coding_tree\s+\| \[abcdef12\]\s+42ms \| projects:src/,'default human view must show bounded path context');
+    assert.match(output.stdout,/X FAIL\s+coding_file_read\s+\| \[fedcba98\]\s+1\.73s \| projects:src\/deadbyte-cli\.mjs/);
+    assert.equal((output.stdout.match(/\+ PASS\s+coding_tree\s+\| \[abcdef12\]\s+42ms/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'));
     assert.deepEqual(resultJournal.events.map(event=>event.seq),[1,2,3,4]);
@@ -375,10 +349,10 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined,'remote session did not exit after foreground input closed');
     const commands=await traceCommands(fx.trace);
-    assert.deepEqual(commands.slice(-8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
+    assert.equal(commands.some(command=>/^(?:arm|disarm|park)/.test(command)),false);
     assert.match(output.stdout,/^DEADBYTE MCP$/m);
     assert.match(output.stdout,/Live tool calls with individual START\/DONE/i);
-    assert.match(output.stdout,/\[AUTH\] Revoking session authority/);
+    assert.match(output.stdout,/preserving owner standing grants/i);
     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{
@@ -388,12 +362,12 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
 });
 
 winTest('remote --resume replays sanitized tool-call and terminal result events after the cursor without duplicates or loss',async()=>{
-  const fx=await fixture();
+  const fx=await fixture({statusOnline:true});
   let first=null,second=null;
   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.filter(x=>x==='status').length>=4);
+    await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=2);
     const liveDeadline=Date.now()+3000;
     while(Date.now()<liveDeadline&&!/\[LOG\] Live tool calls/.test(firstOutput.stdout)) await sleep(50);
     const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
@@ -451,7 +425,7 @@ winTest('remote --resume replays sanitized tool-call and terminal result events
 });
 
 winTest('remote --verbose enables sanitized request detail while preserving foreground authority cleanup',async()=>{
-  const fx=await fixture();
+  const fx=await fixture({statusOnline:true});
   let child=null;
   try{
     child=spawn(process.execPath,[cliPath,'remote','--verbose'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
@@ -474,21 +448,21 @@ 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(-8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
+    assert.equal(commands.some(command=>/^(?:arm|disarm|park)/.test(command)),false);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
     await safeRm(fx.dir);
   }
 });
 
-winTest('detached guardian revokes authority, parks, and removes the session marker after the owner is hard-killed',async()=>{
-  const fx=await fixture();
+winTest('detached observation guardian removes its marker without touching authority after owner death',async()=>{
+  const fx=await fixture({statusOnline:true});
   let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    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.filter(x=>x==='status').length>=4);
-    assert.deepEqual(ready.slice(0,8),['status','start','status','status','armprocess','armcoding','armautonomous','status']);
+    const ready=await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=2);
+    assert.deepEqual(ready.slice(0,2),['status','status']);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
     const markerDeadline=Date.now()+3000;
     let marker=null;
@@ -505,8 +479,9 @@ 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(-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']);
+    await sleep(750);
+    const cleaned=await traceCommands(fx.trace);
+    assert.equal(cleaned.some(command=>/^(?:arm|disarm|park)/.test(command)),false);
     const markerGoneDeadline=Date.now()+3000;
     let markerGone=false;
     while(Date.now()<markerGoneDeadline){
@@ -520,31 +495,24 @@ 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()=>{
+winTest('remote --full cannot create a guardian or mutate Host authority',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()+fixtureTimeoutMs;
-    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:fixtureTimeoutMs});
-    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');
+    assert.notEqual((await output.closed).code,0);
+    assert.match(output.stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
+    assert.deepEqual(await traceCommands(fx.trace),[]);
+    await assert.rejects(()=>readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'),{code:'ENOENT'});
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
     await safeRm(fx.dir);
   }
 });
 
-winTest('bare remote rolls back authority and parks if one plane fails to arm',async()=>{
+winTest('remote --operator cannot reach authority arming or rollback',async()=>{
   const fx=await fixture({failCommand:'armcoding'});
   try{
     const child=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
@@ -553,8 +521,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; stdout=${output.stdout.slice(-1200)} stderr=${output.stderr.slice(-1200)} trace=${(await traceCommands(fx.trace)).join(',')}`);
     assert.notEqual(ended.code,0);
     const commands=await traceCommands(fx.trace);
-    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.deepEqual(commands,[]);
+    assert.match(output.stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
     assert.doesNotMatch(output.stdout,/Live logs/i);
   }finally{await safeRm(fx.dir);}
 });
@@ -571,7 +539,7 @@ winTest('bare remote retains an owner-unverified stale marker without starting o
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined);
     assert.notEqual(ended.code,0);
-    assert.match(output.stderr,/ownership(?: identity)? unverified.*marker retained/i);
+    assert.match(output.stderr,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND/i);
     assert.deepEqual(await traceCommands(fx.trace),[]);
     assert.equal(JSON.parse(await readFile(path.join(runtime,'remote-session.json'),'utf8')).pid,2147483000);
   }finally{
@@ -595,14 +563,14 @@ winTest('PID reuse cannot authorize removal of a marker with a different process
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined);
     assert.notEqual(ended.code,0);
-    assert.match(output.stderr,/owner identity.*marker retained/i);
+  assert.match(output.stderr,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND/i);
     assert.deepEqual(await traceCommands(fx.trace),[]);
     assert.equal(JSON.parse(await readFile(path.join(runtime,'remote-session.json'),'utf8')).session_nonce,marker.session_nonce);
   }finally{await safeRm(fx.dir);}
 });
 
 winTest('remote warning lines use deterministic ASCII fallback on piped Windows output',async()=>{
-  const fx=await fixture();
+  const fx=await fixture({statusOnline:true});
   let child=null;
   try{
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
@@ -625,7 +593,7 @@ winTest('remote warning lines use deterministic ASCII fallback on piped Windows
 });
 
 winTest('remote cleanup never removes a marker with changed ownership identity',async()=>{
-  const fx=await fixture();
+  const fx=await fixture({statusOnline:true});
   let child=null;
   try{
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
@@ -651,18 +619,17 @@ winTest('R58 concurrent cold remote claims have one winner and no loser cleanup'
   const fx=await fixture({statusOnline:true});const children=[],outputs=[];
   try{
     for(let i=0;i<3;i++){
-      const child=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+      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.filter(x=>x==='status').length>=3);
-    assert.ok(commands.filter(x=>x==='status').length>=3,outputs.map(o=>o.stderr).join('\n'));
+    const commands=await waitFor(fx.trace,items=>items.filter(x=>x==='status').length>=2);
+    assert.ok(commands.filter(x=>x==='status').length>=2,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);
     assert.equal(live.length,1,'exactly one verified foreground may survive');
     const trace=await traceCommands(fx.trace);
-    for(const arm of ['armprocess','armcoding','armautonomous'])assert.equal(trace.filter(x=>x===arm).length,1);
-    assert.ok(!trace.some(x=>x.startsWith('disarm')||x==='park'),'losers must not revoke winner authority');
+    assert.ok(!trace.some(x=>x.startsWith('arm')||x.startsWith('disarm')||x==='park'),'observers must not mutate authority');
     for(let i=0;i<children.length;i++)if(children[i]!==live[0])assert.match(outputs[i].stderr,/remote session already (claimed|active)/,'concurrent rejection must have deterministic ownership vocabulary');
     const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
     assert.equal(marker.owner_pid,live[0].pid);
@@ -676,10 +643,10 @@ winTest('R58 concurrent cold remote claims have one winner and no loser cleanup'
 winTest('R58 duplicate remote verifies the real live owner and leaves its authority untouched',async()=>{
   const fx=await fixture({statusOnline:true});let first=null,second=null;
   try{
-    first=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    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.filter(x=>x==='status').length>=3);
-    assert.ok(commands.filter(x=>x==='status').length>=3,firstOutput.stderr);
+    const commands=await waitFor(fx.trace,items=>items.filter(x=>x==='status').length>=2);
+    assert.ok(commands.filter(x=>x==='status').length>=2,firstOutput.stderr);
     const ownerReadyDeadline=Date.now()+fixtureTimeoutMs;
     while(Date.now()<ownerReadyDeadline&&!/\[READY\]/.test(firstOutput.stdout)) await sleep(50);
     assert.match(firstOutput.stdout,/\[READY\]/,firstOutput.stderr);
@@ -688,7 +655,7 @@ winTest('R58 duplicate remote verifies the real live owner and leaves its author
     const marker=JSON.parse(await readFile(markerPath,'utf8'));
     assert.equal(marker.owner_identity.pid,first.pid);
     assert.equal(marker.guardian_identity.parent_pid,first.pid);
-    second=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    second=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const secondOutput=await collect(second);
     const stopped=await secondOutput.closed;
     assert.notEqual(stopped.code,0);
@@ -718,7 +685,7 @@ winTest('bare remote refuses unverified legacy ownership without touching author
     assert.equal(ended.timeout,undefined);
     assert.notEqual(ended.code,0);
     assert.deepEqual(await traceCommands(fx.trace),[]);
-    assert.match(output.stderr,/remote session ownership unverified/i);
+    assert.match(output.stderr,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND/i);
   }finally{
     if(child?.exitCode===null) child.kill();
     await safeRm(fx.dir);
@@ -757,7 +724,7 @@ winTest('explicit remote status keeps the coherent runtime one-shot and silent',
   }finally{await safeRm(fx.dir);}
 });
 
-winTest('bare remote surfaces bounded controller-start-failure evidence instead of only exit code',async()=>{
+winTest('bare remote reports runtime-not-ready without invoking start',async()=>{
   const fx=await fixture({failCommand:'start'});
   try{
     const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
@@ -765,12 +732,12 @@ winTest('bare remote surfaces bounded controller-start-failure evidence instead
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined,'failed start did not terminate');
     assert.notEqual(ended.code,0);
-    assert.match(output.stderr,/fixture controller evidence detail/);
-    assert.match(output.stderr,/controller-start-failure/i);
+    assert.match(output.stderr,/R175_FOREGROUND_RUNTIME_NOT_READY/);
+    assert.equal((await traceCommands(fx.trace)).includes('start'),false);
   }finally{await safeRm(fx.dir);}
 });
 
-winTest('failed startup retains primary and cleanup failure plus ownership marker',async()=>{
+winTest('runtime-not-ready observation does not enter cleanup authority paths',async()=>{
   const fx=await fixture({failCommand:'start,disarmautonomous'});
   try{
     const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
@@ -778,17 +745,16 @@ winTest('failed startup retains primary and cleanup failure plus ownership marke
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined,'failed startup did not terminate');
     assert.notEqual(ended.code,0);
-    assert.match(output.stderr,/remote activation failed/i);
-    assert.match(output.stderr,/controller-start-failure/i);
-    assert.match(output.stderr,/cleanup failed.*disarmautonomous/i);
+    assert.match(output.stderr,/R175_FOREGROUND_RUNTIME_NOT_READY/);
+    assert.equal((await traceCommands(fx.trace)).some(command=>/^(?:arm|disarm|start|park)/.test(command)),false);
     const retained=await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8').then(()=>true,()=>false);
-    assert.equal(retained,true);
+    assert.equal(retained,false);
   }finally{await safeRm(fx.dir);}
 });
 
 
 winTest('remote --trace --filter selects presentation without dropping journaled events',async()=>{
-  const fx=await fixture();
+  const fx=await fixture({statusOnline:true});
   let child=null;
   try{
     child=spawn(process.execPath,[cliPath,'remote','--trace','--filter','category=write,status=error,trace=goal-1234'],{
@@ -811,7 +777,7 @@ winTest('remote --trace --filter selects presentation without dropping journaled
     await writeFile(path.join(auditDir,'segment-00000001.jsonl'),audit.map(JSON.stringify).join('\n')+'\n','utf8');
     const deadline=Date.now()+4000;
     while(Date.now()<deadline&&!/machine_fs\.write.*trace=goal-1234/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/Tool call machine_fs\.write failed \[filter-w\].*trace=goal-123\.\.\. span=filter-w\.\.\..*10ms.*denied/i);
+    assert.match(output.stdout,/machine_fs\.write.*\[filter-w\].*10ms.*trace=goal-123\.\.\. span=filter-w\.\.\..*denied/i);
     assert.doesNotMatch(output.stdout,/coding_file_read.*missing/);
     assert.doesNotMatch(output.stdout,/SECRET/);
     const journal=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-results',marker.result_session_id+'.json'),'utf8'));