deadbyte-mcp 0.10.0 → 0.11.0

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});
+}

package/src/deadbyte-cli.mjs

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'node:url';
 import { defaultPublicKeyPath } from './trust.mjs';
 import { verifyAuditChain } from './audit-verify.mjs';
 import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-result-journal.mjs';
-import { createLiveActivityTracker, formatCompactAuditEvent, formatRemoteLifecycle } from './remote-live-log.mjs';
+import { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -34,9 +34,8 @@ function printHelp(){
   process.stdout.write([
     'DEADBYTE MCP CLI','',
     '  npx deadbyte-mcp@latest mcp                 # stdio MCP server for local clients',
-    '  npx deadbyte-mcp@latest remote              # compact foreground device session',
-    '  npx deadbyte-mcp@latest remote --verbose    # detailed audit + bridge logs',
-    '  npx deadbyte-mcp@latest remote --resume <cursor> # replay missed compact results, then reconnect',
+    '  npx deadbyte-mcp@latest remote              # unified foreground device session + live timeline',
+    '  npx deadbyte-mcp@latest remote --resume <cursor> # replay missed results, then reconnect',
     '  npx deadbyte-mcp@latest remote status',
     '  npx deadbyte-mcp@latest remote restart',
     '  npx deadbyte-mcp@latest supervisor status',
@@ -78,35 +77,15 @@ async function listLogFiles(root){
   }
   return files;
 }
-function formatLogLine(file,line,{verbose=false,activityTracker=null}={}){
+function formatLogLine(file,line,{activityTracker=null}={}){
   if(!line) return null;
   if(/^segment-\d{8}\.jsonl$/.test(path.basename(file))){
     try{
       const event=JSON.parse(line);
-      if(!verbose) return activityTracker?activityTracker.observe(event):formatCompactAuditEvent(event);
-      const seq=Number.isInteger(event.seq)?`#${event.seq}`:'#?';
-      const request=typeof event.request_id==='string'?` ${event.request_id.slice(0,8)}`:'';
-      const tool=typeof event.tool==='string'?` ${event.tool}`:'';
-      let marker='';
-      if(event.event_type==='tool.request') marker='📥 ';
-      else if(event.event_type==='tool.result'){
-        if(event.outcome?.is_error===true) marker='📤❌ ';
-        else if(event.outcome?.is_error===false) marker='📤✅ ';
-        else marker='📤 ';
-      }
-      return `${marker}[AUDIT ${seq}] ${event.event_type||'event'}${tool}${request}`;
-    }catch{return verbose?`[AUDIT] ${line}`:null;}
-  }
-  if(!verbose) return null;
-  const label=path.basename(file).replace(/\.log$/i,'').toUpperCase();
-  let marker='';
-  if(/\[TOOL IN \]/.test(line)) marker='📥 ';
-  else if(/\[TOOL OUT\]/.test(line)){
-    if(/"is_error"\s*:\s*true/.test(line)) marker='📤❌ ';
-    else if(/"is_error"\s*:\s*false/.test(line)) marker='📤✅ ';
-    else marker='📤 ';
+      return activityTracker?activityTracker.observe(event):formatCompactAuditEvent(event);
+    }catch{return null;}
   }
-  return `${marker}[${label}] ${line}`;
+  return formatRuntimeDiagnosticLine(file,line);
 }
 function remoteResultJournalPath(root,sessionId){return path.join(root,'runtime','remote-results',`${sessionId}.json`);}
 function auditTerminalResult(file,line){
@@ -117,7 +96,7 @@ function auditTerminalResult(file,line){
   return {request_id:event.request_id,tool:event.tool,status:event.outcome?.is_error===true?'error':'ok',observed_at_utc:observed,
     payload_sha256:createHash('sha256').update(Buffer.from(line,'utf8')).digest('hex')};
 }
-async function replayRemoteResults(root,cursor,{verbose=false}={}){
+async function replayRemoteResults(root,cursor){
   const parsed=parseRemoteResultCursor(cursor);
   const file=remoteResultJournalPath(root,parsed.session_id);
   await requireRegular(file,'remote result journal');
@@ -127,7 +106,7 @@ async function replayRemoteResults(root,cursor,{verbose=false}={}){
     const page=await journal.replayAfter(next,{limit:200});
     for(const event of page.events){
       const marker=event.status==='error'?'[ERR]':'[OK]';
-      process.stdout.write(`${verbose?'[REPLAY] ': '[REPLAY] '}${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
+      process.stdout.write(`[REPLAY] ${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
     }
     next=page.next_cursor;
     if(!page.has_more) return next;
@@ -151,10 +130,8 @@ async function snapshotRemoteLogOffsets(root){
   }
   return offsets;
 }
-async function tailRemoteLogs(root,signal,{verbose=false,journal=null,offsets=null,activityTracker=null}={}){
-  process.stdout.write(verbose
-    ?'📜 [LOG] Live logs active. Press Ctrl+C to disconnect and revoke authority.\n'
-    :'[LOG] Live activity. Ctrl+C disconnects and revokes authority.\n');
+async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null}={}){
+  process.stdout.write('[LOG] Unified live timeline. Ctrl+C disconnects and revokes authority.\n');
   const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
   while(!signal.aborted){
     for(const file of await listLogFiles(root)){
@@ -165,22 +142,20 @@ async function tailRemoteLogs(root,signal,{verbose=false,journal=null,offsets=nu
         const terminal=auditTerminalResult(file,line);
         let recorded=null;
         if(terminal&&journal) recorded=await journal.recordTerminal(terminal);
-        if(recorded?.duplicate&&!verbose) continue;
-        const formatted=formatLogLine(file,line,{verbose,activityTracker});
+        if(recorded?.duplicate) continue;
+        const formatted=formatLogLine(file,line,{activityTracker});
         if(!formatted) continue;
-        if(!verbose&&recorded) process.stdout.write(`${formatted} [cursor ${recorded.cursor}]\n`);
+        if(recorded) process.stdout.write(`${formatted} [cursor ${recorded.cursor}]\n`);
         else process.stdout.write(`${formatted}\n`);
       }
     }
     try{await sleep(250,null,{signal});}catch(error){if(error?.name!=='AbortError') throw error;}
   }
 }
-async function cleanupRemoteSession(ctx,{verbose=false}={}){
+async function cleanupRemoteSession(ctx){
   for(const command of SESSION_CLEANUP){
     try{
-      const result=invokeController(ctx,command,verbose
-        ?{allowFailure:true}
-        :{allowFailure:true,capture:true,echoCaptured:false});
+      const result=invokeController(ctx,command,{allowFailure:true,capture:true,echoCaptured:false});
       if(result.status!==0) process.stderr.write(`⚠️ [WARN] cleanup ${command} exit=${result.status}\n`);
     }
     catch(error){process.stderr.write(`⚠️ [WARN] cleanup ${command}: ${String(error?.message||error)}\n`);}
@@ -259,15 +234,15 @@ async function releaseRemoteSession(ctx,marker){
   const same=current?.schema==='deadbyte.remote-session.v2'&&current.owner_pid===marker.owner_pid&&current.session_nonce===marker.session_nonce;
   if(same) await rm(remoteSessionMarker(ctx.root),{force:true});
 }
-async function runRemoteSession({verbose=false,resumeCursor=null}={}){
+async function runRemoteSession({resumeCursor=null}={}){
   const ctx=await remoteContext();
-  if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{verbose});
+  if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor);
   await recoverRemoteSession(ctx);
   const marker=await claimRemoteSession(ctx);
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
-  const activityTracker=createLiveActivityTracker();
+  const activityTracker=createLiveTimelineTracker();
   const aborter=new AbortController();
   const abort=()=>aborter.abort();
   const watchStdin=!process.stdin.isTTY;
@@ -276,67 +251,53 @@ async function runRemoteSession({verbose=false,resumeCursor=null}={}){
   let ready=false;
   let logTask=null;
   try{
-    if(verbose) process.stdout.write('DEADBYTE MCP DEVICE SESSION\n');
-    else process.stdout.write('DEADBYTE MCP\n');
+    process.stdout.write('DEADBYTE MCP\n');
     process.stdout.write(`${formatRemoteLifecycle('device_start')}\n`);
     process.stdout.write(`${formatRemoteLifecycle(resumeCursor!==null?'session_restored':'session_new')}\n`);
     const logOffsets=await snapshotRemoteLogOffsets(ctx.root);
-    logTask=tailRemoteLogs(ctx.root,aborter.signal,{verbose,journal:resultJournal,offsets:logOffsets,activityTracker});
-    if(verbose) process.stdout.write('[INFO] Starting local + remote runtime...\n');
-    else process.stdout.write('[BOOT] Starting local + remote runtime...\n');
+    logTask=tailRemoteLogs(ctx.root,aborter.signal,{journal:resultJournal,offsets:logOffsets,activityTracker});
+    process.stdout.write('[BOOT] Starting local + remote runtime...\n');
     const started=[];
     for(const command of SESSION_START){
-      if(!verbose){
-        if(command==='start') process.stdout.write('[BOOT] Starting bridge/runtime...\n');
-        else process.stdout.write(`🔐 [AUTH] Arming ${command.slice(3)}...\n`);
-      }
-      const controllerResult=invokeController(ctx,command,verbose?{}:{capture:true,echoCaptured:false});
+      if(command==='start') process.stdout.write('[BOOT] Starting bridge/runtime...\n');
+      else process.stdout.write(`🔐 [AUTH] Arming ${command.slice(3)}...\n`);
+      const controllerResult=invokeController(ctx,command,{capture:true,echoCaptured:false});
       started.push(controllerResult);
       if(command==='start'){
         process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
         process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\n`);
       }
     }
-    if(!verbose){
-      const startText=started[0]?.stdout||'';
-      const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
-      process.stdout.write('[OK] ONLINE\n');
-      process.stdout.write(`${formatRemoteLifecycle('ready')}\n`);
-      if(url) process.stdout.write(`URL: ${url}\n`);
-      process.stdout.write('🔐 [AUTH] Verifying process, coding, autonomous; host must stay DISARMED...\n');
-    }else process.stdout.write('🛡️ [AUTHORITY] Verifying runtime planes; host must stay DISARMED...\n');
+    const startText=started[0]?.stdout||'';
+    const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
+    process.stdout.write('[OK] ONLINE\n');
+    process.stdout.write(`${formatRemoteLifecycle('ready')}\n`);
+    if(url) process.stdout.write(`URL: ${url}\n`);
+    process.stdout.write('🔐 [AUTH] Verifying process, coding, autonomous; host must stay DISARMED...\n');
     for(const [command,pattern] of SESSION_STATUS){
-      const result=invokeController(ctx,command,{capture:true,echoCaptured:verbose});
+      const result=invokeController(ctx,command,{capture:true,echoCaptured:false});
       if(!pattern.test(result.stdout)) throw new Error(`remote session authority verification failed: ${command} state mismatch`);
     }
     ready=true;
-    if(verbose) process.stdout.write('[DEVICE] DEADBYTE MCP online; process/coding/autonomous ARMED; host DISARMED.\n');
-    else process.stdout.write('🔐 [AUTH] ARMED: process, coding, autonomous | host DISARMED\n');
+    process.stdout.write('🔐 [AUTH] ARMED: process, coding, autonomous | host DISARMED\n');
     await logTask;
   }finally{
     const wasAborted=aborter.signal.aborted;
     aborter.abort();
     if(logTask) await logTask.catch(()=>{});
-    if(!verbose){for(const line of activityTracker.reconcileInterrupted('session_end')) process.stdout.write(`${line}\n`);}
+    for(const line of activityTracker.reconcileInterrupted('session_end')) process.stdout.write(`${line}\n`);
     process.removeListener('SIGINT',abort);process.removeListener('SIGTERM',abort);
     if(watchStdin){process.stdin.removeListener('end',abort);process.stdin.removeListener('close',abort);process.stdin.pause();}
     process.stdout.write(`${formatRemoteLifecycle('cleanup')}\n`);
-    if(ready||!wasAborted) process.stdout.write(verbose?'[INFO] Closing remote device session and revoking authority...\n':'[INFO] Disconnecting; revoking authority...\n');
-    await cleanupRemoteSession(ctx,{verbose});
+    if(ready||!wasAborted) process.stdout.write('[INFO] Disconnecting; revoking authority...\n');
+    await cleanupRemoteSession(ctx);
     await releaseRemoteSession(ctx,marker);
   }
 }
 async function runRemote(args){
   if(args.length===0){await runRemoteSession();return;}
-  if(args.length===1&&args[0]==='--verbose'){await runRemoteSession({verbose:true});return;}
   if(args.length===2&&args[0]==='--resume'){await runRemoteSession({resumeCursor:args[1]});return;}
-  if(args.length===3&&args[0]==='--verbose'&&args[1]==='--resume'){
-    await runRemoteSession({verbose:true,resumeCursor:args[2]});return;
-  }
-  if(args.length===3&&args[0]==='--resume'&&args[2]==='--verbose'){
-    await runRemoteSession({verbose:true,resumeCursor:args[1]});return;
-  }
-  if(args.length>1) throw new Error('remote accepts one controller command, --verbose, or --resume <cursor>');
+  if(args.length>1) throw new Error('remote accepts one controller command or --resume <cursor>');
   const command=args[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
   const ctx=await remoteContext();
   const result=invokeController(ctx,command,{allowFailure:true});