deadbyte-mcp 0.9.0 → 0.11.0

package/src/autonomous-runtime.mjs

@@ -11,6 +11,11 @@ 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';
+import { deriveAgentMemory } from './agent-memory-plane.mjs';
+import { effectIdentity, loopGuardDisposition, bindEffectCompletion } from './effect-ledger.mjs';
+import { createWorkerScheduler } from './worker-scheduler.mjs';
+import { issueObservationLease, verifyObservationLease } from './observation-lease.mjs';
 
 export const AUTONOMOUS_GOAL_SCHEMA = 'deadbyte.autonomous-goal.v1';
 export const AUTONOMOUS_EVENT_SCHEMA = 'deadbyte.autonomous-event.v1';
@@ -163,6 +168,22 @@ async function acquireLock(ctx) {
   throw new Error('autonomous lock acquisition failed');
 }
 async function releaseLock(ctx) { await rm(ctx.lockPath,{force:true}); }
+async function runLockStatus(ctx) {
+  let parsed;
+  try { parsed = JSON.parse(await readFile(ctx.lockPath,'utf8')); }
+  catch (error) {
+    if (error?.code === 'ENOENT') return { run_busy:false, run_owner_pid:null, run_lock_created_at_utc:null };
+    throw new Error('autonomous lock malformed');
+  }
+  if (parsed?.schema !== 'deadbyte.autonomous-lock.v1' || parsed?.goal_id !== path.basename(ctx.dir) ||
+      !Number.isInteger(parsed?.pid) || parsed.pid < 1 || typeof parsed?.created_at_utc !== 'string' || !parsed.created_at_utc) {
+    throw new Error('autonomous lock malformed');
+  }
+  const alive=await processExists(parsed.pid);
+  return alive
+    ? { run_busy:true, run_owner_pid:parsed.pid, run_lock_created_at_utc:parsed.created_at_utc }
+    : { run_busy:false, run_owner_pid:null, run_lock_created_at_utc:null };
+}
 async function readCancel(ctx, verifyKeyPath) {
   if (!await exists(ctx.cancelPath)) return null;
   const parsed = JSON.parse(await readFile(ctx.cancelPath,'utf8'));
@@ -318,17 +339,39 @@ 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, events, codingRuntime, capabilityManifest) {
   const tree = await codingRuntime.tree({ rootId:goal.root_id, path:'.', maxDepth:4, maxEntries:600 });
+  const memory=deriveAgentMemory(events,{maxArchival:24});
   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,
     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 +382,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,events,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 +519,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 +560,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 +600,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 +625,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 +697,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 +739,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 +750,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 +760,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) {
@@ -676,14 +770,36 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
   }
 }
 
-async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy, codingRuntime, signingKeyPath }) {
+async function executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,actionKey,profileId,policy,codingRuntime,signingKeyPath,r34ResumePhase=null}) {
+  if(!workerScheduler) throw new Error('R37 worker scheduler unavailable');
+  const taskId=`${goal.goal_id}:${actionKey}:${profileId}`;
+  const lease=workerScheduler.acquire({taskId,workerClass:'profile',cpuUnits:1,memoryMb:256});
+  await appendEvent(ctx,events,signingKeyPath,'worker_lease_acquired',{
+    lease_id:lease.lease_id,task_id:lease.task_id,worker_class:lease.worker_class,profile_id:profileId,
+    attempt:lease.attempt,cpu_units:lease.cpu_units,memory_mb:lease.memory_mb,expires_at_ms:lease.expires_at_ms
+  });
+  let outcomeStatus='failed';
+  try {
+    const result=await executeProfile({ctx,events,goalId:goal.goal_id,actionKey,profileId,epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase});
+    outcomeStatus=result.status;
+    return result;
+  } finally {
+    const released=workerScheduler.release(lease.lease_id,{status:outcomeStatus});
+    await appendEvent(ctx,events,signingKeyPath,'worker_lease_released',{
+      lease_id:lease.lease_id,task_id:lease.task_id,worker_class:lease.worker_class,profile_id:profileId,
+      status:released.lease.status,released_at_ms:released.lease.released_at_ms
+    });
+  }
+}
+
+async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy, codingRuntime, signingKeyPath, workerScheduler }) {
   const profileIds = Object.entries(policy.profiles)
     .filter(([,profile]) => profile.run_after_mutation)
     .map(([id]) => id);
   const results = [];
   for (const profileId of profileIds) {
-    const result = await executeProfile({ ctx,events,goalId:goal.goal_id,actionKey:`${actionKey}:${profileId}`,
-      profileId,epoch,policy,codingRuntime,signingKeyPath });
+    const result = await executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,
+      actionKey:`${actionKey}:${profileId}`,profileId,policy,codingRuntime,signingKeyPath});
     results.push({ profile_id:profileId, status:result.status, observation:result.observation });
     if (result.status === 'paused') break;
   }
@@ -729,16 +845,22 @@ 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 } : {})
   });
 }
 async function executePatch({ ctx, events, goal, state, decisionEvent, decision, nativeDiffRuntime,
-  policy, codingRuntime, signingKeyPath, actionCoordinatesOverride = null }) {
+  policy, codingRuntime, signingKeyPath, workerScheduler, actionCoordinatesOverride = null }) {
   let started = patchStartedForDecision(events,decisionEvent.event_sha256);
   if (!started && state.mutation_count + decision.operations.length > policy.limits.max_mutations) {
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
@@ -774,7 +896,7 @@ async function executePatch({ ctx, events, goal, state, decisionEvent, decision,
     if (!committed) throw new Error('completed patch 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 });
+      actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath,workerScheduler });
     return { status:profiles.some(item => item.status === 'paused') ? 'paused' : 'completed',
       diff_id:diffId, mutation_epoch:epoch, profiles, recovered:true };
   }
@@ -822,11 +944,72 @@ async function executePatch({ ctx, events, goal, state, decisionEvent, decision,
   }
   const epoch = committed.payload.mutation_epoch;
   const profiles = await runMutationProfiles({ ctx,events,goal,epoch,
-    actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath });
+    actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath,workerScheduler });
   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 }) {
+async function executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId,expectedOperationCount,
+  policy,codingRuntime,nativeDiffRuntime,signingKeyPath,workerScheduler}) {
+  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,workerScheduler});
+    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,workerScheduler});
+  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, workerScheduler }) {
   const requiredIds = Object.entries(policy.profiles)
     .filter(([,profile]) => profile.required_for_release)
     .map(([id]) => id);
@@ -837,9 +1020,9 @@ async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, co
       results.push({ profile_id:profileId, status:'passed', observation:existing, existing:true });
       continue;
     }
-    const result = await executeProfile({ ctx,events,goalId:goal.goal_id,
-      actionKey:`release-${state.mutation_epoch}:${profileId}`, profileId,
-      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath });
+    const result = await executeProfileWithLease({workerScheduler,ctx,events,goal,
+      actionKey:`release-${state.mutation_epoch}:${profileId}`,profileId,
+      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath});
     results.push({ profile_id:profileId, ...result });
     if (result.status === 'paused') break;
   }
@@ -1012,8 +1195,8 @@ 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,
-  signingKeyPath,verifyKeyPath}) {
+  nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
+  signingKeyPath,verifyKeyPath,workerScheduler}) {
   let loop=deriveLoopState(goal,events);
   if (decision.kind === 'plan_create') {
     if (loop.phase !== 'PLAN' || loop.plan) throw new Error('R34 plan_create requires empty PLANNING state');
@@ -1056,7 +1239,7 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
       try {
         outcome=await executePatch({ctx,events,goal,state,decisionEvent,
           decision:{operations:decision.action.operations,summary:`R34 ${currentStep.step_id}`},nativeDiffRuntime,
-          policy,codingRuntime,signingKeyPath,actionCoordinatesOverride:{planId:loop.plan_id,
+          policy,codingRuntime,signingKeyPath,workerScheduler,actionCoordinatesOverride:{planId:loop.plan_id,
             planVersion:loop.plan_version,stepId:currentStep.step_id}});
       } catch (error) {
         const detail=truncated(error,512);
@@ -1069,13 +1252,42 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
       }
     } else if (decision.action.kind === 'run_profile') {
       await assertRunAuthority(goal.root_id);
-      outcome=await executeProfile({ctx,events,goalId:goal.goal_id,
+      outcome=await executeProfileWithLease({workerScheduler,ctx,events,goal,
         actionKey:`r34-${decisionEvent.event_sha256}`,profileId:decision.action.profile_id,
         epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase:loop.phase});
     } 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,workerScheduler});
+    } 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,workerScheduler});
+    } 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 +1299,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});
@@ -1178,14 +1390,14 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
   throw new Error(`unsupported R34 decision '${String(decision.kind)}'`);
 }
 
-async function executeDecision({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
-  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, assertRunAuthority,
-  signingKeyPath, verifyKeyPath }) {
+async function executeDecisionCore({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
+  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, semanticRuntime, assertRunAuthority,
+  signingKeyPath, verifyKeyPath, workerScheduler }) {
   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,
-      signingKeyPath,verifyKeyPath});
+      nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
+      signingKeyPath,verifyKeyPath,workerScheduler});
     await appendEvent(ctx,events,signingKeyPath,'decision_completed',{
       decision_event_sha256:decisionEvent.event_sha256,action:decision.kind,
       outcome_status:outcome.status ?? 'completed'
@@ -1215,15 +1427,15 @@ async function executeDecision({ ctx, events, goal, state, decisionEvent, policy
   } else if (decision.action === 'patch') {
     await assertRunAuthority(goal.root_id);
     outcome = await executePatch({ ctx,events,goal,state,decisionEvent,decision,nativeDiffRuntime,
-      policy,codingRuntime,signingKeyPath });
+      policy,codingRuntime,signingKeyPath,workerScheduler });
   } else if (decision.action === 'delegate') {
     outcome = await executeDelegate({ ctx,events,goal,decisionEvent,decision,policy,
       runtimes:{ machineFsRuntime,observationRuntime,processRuntime },assertRunAuthority,signingKeyPath,verifyKeyPath });
   } else if (decision.action === 'run_profile') {
     await assertRunAuthority(goal.root_id);
-    outcome = await executeProfile({ ctx,events,goalId:goal.goal_id,
-      actionKey:`planner-${decisionEvent.event_sha256}`, profileId:decision.profile_id,
-      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath });
+    outcome = await executeProfileWithLease({workerScheduler,ctx,events,goal,
+      actionKey:`planner-${decisionEvent.event_sha256}`,profileId:decision.profile_id,
+      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath});
   } else if (decision.action === 'pause') {
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
       reason:decision.reason, planner_summary:decision.summary
@@ -1245,6 +1457,83 @@ async function executeDecision({ ctx, events, goal, state, decisionEvent, policy
   return outcome;
 }
 
+function effectDescriptor(goal,state,events,decisionEvent){
+  const decision=decisionEvent?.decision;
+  let action=null,coordinates=null;
+  if(decision?.schema==='deadbyte.autonomous-decision.v2'&&decision.kind==='act'){
+    const loop=deriveLoopState(goal,events);
+    if(!loop.plan_id||!loop.current_step?.step_id) return null;
+    action=decision.action;
+    coordinates={planId:loop.plan_id,stepId:loop.current_step.step_id};
+  }else if(['patch','delegate','run_profile'].includes(decision?.action)){
+    coordinates=patchActionCoordinates(state);
+    if(decision.action==='patch') action={kind:'patch',operations:decision.operations};
+    else if(decision.action==='delegate') action={kind:'delegate',operation:decision.operation};
+    else action={kind:'run_profile',profile_id:decision.profile_id};
+  }
+  if(!action||!coordinates) return null;
+  const observed=[...events].reverse().find(event=>[
+    'inspection_completed','inspect_completed','profile_completed','delegated_action_completed','observation_completed'
+  ].includes(event.type)&&SHA256_RE.test(event.event_sha256??''))?.event_sha256 ?? state.journal_head_sha256;
+  return {action,planId:coordinates.planId,stepId:coordinates.stepId,observationHeadSha256:observed};
+}
+
+async function executeDecision(args) {
+  const {ctx,events,goal,state,decisionEvent,signingKeyPath}=args;
+  const descriptor=effectDescriptor(goal,state,events,decisionEvent);
+  if(!descriptor) return executeDecisionCore(args);
+  const lease=issueObservationLease({goalId:goal.goal_id,mutationEpoch:state.mutation_epoch,
+    observations:[{event_sha256:descriptor.observationHeadSha256}],ttlMs:120000});
+  verifyObservationLease(lease,{goalId:goal.goal_id,currentMutationEpoch:state.mutation_epoch,
+    observationHeadSha256:descriptor.observationHeadSha256});
+  if(!events.some(event=>event.type==='observation_lease_issued'&&event.payload?.lease_id===lease.lease_id)){
+    await appendEvent(ctx,events,signingKeyPath,'observation_lease_issued',{
+      lease_id:lease.lease_id,mutation_epoch:lease.mutation_epoch,
+      observation_head_sha256:lease.observation_head_sha256,expires_at_ms:lease.expires_at_ms,
+      decision_event_sha256:decisionEvent.event_sha256
+    });
+  }
+  const effect=effectIdentity({goalId:goal.goal_id,planId:descriptor.planId,stepId:descriptor.stepId,
+    mutationEpoch:state.mutation_epoch,action:descriptor.action,observationHeadSha256:descriptor.observationHeadSha256});
+  const guard=loopGuardDisposition(events,effect,{maxRepeats:2,window:48});
+  if(!guard.allowed){
+    await appendEvent(ctx,events,signingKeyPath,'effect_guard_blocked',{
+      effect_id:effect.effect_id,fingerprint:effect.fingerprint,repeated_count:guard.repeated_count,
+      max_repeats:guard.max_repeats,reason:guard.reason,decision_event_sha256:decisionEvent.event_sha256
+    });
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason:'effect_repeat_limit',
+      effect_id:effect.effect_id,fingerprint:effect.fingerprint});
+    return {status:'paused',reason:'effect_repeat_limit'};
+  }
+  if(!events.some(event=>event.type==='effect_started'&&event.payload?.effect_id===effect.effect_id)){
+    await appendEvent(ctx,events,signingKeyPath,'effect_started',{
+      ...effect,observation_lease_id:lease.lease_id,decision_event_sha256:decisionEvent.event_sha256
+    });
+  }
+  try{
+    const outcome=await executeDecisionCore(args);
+    if(!events.some(event=>['effect_completed','effect_failed'].includes(event.type)&&event.payload?.effect_id===effect.effect_id)){
+      const completion=bindEffectCompletion(effect,{status:outcome?.status??'completed',
+        mutation_epoch:deriveState(goal,events).mutation_epoch,observation_lease_id:lease.lease_id});
+      await appendEvent(ctx,events,signingKeyPath,'effect_completed',{
+        ...completion,observation_lease_id:lease.lease_id,decision_event_sha256:decisionEvent.event_sha256,
+        outcome_status:outcome?.status??'completed'
+      });
+    }
+    return outcome;
+  }catch(error){
+    if(!events.some(event=>['effect_completed','effect_failed'].includes(event.type)&&event.payload?.effect_id===effect.effect_id)){
+      const completion=bindEffectCompletion(effect,{status:'failed',error:truncated(error,512),
+        mutation_epoch:deriveState(goal,events).mutation_epoch,observation_lease_id:lease.lease_id});
+      await appendEvent(ctx,events,signingKeyPath,'effect_failed',{
+        ...completion,observation_lease_id:lease.lease_id,decision_event_sha256:decisionEvent.event_sha256,
+        detail:truncated(error,512)
+      });
+    }
+    throw error;
+  }
+}
+
 function terminalState(state) {
   return ['succeeded','cancelled'].includes(state.state);
 }
@@ -1269,9 +1558,13 @@ 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});
+  const profileTimeoutCeiling=Math.max(120000,...Object.values(policy.profiles??{}).map(profile=>
+    Number.isInteger(profile?.timeout_ms)&&profile.timeout_ms>0?profile.timeout_ms+120000:120000));
+  const workerScheduler=createWorkerScheduler({maxConcurrent:2,totalCpuUnits:2,totalMemoryMb:2048,leaseMs:profileTimeoutCeiling});
   async function sessionStatus() {
     const autonomous = await autonomousSessionStatus(policy);
     const coding = await codingRuntime.sessionStatus();
@@ -1330,8 +1623,9 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     const journal = await readEvents(ctx,verifyKeyPath);
     const derived = deriveState(goal,journal);
     const loop = publicLoopState(loopStateOrNull(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,
+      title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived, ...lock,
       ...(loop ? {loop} : {}) };
   }
 
@@ -1407,7 +1701,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     }
     state = deriveState(goal,journal);
     const profiles = await runRequiredReleaseProfiles({ ctx,events:journal,goal,state,
-      policy,codingRuntime,signingKeyPath });
+      policy,codingRuntime,signingKeyPath,workerScheduler });
     if (profiles.some(item => item.status === 'paused')) {
       return { status:'paused', goal_id:goal.goal_id, ready:false,
         reason:'release_profile_interrupted', mutation_epoch:state.mutation_epoch };
@@ -1488,7 +1782,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,workerScheduler });
           } catch (error) {
             const loop=loopStateOrNull(goal,journal);
             if (!loop || loop.pending_action || !isAuthorityUnavailable(error)) throw error;
@@ -1512,7 +1806,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) {