deadbyte-mcp 0.15.44 → 0.15.46

package/test/r69-live-outcome.test.mjs

@@ -0,0 +1,137 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import {classifyRemoteAuditOutcome,createLiveTimelineTracker,createLiveTimelineFilter,createLiveTimelineWriter,formatCompactAuditEvent} from '../src/remote-live-log.mjs';
+
+function pair(status,is_error=false,side_effect_state=null){
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii',rootPaths:{local_d:'D:\\'}});
+  const args={root_id:'local_d',path:'TECHNICAL/ProgramingLangPJ/tmp/gfx_r3_dev/runtime/gfx/dbyte_gfx3d.dby'};
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-example-1',args});
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'r69-example-1',
+    outcome:{status,is_error,side_effect_state,duration_ms:1}});
+  return {tracker,start,done};
+}
+
+test('R69 failed, denied and observed_failure never produce a false SUCCEEDED line',()=>{
+  for(const status of ['failed','denied','rejected','blocked','observed_failure','cancelled']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/ERR  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED|\bOK\b/,status);
+    assert.match(tracker.summary(),/0 ok \| 1 error/,status);
+  }
+});
+
+test('R69 unavailable and unsupported result envelopes never print mutation SUCCEEDED',()=>{
+  for(const status of ['unavailable','unsupported']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/ERR  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED/,status);
+    assert.match(tracker.summary(),/0 ok \| 1 error/,status);
+  }
+});
+
+test('R69 pending tool result requires continuation, never implies effect committed',()=>{
+  for(const status of ['pending','running','input_required','paused','processing','accepted']){
+    const {tracker,done}=pair(status);
+    assert.match(done,/PENDING  status=/,status);
+    assert.doesNotMatch(done,/SUCCEEDED|\bOK\b/,status);
+    assert.match(tracker.summary(),/0 ok \| 0 errors \| 0 unknown \| 1 pending/,status);
+  }
+});
+
+test('R69 unknown side-effect outranks every status; no retry claim',()=>{
+  const {done,tracker}=pair('committed',false,'unknown');
+  assert.match(done,/FAILED_AFTER_UNKNOWN_EFFECT/);
+  assert.match(tracker.summary(),/1 unknown/);
+});
+
+test('R69 human console always retains the operation location in terminal result',()=>{
+  const {start,done}=pair('denied');
+  const absolute='D:\\TECHNICAL\\ProgramingLangPJ\\tmp\\gfx_r3_dev\\runtime\\gfx\\dbyte_gfx3d.dby [root=local_d]';
+  assert.ok(start.includes(absolute));
+  assert.ok(done.includes(absolute));
+  assert.match(done,/ERR  status=denied/);
+  assert.doesNotMatch(done,/SUCCEEDED/);
+});
+
+test('R69 compact audit flags status failure or pending even with is_error=false',()=>{
+  assert.match(formatCompactAuditEvent({event_type:'tool.result',tool:'host_exec',outcome:{is_error:false,status:'denied'}}),/ERR/);
+  assert.match(formatCompactAuditEvent({event_type:'tool.result',tool:'host_exec',outcome:{is_error:false,status:'input_required'}}),/PENDING/);
+});
+
+test('R69 TTY writer obeys runtime terminal resize without rewriting a wrapped start line',()=>{
+  const writes=[];
+  const stream={isTTY:true,columns:32,write(value){writes.push(value);return true;}};
+  const writer=createLiveTimelineWriter({stream,displayMode:'ascii'});
+  writer.write('START',{event_type:'tool.call',request_id:'resize'});
+  stream.columns=5;
+  writer.write('TOO LONG RESULT',{event_type:'tool.result',request_id:'resize'});
+  assert.deepEqual(writes,['START','\n','TOO LONG RESULT\n']);
+  assert.equal(writer.pending(),null);
+  stream.columns=80;
+  writer.write('RUN',{event_type:'tool.call',request_id:'wide'});
+  writer.write('OK',{event_type:'tool.result',request_id:'wide'});
+  assert.equal(writes.at(-1),'\r\x1b[2KOK\n');
+});
+
+
+test('R69 live latency uses fractional milliseconds instead of printing a false 0ms',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:'subms'});
+  const done=tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:'subms',
+    outcome:{is_error:false,duration_ms:0.125}});
+  assert.ok(done.includes('0.125ms'));
+  assert.doesNotMatch(done,/ 0ms /);
+});
+
+test('R69 latency summary includes p99 and discloses bounded sample coverage',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  for(let i=1;i<=100;i++){
+    const id='sample-'+i;
+    tracker.observe({event_type:'tool.request',tool:'machine_status',request_id:id});
+    tracker.observe({event_type:'tool.result',tool:'machine_status',request_id:id,
+      outcome:{is_error:false,duration_ms:i}});
+  }
+  const summary=tracker.summary();
+  assert.ok(summary.includes('p50 51ms'));
+  assert.ok(summary.includes('p95 95ms'));
+  assert.ok(summary.includes('p99 99ms'));
+  assert.ok(summary.includes('sample 100/100'));
+});
+
+test('R69 filter matches status-only errors independent of is_error=false',()=>{
+  const filter=createLiveTimelineFilter('status=error');
+  filter.accept({event_type:'tool.request',tool:'host_exec',request_id:'r69-e',args:{}});
+  assert.equal(filter.accept({event_type:'tool.result',tool:'host_exec',request_id:'r69-e',outcome:{status:'denied',is_error:false}}),true);
+});
+
+test('R69 mismatched terminal tool cannot inherit a mutating START or claim success',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-mismatch',args:{root_id:'core',path:'scratch.txt'}});
+  assert.match(start,/START/);
+  const terminal=tracker.observe({event_type:'tool.result',tool:'machine_ping',request_id:'r69-mismatch',
+    outcome:{status:'ok',is_error:false,duration_ms:1,receipt_sha256s:['a'.repeat(64)]}});
+  assert.match(terminal,/CORRELATION_MISMATCH/);
+  assert.doesNotMatch(terminal,/SUCCEEDED|RECEIPT=/);
+  assert.match(tracker.summary(),/0 ok \| 0 errors \| 1 unknown/);
+});
+
+test('R69 status filter cannot hide a mismatched terminal identity as successful',()=>{
+  const unknown=createLiveTimelineFilter('status=unknown');
+  unknown.accept({event_type:'tool.request',tool:'coding_file_write',request_id:'r69-filter-mismatch',args:{}});
+  assert.equal(unknown.accept({event_type:'tool.result',tool:'machine_ping',request_id:'r69-filter-mismatch',
+    outcome:{status:'ok',is_error:false}}),true);
+});
+
+test('R69 remote replay projection does not record unavailable as ok or input_required as complete',async()=>{
+  const source=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  const start=source.indexOf('function auditTimelineRecord(');
+  const end=source.indexOf('async function replayRemoteResults(',start);
+  assert.ok(start>=0&&end>start);
+  const record=new Function('createHash','parseAuditLogLine','classifyRemoteAuditOutcome',`${source.slice(start,end)};return auditTimelineRecord;`)(createHash,()=>null,classifyRemoteAuditOutcome);
+  const base={event_type:'tool.result',request_id:'r69-projection',tool:'coding_file_write',ts:'2026-10-13T00:00:00.000Z'};
+  assert.equal(record('audit.log','bounded-line',{...base,outcome:{status:'unavailable',is_error:false}}).status,'error');
+  assert.equal(record('audit.log','bounded-line',{...base,outcome:{status:'input_required',is_error:false}}).status,'pending');
+});
+

package/test/r70-autonomous-grant-expiry.test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import * as auto from '../src/autonomous-policy.mjs';
+
+const H=c=>c.repeat(64);
+const controller=new URL('../controller/deadbyte-controller.ps1',import.meta.url);
+const quote=s=>`'${String(s).replaceAll("'","''")}'`;
+const issued=Date.parse('2026-10-13T03:00:00.000Z');
+const when=n=>new Date(issued+n).toISOString();
+
+test('R70 signed standing grant expiry is bounded, canonical and fail-closed before authority decision',()=>{
+  assert.equal(typeof auto.inspectAutonomousStandingWindow,'function');
+  const base={granted_at_utc:when(0),expires_at_utc:when(1_800_000)};
+  assert.deepEqual(auto.inspectAutonomousStandingWindow(base,new Date(when(300_000))),
+    {ok:true,reason:null,expires_at_utc:when(1_800_000),remaining_ms:1_500_000});
+  for(const [claim,reason,now] of [
+    [{...base,expires_at_utc:when(0)},'expiry-window-invalid',when(30_000)],
+    [{...base,expires_at_utc:when(3_600_001)},'expiry-window-invalid',when(30_000)],
+    [{...base,expires_at_utc:'bad'},'expiry-invalid',when(30_000)],
+    [{...base,expires_at_utc:when(1_800_000)},'expired',when(1_800_000)],
+    [{...base,granted_at_utc:when(700_000)},'not-yet-valid',when(300_000)]
+  ]){
+    const result=auto.inspectAutonomousStandingWindow(claim,new Date(now));
+    assert.equal(result.ok,false);
+    assert.equal(result.reason,reason);
+  }
+  assert.deepEqual(auto.inspectAutonomousStandingWindow({granted_at_utc:when(0)},new Date(when(300_000))),
+    {ok:true,reason:null,expires_at_utc:null,remaining_ms:null});
+});
+
+test('R70 runtime rejects a v2 grant whose Coding policy digest is missing or stale',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-coding-lease-'));
+  const leaseFile=path.join(root,'grant.json');
+  try{
+    const policy={policy_sha256:H('a'),coding_policy_sha256:H('b'),root_ids:['core'],
+      lease_file:leaseFile,policy_path:path.join(root,'autonomous-policy.json')};
+    const base={schema:'deadbyte.autonomous-grant.v2',policy_sha256:H('a'),
+      instance_nonce:H('c'),root_ids:['core'],granted_at_utc:when(0),
+      expires_at_utc:when(1_800_000)};
+    for(const candidate of [{...base,coding_policy_sha256:H('d')},base]){
+      await writeFile(leaseFile,JSON.stringify(candidate));
+      const status=await auto.autonomousSessionStatus(policy,new Date(when(300_000)));
+      assert.equal(status.armed,false);
+      assert.equal(status.reason,'coding-policy-digest');
+      await assert.rejects(auto.recheckAutonomousAuthority(policy,{
+        armed:true,instance_nonce:H('c'),root_ids:['core'],standing:true,expires_at_utc:when(1_800_000)
+      },'core',new Date(when(300_000))),/coding-policy-digest/);
+    }
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 controller must agree with runtime on expired and malformed signed standing grant',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-grant-expiry-'));
+  const grantFile=path.join(root,'autonomous-grant.json');
+  try{
+    const scriptText=await readFile(controller,'utf8');
+    const start=scriptText.indexOf('function Get-AutonomousLeaseStatus(');
+    const end=scriptText.indexOf('function Arm-Autonomous(',start);
+    assert.ok(start>=0&&end>start);
+    const block=scriptText.slice(start,end);
+    const now=Date.now();
+    const records=[
+      {name:'expired',grant:new Date(now-3_600_000),expires:new Date(now-1_800_000),reason:'expired',armed:false},
+      {name:'oversized',grant:new Date(now-300_000),expires:new Date(now+7_200_000),reason:'expiry-window-invalid',armed:false},
+      {name:'valid',grant:new Date(now-300_000),expires:new Date(now+900_000),reason:'standing-grant',armed:true}
+    ];
+    for(const c of records){
+      const lease={schema:'deadbyte.autonomous-grant.v2',policy_sha256:H('a'),coding_policy_sha256:H('b'),
+        instance_nonce:H('c'),root_ids:['core'],granted_at_utc:c.grant.toISOString(),
+        expires_at_utc:c.expires.toISOString()};
+      await writeFile(grantFile,JSON.stringify(lease));
+      const script=`$ErrorActionPreference='Stop';
+function Get-AutonomousPolicyMetadata($Cfg){return [pscustomobject]@{LeaseFile=${quote(grantFile)};Sha256='${H('a')}';CodingPolicySha256='${H('b')}';RootIds=@('core')}}
+function Get-CodingLeaseStatus($Cfg){return [pscustomobject]@{Armed=$true;RootIds=@('core')}}
+function Get-AuthorityEpochStatus($Cfg,$Plane,$File,$Nonce){return [pscustomobject]@{Trusted=$true;Seq=1;EventSha256='${H('d')}'}}
+${block}
+(Get-AutonomousLeaseStatus @{AutonomousPolicyFile='test-fixture'})|ConvertTo-Json -Compress`;
+      const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+      assert.equal(result.status,0,result.stderr);
+      const out=JSON.parse(result.stdout.trim());
+      assert.equal(out.Armed,c.armed,c.name);
+      assert.equal(out.Reason,c.reason,c.name);
+    }
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/r70-autonomous-policy-bootstrap.test.mjs

@@ -0,0 +1,166 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,sign} from 'node:crypto';
+import {mkdir,mkdtemp,readFile,realpath,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as update from '../src/runtime-update.mjs';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {loadAutonomousPolicy} from '../src/autonomous-policy.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const baseArgs=['--stage','stage','--development-root','dev','--expected-version','0.15.45',
+  '--expected-manifest','a'.repeat(64)];
+
+test('R70 autonomous policy bootstrap is an exact path and SHA pair',()=>{
+  assert.throws(()=>update.parseUpdateArgs([...baseArgs,'--autonomous-policy','policy.json']),/autonomous policy bootstrap requires path plus SHA-256/);
+  assert.throws(()=>update.parseUpdateArgs([...baseArgs,'--autonomous-policy-sha256','a'.repeat(64)]),/autonomous policy bootstrap requires path plus SHA-256/);
+  const parsed=update.parseUpdateArgs([...baseArgs,'--autonomous-policy','policy.json','--autonomous-policy-sha256','b'.repeat(64),
+    '--owner-approval','approval.json','--owner-approval-sha256','c'.repeat(64)]);
+  assert.deepEqual(parsed.autonomousPolicyBootstrap,{path:path.resolve('policy.json'),sha256:'b'.repeat(64)});
+  assert.deepEqual(parsed.ownerApprovalBootstrap,{path:path.resolve('approval.json'),sha256:'c'.repeat(64)});
+});
+
+test('R70 autonomous policy bootstrap cannot be parsed without pinned owner approval',()=>{
+  assert.throws(()=>update.parseUpdateArgs([...baseArgs,'--autonomous-policy','policy.json',
+    '--autonomous-policy-sha256','b'.repeat(64)]),/owner approval/i);
+  assert.throws(()=>update.parseUpdateArgs([...baseArgs,'--owner-approval','approval.json',
+    '--owner-approval-sha256','c'.repeat(64)]),/autonomous policy/i);
+});
+
+test('R70 pinned autonomous policy rejects changed bytes and roots outside Coding policy',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-policy-'));
+  try{
+    const file=path.join(root,'autonomous-policy.json');
+    const bytes=Buffer.from(JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(root,'grant.json'),evidence_dir:path.join(root,'evidence'),
+      coding_policy_sha256:'a'.repeat(64),root_ids:['gfx_project'],planner:{backend:'client_sampling',max_tokens:2048},
+      profiles:{},limits:{max_files_per_diff:8}}));
+    await writeFile(file,bytes);
+    const pinned={path:file,sha256:sha(bytes)};
+    const prepared=await update.prepareAutonomousPolicyBootstrap(pinned);
+    assert.deepEqual(prepared.policy.root_ids,['gfx_project']);
+    assert.doesNotThrow(()=>update.assertAutonomousBootstrapRoots(prepared.policy,{roots:{gfx_project:{path:root}}},'a'.repeat(64)));
+    assert.throws(()=>update.assertAutonomousBootstrapRoots(prepared.policy,{roots:{core:{path:root}}},'a'.repeat(64)),/outside selected coding policy/);
+    assert.throws(()=>update.assertAutonomousBootstrapRoots(prepared.policy,{roots:{gfx_project:{path:root}}},'b'.repeat(64)),/coding policy SHA-256 mismatch/);
+    await writeFile(file,Buffer.concat([bytes,Buffer.from('\n')]));
+    await assert.rejects(update.prepareAutonomousPolicyBootstrap(pinned),/SHA-256 mismatch/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 selected autonomous root must resolve to an existing real directory before update mutation',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-realroot-'));
+  try{
+    const policy={root_ids:['gfx_project'],coding_policy_sha256:'a'.repeat(64)};
+    assert.throws(()=>update.assertAutonomousBootstrapRoots(policy,{roots:{gfx_project:{path:path.join(root,'missing')}}},'a'.repeat(64)),/real directory/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 autonomous bootstrap cannot treat a whole drive as a project root',()=>{
+  if(process.platform!=='win32') return;
+  const drive=path.parse('D:\\').root;
+  const policy={root_ids:['local_d'],coding_policy_sha256:'a'.repeat(64)};
+  assert.throws(()=>update.assertAutonomousBootstrapRoots(policy,{roots:{local_d:{path:drive}}},'a'.repeat(64)),/project-scoped root/);
+});
+
+test('R70 project bootstrap rejects a Coding policy that still exposes a whole drive',async()=>{
+  if(process.platform!=='win32') return;
+  const project=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-narrow-policy-'));
+  try{
+    const autonomous={root_ids:['gfx_project'],coding_policy_sha256:'a'.repeat(64)};
+    const coding={roots:{
+      gfx_project:{path:project,read:true,write:true,exec:false,deny_paths:[]},
+      local_c:{path:'C:\\',read:true,write:true,exec:true,deny_paths:[]}
+    }};
+    assert.throws(()=>update.assertAutonomousBootstrapRoots(autonomous,coding,'a'.repeat(64)),/coding policy contains a broad filesystem root/);
+  }finally{await rm(project,{recursive:true,force:true});}
+});
+
+test('R70 pinned JSON hash and parsed policy come from one read',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-single-read-'));
+  try{
+    const file=path.join(root,'policy.json');
+    const approved=Buffer.from('{"schema":"approved"}');
+    const replacement=Buffer.from('{"schema":"replacement"}');
+    await writeFile(file,approved);
+    let reads=0;
+    const prepared=await update.readPinnedJsonPolicy({path:file,sha256:sha(approved)},'test policy',async()=>{
+      reads++;
+      return reads===1?approved:replacement;
+    });
+    assert.equal(reads,1);
+    assert.equal(prepared.sha256,sha(approved));
+    assert.equal(prepared.policy.schema,'approved');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 preflight and runtime reject profiles outside approved Autonomous roots',async()=>{
+  const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-profile-scope-'));
+  try{
+    const project=path.join(state,'project'),other=path.join(state,'other');
+    await mkdir(project);await mkdir(other);
+    const digest='a'.repeat(64);
+    const codingPolicy={policy_sha256:digest,roots:{gfx_project:{path:project},other_project:{path:other}},
+      commands:{script:{}}};
+    const bad={schema:'deadbyte.autonomous-policy.v1',enabled:true,lease_file:path.join(state,'grant.json'),
+      evidence_dir:path.join(state,'evidence'),coding_policy_sha256:digest,root_ids:['gfx_project'],
+      planner:{backend:'client_sampling',max_tokens:2048},
+      profiles:{unsafe:{kind:'command',root_id:'other_project',command_id:'script',
+        script_path:'verify.ps1',script_sha256:'f'.repeat(64)}}};
+    assert.throws(()=>update.assertAutonomousBootstrapRoots(bad,codingPolicy,digest),/profile|autonomous roots/i);
+    const file=path.join(state,'autonomous.json');
+    await writeFile(file,JSON.stringify(bad));
+    await assert.rejects(loadAutonomousPolicy(file,codingPolicy),/profile.*root invalid/i);
+  }finally{await rm(state,{recursive:true,force:true});}
+});
+
+test('R70 update preflight verifies pinned owner signature against the manifest and selected policies',async()=>{
+  const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-owner-bootstrap-'));
+  try{
+    const root=await realpath(path.join(state,'project').replace(/project$/,'')).then(async()=>{
+      const project=path.join(state,'project');await mkdir(project);return realpath(project);
+    });
+    const trust=path.join(state,'trust');await mkdir(trust);
+    const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust,'r70-owner-public.pem'),publicKey.export({type:'spki',format:'pem'}));
+    const manifest='c'.repeat(64),coding='a'.repeat(64),autonomous='b'.repeat(64);
+    const subject={schema:'deadbyte.project-authority-subject.r70.v1',scope:'coding_autonomous_native_diff',
+      root_id:'gfx_project',project_root:root,coding_policy_sha256:coding,autonomous_policy_sha256:autonomous,
+      reviewed_artifact_sha256:manifest,issued_at_utc:'2026-10-13T00:00:00.000Z',expires_at_utc:'2026-10-13T00:30:00.000Z'};
+    const subjectSha=sha(Buffer.from(canonicalJson(subject)));
+    const signed={schema:'deadbyte.project-owner-approval.r70.v1',subject_sha256:subjectSha,
+      owner_key_id:sha(publicKey.export({type:'spki',format:'der'}))};
+    const approval={...signed,subject,signature_base64:sign(null,Buffer.concat([
+      Buffer.from('DEADBYTE-R70-PROJECT-OWNER-APPROVAL\0'),Buffer.from(canonicalJson(signed))]),privateKey).toString('base64')};
+    const approvalPath=path.join(state,'approval.json'),bytes=Buffer.from(JSON.stringify(approval));
+    await writeFile(approvalPath,bytes);
+    const input={stateRoot:state,bootstrap:{path:approvalPath,sha256:sha(bytes)},
+      autonomousPolicy:{root_ids:['gfx_project'],coding_policy_sha256:coding},codingPolicy:{roots:{gfx_project:{path:root,read:true,write:true}}},
+      codingPolicySha256:coding,autonomousPolicySha256:autonomous,expectedManifest:manifest,
+      now:new Date('2026-10-13T00:05:00.000Z')};
+    const verified=await update.verifyAutonomousOwnerBootstrap(input);
+    assert.equal(verified.subject_sha256,subjectSha);
+    await assert.rejects(update.verifyAutonomousOwnerBootstrap({...input,expectedManifest:'d'.repeat(64)}),/artifact/i);
+    await assert.rejects(update.verifyAutonomousOwnerBootstrap({...input,now:new Date('2026-10-13T00:30:00.000Z')}),/expired/i);
+    await assert.rejects(update.verifyAutonomousOwnerBootstrap({
+      ...input,codingPolicy:{roots:{...input.codingPolicy.roots,trust_writer:{path:trust,write:true}}}
+    }),/owner trust key is writable/i);
+    await assert.rejects(update.performSlotUpdate({
+      stage:path.join(state,'unverified-stage'),developmentRoot:path.join(state,'unverified-dev'),
+      expectedVersion:'0.15.45',expectedManifest:manifest,stateRoot:state,
+      autonomousPolicyBootstrap:{path:'not-loaded',sha256:autonomous}
+    }),/owner approval/i);
+    await assert.rejects(update.verifyAutonomousOwnerBootstrap({
+      ...input,codingPolicy:{roots:{gfx_project:{...input.codingPolicy.roots.gfx_project,exec:true}}}
+    }),/unsandboxed Coding execution/i);
+    await assert.rejects(update.verifyAutonomousOwnerBootstrap({
+      ...input,codingPolicy:{roots:{...input.codingPolicy.roots,
+        command_root:{path:root,read:true,write:false,exec:true}}}
+    }),/unsandboxed Coding execution/i);
+    const attacker=generateKeyPairSync('ed25519').publicKey;
+    await writeFile(path.join(trust,'r70-owner-public.pem'),attacker.export({type:'spki',format:'pem'}));
+    await assert.rejects(update.verifyAutonomousOwnerBootstrap(input),/key identity|signature/i);
+    await writeFile(approvalPath,Buffer.concat([bytes,Buffer.from('\\n')]));
+    await assert.rejects(update.verifyAutonomousOwnerBootstrap(input),/SHA-256 mismatch/i);
+  }finally{await rm(state,{recursive:true,force:true});}
+});

package/test/r70-controller-autonomous-root.test.mjs

@@ -0,0 +1,104 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readFile,rm,symlink,unlink,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+
+const controllerPath=new URL('../controller/deadbyte-controller.ps1',import.meta.url);
+const quote=value=>`'${String(value).replaceAll("'","''")}'`;
+
+test('R70 controller rejects Autonomous roots outside selected Coding roots',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-controller-root-'));
+  try{
+    const runtime=path.join(root,'runtime'),policyFile=path.join(root,'autonomous.json');
+    await writeFile(policyFile,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'autonomous-grant.json'),coding_policy_sha256:'a'.repeat(64),root_ids:['outside']}));
+    const source=await readFile(controllerPath,'utf8');
+    const start=source.indexOf('function Get-AutonomousPolicyMetadata(');
+    const end=source.indexOf('function Get-AutonomousLeaseStatus(',start);
+    assert.ok(start>=0&&end>start);
+    const helperStart=source.indexOf('function Read-ControllerPolicySnapshot(');
+    const helperEnd=source.indexOf('function Get-CodingPolicyMetadata(',helperStart);
+    assert.ok(helperStart>=0&&helperEnd>helperStart);
+    const block=source.slice(helperStart,helperEnd)+source.slice(start,end);
+    const script=`$ErrorActionPreference='Stop';$RuntimeDir=${quote(runtime)};function Fail([string]$m){throw $m};function Get-ExecutableHash($p){return 'b'.PadLeft(64,'b')};function Get-CodingPolicyMetadata($Cfg){return [pscustomobject]@{Sha256='a'.PadLeft(64,'a');RootIds=@('project');RootPaths=@{project=${quote(root)}};RootAccess=@{project=@{read=$true;write=$true;exec=$false}}}};${block};try{Get-AutonomousPolicyMetadata @{AutonomousPolicyFile=${quote(policyFile)}}|Out-Null;Write-Output 'UNEXPECTED_PASS'}catch{Write-Output $_.Exception.Message}`;
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(result.status,0,result.stderr);
+    assert.match(result.stdout,/autonomous policy root 'outside' outside coding policy/);
+    await writeFile(policyFile,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'autonomous-grant.json'),coding_policy_sha256:'a'.repeat(64),root_ids:['project']}));
+    const accepted=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(accepted.status,0,accepted.stderr);
+    assert.match(accepted.stdout,/UNEXPECTED_PASS/);
+    assert.doesNotMatch(accepted.stdout,/outside coding policy/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 controller refuses a direct Autonomous whole-drive policy root',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-controller-drive-'));
+  try{
+    const runtime=path.join(root,'runtime'),policyFile=path.join(root,'autonomous.json');
+    const drive=path.parse(root).root;
+    await writeFile(policyFile,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'autonomous-grant.json'),coding_policy_sha256:'a'.repeat(64),root_ids:['project']}));
+    const source=await readFile(controllerPath,'utf8');
+    const helperStart=source.indexOf('function Read-ControllerPolicySnapshot(');
+    const helperEnd=source.indexOf('function Get-CodingPolicyMetadata(',helperStart);
+    const start=source.indexOf('function Get-AutonomousPolicyMetadata(');
+    const end=source.indexOf('function Get-AutonomousLeaseStatus(',start);
+    assert.ok(helperStart>=0&&helperEnd>helperStart&&start>=0&&end>start);
+    const block=source.slice(helperStart,helperEnd)+source.slice(start,end);
+    const script=`$ErrorActionPreference='Stop';$RuntimeDir=${quote(runtime)};function Fail([string]$m){throw $m};function Get-CodingPolicyMetadata($Cfg){return [pscustomobject]@{Sha256='a'.PadLeft(64,'a');RootIds=@('project');RootPaths=@{project=${quote(drive)}};RootAccess=@{project=@{read=$true;write=$true;exec=$false}}}};${block};try{Get-AutonomousPolicyMetadata @{AutonomousPolicyFile=${quote(policyFile)}}|Out-Null;Write-Output 'UNEXPECTED_PASS'}catch{Write-Output $_.Exception.Message}`;
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(result.status,0,result.stderr);
+    assert.match(result.stdout,/project-scoped root/);
+    assert.doesNotMatch(result.stdout,/UNEXPECTED_PASS/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 controller refuses a project-looking junction to a whole drive',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-controller-junction-'));
+  const link=path.join(root,'project-link');
+  try{
+    const runtime=path.join(root,'runtime'),policyFile=path.join(root,'autonomous.json');
+    await symlink(path.parse(root).root,link,'junction');
+    await writeFile(policyFile,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'autonomous-grant.json'),coding_policy_sha256:'a'.repeat(64),root_ids:['project']}));
+    const source=await readFile(controllerPath,'utf8');
+    const helperStart=source.indexOf('function Read-ControllerPolicySnapshot(');
+    const helperEnd=source.indexOf('function Get-CodingPolicyMetadata(',helperStart);
+    const start=source.indexOf('function Get-AutonomousPolicyMetadata(');
+    const end=source.indexOf('function Get-AutonomousLeaseStatus(',start);
+    const block=source.slice(helperStart,helperEnd)+source.slice(start,end);
+    const script=`$ErrorActionPreference='Stop';$RuntimeDir=${quote(runtime)};function Fail([string]$m){throw $m};function Get-CodingPolicyMetadata($Cfg){return [pscustomobject]@{Sha256='a'.PadLeft(64,'a');RootIds=@('project');RootPaths=@{project=${quote(link)}};RootAccess=@{project=@{read=$true;write=$true;exec=$false}}}};${block};try{Get-AutonomousPolicyMetadata @{AutonomousPolicyFile=${quote(policyFile)}}|Out-Null;Write-Output 'UNEXPECTED_PASS'}catch{Write-Output $_.Exception.Message}`;
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(result.status,0,result.stderr);
+    assert.match(result.stdout,/real project directory/);
+    assert.doesNotMatch(result.stdout,/UNEXPECTED_PASS/);
+  }finally{
+    await unlink(link).catch(error=>{if(error.code!=='ENOENT')throw error;});
+    await rm(root,{recursive:true,force:true});
+  }
+});
+
+test('R70 controller refuses a narrow Autonomous root when Coding still empowers a whole drive',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-controller-coding-drive-'));
+  try{
+    const runtime=path.join(root,'runtime'),policyFile=path.join(root,'autonomous.json');
+    const drive=path.parse(root).root;
+    await writeFile(policyFile,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'autonomous-grant.json'),coding_policy_sha256:'a'.repeat(64),root_ids:['project']}));
+    const source=await readFile(controllerPath,'utf8');
+    const helperStart=source.indexOf('function Read-ControllerPolicySnapshot(');
+    const helperEnd=source.indexOf('function Get-CodingPolicyMetadata(',helperStart);
+    const start=source.indexOf('function Get-AutonomousPolicyMetadata(');
+    const end=source.indexOf('function Get-AutonomousLeaseStatus(',start);
+    const block=source.slice(helperStart,helperEnd)+source.slice(start,end);
+    const script=`$ErrorActionPreference='Stop';$RuntimeDir=${quote(runtime)};function Fail([string]$m){throw $m};function Get-CodingPolicyMetadata($Cfg){return [pscustomobject]@{Sha256='a'.PadLeft(64,'a');RootIds=@('project','local_drive');RootPaths=@{project=${quote(root)};local_drive=${quote(drive)}};RootAccess=@{project=@{read=$true;write=$true;exec=$false};local_drive=@{read=$true;write=$true;exec=$true}}}};${block};try{Get-AutonomousPolicyMetadata @{AutonomousPolicyFile=${quote(policyFile)}}|Out-Null;Write-Output 'UNEXPECTED_PASS'}catch{Write-Output $_.Exception.Message}`;
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(result.status,0,result.stderr);
+    assert.match(result.stdout,/coding policy contains a broad filesystem root/);
+    assert.doesNotMatch(result.stdout,/UNEXPECTED_PASS/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/r70-controller-grant-subset.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+
+const controllerPath=new URL('../controller/deadbyte-controller.ps1',import.meta.url);
+const quote=value=>`'${String(value).replaceAll("'","''")}'`;
+
+test('R70 Autonomous status cannot exceed effective Coding grant roots',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-grant-subset-'));
+  try{
+    const grant=path.join(root,'autonomous-grant.json');
+    await writeFile(grant,JSON.stringify({schema:'deadbyte.autonomous-grant.v2',policy_sha256:'a'.repeat(64),
+      coding_policy_sha256:'b'.repeat(64),instance_nonce:'c'.repeat(64),root_ids:['other']}));
+    const source=await readFile(controllerPath,'utf8');
+    const start=source.indexOf('function Get-AutonomousLeaseStatus('),end=source.indexOf('function Arm-Autonomous(',start);
+    assert.ok(start>=0&&end>start);
+    const block=source.slice(start,end);
+    const script=`$ErrorActionPreference='Stop';function Get-AutonomousPolicyMetadata($Cfg){return [pscustomobject]@{LeaseFile=${quote(grant)};Sha256='a'.PadLeft(64,'a');CodingPolicySha256='b'.PadLeft(64,'b');RootIds=@('project','other')}};function Get-CodingLeaseStatus($Cfg){return [pscustomobject]@{Armed=$true;RootIds=@('project')}};function Get-AuthorityEpochStatus($Cfg,$Plane,$Grant,$Nonce){return [pscustomobject]@{Trusted=$true;Seq=1;EventSha256='d'.PadLeft(64,'d')}};${block};$s=Get-AutonomousLeaseStatus @{AutonomousPolicyFile='fixture'};$s|ConvertTo-Json -Compress`;
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(result.status,0,result.stderr);
+    const state=JSON.parse(result.stdout.trim());
+    assert.equal(state.Armed,false);
+    assert.equal(state.Reason,'coding-roots');
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/r70-controller-owner-issue-boundary.test.mjs

@@ -0,0 +1,80 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readFile,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {spawnSync} from 'node:child_process';
+
+const controllerPath=new URL('../controller/deadbyte-controller.ps1',import.meta.url);
+const LEGACY='6274492644c303b38117541cc22a59e88e6ff5fdef7051a5d57ad336f45765f5';
+const H=c=>c.repeat(64);
+
+async function probe(policySha,rootId){
+  const source=await readFile(controllerPath,'utf8');
+  const start=source.indexOf('function Arm-Autonomous(');
+  const end=source.indexOf('function Disarm-Autonomous(',start);
+  assert.ok(start>=0&&end>start,'controller arm function must be present');
+  const slice=source.slice(start,end);
+  const script=`$ErrorActionPreference='Stop';
+function Fail([string]$m){throw $m}
+function Get-CodingLeaseStatus($Cfg){return [pscustomobject]@{Armed=$true;RootIds=@('core','gfx_project')}}
+function Get-AutonomousPolicyMetadata($Cfg){return [pscustomobject]@{Sha256='${policySha}';RootIds=@('${rootId}');CodingPolicySha256='${H('a')}'}}
+function Ensure-Directory($d){Write-Output 'MUTATION_REACHED';throw 'TEST_STUB_NO_GRANT'}
+$RuntimeDir='fixture-only'
+${slice}
+try{Arm-Autonomous @{};Write-Output 'UNEXPECTED_PASS'}catch{Write-Output ('GATE_ERROR '+$_.Exception.Message)}
+`;
+  const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+  assert.equal(result.status,0,result.stderr);
+  return result.stdout;
+}
+
+test('R70 controller must reject unapproved successor Autonomous policy before grant I/O',async()=>{
+  for(const [sha,id] of [[H('b'),'gfx_project'],[H('b'),'core'],[LEGACY,'gfx_project']]){
+    const output=await probe(sha,id);
+    assert.match(output,/R70_OWNER_ENROLLMENT_REQUIRED/,output);
+    assert.doesNotMatch(output,/MUTATION_REACHED|UNEXPECTED_PASS/,output);
+  }
+});
+
+test('R70 newly issued legacy-core grant includes bounded expiry before signing',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-finite-grant-'));
+  const leaseFile=path.join(root,'grant.json');
+  const quote=s=>`'${s.replaceAll("'","''")}'`;
+  try{
+    const source=await readFile(controllerPath,'utf8');
+    const start=source.indexOf('function Arm-Autonomous(');
+    const end=source.indexOf('function Disarm-Autonomous(',start);
+    assert.ok(start>=0&&end>start);
+    const script=`$ErrorActionPreference='Stop';
+function Fail([string]$m){throw $m}
+function Get-CodingLeaseStatus($Cfg){return [pscustomobject]@{Armed=$true;RootIds=@('core')}}
+function Get-AutonomousPolicyMetadata($Cfg){return [pscustomobject]@{Sha256='${LEGACY}';RootIds=@('core');CodingPolicySha256='${H('a')}';LeaseFile=${quote(leaseFile)}}}
+function Ensure-Directory($p){}
+function Invoke-AuthorityEpochCommand($Cfg,$Plane,$Action,$File){return 'TEST_ONLY_EPOCH'}
+$RuntimeDir=${quote(root)}
+${source.slice(start,end)}
+Arm-Autonomous @{};
+`;
+    const before=Date.now();
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    const after=Date.now();
+    assert.equal(result.status,0,result.stderr);
+    const grant=JSON.parse((await readFile(leaseFile,'utf8')).replace(/^\uFEFF/,''));
+    assert.equal(grant.schema,'deadbyte.autonomous-grant.v2');
+    assert.equal(grant.policy_sha256,LEGACY);
+    assert.equal(grant.coding_policy_sha256,H('a'));
+    assert.deepEqual(grant.root_ids,['core']);
+    const issued=Date.parse(grant.granted_at_utc),expires=Date.parse(grant.expires_at_utc);
+    assert.ok(Number.isFinite(issued)&&Number.isFinite(expires),'grant must include valid UTC times');
+    assert.ok(issued>=before-1000&&issued<=after+1000,'signed grant issued_at must be current');
+    assert.equal(expires-issued,3_600_000,'new grant must expire within exactly one hour');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 exact known-good core policy keeps existing explicit manual arm route',async()=>{
+  const output=await probe(LEGACY,'core');
+  assert.match(output,/MUTATION_REACHED/,output);
+  assert.match(output,/TEST_STUB_NO_GRANT/,output);
+  assert.doesNotMatch(output,/UNEXPECTED_PASS/,output);
+});