@openparachute/agent 0.1.0

package/container/agent-runner/src/poll-loop.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+
+import { initTestSessionDb, closeSessionDb, getInboundDb, getOutboundDb } from './db/connection.js';
+import { getPendingMessages, markCompleted } from './db/messages-in.js';
+import { getUndeliveredMessages } from './db/messages-out.js';
+import { formatMessages, extractRouting } from './formatter.js';
+import { MockProvider } from './providers/mock.js';
+
+beforeEach(() => {
+  initTestSessionDb();
+});
+
+afterEach(() => {
+  closeSessionDb();
+});
+
+function insertMessage(id: string, kind: string, content: object, opts?: { processAfter?: string; trigger?: 0 | 1 }) {
+  getInboundDb()
+    .prepare(
+      `INSERT INTO messages_in (id, kind, timestamp, status, process_after, trigger, content)
+     VALUES (?, ?, datetime('now'), 'pending', ?, ?, ?)`,
+    )
+    .run(id, kind, opts?.processAfter ?? null, opts?.trigger ?? 1, JSON.stringify(content));
+}
+
+describe('formatter', () => {
+  it('should format a single chat message', () => {
+    insertMessage('m1', 'chat', { sender: 'John', text: 'Hello world' });
+    const messages = getPendingMessages();
+    const prompt = formatMessages(messages);
+    expect(prompt).toContain('sender="John"');
+    expect(prompt).toContain('Hello world');
+  });
+
+  it('should format multiple chat messages as XML block', () => {
+    insertMessage('m1', 'chat', { sender: 'John', text: 'Hello' });
+    insertMessage('m2', 'chat', { sender: 'Jane', text: 'Hi there' });
+    const messages = getPendingMessages();
+    const prompt = formatMessages(messages);
+    expect(prompt).toContain('<messages>');
+    expect(prompt).toContain('</messages>');
+    expect(prompt).toContain('sender="John"');
+    expect(prompt).toContain('sender="Jane"');
+  });
+
+  it('should format task messages', () => {
+    insertMessage('m1', 'task', { prompt: 'Review open PRs' });
+    const messages = getPendingMessages();
+    const prompt = formatMessages(messages);
+    expect(prompt).toContain('[SCHEDULED TASK]');
+    expect(prompt).toContain('Review open PRs');
+  });
+
+  it('should format webhook messages', () => {
+    insertMessage('m1', 'webhook', { source: 'github', event: 'push', payload: { ref: 'main' } });
+    const messages = getPendingMessages();
+    const prompt = formatMessages(messages);
+    expect(prompt).toContain('[WEBHOOK: github/push]');
+  });
+
+  it('should format system messages', () => {
+    insertMessage('m1', 'system', { action: 'register_group', status: 'success', result: { id: 'ag-1' } });
+    const messages = getPendingMessages();
+    const prompt = formatMessages(messages);
+    expect(prompt).toContain('[SYSTEM RESPONSE]');
+    expect(prompt).toContain('register_group');
+  });
+
+  it('should handle mixed kinds', () => {
+    insertMessage('m1', 'chat', { sender: 'John', text: 'Hello' });
+    insertMessage('m2', 'system', { action: 'test', status: 'ok', result: null });
+    const messages = getPendingMessages();
+    const prompt = formatMessages(messages);
+    expect(prompt).toContain('sender="John"');
+    expect(prompt).toContain('[SYSTEM RESPONSE]');
+  });
+
+  it('should escape XML in content', () => {
+    insertMessage('m1', 'chat', { sender: 'A<B', text: 'x > y && z' });
+    const messages = getPendingMessages();
+    const prompt = formatMessages(messages);
+    expect(prompt).toContain('A&lt;B');
+    expect(prompt).toContain('x &gt; y &amp;&amp; z');
+  });
+});
+
+describe('accumulate gate (trigger column)', () => {
+  it('getPendingMessages returns both trigger=0 and trigger=1 rows', () => {
+    // trigger=0 rides along as context, trigger=1 is the wake-eligible row.
+    // The poll loop's gate depends on this data contract.
+    insertMessage('m1', 'chat', { sender: 'A', text: 'chit chat' }, { trigger: 0 });
+    insertMessage('m2', 'chat', { sender: 'B', text: 'actual mention' }, { trigger: 1 });
+    const messages = getPendingMessages();
+    expect(messages).toHaveLength(2);
+    const byId = Object.fromEntries(messages.map((m) => [m.id, m]));
+    expect(byId.m1.trigger).toBe(0);
+    expect(byId.m2.trigger).toBe(1);
+  });
+
+  it('trigger=0-only batch: gate predicate `some(trigger===1)` is false', () => {
+    insertMessage('m1', 'chat', { sender: 'A', text: 'noise' }, { trigger: 0 });
+    insertMessage('m2', 'chat', { sender: 'B', text: 'more noise' }, { trigger: 0 });
+    const messages = getPendingMessages();
+    // This is the exact predicate the poll loop uses to skip accumulate-only
+    // batches — gate should be false, so the loop sleeps without waking the agent.
+    expect(messages.some((m) => m.trigger === 1)).toBe(false);
+  });
+
+  it('mixed batch: gate is true → loop proceeds, accumulated rows ride along', () => {
+    insertMessage('m1', 'chat', { sender: 'A', text: 'earlier chatter' }, { trigger: 0 });
+    insertMessage('m2', 'chat', { sender: 'B', text: 'the real mention' }, { trigger: 1 });
+    const messages = getPendingMessages();
+    expect(messages.some((m) => m.trigger === 1)).toBe(true);
+    // Both messages are present for the formatter → agent sees the prior context.
+    expect(messages.map((m) => m.id).sort()).toEqual(['m1', 'm2']);
+  });
+
+  it('trigger column defaults to 1 for legacy inserts without explicit value', () => {
+    // The schema default is 1 (see src/db/schema.ts INBOUND_SCHEMA) — existing
+    // rows / tests without the column set are effectively wake-eligible.
+    getInboundDb()
+      .prepare(
+        `INSERT INTO messages_in (id, kind, timestamp, status, content)
+         VALUES ('m1', 'chat', datetime('now'), 'pending', '{"text":"hi"}')`,
+      )
+      .run();
+    const [msg] = getPendingMessages();
+    expect(msg.trigger).toBe(1);
+  });
+});
+
+describe('routing', () => {
+  it('should extract routing from messages', () => {
+    getInboundDb()
+      .prepare(
+        `INSERT INTO messages_in (id, kind, timestamp, status, platform_id, channel_type, thread_id, content)
+       VALUES ('m1', 'chat', datetime('now'), 'pending', 'chan-123', 'discord', 'thread-456', '{"text":"hi"}')`,
+      )
+      .run();
+
+    const messages = getPendingMessages();
+    const routing = extractRouting(messages);
+    expect(routing.platformId).toBe('chan-123');
+    expect(routing.channelType).toBe('discord');
+    expect(routing.threadId).toBe('thread-456');
+    expect(routing.inReplyTo).toBe('m1');
+  });
+});
+
+describe('mock provider', () => {
+  it('should produce init + result events', async () => {
+    const provider = new MockProvider({}, (prompt) => `Echo: ${prompt}`);
+    const query = provider.query({
+      prompt: 'Hello',
+      cwd: '/tmp',
+    });
+
+    const events: Array<{ type: string }> = [];
+    setTimeout(() => query.end(), 50);
+
+    for await (const event of query.events) {
+      events.push(event);
+    }
+
+    const typed = events.filter((e) => e.type !== 'activity');
+    expect(typed.length).toBeGreaterThanOrEqual(2);
+    expect(typed[0].type).toBe('init');
+    expect(typed[1].type).toBe('result');
+    expect((typed[1] as { text: string }).text).toBe('Echo: Hello');
+  });
+
+  it('should handle push() during active query', async () => {
+    const provider = new MockProvider({}, (prompt) => `Re: ${prompt}`);
+    const query = provider.query({
+      prompt: 'First',
+      cwd: '/tmp',
+    });
+
+    const events: Array<{ type: string; text?: string }> = [];
+
+    setTimeout(() => query.push('Second'), 30);
+    setTimeout(() => query.end(), 60);
+
+    for await (const event of query.events) {
+      events.push(event);
+    }
+
+    const results = events.filter((e) => e.type === 'result');
+    expect(results).toHaveLength(2);
+    expect(results[0].text).toBe('Re: First');
+    expect(results[1].text).toBe('Re: Second');
+  });
+});
+
+describe('end-to-end with mock provider', () => {
+  it('should read messages_in, process with mock provider, write messages_out', async () => {
+    // Insert a chat message into inbound DB
+    insertMessage('m1', 'chat', { sender: 'User', text: 'What is 2+2?' });
+
+    // Read and process
+    const messages = getPendingMessages();
+    expect(messages).toHaveLength(1);
+
+    const routing = extractRouting(messages);
+    const prompt = formatMessages(messages);
+
+    // Create mock provider and run query
+    const provider = new MockProvider({}, () => 'The answer is 4');
+    const query = provider.query({
+      prompt,
+      cwd: '/tmp',
+    });
+
+    // Process events — simulate what poll-loop does
+    const { markProcessing } = await import('./db/messages-in.js');
+    const { writeMessageOut } = await import('./db/messages-out.js');
+
+    markProcessing(['m1']);
+
+    setTimeout(() => query.end(), 50);
+
+    for await (const event of query.events) {
+      if (event.type === 'result' && event.text) {
+        writeMessageOut({
+          id: `out-${Date.now()}`,
+          in_reply_to: routing.inReplyTo,
+          kind: 'chat',
+          platform_id: routing.platformId,
+          channel_type: routing.channelType,
+          thread_id: routing.threadId,
+          content: JSON.stringify({ text: event.text }),
+        });
+      }
+    }
+
+    markCompleted(['m1']);
+
+    // Verify: message was processed (not pending, acked in processing_ack)
+    const processed = getPendingMessages();
+    expect(processed).toHaveLength(0);
+
+    // Verify: response was written to outbound DB
+    const outMessages = getUndeliveredMessages();
+    expect(outMessages).toHaveLength(1);
+    expect(JSON.parse(outMessages[0].content).text).toBe('The answer is 4');
+    expect(outMessages[0].in_reply_to).toBe('m1');
+  });
+});

package/container/agent-runner/src/poll-loop.ts

@@ -0,0 +1,437 @@
+import { findByName, getAllDestinations, type DestinationEntry } from './destinations.js';
+import { getPendingMessages, markProcessing, markCompleted, type MessageInRow } from './db/messages-in.js';
+import { writeMessageOut } from './db/messages-out.js';
+import { touchHeartbeat, clearStaleProcessingAcks } from './db/connection.js';
+import {
+  clearContinuation,
+  migrateLegacyContinuation,
+  setContinuation,
+} from './db/session-state.js';
+import { formatMessages, extractRouting, categorizeMessage, isClearCommand, stripInternalTags, type RoutingContext } from './formatter.js';
+import type { AgentProvider, AgentQuery, ProviderEvent } from './providers/types.js';
+
+const POLL_INTERVAL_MS = 1000;
+const ACTIVE_POLL_INTERVAL_MS = 500;
+
+function log(msg: string): void {
+  console.error(`[poll-loop] ${msg}`);
+}
+
+function generateId(): string {
+  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export interface PollLoopConfig {
+  provider: AgentProvider;
+  /**
+   * Name of the provider (e.g. "claude", "codex", "opencode"). Used to key
+   * the stored continuation per-provider so flipping providers doesn't
+   * resurrect a stale id from a different backend.
+   */
+  providerName: string;
+  cwd: string;
+  systemContext?: {
+    instructions?: string;
+  };
+}
+
+/**
+ * Main poll loop. Runs indefinitely until the process is killed.
+ *
+ * 1. Poll messages_in for pending rows
+ * 2. Format into prompt, call provider.query()
+ * 3. While query active: continue polling, push new messages via provider.push()
+ * 4. On result: write messages_out
+ * 5. Mark messages completed
+ * 6. Loop
+ */
+export async function runPollLoop(config: PollLoopConfig): Promise<void> {
+  // Resume the agent's prior session from a previous container run if one
+  // was persisted. The continuation is opaque to the poll-loop — the
+  // provider decides how to use it (Claude resumes a .jsonl transcript,
+  // other providers may reload a thread ID, etc.). Keyed per-provider so
+  // a Codex thread id never gets handed to Claude or vice versa.
+  let continuation: string | undefined = migrateLegacyContinuation(config.providerName);
+
+  if (continuation) {
+    log(`Resuming agent session ${continuation}`);
+  }
+
+  // Clear leftover 'processing' acks from a previous crashed container.
+  // This lets the new container re-process those messages.
+  clearStaleProcessingAcks();
+
+  let pollCount = 0;
+  while (true) {
+    // Skip system messages — they're responses for MCP tools (e.g., ask_user_question)
+    const messages = getPendingMessages().filter((m) => m.kind !== 'system');
+    pollCount++;
+
+    // Periodic heartbeat so we know the loop is alive
+    if (pollCount % 30 === 0) {
+      log(`Poll heartbeat (${pollCount} iterations, ${messages.length} pending)`);
+    }
+
+    if (messages.length === 0) {
+      await sleep(POLL_INTERVAL_MS);
+      continue;
+    }
+
+    // Accumulate gate: if the batch contains only trigger=0 rows
+    // (context-only, router-stored under ignored_message_policy='accumulate'),
+    // don't wake the agent. Leave them `pending` — they'll ride along the
+    // next time a real trigger=1 message lands via this same getPendingMessages
+    // query. Without this gate, a warm container keeps processing
+    // (and potentially responding to) every accumulate-only batch, defeating
+    // the "store as context, don't engage" contract. Host-side countDueMessages
+    // gates the same way for wake-from-cold (see src/db/session-db.ts).
+    if (!messages.some((m) => m.trigger === 1)) {
+      await sleep(POLL_INTERVAL_MS);
+      continue;
+    }
+
+    const ids = messages.map((m) => m.id);
+    markProcessing(ids);
+
+    const routing = extractRouting(messages);
+
+    // Command handling: the host router gates filtered and unauthorized
+    // admin commands before they reach the container. The only command
+    // the runner handles directly is /clear (session reset).
+    const normalMessages: MessageInRow[] = [];
+    const commandIds: string[] = [];
+
+    for (const msg of messages) {
+      if ((msg.kind === 'chat' || msg.kind === 'chat-sdk') && isClearCommand(msg)) {
+        log('Clearing session (resetting continuation)');
+        continuation = undefined;
+        clearContinuation(config.providerName);
+        writeMessageOut({
+          id: generateId(),
+          kind: 'chat',
+          platform_id: routing.platformId,
+          channel_type: routing.channelType,
+          thread_id: routing.threadId,
+          content: JSON.stringify({ text: 'Session cleared.' }),
+        });
+        commandIds.push(msg.id);
+        continue;
+      }
+      normalMessages.push(msg);
+    }
+
+    if (commandIds.length > 0) {
+      markCompleted(commandIds);
+    }
+
+    if (normalMessages.length === 0) {
+      const remainingIds = ids.filter((id) => !commandIds.includes(id));
+      if (remainingIds.length > 0) markCompleted(remainingIds);
+      log(`All ${messages.length} message(s) were commands, skipping query`);
+      continue;
+    }
+
+    // Pre-task scripts: for any task rows with a `script`, run it before the
+    // provider call. Scripts returning wakeAgent=false (or erroring) gate
+    // their own task row only — surviving messages still go to the agent.
+    // Without the scheduling module, the marker block is empty, `keep`
+    // falls back to `normalMessages`, and no gating happens.
+    let keep: MessageInRow[] = normalMessages;
+    let skipped: string[] = [];
+    // MODULE-HOOK:scheduling-pre-task:start
+    const { applyPreTaskScripts } = await import('./scheduling/task-script.js');
+    const preTask = await applyPreTaskScripts(normalMessages);
+    keep = preTask.keep;
+    skipped = preTask.skipped;
+    if (skipped.length > 0) {
+      markCompleted(skipped);
+      log(`Pre-task script skipped ${skipped.length} task(s): ${skipped.join(', ')}`);
+    }
+    // MODULE-HOOK:scheduling-pre-task:end
+
+    if (keep.length === 0) {
+      log(`All ${normalMessages.length} non-command message(s) gated by script, skipping query`);
+      continue;
+    }
+
+    // Format messages: passthrough commands get raw text (only if the
+    // provider natively handles slash commands), others get XML.
+    const prompt = formatMessagesWithCommands(keep, config.provider.supportsNativeSlashCommands);
+
+    log(`Processing ${keep.length} message(s), kinds: ${[...new Set(keep.map((m) => m.kind))].join(',')}`);
+
+    const query = config.provider.query({
+      prompt,
+      continuation,
+      cwd: config.cwd,
+      systemContext: config.systemContext,
+    });
+
+    // Process the query while concurrently polling for new messages
+    const skippedSet = new Set(skipped);
+    const processingIds = ids.filter((id) => !commandIds.includes(id) && !skippedSet.has(id));
+    try {
+      const result = await processQuery(query, routing, processingIds, config.providerName);
+      if (result.continuation && result.continuation !== continuation) {
+        continuation = result.continuation;
+        setContinuation(config.providerName, continuation);
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log(`Query error: ${errMsg}`);
+
+      // Stale/corrupt continuation recovery: ask the provider whether
+      // this error means the stored continuation is unusable, and clear
+      // it so the next attempt starts fresh.
+      if (continuation && config.provider.isSessionInvalid(err)) {
+        log(`Stale session detected (${continuation}) — clearing for next retry`);
+        continuation = undefined;
+        clearContinuation(config.providerName);
+      }
+
+      // Write error response so the user knows something went wrong
+      writeMessageOut({
+        id: generateId(),
+        kind: 'chat',
+        platform_id: routing.platformId,
+        channel_type: routing.channelType,
+        thread_id: routing.threadId,
+        content: JSON.stringify({ text: `Error: ${errMsg}` }),
+      });
+    }
+
+    // Ensure completed even if processQuery ended without a result event
+    // (e.g. stream closed unexpectedly).
+    markCompleted(processingIds);
+    log(`Completed ${ids.length} message(s)`);
+  }
+}
+
+/**
+ * Format messages, handling passthrough commands differently.
+ * When the provider handles slash commands natively (Claude Code),
+ * passthrough commands are sent raw (no XML wrapping) so the SDK can
+ * dispatch them. Otherwise they fall through to standard XML formatting.
+ */
+function formatMessagesWithCommands(messages: MessageInRow[], nativeSlashCommands: boolean): string {
+  const parts: string[] = [];
+  const normalBatch: MessageInRow[] = [];
+
+  for (const msg of messages) {
+    if (nativeSlashCommands && (msg.kind === 'chat' || msg.kind === 'chat-sdk')) {
+      const cmdInfo = categorizeMessage(msg);
+      if (cmdInfo.category === 'passthrough' || cmdInfo.category === 'admin') {
+        // Flush normal batch first
+        if (normalBatch.length > 0) {
+          parts.push(formatMessages(normalBatch));
+          normalBatch.length = 0;
+        }
+        // Pass raw command text (no XML wrapping) — SDK handles it natively
+        parts.push(cmdInfo.text);
+        continue;
+      }
+    }
+    normalBatch.push(msg);
+  }
+
+  if (normalBatch.length > 0) {
+    parts.push(formatMessages(normalBatch));
+  }
+
+  return parts.join('\n\n');
+}
+
+interface QueryResult {
+  continuation?: string;
+}
+
+async function processQuery(
+  query: AgentQuery,
+  routing: RoutingContext,
+  initialBatchIds: string[],
+  providerName: string,
+): Promise<QueryResult> {
+  let queryContinuation: string | undefined;
+  let done = false;
+
+  // Concurrent polling: push follow-ups into the active query as they arrive.
+  // We do NOT force-end the stream on silence — keeping the query open is
+  // strictly cheaper than close+reopen (no cold prompt cache, no reconnect).
+  // Stream liveness is decided host-side via the heartbeat file + processing
+  // claim age (see src/host-sweep.ts); if something is truly stuck, the host
+  // will kill the container and messages get reset to pending.
+  const pollHandle = setInterval(() => {
+    if (done) return;
+
+    // Skip system messages (MCP tool responses) and /clear (needs fresh query).
+    // Thread routing is the router's concern — if a message landed in this
+    // session, the agent should see it. Per-thread sessions already isolate
+    // threads into separate containers; shared sessions intentionally merge
+    // everything. Filtering on thread_id here caused deadlocks when the
+    // initial batch and follow-ups had mismatched thread_ids (e.g. a
+    // host-generated welcome trigger with null thread vs a Discord DM reply).
+    const newMessages = getPendingMessages().filter((m) => {
+      if (m.kind === 'system') return false;
+      if ((m.kind === 'chat' || m.kind === 'chat-sdk') && isClearCommand(m)) return false;
+      return true;
+    });
+    if (newMessages.length > 0) {
+      const newIds = newMessages.map((m) => m.id);
+      markProcessing(newIds);
+
+      const prompt = formatMessages(newMessages);
+      log(`Pushing ${newMessages.length} follow-up message(s) into active query`);
+      query.push(prompt);
+
+      markCompleted(newIds);
+    }
+  }, ACTIVE_POLL_INTERVAL_MS);
+
+  try {
+    for await (const event of query.events) {
+      handleEvent(event, routing);
+      touchHeartbeat();
+
+      if (event.type === 'init') {
+        queryContinuation = event.continuation;
+        // Persist immediately so a mid-turn container crash still lets the
+        // next wake resume the conversation. Without this, the session id
+        // was only written after the full stream completed — if the
+        // container died between `init` and `result`, the SDK session was
+        // effectively orphaned and the next message started a blank
+        // Claude session with no prior context.
+        setContinuation(providerName, event.continuation);
+      } else if (event.type === 'result') {
+        // A result — with or without text — means the turn is done. Mark
+        // the initial batch completed now so the host sweep doesn't see
+        // stale 'processing' claims while the query stays open for
+        // follow-up pushes. The agent may have responded via MCP
+        // (send_message) mid-turn, or the message may not need a response
+        // at all — either way the turn is finished.
+        markCompleted(initialBatchIds);
+        if (event.text) {
+          dispatchResultText(event.text, routing);
+        }
+      }
+    }
+  } finally {
+    done = true;
+    clearInterval(pollHandle);
+  }
+
+  return { continuation: queryContinuation };
+}
+
+function handleEvent(event: ProviderEvent, _routing: RoutingContext): void {
+  switch (event.type) {
+    case 'init':
+      log(`Session: ${event.continuation}`);
+      break;
+    case 'result':
+      log(`Result: ${event.text ? event.text.slice(0, 200) : '(empty)'}`);
+      break;
+    case 'error':
+      log(`Error: ${event.message} (retryable: ${event.retryable}${event.classification ? `, ${event.classification}` : ''})`);
+      break;
+    case 'progress':
+      log(`Progress: ${event.message}`);
+      break;
+  }
+}
+
+/**
+ * Parse the agent's final text for <message to="name">...</message> blocks
+ * and dispatch each one to its resolved destination. Text outside of blocks
+ * (including <internal>...</internal>) is normally scratchpad — logged but
+ * not sent.
+ *
+ * Single-destination shortcut: if the agent has exactly one configured
+ * destination AND the output contains zero <message> blocks, the entire
+ * cleaned text (with <internal> tags stripped) is sent to that destination.
+ * This preserves the simple case of one user on one channel — the agent
+ * doesn't need to know about wrapping syntax at all.
+ */
+function dispatchResultText(text: string, routing: RoutingContext): void {
+  const MESSAGE_RE = /<message\s+to="([^"]+)"\s*>([\s\S]*?)<\/message>/g;
+
+  let match: RegExpExecArray | null;
+  let sent = 0;
+  let lastIndex = 0;
+  const scratchpadParts: string[] = [];
+
+  while ((match = MESSAGE_RE.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      scratchpadParts.push(text.slice(lastIndex, match.index));
+    }
+    const toName = match[1];
+    const body = match[2].trim();
+    lastIndex = MESSAGE_RE.lastIndex;
+
+    const dest = findByName(toName);
+    if (!dest) {
+      log(`Unknown destination in <message to="${toName}">, dropping block`);
+      scratchpadParts.push(`[dropped: unknown destination "${toName}"] ${body}`);
+      continue;
+    }
+    sendToDestination(dest, body, routing);
+    sent++;
+  }
+  if (lastIndex < text.length) {
+    scratchpadParts.push(text.slice(lastIndex));
+  }
+
+  const scratchpad = stripInternalTags(scratchpadParts.join(''));
+
+  // Single-destination shortcut: the agent wrote plain text — send to
+  // the session's originating channel (from session_routing) if available,
+  // otherwise fall back to the single destination.
+  if (sent === 0 && scratchpad) {
+    if (routing.channelType && routing.platformId) {
+      // Reply to the channel/thread the message came from
+      writeMessageOut({
+        id: generateId(),
+        in_reply_to: routing.inReplyTo,
+        kind: 'chat',
+        platform_id: routing.platformId,
+        channel_type: routing.channelType,
+        thread_id: routing.threadId,
+        content: JSON.stringify({ text: scratchpad }),
+      });
+      return;
+    }
+    const all = getAllDestinations();
+    if (all.length === 1) {
+      sendToDestination(all[0], scratchpad, routing);
+      return;
+    }
+  }
+
+  if (scratchpad) {
+    log(`[scratchpad] ${scratchpad.slice(0, 500)}${scratchpad.length > 500 ? '…' : ''}`);
+  }
+
+  if (sent === 0 && text.trim()) {
+    log(`WARNING: agent output had no <message to="..."> blocks — nothing was sent`);
+  }
+}
+
+function sendToDestination(dest: DestinationEntry, body: string, routing: RoutingContext): void {
+  const platformId = dest.type === 'channel' ? dest.platformId! : dest.agentGroupId!;
+  const channelType = dest.type === 'channel' ? dest.channelType! : 'agent';
+  // Inherit thread_id from the inbound routing context so replies land in the
+  // same thread the conversation is in. For non-threaded adapters the router
+  // strips thread_id at ingest, so this will already be null.
+  writeMessageOut({
+    id: generateId(),
+    in_reply_to: routing.inReplyTo,
+    kind: 'chat',
+    platform_id: platformId,
+    channel_type: channelType,
+    thread_id: routing.threadId,
+    content: JSON.stringify({ text: body }),
+  });
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}