Move provider to a plugin-architecture (#661)

* refactor: introduce provider plugin registry

* refactor: move provider CLI to plugins

* docs: add provider plugin implementation notes

* refactor: shift provider runtime logic into plugins

* refactor: add plugin defaults and summaries

* docs: update provider plugin notes

* feat(commands): add /commands slash list

* Auto-reply: tidy help message

* Auto-reply: fix status command lint

* Tests: align google shared expectations

* Auto-reply: tidy help message

* Auto-reply: fix status command lint

* refactor: move provider routing into plugins

* test: align agent routing expectations

* docs: update provider plugin notes

* refactor: route replies via provider plugins

* docs: note route-reply plugin hooks

* refactor: extend provider plugin contract

* refactor: derive provider status from plugins

* refactor: unify gateway provider control

* refactor: use plugin metadata in auto-reply

* fix: parenthesize cron target selection

* refactor: derive gateway methods from plugins

* refactor: generalize provider logout

* refactor: route provider logout through plugins

* refactor: move WhatsApp web login methods into plugin

* refactor: generalize provider log prefixes

* refactor: centralize default chat provider

* refactor: derive provider lists from registry

* refactor: move provider reload noops into plugins

* refactor: resolve web login provider via alias

* refactor: derive CLI provider options from plugins

* refactor: derive prompt provider list from plugins

* style: apply biome lint fixes

* fix: resolve provider routing edge cases

* docs: update provider plugin refactor notes

* fix(gateway): harden agent provider routing

* refactor: move provider routing into plugins

* refactor: move provider CLI to plugins

* refactor: derive provider lists from registry

* fix: restore slash command parsing

* refactor: align provider ids for schema

* refactor: unify outbound target resolution

* fix: keep outbound labels stable

* feat: add msteams to cron surfaces

* fix: clean up lint build issues

* refactor: localize chat provider alias normalization

* refactor: drive gateway provider lists from plugins

* docs: update provider plugin notes

* style: format message-provider

* fix: avoid provider registry init cycles

* style: sort message-provider imports

* fix: relax provider alias map typing

* refactor: move provider routing into plugins

* refactor: add plugin pairing/config adapters

* refactor: route pairing and provider removal via plugins

* refactor: align auto-reply provider typing

* test: stabilize telegram media mocks

* docs: update provider plugin refactor notes

* refactor: pluginize outbound targets

* refactor: pluginize provider selection

* refactor: generalize text chunk limits

* docs: update provider plugin notes

* refactor: generalize group session/config

* fix: normalize provider id for room detection

* fix: avoid provider init in system prompt

* style: formatting cleanup

* refactor: normalize agent delivery targets

* test: update outbound delivery labels

* chore: fix lint regressions

* refactor: extend provider plugin adapters

* refactor: move elevated/block streaming defaults to plugins

* refactor: defer outbound send deps to plugins

* docs: note plugin-driven streaming/elevated defaults

* refactor: centralize webchat provider constant

* refactor: add provider setup adapters

* refactor: delegate provider add config to plugins

* docs: document plugin-driven provider add

* refactor: add plugin state/binding metadata

* refactor: build agent provider status from plugins

* docs: note plugin-driven agent bindings

* refactor: centralize internal provider constant usage

* fix: normalize WhatsApp targets for groups and E.164 (#631) (thanks @imfing)

* refactor: centralize default chat provider

* refactor: centralize WhatsApp target normalization

* refactor: move provider routing into plugins

* refactor: normalize agent delivery targets

* chore: fix lint regressions

* fix: normalize WhatsApp targets for groups and E.164 (#631) (thanks @imfing)

* feat: expand provider plugin adapters

* refactor: route auto-reply via provider plugins

* fix: align WhatsApp target normalization

* fix: normalize WhatsApp targets for groups and E.164 (#631) (thanks @imfing)

* refactor: centralize WhatsApp target normalization

* feat: add /config chat config updates

* docs: add /config get alias

* feat(commands): add /commands slash list

* refactor: centralize default chat provider

* style: apply biome lint fixes

* chore: fix lint regressions

* fix: clean up whatsapp allowlist typing

* style: format config command helpers

* refactor: pluginize tool threading context

* refactor: normalize session announce targets

* docs: note new plugin threading and announce hooks

* refactor: pluginize message actions

* docs: update provider plugin actions notes

* fix: align provider action adapters

* refactor: centralize webchat checks

* style: format message provider helpers

* refactor: move provider onboarding into adapters

* docs: note onboarding provider adapters

* feat: add msteams onboarding adapter

* style: organize onboarding imports

* fix: normalize msteams allowFrom types

* feat: add plugin text chunk limits

* refactor: use plugin chunk limit fallbacks

* feat: add provider mention stripping hooks

* style: organize provider plugin type imports

* refactor: generalize health snapshots

* refactor: update macOS health snapshot handling

* docs: refresh health snapshot notes

* style: format health snapshot updates

* refactor: drive security warnings via plugins

* docs: note provider security adapter

* style: format provider security adapters

* refactor: centralize provider account defaults

* refactor: type gateway client identity constants

* chore: regen gateway protocol swift

* fix: degrade health on failed provider probe

* refactor: centralize pairing approve hint

* docs: add plugin CLI command references

* refactor: route auth and tool sends through plugins

* docs: expand provider plugin hooks

* refactor: document provider docking touchpoints

* refactor: normalize internal provider defaults

* refactor: streamline outbound delivery wiring

* refactor: make provider onboarding plugin-owned

* refactor: support provider-owned agent tools

* refactor: move telegram draft chunking into telegram module

* refactor: infer provider tool sends via extractToolSend

* fix: repair plugin onboarding imports

* refactor: de-dup outbound target normalization

* style: tidy plugin and agent imports

* refactor: data-drive provider selection line

* fix: satisfy lint after provider plugin rebase

* test: deflake gateway-cli coverage

* style: format gateway-cli coverage test

* refactor(provider-plugins): simplify provider ids

* test(pairing-cli): avoid provider-specific ternary

* style(macos): swiftformat HealthStore

* refactor(sandbox): derive provider tool denylist

* fix(sandbox): avoid plugin init in defaults

* refactor(provider-plugins): centralize provider aliases

* style(test): satisfy biome

* refactor(protocol): v3 providers.status maps

* refactor(ui): adapt to protocol v3

* refactor(macos): adapt to protocol v3

* test: update providers.status v3 fixtures

* refactor(gateway): map provider runtime snapshot

* test(gateway): update reload runtime snapshot

* refactor(whatsapp): normalize heartbeat provider id

* docs(refactor): update provider plugin notes

* style: satisfy biome after rebase

* fix: describe sandboxed elevated in prompt

* feat(gateway): add agent image attachments + live probe

* refactor: derive CLI provider options from plugins

* fix(gateway): harden agent provider routing

* fix(gateway): harden agent provider routing

* refactor: align provider ids for schema

* fix(protocol): keep agent provider string

* fix(gateway): harden agent provider routing

* fix(protocol): keep agent provider string

* refactor: normalize agent delivery targets

* refactor: support provider-owned agent tools

* refactor(config): provider-keyed elevated allowFrom

* style: satisfy biome

* fix(gateway): appease provider narrowing

* style: satisfy biome

* refactor(reply): move group intro hints into plugin

* fix(reply): avoid plugin registry init cycle

* refactor(providers): add lightweight provider dock

* refactor(gateway): use typed client id in connect

* refactor(providers): document docks and avoid init cycles

* refactor(providers): make media limit helper generic

* fix(providers): break plugin registry import cycles

* style: satisfy biome

* refactor(status-all): build providers table from plugins

* refactor(gateway): delegate web login to provider plugin

* refactor(provider): drop web alias

* refactor(provider): lazy-load monitors

* style: satisfy lint/format

* style: format status-all providers table

* style: swiftformat gateway discovery model

* test: make reload plan plugin-driven

* fix: avoid token stringification in status-all

* refactor: make provider IDs explicit in status

* feat: warn on signal/imessage provider runtime errors

* test: cover gateway provider runtime warnings in status

* fix: add runtime kind to provider status issues

* test: cover health degradation on probe failure

* fix: keep routeReply lightweight

* style: organize routeReply imports

* refactor(web): extract auth-store helpers

* refactor(whatsapp): lazy login imports

* refactor(outbound): route replies via plugin outbound

* docs: update provider plugin notes

* style: format provider status issues

* fix: make sandbox scope warning wrap-safe

* refactor: load outbound adapters from provider plugins

* docs: update provider plugin outbound notes

* style(macos): fix swiftformat lint

* docs: changelog for provider plugins

* fix(macos): satisfy swiftformat

* fix(macos): open settings via menu action

* style: format after rebase

* fix(macos): open Settings via menu action

---------

Co-authored-by: LK <luke@kyohere.com>
Co-authored-by: Luke K (pr-0f3t) <2609441+lc0rp@users.noreply.github.com>
Co-authored-by: Xin <xin@imfing.com>

src/cron/isolated-agent.test.ts

@@ -445,7 +445,7 @@ describe("runCronIsolatedAgentTurn", () => {
     });
   });
 
-  it("passes telegram token from config for delivery", async () => {
+  it("delivers telegram via provider send", async () => {
     await withTempHome(async (home) => {
       const storePath = await writeSessionStore(home);
       const deps: CliDeps = {
@@ -488,7 +488,7 @@ describe("runCronIsolatedAgentTurn", () => {
         expect(deps.sendMessageTelegram).toHaveBeenCalledWith(
           "123",
           "hello from cron",
-          expect.objectContaining({ token: "t-1" }),
+          expect.objectContaining({ verbose: false }),
         );
       } finally {
         if (prevTelegramToken === undefined) {
@@ -500,7 +500,7 @@ describe("runCronIsolatedAgentTurn", () => {
     });
   });
 
-  it("delivers telegram topic targets with messageThreadId", async () => {
+  it("delivers telegram topic targets via provider send", async () => {
     await withTempHome(async (home) => {
       const storePath = await writeSessionStore(home);
       const deps: CliDeps = {
@@ -538,14 +538,14 @@ describe("runCronIsolatedAgentTurn", () => {
 
       expect(res.status).toBe("ok");
       expect(deps.sendMessageTelegram).toHaveBeenCalledWith(
-        "-1001234567890",
+        "telegram:group:-1001234567890:topic:321",
         "hello from cron",
-        expect.objectContaining({ messageThreadId: 321 }),
+        expect.objectContaining({ verbose: false }),
       );
     });
   });
 
-  it("delivers telegram shorthand topic suffixes with messageThreadId", async () => {
+  it("delivers telegram shorthand topic suffixes via provider send", async () => {
     await withTempHome(async (home) => {
       const storePath = await writeSessionStore(home);
       const deps: CliDeps = {
@@ -583,9 +583,9 @@ describe("runCronIsolatedAgentTurn", () => {
 
       expect(res.status).toBe("ok");
       expect(deps.sendMessageTelegram).toHaveBeenCalledWith(
-        "-1001234567890",
+        "-1001234567890:321",
         "hello from cron",
-        expect.objectContaining({ messageThreadId: 321 }),
+        expect.objectContaining({ verbose: false }),
       );
     });
   });
@@ -630,7 +630,7 @@ describe("runCronIsolatedAgentTurn", () => {
       expect(deps.sendMessageDiscord).toHaveBeenCalledWith(
         "channel:1122",
         "hello from cron",
-        expect.objectContaining({ token: process.env.DISCORD_BOT_TOKEN }),
+        expect.objectContaining({ verbose: false }),
       );
     });
   });

src/cron/isolated-agent.ts

@@ -25,11 +25,6 @@ import {
   DEFAULT_AGENT_WORKSPACE_DIR,
   ensureAgentWorkspace,
 } from "../agents/workspace.js";
-import {
-  chunkMarkdownText,
-  chunkText,
-  resolveTextChunkLimit,
-} from "../auto-reply/chunk.js";
 import {
   DEFAULT_HEARTBEAT_ACK_MAX_CHARS,
   stripHeartbeatToken,
@@ -48,13 +43,20 @@ import {
   saveSessionStore,
 } from "../config/sessions.js";
 import { registerAgentRunContext } from "../infra/agent-events.js";
-import { parseTelegramTarget } from "../telegram/targets.js";
-import { resolveTelegramToken } from "../telegram/token.js";
-import { normalizeE164, truncateUtf16Safe } from "../utils.js";
+import { deliverOutboundPayloads } from "../infra/outbound/deliver.js";
+import { resolveMessageProviderSelection } from "../infra/outbound/provider-selection.js";
 import {
-  isWhatsAppGroupJid,
-  normalizeWhatsAppTarget,
-} from "../whatsapp/normalize.js";
+  type OutboundProvider,
+  resolveOutboundTarget,
+} from "../infra/outbound/targets.js";
+import { normalizeProviderId } from "../providers/plugins/index.js";
+import type { ProviderId } from "../providers/plugins/types.js";
+import { DEFAULT_CHAT_PROVIDER } from "../providers/registry.js";
+import {
+  INTERNAL_MESSAGE_PROVIDER,
+  normalizeMessageProvider,
+} from "../utils/message-provider.js";
+import { truncateUtf16Safe } from "../utils.js";
 import type { CronJob } from "./types.js";
 
 export type RunCronAgentTurnResult = {
@@ -109,69 +111,23 @@ function isHeartbeatOnlyResponse(
   });
 }
 
-function getMediaList(payload: DeliveryPayload) {
-  return payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
-}
-
-async function deliverPayloadsWithMedia(params: {
-  payloads: DeliveryPayload[];
-  sendText: (text: string) => Promise<unknown>;
-  sendMedia: (caption: string, mediaUrl: string) => Promise<unknown>;
-}) {
-  for (const payload of params.payloads) {
-    const mediaList = getMediaList(payload);
-    if (mediaList.length === 0) {
-      await params.sendText(payload.text ?? "");
-      continue;
-    }
-    let first = true;
-    for (const url of mediaList) {
-      const caption = first ? (payload.text ?? "") : "";
-      first = false;
-      await params.sendMedia(caption, url);
-    }
-  }
-}
-
-async function deliverChunkedPayloads(params: {
-  payloads: DeliveryPayload[];
-  chunkText: (text: string) => string[];
-  sendText: (text: string) => Promise<unknown>;
-  sendMedia: (caption: string, mediaUrl: string) => Promise<unknown>;
-}) {
-  for (const payload of params.payloads) {
-    const mediaList = getMediaList(payload);
-    if (mediaList.length === 0) {
-      for (const chunk of params.chunkText(payload.text ?? "")) {
-        await params.sendText(chunk);
-      }
-      continue;
-    }
-    let first = true;
-    for (const url of mediaList) {
-      const caption = first ? (payload.text ?? "") : "";
-      first = false;
-      await params.sendMedia(caption, url);
-    }
-  }
-}
-function resolveDeliveryTarget(
+async function resolveDeliveryTarget(
   cfg: ClawdbotConfig,
   jobPayload: {
-    provider?:
-      | "last"
-      | "whatsapp"
-      | "telegram"
-      | "discord"
-      | "slack"
-      | "signal"
-      | "imessage"
-      | "msteams";
+    provider?: "last" | ProviderId;
     to?: string;
   },
-) {
-  const requestedProvider =
+): Promise<{
+  provider: string;
+  to?: string;
+  accountId?: string;
+  mode: "explicit" | "implicit";
+  error?: Error;
+}> {
+  const requestedRaw =
     typeof jobPayload.provider === "string" ? jobPayload.provider : "last";
+  const requestedProvider =
+    normalizeMessageProvider(requestedRaw) ?? requestedRaw;
   const explicitTo =
     typeof jobPayload.to === "string" && jobPayload.to.trim()
       ? jobPayload.to.trim()
@@ -184,60 +140,46 @@ function resolveDeliveryTarget(
   const store = loadSessionStore(storePath);
   const main = store[mainSessionKey];
   const lastProvider =
-    main?.lastProvider && main.lastProvider !== "webchat"
-      ? main.lastProvider
+    main?.lastProvider && main.lastProvider !== INTERNAL_MESSAGE_PROVIDER
+      ? (normalizeProviderId(main.lastProvider) ?? main.lastProvider)
       : undefined;
   const lastTo = typeof main?.lastTo === "string" ? main.lastTo.trim() : "";
+  const lastAccountId = main?.lastAccountId;
 
-  const provider = (() => {
-    if (
-      requestedProvider === "whatsapp" ||
-      requestedProvider === "telegram" ||
-      requestedProvider === "discord" ||
-      requestedProvider === "slack" ||
-      requestedProvider === "signal" ||
-      requestedProvider === "imessage"
-    ) {
-      return requestedProvider;
+  let provider =
+    requestedProvider === "last"
+      ? lastProvider
+      : requestedProvider === INTERNAL_MESSAGE_PROVIDER
+        ? undefined
+        : normalizeProviderId(requestedProvider);
+  if (!provider) {
+    try {
+      const selection = await resolveMessageProviderSelection({ cfg });
+      provider = selection.provider;
+    } catch {
+      provider = lastProvider ?? DEFAULT_CHAT_PROVIDER;
     }
-    return lastProvider ?? "whatsapp";
-  })();
+  }
 
-  const rawTo = explicitTo ?? (lastTo || undefined);
-  const telegramTarget =
-    provider === "telegram" && rawTo ? parseTelegramTarget(rawTo) : undefined;
-
-  const sanitizedWhatsappTo = (() => {
-    if (provider !== "whatsapp") return rawTo;
-    if (rawTo && isWhatsAppGroupJid(rawTo)) {
-      return normalizeWhatsAppTarget(rawTo) ?? rawTo;
-    }
-    const rawAllow = cfg.whatsapp?.allowFrom ?? [];
-    if (rawAllow.includes("*")) {
-      return rawTo ? (normalizeWhatsAppTarget(rawTo) ?? rawTo) : rawTo;
-    }
-    const allowFrom = rawAllow
-      .map((val) => normalizeE164(val))
-      .filter((val) => val.length > 1);
-    if (allowFrom.length === 0) {
-      return rawTo ? (normalizeWhatsAppTarget(rawTo) ?? rawTo) : rawTo;
-    }
-    if (!rawTo) return allowFrom[0];
-    const normalized = normalizeWhatsAppTarget(rawTo);
-    if (normalized && allowFrom.includes(normalized)) return normalized;
-    return allowFrom[0];
-  })();
-
-  const to = (() => {
-    if (provider === "telegram" && telegramTarget) return telegramTarget.chatId;
-    if (provider === "whatsapp") return sanitizedWhatsappTo;
-    return rawTo;
-  })();
+  const toCandidate = explicitTo ?? (lastTo || undefined);
+  const mode: "explicit" | "implicit" = explicitTo ? "explicit" : "implicit";
+  if (!toCandidate) {
+    return { provider, to: undefined, accountId: lastAccountId, mode };
+  }
 
+  const resolved = resolveOutboundTarget({
+    provider: provider as Exclude<OutboundProvider, "none">,
+    to: toCandidate,
+    cfg,
+    accountId: provider === lastProvider ? lastAccountId : undefined,
+    mode,
+  });
   return {
     provider,
-    to,
-    messageThreadId: telegramTarget?.messageThreadId,
+    to: resolved.ok ? resolved.to : undefined,
+    accountId: provider === lastProvider ? lastAccountId : undefined,
+    mode,
+    error: resolved.ok ? undefined : resolved.error,
   };
 }
 
@@ -389,7 +331,7 @@ export async function runCronIsolatedAgentTurn(params: {
     params.job.payload.kind === "agentTurn" &&
     params.job.payload.bestEffortDeliver === true;
 
-  const resolvedDelivery = resolveDeliveryTarget(params.cfg, {
+  const resolvedDelivery = await resolveDeliveryTarget(params.cfg, {
     provider:
       params.job.payload.kind === "agentTurn"
         ? params.job.payload.provider
@@ -399,7 +341,6 @@ export async function runCronIsolatedAgentTurn(params: {
         ? params.job.payload.to
         : undefined,
   });
-  const { token: telegramToken } = resolveTelegramToken(params.cfg);
 
   const base =
     `[cron:${params.job.id} ${params.job.name}] ${params.message}`.trim();
@@ -546,194 +487,56 @@ export async function runCronIsolatedAgentTurn(params: {
     delivery && isHeartbeatOnlyResponse(payloads, Math.max(0, ackMaxChars));
 
   if (delivery && !skipHeartbeatDelivery) {
-    if (resolvedDelivery.provider === "whatsapp") {
-      if (!resolvedDelivery.to) {
-        if (!bestEffortDeliver)
-          return {
-            status: "error",
-            summary,
-            error: "Cron delivery to WhatsApp requires a recipient.",
-          };
+    if (!resolvedDelivery.to) {
+      const reason =
+        resolvedDelivery.error?.message ??
+        "Cron delivery requires a recipient (--to).";
+      if (!bestEffortDeliver) {
         return {
-          status: "skipped",
-          summary: "Delivery skipped (no WhatsApp recipient).",
+          status: "error",
+          summary,
+          error: reason,
         };
       }
-      const rawTo = resolvedDelivery.to;
-      const to = normalizeWhatsAppTarget(rawTo) ?? rawTo;
-      try {
-        await deliverPayloadsWithMedia({
-          payloads,
-          sendText: (text) =>
-            params.deps.sendMessageWhatsApp(to, text, { verbose: false }),
-          sendMedia: (caption, mediaUrl) =>
-            params.deps.sendMessageWhatsApp(to, caption, {
-              verbose: false,
-              mediaUrl,
-            }),
-        });
-      } catch (err) {
-        if (!bestEffortDeliver)
-          return { status: "error", summary, error: String(err) };
-        return { status: "ok", summary };
-      }
-    } else if (resolvedDelivery.provider === "telegram") {
-      if (!resolvedDelivery.to) {
-        if (!bestEffortDeliver)
-          return {
-            status: "error",
-            summary,
-            error: "Cron delivery to Telegram requires a chatId.",
-          };
-        return {
-          status: "skipped",
-          summary: "Delivery skipped (no Telegram chatId).",
-        };
-      }
-      const chatId = resolvedDelivery.to;
-      const messageThreadId = resolvedDelivery.messageThreadId;
-      const textLimit = resolveTextChunkLimit(params.cfg, "telegram");
-      try {
-        await deliverChunkedPayloads({
-          payloads,
-          chunkText: (text) => chunkMarkdownText(text, textLimit),
-          sendText: (text) =>
-            params.deps.sendMessageTelegram(chatId, text, {
-              verbose: false,
-              token: telegramToken || undefined,
-              messageThreadId,
-            }),
-          sendMedia: (caption, mediaUrl) =>
-            params.deps.sendMessageTelegram(chatId, caption, {
-              verbose: false,
-              mediaUrl,
-              token: telegramToken || undefined,
-              messageThreadId,
-            }),
-        });
-      } catch (err) {
-        if (!bestEffortDeliver)
-          return { status: "error", summary, error: String(err) };
-        return { status: "ok", summary };
-      }
-    } else if (resolvedDelivery.provider === "discord") {
-      if (!resolvedDelivery.to) {
-        if (!bestEffortDeliver)
-          return {
-            status: "error",
-            summary,
-            error:
-              "Cron delivery to Discord requires --provider discord and --to <channelId|user:ID>",
-          };
-        return {
-          status: "skipped",
-          summary: "Delivery skipped (no Discord destination).",
-        };
-      }
-      const discordTarget = resolvedDelivery.to;
-      try {
-        await deliverPayloadsWithMedia({
-          payloads,
-          sendText: (text) =>
-            params.deps.sendMessageDiscord(discordTarget, text, {
-              token: process.env.DISCORD_BOT_TOKEN,
-            }),
-          sendMedia: (caption, mediaUrl) =>
-            params.deps.sendMessageDiscord(discordTarget, caption, {
-              token: process.env.DISCORD_BOT_TOKEN,
-              mediaUrl,
-            }),
-        });
-      } catch (err) {
-        if (!bestEffortDeliver)
-          return { status: "error", summary, error: String(err) };
-        return { status: "ok", summary };
-      }
-    } else if (resolvedDelivery.provider === "slack") {
-      if (!resolvedDelivery.to) {
-        if (!bestEffortDeliver)
-          return {
-            status: "error",
-            summary,
-            error:
-              "Cron delivery to Slack requires --provider slack and --to <channelId|user:ID>",
-          };
-        return {
-          status: "skipped",
-          summary: "Delivery skipped (no Slack destination).",
-        };
-      }
-      const slackTarget = resolvedDelivery.to;
-      const textLimit = resolveTextChunkLimit(params.cfg, "slack");
-      try {
-        await deliverChunkedPayloads({
-          payloads,
-          chunkText: (text) => chunkMarkdownText(text, textLimit),
-          sendText: (text) => params.deps.sendMessageSlack(slackTarget, text),
-          sendMedia: (caption, mediaUrl) =>
-            params.deps.sendMessageSlack(slackTarget, caption, { mediaUrl }),
-        });
-      } catch (err) {
-        if (!bestEffortDeliver)
-          return { status: "error", summary, error: String(err) };
-        return { status: "ok", summary };
-      }
-    } else if (resolvedDelivery.provider === "signal") {
-      if (!resolvedDelivery.to) {
-        if (!bestEffortDeliver)
-          return {
-            status: "error",
-            summary,
-            error: "Cron delivery to Signal requires a recipient.",
-          };
-        return {
-          status: "skipped",
-          summary: "Delivery skipped (no Signal recipient).",
-        };
-      }
-      const to = resolvedDelivery.to;
-      const textLimit = resolveTextChunkLimit(params.cfg, "signal");
-      try {
-        await deliverChunkedPayloads({
-          payloads,
-          chunkText: (text) => chunkText(text, textLimit),
-          sendText: (text) => params.deps.sendMessageSignal(to, text),
-          sendMedia: (caption, mediaUrl) =>
-            params.deps.sendMessageSignal(to, caption, { mediaUrl }),
-        });
-      } catch (err) {
-        if (!bestEffortDeliver)
-          return { status: "error", summary, error: String(err) };
-        return { status: "ok", summary };
-      }
-    } else if (resolvedDelivery.provider === "imessage") {
-      if (!resolvedDelivery.to) {
-        if (!bestEffortDeliver)
-          return {
-            status: "error",
-            summary,
-            error: "Cron delivery to iMessage requires a recipient.",
-          };
-        return {
-          status: "skipped",
-          summary: "Delivery skipped (no iMessage recipient).",
-        };
-      }
-      const to = resolvedDelivery.to;
-      const textLimit = resolveTextChunkLimit(params.cfg, "imessage");
-      try {
-        await deliverChunkedPayloads({
-          payloads,
-          chunkText: (text) => chunkText(text, textLimit),
-          sendText: (text) => params.deps.sendMessageIMessage(to, text),
-          sendMedia: (caption, mediaUrl) =>
-            params.deps.sendMessageIMessage(to, caption, { mediaUrl }),
-        });
-      } catch (err) {
-        if (!bestEffortDeliver)
-          return { status: "error", summary, error: String(err) };
-        return { status: "ok", summary };
+      return {
+        status: "skipped",
+        summary: `Delivery skipped (${reason}).`,
+      };
+    }
+    try {
+      await deliverOutboundPayloads({
+        cfg: params.cfg,
+        provider: resolvedDelivery.provider as Exclude<
+          OutboundProvider,
+          "none"
+        >,
+        to: resolvedDelivery.to,
+        accountId: resolvedDelivery.accountId,
+        payloads,
+        bestEffort: bestEffortDeliver,
+        deps: {
+          sendWhatsApp: params.deps.sendMessageWhatsApp,
+          sendTelegram: params.deps.sendMessageTelegram,
+          sendDiscord: params.deps.sendMessageDiscord,
+          sendSlack: params.deps.sendMessageSlack,
+          sendSignal: params.deps.sendMessageSignal,
+          sendIMessage: params.deps.sendMessageIMessage,
+          sendMSTeams: params.deps.sendMessageMSTeams
+            ? async (to, text, opts) =>
+                await params.deps.sendMessageMSTeams({
+                  cfg: params.cfg,
+                  to,
+                  text,
+                  mediaUrl: opts?.mediaUrl,
+                })
+            : undefined,
+        },
+      });
+    } catch (err) {
+      if (!bestEffortDeliver) {
+        return { status: "error", summary, error: String(err) };
       }
+      return { status: "ok", summary };
     }
   }
 

src/cron/types.ts

@@ -1,3 +1,5 @@
+import type { ProviderId } from "../providers/plugins/types.js";
+
 export type CronSchedule =
   | { kind: "at"; atMs: number }
   | { kind: "every"; everyMs: number; anchorMs?: number }
@@ -6,6 +8,8 @@ export type CronSchedule =
 export type CronSessionTarget = "main" | "isolated";
 export type CronWakeMode = "next-heartbeat" | "now";
 
+export type CronMessageProvider = ProviderId | "last";
+
 export type CronPayload =
   | { kind: "systemEvent"; text: string }
   | {
@@ -16,15 +20,7 @@ export type CronPayload =
       thinking?: string;
       timeoutSeconds?: number;
       deliver?: boolean;
-      provider?:
-        | "last"
-        | "whatsapp"
-        | "telegram"
-        | "discord"
-        | "slack"
-        | "signal"
-        | "imessage"
-        | "msteams";
+      provider?: CronMessageProvider;
       to?: string;
       bestEffortDeliver?: boolean;
     };