deadbyte-mcp 0.12.0 → 0.14.0

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');
 }
 
@@ -355,6 +355,7 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     decisions:view.recent_decisions ?? [],
     projectMemory:view.project_memory ?? null,
     desktopMemory:view.desktop_memory ?? null,
+    longTermMemory:view.long_term_memory ?? null,
     capabilities:view.capabilities ?? null
   });
   const stateJson = canonicalJson(state);
@@ -362,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.',
@@ -374,8 +375,10 @@ 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.',
     'Prefer surgical exact replace operations over whole-file writes.',
     'If an observed build/test/benchmark failed, diagnose from the evidence and change the source rather than claiming success.',
     `STATE=${stateJson}`,
@@ -391,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' };
@@ -401,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) });
 }
 
@@ -360,20 +390,24 @@ function configuredCapabilityManifest({machineFsRuntime,observationRuntime,proce
     entries:Object.freeze(entries)});
 }
 
-async function plannerView(goal, state, events, codingRuntime, capabilityManifest, desktopMemoryProvider=null) {
+async function plannerView(goal, state, events, codingRuntime, capabilityManifest, desktopMemoryProvider=null,memoryProvider=null) {
   const tree = await codingRuntime.tree({ rootId:goal.root_id, path:'.', maxDepth:4, maxEntries:600 });
   const memory=deriveAgentMemory(events,{maxArchival:24});
   const desktopMemory=desktopMemoryProvider?await desktopMemoryProvider.plannerContext():null;
+  const codingAuthority=memoryProvider?await codingRuntime.sessionStatus():null;
+  const longTerm=memoryProvider?await memoryProvider.refresh({goal,events,currentPlan:state.active_plan,currentFiles:[],currentSymbols:[],
+    currentAuthority:{coding:{armed:codingAuthority.armed,reason:codingAuthority.reason}}}):null;
   return { mutation_epoch:state.mutation_epoch, planner_round:state.planner_round, tree:tree.entries,
     contexts:state.contexts.slice(-16), observations:state.observations.slice(-24), active_plan:state.active_plan,
     capabilities:capabilityManifest, project_memory:memory, desktop_memory:desktopMemory,
+    long_term_memory:longTerm?.planner_context??null,memory_evidence:longTerm,
     recent_decisions:state.decisions.slice(-8).map(item => ({ planner_round:item.planner_round,
       action:item.decision?.action, summary:item.decision?.summary })) };
 }
 function requestIdFor(goalId, plannerRound, journalHead) {
   return sha256Object({ schema:'deadbyte.autonomous-planner-request.v1', goal_id:goalId, planner_round:plannerRound, journal_head_sha256:journalHead });
 }
-async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider, signingKeyPath) {
+async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider,memoryProvider, signingKeyPath) {
   if (state.pending_request) return state.pending_request;
   const round = state.planner_round + 1;
   if (round > goal.max_iterations) {
@@ -384,8 +418,9 @@ async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, c
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'wall_time_limit', max_wall_ms:policy.limits.max_wall_ms });
     return null;
   }
-  const view = await plannerView(goal,state,events,codingRuntime,capabilityManifest,desktopMemoryProvider);
-  let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
+  const view = await plannerView(goal,state,events,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider);
+  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,
@@ -397,6 +432,14 @@ Repair only the decision contract. Return one corrected strict JSON decision; do
   const requestId = requestIdFor(goal.goal_id,round,state.journal_head_sha256);
   const payload = { request_id:requestId, planner_round:round, mutation_epoch:state.mutation_epoch,
     prompt, prompt_sha256:sha256Bytes(Buffer.from(prompt,'utf8')), backend:policy.planner.backend,
+    ...(view.memory_evidence?{
+      working_memory_sha256:view.memory_evidence.working_memory_sha256,
+      memory_snapshot_sha256:view.memory_evidence.snapshot_sha256,
+      memory_index_sha256:view.memory_evidence.index_sha256,
+      historical_archive_sha256:view.memory_evidence.historical_archive_sha256,
+      historical_index_sha256:view.memory_evidence.historical_index_sha256,
+      memory_source_release_manifest:view.memory_evidence.source_release_manifest
+    }:{}),
     ...(repair ? { repair_of_request_id:repair.request_id, rejection_event_sha256:repair.event_sha256 } : {}) };
   await appendEvent(ctx,events,signingKeyPath,'planner_requested',payload);
   return payload;
@@ -440,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
@@ -456,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}) {
@@ -505,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) {
@@ -524,14 +589,14 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
     throw error;
   }
 }
-async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider, signingKeyPath, plannerResponse }) {
+async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, desktopMemoryProvider,memoryProvider, signingKeyPath, plannerResponse }) {
   let currentState = state;
-  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,signingKeyPath);
+  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider,signingKeyPath);
   if (!pending) return null;
   let suppliedResponse = plannerResponse;
   while (pending) {
     let response;
-    if (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;
@@ -565,7 +630,7 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
         return { needs_planner:false, rejected:true, paused:true };
       }
       currentState = deriveState(goal,events);
-      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,signingKeyPath);
+      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider,signingKeyPath);
       if (!pending) return null;
       if (policy.planner.backend === 'client_sampling') return { needs_planner:true, request:pending };
       continue;
@@ -573,6 +638,14 @@ 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,
+        historical_archive_sha256:pending.historical_archive_sha256,historical_index_sha256:pending.historical_index_sha256,
+        memory_source_release_manifest:pending.memory_source_release_manifest
+      }:{}),
       decision
     });
     return { needs_planner:false, event, decision };
@@ -1488,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',{
@@ -1658,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;
@@ -1678,7 +1765,7 @@ function isAuthorityUnavailable(error) {
 
 export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRuntime, machineFsRuntime = null,
   observationRuntime = null, processRuntime = null, semanticRuntime = null, desktopRuntime = null,
-  desktopMemoryProvider = null, signingKeyPath, verifyKeyPath }) {
+  desktopMemoryProvider = null,memoryProvider=null, signingKeyPath, verifyKeyPath }) {
   if (!policy || !codingRuntime || !nativeDiffRuntime) throw new Error('autonomous runtime requires policy/coding/native-diff runtimes');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('autonomous runtime requires trust keys');
   const capabilityManifest=configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime});
@@ -1697,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);
@@ -1712,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)) {
@@ -1731,8 +1818,10 @@ 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,
-      max_iterations:normalized.max_iterations
+      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}:{})
     });
     return { status:'accepted', goal_id:goalId, goal_sha256:normalized.goal_sha256, state:'pending' };
   }
@@ -1742,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,
@@ -1776,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 {
@@ -1792,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',
@@ -1927,7 +2046,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           continue;
         }
         const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
-          desktopMemoryProvider,signingKeyPath,plannerResponse:suppliedResponse });
+          desktopMemoryProvider,memoryProvider,signingKeyPath,plannerResponse:suppliedResponse });
         suppliedResponse = null;
         if (accepted?.needs_planner) {
           state = deriveState(goal,journal);

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

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { access, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
@@ -37,6 +38,7 @@ import { createNativeDesktopInputProvider } from './desktop-input-r40.mjs';
 import { createNativeDesktopGrounder } from './desktop-uia-r40.mjs';
 import { createDesktopRuntime } from './desktop-runtime-r40.mjs';
 import { createDesktopMemoryProvider } from './desktop-memory-r40.mjs';
+import { createR41MemoryProvider } from './memory-r41.mjs';
 import { registerDesktopTools } from './desktop-mcp-tools-r40.mjs';
 import { loadAutonomousPolicy } from './autonomous-policy.mjs';
 import { createNativeDiffRuntime } from './native-diff.mjs';
@@ -61,6 +63,7 @@ import {
 } from './output-contracts.mjs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const packageManifestSha256=createHash('sha256').update(await readFile(path.join(packageRoot,'MANIFEST.SHA256'))).digest('hex');
 const workspaceRoot = path.resolve(process.env.DEADBYTE_WORKSPACE_ROOT ?? path.join(packageRoot, 'workspaces'));
 const signingKeyPath = process.env.DEADBYTE_SIGNING_KEY ?? defaultPrivateKeyPath();
 const verifyKeyPath = process.env.DEADBYTE_VERIFY_KEY ?? defaultPublicKeyPath();
@@ -187,9 +190,19 @@ if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) throw new Error('DEA
 const autonomousPolicy = autonomousRuntimeMode === '1' ? await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy) : null;
 const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath }) : null;
 semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends, nativeDiffRuntime }) : null;
+const autonomousMemorySigningKey=autonomousPolicy?await loadPrivateSigningKey(signingKeyPath):null;
+const autonomousMemoryVerifyKey=autonomousPolicy?await loadPublicVerifyKey(verifyKeyPath):null;
+if(autonomousPolicy&&autonomousMemorySigningKey.keyId!==autonomousMemoryVerifyKey.keyId) throw new Error('R41 memory signing/verify key mismatch');
+const memoryProvider=autonomousPolicy?createR41MemoryProvider({
+  memoryRoot:path.join(autonomousPolicy.evidence_dir,'memory-r41',packageManifestSha256),sourceReleaseManifest:packageManifestSha256,
+  journalRoot:path.join(autonomousPolicy.evidence_dir,'goals'),
+  writerVersion:DEADBYTE_VERSION,privateKey:autonomousMemorySigningKey.privateKey,
+  publicKey:autonomousMemoryVerifyKey.publicKey,keyId:autonomousMemorySigningKey.keyId,
+  byteBudget:Math.min(262144,Math.max(65536,Math.floor(autonomousPolicy.limits.max_context_bytes/2))),semantic:{enabled:false}
+}):null;
 const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
-  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,signingKeyPath,verifyKeyPath }) : null;
-const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible' &&
+  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,memoryProvider,signingKeyPath,verifyKeyPath }) : null;
+const autonomousSupervisor = autonomousRuntime && ['openai_compatible','openai_responses'].includes(autonomousPolicy.planner.backend) &&
   autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })
   : null;