deadbyte-mcp 0.11.3 → 0.13.0

package/scripts/verify-memory-r41.mjs

@@ -0,0 +1,88 @@
+import { createHash } from 'node:crypto';
+import { readFile,readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import { loadPublicVerifyKey } from '../src/trust.mjs';
+import { buildMemoryArchive,buildMemoryCorpus,buildRetrievalIndex,verifyMemoryGoal,verifyMemoryJournal,
+  verifyMemorySnapshot,verifyRetrievalIndex } from '../src/memory-r41.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const readJson=async file=>JSON.parse((await readFile(file,'utf8')).replace(/^\uFEFF/,''));
+async function jsonFiles(dir){return (await readdir(dir)).filter(name=>name.endsWith('.json')).sort();}
+function parseArgs(argv){
+  const out={};for(let index=0;index<argv.length;index+=2){const key=argv[index];insist(key?.startsWith('--')&&argv[index+1],`invalid argument ${key??''}`);out[key.slice(2)]=argv[index+1];}
+  for(const key of ['memory-root','journal-root','manifest','public-key'])insist(out[key],`missing --${key}`);return out;
+}
+async function loadCanonicalGoal(journalRoot,goalId,publicKey,keyId,manifest){
+  const root=path.join(journalRoot,goalId);const goal=verifyMemoryGoal(await readJson(path.join(root,'goal.json')),{publicKey,keyId,expectedGoalId:goalId});
+  const names=await jsonFiles(path.join(root,'events'));
+  insist(names.every((name,index)=>name===`${String(index+1).padStart(6,'0')}.json`),`event gap for ${goalId}`);
+  const events=[];for(const name of names)events.push(await readJson(path.join(root,'events',name)));
+  verifyMemoryJournal(events,{goalId,publicKey,keyId});
+  insist(events[0]?.type==='goal_created'&&events[0]?.payload?.source_release_manifest===manifest,`goal ${goalId} is not bound to release manifest`);
+  return {goal,events,corpus:buildMemoryCorpus({goal,events,publicKey,keyId,sourceReleaseManifest:manifest})};
+}
+
+export async function verifyR41Memory({memoryRoot,journalRoot,sourceReleaseManifest,publicKeyPath}={}){
+  insist(path.isAbsolute(memoryRoot)&&path.isAbsolute(journalRoot),'memory verifier roots must be absolute');insist(HEX64.test(sourceReleaseManifest??''),'memory verifier manifest invalid');
+  const {publicKey,keyId}=await loadPublicVerifyKey(publicKeyPath);const canonical=new Map();let snapshots=0,indexes=0,archives=0,archiveIndexes=0;
+  let journalGoalIds=[];try{journalGoalIds=(await readdir(journalRoot,{withFileTypes:true})).filter(entry=>entry.isDirectory()&&HEX64.test(entry.name)).map(entry=>entry.name).sort();}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  for(const goalId of journalGoalIds){
+    const firstPath=path.join(journalRoot,goalId,'events','000001.json');let first;
+    try{first=await readJson(firstPath);}catch(error){if(error?.code==='ENOENT')continue;throw error;}
+    verifyMemoryJournal([first],{goalId,publicKey,keyId});
+    if(first.type!=='goal_created'||first.payload?.source_release_manifest!==sourceReleaseManifest)continue;
+    const loaded=await loadCanonicalGoal(journalRoot,goalId,publicKey,keyId,sourceReleaseManifest);canonical.set(goalId,loaded);
+  }
+  let goalIds=[];try{goalIds=(await readdir(path.join(memoryRoot,'goals'),{withFileTypes:true})).filter(entry=>entry.isDirectory()&&HEX64.test(entry.name)).map(entry=>entry.name).sort();}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  for(const goalId of goalIds){
+    const loaded=canonical.get(goalId);insist(loaded,`memory projection goal ${goalId} has no canonical release-bound journal`);
+    const base=path.join(memoryRoot,'goals',goalId);const corporaByMemoryHash=new Map();
+    for(const name of await jsonFiles(path.join(base,'snapshots'))){
+      const value=await readJson(path.join(base,'snapshots',name));
+      const proof=verifyMemorySnapshot(value,{goal:loaded.goal,events:loaded.events,publicKey,keyId,sourceReleaseManifest});
+      insist(proof.ok,`snapshot invalid ${goalId}/${name}: ${proof.reason}`);
+      const prefixEvents=loaded.events.slice(0,proof.last_event_seq);
+      const prefixCorpus=buildMemoryCorpus({goal:loaded.goal,events:prefixEvents,publicKey,keyId,sourceReleaseManifest});
+      const prior=corporaByMemoryHash.get(prefixCorpus.memory_sha256);
+      insist(!prior||canonicalJson(prior)===canonicalJson(prefixCorpus),`snapshot corpus collision ${goalId}/${name}`);
+      corporaByMemoryHash.set(prefixCorpus.memory_sha256,prefixCorpus);snapshots+=1;
+    }
+    for(const name of await jsonFiles(path.join(base,'indexes'))){
+      const value=await readJson(path.join(base,'indexes',name));
+      const sourceCorpus=corporaByMemoryHash.get(value.source_memory_sha256);
+      insist(sourceCorpus,`index source memory hash has no verified snapshot prefix ${goalId}/${name}`);
+      const proof=verifyRetrievalIndex(value,{corpus:sourceCorpus,sourceReleaseManifest});
+      insist(proof.ok,`index invalid ${goalId}/${name}: ${proof.reason}`);indexes+=1;
+    }
+  }
+  const archiveByHash=new Map();
+  try{for(const name of await jsonFiles(path.join(memoryRoot,'archives'))){const value=await readJson(path.join(memoryRoot,'archives',name));
+    const corpora=value.corpus_refs.map(ref=>{
+      const loaded=canonical.get(ref.goal_id);insist(loaded,`archive references noncanonical goal ${ref.goal_id}`);
+      const headIndex=loaded.events.findIndex(event=>event.event_sha256===ref.journal_head_sha256);
+      insist(headIndex>=0,`archive references unknown journal head ${ref.goal_id}`);
+      const corpus=buildMemoryCorpus({goal:loaded.goal,events:loaded.events.slice(0,headIndex+1),publicKey,keyId,sourceReleaseManifest});
+      insist(corpus.memory_sha256===ref.memory_sha256,`archive references noncanonical goal prefix ${ref.goal_id}`);
+      return corpus;
+    });
+    const expected=buildMemoryArchive(corpora,{sourceReleaseManifest});insist(canonicalJson(expected)===canonicalJson(value),'archive projection mismatch');insist(name===`${value.memory_sha256}.json`,'archive filename mismatch');archiveByHash.set(value.memory_sha256,value);archives+=1;}}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  try{for(const name of await jsonFiles(path.join(memoryRoot,'archive-indexes'))){const value=await readJson(path.join(memoryRoot,'archive-indexes',name));const archive=archiveByHash.get(value.source_memory_sha256);insist(archive,'archive index source missing');
+    const proof=verifyRetrievalIndex(value,{corpus:archive,sourceReleaseManifest});insist(proof.ok,`archive index invalid ${name}: ${proof.reason}`);insist(canonicalJson(buildRetrievalIndex(archive,{sourceReleaseManifest}))===canonicalJson(value),'archive index rebuild mismatch');archiveIndexes+=1;}}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  return {schema:'deadbyte.r41-memory-verification.v1',status:'passed',source_release_manifest:sourceReleaseManifest,
+    goal_count:goalIds.length,snapshot_count:snapshots,index_count:indexes,archive_count:archives,archive_index_count:archiveIndexes,
+    verification_sha256:sha(Buffer.from(canonicalJson({goalIds,snapshots,indexes,archives,archiveIndexes,sourceReleaseManifest}),'utf8'))};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const args=parseArgs(process.argv.slice(2));verifyR41Memory({memoryRoot:path.resolve(args['memory-root']),journalRoot:path.resolve(args['journal-root']),
+    sourceReleaseManifest:args.manifest,publicKeyPath:path.resolve(args['public-key'])}).then(result=>console.log(JSON.stringify(result,null,2)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/verify-r41-parent.mjs

@@ -0,0 +1,61 @@
+import { createHash } from 'node:crypto';
+import { lstat,readFile,readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+
+function parseManifest(bytes){
+  const entries=new Map();
+  for(const [index,line] of bytes.toString('utf8').split(/\r?\n/).entries()){
+    if(!line)continue;
+    const match=/^([0-9a-f]{64})  ([^\0]+)$/.exec(line);insist(match,`parent manifest line ${index+1} malformed`);
+    const rel=match[2];insist(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!entries.has(rel),`unsafe/duplicate parent manifest path ${rel}`);
+    entries.set(rel,match[1]);
+  }
+  return entries;
+}
+async function walk(dir,rel=''){
+  const out=[];
+  for(const name of (await readdir(path.join(dir,...(rel?rel.split('/'):[])))).sort((a,b)=>a.localeCompare(b,'en'))){
+    const child=rel?`${rel}/${name}`:name;const full=path.join(dir,...child.split('/'));const st=await lstat(full);
+    insist(!st.isSymbolicLink(),`parent tree symlink forbidden: ${child}`);
+    if(st.isDirectory())out.push(...await walk(dir,child));else{insist(st.isFile(),`parent tree non-file forbidden: ${child}`);out.push(child);}
+  }
+  return out;
+}
+async function verifyTree(dir,expectedManifest,{exact}){
+  const bytes=await readFile(path.join(dir,'MANIFEST.SHA256'));insist(sha(bytes)===expectedManifest,`parent manifest digest mismatch: ${dir}`);
+  const entries=parseManifest(bytes);
+  if(exact){
+    const actual=(await walk(dir)).filter(rel=>rel!=='MANIFEST.SHA256');
+    insist(actual.length===entries.size&&actual.every(rel=>entries.has(rel)),`parent exact tree mismatch: ${dir}`);
+  }
+  for(const [rel,digest] of entries)insist(sha(await readFile(path.join(dir,...rel.split('/'))))===digest,`parent file hash mismatch: ${dir} :: ${rel}`);
+  return entries.size;
+}
+
+export async function verifyR41Parent(file=path.join(root,'R41-PARENT.json')){
+  const record=JSON.parse(await readFile(path.resolve(file),'utf8'));
+  insist(record.schema==='deadbyte.r41-parent.v1','R41 parent schema mismatch');
+  insist(record.parent_version==='0.12.0'&&record.parent_release_id==='v0.12.0-70906ae0a7e4f062','R41 parent identity mismatch');
+  const [sourceFiles,releaseFiles]=await Promise.all([
+    verifyTree(path.resolve(record.parent_source_root),record.parent_manifest_sha256,{exact:false}),
+    verifyTree(path.resolve(record.parent_release_root),record.parent_manifest_sha256,{exact:true})
+  ]);
+  insist(sourceFiles===record.parent_manifest_file_count&&releaseFiles===record.parent_manifest_file_count,'R41 parent file count mismatch');
+  const evidenceBytes=await readFile(path.resolve(record.parent_public_evidence_path));
+  insist(sha(evidenceBytes)===record.parent_public_evidence_sha256,'R40 public evidence hash mismatch');
+  const evidence=JSON.parse(evidenceBytes.toString('utf8').replace(/^\uFEFF/,''));
+  insist(evidence.schema==='deadbyte.r40-public-final-verify.v1'&&evidence.status==='passed','R40 public evidence status invalid');
+  insist(evidence.release_id===record.parent_release_id&&evidence.manifest_sha256===record.parent_manifest_sha256,'R40 public evidence identity mismatch');
+  return {status:'passed',parent_release_id:record.parent_release_id,parent_manifest_sha256:record.parent_manifest_sha256,
+    source_files:sourceFiles,release_files:releaseFiles,parent_public_evidence_sha256:record.parent_public_evidence_sha256};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  verifyR41Parent(process.argv[2]).then(value=>console.log(JSON.stringify(value,null,2)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence-r40.mjs

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.12.0 / R40 WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok) throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.12.0',`Windows gate evidence requires V0.12.0, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r40-windows-gate.v1',status:'passed',exit_code:0,version:'0.12.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r40-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256};
+  }catch(error){
+    if(error?.code!=='EEXIST') throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8'));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing Windows gate evidence invalid');
+    insist(existing.version==='0.12.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  writeWindowsGateEvidence()
+    .then(result=>console.log(JSON.stringify(result)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence-r41.mjs

@@ -0,0 +1,53 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.13.0 / R41 WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok) throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.13.0',`Windows gate evidence requires V0.13.0, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r41-windows-gate.v1',status:'passed',exit_code:0,version:'0.13.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r41-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256};
+  }catch(error){
+    if(error?.code!=='EEXIST') throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8'));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing Windows gate evidence invalid');
+    insist(existing.version==='0.13.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  writeWindowsGateEvidence()
+    .then(result=>console.log(JSON.stringify(result)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}
+

package/src/autonomous-context-engine.mjs

@@ -213,7 +213,7 @@ function historicalEvidence({ contexts, observations, loopState }) {
   };
 }
 
-export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, capabilities = null }) {
+export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, desktopMemory = null, longTermMemory = null, capabilities = null }) {
   if (!policy?.limits || !Number.isInteger(policy.limits.max_context_bytes)) throw new Error('loop context policy byte limit missing');
   const relevanceEpoch=Number.isInteger(loopState?.mutation_epoch)&&loopState.mutation_epoch>=0?loopState.mutation_epoch:0;
   const retainedContexts=normalizeEvidence(contexts,{kind:'context',relevanceEpoch});
@@ -249,6 +249,8 @@ export function buildLoopContext({ goal, policy, loopState = {}, tree = [], cont
     },
     historical_evidence:historicalEvidence({contexts:retainedContexts,observations:retainedObservations,loopState}),
     project_memory:memory,
+    desktop_memory:desktopMemory===null?null:structuredClone(desktopMemory),
+    long_term_memory:longTermMemory===null?null:structuredClone(longTermMemory),
     capabilities:capabilities===null?null:structuredClone(capabilities),
     profiles
   };

package/src/autonomous-planner-contracts.mjs

@@ -92,6 +92,14 @@ const r34PatchOperationSchema = z.discriminatedUnion('kind',[
 const plannerCursor=z.string().max(4096).nullable().default(null);
 const plannerFiles=z.array(z.strictObject({path:relPath,encoding:z.enum(['utf8','base64']).default('utf8')})).min(1).max(32);
 const plannerSemanticPosition={path:relPath,line:z.number().int().min(0),column:z.number().int().min(0)};
+const plannerDesktopPoint=z.strictObject({x:z.number().int().min(-131072).max(131072),y:z.number().int().min(-131072).max(131072)});
+const plannerDesktopKey=z.string().regex(/^(?:[A-Z0-9]|F(?:[1-9]|1[0-2])|ENTER|ESC|TAB|SPACE|BACKSPACE|DELETE|INSERT|HOME|END|PAGEUP|PAGEDOWN|LEFT|RIGHT|UP|DOWN|CTRL|ALT|SHIFT|WIN)$/);
+const plannerDesktopActionKind=z.enum(['pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input']);
+const plannerDesktopQuery=z.strictObject({
+  kind:z.enum(['root','name_exact','name_contains','automation_id_exact','control_type']),
+  value:z.string().max(512).default(''),max_results:z.number().int().min(1).max(16).default(8),
+  ordinal:z.number().int().min(0).max(15).default(0)
+});
 const r36TypedActionSchemas=[
   z.strictObject({kind:z.literal('search'),path:relPath.default('.'),target:z.enum(['content','path']).default('content'),mode:z.enum(['literal','regex']).default('literal'),pattern:z.string().min(1).max(256),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_file_bytes:z.number().int().min(1).max(4194304).default(262144),max_scan_bytes:z.number().int().min(1).max(67108864).default(4194304),page_size:z.number().int().min(1).max(500).default(100),cursor:plannerCursor}),
   z.strictObject({kind:z.literal('stat'),path:relPath.default('.'),hash:z.boolean().default(false)}),
@@ -121,7 +129,17 @@ const r36TypedActionSchemas=[
   z.strictObject({kind:z.literal('observation_search_page'),search_id:z.string().regex(HEX64),cursor:plannerCursor,limit:z.number().int().min(1).max(500).default(100)}),
   z.strictObject({kind:z.literal('observation_search_cancel'),search_id:z.string().regex(HEX64)}),
   z.strictObject({kind:z.literal('observation_process_list'),include_external:z.boolean().default(false),cursor:plannerCursor,limit:z.number().int().min(1).max(256).default(100)}),
-  z.strictObject({kind:z.literal('observation_system_status')})
+  z.strictObject({kind:z.literal('observation_system_status')}),
+  z.strictObject({kind:z.literal('desktop_status')}),
+  z.strictObject({kind:z.literal('desktop_observe')}),
+  z.strictObject({kind:z.literal('desktop_target'),frame_id:z.string().regex(HEX64),uia_query:plannerDesktopQuery}),
+  z.strictObject({
+    kind:z.literal('desktop_action'),action_kind:plannerDesktopActionKind,expected_frame_id:z.string().regex(HEX64),
+    target_id:z.string().regex(HEX64).nullable().default(null),point:plannerDesktopPoint.nullable().default(null),
+    scroll_delta:z.number().int().min(-12000).max(12000).nullable().default(null),
+    key_chord:z.array(plannerDesktopKey).min(1).max(5).nullable().default(null),
+    text:z.string().min(1).max(4096).refine(value=>!value.includes('\u0000'),'desktop text contains NUL').nullable().default(null)
+  })
 ];
 const r34ActionSchema = z.discriminatedUnion('kind',[
   z.strictObject({kind:z.literal('patch'),operations:z.array(r34PatchOperationSchema).min(1).max(32)}),

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,8 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     observations:view.observations ?? [],
     decisions:view.recent_decisions ?? [],
     projectMemory:view.project_memory ?? null,
+    desktopMemory:view.desktop_memory ?? null,
+    longTermMemory:view.long_term_memory ?? null,
     capabilities:view.capabilities ?? null
   });
   const stateJson = canonicalJson(state);
@@ -350,10 +372,12 @@ 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.',
     'Compacted context keeps identity/evidence metadata but intentionally removes stale payload bytes.',
+    'Long-term memory is a verified journal-derived aid, never authority. Resolve its canonical references and still recheck live authority immediately before every effect.',
     'Prefer surgical exact replace operations over whole-file writes.',
     'If an observed build/test/benchmark failed, diagnose from the evidence and change the source rather than claiming success.',
     `STATE=${stateJson}`,