deadbyte-mcp 0.10.0 → 0.11.1

package/scripts/windows-gate-evidence-r37-0110.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.11.0 / R37 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.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.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,`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();}
+    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.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};
+  }
+}
+
+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.10.0 / R36 WINDOWS BATCH GATE: PASS';
+const marker='DEADBYTE V0.11.1 / 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.10.0',`Windows gate evidence requires V0.10.0, found ${pkg.version}`);
+  insist(pkg.version==='0.11.1',`Windows gate evidence requires V0.11.1, 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',
+    schema:'deadbyte.r37-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.1',
     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`);
+  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.10.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    insist(existing.version==='0.11.1'&&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-output-contracts.mjs

@@ -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-runtime.mjs

@@ -12,6 +12,10 @@ import { judgeProgress, stallDisposition } from './autonomous-progress.mjs';
 import { classifyProviderFailure, deriveCircuit, providerCallDisposition, providerCircuitId } from './provider-circuit.mjs';
 import { verifyObservationReceiptFile } from './observation-runtime.mjs';
 import { R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
+import { deriveAgentMemory } from './agent-memory-plane.mjs';
+import { effectIdentity, loopGuardDisposition, bindEffectCompletion } from './effect-ledger.mjs';
+import { createWorkerScheduler } from './worker-scheduler.mjs';
+import { issueObservationLease, verifyObservationLease } from './observation-lease.mjs';
 
 export const AUTONOMOUS_GOAL_SCHEMA = 'deadbyte.autonomous-goal.v1';
 export const AUTONOMOUS_EVENT_SCHEMA = 'deadbyte.autonomous-event.v1';
@@ -164,6 +168,22 @@ async function acquireLock(ctx) {
   throw new Error('autonomous lock acquisition failed');
 }
 async function releaseLock(ctx) { await rm(ctx.lockPath,{force:true}); }
+async function runLockStatus(ctx) {
+  let parsed;
+  try { parsed = JSON.parse(await readFile(ctx.lockPath,'utf8')); }
+  catch (error) {
+    if (error?.code === 'ENOENT') return { run_busy:false, run_owner_pid:null, run_lock_created_at_utc:null };
+    throw new Error('autonomous lock malformed');
+  }
+  if (parsed?.schema !== 'deadbyte.autonomous-lock.v1' || parsed?.goal_id !== path.basename(ctx.dir) ||
+      !Number.isInteger(parsed?.pid) || parsed.pid < 1 || typeof parsed?.created_at_utc !== 'string' || !parsed.created_at_utc) {
+    throw new Error('autonomous lock malformed');
+  }
+  const alive=await processExists(parsed.pid);
+  return alive
+    ? { run_busy:true, run_owner_pid:parsed.pid, run_lock_created_at_utc:parsed.created_at_utc }
+    : { run_busy:false, run_owner_pid:null, run_lock_created_at_utc:null };
+}
 async function readCancel(ctx, verifyKeyPath) {
   if (!await exists(ctx.cancelPath)) return null;
   const parsed = JSON.parse(await readFile(ctx.cancelPath,'utf8'));
@@ -339,11 +359,12 @@ function configuredCapabilityManifest({machineFsRuntime,observationRuntime,proce
     entries:Object.freeze(entries)});
 }
 
-async function plannerView(goal, state, codingRuntime, capabilityManifest) {
+async function plannerView(goal, state, events, codingRuntime, capabilityManifest) {
   const tree = await codingRuntime.tree({ rootId:goal.root_id, path:'.', maxDepth:4, maxEntries:600 });
+  const memory=deriveAgentMemory(events,{maxArchival:24});
   return { mutation_epoch:state.mutation_epoch, planner_round:state.planner_round, tree:tree.entries,
     contexts:state.contexts.slice(-16), observations:state.observations.slice(-24), active_plan:state.active_plan,
-    capabilities:capabilityManifest,
+    capabilities:capabilityManifest, project_memory:memory,
     recent_decisions:state.decisions.slice(-8).map(item => ({ planner_round:item.planner_round,
       action:item.decision?.action, summary:item.decision?.summary })) };
 }
@@ -361,7 +382,7 @@ async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, c
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'wall_time_limit', max_wall_ms:policy.limits.max_wall_ms });
     return null;
   }
-  const view = await plannerView(goal,state,codingRuntime,capabilityManifest);
+  const view = await plannerView(goal,state,events,codingRuntime,capabilityManifest);
   let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
   const repair = [...(state.planner_rejections ?? [])].reverse().find(item => item.planner_round === round) ?? null;
   if (repair) {
@@ -749,14 +770,36 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
   }
 }
 
-async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy, codingRuntime, signingKeyPath }) {
+async function executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,actionKey,profileId,policy,codingRuntime,signingKeyPath,r34ResumePhase=null}) {
+  if(!workerScheduler) throw new Error('R37 worker scheduler unavailable');
+  const taskId=`${goal.goal_id}:${actionKey}:${profileId}`;
+  const lease=workerScheduler.acquire({taskId,workerClass:'profile',cpuUnits:1,memoryMb:256});
+  await appendEvent(ctx,events,signingKeyPath,'worker_lease_acquired',{
+    lease_id:lease.lease_id,task_id:lease.task_id,worker_class:lease.worker_class,profile_id:profileId,
+    attempt:lease.attempt,cpu_units:lease.cpu_units,memory_mb:lease.memory_mb,expires_at_ms:lease.expires_at_ms
+  });
+  let outcomeStatus='failed';
+  try {
+    const result=await executeProfile({ctx,events,goalId:goal.goal_id,actionKey,profileId,epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase});
+    outcomeStatus=result.status;
+    return result;
+  } finally {
+    const released=workerScheduler.release(lease.lease_id,{status:outcomeStatus});
+    await appendEvent(ctx,events,signingKeyPath,'worker_lease_released',{
+      lease_id:lease.lease_id,task_id:lease.task_id,worker_class:lease.worker_class,profile_id:profileId,
+      status:released.lease.status,released_at_ms:released.lease.released_at_ms
+    });
+  }
+}
+
+async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy, codingRuntime, signingKeyPath, workerScheduler }) {
   const profileIds = Object.entries(policy.profiles)
     .filter(([,profile]) => profile.run_after_mutation)
     .map(([id]) => id);
   const results = [];
   for (const profileId of profileIds) {
-    const result = await executeProfile({ ctx,events,goalId:goal.goal_id,actionKey:`${actionKey}:${profileId}`,
-      profileId,epoch,policy,codingRuntime,signingKeyPath });
+    const result = await executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,
+      actionKey:`${actionKey}:${profileId}`,profileId,policy,codingRuntime,signingKeyPath});
     results.push({ profile_id:profileId, status:result.status, observation:result.observation });
     if (result.status === 'paused') break;
   }
@@ -817,7 +860,7 @@ async function appendPatchCommit({ctx,events,signingKeyPath,started,decisionEven
   });
 }
 async function executePatch({ ctx, events, goal, state, decisionEvent, decision, nativeDiffRuntime,
-  policy, codingRuntime, signingKeyPath, actionCoordinatesOverride = null }) {
+  policy, codingRuntime, signingKeyPath, workerScheduler, actionCoordinatesOverride = null }) {
   let started = patchStartedForDecision(events,decisionEvent.event_sha256);
   if (!started && state.mutation_count + decision.operations.length > policy.limits.max_mutations) {
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
@@ -853,7 +896,7 @@ async function executePatch({ ctx, events, goal, state, decisionEvent, decision,
     if (!committed) throw new Error('completed patch action missing native diff commit');
     const epoch = committed.payload.mutation_epoch;
     const profiles = await runMutationProfiles({ ctx,events,goal,epoch,
-      actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath });
+      actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath,workerScheduler });
     return { status:profiles.some(item => item.status === 'paused') ? 'paused' : 'completed',
       diff_id:diffId, mutation_epoch:epoch, profiles, recovered:true };
   }
@@ -901,12 +944,12 @@ async function executePatch({ ctx, events, goal, state, decisionEvent, decision,
   }
   const epoch = committed.payload.mutation_epoch;
   const profiles = await runMutationProfiles({ ctx,events,goal,epoch,
-    actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath });
+    actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath,workerScheduler });
   return { status:profiles.some(item => item.status === 'paused') ? 'paused' : 'completed',
     diff_id:diffId, mutation_epoch:epoch, profiles, recovered };
 }
 async function executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId,expectedOperationCount,
-  policy,codingRuntime,nativeDiffRuntime,signingKeyPath}) {
+  policy,codingRuntime,nativeDiffRuntime,signingKeyPath,workerScheduler}) {
   let started=patchStartedForDecision(events,decisionEvent.event_sha256);
   if(!started&&state.mutation_count+expectedOperationCount>policy.limits.max_mutations){
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason:'mutation_limit',max_mutations:policy.limits.max_mutations});
@@ -929,7 +972,7 @@ async function executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId,e
     const committed=patchCommitForAction(events,actionId);
     if(!committed) throw new Error('completed prepared diff action missing native diff commit');
     const epoch=committed.payload.mutation_epoch;
-    const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath});
+    const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath,workerScheduler});
     return {status:profiles.some(item=>item.status==='paused')?'paused':'completed',diff_id:diffId,mutation_epoch:epoch,profiles,recovered:true};
   }
   const reconciliation=await reconcileStartedAction({startedEvent:started,journal:events,runtimes:{nativeDiffRuntime,codingRuntime}});
@@ -963,10 +1006,10 @@ async function executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId,e
       receipt_sha256:verified.receipt_sha256,recovered});
   }
   const epoch=committed.payload.mutation_epoch;
-  const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath});
+  const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath,workerScheduler});
   return {status:profiles.some(item=>item.status==='paused')?'paused':'completed',diff_id:diffId,mutation_epoch:epoch,profiles,recovered};
 }
-async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath }) {
+async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath, workerScheduler }) {
   const requiredIds = Object.entries(policy.profiles)
     .filter(([,profile]) => profile.required_for_release)
     .map(([id]) => id);
@@ -977,9 +1020,9 @@ async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, co
       results.push({ profile_id:profileId, status:'passed', observation:existing, existing:true });
       continue;
     }
-    const result = await executeProfile({ ctx,events,goalId:goal.goal_id,
-      actionKey:`release-${state.mutation_epoch}:${profileId}`, profileId,
-      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath });
+    const result = await executeProfileWithLease({workerScheduler,ctx,events,goal,
+      actionKey:`release-${state.mutation_epoch}:${profileId}`,profileId,
+      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath});
     results.push({ profile_id:profileId, ...result });
     if (result.status === 'paused') break;
   }
@@ -1153,7 +1196,7 @@ function r34ReasonHash(goal,decisionEvent,reason) {
 }
 async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,policy,codingRuntime,
   nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
-  signingKeyPath,verifyKeyPath}) {
+  signingKeyPath,verifyKeyPath,workerScheduler}) {
   let loop=deriveLoopState(goal,events);
   if (decision.kind === 'plan_create') {
     if (loop.phase !== 'PLAN' || loop.plan) throw new Error('R34 plan_create requires empty PLANNING state');
@@ -1196,7 +1239,7 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
       try {
         outcome=await executePatch({ctx,events,goal,state,decisionEvent,
           decision:{operations:decision.action.operations,summary:`R34 ${currentStep.step_id}`},nativeDiffRuntime,
-          policy,codingRuntime,signingKeyPath,actionCoordinatesOverride:{planId:loop.plan_id,
+          policy,codingRuntime,signingKeyPath,workerScheduler,actionCoordinatesOverride:{planId:loop.plan_id,
             planVersion:loop.plan_version,stepId:currentStep.step_id}});
       } catch (error) {
         const detail=truncated(error,512);
@@ -1209,7 +1252,7 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
       }
     } else if (decision.action.kind === 'run_profile') {
       await assertRunAuthority(goal.root_id);
-      outcome=await executeProfile({ctx,events,goalId:goal.goal_id,
+      outcome=await executeProfileWithLease({workerScheduler,ctx,events,goal,
         actionKey:`r34-${decisionEvent.event_sha256}`,profileId:decision.action.profile_id,
         epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase:loop.phase});
     } else if (decision.action.kind === 'delegate') {
@@ -1219,7 +1262,7 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
     } else if (decision.action.kind === 'native_diff_apply') {
       await assertRunAuthority(goal.root_id);
       outcome=await executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId:decision.action.diff_id,
-        expectedOperationCount:decision.action.expected_operation_count,policy,codingRuntime,nativeDiffRuntime,signingKeyPath});
+        expectedOperationCount:decision.action.expected_operation_count,policy,codingRuntime,nativeDiffRuntime,signingKeyPath,workerScheduler});
     } else if (['machine_fs_mkdir','machine_fs_move','machine_fs_delete'].includes(decision.action.kind)) {
       await assertRunAuthority(goal.root_id);
       if(!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
@@ -1240,7 +1283,7 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
         }
       }
       outcome=await executePatch({ctx,events,goal,state,decisionEvent,decision:{operations,summary:`R36 ${decision.action.kind}`},
-        nativeDiffRuntime,policy,codingRuntime,signingKeyPath});
+        nativeDiffRuntime,policy,codingRuntime,signingKeyPath,workerScheduler});
     } else if (capabilityIdForOperation(decision.action)) {
       outcome=await executeDelegate({ctx,events,goal,decisionEvent,
         decision:{operation:decision.action},policy,
@@ -1347,14 +1390,14 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
   throw new Error(`unsupported R34 decision '${String(decision.kind)}'`);
 }
 
-async function executeDecision({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
+async function executeDecisionCore({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
   nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, semanticRuntime, assertRunAuthority,
-  signingKeyPath, verifyKeyPath }) {
+  signingKeyPath, verifyKeyPath, workerScheduler }) {
   const decision = decisionEvent.decision;
   if (decision?.schema === 'deadbyte.autonomous-decision.v2') {
     const outcome=await executeR34Decision({ctx,events,goal,state,decisionEvent,decision,policy,codingRuntime,
       nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
-      signingKeyPath,verifyKeyPath});
+      signingKeyPath,verifyKeyPath,workerScheduler});
     await appendEvent(ctx,events,signingKeyPath,'decision_completed',{
       decision_event_sha256:decisionEvent.event_sha256,action:decision.kind,
       outcome_status:outcome.status ?? 'completed'
@@ -1384,15 +1427,15 @@ async function executeDecision({ ctx, events, goal, state, decisionEvent, policy
   } else if (decision.action === 'patch') {
     await assertRunAuthority(goal.root_id);
     outcome = await executePatch({ ctx,events,goal,state,decisionEvent,decision,nativeDiffRuntime,
-      policy,codingRuntime,signingKeyPath });
+      policy,codingRuntime,signingKeyPath,workerScheduler });
   } else if (decision.action === 'delegate') {
     outcome = await executeDelegate({ ctx,events,goal,decisionEvent,decision,policy,
       runtimes:{ machineFsRuntime,observationRuntime,processRuntime },assertRunAuthority,signingKeyPath,verifyKeyPath });
   } else if (decision.action === 'run_profile') {
     await assertRunAuthority(goal.root_id);
-    outcome = await executeProfile({ ctx,events,goalId:goal.goal_id,
-      actionKey:`planner-${decisionEvent.event_sha256}`, profileId:decision.profile_id,
-      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath });
+    outcome = await executeProfileWithLease({workerScheduler,ctx,events,goal,
+      actionKey:`planner-${decisionEvent.event_sha256}`,profileId:decision.profile_id,
+      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath});
   } else if (decision.action === 'pause') {
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
       reason:decision.reason, planner_summary:decision.summary
@@ -1414,6 +1457,83 @@ async function executeDecision({ ctx, events, goal, state, decisionEvent, policy
   return outcome;
 }
 
+function effectDescriptor(goal,state,events,decisionEvent){
+  const decision=decisionEvent?.decision;
+  let action=null,coordinates=null;
+  if(decision?.schema==='deadbyte.autonomous-decision.v2'&&decision.kind==='act'){
+    const loop=deriveLoopState(goal,events);
+    if(!loop.plan_id||!loop.current_step?.step_id) return null;
+    action=decision.action;
+    coordinates={planId:loop.plan_id,stepId:loop.current_step.step_id};
+  }else if(['patch','delegate','run_profile'].includes(decision?.action)){
+    coordinates=patchActionCoordinates(state);
+    if(decision.action==='patch') action={kind:'patch',operations:decision.operations};
+    else if(decision.action==='delegate') action={kind:'delegate',operation:decision.operation};
+    else action={kind:'run_profile',profile_id:decision.profile_id};
+  }
+  if(!action||!coordinates) return null;
+  const observed=[...events].reverse().find(event=>[
+    'inspection_completed','inspect_completed','profile_completed','delegated_action_completed','observation_completed'
+  ].includes(event.type)&&SHA256_RE.test(event.event_sha256??''))?.event_sha256 ?? state.journal_head_sha256;
+  return {action,planId:coordinates.planId,stepId:coordinates.stepId,observationHeadSha256:observed};
+}
+
+async function executeDecision(args) {
+  const {ctx,events,goal,state,decisionEvent,signingKeyPath}=args;
+  const descriptor=effectDescriptor(goal,state,events,decisionEvent);
+  if(!descriptor) return executeDecisionCore(args);
+  const lease=issueObservationLease({goalId:goal.goal_id,mutationEpoch:state.mutation_epoch,
+    observations:[{event_sha256:descriptor.observationHeadSha256}],ttlMs:120000});
+  verifyObservationLease(lease,{goalId:goal.goal_id,currentMutationEpoch:state.mutation_epoch,
+    observationHeadSha256:descriptor.observationHeadSha256});
+  if(!events.some(event=>event.type==='observation_lease_issued'&&event.payload?.lease_id===lease.lease_id)){
+    await appendEvent(ctx,events,signingKeyPath,'observation_lease_issued',{
+      lease_id:lease.lease_id,mutation_epoch:lease.mutation_epoch,
+      observation_head_sha256:lease.observation_head_sha256,expires_at_ms:lease.expires_at_ms,
+      decision_event_sha256:decisionEvent.event_sha256
+    });
+  }
+  const effect=effectIdentity({goalId:goal.goal_id,planId:descriptor.planId,stepId:descriptor.stepId,
+    mutationEpoch:state.mutation_epoch,action:descriptor.action,observationHeadSha256:descriptor.observationHeadSha256});
+  const guard=loopGuardDisposition(events,effect,{maxRepeats:2,window:48});
+  if(!guard.allowed){
+    await appendEvent(ctx,events,signingKeyPath,'effect_guard_blocked',{
+      effect_id:effect.effect_id,fingerprint:effect.fingerprint,repeated_count:guard.repeated_count,
+      max_repeats:guard.max_repeats,reason:guard.reason,decision_event_sha256:decisionEvent.event_sha256
+    });
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason:'effect_repeat_limit',
+      effect_id:effect.effect_id,fingerprint:effect.fingerprint});
+    return {status:'paused',reason:'effect_repeat_limit'};
+  }
+  if(!events.some(event=>event.type==='effect_started'&&event.payload?.effect_id===effect.effect_id)){
+    await appendEvent(ctx,events,signingKeyPath,'effect_started',{
+      ...effect,observation_lease_id:lease.lease_id,decision_event_sha256:decisionEvent.event_sha256
+    });
+  }
+  try{
+    const outcome=await executeDecisionCore(args);
+    if(!events.some(event=>['effect_completed','effect_failed'].includes(event.type)&&event.payload?.effect_id===effect.effect_id)){
+      const completion=bindEffectCompletion(effect,{status:outcome?.status??'completed',
+        mutation_epoch:deriveState(goal,events).mutation_epoch,observation_lease_id:lease.lease_id});
+      await appendEvent(ctx,events,signingKeyPath,'effect_completed',{
+        ...completion,observation_lease_id:lease.lease_id,decision_event_sha256:decisionEvent.event_sha256,
+        outcome_status:outcome?.status??'completed'
+      });
+    }
+    return outcome;
+  }catch(error){
+    if(!events.some(event=>['effect_completed','effect_failed'].includes(event.type)&&event.payload?.effect_id===effect.effect_id)){
+      const completion=bindEffectCompletion(effect,{status:'failed',error:truncated(error,512),
+        mutation_epoch:deriveState(goal,events).mutation_epoch,observation_lease_id:lease.lease_id});
+      await appendEvent(ctx,events,signingKeyPath,'effect_failed',{
+        ...completion,observation_lease_id:lease.lease_id,decision_event_sha256:decisionEvent.event_sha256,
+        detail:truncated(error,512)
+      });
+    }
+    throw error;
+  }
+}
+
 function terminalState(state) {
   return ['succeeded','cancelled'].includes(state.state);
 }
@@ -1442,6 +1562,9 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
   if (!policy || !codingRuntime || !nativeDiffRuntime) throw new Error('autonomous runtime requires policy/coding/native-diff runtimes');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('autonomous runtime requires trust keys');
   const capabilityManifest=configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime});
+  const profileTimeoutCeiling=Math.max(120000,...Object.values(policy.profiles??{}).map(profile=>
+    Number.isInteger(profile?.timeout_ms)&&profile.timeout_ms>0?profile.timeout_ms+120000:120000));
+  const workerScheduler=createWorkerScheduler({maxConcurrent:2,totalCpuUnits:2,totalMemoryMb:2048,leaseMs:profileTimeoutCeiling});
   async function sessionStatus() {
     const autonomous = await autonomousSessionStatus(policy);
     const coding = await codingRuntime.sessionStatus();
@@ -1500,8 +1623,9 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     const journal = await readEvents(ctx,verifyKeyPath);
     const derived = deriveState(goal,journal);
     const loop = publicLoopState(loopStateOrNull(goal,journal));
+    const lock=await runLockStatus(ctx);
     return { status:'ok', goal_id:goalId, goal_sha256:goal.goal_sha256,
-      title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived,
+      title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived, ...lock,
       ...(loop ? {loop} : {}) };
   }
 
@@ -1577,7 +1701,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     }
     state = deriveState(goal,journal);
     const profiles = await runRequiredReleaseProfiles({ ctx,events:journal,goal,state,
-      policy,codingRuntime,signingKeyPath });
+      policy,codingRuntime,signingKeyPath,workerScheduler });
     if (profiles.some(item => item.status === 'paused')) {
       return { status:'paused', goal_id:goal.goal_id, ready:false,
         reason:'release_profile_interrupted', mutation_epoch:state.mutation_epoch };
@@ -1658,7 +1782,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           try {
             outcome = await executeDecision({ ctx,events:journal,goal,state,
               decisionEvent:state.pending_decision,policy,codingRuntime,nativeDiffRuntime,machineFsRuntime,
-              observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath });
+              observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath,workerScheduler });
           } catch (error) {
             const loop=loopStateOrNull(goal,journal);
             if (!loop || loop.pending_action || !isAuthorityUnavailable(error)) throw error;

package/src/autonomous-timeout-recovery.mjs

@@ -0,0 +1,27 @@
+const HEX64=/^[0-9a-f]{64}$/;
+
+export function classifyAutonomousTimeoutRecovery(status,{beforeJournalHead}={}){
+  if(!status||typeof status!=='object'||Array.isArray(status)) throw new Error('autonomous timeout status invalid');
+  if(!HEX64.test(beforeJournalHead??'')) throw new Error('autonomous timeout before journal head invalid');
+  if(status.status!=='ok') throw new Error('autonomous timeout status not ok');
+  if(!HEX64.test(status.journal_head_sha256??'')) throw new Error('autonomous timeout journal head invalid');
+  if(status.state==='succeeded') return Object.freeze({kind:'completed',state:'succeeded',journal_head_sha256:status.journal_head_sha256});
+  if(status.state==='cancelled'||status.state==='paused'){
+    return Object.freeze({kind:'terminal_failure',state:status.state,reason:status.reason??null,journal_head_sha256:status.journal_head_sha256});
+  }
+  if(status.state!=='pending'&&status.state!=='running') throw new Error(`autonomous timeout unexpected state: ${status.state}`);
+  if(status.run_busy===true){
+    return Object.freeze({kind:'wait',state:status.state,reason:'server_run_in_flight',journal_head_sha256:status.journal_head_sha256});
+  }
+  if(status.run_busy!==false) throw new Error('autonomous timeout run-lock state unavailable');
+  if(status.pending_request!==null&&status.pending_request!==undefined){
+    return Object.freeze({kind:'wait',state:status.state,reason:'planner_request_in_flight',journal_head_sha256:status.journal_head_sha256});
+  }
+  if(status.pending_decision!==null&&status.pending_decision!==undefined){
+    return Object.freeze({kind:'wait',state:status.state,reason:'decision_in_flight',journal_head_sha256:status.journal_head_sha256});
+  }
+  if(status.journal_head_sha256===beforeJournalHead){
+    return Object.freeze({kind:'wait',state:status.state,reason:'no_durable_progress',journal_head_sha256:status.journal_head_sha256});
+  }
+  return Object.freeze({kind:'resumable',state:status.state,reason:'durable_cycle_completed',journal_head_sha256:status.journal_head_sha256});
+}