deadbyte-mcp 0.15.44 → 0.15.45

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

package/test/r70-controller-policy-snapshot.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,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("'","''")+"'";
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+test('R70 controller policy digest binds the same bytes used for root decisions',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-policy-snapshot-'));
+  try{
+    const runtime=path.join(root,'runtime'),workspace=path.join(root,'project');
+    await mkdir(workspace);
+    const file=path.join(root,'coding.json');
+    const bytes=Buffer.from(JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'coding-grant.json'),roots:{gfx_project:{path:workspace}},
+      commands:{}}));
+    await writeFile(file,bytes);
+    const source=await readFile(controllerPath,'utf8');
+    const begin=source.indexOf('function Get-CodingPolicyMetadata(');
+    const end=source.indexOf('function Get-CodingLeaseStatus(',begin);
+    assert.ok(begin>=0&&end>begin);
+    const helperBegin=source.indexOf('function Read-ControllerPolicySnapshot(');
+    const helper=helperBegin>=0?source.slice(helperBegin,source.indexOf('function Get-CodingPolicyMetadata(',helperBegin)):'';
+    const block=source.slice(begin,end);
+    const script="$ErrorActionPreference='Stop';$RuntimeDir="+quote(runtime)+";function Fail([string]$m){throw $m};function Get-ExecutableHash($p){return 'a'.PadLeft(64,'a')};function Assert-PolicyRootsAvailable($p,$n){return @('gfx_project')};"+helper+";"+block+";$m=Get-CodingPolicyMetadata @{CodingPolicyFile="+quote(file)+"};$m|ConvertTo-Json -Compress";
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(result.status,0,result.stderr);
+    const metadata=JSON.parse(result.stdout.trim());
+    assert.equal(metadata.Sha256,sha(bytes));
+    assert.deepEqual(metadata.RootIds,['gfx_project']);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R70 Autonomous metadata binds parsed policy and Coding digest to one snapshot',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-autonomous-snapshot-'));
+  try{
+    const runtime=path.join(root,'runtime'),file=path.join(root,'autonomous.json');
+    const codingSha='b'.repeat(64);
+    const bytes=Buffer.from(JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'autonomous-grant.json'),coding_policy_sha256:codingSha,
+      root_ids:['gfx_project']}));
+    await writeFile(file,bytes);
+    const source=await readFile(controllerPath,'utf8');
+    const helperBegin=source.indexOf('function Read-ControllerPolicySnapshot(');
+    const helperEnd=source.indexOf('function Get-CodingPolicyMetadata(',helperBegin);
+    const begin=source.indexOf('function Get-AutonomousPolicyMetadata(');
+    const end=source.indexOf('function Get-AutonomousLeaseStatus(',begin);
+    assert.ok(helperBegin>=0&&helperEnd>helperBegin&&begin>=0&&end>begin);
+    const helper=source.slice(helperBegin,helperEnd),block=source.slice(begin,end);
+    const script="$ErrorActionPreference='Stop';$RuntimeDir="+quote(runtime)+
+      ";function Fail([string]$m){throw $m};function Get-ExecutableHash($p){return 'a'.PadLeft(64,'a')}"+
+      ";function Get-CodingPolicyMetadata($Cfg){return [pscustomobject]@{Sha256='b'.PadLeft(64,'b');RootIds=@('gfx_project');RootPaths=@{gfx_project="+quote(root)+"};RootAccess=@{gfx_project=@{read=$true;write=$true;exec=$false}}}};"+
+      helper+";"+block+";$m=Get-AutonomousPolicyMetadata @{AutonomousPolicyFile="+quote(file)+"};$m|ConvertTo-Json -Compress";
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8',timeout:15000});
+    assert.equal(result.status,0,result.stderr);
+    const metadata=JSON.parse(result.stdout.trim());
+    assert.equal(metadata.Sha256,sha(bytes));
+    assert.equal(metadata.CodingPolicySha256,codingSha);
+    assert.deepEqual(metadata.RootIds,['gfx_project']);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/r70-owner-approval.test.mjs

@@ -0,0 +1,67 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,sign} from 'node:crypto';
+import {mkdtemp,realpath,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {verifyProjectOwnerApproval} from '../src/r70-owner-approval.mjs';
+
+const H=c=>c.repeat(64);
+const domain=Buffer.from('DEADBYTE-R70-PROJECT-OWNER-APPROVAL\0','utf8');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r70-owner-'));
+  const projectRoot=await realpath(root);
+  const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+  const keyId=sha(publicKey.export({type:'spki',format:'der'}));
+  const subject={schema:'deadbyte.project-authority-subject.r70.v1',scope:'coding_autonomous_native_diff',
+    root_id:'gfx_project',project_root:projectRoot,coding_policy_sha256:H('a'),
+    autonomous_policy_sha256:H('b'),reviewed_artifact_sha256:H('c'),
+    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),'utf8'));
+  const signed={schema:'deadbyte.project-owner-approval.r70.v1',subject_sha256:subjectSha,owner_key_id:keyId};
+  const approval={...signed,subject,signature_base64:sign(null,Buffer.concat([domain,Buffer.from(canonicalJson(signed),'utf8')]),privateKey).toString('base64')};
+  const expected={rootId:'gfx_project',projectRoot,codingPolicySha256:H('a'),autonomousPolicySha256:H('b'),reviewedArtifactSha256:H('c')};
+  return {root,projectRoot,publicKey,approval,expected,subjectSha};
+}
+
+test('R70 owner signature binds exact reviewed project, policy pair, scope and bounded lifetime',async()=>{
+  const f=await fixture();
+  try{
+    const proof=await verifyProjectOwnerApproval({approval:f.approval,ownerPublicKey:f.publicKey,expected:f.expected,
+      now:new Date('2026-10-13T00:05:00.000Z')});
+    assert.equal(proof.approved,true);
+    assert.equal(proof.subject_sha256,f.subjectSha);
+    assert.equal(proof.expires_at_utc,'2026-10-13T00:30:00.000Z');
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R70 signed owner approval fails closed on artifact, policy, root and signature drift',async()=>{
+  const f=await fixture();
+  try{
+    const now=new Date('2026-10-13T00:05:00.000Z');
+    for(const changed of [
+      {reviewedArtifactSha256:H('d')},{codingPolicySha256:H('d')},{autonomousPolicySha256:H('d')},{rootId:'other'}
+    ]){
+      await assert.rejects(verifyProjectOwnerApproval({approval:f.approval,ownerPublicKey:f.publicKey,
+        expected:{...f.expected,...changed},now}),/subject|scope|root|artifact|policy/i);
+    }
+    await assert.rejects(verifyProjectOwnerApproval({approval:{...f.approval,signature_base64:Buffer.alloc(64).toString('base64')},
+      ownerPublicKey:f.publicKey,expected:f.expected,now}),/signature/i);
+    await assert.rejects(verifyProjectOwnerApproval({approval:{...f.approval,unreviewed_extra:true},
+      ownerPublicKey:f.publicKey,expected:f.expected,now}),/unknown field/i);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R70 owner approval expires and cannot survive a changed lifetime field',async()=>{
+  const f=await fixture();
+  try{
+    await assert.rejects(verifyProjectOwnerApproval({approval:f.approval,ownerPublicKey:f.publicKey,expected:f.expected,
+      now:new Date('2026-10-13T00:30:00.000Z')}),/expired/i);
+    const altered={...f.approval,subject:{...f.approval.subject,expires_at_utc:'2026-10-13T01:00:00.000Z'}};
+    await assert.rejects(verifyProjectOwnerApproval({approval:altered,ownerPublicKey:f.publicKey,expected:f.expected,
+      now:new Date('2026-10-13T00:05:00.000Z')}),/subject|signature/i);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});

package/test/r71-full-verifier-artifact.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+test('R71 full verifier persists the complete stdout bytes beside its no-clobber result',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows PowerShell verifier only');return;}
+  const run=spawnSync('powershell.exe',['-NoProfile','-ExecutionPolicy','Bypass','-File',
+    path.join(root,'scripts','verify-r70-full-regression.ps1'),'-SelfTest'],
+    {cwd:root,encoding:'utf8',windowsHide:true,timeout:30_000});
+  assert.equal(run.status,0,run.stderr||run.stdout);
+  const resultPath=/R70_FULL_TEST_ARTIFACT=([^\r\n]+)/.exec(run.stdout)?.[1];
+  assert.ok(resultPath,'durable result path missing');
+  const result=JSON.parse(await readFile(resultPath,'utf8'));
+  assert.equal(result.mode,'synthetic-selftest');
+  assert.equal(result.exit_code,1);
+  assert.equal(typeof result.stdout_path,'string');
+  const output=await readFile(result.stdout_path);
+  assert.equal(sha(output),result.stdout_sha256);
+  assert.match(output.toString('utf8'),/hash mismatch: SYNTHETIC_TEST/);
+  assert.equal(output.toString('utf8').trimEnd().split('\n').length,result.total_line_count);
+});