deadbyte-mcp 0.14.0 → 0.15.0

package/scripts/windows-gate-evidence-r44.mjs

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyR44Parent } from './verify-r44-parent.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.15.0 / R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok)throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.15.0',`Windows gate evidence requires V0.15.0, found ${pkg.version}`);
+  const parent=await verifyR44Parent(path.join(candidate,'R44-PARENT.json'));
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r44-windows-gate.v1',status:'passed',exit_code:0,version:'0.15.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256,
+    parent:{release_id:parent.release_id,manifest_sha256:parent.manifest_sha256,
+      generation_manifest_sha256:parent.generation_manifest_sha256,
+      final_closure_sha256:parent.closure_sha256,final_closure_file_sha256:parent.closure_file_sha256,
+      signer_key_id:parent.signer_key_id},
+    features:{skill_integrity:true,agent_backend_persistence:true,codex_protocol_contract:true,
+      remote_device_identity:true,durable_job_supervisor:true,real_external_supervisor_smoke:true,
+      full_regression_required:true,codex_live_binary_required:false}
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r44-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256,parent:evidence.parent};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R44 Windows gate evidence invalid');
+    insist(existing.version==='0.15.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R44 Windows gate identity mismatch');
+    insist(existing.parent?.release_id===parent.release_id&&existing.parent?.final_closure_sha256===parent.closure_sha256,'existing R44 parent evidence mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,parent:existing.parent};
+  }
+}
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeWindowsGateEvidence().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/src/agent-backend-r44.mjs

@@ -0,0 +1,254 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { lstat, mkdir, open, readFile, realpath, rename } from 'node:fs/promises';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const STATE_SCHEMA='deadbyte.agent-backend-state.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,64}$/;
+const METHOD=/^[A-Za-z0-9._\/-]{1,128}$/;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort((a,b)=>a.localeCompare(b,'en')).map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+function insist(ok,message){if(!ok) throw new Error(message);}
+function now(){return new Date().toISOString();}
+function isJson(value){try{JSON.stringify(value);return true;}catch{return false;}}
+
+async function atomicJson(file,value){
+  await mkdir(path.dirname(file),{recursive:true});
+  const bytes=Buffer.from(`${JSON.stringify(value,null,2)}\n`,'utf8');
+  const temp=`${file}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  const handle=await open(temp,'wx');
+  try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+  await rename(temp,file);
+  return sha(bytes);
+}
+function validateState(state,backendId){
+  insist(state&&typeof state==='object'&&!Array.isArray(state),'agent backend state must be object');
+  const allowed=['schema','backend_id','state_epoch','next_sequence','threads','requests','updated_at_utc'];
+  insist(Object.keys(state).every(k=>allowed.includes(k))&&allowed.every(k=>Object.hasOwn(state,k)),'agent backend state fields mismatch');
+  insist(state.schema===STATE_SCHEMA,'agent backend state schema mismatch');
+  insist(state.backend_id===backendId,'agent backend state backend mismatch');
+  insist(HEX64.test(state.state_epoch??''),'agent backend state epoch invalid');
+  insist(Number.isInteger(state.next_sequence)&&state.next_sequence>=0,'agent backend sequence invalid');
+  insist(state.threads&&typeof state.threads==='object'&&!Array.isArray(state.threads),'agent backend threads invalid');
+  for(const [logicalId,threadId] of Object.entries(state.threads)){
+    insist(ID.test(logicalId),'agent backend logical thread id invalid');
+    insist(typeof threadId==='string'&&threadId.length>=1&&threadId.length<=512,'agent backend thread id invalid');
+  }
+  insist(state.requests&&typeof state.requests==='object'&&!Array.isArray(state.requests),'agent backend requests invalid');
+  for(const [id,item] of Object.entries(state.requests)){
+    insist(HEX64.test(id),'agent backend request id invalid');
+    insist(item&&typeof item==='object'&&!Array.isArray(item),'agent backend request record invalid');
+    insist(['pending','completed','failed','interrupted'].includes(item.state),'agent backend request state invalid');
+    insist(typeof item.method==='string'&&METHOD.test(item.method),'agent backend request method invalid');
+    insist(HEX64.test(item.params_sha256??''),'agent backend params hash invalid');
+    insist(typeof item.created_at_utc==='string'&&typeof item.updated_at_utc==='string','agent backend request timestamp invalid');
+  }
+  insist(typeof state.updated_at_utc==='string','agent backend state timestamp invalid');
+  return state;
+}
+async function loadState(file,backendId){
+  try{
+    const st=await lstat(file);
+    insist(st.isFile()&&!st.isSymbolicLink(),'agent backend state must be real file');
+    let parsed;
+    try{parsed=JSON.parse(await readFile(file,'utf8'));}catch(error){throw new Error(`agent backend state JSON invalid: ${error.message}`);}
+    return validateState(parsed,backendId);
+  }catch(error){
+    if(error?.code!=='ENOENT') throw error;
+    return {schema:STATE_SCHEMA,backend_id:backendId,state_epoch:randomBytes(32).toString('hex'),next_sequence:0,threads:{},requests:{},updated_at_utc:now()};
+  }
+}
+async function fileSha256(file){
+  const st=await lstat(file);
+  insist(st.isFile()&&!st.isSymbolicLink(),'agent backend executable must be real file');
+  return sha(await readFile(file));
+}
+
+class JsonRpcLineTransport extends EventEmitter {
+  constructor({executable,args=[],cwd=null,env=null,maxLineBytes=1024*1024}){
+    super();this.executable=executable;this.args=args;this.cwd=cwd;this.env=env;this.maxLineBytes=maxLineBytes;this.child=null;this.buffer='';
+  }
+  async start(){
+    if(this.child) throw new Error('agent backend transport already started');
+    this.child=spawn(this.executable,this.args,{cwd:this.cwd??undefined,env:this.env??process.env,windowsHide:true,shell:false,stdio:['pipe','pipe','pipe']});
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data',chunk=>{
+      this.buffer+=chunk;
+      if(Buffer.byteLength(this.buffer,'utf8')>this.maxLineBytes*2){this.emit('protocol_error',new Error('agent backend JSON-RPC buffer limit exceeded'));return;}
+      for(;;){
+        const nl=this.buffer.indexOf('\n');if(nl<0)break;
+        const line=this.buffer.slice(0,nl).trim();this.buffer=this.buffer.slice(nl+1);
+        if(!line)continue;
+        if(Buffer.byteLength(line,'utf8')>this.maxLineBytes){this.emit('protocol_error',new Error('agent backend JSON-RPC line limit exceeded'));continue;}
+        try{this.emit('message',JSON.parse(line));}catch(error){this.emit('protocol_error',new Error(`agent backend JSON-RPC invalid: ${error.message}`));}
+      }
+    });
+    let stderr='';
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data',chunk=>{stderr=(stderr+chunk).slice(-16384);});
+    this.child.once('error',error=>this.emit('transport_error',error));
+    this.child.once('exit',(code,signal)=>{this.emit('exit',{code,signal,stderr});this.child=null;});
+    await new Promise((resolve,reject)=>{
+      if(this.child.pid){resolve();return;}
+      this.child.once('spawn',resolve);this.child.once('error',reject);
+    });
+  }
+  async send(value){
+    insist(this.child?.stdin?.writable,'agent backend transport is not writable');
+    const line=`${JSON.stringify(value)}\n`;
+    insist(Buffer.byteLength(line,'utf8')<=this.maxLineBytes,'agent backend outbound JSON-RPC line limit exceeded');
+    await new Promise((resolve,reject)=>this.child.stdin.write(line,error=>error?reject(error):resolve()));
+  }
+  async stop(){
+    if(!this.child)return;
+    const child=this.child;
+    const done=new Promise(resolve=>child.once('exit',resolve));
+    child.kill();
+    await Promise.race([done,new Promise(resolve=>setTimeout(resolve,3000))]);
+  }
+}
+
+export async function createAgentBackendR44({
+  backendId,stateDir,transportFactory=null,serverRequestHandler=null,notificationHandler=null,wireMode='jsonrpc2',
+  executable=null,executableSha256=null,args=[],cwd=null,env=null
+}={}){
+  insist(typeof backendId==='string'&&ID.test(backendId),'agent backend id invalid');
+  insist(typeof stateDir==='string'&&path.isAbsolute(stateDir),'agent backend stateDir must be absolute');
+  await mkdir(stateDir,{recursive:true});
+  const root=await realpath(stateDir);
+  const stateFile=path.join(root,`${backendId}.json`);
+  if(transportFactory===null){
+    insist(typeof executable==='string'&&path.isAbsolute(executable),'agent backend executable must be absolute');
+    insist(HEX64.test(executableSha256??''),'agent backend executable SHA-256 invalid');
+    insist(await fileSha256(executable)===executableSha256,'agent backend executable hash mismatch');
+    insist(Array.isArray(args)&&args.length<=64&&args.every(x=>typeof x==='string'&&x.length<=4096),'agent backend args invalid');
+    transportFactory=async()=>new JsonRpcLineTransport({executable,args,cwd,env});
+  }else insist(typeof transportFactory==='function','agent backend transportFactory invalid');
+  insist(serverRequestHandler===null||typeof serverRequestHandler==='function','agent backend serverRequestHandler invalid');
+  insist(notificationHandler===null||typeof notificationHandler==='function','agent backend notificationHandler invalid');
+  insist(['jsonrpc2','codex-app-server'].includes(wireMode),'agent backend wireMode invalid');
+  const wire=value=>wireMode==='jsonrpc2'?{jsonrpc:'2.0',...value}:value;
+
+  let state=await loadState(stateFile,backendId);
+  let changed=false;
+  for(const item of Object.values(state.requests)){
+    if(item.state==='pending'){item.state='interrupted';item.updated_at_utc=now();item.error='backend restarted before terminal response';changed=true;}
+  }
+  if(changed){state.updated_at_utc=now();await atomicJson(stateFile,state);}
+  else{
+    try{await lstat(stateFile);}catch(error){if(error?.code==='ENOENT')await atomicJson(stateFile,state);else throw error;}
+  }
+
+  let transport=null;
+  let started=false;
+  const pending=new Map();
+  let writeChain=Promise.resolve();
+  const persist=async()=>{
+    state.updated_at_utc=now();
+    writeChain=writeChain.then(()=>atomicJson(stateFile,state));
+    return writeChain;
+  };
+  const publicState=()=>({
+    status:'ok',backend_id:backendId,running:started,state_epoch:state.state_epoch,
+    threads:structuredClone(state.threads),requests:structuredClone(state.requests)
+  });
+
+  async function terminal(id,{stateName,result=null,error=null}){
+    const record=state.requests[id];if(!record||record.state!=='pending')return;
+    record.state=stateName;record.updated_at_utc=now();
+    if(result!==null)record.result=result;
+    if(error!==null)record.error=String(error);
+    await persist();
+    const waiter=pending.get(id);pending.delete(id);
+    if(!waiter)return;
+    if(stateName==='completed')waiter.resolve(result);
+    else waiter.reject(new Error(record.error??stateName));
+  }
+  async function handleMessage(message){
+    if(!message||typeof message!=='object'||Array.isArray(message))return;
+    if(typeof message.id==='string'&&Object.hasOwn(message,'method')){
+      const method=String(message.method);
+      try{
+        if(!serverRequestHandler) throw Object.assign(new Error('server request denied by DEADBYTE policy'),{code:-32001});
+        const result=await serverRequestHandler({method,params:message.params??{},backendId});
+        await transport?.send(wire({id:message.id,result}));
+      }catch(error){
+        await transport?.send(wire({id:message.id,error:{code:Number.isInteger(error?.code)?error.code:-32001,message:String(error?.message??error)}}));
+      }
+      return;
+    }
+    if(!Object.hasOwn(message,'id')&&typeof message.method==='string'){
+      if(notificationHandler) await notificationHandler({method:String(message.method),params:message.params??{},backendId});
+      return;
+    }
+    if(typeof message.id!=='string'||!state.requests[message.id])return;
+    if(Object.hasOwn(message,'result'))await terminal(message.id,{stateName:'completed',result:message.result});
+    else if(Object.hasOwn(message,'error'))await terminal(message.id,{stateName:'failed',error:message.error?.message??'JSON-RPC error'});
+  }
+  async function start(){
+    if(started)return publicState();
+    transport=await transportFactory();
+    insist(transport&&typeof transport.start==='function'&&typeof transport.send==='function'&&typeof transport.on==='function','agent backend transport contract invalid');
+    transport.on('message',message=>{void handleMessage(message);});
+    transport.on('protocol_error',error=>{
+      for(const id of pending.keys())void terminal(id,{stateName:'failed',error:String(error?.message??error)});
+    });
+    transport.on('transport_error',error=>{
+      for(const id of pending.keys())void terminal(id,{stateName:'interrupted',error:String(error?.message??error)});
+      started=false;
+    });
+    transport.on('exit',()=>{
+      for(const id of pending.keys())void terminal(id,{stateName:'interrupted',error:'agent backend transport exited'});
+      started=false;
+    });
+    await transport.start();started=true;return publicState();
+  }
+  async function bindThread({logicalId,threadId}={}){
+    insist(typeof logicalId==='string'&&ID.test(logicalId),'logical thread id invalid');
+    insist(typeof threadId==='string'&&threadId.length>=1&&threadId.length<=512,'provider thread id invalid');
+    const existing=state.threads[logicalId];
+    if(existing!==undefined&&existing!==threadId) throw new Error('logical thread already bound to different provider thread');
+    state.threads[logicalId]=threadId;await persist();
+    return {status:'ok',logical_id:logicalId,thread_id:threadId};
+  }
+  async function request({method,params={},timeoutMs=60000}={}){
+    insist(started&&transport,'agent backend is not started');
+    insist(typeof method==='string'&&METHOD.test(method),'agent backend method invalid');
+    insist(isJson(params)&&params&&typeof params==='object','agent backend params must be JSON');
+    insist(Number.isInteger(timeoutMs)&&timeoutMs>=100&&timeoutMs<=900000,'agent backend timeout invalid');
+    const sequence=++state.next_sequence;
+    const paramsSha=sha(Buffer.from(canonicalJson(params),'utf8'));
+    const id=sha(Buffer.from(canonicalJson({backend_id:backendId,state_epoch:state.state_epoch,sequence,method,params_sha256:paramsSha}),'utf8'));
+    state.requests[id]={state:'pending',method,params_sha256:paramsSha,created_at_utc:now(),updated_at_utc:now()};
+    await persist();
+    let timer;
+    const promise=new Promise((resolve,reject)=>{
+      pending.set(id,{resolve,reject});
+      timer=setTimeout(()=>{void terminal(id,{stateName:'failed',error:'agent backend request timeout'});},timeoutMs);
+    }).finally(()=>clearTimeout(timer));
+    try{await transport.send(wire({id,method,params}));}
+    catch(error){await terminal(id,{stateName:'failed',error:String(error?.message??error)});}
+    return promise;
+  }
+  async function notify({method,params={}}={}){
+    insist(started&&transport,'agent backend is not started');
+    insist(typeof method==='string'&&METHOD.test(method),'agent backend notification method invalid');
+    insist(isJson(params)&&params&&typeof params==='object','agent backend notification params must be JSON');
+    await transport.send(wire({method,params}));
+    return {status:'sent',method};
+  }
+  async function status(){return publicState();}
+  async function close(){
+    for(const id of [...pending.keys()])await terminal(id,{stateName:'interrupted',error:'agent backend closed before response'});
+    if(transport?.stop)await transport.stop();transport=null;started=false;return publicState();
+  }
+  async function simulateCrashForTest(){
+    for(const [id,waiter] of pending){waiter.reject(new Error('simulated backend crash'));pending.delete(id);}
+    if(transport?.stop)await transport.stop();transport=null;started=false;
+  }
+  return Object.freeze({start,bindThread,request,notify,status,close,simulateCrashForTest,state_file:stateFile,wire_mode:wireMode});
+}

package/src/autonomous-output-contracts.mjs

@@ -68,7 +68,7 @@ export const autonomousSessionStatusOutputSchema = statusContract({
   shape:{ configured:z.literal(true).optional(), armed:z.boolean().optional(), autonomous_armed:z.boolean().optional(),
     autonomous_reason:z.string().optional(), autonomous_expires_at_utc:z.string().nullable().optional(),
     coding_armed:z.boolean().optional(), coding_reason:z.string().optional(), root_ids:z.array(z.string()).max(64).optional(),
-    planner_backend:z.enum(['client_sampling','openai_compatible','openai_responses']).optional(), profile_ids:z.array(z.string()).max(128).optional(),
+    planner_backend:z.enum(['client_sampling','openai_compatible','openai_responses','codex_app_server']).optional(), profile_ids:z.array(z.string()).max(128).optional(),
     policy_sha256:hex64.optional(), coding_policy_sha256:hex64.optional() }
 });
 

package/src/autonomous-policy.mjs

@@ -30,12 +30,31 @@ function normalizeProviderCircuit(raw) {
     half_open_probe_limit:integer(value.half_open_probe_limit,'planner.circuit.half_open_probe_limit',1,8,1)
   });
 }
-function normalizePlanner(raw) {
+function normalizePlanner(raw,codingPolicy,rootIds) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('autonomous planner missing');
   const backend = raw.backend;
-  if (!['client_sampling', 'openai_compatible', 'openai_responses'].includes(backend)) throw new Error('autonomous planner backend invalid');
+  if (!['client_sampling', 'openai_compatible', 'openai_responses', 'codex_app_server'].includes(backend)) throw new Error('autonomous planner backend invalid');
   const common = { backend, max_tokens: integer(raw.max_tokens, 'planner.max_tokens', 256, 16384, 4096) };
   if (backend === 'client_sampling') return common;
+  if (typeof raw.model !== 'string' || raw.model.length < 1 || raw.model.length > 128) throw new Error('planner.model invalid');
+  if (backend === 'codex_app_server') {
+    if (!ID_RE.test(raw.root_id ?? '') || !rootIds.includes(raw.root_id) || !codingPolicy.roots[raw.root_id]) {
+      throw new Error('planner.root_id invalid');
+    }
+    if (typeof raw.executable !== 'string' || !path.isAbsolute(raw.executable)) throw new Error('planner.executable must be absolute');
+    if (!SHA256_RE.test(raw.executable_sha256 ?? '')) throw new Error('planner.executable_sha256 invalid');
+    const args=raw.args ?? ['app-server'];
+    if (!Array.isArray(args) || args.length < 1 || args.length > 16 ||
+        args.some(value=>typeof value!=='string'||value.length<1||value.length>2048||value.includes('\0'))) {
+      throw new Error('planner.args invalid');
+    }
+    return {
+      ...common, model:raw.model, root_id:raw.root_id, executable:path.resolve(raw.executable),
+      executable_sha256:raw.executable_sha256, args:[...args],
+      timeout_ms:integer(raw.timeout_ms,'planner.timeout_ms',1000,300000,60000),
+      circuit:normalizeProviderCircuit(raw.circuit)
+    };
+  }
   if (typeof raw.endpoint !== 'string') throw new Error('planner.endpoint required');
   const endpoint = new URL(raw.endpoint);
   const loopback = ['127.0.0.1', 'localhost', '::1'].includes(endpoint.hostname);
@@ -43,7 +62,6 @@ function normalizePlanner(raw) {
     throw new Error('planner endpoint must be HTTPS or loopback HTTP');
   }
   if (endpoint.username || endpoint.password || endpoint.hash) throw new Error('planner endpoint credentials/fragments forbidden');
-  if (typeof raw.model !== 'string' || raw.model.length < 1 || raw.model.length > 128) throw new Error('planner.model invalid');
   const apiKeyEnv = raw.api_key_env ?? null;
   if (apiKeyEnv !== null && !ENV_RE.test(apiKeyEnv)) throw new Error('planner.api_key_env invalid');
   const provider = {
@@ -117,7 +135,7 @@ export async function loadAutonomousPolicy(policyPath, codingPolicy) {
     schema: AUTONOMOUS_POLICY_SCHEMA, enabled: true, policy_path: absolute,
     lease_file: path.resolve(raw.lease_file), evidence_dir: path.resolve(raw.evidence_dir),
     coding_policy_sha256: codingPolicy.policy_sha256, root_ids: rootIds,
-    planner: normalizePlanner(raw.planner), profiles,
+    planner: normalizePlanner(raw.planner,codingPolicy,rootIds), profiles,
     limits: {
       max_iterations: integer(limits.max_iterations, 'limits.max_iterations', 1, 64, 12),
       max_mutations: integer(limits.max_mutations, 'limits.max_mutations', 1, 128, 24),
@@ -165,3 +183,22 @@ export async function assertAutonomousArmed(policy, rootId = null, now = new Dat
   if (rootId !== null && !status.root_ids.includes(rootId)) throw new Error(`autonomous root '${rootId}' is outside active lease`);
   return status;
 }
+
+export async function recheckAutonomousAuthority(policy, initial, rootId = null, now = new Date()) {
+  if (!initial?.armed || typeof initial.instance_nonce !== 'string' || !Array.isArray(initial.root_ids)) {
+    throw new Error('autonomous authority recheck requires an armed initial snapshot');
+  }
+  let current;
+  try { current = await assertAutonomousArmed(policy, rootId, now); }
+  catch (error) { throw new Error(`autonomous authority changed during operation: ${String(error?.message ?? error)}`); }
+  const initialRoots = [...initial.root_ids].sort();
+  const currentRoots = [...current.root_ids].sort();
+  const changed =
+    current.instance_nonce !== initial.instance_nonce ||
+    current.standing !== initial.standing ||
+    current.expires_at_utc !== initial.expires_at_utc ||
+    initialRoots.length !== currentRoots.length ||
+    initialRoots.some((id, index) => id !== currentRoots[index]);
+  if (changed) throw new Error('autonomous authority changed during operation');
+  return current;
+}

package/src/autonomous-runtime.mjs

@@ -3,7 +3,7 @@ import { access, mkdir, open, readFile, readdir, rm, writeFile } from 'node:fs/p
 import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
-import { assertAutonomousArmed, autonomousSessionStatus } from './autonomous-policy.mjs';
+import { assertAutonomousArmed, autonomousSessionStatus, recheckAutonomousAuthority } from './autonomous-policy.mjs';
 import { buildPlannerPrompt, parsePlannerDecision, parseR34PlannerDecision, requestProviderDecision } from './autonomous-planner.mjs';
 import { actionIdentity, reconcileStartedAction } from './autonomous-action-reconcile.mjs';
 import { createPlan, replanPlan, completePlanStep, planIsComplete as r34PlanIsComplete } from './autonomous-plan.mjs';
@@ -274,16 +274,24 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
     await appendEvent(ctx,events,signingKeyPath,'profile_completed',payload);
     return { status:outcome.passed ? 'passed' : 'failed', observation:payload, existing:false };
   }
+  const autonomousAuthority = await assertAutonomousArmed(policy,profile.root_id);
+  if (Number.isFinite(autonomousAuthority.remaining_ms) && autonomousAuthority.remaining_ms < 100) {
+    throw new Error('autonomous lease expires too soon to execute profile');
+  }
   await appendEvent(ctx,events,signingKeyPath,'profile_started',{ action_key:actionKey, profile_id:profileId,
-    mutation_epoch:epoch, receipt_id:receiptId, request_sha256:requestSha256 });
+    mutation_epoch:epoch, receipt_id:receiptId, request_sha256:requestSha256,
+    authority_instance_nonce:autonomousAuthority.instance_nonce,
+    authority_expires_at_utc:autonomousAuthority.expires_at_utc });
+  const preExecutionCheck = () => recheckAutonomousAuthority(policy,autonomousAuthority,profile.root_id);
   let result;
   try {
     result = profile.kind === 'command'
       ? await codingRuntime.commandRun({ rootId:profile.root_id, commandId:profile.command_id, scriptPath:profile.script_path,
           scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:profile.timeout_ms,
-          receiptId, requestSha256 })
+          executionDeadlineUtc:autonomousAuthority.expires_at_utc, preExecutionCheck, receiptId, requestSha256 })
       : await codingRuntime.benchmarkRun({ rootId:profile.root_id, commandId:profile.command_id, scriptPath:profile.script_path,
           scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:profile.timeout_ms,
+          executionDeadlineUtc:autonomousAuthority.expires_at_utc, preExecutionCheck,
           warmups:profile.warmups, iterations:profile.iterations, baselineMedianMs:profile.baseline_median_ms,
           maxRegressionPct:profile.max_regression_pct, receiptId, requestSha256 });
   } catch (error) {
@@ -527,7 +535,7 @@ function withLoopResult(goal,events,result) {
   return loop ? {...result,loop} : result;
 }
 function providerCircuitSnapshot(policy,events,observedAtUtc=new Date().toISOString()) {
-  if (!['openai_compatible','openai_responses'].includes(policy.planner.backend)) return null;
+  if (!['openai_compatible','openai_responses','codex_app_server'].includes(policy.planner.backend)) return null;
   return deriveCircuit(events,providerCircuitId(policy.planner),policy.planner.circuit,observedAtUtc);
 }
 async function enterProviderCircuitWait({ctx,events,goal,policy,signingKeyPath,reason,circuit}) {
@@ -545,7 +553,7 @@ async function enterProviderCircuitWait({ctx,events,goal,policy,signingKeyPath,r
   });
   return {status:'paused',reason,circuit};
 }
-async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signingKeyPath}) {
+async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signingKeyPath,plannerProviderRuntime}) {
   const providerId=providerCircuitId(policy.planner);
   let circuit=providerCircuitSnapshot(policy,events);
   let disposition=providerCallDisposition(circuit);
@@ -566,7 +574,9 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
     });
   }
   try {
-    const response=await requestProviderDecision(policy,pending.prompt);
+    const response=policy.planner.backend==='codex_app_server'
+      ? await plannerProviderRuntime.runPlanner({logicalId:`goal-${goal.goal_id}`,prompt:pending.prompt,timeoutMs:policy.planner.timeout_ms})
+      : await requestProviderDecision(policy,pending.prompt);
     await appendEvent(ctx,events,signingKeyPath,'provider_call_succeeded',{
       provider_id:providerId,request_id:pending.request_id,probe:disposition.probe===true,
       ...(response.response_id?{response_id:response.response_id}:{}),
@@ -589,15 +599,15 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
     throw error;
   }
 }
-async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider,memoryProvider, signingKeyPath, plannerResponse }) {
+async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider,memoryProvider, signingKeyPath, plannerResponse, plannerProviderRuntime }) {
   let currentState = state;
   let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider,signingKeyPath);
   if (!pending) return null;
   let suppliedResponse = plannerResponse;
   while (pending) {
     let response;
-    if (['openai_compatible','openai_responses'].includes(policy.planner.backend)) {
-      const provider=await requestProviderWithCircuit({ctx,events,goal,policy,pending,signingKeyPath});
+    if (['openai_compatible','openai_responses','codex_app_server'].includes(policy.planner.backend)) {
+      const provider=await requestProviderWithCircuit({ctx,events,goal,policy,pending,signingKeyPath,plannerProviderRuntime});
       if (provider.waiting) return {needs_planner:false,rejected:false,paused:true,provider_waiting:true};
       response=provider.response;
     } else {
@@ -1765,9 +1775,12 @@ function isAuthorityUnavailable(error) {
 
 export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRuntime, machineFsRuntime = null,
   observationRuntime = null, processRuntime = null, semanticRuntime = null, desktopRuntime = null,
-  desktopMemoryProvider = null,memoryProvider=null, signingKeyPath, verifyKeyPath }) {
+  desktopMemoryProvider = null,memoryProvider=null, plannerProviderRuntime=null, signingKeyPath, verifyKeyPath }) {
   if (!policy || !codingRuntime || !nativeDiffRuntime) throw new Error('autonomous runtime requires policy/coding/native-diff runtimes');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('autonomous runtime requires trust keys');
+  if (policy.planner?.backend==='codex_app_server' && (!plannerProviderRuntime || typeof plannerProviderRuntime.runPlanner!=='function')) {
+    throw new Error('Codex planner provider runtime is required by autonomous policy');
+  }
   const capabilityManifest=configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime});
   const profileTimeoutCeiling=Math.max(120000,...Object.values(policy.profiles??{}).map(profile=>
     Number.isInteger(profile?.timeout_ms)&&profile.timeout_ms>0?profile.timeout_ms+120000:120000));
@@ -1784,7 +1797,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       coding_policy_sha256:policy.coding_policy_sha256 };
   }
   async function providerCircuitStatus({goalId}) {
-    if (!['openai_compatible','openai_responses'].includes(policy.planner.backend)) return null;
+    if (!['openai_compatible','openai_responses','codex_app_server'].includes(policy.planner.backend)) return null;
     const ctx=goalContext(policy,goalId);
     await loadGoal(ctx,policy,verifyKeyPath);
     const journal=await readEvents(ctx,verifyKeyPath);
@@ -2046,7 +2059,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           continue;
         }
         const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
-          desktopMemoryProvider,memoryProvider,signingKeyPath,plannerResponse:suppliedResponse });
+          desktopMemoryProvider,memoryProvider,signingKeyPath,plannerResponse:suppliedResponse,plannerProviderRuntime });
         suppliedResponse = null;
         if (accepted?.needs_planner) {
           state = deriveState(goal,journal);

package/src/autonomous-supervisor-host.mjs

@@ -7,6 +7,8 @@ import { createCodingRuntime, loadCodingPolicy } from './coding-plane.mjs';
 import { loadAutonomousPolicy } from './autonomous-policy.mjs';
 import { createNativeDiffRuntime } from './native-diff.mjs';
 import { createAutonomousRuntime } from './autonomous-runtime.mjs';
+import { createCodexAppServerR44 } from './codex-app-server-r44.mjs';
+import { DEADBYTE_VERSION } from './version.mjs';
 import { startLocalSupervisorHost } from './autonomous-local-supervisor.mjs';
 
 const packageRoot=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
@@ -30,7 +32,15 @@ const codingPolicy=await loadCodingPolicy(codingPolicyPath);
 const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath,verifyKeyPath});
 const autonomousPolicy=await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy);
 const nativeDiffRuntime=createNativeDiffRuntime({policy:autonomousPolicy,codingRuntime,signingKeyPath,verifyKeyPath});
-const autonomousRuntime=createAutonomousRuntime({policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,signingKeyPath,verifyKeyPath});
+const plannerProviderRuntime=autonomousPolicy.planner.backend==='codex_app_server'
+  ? await createCodexAppServerR44({
+      stateDir:path.join(autonomousPolicy.evidence_dir,'provider-r44','codex-app-server'),
+      model:autonomousPolicy.planner.model,cwd:codingPolicy.roots[autonomousPolicy.planner.root_id].real_path,
+      clientVersion:DEADBYTE_VERSION,executable:autonomousPolicy.planner.executable,
+      executableSha256:autonomousPolicy.planner.executable_sha256,args:autonomousPolicy.planner.args
+    })
+  : null;
+const autonomousRuntime=createAutonomousRuntime({policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,plannerProviderRuntime,signingKeyPath,verifyKeyPath});
 const markerPath=path.resolve(process.env.DEADBYTE_SUPERVISOR_MARKER||path.join(autonomousPolicy.evidence_dir,'supervisor-owner.json'));
 const host=await startLocalSupervisorHost({runtime:autonomousRuntime,policy:autonomousPolicy,markerPath,
   idleDelayMs:750,maxCycles:32,continuous:onceMode!=='1'});
@@ -43,7 +53,7 @@ let stopping=false;
 async function stopAndExit(code=0){
   if(stopping) return;
   stopping=true;
-  try { await host.stop(); }
+  try { await host.stop(); await plannerProviderRuntime?.close(); }
   catch(error){ process.stderr.write(`DEADBYTE supervisor host stop failed: ${String(error)}\n`); code=1; }
   process.exitCode=code;
 }

package/src/capability-ledger.mjs

@@ -3,7 +3,7 @@ import { createHash } from 'node:crypto';
 export const CAPABILITY_LEDGER_SCHEMA='deadbyte.capability-ledger.v1';
 const AUTHORITIES=new Set(['none','process','coding','autonomous','desktop','host']);
 const PROFILE_ENV='DEADBYTE_CAPABILITY_PROFILE';
-const COMPACT_TOOL_LIMIT=42;
+const COMPACT_TOOL_LIMIT=43;
 
 function sha256(text){return createHash('sha256').update(text,'utf8').digest('hex');}
 function canonicalJson(value){
@@ -81,6 +81,7 @@ const gateway=(id,full_tool,compact_tool,compact_op,runtime_flag,authority,{muta
 
 export const R36_CAPABILITY_ENTRIES=Object.freeze([
   direct('evidence.verify','evidence_verify',null,'none',{receipt_class:'verification'}),
+  direct('skill.catalog','skill_catalog',null,'none',{receipt_class:'skill'}),
   gateway('machine.list','machine_list','machine_observe','machine_list','DEADBYTE_MACHINE_RUNTIME','none',{receipt_class:'machine'}),
   gateway('machine.status','machine_status','machine_observe','machine_status','DEADBYTE_MACHINE_RUNTIME','none',{receipt_class:'machine'}),
   gateway('machine.ping','machine_ping','machine_observe','machine_ping','DEADBYTE_MACHINE_RUNTIME','none',{receipt_class:'machine'}),