@milpa/comal 0.2.1 → 0.2.3

package/src/code-run-artifact.mjs

@@ -0,0 +1,30 @@
+import {readFileSync,readdirSync,statSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {digest} from './operations.mjs';
+
+// Fingerprint actual installed source/VM artifacts, not just dependency versions.
+export function codeRunArtifactIdentity(configuration) {
+  const files=[],seen=new Set(),require=createRequire(import.meta.url);
+  const walk=(directory,prefix)=>{
+    for(const name of readdirSync(directory).sort()) {
+      if(name==='node_modules')continue;
+      const target=path.join(directory,name),label=prefix+'/'+name,info=statSync(target);
+      if(info.isDirectory())walk(target,label);
+      else if(info.isFile())files.push([label,createHash('sha256').update(readFileSync(target)).digest('hex')]);
+    }
+  };
+  const dependency=(name,resolver)=>{
+    let base=path.dirname(resolver.resolve(name)),pkg;
+    for(;;){try{pkg=JSON.parse(readFileSync(path.join(base,'package.json'),'utf8'));if(pkg.name===name)break;}catch{}const parent=path.dirname(base);if(parent===base)throw Error('Cannot locate installed VM package: '+name);base=parent;}
+    if(seen.has(base))return;seen.add(base);walk(base,pkg.name+'@'+pkg.version);
+    for(const child of Object.keys(pkg.dependencies||{}).sort())dependency(child,createRequire(path.join(base,'package.json')));
+  };
+  walk(fileURLToPath(new URL('.',import.meta.url)),'src');
+  dependency('quickjs-emscripten',require);
+  dependency('ajv',require);
+  const identity={schema:'comal-code-run-artifact/1',node:process.version,platform:process.platform,arch:process.arch,timezone:Intl.DateTimeFormat().resolvedOptions().timeZone,configuration,files};
+  return {digest:digest(identity),identity};
+}

package/src/code-run-journal.mjs

@@ -0,0 +1,135 @@
+import { randomUUID, randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { digest } from './operations.mjs';
+import { SessionStore } from './sessions.mjs';
+import { auditExecution } from './audit.mjs';
+import { acquireProcessLock } from './process-lock.mjs';
+
+const VERSION=1;
+export const CODE_RUN_JOURNAL_MAX_ATTEMPTS=5;
+const fail=(code,message)=>Object.assign(new Error(message),{code:`CODE_RUN_JOURNAL_${code}`});
+const uuid=value=>/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(value);
+const engine=()=>digest({version:VERSION,node:process.version,platform:process.platform,arch:process.arch,
+  timezone:Intl.DateTimeFormat().resolvedOptions().timeZone,
+  files:['code-run.mjs','code-run-worker.mjs','code-run-journal.mjs'].map(file=>readFileSync(new URL(file,import.meta.url),'utf8'))});
+
+// Host-only experimental resource. No model argument chooses a journal or grants replay safety.
+// The native book is the only store: results reference existing complete House receipts.
+export class CodeRunJournal {
+  #store; #sessionId; #id; #safe; #busy=false; #compatibility;
+  constructor({store,sessionId,id=randomUUID(),replaySafe=[],compatibility=null}) {
+    if(!(store instanceof SessionStore)||!uuid(id)||!Array.isArray(replaySafe)||replaySafe.some(n=>typeof n!=='string')) throw fail('HOST','A native store, session, UUID and host replay-safe operation list are required.');
+    store.file(sessionId);
+    if(compatibility!==null&&!/^[a-f0-9]{64}$/.test(compatibility))throw fail('HOST','Compatibility needs a pinned host profile identity.');
+    this.#store=store;this.#sessionId=sessionId;this.#id=id;this.#safe=[...new Set(replaySafe)].sort();this.#compatibility=compatibility;
+  }
+  get id(){return this.#id;}
+  async open({sourceRef,catalogue,limits,actor,sessionId,recordWork,signal}) {
+    if(this.#busy)throw fail('BUSY','This journal already owns a runtime.');
+    if(sessionId!==this.#sessionId||!actor?.id||typeof recordWork!=='function')throw fail('OWNER','The journal needs its original host-bound session and actor.');
+    this.#busy=true;let lock;
+    try {
+      lock=await acquireProcessLock(`${this.#store.file(sessionId)}.code-run-${this.#id}.lock`,{validate:()=>this.#store.validateForRecovery(sessionId)});
+      const load=async()=>{
+        const book=await this.#store.load(sessionId);
+        if(!book.journalAudit.verified||auditExecution(book).violations.length)throw fail('EVIDENCE','The native execution book does not verify.');
+        return book;
+      };
+      let book=await load();
+      const owned=row=>row.journal_id===this.#id&&row.type.startsWith('code_run_journal_');
+      const rows=book.rows.filter(owned),headers=rows.filter(r=>r.type==='code_run_journal_start');
+      const binding={version:VERSION,source_ref:sourceRef,catalogue,limits,actor,session_id:sessionId,house:this.#store.cwd,engine:engine(),replay_safe:this.#safe,...(this.#compatibility?{compatibility:this.#compatibility}:{})};
+      const fingerprint=digest(binding);
+      if(headers.length>1||rows.length&&!headers.length)throw fail('EVIDENCE','Journal birth is missing or duplicated.');
+      let header=headers[0];
+      if(header) {
+        if(header.fingerprint!==fingerprint||digest(header.binding)!==fingerprint||rows.some(r=>r.session_id!==sessionId||r.house!==this.#store.cwd||digest(r.actor)!==digest(actor)))throw fail('DRIFT','Source, runtime, catalogue, actor or replay policy changed; start a new journal.');
+        if(!Number.isSafeInteger(header.clock_ms)||!Number.isSafeInteger(header.deadline_ms)||header.deadline_ms!==header.clock_ms+limits.wallMs||!Number.isInteger(header.seed)||header.seed<0||header.seed>0xffffffff)throw fail('EVIDENCE','Invalid deterministic start data.');
+      } else {
+        const clock=Date.now();
+        header={type:'code_run_journal_start',journal_id:this.#id,binding,fingerprint,clock_ms:clock,deadline_ms:clock+limits.wallMs,seed:randomBytes(4).readUInt32LE()};
+        await recordWork(header);book=await load();header=book.rows.find(owned);
+        if(!header)throw fail('EVIDENCE','Journal birth was not retained by the native recorder.');
+      }
+      const check=()=>{signal?.throwIfAborted();if(Date.now()>=header.deadline_ms)throw fail('EXPIRED','The original journal deadline expired; no new observation was started.');};
+      check();
+      const slots=new Map(),results=new Map();
+      for(const row of book.rows.filter(owned)) {
+        if(row.type==='code_run_journal_call') {
+          if(!Number.isInteger(row.index)||row.index<1||row.index>limits.calls||!uuid(row.attempt_id)||row.call_id!==`${this.#id}:${row.attempt_id}:${row.index}`||!row.descriptor||row.descriptor_digest!==digest(row.descriptor))throw fail('EVIDENCE','Invalid journal call identity.');
+          const parent=book.rows.find(r=>r.type==='code_run_source'&&r.invocation_id===row.invocation_id&&r.run_id===this.#id&&r.attempt_id===row.attempt_id);
+          const proposal=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===row.invocation_id);
+          if(!parent||parent.source_ref!==sourceRef||digest(parent.source)!==sourceRef||proposal?.operation!=='CodeRun'||proposal.arguments_digest!==digest({code:parent.source}))throw fail('EVIDENCE','The call is not bound to its original native script invocation.');
+          const prior=slots.get(row.index);
+          const logical=descriptor=>{const {dispatch_contract_digest,...rest}=descriptor;return digest(rest);};
+          if(prior&&logical(prior[0].descriptor)!==logical(row.descriptor))throw fail('EVIDENCE','Journal call identity was reused for different arguments.');
+          if(!prior)slots.set(row.index,[]);
+          // Arrays retain every uncertain attempt; none is silently discarded.
+          slots.get(row.index).push(row);
+        }
+        if(row.type==='code_run_journal_result') {
+          if(results.has(row.index))throw fail('EVIDENCE','Duplicate journal result.');
+          results.set(row.index,row);
+        }
+      }
+      const prefix=slots.size;
+      if([...slots.keys()].some(i=>i<1||i>prefix)||[...results.keys()].some(i=>!slots.has(i)))throw fail('EVIDENCE','The saved call prefix is incomplete.');
+      const receiptFor=(intent,currentBook)=>{
+        const receipts=currentBook.rows.filter(r=>r.type==='house_receipt'&&r.call_id===intent.call_id);
+        if(receipts.length>1)throw fail('EVIDENCE','An attempt has multiple native receipts.');
+        const receipt=receipts[0];
+        if(!receipt)return null;
+        const d=intent.descriptor;
+        if(receipt.status!=='returned')throw fail('UNCERTAIN','A saved call failed or was refused; automatic recovery is unavailable.');
+        if(d.dispatch_contract_digest&&!this.#compatibility)throw fail('EVIDENCE','A changed dispatch contract requires a pinned host compatibility proof.');
+        if(receipt.parent_invocation_id!==intent.invocation_id||receipt.operation!==d.name||receipt.arguments_digest!==d.arguments_digest||receipt.contract_digest!==(d.dispatch_contract_digest||d.contract_digest)||digest(receipt.actor)!==digest(actor)||receipt.session_id!==sessionId||receipt.house!==this.#store.cwd||receipt.output_truncated||typeof receipt.output!=='string'||digest(receipt.output)!==receipt.output_digest||!receipt.timestamp)throw fail('EVIDENCE','The complete native receipt does not match the original call.');
+        return receipt;
+      };
+      const saved=new Map();
+      for(const [index,intents] of slots) {
+        const receipts=intents.map(i=>receiptFor(i,book)).filter(Boolean),reference=results.get(index);
+        if(receipts.length>1)throw fail('EVIDENCE','Multiple completed attempts cannot become one observation.');
+        const receipt=receipts[0];
+        if(reference&&(!receipt||reference.receipt_invocation_id!==receipt.invocation_id||reference.receipt_digest!==receipt.audit.sha256))throw fail('EVIDENCE','The journal result reference is missing or mismatched.');
+        if(receipt)saved.set(index,{receipt,referenced:Boolean(reference)});
+        else if(!this.#safe.includes(intents[0].descriptor.name))throw fail('UNCERTAIN','An unreceipted call may have partially run; this host did not authorize read-only replay.');
+      }
+      let cursor=0;
+      if(rows.filter(r=>r.type==='code_run_journal_attempt').length>=CODE_RUN_JOURNAL_MAX_ATTEMPTS)throw fail('ATTEMPTS','The original journal exhausted its five runtime attempts.');
+      const attemptId=randomUUID(),reused=[];
+      const event=event=>recordWork({...event,journal_id:this.#id,attempt_id:attemptId});
+      await event({type:'code_run_journal_attempt'});check();
+      const reference=async(index,receipt)=>event({type:'code_run_journal_result',index,receipt_invocation_id:receipt.invocation_id,receipt_digest:receipt.audit.sha256});
+      const runtime={
+        runId:this.#id,attemptId,determinism:{clock_ms:header.clock_ms,seed:header.seed},
+        deadlineMs:header.deadline_ms,reused,
+        call:async(index,name,args,contractDigest,invoke,dispatchDigest=contractDigest)=>{
+          check();
+          if(index!==cursor+1)throw fail('DIVERGED','The script call order diverged.');
+          if(dispatchDigest!==contractDigest&&!this.#compatibility)throw fail('HOST','Dispatch rebinding needs a pinned host profile.');
+          const descriptor={name,arguments_digest:digest(args),contract_digest:contractDigest,...(dispatchDigest!==contractDigest?{dispatch_contract_digest:dispatchDigest}:{})};
+          const prior=slots.get(index)?.[0].descriptor;
+          if(prior&&(prior.name!==name||prior.arguments_digest!==descriptor.arguments_digest||prior.contract_digest!==contractDigest))throw fail('DIVERGED','The script arguments or tool diverged before the saved prefix was consumed.');
+          const old=saved.get(index);
+          if(old) {
+            if(!old.referenced){await reference(index,old.receipt);old.referenced=true;}
+            const observation={call_index:index,operation:name,call_id:old.receipt.call_id,contract_digest:old.receipt.contract_digest,receipt_invocation_id:old.receipt.invocation_id,receipt_digest:old.receipt.audit.sha256,observed_at:old.receipt.timestamp,current:false};
+            await event({type:'code_run_journal_reuse',index,...observation});check();
+            reused.push(observation);cursor=index;
+            return {result:old.receipt.output,...observation,reused:true};
+          }
+          const callId=`${this.#id}:${attemptId}:${index}`;
+          await event({type:'code_run_journal_call',index,call_id:callId,descriptor,descriptor_digest:digest(descriptor)});check();
+          const result=await invoke(callId);
+          const current=await load(),intent=current.rows.find(r=>r.type==='code_run_journal_call'&&r.call_id===callId),receipt=intent&&receiptFor(intent,current);
+          if(!receipt||receipt.output!==result)throw fail('EVIDENCE','A complete matching native result is required before delivery to the VM.');
+          await reference(index,receipt);check();cursor=index;
+          return {result,call_id:callId,contract_digest:dispatchDigest,observed_at:receipt.timestamp,reused:false};
+        },
+        finish:()=>{check();if(cursor<prefix)throw fail('DIVERGED','The script ended before consuming its original call prefix.');},
+        close:async()=>{await lock.release();this.#busy=false;}
+      };
+      return runtime;
+    }catch(error){try{await lock?.release();}finally{this.#busy=false;}throw error;}
+  }
+}

package/src/code-run-session-proof.mjs

@@ -0,0 +1,50 @@
+import {digest} from './operations.mjs';
+
+// Incarnation IDs remain in native contracts. Only this compatibility comparison
+// removes them; an independently pinned implementation/configuration must match too.
+export function codeRunContractShape(value) {
+  const {revision,contract_digest,...contract}=value;
+  if(contract.origin){const {generation,...origin}=contract.origin;contract.origin=origin;}
+  return contract;
+}
+export function codeRunSessionPlan(rows,p,index=rows.length) {
+  const prefix=rows.slice(0,index),birth=prefix.find(r=>r.type==='code_run_session_bound'&&r.invocation_id===p.invocation_id);
+  if(!birth||birth.source!=='code_run_session_host'||p.operation!=='CodeRun'||p.parent_invocation_id!==null||birth.input_digest!==p.arguments_digest||digest(birth.input)!==p.arguments_digest||birth.session_id!==p.session_id||birth.house!==p.house||digest(birth.actor)!==digest(p.actor))return null;
+  const profile=prefix.find(r=>r.type==='code_run_session_profile'&&r.profile_digest===birth.profile_digest);
+  const rootContract=prefix.findLast(r=>r.type==='house_contract'&&r.contract_digest===p.contract_digest)?.contract;
+  if(!profile||digest(profile.identity)!==birth.profile_digest||rootContract?.revision!=='code-run-session/1:'+birth.profile_digest||rootContract.origin!==null||rootContract.permission!=='CodeRun'||!rootContract.steps)return null;
+  const preparations=prefix.filter(r=>r.type==='code_run_session_recovery'&&r.original_invocation_id===p.invocation_id&&r.journal_id===birth.journal_id&&r.profile_digest===birth.profile_digest);
+  for(const prepared of preparations.toReversed()) {
+    if(prepared.source!=='code_run_session_host')return null;
+    const result=prefix.findLast(r=>r.type==='house_receipt'&&r.call_id===prepared.call_id&&r.operation==='CodeRun'&&digest(r.actor)===digest(p.actor)&&r.session_id===p.session_id&&r.house===p.house);
+    const bound=result&&prefix.find(r=>r.type==='code_run_session_bound'&&r.invocation_id===result.invocation_id);
+    if(!result||result.arguments_digest!==p.arguments_digest||prepared.input_digest!==p.arguments_digest)continue;
+    const continuationContract=prefix.findLast(r=>r.type==='house_contract'&&r.contract_digest===result.contract_digest)?.contract;
+    if(continuationContract?.revision!=='code-run-session/1:'+birth.profile_digest||continuationContract.origin!==null||!continuationContract.steps||continuationContract.permission!=='CodeRun')return null;
+    if(bound&&(bound.original_invocation_id!==p.invocation_id||bound.journal_id!==birth.journal_id||bound.profile_digest!==birth.profile_digest||bound.input_digest!==p.arguments_digest||digest(bound.input)!==p.arguments_digest))continue;
+    if(!bound&&(result.status==='returned'||prefix.some(r=>r.type==='house_proposal'&&r.parent_invocation_id===result.invocation_id)))continue;
+    if(digest(birth.catalogue.map(codeRunContractShape))!==digest((bound?.catalogue||prepared.catalogue).map(codeRunContractShape)))return null;
+    const roots=[p.invocation_id,...prefix.filter(r=>r.type==='code_run_session_bound'&&r.original_invocation_id===p.invocation_id&&r.journal_id===birth.journal_id&&r.profile_digest===birth.profile_digest).map(r=>r.invocation_id)];
+    for(const member of prefix.filter(r=>r.type==='code_run_session_bound'&&roots.includes(r.invocation_id)))if(member.source!=='code_run_session_host'||member.house!==p.house||member.session_id!==p.session_id||digest(member.actor)!==digest(p.actor)||member.input_digest!==p.arguments_digest||digest(member.input)!==p.arguments_digest||digest(member.catalogue.map(codeRunContractShape))!==digest(birth.catalogue.map(codeRunContractShape)))return null;
+    const descendants=new Set(roots);
+    for(const row of prefix)if(row.type==='house_proposal'&&descendants.has(row.parent_invocation_id))descendants.add(row.invocation_id);
+    const proposed=prefix.filter(r=>r.type==='house_proposal'&&descendants.has(r.invocation_id)&&!roots.includes(r.invocation_id));
+    for(const child of proposed) {
+      const contract=prefix.findLast(r=>r.type==='house_contract'&&r.contract_digest===child.contract_digest)?.contract;
+      const owner=prefix.find(r=>r.type==='code_run_session_bound'&&r.invocation_id===child.parent_invocation_id);
+      if(!contract||contract.steps||!['none','read'].includes(contract.effects?.workspace)||!['none','read'].includes(contract.effects?.external)||contract.effects?.authority!=='none'||!owner?.catalogue.some(c=>c.name===contract.name&&c.contract_digest===child.contract_digest))return null;
+    }
+    const final=result.status==='returned'?prefix.findLast(r=>r.type==='code_run_result'&&r.invocation_id===result.invocation_id&&r.source_ref===digest(birth.input.code)&&r.status==='returned'):null;
+    if(result.status==='returned'&&(!final||JSON.stringify(JSON.parse(result.output).output)!==JSON.stringify(final.output)))return null;
+    return {status:result.status==='returned'?'returned':'refused',journal_id:birth.journal_id,birth_ref:prefix.indexOf(birth),preparation_ref:prefix.indexOf(prepared),continuation_ref:prefix.indexOf(result),
+      output:result.status==='returned'?result.output:undefined,error:result.status==='returned'?undefined:JSON.stringify({code:'HOUSE_RECOVERY_CONTINUE',original_handler_return:'unavailable',continuation_status:result.status,reason:result.error,asked:'unjudged'}),
+      roots,descendants:[...descendants].filter(id=>!roots.includes(id))};
+  }
+  return null;
+}
+export function codeRunSessionRecoveryValid(rows,index,row) {
+  const r=row.recovery,root=rows[r.root_ref],plan=root&&codeRunSessionPlan(rows,root,index);
+  if(!plan||r.plan_digest!==digest(plan)||!['code_run_journal','code_run_journal_read'].includes(r.kind))return false;
+  if(r.kind==='code_run_journal_read')return plan.descendants.includes(row.invocation_id)&&row.status==='refused'&&row.code==='HOUSE_RECOVERY_READ_RETRY'&&row.effects_observed==='read_only'&&row.observations?.length===0;
+  return plan.roots.includes(row.invocation_id)&&row.status===plan.status&&row.asked==='unjudged'&&row.observations?.length===0&&(plan.status==='returned'?row.output===plan.output&&row.output_digest===digest(plan.output)&&row.output_truncated===false&&row.judgment_scope==='reconstructed_read_only_script_response'&&row.authority==='reconstructed_governed_continuation'&&row.disposition==='serve':row.code==='HOUSE_RECOVERY_CONTINUE'&&row.error===plan.error&&row.effects_observed==='read_only');
+}

package/src/code-run-session.mjs

@@ -0,0 +1,97 @@
+import {AsyncLocalStorage} from 'node:async_hooks';
+import {randomUUID} from 'node:crypto';
+import {digest} from './operations.mjs';
+import {CodeRunJournal,CODE_RUN_JOURNAL_MAX_ATTEMPTS} from './code-run-journal.mjs';
+import {codeRunDefinition,codeRunEligible,runCode,CODE_RUN_LIMITS} from './code-run.mjs';
+import {codeRunArtifactIdentity} from './code-run-artifact.mjs';
+import {codeRunContractShape,codeRunSessionPlan} from './code-run-session-proof.mjs';
+import {auditExecution} from './audit.mjs';
+import {processDead,processIdentity} from './process-lock.mjs';
+import {recoveryReceiptValid} from './file-recovery-proof.mjs';
+
+const fail=(code,message)=>Object.assign(new Error(message),{code});
+
+// Startup-only native experiment. Current registry generations are never rewritten.
+export function installCodeRunSession({tools,store,house,sessionId,actor,toolNames,replaySafe=[],configuration={},onCheckpoint=async()=>{},strategy='journal'}) {
+  if(!Array.isArray(toolNames)||!toolNames.length||toolNames.length>8||toolNames.some(n=>typeof n!=='string')||replaySafe.some(n=>!toolNames.includes(n)))throw Error('Select one to eight explicit observation names.');
+  if(!['journal','restart'].includes(strategy)||strategy==='restart'&&toolNames.some(n=>!replaySafe.includes(n)))throw Error('Whole-script comparison retry requires explicit replay safety for every selected observation.');
+  const artifact=codeRunArtifactIdentity({configuration,strategy,toolNames:[...toolNames].sort(),replaySafe:[...replaySafe].sort()});
+  const context=new AsyncLocalStorage();
+  const id=()=>typeof sessionId==='function'?sessionId():sessionId;
+  const catalogue=()=>{
+    const visible=tools.executor.catalogue().filter(c=>toolNames.includes(c.name));
+    if(visible.length!==toolNames.length||visible.some(c=>!codeRunEligible(c)))throw fail('CODE_RUN_SESSION_SCOPE','The current caller does not expose the complete selected read-only surface.');
+    for(const c of visible) {
+      if(c.origin===null&&!tools.isNativeOperation(c.name))throw fail('CODE_RUN_SESSION_SCOPE','Only native workspace operations are supported by this profile.');
+      if(c.origin&&(c.origin.plugin!=='chrome-lab'||c.origin.module_sha256!==artifact.identity.files.find(([name])=>name==='src/plugins/chrome-lab/index.mjs')?.[1]))throw fail('CODE_RUN_SESSION_SCOPE','The selected plugin implementation is outside the pinned native artifact.');
+    }
+    return visible.sort((a,b)=>a.name.localeCompare(b.name,'en'));
+  };
+  const verifyBook=book=>{if(!book.journalAudit.verified||auditExecution(book,house.stateContext()).violations.length)throw fail('AUDIT_INVALID','The session recovery book does not verify.');};
+  house.registry.replace(['CodeRun'],[{...codeRunDefinition,description:codeRunDefinition.description+' This host manages sequential read-only recovery. Recovery call_index is the 1-based tool-call order, not an output-field index. historical_reused identifies a dated prior observation; observed_this_attempt identifies a new observation in this execution, never proof of current or atomic DOM state.',revision:'code-run-session/1:'+artifact.digest,run:async(input,options)=>{
+    const sid=id(),book=await store.load(sid);verifyBook(book);
+    if(options.sessionId!==sid||digest(options.actor)!==digest(actor))throw fail('CODE_RUN_SESSION_OWNER','Session recovery needs its original host actor.');
+    const selected=catalogue(),resume=context.getStore();
+    const original=resume?.birth;
+    if(original&&(original.profile_digest!==artifact.digest||digest(original.catalogue.map(codeRunContractShape))!==digest(selected.map(codeRunContractShape))))throw fail('CODE_RUN_SESSION_DRIFT','Source, installed VM, plugin configuration or observation contracts changed.');
+    if(original&&(Date.now()>=original.deadline_ms||book.rows.filter(r=>r.type==='code_run_session_recovery'&&r.original_invocation_id===resume.original.invocation_id).length>=CODE_RUN_JOURNAL_MAX_ATTEMPTS))throw fail('CODE_RUN_SESSION_BUDGET','The original read-only execution deadline or five-attempt budget is exhausted.');
+    if(!book.rows.some(r=>r.type==='code_run_session_profile'&&r.profile_digest===artifact.digest))await options.recordWork({type:'code_run_session_profile',source:'code_run_session_host',profile_digest:artifact.digest,identity:artifact.identity});
+    const journalId=original?.journal_id||randomUUID();
+    const deadline=original?.deadline_ms||Date.now()+CODE_RUN_LIMITS.wallMs;
+    await options.recordWork({type:'code_run_session_bound',source:'code_run_session_host',profile_digest:artifact.digest,journal_id:journalId,input, input_digest:digest(input),deadline_ms:deadline,catalogue:selected,...(resume?{original_invocation_id:resume.original.invocation_id}:{})});
+    const journal=strategy==='journal'?new CodeRunJournal({store,sessionId:sid,id:journalId,replaySafe,compatibility:artifact.digest}):undefined;
+    // Enforce the original deadline during execution too, including the comparison
+    // strategy which has no journal timer of its own. A fresh VM gets no new budget.
+    const budget=new AbortController(),timer=setTimeout(()=>budget.abort(fail('CODE_RUN_SESSION_BUDGET','The original read-only execution deadline expired.')),Math.max(0,deadline-Date.now()));
+    const signal=options.signal?AbortSignal.any([options.signal,budget.signal]):budget.signal;
+    try {return await runCode(input,{...options,signal,codeRunJournal:journal,
+      recordWork:async event=>{await options.recordWork(event);await onCheckpoint(event);},
+      onCodeRunObservation:onCheckpoint,
+      // VM metadata stays byte-identical; actual dispatch still uses this invocation's
+      // fresh House snapshot and records its real current contract digest.
+      catalogue:strategy==='journal'?(original?.catalogue||selected):selected,
+      codeRunDispatchContracts:Object.fromEntries(selected.map(c=>[c.name,c.contract_digest]))});
+    } finally {clearTimeout(timer);}
+  }}]);
+
+  const recover=async({signal}={})=>store.workTransaction(id(),async()=>{
+    let book=await store.load(id());verifyBook(book);
+    const roots=book.rows.filter(r=>r.type==='code_run_session_bound'&&!r.original_invocation_id);
+    for(const birth of roots) {
+      book=await store.load(id());verifyBook(book);
+      const original=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===birth.invocation_id);
+      if(!original||original.parent_invocation_id!==null||book.rows.some(r=>r.type==='house_receipt'&&r.invocation_id===original.invocation_id))continue;
+      if(!processDead(original.execution_process))throw fail('CODE_RUN_SESSION_OWNER','The original CodeRun process is not proven dead.');
+      let plan=codeRunSessionPlan(book.rows,original);
+      if(!plan) {
+        const current=catalogue();
+        if(birth.profile_digest!==artifact.digest||digest(birth.catalogue.map(codeRunContractShape))!==digest(current.map(codeRunContractShape)))throw fail('CODE_RUN_SESSION_DRIFT','Recovery implementation/configuration/contracts differ; no observation was dispatched.');
+        const callId='code-run-recovery-'+randomUUID();
+        await store.append(id(),{type:'code_run_session_recovery',source:'code_run_session_host',original_invocation_id:original.invocation_id,journal_id:birth.journal_id,profile_digest:artifact.digest,input_digest:original.arguments_digest,catalogue:current,call_id:callId});
+        try{await context.run({birth,original},()=>tools.execute('CodeRun',birth.input,{callId,signal}));}
+        catch(error){if(signal?.aborted)throw error;/* A durable refusal is delivered below, never converted to success. */}
+        book=await store.load(id());verifyBook(book);plan=codeRunSessionPlan(book.rows,original);
+      }
+      if(!plan)throw fail('HOUSE_RECOVERY_UNCERTAIN','No complete compatible CodeRun continuation outcome is available.');
+      const targets=book.rows.filter(r=>r.type==='house_proposal'&&[...plan.roots,...plan.descendants].includes(r.invocation_id)).toReversed();
+      for(const proposal of targets) {
+        book=await store.load(id());
+        if(book.rows.some(r=>r.type==='house_receipt'&&r.invocation_id===proposal.invocation_id))continue;
+        if(!processDead(proposal.execution_process))throw fail('CODE_RUN_SESSION_OWNER','A related original process is not proven dead.');
+        const {audit:ignored,type,timestamp,...base}=proposal,isRoot=plan.roots.includes(proposal.invocation_id);
+        const recovery={version:1,kind:isRoot?'code_run_journal':'code_run_journal_read',proposal_ref:book.rows.indexOf(proposal),root_ref:book.rows.findIndex(r=>r.type==='house_proposal'&&r.invocation_id===original.invocation_id),original_process:proposal.execution_process,process_state:'dead',recovered_by:{actor,process:processIdentity},plan_digest:digest(plan)};
+        // Reloaded row objects are not reference-equal to the earlier target list.
+        recovery.proposal_ref=book.rows.findIndex(r=>r.type==='house_proposal'&&r.invocation_id===proposal.invocation_id);
+        const contract=book.rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===proposal.contract_digest)?.contract;
+        const returned=isRoot&&plan.status==='returned';
+        const closure={...base,type:'house_receipt',source:'recovery_host',recovery,status:returned?'returned':'refused',observations:[],asked:'unjudged',
+          ...(returned?{output:plan.output,output_digest:digest(plan.output),output_truncated:false,effects:contract.effects,authority:'reconstructed_governed_continuation',judgment_scope:'reconstructed_read_only_script_response',disposition:'serve'}:
+          {code:isRoot?'HOUSE_RECOVERY_CONTINUE':'HOUSE_RECOVERY_READ_RETRY',error:isRoot?plan.error:'Original read ended without a durable return; a separate governed continuation is recorded.',effects_observed:'read_only'})};
+        if(!recoveryReceiptValid(book.rows,book.rows.length,closure))throw fail('AUDIT_INVALID','The CodeRun recovery linkage does not verify.');
+        await store.append(id(),closure);
+      }
+    }
+  });
+  tools.codeRunSessionRecovery={recover,profile:artifact.digest};
+  return tools.codeRunSessionRecovery;
+}

package/src/code-run-worker.mjs

@@ -1,7 +1,7 @@
 import { parentPort, workerData } from 'node:worker_threads';
 import { getQuickJS } from 'quickjs-emscripten';
 
-const { code, catalogue, limits } = workerData;
+const { code, catalogue, limits, determinism } = workerData;
 const module = await getQuickJS(), runtime = module.newRuntime();
 runtime.setMemoryLimit(limits.memoryBytes); runtime.setMaxStackSize(limits.stackBytes);
 let cpuLeft = limits.cpuMs, activeStart = performance.now(), stopped = false, sequence = 0, emitted = 2;
@@ -13,7 +13,10 @@ const expose = (name, fn) => { const handle = vm.newFunction(name, fn); vm.setPr
 const jsonHandle = value => vm.unwrapResult(enter(() => vm.evalCode(`JSON.parse(${JSON.stringify(JSON.stringify(value))})`)));
 function fail(error) {
   if (stopped) return; stopped = true;
-  const message = error.message || String(error);
+  let message = error.message || String(error);
+  // Gate «extensión de bóveda»: QuickJS solo dice «not a function» (p. ej. `tools.searchTools(...)` antes
+  // de existir el alias); el modelo necesita saber qué hay para no repetir.
+  if (/not a function/.test(message)) message += ' — tools only has the visible tool names (tools.Read(args)), tools.call(name,args), tools.searchTools(query) and tools.describeTool(name); searchTools/describeTool also exist as globals.';
   const code = error.code || (cpuLeft <= 0 || /interrupted/.test(message) ? 'CODE_RUN_CPU_LIMIT' : /out of memory|allocation failed/i.test(message) ? 'CODE_RUN_MEMORY_LIMIT' : /stack overflow/i.test(message) ? 'CODE_RUN_STACK_LIMIT' : /output byte limit/.test(message) ? 'CODE_RUN_OUTPUT_LIMIT' : /call\/concurrency limit/.test(message) ? 'CODE_RUN_CALL_LIMIT' : /argument byte limit/.test(message) ? 'CODE_RUN_ARGUMENT_LIMIT' : /outside the read-only caller catalogue/.test(message) ? 'CODE_RUN_TOOL_UNAVAILABLE' : 'CODE_RUN_SCRIPT');
   parentPort.postMessage({ type: 'error', code, message, output });
 }
@@ -34,14 +37,27 @@ expose('__call', (nameHandle, argsHandle) => {
 });
 let script;
 try {
+  if(determinism)vm.unwrapResult(enter(()=>vm.evalCode(`(function(){
+    const NativeDate=globalThis.Date,clock=${JSON.stringify(determinism.clock_ms)};
+    function StableDate(...args){
+      if(!new.target)return new NativeDate(clock).toString();
+      return Reflect.construct(NativeDate,args.length?args:[clock],new.target===StableDate?NativeDate:new.target);
+    }
+    StableDate.prototype=NativeDate.prototype;
+    Object.defineProperty(StableDate.prototype,'constructor',{value:StableDate,writable:false,configurable:false});
+    Object.defineProperties(StableDate,{now:{value:()=>clock},parse:{value:NativeDate.parse},UTC:{value:NativeDate.UTC}});
+    Object.defineProperty(globalThis,'Date',{value:StableDate,writable:false,configurable:false});
+    let seed=${JSON.stringify(determinism.seed)};const imul=Math.imul;
+    Object.defineProperty(Math,'random',{value:()=>{seed=(imul(1664525,seed)+1013904223)>>>0;return seed/4294967296;},writable:false,configurable:false});
+  })();`))).dispose();
   // All metadata enters as JSON. Bindings expose only VM values, never native
   // host objects or host function constructors. No module loader is installed.
   vm.unwrapResult(enter(() => vm.evalCode(`
     const ALL_TOOLS = Object.freeze(${JSON.stringify(catalogue)}.map(t => Object.freeze(t)));
     const __allowed = new Set(ALL_TOOLS.map(t => t.name));
-    const tools = Object.freeze({...Object.fromEntries(ALL_TOOLS.map(t => [t.name, args => __call(t.name, JSON.stringify(args ?? {})).then(JSON.parse)])), call: (name,args) => __call(String(name),JSON.stringify(args ?? {})).then(JSON.parse)});
+    const tools = Object.freeze({...Object.fromEntries(ALL_TOOLS.map(t => [t.name, args => __call(t.name, JSON.stringify(args ?? {})).then(JSON.parse)])), call: (name,args) => __call(String(name),JSON.stringify(args ?? {})).then(JSON.parse), searchTools, describeTool});
     function text(value) { const encoded = JSON.stringify(value); __emit(encoded === undefined ? 'null' : encoded); }
-    function searchTools(query = '') { return ALL_TOOLS.filter(t => (t.name+' '+t.description).toLowerCase().includes(String(query).toLowerCase())).map(t => ({name:t.name,description:t.description})); }
+    function searchTools(query = '') { const q = String(query && typeof query === 'object' ? (query.query ?? '') : query).toLowerCase(); return ALL_TOOLS.filter(t => (t.name+' '+t.description).toLowerCase().includes(q)).map(t => ({name:t.name,description:t.description})); }
     function describeTool(name) { return ALL_TOOLS.find(t => t.name === name) || null; }
     Object.freeze(tools); Object.freeze(searchTools); Object.freeze(describeTool);
   `))).dispose();

package/src/code-run.mjs

@@ -2,6 +2,7 @@ import { Worker } from 'node:worker_threads';
 import { randomUUID } from 'node:crypto';
 import { digest } from './operations.mjs';
 import { chromeLabObservation } from './read-only-check.mjs';
+import { CodeRunJournal } from './code-run-journal.mjs';
 
 export const CODE_RUN_LIMITS = Object.freeze({ sourceBytes: 32768, outputBytes: 16384, resultBytes: 1048576, argumentBytes: 65536, calls: 32, concurrency: 4, wallMs: 30000, cpuMs: 2000, memoryBytes: 33554432, stackBytes: 262144, cleanupMs: 2000 });
 const ceiling = { ...CODE_RUN_LIMITS, wallMs: 60000, cpuMs: 5000, memoryBytes: 67108864 };
@@ -29,47 +30,70 @@ export async function runCode({ code }, options = {}) {
   signal?.throwIfAborted();
   const catalogue = options.catalogue.filter(codeRunEligible).map(row => ({ name: row.name, description: row.description, input_schema: row.input_schema, effects: row.effects, contract_digest: row.contract_digest }));
   const visible = new Map(catalogue.map(row => [row.name, row]));
-  const runId = randomUUID(), sourceRef = digest(code), controller = new AbortController();
+  let runId = randomUUID(), journal;
+  const runtimeToken=randomUUID(),sourceRef = digest(code), controller = new AbortController();
   const pending = new Map(), calls = []; let total = 0, closed = false, worker, timer;
   if (activeRuns.size >= CODE_RUN_MAX_WORKERS) throw failure('CODE_RUN_BUSY', 'Two CodeRun runtimes are already active; wait for completion before proposing another run.');
-  activeRuns.add(runId);
-  try { await recordWork({ type: 'code_run_source', run_id: runId, source_ref: sourceRef, source: code, limits, max_workers: CODE_RUN_MAX_WORKERS, catalogue: catalogue.map(({name,contract_digest}) => ({name,contract_digest})) }); }
-  catch(error) { activeRuns.delete(runId); throw error; }
+  activeRuns.add(runtimeToken);
+  try {
+    if(options.codeRunJournal) {
+      if(!(options.codeRunJournal instanceof CodeRunJournal))throw failure('CODE_RUN_JOURNAL_HOST','A native host journal is required.');
+      journal=await options.codeRunJournal.open({sourceRef,catalogue,limits,actor:options.actor,sessionId:options.sessionId,recordWork,signal});
+      runId=journal.runId;
+    }
+    await recordWork({ type: 'code_run_source', run_id: runId, ...(journal?{attempt_id:journal.attemptId}:{}),source_ref: sourceRef, source: code, limits, max_workers: CODE_RUN_MAX_WORKERS, catalogue: catalogue.map(({name,contract_digest}) => ({name,contract_digest})) });
+  } catch(error) { activeRuns.delete(runtimeToken);await journal?.close();throw error; }
   let rejectRun;
   const abort = () => { const error = signal?.reason instanceof Error ? signal.reason : failure('CODE_RUN_ABORTED', 'CodeRun was cancelled.'); controller.abort(error); rejectRun?.(error); };
   signal?.addEventListener('abort', abort, { once: true });
   let selected = [], runError;
   try {
     signal?.throwIfAborted();
-    worker = new Worker(new URL('./code-run-worker.mjs', import.meta.url), { workerData: { code, catalogue, limits }, resourceLimits: { maxOldGenerationSizeMb: 96, stackSizeMb: 4 }, execArgv: [] });
+    worker = new Worker(new URL('./code-run-worker.mjs', import.meta.url), { workerData: { code, catalogue, limits, ...(journal?{determinism:journal.determinism}: {}) }, resourceLimits: { maxOldGenerationSizeMb: 96, stackSizeMb: 4 }, execArgv: [] });
     selected = await new Promise((resolve, reject) => {
       rejectRun = reject;
-      timer = setTimeout(() => { const e = failure('CODE_RUN_TIMEOUT', 'CodeRun wall deadline exceeded.'); controller.abort(e); reject(e); }, limits.wallMs);
+      timer = setTimeout(() => { const e = failure('CODE_RUN_TIMEOUT', 'CodeRun wall deadline exceeded.'); controller.abort(e); reject(e); }, journal?Math.max(1,journal.deadlineMs-Date.now()):limits.wallMs);
       worker.on('error', reject);
       worker.on('exit', exit => { if (!closed && exit !== 0) reject(failure('CODE_RUN_WORKER', `CodeRun worker exited (${exit}).`)); });
       worker.on('message', message => {
         if (closed) return;
         if (message.type === 'output') { selected.push(message.value); return; }
-        if (message.type === 'done') { resolve(message.output); return; }
+        if (message.type === 'done') { try{journal?.finish();resolve(message.output);}catch(error){reject(error);}return; }
         if (message.type === 'error') { selected = message.output || []; reject(failure(message.code || 'CODE_RUN_SCRIPT', message.message)); return; }
         if (message.type !== 'call') return;
         const { id, name, args } = message;
         const answer = (ok, value, errorCode) => { if (!closed) worker.postMessage({ type: 'result', id, ok, value, code: errorCode }); };
         if (controller.signal.aborted) { answer(false, 'CodeRun is stopping.', 'CODE_RUN_ABORTED'); return; }
         if (!visible.has(name)) { answer(false, 'Tool is outside the read-only caller catalogue.', 'CODE_RUN_TOOL_UNAVAILABLE'); return; }
+        if(journal&&pending.size) {
+          const error=failure('CODE_RUN_JOURNAL_CONCURRENCY','The experimental journal accepts sequential awaited calls only.');
+          controller.abort(error);reject(error);return;
+        }
         if (++total > limits.calls || pending.size >= limits.concurrency) { answer(false, 'CodeRun tool call/concurrency limit exceeded.', 'CODE_RUN_CALL_LIMIT'); return; }
         if (Buffer.byteLength(JSON.stringify(args) ?? '') > limits.argumentBytes) { answer(false, 'CodeRun tool arguments exceed their byte limit.', 'CODE_RUN_ARGUMENT_LIMIT'); return; }
-        const callId = `${runId}:${id}`, row = { call_id: callId, operation: name, contract_digest: visible.get(name).contract_digest, arguments_digest: digest(args), status: 'started' }; calls.push(row);
+        const callId = journal?`${runId}:${journal.attemptId}:${id}`:`${runId}:${id}`, row = { call_id: callId, ...(journal?{call_index:id}:{}),operation: name, contract_digest: visible.get(name).contract_digest, arguments_digest: digest(args), status: 'started' }; calls.push(row);
         const work = (async () => {
           try {
             // This callback runs in the parent operation's async context; House
             // revalidates contracts, visibility and authority at the effect frontier.
-            const result = await invoke(name, args, { signal: controller.signal, callId, modelProposed: true });
-            row.status = 'returned'; row.output_ref = digest(result);
+            const governed=id=>invoke(name,args,{signal:controller.signal,callId:id,modelProposed:true});
+            const observation=journal?await journal.call(id,name,args,visible.get(name).contract_digest,governed,options.codeRunDispatchContracts?.[name]||visible.get(name).contract_digest):{result:await governed(callId),call_id:callId};
+            const result=observation.result;
+            row.call_id=observation.call_id;row.status = observation.reused?'historical_reused':'returned'; row.output_ref = digest(result);
+            if(observation.contract_digest&&observation.contract_digest!==row.contract_digest) {
+              row.vm_contract_digest=row.contract_digest;row.contract_digest=observation.contract_digest;
+            }
+            if(observation.observed_at)row.observed_at=observation.observed_at;
+            if(observation.reused)Object.assign(row,{observed_at:observation.observed_at,receipt_invocation_id:observation.receipt_invocation_id,current:false});
             const encoded = JSON.stringify(result);
             if (Buffer.byteLength(encoded ?? '') > limits.resultBytes) throw failure('CODE_RUN_RESULT_LIMIT', 'Tool observation exceeds the VM transfer limit; the complete House receipt remains recorded.');
+            await options.onCodeRunObservation?.({type:'code_run_observation',index:id,name,call_id:row.call_id,reused:Boolean(observation.reused)});
             answer(true, encoded ?? 'null');
-          } catch (error) { row.status = row.status === 'returned' ? 'returned_untransferred' : 'failed_or_refused'; row.code = error.code; answer(false, error.message, error.code); }
+          } catch (error) {
+            row.status = row.status === 'returned' ? 'returned_untransferred' : 'failed_or_refused'; row.code = error.code;
+            if(error.code?.startsWith('CODE_RUN_JOURNAL_')){controller.abort(error);reject(error);}
+            answer(false, error.message, error.code);
+          }
         })();
         pending.set(id, work); work.finally(() => pending.delete(id));
       });
@@ -84,14 +108,25 @@ export async function runCode({ code }, options = {}) {
       const settled = await Promise.race([Promise.allSettled([...pending.values()]).then(() => true), new Promise(resolve => { cleanupTimer = setTimeout(() => resolve(false), limits.cleanupMs); })]); clearTimeout(cleanupTimer);
       if (!settled) runError = failure('CODE_RUN_CLEANUP_PENDING', 'A host tool ignored cancellation; its outcome remains unknown/partial. Pending call IDs are recorded. Do not replay this script.');
     }
-    activeRuns.delete(runId);
+    activeRuns.delete(runtimeToken);
   }
   const outputRef = digest(selected);
-  const outcome = { run_id: runId, source_ref: sourceRef, output_ref: outputRef, output: selected, status: runError ? 'failed' : 'returned', code: runError?.code, error: runError?.message, calls: structuredClone(calls), pending_calls: [...pending.keys()].map(id => `${runId}:${id}`), replayed: false };
+  const recovery=journal?{journal_id:runId,attempt_id:journal.attemptId,scope:'historical_observation_reconstruction',reused_observations:structuredClone(journal.reused)}:null;
+  const outcome = { run_id: runId, source_ref: sourceRef, output_ref: outputRef, output: selected, status: runError ? 'failed' : 'returned', code: runError?.code, error: runError?.message, calls: structuredClone(calls), pending_calls: [...pending.keys()].map(id => journal?`${runId}:${journal.attemptId}:${id}`:`${runId}:${id}`), replayed: Boolean(journal?.reused.length),...(recovery?{recovery}:{}) };
+  try {
   await recordWork({ type: 'code_run_result', ...outcome });
   if (runError) {
     const details = { ...outcome, message: runError.message, next_action: 'Inspect this run and individual House receipts using the recorded call IDs. Preserve completed observations. Do not replay the script automatically; pending host calls may still have unknown/partial outcomes.' };
     const error = failure(runError.code || 'CODE_RUN_SCRIPT', JSON.stringify(details)); error.run_id = runId; error.details = details; throw error;
   }
-  return JSON.stringify({ run_id: runId, output: selected, source_ref: sourceRef, output_ref: outputRef, calls: calls.length });
+  const modelRecovery=recovery?{scope:recovery.scope,
+    reused_observations:recovery.reused_observations.map(({call_index,operation,observed_at,current,receipt_invocation_id})=>({call_index,operation,observed_at,current,receipt_invocation_id})),
+    call_observations:calls.map(row=>({call_index:row.call_index,operation:row.operation,state:row.status==='returned'?'observed_this_attempt':row.status,observed_at:row.observed_at}))}:null;
+  return JSON.stringify({ run_id: runId, output: selected, source_ref: sourceRef, output_ref: outputRef, calls: calls.length,...(modelRecovery?{recovery:modelRecovery}:{}) });
+  } finally {
+    if(journal) {
+      if(pending.size)void Promise.allSettled([...pending.values()]).then(()=>journal.close()).catch(()=>{});
+      else await journal.close();
+    }
+  }
 }

package/src/codex-provider.mjs

@@ -176,7 +176,7 @@ export class CodexProvider {
   async getVisionCapability({ signal } = {}) { const state = await this.discoverModelCapabilities({ signal }); return { supported: state.capabilities.vision === true, source: this.vision !== 'auto' ? 'explicit_user_configuration' : 'codex_models', model: this.model, imageTokens: this.imageTokens }; }
   getCapabilities() { return this.modelCapabilities?.model === this.model ? { ...this.modelCapabilities.capabilities, vision: this.modelCapabilities.capabilities.vision === true } : { text: true, tools: true, ...this.capabilitiesConfigured, vision: this.vision === 'on', video: false, web_search: false }; }
   analyzeMedia(request) { return analyzeImages(this, request); }
-  async complete({ system, messages, tools = [], schemaCatalog = [], contextIdentity, signal, onText = () => {}, onProgress = () => {}, purpose = 'worker', maxTokens = this.maxTokens }) {
+  async complete({ system, messages, tools = [], schemaCatalog = [], contextIdentity, signal, onText = () => {}, onProgress = () => {}, onReasoning = () => {}, onToolCall = () => {}, purpose = 'worker', maxTokens = this.maxTokens }) {
     if (this.capabilitiesConfigured.tools === false && tools.length) throw fail('The Codex profile does not enable tools; the request was not sent.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
     await this.discoverModel({ signal });
     const accountingRequest={system,messages,tools,maxTokens},identity={...accountingIdentity(this),projection_epoch:contextIdentity?.projection_epoch ?? null};
@@ -205,15 +205,15 @@ export class CodexProvider {
       let result, textChars = 0, reasoningChars = 0, argumentChars = 0, toolName;
       for await (const event of sseEvents(framed.body)) {
         if (event.type === 'response.output_text.delta') { onText(event.delta || ''); textChars += (event.delta || '').length; deadline.touch(); }
-        else if (event.type === 'response.reasoning_summary_text.delta') { reasoningChars += (event.delta || '').length; deadline.touch(); }
+        else if (event.type === 'response.reasoning_summary_text.delta') { reasoningChars += (event.delta || '').length; deadline.touch(); onReasoning(); }
         else if (event.type === 'response.function_call_arguments.delta') { argumentChars += (event.delta || '').length; deadline.touch(); }
-        else if (event.type === 'response.output_item.added') { toolName = event.item?.type === 'function_call' && typeof event.item.name === 'string' ? event.item.name : undefined; }
+        else if (event.type === 'response.output_item.added') { if (event.item?.type === 'function_call') onToolCall(); toolName = event.item?.type === 'function_call' && typeof event.item.name === 'string' ? event.item.name : undefined; }
         else if (event.type === 'response.completed') result = normalized(event.response);
         else if (['response.failed', 'response.incomplete', 'error'].includes(event.type)) { const failure = responseFailure(event); if (failure.code === 'OUTPUT_LENGTH') failure.details = { ...failure.details, text_chars: textChars, reasoning_chars: reasoningChars, tool_argument_chars: argumentChars, ...(toolName ? { tool_name: toolName } : {}) }; throw failure; }
         onProgress({ text_chars: textChars, reasoning_chars: reasoningChars, tool_argument_chars: argumentChars, elapsed_ms: deadline.elapsedMs(), purpose });
       }
       deadline.signal.throwIfAborted();
-      if (!result) throw fail('Codex streaming was interrupted; no tools were executed.', 'CODEX_RESPONSE_INCOMPLETE');
+      if (!result) throw fail('Codex streaming was interrupted; no tools were executed.', 'MODEL_STREAM_ERROR');
       return account(result);
     } catch (error) { if(error.usage_accounting)error.usage_accounting=bindUsageAccounting(error.usage_accounting,accountingRequest,identity,body);throw deadline.error(error); } finally { deadline.close(); }
   }

package/src/compaction-notice.mjs

@@ -0,0 +1,22 @@
+// One-line notices for automatic compactions. Pure presentation: no files, no
+// provider, no authority; safe to import from the TUI.
+import { t, registerMessages } from './i18n/index.mjs';
+const kilo = value => !Number.isFinite(value) ? '?' : value >= 10000 ? `${Math.round(value / 1000)}k` : String(Math.round(value));
+const TRIGGER_TEXT = {
+  soft_turn_end: 'Context compacted at the end of the turn · ~{v0} → ~{v1} tokens · compaction window {v2}',
+  idle_cache_expired: 'Context compacted after {v3} min idle (prompt cache expired) · ~{v0} → ~{v1} tokens · compaction window {v2}',
+  hard: 'Context compacted at the hard limit · ~{v0} → ~{v1} tokens · compaction window {v2}',
+  recovery: 'Context compacted to recover a context-length rejection · ~{v0} → ~{v1} tokens',
+  manual: 'Context compacted on request · ~{v0} → ~{v1} tokens',
+};
+registerMessages({
+  [TRIGGER_TEXT.soft_turn_end]: 'Contexto compactado al terminar el turno · ~{v0} → ~{v1} tokens · ventana de compactación {v2}',
+  [TRIGGER_TEXT.idle_cache_expired]: 'Contexto compactado tras {v3} min de inactividad (caché expirada) · ~{v0} → ~{v1} tokens · ventana de compactación {v2}',
+  [TRIGGER_TEXT.hard]: 'Contexto compactado en el límite duro · ~{v0} → ~{v1} tokens · ventana de compactación {v2}',
+  [TRIGGER_TEXT.recovery]: 'Contexto compactado para recuperar un rechazo por longitud · ~{v0} → ~{v1} tokens',
+  [TRIGGER_TEXT.manual]: 'Contexto compactado a pedido · ~{v0} → ~{v1} tokens',
+});
+export function compactionNotice(event) {
+  const template = TRIGGER_TEXT[event.compaction_trigger]; if (!template) return null;
+  return t(template, { v0: kilo(event.before_tokens), v1: kilo(event.after_tokens), v2: kilo(event.compaction?.compaction_window), v3: Math.round((event.compaction?.idle_ms || 0) / 60000) });
+}