@agent-harness-experimental/adapter-claude-code 0.0.0 → 0.0.1

package/dist/bridge.mts

@@ -0,0 +1,745 @@
+#!/usr/bin/env node
+/**
+ * Claude Code bridge — runs inside the Vercel Sandbox.
+ *
+ * Flow:
+ *   1. WS server starts → prints bridge-ready
+ *   2. Waits for harness to connect and send 'start'
+ *   3. Starts Claude Code with the prompt from 'start'
+ *   4. Streams events over WS
+ *   5. Waits for harness to receive all events before exiting
+ */
+import {
+  initBridge,
+  waitForStart,
+  waitForNextPrompt,
+  setRunning,
+  emit,
+  requestToolResult,
+  requestToolDecision,
+  drainUserMessages,
+  consumeCompactRequest,
+  finish,
+} from './bridge-ws-server.mts';
+import { createClaudeQueryToolOptions, recordClaudeSubagentFinish, recordClaudeSubagentStart } from './bridge-helpers.mts';
+import { createDelegateToolSchema, parseDelegateTaskInput } from './bridge-delegation.mts';
+import { isToolAllowed } from './bridge-tool-policy.mts';
+import { applyBridgeContinuationConfig } from './bridge-continuation.mts';
+import { msg as protocolMessage } from '@agent-harness-experimental/protocol';
+import { z } from 'zod';
+
+// Crash loud
+process.on('uncaughtException', (err) => {
+  emit(protocolMessage.error({ message: `Bridge crash: ${err.message}\n${err.stack}` }));
+  process.exit(1);
+});
+process.on('unhandledRejection', (err: unknown) => {
+  emit(protocolMessage.error({ message: `Bridge rejection: ${err instanceof Error ? err.message : String(err)}` }));
+  process.exit(1);
+});
+
+initBridge();
+
+let { prompt, tools: toolSchemas, config } = await waitForStart();
+setRunning();
+
+const BRIDGE_DEBUG = process.env.BRIDGE_DEBUG === '1';
+
+function debug(message: string) {
+  if (BRIDGE_DEBUG) {
+    process.stderr.write(`[bridge-claude] ${message}\n`);
+  }
+}
+
+const claudeStderrLines: string[] = [];
+
+function recordClaudeStderr(data: string) {
+  for (const line of data.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    claudeStderrLines.push(trimmed);
+    if (claudeStderrLines.length > 50) {
+      claudeStderrLines.shift();
+    }
+    debug(`[claude-code:stderr] ${trimmed}`);
+  }
+}
+
+function formatClaudeProcessError(error: unknown, observedTerminalError: string | undefined): string {
+  const message = observedTerminalError || String(error);
+  const stderrTail = claudeStderrLines.slice(-10).join('\n');
+  return stderrTail ? `${message}\n${stderrTail}` : message;
+}
+
+let isFirstTurn = true;
+
+type JsonSchemaObject = {
+  properties?: Record<string, unknown>;
+  required?: string[];
+};
+
+type ClaudeBridgeConfig = {
+  workDir?: string;
+  interceptBuiltinTools?: boolean | string[];
+  activeTools?: string[];
+  builtinToolMappings?: Array<{
+    name: string;
+    nativeName?: string;
+  }>;
+  model?: string;
+  maxTurns?: number;
+  executableArgs?: string[];
+  instructions?: string;
+  thinking?: 'adaptive' | 'disabled' | Record<string, unknown>;
+  effort?: string;
+  agents?: Record<string, AgentDefinition>;
+};
+
+type AgentDefinition = {
+  description: string;
+  prompt: string;
+  model?: string;
+  tools?: string[];
+  maxTurns?: number;
+};
+
+type ClaudeTextContent = {
+  type?: string;
+  text?: string;
+};
+
+type ClaudeMessageBlock = {
+  type?: string;
+  id?: string;
+  name?: string;
+  input?: unknown;
+  tool_use_id?: string;
+  content?: string | ClaudeTextContent[];
+};
+
+type ClaudeQueryMessage = {
+  type?: string;
+  event?: {
+    type?: string;
+    delta?: {
+      type?: string;
+      text?: string;
+    };
+  };
+  message?: {
+    content?: ClaudeMessageBlock[];
+  };
+  subtype?: string;
+  stop_reason?: string;
+  errors?: string[];
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+  total_cost_usd?: number;
+  result?: string;
+  terminal_reason?: string;
+  error?: string;
+  error_status?: number | null;
+  output?: string[];
+  patch?: {
+    status?: 'pending' | 'running' | 'completed' | 'failed' | 'killed';
+    error?: string;
+  };
+};
+
+const claudeMessageBlockSchema = z
+  .object({
+    type: z.string().optional(),
+    id: z.string().optional(),
+    name: z.string().optional(),
+    input: z.unknown().optional(),
+    tool_use_id: z.string().optional(),
+    content: z.union([z.string(), z.array(z.object({ type: z.string().optional(), text: z.string().optional() }).passthrough())]).optional(),
+  })
+  .passthrough();
+
+const claudeQueryMessageSchema: z.ZodType<ClaudeQueryMessage> = z
+  .object({
+    type: z.string().optional(),
+    event: z
+      .object({
+        type: z.string().optional(),
+        delta: z
+          .object({
+            type: z.string().optional(),
+            text: z.string().optional(),
+          })
+          .passthrough()
+          .optional(),
+      })
+      .passthrough()
+      .optional(),
+    message: z
+      .object({ content: z.array(claudeMessageBlockSchema).optional() })
+      .passthrough()
+      .optional(),
+    subtype: z.string().optional(),
+    stop_reason: z.string().optional(),
+    errors: z.array(z.string()).optional(),
+    usage: z.object({ input_tokens: z.number().optional(), output_tokens: z.number().optional() }).passthrough().optional(),
+    total_cost_usd: z.number().optional(),
+    result: z.string().optional(),
+    terminal_reason: z.string().optional(),
+    error: z.string().optional(),
+    error_status: z.number().nullable().optional(),
+    output: z.array(z.string()).optional(),
+    patch: z
+      .object({
+        status: z.enum(['pending', 'running', 'completed', 'failed', 'killed']).optional(),
+        error: z.string().optional(),
+      })
+      .passthrough()
+      .optional(),
+  })
+  .passthrough();
+
+function parseNativeEvent(raw: unknown): ClaudeQueryMessage {
+  return claudeQueryMessageSchema.parse(raw);
+}
+
+type ZodLikeSchema = {
+  describe(description: string): ZodLikeSchema;
+  optional(): ZodLikeSchema;
+};
+
+type ZodLike = {
+  string(): ZodLikeSchema;
+  number(): ZodLikeSchema;
+  boolean(): ZodLikeSchema;
+  any(): ZodLikeSchema;
+};
+
+type BridgeMcpServer = {
+  tool(
+    name: string,
+    description: string,
+    shape: Record<string, ZodLikeSchema>,
+    handler: (input: Record<string, unknown>) => Promise<{ content: Array<{ type: 'text'; text: string }> }>,
+  ): void;
+};
+
+type ClaudeQueryStream = AsyncIterable<ClaudeQueryMessage> & {
+  close(): void;
+};
+
+type ClaudeQueryFn = (args: { prompt: string; options: Record<string, unknown> }) => ClaudeQueryStream;
+
+function extractBlockOutput(content: string | ClaudeTextContent[] | unknown): string {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content
+      .filter((entry) => entry.type === 'text')
+      .map((entry) => entry.text ?? '')
+      .join('\n');
+  }
+  return JSON.stringify(content);
+}
+
+const { query } = (await import('@anthropic-ai/claude-agent-sdk')) as { query: ClaudeQueryFn };
+let bridgeConfig = config as ClaudeBridgeConfig;
+
+function applyContinuationConfig(next: Partial<ClaudeBridgeConfig> | undefined) {
+  applyBridgeContinuationConfig(bridgeConfig, next, ['instructions', 'activeTools', 'interceptBuiltinTools']);
+}
+
+async function requestContinuationToolResult(requestId: string) {
+  debug(`waiting for tool result requestId=${requestId}`);
+  const response = await requestToolResult(requestId);
+  debug(`received tool result requestId=${requestId}`);
+  applyContinuationConfig(response.config as Partial<ClaudeBridgeConfig> | undefined);
+  return response.output;
+}
+
+async function requestContinuationToolDecision(requestId: string) {
+  const decision = await requestToolDecision(requestId);
+  applyContinuationConfig(decision.config as Partial<ClaudeBridgeConfig> | undefined);
+  return decision;
+}
+
+function buildSubagentSystemPrompt(agentName: string, definition: AgentDefinition, instructions?: string): string {
+  return [
+    `You are the subagent "${agentName}".`,
+    definition.prompt,
+    instructions ?? '',
+    definition.tools?.length ? `Only use these tools for this delegated task: ${definition.tools.join(', ')}.` : '',
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function buildDelegationSystemPrompt(agents: Record<string, AgentDefinition> | undefined): string | undefined {
+  if (!agents || Object.keys(agents).length === 0) {
+    return;
+  }
+
+  return [
+    'Configured subagents are available through the `delegate_task` tool.',
+    'When the user asks you to delegate, review with a subagent, or call `delegate_task`, call that tool and wait for its result before the final response.',
+    'Do not simulate subagent work inline, and do not output a reviewer confirmation marker unless it was returned by `delegate_task`.',
+    'Available subagents:',
+    ...Object.entries(agents).map(([name, definition]) => `- ${name}: ${definition.description}`),
+  ].join('\n');
+}
+
+function buildMainSystemPromptAppend(): string | undefined {
+  const append = [bridgeConfig.instructions, delegationSystemPrompt].filter(Boolean).join('\n\n');
+  return append || undefined;
+}
+
+// Map from MCP-prefixed name to original name
+const delegateToolSchema = createDelegateToolSchema(bridgeConfig.agents);
+const mcpToolSchemas = delegateToolSchema ? [...toolSchemas, delegateToolSchema] : toolSchemas;
+let delegationSystemPrompt = buildDelegationSystemPrompt(bridgeConfig.agents);
+const mcpNameMap = new Map<string, string>();
+for (const t of mcpToolSchemas) {
+  mcpNameMap.set(`mcp__harness-tools__${t.name}`, t.name);
+}
+
+// Build MCP server for user-defined tools
+let mcpServers: Record<string, unknown> = {};
+
+if (mcpToolSchemas.length > 0) {
+  const { McpServer } = (await import('@modelcontextprotocol/sdk/server/mcp.js')) as {
+    McpServer: new (config: { name: string; version: string }) => BridgeMcpServer;
+  };
+  const { z } = (await import('zod')) as { z: ZodLike };
+  const server = new McpServer({ name: 'harness-tools', version: '1.0.0' });
+
+  for (const schema of mcpToolSchemas) {
+    const inputSchema = schema.inputSchema as JsonSchemaObject;
+    const zodShape: Record<string, ZodLikeSchema> = {};
+    const props = inputSchema.properties ?? {};
+    const required = new Set(inputSchema.required ?? []);
+    for (const [key, val] of Object.entries(props)) {
+      const v = val as Record<string, unknown>;
+      let zType: ZodLikeSchema;
+      switch (v.type) {
+        case 'string':
+          zType = z.string();
+          break;
+        case 'number':
+          zType = z.number();
+          break;
+        case 'boolean':
+          zType = z.boolean();
+          break;
+        default:
+          zType = z.any();
+      }
+      if (v.description) zType = zType.describe(v.description as string);
+      zodShape[key] = required.has(key) ? zType : zType.optional();
+    }
+
+    server.tool(schema.name, schema.description ?? '', zodShape, async (_input: Record<string, unknown>) => {
+      // The tool-call event was already emitted from the assistant message
+      // observation below (with raw input). Just wait for the result.
+      debug(`mcp tool invoked name=${schema.name}`);
+      const requestId = pendingToolRequestIds.get(schema.name);
+      if (!requestId) {
+        debug(`mcp tool missing pending request name=${schema.name}`);
+        return { content: [{ type: 'text', text: 'Error: no pending tool call' }] };
+      }
+      pendingToolRequestIds.delete(schema.name);
+      const currentSubagentAllowedTools = subagentAllowedToolStack.at(-1);
+      if (currentSubagentAllowedTools?.length && !isToolAllowed(schema.name, currentSubagentAllowedTools)) {
+        return { content: [{ type: 'text', text: `Error: tool "${schema.name}" is not allowed for this subagent` }] };
+      }
+      if (schema.name === 'delegate_task') {
+        const decision = await requestContinuationToolDecision(requestId);
+        if (!decision.approved) {
+          return { content: [{ type: 'text', text: `Error: ${decision.reason || 'delegate_task denied'}` }] };
+        }
+        const result = await runClaudeDelegateTask(_input, requestId);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+      }
+      const result = await requestContinuationToolResult(requestId);
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+  }
+
+  mcpServers = { 'harness-tools': { type: 'sdk', name: 'harness-tools', instance: server } };
+}
+
+// Track pending tool calls — the assistant message handler emits the event,
+// the MCP callback picks up the requestId to wait for the result
+const pendingToolRequestIds = new Map<string, string>();
+const subagentAllowedToolStack: Array<string[] | undefined> = [];
+
+// Track toolCallId → toolName for emitting tool-result with the correct name
+const toolCallNames = new Map<string, string>();
+const activeSubagents = new Map<string, string>();
+const startedSubagentNames = new Set<string>();
+
+function observeClaudeAssistantToolCall(block: ClaudeMessageBlock) {
+  if (block.type !== 'tool_use' || typeof block.id !== 'string' || typeof block.name !== 'string') {
+    return;
+  }
+
+  const mcpOriginalName = mcpNameMap.get(block.name);
+  if (mcpOriginalName) {
+    const requestId = crypto.randomUUID();
+    pendingToolRequestIds.set(mcpOriginalName, requestId);
+    toolCallNames.set(block.id, mcpOriginalName);
+    emit(protocolMessage.toolCall({ requestId, toolName: mcpOriginalName, toolCallId: block.id, input: block.input }));
+    return;
+  }
+
+  toolCallNames.set(block.id, block.name);
+  emit(
+    protocolMessage.toolCall({
+      requestId: block.id,
+      toolName: bridgeConfig.builtinToolMappings?.find((entry) => (entry.nativeName ?? entry.name) === block.name)?.name ?? block.name,
+      toolCallId: block.id,
+      input: block.input,
+      observeOnly: true,
+    }),
+  );
+  let agentName = recordClaudeSubagentStart(activeSubagents, emit, block.name, block.id, block.input);
+  if (!agentName && (block.name === 'Agent' || block.name === 'Task') && bridgeConfig.agents && Object.keys(bridgeConfig.agents).length === 1) {
+    [agentName] = Object.keys(bridgeConfig.agents);
+    activeSubagents.set(block.id, agentName);
+    emit(protocolMessage.subagentStart({ agentName, parentToolCallId: block.id }));
+  }
+  if (agentName) {
+    startedSubagentNames.add(agentName);
+  }
+}
+
+function observeClaudeToolResult(block: ClaudeMessageBlock) {
+  if (block.type !== 'tool_result' || typeof block.tool_use_id !== 'string') {
+    return;
+  }
+
+  const toolUseId = block.tool_use_id;
+  const toolName = toolCallNames.get(toolUseId) ?? 'unknown';
+  const output = extractBlockOutput(block.content);
+  emit(protocolMessage.toolResult({ toolName, toolCallId: toolUseId, output }));
+  const finishedAgentName = recordClaudeSubagentFinish(activeSubagents, emit, toolUseId, output);
+  if (!finishedAgentName && (toolName === 'Agent' || toolName === 'Task') && bridgeConfig.agents && Object.keys(bridgeConfig.agents).length === 1) {
+    const [agentName] = Object.keys(bridgeConfig.agents);
+    startedSubagentNames.add(agentName);
+    emit(protocolMessage.subagentStart({ agentName, parentToolCallId: toolUseId }));
+    emit(protocolMessage.subagentFinish({ agentName, parentToolCallId: toolUseId, output }));
+  }
+}
+
+async function runClaudeDelegateTask(input: unknown, parentToolCallId: string) {
+  if (!bridgeConfig.agents) {
+    throw new Error('delegate_task requires configured agents');
+  }
+
+  const { agentName, task, definition } = parseDelegateTaskInput(input, bridgeConfig.agents);
+  startedSubagentNames.add(agentName);
+  emit(protocolMessage.subagentStart({ agentName, parentToolCallId }));
+  let text = '';
+  let result: { agent: string; text: string } | undefined;
+  let usage: { inputTokens: number; outputTokens: number; costUsd?: number } | undefined;
+  const allowedTools = definition.tools?.length ? definition.tools : undefined;
+  const queryToolOptions = createClaudeQueryToolOptions(bridgeConfig, emit, requestContinuationToolDecision, allowedTools);
+  subagentAllowedToolStack.push(allowedTools);
+  const q = query({
+    prompt: task,
+    options: {
+      ...(definition.model || bridgeConfig.model ? { model: definition.model ?? bridgeConfig.model } : {}),
+      ...(definition.maxTurns ? { maxTurns: definition.maxTurns } : bridgeConfig.maxTurns ? { maxTurns: bridgeConfig.maxTurns } : {}),
+      systemPrompt: {
+        type: 'preset' as const,
+        preset: 'claude_code' as const,
+        append: buildSubagentSystemPrompt(agentName, definition, bridgeConfig.instructions),
+      },
+      debug: BRIDGE_DEBUG,
+      stderr: recordClaudeStderr,
+      includePartialMessages: true,
+      permissionMode: queryToolOptions.permissionMode,
+      allowDangerouslySkipPermissions: queryToolOptions.allowDangerouslySkipPermissions,
+      mcpServers,
+      ...(queryToolOptions.canUseTool ? { canUseTool: queryToolOptions.canUseTool } : {}),
+    },
+  });
+
+  try {
+    for await (const rawMessage of q) {
+      const message = parseNativeEvent(rawMessage);
+
+      if (message.type === 'stream_event' && message.event?.type === 'content_block_delta' && message.event.delta?.type === 'text_delta') {
+        text += message.event.delta.text;
+      }
+
+      if (message.type === 'assistant') {
+        for (const block of message.message?.content ?? []) {
+          observeClaudeAssistantToolCall(block);
+        }
+      }
+
+      if (message.type === 'user') {
+        const content = message.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            observeClaudeToolResult(block);
+          }
+        }
+      }
+
+      if (message.type === 'result') {
+        if (message.subtype !== 'success') {
+          throw new Error(message.errors?.join('\n') || message.result || 'Unknown subagent error');
+        }
+        if (message.result?.trim()) {
+          text = message.result;
+        }
+        usage = {
+          inputTokens: message.usage?.input_tokens ?? 0,
+          outputTokens: message.usage?.output_tokens ?? 0,
+          ...(typeof message.total_cost_usd === 'number' ? { costUsd: message.total_cost_usd } : {}),
+        };
+      }
+    }
+
+    result = { agent: agentName, text: text.trim() };
+    return result;
+  } finally {
+    subagentAllowedToolStack.pop();
+    q.close();
+    emit(protocolMessage.subagentFinish({ agentName, parentToolCallId, ...(result ? { output: result } : {}), ...(usage ? { usage } : {}) }));
+  }
+}
+
+function promptRequestedDelegation() {
+  const text = [prompt, bridgeConfig.instructions].filter(Boolean).join('\n');
+  return /\bdelegate_task\b|\bsubagent\b|\bdelegate\b|\breviewer\b/i.test(text);
+}
+
+function shouldAppendAutoDelegateText(finalText: string | undefined, delegateText: string) {
+  const trimmedFinal = finalText?.trim() ?? '';
+  const trimmedDelegate = delegateText.trim();
+  if (!trimmedDelegate || trimmedFinal.includes(trimmedDelegate)) {
+    return false;
+  }
+  if (trimmedFinal.startsWith('{') || /return only json|raw json|json object/i.test(prompt)) {
+    return false;
+  }
+  return true;
+}
+
+async function runMissingDelegateTaskIfNeeded(finalText: string | undefined) {
+  if (!bridgeConfig.agents || startedSubagentNames.size > 0 || !promptRequestedDelegation()) {
+    return;
+  }
+
+  const [agentName] = Object.keys(bridgeConfig.agents);
+  if (!agentName) {
+    return;
+  }
+
+  const requestId = `auto-delegate-${crypto.randomUUID()}`;
+  const input = {
+    agent: agentName,
+    task: [
+      'The parent task requested a subagent review through `delegate_task`, but the primary run reached a final answer before invoking it.',
+      'Run the requested review now and return only the reviewer result.',
+      '',
+      `Parent prompt:\n${prompt}`,
+      finalText?.trim() ? `\nPrimary final text:\n${finalText.trim()}` : '',
+    ]
+      .filter(Boolean)
+      .join('\n'),
+  };
+
+  emit(protocolMessage.toolCall({ requestId, toolName: 'delegate_task', toolCallId: requestId, input }));
+  const decision = await requestContinuationToolDecision(requestId);
+  if (!decision.approved) {
+    emit(
+      protocolMessage.toolResult({
+        toolName: 'delegate_task',
+        toolCallId: requestId,
+        output: { type: 'execution-denied', reason: decision.reason || 'delegate_task denied' },
+      }),
+    );
+    return;
+  }
+  const result = await runClaudeDelegateTask(input, requestId);
+  emit(protocolMessage.toolResult({ toolName: 'delegate_task', toolCallId: requestId, output: result }));
+
+  if (shouldAppendAutoDelegateText(finalText, result.text)) {
+    emit(protocolMessage.textDelta({ delta: `\n${result.text}` }));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Multi-turn loop: run prompt → finish → wait for next → run again
+// ---------------------------------------------------------------------------
+
+while (true) {
+  const queryToolOptions = createClaudeQueryToolOptions(bridgeConfig, emit, requestContinuationToolDecision);
+  const mainSystemPromptAppend = buildMainSystemPromptAppend();
+  const abortController = new AbortController();
+  let observedTerminalError: string | undefined;
+  let emittedTerminalError = false;
+  let emittedTerminalFinish = false;
+
+  function emitTerminalError(message: string | undefined) {
+    const normalized = message?.trim();
+    if (!normalized || emittedTerminalError || emittedTerminalFinish) {
+      return;
+    }
+
+    observedTerminalError = normalized;
+    emittedTerminalError = true;
+    emit(protocolMessage.error({ message: normalized }));
+    abortController.abort();
+  }
+
+  const q = query({
+    prompt,
+    options: {
+      abortController,
+      ...(bridgeConfig.model ? { model: bridgeConfig.model } : {}),
+      ...(bridgeConfig.maxTurns ? { maxTurns: bridgeConfig.maxTurns } : {}),
+      ...(bridgeConfig.executableArgs ? { executableArgs: bridgeConfig.executableArgs } : {}),
+      ...(mainSystemPromptAppend
+        ? {
+            systemPrompt: { type: 'preset' as const, preset: 'claude_code' as const, append: mainSystemPromptAppend },
+          }
+        : {}),
+      ...(bridgeConfig.thinking
+        ? {
+            thinking:
+              bridgeConfig.thinking === 'adaptive' ? { type: 'adaptive' } : bridgeConfig.thinking === 'disabled' ? { type: 'disabled' } : bridgeConfig.thinking,
+          }
+        : {}),
+      ...(bridgeConfig.effort ? { effort: bridgeConfig.effort } : {}),
+      debug: BRIDGE_DEBUG,
+      stderr: recordClaudeStderr,
+      // Multi-turn: continue the most recent conversation on subsequent turns
+      ...(!isFirstTurn ? { continue: true } : {}),
+      includePartialMessages: true,
+      // Sandbox is already isolated — default to maximum-liberal permissions
+      // (bypass all prompts, auto-approve writes and shell).  When the harness
+      // opts into tool interception, we must use 'default' permissionMode so
+      // the SDK calls canUseTool; the callback itself still auto-approves
+      // anything not explicitly intercepted.
+      permissionMode: queryToolOptions.permissionMode,
+      allowDangerouslySkipPermissions: queryToolOptions.allowDangerouslySkipPermissions,
+      mcpServers,
+      ...(queryToolOptions.canUseTool ? { canUseTool: queryToolOptions.canUseTool } : {}),
+    },
+  });
+
+  try {
+    for await (const rawMessage of q) {
+      const message = parseNativeEvent(rawMessage);
+      const type = message.type;
+      debug(
+        `message type=${String(type)} subtype=${String(message.subtype ?? '')} stop_reason=${String(message.stop_reason ?? '')} result=${JSON.stringify(message.result ?? null)}`,
+      );
+
+      if (typeof message.error === 'string' && message.error.trim()) {
+        observedTerminalError = message.error.trim();
+      }
+
+      if (type === 'auth_status' && typeof message.error === 'string' && message.error.trim()) {
+        emitTerminalError(message.error);
+        continue;
+      }
+
+      if (type === 'system' && message.subtype === 'api_retry' && message.error_status && [401, 403, 404].includes(message.error_status)) {
+        emitTerminalError(`HTTP ${message.error_status}: ${message.error ?? 'provider request failed'}`);
+        continue;
+      }
+
+      if (type === 'system' && message.subtype === 'task_updated' && message.patch?.status === 'failed' && typeof message.patch.error === 'string') {
+        emitTerminalError(message.patch.error);
+        continue;
+      }
+
+      if (type === 'stream_event') {
+        const event = message.event;
+        if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta' && typeof event.delta.text === 'string') {
+          emit(protocolMessage.textDelta({ delta: event.delta.text }));
+        }
+      }
+
+      if (type === 'assistant') {
+        for (const block of message.message?.content ?? []) {
+          observeClaudeAssistantToolCall(block);
+        }
+      }
+
+      if (type === 'user') {
+        const content = message.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            observeClaudeToolResult(block);
+          }
+        }
+      }
+
+      if (type === 'result') {
+        if (message.subtype === 'success') {
+          const emptyResult = !message.result?.trim();
+          if (emptyResult && observedTerminalError) {
+            emitTerminalError(observedTerminalError);
+            continue;
+          }
+          if (
+            emptyResult &&
+            bridgeConfig.model &&
+            message.stop_reason === 'stop_sequence' &&
+            (message.terminal_reason === 'model_error' || ((message.usage?.input_tokens ?? 0) === 0 && (message.usage?.output_tokens ?? 0) === 0))
+          ) {
+            emitTerminalError(`Unknown model "${bridgeConfig.model}"`);
+            continue;
+          }
+
+          emittedTerminalFinish = true;
+          await runMissingDelegateTaskIfNeeded(message.result);
+          emit(
+            protocolMessage.finish({
+              finishReason: message.stop_reason || 'stop',
+              usage: {
+                inputTokens: message.usage?.input_tokens ?? 0,
+                outputTokens: message.usage?.output_tokens ?? 0,
+                costUsd: message.total_cost_usd,
+              },
+            }),
+          );
+        } else {
+          emitTerminalError(message.errors?.join('\n') || observedTerminalError || message.result || 'Unknown error');
+        }
+      }
+    }
+  } catch (err) {
+    if (!(abortController.signal.aborted && emittedTerminalError)) {
+      emit(protocolMessage.error({ message: formatClaudeProcessError(err, observedTerminalError) }));
+    }
+  } finally {
+    q.close();
+  }
+
+  isFirstTurn = false;
+  await finish();
+
+  // Wait for next prompt via WS
+  process.stderr.write('[bridge] Waiting for next prompt...\n');
+  const next = await waitForNextPrompt();
+  const queuedMessages = drainUserMessages();
+  if (consumeCompactRequest()) {
+    process.stderr.write('[bridge] Compact requested (queued for adapter-native support later)\n');
+  }
+  prompt = queuedMessages.length > 0 ? `${queuedMessages.join('\n\n')}\n\n${next.prompt}` : next.prompt;
+  config = next.config;
+  bridgeConfig = next.config as ClaudeBridgeConfig;
+  delegationSystemPrompt = buildDelegationSystemPrompt(bridgeConfig.agents);
+  startedSubagentNames.clear();
+  setRunning();
+}