docs: add Bedrock EC2 role notes (#1625 ) (thanks @sergical)

docs: add EC2 instance role setup for Bedrock
- Add EC2 Instance Roles section with workaround for IMDS credential detection - Include step-by-step IAM role and instance profile setup - Document required permissions (bedrock:InvokeModel, ListFoundationModels) - Update example model to Claude Opus 4.5 (latest) The AWS SDK auto-detects EC2 instance roles via IMDS, but Clawdbot's credential detection only checks environment variables. The workaround is to set AWS_PROFILE=default to signal credentials are available. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-24 21:16:59 +00:00 · 2026-01-24 21:13:13 +00:00
14 changed files with 503 additions and 1031 deletions
@@ -12,13 +12,9 @@ Docs: https://docs.clawd.bot
 - Exec approvals: forward approval prompts to chat with `/approve` for all channels (including plugins). (#1621) Thanks @czekaj. https://docs.clawd.bot/tools/exec-approvals https://docs.clawd.bot/tools/slash-commands

 ### Fixes
- BlueBubbles: preserve full message GUIDs in reply tags + reaction events (no part-prefix stripping). (#1641) Thanks @tyler6204.
 - Web UI: hide internal `message_id` hints in chat bubbles.
 - Heartbeat: normalize target identifiers for consistent routing.
- Telegram: use wrapped fetch for long-polling on Node to normalize AbortSignal handling. (#1639)
 - Exec: keep approvals for elevated ask unless full mode. (#1616) Thanks @ivancasco.
- Agents: auto-compact on context overflow prompt errors before failing. (#1627) Thanks @rodrigouroz.
- Agents: use the active auth profile for auto-compaction recovery.
 - Gateway: reduce log noise for late invokes + remote node probes; debounce skills refresh. (#1607) Thanks @petter-b.
 - macOS: default direct-transport `ws://` URLs to port 18789; document `gateway.remote.transport`. (#1603) Thanks @ngutman.

@@ -1189,8 +1189,9 @@ describe("BlueBubbles webhook monitor", () => {
      expect(callArgs.ctx.ReplyToId).toBe("msg-0");
      expect(callArgs.ctx.ReplyToBody).toBe("original message");
      expect(callArgs.ctx.ReplyToSender).toBe("+15550000000");
-      // Body uses inline [[reply_to:N]] tag format
-      expect(callArgs.ctx.Body).toContain("[[reply_to:msg-0]]");
+      // Body uses just the ID (no sender) for token savings
+      expect(callArgs.ctx.Body).toContain("[Replying to id:msg-0]");
+      expect(callArgs.ctx.Body).toContain("original message");
    });

    it("hydrates missing reply sender/body from the recent-message cache", async () => {
@@ -1259,8 +1260,9 @@ describe("BlueBubbles webhook monitor", () => {
      expect(callArgs.ctx.ReplyToIdFull).toBe("cache-msg-0");
      expect(callArgs.ctx.ReplyToBody).toBe("original message (cached)");
      expect(callArgs.ctx.ReplyToSender).toBe("+15550000000");
-      // Body uses inline [[reply_to:N]] tag format with short ID
-      expect(callArgs.ctx.Body).toContain("[[reply_to:1]]");
+      // Body uses just the short ID (no sender) for token savings
+      expect(callArgs.ctx.Body).toContain("[Replying to id:1]");
+      expect(callArgs.ctx.Body).toContain("original message (cached)");
    });

    it("falls back to threadOriginatorGuid when reply metadata is absent", async () => {
@@ -1303,88 +1305,6 @@ describe("BlueBubbles webhook monitor", () => {
    });
  });

-  describe("tapback text parsing", () => {
-    it("does not rewrite tapback-like text without metadata", async () => {
-      const account = createMockAccount({ dmPolicy: "open" });
-      const config: ClawdbotConfig = {};
-      const core = createMockRuntime();
-      setBlueBubblesRuntime(core);
-
-      unregister = registerBlueBubblesWebhookTarget({
-        account,
-        config,
-        runtime: { log: vi.fn(), error: vi.fn() },
-        core,
-        path: "/bluebubbles-webhook",
-      });
-
-      const payload = {
-        type: "new-message",
-        data: {
-          text: "Loved this idea",
-          handle: { address: "+15551234567" },
-          isGroup: false,
-          isFromMe: false,
-          guid: "msg-1",
-          chatGuid: "iMessage;-;+15551234567",
-          date: Date.now(),
-        },
-      };
-
-      const req = createMockRequest("POST", "/bluebubbles-webhook", payload);
-      const res = createMockResponse();
-
-      await handleBlueBubblesWebhookRequest(req, res);
-      await flushAsync();
-
-      expect(mockDispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalled();
-      const callArgs = mockDispatchReplyWithBufferedBlockDispatcher.mock.calls[0][0];
-      expect(callArgs.ctx.RawBody).toBe("Loved this idea");
-      expect(callArgs.ctx.Body).toContain("Loved this idea");
-      expect(callArgs.ctx.Body).not.toContain("reacted with");
-    });
-
-    it("parses tapback text with custom emoji when metadata is present", async () => {
-      const account = createMockAccount({ dmPolicy: "open" });
-      const config: ClawdbotConfig = {};
-      const core = createMockRuntime();
-      setBlueBubblesRuntime(core);
-
-      unregister = registerBlueBubblesWebhookTarget({
-        account,
-        config,
-        runtime: { log: vi.fn(), error: vi.fn() },
-        core,
-        path: "/bluebubbles-webhook",
-      });
-
-      const payload = {
-        type: "new-message",
-        data: {
-          text: 'Reacted 😅 to "nice one"',
-          handle: { address: "+15551234567" },
-          isGroup: false,
-          isFromMe: false,
-          guid: "msg-2",
-          chatGuid: "iMessage;-;+15551234567",
-          date: Date.now(),
-        },
-      };
-
-      const req = createMockRequest("POST", "/bluebubbles-webhook", payload);
-      const res = createMockResponse();
-
-      await handleBlueBubblesWebhookRequest(req, res);
-      await flushAsync();
-
-      expect(mockDispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalled();
-      const callArgs = mockDispatchReplyWithBufferedBlockDispatcher.mock.calls[0][0];
-      expect(callArgs.ctx.RawBody).toBe("reacted with 😅");
-      expect(callArgs.ctx.Body).toContain("reacted with 😅");
-      expect(callArgs.ctx.Body).not.toContain("[[reply_to:");
-    });
-  });
-
  describe("ack reactions", () => {
    it("sends ack reaction when configured", async () => {
      const { sendBlueBubblesReaction } = await import("./reactions.js");
@@ -1839,7 +1759,7 @@ describe("BlueBubbles webhook monitor", () => {
      await flushAsync();

      expect(mockEnqueueSystemEvent).toHaveBeenCalledWith(
-        expect.stringContaining("reacted with ❤️ [[reply_to:"),
+        expect.stringContaining("reaction added"),
        expect.any(Object),
      );
    });
@@ -1879,7 +1799,7 @@ describe("BlueBubbles webhook monitor", () => {
      await flushAsync();

      expect(mockEnqueueSystemEvent).toHaveBeenCalledWith(
-        expect.stringContaining("removed ❤️ reaction [[reply_to:"),
+        expect.stringContaining("reaction removed"),
        expect.any(Object),
      );
    });
@@ -1985,7 +1905,7 @@ describe("BlueBubbles webhook monitor", () => {
          handle: { address: "+15551234567" },
          isGroup: false,
          isFromMe: false,
-          guid: "p:1/msg-uuid-12345",
+          guid: "msg-uuid-12345",
          chatGuid: "iMessage;-;+15551234567",
          date: Date.now(),
        },
@@ -2001,7 +1921,7 @@ describe("BlueBubbles webhook monitor", () => {
      const callArgs = mockDispatchReplyWithBufferedBlockDispatcher.mock.calls[0][0];
      // MessageSid should be short ID "1" instead of full UUID
      expect(callArgs.ctx.MessageSid).toBe("1");
-      expect(callArgs.ctx.MessageSidFull).toBe("p:1/msg-uuid-12345");
+      expect(callArgs.ctx.MessageSidFull).toBe("msg-uuid-12345");
    });

    it("resolves short ID back to UUID", async () => {
@@ -2025,7 +1945,7 @@ describe("BlueBubbles webhook monitor", () => {
          handle: { address: "+15551234567" },
          isGroup: false,
          isFromMe: false,
-          guid: "p:1/msg-uuid-12345",
+          guid: "msg-uuid-12345",
          chatGuid: "iMessage;-;+15551234567",
          date: Date.now(),
        },
@@ -2038,7 +1958,7 @@ describe("BlueBubbles webhook monitor", () => {
      await flushAsync();

      // The short ID "1" should resolve back to the full UUID
-      expect(resolveBlueBubblesMessageId("1")).toBe("p:1/msg-uuid-12345");
+      expect(resolveBlueBubblesMessageId("1")).toBe("msg-uuid-12345");
    });

    it("returns UUID unchanged when not in cache", () => {
@@ -55,7 +55,7 @@ type BlueBubblesReplyCacheEntry = {
 // Best-effort cache for resolving reply context when BlueBubbles webhooks omit sender/body.
 const blueBubblesReplyCacheByMessageId = new Map<string, BlueBubblesReplyCacheEntry>();

-// Bidirectional maps for short ID ↔ message GUID resolution (token savings optimization)
+// Bidirectional maps for short ID ↔ UUID resolution (token savings optimization)
 const blueBubblesShortIdToUuid = new Map<string, string>();
 const blueBubblesUuidToShortId = new Map<string, string>();
 let blueBubblesShortIdCounter = 0;
@@ -78,7 +78,7 @@ function rememberBlueBubblesReplyCache(
    return { ...entry, shortId: "" };
  }

-  // Check if we already have a short ID for this GUID
+  // Check if we already have a short ID for this UUID
  let shortId = blueBubblesUuidToShortId.get(messageId);
  if (!shortId) {
    shortId = generateShortId();
@@ -86,7 +86,7 @@ function rememberBlueBubblesReplyCache(
    blueBubblesUuidToShortId.set(messageId, shortId);
  }

-  const fullEntry: BlueBubblesReplyCacheEntry = { ...entry, messageId, shortId };
+  const fullEntry: BlueBubblesReplyCacheEntry = { ...entry, shortId };

  // Refresh insertion order.
  blueBubblesReplyCacheByMessageId.delete(messageId);
@@ -122,8 +122,8 @@ function rememberBlueBubblesReplyCache(
 }

 /**
- * Resolves a short message ID (e.g., "1", "2") to a full BlueBubbles GUID.
- * Returns the input unchanged if it's already a GUID or not found in the mapping.
+ * Resolves a short message ID (e.g., "1", "2") to a full BlueBubbles UUID.
+ * Returns the input unchanged if it's already a UUID or not found in the mapping.
 */
 export function resolveBlueBubblesMessageId(
  shortOrUuid: string,
@@ -159,7 +159,7 @@ export function _resetBlueBubblesShortIdState(): void {
 }

 /**
- * Gets the short ID for a message GUID, if one exists.
+ * Gets the short ID for a UUID, if one exists.
 */
 function getShortIdForUuid(uuid: string): string | undefined {
  return blueBubblesUuidToShortId.get(uuid.trim());
@@ -390,15 +390,29 @@ function buildMessagePlaceholder(message: NormalizedWebhookMessage): string {
  return "";
 }

-// Returns inline reply tag like "[[reply_to:4]]" for prepending to message body
-function formatReplyTag(message: {
+const REPLY_BODY_TRUNCATE_LENGTH = 60;
+
+function formatReplyContext(message: {
  replyToId?: string;
  replyToShortId?: string;
+  replyToBody?: string;
+  replyToSender?: string;
 }): string | null {
-  // Prefer short ID
-  const rawId = message.replyToShortId || message.replyToId;
-  if (!rawId) return null;
-  return `[[reply_to:${rawId}]]`;
+  if (!message.replyToId && !message.replyToBody && !message.replyToSender) return null;
+  // Prefer short ID for token savings
+  const displayId = message.replyToShortId || message.replyToId;
+  // Only include sender if we don't have an ID (fallback)
+  const label = displayId ? `id:${displayId}` : (message.replyToSender?.trim() || "unknown");
+  const rawBody = message.replyToBody?.trim();
+  if (!rawBody) {
+    return `[Replying to ${label}]\n[/Replying]`;
+  }
+  // Truncate long reply bodies for token savings
+  const body =
+    rawBody.length > REPLY_BODY_TRUNCATE_LENGTH
+      ? `${rawBody.slice(0, REPLY_BODY_TRUNCATE_LENGTH)}…`
+      : rawBody;
+  return `[Replying to ${label}]\n${body}\n[/Replying]`;
 }

 function readNumberLike(record: Record<string, unknown> | null, key: string): number | undefined {
@@ -615,10 +629,6 @@ type NormalizedWebhookMessage = {
  fromMe?: boolean;
  attachments?: BlueBubblesAttachment[];
  balloonBundleId?: string;
-  associatedMessageGuid?: string;
-  associatedMessageType?: number;
-  associatedMessageEmoji?: string;
-  isTapback?: boolean;
  participants?: BlueBubblesParticipant[];
  replyToId?: string;
  replyToBody?: string;
@@ -655,113 +665,6 @@ const REACTION_TYPE_MAP = new Map<number, { emoji: string; action: "added" | "re
  [3005, { emoji: "❓", action: "removed" }],
 ]);

-// Maps tapback text patterns (e.g., "Loved", "Liked") to emoji + action
-const TAPBACK_TEXT_MAP = new Map<string, { emoji: string; action: "added" | "removed" }>([
-  ["loved", { emoji: "❤️", action: "added" }],
-  ["liked", { emoji: "👍", action: "added" }],
-  ["disliked", { emoji: "👎", action: "added" }],
-  ["laughed at", { emoji: "😂", action: "added" }],
-  ["emphasized", { emoji: "‼️", action: "added" }],
-  ["questioned", { emoji: "❓", action: "added" }],
-  // Removal patterns (e.g., "Removed a heart from")
-  ["removed a heart from", { emoji: "❤️", action: "removed" }],
-  ["removed a like from", { emoji: "👍", action: "removed" }],
-  ["removed a dislike from", { emoji: "👎", action: "removed" }],
-  ["removed a laugh from", { emoji: "😂", action: "removed" }],
-  ["removed an emphasis from", { emoji: "‼️", action: "removed" }],
-  ["removed a question from", { emoji: "❓", action: "removed" }],
-]);
-
-const TAPBACK_EMOJI_REGEX =
-  /(?:\p{Regional_Indicator}{2})|(?:[0-9#*]\uFE0F?\u20E3)|(?:\p{Extended_Pictographic}(?:\uFE0F|\uFE0E)?(?:\p{Emoji_Modifier})?(?:\u200D\p{Extended_Pictographic}(?:\uFE0F|\uFE0E)?(?:\p{Emoji_Modifier})?)*)/u;
-
-function extractFirstEmoji(text: string): string | null {
-  const match = text.match(TAPBACK_EMOJI_REGEX);
-  return match ? match[0] : null;
-}
-
-function extractQuotedTapbackText(text: string): string | null {
-  const match = text.match(/[“"]([^”"]+)[”"]/s);
-  return match ? match[1] : null;
-}
-
-function isTapbackAssociatedType(type: number | undefined): boolean {
-  return typeof type === "number" && Number.isFinite(type) && type >= 2000 && type < 4000;
-}
-
-function resolveTapbackActionHint(type: number | undefined): "added" | "removed" | undefined {
-  if (typeof type !== "number" || !Number.isFinite(type)) return undefined;
-  if (type >= 3000 && type < 4000) return "removed";
-  if (type >= 2000 && type < 3000) return "added";
-  return undefined;
-}
-
-function resolveTapbackContext(message: NormalizedWebhookMessage): {
-  emojiHint?: string;
-  actionHint?: "added" | "removed";
-  replyToId?: string;
-} | null {
-  const associatedType = message.associatedMessageType;
-  const hasTapbackType = isTapbackAssociatedType(associatedType);
-  const hasTapbackMarker = Boolean(message.associatedMessageEmoji) || Boolean(message.isTapback);
-  if (!hasTapbackType && !hasTapbackMarker) return null;
-  const replyToId = message.associatedMessageGuid?.trim() || message.replyToId?.trim() || undefined;
-  const actionHint = resolveTapbackActionHint(associatedType);
-  const emojiHint =
-    message.associatedMessageEmoji?.trim() || REACTION_TYPE_MAP.get(associatedType ?? -1)?.emoji;
-  return { emojiHint, actionHint, replyToId };
-}
-
-// Detects tapback text patterns like 'Loved "message"' and converts to structured format
-function parseTapbackText(params: {
-  text: string;
-  emojiHint?: string;
-  actionHint?: "added" | "removed";
-  requireQuoted?: boolean;
-}): {
-  emoji: string;
-  action: "added" | "removed";
-  quotedText: string;
-} | null {
-  const trimmed = params.text.trim();
-  const lower = trimmed.toLowerCase();
-  if (!trimmed) return null;
-
-  for (const [pattern, { emoji, action }] of TAPBACK_TEXT_MAP) {
-    if (lower.startsWith(pattern)) {
-      // Extract quoted text if present (e.g., 'Loved "hello"' -> "hello")
-      const afterPattern = trimmed.slice(pattern.length).trim();
-      if (params.requireQuoted) {
-        const strictMatch = afterPattern.match(/^[“"](.+)[”"]$/s);
-        if (!strictMatch) return null;
-        return { emoji, action, quotedText: strictMatch[1] };
-      }
-      const quotedText =
-        extractQuotedTapbackText(afterPattern) ?? extractQuotedTapbackText(trimmed) ?? afterPattern;
-      return { emoji, action, quotedText };
-    }
-  }
-
-  if (lower.startsWith("reacted")) {
-    const emoji = extractFirstEmoji(trimmed) ?? params.emojiHint;
-    if (!emoji) return null;
-    const quotedText = extractQuotedTapbackText(trimmed);
-    if (params.requireQuoted && !quotedText) return null;
-    const fallback = trimmed.slice("reacted".length).trim();
-    return { emoji, action: params.actionHint ?? "added", quotedText: quotedText ?? fallback };
-  }
-
-  if (lower.startsWith("removed")) {
-    const emoji = extractFirstEmoji(trimmed) ?? params.emojiHint;
-    if (!emoji) return null;
-    const quotedText = extractQuotedTapbackText(trimmed);
-    if (params.requireQuoted && !quotedText) return null;
-    const fallback = trimmed.slice("removed".length).trim();
-    return { emoji, action: params.actionHint ?? "removed", quotedText: quotedText ?? fallback };
-  }
-  return null;
-}
-
 function maskSecret(value: string): string {
  if (value.length <= 6) return "***";
  return `${value.slice(0, 2)}***${value.slice(-2)}`;
@@ -902,25 +805,6 @@ function normalizeWebhookMessage(payload: Record<string, unknown>): NormalizedWe
    readString(message, "messageId") ??
    undefined;
  const balloonBundleId = readString(message, "balloonBundleId");
-  const associatedMessageGuid =
-    readString(message, "associatedMessageGuid") ??
-    readString(message, "associated_message_guid") ??
-    readString(message, "associatedMessageId") ??
-    undefined;
-  const associatedMessageType =
-    readNumberLike(message, "associatedMessageType") ??
-    readNumberLike(message, "associated_message_type");
-  const associatedMessageEmoji =
-    readString(message, "associatedMessageEmoji") ??
-    readString(message, "associated_message_emoji") ??
-    readString(message, "reactionEmoji") ??
-    readString(message, "reaction_emoji") ??
-    undefined;
-  const isTapback =
-    readBoolean(message, "isTapback") ??
-    readBoolean(message, "is_tapback") ??
-    readBoolean(message, "tapback") ??
-    undefined;

  const timestampRaw =
    readNumber(message, "date") ??
@@ -951,10 +835,6 @@ function normalizeWebhookMessage(payload: Record<string, unknown>): NormalizedWe
    fromMe,
    attachments: extractAttachments(message),
    balloonBundleId,
-    associatedMessageGuid,
-    associatedMessageType,
-    associatedMessageEmoji,
-    isTapback,
    participants: normalizedParticipants,
    replyToId: replyMetadata.replyToId,
    replyToBody: replyMetadata.replyToBody,
@@ -976,13 +856,8 @@ function normalizeWebhookReaction(payload: Record<string, unknown>): NormalizedW
  if (!associatedGuid || associatedType === undefined) return null;

  const mapping = REACTION_TYPE_MAP.get(associatedType);
-  const associatedEmoji =
-    readString(message, "associatedMessageEmoji") ??
-    readString(message, "associated_message_emoji") ??
-    readString(message, "reactionEmoji") ??
-    readString(message, "reaction_emoji");
-  const emoji = (associatedEmoji?.trim() || mapping?.emoji) ?? `reaction:${associatedType}`;
-  const action = mapping?.action ?? resolveTapbackActionHint(associatedType) ?? "added";
+  const emoji = mapping?.emoji ?? `reaction:${associatedType}`;
+  const action = mapping?.action ?? "added";

  const handleValue = message.handle ?? message.sender;
  const handle =
@@ -1247,21 +1122,7 @@ async function processMessage(
  const text = message.text.trim();
  const attachments = message.attachments ?? [];
  const placeholder = buildMessagePlaceholder(message);
-  // Check if text is a tapback pattern (e.g., 'Loved "hello"') and transform to emoji format
-  // For tapbacks, we'll append [[reply_to:N]] at the end; for regular messages, prepend it
-  const tapbackContext = resolveTapbackContext(message);
-  const tapbackParsed = parseTapbackText({
-    text,
-    emojiHint: tapbackContext?.emojiHint,
-    actionHint: tapbackContext?.actionHint,
-    requireQuoted: !tapbackContext,
-  });
-  const isTapbackMessage = Boolean(tapbackParsed);
-  const rawBody = tapbackParsed
-    ? tapbackParsed.action === "removed"
-      ? `removed ${tapbackParsed.emoji} reaction`
-      : `reacted with ${tapbackParsed.emoji}`
-    : text || placeholder;
+  const rawBody = text || placeholder;

  const cacheMessageId = message.messageId?.trim();
  let messageShortId: string | undefined;
@@ -1588,11 +1449,7 @@ async function processMessage(
  let replyToSender = message.replyToSender;
  let replyToShortId: string | undefined;

-  if (isTapbackMessage && tapbackContext?.replyToId) {
-    replyToId = tapbackContext.replyToId;
-  }
-
-  if (replyToId) {
+  if (replyToId && (!replyToBody || !replyToSender)) {
    const cached = resolveReplyContextFromCache({
      accountId: account.accountId,
      replyToId,
@@ -1620,15 +1477,8 @@ async function processMessage(
    replyToShortId = getShortIdForUuid(replyToId);
  }

-  // Use inline [[reply_to:N]] tag format
-  // For tapbacks/reactions: append at end (e.g., "reacted with ❤️ [[reply_to:4]]")
-  // For regular replies: prepend at start (e.g., "[[reply_to:4]] Awesome")
-  const replyTag = formatReplyTag({ replyToId, replyToShortId });
-  const baseBody = replyTag
-    ? isTapbackMessage
-      ? `${rawBody} ${replyTag}`
-      : `${replyTag} ${rawBody}`
-    : rawBody;
+  const replyContext = formatReplyContext({ replyToId, replyToShortId, replyToBody, replyToSender });
+  const baseBody = replyContext ? `${rawBody}\n\n${replyContext}` : rawBody;
  const fromLabel = isGroup ? undefined : message.senderName || `user:${message.senderId}`;
  const groupSubject = isGroup ? message.chatName?.trim() || undefined : undefined;
  const groupMembers = isGroup
@@ -2021,11 +1871,7 @@ async function processReaction(
  const chatLabel = reaction.isGroup ? ` in group:${peerId}` : "";
  // Use short ID for token savings
  const messageDisplayId = getShortIdForUuid(reaction.messageId) || reaction.messageId;
-  // Format: "Tyler reacted with ❤️ [[reply_to:5]]" or "Tyler removed ❤️ reaction [[reply_to:5]]"
-  const text =
-    reaction.action === "removed"
-      ? `${senderLabel} removed ${reaction.emoji} reaction [[reply_to:${messageDisplayId}]]${chatLabel}`
-      : `${senderLabel} reacted with ${reaction.emoji} [[reply_to:${messageDisplayId}]]${chatLabel}`;
+  const text = `BlueBubbles reaction ${reaction.action}: ${reaction.emoji} by ${senderLabel}${chatLabel} on msg ${messageDisplayId}`;
  core.system.enqueueSystemEvent(text, {
    sessionKey: route.sessionKey,
    contextKey: `bluebubbles:reaction:${reaction.action}:${peerId}:${reaction.messageId}:${reaction.senderId}:${reaction.emoji}`,
@@ -1,7 +1,15 @@
 import type { AssistantMessage } from "@mariozechner/pi-ai";
 import { describe, expect, it } from "vitest";
 import { formatAssistantErrorText } from "./pi-embedded-helpers.js";
+import { DEFAULT_AGENTS_FILENAME } from "./workspace.js";

+const _makeFile = (overrides: Partial<WorkspaceBootstrapFile>): WorkspaceBootstrapFile => ({
+  name: DEFAULT_AGENTS_FILENAME,
+  path: "/tmp/AGENTS.md",
+  content: "",
+  missing: false,
+  ...overrides,
+});
 describe("formatAssistantErrorText", () => {
  const makeAssistantError = (errorMessage: string): AssistantMessage =>
    ({
@@ -13,16 +21,6 @@ describe("formatAssistantErrorText", () => {
    const msg = makeAssistantError("request_too_large");
    expect(formatAssistantErrorText(msg)).toContain("Context overflow");
  });
-  it("returns context overflow for Anthropic 'Request size exceeds model context window'", () => {
-    // This is the new Anthropic error format that wasn't being detected.
-    // Without the fix, this falls through to the invalidRequest regex and returns
-    // "LLM request rejected: Request size exceeds model context window"
-    // instead of the context overflow message, preventing auto-compaction.
-    const msg = makeAssistantError(
-      '{"type":"error","error":{"type":"invalid_request_error","message":"Request size exceeds model context window"}}',
-    );
-    expect(formatAssistantErrorText(msg)).toContain("Context overflow");
-  });
  it("returns a friendly message for Anthropic role ordering", () => {
    const msg = makeAssistantError('messages: roles must alternate between "user" and "assistant"');
    expect(formatAssistantErrorText(msg)).toContain("Message ordering conflict");
@@ -1,6 +1,14 @@
 import { describe, expect, it } from "vitest";
 import { isContextOverflowError } from "./pi-embedded-helpers.js";
+import { DEFAULT_AGENTS_FILENAME } from "./workspace.js";

+const _makeFile = (overrides: Partial<WorkspaceBootstrapFile>): WorkspaceBootstrapFile => ({
+  name: DEFAULT_AGENTS_FILENAME,
+  path: "/tmp/AGENTS.md",
+  content: "",
+  missing: false,
+  ...overrides,
+});
 describe("isContextOverflowError", () => {
  it("matches known overflow hints", () => {
    const samples = [
@@ -16,34 +24,7 @@ describe("isContextOverflowError", () => {
      expect(isContextOverflowError(sample)).toBe(true);
    }
  });
-
-  it("matches Anthropic 'Request size exceeds model context window' error", () => {
-    // Anthropic returns this error format when the prompt exceeds the context window.
-    // Without this fix, auto-compaction is NOT triggered because neither
-    // isContextOverflowError nor pi-ai's isContextOverflow recognizes this pattern.
-    // The user sees: "LLM request rejected: Request size exceeds model context window"
-    // instead of automatic compaction + retry.
-    const anthropicRawError =
-      '{"type":"error","error":{"type":"invalid_request_error","message":"Request size exceeds model context window"}}';
-    expect(isContextOverflowError(anthropicRawError)).toBe(true);
-  });
-
-  it("matches 'exceeds model context window' in various formats", () => {
-    const samples = [
-      "Request size exceeds model context window",
-      "request size exceeds model context window",
-      '400 {"type":"error","error":{"type":"invalid_request_error","message":"Request size exceeds model context window"}}',
-      "The request size exceeds model context window limit",
-    ];
-    for (const sample of samples) {
-      expect(isContextOverflowError(sample)).toBe(true);
-    }
-  });
-
  it("ignores unrelated errors", () => {
    expect(isContextOverflowError("rate limit exceeded")).toBe(false);
-    expect(isContextOverflowError("request size exceeds upload limit")).toBe(false);
-    expect(isContextOverflowError("model not found")).toBe(false);
-    expect(isContextOverflowError("authentication failed")).toBe(false);
  });
 });
@@ -7,19 +7,12 @@ import type { FailoverReason } from "./types.js";
 export function isContextOverflowError(errorMessage?: string): boolean {
  if (!errorMessage) return false;
  const lower = errorMessage.toLowerCase();
-  const hasRequestSizeExceeds = lower.includes("request size exceeds");
-  const hasContextWindow =
-    lower.includes("context window") ||
-    lower.includes("context length") ||
-    lower.includes("maximum context length");
  return (
    lower.includes("request_too_large") ||
    lower.includes("request exceeds the maximum size") ||
    lower.includes("context length exceeded") ||
    lower.includes("maximum context length") ||
    lower.includes("prompt is too long") ||
-    lower.includes("exceeds model context window") ||
-    (hasRequestSizeExceeds && hasContextWindow) ||
    lower.includes("context overflow") ||
    (lower.includes("413") && lower.includes("too large"))
  );
@@ -68,13 +68,12 @@ import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../d
 import { describeUnknownError, mapThinkingLevel, resolveExecToolDefaults } from "./utils.js";
 import { buildTtsSystemPromptHint } from "../../tts/tts.js";

-export type CompactEmbeddedPiSessionParams = {
+export async function compactEmbeddedPiSession(params: {
  sessionId: string;
  sessionKey?: string;
  messageChannel?: string;
  messageProvider?: string;
  agentAccountId?: string;
-  authProfileId?: string;
  /** Group id for channel-level tool policy resolution. */
  groupId?: string | null;
  /** Group channel label (e.g. #general) for channel-level tool policy resolution. */
@@ -98,366 +97,354 @@ export type CompactEmbeddedPiSessionParams = {
  enqueue?: typeof enqueueCommand;
  extraSystemPrompt?: string;
  ownerNumbers?: string[];
-};
-
-/**
- * Core compaction logic without lane queueing.
- * Use this when already inside a session/global lane to avoid deadlocks.
- */
-export async function compactEmbeddedPiSessionDirect(
-  params: CompactEmbeddedPiSessionParams,
-): Promise<EmbeddedPiCompactResult> {
-  const resolvedWorkspace = resolveUserPath(params.workspaceDir);
-  const prevCwd = process.cwd();
-
-  const provider = (params.provider ?? DEFAULT_PROVIDER).trim() || DEFAULT_PROVIDER;
-  const modelId = (params.model ?? DEFAULT_MODEL).trim() || DEFAULT_MODEL;
-  const agentDir = params.agentDir ?? resolveClawdbotAgentDir();
-  await ensureClawdbotModelsJson(params.config, agentDir);
-  const { model, error, authStorage, modelRegistry } = resolveModel(
-    provider,
-    modelId,
-    agentDir,
-    params.config,
-  );
-  if (!model) {
-    return {
-      ok: false,
-      compacted: false,
-      reason: error ?? `Unknown model: ${provider}/${modelId}`,
-    };
-  }
-  try {
-    const apiKeyInfo = await getApiKeyForModel({
-      model,
-      cfg: params.config,
-      profileId: params.authProfileId,
-      agentDir,
-    });
-
-    if (!apiKeyInfo.apiKey) {
-      if (apiKeyInfo.mode !== "aws-sdk") {
-        throw new Error(
-          `No API key resolved for provider "${model.provider}" (auth mode: ${apiKeyInfo.mode}).`,
-        );
-      }
-    } else if (model.provider === "github-copilot") {
-      const { resolveCopilotApiToken } = await import("../../providers/github-copilot-token.js");
-      const copilotToken = await resolveCopilotApiToken({
-        githubToken: apiKeyInfo.apiKey,
-      });
-      authStorage.setRuntimeApiKey(model.provider, copilotToken.token);
-    } else {
-      authStorage.setRuntimeApiKey(model.provider, apiKeyInfo.apiKey);
-    }
-  } catch (err) {
-    return {
-      ok: false,
-      compacted: false,
-      reason: describeUnknownError(err),
-    };
-  }
-
-  await fs.mkdir(resolvedWorkspace, { recursive: true });
-  const sandboxSessionKey = params.sessionKey?.trim() || params.sessionId;
-  const sandbox = await resolveSandboxContext({
-    config: params.config,
-    sessionKey: sandboxSessionKey,
-    workspaceDir: resolvedWorkspace,
-  });
-  const effectiveWorkspace = sandbox?.enabled
-    ? sandbox.workspaceAccess === "rw"
-      ? resolvedWorkspace
-      : sandbox.workspaceDir
-    : resolvedWorkspace;
-  await fs.mkdir(effectiveWorkspace, { recursive: true });
-  await ensureSessionHeader({
-    sessionFile: params.sessionFile,
-    sessionId: params.sessionId,
-    cwd: effectiveWorkspace,
-  });
-
-  let restoreSkillEnv: (() => void) | undefined;
-  process.chdir(effectiveWorkspace);
-  try {
-    const shouldLoadSkillEntries = !params.skillsSnapshot || !params.skillsSnapshot.resolvedSkills;
-    const skillEntries = shouldLoadSkillEntries
-      ? loadWorkspaceSkillEntries(effectiveWorkspace)
-      : [];
-    restoreSkillEnv = params.skillsSnapshot
-      ? applySkillEnvOverridesFromSnapshot({
-          snapshot: params.skillsSnapshot,
-          config: params.config,
-        })
-      : applySkillEnvOverrides({
-          skills: skillEntries ?? [],
-          config: params.config,
-        });
-    const skillsPrompt = resolveSkillsPromptForRun({
-      skillsSnapshot: params.skillsSnapshot,
-      entries: shouldLoadSkillEntries ? skillEntries : undefined,
-      config: params.config,
-      workspaceDir: effectiveWorkspace,
-    });
-
-    const sessionLabel = params.sessionKey ?? params.sessionId;
-    const { contextFiles } = await resolveBootstrapContextForRun({
-      workspaceDir: effectiveWorkspace,
-      config: params.config,
-      sessionKey: params.sessionKey,
-      sessionId: params.sessionId,
-      warn: makeBootstrapWarn({ sessionLabel, warn: (message) => log.warn(message) }),
-    });
-    const runAbortController = new AbortController();
-    const toolsRaw = createClawdbotCodingTools({
-      exec: {
-        ...resolveExecToolDefaults(params.config),
-        elevated: params.bashElevated,
-      },
-      sandbox,
-      messageProvider: params.messageChannel ?? params.messageProvider,
-      agentAccountId: params.agentAccountId,
-      sessionKey: params.sessionKey ?? params.sessionId,
-      groupId: params.groupId,
-      groupChannel: params.groupChannel,
-      groupSpace: params.groupSpace,
-      spawnedBy: params.spawnedBy,
-      agentDir,
-      workspaceDir: effectiveWorkspace,
-      config: params.config,
-      abortSignal: runAbortController.signal,
-      modelProvider: model.provider,
-      modelId,
-      modelAuthMode: resolveModelAuthMode(model.provider, params.config),
-    });
-    const tools = sanitizeToolsForGoogle({ tools: toolsRaw, provider });
-    logToolSchemasForGoogle({ tools, provider });
-    const machineName = await getMachineDisplayName();
-    const runtimeChannel = normalizeMessageChannel(params.messageChannel ?? params.messageProvider);
-    let runtimeCapabilities = runtimeChannel
-      ? (resolveChannelCapabilities({
-          cfg: params.config,
-          channel: runtimeChannel,
-          accountId: params.agentAccountId,
-        }) ?? [])
-      : undefined;
-    if (runtimeChannel === "telegram" && params.config) {
-      const inlineButtonsScope = resolveTelegramInlineButtonsScope({
-        cfg: params.config,
-        accountId: params.agentAccountId ?? undefined,
-      });
-      if (inlineButtonsScope !== "off") {
-        if (!runtimeCapabilities) runtimeCapabilities = [];
-        if (
-          !runtimeCapabilities.some((cap) => String(cap).trim().toLowerCase() === "inlinebuttons")
-        ) {
-          runtimeCapabilities.push("inlineButtons");
-        }
-      }
-    }
-    // Resolve channel-specific message actions for system prompt
-    const channelActions = runtimeChannel
-      ? listChannelSupportedActions({
-          cfg: params.config,
-          channel: runtimeChannel,
-        })
-      : undefined;
-    const messageToolHints = runtimeChannel
-      ? resolveChannelMessageToolHints({
-          cfg: params.config,
-          channel: runtimeChannel,
-          accountId: params.agentAccountId,
-        })
-      : undefined;
-
-    const runtimeInfo = {
-      host: machineName,
-      os: `${os.type()} ${os.release()}`,
-      arch: os.arch(),
-      node: process.version,
-      model: `${provider}/${modelId}`,
-      channel: runtimeChannel,
-      capabilities: runtimeCapabilities,
-      channelActions,
-    };
-    const sandboxInfo = buildEmbeddedSandboxInfo(sandbox, params.bashElevated);
-    const reasoningTagHint = isReasoningTagProvider(provider);
-    const userTimezone = resolveUserTimezone(params.config?.agents?.defaults?.userTimezone);
-    const userTimeFormat = resolveUserTimeFormat(params.config?.agents?.defaults?.timeFormat);
-    const userTime = formatUserTime(new Date(), userTimezone, userTimeFormat);
-    const { defaultAgentId, sessionAgentId } = resolveSessionAgentIds({
-      sessionKey: params.sessionKey,
-      config: params.config,
-    });
-    const isDefaultAgent = sessionAgentId === defaultAgentId;
-    const promptMode = isSubagentSessionKey(params.sessionKey) ? "minimal" : "full";
-    const docsPath = await resolveClawdbotDocsPath({
-      workspaceDir: effectiveWorkspace,
-      argv1: process.argv[1],
-      cwd: process.cwd(),
-      moduleUrl: import.meta.url,
-    });
-    const ttsHint = params.config ? buildTtsSystemPromptHint(params.config) : undefined;
-    const appendPrompt = buildEmbeddedSystemPrompt({
-      workspaceDir: effectiveWorkspace,
-      defaultThinkLevel: params.thinkLevel,
-      reasoningLevel: params.reasoningLevel ?? "off",
-      extraSystemPrompt: params.extraSystemPrompt,
-      ownerNumbers: params.ownerNumbers,
-      reasoningTagHint,
-      heartbeatPrompt: isDefaultAgent
-        ? resolveHeartbeatPrompt(params.config?.agents?.defaults?.heartbeat?.prompt)
-        : undefined,
-      skillsPrompt,
-      docsPath: docsPath ?? undefined,
-      ttsHint,
-      promptMode,
-      runtimeInfo,
-      messageToolHints,
-      sandboxInfo,
-      tools,
-      modelAliasLines: buildModelAliasLines(params.config),
-      userTimezone,
-      userTime,
-      userTimeFormat,
-      contextFiles,
-    });
-    const systemPrompt = createSystemPromptOverride(appendPrompt);
-
-    const sessionLock = await acquireSessionWriteLock({
-      sessionFile: params.sessionFile,
-    });
-    try {
-      await prewarmSessionFile(params.sessionFile);
-      const transcriptPolicy = resolveTranscriptPolicy({
-        modelApi: model.api,
-        provider,
-        modelId,
-      });
-      const sessionManager = guardSessionManager(SessionManager.open(params.sessionFile), {
-        agentId: sessionAgentId,
-        sessionKey: params.sessionKey,
-        allowSyntheticToolResults: transcriptPolicy.allowSyntheticToolResults,
-      });
-      trackSessionManagerAccess(params.sessionFile);
-      const settingsManager = SettingsManager.create(effectiveWorkspace, agentDir);
-      ensurePiCompactionReserveTokens({
-        settingsManager,
-        minReserveTokens: resolveCompactionReserveTokensFloor(params.config),
-      });
-      const additionalExtensionPaths = buildEmbeddedExtensionPaths({
-        cfg: params.config,
-        sessionManager,
-        provider,
-        modelId,
-        model,
-      });
-
-      const { builtInTools, customTools } = splitSdkTools({
-        tools,
-        sandboxEnabled: !!sandbox?.enabled,
-      });
-
-      let session: Awaited<ReturnType<typeof createAgentSession>>["session"];
-      ({ session } = await createAgentSession({
-        cwd: resolvedWorkspace,
-        agentDir,
-        authStorage,
-        modelRegistry,
-        model,
-        thinkingLevel: mapThinkingLevel(params.thinkLevel),
-        systemPrompt,
-        tools: builtInTools,
-        customTools,
-        sessionManager,
-        settingsManager,
-        skills: [],
-        contextFiles: [],
-        additionalExtensionPaths,
-      }));
-
-      try {
-        const prior = await sanitizeSessionHistory({
-          messages: session.messages,
-          modelApi: model.api,
-          modelId,
-          provider,
-          sessionManager,
-          sessionId: params.sessionId,
-          policy: transcriptPolicy,
-        });
-        const validatedGemini = transcriptPolicy.validateGeminiTurns
-          ? validateGeminiTurns(prior)
-          : prior;
-        const validated = transcriptPolicy.validateAnthropicTurns
-          ? validateAnthropicTurns(validatedGemini)
-          : validatedGemini;
-        const limited = limitHistoryTurns(
-          validated,
-          getDmHistoryLimitFromSessionKey(params.sessionKey, params.config),
-        );
-        if (limited.length > 0) {
-          session.agent.replaceMessages(limited);
-        }
-        const result = await session.compact(params.customInstructions);
-        // Estimate tokens after compaction by summing token estimates for remaining messages
-        let tokensAfter: number | undefined;
-        try {
-          tokensAfter = 0;
-          for (const message of session.messages) {
-            tokensAfter += estimateTokens(message);
-          }
-          // Sanity check: tokensAfter should be less than tokensBefore
-          if (tokensAfter > result.tokensBefore) {
-            tokensAfter = undefined; // Don't trust the estimate
-          }
-        } catch {
-          // If estimation fails, leave tokensAfter undefined
-          tokensAfter = undefined;
-        }
-        return {
-          ok: true,
-          compacted: true,
-          result: {
-            summary: result.summary,
-            firstKeptEntryId: result.firstKeptEntryId,
-            tokensBefore: result.tokensBefore,
-            tokensAfter,
-            details: result.details,
-          },
-        };
-      } finally {
-        sessionManager.flushPendingToolResults?.();
-        session.dispose();
-      }
-    } finally {
-      await sessionLock.release();
-    }
-  } catch (err) {
-    return {
-      ok: false,
-      compacted: false,
-      reason: describeUnknownError(err),
-    };
-  } finally {
-    restoreSkillEnv?.();
-    process.chdir(prevCwd);
-  }
-}
-
-/**
- * Compacts a session with lane queueing (session lane + global lane).
- * Use this from outside a lane context. If already inside a lane, use
- * `compactEmbeddedPiSessionDirect` to avoid deadlocks.
- */
-export async function compactEmbeddedPiSession(
-  params: CompactEmbeddedPiSessionParams,
-): Promise<EmbeddedPiCompactResult> {
+}): Promise<EmbeddedPiCompactResult> {
  const sessionLane = resolveSessionLane(params.sessionKey?.trim() || params.sessionId);
  const globalLane = resolveGlobalLane(params.lane);
  const enqueueGlobal =
    params.enqueue ?? ((task, opts) => enqueueCommandInLane(globalLane, task, opts));
  return enqueueCommandInLane(sessionLane, () =>
-    enqueueGlobal(async () => compactEmbeddedPiSessionDirect(params)),
+    enqueueGlobal(async () => {
+      const resolvedWorkspace = resolveUserPath(params.workspaceDir);
+      const prevCwd = process.cwd();
+
+      const provider = (params.provider ?? DEFAULT_PROVIDER).trim() || DEFAULT_PROVIDER;
+      const modelId = (params.model ?? DEFAULT_MODEL).trim() || DEFAULT_MODEL;
+      const agentDir = params.agentDir ?? resolveClawdbotAgentDir();
+      await ensureClawdbotModelsJson(params.config, agentDir);
+      const { model, error, authStorage, modelRegistry } = resolveModel(
+        provider,
+        modelId,
+        agentDir,
+        params.config,
+      );
+      if (!model) {
+        return {
+          ok: false,
+          compacted: false,
+          reason: error ?? `Unknown model: ${provider}/${modelId}`,
+        };
+      }
+      try {
+        const apiKeyInfo = await getApiKeyForModel({
+          model,
+          cfg: params.config,
+          agentDir,
+        });
+
+        if (!apiKeyInfo.apiKey) {
+          if (apiKeyInfo.mode !== "aws-sdk") {
+            throw new Error(
+              `No API key resolved for provider "${model.provider}" (auth mode: ${apiKeyInfo.mode}).`,
+            );
+          }
+        } else if (model.provider === "github-copilot") {
+          const { resolveCopilotApiToken } =
+            await import("../../providers/github-copilot-token.js");
+          const copilotToken = await resolveCopilotApiToken({
+            githubToken: apiKeyInfo.apiKey,
+          });
+          authStorage.setRuntimeApiKey(model.provider, copilotToken.token);
+        } else {
+          authStorage.setRuntimeApiKey(model.provider, apiKeyInfo.apiKey);
+        }
+      } catch (err) {
+        return {
+          ok: false,
+          compacted: false,
+          reason: describeUnknownError(err),
+        };
+      }
+
+      await fs.mkdir(resolvedWorkspace, { recursive: true });
+      const sandboxSessionKey = params.sessionKey?.trim() || params.sessionId;
+      const sandbox = await resolveSandboxContext({
+        config: params.config,
+        sessionKey: sandboxSessionKey,
+        workspaceDir: resolvedWorkspace,
+      });
+      const effectiveWorkspace = sandbox?.enabled
+        ? sandbox.workspaceAccess === "rw"
+          ? resolvedWorkspace
+          : sandbox.workspaceDir
+        : resolvedWorkspace;
+      await fs.mkdir(effectiveWorkspace, { recursive: true });
+      await ensureSessionHeader({
+        sessionFile: params.sessionFile,
+        sessionId: params.sessionId,
+        cwd: effectiveWorkspace,
+      });
+
+      let restoreSkillEnv: (() => void) | undefined;
+      process.chdir(effectiveWorkspace);
+      try {
+        const shouldLoadSkillEntries =
+          !params.skillsSnapshot || !params.skillsSnapshot.resolvedSkills;
+        const skillEntries = shouldLoadSkillEntries
+          ? loadWorkspaceSkillEntries(effectiveWorkspace)
+          : [];
+        restoreSkillEnv = params.skillsSnapshot
+          ? applySkillEnvOverridesFromSnapshot({
+              snapshot: params.skillsSnapshot,
+              config: params.config,
+            })
+          : applySkillEnvOverrides({
+              skills: skillEntries ?? [],
+              config: params.config,
+            });
+        const skillsPrompt = resolveSkillsPromptForRun({
+          skillsSnapshot: params.skillsSnapshot,
+          entries: shouldLoadSkillEntries ? skillEntries : undefined,
+          config: params.config,
+          workspaceDir: effectiveWorkspace,
+        });
+
+        const sessionLabel = params.sessionKey ?? params.sessionId;
+        const { contextFiles } = await resolveBootstrapContextForRun({
+          workspaceDir: effectiveWorkspace,
+          config: params.config,
+          sessionKey: params.sessionKey,
+          sessionId: params.sessionId,
+          warn: makeBootstrapWarn({ sessionLabel, warn: (message) => log.warn(message) }),
+        });
+        const runAbortController = new AbortController();
+        const toolsRaw = createClawdbotCodingTools({
+          exec: {
+            ...resolveExecToolDefaults(params.config),
+            elevated: params.bashElevated,
+          },
+          sandbox,
+          messageProvider: params.messageChannel ?? params.messageProvider,
+          agentAccountId: params.agentAccountId,
+          sessionKey: params.sessionKey ?? params.sessionId,
+          groupId: params.groupId,
+          groupChannel: params.groupChannel,
+          groupSpace: params.groupSpace,
+          spawnedBy: params.spawnedBy,
+          agentDir,
+          workspaceDir: effectiveWorkspace,
+          config: params.config,
+          abortSignal: runAbortController.signal,
+          modelProvider: model.provider,
+          modelId,
+          modelAuthMode: resolveModelAuthMode(model.provider, params.config),
+        });
+        const tools = sanitizeToolsForGoogle({ tools: toolsRaw, provider });
+        logToolSchemasForGoogle({ tools, provider });
+        const machineName = await getMachineDisplayName();
+        const runtimeChannel = normalizeMessageChannel(
+          params.messageChannel ?? params.messageProvider,
+        );
+        let runtimeCapabilities = runtimeChannel
+          ? (resolveChannelCapabilities({
+              cfg: params.config,
+              channel: runtimeChannel,
+              accountId: params.agentAccountId,
+            }) ?? [])
+          : undefined;
+        if (runtimeChannel === "telegram" && params.config) {
+          const inlineButtonsScope = resolveTelegramInlineButtonsScope({
+            cfg: params.config,
+            accountId: params.agentAccountId ?? undefined,
+          });
+          if (inlineButtonsScope !== "off") {
+            if (!runtimeCapabilities) runtimeCapabilities = [];
+            if (
+              !runtimeCapabilities.some(
+                (cap) => String(cap).trim().toLowerCase() === "inlinebuttons",
+              )
+            ) {
+              runtimeCapabilities.push("inlineButtons");
+            }
+          }
+        }
+        // Resolve channel-specific message actions for system prompt
+        const channelActions = runtimeChannel
+          ? listChannelSupportedActions({
+              cfg: params.config,
+              channel: runtimeChannel,
+            })
+          : undefined;
+        const messageToolHints = runtimeChannel
+          ? resolveChannelMessageToolHints({
+              cfg: params.config,
+              channel: runtimeChannel,
+              accountId: params.agentAccountId,
+            })
+          : undefined;
+
+        const runtimeInfo = {
+          host: machineName,
+          os: `${os.type()} ${os.release()}`,
+          arch: os.arch(),
+          node: process.version,
+          model: `${provider}/${modelId}`,
+          channel: runtimeChannel,
+          capabilities: runtimeCapabilities,
+          channelActions,
+        };
+        const sandboxInfo = buildEmbeddedSandboxInfo(sandbox, params.bashElevated);
+        const reasoningTagHint = isReasoningTagProvider(provider);
+        const userTimezone = resolveUserTimezone(params.config?.agents?.defaults?.userTimezone);
+        const userTimeFormat = resolveUserTimeFormat(params.config?.agents?.defaults?.timeFormat);
+        const userTime = formatUserTime(new Date(), userTimezone, userTimeFormat);
+        const { defaultAgentId, sessionAgentId } = resolveSessionAgentIds({
+          sessionKey: params.sessionKey,
+          config: params.config,
+        });
+        const isDefaultAgent = sessionAgentId === defaultAgentId;
+        const promptMode = isSubagentSessionKey(params.sessionKey) ? "minimal" : "full";
+        const docsPath = await resolveClawdbotDocsPath({
+          workspaceDir: effectiveWorkspace,
+          argv1: process.argv[1],
+          cwd: process.cwd(),
+          moduleUrl: import.meta.url,
+        });
+        const ttsHint = params.config ? buildTtsSystemPromptHint(params.config) : undefined;
+        const appendPrompt = buildEmbeddedSystemPrompt({
+          workspaceDir: effectiveWorkspace,
+          defaultThinkLevel: params.thinkLevel,
+          reasoningLevel: params.reasoningLevel ?? "off",
+          extraSystemPrompt: params.extraSystemPrompt,
+          ownerNumbers: params.ownerNumbers,
+          reasoningTagHint,
+          heartbeatPrompt: isDefaultAgent
+            ? resolveHeartbeatPrompt(params.config?.agents?.defaults?.heartbeat?.prompt)
+            : undefined,
+          skillsPrompt,
+          docsPath: docsPath ?? undefined,
+          ttsHint,
+          promptMode,
+          runtimeInfo,
+          messageToolHints,
+          sandboxInfo,
+          tools,
+          modelAliasLines: buildModelAliasLines(params.config),
+          userTimezone,
+          userTime,
+          userTimeFormat,
+          contextFiles,
+        });
+        const systemPrompt = createSystemPromptOverride(appendPrompt);
+
+        const sessionLock = await acquireSessionWriteLock({
+          sessionFile: params.sessionFile,
+        });
+        try {
+          await prewarmSessionFile(params.sessionFile);
+          const transcriptPolicy = resolveTranscriptPolicy({
+            modelApi: model.api,
+            provider,
+            modelId,
+          });
+          const sessionManager = guardSessionManager(SessionManager.open(params.sessionFile), {
+            agentId: sessionAgentId,
+            sessionKey: params.sessionKey,
+            allowSyntheticToolResults: transcriptPolicy.allowSyntheticToolResults,
+          });
+          trackSessionManagerAccess(params.sessionFile);
+          const settingsManager = SettingsManager.create(effectiveWorkspace, agentDir);
+          ensurePiCompactionReserveTokens({
+            settingsManager,
+            minReserveTokens: resolveCompactionReserveTokensFloor(params.config),
+          });
+          const additionalExtensionPaths = buildEmbeddedExtensionPaths({
+            cfg: params.config,
+            sessionManager,
+            provider,
+            modelId,
+            model,
+          });
+
+          const { builtInTools, customTools } = splitSdkTools({
+            tools,
+            sandboxEnabled: !!sandbox?.enabled,
+          });
+
+          let session: Awaited<ReturnType<typeof createAgentSession>>["session"];
+          ({ session } = await createAgentSession({
+            cwd: resolvedWorkspace,
+            agentDir,
+            authStorage,
+            modelRegistry,
+            model,
+            thinkingLevel: mapThinkingLevel(params.thinkLevel),
+            systemPrompt,
+            tools: builtInTools,
+            customTools,
+            sessionManager,
+            settingsManager,
+            skills: [],
+            contextFiles: [],
+            additionalExtensionPaths,
+          }));
+
+          try {
+            const prior = await sanitizeSessionHistory({
+              messages: session.messages,
+              modelApi: model.api,
+              modelId,
+              provider,
+              sessionManager,
+              sessionId: params.sessionId,
+              policy: transcriptPolicy,
+            });
+            const validatedGemini = transcriptPolicy.validateGeminiTurns
+              ? validateGeminiTurns(prior)
+              : prior;
+            const validated = transcriptPolicy.validateAnthropicTurns
+              ? validateAnthropicTurns(validatedGemini)
+              : validatedGemini;
+            const limited = limitHistoryTurns(
+              validated,
+              getDmHistoryLimitFromSessionKey(params.sessionKey, params.config),
+            );
+            if (limited.length > 0) {
+              session.agent.replaceMessages(limited);
+            }
+            const result = await session.compact(params.customInstructions);
+            // Estimate tokens after compaction by summing token estimates for remaining messages
+            let tokensAfter: number | undefined;
+            try {
+              tokensAfter = 0;
+              for (const message of session.messages) {
+                tokensAfter += estimateTokens(message);
+              }
+              // Sanity check: tokensAfter should be less than tokensBefore
+              if (tokensAfter > result.tokensBefore) {
+                tokensAfter = undefined; // Don't trust the estimate
+              }
+            } catch {
+              // If estimation fails, leave tokensAfter undefined
+              tokensAfter = undefined;
+            }
+            return {
+              ok: true,
+              compacted: true,
+              result: {
+                summary: result.summary,
+                firstKeptEntryId: result.firstKeptEntryId,
+                tokensBefore: result.tokensBefore,
+                tokensAfter,
+                details: result.details,
+              },
+            };
+          } finally {
+            sessionManager.flushPendingToolResults?.();
+            session.dispose();
+          }
+        } finally {
+          await sessionLock.release();
+        }
+      } catch (err) {
+        return {
+          ok: false,
+          compacted: false,
+          reason: describeUnknownError(err),
+        };
+      } finally {
+        restoreSkillEnv?.();
+        process.chdir(prevCwd);
+      }
+    }),
  );
 }
@@ -1,285 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-
-vi.mock("./run/attempt.js", () => ({
-  runEmbeddedAttempt: vi.fn(),
-}));
-
-vi.mock("./compact.js", () => ({
-  compactEmbeddedPiSessionDirect: vi.fn(),
-}));
-
-vi.mock("./model.js", () => ({
-  resolveModel: vi.fn(() => ({
-    model: {
-      id: "test-model",
-      provider: "anthropic",
-      contextWindow: 200000,
-      api: "messages",
-    },
-    error: null,
-    authStorage: {
-      setRuntimeApiKey: vi.fn(),
-    },
-    modelRegistry: {},
-  })),
-}));
-
-vi.mock("../model-auth.js", () => ({
-  ensureAuthProfileStore: vi.fn(() => ({})),
-  getApiKeyForModel: vi.fn(async () => ({
-    apiKey: "test-key",
-    profileId: "test-profile",
-    source: "test",
-  })),
-  resolveAuthProfileOrder: vi.fn(() => []),
-}));
-
-vi.mock("../models-config.js", () => ({
-  ensureClawdbotModelsJson: vi.fn(async () => {}),
-}));
-
-vi.mock("../context-window-guard.js", () => ({
-  CONTEXT_WINDOW_HARD_MIN_TOKENS: 1000,
-  CONTEXT_WINDOW_WARN_BELOW_TOKENS: 5000,
-  evaluateContextWindowGuard: vi.fn(() => ({
-    shouldWarn: false,
-    shouldBlock: false,
-    tokens: 200000,
-    source: "model",
-  })),
-  resolveContextWindowInfo: vi.fn(() => ({
-    tokens: 200000,
-    source: "model",
-  })),
-}));
-
-vi.mock("../../process/command-queue.js", () => ({
-  enqueueCommandInLane: vi.fn((_lane: string, task: () => unknown) => task()),
-}));
-
-vi.mock("../../utils.js", () => ({
-  resolveUserPath: vi.fn((p: string) => p),
-}));
-
-vi.mock("../../utils/message-channel.js", () => ({
-  isMarkdownCapableMessageChannel: vi.fn(() => true),
-}));
-
-vi.mock("../agent-paths.js", () => ({
-  resolveClawdbotAgentDir: vi.fn(() => "/tmp/agent-dir"),
-}));
-
-vi.mock("../auth-profiles.js", () => ({
-  markAuthProfileFailure: vi.fn(async () => {}),
-  markAuthProfileGood: vi.fn(async () => {}),
-  markAuthProfileUsed: vi.fn(async () => {}),
-}));
-
-vi.mock("../defaults.js", () => ({
-  DEFAULT_CONTEXT_TOKENS: 200000,
-  DEFAULT_MODEL: "test-model",
-  DEFAULT_PROVIDER: "anthropic",
-}));
-
-vi.mock("../failover-error.js", () => ({
-  FailoverError: class extends Error {
-    constructor(msg: string) {
-      super(msg);
-    }
-  },
-  resolveFailoverStatus: vi.fn(),
-}));
-
-vi.mock("../usage.js", () => ({
-  normalizeUsage: vi.fn(() => undefined),
-}));
-
-vi.mock("./lanes.js", () => ({
-  resolveSessionLane: vi.fn(() => "session-lane"),
-  resolveGlobalLane: vi.fn(() => "global-lane"),
-}));
-
-vi.mock("./logger.js", () => ({
-  log: {
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  },
-}));
-
-vi.mock("./run/payloads.js", () => ({
-  buildEmbeddedRunPayloads: vi.fn(() => []),
-}));
-
-vi.mock("./utils.js", () => ({
-  describeUnknownError: vi.fn((err: unknown) => {
-    if (err instanceof Error) return err.message;
-    return String(err);
-  }),
-}));
-
-vi.mock("../pi-embedded-helpers.js", async () => {
-  return {
-    isCompactionFailureError: (msg?: string) => {
-      if (!msg) return false;
-      const lower = msg.toLowerCase();
-      return lower.includes("request_too_large") && lower.includes("summarization failed");
-    },
-    isContextOverflowError: (msg?: string) => {
-      if (!msg) return false;
-      const lower = msg.toLowerCase();
-      return lower.includes("request_too_large") || lower.includes("request size exceeds");
-    },
-    isFailoverAssistantError: vi.fn(() => false),
-    isFailoverErrorMessage: vi.fn(() => false),
-    isAuthAssistantError: vi.fn(() => false),
-    isRateLimitAssistantError: vi.fn(() => false),
-    classifyFailoverReason: vi.fn(() => null),
-    formatAssistantErrorText: vi.fn(() => ""),
-    pickFallbackThinkingLevel: vi.fn(() => null),
-    isTimeoutErrorMessage: vi.fn(() => false),
-    parseImageDimensionError: vi.fn(() => null),
-  };
-});
-
-import { runEmbeddedPiAgent } from "./run.js";
-import { runEmbeddedAttempt } from "./run/attempt.js";
-import { compactEmbeddedPiSessionDirect } from "./compact.js";
-import { log } from "./logger.js";
-
-import type { EmbeddedRunAttemptResult } from "./run/types.js";
-
-const mockedRunEmbeddedAttempt = vi.mocked(runEmbeddedAttempt);
-const mockedCompactDirect = vi.mocked(compactEmbeddedPiSessionDirect);
-
-function makeAttemptResult(
-  overrides: Partial<EmbeddedRunAttemptResult> = {},
-): EmbeddedRunAttemptResult {
-  return {
-    aborted: false,
-    timedOut: false,
-    promptError: null,
-    sessionIdUsed: "test-session",
-    assistantTexts: ["Hello!"],
-    toolMetas: [],
-    lastAssistant: undefined,
-    messagesSnapshot: [],
-    didSendViaMessagingTool: false,
-    messagingToolSentTexts: [],
-    messagingToolSentTargets: [],
-    cloudCodeAssistFormatError: false,
-    ...overrides,
-  };
-}
-
-const baseParams = {
-  sessionId: "test-session",
-  sessionKey: "test-key",
-  sessionFile: "/tmp/session.json",
-  workspaceDir: "/tmp/workspace",
-  prompt: "hello",
-  timeoutMs: 30000,
-  runId: "run-1",
-};
-
-describe("overflow compaction in run loop", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("retries after successful compaction on context overflow promptError", async () => {
-    const overflowError = new Error("request_too_large: Request size exceeds model context window");
-
-    mockedRunEmbeddedAttempt
-      .mockResolvedValueOnce(makeAttemptResult({ promptError: overflowError }))
-      .mockResolvedValueOnce(makeAttemptResult({ promptError: null }));
-
-    mockedCompactDirect.mockResolvedValueOnce({
-      ok: true,
-      compacted: true,
-      result: {
-        summary: "Compacted session",
-        firstKeptEntryId: "entry-5",
-        tokensBefore: 150000,
-      },
-    });
-
-    const result = await runEmbeddedPiAgent(baseParams);
-
-    expect(mockedCompactDirect).toHaveBeenCalledTimes(1);
-    expect(mockedCompactDirect).toHaveBeenCalledWith(
-      expect.objectContaining({ authProfileId: "test-profile" }),
-    );
-    expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);
-    expect(log.warn).toHaveBeenCalledWith(
-      expect.stringContaining("context overflow detected; attempting auto-compaction"),
-    );
-    expect(log.info).toHaveBeenCalledWith(expect.stringContaining("auto-compaction succeeded"));
-    // Should not be an error result
-    expect(result.meta.error).toBeUndefined();
-  });
-
-  it("returns error if compaction fails", async () => {
-    const overflowError = new Error("request_too_large: Request size exceeds model context window");
-
-    mockedRunEmbeddedAttempt.mockResolvedValue(makeAttemptResult({ promptError: overflowError }));
-
-    mockedCompactDirect.mockResolvedValueOnce({
-      ok: false,
-      compacted: false,
-      reason: "nothing to compact",
-    });
-
-    const result = await runEmbeddedPiAgent(baseParams);
-
-    expect(mockedCompactDirect).toHaveBeenCalledTimes(1);
-    expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(1);
-    expect(result.meta.error?.kind).toBe("context_overflow");
-    expect(result.payloads?.[0]?.isError).toBe(true);
-    expect(log.warn).toHaveBeenCalledWith(expect.stringContaining("auto-compaction failed"));
-  });
-
-  it("returns error if overflow happens again after compaction", async () => {
-    const overflowError = new Error("request_too_large: Request size exceeds model context window");
-
-    mockedRunEmbeddedAttempt
-      .mockResolvedValueOnce(makeAttemptResult({ promptError: overflowError }))
-      .mockResolvedValueOnce(makeAttemptResult({ promptError: overflowError }));
-
-    mockedCompactDirect.mockResolvedValueOnce({
-      ok: true,
-      compacted: true,
-      result: {
-        summary: "Compacted",
-        firstKeptEntryId: "entry-3",
-        tokensBefore: 180000,
-      },
-    });
-
-    const result = await runEmbeddedPiAgent(baseParams);
-
-    // Compaction attempted only once
-    expect(mockedCompactDirect).toHaveBeenCalledTimes(1);
-    // Two attempts: first overflow -> compact -> retry -> second overflow -> return error
-    expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(2);
-    expect(result.meta.error?.kind).toBe("context_overflow");
-    expect(result.payloads?.[0]?.isError).toBe(true);
-  });
-
-  it("does not attempt compaction for compaction_failure errors", async () => {
-    const compactionFailureError = new Error(
-      "request_too_large: summarization failed - Request size exceeds model context window",
-    );
-
-    mockedRunEmbeddedAttempt.mockResolvedValue(
-      makeAttemptResult({ promptError: compactionFailureError }),
-    );
-
-    const result = await runEmbeddedPiAgent(baseParams);
-
-    expect(mockedCompactDirect).not.toHaveBeenCalled();
-    expect(mockedRunEmbeddedAttempt).toHaveBeenCalledTimes(1);
-    expect(result.meta.error?.kind).toBe("compaction_failure");
-  });
-});
@@ -42,7 +42,6 @@ import {
 } from "../pi-embedded-helpers.js";
 import { normalizeUsage, type UsageLike } from "../usage.js";

-import { compactEmbeddedPiSessionDirect } from "./compact.js";
 import { resolveGlobalLane, resolveSessionLane } from "./lanes.js";
 import { log } from "./logger.js";
 import { resolveModel } from "./model.js";
@@ -291,7 +290,6 @@ export async function runEmbeddedPiAgent(
        }
      }

-      let overflowCompactionAttempted = false;
      try {
        while (true) {
          attemptedThinking.add(thinkLevel);
@@ -360,42 +358,9 @@ export async function runEmbeddedPiAgent(
          if (promptError && !aborted) {
            const errorText = describeUnknownError(promptError);
            if (isContextOverflowError(errorText)) {
-              const isCompactionFailure = isCompactionFailureError(errorText);
-              // Attempt auto-compaction on context overflow (not compaction_failure)
-              if (!isCompactionFailure && !overflowCompactionAttempted) {
-                log.warn(
-                  `context overflow detected; attempting auto-compaction for ${provider}/${modelId}`,
-                );
-                overflowCompactionAttempted = true;
-                const compactResult = await compactEmbeddedPiSessionDirect({
-                  sessionId: params.sessionId,
-                  sessionKey: params.sessionKey,
-                  messageChannel: params.messageChannel,
-                  messageProvider: params.messageProvider,
-                  agentAccountId: params.agentAccountId,
-                  authProfileId: lastProfileId,
-                  sessionFile: params.sessionFile,
-                  workspaceDir: params.workspaceDir,
-                  agentDir,
-                  config: params.config,
-                  skillsSnapshot: params.skillsSnapshot,
-                  provider,
-                  model: modelId,
-                  thinkLevel,
-                  reasoningLevel: params.reasoningLevel,
-                  bashElevated: params.bashElevated,
-                  extraSystemPrompt: params.extraSystemPrompt,
-                  ownerNumbers: params.ownerNumbers,
-                });
-                if (compactResult.compacted) {
-                  log.info(`auto-compaction succeeded for ${provider}/${modelId}; retrying prompt`);
-                  continue;
-                }
-                log.warn(
-                  `auto-compaction failed for ${provider}/${modelId}: ${compactResult.reason ?? "nothing to compact"}`,
-                );
-              }
-              const kind = isCompactionFailure ? "compaction_failure" : "context_overflow";
+              const kind = isCompactionFailureError(errorText)
+                ? "compaction_failure"
+                : "context_overflow";
              return {
                payloads: [
                  {
@@ -177,11 +177,13 @@ describe("createTelegramBot", () => {
    expect(throttlerSpy).toHaveBeenCalledTimes(1);
    expect(useSpy).toHaveBeenCalledWith("throttler");
  });
-  it("uses wrapped fetch when global fetch is available", () => {
+  it("forces native fetch only under Bun", () => {
    const originalFetch = globalThis.fetch;
+    const originalBun = (globalThis as { Bun?: unknown }).Bun;
    const fetchSpy = vi.fn() as unknown as typeof fetch;
    globalThis.fetch = fetchSpy;
    try {
+      (globalThis as { Bun?: unknown }).Bun = {};
      createTelegramBot({ token: "tok" });
      const fetchImpl = resolveTelegramFetch();
      expect(fetchImpl).toBeTypeOf("function");
@@ -192,6 +194,33 @@ describe("createTelegramBot", () => {
      expect(clientFetch).not.toBe(fetchSpy);
    } finally {
      globalThis.fetch = originalFetch;
+      if (originalBun === undefined) {
+        delete (globalThis as { Bun?: unknown }).Bun;
+      } else {
+        (globalThis as { Bun?: unknown }).Bun = originalBun;
+      }
+    }
+  });
+  it("does not force native fetch on Node", () => {
+    const originalFetch = globalThis.fetch;
+    const originalBun = (globalThis as { Bun?: unknown }).Bun;
+    const fetchSpy = vi.fn() as unknown as typeof fetch;
+    globalThis.fetch = fetchSpy;
+    try {
+      if (originalBun !== undefined) {
+        delete (globalThis as { Bun?: unknown }).Bun;
+      }
+      createTelegramBot({ token: "tok" });
+      const fetchImpl = resolveTelegramFetch();
+      expect(fetchImpl).toBeUndefined();
+      expect(botCtorSpy).toHaveBeenCalledWith("tok", undefined);
+    } finally {
+      globalThis.fetch = originalFetch;
+      if (originalBun === undefined) {
+        delete (globalThis as { Bun?: unknown }).Bun;
+      } else {
+        (globalThis as { Bun?: unknown }).Bun = originalBun;
+      }
    }
  });
  it("passes timeoutSeconds even without a custom fetch", () => {
@@ -309,11 +309,13 @@ describe("createTelegramBot", () => {
    expect(registered.some((command) => reserved.includes(command.command))).toBe(false);
  });

-  it("uses wrapped fetch when global fetch is available", () => {
+  it("forces native fetch only under Bun", () => {
    const originalFetch = globalThis.fetch;
+    const originalBun = (globalThis as { Bun?: unknown }).Bun;
    const fetchSpy = vi.fn() as unknown as typeof fetch;
    globalThis.fetch = fetchSpy;
    try {
+      (globalThis as { Bun?: unknown }).Bun = {};
      createTelegramBot({ token: "tok" });
      const fetchImpl = resolveTelegramFetch();
      expect(fetchImpl).toBeTypeOf("function");
@@ -324,6 +326,34 @@ describe("createTelegramBot", () => {
      expect(clientFetch).not.toBe(fetchSpy);
    } finally {
      globalThis.fetch = originalFetch;
+      if (originalBun === undefined) {
+        delete (globalThis as { Bun?: unknown }).Bun;
+      } else {
+        (globalThis as { Bun?: unknown }).Bun = originalBun;
+      }
+    }
+  });
+
+  it("does not force native fetch on Node", () => {
+    const originalFetch = globalThis.fetch;
+    const originalBun = (globalThis as { Bun?: unknown }).Bun;
+    const fetchSpy = vi.fn() as unknown as typeof fetch;
+    globalThis.fetch = fetchSpy;
+    try {
+      if (originalBun !== undefined) {
+        delete (globalThis as { Bun?: unknown }).Bun;
+      }
+      createTelegramBot({ token: "tok" });
+      const fetchImpl = resolveTelegramFetch();
+      expect(fetchImpl).toBeUndefined();
+      expect(botCtorSpy).toHaveBeenCalledWith("tok", undefined);
+    } finally {
+      globalThis.fetch = originalFetch;
+      if (originalBun === undefined) {
+        delete (globalThis as { Bun?: unknown }).Bun;
+      } else {
+        (globalThis as { Bun?: unknown }).Bun = originalBun;
+      }
    }
  });

@@ -117,7 +117,8 @@ export function createTelegramBot(opts: TelegramBotOptions) {
  const telegramCfg = account.config;

  const fetchImpl = resolveTelegramFetch(opts.proxyFetch);
-  const shouldProvideFetch = Boolean(fetchImpl);
+  const isBun = "Bun" in globalThis || Boolean(process?.versions?.bun);
+  const shouldProvideFetch = Boolean(opts.proxyFetch) || isBun;
  const timeoutSeconds =
    typeof telegramCfg?.timeoutSeconds === "number" && Number.isFinite(telegramCfg.timeoutSeconds)
      ? Math.max(1, Math.floor(telegramCfg.timeoutSeconds))
@@ -1,28 +1,37 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";

 import { resolveTelegramFetch } from "./fetch.js";

 describe("resolveTelegramFetch", () => {
-  const originalFetch = globalThis.fetch;
+  it("wraps proxy fetch to normalize foreign abort signals", async () => {
+    let seenSignal: AbortSignal | undefined;
+    const proxyFetch = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      seenSignal = init?.signal as AbortSignal | undefined;
+      return {} as Response;
+    });

-  afterEach(() => {
-    if (originalFetch) {
-      globalThis.fetch = originalFetch;
-    } else {
-      delete (globalThis as { fetch?: typeof fetch }).fetch;
-    }
-  });
+    const fetcher = resolveTelegramFetch(proxyFetch);
+    expect(fetcher).toBeTypeOf("function");

-  it("returns wrapped global fetch when available", () => {
-    const fetchMock = vi.fn(async () => ({}));
-    globalThis.fetch = fetchMock as unknown as typeof fetch;
-    const resolved = resolveTelegramFetch();
-    expect(resolved).toBeTypeOf("function");
-  });
+    let abortHandler: (() => void) | null = null;
+    const fakeSignal = {
+      aborted: false,
+      addEventListener: (event: string, handler: () => void) => {
+        if (event === "abort") abortHandler = handler;
+      },
+      removeEventListener: (event: string, handler: () => void) => {
+        if (event === "abort" && abortHandler === handler) abortHandler = null;
+      },
+    } as AbortSignal;

-  it("prefers proxy fetch when provided", () => {
-    const fetchMock = vi.fn(async () => ({}));
-    const resolved = resolveTelegramFetch(fetchMock as unknown as typeof fetch);
-    expect(resolved).toBeTypeOf("function");
+    const promise = fetcher!("https://example.com", { signal: fakeSignal });
+    expect(proxyFetch).toHaveBeenCalledOnce();
+    expect(seenSignal).toBeInstanceOf(AbortSignal);
+    expect(seenSignal).not.toBe(fakeSignal);
+
+    abortHandler?.();
+    expect(seenSignal?.aborted).toBe(true);
+
+    await promise;
  });
 });
@@ -1,8 +1,10 @@
 import { resolveFetch } from "../infra/fetch.js";

-// Prefer wrapped fetch when available to normalize AbortSignal across runtimes.
+// Bun-only: force native fetch to avoid grammY's Node shim under Bun.
 export function resolveTelegramFetch(proxyFetch?: typeof fetch): typeof fetch | undefined {
  if (proxyFetch) return resolveFetch(proxyFetch);
+  const isBun = "Bun" in globalThis || Boolean(process?.versions?.bun);
+  if (!isBun) return undefined;
  const fetchImpl = resolveFetch();
  if (!fetchImpl) {
    throw new Error("fetch is not available; set channels.telegram.proxy in config");