deadbyte-mcp 0.15.13 → 0.15.15

package/src/operation-lifecycle.mjs

@@ -0,0 +1,63 @@
+import { randomBytes } from 'node:crypto';
+import { createOperationHistory, operationHistoryReceipt } from './operation-history.mjs';
+
+export const OPERATION_LIFECYCLE_SCHEMA='deadbyte.operation-lifecycle.v1';
+const TERMINAL=new Set(['success','failure','cancelled','timed_out']);
+const ACTIVE=new Set(['start','running','cancel_requested','canceling','output','error']);
+const ALLOWED=new Map([
+  ['start',new Set(['running','cancel_requested','output','error','success','failure','cancelled','timed_out'])],
+  ['running',new Set(['running','cancel_requested','canceling','output','error','success','failure','cancelled','timed_out'])],
+  ['cancel_requested',new Set(['canceling','cancelled','timed_out','output','error'])],
+  ['canceling',new Set(['cancelled','timed_out','output','error'])],
+  ['output',new Set(['running','cancel_requested','canceling','output','error','success','failure','cancelled','timed_out'])],
+  ['error',new Set(['running','cancel_requested','canceling','success','failure','cancelled','timed_out','error'])],
+  ['success',new Set()], ['failure',new Set()], ['cancelled',new Set()], ['timed_out',new Set()]
+]);
+
+export function createOperationLifecycle({operationId=randomBytes(32).toString('hex'),clockMs=()=>Date.now(),maxEvents=1024,maxBytes=1024*1024}={}){
+  const history=createOperationHistory({operationId,clockMs,maxEvents,maxBytes});
+  let state='new';
+  let terminalSequence=null;
+  let terminalEventHash=null;
+  let terminalType=null;
+
+  function emit(type,payload={}){
+    if(typeof type!=='string'||(!ACTIVE.has(type)&&!TERMINAL.has(type))) throw new Error('invalid lifecycle event');
+    if(terminalType) {
+      if(TERMINAL.has(type)) throw new Error('terminal transition already committed');
+      throw new Error('late operation event rejected after terminal');
+    }
+    if(type==='start' && state!=='new') throw new Error('duplicate operation start');
+    const allowed=state==='new' ? new Set(['start']) : ALLOWED.get(state);
+    if(!allowed?.has(type)) throw new Error('invalid operation transition '+state+' -> '+type);
+    const event=history.append(type,payload);
+    state=type;
+    if(TERMINAL.has(type)){ terminalSequence=event.sequence; terminalEventHash=event.event_hash; terminalType=type; }
+    return Object.freeze({schema:OPERATION_LIFECYCLE_SCHEMA,operation_id:operationId,state,event});
+  }
+
+  function terminal(type,payload={}) {
+    if(!TERMINAL.has(type)) throw new Error('terminal type required');
+    return emit(type,payload);
+  }
+
+  function snapshot(){
+    const verified=history.verify();
+    return Object.freeze({
+      schema:OPERATION_LIFECYCLE_SCHEMA,operation_id:operationId,state,
+      terminal:{type:terminalType,sequence:terminalSequence,event_hash:terminalEventHash},
+      history_head_sha256:verified.head_event_hash,
+      next_sequence:verified.next_sequence,
+      overflow:verified.overflow
+    });
+  }
+
+  function receipt(){
+    if(!terminalType) throw new Error('terminal receipt unavailable before terminal transition');
+    const h=operationHistoryReceipt(history);
+    if(h.next_sequence!==terminalSequence+1 || h.head_event_hash!==terminalEventHash) throw new Error('terminal receipt/history mismatch');
+    return Object.freeze({...h,terminal_type:terminalType,terminal_sequence:terminalSequence,terminal_event_hash:terminalEventHash});
+  }
+
+  return Object.freeze({operationId,history,emit,terminal,snapshot,receipt,isTerminal:()=>Boolean(terminalType)});
+}

package/src/process-output-contracts.mjs

@@ -4,6 +4,17 @@ import { structuredToolResult } from './output-contracts.mjs';
 const hex64 = z.string().regex(/^[0-9a-f]{64}$/);
 const digits = z.string().regex(/^[0-9]+$/);
 const processState = z.enum(['running','exited','terminated']);
+const operationSnapshot = z.strictObject({
+  schema:z.literal('deadbyte.operation-lifecycle.v1'), operation_id:hex64,
+  state:z.string().min(1).max(32),
+  terminal:z.strictObject({type:z.enum(['success','failure','cancelled','timed_out']).nullable(),sequence:z.number().int().positive().nullable(),event_hash:hex64.nullable()}),
+  history_head_sha256:hex64,next_sequence:z.number().int().positive(),overflow:z.object({}).passthrough()
+});
+const operationReceipt = z.strictObject({
+  schema:z.literal('deadbyte.operation-terminal-receipt.v1'),operation_id:hex64,session_id:hex64,
+  terminal:z.object({}).passthrough(),root_id:z.string().min(1).max(64),policy_sha256:hex64,
+  key_id:z.string().min(1).max(128),signature:z.string().min(1).max(512)
+});
 const termination = z.strictObject({
   deadline_exceeded:z.boolean(), cancellation_requested:z.boolean(), physical_termination:z.boolean(), verified:z.boolean(),
   terminal_semantics:z.string().min(1).max(64)
@@ -11,6 +22,12 @@ const termination = z.strictObject({
 const deadline = z.strictObject({
   schema:z.literal('deadbyte.deadline.v1'), id:hex64.nullable(), created_at_ms:z.number(), timeout_ms:z.number().int().positive().nullable(), deadline_ms:z.number().nullable()
 });
+const readiness = z.strictObject({
+  state:z.enum(['running','ready_for_input','finished']),
+  evidence:z.string().min(1).max(64),
+  prompt:z.strictObject({profile:z.string().min(1).max(32),prompt:z.string().min(1).max(64)}).nullable(),
+  exit_code:z.number().int().nullable()
+});
 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),
@@ -40,7 +57,13 @@ export const processSessionRecordSchema = z.strictObject({
   stream_coverage: streamCoverage.nullable(),
   termination: termination.nullable(),
   deadline: deadline.nullable(),
-  journal_head_sha256: hex64
+  readiness: readiness.optional().nullable(),
+  journal_head_sha256: hex64,
+  operation_id: hex64.nullable().optional(),
+  operation: operationSnapshot.nullable().optional(),
+  operation_history_head_sha256: hex64.nullable().optional(),
+  operation_receipt: operationReceipt.nullable().optional(),
+  operation_history_error: z.string().max(4096).nullable().optional()
 });
 
 function resultWithSession(okStatus = 'ok') {

package/src/process-readiness.mjs

@@ -0,0 +1,120 @@
+const PROMPTS = Object.freeze({
+  python: ['>>> ', '... '],
+  node: ['> ', '... '],
+  powershell: ['PS> ', 'PS C:\\', '>> '],
+  cmd: ['> ', 'More? '],
+  shell: ['$ ', '# ', '% '],
+  mysql: ['mysql> ', '    -> '],
+  postgres: ['=# ', '-# '],
+  redis: ['redis> ']
+});
+
+const COMPLETION = [
+  /(?:^|\n)Process finished(?:\r?\n|$)/i,
+  /(?:^|\n)Command completed(?:\r?\n|$)/i,
+  /(?:^|\n)\[Process completed\]/i,
+  /(?:^|\n)Program terminated(?:\r?\n|$)/i,
+  /(?:^|\n)Exit code:\s*-?\d+/i
+];
+
+const ERROR_TERMINAL = [
+  /^\s*SyntaxError:/m,
+  /^\s*TypeError:/m,
+  /^\s*ReferenceError:/m,
+  /^\s*NameError:/m,
+  /^\s*Traceback/m,
+  /^\s*Unhandled exception/m
+];
+
+const stripAnsi = value => String(value ?? '').replace(/\x1b\[[0-?]*[ -\/]*[@-~]/g, '');
+
+export function normalizeProcessText(value) {
+  return stripAnsi(value).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+export function detectPrompt(text, profiles = PROMPTS) {
+  const normalized = normalizeProcessText(text);
+  const lastLine = normalized.split('\n').at(-1) ?? '';
+  for (const [profile, prompts] of Object.entries(profiles)) {
+    for (const prompt of prompts) {
+      if (lastLine.endsWith(prompt) || lastLine === prompt.trimEnd()) {
+        return { profile, prompt };
+      }
+    }
+  }
+  return null;
+}
+
+export function analyzeReadiness({stdout='', stderr='', state='running', exitCode=null} = {}) {
+  const out = normalizeProcessText(stdout);
+  const err = normalizeProcessText(stderr);
+  if (state === 'exited' || state === 'terminated') {
+    return Object.freeze({ state: 'finished', evidence: 'process_terminal', prompt: null, exit_code: exitCode });
+  }
+  const prompt = detectPrompt(out);
+  if (prompt) {
+    return Object.freeze({ state: 'ready_for_input', evidence: 'prompt', prompt, exit_code: null });
+  }
+  if (COMPLETION.some(pattern => pattern.test(out)) || ERROR_TERMINAL.some(pattern => pattern.test(err || out))) {
+    return Object.freeze({ state: 'finished', evidence: 'terminal_output', prompt: null, exit_code: exitCode });
+  }
+  if (out.length === 0 && err.length === 0) {
+    return Object.freeze({ state: 'running', evidence: 'no_output', prompt: null, exit_code: null });
+  }
+  return Object.freeze({ state: 'running', evidence: 'output_without_terminal_marker', prompt: null, exit_code: null });
+}
+
+export function lineEndingProfile(text) {
+  const value = String(text ?? '');
+  let crlf = 0, lf = 0, cr = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    if (value[i] === '\r') {
+      if (value[i + 1] === '\n') { crlf += 1; i += 1; } else cr += 1;
+    } else if (value[i] === '\n') lf += 1;
+  }
+  const total = crlf + lf + cr;
+  const styles = [crlf > 0, lf > 0, cr > 0].filter(Boolean).length;
+  const style = crlf >= lf && crlf >= cr && crlf > 0 ? '\r\n' : lf > 0 ? '\n' : cr > 0 ? '\r' : null;
+  return Object.freeze({ style, crlf, lf, cr, total, mixed: styles > 1 });
+}
+
+export function normalizeLineEndings(text, target) {
+  const lf = String(text ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  if (target === '\r\n') return lf.replace(/\n/g, '\r\n');
+  if (target === '\r') return lf.replace(/\n/g, '\r');
+  return lf;
+}
+
+export function createReadinessTracker({maxEvidenceBytes=16384}={}) {
+  if (!Number.isInteger(maxEvidenceBytes) || maxEvidenceBytes < 256) {
+    throw new Error('maxEvidenceBytes must be >= 256');
+  }
+  let stdout = '';
+  let stderr = '';
+  let sequence = 0;
+  let last = analyzeReadiness();
+
+  const append = (channel, chunk) => {
+    const value = normalizeProcessText(chunk);
+    if (channel === 'stderr') stderr = (stderr + value).slice(-maxEvidenceBytes);
+    else stdout = (stdout + value).slice(-maxEvidenceBytes);
+    sequence += 1;
+    last = analyzeReadiness({stdout, stderr});
+    return Object.freeze({sequence, channel, readiness: last});
+  };
+
+  const updateTerminal = (state, exitCode) => {
+    last = analyzeReadiness({stdout, stderr, state, exitCode});
+    sequence += 1;
+    return Object.freeze({sequence, readiness: last});
+  };
+
+  const snapshot = () => Object.freeze({
+    sequence,
+    readiness: last,
+    stdout_tail: stdout.slice(-2048),
+    stderr_tail: stderr.slice(-2048)
+  });
+
+  return Object.freeze({append, updateTerminal, snapshot});
+}

package/src/process-runtime.mjs

@@ -2,12 +2,14 @@ import { createHash, randomBytes, sign as cryptoSign, verify as cryptoVerify } f
 import { appendFile, lstat, mkdir, readFile, readdir, realpath, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import { createOperationLifecycle } from './operation-lifecycle.mjs';
 import { canonicalJson } from './canonical-json.mjs';
 import { isInside, validatePortableRelativePath } from './path-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { assertProcessArmed, recheckProcessAuthority } from './process-policy.mjs';
 import { createSequenceStream } from './workload-substrate.mjs';
 import { classifyTermination, composeAbortSignal, createCancellationToken, createDeadline } from './deadline-cancellation.mjs';
+import { createReadinessTracker } from './process-readiness.mjs';
 
 const EVENT_SCHEMA = 'deadbyte.process-event.v1';
 const EVENT_DOMAIN = Buffer.from('DEADBYTE-PROCESS-EVENT-V1\0', 'utf8');
@@ -18,6 +20,19 @@ const START_TIMEOUT_MS = 8000;
 const TERMINAL_RECOVERY_SCHEMA = 'deadbyte.process-terminal.v1';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+function textToOperationRecords(text){
+  const records=text.split(/\r?\n/).filter(Boolean).map(line=>JSON.parse(line));
+  let previous=ZERO_SHA256;
+  for(let i=0;i<records.length;i++){
+    const record=records[i];
+    const {event_hash:eventHash,payload,...body}=record;
+    if(body.sequence!==i+1||body.previous_event_hash!==previous||
+       body.payload_digest!==sha256Bytes(Buffer.from(canonicalJson(payload ?? {}),'utf8'))||
+       eventHash!==sha256Bytes(Buffer.from(canonicalJson(body),'utf8'))) throw new Error('operation history chain mismatch');
+    previous=eventHash;
+  }
+  return records;
+}
 const nowUtc = () => new Date().toISOString();
 
 const STANDARD_PATHEXT = '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC';
@@ -81,7 +96,13 @@ function publicSession(session) {
     stream_coverage: stream?.coverage() ?? null,
     termination: session.termination ?? null,
     deadline: session.deadline ?? null,
-    journal_head_sha256: session.journal_head_sha256
+    readiness: session.readiness?.snapshot().readiness ?? null,
+    journal_head_sha256: session.journal_head_sha256,
+    operation_id: session.operation_lifecycle?.operationId ?? null,
+    operation: session.operation_lifecycle?.snapshot() ?? null,
+    operation_history_head_sha256: session.operation_history_head_sha256 ?? null,
+    operation_receipt: session.operation_receipt ?? null,
+    operation_history_error: session.operation_history_error ?? null
   };
 }
 function retainedSlice(session, begin = 0, length = session.retained_output_bytes - begin) {
@@ -173,6 +194,75 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
     verifying: () => (verifyPromise ??= loadPublicVerifyKey(verifyKeyPath))
   };
 
+  async function persistOperationEvent(session, result){
+    const recordPath=session.operation_history_path;
+    await appendFile(recordPath, canonicalJson(result.event)+'\n', 'utf8');
+    session.operation_history_head_sha256=result.event.event_hash;
+    session.operation_sequence=result.event.sequence;
+    return result;
+  }
+  async function recordOperationEvent(session,type,payload={}){
+    const result=session.operation_lifecycle.emit(type,payload);
+    return persistOperationEvent(session,result);
+  }
+  function queueOperationEvent(session,type,payload={}){
+    const next=session.operation_event_chain.then(async ()=>{
+      try { return await recordOperationEvent(session,type,payload); }
+      catch(error){ session.operation_history_error=String(error?.message ?? error); throw error; }
+    });
+    session.operation_event_chain=next.catch(()=>undefined);
+    return next;
+  }
+  async function createSignedOperationReceipt(session){
+    const body={
+      schema:'deadbyte.operation-terminal-receipt.v1',
+      operation_id:session.operation_lifecycle.operationId,
+      session_id:session.session_id,
+      terminal:session.operation_lifecycle.receipt(),
+      root_id:session.root_id,
+      policy_sha256:runtime.policy.policy_sha256
+    };
+    const signing=await runtime.signing();
+    const canonical=Buffer.from(canonicalJson(body),'utf8');
+    const signature=cryptoSign(null,Buffer.concat([Buffer.from('DEADBYTE-OPERATION-RECEIPT-V1\\0','utf8'),canonical]),signing.privateKey).toString('base64');
+    const receipt={...body,key_id:signing.keyId,signature};
+    await writeFile(session.operation_receipt_path,canonicalJson(receipt)+'\n',{flag:'wx'});
+    session.operation_receipt=receipt;
+    return receipt;
+  }
+
+  async function verifyOperationEvidence({sessionId}){
+    const session=await sessionFor(sessionId);
+    const text=await readFile(session.operation_history_path,'utf8');
+    const records=text.split(/\r?\n/).filter(Boolean).map(line=>JSON.parse(line));
+    let previous=ZERO_SHA256;
+    for(let i=0;i<records.length;i++){
+      const record=records[i];
+      const {event_hash:eventHash,payload,...body}=record;
+      if(body.operation_id!==session.operation_lifecycle.operationId || body.sequence!==i+1 || body.previous_event_hash!==previous){
+        throw new Error('operation history continuity mismatch');
+      }
+      const payloadDigest=sha256Bytes(Buffer.from(canonicalJson(payload ?? {}),'utf8'));
+      if(body.payload_digest!==payloadDigest || eventHash!==sha256Bytes(Buffer.from(canonicalJson(body),'utf8'))){
+        throw new Error('operation history hash mismatch');
+      }
+      previous=eventHash;
+    }
+    if(previous!==session.operation_history_head_sha256) throw new Error('operation history head mismatch');
+    const receipt=JSON.parse(await readFile(session.operation_receipt_path,'utf8'));
+    const {key_id:keyId,signature,...body}=receipt;
+    const verifying=await runtime.verifying();
+    const canonical=Buffer.from(canonicalJson(body),'utf8');
+    if(keyId!==verifying.keyId || !cryptoVerify(null,Buffer.concat([Buffer.from('DEADBYTE-OPERATION-RECEIPT-V1\\0','utf8'),canonical]),verifying.publicKey,Buffer.from(signature,'base64'))){
+      throw new Error('operation terminal receipt signature mismatch');
+    }
+    if(body.operation_id!==session.operation_lifecycle.operationId || body.session_id!==session.session_id ||
+       body.terminal?.terminal_event_hash!==previous || body.terminal?.terminal_sequence!==records.length){
+      throw new Error('operation terminal receipt/history mismatch');
+    }
+    return {ok:true,operation_id:body.operation_id,terminal_sequence:body.terminal.terminal_sequence,terminal_event_hash:previous,receipt};
+  }
+
   async function readVerifiedJournal(sessionId, journalPath) {
     const verifying = await runtime.verifying();
     const text = await readFile(journalPath, 'utf8');
@@ -200,6 +290,7 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
   async function hydrateTerminalSessions() {
     if (hydrationPromise) return hydrationPromise;
     hydrationPromise = (async () => {
+      const verifying = await runtime.verifying();
       await mkdir(policy.state_dir, { recursive: true });
       const names = (await readdir(policy.state_dir)).filter(name => /^[0-9a-f]{64}\.jsonl$/.test(name)).sort();
       for (const name of names) {
@@ -224,8 +315,39 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
             !SHA256_RE.test(terminal.detail.stream_sha256 ?? '') || !Number.isInteger(terminal.detail.stream_head) ||
             !Number.isInteger(terminal.detail.earliest_offset) || terminal.detail.earliest_offset < 0 ||
             terminal.detail.stream_head < terminal.detail.earliest_offset || terminal.detail.stream_head - terminal.detail.earliest_offset !== output.length) continue;
+        const operationHistoryPath=path.join(policy.state_dir,`${sessionId}.operation.jsonl`);
+        const operationReceiptPath=path.join(policy.state_dir,`${sessionId}.operation-receipt.json`);
+        let operationReceipt, operationRecords, operationId;
+        try {
+          operationReceipt=JSON.parse(await readFile(operationReceiptPath,'utf8'));
+          const {key_id:keyId,signature,...receiptBody}=operationReceipt;
+          const receiptCanonical=Buffer.from(canonicalJson(receiptBody),'utf8');
+          if(operationReceipt.schema!=='deadbyte.operation-terminal-receipt.v1'||operationReceipt.session_id!==sessionId||
+             operationReceipt.policy_sha256!==policy.policy_sha256||keyId!==verifying.keyId||
+             !cryptoVerify(null,Buffer.concat([Buffer.from('DEADBYTE-OPERATION-RECEIPT-V1\\0','utf8'),receiptCanonical]),verifying.publicKey,Buffer.from(signature,'base64'))) continue;
+          operationId=operationReceipt.operation_id;
+          operationRecords=textToOperationRecords(await readFile(operationHistoryPath,'utf8'));
+          if(!operationRecords.length||operationRecords.at(-1).event_hash!==operationReceipt.terminal.terminal_event_hash||
+             operationRecords.at(-1).sequence!==operationReceipt.terminal.terminal_sequence) continue;
+        } catch { continue; }
+
+        const terminalOperation=operationReceipt.terminal;
+        const operationSnapshot={
+          schema:'deadbyte.operation-lifecycle.v1',
+          operation_id:operationId,
+          state:terminalOperation.terminal_type,
+          terminal:{type:terminalOperation.terminal_type,sequence:terminalOperation.terminal_sequence,event_hash:terminalOperation.terminal_event_hash},
+          history_head_sha256:terminalOperation.head_event_hash,
+          next_sequence:terminalOperation.next_sequence,
+          overflow:terminalOperation.overflow
+        };
         sessions.set(sessionId, {
           session_id:sessionId, job_id:null, profile_id:terminal.profile_id, root_id:terminal.root_id,
+          operation_lifecycle:{operationId,snapshot:()=>operationSnapshot},
+          operation_history_path:operationHistoryPath, operation_receipt_path:operationReceiptPath,
+          operation_history_head_sha256:terminalOperation.head_event_hash,
+          operation_sequence:terminalOperation.terminal_sequence,
+          operation_receipt:operationReceipt, operation_event_chain:Promise.resolve(), operation_history_error:null,
           cwd_relative:typeof started.detail?.cwd === 'string' ? started.detail.cwd : '.',
           child_pid:started.detail.child_pid, creation_filetime:String(started.detail.creation_filetime),
           state:terminal.type, exit_code:Number.isInteger(terminal.detail.exit_code) ? terminal.detail.exit_code : null,
@@ -300,6 +422,7 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
         session.child_pid = record.child_pid;
         session.creation_filetime = String(record.creation_filetime);
         session.state = 'running';
+        queueOperationEvent(session,'running',{child_pid:session.child_pid,creation_filetime:session.creation_filetime}).catch(()=>{});
         session.ready_resolve?.();
       } else if (record.child_pid === session.child_pid && Number.isInteger(record.exit_code)) {
         session.exit_code = record.exit_code;
@@ -327,10 +450,16 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
     const sessionId = randomBytes(32).toString('hex');
     const session = {
       session_id: sessionId, job_id: randomBytes(32).toString('hex'), profile_id: profileId, root_id: rootId,
+      operation_lifecycle:createOperationLifecycle({operationId:randomBytes(32).toString('hex')}),
+      operation_history_path:path.join(policy.state_dir, `${sessionId}.operation.jsonl`),
+      operation_receipt_path:path.join(policy.state_dir, `${sessionId}.operation-receipt.json`),
+      operation_history_head_sha256:ZERO_SHA256, operation_sequence:0, operation_receipt:null, operation_event_chain:Promise.resolve(), operation_history_error:null,
       cwd_relative: cwdInfo.relative, child_pid: null, creation_filetime: null, state: 'starting', exit_code: null,
       earliest_offset: 0, stream_head: 0, stream_sha256: ZERO_SHA256, output_chunks: [], retained_output_bytes: 0, control_buffer: Buffer.alloc(0),
       journal_head_sha256: ZERO_SHA256, journal_path: path.join(policy.state_dir, `${sessionId}.jsonl`), event_count: 0,
-      max_retained_output_bytes: profile.max_retained_output_bytes, output_stream: createSequenceStream({streamId: sessionId, maxItems: 1000000, maxBytes: profile.max_retained_output_bytes}), stderr: '', terminate_requested: false, protocol_error: null,
+      max_retained_output_bytes: profile.max_retained_output_bytes, output_stream: createSequenceStream({streamId: sessionId, maxItems: 1000000, maxBytes: profile.max_retained_output_bytes}), stderr: '',
+      readiness: createReadinessTracker({ maxEvidenceBytes: Math.min(65536, Math.max(4096, profile.max_retained_output_bytes)) }),
+      terminate_requested: false, protocol_error: null,
       deadline: createDeadline({ timeoutMs, id: sessionId }),
       cancellation: createCancellationToken({ id: sessionId }),
       termination: classifyTermination(),
@@ -345,6 +474,10 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
       { cwd: cwdInfo.resolved, env: processEnvironment(profile), windowsHide: true, shell: false, stdio: ['pipe','pipe','pipe'] });
     session.host = host;
     sessions.set(sessionId, session);
+    await queueOperationEvent(session,'start',{
+      profile_id:profileId,root_id:rootId,cwd:cwdInfo.relative,
+      args_sha256:sha256Bytes(Buffer.from(canonicalJson(args),'utf8'))
+    });
     const abortProcess = () => {
       const reason = String(composed.signal.reason ?? 'cancelled');
       const snapshot = session.cancellation.snapshot();
@@ -355,19 +488,39 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
         verified: false
       });
       session.terminate_requested = true;
+      if (!session.operation_cancel_transition) {
+        session.operation_cancel_transition=true;
+        if (snapshot.requested) {
+          queueOperationEvent(session,'cancel_requested',{reason:snapshot.reason ?? 'operator_request'}).catch(()=>{});
+        }
+        queueOperationEvent(session,'canceling',{
+          reason:reason,
+          deadline_exceeded:reason==='deadline_exceeded',
+          cancellation_requested:snapshot.requested
+        }).catch(()=>{});
+      }
       if (!host.killed) host.kill();
     };
     composed.signal.addEventListener('abort', abortProcess, { once: true });
     if (composed.signal.aborted) abortProcess();
     const ready = new Promise((resolve, reject) => { session.ready_resolve = resolve; session.ready_reject = reject; });
-    host.stdout.on('data', chunk => parseHostOutput(session, chunk));
-    host.stderr.on('data', chunk => { session.stderr = (session.stderr + chunk.toString('utf8')).slice(-16384); });
+    host.stdout.on('data', chunk => {
+      session.readiness.append('stdout', chunk);
+      parseHostOutput(session, chunk);
+      queueOperationEvent(session,'output',{channel:'stdout',bytes:Buffer.byteLength(chunk),payload_digest:sha256Bytes(Buffer.from(chunk))}).catch(()=>{});
+    });
+    host.stderr.on('data', chunk => {
+      session.stderr = (session.stderr + chunk.toString('utf8')).slice(-16384);
+      session.readiness.append('stderr', chunk);
+      queueOperationEvent(session,'error',{channel:'stderr',bytes:Buffer.byteLength(chunk),payload_digest:sha256Bytes(Buffer.from(chunk))}).catch(()=>{});
+    });
     host.once('error', error => session.ready_reject?.(error));
     session.close_promise = new Promise(resolve => {
       host.once('close', async code => {
         parseHostOutput(session, null, true);
         if (session.state === 'starting') session.ready_reject?.(new Error(`process host exited before READY: ${session.stderr}`));
         session.exit_code ??= Number.isInteger(code) ? code : null;
+        session.readiness.updateTerminal(session.terminate_requested ? 'terminated' : 'exited', session.exit_code);
         const snapshot = session.cancellation.snapshot();
         session.termination = classifyTermination({
           deadlineExceeded: session.deadline.deadline_ms !== null && Date.now() >= session.deadline.deadline_ms && session.terminate_requested,
@@ -376,6 +529,8 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
           verified: true
         });
         const terminalState = session.terminate_requested ? 'terminated' : 'exited';
+        const deadlineExceeded=session.deadline.deadline_ms !== null && Date.now() >= session.deadline.deadline_ms && session.terminate_requested;
+        const operationTerminal=deadlineExceeded ? 'timed_out' : (session.terminate_requested || snapshot.requested ? 'cancelled' : (session.exit_code===0 ? 'success' : 'failure'));
         try {
           const outputFile = `${session.session_id}.stream.bin`;
           const retainedOutput = retainedAll(session);
@@ -393,8 +548,20 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
             deadline:session.deadline,
             output_file:outputFile
           });
+          await queueOperationEvent(session,operationTerminal,{
+            exit_code:session.exit_code,
+            process_state:terminalState,
+            termination:session.termination,
+            stream_head:session.stream_head,
+            stream_sha256:session.stream_sha256
+          });
+          await session.operation_event_chain;
+          await createSignedOperationReceipt(session);
           session.state = terminalState;
-        } catch {}
+        } catch(error) {
+          session.operation_history_error=String(error?.message ?? error);
+          session.state = terminalState;
+        }
         composed.close();
         resolve();
       });
@@ -495,6 +662,11 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
   async function terminate({ sessionId }) {
     const session = await sessionFor(sessionId);
     if (['exited','terminated'].includes(session.state)) return publicSession(session);
+    if (!session.operation_cancel_transition) {
+      session.operation_cancel_transition=true;
+      await queueOperationEvent(session,'cancel_requested',{reason:'physical_termination'});
+      await queueOperationEvent(session,'canceling',{reason:'physical_termination',cancellation_requested:false});
+    }
     session.terminate_requested = true;
     if (!session.host.killed) session.host.kill();
     await session.close_promise;
@@ -527,5 +699,5 @@ export function createProcessRuntime({ policy, signingKeyPath, verifyKeyPath })
     return { ok: true, event_count: sequence, head_sha256: previous };
   }
 
-  return { policy, start, read, write, status, list, action, cancel, terminate, verifyEventJournal };
+  return { policy, start, read, write, status, list, action, cancel, terminate, verifyEventJournal, verifyOperationEvidence };
 }