async handle(
    message: ChannelMessage,
    callbacks?: BridgeCallbacks,
    abortSignal?: AbortSignal,
): Promise<AgentDeliveryResult> {
    // 1. Session lookup
    const sessionKey = buildSessionKey(message);
    const existingSessionId = this.sessionMap.get(sessionKey);

    // 2. System prompt
    const systemPrompt = buildSystemPrompt({ ... });

    // 3. MCP config: build McpServerConfig with gateway env vars
    const invocationDir = await mkdtemp(join(tmpdir(), "rc-"));
    const sideEffectsFile = join(invocationDir, "side-effects.ndjson");
    const mcpServers = this.buildMcpConfig(message, sideEffectsFile);

    // 4. Runtime params
    const runtime = createCliRuntime(this.provider);
    const params: AgentExecuteParams = {
        prompt: systemPrompt + "\n\n" + message.text,
        sessionId: existingSessionId,
        mcpServers,
        abortSignal,
        workingDirectory: this.workspaceDir,
        env: this.buildRuntimeEnv(),
    };

    // 5-6. Execute + stream events through DeliveryAdapter
    const adapter = new DeliveryAdapter({ chunkLimit: this.chunkLimit });
    let runResult: AgentRunResult | undefined;
    let lastError: string | undefined;

    try {
        const { payloads, result, error } = await adapter.process(
            runtime.execute(params),
            callbacks,
        );
        runResult = result;
        lastError = error;
    } catch (err) {
        // 7. Error classification
        const category = classifyError(String(err));
        lastError = String(err);
        // Handle based on category (retryable, fatal, context_overflow)
    }

    // 8. Read MCP side effects
    const mcp = await readMcpSideEffects(sideEffectsFile);

    // 9. Session update
    if (runResult?.sessionId) {
        this.sessionMap.set(sessionKey, runResult.sessionId);
    }

    // 10. Cleanup and return
    await rm(invocationDir, { recursive: true, force: true });

    const text = (runResult?.text ?? "").trim();
    return {
        payloads: text ? [{ text }] : [],
        run: runResult ?? DEFAULT_RUN_RESULT,
        mcp,
        error: lastError,
    };
}

export class ChannelBridge {
    constructor(options: {
        /** CLI runtime provider ("claude", "gemini", "codex", "opencode"). */
        provider: string;
        /** Session map for session persistence. */
        sessionMap: SessionMap;
        /** Gateway URL for MCP server WebSocket connection. */
        gatewayUrl: string;
        /** Gateway auth token for MCP server. */
        gatewayToken: string;
        /** Working directory for CLI subprocess. */
        workspaceDir?: string;
        /** Channel text chunk limit (default: 4000). */
        chunkLimit?: number;
        /** MCP server entry point path. */
        mcpServerPath?: string;
    });
}

private buildMcpConfig(
    message: ChannelMessage,
    sideEffectsFile: string,
): Record<string, McpServerConfig> {
    return {
        remoteclaw: {
            command: "node",
            args: [this.mcpServerPath],
            env: {
                REMOTECLAW_GATEWAY_URL: this.gatewayUrl,
                REMOTECLAW_GATEWAY_TOKEN: this.gatewayToken,
                REMOTECLAW_SESSION_KEY: buildSessionKey(message),
                REMOTECLAW_SIDE_EFFECTS_FILE: sideEffectsFile,
                REMOTECLAW_CHANNEL: message.provider,
                REMOTECLAW_ACCOUNT_ID: message.from,
                REMOTECLAW_TO: message.channelId,
                ...(message.replyToId ? { REMOTECLAW_THREAD_ID: message.replyToId } : {}),
            },
        },
    };
}

function buildSessionKey(message: ChannelMessage): string {
    const threadPart = message.replyToId ?? "_";
    return `${message.channelId}:${message.from}:${threadPart}`;
}