@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/providers/reasoning-effort.ts

@@ -2,21 +2,28 @@
  * Normalized per-agent reasoning/effort control, shared across the four
  * local harnesses (`claude`, `codex`, `pi`, `opencode`).
  *
- * Pure module — no DB import, no network I/O at runtime. Capability data is
- * read from the slim, checked-in `modelsdev-reasoning.json` snapshot (derived
- * from the canonical `src/be/modelsdev-cache.json` by
- * `scripts/refresh-modelsdev-pricing.ts`), layered with a small
- * harness-specific override table for quirks the cache can't encode. See
+ * Pure module — no DB import, no network I/O of its own. Capability data is
+ * read from the model catalog (`src/utils/runtime-model-catalog.ts`: live
+ * `model_catalog` + overlay rows, vendored models.dev snapshot offline),
+ * layered with a small harness-specific override table for quirks the
+ * catalog can't encode. A new model's reasoning levels arrive with its
+ * catalog row (model-catalog phase 4). See
  * `thoughts/taras/plans/2026-07-01-agent-reasoning-effort-runtime-control.md`
  * (Phase 1) and `thoughts/taras/research/2026-05-26-agent-reasoning-effort-runtime-control.md`
  * for the design rationale.
  */
 
-import reasoningSnapshotJson from "./modelsdev-reasoning.json";
+import {
+  claudeCatalogModelId,
+  REASONING_EFFORT_LEVELS,
+  type ReasoningEffortLevel,
+  reasoningLevelsFor,
+} from "@desplega/model-catalog";
+import { runtimeCatalogModel, runtimeCatalogSection } from "../utils/runtime-model-catalog";
 
 /** Closed, normalized enum. `minimal` remains out of scope; GPT-5.6 Codex adds `max`. */
-export const REASONING_EFFORT_LEVELS = ["off", "low", "medium", "high", "xhigh", "max"] as const;
-export type ReasoningEffort = (typeof REASONING_EFFORT_LEVELS)[number];
+export { REASONING_EFFORT_LEVELS };
+export type ReasoningEffort = ReasoningEffortLevel;
 
 /** The four local harnesses this feature covers (Devin / claude-managed are out of scope). */
 export type ReasoningHarness = "claude" | "codex" | "pi" | "opencode";
@@ -45,44 +52,7 @@ export type ReasoningEffortApplication =
     }
   | { kind: "noop" };
 
-// --- Slim capability snapshot ------------------------------------------------
-
-interface SlimReasoningOption {
-  type: string;
-  values?: string[];
-}
-
-interface SlimModelEntry {
-  id: string;
-  reasoning: boolean;
-  reasoningOptions?: SlimReasoningOption[];
-}
-
-/**
- * Providers the snapshot covers — mirrors `SNAPSHOT_ORDER` +
- * `BEDROCK_SNAPSHOT_ID` in `apps/ui/src/lib/agent-runtime-models.ts`. Direct
- * `claude`/`codex` model strings (no provider prefix) resolve against
- * `anthropic`/`openai` respectively; `pi`/`opencode` model strings are always
- * `<providerId>/<model-id>` (see `splitProviderModel`).
- */
-type SnapshotProviderId = "anthropic" | "openai" | "openrouter" | "amazon-bedrock";
-
-type ReasoningSnapshot = Partial<Record<SnapshotProviderId, Record<string, SlimModelEntry>>>;
-
-const SNAPSHOT = reasoningSnapshotJson as ReasoningSnapshot;
-
-/** Shared-safe subset accepted by all four harnesses on at least their default models (see research doc). */
-const FALLBACK_LEVELS: ReasoningEffort[] = ["low", "medium", "high"];
-
-/** models.dev `reasoning_options[].type === "effort"` value → our normalized enum. `minimal` intentionally dropped. */
-const EFFORT_VALUE_MAP: Partial<Record<string, ReasoningEffort>> = {
-  none: "off",
-  low: "low",
-  medium: "medium",
-  high: "high",
-  xhigh: "xhigh",
-  max: "max",
-};
+// --- Capability lookup --------------------------------------------------------
 
 function splitProviderModel(model: string): { providerId: string; modelId: string } {
   const slash = model.indexOf("/");
@@ -90,81 +60,33 @@ function splitProviderModel(model: string): { providerId: string; modelId: strin
   return { providerId: model.slice(0, slash), modelId: model.slice(slash + 1) };
 }
 
-function lookupModelEntry(harness: ReasoningHarness, model: string): SlimModelEntry | undefined {
-  if (!model) return undefined;
-  if (harness === "claude") return SNAPSHOT.anthropic?.[model];
-  if (harness === "codex") return SNAPSHOT.openai?.[model];
-  // pi / opencode model strings are always "<provider>/<model-id...>" — the
-  // model id itself may contain further slashes (e.g. openrouter's
-  // "google/gemini-3-flash-preview"), so split on the FIRST slash only.
-  const { providerId, modelId } = splitProviderModel(model);
-  if (!providerId) return undefined;
-  return SNAPSHOT[providerId as SnapshotProviderId]?.[modelId];
-}
-
-function levelsFromReasoningOptions(options: SlimReasoningOption[] | undefined): ReasoningEffort[] {
-  const effortEntry = options?.find((o) => o.type === "effort");
-  if (!effortEntry?.values?.length) return [];
-  const mapped = new Set(
-    effortEntry.values
-      .map((v) => EFFORT_VALUE_MAP[v])
-      .filter((v): v is ReasoningEffort => v !== undefined),
-  );
-  // Preserve canonical ordering rather than whatever order models.dev lists them in.
-  return REASONING_EFFORT_LEVELS.filter((level) => mapped.has(level));
-}
-
-function hasBudgetTokensOption(entry: SlimModelEntry): boolean {
-  return Boolean(entry.reasoningOptions?.some((o) => o.type === "budget_tokens"));
-}
-
 /**
- * Harness-specific quirks the cache doesn't (fully) encode. Kept small — this
- * patches gaps, it does not duplicate the cache. Applied on top of whichever
- * levels resolution step 2/3 already produced.
+ * The (catalog id, catalog facts) a harness's model string names. Direct
+ * `claude`/`codex` strings (no provider prefix) resolve against
+ * `anthropic`/`openai`; a Claude CLI shortname (`opus`, the tier default)
+ * resolves to the newest model of its family. `pi`/`opencode` strings are
+ * always `<providerId>/<model-id>`, and the id may hold more slashes (openrouter's
+ * `google/gemini-3-flash-preview`), so split on the FIRST slash only.
  */
-function applyHarnessOverrides(
+function lookupModel(
   harness: ReasoningHarness,
   model: string,
-  entry: SlimModelEntry,
-  levels: ReasoningEffort[],
-): ReasoningEffort[] {
-  let result = levels;
-
+): { id: string; facts: ReturnType<typeof runtimeCatalogModel> } | undefined {
+  if (!model) return undefined;
+  let providerId: string;
+  let modelId: string;
   if (harness === "claude") {
-    // Claude's native vocabulary has no "off" (see research doc) — we
-    // implement it as a synthetic level via `MAX_THINKING_TOKENS=0`, which
-    // only exists on legacy (non-adaptive-only) models that still expose a
-    // numeric thinking-budget knob (`reasoning_options` carries a
-    // `budget_tokens` entry). Opus 4.7+ models are adaptive-only — effort
-    // only, no `budget_tokens` — so `off` is naturally never added for them,
-    // rather than hardcoding "Opus 4.7" by name.
-    if (hasBudgetTokensOption(entry) && !result.includes("off")) {
-      result = ["off", ...result];
-    }
-  }
-
-  if (harness !== "codex") {
-    result = result.filter((l) => l !== "max");
-  }
-
-  if (harness === "codex") {
-    // The cache already tends to encode this correctly per model (verified:
-    // `gpt-5.1-codex` excludes xhigh, `gpt-5.1-codex-max` includes it). This
-    // rule is defense-in-depth for models missing from the snapshot (the
-    // {low,medium,high} fallback path), where naming alone should still
-    // decide xhigh eligibility for `*-codex` family models.
-    const isCodexMax = /-codex-max$/.test(model);
-    const isCodexNonMax = /-codex$/.test(model) && !isCodexMax;
-    if (isCodexMax && !result.includes("xhigh")) {
-      result = [...result, "xhigh"];
-    }
-    if (isCodexNonMax) {
-      result = result.filter((l) => l !== "xhigh");
-    }
+    providerId = "anthropic";
+    modelId = claudeCatalogModelId(model, runtimeCatalogSection("anthropic"));
+  } else if (harness === "codex") {
+    providerId = "openai";
+    modelId = model;
+  } else {
+    ({ providerId, modelId } = splitProviderModel(model));
+    if (!providerId) return undefined;
   }
-
-  return REASONING_EFFORT_LEVELS.filter((level) => result.includes(level));
+  const facts = runtimeCatalogModel(providerId, modelId);
+  return facts ? { id: modelId, facts } : undefined;
 }
 
 function pickDefault(levels: ReasoningEffort[]): ReasoningEffort | null {
@@ -173,33 +95,15 @@ function pickDefault(levels: ReasoningEffort[]): ReasoningEffort | null {
 }
 
 /**
- * Resolution order:
- *  1. No capability data for (harness, model) at all (custom model strings,
- *     models absent from the snapshot) → unsupported.
- *  2. `reasoning: false` → unsupported, regardless of the override table.
- *  3. `reasoning_options` has a usable `type: "effort"` entry → levels come
- *     from its `values` (mapped/filtered — `none`→`off`, `minimal` dropped).
- *  4. Otherwise (`reasoning: true`, no usable effort entry) → the shared-safe
- *     fallback subset `{low, medium, high}`.
- *  5. Harness-specific override table applied on top for known quirks.
+ * The levels `(harness, model)` accepts, from the catalog facts
+ * (`reasoningLevelsFor`, shared with the swarm app's effort pickers). Unknown
+ * models (custom strings, ids the catalog lacks) and non-reasoning models are
+ * unsupported.
  */
 export function reasoningCapability(harness: ReasoningHarness, model: string): ReasoningCapability {
-  const entry = lookupModelEntry(harness, model);
-  if (!entry || !entry.reasoning) {
-    return { supported: false, levels: [], default: null };
-  }
-
-  let levels = levelsFromReasoningOptions(entry.reasoningOptions);
-  if (levels.length === 0) {
-    levels = [...FALLBACK_LEVELS];
-  }
-
-  levels = applyHarnessOverrides(harness, model, entry, levels);
-
-  if (levels.length === 0) {
-    return { supported: false, levels: [], default: null };
-  }
-
+  const entry = lookupModel(harness, model);
+  const levels = entry ? reasoningLevelsFor(harness, entry.id, entry.facts) : [];
+  if (levels.length === 0) return { supported: false, levels: [], default: null };
   return { supported: true, levels, default: pickDefault(levels) };
 }
 

package/src/providers/types.ts

@@ -203,6 +203,12 @@ export interface ProviderResult {
    * rejection event arrived; it orders the report against other workers'.
    */
   modelRateLimit?: { window: string; model: ModelFamily; resetAt: string; observedAt?: string };
+  /**
+   * Set when the Claude CLI sent a rejected `rate_limit_event` with
+   * `errorCode: "credits_required"`: the key's seat cannot run the model. Not
+   * a rate limit, so `rateLimitResetAt` is never set from that event.
+   */
+  creditsRequired?: { observedAt: string; overageDisabledReason?: string };
   /**
    * Reasoning/effort level the adapter actually applied (Phase 4). `null`
    * means `applyReasoningEffort()` returned `noop` (capability rejected the
@@ -216,6 +222,8 @@ export interface ProviderResult {
 export interface ProviderTraits {
   /** Provider can call MCP tools (store-progress, task-action, skills, slack-reply, etc.) */
   hasMcp: boolean;
+  /** Provider hides MCP tools behind a native tool search. Defaults to false. */
+  hasToolSearch?: boolean;
   /**
    * Provider discovers installed skills on its own — it reads the local skills
    * tree and ambient-injects each skill's name + description into the session

package/src/rbac/legacy-policy.ts

@@ -56,6 +56,27 @@ const leadOrOperatorOrUser: LegacyRule = {
     principal.kind === "operator" || principal.kind === "user" || actsAsLead(principal),
 };
 
+/**
+ * Lead agents and the operator (shared API key with no agent identity). Plain dashboard users are
+ * left out: nothing in the UI writes through a verb with this rule yet.
+ */
+const leadOrOperator: LegacyRule = {
+  name: "lead-or-operator",
+  denyReason: "requires lead agent or operator authentication",
+  evaluate: (principal) => principal.kind === "operator" || actsAsLead(principal),
+};
+
+/**
+ * Registered agents and the operator. Dashboard users are left out: a support row is a worker's
+ * report about its own CLI (or an operator correction), and no UI writes one.
+ */
+const agentOrOperator: LegacyRule = {
+  name: "agent-or-operator",
+  denyReason: "requires a registered agent or operator authentication",
+  evaluate: (principal) =>
+    principal.kind === "operator" || (principal.kind === "agent" && principal.agentId !== ""),
+};
+
 const extensionWrite: LegacyRule = {
   name: "extension-owner-or-elevated",
   denyReason: "requires extension owner, lead agent, operator, or user authentication",
@@ -195,10 +216,29 @@ const taskFsMutate: LegacyRule = {
   },
 };
 
+/**
+ * task.progress.write — operator OR user OR lead OR task-assignee OR unassigned
+ * task (store-progress, POST /api/tasks/{id}/progress). A worker once completed
+ * a workflow sibling's task with its own report; the creator gets no write
+ * here, unlike task.fs.mutate. Leads may write, unlike HTTP finish.
+ */
+const taskProgressWrite: LegacyRule = {
+  name: "operator-or-user-or-lead-or-task-assignee",
+  denyReason: "requires operator, user, lead agent, or task assignee",
+  evaluate: (principal, resource) => {
+    if (principal.kind === "operator" || principal.kind === "user") return true;
+    if (actsAsLead(principal)) return true;
+    if (resource?.kind !== "task") return false;
+    return resource.agentId == null || resource.agentId === principal.agentId;
+  },
+};
+
 /** All named (non-composite) rule kinds, keyed by identifier. */
 export const LEGACY_RULES = {
   "operator-or-user": operatorOrUser,
   "lead-or-operator-or-user": leadOrOperatorOrUser,
+  "lead-or-operator": leadOrOperator,
+  "agent-or-operator": agentOrOperator,
   "lead-only": leadOnly,
   "lead-or-task-creator": leadOrTaskCreator,
   "lead-or-resource-owner": leadOrResourceOwner,
@@ -223,6 +263,7 @@ export const LEGACY_POLICY = {
   "task.steer.own": requesterOwnsTask,
   "task.action.own": requesterOwnsTask,
   "task.fs.mutate": taskFsMutate,
+  "task.progress.write": taskProgressWrite,
   "favorite.write.own": anyAuthenticated,
   "memory.learning.inject": leadOnly,
   "memory.edit.any": leadOrResourceOwner,
@@ -246,6 +287,8 @@ export const LEGACY_POLICY = {
   "config.write.any": leadOnly,
   "config.delete.any": leadOnly,
   "config.read.secrets": leadOnly,
+  "models.catalog.write": leadOrOperator,
+  "models.harness-support.write": agentOrOperator,
   "skill.create.swarm": leadOnly,
   "skill.install.any": leadOnly,
   "skill.install.global": leadOnly,

package/src/rbac/permissions.ts

@@ -65,6 +65,11 @@ export const PERMISSIONS = {
     description: "Mutate a task's filesystem artifacts and attachments.",
     namespace: "task",
   },
+  "task.progress.write": {
+    description:
+      "Write a task's progress, status, or output (its assignee, a lead, a human, or anyone while unassigned).",
+    namespace: "task",
+  },
   "favorite.write.own": {
     description: "Set a favorite the caller owns.",
     namespace: "favorite",
@@ -153,6 +158,16 @@ export const PERMISSIONS = {
     description: "Delete any swarm-config entry.",
     namespace: "config",
   },
+  "models.catalog.write": {
+    description:
+      "Force a model-catalog refresh from models.dev or write/delete model-catalog overlay rows.",
+    namespace: "models",
+  },
+  "models.harness-support.write": {
+    description:
+      "Record whether a pinned harness CLI version accepts a model (a worker reports its own probe results; the operator may correct any row).",
+    namespace: "models",
+  },
   "config.read.secrets": {
     description: "Read unmasked secret config values.",
     namespace: "config",

package/src/scripts-runtime/sdk-allowlist.ts

@@ -80,6 +80,10 @@ export const SDK_TOOL_NAME_MAP = {
   config_set: "set-config",
   config_delete: "delete-config", // destructive
 
+  // ── model catalog ──
+  modelCatalog_refresh: "model-catalog-refresh", // external: fetches models.dev
+  modelCatalog_overlayUpsert: "model-catalog-overlay-upsert",
+
   // ── slack ──
   slack_read: "slack-read",
   slack_listChannels: "slack-list-channels",

package/src/scripts-runtime/types/stdlib.d.ts

@@ -433,6 +433,21 @@ declare module "swarm-sdk" {
     }): Promise<unknown>;
     config_delete(args: { id: string }): Promise<unknown>;
 
+    // --- write: model catalog ---
+    modelCatalog_refresh(args?: { force?: boolean }): Promise<unknown>;
+    modelCatalog_overlayUpsert(args: {
+      provider: string;
+      modelId: string;
+      name?: string;
+      releaseDate?: string;
+      contextWindow?: number;
+      maxOutput?: number;
+      reasoningOptions?: Array<{ type: string; values?: string[] }>;
+      pricing?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
+      reason: string;
+      verifiedBy?: string;
+    }): Promise<unknown>;
+
     // --- write: slack ---
     slack_post(args: { channelId: string; message: string; blocks?: unknown }): Promise<unknown>;
     slack_reply(args: {

package/src/scripts-runtime/types/swarm-extension.d.ts

@@ -180,6 +180,9 @@ declare module "swarm-extension" {
     model?: string | undefined;
     modelTier?: "smol" | "regular" | "smart" | "ultra" | undefined;
     effort?: "off" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    resolvedModel?: string | undefined;
+    modelSource?: string | undefined;
+    modelAlias?: string | undefined;
     scheduleId?: string | undefined;
     workflowRunId?: string | null | undefined;
     workflowRunStepId?: string | null | undefined;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -415,6 +415,21 @@ declare module "swarm-sdk" {
     }): Promise<unknown>;
     config_delete(args: { id: string }): Promise<unknown>;
 
+    // --- write: model catalog ---
+    modelCatalog_refresh(args?: { force?: boolean }): Promise<unknown>;
+    modelCatalog_overlayUpsert(args: {
+      provider: string;
+      modelId: string;
+      name?: string;
+      releaseDate?: string;
+      contextWindow?: number;
+      maxOutput?: number;
+      reasoningOptions?: Array<{ type: string; values?: string[] }>;
+      pricing?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
+      reason: string;
+      verifiedBy?: string;
+    }): Promise<unknown>;
+
     // --- write: slack ---
     slack_post(args: { channelId: string; message: string; blocks?: unknown }): Promise<unknown>;
     slack_reply(args: {

package/src/server.ts

@@ -73,6 +73,10 @@ import { registerMemoryGetTool } from "./tools/memory-get";
 import { registerMemoryRateTool } from "./tools/memory-rate";
 import { registerMemorySearchTool } from "./tools/memory-search";
 import { registerMemoryStoreTool } from "./tools/memory-store";
+import {
+  registerModelCatalogOverlayUpsertTool,
+  registerModelCatalogRefreshTool,
+} from "./tools/model-catalog";
 import { registerMyAgentInfoTool } from "./tools/my-agent-info";
 import { registerGetOauthAccessTokenTool } from "./tools/oauth-access-token";
 import { registerPollTaskTool } from "./tools/poll-task";
@@ -413,6 +417,8 @@ export async function createServer(
     registerListConfigTool(server);
     registerDeleteConfigTool(server);
     registerCredentialBindingsTool(server);
+    registerModelCatalogRefreshTool(server);
+    registerModelCatalogOverlayUpsertTool(server);
   }
 
   // Scripts capability - reusable script catalog (HTTP MCP only in v1)

package/src/slack/assistant.ts

@@ -14,6 +14,7 @@ import {
 } from "./inbound-files";
 import { ensureSlackThreadTree, isSlackRenderV2Enabled } from "./render-v2";
 import { hasOtherUserMention } from "./router";
+import { markSlackSessionProcessing } from "./session-status";
 import { bufferThreadMessage, getBufferMessageCount } from "./thread-buffer";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
@@ -65,7 +66,18 @@ export function createAssistant(): Assistant {
       // Wrap setStatus/setTitle to swallow all errors gracefully.
       // These calls can fail for various reasons (no_permission when the thread
       // wasn't started by the assistant, network errors, etc.), so we log and continue.
+      // With the v2 renderer Slack's native session status carries the "working"
+      // state for the whole ask (see session-status.ts), so the legacy free-text
+      // status below is only the fallback when the native call is unavailable.
+      let statusThread: { channelId: string; threadTs: string } | undefined;
       const safeSetStatus = async (status: string) => {
+        if (
+          statusThread &&
+          isSlackRenderV2Enabled() &&
+          (await markSlackSessionProcessing({ ...statusThread, client }))
+        ) {
+          return;
+        }
         try {
           await setStatus(status);
         } catch (error) {
@@ -85,6 +97,7 @@ export function createAssistant(): Assistant {
         const msg = message as unknown as Record<string, unknown>;
         const threadTs = (msg.thread_ts as string) || message.ts;
         const channelId = message.channel;
+        statusThread = { channelId, threadTs };
         const messageText = (msg.text as string) || "";
         // `file_share` messages land here too: an image sent with no caption
         // arrives with empty `text` and everything in `files`.

package/src/slack/message-text.ts

@@ -52,6 +52,34 @@ function collectRichTextParts(node: unknown, parts: string[]): void {
   }
 }
 
+/**
+ * Turn top-level mrkdwn `text` into the plain text a rich_text block flattens
+ * to: drop `<…>` tokens (user/channel mentions, links, `<!here>`), which
+ * collectRichTextParts does not emit, then decode Slack's HTML escapes.
+ */
+function decodeMrkdwn(text: string): string {
+  return text
+    .replace(/<[^<>]*>/g, "")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}
+
+/**
+ * Normalize text for the text-vs-rich_text equality check only (never for
+ * output): drop emoji shortcodes, quote and list markers, and mrkdwn style
+ * characters, which rich_text carries as element types or style flags rather
+ * than characters, then all whitespace, since flattening joins styled runs
+ * with newlines.
+ */
+function normalizeForDedupe(text: string): string {
+  return text
+    .replace(/:[a-z0-9_+'-]+:/gi, "")
+    .replace(/^[ \t]*(?:>|[•◦▪‣-]|\d+\.)[ \t]*/gm, "")
+    .replace(/[*_~`]/g, "")
+    .replace(/\s+/g, "");
+}
+
 /**
  * Return displayable text for a Slack message, combining ALL content layers.
  *
@@ -64,7 +92,8 @@ function collectRichTextParts(node: unknown, parts: string[]): void {
  *
  * Dedup: if `msg.text` is already contained verbatim in the combined
  * attachments+blocks body (fallback echoed in a block), it is omitted to avoid
- * printing it twice.
+ * printing it twice. A rich_text block whose content equals `msg.text` after
+ * normalization is omitted instead (see below).
  *
  * Block types extracted: section (text + fields), rich_text, header, context,
  * actions (button label + url as mrkdwn link).
@@ -123,6 +152,9 @@ export function extractSlackMessageText(msg: SlackMessageLike): string {
 
   // Block Kit blocks
   const blockParts: string[] = [];
+  // Index range of each rich_text block's parts inside blockParts, so a
+  // rich_text block that merely re-renders `msg.text` can be dropped below.
+  const richTextRanges: Array<[number, number]> = [];
   if (Array.isArray(msg.blocks) && msg.blocks.length > 0) {
     for (const rawBlock of msg.blocks) {
       if (rawBlock == null || typeof rawBlock !== "object") continue;
@@ -137,9 +169,11 @@ export function extractSlackMessageText(msg: SlackMessageLike): string {
           }
         }
       } else if (block.type === "rich_text" && Array.isArray(block.elements)) {
+        const start = blockParts.length;
         for (const el of block.elements) {
           collectRichTextParts(el, blockParts);
         }
+        if (blockParts.length > start) richTextRanges.push([start, blockParts.length]);
       } else if (block.type === "header") {
         if (block.text?.text) blockParts.push(block.text.text);
       } else if (block.type === "context" && Array.isArray(block.elements)) {
@@ -162,7 +196,27 @@ export function extractSlackMessageText(msg: SlackMessageLike): string {
     }
   }
 
-  const bodyText = [...attachmentParts, ...blockParts].filter(Boolean).join("\n");
+  // A human message carries the same content twice: `text` (mrkdwn) and a
+  // rich_text block. The block flattens to one part per styled run, so the
+  // per-line check below never matches a multi-line or formatted message and
+  // the whole message would render twice. When the rich_text content equals
+  // `text` after normalization, keep `text` (it also carries the mentions,
+  // links and emoji the rich_text flattening drops) and skip the blocks.
+  let bodyBlockParts = blockParts;
+  if (topText && richTextRanges.length > 0) {
+    const richText = richTextRanges
+      .map(([start, end]) => blockParts.slice(start, end).join("\n"))
+      .join("\n");
+    if (normalizeForDedupe(richText) === normalizeForDedupe(decodeMrkdwn(topText))) {
+      const dropped = new Set<number>();
+      for (const [start, end] of richTextRanges) {
+        for (let i = start; i < end; i++) dropped.add(i);
+      }
+      bodyBlockParts = blockParts.filter((_, i) => !dropped.has(i));
+    }
+  }
+
+  const bodyText = [...attachmentParts, ...bodyBlockParts].filter(Boolean).join("\n");
 
   // Include the top-level text unless it already appears as a complete line in the body.
   // Boundary-aware check: "hi".includes check would silently drop "hi" when the body