deadbyte-mcp 0.14.0 → 0.15.0

package/test/autonomous-loop.test.mjs

@@ -32,7 +32,7 @@ async function startPlanner(decisions) {
   await new Promise(resolve => server.listen(0,'127.0.0.1',resolve));
   return { server, prompts, endpoint:`http://127.0.0.1:${server.address().port}/v1/chat/completions` };
 }
-async function fixture(decisionPrefix = []) {
+async function fixture(decisionPrefix = [], options = {}) {
   const root = await mkdtemp(path.join(os.tmpdir(),'deadbyte-autonomous-loop-'));
   const project = path.join(root,'project'); const trust = path.join(root,'trust');
   await mkdir(project); await mkdir(trust);
@@ -101,14 +101,17 @@ async function fixture(decisionPrefix = []) {
   const policy = await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy);
   await writeFile(policy.lease_file,JSON.stringify({ schema:'deadbyte.autonomous-lease.v1',
     policy_sha256:policy.policy_sha256, instance_nonce:randomBytes(32).toString('hex'), root_ids:['project'],
-    armed_at_utc:new Date().toISOString(), expires_at_utc:new Date(Date.now()+1800000).toISOString() }));
+    armed_at_utc:new Date().toISOString(), expires_at_utc:new Date(Date.now()+(options.autonomousLeaseMs??1800000)).toISOString() }));
   const codingRuntime = createCodingRuntime({ policy:codingPolicy,
     signingKeyPath:keys.privateKeyPath, verifyKeyPath:keys.publicKeyPath });
+  const autonomousCodingRuntime = options.codingRuntimeFactory
+    ? options.codingRuntimeFactory(codingRuntime,{policy})
+    : codingRuntime;
   const nativeDiff = createNativeDiffRuntime({ policy,codingRuntime,
     signingKeyPath:keys.privateKeyPath, verifyKeyPath:keys.publicKeyPath });
-  const runtime = createAutonomousRuntime({ policy,codingRuntime,nativeDiffRuntime:nativeDiff,
+  const runtime = createAutonomousRuntime({ policy,codingRuntime:autonomousCodingRuntime,nativeDiffRuntime:nativeDiff,
     signingKeyPath:keys.privateKeyPath, verifyKeyPath:keys.publicKeyPath });
-  return { root,project,program,keys,policy,codingRuntime,nativeDiff,runtime,planner,
+  return { root,project,program,keys,policy,codingRuntime,autonomousCodingRuntime,nativeDiff,runtime,planner,
     initialHash,almostHash,fixedHash };
 }
 
@@ -144,6 +147,83 @@ test('R24 autonomous goal diagnoses a failing test, replans with native diff, be
   }
 });
 
+test('autonomous profile execution is capped by the absolute autonomous lease without changing coding request identity', async () => {
+  const calls=[];
+  const f=await fixture([],{
+    autonomousLeaseMs:30000,
+    codingRuntimeFactory:base=>Object.freeze({
+      ...base,
+      commandRun:async args=>{
+        const result=await base.commandRun(args);
+        calls.push({kind:'command',deadline:args.executionDeadlineUtc,has_precheck:typeof args.preExecutionCheck==='function',
+          timeout_ms:result.timeout_ms,request_sha256:result.request_sha256});
+        return result;
+      },
+      benchmarkRun:async args=>{
+        const result=await base.benchmarkRun(args);
+        calls.push({kind:'benchmark',deadline:args.executionDeadlineUtc,has_precheck:typeof args.preExecutionCheck==='function',
+          request_sha256:result.request_sha256});
+        return result;
+      }
+    })
+  });
+  try {
+    const submitted=await f.runtime.submit({submissionId:'profile-deadline',rootId:'project',
+      title:'deadline-bound profiles',goal:'make exported value equal fixed',
+      acceptance:'build, test, and benchmark must pass',maxIterations:10});
+    const result=await f.runtime.run({goalId:submitted.goal_id,maxCycles:16});
+    assert.equal(result.status,'completed');
+    assert.ok(calls.length>=3);
+    assert.ok(calls.every(call=>typeof call.deadline==='string'&&Number.isFinite(Date.parse(call.deadline))));
+    assert.ok(calls.every(call=>call.has_precheck===true));
+    const command=calls.find(call=>call.kind==='command');
+    assert.ok(command.timeout_ms>=100&&command.timeout_ms<30000);
+    const build=f.policy.profiles.build;
+    assert.equal(command.request_sha256,f.codingRuntime.requestSha('coding_command_run',{
+      root_id:build.root_id,command_id:build.command_id,script_path:build.script_path,script_sha256:build.script_sha256,
+      args:build.args,cwd:build.cwd,timeout_ms:build.timeout_ms
+    }));
+  } finally {
+    await new Promise(resolve=>f.planner.server.close(resolve));
+    await rm(f.root,{recursive:true,force:true});
+  }
+});
+
+test('autonomous profile nonce rotation immediately before spawn fails closed without a coding receipt', async () => {
+  let rotated=false;
+  const f=await fixture([],{
+    codingRuntimeFactory:(base,{policy})=>Object.freeze({
+      ...base,
+      commandRun:async args=>{
+        if(!rotated){
+          rotated=true;
+          const lease=JSON.parse(await readFile(policy.lease_file,'utf8'));
+          await writeFile(policy.lease_file,JSON.stringify({...lease,instance_nonce:'f'.repeat(64)}));
+        }
+        return base.commandRun(args);
+      }
+    })
+  });
+  try {
+    const submitted=await f.runtime.submit({submissionId:'profile-revoke-before-spawn',rootId:'project',
+      title:'profile revoke',goal:'make exported value equal fixed',
+      acceptance:'profile dispatch must fail closed after authority rotation',maxIterations:10});
+    const result=await f.runtime.run({goalId:submitted.goal_id,maxCycles:16});
+    assert.equal(rotated,true);
+    assert.equal(result.status,'paused');
+    const journal=await f.runtime.events({goalId:submitted.goal_id,fromSeq:1,limit:200});
+    const started=journal.events.find(event=>event.type==='profile_started'&&event.payload?.profile_id==='build');
+    assert.ok(started);
+    assert.match(started.payload.authority_instance_nonce,/^[0-9a-f]{64}$/);
+    assert.ok(journal.events.some(event=>event.type==='goal_paused'&&event.payload?.reason==='profile_execution_without_receipt'));
+    assert.equal(journal.events.some(event=>event.type==='profile_completed'&&event.payload?.profile_id==='build'),false);
+    assert.equal((await f.codingRuntime.verifyReceiptDetailed(started.payload.receipt_id)).ok,false);
+  } finally {
+    await new Promise(resolve=>f.planner.server.close(resolve));
+    await rm(f.root,{recursive:true,force:true});
+  }
+});
+
 test('provider planner repairs an invalid structured decision inside the same run', async () => {
   const f = await fixture(['not-json']);
   try {
@@ -166,7 +246,7 @@ test('provider planner repairs an invalid structured decision inside the same ru
   }
 });
 
-test('provider circuit survives runtime restart, suppresses OPEN calls, then permits one HALF_OPEN probe', async () => {
+test('provider circuit survives runtime restart and permits exactly one probe at the HALF_OPEN boundary', async () => {
   const failures=[{__http_status:503},{__http_status:503},{__http_status:503}];
   const f=await fixture(failures);
   try {
@@ -178,17 +258,23 @@ test('provider circuit survives runtime restart, suppresses OPEN calls, then per
     const opened=await f.runtime.run({goalId:submitted.goal_id,maxCycles:2});
     assert.equal(opened.status,'paused');
     assert.equal(opened.reason,'provider_circuit_open');
+    const openedJournal=await f.runtime.events({goalId:submitted.goal_id,fromSeq:1,limit:200});
+    const openPause=[...openedJournal.events].reverse().find(event=>event.type==='goal_paused'&&event.payload?.reason==='provider_circuit_open');
+    assert.equal(openPause?.payload?.circuit_state,'OPEN',JSON.stringify(openPause));
     assert.equal(f.planner.prompts.length,3);
 
-    const immediate=await f.runtime.run({goalId:submitted.goal_id,maxCycles:2});
-    assert.equal(immediate.status,'paused');
-    assert.equal(f.planner.prompts.length,3,'OPEN circuit must suppress provider invocation');
-
     const restarted=createAutonomousRuntime({policy:f.policy,codingRuntime:f.codingRuntime,nativeDiffRuntime:f.nativeDiff,
       signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath});
-    await new Promise(resolve=>setTimeout(resolve,130));
-    const circuitBeforeResume=await restarted.providerCircuitStatus({goalId:submitted.goal_id});
+    const deadline=Date.now()+2_000;
+    let circuitBeforeResume;
+    do {
+      circuitBeforeResume=await restarted.providerCircuitStatus({goalId:submitted.goal_id});
+      if(circuitBeforeResume.state==='HALF_OPEN') break;
+      assert.equal(circuitBeforeResume.state,'OPEN',JSON.stringify(circuitBeforeResume));
+      await new Promise(resolve=>setTimeout(resolve,10));
+    } while(Date.now()<deadline);
     assert.equal(circuitBeforeResume.state,'HALF_OPEN',JSON.stringify(circuitBeforeResume));
+
     const resumed=await restarted.run({goalId:submitted.goal_id,maxCycles:1});
     assert.notEqual(resumed.status,'paused');
     assert.equal(f.planner.prompts.length,4,'HALF_OPEN must permit exactly one provider probe');

package/test/autonomous-runtime.test.mjs

@@ -20,7 +20,7 @@ const r24Tools = [
   'native_diff_apply', 'native_diff_preview', 'native_diff_verify'
 ];
 const r23Tools = [
-  'contained_transform','evidence_verify','file_read','proof_execute','workspace_open',
+  'contained_transform','evidence_verify','file_read','proof_execute','skill_catalog','workspace_open',
   'agent_task_approve','agent_task_cancel','agent_task_events','agent_task_run',
   'agent_task_status','agent_task_submit','agent_task_verify',
   'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_files_read',
@@ -75,7 +75,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test('R36 hermetic autonomous fixture exposes the exact 49-tool no-host catalog', async () => {
+test('R44 hermetic autonomous fixture exposes the exact 50-tool no-host catalog', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

package/test/capability-ledger-r36.test.mjs

@@ -92,12 +92,12 @@ test('R36 closure fails when a production route is lost or advertised tool is ab
   }), /compact tool/i);
 });
 
-test('R36 compact surface hard-fails above the observed 42-tool ceiling', () => {
+test('R44 compact surface hard-fails above the observed 43-tool ceiling', () => {
   const ledger=createCapabilityLedger([entry({})]);
-  const tooMany=Array.from({length:43},(_,i)=>i===0?'coding_inspect':`extra_${i}`);
+  const tooMany=Array.from({length:44},(_,i)=>i===0?'coding_inspect':`extra_${i}`);
   assert.throws(() => assertCapabilityClosure({
     ledger,
     fullToolSnapshot:snapshot(['coding_search']),
     compactToolSnapshot:snapshot(tooMany)
-  }), /42/i);
+  }), /43/i);
 });

package/test/cli-entrypoint.test.mjs

@@ -21,7 +21,7 @@ test('npx CLI reports the canonical package version through --version, -v and ve
   for(const arg of ['--version','-v','version']){
     const result=spawnSync(process.execPath,[cliPath,arg],{cwd:root,encoding:'utf8',windowsHide:true});
     assert.equal(result.status,0,result.stderr);
-    assert.equal(result.stdout.trim(),'0.14.0');
+    assert.equal(result.stdout.trim(),'0.15.0');
   }
 });
 

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

@@ -0,0 +1,115 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createCodexAppServerR44 } from '../src/codex-app-server-r44.mjs';
+
+async function waitFor(predicate,timeoutMs=2000){
+  const deadline=Date.now()+timeoutMs;
+  while(Date.now()<deadline){const value=predicate();if(value)return value;await new Promise(resolve=>setTimeout(resolve,5));}
+  throw new Error('waitFor timeout');
+}
+class FakeTransport extends EventEmitter{
+  constructor(){super();this.sent=[];}
+  async start(){}
+  async send(value){this.sent.push(structuredClone(value));}
+  async stop(){}
+  request(method){return this.sent.findLast?.(x=>x.method===method&&Object.hasOwn(x,'id'))??[...this.sent].reverse().find(x=>x.method===method&&Object.hasOwn(x,'id'));}
+  reply(id,result){this.emit('message',{id,result});}
+  notify(method,params){this.emit('message',{method,params});}
+  serverRequest(id,method,params){this.emit('message',{id,method,params});}
+}
+
+test('R44 Codex adapter initializes no-jsonrpc wire and starts safe persistent planner thread',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-codex-'));const transport=new FakeTransport();
+  try{
+    const codex=await createCodexAppServerR44({stateDir:root,transportFactory:async()=>transport,
+      model:'gpt-test',cwd:root,clientVersion:'0.15.0'});
+    const start=codex.start();
+    const init=await waitFor(()=>transport.request('initialize'));
+    assert.equal('jsonrpc' in init,false);
+    assert.deepEqual(init.params.clientInfo,{name:'deadbyte-mcp',version:'0.15.0'});
+    assert.equal(init.params.capabilities.experimentalApi,false);
+    transport.reply(init.id,{userAgent:'codex-test'});
+    await start;
+    const initialized=transport.sent.find(x=>x.method==='initialized'&&!Object.hasOwn(x,'id'));
+    assert.ok(initialized);assert.equal('jsonrpc' in initialized,false);
+
+    const ensure=codex.ensureThread({logicalId:'planner'});
+    const req=await waitFor(()=>transport.request('thread/start'));
+    assert.equal(req.params.model,'gpt-test');assert.equal(req.params.cwd,root);
+    assert.equal(req.params.approvalPolicy,'never');assert.equal(req.params.sandbox,'read-only');
+    assert.equal(req.params.ephemeral,false);assert.equal(req.params.approvalsReviewer,'user');
+    transport.reply(req.id,{thread:{id:'thread-1'},model:'gpt-test',modelProvider:'openai',cwd:root,
+      approvalPolicy:'never',approvalsReviewer:'user',sandbox:{type:'readOnly'}});
+    const thread=await ensure;assert.equal(thread.thread_id,'thread-1');assert.equal(thread.resumed,false);
+    await codex.close();
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 Codex planner routes final answer by turn id and declines provider approvals',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-codex-turn-'));const transport=new FakeTransport();
+  try{
+    const codex=await createCodexAppServerR44({stateDir:root,transportFactory:async()=>transport,model:'gpt-test',cwd:root});
+    const start=codex.start();const init=await waitFor(()=>transport.request('initialize'));transport.reply(init.id,{});await start;
+    const ensure=codex.ensureThread({logicalId:'planner'});const ts=await waitFor(()=>transport.request('thread/start'));
+    transport.reply(ts.id,{thread:{id:'thread-1'},model:'gpt-test'});await ensure;
+
+    const planned=codex.runPlanner({logicalId:'planner',prompt:'Return JSON',timeoutMs:2000});
+    const turn=await waitFor(()=>transport.request('turn/start'));
+    assert.equal(turn.params.threadId,'thread-1');assert.deepEqual(turn.params.input,[{type:'text',text:'Return JSON'}]);
+    assert.equal(turn.params.approvalPolicy,'never');
+    transport.reply(turn.id,{turn:{id:'turn-1',status:'inProgress'}});
+    transport.notify('item/completed',{threadId:'thread-1',turnId:'other',item:{id:'x',type:'agentMessage',text:'wrong'}});
+    transport.notify('item/completed',{threadId:'thread-1',turnId:'turn-1',item:{id:'m1',type:'agentMessage',text:'working',phase:'commentary'}});
+    transport.notify('item/completed',{threadId:'thread-1',turnId:'turn-1',item:{id:'m2',type:'agentMessage',text:'{"schema":"ok"}',phase:'final_answer'}});
+    transport.notify('turn/completed',{threadId:'thread-1',turn:{id:'turn-1',status:'completed'}});
+    const result=await planned;
+    assert.equal(result.backend,'codex_app_server');assert.equal(result.raw_text,'{"schema":"ok"}');assert.equal(result.response_id,'turn-1');
+
+    transport.serverRequest('approval-1','item/commandExecution/requestApproval',{threadId:'thread-1',turnId:'turn-1'});
+    const denial=await waitFor(()=>transport.sent.find(x=>x.id==='approval-1'));
+    assert.deepEqual(denial.result,{decision:'decline'});assert.equal(denial.error,undefined);
+    await codex.close();
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 Codex steer and interrupt bind exact active turn identity',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-codex-control-'));const transport=new FakeTransport();
+  try{
+    const codex=await createCodexAppServerR44({stateDir:root,transportFactory:async()=>transport,model:'gpt-test',cwd:root});
+    const start=codex.start();const init=await waitFor(()=>transport.request('initialize'));transport.reply(init.id,{});await start;
+    const steerP=codex.steer({threadId:'thread-1',turnId:'turn-1',text:'new direction',timeoutMs:2000});
+    const steer=await waitFor(()=>transport.request('turn/steer'));
+    assert.deepEqual(steer.params,{threadId:'thread-1',expectedTurnId:'turn-1',input:[{type:'text',text:'new direction'}]});
+    transport.reply(steer.id,{turnId:'turn-1'});await steerP;
+    const interruptP=codex.interrupt({threadId:'thread-1',turnId:'turn-1',timeoutMs:2000});
+    const interrupt=await waitFor(()=>transport.request('turn/interrupt'));
+    assert.deepEqual(interrupt.params,{threadId:'thread-1',turnId:'turn-1'});
+    transport.reply(interrupt.id,{});await interruptP;
+    await codex.close();
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R44 Codex adapter resumes durable thread after backend process recreation',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-codex-resume-'));
+  try{
+    const firstTransport=new FakeTransport();
+    const first=await createCodexAppServerR44({stateDir:root,transportFactory:async()=>firstTransport,model:'gpt-test',cwd:root});
+    const s1=first.start();const i1=await waitFor(()=>firstTransport.request('initialize'));firstTransport.reply(i1.id,{});await s1;
+    const e1=first.ensureThread({logicalId:'planner'});const t1=await waitFor(()=>firstTransport.request('thread/start'));
+    firstTransport.reply(t1.id,{thread:{id:'thread-persist'},model:'gpt-test'});await e1;await first.close();
+
+    const secondTransport=new FakeTransport();
+    const second=await createCodexAppServerR44({stateDir:root,transportFactory:async()=>secondTransport,model:'gpt-test',cwd:root});
+    const s2=second.start();const i2=await waitFor(()=>secondTransport.request('initialize'));secondTransport.reply(i2.id,{});await s2;
+    const e2=second.ensureThread({logicalId:'planner'});const resume=await waitFor(()=>secondTransport.request('thread/resume'));
+    assert.equal(resume.params.threadId,'thread-persist');assert.equal(resume.params.approvalPolicy,'never');assert.equal(resume.params.sandbox,'read-only');
+    secondTransport.reply(resume.id,{thread:{id:'thread-persist'},model:'gpt-test'});
+    const result=await e2;assert.equal(result.thread_id,'thread-persist');assert.equal(result.resumed,true);
+    assert.equal(secondTransport.sent.some(x=>x.method==='thread/start'),false);
+    await second.close();
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/codex-autonomous-r44.test.mjs

@@ -0,0 +1,87 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, randomBytes } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { createCodingRuntime, loadCodingPolicy } from '../src/coding-plane.mjs';
+import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
+import { createNativeDiffRuntime } from '../src/native-diff.mjs';
+import { createAutonomousRuntime } from '../src/autonomous-runtime.mjs';
+import { providerCircuitId } from '../src/provider-circuit.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const nonce=()=>randomBytes(32).toString('hex');
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-codex-auto-'));
+  const project=path.join(root,'project'),trust=path.join(root,'trust');
+  await mkdir(project);await mkdir(trust);
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  const codingPath=path.join(root,'coding.json');
+  await writeFile(codingPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(root,'coding-grant.json'),evidence_dir:path.join(root,'coding-evidence'),
+    roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:[]}},commands:{}},null,2));
+  const codingPolicy=await loadCodingPolicy(codingPath);
+  const nodeSha=sha(await readFile(process.execPath));
+  const autonomousPath=path.join(root,'autonomous.json');
+  await writeFile(autonomousPath,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+    lease_file:path.join(root,'autonomous-grant.json'),evidence_dir:path.join(root,'autonomous-evidence'),
+    coding_policy_sha256:codingPolicy.policy_sha256,root_ids:['project'],
+    planner:{backend:'codex_app_server',model:'gpt-test',root_id:'project',executable:process.execPath,
+      executable_sha256:nodeSha,args:['app-server'],max_tokens:4096,timeout_ms:30000,
+      circuit:{failure_threshold:2,open_ms:1000,half_open_probe_limit:1}},
+    profiles:{},limits:{max_iterations:8,max_mutations:4,max_wall_ms:600000,max_context_bytes:262144,
+      max_diff_bytes:262144,max_files_per_diff:4,max_stalled_cycles:2,max_post_replan_stalls:2,max_replans:4}},null,2));
+  const policy=await loadAutonomousPolicy(autonomousPath,codingPolicy);
+  await writeFile(codingPolicy.lease_file,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:codingPolicy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()}));
+  await writeFile(policy.lease_file,JSON.stringify({schema:'deadbyte.autonomous-grant.v2',policy_sha256:policy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()}));
+  const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const nativeDiffRuntime=createNativeDiffRuntime({policy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  return {root,project,keys,codingPolicy,policy,codingRuntime,nativeDiffRuntime,cleanup:()=>rm(root,{recursive:true,force:true})};
+}
+
+test('R44 policy binds Codex executable, model, root and circuit identity',async()=>{
+  const f=await fixture();
+  try{
+    assert.equal(f.policy.planner.backend,'codex_app_server');
+    assert.equal(f.policy.planner.root_id,'project');
+    assert.equal(f.policy.planner.executable,process.execPath);
+    assert.match(f.policy.planner.executable_sha256,/^[0-9a-f]{64}$/);
+    assert.deepEqual(f.policy.planner.args,['app-server']);
+    assert.match(providerCircuitId(f.policy.planner),/^codex_app_server:[0-9a-f]{64}$/);
+  }finally{await f.cleanup();}
+});
+
+test('R44 autonomous runtime consumes injected Codex planner and does not ask client sampling',async()=>{
+  const f=await fixture();const calls=[];
+  try{
+    const plannerProviderRuntime={runPlanner:async({logicalId,prompt,timeoutMs})=>{
+      calls.push({logicalId,prompt,timeoutMs});
+      return {backend:'codex_app_server',model:'gpt-test',raw_text:JSON.stringify({
+        schema:'deadbyte.autonomous-decision.v2',kind:'plan_create',title:'Provider path',
+        reason:'prove Codex planner integration',steps:[{step_id:'prove',intent:'observe provider call'}]
+      }),response_id:'turn-test-1'};
+    }};
+    const runtime=createAutonomousRuntime({policy:f.policy,codingRuntime:f.codingRuntime,nativeDiffRuntime:f.nativeDiffRuntime,
+      plannerProviderRuntime,signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath});
+    const submitted=await runtime.submit({submissionId:'codex-plan',rootId:'project',title:'codex',goal:'prove provider path',acceptance:'pause'});
+    const result=await runtime.run({goalId:submitted.goal_id,maxCycles:1});
+    assert.notEqual(result.status,'input_required');
+    assert.equal(result.status,'yielded');
+    assert.equal(calls.length,1);
+    assert.equal(calls[0].logicalId,`goal-${submitted.goal_id}`);
+    assert.match(calls[0].prompt,/DEADBYTE/);
+  }finally{await f.cleanup();}
+});
+
+test('R44 autonomous Codex policy fails closed without injected provider runtime',async()=>{
+  const f=await fixture();
+  try{
+    assert.throws(()=>createAutonomousRuntime({policy:f.policy,codingRuntime:f.codingRuntime,nativeDiffRuntime:f.nativeDiffRuntime,
+      signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath}),/codex.*provider/i);
+  }finally{await f.cleanup();}
+});

package/test/coding-plane.test.mjs

@@ -19,7 +19,7 @@ const codingTools = [
   'coding_task_events', 'coding_task_run', 'coding_task_status', 'coding_task_submit',
   'coding_task_verify', 'coding_text_replace', 'coding_tree'
 ];
-const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'workspace_open'];
+const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'skill_catalog', 'workspace_open'];
 const agentTools = [
   'agent_task_approve', 'agent_task_cancel', 'agent_task_events', 'agent_task_run',
   'agent_task_status', 'agent_task_submit', 'agent_task_verify'
@@ -69,7 +69,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test('R36 hermetic coding fixture exposes the exact 37-tool no-host catalog', async () => {
+test('R44 hermetic coding fixture exposes the exact 38-tool no-host catalog', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

package/test/coding-runtime.test.mjs

@@ -5,7 +5,7 @@ import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
-import { createCodingRuntime, loadCodingPolicy } from '../src/coding-plane.mjs';
+import { assertCodingArmed, createCodingRuntime, loadCodingPolicy, recheckCodingAuthority } from '../src/coding-plane.mjs';
 import { createCodingTaskRuntime } from '../src/coding-task-runtime.mjs';
 
 function sha256Bytes(bytes) { return createHash('sha256').update(bytes).digest('hex'); }
@@ -78,6 +78,41 @@ test('coding plane rejects mutation when lease is absent or precondition is stal
     await assert.rejects(() => f.runtime.fileWrite({ rootId: 'project', relativePath: 'x.txt', content: 'x', expectedSha256: 'absent' }), /coding plane is disarmed/);
   } finally { await rm(f.root, { recursive: true, force: true }); }
 });
+
+test('coding authority recheck rejects lease generation or expiry drift before commit', async () => {
+  const f = await fixture();
+  try {
+    const initial = await assertCodingArmed(f.policy, 'project');
+    const lease = JSON.parse(await readFile(f.policy.lease_file, 'utf8'));
+    await writeFile(f.policy.lease_file, JSON.stringify({ ...lease, instance_nonce: 'b'.repeat(64) }));
+    await assert.rejects(() => recheckCodingAuthority(f.policy, initial, 'project'), /coding authority changed during operation/);
+    await writeFile(f.policy.lease_file, JSON.stringify({
+      ...lease,
+      expires_at_utc: new Date(Date.parse(lease.expires_at_utc) + 60000).toISOString()
+    }));
+    await assert.rejects(() => recheckCodingAuthority(f.policy, initial, 'project'), /coding authority changed during operation/);
+  } finally { await rm(f.root, { recursive: true, force: true }); }
+});
+test('coding execution deadline bounds runtime without changing the signed request identity', async () => {
+  const f = await fixture();
+  try {
+    const script = path.join(f.project, 'deadline.mjs');
+    await writeFile(script, "await new Promise(resolve => setTimeout(resolve, 10000));\n");
+    const scriptHash = await sha256File(script);
+    const args = { rootId:'project', commandId:'node_script', scriptPath:'deadline.mjs', scriptSha256:scriptHash,
+      timeoutMs:20000, executionDeadlineUtc:new Date(Date.now()+3000).toISOString() };
+    const expectedRequest = f.runtime.requestSha('coding_command_run', {
+      root_id:'project', command_id:'node_script', script_path:'deadline.mjs', script_sha256:scriptHash,
+      args:[], cwd:'.', timeout_ms:20000
+    });
+    const result = await f.runtime.commandRun(args);
+    assert.equal(result.status, 'observed_failure');
+    assert.equal(result.timed_out, true);
+    assert.ok(result.timeout_ms >= 500 && result.timeout_ms <= 3000);
+    assert.equal(result.request_sha256, expectedRequest);
+  } finally { await rm(f.root, { recursive:true, force:true }); }
+});
+
 test('coding command and benchmark produce signed observations', async () => {
   const f = await fixture();
   try {

package/test/compact-catalog-r36.test.mjs

@@ -10,7 +10,7 @@ const repoRoot=path.resolve(here,'..');
 const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
 const gatewayNames=['capability_manifest','coding_inspect','desktop_control','machine_fs','machine_observe','process_session'];
 
-test('R36 real compact stdio catalog stays <=42 and exposes all gateways',async()=>{
+test('R44 real compact stdio catalog stays <=43 and exposes all gateways plus skill_catalog',async()=>{
   const client=new Client({name:'deadbyte-r36-compact-test',version:'0.10.0-dev'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
   const env={
     ...getDefaultEnvironment(),
@@ -24,8 +24,8 @@ test('R36 real compact stdio catalog stays <=42 and exposes all gateways',async(
     await client.connect(transport);
     const listed=await client.listTools();
     const names=listed.tools.map(tool=>tool.name).sort();
-    assert.ok(names.length<=42,`compact tool count ${names.length} exceeds 42`);
-    for(const name of gatewayNames) assert.ok(names.includes(name),`missing ${name}`);
+    assert.ok(names.length<=43,`compact tool count ${names.length} exceeds 43`);
+    for(const name of [...gatewayNames,'skill_catalog']) assert.ok(names.includes(name),`missing ${name}`);
     for(const legacy of ['workspace_open','file_read','proof_execute','contained_transform']) assert.equal(names.includes(legacy),false,`legacy full-only tool leaked: ${legacy}`);
     const manifest=await client.callTool({name:'capability_manifest',arguments:{}});
     assert.equal(manifest.isError,false);

package/test/compact-max-catalog-r40.test.mjs

@@ -10,7 +10,9 @@ import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
 
 const here=path.dirname(fileURLToPath(import.meta.url));
 const repoRoot=path.resolve(here,'..');
-const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const parent=JSON.parse(await readFile(path.join(repoRoot,'R44-PARENT.json'),'utf8'));
+const parentRoot=parent.parent_release_root;
+const serverPath=path.join(parentRoot,'src','mcp-server.mjs');
 const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy.json');
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
 const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
@@ -70,7 +72,7 @@ test('R40 real max-runtime compact stdio catalog is exactly 42 while all authori
     DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
     DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
   };
-  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:parentRoot,env,stderr:'pipe'});
   try{
     await client.connect(transport);
     const listed=await client.listTools();

package/test/compact-max-catalog-r44.test.mjs

@@ -0,0 +1,97 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy.json');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
+
+test('R44 real max-runtime compact stdio catalog is exactly 43 with verified skill_catalog while all authority remains disarmed',async()=>{
+  const f=await createR34Fixture({authority:'disarmed'});
+  const processPolicyPath=path.join(f.root,'process-policy.json');
+  const processGrant=path.join(f.root,'process-grant.json');
+  const processState=path.join(f.root,'process-state');
+  const hostPolicyPath=path.join(f.root,'host-policy.json');
+  const hostArm=path.join(f.root,'host-arm.json');
+  const nodeSha=sha(await readFile(process.execPath));
+  await mkdir(processState,{recursive:true});
+  await writeFile(processPolicyPath,JSON.stringify({
+    schema:'deadbyte.process-policy.v1',enabled:true,grant_file:processGrant,state_dir:processState,
+    native_host:{path:process.execPath,sha256:nodeSha},
+    roots:{core:{path:f.project,deny_paths:[]}},
+    profiles:{node:{executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],
+      prefix_args:[],transport:'pipe',max_args:8,max_arg_bytes:1024,max_sessions:2,
+      max_input_bytes:65536,max_retained_output_bytes:262144,env_allow:['PATH','TEMP','TMP'],
+      input_actions:{ping:'PING\r\n'}}}
+  },null,2));
+  await writeFile(hostPolicyPath,JSON.stringify({
+    schema:'deadbyte.host-policy.v1',enabled:true,arm_file:hostArm,max_read_bytes:262144,max_write_bytes:1048576,
+    roots:{core:{path:f.project,read:true,write:true,exec:true}},
+    commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:nodeSha,
+      root_ids:['core'],prefix_args:[],extensions:['.mjs'],timeout_ms:5000,max_output_bytes:65536}}
+  },null,2));
+
+  const desktopRaw=JSON.parse(await readFile(desktopPolicyPath,'utf8'));
+  const desktopGrant=desktopRaw.grant_file;
+  const codingLease=f.codingPolicy.lease_file;
+  const autonomousLease=f.policy.lease_file;
+  for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority unexpectedly armed before start: '+q);
+
+  const client=new Client({name:'deadbyte-r40-max-catalog',version:'0.12.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const env={
+    ...getDefaultEnvironment(),
+    DEADBYTE_CAPABILITY_PROFILE:'compact',
+    DEADBYTE_AUDIT_RUNTIME:'0',
+    DEADBYTE_STATE_ROOT:path.join(f.root,'state'),
+    DEADBYTE_WORKSPACE_ROOT:f.root,
+    DEADBYTE_SIGNING_KEY:f.keys.privateKeyPath,
+    DEADBYTE_VERIFY_KEY:f.keys.publicKeyPath,
+    DEADBYTE_PRIVILEGED_POLICY:hostPolicyPath,
+    DEADBYTE_MACHINE_RUNTIME:'1',
+    DEADBYTE_AGENT_RUNTIME:'0',
+    DEADBYTE_PROCESS_RUNTIME:'1',
+    DEADBYTE_PROCESS_POLICY:processPolicyPath,
+    DEADBYTE_CODING_RUNTIME:'1',
+    DEADBYTE_CODING_POLICY:path.join(f.root,'coding-policy.json'),
+    DEADBYTE_MACHINE_FS_RUNTIME:'1',
+    DEADBYTE_OBSERVATION_RUNTIME:'1',
+    DEADBYTE_DESKTOP_RUNTIME:'1',
+    DEADBYTE_DESKTOP_POLICY:desktopPolicyPath,
+    DEADBYTE_AUTONOMOUS_RUNTIME:'1',
+    DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
+    DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
+  };
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(t=>t.name).sort();
+    assert.equal(names.length,43,'expected exact compact max catalog 43, got '+names.length+': '+names.join(','));
+    for(const name of ['capability_manifest','desktop_control','coding_inspect','machine_fs','machine_observe','process_session',
+      'host_file_read','host_file_write','host_exec','skill_catalog']) assert.ok(names.includes(name),'missing '+name);
+    const manifest=await client.callTool({name:'capability_manifest',arguments:{}});
+    assert.equal(manifest.isError,false);
+    const m=manifest.structuredContent.result;
+    assert.equal(m.schema,'deadbyte.capability-manifest.v2');
+    assert.equal(m.profile,'compact');
+    assert.equal(m.tool_count,43);
+    assert.deepEqual(m.tool_catalog,names);
+    assert.match(m.catalog_sha256,/^[0-9a-f]{64}$/);
+    const skill=m.capabilities.find(item=>item.id==='skill.catalog');
+    assert.ok(skill);assert.equal(skill.authority,'none');assert.equal(skill.mutating,false);
+    console.log(JSON.stringify({tool_count:m.tool_count,catalog_sha256:m.catalog_sha256,ledger_sha256:m.ledger_sha256,desktop:true,skill:true,authority:'DISARMED'}));
+  } finally {
+    await client.close().catch(()=>{});
+    for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority file appeared during catalog probe: '+q);
+    await f.cleanup();
+  }
+});

package/test/core.test.mjs

@@ -105,7 +105,7 @@ test('proof execution creates deterministic output and signed verifiable receipt
   assert.equal(result.receipt.request.schema, 'deadbyte.request.v1');
   assert.match(result.receipt.request.nonce, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.request.sha256, /^[0-9a-f]{64}$/);
-  assert.equal(result.receipt.runtime.package_version, '0.14.0');
+  assert.equal(result.receipt.runtime.package_version, '0.15.0');
   assert.match(result.receipt.runtime.mcp_ingress_adapter, /^(?:none|tunnel-stdio-probe-compat-v1)$/);
   assert.match(result.receipt.runtime.mcp_ingress_adapter_sha256, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.runtime.mcp_ingress_mode_source_sha256, /^[0-9a-f]{64}$/);