deadbyte-mcp 0.15.41 → 0.15.43

package/test/desktop-runtime-r40.test.mjs

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { createDesktopFrame } from '../src/desktop-contract.mjs';
 import { DESKTOP_POLICY_SCHEMA,DESKTOP_GRANT_SCHEMA } from '../src/desktop-policy-r40.mjs';
 import { createDesktopRuntime,verifyDesktopReceiptObject } from '../src/desktop-runtime-r40.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const H=value=>createHash('sha256').update(String(value)).digest('hex');
 const EPOCH=H('epoch');
@@ -21,7 +22,7 @@ function F(at,image=H('same'),window=WIN){
 }
 async function fixture({grantActions=['click_primary','text_input'],captureFrames=null,times=null,inputProvider=null,grounderProvider=null,clockMs=null,sleeper=null}={}){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r40-desktop-runtime-'));
-  const grant=path.join(root,'grant.json'),evidence=path.join(root,'evidence');
+  const grant=path.join(root,'runtime','grant.json'),evidence=path.join(root,'evidence');
   const policy={
     schema:DESKTOP_POLICY_SCHEMA,enabled:true,policy_path:path.join(root,'policy.json'),
     policy_sha256:H('policy'),grant_file:grant,evidence_dir:evidence,
@@ -31,9 +32,13 @@ async function fixture({grantActions=['click_primary','text_input'],captureFrame
     allowed_actions:['pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input'],
     limits:{max_frame_age_ms:2000,max_frame_bytes:8*1024*1024,capture_timeout_ms:5000,input_timeout_ms:2000,post_observe_timeout_ms:5000,max_preview_bytes:512*1024,max_text_bytes:4096}
   };
-  await writeFile(grant,JSON.stringify({
+  const {policy_path:policyPath,policy_sha256:_unusedSha,...rawPolicy}=policy;
+  const policyBytes=Buffer.from(JSON.stringify(rawPolicy));
+  await writeFile(policyPath,policyBytes);
+  policy.policy_sha256=createHash('sha256').update(policyBytes).digest('hex');
+  await writeBoundStandingGrant('desktop', grant, {
     schema:DESKTOP_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:H('grant-nonce'),action_kinds:grantActions
-  }));
+  });
   const expected=F('2026-09-19T02:00:00.000Z');
   const frames=captureFrames??[
     {frame:F('2026-09-19T02:00:00.700Z'),backend:'fake',byte_length:4},

package/test/host-inline-r45.test.mjs

@@ -7,13 +7,14 @@ import path from 'node:path';
 import {
   HOST_GRANT_SCHEMA, HOST_POLICY_SCHEMA_V2, hostExecInline, hostExecNative, loadHostPolicy
 } from '../src/host-plane.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
 
 async function fixture(){
   const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-host-inline-r45-'));
   const root=path.join(dir,'root');await mkdir(root);
-  const arm=path.join(dir,'arm.json'), policyPath=path.join(dir,'policy.json');
+  const arm=path.join(dir,'runtime','arm.json'), policyPath=path.join(dir,'policy.json');
   const exeSha=sha(await readFile(process.execPath));
   const raw={
     schema:HOST_POLICY_SCHEMA_V2,enabled:true,arm_file:arm,
@@ -27,8 +28,8 @@ async function fixture(){
   };
   await writeFile(policyPath,JSON.stringify(raw,null,2));
   const policy=await loadHostPolicy(policyPath);
-  await writeFile(arm,JSON.stringify({schema:HOST_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,
-    instance_nonce:randomBytes(32).toString('hex'),armed_at_utc:new Date().toISOString()},null,2));
+  await writeBoundStandingGrant('host', arm, {schema:HOST_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,
+    instance_nonce:randomBytes(32).toString('hex'),armed_at_utc:new Date().toISOString()},{space:2});
   return {dir,root,arm,policy,exeSha};
 }
 

package/test/machine-fs-runtime.test.mjs

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
 import { loadCodingPolicy } from '../src/coding-plane.mjs';
 import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machine-fs.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
@@ -15,17 +16,17 @@ async function fixture({ readWorkerPath = undefined, listEntryLstat = undefined
   const project = path.join(root, 'project');
   await mkdir(project);
   const policyPath = path.join(root, 'coding-policy.json');
-  const grantPath = path.join(root, 'coding-grant.json');
+  const grantPath = path.join(root, 'runtime', 'coding-grant.json');
   await writeFile(policyPath, JSON.stringify({
     schema: 'deadbyte.coding-policy.v1', enabled: true,
     lease_file: grantPath, evidence_dir: path.join(root, 'evidence'),
     roots: { project: { path: project, read: true, write: true, exec: false, deny_paths: ['blocked'] } },
     commands: {}, max_read_bytes: 65536, max_write_bytes: 65536
   }));  const policy = await loadCodingPolicy(policyPath);
-  await writeFile(grantPath, JSON.stringify({
+  await writeBoundStandingGrant('coding', grantPath, {
     schema: 'deadbyte.coding-grant.v2', policy_sha256: policy.policy_sha256,
     instance_nonce: 'b'.repeat(64), root_ids: ['project'], granted_at_utc: new Date().toISOString()
-  }));
+  });
   const keys = await generateTrustKeypair({
     privateKeyPath: path.join(root, 'private.pem'), publicKeyPath: path.join(root, 'public.pem')
   });

package/test/process-longrun-r36.test.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
 import { createProcessRuntime } from '../src/process-runtime.mjs';
 import { generateTrustKeypair } from '../src/trust.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const repo=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 const host=path.join(repo,'bin','deadbyte-process-host.exe');
@@ -20,11 +21,11 @@ async function fixture(){
   await mkdir(project); await mkdir(trust);
   const script=path.join(project,'longrun.mjs');
   await writeFile(script,`process.stdout.write('chunk-1\\n');\nsetTimeout(()=>process.stdout.write('chunk-2\\n'),180);\nsetTimeout(()=>process.stdout.write('chunk-3\\n'),360);\nsetTimeout(()=>process.exit(0),540);\n`);
-  const grantFile=path.join(root,'process-grant.json'); const stateDir=path.join(root,'state'); const policyPath=path.join(root,'process-policy.json');
+  const grantFile=path.join(root,'runtime','process-grant.json'); const stateDir=path.join(root,'state'); const policyPath=path.join(root,'process-policy.json');
   const raw={schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,native_host:{path:host,sha256:sha(await readFile(host))},roots:{core:{path:project,deny_paths:[]}},profiles:{longrun:{executable:process.execPath,executable_sha256:sha(await readFile(process.execPath)),root_ids:['core'],transport:'pipe',prefix_args:[script],max_args:0,max_arg_bytes:256,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}}};
   await writeFile(policyPath,JSON.stringify(raw));
   const policy=await loadProcessPolicy(policyPath);
-  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'6'.repeat(64),profile_ids:['longrun'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('process', grantFile, {schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'6'.repeat(64),profile_ids:['longrun'],root_ids:['core'],granted_at_utc:new Date().toISOString()});
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   const make=()=>createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   return {root,project,stateDir,policy,keys,make,runtime:make()};

package/test/process-policy.test.mjs

@@ -12,17 +12,19 @@ import {
   processSessionStatus,
   recheckProcessAuthority
 } from '../src/process-policy.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
 async function fixture() {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-process-policy-'));
+  await mkdir(path.join(root,'runtime'));
   const project = path.join(root, 'project');
   await mkdir(project);
   const executable = process.execPath;
   const executableSha = sha(await readFile(executable));
   const policyPath = path.join(root, 'process-policy.json');
-  const grantFile = path.join(root, 'process-grant.json');
+  const grantFile = path.join(root, 'runtime', 'process-grant.json');
   const stateDir = path.join(root, 'process-state');  const raw = {
     schema: PROCESS_POLICY_SCHEMA, enabled: true, grant_file: grantFile, state_dir: stateDir,
     native_host: { path: executable, sha256: executableSha },
@@ -52,14 +54,14 @@ test('process policy loads pinned native host, profile and root while grant is a
 });test('process standing grant binds exact policy, profile and root', async () => {
   const f = await fixture();
   const policy = await loadProcessPolicy(f.policyPath);
-  await writeFile(f.grantFile, JSON.stringify({
+  await writeBoundStandingGrant('process', f.grantFile, {
     schema: PROCESS_GRANT_SCHEMA,
     policy_sha256: policy.policy_sha256,
     instance_nonce: 'a'.repeat(64),
     profile_ids: ['node'],
     root_ids: ['core'],
     granted_at_utc: '2026-09-14T00:00:00Z'
-  }));
+  });
   const status = await processSessionStatus(policy);
   assert.equal(status.armed, true);
   assert.equal(status.reason, 'standing-grant');
@@ -81,13 +83,15 @@ test('process authority recheck rejects grant generation or scope drift before s
     root_ids: ['core'],
     granted_at_utc: '2026-09-14T00:00:00Z'
   };
-  await writeFile(f.grantFile, JSON.stringify(grant));
+  await writeBoundStandingGrant('process', f.grantFile, grant);
   const initial = await assertProcessArmed(policy, 'node', 'core');
   await writeFile(f.grantFile, JSON.stringify({ ...grant, instance_nonce: 'b'.repeat(64) }));
   await assert.rejects(() => recheckProcessAuthority(policy, initial, 'node', 'core'), /process authority changed during operation/);
   await writeFile(f.grantFile, JSON.stringify({ ...grant, profile_ids: ['node', 'node'] }));
-  const deduped = await recheckProcessAuthority(policy, initial, 'node', 'core');
-  assert.equal(deduped.instance_nonce, initial.instance_nonce);
+  await assert.rejects(
+    () => recheckProcessAuthority(policy, initial, 'node', 'core'),
+    /process authority changed during operation|epoch-grant-mismatch/
+  );
 });
 
 test('process grant with wrong policy digest is disarmed', async () => {

package/test/process-runtime.test.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
 import { createProcessRuntime } from '../src/process-runtime.mjs';
 import { generateTrustKeypair } from '../src/trust.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const host = path.join(repo, 'bin', 'deadbyte-process-host.exe');
@@ -21,7 +22,7 @@ async function fixture() {
   const project = path.join(root, 'project');
   const trust = path.join(root, 'trust');
   await mkdir(project); await mkdir(trust);
-  const grantFile = path.join(root, 'process-grant.json');
+  const grantFile = path.join(root, 'runtime', 'process-grant.json');
   const stateDir = path.join(root, 'process-state');
   const policyPath = path.join(root, 'process-policy.json');
   const hostSha = sha(await readFile(host));
@@ -66,11 +67,11 @@ async function fixture() {
   };
   await writeFile(policyPath, JSON.stringify(raw));
   const policy = await loadProcessPolicy(policyPath);
-  await writeFile(grantFile, JSON.stringify({
+  await writeBoundStandingGrant('process', grantFile, {
     schema: PROCESS_GRANT_SCHEMA, policy_sha256: policy.policy_sha256,
     instance_nonce: 'a'.repeat(64), profile_ids: ['echo', 'hold', 'conptyhold', 'powershell', 'powershell_repl'], root_ids: ['core'],
     granted_at_utc: '2026-09-14T00:00:00Z'
-  }));
+  });
   const keys = await generateTrustKeypair({
     privateKeyPath: path.join(trust, 'private.pem'), publicKeyPath: path.join(trust, 'public.pem')
   });
@@ -99,9 +100,11 @@ test('R31 runtime starts one approved profile and exposes ordered bounded output
   assert.equal(started.profile_id, 'echo');
   assert.equal(started.stream_id, started.session_id);
   assert.equal(started.stream_generation, 1);
-  assert.equal(started.stream_next_seq, 1);
-  assert.equal(started.stream_coverage.logical_item_count, 0);
-  assert.equal(started.stream_coverage.retained_item_count, 0);
+  // The child may emit its first chunk while start() persists the started
+  // event. Assert stream/coverage coherence, not an impossible empty-stream
+  // timing promise that fails only under parallel suite load.
+  assert.equal(started.stream_next_seq, started.stream_coverage.logical_item_count + 1);
+  assert.ok(started.stream_coverage.retained_item_count <= started.stream_coverage.logical_item_count);
   assert.equal(started.stream_coverage.complete, true);
   const observed = await waitFor(f.runtime, started.session_id, text => text.includes('DBR31RUNTIME:42'));
   assert.match(observed.text, /DBR31RUNTIME:42/);

package/test/r52-host-revocation.test.mjs

@@ -13,6 +13,7 @@ async function runRevoke(t,prelude){
   // filesystem that refuses deletion while Test-Path still sees the grant.
   const script=`$ErrorActionPreference='Stop'
 function Get-HostPolicyMetadata($Cfg) { return @{ArmFile='fixture-host-grant'} }
+function Invoke-AuthorityEpochCommand($Cfg,[string]$Plane,[string]$Action,[string]$GrantFile) { return @{} }
 ${prelude}
 ${source.slice(begin,end)}
 try { Disarm-Host @{}; exit 0 } catch { Write-Output $_.Exception.Message; exit 7 }

package/test/r58-doctor-runtime.test.mjs

@@ -43,3 +43,21 @@ test('R58 doctor surfaces corrupt grants and authority dependency loss without s
  const report=classifyDoctorControllerObservation(host,coreRoot);assert.equal(report.status,'WARN');assert.equal(host.authority.host.armed,true);
  for(const finding of report.findings.filter(f=>f.level!=='PASS'))assert.ok(finding.what&&finding.evidence&&finding.next_action);
 });
+
+test('R66 doctor accepts strict epoch metadata on armed authority observations',()=>{
+ const snapshot=online();
+ snapshot.authority.process={configured:true,armed:true,reason:'standing-grant',epoch_seq:1,epoch_sha256:'a'.repeat(64)};
+ const validated=validateDoctorControllerObservation(snapshot,coreRoot);
+ assert.equal(validated.authority.process.epoch_seq,1);
+ assert.equal(validated.authority.process.epoch_sha256,'a'.repeat(64));
+ for(const process of [
+  {configured:true,armed:true,reason:'standing-grant',epoch_seq:1},
+  {configured:true,armed:true,reason:'standing-grant',epoch_sha256:'a'.repeat(64)},
+  {configured:true,armed:true,reason:'standing-grant',epoch_seq:0,epoch_sha256:'a'.repeat(64)},
+  {configured:true,armed:true,reason:'standing-grant',epoch_seq:1,epoch_sha256:'not-a-sha'},
+  {configured:true,armed:false,reason:'disarmed',epoch_seq:1,epoch_sha256:'a'.repeat(64)},
+  {configured:true,armed:true,reason:'standing-grant',epoch_seq:1,epoch_sha256:'a'.repeat(64),injected:true}
+ ]){
+  assert.throws(()=>validateDoctorControllerObservation({...online(),authority:{...authority(),process}},coreRoot));
+ }
+});

package/test/r59-tool-surface-compat.test.mjs

@@ -83,7 +83,7 @@ test('R59 compact baseline changes only at the explicitly authorized R64 read-of
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
   const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
-  if(packageVersion==='0.15.41'){
+  if(['0.15.41','0.15.42','0.15.43'].includes(packageVersion)){
     assert.deepEqual(diff.schema_changed,['machine_fs']);
     assert.equal(diff.unchanged.length,42);
     const prior=baseline.tools.find(tool=>tool.name==='machine_fs');

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

@@ -4,6 +4,7 @@ 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',
@@ -11,7 +12,7 @@ const runtime={
   generation_manifest_sha256:'f47cb96083679e764725df1bde6eda53169a39f55772c173ab22f89a1dfaa7ab'
 };
 
-test('R64 release identity distinguishes unsealed source predecessor from active runtime predecessor',async()=>{
+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'),

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