deadbyte-mcp 0.15.1 → 0.15.3

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

@@ -0,0 +1,111 @@
+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';
+import { doctor } from '../src/doctor-r45.mjs';
+
+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.15.2 / R46 FILELESS POWERSHELL WINDOWS BATCH GATE: PASS';
+const PARENT_RELEASE_ID='v0.15.1-d55f00b5144dc31a';
+const PARENT_MANIFEST='d55f00b5144dc31a7fe39e4dc60d640a94780da6aaeca0918e87636b816d7854';
+const PARENT_GENERATION='00cde7bf540cc2804d679a39040d5b07193c5f8a0d49cac3b882402f8f4e6ad8';
+const REOPENED_RUNTIME_RELEASE_ID='v0.15.2-0fb46542f6a4345f';
+const REOPENED_RUNTIME_MANIFEST='0fb46542f6a4345f1c527565d06bf6e9b8e283260e47bf684fb70a60308fcf34';
+const REOPENED_RUNTIME_GENERATION='4717e0eb9c515ce4b1e90b8496c49c68abde765a6de7490176b803912385afe4';
+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.15.2',`R46 Windows gate evidence requires V0.15.2, found ${pkg.version}`);
+  const release=JSON.parse(await readFile(path.join(candidate,'RELEASE.json'),'utf8'));
+  insist(release.version==='0.15.2'&&release.train==='R46','R46 release metadata mismatch');
+  const active=JSON.parse(await readFile(path.join(path.resolve(stateRoot),'active-release.json'),'utf8'));
+  const originalParent=active.release_id===PARENT_RELEASE_ID&&active.manifest_sha256===PARENT_MANIFEST&&active.generation_manifest_sha256===PARENT_GENERATION;
+  const reopenedPredecessor=active.release_id===REOPENED_RUNTIME_RELEASE_ID&&active.manifest_sha256===REOPENED_RUNTIME_MANIFEST&&active.generation_manifest_sha256===REOPENED_RUNTIME_GENERATION;
+  const currentR46Predecessor=active.version==='0.15.2'&&active.manifest_sha256!==manifestSha256&&/^[0-9a-f]{64}$/.test(active.generation_manifest_sha256??'');
+  insist(originalParent||reopenedPredecessor||currentR46Predecessor,'R46 runtime predecessor identity mismatch');
+  const parent={release_id:PARENT_RELEASE_ID,version:'0.15.1',manifest_sha256:PARENT_MANIFEST,generation_manifest_sha256:PARENT_GENERATION};
+
+  const doctorResult=await doctor();
+  insist(doctorResult?.status==='ok'&&doctorResult?.package_version==='0.15.2'&&doctorResult?.manifest?.verified===true,'R46 doctor evidence invalid');
+  insist(doctorResult?.policy?.host_v2_ready===true,'R46 doctor did not verify Host policy v2');
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'R46 Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r46-windows-gate.v1',
+    status:'passed',
+    exit_code:0,
+    version:'0.15.2',
+    train:'R46',
+    marker,
+    completed_at_utc:completed.toISOString(),
+    manifest_sha256:manifestSha256,
+    doctor:{
+      status:doctorResult.status,
+      manifest_sha256:doctorResult.manifest.sha256,
+      verified_entries:doctorResult.manifest.verified_entries,
+      host_v2_ready:doctorResult.policy.host_v2_ready
+    },
+    parent,
+    runtime_predecessor:{
+      release_id:active.release_id,
+      version:active.version,
+      manifest_sha256:active.manifest_sha256,
+      generation_manifest_sha256:active.generation_manifest_sha256,
+      mode:currentR46Predecessor?'current-r46-active':'reopenedPredecessor'===true?'reopened-unpublished-0.15.2':'sealed-0.15.1-parent'
+    },
+    features:{
+      fileless_powershell:true,
+      powershell_source_via_process_argv:true,
+      no_ps1_materialization_regression:true,
+      target_machine_process_profile_repin:true,
+      target_machine_cmd_repin:true,
+      target_machine_powershell_repin:true,
+      powershell_persistent_repl:true,
+      guarded_process_raw_input:true,
+      process_tail_reads:true,
+      process_wait_reads:true,
+      process_chunked_output_ring:true,
+      remote_reachability_ttl:true,
+      remote_probe_timeout_retry:true,
+      remote_dispatch_timeout_no_retry:true,
+      observation_search_terminal_ttl:true,
+      observation_search_hard_cap:128,
+      full_regression_required:true,
+      compact_tool_count:43,
+      full_tool_count:84
+    }
+  };
+  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,`r46-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,parent:evidence.parent};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R46 Windows gate evidence invalid');
+    insist(existing.version==='0.15.2'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R46 Windows gate identity mismatch');
+    insist(existing.parent?.release_id===parent.release_id&&existing.parent?.manifest_sha256===parent.manifest_sha256,'existing R46 parent evidence mismatch');
+    insist(existing.runtime_predecessor?.release_id===active.release_id&&existing.runtime_predecessor?.manifest_sha256===active.manifest_sha256,'existing R46 runtime predecessor evidence mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,parent:existing.parent};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeWindowsGateEvidence().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/workload-contract-regression-r47.mjs

@@ -0,0 +1,14 @@
+import { spawnSync } from 'node:child_process';
+const files = [
+  'test/output-schema.test.mjs',
+  'test/coding-catalog-consistency.test.mjs',
+  'test/semantic-backend-registry.test.mjs',
+  'test/coding-runtime.test.mjs',
+  'test/autonomous-runtime.test.mjs',
+  'test/process-runtime.test.mjs',
+  'test/workload-substrate.test.mjs'
+];
+const result = spawnSync(process.execPath, ['--test', '--test-concurrency=1', ...files], { cwd: new URL('..', import.meta.url), stdio: 'inherit', windowsHide: true, shell: false });
+if (result.error) throw result.error;
+if (result.signal) throw new Error(`workload contract regression terminated by ${result.signal}`);
+process.exitCode = Number.isInteger(result.status) ? result.status : 1;

package/scripts/workload-stream-regression.mjs

@@ -0,0 +1,16 @@
+import { spawnSync } from 'node:child_process';
+
+const files = [
+  'test/workload-substrate.test.mjs',
+  'test/coding-search-r36.test.mjs',
+  'test/process-runtime.test.mjs'
+];
+const result = spawnSync(process.execPath, ['--test', '--test-concurrency=1', ...files], {
+  cwd: new URL('..', import.meta.url),
+  stdio: 'inherit',
+  windowsHide: true,
+  shell: false
+});
+if (result.error) throw result.error;
+if (result.signal) throw new Error(`workload stream regression terminated by ${result.signal}`);
+process.exitCode = Number.isInteger(result.status) ? result.status : 1;

package/scripts/workload-substrate-r47-regression.mjs

@@ -0,0 +1,12 @@
+import { spawnSync } from 'node:child_process';
+const files = [
+  'test/workload-substrate.test.mjs',
+  'test/coding-search-r36.test.mjs',
+  'test/process-runtime.test.mjs',
+  'test/coding-runtime.test.mjs',
+  'test/autonomous-runtime.test.mjs'
+];
+const result = spawnSync(process.execPath, ['--test', '--test-concurrency=1', ...files], { cwd: new URL('..', import.meta.url), stdio: 'inherit', windowsHide: true, shell: false });
+if (result.error) throw result.error;
+if (result.signal) throw new Error(`workload substrate regression terminated by ${result.signal}`);
+process.exitCode = Number.isInteger(result.status) ? result.status : 1;

package/src/agent-backend-r44.mjs

@@ -3,6 +3,7 @@ import { EventEmitter } from 'node:events';
 import { lstat, mkdir, open, readFile, realpath, rename } from 'node:fs/promises';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import { classifyTermination, composeAbortSignal, createCancellationToken, createDeadline } from './deadline-cancellation.mjs';
 
 const STATE_SCHEMA='deadbyte.agent-backend-state.v1';
 const HEX64=/^[0-9a-f]{64}$/;
@@ -46,6 +47,16 @@ function validateState(state,backendId){
     insist(typeof item.method==='string'&&METHOD.test(item.method),'agent backend request method invalid');
     insist(HEX64.test(item.params_sha256??''),'agent backend params hash invalid');
     insist(typeof item.created_at_utc==='string'&&typeof item.updated_at_utc==='string','agent backend request timestamp invalid');
+    if(item.deadline!==undefined){
+      insist(item.deadline&&item.deadline.schema==='deadbyte.deadline.v1','agent backend request deadline invalid');
+      insist(item.deadline.timeout_ms===null||Number.isInteger(item.deadline.timeout_ms),'agent backend request deadline timeout invalid');
+      insist(item.deadline.deadline_ms===null||Number.isFinite(item.deadline.deadline_ms),'agent backend request deadline timestamp invalid');
+    }
+    if(item.termination!==undefined){
+      insist(item.termination&&typeof item.termination==='object'&&!Array.isArray(item.termination),'agent backend request termination invalid');
+      for(const key of ['deadline_exceeded','cancellation_requested','physical_termination','verified'])insist(typeof item.termination[key]==='boolean',`agent backend request termination ${key} invalid`);
+      insist(typeof item.termination.terminal_semantics==='string','agent backend request termination semantics invalid');
+    }
   }
   insist(typeof state.updated_at_utc==='string','agent backend state timestamp invalid');
   return state;
@@ -157,11 +168,12 @@ export async function createAgentBackendR44({
     threads:structuredClone(state.threads),requests:structuredClone(state.requests)
   });
 
-  async function terminal(id,{stateName,result=null,error=null}){
+  async function terminal(id,{stateName,result=null,error=null,termination=null}){
     const record=state.requests[id];if(!record||record.state!=='pending')return;
     record.state=stateName;record.updated_at_utc=now();
     if(result!==null)record.result=result;
     if(error!==null)record.error=String(error);
+    if(termination!==null)record.termination=termination;
     await persist();
     const waiter=pending.get(id);pending.delete(id);
     if(!waiter)return;
@@ -198,11 +210,29 @@ export async function createAgentBackendR44({
       for(const id of pending.keys())void terminal(id,{stateName:'failed',error:String(error?.message??error)});
     });
     transport.on('transport_error',error=>{
-      for(const id of pending.keys())void terminal(id,{stateName:'interrupted',error:String(error?.message??error)});
+      for(const id of pending.keys()){
+        const record=state.requests[id];
+        const termination=classifyTermination({
+          deadlineExceeded:record?.termination?.deadline_exceeded===true,
+          cancellationRequested:record?.termination?.cancellation_requested===true,
+          physicallyTerminated:false,
+          verified:false
+        });
+        void terminal(id,{stateName:'interrupted',error:String(error?.message??error),termination});
+      }
       started=false;
     });
     transport.on('exit',()=>{
-      for(const id of pending.keys())void terminal(id,{stateName:'interrupted',error:'agent backend transport exited'});
+      for(const id of pending.keys()){
+        const record=state.requests[id];
+        const termination=classifyTermination({
+          deadlineExceeded:record?.termination?.deadline_exceeded===true,
+          cancellationRequested:record?.termination?.cancellation_requested===true,
+          physicallyTerminated:true,
+          verified:true
+        });
+        void terminal(id,{stateName:'interrupted',error:'agent backend transport exited',termination});
+      }
       started=false;
     });
     await transport.start();started=true;return publicState();
@@ -223,17 +253,52 @@ export async function createAgentBackendR44({
     const sequence=++state.next_sequence;
     const paramsSha=sha(Buffer.from(canonicalJson(params),'utf8'));
     const id=sha(Buffer.from(canonicalJson({backend_id:backendId,state_epoch:state.state_epoch,sequence,method,params_sha256:paramsSha}),'utf8'));
-    state.requests[id]={state:'pending',method,params_sha256:paramsSha,created_at_utc:now(),updated_at_utc:now()};
+    const deadline=createDeadline({timeoutMs,id});
+    const cancellation=createCancellationToken({id});
+    const composed=composeAbortSignal({deadline,cancellation});
+    state.requests[id]={
+      state:'pending',method,params_sha256:paramsSha,created_at_utc:now(),updated_at_utc:now(),
+      deadline,
+      termination:classifyTermination()
+    };
     await persist();
-    let timer;
     const promise=new Promise((resolve,reject)=>{
-      pending.set(id,{resolve,reject});
-      timer=setTimeout(()=>{void terminal(id,{stateName:'failed',error:'agent backend request timeout'});},timeoutMs);
-    }).finally(()=>clearTimeout(timer));
+      pending.set(id,{resolve,reject,cancellation,composed});
+      composed.signal.addEventListener('abort',()=>{
+        const reason=String(composed.signal.reason??'cancelled');
+        const deadlineExceeded=reason==='deadline_exceeded';
+        const cancellationRequested=cancellation.snapshot().requested;
+        const termination=classifyTermination({deadlineExceeded,cancellationRequested,physicallyTerminated:false,verified:false});
+        void terminal(id,{stateName:'failed',error:deadlineExceeded?'agent backend request deadline exceeded':'agent backend request cancelled',termination});
+      },{once:true});
+    }).finally(()=>{
+      composed.close();
+      const waiter=pending.get(id);
+      if(waiter?.composed===composed)pending.delete(id);
+    });
     try{await transport.send(wire({id,method,params}));}
-    catch(error){await terminal(id,{stateName:'failed',error:String(error?.message??error)});}
+    catch(error){
+      const record=state.requests[id];
+      const termination=classifyTermination({
+        deadlineExceeded:record?.termination?.deadline_exceeded===true,
+        cancellationRequested:record?.termination?.cancellation_requested===true,
+        physicallyTerminated:false,
+        verified:false
+      });
+      await terminal(id,{stateName:'failed',error:String(error?.message??error),termination});
+    }
     return promise;
   }
+  async function cancelRequest(id,{reason='operator_request'}={}){
+    insist(HEX64.test(id),'agent backend request id invalid');
+    const record=state.requests[id];
+    if(!record)return {status:'missing',request_id:id};
+    if(record.state!=='pending')return {status:'terminal',request_id:id,state:record.state,termination:record.termination??null};
+    const waiter=pending.get(id);
+    if(!waiter?.cancellation)return {status:'pending',request_id:id,termination:record.termination??null};
+    waiter.cancellation.request(reason);
+    return {status:'requested',request_id:id};
+  }
   async function notify({method,params={}}={}){
     insist(started&&transport,'agent backend is not started');
     insist(typeof method==='string'&&METHOD.test(method),'agent backend notification method invalid');
@@ -250,5 +315,5 @@ export async function createAgentBackendR44({
     for(const [id,waiter] of pending){waiter.reject(new Error('simulated backend crash'));pending.delete(id);}
     if(transport?.stop)await transport.stop();transport=null;started=false;
   }
-  return Object.freeze({start,bindThread,request,notify,status,close,simulateCrashForTest,state_file:stateFile,wire_mode:wireMode});
+  return Object.freeze({start,bindThread,request,cancelRequest,notify,status,close,simulateCrashForTest,state_file:stateFile,wire_mode:wireMode});
 }

package/src/atomic-mutation.mjs

@@ -0,0 +1,55 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { open, rename, rm } from 'node:fs/promises';
+import path from 'node:path';
+
+const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+
+export async function atomicMutation({
+  target,
+  bytes,
+  expected,
+  readState,
+  assertExpected,
+  authorityCheck = null,
+  tempTag = 'deadbyte-atomic',
+  verifyPostcondition = null
+}) {
+  if (typeof target !== 'string' || target.length === 0) throw new Error('atomic mutation target is required');
+  if (!Buffer.isBuffer(bytes)) throw new Error('atomic mutation bytes must be a Buffer');
+  if (typeof readState !== 'function' || typeof assertExpected !== 'function') {
+    throw new Error('atomic mutation requires readState and assertExpected');
+  }
+  const before = await readState(target);
+  assertExpected(before, expected);
+  const temp = path.join(
+    path.dirname(target),
+    `.\${path.basename(target)}.\${tempTag}-\${process.pid}-\${randomBytes(8).toString('hex')}.tmp`
+  );
+  let handle;
+  try {
+    if (authorityCheck) await authorityCheck();
+    handle = await open(temp, 'wx', 0o600);
+    await handle.writeFile(bytes);
+    await handle.sync();
+    await handle.close();
+    handle = null;
+
+    const race = await readState(target);
+    assertExpected(race, expected);
+    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 readState(target);
+  const expectedAfter = sha256Bytes(bytes);
+  if (!after.exists || after.sha256 !== expectedAfter) {
+    throw new Error('atomic mutation post-commit hash mismatch');
+  }
+  if (verifyPostcondition) await verifyPostcondition({ before, after, expected_after_sha256: expectedAfter });
+  return { before, after, expected_after_sha256: expectedAfter };
+}

package/src/autonomous-mcp-tools.mjs

@@ -72,11 +72,12 @@ export function registerAutonomousTools(server,{ autonomousRuntime, nativeDiffRu
     inputSchema:z.strictObject({ submission_id:id, root_id:id, title:z.string().max(160).default(''),
       goal:z.string().min(1).max(8192), acceptance:z.string().max(4096).default(''),
       task_contract:taskContract.nullable().default(null),
-      max_iterations:z.number().int().min(1).max(64).nullable().default(null) }),
+      max_iterations:z.number().int().min(1).max(64).nullable().default(null),
+      timeout_ms:z.number().int().min(100).max(900000).nullable().default(null) }),
     outputSchema:autonomousGoalSubmitOutputSchema
-  },async({submission_id,root_id,title,goal,acceptance,task_contract,max_iterations})=>{ try {
+  },async({submission_id,root_id,title,goal,acceptance,task_contract,max_iterations,timeout_ms})=>{ try {
       return result(autonomousGoalSubmitOutputSchema,await autonomousRuntime.submit({ submissionId:submission_id,
-        rootId:root_id,title,goal,acceptance,taskContract:task_contract,maxIterations:max_iterations })); }
+        rootId:root_id,title,goal,acceptance,taskContract:task_contract,maxIterations:max_iterations,timeoutMs:timeout_ms })); }
     catch(error){ return fail(autonomousGoalSubmitOutputSchema,error); } });
   server.registerTool('autonomous_goal_run',{
     description:'Advance one autonomous production goal through inspect/native-diff/build/test/benchmark/replan cycles. Client-planner mode returns a typed input_required sentinel for the Bridge MRTR adapter.',

package/src/autonomous-output-contracts.mjs

@@ -3,7 +3,17 @@ import * as z from 'zod/v4';
 const hex64 = z.string().regex(/^[0-9a-f]{64}$/);
 const goalId = hex64;
 const jsonObject = z.record(z.string(),z.json());
+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 goalState = z.enum(['pending','running','paused','cancelled','succeeded']);
+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() });
 const loopPhase = z.enum(['PLANNING','INSPECTING','ACTING','VERIFYING','REPLANNING','WAITING','COMPLETE']);
 const loopStep = z.strictObject({
   step_id:z.string().regex(/^[A-Za-z0-9._-]{1,64}$/), intent:z.string().min(1).max(512), status:z.literal('active')
@@ -106,7 +116,7 @@ export const autonomousGoalSubmitOutputSchema = statusContract({
 const runShape = Object.fromEntries(Object.entries(derivedShape).map(([key,schema]) => [key,schema.optional()]));
 export const autonomousGoalRunOutputSchema = z.strictObject({
   status:z.enum(['terminal','paused','cancelled','completed','yielded','running','input_required','failed']), error:z.string().optional(),
-  goal_id:goalId.optional(), release:jsonObject.optional(), planner_request:jsonObject.optional(), loop:publicLoopSchema.optional(),
+  goal_id:goalId.optional(), release:jsonObject.optional(), planner_request:jsonObject.optional(), deadline:deadline.optional(), loop:publicLoopSchema.optional(),
   cycles:z.number().int().min(1).max(32).optional(), ...runShape
 }).superRefine((value,ctx) => {
   if (value.error !== undefined) { if (value.status !== 'failed') ctx.addIssue({code:'custom',path:['error'],message:'error wrapper requires failed'}); return; }
@@ -119,12 +129,15 @@ export const autonomousGoalStatusOutputSchema = statusContract({
   shape:{ goal_id:goalId.optional(), goal_sha256:hex64.optional(), title:z.string().optional(), root_id:z.string().optional(),
     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 }
+    run_lock_created_at_utc:z.string().nullable().optional(), timeout_ms:z.number().int().min(100).max(900000).nullable().optional(), deadline:deadline.optional(), loop:publicLoopSchema.optional(),
+    stream_id:goalId.nullable().optional(), stream_generation:z.number().int().min(1).nullable().optional(),
+    stream_next_seq:z.number().int().min(1).nullable().optional(), stream_coverage:streamCoverage.nullable().optional(), ...runShape }
 });
 export const autonomousGoalEventsOutputSchema = statusContract({
   statuses:['ok','failed'], success:['ok'], required:['goal_id','journal_verified','journal_head_sha256','events'],
   shape:{ goal_id:goalId.optional(), journal_verified:z.literal(true).optional(), journal_head_sha256:hex64.optional(),
-    events:z.array(jsonObject).max(200).optional() }
+    events:z.array(jsonObject).max(200).optional(), stream_id:goalId.optional(), stream_generation:z.number().int().min(1).optional(),
+    stream_next_seq:z.number().int().min(1).optional(), stream_coverage:streamCoverage.optional() }
 });
 export const autonomousGoalCancelOutputSchema = statusContract({
   statuses:['terminal','requested','existing','failed'], success:['terminal','requested','existing'], required:['goal_id','state'],