deadbyte-mcp 0.9.0 → 0.10.0

package/src/autonomous-runtime.mjs

@@ -11,6 +11,7 @@ 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 { verifyObservationReceiptFile } from './observation-runtime.mjs';
+import { R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
 
 export const AUTONOMOUS_GOAL_SCHEMA = 'deadbyte.autonomous-goal.v1';
 export const AUTONOMOUS_EVENT_SCHEMA = 'deadbyte.autonomous-event.v1';
@@ -318,17 +319,38 @@ function normalizeGoal(policy, { submissionId, rootId, title = '', goal, accepta
   return Object.freeze({ ...body, goal_sha256:sha256Object(body) });
 }
 
-async function plannerView(goal, state, codingRuntime) {
+function configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime}) {
+  const plannerReachable=id => id === 'coding.stat' || id === 'coding.search' || id === 'coding.files_read' ||
+    id.startsWith('semantic.') || id.startsWith('native_diff.') || id.startsWith('process.') ||
+    id.startsWith('machine_fs.') || id.startsWith('observation.') || id === 'autonomous.release_gate';
+  const runtimeEnabled=entry => {
+    if (entry.runtime_flag === 'DEADBYTE_CODING_RUNTIME' || entry.runtime_flag === 'DEADBYTE_AUTONOMOUS_RUNTIME') return true;
+    if (entry.runtime_flag === 'DEADBYTE_MACHINE_FS_RUNTIME') return Boolean(machineFsRuntime);
+    if (entry.runtime_flag === 'DEADBYTE_PROCESS_RUNTIME') return Boolean(processRuntime);
+    if (entry.runtime_flag === 'DEADBYTE_OBSERVATION_RUNTIME') return Boolean(observationRuntime);
+    return entry.runtime_flag === null;
+  };
+  const entries=R36_CAPABILITY_LEDGER.entries
+    .filter(entry=>entry.production && !entry.host_only && plannerReachable(entry.id) && runtimeEnabled(entry))
+    .filter(entry=>!entry.id.startsWith('semantic.') || Boolean(semanticRuntime))
+    .map(entry=>({id:entry.id,authority:entry.authority,mutating:entry.mutating,full_tool:entry.full_tool,
+      compact_tool:entry.compact_tool,compact_op:entry.compact_op}));
+  return Object.freeze({schema:'deadbyte.capability-manifest.v1',ledger_sha256:R36_CAPABILITY_LEDGER.ledger_sha256,
+    entries:Object.freeze(entries)});
+}
+
+async function plannerView(goal, state, codingRuntime, capabilityManifest) {
   const tree = await codingRuntime.tree({ rootId:goal.root_id, path:'.', maxDepth:4, maxEntries:600 });
   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,
     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, signingKeyPath) {
+async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, capabilityManifest, signingKeyPath) {
   if (state.pending_request) return state.pending_request;
   const round = state.planner_round + 1;
   if (round > goal.max_iterations) {
@@ -339,7 +361,7 @@ async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, s
     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,codingRuntime);
+  const view = await plannerView(goal,state,codingRuntime,capabilityManifest);
   let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
   const repair = [...(state.planner_rejections ?? [])].reverse().find(item => item.planner_round === round) ?? null;
   if (repair) {
@@ -476,9 +498,9 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
     throw error;
   }
 }
-async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath, plannerResponse }) {
+async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, signingKeyPath, plannerResponse }) {
   let currentState = state;
-  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,signingKeyPath);
+  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,signingKeyPath);
   if (!pending) return null;
   let suppliedResponse = plannerResponse;
   while (pending) {
@@ -517,7 +539,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,signingKeyPath);
+      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,signingKeyPath);
       if (!pending) return null;
       if (policy.planner.backend === 'client_sampling') return { needs_planner:true, request:pending };
       continue;
@@ -557,6 +579,18 @@ async function executeInspect({ ctx, events, goal, decisionEvent, decision, codi
 }
 
 const DELEGATED_MUTATIONS = new Set(['process_start','process_action','process_terminate','observation_search_cancel']);
+const CAPABILITY_BY_ACTION=Object.freeze({
+  search:'coding.search',stat:'coding.stat',multi_read:'coding.files_read',
+  semantic_outline:'semantic.outline',semantic_definition:'semantic.definition',semantic_references:'semantic.references',
+  semantic_diagnostics:'semantic.diagnostics',semantic_implementations:'semantic.implementations',semantic_rename_preview:'semantic.rename_preview',
+  native_diff_apply:'native_diff.apply',native_diff_verify:'native_diff.verify',
+  process_start:'process.start',process_read:'process.read',process_status:'process.status',process_list:'process.list',process_action:'process.action',process_terminate:'process.terminate',
+  machine_fs_stat:'machine_fs.stat',machine_fs_list:'machine_fs.list',machine_fs_read:'machine_fs.read',machine_fs_mkdir:'machine_fs.mkdir',machine_fs_move:'machine_fs.move',machine_fs_delete:'machine_fs.delete',
+  machine_stat:'machine_fs.stat',machine_list:'machine_fs.list',machine_read:'machine_fs.read',
+  observation_search_start:'observation.search_start',observation_search_status:'observation.search_status',observation_search_page:'observation.search_page',observation_search_cancel:'observation.search_cancel',
+  observation_process_list:'observation.process_list',observation_system_status:'observation.system_status'
+});
+function capabilityIdForOperation(operation){return CAPABILITY_BY_ACTION[operation?.kind]??null;}
 function assertDelegatedIdentity(events, operation) {
   if (['observation_search_status','observation_search_page','observation_search_cancel'].includes(operation.kind)) {
     const owned = events.some(event => event.type === 'delegated_action_completed' &&
@@ -570,8 +604,45 @@ function assertDelegatedIdentity(events, operation) {
   }
 }
 async function invokeDelegatedOperation(goal, operation, runtimes) {
-  const { machineFsRuntime, observationRuntime, processRuntime } = runtimes;
+  const { codingRuntime, semanticRuntime, nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime } = runtimes;
   switch (operation.kind) {
+    case 'stat':
+      return codingRuntime.stat({rootId:goal.root_id,relativePath:operation.path,hash:operation.hash});
+    case 'search':
+      return codingRuntime.search({rootId:goal.root_id,path:operation.path,pattern:operation.pattern,target:operation.target,mode:operation.mode,
+        caseSensitive:operation.case_sensitive,maxResults:operation.max_results,maxFileBytes:operation.max_file_bytes,
+        maxScanBytes:operation.max_scan_bytes,pageSize:operation.page_size,cursor:operation.cursor});
+    case 'multi_read':
+      return codingRuntime.filesRead({rootId:goal.root_id,files:operation.files,maxTotalBytes:operation.max_total_bytes});
+    case 'semantic_outline':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.outline({rootId:goal.root_id,relativePath:operation.path,maxSymbols:operation.max_symbols});
+    case 'semantic_definition':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.definition({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,maxResults:operation.max_results});
+    case 'semantic_references':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.references({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,maxResults:operation.max_results});
+    case 'semantic_diagnostics':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.diagnostics({rootId:goal.root_id,relativePath:operation.path,maxResults:operation.max_results});
+    case 'semantic_implementations':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.implementations({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,maxResults:operation.max_results});
+    case 'semantic_rename_preview':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.renamePreview({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,newName:operation.new_name});
+    case 'native_diff_verify':
+      return nativeDiffRuntime.verify({diffId:operation.diff_id});
+    case 'machine_fs_stat':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.stat({rootId:goal.root_id,relativePath:operation.path,hash:operation.hash});
+    case 'machine_fs_list':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.list({rootId:goal.root_id,relativePath:operation.path,cursor:operation.cursor,limit:operation.limit,hashFiles:operation.hash_files});
+    case 'machine_fs_read':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.read({rootId:goal.root_id,relativePath:operation.path,offset:operation.offset,maxBytes:operation.max_bytes,hashFile:operation.hash_file});
     case 'machine_stat':
       if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
       return machineFsRuntime.stat({ rootId:goal.root_id, relativePath:operation.path, hash:operation.hash });
@@ -605,7 +676,7 @@ async function invokeDelegatedOperation(goal, operation, runtimes) {
       return observationRuntime.systemStatus();
     case 'process_start':
       if (!processRuntime) throw new Error('process runtime unavailable');
-      return processRuntime.start({ profileId:operation.profile_id, rootId:goal.root_id, cwd:operation.cwd, args:[] });
+      return processRuntime.start({ profileId:operation.profile_id, rootId:goal.root_id, cwd:operation.cwd, args:operation.args??[] });
     case 'process_read':
       if (!processRuntime) throw new Error('process runtime unavailable');
       return processRuntime.read({ sessionId:operation.session_id, offset:operation.offset, maxBytes:operation.max_bytes });
@@ -647,7 +718,9 @@ async function verifyDelegatedEvidence(operation, result, runtimes, verifyKeyPat
 }
 async function executeDelegate({ ctx, events, goal, decisionEvent, decision, policy, runtimes, assertRunAuthority,
   signingKeyPath, verifyKeyPath }) {
-  const actionKey = `delegate-${decisionEvent.event_sha256}`;
+  const capabilityId=capabilityIdForOperation(decision.operation);
+  if(!capabilityId) throw new Error(`unsupported typed capability action '${String(decision.operation?.kind)}'`);
+  const actionKey = `capability-${decisionEvent.event_sha256}`;
   const prior = [...events].reverse().find(event => event.type === 'delegated_action_completed' && event.payload?.action_key === actionKey);
   if (prior) return { status:'completed', result:prior.payload.result, existing:true };
   const started = [...events].reverse().find(event => event.type === 'delegated_action_started' && event.payload?.action_key === actionKey);
@@ -656,7 +729,7 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
       operation_kind:decision.operation.kind });
     return { status:'paused' };
   }
-  await appendEvent(ctx,events,signingKeyPath,'delegated_action_started',{ action_key:actionKey,
+  await appendEvent(ctx,events,signingKeyPath,'delegated_action_started',{ action_key:actionKey, capability_id:capabilityId,
     decision_event_sha256:decisionEvent.event_sha256, operation:decision.operation });
   try {
     assertDelegatedIdentity(events,decision.operation);
@@ -666,7 +739,7 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
       throw new Error('delegated result exceeds autonomous context bound');
     }
     const evidence = await verifyDelegatedEvidence(decision.operation,result,runtimes,verifyKeyPath);
-    await appendEvent(ctx,events,signingKeyPath,'delegated_action_completed',{ action_key:actionKey,
+    await appendEvent(ctx,events,signingKeyPath,'delegated_action_completed',{ action_key:actionKey, capability_id:capabilityId,
       decision_event_sha256:decisionEvent.event_sha256, operation:decision.operation, result, evidence });
     return { status:'completed', result, evidence };
   } catch (error) {
@@ -729,11 +802,17 @@ async function appendPatchCommit({ctx,events,signingKeyPath,started,decisionEven
   const prior = patchCommitForAction(events,actionId);
   if (prior) return prior;
   const action = started.payload.action;
+  const verifiedPaths=[...new Set((verified.final_states??[]).flatMap(item=>[
+    typeof item?.path==='string'?item.path:null,
+    typeof item?.source_path==='string'?item.source_path:null,
+    typeof item?.destination_path==='string'?item.destination_path:null
+  ].filter(Boolean)))].sort((a,b)=>a.localeCompare(b,'en'));
   return appendEvent(ctx,events,signingKeyPath,'native_diff_committed',{
     action_id:actionId, decision_event_sha256:decisionEvent.event_sha256, diff_id:action.diff_id,
     diff_receipt_sha256:verified.receipt_sha256, mutation_epoch:started.payload.target_mutation_epoch,
     mutation_count:started.payload.mutation_count, operation_count:action.operation_count,
-    paths:action.paths, coding_receipts_verified:verified.coding_receipts_verified,
+    paths:Array.isArray(action.paths)&&action.paths.length>0?action.paths:verifiedPaths,
+    coding_receipts_verified:verified.coding_receipts_verified,
     ...(recovered ? { recovered:true } : {})
   });
 }
@@ -826,6 +905,67 @@ async function executePatch({ ctx, events, goal, state, decisionEvent, decision,
   return { status:profiles.some(item => item.status === 'paused') ? 'paused' : 'completed',
     diff_id:diffId, mutation_epoch:epoch, profiles, recovered };
 }
+async function executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId,expectedOperationCount,
+  policy,codingRuntime,nativeDiffRuntime,signingKeyPath}) {
+  let started=patchStartedForDecision(events,decisionEvent.event_sha256);
+  if(!started&&state.mutation_count+expectedOperationCount>policy.limits.max_mutations){
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason:'mutation_limit',max_mutations:policy.limits.max_mutations});
+    return {status:'paused'};
+  }
+  if(!started){
+    const coordinates=patchActionCoordinates(state);
+    const action={kind:'patch',diff_id:diffId,operation_count:expectedOperationCount,paths:[]};
+    const identity=actionIdentity({goalId:goal.goal_id,planId:coordinates.planId,planVersion:coordinates.planVersion,
+      stepId:coordinates.stepId,mutationEpoch:state.mutation_epoch,decisionEventSha:decisionEvent.event_sha256,action});
+    started=await appendEvent(ctx,events,signingKeyPath,'action_started',{
+      ...identity,decision_event_sha256:decisionEvent.event_sha256,plan_id:coordinates.planId,
+      plan_version:coordinates.planVersion,step_id:coordinates.stepId,mutation_epoch:state.mutation_epoch,
+      target_mutation_epoch:state.mutation_epoch+1,mutation_count:expectedOperationCount,action
+    });
+  }
+  const actionId=started.payload.action_id;
+  const existingCompletion=patchCompletionForAction(events,actionId);
+  if(existingCompletion){
+    const committed=patchCommitForAction(events,actionId);
+    if(!committed) throw new Error('completed prepared diff action missing native diff commit');
+    const epoch=committed.payload.mutation_epoch;
+    const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath});
+    return {status:profiles.some(item=>item.status==='paused')?'paused':'completed',diff_id:diffId,mutation_epoch:epoch,profiles,recovered:true};
+  }
+  const reconciliation=await reconcileStartedAction({startedEvent:started,journal:events,runtimes:{nativeDiffRuntime,codingRuntime}});
+  if(reconciliation.classification==='ambiguous'){
+    if(!events.some(event=>event.type==='waiting_entered'&&event.payload?.action_id===actionId)){
+      await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{reason:'ambiguous_interrupted_action',action_id:actionId,
+        decision_event_sha256:decisionEvent.event_sha256,detail:truncated(reconciliation.reason,512)});
+    }
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason:'ambiguous_interrupted_action',action_id:actionId,
+      decision_event_sha256:decisionEvent.event_sha256});
+    return {status:'paused',reason:'ambiguous_interrupted_action'};
+  }
+  let verified; let recovered=false;
+  if(reconciliation.classification==='executed_verified'){
+    recovered=true;
+    verified=await verifyPatchDiff(nativeDiffRuntime,diffId);
+    if(verified.operation_count!==expectedOperationCount) throw new Error(`prepared native diff operation count mismatch: expected ${expectedOperationCount}, verified ${verified.operation_count}`);
+    if(!events.some(event=>event.type==='action_reconciled'&&event.payload?.action_id===actionId)){
+      await appendEvent(ctx,events,signingKeyPath,'action_reconciled',{action_id:actionId,request_sha256:started.payload.request_sha256,
+        decision_event_sha256:decisionEvent.event_sha256,classification:reconciliation.classification,evidence:reconciliation.evidence});
+    }
+  }else{
+    await nativeDiffRuntime.apply({diffId,expectedOperationCount});
+    verified=await verifyPatchDiff(nativeDiffRuntime,diffId);
+    if(verified.operation_count!==expectedOperationCount) throw new Error(`prepared native diff operation count mismatch: expected ${expectedOperationCount}, verified ${verified.operation_count}`);
+  }
+  const committed=await appendPatchCommit({ctx,events,signingKeyPath,started,decisionEvent,verified,recovered});
+  if(!patchCompletionForAction(events,actionId)){
+    await appendEvent(ctx,events,signingKeyPath,'action_completed',{action_id:actionId,request_sha256:started.payload.request_sha256,
+      decision_event_sha256:decisionEvent.event_sha256,classification:'executed_verified',diff_id:diffId,
+      receipt_sha256:verified.receipt_sha256,recovered});
+  }
+  const epoch=committed.payload.mutation_epoch;
+  const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath});
+  return {status:profiles.some(item=>item.status==='paused')?'paused':'completed',diff_id:diffId,mutation_epoch:epoch,profiles,recovered};
+}
 async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath }) {
   const requiredIds = Object.entries(policy.profiles)
     .filter(([,profile]) => profile.required_for_release)
@@ -1012,7 +1152,7 @@ function r34ReasonHash(goal,decisionEvent,reason) {
     decision_event_sha256:decisionEvent.event_sha256,reason:String(reason ?? '')});
 }
 async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,policy,codingRuntime,
-  nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,assertRunAuthority,
+  nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
   signingKeyPath,verifyKeyPath}) {
   let loop=deriveLoopState(goal,events);
   if (decision.kind === 'plan_create') {
@@ -1075,7 +1215,36 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
     } else if (decision.action.kind === 'delegate') {
       outcome=await executeDelegate({ctx,events,goal,decisionEvent,
         decision:{operation:decision.action.operation},policy,
-        runtimes:{machineFsRuntime,observationRuntime,processRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
+    } else if (decision.action.kind === 'native_diff_apply') {
+      await assertRunAuthority(goal.root_id);
+      outcome=await executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId:decision.action.diff_id,
+        expectedOperationCount:decision.action.expected_operation_count,policy,codingRuntime,nativeDiffRuntime,signingKeyPath});
+    } else if (['machine_fs_mkdir','machine_fs_move','machine_fs_delete'].includes(decision.action.kind)) {
+      await assertRunAuthority(goal.root_id);
+      if(!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      let operations;
+      if(decision.action.kind==='machine_fs_mkdir') {
+        operations=[{kind:'mkdir',path:decision.action.path}];
+      } else if(decision.action.kind==='machine_fs_move') {
+        operations=[{kind:'move',source_path:decision.action.source_path,destination_path:decision.action.destination_path,
+          expected_source_identity:decision.action.expected_source_identity}];
+      } else {
+        const topology=await machineFsRuntime.state({rootId:goal.root_id,relativePath:decision.action.path});
+        if(!topology.exists||topology.identity_sha256!==decision.action.expected_source_identity) throw new Error(`machine fs delete identity precondition mismatch '${decision.action.path}'`);
+        if(topology.kind==='directory') operations=[{kind:'rmdir',path:decision.action.path,expected_source_identity:decision.action.expected_source_identity}];
+        else {
+          const file=await codingRuntime.fileState({rootId:goal.root_id,relativePath:decision.action.path});
+          if(!file.exists||!SHA256_RE.test(file.sha256??'')) throw new Error(`machine fs delete file precondition unavailable '${decision.action.path}'`);
+          operations=[{kind:'delete',path:decision.action.path,expected_sha256:file.sha256}];
+        }
+      }
+      outcome=await executePatch({ctx,events,goal,state,decisionEvent,decision:{operations,summary:`R36 ${decision.action.kind}`},
+        nativeDiffRuntime,policy,codingRuntime,signingKeyPath});
+    } else if (capabilityIdForOperation(decision.action)) {
+      outcome=await executeDelegate({ctx,events,goal,decisionEvent,
+        decision:{operation:decision.action},policy,
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
     } else {
       throw new Error(`unsupported R34 action '${String(decision.action.kind)}'`);
     }
@@ -1087,10 +1256,10 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
       evidence_head:loop.evidence_head_sha256,release_ready:false,
       acceptance_failures:afterState.observations.filter(item=>item?.passed===false).length};
     const evidence={
-      native_diff_verified:decision.action.kind === 'patch' && afterState.mutation_epoch > state.mutation_epoch,
+      native_diff_verified:['patch','native_diff_apply','machine_fs_mkdir','machine_fs_move','machine_fs_delete'].includes(decision.action.kind) && afterState.mutation_epoch > state.mutation_epoch,
       new_profile_evidence:decision.action.kind === 'run_profile' && outcome.status === 'passed' &&
         afterState.observations.length > state.observations.length,
-      diagnostic_narrowed:decision.action.kind === 'delegate' && afterState.observations.length > state.observations.length,
+      diagnostic_narrowed:(decision.action.kind === 'delegate' || capabilityIdForOperation(decision.action)) && afterState.observations.length > state.observations.length,
       interrupted_action_recovered:outcome.recovered === true
     };
     const progress=judgeProgress({before,after,decision,evidence});
@@ -1179,12 +1348,12 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
 }
 
 async function executeDecision({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
-  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, assertRunAuthority,
+  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, semanticRuntime, assertRunAuthority,
   signingKeyPath, verifyKeyPath }) {
   const decision = decisionEvent.decision;
   if (decision?.schema === 'deadbyte.autonomous-decision.v2') {
     const outcome=await executeR34Decision({ctx,events,goal,state,decisionEvent,decision,policy,codingRuntime,
-      nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,assertRunAuthority,
+      nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
       signingKeyPath,verifyKeyPath});
     await appendEvent(ctx,events,signingKeyPath,'decision_completed',{
       decision_event_sha256:decisionEvent.event_sha256,action:decision.kind,
@@ -1269,9 +1438,10 @@ function isAuthorityUnavailable(error) {
 }
 
 export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRuntime, machineFsRuntime = null,
-  observationRuntime = null, processRuntime = null, signingKeyPath, verifyKeyPath }) {
+  observationRuntime = null, processRuntime = null, semanticRuntime = 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});
   async function sessionStatus() {
     const autonomous = await autonomousSessionStatus(policy);
     const coding = await codingRuntime.sessionStatus();
@@ -1488,7 +1658,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           try {
             outcome = await executeDecision({ ctx,events:journal,goal,state,
               decisionEvent:state.pending_decision,policy,codingRuntime,nativeDiffRuntime,machineFsRuntime,
-              observationRuntime,processRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath });
+              observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath });
           } catch (error) {
             const loop=loopStateOrNull(goal,journal);
             if (!loop || loop.pending_action || !isAuthorityUnavailable(error)) throw error;
@@ -1512,7 +1682,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           }
           continue;
         }
-        const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,
+        const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
           signingKeyPath,plannerResponse:suppliedResponse });
         suppliedResponse = null;
         if (accepted?.needs_planner) {

package/src/capability-benchmark-runner.mjs

@@ -4,7 +4,7 @@ import { readdir, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { canonicalJson } from './canonical-json.mjs';
-import { buildCapabilityBenchmark } from './capability-benchmark.mjs';
+import { buildCapabilityBenchmark, buildR36CapabilityBenchmark } from './capability-benchmark.mjs';
 
 const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
 const TEST_TIMEOUT_MS=180_000;
@@ -106,3 +106,88 @@ export async function runCapabilityBenchmark({rootUrl,definitions=benchmarkCaseD
   }
   return buildCapabilityBenchmark({suite_id:'r35-offline-v1',cases});
 }
+
+export const R36_BENCHMARK_CASE_IDS=Object.freeze([
+  'repository_tree_exploration','literal_content_search','regex_content_search','filename_path_search',
+  'deterministic_search_paging_cancel','bounded_multi_file_read','rich_stat_reparse_handling','stale_edit_race_rejection',
+  'transactional_multi_file_native_diff','topology_mkdir_move_delete_rollback','semantic_typescript_navigation',
+  'semantic_python_navigation','semantic_rust_navigation','semantic_cpp_navigation','diagnostics_normalization',
+  'implementation_lookup','cross_file_rename_transaction','long_process_lifecycle','policy_defined_process_action',
+  'process_crash_reconciliation','autonomous_failing_test_repair','autonomous_search_semantic_patch_test',
+  'release_gate_finish_without_evidence_refusal','provider_bridge_interruption_recovery','remote_result_replay_deduplication',
+  'compact_connector_capability_closure','live_log_request_before_result','live_log_redaction',
+  'forged_stale_receipt_rejection','rollback_r35_restore_r36'
+]);
+
+const r36Def=(case_id,purpose,test_files,fixture_files,{test_name_pattern=null,pass_witness=null,round_trips=2,stale_rejected=false,recovery_success=true,release_gate_result='not_applicable'}={})=>Object.freeze({
+  case_id,purpose,test_files:Object.freeze([...test_files]),fixture_files:Object.freeze([...fixture_files]),
+  ...(test_name_pattern?{test_name_pattern}:{}),...(pass_witness?{pass_witness}:{}),round_trips,stale_rejected,recovery_success,
+  capability_reachable:true,evidence_verified:true,release_gate_result
+});
+
+const R36_DEFINITIONS=Object.freeze([
+  r36Def('repository_tree_exploration','repository tree exploration',['test/coding-plane.test.mjs'],['test/coding-plane.test.mjs'],{round_trips:1}),
+  r36Def('literal_content_search','literal content search',['test/coding-search-r36.test.mjs'],['test/coding-search-r36.test.mjs'],{test_name_pattern:'R36 regex search returns multiple matches',pass_witness:'R36 regex search returns multiple matches',round_trips:2}),
+  r36Def('regex_content_search','regex content search',['test/coding-search-r36.test.mjs'],['test/coding-search-r36.test.mjs'],{test_name_pattern:'R36 regex search returns multiple matches',pass_witness:'R36 regex search returns multiple matches',round_trips:2}),
+  r36Def('filename_path_search','filename/path search',['test/coding-search-r36.test.mjs'],['test/coding-search-r36.test.mjs'],{test_name_pattern:'R36 path search does not decode',pass_witness:'R36 path search does not decode',round_trips:2}),
+  r36Def('deterministic_search_paging_cancel','deterministic paging/cancel',['test/coding-search-r36.test.mjs','test/observation-runtime.test.mjs'],['test/coding-search-r36.test.mjs','test/observation-runtime.test.mjs'],{round_trips:4}),
+  r36Def('bounded_multi_file_read','bounded multi-file read',['test/multi-file-read.test.mjs'],['test/multi-file-read.test.mjs'],{round_trips:1}),
+  r36Def('rich_stat_reparse_handling','rich stat and reparse denial',['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],{test_name_pattern:'(?:R36 coding stat exposes|R36 Native Diff V2 denies topology through reparse)',round_trips:3,stale_rejected:true}),
+  r36Def('stale_edit_race_rejection','stale-edit race rejection',['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],{test_name_pattern:'(?:rejects mutation when lease is absent or precondition is stale|rejects stale move identity)',round_trips:3,stale_rejected:true}),
+  r36Def('transactional_multi_file_native_diff','transactional multi-file Native Diff',['test/native-diff.test.mjs'],['test/native-diff.test.mjs'],{test_name_pattern:'native diff commits exact preconditioned edits',pass_witness:'native diff commits exact preconditioned edits',round_trips:4,stale_rejected:true}),
+  r36Def('topology_mkdir_move_delete_rollback','topology transaction and rollback',['test/native-diff-topology-r36.test.mjs'],['test/native-diff-topology-r36.test.mjs'],{round_trips:5,stale_rejected:true}),
+  r36Def('semantic_typescript_navigation','TypeScript symbol navigation',['test/semantic-code.test.mjs'],['test/semantic-code.test.mjs','test/fixtures/semantic/typescript'],{round_trips:4,stale_rejected:true}),
+  r36Def('semantic_python_navigation','Python symbol navigation through hermetic LSP adapter',['test/capability-benchmark-semantic-r36.test.mjs'],['test/capability-benchmark-semantic-r36.test.mjs','test/fixtures/lsp-framed-server.mjs'],{test_name_pattern:'R36 benchmark Python symbol navigation',pass_witness:'R36 benchmark Python symbol navigation',round_trips:4}),
+  r36Def('semantic_rust_navigation','Rust symbol navigation through hermetic LSP adapter',['test/capability-benchmark-semantic-r36.test.mjs'],['test/capability-benchmark-semantic-r36.test.mjs','test/fixtures/lsp-framed-server.mjs'],{test_name_pattern:'R36 benchmark Rust symbol navigation',pass_witness:'R36 benchmark Rust symbol navigation',round_trips:4}),
+  r36Def('semantic_cpp_navigation','C/C++ symbol navigation through hermetic LSP adapter',['test/capability-benchmark-semantic-r36.test.mjs'],['test/capability-benchmark-semantic-r36.test.mjs','test/fixtures/lsp-framed-server.mjs'],{test_name_pattern:'R36 benchmark Cpp symbol navigation',pass_witness:'R36 benchmark Cpp symbol navigation',round_trips:4}),
+  r36Def('diagnostics_normalization','diagnostics normalization',['test/semantic-r36-rename.test.mjs'],['test/semantic-r36-rename.test.mjs'],{test_name_pattern:'R36 TypeScript diagnostics carry',pass_witness:'R36 TypeScript diagnostics carry',round_trips:2}),
+  r36Def('implementation_lookup','implementation lookup',['test/semantic-r36-rename.test.mjs'],['test/semantic-r36-rename.test.mjs'],{test_name_pattern:'R36 TypeScript implementations normalize',pass_witness:'R36 TypeScript implementations normalize',round_trips:2}),
+  r36Def('cross_file_rename_transaction','cross-file rename through Native Diff',['test/semantic-r36-rename.test.mjs'],['test/semantic-r36-rename.test.mjs'],{test_name_pattern:'R36 cross-file rename preview',pass_witness:'R36 cross-file rename preview',round_trips:5,stale_rejected:true}),
+  r36Def('long_process_lifecycle','long process start/output/status/terminate',['test/process-longrun-r36.test.mjs','test/process-runtime.test.mjs'],['test/process-longrun-r36.test.mjs','test/process-runtime.test.mjs'],{test_name_pattern:'(?:R36 long process returns before exit|R31 runtime lists, reports and terminates)',round_trips:6,recovery_success:true}),
+  r36Def('policy_defined_process_action','policy-defined named process action',['test/process-runtime.test.mjs'],['test/process-runtime.test.mjs'],{test_name_pattern:'R32 runtime executes one policy-defined named action',pass_witness:'R32 runtime executes one policy-defined named action',round_trips:3}),
+  r36Def('process_crash_reconciliation','terminal process journal/output recovery',['test/process-longrun-r36.test.mjs'],['test/process-longrun-r36.test.mjs'],{test_name_pattern:'R36 terminal process session is recovered',pass_witness:'R36 terminal process session is recovered',round_trips:4,recovery_success:true}),
+  r36Def('autonomous_failing_test_repair','autonomous failing-test critic/repair/release',['test/autonomous-r34-e2e.test.mjs','test/autonomous-loop-v2.test.mjs'],['test/autonomous-r34-e2e.test.mjs','test/autonomous-loop-v2.test.mjs','test/helpers/autonomous-r34-fixture.mjs'],{test_name_pattern:'(?:multi-step fail replan repair finish|failed VERIFY enters CRITIC|REPAIR must change)',round_trips:8,stale_rejected:true,release_gate_result:'passed'}),
+  r36Def('autonomous_search_semantic_patch_test','capability-aware planner inspection/mutation loop',['test/autonomous-capability-r36.test.mjs','test/semantic-r36-rename.test.mjs','test/autonomous-r34-e2e.test.mjs'],['test/autonomous-capability-r36.test.mjs','test/semantic-r36-rename.test.mjs','test/autonomous-r34-e2e.test.mjs','test/helpers/autonomous-r34-fixture.mjs'],{test_name_pattern:'(?:planner parses first-class capability actions|typed native_diff_apply|cross-file rename preview|multi-step fail replan repair finish)',round_trips:8,stale_rejected:true,release_gate_result:'passed'}),
+  r36Def('release_gate_finish_without_evidence_refusal','finish claim cannot bypass objective release evidence',['test/autonomous-r34-e2e.test.mjs'],['test/autonomous-r34-e2e.test.mjs'],{test_name_pattern:'R34 finish is blocked while the active plan is incomplete',pass_witness:'R34 finish is blocked while the active plan is incomplete',round_trips:3,release_gate_result:'blocked'}),
+  r36Def('provider_bridge_interruption_recovery','provider circuit and remote-session interruption recovery',['test/provider-circuit.test.mjs','test/remote-session-cli.test.mjs'],['test/provider-circuit.test.mjs','test/remote-session-cli.test.mjs'],{test_name_pattern:'(?:OPEN becomes HALF_OPEN|bare remote recovers a stale crashed session)',round_trips:4,recovery_success:true}),
+  r36Def('remote_result_replay_deduplication','remote result replay/dedupe',['test/remote-result-journal.test.mjs','test/remote-session-cli.test.mjs'],['test/remote-result-journal.test.mjs','test/remote-session-cli.test.mjs'],{test_name_pattern:'(?:remote result journal is monotonic|remote --resume replays only terminal results)',round_trips:4,recovery_success:true}),
+  r36Def('compact_connector_capability_closure','compact connector <=42 with production capability closure',['test/compact-catalog-r36.test.mjs','test/capability-ledger-r36.test.mjs'],['test/compact-catalog-r36.test.mjs','test/capability-ledger-r36.test.mjs'],{test_name_pattern:'(?:real compact stdio catalog stays <=42|compact closure covers every production non-host capability)',round_trips:2}),
+  r36Def('live_log_request_before_result','live activity request-before-result ordering',['test/remote-live-log-recovery-r36.test.mjs'],['test/remote-live-log-recovery-r36.test.mjs','src/remote-live-log.mjs'],{test_name_pattern:'R36 live activity tracker prints RUN before terminal result',pass_witness:'R36 live activity tracker prints RUN before terminal result',round_trips:2,recovery_success:true}),
+  r36Def('live_log_redaction','live activity secret/payload redaction',['test/remote-live-log-r36.test.mjs','test/remote-session-cli.test.mjs'],['test/remote-live-log-r36.test.mjs','test/remote-session-cli.test.mjs','src/remote-live-log.mjs'],{test_name_pattern:'compact live activity shows request context without payload or secret values',pass_witness:'compact live activity shows request context without payload or secret values',round_trips:1}),
+  r36Def('forged_stale_receipt_rejection','forged/stale receipt and precondition rejection',['test/autonomous-r34-e2e.test.mjs','test/coding-plane-adversarial.test.mjs'],['test/autonomous-r34-e2e.test.mjs','test/coding-plane-adversarial.test.mjs'],{test_name_pattern:'(?:forged profile receipt substitution|signed autonomous journal tamper|coding task adopts a signed command receipt)',round_trips:4,stale_rejected:true,recovery_success:true}),
+  r36Def('rollback_r35_restore_r36','hermetic signed predecessor rollback and exact slot restore mechanism',['test/runtime-self-update.test.mjs','test/release-slot.test.mjs'],['test/runtime-self-update.test.mjs','test/release-slot.test.mjs'],{test_name_pattern:'(?:R31 explicit rollback restores the exact signed prior pointer|release slot materialization copies only manifest-bound files)',round_trips:5,recovery_success:true})
+]);
+
+export function r36BenchmarkCaseDefinitions(){
+  return R36_DEFINITIONS.map(item=>({...structuredClone(item),fixture_files:['bench/fixtures/corpus.json','bench/fixtures/r36/case-map.json',...item.fixture_files]}));
+}
+
+function hasPassingWitness(stdout,witness){
+  if(!witness) return true;
+  const text=Buffer.isBuffer(stdout)?stdout.toString('utf8'):String(stdout??'');
+  return text.split(/\r?\n/).some(line=>line.includes(witness)&&!/\bSKIP\b/i.test(line)&&/(?:✔|\bok\b)/i.test(line));
+}
+
+export async function runR36CapabilityBenchmark({rootUrl,definitions=r36BenchmarkCaseDefinitions(),env={},timeoutMs=TEST_TIMEOUT_MS}={}){
+  const root=typeof rootUrl==='string'?path.resolve(rootUrl):fileURLToPath(rootUrl??new URL('../',import.meta.url));
+  if(!Array.isArray(definitions)||definitions.length<1) throw new Error('R36 benchmark definitions invalid');
+  if(!Number.isInteger(timeoutMs)||timeoutMs<1000||timeoutMs>600000) throw new Error('R36 benchmark timeout invalid');
+  const cases=[];
+  for(const definition of definitions){
+    const fixture_sha256=await fixtureIdentityForCase({rootUrl:root,definition});
+    let result;
+    try{result=await runNodeTest({root,definition,env,timeoutMs});}
+    catch(error){result={exit_code:null,timed_out:false,error:String(error),stdout:Buffer.alloc(0),stderr:Buffer.alloc(0),bytes:0,elapsed_ms:0};}
+    const witnessOk=hasPassingWitness(result.stdout,definition.pass_witness??null);
+    const correct=result.exit_code===0&&!result.timed_out&&!result.error&&witnessOk;
+    const evidence={schema:'deadbyte.r36-benchmark-case-evidence.v1',case_id:definition.case_id,exit_code:result.exit_code,
+      timed_out:result.timed_out===true,signal:result.signal??null,error:result.error??null,pass_witness:definition.pass_witness??null,
+      pass_witness_observed:witnessOk,stdout_sha256:sha256(result.stdout??Buffer.alloc(0)),stderr_sha256:sha256(result.stderr??Buffer.alloc(0))};
+    cases.push({case_id:definition.case_id,fixture_sha256,correct,round_trips:definition.round_trips,
+      bytes_returned:result.bytes??0,elapsed_ms:result.elapsed_ms??0,stale_rejected:correct&&definition.stale_rejected===true,
+      recovery_success:correct&&definition.recovery_success===true,duplicate_side_effects:correct?0:1,
+      capability_reachable:correct&&definition.capability_reachable===true,evidence_verified:correct&&definition.evidence_verified===true,
+      release_gate_result:correct?definition.release_gate_result:'blocked',evidence_sha256:sha256(Buffer.from(canonicalJson(evidence),'utf8'))});
+  }
+  return buildR36CapabilityBenchmark({suite_id:'r36-production-coding-v1',cases});
+}

package/src/capability-benchmark.mjs

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { canonicalJson } from './canonical-json.mjs';
 
 export const CAPABILITY_BENCHMARK_SCHEMA='deadbyte.r35-capability-benchmark.v1';
+export const R36_CAPABILITY_BENCHMARK_SCHEMA='deadbyte.r36-capability-benchmark.v1';
 const HEX64=/^[0-9a-f]{64}$/;
 const CASE_ID=/^[A-Za-z0-9._-]{1,96}$/;
 const SUITE_ID=/^[A-Za-z0-9._-]{1,96}$/;
@@ -48,3 +49,47 @@ export function buildCapabilityBenchmark({suite_id:rawSuiteId,cases:rawCases}={}
     observation_sha256:sha256(observation)
   });
 }
+
+const R36_RELEASE_GATE_RESULTS=new Set(['passed','blocked','not_applicable']);
+export function normalizeR36BenchmarkCase(raw){
+  const base=normalizeBenchmarkCase(raw);
+  if(typeof raw.capability_reachable!=='boolean') throw new Error('benchmark capability_reachable invalid');
+  if(typeof raw.evidence_verified!=='boolean') throw new Error('benchmark evidence_verified invalid');
+  if(typeof raw.release_gate_result!=='string'||!R36_RELEASE_GATE_RESULTS.has(raw.release_gate_result)) throw new Error('benchmark release_gate_result invalid');
+  return Object.freeze({...base,
+    capability_reachable:raw.capability_reachable,
+    evidence_verified:raw.evidence_verified,
+    release_gate_result:raw.release_gate_result
+  });
+}
+
+export function buildR36CapabilityBenchmark({suite_id:rawSuiteId,cases:rawCases}={}){
+  if(typeof rawSuiteId!=='string'||!SUITE_ID.test(rawSuiteId)) throw new Error('benchmark suite_id invalid');
+  if(!Array.isArray(rawCases)||rawCases.length<1||rawCases.length>128) throw new Error('benchmark cases invalid');
+  const cases=rawCases.map(normalizeR36BenchmarkCase).sort((a,b)=>a.case_id.localeCompare(b.case_id));
+  const seen=new Set();
+  for(const item of cases){if(seen.has(item.case_id)) throw new Error(`duplicate case '${item.case_id}'`);seen.add(item.case_id);}
+  const fixtureIdentity={schema:'deadbyte.r36-capability-fixtures.v1',suite_id:rawSuiteId,
+    fixtures:cases.map(item=>({case_id:item.case_id,fixture_sha256:item.fixture_sha256}))};
+  const fixture_identity_sha256=sha256(fixtureIdentity);
+  const observation={schema:R36_CAPABILITY_BENCHMARK_SCHEMA,suite_id:rawSuiteId,fixture_identity_sha256,cases};
+  const capability_closure=cases.every(item=>item.capability_reachable);
+  const evidence_closure=cases.every(item=>item.evidence_verified);
+  const verdictIdentity={
+    schema:'deadbyte.r36-capability-verdict.v1',suite_id:rawSuiteId,fixture_identity_sha256,
+    cases:cases.map(item=>({
+      case_id:item.case_id,fixture_sha256:item.fixture_sha256,correct:item.correct,
+      stale_rejected:item.stale_rejected,recovery_success:item.recovery_success,
+      duplicate_side_effects:item.duplicate_side_effects,capability_reachable:item.capability_reachable,
+      evidence_verified:item.evidence_verified,release_gate_result:item.release_gate_result
+    }))
+  };
+  return Object.freeze({
+    ...observation,
+    capability_closure,
+    evidence_closure,
+    overall_correct:cases.every(item=>item.correct)&&capability_closure&&evidence_closure,
+    verdict_identity_sha256:sha256(verdictIdentity),
+    observation_sha256:sha256(observation)
+  });
+}