deadbyte-mcp 0.11.2 → 0.12.0

package/test/r39-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, R39_PREDECESSOR_RELEASE_ID, R39_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r39.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r39.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.r39-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:`v0.11.3-${manifest.slice(0,16)}`,version:'0.11.3',manifest_sha256:manifest},
+    immutable_slot:{protected:true,release_root:'C:/immutable/r39',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:R39_PREDECESSOR_RELEASE_ID,version:'0.11.2',manifest_sha256:R39_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:41,capability_closure:true},
+    successor:{release_id:`v0.11.3-${manifest.slice(0,16)}`,version:'0.11.3',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('R39 parity validator requires full-76, compact closure, exact public 0.11.2 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('R39 parity captures R39 bridge, exact public 0.11.2 predecessor, stage reseed and successor restore',async()=>{
+  const parity=await text('scripts/release-parity-r39.mjs');
+  assert.match(parity,/R39_PREDECESSOR_RELEASE_ID='v0\.11\.2-058605dfccaa3035'/);
+  assert.match(parity,/058605dfccaa3035a57c6393d53f2421c14e5a92bd145c2334477ba24d7cab8b/);
+  assert.match(parity,/const stageRestore=await restoreFrozenStage/);
+  assert.match(parity,/publicR39Disarmed/);
+  assert.match(parity,/scheduleDeferred\('activate',candidateManifest,\{bridgeRoot:successorBridge\.root,bridgeScriptSha256:successorBridge\.sha256\}\)/);
+});
+
+test('R39 current final closure writer and independent verifier bind R39 domains and public 0.11.2 predecessor',async()=>{
+  const [writer,verifier]=await Promise.all([text('scripts/final-closure-r39.mjs'),text('scripts/final-closure-verify-r39.mjs')]);
+  assert.equal(typeof verifyFinalClosureObject,'function');
+  assert.match(writer,/DEADBYTE-R39-FINAL-CLOSURE-V1/);
+  assert.match(writer,/deadbyte\.r39-final-closure\.v1/);
+  assert.match(writer,/pointer\.version==='0\.11\.3'/);
+  assert.match(writer,/R39 FINAL MACHINE BASELINE/);
+  assert.match(writer,/deadbyte\.r39-parity\.v1/);
+  assert.match(writer,/deadbyte\.r39-windows-gate\.v1/);
+  assert.match(writer,/R39_PREDECESSOR_RELEASE_ID/);
+  assert.doesNotMatch(verifier,/from ['"]\.\.\/src\//);
+  assert.match(verifier,/DEADBYTE-R39-FINAL-CLOSURE-V1/);
+  assert.match(verifier,/deadbyte\.r39-final-closure\.v1/);
+  assert.match(verifier,/envelope\.body\.version==='0\.11\.3'/);
+  assert.match(verifier,/R39 FINAL MACHINE BASELINE/);
+  assert.match(verifier,/deadbyte\.r39-parity\.v1/);
+  assert.match(verifier,/deadbyte\.r39-windows-gate\.v1/);
+  assert.match(verifier,/058605dfccaa3035a57c6393d53f2421c14e5a92bd145c2334477ba24d7cab8b/);
+});
+
+test('R39 bounded public parity suite covers current release identity and agent fabric',async()=>{
+  const script=await text('scripts/release-parity-tests-r39.ps1');
+  assert.match(script,/r39-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/r40-finalization.test.mjs

@@ -0,0 +1,118 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence,R40_PREDECESSOR_RELEASE_ID,R40_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r40.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r40.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.r40-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:'v0.12.0-'+manifest.slice(0,16),version:'0.12.0',manifest_sha256:manifest},
+    immutable_slot:{protected:true,release_root:'C:/immutable/r40',development_root:'D:/Projects/deadbyte-mcp-r36-dev'},
+    local_full:{status:'passed',tool_count:80,strict_output_schemas:true},
+    public_compact:{status:'passed',tool_count:42,capability_closure:true,gateway_count:6,desktop_armed:false,
+      desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true},
+    autonomous:{status:'passed',signed_release_verified:true,observed_failure_before_replan:true},
+    desktop_guarded:{status:'passed',native_injected:true,replay_performed:false,predispatch_retry_count:0,observation_receipts_verified:1,action_receipts_verified:3},
+    before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},
+    rollback:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},restore:{state:'completed'},
+    predecessor:{release_id:R40_PREDECESSOR_RELEASE_ID,version:'0.11.3',manifest_sha256:R40_PREDECESSOR_MANIFEST},
+    predecessor_disarmed:{status:'passed',tool_count:41,capability_closure:true},
+    successor:{release_id:'v0.12.0-'+manifest.slice(0,16),version:'0.12.0',manifest_sha256:manifest},
+    successor_disarmed:{status:'passed',tool_count:42,capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},
+    requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy',
+      'interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input'].map(key=>[key,true]))
+  };
+}
+
+test('R40 parity validator requires full-80 compact-42 six gateways Desktop proof exact 0.11.3 predecessor and immutable separation',()=>{
+  const good=parityFixture();
+  assert.equal(validateParityEvidence(good),true);
+  assert.throws(()=>validateParityEvidence({...good,local_full:{...good.local_full,tool_count:79}}),/full 80/i);
+  assert.throws(()=>validateParityEvidence({...good,public_compact:{...good.public_compact,gateway_count:5}}),/compact/i);
+  assert.throws(()=>validateParityEvidence({...good,public_compact:{...good.public_compact,desktop_armed:true}}),/Desktop/i);
+  assert.throws(()=>validateParityEvidence({...good,desktop_guarded:{...good.desktop_guarded,replay_performed:true}}),/guarded Desktop/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);
+});
+
+test('R40 parity binds exact sealed 0.11.3 predecessor and separate Desktop authority smoke',async()=>{
+  const parity=await text('scripts/release-parity-r40.mjs');
+  assert.equal(R40_PREDECESSOR_RELEASE_ID,'v0.11.3-ce761dd6e014d42e');
+  assert.equal(R40_PREDECESSOR_MANIFEST,'ce761dd6e014d42eddb635855038e0ce049c63c6e3af7e63c3005bbe198bcf7b');
+  assert.match(parity,/probeR40FullSurface/);
+  assert.match(parity,/runR40CompactParity/);
+  assert.match(parity,/probeR36CompactDisarmed/);
+  assert.match(parity,/armdesktop/);
+  assert.match(parity,/disarmdesktop/);
+  assert.match(parity,/runR40DesktopGuardedSmoke/);
+  assert.match(parity,/desktop_guarded_input/);
+  assert.match(parity,/scheduleDeferred\('activate',candidateManifest,\{bridgeRoot:successorBridge\.root,bridgeScriptSha256:successorBridge\.sha256\}\)/);
+});
+
+test('R40 deferred activation binds pinned Desktop policy and enables runtime without an arm command',async()=>{
+  const source=await text('scripts/deferred-slot-operation-r40.mjs');
+  assert.match(source,/--expected-version','0\.12\.0'/);
+  assert.match(source,/--desktop-policy'/);
+  assert.match(source,/--desktop-policy-sha256'/);
+  assert.match(source,/--enable-desktop'/);
+  assert.doesNotMatch(source,/armdesktop/);
+});
+
+test('R40 final closure writer and independent verifier bind R40 domains Desktop disarm and exact predecessor',async()=>{
+  const [writer,verifier]=await Promise.all([text('scripts/final-closure-r40.mjs'),text('scripts/final-closure-verify-r40.mjs')]);
+  assert.equal(typeof verifyFinalClosureObject,'function');
+  for(const source of [writer,verifier]){
+    assert.match(source,/DEADBYTE-R40-FINAL-CLOSURE-V1/);
+    assert.match(source,/deadbyte\.r40-final-closure\.v1/);
+    assert.match(source,/0\.12\.0/);
+    assert.match(source,/R40 FINAL MACHINE BASELINE/);
+    assert.match(source,/desktop-grant\.json/);
+  }
+  assert.match(writer,/probeR40FullSurface/);
+  assert.match(writer,/probeR40CompactDisarmed/);
+  assert.match(writer,/tool_count===80/);
+  assert.match(writer,/compact\.tool_count===42/);
+  assert.match(verifier,/R40_FULL_TOOL_COUNT=80/);
+  assert.match(verifier,/R40_COMPACT_TOOL_COUNT=42/);
+  assert.match(verifier,/v0\.11\.3-ce761dd6e014d42e/);
+  assert.match(verifier,/ce761dd6e014d42eddb635855038e0ce049c63c6e3af7e63c3005bbe198bcf7b/);
+  assert.match(verifier,/desktop_armed===false/);
+  assert.doesNotMatch(verifier,/from ['"]\.\.\/src\//);
+});
+
+test('R40 Windows gate refreshes Desktop policy before manifest freeze and emits R40 evidence',async()=>{
+  const [gate,evidence]=await Promise.all([text('scripts/gate-windows-r40.ps1'),text('scripts/windows-gate-evidence-r40.mjs')]);
+  const desktop=gate.indexOf("'desktop-policy-refresh'");
+  const manifest=gate.indexOf("'release-manifest-write'");
+  assert.ok(desktop>=0&&manifest>desktop);
+  assert.match(gate,/desktop:policy:refresh/);
+  assert.match(gate,/DEADBYTE V0\.12\.0 \/ R40 WINDOWS BATCH GATE: PASS/);
+  assert.match(evidence,/deadbyte\.r40-windows-gate\.v1/);
+  assert.match(evidence,/version:'0\.12\.0'/);
+});
+
+test('R40 bounded release parity suite includes Desktop updater generation and autonomous integration proofs',async()=>{
+  const script=await text('scripts/release-parity-tests-r40.ps1');
+  for(const required of ['r40-finalization.test.mjs','controller-desktop-r40.test.mjs','desktop-adversarial-r40.test.mjs',
+    'autonomous-desktop-r40.test.mjs','release-generation.test.mjs','runtime-self-update.test.mjs']) assert.match(script,new RegExp(required.replaceAll('.','\\.')));
+});
+
+
+test('R40 guarded Desktop smoke retries only bounded pre-dispatch foreground drift and never replays an unknown effect',async()=>{
+  const source=await text('src/remote-mcp-desktop-r40-smoke-client.mjs');
+  assert.match(source,/const maxPredispatchAttempts=3/);
+  assert.match(source,/desktop foreground window changed before action/);
+  assert.match(source,/if\(predispatchForegroundChanged\(actionResult\)\)/);
+  assert.match(source,/if\(attempt===maxPredispatchAttempts\)throw new Error\('Desktop guarded smoke foreground remained unstable before dispatch'\)/);
+  assert.match(source,/predispatchRetryCount\+=1/);
+  assert.match(source,/action=gateway\(actionResult,'desktop key_chord'\)/);
+  assert.match(source,/replay_performed:false/);
+  assert.match(source,/predispatch_retry_count:predispatchRetryCount/);
+  assert.doesNotMatch(source,/side_effect_state.*unknown.*continue/is);
+  assert.doesNotMatch(source,/desktop_action_started.*continue/is);
+});

package/test/release-generation.test.mjs

@@ -19,10 +19,16 @@ 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 desktopObserver=Buffer.from('desktop-observer-bytes\n');
+  const desktopInput=Buffer.from('desktop-input-bytes\n');
+  const desktopUia=Buffer.from('desktop-uia-bytes\n');
+  await writeFile(path.join(release,'bin','deadbyte-desktop-observer-r40.exe'),desktopObserver);
+  await writeFile(path.join(release,'bin','deadbyte-desktop-input-r40.exe'),desktopInput);
+  await writeFile(path.join(release,'bin','deadbyte-desktop-uia-r40.exe'),desktopUia);
   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),
+  const currentConfig={AgentRuntimeEnabled:true,ProcessRuntimeEnabled:true,CodingRuntimeEnabled:true,MachineFsRuntimeEnabled:true,ObservationRuntimeEnabled:true,DesktopRuntimeEnabled: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:[
@@ -42,20 +48,35 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
     native_host:{path:'C:/old/deadbyte-process-host.exe',sha256:'0'.repeat(64)},
     roots:{core:{path:'C:/old/core',deny_paths:['node_modules']}},
     profiles:{probe:{executable:'C:/Windows/System32/ping.exe',executable_sha256:EXE,root_ids:['core'],prefix_args:['127.0.0.1','-n','2'],max_args:0,max_arg_bytes:256,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}}};
+  const desktopPolicy={schema:'deadbyte.desktop-policy.v1',enabled:true,grant_file:'C:/old/desktop-grant.json',evidence_dir:'C:/old/desktop-evidence',
+    allowed_input_desktops:['Default'],allowed_actions:['click_primary','key_chord'],
+    limits:{max_frame_age_ms:2000,max_frame_bytes:8388608,capture_timeout_ms:5000,input_timeout_ms:2000,ground_timeout_ms:5000,post_observe_timeout_ms:5000,max_preview_bytes:1048576,max_text_bytes:4096},
+    observer:{executable:'C:/old/observer.exe',sha256:sha(desktopObserver),backend:'gdi-bitblt-fallback'},
+    input:{executable:'C:/old/input.exe',sha256:sha(desktopInput)},
+    grounder:{executable:'C:/old/uia.exe',sha256:sha(desktopUia)}};
   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');
   await writeFile(path.join(development,'scripts','gate-windows-old.ps1'),'Write-Output old-gate\n');
   await writeFile(path.join(development,'scripts','gate-windows-current.ps1'),'Write-Output current-gate\n');
   await writeFile(path.join(development,'package.json'),JSON.stringify({scripts:{'gate:windows':'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-current.ps1'}}));
-  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 result=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   const verified=await verifyGenerationBundle(result.generation_root,result.generation_manifest_sha256);
-  assert.equal(verified.files,6);
+  assert.equal(verified.files,7);
   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'));
   assert.equal(generatedProcess.roots.core.path,path.resolve(development));
   assert.equal(generatedProcess.native_host.path,path.join(path.resolve(release),'bin','deadbyte-process-host.exe'));
   assert.equal(generatedProcess.native_host.sha256,sha(Buffer.from('process-host-bytes\n')));
+  const generatedDesktop=JSON.parse(await readFile(result.desktop_policy_path,'utf8'));
+  assert.equal(generatedDesktop.grant_file,path.join(path.resolve(state),'runtime','desktop-grant.json'));
+  assert.equal(generatedDesktop.evidence_dir,path.join(path.resolve(state),'runtime','desktop-evidence'));
+  assert.equal(generatedDesktop.observer.executable,path.join(path.resolve(release),'bin','deadbyte-desktop-observer-r40.exe'));
+  assert.equal(generatedDesktop.input.executable,path.join(path.resolve(release),'bin','deadbyte-desktop-input-r40.exe'));
+  assert.equal(generatedDesktop.grounder.executable,path.join(path.resolve(release),'bin','deadbyte-desktop-uia-r40.exe'));
+  assert.equal(generatedDesktop.observer.sha256,sha(desktopObserver));
+  assert.equal(generatedDesktop.input.sha256,sha(desktopInput));
+  assert.equal(generatedDesktop.grounder.sha256,sha(desktopUia));
   const generatedCoding=JSON.parse(await readFile(result.coding_policy_path,'utf8'));
   assert.equal(generatedCoding.roots.core.path,path.resolve(development));
   assert.notEqual(generatedCoding.roots.core.path,path.resolve(release));
@@ -89,6 +110,8 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.match(config,/CodingRuntimeEnabled = \$true/);
   assert.match(config,/MachineFsRuntimeEnabled = \$true/);
   assert.match(config,/ObservationRuntimeEnabled = \$true/);
+  assert.match(config,/DesktopRuntimeEnabled = \$true/);
+  assert.match(config,/DesktopPolicyFile = '/);
   assert.match(config,/CodingPolicyFile = '/);
   assert.match(config,/AutonomousPolicyFile = '/);
   assert.match(config,/AutonomousSupervisorEnabled = \$true/);
@@ -105,36 +128,44 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   assert.match(path.basename(result.generation_root),/^v0\.8\.3-aaaaaaaaaaaaaaaa-g[0-9a-f]{16}$/);
   const changedConfig=structuredClone(currentConfig);
   changedConfig.Bridge.Arguments='bridge-v2.mjs';
-  const second=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:changedConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
+  const second=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:changedConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(second.generation_root,result.generation_root);
   assert.notEqual(second.generation_seed_sha256,result.generation_seed_sha256);
   const endpointChanged=structuredClone(currentConfig);
   endpointChanged.McpUrlFileSha256='2'.repeat(64);
-  const third=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:endpointChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
+  const third=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:endpointChanged,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(third.generation_root,result.generation_root);
   assert.notEqual(third.generation_seed_sha256,result.generation_seed_sha256);
   const machineDisabled=structuredClone(currentConfig);
   machineDisabled.MachineRuntimeEnabled=false;
-  const fourth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
+  const fourth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(fourth.generation_root,result.generation_root);
   assert.notEqual(fourth.generation_seed_sha256,result.generation_seed_sha256);
   const machineFsDisabled=structuredClone(currentConfig);
   machineFsDisabled.MachineFsRuntimeEnabled=false;
-  const fifth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineFsDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy});
+  const fifth=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:machineFsDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
   assert.notEqual(fifth.generation_root,result.generation_root);
   assert.notEqual(fifth.generation_seed_sha256,result.generation_seed_sha256);
   const observationDisabled=structuredClone(currentConfig);
   observationDisabled.ObservationRuntimeEnabled=false;
-  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});
+  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,desktopPolicy});
   assert.notEqual(sixth.generation_root,result.generation_root);
   assert.notEqual(sixth.generation_seed_sha256,result.generation_seed_sha256);
+  const desktopDisabled=structuredClone(currentConfig);
+  desktopDisabled.DesktopRuntimeEnabled=false;
+  const desktopVariant=await createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig:desktopDisabled,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy});
+  assert.notEqual(desktopVariant.generation_root,result.generation_root);
+  assert.notEqual(desktopVariant.generation_seed_sha256,result.generation_seed_sha256);
+  const desktopTampered=structuredClone(desktopPolicy);
+  desktopTampered.input.sha256='f'.repeat(64);
+  await assert.rejects(createGenerationBundle({stateRoot:state,releaseRoot:release,developmentRoot:development,workspaceRoot:workspace,releaseId:'v0.8.3-aaaaaaaaaaaaaaaa',currentConfig,codingPolicy:coding,autonomousPolicy:autonomous,hostPolicy:host,processPolicy,desktopPolicy:desktopTampered}),/desktop input helper SHA-256 mismatch/);
   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});
+  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,desktopPolicy});
   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);
@@ -143,5 +174,6 @@ test('R27 generation bundle rebinds authority and mutable state outside the rele
   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(desktopVariant.generation_root,desktopVariant.generation_manifest_sha256);
   await verifyGenerationBundle(seventh.generation_root,seventh.generation_manifest_sha256);
 });

package/test/release-version.test.mjs

@@ -2,62 +2,23 @@ import test from 'node:test';
 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 R38_PREDECESSOR_RELEASE_ID='v0.11.1-220fac89dd82cdcd';
-const R38_PREDECESSOR_MANIFEST='220fac89dd82cdcdddb82cd7d0b71b768f84a5c87d57ebaca0f5383f33d97a76';
-
-test('R38 hotfix authority agrees on V0.11.2 and preserves exact public 0.11.1 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-r38.ps1'),
-    text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),
-    text('scripts/deferred-slot-operation-r38.mjs'),text('scripts/release-parity-r38.mjs'),text('scripts/final-closure-r38.mjs'),
-    text('scripts/final-closure-verify-r38.mjs'),text('scripts/windows-gate-evidence-r38.mjs'),
-    text('controller/deadbyte-semantic-lsp-config.json')
-  ]);
-  assert.equal(pkg.version,'0.11.2');
-  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r38.ps1');
-  assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r38.mjs');
-  assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r38.mjs');
-  assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r38.mjs');
-  assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r38.mjs');
-  assert.match(version,/DEADBYTE_VERSION = '0\.11\.2'/);
-  assert.match(controller,/CONTROLLER V0\.11\.2 \/ R38/);
-  assert.match(gate,/DEADBYTE V0\.11\.2 \/ R38 WINDOWS BATCH GATE: PASS/);
-  assert.match(readme,/^DEADBYTE MCP V0\.11\.2 \/ R38 HOTFIX BASELINE$/m);
-  assert.match(architecture,/^# DEADBYTE MCP V0\.11\.2 \/ R38 ARCHITECTURE$/m);
-  assert.match(controllerReadme,/^DEADBYTE MCP V0\.11\.2 \/ R38 CONTROLLER$/m);
-  assert.match(deferred,/--expected-version','0\.11\.2'/);
-  assert.match(parity,/R38_PREDECESSOR_RELEASE_ID='v0\.11\.1-220fac89dd82cdcd'/);
-  assert.match(parity,new RegExp(R38_PREDECESSOR_MANIFEST));
-  assert.match(parity,/version==='0\.11\.2'|version:'0\.11\.2'/);
-  assert.match(closure,/version:'0\.11\.2'/);
-  assert.match(closureVerify,/DEADBYTE V0\.11\.2 \/ R38 WINDOWS BATCH GATE: PASS/);
-  assert.match(windowsGate,/version:'0\.11\.2'/);
-  assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');
-  assert.equal(R38_PREDECESSOR_RELEASE_ID,'v0.11.1-220fac89dd82cdcd');
-});
-
-test('R38 hotfix keeps ONLINE reuse and fixes PowerShell $Host recovery collision',async()=>{
-  const [cli,controller]=await Promise.all([text('src/deadbyte-cli.mjs'),text('controller/deadbyte-controller.ps1')]);
-  assert.match(cli,/controllerRuntimeReady/);
-  assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);
-  const start=controller.indexOf('function Recover-AutonomousSupervisor');
-  const end=controller.indexOf('function Show-State',start);
-  assert.ok(start>=0&&end>start,'supervisor recovery block missing');
-  const block=controller.slice(start,end);
-  assert.doesNotMatch(block,/\$host\s*=/i);
-  assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);
-});
-
-test('sealed R37 tooling remains historical 0.11.1 authority',async()=>{
-  const [parity,gate,closure]=await Promise.all([
-    text('scripts/release-parity.mjs'),text('scripts/gate-windows.ps1'),text('scripts/final-closure.mjs')
-  ]);
-  assert.match(parity,/R37_PREDECESSOR_RELEASE_ID='v0\.11\.0-08c2a0008b1f84c9'/);
-  assert.match(parity,/version==='0\.11\.1'|version:'0\.11\.1'/);
-  assert.match(gate,/DEADBYTE V0\.11\.1 \/ R37 WINDOWS BATCH GATE: PASS/);
-  assert.match(closure,/version:'0\.11\.1'/);
+const root=new URL('../',import.meta.url);const text=rel=>readFile(new URL(rel,root),'utf8');
+const R40_PREDECESSOR_RELEASE_ID='v0.11.3-ce761dd6e014d42e';
+const R40_PREDECESSOR_MANIFEST='ce761dd6e014d42eddb635855038e0ce049c63c6e3af7e63c3005bbe198bcf7b';
+test('R40 authority agrees on V0.12.0 and preserves exact sealed public 0.11.3 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-r40.ps1'),text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r40.mjs'),text('scripts/release-parity-r40.mjs'),text('scripts/final-closure-r40.mjs'),text('scripts/final-closure-verify-r40.mjs'),text('scripts/windows-gate-evidence-r40.mjs'),text('controller/deadbyte-semantic-lsp-config.json')]);
+ assert.equal(pkg.version,'0.12.0');assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r40.ps1');
+ assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r40.mjs');assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r40.mjs');
+ assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r40.mjs');assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r40.mjs');
+ assert.equal(pkg.scripts['desktop:policy:refresh'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/init-desktop-policy-r40.ps1');
+ assert.match(version,/DEADBYTE_VERSION = '0\.12\.0'/);assert.match(controller,/CONTROLLER V0\.12\.0 \/ R40/);assert.match(gate,/DEADBYTE V0\.12\.0 \/ R40 WINDOWS BATCH GATE: PASS/);
+ assert.match(readme,/^DEADBYTE MCP V0\.12\.0 \/ R40 DESKTOP COMPUTER-USE BASELINE$/m);assert.match(architecture,/^# DEADBYTE MCP V0\.12\.0 \/ R40 ARCHITECTURE$/m);assert.match(controllerReadme,/^DEADBYTE MCP V0\.12\.0 \/ R40 CONTROLLER$/m);
+ assert.match(deferred,/--expected-version','0\.12\.0'/);assert.match(deferred,/--enable-desktop/);assert.match(parity,/R40_PREDECESSOR_RELEASE_ID='v0\.11\.3-ce761dd6e014d42e'/);assert.match(parity,new RegExp(R40_PREDECESSOR_MANIFEST));
+ assert.match(parity,/version==='0\.12\.0'|version:'0\.12\.0'/);assert.match(closure,/version:'0\.12\.0'/);assert.match(closureVerify,/DEADBYTE V0\.12\.0 \/ R40 WINDOWS BATCH GATE: PASS/);assert.match(windowsGate,/version:'0\.12\.0'/);
+ assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');assert.equal(R40_PREDECESSOR_RELEASE_ID,'v0.11.3-ce761dd6e014d42e');
 });
+test('R40 keeps ONLINE reuse and PowerShell Host collision fix while Desktop stays explicit',async()=>{const [cli,controller]=await Promise.all([text('src/deadbyte-cli.mjs'),text('controller/deadbyte-controller.ps1')]);assert.match(cli,/controllerRuntimeReady/);assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);const start=controller.indexOf('function Recover-AutonomousSupervisor'),end=controller.indexOf('function Show-State',start);assert.ok(start>=0&&end>start);const block=controller.slice(start,end);assert.doesNotMatch(block,/\$host\s*=/i);assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);assert.match(controller,/armdesktop/);assert.match(controller,/disarmdesktop/);});
+test('sealed R39 tooling remains historical 0.11.3 authority with exact 0.11.2 predecessor',async()=>{const [parity,gate,closure]=await Promise.all([text('scripts/release-parity-r39.mjs'),text('scripts/gate-windows-r39.ps1'),text('scripts/final-closure-r39.mjs')]);assert.match(parity,/R39_PREDECESSOR_RELEASE_ID='v0\.11\.2-058605dfccaa3035'/);assert.match(parity,/version==='0\.11\.3'|version:'0\.11\.3'/);assert.match(gate,/DEADBYTE V0\.11\.3 \/ R39 WINDOWS BATCH GATE: PASS/);assert.match(closure,/version:'0\.11\.3'/);});
+test('sealed R37 tooling remains historical 0.11.1 authority',async()=>{const [parity,gate,closure]=await Promise.all([text('scripts/release-parity.mjs'),text('scripts/gate-windows.ps1'),text('scripts/final-closure.mjs')]);assert.match(parity,/R37_PREDECESSOR_RELEASE_ID='v0\.11\.0-08c2a0008b1f84c9'/);assert.match(parity,/version==='0\.11\.1'|version:'0\.11\.1'/);assert.match(gate,/DEADBYTE V0\.11\.1 \/ R37 WINDOWS BATCH GATE: PASS/);assert.match(closure,/version:'0\.11\.1'/);});

package/test/remote-console-r40.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { prepareRemoteConsole, remoteDisplayText } from '../src/remote-console.mjs';
+
+test('R40 remote console keeps Unicode off Windows and forces deterministic ASCII when requested',()=>{
+  assert.equal(prepareRemoteConsole({platform:'linux',isTTY:false,env:{},spawnSyncFn:()=>{throw new Error('must not spawn');}}).mode,'unicode');
+  const forced=prepareRemoteConsole({platform:'win32',isTTY:true,env:{DEADBYTE_REMOTE_ASCII:'1'},spawnSyncFn:()=>{throw new Error('must not spawn');}});
+  assert.deepEqual(forced,{mode:'ascii',code_page:null,reason:'forced_ascii'});
+});
+
+test('R40 Windows pipe uses ASCII fallback instead of emitting mojibake',()=>{
+  let spawned=false;
+  const state=prepareRemoteConsole({platform:'win32',isTTY:false,env:{SystemRoot:'C:\\Windows'},spawnSyncFn:()=>{spawned=true;return {status:0};}});
+  assert.deepEqual(state,{mode:'ascii',code_page:null,reason:'stdout_not_tty'});
+  assert.equal(spawned,false);
+  const rendered=remoteDisplayText('🚀 [DEVICE] ไทย 🙂','ascii');
+  assert.doesNotMatch(rendered,/[^\x20-\x7E]/);
+  assert.match(rendered,/\\u\{/);
+  assert.equal(rendered.includes('\uFFFD'),false);
+});
+
+test('R40 Windows TTY switches shared console code page to 65001 before enabling Unicode',()=>{
+  let call=null;
+  const state=prepareRemoteConsole({platform:'win32',isTTY:true,env:{SystemRoot:'C:\\Windows'},spawnSyncFn:(exe,args,options)=>{call={exe,args,options};return {status:0};}});
+  assert.equal(state.mode,'unicode');
+  assert.equal(state.code_page,65001);
+  assert.equal(call.exe,'C:\\Windows\\System32\\chcp.com');
+  assert.deepEqual(call.args,['65001']);
+  assert.equal(call.options.shell,false);
+  assert.equal(call.options.stdio,'ignore');
+});
+
+test('R40 Windows TTY falls back to ASCII when code-page setup fails',()=>{
+  const failed=prepareRemoteConsole({platform:'win32',isTTY:true,env:{SystemRoot:'C:\\Windows'},spawnSyncFn:()=>({status:1})});
+  assert.deepEqual(failed,{mode:'ascii',code_page:null,reason:'codepage_65001_unavailable'});
+  const thrown=prepareRemoteConsole({platform:'win32',isTTY:true,env:{SystemRoot:'C:\\Windows'},spawnSyncFn:()=>{throw new Error('blocked');}});
+  assert.deepEqual(thrown,{mode:'ascii',code_page:null,reason:'codepage_probe_threw'});
+});

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

@@ -1,50 +1,107 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { createLiveTimelineTracker } from '../src/remote-live-log.mjs';
+import { createLiveTimelineTracker, formatRemoteLifecycle, formatRuntimeDiagnosticLine, summarizeLiveToolArgs, truncateUtf8 } from '../src/remote-live-log.mjs';
 
-test('R37 live timeline renders sanitized tool-call detail and correlates terminal result with stable short span id',()=>{
+test('R40 human live timeline suppresses noisy read request and emits one categorized terminal line',()=>{
   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.match(run,/^1970-01-01T00:00:01\.000Z \| coding_file_read\s+\| Arguments: \{/);
-  assert.match(run,/\"path\":\"src\/a\.mjs\"/);
-  assert.match(run,/\"reason\":\"payload\"/);
-  assert.match(run,/\"reason\":\"secret\"/);
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_read',request_id:'abcdef1234567890',
+    ts:'1970-01-01T00:00:01.000Z',args:{root_id:'projects',path:'src/a.mjs',content:'SECRET',token:'SECRET'}},{sequence:10});
+  assert.equal(start,null);
   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');
+    ts:'1970-01-01T00:00:01.250Z',outcome:{is_error:false,duration_ms:250}},{sequence:11});
+  assert.match(done,/^📖  07:00:01\.250  #11  \[abcdef12\]  coding_file_read  projects:src\/a\.mjs  250ms  ✓$/);
   assert.deepEqual(tracker.pending(),[]);
-  assert.doesNotMatch(run+done,/SECRET/);
+  assert.doesNotMatch(String(done),/SECRET|Arguments:/);
 });
 
-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('R40 long or mutating call gets start line and terminal error carries sanitized reason',()=>{
+  let now=1000;
+  const tracker=createLiveTimelineTracker({clock:()=>now});
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_command_run',request_id:'request-23456789',
+    ts:'1970-01-01T00:00:01.000Z',args:{root_id:'core',command_id:'node_script',script_path:'scripts/check.mjs'}},{sequence:20});
+  assert.match(start,/^🏃  07:00:01\.000  #20  \[request-\]  coding_command_run  core node_script scripts\/check\.mjs  …$/);
+  now=1900;
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_command_run',request_id:'request-23456789',
+    ts:'1970-01-01T00:00:01.900Z',outcome:{is_error:true,duration_ms:900,reason:'script exited 1: ENOENT scripts/missing.mjs'}},{sequence:21});
+  assert.match(done,/🏃  07:00:01\.900  #21  \[request-\]  coding_command_run .* 900ms  ✗ — script exited 1: ENOENT scripts\/missing\.mjs$/);
+  assert.equal(tracker.observe({event_type:'tool.result',tool:'coding_command_run',request_id:'request-23456789',
+    outcome:{is_error:true,duration_ms:900}},{sequence:22}),null);
 });
 
-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);
+test('R40 heartbeat burst folds repeated status calls instead of printing every round-trip',()=>{
+  let now=1000;
+  const tracker=createLiveTimelineTracker({clock:()=>now,heartbeatBurstLimit:5,heartbeatWindowMs:3000});
+  for(let i=0;i<5;i++){
+    const id='ping-'+String(i).padStart(12,'0');
+    tracker.observe({event_type:'tool.request',tool:'machine_ping',request_id:id,args:{nonce:'mcpbench-'+i}},{sequence:30+i*2});
+    now+=10;
+    const line=tracker.observe({event_type:'tool.result',tool:'machine_ping',request_id:id,
+      outcome:{is_error:false,duration_ms:1+i}},{sequence:31+i*2});
+    if(i<4) assert.equal(line,null);
+    else assert.match(line,/^📡  .*#39  machine_ping ×5  avg 3ms  ✓$/);
+    now+=10;
+  }
+  assert.match(tracker.summary(),/5 calls \| 0 errors .*folded 4 heartbeat lines.*machine_ping×5/);
+});
+
+test('R40 transport IN/OUT echo is hidden by default and available only in verbose diagnostics',()=>{
+  const line='[TOOL IN ] 2026-09-19T00:00:00.000Z #7 coding_tree {"root_id":"core"}';
+  assert.equal(formatRuntimeDiagnosticLine('bridge.log',line),null);
+  assert.equal(formatRuntimeDiagnosticLine('bridge.log',line,{verbose:true}),'[BRIDGE.DEBUG] IN  coding_tree');
+});
+
+test('R40 argument summaries are human-sized and do not expose payload text',()=>{
+  assert.equal(summarizeLiveToolArgs('coding_file_write',{
+    root_id:'core',path:'src/x.mjs',content:'TOP_SECRET_PAYLOAD'
+  }),'core:src/x.mjs (18B)');
+});
 
-  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('R40 interrupted spans remain correlated and session summary is available',()=>{
+  const tracker=createLiveTimelineTracker();
+  tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'pending-12345678',
+    args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:50});
+  const lines=tracker.reconcileInterrupted('recovery');
+  assert.deepEqual(lines,['⚠ [pending-] OUTCOME_UNKNOWN coding_file_write — recovery ended before terminal result; inspect state before retry']);
+  assert.match(tracker.summary(),/^📊 \[SUMMARY\] 0 calls \| 0 errors/);
 });
 
-test('R37 CLI uses timeline tracker for compact live mode while keeping legacy formatter API',async()=>{
+test('R40 CLI exposes explicit verbose mode while keeping default live mode compact',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'/);
+  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode\}\)/);
+  assert.match(src,/args\.includes\('--verbose'\)/);
+  assert.match(src,/Transport IN\/OUT hidden/);
+  assert.doesNotMatch(src,/\[cursor \$\{recorded\.cursor\}\]/);
+});
+
+
+test('R40 ASCII display fallback contains no non-ASCII bytes and preserves terminal meaning',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1250,displayMode:'ascii'});
+  tracker.observe({event_type:'tool.request',tool:'coding_file_read',request_id:'ascii-1234567890',
+    ts:'1970-01-01T00:00:01.000Z',args:{root_id:'projects',path:'src/ไทย.mjs'}},{sequence:60});
+  const line=tracker.observe({event_type:'tool.result',tool:'coding_file_read',request_id:'ascii-1234567890',
+    ts:'1970-01-01T00:00:01.250Z',outcome:{is_error:false,duration_ms:250}},{sequence:61});
+  assert.match(line,/^R  07:00:01\.250  #61 .* coding_file_read .* 250ms  OK$/);
+  assert.doesNotMatch(line,/[^\x20-\x7E]/);
+  assert.equal(formatRemoteLifecycle('device_start',{displayMode:'ascii'}),'[DEVICE] Starting DEADBYTE MCP...');
+});
+
+test('R40 interrupted side effect is explicit OUTCOME_UNKNOWN instead of implying failure or replay safety',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'unknown-12345678',
+    args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:70});
+  const line=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'unknown-12345678',
+    outcome:{status:'interrupted',is_error:true,duration_ms:0,side_effect_state:'unknown',recovery:{reason:'runtime_restart'}}},{sequence:71});
+  assert.match(line,/OUTCOME_UNKNOWN — runtime_restart$/);
+  assert.doesNotMatch(line,/\s[✓✗]\s/);
+});
+
+test('R40 UTF-8 truncation never splits Thai or emoji into replacement characters',()=>{
+  const input='ภาษาไทย🙂'.repeat(40);
+  const clipped=truncateUtf8(input,73);
+  assert.ok(new TextEncoder().encode(clipped).length<=73);
+  assert.equal(clipped.includes('\uFFFD'),false);
+  assert.ok(clipped.endsWith('…'));
 });