interface TurnSink {
  channelId: string

  onSegment(segment: Segment): void
  onTurnEvent(event: CorpusEvent): void
  onApprovalRequest(req: ApprovalRequest): Promise<'approved' | 'denied'>
  onDone(): void
  onError(error: Error): void
  onCredentialBlocked(variable: string): void
}

type Segment =
  | { type: 'text'; delta: string }           // Streaming text chunk
  | { type: 'tool_call'; call: ToolCallInfo } // Tool invocation starting
  | { type: 'tool_result'; result: ToolResult } // Tool execution output
  | { type: 'turn_end'; reason: StopReason }  // Final marker

touch src/main/channels/my-channel.ts

import { TurnSink, Segment, ApprovalRequest, CorpusEvent } from '../types'
import { TurnRunner } from '../runtime/turn-runner'

export class MyChannel implements TurnSink {
  channelId = 'my-channel'
  private turnRunner: TurnRunner
  private responseBuffer = ''

  constructor(turnRunner: TurnRunner) {
    this.turnRunner = turnRunner
  }

  onSegment(segment: Segment): void {
    switch (segment.type) {
      case 'text':
        this.responseBuffer += segment.delta
        this.sendPartialUpdate(this.responseBuffer)
        break
      case 'tool_call':
        this.sendStatus(`Using tool: ${segment.call.name}`)
        break
      case 'tool_result':
        if (!segment.result.success) {
          this.sendStatus(`Tool failed: ${segment.result.error}`)
        }
        break
      case 'turn_end':
        // Final response is ready
        break
    }
  }

  onTurnEvent(event: CorpusEvent): void {
    // Optional: show status indicators
    // e.g., "context.built" → "Thinking..."
  }

  async onApprovalRequest(req: ApprovalRequest): Promise<'approved' | 'denied'> {
    // Implement however your platform prompts users
    // Must return 'approved' or 'denied'
    const userResponse = await this.promptUser(
      `Wolffish wants to run: ${req.toolName}\nArgs: ${JSON.stringify(req.args)}`
    )
    return userResponse ? 'approved' : 'denied'
  }

  onDone(): void {
    this.sendFinalMessage(this.responseBuffer)
    this.responseBuffer = ''
  }

  onError(error: Error): void {
    this.sendErrorMessage(`Error: ${error.message}`)
    this.responseBuffer = ''
  }

  onCredentialBlocked(variable: string): void {
    this.sendErrorMessage(
      `Missing credential: ${variable}. Add it in Settings > Variables.`
    )
  }

  // Platform-specific methods
  private sendPartialUpdate(text: string) { /* ... */ }
  private sendStatus(status: string) { /* ... */ }
  private sendFinalMessage(text: string) { /* ... */ }
  private sendErrorMessage(text: string) { /* ... */ }
  private promptUser(message: string): Promise<boolean> { /* ... */ }
}

async handleIncomingMessage(externalMessage: ExternalMessage) {
  // Map external thread to a Wolffish conversation
  const conversationId = this.resolveConversation(externalMessage.threadId)

  // Load conversation history
  const history = await this.loadHistory(conversationId)

  // Send through the agent pipeline
  await this.turnRunner.send({
    content: externalMessage.text,
    history,
    conversationId,
    sink: this // This channel is the TurnSink
  })
}

import { MyChannel } from './channels/my-channel'

// During app initialization, after TurnRunner is created:
const myChannel = new MyChannel(turnRunner)
myChannel.start() // Begin listening for incoming messages

Desktop conversation A: "Summarize my emails" → [running] ─┐
Telegram conversation B: "What's the weather?" → [running] ─┴─ concurrently
Desktop conversation A: "…and reply to Sam"    → [queued behind A's turn]

private resolveConversation(externalThreadId: string): string {
  // Option A: One conversation per external thread
  return `my-channel-${externalThreadId}`

  // Option B: Single persistent conversation for the channel
  return `my-channel-main`

  // Option C: New conversation per session (with /new command to reset)
  return this.activeConversation || this.createNew()
}

// Simplified from src/main/channels/telegram.ts
class TelegramChannel implements TurnSink {
  channelId = 'telegram'

  async onMessage(msg: TelegramMessage) {
    // 1. Check for slash commands
    if (msg.text.startsWith('/')) {
      await this.handleCommand(msg)
      return
    }

    // 2. Load or create conversation
    const conversationId = this.activeConversation
      || await this.createConversation()

    // 3. Build history from stored messages
    const history = await this.hippocampus.loadEpisode(conversationId)

    // 4. Send through pipeline
    await this.turnRunner.send({
      content: msg.text,
      history,
      conversationId,
      sink: this
    })
  }

  async onApprovalRequest(req: ApprovalRequest) {
    // Send inline keyboard with Approve/Deny buttons
    const response = await this.sendInlineKeyboard(
      `Wolffish wants to execute:\n  ${req.toolName}: ${JSON.stringify(req.args)}`,
      ['Approve', 'Deny']
    )
    return response === 'Approve' ? 'approved' : 'denied'
  }
}