@0xmaxma/claude-gateway 1.8.13 → 2.0.0

package/mcp/tools/telegram/typing.ts

@@ -24,127 +24,15 @@ import {
   type TurnIncidentEvidence,
 } from '../../../dist/agent/turn-trace.js'
 
-export const TELEGRAM_MAX_CHARS = 4096
-
-/**
- * Telegram rejects a message whose HTML entities are unbalanced, so a chunk cut
- * that falls inside a <pre><code>…</code></pre> block must close the open tags
- * at the end of the chunk and reopen them at the start of the next one.
- * Reserve room for that worst-case suffix (</a></code></pre></b></i>) plus the
- * mirrored reopening prefix so balancing never pushes a chunk past the limit.
- */
-const HTML_BALANCE_HEADROOM = 64
-
-/** Tags toTelegramHtml() emits — the only ones balancing needs to understand. */
-const BALANCED_TAGS = ['b', 'i', 'code', 'pre', 'a'] as const
-
-/**
- * Scan an HTML fragment (as produced by toTelegramHtml — no attributes except
- * <a href>, no self-closing forms) and return the stack of tags still open at
- * the end, as full opening-tag strings in opening order.
- */
-export function openTagStack(html: string): string[] {
-  const stack: string[] = []
-  // Attribute part tolerates '>' inside quoted values (<a href="a>b">).
-  const re = /<(\/?)([a-z]+)((?:\s(?:"[^"]*"|[^>])*)?)>/g
-  let m: RegExpExecArray | null
-  while ((m = re.exec(html)) !== null) {
-    const closing = m[1] === '/'
-    const name = m[2]
-    if (!(BALANCED_TAGS as readonly string[]).includes(name)) continue
-    if (closing) {
-      // toTelegramHtml emits well-nested pairs, so the match is always the top.
-      const top = stack.length - 1
-      if (top >= 0 && /^<([a-z]+)/.exec(stack[top])?.[1] === name) stack.pop()
-    } else {
-      stack.push(`<${name}${m[3] ?? ''}>`)
-    }
-  }
-  return stack
-}
-
-/** Strip Telegram-HTML tags and unescape entities → plain-text equivalent. */
-export function htmlToPlain(html: string): string {
-  return html
-    .replace(/&lt;br\s*\/?&gt;/gi, '\n')
-    .replace(/<[^>]+>/g, '')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&amp;/g, '&')
-}
-
-/**
- * Split text into chunks that fit within Telegram's message size limit.
- * Prefers paragraph → line → space boundaries over hard cuts.
- * When htmlSafe=true, avoids cutting inside an HTML tag (e.g. <code>, <b>) AND
- * keeps every chunk entity-balanced: tags left open at a cut are closed at the
- * chunk's end and reopened at the next chunk's start, so no chunk is ever
- * rejected by Telegram's HTML parser for an unclosed <pre>/<code>/<b>.
- */
-export function chunkText(text: string, limit = TELEGRAM_MAX_CHARS, htmlSafe = false): string[] {
-  if (text.length <= limit) return [text]
-  const out: string[] = []
-  let rest = text
-  const effLimit = htmlSafe ? limit - HTML_BALANCE_HEADROOM : limit
-  // If cut lands inside an open tag (<...>), move cut to before the '<'
-  const avoidMidTag = (cut: number): number => {
-    const tagStart = rest.lastIndexOf('<', cut)
-    const tagEnd = rest.lastIndexOf('>', cut)
-    return tagStart > tagEnd ? tagStart : cut
-  }
-  const closersFor = (open: string[]): string =>
-    open.map((t) => `</${/^<([a-z]+)/.exec(t)![1]}>`).reverse().join('')
-  // Cut at `cut`, balancing tags across the boundary when htmlSafe.
-  const splitAt = (cut: number): { head: string; tail: string } => {
-    let head = rest.slice(0, cut)
-    let tail = rest.slice(cut).replace(/^\n+/, '')
-    if (htmlSafe) {
-      const open = openTagStack(head)
-      if (open.length) {
-        head += closersFor(open)
-        tail = open.join('') + tail
-      }
-    }
-    return { head, tail }
-  }
-  while (rest.length > effLimit) {
-    const para = rest.lastIndexOf('\n\n', effLimit)
-    const line = rest.lastIndexOf('\n', effLimit)
-    const space = rest.lastIndexOf(' ', effLimit)
-    let cut = para > effLimit / 2 ? para : line > effLimit / 2 ? line : space > 0 ? space : effLimit
-    if (htmlSafe) cut = avoidMidTag(cut)
-    let { head, tail } = splitAt(cut)
-    // Forward-progress guard: when the chosen boundary sits right after an
-    // opening tag (e.g. "<b> " + one unbroken >limit token), the reopened tag
-    // prefix can re-add as much as the cut removed and `rest` never shrinks —
-    // an infinite loop that would hang the whole receiver. Retry with a hard
-    // cut at effLimit; if even that cannot shrink (degenerate tag-heavy input,
-    // e.g. a single huge <a href>), emit the remainder as one oversized chunk
-    // and stop — Telegram rejects it and the plain-text retry rescues the
-    // content, which beats hanging the process.
-    if (tail.length >= rest.length) {
-      cut = htmlSafe ? avoidMidTag(effLimit) : effLimit
-      ;({ head, tail } = splitAt(cut))
-      if (tail.length >= rest.length) {
-        out.push(rest)
-        rest = ''
-        break
-      }
-    }
-    out.push(head)
-    rest = tail
-  }
-  if (rest) out.push(rest)
-  return out
-}
+import { TELEGRAM_MAX_CHARS, htmlToPlain, chunkText } from '../../../dist/telegram/chunks.js'
+export { TELEGRAM_MAX_CHARS, openTagStack, htmlToPlain, chunkText } from '../../../dist/telegram/chunks.js'
 
 export const STATUS_MESSAGES = [
   '⏳ Thinking...',
   '🔍 Analyzing your request...',
   '⚙️ Working on it...',
   '📝 Preparing a response...',
-  '🧠 Processing, please wait...',
+  '🧠 Thinking...',
 ]
 
 export const STALLED_TIMEOUT_MS = 300_000  // 5 minutes without heartbeat → warn + stop
@@ -429,6 +317,7 @@ export function createWorkingStateManager(
   botApi: BotApi,
   fsApi: FsApi,
   onIncident?: TurnIncidentSink,
+  mode: 'legacy' | 'orchestration' = 'legacy',
 ) {
   const states = new Map<string, WorkingState>()
 
@@ -645,7 +534,8 @@ export function createWorkingStateManager(
   }
 
   function start(chatId: string): void {
-    if (states.has(chatId)) return
+    // Managed turns use durable orchestration activity, not legacy file heartbeats.
+    if (mode === 'orchestration' || states.has(chatId)) return
 
     fsApi.mkdirSync(typingDir, { recursive: true })
     fsApi.writeFileSync(typingFilePath(chatId), String(Date.now()))

package/mcp/tools/video/module.ts

@@ -553,7 +553,7 @@ export class VideoModule implements ToolModule {
           byok: job.byok ?? false,
           cost: job.cost ?? 0,
           files: [filePath],
-          note: 'Video saved. Deliver it to the user with your channel delivery tool — api_reply/reply (files: [...]). Do NOT open/Read the file to inspect it first; attach it and answer briefly.'
+          note: (process.env.GATEWAY_ORCHESTRATION_ROLE === 'worker' ? 'Video saved. Call task_stage_file with this file path, then report completion. Orchestration handles delivery.' : 'Video saved. Deliver it to the user with your channel delivery tool — api_reply/reply (files: [...]). Do NOT open/Read the file to inspect it first; attach it and answer briefly.')
             + (model ? ` Mention which model made it (${model}).` : ''),
         }),
       }],

package/mcp/tools/wechat/client.ts

@@ -0,0 +1,49 @@
+/**
+ * HTTP client for the gateway's own WeChat REST API — never a direct iLink
+ * call from inside the agent's sandbox. Mirrors `mcp/tools/cron/client.ts`'s
+ * shape: this subprocess has no route to the live long-poll session the main
+ * gateway process holds in memory (per agent), so sending has to go through
+ * that process's own `/wechat/send` route, the same way WhatsApp's Baileys
+ * socket is reached (see src/api/router.ts's `/whatsapp/send` doc comment
+ * for the same reasoning, once that channel lands).
+ */
+
+export class WeChatClient {
+  private readonly baseUrl: string;
+  private readonly agentId: string;
+  private readonly apiKey: string;
+
+  constructor(apiUrl: string, agentId: string, apiKey?: string) {
+    this.baseUrl = apiUrl.replace(/\/$/, '');
+    this.agentId = agentId;
+    this.apiKey = apiKey ?? '';
+  }
+
+  private url(path: string): string {
+    return `${this.baseUrl}/api/v1/agents/${this.agentId}/wechat${path}`;
+  }
+
+  private async request(method: string, path: string, body?: unknown): Promise<unknown> {
+    const headers: Record<string, string> = {};
+    if (body) headers['Content-Type'] = 'application/json';
+    if (this.apiKey) headers['X-Api-Key'] = this.apiKey;
+
+    const res = await fetch(this.url(path), {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`WeChat API ${method} ${path} failed: HTTP ${res.status} ${text}`);
+    }
+
+    const contentType = res.headers.get('content-type') ?? '';
+    return contentType.includes('application/json') ? res.json() : res.text();
+  }
+
+  async send(toId: string, text: string): Promise<void> {
+    await this.request('POST', '/send', { to_id: toId, text });
+  }
+}

package/mcp/tools/wechat/module.ts

@@ -0,0 +1,88 @@
+/**
+ * WeChat outbound tool module — exposes `wechat_reply` to the Claude session.
+ *
+ * WeChat is a ToolModule (reply-only): inbound arrives via the gateway's own
+ * WeChatManager long-poll loop (src/wechat/manager.ts), not here. Unlike
+ * Slack (`mcp/tools/slack/module.ts`), this module cannot talk to the
+ * third-party API directly — the live iLink session (credentials, per-
+ * recipient context tokens) only exists inside the main gateway process, so
+ * every send is proxied through that process's own `/wechat/send` route,
+ * the same reasoning WhatsApp's Baileys socket needs (see
+ * src/api/router.ts's `/whatsapp/send` route once that channel lands, and
+ * `mcp/tools/cron/module.ts` for the same "call back into our own gateway
+ * API" shape this module follows).
+ */
+import type { ToolModule, McpToolDefinition, McpToolResult, ToolVisibility } from '../../types';
+import { WeChatClient } from './client';
+
+export class WeChatModule implements ToolModule {
+  id = 'wechat';
+  toolVisibility: ToolVisibility = 'current-channel';
+
+  private client: WeChatClient | null = null;
+
+  isEnabled(): boolean {
+    return (
+      process.env.GATEWAY_ORIGIN_CHANNEL === 'wechat' &&
+      Boolean(process.env.GATEWAY_API_URL && process.env.GATEWAY_AGENT_ID)
+    );
+  }
+
+  private getClient(): WeChatClient {
+    if (!this.client) {
+      const apiUrl = process.env.GATEWAY_API_URL!;
+      const agentId = process.env.GATEWAY_AGENT_ID!;
+      const apiKey = process.env.GATEWAY_API_KEY;
+      this.client = new WeChatClient(apiUrl, agentId, apiKey);
+    }
+    return this.client;
+  }
+
+  getTools(): McpToolDefinition[] {
+    return [
+      {
+        name: 'wechat_reply',
+        description:
+          'Send a reply to the current WeChat conversation. ' +
+          'Pass chat_id (the WeChat sender id shown in the <channel> tag) and text. ' +
+          'Text-only for now — WeChat media sending is not yet supported.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            chat_id: {
+              type: 'string',
+              description: 'WeChat sender id to send to (the chat_id from the channel turn).',
+            },
+            text: {
+              type: 'string',
+              description: 'Message text.',
+            },
+          },
+          required: ['chat_id', 'text'],
+          additionalProperties: false,
+        },
+      },
+    ];
+  }
+
+  async handleTool(name: string, args: Record<string, unknown>): Promise<McpToolResult> {
+    if (name !== 'wechat_reply') {
+      return { content: [{ type: 'text', text: `unknown tool: ${name}` }], isError: true };
+    }
+    const chatId = args.chat_id as string | undefined;
+    const text = args.text as string | undefined;
+    if (!chatId || !text) {
+      return {
+        content: [{ type: 'text', text: 'wechat_reply failed: chat_id and text are required' }],
+        isError: true,
+      };
+    }
+    try {
+      await this.getClient().send(chatId, text);
+      return { content: [{ type: 'text', text: 'sent' }] };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: 'text', text: `wechat_reply failed: ${msg}` }], isError: true };
+    }
+  }
+}

package/mcp/types.ts

@@ -14,8 +14,13 @@ export type InboundMessage = {
   text: string;
   messageId: string;
   replyToMessageId?: string;
+  repliedText?: string;
+  repliedSender?: string;
+  attachments?: Array<{url:string;name?:string;kind?:string;quoted?:boolean}>;
   threadId?: string;
   attachmentFileId?: string;
+  attachmentKind?: 'voice' | 'file';
+  controlMessageId?: string;
   ts: number;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "1.8.13",
+  "version": "2.0.0",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",
@@ -21,6 +21,7 @@
     "!mcp/node_modules",
     "!mcp/node_modules/**",
     "README.md",
+    "scripts/orchestration/",
     "config.template.json"
   ],
   "publishConfig": {

package/scripts/orchestration/bench-store.cjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// Local durability latency, not a provider/model/network performance claim.
+const { mkdtempSync, rmSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+const { performance } = require('node:perf_hooks');
+const { OrchestrationStore } = require('../../dist/orchestration/store');
+const { DecisionService } = require('../../dist/orchestration/decisions');
+const { TaskService } = require('../../dist/orchestration/tasks/service');
+const root = mkdtempSync(join(tmpdir(), 'orchestration-bench-'));
+const store = new OrchestrationStore(join(root, 'orchestration.db'), 'fixture');
+const decisions = new DecisionService(store), tasks = new TaskService(store, { tasks: { maxQueuedPerAgent: 1000, maxQueuedPerConversation: 1000 } });
+const inputTimes = [], commandTimes = [];
+const scope = { agentId: 'fixture', agentSessionId: 'agentSession', source: 'api', accountId: 'key', chatId: 'chat', threadKey: '', principalId: 'owner' };
+try {
+  for (let i = 0; i < 200; i++) {
+    let start = performance.now();
+    const receipt = store.acceptInput({ scope, text: `Task ${i}`, ingressKey: String(i) });
+    inputTimes.push(performance.now() - start);
+    const decision = decisions.begin(receipt.conversationId, 'owner', [receipt.inputId]);
+    start = performance.now();
+    tasks.spawn({ ...receipt, ...decision, principalId: 'owner', actionId: `action-${i}`, execute: true, writeMemory: false }, { title: `Task ${i}`, targetProfile: 'default-worker', instructions: 'Do the fixture task' });
+    commandTimes.push(performance.now() - start);
+    decisions.finish(decision, 'Queued.');
+  }
+  const summarize = values => { values.sort((a,b) => a-b); return { n: values.length, p50Ms: values[Math.floor(values.length * .50)], p95Ms: values[Math.floor(values.length * .95)], maxMs: values.at(-1) }; };
+  const input = summarize(inputTimes), command = summarize(commandTimes);
+  console.log(JSON.stringify({ node: process.version, platform: process.platform, sqlite: 'WAL, synchronous=FULL', input, command, pass: input.p95Ms <= 250 && command.p95Ms <= 250 }, null, 2));
+  process.exitCode = input.p95Ms <= 250 && command.p95Ms <= 250 ? 0 : 1;
+} finally { store.close(); rmSync(root, { recursive: true, force: true }); }

package/scripts/orchestration/inspect.cjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// Read-only operator inspection. Never print tickets, prompts or credentials.
+const { DatabaseSync } = require('node:sqlite');
+if (process.argv.length !== 3) { console.error('Usage: node scripts/orchestration/inspect.cjs /path/to/agent/orchestration.db'); process.exit(2); }
+const db = new DatabaseSync(process.argv[2], { readOnly: true });
+try {
+  const all = sql => db.prepare(sql).all();
+  console.log(JSON.stringify({
+    conversations: all('SELECT status,COUNT(*) count FROM conversations GROUP BY status'),
+    inputs: all('SELECT status,COUNT(*) count FROM conversation_inputs GROUP BY status'),
+    tasks: all('SELECT state,COUNT(*) count FROM tasks GROUP BY state'),
+    outbox: all('SELECT kind,state,COUNT(*) count FROM outbox GROUP BY kind,state'),
+    resources: all('SELECT mode,lifecycle_state,COUNT(*) count FROM task_resources GROUP BY mode,lifecycle_state'),
+    reconcile: all("SELECT t.id,t.state,t.active_attempt_id,r.worktree_path FROM tasks t LEFT JOIN task_resources r ON r.task_id=t.id WHERE t.state='needs_reconciliation'"),
+  }, null, 2));
+} finally { db.close(); }

package/scripts/orchestration/probe-profile.cjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// Opt-in live P0 probe. Only disposable workspace data enters the prompt.
+const { mkdtempSync, writeFileSync, mkdirSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join, resolve } = require('node:path');
+const { spawn, execFileSync } = require('node:child_process');
+const { randomUUID } = require('node:crypto');
+const { loadWorkspace } = require('../../dist/agent/workspace-loader');
+const { SessionStore } = require('../../dist/session/store');
+const { runtimeProfileArgs, AGENT_OVERLAY } = require('../../dist/session/runtime-profile');
+(async () => {
+  const root = mkdtempSync(join(tmpdir(), 'gateway-orchestration-probe-'));
+  const workspace = join(root, 'probe', 'workspace');
+  mkdirSync(workspace, { recursive: true });
+  for (const [file, content] of Object.entries({
+    'AGENTS.md': 'You are a disposable conversation profile test fixture.',
+    'IDENTITY.md': 'Your fixture identity is CitrineHeron.',
+    'SOUL.md': 'Be concise and truthful.',
+    'USER.md': 'The fixture user prefers Thai.',
+    'MEMORY.md': 'The fixture project codeword is cobalt-orchid.',
+  })) writeFileSync(join(workspace, file), content);
+  const loaded = await loadWorkspace(workspace);
+  mkdirSync(join(workspace, 'memory'));
+  writeFileSync(join(workspace, 'memory', 'fixture.md'), 'Archived marker: silver-pine.');
+  writeFileSync(join(workspace, 'CLAUDE.md'), loaded.systemPrompt);
+  const sessionId = randomUUID();
+  const store = new SessionStore(root);
+  await store.appendMessage('probe', sessionId, { role: 'user', content: 'Our previous fixture choice was amber-bridge.', ts: Date.now() });
+  const history = await store.loadSession('probe', sessionId);
+  const mcpConfigPath = join(root, 'mcp.json');
+  writeFileSync(mcpConfigPath, JSON.stringify({ mcpServers: { gateway: { command: 'bun',
+    args: [resolve(__dirname, '../../mcp/server.ts')],
+    env: { GATEWAY_ORCHESTRATION_ROLE: 'agent', GATEWAY_WORKSPACE_DIR: workspace, GATEWAY_ORCHESTRATION_TICKET_FILE: join(root, 'unused-ticket.json') },
+  } } }));
+  const args = ['--print', '--verbose', '--input-format', 'stream-json', '--output-format', 'stream-json',
+    '--include-partial-messages', '--session-id', sessionId, '--dangerously-skip-permissions',
+    ...runtimeProfileArgs({ role: 'agent', mcpConfigPath, overlay: AGENT_OVERLAY, context: loaded.systemPrompt }, [])];
+  const child = spawn('claude', args, { cwd: workspace, env: { ...process.env }, stdio: ['pipe', 'pipe', 'pipe'] });
+  let buffer = '', stderr = '', inventory, result;
+  const timer = setTimeout(() => child.kill('SIGTERM'), 45000);
+  child.stdout.on('data', chunk => {
+    buffer += chunk;
+    let end;
+    while ((end = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
+      try {
+        const event = JSON.parse(line);
+        if (event.type === 'system' && event.subtype === 'init') inventory = { tools: event.tools, mcp_servers: event.mcp_servers, session_id: event.session_id };
+        if (event.type === 'result') { result = { subtype: event.subtype, result: event.result, is_error: event.is_error }; child.stdin.end(); }
+      } catch {}
+    }
+  });
+  child.stderr.on('data', chunk => { stderr += chunk; });
+  child.stdin.write(JSON.stringify({ type: 'user', message: { role: 'user', content: `Fixture history: ${JSON.stringify(history)}\nWhat are your fixture identity, project codeword and previous choice? Use memory_get to retrieve memory/fixture.md and report its archived marker. State whether Read or Bash tools are available; do not create any tasks.` } }) + '\n');
+  child.stdin.end();
+  child.on('close', (code, signal) => {
+    clearTimeout(timer);
+    const report = { cli: execFileSync('claude', ['--version'], { encoding: 'utf8' }).trim(), backend: 'headless', workspace, sessionId,
+      inventory, result, exitCode: code, signal, stderrPresent: Boolean(stderr),
+      contextPassed: Boolean(result?.result && ['CitrineHeron', 'cobalt-orchid', 'amber-bridge', 'silver-pine'].every(s => result.result.includes(s))),
+      inventoryPassed: Array.isArray(inventory?.tools) && inventory.tools.length === 7 && inventory.tools.every(name => /^mcp__gateway__(task_(spawn|status|cancel|update|answer)|memory_(search|get))$/.test(name)) };
+    const target = process.argv[2];
+    if (target) writeFileSync(resolve(target), JSON.stringify(report, null, 2) + '\n');
+    console.log(JSON.stringify(report, null, 2));
+    process.exitCode = report.contextPassed && report.inventoryPassed && code === 0 ? 0 : 1;
+  });
+})().catch(error => { console.error(error.message); process.exitCode = 1; });

package/scripts/orchestration/reconcile.cjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// Explicit offline operator resolution; no automatic liveness/side-effect guess.
+const { dirname, join } = require('node:path');
+const { readFileSync } = require('node:fs');
+const { OrchestrationStore } = require('../../dist/orchestration/store');
+const { TaskService } = require('../../dist/orchestration/tasks/service');
+const { acquireInstanceLock } = require('../../dist/orchestration/instance-lock');
+const [database, agentId, taskId, state, evidenceFile] = process.argv.slice(2);
+if (!evidenceFile || !['queued', 'failed', 'cancelled'].includes(state)) {
+  console.error('Usage: node scripts/orchestration/reconcile.cjs ORCHESTRATION_DB AGENT_ID TASK_ID queued|failed|cancelled EVIDENCE_FILE');
+  console.error('Stop the gateway and verify process liveness and side effects first. queued explicitly authorizes another attempt.');
+  process.exit(2);
+}
+let release, store;
+try {
+  release = acquireInstanceLock(join(dirname(database), 'orchestration-instance.lock'));
+  store = new OrchestrationStore(database, agentId);
+  const result = new TaskService(store).reconcile(taskId, state, readFileSync(evidenceFile, 'utf8'));
+  console.log(JSON.stringify({ taskId: result.taskId, state: result.state, stateVersion: result.stateVersion }));
+} catch (error) { console.error(error.code || error.message); process.exitCode = 1; }
+finally { store?.close(); release?.(); }

package/scripts/orchestration/smoke-elevenlabs.cjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// Paid, bounded provider smoke: two short TTS requests, one file STT, one voice turn.
+// npm run build && node scripts/orchestration/smoke-elevenlabs.cjs /path/to/elevenlabs.env [voice-id]
+// Uses a synthetic summary fixture; does not run agent inference or test hardware.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const { join } = require('node:path');
+const { tmpdir } = require('node:os');
+const { ElevenLabsTts } = require('../../dist/voice/providers/elevenlabs-tts');
+const { ElevenLabsStt } = require('../../dist/voice/providers/elevenlabs-stt');
+const { transcribeVoiceNote } = require('../../dist/voice/notes');
+const { VoiceSession } = require('../../dist/voice/session');
+const { decodeVoiceFrame } = require('../../dist/voice/protocol');
+const { splitSpeechResponse } = require('../../dist/orchestration/speech');
+const { PCM16 } = require('../../dist/voice/types');
+const voiceSurfaces = {
+  display: 'ตัวอย่างผลทดสอบ: แก้ฟังก์ชันจากลบเป็นบวกสำเร็จ และทดสอบผ่านแล้ว รายละเอียดนี้เป็นข้อมูลจำลองสำหรับตรวจการสรุปเสียงเท่านั้น '.repeat(4),
+  spoken: 'ทดสอบสำเร็จแล้ว แก้ฟังก์ชันจากลบเป็นบวก และรันเทสต์ผ่านครับ',
+};
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+function wav(pcm) {
+  const h = Buffer.alloc(44); h.write('RIFF'); h.writeUInt32LE(36 + pcm.length, 4); h.write('WAVEfmt ', 8);
+  h.writeUInt32LE(16, 16); h.writeUInt16LE(1, 20); h.writeUInt16LE(1, 22); h.writeUInt32LE(16000, 24);
+  h.writeUInt32LE(32000, 28); h.writeUInt16LE(2, 32); h.writeUInt16LE(16, 34); h.write('data', 36); h.writeUInt32LE(pcm.length, 40);
+  return Buffer.concat([h, pcm]);
+}
+(async () => {
+  if (process.argv[2]) process.loadEnvFile(process.argv[2]);
+  const key = process.env.ELEVENLABS_API_KEY; assert(key, 'ELEVENLABS_API_KEY required');
+  const voiceId = process.argv[3] || 'JBFqnCBsd6RMkjVDRZzb';
+  const root = fs.mkdtempSync(join(tmpdir(), 'orchestration-elevenlabs-'));
+  const report = { date: new Date().toISOString(), voiceId, root, pass: false,
+    limits: ['Synthetic microphone; no hardware, echo or platform-account delivery tested.', 'Synthetic summary fixture, not a fresh agent inference.', 'No quota exhaustion or outage injected.'] };
+  let session;
+  const watchdog = setTimeout(() => { console.error('SMOKE_DEADLINE'); process.exit(1); }, 120000);
+  try {
+    const surfaces = splitSpeechResponse(JSON.stringify({ display_text: voiceSurfaces.display, spoken_text: voiceSurfaces.spoken }));
+    assert(surfaces.spoken && surfaces.spoken.length <= 600 && surfaces.display.length > surfaces.spoken.length);
+    const tts = new ElevenLabsTts(key), stt = new ElevenLabsStt(key);
+    const started = Date.now(), chunks = [];
+    report.tts = { model: 'eleven_v3_conversational', characters: surfaces.spoken.length };
+    for await (const chunk of tts.synthesize({ text: (async function* () { yield surfaces.spoken; })(), voiceId, language: 'th', outputFormat: PCM16, signal: AbortSignal.timeout(40000) })) {
+      if (!chunks.length) report.tts.firstAudioMs = Date.now() - started;
+      chunks.push(chunk.bytes); assert(chunks.reduce((n, c) => n + c.length, 0) <= 960000, 'Audio exceeds 30-second bound');
+    }
+    const pcm = Buffer.concat(chunks); assert(pcm.length > 3200 && pcm.some(b => b));
+    Object.assign(report.tts, { durationMs: Date.now() - started, audioSeconds: pcm.length / 32000, chunks: chunks.length });
+    const path = join(root, 'summary.wav'); fs.writeFileSync(path, wav(pcm), { mode: 0o600 });
+    console.log(JSON.stringify({ stage: 'tts', ...report.tts }));
+    const noteStart = Date.now();
+    const transcript = await transcribeVoiceNote(path, { provider: 'elevenlabs', model: 'scribe_v2', language: 'th' });
+    assert(/สำเร็จ/.test(transcript) && /บวก/.test(transcript), 'Thai file transcript lost key summary facts');
+    report.note = { model: 'scribe_v2', transcript, durationMs: Date.now() - noteStart };
+    console.log(JSON.stringify({ stage: 'file-stt', ...report.note }));
+    const controls = [], spokenInputs = [], output = []; let listening, played = 0, submittedText;
+    const tracedTts = { id: tts.id, capabilities: tts.capabilities, synthesize: options => tts.synthesize({ ...options, text: (async function* () {
+      for await (const text of options.text) { spokenInputs.push(text); assert.equal(text, surfaces.spoken); yield text; }
+    })() }) };
+    session = new VoiceSession(stt, tracedTts, voiceId, {
+      control: c => { controls.push(c); if (c.type === 'voice.state' && c.state === 'listening') listening = c; },
+      audio: bytes => { const frame = decodeVoiceFrame(bytes); output.push(frame.audio); played += frame.audio.length / 2; session.progress(frame.epoch, played); },
+      bufferedBytes: () => 0,
+    }, async text => {
+      submittedText = text;
+      assert(/สำเร็จ/.test(text) && /บวก/.test(text), 'Realtime transcript lost key summary facts');
+      return { inputId: 'live-summary-proof', response: Promise.resolve(surfaces.display), responseId: () => 'summary-proof',
+        stream: (async function* () { yield { responseId: 'summary-proof', text: surfaces.spoken }; })() };
+    }, () => {}, { language: 'th', silenceCommitMs: 650, finalizationTimeoutMs: 15000, maxUtteranceMs: 60000, maxBufferedAudioMs: 1500 });
+    await session.start(); const turn = listening; let sequence = 0;
+    const mic = Buffer.concat([pcm, Buffer.alloc(16000)]);
+    for (let offset = 0; offset < mic.length; offset += 3200) {
+      await session.audio({ generation: turn.generation, epoch: turn.epoch, sequence: ++sequence, segmentId: turn.utterance_id, audio: mic.subarray(offset, offset + 3200) });
+      await sleep(100);
+    }
+    const commitStart = Date.now(); await session.commit(sequence);
+    const deadline = Date.now() + 40000;
+    while (!controls.some(c => c.type === 'playback.end' || c.type === 'voice.error') && Date.now() < deadline) await sleep(20);
+    assert.deepEqual(controls.filter(c => c.type === 'voice.error'), []);
+    assert(controls.some(c => c.type === 'playback.end'), 'Missing final audio');
+    assert(controls.some(c => c.type === 'response.text' && c.text === surfaces.display && c.final));
+    assert.deepEqual(spokenInputs, [surfaces.spoken]); assert(output.length > 0);
+    report.voiceSession = { transcript: submittedText, partials: controls.filter(c => c.type === 'stt.partial').length,
+      displayCharacters: surfaces.display.length, ttsCharacters: spokenInputs.join('').length, audioSeconds: played / 16000,
+      commitToPlaybackEndMs: Date.now() - commitStart, nextTurnListening: listening.utterance_id !== turn.utterance_id, fullReportExcludedFromTts: true };
+    fs.writeFileSync(join(root, 'playback.wav'), wav(Buffer.concat(output)), { mode: 0o600 });
+    assert(report.voiceSession.nextTurnListening); report.pass = true;
+  } catch (error) { report.error = { code: error.code, message: String(error.message).replaceAll(key, '[redacted]') }; }
+  finally { await session?.close(); clearTimeout(watchdog); fs.writeFileSync(join(root, 'report.json'), JSON.stringify(report, null, 2), { mode: 0o600 }); console.log(JSON.stringify(report, null, 2)); }
+  process.exitCode = report.pass ? 0 : 1;
+})().catch(error => { console.error(error.code || error.name); process.exitCode = 1; });

package/scripts/orchestration/smoke-media.cjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// Real Claude CLI with a local image-service fixture; no live image-provider claim.
+const { mkdtempSync, mkdirSync, writeFileSync, readFileSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { randomUUID } = require('node:crypto');
+const { createServer } = require('node:http');
+const { once } = require('node:events');
+const { loadWorkspace } = require('../../dist/agent/workspace-loader');
+const { SessionStore } = require('../../dist/session/store');
+const { SessionProcess } = require('../../dist/session/process');
+const { HistoryDB } = require('../../dist/history/db');
+const { AgentOrchestrationRuntime } = require('../../dist/orchestration/runtime');
+(async () => {
+  const root = mkdtempSync(join(tmpdir(), 'gateway-orchestration-media-'));
+  const agentDir = join(root, 'agents', 'probe'), workspace = join(agentDir, 'workspace'), project = join(root, 'fixture-project');
+  mkdirSync(workspace, { recursive: true }); mkdirSync(project);
+  for (const [file, value] of Object.entries({ 'AGENTS.md': 'You are an engineering assistant. Follow the agent role.',
+    'IDENTITY.md': 'Name: CitrineHeron', 'SOUL.md': 'Be concise.', 'MEMORY.md': 'Project codeword: cobalt-orchid.' })) writeFileSync(join(workspace, file), value);
+  const loaded = await loadWorkspace(workspace); writeFileSync(join(workspace, 'CLAUDE.md'), loaded.systemPrompt);
+  const png = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+j3xkAAAAASUVORK5CYII=';
+  let generated = 0;
+  const imageServer = createServer(async (req, res) => {
+    for await (const _chunk of req) { /* consume the fixture request */ }
+    res.setHeader('Content-Type', 'application/json');
+    if (req.method === 'POST') { generated++; res.statusCode = 202; res.end(JSON.stringify({ task_id: 'fixture-job', status: 'queued' })); }
+    else if (req.url.includes('/jobs/')) res.end(JSON.stringify({ task_id: 'fixture-job', status: 'done', provider: 'fixture', model: 'fixture-image', images: [png] }));
+    else res.end(JSON.stringify({ data: [{ id: 'fixture-image', type: 'image', supports_image_ref: false }] }));
+  });
+  imageServer.listen(0, '127.0.0.1'); await once(imageServer, 'listening');
+  process.env.IMAGE_BASE_URL = `http://127.0.0.1:${imageServer.address().port}`;
+  process.env.IMAGE_API_KEY = 'fixture-only';
+  const agent = { id: 'probe', description: 'real CLI with fixture image provider', workspace, env: '', claude: { model: process.env.ORCHESTRATION_SMOKE_MODEL || 'sonnet', extraFlags: [] },
+    orchestration: { enabled: true, conversation: { decisionTimeoutMs: 45000 }, tasks: { defaultTimeoutMs: 120000 } } };
+  const gateway = { gateway: { orchestration: true, headless: true, logDir: join(root, 'logs'), timezone: 'UTC' }, agents: [agent] };
+  const sessions = new SessionStore(join(root, 'agents')), history = HistoryDB.forDir(agentDir, 'probe');
+  let runtime;
+  const host = { createAgentSession: async (sessionId, profile) => new SessionProcess(sessionId, 'api', agent, gateway, sessions, undefined, profile), releaseAgentSession: async (_, p) => p.stop() };
+  const report = { root, cli: execFileSync('claude', ['--version'], { encoding: 'utf8' }).trim(), events: [] };
+  try {
+    runtime = await AgentOrchestrationRuntime.open(agent, gateway, agentDir, sessions, history, host);
+    const scope = { agentId: 'probe', agentSessionId: randomUUID(), source: 'api', accountId: 'fixture', chatId: 'fixture', threadKey: '', principalId: 'fixture' };
+    const send = async text => {
+      const start = Date.now();
+      const answer = await runtime.send({ scope, text, requestId: randomUUID() }, { execute: true, writeMemory: false }, { timeoutMs: 45000 });
+      report.events.push({ answer, durationMs: Date.now() - start });
+    };
+    await send('Create exactly one media-worker task: use generate_image with model fixture-image and prompt a tiny red square, then task_stage_file on the generated file. Also create a document named receipt.txt containing exactly DOCUMENT_FIXTURE_OK and stage it. Do not use a project repository. Queue now and end the response.');
+    report.afterDispatch = runtime.store.all('SELECT state,snapshot_json FROM tasks').map(r => JSON.parse(r.snapshot_json));
+    await send('What is your name and our project codeword? Also report the current task status from the saved snapshot.');
+    report.afterFollowup = runtime.store.all('SELECT state,snapshot_json FROM tasks').map(r => JSON.parse(r.snapshot_json));
+    const deadline = Date.now() + 140000;
+    while (Date.now() < deadline) {
+      const task = runtime.store.all('SELECT snapshot_json FROM tasks').map(r => JSON.parse(r.snapshot_json))[0];
+      if (!task || ['completed', 'failed', 'needs_reconciliation', 'cancelled'].includes(task.state)) { report.task = task; break; }
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    await send('Report the task result and actual test evidence.');
+    const paths = runtime.responseFiles(scope.agentSessionId);
+    report.attachments = paths;
+    report.generatedCalls = generated;
+    const buffers = paths.map(ref => readFileSync(join(agentDir, ref)));
+    report.imageBytesMatch = buffers.some(bytes => bytes.equals(Buffer.from(png, 'base64')));
+    report.documentBytesMatch = buffers.some(bytes => bytes.toString().trim() === 'DOCUMENT_FIXTURE_OK');
+    report.pass = report.task?.state === 'completed' && paths.length === 2 && report.imageBytesMatch && report.documentBytesMatch && generated === 1;
+  } catch (error) { report.error = { message: error.message, code: error.code }; }
+  finally { await runtime?.close(); await new Promise(resolve => imageServer.close(resolve)); writeFileSync(join(root, 'report.json'), JSON.stringify(report, null, 2)); console.log(JSON.stringify(report, null, 2)); }
+  process.exit(report.pass ? 0 : 1);
+})().catch(error => { console.error(error.message); process.exit(1); });