openclaw-codex-app-server 0.0.0

package/src/controller.test.ts

@@ -0,0 +1,1177 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { OpenClawPluginApi, PluginCommandContext } from "openclaw/plugin-sdk";
+import { CodexPluginController } from "./controller.js";
+
+function makeStateDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-app-server-test-"));
+}
+
+function createApiMock() {
+  const stateDir = makeStateDir();
+  const sendComponentMessage = vi.fn(async () => ({}));
+  const sendMessageDiscord = vi.fn(async () => ({}));
+  const sendMessageTelegram = vi.fn(async () => ({}));
+  const discordTypingStart = vi.fn(async () => ({ refresh: vi.fn(async () => {}), stop: vi.fn() }));
+  const renameTopic = vi.fn(async () => ({}));
+  const api = {
+    id: "test-plugin",
+    pluginConfig: {
+      enabled: true,
+      defaultWorkspaceDir: "/repo/openclaw",
+    },
+    logger: {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    },
+    runtime: {
+      state: {
+        resolveStateDir: () => stateDir,
+      },
+      channel: {
+        bindings: {
+          bind: vi.fn(async () => ({})),
+          unbind: vi.fn(async () => []),
+          resolveByConversation: vi.fn(() => null),
+        },
+        text: {
+          chunkText: (text: string) => [text],
+          resolveTextChunkLimit: (_cfg: unknown, _provider?: string, _accountId?: string | null, opts?: { fallbackLimit?: number }) =>
+            opts?.fallbackLimit ?? 2000,
+        },
+        telegram: {
+          sendMessageTelegram,
+          typing: {
+            start: vi.fn(async () => ({ refresh: vi.fn(async () => {}), stop: vi.fn() })),
+          },
+          conversationActions: {
+            renameTopic,
+          },
+        },
+        discord: {
+          sendMessageDiscord,
+          sendComponentMessage,
+          typing: {
+            start: discordTypingStart,
+          },
+          conversationActions: {
+            editChannel: vi.fn(async () => ({})),
+          },
+        },
+      },
+    },
+    registerService: vi.fn(),
+    registerInteractiveHandler: vi.fn(),
+    registerCommand: vi.fn(),
+    on: vi.fn(),
+  } as unknown as OpenClawPluginApi;
+  return {
+    api,
+    sendComponentMessage,
+    sendMessageDiscord,
+    sendMessageTelegram,
+    discordTypingStart,
+    renameTopic,
+    stateDir,
+  };
+}
+
+async function createControllerHarness() {
+  const {
+    api,
+    sendComponentMessage,
+    sendMessageDiscord,
+    sendMessageTelegram,
+    discordTypingStart,
+    renameTopic,
+    stateDir,
+  } = createApiMock();
+  const controller = new CodexPluginController(api);
+  await controller.start();
+  const clientMock = {
+    listThreads: vi.fn(async () => [
+      {
+        threadId: "thread-1",
+        title: "Discord Thread",
+        projectKey: "/repo/openclaw",
+        createdAt: Date.now() - 60_000,
+        updatedAt: Date.now() - 30_000,
+      },
+    ]),
+    listModels: vi.fn(async () => [
+      { id: "openai/gpt-5.4", current: true },
+      { id: "openai/gpt-5.3" },
+    ]),
+    listSkills: vi.fn(async () => [
+      { name: "skill-a", description: "Skill A", cwd: "/repo/openclaw" },
+      { name: "skill-b", description: "Skill B", cwd: "/repo/openclaw" },
+    ]),
+    readThreadState: vi.fn(async () => ({
+      threadId: "thread-1",
+      threadName: "Discord Thread",
+      model: "openai/gpt-5.4",
+      cwd: "/repo/openclaw",
+      serviceTier: "default",
+    })),
+    readThreadContext: vi.fn(async () => ({
+      lastUserMessage: undefined,
+      lastAssistantMessage: undefined,
+    })),
+    setThreadName: vi.fn(async () => ({
+      threadId: "thread-1",
+      threadName: "Discord Thread",
+    })),
+    readAccount: vi.fn(async () => ({
+      email: "test@example.com",
+      planType: "pro",
+      type: "chatgpt",
+    })),
+    readRateLimits: vi.fn(async () => []),
+  };
+  (controller as any).client = clientMock;
+  (controller as any).readThreadHasChanges = vi.fn(async () => false);
+  return {
+    controller,
+    api,
+    clientMock,
+    sendComponentMessage,
+    sendMessageDiscord,
+    sendMessageTelegram,
+    discordTypingStart,
+    renameTopic,
+    stateDir,
+  };
+}
+
+async function createControllerHarnessWithoutLegacyBindings() {
+  const harness = createApiMock();
+  delete (harness.api as any).runtime.channel.bindings;
+  const controller = new CodexPluginController(harness.api);
+  await controller.start();
+  return {
+    controller,
+    api: harness.api,
+  };
+}
+
+function buildDiscordCommandContext(
+  overrides: Partial<PluginCommandContext> & Record<string, unknown> = {},
+): PluginCommandContext {
+  return {
+    senderId: "user-1",
+    channel: "discord",
+    channelId: "discord",
+    isAuthorizedSender: true,
+    args: "",
+    commandBody: "/codex_resume",
+    config: {},
+    from: "discord:channel:chan-1",
+    to: "slash:user-1",
+    accountId: "default",
+    requestConversationBinding: vi.fn(async () => ({ status: "bound" as const })),
+    detachConversationBinding: vi.fn(async () => ({ removed: true })),
+    getCurrentConversationBinding: vi.fn(async () => null),
+    ...overrides,
+  } as unknown as PluginCommandContext;
+}
+
+function buildTelegramCommandContext(
+  overrides: Partial<PluginCommandContext> & Record<string, unknown> = {},
+): PluginCommandContext {
+  return {
+    senderId: "user-1",
+    channel: "telegram",
+    channelId: "telegram",
+    isAuthorizedSender: true,
+    args: "",
+    commandBody: "/codex_status",
+    config: {},
+    from: "telegram:123",
+    to: "telegram:123",
+    accountId: "default",
+    requestConversationBinding: vi.fn(async () => ({ status: "bound" as const })),
+    detachConversationBinding: vi.fn(async () => ({ removed: true })),
+    getCurrentConversationBinding: vi.fn(async () => null),
+    ...overrides,
+  } as unknown as PluginCommandContext;
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("Discord controller flows", () => {
+  it("starts cleanly without the legacy runtime.channel.bindings surface", async () => {
+    const { controller } = await createControllerHarnessWithoutLegacyBindings();
+
+    expect(controller).toBeInstanceOf(CodexPluginController);
+  });
+
+  it("uses the real Discord conversation target for slash-command resume pickers", async () => {
+    const { controller, sendComponentMessage } = await createControllerHarness();
+
+    const reply = await controller.handleCommand("codex_resume", buildDiscordCommandContext());
+
+    expect(reply).toEqual({
+      text: "Sent a Codex thread picker to this Discord conversation.",
+    });
+    expect(sendComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      expect.objectContaining({
+        text: expect.stringContaining("Showing recent Codex sessions"),
+      }),
+      expect.objectContaining({
+        accountId: "default",
+      }),
+    );
+  });
+
+  it("sends Discord model pickers directly instead of returning Telegram buttons", async () => {
+    const { controller, sendComponentMessage } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+
+    const reply = await controller.handleCommand("codex_model", buildDiscordCommandContext({
+      commandBody: "/codex_model",
+      getCurrentConversationBinding: vi.fn(async () => ({ bindingId: "b1" })),
+    }));
+
+    expect(reply).toEqual({
+      text: "Sent Codex model choices to this Discord conversation.",
+    });
+    expect(sendComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      expect.objectContaining({
+        text: expect.stringContaining("Current model"),
+      }),
+      expect.objectContaining({ accountId: "default" }),
+    );
+  });
+
+  it("sends Discord skills directly instead of returning Telegram buttons", async () => {
+    const { controller, sendComponentMessage } = await createControllerHarness();
+
+    const reply = await controller.handleCommand("codex_skills", buildDiscordCommandContext({
+      commandBody: "/codex_skills",
+    }));
+
+    expect(reply).toEqual({
+      text: "Sent Codex skills to this Discord conversation.",
+    });
+    expect(sendComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      expect.objectContaining({
+        text: expect.stringContaining("Codex skills"),
+      }),
+      expect.objectContaining({ accountId: "default" }),
+    );
+  });
+
+  it("refreshes Discord pickers by clearing the old components and sending a new picker", async () => {
+    const { controller, sendComponentMessage } = await createControllerHarness();
+    const callback = await (controller as any).store.putCallback({
+      kind: "picker-view",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      view: {
+        mode: "threads",
+        includeAll: true,
+        page: 0,
+      },
+    });
+    const clearComponents = vi.fn(async () => {});
+
+    await controller.handleDiscordInteractive({
+      channel: "discord",
+      accountId: "default",
+      interactionId: "interaction-1",
+      conversationId: "channel:chan-1",
+      auth: { isAuthorizedSender: true },
+      interaction: {
+        kind: "button",
+        data: `codexapp:${callback.token}`,
+        namespace: "codexapp",
+        payload: callback.token,
+        messageId: "message-1",
+      },
+      senderId: "user-1",
+      senderUsername: "Ada",
+      respond: {
+        acknowledge: vi.fn(async () => {}),
+        reply: vi.fn(async () => {}),
+        followUp: vi.fn(async () => {}),
+        editMessage: vi.fn(async () => {}),
+        clearComponents,
+      },
+    } as any);
+
+    expect(clearComponents).toHaveBeenCalledWith(
+      expect.objectContaining({
+        text: expect.stringContaining("Showing recent Codex sessions"),
+      }),
+    );
+    expect(sendComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      expect.objectContaining({
+        text: expect.stringContaining("Showing recent Codex sessions"),
+      }),
+      expect.objectContaining({ accountId: "default" }),
+    );
+  });
+
+  it("refreshes the Discord project picker without using interactive editMessage components", async () => {
+    const { controller, sendComponentMessage } = await createControllerHarness();
+    const callback = await (controller as any).store.putCallback({
+      kind: "picker-view",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      view: {
+        mode: "projects",
+        includeAll: true,
+        page: 0,
+      },
+    });
+    const editMessage = vi.fn(async () => {});
+
+    await controller.handleDiscordInteractive({
+      channel: "discord",
+      accountId: "default",
+      interactionId: "interaction-1",
+      conversationId: "channel:chan-1",
+      auth: { isAuthorizedSender: true },
+      interaction: {
+        kind: "button",
+        data: `codexapp:${callback.token}`,
+        namespace: "codexapp",
+        payload: callback.token,
+        messageId: "message-1",
+      },
+      senderId: "user-1",
+      senderUsername: "Ada",
+      respond: {
+        acknowledge: vi.fn(async () => {}),
+        reply: vi.fn(async () => {}),
+        followUp: vi.fn(async () => {}),
+        editMessage,
+        clearComponents: vi.fn(async () => {}),
+      },
+    } as any);
+
+    expect(editMessage).not.toHaveBeenCalled();
+    expect(sendComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      expect.objectContaining({
+        text: expect.stringContaining("Choose a project to filter recent Codex sessions"),
+      }),
+      expect.objectContaining({ accountId: "default" }),
+    );
+  });
+
+  it("normalizes raw Discord callback conversation ids for guild interactions", async () => {
+    const { controller, sendComponentMessage } = await createControllerHarness();
+    const callback = await (controller as any).store.putCallback({
+      kind: "picker-view",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      view: {
+        mode: "projects",
+        includeAll: true,
+        page: 0,
+      },
+    });
+
+    await controller.handleDiscordInteractive({
+      channel: "discord",
+      accountId: "default",
+      interactionId: "interaction-1",
+      conversationId: "1481858418548412579",
+      guildId: "guild-1",
+      auth: { isAuthorizedSender: true },
+      interaction: {
+        kind: "button",
+        data: `codexapp:${callback.token}`,
+        namespace: "codexapp",
+        payload: callback.token,
+        messageId: "message-1",
+      },
+      senderId: "user-1",
+      senderUsername: "Ada",
+      respond: {
+        acknowledge: vi.fn(async () => {}),
+        reply: vi.fn(async () => {}),
+        followUp: vi.fn(async () => {}),
+        editMessage: vi.fn(async () => {}),
+        clearComponents: vi.fn(async () => {
+          throw new Error("Interaction has already been acknowledged.");
+        }),
+      },
+    } as any);
+
+    expect(sendComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      expect.objectContaining({
+        text: expect.stringContaining("Choose a project to filter recent Codex sessions"),
+      }),
+      expect.objectContaining({ accountId: "default" }),
+    );
+  });
+
+  it("hydrates a pending approved binding when status is requested after core approval", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertPendingBind({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      threadTitle: "Discord Thread",
+      updatedAt: Date.now(),
+    });
+
+    const reply = await controller.handleCommand("codex_status", buildDiscordCommandContext({
+      commandBody: "/codex_status",
+      getCurrentConversationBinding: vi.fn(async () => ({ bindingId: "b1" })),
+    }));
+
+    expect(reply.text).toContain("Binding: active");
+    expect((controller as any).store.getBinding({
+      channel: "discord",
+      accountId: "default",
+      conversationId: "channel:chan-1",
+    })).toEqual(
+      expect.objectContaining({
+        threadId: "thread-1",
+        workspaceDir: "/repo/openclaw",
+      }),
+    );
+  });
+
+  it("shows codex_status as none when no core binding exists", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "user:1177378744822943744",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/discrawl",
+      threadTitle: "Summarize tools used",
+      updatedAt: Date.now(),
+    });
+
+    const reply = await controller.handleCommand(
+      "codex_status",
+      buildDiscordCommandContext({
+        from: "discord:1177378744822943744",
+        to: "slash:1177378744822943744",
+        commandBody: "/codex_status",
+        getCurrentConversationBinding: vi.fn(async () => null),
+      }),
+    );
+
+    expect(reply.text).toContain("Binding: none");
+    expect(reply.text).not.toContain("Project folder: /repo/discrawl");
+    expect(reply.text).not.toContain("Session: session-1");
+  });
+
+  it("does not hydrate a denied pending bind into codex_status", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertPendingBind({
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/repo/discrawl",
+      threadTitle: "Summarize tools used",
+      updatedAt: Date.now(),
+    });
+
+    const reply = await controller.handleCommand(
+      "codex_status",
+      buildTelegramCommandContext({
+        commandBody: "/codex_status",
+        getCurrentConversationBinding: vi.fn(async () => null),
+      }),
+    );
+
+    expect(reply.text).toContain("Binding: none");
+    expect(reply.text).not.toContain("Project folder: /repo/discrawl");
+    expect((controller as any).store.getBinding({
+      channel: "telegram",
+      accountId: "default",
+      conversationId: "123",
+    })).toBeNull();
+  });
+
+  it("shows plan mode on in codex_status when the bound conversation has an active plan run", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      threadTitle: "Discord Thread",
+      updatedAt: Date.now(),
+    });
+    (controller as any).activeRuns.set("discord::default::channel:chan-1::", {
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      workspaceDir: "/repo/openclaw",
+      mode: "plan",
+      handle: {
+        result: Promise.resolve({ threadId: "thread-1", text: "planned" }),
+        queueMessage: vi.fn(async () => true),
+        getThreadId: () => "thread-1",
+        interrupt: vi.fn(async () => {}),
+        isAwaitingInput: () => false,
+        submitPendingInput: vi.fn(async () => false),
+        submitPendingInputPayload: vi.fn(async () => false),
+      },
+    });
+
+    const reply = await controller.handleCommand("codex_status", buildDiscordCommandContext({
+      commandBody: "/codex_status",
+      getCurrentConversationBinding: vi.fn(async () => ({ bindingId: "b1" })),
+    }));
+
+    expect(reply.text).toContain("Binding: active");
+    expect(reply.text).toContain("Plan mode: on");
+  });
+
+  it("parses unicode em dash --sync for codex_rename and renames the Telegram topic", async () => {
+    const { controller, clientMock, renameTopic } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123:topic:456",
+        parentConversationId: "123",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      threadTitle: "Old Name",
+      updatedAt: Date.now(),
+    });
+    clientMock.setThreadName = vi.fn(async () => ({
+      threadId: "thread-1",
+      threadName: "New Topic Name",
+    }));
+
+    const reply = await controller.handleCommand(
+      "codex_rename",
+      buildTelegramCommandContext({
+        args: "—sync New Topic Name",
+        commandBody: "/codex_rename —sync New Topic Name",
+        messageThreadId: 456,
+        getCurrentConversationBinding: vi.fn(async () => ({ bindingId: "b1" })),
+      }),
+    );
+
+    expect(clientMock.setThreadName).toHaveBeenCalledWith({
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      name: "New Topic Name",
+    });
+    expect(renameTopic).toHaveBeenCalledWith(
+      "123",
+      456,
+      "New Topic Name",
+      expect.objectContaining({ accountId: "default" }),
+    );
+    expect(reply).toEqual({ text: 'Renamed the Codex thread to "New Topic Name".' });
+  });
+
+  it("offers compact rename style buttons for codex_rename --sync without a name", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123:topic:456",
+        parentConversationId: "123",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      threadTitle: "Discord Thread",
+      updatedAt: Date.now(),
+    });
+
+    const reply = await controller.handleCommand(
+      "codex_rename",
+      buildTelegramCommandContext({
+        args: "--sync",
+        commandBody: "/codex_rename --sync",
+        messageThreadId: 456,
+        getCurrentConversationBinding: vi.fn(async () => ({ bindingId: "b1" })),
+      }),
+    );
+
+    expect(reply.text).toContain("Choose a name style");
+    const buttons = (reply.channelData as any)?.telegram?.buttons;
+    expect(buttons).toHaveLength(2);
+    expect(buttons[0][0].text).toBe("Discord Thread (openclaw)");
+    expect(buttons[1][0].text).toBe("Discord Thread");
+    expect(String(buttons[0][0].callback_data)).toMatch(/^codexapp:/);
+    expect(String(buttons[0][0].callback_data).length).toBeLessThan(64);
+  });
+
+  it("deduplicates repeated project suffixes in rename style suggestions", async () => {
+    const { controller } = await createControllerHarness();
+    (controller as any).client.readThreadState = vi.fn(async () => ({
+      threadId: "thread-1",
+      threadName: "Explore OAuth login for gifgrep (gifgrep) (gifgrep)",
+      cwd: "/repo/gifgrep",
+    }));
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123:topic:456",
+        parentConversationId: "123",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/gifgrep",
+      threadTitle: "Explore OAuth login for gifgrep (gifgrep) (gifgrep)",
+      updatedAt: Date.now(),
+    });
+
+    const reply = await controller.handleCommand(
+      "codex_rename",
+      buildTelegramCommandContext({
+        args: "--sync",
+        commandBody: "/codex_rename --sync",
+        messageThreadId: 456,
+        getCurrentConversationBinding: vi.fn(async () => ({ bindingId: "b1" })),
+      }),
+    );
+
+    const buttons = (reply.channelData as any)?.telegram?.buttons;
+    expect(buttons).toHaveLength(2);
+    expect(buttons[0][0].text).toBe("Explore OAuth login for gifgrep (gifgrep)");
+    expect(buttons[1][0].text).toBe("Explore OAuth login for gifgrep");
+  });
+
+  it("requests approved conversation binding when binding a Discord thread", async () => {
+    const { controller } = await createControllerHarness();
+    const requestConversationBinding = vi.fn(async () => ({ status: "bound" as const }));
+
+    await controller.handleCommand("codex_resume", buildDiscordCommandContext({
+      args: "thread-1",
+      commandBody: "/codex_resume thread-1",
+      requestConversationBinding,
+    }));
+
+    expect(requestConversationBinding).toHaveBeenCalledWith(
+      expect.objectContaining({
+        summary: expect.stringContaining("Bind this conversation to Codex thread"),
+      }),
+    );
+  });
+
+  it("claims inbound Discord messages for raw thread ids after a typed bind", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:1481858418548412579",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+    const startTurn = vi.fn(() => ({
+      result: Promise.resolve({
+        threadId: "thread-1",
+        text: "hello",
+      }),
+      getThreadId: () => "thread-1",
+      queueMessage: vi.fn(async () => true),
+    }));
+    (controller as any).client.startTurn = startTurn;
+
+    const result = await controller.handleInboundClaim({
+      content: "who are you?",
+      channel: "discord",
+      accountId: "default",
+      conversationId: "1481858418548412579",
+      isGroup: true,
+      metadata: { guildId: "guild-1" },
+    });
+
+    expect(result).toEqual({ handled: true });
+    expect(startTurn).toHaveBeenCalled();
+  });
+
+  it("matches a Discord binding even when the inbound event includes a parent conversation id", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:1481858418548412579",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+    const startTurn = vi.fn(() => ({
+      result: Promise.resolve({
+        threadId: "thread-1",
+        text: "hello",
+      }),
+      getThreadId: () => "thread-1",
+      queueMessage: vi.fn(async () => true),
+    }));
+    (controller as any).client.startTurn = startTurn;
+
+    const result = await controller.handleInboundClaim({
+      content: "What is the CWD?",
+      channel: "discord",
+      accountId: "default",
+      conversationId: "1481858418548412579",
+      parentConversationId: "987654321",
+      isGroup: true,
+      metadata: { guildId: "guild-1" },
+    });
+
+    expect(result).toEqual({ handled: true });
+    expect(startTurn).toHaveBeenCalled();
+  });
+
+  it("does not claim inbound Discord messages when only core binding state exists", async () => {
+    const { controller } = await createControllerHarness();
+
+    const result = await controller.handleInboundClaim({
+      content: "who are you?",
+      channel: "discord",
+      accountId: "default",
+      conversationId: "1481858418548412579",
+      isGroup: true,
+      metadata: { guildId: "guild-1" },
+    });
+
+    expect(result).toEqual({ handled: false });
+  });
+
+  it("uses a raw Discord channel id for the typing lease on inbound claims", async () => {
+    const { controller, discordTypingStart } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:1481858418548412579",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+    (controller as any).client.startTurn = vi.fn(() => ({
+      result: Promise.resolve({
+        threadId: "thread-1",
+        text: "hello",
+      }),
+      getThreadId: () => "thread-1",
+      queueMessage: vi.fn(async () => true),
+    }));
+
+    const result = await controller.handleInboundClaim({
+      content: "hello",
+      channel: "discord",
+      accountId: "default",
+      conversationId: "1481858418548412579",
+      isGroup: true,
+      metadata: { guildId: "guild-1" },
+    });
+
+    expect(result).toEqual({ handled: true });
+    expect(discordTypingStart).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channelId: "1481858418548412579",
+        accountId: "default",
+      }),
+    );
+  });
+
+  it("skips the Discord typing lease for bound DM inbound claims", async () => {
+    const { controller, discordTypingStart } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "user:1177378744822943744",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+    (controller as any).client.startTurn = vi.fn(() => ({
+      result: Promise.resolve({
+        threadId: "thread-1",
+        text: "hello",
+      }),
+      getThreadId: () => "thread-1",
+      queueMessage: vi.fn(async () => true),
+    }));
+
+    const result = await controller.handleInboundClaim({
+      content: "hello",
+      channel: "discord",
+      accountId: "default",
+      conversationId: "user:1177378744822943744",
+      isGroup: false,
+      metadata: {},
+    });
+
+    expect(result).toEqual({ handled: true });
+    expect(discordTypingStart).not.toHaveBeenCalled();
+  });
+
+  it("implements a plan by switching back to default mode with a short prompt", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+    const callback = await (controller as any).store.putCallback({
+      kind: "run-prompt",
+      token: "run-prompt-token",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      workspaceDir: "/repo/openclaw",
+      prompt: "Implement the plan.",
+      collaborationMode: {
+        mode: "default",
+        settings: {
+          model: "openai/gpt-5.4",
+          developerInstructions: null,
+        },
+      },
+    });
+    const startTurn = vi.fn(() => ({
+      result: Promise.resolve({
+        threadId: "thread-1",
+        text: "implemented",
+      }),
+      getThreadId: () => "thread-1",
+      queueMessage: vi.fn(async () => true),
+      interrupt: vi.fn(async () => {}),
+      isAwaitingInput: () => false,
+      submitPendingInput: vi.fn(async () => false),
+      submitPendingInputPayload: vi.fn(async () => false),
+    }));
+    (controller as any).client.startTurn = startTurn;
+    const reply = vi.fn(async () => {});
+
+    await controller.handleDiscordInteractive({
+      channel: "discord",
+      accountId: "default",
+      interactionId: "interaction-1",
+      conversationId: "channel:chan-1",
+      auth: { isAuthorizedSender: true },
+      interaction: {
+        kind: "button",
+        data: `codexapp:${callback.token}`,
+        namespace: "codexapp",
+        payload: callback.token,
+        messageId: "message-1",
+      },
+      senderId: "user-1",
+      senderUsername: "Ada",
+      respond: {
+        acknowledge: vi.fn(async () => {}),
+        reply,
+        followUp: vi.fn(async () => {}),
+        editMessage: vi.fn(async () => {}),
+        clearComponents: vi.fn(async () => {}),
+      },
+    } as any);
+
+    expect(reply).toHaveBeenCalledWith({ text: "Sent the plan to Codex.", ephemeral: true });
+    expect(startTurn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: "Implement the plan.",
+        collaborationMode: {
+          mode: "default",
+          settings: {
+            model: "openai/gpt-5.4",
+            developerInstructions: null,
+          },
+        },
+      }),
+    );
+  });
+
+  it("supports codex_plan off to interrupt an active plan run", async () => {
+    const { controller } = await createControllerHarness();
+    const interrupt = vi.fn(async () => {});
+    (controller as any).activeRuns.set("discord::default::channel:chan-1::", {
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      workspaceDir: "/repo/openclaw",
+      mode: "plan",
+      handle: {
+        result: Promise.resolve({ threadId: "thread-1", text: "planned" }),
+        queueMessage: vi.fn(async () => true),
+        getThreadId: () => "thread-1",
+        interrupt,
+        isAwaitingInput: () => false,
+        submitPendingInput: vi.fn(async () => false),
+        submitPendingInputPayload: vi.fn(async () => false),
+      },
+    });
+
+    const reply = await controller.handleCommand(
+      "codex_plan",
+      buildDiscordCommandContext({
+        args: "off",
+        commandBody: "/codex_plan off",
+      }),
+    );
+
+    expect(interrupt).toHaveBeenCalled();
+    expect(reply).toEqual({
+      text: "Exited Codex plan mode. Future turns will use default coding mode.",
+    });
+  });
+
+  it("restarts a lingering active plan run instead of queueing a normal inbound message into it", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:1481858418548412579",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+    const staleQueueMessage = vi.fn(async () => true);
+    const staleInterrupt = vi.fn(async () => {});
+    (controller as any).activeRuns.set("discord::default::channel:1481858418548412579::", {
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:1481858418548412579",
+      },
+      workspaceDir: "/repo/openclaw",
+      mode: "plan",
+      handle: {
+        result: Promise.resolve({ threadId: "thread-1", text: "stale-plan" }),
+        queueMessage: staleQueueMessage,
+        getThreadId: () => "thread-1",
+        interrupt: staleInterrupt,
+        isAwaitingInput: () => false,
+        submitPendingInput: vi.fn(async () => false),
+        submitPendingInputPayload: vi.fn(async () => false),
+      },
+    });
+    const startTurn = vi.fn(() => ({
+      result: Promise.resolve({
+        threadId: "thread-1",
+        text: "hello",
+      }),
+      getThreadId: () => "thread-1",
+      queueMessage: vi.fn(async () => true),
+      interrupt: vi.fn(async () => {}),
+      isAwaitingInput: () => false,
+      submitPendingInput: vi.fn(async () => false),
+      submitPendingInputPayload: vi.fn(async () => false),
+    }));
+    (controller as any).client.startTurn = startTurn;
+
+    const result = await controller.handleInboundClaim({
+      content: "And? Build it?",
+      channel: "discord",
+      accountId: "default",
+      conversationId: "1481858418548412579",
+      isGroup: true,
+      metadata: { guildId: "guild-1" },
+    });
+
+    expect(result).toEqual({ handled: true });
+    expect(staleQueueMessage).not.toHaveBeenCalled();
+    expect(staleInterrupt).toHaveBeenCalled();
+    expect(startTurn).toHaveBeenCalled();
+  });
+
+  it("passes trusted local media roots when sending a Telegram plan attachment", async () => {
+    const { controller, sendMessageTelegram, stateDir } = await createControllerHarness();
+    const attachmentPath = path.join(stateDir, "tmp", "plan.md");
+    fs.mkdirSync(path.dirname(attachmentPath), { recursive: true });
+    fs.writeFileSync(attachmentPath, "# Plan\n");
+
+    const sent = await (controller as any).sendReply(
+      {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "8460800771",
+      },
+      {
+        mediaUrl: attachmentPath,
+      },
+    );
+
+    expect(sent).toBe(true);
+    expect(sendMessageTelegram).toHaveBeenCalledWith(
+      "8460800771",
+      "",
+      expect.objectContaining({
+        mediaUrl: attachmentPath,
+        mediaLocalRoots: expect.arrayContaining([stateDir, path.dirname(attachmentPath)]),
+      }),
+    );
+  });
+
+  it("passes trusted local media roots when sending a Discord plan attachment", async () => {
+    const { controller, sendMessageDiscord, stateDir } = await createControllerHarness();
+    const attachmentPath = path.join(stateDir, "tmp", "plan.md");
+    fs.mkdirSync(path.dirname(attachmentPath), { recursive: true });
+    fs.writeFileSync(attachmentPath, "# Plan\n");
+
+    const sent = await (controller as any).sendReply(
+      {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "user:1177378744822943744",
+      },
+      {
+        mediaUrl: attachmentPath,
+      },
+    );
+
+    expect(sent).toBe(true);
+    expect(sendMessageDiscord).toHaveBeenCalledWith(
+      "user:1177378744822943744",
+      "",
+      expect.objectContaining({
+        mediaUrl: attachmentPath,
+        mediaLocalRoots: expect.arrayContaining([stateDir, path.dirname(attachmentPath)]),
+      }),
+    );
+  });
+
+  it("restarts a Discord bound run when the active queue path fails", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:1481858418548412579",
+      },
+      sessionKey: "session-1",
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      updatedAt: Date.now(),
+    });
+    const staleInterrupt = vi.fn(async () => {});
+    (controller as any).activeRuns.set("discord::default::channel:1481858418548412579::", {
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:1481858418548412579",
+      },
+      workspaceDir: "/repo/openclaw",
+      mode: "default",
+      handle: {
+        result: Promise.resolve({ threadId: "thread-1", text: "stale" }),
+        queueMessage: vi.fn(async () => {
+          throw new Error("codex app server rpc error (-32600): Invalid request: missing field `threadId`");
+        }),
+        getThreadId: () => "thread-1",
+        interrupt: staleInterrupt,
+        isAwaitingInput: () => false,
+        submitPendingInput: vi.fn(async () => false),
+        submitPendingInputPayload: vi.fn(async () => false),
+      },
+    });
+    const startTurn = vi.fn(() => ({
+      result: Promise.resolve({
+        threadId: "thread-1",
+        text: "hello",
+      }),
+      getThreadId: () => "thread-1",
+      queueMessage: vi.fn(async () => true),
+      interrupt: vi.fn(async () => {}),
+      isAwaitingInput: () => false,
+      submitPendingInput: vi.fn(async () => false),
+      submitPendingInputPayload: vi.fn(async () => false),
+    }));
+    (controller as any).client.startTurn = startTurn;
+
+    const result = await controller.handleInboundClaim({
+      content: "who are you?",
+      channel: "discord",
+      accountId: "default",
+      conversationId: "1481858418548412579",
+      isGroup: true,
+      metadata: { guildId: "guild-1" },
+    });
+
+    expect(result).toEqual({ handled: true });
+    expect(staleInterrupt).toHaveBeenCalled();
+    expect(startTurn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        existingThreadId: "thread-1",
+        prompt: "who are you?",
+      }),
+    );
+  });
+});