deadbyte-mcp 0.13.0 → 0.14.0

package/src/autonomous-mcp-tools.mjs

@@ -25,6 +25,17 @@ const rmdirOperation = z.strictObject({ kind:z.literal('rmdir'), path:relPath, e
 const nativeOperation = z.union([writeOperation,replaceOperation,deleteOperation,mkdirOperation,moveOperation,rmdirOperation]);
 const plannerResponse = z.strictObject({ request_id:hex64, raw_text:z.string().min(2).max(8*1024*1024),
   model:z.string().min(1).max(128).default('client-model') });
+const taskContract = z.strictObject({
+  schema:z.literal('deadbyte.task-contract.v1'),
+  scope:z.array(z.string().min(1).max(512)).max(32).default([]),
+  non_goals:z.array(z.string().min(1).max(512)).max(24).default([]),
+  constraints:z.array(z.string().min(1).max(512)).max(32).default([]),
+  evidence_requirements:z.array(z.string().min(1).max(512)).max(32).default([]),
+  risk_level:z.enum(['low','medium','high']).default('medium'),
+  clarification_policy:z.enum(['ask_when_blocked','fail_closed']).default('ask_when_blocked'),
+  project_default:z.enum(['lightweight','structured','agentic']).default('structured'),
+  explicit_override:z.enum(['lightweight','structured','agentic']).nullable().default(null)
+});
 function result(schema,value,isError=false) { return autonomousStructuredResult(schema,value,isError); }
 function fail(schema,error,status='failed') { return result(schema,{ status, error:String(error) },true); }
 
@@ -60,11 +71,12 @@ export function registerAutonomousTools(server,{ autonomousRuntime, nativeDiffRu
     description:'Submit one bounded R24 production goal. Execution requires separate live coding and autonomous leases.',
     inputSchema:z.strictObject({ submission_id:id, root_id:id, title:z.string().max(160).default(''),
       goal:z.string().min(1).max(8192), acceptance:z.string().max(4096).default(''),
+      task_contract:taskContract.nullable().default(null),
       max_iterations:z.number().int().min(1).max(64).nullable().default(null) }),
     outputSchema:autonomousGoalSubmitOutputSchema
-  },async({submission_id,root_id,title,goal,acceptance,max_iterations})=>{ try {
+  },async({submission_id,root_id,title,goal,acceptance,task_contract,max_iterations})=>{ try {
       return result(autonomousGoalSubmitOutputSchema,await autonomousRuntime.submit({ submissionId:submission_id,
-        rootId:root_id,title,goal,acceptance,maxIterations:max_iterations })); }
+        rootId:root_id,title,goal,acceptance,taskContract:task_contract,maxIterations:max_iterations })); }
     catch(error){ return fail(autonomousGoalSubmitOutputSchema,error); } });
   server.registerTool('autonomous_goal_run',{
     description:'Advance one autonomous production goal through inspect/native-diff/build/test/benchmark/replan cycles. Client-planner mode returns a typed input_required sentinel for the Bridge MRTR adapter.',
@@ -100,11 +112,14 @@ export function registerAutonomousTools(server,{ autonomousRuntime, nativeDiffRu
     catch(error){ return fail(autonomousGoalCancelOutputSchema,error); } });
 
   server.registerTool('autonomous_goal_approve',{
-    description:'Approve or reject resuming a paused autonomous goal. This never arms or renews any lease and cannot bypass release evidence.',
-    inputSchema:z.strictObject({ goal_id:hex64, decision:z.enum(['approve','reject']).default('approve') }),
+    description:'Approve or reject resuming a paused autonomous goal, optionally supplying the bounded answer required by a typed human clarification. This never arms or renews any lease and cannot bypass release evidence.',
+    inputSchema:z.strictObject({ goal_id:hex64, decision:z.enum(['approve','reject']).default('approve'),
+      answer:z.string().min(1).max(4096).nullable().default(null),
+      approval_subject_sha256:hex64.nullable().default(null),
+      expires_in_ms:z.number().int().min(1000).max(3600000).default(300000) }),
     outputSchema:autonomousGoalApproveOutputSchema
-  },async({goal_id,decision})=>{ try { return result(autonomousGoalApproveOutputSchema,
-      await autonomousRuntime.approve({goalId:goal_id,decision})); }
+  },async({goal_id,decision,answer,approval_subject_sha256,expires_in_ms})=>{ try { return result(autonomousGoalApproveOutputSchema,
+      await autonomousRuntime.approve({goalId:goal_id,decision,answer,approvalSubjectSha256:approval_subject_sha256,expiresInMs:expires_in_ms})); }
     catch(error){ return fail(autonomousGoalApproveOutputSchema,error); } });
 
   server.registerTool('autonomous_goal_verify',{

package/src/autonomous-output-contracts.mjs

@@ -15,12 +15,28 @@ const loopProgress = z.strictObject({
 const loopPendingAction = z.strictObject({
   action_id:hex64, request_sha256:hex64, kind:z.string().regex(/^[A-Za-z0-9._-]{1,64}$/)
 });
+const loopClarification = z.strictObject({
+  question:z.string().min(1).max(1000), choices:z.array(z.string().min(1).max(256)).max(5)
+});
+const loopApprovalSubject = z.strictObject({
+  goal_id:hex64,reviewed_event_seq:z.number().int().min(1),reviewed_event_sha256:hex64,
+  journal_head_sha256:hex64,scope:z.enum(['resume_goal','human_clarification','desktop_resume','interrupted_effect_resume']),
+  subject:z.strictObject({reason:z.string().min(1).max(1024),waiting_payload_sha256:hex64}),approval_subject_sha256:hex64
+});
+const taskDagTask=z.strictObject({task_id:z.string().regex(/^[A-Za-z0-9._-]{1,64}$/),depends_on:z.array(z.string()).max(256),
+  input_artifacts:z.array(z.string()).max(128),output_artifacts:z.array(z.string()).max(128),
+  state:z.enum(['PENDING','RUNNING','COMPLETE','FAILED','STALE'])});
+const taskDag=z.strictObject({schema:z.literal('deadbyte.task-dag.v1'),run_id:z.string().regex(/^[A-Za-z0-9._-]{1,96}$/),
+  goal_id:hex64,tasks:z.array(taskDagTask).min(1).max(256),dag_sha256:hex64});
 const publicLoopSchema = z.strictObject({
   schema:z.literal('deadbyte.autonomous-loop-state.v1'), phase:loopPhase,
   plan_id:hex64.nullable(), plan_version:z.number().int().min(1).nullable(),
   current_step:loopStep.nullable(), replan_count:z.number().int().min(0),
   progress:loopProgress.nullable(), pending_action:loopPendingAction.nullable(),
-  pending_approval:z.boolean(), wait_reason:z.string().min(1).max(1024).nullable()
+  pending_approval:z.boolean(), wait_reason:z.string().min(1).max(1024).nullable(),
+  clarification:loopClarification.nullable().default(null),
+  approval_subject:loopApprovalSubject.nullable().default(null),
+  task_dag:taskDag.nullable().default(null)
 });
 function requireFields(value,ctx,fields) {
   for (const field of fields) if (value[field] === undefined) ctx.addIssue({ code:'custom', path:[field], message:`${field} is required` });
@@ -52,7 +68,7 @@ export const autonomousSessionStatusOutputSchema = statusContract({
   shape:{ configured:z.literal(true).optional(), armed:z.boolean().optional(), autonomous_armed:z.boolean().optional(),
     autonomous_reason:z.string().optional(), autonomous_expires_at_utc:z.string().nullable().optional(),
     coding_armed:z.boolean().optional(), coding_reason:z.string().optional(), root_ids:z.array(z.string()).max(64).optional(),
-    planner_backend:z.enum(['client_sampling','openai_compatible']).optional(), profile_ids:z.array(z.string()).max(128).optional(),
+    planner_backend:z.enum(['client_sampling','openai_compatible','openai_responses']).optional(), profile_ids:z.array(z.string()).max(128).optional(),
     policy_sha256:hex64.optional(), coding_policy_sha256:hex64.optional() }
 });
 

package/src/autonomous-planner-contracts.mjs

@@ -163,6 +163,9 @@ export const r34PlannerDecisionSchema = z.discriminatedUnion('kind',[
     step_id:z.string().regex(ID),evidence:z.array(r34EvidenceSchema).min(1).max(32)}),
   z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('replan'),
     reason:z.string().min(1).max(512),steps:z.array(r34PlanStepSchema).min(1).max(24)}),
+  z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('clarify'),
+    question:z.string().min(1).max(1000),
+    choices:z.array(z.string().min(1).max(256)).min(2).max(5).default([])}),
   z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('pause'),
     reason:z.string().min(1).max(1000)}),
   z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('finish'),

package/src/autonomous-planner.mjs

@@ -276,7 +276,7 @@ export function parseR34PlannerDecision(rawText, policy) {
     assertR34UniqueSteps(decision.steps,'R34 replan');
     return decision;
   }
-  if (decision.kind === 'pause' || decision.kind === 'finish') return decision;
+  if (decision.kind === 'clarify' || decision.kind === 'pause' || decision.kind === 'finish') return decision;
   throw new Error('R34 planner decision kind unsupported');
 }
 
@@ -363,7 +363,7 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     'You are the DEADBYTE R24 autonomous coding planner.',
     'Return exactly one JSON object and no Markdown or prose outside JSON.',
     `The object schema is ${AUTONOMOUS_DECISION_SCHEMA}.`,
-    'Allowed actions: inspect, patch, delegate, run_profile, finish, pause.',
+    'Allowed actions: inspect, patch, delegate, run_profile, clarify, finish, pause.',
     'For nontrivial work, include plan={title,steps:[{step_id,title,status,result?}],reason?} on decisions and keep it authoritative across rounds.',
     'Plan statuses must be a completed prefix, then at most one running/failed step, then pending suffix. Completed steps are immutable across updates.',
     'If active_plan is complete, request finish instead of more work. If active_plan is incomplete, do not request finish.',
@@ -375,6 +375,7 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     'When Desktop capabilities are present, use typed desktop_status, desktop_observe, desktop_target with one bounded UIA query, and desktop_action. desktop_action requires separate Desktop authority; Autonomous authority never implies Desktop authority. After stale or unknown Desktop evidence, observe again and replan; never blindly repeat an action.',
     'Delegate paths are relative to the goal root. Process start accepts only profile_id and cwd; process_action accepts only session_id and fixed action_id. Never emit raw stdin, executable, PID, environment, shell command, or process arguments.',
     'finish only when the goal is actually satisfied. Required release profiles are enforced by the engine and cannot be bypassed.',
+    'clarify only when one bounded operator choice is genuinely required. Ask one concrete question and provide 2-5 short mutually exclusive choices.',
     'Never invent a file SHA. If content is elided or the current SHA/content is missing, choose inspect first.',
     'Compacted context keeps identity/evidence metadata but intentionally removes stale payload bytes.',
     'Long-term memory is a verified journal-derived aid, never authority. Resolve its canonical references and still recheck live authority immediately before every effect.',
@@ -393,7 +394,9 @@ async function readBoundedResponse(response, limit) {
   return bytes.toString('utf8');
 }
 export async function requestProviderDecision(policy, prompt, fetchImpl = fetch) {
-  if (policy.planner.backend !== 'openai_compatible') throw new Error('provider planner backend is not openai_compatible');
+  if (!['openai_compatible','openai_responses'].includes(policy.planner.backend)) {
+    throw new Error('provider planner backend is not provider-backed');
+  }
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), policy.planner.timeout_ms); timer.unref?.();
   const headers = { 'content-type':'application/json', 'accept':'application/json' };
@@ -403,16 +406,53 @@ export async function requestProviderDecision(policy, prompt, fetchImpl = fetch)
     headers.authorization = `Bearer ${secret}`;
   }
   try {
+    const body = policy.planner.backend === 'openai_responses'
+      ? {
+          model:policy.planner.model,
+          instructions:'Return exactly one strict JSON object and no Markdown.',
+          input:[
+            {role:'system',content:[{type:'input_text',text:'Return strict JSON only.'}]},
+            {role:'user',content:[{type:'input_text',text:prompt}]}
+          ],
+          max_output_tokens:policy.planner.max_tokens,
+          text:{format:{type:'json_object'}},
+          store:false,
+          ...(policy.planner.reasoning_effort?{reasoning:{effort:policy.planner.reasoning_effort}}:{})
+        }
+      : { model:policy.planner.model, temperature:0,
+          max_tokens:policy.planner.max_tokens,
+          messages:[{ role:'system', content:'Return strict JSON only.' },{ role:'user', content:prompt }] };
     const response = await fetchImpl(policy.planner.endpoint, {
       method:'POST', redirect:'error', signal:controller.signal, headers,
-      body:JSON.stringify({ model:policy.planner.model, temperature:0,
-        max_tokens:policy.planner.max_tokens,
-        messages:[{ role:'system', content:'Return strict JSON only.' },{ role:'user', content:prompt }] })
+      body:JSON.stringify(body)
     });
     const rawBody = await readBoundedResponse(response, policy.planner.max_response_bytes);
     if (!response.ok) throw new Error(`planner HTTP ${response.status}: ${rawBody.slice(0,512)}`);
     let parsed;
     try { parsed = JSON.parse(rawBody); } catch { throw new Error('planner HTTP response is not JSON'); }
+    if (policy.planner.backend === 'openai_responses') {
+      if (parsed?.status !== 'completed') throw new Error(`planner Responses API response not completed: ${String(parsed?.status ?? 'missing')}`);
+      const content=[];
+      let refused=false;
+      for (const item of Array.isArray(parsed?.output) ? parsed.output : []) {
+        if (item?.type !== 'message') continue;
+        for (const part of Array.isArray(item.content) ? item.content : []) {
+          if (part?.type === 'refusal') refused=true;
+          if (part?.type === 'output_text' && typeof part.text === 'string') content.push(part.text);
+        }
+      }
+      if (refused) throw new Error('planner Responses API refusal');
+      if (content.length < 1) throw new Error('planner Responses API response missing output_text');
+      const usage=parsed?.usage && Number.isInteger(parsed.usage.input_tokens) && Number.isInteger(parsed.usage.output_tokens) && Number.isInteger(parsed.usage.total_tokens)
+        ? {input_tokens:parsed.usage.input_tokens,output_tokens:parsed.usage.output_tokens,total_tokens:parsed.usage.total_tokens}
+        : null;
+      return {
+        backend:'openai_responses', model:typeof parsed.model === 'string' ? parsed.model.slice(0,128) : policy.planner.model,
+        raw_text:content.join(''),
+        response_id:typeof parsed.id === 'string' ? parsed.id.slice(0,160) : null,
+        usage
+      };
+    }
     const content = parsed?.choices?.[0]?.message?.content;
     if (typeof content !== 'string') throw new Error('planner HTTP response missing choices[0].message.content');
     return { backend:'openai_compatible', model:typeof parsed.model === 'string' ? parsed.model : policy.planner.model,

package/src/autonomous-policy.mjs

@@ -33,7 +33,7 @@ function normalizeProviderCircuit(raw) {
 function normalizePlanner(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('autonomous planner missing');
   const backend = raw.backend;
-  if (!['client_sampling', 'openai_compatible'].includes(backend)) throw new Error('autonomous planner backend invalid');
+  if (!['client_sampling', 'openai_compatible', 'openai_responses'].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.endpoint !== 'string') throw new Error('planner.endpoint required');
@@ -46,12 +46,20 @@ function normalizePlanner(raw) {
   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');
-  return {
+  const provider = {
     ...common, endpoint: endpoint.toString(), model: raw.model, api_key_env: apiKeyEnv,
     timeout_ms: integer(raw.timeout_ms, 'planner.timeout_ms', 1000, 300000, 60000),
     max_response_bytes: integer(raw.max_response_bytes, 'planner.max_response_bytes', 4096, 2 * 1024 * 1024, 512 * 1024),
     circuit:normalizeProviderCircuit(raw.circuit)
   };
+  if (backend === 'openai_responses') {
+    const effort = raw.reasoning_effort ?? null;
+    if (effort !== null && !['minimal','low','medium','high','xhigh'].includes(effort)) {
+      throw new Error('planner.reasoning_effort invalid');
+    }
+    return { ...provider, reasoning_effort:effort, store:false };
+  }
+  return provider;
 }
 function normalizeProfile(id, raw, codingPolicy) {
   if (!ID_RE.test(id)) throw new Error(`invalid autonomous profile '${id}'`);

package/src/autonomous-runtime.mjs

@@ -10,6 +10,7 @@ import { createPlan, replanPlan, completePlanStep, planIsComplete as r34PlanIsCo
 import { deriveLoopState, repairFingerprint } from './autonomous-loop-state.mjs';
 import { judgeProgress, stallDisposition } from './autonomous-progress.mjs';
 import { classifyProviderFailure, deriveCircuit, providerCallDisposition, providerCircuitId } from './provider-circuit.mjs';
+import { bindApprovalSubject, deriveEffectiveRigor, taskDagFromPlan, validateBoundApproval } from './agent-governance-r42.mjs';
 import { verifyObservationReceiptFile } from './observation-runtime.mjs';
 import { R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
 import { deriveAgentMemory } from './agent-memory-plane.mjs';
@@ -129,6 +130,11 @@ function deriveState(goal, events) {
       const binding = { ...p, event_sha256:event.event_sha256 };
       observations.push(binding);
     }
+    if (event.type === 'human_input_provided') {
+      observations.push({kind:'human_input',question:p.question,answer:p.answer,
+        answer_sha256:p.answer_sha256,trust_class:'operator_input',observed_at_utc:event.created_at_utc,
+        event_sha256:event.event_sha256});
+    }
     if (event.type === 'native_diff_committed') {
       mutationEpoch = Number(p.mutation_epoch ?? mutationEpoch + 1); mutationCount += Number(p.mutation_count ?? 1);
       diffs.push({ ...p, event_sha256:event.event_sha256 });
@@ -325,7 +331,31 @@ function releaseReadiness(policy, state) {
   });
   return { ready:results.every(item => item.passed), mutation_epoch:state.mutation_epoch, required_profiles:results };
 }
-function normalizeGoal(policy, { submissionId, rootId, title = '', goal, acceptance = '', maxIterations = null }) {
+function normalizeTaskContract(raw) {
+  const value=raw ?? {schema:'deadbyte.task-contract.v1',scope:[],non_goals:[],constraints:[],
+    evidence_requirements:[],risk_level:'medium',clarification_policy:'ask_when_blocked',
+    project_default:'structured',explicit_override:null};
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('autonomous task contract invalid');
+  const allowed=['schema','scope','non_goals','constraints','evidence_requirements','risk_level','clarification_policy','project_default','explicit_override'];
+  const unknown=Object.keys(value).filter(key=>!allowed.includes(key));
+  if (unknown.length) throw new Error(`autonomous task contract unknown field '${unknown[0]}'`);
+  if (value.schema !== 'deadbyte.task-contract.v1') throw new Error('autonomous task contract schema invalid');
+  const list=(field,maxItems,maxLength)=>{
+    const items=value[field] ?? [];
+    if (!Array.isArray(items) || items.length > maxItems || items.some(item=>typeof item !== 'string' || item.length < 1 || item.length > maxLength || item.includes('\0'))) {
+      throw new Error(`autonomous task contract ${field} invalid`);
+    }
+    return [...items];
+  };
+  if (!['low','medium','high'].includes(value.risk_level)) throw new Error('autonomous task contract risk_level invalid');
+  if (!['ask_when_blocked','fail_closed'].includes(value.clarification_policy)) throw new Error('autonomous task contract clarification_policy invalid');
+  const rigor=deriveEffectiveRigor({project_default:value.project_default??'structured',risk_level:value.risk_level,
+    explicit_override:value.explicit_override??null});
+  return Object.freeze({schema:value.schema,scope:list('scope',32,512),non_goals:list('non_goals',24,512),
+    constraints:list('constraints',32,512),evidence_requirements:list('evidence_requirements',32,512),
+    risk_level:value.risk_level,clarification_policy:value.clarification_policy,...rigor});
+}
+function normalizeGoal(policy, { submissionId, rootId, title = '', goal, acceptance = '', taskContract = null, maxIterations = null }) {
   if (!ID_RE.test(submissionId ?? '')) throw new Error('autonomous submission_id invalid');
   if (!policy.root_ids.includes(rootId)) throw new Error(`autonomous root '${rootId}' is not allowed`);
   if (typeof title !== 'string' || title.length > 160) throw new Error('autonomous title must be <=160 characters');
@@ -335,7 +365,7 @@ function normalizeGoal(policy, { submissionId, rootId, title = '', goal, accepta
   if (!Number.isInteger(iterations) || iterations < 1 || iterations > policy.limits.max_iterations) throw new Error('autonomous max_iterations exceeds policy');
   const body = { schema:AUTONOMOUS_GOAL_SCHEMA, policy_sha256:policy.policy_sha256,
     coding_policy_sha256:policy.coding_policy_sha256, submission_id:submissionId, root_id:rootId,
-    title, goal, acceptance, max_iterations:iterations };
+    title, goal, acceptance, task_contract:normalizeTaskContract(taskContract),max_iterations:iterations };
   return Object.freeze({ ...body, goal_sha256:sha256Object(body) });
 }
 
@@ -389,7 +419,8 @@ async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, c
     return null;
   }
   const view = await plannerView(goal,state,events,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider);
-  let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
+  let prompt = buildPlannerPrompt({ goal:{ goal_id:goal.goal_id,title:goal.title, goal:goal.goal, acceptance:goal.acceptance,
+    task_contract:goal.task_contract }, policy, view });
   const repair = [...(state.planner_rejections ?? [])].reverse().find(item => item.planner_round === round) ?? null;
   if (repair) {
     const repairState = canonicalJson({ request_id:repair.request_id, response_sha256:repair.response_sha256,
@@ -452,7 +483,24 @@ function legacyPublicLoopPhase(phase) {
   return ({PLAN:'PLANNING',INSPECT:'INSPECTING',ACT:'ACTING',VERIFY:'VERIFYING',CRITIC:'REPLANNING',
     REPAIR:'REPLANNING',RELEASE:'VERIFYING',WAITING:'WAITING',SUCCEEDED:'COMPLETE',FAILED:'WAITING'})[phase] ?? 'WAITING';
 }
-function publicLoopState(loop) {
+function approvalScopeFor(reason){
+  if(reason==='human_input_required') return 'human_clarification';
+  if(String(reason??'').startsWith('desktop_')) return 'desktop_resume';
+  if(['ambiguous_interrupted_action','profile_execution_without_receipt'].includes(reason)) return 'interrupted_effect_resume';
+  return 'resume_goal';
+}
+function pendingApprovalSubject(goal,events,loop){
+  if(!loop?.pending_approval) return null;
+  const waiting=[...events].reverse().find(event=>event.type==='waiting_entered')??null;
+  if(!waiting) return null;
+  const payload=waiting.payload??{};
+  return bindApprovalSubject({
+    goal_id:goal.goal_id,reviewed_event_seq:waiting.seq,reviewed_event_sha256:waiting.event_sha256,
+    journal_head_sha256:events.at(-1)?.event_sha256??ZERO_HASH,scope:approvalScopeFor(payload.reason),
+    subject:{reason:payload.reason??loop.wait_reason??'paused',waiting_payload_sha256:sha256Object(payload)}
+  });
+}
+function publicLoopState(loop,goal=null,events=null) {
   if (!loop) return null;
   const currentStep=loop.current_step ? {
     step_id:loop.current_step.step_id,intent:loop.current_step.intent,status:loop.current_step.status
@@ -468,15 +516,18 @@ function publicLoopState(loop) {
   return {
     schema:'deadbyte.autonomous-loop-state.v1',phase:legacyPublicLoopPhase(loop.phase),plan_id:loop.plan_id,plan_version:loop.plan_version,
     current_step:currentStep,replan_count:loop.replan_count,progress,
-    pending_action:pendingAction,pending_approval:loop.pending_approval,wait_reason:loop.wait_reason
+    pending_action:pendingAction,pending_approval:loop.pending_approval,wait_reason:loop.wait_reason,
+    clarification:loop.clarification ?? null,
+    approval_subject:goal&&events?pendingApprovalSubject(goal,events,loop):null,
+    task_dag:goal&&loop.plan?taskDagFromPlan({run_id:goal.goal_id,goal_id:goal.goal_id,plan:loop.plan}):null
   };
 }
 function withLoopResult(goal,events,result) {
-  const loop=publicLoopState(loopStateOrNull(goal,events));
+  const loop=publicLoopState(loopStateOrNull(goal,events),goal,events);
   return loop ? {...result,loop} : result;
 }
 function providerCircuitSnapshot(policy,events,observedAtUtc=new Date().toISOString()) {
-  if (policy.planner.backend !== 'openai_compatible') return null;
+  if (!['openai_compatible','openai_responses'].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}) {
@@ -517,7 +568,9 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
   try {
     const response=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
+      provider_id:providerId,request_id:pending.request_id,probe:disposition.probe===true,
+      ...(response.response_id?{response_id:response.response_id}:{}),
+      ...(response.usage?{usage:response.usage}:{})
     });
     return {response};
   } catch (error) {
@@ -543,7 +596,7 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
   let suppliedResponse = plannerResponse;
   while (pending) {
     let response;
-    if (policy.planner.backend === 'openai_compatible') {
+    if (['openai_compatible','openai_responses'].includes(policy.planner.backend)) {
       const provider=await requestProviderWithCircuit({ctx,events,goal,policy,pending,signingKeyPath});
       if (provider.waiting) return {needs_planner:false,rejected:false,paused:true,provider_waiting:true};
       response=provider.response;
@@ -585,6 +638,8 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
     const event = await appendEvent(ctx,events,signingKeyPath,'planner_decision',{
       request_id:pending.request_id, planner_round:pending.planner_round, mutation_epoch:pending.mutation_epoch,
       backend:response.backend, model:response.model ?? 'unknown', response_sha256:sha256Bytes(Buffer.from(response.raw_text,'utf8')),
+      ...(response.response_id?{response_id:response.response_id}:{}),
+      ...(response.usage?{usage:response.usage}:{}),
       ...(pending.working_memory_sha256?{
         working_memory_sha256:pending.working_memory_sha256,memory_snapshot_sha256:pending.memory_snapshot_sha256,
         memory_index_sha256:pending.memory_index_sha256,
@@ -1506,6 +1561,20 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
     return r34EnterWaiting({ctx,events,goal,signingKeyPath,reason:decision.reason,resumePhase:loop.phase});
   }
 
+  if (decision.kind === 'clarify') {
+    await appendEvent(ctx,events,signingKeyPath,'human_input_requested',{
+      decision_event_sha256:decisionEvent.event_sha256,question:decision.question,choices:decision.choices
+    });
+    await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{
+      reason:'human_input_required',requires_approval:true,resume_phase:'PLAN',
+      question:decision.question,choices:decision.choices
+    });
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+      reason:'human_input_required',decision_event_sha256:decisionEvent.event_sha256
+    });
+    return {status:'paused',reason:'human_input_required'};
+  }
+
   if (decision.kind === 'finish') {
     if (!r34PlanIsComplete(loop.plan)) {
       await appendEvent(ctx,events,signingKeyPath,'plan_guard_blocked',{
@@ -1676,7 +1745,7 @@ function terminalState(state) {
 }
 function pauseState(state) { return state.state === 'paused'; }
 async function resumeProviderWaitIfReady({ctx,journal,goal,state,policy,signingKeyPath}) {
-  if (state.state!=='paused'||state.reason!=='provider_circuit_open'||policy.planner.backend!=='openai_compatible') return state;
+  if (state.state!=='paused'||state.reason!=='provider_circuit_open'||!['openai_compatible','openai_responses'].includes(policy.planner.backend)) return state;
   const circuit=providerCircuitSnapshot(policy,journal);
   const disposition=providerCallDisposition(circuit);
   if (!disposition.allowed||circuit.state!=='HALF_OPEN') return state;
@@ -1715,7 +1784,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       coding_policy_sha256:policy.coding_policy_sha256 };
   }
   async function providerCircuitStatus({goalId}) {
-    if (policy.planner.backend!=='openai_compatible') return null;
+    if (!['openai_compatible','openai_responses'].includes(policy.planner.backend)) return null;
     const ctx=goalContext(policy,goalId);
     await loadGoal(ctx,policy,verifyKeyPath);
     const journal=await readEvents(ctx,verifyKeyPath);
@@ -1730,9 +1799,9 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     return { autonomous, coding };
   }
 
-  async function submit({ submissionId, rootId, title = '', goal, acceptance = '', maxIterations = null }) {
+  async function submit({ submissionId, rootId, title = '', goal, acceptance = '', taskContract = null, maxIterations = null }) {
     await assertRunAuthority(rootId);
-    const normalized = normalizeGoal(policy,{ submissionId,rootId,title,goal,acceptance,maxIterations });
+    const normalized = normalizeGoal(policy,{ submissionId,rootId,title,goal,acceptance,taskContract,maxIterations });
     const goalId = goalIdFor(policy.policy_sha256,submissionId);
     const ctx = goalContext(policy,goalId);
     if (await exists(ctx.dir)) {
@@ -1749,7 +1818,8 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     await writeFile(ctx.goalPath,`${canonicalJson(envelope)}\n`,{flag:'wx'});
     const journal = [];
     await appendEvent(ctx,journal,signingKeyPath,'goal_created',{
-      submission_id:submissionId, root_id:rootId, title, goal_sha256:normalized.goal_sha256,
+      submission_id:submissionId, root_id:rootId, title, acceptance:normalized.acceptance,
+      task_contract:normalized.task_contract,goal_sha256:normalized.goal_sha256,
       max_iterations:normalized.max_iterations,
       ...(memoryProvider?{source_release_manifest:memoryProvider.source_release_manifest}:{})
     });
@@ -1761,7 +1831,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     const goal = await loadGoal(ctx,policy,verifyKeyPath);
     const journal = await readEvents(ctx,verifyKeyPath);
     const derived = deriveState(goal,journal);
-    const loop = publicLoopState(loopStateOrNull(goal,journal));
+    const loop = publicLoopState(loopStateOrNull(goal,journal),goal,journal);
     const lock=await runLockStatus(ctx);
     return { status:'ok', goal_id:goalId, goal_sha256:goal.goal_sha256,
       title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived, ...lock,
@@ -1795,8 +1865,11 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       return { status:'existing', goal_id:goalId, state:current.state };
     }
   }
-  async function approve({ goalId, decision = 'approve' }) {
+  async function approve({ goalId, decision = 'approve', answer = null, approvalSubjectSha256 = null, expiresInMs = 300000 }) {
     if (!['approve','reject'].includes(decision)) throw new Error('autonomous approval decision invalid');
+    if (answer !== null && (typeof answer !== 'string' || answer.length < 1 || answer.length > 4096 || answer.includes('\0'))) {
+      throw new Error('autonomous approval answer invalid');
+    }
     const ctx = goalContext(policy,goalId);
     await acquireLock(ctx);
     try {
@@ -1811,7 +1884,34 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       }
       if (hasR34Loop(journal)) {
         await assertRunAuthority(goal.root_id);
+        const loopState=loopStateOrNull(goal,journal);
+        const approvalSubject=pendingApprovalSubject(goal,journal,loopState);
+        if(!approvalSubject) throw new Error('autonomous approval subject unavailable');
+        if(typeof approvalSubjectSha256!=='string'||approvalSubjectSha256!==approvalSubject.approval_subject_sha256){
+          throw new Error('autonomous approval subject mismatch');
+        }
+        if(!Number.isInteger(expiresInMs)||expiresInMs<1000||expiresInMs>3_600_000) throw new Error('autonomous approval lifetime invalid');
         const waiting=[...journal].reverse().find(event=>event.type==='waiting_entered') ?? null;
+        if (waiting?.payload?.reason === 'human_input_required' && answer === null) {
+          throw new Error('autonomous clarification answer is required');
+        }
+        if (waiting?.payload?.reason !== 'human_input_required' && answer !== null) {
+          throw new Error('autonomous approval answer is only valid for human clarification');
+        }
+        const issuedAt=new Date();
+        const approval={schema:'deadbyte.bound-approval.v1',approval_subject_sha256:approvalSubjectSha256,
+          reviewed_event_seq:approvalSubject.reviewed_event_seq,reviewed_event_sha256:approvalSubject.reviewed_event_sha256,
+          journal_head_sha256:approvalSubject.journal_head_sha256,scope:approvalSubject.scope,
+          issued_at_utc:issuedAt.toISOString(),expires_at_utc:new Date(issuedAt.getTime()+expiresInMs).toISOString(),
+          provenance:'operator_mcp'};
+        validateBoundApproval({approval,subject:approvalSubject,now:issuedAt});
+        await appendEvent(ctx,journal,signingKeyPath,'approval_granted',approval);
+        if (waiting?.payload?.reason === 'human_input_required') {
+          await appendEvent(ctx,journal,signingKeyPath,'human_input_provided',{
+            request_event_sha256:waiting.event_sha256,question:waiting.payload.question,
+            answer,answer_sha256:sha256Bytes(Buffer.from(answer,'utf8'))
+          });
+        }
         const resumePhase=typeof waiting?.payload?.resume_phase === 'string' ? waiting.payload.resume_phase : 'PLAN';
         await appendEvent(ctx,journal,signingKeyPath,'waiting_resumed',{
           to:resumePhase,reason:waiting?.payload?.reason ?? current.reason ?? 'operator_approved',

package/src/autonomous-supervisor.mjs

@@ -24,7 +24,7 @@ async function listGoalIds(policy) {
 export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
   idleDelayMs = 750, maxCycles = 32, logger = console, continuous = true } = {}) {
   if (!runtime || !policy) throw new Error('autonomous supervisor requires runtime + policy');
-  const providerBacked = policy.planner.backend === 'openai_compatible';
+  const providerBacked = ['openai_compatible','openai_responses'].includes(policy.planner.backend);
   if (!Number.isInteger(idleDelayMs) || idleDelayMs < 25 || idleDelayMs > 60_000) {
     throw new Error('autonomous supervisor idleDelayMs out of range');
   }

package/src/evidence-publisher-r42.mjs

@@ -0,0 +1,76 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { link, mkdir, open, readFile, realpath, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,96}$/;
+const shaBytes=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sha=value=>shaBytes(Buffer.from(canonicalJson(value),'utf8'));
+function object(value,label){if(!value||typeof value!=='object'||Array.isArray(value))throw new Error(`${label} invalid`);return value;}
+function keys(value,allowed,label){const extra=Object.keys(value).filter(key=>!allowed.includes(key));if(extra.length)throw new Error(`${label} unknown field '${extra[0]}'`);}
+function id(value,label){if(typeof value!=='string'||!ID.test(value))throw new Error(`${label} invalid`);return value;}
+function hex(value,label){if(typeof value!=='string'||!HEX64.test(value))throw new Error(`${label} invalid`);return value;}
+function iso(value,label){if(typeof value!=='string'||!Number.isFinite(Date.parse(value)))throw new Error(`${label} invalid`);return value;}
+
+export async function publishEvidenceAtomic({root,kind,evidenceId=null,payload}){
+  if(typeof root!=='string'||!path.isAbsolute(root)) throw new Error('evidence root must be absolute');
+  id(kind,'evidence kind');object(payload,'evidence payload');
+  const payloadSha=sha(payload);
+  const resolvedId=id(evidenceId??payloadSha,'evidence id');
+  const body={schema:'deadbyte.evidence-publication.v1',kind,evidence_id:resolvedId,payload_sha256:payloadSha,payload:structuredClone(payload)};
+  const envelope={...body,evidence_sha256:sha(body)};
+  const bytes=Buffer.from(`${canonicalJson(envelope)}\n`,'utf8');
+  const base=path.resolve(root);await mkdir(base,{recursive:true});
+  const canonicalRoot=await realpath(base);
+  const pendingDir=path.join(canonicalRoot,'.pending');const finalDir=path.join(canonicalRoot,kind);
+  await mkdir(pendingDir,{recursive:true});await mkdir(finalDir,{recursive:true});
+  const target=path.join(finalDir,`${resolvedId}.json`);
+  const temp=path.join(pendingDir,`${kind}-${resolvedId}-${randomUUID()}.tmp`);
+  let handle;
+  try{
+    handle=await open(temp,'wx',0o600);await handle.writeFile(bytes);await handle.sync();await handle.close();handle=null;
+    const staged=await readFile(temp);
+    if(shaBytes(staged)!==shaBytes(bytes)) throw new Error('staged evidence hash verification failed');
+    try{
+      await link(temp,target);
+      return Object.freeze({status:'created',kind,evidence_id:resolvedId,evidence_sha256:envelope.evidence_sha256,
+        bytes:bytes.length,path:target});
+    }catch(error){
+      if(error?.code!=='EEXIST') throw error;
+      const existing=await readFile(target);
+      if(!existing.equals(bytes)){
+        const conflict=new Error(`EVIDENCE_ID_CONFLICT: ${kind}/${resolvedId}`);conflict.code='EVIDENCE_ID_CONFLICT';throw conflict;
+      }
+      return Object.freeze({status:'existing',kind,evidence_id:resolvedId,evidence_sha256:envelope.evidence_sha256,
+        bytes:bytes.length,path:target});
+    }
+  }finally{
+    if(handle) await handle.close().catch(()=>{});
+    await rm(temp,{force:true}).catch(()=>{});
+  }
+}
+
+export function createExecutionReceipt(raw){
+  const value=object(raw,'execution receipt');
+  keys(value,['execution_id','subject_sha256','request_sha256','observed_exit_code','started_at_utc','completed_at_utc'],'execution receipt');
+  const core={schema:'deadbyte.execution-receipt.v1',execution_id:id(value.execution_id,'execution_id'),
+    subject_sha256:hex(value.subject_sha256,'execution subject_sha256'),request_sha256:hex(value.request_sha256,'execution request_sha256'),
+    observed_exit_code:value.observed_exit_code,started_at_utc:iso(value.started_at_utc,'execution started_at_utc'),
+    completed_at_utc:iso(value.completed_at_utc,'execution completed_at_utc')};
+  if(!Number.isInteger(core.observed_exit_code)) throw new Error('execution exit code invalid');
+  if(Date.parse(core.completed_at_utc)<Date.parse(core.started_at_utc)) throw new Error('execution time order invalid');
+  return Object.freeze({...core,receipt_sha256:sha(core)});
+}
+
+export function createVerificationResult(raw){
+  const value=object(raw,'verification result');
+  keys(value,['verification_id','subject_sha256','execution_receipt_sha256','outcome_passed','oracle','evidence_refs'],'verification result');
+  if(typeof value.outcome_passed!=='boolean') throw new Error('verification outcome invalid');
+  if(!Array.isArray(value.evidence_refs)||value.evidence_refs.length<1||value.evidence_refs.length>64||value.evidence_refs.some(ref=>!HEX64.test(ref))) throw new Error('verification evidence refs invalid');
+  const core={schema:'deadbyte.verification-result.v1',verification_id:id(value.verification_id,'verification_id'),
+    subject_sha256:hex(value.subject_sha256,'verification subject_sha256'),
+    execution_receipt_sha256:hex(value.execution_receipt_sha256,'verification receipt_sha256'),
+    outcome_passed:value.outcome_passed,oracle:id(value.oracle,'verification oracle'),evidence_refs:[...value.evidence_refs]};
+  return Object.freeze({...core,verification_sha256:sha(core)});
+}

package/src/mcp-server.mjs

@@ -202,7 +202,7 @@ const memoryProvider=autonomousPolicy?createR41MemoryProvider({
 }):null;
 const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
   machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,memoryProvider,signingKeyPath,verifyKeyPath }) : null;
-const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible' &&
+const autonomousSupervisor = autonomousRuntime && ['openai_compatible','openai_responses'].includes(autonomousPolicy.planner.backend) &&
   autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })
   : null;

package/src/provider-circuit.mjs

@@ -48,11 +48,11 @@ function openAt(state,ms,policy){
 }
 
 export function providerCircuitId(planner){
-  if(planner?.backend!=='openai_compatible'||typeof planner.endpoint!=='string'||typeof planner.model!=='string') {
+  if(!['openai_compatible','openai_responses'].includes(planner?.backend)||typeof planner.endpoint!=='string'||typeof planner.model!=='string') {
     throw new Error('provider circuit planner identity invalid');
   }
-  const digest=createHash('sha256').update(Buffer.from(`${planner.endpoint}\0${planner.model}`,'utf8')).digest('hex');
-  return `openai_compatible:${digest}`;
+  const digest=createHash('sha256').update(Buffer.from(`${planner.backend}\0${planner.endpoint}\0${planner.model}`,'utf8')).digest('hex');
+  return `${planner.backend}:${digest}`;
 }
 
 export function classifyProviderFailure(error){
@@ -61,7 +61,7 @@ export function classifyProviderFailure(error){
   if(name==='aborterror'||/\b(?:timed?\s*out|timeout|aborted)\b/.test(text)) return 'timeout';
   if(/(?:http\s*429|rate[ _-]?limit|too many requests)/.test(text)) return 'rate_limit';
   if(/(?:http\s*(?:401|403)|unauthori[sz]ed|forbidden|api key|authentication)/.test(text)) return 'auth';
-  if(/(?:not json|invalid json|missing choices|invalid response|response.*(?:schema|contract|content))/.test(text)) return 'invalid_response';
+  if(/(?:not json|invalid json|missing choices|missing output_text|refusal|not completed|incomplete response|invalid response|response.*(?:schema|contract|content))/.test(text)) return 'invalid_response';
   if(/(?:econnreset|econnrefused|enotfound|fetch failed|network|socket|transport|connection)/.test(text)) return 'transport';
   return 'other';
 }

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.13.0';
+export const DEADBYTE_VERSION = '0.14.0';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';