@0xmaxma/claude-gateway 1.8.14 → 2.0.0

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

@@ -0,0 +1,117 @@
+/** A single live task browser per private chat. All reads are session-bound and
+ * serialized with navigation, replacement, and explicit cancellation. */
+export interface TaskBrowserMessage {
+  chatId: string; userId: string; messageId: number; sessionId: string;
+  view: { page?: number; action?: 'detail'; task_id?: string };
+}
+export interface TaskBrowserResult {
+  sessionId: string;
+  task?: { taskId: string; state: string };
+  page?: number;
+}
+export interface TaskBrowserMenu { text: string; reply_markup: unknown }
+interface Entry extends TaskBrowserMessage { fingerprint?: string; retryAt?: number; finished?: boolean }
+interface Dependencies {
+  read(chat: string, user: string, payload: Record<string, unknown>): Promise<TaskBrowserResult>;
+  render(result: TaskBrowserResult): TaskBrowserMenu;
+  send(chat: string, menu: TaskBrowserMenu): Promise<number>;
+  edit(chat: string, id: number, menu: TaskBrowserMenu): Promise<unknown>;
+  remove(chat: string, id: number): Promise<unknown>;
+  close(chat: string, id: number): Promise<unknown>;
+  allowed(chat: string, user: string): boolean;
+  persist(entries: TaskBrowserMessage[]): void;
+  now?: () => number;
+}
+const description = (e: any) => String(e?.description ?? e?.message ?? '');
+const absent = (e: any) => /message to (?:edit|delete) not found|message_id_invalid/i.test(description(e));
+const unchanged = (e: any) => /message is not modified/i.test(description(e));
+export class LiveTaskBrowser {
+  private entries = new Map<string, Entry>();
+  private locks = new Map<string, Promise<unknown>>();
+  private nextEditAt = 0;
+  constructor(private io: Dependencies, restored: TaskBrowserMessage[] = []) {
+    for (const e of restored) {
+      if (e && typeof e === 'object' && /^\d+$/.test(e.chatId) && e.userId === e.chatId && Number.isSafeInteger(e.messageId) && e.messageId > 0 && typeof e.sessionId === 'string' && e.view &&
+        (e.view.action === 'detail' ? typeof e.view.task_id === 'string' : Number.isSafeInteger(e.view.page ?? 0))) this.entries.set(e.chatId, { ...e });
+    }
+  }
+  private now() { return this.io.now?.() ?? Date.now(); }
+  private persist() {
+    this.io.persist([...this.entries.values()].map(({chatId,userId,messageId,sessionId,view}) => ({chatId,userId,messageId,sessionId,view})));
+  }
+  private serial<T>(chat: string, work: () => Promise<T>): Promise<T> {
+    const previous = this.locks.get(chat) ?? Promise.resolve();
+    const job = previous.catch(() => {}).then(work);
+    this.locks.set(chat, job);
+    void job.finally(() => { if (this.locks.get(chat) === job) this.locks.delete(chat); }).catch(() => {});
+    return job;
+  }
+  private async retire(e: Entry) {
+    try { await this.io.remove(e.chatId, e.messageId); }
+    catch (error) {
+      if (!absent(error)) {
+        try { await this.io.close(e.chatId, e.messageId); }
+        catch (closed) { if (!absent(closed) && !unchanged(closed)) throw closed; }
+      }
+    }
+    this.entries.delete(e.chatId); this.persist();
+  }
+  open(chatId: string, userId: string) {
+    return this.serial(chatId, async () => {
+      if (!this.io.allowed(chatId, userId)) throw Error('TASK_BROWSER_UNAUTHORIZED');
+      const result = await this.io.read(chatId, userId, { page: 0 });
+      const menu = this.io.render(result);
+      const previous = this.entries.get(chatId);
+      if (previous) await this.retire(previous);
+      const messageId = await this.io.send(chatId, menu);
+      this.entries.set(chatId, {chatId,userId,messageId,sessionId:result.sessionId,view:{page:result.page ?? 0},fingerprint:JSON.stringify(menu)});
+      this.persist();
+    });
+  }
+  navigate(chatId: string, userId: string, messageId: number, payload: Record<string, unknown>) {
+    return this.serial(chatId, async () => {
+      const e = this.entries.get(chatId);
+      if (!e || e.messageId !== messageId || e.userId !== userId || !this.io.allowed(chatId,userId)) throw Error('TASK_BROWSER_EXPIRED');
+      if (payload.action === 'dismiss') { await this.retire(e); return; }
+      try {
+        const result = await this.io.read(chatId,userId,{...payload,session_id:e.sessionId});
+        // Never repeat a mutation during auto-refresh, even if Telegram edit fails.
+        e.view = result.task ? {action:'detail',task_id:result.task.taskId} : {page:result.page ?? 0};
+        this.persist();
+        await this.update(e,result);
+      } catch (error) { await this.failure(e,error); throw error; }
+    });
+  }
+  private async update(e: Entry, result: TaskBrowserResult) {
+    if (result.sessionId !== e.sessionId) throw Error('TASK_SESSION_CHANGED');
+    const view = result.task ? { action: 'detail' as const, task_id: result.task.taskId } : { page: result.page ?? 0 };
+    if (JSON.stringify(view) !== JSON.stringify(e.view)) { e.view = view; this.persist(); }
+    const finished = !!result.task && ['completed','failed','cancelled'].includes(result.task.state);
+    const menu = this.io.render(result), fingerprint = JSON.stringify(menu);
+    if (fingerprint === e.fingerprint) { e.finished = finished; return; }
+    try { await this.io.edit(e.chatId,e.messageId,menu); }
+    catch (error) { if (!unchanged(error)) throw error; }
+    e.fingerprint = fingerprint; e.retryAt = undefined; e.finished = finished;
+  }
+  private async failure(e: Entry, error: any) {
+    if (description(error).includes('TASK_SESSION_CHANGED')) { await this.retire(e); return; }
+    if (absent(error) || error?.error_code === 403) { this.entries.delete(e.chatId); this.persist(); return; }
+    const retry = Number(error?.parameters?.retry_after);
+    e.retryAt = this.now() + (Number.isFinite(retry) && retry > 0 ? retry * 1000 : 10000);
+    if (retry > 0) this.nextEditAt = Math.max(this.nextEditAt,e.retryAt);
+  }
+  async tick() {
+    // One tick cannot overlap a previous read/edit or user action for this chat.
+    for (const e of [...this.entries.values()]) {
+      if (e.finished || this.locks.has(e.chatId) || this.now() < Math.max(e.retryAt ?? 0,this.nextEditAt)) continue;
+      await this.serial(e.chatId, async () => {
+        if (this.entries.get(e.chatId) !== e) return;
+        if (!this.io.allowed(e.chatId,e.userId)) {
+          this.entries.delete(e.chatId); this.persist(); return;
+        }
+        try { await this.update(e,await this.io.read(e.chatId,e.userId,{...e.view,session_id:e.sessionId})); }
+        catch (error) { await this.failure(e,error).catch(() => {}); }
+      });
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+import { formatTiming } from '../../../dist/orchestration/tasks/timing';
+import { formatTaskElapsed } from './task-elapsed';
+import type { ProcessSample } from '../../../src/orchestration/process-activity';
+import type { ToolOutcome } from '../../../src/orchestration/execution-observation';
+
+export interface TaskDetail {
+  title: string; state: string; startedAt?: number; finishedAt?: number;
+  timing?: Partial<Record<'working' | 'tool' | 'input' | 'queued' | 'other' | 'finished', number>>;
+  timingMeasuredFrom?: number;
+  progress?: string; progressText?: string; question?: string;
+  activityDetails?: { counters: string; status: string; age: number; activeTools: string[];
+    observationStatus?: string; process?: ProcessSample; lastTool?: ToolOutcome; quiet?: boolean };
+}
+function bytes(value: number): string {
+  const unit = value >= 1000000 ? 'MB' : value >= 1000 ? 'KB' : 'B';
+  return `${Number((value / (unit === 'MB' ? 1000000 : unit === 'KB' ? 1000 : 1)).toFixed(2))} ${unit}`;
+}
+export function formatTaskDetail(task: TaskDetail, label: string): string {
+  const activity = task.activityDetails;
+  const progress = task.progressText ?? task.progress;
+  const progressLines = [progress, activity?.activeTools.length ? `Active tools: ${activity.activeTools.join(', ')}` : '', activity ? `Last activity: ${activity.age}s ago.` : '', task.question ? `Waiting for your input:\n${task.question}` : ''].filter(Boolean);
+  const process = activity?.process;
+  const counters = process ? process.available ? [
+    `Processes: ${process.processCount}`,
+    process.cpuTicksDelta !== undefined ? `CPU: +${process.cpuTicksDelta} ticks · Children: ${process.childCpuTicksDelta === undefined ? 'unavailable' : `+${process.childCpuTicksDelta} ticks`}` : 'CPU: unavailable',
+    process.ioAvailable ? `I/O: Read ${process.readBytesDelta === undefined ? 'unavailable' : `+${bytes(process.readBytesDelta)}`} · Write ${process.writeBytesDelta === undefined ? 'unavailable' : `+${bytes(process.writeBytesDelta)}`}` : 'I/O: partially unavailable',
+  ].join('\n') : '' : activity?.counters;
+  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)}`,
+    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')}` : '',
+  ].filter(Boolean).join('\n\n');
+}

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

@@ -0,0 +1 @@
+export { formatTaskElapsed } from '../../../dist/shared/task-elapsed';

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/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.14",
+  "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; });