deadbyte-mcp 0.15.44 → 0.15.46

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

@@ -12,6 +12,15 @@ const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const cliPath=path.join(root,'src','deadbyte-cli.mjs');
 const isWindows=process.platform==='win32';
 const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+const fixtureTimeoutMs=30000;
+async function boundedCompletion(promise,timeoutMs=fixtureTimeoutMs){
+  let timer;
+  try{return await Promise.race([promise,new Promise(resolve=>{
+    timer=setTimeout(()=>resolve({timeout:true}),timeoutMs);
+    timer.unref?.();
+  })]);}
+  finally{clearTimeout(timer);}
+}
 
 async function fixture({failCommand='',statusOnline=false}={}){
   const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-remote-session-'));
@@ -45,7 +54,7 @@ async function traceCommands(file,{read=readFile,retryDelayMs=10,maxAttempts=20}
   }
   return [];
 }
-async function waitFor(file,predicate,{timeoutMs=12000}={}){
+async function waitFor(file,predicate,{timeoutMs=fixtureTimeoutMs}={}){
   const deadline=Date.now()+timeoutMs;
   while(Date.now()<deadline){
     const commands=await traceCommands(file);
@@ -73,6 +82,17 @@ async function collect(child){
   const closed=new Promise(resolve=>child.once('close',(code,signal)=>resolve({code,signal})));
   return {closed,get stdout(){return stdout;},get stderr(){return stderr;}};
 }
+// Windows: SIGKILL leaves PowerShell child holding a handle on the .ps1 fixture
+// for a short window; retry rm() until it succeeds or gives up.
+async function safeRm(dir,{maxAttempts=10,retryDelayMs=200}={}){
+  for(let i=0;i<maxAttempts;i++){
+    try{await rm(dir,{recursive:true,force:true});return;}
+    catch(err){
+      if(err?.code==='EBUSY'&&i<maxAttempts-1){await sleep(retryDelayMs);continue;}
+      throw err;
+    }
+  }
+}
 
 const winTest=isWindows?test:test.skip;
 
@@ -80,14 +100,14 @@ winTest('bare remote reuses a fully verified ONLINE runtime without invoking blo
   const fx=await fixture({failCommand:'start',statusOnline:true});
   let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    child=spawn(process.execPath,[cliPath,'remote','--operator'],{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:8000});
+    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(,|$)/);
     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;
+    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/);
@@ -95,7 +115,31 @@ winTest('bare remote reuses a fully verified ONLINE runtime without invoking blo
     await output.closed;
   }finally{
     if(child&&child.exitCode===null) child.kill('SIGKILL');
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
+  }
+});
+
+winTest('R72 bare remote reaches READY with every authority disarmed and never arms a plane',async()=>{
+  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});
+    const output=await collect(child);
+    const deadline=Date.now()+fixtureTimeoutMs;
+    while(Date.now()<deadline&&!/\[READY\]/.test(output.stdout)&&child.exitCode===null)await sleep(50);
+    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');
+    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');
+  }finally{
+    if(child?.exitCode===null)child.kill('SIGKILL');
+    await safeRm(fx.dir);
   }
 });
 
@@ -106,16 +150,16 @@ winTest('bounded remote disarms a stale standing Host grant before READY',async(
   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});
+    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 deadline=Date.now()+3000;
+    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.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});
+    await safeRm(fx.dir);
   }
 });
 
@@ -125,7 +169,7 @@ winTest('remote --full verifies all five planes before READY and revokes them on
   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;
+    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\]/);
@@ -137,7 +181,7 @@ winTest('remote --full verifies all five planes before READY and revokes them on
     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});
+    await safeRm(fx.dir);
   }
 });
 
@@ -148,7 +192,7 @@ for(const [flag,armedPlane,disarmedPlane] of [['--desktop','desktop','host'],['-
     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;
+      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`));
@@ -160,7 +204,7 @@ for(const [flag,armedPlane,disarmedPlane] of [['--desktop','desktop','host'],['-
       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});
+      await safeRm(fx.dir);
     }
   });
 }
@@ -173,7 +217,7 @@ winTest('conflicting remote authority modes fail before controller mutation',asy
     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});}
+  }finally{await safeRm(fx.dir);}
 });
 
 winTest('remote refuses READY when public signed MCP execution probe fails',async()=>{
@@ -182,14 +226,14 @@ winTest('remote refuses READY when public signed MCP execution probe fails',asyn
   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(12000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     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});
+    await safeRm(fx.dir);
   }
 });
 
@@ -201,14 +245,14 @@ winTest('remote refuses READY when controller snapshot lies about Host enforceme
   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(12000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined,`remote did not reject split authority truth; stdout=${output.stdout.slice(-1200)} stderr=${output.stderr.slice(-1200)} trace=${(await traceCommands(fx.trace)).join(',')}`);
     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});
+    await safeRm(fx.dir);
   }
 });
 
@@ -220,7 +264,7 @@ 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()+8000;
+    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();
@@ -230,7 +274,7 @@ winTest('foreground cleanup retains ownership when status lies about a no-op Hos
     assert.ok(!(await traceCommands(fx.trace)).includes('park'));
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -240,26 +284,28 @@ winTest('bare remote PARKED startup does not wait for a long-lived child holding
   let child=null;
   try{
     const startedAt=Date.now();
-    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    child=spawn(process.execPath,[cliPath,'remote','--operator'],{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,{timeoutMs:8000});
+    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.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;
+    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 Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    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);
   }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{}
     await sleep(100);
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -267,13 +313,14 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
   const fx=await fixture();
   let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    child=spawn(process.execPath,[cliPath,'remote','--operator'],{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']);
     assert.equal(child.exitCode,null,'remote session must remain foreground after becoming ready');
-    const tailDeadline=Date.now()+3000;
-    while(Date.now()<tailDeadline&&!/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/.test(output.stdout)) await sleep(50);
+    const tailDeadline=Date.now()+fixtureTimeoutMs;
+    while(Date.now()<tailDeadline&&(!/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| 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/);
     assert.match(output.stdout,/\[BRIDGE\] Local bridge connected/);
@@ -305,7 +352,7 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
       '[TOOL OUT] 2026-09-16T00:00:00.001Z #000001 coding_tree {"is_error":false}',
       '[TOOL OUT] 2026-09-16T00:00:00.002Z #000002 coding_file_read {"is_error":true}'
     ].join('\n')+'\n','utf8');
-    const logDeadline=Date.now()+3000;
+    const logDeadline=Date.now()+fixtureTimeoutMs;
     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);
@@ -325,7 +372,7 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     assert.doesNotMatch(output.stdout,/\[TOOL IN \]|\[TOOL OUT\]/);
     assert.doesNotMatch(output.stdout,/payload bytes=/);
     child.stdin.end();
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    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']);
@@ -336,7 +383,7 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     assert.doesNotMatch(output.stdout,/\p{Extended_Pictographic}/u,'piped Windows fallback must remain ASCII-safe');
   }finally{
     if(child?.exitCode===null) child.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -373,7 +420,7 @@ winTest('remote --resume replays sanitized tool-call and terminal result events
     deadline=Date.now()+3000;
     while(Date.now()<deadline&&!/^R  .*#4  \[resume-r\]  coding_file_read  projects:src\/deadbyte-cli\.mjs.*OK$/m.test(firstOutput.stdout)) await sleep(50);
     first.stdin.end();
-    const firstEnded=await Promise.race([firstOutput.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const firstEnded=await boundedCompletion(firstOutput.closed);
     assert.equal(firstEnded.timeout,undefined);
 
     second=spawn(process.execPath,[cliPath,'remote','--resume',cursor1],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
@@ -394,12 +441,12 @@ winTest('remote --resume replays sanitized tool-call and terminal result events
     const liveIndex=secondOutput.stdout.indexOf('[LOG] Human live timeline');
     assert.ok(callReplayIndex>=0&&resultReplayIndex>callReplayIndex&&liveIndex>resultReplayIndex,'resume ordering must be call -> result -> live tail');
     second.stdin.end();
-    const secondEnded=await Promise.race([secondOutput.closed,sleep(12000).then(()=>({timeout:true}))]);
+    const secondEnded=await boundedCompletion(secondOutput.closed);
     assert.equal(secondEnded.timeout,undefined);
     assert.equal(secondEnded.code,0,secondOutput.stderr);
   }finally{
     if(first?.exitCode===null) first.kill();if(second?.exitCode===null) second.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -423,14 +470,14 @@ winTest('remote --verbose enables sanitized request detail while preserving fore
     assert.match(output.stdout,/coding_tree\s+\| Arguments: .*"path":"src".*"root_id":"projects"/);
     assert.doesNotMatch(output.stdout,/DO_NOT_PRINT_VERBOSE_SECRET/);
     child.stdin.end();
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     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']);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -438,7 +485,7 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
   const fx=await fixture();
   let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    child=spawn(process.execPath,[cliPath,'remote','--operator'],{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']);
@@ -469,7 +516,7 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
     assert.equal(markerGone,true,'guardian left stale remote-session marker after hard kill');
   }finally{
     if(child?.exitCode===null) child.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -480,12 +527,12 @@ winTest('guardian retains ownership marker when disarm exits zero but Host remai
   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;
+    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:8000});
+    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');
@@ -493,23 +540,23 @@ winTest('guardian retains ownership marker when disarm exits zero but Host remai
     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});
+    await safeRm(fx.dir);
   }
 });
 
 winTest('bare remote rolls back authority and parks if one plane fails to arm',async()=>{
   const fx=await fixture({failCommand:'armcoding'});
   try{
-    const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
+    const child=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ended=await Promise.race([output.closed,sleep(12000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     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.doesNotMatch(output.stdout,/Live logs/i);
-  }finally{await rm(fx.dir,{recursive:true,force:true});}
+  }finally{await safeRm(fx.dir);}
 });
 
 winTest('bare remote recovers a stale crashed session before arming a new one',async()=>{
@@ -521,18 +568,18 @@ 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.filter(x=>x==='status').length>=5);
+    const ready=await waitFor(fx.trace,commands=>commands.length>=10&&commands[9]==='start');
     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}))]);
+    const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined);
     assert.equal(ended.code,0,output.stderr);
   }finally{
     if(child?.exitCode===null) child.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -546,13 +593,13 @@ winTest('remote warning lines use deterministic ASCII fallback on piped Windows
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
     await writeFile(markerPath,'{invalid-json\n','utf8');
     child.stdin.end();
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined,'remote session did not exit after warning fixture');
     assert.match(output.stderr,/^\[WARN\] remote session marker cleanup:/m);
     assert.doesNotMatch(output.stderr,/\p{Extended_Pictographic}/u);
   }finally{
     if(child?.exitCode===null) child.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -560,7 +607,7 @@ 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'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+      const child=spawn(process.execPath,[cliPath,'remote','--operator'],{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);
@@ -578,18 +625,18 @@ winTest('R58 concurrent cold remote claims have one winner and no loser cleanup'
     live[0].stdin.end();assert.equal((await outputs[children.indexOf(live[0])].closed).code,0);
   }finally{
     for(const child of children)if(child.exitCode===null)child.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
 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'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    first=spawn(process.execPath,[cliPath,'remote','--operator'],{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 ownerReadyDeadline=Date.now()+3000;
+    const ownerReadyDeadline=Date.now()+fixtureTimeoutMs;
     while(Date.now()<ownerReadyDeadline&&!/\[READY\]/.test(firstOutput.stdout)) await sleep(50);
     assert.match(firstOutput.stdout,/\[READY\]/,firstOutput.stderr);
     const before=await traceCommands(fx.trace);
@@ -597,7 +644,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'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    second=spawn(process.execPath,[cliPath,'remote','--operator'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const secondOutput=await collect(second);
     const stopped=await secondOutput.closed;
     assert.notEqual(stopped.code,0);
@@ -608,7 +655,7 @@ winTest('R58 duplicate remote verifies the real live owner and leaves its author
     first.stdin.end();assert.equal((await firstOutput.closed).code,0,firstOutput.stderr);
   }finally{
     if(first?.exitCode===null)first.kill();if(second?.exitCode===null)second.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -623,14 +670,14 @@ winTest('bare remote refuses unverified legacy ownership without touching author
     const output=await collect(child);
     await sleep(500);
     if(child.exitCode===null) child.stdin.end();
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     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);
   }finally{
     if(child?.exitCode===null) child.kill();
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });
 
@@ -639,11 +686,11 @@ winTest('explicit remote status remains a one-shot controller command',async()=>
   try{
     const child=spawn(process.execPath,[cliPath,'remote','status'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined);
     assert.equal(ended.code,0,output.stderr);
     assert.deepEqual(await traceCommands(fx.trace),['status']);
-  }finally{await rm(fx.dir,{recursive:true,force:true});}
+  }finally{await safeRm(fx.dir);}
 });
 
 winTest('explicit remote status keeps the coherent runtime one-shot and silent',async()=>{
@@ -658,12 +705,12 @@ winTest('explicit remote status keeps the coherent runtime one-shot and silent',
     }),'utf8');
     const child=spawn(process.execPath,[cliPath,'remote','status'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined);
     assert.equal(ended.code,0,output.stderr);
     assert.doesNotMatch(output.stderr,/VERSION SKEW/);
     assert.deepEqual(await traceCommands(fx.trace),['status']);
-  }finally{await rm(fx.dir,{recursive:true,force:true});}
+  }finally{await safeRm(fx.dir);}
 });
 
 winTest('bare remote surfaces bounded controller-start-failure evidence instead of only exit code',async()=>{
@@ -671,12 +718,12 @@ winTest('bare remote surfaces bounded controller-start-failure evidence instead
   try{
     const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    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);
-  }finally{await rm(fx.dir,{recursive:true,force:true});}
+  }finally{await safeRm(fx.dir);}
 });
 
 
@@ -710,11 +757,11 @@ winTest('remote --trace --filter selects presentation without dropping journaled
     const journal=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-results',marker.result_session_id+'.json'),'utf8'));
     assert.equal(journal.events.length,4,'presentation filter must not remove journal evidence');
     child.stdin.end();
-    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined);
     assert.equal(ended.code,0,output.stderr);
   }finally{
     if(child?.exitCode===null) child.kill('SIGKILL');
-    await rm(fx.dir,{recursive:true,force:true});
+    await safeRm(fx.dir);
   }
 });

package/test/standing-grants.test.mjs

@@ -85,13 +85,13 @@ test('host standing grant remains armed until explicit revocation', async () =>
   assert.equal(status.remaining_ms, null);
 });
 
-test('controller emits standing grants and hides expiry UX', async () => {
+test('controller retains coding/host standing grants but issues bounded autonomous expiry', async () => {
   const controller = await import('node:fs/promises').then(fs => fs.readFile(
     new URL('../controller/deadbyte-controller.ps1', import.meta.url), 'utf8'));
   assert.match(controller, /deadbyte\.host-grant\.v2/);
   assert.match(controller, /deadbyte\.coding-grant\.v2/);
   assert.match(controller, /deadbyte\.autonomous-grant\.v2/);
-  assert.doesNotMatch(controller, /expires_at_utc/);
+  assert.match(controller, /expires_at_utc=\$now\.AddHours\(1\)\.ToString\('o'\)/);
   assert.doesNotMatch(controller, /AddMinutes\((?:15|30|60)\)/);
   assert.doesNotMatch(controller, /expires=/);
 });

package/test/tool-audit.test.mjs

@@ -71,6 +71,20 @@ test('tool wrapper durably records request before handler and writes correlated
   }finally{await rm(root,{recursive:true,force:true});}
 });
 
+test('R69 audit retains explicit unknown side effect even when a tool envelope says ok',async()=>{
+  const root=await temp();
+  try{
+    const k=await keys(root);
+    const audit=await createToolAudit({stateRoot:root,signingKeyPath:k.privateKeyPath,contextProvider:async()=>context()});
+    const server=fakeServer();installToolAudit(server,audit);
+    server.registerTool('uncertain_write',{},async()=>({isError:false,
+      structuredContent:{status:'ok',side_effect_state:'unknown'}}));
+    await server.handlers.get('uncertain_write')({path:'scratch.txt'});
+    const all=await events(root);
+    assert.equal(all.at(-1).outcome.side_effect_state,'unknown');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
 test('audit failure before request commit prevents handler side effects',async()=>{
   const server=fakeServer();let sideEffect=false;
   installToolAudit(server,{async recordRequest(){throw new Error('audit unavailable');},async recordResult(){throw new Error('unexpected');}});