fix(discord): forward DiscordAPIError code through resolveTextChannel wrapper

Addresses Codex P2 review on PR #211. resolveTextChannel() catches each
client.channels.fetch() failure and then rethrows a generic
Error("Discord channel ... is not text-based or inaccessible") with no
`code` attached. That generic error reaches isPermanentChannelError(),
which checks for numeric DiscordAPIErrorcode (10003 Unknown Channel /
50001 Missing Access / etc.) and falls through to false — so a Discord
cron job whose bot has been removed from the target channel stays
enabled and keeps firing every tick, exactly the noise pattern this PR
exists to fix.

Capture every Discord API code from each fetch attempt, pick a permanent
one (10003 / 50001 / 50013 / 50007) when available, and attach it to the
thrown wrapper as `code` (with the full list on `discordErrorCodes`
for diagnostics). The wrapper's message is unchanged so callers that
match on the string still work.

Add a permanent-error.test.ts case asserting the wrapper Error with a
forwarded code is classified as permanent.

bun test: 419 pass, 1 skip, 0 fail.

Author: Kai Liu

packages/ims/discord/client.ts

@@ -116,6 +116,20 @@ async function maybeHandleLauncherCommand(params: {
 }
 async function resolveTextChannel(channelId: string, processorId?: string) {
   const attempts: string[] = [];
+  // Collect Discord API error codes across every fetch attempt so the
+  // caller can detect permanent-access failures (Unknown Channel / Missing
+  // Access / etc.) even though we re-throw a generic wrapper Error below.
+  // discord.js surfaces these on `err.code` as numbers; we forward them on
+  // the wrapper as `discordErrorCodes` and also expose the first as `code`
+  // so `isPermanentChannelError` can pick it up via the `code` shape.
+  const discordErrorCodes: number[] = [];
+  const captureCode = (error: unknown) => {
+    if (typeof error === "object" && error !== null) {
+      const code = (error as { code?: unknown }).code;
+      if (typeof code === "number") discordErrorCodes.push(code);
+    }
+  };
+
   if (processorId) {
     const pinnedClient = discordClientByProcessorId.get(processorId);
     if (pinnedClient) {
@@ -126,6 +140,7 @@ async function resolveTextChannel(channelId: string, processorId?: string) {
         }
         attempts.push(`bot=${pinnedClient.user?.id || "unknown"}: channel_not_text_or_missing`);
       } catch (error) {
+        captureCode(error);
         const errorMessage = error instanceof Error ? error.message : String(error);
         attempts.push(`bot=${pinnedClient.user?.id || "unknown"}: ${errorMessage}`);
       }
@@ -141,6 +156,7 @@ async function resolveTextChannel(channelId: string, processorId?: string) {
       }
       attempts.push(`bot=${client.user?.id || "unknown"}: channel_not_text_or_missing`);
     } catch (error) {
+      captureCode(error);
       const errorMessage = error instanceof Error ? error.message : String(error);
       attempts.push(`bot=${client.user?.id || "unknown"}: ${errorMessage}`);
     }
@@ -154,7 +170,20 @@ async function resolveTextChannel(channelId: string, processorId?: string) {
     });
   }
 
-  throw new Error(`Discord channel ${channelId} is not text-based or inaccessible`);
+  const wrapper = new Error(`Discord channel ${channelId} is not text-based or inaccessible`);
+  if (discordErrorCodes.length > 0) {
+    // Prefer the most informative code: prioritise "permanent" classes
+    // (10003 Unknown Channel, 50001 Missing Access, 50013 Missing Perms,
+    // 50007 Cannot DM) so isPermanentChannelError can disable the cron row
+    // even if some bots failed transiently.
+    const PERMANENT_PRIORITY = new Set([10003, 50001, 50013, 50007]);
+    const permanent = discordErrorCodes.find((c) => PERMANENT_PRIORITY.has(c));
+    (wrapper as Error & { code?: number; discordErrorCodes?: number[] }).code =
+      permanent ?? discordErrorCodes[0];
+    (wrapper as Error & { code?: number; discordErrorCodes?: number[] }).discordErrorCodes =
+      [...discordErrorCodes];
+  }
+  throw wrapper;
 }
 
 async function buildDiscordContext(

packages/shared/delivery/permanent-error.test.ts

@@ -39,6 +39,18 @@ describe("isPermanentChannelError", () => {
     ).toBe(true);
   });
 
+  test("matches the Discord resolveTextChannel wrapper when it carries a DiscordAPIError code", () => {
+    // resolveTextChannel() in packages/ims/discord/client.ts wraps the
+    // underlying DiscordAPIError in a generic Error("... is not text-based
+    // or inaccessible"). The wrapper forwards the original numeric `code`
+    // so this helper can still classify it as permanent.
+    const wrapper = Object.assign(
+      new Error("Discord channel 123 is not text-based or inaccessible"),
+      { code: 10003 },
+    );
+    expect(isPermanentChannelError(wrapper)).toBe(true);
+  });
+
   test("matches Lark chat_not_found", () => {
     expect(isPermanentChannelError(new Error("chat_not_found: chat does not exist"))).toBe(true);
   });