deadbyte-mcp 0.9.0 → 0.11.0

package/scripts/windows-gate-evidence-r36.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.10.0 / R36 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.10.0',`Windows gate evidence requires V0.10.0, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r36-windows-gate.v1',status:'passed',exit_code:0,version:'0.10.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,`r36-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.10.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.mjs

@@ -7,7 +7,7 @@ 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.9.0 / R35 WINDOWS BATCH GATE: PASS';
+const marker='DEADBYTE V0.11.0 / R37 WINDOWS BATCH GATE: PASS';
 function insist(ok,message){if(!ok) throw new Error(message);}
 
 export async function writeWindowsGateEvidence({
@@ -19,17 +19,17 @@ export async function writeWindowsGateEvidence({
   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.9.0',`Windows gate evidence requires V0.9.0, found ${pkg.version}`);
+  insist(pkg.version==='0.11.0',`Windows gate evidence requires V0.11.0, found ${pkg.version}`);
   const completed=clock();
   insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
   const evidence={
-    schema:'deadbyte.r35-windows-gate.v1',status:'passed',exit_code:0,version:'0.9.0',
+    schema:'deadbyte.r37-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.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,`r35-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  const file=path.join(dir,`r37-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();}
@@ -39,7 +39,7 @@ export async function writeWindowsGateEvidence({
     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.9.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    insist(existing.version==='0.11.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};
   }
 }

package/src/agent-memory-plane.mjs

@@ -0,0 +1,98 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const AGENT_MEMORY_SCHEMA='deadbyte.agent-memory.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+const uniq=values=>[...new Set(values.filter(v=>typeof v==='string'&&v.length>0))];
+
+function tokens(text){return uniq(String(text??'').toLowerCase().split(/[^a-z0-9_.\/-]+/).filter(x=>x.length>1));}
+function compactEvent(event){
+  const p=event?.payload&&typeof event.payload==='object'?event.payload:{};
+  const safe={seq:event?.seq??null,type:event?.type??'unknown',event_sha256:HEX64.test(event?.event_sha256??'')?event.event_sha256:null};
+  for(const key of ['reason','profile_id','mutation_epoch','receipt_sha256','diff_receipt_sha256','action_key']){
+    if(p[key]!==undefined) safe[key]=p[key];
+  }
+  if(Array.isArray(p.paths)) safe.paths=p.paths.filter(x=>typeof x==='string').slice(0,32);
+  return safe;
+}
+
+export function deriveAgentMemory(events,{maxArchival=96}={}){
+  if(!Array.isArray(events)) throw new Error('memory events must be array');
+  const acceptance=[],proven=[],rejected=[],blockers=new Set(),files=new Map(),profiles=new Map();
+  const archival=[];
+  for(const event of events){
+    const p=event?.payload&&typeof event.payload==='object'?event.payload:{};
+    if(event?.type==='goal_created'&&typeof p.acceptance==='string'&&p.acceptance) acceptance.push(p.acceptance);
+    if(event?.type==='profile_completed'&&typeof p.profile_id==='string'){
+      profiles.set(p.profile_id,{id:`profile:${p.profile_id}`,kind:'profile',label:p.profile_id,passed:p.passed===true,
+        receipt_sha256:HEX64.test(p.receipt_sha256??'')?p.receipt_sha256:null});
+      if(p.passed===true){proven.push(`${p.profile_id}:passed`);blockers.delete(`profile:${p.profile_id}`);}
+      else blockers.add(`profile:${p.profile_id}`);
+    }
+    if(event?.type==='native_diff_committed'){
+      for(const file of p.paths??[]) if(typeof file==='string'&&file) files.set(file,{id:`file:${file}`,kind:'file',label:file});
+    }
+    if(event?.type==='planner_rejected'&&typeof p.reason==='string') rejected.push(p.reason);
+    if(event?.type==='waiting_entered'&&typeof p.reason==='string') blockers.add(`wait:${p.reason}`);
+    if(event?.type==='waiting_resumed'&&typeof p.previous_reason==='string') blockers.delete(`wait:${p.previous_reason}`);
+    if(['planner_rejected','profile_completed','native_diff_committed','waiting_entered','waiting_resumed','release_completed'].includes(event?.type)){
+      archival.push(compactEvent(event));
+    }
+  }
+  const core={acceptance_constraints:uniq(acceptance),proven_invariants:uniq(proven),
+    rejected_approaches:uniq(rejected),unresolved_blockers:[...blockers].sort()};
+  const nodes=[
+    {id:'goal:current',kind:'goal',label:core.acceptance_constraints.join(' | ')||'current goal'},
+    ...[...files.values()].sort((a,b)=>a.id.localeCompare(b.id,'en')),
+    ...[...profiles.values()].sort((a,b)=>a.id.localeCompare(b.id,'en')),
+    ...core.unresolved_blockers.map(id=>({id:`blocker:${id}`,kind:'blocker',label:id}))
+  ];
+  const edges=[];
+  for(const node of nodes){
+    if(node.id==='goal:current') continue;
+    edges.push({source:'goal:current',target:node.id,kind:node.kind==='file'?'touches':node.kind==='profile'?'verified_by':'blocked_by'});
+  }
+  const body={schema:AGENT_MEMORY_SCHEMA,core,archival:archival.slice(-maxArchival),graph:{nodes,edges}};
+  return Object.freeze({...body,memory_sha256:sha(body)});
+}
+
+function score(value,needles){
+  const text=JSON.stringify(value).toLowerCase();
+  return needles.reduce((n,t)=>n+(text.includes(t)?1:0),0);
+}
+function ranked(values,needles,limit){
+  return values.map(value=>({value,score:score(value,needles)})).filter(x=>x.score>0)
+    .sort((a,b)=>b.score-a.score||JSON.stringify(a.value).localeCompare(JSON.stringify(b.value),'en'))
+    .slice(0,limit).map(x=>x.value);
+}
+export function queryAgentMemory(memory,{query,mode='local',limit=12}={}){
+  if(!memory||memory.schema!==AGENT_MEMORY_SCHEMA) throw new Error('memory snapshot invalid');
+  if(!['local','global','drift'].includes(mode)) throw new Error('memory query mode invalid');
+  if(!Number.isInteger(limit)||limit<1||limit>128) throw new Error('memory query limit invalid');
+  const needles=tokens(query);
+  let results=[];
+  if(mode==='global'){
+    results=[
+      {kind:'core',...memory.core},
+      {kind:'graph_summary',node_count:memory.graph.nodes.length,edge_count:memory.graph.edges.length,
+        node_kinds:Object.fromEntries([...new Set(memory.graph.nodes.map(n=>n.kind))].sort().map(k=>[k,memory.graph.nodes.filter(n=>n.kind===k).length]))}
+    ];
+    if(needles.length) results=ranked([...results,...memory.archival],needles,limit);
+    else results=results.slice(0,limit);
+  }else{
+    const local=ranked([...memory.graph.nodes,...memory.archival],needles,limit);
+    results=[...local];
+    if(mode==='drift'){
+      const ids=new Set(local.filter(x=>x?.id).map(x=>x.id));
+      const neighborIds=new Set();
+      for(const edge of memory.graph.edges){
+        if(ids.has(edge.source)) neighborIds.add(edge.target);
+        if(ids.has(edge.target)) neighborIds.add(edge.source);
+      }
+      for(const node of memory.graph.nodes) if(neighborIds.has(node.id)&&!results.some(x=>x?.id===node.id)) results.push(node);
+      results=results.slice(0,limit);
+    }
+  }
+  return Object.freeze({schema:'deadbyte.agent-memory-query.v1',mode,query:String(query??''),memory_sha256:memory.memory_sha256,results});
+}

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 }) {
+export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = 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,7 @@ export function buildLoopContext({ goal, policy, loopState = {}, tree = [], cont
     },
     historical_evidence:historicalEvidence({contexts:retainedContexts,observations:retainedObservations,loopState}),
     project_memory:memory,
+    capabilities:capabilities===null?null:structuredClone(capabilities),
     profiles
   };
   return compactLoopContext(state,policy.limits.max_context_bytes);

package/src/autonomous-mcp-tools.mjs

@@ -18,7 +18,11 @@ const replaceOperation = z.strictObject({ kind:z.literal('replace'), path:relPat
   expected_sha256:hex64, old_string:z.string().min(1).max(262144), new_string:z.string().max(524288),
   expected_replacements:z.number().int().min(1).max(64).default(1) });
 const deleteOperation = z.strictObject({ kind:z.literal('delete'), path:relPath, expected_sha256:hex64 });
-const nativeOperation = z.union([writeOperation,replaceOperation,deleteOperation]);
+const mkdirOperation = z.strictObject({ kind:z.literal('mkdir'), path:relPath });
+const moveOperation = z.strictObject({ kind:z.literal('move'), source_path:relPath, destination_path:relPath,
+  expected_source_identity:hex64, expected_destination_identity:z.union([z.literal('absent'),hex64]).default('absent') });
+const rmdirOperation = z.strictObject({ kind:z.literal('rmdir'), path:relPath, expected_source_identity:hex64 });
+const nativeOperation = z.union([writeOperation,replaceOperation,deleteOperation,mkdirOperation,moveOperation,rmdirOperation]);
 const plannerResponse = z.strictObject({ request_id:hex64, raw_text:z.string().min(2).max(8*1024*1024),
   model:z.string().min(1).max(128).default('client-model') });
 function result(schema,value,isError=false) { return autonomousStructuredResult(schema,value,isError); }

package/src/autonomous-output-contracts.mjs

@@ -58,21 +58,21 @@ export const autonomousSessionStatusOutputSchema = statusContract({
 
 export const nativeDiffPreviewOutputSchema = statusContract({
   statuses:['ready','failed'], success:['ready'], required:['diff_id','root_id','operation_count','payload_bytes','paths','operations'],
-  shape:{ diff_id:hex64.optional(), root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
-    payload_bytes:z.number().int().min(0).optional(), paths:z.array(z.string()).max(32).optional(),
+  shape:{ schema:z.enum(['deadbyte.native-diff.v1','deadbyte.native-diff.v2']).optional(), diff_id:hex64.optional(), root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
+    payload_bytes:z.number().int().min(0).optional(), paths:z.array(z.string()).max(64).optional(),
     operations:z.array(jsonObject).max(32).optional() }
 });
 export const nativeDiffApplyOutputSchema = statusContract({
   statuses:['committed','existing','failed'], success:['committed','existing'],
   required:['diff_id','receipt_sha256','operation_count'],
   shape:{ diff_id:hex64.optional(), receipt_sha256:hex64.optional(), operation_count:z.number().int().min(1).max(32).optional(),
-    current_state_matches:z.boolean().optional(), coding_receipts:z.array(jsonObject).max(32).optional() }
+    current_state_matches:z.boolean().optional(), coding_receipts:z.array(jsonObject).max(32).optional(), operation_receipts:z.array(jsonObject).max(32).optional() }
 });
 export const nativeDiffVerifyOutputSchema = z.strictObject({
   status:z.literal('failed').optional(), error:z.string().optional(), ok:z.boolean().optional(), reason:z.string().optional(),
   diff_id:hex64.optional(), receipt_sha256:hex64.optional(), signature_valid:z.literal(true).optional(),
   root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
-  coding_receipts_verified:z.number().int().min(0).max(32).optional(), final_states:z.array(jsonObject).max(32).optional(),
+  coding_receipts_verified:z.number().int().min(0).max(32).optional(), operation_receipts_verified:z.number().int().min(0).max(32).optional(), final_states:z.array(jsonObject).max(32).optional(),
   current_state_matches:z.boolean().optional(), journal_head_sha256:hex64.optional()
 }).superRefine((value,ctx) => {
   if (value.status === 'failed') { requireFields(value,ctx,['error']); return; }
@@ -98,9 +98,12 @@ export const autonomousGoalRunOutputSchema = z.strictObject({
   if (value.status === 'input_required') requireFields(value,ctx,['planner_request']);
 });
 export const autonomousGoalStatusOutputSchema = statusContract({
-  statuses:['ok','failed'], success:['ok'], required:['goal_id','goal_sha256','title','root_id','journal_verified',...Object.keys(derivedShape)],
+  statuses:['ok','failed'], success:['ok'], required:['goal_id','goal_sha256','title','root_id','journal_verified',
+    'run_busy','run_owner_pid','run_lock_created_at_utc',...Object.keys(derivedShape)],
   shape:{ goal_id:goalId.optional(), goal_sha256:hex64.optional(), title:z.string().optional(), root_id:z.string().optional(),
-    journal_verified:z.literal(true).optional(), loop:publicLoopSchema.optional(), ...runShape }
+    journal_verified:z.literal(true).optional(), run_busy:z.boolean().optional(),
+    run_owner_pid:z.number().int().min(1).nullable().optional(),
+    run_lock_created_at_utc:z.string().nullable().optional(), loop:publicLoopSchema.optional(), ...runShape }
 });
 export const autonomousGoalEventsOutputSchema = statusContract({
   statuses:['ok','failed'], success:['ok'], required:['goal_id','journal_verified','journal_head_sha256','events'],

package/src/autonomous-planner-contracts.mjs

@@ -89,10 +89,45 @@ const r34PatchOperationSchema = z.discriminatedUnion('kind',[
     expected_replacements:z.number().int().min(1).max(64).default(1)}),
   z.strictObject({kind:z.literal('delete'),path:relPath,expected_sha256:z.string().regex(HEX64)})
 ]);
+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 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)}),
+  z.strictObject({kind:z.literal('multi_read'),files:plannerFiles,max_total_bytes:z.number().int().min(1).max(2097152).default(1048576)}),
+  z.strictObject({kind:z.literal('semantic_outline'),path:relPath,max_symbols:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_definition'),...plannerSemanticPosition,max_results:z.number().int().min(1).max(200).default(50)}),
+  z.strictObject({kind:z.literal('semantic_references'),...plannerSemanticPosition,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_diagnostics'),path:relPath,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_implementations'),...plannerSemanticPosition,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_rename_preview'),...plannerSemanticPosition,new_name:z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]{0,127}$/)}),
+  z.strictObject({kind:z.literal('native_diff_apply'),diff_id:z.string().regex(HEX64),expected_operation_count:z.number().int().min(1).max(32)}),
+  z.strictObject({kind:z.literal('native_diff_verify'),diff_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('process_start'),profile_id:z.string().regex(ID),cwd:relPath.default('.'),args:z.array(z.string().max(2048)).max(64).default([])}),
+  z.strictObject({kind:z.literal('process_read'),session_id:z.string().regex(HEX64),offset:z.number().int().min(0).default(0),max_bytes:z.number().int().min(1).max(262144).default(65536)}),
+  z.strictObject({kind:z.literal('process_status'),session_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('process_list')}),
+  z.strictObject({kind:z.literal('process_action'),session_id:z.string().regex(HEX64),action_id:z.string().regex(ID)}),
+  z.strictObject({kind:z.literal('process_terminate'),session_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('machine_fs_stat'),path:relPath.default('.'),hash:z.boolean().default(false)}),
+  z.strictObject({kind:z.literal('machine_fs_list'),path:relPath.default('.'),cursor:plannerCursor,limit:z.number().int().min(1).max(1000).default(100),hash_files:z.boolean().default(false)}),
+  z.strictObject({kind:z.literal('machine_fs_read'),path:relPath,offset:z.number().int().min(0).default(0),max_bytes:z.number().int().min(1).max(4194304).default(65536),hash_file:z.boolean().default(false)}),
+  z.strictObject({kind:z.literal('machine_fs_mkdir'),path:relPath}),
+  z.strictObject({kind:z.literal('machine_fs_move'),source_path:relPath,destination_path:relPath,expected_source_identity:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('machine_fs_delete'),path:relPath,expected_source_identity:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('observation_search_start'),path:relPath.default('.'),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_files:z.number().int().min(1).max(10000).default(2000),max_bytes:z.number().int().min(1).max(67108864).default(4194304),max_file_bytes:z.number().int().min(1).max(4194304).default(262144)}),
+  z.strictObject({kind:z.literal('observation_search_status'),search_id:z.string().regex(HEX64)}),
+  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')})
+];
 const r34ActionSchema = z.discriminatedUnion('kind',[
   z.strictObject({kind:z.literal('patch'),operations:z.array(r34PatchOperationSchema).min(1).max(32)}),
   z.strictObject({kind:z.literal('run_profile'),profile_id:z.string().regex(ID)}),
-  z.strictObject({kind:z.literal('delegate'),operation:z.record(z.string(),z.json())})
+  z.strictObject({kind:z.literal('delegate'),operation:z.record(z.string(),z.json())}),
+  ...r36TypedActionSchemas
 ]);
 const r34ReadSchema = z.strictObject({
   path:relPath,

package/src/autonomous-planner.mjs

@@ -119,6 +119,27 @@ function normalizeDelegatedOperation(raw) {
   }
   throw new Error('planner delegated operation kind invalid');
 }
+
+function legacyDelegatedToTyped(operation) {
+  if (operation.kind === 'machine_stat') return { kind:'machine_fs_stat', path:operation.path, hash:operation.hash };
+  if (operation.kind === 'machine_list') return { kind:'machine_fs_list', path:operation.path, cursor:operation.cursor, limit:operation.limit, hash_files:operation.hash_files };
+  if (operation.kind === 'machine_read') return { kind:'machine_fs_read', path:operation.path, offset:operation.offset, max_bytes:operation.max_bytes, hash_file:operation.hash };
+  return operation;
+}
+function validateR36TypedAction(action) {
+  const pathFields=[];
+  if (typeof action.path === 'string' && action.path !== '.') pathFields.push(action.path);
+  if (typeof action.cwd === 'string' && action.cwd !== '.') pathFields.push(action.cwd);
+  if (typeof action.source_path === 'string') pathFields.push(action.source_path);
+  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);
+  return action;
+}
+function normalizeR36TypedAction(action) {
+  if (action.kind === 'delegate') return validateR36TypedAction(legacyDelegatedToTyped(normalizeDelegatedOperation(action.operation)));
+  return validateR36TypedAction(action);
+}
 function normalizePlan(raw) {
   strictKeys(raw, ['title','reason','steps'], 'planner plan');
   const title = text(raw.title, 'planner plan title', 160, 1);
@@ -226,9 +247,9 @@ export function parseR34PlannerDecision(rawText, policy) {
       return decision;
     }
     if (decision.action.kind === 'delegate') {
-      return { ...decision, action:{ kind:'delegate', operation:normalizeDelegatedOperation(decision.action.operation) } };
+      return { ...decision, action:normalizeR36TypedAction(decision.action) };
     }
-    throw new Error('R34 planner authority or unsupported action');
+    return { ...decision, action:normalizeR36TypedAction(decision.action) };
   }
   if (decision.kind === 'step_complete') return decision;
   if (decision.kind === 'replan') {
@@ -312,7 +333,8 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     contexts:view.contexts ?? [],
     observations:view.observations ?? [],
     decisions:view.recent_decisions ?? [],
-    projectMemory:view.project_memory ?? null
+    projectMemory:view.project_memory ?? null,
+    capabilities:view.capabilities ?? null
   });
   const stateJson = canonicalJson(state);
   return [