deadbyte-mcp 0.15.68 → 0.15.70

package/test/r186-owner-review-export.test.mjs

@@ -0,0 +1,52 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readFile,symlink,writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {writeR186OwnerReviewRequest} from '../src/r186-owner-review-export.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function fixture(){
+ const root=await mkdtemp(path.join(tmpdir(),'deadbyte-r186-review-'));
+ const project='D:\\Projects\\deadbyte-mcp';
+ const codingPath=path.join(root,'coding.json');
+ const autonomousPath=path.join(root,'autonomous.json');
+ const manifestPath=path.join(root,'MANIFEST.SHA256');
+ const outputPath=path.join(root,'review-request.json');
+ const codingBytes=Buffer.from(JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+  roots:{core:{path:project,read:true,write:true,exec:false}}}));
+ await writeFile(codingPath,codingBytes);
+ await writeFile(autonomousPath,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+  root_ids:['core'],coding_policy_sha256:sha(codingBytes),lease_file:path.join(root,'grant.json')}));
+ await writeFile(manifestPath,'a'.repeat(64)+'  package.json\n');
+ return {root,projectRoot:project,codingPolicyPath:codingPath,
+  autonomousPolicyPath:autonomousPath,manifestPath,outputPath};
+}
+
+test('R186 owner review export writes one exact bounded request without granting authority',async()=>{
+ const f=await fixture();
+ const result=await writeR186OwnerReviewRequest({...f,rootId:'core',
+  now:new Date('2026-10-28T04:00:00.000Z'),durationMs:300000});
+ const saved=JSON.parse(await readFile(f.outputPath,'utf8'));
+ assert.equal(saved.subject_sha256,result.subject_sha256);
+ assert.equal(saved.subject.project_root,f.projectRoot);
+ assert.equal(saved.subject.expires_at_utc,'2026-10-28T04:05:00.000Z');
+ assert.equal(saved.authority_granted,false);
+ assert.equal(saved.owner_signature_present,false);
+ await assert.rejects(()=>writeR186OwnerReviewRequest({...f,rootId:'core'}),/exists|EEXIST/i);
+});
+
+test('R186 owner review export rejects policy drift and reparse inputs',async()=>{
+ const f=await fixture();
+ const autonomous=JSON.parse(await readFile(f.autonomousPolicyPath,'utf8'));
+ autonomous.coding_policy_sha256='b'.repeat(64);
+ await writeFile(f.autonomousPolicyPath,JSON.stringify(autonomous));
+ await assert.rejects(()=>writeR186OwnerReviewRequest({...f,rootId:'core'}),/digest binding/i);
+
+ const clean=await fixture();
+ const link=path.join(path.dirname(clean.root),'coding-policy-junction-'+path.basename(clean.root));
+ await symlink(clean.root,link,'junction');
+ await assert.rejects(()=>writeR186OwnerReviewRequest({...clean,rootId:'core',codingPolicyPath:link}),/reparse|symlink/i);
+});

package/test/r190-foreground-cli.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+
+test('R190 CLI exposes explicit marker recovery and applies the R89 trust boundary before mutation',async()=>{
+ const installation=await inspectTrustedInstallation([
+  process.execPath,
+  path.join(root,'src','deadbyte-cli.mjs'),
+  path.join(root,'MANIFEST.SHA256'),
+  path.join(root,'src','foreground-owner-recovery-r190.mjs'),
+  path.join(root,'src','foreground-marker-cas-win32.mjs'),
+  path.join(root,'src','foreground-process-identity.mjs'),
+  path.join(root,'src','foreground-session-lock.mjs'),
+  path.join(root,'src','privileged-install-trust-r89.mjs'),
+  path.join(root,'src','canonical-json.mjs'),
+  path.join(root,'bin','deadbyte-epoch-lock-r85.node')
+ ]).catch(()=>({trusted:false}));
+ const result=spawnSync(process.execPath,['src/deadbyte-cli.mjs','remote','reconcileforeground',
+  '--confirm-marker-sha256','f'.repeat(64)],{encoding:'utf8',windowsHide:true,shell:false});
+ const output=String(result.stdout||'')+String(result.stderr||'');
+ assert.notEqual(result.status,0,output);
+ if(installation.trusted) assert.match(output,/marker (?:hash differs from explicit confirmation|absent without a durable R190 intent)/);
+ else assert.match(output,/R190_PROTECTED_RECOVERY_REQUIRED/);
+ assert.doesNotMatch(output,/unsupported remote command|EXACT_ACTIVE_RELEASE_REQUIRED/);
+});
+
+test('R190 CLI requires exact marker hash and never accepts recovery confirmation on another command',()=>{
+ const missing=spawnSync(process.execPath,['src/deadbyte-cli.mjs','remote','reconcileforeground'],
+  {encoding:'utf8',windowsHide:true,shell:false});
+ assert.notEqual(missing.status,0);
+ assert.match(String(missing.stderr),/requires --confirm-marker-sha256/);
+ const confused=spawnSync(process.execPath,['src/deadbyte-cli.mjs','remote','status',
+  '--confirm-marker-sha256','f'.repeat(64)],{encoding:'utf8',windowsHide:true,shell:false});
+ assert.notEqual(confused.status,0);
+ assert.match(String(confused.stderr),/valid only with reconcileforeground/);
+});

package/test/r190-foreground-owner-recovery.test.mjs

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {recoverLegacyForegroundOwnership} from '../src/foreground-owner-recovery-r190.mjs';
+
+const H=char=>char.repeat(64);
+const owner={schema:'deadbyte.foreground-process.v1',pid:9496,parent_pid:5272,
+ creation_utc:'2026-10-27T12:25:38.764342Z',executable_path:'C:\\Program Files\\nodejs\\node.exe',command_line_sha256:H('a')};
+const guardian={...owner,pid:10456,parent_pid:9496,creation_utc:'2026-10-27T12:25:39.244355Z',command_line_sha256:H('b')};
+const marker={schema:'deadbyte.remote-session.v2',owner_pid:9496,guardian_pid:10456,
+ session_nonce:H('c'),result_session_id:'b0015a97167ff20bf4e15588',started_at_utc:'2026-10-27T12:25:38.994Z',owner_identity:owner,guardian_identity:guardian};
+const pointer={release_id:'v0.15.68-'+H('d').slice(0,16),version:'0.15.68',manifest_sha256:H('d'),
+ generation_manifest_sha256:H('e'),generation_root:'C:\\Users\\DEADBYTE\\.deadbyte-mcp\\generations\\fixture'};
+const authority={state:'ONLINE',local_ready:true,supervisor:{running:true},authority:Object.fromEntries(
+ ['process','coding','autonomous','desktop','host'].map((plane,index)=>[plane,{configured:true,armed:[true,true,false,false,true][index],reason:[true,true,false,false,true][index]?'standing-grant':'disarmed'}]))};
+
+function harness({ownerActual={...owner,pid:9496,creation_utc:'2026-10-28T03:22:41.668663Z',executable_path:'C:\\Windows\\WidgetBoard.exe'},
+ guardianActual=null,driftPointer=false,terminalFailure=false}={}){
+ let snapshot={marker,sha256:H('f')},intent=null,terminal=null,deletes=0,pointerReads=0;
+ return {state:()=>({snapshot,intent,terminal,deletes}),run:()=>recoverLegacyForegroundOwnership({
+  expectedMarkerSha256:H('f'),readMarkerSnapshot:async()=>snapshot,
+  deleteMarkerIfHash:async expected=>{assert.equal(expected,H('f'));snapshot=null;deletes++;return 'REMOVED';},
+  readActivePointer:async()=>{pointerReads++;return driftPointer&&pointerReads>1?{...pointer,release_id:'changed'}:pointer;},
+  readAuthority:async()=>authority,
+  queryIdentity:identity=>identity.pid===owner.pid?ownerActual:guardianActual,
+  loadIntent:async()=>intent,loadTerminal:async()=>terminal,
+  publishIntent:async value=>{intent=value;return {sha256:value.intent_sha256};},
+  publishTerminal:async value=>{if(terminalFailure){terminalFailure=false;throw new Error('terminal write failed');}terminal=value;return {sha256:value.receipt_sha256};},
+  now:()=>new Date('2026-10-28T07:00:00.000Z')
+ })};
+}
+
+test('R190 explicit owner recovery CAS-removes only a PID-reused legacy marker and preserves authority vector',async()=>{
+ const h=harness(),result=await h.run(),state=h.state();
+ assert.equal(result.status,'MARKER_RECONCILED');
+ assert.equal(state.deletes,1);
+ assert.equal(state.snapshot,null);
+ assert.equal(state.intent.authority.process.armed,true);
+ assert.equal(state.intent.authority.coding.armed,true);
+ assert.equal(state.intent.authority.autonomous.armed,false);
+ assert.equal(state.intent.authority.host.armed,true);
+ assert.equal(state.terminal.marker_sha256,H('f'));
+});
+
+test('R190 refuses live matching owner and pointer drift without deleting marker',async()=>{
+ const live=harness({ownerActual:owner});
+ await assert.rejects(()=>live.run(),/owner.*active/i);
+ assert.equal(live.state().deletes,0);
+ const drift=harness({driftPointer:true});
+ await assert.rejects(()=>drift.run(),/pointer.*drift/i);
+ assert.equal(drift.state().deletes,0);
+});
+
+test('R190 resumes terminal publication after crash following native CAS delete without repeating mutation',async()=>{
+ const h=harness({terminalFailure:true});
+ await assert.rejects(()=>h.run(),/terminal write failed/);
+ assert.equal(h.state().deletes,1);
+ const result=await h.run();
+ assert.equal(result.status,'MARKER_RECONCILED_AFTER_DELETE');
+ assert.equal(h.state().deletes,1);
+ assert.ok(h.state().terminal);
+});

package/test/r190-release-contract.test.mjs

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const json=async file=>JSON.parse(await readFile(new URL('../'+file,import.meta.url),'utf8'));
+test('R190 candidate identity separates published source 0.15.69 from active runtime 0.15.68',async()=>{
+ const [pkg,bridge,release,provenance,matrix,sbom,versionSource]=await Promise.all([
+  json('package.json'),json('bridge/package.json'),json('RELEASE.json'),json('PROVENANCE.json'),
+  json('TEST-MATRIX.json'),json('SBOM.cdx.json'),readFile(new URL('../src/version.mjs',import.meta.url),'utf8')]);
+ for(const value of [pkg.version,bridge.version,release.version,provenance.version,matrix.version,
+  sbom.metadata.component.version])assert.equal(value,'0.15.70');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.70'/);
+ assert.equal(release.train,'R190');assert.equal(matrix.train,'R190');
+ assert.equal(release.source_predecessor.version,'0.15.69');
+ assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
+ assert.equal(release.source_predecessor.manifest_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
+ assert.equal(release.runtime_predecessor.version,'0.15.68');
+ assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
+ assert.equal(provenance.source_predecessor_version,'0.15.69');
+ assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+ assert.match(sbom.serialNumber,/r190:0\.15\.70$/);
+});
+
+test('R190 release metadata records verified recovery without claiming publication or activation',async()=>{
+ const release=await json('RELEASE.json');
+ assert.equal(release.r190_foreground_recovery.status,'PREPUBLISH_VERIFIED');
+ assert.equal(release.r190_foreground_recovery.npm_published,false);
+ assert.equal(release.r190_foreground_recovery.production_activated,false);
+ assert.equal(release.r190_foreground_recovery.live_marker_reconciled,true);
+ assert.equal(release.r190_foreground_recovery.authority_mutation_allowed,false);
+ assert.equal(release.r190_foreground_recovery.runtime_mutation_allowed,false);
+ assert.match(release.r190_foreground_recovery.protected_full_regression,/0_FAIL$/);
+});

package/test/r48-release-contract.test.mjs

@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { DEADBYTE_VERSION } from '../src/version.mjs';
+import { readReleaseLock } from './helpers/release-lock.mjs';
 
 const root = new URL('../', import.meta.url);
 const read = rel => readFile(new URL(rel, root), 'utf8');
@@ -9,7 +10,7 @@ const json = rel => read(rel).then(raw => JSON.parse(raw.replace(/^\uFEFF/,'')))
 
 test('R48 compatibility release contract remains coherent in the current successor', async () => {
   const [pkg, lock, release, provenance, matrix] = await Promise.all([
-    json('package.json'), json('package-lock.json'), json('RELEASE.json'),
+    json('package.json'), readReleaseLock(new URL('.', root)), json('RELEASE.json'),
     json('PROVENANCE.json'), json('TEST-MATRIX.json')
   ]);
 

package/test/r51-runtime-coherence.test.mjs

@@ -50,10 +50,12 @@ test('R51 bare remote wires coherence before live generation binding and deploy
 });
 
 
-test('R51 foreground authority contract explicitly verifies and cleans desktop plus host',async()=>{
+test('R175 observation-only foreground retains legacy cleanup only for legacy markers, never owned grants',async()=>{
   const {readFile}=await import('node:fs/promises');
   const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
-  assert.match(cli,/assertAuthorityVector\(assertRuntimeReadyObservation\(observedAuthority/);
+  assert.match(cli,/if\(marker!==null\)/);
+  assert.match(cli,/R175_INVALID_OBSERVE_ONLY_MARKER/);
+  assert.match(cli,/assertRuntimeReadyObservation\(observedAuthority/);
   assert.match(cli,/SESSION_CLEANUP=.*disarmdesktop.*disarmhost/s);
   assert.match(cli,/authorityBanner\(authority\)/);
 });

package/test/r58-cleanup-retention.test.mjs

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
 
-test('R58 foreground cleanup failure retains ownership evidence for recovery', {timeout:60000}, async () => {
+test('R175 elevated foreground rejection cannot create cleanup ownership evidence', {timeout:60000}, async () => {
   const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
   await mkdir(base,{recursive:true});
   const root=await mkdtemp(path.join(base,'cleanup-'));
@@ -34,18 +34,11 @@ exit 0
   child.stdout.on('data',b=>{stdout+=b;});child.stderr.on('data',b=>{stderr+=b;});
   const closed=new Promise(resolve=>child.once('close',code=>resolve(code)));
   try {
-    const deadline=Date.now()+50000;
-    while(!stdout.includes('[READY]')&&child.exitCode===null&&Date.now()<deadline) await delay(50);
-    assert.match(stdout,/\[READY\]/,stderr);
-    assert.match(stdout,/\[AUTH\] process ARMED \| coding ARMED \| autonomous ARMED \| desktop DISARMED \| host DISARMED/,stderr);
-    child.stdin.end();
-    assert.notEqual(await closed,0,'cleanup failure must not report a successful foreground exit');
-    assert.match(stderr,/cleanup disarmprocess exit=9/);
-    const marker=JSON.parse(await readFile(path.join(root,'runtime','remote-session.json'),'utf8'));
-    assert.equal(marker.owner_pid,child.pid);
-    assert.match(marker.session_nonce,/^[0-9a-f]{64}$/);
+    assert.notEqual(await closed,0,'elevated foreground must fail closed');
+    assert.match(stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
+    await assert.rejects(()=>readFile(path.join(root,'runtime','remote-session.json'),'utf8'),{code:'ENOENT'});
   } finally {
     if(child.exitCode===null) child.kill();
-    // A failed cleanup intentionally leaves state as reproducible evidence.
+    // Rejection occurs before a session claim or controller mutation.
   }
 });

package/test/r58-concurrent-recovery.test.mjs

@@ -5,6 +5,9 @@ import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {spawn} from 'node:child_process';
 import {setTimeout as delay} from 'node:timers/promises';
+import {installExactActivePointer} from './helpers/r175-active-pointer.mjs';
+
+const packageRoot=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 
 test('R75 simultaneous owner-unverified recovery attempts both retain authority and marker', {timeout:30000},async()=>{
  const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
@@ -41,6 +44,7 @@ switch($Command){
 }
 exit 0
 `);
+ await installExactActivePointer({stateRoot:root,packageRoot,launcherPath:path.join(root,'bin','DEADBYTE-MCP.ps1')});
  const children=[],outputs=[];
  try{
   for(let i=0;i<2;i++){
@@ -52,7 +56,7 @@ exit 0
   const commands=await readFile(trace,'utf8').catch(error=>error.code==='ENOENT'?'':Promise.reject(error));
   await writeFile(path.join(root,'observation.json'),JSON.stringify({commands,exits,outputs:outputs.map(o=>({stdout:o.stdout,stderr:o.stderr})),simulation:'concurrent owner-unverified stale marker'}),{flag:'wx'});
   assert.ok(exits.every(code=>code!==0));
-  for(const output of outputs)assert.match(output.stderr,/ownership(?: identity)? unverified.*marker retained|already claimed \(startup\/recovery lock\)/i);
+  for(const output of outputs)assert.match(output.stderr,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND|already claimed \(startup\/recovery lock\)/i);
   assert.equal(commands,'','neither attempt may touch authority');
   assert.equal(JSON.parse(await readFile(markerPath,'utf8')).pid,2147483000);
  }finally{

package/test/r58-stale-owner.test.mjs

@@ -5,12 +5,16 @@ import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {spawn} from 'node:child_process';
 import {queryForegroundIdentity} from '../src/foreground-process-identity.mjs';
+import {installExactActivePointer} from './helpers/r175-active-pointer.mjs';
+
+const packageRoot=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 
 test('R58 inconsistent owner PID binding cannot trigger stale-session authority cleanup', {timeout:20000}, async()=>{
  const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
  const root=await mkdtemp(path.join(base,'owner-binding-'));await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));
  const trace=path.join(root,'trace.txt');
  await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nexit 0\n`);
+ await installExactActivePointer({stateRoot:root,packageRoot,launcherPath:path.join(root,'bin','DEADBYTE-MCP.ps1')});
  const identity=queryForegroundIdentity(process.pid);
  const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:0,session_nonce:'c'.repeat(64),owner_identity:{...identity,pid:process.pid+1}};
  const markerPath=path.join(root,'runtime','remote-session.json');const bytes=JSON.stringify(marker);await writeFile(markerPath,bytes);
@@ -18,7 +22,7 @@ test('R58 inconsistent owner PID binding cannot trigger stale-session authority
  let stderr='';child.stderr.on('data',b=>{stderr+=b;});child.stdout.resume();
  const code=await new Promise(resolve=>child.once('close',resolve));
  await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stderr}),{flag:'wx'});
- assert.notEqual(code,0);assert.match(stderr,/ownership identity|binding/i);
+ assert.notEqual(code,0);assert.match(stderr,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND/i);
  assert.equal(await readFile(trace,'utf8').catch(e=>e.code==='ENOENT'?'':Promise.reject(e)),'','inconsistent marker must cause no controller actions');
  assert.equal(await readFile(markerPath,'utf8'),bytes,'retain ambiguous ownership evidence');
 });
@@ -29,6 +33,7 @@ test('R58 live unrelated PID is not accepted as a remote foreground owner', {tim
  await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));
  const trace=path.join(root,'trace.txt');
  await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nexit 0\n`);
+ await installExactActivePointer({stateRoot:root,packageRoot,launcherPath:path.join(root,'bin','DEADBYTE-MCP.ps1')});
  // The test runner is alive but neither a remote CLI nor a guardian. This
  // represents a stale numeric PID now occupied by an unrelated process.
  const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:process.pid,session_nonce:'a'.repeat(64),started_at_utc:'2000-01-01T00:00:00.000Z'};
@@ -41,7 +46,7 @@ test('R58 live unrelated PID is not accepted as a remote foreground owner', {tim
  // Fail-closed ambiguity is acceptable; do not kill the unrelated process or
  // mutate authority based on unverified ownership. Automatic convergence still
  // requires separately observed exact owner/guardian identity evidence.
- assert.match(stderr,/identity|ownership|ambiguous|unverified/i);
+ assert.match(stderr,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND/i);
  assert.deepEqual(JSON.parse(await readFile(path.join(root,'runtime','remote-session.json'),'utf8')),marker);
  assert.notEqual(code,0);
 });
@@ -52,6 +57,7 @@ test('R75 bound stale birth identity retains marker without touching a reused PI
  await mkdir(path.join(root,'runtime'));await mkdir(path.join(root,'bin'));
  const trace=path.join(root,'trace.txt');
  await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command,[switch]$Json)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nif ($Command -eq 'status' -and $Json) { $off=@{configured=$true;armed=$false;reason='disarmed'}; @{schema='deadbyte.controller-observation.v1';state='OFFLINE';authority=@{process=$off;coding=$off;autonomous=$off;desktop=$off;host=$off}} | ConvertTo-Json -Depth 5 -Compress }\nexit 0\n`);
+ await installExactActivePointer({stateRoot:root,packageRoot,launcherPath:path.join(root,'bin','DEADBYTE-MCP.ps1')});
  const current=queryForegroundIdentity(process.pid);
  const stale={...current,creation_utc:'2000-01-01T00:00:00.000Z'};
  const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:process.pid,session_nonce:'b'.repeat(64),owner_identity:stale,guardian_identity:stale};
@@ -62,7 +68,7 @@ test('R75 bound stale birth identity retains marker without touching a reused PI
  const code=await new Promise(resolve=>child.once('close',resolve));
  await writeFile(path.join(root,'observation.json'),JSON.stringify({code,stdout,stderr,simulation:'birth identity drift at a live unrelated numeric PID'}),{flag:'wx'});
  assert.notEqual(code,0);
- assert.match(stderr,/owner identity mismatch; marker retained/i);
+ assert.match(stderr,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND/i);
  assert.equal(await readFile(trace,'utf8').catch(error=>error.code==='ENOENT'?'':Promise.reject(error)),'','identity drift must cause no authority commands');
  assert.deepEqual(JSON.parse(await readFile(markerPath,'utf8')),marker);
  assert.equal(foregroundAlive(),true,'unrelated live process must not be killed');

package/test/r59-tool-surface-compat.test.mjs

@@ -83,7 +83,7 @@ test('R72 compact baseline permits only R64 read offset and authorized coding-on
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
   const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
-  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65','0.15.66','0.15.67','0.15.68'].includes(packageVersion)){
+  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65','0.15.66','0.15.67','0.15.68','0.15.69','0.15.70'].includes(packageVersion)){
     assert.deepEqual([...diff.schema_changed].sort(),['machine_fs','native_diff_preview']);
     assert.equal(diff.unchanged.length,41);
     const prior=baseline.tools.find(tool=>tool.name==='machine_fs');

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

@@ -73,8 +73,8 @@ test('R40 CLI exposes explicit verbose mode while keeping default live mode comp
   const src=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
   assert.match(src,/readLiveRootPaths\(ctx\.root\)/);
   assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode,rootPaths,trace,\.\.\.defaultForegroundTimelineOptions\(\{verbose\}\)\}\)/);
-  assert.deepEqual(live.defaultForegroundTimelineOptions({verbose:false}),{commanderStyle:true,foldHeartbeats:false});
-  assert.deepEqual(live.defaultForegroundTimelineOptions({verbose:true}),{commanderStyle:false,foldHeartbeats:false});
+  assert.deepEqual(live.defaultForegroundTimelineOptions({verbose:false}),{commanderStyle:false,foldHeartbeats:true,prettyStyle:true});
+  assert.deepEqual(live.defaultForegroundTimelineOptions({verbose:true}),{commanderStyle:false,foldHeartbeats:false,prettyStyle:false});
   assert.match(src,/createLiveTimelineFilter\(filterExpression\)/);
   assert.match(src,/createLiveTimelineWriter\(\{stream:process\.stdout,displayMode,rewrite:false\}\)/);
   assert.match(src,/arg==='--verbose'\|\|arg==='-v'/);

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

@@ -9,7 +9,7 @@ test('R36 lifecycle formatter exposes device/connect/ready/cleanup states with b
   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.equal(formatRemoteLifecycle('cleanup'),'[SESSION] Closing observation session...');
   assert.throws(()=>formatRemoteLifecycle('invented'),/unknown remote lifecycle/i);
 });