deadbyte-mcp 0.15.68 → 0.15.69

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

@@ -8,11 +8,11 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 const readOptional=async rel=>{try{return await read(rel);}catch(error){if(error?.code==='ENOENT')return null;throw error;}};
-const VERSION='0.15.68';
+const VERSION='0.15.69';
 const R166_MANIFEST='ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849';
 const R166_TARBALL='3d22412c3cebabd66bfa92ca4dbaaf3ef49acba7f92436a16485d7e4cb18c653';
 
-test('R173 package identity binds published R172 source separately from active R153 runtime',async()=>{
+test('current package identity retains the immutable R167/R173 activation lineage',async()=>{
   const [pkg,lock,bridge,release,provenance,matrix,bom]=await Promise.all([
     read('package.json'),readOptional('package-lock.json'),read('bridge/package.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
@@ -20,19 +20,21 @@ test('R173 package identity binds published R172 source separately from active R
     provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION];
   if(lock)versions.push(lock.version,lock.packages[''].version);
   for(const version of versions)assert.equal(version,VERSION);
-  assert.equal(release.train,'R173');
-  assert.equal(matrix.train,'R173');
-  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r173:0.15.68');
+  assert.equal(release.train,'R179');
+  assert.equal(matrix.train,'R179');
+  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r179:0.15.69');
   assert.deepEqual(release.runtime_predecessor,{
-    version:'0.15.61',release_id:'v0.15.61-055d1ff0aa99e60b',
-    manifest_sha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',
-    generation_manifest_sha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'
+    version:'0.15.68',release_id:'v0.15.68-ff29dbb2fbb89862',
+    manifest_sha256:'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885',
+    generation_manifest_sha256:'2887d4a8d54ea6fc6b28869072f72491c892dfe28178b3537936dce958147bd2'
   });
-  assert.equal(release.source_predecessor.version,'0.15.67');
-  assert.equal(release.source_predecessor.train,'R172');
-  assert.equal(release.source_predecessor.tarball_sha256,'0fe761f035f38730a4717448da4217f55464c38cd1616126b5850ff44411cd6d');
+  assert.equal(release.source_predecessor.version,'0.15.68');
+  assert.equal(release.source_predecessor.train,'R173');
+  assert.equal(release.source_predecessor.tarball_sha256,'1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf');
+  assert.equal(release.r173.source_predecessor_version,'0.15.67');
   assert.equal(release.r167.source_predecessor_manifest_sha256,R166_MANIFEST);
-  assert.equal(provenance.source_predecessor_manifest_file_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885');
+  assert.equal(provenance.r173.source_predecessor_manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
   assert.equal(release.r172.source_predecessor_manifest_sha256,'962e227dace247d59aa860211388fbde461c5f9c8a7e8a878e34a14a27d355f8');
   assert.equal(release.r172.source_predecessor_tarball_sha256,'31b194a4fbff7dbdb9f4f275b4ea49c5115f7b0bb2241c0c72d72ef690311a5d');
   assert.equal(release.r167.public_tool_delta,0);
@@ -41,7 +43,7 @@ test('R173 package identity binds published R172 source separately from active R
   assert.equal(release.r167.npm_publish,'NOT_RUN');
 });
 
-test('R167 protected continuity remains pending until exact Windows fixture evidence exists',async()=>{
+test('R167 historical protected continuity remains recorded without overriding current release truth',async()=>{
   const [release,provenance,matrix]=await Promise.all([
     read('RELEASE.json'),read('PROVENANCE.json'),read('TEST-MATRIX.json')]);
   assert.equal(release.r167.protected_entrypoint_continuity,'PENDING_PROTECTED_WINDOWS_FIXTURE');

package/test/r168-protected-entrypoint.test.mjs

@@ -10,13 +10,16 @@ const script=path.join(root,'scripts','r173-protected-preflight.mjs');
 const protectedRoot='C:\\Program Files';
 const relative=path.win32.relative(protectedRoot,root);
 const isProtected=process.platform==='win32'&&relative!==''&&relative!=='..'&&!relative.startsWith('..'+path.win32.sep)&&!path.win32.isAbsolute(relative);
+const packageIdentity=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+const releaseIdentity=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+const isR173Identity=packageIdentity.version==='0.15.68'&&releaseIdentity.version==='0.15.68'&&releaseIdentity.train==='R173';
 function launch(file,...args){return spawnSync(process.execPath,[file,...args],{
   encoding:'utf8',windowsHide:true,shell:false,timeout:15000,maxBuffer:65536
 });}
 
 test('R173 installed preflight respects R89 protected-vs-writable execution context',()=>{
   const result=launch(script);
-  if(isProtected){
+  if(isProtected&&isR173Identity){
     assert.equal(result.status,0,result.stderr);
     assert.match(result.stdout,/R173_PROTECTED_PREFLIGHT_READONLY_PASS/);
     assert.match(result.stdout,/"terminalization_authorized":false/);
@@ -24,7 +27,7 @@ test('R173 installed preflight respects R89 protected-vs-writable execution cont
   }else{
     assert.notEqual(result.status,0);
     assert.match(result.stderr,/R173_PROTECTED_PREFLIGHT=BLOCKED/);
-    assert.match(result.stderr,/R173_.*_(UNPROTECTED|VERSION_DRIFT)/);
+    assert.match(result.stderr,isProtected?/R173_VERSION_DRIFT/:/R173_.*_UNPROTECTED/);
   }
 });
 

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

@@ -13,9 +13,10 @@ const predecessorTarball='fc3ae5b1505e316bc9dfedf8d063cb00641754c8f5f1306a31f8cc
 
 test('R172 preserves the immutable R168 publication lineage separately from current identity',async()=>{
  const release=await read('RELEASE.json');
- assert.equal(release.runtime_predecessor.version,'0.15.61');
- assert.equal(release.runtime_predecessor.release_id,parent);
- assert.equal(release.parent.release_id,parent);
+ assert.equal(release.runtime_predecessor.version,'0.15.68');
+ assert.equal(release.parent.version,'0.15.68');
+ assert.notEqual(release.runtime_predecessor.release_id,parent);
+ assert.notEqual(release.parent.release_id,parent);
  assert.equal(release.r168.scope,'REMOTE_VERSION_SKEW_FAIL_CLOSED_AND_READONLY_RECONCILIATION');
  assert.equal(release.r168.source_predecessor_version,'0.15.65');
  assert.equal(release.r168.source_predecessor_manifest_sha256,predecessorManifest);

package/test/r168-remote-one-shot-coherence.test.mjs

@@ -60,7 +60,8 @@ test('R168 foreground remote refuses npm-cache version skew before session marke
   const source=cli.slice(start,end);
   assert.match(source,/selectR168OneShotRemotePath/);
   const safety=source.indexOf('selectR168OneShotRemotePath');
-  for(const operation of ['recoverRemoteSession(ctx','acquireForegroundSessionLock({root','synchronizeForegroundRuntime(ctx']){
+  for(const operation of ['recoverRemoteSession(ctx','acquireForegroundSessionLock({root','readRemoteSessionMarker(ctx.root)','claimRemoteSession(ctx)']){
     assert.ok(safety<source.indexOf(operation),'version guard must precede '+operation);
   }
+  assert.doesNotMatch(source,/synchronizeForegroundRuntime\(/,'R175 foreground must remain observation-only');
 });

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

@@ -9,19 +9,19 @@ const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 const readOptional=async rel=>{try{return await read(rel);}catch(error){if(error?.code==='ENOENT')return null;throw error;}};
 
-test('R173 binds the published source predecessor separately from the active runtime predecessor',async()=>{
+test('R179 binds the published source predecessor separately from the active runtime predecessor',async()=>{
   const [pkg,lock,bridge,release,provenance,matrix,bom]=await Promise.all([
     read('package.json'),readOptional('package-lock.json'),read('bridge/package.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
   const versions=[pkg.version,bridge.version,release.version,provenance.version,matrix.version,
     bom.metadata.component.version,DEADBYTE_VERSION];
   if(lock)versions.push(lock.version,lock.packages[''].version);
-  for(const value of versions)assert.equal(value,'0.15.68');
-  assert.equal(release.train,'R173'); assert.equal(matrix.train,'R173');
-  assert.equal(release.source_predecessor.version,'0.15.67');
-  assert.equal(release.source_predecessor.manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
-  assert.equal(release.source_predecessor.tarball_sha256,'0fe761f035f38730a4717448da4217f55464c38cd1616126b5850ff44411cd6d');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.61-055d1ff0aa99e60b');
+  for(const value of versions)assert.equal(value,'0.15.69');
+  assert.equal(release.train,'R179'); assert.equal(matrix.train,'R179');
+  assert.equal(release.source_predecessor.version,'0.15.68');
+  assert.equal(release.source_predecessor.manifest_sha256,'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885');
+  assert.equal(release.source_predecessor.tarball_sha256,'1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
   assert.equal(release.r173.public_tool_delta,0); assert.equal(release.r173.authority_scope_delta,0);
 });
 

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

@@ -3,30 +3,31 @@ import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
+import {readReleaseLock} from './helpers/release-lock.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 const json=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
 
-test('R173 package identity binds the exact published R172 source and live runtime predecessor',async()=>{
+test('R179 package identity binds the exact published R173 source and live runtime predecessor',async()=>{
   const [pkg,lock,bridge,release,provenance,matrix,sbom]=await Promise.all([
-    json('package.json'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    json('package.json'),readReleaseLock(root),json('bridge/package.json'),json('RELEASE.json'),
     json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json')
   ]);
-  assert.equal(pkg.version,'0.15.68');
-  assert.equal(lock.version,'0.15.68');
-  assert.equal(lock.packages[''].version,'0.15.68');
-  assert.equal(bridge.version,'0.15.68');
-  assert.equal(release.version,'0.15.68');
-  assert.equal(release.train,'R173');
-  assert.equal(matrix.version,'0.15.68');
-  assert.equal(matrix.train,'R173');
-  assert.equal(sbom.metadata.component.version,'0.15.68');
-  assert.equal(release.source_predecessor.version,'0.15.67');
-  assert.equal(release.source_predecessor.train,'R172');
-  assert.equal(release.source_predecessor.manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
-  assert.equal(release.source_predecessor.tarball_sha256,'0fe761f035f38730a4717448da4217f55464c38cd1616126b5850ff44411cd6d');
-  assert.equal(release.runtime_predecessor.version,'0.15.61');
-  assert.equal(provenance.version,'0.15.68');
+  assert.equal(pkg.version,'0.15.69');
+  assert.equal(lock.version,'0.15.69');
+  assert.equal(lock.packages[''].version,'0.15.69');
+  assert.equal(bridge.version,'0.15.69');
+  assert.equal(release.version,'0.15.69');
+  assert.equal(release.train,'R179');
+  assert.equal(matrix.version,'0.15.69');
+  assert.equal(matrix.train,'R179');
+  assert.equal(sbom.metadata.component.version,'0.15.69');
+  assert.equal(release.source_predecessor.version,'0.15.68');
+  assert.equal(release.source_predecessor.train,'R173');
+  assert.equal(release.source_predecessor.manifest_sha256,'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885');
+  assert.equal(release.source_predecessor.tarball_sha256,'1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf');
+  assert.equal(release.runtime_predecessor.version,'0.15.68');
+  assert.equal(provenance.version,'0.15.69');
   assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
   assert.equal(provenance.source_predecessor_manifest_file_sha256,release.source_predecessor.manifest_sha256);
 });

package/test/r174-owner-webauthn.test.mjs

@@ -0,0 +1,144 @@
+import test from 'node:test';
+import {mkdtemp,readdir,readFile,rm,symlink} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,randomBytes,sign} from 'node:crypto';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {verifyR174OwnerAssertion,acceptR174OwnerProof} from '../src/r174-owner-webauthn.mjs';
+const sha=b=>createHash('sha256').update(b).digest();
+const hex=b=>sha(b).toString('hex');
+const b64=b=>Buffer.from(b).toString('base64url');
+function fixture(){
+  const pair=generateKeyPairSync('ec',{namedCurve:'prime256v1'});
+  const credential={schema:'deadbyte.r174-owner-credential.v1',
+    credential_id_b64url:b64(randomBytes(32)),rp_id:'owner.deadbyte.local',
+    origin:'https://owner.deadbyte.local',
+    public_key_spki_pem:pair.publicKey.export({type:'spki',format:'pem'}),
+    algorithm:'ES256',sign_count:4};
+  const subject={schema:'deadbyte.r174-autonomous-owner-subject.v1',
+    release_manifest_sha256:'a'.repeat(64),coding_policy_sha256:'b'.repeat(64),
+    autonomous_policy_sha256:'c'.repeat(64),root_id:'core',
+    project_root:'D:\\Projects\\deadbyte-mcp',effect:'autonomous_goal_run',max_seconds:3600};
+  const transaction={schema:'deadbyte.r174-owner-challenge.v1',
+    challenge_b64url:b64(randomBytes(32)),subject_sha256:hex(Buffer.from(canonicalJson(subject))),
+    issued_at_utc:'2026-10-27T06:59:00.000Z',expires_at_utc:'2026-10-27T07:04:00.000Z'};
+  const clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:transaction.challenge_b64url,origin:credential.origin,crossOrigin:false}));
+  const authData=Buffer.alloc(37);
+  sha(Buffer.from(credential.rp_id)).copy(authData);
+  authData[32]=5;authData.writeUInt32BE(5,33);
+  const assertion={credential_id_b64url:credential.credential_id_b64url,
+    client_data_json_b64url:b64(clientData),authenticator_data_b64url:b64(authData),
+    signature_b64url:b64(sign('sha256',Buffer.concat([authData,sha(clientData)]),pair.privateKey))};
+  const ownerTrust={schema:'deadbyte.r174-owner-trust-binding.v1',
+    credential_id_b64url:credential.credential_id_b64url,
+    public_key_spki_sha256:hex(pair.publicKey.export({type:'spki',format:'der'})),
+    rp_id:credential.rp_id,origin:credential.origin,
+    subject_sha256:transaction.subject_sha256};
+  return {credential,subject,transaction,assertion,ownerTrust,now:new Date('2026-10-27T07:00:00.000Z'),privateKey:pair.privateKey,clientData,authData};
+}
+function reSign(f){
+ f.assertion.client_data_json_b64url=b64(f.clientData);
+ f.assertion.authenticator_data_b64url=b64(f.authData);
+ f.assertion.signature_b64url=b64(sign('sha256',Buffer.concat([f.authData,sha(f.clientData)]),f.privateKey));
+}
+test('R174 verifies ES256 authenticator signature and owner UV with bound challenge',async()=>{
+ const f=fixture();const r=await verifyR174OwnerAssertion(f);
+ assert.equal(r.status,'verified');assert.equal(r.sign_count,5);
+ assert.equal(r.subject_sha256,f.transaction.subject_sha256);assert.equal(r.user_verified,true);
+});
+test('R174 refuses invalid signature and UV=false even when resigned',async()=>{
+ const f=fixture();f.assertion.signature_b64url=b64(randomBytes(70));
+ await assert.rejects(verifyR174OwnerAssertion(f),/signature/i);
+ const g=fixture();g.authData[32]=1;reSign(g);
+ await assert.rejects(verifyR174OwnerAssertion(g),/user verification/i);
+});
+test('R174 refuses RP ID, origin, credential ID, and signature counter drift',async()=>{
+ const f=fixture();f.credential.rp_id='evil.example';
+ await assert.rejects(verifyR174OwnerAssertion(f),/rp id/i);
+ const g=fixture();g.credential.origin='https://evil.example';
+ await assert.rejects(verifyR174OwnerAssertion(g),/origin/i);
+ const h=fixture();h.credential.credential_id_b64url=b64(randomBytes(32));
+ await assert.rejects(verifyR174OwnerAssertion(h),/credential id/i);
+ const j=fixture();j.credential.sign_count=5;
+ await assert.rejects(verifyR174OwnerAssertion(j),/sign counter/i);
+});
+test('R174 refuses signed wrong challenge, cross origin, expired transaction',async()=>{
+ const f=fixture();f.clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:b64(randomBytes(32)),origin:f.credential.origin}));reSign(f);
+ await assert.rejects(verifyR174OwnerAssertion(f),/challenge/i);
+ const g=fixture();g.clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:g.transaction.challenge_b64url,origin:g.credential.origin,crossOrigin:true}));reSign(g);
+ await assert.rejects(verifyR174OwnerAssertion(g),/cross.origin/i);
+ const h=fixture();h.now=new Date('2026-10-27T07:05:00.000Z');
+ await assert.rejects(verifyR174OwnerAssertion(h),/expired/i);
+});
+test('R174 refuses policy-bound subject drift and overlong approval',async()=>{
+ const f=fixture();f.subject.root_id='projects';
+ await assert.rejects(verifyR174OwnerAssertion(f),/subject/i);
+ const g=fixture();g.transaction.expires_at_utc='2026-10-27T09:04:00.000Z';
+ await assert.rejects(verifyR174OwnerAssertion(g),/lifetime/i);
+});
+async function withLedger(work){
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r174-owner-ledger-'));
+  try{return await work(dir);}finally{await rm(dir,{recursive:true,force:true});}
+}
+test('R174 consumes verified assertion once with append-only JSON receipt and no authority grant',()=>withLedger(async ledgerRoot=>{
+  const result=await acceptR174OwnerProof({...fixture(),ledgerRoot});
+  assert.equal(result.status,'consumed');
+  assert.equal(result.authority_granted,false);
+  const files=await readdir(ledgerRoot);
+  assert.equal(files.length,1);
+  const receipt=JSON.parse(await readFile(path.join(ledgerRoot,files[0]),'utf8'));
+  assert.equal(receipt.schema,'deadbyte.r174-consumed-owner-challenge.v1');
+  assert.equal(receipt.subject_sha256,result.subject_sha256);
+  assert.equal(receipt.authority_granted,false);
+}));
+test('R174 rejects repeated or concurrent presentation of the same signed challenge',()=>withLedger(async ledgerRoot=>{
+  const f=fixture();const once=await acceptR174OwnerProof({...f,ledgerRoot});
+  assert.equal(once.status,'consumed');
+  await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/replay/i);
+  const another=fixture();
+  const results=await Promise.allSettled([
+    acceptR174OwnerProof({...another,ledgerRoot}),
+    acceptR174OwnerProof({...another,ledgerRoot})
+  ]);
+  assert.deepEqual(results.map(x=>x.status).sort(),['fulfilled','rejected']);
+  assert.equal((await readdir(ledgerRoot)).length,2);
+}));
+test('R174 invalid assertion never consumes challenge',()=>withLedger(async ledgerRoot=>{
+  const f=fixture();f.assertion.signature_b64url=b64(randomBytes(70));
+  await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/signature/i);
+  assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+test('R174 same challenge cannot be reused with a different credential',()=>withLedger(async ledgerRoot=>{
+ const f=fixture();
+ const g=fixture();
+ g.transaction.challenge_b64url=f.transaction.challenge_b64url;
+ g.clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:g.transaction.challenge_b64url,origin:g.credential.origin,crossOrigin:false}));
+ reSign(g);
+ assert.equal((await acceptR174OwnerProof({...f,ledgerRoot})).status,'consumed');
+ await assert.rejects(acceptR174OwnerProof({...g,ledgerRoot}),/replay/i);
+}));
+test('R174 rejects counter downgrade from nonzero previous to zero',async()=>{
+ const f=fixture();f.authData.writeUInt32BE(0,33);reSign(f);
+ await assert.rejects(verifyR174OwnerAssertion(f),/sign counter/i);
+});
+test('R174 refuses consumption when independently pinned owner trust is missing',()=>withLedger(async ledgerRoot=>{
+ const f=fixture();delete f.ownerTrust;
+ await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/owner trust/i);
+ assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+test('R174 refuses self-signed substitute owner credential against pinned trust',()=>withLedger(async ledgerRoot=>{
+ const known=fixture(),impostor=fixture();
+ impostor.ownerTrust=known.ownerTrust;
+ await assert.rejects(acceptR174OwnerProof({...impostor,ledgerRoot}),/owner trust|credential|public key/i);
+ assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+test('R174 refuses legitimate key if expected reviewed subject changed',()=>withLedger(async ledgerRoot=>{
+ const f=fixture();
+ f.subject.max_seconds=100;
+ f.transaction.subject_sha256=hex(Buffer.from(canonicalJson(f.subject)));
+ await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/owner trust|subject/i);
+ assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+
+

package/test/r175-cli-flags.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readdir,rm} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import os from 'node:os';
+import path from 'node:path';
+
+const cli=fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url));
+for(const mode of ['--operator','--desktop','--host','--full']){
+ test('R175 '+mode+' refuses implicit session-owned grant escalation before runtime state access',async()=>{
+  const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r175-flags-'));
+  try{
+   const child=spawnSync(process.execPath,[cli,'remote',mode],{
+    encoding:'utf8',windowsHide:true,timeout:15000,env:{...process.env,DEADBYTE_STATE_ROOT:state}
+   });
+   assert.equal(child.error,undefined,String(child.error));
+   assert.notEqual(child.status,0);
+   assert.match(child.stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
+   assert.deepEqual(await readdir(state),[],'failed flag must not create an authority marker or any state');
+  }finally{await rm(state,{recursive:true,force:true});}
+ });
+}

package/test/r175-foreground-boundary.test.mjs

@@ -0,0 +1,87 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {observeOnlyAuthority,assertObserveOnlyMarker,assertMatchingForegroundRelease} from '../src/r175-foreground-boundary.mjs';
+
+const planes=['process','coding','autonomous','desktop','host'];
+function observation(states){
+  return {state:'ONLINE',authority:Object.fromEntries(planes.map((plane,index)=>
+    [plane,{configured:true,armed:Boolean(states[index]),reason:states[index]?'standing-grant':'disarmed',
+      epoch_seq:index+1,epoch_sha256:String(index+1).repeat(64)}]))};
+}
+test('R175 bare remote preserves all owner standing grants as observed, never implies revocation',()=>{
+  const status=observation([false,true,false,true,true]);
+  const scope=observeOnlyAuthority(status);
+  assert.deepEqual(scope.expected,{process:false,coding:true,autonomous:false,desktop:true,host:true});
+  assert.deepEqual(scope.commands,[]);
+  assert.equal(scope.authority_scope,'observe-only');
+});
+test('R175 bare remote leaves all-disarmed state untouched',()=>{
+  const scope=observeOnlyAuthority(observation([false,false,false,false,false]));
+  assert.deepEqual(scope.commands,[]);
+  assert.ok(Object.values(scope.expected).every(value=>value===false));
+});
+test('R175 observation-only marker can be identified and has no owned grants',()=>{
+  const marker={schema:'deadbyte.remote-session.v2',owner_pid:1001,session_nonce:'a'.repeat(64),authority_scope:'observe-only'};
+  assert.equal(assertObserveOnlyMarker(marker),true);
+  assert.equal(assertObserveOnlyMarker({...marker,authority_scope:'legacy'}),false);
+  assert.equal(assertObserveOnlyMarker({...marker,session_nonce:'x'}),false);
+});
+test('R175 foreground never issues or revokes grants for observation-only mode',async()=>{
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(cli,/observeOnlyAuthority\(authority\)/);
+  assert.match(cli,/authority_scope:\s*['"]observe-only['"]/);
+  assert.match(cli,/if\s*\(mode!==['"]default['"]\)\s*throw/);
+  assert.match(cli,/if\(marker!==null\)/);
+  assert.match(cli,/R175_INVALID_OBSERVE_ONLY_MARKER/);
+});
+test('R175 crash guardian must not revoke or park observation-only markers',async()=>{
+  const guardian=await readFile(new URL('../src/remote-session-guardian.mjs',import.meta.url),'utf8');
+  assert.match(guardian,/if\(observerGuard\)/);
+  assert.match(guardian,/if\(!assertObserveOnlyMarker\(marker\)\)/);
+  assert.match(guardian,/deletePinnedRemoteMarker/);
+});
+
+test('R175 observation-only CLI refuses version drift or stale manifest before authority mutation',()=>{
+ const active={version:'0.15.69',manifest_sha256:'a'.repeat(64)};
+ assert.equal(assertMatchingForegroundRelease(active,{version:'0.15.69',manifest_sha256:'a'.repeat(64)}),active);
+ assert.throws(()=>assertMatchingForegroundRelease(active,{version:'0.15.68',manifest_sha256:'a'.repeat(64)}),/EXACT_ACTIVE_RELEASE/);
+ assert.throws(()=>assertMatchingForegroundRelease(active,{version:'0.15.69',manifest_sha256:'b'.repeat(64)}),/EXACT_ACTIVE_RELEASE/);
+ assert.throws(()=>assertMatchingForegroundRelease(null,{version:'0.15.69',manifest_sha256:'a'.repeat(64)}),/EXACT_ACTIVE_RELEASE/);
+});
+
+test('R175 foreground session has no implicit runtime synchronization, startup or restart',async()=>{
+ const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+ const foreground=cli.slice(cli.indexOf('async function runRemoteSession('),cli.indexOf('async function parseRemoteFlags(',cli.indexOf('async function runRemoteSession(')));
+ assert.ok(foreground.length>3500,'R175 foreground extraction incomplete');
+ assert.doesNotMatch(foreground,/await synchronizeForegroundRuntime\(/);
+ assert.doesNotMatch(foreground,/invokeController\(ctx,\s*['"](?:arm|disarm|park|start|restart)/);
+ assert.match(foreground,/R175_FOREGROUND_RUNTIME_NOT_READY/);
+ assert.match(foreground,/R175_FOREGROUND_ACTIVE_DRIFT/);
+ assert.match(foreground,/R175_FOREGROUND_OBSERVE_ONLY/);
+});
+test('R175 standing grants may change during monitoring without implicit revoke',async()=>{
+ const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+ const start=cli.indexOf('async function runRemoteSession(');
+ const authority=cli.slice(start,cli.indexOf('ready=true;',start));
+ assert.doesNotMatch(authority,/assertAuthorityVector\(/);
+ assert.match(authority,/observeOnlyAuthority\(authority\)/);
+ assert.match(authority,/Observing existing grants without ARM or DISARM/);
+});
+
+test('R179 observer never initiates legacy marker reconciliation, epoch mutations or no-marker migration',async()=>{
+ const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+ const start=cli.indexOf('async function runRemoteSession(');
+ const claim=cli.indexOf('marker=await claimRemoteSession(ctx)',start);
+ const section=cli.slice(start,claim);
+ assert.match(section,/if\(staleObserver\)/);
+ assert.match(section,/if\(!assertObserveOnlyMarker\(staleObserver\)\)/);
+ assert.match(section,/R179_LEGACY_FOREGROUND_RECOVERY_REQUIRES_EXPLICIT_OWNER_COMMAND/);
+ assert.doesNotMatch(section,/\n\s*await recoverRemoteSession\(ctx,\{displayMode\}\);\s*\n\s*startupLock/);
+});
+test('R179 guardian cannot downgrade observation-only marker into legacy cleanup',async()=>{
+ const guardian=await readFile(new URL('../src/remote-session-guardian.mjs',import.meta.url),'utf8');
+ const fence=guardian.indexOf('R179_OBSERVER_GUARDIAN_SCOPE_DOWNGRADE');
+ const revoke=guardian.indexOf('for(const command of CLEANUP)');
+ assert.ok(fence>0&&revoke>fence);
+});

package/test/r175-guardian-owner-boundary.test.mjs

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,writeFile,readFile,rm} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const winTest=process.platform==='win32'?test:test.skip;
+const guardian=new URL('../src/remote-session-guardian.mjs',import.meta.url);
+const missing=async path=>assert.rejects(()=>readFile(path),{code:'ENOENT'});
+async function fixture(run,{valid=true,observerArg=true}={}){
+ const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r175-guardian-'));
+ const bin=path.join(dir,'bin'),runtime=path.join(dir,'runtime');
+ await mkdir(bin);await mkdir(runtime);
+ const trace=path.join(dir,'controller.trace'),grant=path.join(runtime,'host-grant.json');
+ const markerPath=path.join(runtime,'remote-session.json');
+ const quote=s=>String(s).replaceAll("'","''");
+ const launcher=`param([string]$Command)
+[IO.File]::AppendAllText('${quote(trace)}',$Command+[Environment]::NewLine)
+exit 0
+`;
+ await writeFile(path.join(bin,'DEADBYTE-MCP.ps1'),launcher);
+ await writeFile(grant,'owner-standing-grant\n');
+ const dead=spawnSync(process.execPath,['-e','process.exit(0)'],{windowsHide:true});
+ assert.equal(dead.status,0);assert.ok(dead.pid>0);
+ const marker={schema:'deadbyte.remote-session.v2',owner_pid:dead.pid,guardian_pid:0,
+ session_nonce:'a'.repeat(64),...(valid?{authority_scope:'observe-only'}:{})};
+ await writeFile(markerPath,JSON.stringify(marker)+'\n');
+ try{
+  const result=spawnSync(process.execPath,[fileURLToPath(guardian),'--state-root',dir,
+   '--owner-pid',String(dead.pid),'--session-nonce',marker.session_nonce,...(observerArg?['--authority-scope','observe-only']:[])],
+   {encoding:'utf8',windowsHide:true,timeout:12000,env:{...process.env,DEADBYTE_STATE_ROOT:dir}});
+  return await run({dir,trace,grant,markerPath,result,marker});
+ }finally{await rm(dir,{recursive:true,force:true});}
+}
+winTest('R175 guardian after owner death removes only observe-only marker and never touches owner grant',()=>fixture(async f=>{
+ assert.equal(f.result.error,undefined,String(f.result.error));
+ assert.equal(f.result.status,0,f.result.stderr);
+ await missing(f.markerPath);
+ await missing(f.trace);
+ assert.equal(await readFile(f.grant,'utf8'),'owner-standing-grant\n');
+}));
+winTest('R175 guardian rejects tampered observer scope without revoking owner grant or removing evidence',()=>fixture(async f=>{
+ assert.notEqual(f.result.status,0,'inherited monitor scope must reject modified marker');
+ await missing(f.trace);
+ assert.deepEqual(JSON.parse(await readFile(f.markerPath,'utf8')),f.marker);
+ assert.equal(await readFile(f.grant,'utf8'),'owner-standing-grant\n');
+},{valid:false}));
+
+winTest('R179 guardian refuses missing observe-only scope flag without revoking owner grants',()=>fixture(async f=>{
+ assert.notEqual(f.result.status,0,'missing guardian scope must fail closed');
+ await missing(f.trace);
+ assert.deepEqual(JSON.parse(await readFile(f.markerPath,'utf8')),f.marker);
+ assert.equal(await readFile(f.grant,'utf8'),'owner-standing-grant\n');
+},{valid:true,observerArg:false}));

package/test/r176-pretty-live-log.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createLiveTimelineTracker,defaultForegroundTimelineOptions} from '../src/remote-live-log.mjs';
+const now=()=>Date.parse('2026-10-27T12:25:56.000Z');
+const fixture=()=>createLiveTimelineTracker({clock:now,...defaultForegroundTimelineOptions({verbose:false})});
+test('R176 normal console uses compact aligned emoji rather than legacy CALL/DONE spam',()=>{
+ const tracker=fixture();
+ const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r176-abc123xyz',args:{root_id:'projects',path:'src/alpha.mjs',token:'SECRET_DO_NOT_PRINT',content:'SECRET_PAYLOAD'}},{sequence:1});
+ assert.match(start,/19:25:56/);assert.match(start,/📝/);assert.match(start,/START/);
+ assert.match(start,/coding_file_write/);
+ assert.doesNotMatch(start,/SECRET_DO_NOT_PRINT|SECRET_PAYLOAD|Received tool call/);
+ const end=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'r176-abc123xyz',outcome:{status:'ok',duration_ms:17,receipt_sha256s:['e'.repeat(64)]}},{sequence:2});
+ assert.match(end,/✅/);assert.match(end,/PASS/);assert.match(end,/17ms/);
+ assert.match(end,/receipt=e{8}/);assert.doesNotMatch(end,/Tool call .*completed/);
+});
+test('R176 heartbeat chatter is folded into a single compact count',()=>{
+ const tracker=fixture();
+ for(let i=0;i<5;i++){
+  tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:'poll-'+i,args:{}},{sequence:i*2+1});
+  tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:'poll-'+i,outcome:{status:'ok',duration_ms:2}},{sequence:i*2+2});
+ }
+ const tail=tracker.reconcileInterrupted();
+ assert.match(tail.join('\n'),/machine_status.*×5/);
+ assert.match(tracker.summary(),/5 calls/);
+ assert.match(tracker.summary(),/folded 4 heartbeat/);
+});
+test('R176 denied or unknown effects are visually distinct and keep reasons',()=>{
+ const tracker=fixture();
+ tracker.observe({event_type:'tool.request',tool:'host_file_read',request_id:'deny-one',args:{root_id:'core',path:'a.mjs'}},{sequence:1});
+ const denied=tracker.observe({event_type:'tool.result',tool:'host_file_read',request_id:'deny-one',outcome:{status:'denied',is_error:true,reason:'arm file missing',duration_ms:1}},{sequence:2});
+ assert.match(denied,/❌|✗/);assert.match(denied,/DENIED|FAIL/);assert.match(denied,/arm file missing/);
+ tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'unknown-one',args:{root_id:'core',path:'x.mjs'}},{sequence:3});
+ const unknown=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'unknown-one',outcome:{status:'interrupted',side_effect_state:'unknown',reason:'after dispatch'}},{sequence:4});
+ assert.match(unknown,/⚠/);assert.match(unknown,/UNKNOWN/);assert.match(unknown,/after dispatch/);
+});
+test('R176 ASCII fallback never emits Unicode graphics in default layout',()=>{
+ const tracker=createLiveTimelineTracker({clock:now,displayMode:'ascii',...defaultForegroundTimelineOptions({verbose:false})});
+ const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'ascii-one',args:{root_id:'core',path:'x.mjs'}},{sequence:1});
+ const done=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'ascii-one',outcome:{status:'ok',duration_ms:6}},{sequence:2});
+ assert.doesNotMatch(start+done,/[^\x20-\x7E\n]/);
+ assert.match(done,/PASS/);
+});
+
+test('R176 session summary is a compact readable multi-line report',()=>{
+ const tracker=fixture();
+ tracker.observe({event_type:'tool.request',request_id:'one',tool:'coding_file_write',args:{root_id:'core',path:'a.mjs'}},{sequence:1});
+ tracker.observe({event_type:'tool.result',request_id:'one',tool:'coding_file_write',outcome:{status:'ok',duration_ms:14}},{sequence:2});
+ const report=tracker.summary();
+ assert.match(report,/📊.*SESSION/i);
+ assert.match(report,/1 calls \| 1 ok/);
+ assert.match(report,/\n.*p50/i);
+ assert.match(report,/\n.*top:/i);
+ assert.doesNotMatch(report,/secret|undefined|NaN/);
+});

package/test/r177-windows-absolute-live-path.test.mjs

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createLiveTimelineTracker,defaultForegroundTimelineOptions} from '../src/remote-live-log.mjs';
+const fixed=()=>Date.parse('2026-10-27T12:25:56.000Z');
+const root='D:\\Projects';
+const relative='deadbyte-mcp\\development\\deadbyte-mcp-0.15.69-r174-owner-consent\\src\\alpha.mjs';
+const exact=root+'\\'+relative;
+function tracker(){return createLiveTimelineTracker({clock:fixed,rootPaths:{projects:root},...defaultForegroundTimelineOptions({verbose:false})});}
+test('R177 prints exact full Windows path under trusted root on START and PASS',()=>{
+ const t=tracker(),id='write-full-path-123';
+ const start=t.observe({event_type:'tool.request',request_id:id,tool:'coding_file_write',args:{root_id:'projects',path:relative}},{sequence:1});
+ assert.ok(start.includes(exact),start);
+ assert.match(start,/\[root=projects\]/);
+ const done=t.observe({event_type:'tool.result',request_id:id,tool:'coding_file_write',outcome:{status:'ok',duration_ms:7}},{sequence:2});
+ assert.ok(done.includes(exact),done);
+ assert.match(done,/PASS/);
+});
+test('R177 no policy mapping means visibly unresolved, never guessed C or D drive',()=>{
+ const t=createLiveTimelineTracker({clock:fixed,rootPaths:{},...defaultForegroundTimelineOptions({verbose:false})});
+ const line=t.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'unmapped-1',args:{root_id:'projects',path:'src/alpha.mjs'}});
+ assert.match(line,/unresolved root/);
+ assert.doesNotMatch(line,/[A-Z]:\\/);
+});
+test('R177 full command script path and move source/destination stay explicit',()=>{
+ const t=tracker();
+ const command=t.observe({event_type:'tool.request',tool:'coding_command_run',request_id:'command-1',args:{root_id:'projects',command_id:'node_script',script_path:relative}});
+ assert.ok(command.includes(exact),command);
+ const move=t.observe({event_type:'tool.request',tool:'machine_fs',request_id:'move-1',args:{op:'move',root_id:'projects',source_path:'deadbyte-mcp/src/a.js',destination_path:'deadbyte-mcp/src/b.js'}});
+ assert.match(move,/FROM.*D:\\Projects\\deadbyte-mcp\\src\\a.js/);
+ assert.match(move,/TO.*D:\\Projects\\deadbyte-mcp\\src\\b.js/);
+});
+test('R177 path traversal is flagged rather than displayed as trusted in-root file',()=>{
+ const t=tracker();
+ const line=t.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'escape-1',args:{root_id:'projects',path:'..\\secrets\\hidden.txt'}});
+ assert.match(line,/outside root=projects/);
+ assert.doesNotMatch(line,/📁 .*\[root=projects\]/);
+});