deadbyte-mcp 0.14.0 → 0.15.1

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 {
@@ -1220,10 +1230,13 @@ async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, co
   return results;
 }
 
-async function collectNativeHead(state, nativeDiffRuntime, codingRuntime) {
+async function collectNativeHead(state, nativeDiffRuntime, codingRuntime, { requireCurrentState = true } = {}) {
   const diffBindings = []; const head = new Map();
   for (const item of state.diffs) {
-    const checked = await nativeDiffRuntime.verify({ diffId:item.diff_id });
+    const verifier = requireCurrentState
+      ? nativeDiffRuntime.verify.bind(nativeDiffRuntime)
+      : (nativeDiffRuntime.verifyEvidence ?? nativeDiffRuntime.verify).bind(nativeDiffRuntime);
+    const checked = await verifier({ diffId:item.diff_id });
     if (!checked.ok || !Array.isArray(checked.final_states)) throw new Error(`release diff '${item.diff_id}' verification failed`);
     diffBindings.push({ diff_id:item.diff_id, receipt_sha256:checked.receipt_sha256,
       coding_receipts_verified:checked.coding_receipts_verified });
@@ -1233,10 +1246,12 @@ async function collectNativeHead(state, nativeDiffRuntime, codingRuntime) {
     }
   }
   const finalSourceStates = [...head.values()].sort((a,b) => `${a.root_id}/${a.path}`.localeCompare(`${b.root_id}/${b.path}`));
-  for (const expected of finalSourceStates) {
-    const current = await codingRuntime.fileState({ rootId:expected.root_id, relativePath:expected.path });
-    if (current.exists !== expected.exists || current.sha256 !== expected.sha256) {
-      throw new Error(`release native HEAD mismatch '${expected.path}'`);
+  if (requireCurrentState) {
+    for (const expected of finalSourceStates) {
+      const current = await codingRuntime.fileState({ rootId:expected.root_id, relativePath:expected.path });
+      if (current.exists !== expected.exists || current.sha256 !== expected.sha256) {
+        throw new Error(`release native HEAD mismatch '${expected.path}'`);
+      }
     }
   }
   return { diffBindings, finalSourceStates };
@@ -1299,7 +1314,7 @@ async function verifyReleaseReceipt({ ctx, goal, events, policy, verifyKeyPath,
     return { ok:false, reason:'release profile evidence mismatch' };
   }
   let nativeHead;
-  try { nativeHead = await collectNativeHead(preCompletionState,nativeDiffRuntime,codingRuntime); }
+  try { nativeHead = await collectNativeHead(preCompletionState,nativeDiffRuntime,codingRuntime,{requireCurrentState:false}); }
   catch (error) { return { ok:false, reason:truncated(error) }; }
   if (canonicalJson(nativeHead.diffBindings) !== canonicalJson(body.native_diffs ?? [])) {
     return { ok:false, reason:'release native diff binding mismatch' };
@@ -1765,9 +1780,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 +1802,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 +2064,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'}),
@@ -134,6 +135,7 @@ export const R36_CAPABILITY_ENTRIES=Object.freeze([
   gateway('observation.search_cancel','machine_search_cancel','machine_observe','search_cancel','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
   gateway('observation.process_list','machine_process_list','machine_observe','process_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
   gateway('observation.system_status','machine_system_status','machine_observe','system_status','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
+  gateway('observation.hardware_query','machine_hardware_query','machine_observe','hardware_query','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
 
   gateway('desktop.status','desktop_status','desktop_control','status','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),
   gateway('desktop.observe','desktop_observe','desktop_control','observe','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),

package/src/codex-app-server-r44.mjs

@@ -0,0 +1,154 @@
+import path from 'node:path';
+import { createAgentBackendR44 } from './agent-backend-r44.mjs';
+
+const ID=/^[A-Za-z0-9._-]{1,64}$/;
+function insist(ok,message){if(!ok)throw new Error(message);}
+function text(value,label,max=262144){insist(typeof value==='string'&&value.length>=1&&value.length<=max,`${label} invalid`);return value;}
+function threadIdFromResponse(value){
+  const id=value?.thread?.id;insist(typeof id==='string'&&id.length>=1&&id.length<=512,'Codex thread response missing thread.id');return id;
+}
+function turnIdFromResponse(value){
+  const id=value?.turn?.id;insist(typeof id==='string'&&id.length>=1&&id.length<=512,'Codex turn response missing turn.id');return id;
+}
+function safeThreadParams({model,cwd}){
+  return {model,cwd,approvalPolicy:'never',approvalsReviewer:'user',sandbox:'read-only',ephemeral:false};
+}
+function approvalHandler({method}){
+  if(method==='item/commandExecution/requestApproval'||method==='item/fileChange/requestApproval')return {decision:'decline'};
+  if(method==='item/permissions/requestApproval')return {permissions:{},scope:'turn'};
+  if(method==='item/tool/requestUserInput')return {answers:{}};
+  const error=new Error(`Codex server request denied: ${method}`);error.code=-32001;throw error;
+}
+
+export async function createCodexAppServerR44({
+  stateDir,model,cwd,clientVersion='0.15.0',transportFactory=null,
+  executable=null,executableSha256=null,args=['app-server'],env=null
+}={}){
+  insist(typeof stateDir==='string'&&path.isAbsolute(stateDir),'Codex stateDir must be absolute');
+  text(model,'Codex model',128);insist(typeof cwd==='string'&&path.isAbsolute(cwd),'Codex cwd must be absolute');
+  text(clientVersion,'Codex client version',64);
+  const turns=new Map();
+  const attachedThreads=new Set();
+  let initialized=false;
+
+  function turnRecord(turnId,threadId=null){
+    let rec=turns.get(turnId);
+    if(!rec){rec={turn_id:turnId,thread_id:threadId,final_answer:null,unknown_answer:null,status:null,error:null,waiters:[]};turns.set(turnId,rec);}
+    else if(threadId&&rec.thread_id===null)rec.thread_id=threadId;
+    return rec;
+  }
+  function settle(rec){
+    if(!rec.status||!['completed','failed','interrupted'].includes(rec.status))return;
+    const waiters=rec.waiters.splice(0);
+    if(rec.status==='completed'){
+      const raw=rec.final_answer??rec.unknown_answer;
+      for(const waiter of waiters){
+        clearTimeout(waiter.timer);
+        if(typeof raw==='string'&&raw.length>0)waiter.resolve({raw_text:raw});
+        else waiter.reject(new Error('Codex turn completed without agent final response'));
+      }
+    }else{
+      for(const waiter of waiters){clearTimeout(waiter.timer);waiter.reject(new Error(rec.error??`Codex turn ${rec.status}`));}
+    }
+  }
+  async function notificationHandler({method,params}){
+    if(method==='item/completed'){
+      const tid=params?.turnId,threadId=params?.threadId,item=params?.item;
+      if(typeof tid!=='string'||!item||typeof item!=='object')return;
+      const rec=turnRecord(tid,typeof threadId==='string'?threadId:null);
+      if(item.type==='agentMessage'||item.type==='agent_message'){
+        if(typeof item.text!=='string')return;
+        if(item.phase==='final_answer'||item.phase==='finalAnswer')rec.final_answer=item.text;
+        else if(item.phase===null||item.phase===undefined)rec.unknown_answer=item.text;
+      }
+      return;
+    }
+    if(method==='turn/completed'){
+      const turn=params?.turn;const tid=turn?.id;
+      if(typeof tid!=='string')return;
+      const rec=turnRecord(tid,typeof params?.threadId==='string'?params.threadId:null);
+      rec.status=String(turn.status??'completed');
+      if(rec.status==='failed')rec.error=turn.error?.message??'Codex turn failed';
+      settle(rec);
+    }
+  }
+
+  const backend=await createAgentBackendR44({
+    backendId:'codex-app-server',stateDir:path.join(stateDir,'backend'),transportFactory,
+    executable,executableSha256,args,cwd,env,wireMode:'codex-app-server',
+    serverRequestHandler:approvalHandler,notificationHandler
+  });
+
+  async function start(){
+    if(initialized)return {status:'ok',initialized:true};
+    await backend.start();
+    await backend.request({method:'initialize',params:{
+      clientInfo:{name:'deadbyte-mcp',version:clientVersion},
+      capabilities:{experimentalApi:false,requestAttestation:false,optOutNotificationMethods:null}
+    },timeoutMs:30000});
+    await backend.notify({method:'initialized',params:{}});
+    initialized=true;
+    return {status:'ok',initialized:true,backend:'codex_app_server'};
+  }
+  async function ensureStarted(){if(!initialized)await start();}
+  async function ensureThread({logicalId}={}){
+    await ensureStarted();insist(typeof logicalId==='string'&&ID.test(logicalId),'Codex logical thread id invalid');
+    const status=await backend.status();const existing=status.threads[logicalId];
+    if(existing){
+      if(!attachedThreads.has(existing)){
+        const response=await backend.request({method:'thread/resume',params:{threadId:existing,...safeThreadParams({model,cwd}),excludeTurns:true},timeoutMs:60000});
+        const resumed=threadIdFromResponse(response);insist(resumed===existing,'Codex resumed thread identity mismatch');attachedThreads.add(existing);
+      }
+      return {status:'ok',logical_id:logicalId,thread_id:existing,resumed:true};
+    }
+    const response=await backend.request({method:'thread/start',params:safeThreadParams({model,cwd}),timeoutMs:60000});
+    const created=threadIdFromResponse(response);
+    await backend.bindThread({logicalId,threadId:created});attachedThreads.add(created);
+    return {status:'ok',logical_id:logicalId,thread_id:created,resumed:false};
+  }
+  function waitTurn(turnId,threadId,timeoutMs){
+    insist(Number.isInteger(timeoutMs)&&timeoutMs>=100&&timeoutMs<=900000,'Codex turn timeout invalid');
+    const rec=turnRecord(turnId,threadId);
+    if(rec.status&&['completed','failed','interrupted'].includes(rec.status)){
+      return new Promise((resolve,reject)=>{
+        const timer=setTimeout(()=>{},1);rec.waiters.push({resolve,reject,timer});settle(rec);
+      });
+    }
+    return new Promise((resolve,reject)=>{
+      const timer=setTimeout(()=>{
+        const index=rec.waiters.findIndex(x=>x.timer===timer);if(index>=0)rec.waiters.splice(index,1);
+        reject(new Error('Codex turn completion timeout'));
+      },timeoutMs);
+      rec.waiters.push({resolve,reject,timer});
+    });
+  }
+  async function runPlanner({logicalId='planner',prompt,timeoutMs=120000}={}){
+    text(prompt,'Codex planner prompt',1024*1024);
+    const thread=await ensureThread({logicalId});
+    const started=await backend.request({method:'turn/start',params:{
+      threadId:thread.thread_id,input:[{type:'text',text:prompt}],approvalPolicy:'never'
+    },timeoutMs:Math.min(timeoutMs,60000)});
+    const turnId=turnIdFromResponse(started);turnRecord(turnId,thread.thread_id);
+    const completed=await waitTurn(turnId,thread.thread_id,timeoutMs);
+    return {backend:'codex_app_server',model,raw_text:completed.raw_text,response_id:turnId,thread_id:thread.thread_id};
+  }
+  async function steer({threadId,turnId,text:message,timeoutMs=30000}={}){
+    await ensureStarted();text(threadId,'Codex threadId',512);text(turnId,'Codex turnId',512);text(message,'Codex steer text',262144);
+    return backend.request({method:'turn/steer',params:{threadId,expectedTurnId:turnId,input:[{type:'text',text:message}]},timeoutMs});
+  }
+  async function interrupt({threadId,turnId,timeoutMs=30000}={}){
+    await ensureStarted();text(threadId,'Codex threadId',512);text(turnId,'Codex turnId',512);
+    return backend.request({method:'turn/interrupt',params:{threadId,turnId},timeoutMs});
+  }
+  async function modelList({includeHidden=false}={}){
+    await ensureStarted();return backend.request({method:'model/list',params:{includeHidden:includeHidden===true},timeoutMs:30000});
+  }
+  async function status(){const value=await backend.status();return {...value,initialized,attached_threads:[...attachedThreads].sort()};}
+  async function close(){
+    for(const rec of turns.values()){
+      for(const waiter of rec.waiters.splice(0)){clearTimeout(waiter.timer);waiter.reject(new Error('Codex adapter closed before turn completion'));}
+    }
+    initialized=false;attachedThreads.clear();return backend.close();
+  }
+  return Object.freeze({start,ensureThread,runPlanner,steer,interrupt,modelList,status,close,backend});
+}