@@ -341,9 +341,10 @@ export const UserInput = forwardRef<UserInputHandle, UserInputProps>(function Us
 
   /**
    * Bulk-chipifies a block of text on the non-keystroke paths (mount, template,
-   * draft restore, STT, queued message, multi-char paste): integration `@`
-   * names first (rewrites the text), then skill `/` triggers (swapped to the
-   * sentinel). Returns the fully converted text and registers both context kinds.
+   * draft restore, STT, queued message, multi-char paste): explicit integration
+   * `@`-mentions first (casing canonicalized; bare names are never touched),
+   * then skill `/` triggers (swapped to the sentinel). Returns the fully
+   * converted text and registers both context kinds.
    */
   const applyAutoMentions = useCallback(
     (text: string) => skillAutoMention.applyToText(integrationAutoMention.applyToText(text)),
@@ -353,11 +354,11 @@ export const UserInput = forwardRef<UserInputHandle, UserInputProps>(function Us
   const canSubmit = (value.trim().length > 0 || hasFiles) && !isSending && !hasUploadingFiles
 
   /**
-   * Convert integration names on mount for any initial value seeded by
-   * `defaultValue` or a restored mothership draft. Mid-typing conversion
-   * is intentionally NOT handled here — the keystroke fast-path in
-   * `handleInputChange` covers that case via `processChange`, and running
-   * it on every value change would inject `@` while the user is still
+   * Canonicalize integration `@`-mentions on mount for any initial value
+   * seeded by `defaultValue` or a restored mothership draft. Mid-typing
+   * conversion is intentionally NOT handled here — the keystroke fast-path
+   * in `handleInputChange` covers that case via `processChange`, and running
+   * it on every value change would rewrite tokens while the user is still
    * typing the name and prematurely open the mention menu.
    */
   useEffect(() => {
@@ -372,8 +373,8 @@ export const UserInput = forwardRef<UserInputHandle, UserInputProps>(function Us
    * Sync `value` when the `defaultValue` prop changes post-mount — e.g.
    * the user clicks a different template while UserInput is already
    * mounted. Mirrors the previously inline render-phase derivation but
-   * now runs the prompt through `applyToText` so integration names get
-   * chipified consistently with paste / draft restore flows.
+   * now runs the prompt through `applyToText` so integration `@`-mentions
+   * get chipified consistently with paste / draft restore flows.
    */
   useEffect(() => {
     if (defaultValue === prevDefaultValueRef.current) return
 
@@ -5,6 +5,7 @@ import { useParams } from 'next/navigation'
 import { cn } from '@/lib/core/utils/cn'
 import { ContextMentionIcon } from '@/app/workspace/[workspaceId]/home/components/context-mention-icon'
 import type { ChatMessageContext } from '@/app/workspace/[workspaceId]/home/types'
+import { getIntegrationMatcher } from '@/blocks/integration-matcher'
 import { useWorkflows } from '@/hooks/queries/workflows'
 
 const USER_MESSAGE_CLASSES =
@@ -33,11 +34,26 @@ interface MentionRange {
   context: ChatMessageContext
 }
 
+/**
+ * Backfills a renderable `blockType` onto integration contexts that are
+ * missing one (or carry one the registry no longer knows) by resolving the
+ * label through the integration matcher. Messages persisted before
+ * `blockType` was included in the save mapping would otherwise render a
+ * mention pill with no icon.
+ */
+function withResolvedBlockType(ctx: ChatMessageContext): ChatMessageContext {
+  if (ctx.kind !== 'integration' || !ctx.label) return ctx
+  const info = getIntegrationMatcher().byName.get(ctx.label.toLowerCase())
+  if (!info) return ctx
+  return { ...ctx, blockType: info.blockType }
+}
+
 function computeMentionRanges(text: string, contexts: ChatMessageContext[]): MentionRange[] {
   const ranges: MentionRange[] = []
 
-  for (const ctx of contexts) {
-    if (!ctx.label) continue
+  for (const rawCtx of contexts) {
+    if (!rawCtx.label) continue
+    const ctx = withResolvedBlockType(rawCtx)
     const prefix = ctx.kind === 'skill' ? '/' : '@'
     const token = `${prefix}${ctx.label}`
     const pattern = new RegExp(`(^|\\s)(${escapeRegex(token)})(\\s|$)`, 'g')
@@ -50,10 +66,48 @@ function computeMentionRanges(text: string, contexts: ChatMessageContext[]): Men
     }
   }
 
+  for (const range of computeIntegrationRanges(text, ranges)) {
+    ranges.push(range)
+  }
+
   ranges.sort((a, b) => a.start - b.start)
   return ranges
 }
 
+/**
+ * Scans the raw text for explicit, token-starting `@IntegrationName` mentions
+ * (any casing) and decorates them even when no matching context was stored —
+ * e.g. a message submitted before the input's auto-mention pass ran, or one
+ * authored outside the chat input. Ranges already claimed by stored contexts
+ * are skipped so the two sources never double-decorate.
+ */
+function computeIntegrationRanges(text: string, taken: MentionRange[]): MentionRange[] {
+  const { regex, byName } = getIntegrationMatcher()
+  if (!regex || !text) return []
+
+  regex.lastIndex = 0
+  const ranges: MentionRange[] = []
+  let match: RegExpExecArray | null
+
+  while ((match = regex.exec(text)) !== null) {
+    const atIndex = match.index - 1
+    if (atIndex < 0 || text[atIndex] !== '@') continue
+    if (atIndex > 0 && !/\s/.test(text[atIndex - 1])) continue
+    const info = byName.get(match[0].toLowerCase())
+    if (!info) continue
+    const start = atIndex
+    const end = match.index + match[0].length
+    if (taken.some((r) => start < r.end && end > r.start)) continue
+    ranges.push({
+      start,
+      end,
+      context: { kind: 'integration', blockType: info.blockType, label: info.name },
+    })
+  }
+
+  return ranges
+}
+
 function MentionHighlight({ context }: { context: ChatMessageContext }) {
   const { workspaceId } = useParams<{ workspaceId: string }>()
   const { data: workflowList } = useWorkflows(workspaceId)
@@ -84,10 +138,7 @@ export function UserMessageContent({
   const trimmed = content.trim()
   const classes = cn(compact ? COMPACT_CLASSES : USER_MESSAGE_CLASSES, className)
 
-  const ranges = useMemo(
-    () => (contexts && contexts.length > 0 ? computeMentionRanges(content, contexts) : []),
-    [content, contexts]
-  )
+  const ranges = useMemo(() => computeMentionRanges(content, contexts ?? []), [content, contexts])
 
   if (ranges.length === 0) {
     return <p className={classes}>{trimmed}</p>
 
@@ -22,9 +22,11 @@ function isMentionPrefixAt(text: string, atIndex: number): boolean {
 }
 
 /**
- * Scans `text` for known integration names and rewrites each bare
- * occurrence to `@CanonicalName` (case-normalized). Names already
- * preceded by `@` are surfaced as contexts but not double-prefixed.
+ * Scans `text` for explicit `@`-prefixed integration mentions and
+ * canonicalizes their casing (`@slack` → `@Slack`). Bare integration names
+ * are left untouched — plain words like `Monday` or `Notion` in prose must
+ * never be rewritten or chipped (the scunthorpe problem); only a deliberate
+ * `@` opt-in gets mention treatment.
  */
 function convertText(text: string): { text: string; contexts: IntegrationContext[] } {
   const { regex, byName } = getIntegrationMatcher()
@@ -42,23 +44,17 @@ function convertText(text: string): { text: string; contexts: IntegrationContext
   while ((match = regex.exec(text)) !== null) {
     const info = byName.get(match[0].toLowerCase())
     if (!info) continue
-    const atIndex = match.index - 1
-    const hasAtChar = atIndex >= 0 && text[atIndex] === '@'
-    // Email-like prefix (`foo@slack`): the `@` is not a token-starting
-    // prefix. Skip entirely so we neither rewrite nor surface a context —
-    // the downstream sync effect would strip it anyway and we'd just be
-    // doing wasted work that flickers a chip for one render.
-    if (hasAtChar && !isMentionPrefixAt(text, atIndex)) continue
+    // Only explicit, token-starting `@` mentions count. Bare names and
+    // email-like prefixes (`foo@slack`) are skipped entirely.
+    if (!isMentionPrefixAt(text, match.index - 1)) continue
     if (!seen.has(info.name)) {
       seen.add(info.name)
       contexts.push({ kind: 'integration', blockType: info.blockType, label: info.name })
     }
-    const isPrefixed = hasAtChar
     // Skip rewrite when the match is already in canonical `@Slack` form;
-    // otherwise rewrite (either insert `@` or canonicalize the casing).
-    if (isPrefixed && match[0] === info.name) continue
-    const replacement = isPrefixed ? info.name : `@${info.name}`
-    result += text.slice(lastEnd, match.index) + replacement
+    // otherwise canonicalize the casing.
+    if (match[0] === info.name) continue
+    result += text.slice(lastEnd, match.index) + info.name
     lastEnd = match.index + match[0].length
     mutated = true
   }
@@ -78,15 +74,17 @@ interface ProcessChangeArgs {
 }
 
 /**
- * Auto-converts organic integration names (`Slack`, `AWS Textract`,
- * `Gmail`, any casing) into proper `@CanonicalName` mentions so they
- * render with the exact same chip UI as resource mentions — preserving
- * caret alignment, undo grouping, and copy/paste round-tripping.
+ * Canonicalizes explicit `@`-prefixed integration mentions (`@slack`,
+ * `@aws textract`, any casing) into `@CanonicalName` form so they render
+ * with the exact same chip UI as resource mentions — preserving caret
+ * alignment, undo grouping, and copy/paste round-tripping. Bare integration
+ * names in prose are deliberately left untouched: mention treatment is
+ * strictly opt-in via `@`.
  *
  * Two entry points share one dedup helper:
  * - `processChange`: keystroke fast-path. Detects a typed word-boundary
- *   char that just completed an integration name and rewrites the
- *   textarea in a single `setRangeText` edit (joined with the typed
+ *   char that just completed an `@`-prefixed integration name and rewrites
+ *   the textarea in a single `setRangeText` edit (joined with the typed
  *   boundary char in native undo history).
  * - `applyToText`: bulk path for paste, template insertion, draft
  *   restore, speech-to-text, and any other programmatic value source.
@@ -139,22 +137,18 @@ export function useIntegrationAutoMention({ setSelectedContexts }: UseIntegratio
       const info = byName.get(completed.name.toLowerCase())
       if (!info) return nextValue
 
-      const atIndex = completed.start - 1
-      const hasAtChar = atIndex >= 0 && nextValue[atIndex] === '@'
-      // Email-like prefix (`foo@slack`): bail out — neither rewrite nor
-      // record a context. The `@` is not a token-starting prefix.
-      if (hasAtChar && !isMentionPrefixAt(nextValue, atIndex)) return nextValue
-      const hasAtPrefix = hasAtChar
+      // Only explicit, token-starting `@` mentions count. Bare names and
+      // email-like prefixes (`foo@slack`) are left untouched — a plain word
+      // like `Monday` in prose must never be rewritten or chipped.
+      if (!isMentionPrefixAt(nextValue, completed.start - 1)) return nextValue
       // If the user already typed canonical `@Slack`, nothing to rewrite —
-      // just record the context. Otherwise either insert `@` (bare name)
-      // or canonicalize the casing (e.g. `@slack` → `@Slack` so the
-      // mention pipeline's case-sensitive token match finds it).
-      if (!hasAtPrefix || completed.name !== info.name) {
+      // just record the context. Otherwise canonicalize the casing
+      // (e.g. `@slack` → `@Slack` so the mention pipeline's case-sensitive
+      // token match finds it).
+      if (completed.name !== info.name) {
         const caret = textarea.selectionStart ?? diffIndex + 1
-        const replacement = hasAtPrefix ? info.name : `@${info.name}`
-        const caretShift = hasAtPrefix ? 0 : 1
-        textarea.setRangeText(replacement, completed.start, completed.end, 'preserve')
-        textarea.setSelectionRange(caret + caretShift, caret + caretShift)
+        textarea.setRangeText(info.name, completed.start, completed.end, 'preserve')
+        textarea.setSelectionRange(caret, caret)
       }
 
       mergeContexts([{ kind: 'integration', blockType: info.blockType, label: info.name }])