@automagik/genie 4.260409.2 → 4.260409.4

package/src/services/executors/claude-code.test.ts

@@ -2,31 +2,45 @@ import { describe, expect, test } from 'bun:test';
 import { buildOmniSpawnParams, sanitizeWindowName } from './claude-code.js';
 
 describe('sanitizeWindowName', () => {
-  test('WhatsApp DM: number@s.whatsapp.net → wa-number', () => {
+  // --- Without chatName (fallback to JID) ---
+  test('WhatsApp DM: always uses phone number', () => {
     expect(sanitizeWindowName('5512982298888@s.whatsapp.net')).toBe('wa-5512982298888');
   });
 
-  test('WhatsApp group: id@g.us → group-id', () => {
-    expect(sanitizeWindowName('120363422699972298@g.us')).toBe('group-120363422699972298');
+  test('WhatsApp DM: ignores chatName, always phone', () => {
+    expect(sanitizeWindowName('5512982298888@s.whatsapp.net', 'Felipe Rosa')).toBe('wa-5512982298888');
   });
 
-  test('LID format: id@lid → lid-id', () => {
+  test('WhatsApp group without name: uses group ID', () => {
+    expect(sanitizeWindowName('120363422699972298@g.us')).toBe('grp-120363422699972298');
+  });
+
+  test('WhatsApp group with name: uses chat name', () => {
+    expect(sanitizeWindowName('120363422699972298@g.us', 'NMSTX leadership')).toBe('grp-NMSTXleadership');
+  });
+
+  test('LID without name: uses lid-id', () => {
     expect(sanitizeWindowName('54958418317348@lid')).toBe('lid-54958418317348');
   });
 
+  test('LID with name: uses wa- prefix + contact name', () => {
+    expect(sanitizeWindowName('54958418317348@lid', 'Felipe Rosa')).toBe('wa-FelipeRosa');
+  });
+
+  // --- Determinism ---
+  test('same chatId always produces same name (no sender dependency)', () => {
+    const id = '120363422699972298@g.us';
+    // Without chatName, always deterministic from JID
+    expect(sanitizeWindowName(id)).toBe(sanitizeWindowName(id));
+  });
+
   test('different DM numbers produce different names', () => {
     const a = sanitizeWindowName('5511999999999@s.whatsapp.net');
     const b = sanitizeWindowName('5511888888888@s.whatsapp.net');
     expect(a).not.toBe(b);
-    expect(a).toBe('wa-5511999999999');
-    expect(b).toBe('wa-5511888888888');
-  });
-
-  test('identical inputs produce identical output', () => {
-    const id = '5511999999999@s.whatsapp.net';
-    expect(sanitizeWindowName(id)).toBe(sanitizeWindowName(id));
   });
 
+  // --- Edge cases ---
   test('fallback: unknown format uses chat- prefix', () => {
     expect(sanitizeWindowName('user@domain.com/resource')).toBe('chat-userdomain.comresource');
   });
@@ -47,15 +61,21 @@ describe('sanitizeWindowName', () => {
   test('output is path-safe — no slashes, dots, or colons', () => {
     const names = [
       sanitizeWindowName('5512982298888@s.whatsapp.net'),
-      sanitizeWindowName('120363422699972298@g.us'),
-      sanitizeWindowName('54958418317348@lid'),
+      sanitizeWindowName('120363422699972298@g.us', 'Test Group'),
+      sanitizeWindowName('54958418317348@lid', 'Felipe'),
       sanitizeWindowName('some-weird-id'),
     ];
     for (const name of names) {
-      // Must be safe as both tmux window name and filename component
       expect(name).not.toMatch(/[\/.:]/);
     }
   });
+
+  test('long chat name is truncated to 30 chars', () => {
+    const longName = 'A'.repeat(50);
+    const result = sanitizeWindowName('120363422699972298@g.us', longName);
+    // "grp-" prefix + 30 chars max
+    expect(result.length).toBeLessThanOrEqual(34);
+  });
 });
 
 describe('buildOmniSpawnParams', () => {
@@ -84,15 +104,17 @@ describe('buildOmniSpawnParams', () => {
     expect(params.systemPromptFile).toBe('/home/genie/agents/simone/AGENTS.md');
   });
 
-  test('injects turn-based prompt as systemPrompt', () => {
+  test('injects turn-based prompt into initialPrompt (not systemPrompt)', () => {
     const params = buildOmniSpawnParams('simone', 'chat123', fakeEntry, {
       OMNI_INSTANCE: 'inst-1',
       OMNI_SENDER_NAME: 'Stefani',
     });
-    expect(params.systemPrompt).toContain('WhatsApp Turn-Based Conversation');
-    expect(params.systemPrompt).toContain('Stefani');
-    expect(params.systemPrompt).toContain('inst-1');
-    expect(params.systemPrompt).toContain('chat123');
+    // Turn context goes in initialPrompt, not systemPrompt
+    expect(params.systemPrompt).toBeUndefined();
+    expect(params.initialPrompt).toContain('WhatsApp Turn');
+    expect(params.initialPrompt).toContain('Stefani');
+    expect(params.initialPrompt).toContain('inst-1');
+    expect(params.initialPrompt).toContain('chat123');
   });
 
   test('enables nativeTeam with agent name and color', () => {
@@ -107,9 +129,21 @@ describe('buildOmniSpawnParams', () => {
     expect(params.model).toBe('opus');
   });
 
-  test('passes initialMessage as initialPrompt', () => {
-    const params = buildOmniSpawnParams('simone', 'chat123', fakeEntry, {}, 'Hello!');
-    expect(params.initialPrompt).toBe('Hello!');
+  test('passes initialMessage appended to turn context in initialPrompt', () => {
+    const params = buildOmniSpawnParams(
+      'simone',
+      'chat123',
+      fakeEntry,
+      {
+        OMNI_INSTANCE: 'inst-1',
+        OMNI_SENDER_NAME: 'Stefani',
+      },
+      'Hello!',
+    );
+    expect(params.initialPrompt).toContain('WhatsApp Turn');
+    expect(params.initialPrompt).toContain('Hello!');
+    // User message comes after separator
+    expect(params.initialPrompt).toContain('---\n\nHello!');
   });
 
   test('generates a sessionId', () => {

package/src/services/executors/claude-code.ts

@@ -2,18 +2,19 @@
  * ClaudeCodeOmniExecutor -- tmux-based IExecutor implementation.
  *
  * Spawns Claude Code processes in tmux windows (one per chat),
- * delivers messages via Claude Code's native team inbox, and
- * injects env vars so agents can call `omni say/done` directly.
+ * delivers follow-up messages via genie's PG mailbox pipeline
+ * (mailbox.send → PG LISTEN/NOTIFY → scheduler → deliverToPane),
+ * and injects env vars so agents can call `omni say/done` directly.
  */
 
 import { randomUUID } from 'node:crypto';
-import { mkdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import * as directory from '../../lib/agent-directory.js';
 import type { DirectoryEntry } from '../../lib/agent-directory.js';
 import * as agents from '../../lib/agent-registry.js';
 import * as registry from '../../lib/executor-registry.js';
+import * as mailbox from '../../lib/mailbox.js';
 import { buildLaunchCommand } from '../../lib/provider-adapters.js';
 import type { SpawnParams } from '../../lib/provider-adapters.js';
 import { shellQuote } from '../../lib/team-lead-command.js';
@@ -23,36 +24,81 @@ import { buildTurnBasedPrompt } from './turn-based-prompt.js';
 
 interface TmuxSessionState {
   executorId: string | null;
+  /** Agent ID in genie's agents table (for mailbox delivery). */
+  agentId: string | null;
+  /** Agent repo/working directory (for mailbox repoPath). */
+  repoPath: string | null;
+}
+
+/**
+ * Sanitize a string for use as tmux window name and inbox filename.
+ * Strips unsafe characters, truncates to 30 chars.
+ */
+function safeName(raw: string, maxLen = 30): string {
+  return raw.replace(/[^a-zA-Z0-9._-]/g, '').slice(0, maxLen) || 'unknown';
 }
 
 /**
  * Convert a chat JID into a human-readable, path-safe tmux window name.
  *
+ * MUST be deterministic from chatId alone — senderName changes per message
+ * in groups, so it cannot be part of the key. The optional chatName is
+ * resolved once at spawn time from omni's chat database.
+ *
  * Uses `-` separator (not `/`) so the name is safe as both a tmux window
  * name AND a filename component in the Claude Code team inbox path.
  *
  * Formats:
  *   5512982298888@s.whatsapp.net  → wa-5512982298888
- *   120363422699972298@g.us       → group-120363422699972298
+ *   120363422699972298@g.us       → grp-NMSTXleadership (if chatName) or grp-120363422699972298
  *   54958418317348@lid            → lid-54958418317348
  *   other                         → chat-<sanitized prefix>
  */
-export function sanitizeWindowName(chatId: string): string {
-  // WhatsApp DM: number@s.whatsapp.net
+export function sanitizeWindowName(chatId: string, chatName?: string): string {
+  // WhatsApp DM: number@s.whatsapp.net — always use phone number
   const whatsappDm = chatId.match(/^(\d+)@s\.whatsapp\.net$/);
   if (whatsappDm) return `wa-${whatsappDm[1]}`;
 
-  // WhatsApp group: id@g.us
+  // WhatsApp group: id@g.us — use chatName if available
   const whatsappGroup = chatId.match(/^(\d+)@g\.us$/);
-  if (whatsappGroup) return `group-${whatsappGroup[1]}`;
+  if (whatsappGroup) return `grp-${chatName ? safeName(chatName) : whatsappGroup[1]}`;
 
-  // LID format: id@lid
+  // LID format: id@lid — use chatName (contact name) if available
   const lid = chatId.match(/^(\d+)@lid$/);
-  if (lid) return `lid-${lid[1]}`;
+  if (lid) return chatName ? `wa-${safeName(chatName)}` : `lid-${lid[1]}`;
 
   // Fallback: sanitize for tmux and file paths (no special chars)
-  const clean = chatId.replace(/[^a-zA-Z0-9._-]/g, '').slice(0, 30);
-  return `chat-${clean || 'unknown'}`;
+  return `chat-${safeName(chatId)}`;
+}
+
+/**
+ * Look up the chat/contact name from omni API for human-readable window naming.
+ * Queries GET /api/v2/chats?externalId=<jid> — returns the chat name.
+ * Returns null if lookup fails (best-effort, never blocks spawn).
+ */
+async function lookupChatName(chatId: string, _instanceId: string): Promise<string | null> {
+  try {
+    const configPath = join(homedir(), '.omni', 'config.json');
+    const { readFileSync } = await import('node:fs');
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    const apiUrl = config.apiUrl || 'http://localhost:8882';
+    const apiKey = config.apiKey || '';
+    if (!apiKey) return null;
+
+    const url = `${apiUrl}/api/v2/chats?externalId=${encodeURIComponent(chatId)}`;
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return null;
+    // API returns { items: [...] } at root (no data wrapper)
+    const body = (await res.json()) as { items?: { name?: string; externalId?: string }[] };
+    // Find exact match by externalId since the API may return multiple results
+    const match = body.items?.find((c) => c.externalId === chatId) ?? body.items?.[0];
+    return match?.name || null;
+  } catch {
+    return null;
+  }
 }
 
 /**
@@ -67,7 +113,12 @@ export function buildOmniSpawnParams(
 ): SpawnParams {
   const instanceId = env.OMNI_INSTANCE ?? '';
   const senderName = env.OMNI_SENDER_NAME ?? 'whatsapp-user';
-  const turnPrompt = buildTurnBasedPrompt(senderName, instanceId, chatId);
+  const turnContext = buildTurnBasedPrompt(senderName, instanceId, chatId);
+
+  // Turn instructions go in the initial prompt (before the user's message),
+  // NOT in the system prompt. System prompt = agent identity (AGENTS.md).
+  // Turn context = operational instructions for this specific interaction.
+  const fullInitialPrompt = initialMessage ? `${turnContext}\n\n---\n\n${initialMessage}` : turnContext;
 
   return {
     provider: (entry.provider as SpawnParams['provider']) ?? 'claude',
@@ -77,8 +128,7 @@ export function buildOmniSpawnParams(
     model: entry.model,
     promptMode: entry.promptMode,
     systemPromptFile: join(entry.dir, 'AGENTS.md'),
-    systemPrompt: turnPrompt,
-    initialPrompt: initialMessage,
+    initialPrompt: fullInitialPrompt,
     nativeTeam: {
       enabled: true,
       agentName,
@@ -106,18 +156,24 @@ export class ClaudeCodeOmniExecutor implements IExecutor {
     await executeTmux(`send-keys -t '${paneId}' ${shellQuote(nudgeText)} Enter`);
   }
 
-  async spawn(agentName: string, chatId: string, env: Record<string, string>): Promise<ExecutorSession> {
+  async spawn(
+    agentName: string,
+    chatId: string,
+    env: Record<string, string>,
+    initialMessage?: string,
+  ): Promise<ExecutorSession> {
     const resolved = await directory.resolve(agentName);
     if (!resolved) throw new Error(`Agent "${agentName}" not found in genie directory`);
 
     const entry = resolved.entry;
     const tmuxSession = agentName;
-    const windowName = sanitizeWindowName(chatId);
+    const chatName = await lookupChatName(chatId, env.OMNI_INSTANCE ?? '');
+    const windowName = sanitizeWindowName(chatId, chatName ?? undefined);
     const { paneId, created } = await ensureTeamWindow(tmuxSession, windowName, entry.dir);
 
     if (created) {
       const omniEnv: Record<string, string> = { ...env, GENIE_OMNI_CHAT_ID: chatId, GENIE_OMNI_AGENT: agentName };
-      const params = buildOmniSpawnParams(agentName, chatId, entry, omniEnv);
+      const params = buildOmniSpawnParams(agentName, chatId, entry, omniEnv, initialMessage);
       const launch = buildLaunchCommand(params);
 
       // Merge omni-specific env vars with those produced by buildLaunchCommand
@@ -130,16 +186,21 @@ export class ClaudeCodeOmniExecutor implements IExecutor {
     }
 
     const sessionKey = `${agentName}:${chatId}`;
-    const executorId = await this.registerInWorldA(
+    const registration = await this.registerInWorldA(
       agentName,
       chatId,
       env.OMNI_INSTANCE ?? '',
       tmuxSession,
       windowName,
       paneId,
+      entry.dir,
     );
-    this.sessions.set(sessionKey, { executorId });
-    if (executorId) await this.updateState(executorId, 'running', chatId);
+    this.sessions.set(sessionKey, {
+      executorId: registration?.executorId ?? null,
+      agentId: registration?.agentId ?? null,
+      repoPath: entry.dir,
+    });
+    if (registration?.executorId) await this.updateState(registration.executorId, 'running', chatId);
 
     const now = Date.now();
     return {
@@ -160,7 +221,8 @@ export class ClaudeCodeOmniExecutor implements IExecutor {
     tmuxSession: string,
     tmuxWindow: string,
     tmuxPaneId: string,
-  ): Promise<string | null> {
+    repoPath: string,
+  ): Promise<{ executorId: string; agentId: string } | null> {
     if (!this.safePgCall) return null;
     const agent = await this.safePgCall(
       'tmux-find-or-create-agent',
@@ -169,6 +231,28 @@ export class ClaudeCodeOmniExecutor implements IExecutor {
       { chatId },
     );
     if (!agent) return null;
+
+    // Update agent record with pane_id and repo_path so the scheduler daemon's
+    // deliverToPane() (via PG LISTEN/NOTIFY) can resolve this agent for mailbox delivery.
+    await this.safePgCall(
+      'tmux-update-agent-pane',
+      async () => {
+        const sql = await import('../../lib/db.js').then((m) => m.getConnection());
+        await sql`
+          UPDATE agents
+          SET pane_id = ${tmuxPaneId},
+              session = ${tmuxSession},
+              repo_path = ${repoPath},
+              window_name = ${tmuxWindow},
+              state = 'idle',
+              last_state_change = now()
+          WHERE id = ${agent.id}
+        `;
+      },
+      undefined,
+      { chatId },
+    );
+
     const executor = await this.safePgCall(
       'tmux-create-executor',
       () =>
@@ -182,7 +266,7 @@ export class ClaudeCodeOmniExecutor implements IExecutor {
       null,
       { chatId },
     );
-    return executor?.id ?? null;
+    return executor ? { executorId: executor.id, agentId: agent.id } : null;
   }
 
   private async updateState(executorId: string, state: 'running' | 'working' | 'idle', chatId: string): Promise<void> {
@@ -198,30 +282,29 @@ export class ClaudeCodeOmniExecutor implements IExecutor {
   async deliver(session: ExecutorSession, message: OmniMessage): Promise<void> {
     const state = this.sessions.get(session.id);
     if (state?.executorId) await this.updateState(state.executorId, 'working', session.chatId);
-    const tmuxSessionName = session.tmux?.session ?? session.agentName;
-    const inboxDir = join(
-      process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'),
-      'teams',
-      tmuxSessionName,
-      'inboxes',
-    );
-    const inboxFile = join(inboxDir, `${sanitizeWindowName(session.chatId)}.json`);
-    mkdirSync(dirname(inboxFile), { recursive: true });
-    let messages: { from: string; text: string; summary: string; timestamp: string; read: boolean }[] = [];
-    try {
-      const { readFileSync } = await import('node:fs');
-      messages = JSON.parse(readFileSync(inboxFile, 'utf-8'));
-    } catch {
-      /* start fresh */
+
+    // Build turn context + user message for the follow-up turn
+    const senderName = message.sender || 'whatsapp-user';
+    const turnContext = buildTurnBasedPrompt(senderName, message.instanceId, session.chatId);
+    const body = `${turnContext}\n\n---\n\n[${senderName}]: ${message.content}`;
+
+    // Deliver via genie's PG mailbox pipeline:
+    //   mailbox.send() → PG INSERT + NOTIFY → scheduler daemon → deliverToPane() → tmux send-keys
+    // This provides: durability, observability (runtime_events), retry on missed NOTIFY (30s poll),
+    // and delivery confirmation (delivered_at timestamp).
+    const agentId = state?.agentId;
+    const repoPath = state?.repoPath;
+
+    if (agentId && repoPath) {
+      try {
+        await mailbox.send(repoPath, `omni:${senderName}`, agentId, body);
+      } catch (err) {
+        console.error(`[claude-code] mailbox.send failed for ${session.id}:`, err instanceof Error ? err.message : err);
+      }
+    } else {
+      console.error(`[claude-code] deliver: no agentId/repoPath for session ${session.id}, message lost`);
     }
-    messages.push({
-      from: message.sender || 'whatsapp-user',
-      text: message.content,
-      summary: message.content.slice(0, 120),
-      timestamp: message.timestamp || new Date().toISOString(),
-      read: false,
-    });
-    writeFileSync(inboxFile, JSON.stringify(messages, null, 2));
+
     session.lastActivityAt = Date.now();
     if (state?.executorId) await this.updateState(state.executorId, 'idle', session.chatId);
   }
@@ -239,6 +322,12 @@ export class ClaudeCodeOmniExecutor implements IExecutor {
           { executorId: state.executorId, chatId: session.chatId },
         );
       }
+      // Clean up agent registry so deliverToPane() won't try to deliver to a dead pane
+      if (state?.agentId && this.safePgCall) {
+        await this.safePgCall('tmux-unregister-agent', () => agents.unregister(state.agentId as string), undefined, {
+          chatId: session.chatId,
+        });
+      }
       this.sessions.delete(session.id);
     }
   }

package/src/services/executors/claude-sdk.ts

@@ -57,18 +57,23 @@ async function loadSystemPrompt(entry: directory.DirectoryEntry): Promise<string
 async function resolveSystemPrompt(
   entry: directory.DirectoryEntry,
   state: SdkSessionState,
-  message: OmniMessage,
-  chatId: string,
 ): Promise<{ prompt: string | undefined; isTurnBased: boolean }> {
-  let prompt = await loadSystemPrompt(entry);
+  const prompt = await loadSystemPrompt(entry);
   const isTurnBased = Boolean(state.env.OMNI_INSTANCE);
-  if (isTurnBased) {
-    const turnPrompt = buildTurnBasedPrompt(message.sender, state.env.OMNI_INSTANCE, state.env.OMNI_CHAT ?? chatId);
-    prompt = prompt ? `${turnPrompt}\n\n${prompt}` : turnPrompt;
-  }
+  // Turn-based instructions are injected into the user message (initialPrompt),
+  // NOT into the system prompt. System prompt = agent identity only.
   return { prompt, isTurnBased };
 }
 
+/**
+ * Build the turn context prefix for the user message.
+ * Returns empty string if not in a turn-based session.
+ */
+function buildTurnContextPrefix(state: SdkSessionState, message: OmniMessage, chatId: string): string {
+  if (!state.env.OMNI_INSTANCE) return '';
+  return buildTurnBasedPrompt(message.sender, state.env.OMNI_INSTANCE, state.env.OMNI_CHAT ?? chatId);
+}
+
 interface QueryResult {
   text: string;
   sessionId?: string;
@@ -297,7 +302,12 @@ export class ClaudeSdkOmniExecutor implements IExecutor {
     this.pendingNudges.set(session.id, text);
   }
 
-  async spawn(agentName: string, chatId: string, env: Record<string, string>): Promise<ExecutorSession> {
+  async spawn(
+    agentName: string,
+    chatId: string,
+    env: Record<string, string>,
+    _initialMessage?: string,
+  ): Promise<ExecutorSession> {
     const resolved = await directory.resolve(agentName);
     if (!resolved) {
       throw new Error(`Agent "${agentName}" not found in genie directory`);
@@ -437,7 +447,7 @@ export class ClaudeSdkOmniExecutor implements IExecutor {
 
     const entry = resolved.entry;
     const permissionConfig = resolvePermissionConfig(entry.permissions);
-    const { prompt: systemPrompt, isTurnBased } = await resolveSystemPrompt(entry, state, message, session.chatId);
+    const { prompt: systemPrompt, isTurnBased } = await resolveSystemPrompt(entry, state);
 
     if (state.executorId) await this.updateState(state.executorId, 'working', session.chatId);
 
@@ -470,12 +480,17 @@ export class ClaudeSdkOmniExecutor implements IExecutor {
       extraOptions.resume = state.claudeSessionId;
     }
 
+    // Build query content: turn context (if turn-based) + nudge (if pending) + user message
+    const turnPrefix = buildTurnContextPrefix(state, message, session.chatId);
     let queryContent = message.content;
     const pendingNudge = this.pendingNudges.get(session.id);
     if (pendingNudge) {
       queryContent = `[system] ${pendingNudge}\n\n${message.content}`;
       this.pendingNudges.delete(session.id);
     }
+    if (turnPrefix) {
+      queryContent = `${turnPrefix}\n\n---\n\n${queryContent}`;
+    }
 
     const { messages: queryMessages } = state.provider.runQuery(
       {

package/src/services/executors/turn-based-prompt.ts

@@ -1,38 +1,28 @@
 /**
- * Turn-based WhatsApp system prompt for agents spawned via the Omni bridge.
+ * Turn-based WhatsApp orchestration prompt for agents spawned via the Omni bridge.
  *
- * Injected on every delivery when OMNI_INSTANCE is present in the executor env.
- * Teaches the agent how to reply via omni CLI verbs and close the turn.
+ * Injected as a prefix to the initial user message (NOT in the system prompt).
+ * This is operational context — it tells the agent HOW to interact in this turn,
+ * not WHO it is. Identity stays in AGENTS.md (system prompt).
  */
 
 export function buildTurnBasedPrompt(senderName: string, instanceId: string, chatId: string): string {
   return `
-# WhatsApp Turn-Based Conversation
+[WhatsApp Turn — reply to ${senderName}]
 
-You are responding to a WhatsApp message from ${senderName}.
-Your context is pre-set (instance: ${instanceId}, chat: ${chatId}) — do NOT use \`omni use\` or \`omni open\`.
+You received a WhatsApp message. Read it, reply, then close the turn.
+Context is pre-set (instance: ${instanceId}, chat: ${chatId}) — do NOT run \`omni use\` or \`omni open\`.
 
-## Reply Channels
+Reply with omni verbs:
+- \`omni say "your reply"\` — send a text message
+- \`omni speak "text" --voice Kore\` — send a voice note
+- \`omni imagine "prompt"\` — generate and send an image
+- \`omni react "👍"\` — react to the trigger message
+- \`omni done\` — close the turn (ALWAYS your last action)
 
-You have two equivalent ways to send a reply to the user:
+Flow: 1) \`omni say "..."\` to reply → 2) \`omni done\` to close.
+Bare text output goes nowhere — you MUST use omni verbs to reach the user.
 
-1. **SendMessage** (preferred): \`SendMessage(recipient: "omni", message: "your reply")\` —
-   intercepted by the omni bridge and delivered as a WhatsApp text message.
-   You may call SendMessage multiple times in one turn for multi-message replies.
-2. **omni done text='...'** — closes the turn AND sends a final text in one call.
-
-## Available Tools
-
-- SendMessage(recipient: "omni", message: '...') — send a text reply (repeatable)
-- omni done text='...' — send final text + close turn (use as the LAST action)
-- omni done react='emoji' — react instead of replying, then close turn
-- omni done media='/path' caption='...' — send media + close turn
-- omni done skip=true — close turn silently
-
-## Rules
-
-1. Use \`SendMessage(recipient: "omni", ...)\` for normal text replies.
-2. ALWAYS call \`omni done\` as your LAST action to close the turn — even if you already sent SendMessage replies, call \`omni done skip=true\`.
-3. Do NOT generate bare text as your reply — it will go nowhere. Use SendMessage or omni done.
+The user's message:
 `.trim();
 }