deadbyte-mcp 0.15.68 → 0.15.70

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\]/);
+});

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('R190 version, lock snapshot, bridge, matrix, SBOM and provenance identify exact 0.15.70 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.70');
+ assert.equal(release.train,'R190');assert.equal(matrix.train,'R190');
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r190:0.15.70');
+ 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.69');
+ assert.equal(release.source_predecessor.manifest_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
+ assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
+ assert.equal(release.runtime_predecessor.release_id,parent);
+ assert.equal(provenance.runtime_predecessor.release_id,parent);
+ assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
+ assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+});
+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('R190 retains historical R179 and R173 source 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.69');
+ 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/);
+ }
+});