@animalabs/connectome-host 0.3.9 → 0.3.10

package/src/tui.ts

@@ -66,6 +66,17 @@ interface TokenUsage {
   output: number;
   cacheRead: number;
   cacheWrite: number;
+  /** Session cost estimate from the framework's UsageTracker, when priced. */
+  cost?: { total: number; currency: string };
+}
+
+/** One active operator alert from the ops:alert pipeline, keyed
+ *  `${agent}:${kind}` (fleet-child alerts prefix the child name). */
+interface OpsAlertEntry {
+  kind: string;
+  agent: string;
+  message: string;
+  count: number;
 }
 
 interface TuiState {
@@ -84,6 +95,10 @@ interface TuiState {
   peekTarget: string | null;
   /** Name of the child process being peeked at (peek-proc mode). */
   peekProcTarget: string | null;
+  /** When set, peek-proc is filtered to this one agent inside the child —
+   *  the honest per-agent view for agents and sub-subagents living in a
+   *  fleet child. Null = whole-process stream. */
+  peekProcAgent: string | null;
   /** True while we're waiting for the user to resolve a pending /quit with children still running. */
   pendingQuitConfirm: boolean;
 }
@@ -169,9 +184,35 @@ export async function runTui(app: AppContext): Promise<void> {
     tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
     peekTarget: null,
     peekProcTarget: null,
+    peekProcAgent: null,
     pendingQuitConfirm: false,
   };
 
+  /** Active ops alerts (quarantine klaxon, refusal streaks, …), keyed
+   *  `${agent}:${kind}`. Drives the status-bar ⚠ segment; each firing also
+   *  prints a chat line so the alert exists in scrollback. */
+  const opsAlerts = new Map<string, OpsAlertEntry>();
+
+  function handleOpsAlert(kind: string, agent: string, message: string): void {
+    // All-clears travel as a distinct `<kind>-clear` kind (the alarm kind's
+    // ops cooldown must never swallow the stand-down). Remove the base alert
+    // and announce the recovery instead of adding a row.
+    if (kind.endsWith('-clear')) {
+      const baseKey = `${agent}:${kind.slice(0, -'-clear'.length)}`;
+      if (opsAlerts.delete(baseKey)) {
+        addLine(`✓ [${agent}] ${kind}: ${message}`, CYAN);
+        updateStatus();
+      }
+      return;
+    }
+    const key = `${agent}:${kind}`;
+    const existing = opsAlerts.get(key);
+    opsAlerts.set(key, { kind, agent, message, count: (existing?.count ?? 0) + 1 });
+    const times = existing ? ` (×${existing.count + 1})` : '';
+    addLine(`⚠ [${agent}] ${kind}${times}: ${message}`, RED);
+    updateStatus();
+  }
+
   let streaming = false;
   let currentStreamText: TextRenderable | null = null;
   let backgrounded = false;       // researcher pushed to background via Ctrl+B
@@ -370,7 +411,10 @@ export async function runTui(app: AppContext): Promise<void> {
   }
 
   function updateStatus() {
-    statusLeft.content = formatStatusLeft(state, SPINNER[spinnerFrame], streamOutputTokens);
+    statusLeft.content = formatStatusLeft(state, SPINNER[spinnerFrame], streamOutputTokens, opsAlerts.size);
+    // An active ops alert repaints the whole left segment — a one-cell glyph
+    // in default gray is exactly the kind of signal that gets scrolled past.
+    statusLeft.fg = opsAlerts.size > 0 ? RED : GRAY;
     statusRight.content = formatTokens(state.tokens, verboseChat) + formatMemStats(getRootCM());
   }
 
@@ -849,9 +893,7 @@ export async function runTui(app: AppContext): Promise<void> {
         const fc = fleetMod?.getChildren().get(node.fleetChildName!);
         hints = fc?.status === 'ready' ? '  ⏎:fold p:peek Del:stop' : '  ⏎:fold';
       } else if (node.kind === 'fleet-child-agent') {
-        // Per-agent peek isn't separately supported yet; peek opens the
-        // owning child process's stream, which still contains this agent's events.
-        hints = '  ⏎:fold p:peek-proc';
+        hints = '  ⏎:fold p:peek';
       } else {
         hints = '  ⏎:fold';
       }
@@ -976,12 +1018,36 @@ export async function runTui(app: AppContext): Promise<void> {
     const name = state.peekProcTarget;
     if (!name || !fleetMod) return;
     const child = fleetMod.getChildren().get(name);
+    const agentFilter = state.peekProcAgent ?? undefined;
+    const key = procLogKey(name, agentFilter);
 
     const lines: FleetLine[] = [];
-    lines.push({ text: `─── Peek proc: ${name} ──────────────── Esc:back ───`, color: GRAY });
+    const title = agentFilter ? `Peek: ${name} › ${agentFilter}` : `Peek proc: ${name}`;
+    lines.push({ text: `─── ${title} ──────────────── Esc:back ───`, color: GRAY });
     lines.push({ text: '', color: GRAY });
 
-    if (child) {
+    if (child && agentFilter) {
+      // Per-agent header: the reducer node carries the honest phase/tokens/
+      // task for this one agent inside the child.
+      const rn = treeAggregator?.getChildNodes(name).find(n => n.name === agentFilter);
+      if (rn) {
+        const elapsed = rn.startedAt ? Math.floor(((rn.completedAt ?? Date.now()) - rn.startedAt) / 1000) : 0;
+        const phaseColor = rn.status === 'failed' ? RED
+          : rn.phase === 'idle' || rn.phase === 'done' || rn.phase === 'cancelled' ? DIM_GRAY
+          : PHASE_COLOR[rn.phase as SubagentPhase] ?? CYAN;
+        const ctx = rn.tokens.input > 0 ? `  ${fmtK(rn.tokens.input)}ctx` : '';
+        lines.push({ text: `  ${rn.phase}  ${elapsed}s  ${rn.toolCallsCount} tool calls${ctx}`, color: phaseColor });
+        if (rn.task) {
+          const task = rn.task.length > 70 ? rn.task.slice(0, 67) + '...' : rn.task;
+          lines.push({ text: `  task: ${task}`, color: GRAY });
+        }
+        if (rn.parent) {
+          lines.push({ text: `  parent: ${rn.parent} (in ${name})`, color: DIM_GRAY });
+        }
+      } else {
+        lines.push({ text: `  (agent not currently tracked in ${name} — events stream as they arrive)`, color: DIM_GRAY });
+      }
+    } else if (child) {
       const elapsed = Math.floor((Date.now() - child.startedAt) / 1000);
       const min = Math.floor(elapsed / 60);
       const sec = elapsed % 60;
@@ -1002,7 +1068,7 @@ export async function runTui(app: AppContext): Promise<void> {
 
     lines.push({ text: '', color: GRAY });
 
-    const log = procPeekLogs.get(name);
+    const log = procPeekLogs.get(key);
     if (log && log.length > 0) {
       const maxLines = Math.max(10, renderer.terminalHeight - 10);
       const tail = log.slice(-maxLines);
@@ -1013,11 +1079,13 @@ export async function runTui(app: AppContext): Promise<void> {
         lines.push({ text: `  ${entry.text}`, color: entry.color });
       }
     } else {
-      lines.push({ text: '  (no events yet — child may be idle)', color: DIM_GRAY });
+      lines.push({ text: agentFilter
+        ? '  (no events from this agent yet)'
+        : '  (no events yet — child may be idle)', color: DIM_GRAY });
     }
 
     // In-progress token line (not yet flushed to log) — shows live streaming output.
-    const pending = procPeekTokenLine.get(name);
+    const pending = procPeekTokenLine.get(key);
     if (pending) {
       lines.push({ text: `  ${pending}`, color: WHITE });
     }
@@ -1032,19 +1100,32 @@ export async function runTui(app: AppContext): Promise<void> {
     }
   }
 
-  function enterPeekProc(name: string): void {
+  /**
+   * Peek a fleet child's live event stream. With `agentFilter` set, the view
+   * narrows to that one agent inside the child — the honest per-agent peek
+   * for fleet-child agents and their subagents (sub-subagents from the
+   * parent's point of view). Events on the fleet IPC carry `agentName`
+   * verbatim from the child's framework traces, so the filter sees exactly
+   * what a local peek of that agent would.
+   */
+  function enterPeekProc(name: string, agentFilter?: string): void {
     if (!fleetMod) return;
     const child = fleetMod.getChildren().get(name);
     if (!child) return;
 
     state.peekProcTarget = name;
+    state.peekProcAgent = agentFilter ?? null;
+    const key = procLogKey(name, agentFilter);
+    const matches = (evt: WireEvent): boolean =>
+      !agentFilter || (evt as { agentName?: string }).agentName === agentFilter;
 
     // Seed the log from the child's existing event buffer so the user
     // doesn't have to wait for the next event to see history.
-    if (!procPeekLogs.has(name)) procPeekLogs.set(name, []);
-    const log = procPeekLogs.get(name)!;
+    if (!procPeekLogs.has(key)) procPeekLogs.set(key, []);
+    const log = procPeekLogs.get(key)!;
     if (log.length === 0) {
       for (const evt of child.events) {
+        if (!matches(evt)) continue;
         const formatted = formatWireEvent(evt);
         if (formatted) log.push(formatted);
       }
@@ -1055,39 +1136,39 @@ export async function runTui(app: AppContext): Promise<void> {
     // than one log entry per token.
     if (procPeekUnsub) { procPeekUnsub(); procPeekUnsub = null; }
     procPeekUnsub = fleetMod.onChildEvent(name, (_childName, evt) => {
+      if (!matches(evt)) return;
       const type = typeof evt.type === 'string' ? evt.type : '';
+      const active = state.viewMode === 'peek-proc'
+        && state.peekProcTarget === name
+        && state.peekProcAgent === (agentFilter ?? null);
 
       if (type === 'inference:tokens') {
         const content = (evt as { content?: string }).content ?? '';
         if (!content) return;
-        const prev = procPeekTokenLine.get(name) ?? '';
+        const prev = procPeekTokenLine.get(key) ?? '';
         const merged = prev + content;
         const parts = merged.split('\n');
         // Flush completed lines (everything except the last segment).
         for (let i = 0; i < parts.length - 1; i++) {
-          if (parts[i]!.trim()) appendProcPeekLog(name, parts[i]!, WHITE);
-        }
-        procPeekTokenLine.set(name, parts[parts.length - 1]!);
-        if (state.viewMode === 'peek-proc' && state.peekProcTarget === name) {
-          updatePeekProcView();
+          if (parts[i]!.trim()) appendProcPeekLog(key, parts[i]!, WHITE);
         }
+        procPeekTokenLine.set(key, parts[parts.length - 1]!);
+        if (active) updatePeekProcView();
         return;
       }
 
       // Non-token event: flush any pending token line first so its text
       // doesn't get visually chopped by subsequent log entries.
-      const pending = procPeekTokenLine.get(name);
+      const pending = procPeekTokenLine.get(key);
       if (pending?.trim()) {
-        appendProcPeekLog(name, pending, WHITE);
+        appendProcPeekLog(key, pending, WHITE);
       }
-      procPeekTokenLine.delete(name);
+      procPeekTokenLine.delete(key);
 
       const formatted = formatWireEvent(evt);
       if (!formatted) return;
-      appendProcPeekLog(name, formatted.text, formatted.color);
-      if (state.viewMode === 'peek-proc' && state.peekProcTarget === name) {
-        updatePeekProcView();
-      }
+      appendProcPeekLog(key, formatted.text, formatted.color);
+      if (active) updatePeekProcView();
     });
 
     switchView('peek-proc');
@@ -1098,13 +1179,15 @@ export async function runTui(app: AppContext): Promise<void> {
     // Flush any in-progress token line into the log before clearing it so
     // re-entering peek-proc doesn't lose the last few tokens mid-stream.
     if (state.peekProcTarget) {
-      const pending = procPeekTokenLine.get(state.peekProcTarget);
+      const key = procLogKey(state.peekProcTarget, state.peekProcAgent ?? undefined);
+      const pending = procPeekTokenLine.get(key);
       if (pending?.trim()) {
-        appendProcPeekLog(state.peekProcTarget, pending, WHITE);
+        appendProcPeekLog(key, pending, WHITE);
       }
-      procPeekTokenLine.delete(state.peekProcTarget);
+      procPeekTokenLine.delete(key);
     }
     state.peekProcTarget = null;
+    state.peekProcAgent = null;
   }
 
   // ── Peek view ────────────────────────────────────────────────────────
@@ -1353,10 +1436,20 @@ export async function runTui(app: AppContext): Promise<void> {
         state.tokens.output = totals.outputTokens;
         state.tokens.cacheRead = totals.cacheReadTokens;
         state.tokens.cacheWrite = totals.cacheCreationTokens;
+        if (totals.estimatedCost) state.tokens.cost = totals.estimatedCost;
         updateStatus();
         break;
       }
 
+      case 'ops:alert': {
+        handleOpsAlert(
+          typeof event.kind === 'string' ? event.kind : 'unknown',
+          typeof event.agentName === 'string' ? event.agentName : '?',
+          typeof event.message === 'string' ? event.message : '',
+        );
+        break;
+      }
+
       case 'inference:failed': {
         if (agent === rootAgentName) {
           state.status = 'error';
@@ -1529,8 +1622,33 @@ export async function runTui(app: AppContext): Promise<void> {
     });
   }
 
+  // Fleet-child ops alerts: a quarantine klaxon or refusal streak inside a
+  // child process must be as loud here as a local one — the operator is
+  // looking at THIS terminal, not the child's log. Default subscription is
+  // '*' so ops:alert events flow over the IPC with agentName intact.
+  // Re-bound on session switch alongside fleetMod itself.
+  let fleetOpsUnsub: (() => void) | null = null;
+  function subscribeFleetOps(): void {
+    fleetOpsUnsub?.();
+    fleetOpsUnsub = fleetMod?.onChildEvent('*', (childName, evt) => {
+      if (evt.type !== 'ops:alert') return;
+      const e = evt as Record<string, unknown>;
+      handleOpsAlert(
+        typeof e.kind === 'string' ? e.kind : 'unknown',
+        `${childName}/${typeof e.agentName === 'string' ? e.agentName : '?'}`,
+        typeof e.message === 'string' ? e.message : '',
+      );
+    }) ?? null;
+  }
+  subscribeFleetOps();
+
   // Per-child event log (analogue of peekLogs but for child processes).
+  // Keys come from procLogKey: bare child name for the whole-process stream,
+  // `child#agent` for an agent-filtered stream — the two never mix.
   const procPeekLogs = new Map<string, FleetLine[]>();
+  function procLogKey(child: string, agentFilter?: string): string {
+    return agentFilter ? `${child}#${agentFilter}` : child;
+  }
   // In-progress token line buffer per child (flushed to log on newline / next event).
   const procPeekTokenLine = new Map<string, string>();
   let procPeekUnsub: (() => void) | null = null;
@@ -1847,12 +1965,11 @@ export async function runTui(app: AppContext): Promise<void> {
           // Dispatch by node kind, not string-prefix surgery on the ID.
           if (node.kind === 'fleet-child') {
             enterPeekProc(node.fleetChildName!);
-            switchView('peek-proc');
           } else if (node.kind === 'fleet-child-agent') {
-            // Per-agent peek isn't separately supported yet; peek the
-            // owning process — its event stream still includes this agent.
-            enterPeekProc(node.fleetChildName!);
-            switchView('peek-proc');
+            // Honest per-agent peek: the child's event stream filtered to
+            // this one agent (works for the child's root agent and for its
+            // subagents — sub-subagents from where we stand).
+            enterPeekProc(node.fleetChildName!, node.fullName);
           } else {
             // node.kind === 'subagent' — local in-process peek.
             enterPeek(nodeId!);
@@ -1985,12 +2102,18 @@ export async function runTui(app: AppContext): Promise<void> {
           // Rebind to new framework
           subMod = app.framework.getAllModules().find(m => m.name === 'subagent') as SubagentModule | undefined;
           fleetMod = app.framework.getAllModules().find(m => m.name === 'fleet') as FleetModule | undefined;
+          subscribeFleetOps();
           app.framework.onTrace(onTrace as (e: unknown) => void);
 
           const session = app.sessionManager.getActiveSession();
           refreshFromStore();
           addLine(`Session: ${session?.name ?? 'unknown'}`, GRAY);
           state.tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+          // Alerts describe the OLD session's strategy/agents; the new
+          // session's own klaxons re-fire within their alarm interval if the
+          // condition still holds there. A stale alert with no reachable
+          // all-clear would otherwise pin the status bar red forever.
+          opsAlerts.clear();
           updateStatus();
         }).catch(err => {
           addLine(`Session switch failed: ${err}`, RED);
@@ -2061,6 +2184,7 @@ export async function runTui(app: AppContext): Promise<void> {
   function cleanup() {
     cleanupPeek();
     cleanupPeekProc();
+    fleetOpsUnsub?.();
     treeAggregator?.dispose();
     for (const unsub of subagentStreamUnsubs) unsub();
     clearInterval(pollTimer);
@@ -2090,9 +2214,11 @@ function formatStatusLeft(
   state: TuiState,
   spinnerChar?: string,
   outputTokens?: number,
+  alertCount = 0,
 ): string {
   const sColor = state.status === 'idle' ? '✓' : state.status === 'error' ? '✗' : state.status === 'background' ? '↓' : state.status === 'queued' ? '⏳' : '…';
   let bar = `[${sColor} ${state.status}`;
+  if (alertCount > 0) bar += ` | ⚠ ${alertCount} alert${alertCount === 1 ? '' : 's'}`;
   if (spinnerChar !== undefined && state.status !== 'idle' && state.status !== 'error' && state.status !== 'background') {
     bar += ` ${spinnerChar}`;
     if (state.status === 'thinking' && outputTokens !== undefined && outputTokens > 0) {
@@ -2108,7 +2234,9 @@ function formatStatusLeft(
   if (state.viewMode === 'fleet' || state.viewMode === 'peek') {
     bar += state.viewMode === 'peek' ? ` | peek: ${state.peekTarget}` : ' | fleet view';
   } else if (state.viewMode === 'peek-proc') {
-    bar += ` | peek-proc: ${state.peekProcTarget}`;
+    bar += state.peekProcAgent
+      ? ` | peek: ${state.peekProcTarget}›${state.peekProcAgent}`
+      : ` | peek-proc: ${state.peekProcTarget}`;
   } else if (state.viewMode === 'chat') {
     if (state.status === 'background') bar += ' Esc:stop';
     else if (state.status !== 'idle' && state.status !== 'error') bar += ' Ctrl+B:bg Esc:stop';
@@ -2126,6 +2254,9 @@ function formatTokens(tokens: TokenUsage, verbose: boolean): string {
     let s = `${fmtTokens(tokens.input)}in ${fmtTokens(tokens.output)}out`;
     if (tokens.cacheRead > 0) s += ` ${fmtTokens(tokens.cacheRead)}hit`;
     if (tokens.cacheWrite > 0) s += ` ${fmtTokens(tokens.cacheWrite)}write`;
+    if (tokens.cost && tokens.cost.total > 0) {
+      s += ` $${tokens.cost.total.toFixed(tokens.cost.total < 1 ? 3 : 2)}`;
+    }
     parts.push(s);
   }
 

package/src/web/protocol.ts

@@ -280,6 +280,31 @@ export interface BranchChangedMessage {
   branch: { id: string; name: string };
 }
 
+/** One Chronicle branch with its lineage. `parentId`/`branchPoint` are
+ *  undefined for the root branch; together they place the fork in the
+ *  parent's sequence so the SPA can render a lineage tree. */
+export interface BranchRow {
+  id: string;
+  name: string;
+  /** Head sequence number of the branch. */
+  head: number;
+  parentId?: string;
+  /** Sequence in the PARENT at which this branch forked. */
+  branchPoint?: number;
+  /** Epoch millis creation time. */
+  created: number;
+}
+
+/** Full branch listing with lineage — response to `request-branches`, routed
+ *  only to the requesting client. The SPA refreshes it after every
+ *  `branch-changed` while its branch panel is open. */
+export interface BranchesListMessage {
+  type: 'branches-list';
+  branches: BranchRow[];
+  /** id of the branch the agent is currently on. */
+  currentId: string;
+}
+
 /** Sent when the active session changes. Clients should soft-reconnect. */
 export interface SessionChangedMessage {
   type: 'session-changed';
@@ -442,6 +467,7 @@ export type WebUiServerMessage =
   | UsageMessage
   | CallLedgerMessage
   | BranchChangedMessage
+  | BranchesListMessage
   | SessionChangedMessage
   | PeekMessage
   | InboundTriggerMessage
@@ -576,6 +602,13 @@ export interface RequestMcplMessage {
   type: 'request-mcpl';
 }
 
+/** Pull the Chronicle branch listing. Response is a `branches-list` envelope
+ *  routed only to the requesting client. Read-only; switching branches goes
+ *  through the `/checkout` command (full-auth clients only). */
+export interface RequestBranchesMessage {
+  type: 'request-branches';
+}
+
 /** Add or overwrite an MCPL server entry in mcpl-servers.json. Restart is
  *  required for the host to pick up the change; the response is a fresh
  *  `mcpl-list` so the SPA reflects the new state. */
@@ -669,6 +702,7 @@ export type WebUiClientMessage =
   | QuitConfirmMessage
   | RequestLessonsMessage
   | RequestMcplMessage
+  | RequestBranchesMessage
   | McplAddMessage
   | McplRemoveMessage
   | McplSetEnvMessage
@@ -696,6 +730,7 @@ export function isClientMessage(value: unknown): value is WebUiClientMessage {
     case 'ping':
     case 'interrupt':
     case 'request-mcpl':
+    case 'request-branches':
       return true;
     case 'user-message':
       return typeof v.content === 'string';

package/test/codex-subscription-adapter.test.ts

@@ -0,0 +1,226 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import type { ProviderRequest } from '@animalabs/membrane';
+import {
+  CodexSubscriptionAdapter,
+  type CodexAuthProvider,
+} from '../src/codex-subscription-adapter.js';
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+function request(extra: Record<string, unknown> = {}): ProviderRequest {
+  return {
+    model: 'gpt-5.4',
+    messages: [{ type: 'message', role: 'user', content: 'Hello' }],
+    maxTokens: 8192,
+    temperature: 0.2,
+    topP: 0.9,
+    topK: 20,
+    extra,
+  };
+}
+
+function completedResponse(): Response {
+  const item = {
+      type: 'message',
+      id: 'msg_test',
+      role: 'assistant',
+      content: [{ type: 'output_text', text: 'Hello back' }],
+  };
+  const events = [
+    { type: 'response.output_item.done', output_index: 0, item },
+    {
+      type: 'response.completed',
+      response: {
+        id: 'resp_test',
+        model: 'gpt-5.4',
+        status: 'completed',
+        output: [],
+        usage: { input_tokens: 1, output_tokens: 2, total_tokens: 3 },
+      },
+    },
+  ];
+  return new Response(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(''), {
+    headers: { 'Content-Type': 'text/event-stream' },
+  });
+}
+
+describe('CodexSubscriptionAdapter', () => {
+  test('uses the subscription endpoint and enables Fast mode per request', async () => {
+    const requests: Array<{ url: string; headers: Headers; body: Record<string, unknown> }> = [];
+    globalThis.fetch = async (input, init) => {
+      requests.push({
+        url: String(input),
+        headers: new Headers(init?.headers),
+        body: JSON.parse(String(init?.body)),
+      });
+      return completedResponse();
+    };
+    const auth: CodexAuthProvider = {
+      getAccessToken: async () => 'subscription-token',
+      getAccountId: () => 'account-test',
+    };
+    const adapter = new CodexSubscriptionAdapter({
+      authProvider: auth,
+      baseURL: 'https://example.test/backend-api/codex/',
+      fastMode: true,
+    });
+
+    const response = await adapter.complete(request({ max_output_tokens: 999 }));
+
+    expect(response.stopReason).toBe('end_turn');
+    expect((response.content as Array<{ text?: string }>)[0]?.text).toBe('Hello back');
+    expect(requests).toHaveLength(1);
+    expect(requests[0]?.url).toBe('https://example.test/backend-api/codex/responses');
+    expect(requests[0]?.headers.get('authorization')).toBe('Bearer subscription-token');
+    expect(requests[0]?.headers.get('chatgpt-account-id')).toBe('account-test');
+    expect(requests[0]?.body.service_tier).toBe('priority');
+    expect(requests[0]?.body.max_output_tokens).toBeUndefined();
+    expect(requests[0]?.body.temperature).toBeUndefined();
+    expect(requests[0]?.body.top_p).toBeUndefined();
+    expect(requests[0]?.body.input).toEqual([{
+      type: 'message',
+      role: 'user',
+      content: [{ type: 'input_text', text: 'Hello' }],
+    }]);
+  });
+
+  test('normalizes maintenance text, images, and tool blocks at the transport boundary', async () => {
+    let body: Record<string, any> = {};
+    globalThis.fetch = async (_input, init) => {
+      body = JSON.parse(String(init?.body));
+      return completedResponse();
+    };
+    const adapter = new CodexSubscriptionAdapter({
+      authProvider: { getAccessToken: async () => 'subscription-token' },
+      baseURL: 'https://example.test/codex',
+    });
+
+    await adapter.complete({
+      model: 'gpt-5.4',
+      messages: [
+        {
+          type: 'message', role: 'user', content: [
+            { type: 'text', text: 'inspect' },
+            { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'aGVsbG8=' } },
+          ],
+        },
+        {
+          type: 'message', role: 'assistant', content: [
+            { type: 'tool_use', id: 'call_1', name: 'lookup', input: { q: 'x' } },
+          ],
+        },
+        {
+          type: 'message', role: 'user', content: [
+            { type: 'tool_result', tool_use_id: 'call_1', content: 'found' },
+          ],
+        },
+      ] as any,
+      maxTokens: 1024,
+    });
+
+    expect(body.input).toEqual([
+      {
+        type: 'message', role: 'user', content: [
+          { type: 'input_text', text: 'inspect' },
+          { type: 'input_image', image_url: 'data:image/png;base64,aGVsbG8=' },
+        ],
+      },
+      { type: 'function_call', call_id: 'call_1', name: 'lookup', arguments: '{"q":"x"}' },
+      { type: 'function_call_output', call_id: 'call_1', output: 'found' },
+    ]);
+  });
+
+  test('turns Fast mode off without reconstructing the adapter', async () => {
+    const bodies: Record<string, unknown>[] = [];
+    globalThis.fetch = async (_input, init) => {
+      bodies.push(JSON.parse(String(init?.body)));
+      return completedResponse();
+    };
+    const adapter = new CodexSubscriptionAdapter({
+      authProvider: { getAccessToken: async () => 'subscription-token' },
+      baseURL: 'https://example.test/codex',
+      fastMode: true,
+    });
+
+    await adapter.complete(request());
+    adapter.setFastMode(false);
+    await adapter.complete(request({ service_tier: 'priority' }));
+
+    expect(bodies[0]?.service_tier).toBe('priority');
+    expect(bodies[1]?.service_tier).toBeUndefined();
+  });
+
+  test('refreshes the ChatGPT token once after a 401', async () => {
+    const refreshFlags: boolean[] = [];
+    let calls = 0;
+    globalThis.fetch = async () => {
+      calls += 1;
+      if (calls === 1) return new Response('expired', { status: 401 });
+      return completedResponse();
+    };
+    const adapter = new CodexSubscriptionAdapter({
+      authProvider: {
+        getAccessToken: async (forceRefresh = false) => {
+          refreshFlags.push(forceRefresh);
+          return forceRefresh ? 'fresh-token' : 'expired-token';
+        },
+      },
+      baseURL: 'https://example.test/codex',
+    });
+
+    await adapter.complete(request());
+
+    expect(calls).toBe(2);
+    expect(refreshFlags).toEqual([false, true]);
+  });
+
+  test('reconstructs tool calls when the terminal event has an empty output', async () => {
+    const item = {
+      type: 'function_call',
+      id: 'fc_test',
+      call_id: 'call_test',
+      name: 'lookup',
+      arguments: '{"query":"connectome"}',
+    };
+    globalThis.fetch = async () => new Response([
+      `data: ${JSON.stringify({ type: 'response.output_item.done', output_index: 0, item })}\n\n`,
+      `data: ${JSON.stringify({
+        type: 'response.completed',
+        response: {
+          model: 'gpt-5.4', status: 'completed', output: [],
+          usage: { input_tokens: 2, output_tokens: 3 },
+        },
+      })}\n\n`,
+    ].join(''), { headers: { 'Content-Type': 'text/event-stream' } });
+    const adapter = new CodexSubscriptionAdapter({
+      authProvider: { getAccessToken: async () => 'subscription-token' },
+      baseURL: 'https://example.test/codex',
+    });
+
+    const response = await adapter.complete(request());
+
+    expect(response.stopReason).toBe('tool_use');
+    expect(response.content).toEqual([expect.objectContaining({
+      type: 'tool_use', id: 'call_test', name: 'lookup', input: { query: 'connectome' },
+    })]);
+  });
+
+  test('surfaces nested SSE error details', async () => {
+    globalThis.fetch = async () => new Response(
+      'data: {"type":"error","error":{"type":"invalid_request_error","code":"context_length_exceeded","message":"input is too large"}}\n\n',
+      { headers: { 'Content-Type': 'text/event-stream' } },
+    );
+    const adapter = new CodexSubscriptionAdapter({
+      authProvider: { getAccessToken: async () => 'subscription-token' },
+      baseURL: 'https://example.test/codex',
+    });
+
+    await expect(adapter.complete(request())).rejects.toThrow(
+      /context_length_exceeded.*input is too large/,
+    );
+  });
+});