deadbyte-mcp 0.15.39 → 0.15.42

package/test/r64-machine-fs-large-read.test.mjs

@@ -0,0 +1,136 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import fs from 'node:fs';
+import {EventEmitter} from 'node:events';
+import {mkdtemp, mkdir, readFile, writeFile, rm} from 'node:fs/promises';
+import {syncBuiltinESMExports} from 'node:module';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {loadCodingPolicy} from '../src/coding-plane.mjs';
+import {createMachineFsRuntime} from '../src/machine-fs.mjs';
+import {generateTrustKeypair} from '../src/trust.mjs';
+import {machineFsGatewayInputSchema} from '../src/compact-gateway-mcp-tools.mjs';
+import {registerMachineFsTools} from '../src/machine-fs-mcp-tools.mjs';
+
+const PAGE=4*1024*1024;
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function fixture(t,{read=true}={}){
+  const root=await mkdtemp(path.join(tmpdir(),'deadbyte-r64-read-'));
+  t.after(()=>rm(root,{recursive:true,force:true}));
+  const project=path.join(root,'project');
+  await mkdir(project);
+  const policyPath=path.join(root,'policy.json');
+  await writeFile(policyPath,JSON.stringify({
+    schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(root,'coding-grant.json'),evidence_dir:path.join(root,'evidence'),
+    roots:{project:{path:project,read,write:false,exec:false,deny_paths:[]}},
+    commands:{},max_read_bytes:PAGE,max_write_bytes:65536
+  }));
+  const policy=await loadCodingPolicy(policyPath);
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(root,'private.pem'),publicKeyPath:path.join(root,'public.pem')});
+  return {root,project,policy,keys,runtime:createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
+}
+
+test('R64 full and compact read schemas accept next_offset beyond one-page bound',()=>{
+  const server={registerTool(name,definition){if(name==='machine_fs_read')this.read=definition;}};
+  registerMachineFsTools(server,{runtime:{}});
+  const args={root_id:'project',path:'large.bin',offset:PAGE+2,max_bytes:64,hash_file:false,timeout_ms:30000};
+  assert.equal(server.read.inputSchema.safeParse(args).success,true,'full tool rejects a valid next_offset');
+  assert.equal(machineFsGatewayInputSchema.safeParse({op:'read',...args}).success,true,'compact tool rejects a valid next_offset');
+  assert.equal(server.read.inputSchema.safeParse({...args,max_bytes:PAGE+1}).success,false,'per-call byte cap must remain');
+  assert.equal(machineFsGatewayInputSchema.safeParse({op:'read',...args,max_bytes:PAGE+1}).success,false);
+  assert.equal(server.read.inputSchema.safeParse({...args,offset:Number.MAX_SAFE_INTEGER+1}).success,false);
+  assert.equal(machineFsGatewayInputSchema.safeParse({op:'read',...args,offset:Number.MAX_SAFE_INTEGER+1}).success,false);
+});
+
+test('R64 reads page two using next_offset beyond 4 MiB',async t=>{
+  const f=await fixture(t);
+  const bytes=Buffer.alloc(PAGE+32,0x61);
+  bytes[0]=0x5a;
+  bytes[1]=0x5b;
+  bytes[PAGE+2]=0x7f;
+  await writeFile(path.join(f.project,'large.bin'),bytes);
+  const first=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:2,maxBytes:PAGE});
+  assert.equal(first.next_offset,PAGE+2);
+  assert.equal(first.eof,false);
+  const second=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:first.next_offset,maxBytes:64});
+  assert.equal(second.offset,PAGE+2);
+  assert.equal(Buffer.from(second.data_base64,'base64')[0],0x7f);
+  assert.equal(second.eof,true);
+  assert.equal(second.next_offset,bytes.length);
+  const atEof=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:bytes.length,maxBytes:1});
+  assert.equal(atEof.eof,true);
+  assert.equal(Buffer.from(atEof.data_base64,'base64').length,0);
+  assert.equal(atEof.next_offset,bytes.length);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:bytes.length+1,maxBytes:1}),/exceeds file size/);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:Number.MAX_SAFE_INTEGER+1,maxBytes:1}),/safe integer/);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:0,maxBytes:PAGE+1}),/max_bytes/);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:-PAGE-1,maxBytes:1}),/offset/);
+});
+
+test('R64 pages are independent observations and hash_file reveals replacement between calls',async t=>{
+  const f=await fixture(t);
+  const file=path.join(f.project,'large.bin');
+  const before=Buffer.alloc(PAGE+32,0x61);
+  const after=Buffer.alloc(PAGE+32,0x62);
+  await writeFile(file,before);
+  const first=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:2,maxBytes:PAGE,hashFile:true});
+  assert.equal(first.file_sha256,sha(before));
+  await writeFile(file,after);
+  const second=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:first.next_offset,maxBytes:64,hashFile:true});
+  assert.equal(second.file_sha256,sha(after));
+  assert.notEqual(second.file_sha256,first.file_sha256,'the caller must not treat these pages as one snapshot');
+});
+
+test('R64 a denied read root remains denied at a large offset',async t=>{
+  const f=await fixture(t,{read:false});
+  await writeFile(path.join(f.project,'large.bin'),Buffer.alloc(PAGE+16));
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1}),/does not allow read/);
+});
+
+test('R64 large offset does not bypass root containment',async t=>{
+  const f=await fixture(t);
+  await writeFile(path.join(f.root,'outside.bin'),Buffer.alloc(PAGE+16));
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'../outside.bin',offset:PAGE+1,maxBytes:1}),/relative|traversal|path|outside/i);
+});
+
+test('R64 large-offset read retains bounded worker cancellation',async t=>{
+  const f=await fixture(t);
+  await writeFile(path.join(f.project,'large.bin'),Buffer.alloc(PAGE+16));
+  const worker=path.join(f.root,'slow-read-worker.mjs');
+  await writeFile(worker,'setTimeout(() => process.stdout.write("{}"), 30000);\n');
+  const runtime=createMachineFsRuntime({policy:f.policy,signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath,readWorkerPath:worker});
+  await assert.rejects(()=>runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1,timeoutMs:100}),/timed out after 100ms/);
+});
+
+test('R64 default hash stream is abort-bound to read timeout',async()=>{
+  const source=await readFile(new URL('../src/machine-fs.mjs',import.meta.url),'utf8');
+  assert.ok(/createReadStream\(file,\s*\{\s*signal\s*\}\)/.test(source),'hash stream must receive the read abort signal');
+  assert.ok(/abortController\.abort\(\)/.test(source),'read timeout must abort its hash stream');
+});
+
+test('R64 timed-out default hash stream receives abort and stops',async t=>{
+  const f=await fixture(t);
+  await writeFile(path.join(f.project,'large.bin'),Buffer.alloc(PAGE+16));
+  const original=fs.createReadStream;
+  let observedAbort=false;
+  fs.createReadStream=(_file,options={})=>{
+    const stream=new EventEmitter();
+    options.signal?.addEventListener('abort',()=>{
+      observedAbort=true;
+      queueMicrotask(()=>stream.emit('error',new Error('aborted')));
+    },{once:true});
+    return stream;
+  };
+  syncBuiltinESMExports();
+  try{
+    await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1,hashFile:true,timeoutMs:100}),/timed out after 100ms/);
+    assert.equal(observedAbort,true,'default hash stream continued after timeout');
+  }finally{
+    fs.createReadStream=original;
+    syncBuiltinESMExports();
+  }
+});

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

@@ -0,0 +1,52 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=async rel=>JSON.parse((await read(rel)).replace(/^\uFEFF/,''));
+const currentPackage=await json('package.json');
+const sourceSha='d6f75feada9ad0ae2c248b3a833ac9cf0e04150d2430ddaa70b3dfb64a0b0a86';
+const runtime={
+  release_id:'v0.15.39-3cda3b1c65b7b7c5',
+  manifest_sha256:'3cda3b1c65b7b7c561c5a8617156ab87d69cf162f447f3e99a4cb4a76471b3de',
+  generation_manifest_sha256:'f47cb96083679e764725df1bde6eda53169a39f55772c173ab22f89a1dfaa7ab'
+};
+
+test('R64 release identity distinguishes unsealed source predecessor from active runtime predecessor',{skip:currentPackage.version!=='0.15.41'},async()=>{
+  const [pkg,lock,bridge,release,provenance,matrix,sbom,scope,gaps,version,gate]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),json('docs/R64-SCOPE.json'),
+    json('docs/R64-REFERENCE-GAP-MATRIX.json'),read('src/version.mjs'),read('scripts/gate-windows-r64-prepublish.ps1')
+  ]);
+  assert.equal(pkg.version,'0.15.41');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.equal(bridge.version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.41'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R64');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R64');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r64:0.15.41');
+  assert.deepEqual(release.runtime_predecessor,runtime);
+  assert.deepEqual(provenance.runtime_predecessor,runtime);
+  assert.equal(release.source_predecessor.version,'0.15.40');
+  assert.equal(release.source_predecessor.manifest_file_sha256,sourceSha);
+  assert.equal(release.source_predecessor.release_status,'NOT_PROVEN_RELEASED');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,sourceSha);
+  assert.equal(scope.source_predecessor.manifest_sha256,sourceSha);
+  assert.deepEqual(scope.runtime_predecessor,runtime);
+  assert.equal(release.r64_bounded_large_file_read.new_public_tools,0);
+  assert.equal(release.r64_bounded_large_file_read.new_authority_scopes,0);
+  assert.equal(release.r64_bounded_large_file_read.cross_page_atomic_snapshot_claim,false);
+  assert.equal(matrix.r64.prepublish_only,true);
+  assert.equal(gaps.references.length,7);
+  assert.equal(gaps.references.filter(row=>row.proposed_action.startsWith('ADAPT')).length,1);
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r64-prepublish.ps1');
+  assert.match(pkg.scripts['r64:focused:test'],/r64-machine-fs-large-read\.test\.mjs/);
+  assert.match(gate,/d6f75feada9ad0ae2c248b3a833ac9cf0e04150d2430ddaa70b3dfb64a0b0a86/);
+  assert.match(gate,/v0\.15\.39-3cda3b1c65b7b7c5/);
+  assert.doesNotMatch(gate,/npm\.cmd publish|--publish-only/);
+});

package/test/r65-activation-lock-recovery.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,sign as cryptoSign} from 'node:crypto';
+import {mkdtemp,mkdir,writeFile,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createActivationClaimManager} from '../src/activation-lock-r65.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const DOMAIN=Buffer.from('DEADBYTE-R27-SLOT-UPDATE-V1\0','utf8');
+
+function signReceipt(body,privateKey,publicKey){
+  const bodyBytes=Buffer.from(canonicalJson(body),'utf8');
+  const signature=cryptoSign(null,Buffer.concat([DOMAIN,bodyBytes]),privateKey);
+  const keyId=sha(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  const envelope={body,body_sha256:sha(bodyBytes),attestation:{algorithm:'ed25519',domain:'DEADBYTE-R27-SLOT-UPDATE-V1',key_id:keyId,signature_base64:signature.toString('base64')}};
+  envelope.receipt_sha256=sha(Buffer.from(canonicalJson(envelope),'utf8'));
+  return envelope;
+}
+
+test('stale activation lock is reclaimed only from exact terminal signed activation evidence',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-activation-lock-'));
+  try{
+    const updates=path.join(root,'evidence','updates'),trust=path.join(root,'trust');
+    await mkdir(updates,{recursive:true});await mkdir(trust,{recursive:true});
+    const {privateKey,publicKey}=generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust,'ed25519-public.pem'),publicKey.export({type:'spki',format:'pem'}));
+    const subject='a'.repeat(64),manager=createActivationClaimManager({stateRoot:root});
+    const first=await manager.claim(subject);
+    const updateId='r27-test-terminal';
+    const dir=path.join(updates,updateId);await mkdir(dir,{recursive:true});
+    const activePointer={schema:'deadbyte.active-release.v1',release_id:'v0.15.42-test',version:'0.15.42',
+      manifest_sha256:'b'.repeat(64),release_root:path.join(root,'releases','v0.15.42-test'),
+      generation_root:path.join(root,'generations','v0.15.42-test-g1'),generation_manifest_sha256:'c'.repeat(64),
+      launcher_sha256:'d'.repeat(64),config_path:path.join(root,'generations','v0.15.42-test-g1','controller-config.psd1')};
+    const receipt=signReceipt({schema:'deadbyte.r27-slot-update-receipt.v1',update_id:updateId,release_version:'0.15.42',
+      candidate_manifest_sha256:'b'.repeat(64),rollback_performed:false,prior_pointer:{release_id:'v0.15.41-parent'},
+      active_pointer:activePointer},privateKey,publicKey);
+    const receiptPath=path.join(dir,'receipt.json');await writeFile(receiptPath,JSON.stringify(receipt));
+    await writeFile(path.join(root,'active-release.json'),JSON.stringify(activePointer));
+    const outcome={schema:'deadbyte.r65-activation-outcome.v1',claim_operation_id:first.operation_id,
+      preflight_subject_sha256:subject,candidate_version:'0.15.42',candidate_manifest_sha256:'b'.repeat(64),
+      predecessor_release_id:'v0.15.41-parent',outcome:{state:'ACTIVATED'},update_id:updateId,
+      state_path:path.join(dir,'state.json'),receipt_path:receiptPath,receipt_sha256:receipt.receipt_sha256};
+    await writeFile(path.join(updates,'r65-activation-outcome-terminal.json'),JSON.stringify(outcome));
+    const second=await manager.claim('e'.repeat(64));
+    assert.notEqual(second.operation_id,first.operation_id);
+    await second.release();
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('terminal-looking outcome with invalid receipt cannot reclaim activation lock',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-activation-lock-forged-'));
+  try{
+    const updates=path.join(root,'evidence','updates'),trust=path.join(root,'trust');
+    await mkdir(updates,{recursive:true});await mkdir(trust,{recursive:true});
+    const {publicKey}=generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust,'ed25519-public.pem'),publicKey.export({type:'spki',format:'pem'}));
+    const subject='1'.repeat(64),manager=createActivationClaimManager({stateRoot:root});
+    const first=await manager.claim(subject);
+    const receiptPath=path.join(updates,'forged-receipt.json');
+    await writeFile(receiptPath,JSON.stringify({body:{schema:'deadbyte.r27-slot-update-receipt.v1'},receipt_sha256:'2'.repeat(64)}));
+    await writeFile(path.join(updates,'r65-activation-outcome-forged.json'),JSON.stringify({
+      schema:'deadbyte.r65-activation-outcome.v1',claim_operation_id:first.operation_id,preflight_subject_sha256:subject,
+      candidate_version:'0.15.42',candidate_manifest_sha256:'3'.repeat(64),predecessor_release_id:'v0.15.41-parent',
+      outcome:{state:'ACTIVATED'},update_id:'r27-forged',state_path:path.join(updates,'x','state.json'),
+      receipt_path:receiptPath,receipt_sha256:'2'.repeat(64)
+    }));
+    await assert.rejects(()=>manager.claim('4'.repeat(64)),/unresolved|in progress|receipt|terminal/i);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/r65-activation-lock.test.mjs

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {createActivationClaimManager} from '../src/activation-lock-r65.mjs';
+
+const subject='a'.repeat(64);
+
+test('terminal pre-mutation rejected claim can be reclaimed by exact operation evidence',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-lock-terminal-'));
+  try{
+    const state=path.join(root,'state'),manager=createActivationClaimManager({stateRoot:state});
+    const first=await manager.claim(subject);
+    const updates=path.join(state,'evidence','updates');await mkdir(updates,{recursive:true});
+    await writeFile(path.join(updates,'r65-activation-outcome-terminal.json'),JSON.stringify({
+      schema:'deadbyte.r65-activation-outcome.v1',claim_operation_id:first.operation_id,
+      preflight_subject_sha256:subject,candidate_version:'0.15.42',candidate_manifest_sha256:'b'.repeat(64),
+      outcome:{state:'ACTIVATION_REJECTED'},update_id:null,state_path:null
+    }));
+    const second=await manager.claim(subject);
+    assert.notEqual(second.operation_id,first.operation_id);
+    await second.release();
+    await assert.rejects(first.release(),/changed|missing|ownership/i);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('unknown activation outcome is never reclaimed automatically',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-lock-unknown-'));
+  try{
+    const state=path.join(root,'state'),manager=createActivationClaimManager({stateRoot:state});
+    const first=await manager.claim(subject);
+    const updates=path.join(state,'evidence','updates');
+    await writeFile(path.join(updates,'r65-activation-outcome-unknown.json'),JSON.stringify({
+      schema:'deadbyte.r65-activation-outcome.v1',claim_operation_id:first.operation_id,
+      preflight_subject_sha256:subject,candidate_version:'0.15.42',candidate_manifest_sha256:'b'.repeat(64),
+      outcome:{state:'ACTIVATION_OUTCOME_UNKNOWN'},update_id:'r27-unknown',state_path:path.join(updates,'unknown','state.json')
+    }));
+    await assert.rejects(()=>manager.claim(subject),/unresolved|unknown|in progress/i);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('corrupt or foreign-subject lock evidence fails closed',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-lock-corrupt-'));
+  try{
+    const state=path.join(root,'state'),updates=path.join(state,'evidence','updates');await mkdir(updates,{recursive:true});
+    await writeFile(path.join(updates,'r65-activation.lock'),'{bad');
+    const manager=createActivationClaimManager({stateRoot:state});
+    await assert.rejects(()=>manager.claim(subject),/corrupt|invalid/i);
+    await rm(path.join(updates,'r65-activation.lock'));
+    const first=await manager.claim(subject);
+    await writeFile(path.join(updates,'r65-activation-outcome-foreign.json'),JSON.stringify({
+      schema:'deadbyte.r65-activation-outcome.v1',claim_operation_id:first.operation_id,
+      preflight_subject_sha256:'c'.repeat(64),candidate_version:'0.15.42',candidate_manifest_sha256:'b'.repeat(64),
+      outcome:{state:'ACTIVATION_REJECTED'},update_id:null,state_path:null
+    }));
+    await assert.rejects(()=>manager.claim(subject),/unresolved|in progress|subject/i);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/r65-activation-orchestration.test.mjs

@@ -0,0 +1,179 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {orchestrateActivation} from '../src/activation-preflight-r65.mjs';
+
+const parent={release_id:'v0.15.41-63a78ad159ad3003',version:'0.15.41',manifest_sha256:'63a78ad159ad3003db3fefafcd468bef22599c829a867f4f10a46c7a20748b3e',generation_manifest_sha256:'19ae2efcdcde9f80c474f0e55851d4ada51c22813d3e05af03b11acb28c3fca5'};
+const candidate={version:'0.15.42',manifest_sha256:'a'.repeat(64)};
+const ids={bridge:{alive:true,reason:'verified',pid:10},core:{alive:true,reason:'verified',pid:11},cloud:{alive:true,reason:'verified',pid:12}};
+const policies={process:'a'.repeat(64),coding:'b'.repeat(64),autonomous:'c'.repeat(64),desktop:'d'.repeat(64),host:'e'.repeat(64)};
+
+function legacyEntry(armed){return {configured:true,armed,reason:armed?'standing-grant':'disarmed',epoch_seq:null,epoch_sha256:null};}
+function epochEntry(armed,seq=7,sha='f'.repeat(64)){return {configured:true,armed,reason:armed?'standing-grant':'disarmed',epoch_seq:armed?seq:null,epoch_sha256:armed?sha:null};}
+function authorityEntries(vector,epochNative=false){
+  return Object.fromEntries(Object.entries(vector).map(([plane,armed])=>[plane,epochNative?epochEntry(armed):legacyEntry(armed)]));
+}
+
+function fixture(initial={}){
+  const calls=[];
+  const initialVector=initial.authority??{process:true,coding:true,autonomous:true,desktop:false,host:true};
+  let current={state:'ONLINE',local_ready:true,...ids,supervisor:{running:true},authority:authorityEntries(initialVector,initial.epochNative===true),policy_sha256:policies,
+    active_release_id:parent.release_id,active_manifest_sha256:parent.manifest_sha256,active_generation_manifest_sha256:parent.generation_manifest_sha256,...initial};
+  if(initial.authority)current={...current,authority:authorityEntries(initial.authority,initial.epochNative===true)};
+  return {calls,observe:async()=>current,command:async name=>{
+    calls.push(name);
+    if(name.startsWith('disarm')){
+      const plane=name.slice(6);
+      current={...current,authority:{...current.authority,[plane]:legacyEntry(false)}};
+      if(plane==='coding')current={...current,authority:{...current.authority,autonomous:legacyEntry(false)}};
+    }else if(name==='supervisorstop')current={...current,supervisor:{running:false}};
+    else if(name==='stop')current={...current,state:'OFFLINE',local_ready:false,bridge:{alive:false},core:{alive:false},cloud:{alive:false}};
+    else throw new Error('unexpected authority widening command '+name);
+  },activate:async()=>{calls.push('activate');current={...current,state:'ONLINE',local_ready:true,...ids,supervisor:{running:true}};return {release_id:'v0.15.42-candidate',verified:true};},
+  setCurrent:value=>{current=value;},getCurrent:()=>current};
+}
+
+test('legacy standing authority is revoked before activation and never auto-restored',async()=>{
+  const f=fixture();
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f});
+  assert.equal(result.state,'ACTIVATED');
+  assert.equal(result.runtime_activation,'ACTIVATED');
+  assert.equal(result.authority_continuity,'REAUTH_REQUIRED');
+  assert.deepEqual(result.reauth_planes,['process','coding','autonomous','host']);
+  assert.deepEqual(f.calls,['disarmhost','disarmautonomous','disarmcoding','disarmprocess','activate']);
+  assert.equal(f.calls.some(name=>name.startsWith('arm')),false);
+  assert.deepEqual(result.final_authority,{process:false,coding:false,autonomous:false,desktop:false,host:false});
+});
+
+test('parked dirty predecessor reaches clean offline before activation',async()=>{
+  const f=fixture({state:'PARKED',authority:{process:false,coding:false,autonomous:false,desktop:false,host:false}});
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f});
+  assert.equal(result.state,'ACTIVATED');
+  assert.equal(result.authority_continuity,'NOT_APPLICABLE');
+  assert.deepEqual(f.calls,['supervisorstop','stop','activate']);
+});
+
+test('legacy revoke failure is terminal for the original action and never dispatches activation',async()=>{
+  const f=fixture();
+  const command=f.command;
+  f.command=async name=>{if(name==='disarmcoding'){f.calls.push(name);throw new Error('forced revoke failure');}await command(name);};
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f});
+  assert.equal(result.state,'ACTIVATION_OUTCOME_UNKNOWN');
+  assert.equal(f.calls.includes('activate'),false);
+  assert.equal(f.calls.some(name=>name.startsWith('arm')),false);
+});
+
+test('unexpected successor authority after activation is not reported as safe activation',async()=>{
+  const f=fixture();
+  const activate=f.activate;
+  f.activate=async()=>{
+    const result=await activate();
+    const current=f.getCurrent();
+    f.setCurrent({...current,authority:{...current.authority,process:legacyEntry(true)}});
+    return result;
+  };
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f});
+  assert.equal(result.state,'ACTIVATION_OUTCOME_UNKNOWN');
+  assert.equal(f.calls.some(name=>name.startsWith('arm')),false);
+});
+
+test('concurrent activation attempts admit only one transition',async()=>{
+  const f=fixture({authority:{process:false,coding:false,autonomous:false,desktop:false,host:false}});
+  let held=false,releaseFirst;
+  const claim=async()=>{if(held)throw new Error('activation already in progress');held=true;return async()=>{held=false;};};
+  const activate=f.activate;
+  f.activate=async()=>{await new Promise(resolve=>{releaseFirst=resolve;});return activate();};
+  const options={pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f,claim};
+  const first=orchestrateActivation(options);
+  while(!releaseFirst)await new Promise(resolve=>setTimeout(resolve,1));
+  let second;
+  try{
+    second=await Promise.race([orchestrateActivation(options),new Promise(resolve=>setTimeout(()=>resolve({state:'TIMED_OUT'}),50))]);
+    assert.equal(second.state,'ACTIVATION_REJECTED');
+  }finally{releaseFirst();}
+  assert.equal((await first).state,'ACTIVATED');
+  assert.deepEqual(f.calls,['activate']);
+});
+
+test('successor policy drift cannot become an exact legacy authority restoration',async()=>{
+  for(const plane of ['host','process']){
+    const vector={process:false,coding:false,autonomous:false,desktop:false,host:false};
+    vector[plane]=true;
+    const f=fixture({authority:vector});
+    const activate=f.activate;
+    let drift=false;
+    f.activate=async()=>{const result=await activate();drift=true;return result;};
+    const observe=f.observe;
+    f.observe=async()=>{
+      const value=await observe();
+      return drift?{...value,policy_sha256:{...value.policy_sha256,[plane]:'9'.repeat(64)}}:value;
+    };
+    const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f});
+    assert.equal(result.state,'ACTIVATED');
+    assert.equal(result.authority_continuity,'REAUTH_REQUIRED');
+    assert.deepEqual(result.reauth_planes,[plane]);
+    assert.equal(f.calls.some(name=>name.startsWith('arm')),false);
+  }
+});
+
+test('epoch-native standing authority remains fail-closed until transaction continuity engine is wired',async()=>{
+  const f=fixture({epochNative:true,authority:{process:true,coding:true,autonomous:true,desktop:false,host:false}});
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f});
+  assert.equal(result.state,'ACTIVATION_REJECTED');
+  assert.equal(result.preflight,'AUTHORITY_CONTINUITY_ENGINE_REQUIRED');
+  assert.equal(result.authority_continuity,'UNVERIFIED');
+  assert.deepEqual(f.calls,[]);
+});
+
+test('epoch-native continuity engine revokes before switch and restores exact bounded authority afterward',async()=>{
+  const f=fixture({epochNative:true,authority:{process:true,coding:true,autonomous:true,desktop:false,host:false}});
+  const capturedNonces={process:'1'.repeat(64),coding:'2'.repeat(64),autonomous:'3'.repeat(64)};
+  const restoredNonces={process:'4'.repeat(64),coding:'5'.repeat(64),autonomous:'6'.repeat(64)};
+  const continuityEngine={
+    capture:async({observation,subject_sha256})=>{
+      f.calls.push('continuity:capture');
+      assert.equal(observation.authority.process.armed,true);
+      return {update_id:'r65-epoch-native-test',subject_sha256,planes:['process','coding','autonomous'],captured_nonces:capturedNonces};
+    },
+    revoke:async capture=>{
+      f.calls.push('continuity:revoke');
+      assert.equal(capture.update_id,'r65-epoch-native-test');
+      const current=f.getCurrent();
+      f.setCurrent({...current,authority:authorityEntries({process:false,coding:false,autonomous:false,desktop:false,host:false},true)});
+      return {process:'TRANSACTION_REVOKED',coding:'TRANSACTION_REVOKED',autonomous:'TRANSACTION_REVOKED'};
+    },
+    restore:async ({capture,successor_observation})=>{
+      f.calls.push('continuity:restore');
+      assert.equal(successor_observation.authority.process.armed,false);
+      const current=f.getCurrent();
+      f.setCurrent({...current,authority:{
+        process:epochEntry(true,9,'7'.repeat(64)),coding:epochEntry(true,9,'8'.repeat(64)),autonomous:epochEntry(true,9,'9'.repeat(64)),
+        desktop:epochEntry(false),host:epochEntry(false)
+      }});
+      return {authority_outcomes:{process:'RESTORED_EXACT',coding:'RESTORED_EXACT',autonomous:'RESTORED_EXACT',desktop:'NOT_APPLICABLE',host:'NOT_APPLICABLE'},
+        restored_nonces:restoredNonces,reauth_planes:[]};
+    }
+  };
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f,continuityEngine});
+  assert.equal(result.state,'ACTIVATED');
+  assert.equal(result.runtime_activation,'ACTIVATED');
+  assert.equal(result.authority_continuity,'RESTORED_EXACT');
+  assert.deepEqual(result.authority_outcomes,{process:'RESTORED_EXACT',coding:'RESTORED_EXACT',autonomous:'RESTORED_EXACT',desktop:'NOT_APPLICABLE',host:'NOT_APPLICABLE'});
+  assert.deepEqual(f.calls,['continuity:capture','continuity:revoke','activate','continuity:restore']);
+  assert.notEqual(restoredNonces.process,capturedNonces.process);
+  assert.notEqual(restoredNonces.coding,capturedNonces.coding);
+  assert.notEqual(restoredNonces.autonomous,capturedNonces.autonomous);
+  assert.deepEqual(result.final_authority,{process:true,coding:true,autonomous:true,desktop:false,host:false});
+});
+
+
+test('terminal activation outcome is persisted before activation claim release',async()=>{
+  const f=fixture({authority:{process:false,coding:false,autonomous:false,desktop:false,host:false}});
+  const order=[];
+  const claim=async()=>{order.push('claim');return async()=>{order.push('release');};};
+  const activate=f.activate;
+  f.activate=async()=>{order.push('activate-start');const value=await activate();order.push('activate-end');return value;};
+  const recordOutcome=async outcome=>{assert.equal(outcome.state,'ACTIVATED');order.push('record');};
+  const result=await orchestrateActivation({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,...f,claim,recordOutcome});
+  assert.equal(result.state,'ACTIVATED');
+  assert.deepEqual(order,['claim','activate-start','activate-end','record','release']);
+});

package/test/r65-activation-preflight.test.mjs

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {classifyActivationPreflight,authorityTransitionPlan} from '../src/activation-preflight-r65.mjs';
+
+const parent={release_id:'v0.15.41-63a78ad159ad3003',version:'0.15.41',manifest_sha256:'63a78ad159ad3003db3fefafcd468bef22599c829a867f4f10a46c7a20748b3e',generation_manifest_sha256:'19ae2efcdcde9f80c474f0e55851d4ada51c22813d3e05af03b11acb28c3fca5'};
+const candidate={version:'0.15.42',manifest_sha256:'a'.repeat(64)};
+const authority={process:true,coding:true,autonomous:true,desktop:false,host:false};
+const policies={process:'1'.repeat(64),coding:'2'.repeat(64),autonomous:'3'.repeat(64),desktop:'4'.repeat(64),host:'5'.repeat(64)};
+const online={state:'ONLINE',local_ready:true,bridge:{alive:true,reason:'verified',pid:10},core:{alive:true,reason:'verified',pid:11},cloud:{alive:true,reason:'verified',pid:12},supervisor:{running:true},authority,policy_sha256:policies,
+  active_release_id:parent.release_id,active_manifest_sha256:parent.manifest_sha256,active_generation_manifest_sha256:parent.generation_manifest_sha256};
+const input={pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,observation:online};
+
+test('preflight accepts exact online predecessor with full observed identity and authority vector',()=>{
+  const result=classifyActivationPreflight(input);
+  assert.equal(result.state,'ONLINE_READY');assert.equal(result.safe_to_activate,true);
+  assert.deepEqual(result.authority,authority);
+  assert.match(result.subject_sha256,/^[0-9a-f]{64}$/);
+});
+
+test('host armed is not safe; plan only disarms Host and restores exact captured vector',()=>{
+  const armed={...authority,host:true};
+  const result=classifyActivationPreflight({...input,observation:{...online,authority:armed}});
+  assert.equal(result.state,'ONLINE_HOST_ARMED');assert.equal(result.safe_to_activate,false);
+  const plan=authorityTransitionPlan(result.authority);
+  assert.deepEqual(plan.before,['disarmhost']);
+  assert.deepEqual(plan.after,['armhost']);
+});
+
+test('parked dirty, generation drift and identity loss fail closed without an activation command',()=>{
+  assert.equal(classifyActivationPreflight({...input,observation:{...online,state:'PARKED'}}).state,'PARKED_DIRTY');
+  assert.equal(classifyActivationPreflight({...input,pointer:{...parent,generation_manifest_sha256:'b'.repeat(64)}}).state,'POINTER_DRIFT');
+  assert.equal(classifyActivationPreflight({...input,observation:{...online,active_release_id:'wrong'}}).state,'POINTER_DRIFT');
+  assert.equal(classifyActivationPreflight({...input,observation:{...online,policy_sha256:{...policies,host:null}}}).state,'UNKNOWN');
+  assert.equal(classifyActivationPreflight({...input,observation:{...online,cloud:{alive:false,reason:'missing'}}}).state,'RUNTIME_DRIFT');
+});

package/test/r65-authority-continuity-decision.test.mjs

@@ -0,0 +1,58 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {captureStandingGrant,deriveSecurityEnvelope,compareSecurityEnvelopes} from '../src/authority-continuity-r65.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const beforePolicy={schema:'deadbyte.process-policy.v1',enabled:true,grant_file:'C:\\state\\runtime\\process-grant.json',
+  state_dir:'C:\\state\\evidence\\process',native_host:{path:'C:\\slot\\host.exe',sha256:'a'.repeat(64)},
+  roots:{core:{path:'D:\\Projects',deny_paths:['secrets']}},profiles:{ping:{executable:'C:\\Windows\\cmd.exe',
+    executable_sha256:'b'.repeat(64),root_ids:['core'],prefix_args:['/d'],max_input_bytes:4096}}};
+const policyBytes=Buffer.from(JSON.stringify(beforePolicy));
+const grant={schema:'deadbyte.process-grant.v1',policy_sha256:sha(policyBytes),instance_nonce:'c'.repeat(64),
+  profile_ids:['ping'],root_ids:['core'],granted_at_utc:'2026-10-07T00:00:00Z'};
+const grantBytes=Buffer.from(JSON.stringify(grant));
+const predecessor={release_id:'v0.15.41-parent',generation_manifest_sha256:'d'.repeat(64)};
+const candidate={version:'0.15.42',manifest_sha256:'e'.repeat(64)};
+const updateId='r65-activation-test';
+
+test('continuity record binds exact policy bytes, grant bytes, scope and release lineage',()=>{
+  const record=captureStandingGrant({plane:'process',policyBytes,grantBytes,predecessor,candidate,updateId});
+  assert.equal(record.prior_policy_sha256,sha(policyBytes));
+  assert.equal(record.grant_sha256,sha(grantBytes));
+  assert.equal(record.grant_instance_nonce,grant.instance_nonce);
+  assert.deepEqual(record.granted_scope,{profile_ids:['ping'],root_ids:['core']});
+  assert.equal(record.predecessor_release,predecessor.release_id);
+  assert.equal(record.predecessor_generation_manifest_sha256,predecessor.generation_manifest_sha256);
+  assert.equal(record.candidate_version,candidate.version);
+  assert.equal(record.candidate_manifest_sha256,candidate.manifest_sha256);
+  assert.match(record.subject_sha256,/^[0-9a-f]{64}$/);
+});
+
+test('removing unused authority is narrower while adding a root is wider',()=>{
+  const prior={...beforePolicy,roots:{...beforePolicy.roots,unused:{path:'D:\\Unused',deny_paths:[]}}};
+  const priorEnvelope=deriveSecurityEnvelope('process',prior);
+  const currentEnvelope=deriveSecurityEnvelope('process',beforePolicy);
+  const added={...beforePolicy,roots:{...beforePolicy.roots,extra:{path:'D:\\Extra',deny_paths:[]}}};
+  assert.equal(compareSecurityEnvelopes('process',priorEnvelope,currentEnvelope).relation,'NARROWER');
+  assert.equal(compareSecurityEnvelopes('process',currentEnvelope,deriveSecurityEnvelope('process',added)).relation,'WIDER');
+});
+
+test('changed executable pin or disjoint root remains unverified instead of guessed safe',()=>{
+  const base=deriveSecurityEnvelope('process',beforePolicy);
+  const changedPin={...beforePolicy,native_host:{...beforePolicy.native_host,sha256:'f'.repeat(64)}};
+  const moved={...beforePolicy,roots:{core:{path:'E:\\Other',deny_paths:['secrets']}}};
+  assert.equal(compareSecurityEnvelopes('process',base,deriveSecurityEnvelope('process',changedPin)).relation,'UNVERIFIED');
+  assert.equal(compareSecurityEnvelopes('process',base,deriveSecurityEnvelope('process',moved)).relation,'UNVERIFIED');
+});
+
+test('grant outside predecessor scope is rejected before a continuity record exists',()=>{
+  const badGrant={...grant,root_ids:['missing'],policy_sha256:sha(policyBytes)};
+  const badBytes=Buffer.from(JSON.stringify(badGrant));
+  assert.throws(()=>captureStandingGrant({plane:'process',policyBytes,grantBytes:badBytes,predecessor,candidate,updateId}),/scope invalid/i);
+});
+
+test('candidate or predecessor identity must be complete and hash-bound',()=>{
+  assert.throws(()=>captureStandingGrant({plane:'process',policyBytes,grantBytes,predecessor:{release_id:'x',generation_manifest_sha256:'bad'},candidate,updateId}),/identity invalid/i);
+  assert.throws(()=>captureStandingGrant({plane:'process',policyBytes,grantBytes,predecessor,candidate:{version:'0.15.42',manifest_sha256:'bad'},updateId}),/identity invalid/i);
+});

package/test/r65-authority-durable-policy-binding.test.mjs

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import {createAuthorityEpochStore,deriveSecurityEnvelope} from '../src/authority-continuity-r65.mjs';
+import {prepareAuthorityTestTrust} from './r65-authority-test-trust.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+test('durable standing epoch binds exact policy bytes and canonical security ceiling',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-durable-policy-'));
+  try{
+    const runtime=await prepareAuthorityTestTrust(root);
+    const grantFile=path.join(runtime,'coding-grant.json');
+    const policy={schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:grantFile,
+      evidence_dir:path.join(root,'evidence'),max_read_bytes:4096,max_write_bytes:4096,
+      roots:{core:{path:path.join(root,'project'),read:true,write:true,exec:false,deny_paths:[]}},commands:{}};
+    const policyBytes=Buffer.from(JSON.stringify(policy));
+    const grantBytes=Buffer.from(JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:sha(policyBytes),
+      instance_nonce:'a'.repeat(64),root_ids:['core'],granted_at_utc:'2026-10-06T00:00:00Z'}));
+    await writeFile(grantFile,grantBytes);
+    const store=createAuthorityEpochStore({runtimeDir:runtime,policyBytes});
+    const head=await store.append({plane:'coding',action:'grant',grantBytes,grantInstanceNonce:'a'.repeat(64),updateId:null});
+    const event=JSON.parse(await readFile(path.join(runtime,'authority-epochs','coding','events',head.event_file),'utf8'));
+    assert.equal(event.policy_sha256,sha(policyBytes));
+    assert.equal(event.policy_envelope_sha256,deriveSecurityEnvelope('coding',policy).sha256);
+    assert.equal((await store.verifyGrant({plane:'coding',grantBytes,grantInstanceNonce:'a'.repeat(64),policyBytes})).trusted,true);
+    const changed=Buffer.from(JSON.stringify({...policy,max_read_bytes:8192}));
+    assert.equal((await store.verifyGrant({plane:'coding',grantBytes,grantInstanceNonce:'a'.repeat(64),policyBytes:changed})).trusted,false,
+      'a changed policy must not inherit a prior epoch even with the same grant bytes');
+  }finally{await rm(root,{recursive:true,force:true});}
+});