deadbyte-mcp 0.15.68 → 0.15.69

package/test/r179-absolute-path-live-log.test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createLiveTimelineTracker,defaultForegroundTimelineOptions,summarizeLiveToolArgs} from '../src/remote-live-log.mjs';
+const base=String.raw`D:\Projects`;
+const sub=String.raw`deadbyte-mcp\development\deadbyte-mcp-0.15.69-r174-owner-consent\src\alpha.mjs`;
+const full=String.raw`D:\Projects\deadbyte-mcp\development\deadbyte-mcp-0.15.69-r174-owner-consent\src\alpha.mjs`;
+const env={rootPaths:{projects:base,core:String.raw`C:\Users\DEADBYTE\.deadbyte-mcp\releases\v0.15.68-ff29dbb2fbb89862`}};
+const tracker=()=>createLiveTimelineTracker({clock:()=>Date.parse('2026-10-27T12:25:56.000Z'),...defaultForegroundTimelineOptions({verbose:false}),...env});
+test('R179 absolute Windows file path visible, with root identity, on START and PASS',()=>{
+ const t=tracker();
+ const start=t.observe({event_type:'tool.request',request_id:'win-full-path',tool:'coding_file_write',args:{root_id:'projects',path:sub,content:'safe'}} ,{sequence:1});
+ assert.match(start,/📁|📂/);assert.ok(start.includes(full),start);
+ assert.match(start,/root=projects/);
+ const done=t.observe({event_type:'tool.result',request_id:'win-full-path',tool:'coding_file_write',outcome:{status:'ok',duration_ms:13}},{sequence:2});
+ assert.ok(done.includes(full),done);assert.match(done,/root=projects/);
+ assert.match(done,/PASS/);
+});
+test('R179 Windows PowerShell command script_path uses canonical full path',()=>{
+ const t=tracker();
+ const start=t.observe({event_type:'tool.request',request_id:'script-path',tool:'coding_command_run',args:{root_id:'projects',command_id:'powershell_script',script_path:sub}},{sequence:1});
+ assert.ok(start.includes(full),start);
+ assert.match(start,/powershell_script/);
+});
+test('R179 unknown root fails to invent a drive-letter path',()=>{
+ const str=summarizeLiveToolArgs('coding_file_read',{root_id:'mystery',path:'src/alpha.mjs'},{rootPaths:env.rootPaths});
+ assert.doesNotMatch(str,/[A-Z]:\\/);
+ assert.match(str,/mystery/);
+});
+test('R179 path traversal is not represented as an in-root file',()=>{
+ const str=summarizeLiveToolArgs('coding_file_read',{root_id:'projects',path:'..\\secret.txt'},{rootPaths:env.rootPaths});
+ assert.doesNotMatch(str,/D:\\secret.txt/);
+ assert.match(str,/outside|unresolved|denied/i);
+});
+test('R179 log path presentation keeps tool argument secrets redacted',()=>{
+ const t=tracker();
+ const start=t.observe({event_type:'tool.request',request_id:'secret-path',tool:'coding_file_write',args:{
+   root_id:'projects',path:sub,content:'secret-data',private_key:'DO_NOT_SHOW_KEY'
+ }},{sequence:1});
+ assert.doesNotMatch(start,/secret-data|DO_NOT_SHOW_KEY/);
+});

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

@@ -0,0 +1,62 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {DEADBYTE_VERSION} from '../src/version.mjs';
+import {readReleaseLock} from './helpers/release-lock.mjs';
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const read=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
+const parent='v0.15.68-ff29dbb2fbb89862';
+const manifest='ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885';
+const generation='2887d4a8d54ea6fc6b28869072f72491c892dfe28178b3537936dce958147bd2';
+const tarball='1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf';
+test('R179 version, lockfile, bridge, matrix, SBOM and provenance identify exact 0.15.69 successor',async()=>{
+ const [pkg,lock,bridge,release,provenance,matrix,sbom]=await Promise.all([
+  read('package.json'),readReleaseLock(root),read('bridge/package.json'),read('RELEASE.json'),
+  read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
+ for(const version of [pkg.version,lock.version,lock.packages[''].version,bridge.version,release.version,provenance.version,
+  matrix.version,sbom.metadata.component.version,DEADBYTE_VERSION])assert.equal(version,'0.15.69');
+ assert.equal(release.train,'R179');assert.equal(matrix.train,'R179');
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r179:0.15.69');
+ assert.equal(release.parent.release_id,parent);assert.equal(release.parent.manifest_sha256,manifest);
+ assert.equal(release.parent.generation_manifest_sha256,generation);
+ assert.equal(release.source_predecessor.version,'0.15.68');
+ assert.equal(release.source_predecessor.manifest_sha256,manifest);
+ assert.equal(release.source_predecessor.tarball_sha256,tarball);
+ assert.equal(release.runtime_predecessor.release_id,parent);
+ assert.equal(provenance.runtime_predecessor.release_id,parent);
+ assert.equal(provenance.parent_tarball_sha256,tarball);
+ assert.equal(provenance.source_predecessor_tarball_sha256,tarball);
+});
+test('R179 does not misrepresent owner Autonomous enrollment, protected regression or publication as finished',async()=>{
+ const [release,prov,matrix]=await Promise.all(['RELEASE.json','PROVENANCE.json','TEST-MATRIX.json'].map(read));
+ assert.equal(release.r179.owner_approved_autonomous_grant,'NOT_ISSUED');
+ assert.equal(release.r179.protected_full_regression,'NOT_VERIFIED');
+ assert.equal(release.r179.npm_publish,'NOT_RUN');
+ assert.equal(release.r179.production_activation,'NOT_RUN');
+ assert.equal(release.r179.stable_final_claim,false);
+ assert.equal(prov.r179.independent_owner_enrollment,'NOT_PRESENT');
+ assert.equal(prov.r179.protected_full_regression,'NOT_RUN');
+ assert.equal(matrix.r179.owner_consent,'NOT_VERIFIED');
+ assert.equal(matrix.r179.registry_publish,'NOT_RUN');
+ assert.ok(matrix.required.some(r=>r.id==='r179-owner-authorized-autonomous'));
+ assert.ok(matrix.required.some(r=>r.id==='r179-protected-full'));
+});
+test('R179 retains historical R173 source ancestor evidence without promoting it to current parent',async()=>{
+ const [release,prov]=await Promise.all(['RELEASE.json','PROVENANCE.json'].map(read));
+ assert.equal(release.r173.source_predecessor_version,'0.15.67');
+ assert.equal(release.r173.source_predecessor_manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
+ assert.equal(prov.r173.source_predecessor_version,'0.15.67');
+ assert.equal(release.source_predecessor.version,'0.15.68');
+ assert.notEqual(release.source_predecessor.tarball_sha256,release.r173.source_predecessor_tarball_sha256);
+});
+test('R184 ships a semantic lock snapshot matching installed package identity and dependencies',async()=>{
+ const [pkg,lock,snapshot]=await Promise.all([
+  read('package.json'),readReleaseLock(root),read('docs/R184-package-lock.json')]);
+ assert.deepEqual(snapshot,lock);
+ assert.equal(snapshot.name,pkg.name);
+ assert.equal(snapshot.version,pkg.version);
+ assert.equal(snapshot.packages[''].version,pkg.version);
+ assert.deepEqual(snapshot.packages[''].dependencies,pkg.dependencies);
+});

package/test/r186-controller-owner-grant.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+test('R186 successor Autonomous arm delegates non-legacy issuance to protected owner broker',async()=>{
+ const source=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+ assert.match(source,/function Invoke-R186ProtectedAutonomousGrant/);
+ const arm=/function Arm-Autonomous\(\$Cfg\) \{([\s\S]*?)\n\}/.exec(source)?.[1]??'';
+ assert.match(arm,/Invoke-R186ProtectedAutonomousGrant/);
+ assert.match(arm,/R70_OWNER_ENROLLMENT_REQUIRED/);
+ assert.match(arm,/legacyOwnerPolicySha256/,'legacy compatibility path must remain explicit');
+});
+
+test('R186 protected broker and consent dependencies are exact-byte pinned by controller',async()=>{
+ const source=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+ for(const file of [
+  'scripts\\r186-owner-grant-cli.mjs','src\\r186-owner-grant-broker.mjs',
+  'src\\r186-owner-consent-preflight.mjs','src\\r70-owner-approval.mjs'
+ ])assert.match(source,new RegExp(file.replace(/[.*+?^${}()|[\]\\]/g,'\\$&')));
+});

package/test/r186-owner-consent-preflight.test.mjs

@@ -0,0 +1,98 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,sign} from 'node:crypto';
+import {mkdtemp,rm,realpath} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {verifyR186OwnerConsent,verifyR186PolicyRootBinding} from '../src/r186-owner-consent-preflight.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const domain=Buffer.from('DEADBYTE-R70-PROJECT-OWNER-APPROVAL\0','utf8');
+const H=c=>c.repeat(64);
+async function fixture(){
+ const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r186-consent-'));
+ const real=await realpath(dir);
+ const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+ const owner_key_id=sha(publicKey.export({type:'spki',format:'der'}));
+ const now=new Date();
+ const issued=new Date(now.getTime()-1000).toISOString();
+ const expires=new Date(now.getTime()+120000).toISOString();
+ const expected={rootId:'core',projectRoot:real,codingPolicySha256:H('a'),
+  autonomousPolicySha256:H('b'),reviewedArtifactSha256:H('c')};
+ const subject={schema:'deadbyte.project-authority-subject.r70.v1',scope:'coding_autonomous_native_diff',
+  root_id:expected.rootId,project_root:real,coding_policy_sha256:expected.codingPolicySha256,
+  autonomous_policy_sha256:expected.autonomousPolicySha256,reviewed_artifact_sha256:expected.reviewedArtifactSha256,
+  issued_at_utc:issued,expires_at_utc:expires};
+ const signed={schema:'deadbyte.project-owner-approval.r70.v1',subject_sha256:sha(Buffer.from(canonicalJson(subject))),owner_key_id};
+ const approval={...signed,subject,signature_base64:sign(null,Buffer.concat([domain,Buffer.from(canonicalJson(signed))]),privateKey).toString('base64')};
+ const trust={schema:'deadbyte.r186-owner-anchor.v1',owner_key_id};
+ return {dir,publicKeyPem:publicKey.export({type:'spki',format:'pem'}),expected,approval,trust,now};
+}
+test('R186 independently pinned Ed25519 owner anchor validates the reviewed artifact and produces no grant',async()=>{
+ const f=await fixture();try{
+ const d=await verifyR186OwnerConsent({ownerTrust:f.trust,ownerPublicKeyPem:f.publicKeyPem,
+  approval:f.approval,expected:f.expected,now:f.now});
+ assert.equal(d.status,'verified_readonly');
+ assert.equal(d.authority_granted,false);
+ assert.equal(d.root_id,'core');
+ assert.equal(d.owner_key_id,f.trust.owner_key_id);
+ }finally{await rm(f.dir,{recursive:true,force:true});}
+});
+test('R186 cannot self-enroll an alternate key or swap in a signer-provided key anchor',async()=>{
+ const f=await fixture();try{
+ const rogue=generateKeyPairSync('ed25519');
+ await assert.rejects(verifyR186OwnerConsent({ownerTrust:f.trust,
+  ownerPublicKeyPem:rogue.publicKey.export({type:'spki',format:'pem'}),
+  approval:f.approval,expected:f.expected,now:f.now}),/owner anchor|owner key/i);
+ await assert.rejects(verifyR186OwnerConsent({ownerTrust:{...f.trust,override:true},
+  ownerPublicKeyPem:f.publicKeyPem,approval:f.approval,expected:f.expected,now:f.now}),/owner anchor/i);
+ }finally{await rm(f.dir,{recursive:true,force:true});}
+});
+test('R186 fail closed on artifact, policy, root or expiry drift without granting authority',async()=>{
+ const f=await fixture();try{
+ for(const changed of [
+  {reviewedArtifactSha256:H('d')},{codingPolicySha256:H('e')},
+  {autonomousPolicySha256:H('f')},{rootId:'projects'}
+ ]){
+  await assert.rejects(verifyR186OwnerConsent({ownerTrust:f.trust,
+   ownerPublicKeyPem:f.publicKeyPem,approval:f.approval,
+   expected:{...f.expected,...changed},now:f.now}),/owner approval/i);
+ }
+ await assert.rejects(verifyR186OwnerConsent({ownerTrust:f.trust,
+   ownerPublicKeyPem:f.publicKeyPem,approval:f.approval,
+   expected:f.expected,now:new Date(f.now.getTime()+180000)}),/expired/i);
+ }finally{await rm(f.dir,{recursive:true,force:true});}
+});
+
+test('R186 CLI has no usable enrollment or grant path from writable source',async()=>{
+ const {spawnSync}=await import('node:child_process');
+ const {fileURLToPath}=await import('node:url');
+ const result=spawnSync(process.execPath,[fileURLToPath(new URL('../scripts/r186-owner-consent-check.mjs',import.meta.url)),
+  'C:\\approval.json','core','D:\\Projects\\deadbyte-mcp','C:\\coding.json','C:\\autonomous.json'],{
+   cwd:process.cwd(),encoding:'utf8',windowsHide:true,timeout:18000
+  });
+ // A read-only preview is not a privileged grant, including on CLI failure.
+ assert.equal(result.status,2,'R186 CLI must execute and reject, not fail to resolve its module');
+ assert.match(String(result.stderr),/R186_OWNER_PREFLIGHT_BLOCKED/);
+ assert.doesNotMatch(String(result.stderr),/ERR_MODULE_NOT_FOUND/);
+ assert.doesNotMatch(String(result.stdout),/authority_granted":true/);
+});
+
+test('R186 validates actual Coding root map and Autonomous root vector before owner approval',()=>{
+ const root='D:\\Projects\\deadbyte-mcp';
+ const coding={schema:'deadbyte.coding-policy.v1',enabled:true,
+  roots:{core:{path:root,read:true,write:true,exec:true}}};
+ const autonomous={schema:'deadbyte.autonomous-policy.v1',enabled:true,
+  root_ids:['core'],coding_policy_sha256:H('a')};
+ const input={codingPolicy:coding,autonomousPolicy:autonomous,rootId:'core',projectRoot:root,
+  codingPolicySha256:H('a')};
+ assert.equal(verifyR186PolicyRootBinding(input).root_id,'core');
+ assert.throws(()=>verifyR186PolicyRootBinding({...input,projectRoot:'D:\\Other'}),/R186/i);
+ assert.throws(()=>verifyR186PolicyRootBinding({...input,
+  autonomousPolicy:{...autonomous,root_ids:['core','projects']}}),/R186/i);
+ assert.throws(()=>verifyR186PolicyRootBinding({...input,
+  autonomousPolicy:{...autonomous,coding_policy_sha256:H('b')}}),/R186/i);
+ assert.throws(()=>verifyR186PolicyRootBinding({...input,
+  codingPolicy:{...coding,roots:{core:{...coding.roots.core,path:'C:\\'}}}}),/R186/i);
+});

package/test/r186-owner-enrollment.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync} from 'node:crypto';
+import {createR186OwnerAnchor} from '../src/r186-owner-anchor.mjs';
+
+test('R186 enrollment material contains only an Ed25519 public identity',()=>{
+ const pair=generateKeyPairSync('ed25519');
+ const out=createR186OwnerAnchor(pair.publicKey.export({type:'spki',format:'pem'}));
+ assert.equal(out.anchor.schema,'deadbyte.r186-owner-anchor.v1');
+ assert.match(out.anchor.owner_key_id,/^[0-9a-f]{64}$/);
+ assert.match(out.public_key_pem,/BEGIN PUBLIC KEY/);
+ assert.doesNotMatch(JSON.stringify(out),/PRIVATE KEY/);
+});
+
+test('R186 enrollment rejects non-Ed25519 and private-key input',()=>{
+ const rsa=generateKeyPairSync('rsa',{modulusLength:2048});
+ assert.throws(()=>createR186OwnerAnchor(rsa.publicKey.export({type:'spki',format:'pem'})),/Ed25519/i);
+ const ed=generateKeyPairSync('ed25519');
+ assert.throws(()=>createR186OwnerAnchor(ed.privateKey.export({type:'pkcs8',format:'pem'})),/public/i);
+});

package/test/r186-owner-grant-broker.test.mjs

@@ -0,0 +1,85 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,sign} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,rm,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {issueR186AutonomousGrant} from '../src/r186-owner-grant-broker.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const domain=Buffer.from('DEADBYTE-R70-PROJECT-OWNER-APPROVAL\0','utf8');
+async function fixture(){
+ const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r186-broker-'));
+ const project=path.join(state,'project');await mkdir(project);
+ const grantFile=path.join(state,'runtime','autonomous-grant.json');
+ const codingPolicy={schema:'deadbyte.coding-policy.v1',enabled:true,
+  roots:{core:{path:project,read:true,write:true,exec:true,deny_paths:[]}}};
+ const codingBytes=Buffer.from(JSON.stringify(codingPolicy));
+ const autonomousPolicy={schema:'deadbyte.autonomous-policy.v1',enabled:true,
+  lease_file:grantFile,evidence_dir:path.join(state,'evidence'),coding_policy_sha256:sha(codingBytes),
+  root_ids:['core'],planner:{},limits:{},profiles:{}};
+ const autonomousBytes=Buffer.from(JSON.stringify(autonomousPolicy));
+ const manifestBytes=Buffer.from('manifest fixture');
+ const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+ const machine=generateKeyPairSync('ed25519');
+ await mkdir(path.join(state,'trust'));
+ await writeFile(path.join(state,'trust','ed25519-private.pem'),machine.privateKey.export({type:'pkcs8',format:'pem'}));
+ await writeFile(path.join(state,'trust','ed25519-public.pem'),machine.publicKey.export({type:'spki',format:'pem'}));
+ const owner_key_id=sha(publicKey.export({type:'spki',format:'der'}));
+ const now=new Date('2026-10-28T00:00:00.000Z');
+ const subject={schema:'deadbyte.project-authority-subject.r70.v1',scope:'coding_autonomous_native_diff',
+  root_id:'core',project_root:project,coding_policy_sha256:sha(codingBytes),
+  autonomous_policy_sha256:sha(autonomousBytes),reviewed_artifact_sha256:sha(manifestBytes),
+  issued_at_utc:now.toISOString(),expires_at_utc:new Date(now.getTime()+300000).toISOString()};
+ const subject_sha256=sha(Buffer.from(canonicalJson(subject)));
+ const signed={schema:'deadbyte.project-owner-approval.r70.v1',subject_sha256,owner_key_id};
+ const approval={...signed,subject,signature_base64:sign(null,Buffer.concat([domain,Buffer.from(canonicalJson(signed))]),privateKey).toString('base64')};
+ const trust={schema:'deadbyte.r186-owner-anchor.v1',owner_key_id};
+ const publicPem=publicKey.export({type:'spki',format:'pem'});
+ const epoch={head:null,calls:0,async readHead(){return this.head;},async append({grantBytes,grantInstanceNonce}){
+   this.calls++;this.head={seq:1,action:'grant',event_sha256:'e'.repeat(64),grant_sha256:sha(grantBytes),grant_instance_nonce:grantInstanceNonce};return this.head;
+ },async verifyGrant({grantBytes,grantInstanceNonce}){return {trusted:this.head?.grant_sha256===sha(grantBytes)&&this.head?.grant_instance_nonce===grantInstanceNonce,reason:'epoch-bound-standing-grant',event_sha256:this.head?.event_sha256,seq:1,action:'grant'};}};
+ return {state,project,grantFile,codingPolicy,codingBytes,autonomousPolicy,autonomousBytes,manifestBytes,
+  trust,publicPem,approval,now,epoch};
+}
+const run=(f,extra={})=>issueR186AutonomousGrant({runtimeDir:path.join(f.state,'runtime'),grantFile:f.grantFile,
+ codingPolicy:f.codingPolicy,codingPolicyBytes:f.codingBytes,autonomousPolicy:f.autonomousPolicy,
+ autonomousPolicyBytes:f.autonomousBytes,releaseManifestBytes:f.manifestBytes,ownerTrust:f.trust,
+ ownerPublicKeyPem:f.publicPem,approval:f.approval,now:f.now,epochStore:f.epoch,...extra});
+
+test('R186 broker consumes exact owner approval once and verifies grant plus signed epoch',async()=>{
+ const f=await fixture();try{const out=await run(f);
+  assert.equal(out.status,'GRANTED');assert.equal(out.authority_granted,true);assert.equal(f.epoch.calls,1);
+  const grant=JSON.parse(await readFile(f.grantFile,'utf8'));
+  assert.deepEqual(grant.root_ids,['core']);assert.equal(grant.policy_sha256,sha(f.autonomousBytes));
+  assert.equal(out.epoch_event_sha256,'e'.repeat(64));
+  const terminal=JSON.parse(await readFile(out.terminal_path,'utf8'));
+  assert.equal(terminal.attestation.domain,'DEADBYTE-R186-OWNER-GRANT-TERMINAL');
+  assert.match(terminal.receipt_sha256,/^[0-9a-f]{64}$/);
+  await assert.rejects(run(f),/already consumed|replay/i);assert.equal(f.epoch.calls,1);
+ }finally{await rm(f.state,{recursive:true,force:true});}
+});
+
+test('R186 broker fails closed before mutation on missing enrollment, drift and expiry',async()=>{
+ const f=await fixture();try{
+  for(const override of [
+   {ownerTrust:null},
+   {releaseManifestBytes:Buffer.from('changed')},
+   {now:new Date(f.now.getTime()+600000)}
+  ]){
+   const isolated=await fixture();try{await assert.rejects(run(isolated,override),/R186|owner|artifact|expired|anchor/i);
+    await assert.rejects(readFile(isolated.grantFile),{code:'ENOENT'});assert.equal(isolated.epoch.calls,0);
+   }finally{await rm(isolated.state,{recursive:true,force:true});}
+  }
+ }finally{await rm(f.state,{recursive:true,force:true});}
+});
+
+test('R186 concurrent broker attempts produce one grant and one epoch mutation',async()=>{
+ const f=await fixture();try{
+  const results=await Promise.allSettled([run(f),run(f)]);
+  assert.equal(results.filter(x=>x.status==='fulfilled').length,1);
+  assert.equal(results.filter(x=>x.status==='rejected').length,1);
+  assert.equal(f.epoch.calls,1);
+ }finally{await rm(f.state,{recursive:true,force:true});}
+});

package/test/r186-owner-local-signing.test.mjs

@@ -0,0 +1,30 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync} from 'node:crypto';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createR186OwnerApproval} from '../src/r186-owner-local-signing.mjs';
+import {verifyR186OwnerConsent} from '../src/r186-owner-consent-preflight.mjs';
+
+test('R186 local owner signer signs only an exact review request and verifies with public identity',async()=>{
+ const pair=generateKeyPairSync('ed25519');
+ const now=new Date();
+ const subject={schema:'deadbyte.project-authority-subject.r70.v1',scope:'coding_autonomous_native_diff',root_id:'core',
+  project_root:process.cwd(),coding_policy_sha256:'a'.repeat(64),autonomous_policy_sha256:'b'.repeat(64),
+  reviewed_artifact_sha256:'c'.repeat(64),issued_at_utc:now.toISOString(),expires_at_utc:new Date(now.getTime()+300000).toISOString()};
+ const request={schema:'deadbyte.r186-owner-review-request.v1',subject,
+  subject_sha256:createHash('sha256').update(Buffer.from(canonicalJson(subject))).digest('hex'),owner_signature_present:false,authority_granted:false};
+ const privatePem=pair.privateKey.export({type:'pkcs8',format:'pem'});
+ const approval=createR186OwnerApproval({request,privateKeyPem:privatePem});
+ const publicPem=pair.publicKey.export({type:'spki',format:'pem'});
+ const keyId=approval.owner_key_id;
+ const checked=await verifyR186OwnerConsent({ownerTrust:{schema:'deadbyte.r186-owner-anchor.v1',owner_key_id:keyId},
+  ownerPublicKeyPem:publicPem,approval,now,expected:{rootId:'core',projectRoot:process.cwd(),
+  codingPolicySha256:'a'.repeat(64),autonomousPolicySha256:'b'.repeat(64),reviewedArtifactSha256:'c'.repeat(64)}});
+ assert.equal(checked.subject_sha256,approval.subject_sha256);
+});
+
+test('R186 local owner signer rejects private-key material embedded in request',()=>{
+ const pair=generateKeyPairSync('ed25519');
+ assert.throws(()=>createR186OwnerApproval({request:{private_key:'forbidden'},
+  privateKeyPem:pair.privateKey.export({type:'pkcs8',format:'pem'})}),/request/i);
+});

package/test/r186-owner-request.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createR186OwnerReviewRequest} from '../src/r186-owner-request.mjs';
+const H=c=>c.repeat(64);
+const parameters={rootId:'core',projectRoot:'D:\\Projects\\deadbyte-mcp',
+ codingPolicySha256:H('a'),autonomousPolicySha256:H('b'),reviewedArtifactSha256:H('c'),
+ now:new Date('2026-10-28T01:00:00.000Z'),durationMs:600000};
+test('R186 request previews a bounded exact R70 subject, never an approval or grant',()=>{
+ const request=createR186OwnerReviewRequest(parameters);
+ assert.equal(request.schema,'deadbyte.r186-owner-review-request.v1');
+ assert.equal(request.authority_granted,false);
+ assert.equal(request.owner_signature_present,false);
+ assert.equal(request.subject.schema,'deadbyte.project-authority-subject.r70.v1');
+ assert.equal(request.subject.expires_at_utc,'2026-10-28T01:10:00.000Z');
+ assert.equal(request.subject.coding_policy_sha256,H('a'));
+ assert.equal(request.subject.autonomous_policy_sha256,H('b'));
+ assert.equal(request.subject.reviewed_artifact_sha256,H('c'));
+ assert.match(request.subject_sha256,/^[0-9a-f]{64}$/);
+});
+test('R186 request rejects excessive duration, bad roots and fabricated policy digests',()=>{
+ for(const changed of [
+  {durationMs:0},{durationMs:3600001},{durationMs:-1},
+  {rootId:'../core'},{projectRoot:'relative'},
+  {codingPolicySha256:H('x')},
+  {autonomousPolicySha256:'0'.repeat(63)}]){
+  assert.throws(()=>createR186OwnerReviewRequest({...parameters,...changed}),/R186/);
+ }
+});

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/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'].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'/);