@0xmaxma/claude-gateway 2.0.5 → 2.0.7

package/mcp/lazy-connector.ts

@@ -10,15 +10,17 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ToolListChangedNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
 import { createLazyToolCatalog, LAZY_TOOL_DEFINITIONS } from './lazy-tools';
+import { CodexNativeClient } from '../dist/session/codex-native-mcp-client.js';
 
 const config = JSON.parse(readFileSync(process.argv[2], 'utf8'));
-const client = new Client({name:'gateway-lazy-connector',version:'1'});
+const client: any = config.nativeCodex ? new CodexNativeClient(config.nativeCodex) : new Client({name:'gateway-lazy-connector',version:'1'});
 const shutdown = new AbortController();
 let connection: Promise<void> | undefined;
 let catalog: ReturnType<typeof createLazyToolCatalog> | undefined;
 let loading: Promise<ReturnType<typeof createLazyToolCatalog>> | undefined;
 function connect(): Promise<void> {
   if (!connection) connection = (async()=>{
+    if (config.nativeCodex) { await client.connect(); return; }
     const transport = config.command ? new StdioClientTransport({command:config.command,args:config.args,env:{...process.env,...config.env},cwd:config.cwd,stderr:'inherit'})
       : config.type === 'sse' ? new SSEClientTransport(new URL(config.url),{requestInit:{headers:config.headers}})
       : new StreamableHTTPClientTransport(new URL(config.url),{requestInit:{headers:config.headers}});
@@ -35,7 +37,7 @@ async function discover() {
     do {
       if(++pages>500)throw Error('Connector catalog pagination exceeded page limit');
       const page=await client.listTools(cursor?{cursor}:{},{timeout:10000,signal:shutdown.signal});
-      const pageTools=page.tools.map(t=>({...t,description:t.description??''}));
+      const pageTools=page.tools.filter(t => (!Array.isArray(config.enabled_tools) || config.enabled_tools.includes(t.name)) && !config.disabled_tools?.includes(t.name)).map(t=>({...t,description:t.description??''}));
       bytes+=Buffer.byteLength(JSON.stringify(pageTools));
       if(tools.length+pageTools.length>10000||bytes>8*1024*1024)throw Error('Connector catalog too large');
       tools.push(...pageTools);

package/mcp/lazy-tools.test.ts

@@ -150,3 +150,32 @@ test('real lazy inventory preserves every execution schema and successful browse
     local.stop(true); rmSync(dir, { recursive: true, force: true });
   }
 }, 15000);
+
+test('cron tools survive module registration and lazy discovery, while privileged modules remain unavailable', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'cron-lazy-'));
+  const calls: string[] = [];
+  const bridge = Bun.serve({hostname:'127.0.0.1',port:0,async fetch(req) {
+    const body=await req.json(); calls.push(body.tool);
+    return Response.json(body.tool === 'cron_list' ? {jobs:[]} : {active:true});
+  }});
+  const ticket=join(dir,'ticket.json');writeFileSync(ticket,JSON.stringify({url:`http://127.0.0.1:${bridge.port}`,token:'fixture'}));
+  const client=new Client({name:'cron-test',version:'1'});
+  try{
+    await client.connect(new StdioClientTransport({command:'bun',args:[join(import.meta.dir,'server.ts')],stderr:'ignore',env:{PATH:process.env.PATH??'',HOME:dir,GATEWAY_AGENT_ID:'fixture',GATEWAY_WORKSPACE_DIR:dir,GATEWAY_ORCHESTRATION_ROLE:'worker',GATEWAY_ORCHESTRATION_MEDIA:'true',GATEWAY_ORCHESTRATION_CRON:'true',GATEWAY_ORCHESTRATION_TICKET_FILE:ticket,GATEWAY_LAZY_TOOLS:'true'}}));
+    const search=await client.callTool({name:'tool_search',arguments:{query:'cron'}});
+    expect(JSON.parse((search.content as any)[0].text).total).toBe(6);
+    const result=await client.callTool({name:'tool_call',arguments:{name:'cron_list',arguments:{}}});
+    expect(result.isError).not.toBe(true);expect(calls).toEqual(['task_validate','cron_list']);
+    for(const name of ['agent_create','install_app','skill_install','api_request','telegram_send_message']){
+      const denied=await client.callTool({name:'tool_call',arguments:{name,arguments:{}}});expect(denied.isError).toBe(true);
+    }
+  }finally{await client.close();bridge.stop(true);rmSync(dir,{recursive:true,force:true});}
+},15000);
+
+test('all registered worker modules follow the scoped execution policy',async()=>{
+ const {gatewayModules}=await import('./modules');
+ expect(gatewayModules('agent').map(m=>m.id)).toEqual(['memory','safemode']);
+ expect(gatewayModules('worker',true).map(m=>m.id)).toEqual(['memory','cron','image','video','share-file','browser']);
+ const standalone=gatewayModules().map(m=>m.id);
+ for(const id of ['cron','image','video','share-file','browser','skills','apps','agent','api','telegram','discord','line','slack','whatsapp','whatsapp_cloud','wechat'])expect(standalone).toContain(id);
+});

package/mcp/modules.ts

@@ -25,6 +25,7 @@ export function gatewayModules(
   return role
     ? [
         new MemoryModule(),
+        ...(role === 'worker' ? [new CronModule()] : []),
         ...(role === 'worker' && media
           ? [
               new ImageModule(),

package/mcp/server.ts

@@ -46,8 +46,8 @@ for (const mod of modules) {
   if (!visible) continue;
 
   for (const tool of mod.getTools()) {
-    if (ORCHESTRATION_ROLE && !['memory_search', 'memory_get'].includes(tool.name) && !(ORCHESTRATION_ROLE === 'worker' &&
-      ((mod.id === 'image' || mod.id === 'video' || mod.id === 'share-file' || mod.id === 'browser') || (mod.id === 'memory' && process.env.GATEWAY_ORCHESTRATION_WRITE_MEMORY === 'true')))) continue;
+    if (ORCHESTRATION_ROLE && !(ORCHESTRATION_ROLE === 'agent' && mod.id === 'safemode') && !['memory_search', 'memory_get'].includes(tool.name) && !(ORCHESTRATION_ROLE === 'worker' &&
+      ((mod.id === 'cron' || mod.id === 'image' || mod.id === 'video' || mod.id === 'share-file' || mod.id === 'browser') || (mod.id === 'memory' && process.env.GATEWAY_ORCHESTRATION_WRITE_MEMORY === 'true')))) continue;
     toolMap.set(tool.name, mod);
     visibleTools.push(tool);
   }

package/mcp/tools/cron/module.ts

@@ -1,3 +1,5 @@
+import { CRON_TOOLS } from '../../../dist/cron/tool-schemas.js';
+import { callTaskBridge } from '../tasks/module';
 /**
  * Cron tool module — implements ToolModule interface.
  * Provides cron job management tools via the gateway REST API.
@@ -21,7 +23,7 @@ export class CronModule implements ToolModule {
   private client: CronClient | null = null;
 
   isEnabled(): boolean {
-    return Boolean(process.env.GATEWAY_API_URL && process.env.GATEWAY_AGENT_ID);
+    return Boolean((process.env.GATEWAY_ORCHESTRATION_ROLE === 'worker' && process.env.GATEWAY_ORCHESTRATION_CRON === 'true' && process.env.GATEWAY_ORCHESTRATION_TICKET_FILE) || (process.env.GATEWAY_API_URL && process.env.GATEWAY_AGENT_ID));
   }
 
   private getClient(): CronClient {
@@ -35,121 +37,13 @@ export class CronModule implements ToolModule {
   }
 
   getTools(): McpToolDefinition[] {
-    return [
-      {
-        name: 'cron_list',
-        description: 'List scheduled cron jobs for this agent',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          additionalProperties: false,
-        },
-      },
-      {
-        name: 'cron_create',
-        description: 'Create a new cron job',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'Job name' },
-            schedule: { type: 'string', description: '5-field cron expression' },
-            type: { type: 'string', enum: ['command', 'agent'], description: 'Job type' },
-            command: { type: 'string', description: 'Shell command (type=command)' },
-            prompt: { type: 'string', description: 'Agent prompt (type=agent)' },
-            telegram: { type: 'string', description: 'Telegram chat_id for delivery — full response on success (type=agent), or a short failure notice on error (any type)' },
-            discord: { type: 'string', description: 'Discord channel_id for delivery — full response on success (type=agent), or a short failure notice on error (any type)' },
-            timeout_ms: { type: 'number', description: 'Timeout in milliseconds' },
-            scheduleKind: {
-              type: 'string',
-              enum: ['cron', 'at'],
-              description: 'Schedule type: "cron" for recurring (default), "at" for one-shot at a specific ISO datetime',
-            },
-            scheduleAt: {
-              type: 'string',
-              description: 'ISO 8601 datetime for one-shot execution (required when scheduleKind=at)',
-            },
-            deleteAfterRun: {
-              type: 'boolean',
-              description: 'Delete the job after it runs once. Defaults to true for scheduleKind=at, false for cron',
-            },
-          },
-          required: ['name', 'type'],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: 'cron_delete',
-        description: 'Delete a cron job by ID',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            job_id: { type: 'string', description: 'Job ID to delete' },
-          },
-          required: ['job_id'],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: 'cron_update',
-        description: 'Update an existing cron job. Provide job_id plus only the fields to change.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            job_id: { type: 'string', description: 'ID of the job to update' },
-            name: { type: 'string', description: 'Job name' },
-            schedule: { type: 'string', description: '5-field cron expression' },
-            type: { type: 'string', enum: ['command', 'agent'], description: 'Job type' },
-            command: { type: 'string', description: 'Shell command (type=command)' },
-            prompt: { type: 'string', description: 'Agent prompt (type=agent)' },
-            telegram: { type: 'string', description: 'Telegram chat_id for delivery — full response on success (type=agent), or a short failure notice on error (any type)' },
-            discord: { type: 'string', description: 'Discord channel_id for delivery — full response on success (type=agent), or a short failure notice on error (any type)' },
-            timeout_ms: { type: 'number', description: 'Timeout in milliseconds' },
-            scheduleKind: {
-              type: 'string',
-              enum: ['cron', 'at'],
-              description: 'Schedule type: "cron" for recurring, "at" for one-shot at a specific ISO datetime',
-            },
-            scheduleAt: {
-              type: 'string',
-              description: 'ISO 8601 datetime for one-shot execution (required when scheduleKind=at)',
-            },
-            deleteAfterRun: {
-              type: 'boolean',
-              description: 'Delete the job after it runs once',
-            },
-          },
-          required: ['job_id'],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: 'cron_run',
-        description: 'Run a cron job immediately',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            job_id: { type: 'string', description: 'Job ID to run' },
-          },
-          required: ['job_id'],
-          additionalProperties: false,
-        },
-      },
-      {
-        name: 'cron_get_runs',
-        description: 'Get run history for a cron job',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            job_id: { type: 'string', description: 'Job ID' },
-          },
-          required: ['job_id'],
-          additionalProperties: false,
-        },
-      },
-    ];
+    return CRON_TOOLS;
   }
 
-  async handleTool(name: string, args: Record<string, unknown>): Promise<McpToolResult> {
+  async handleTool(name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<McpToolResult> {
+    if (process.env.GATEWAY_ORCHESTRATION_ROLE === 'worker') {
+      return callTaskBridge(name, args, crypto.randomUUID(), signal ?? new AbortController().signal);
+    }
     const client = this.getClient();
 
     try {

package/mcp/tools/discord/commands.ts

@@ -13,6 +13,10 @@ export const SLASH_COMMANDS: SlashCommandDef[] = [
   },
   { name: 'clear', description: 'Reset model context without deleting chat history' },
   { name: 'compact', description: 'Compact Claude Code context without changing chat history' },
+  { name: 'help', description: 'Show all supported commands' },
+  { name: 'restart', description: 'Restart the session process after confirmation' },
+  { name: 'sessions', description: 'List sessions' },
+  { name: 'models', description: 'List and select a model' },
   { name: 'session', description: 'Show current session info' },
   {
     name: 'new',
@@ -32,7 +36,6 @@ export function commandDefinitions(orchestration:boolean,interactive:boolean):Sl
       {name:'voice',description:'Turn automatic voice replies on or off',options:[{name:'mode',description:'on or off (omit to show buttons)',required:false,type:'STRING' as const}]},
       {name:'voices',description:'Choose the agent voice'},
       {name:'tasks',description:'View pending tasks in this conversation'},
-      {name:'help',description:'Show available orchestration controls'},
     ] : []),
     {name:'stop',description:orchestration?'Stop a response or choose a task to stop':'Stop the agent response'},
     ...(interactive && !orchestration ? [{name:'cli',description:'Open the live terminal viewer'}] : []),

package/mcp/tools/safemode/module.test.ts

@@ -0,0 +1,29 @@
+import { expect, test } from 'bun:test';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+  test('real MCP never loads legacy safemode schemas for agents or workers', async () => {
+    const directory = mkdtempSync(join(tmpdir(), 'safemode-mcp-'));
+    const calls: Array<{ tool: string; args: unknown }> = [];
+    let allow = false;
+    const bridge = Bun.serve({ hostname: '127.0.0.1', port: 0, async fetch(req) {
+      calls.push(await req.json()); return allow ? Response.json({ allowed: true }) : new Response('ACCESS_DENIED', { status: 403 });
+    } });
+    const ticket = join(directory, 'ticket.json');
+    writeFileSync(ticket, JSON.stringify({ url: `http://127.0.0.1:${bridge.port}`, token: 'synthetic-test' }));
+    const clients: Client[] = [];
+    try {
+      for (const [role, permittedTools] of [['agent',true],['agent',false],['worker',true]] as const) {
+        const client = new Client({ name: 'safemode-test', version: '1' }); clients.push(client);
+        await client.connect(new StdioClientTransport({ command: 'bun', args: [join(import.meta.dir, '../../server.ts')], stderr: 'ignore', env: {
+          PATH: process.env.PATH ?? '', HOME: directory, GATEWAY_ORCHESTRATION_ROLE: role, GATEWAY_SAFEMODE_ALLOWED: permittedTools ? 'true' : '', GATEWAY_ORCHESTRATION_TICKET_FILE: ticket,
+        } }));
+        const listed = (await client.listTools()).tools.filter(tool => tool.name.startsWith('safemode_'));
+        expect(listed).toEqual([]);
+        expect((await client.callTool({name:'safemode_list',arguments:{}})).isError).toBe(true);
+      }
+      expect(calls).toHaveLength(0);
+    } finally { for (const client of clients) await client.close(); bridge.stop(true); rmSync(directory, { recursive: true, force: true }); }
+  }, 15000);

package/mcp/tools/telegram/receiver-server.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env bun
+import { commandHelp } from '../../../dist/agent/command-help.js';
+import { parseSessionInfo } from './session-browser';
 /**
  * Telegram channel for Claude Gateway.
  *
@@ -1161,28 +1163,7 @@ bot.command('start', async ctx => {
 
 bot.command('help', async ctx => {
   if (ctx.chat?.type !== 'private') return
-  await ctx.reply(
-    `Messages you send here route to a paired Claude Code session. ` +
-    `Text and photos are forwarded; replies and reactions come back.\n\n` +
-    `*Session management*\n` +
-    `/session — show current session info\n` +    
-    `/sessions — list and switch between sessions\n` +
-    `/new <name> — create a new session\n` +
-    `/rename <name> — rename current session\n` +
-    `/clear — reset context; keep chat history\n` +
-    `/compact — compact Claude Code context; keep chat history\n` +
-    (ORCHESTRATION_ENABLED ? `/stop — stop the reply and choose a task to cancel\n` : `/stop — interrupt the running turn\n`) +
-    `/restart — graceful restart session\n\n` +
-    `*Agent*\n` +
-    `/model — show current AI model\n` +
-    `/models — switch AI model\n` +
-    (ORCHESTRATION_ENABLED ? `/tasks — view pending tasks in this chat\n/voice — turn automatic voice replies on/off (default off)\n/voices — choose the agent voice\n` : '') +
-    (INTERACTIVE_CLI_ENABLED ? `/cli — open the live terminal viewer\n\n` : '\n') +
-    `*Account*\n` +
-    `/start — pairing instructions\n` +
-    `/status — check your pairing state`,
-    { parse_mode: 'Markdown' }
-  )
+  await ctx.reply(commandHelp('telegram', ORCHESTRATION_ENABLED, INTERACTIVE_CLI_ENABLED))
 })
 
 bot.command('status', async ctx => {
@@ -1514,24 +1495,37 @@ bot.command('voice', async ctx => {
   } catch { await ctx.reply('Voice settings are unavailable. Check the agent TTS configuration.') }
 })
 
-// /session — show current session info (direct command, no typing manager)
-bot.command('session', async ctx => {
-  if (ctx.chat?.type !== 'private') return
-  const access = loadAccess()
-  if (!access.allowFrom.includes(String(ctx.from!.id))) return
-  if (!CALLBACK_URL_BASE) return
-
-  try {
-    const res = await fetch(CALLBACK_URL_BASE + '/command', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ command: 'session_info', chat_id: String(ctx.chat.id) }),
+// Reuse the /tasks live-message lifecycle: serialize reads/replacement, edit only
+// changes, persist the last message across restart, and honor Telegram backoff.
+const SESSION_BROWSER_FILE = join(STATE_DIR, 'session-browser.json')
+let restoredSessionBrowsers: TaskBrowserMessage[] = []
+try { const saved = JSON.parse(readFileSync(SESSION_BROWSER_FILE, 'utf8')); if (Array.isArray(saved)) restoredSessionBrowsers = saved } catch {}
+const liveSessionBrowser = new LiveTaskBrowser({
+  read: async (chat) => {
+    if (!CALLBACK_URL_BASE) throw new Error('not_configured')
+    const response = await fetch(CALLBACK_URL_BASE + '/command', {
+      method:'POST', headers:{'Content-Type':'application/json'}, signal:AbortSignal.timeout(10000),
+      body:JSON.stringify({command:'session_info',chat_id:chat}),
     })
-    const data = await res.json() as { success: boolean; text?: string }
-    await ctx.reply(data.text ?? '⚠️ Could not get session info.', { parse_mode: 'HTML' })
-  } catch {
-    await ctx.reply('⚠️ Could not connect to gateway.')
-  }
+    return parseSessionInfo(response.ok, await response.json())
+  },
+  render: result => ({text:(result as {sessionId:string;text:string}).text,reply_markup:{inline_keyboard:[]}}),
+  send: async (chat,menu) => (await bot.api.sendMessage(chat,menu.text,{parse_mode:'HTML'})).message_id,
+  edit: (chat,id,menu) => bot.api.editMessageText(chat,id,menu.text,{parse_mode:'HTML'}),
+  remove: (chat,id) => bot.api.deleteMessage(chat,id),
+  close: (chat,id) => bot.api.editMessageText(chat,id,'Session view closed.'),
+  allowed: (chat,user) => chat === user && loadAccess().allowFrom.includes(user),
+  persist: entries => {
+    mkdirSync(STATE_DIR,{recursive:true,mode:0o700})
+    const temp=SESSION_BROWSER_FILE+'.tmp'
+    writeFileSync(temp,JSON.stringify(entries),{mode:0o600});renameSync(temp,SESSION_BROWSER_FILE)
+  },
+},restoredSessionBrowsers)
+setInterval(()=>{void liveSessionBrowser.tick().catch(()=>{})},3000).unref()
+bot.command('session',async ctx=>{
+  if(ctx.chat?.type!=='private'||!isCallbackAuthorized(ctx))return
+  try{await liveSessionBrowser.open(String(ctx.chat.id),String(ctx.from!.id))}
+  catch{await ctx.reply('Could not load session info. Please try /session again.')}
 })
 
 // /sessions — list sessions with inline keyboard for switching/deleting

package/mcp/tools/telegram/session-browser.ts

@@ -0,0 +1,10 @@
+/** A successful empty session is a status, not a transport failure. The empty
+ * ID binds its live message until a real session appears, when it is retired. */
+export function parseSessionInfo(ok: boolean, value: unknown): { sessionId: string; text: string } {
+  const result = value as { success?: unknown; sessionId?: unknown; text?: unknown } | null;
+  if (!ok || result?.success !== true || typeof result.text !== 'string' ||
+      !(result.sessionId === null || (typeof result.sessionId === 'string' && result.sessionId.length > 0))) {
+    throw new Error('Session info unavailable');
+  }
+  return { sessionId: result.sessionId ?? '', text: result.text };
+}

package/mcp/tools/telegram/task-detail.ts

@@ -4,6 +4,7 @@ import type { ProcessSample } from '../../../src/orchestration/process-activity'
 import type { ToolOutcome } from '../../../src/orchestration/execution-observation';
 
 export interface TaskDetail {
+  harness?: 'claude' | 'codex';
   title: string; state: string; startedAt?: number; finishedAt?: number;
   timing?: Partial<Record<'working' | 'tool' | 'input' | 'queued' | 'other' | 'finished', number>>;
   timingMeasuredFrom?: number;
@@ -28,7 +29,7 @@ export function formatTaskDetail(task: TaskDetail, label: string): string {
   const lastTool = activity?.lastTool;
   const diagnostics = [counters, lastTool ? `Last tool: ${lastTool.name} · ${lastTool.status === 'error' ? 'Reported error' : 'Result received'}${lastTool.exitCode === undefined ? '' : ` · Exit code: ${lastTool.exitCode}`}\nReported at: ${new Date(lastTool.observedAt).toISOString().replace('T',' ').replace(/\.\d{3}Z$/, ' UTC')}` : '', activity?.observationStatus ?? activity?.status, activity?.quiet ? 'No recent tool/model progress; task retained for inspection or cancellation.' : ''].filter(Boolean);
   return [
-    `${task.title}\n${label} · Elapsed: ${formatTaskElapsed(task.startedAt,task.finishedAt)}`,
+    `${task.title}\n${label} · Elapsed: ${formatTaskElapsed(task.startedAt,task.finishedAt)}${task.harness ? `\nHarness: ${task.harness === 'codex' ? 'Codex' : 'Claude Code'}` : ''}`,
     formatTiming(task.timing) ? 'Time breakdown\n' + formatTiming(task.timing) + (task.timingMeasuredFrom && task.startedAt && task.timingMeasuredFrom > task.startedAt + 1000 ? '\nMeasured since ' + new Date(task.timingMeasuredFrom).toISOString() : '') : '',
     progressLines.length ? `Progress\n${progressLines.join('\n')}` : '',
     diagnostics.length ? `Diagnostics\n${diagnostics.join('\n')}` : '',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/write-build-provenance.cjs",
     "start": "node --no-warnings=ExperimentalWarning --env-file-if-exists=.env dist/entry.js gateway start",
     "postinstall": "if command -v bun >/dev/null 2>&1; then bun install --cwd mcp; else echo 'Warning: bun not found. Run `cd mcp && bun install` manually to enable MCP tools.'; fi",
     "pretest": "npm run build",
@@ -61,6 +61,7 @@
     "pino": "^10.3.1",
     "qrcode": "^1.5.4",
     "sharp": "^0.35.4",
+    "smol-toml": "^1.8.0",
     "ws": "^8.21.0"
   },
   "devDependencies": {

package/scripts/orchestration/audit-codex-context.cjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// Measure native CLI context metadata with a local Responses fixture, without model billing.
+// This does NOT certify that an upstream provider accepts requests of that size.
+require('ts-node/register/transpile-only');
+const {CodexProcess}=require('../../src/session/codex-process');
+const {resolveCodexRuntime}=require('../../src/session/codex-runtime');
+const {resolveWorkerHarness}=require('../../src/orchestration/worker-harness');
+const fs=require('fs/promises'),path=require('path'),os=require('os'),http=require('http');
+const {execFileSync}=require('child_process'),{once}=require('events');
+const args=process.argv.slice(2);
+function option(name){const i=args.indexOf(name);return i<0?undefined:args[i+1];}
+(async()=>{
+ const runtime=resolveCodexRuntime();
+ const catalog=option('--catalog-json')?JSON.parse(await fs.readFile(option('--catalog-json'),'utf8')).models:JSON.parse(execFileSync(runtime.executable,['debug','models','--bundled'],{encoding:'utf8',timeout:15000,maxBuffer:8*1024*1024})).models;
+ const supplied=option('--models-json')?JSON.parse(await fs.readFile(option('--models-json'),'utf8')):[];
+ const selected=new Map([...catalog.filter(m=>m.slug.includes('gpt')).map(m=>[m.slug,{id:m.slug}]),...supplied.map(m=>[m.id,m])]);
+ const directory=await fs.mkdtemp(path.join(os.tmpdir(),'gateway-context-audit-'));
+ const previous=process.env.GATEWAY_CONTEXT_AUDIT_KEY;
+ process.env.GATEWAY_CONTEXT_AUDIT_KEY='local-fixture-only';
+ const sockets=new Set(),adapters=new Set(),rows=[];
+ const server=http.createServer(async(req,res)=>{
+  try{
+   let raw='';for await(const chunk of req){raw+=chunk;if(raw.length>4*1024*1024)throw Error('Fixture request too large');}
+   const body=JSON.parse(raw),id='resp_fixture',item={type:'message',id:'msg_fixture',role:'assistant',phase:'final_answer',status:'completed',content:[{type:'output_text',text:'Context audit fixture complete.',annotations:[]}]};
+   const response={id,object:'response',created_at:Math.floor(Date.now()/1000),status:'completed',model:body.model,output:[item],usage:{input_tokens:100,input_tokens_details:{cached_tokens:0},output_tokens:5,total_tokens:105}};
+   res.writeHead(200,{'content-type':'text/event-stream'});
+   const emit=(type,payload)=>res.write('event: '+type+'\ndata: '+JSON.stringify({type,...payload})+'\n\n');
+   emit('response.created',{response:{...response,status:'in_progress',output:[]}});
+   emit('response.output_item.added',{output_index:0,item:{...item,status:'in_progress',content:[]}});
+   emit('response.content_part.added',{item_id:item.id,output_index:0,content_index:0,part:{type:'output_text',text:'',annotations:[]}});
+   emit('response.output_text.delta',{item_id:item.id,output_index:0,content_index:0,delta:item.content[0].text});
+   emit('response.output_text.done',{item_id:item.id,output_index:0,content_index:0,text:item.content[0].text});
+   emit('response.content_part.done',{item_id:item.id,output_index:0,content_index:0,part:item.content[0]});
+   emit('response.output_item.done',{output_index:0,item});
+   emit('response.completed',{response});res.end();
+  }catch(error){res.destroy(error);}
+ });
+ server.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));});
+ try{
+  server.listen(0,'127.0.0.1');await once(server,'listening');
+  await fs.writeFile(path.join(directory,'mcp.json'),'{"mcpServers":{}}');
+  let index=0;
+  async function runNext(){
+   while(index<selected.size){
+    const record=[...selected.values()][index++],model=record.workerModel||record.id.replace(/\[(?:1m|200k)\]$/i,'');
+    const row={selection:record.id,nativeModel:model,advertisedGatewayWindow:record.contextWindow??null,requested:1000000};
+    const known=catalog.find(m=>m.slug===model);
+    row.catalog=known?{default:known.context_window,max:known.max_context_window,usablePercent:known.effective_context_window_percent}:null;
+    row.autoHarness=resolveWorkerHarness({workers:{harness:'auto'}},{gateway:{models:record.workerHarness?[record]:[]}},record.id).harness;
+    const adapter=new CodexProcess({agent:{workspace:directory},gateway:{gateway:{}},profile:{role:'worker',hostExecution:true,connectorsAllowed:false,mcpConfigPath:path.join(directory,'mcp.json'),overlay:'Local metadata audit. Return one short message.'},sessionId:'audit-'+index,stateDirectory:directory,
+      config:{model,contextWindow:1000000,bin:runtime.executable,baseUrl:'http://127.0.0.1:'+server.address().port+'/v1',apiKeyEnv:'GATEWAY_CONTEXT_AUDIT_KEY'}});
+    adapters.add(adapter);
+    const originalEvent=adapter.event.bind(adapter);
+    adapter.event=function(event){if(event.method==='thread/tokenUsage/updated')row.observedUsable=event.params?.tokenUsage?.modelContextWindow??null;return originalEvent(event);};
+    const originalRequest=adapter.request.bind(adapter);
+    adapter.request=async function(method,params){const result=await originalRequest(method,params);if(method==='config/read')row.effectiveConfiguredWindow=result.config?.model_context_window;return result;};
+    let timer;
+    try{
+     const complete=new Promise((resolve,reject)=>{timer=setTimeout(()=>reject(Error('Native audit timed out')),30000);adapter.on('startup-error',reject);adapter.on('output',line=>{const e=JSON.parse(line);if(e.contextWindow)row.context=e.contextWindow;if(e.type==='result')e.is_error?reject(Error(e.result)):resolve();});});
+     await adapter.start();
+     if(option('--catalog-json')){
+       const filename=path.join(adapter.home,'config.toml');
+       const config=await fs.readFile(filename,'utf8');
+       await fs.writeFile(filename,'model_catalog_json = '+JSON.stringify(path.resolve(option('--catalog-json')))+'\n'+config,{mode:0o600});
+     }
+     adapter.sendMessage('Return a short audit completion.');await complete;
+     row.status=typeof row.observedUsable==='number'?'measured':'missing-native-measurement';
+    }catch(error){row.status='error';row.error=error.message;}
+    finally{clearTimeout(timer);await adapter.stop();adapters.delete(adapter);}
+    rows.push(row);console.log(JSON.stringify(row));
+   }
+  }
+  await Promise.all([runNext(),runNext()]);
+  const report={measuredAt:new Date().toISOString(),version:execFileSync(runtime.executable,['--version'],{encoding:'utf8'}).trim(),catalogSource:option('--catalog-json')?'explicit snapshot':'bundled',method:'Real CodexProcess/app-server; explicit 1M request; local fake Responses API; observe native modelContextWindow. No upstream capacity/inference certification.',rows:rows.sort((a,b)=>a.selection.localeCompare(b.selection))};
+  if(option('--output'))await fs.writeFile(option('--output'),JSON.stringify(report,null,2)+'\n');
+  if(rows.some(row=>row.status!=='measured'))process.exitCode=1;
+ }finally{
+  await Promise.allSettled([...adapters].map(a=>a.stop()));
+  for(const socket of sockets)socket.destroy();server.close();
+  if(previous===undefined)delete process.env.GATEWAY_CONTEXT_AUDIT_KEY;else process.env.GATEWAY_CONTEXT_AUDIT_KEY=previous;
+  await fs.rm(directory,{recursive:true,force:true});
+ }
+})().catch(error=>{console.error(error.message);process.exitCode=1;});

package/scripts/orchestration/benchmark-worker-harnesses.cjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+'use strict';
+// Opt-in, billable native CLI smoke benchmark; deliberately not a gateway benchmark.
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn, spawnSync } = require('node:child_process');
+const args = process.argv.slice(2);
+const option = (name, fallback) => args.includes(name) ? args[args.indexOf(name) + 1] : fallback;
+if (!args.includes('--run')) {
+  console.log('Opt-in real calls: node scripts/orchestration/benchmark-worker-harnesses.cjs --run [--claude-model sonnet] [--codex-model gpt-5.6-luna] [--claude-base-url URL --claude-api-key-env ENV_NAME] [--codex-base-url URL --codex-api-key-env ENV_NAME] [--host-execution] [--output /tmp/worker-benchmark.json]');
+  process.exit(0);
+}
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gateway-worker-benchmark-'));
+fs.chmodSync(root, 0o700);
+const prompt = 'Implement sumIntegers(values) in sum.cjs, exporting { sumIntegers }. Accept an array of safe integers and return its sum. Throw TypeError for non-arrays or invalid elements and RangeError if any intermediate sum is not a safe integer. Empty arrays return 0. Use built-in Node only. Run a small Node verification. Modify only sum.cjs in this directory; do not inspect parent directories or credentials. Finish with a brief summary.';
+const harness = `const assert=require('node:assert/strict');const {sumIntegers:s}=require(process.argv[1]);assert.equal(s([]),0);assert.equal(s([1,2,-3,4]),4);assert.equal(s([-4,-2]),-6);for(const x of [null,{},'1',[1.2],[NaN],[Infinity],['1'],[Number.MAX_SAFE_INTEGER+1]])assert.throws(()=>s(x),TypeError);assert.throws(()=>s([Number.MAX_SAFE_INTEGER,1]),RangeError);assert.throws(()=>s([-Number.MAX_SAFE_INTEGER,-1]),RangeError);`;
+function execute(bin, argv, cwd, env) {
+  return new Promise(resolve => {
+    const started = Date.now(); let output = '', timedOut = false, spawnError = false;
+    const p = spawn(bin, argv, { cwd, env, detached: process.platform !== 'win32', stdio: ['pipe','pipe','pipe'] });
+    const kill = () => { try { process.platform === 'win32' ? p.kill('SIGKILL') : process.kill(-p.pid, 'SIGKILL'); } catch {} };
+    const timer = setTimeout(() => { timedOut = true; kill(); }, 120000);
+    p.stdout.on('data', b => { if (output.length < 8 * 1024 * 1024) output += b; else kill(); });
+    // Never persist stderr: providers may echo account/endpoint/auth information.
+    p.stderr.resume();
+    p.on('error', () => { spawnError = true; });
+    p.on('close', code => { clearTimeout(timer); kill(); resolve({ code, timedOut, spawnError, wallMs: Date.now() - started, output }); });
+    p.stdin.on('error', () => {}); p.stdin.end(prompt);
+  });
+}
+function metrics(harness, text) {
+  const result = { inputTokens: null, cachedInputTokens: null, cacheCreationTokens: null, outputTokens: null, toolErrors: 0, providerErrors: 0, failureCategory: null, toolCalls: 0 };
+  for (const line of text.split('\n')) {
+    let event; try { event = JSON.parse(line); } catch { continue; }
+    const diagnostic = JSON.stringify(event);
+    if (event.is_error || event.type === 'error' || event.type === 'turn.failed') {
+      result.failureCategory = /auth|token|credential|401|403/i.test(diagnostic) ? 'authentication' : /model.*(not|invalid|unknown)|unsupported.*model/i.test(diagnostic) ? 'model_unavailable' : /permission|sandbox|denied/i.test(diagnostic) ? 'permission' : 'provider_or_cli';
+    }
+    if (harness === 'codex') {
+      if (event.type === 'item.completed' && ['command_execution','mcp_tool_call','file_change'].includes(event.item?.type)) result.toolCalls++;
+      if (event.type === 'turn.completed' && event.usage) {
+        result.inputTokens = event.usage.input_tokens ?? null;
+        result.cachedInputTokens = event.usage.cached_input_tokens ?? null;
+        result.cacheCreationTokens = event.usage.cache_write_input_tokens ?? null;
+        result.outputTokens = event.usage.output_tokens ?? null;
+      }
+      if (event.type === 'item.completed' && (event.item?.status === 'failed' || (typeof event.item?.exit_code === 'number' && event.item.exit_code !== 0))) result.toolErrors++;
+      if (event.type === 'turn.failed' || event.type === 'error') result.providerErrors++;
+    } else {
+      if (event.type === 'result') {
+        const u = event.usage ?? {};
+        result.inputTokens = u.input_tokens ?? null;
+        result.cachedInputTokens = u.cache_read_input_tokens ?? null;
+        result.cacheCreationTokens = u.cache_creation_input_tokens ?? null;
+        result.outputTokens = u.output_tokens ?? null;
+        if (event.is_error) result.providerErrors++;
+      }
+      for (const block of event.message?.content ?? []) if (block.type === 'tool_use') result.toolCalls++;
+      for (const block of event.message?.content ?? []) if (block.type === 'tool_result' && block.is_error) result.toolErrors++;
+    }
+  }
+  // Codex includes reads and writes in input_tokens; Claude reports disjoint categories.
+  result.freshInputTokens = result.inputTokens === null ? null : harness === 'codex'
+    ? Math.max(0, result.inputTokens - (result.cachedInputTokens ?? 0) - (result.cacheCreationTokens ?? 0)) : result.inputTokens;
+  result.totalInputTokens = result.inputTokens === null ? null : harness === 'codex'
+    ? result.inputTokens : result.inputTokens + (result.cachedInputTokens ?? 0) + (result.cacheCreationTokens ?? 0);
+  return result;
+}
+(async () => {
+  let settings = {}; try { settings = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.claude', 'settings.json'), 'utf8')); } catch {}
+  const claudeEnv = { ...process.env };
+  for (const key of ['ANTHROPIC_API_KEY','ANTHROPIC_AUTH_TOKEN','CLAUDE_CODE_OAUTH_TOKEN','ANTHROPIC_BASE_URL']) if (!claudeEnv[key] && typeof settings.env?.[key] === 'string') claudeEnv[key] = settings.env[key];
+  const claudeKeyEnv = option('--claude-api-key-env');
+  if (claudeKeyEnv) {
+    if (!/^[A-Z_][A-Z0-9_]*$/.test(claudeKeyEnv) || !process.env[claudeKeyEnv]) throw new Error('Missing explicit Claude credential');
+    delete claudeEnv.ANTHROPIC_AUTH_TOKEN;
+    delete claudeEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    claudeEnv.ANTHROPIC_API_KEY = process.env[claudeKeyEnv];
+  }
+  if (option('--claude-base-url')) claudeEnv.ANTHROPIC_BASE_URL = option('--claude-base-url');
+  const codexKeyEnv = option('--codex-api-key-env', 'OPENAI_API_KEY');
+  if (!/^[A-Z_][A-Z0-9_]*$/.test(codexKeyEnv)) throw new Error('Invalid credential environment name');
+  const codexEnv = { ...process.env }; // CLI reads existing auth in-place; never copy it.
+  const routes = [
+    { harness: 'claude', bin: process.env.CLAUDE_BIN || 'claude', model: option('--claude-model','sonnet'), env: claudeEnv,
+      auth: ['ANTHROPIC_API_KEY','ANTHROPIC_AUTH_TOKEN','CLAUDE_CODE_OAUTH_TOKEN'].some(k => claudeEnv[k]) || fs.existsSync(path.join(os.homedir(),'.claude','.credentials.json')) },
+    { harness: 'codex', bin: process.env.CODEX_BIN || 'codex', model: option('--codex-model','gpt-5.6-luna'), env: codexEnv,
+      auth: Boolean(codexEnv[codexKeyEnv]) || (!option('--codex-base-url') && fs.existsSync(path.join(codexEnv.CODEX_HOME || path.join(os.homedir(),'.codex'),'auth.json'))) },
+  ];
+  const report = { kind: 'native-cli-smoke', codexSandbox: args.includes('--host-execution') ? 'danger-full-access' : 'workspace-write', note: 'Different models/provider/account routes may apply. Not a controlled timing/cost A/B, gateway integration test, or quality-parity claim. CLI token accounting differs; null means unavailable.', runs: [] };
+  for (const route of routes) {
+    if (!route.auth) { report.runs.push({ harness: route.harness, model: route.model, status: 'skipped_missing_credentials' }); continue; }
+    const cwd = path.join(root,route.harness); fs.mkdirSync(cwd, {mode:0o700});
+    fs.writeFileSync(path.join(cwd,'sum.cjs'),'module.exports = { sumIntegers() { throw new Error("TODO"); } };\n');
+    const argv = route.harness === 'codex'
+      ? ['exec','--ignore-user-config','--ignore-rules','--skip-git-repo-check','--ephemeral','--json','--sandbox',args.includes('--host-execution') ? 'danger-full-access' : 'workspace-write','-c','project_doc_max_bytes=0','-c','approval_policy="never"','-c','model_reasoning_effort="medium"','--model',route.model,'-']
+      : ['--print',...(claudeKeyEnv ? ['--bare','--setting-sources',''] : []),'--no-session-persistence','--output-format','stream-json','--verbose','--model',route.model,'--permission-mode','bypassPermissions','--tools','Read,Edit,Write,Bash','--strict-mcp-config','--mcp-config','{"mcpServers":{}}'];
+    if (route.harness === 'codex' && option('--codex-base-url')) {
+      const url = new URL(option('--codex-base-url'));
+      if (url.username || url.password || url.search || url.hash || !['https:', 'http:'].includes(url.protocol)) throw new Error('Invalid endpoint');
+      argv.splice(argv.length - 1, 0, '-c', 'model_provider="benchmark"', '-c', 'model_providers.benchmark.name="Benchmark"', '-c', 'model_providers.benchmark.wire_api="responses"', '-c', 'model_providers.benchmark.base_url=' + JSON.stringify(url.href), '-c', 'model_providers.benchmark.env_key=' + JSON.stringify(codexKeyEnv));
+    }
+    const run = await execute(route.bin,argv,cwd,route.env);
+    const checked = spawnSync(process.execPath,['-e',harness,path.join(cwd,'sum.cjs')],{timeout:5000,encoding:'utf8'});
+    report.runs.push({harness:route.harness,model:route.model,status:run.spawnError?'cli_unavailable':run.timedOut?'timeout':run.code===0?'finished':'cli_failed',exitCode:run.code,wallMs:run.wallMs,correctnessPassed:checked.status===0,validationFailure:checked.status===0?null:checked.error?'harness_error':(checked.stderr?.match(/(?:AssertionError|TypeError|RangeError|SyntaxError|ReferenceError|MODULE_NOT_FOUND)/)?.[0] ?? 'test_failed'),...metrics(route.harness,run.output)});
+  }
+  const json = JSON.stringify(report,null,2)+'\n';
+  if (option('--output')) fs.writeFileSync(option('--output'),json,{mode:0o600});
+  process.stdout.write(json);
+  process.exitCode = report.runs.every(r=>r.status==='finished'&&r.correctnessPassed&&r.providerErrors===0) ? 0 : 1;
+})().catch(() => { console.error('Benchmark failed; raw provider output suppressed.'); process.exitCode=1; }).finally(()=>fs.rmSync(root,{recursive:true,force:true}));