deadbyte-mcp 0.11.3 → 0.12.0

package/src/remote-mcp-smoke-client.mjs

@@ -1,4 +1,4 @@
-import { randomBytes } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
 
 const endpointText = process.argv[2];
@@ -51,6 +51,9 @@ const r36CompactTools = [
   'process_session'
 ].sort();
 if (r36CompactTools.length !== 41) throw new Error(`R36 compact catalog constant drift: ${r36CompactTools.length}`);
+const r40CompactTools = [...r36CompactTools, 'desktop_control'].sort();
+if (r40CompactTools.length !== 42) throw new Error(`R40 compact catalog constant drift: ${r40CompactTools.length}`);
+const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
 const allowedCatalogs = [];
 for (const machine of [false, true]) for (const host of [false, true]) for (const agent of [false, true]) {
   for (const processPlane of [false, true]) for (const machineFs of [false, true]) for (const observation of [false, true]) for (const codingMode of ['none', 'coding', 'autonomous']) {
@@ -93,7 +96,9 @@ try {
   if (client.getProtocolEra() !== 'modern') throw new Error(`expected modern MCP era, got ${String(client.getProtocolEra())}`);
   const listed = await client.listTools();
   const names = listed.tools.map(t => t.name).sort();
-  const compactProfile = JSON.stringify(names) === JSON.stringify(r36CompactTools);
+  const exactR36Compact = JSON.stringify(names) === JSON.stringify(r36CompactTools);
+  const exactR40Compact = JSON.stringify(names) === JSON.stringify(r40CompactTools);
+  const compactProfile = exactR36Compact || exactR40Compact;
   const catalogOk = compactProfile || allowedCatalogs.some(expected => JSON.stringify(names) === JSON.stringify(expected));
   if (!catalogOk) throw new Error(`tool catalog mismatch: ${JSON.stringify(names)}`);
   for (const tool of listed.tools) {
@@ -117,14 +122,23 @@ try {
   let agent = null;
   if (compactProfile) {
     const manifest = gateway(await client.callTool({ name: 'capability_manifest', arguments: {} }), 'capability_manifest');
-    if (manifest.schema !== 'deadbyte.capability-manifest.v1' || manifest.profile !== 'compact' ||
+    const manifestV1 = manifest.schema === 'deadbyte.capability-manifest.v1' && exactR36Compact;
+    const manifestV2 = manifest.schema === 'deadbyte.capability-manifest.v2' && exactR40Compact;
+    if ((!manifestV1 && !manifestV2) || manifest.profile !== 'compact' ||
         !Array.isArray(manifest.capabilities) || !/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256 ?? ''))) {
-      throw new Error('R36 compact capability manifest malformed');
+      throw new Error('compact capability manifest malformed');
+    }
+    if (manifestV2) {
+      const expectedCatalogSha = sha256(Buffer.from(JSON.stringify(names), 'utf8'));
+      if (manifest.tool_count !== names.length || JSON.stringify(manifest.tool_catalog) !== JSON.stringify(names) ||
+          manifest.catalog_sha256 !== expectedCatalogSha) {
+        throw new Error('R40 compact capability manifest catalog attestation mismatch');
+      }
     }
     const required = manifest.capabilities.filter(item => item?.production === true && item?.host_only !== true);
     for (const item of required) {
       if (typeof item.compact_tool !== 'string' || !names.includes(item.compact_tool)) {
-        throw new Error(`R36 compact capability route missing: ${String(item.id)}`);
+        throw new Error(`compact capability route missing: ${String(item.id)}`);
       }
     }
     const machine = gateway(await client.callTool({ name: 'machine_observe', arguments: { op: 'machine_status' } }), 'machine_status');
@@ -132,7 +146,7 @@ try {
     const ping = gateway(await client.callTool({ name: 'machine_observe', arguments: { op: 'machine_ping', nonce } }), 'machine_ping');
     if (ping.nonce !== nonce || ping.machine_id !== machine.machine_id ||
         ping.release_id !== machine.release_id || ping.release_manifest_sha256 !== machine.release_manifest_sha256) {
-      throw new Error('R36 compact machine ping binding mismatch');
+      throw new Error('compact machine ping binding mismatch');
     }
     compact = {
       profile: 'compact',

package/src/remote-result-journal.mjs

@@ -6,6 +6,7 @@ export const REMOTE_RESULT_JOURNAL_SCHEMA='deadbyte.remote-result-journal.v1';
 const SESSION=/^[0-9a-f]{24}$/;
 const HASH=/^[0-9a-f]{64}$/;
 const STATUS=new Set(['ok','error']);
+const SIDE_EFFECT_STATES=new Set(['unknown']);
 const EVENT_TYPES=new Set(['tool.call','tool.result']);
 
 function text(value,label,max){
@@ -40,10 +41,17 @@ function validateEvent(raw,index=null){
       observed_at_utc:observed,payload_sha256:raw.payload_sha256,arguments:sanitizeAuditArgs(rawArgs)});
   }
   if(!STATUS.has(raw.status)) throw new Error('remote result status invalid');
+  const durationMs=raw.duration_ms===undefined?null:raw.duration_ms;
+  if(durationMs!==null&&(!Number.isFinite(durationMs)||durationMs<0||durationMs>86_400_000)) throw new Error('remote result duration_ms invalid');
+  const reason=raw.reason===undefined||raw.reason===null?null:text(raw.reason,'remote result reason',512);
+  const sideEffectState=raw.side_effect_state===undefined||raw.side_effect_state===null?null:raw.side_effect_state;
+  if(sideEffectState!==null&&!SIDE_EFFECT_STATES.has(sideEffectState)) throw new Error('remote result side_effect_state invalid');
   return Object.freeze({session_id:sessionId,seq,event_type:eventType,request_id:requestId,tool,status:raw.status,
-    observed_at_utc:observed,payload_sha256:raw.payload_sha256});
+    observed_at_utc:observed,payload_sha256:raw.payload_sha256,
+    ...(durationMs===null?{}:{duration_ms:durationMs}),...(reason===null?{}:{reason}),
+    ...(sideEffectState===null?{}:{side_effect_state:sideEffectState})});
 }
-function identity(item){return `${item.event_type}\0${item.request_id}\0${item.status??''}\0${item.payload_sha256}`;}
+function identity(item){return `${item.event_type}\0${item.request_id}\0${item.status??''}\0${item.side_effect_state??''}\0${item.payload_sha256}`;}
 export function parseRemoteResultCursor(cursor){
   if(typeof cursor!=='string') throw new Error('remote result cursor invalid');
   const match=/^r1:([0-9a-f]{24}):(0|[1-9][0-9]{0,15})$/.exec(cursor);

package/src/runtime-update.mjs

@@ -45,14 +45,17 @@ function normalizePersistentPublicOrigin(value){
   return publicOrigin.origin;
 }
 export function parseUpdateArgs(argv){
-  const out={stage:null,developmentRoot:null,expectedVersion:null,expectedManifest:null,sourceRoot:null,restoreStandingGrants:false,recoverOfflinePredecessor:false,enableMachineFs:false,enableObservation:false,enableAutonomousSupervisor:false,cloudTransport:null,bridgeBootstrap:null,processPolicyBootstrap:null,semanticLspBootstrap:null,hostCommandPins:[]};
-  const cloud={},bridge={},processPolicy={},semanticLsp={},seen=new Set(),hostPinIds=new Set();
+  const out={stage:null,developmentRoot:null,expectedVersion:null,expectedManifest:null,sourceRoot:null,restoreStandingGrants:false,recoverOfflinePredecessor:false,enableMachineFs:false,enableObservation:false,enableDesktop:false,enableAutonomousSupervisor:false,cloudTransport:null,bridgeBootstrap:null,processPolicyBootstrap:null,desktopPolicyBootstrap:null,semanticLspBootstrap:null,hostCommandPins:[]};
+  const cloud={},bridge={},processPolicy={},desktopPolicy={},semanticLsp={},seen=new Set(),hostPinIds=new Set();
   const bridgeFlags=new Map([
     ['--bridge-root','root'],['--bridge-script-sha256','scriptSha256']
   ]);
   const processPolicyFlags=new Map([
     ['--process-policy','path'],['--process-policy-sha256','sha256']
   ]);
+  const desktopPolicyFlags=new Map([
+    ['--desktop-policy','path'],['--desktop-policy-sha256','sha256']
+  ]);
   const semanticLspFlags=new Map([
     ['--semantic-lsp-config','path'],['--semantic-lsp-config-sha256','sha256']
   ]);
@@ -61,16 +64,17 @@ export function parseUpdateArgs(argv){
     ['--cloud-token-file','tokenFilePath'],['--cloud-token-sha256','tokenFileSha256'],
     ['--cloud-child-working-directory','childWorkingDirectory'],['--cloud-public-origin','publicOrigin']
   ]);
-  const valued=new Set(['--stage','--development-root','--expected-version','--expected-manifest','--source-root','--host-command-pin',...bridgeFlags.keys(),...processPolicyFlags.keys(),...semanticLspFlags.keys(),...cloudFlags.keys()]);
+  const valued=new Set(['--stage','--development-root','--expected-version','--expected-manifest','--source-root','--host-command-pin',...bridgeFlags.keys(),...processPolicyFlags.keys(),...desktopPolicyFlags.keys(),...semanticLspFlags.keys(),...cloudFlags.keys()]);
   for(let index=0;index<argv.length;index++){
     const arg=argv[index];
-    if(arg==='--restore-standing-grants'||arg==='--recover-offline-predecessor'||arg==='--enable-machine-fs'||arg==='--enable-observation'||arg==='--enable-autonomous-supervisor'){
+    if(arg==='--restore-standing-grants'||arg==='--recover-offline-predecessor'||arg==='--enable-machine-fs'||arg==='--enable-observation'||arg==='--enable-desktop'||arg==='--enable-autonomous-supervisor'){
       if(seen.has(arg)) throw new Error(`duplicate self-update argument '${arg}'`);
       seen.add(arg);
       if(arg==='--restore-standing-grants') out.restoreStandingGrants=true;
       else if(arg==='--recover-offline-predecessor') out.recoverOfflinePredecessor=true;
       else if(arg==='--enable-machine-fs') out.enableMachineFs=true;
       else if(arg==='--enable-observation') out.enableObservation=true;
+      else if(arg==='--enable-desktop') out.enableDesktop=true;
       else out.enableAutonomousSupervisor=true;
       continue;
     }
@@ -95,6 +99,7 @@ export function parseUpdateArgs(argv){
     else if(arg==='--source-root') out.sourceRoot=path.resolve(value);
     else if(bridgeFlags.has(arg)) bridge[bridgeFlags.get(arg)]=value;
     else if(processPolicyFlags.has(arg)) processPolicy[processPolicyFlags.get(arg)]=value;
+    else if(desktopPolicyFlags.has(arg)) desktopPolicy[desktopPolicyFlags.get(arg)]=value;
     else if(semanticLspFlags.has(arg)) semanticLsp[semanticLspFlags.get(arg)]=value;
     else cloud[cloudFlags.get(arg)]=value;
   }
@@ -116,6 +121,13 @@ export function parseUpdateArgs(argv){
     if(!HEX64.test(sha256)) throw new Error('process policy SHA-256 must be lowercase hex');
     out.processPolicyBootstrap={path:path.resolve(processPolicy.path),sha256};
   }
+  const desktopPolicyFields=[...desktopPolicyFlags.values()],desktopPolicyPresent=desktopPolicyFields.filter(key=>desktopPolicy[key]!==undefined);
+  if(desktopPolicyPresent.length!==0&&desktopPolicyPresent.length!==desktopPolicyFields.length) throw new Error('desktop policy bootstrap requires path plus SHA-256 as one pair');
+  if(desktopPolicyPresent.length===desktopPolicyFields.length){
+    const sha256=String(desktopPolicy.sha256).toLowerCase();
+    if(!HEX64.test(sha256)) throw new Error('desktop policy SHA-256 must be lowercase hex');
+    out.desktopPolicyBootstrap={path:path.resolve(desktopPolicy.path),sha256};
+  }
   const semanticLspFields=[...semanticLspFlags.values()],semanticLspPresent=semanticLspFields.filter(key=>semanticLsp[key]!==undefined);
   if(semanticLspPresent.length!==0&&semanticLspPresent.length!==semanticLspFields.length) throw new Error('semantic LSP config bootstrap requires path plus SHA-256 as one pair');
   if(semanticLspPresent.length===semanticLspFields.length){
@@ -321,6 +333,21 @@ export async function prepareProcessPolicyBootstrap(bootstrap){
   return {...pinned,policy};
 }
 
+export async function prepareDesktopPolicyBootstrap(bootstrap){
+  if(!bootstrap) return null;
+  const pinned=await verifyPinnedRegularFile(bootstrap.path,bootstrap.sha256,'desktop policy');
+  const policy=await readJson(pinned.path);
+  if(policy?.schema!=='deadbyte.desktop-policy.v1'||policy?.enabled!==true) throw new Error('desktop policy schema/enabled mismatch');
+  for(const name of ['observer','input','grounder']){
+    const provider=policy[name];
+    if(!provider||typeof provider.executable!=='string'||!path.isAbsolute(provider.executable)||!HEX64.test(String(provider.sha256??''))) {
+      throw new Error(`desktop policy ${name} pin invalid`);
+    }
+  }
+  if(!Array.isArray(policy.allowed_actions)||policy.allowed_actions.length<1) throw new Error('desktop policy allowed_actions invalid');
+  return {...pinned,policy};
+}
+
 export async function prepareSemanticLspConfigBootstrap(bootstrap){
   if(!bootstrap) return null;
   const pinned=await verifyPinnedRegularFile(bootstrap.path,bootstrap.sha256,'semantic LSP config');
@@ -460,6 +487,7 @@ export function parseControllerStatus(text){
     local_ready:/Local ready\s*:\s*True/.test(text),
     coding_armed:/Coding plane\s*:\s*ARMED \[standing-grant\]/.test(text),
     autonomous_armed:/Autonomous\s*:\s*ARMED \[standing-grant\]/.test(text),
+    desktop_armed:/Desktop plane\s*:\s*ARMED \[standing-grant\]/.test(text),
     host_armed:/Host plane\s*:\s*ARMED \[standing-grant\]/.test(text)
   };
 }
@@ -664,13 +692,14 @@ async function loadControlInputs({stateRoot,sourceRoot,pointerInfo}){
     ctx=legacyContext(sourceRoot); configPath=path.join(ctx.source_root,'controller','deadbyte-controller.config.psd1');
   }
   let config=await loadPowerShellDataFile(configPath); config=await normalizeComponentIdentities(config);
-  const codingPath=String(config.CodingPolicyFile??''); const autonomousPath=String(config.AutonomousPolicyFile??''); const hostPath=String(config.HostPolicyFile??''); const processPath=String(config.ProcessPolicyFile??'');
+  const codingPath=String(config.CodingPolicyFile??''); const autonomousPath=String(config.AutonomousPolicyFile??''); const hostPath=String(config.HostPolicyFile??''); const processPath=String(config.ProcessPolicyFile??''); const desktopPath=String(config.DesktopPolicyFile??'');
   if(!path.isAbsolute(codingPath)||!path.isAbsolute(autonomousPath)) throw new Error('coding/autonomous policy paths must be absolute');
   if(processPath&&!path.isAbsolute(processPath)) throw new Error('process policy path must be absolute');
-  const codingPolicy=await readJson(codingPath); const autonomousPolicy=await readJson(autonomousPath); const hostPolicy=hostPath?await readJson(hostPath):null; const processPolicy=processPath?await readJson(processPath):null;
+  if(desktopPath&&!path.isAbsolute(desktopPath)) throw new Error('desktop policy path must be absolute');
+  const codingPolicy=await readJson(codingPath); const autonomousPolicy=await readJson(autonomousPath); const hostPolicy=hostPath?await readJson(hostPath):null; const processPolicy=processPath?await readJson(processPath):null; const desktopPolicy=desktopPath?await readJson(desktopPath):null;
   const legacyCore=typeof config.CoreRoot==='string'&&config.CoreRoot?path.resolve(config.CoreRoot):ctx.core_root;
   const workspaceRoot=typeof config.WorkspaceRoot==='string'&&config.WorkspaceRoot?path.resolve(config.WorkspaceRoot):path.join(legacyCore,'workspaces');
-  return {ctx,configPath,config,codingPolicy,autonomousPolicy,hostPolicy,processPolicy,workspaceRoot};
+  return {ctx,configPath,config,codingPolicy,autonomousPolicy,hostPolicy,processPolicy,desktopPolicy,workspaceRoot};
 }
 export function assertDevelopmentRootSafe(developmentRoot,stateRoot){
   const dev=path.resolve(developmentRoot),state=path.resolve(stateRoot);
@@ -724,17 +753,18 @@ async function rollbackLaunchers(plan){
 }
 async function revokeAuthority(ctx,prior){
   let revoked=false;
+  if(prior.desktop_armed){ controllerCaptured(ctx,'disarmdesktop',15000); revoked=true; }
   if(prior.autonomous_armed){ controllerCaptured(ctx,'disarmautonomous',15000); revoked=true; }
   if(prior.coding_armed){ controllerCaptured(ctx,'disarmcoding',15000); revoked=true; }
   const status=parseControllerStatus(controllerCaptured(ctx,'status',15000));
-  if(status.coding_armed||status.autonomous_armed) throw new Error('standing authority revoke gate failed');
+  if(status.coding_armed||status.autonomous_armed||status.desktop_armed) throw new Error('standing authority revoke gate failed');
   if(status.host_armed) throw new Error('host plane became armed during revoke');
   return {revoked,status};
 }
 async function restoreStandingAuthority(ctx,prior,enabled){
   if(!enabled){
     const status=parseControllerStatus(controllerCaptured(ctx,'status',15000));
-    if(status.coding_armed||status.autonomous_armed) throw new Error('standing authority unexpectedly survived slot switch');
+    if(status.coding_armed||status.autonomous_armed||status.desktop_armed) throw new Error('standing authority unexpectedly survived slot switch');
     if(status.host_armed) throw new Error('host plane became armed during slot switch');
     return status;
   }
@@ -744,6 +774,7 @@ async function restoreStandingAuthority(ctx,prior,enabled){
   const status=parseControllerStatus(controllerCaptured(ctx,'status',15000));
   if(status.coding_armed!==prior.coding_armed) throw new Error('coding standing-grant restore gate failed');
   if(status.autonomous_armed!==prior.autonomous_armed) throw new Error('autonomous standing-grant restore gate failed');
+  if(status.desktop_armed) throw new Error('desktop plane must remain disarmed after slot switch');
   if(status.host_armed) throw new Error('host plane became armed during slot switch');
   return status;
 }
@@ -795,7 +826,7 @@ function publicPointer(pointer){
     release_root:pointer.release_root,generation_root:pointer.generation_root,generation_manifest_sha256:pointer.generation_manifest_sha256,
     launcher_sha256:pointer.launcher_sha256,config_path:pointer.config_path};
 }
-export async function performSlotUpdate({stage,developmentRoot,expectedVersion,expectedManifest,sourceRoot=null,stateRoot=DEFAULT_STATE_ROOT,restoreStandingGrants=false,recoverOfflinePredecessor=false,cloudTransport=null,bridgeBootstrap=null,processPolicyBootstrap=null,semanticLspBootstrap=null,enableMachineFs=false,enableObservation=false,enableAutonomousSupervisor=false,hostCommandPins=[]}){
+export async function performSlotUpdate({stage,developmentRoot,expectedVersion,expectedManifest,sourceRoot=null,stateRoot=DEFAULT_STATE_ROOT,restoreStandingGrants=false,recoverOfflinePredecessor=false,cloudTransport=null,bridgeBootstrap=null,processPolicyBootstrap=null,desktopPolicyBootstrap=null,semanticLspBootstrap=null,enableMachineFs=false,enableObservation=false,enableDesktop=false,enableAutonomousSupervisor=false,hostCommandPins=[]}){
   if(process.platform!=='win32') throw new Error('R27 slot update is Windows-only');
   const state=path.resolve(stateRoot),stageRoot=path.resolve(stage),development=assertDevelopmentRootSafe(developmentRoot,state);
   const key=await loadUpdateKey(state); const updateId=`r27-${expectedManifest.slice(0,16)}-${Date.now().toString(36)}-${randomBytes(4).toString('hex')}`;
@@ -820,6 +851,8 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       control.processPolicy=processBootstrap.policy;
       control.config.ProcessRuntimeEnabled=true;
     }
+    const desktopBootstrap=await prepareDesktopPolicyBootstrap(desktopPolicyBootstrap);
+    if(desktopBootstrap) control.desktopPolicy=desktopBootstrap.policy;
     const semanticBootstrap=await prepareSemanticLspConfigBootstrap(semanticLspBootstrap);
     if(semanticBootstrap){
       control.config.SemanticLspConfigFile=semanticBootstrap.path;
@@ -834,6 +867,10 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       if(control.config.CodingRuntimeEnabled!==true) throw new Error('ObservationRuntimeEnabled requires CodingRuntimeEnabled');
       control.config.ObservationRuntimeEnabled=true;
     }
+    if(enableDesktop){
+      if(!control.desktopPolicy) throw new Error('DesktopRuntimeEnabled requires pinned desktop policy bootstrap or existing policy');
+      control.config.DesktopRuntimeEnabled=true;
+    }
     control.config=await prepareBridgeSpec(control.config,bridgeBootstrap);
     control.config=await prepareNamedTunnelCloudSpec(control.config,{releaseRoot:slot.release_root,bootstrap:cloudTransport});
     control.config=await prepareAutonomousSupervisorSpec(control.config,{releaseRoot:slot.release_root,enable:enableAutonomousSupervisor});
@@ -860,7 +897,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     launchers=await launcherPlan(state);
     const generation=await createGenerationBundle({stateRoot:state,releaseRoot:slot.release_root,developmentRoot:development,
       workspaceRoot:workspace.target,releaseId:slot.release_id,currentConfig:control.config,codingPolicy:control.codingPolicy,
-      autonomousPolicy:control.autonomousPolicy,hostPolicy:control.hostPolicy,processPolicy:control.processPolicy});
+      autonomousPolicy:control.autonomousPolicy,hostPolicy:control.hostPolicy,processPolicy:control.processPolicy,desktopPolicy:control.desktopPolicy});
     newPointer={schema:'deadbyte.active-release.v1',release_id:slot.release_id,version:expectedVersion,manifest_sha256:expectedManifest,
       release_root:slot.release_root,generation_root:generation.generation_root,generation_manifest_sha256:generation.generation_manifest_sha256,
       launcher_sha256:launchers.launcher_sha256,config_path:generation.config_path};
@@ -875,7 +912,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       coding_repin:{requested:hostCommandPins.length>0,repinned:authorityPreparation.codingRepinned},new_pointer:publicPointer(newPointer)});
     predecessor=await capturePredecessor(control.ctx,recoverOfflinePredecessor); oldRuntime=predecessor.runtime; priorStatus=predecessor.status;
     await writeState(statePath,journal,'old_runtime_verified',{predecessor_mode:predecessor.mode,old_runtime:generationTuple(oldRuntime),
-      prior_authority:{coding_armed:priorStatus.coding_armed,autonomous_armed:priorStatus.autonomous_armed,host_armed:priorStatus.host_armed}});
+      prior_authority:{coding_armed:priorStatus.coding_armed,autonomous_armed:priorStatus.autonomous_armed,desktop_armed:priorStatus.desktop_armed,host_armed:priorStatus.host_armed}});
     const revoke=await revokeAuthority(control.ctx,priorStatus); revoked=revoke.revoked;
     await writeState(statePath,journal,'authority_revoked',{revoked_before_switch:revoked});
     if(oldRuntime){
@@ -897,7 +934,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     await writeState(statePath,journal,'fresh_runtime_verified',{new_runtime:generationTuple(newRuntime),stabilization});
     const finalAuthority=await restoreStandingAuthority(newCtx,priorStatus,restoreStandingGrants);
     await writeState(statePath,journal,'authority_verified',{final_authority:{coding_armed:finalAuthority.coding_armed,
-      autonomous_armed:finalAuthority.autonomous_armed,host_armed:finalAuthority.host_armed}});
+      autonomous_armed:finalAuthority.autonomous_armed,desktop_armed:finalAuthority.desktop_armed,host_armed:finalAuthority.host_armed}});
     const body={schema:UPDATE_SCHEMA,update_id:updateId,release_version:expectedVersion,candidate_manifest_sha256:expectedManifest,
       completed_at_utc:new Date().toISOString(),activation_boundary:'active-release-pointer',mechanism:'immutable-release-slot-plus-atomic-pointer-rename',
       predecessor_mode:predecessor.mode,prior_pointer:publicPointer(pointerInfo.pointer),active_pointer:publicPointer(newPointer),release_slot:{release_id:slot.release_id,release_root:slot.release_root,
@@ -908,8 +945,9 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       host_repin:{requested:hostCommandPins.length>0,repinned:authorityPreparation.hostRepinned},
       coding_repin:{requested:hostCommandPins.length>0,repinned:authorityPreparation.codingRepinned},old_runtime:generationTuple(oldRuntime),new_runtime:generationTuple(newRuntime),stabilization,
       authority:{prior:{coding_armed:priorStatus.coding_armed,
-      autonomous_armed:priorStatus.autonomous_armed,host_armed:priorStatus.host_armed},revoked_before_switch:revoked,restore_requested:restoreStandingGrants,
-      final:{coding_armed:finalAuthority.coding_armed,autonomous_armed:finalAuthority.autonomous_armed,host_armed:finalAuthority.host_armed}},rollback_performed:false};
+      autonomous_armed:priorStatus.autonomous_armed,desktop_armed:priorStatus.desktop_armed,host_armed:priorStatus.host_armed},revoked_before_switch:revoked,restore_requested:restoreStandingGrants,
+      desktop_restore_policy:'explicit-rearm-required',
+      final:{coding_armed:finalAuthority.coding_armed,autonomous_armed:finalAuthority.autonomous_armed,desktop_armed:finalAuthority.desktop_armed,host_armed:finalAuthority.host_armed}},rollback_performed:false};
     const receipt=await writeEnvelope(receiptPath,body,key);
     await writeState(statePath,journal,'completed',{receipt_path:receiptPath,receipt_sha256:receipt.receipt_sha256});
     return {ok:true,update_id:updateId,state_path:statePath,receipt_path:receiptPath,receipt_sha256:receipt.receipt_sha256,
@@ -1042,8 +1080,8 @@ export async function runSlotUpdateCli(argv=process.argv.slice(2),{stateRoot=DEF
   const args=parseUpdateArgs(argv);
   const result=await performSlotUpdate({stage:args.stage,developmentRoot:args.developmentRoot,expectedVersion:args.expectedVersion,
     expectedManifest:args.expectedManifest,sourceRoot:args.sourceRoot,stateRoot,restoreStandingGrants:args.restoreStandingGrants,recoverOfflinePredecessor:args.recoverOfflinePredecessor,
-    cloudTransport:args.cloudTransport,bridgeBootstrap:args.bridgeBootstrap,processPolicyBootstrap:args.processPolicyBootstrap,semanticLspBootstrap:args.semanticLspBootstrap,enableMachineFs:args.enableMachineFs,
-    enableObservation:args.enableObservation,enableAutonomousSupervisor:args.enableAutonomousSupervisor,hostCommandPins:args.hostCommandPins});
+    cloudTransport:args.cloudTransport,bridgeBootstrap:args.bridgeBootstrap,processPolicyBootstrap:args.processPolicyBootstrap,desktopPolicyBootstrap:args.desktopPolicyBootstrap,semanticLspBootstrap:args.semanticLspBootstrap,enableMachineFs:args.enableMachineFs,
+    enableObservation:args.enableObservation,enableDesktop:args.enableDesktop,enableAutonomousSupervisor:args.enableAutonomousSupervisor,hostCommandPins:args.hostCommandPins});
   console.log(`R27_SLOT_UPDATE_PASS version=${args.expectedVersion}`);
   console.log(`UPDATE_ID ${result.update_id}`); console.log(`RECEIPT_SHA256 ${result.receipt_sha256}`);
   console.log(`STATE_PATH ${result.state_path}`); console.log(`ACTIVE_RELEASE ${result.pointer.release_id}`);

package/src/tool-audit.mjs

@@ -82,15 +82,42 @@ function outcomeReceiptHashes(result){
   visit(result?.structuredContent??result);
   return [...found].sort();
 }
+function safeOutcomeReason(value){
+  if(value===null||value===undefined) return null;
+  let text=typeof value==='string'?value:(value instanceof Error?String(value.message??value):null);
+  if(text===null) return null;
+  text=text.replace(/[\\r\\n\\t]+/g,' ').replace(/\\s{2,}/g,' ').trim();
+  if(!text) return null;
+  const originalBytes=Buffer.from(text,'utf8');
+  if(secretValuePattern.test(text)) return `<redacted reason bytes=${originalBytes.length} sha256=${sha256(originalBytes)}>`;
+  const max=240;
+  if(text.length>max) text=`${text.slice(0,max-1)}…`;
+  return text;
+}
+function resultOutcomeReason(result){
+  const structured=result?.structuredContent;
+  const candidates=[
+    structured?.error,structured?.message,structured?.reason,structured?.result?.error,structured?.result?.message,
+    ...(Array.isArray(result?.content)?result.content.filter(item=>item?.type==='text').map(item=>item.text):[])
+  ];
+  for(const candidate of candidates){
+    const reason=safeOutcomeReason(candidate);
+    if(reason) return reason;
+  }
+  return null;
+}
 function summarizeOutcome(result,error,durationMs){
   const duration=Math.max(0,Math.round(Number(durationMs)||0));
   if(error){
     const message=String(error?.message??error);
-    return {status:'threw',is_error:true,duration_ms:duration,receipt_sha256s:[],error:{name:String(error?.name||'Error').slice(0,128),byte_count:Buffer.byteLength(message,'utf8'),sha256:sha256(Buffer.from(message,'utf8'))}};
+    return {status:'threw',is_error:true,duration_ms:duration,receipt_sha256s:[],reason:safeOutcomeReason(message),
+      error:{name:String(error?.name||'Error').slice(0,128),byte_count:Buffer.byteLength(message,'utf8'),sha256:sha256(Buffer.from(message,'utf8'))}};
   }
   const structured=result?.structuredContent;
   const status=typeof structured?.status==='string'?structured.status:(result?.isError===true?'error':'ok');
-  return {status:String(status).slice(0,128),is_error:result?.isError===true,duration_ms:duration,receipt_sha256s:outcomeReceiptHashes(result)};
+  const isError=result?.isError===true;
+  return {status:String(status).slice(0,128),is_error:isError,duration_ms:duration,receipt_sha256s:outcomeReceiptHashes(result),
+    ...(isError?{reason:resultOutcomeReason(result)}:{})};
 }
 
 async function appendSynced(file,line){

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.11.3';
+export const DEADBYTE_VERSION = '0.12.0';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/autonomous-capability-r36.test.mjs

@@ -32,7 +32,11 @@ const typedCases=[
   ['machine_fs_delete',{kind:'machine_fs_delete',path:'empty',expected_source_identity:H}],
   ['observation_search_start',{kind:'observation_search_start',path:'.',pattern:'FAIL',case_sensitive:false,max_results:100,max_files:1000,max_bytes:1048576,max_file_bytes:262144}],
   ['observation_search_page',{kind:'observation_search_page',search_id:H,cursor:null,limit:50}],
-  ['observation_system_status',{kind:'observation_system_status'}]
+  ['observation_system_status',{kind:'observation_system_status'}],
+  ['desktop_status',{kind:'desktop_status'}],
+  ['desktop_observe',{kind:'desktop_observe'}],
+  ['desktop_target',{kind:'desktop_target',frame_id:H,uia_query:{kind:'root',value:'',max_results:1,ordinal:0}}],
+  ['desktop_action',{kind:'desktop_action',action_kind:'click_primary',expected_frame_id:H,target_id:null,point:{x:10,y:20},scroll_delta:null,key_chord:null,text:null}]
 ];
 
 test('R36 planner parses first-class capability actions without delegate wrapper',()=>{
@@ -44,6 +48,20 @@ test('R36 planner parses first-class capability actions without delegate wrapper
   }
 });
 
+test('R40 T7 planner rejects ambiguous Desktop actions before runtime',()=>{
+  assert.throws(()=>parseR34PlannerDecision(wrap({
+    kind:'desktop_action',action_kind:'click_primary',expected_frame_id:H,
+    target_id:H,point:{x:1,y:2},scroll_delta:null,key_chord:null,text:null
+  }),policy),/exactly one/);
+  assert.throws(()=>parseR34PlannerDecision(wrap({
+    kind:'desktop_action',action_kind:'key_chord',expected_frame_id:H,
+    target_id:null,point:null,scroll_delta:null,key_chord:['CTRL','CTRL'],text:null
+  }),policy),/duplicate/);
+  assert.throws(()=>parseR34PlannerDecision(wrap({
+    kind:'desktop_target',frame_id:H,uia_query:{kind:'root',value:'not-empty',max_results:1,ordinal:0}
+  }),policy),/root query value/);
+});
+
 test('R36 legacy delegate is accepted only for a known operation and normalized into typed action',()=>{
   const parsed=parseR34PlannerDecision(wrap({kind:'delegate',operation:{kind:'process_status',session_id:H}}),policy);
   assert.equal(parsed.action.kind,'process_status');
@@ -62,6 +80,30 @@ test('R36 planner prompt exposes configured capability manifest and never advert
   assert.doesNotMatch(prompt,/host\.exec|host_file|host authority/i);
 });
 
+test('R40 T6 autonomous planner receives bounded Desktop memory projection as context only',async()=>{
+  let calls=0;
+  const desktopMemoryProvider={plannerContext:async()=>{
+    calls++;
+    return Object.freeze({
+      schema:'deadbyte.desktop-memory-planner.v1',
+      snapshot_sha256:'1'.repeat(64),memory_sha256:'2'.repeat(64),policy_sha256:'3'.repeat(64),
+      source_receipt_count:7,last_verified_desktop:{frame_id:'4'.repeat(64),desktop_epoch:'5'.repeat(64),topology_sha256:'6'.repeat(64)},
+      windows:[],grounded_targets:[],rejected_target_fingerprints:[],recent_effects:[],unresolved_unknown_effects:[]
+    });
+  }};
+  const f=await createR34Fixture({desktopMemoryProvider});
+  try{
+    const goal=await f.runtime.submit({submissionId:'r40-t6-memory',rootId:'project',title:'desktop memory context',goal:'inspect project',acceptance:'planner sees authenticated desktop summary'});
+    const result=await f.runtime.run({goalId:goal.goal_id,maxCycles:1});
+    assert.equal(result.status,'input_required');
+    assert.equal(calls,1);
+    assert.match(result.planner_request.prompt,/deadbyte\.desktop-memory-planner\.v1/);
+    assert.match(result.planner_request.prompt,/"desktop_memory"/);
+    assert.match(result.planner_request.prompt,/"source_receipt_count":7/);
+    assert.doesNotMatch(result.planner_request.prompt,/data_base64|authority_instance_nonce|SECRET/);
+  }finally{await f.cleanup();}
+});
+
 test('R36 progress fingerprint ignores rationale but binds capability, evidence, session and cursor identity',()=>{
   const base={before:{mutation_epoch:2},after:{mutation_epoch:2},decision:{kind:'process_read',rationale:'first'},evidence:{capability_id:'process.read',session_id:H,cursor:10,observation_sha256:'b'.repeat(64),receipt_sha256:'c'.repeat(64)}};
   const a=judgeProgress(base);

package/test/autonomous-desktop-r40.test.mjs

@@ -0,0 +1,188 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { createR34Fixture,sendPlannerDecision,inspectDecision } from './helpers/autonomous-r34-fixture.mjs';
+
+const H=v=>createHash('sha256').update(String(v)).digest('hex');
+const FRAME=H('desktop-frame');
+const GROUNDED_FRAME=H('desktop-grounded-frame');
+const TARGET=H('desktop-target');
+const POLICY=H('desktop-policy');
+const WIN={hwnd:'0x1234',pid:77,process_image_sha256:H('desktop-app'),title_sha256:H('desktop-title')};
+
+function fakeDesktopRuntime({armed=false,unknown=false}={}){
+  const calls={status:0,observe:0,ground:0,action:0,verify:0};
+  const receipts=new Map();
+  let seq=0;
+  const issue=kind=>{
+    const receipt_id=(++seq).toString(16).padStart(24,'0');
+    const receipt_sha256=H(kind+':'+receipt_id);
+    receipts.set(receipt_id,{ok:true,receipt_id,receipt_sha256,kind});
+    return {receipt_id,receipt_sha256};
+  };
+  const frame=id=>({frame_id:id,desktop_epoch:H('epoch'),topology_sha256:H('topology'),
+    observed_at_utc:'2026-09-19T10:00:00.000Z',bounds:{left:0,top:0,width:1920,height:1080},
+    active_window:WIN,image_sha256:H('image:'+id)});
+  return {
+    calls,
+    async status(){calls.status++;return {status:'ok',configured:true,armed,reason:armed?'standing-grant':'disarmed',
+      action_kinds:armed?['click_primary']:[],policy_sha256:POLICY,observer_backend:'fake'};},
+    async observe(){calls.observe++;const r=issue('desktop_observation');return {status:'ok',frame:frame(FRAME),backend:'fake',byte_length:4,...r};},
+    async ground({frameId,query}){calls.ground++;assert.equal(frameId,FRAME);assert.equal(query.kind,'root');
+      const r=issue('desktop_grounding');return {status:'ok',frame:frame(GROUNDED_FRAME),
+        target:{target_id:TARGET,frame_id:GROUNDED_FRAME,rect:{left:100,top:100,width:200,height:80},source:'uia'},
+        grounding:{query_sha256:H('query'),query_kind:'root',match_count:1,ordinal:0,provider_receipt_sha256:H('provider'),...r}};},
+    async action(args){calls.action++;
+      assert.equal(args.effectContext.goalId.length,64);
+      if(unknown){
+        assert.equal(args.expectedFrameId,FRAME);assert.equal(args.effectContext.observationHeadSha256,FRAME);
+        const e=new Error('transport lost after SendInput');e.side_effect_state='unknown';const r=issue('desktop_action_outcome_unknown');
+        e.receipt_id=r.receipt_id;e.receipt_sha256=r.receipt_sha256;throw e;
+      }
+      assert.equal(args.expectedFrameId,GROUNDED_FRAME);assert.equal(args.targetId,TARGET);
+      assert.equal(args.effectContext.observationHeadSha256,GROUNDED_FRAME);
+      const started=issue('desktop_action_started'),post=issue('desktop_post_observation'),done=issue('desktop_action_completed');
+      return {status:'ok',injected:true,side_effect_state:'confirmed_injected',
+        action:{intent_id:args.intentId,kind:'click_primary',frame_id:GROUNDED_FRAME,desktop_epoch:H('epoch'),
+          topology_sha256:H('topology'),expected_window:WIN,target_id:TARGET,point:{x:200,y:140},
+          scroll_delta:null,key_chord:null,text:null,text_sha256:null,action_sha256:H('action')},
+        guard:{guard_sha256:H('guard')},post_observation:{change_observed:true,window_changed:false,
+          post_observation_sha256:H('post-observation')},action_chain:{chain_sha256:H('chain')},
+        effect_id:H('effect'),effect_fingerprint:H('effect-fp'),effect_completion:{schema:'deadbyte.effect-completion.v1',result_sha256:H('effect-result')},
+        started_receipt_id:started.receipt_id,started_receipt_sha256:started.receipt_sha256,
+        post_receipt_id:post.receipt_id,post_receipt_sha256:post.receipt_sha256,
+        receipt_id:done.receipt_id,receipt_sha256:done.receipt_sha256};},
+    async verifyReceipt({receiptId}){calls.verify++;const r=receipts.get(receiptId);if(!r)throw new Error('unknown fake receipt');return r;}
+  };
+}
+
+const plan=steps=>({schema:'deadbyte.autonomous-decision.v2',kind:'plan_create',title:'Desktop flow',
+  reason:'prove bounded desktop loop',steps:steps.map(step_id=>({step_id,intent:step_id}))});
+const complete=(step_id,tag)=>({schema:'deadbyte.autonomous-decision.v2',kind:'step_complete',step_id,
+  evidence:[{kind:'desktop',id:tag,sha256:H(tag)}]});
+
+async function toAct(f,goal,result){
+  result=await sendPlannerDecision(f.runtime,goal.goal_id,result,inspectDecision());
+  assert.equal(result.loop.phase,'ACTING');
+  return result;
+}
+
+test('T7 capability manifest exposes Desktop only when runtime exists and never Host',async()=>{
+  const d=fakeDesktopRuntime();
+  const f=await createR34Fixture({desktopRuntime:d});
+  try{
+    const goal=await f.runtime.submit({submissionId:'r40-t7-manifest',rootId:'project',title:'desktop manifest',goal:'inspect desktop',acceptance:'desktop capability visible'});
+    const result=await f.runtime.run({goalId:goal.goal_id,maxCycles:1});
+    assert.equal(result.status,'input_required');
+    assert.match(result.planner_request.prompt,/"id":"desktop\.observe"/);
+    assert.match(result.planner_request.prompt,/"id":"desktop\.action"/);
+    assert.match(result.planner_request.prompt,/"authority":"desktop"/);
+    assert.doesNotMatch(result.planner_request.prompt,/host\.exec|host_file/);
+  }finally{await f.cleanup();}
+});
+
+test('T7 read-only Desktop observe works while Desktop mutation authority is DISARMED',async()=>{
+  const d=fakeDesktopRuntime({armed:false});
+  const f=await createR34Fixture({desktopRuntime:d});
+  try{
+    const goal=await f.runtime.submit({submissionId:'r40-t7-observe',rootId:'project',title:'desktop observe',goal:'observe desktop',acceptance:'signed observation'});
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,plan(['observe']));
+    result=await toAct(f,goal,result);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'desktop_observe'}});
+    assert.equal(result.loop.phase,'VERIFYING');
+    assert.equal(d.calls.observe,1);assert.equal(d.calls.action,0);assert.equal(d.calls.verify,1);
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const completed=journal.events.find(e=>e.type==='delegated_action_completed'&&e.payload?.operation?.kind==='desktop_observe');
+    assert.equal(completed.payload.capability_id,'desktop.observe');
+    assert.equal(completed.payload.evidence.kind,'desktop_receipts');
+  }finally{await f.cleanup();}
+});
+
+test('T7 Autonomous authority cannot substitute for missing Desktop mutation grant',async()=>{
+  const d=fakeDesktopRuntime({armed:false});
+  const f=await createR34Fixture({desktopRuntime:d});
+  try{
+    const goal=await f.runtime.submit({submissionId:'r40-t7-disarmed',rootId:'project',title:'desktop disarmed',goal:'click only if separately authorized',acceptance:'no input without Desktop grant'});
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,plan(['act']));
+    result=await toAct(f,goal,result);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{
+      kind:'desktop_action',action_kind:'click_primary',expected_frame_id:FRAME,target_id:null,point:{x:20,y:20},
+      scroll_delta:null,key_chord:null,text:null
+    }});
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'desktop_authority_unavailable');
+    assert.equal(d.calls.action,0);
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    assert.ok(journal.events.some(e=>e.type==='waiting_entered'&&e.payload?.reason==='desktop_authority_unavailable'));
+    assert.equal(journal.events.some(e=>e.type==='delegated_action_started'&&e.payload?.operation?.kind==='desktop_action'),false);
+  }finally{await f.cleanup();}
+});
+
+test('T7 armed flow binds observe to UIA target to one Desktop action and verifies every Desktop receipt',async()=>{
+  const d=fakeDesktopRuntime({armed:true});
+  const f=await createR34Fixture({desktopRuntime:d});
+  try{
+    const goal=await f.runtime.submit({submissionId:'r40-t7-flow',rootId:'project',title:'desktop flow',goal:'observe target click',acceptance:'one receipt-verified action'});
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,plan(['observe','target','act']));
+
+    result=await toAct(f,goal,result);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'desktop_observe'}});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,complete('observe','observe-proof'));
+
+    result=await toAct(f,goal,result);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{
+      kind:'desktop_target',frame_id:FRAME,uia_query:{kind:'root',value:'',max_results:1,ordinal:0}
+    }});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,complete('target','target-proof'));
+
+    result=await toAct(f,goal,result);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{
+      kind:'desktop_action',action_kind:'click_primary',expected_frame_id:GROUNDED_FRAME,target_id:TARGET,point:null,
+      scroll_delta:null,key_chord:null,text:null
+    }});
+    assert.equal(result.loop.phase,'VERIFYING');
+    assert.equal(d.calls.observe,1);assert.equal(d.calls.ground,1);assert.equal(d.calls.action,1);
+    assert.equal(d.calls.verify,5);
+
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const completed=journal.events.filter(e=>e.type==='delegated_action_completed'&&String(e.payload?.operation?.kind).startsWith('desktop_'));
+    assert.deepEqual(completed.map(e=>e.payload.operation.kind),['desktop_observe','desktop_target','desktop_action']);
+    const action=completed.at(-1);
+    assert.equal(action.payload.capability_id,'desktop.action');
+    assert.equal(action.payload.evidence.kind,'desktop_receipts');
+    assert.deepEqual(action.payload.evidence.receipts.map(x=>x.kind),[
+      'desktop_action_started','desktop_post_observation','desktop_action_completed'
+    ]);
+    assert.equal(Object.hasOwn(action.payload.result.action_summary,'text'),false);
+  }finally{await f.cleanup();}
+});
+
+test('T7 UNKNOWN Desktop outcome pauses for critic/replan and is never replayed',async()=>{
+  const d=fakeDesktopRuntime({armed:true,unknown:true});
+  const f=await createR34Fixture({desktopRuntime:d});
+  try{
+    const goal=await f.runtime.submit({submissionId:'r40-t7-unknown',rootId:'project',title:'desktop unknown',goal:'never replay unknown',acceptance:'pause on uncertain side effect'});
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,plan(['observe','act']));
+    result=await toAct(f,goal,result);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'desktop_observe'}});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,complete('observe','observe-proof-unknown'));
+    result=await toAct(f,goal,result);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{
+      kind:'desktop_action',action_kind:'click_primary',expected_frame_id:FRAME,target_id:null,point:{x:40,y:40},
+      scroll_delta:null,key_chord:null,text:null
+    }});
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'desktop_outcome_unknown');
+    assert.equal(d.calls.action,1);
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    assert.ok(journal.events.some(e=>e.type==='waiting_entered'&&e.payload?.reason==='desktop_outcome_unknown'&&e.payload?.resume_phase==='CRITIC'));
+    assert.ok(journal.events.some(e=>e.type==='goal_paused'&&e.payload?.side_effect_state==='unknown'));
+    const again=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    assert.equal(again.status,'paused');
+    assert.equal(d.calls.action,1,'UNKNOWN action was replayed');
+  }finally{await f.cleanup();}
+});

package/test/capability-ledger-r36.test.mjs

@@ -36,6 +36,7 @@ test('R36 capability ledger rejects duplicate ids', () => {
 
 test('R36 capability ledger validates authority and canonicalizes identity', () => {
   assert.throws(() => createCapabilityLedger([entry({authority:'root'})]), /authority/i);
+  assert.doesNotThrow(()=>createCapabilityLedger([entry({authority:'desktop'})]));
   const a=createCapabilityLedger([
     entry({id:'process.read',full_tool:'process_session_read',compact_tool:'process_session',compact_op:'read',runtime_flag:'DEADBYTE_PROCESS_RUNTIME',authority:'process'}),
     entry({})