deadbyte-mcp 0.15.1 → 0.15.3

package/src/autonomous-runtime.mjs

@@ -17,6 +17,8 @@ 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';
+import { createJournalStream } from './workload-substrate.mjs';
+import { createDeadline, deadlineState } from './deadline-cancellation.mjs';
 
 export const AUTONOMOUS_GOAL_SCHEMA = 'deadbyte.autonomous-goal.v1';
 export const AUTONOMOUS_EVENT_SCHEMA = 'deadbyte.autonomous-event.v1';
@@ -229,7 +231,7 @@ function profileOutcome(profile, checked) {
       { median_ms:receipt.median_ms, p95_ms:receipt.p95_ms, regression_pct:receipt.regression_pct, verdict:receipt.verdict }) } };
 }
 async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch, policy, codingRuntime, signingKeyPath,
-  r34ResumePhase = null }) {
+  r34ResumePhase = null, childDeadline = null }) {
   const profile = policy.profiles[profileId];
   if (!profile) throw new Error(`autonomous profile '${profileId}' not found`);
   const prior = [...events].reverse().find(event => event.type === 'profile_completed' && event.payload?.action_key === actionKey && event.payload?.profile_id === profileId);
@@ -274,6 +276,9 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
     await appendEvent(ctx,events,signingKeyPath,'profile_completed',payload);
     return { status:outcome.passed ? 'passed' : 'failed', observation:payload, existing:false };
   }
+  const childRemainingRaw = childDeadline ? deadlineState(childDeadline).remaining_ms : null;
+  const childRemainingMs = childRemainingRaw === null ? null : Math.floor(childRemainingRaw);
+  if (childRemainingMs !== null && childRemainingMs < 100) throw new Error('deadline_exceeded');
   const autonomousAuthority = await assertAutonomousArmed(policy,profile.root_id);
   if (Number.isFinite(autonomousAuthority.remaining_ms) && autonomousAuthority.remaining_ms < 100) {
     throw new Error('autonomous lease expires too soon to execute profile');
@@ -283,20 +288,22 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
     authority_instance_nonce:autonomousAuthority.instance_nonce,
     authority_expires_at_utc:autonomousAuthority.expires_at_utc });
   const preExecutionCheck = () => recheckAutonomousAuthority(policy,autonomousAuthority,profile.root_id);
+  const childTimeoutMs = childRemainingMs === null ? profile.timeout_ms : Math.max(100, Math.min(profile.timeout_ms, childRemainingMs));
   let result;
   try {
     result = profile.kind === 'command'
       ? await codingRuntime.commandRun({ rootId:profile.root_id, commandId:profile.command_id, scriptPath:profile.script_path,
-          scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:profile.timeout_ms,
+          scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:childTimeoutMs,
           executionDeadlineUtc:autonomousAuthority.expires_at_utc, preExecutionCheck, receiptId, requestSha256 })
       : await codingRuntime.benchmarkRun({ rootId:profile.root_id, commandId:profile.command_id, scriptPath:profile.script_path,
-          scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:profile.timeout_ms,
+          scriptSha256:profile.script_sha256, args:profile.args, cwd:profile.cwd, timeoutMs:childTimeoutMs,
           executionDeadlineUtc:autonomousAuthority.expires_at_utc, preExecutionCheck,
           warmups:profile.warmups, iterations:profile.iterations, baselineMedianMs:profile.baseline_median_ms,
           maxRegressionPct:profile.max_regression_pct, receiptId, requestSha256 });
   } catch (error) {
     const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
     if (!checked.ok) {
+      if (childDeadline && deadlineState(childDeadline).expired) throw new Error('deadline_exceeded');
       const r34Paused=await pauseR34Ambiguous(checked.reason ?? error);
       if (r34Paused) return r34Paused;
       await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'profile_execution_without_receipt', profile_id:profileId,
@@ -311,6 +318,7 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
     if (r34Paused) return r34Paused;
     throw new Error(`profile '${profileId}' post-execution receipt verification failed`);
   }
+  if (childDeadline && deadlineState(childDeadline).expired) throw new Error('deadline_exceeded');
   const outcome = profileOutcome(profile,checked);
   if (!outcome.valid) {
     const r34Paused=await pauseR34Ambiguous(outcome.reason);
@@ -363,7 +371,7 @@ function normalizeTaskContract(raw) {
     constraints:list('constraints',32,512),evidence_requirements:list('evidence_requirements',32,512),
     risk_level:value.risk_level,clarification_policy:value.clarification_policy,...rigor});
 }
-function normalizeGoal(policy, { submissionId, rootId, title = '', goal, acceptance = '', taskContract = null, maxIterations = null }) {
+function normalizeGoal(policy, { submissionId, rootId, title = '', goal, acceptance = '', taskContract = null, maxIterations = null, timeoutMs = null }) {
   if (!ID_RE.test(submissionId ?? '')) throw new Error('autonomous submission_id invalid');
   if (!policy.root_ids.includes(rootId)) throw new Error(`autonomous root '${rootId}' is not allowed`);
   if (typeof title !== 'string' || title.length > 160) throw new Error('autonomous title must be <=160 characters');
@@ -371,9 +379,10 @@ function normalizeGoal(policy, { submissionId, rootId, title = '', goal, accepta
   if (typeof acceptance !== 'string' || acceptance.length > 4096) throw new Error('autonomous acceptance must be <=4096 characters');
   const iterations = maxIterations ?? policy.limits.max_iterations;
   if (!Number.isInteger(iterations) || iterations < 1 || iterations > policy.limits.max_iterations) throw new Error('autonomous max_iterations exceeds policy');
+  if (timeoutMs !== null && (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 900000)) throw new Error('autonomous timeout_ms must be null or in [100,900000]');
   const body = { schema:AUTONOMOUS_GOAL_SCHEMA, policy_sha256:policy.policy_sha256,
     coding_policy_sha256:policy.coding_policy_sha256, submission_id:submissionId, root_id:rootId,
-    title, goal, acceptance, task_contract:normalizeTaskContract(taskContract),max_iterations:iterations };
+    title, goal, acceptance, task_contract:normalizeTaskContract(taskContract),max_iterations:iterations, timeout_ms:timeoutMs };
   return Object.freeze({ ...body, goal_sha256:sha256Object(body) });
 }
 
@@ -731,7 +740,9 @@ function assertDelegatedIdentity(events, operation) {
     }
   }
 }
-async function invokeDelegatedOperation(goal, operation, runtimes, desktopContext=null) {
+async function invokeDelegatedOperation(goal, operation, runtimes, desktopContext=null, childDeadline=null) {
+  const remainingMs = childDeadline ? Math.max(100, Math.floor(deadlineState(childDeadline).remaining_ms)) : null;
+  if (childDeadline && deadlineState(childDeadline).expired) throw new Error('deadline_exceeded');
   const { codingRuntime, semanticRuntime, nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, desktopRuntime } = runtimes;
   switch (operation.kind) {
     case 'stat':
@@ -804,7 +815,7 @@ async function invokeDelegatedOperation(goal, operation, runtimes, desktopContex
       return observationRuntime.systemStatus();
     case 'process_start':
       if (!processRuntime) throw new Error('process runtime unavailable');
-      return processRuntime.start({ profileId:operation.profile_id, rootId:goal.root_id, cwd:operation.cwd, args:operation.args??[] });
+      return processRuntime.start({ profileId:operation.profile_id, rootId:goal.root_id, cwd:operation.cwd, args:operation.args??[], timeoutMs:remainingMs });
     case 'process_read':
       if (!processRuntime) throw new Error('process runtime unavailable');
       return processRuntime.read({ sessionId:operation.session_id, offset:operation.offset, maxBytes:operation.max_bytes });
@@ -893,7 +904,7 @@ async function verifyDelegatedEvidence(operation, result, runtimes, verifyKeyPat
   return { kind:'runtime_result', result_sha256:sha256Object(result) };
 }
 async function executeDelegate({ ctx, events, goal, decisionEvent, decision, policy, runtimes, assertRunAuthority,
-  signingKeyPath, verifyKeyPath }) {
+  signingKeyPath, verifyKeyPath, childDeadline = null }) {
   const capabilityId=capabilityIdForOperation(decision.operation);
   if(!capabilityId) throw new Error(`unsupported typed capability action '${String(decision.operation?.kind)}'`);
   const actionKey = `capability-${decisionEvent.event_sha256}`;
@@ -939,7 +950,7 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
         }
       };
     }
-    const result = await invokeDelegatedOperation(goal,decision.operation,runtimes,desktopContext);
+    const result = await invokeDelegatedOperation(goal,decision.operation,runtimes,desktopContext,childDeadline);
     if (Buffer.byteLength(canonicalJson(result),'utf8') > policy.limits.max_context_bytes) {
       throw new Error('delegated result exceeds autonomous context bound');
     }
@@ -971,7 +982,7 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
   }
 }
 
-async function executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,actionKey,profileId,policy,codingRuntime,signingKeyPath,r34ResumePhase=null}) {
+async function executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,actionKey,profileId,policy,codingRuntime,signingKeyPath,r34ResumePhase=null,childDeadline=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});
@@ -981,7 +992,7 @@ async function executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,ac
   });
   let outcomeStatus='failed';
   try {
-    const result=await executeProfile({ctx,events,goalId:goal.goal_id,actionKey,profileId,epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase});
+    const result=await executeProfile({ctx,events,goalId:goal.goal_id,actionKey,profileId,epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase,childDeadline});
     outcomeStatus=result.status;
     return result;
   } finally {
@@ -993,14 +1004,14 @@ async function executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,ac
   }
 }
 
-async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy, codingRuntime, signingKeyPath, workerScheduler }) {
+async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy, codingRuntime, signingKeyPath, workerScheduler, childDeadline=null }) {
   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 executeProfileWithLease({workerScheduler,ctx,events,goal,epoch,
-      actionKey:`${actionKey}:${profileId}`,profileId,policy,codingRuntime,signingKeyPath});
+      actionKey:`${actionKey}:${profileId}`,profileId,policy,codingRuntime,signingKeyPath,childDeadline});
     results.push({ profile_id:profileId, status:result.status, observation:result.observation });
     if (result.status === 'paused') break;
   }
@@ -1402,7 +1413,7 @@ function r34ReasonHash(goal,decisionEvent,reason) {
 }
 async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,policy,codingRuntime,
   nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,assertRunAuthority,
-  signingKeyPath,verifyKeyPath,workerScheduler}) {
+  signingKeyPath,verifyKeyPath,workerScheduler,childDeadline=null}) {
   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');
@@ -1460,11 +1471,11 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
       await assertRunAuthority(goal.root_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});
+        epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase:loop.phase,childDeadline});
     } else if (decision.action.kind === 'delegate') {
       outcome=await executeDelegate({ctx,events,goal,decisionEvent,
         decision:{operation:decision.action.operation},policy,
-        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,desktopRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,desktopRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath,childDeadline});
     } 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,
@@ -1493,7 +1504,7 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
     } else if (capabilityIdForOperation(decision.action)) {
       outcome=await executeDelegate({ctx,events,goal,decisionEvent,
         decision:{operation:decision.action},policy,
-        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,desktopRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,desktopRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath,childDeadline});
     } else {
       throw new Error(`unsupported R34 action '${String(decision.action.kind)}'`);
     }
@@ -1612,12 +1623,12 @@ async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,
 
 async function executeDecisionCore({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
   nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, semanticRuntime, desktopRuntime, assertRunAuthority,
-  signingKeyPath, verifyKeyPath, workerScheduler }) {
+  signingKeyPath, verifyKeyPath, workerScheduler, childDeadline = null }) {
   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,desktopRuntime,assertRunAuthority,
-      signingKeyPath,verifyKeyPath,workerScheduler});
+      signingKeyPath,verifyKeyPath,workerScheduler,childDeadline});
     await appendEvent(ctx,events,signingKeyPath,'decision_completed',{
       decision_event_sha256:decisionEvent.event_sha256,action:decision.kind,
       outcome_status:outcome.status ?? 'completed'
@@ -1650,12 +1661,12 @@ async function executeDecisionCore({ ctx, events, goal, state, decisionEvent, po
       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 });
+      runtimes:{ machineFsRuntime,observationRuntime,processRuntime },assertRunAuthority,signingKeyPath,verifyKeyPath,childDeadline });
   } else if (decision.action === 'run_profile') {
     await assertRunAuthority(goal.root_id);
     outcome = await executeProfileWithLease({workerScheduler,ctx,events,goal,
       actionKey:`planner-${decisionEvent.event_sha256}`,profileId:decision.profile_id,
-      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath});
+      epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath,childDeadline});
   } else if (decision.action === 'pause') {
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
       reason:decision.reason, planner_summary:decision.summary
@@ -1817,9 +1828,9 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     return { autonomous, coding };
   }
 
-  async function submit({ submissionId, rootId, title = '', goal, acceptance = '', taskContract = null, maxIterations = null }) {
+  async function submit({ submissionId, rootId, title = '', goal, acceptance = '', taskContract = null, maxIterations = null, timeoutMs = null }) {
     await assertRunAuthority(rootId);
-    const normalized = normalizeGoal(policy,{ submissionId,rootId,title,goal,acceptance,taskContract,maxIterations });
+    const normalized = normalizeGoal(policy,{ submissionId,rootId,title,goal,acceptance,taskContract,maxIterations,timeoutMs });
     const goalId = goalIdFor(policy.policy_sha256,submissionId);
     const ctx = goalContext(policy,goalId);
     if (await exists(ctx.dir)) {
@@ -1838,7 +1849,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     await appendEvent(ctx,journal,signingKeyPath,'goal_created',{
       submission_id:submissionId, root_id:rootId, title, acceptance:normalized.acceptance,
       task_contract:normalized.task_contract,goal_sha256:normalized.goal_sha256,
-      max_iterations:normalized.max_iterations,
+      max_iterations:normalized.max_iterations, timeout_ms:normalized.timeout_ms,
       ...(memoryProvider?{source_release_manifest:memoryProvider.source_release_manifest}:{})
     });
     return { status:'accepted', goal_id:goalId, goal_sha256:normalized.goal_sha256, state:'pending' };
@@ -1849,11 +1860,18 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     const goal = await loadGoal(ctx,policy,verifyKeyPath);
     const journal = await readEvents(ctx,verifyKeyPath);
     const derived = deriveState(goal,journal);
+    const goalCreated = journal.find(event => event.type === 'goal_created');
+    const goalCreatedAtMs = goalCreated ? Date.parse(goalCreated.created_at_utc) : NaN;
+    if (!Number.isFinite(goalCreatedAtMs)) throw new Error('autonomous goal creation timestamp invalid');
+    const deadline = createDeadline({ timeoutMs:goal.timeout_ms, nowMs:goalCreatedAtMs, id:goalId });
     const loop = publicLoopState(loopStateOrNull(goal,journal),goal,journal);
     const lock=await runLockStatus(ctx);
+    const stream=createJournalStream({streamId:goalId,events:journal,maxItems:10000,maxBytes:16*1024*1024,producer:'autonomous-goal',channel:'event'});
+    const snapshot=stream.snapshot();
     return { status:'ok', goal_id:goalId, goal_sha256:goal.goal_sha256,
-      title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived, ...lock,
-      ...(loop ? {loop} : {}) };
+      title:goal.title, root_id:goal.root_id, timeout_ms:goal.timeout_ms, deadline, journal_verified:true, ...derived, ...lock,
+      stream_id:snapshot.stream_id, stream_generation:snapshot.generation, stream_next_seq:snapshot.next_seq,
+      stream_coverage:stream.coverage(), ...(loop ? {loop} : {}) };
   }
 
   async function events({ goalId, fromSeq = 1, limit = 100 }) {
@@ -1861,9 +1879,13 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     if (!Number.isInteger(limit) || limit < 1 || limit > 200) throw new Error('autonomous event limit must be in [1,200]');
     const ctx = goalContext(policy,goalId); await loadGoal(ctx,policy,verifyKeyPath);
     const journal = await readEvents(ctx,verifyKeyPath);
+    const stream=createJournalStream({streamId:goalId,events:journal,maxItems:10000,maxBytes:16*1024*1024,producer:'autonomous-goal',channel:'event'});
+    const page=stream.read(fromSeq,limit);
+    const snapshot=stream.snapshot();
     return { status:'ok', goal_id:goalId, journal_verified:true,
       journal_head_sha256:journal.at(-1)?.event_sha256 ?? ZERO_HASH,
-      events:journal.slice(fromSeq-1,fromSeq-1+limit) };
+      stream_id:snapshot.stream_id, stream_generation:snapshot.generation, stream_next_seq:snapshot.next_seq,
+      stream_coverage:stream.coverage(), events:page.items.map(item=>item.value) };
   }
   async function cancel({ goalId, reason = 'operator_request' }) {
     if (typeof reason !== 'string' || reason.length < 1 || reason.length > 256) throw new Error('autonomous cancel reason invalid');
@@ -1896,6 +1918,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       const current = deriveState(goal,journal);
       if (terminalState(current)) return withLoopResult(goal,journal,{ status:'terminal', goal_id:goalId, state:current.state });
       if (!pauseState(current)) throw new Error('autonomous goal is not paused');
+      if (current.reason === 'deadline_exceeded') throw new Error('autonomous goal deadline expired');
       if (decision === 'reject') {
         await appendEvent(ctx,journal,signingKeyPath,'goal_cancelled',{ reason:'resume_rejected' });
         return withLoopResult(goal,journal,{ status:'rejected', goal_id:goalId, state:'cancelled' });
@@ -2026,9 +2049,26 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       if (await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)) {
         state = deriveState(goal,journal); return withLoopResult(goal,journal,{ status:'cancelled', goal_id:goalId, ...state });
       }
-      await appendEvent(ctx,journal,signingKeyPath,'goal_run_started',{ max_cycles:maxCycles });
+      const goalCreated = journal.find(event => event.type === 'goal_created');
+      const goalCreatedAtMs = goalCreated ? Date.parse(goalCreated.created_at_utc) : NaN;
+      if (!Number.isFinite(goalCreatedAtMs)) throw new Error('autonomous goal creation timestamp invalid');
+      const deadline = createDeadline({ timeoutMs:goal.timeout_ms, nowMs:goalCreatedAtMs, id:goalId });
+      const deadlineExpired = () => goal.timeout_ms !== null && deadlineState(deadline).expired;
+      const stopAtDeadline = async () => {
+        if (!deadlineExpired()) return false;
+        const existing = deriveState(goal,journal);
+        if (!(existing.state === 'paused' && existing.reason === 'deadline_exceeded')) {
+          await appendEvent(ctx,journal,signingKeyPath,'goal_paused',{ reason:'deadline_exceeded', deadline });
+        }
+        return true;
+      };
+      await appendEvent(ctx,journal,signingKeyPath,'goal_run_started',{ max_cycles:maxCycles, deadline });
       let cycles = 0; let suppliedResponse = plannerResponse;
       while (cycles < maxCycles) {
+        if (await stopAtDeadline()) {
+          state = deriveState(goal,journal);
+          return withLoopResult(goal,journal,{ status:'paused', reason:'deadline_exceeded', goal_id:goalId, deadline, ...state });
+        }
         state = deriveState(goal,journal);
         if (terminalState(state) || pauseState(state)) return withLoopResult(goal,journal,{ status:state.state, goal_id:goalId, ...state });
         if (await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)) {
@@ -2039,14 +2079,23 @@ 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,desktopRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath,workerScheduler });
+              observationRuntime,processRuntime,semanticRuntime,desktopRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath,workerScheduler,childDeadline:deadline });
           } catch (error) {
+            if (deadlineExpired() || error?.message === 'deadline_exceeded') {
+              await stopAtDeadline();
+              state = deriveState(goal,journal);
+              return withLoopResult(goal,journal,{ status:'paused', reason:'deadline_exceeded', goal_id:goalId, deadline, ...state });
+            }
             const loop=loopStateOrNull(goal,journal);
             if (!loop || loop.pending_action || !isAuthorityUnavailable(error)) throw error;
             outcome=await r34EnterWaiting({ctx,events:journal,goal,signingKeyPath,
               reason:'authority_unavailable',resumePhase:loop.phase});
           }
           cycles += 1; state = deriveState(goal,journal);
+          if (await stopAtDeadline()) {
+            state = deriveState(goal,journal);
+            return withLoopResult(goal,journal,{ status:'paused', reason:'deadline_exceeded', goal_id:goalId, deadline, ...state });
+          }
           if (outcome.status === 'paused' || pauseState(state)) return withLoopResult(goal,journal,{ status:'paused', goal_id:goalId, ...state });
           if (outcome.status === 'finish_requested') {
             const gate = await releaseGateLocked(ctx,goal,journal);
@@ -2063,6 +2112,10 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
           }
           continue;
         }
+        if (await stopAtDeadline()) {
+          state = deriveState(goal,journal);
+          return withLoopResult(goal,journal,{ status:'paused', reason:'deadline_exceeded', goal_id:goalId, deadline, ...state });
+        }
         const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
           desktopMemoryProvider,memoryProvider,signingKeyPath,plannerResponse:suppliedResponse,plannerProviderRuntime });
         suppliedResponse = null;
@@ -2079,7 +2132,7 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
         if (pauseState(state)) return withLoopResult(goal,journal,{ status:'paused', goal_id:goalId, ...state });
       }
       state = deriveState(goal,journal);
-      return withLoopResult(goal,journal,{ status:'yielded', goal_id:goalId, cycles, ...state });
+      return withLoopResult(goal,journal,{ status:'yielded', goal_id:goalId, cycles, deadline, ...state });
     } finally { await releaseLock(ctx); }
   }
 

package/src/capability-ledger.mjs

@@ -89,6 +89,7 @@ export const R36_CAPABILITY_ENTRIES=Object.freeze([
 
   gateway('process.start','process_session_start','process_session','start','DEADBYTE_PROCESS_RUNTIME','process',{mutating:true,receipt_class:'process'}),
   gateway('process.read','process_session_read','process_session','read','DEADBYTE_PROCESS_RUNTIME','process',{receipt_class:'process'}),
+  gateway('process.write','process_session_write','process_session','write','DEADBYTE_PROCESS_RUNTIME','process',{mutating:true,receipt_class:'process'}),
   gateway('process.status','process_session_status','process_session','status','DEADBYTE_PROCESS_RUNTIME','process',{receipt_class:'process'}),
   gateway('process.list','process_session_list','process_session','list','DEADBYTE_PROCESS_RUNTIME','process',{receipt_class:'process'}),
   gateway('process.action','process_session_action','process_session','action','DEADBYTE_PROCESS_RUNTIME','process',{mutating:true,receipt_class:'process'}),

package/src/coding-mcp-tools.mjs

@@ -171,8 +171,8 @@ export function registerCodingTools(server, { codingRuntime, taskRuntime, semant
   }, async ({ submission_id, title, steps }) => { try { return result(codingTaskSubmitOutputSchema, await taskRuntime.submit({ submissionId: submission_id, title, steps })); } catch (error) { return fail(codingTaskSubmitOutputSchema, error); } });
   server.registerTool('coding_task_run', {
     description: 'Advance one durable coding task by bounded steps with retry/checkpoint/crash reconciliation.',
-    inputSchema: z.strictObject({ task_id: taskId, max_steps: z.number().int().min(1).max(32).default(8) }), outputSchema: codingTaskRunOutputSchema
-  }, async ({ task_id, max_steps }) => { try { return result(codingTaskRunOutputSchema, await taskRuntime.run({ taskId: task_id, maxSteps: max_steps })); } catch (error) { return fail(codingTaskRunOutputSchema, error); } });
+    inputSchema: z.strictObject({ task_id: taskId, max_steps: z.number().int().min(1).max(32).default(8), timeout_ms: z.number().int().min(100).max(900000).nullable().default(null) }), outputSchema: codingTaskRunOutputSchema
+  }, async ({ task_id, max_steps, timeout_ms }) => { try { return result(codingTaskRunOutputSchema, await taskRuntime.run({ taskId: task_id, maxSteps: max_steps, timeoutMs: timeout_ms })); } catch (error) { return fail(codingTaskRunOutputSchema, error); } });
 
   server.registerTool('coding_task_status', {
     description: 'Read derived coding-task state from the authenticated event journal.',

package/src/coding-output-contracts.mjs

@@ -8,9 +8,19 @@ const hex64 = z.string().regex(HEX64_RE);
 const receiptId = z.string().regex(HEX24_RE);
 const taskId = z.string().regex(TASK_ID_RE);
 const stepId = z.string().regex(STEP_ID_RE);
+const streamCoverage = z.strictObject({
+  logical_first_seq:z.number().int().min(1), logical_last_seq:z.number().int().min(0),
+  retained_first_seq:z.number().int().min(1), retained_last_seq:z.number().int().min(0),
+  complete:z.boolean(), truncated:z.boolean(),
+  missing_ranges:z.array(z.strictObject({from:z.number().int().min(1),to:z.number().int().min(0)})).max(100000),
+  logical_item_count:z.number().int().min(0), retained_item_count:z.number().int().min(0),
+  logical_bytes:z.number().int().min(0), retained_bytes:z.number().int().min(0),
+  dropped_items:z.number().int().min(0), dropped_bytes:z.number().int().min(0), status:z.enum(['open','closed'])
+});
 const jsonObject = z.record(z.string(), z.json());
 const taskState = z.enum(['pending', 'running', 'paused', 'failed', 'cancelled', 'succeeded']);
 const codingKind = z.enum(['checkpoint', 'write', 'replace', 'command', 'benchmark']);
+const deadline = z.strictObject({ schema:z.literal('deadbyte.deadline.v1'), id:z.string().nullable(), created_at_ms:z.number(), timeout_ms:z.number().int().min(1).nullable(), deadline_ms:z.number().nullable() });
 
 function requireFields(value, ctx, fields) {
   for (const field of fields) if (value[field] === undefined) ctx.addIssue({ code: 'custom', path: [field], message: `${field} is required` });
@@ -87,7 +97,9 @@ export const codingSearchOutputSchema = statusContract({
     binary_files_skipped: z.number().int().min(0).optional(), truncated: z.boolean().optional(),
     truncation_reason: z.enum(['tree_limit','scan_byte_limit','max_results']).nullable().optional(),
     query_sha256: hex64.optional(), snapshot_sha256: hex64.optional(), page_sha256: hex64.optional(),
-    next_cursor: z.string().max(8192).nullable().optional() },
+    next_cursor: z.string().max(8192).nullable().optional(),
+    stream_id: hex64.optional(), stream_generation: z.number().int().min(1).optional(), stream_next_seq: z.number().int().min(1).optional(),
+    stream_coverage: streamCoverage.optional() },
   successStatuses: ['ok'], successRequired: ['root_id','path','pattern','target','mode','case_sensitive','matches','files_scanned','bytes_scanned','binary_files_skipped','truncated','truncation_reason','query_sha256','snapshot_sha256','page_sha256','next_cursor']
 });
 const semanticLocationSchema = z.strictObject({
@@ -222,7 +234,7 @@ export const codingTaskSubmitOutputSchema = statusContract({
   successStatuses: ['accepted', 'existing'], successRequired: ['task_id', 'plan_sha256', 'state']
 });
 export const codingTaskRunOutputSchema = z.strictObject({
-  status: z.enum(['terminal', 'paused', 'completed', 'cancelled', 'failed', 'yielded', 'succeeded']), error: z.string().optional(), task_id: taskId.optional(),
+  status: z.enum(['terminal', 'paused', 'completed', 'cancelled', 'failed', 'yielded', 'succeeded']), error: z.string().optional(), task_id: taskId.optional(), deadline: deadline.optional(),
   ...Object.fromEntries(Object.entries(derivedShape).map(([key, schema]) => [key, schema.optional()]))
 }).superRefine((value, ctx) => {
   if (value.error !== undefined) { if (value.status !== 'failed') ctx.addIssue({ code: 'custom', path: ['error'], message: 'error wrapper requires status=failed' }); return; }
@@ -231,13 +243,15 @@ export const codingTaskRunOutputSchema = z.strictObject({
 export const codingTaskStatusOutputSchema = statusContract({
   statuses: ['ok', 'failed'],
   shape: { task_id: taskId.optional(), plan_sha256: hex64.optional(),
-    ...Object.fromEntries(Object.entries(derivedShape).map(([key, schema]) => [key, schema.optional()])), journal_verified: z.literal(true).optional() },
+    ...Object.fromEntries(Object.entries(derivedShape).map(([key, schema]) => [key, schema.optional()])), journal_verified: z.literal(true).optional(),
+    stream_id: taskId.optional(), stream_generation: z.number().int().min(1).optional(), stream_next_seq: z.number().int().min(1).optional(), stream_coverage: streamCoverage.optional() },
   successStatuses: ['ok'], successRequired: ['task_id', 'plan_sha256', ...Object.keys(derivedShape), 'journal_verified']
 });
 export const codingTaskEventsOutputSchema = statusContract({
   statuses: ['ok', 'failed'],
   shape: { task_id: taskId.optional(), plan_sha256: hex64.optional(), journal_verified: z.literal(true).optional(),
-    journal_head_sha256: hex64.optional(), events: z.array(eventSchema).max(200).optional() },
+    journal_head_sha256: hex64.optional(), events: z.array(eventSchema).max(200).optional(),
+    stream_id: taskId.optional(), stream_generation: z.number().int().min(1).optional(), stream_next_seq: z.number().int().min(1).optional(), stream_coverage: streamCoverage.optional() },
   successStatuses: ['ok'], successRequired: ['task_id', 'plan_sha256', 'journal_verified', 'journal_head_sha256', 'events']
 });
 export const codingTaskCancelOutputSchema = statusContract({

package/src/coding-plane.mjs

@@ -10,6 +10,7 @@ import { isInside, validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { createCodingSearch } from './coding-search.mjs';
 import { createSearchCursorCodec } from './search-cursor.mjs';
+import { atomicMutation } from './atomic-mutation.mjs';
 
 export const CODING_POLICY_SCHEMA = 'deadbyte.coding-policy.v1';
 export const CODING_LEASE_SCHEMA = 'deadbyte.coding-lease.v1';
@@ -261,30 +262,8 @@ function decodeContent(content, encoding) {
   throw new Error('encoding must be utf8 or base64');
 }
 async function atomicWrite(target, bytes, expectedSha256, authorityCheck = null) {
-  const before = await targetState(target);
-  checkExpected(before, expectedSha256);
-  const temp = path.join(path.dirname(target), `.${path.basename(target)}.deadbyte-coding-${process.pid}-${randomBytes(8).toString('hex')}.tmp`);
-  let handle;
-  try {
-    if (authorityCheck) await authorityCheck();
-    handle = await open(temp, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY, 0o600);
-    await handle.writeFile(bytes);
-    await handle.sync();
-    await handle.close();
-    handle = null;
-    const race = await targetState(target);
-    checkExpected(race, expectedSha256);
-    if (authorityCheck) await authorityCheck();
-    await rename(temp, target);
-  } catch (error) {
-    if (handle) await handle.close().catch(() => {});
-    await rm(temp, { force: true }).catch(() => {});
-    throw error;
-  }
-  const after = await targetState(target);
-  const expectedAfter = sha256Bytes(bytes);
-  if (!after.exists || after.sha256 !== expectedAfter) throw new Error('coding write post-commit hash mismatch');
-  return { before, after };
+  return atomicMutation({ target, bytes, expected: expectedSha256, readState: targetState,
+    assertExpected: checkExpected, authorityCheck, tempTag: 'deadbyte-coding' });
 }
 function codingEnvironment() {
   const allowed = new Set([

package/src/coding-search.mjs

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { canonicalJson } from './canonical-json.mjs';
 import { decodeUtf8Strict } from './text-policy.mjs';
+import { createSequenceStream } from './workload-substrate.mjs';
 
 const sha256Object=value=>createHash('sha256').update(canonicalJson(value),'utf8').digest('hex');
 const sha256Bytes=bytes=>createHash('sha256').update(bytes).digest('hex');
@@ -121,18 +122,26 @@ export function createCodingSearch({tree,fileRead,cursorCodec}){
 
     const snapshotSha=sha256Object({schema:'deadbyte.coding-search-snapshot.v2',query_sha256:querySha,entries:snapshotEntries});
     if(decodedCursor&&decodedCursor.snapshot_sha256!==snapshotSha) throw new Error('coding search cursor stale snapshot mismatch');
+    const stream=createSequenceStream({streamId:querySha,maxItems:Math.max(1,maxResults),maxBytes:Math.max(1024, maxResults*4096)});
+    for(const match of matches) stream.append(match,{producer:'coding-search',channel:'match'});
     const offset=decodedCursor?.offset??0;
     if(offset>matches.length) throw new Error('coding search cursor offset exceeds retained results');
-    const pageMatches=matches.slice(offset,offset+pageSize);
+    const page=stream.read(offset+1,pageSize);
+    if(page.missing) throw new Error('coding search cursor offset is outside retained stream coverage');
+    const pageMatches=page.items.map(item=>item.value);
     const nextOffset=offset+pageMatches.length;
     const hasMore=nextOffset<matches.length;
     const nextCursor=hasMore?await cursorCodec.encode({query_sha256:querySha,snapshot_sha256:snapshotSha,offset:nextOffset}):null;
     const pageSha=sha256Object({schema:'deadbyte.coding-search-page.v2',query_sha256:querySha,snapshot_sha256:snapshotSha,offset,matches:pageMatches});
+    const coverage=stream.coverage();
+    const streamSnapshot=stream.snapshot();
     return {
       status:'ok',root_id:rootId,path,pattern,target,mode,case_sensitive:caseSensitive,
       matches:pageMatches,files_scanned:filesScanned,bytes_scanned:bytesScanned,binary_files_skipped:binaryFilesSkipped,
       truncated:truncated||hasMore,truncation_reason:truncationReason,query_sha256:querySha,snapshot_sha256:snapshotSha,
-      page_sha256:pageSha,next_cursor:nextCursor
+      page_sha256:pageSha,next_cursor:nextCursor,
+      stream_id:stream.streamId,stream_generation:stream.generation,stream_next_seq:streamSnapshot.next_seq,
+      stream_coverage:coverage
     };
   };
 }

package/src/coding-task-runtime.mjs

@@ -4,6 +4,8 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
+import { createJournalStream } from './workload-substrate.mjs';
+import { createDeadline, deadlineState } from './deadline-cancellation.mjs';
 
 export const CODING_TASK_PLAN_SCHEMA = 'deadbyte.coding-task-plan.v1';
 export const CODING_TASK_EVENT_SCHEMA = 'deadbyte.coding-task-event.v1';
@@ -525,7 +527,11 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
     const ctx = taskContext(policy, taskId);
     const plan = await loadPlan(ctx, policy, verifyKeyPath);
     const events = await readEvents(ctx, verifyKeyPath);
-    return { status: 'ok', task_id: taskId, plan_sha256: plan.plan_sha256, ...deriveState(plan, events), journal_verified: true };
+    const stream = createJournalStream({streamId:taskId,events,maxItems:MAX_EVENTS,maxBytes:8*1024*1024,producer:'coding-task',channel:'event'});
+    const snapshot = stream.snapshot();
+    return { status: 'ok', task_id: taskId, plan_sha256: plan.plan_sha256, ...deriveState(plan, events), journal_verified: true,
+      stream_id:snapshot.stream_id, stream_generation:snapshot.generation, stream_next_seq:snapshot.next_seq,
+      stream_coverage:stream.coverage() };
   }
 
   async function events({ taskId, fromSeq = 1, limit = 100 }) {
@@ -534,10 +540,15 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
     const ctx = taskContext(policy, taskId);
     const plan = await loadPlan(ctx, policy, verifyKeyPath);
     const all = await readEvents(ctx, verifyKeyPath);
+    const stream = createJournalStream({streamId:taskId,events:all,maxItems:MAX_EVENTS,maxBytes:8*1024*1024,producer:'coding-task',channel:'event'});
+    const page = stream.read(fromSeq,limit);
+    const snapshot = stream.snapshot();
     return {
       status: 'ok', task_id: taskId, plan_sha256: plan.plan_sha256, journal_verified: true,
       journal_head_sha256: all.at(-1)?.event_sha256 ?? ZERO_HASH,
-      events: all.slice(fromSeq - 1, fromSeq - 1 + limit)
+      stream_id: snapshot.stream_id, stream_generation: snapshot.generation, stream_next_seq: snapshot.next_seq,
+      stream_coverage: stream.coverage(),
+      events: page.items.map(item=>item.value)
     };
   }
 
@@ -590,8 +601,18 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
     const journal = await readEvents(ctx, verifyKeyPath);
     return verifyTaskReceipt(ctx, plan, journal, policy, verifyKeyPath, codingRuntime);
   }
-  async function run({ taskId, maxSteps = 8 }) {
+  async function run({ taskId, maxSteps = 8, timeoutMs = null }) {
     if (!Number.isInteger(maxSteps) || maxSteps < 1 || maxSteps > MAX_STEPS) throw new Error(`max_steps must be in [1, ${MAX_STEPS}]`);
+    if (timeoutMs !== null && (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 900000)) throw new Error('timeout_ms must be null or in [100,900000]');
+    const deadline = createDeadline({ timeoutMs });
+    const deadlineExpired = () => timeoutMs !== null && deadlineState(deadline).expired;
+    const failDeadline = async (ctx, journal, plan, stepId = null) => {
+      await appendEvent(ctx, journal, signingKeyPath, 'task_failed', {
+        stepId,
+        payload: { reason: 'deadline_exceeded', deadline }
+      });
+      return deriveState(plan, journal);
+    };
     const session = await codingRuntime.sessionStatus();
     if (!session.armed) throw new Error(`coding plane is disarmed: ${session.reason}`);
     const ctx = taskContext(policy, taskId);
@@ -610,10 +631,14 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
       if (await consumeCancel(ctx, journal, signingKeyPath, verifyKeyPath)) {
         derived = deriveState(plan, journal); return { status: 'cancelled', task_id: taskId, ...derived };
       }
-      await appendEvent(ctx, journal, signingKeyPath, 'run_started', { payload: { max_steps: maxSteps } });
+      await appendEvent(ctx, journal, signingKeyPath, 'run_started', { payload: { max_steps: maxSteps, deadline } });
       derived = deriveState(plan, journal);
       let consumed = 0;
       while (consumed < maxSteps) {
+        if (deadlineExpired()) {
+          derived = await failDeadline(ctx, journal, plan);
+          return { status: 'failed', task_id: taskId, ...derived, deadline };
+        }
         if (await consumeCancel(ctx, journal, signingKeyPath, verifyKeyPath)) {
           derived = deriveState(plan, journal); return { status: 'cancelled', task_id: taskId, ...derived };
         }
@@ -638,7 +663,9 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
         derived = deriveState(plan, journal);
         consumed += 1;
         try {
-          const executed = await executeStep(codingRuntime, plan, next, attempt);
+          const remainingMs = timeoutMs === null ? null : Math.max(100, Math.floor(deadlineState(deadline).remaining_ms));
+          const boundedStep = remainingMs === null ? next : { ...next, timeout_ms: next.timeout_ms === null || next.timeout_ms === undefined ? remainingMs : Math.min(next.timeout_ms, remainingMs) };
+          const executed = await executeStep(codingRuntime, plan, boundedStep, attempt);
           if (!executed.outcome.valid) {
             await appendEvent(ctx, journal, signingKeyPath, 'task_paused', {
               stepId: next.step_id, payload: { reason: 'post_execute_receipt_mismatch', detail: executed.outcome.reason }
@@ -646,6 +673,10 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
             derived = deriveState(plan, journal);
             return { status: 'paused', task_id: taskId, ...derived };
           }
+          if (deadlineExpired()) {
+            derived = await failDeadline(ctx, journal, plan, next.step_id);
+            return { status: 'failed', task_id: taskId, ...derived, deadline };
+          }
           if (executed.outcome.success) {
             await appendEvent(ctx, journal, signingKeyPath, 'step_succeeded', {
               stepId: next.step_id, payload: { ...executed.outcome.payload, attempt, recovered: false }
@@ -664,6 +695,10 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
           }
           derived = deriveState(plan, journal);
         } catch (error) {
+          if (deadlineExpired()) {
+            derived = await failDeadline(ctx, journal, plan, next.step_id);
+            return { status: 'failed', task_id: taskId, ...derived, deadline };
+          }
           const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
           if (checked.ok) {
             const outcome = receiptOutcome(next, checked, requestSha256);
@@ -717,7 +752,7 @@ export function createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyK
           }
         }
       }
-      return { status: 'yielded', task_id: taskId, ...derived };
+      return { status: 'yielded', task_id: taskId, ...derived, deadline };
     } finally { await releaseLock(ctx); }
   }