deadbyte-mcp 0.9.0 → 0.10.0

package/test/r36-finalization.test.mjs

@@ -0,0 +1,104 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence, R35_PREDECESSOR_RELEASE_ID, R35_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.r36-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:`v0.10.0-${manifest.slice(0,16)}`,version:'0.10.0',manifest_sha256:manifest},
+    immutable_slot:{protected:true,release_root:'C:/immutable/r36',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:R35_PREDECESSOR_RELEASE_ID,version:'0.9.0',manifest_sha256:R35_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:73},
+    successor:{release_id:`v0.10.0-${manifest.slice(0,16)}`,version:'0.10.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('R36 parity validator requires full-76, compact closure, exact R35 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('R36 compact disarmed probe carries signed machine status/ping evidence into closure',async()=>{
+  const probe=await text('src/r36-compact-disarmed-probe.mjs');
+  assert.match(probe,/op:'machine_ping'/);
+  assert.match(probe,/machine_status/);
+  assert.match(probe,/machine_ping/);
+  assert.match(probe,/nonce/);
+});
+
+test('R36 parity captures exact successor bridge before rollback and reuses it for restore',async()=>{
+  const parity=await text('scripts/release-parity.mjs');
+  assert.match(parity,/loadPowerShellDataFile/);
+  assert.match(parity,/successorBridge/);
+  assert.match(parity,/Bridge\?\.WorkingDirectory/);
+  assert.match(parity,/Bridge\?\.ScriptSha256/);
+  assert.match(parity,/const stageRestore=await restoreFrozenStage\(\{developmentRoot,releaseRoot:active\.release_root,expectedManifestSha256:candidateManifest\}\)/);
+  assert.match(parity,/scheduleDeferred\('activate',candidateManifest,\{bridgeRoot:successorBridge\.root,bridgeScriptSha256:successorBridge\.sha256\}\)/);
+});
+
+test('R36 compact parity uses bounded release-parity tests instead of the full npm suite',async()=>{
+  const parity=await text('src/remote-mcp-r36-parity-client.mjs');
+  assert.match(parity,/const testScript='scripts\/release-parity-tests\.ps1'/);
+  assert.doesNotMatch(parity,/const testScript='scripts\/autonomous-tests\.ps1'/);
+  const script=await text('scripts/release-parity-tests.ps1');
+  assert.match(script,/r36-finalization\.test\.mjs/);
+  assert.match(script,/r36-release-identity\.test\.mjs/);
+  assert.match(script,/deferred-slot-operation\.test\.mjs/);
+});
+
+test('R36 compact parity treats stale machine-fs precondition denial as expected evidence',async()=>{
+  const parity=await text('src/remote-mcp-r36-parity-client.mjs');
+  assert.match(parity,/const staleValue=stale\.structuredContent/);
+  assert.match(parity,/stale\.isError!==true\|\|staleValue\.status!=='denied'/);
+  assert.doesNotMatch(parity,/structured\(stale,'machine_fs stale'\)/);
+});
+
+test('R36 final closure writer binds compact public evidence and R36 release evidence domains',async()=>{
+  const writer=await text('scripts/final-closure.mjs');
+  assert.match(writer,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(writer,/deadbyte\.r36-final-closure\.v1/);
+  assert.match(writer,/pointer\.version==='0\.10\.0'/);
+  assert.match(writer,/release_label:'R36 FINAL MACHINE BASELINE'/);
+  assert.match(writer,/deadbyte\.r36-parity\.v1/);
+  assert.match(writer,/deadbyte\.r36-windows-gate\.v1/);
+  assert.match(writer,/tool_count.*76|local_full[\s\S]*76/);
+  assert.match(writer,/capability_closure/);
+  assert.match(writer,/R35_PREDECESSOR_RELEASE_ID|v0\.9\.0-b95e1ec1d9a7e26a/);
+  assert.match(writer,/development_root/);
+});
+
+test('R36 independent closure verifier binds full, compact, predecessor, restore, Windows gate and immutable slot',async()=>{
+  const verifier=await text('scripts/final-closure-verify.mjs');
+  assert.equal(typeof verifyFinalClosureObject,'function');
+  assert.doesNotMatch(verifier,/from ['"]\.\.\/src\//);
+  assert.match(verifier,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(verifier,/deadbyte\.r36-final-closure\.v1/);
+  assert.match(verifier,/envelope\.body\.version==='0\.10\.0'/);
+  assert.match(verifier,/R36 FINAL MACHINE BASELINE/);
+  assert.match(verifier,/deadbyte\.r36-parity\.v1/);
+  assert.match(verifier,/deadbyte\.r36-windows-gate\.v1/);
+  assert.match(verifier,/76/);
+  assert.match(verifier,/42/);
+  assert.match(verifier,/b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d/);
+  assert.match(verifier,/development_root/);
+  assert.match(verifier,/release_root/);
+  assert.match(verifier,/successor_disarmed/);
+});

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

@@ -0,0 +1,52 @@
+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');
+const R35_RELEASE_ID='v0.9.0-b95e1ec1d9a7e26a';
+const R35_MANIFEST='b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d';
+
+test('R36 current release authority is consistently 0.10.0 / R36 and preserves exact R35 predecessor',async()=>{
+  const pkg=JSON.parse(await text('package.json'));
+  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate]=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')
+  ]);
+  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(deferred,/--expected-version','0\.10\.0'/);
+  assert.match(parity,/deadbyte\.r36-parity\.v1/);
+  assert.match(parity,new RegExp(R35_RELEASE_ID.replaceAll('.','\\.')));
+  assert.match(parity,new RegExp(R35_MANIFEST));
+  assert.match(closure,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(closure,/version:'0\.10\.0'/);
+  assert.match(closure,/release_label:'R36 FINAL MACHINE BASELINE'/);
+  assert.match(closureVerify,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
+  assert.match(closureVerify,/version==='0\.10\.0'/);
+  assert.match(windowsGate,/schema:'deadbyte\.r36-windows-gate\.v1'/);
+});
+
+test('R36 controller binds production remote to compact profile and restores parent environment',async()=>{
+  const controller=await text('controller/deadbyte-controller.ps1');
+  assert.match(controller,/Test-Path Env:DEADBYTE_CAPABILITY_PROFILE/);
+  assert.match(controller,/\$previousCapabilityProfileEnv = \$env:DEADBYTE_CAPABILITY_PROFILE/);
+  assert.match(controller,/\$env:DEADBYTE_CAPABILITY_PROFILE = 'compact'/);
+  assert.match(controller,/Remove-Item Env:DEADBYTE_CAPABILITY_PROFILE/);
+  assert.match(controller,/\$env:DEADBYTE_CAPABILITY_PROFILE = \$previousCapabilityProfileEnv/);
+});
+
+test('R36 parity source defines exact full 76-tool authority plus compact gateway closure',async()=>{
+  const parity=await text('src/remote-mcp-r36-parity-client.mjs');
+  assert.match(parity,/R36_EXPECTED_TOOLS/);
+  assert.match(parity,/R36_EXPECTED_TOOLS\.length !== 76|tool_count !== 76|length === 76/);
+  for(const name of ['capability_manifest','coding_inspect','machine_fs','process_session','machine_observe']) assert.match(parity,new RegExp(name));
+  assert.match(parity,/42/);
+});

package/test/release-version.test.mjs

@@ -6,7 +6,7 @@ import { createHash } from 'node:crypto';
 const root = new URL('../', import.meta.url);
 const text = rel => readFile(new URL(rel, root), 'utf8');
 
-test('R35 successor release authority agrees on V0.9.0 / R35 identity', async () => {
+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'),
@@ -16,25 +16,28 @@ test('R35 successor release authority agrees on V0.9.0 / R35 identity', async ()
     text('docs/ARCHITECTURE.md'),
     text('controller/README.TXT'),
     text('scripts/deferred-slot-operation.mjs'),
-    text('src/remote-mcp-r34-parity-client.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'),
     text('controller/deadbyte-semantic-lsp-config.json')
   ]);
-  assert.equal(pkg.version, '0.9.0');
-  assert.match(version, /DEADBYTE_VERSION = '0\.9\.0'/);
-  assert.match(controller, /CONTROLLER V0\.9\.0 \/ R35/);
-  assert.match(gate, /DEADBYTE V0\.9\.0 \/ R35 WINDOWS BATCH GATE: PASS/);
-  assert.match(readme, /^DEADBYTE MCP V0\.9\.0 \/ R35 PRODUCTION BASELINE$/m);
-  assert.match(architecture, /^# DEADBYTE MCP V0\.9\.0 \/ R35 ARCHITECTURE$/m);
-  assert.match(controllerReadme, /^DEADBYTE MCP V0\.9\.0 \/ R35 CONTROLLER$/m);
-  assert.match(controllerReadme, /73-tool public catalog/);
-  assert.match(deferred, /--expected-version','0\.9\.0'/);
-  assert.match(parity, /version:'0\.9\.0'/);
-  assert.match(closure, /version:'0\.9\.0'/);
-  assert.match(closureVerify, /DEADBYTE V0\.9\.0 \/ R35 WINDOWS BATCH GATE: PASS/);
-  assert.match(windowsGate, /schema:'deadbyte\.r35-windows-gate\.v1'/);
+  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/);

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

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { formatCompactAuditEvent } from '../src/remote-live-log.mjs';
+
+test('compact live activity shows request context without payload or secret values',()=>{
+  const line=formatCompactAuditEvent({
+    event_type:'tool.request',
+    tool:'coding_file_read',
+    request_id:'abcdef1234567890',
+    args:{
+      root_id:'projects',
+      path:'src/deadbyte-cli.mjs',
+      content:'DO_NOT_PRINT_PAYLOAD',
+      token:'DO_NOT_PRINT_TOKEN'
+    }
+  });
+  assert.equal(line,'▶ RUN coding_file_read root=projects path=src/deadbyte-cli.mjs');
+  assert.doesNotMatch(line,/DO_NOT_PRINT_PAYLOAD|DO_NOT_PRINT_TOKEN|abcdef1234567890/);
+});
+
+test('compact live activity shows successful result duration',()=>{
+  assert.equal(formatCompactAuditEvent({
+    event_type:'tool.result',tool:'coding_search',request_id:'r1',
+    outcome:{is_error:false,duration_ms:42}
+  }),'✅ OK coding_search 42ms');
+});
+
+test('compact live activity shows failed result duration',()=>{
+  assert.equal(formatCompactAuditEvent({
+    event_type:'tool.result',tool:'coding_command_run',request_id:'r2',
+    outcome:{is_error:true,duration_ms:1734}
+  }),'❌ ERR coding_command_run 1.73s');
+});
+
+test('compact live activity ignores unrelated audit events',()=>{
+  assert.equal(formatCompactAuditEvent({event_type:'checkpoint',tool:'coding_tree'}),null);
+});

package/test/remote-live-log-recovery-r36.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createLiveActivityTracker, formatRemoteLifecycle } from '../src/remote-live-log.mjs';
+
+test('R36 lifecycle formatter exposes device/connect/ready/cleanup states with bounded semantic emoji',()=>{
+  assert.equal(formatRemoteLifecycle('device_start'),'🚀 [DEVICE] Starting DEADBYTE MCP...');
+  assert.equal(formatRemoteLifecycle('bridge_connected'),'🔌 [BRIDGE] Local bridge connected');
+  assert.equal(formatRemoteLifecycle('cloud_connected'),'🔌 [CLOUD] Remote MCP connected');
+  assert.equal(formatRemoteLifecycle('session_new'),'[SESSION] New foreground session');
+  assert.equal(formatRemoteLifecycle('session_restored'),'♻️ [SESSION] Previous result stream replayed');
+  assert.equal(formatRemoteLifecycle('ready'),'✅ [READY] DEADBYTE MCP online');
+  assert.equal(formatRemoteLifecycle('cleanup'),'🔐 [AUTH] Revoking session authority...');
+  assert.throws(()=>formatRemoteLifecycle('invented'),/unknown remote lifecycle/i);
+});
+
+test('R36 live activity tracker prints RUN before terminal result and reconciles interrupted requests',()=>{
+  const tracker=createLiveActivityTracker();
+  const run=tracker.observe({event_type:'tool.request',tool:'coding_search',request_id:'request-1',args:{root_id:'projects',path:'src',pattern:'needle',token:'DO_NOT_PRINT'}});
+  assert.equal(run,'▶ RUN coding_search root=projects path=src pattern=needle');
+  assert.deepEqual(tracker.pending(),[{request_id:'request-1',tool:'coding_search'}]);
+  const ok=tracker.observe({event_type:'tool.result',tool:'coding_search',request_id:'request-1',outcome:{is_error:false,duration_ms:84}});
+  assert.equal(ok,'✅ OK coding_search 84ms');
+  assert.deepEqual(tracker.pending(),[]);
+
+  tracker.observe({event_type:'tool.request',tool:'coding_command_run',request_id:'request-2',args:{command_id:'node_script',content:'DO_NOT_PRINT_PAYLOAD'}});
+  tracker.observe({event_type:'tool.request',tool:'coding_file_read',request_id:'request-3',args:{path:'src/a.mjs',private_key:'DO_NOT_PRINT_KEY'}});
+  const interrupted=tracker.reconcileInterrupted('session_end');
+  assert.deepEqual(interrupted,[
+    '⚠️ INTERRUPTED coding_command_run — session ended before result',
+    '⚠️ INTERRUPTED coding_file_read — session ended before result'
+  ]);
+  assert.deepEqual(tracker.pending(),[]);
+  assert.doesNotMatch(interrupted.join('\n'),/DO_NOT_PRINT|request-2|request-3/);
+});
+
+test('R36 live activity tracker tolerates terminal result whose request was before the tail baseline',()=>{
+  const tracker=createLiveActivityTracker();
+  const line=tracker.observe({event_type:'tool.result',tool:'coding_tree',request_id:'old-request',outcome:{is_error:false,duration_ms:15}});
+  assert.equal(line,'✅ OK coding_tree 15ms');
+  assert.deepEqual(tracker.pending(),[]);
+});

package/test/remote-r24-catalog.test.mjs

@@ -66,6 +66,19 @@ test('R32 remote gate accepts observation only with machine plus coding configur
   assert.match(source, /observation_runtime: observationRuntime/);
 });
 
+test('R36 remote smoke accepts only the exact compact production catalog and uses read-only gateway proof', async () => {
+  const source = await readFile(sourcePath, 'utf8');
+  assert.match(source, /const r36CompactTools = \[/);
+  assert.match(source, /r36CompactTools\.length !== 41/);
+  assert.match(source, /const compactProfile = JSON\.stringify\(names\) === JSON\.stringify\(r36CompactTools\)/);
+  assert.match(source, /capability_manifest/);
+  assert.match(source, /machine_observe/);
+  assert.match(source, /op: 'machine_status'/);
+  assert.match(source, /op: 'machine_ping'/);
+  assert.match(source, /if \(compactProfile\) \{[\s\S]*?\} else \{[\s\S]*?workspace_open/);
+  assert.doesNotMatch(source, /r36CompactTools\.includes\(name\).*extras/s);
+});
+
 test('R34 disarmed public gate requires the exact canonical 73-tool catalog', async () => {
   const disarmedPath = fileURLToPath(new URL('../src/remote-mcp-r24-disarmed-smoke-client.mjs', import.meta.url));
   const source = await readFile(disarmedPath, 'utf8');

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

@@ -18,7 +18,7 @@ async function fixture({failCommand=''}={}){
   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    : ARMED [standing-grant]' }\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  '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}};
 }
@@ -71,17 +71,23 @@ winTest('bare remote uses compact human logs by default, keeps authority semanti
   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,9).join(',')==='start,armprocess,armcoding,armautonomous,armhost,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,9),[
-      'start','armprocess','armcoding','armautonomous','armhost',
+    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',
       'processstatus','codingstatus','autonomousstatus','hoststatus'
     ]);
     assert.equal(child.exitCode,null,'remote session must remain foreground after becoming ready');
     const tailDeadline=Date.now()+3000;
-    while(Date.now()<tailDeadline&&!/\[LOG\] Live tool results/.test(output.stdout)) await sleep(50);
+    while(Date.now()<tailDeadline&&!/🔐 \[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/🚀 \[DEVICE\] Starting DEADBYTE MCP/);
+    assert.match(output.stdout,/🔌 \[BRIDGE\] Local bridge connected/);
+    assert.match(output.stdout,/🔌 \[CLOUD\] Remote MCP connected/);
+    assert.match(output.stdout,/\[SESSION\] New foreground session/);
+    assert.match(output.stdout,/\[BOOT\] Starting local \+ remote runtime/);
     assert.match(output.stdout,/\[OK\] ONLINE/);
-    assert.match(output.stdout,/\[OK\] Authority ARMED: process, coding, autonomous, host/);
-    assert.match(output.stdout,/\[LOG\] Live tool results\. Ctrl\+C disconnects and revokes authority\./);
+    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.doesNotMatch(output.stdout,/Process plane\s*:/);
     assert.doesNotMatch(output.stdout,/Coding plane\s*:/);
     const auditDir=path.join(fx.state,'audit');
@@ -91,11 +97,11 @@ winTest('bare remote uses compact human logs by default, keeps authority semanti
     const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
     assert.match(String(marker.result_session_id||''),/^[0-9a-f]{24}$/);
     const auditEvents=[
-      {seq:1,event_type:'tool.request',tool:'coding_tree',request_id:'abcdef1234567890'},
-      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false}},
-      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false}},
-      {seq:3,event_type:'tool.request',tool:'coding_file_read',request_id:'fedcba9876543210'},
-      {seq:4,event_type:'tool.result',tool:'coding_file_read',request_id:'fedcba9876543210',outcome:{is_error:true}}
+      {seq:1,event_type:'tool.request',tool:'coding_tree',request_id:'abcdef1234567890',args:{root_id:'projects',path:'src',content:'DO_NOT_PRINT_PAYLOAD',token:'DO_NOT_PRINT_TOKEN'}},
+      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false,duration_ms:42}},
+      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false,duration_ms:42}},
+      {seq:3,event_type:'tool.request',tool:'coding_file_read',request_id:'fedcba9876543210',args:{root_id:'projects',path:'src/deadbyte-cli.mjs'}},
+      {seq:4,event_type:'tool.result',tool:'coding_file_read',request_id:'fedcba9876543210',outcome:{is_error:true,duration_ms:1734}}
     ];
     await writeFile(path.join(auditDir,'segment-00000001.jsonl'),`${auditEvents.map(event=>JSON.stringify(event)).join('\n')}\n`,'utf8');
     await writeFile(path.join(runtimeLogs,'bridge.stdout.log'),[
@@ -104,17 +110,19 @@ 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/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/\[OK\] coding_tree \[cursor r1:[0-9a-f]{24}:1\]/);
-    assert.match(output.stdout,/\[ERR\] coding_file_read \[cursor r1:[0-9a-f]{24}:2\]/);
-    assert.equal((output.stdout.match(/\[OK\] coding_tree/g)||[]).length,1,'duplicate terminal result must print once');
+    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');
     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.doesNotMatch(output.stdout,/tool\.request/);
+    assert.doesNotMatch(output.stdout,/DO_NOT_PRINT_PAYLOAD|DO_NOT_PRINT_TOKEN/);
     assert.doesNotMatch(output.stdout,/BRIDGE\.STDOUT/);
     assert.doesNotMatch(output.stdout,/\[TOOL IN \]|\[TOOL OUT\]/);
     assert.doesNotMatch(output.stdout,/payload bytes=/);
@@ -124,9 +132,10 @@ 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 tool results/i);
+    assert.match(output.stdout,/Live activity/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,'');
+    const withoutApprovedEmoji=output.stdout.replace(/[📜📥📤✅❌⚠♻🛡▶🔐🚀🔌]/gu,'');
     assert.doesNotMatch(withoutApprovedEmoji,/\p{Extended_Pictographic}/u,'human live stream may use only the approved semantic emoji set');
   }finally{
     if(child?.exitCode===null) child.kill();
@@ -142,7 +151,7 @@ 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 tool results/.test(firstOutput.stdout)) await sleep(50);
+    while(Date.now()<liveDeadline&&!/\[LOG\] Live activity/.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');
@@ -161,11 +170,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 tool results/.test(secondOutput.stdout))) await sleep(50);
+      !/\[LOG\] Live activity/.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 tool results');
+    const liveIndex=secondOutput.stdout.indexOf('[LOG] Live activity');
     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}))]);
@@ -183,8 +193,8 @@ winTest('remote --verbose preserves detailed audit and bridge log streaming for
   try{
     child=spawn(process.execPath,[cliPath,'remote','--verbose'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ready=await waitFor(fx.trace,commands=>commands.slice(0,9).join(',')==='start,armprocess,armcoding,armautonomous,armhost,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.equal(ready.length>=9,true);
+    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/);
@@ -201,7 +211,7 @@ winTest('remote --verbose preserves detailed audit and bridge log streaming for
       '[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&&!/\[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_tree/.test(output.stdout)) await sleep(50);
+    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/);
@@ -222,9 +232,9 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
   try{
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ready=await waitFor(fx.trace,commands=>commands.slice(0,9).join(',')==='start,armprocess,armcoding,armautonomous,armhost,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,9),[
-      'start','armprocess','armcoding','armautonomous','armhost',
+    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',
       'processstatus','codingstatus','autonomousstatus','hoststatus'
     ]);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
@@ -259,7 +269,7 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
 });
 
 winTest('bare remote rolls back authority and parks if one plane fails to arm',async()=>{
-  const fx=await fixture({failCommand:'armhost'});
+  const fx=await fixture({failCommand:'armcoding'});
   try{
     const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
@@ -267,7 +277,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,5),['start','armprocess','armcoding','armautonomous','armhost']);
+    assert.deepEqual(commands.slice(0,3),['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});}

package/test/runtime-self-update.test.mjs

@@ -10,6 +10,7 @@ import {
   loadPowerShellDataFile,
   parseUpdateArgs,
   prepareNamedTunnelCloudSpec,
+  readControllerStartFailure,
   runControllerStartNoCapture
 } from '../scripts/runtime-self-update.mjs';
 import * as runtimeUpdate from '../scripts/runtime-self-update.mjs';
@@ -31,10 +32,12 @@ test('R32 updater loads controller data with Windows PowerShell modules isolated
   }
 });
 
-test('R32 updater applies the isolated Windows PowerShell environment to detached controller starts', async () => {
+test('R36 updater keeps detached start semantics and binds controller sidecar diagnostics', async () => {
   const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
   assert.match(source,/stdio:'ignore'/);
   assert.match(source,/env:commandEnvironment\(exe,env\?\?process\.env\)/);
+  assert.match(source,/readControllerStartFailure\(ctx\)/);
+  assert.match(source,/evidence_sha256/);
   assert.match(source,/for\(let attempt=1;attempt<=3;attempt\+=1\)/);
 });
 
@@ -74,6 +77,60 @@ test('R27 controller start transport returns while its long-lived descendant is
   assert.doesNotThrow(()=>process.kill(childPid,0),'controller start returned only after descendant exited');
 });
 
+test('R36 controller start sidecar is schema-bound and hash-bound', async () => {
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-start-evidence-'));
+  const controllerDir=path.join(base,'controller');
+  const runtime=path.join(controllerDir,'runtime');
+  await mkdir(runtime,{recursive:true});
+  await writeFile(path.join(controllerDir,'deadbyte-controller.ps1'),"param([string]$Command)\nexit 0\n");
+  const body={
+    schema:'deadbyte.controller-start-failure.v1',
+    command:'start',
+    failed_at_utc:'2026-09-18T00:00:00.000Z',
+    message:'R36_CONTROLLER_START_SENTINEL',
+    bridge_stdout_tail:'',
+    bridge_stderr_tail:'compact bridge failed',
+    cloud_stdout_tail:'',
+    cloud_stderr_tail:''
+  };
+  const bytes=Buffer.from(JSON.stringify(body),'utf8');
+  await writeFile(path.join(runtime,'controller-start-failure.json'),bytes);
+  const evidence=await readControllerStartFailure(legacyContext(base));
+  assert.equal(evidence.message,'R36_CONTROLLER_START_SENTINEL');
+  assert.equal(evidence.command,'start');
+  assert.equal(evidence.sha256,sha(bytes));
+});
+
+test('R36 updater preserves exact controller-start failure evidence before rollback', async () => {
+  assert.equal(typeof runtimeUpdate.preserveControllerStartFailure,'function');
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-preserve-start-evidence-'));
+  const controllerDir=path.join(base,'controller');
+  const runtime=path.join(controllerDir,'runtime');
+  const evidenceDir=path.join(base,'evidence','updates','candidate');
+  await mkdir(runtime,{recursive:true});
+  await writeFile(path.join(controllerDir,'deadbyte-controller.ps1'),"param([string]$Command)\nexit 0\n");
+  const body={
+    schema:'deadbyte.controller-start-failure.v1',
+    command:'start',
+    failed_at_utc:'2026-09-18T00:00:00.000Z',
+    message:'R36_PRESERVE_SENTINEL',
+    bridge_stdout_tail:'bridge-out',
+    bridge_stderr_tail:'bridge-err',
+    cloud_stdout_tail:'',
+    cloud_stderr_tail:''
+  };
+  const bytes=Buffer.from(JSON.stringify(body),'utf8');
+  const source=path.join(runtime,'controller-start-failure.json');
+  await writeFile(source,bytes);
+  const preserved=await runtimeUpdate.preserveControllerStartFailure(legacyContext(base),evidenceDir);
+  assert.equal(preserved.sha256,sha(bytes));
+  assert.equal(preserved.message,'R36_PRESERVE_SENTINEL');
+  assert.equal(preserved.path,path.join(evidenceDir,'controller-start-failure.json'));
+  assert.deepEqual(await readFile(preserved.path),bytes);
+  await writeFile(source,Buffer.from('destroyed-after-snapshot','utf8'));
+  assert.deepEqual(await readFile(preserved.path),bytes,'rollback/runtime restart must not mutate preserved evidence');
+});
+
 test('R28 slot-update CLI binds direct cloudflared plus external token file as one pinned contract', () => {
   const base=['--stage','stage','--development-root','dev','--expected-version','0.8.4','--expected-manifest',hex('a')];
   assert.throws(() => parseUpdateArgs([...base,'--cloud-cloudflared','C:/cloudflared.exe']), /named tunnel bootstrap requires all|cloud/i);

package/test/semantic-lsp-backend.test.mjs

@@ -43,6 +43,15 @@ test('semantic LSP backend normalizes outline definition references diagnostics
     assert.equal(refs.locations[0].path,'main.foo');
     const diagnostics=await f.backend.diagnostics({rootId:'project',relativePath:'main.foo',maxResults:10});
     assert.equal(diagnostics.diagnostics[0].message,'fixture diagnostic');
+    assert.match(diagnostics.file_sha256,/^[0-9a-f]{64}$/); assert.match(diagnostics.result_sha256,/^[0-9a-f]{64}$/);
+    const implementations=await f.backend.implementations({rootId:'project',relativePath:'main.foo',line:0,column:18,maxResults:10});
+    assert.equal(implementations.status,'ok'); assert.equal(implementations.locations[0].path,'main.foo'); assert.match(implementations.result_sha256,/^[0-9a-f]{64}$/);
+    const unsupportedImpl=await f.backend.implementations({rootId:'project',relativePath:'main.foo',line:0,column:999,maxResults:10});
+    assert.equal(unsupportedImpl.status,'unsupported'); assert.equal(unsupportedImpl.capability,'implementations');
+    const rename=await f.backend.renameEdits({rootId:'project',relativePath:'main.foo',line:0,column:18,newName:'gamma'});
+    assert.equal(rename.status,'ok'); assert.deepEqual(rename.edits,[{path:'main.foo',start:16,length:5,new_text:'gamma'}]);
+    const unsupportedRename=await f.backend.renameEdits({rootId:'project',relativePath:'main.foo',line:0,column:18,newName:'UNSUPPORTED'});
+    assert.equal(unsupportedRename.status,'unsupported'); assert.equal(unsupportedRename.capability,'rename_preview');
     const before=await f.codingRuntime.fileRead({rootId:'project',relativePath:'main.foo'});
     const edited=await f.backend.replaceSymbol({rootId:'project',relativePath:'main.foo',symbolId:symbol.symbol_id,newBody:'export function beta() {}',expectedSha256:before.sha256});
     assert.equal(edited.status,'committed');assert.equal(edited.symbol_name,'alpha');assert.equal(edited.engine,'fixture-lsp');