fix: document /models directive regression (#1753) (thanks @uos-status)

CHANGELOG.md

@@ -24,11 +24,11 @@ Docs: https://docs.clawd.bot
 - Telegram: add verbose raw-update logging for inbound Telegram updates. (#1597) Thanks @rohannagpal.
 
 ### Fixes
-- BlueBubbles: route phone-number targets to DMs, avoid leaking routing IDs, and auto-create missing DMs (Private API required). (#1751) Thanks @tyler6204. https://docs.clawd.bot/channels/bluebubbles
 - BlueBubbles: keep part-index GUIDs in reply tags when short IDs are missing.
 - Web UI: hide internal `message_id` hints in chat bubbles.
 - Web UI: show Stop button during active runs, swap back to New session when idle. (#1664) Thanks @ndbroadbent.
 - Web UI: clear stale disconnect banners on reconnect; allow form saves with unsupported schema paths but block missing schema. (#1707) Thanks @Glucksberg.
+- Auto-reply: don't treat `/models` as a `/model` directive. (#1753) Thanks @uos-status.
 - Heartbeat: normalize target identifiers for consistent routing.
 - TUI: reload history after gateway reconnect to restore session state. (#1663)
 - Telegram: use wrapped fetch for long-polling on Node to normalize AbortSignal handling. (#1639)

docs/channels/bluebubbles.md

@@ -213,7 +213,6 @@ Prefer `chat_guid` for stable routing:
 - `chat_id:123`
 - `chat_identifier:...`
 - Direct handles: `+15555550123`, `user@example.com`
-  - If a direct handle does not have an existing DM chat, Clawdbot will create one via `POST /api/v1/chat/new`. This requires the BlueBubbles Private API to be enabled.
 
 ## Security
 - Webhook requests are authenticated by comparing `guid`/`password` query params or headers against `channels.bluebubbles.password`. Requests from `localhost` are also accepted.

extensions/bluebubbles/src/channel.ts

@@ -25,11 +25,9 @@ import { resolveBlueBubblesMessageId } from "./monitor.js";
 import { probeBlueBubbles, type BlueBubblesProbe } from "./probe.js";
 import { sendMessageBlueBubbles } from "./send.js";
 import {
-  extractHandleFromChatGuid,
   looksLikeBlueBubblesTargetId,
   normalizeBlueBubblesHandle,
   normalizeBlueBubblesMessagingTarget,
-  parseBlueBubblesTarget,
 } from "./targets.js";
 import { bluebubblesMessageActions } from "./actions.js";
 import { monitorBlueBubblesProvider, resolveWebhookPathFromConfig } from "./monitor.js";
@@ -150,58 +148,6 @@ export const bluebubblesPlugin: ChannelPlugin<ResolvedBlueBubblesAccount> = {
       looksLikeId: looksLikeBlueBubblesTargetId,
       hint: "<handle|chat_guid:GUID|chat_id:ID|chat_identifier:ID>",
     },
-    formatTargetDisplay: ({ target, display }) => {
-      const shouldParseDisplay = (value: string): boolean => {
-        if (looksLikeBlueBubblesTargetId(value)) return true;
-        return /^(bluebubbles:|chat_guid:|chat_id:|chat_identifier:)/i.test(value);
-      };
-
-      // Helper to extract a clean handle from any BlueBubbles target format
-      const extractCleanDisplay = (value: string | undefined): string | null => {
-        const trimmed = value?.trim();
-        if (!trimmed) return null;
-        try {
-          const parsed = parseBlueBubblesTarget(trimmed);
-          if (parsed.kind === "chat_guid") {
-            const handle = extractHandleFromChatGuid(parsed.chatGuid);
-            if (handle) return handle;
-          }
-          if (parsed.kind === "handle") {
-            return normalizeBlueBubblesHandle(parsed.to);
-          }
-        } catch {
-          // Fall through
-        }
-        // Strip common prefixes and try raw extraction
-        const stripped = trimmed
-          .replace(/^bluebubbles:/i, "")
-          .replace(/^chat_guid:/i, "")
-          .replace(/^chat_id:/i, "")
-          .replace(/^chat_identifier:/i, "");
-        const handle = extractHandleFromChatGuid(stripped);
-        if (handle) return handle;
-        // Don't return raw chat_guid formats - they contain internal routing info
-        if (stripped.includes(";-;") || stripped.includes(";+;")) return null;
-        return stripped;
-      };
-
-      // Try to get a clean display from the display parameter first
-      const trimmedDisplay = display?.trim();
-      if (trimmedDisplay) {
-        if (!shouldParseDisplay(trimmedDisplay)) {
-          return trimmedDisplay;
-        }
-        const cleanDisplay = extractCleanDisplay(trimmedDisplay);
-        if (cleanDisplay) return cleanDisplay;
-      }
-
-      // Fall back to extracting from target
-      const cleanTarget = extractCleanDisplay(target);
-      if (cleanTarget) return cleanTarget;
-
-      // Last resort: return display or target as-is
-      return display?.trim() || target?.trim() || "";
-    },
   },
   setup: {
     resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),

extensions/bluebubbles/src/send.test.ts

@@ -187,47 +187,6 @@ describe("send", () => {
       expect(result).toBe("iMessage;-;+15551234567");
     });
 
-    it("returns null when handle only exists in group chat (not DM)", async () => {
-      // This is the critical fix: if a phone number only exists as a participant in a group chat
-      // (no direct DM chat), we should NOT send to that group. Return null instead.
-      mockFetch
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () =>
-            Promise.resolve({
-              data: [
-                {
-                  guid: "iMessage;+;group-the-council",
-                  participants: [
-                    { address: "+12622102921" },
-                    { address: "+15550001111" },
-                    { address: "+15550002222" },
-                  ],
-                },
-              ],
-            }),
-        })
-        // Empty second page to stop pagination
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () => Promise.resolve({ data: [] }),
-        });
-
-      const target: BlueBubblesSendTarget = {
-        kind: "handle",
-        address: "+12622102921",
-        service: "imessage",
-      };
-      const result = await resolveChatGuidForTarget({
-        baseUrl: "http://localhost:1234",
-        password: "test",
-        target,
-      });
-
-      // Should return null, NOT the group chat GUID
-      expect(result).toBeNull();
-    });
-
     it("returns null when chat not found", async () => {
       mockFetch.mockResolvedValueOnce({
         ok: true,
@@ -385,14 +344,14 @@ describe("send", () => {
       ).rejects.toThrow("password is required");
     });
 
-    it("throws when chatGuid cannot be resolved for non-handle targets", async () => {
+    it("throws when chatGuid cannot be resolved", async () => {
       mockFetch.mockResolvedValue({
         ok: true,
         json: () => Promise.resolve({ data: [] }),
       });
 
       await expect(
-        sendMessageBlueBubbles("chat_id:999", "Hello", {
+        sendMessageBlueBubbles("+15559999999", "Hello", {
           serverUrl: "http://localhost:1234",
           password: "test",
         }),
@@ -439,57 +398,6 @@ describe("send", () => {
       expect(body.method).toBeUndefined();
     });
 
-    it("creates a new chat when handle target is missing", async () => {
-      mockFetch
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () => Promise.resolve({ data: [] }),
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          text: () =>
-            Promise.resolve(
-              JSON.stringify({
-                data: { guid: "new-msg-guid" },
-              }),
-            ),
-        });
-
-      const result = await sendMessageBlueBubbles("+15550009999", "Hello new chat", {
-        serverUrl: "http://localhost:1234",
-        password: "test",
-      });
-
-      expect(result.messageId).toBe("new-msg-guid");
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-
-      const createCall = mockFetch.mock.calls[1];
-      expect(createCall[0]).toContain("/api/v1/chat/new");
-      const body = JSON.parse(createCall[1].body);
-      expect(body.addresses).toEqual(["+15550009999"]);
-      expect(body.message).toBe("Hello new chat");
-    });
-
-    it("throws when creating a new chat requires Private API", async () => {
-      mockFetch
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () => Promise.resolve({ data: [] }),
-        })
-        .mockResolvedValueOnce({
-          ok: false,
-          status: 403,
-          text: () => Promise.resolve("Private API not enabled"),
-        });
-
-      await expect(
-        sendMessageBlueBubbles("+15550008888", "Hello", {
-          serverUrl: "http://localhost:1234",
-          password: "test",
-        }),
-      ).rejects.toThrow("Private API must be enabled");
-    });
-
     it("uses private-api when reply metadata is present", async () => {
       mockFetch
         .mockResolvedValueOnce({

extensions/bluebubbles/src/send.ts

@@ -257,17 +257,11 @@ export async function resolveChatGuidForTarget(params: {
           return guid;
         }
         if (!participantMatch && guid) {
-          // Only consider DM chats (`;-;` separator) as participant matches.
-          // Group chats (`;+;` separator) should never match when searching by handle/phone.
-          // This prevents routing "send to +1234567890" to a group chat that contains that number.
-          const isDmChat = guid.includes(";-;");
-          if (isDmChat) {
-            const participants = extractParticipantAddresses(chat).map((entry) =>
-              normalizeBlueBubblesHandle(entry),
-            );
-            if (participants.includes(normalizedHandle)) {
-              participantMatch = guid;
-            }
+          const participants = extractParticipantAddresses(chat).map((entry) =>
+            normalizeBlueBubblesHandle(entry),
+          );
+          if (participants.includes(normalizedHandle)) {
+            participantMatch = guid;
           }
         }
       }
@@ -276,55 +270,6 @@ export async function resolveChatGuidForTarget(params: {
   return participantMatch;
 }
 
-/**
- * Creates a new chat (DM) and optionally sends an initial message.
- * Requires Private API to be enabled in BlueBubbles.
- */
-async function createNewChatWithMessage(params: {
-  baseUrl: string;
-  password: string;
-  address: string;
-  message: string;
-  timeoutMs?: number;
-}): Promise<BlueBubblesSendResult> {
-  const url = buildBlueBubblesApiUrl({
-    baseUrl: params.baseUrl,
-    path: "/api/v1/chat/new",
-    password: params.password,
-  });
-  const payload = {
-    addresses: [params.address],
-    message: params.message,
-  };
-  const res = await blueBubblesFetchWithTimeout(
-    url,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload),
-    },
-    params.timeoutMs,
-  );
-  if (!res.ok) {
-    const errorText = await res.text();
-    // Check for Private API not enabled error
-    if (res.status === 400 || res.status === 403 || errorText.toLowerCase().includes("private api")) {
-      throw new Error(
-        `BlueBubbles send failed: Cannot create new chat - Private API must be enabled. Original error: ${errorText || res.status}`,
-      );
-    }
-    throw new Error(`BlueBubbles create chat failed (${res.status}): ${errorText || "unknown"}`);
-  }
-  const body = await res.text();
-  if (!body) return { messageId: "ok" };
-  try {
-    const parsed = JSON.parse(body) as unknown;
-    return { messageId: extractMessageId(parsed) };
-  } catch {
-    return { messageId: "ok" };
-  }
-}
-
 export async function sendMessageBlueBubbles(
   to: string,
   text: string,
@@ -352,17 +297,6 @@ export async function sendMessageBlueBubbles(
     target,
   });
   if (!chatGuid) {
-    // If target is a phone number/handle and no existing chat found,
-    // auto-create a new DM chat using the /api/v1/chat/new endpoint
-    if (target.kind === "handle") {
-      return createNewChatWithMessage({
-        baseUrl,
-        password,
-        address: target.address,
-        message: trimmedText,
-        timeoutMs: opts.timeoutMs,
-      });
-    }
     throw new Error(
       "BlueBubbles send failed: chatGuid not found for target. Use a chat_guid target or ensure the chat exists.",
     );

src/agents/tools/message-tool.ts

@@ -333,13 +333,7 @@ export function createMessageTool(options?: MessageToolOptions): AnyAgentTool {
     name: "message",
     description,
     parameters: schema,
-    execute: async (_toolCallId, args, signal) => {
-      // Check if already aborted before doing any work
-      if (signal?.aborted) {
-        const err = new Error("Message send aborted");
-        err.name = "AbortError";
-        throw err;
-      }
+    execute: async (_toolCallId, args) => {
       const params = args as Record<string, unknown>;
       const cfg = options?.config ?? loadConfig();
       const action = readStringParam(params, "action", {
@@ -372,9 +366,6 @@ export function createMessageTool(options?: MessageToolOptions): AnyAgentTool {
               currentThreadTs: options?.currentThreadTs,
               replyToMode: options?.replyToMode,
               hasRepliedRef: options?.hasRepliedRef,
-              // Direct tool invocations should not add cross-context decoration.
-              // The agent is composing a message, not forwarding from another chat.
-              skipCrossContextDecoration: true,
             }
           : undefined;
 
@@ -388,7 +379,6 @@ export function createMessageTool(options?: MessageToolOptions): AnyAgentTool {
         agentId: options?.agentSessionKey
           ? resolveSessionAgentId({ sessionKey: options.agentSessionKey, config: cfg })
           : undefined,
-        abortSignal: signal,
       });
 
       const toolResult = getToolResult(result);

src/auto-reply/model.test.ts

@@ -10,11 +10,17 @@ describe("extractModelDirective", () => {
       expect(result.cleaned).toBe("");
     });
 
-    it("extracts /models with argument", () => {
+    it("does not treat /models as a /model directive", () => {
       const result = extractModelDirective("/models gpt-5");
-      expect(result.hasDirective).toBe(true);
-      expect(result.rawModel).toBe("gpt-5");
-      expect(result.cleaned).toBe("");
+      expect(result.hasDirective).toBe(false);
+      expect(result.rawModel).toBeUndefined();
+      expect(result.cleaned).toBe("/models gpt-5");
+    });
+
+    it("does not parse /models as a /model directive (no args)", () => {
+      const result = extractModelDirective("/models");
+      expect(result.hasDirective).toBe(false);
+      expect(result.cleaned).toBe("/models");
     });
 
     it("extracts /model with provider/model format", () => {

src/auto-reply/model.ts

@@ -14,7 +14,7 @@ export function extractModelDirective(
   if (!body) return { cleaned: "", hasDirective: false };
 
   const modelMatch = body.match(
-    /(?:^|\s)\/models?(?=$|\s|:)\s*:?\s*([A-Za-z0-9_.:@-]+(?:\/[A-Za-z0-9_.:@-]+)*)?/i,
+    /(?:^|\s)\/model(?=$|\s|:)\s*:?\s*([A-Za-z0-9_.:@-]+(?:\/[A-Za-z0-9_.:@-]+)*)?/i,
   );
 
   const aliases = (options?.aliases ?? []).map((alias) => alias.trim()).filter(Boolean);

src/channels/plugins/types.core.ts

@@ -240,12 +240,6 @@ export type ChannelThreadingToolContext = {
   currentThreadTs?: string;
   replyToMode?: "off" | "first" | "all";
   hasRepliedRef?: { value: boolean };
-  /**
-   * When true, skip cross-context decoration (e.g., "[from X]" prefix).
-   * Use this for direct tool invocations where the agent is composing a new message,
-   * not forwarding/relaying a message from another conversation.
-   */
-  skipCrossContextDecoration?: boolean;
 };
 
 export type ChannelMessagingAdapter = {

src/infra/outbound/message-action-runner.test.ts

@@ -321,44 +321,6 @@ describe("runMessageAction context isolation", () => {
       }),
     ).rejects.toThrow(/Cross-context messaging denied/);
   });
-
-  it("aborts send when abortSignal is already aborted", async () => {
-    const controller = new AbortController();
-    controller.abort();
-
-    await expect(
-      runMessageAction({
-        cfg: slackConfig,
-        action: "send",
-        params: {
-          channel: "slack",
-          target: "#C12345678",
-          message: "hi",
-        },
-        dryRun: true,
-        abortSignal: controller.signal,
-      }),
-    ).rejects.toMatchObject({ name: "AbortError" });
-  });
-
-  it("aborts broadcast when abortSignal is already aborted", async () => {
-    const controller = new AbortController();
-    controller.abort();
-
-    await expect(
-      runMessageAction({
-        cfg: slackConfig,
-        action: "broadcast",
-        params: {
-          targets: ["channel:C12345678"],
-          channel: "slack",
-          message: "hi",
-        },
-        dryRun: true,
-        abortSignal: controller.signal,
-      }),
-    ).rejects.toMatchObject({ name: "AbortError" });
-  });
 });
 
 describe("runMessageAction sendAttachment hydration", () => {

src/infra/outbound/message-action-runner.ts

@@ -64,7 +64,6 @@ export type RunMessageActionParams = {
   sessionKey?: string;
   agentId?: string;
   dryRun?: boolean;
-  abortSignal?: AbortSignal;
 };
 
 export type MessageActionRunResult =
@@ -508,7 +507,6 @@ type ResolvedActionContext = {
   input: RunMessageActionParams;
   agentId?: string;
   resolvedTarget?: ResolvedMessagingTarget;
-  abortSignal?: AbortSignal;
 };
 function resolveGateway(input: RunMessageActionParams): MessageActionRunnerGateway | undefined {
   if (!input.gateway) return undefined;
@@ -526,7 +524,6 @@ async function handleBroadcastAction(
   input: RunMessageActionParams,
   params: Record<string, unknown>,
 ): Promise<MessageActionRunResult> {
-  throwIfAborted(input.abortSignal);
   const broadcastEnabled = input.cfg.tools?.message?.broadcast?.enabled !== false;
   if (!broadcastEnabled) {
     throw new Error("Broadcast is disabled. Set tools.message.broadcast.enabled to true.");
@@ -551,11 +548,8 @@ async function handleBroadcastAction(
     error?: string;
     result?: MessageSendResult;
   }> = [];
-  const isAbortError = (err: unknown): boolean => err instanceof Error && err.name === "AbortError";
   for (const targetChannel of targetChannels) {
-    throwIfAborted(input.abortSignal);
     for (const target of rawTargets) {
-      throwIfAborted(input.abortSignal);
       try {
         const resolved = await resolveChannelTarget({
           cfg: input.cfg,
@@ -579,7 +573,6 @@ async function handleBroadcastAction(
           result: sendResult.kind === "send" ? sendResult.sendResult : undefined,
         });
       } catch (err) {
-        if (isAbortError(err)) throw err;
         results.push({
           channel: targetChannel,
           to: target,
@@ -599,28 +592,8 @@ async function handleBroadcastAction(
   };
 }
 
-function throwIfAborted(abortSignal?: AbortSignal): void {
-  if (abortSignal?.aborted) {
-    const err = new Error("Message send aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 async function handleSendAction(ctx: ResolvedActionContext): Promise<MessageActionRunResult> {
-  const {
-    cfg,
-    params,
-    channel,
-    accountId,
-    dryRun,
-    gateway,
-    input,
-    agentId,
-    resolvedTarget,
-    abortSignal,
-  } = ctx;
-  throwIfAborted(abortSignal);
+  const { cfg, params, channel, accountId, dryRun, gateway, input, agentId, resolvedTarget } = ctx;
   const action: ChannelMessageActionName = "send";
   const to = readStringParam(params, "to", { required: true });
   // Support media, path, and filePath parameters for attachments
@@ -703,7 +676,6 @@ async function handleSendAction(ctx: ResolvedActionContext): Promise<MessageActi
   }
   const mirrorMediaUrls =
     mergedMediaUrls.length > 0 ? mergedMediaUrls : mediaUrl ? [mediaUrl] : undefined;
-  throwIfAborted(abortSignal);
   const send = await executeSendAction({
     ctx: {
       cfg,
@@ -723,7 +695,6 @@ async function handleSendAction(ctx: ResolvedActionContext): Promise<MessageActi
               mediaUrls: mirrorMediaUrls,
             }
           : undefined,
-      abortSignal,
     },
     to,
     message,
@@ -747,8 +718,7 @@ async function handleSendAction(ctx: ResolvedActionContext): Promise<MessageActi
 }
 
 async function handlePollAction(ctx: ResolvedActionContext): Promise<MessageActionRunResult> {
-  const { cfg, params, channel, accountId, dryRun, gateway, input, abortSignal } = ctx;
-  throwIfAborted(abortSignal);
+  const { cfg, params, channel, accountId, dryRun, gateway, input } = ctx;
   const action: ChannelMessageActionName = "poll";
   const to = readStringParam(params, "to", { required: true });
   const question = readStringParam(params, "pollQuestion", {
@@ -807,8 +777,7 @@ async function handlePollAction(ctx: ResolvedActionContext): Promise<MessageActi
 }
 
 async function handlePluginAction(ctx: ResolvedActionContext): Promise<MessageActionRunResult> {
-  const { cfg, params, channel, accountId, dryRun, gateway, input, abortSignal } = ctx;
-  throwIfAborted(abortSignal);
+  const { cfg, params, channel, accountId, dryRun, gateway, input } = ctx;
   const action = input.action as Exclude<ChannelMessageActionName, "send" | "poll" | "broadcast">;
   if (dryRun) {
     return {
@@ -961,7 +930,6 @@ export async function runMessageAction(
       input,
       agentId: resolvedAgentId,
       resolvedTarget,
-      abortSignal: input.abortSignal,
     });
   }
 
@@ -974,7 +942,6 @@ export async function runMessageAction(
       dryRun,
       gateway,
       input,
-      abortSignal: input.abortSignal,
     });
   }
 
@@ -986,6 +953,5 @@ export async function runMessageAction(
     dryRun,
     gateway,
     input,
-    abortSignal: input.abortSignal,
   });
 }

src/infra/outbound/message.ts

@@ -50,7 +50,6 @@ type MessageSendParams = {
     text?: string;
     mediaUrls?: string[];
   };
-  abortSignal?: AbortSignal;
 };
 
 export type MessageSendResult = {
@@ -168,7 +167,6 @@ export async function sendMessage(params: MessageSendParams): Promise<MessageSen
       gifPlayback: params.gifPlayback,
       deps: params.deps,
       bestEffort: params.bestEffort,
-      abortSignal: params.abortSignal,
       mirror: params.mirror
         ? {
             ...params.mirror,

src/infra/outbound/outbound-policy.ts

@@ -119,8 +119,6 @@ export async function buildCrossContextDecoration(params: {
   accountId?: string | null;
 }): Promise<CrossContextDecoration | null> {
   if (!params.toolContext?.currentChannelId) return null;
-  // Skip decoration for direct tool sends (agent composing, not forwarding)
-  if (params.toolContext.skipCrossContextDecoration) return null;
   if (!isCrossContextTarget(params)) return null;
 
   const markerConfig = params.cfg.tools?.message?.crossContext?.marker;
@@ -133,11 +131,11 @@ export async function buildCrossContextDecoration(params: {
       targetId: params.toolContext.currentChannelId,
       accountId: params.accountId ?? undefined,
     })) ?? params.toolContext.currentChannelId;
-  // Don't force group formatting here; currentChannelId can be a DM or a group.
   const originLabel = formatTargetDisplay({
     channel: params.channel,
     target: params.toolContext.currentChannelId,
     display: currentName,
+    kind: "group",
   });
   const prefixTemplate = markerConfig?.prefix ?? "[from {channel}] ";
   const suffixTemplate = markerConfig?.suffix ?? "";

src/infra/outbound/outbound-send-service.ts

@@ -32,7 +32,6 @@ export type OutboundSendContext = {
     text?: string;
     mediaUrls?: string[];
   };
-  abortSignal?: AbortSignal;
 };
 
 function extractToolPayload(result: AgentToolResult<unknown>): unknown {
@@ -57,14 +56,6 @@ function extractToolPayload(result: AgentToolResult<unknown>): unknown {
   return result.content ?? result;
 }
 
-function throwIfAborted(abortSignal?: AbortSignal): void {
-  if (abortSignal?.aborted) {
-    const err = new Error("Message send aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 export async function executeSendAction(params: {
   ctx: OutboundSendContext;
   to: string;
@@ -79,7 +70,6 @@ export async function executeSendAction(params: {
   toolResult?: AgentToolResult<unknown>;
   sendResult?: MessageSendResult;
 }> {
-  throwIfAborted(params.ctx.abortSignal);
   if (!params.ctx.dryRun) {
     const handled = await dispatchChannelMessageAction({
       channel: params.ctx.channel,
@@ -113,7 +103,6 @@ export async function executeSendAction(params: {
     }
   }
 
-  throwIfAborted(params.ctx.abortSignal);
   const result: MessageSendResult = await sendMessage({
     cfg: params.ctx.cfg,
     to: params.to,
@@ -128,7 +117,6 @@ export async function executeSendAction(params: {
     deps: params.ctx.deps,
     gateway: params.ctx.gateway,
     mirror: params.ctx.mirror,
-    abortSignal: params.ctx.abortSignal,
   });
 
   return {

src/infra/outbound/target-resolver.ts

@@ -100,12 +100,7 @@ export function formatTargetDisplay(params: {
   if (!trimmedTarget) return trimmedTarget;
   if (trimmedTarget.startsWith("#") || trimmedTarget.startsWith("@")) return trimmedTarget;
 
-  const channelPrefix = `${params.channel}:`;
-  const withoutProvider = trimmedTarget.toLowerCase().startsWith(channelPrefix)
-    ? trimmedTarget.slice(channelPrefix.length)
-    : trimmedTarget;
-
-  const withoutPrefix = withoutProvider.replace(/^telegram:/i, "");
+  const withoutPrefix = trimmedTarget.replace(/^telegram:/i, "");
   if (/^channel:/i.test(withoutPrefix)) {
     return `#${withoutPrefix.replace(/^channel:/i, "")}`;
   }
@@ -124,23 +119,14 @@ function preserveTargetCase(channel: ChannelId, raw: string, normalized: string)
   return trimmed;
 }
 
-function detectTargetKind(
-  channel: ChannelId,
-  raw: string,
-  preferred?: TargetResolveKind,
-): TargetResolveKind {
+function detectTargetKind(raw: string, preferred?: TargetResolveKind): TargetResolveKind {
   if (preferred) return preferred;
   const trimmed = raw.trim();
   if (!trimmed) return "group";
-
   if (trimmed.startsWith("@") || /^<@!?/.test(trimmed) || /^user:/i.test(trimmed)) return "user";
-  if (trimmed.startsWith("#") || /^channel:/i.test(trimmed)) return "group";
-
-  // For some channels (e.g., BlueBubbles/iMessage), bare phone numbers are almost always DM targets.
-  if ((channel === "bluebubbles" || channel === "imessage") && /^\+?\d{6,}$/.test(trimmed)) {
-    return "user";
+  if (trimmed.startsWith("#") || /^channel:/i.test(trimmed)) {
+    return "group";
   }
-
   return "group";
 }
 
@@ -296,7 +282,7 @@ export async function resolveMessagingTarget(params: {
   const plugin = getChannelPlugin(params.channel);
   const providerLabel = plugin?.meta?.label ?? params.channel;
   const hint = plugin?.messaging?.targetResolver?.hint;
-  const kind = detectTargetKind(params.channel, raw, params.preferredKind);
+  const kind = detectTargetKind(raw, params.preferredKind);
   const normalized = normalizeTargetForProvider(params.channel, raw) ?? raw;
   const looksLikeTargetId = (): boolean => {
     const trimmed = raw.trim();
@@ -305,12 +291,7 @@ export async function resolveMessagingTarget(params: {
     if (lookup) return lookup(trimmed, normalized);
     if (/^(channel|group|user):/i.test(trimmed)) return true;
     if (/^[@#]/.test(trimmed)) return true;
-    if (/^\+?\d{6,}$/.test(trimmed)) {
-      // BlueBubbles/iMessage phone numbers should usually resolve via the directory to a DM chat,
-      // otherwise the provider may pick an existing group containing that handle.
-      if (params.channel === "bluebubbles" || params.channel === "imessage") return false;
-      return true;
-    }
+    if (/^\+?\d{6,}$/.test(trimmed)) return true;
     if (trimmed.includes("@thread")) return true;
     if (/^(conversation|user):/i.test(trimmed)) return true;
     return false;
@@ -372,24 +353,6 @@ export async function resolveMessagingTarget(params: {
       candidates: match.entries,
     };
   }
-  // For iMessage-style channels, allow sending directly to the normalized handle
-  // even if the directory doesn't contain an entry yet.
-  if (
-    (params.channel === "bluebubbles" || params.channel === "imessage") &&
-    /^\+?\d{6,}$/.test(query)
-  ) {
-    const directTarget = preserveTargetCase(params.channel, raw, normalized);
-    return {
-      ok: true,
-      target: {
-        to: directTarget,
-        kind,
-        display: stripTargetPrefixes(raw),
-        source: "normalized",
-      },
-    };
-  }
-
   return {
     ok: false,
     error: unknownTargetError(providerLabel, raw, hint),
@@ -404,32 +367,16 @@ export async function lookupDirectoryDisplay(params: {
   runtime?: RuntimeEnv;
 }): Promise<string | undefined> {
   const normalized = normalizeTargetForProvider(params.channel, params.targetId) ?? params.targetId;
-
-  // Targets can resolve to either peers (DMs) or groups. Try both.
-  const [groups, users] = await Promise.all([
-    getDirectoryEntries({
-      cfg: params.cfg,
-      channel: params.channel,
-      accountId: params.accountId,
-      kind: "group",
-      runtime: params.runtime,
-      preferLiveOnMiss: false,
-    }),
-    getDirectoryEntries({
-      cfg: params.cfg,
-      channel: params.channel,
-      accountId: params.accountId,
-      kind: "user",
-      runtime: params.runtime,
-      preferLiveOnMiss: false,
-    }),
-  ]);
-
-  const findMatch = (candidates: ChannelDirectoryEntry[]) =>
-    candidates.find(
-      (candidate) => normalizeDirectoryEntryId(params.channel, candidate) === normalized,
-    );
-
-  const entry = findMatch(groups) ?? findMatch(users);
+  const candidates = await getDirectoryEntries({
+    cfg: params.cfg,
+    channel: params.channel,
+    accountId: params.accountId,
+    kind: "group",
+    runtime: params.runtime,
+    preferLiveOnMiss: false,
+  });
+  const entry = candidates.find(
+    (candidate) => normalizeDirectoryEntryId(params.channel, candidate) === normalized,
+  );
   return entry?.name ?? entry?.handle ?? undefined;
 }