deadbyte-mcp 0.13.0 → 0.14.0

package/test/agent-eval-r42.test.mjs

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runIsolatedEvaluation, buildFreshCriticContext, triageJudgeResult } from '../src/agent-eval-r42.mjs';
+
+const H=value=>String(value).repeat(64).slice(0,64);
+
+test('R42 generator never receives judge-only oracle or hidden ground truth',async()=>{
+  const oracleToken='ORACLE_ONLY_7fca1b';
+  let generatorInput,judgeInput;
+  const result=await runIsolatedEvaluation({caseSpec:{schema:'deadbyte.agent-eval-case.v1',case_id:'no-leak',
+    task:'Return a safe plan.',allowed_context:{files:['a.mjs']},hidden_oracle:{secret:oracleToken,expected:'bounded'},
+    acceptance:['No oracle leakage']},
+    generator:async input=>{generatorInput=input;return {artifact:{plan:['inspect','verify']},trace:{private_reasoning:'not shared'}};},
+    judge:async input=>{judgeInput=input;return {verdict:'pass',findings:[],evidence_refs:[H('1')]};}
+  });
+  assert.equal(JSON.stringify(generatorInput).includes(oracleToken),false);
+  assert.equal(Object.hasOwn(generatorInput,'hidden_oracle'),false);
+  assert.equal(judgeInput.hidden_oracle.secret,oracleToken);
+  assert.equal(Object.hasOwn(judgeInput,'generator_trace'),false);
+  assert.equal(result.advisory,true);
+  assert.match(result.case_sha256,/^[0-9a-f]{64}$/);
+  assert.match(result.candidate_sha256,/^[0-9a-f]{64}$/);
+});
+
+test('R42 fresh critic context contains artifacts and evidence but no implementer assumptions',()=>{
+  const context=buildFreshCriticContext({case_id:'fresh-review',artifact:{files:['x.mjs']},evidence:[{id:H('2'),level:'automated'}],
+    criteria:['No authority widening']});
+  assert.deepEqual(Object.keys(context).sort(),['artifact','case_id','criteria','evidence','schema']);
+  assert.equal(JSON.stringify(context).includes('reasoning'),false);
+  assert.throws(()=>buildFreshCriticContext({case_id:'bad',artifact:{},evidence:[],criteria:[],implementer_reasoning:'trust me'}),/unknown field/i);
+});
+
+test('R42 judge remains advisory and controller triage owns repair decision',()=>{
+  const judge={schema:'deadbyte.agent-eval-judge-result.v1',verdict:'fail',advisory:true,
+    findings:[{code:'AUTH_WIDEN',severity:'critical',evidence:'schema admits command'}],evidence_refs:[H('3')]};
+  const triage=triageJudgeResult(judge,{critical_action:'pause',noncritical_action:'repair'});
+  assert.deepEqual(triage,{action:'pause',reason_codes:['AUTH_WIDEN'],judge_advisory:true});
+  assert.throws(()=>triageJudgeResult({...judge,advisory:false},{critical_action:'pause',noncritical_action:'repair'}),/advisory/i);
+});

package/test/agent-eval-runner-r42.test.mjs

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runAgentEvalSuiteR42, readAndVerifyR42EvalEvidence } from '../src/agent-eval-runner-r42.mjs';
+
+const H=value=>String(value).repeat(64).slice(0,64);
+const suite={schema:'deadbyte.agent-eval-suite.v1',suite_id:'suite',
+  cases:[{schema:'deadbyte.agent-eval-case.v1',case_id:'case-1',task:'Safe action',
+    allowed_context:{visible:'YES'},hidden_oracle:{secret:'ORACLE_ONLY',expected:'bounded'},acceptance:['bounded']}]
+};
+
+test('R42 model eval keeps hidden oracle out of generator and binds passed evidence to manifest',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r42-eval-'));
+  const calls=[];
+  try{
+    const run=await runAgentEvalSuiteR42({suite,subjectManifestSha256:H('a'),evidenceRoot:root,
+      clock:()=>new Date('2026-09-20T02:00:00.000Z'),
+      requestModel:async call=>{
+        calls.push(call);
+        if(call.role==='generator')return {backend:'fake',model:'fake',response_id:'g1',raw_text:JSON.stringify({artifact:{plan:['inspect','verify']}})};
+        return {backend:'fake',model:'fake',response_id:'j1',raw_text:JSON.stringify({schema:'deadbyte.agent-eval-judge-result.v1',
+          verdict:'pass',advisory:true,findings:[],evidence_refs:[H('1')]})};
+      }});
+    assert.equal(calls.length,2);
+    assert.equal(calls[0].prompt.includes('ORACLE_ONLY'),false);
+    assert.equal(calls[1].prompt.includes('ORACLE_ONLY'),true);
+    assert.equal(run.payload.status,'passed');
+    assert.equal(run.payload.subject_manifest_sha256,H('a'));
+    assert.equal(run.publication.status,'created');
+    const verified=await readAndVerifyR42EvalEvidence(run.publication.path,{subjectManifestSha256:H('a'),suiteSha256:run.payload.suite_sha256});
+    assert.equal(verified.status,'passed');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R42 model eval rejects failed judge and publishes no PASS evidence',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r42-eval-fail-'));
+  try{
+    await assert.rejects(runAgentEvalSuiteR42({suite,subjectManifestSha256:H('b'),evidenceRoot:root,
+      requestModel:async call=>call.role==='generator'
+        ?{raw_text:JSON.stringify({artifact:{plan:['unsafe']}})}
+        :{raw_text:JSON.stringify({schema:'deadbyte.agent-eval-judge-result.v1',verdict:'fail',advisory:true,
+          findings:[{code:'AUTH',severity:'critical',evidence:'authority widening'}],evidence_refs:[H('2')]})}}),/suite failed/i);
+    await assert.rejects(readFile(path.join(root,'agent_eval',`r42-${H('b').slice(0,16)}-`),'utf8'));
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R42 eval evidence tampering fails independent verification',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r42-eval-tamper-'));
+  try{
+    const run=await runAgentEvalSuiteR42({suite,subjectManifestSha256:H('c'),evidenceRoot:root,
+      requestModel:async call=>call.role==='generator'
+        ?{raw_text:JSON.stringify({artifact:{plan:['safe']}})}
+        :{raw_text:JSON.stringify({schema:'deadbyte.agent-eval-judge-result.v1',verdict:'pass',advisory:true,findings:[],evidence_refs:[H('3')]})}});
+    const raw=JSON.parse(await readFile(run.publication.path,'utf8'));
+    raw.payload.cases[0].result.verdict='fail';
+    await writeFile(run.publication.path,JSON.stringify(raw));
+    await assert.rejects(readAndVerifyR42EvalEvidence(run.publication.path,{subjectManifestSha256:H('c')}),/hash mismatch/i);
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/agent-governance-r42.test.mjs

@@ -0,0 +1,77 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  bindApprovalSubject, validateBoundApproval, createTaskDag, invalidateTaskDag,
+  createEvidenceClaim, evidenceSatisfies, deriveEffectiveRigor, taskDagFromPlan,
+  createDecisionRecord, evaluateDecisionFreshness
+} from '../src/agent-governance-r42.mjs';
+
+const H=value=>String(value).repeat(64).slice(0,64);
+
+test('R42 approval binds exact artifact, event head, scope and expiry',()=>{
+  const subject=bindApprovalSubject({goal_id:H('1'),reviewed_event_seq:9,reviewed_event_sha256:H('2'),
+    journal_head_sha256:H('3'),scope:'resume_goal',subject:{diff_id:H('4'),operation_count:2}});
+  const approval={schema:'deadbyte.bound-approval.v1',approval_subject_sha256:subject.approval_subject_sha256,
+    reviewed_event_seq:9,reviewed_event_sha256:H('2'),journal_head_sha256:H('3'),scope:'resume_goal',
+    issued_at_utc:'2026-09-20T01:00:00.000Z',expires_at_utc:'2026-09-20T01:05:00.000Z',provenance:'operator_mcp'};
+  assert.equal(validateBoundApproval({approval,subject,now:new Date('2026-09-20T01:01:00Z')}),true);
+  assert.throws(()=>validateBoundApproval({approval:{...approval,journal_head_sha256:H('9')},subject,
+    now:new Date('2026-09-20T01:01:00Z')}),/journal|subject/i);
+  assert.throws(()=>validateBoundApproval({approval,subject:{...subject,subject:{diff_id:H('5'),operation_count:2}},
+    now:new Date('2026-09-20T01:01:00Z')}),/subject/i);
+  assert.throws(()=>validateBoundApproval({approval,subject,now:new Date('2026-09-20T01:06:00Z')}),/expired/i);
+});
+
+test('R42 canonical DAG propagates STALE only through affected descendants',()=>{
+  const dag=createTaskDag({run_id:'run-1',goal_id:H('a'),tasks:[
+    {task_id:'inspect',depends_on:[],input_artifacts:['source'],output_artifacts:['analysis']},
+    {task_id:'patch',depends_on:['inspect'],input_artifacts:['analysis'],output_artifacts:['diff']},
+    {task_id:'test',depends_on:['patch'],input_artifacts:['diff'],output_artifacts:['test-result']},
+    {task_id:'docs',depends_on:[],input_artifacts:['readme'],output_artifacts:['docs-result']}
+  ]});
+  const next=invalidateTaskDag(dag,{changed_artifact_ids:['analysis']});
+  assert.deepEqual(next.tasks.filter(task=>task.state==='STALE').map(task=>task.task_id),['patch','test']);
+  assert.equal(next.tasks.find(task=>task.task_id==='inspect').state,'PENDING');
+  assert.equal(next.tasks.find(task=>task.task_id==='docs').state,'PENDING');
+  assert.throws(()=>createTaskDag({run_id:'x',goal_id:H('a'),tasks:[
+    {task_id:'a',depends_on:['b'],input_artifacts:[],output_artifacts:[]},
+    {task_id:'b',depends_on:['a'],input_artifacts:[],output_artifacts:[]}
+  ]}),/cycle/i);
+});
+
+test('R42 one canonical DAG is deterministically derived from the authoritative plan',()=>{
+  const plan={steps:[{step_id:'inspect',status:'completed'},{step_id:'patch',status:'active'},{step_id:'verify',status:'pending'}]};
+  const one=taskDagFromPlan({run_id:H('7'),goal_id:H('7'),plan});
+  const two=taskDagFromPlan({run_id:H('7'),goal_id:H('7'),plan});
+  assert.equal(one.dag_sha256,two.dag_sha256);
+  assert.deepEqual(one.tasks.map(task=>[task.task_id,task.depends_on,task.state]),[
+    ['inspect',[],'COMPLETE'],['patch',['inspect'],'RUNNING'],['verify',['patch'],'PENDING']
+  ]);
+});
+
+test('R42 evidence ladder never lets weak evidence masquerade as runtime proof',()=>{
+  const source=createEvidenceClaim({claim_id:'claim-1',statement:'provider shape matches source',level:'source',refs:[H('b')]});
+  assert.equal(evidenceSatisfies(source,'source'),true);
+  assert.equal(evidenceSatisfies(source,'automated'),false);
+  assert.equal(evidenceSatisfies(source,'runtime'),false);
+  assert.throws(()=>createEvidenceClaim({claim_id:'claim-2',statement:'bad',level:'runtime',refs:[]}),/reference/i);
+});
+
+test('R42 rigor is derived once and cannot downgrade below risk minimum',()=>{
+  assert.deepEqual(deriveEffectiveRigor({project_default:'lightweight',risk_level:'high',explicit_override:'structured'}),{
+    project_default:'lightweight',risk_minimum:'agentic',explicit_override:'structured',effective_rigor:'agentic'
+  });
+  assert.equal(deriveEffectiveRigor({project_default:'structured',risk_level:'low',explicit_override:'agentic'}).effective_rigor,'agentic');
+});
+
+test('R42 decisions become stale deterministically without deleting history',()=>{
+  const record=createDecisionRecord({decision_id:'provider-choice',decision:'Use Responses adapter',reason:'strict bounded JSON',
+    evidence_refs:[H('c')],invalidates_if:[
+      {kind:'artifact_sha_changed',artifact_id:'provider-contract',expected_sha256:H('d')},
+      {kind:'policy_sha_changed',expected_sha256:H('e')}
+    ]});
+  assert.equal(evaluateDecisionFreshness(record,{artifact_sha256:{'provider-contract':H('d')},policy_sha256:H('e')}).state,'CURRENT');
+  const stale=evaluateDecisionFreshness(record,{artifact_sha256:{'provider-contract':H('f')},policy_sha256:H('e')});
+  assert.equal(stale.state,'STALE');
+  assert.deepEqual(stale.invalidated_by,[{kind:'artifact_sha_changed',artifact_id:'provider-contract',expected_sha256:H('d'),observed_sha256:H('f')}]);
+});

package/test/autonomous-r34-e2e.test.mjs

@@ -75,7 +75,8 @@ test('R34 missing authority waits durably and approval resumes the same phase af
     assert.equal(journal.events.filter(event=>event.type==='action_started').length,0);
 
     await f.arm();
-    const approved = await f.runtime.approve({goalId:goal.goal_id,decision:'approve'});
+    const approved = await f.runtime.approve({goalId:goal.goal_id,decision:'approve',
+      approvalSubjectSha256:result.loop.approval_subject.approval_subject_sha256});
     assert.equal(approved.status,'approved');
     assert.equal(approved.loop.phase,'ACTING');
     const resumed = await f.runtime.run({goalId:goal.goal_id,maxCycles:2});

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.13.0');
+    assert.equal(result.stdout.trim(),'0.14.0');
   }
 });
 

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.13.0');
+  assert.equal(result.receipt.runtime.package_version, '0.14.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}$/);

package/test/evidence-publisher-r42.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  publishEvidenceAtomic, createExecutionReceipt, createVerificationResult
+} from '../src/evidence-publisher-r42.mjs';
+
+const H=value=>String(value).repeat(64).slice(0,64);
+
+test('R42 evidence publication is atomic, no-clobber and idempotent for identical bytes',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r42-evidence-'));
+  try{
+    const one=await publishEvidenceAtomic({root,kind:'eval',evidenceId:'case-1',payload:{status:'passed',score:1}});
+    assert.equal(one.status,'created');
+    const two=await publishEvidenceAtomic({root,kind:'eval',evidenceId:'case-1',payload:{status:'passed',score:1}});
+    assert.equal(two.status,'existing');
+    assert.equal(two.evidence_sha256,one.evidence_sha256);
+    const bytes=await readFile(one.path);
+    assert.equal(H('0')===one.evidence_sha256,false);
+    assert.match(bytes.toString('utf8'),/"payload_sha256":"[0-9a-f]{64}"/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R42 conflicting concurrent evidence identity fails closed without overwrite',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r42-evidence-race-'));
+  try{
+    const settled=await Promise.allSettled([
+      publishEvidenceAtomic({root,kind:'closure',evidenceId:'release-final',payload:{candidate:'a'}}),
+      publishEvidenceAtomic({root,kind:'closure',evidenceId:'release-final',payload:{candidate:'b'}})
+    ]);
+    assert.equal(settled.filter(item=>item.status==='fulfilled').length,1);
+    assert.equal(settled.filter(item=>item.status==='rejected').length,1);
+    assert.match(String(settled.find(item=>item.status==='rejected').reason),/EVIDENCE_ID_CONFLICT/);
+    const winner=settled.find(item=>item.status==='fulfilled').value;
+    const parsed=JSON.parse(await readFile(winner.path,'utf8'));
+    assert.ok(['a','b'].includes(parsed.payload.candidate));
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('R42 execution receipt and outcome verification are distinct typed artifacts',()=>{
+  const receipt=createExecutionReceipt({execution_id:'exec-1',subject_sha256:H('1'),request_sha256:H('2'),
+    observed_exit_code:0,started_at_utc:'2026-09-20T01:00:00.000Z',completed_at_utc:'2026-09-20T01:00:01.000Z'});
+  assert.equal(receipt.schema,'deadbyte.execution-receipt.v1');
+  assert.equal(Object.hasOwn(receipt,'outcome_passed'),false);
+  const verified=createVerificationResult({verification_id:'verify-1',subject_sha256:H('1'),
+    execution_receipt_sha256:receipt.receipt_sha256,outcome_passed:true,oracle:'runtime_behavior',evidence_refs:[H('3')]});
+  assert.equal(verified.schema,'deadbyte.verification-result.v1');
+  assert.equal(verified.outcome_passed,true);
+  assert.throws(()=>createExecutionReceipt({execution_id:'exec-2',subject_sha256:H('1'),request_sha256:H('2'),
+    observed_exit_code:0,started_at_utc:'2026-09-20T01:00:00.000Z',completed_at_utc:'2026-09-20T01:00:01.000Z',outcome_passed:true}),/unknown field/i);
+});

package/test/human-clarification-r42.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createR34Fixture, planCreateDecision, sendPlannerDecision } from './helpers/autonomous-r34-fixture.mjs';
+
+async function startPlannedGoal(f) {
+  const goal=await f.runtime.submit({submissionId:'r42-clarify',rootId:'project',title:'Clarification',
+    goal:'Choose the correct bounded implementation.',acceptance:'Use the operator choice.',maxIterations:8});
+  let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+  result=await sendPlannerDecision(f.runtime,goal.goal_id,result,planCreateDecision(),{maxCycles:2});
+  return {goal,result};
+}
+
+test('R42 planner can request typed human clarification and resume with signed answer context',async()=>{
+  const f=await createR34Fixture();
+  try {
+    const {goal,result:first}=await startPlannedGoal(f);
+    const clarify={schema:'deadbyte.autonomous-decision.v2',kind:'clarify',
+      question:'Which compatibility target should be authoritative?',
+      choices:['Preserve R41 behavior','Adopt R42 behavior']};
+    const paused=await sendPlannerDecision(f.runtime,goal.goal_id,first,clarify,{maxCycles:2});
+    assert.equal(paused.status,'paused');
+    assert.equal(paused.reason,'human_input_required');
+    assert.deepEqual(paused.loop.clarification,{question:clarify.question,choices:clarify.choices});
+    const subject=paused.loop.approval_subject.approval_subject_sha256;
+    await assert.rejects(f.runtime.approve({goalId:goal.goal_id,decision:'approve',answer:'Preserve R41 behavior',
+      approvalSubjectSha256:'f'.repeat(64)}),/approval subject mismatch/i);
+    await assert.rejects(f.runtime.approve({goalId:goal.goal_id,decision:'approve',approvalSubjectSha256:subject}),/answer.*required/i);
+    const approved=await f.runtime.approve({goalId:goal.goal_id,decision:'approve',answer:'Preserve R41 behavior',
+      approvalSubjectSha256:subject});
+    assert.equal(approved.status,'approved');
+    const next=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    assert.equal(next.status,'input_required');
+    assert.match(next.planner_request.prompt,/Preserve R41 behavior/);
+    const events=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const provided=events.events.find(event=>event.type==='human_input_provided');
+    assert.equal(provided.payload.answer,'Preserve R41 behavior');
+    assert.match(provided.payload.answer_sha256,/^[0-9a-f]{64}$/);
+    const approval=events.events.find(event=>event.type==='approval_granted');
+    assert.equal(approval.payload.approval_subject_sha256,subject);
+    assert.equal(approval.payload.scope,'human_clarification');
+  } finally { await f.cleanup(); }
+});
+
+test('R42 clarification contract rejects injected fields and oversized choices',async()=>{
+  const f=await createR34Fixture();
+  try {
+    const {goal,result:first}=await startPlannedGoal(f);
+    const injected={schema:'deadbyte.autonomous-decision.v2',kind:'clarify',question:'Choose?',choices:[],command:'cmd.exe'};
+    const repaired=await sendPlannerDecision(f.runtime,goal.goal_id,first,injected,{maxCycles:2});
+    assert.equal(repaired.status,'input_required');
+    assert.match(repaired.planner_request.prompt,/PREVIOUS_RESPONSE_REJECTED/);
+  } finally { await f.cleanup(); }
+});

package/test/provider-responses-r42.test.mjs

@@ -0,0 +1,90 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
+import { requestProviderDecision } from '../src/autonomous-planner.mjs';
+import { providerCircuitId } from '../src/provider-circuit.mjs';
+
+const H = value => String(value).repeat(64).slice(0,64);
+
+async function policyFixture(planner) {
+  const root = await mkdtemp(path.join(os.tmpdir(),'deadbyte-r42-provider-'));
+  const project = path.join(root,'project');
+  await mkdir(project);
+  const codingPolicy = {
+    policy_sha256:H('c'), roots:{project:{path:project}}, commands:{}
+  };
+  const policyPath = path.join(root,'autonomous-policy.json');
+  await writeFile(policyPath,JSON.stringify({
+    schema:'deadbyte.autonomous-policy.v1', enabled:true,
+    lease_file:path.join(root,'grant.json'), evidence_dir:path.join(root,'evidence'),
+    coding_policy_sha256:codingPolicy.policy_sha256, root_ids:['project'], planner,
+    profiles:{}, limits:{max_wall_ms:null}
+  }));
+  const policy = await loadAutonomousPolicy(policyPath,codingPolicy);
+  return {root,policy,cleanup:()=>rm(root,{recursive:true,force:true})};
+}
+
+test('R42 policy accepts bounded OpenAI Responses planner configuration',async()=>{
+  const f=await policyFixture({
+    backend:'openai_responses', endpoint:'https://api.openai.com/v1/responses',
+    model:'gpt-5', api_key_env:'OPENAI_API_KEY', max_tokens:4096,
+    reasoning_effort:'medium', timeout_ms:45000, max_response_bytes:131072,
+    circuit:{failure_threshold:2,open_ms:1000,half_open_probe_limit:1}
+  });
+  try {
+    assert.equal(f.policy.planner.backend,'openai_responses');
+    assert.equal(f.policy.planner.reasoning_effort,'medium');
+    assert.equal(f.policy.planner.store,false);
+    assert.match(providerCircuitId(f.policy.planner),/^openai_responses:[0-9a-f]{64}$/);
+  } finally { await f.cleanup(); }
+});
+
+test('R42 Responses adapter sends JSON mode and extracts bounded output with provenance',async()=>{
+  const old=process.env.DEADBYTE_R42_TEST_KEY;
+  process.env.DEADBYTE_R42_TEST_KEY='test-only-token';
+  const policy={planner:{
+    backend:'openai_responses', endpoint:'https://api.openai.com/v1/responses', model:'gpt-5',
+    api_key_env:'DEADBYTE_R42_TEST_KEY', max_tokens:2048, reasoning_effort:'high', store:false,
+    timeout_ms:30000, max_response_bytes:65536
+  }};
+  let captured;
+  const fetchImpl=async(url,options)=>{
+    captured={url,options,body:JSON.parse(options.body)};
+    return new Response(JSON.stringify({
+      id:'resp_test_123', status:'completed', model:'gpt-5-2026-01-01',
+      output:[{type:'message',role:'assistant',content:[{type:'output_text',text:'{"schema":"deadbyte.autonomous-decision.v2","kind":"pause","reason":"need fixture"}'}]}],
+      usage:{input_tokens:111,output_tokens:22,total_tokens:133}
+    }),{status:200,headers:{'content-type':'application/json'}});
+  };
+  try {
+    const result=await requestProviderDecision(policy,'bounded prompt',fetchImpl);
+    assert.equal(captured.url,policy.planner.endpoint);
+    assert.equal(captured.options.headers.authorization,'Bearer test-only-token');
+    assert.deepEqual(captured.body.text,{format:{type:'json_object'}});
+    assert.equal(captured.body.store,false);
+    assert.equal(captured.body.max_output_tokens,2048);
+    assert.deepEqual(captured.body.reasoning,{effort:'high'});
+    assert.equal(captured.body.input[0].role,'system');
+    assert.equal(captured.body.input[1].role,'user');
+    assert.equal(result.backend,'openai_responses');
+    assert.equal(result.response_id,'resp_test_123');
+    assert.deepEqual(result.usage,{input_tokens:111,output_tokens:22,total_tokens:133});
+    assert.match(result.raw_text,/deadbyte\.autonomous-decision\.v2/);
+  } finally {
+    if(old===undefined) delete process.env.DEADBYTE_R42_TEST_KEY; else process.env.DEADBYTE_R42_TEST_KEY=old;
+  }
+});
+
+test('R42 Responses adapter fails closed on refusal and incomplete response',async()=>{
+  const policy={planner:{backend:'openai_responses',endpoint:'https://api.openai.com/v1/responses',model:'gpt-5',
+    api_key_env:null,max_tokens:2048,reasoning_effort:null,store:false,timeout_ms:30000,max_response_bytes:65536}};
+  const refusal=async()=>new Response(JSON.stringify({id:'resp_refuse',status:'completed',model:'gpt-5',
+    output:[{type:'message',content:[{type:'refusal',refusal:'cannot comply'}]}]}),{status:200});
+  await assert.rejects(requestProviderDecision(policy,'x',refusal),/refusal|output_text/i);
+  const incomplete=async()=>new Response(JSON.stringify({id:'resp_incomplete',status:'incomplete',model:'gpt-5',output:[],
+    incomplete_details:{reason:'max_output_tokens'}}),{status:200});
+  await assert.rejects(requestProviderDecision(policy,'x',incomplete),/not completed|incomplete/i);
+});

package/test/r33-closeout-regression.test.mjs

@@ -86,25 +86,40 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows current R41 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
-  const stateRoot=await temp('deadbyte-r33-windows-evidence-');
+test('Windows current R42 gate emits manifest-bound model-eval evidence outside the candidate tree', async()=>{
+  const stateRoot=await temp('deadbyte-r42-windows-evidence-');
   try{
-    const gate=await readFile(path.join(root,'scripts','gate-windows-r41.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence-r41\.mjs/,'gate-windows-r41.ps1 must invoke the evidence writer');
-    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence-r41.mjs')],{
-      cwd:root,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+    const gate=await readFile(path.join(root,'scripts','gate-windows-r42.ps1'),'utf8');
+    assert.match(gate,/windows-gate-evidence-r42\.mjs/,'gate-windows-r42.ps1 must invoke the evidence writer');
+    assert.match(gate,/r42-model-backed-eval/,'R42 gate must require model-backed eval before evidence writer');
+
+    const suite=JSON.parse(await readFile(path.join(root,'harness','r42-agent-evals.json'),'utf8'));
+    const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+    const { runAgentEvalSuiteR42 }=await import('../src/agent-eval-runner-r42.mjs');
+    const { writeWindowsGateEvidence }=await import('../scripts/windows-gate-evidence-r42.mjs');
+    const evaluation=await runAgentEvalSuiteR42({
+      suite,subjectManifestSha256:manifestSha,
+      evidenceRoot:path.join(stateRoot,'evidence','release','r42-agent-evals'),
+      clock:()=>new Date('2026-09-20T02:00:00.000Z'),
+      requestModel:async call=>call.role==='generator'
+        ?{backend:'fixture',model:'fixture',response_id:`g-${call.case_id}`,raw_text:JSON.stringify({artifact:{plan:['inspect','verify','fail_closed']}})}
+        :{backend:'fixture',model:'fixture',response_id:`j-${call.case_id}`,raw_text:JSON.stringify({
+          schema:'deadbyte.agent-eval-judge-result.v1',verdict:'pass',advisory:true,findings:[],evidence_refs:['1'.repeat(64)]
+        })}
     });
-    assert.equal(result.code,0,result.stderr||result.stdout);
-    const summary=JSON.parse(result.stdout.trim());
+    assert.equal(evaluation.payload.status,'passed');
+
+    const summary=await writeWindowsGateEvidence({candidateRoot:root,stateRoot,clock:()=>new Date('2026-09-20T02:01:00.000Z')});
     assert.equal(summary.status,'written');
     const evidence=JSON.parse(await readFile(summary.path,'utf8'));
-    const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r41-windows-gate.v1');
+    assert.equal(evidence.schema,'deadbyte.r42-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
-    assert.equal(evidence.version,'0.13.0');
+    assert.equal(evidence.version,'0.14.0');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.13.0 / R41 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.14.0 / R42 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.model_eval.evidence_sha256,evaluation.publication.evidence_sha256);
+    assert.equal(evidence.model_eval.case_count,suite.cases.length);
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -19,9 +19,9 @@ test('R34 public parity catalog is exact, unique, and includes production coding
 
 test('release parity and final verifier are package entry points', async () => {
   const pkg = JSON.parse(await text('package.json'));
-  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r41.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r41.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r41.mjs');
+  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r42.mjs');
+  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r42.mjs');
+  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r42.mjs');
   assert.equal(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });

package/test/r42-finalization.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { validateParityEvidence,R42_PREDECESSOR_RELEASE_ID,R42_PREDECESSOR_MANIFEST } from '../scripts/release-parity-r42.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r42.mjs';
+
+const root=new URL('../',import.meta.url);const text=rel=>readFile(new URL(rel,root),'utf8');
+function parity(){const manifest='a'.repeat(64);return {schema:'deadbyte.r42-parity.v1',status:'passed',execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+  candidate:{release_id:`v0.14.0-${manifest.slice(0,16)}`,version:'0.14.0',manifest_sha256:manifest},
+  immutable_slot:{protected:true,release_root:'C:/immutable/r42',development_root:'D:/Projects/deadbyte-mcp/development/deadbyte-mcp-r42-agentic-dev'},
+  local_full:{status:'passed',tool_count:80,strict_output_schemas:true},
+  public_compact:{status:'passed',tool_count:42,capability_closure:true,gateway_count:6,desktop_armed:false,desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true},
+  autonomous:{status:'passed',signed_release_verified:true},desktop_guarded:{status:'passed',native_injected:true,replay_performed:false,predispatch_retry_count:0,observation_receipts_verified:1,action_receipts_verified:3},
+  deterministic_memory:{status:'passed',goal_count:1,snapshot_count:1,index_count:1},model_eval:{status:'passed',path:'C:/evidence/eval.json',evidence_sha256:'e'.repeat(64),payload_sha256:'f'.repeat(64),suite_sha256:'d'.repeat(64),case_count:3},
+  before_rollback_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},rollback:{state:'completed'},restore:{state:'completed'},stage_restore:{status:'restored',manifest_sha256:manifest},
+  predecessor:{release_id:R42_PREDECESSOR_RELEASE_ID,version:'0.13.0',manifest_sha256:R42_PREDECESSOR_MANIFEST},predecessor_disarmed:{status:'passed',tool_count:42,capability_closure:true},
+  successor:{release_id:`v0.14.0-${manifest.slice(0,16)}`,version:'0.14.0',manifest_sha256:manifest},successor_disarmed:{status:'passed',capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false},
+  requirements:Object.fromEntries(['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input','deterministic_memory','model_eval'].map(key=>[key,true]))};}
+
+test('R42 parity requires exact R41 predecessor and immutable R42 slot',()=>{const value=parity();assert.equal(validateParityEvidence(value),true);
+  assert.throws(()=>validateParityEvidence({...value,predecessor:{...value.predecessor,manifest_sha256:'b'.repeat(64)}}),/predecessor/i);
+  assert.throws(()=>validateParityEvidence({...value,immutable_slot:{...value.immutable_slot,development_root:value.immutable_slot.release_root}}),/immutable-slot/i);});
+
+test('R42 release machinery binds 0.14.0, R41 predecessor, memory gates and R42 domains',async()=>{const [gate,deferred,paritySource,writer,verifier,evidence,suite]=await Promise.all([
+  text('scripts/gate-windows-r42.ps1'),text('scripts/deferred-slot-operation-r42.mjs'),text('scripts/release-parity-r42.mjs'),text('scripts/final-closure-r42.mjs'),text('scripts/final-closure-verify-r42.mjs'),text('scripts/windows-gate-evidence-r42.mjs'),text('scripts/release-parity-tests-r42.ps1')]);
+  assert.equal(R42_PREDECESSOR_RELEASE_ID,'v0.13.0-3255be10de4daf08');assert.equal(R42_PREDECESSOR_MANIFEST,'3255be10de4daf0837d67d1ab1913b785b8b8215bc7405823c2ff46968c4b98f');
+  assert.match(gate,/r42-parent-verify/);assert.match(gate,/r42-model-backed-eval/);assert.match(gate,/memory-history-r41\.test\.mjs/);assert.match(gate,/DEADBYTE V0\.14\.0 \/ R42 WINDOWS BATCH GATE: PASS/);
+  assert.match(deferred,/--expected-version','0\.14\.0'/);assert.match(paritySource,/deadbyte\.r42-parity\.v1/);
+  for(const source of [writer,verifier]){assert.match(source,/DEADBYTE-R42-FINAL-CLOSURE-V1/);assert.match(source,/deadbyte\.r42-final-closure\.v1/);assert.match(source,/R42 AGENTIC GOVERNANCE BASELINE/);}
+  assert.equal(typeof verifyFinalClosureObject,'function');assert.match(evidence,/deadbyte\.r42-windows-gate\.v1/);assert.match(suite,/memory-autonomous-integration-r41\.test\.mjs/);
+});
+
+
+test('R42 preserves release-namespaced deterministic memory storage',async()=>{
+  const [server,paritySource]=await Promise.all([text('src/mcp-server.mjs'),text('scripts/release-parity-r42.mjs')]);
+  assert.match(server,/memoryRoot:path\.join\(autonomousPolicy\.evidence_dir,'memory-r41',packageManifestSha256\)/);
+  assert.match(paritySource,/memoryRoot:path\.join\(stateRoot,'evidence','autonomous','memory-r41',candidateManifest\)/);
+});

package/test/release-version.test.mjs

@@ -3,22 +3,22 @@ import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 const root=new URL('../',import.meta.url);const text=rel=>readFile(new URL(rel,root),'utf8');
-const R41_PREDECESSOR_RELEASE_ID='v0.12.0-70906ae0a7e4f062';
-const R41_PREDECESSOR_MANIFEST='70906ae0a7e4f0627efbb5087b40b85677c81ed6d64ed89c0ba2af846e390f39';
-test('R41 authority agrees on V0.13.0 and preserves exact sealed public R40 predecessor',async()=>{
+const R42_PREDECESSOR_RELEASE_ID='v0.13.0-3255be10de4daf08';
+const R42_PREDECESSOR_MANIFEST='3255be10de4daf0837d67d1ab1913b785b8b8215bc7405823c2ff46968c4b98f';
+test('R42 authority agrees on V0.14.0 and preserves exact sealed public R41 predecessor',async()=>{
  const pkg=JSON.parse(await text('package.json'));
  const [version,controller,gate,readme,architecture,controllerReadme,deferred,parity,closure,closureVerify,windowsGate,parent,semanticConfig]=await Promise.all([
- text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r41.ps1'),text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r41.mjs'),text('scripts/release-parity-r41.mjs'),text('scripts/final-closure-r41.mjs'),text('scripts/final-closure-verify-r41.mjs'),text('scripts/windows-gate-evidence-r41.mjs'),text('R41-PARENT.json'),text('controller/deadbyte-semantic-lsp-config.json')]);
- assert.equal(pkg.version,'0.13.0');assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r41.ps1');
- assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r41.mjs');assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r41.mjs');
- assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r41.mjs');assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r41.mjs');
+ text('src/version.mjs'),text('controller/deadbyte-controller.ps1'),text('scripts/gate-windows-r42.ps1'),text('README.txt'),text('docs/ARCHITECTURE.md'),text('controller/README.TXT'),text('scripts/deferred-slot-operation-r42.mjs'),text('scripts/release-parity-r42.mjs'),text('scripts/final-closure-r42.mjs'),text('scripts/final-closure-verify-r42.mjs'),text('scripts/windows-gate-evidence-r42.mjs'),text('R42-PARENT.json'),text('controller/deadbyte-semantic-lsp-config.json')]);
+ assert.equal(pkg.version,'0.14.0');assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r42.ps1');
+ assert.equal(pkg.scripts['self-update:deferred'],'node scripts/deferred-slot-operation-r42.mjs');assert.equal(pkg.scripts['release:parity'],'node scripts/release-parity-r42.mjs');
+ assert.equal(pkg.scripts['release:final:write'],'node scripts/final-closure-r42.mjs');assert.equal(pkg.scripts['release:final:verify'],'node scripts/final-closure-verify-r42.mjs');
  assert.equal(pkg.scripts['desktop:policy:refresh'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/init-desktop-policy-r40.ps1');
- assert.match(version,/DEADBYTE_VERSION = '0\.13\.0'/);assert.match(controller,/CONTROLLER V0\.13\.0 \/ R41/);assert.match(gate,/DEADBYTE V0\.13\.0 \/ R41 WINDOWS BATCH GATE: PASS/);
- assert.match(readme,/^DEADBYTE MCP V0\.13\.0 \/ R41 DETERMINISTIC MEMORY BASELINE$/m);assert.match(architecture,/^# DEADBYTE MCP V0\.13\.0 \/ R41 ARCHITECTURE$/m);assert.match(controllerReadme,/^DEADBYTE MCP V0\.13\.0 \/ R41 CONTROLLER$/m);
- assert.match(deferred,/--expected-version','0\.13\.0'/);assert.match(deferred,/--enable-desktop/);assert.match(parity,/R41_PREDECESSOR_RELEASE_ID='v0\.12\.0-70906ae0a7e4f062'/);assert.match(parity,new RegExp(R41_PREDECESSOR_MANIFEST));
- assert.match(parity,/version==='0\.13\.0'|version:'0\.13\.0'/);assert.match(closure,/version:'0\.13\.0'/);assert.match(closureVerify,/DEADBYTE V0\.13\.0 \/ R41 WINDOWS BATCH GATE: PASS/);assert.match(windowsGate,/version:'0\.13\.0'/);
- assert.equal(JSON.parse(parent).parent_manifest_sha256,R41_PREDECESSOR_MANIFEST);
- assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');assert.equal(R41_PREDECESSOR_RELEASE_ID,'v0.12.0-70906ae0a7e4f062');
+ assert.match(version,/DEADBYTE_VERSION = '0\.14\.0'/);assert.match(controller,/CONTROLLER V0\.14\.0 \/ R42/);assert.match(gate,/DEADBYTE V0\.14\.0 \/ R42 WINDOWS BATCH GATE: PASS/);
+ assert.match(readme,/^DEADBYTE MCP V0\.14\.0 \/ R42 AGENTIC GOVERNANCE BASELINE$/m);assert.match(architecture,/^# DEADBYTE MCP V0\.14\.0 \/ R42 ARCHITECTURE$/m);assert.match(controllerReadme,/^DEADBYTE MCP V0\.14\.0 \/ R42 CONTROLLER$/m);
+ assert.match(deferred,/--expected-version','0\.14\.0'/);assert.match(deferred,/--enable-desktop/);assert.match(parity,/R42_PREDECESSOR_RELEASE_ID='v0\.13\.0-3255be10de4daf08'/);assert.match(parity,new RegExp(R42_PREDECESSOR_MANIFEST));
+ assert.match(parity,/version==='0\.14\.0'|version:'0\.14\.0'/);assert.match(closure,/version:'0\.14\.0'/);assert.match(closureVerify,/DEADBYTE V0\.14\.0 \/ R42 WINDOWS BATCH GATE: PASS/);assert.match(windowsGate,/version:'0\.14\.0'/);
+ assert.equal(JSON.parse(parent).parent_manifest_sha256,R42_PREDECESSOR_MANIFEST);
+ assert.equal(createHash('sha256').update(Buffer.from(semanticConfig,'utf8')).digest('hex'),'d274b099a298c1033fea8f1e8849751693bbc0448778d619400acb82d4f53a3b');assert.equal(R42_PREDECESSOR_RELEASE_ID,'v0.13.0-3255be10de4daf08');
 });
 test('R40 keeps ONLINE reuse and PowerShell Host collision fix while Desktop stays explicit',async()=>{const [cli,controller]=await Promise.all([text('src/deadbyte-cli.mjs'),text('controller/deadbyte-controller.ps1')]);assert.match(cli,/controllerRuntimeReady/);assert.match(cli,/Runtime already ONLINE; reusing verified bridge\/cloud\/supervisor/);const start=controller.indexOf('function Recover-AutonomousSupervisor'),end=controller.indexOf('function Show-State',start);assert.ok(start>=0&&end>start);const block=controller.slice(start,end);assert.doesNotMatch(block,/\$host\s*=/i);assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus/);assert.match(controller,/armdesktop/);assert.match(controller,/disarmdesktop/);});
 test('sealed R39 tooling remains historical 0.11.3 authority with exact 0.11.2 predecessor',async()=>{const [parity,gate,closure]=await Promise.all([text('scripts/release-parity-r39.mjs'),text('scripts/gate-windows-r39.ps1'),text('scripts/final-closure-r39.mjs')]);assert.match(parity,/R39_PREDECESSOR_RELEASE_ID='v0\.11\.2-058605dfccaa3035'/);assert.match(parity,/version==='0\.11\.3'|version:'0\.11\.3'/);assert.match(gate,/DEADBYTE V0\.11\.3 \/ R39 WINDOWS BATCH GATE: PASS/);assert.match(closure,/version:'0\.11\.3'/);});

package/test/task-contract-r42.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const contract={
+  schema:'deadbyte.task-contract.v1',
+  scope:['src/autonomous-*','test/*r42*'],
+  non_goals:['No generic shell','No implicit grant renewal'],
+  constraints:['Preserve R41 compatibility','Use exact preconditions'],
+  evidence_requirements:['Focused tests pass','Signed journal verifies'],
+  risk_level:'high',
+  clarification_policy:'ask_when_blocked',
+  project_default:'lightweight',
+  explicit_override:'structured'
+};
+
+test('R42 task contract is identity-bound and visible to every planner round',async()=>{
+  const f=await createR34Fixture();
+  try {
+    const goal=await f.runtime.submit({submissionId:'r42-task-contract',rootId:'project',title:'Contract',
+      goal:'Implement bounded behavior.',acceptance:'All required evidence passes.',taskContract:contract,maxIterations:8});
+    const status=await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(status.state,'pending');
+    const run=await f.runtime.run({goalId:goal.goal_id,maxCycles:1});
+    assert.equal(run.status,'input_required');
+    assert.match(run.planner_request.prompt,/deadbyte\.task-contract\.v1/);
+    assert.match(run.planner_request.prompt,/No generic shell/);
+    assert.match(run.planner_request.prompt,/Signed journal verifies/);
+    assert.match(run.planner_request.prompt,/"effective_rigor":"agentic"/);
+  } finally { await f.cleanup(); }
+});
+
+test('R42 task contract rejects authority widening fields and invalid risk',async()=>{
+  const f=await createR34Fixture();
+  try {
+    await assert.rejects(f.runtime.submit({submissionId:'r42-task-injected',rootId:'project',title:'Contract',
+      goal:'Reject injection.',acceptance:'Fail closed.',taskContract:{...contract,shell:'cmd.exe'}}),/unknown field|task contract/i);
+    await assert.rejects(f.runtime.submit({submissionId:'r42-task-risk',rootId:'project',title:'Contract',
+      goal:'Reject risk.',acceptance:'Fail closed.',taskContract:{...contract,risk_level:'unbounded'}}),/risk_level/i);
+  } finally { await f.cleanup(); }
+});