deadbyte-mcp 0.11.0 → 0.11.1

package/src/version.mjs

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

package/test/cli-entrypoint.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -16,6 +17,14 @@ test('package exposes npx-first deadbyte-mcp bin and is registry-publishable',as
   assert.equal(pkg.publishConfig?.access,'public');
 });
 
+test('npx CLI reports the canonical package version through --version, -v and version',()=>{
+  for(const arg of ['--version','-v','version']){
+    const result=spawnSync(process.execPath,[cliPath,arg],{cwd:root,encoding:'utf8',windowsHide:true});
+    assert.equal(result.status,0,result.stderr);
+    assert.equal(result.stdout.trim(),'0.11.1');
+  }
+});
+
 test('npx CLI remote path invokes stable PS1 directly and never routes through CMD',async()=>{
   const source=await readFile(cliPath,'utf8');
   assert.match(source,/^#!\/usr\/bin\/env node/m);

package/test/containment.test.mjs

@@ -230,6 +230,24 @@ test('native build script targets Windows 10 and preserves MSVC diagnostics', as
   assert.doesNotMatch(source, /\$VsWhere = Join-Path \$\{env:ProgramFiles\(x86\)\}/);
 });
 
+test('native build is reproducible at both MSVC object and linker boundaries', async () => {
+  const buildScript = fileURLToPath(new URL('../scripts/build-containment.ps1', import.meta.url));
+  const source = await readFile(buildScript, 'utf8');
+  const lines = source.split(/\r?\n/);
+  const commonLine = lines.find(line => line.startsWith('$Common ='));
+  const bootstrapLine = lines.find(line => line.startsWith('$BootstrapCommon ='));
+  assert.ok(commonLine?.includes('/Brepro'), 'common compiler flags must include /Brepro');
+  assert.ok(bootstrapLine?.includes('/Brepro'), 'bootstrap compiler flags must include /Brepro');
+  for (const name of [
+    'Launcher','Probe','BootstrapKernel','BootstrapAdvapi','StageLauncher','BootstrapExit',
+    'ChildControlStage','ChildControlProbe','ContainedLauncher','ContainedWorker',
+    'ContainedReverseWorker','TunnelHost','ProcessHost'
+  ]) {
+    const line = lines.find(candidate => candidate.startsWith(`$${name}Command =`));
+    assert.ok(line?.includes('/link /Brepro /INCREMENTAL:NO'), `${name} linker flags must be reproducible and non-incremental`);
+  }
+});
+
 
 
 test('native build command composition is Windows PowerShell 5.1 parser-safe', async () => {

package/test/core.test.mjs

@@ -105,7 +105,7 @@ test('proof execution creates deterministic output and signed verifiable receipt
   assert.equal(result.receipt.request.schema, 'deadbyte.request.v1');
   assert.match(result.receipt.request.nonce, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.request.sha256, /^[0-9a-f]{64}$/);
-  assert.equal(result.receipt.runtime.package_version, '0.11.0');
+  assert.equal(result.receipt.runtime.package_version, '0.11.1');
   assert.match(result.receipt.runtime.mcp_ingress_adapter, /^(?:none|tunnel-stdio-probe-compat-v1)$/);
   assert.match(result.receipt.runtime.mcp_ingress_adapter_sha256, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.runtime.mcp_ingress_mode_source_sha256, /^[0-9a-f]{64}$/);

package/test/production-docs.test.mjs

@@ -9,9 +9,9 @@ const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
 
 test('production README documents one-command stdio configs for major MCP clients',async()=>{
   const text=await readme();
-  assert.match(text,/npx -y deadbyte-mcp@0\.11\.0 mcp/);
+  assert.match(text,/npx -y deadbyte-mcp@0\.11\.1 mcp/);
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.0"[\s\S]*?"mcp"/);
+  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.1"[\s\S]*?"mcp"/);
   assert.match(text,/CURSOR/);
   assert.match(text,/\.cursor\/mcp\.json/);
   assert.match(text,/VS CODE/);
@@ -20,7 +20,7 @@ test('production README documents one-command stdio configs for major MCP client
   assert.match(text,/CODEX/);
   assert.match(text,/\[mcp_servers\.deadbyte\]/);
   assert.match(text,/command\s*=\s*"npx"/);
-  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.11\.0",\s*"mcp"\]/);
+  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.11\.1",\s*"mcp"\]/);
 });
 
 test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{

package/test/r33-closeout-regression.test.mjs

@@ -102,9 +102,9 @@ test('Windows R37 gate emits manifest-bound machine-readable evidence outside th
     assert.equal(evidence.schema,'deadbyte.r37-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
-    assert.equal(evidence.version,'0.11.0');
+    assert.equal(evidence.version,'0.11.1');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.11.0 / R37 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.11.1 / R37 WINDOWS BATCH GATE: PASS');
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -33,10 +33,10 @@ test('R37 final closure verifier is implementation-independent from production h
   assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
   assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
   assert.match(verifier, /DEADBYTE-R37-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.11\.0'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.11\.0'/);
+  assert.match(writer, /pointer\.version==='0\.11\.1'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.11\.1'/);
   assert.match(verifier, /release_label==='R37 FINAL MACHINE BASELINE'/);
-  assert.match(verifier, /8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
+  assert.match(verifier, /08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {

package/test/r36-release-identity.test.mjs

@@ -10,10 +10,10 @@ const R36_RELEASE_ID='v0.10.0-8d1e5f09745e7647';
 const R36_MANIFEST='8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8';
 
 test('sealed R36 historical proof scripts preserve 0.10.0 / R36 and exact R35 predecessor',async()=>{
-  const [gate,parity,closure,closureVerify,windowsGate,currentParity]=await Promise.all([
+  const [gate,parity,closure,closureVerify,windowsGate,r37_0110Parity]=await Promise.all([
     text('scripts/gate-windows-r36.ps1'),text('scripts/release-parity-r36.mjs'),
     text('scripts/final-closure-r36.mjs'),text('scripts/final-closure-verify-r36.mjs'),
-    text('scripts/windows-gate-evidence-r36.mjs'),text('scripts/release-parity.mjs')
+    text('scripts/windows-gate-evidence-r36.mjs'),text('scripts/release-parity-r37-0110.mjs')
   ]);
   assert.match(gate,/DEADBYTE V0\.10\.0 \/ R36 WINDOWS BATCH GATE: PASS/);
   assert.match(parity,/deadbyte\.r36-parity\.v1/);
@@ -23,8 +23,8 @@ test('sealed R36 historical proof scripts preserve 0.10.0 / R36 and exact R35 pr
   assert.match(closure,/version:'0\.10\.0'/);
   assert.match(closureVerify,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
   assert.match(windowsGate,/deadbyte\.r36-windows-gate\.v1/);
-  assert.match(currentParity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
-  assert.match(currentParity,new RegExp(R36_MANIFEST));
+  assert.match(r37_0110Parity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
+  assert.match(r37_0110Parity,new RegExp(R36_MANIFEST));
 });
 
 test('current R37 controller still binds production remote to compact profile and restores parent environment',async()=>{

package/test/r37-0110-history.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+
+test('sealed public 0.11.0 release scripts remain preserved as historical R37 authority',async()=>{
+  const [gate,evidence,parity,closure,verify,deferred]=await Promise.all([
+    text('scripts/gate-windows-r37-0110.ps1'),text('scripts/windows-gate-evidence-r37-0110.mjs'),
+    text('scripts/release-parity-r37-0110.mjs'),text('scripts/final-closure-r37-0110.mjs'),
+    text('scripts/final-closure-verify-r37-0110.mjs'),text('scripts/deferred-slot-operation-r37-0110.mjs')
+  ]);
+  assert.match(gate,/V0\.11\.0 \/ R37/);
+  assert.match(evidence,/version:'0\.11\.0'/);
+  assert.match(parity,/v0\.10\.0-8d1e5f09745e7647/);
+  assert.match(parity,/candidate\?\.version==='0\.11\.0'/);
+  assert.match(closure,/version:'0\.11\.0'/);
+  assert.match(verify,/value\?\.version==='0\.11\.0'/);
+  assert.match(deferred,/--expected-version','0\.11\.0'/);
+});

package/test/r37-finalization.test.mjs

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
-import { validateParityEvidence, R36_PREDECESSOR_RELEASE_ID, R36_PREDECESSOR_MANIFEST } from '../scripts/release-parity.mjs';
+import { validateParityEvidence, R37_PREDECESSOR_RELEASE_ID, R37_PREDECESSOR_MANIFEST } from '../scripts/release-parity.mjs';
 import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
 
 const root=new URL('../',import.meta.url);
@@ -11,22 +11,22 @@ function parityFixture(){
   const manifest='a'.repeat(64);
   return {
     schema:'deadbyte.r37-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
-    candidate:{release_id:`v0.11.0-${manifest.slice(0,16)}`,version:'0.11.0',manifest_sha256:manifest},
+    candidate:{release_id:`v0.11.1-${manifest.slice(0,16)}`,version:'0.11.1',manifest_sha256:manifest},
     immutable_slot:{protected:true,release_root:'C:/immutable/r37',development_root:'D:/Projects/deadbyte-mcp-r36-dev'},
     local_full:{status:'passed',tool_count:76,strict_output_schemas:true},
     public_compact:{status:'passed',tool_count:41,capability_closure:true,gateway_count:5},
     autonomous:{status:'passed',signed_release_verified:true,observed_failure_before_replan:true},
     before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
     rollback:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},restore:{state:'completed'},
-    predecessor:{release_id:R36_PREDECESSOR_RELEASE_ID,version:'0.10.0',manifest_sha256:R36_PREDECESSOR_MANIFEST},
+    predecessor:{release_id:R37_PREDECESSOR_RELEASE_ID,version:'0.11.0',manifest_sha256:R37_PREDECESSOR_MANIFEST},
     predecessor_disarmed:{status:'passed',tool_count:41,capability_closure:true},
-    successor:{release_id:`v0.11.0-${manifest.slice(0,16)}`,version:'0.11.0',manifest_sha256:manifest},
+    successor:{release_id:`v0.11.1-${manifest.slice(0,16)}`,version:'0.11.1',manifest_sha256:manifest},
     successor_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false},
     requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface'].map(key=>[key,true]))
   };
 }
 
-test('R37 parity validator requires full-76, compact closure, exact R36 predecessor and immutable-slot separation',()=>{
+test('R37 parity validator requires full-76, compact closure, exact public 0.11.0 predecessor and immutable-slot separation',()=>{
   const good=parityFixture();
   assert.equal(validateParityEvidence(good),true);
   assert.throws(()=>validateParityEvidence({...good,local_full:{...good.local_full,tool_count:75}}),/full 76/i);
@@ -36,33 +36,33 @@ test('R37 parity validator requires full-76, compact closure, exact R36 predeces
   assert.throws(()=>validateParityEvidence({...good,stage_restore:{status:'missing',manifest_sha256:good.candidate.manifest_sha256}}),/stage restore/i);
 });
 
-test('R37 parity captures R37 bridge, exact R36 predecessor, stage reseed and successor restore',async()=>{
+test('R37 parity captures R37 bridge, exact public 0.11.0 predecessor, stage reseed and successor restore',async()=>{
   const parity=await text('scripts/release-parity.mjs');
-  assert.match(parity,/R36_PREDECESSOR_RELEASE_ID='v0\.10\.0-8d1e5f09745e7647'/);
-  assert.match(parity,/8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
+  assert.match(parity,/R37_PREDECESSOR_RELEASE_ID='v0\.11\.0-08c2a0008b1f84c9'/);
+  assert.match(parity,/08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
   assert.match(parity,/const stageRestore=await restoreFrozenStage/);
-  assert.match(parity,/publicR36Disarmed/);
+  assert.match(parity,/publicR37Disarmed/);
   assert.match(parity,/scheduleDeferred\('activate',candidateManifest,\{bridgeRoot:successorBridge\.root,bridgeScriptSha256:successorBridge\.sha256\}\)/);
 });
 
-test('R37 current final closure writer and independent verifier bind R37 domains and R36 predecessor',async()=>{
+test('R37 current final closure writer and independent verifier bind R37 domains and public 0.11.0 predecessor',async()=>{
   const [writer,verifier]=await Promise.all([text('scripts/final-closure.mjs'),text('scripts/final-closure-verify.mjs')]);
   assert.equal(typeof verifyFinalClosureObject,'function');
   assert.match(writer,/DEADBYTE-R37-FINAL-CLOSURE-V1/);
   assert.match(writer,/deadbyte\.r37-final-closure\.v1/);
-  assert.match(writer,/pointer\.version==='0\.11\.0'/);
+  assert.match(writer,/pointer\.version==='0\.11\.1'/);
   assert.match(writer,/R37 FINAL MACHINE BASELINE/);
   assert.match(writer,/deadbyte\.r37-parity\.v1/);
   assert.match(writer,/deadbyte\.r37-windows-gate\.v1/);
-  assert.match(writer,/R36_PREDECESSOR_RELEASE_ID/);
+  assert.match(writer,/R37_PREDECESSOR_RELEASE_ID/);
   assert.doesNotMatch(verifier,/from ['"]\.\.\/src\//);
   assert.match(verifier,/DEADBYTE-R37-FINAL-CLOSURE-V1/);
   assert.match(verifier,/deadbyte\.r37-final-closure\.v1/);
-  assert.match(verifier,/envelope\.body\.version==='0\.11\.0'/);
+  assert.match(verifier,/envelope\.body\.version==='0\.11\.1'/);
   assert.match(verifier,/R37 FINAL MACHINE BASELINE/);
   assert.match(verifier,/deadbyte\.r37-parity\.v1/);
   assert.match(verifier,/deadbyte\.r37-windows-gate\.v1/);
-  assert.match(verifier,/8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
+  assert.match(verifier,/08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
 });
 
 test('R37 bounded public parity suite covers current release identity and agent fabric',async()=>{

package/test/r37-remote-tool-call-timeline.test.mjs

@@ -0,0 +1,94 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createLiveTimelineTracker, formatRemoteToolCall } from '../src/remote-live-log.mjs';
+import { openRemoteResultJournal } from '../src/remote-result-journal.mjs';
+
+const H=c=>c.repeat(64);
+const session='c'.repeat(24);
+
+test('R37 unified timeline renders one sanitized tool-call line with ISO timestamp, padded tool name, and JSON arguments',()=>{
+  const event={
+    event_type:'tool.request',
+    request_id:'abcdef1234567890',
+    tool:'coding_file_write',
+    created_at_utc:'2026-09-18T16:24:30.125Z',
+    args:{
+      root_id:'projects',
+      path:'src/example.mjs',
+      content:'TOP_SECRET_PAYLOAD',
+      token:'TOP_SECRET_TOKEN',
+      nested:{authorization:'Bearer abc.def.ghi',safe:true}
+    }
+  };
+  const line=formatRemoteToolCall(event);
+  assert.match(line,/^2026-09-18T16:24:30\.125Z \| coding_file_write\s+\| Arguments: \{/);
+  assert.match(line,/"root_id":"projects"/);
+  assert.match(line,/"path":"src\/example\.mjs"/);
+  assert.match(line,/"reason":"payload"/);
+  assert.match(line,/"reason":"secret"/);
+  assert.doesNotMatch(line,/TOP_SECRET_PAYLOAD|TOP_SECRET_TOKEN|Bearer abc\.def\.ghi/);
+});
+
+test('R37 live tracker uses the tool-call line for request and keeps correlated terminal result',()=>{
+  let now=Date.parse('2026-09-18T16:24:30.125Z');
+  const tracker=createLiveTimelineTracker({clock:()=>now});
+  const call=tracker.observe({event_type:'tool.request',request_id:'abcdef1234567890',tool:'coding_tree',
+    created_at_utc:'2026-09-18T16:24:30.125Z',args:{root_id:'projects',path:'src'}});
+  assert.match(call,/^2026-09-18T16:24:30\.125Z \| coding_tree\s+\| Arguments: \{"path":"src","root_id":"projects"\}$/);
+  now+=250;
+  assert.equal(tracker.observe({event_type:'tool.result',request_id:'abcdef1234567890',tool:'coding_tree',
+    outcome:{is_error:false,duration_ms:250}}),'✓ [abcdef12] OK  coding_tree 250ms');
+});
+
+test('R37 remote result journal persists sanitized tool-call and result in one monotonic cursor stream',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r37-toolcall-journal-'));
+  const file=path.join(root,'journal.json');
+  try{
+    const journal=await openRemoteResultJournal({filePath:file,sessionId:session,maxEntries:16});
+    const call=await journal.recordCall({
+      request_id:'req-1',tool:'coding_file_write',observed_at_utc:'2026-09-18T16:24:30.125Z',
+      arguments:{root_id:'projects',path:'x.txt',content:'DO_NOT_STORE_PAYLOAD',token:'DO_NOT_STORE_TOKEN'},
+      payload_sha256:H('1')
+    });
+    const duplicate=await journal.recordCall({
+      request_id:'req-1',tool:'coding_file_write',observed_at_utc:'2026-09-18T16:24:30.125Z',
+      arguments:{root_id:'projects',path:'x.txt',content:'DO_NOT_STORE_PAYLOAD',token:'DO_NOT_STORE_TOKEN'},
+      payload_sha256:H('1')
+    });
+    const result=await journal.recordTerminal({
+      request_id:'req-1',tool:'coding_file_write',status:'ok',observed_at_utc:'2026-09-18T16:24:30.500Z',
+      payload_sha256:H('2')
+    });
+    assert.equal(call.event.seq,1);
+    assert.equal(call.event.event_type,'tool.call');
+    assert.equal(duplicate.duplicate,true);
+    assert.equal(result.event.seq,2);
+    assert.equal(result.event.event_type,'tool.result');
+    assert.equal(journal.cursor(),'r1:'+session+':2');
+    const replay=await journal.replayAfter('r1:'+session+':0',{limit:8});
+    assert.deepEqual(replay.events.map(e=>[e.seq,e.event_type]),[[1,'tool.call'],[2,'tool.result']]);
+    const disk=await readFile(file,'utf8');
+    assert.doesNotMatch(disk,/DO_NOT_STORE_PAYLOAD|DO_NOT_STORE_TOKEN/);
+    assert.match(disk,/"reason":"payload"/);
+    assert.match(disk,/"reason":"secret"/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R37 journal remains backward-compatible with pre-tool-call result-only events',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r37-old-result-journal-'));
+  const file=path.join(root,'journal.json');
+  try{
+    await import('node:fs/promises').then(({writeFile})=>writeFile(file,JSON.stringify({
+      schema:'deadbyte.remote-result-journal.v1',session_id:session,next_seq:2,
+      events:[{session_id:session,seq:1,request_id:'old-1',tool:'coding_tree',status:'ok',
+        observed_at_utc:'2026-09-17T00:00:00.000Z',payload_sha256:H('3')}]
+    })+'\n','utf8'));
+    const journal=await openRemoteResultJournal({filePath:file,sessionId:session,maxEntries:16});
+    const replay=await journal.replayAfter('r1:'+session+':0',{limit:8});
+    assert.equal(replay.events[0].event_type,'tool.result');
+    assert.equal(replay.events[0].status,'ok');
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/release-version.test.mjs

@@ -5,10 +5,10 @@ import { createHash } from 'node:crypto';
 
 const root=new URL('../',import.meta.url);
 const text=rel=>readFile(new URL(rel,root),'utf8');
-const R36_RELEASE_ID='v0.10.0-8d1e5f09745e7647';
-const R36_MANIFEST='8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8';
+const R37_PREDECESSOR_RELEASE_ID='v0.11.0-08c2a0008b1f84c9';
+const R37_PREDECESSOR_MANIFEST='08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8';
 
-test('R37 successor release authority agrees on V0.11.0 / R37 and preserves exact public R36 predecessor',async()=>{
+test('R37 patch release authority agrees on V0.11.1 and preserves exact public 0.11.0 predecessor',async()=>{
   const pkg=JSON.parse(await text('package.json'));
   const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,semanticConfig]=await Promise.all([
     text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows.ps1'),
@@ -17,35 +17,28 @@ test('R37 successor release authority agrees on V0.11.0 / R37 and preserves exac
     text('scripts/final-closure-verify.mjs'),text('scripts/windows-gate-evidence.mjs'),
     text('controller/deadbyte-semantic-lsp-config.json')
   ]);
-  assert.equal(pkg.version,'0.11.0');
-  assert.match(version,/DEADBYTE_VERSION = '0\.11\.0'/);
-  assert.match(controller,/CONTROLLER V0\.11\.0 \/ R37/);
-  assert.match(gate,/DEADBYTE V0\.11\.0 \/ R37 WINDOWS BATCH GATE: PASS/);
-  assert.match(readme,/^DEADBYTE MCP V0\.11\.0 \/ R37 PRODUCTION BASELINE$/m);
-  assert.match(architecture,/^# DEADBYTE MCP V0\.11\.0 \/ R37 ARCHITECTURE$/m);
-  assert.match(controllerReadme,/^DEADBYTE MCP V0\.11\.0 \/ R37 CONTROLLER$/m);
-  assert.match(controllerReadme,/full 76-tool (?:profile|catalog)/);
-  assert.match(controllerReadme,/compact capability profile[^\n]*<=42 tools/);
-  assert.match(deferred,/--expected-version','0\.11\.0'/);
-  assert.match(parity,/deadbyte\.r37-parity\.v1/);
-  assert.match(parity,/version==='0\.11\.0'|version:'0\.11\.0'/);
-  assert.match(parity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
-  assert.match(parity,new RegExp(R36_MANIFEST));
-  assert.match(closure,/DEADBYTE-R37-FINAL-CLOSURE-V1/);
-  assert.match(closure,/version:'0\.11\.0'/);
-  assert.match(closureVerify,/DEADBYTE V0\.11\.0 \/ R37 WINDOWS BATCH GATE: PASS/);
-  assert.match(windowsGate,/schema:'deadbyte\.r37-windows-gate\.v1'/);
+  assert.equal(pkg.version,'0.11.1');
+  assert.match(version,/DEADBYTE_VERSION = '0\.11\.1'/);
+  assert.match(controller,/CONTROLLER V0\.11\.1 \/ R37/);
+  assert.match(gate,/DEADBYTE V0\.11\.1 \/ R37 WINDOWS BATCH GATE: PASS/);
+  assert.match(readme,/^DEADBYTE MCP V0\.11\.1 \/ R37 PRODUCTION BASELINE$/m);
+  assert.match(architecture,/^# DEADBYTE MCP V0\.11\.1 \/ R37 ARCHITECTURE$/m);
+  assert.match(controllerReadme,/^DEADBYTE MCP V0\.11\.1 \/ R37 CONTROLLER$/m);
+  assert.match(deferred,/--expected-version','0\.11\.1'/);
+  assert.match(parity,/R37_PREDECESSOR_RELEASE_ID='v0\.11\.0-08c2a0008b1f84c9'/);
+  assert.match(parity,new RegExp(R37_PREDECESSOR_MANIFEST));
+  assert.match(parity,/version==='0\.11\.1'|version:'0\.11\.1'/);
+  assert.match(closure,/version:'0\.11\.1'/);
+  assert.match(closureVerify,/DEADBYTE V0\.11\.1 \/ R37 WINDOWS BATCH GATE: PASS/);
+  assert.match(windowsGate,/version:'0\.11\.1'/);
   assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
 });
 
-test('R37 keeps the R36 capability surface contract while adding internal agent fabric',async()=>{
-  const [parity,fabric,live]=await Promise.all([
-    text('src/remote-mcp-r36-parity-client.mjs'),
-    text('src/autonomous-runtime.mjs'),
-    text('src/remote-live-log.mjs')
-  ]);
+test('R37 patch keeps capability surface and fixes ONLINE remote startup without restoring verbose mode',async()=>{
+  const [parity,cli]=await Promise.all([text('src/remote-mcp-r36-parity-client.mjs'),text('src/deadbyte-cli.mjs')]);
   assert.match(parity,/R36_EXPECTED_TOOLS\.length !== 76/);
   assert.match(parity,/R36_COMPACT_TOOL_LIMIT=42/);
-  for(const name of ['deriveAgentMemory','effectIdentity','createWorkerScheduler','issueObservationLease']) assert.match(fabric,new RegExp(name));
-  assert.match(live,/createLiveTimelineTracker/);
+  assert.match(cli,/controllerRuntimeReady/);
+  assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
+  assert.doesNotMatch(cli,/remote --verbose/);
 });

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

@@ -2,12 +2,15 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createLiveTimelineTracker } from '../src/remote-live-log.mjs';
 
-test('R37 live timeline correlates RUN and result with stable short span id',()=>{
+test('R37 live timeline renders sanitized tool-call detail and correlates terminal result with stable short span id',()=>{
   let now=1000;
   const tracker=createLiveTimelineTracker({clock:()=>now});
   const run=tracker.observe({event_type:'tool.request',tool:'coding_file_read',request_id:'abcdef1234567890',
     args:{root_id:'projects',path:'src/a.mjs',content:'SECRET',token:'SECRET'}});
-  assert.equal(run,'▶ [abcdef12] RUN coding_file_read root=projects path=src/a.mjs');
+  assert.match(run,/^1970-01-01T00:00:01\.000Z \| coding_file_read\s+\| Arguments: \{/);
+  assert.match(run,/\"path\":\"src\/a\.mjs\"/);
+  assert.match(run,/\"reason\":\"payload\"/);
+  assert.match(run,/\"reason\":\"secret\"/);
   now=1250;
   const done=tracker.observe({event_type:'tool.result',tool:'coding_file_read',request_id:'abcdef1234567890',
     outcome:{is_error:false,duration_ms:250}});

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

@@ -11,16 +11,16 @@ const cliPath=path.join(root,'src','deadbyte-cli.mjs');
 const isWindows=process.platform==='win32';
 const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
 
-async function fixture({failCommand=''}={}){
+async function fixture({failCommand='',statusOnline=false}={}){
   const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-remote-session-'));
   const state=path.join(dir,'state');
   const bin=path.join(state,'bin');
   const trace=path.join(dir,'trace.txt');
   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) { Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { Write-Host 'DEADBYTE MCP = ONLINE' }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'hoststatus' { Write-Host 'Host plane    : DISARMED [disarmed]' }\n  'park' { Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
+  const ps1=`param([string]$Command)\n$ErrorActionPreference='Stop'\nfor($i=0;$i -lt 20;$i++){ try { [IO.File]::AppendAllText($env:DEADBYTE_REMOTE_TEST_TRACE,(\"$Command\" + [Environment]::NewLine),[Text.Encoding]::UTF8); break } catch { if($i -eq 19){ throw }; Start-Sleep -Milliseconds 10 } }\nif ($env:DEADBYTE_REMOTE_TEST_FAIL -and $Command -eq $env:DEADBYTE_REMOTE_TEST_FAIL) { Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { Write-Host 'DEADBYTE MCP = ONLINE' }\n  'status' { if ($env:DEADBYTE_REMOTE_TEST_STATUS_ONLINE -eq '1') { Write-Host 'DEADBYTE MCP = ONLINE'; Write-Host 'Bridge PID   : 1001 [verified]'; Write-Host 'Cloud PID    : 1002 [verified]'; Write-Host 'Local ready  : True'; Write-Host 'Loop supervisor: RUNNING [verified]' } else { Write-Host 'DEADBYTE MCP = OFFLINE' } }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'hoststatus' { Write-Host 'Host plane    : DISARMED [disarmed]' }\n  'park' { Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
   await writeFile(launcher,ps1,'utf8');
-  return {dir,state,trace,env:{...process.env,DEADBYTE_STATE_ROOT:state,DEADBYTE_REMOTE_TEST_TRACE:trace,DEADBYTE_REMOTE_TEST_FAIL:failCommand}};
+  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'}};
 }
 
 async function traceCommands(file,{read=readFile,retryDelayMs=10,maxAttempts=20}={}){
@@ -65,15 +65,40 @@ async function collect(child){
 
 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});
+  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 ready=await waitFor(fx.trace,commands=>commands.includes('hoststatus'),{timeoutMs:8000});
+    assert.deepEqual(ready.slice(0,8),[
+      'status','armprocess','armcoding','armautonomous',
+      'processstatus','codingstatus','autonomousstatus','hoststatus'
+    ]);
+    assert.doesNotMatch(ready.join(','),/(^|,)start(,|$)/);
+    assert.equal(child.exitCode,null,'remote session must remain foreground after reusing ONLINE runtime');
+    assert.match(output.stdout,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
+    const authDeadline=Date.now()+3000;
+    while(Date.now()<authDeadline&&!/🔐 \[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/🔐 \[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/);
+    child.kill('SIGINT');
+    await output.closed;
+  }finally{
+    if(child&&child.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
 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();
   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 ready=await waitFor(fx.trace,commands=>commands.slice(0,8).join(',')==='start,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,8),[
-      'start','armprocess','armcoding','armautonomous',
+    const ready=await waitFor(fx.trace,commands=>commands.slice(0,9).join(',')==='status,start,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
+    assert.deepEqual(ready.slice(0,9),[
+      'status','start','armprocess','armcoding','armautonomous',
       'processstatus','codingstatus','autonomousstatus','hoststatus'
     ]);
     assert.equal(child.exitCode,null,'remote session must remain foreground after becoming ready');
@@ -111,13 +136,14 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
     ].join('\n')+'\n','utf8');
     const logDeadline=Date.now()+3000;
     while(Date.now()<logDeadline&&!/✗ \[fedcba98\] ERR coding_file_read 1\.73s/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/▶ \[abcdef12\] RUN coding_tree root=projects path=src/);
-    assert.match(output.stdout,/✓ \[abcdef12\] OK  coding_tree 42ms \[cursor r1:[0-9a-f]{24}:1\]/);
-    assert.match(output.stdout,/▶ \[fedcba98\] RUN coding_file_read root=projects path=src\/deadbyte-cli\.mjs/);
-    assert.match(output.stdout,/✗ \[fedcba98\] ERR coding_file_read 1\.73s \[cursor r1:[0-9a-f]{24}:2\]/);
+    assert.match(output.stdout,/^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}Z \| coding_tree\s+\| Arguments: .*\"path\":\"src\".*\"root_id\":\"projects\".*\[cursor r1:[0-9a-f]{24}:1\]$/m);
+    assert.match(output.stdout,/✓ \[abcdef12\] OK  coding_tree 42ms \[cursor r1:[0-9a-f]{24}:2\]/);
+    assert.match(output.stdout,/^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}Z \| coding_file_read\s+\| Arguments: \{\"path\":\"src\/deadbyte-cli\.mjs\",\"root_id\":\"projects\"\} \[cursor r1:[0-9a-f]{24}:3\]$/m);
+    assert.match(output.stdout,/✗ \[fedcba98\] ERR coding_file_read 1\.73s \[cursor r1:[0-9a-f]{24}:4\]/);
     assert.equal((output.stdout.match(/✓ \[abcdef12\] OK  coding_tree 42ms/g)||[]).length,1,'duplicate terminal result must print once');
     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]);
+    assert.deepEqual(resultJournal.events.map(event=>event.seq),[1,2,3,4]);
+    assert.deepEqual(resultJournal.events.map(event=>event.event_type),['tool.call','tool.result','tool.call','tool.result']);
     assert.equal(resultJournal.events[0].request_id,'abcdef1234567890');
     assert.ok(resultJournal.events.every(event=>/^[0-9a-f]{64}$/.test(event.payload_sha256)));
     assert.doesNotMatch(JSON.stringify(resultJournal),/TOOL IN|TOOL OUT|stdout_excerpt|stderr_excerpt/);
@@ -146,7 +172,7 @@ winTest('bare remote uses one unified live timeline, keeps authority semantics,
   }
 });
 
-winTest('remote --resume replays only terminal results after the cursor before starting a new live session',async()=>{
+winTest('remote --resume replays sanitized tool-call and terminal result events after the cursor without duplicates or loss',async()=>{
   const fx=await fixture();
   let first=null,second=null;
   try{
@@ -157,14 +183,22 @@ winTest('remote --resume replays only terminal results after the cursor before s
     while(Date.now()<liveDeadline&&!/\[LOG\] Unified live timeline/.test(firstOutput.stdout)) await sleep(50);
     const auditDir=path.join(fx.state,'audit');await mkdir(auditDir,{recursive:true});
     const auditFile=path.join(auditDir,'segment-00000001.jsonl');
-    await writeFile(auditFile,JSON.stringify({seq:1,event_type:'tool.result',tool:'coding_tree',request_id:'resume-request-1',outcome:{is_error:false}})+'\n','utf8');
+    const firstBatch=[
+      {seq:1,event_type:'tool.request',tool:'coding_tree',request_id:'resume-request-1',created_at_utc:'2026-09-18T16:30:00.000Z',args:{root_id:'projects',path:'src'}},
+      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'resume-request-1',created_at_utc:'2026-09-18T16:30:00.100Z',outcome:{is_error:false}}
+    ];
+    await writeFile(auditFile,firstBatch.map(JSON.stringify).join('\n')+'\n','utf8');
     let deadline=Date.now()+3000;
-    while(Date.now()<deadline&&!/coding_tree .*\[cursor r1:[0-9a-f]{24}:1\]/.test(firstOutput.stdout)) await sleep(50);
-    const cursor1=firstOutput.stdout.match(/coding_tree .*\[cursor (r1:[0-9a-f]{24}:1)\]/)?.[1];
+    while(Date.now()<deadline&&!/coding_tree .*\[cursor r1:[0-9a-f]{24}:2\]/.test(firstOutput.stdout)) await sleep(50);
+    const cursor1=firstOutput.stdout.match(/coding_tree .*\[cursor (r1:[0-9a-f]{24}:2)\]/)?.[1];
     assert.ok(cursor1,'first result cursor missing');
-    await writeFile(auditFile,JSON.stringify({seq:2,event_type:'tool.result',tool:'coding_file_read',request_id:'resume-request-2',outcome:{is_error:false}})+'\n',{encoding:'utf8',flag:'a'});
+    const secondBatch=[
+      {seq:3,event_type:'tool.request',tool:'coding_file_read',request_id:'resume-request-2',created_at_utc:'2026-09-18T16:30:01.000Z',args:{root_id:'projects',path:'src/deadbyte-cli.mjs',token:'DO_NOT_REPLAY_SECRET'}},
+      {seq:4,event_type:'tool.result',tool:'coding_file_read',request_id:'resume-request-2',created_at_utc:'2026-09-18T16:30:01.100Z',outcome:{is_error:false}}
+    ];
+    await writeFile(auditFile,secondBatch.map(JSON.stringify).join('\n')+'\n',{encoding:'utf8',flag:'a'});
     deadline=Date.now()+3000;
-    while(Date.now()<deadline&&!/coding_file_read .*\[cursor r1:[0-9a-f]{24}:2\]/.test(firstOutput.stdout)) await sleep(50);
+    while(Date.now()<deadline&&!/coding_file_read .*\[cursor r1:[0-9a-f]{24}:4\]/.test(firstOutput.stdout)) await sleep(50);
     first.stdin.end();
     const firstEnded=await Promise.race([firstOutput.closed,sleep(6000).then(()=>({timeout:true}))]);
     assert.equal(firstEnded.timeout,undefined);
@@ -172,14 +206,20 @@ winTest('remote --resume replays only terminal results after the cursor before s
     second=spawn(process.execPath,[cliPath,'remote','--resume',cursor1],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const secondOutput=await collect(second);
     deadline=Date.now()+5000;
-    while(Date.now()<deadline&&(!/\[REPLAY\] \[OK\] coding_file_read \[cursor r1:[0-9a-f]{24}:2\]/.test(secondOutput.stdout)||
+    while(Date.now()<deadline&&(!/coding_file_read\s+\| Arguments: .*REPLAY cursor r1:[0-9a-f]{24}:3/.test(secondOutput.stdout)||
+      !/\[REPLAY\] \[OK\] coding_file_read \[cursor r1:[0-9a-f]{24}:4\]/.test(secondOutput.stdout)||
       !/\[LOG\] Unified live timeline/.test(secondOutput.stdout))) await sleep(50);
-    assert.match(secondOutput.stdout,/\[REPLAY\] \[OK\] coding_file_read \[cursor r1:[0-9a-f]{24}:2\]/);
+    assert.match(secondOutput.stdout,/^2026-09-18T16:30:01\.000Z \| coding_file_read\s+\| Arguments: .*\"path\":\"src\/deadbyte-cli\.mjs\".*REPLAY cursor r1:[0-9a-f]{24}:3$/m);
+    assert.match(secondOutput.stdout,/\[REPLAY\] \[OK\] coding_file_read \[cursor r1:[0-9a-f]{24}:4\]/);
     assert.match(secondOutput.stdout,/♻️ \[SESSION\] Previous result stream replayed/);
+    assert.doesNotMatch(secondOutput.stdout,/DO_NOT_REPLAY_SECRET/);
     assert.doesNotMatch(secondOutput.stdout,/\[REPLAY\] \[OK\] coding_tree/);
-    const replayIndex=secondOutput.stdout.indexOf('[REPLAY]');
+    assert.equal((secondOutput.stdout.match(/\| coding_file_read\s+\| Arguments:/g)||[]).length,1,'tool-call replay duplicated');
+    assert.equal((secondOutput.stdout.match(/\[REPLAY\] \[OK\] coding_file_read/g)||[]).length,1,'terminal replay duplicated');
+    const callReplayIndex=secondOutput.stdout.indexOf('| coding_file_read');
+    const resultReplayIndex=secondOutput.stdout.indexOf('[REPLAY] [OK] coding_file_read');
     const liveIndex=secondOutput.stdout.indexOf('[LOG] Unified live timeline');
-    assert.ok(replayIndex>=0&&liveIndex>replayIndex,'resume replay must happen before new live tail');
+    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(6000).then(()=>({timeout:true}))]);
     assert.equal(secondEnded.timeout,undefined);
@@ -210,8 +250,8 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
     const ready=await waitFor(fx.trace,commands=>commands.slice(0,8).join(',')==='start,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,8),[
-      'start','armprocess','armcoding','armautonomous',
+    assert.deepEqual(ready.slice(0,9),[
+      'status','start','armprocess','armcoding','armautonomous',
       'processstatus','codingstatus','autonomousstatus','hoststatus'
     ]);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
@@ -254,7 +294,7 @@ 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,3),['start','armprocess','armcoding']);
+    assert.deepEqual(commands.slice(0,4),['status','start','armprocess','armcoding']);
     assert.deepEqual(commands.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
     assert.doesNotMatch(output.stdout,/Live logs/i);
   }finally{await rm(fx.dir,{recursive:true,force:true});}
@@ -271,7 +311,8 @@ winTest('bare remote recovers a stale crashed session before arming a new one',a
     const output=await collect(child);
     const ready=await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
     assert.deepEqual(ready.slice(0,5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
-    assert.equal(ready[5],'start');
+    assert.equal(ready[5],'status');
+    assert.equal(ready[6],'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}))]);