@milpa/comal 0.1.0 → 0.1.1

package/src/cloud-client.mjs

@@ -8,17 +8,59 @@ import { networkFetch } from '../backend/verifier/transport.mjs';
 
 const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
 const defaultOrigin='https://comal.milpahq.com';
-export function cloudOrigin(value=defaultOrigin,env=process.env){const url=new URL(value);if(url.username||url.password||url.pathname!=='/'||url.search||url.hash)throw Error('Comal Cloud requiere un origen sin ruta ni credenciales.');if(url.protocol!=='https:'&&!(env.COMAL_ENV==='test'&&url.protocol==='http:'&&['localhost','127.0.0.1','[::1]','comal.localhost'].includes(url.hostname)))throw Error('Comal Cloud requiere HTTPS.');return url.origin;}
+export function cloudOrigin(value=defaultOrigin,env=process.env){const url=new URL(value);if(url.username||url.password||url.pathname!=='/'||url.search||url.hash)throw Error('Comal Cloud requires an origin without a path or credentials.');if(url.protocol!=='https:'&&!(env.COMAL_ENV==='test'&&url.protocol==='http:'&&['localhost','127.0.0.1','[::1]','comal.localhost'].includes(url.hostname)))throw Error('Comal Cloud requires HTTPS.');return url.origin;}
 export class CloudClient {
   constructor({env=process.env,file,origin,fetcher=networkFetch}={}){this.env=env;this.file=file||env.COMAL_CLOUD_CONFIG||path.join(env.XDG_CONFIG_HOME||path.join(os.homedir(),'.config'),'comal','cloud','credentials.json');this.explicitOrigin=origin||env.COMAL_CLOUD_ORIGIN;this.fetcher=fetcher;}
-  async credentials(){try{const stat=await lstat(this.file);if(!stat.isFile()||stat.isSymbolicLink()||(stat.mode&0o077)!==0||process.getuid&&stat.uid!==process.getuid())throw Error('Las credenciales de Comal deben ser un archivo privado (0600) de tu usuario.');const handle=await open(this.file,constants.O_RDONLY|constants.O_NOFOLLOW);let value;try{const current=await handle.stat();if(current.ino!==stat.ino||current.dev!==stat.dev||current.size>16384)throw Error('El archivo de credenciales cambió o es demasiado grande.');value=JSON.parse(await handle.readFile('utf8'));}finally{await handle.close();}const origin=cloudOrigin(value.origin,this.env);if(this.explicitOrigin&&cloudOrigin(this.explicitOrigin,this.env)!==origin)throw Error('El origen solicitado no coincide con la sesión guardada de Comal. Inicia sesión en ese origen.');if(typeof value.token!=='string'||!/^[A-Za-z0-9_-]{43}$/.test(value.token))throw Error('Credencial de Comal inválida. Vuelve a iniciar sesión.');return{...value,origin};}catch(error){if(error.code==='ENOENT')return null;throw error;}}
-  async save(value){const directory=path.dirname(this.file);await mkdir(directory,{recursive:true,mode:0o700});const stat=await lstat(directory);if(!stat.isDirectory()||stat.isSymbolicLink()||(stat.mode&0o077)!==0)throw Error('El directorio de credenciales de Comal debe ser privado (0700).');const temp=path.join(directory,'.cloud-'+randomBytes(12).toString('hex'));try{await writeFile(temp,JSON.stringify(value)+'\n',{mode:0o600,flag:'wx'});await rename(temp,this.file);}finally{await unlink(temp).catch(error=>{if(error.code!=='ENOENT')throw error;});}}
-  async request(origin,operation,input={},token,signal){const networkOrigin=this.env.COMAL_CLOUD_NETWORK_ORIGIN;if(networkOrigin&&this.env.COMAL_ENV!=='test')throw Error('El transporte de laboratorio de Comal está desactivado en producción.');const response=await this.fetcher(origin+'/api/operations/'+encodeURIComponent(operation),{networkOrigin,method:'POST',headers:{'Content-Type':'application/json',...(token?{Authorization:'Bearer '+token}:{})},body:JSON.stringify(input),signal:signal?AbortSignal.any([signal,AbortSignal.timeout(30000)]):AbortSignal.timeout(30000),maxBytes:2097152});if(response.headers.get('content-length')>2097152)throw Error('Respuesta de Comal demasiado grande.');const reader=response.body?.getReader();let length=0,parts=[];if(reader){try{for(;;){const{done,value}=await reader.read();if(done)break;length+=value.byteLength;if(length>2097152){await reader.cancel();throw Error('Respuesta de Comal demasiado grande.');}parts.push(Buffer.from(value));}}finally{reader.releaseLock();}}let body;try{body=JSON.parse(Buffer.concat(parts).toString('utf8'));}catch{throw Error('Comal devolvió una respuesta inválida (HTTP '+response.status+').');}if(!response.ok||!body.ok){const error=Error((body.error?.code||'CLOUD_HTTP')+': '+(body.error?.message||'HTTP '+response.status));error.code=body.error?.code;error.status=response.status;throw error;}return body.result;}
-  async invoke(operation,input={},options={}){const credential=await this.credentials();if(!credential)throw Error('Conecta tu cuenta con comal cloud login.');if(options.expectedAccount&&(credential.origin!==options.expectedAccount.origin||credential.user_id!==options.expectedAccount.user_id))throw Error('La cuenta de Comal cambió durante la publicación. Revisa el destino y vuelve a publicar.');if(credential.expires_at<=Date.now()/1000)throw Error('Tu sesión de Comal expiró. Usa comal cloud login.');return this.request(credential.origin,operation,input,credential.token,options.signal);}
+  async credentials(){try{const stat=await lstat(this.file);if(!stat.isFile()||stat.isSymbolicLink()||(stat.mode&0o077)!==0||process.getuid&&stat.uid!==process.getuid())throw Error('Comal credentials must be a private file (0600) owned by your user.');const handle=await open(this.file,constants.O_RDONLY|constants.O_NOFOLLOW);let value;try{const current=await handle.stat();if(current.ino!==stat.ino||current.dev!==stat.dev||current.size>16384)throw Error('The credential file changed or is too large.');value=JSON.parse(await handle.readFile('utf8'));}finally{await handle.close();}const origin=cloudOrigin(value.origin,this.env);if(this.explicitOrigin&&cloudOrigin(this.explicitOrigin,this.env)!==origin)throw Error('The requested origin does not match the saved Comal session. Log in to that origin.');if(typeof value.token!=='string'||!/^[A-Za-z0-9_-]{43}$/.test(value.token))throw Error('Invalid Comal credential. Log in again.');return{...value,origin};}catch(error){if(error.code==='ENOENT')return null;throw error;}}
+  async save(value){const directory=path.dirname(this.file);await mkdir(directory,{recursive:true,mode:0o700});const stat=await lstat(directory);if(!stat.isDirectory()||stat.isSymbolicLink()||(stat.mode&0o077)!==0)throw Error('The Comal credential directory must be private (0700).');const temp=path.join(directory,'.cloud-'+randomBytes(12).toString('hex'));try{await writeFile(temp,JSON.stringify(value)+'\n',{mode:0o600,flag:'wx'});await rename(temp,this.file);}finally{await unlink(temp).catch(error=>{if(error.code!=='ENOENT')throw error;});}}
+  async request(origin,operation,input={},token,signal){const networkOrigin=this.env.COMAL_CLOUD_NETWORK_ORIGIN;if(networkOrigin&&this.env.COMAL_ENV!=='test')throw Error('Comal laboratory transport is disabled in production.');const response=await this.fetcher(origin+'/api/operations/'+encodeURIComponent(operation),{networkOrigin,method:'POST',headers:{'Content-Type':'application/json',...(token?{Authorization:'Bearer '+token}:{})},body:JSON.stringify(input),signal:signal?AbortSignal.any([signal,AbortSignal.timeout(operation==='media.upload'?90000:30000)]):AbortSignal.timeout(operation==='media.upload'?90000:30000),maxBytes:2097152});if(response.headers.get('content-length')>2097152)throw Error('Comal response is too large.');const reader=response.body?.getReader();let length=0,parts=[];if(reader){try{for(;;){const{done,value}=await reader.read();if(done)break;length+=value.byteLength;if(length>2097152){await reader.cancel();throw Error('Comal response is too large.');}parts.push(Buffer.from(value));}}finally{reader.releaseLock();}}let body;try{body=JSON.parse(Buffer.concat(parts).toString('utf8'));}catch{throw Error('Comal returned an invalid response (HTTP '+response.status+').');}if(!response.ok||!body.ok){const error=Error((body.error?.code||'CLOUD_HTTP')+': '+(body.error?.message||'HTTP '+response.status));error.code=body.error?.code;error.status=response.status;throw error;}return body.result;}
+  async invoke(operation,input={},options={}){const credential=await this.credentials();if(!credential)throw Error('Connect your account with comal cloud login.');if(options.expectedAccount&&(credential.origin!==options.expectedAccount.origin||credential.user_id!==options.expectedAccount.user_id))throw Error('The Comal account changed during publication. Check the destination and publish again.');if(credential.expires_at<=Date.now()/1000)throw Error('Your Comal session expired. Use comal cloud login.');return this.request(credential.origin,operation,input,credential.token,options.signal);}
   async status(options={}){const credential=await this.credentials();if(!credential)return{authenticated:false,origin:cloudOrigin(this.explicitOrigin||defaultOrigin,this.env)};const result=await this.invoke('account.inspect',{},options);const workspaces=await this.invoke('workspaces.list',{},options);return{authenticated:true,origin:credential.origin,user:result.user,identities:result.identities,expires_at:credential.expires_at,workspaces:workspaces.workspaces};}
-  async login({label=os.hostname()+' · Comal CLI',signal,onCode=()=>{}}={}){const origin=cloudOrigin(this.explicitOrigin||defaultOrigin,this.env);const proof=randomBytes(32).toString('base64url');const flow=await this.request(origin,'device.begin',{label:label.slice(0,80),code_challenge:createHash('sha256').update(proof).digest('base64url')},null,signal);if(!/^[A-Za-z0-9_-]{43}$/.test(flow.device_code)||!Number.isSafeInteger(flow.expires_in)||flow.expires_in<1||flow.expires_in>600)throw Error('Contrato de conexión CLI inválido.');const uri=new URL(flow.verification_uri_complete);if(uri.origin!==origin||uri.pathname!=='/connect')throw Error('Comal devolvió un destino de autenticación diferente.');await onCode({verification_uri:flow.verification_uri,verification_uri_complete:flow.verification_uri_complete,user_code:flow.user_code,expires_in:flow.expires_in});const deadline=Date.now()+flow.expires_in*1000;let interval=5;while(Date.now()<deadline){await delay(interval*1000,null,{signal});const result=await this.request(origin,'device.exchange',{device_code:flow.device_code,code_verifier:proof},null,signal);if(result.status==='authorization_pending')continue;if(result.status==='slow_down'){interval=Math.min(30,Math.max(interval+5,result.interval||10));continue;}if(result.status==='access_denied')throw Error('La conexión fue denegada en Comal.');if(result.status!=='authenticated'||!/^[A-Za-z0-9_-]{43}$/.test(result.access_token)||!Number.isSafeInteger(result.expires_at))throw Error('Comal devolvió un intercambio inválido.');await this.save({version:1,origin,token:result.access_token,user_id:result.user_id,expires_at:result.expires_at});return this.status({signal});}throw Error('El código de Comal expiró. Inicia la conexión de nuevo.');}
+  async login({label=os.hostname()+' · Comal CLI',signal,onCode=()=>{}}={}){const origin=cloudOrigin(this.explicitOrigin||defaultOrigin,this.env);const proof=randomBytes(32).toString('base64url');const flow=await this.request(origin,'device.begin',{label:label.slice(0,80),code_challenge:createHash('sha256').update(proof).digest('base64url')},null,signal);if(!/^[A-Za-z0-9_-]{43}$/.test(flow.device_code)||!Number.isSafeInteger(flow.expires_in)||flow.expires_in<1||flow.expires_in>600)throw Error('Invalid CLI connection contract.');const uri=new URL(flow.verification_uri_complete);if(uri.origin!==origin||uri.pathname!=='/connect')throw Error('Comal returned a different authentication destination.');await onCode({verification_uri:flow.verification_uri,verification_uri_complete:flow.verification_uri_complete,user_code:flow.user_code,expires_in:flow.expires_in});const deadline=Date.now()+flow.expires_in*1000;let interval=5;while(Date.now()<deadline){await delay(interval*1000,null,{signal});const result=await this.request(origin,'device.exchange',{device_code:flow.device_code,code_verifier:proof},null,signal);if(result.status==='authorization_pending')continue;if(result.status==='slow_down'){interval=Math.min(30,Math.max(interval+5,result.interval||10));continue;}if(result.status==='access_denied')throw Error('The connection was denied in Comal.');if(result.status!=='authenticated'||!/^[A-Za-z0-9_-]{43}$/.test(result.access_token)||!Number.isSafeInteger(result.expires_at))throw Error('Comal returned an invalid token exchange.');await this.save({version:1,origin,token:result.access_token,user_id:result.user_id,expires_at:result.expires_at});return this.status({signal});}throw Error('The Comal code expired. Start the connection again.');}
   async logout({signal}={}){const credential=await this.credentials();if(!credential)return{revoked:false,local_session:false};try{await this.request(credential.origin,'account.logout',{},credential.token,signal);}catch(error){if(error.code!=='AUTH_INVALID')throw error;}await unlink(this.file);return{revoked:true,local_session:false,origin:credential.origin};}
 }
 const staticTypes=new Set(['html','htm','js','mjs','css','json','map','txt','svg','png','jpg','jpeg','webp','gif','ico','woff','woff2']);
-export async function bundleArtifact(directory,{workspaceRoot}={}){const base=await realpath(directory);if(workspaceRoot){const workspace=await realpath(workspaceRoot);if(base!==workspace&&!base.startsWith(workspace+path.sep))throw Error('La publicación debe estar dentro del workspace de esta sesión.');}const files=[];let bytes=0;async function visit(relative=''){const entries=await readdir(path.join(base,relative),{withFileTypes:true});entries.sort((a,b)=>a.name.localeCompare(b.name,'en'));for(const entry of entries){if(entry.name.startsWith('.'))continue;const name=relative?relative+'/'+entry.name:entry.name;const full=path.join(base,name);if(entry.isSymbolicLink())throw Error('No se publican enlaces simbólicos: '+name);if(entry.isDirectory()){await visit(name);continue;}if(!entry.isFile()||!staticTypes.has(path.extname(entry.name).slice(1).toLowerCase()))throw Error('El directorio debe contener sólo archivos web estáticos: '+name);if(files.length>=256)throw Error('El artifact excede 256 archivos.');const current=await realpath(full);if(!current.startsWith(base+path.sep))throw Error('Un archivo sale del directorio de publicación.');const handle=await open(full,constants.O_RDONLY|constants.O_NOFOLLOW);try{const stat=await handle.stat();if(!stat.isFile()||bytes+stat.size>8388608)throw Error('El artifact excede 8 MiB.');const content=await handle.readFile();bytes+=content.length;if(bytes>8388608)throw Error('El artifact excede 8 MiB.');files.push({path:name,content_base64:content.toString('base64'),sha256:hash(content)});}finally{await handle.close();}}}await visit();if(!files.length)throw Error('El directorio de publicación está vacío.');return files;}
-export async function publishArtifact(client,{directory,workspaceRoot,...metadata},options={}){const files=await bundleArtifact(directory,{workspaceRoot});const account=await client.credentials();if(!account)throw Error('Conecta tu cuenta con comal cloud login.');const input={...metadata,files};input.request_id='comal_'+hash(JSON.stringify({origin:account.origin,user:account.user_id,input}));return client.invoke('artifacts.publish',input,{...options,expectedAccount:{origin:account.origin,user_id:account.user_id}});}
+export async function bundleArtifact(directory,{workspaceRoot,onVideo}={}){const base=await realpath(directory);if(workspaceRoot){const workspace=await realpath(workspaceRoot);if(base!==workspace&&!base.startsWith(workspace+path.sep))throw Error('Publication must stay within this session workspace.');}const files=[];let bytes=0,videos=0;async function visit(relative=''){const entries=await readdir(path.join(base,relative),{withFileTypes:true});entries.sort((a,b)=>a.name.localeCompare(b.name,'en'));for(const entry of entries){if(entry.name.startsWith('.'))continue;const name=relative?relative+'/'+entry.name:entry.name;const full=path.join(base,name);if(Buffer.byteLength(name)>512||/[\\%\x00-\x20\x7f?#]/.test(name)||name.split('/').some(part=>!part||part.startsWith('.')))throw Error('Published paths must be normalized relative paths without spaces or reserved characters: '+name);if(entry.isSymbolicLink())throw Error('Symbolic links cannot be published: '+name);if(entry.isDirectory()){await visit(name);continue;}if(entry.isFile()&&path.extname(entry.name).toLowerCase()==='.mp4'&&onVideo){if(++videos>4)throw Error('An artifact supports up to four videos.');await onVideo(full,name);continue;}if(!entry.isFile()||!staticTypes.has(path.extname(entry.name).slice(1).toLowerCase()))throw Error('The directory must contain only static web files: '+name);if(files.length>=256)throw Error('The artifact exceeds 256 files.');const current=await realpath(full);if(!current.startsWith(base+path.sep))throw Error('A file is outside the publication directory.');const handle=await open(full,constants.O_RDONLY|constants.O_NOFOLLOW);try{const stat=await handle.stat();if(!stat.isFile()||bytes+stat.size>8388608)throw Error('The artifact exceeds 8 MiB.');const content=await handle.readFile();bytes+=content.length;if(bytes>8388608)throw Error('The artifact exceeds 8 MiB.');files.push({path:name,content_base64:content.toString('base64'),sha256:hash(content)});}finally{await handle.close();}}}await visit();if(!files.length&&!videos)throw Error('The publication directory is empty.');return files;}
+async function captureArtifactVideo(file,workspaceRoot){
+  const absolute=path.resolve(file),base=await realpath(workspaceRoot);const actual=await realpath(absolute);
+  if(!actual.startsWith(base+path.sep))throw Error('Video must stay inside the session workspace.');
+  if(path.extname(absolute).toLowerCase()!=='.mp4')throw Error('Only source MP4 videos are supported.');
+  const inspected=await lstat(actual,{bigint:true});
+  const handle=await open(actual,constants.O_RDONLY|constants.O_NOFOLLOW|constants.O_NONBLOCK);
+  let content;
+  try{const before=await handle.stat({bigint:true});if(before.ino!==inspected.ino||before.dev!==inspected.dev||!before.isFile()||before.size<16n||before.size>8388608n)throw Error('A source MP4 of at most 8 MiB is required.');
+    const buffer=Buffer.alloc(Number(before.size)+1);let length=0;while(length<buffer.length){const read=await handle.read(buffer,length,buffer.length-length,null);if(!read.bytesRead)break;length+=read.bytesRead;}
+    const after=await handle.stat({bigint:true});if(length!==Number(before.size)||before.ino!==after.ino||before.dev!==after.dev||before.mtimeNs!==after.mtimeNs||before.ctimeNs!==after.ctimeNs)throw Error('Video changed while being captured.');
+    if(await realpath(absolute)!==actual)throw Error('Video path changed during capture.');const current=await lstat(actual,{bigint:true});if(current.ino!==before.ino||current.dev!==before.dev)throw Error('Video path changed during capture.');
+    content=buffer.subarray(0,length);if(content.subarray(4,8).toString()!=='ftyp')throw Error('The selected file is not an MP4.');
+  }finally{await handle.close();}
+  return content;
+}
+async function sendArtifactVideo(client,content,{workspace_id,session_id},options={}){
+  const account=await client.credentials();if(!account)throw Error('Connect your account with /cloud login.');
+  if(options.expectedAccount&&(options.expectedAccount.origin!==account.origin||options.expectedAccount.user_id!==account.user_id))throw Error('The Comal account changed before video upload.');
+  const authority={...options,expectedAccount:{origin:account.origin,user_id:account.user_id}};
+  let result=await client.invoke('media.upload',{workspace_id,session_id,sha256:hash(content),content_base64:content.toString('base64')},authority);
+  const deadline=Date.now()+90000;
+  while(result.status!=='ready'&&Date.now()<deadline){if(result.status==='failed')throw Error('Gumlet could not process this video. Inspect media '+result.id+'.');await delay(2000,null,{signal:options.signal});result=await client.invoke('media.inspect',{media_id:result.id},authority);}
+  if(result.status!=='ready')throw Error('Video '+result.id+' is still processing. Retry the same source to reconcile it without another upload.');
+  return result;
+}
+export async function uploadArtifactVideo(client,{file,workspaceRoot,...metadata},options={}){return sendArtifactVideo(client,await captureArtifactVideo(file,workspaceRoot),metadata,options);}
+export async function publishArtifact(client,{directory,workspaceRoot=directory,...metadata},options={}){
+  const account=await client.credentials();if(!account)throw Error('Connect your account with comal cloud login.');
+  const authority={...options,expectedAccount:{origin:account.origin,user_id:account.user_id}},media=[],videos=[];
+  const files=await bundleArtifact(directory,{workspaceRoot,onVideo:async(file,name)=>{
+    videos.push({content:await captureArtifactVideo(file,workspaceRoot),path:name.slice(0,-4)+'.player.html'});
+  }});
+  if(metadata.entrypoint?.toLowerCase().endsWith('.mp4'))metadata.entrypoint=metadata.entrypoint.slice(0,-4)+'.player.html';
+  if(videos.length){
+    const paths=new Set(files.map(file=>file.path));for(const video of videos){if(paths.has(video.path))throw Error('Generated video player conflicts with another published path: '+video.path);paths.add(video.path);}
+    if(paths.size>256||files.reduce((sum,file)=>sum+Buffer.byteLength(file.content_base64,'base64'),0)+videos.length*2048>8388608)throw Error('The artifact exceeds its static budget including generated video players.');
+    if(!paths.has(metadata.entrypoint)||!/[.]html?$/i.test(metadata.entrypoint))throw Error('The entrypoint must exist as HTML or a selected MP4; use clip.mp4 for its generated player.');
+  }
+  for(const capture of videos){const video=await sendArtifactVideo(client,capture.content,metadata,authority);media.push({path:capture.path,media_id:video.id});}
+  const input={...metadata,files,...(media.length?{media}:{})};
+  input.request_id='comal_'+hash(JSON.stringify({origin:account.origin,user:account.user_id,input}));
+  return client.invoke('artifacts.publish',input,authority);
+}

package/src/code-run-worker.mjs

@@ -0,0 +1,70 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { getQuickJS } from 'quickjs-emscripten';
+
+const { code, catalogue, limits } = 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;
+runtime.setInterruptHandler(() => performance.now() - activeStart > cpuLeft);
+const vm = runtime.newContext(), pending = new Map(), output = [];
+const allowedNames = new Set(catalogue.map(row => row.name));
+const enter = fn => { activeStart = performance.now(); try { return fn(); } finally { cpuLeft -= performance.now() - activeStart; } };
+const expose = (name, fn) => { const handle = vm.newFunction(name, fn); vm.setProp(vm.global, name, handle); handle.dispose(); };
+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);
+  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 });
+}
+expose('__emit', value => {
+  const text = vm.getString(value); emitted += Buffer.byteLength(text) + (output.length ? 1 : 0);
+  if (emitted > limits.outputBytes) throw Object.assign(new Error('CodeRun output byte limit exceeded.'), {code:'CODE_RUN_OUTPUT_LIMIT'});
+  const item = JSON.parse(text); output.push(item); parentPort.postMessage({type:'output',value:item});
+});
+expose('__call', (nameHandle, argsHandle) => {
+  const name = vm.getString(nameHandle), raw = vm.getString(argsHandle);
+  // Enforce before IPC too: a VM loop cannot flood the parent with queued RPCs.
+  if (++sequence > limits.calls || pending.size >= limits.concurrency) throw new Error('CodeRun tool call/concurrency limit exceeded.');
+  if (!allowedNames.has(name)) throw new Error('Tool is outside the read-only caller catalogue.');
+  if (Buffer.byteLength(raw) > limits.argumentBytes) throw new Error('CodeRun tool argument byte limit exceeded.');
+  const deferred = vm.newPromise(), id = sequence; pending.set(id, deferred);
+  parentPort.postMessage({ type: 'call', id, name, args: JSON.parse(raw) });
+  return deferred.handle;
+});
+let script;
+try {
+  // 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)});
+    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 describeTool(name) { return ALL_TOOLS.find(t => t.name === name) || null; }
+    Object.freeze(tools); Object.freeze(searchTools); Object.freeze(describeTool);
+  `))).dispose();
+  script = vm.unwrapResult(enter(() => vm.evalCode(`(async () => { "use strict";\n${code}\n})().then(value => { if(value !== undefined) text(value); })`, 'comal-code-run.js')));
+  pump();
+} catch (error) { fail(error); }
+function pump() {
+  if (stopped) return;
+  try {
+    const jobs = enter(() => runtime.executePendingJobs());
+    if (jobs.error) { const error = vm.dump(jobs.error); jobs.error.dispose(); throw error; }
+    const state = vm.getPromiseState(script);
+    if (state.type === 'fulfilled') { state.value.dispose(); stopped = true; parentPort.postMessage({type:'done', output}); }
+    else if (state.type === 'rejected') { const error = vm.dump(state.error); state.error.dispose(); throw error; }
+    else if (!pending.size) throw new Error('CodeRun promise cannot make progress without an awaited tool.');
+  } catch (error) { fail(error); }
+}
+parentPort.on('message', message => {
+  if (stopped || message.type !== 'result') return;
+  const deferred = pending.get(message.id); if (!deferred) return; pending.delete(message.id);
+  try {
+    const handle = message.ok ? vm.newString(message.value) : jsonHandle({name:'Error', message:message.value, code:message.code || 'CODE_RUN_TOOL'});
+    if (message.ok) deferred.resolve(handle); else deferred.reject(handle);
+    handle.dispose(); deferred.dispose(); pump();
+  } catch (error) { fail(error); }
+});

package/src/code-run.mjs

@@ -0,0 +1,97 @@
+import { Worker } from 'node:worker_threads';
+import { randomUUID } from 'node:crypto';
+import { digest } from './operations.mjs';
+import { chromeLabObservation } from './read-only-check.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 };
+const failure = (code, message) => Object.assign(new Error(message), { code });
+const activeRuns = new Set();
+export const CODE_RUN_MAX_WORKERS = 2;
+export const codeRunEligible = row => Boolean(row && row.name !== 'CodeRun' && row.permission === row.name && !row.steps && row.audience !== 'human' && ['none', 'read'].includes(row.effects?.workspace) && ['none', 'read'].includes(row.effects?.external) && (row.effects?.process === 'none' || row.effects?.process === 'spawn' && row.origin?.plugin === 'chrome-lab' && chromeLabObservation(row.name)) && row.effects?.authority === 'none');
+export const codeRunDefinition = Object.freeze({
+  name: 'CodeRun', description: 'Experimental read-only JavaScript composition in an isolated QuickJS VM. Use searchTools/describeTool for the currently visible tool catalogue, tools.call(name,args) or tools[name](args) to call tools and text(value) or return value to emit selected observations. No filesystem, network, Node APIs, timers, persistence or nested CodeRun. Every tool call retains its own House judgment and receipt. Effects completed before an error remain recorded; never automatically replay the script.',
+  input_schema: { type: 'object', properties: { code: { type: 'string', minLength: 1, maxLength: 32768 } }, required: ['code'], additionalProperties: false },
+  effects: { workspace: 'read', external: 'read', process: 'spawn', authority: 'none' }, steps: true, permission: 'CodeRun', run: runCode,
+});
+
+// Caller supplies a captured, actor-scoped catalogue AND its matching House invoke.
+// No tool code, host objects, credentials or runtime resources cross the VM boundary.
+export async function runCode({ code }, options = {}) {
+  const { invoke, recordWork, signal } = options;
+  if (typeof invoke !== 'function' || typeof recordWork !== 'function' || !Array.isArray(options.catalogue)) throw failure('CODE_RUN_HOST', 'CodeRun requires the caller catalogue, governed invoke and durable recorder.');
+  const limits = { ...CODE_RUN_LIMITS };
+  for (const [key, value] of Object.entries(options.limits || {})) {
+    if (!(key in limits) || !Number.isSafeInteger(value) || value < 1 || value > ceiling[key]) throw failure('CODE_RUN_LIMIT', `Invalid CodeRun limit: ${key}.`);
+    limits[key] = value;
+  }
+  if (typeof code !== 'string' || !code.trim() || Buffer.byteLength(code) > limits.sourceBytes) throw failure('CODE_RUN_SOURCE_LIMIT', 'CodeRun source exceeds its byte limit or is empty.');
+  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();
+  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; }
+  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: [] });
+    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);
+      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 === '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 (++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 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 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.');
+            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); }
+        })();
+        pending.set(id, work); work.finally(() => pending.delete(id));
+      });
+    });
+  } catch (error) { runError = error; }
+  finally {
+    closed = true; clearTimeout(timer); signal?.removeEventListener('abort', abort);
+    controller.abort(runError || failure('CODE_RUN_FINISHED', 'CodeRun script finished; unawaited calls are cancelled.'));
+    await worker?.terminate().catch(() => {});
+    if (pending.size) {
+      let cleanupTimer;
+      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);
+  }
+  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 };
+  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 });
+}

package/src/codex-provider.mjs

@@ -19,16 +19,16 @@ function responseFailure(value, httpStatus) {
   const field = (value, pattern = /^[A-Za-z0-9_.:-]{1,100}$/) => typeof value === 'string' && pattern.test(value) ? value : undefined;
   const metadata = Object.fromEntries(Object.entries({ code: field(upstream?.code), type: field(upstream?.type), param: field(upstream?.param, /^[A-Za-z0-9_.\[\]-]{1,160}$/) }).filter(([, value]) => value !== undefined));
   const reason = field(response?.incomplete_details?.reason);
-  let code = 'CODEX_RESPONSE_INCOMPLETE', message = 'Respuesta Codex incompleta';
+  let code = 'CODEX_RESPONSE_INCOMPLETE', message = 'Incomplete Codex response';
   if (reason === 'max_output_tokens') code = 'OUTPUT_LENGTH';
   else if (metadata.code === 'context_length_exceeded') code = 'CONTEXT_LENGTH';
-  else if (metadata.code === 'invalid_function_parameters') { code = 'CODEX_TOOL_SCHEMA_INVALID'; message = 'Codex rechazó el esquema de herramientas'; }
-  else if (metadata.type === 'invalid_request_error' || metadata.code === 'invalid_request_error') { code = 'CODEX_REQUEST_REJECTED'; message = 'Codex rechazó la petición'; }
-  else if (upstream) { code = 'CODEX_RESPONSE_FAILED'; message = 'Codex devolvió un error'; }
-  if (httpStatus === 401) { code = 'PROVIDER_AUTH_REQUIRED'; message = 'Codex requiere login'; }
+  else if (metadata.code === 'invalid_function_parameters') { code = 'CODEX_TOOL_SCHEMA_INVALID'; message = 'Codex rejected the tool schema'; }
+  else if (metadata.type === 'invalid_request_error' || metadata.code === 'invalid_request_error') { code = 'CODEX_REQUEST_REJECTED'; message = 'Codex rejected the request'; }
+  else if (upstream) { code = 'CODEX_RESPONSE_FAILED'; message = 'Codex returned an error'; }
+  if (httpStatus === 401) { code = 'PROVIDER_AUTH_REQUIRED'; message = 'Codex requires login'; }
   else if (httpStatus && code === 'CODEX_RESPONSE_INCOMPLETE') { code = 'CODEX_HTTP_ERROR'; message = `Codex HTTP ${httpStatus}`; }
   const diagnostic = [metadata.code, metadata.param, reason].filter(Boolean).join('; ');
-  return Object.assign(fail(`${message}${diagnostic ? ` (${diagnostic})` : ''}; no se ejecutaron herramientas de esta respuesta.`, code), {
+  return Object.assign(fail(`${message}${diagnostic ? ` (${diagnostic})` : ''}; no tools from this response were executed.`, code), {
     usage_accounting:normalizeUsage('codex',response?.usage),
     details: { provider: 'codex', upstream: metadata, ...(reason ? { reason } : {}), ...(httpStatus ? { http_status: httpStatus } : {}), tools_executed: false,
       ...(['CODEX_TOOL_SCHEMA_INVALID', 'CODEX_REQUEST_REJECTED'].includes(code) ? { retryable: false } : {}) }
@@ -38,17 +38,17 @@ function responseFailure(value, httpStatus) {
 // Some Codex responses omit Content-Type despite carrying SSE. Inspect a
 // bounded prefix, then replay every byte: framing must not depend on a header.
 async function responseFormat(body) {
-  if (!body) throw fail('Codex devolvió un cuerpo vacío.', 'CODEX_RESPONSE_INCOMPLETE');
+  if (!body) throw fail('Codex returned an empty body.', 'CODEX_RESPONSE_INCOMPLETE');
   const reader=body.getReader(),chunks=[],decoder=new TextDecoder();let prefix='',size=0,format;
   try {
     while(!format){
       const{done,value}=await reader.read();
-      if(done)throw fail('Codex devolvió un cuerpo vacío o incompleto.', 'CODEX_RESPONSE_INCOMPLETE');
+      if(done)throw fail('Codex returned an empty or incomplete body.', 'CODEX_RESPONSE_INCOMPLETE');
       chunks.push(value);const head=value.subarray(0,Math.max(0,4096-size));size+=head.byteLength;
       prefix+=decoder.decode(head,{stream:true});const start=prefix.trimStart();
       if(start.startsWith('{'))format='json';
       else if(start.startsWith(':') || /^(?:event|data|id|retry):/.test(start))format='sse';
-      else if(size>=4096 || start && !['event:','data:','id:','retry:'].some(field=>field.startsWith(start)))throw fail('Formato de respuesta Codex desconocido; no se ejecutaron herramientas.');
+      else if(size>=4096 || start && !['event:','data:','id:','retry:'].some(field=>field.startsWith(start)))throw fail('Unknown Codex response format; no tools were executed.');
     }
   }catch(error){await reader.cancel().catch(()=>{});reader.releaseLock();throw error;}
   return{format,body:{async *[Symbol.asyncIterator](){
@@ -59,8 +59,8 @@ async function responseFormat(body) {
 
 async function responseJSON(body, maxBytes = 8 * 1024 * 1024) {
   const decoder=new TextDecoder();let text='',size=0;
-  for await(const chunk of body){size+=chunk.byteLength;if(size>maxBytes)throw fail('La respuesta Codex excedió el límite de bytes.');text+=decoder.decode(chunk,{stream:true});}
-  try{return JSON.parse(text+decoder.decode());}catch{throw fail('Codex devolvió JSON inválido; no se ejecutaron herramientas.');}
+  for await(const chunk of body){size+=chunk.byteLength;if(size>maxBytes)throw fail('The Codex response exceeded its byte limit.');text+=decoder.decode(chunk,{stream:true});}
+  try{return JSON.parse(text+decoder.decode());}catch{throw fail('Codex returned invalid JSON; no tools were executed.');}
 }
 
 export function toCodexInput(messages) {
@@ -79,7 +79,7 @@ export function toCodexInput(messages) {
       const content = blocks.flatMap(block => {
         if (block.type === 'text') return [{ type: 'input_text', text: block.text }];
         if (block.type === 'image' && block.source?.type === 'base64') return [{ type: 'input_image', image_url: `data:${block.source.media_type};base64,${block.source.data}` }];
-        if (['video', 'media', 'image_reference'].includes(block.type)) throw fail('Multimedia no admitida o referencia sin resolver.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+        if (['video', 'media', 'image_reference'].includes(block.type)) throw fail('Unsupported media or unresolved reference.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
         return [];
       });
       if (content.length) input.push({ role: 'user', content });
@@ -98,13 +98,13 @@ function normalized(response) {
         else if (block.type === 'refusal') content.push({ type: 'text', text: block.refusal });
       }
     } else if (item.type === 'function_call') {
-      if (!id(item.call_id) || ids.has(item.call_id) || !id(item.name) || typeof item.arguments !== 'string') throw fail('Llamada Codex inválida.');
+      if (!id(item.call_id) || ids.has(item.call_id) || !id(item.name) || typeof item.arguments !== 'string') throw fail('Invalid Codex tool call.');
       let args; try { args = JSON.parse(item.arguments); } catch { throw fail('Argumentos Codex incompletos.', 'TOOL_ARGUMENTS_INVALID'); }
       if (!args || typeof args !== 'object' || Array.isArray(args)) throw fail('Argumentos Codex deben ser objeto.', 'TOOL_ARGUMENTS_INVALID');
       ids.add(item.call_id); content.push({ type: 'tool_use', id: item.call_id, name: item.name, input: args });
     } else if (item.type === 'reasoning') content.push({ type: 'openai_reasoning', text: (item.summary || []).map(block => block.text || '').join('\n'), codex_item: structuredClone(item) });
   }
-  if (!content.length) throw fail('Codex devolvió una respuesta vacía.');
+  if (!content.length) throw fail('Codex returned an empty response.');
   return { role: 'assistant', content, stop_reason: ids.size ? 'tool_use' : 'end_turn', usage_accounting:normalizeUsage('codex',response.usage), usage: {
     input_tokens: response.usage?.input_tokens || 0, output_tokens: response.usage?.output_tokens || 0,
     ...(response.usage?.input_tokens_details?.cached_tokens ? { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens } : {}) } };
@@ -113,14 +113,14 @@ function normalized(response) {
 // Subscription bearer tokens go only to the fixed Codex backend, never api.openai.com.
 export class CodexProvider {
   constructor({ authManager, authProvider = 'codex', model, maxTokens = 4096, effort = 'auto', fetchImpl = globalThis.fetch, timeoutMs, idleTimeoutMs, vision, capabilitiesConfigured, profile, ...options } = {}) {
-    if (!authManager || authProvider !== 'codex') throw new Error('CodexProvider requiere AuthManager y authProvider codex.');
+    if (!authManager || authProvider !== 'codex') throw new Error('CodexProvider requires AuthManager and authProvider codex.');
     this.authManager = authManager; this.authProvider = authProvider; this.protocol = 'openai'; this.model = model;
     this.baseURL = 'https://chatgpt.com/backend-api/codex'; this.fetch = fetchImpl; this.maxTokens = maxTokens;
     this.capabilitiesConfigured = { ...profile?.capabilitiesConfigured, ...capabilitiesConfigured };
-    for (const [name, enabled] of Object.entries(this.capabilitiesConfigured)) if (!['text', 'tools', 'thinking', 'vision', 'video', 'web_search'].includes(name) || typeof enabled !== 'boolean') throw fail('Configuración de capacidades Codex inválida.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
-    if (this.capabilitiesConfigured.text === false || this.capabilitiesConfigured.video === true || this.capabilitiesConfigured.web_search === true) throw fail('El adaptador Codex requiere texto y no implementa video/web_search nativos.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    for (const [name, enabled] of Object.entries(this.capabilitiesConfigured)) if (!['text', 'tools', 'thinking', 'vision', 'video', 'web_search'].includes(name) || typeof enabled !== 'boolean') throw fail('Invalid Codex capability configuration.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    if (this.capabilitiesConfigured.text === false || this.capabilitiesConfigured.video === true || this.capabilitiesConfigured.web_search === true) throw fail('The Codex adapter requires text and does not implement native video/web_search.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
     this.effort = normalizeEffort(effort); this.vision = vision || (Object.hasOwn(this.capabilitiesConfigured, 'vision') ? this.capabilitiesConfigured.vision ? 'on' : 'off' : 'auto'); this.imageTokens = options.imageTokens || 4096;
-    if (!['auto', 'on', 'off'].includes(this.vision)) throw fail('Visión Codex inválida.');
+    if (!['auto', 'on', 'off'].includes(this.vision)) throw fail('Invalid Codex vision setting.');
     this.configuredCapabilities = this.capabilitiesConfigured;
     if (profile?.name) this.profileName = profile.name;
     Object.assign(this, modelTimingSettings({ timeoutMs, idleTimeoutMs }));
@@ -139,10 +139,10 @@ export class CodexProvider {
   async listModels({ signal } = {}) {
     const timeout = AbortSignal.timeout(15000), response = await this._fetch(`models?client_version=${CODEX_CATALOG_VERSION}`, { signal: signal ? AbortSignal.any([signal, timeout]) : timeout });
     const text = await response.text();
-    if (text.length > 1024 * 1024) throw fail('Catálogo Codex demasiado grande.');
-    let data; try { data = JSON.parse(text); } catch { throw fail('Catálogo Codex inválido.'); }
+    if (text.length > 1024 * 1024) throw fail('Codex catalog is too large.');
+    let data; try { data = JSON.parse(text); } catch { throw fail('Invalid Codex catalog.'); }
     const models = data.models || data.data;
-    if (!Array.isArray(models)) throw fail('Codex no anunció modelos.', 'MODEL_DISCOVERY_UNAVAILABLE');
+    if (!Array.isArray(models)) throw fail('Codex did not advertise models.', 'MODEL_DISCOVERY_UNAVAILABLE');
     this.discoveredModels = models.filter(item => id(item.slug || item.id)).slice(0, 1024);
     return this.discoveredModels.filter(item => item.visibility !== 'hide').map(item => ({ id: item.slug || item.id,
       ...(typeof item.display_name === 'string' ? { display_name: item.display_name.slice(0, 256) } : {}),
@@ -152,7 +152,7 @@ export class CodexProvider {
   }
   async discoverModel({ signal } = {}) {
     if (!this.model) { const models = await this.listModels({ signal }); this.model = models[0]?.id; }
-    if (!this.model) throw fail(`El catálogo Codex no anunció modelos para compatibilidad ${CODEX_CATALOG_VERSION}. Revisa acceso y versión del adaptador; una lista vacía no prueba que tu plan carezca de modelos.`, 'MODEL_DISCOVERY_UNAVAILABLE');
+    if (!this.model) throw fail(`The Codex catalog did not advertise models for compatibility ${CODEX_CATALOG_VERSION}. Check access and adapter version; an empty list does not prove your plan has no models.`, 'MODEL_DISCOVERY_UNAVAILABLE');
     return this.model;
   }
   async discoverModelCapabilities({ signal, force = false } = {}) {
@@ -177,15 +177,15 @@ export class CodexProvider {
   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 }) {
-    if (this.capabilitiesConfigured.tools === false && tools.length) throw fail('El perfil Codex no habilita tools; no se envió la petición.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    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};
     const schemaFrame=compileToolSchemas(tools,{provider:this.protocol,capabilities:{...(this.getCapabilities?.() || {}),...(this.toolSchemaCapabilities?{tool_schema:this.toolSchemaCapabilities}:{})},catalogue:schemaCatalog}); tools=schemaFrame.tools;
-    if (messages.some(message => Array.isArray(message.content) && message.content.some(block => block.type === 'image')) && !(await this.getVisionCapability({ signal })).supported) throw fail('El catálogo Codex no anuncia visión para este modelo.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    if (messages.some(message => Array.isArray(message.content) && message.content.some(block => block.type === 'image')) && !(await this.getVisionCapability({ signal })).supported) throw fail('The Codex catalog does not advertise vision for this model.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
     let reasoning;
     if (this.effort !== 'auto') {
       const state = await this.discoverModelCapabilities({ signal });
-      if (!state.effort.levels.includes(this.effort)) throw fail(`El modelo no anuncia effort ${this.effort}.`, 'MODEL_EFFORT_UNAVAILABLE');
+      if (!state.effort.levels.includes(this.effort)) throw fail(`The model does not advertise effort ${this.effort}.`, 'MODEL_EFFORT_UNAVAILABLE');
       reasoning = { effort: this.effort === 'off' ? 'none' : this.effort };
     }
     // Follow the upstream Codex request shape, which omits max_output_tokens.
@@ -194,7 +194,7 @@ export class CodexProvider {
       include: ['reasoning.encrypted_content'], ...(reasoning ? { reasoning } : {}),
       ...(tools.length ? { tools: tools.map(tool => ({ type: 'function', name: tool.name, description: tool.description, parameters: tool.input_schema })), tool_choice: 'auto', parallel_tool_calls: true } : {}) });
     const account=result=>{result.usage_accounting=bindUsageAccounting(result.usage_accounting,accountingRequest,identity,body); result.schema_diagnostics=schemaFrame.diagnostics;result.schema_manifest=schemaFrame.manifest;return result;};
-    if (Buffer.byteLength(body) > 8 * 1024 * 1024) throw fail('El contexto Codex excede 8 MiB.');
+    if (Buffer.byteLength(body) > 8 * 1024 * 1024) throw fail('The Codex context exceeds 8 MiB.');
     const deadline = modelDeadline({ signal, timeoutMs: this.timeoutMs, idleTimeoutMs: this.idleTimeoutMs, purpose });
     try {
       const response = await this._fetch('responses', { method: 'POST', body, signal: deadline.signal });
@@ -212,7 +212,7 @@ export class CodexProvider {
         onProgress({ text_chars: textChars, reasoning_chars: reasoningChars, tool_argument_chars: argumentChars, elapsed_ms: deadline.elapsedMs(), purpose });
       }
       deadline.signal.throwIfAborted();
-      if (!result) throw fail('Streaming Codex interrumpido; no se ejecutaron herramientas.', 'CODEX_RESPONSE_INCOMPLETE');
+      if (!result) throw fail('Codex streaming was interrupted; no tools were executed.', 'CODEX_RESPONSE_INCOMPLETE');
       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.mjs

@@ -155,7 +155,7 @@ export class WorkContextProjector {
       const ceiling=Math.floor(hardBudget*.65),details={estimated:true,overhead_tokens:overhead,overhead_ceiling:ceiling,context_window:this.contextWindow,input_budget:hardBudget,output_reserve:outputTokens,margin:initial.margin,tools_count:tools.length,instructions_utf8_bytes:Buffer.byteLength(system || ''),tool_schema_utf8_bytes:Buffer.byteLength(JSON.stringify(tools)),generation_dispatched:false};
       throw Object.assign(new Error(`Las instrucciones y esquemas de herramientas ocupan demasiado contexto: ~${overhead} tokens, techo ${ceiling} para ventana ${this.contextWindow} (${tools.length} herramientas; salida ${outputTokens}, margen ${initial.margin}). No se llamó al modelo. Reduce el catálogo/servidores MCP o las instrucciones; aumenta --context-window sólo si tu servidor y modelo lo permiten.`),{code:'CONTEXT_OVERHEAD',details});
     }
-    const current = history.findLast(message => message.role === 'user' && typeof message.content === 'string'), protectedMessages = current ? [current] : [];
+    const current = history.findLast(message => message.role === 'user' && (typeof message.content === 'string' || Array.isArray(message.content) && message.content.some(block => block.type === 'text'))), protectedMessages = current ? [withoutImages(current)] : [];
     const units = messageUnits(history);
     const latest = units.slice(-8).findLast(unit => unit.messages[0].content?.some?.(block => block.type === 'tool_use')
       && !unit.messages[0].content.filter(block => block.type === 'tool_use').every(block => ['WorkBoard','WorkSnapshot','AuditStatus','HouseSnapshot','OperationCatalog','McpStatus','HouseContext','PluginStatus'].includes(block.name)));

package/src/goals.mjs

@@ -144,9 +144,9 @@ export class GoalRunner {
         goal = await this.manager.read();
         const delegatedDenied = recent.some(block => {
           if (block.type !== 'tool_result') return false;
-          try { return JSON.parse(block.content).agents?.some(child => child.evidence?.some(item => item.is_error && /Permiso denegado/.test(item.output))) || false; } catch { return false; }
+          try { return JSON.parse(block.content).agents?.some(child => child.evidence?.some(item => item.is_error && /Permission denied|Permiso denegado/.test(item.output))) || false; } catch { return false; }
         });
-        if (delegatedDenied || recent.some(b => b.type === 'tool_result' && b.is_error && /Permiso denegado/.test(b.content))) {
+        if (delegatedDenied || recent.some(b => b.type === 'tool_result' && b.is_error && /Permission denied|Permiso denegado/.test(b.content))) {
           goal = await this.manager.write({ ...goal, status: 'paused', lastReason: 'Se requiere autorización para una herramienta; revisa los permisos y usa /goal resume.' }); break;
         }
         const verdict = await this.evaluator.evaluate({ condition: goal.condition, messages: session.historyMessages.slice(goal.messageBaseline || 0), signal, receipts: this.getReceipts ? await this.getReceipts(session, goal) : undefined });