deadbyte-mcp 0.15.41 → 0.15.42

package/src/authority-continuity-r65.mjs

@@ -0,0 +1,541 @@
+import {createHash,createPrivateKey,createPublicKey,randomBytes,sign as cryptoSign,verify as cryptoVerify} from 'node:crypto';
+import {mkdir,open,readFile,readdir,rename,rm,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {canonicalJson} from './canonical-json.mjs';
+import {decodeUtf8Strict} from './text-policy.mjs';
+
+const SHAPAT=/^[0-9a-f]{64}$/;
+const SCHEMAS=Object.freeze({
+  process:'deadbyte.process-policy.v1',coding:'deadbyte.coding-policy.v1',
+  autonomous:'deadbyte.autonomous-policy.v1',desktop:'deadbyte.desktop-policy.v1',
+  host:['deadbyte.host-policy.v1','deadbyte.host-policy.v2']
+});
+const TOP=Object.freeze({
+  process:['schema','enabled','grant_file','state_dir','native_host','roots','profiles'],
+  coding:['schema','enabled','lease_file','evidence_dir','max_read_bytes','max_write_bytes','roots','commands'],
+  autonomous:['schema','enabled','lease_file','evidence_dir','coding_policy_sha256','root_ids','planner','limits','profiles'],
+  desktop:['schema','enabled','grant_file','evidence_dir','observer','input','grounder','allowed_input_desktops','allowed_actions','limits'],
+  host:['schema','enabled','arm_file','max_read_bytes','max_write_bytes','roots','commands','native_exec']
+});
+const FIELDS=Object.freeze({
+  native_host:['path','sha256'],
+  process_root:['path','deny_paths'],
+  process_profile:['executable','executable_sha256','root_ids','prefix_args','transport','allow_raw_input','max_args','max_arg_bytes','max_sessions','max_input_bytes','max_retained_output_bytes','env_allow','input_actions'],
+  coding_root:['path','read','write','exec','deny_paths'],
+  coding_command:['kind','executable','executable_sha256','root_ids','prefix_args','extensions','timeout_ms','max_output_bytes'],
+  autonomous_planner:['backend','endpoint','model','max_tokens','timeout_ms','max_response_bytes','api_key_env','reasoning_effort','root_id','executable','executable_sha256','args','circuit'],
+  autonomous_limits:['max_iterations','max_mutations','max_wall_ms','max_context_bytes','max_diff_bytes','max_files_per_diff','max_stalled_cycles','max_post_replan_stalls','max_replans'],
+  autonomous_profile:['kind','root_id','command_id','script_path','script_sha256','args','cwd','timeout_ms','expect_exit_code','required_for_release','run_after_mutation','warmups','iterations','baseline_median_ms','max_regression_pct','description'],
+  desktop_provider:['executable','sha256','backend'],
+  desktop_limits:['max_frame_age_ms','max_frame_bytes','capture_timeout_ms','input_timeout_ms','ground_timeout_ms','post_observe_timeout_ms','max_preview_bytes','max_text_bytes'],
+  host_root:['path','read','write','exec','deny_paths'],
+  host_command:['kind','executable','executable_sha256','root_ids','prefix_args','extensions','timeout_ms','max_output_bytes','max_command_chars'],
+  native_exec:['enabled','root_ids','timeout_ms','max_output_bytes','max_args','max_arg_chars']
+});
+const STORAGE=new Set(['grant_file','state_dir','lease_file','evidence_dir','arm_file']);
+const sha=value=>createHash('sha256').update(canonicalJson(value)).digest('hex');
+const hashBytes=bytes=>createHash('sha256').update(bytes).digest('hex');
+const plain=value=>value&&typeof value==='object'&&!Array.isArray(value);
+
+function known(value,fields,label){
+  if(!plain(value))throw new Error(`${label} invalid`);
+  for(const key of Object.keys(value))if(!fields.includes(key))throw new Error(`${label} unknown field ${key}`);
+  return value;
+}
+function absolute(value,label){
+  if(typeof value!=='string'||!path.win32.isAbsolute(value)||value.includes('\0'))throw new Error(`${label} invalid path`);
+  return path.win32.normalize(value).toLowerCase();
+}
+function normalize(value,field,label){
+  if(value===undefined)return undefined;
+  if(field==='description')return undefined; // Non-authoritative presentation text.
+  if(field==='path'||field==='executable')return absolute(value,label);
+  if(field==='script_path'){
+    if(typeof value!=='string'||value.length<1||path.win32.isAbsolute(value)||value.split(/[\\/]/).includes('..')||value.includes('\0'))throw new Error(`${label} invalid relative path`);
+    return value.replaceAll('\\','/').toLowerCase();
+  }
+  if(field.endsWith('sha256')){
+    if(typeof value!=='string'||!SHAPAT.test(value))throw new Error(`${label} invalid SHA-256`);
+    return value;
+  }
+  if(Array.isArray(value)){
+    if(value.length>128||value.some(item=>typeof item!=='string'||item.length>4096||item.includes('\0')))throw new Error(`${label} invalid list`);
+    return ['prefix_args','args'].includes(field)?[...value]:[...new Set(value)].sort();
+  }
+  if(plain(value)){
+    if(Object.keys(value).length>256)throw new Error(`${label} oversized map`);
+    return Object.fromEntries(Object.entries(value).sort(([a],[b])=>a.localeCompare(b,'en')).map(([key,item])=>{
+      if(!/^[A-Za-z0-9._-]{1,64}$/.test(key))throw new Error(`${label} invalid identifier`);
+      if(typeof item!=='string'||item.includes('\0')||item.length>65536)throw new Error(`${label} invalid action payload`);
+      return [key,item];
+    }));
+  }
+  if(value===null)return null;
+  if(typeof value==='boolean'||typeof value==='string')return value;
+  if(typeof value==='number'&&Number.isFinite(value)&&value>=0&&value<=Number.MAX_SAFE_INTEGER)return value;
+  throw new Error(`${label} invalid value`);
+}
+function fixed(value,fields,label){
+  known(value,fields,label);
+  return Object.fromEntries(Object.entries(value).filter(([key])=>key!=='description').map(([key,item])=>
+    [key,key==='circuit'?fixed(item,['failure_threshold','open_ms','half_open_probe_limit'],`${label}.${key}`):normalize(item,key,`${label}.${key}`)]));
+}
+function map(value,fields,label){
+  if(!plain(value)||Object.keys(value).length>256)throw new Error(`${label} invalid map`);
+  return Object.fromEntries(Object.entries(value).sort(([a],[b])=>a.localeCompare(b,'en')).map(([id,item])=>{
+    if(!/^[A-Za-z0-9._-]{1,64}$/.test(id))throw new Error(`${label} invalid identifier`);
+    return [id,fixed(item,fields,`${label}.${id}`)];
+  }));
+}
+
+export function deriveSecurityEnvelope(plane,raw){
+  const schemas=SCHEMAS[plane];
+  if(!schemas)throw new Error('unknown authority plane');
+  known(raw,TOP[plane],`${plane} policy`);
+  if(!(Array.isArray(schemas)?schemas:[schemas]).includes(raw.schema)||typeof raw.enabled!=='boolean')throw new Error(`${plane} policy schema/enabled invalid`);
+  const semantics={schema:raw.schema,enabled:raw.enabled};
+  for(const [key,value] of Object.entries(raw)){
+    if(key==='schema'||key==='enabled'||STORAGE.has(key))continue;
+    if(key==='roots')semantics.roots=map(value,FIELDS[`${plane}_root`],`${plane}.roots`);
+    else if(key==='profiles'&&plane==='process')semantics.profiles=map(value,FIELDS.process_profile,'process.profiles');
+    else if(key==='profiles'&&plane==='autonomous')semantics.profiles=map(value,FIELDS.autonomous_profile,'autonomous.profiles');
+    else if(key==='commands')semantics.commands=map(value,FIELDS[`${plane}_command`],`${plane}.commands`);
+    else if(key==='native_host')semantics.native_host=fixed(value,FIELDS.native_host,'process.native_host');
+    else if(key==='native_exec')semantics.native_exec=fixed(value,FIELDS.native_exec,'host.native_exec');
+    else if(key==='planner')semantics.planner=fixed(value,FIELDS.autonomous_planner,'autonomous.planner');
+    else if(key==='limits')semantics.limits=fixed(value,FIELDS[`${plane}_limits`],`${plane}.limits`);
+    else if(['observer','input','grounder'].includes(key))semantics[key]=fixed(value,FIELDS.desktop_provider,`desktop.${key}`);
+    else semantics[key]=normalize(value,key,`${plane}.${key}`);
+  }
+  const envelope={schema:'deadbyte.authority-envelope.r65.v1',plane,semantics};
+  return Object.freeze({...envelope,sha256:sha(envelope)});
+}
+
+function relation(before,after,field){
+  if(before===after)return 'EQUAL';
+  if(before===undefined)return 'WIDER';
+  if(after===undefined)return 'NARROWER';
+  if(typeof before==='boolean'&&typeof after==='boolean')return after?'WIDER':'NARROWER';
+  if(typeof before==='number'&&typeof after==='number')return after>before?'WIDER':'NARROWER';
+  if(Array.isArray(before)&&Array.isArray(after)){
+    if(canonicalJson(before)===canonicalJson(after))return 'EQUAL';
+    if(['prefix_args','args'].includes(field))return canonicalJson(before)===canonicalJson(after)?'EQUAL':'UNVERIFIED';
+    const prior=new Set(before),next=new Set(after);
+    if(field==='deny_paths')return [...prior].every(x=>next.has(x))?'NARROWER':'WIDER';
+    return [...next].every(x=>prior.has(x))?'NARROWER':'WIDER';
+  }
+  if(plain(before)&&plain(after)){
+    let narrowed=false,unverified=false;
+    for(const key of new Set([...Object.keys(before),...Object.keys(after)])){
+      const part=relation(before[key],after[key],key);
+      if(part==='WIDER')return 'WIDER';
+      if(part==='UNVERIFIED')unverified=true;
+      if(part==='NARROWER')narrowed=true;
+    }
+    return unverified?'UNVERIFIED':narrowed?'NARROWER':'EQUAL';
+  }
+  if(typeof before==='string'&&typeof after==='string'&&field==='path'){
+    const prefix=before.endsWith('\\')?before:before+'\\';
+    return after.startsWith(prefix)?'NARROWER':'UNVERIFIED';
+  }
+  return 'UNVERIFIED';
+}
+
+export function compareSecurityEnvelopes(plane,prior,successor){
+  if(prior?.plane!==plane||successor?.plane!==plane||prior?.schema!=='deadbyte.authority-envelope.r65.v1'||
+      successor?.schema!==prior.schema||prior.sha256!==sha({schema:prior.schema,plane,semantics:prior.semantics})||
+      successor.sha256!==sha({schema:successor.schema,plane,semantics:successor.semantics}))
+    return Object.freeze({relation:'UNVERIFIED',reason:'envelope identity invalid'});
+  return Object.freeze({relation:relation(prior.semantics,successor.semantics,''),prior_sha256:prior.sha256,successor_sha256:successor.sha256});
+}
+
+const GRANT_SCHEMAS=Object.freeze({
+  process:'deadbyte.process-grant.v1',coding:'deadbyte.coding-grant.v2',
+  autonomous:'deadbyte.autonomous-grant.v2',desktop:'deadbyte.desktop-grant.v1',host:'deadbyte.host-grant.v2'
+});
+const GRANT_FIELDS=Object.freeze({
+  process:['schema','policy_sha256','instance_nonce','profile_ids','root_ids','granted_at_utc'],
+  coding:['schema','policy_sha256','instance_nonce','root_ids','granted_at_utc'],
+  autonomous:['schema','policy_sha256','coding_policy_sha256','instance_nonce','root_ids','granted_at_utc'],
+  desktop:['schema','policy_sha256','instance_nonce','action_kinds','granted_at_utc'],
+  host:['schema','policy_sha256','instance_nonce','granted_at_utc']
+});
+function scopeIds(values,allowed,label){
+  if(!Array.isArray(values)||values.length<1||values.length>128||new Set(values).size!==values.length||
+      values.some(id=>typeof id!=='string'||!Object.hasOwn(allowed,id)))throw new Error(`${label} scope invalid`);
+  return [...values].sort();
+}
+
+export function captureStandingGrant({plane,policyBytes,grantBytes,predecessor,candidate,updateId}){
+  if(!GRANT_SCHEMAS[plane]||!Buffer.isBuffer(policyBytes)||!Buffer.isBuffer(grantBytes)||
+      typeof predecessor?.release_id!=='string'||!SHAPAT.test(String(predecessor?.generation_manifest_sha256))||
+      typeof candidate?.version!=='string'||!SHAPAT.test(String(candidate?.manifest_sha256))||
+      typeof updateId!=='string'||!/^[A-Za-z0-9._-]{1,96}$/.test(updateId))throw new Error('authority continuity predecessor/candidate identity invalid');
+  let policy,grant;
+  try{policy=JSON.parse(decodeUtf8Strict(policyBytes));grant=JSON.parse(decodeUtf8Strict(grantBytes));}
+  catch{throw new Error('authority continuity policy/grant JSON invalid');}
+  const envelope=deriveSecurityEnvelope(plane,policy);
+  known(grant,GRANT_FIELDS[plane],`${plane} grant`);
+  if(grant.schema!==GRANT_SCHEMAS[plane])throw new Error(`${plane} grant schema invalid`);
+  const policySha256=hashBytes(policyBytes),grantSha256=hashBytes(grantBytes);
+  if(grant.policy_sha256!==policySha256)throw new Error(`${plane} grant policy SHA-256 mismatch`);
+  if(!SHAPAT.test(String(grant.instance_nonce)))throw new Error(`${plane} grant instance nonce invalid`);
+  if(typeof grant.granted_at_utc!=='string'||!Number.isFinite(Date.parse(grant.granted_at_utc)))throw new Error(`${plane} grant timestamp invalid`);
+  const grantedScope={};
+  if(plane==='process'){
+    grantedScope.profile_ids=scopeIds(grant.profile_ids,policy.profiles,'process profiles');
+    grantedScope.root_ids=scopeIds(grant.root_ids,policy.roots,'process roots');
+    for(const id of grantedScope.profile_ids)if(policy.profiles[id].root_ids.some(rootId=>!grantedScope.root_ids.includes(rootId)))
+      throw new Error('process profile root scope exceeds grant');
+  }else if(plane==='coding')grantedScope.root_ids=scopeIds(grant.root_ids,policy.roots,'coding roots');
+  else if(plane==='autonomous'){
+    grantedScope.root_ids=scopeIds(grant.root_ids,Object.fromEntries((policy.root_ids??[]).map(id=>[id,true])),'autonomous roots');
+    if(grant.coding_policy_sha256!==policy.coding_policy_sha256)throw new Error('autonomous grant Coding policy SHA-256 mismatch');
+  }else if(plane==='desktop'){
+    grantedScope.action_kinds=scopeIds(grant.action_kinds,Object.fromEntries((policy.allowed_actions??[]).map(id=>[id,true])),'desktop actions');
+  }
+  const record={schema:'deadbyte.authority-continuity.r65.v1',update_id:updateId,
+    predecessor_release:predecessor.release_id,predecessor_generation_manifest_sha256:predecessor.generation_manifest_sha256,
+    candidate_version:candidate.version,candidate_manifest_sha256:candidate.manifest_sha256,plane,
+    prior_policy_sha256:policySha256,prior_policy_envelope_sha256:envelope.sha256,
+    grant_schema:grant.schema,grant_sha256:grantSha256,grant_instance_nonce:grant.instance_nonce,
+    granted_scope:grantedScope,granted_at_utc:grant.granted_at_utc};
+  return Object.freeze({...record,subject_sha256:sha(record)});
+}
+
+const DURABLE_EPOCH_ACTIONS=new Set(['grant','transaction_revoke','user_revoke','transaction_restore']);
+const DURABLE_EPOCH_SCHEMA='deadbyte.authority-epoch-event.r65.v1';
+const DURABLE_HEAD_SCHEMA='deadbyte.authority-epoch-head.r65.v1';
+const DURABLE_EPOCH_DOMAIN=Buffer.from('DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1\0','utf8');
+const RESTORE_BINDING_FIELDS=Object.freeze(['prior_grant_sha256','prior_grant_instance_nonce','predecessor_policy_envelope_sha256','successor_policy_envelope_sha256','candidate_manifest_sha256','continuity_subject_sha256']);
+function normalizeRestoreBinding(value,{required=false}={}){
+  if(value===undefined||value===null){if(required)throw new Error('authority epoch transaction restore binding required');return null;}
+  if(!plain(value)||Object.keys(value).length!==RESTORE_BINDING_FIELDS.length||RESTORE_BINDING_FIELDS.some(key=>!SHAPAT.test(String(value[key]))))
+    throw new Error('authority epoch transaction restore binding invalid');
+  for(const key of Object.keys(value))if(!RESTORE_BINDING_FIELDS.includes(key))throw new Error('authority epoch transaction restore binding invalid');
+  return Object.freeze(Object.fromEntries(RESTORE_BINDING_FIELDS.map(key=>[key,String(value[key])])));
+}
+
+async function durableEpochKeys(runtimeDir,{privateRequired=false}={}){
+  const trust=path.join(path.dirname(path.resolve(runtimeDir)),'trust');
+  const publicKey=createPublicKey(await readFile(path.join(trust,'ed25519-public.pem')));
+  if(publicKey.asymmetricKeyType!=='ed25519')throw new Error('authority epoch trust public key invalid');
+  const keyId=hashBytes(Buffer.from(publicKey.export({format:'der',type:'spki'})));
+  if(!privateRequired)return {publicKey,keyId};
+  const privateKey=createPrivateKey(await readFile(path.join(trust,'ed25519-private.pem')));
+  if(privateKey.asymmetricKeyType!=='ed25519'||
+      hashBytes(Buffer.from(createPublicKey(privateKey).export({format:'der',type:'spki'})))!==keyId)
+    throw new Error('authority epoch trust key pair mismatch');
+  return {publicKey,privateKey,keyId};
+}
+
+function durableEventBody(event){
+  const {attestation,...body}=event;
+  return body;
+}
+function verifyDurableEvent(event,publicKey,keyId){
+  if(!plain(event)||!plain(event.attestation)||event.attestation.algorithm!=='ed25519'||
+      event.attestation.domain!=='DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1'||
+      event.attestation.key_id!==keyId||typeof event.attestation.signature_base64!=='string')return false;
+  try{
+    const signature=Buffer.from(event.attestation.signature_base64,'base64');
+    if(signature.length!==64||signature.toString('base64')!==event.attestation.signature_base64)return false;
+    return cryptoVerify(null,Buffer.concat([DURABLE_EPOCH_DOMAIN,Buffer.from(canonicalJson(durableEventBody(event)),'utf8')]),publicKey,signature);
+  }catch{return false;}
+}
+
+function durableEpochDir(runtimeDir,plane){
+  if(!SCHEMAS[plane])throw new Error('authority epoch plane invalid');
+  if(typeof runtimeDir!=='string'||runtimeDir.length<1)throw new Error('authority epoch runtime directory invalid');
+  return path.join(path.resolve(runtimeDir),'authority-epochs',plane);
+}
+function durableEventName(seq,eventSha256){
+  return `${String(seq).padStart(16,'0')}-${eventSha256}.json`;
+}
+function processAlive(pid){
+  if(!Number.isInteger(pid)||pid<1)return false;
+  if(pid===process.pid)return true;
+  try{process.kill(pid,0);return true;}catch(error){return error?.code==='EPERM';}
+}
+async function atomicJsonWrite(file,value){
+  const dir=path.dirname(file);
+  await mkdir(dir,{recursive:true});
+  const tmp=`${file}.tmp-${process.pid}-${randomBytes(8).toString('hex')}`;
+  try{
+    await writeFile(tmp,canonicalJson(value),{encoding:'utf8',flag:'wx'});
+    await rename(tmp,file);
+  }finally{
+    await rm(tmp,{force:true}).catch(()=>{});
+  }
+}
+async function acquireEpochLock(dir){
+  await mkdir(dir,{recursive:true});
+  const lockPath=path.join(dir,'.lock');
+  for(let attempt=0;attempt<2;attempt++){
+    const token=randomBytes(16).toString('hex');
+    try{
+      const handle=await open(lockPath,'wx');
+      try{await handle.writeFile(canonicalJson({schema:'deadbyte.authority-epoch-lock.r65.v1',pid:process.pid,token,created_at_utc:new Date().toISOString()}),'utf8');}
+      finally{await handle.close();}
+      return async()=>{
+        try{
+          const current=JSON.parse(await readFile(lockPath,'utf8'));
+          if(current?.token===token)await rm(lockPath,{force:true});
+        }catch(error){if(error?.code!=='ENOENT')throw error;}
+      };
+    }catch(error){
+      if(error?.code!=='EEXIST')throw error;
+      let owner=null;
+      try{owner=JSON.parse(await readFile(lockPath,'utf8'));}catch{}
+      if(attempt===0&&owner&&Number.isInteger(owner.pid)&&!processAlive(owner.pid)){
+        await rm(lockPath,{force:true});
+        continue;
+      }
+      throw new Error('authority epoch mutation locked');
+    }
+  }
+  throw new Error('authority epoch mutation locked');
+}
+async function readDurableHead(runtimeDir,plane){
+  const dir=durableEpochDir(runtimeDir,plane),headPath=path.join(dir,'head.json');
+  let head;
+  try{head=JSON.parse(await readFile(headPath,'utf8'));}
+  catch(error){
+    if(error?.code==='ENOENT')return null;
+    throw new Error('authority epoch head invalid');
+  }
+  if(!plain(head)||head.schema!==DURABLE_HEAD_SCHEMA||head.plane!==plane||
+      !Number.isSafeInteger(head.seq)||head.seq<1||!DURABLE_EPOCH_ACTIONS.has(head.action)||
+      !SHAPAT.test(String(head.event_sha256))||!SHAPAT.test(String(head.grant_sha256))||
+      !SHAPAT.test(String(head.grant_instance_nonce))||
+      (head.previous_event_sha256!==null&&!SHAPAT.test(String(head.previous_event_sha256)))||
+      typeof head.event_file!=='string'||path.basename(head.event_file)!==head.event_file)
+    throw new Error('authority epoch head invalid');
+  const headRestoreBinding=normalizeRestoreBinding(head.restore_binding,{required:head.action==='transaction_restore'});
+  if(head.action!=='transaction_restore'&&headRestoreBinding!==null)throw new Error('authority epoch unexpected restore binding');
+  const expectedName=durableEventName(head.seq,head.event_sha256);
+  if(head.event_file!==expectedName)throw new Error('authority epoch head event name mismatch');
+  const eventNames=await readdir(path.join(dir,'events'));
+  if(eventNames.length>10000)throw new Error('authority epoch event budget exceeded');
+  for(const name of eventNames){
+    const match=/^(\d{16})-([0-9a-f]{64})\.json$/.exec(name);
+    if(!match)throw new Error('authority epoch unexpected event file');
+    const seq=Number(match[1]);
+    if(!Number.isSafeInteger(seq)||seq>head.seq||(seq===head.seq&&name!==head.event_file))
+      throw new Error('authority epoch head replay or incomplete write');
+  }
+  let eventBytes;
+  try{eventBytes=await readFile(path.join(dir,'events',head.event_file));}
+  catch{throw new Error('authority epoch event missing');}
+  if(hashBytes(eventBytes)!==head.event_sha256)throw new Error('authority epoch event hash mismatch');
+  let event;
+  try{event=JSON.parse(decodeUtf8Strict(eventBytes));}catch{throw new Error('authority epoch event invalid');}
+  const {publicKey,keyId}=await durableEpochKeys(runtimeDir);
+  if(!verifyDurableEvent(event,publicKey,keyId))throw new Error('authority epoch event signature invalid');
+  for(const key of ['schema','plane','seq','action','update_id','grant_sha256','grant_instance_nonce','previous_event_sha256']){
+    const expected=key==='schema'?DURABLE_EPOCH_SCHEMA:head[key];
+    if(event?.[key]!==expected)throw new Error('authority epoch head/event mismatch');
+  }
+  const eventRestoreBinding=normalizeRestoreBinding(event?.restore_binding,{required:head.action==='transaction_restore'});
+  if(canonicalJson(eventRestoreBinding)!==canonicalJson(headRestoreBinding))throw new Error('authority epoch restore binding mismatch');
+  if((head.policy_sha256!==undefined||head.policy_envelope_sha256!==undefined||
+      event.policy_sha256!==undefined||event.policy_envelope_sha256!==undefined)&&
+      (!SHAPAT.test(String(head.policy_sha256))||!SHAPAT.test(String(head.policy_envelope_sha256))||
+       head.policy_sha256!==event.policy_sha256||head.policy_envelope_sha256!==event.policy_envelope_sha256))
+    throw new Error('authority epoch policy binding invalid');
+  if(head.seq===1&&head.previous_event_sha256!==null)throw new Error('authority epoch genesis chain invalid');
+  if(head.seq>1){
+    if(!SHAPAT.test(String(head.previous_event_sha256)))throw new Error('authority epoch predecessor missing');
+    const priorName=durableEventName(head.seq-1,head.previous_event_sha256);
+    let priorBytes;
+    try{priorBytes=await readFile(path.join(dir,'events',priorName));}
+    catch{throw new Error('authority epoch predecessor event missing');}
+    if(hashBytes(priorBytes)!==head.previous_event_sha256)throw new Error('authority epoch predecessor hash mismatch');
+    let prior;
+    try{prior=JSON.parse(decodeUtf8Strict(priorBytes));}catch{throw new Error('authority epoch predecessor invalid');}
+    if(!verifyDurableEvent(prior,publicKey,keyId)||prior.seq!==head.seq-1||prior.plane!==plane)
+      throw new Error('authority epoch predecessor signature invalid');
+  }
+  return Object.freeze({...head});
+}
+
+export function createAuthorityEpochStore({runtimeDir,policyBytes=null}={}){
+  const root=path.resolve(String(runtimeDir??''));
+  if(!runtimeDir)throw new Error('authority epoch runtime directory invalid');
+  if(policyBytes!==null&&!Buffer.isBuffer(policyBytes))throw new Error('authority epoch policy bytes invalid');
+  return Object.freeze({
+    async readHead({plane}){
+      return readDurableHead(root,plane);
+    },
+    async append({plane,action,grantBytes,grantInstanceNonce,updateId=null,expectedHeadSha256=undefined,restoreBinding=null}){
+      const transactional=action?.startsWith('transaction_')===true;
+      if(!SCHEMAS[plane]||!DURABLE_EPOCH_ACTIONS.has(action)||!Buffer.isBuffer(grantBytes)||
+          !SHAPAT.test(String(grantInstanceNonce))||
+          (transactional?!/^[A-Za-z0-9._-]{1,96}$/.test(String(updateId??'')):updateId!==null)||
+          (expectedHeadSha256!==undefined&&!SHAPAT.test(String(expectedHeadSha256))))
+        throw new Error('authority epoch append input invalid');
+      if(transactional&&expectedHeadSha256===undefined)
+        throw new Error('authority epoch transaction expected head required for compare-and-swap');
+      const normalizedRestoreBinding=normalizeRestoreBinding(restoreBinding,{required:action==='transaction_restore'});
+      if(action!=='transaction_restore'&&normalizedRestoreBinding!==null)throw new Error('authority epoch restore binding only applies to transaction restore');
+      let parsedGrant;
+      try{parsedGrant=JSON.parse(decodeUtf8Strict(grantBytes));}catch{throw new Error('authority epoch grant JSON invalid');}
+      if(parsedGrant?.instance_nonce!==grantInstanceNonce)throw new Error('authority epoch grant nonce mismatch');
+      let policyBinding=null;
+      if(policyBytes!==null){
+        let parsedPolicy;
+        try{parsedPolicy=JSON.parse(decodeUtf8Strict(policyBytes));}catch{throw new Error('authority epoch policy JSON invalid');}
+        const policySha256=hashBytes(policyBytes);
+        if(parsedGrant?.policy_sha256!==policySha256)throw new Error('authority epoch grant policy digest mismatch');
+        policyBinding={policy_sha256:policySha256,policy_envelope_sha256:deriveSecurityEnvelope(plane,parsedPolicy).sha256};
+      }
+      const dir=durableEpochDir(root,plane),events=path.join(dir,'events');
+      const release=await acquireEpochLock(dir);
+      try{
+        await mkdir(events,{recursive:true});
+        const previous=await readDurableHead(root,plane);
+        if(expectedHeadSha256!==undefined&&(previous?.event_sha256??null)!==expectedHeadSha256)
+          throw new Error('authority epoch compare-and-swap conflict');
+        const grantSha256=hashBytes(grantBytes);
+        if(action==='transaction_revoke'){
+          if(!previous||!['grant','transaction_restore'].includes(previous.action))
+            throw new Error('authority epoch transaction revoke requires a current trusted grant head');
+          if(previous.grant_sha256!==grantSha256||previous.grant_instance_nonce!==grantInstanceNonce)
+            throw new Error('authority epoch transaction revoke grant does not match current head');
+        }
+        if(action==='transaction_restore'){
+          if(!previous||previous.action!=='transaction_revoke')
+            throw new Error('authority epoch transaction restore requires transaction revoke head');
+          if(previous.update_id!==updateId)
+            throw new Error('authority epoch transaction restore owner update mismatch');
+          if(normalizedRestoreBinding.prior_grant_sha256!==previous.grant_sha256||
+              normalizedRestoreBinding.prior_grant_instance_nonce!==previous.grant_instance_nonce)
+            throw new Error('authority epoch transaction restore predecessor grant binding mismatch');
+          if(previous.grant_instance_nonce===grantInstanceNonce)
+            throw new Error('authority epoch transaction restore requires fresh nonce; revoked nonce cannot be resurrected');
+        }
+        if(action==='grant'&&previous?.grant_instance_nonce===grantInstanceNonce)
+          throw new Error('authority epoch grant requires fresh nonce; prior nonce cannot be resurrected');
+        const seq=(previous?.seq??0)+1;
+        const body={schema:DURABLE_EPOCH_SCHEMA,plane,seq,action,update_id:updateId,
+          grant_sha256:grantSha256,grant_instance_nonce:grantInstanceNonce,restore_binding:normalizedRestoreBinding,
+          ...(policyBinding??{}),previous_event_sha256:previous?.event_sha256??null,recorded_at_utc:new Date().toISOString()};
+        const {privateKey,keyId}=await durableEpochKeys(root,{privateRequired:true});
+        const signature=cryptoSign(null,Buffer.concat([DURABLE_EPOCH_DOMAIN,Buffer.from(canonicalJson(body),'utf8')]),privateKey);
+        const event={...body,attestation:{algorithm:'ed25519',domain:'DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1',key_id:keyId,signature_base64:signature.toString('base64')}};
+        const eventBytes=Buffer.from(canonicalJson(event),'utf8'),eventSha256=hashBytes(eventBytes);
+        const eventFile=durableEventName(seq,eventSha256);
+        await writeFile(path.join(events,eventFile),eventBytes,{flag:'wx'});
+        const head={schema:DURABLE_HEAD_SCHEMA,plane,seq,action,update_id:updateId,
+          grant_sha256:grantSha256,grant_instance_nonce:grantInstanceNonce,restore_binding:normalizedRestoreBinding,
+          ...(policyBinding??{}),
+          previous_event_sha256:event.previous_event_sha256,event_sha256:eventSha256,event_file:eventFile};
+        await atomicJsonWrite(path.join(dir,'head.json'),head);
+        return Object.freeze({...head});
+      }finally{await release();}
+    },
+    async verifyGrant({plane,grantBytes,grantInstanceNonce,policyBytes:verifyPolicyBytes=null}){
+      if(!SCHEMAS[plane]||!Buffer.isBuffer(grantBytes)||!SHAPAT.test(String(grantInstanceNonce)))
+        return Object.freeze({trusted:false,reason:'epoch-input-invalid'});
+      if(verifyPolicyBytes!==null&&!Buffer.isBuffer(verifyPolicyBytes))return Object.freeze({trusted:false,reason:'epoch-policy-input-invalid'});
+      let head;
+      try{head=await readDurableHead(root,plane);}
+      catch(error){return Object.freeze({trusted:false,reason:String(error?.message??error)});}
+      if(!head)return Object.freeze({trusted:false,reason:'legacy-no-epoch'});
+      if(verifyPolicyBytes!==null){
+        try{
+          const observedPolicy=JSON.parse(decodeUtf8Strict(verifyPolicyBytes));
+          if(head.policy_sha256!==hashBytes(verifyPolicyBytes)||
+              head.policy_envelope_sha256!==deriveSecurityEnvelope(plane,observedPolicy).sha256)
+            return Object.freeze({trusted:false,reason:'epoch-policy-mismatch'});
+        }catch{return Object.freeze({trusted:false,reason:'epoch-policy-invalid'});}
+      }
+      const grantSha256=hashBytes(grantBytes);
+      if(head.grant_sha256!==grantSha256||head.grant_instance_nonce!==grantInstanceNonce)
+        return Object.freeze({trusted:false,reason:'epoch-grant-mismatch',seq:head.seq,action:head.action,event_sha256:head.event_sha256});
+      const trusted=head.action==='grant'||head.action==='transaction_restore';
+      return Object.freeze({trusted,reason:trusted?'epoch-bound-standing-grant':'epoch-revoked',
+        seq:head.seq,action:head.action,event_sha256:head.event_sha256,update_id:head.update_id});
+    }
+  });
+}
+
+
+export async function verifyStandingGrantEpoch({plane,grantFile,grantBytes,grantInstanceNonce,policyPath}){
+  if(typeof grantFile!=='string'||grantFile.length<1)return Object.freeze({trusted:false,reason:'epoch-grant-file-invalid'});
+  if(typeof policyPath!=='string'||policyPath.length<1)return Object.freeze({trusted:false,reason:'epoch-policy-unavailable'});
+  let policyBytes;
+  try{policyBytes=await readFile(policyPath);}catch{return Object.freeze({trusted:false,reason:'epoch-policy-unavailable'});}
+  const store=createAuthorityEpochStore({runtimeDir:path.dirname(path.resolve(grantFile))});
+  return store.verifyGrant({plane,grantBytes,grantInstanceNonce,policyBytes});
+}
+
+
+function parseEpochCliArgs(argv){
+  if(!Array.isArray(argv)||argv.length<1)throw new Error('authority epoch command missing');
+  const command=String(argv[0]);
+  if(!['status','grant','user-revoke','transaction-revoke','transaction-restore'].includes(command))
+    throw new Error('authority epoch command invalid');
+  const out={command,plane:null,grantFile:null,policyFile:null,updateId:null,expectedHeadSha256:undefined,
+    priorGrantSha256:undefined,priorGrantNonce:undefined,predecessorPolicyEnvelope:undefined,successorPolicyEnvelope:undefined,
+    candidateManifest:undefined,continuitySubject:undefined,restoreBinding:null};
+  for(let i=1;i<argv.length;i++){
+    const flag=String(argv[i]),value=argv[++i];
+    if(value===undefined)throw new Error(`authority epoch ${flag} value missing`);
+    if(flag==='--plane')out.plane=String(value);
+    else if(flag==='--grant-file')out.grantFile=path.resolve(String(value));
+    else if(flag==='--policy-file')out.policyFile=path.resolve(String(value));
+    else if(flag==='--update-id')out.updateId=String(value);
+    else if(flag==='--expected-head')out.expectedHeadSha256=String(value);
+    else if(flag==='--prior-grant-sha256')out.priorGrantSha256=String(value);
+    else if(flag==='--prior-grant-nonce')out.priorGrantNonce=String(value);
+    else if(flag==='--predecessor-policy-envelope')out.predecessorPolicyEnvelope=String(value);
+    else if(flag==='--successor-policy-envelope')out.successorPolicyEnvelope=String(value);
+    else if(flag==='--candidate-manifest')out.candidateManifest=String(value);
+    else if(flag==='--continuity-subject')out.continuitySubject=String(value);
+    else throw new Error(`authority epoch unknown option ${flag}`);
+  }
+  if(!SCHEMAS[out.plane]||typeof out.grantFile!=='string'||out.grantFile.length<1)
+    throw new Error('authority epoch plane/grant file missing');
+  if(typeof out.policyFile!=='string'||out.policyFile.length<1)throw new Error('authority epoch policy-file required');
+  if(['transaction-revoke','transaction-restore'].includes(command)){
+    if(!/^[A-Za-z0-9._-]{1,96}$/.test(String(out.updateId??'')))throw new Error('authority epoch transaction update id invalid');
+    if(!SHAPAT.test(String(out.expectedHeadSha256??'')))throw new Error('authority epoch transaction expected head invalid');
+  }else if(out.updateId!==null||out.expectedHeadSha256!==undefined){
+    throw new Error('authority epoch transaction options not allowed');
+  }
+  const restoreFields=[out.priorGrantSha256,out.priorGrantNonce,out.predecessorPolicyEnvelope,out.successorPolicyEnvelope,out.candidateManifest,out.continuitySubject];
+  if(command==='transaction-restore'){
+    out.restoreBinding=normalizeRestoreBinding({
+      prior_grant_sha256:out.priorGrantSha256,prior_grant_instance_nonce:out.priorGrantNonce,
+      predecessor_policy_envelope_sha256:out.predecessorPolicyEnvelope,successor_policy_envelope_sha256:out.successorPolicyEnvelope,
+      candidate_manifest_sha256:out.candidateManifest,continuity_subject_sha256:out.continuitySubject
+    },{required:true});
+  }else if(restoreFields.some(value=>value!==undefined)){
+    throw new Error('authority epoch restore binding options require transaction-restore');
+  }
+  return out;
+}
+
+export async function authorityEpochCliMain(argv=process.argv.slice(2)){
+  const opts=parseEpochCliArgs(argv);
+  let grantBytes,grant;
+  try{
+    grantBytes=await readFile(opts.grantFile);
+    grant=JSON.parse(decodeUtf8Strict(grantBytes));
+  }catch(error){
+    throw new Error(`authority epoch grant unreadable: ${String(error?.message??error)}`);
+  }
+  if(!plain(grant)||!SHAPAT.test(String(grant.instance_nonce)))throw new Error('authority epoch grant nonce invalid');
+  const policyBytes=await readFile(opts.policyFile);
+  if(hashBytes(policyBytes)!==grant.policy_sha256)throw new Error('authority epoch grant policy digest mismatch');
+  const store=createAuthorityEpochStore({runtimeDir:path.dirname(opts.grantFile),policyBytes});
+  if(opts.command==='status'){
+    return store.verifyGrant({plane:opts.plane,grantBytes,grantInstanceNonce:grant.instance_nonce,policyBytes});
+  }
+  const action=opts.command.replaceAll('-','_');
+  return store.append({
+    plane:opts.plane,action,grantBytes,grantInstanceNonce:grant.instance_nonce,
+    updateId:opts.updateId,expectedHeadSha256:opts.expectedHeadSha256,restoreBinding:opts.restoreBinding
+  });
+}

package/src/authority-epoch-cli-r65.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {authorityEpochCliMain} from './authority-continuity-r65.mjs';
+
+try{
+  const result=await authorityEpochCliMain(process.argv.slice(2));
+  process.stdout.write(JSON.stringify(result)+'\n');
+}catch(error){
+  process.stderr.write(`DEADBYTE AUTHORITY EPOCH: ${String(error?.message??error)}\n`);
+  process.exitCode=1;
+}

package/src/autonomous-policy.mjs

@@ -3,6 +3,7 @@ import { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { decodeUtf8Strict } from './text-policy.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
+import { verifyStandingGrantEpoch } from './authority-continuity-r65.mjs';
 
 export const AUTONOMOUS_POLICY_SCHEMA = 'deadbyte.autonomous-policy.v1';
 export const AUTONOMOUS_LEASE_SCHEMA = 'deadbyte.autonomous-lease.v1';
@@ -154,8 +155,8 @@ export async function loadAutonomousPolicy(policyPath, codingPolicy) {
 }
 
 export async function autonomousSessionStatus(policy, now = new Date()) {
-  let lease;
-  try { lease = JSON.parse(decodeUtf8Strict(await readFile(policy.lease_file))); }
+  let lease,leaseBytes;
+  try { leaseBytes=await readFile(policy.lease_file); lease = JSON.parse(decodeUtf8Strict(leaseBytes)); }
   catch (error) {
     return { configured:true, armed:false, reason:error?.code === 'ENOENT' ? 'disarmed' : 'invalid-lease', expires_at_utc:null };
   }
@@ -167,8 +168,11 @@ export async function autonomousSessionStatus(policy, now = new Date()) {
   const roots = Array.isArray(lease.root_ids) ? [...new Set(lease.root_ids)] : [];
   if (roots.length < 1 || roots.some(id => !policy.root_ids.includes(id))) return { configured:true, armed:false, reason:'roots-invalid', expires_at_utc:null };
   if (lease.schema === AUTONOMOUS_GRANT_SCHEMA) {
+    const epoch=await verifyStandingGrantEpoch({plane:'autonomous',grantFile:policy.lease_file,grantBytes:leaseBytes,grantInstanceNonce:lease.instance_nonce,policyPath:policy.policy_path});
+    if(!epoch.trusted)return { configured:true,armed:false,reason:epoch.reason,expires_at_utc:null,
+      remaining_ms:null,standing:false,instance_nonce:lease.instance_nonce,root_ids:roots };
     return { configured:true, armed:true, reason:'standing-grant', expires_at_utc:null,
-      remaining_ms:null, standing:true, instance_nonce:lease.instance_nonce, root_ids:roots };
+      remaining_ms:null, standing:true, instance_nonce:lease.instance_nonce, root_ids:roots, authority_epoch:epoch };
   }
   const expires = Date.parse(lease.expires_at_utc);
   if (!Number.isFinite(expires)) return { configured:true, armed:false, reason:'expiry-invalid', expires_at_utc:null };

package/src/coding-plane.mjs

@@ -11,6 +11,7 @@ import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { createCodingSearch } from './coding-search.mjs';
 import { createSearchCursorCodec } from './search-cursor.mjs';
 import { atomicMutation } from './atomic-mutation.mjs';
+import { createAuthorityEpochStore } from './authority-continuity-r65.mjs';
 import { fileURLToPath } from 'node:url';
 
 export const CODING_POLICY_SCHEMA = 'deadbyte.coding-policy.v1';
@@ -123,8 +124,8 @@ export async function loadCodingPolicy(policyPath) {
 }
 
 export async function codingSessionStatus(policy, now = new Date()) {
-  let lease;
-  try { lease = JSON.parse(decodeUtf8Strict(await readFile(policy.lease_file))); }
+  let lease,leaseBytes;
+  try { leaseBytes=await readFile(policy.lease_file); lease = JSON.parse(decodeUtf8Strict(leaseBytes)); }
   catch (error) {
     return { configured: true, armed: false, reason: error?.code === 'ENOENT' ? 'disarmed' : 'invalid-lease', expires_at_utc: null };
   }
@@ -138,8 +139,16 @@ export async function codingSessionStatus(policy, now = new Date()) {
   }
   const roots = [...new Set(lease.root_ids)];
   if (lease.schema === CODING_GRANT_SCHEMA) {
+    let policyBytes;
+    try { policyBytes=await readFile(policy.policy_path); }
+    catch { return { configured:true,armed:false,reason:'epoch-policy-unavailable',expires_at_utc:null }; }
+    const epoch=await createAuthorityEpochStore({runtimeDir:path.dirname(policy.lease_file)}).verifyGrant({
+      plane:'coding',grantBytes:leaseBytes,grantInstanceNonce:lease.instance_nonce,policyBytes
+    });
+    if(!epoch.trusted)return { configured:true,armed:false,reason:epoch.reason,expires_at_utc:null,
+      remaining_ms:null,standing:false,instance_nonce:lease.instance_nonce,root_ids:roots };
     return { configured: true, armed: true, reason: 'standing-grant', expires_at_utc: null,
-      remaining_ms: null, standing: true, instance_nonce: lease.instance_nonce, root_ids: roots };
+      remaining_ms: null, standing: true, instance_nonce: lease.instance_nonce, root_ids: roots, authority_epoch:epoch };
   }
   const expires = Date.parse(lease.expires_at_utc);
   if (!Number.isFinite(expires)) return { configured: true, armed: false, reason: 'expiry-invalid', expires_at_utc: null };