deadbyte-mcp 0.11.3 → 0.13.0

package/src/autonomous-runtime.mjs

@@ -339,15 +339,16 @@ function normalizeGoal(policy, { submissionId, rootId, title = '', goal, accepta
   return Object.freeze({ ...body, goal_sha256:sha256Object(body) });
 }
 
-function configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime}) {
+function configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime}) {
   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';
+    id.startsWith('machine_fs.') || id.startsWith('observation.') || id.startsWith('desktop.') || 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);
+    if (entry.runtime_flag === 'DEADBYTE_DESKTOP_RUNTIME') return Boolean(desktopRuntime);
     return entry.runtime_flag === null;
   };
   const entries=R36_CAPABILITY_LEDGER.entries
@@ -359,19 +360,24 @@ function configuredCapabilityManifest({machineFsRuntime,observationRuntime,proce
     entries:Object.freeze(entries)});
 }
 
-async function plannerView(goal, state, events, codingRuntime, capabilityManifest) {
+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,
+    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, 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) {
@@ -382,7 +388,7 @@ 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);
+  const view = await plannerView(goal,state,events,codingRuntime,capabilityManifest,desktopMemoryProvider,memoryProvider);
   let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
   const repair = [...(state.planner_rejections ?? [])].reverse().find(item => item.planner_round === round) ?? null;
   if (repair) {
@@ -395,6 +401,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;
@@ -511,7 +525,10 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
       provider_id:providerId,request_id:pending.request_id,failure_class:classifyProviderFailure(error),
       probe:disposition.probe===true
     });
-    circuit=providerCircuitSnapshot(policy,events);
+    // Bind the transition to the durable failure event's own timestamp. A short OPEN
+    // interval must not expire inside the same run before the caller observes the pause.
+    const failureObservedAt=events.at(-1)?.created_at_utc;
+    circuit=providerCircuitSnapshot(policy,events,failureObservedAt);
     if (circuit.state==='OPEN'||circuit.state==='UNAVAILABLE') {
       const reason=circuit.state==='UNAVAILABLE'?'provider_circuit_unavailable':'provider_circuit_open';
       return {waiting:await enterProviderCircuitWait({ctx,events,goal,policy,signingKeyPath,reason,circuit})};
@@ -519,9 +536,9 @@ async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signin
     throw error;
   }
 }
-async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, 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,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) {
@@ -560,7 +577,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,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;
@@ -568,6 +585,12 @@ 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')),
+      ...(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 };
@@ -599,7 +622,7 @@ async function executeInspect({ ctx, events, goal, decisionEvent, decision, codi
   return { status:'completed', contexts };
 }
 
-const DELEGATED_MUTATIONS = new Set(['process_start','process_action','process_terminate','observation_search_cancel']);
+const DELEGATED_MUTATIONS = new Set(['process_start','process_action','process_terminate','observation_search_cancel','desktop_action']);
 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',
@@ -609,7 +632,8 @@ const CAPABILITY_BY_ACTION=Object.freeze({
   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'
+  observation_process_list:'observation.process_list',observation_system_status:'observation.system_status',
+  desktop_status:'desktop.status',desktop_observe:'desktop.observe',desktop_target:'desktop.target',desktop_action:'desktop.action'
 });
 function capabilityIdForOperation(operation){return CAPABILITY_BY_ACTION[operation?.kind]??null;}
 function assertDelegatedIdentity(events, operation) {
@@ -623,9 +647,27 @@ function assertDelegatedIdentity(events, operation) {
       event.payload?.operation?.kind === 'process_start' && event.payload?.result?.session_id === operation.session_id);
     if (!owned) throw new Error(`delegated process session '${operation.session_id}' is stale or belongs to another goal`);
   }
+  if(operation.kind==='desktop_target'){
+    const owned=events.some(event=>event.type==='delegated_action_completed'&&
+      event.payload?.operation?.kind==='desktop_observe'&&event.payload?.result?.frame?.frame_id===operation.frame_id);
+    if(!owned) throw new Error(`desktop frame '${operation.frame_id}' was not freshly observed by this goal`);
+  }
+  if(operation.kind==='desktop_action'){
+    const frameOwned=events.some(event=>event.type==='delegated_action_completed'&&
+      ['desktop_observe','desktop_target'].includes(event.payload?.operation?.kind)&&
+      event.payload?.result?.frame?.frame_id===operation.expected_frame_id);
+    if(!frameOwned) throw new Error(`desktop action frame '${operation.expected_frame_id}' was not observed or grounded by this goal`);
+    if(operation.target_id!==null){
+      const targetOwned=events.some(event=>event.type==='delegated_action_completed'&&
+        event.payload?.operation?.kind==='desktop_target'&&
+        event.payload?.result?.target?.target_id===operation.target_id&&
+        event.payload?.result?.frame?.frame_id===operation.expected_frame_id);
+      if(!targetOwned) throw new Error(`desktop target '${operation.target_id}' is stale or belongs to another goal`);
+    }
+  }
 }
-async function invokeDelegatedOperation(goal, operation, runtimes) {
-  const { codingRuntime, semanticRuntime, nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime } = runtimes;
+async function invokeDelegatedOperation(goal, operation, runtimes, desktopContext=null) {
+  const { codingRuntime, semanticRuntime, nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, desktopRuntime } = runtimes;
   switch (operation.kind) {
     case 'stat':
       return codingRuntime.stat({rootId:goal.root_id,relativePath:operation.path,hash:operation.hash});
@@ -713,6 +755,33 @@ async function invokeDelegatedOperation(goal, operation, runtimes) {
     case 'process_terminate':
       if (!processRuntime) throw new Error('process runtime unavailable');
       return processRuntime.terminate({ sessionId:operation.session_id });
+    case 'desktop_status':
+      if(!desktopRuntime) throw new Error('desktop runtime unavailable');
+      return desktopRuntime.status();
+    case 'desktop_observe':
+      if(!desktopRuntime) throw new Error('desktop runtime unavailable');
+      return desktopRuntime.observe({preview:false});
+    case 'desktop_target':
+      if(!desktopRuntime) throw new Error('desktop runtime unavailable');
+      return desktopRuntime.ground({frameId:operation.frame_id,query:operation.uia_query});
+    case 'desktop_action': {
+      if(!desktopRuntime) throw new Error('desktop runtime unavailable');
+      if(!desktopContext) throw new Error('desktop autonomous effect context missing');
+      const result=await desktopRuntime.action({
+        intentId:desktopContext.intentId,kind:operation.action_kind,expectedFrameId:operation.expected_frame_id,
+        targetId:operation.target_id,point:operation.point,scrollDelta:operation.scroll_delta,
+        keyChord:operation.key_chord,text:operation.text,effectContext:desktopContext.effectContext
+      });
+      const {action,...rest}=result;
+      return Object.freeze({...rest,action_summary:Object.freeze({
+        schema:'deadbyte.desktop-action-summary.v1',intent_id:action.intent_id,kind:action.kind,
+        frame_id:action.frame_id,desktop_epoch:action.desktop_epoch,topology_sha256:action.topology_sha256,
+        expected_window:action.expected_window,target_id:action.target_id,point:action.point,
+        scroll_delta:action.scroll_delta,key_chord:action.key_chord,text_sha256:action.text_sha256,
+        ...(action.kind==='text_input'?{text_bytes:Buffer.byteLength(action.text??'','utf8')}:{}),
+        action_sha256:action.action_sha256
+      })});
+    }
     default: throw new Error(`unsupported delegated operation '${String(operation.kind)}'`);
   }
 }
@@ -735,6 +804,27 @@ async function verifyDelegatedEvidence(operation, result, runtimes, verifyKeyPat
         journal_head_sha256:checked.head_sha256 };
     }
   }
+  if(operation.kind.startsWith('desktop_')&&operation.kind!=='desktop_status'){
+    if(!runtimes.desktopRuntime?.verifyReceipt) throw new Error('desktop receipt verifier unavailable');
+    const refs=[];
+    if(operation.kind==='desktop_observe'&&result?.receipt_id) refs.push([result.receipt_id,result.receipt_sha256,'desktop_observation']);
+    if(operation.kind==='desktop_target'&&result?.grounding?.receipt_id) refs.push([result.grounding.receipt_id,result.grounding.receipt_sha256,'desktop_grounding']);
+    if(operation.kind==='desktop_action'){
+      refs.push(
+        [result?.started_receipt_id,result?.started_receipt_sha256,'desktop_action_started'],
+        [result?.post_receipt_id,result?.post_receipt_sha256,'desktop_post_observation'],
+        [result?.receipt_id,result?.receipt_sha256,'desktop_action_completed']
+      );
+    }
+    if(refs.length<1||refs.some(([id,sha])=>typeof id!=='string'||!SHA256_RE.test(sha??''))) throw new Error('desktop delegated evidence references missing');
+    const verified=[];
+    for(const [id,sha,kind] of refs){
+      const proof=await runtimes.desktopRuntime.verifyReceipt({receiptId:id});
+      if(!proof.ok||proof.receipt_sha256!==sha||proof.kind!==kind) throw new Error('desktop delegated receipt mismatch');
+      verified.push({receipt_id:id,receipt_sha256:sha,kind});
+    }
+    return {kind:'desktop_receipts',receipts:verified,result_sha256:sha256Object(result)};
+  }
   return { kind:'runtime_result', result_sha256:sha256Object(result) };
 }
 async function executeDelegate({ ctx, events, goal, decisionEvent, decision, policy, runtimes, assertRunAuthority,
@@ -742,6 +832,22 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
   const capabilityId=capabilityIdForOperation(decision.operation);
   if(!capabilityId) throw new Error(`unsupported typed capability action '${String(decision.operation?.kind)}'`);
   const actionKey = `capability-${decisionEvent.event_sha256}`;
+  if(decision.operation.kind==='desktop_action'){
+    if(!runtimes.desktopRuntime) throw new Error('desktop runtime unavailable');
+    const desktopStatus=await runtimes.desktopRuntime.status();
+    if(!desktopStatus.armed||!desktopStatus.action_kinds.includes(decision.operation.action_kind)){
+      if(!events.some(event=>event.type==='waiting_entered'&&event.payload?.reason==='desktop_authority_unavailable')){
+        await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{
+          reason:'desktop_authority_unavailable',requires_approval:true,resume_phase:'ACT',
+          desktop_action_kind:decision.operation.action_kind
+        });
+      }
+      await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+        reason:'desktop_authority_unavailable',desktop_action_kind:decision.operation.action_kind
+      });
+      return {status:'paused',reason:'desktop_authority_unavailable'};
+    }
+  }
   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);
@@ -755,7 +861,20 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
   try {
     assertDelegatedIdentity(events,decision.operation);
     if (DELEGATED_MUTATIONS.has(decision.operation.kind)) await assertRunAuthority(goal.root_id);
-    const result = await invokeDelegatedOperation(goal,decision.operation,runtimes);
+    let desktopContext=null;
+    if(decision.operation.kind==='desktop_action'){
+      const loop=deriveLoopState(goal,events);
+      const current=deriveState(goal,events);
+      desktopContext={
+        intentId:sha256Object({schema:'deadbyte.autonomous-desktop-intent.v1',goal_id:goal.goal_id,
+          decision_event_sha256:decisionEvent.event_sha256,operation:decision.operation}),
+        effectContext:{
+          goalId:goal.goal_id,planId:loop.plan_id,stepId:loop.current_step?.step_id??'desktop',
+          mutationEpoch:current.mutation_epoch,observationHeadSha256:decision.operation.expected_frame_id
+        }
+      };
+    }
+    const result = await invokeDelegatedOperation(goal,decision.operation,runtimes,desktopContext);
     if (Buffer.byteLength(canonicalJson(result),'utf8') > policy.limits.max_context_bytes) {
       throw new Error('delegated result exceeds autonomous context bound');
     }
@@ -764,6 +883,23 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
       decision_event_sha256:decisionEvent.event_sha256, operation:decision.operation, result, evidence });
     return { status:'completed', result, evidence };
   } catch (error) {
+    if(decision.operation.kind==='desktop_action'){
+      const sideEffectState=error?.side_effect_state??null;
+      const reason=sideEffectState==='unknown'?'desktop_outcome_unknown':
+        sideEffectState==='not_started'?'desktop_effect_not_started':'desktop_action_failed';
+      const resumePhase=sideEffectState==='unknown'?'CRITIC':'ACT';
+      if(!events.some(event=>event.type==='waiting_entered'&&event.payload?.reason===reason)){
+        await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{
+          reason,requires_approval:true,resume_phase:resumePhase,
+          receipt_id:error?.receipt_id??null,receipt_sha256:error?.receipt_sha256??null
+        });
+      }
+      await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+        reason,action_key:actionKey,operation_kind:decision.operation.kind,side_effect_state:sideEffectState,
+        receipt_id:error?.receipt_id??null,receipt_sha256:error?.receipt_sha256??null,detail:truncated(error)
+      });
+      return {status:'paused',reason,side_effect_state:sideEffectState};
+    }
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'delegated_action_failed', action_key:actionKey,
       operation_kind:decision.operation.kind, detail:truncated(error) });
     return { status:'paused', reason:'delegated_action_failed' };
@@ -1195,7 +1331,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,semanticRuntime,assertRunAuthority,
+  nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,assertRunAuthority,
   signingKeyPath,verifyKeyPath,workerScheduler}) {
   let loop=deriveLoopState(goal,events);
   if (decision.kind === 'plan_create') {
@@ -1258,7 +1394,7 @@ 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:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,desktopRuntime},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,
@@ -1287,7 +1423,7 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
     } 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});
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,desktopRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
     } else {
       throw new Error(`unsupported R34 action '${String(decision.action.kind)}'`);
     }
@@ -1391,12 +1527,12 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
 }
 
 async function executeDecisionCore({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
-  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, semanticRuntime, assertRunAuthority,
+  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, semanticRuntime, desktopRuntime, 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,semanticRuntime,assertRunAuthority,
+      nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,assertRunAuthority,
       signingKeyPath,verifyKeyPath,workerScheduler});
     await appendEvent(ctx,events,signingKeyPath,'decision_completed',{
       decision_event_sha256:decisionEvent.event_sha256,action:decision.kind,
@@ -1463,6 +1599,7 @@ function effectDescriptor(goal,state,events,decisionEvent){
   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;
+    if(String(decision.action?.kind??'').startsWith('desktop_')) 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)){
@@ -1558,10 +1695,11 @@ function isAuthorityUnavailable(error) {
 }
 
 export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRuntime, machineFsRuntime = null,
-  observationRuntime = null, processRuntime = null, semanticRuntime = null, signingKeyPath, verifyKeyPath }) {
+  observationRuntime = null, processRuntime = null, semanticRuntime = null, desktopRuntime = null,
+  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});
+  const capabilityManifest=configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime});
   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});
@@ -1612,7 +1750,8 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     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
+      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' };
   }
@@ -1782,7 +1921,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,semanticRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath,workerScheduler });
+              observationRuntime,processRuntime,semanticRuntime,desktopRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath,workerScheduler });
           } catch (error) {
             const loop=loopStateOrNull(goal,journal);
             if (!loop || loop.pending_action || !isAuthorityUnavailable(error)) throw error;
@@ -1807,7 +1946,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           continue;
         }
         const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
-          signingKeyPath,plannerResponse:suppliedResponse });
+          desktopMemoryProvider,memoryProvider,signingKeyPath,plannerResponse:suppliedResponse });
         suppliedResponse = null;
         if (accepted?.needs_planner) {
           state = deriveState(goal,journal);

package/src/capability-ledger.mjs

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 
 export const CAPABILITY_LEDGER_SCHEMA='deadbyte.capability-ledger.v1';
-const AUTHORITIES=new Set(['none','process','coding','autonomous','host']);
+const AUTHORITIES=new Set(['none','process','coding','autonomous','desktop','host']);
 const PROFILE_ENV='DEADBYTE_CAPABILITY_PROFILE';
 const COMPACT_TOOL_LIMIT=42;
 
@@ -135,6 +135,11 @@ export const R36_CAPABILITY_ENTRIES=Object.freeze([
   gateway('observation.process_list','machine_process_list','machine_observe','process_list','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
   gateway('observation.system_status','machine_system_status','machine_observe','system_status','DEADBYTE_OBSERVATION_RUNTIME','none',{receipt_class:'observation'}),
 
+  gateway('desktop.status','desktop_status','desktop_control','status','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),
+  gateway('desktop.observe','desktop_observe','desktop_control','observe','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),
+  gateway('desktop.target','desktop_target','desktop_control','target','DEADBYTE_DESKTOP_RUNTIME','none',{receipt_class:'desktop'}),
+  gateway('desktop.action','desktop_action','desktop_control','action','DEADBYTE_DESKTOP_RUNTIME','desktop',{mutating:true,receipt_class:'desktop'}),
+
   direct('autonomous.session_status','autonomous_session_status','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{receipt_class:'autonomous'}),
   direct('native_diff.preview','native_diff_preview','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{mutating:true,receipt_class:'native_diff'}),
   direct('native_diff.apply','native_diff_apply','DEADBYTE_AUTONOMOUS_RUNTIME','autonomous',{mutating:true,receipt_class:'native_diff'}),

package/src/compact-gateway-mcp-tools.mjs

@@ -1,5 +1,7 @@
+import { createHash } from 'node:crypto';
 import * as z from 'zod/v4';
 import { compactGatewayOutputSchema, compactGatewayResult } from './compact-gateway-output-contracts.mjs';
+import { desktopControlInputSchema,invokeDesktopOperation } from './desktop-mcp-tools-r40.mjs';
 
 const id=z.string().regex(/^[A-Za-z0-9._-]{1,64}$/);
 const rel=z.string().min(1).max(2048);
@@ -117,12 +119,22 @@ async function machineObserve(args,machineRuntime,observationRuntime){
   return invoke(args.op,observationRuntime,'observation',map[args.op]);
 }
 
-export function registerCompactGatewayTools(server,{profile,ledger,codingRuntime,semanticRuntime,machineFsRuntime,processRuntime,observationRuntime,machineRuntime}){
+export function registerCompactGatewayTools(server,{profile,ledger,codingRuntime,semanticRuntime,machineFsRuntime,processRuntime,observationRuntime,machineRuntime,desktopRuntime,catalogProvider}){
   if(!server) throw new Error('compact gateway registration requires server');
   if(profile!=='compact') return;
-  server.registerTool('capability_manifest',{description:'Read the canonical R36 capability ledger and active compact profile.',inputSchema:capabilityManifestInputSchema,outputSchema:compactGatewayOutputSchema},async()=>compactGatewayResult({status:'ok',op:'manifest',result:{schema:'deadbyte.capability-manifest.v1',profile,ledger_sha256:ledger?.ledger_sha256??null,capabilities:ledger?.entries??[]}},false));
+  if(typeof catalogProvider!=='function') throw new Error('compact gateway requires catalogProvider');
+  server.registerTool('capability_manifest',{description:'Read the canonical capability ledger and exact active compact tool catalog.',inputSchema:capabilityManifestInputSchema,outputSchema:compactGatewayOutputSchema},async()=>{
+    const toolCatalog=[...catalogProvider()].map(String).sort();
+    if(toolCatalog.length<1||new Set(toolCatalog).size!==toolCatalog.length) throw new Error('compact catalog provider returned invalid catalog');
+    const catalogSha256=createHash('sha256').update(JSON.stringify(toolCatalog),'utf8').digest('hex');
+    return compactGatewayResult({status:'ok',op:'manifest',result:{
+      schema:'deadbyte.capability-manifest.v2',profile,ledger_sha256:ledger?.ledger_sha256??null,
+      tool_catalog:toolCatalog,tool_count:toolCatalog.length,catalog_sha256:catalogSha256,capabilities:ledger?.entries??[]
+    }},false);
+  });
   server.registerTool('coding_inspect',{description:'Typed compact coding inspection and semantic navigation gateway. No arbitrary tool dispatch.',inputSchema:codingInspectInputSchema,outputSchema:compactGatewayOutputSchema},args=>codingInspect(args,codingRuntime,semanticRuntime));
   server.registerTool('machine_fs',{description:'Typed compact machine filesystem gateway preserving root policy and mutation preconditions.',inputSchema:machineFsGatewayInputSchema,outputSchema:compactGatewayOutputSchema},args=>machineFs(args,machineFsRuntime));
   server.registerTool('process_session',{description:'Typed compact DEADBYTE-owned process session gateway. No raw stdin or PID authority.',inputSchema:processSessionGatewayInputSchema,outputSchema:compactGatewayOutputSchema},args=>processSession(args,processRuntime));
   server.registerTool('machine_observe',{description:'Typed compact machine identity and read-only observation gateway. Revoke is intentionally excluded.',inputSchema:machineObserveInputSchema,outputSchema:compactGatewayOutputSchema},args=>machineObserve(args,machineRuntime,observationRuntime));
+  server.registerTool('desktop_control',{description:'Typed Desktop observe, target, status and guarded action gateway. No arbitrary dispatch; mutation still requires separate Desktop authority.',inputSchema:desktopControlInputSchema,outputSchema:compactGatewayOutputSchema},args=>invokeDesktopOperation(args,desktopRuntime));
 }