deadbyte-mcp 0.11.2 → 0.12.0

package/src/autonomous-planner.mjs

@@ -134,6 +134,26 @@ function validateR36TypedAction(action) {
   if (typeof action.destination_path === 'string') pathFields.push(action.destination_path);
   for (const item of action.files ?? []) if (typeof item?.path === 'string') pathFields.push(item.path);
   for (const candidate of pathFields) validatePortableRelativePath(candidate);
+  if(action.kind==='desktop_target'){
+    const q=action.uia_query;
+    if(q.kind==='root'&&q.value!=='') throw new Error('desktop root query value must be empty');
+    if(q.kind!=='root'&&q.value.length<1) throw new Error('desktop UIA query value required');
+    if(q.ordinal>=q.max_results) throw new Error('desktop UIA ordinal must be below max_results');
+  }
+  if(action.kind==='desktop_action'){
+    const pointer=['pointer_move','click_primary','click_secondary','double_click_primary','scroll'].includes(action.action_kind);
+    if(pointer&&((action.target_id===null)===(action.point===null))) throw new Error('desktop pointer action requires exactly one of target_id or point');
+    if(!pointer&&(action.target_id!==null||action.point!==null)) throw new Error('desktop non-pointer action cannot carry target_id or point');
+    if(action.action_kind==='scroll'){
+      if(action.scroll_delta===null||action.scroll_delta===0) throw new Error('desktop scroll requires non-zero scroll_delta');
+    }else if(action.scroll_delta!==null) throw new Error('desktop non-scroll action cannot carry scroll_delta');
+    if(action.action_kind==='key_chord'){
+      if(action.key_chord===null||new Set(action.key_chord).size!==action.key_chord.length) throw new Error('desktop key_chord missing or duplicate');
+    }else if(action.key_chord!==null) throw new Error('desktop non-key action cannot carry key_chord');
+    if(action.action_kind==='text_input'){
+      if(action.text===null) throw new Error('desktop text_input requires text');
+    }else if(action.text!==null) throw new Error('desktop non-text action cannot carry text');
+  }
   return action;
 }
 function normalizeR36TypedAction(action) {
@@ -334,6 +354,7 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     observations:view.observations ?? [],
     decisions:view.recent_decisions ?? [],
     projectMemory:view.project_memory ?? null,
+    desktopMemory:view.desktop_memory ?? null,
     capabilities:view.capabilities ?? null
   });
   const stateJson = canonicalJson(state);
@@ -350,6 +371,7 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     'patch: operations are DEADBYTE Native Diff operations (write, replace, delete) and MUST use exact SHA-256 preconditions from supplied context.',
     'run_profile: profile_id must be one of the policy profile ids in state.',
     'delegate: operation is one bounded existing-runtime action. Allowed kinds: machine_stat, machine_list, machine_read, observation_search_start, observation_search_status, observation_search_page, observation_search_cancel, observation_process_list, observation_system_status, process_start, process_read, process_status, process_list, process_action, process_terminate.',
+    'When Desktop capabilities are present, use typed desktop_status, desktop_observe, desktop_target with one bounded UIA query, and desktop_action. desktop_action requires separate Desktop authority; Autonomous authority never implies Desktop authority. After stale or unknown Desktop evidence, observe again and replan; never blindly repeat an action.',
     'Delegate paths are relative to the goal root. Process start accepts only profile_id and cwd; process_action accepts only session_id and fixed action_id. Never emit raw stdin, executable, PID, environment, shell command, or process arguments.',
     'finish only when the goal is actually satisfied. Required release profiles are enforced by the engine and cannot be bypassed.',
     'Never invent a file SHA. If content is elided or the current SHA/content is missing, choose inspect first.',

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,20 @@ 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) {
   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;
   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,
     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, signingKeyPath) {
   if (state.pending_request) return state.pending_request;
   const round = state.planner_round + 1;
   if (round > goal.max_iterations) {
@@ -382,7 +384,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);
   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) {
@@ -511,7 +513,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 +524,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, 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,signingKeyPath);
   if (!pending) return null;
   let suppliedResponse = plannerResponse;
   while (pending) {
@@ -560,7 +565,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,signingKeyPath);
       if (!pending) return null;
       if (policy.planner.backend === 'client_sampling') return { needs_planner:true, request:pending };
       continue;
@@ -599,7 +604,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 +614,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 +629,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 +737,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 +786,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 +814,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 +843,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 +865,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 +1313,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 +1376,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 +1405,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 +1509,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 +1581,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 +1677,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, 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});
@@ -1782,7 +1902,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 +1927,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           continue;
         }
         const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
-          signingKeyPath,plannerResponse:suppliedResponse });
+          desktopMemoryProvider,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));
 }