Extract message runtime final delivery

src/message-runtime-final-delivery.test.ts

@@ -0,0 +1,216 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('./db.js', () => ({
+  createProducedWorkItem: vi.fn((args) => ({
+    id: 123,
+    chat_jid: args.chat_jid,
+    delivery_role: args.delivery_role,
+    result_payload: args.result_payload,
+    attachments: args.attachments,
+    delivery_attempts: 0,
+  })),
+}));
+
+vi.mock('./logger.js', () => ({
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+vi.mock('./message-runtime-delivery.js', () => ({
+  deliverOpenWorkItem: vi.fn(() => Promise.resolve(true)),
+}));
+
+import { createProducedWorkItem } from './db.js';
+import { logger } from './logger.js';
+import { deliverOpenWorkItem } from './message-runtime-delivery.js';
+import { deliverMessageRuntimeFinalText } from './message-runtime-final-delivery.js';
+import type { Channel, RegisteredGroup } from './types.js';
+
+function makeChannel(): Channel {
+  return {
+    name: 'discord-owner',
+    connect: vi.fn(),
+    sendMessage: vi.fn(),
+    isConnected: vi.fn(() => true),
+    ownsJid: vi.fn(() => true),
+    disconnect: vi.fn(),
+  } as unknown as Channel;
+}
+
+function makeGroup(overrides: Partial<RegisteredGroup> = {}): RegisteredGroup {
+  return {
+    name: 'Room',
+    folder: 'room-folder',
+    added_at: '2026-04-29T01:00:00.000Z',
+    ...overrides,
+  };
+}
+
+describe('message-runtime-final-delivery', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(deliverOpenWorkItem).mockResolvedValue(true);
+    vi.mocked(createProducedWorkItem).mockImplementation(
+      (args: any) =>
+        ({
+          id: 123,
+          chat_jid: args.chat_jid,
+          delivery_role: args.delivery_role,
+          result_payload: args.result_payload,
+          attachments: args.attachments,
+          delivery_attempts: 0,
+        }) as any,
+    );
+  });
+
+  it.each(['reviewer', 'arbiter'] as const)(
+    'skips %s work item delivery after direct terminal IPC delivery',
+    async (deliveryRole) => {
+      const hasDirectTerminalDeliveryForRun = vi.fn(() => true);
+
+      const result = await deliverMessageRuntimeFinalText({
+        text: `${deliveryRole} final`,
+        chatJid: 'chat-1',
+        runId: 'run-1',
+        channel: makeChannel(),
+        group: makeGroup(),
+        startSeq: 10,
+        endSeq: 11,
+        deliveryRole,
+        deliveryServiceId: 'codex-main',
+        hasDirectTerminalDeliveryForRun,
+        isDuplicateOfLastBotFinal: vi.fn(),
+        openContinuation: vi.fn(),
+      });
+
+      expect(result).toBe(true);
+      expect(hasDirectTerminalDeliveryForRun).toHaveBeenCalledWith(
+        'chat-1',
+        'run-1',
+        deliveryRole,
+      );
+      expect(createProducedWorkItem).not.toHaveBeenCalled();
+      expect(deliverOpenWorkItem).not.toHaveBeenCalled();
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chatJid: 'chat-1',
+          runId: 'run-1',
+          deliveryRole,
+        }),
+        'Skipping final work item delivery because this run already sent a direct terminal IPC message',
+      );
+    },
+  );
+
+  it('creates and delivers a produced work item with default agent type and attachment roots', async () => {
+    const channel = makeChannel();
+    const isDuplicateOfLastBotFinal = vi.fn(() => false);
+    const openContinuation = vi.fn();
+    const attachments = [
+      {
+        path: '/tmp/image.png',
+        name: 'image.png',
+        mime: 'image/png',
+      },
+    ];
+
+    const result = await deliverMessageRuntimeFinalText({
+      text: 'owner final',
+      attachments,
+      chatJid: 'chat-1',
+      runId: 'run-owner',
+      channel,
+      group: makeGroup({ workDir: '/work/room' }),
+      startSeq: 1,
+      endSeq: 2,
+      deliveryRole: 'owner',
+      deliveryServiceId: null,
+      hasDirectTerminalDeliveryForRun: vi.fn(() => true),
+      isDuplicateOfLastBotFinal,
+      openContinuation,
+    });
+
+    expect(result).toBe(true);
+    expect(createProducedWorkItem).toHaveBeenCalledWith({
+      group_folder: 'room-folder',
+      chat_jid: 'chat-1',
+      agent_type: 'claude-code',
+      service_id: undefined,
+      delivery_role: 'owner',
+      start_seq: 1,
+      end_seq: 2,
+      result_payload: 'owner final',
+      attachments,
+    });
+    expect(deliverOpenWorkItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channel,
+        log: logger,
+        attachmentBaseDirs: ['/work/room'],
+        replaceMessageId: undefined,
+        isDuplicateOfLastBotFinal,
+        openContinuation,
+      }),
+    );
+  });
+
+  it('preserves forced agent, delivery service, and replacement message metadata', async () => {
+    const channel = makeChannel();
+
+    await deliverMessageRuntimeFinalText({
+      text: 'forced final',
+      chatJid: 'chat-1',
+      runId: 'run-forced',
+      channel,
+      group: makeGroup({ agentType: 'claude-code' }),
+      startSeq: null,
+      endSeq: null,
+      forcedAgentType: 'codex',
+      deliveryRole: 'arbiter',
+      deliveryServiceId: 'codex-main',
+      replaceMessageId: 'discord-message-1',
+      hasDirectTerminalDeliveryForRun: vi.fn(() => false),
+      isDuplicateOfLastBotFinal: vi.fn(),
+      openContinuation: vi.fn(),
+    });
+
+    expect(createProducedWorkItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        agent_type: 'codex',
+        service_id: 'codex-main',
+        delivery_role: 'arbiter',
+        start_seq: null,
+        end_seq: null,
+      }),
+    );
+    expect(deliverOpenWorkItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        replaceMessageId: 'discord-message-1',
+        attachmentBaseDirs: undefined,
+      }),
+    );
+  });
+
+  it('returns the deliverOpenWorkItem result', async () => {
+    vi.mocked(deliverOpenWorkItem).mockResolvedValue(false);
+
+    await expect(
+      deliverMessageRuntimeFinalText({
+        text: 'failed final',
+        chatJid: 'chat-1',
+        runId: 'run-failed',
+        channel: makeChannel(),
+        group: makeGroup(),
+        startSeq: 1,
+        endSeq: 2,
+        deliveryRole: null,
+        deliveryServiceId: null,
+        isDuplicateOfLastBotFinal: vi.fn(),
+        openContinuation: vi.fn(),
+      }),
+    ).resolves.toBe(false);
+  });
+});