deadbyte-mcp 0.10.0 → 0.11.0

package/test/r37-finalization.test.mjs

@@ -0,0 +1,74 @@
+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 { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
+
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+
+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},
+    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_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_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',()=>{
+  const good=parityFixture();
+  assert.equal(validateParityEvidence(good),true);
+  assert.throws(()=>validateParityEvidence({...good,local_full:{...good.local_full,tool_count:75}}),/full 76/i);
+  assert.throws(()=>validateParityEvidence({...good,public_compact:{...good.public_compact,capability_closure:false}}),/compact closure/i);
+  assert.throws(()=>validateParityEvidence({...good,predecessor:{...good.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...good,immutable_slot:{...good.immutable_slot,development_root:good.immutable_slot.release_root}}),/immutable-slot/i);
+  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()=>{
+  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,/const stageRestore=await restoreFrozenStage/);
+  assert.match(parity,/publicR36Disarmed/);
+  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()=>{
+  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,/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.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,/R37 FINAL MACHINE BASELINE/);
+  assert.match(verifier,/deadbyte\.r37-parity\.v1/);
+  assert.match(verifier,/deadbyte\.r37-windows-gate\.v1/);
+  assert.match(verifier,/8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
+});
+
+test('R37 bounded public parity suite covers current release identity and agent fabric',async()=>{
+  const script=await text('scripts/release-parity-tests.ps1');
+  assert.match(script,/r37-finalization\.test\.mjs/);
+  assert.match(script,/release-version\.test\.mjs/);
+  assert.match(script,/r37-agent-fabric\.test\.mjs/);
+  assert.match(script,/remote-live-log-r37\.test\.mjs/);
+});

package/test/release-version.test.mjs

@@ -3,43 +3,49 @@ import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 
-const root = new URL('../', import.meta.url);
-const text = rel => readFile(new URL(rel, root), 'utf8');
+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';
 
-test('R36 successor release authority agrees on V0.10.0 / R36 full+compact identity', 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'),
-    text('README.txt'),
-    text('docs/ARCHITECTURE.md'),
-    text('controller/README.TXT'),
-    text('scripts/deferred-slot-operation.mjs'),
-    text('src/remote-mcp-r36-parity-client.mjs'),
-    text('scripts/final-closure.mjs'),
-    text('scripts/final-closure-verify.mjs'),
-    text('scripts/windows-gate-evidence.mjs'),
+test('R37 successor release authority agrees on V0.11.0 / R37 and preserves exact public R36 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'),
+    text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),
+    text('scripts/deferred-slot-operation.mjs'),text('scripts/release-parity.mjs'),text('scripts/final-closure.mjs'),
+    text('scripts/final-closure-verify.mjs'),text('scripts/windows-gate-evidence.mjs'),
     text('controller/deadbyte-semantic-lsp-config.json')
   ]);
-  assert.equal(pkg.version, '0.10.0');
-  assert.match(version, /DEADBYTE_VERSION = '0\.10\.0'/);
-  assert.match(controller, /CONTROLLER V0\.10\.0 \/ R36/);
-  assert.match(gate, /DEADBYTE V0\.10\.0 \/ R36 WINDOWS BATCH GATE: PASS/);
-  assert.match(readme, /^DEADBYTE MCP V0\.10\.0 \/ R36 PRODUCTION BASELINE$/m);
-  assert.match(architecture, /^# DEADBYTE MCP V0\.10\.0 \/ R36 ARCHITECTURE$/m);
-  assert.match(controllerReadme, /^DEADBYTE MCP V0\.10\.0 \/ R36 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\.10\.0'/);
-  assert.match(parity, /version:'0\.10\.0'/);
-  assert.match(parity, /R36_EXPECTED_TOOLS\.length !== 76/);
-  assert.match(parity, /R36_COMPACT_TOOL_LIMIT=42/);
-  assert.match(closure, /version:'0\.10\.0'/);
-  assert.match(closureVerify, /DEADBYTE V0\.10\.0 \/ R36 WINDOWS BATCH GATE: PASS/);
-  assert.match(windowsGate, /schema:'deadbyte\.r36-windows-gate\.v1'/);
-  assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'), 'd274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
-  assert.match(deferred, /--semantic-lsp-config/);
-  assert.match(deferred, /--semantic-lsp-config-sha256/);
-  assert.match(deferred, /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(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')
+  ]);
+  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/);
 });

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

@@ -0,0 +1,47 @@
+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',()=>{
+  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');
+  now=1250;
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_file_read',request_id:'abcdef1234567890',
+    outcome:{is_error:false,duration_ms:250}});
+  assert.equal(done,'✓ [abcdef12] OK  coding_file_read 250ms');
+  assert.deepEqual(tracker.pending(),[]);
+  assert.doesNotMatch(run+done,/SECRET/);
+});
+
+test('R37 live timeline distinguishes result whose request was outside live tail',()=>{
+  const tracker=createLiveTimelineTracker();
+  const line=tracker.observe({event_type:'tool.result',tool:'coding_tree',request_id:'old-request-12345678',
+    outcome:{is_error:false,duration_ms:15}});
+  assert.equal(line,'↩ [old-requ] OK  coding_tree 15ms (request before live window)');
+});
+
+test('R37 live timeline deduplicates terminal result and reports interrupted spans with ids',()=>{
+  const tracker=createLiveTimelineTracker();
+  tracker.observe({event_type:'tool.request',tool:'coding_command_run',request_id:'request-23456789',args:{command_id:'node_script'}});
+  const first=tracker.observe({event_type:'tool.result',tool:'coding_command_run',request_id:'request-23456789',outcome:{is_error:true,duration_ms:900}});
+  const duplicate=tracker.observe({event_type:'tool.result',tool:'coding_command_run',request_id:'request-23456789',outcome:{is_error:true,duration_ms:900}});
+  assert.equal(first,'✗ [request-] ERR coding_command_run 900ms');
+  assert.equal(duplicate,null);
+
+  tracker.observe({event_type:'tool.request',tool:'coding_file_read',request_id:'pending-12345678',args:{path:'src/a.mjs'}});
+  assert.deepEqual(tracker.reconcileInterrupted('recovery'),[
+    '⚠ [pending-] INTERRUPTED coding_file_read — recovery ended before terminal result'
+  ]);
+});
+
+test('R37 CLI uses timeline tracker for compact live mode while keeping legacy formatter API',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const src=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(src,/createLiveTimelineTracker/);
+  assert.match(src,/const activityTracker=createLiveTimelineTracker\(\)/);
+  assert.doesNotMatch(src,/remote --verbose/);
+  assert.doesNotMatch(src,/args\[0\]==='--verbose'/);
+});

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

@@ -65,7 +65,7 @@ async function collect(child){
 
 const winTest=isWindows?test:test.skip;
 
-winTest('bare remote uses compact human logs by default, keeps authority semantics, then disarms and parks when the foreground session ends',async()=>{
+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{
@@ -87,7 +87,7 @@ winTest('bare remote uses compact human logs by default, keeps authority semanti
     assert.match(output.stdout,/\[OK\] ONLINE/);
     assert.match(output.stdout,/✅ \[READY\] DEADBYTE MCP online/);
     assert.match(output.stdout,/🔐 \[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/);
-    assert.match(output.stdout,/\[LOG\] Live activity\. Ctrl\+C disconnects and revokes authority\./);
+    assert.match(output.stdout,/\[LOG\] Unified live timeline\. Ctrl\+C disconnects and revokes authority\./);
     assert.doesNotMatch(output.stdout,/Process plane\s*:/);
     assert.doesNotMatch(output.stdout,/Coding plane\s*:/);
     const auditDir=path.join(fx.state,'audit');
@@ -110,20 +110,23 @@ winTest('bare remote uses compact human logs by default, keeps authority semanti
       '[TOOL OUT] 2026-09-16T00:00:00.002Z #000002 coding_file_read {"is_error":true}'
     ].join('\n')+'\n','utf8');
     const logDeadline=Date.now()+3000;
-    while(Date.now()<logDeadline&&!/❌ ERR coding_file_read 1\.73s/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/▶ RUN coding_tree root=projects path=src/);
-    assert.match(output.stdout,/✅ OK coding_tree 42ms \[cursor r1:[0-9a-f]{24}:1\]/);
-    assert.match(output.stdout,/▶ RUN coding_file_read root=projects path=src\/deadbyte-cli\.mjs/);
-    assert.match(output.stdout,/❌ ERR coding_file_read 1\.73s \[cursor r1:[0-9a-f]{24}:2\]/);
-    assert.equal((output.stdout.match(/✅ OK coding_tree 42ms/g)||[]).length,1,'duplicate terminal result must print once');
+    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.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.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/);
-    assert.doesNotMatch(output.stdout,/abcdef12|fedcba98/);
+    assert.match(output.stdout,/abcdef12/);
+    assert.match(output.stdout,/fedcba98/);
     assert.doesNotMatch(output.stdout,/DO_NOT_PRINT_PAYLOAD|DO_NOT_PRINT_TOKEN/);
-    assert.doesNotMatch(output.stdout,/BRIDGE\.STDOUT/);
+    assert.match(output.stdout,/\[BRIDGE\.STDOUT\] IN  coding_tree/);
+    assert.match(output.stdout,/\[BRIDGE\.STDOUT\] OUT coding_tree/);
+    assert.match(output.stdout,/\[BRIDGE\.STDOUT\] ERR coding_file_read/);
     assert.doesNotMatch(output.stdout,/\[TOOL IN \]|\[TOOL OUT\]/);
     assert.doesNotMatch(output.stdout,/payload bytes=/);
     child.stdin.end();
@@ -132,7 +135,7 @@ winTest('bare remote uses compact human logs by default, keeps authority semanti
     const commands=await traceCommands(fx.trace);
     assert.deepEqual(commands.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
     assert.match(output.stdout,/^DEADBYTE MCP$/m);
-    assert.match(output.stdout,/Live activity/i);
+    assert.match(output.stdout,/Unified live timeline/i);
     assert.match(output.stdout,/🔐 \[AUTH\] Revoking session authority/);
     assert.doesNotMatch(output.stdout,/disarmautonomous OK|disarmcoding OK|disarmprocess OK|disarmhost OK|DEADBYTE MCP = PARKED/);
     const withoutApprovedEmoji=output.stdout.replace(/[📜📥📤✅❌⚠♻🛡▶🔐🚀🔌]/gu,'');
@@ -151,17 +154,17 @@ winTest('remote --resume replays only terminal results after the cursor before s
     const firstOutput=await collect(first);
     await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
     const liveDeadline=Date.now()+3000;
-    while(Date.now()<liveDeadline&&!/\[LOG\] Live activity/.test(firstOutput.stdout)) await sleep(50);
+    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');
     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}:1\]/.test(firstOutput.stdout)) await sleep(50);
+    const cursor1=firstOutput.stdout.match(/coding_tree .*\[cursor (r1:[0-9a-f]{24}:1)\]/)?.[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'});
     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}:2\]/.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);
@@ -170,12 +173,12 @@ winTest('remote --resume replays only terminal results after the cursor before s
     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)||
-      !/\[LOG\] Live activity/.test(secondOutput.stdout))) await sleep(50);
+      !/\[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,/♻️ \[SESSION\] Previous result stream replayed/);
     assert.doesNotMatch(secondOutput.stdout,/\[REPLAY\] \[OK\] coding_tree/);
     const replayIndex=secondOutput.stdout.indexOf('[REPLAY]');
-    const liveIndex=secondOutput.stdout.indexOf('[LOG] Live activity');
+    const liveIndex=secondOutput.stdout.indexOf('[LOG] Unified live timeline');
     assert.ok(replayIndex>=0&&liveIndex>replayIndex,'resume replay must happen before new live tail');
     second.stdin.end();
     const secondEnded=await Promise.race([secondOutput.closed,sleep(6000).then(()=>({timeout:true}))]);
@@ -187,43 +190,17 @@ winTest('remote --resume replays only terminal results after the cursor before s
   }
 });
 
-winTest('remote --verbose preserves detailed audit and bridge log streaming for debugging',async()=>{
+winTest('remote --verbose is rejected because R37 has one unified remote mode',async()=>{
   const fx=await fixture();
-  let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote','--verbose'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const child=spawn(process.execPath,[cliPath,'remote','--verbose'],{env:fx.env,stdio:['ignore','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.equal(ready.length>=8,true);
-    const liveDeadline=Date.now()+3000;
-    while(Date.now()<liveDeadline&&!/Live logs active/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/Live logs active/);
-    const auditDir=path.join(fx.state,'audit');
-    const runtimeLogs=path.join(fx.state,'runtime','logs');
-    await mkdir(auditDir,{recursive:true});
-    await mkdir(runtimeLogs,{recursive:true});
-    await writeFile(path.join(auditDir,'segment-00000001.jsonl'),[
-      JSON.stringify({seq:1,event_type:'tool.request',tool:'coding_tree',request_id:'abcdef1234567890'}),
-      JSON.stringify({seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false}})
-    ].join('\n')+'\n','utf8');
-    await writeFile(path.join(runtimeLogs,'bridge.stdout.log'),[
-      '[TOOL IN ] 2026-09-16T00:00:00.000Z #000001 coding_tree {}',
-      '[TOOL OUT] 2026-09-16T00:00:00.001Z #000001 coding_tree {"is_error":false}'
-    ].join('\n')+'\n','utf8');
-    const deadline=Date.now()+3000;
-    while(Date.now()<deadline&&(!/\[AUDIT #2\] tool\.result coding_tree abcdef12/.test(output.stdout)||!/\[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_tree/.test(output.stdout))) await sleep(50);
-    assert.match(output.stdout,/\[AUDIT #1\] tool\.request coding_tree abcdef12/);
-    assert.match(output.stdout,/\[AUDIT #2\] tool\.result coding_tree abcdef12/);
-    assert.match(output.stdout,/\[BRIDGE\.STDOUT\] \[TOOL IN \].*coding_tree/);
-    assert.match(output.stdout,/\[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_tree/);
-    child.stdin.end();
     const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
-    assert.equal(ended.timeout,undefined,'verbose remote session did not exit after input closed');
-    assert.equal(ended.code,0,output.stderr);
-  }finally{
-    if(child?.exitCode===null) child.kill();
-    await rm(fx.dir,{recursive:true,force:true});
-  }
+    assert.equal(ended.timeout,undefined);
+    assert.notEqual(ended.code,0);
+    assert.match(output.stderr,/unsupported remote command '--verbose'/i);
+    assert.deepEqual(await traceCommands(fx.trace),[],'rejected legacy flag must not touch runtime authority');
+  }finally{await rm(fx.dir,{recursive:true,force:true});}
 });
 
 winTest('detached guardian revokes authority, parks, and removes the session marker after the owner is hard-killed',async()=>{