deadbyte-mcp 0.8.10 → 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-generation.test.mjs

@@ -19,7 +19,11 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   await mkdir(path.join(release,'scripts'),{recursive:true}); await mkdir(path.join(release,'bin'),{recursive:true}); await mkdir(workspace,{recursive:true});
   await writeFile(path.join(release,'scripts','gate.ps1'),'Write-Output gate\n');
   await writeFile(path.join(release,'bin','deadbyte-process-host.exe'),'process-host-bytes\n');
-  const currentConfig={AgentRuntimeEnabled:true,ProcessRuntimeEnabled:true,CodingRuntimeEnabled:true,MachineFsRuntimeEnabled:true,ObservationRuntimeEnabled:true,AutonomousRuntimeEnabled:true,
+  const semanticConfigPath=path.join(base,'semantic-lsp.json');
+  const semanticConfigBytes=Buffer.from(JSON.stringify({schema:'deadbyte.semantic-lsp-config.v1',servers:[]})+'\n','utf8');
+  await writeFile(semanticConfigPath,semanticConfigBytes);
+  const currentConfig={AgentRuntimeEnabled:true,ProcessRuntimeEnabled:true,CodingRuntimeEnabled:true,MachineFsRuntimeEnabled:true,ObservationRuntimeEnabled:true,AutonomousRuntimeEnabled:true,AutonomousSupervisorEnabled:true,SemanticLspConfigFile:semanticConfigPath,SemanticLspConfigSha256:sha(semanticConfigBytes),
+    Supervisor:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'src\\autonomous-supervisor-host.mjs',WorkingDirectory:'C:/release',ScriptPath:'C:/release/src/autonomous-supervisor-host.mjs',ScriptSha256:'2'.repeat(64)},
     Bridge:{FilePath:'C:/node.exe',FileSha256:EXE,Arguments:'bridge.mjs',WorkingDirectory:'C:/bridge',ScriptPath:'C:/bridge/bridge.mjs',ScriptSha256:EXE},
     Cloud:{FilePath:'C:/deadbyte-tunnel-host.exe',FileSha256:EXE,Arguments:'"C:/cloudflared.exe" "C:/secret/tunnel-token.txt" "C:/bridge"',WorkingDirectory:'C:/release',Transport:'deadbyte.named-tunnel.v2',Dependencies:[
       {Name:'cloudflared',Path:'C:/cloudflared.exe',Sha256:EXE},{Name:'tunnel-token',Path:'C:/secret/tunnel-token.txt',Sha256:EXE}
@@ -38,7 +42,7 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const development=path.join(base,'development'); await mkdir(development,{recursive:true}); await mkdir(path.join(development,'scripts'),{recursive:true}); await writeFile(path.join(development,'scripts','gate.ps1'),'Write-Output gate\n');
   const result=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
   const verified=await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
-  assert.equal(verified.files,5);
+  assert.equal(verified.files,6);
   const generatedProcess=JSON.parse(await readFile(result.process_policy_path,'utf8'));
   assert.equal(generatedProcess.grant_file,path.join(path.resolve(state),'runtime','process-grant.json'));
   assert.equal(generatedProcess.state_dir,path.join(path.resolve(state),'evidence','process'));
@@ -62,8 +66,11 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.equal(generatedHost.roots.core.path,path.resolve(development));
   assert.notEqual(generatedHost.roots.core.path,path.resolve(release));
   assert.equal(generatedHost.arm_file,path.join(path.resolve(state),'runtime','host-grant.json'));
+  assert.equal(await readFile(result.semantic_config_path,'utf8'),semanticConfigBytes.toString('utf8'));
   const config=await readFile(result.config_path,'utf8');
   assert.match(config,new RegExp(`CoreRoot = '${release.replaceAll('\\','\\\\')}`));
+  assert.match(config,/SemanticLspConfigFile = '/);
+  assert.match(config,new RegExp(`SemanticLspConfigSha256 = '${sha(semanticConfigBytes)}'`));
   assert.doesNotMatch(config,/CoreRoot = ''/);
   assert.match(config,new RegExp(`WorkspaceRoot = '${workspace.replaceAll('\\','\\\\')}`));
   assert.match(config,/MachineRuntimeEnabled = \$true/);
@@ -74,6 +81,10 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.match(config,/ObservationRuntimeEnabled = \$true/);
   assert.match(config,/CodingPolicyFile = '/);
   assert.match(config,/AutonomousPolicyFile = '/);
+  assert.match(config,/AutonomousSupervisorEnabled = \$true/);
+  assert.match(config,/Supervisor = @\{/);
+  assert.match(config,/ScriptPath = 'C:\/release\/src\/autonomous-supervisor-host\.mjs'/);
+  assert.match(config,/ScriptSha256 = '2{64}'/);
   assert.match(config,/HostPolicyFile = '/);
   assert.match(config,/Transport = 'deadbyte\.named-tunnel\.v2'/);
   assert.match(config,/McpUrlFile = 'C:\/mcp-url\.txt'/);
@@ -107,10 +118,20 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   const sixth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:observationDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
   assert.notEqual(sixth.generation_root,result.generation_root);
   assert.notEqual(sixth.generation_seed_sha256,result.generation_seed_sha256);
+  const semanticConfig2Path=path.join(base,'semantic-lsp-v2.json');
+  const semanticConfig2Bytes=Buffer.from(JSON.stringify({schema:'deadbyte.semantic-lsp-config.v1',servers:[{id:'changed'}]})+'\n','utf8');
+  await writeFile(semanticConfig2Path,semanticConfig2Bytes);
+  const semanticChanged=structuredClone(currentConfig);
+  semanticChanged.SemanticLspConfigFile=semanticConfig2Path;
+  semanticChanged.SemanticLspConfigSha256=sha(semanticConfig2Bytes);
+  const seventh=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:semanticChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
+  assert.notEqual(seventh.generation_root,result.generation_root);
+  assert.notEqual(seventh.generation_seed_sha256,result.generation_seed_sha256);
   await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
   await verifyGenerationBundle(second.generation_root,second.generation_manifest_sha256);
   await verifyGenerationBundle(third.generation_root,third.generation_manifest_sha256);
   await verifyGenerationBundle(fourth.generation_root,fourth.generation_manifest_sha256);
   await verifyGenerationBundle(fifth.generation_root,fifth.generation_manifest_sha256);
   await verifyGenerationBundle(sixth.generation_root,sixth.generation_manifest_sha256);
+  await verifyGenerationBundle(seventh.generation_root,seventh.generation_manifest_sha256);
 });

package/test/release-version.test.mjs

@@ -1,14 +1,14 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
 
 const root = new URL('../', import.meta.url);
 const text = rel => readFile(new URL(rel, root), 'utf8');
 
-test('R33 patch successor release authority agrees on V0.8.10 / R33 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] = await Promise.all([
+  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'),
@@ -16,20 +16,30 @@ test('R33 patch successor release authority agrees on V0.8.10 / R33 identity', a
     text('docs/ARCHITECTURE.md'),
     text('controller/README.TXT'),
     text('scripts/deferred-slot-operation.mjs'),
-    text('src/remote-mcp-r33-parity-client.mjs'),
+    text('src/remote-mcp-r36-parity-client.mjs'),
     text('scripts/final-closure.mjs'),
-    text('scripts/final-closure-verify.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.8.10');
-  assert.match(version, /DEADBYTE_VERSION = '0\.8\.10'/);
-  assert.match(controller, /CONTROLLER V0\.8\.10 \/ R33/);
-  assert.match(gate, /DEADBYTE V0\.8\.10 \/ R33 WINDOWS BATCH GATE: PASS/);
-  assert.match(readme, /^DEADBYTE MCP V0\.8\.10 \/ R33 FINAL MACHINE BASELINE$/m);
-  assert.match(architecture, /^# DEADBYTE MCP V0\.8\.10 \/ R33 ARCHITECTURE$/m);
-  assert.match(controllerReadme, /^DEADBYTE MCP V0\.8\.10 \/ R33 CONTROLLER$/m);
-  assert.match(controllerReadme, /68-tool public catalog/);
-  assert.match(deferred, /--expected-version','0\.8\.10'/);
-  assert.match(parity, /version:'0\.8\.10'/);
-  assert.match(closure, /version:'0\.8\.10'/);
-  assert.match(closureVerify, /DEADBYTE V0\.8\.10 \/ R33 WINDOWS BATCH GATE: PASS/);
+  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/);
 });

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,10 +66,24 @@ test('R32 remote gate accepts observation only with machine plus coding configur
   assert.match(source, /observation_runtime: observationRuntime/);
 });
 
-test('R32 disarmed public gate requires the fully enabled 68-tool catalog', async () => {
+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');
-  assert.match(source, /listed\.tools\.length !== 68/);
-  assert.match(source, /tool_count:68/);
-  assert.doesNotMatch(source, /expected 61 tools/);
+  assert.match(source, /R34_EXPECTED_TOOLS/);
+  assert.match(source, /JSON\.stringify\(names\).*JSON\.stringify\(R34_EXPECTED_TOOLS\)/s);
+  assert.match(source, /tool_count:R34_EXPECTED_TOOLS\.length/);
+  assert.doesNotMatch(source, /listed\.tools\.length !== 68/);
 });

package/test/remote-result-journal.test.mjs

@@ -0,0 +1,58 @@
+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 { openRemoteResultJournal, parseRemoteResultCursor } from '../src/remote-result-journal.mjs';
+
+const H=c=>c.repeat(64);
+const session='a'.repeat(24);
+const item=(requestId,payload,status='ok')=>({request_id:requestId,tool:'coding_tree',status,
+  observed_at_utc:'2026-09-17T00:00:00.000Z',payload_sha256:payload});
+
+test('remote result journal is monotonic, restart-safe, and suppresses duplicate terminal results',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r35-remote-results-'));
+  const file=path.join(root,'journal.json');
+  try{
+    const first=await openRemoteResultJournal({filePath:file,sessionId:session,maxEntries:8});
+    const a=await first.recordTerminal(item('req-1',H('1')));
+    const duplicate=await first.recordTerminal(item('req-1',H('1')));
+    const b=await first.recordTerminal(item('req-2',H('2'),'error'));
+    assert.equal(a.event.seq,1);assert.equal(duplicate.duplicate,true);assert.equal(duplicate.event.seq,1);
+    assert.equal(b.event.seq,2);assert.equal(first.cursor(),'r1:'+session+':2');
+
+    const restarted=await openRemoteResultJournal({filePath:file,sessionId:session,maxEntries:8});
+    const c=await restarted.recordTerminal(item('req-3',H('3')));
+    assert.equal(c.event.seq,3);
+    const replay=await restarted.replayAfter('r1:'+session+':1',{limit:8});
+    assert.deepEqual(replay.events.map(event=>event.seq),[2,3]);
+    assert.equal(replay.next_cursor,'r1:'+session+':3');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('bounded retention rejects stale cursor and never stores raw payload bytes',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r35-remote-retention-'));
+  const file=path.join(root,'journal.json');
+  try{
+    const journal=await openRemoteResultJournal({filePath:file,sessionId:session,maxEntries:2});
+    await journal.recordTerminal(item('req-1',H('1')));
+    await journal.recordTerminal(item('req-2',H('2')));
+    await journal.recordTerminal(item('req-3',H('3')));
+    await assert.rejects(journal.replayAfter('r1:'+session+':0',{limit:8}),/cursor_outside_retention/);
+    const text=await readFile(file,'utf8');
+    assert.doesNotMatch(text,/stdout|stderr|payload\s*:/i);
+    const stored=JSON.parse(text);
+    assert.deepEqual(stored.events.map(event=>event.seq),[2,3]);
+    assert.equal(stored.next_seq,4);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('cursor parser rejects foreign sessions and malformed cursors',async()=>{
+  assert.deepEqual(parseRemoteResultCursor('r1:'+session+':42'),{session_id:session,seq:42});
+  assert.throws(()=>parseRemoteResultCursor('bad'),/cursor/i);
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r35-remote-cursor-'));
+  try{
+    const journal=await openRemoteResultJournal({filePath:path.join(root,'j.json'),sessionId:session,maxEntries:8});
+    await assert.rejects(journal.replayAfter('r1:'+'b'.repeat(24)+':0',{limit:8}),/cursor session mismatch/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});