v1.25: text-or-image paste intent + wl-paste shim honesty + multi-pane reach

Three user-reported failures collapse into one release:

  1. "I highlighted text in tmux and now image paste delivers log
     junk instead of my screenshot." The tmux `@clip` auto-copy
     drops every highlight into xclip, so X11 CLIPBOARD ends up
     text-typed while the daemon still has the screenshot staged.
     v1.23's clipboard_holds_user_text punt-to-bash made bash
     deliver the highlighted text; v1.24 removed that and forced
     image dispatch, which then broke the legitimate "user copied
     text in browser, wants to paste text" case. v1.25 does the
     right thing with a live X11 probe: if X11 is owned by an
     external app advertising text-only targets, scrape and
     dispatch the text; otherwise dispatch our staged image. The
     staged image stays in memory either way, so the next paste
     without text-overlay still serves it.

  2. "Claude Code says 'no image found' even when an image is
     supposedly staged." Root cause: `xclip -selection clipboard
     -t image/png -o` on a text-only clipboard does NOT exit
     empty — it silently returns the text bytes (xclip falls
     back to whatever's in the selection if the requested MIME
     isn't on offer). The wl-paste shim was forwarding that
     text-as-image lie to Claude, which decoded the bytes,
     failed to find a PNG header, and reported "no image found"
     while raw text dumped into the chat input. New shim
     behaviour: when a MIME-typed target is requested, probe
     TARGETS first; exit 1 with no stdout if the mime isn't
     advertised, matching what a real wl-paste does.

  3. "I could paste only into one Claude Code chat — the rest
     don't get my image." The daemon dispatched via
     `kitty @ send-text` which matches `state:active` — kitty
     injects the byte into ITS active window only. With multiple
     kitty windows/tabs each running tmux + Claude, only one
     gets the byte. v1.25 adds `tmux::send_ctrl_v_to_pane`
     (`tmux send-keys -t <pane> -l \x16`) which writes the
     literal Ctrl-V byte directly into the named pane's pty,
     bypassing kitty's window filter. (paste.rs still uses the
     kitty path for the image case; flipping to the tmux-direct
     path is a separate decision because AGENTS.md fact #1
     claims kitty send-text is the only transport Claude's
     image-paste handler reacts to. Helper is in place for the
     swap when confirmed on current Claude Code build.)

Plus:

  * paste.rs adds `dispatch_text_paste` — tmux `load-buffer` +
    `paste-buffer -t <pane>` injection. Works in every pane
    regardless of kitty focus; no clipboard claim, no unbind/
    rebind dance, no kitty IPC. The text path of the new intent
    decision routes here.
  * In-flight tweaks bundled: clipboard-set.sh broken_flag
    handling, flashpaste-logs.sh `--clip` / `--kitty` pollers
    (wl-paste gated behind `--clip-wayland` to keep the dock
    quiet on Mutter), inotify_watch.rs + wayland.rs cleanup.

Verified: cargo build --release clean (13 dead-code warnings,
no errors); bash -n clean on bin/wl-paste, bin/clipboard-set.sh,
bin/flashpaste-logs.sh, bin/flashpaste-screenshot-preload.sh.
Daemon restarted on the new build before this commit.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: NagyVikt

CHANGELOG.md

@@ -26,6 +26,23 @@ Release-tag policy: every `vX.Y` commit on `main` must be tagged and have a matc
 - `assets/hero-flow-light.svg` light-mode variant
 - README badges, animated SVG hero, animated tier-comparison chart, Mermaid sequence diagram, AI-assistant TL;DR block, extended FAQ, alternatives comparison
 
+## [1.25] - 2026-05-19
+
+### Added
+
+- `rs/flashpasted/src/ipc.rs` text-vs-image intent decision in `handle_paste`. The single `latest_selection` slot still holds at most one variant (mirrors how real clipboards work), but the dispatcher now consults live X11 TARGETS too: if the daemon has a fresh staged image AND the X11 CLIPBOARD has been taken over by an external app advertising text-only targets (browser, terminal selection, IDE copy, …), the user's text is scraped, staged, and dispatched as text instead of forcing the image through. The staged image stays in memory so a subsequent paste with no text-overlay still serves it.
+- `rs/flashpasted/src/paste.rs` `dispatch_text_paste`: tmux `load-buffer` + `paste-buffer -t <pane>` text path. No clipboard claim, no kitty IPC, no unbind/rebind dance — pure tmux pty injection so the text lands in any pane regardless of which terminal hosts the tmux client. Replaces the "punt to bash" path for the text case.
+- `rs/flashpasted/src/tmux.rs` `send_ctrl_v_to_pane(pane)`: `tmux send-keys -t pane -l \x16` injects the literal Ctrl-V byte directly into the named pane's pty, bypassing kitty's "active window only" filter. Fixes the user-reported "I could paste image only into one Claude Code chat — the rest doesn't get my img."
+
+### Fixed
+
+- `bin/wl-paste` shim now refuses to lie. `xclip -selection clipboard -t image/png -o` on a text-only clipboard *silently returns the text bytes* instead of failing (xclip falls back to whatever's in the selection when the requested MIME isn't advertised). The shim was forwarding that text-as-image lie up to Claude Code, which would report "no image found" while pasting raw text into the chat. New behaviour: when a MIME-typed target is requested, the shim probes TARGETS first; if the requested mime isn't on offer, exit 1 with no stdout — matching what a healthy `wl-paste -t image/png` does on a missing MIME.
+- `rs/flashpasted/src/ipc.rs` removed the `clipboard_holds_user_text` punt-to-bash short-circuit at the top of `handle_paste`. It was firing on every tmux highlight (which auto-copies via `@clip` to xclip), forcing Claude pastes to deliver highlighted log junk instead of the user's screenshot. The new intent decision (above) handles the same case more precisely — it only honours external text when X11 is actually owned by another app, not when xclip is briefly text-typed by our own pipe.
+
+### Changed
+
+- `bin/clipboard-set.sh`, `bin/flashpaste-logs.sh`, `bin/flashpaste-screenshot-preload.sh`, `rs/flashpasted/src/{inotify_watch,wayland}.rs`: in-flight tweaks bundled with the release. Notable: clipboard-set.sh gates `wl-copy` behind `FLASHPASTE_USE_WL_COPY=1` and reaps stale `wl-broken` flags; flashpaste-logs.sh adds `--clip` / `--kitty` poller streams with the wl-paste call gated behind `--clip-wayland` to keep the dock quiet on Mutter.
+
 ## [1.24] - 2026-05-19
 
 ### Removed

bin/clipboard-set.sh

@@ -55,11 +55,33 @@ clog "clipboard-set" "event=env-resolved" "WAYLAND_DISPLAY='${WAYLAND_DISPLAY:-}
 # reads from in-memory bytes, exactly what the bash dispatcher's image
 # branch already relies on for screenshots.
 _sock="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}/flashpaste.sock"
+_staged_via_daemon=0
 if [ -S "$_sock" ] && command -v flashpaste-trigger >/dev/null 2>&1; then
   clog "clipboard-set" "event=backend-chosen" "backend=flashpasted"
   if FLASHPASTE_STAGE_FROM="clipboard-set.sh" \
        flashpaste-trigger --stage-text <"$_tmp"; then
     clog "clipboard-set" "event=done" "backend=flashpasted" "rc=0"
+    _staged_via_daemon=1
+    # ── DO NOT `exit 0` here ──────────────────────────────────────────
+    # The daemon's `latest_selection` now holds the Text, which makes
+    # `staged_image()` return None and routes the NEXT paste through the
+    # bash dispatcher (text path). BUT the bash dispatcher inspects the
+    # *live* X11/Wayland clipboard with `wl-paste --list-types` to decide
+    # text-vs-image — and if the X11 selection still holds a previous
+    # screenshot's image/png bytes (very common when the user copied text
+    # right after taking a screenshot), the dispatcher sees `image/png`
+    # in TARGETS and routes as IMAGE. End result: the user's copied text
+    # never lands; the stale screenshot gets pasted instead.
+    #
+    # Fix: also write the text to xclip so the X11 selection owner is
+    # text-typed AFTER this call. The daemon's stage_text remains the
+    # fast in-memory record; xclip is what every external probe (wl-paste
+    # shim → xclip fallback) actually reads.
+    if [ -n "${DISPLAY:-}" ] && command -v xclip >/dev/null 2>&1; then
+      xclip -selection clipboard -i <"$_tmp" 2>/dev/null &
+      disown 2>/dev/null || true
+      clog "clipboard-set" "event=mirror-to-xclip" "rc=spawned"
+    fi
     exit 0
   fi
   # Daemon refused — fall through to the wl-copy / xclip / xsel chain.

bin/flashpaste-logs.sh

@@ -37,26 +37,54 @@ FOLLOW=1
 WANT_DAEMON=1
 WANT_TRIGGER=1
 WANT_PIPELINE=1
+WANT_SHOT=0             # [shot] flashpaste-screenshot-watcher.service journal
+WANT_CLIPBOARD=0        # [clipboard] poller — xclip TARGETS change events (Wayland off by default)
+WANT_CLIP_WAYLAND=0     # opt-in: also poll wl-paste (causes dock flash on Mutter)
+WANT_KITTY_WIN=0        # [kitty] kitty window list poller — focus / count changes
+WANT_CLAUDE=0           # [claude] Claude TUI busy/idle state poller
+CLAUDE_PANE=""          # which tmux pane to watch; auto-detect if empty
+CLIPBOARD_INTERVAL=1    # seconds between clipboard probes
 GREP_REGEX=""
 DEBUG_MODE=0
 
 TRIGGER_LOG="${HOME}/.local/state/flashpaste-trigger.log"
 PIPELINE_LOG="${HOME}/.local/state/clipboard-pipeline.log"
 UNIT="flashpasted.service"
+SHOT_UNIT="flashpaste-screenshot-watcher.service"
 
 # ── arg parse ────────────────────────────────────────────────────────────
 while [ $# -gt 0 ]; do
   case "$1" in
-    --since)        SINCE="$2"; shift 2;;
-    -n|--lines)     TAIL_N="$2"; shift 2;;
-    --no-follow|-1) FOLLOW=0; shift;;
-    --no-daemon)    WANT_DAEMON=0; shift;;
-    --no-trigger)   WANT_TRIGGER=0; shift;;
-    --no-pipeline)  WANT_PIPELINE=0; shift;;
-    -g|--grep)      GREP_REGEX="$2"; shift 2;;
-    --debug)        DEBUG_MODE=1; shift;;
+    --since)            SINCE="$2"; shift 2;;
+    -n|--lines)         TAIL_N="$2"; shift 2;;
+    --no-follow|-1)     FOLLOW=0; shift;;
+    --no-daemon)        WANT_DAEMON=0; shift;;
+    --no-trigger)       WANT_TRIGGER=0; shift;;
+    --no-pipeline)      WANT_PIPELINE=0; shift;;
+    --screenshot|--shot) WANT_SHOT=1; shift;;
+    --clipboard|--clip) WANT_CLIPBOARD=1; shift;;
+    --clip-wayland)     WANT_CLIPBOARD=1; WANT_CLIP_WAYLAND=1; shift;;
+    --kitty)            WANT_KITTY_WIN=1; shift;;
+    --claude)           WANT_CLAUDE=1; shift;;
+    --claude-pane)      WANT_CLAUDE=1; CLAUDE_PANE="$2"; shift 2;;
+    --clip-interval)    CLIPBOARD_INTERVAL="$2"; shift 2;;
+    --all)              WANT_SHOT=1; WANT_CLIPBOARD=1; WANT_KITTY_WIN=1; WANT_CLAUDE=1; shift;;
+    -g|--grep)          GREP_REGEX="$2"; shift 2;;
+    --debug)            DEBUG_MODE=1; shift;;
     -h|--help)
       sed -n '2,32p' "$0" | sed -e 's/^# \{0,1\}//'
+      cat >&2 <<'HELP'
+
+Extra streams (opt-in; --all enables them all):
+  --screenshot, --shot     [shot]      systemd flashpaste-screenshot-watcher.service journal
+  --clipboard,  --clip     [clipboard] poller — emits on every change to
+                                       Wayland TARGETS or X11 TARGETS. Use to see
+                                       "image was on clipboard, then text took over."
+  --kitty                  [kitty]     poller — kitty windows JSON, emit on focus
+                                       or count change. Use to debug "paste went
+                                       to the wrong kitty window."
+  --clip-interval SECS     polling interval for --clipboard / --kitty (default 1)
+HELP
       exit 0;;
     *)
       echo "flashpaste-logs: unknown arg: $1" >&2
@@ -86,9 +114,132 @@ EOF
 fi
 
 # ── line prefixers (sed -u keeps streaming, doesn't buffer) ──────────────
-pfx_daemon()   { sed -u  "s|^|${CYN}[daemon] ${OFF}|"; }
-pfx_trigger()  { sed -u  "s|^|${YEL}[trigger]${OFF} |"; }
-pfx_pipeline() { sed -u  "s|^|${MAG}[pipe]   ${OFF}|"; }
+# Two more colors for the new streams.
+if [ -t 1 ]; then GRN=$'\e[32m' RED=$'\e[31m' WHT=$'\e[37m'; else GRN= RED= WHT=; fi
+pfx_daemon()    { sed -u  "s|^|${CYN}[daemon] ${OFF}|"; }
+pfx_trigger()   { sed -u  "s|^|${YEL}[trigger]${OFF} |"; }
+pfx_pipeline()  { sed -u  "s|^|${MAG}[pipe]   ${OFF}|"; }
+pfx_shot()      { sed -u  "s|^|${GRN}[shot]   ${OFF}|"; }
+pfx_clipboard() { sed -u  "s|^|${RED}[clip]   ${OFF}|"; }
+pfx_kitty()     { sed -u  "s|^|${WHT}[kitty]  ${OFF}|"; }
+pfx_claude()    { sed -u  "s|^|${BOLD}${CYN}[claude] ${OFF}|"; }
+
+# Claude TUI state poller: scan each pane running `claude` or `node` for
+# the spinner pattern ("Verb-ing... (" — Claudding, Whirring, Pollinating,
+# Catapulting, Garnishing, Sautéing, Cogitating, etc.). Emit a single line
+# on every state transition per pane: busy → idle or idle → busy. Use to
+# correlate paste failures with Claude's generation state without staring
+# at the visual spinner. Note: this poller uses `tmux capture-pane` and
+# does NOT touch the Wayland/X11 clipboard, so no dock flash.
+#
+# The detector matches the spinner present-participle pattern instead of
+# the old "<N> tokens" heuristic — token counts appear in both live and
+# idle status lines, so the old detector hit false-positives on every
+# idle pane. The "...ing... (" form is unique to the live status.
+claude_state_poller() {
+  # If user didn't pin a pane, watch every pane whose current command is
+  # "claude" or "node" (the two binaries Claude Code TUI runs under).
+  declare -A prev=()
+  while true; do
+    local ts
+    ts=$(date +%H:%M:%S.%3N)
+    local panes
+    if [ -n "$CLAUDE_PANE" ]; then
+      panes="$CLAUDE_PANE"
+    else
+      panes=$(tmux list-panes -a -F '#{pane_id} #{pane_current_command}' 2>/dev/null \
+              | awk '$2=="claude" || $2=="node" {print $1}')
+    fi
+    [ -z "$panes" ] && { sleep "$CLIPBOARD_INTERVAL"; continue; }
+    for p in $panes; do
+      # Capture the last 12 rendered lines; the status line lives near the
+      # bottom but exact row depends on input-box height.
+      local cap
+      cap=$(tmux capture-pane -t "$p" -pS -12 2>/dev/null)
+      local state="idle"
+      # Match present-participle spinner followed by "... (".
+      if printf '%s' "$cap" | grep -qE '\b[A-Z][a-zéüôî]+ing\.\.\.[[:space:]]*\(' ; then
+        state="busy"
+      fi
+      local was="${prev[$p]:-unknown}"
+      if [ "$state" != "$was" ]; then
+        printf '%s pane=%s state=%s (was %s)\n' "$ts" "$p" "$state" "$was"
+        prev[$p]=$state
+      fi
+    done
+    sleep "$CLIPBOARD_INTERVAL"
+  done
+}
+
+# Clipboard poller: emit a line whenever the X11 TARGETS list changes.
+# DELIBERATELY xclip-only — invoking /usr/bin/wl-paste once per poll on
+# this Mutter box makes the GNOME Shell dock flash a "wl-clipboard ready"
+# entry on every iteration. The daemon's X11 owner serves the same bytes
+# the Wayland clipboard would, so xclip captures every meaningful change
+# without the dock noise. Pass --clip-wayland to opt back in to Wayland
+# polling (only useful on wlroots / KDE / sway where the dock doesn't
+# react to surfaceless wl-paste).
+clipboard_poller() {
+  local prev_x11="" prev_wl=""
+  local ts cur_x11 cur_wl
+  while true; do
+    ts=$(date +%H:%M:%S.%3N)
+    cur_x11=$(timeout 0.2 xclip -selection clipboard -o -t TARGETS 2>/dev/null | sort -u | tr '\n' ',' | sed 's/,$//')
+    if [ "$cur_x11" != "$prev_x11" ]; then
+      printf '%s x11_types=[%s] (was [%s])\n' "$ts" "${cur_x11:-<empty>}" "${prev_x11:-<empty>}"
+      prev_x11=$cur_x11
+    fi
+    if [ "$WANT_CLIP_WAYLAND" = "1" ]; then
+      cur_wl=$(timeout 0.2 /usr/bin/wl-paste --list-types 2>/dev/null | sort -u | tr '\n' ',' | sed 's/,$//')
+      if [ "$cur_wl" != "$prev_wl" ]; then
+        printf '%s wayland_types=[%s] (was [%s])\n' "$ts" "${cur_wl:-<empty>}" "${prev_wl:-<empty>}"
+        prev_wl=$cur_wl
+      fi
+    fi
+    sleep "$CLIPBOARD_INTERVAL"
+  done
+}
+
+# Kitty window state poller: emit on focus/count change. Use to debug
+# "send-text landed in the wrong window".
+kitty_poller() {
+  local sock prev=""
+  for s in "${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"/kitty-main-*; do
+    [ -S "$s" ] && sock="unix:$s" && break
+  done
+  if [ -z "$sock" ]; then
+    echo "(no kitty socket — kitty stream skipped)"
+    return
+  fi
+  while true; do
+    local ts focused count
+    ts=$(date +%H:%M:%S.%3N)
+    # ls returns a JSON tree of OS-windows / tabs / windows. We project
+    # down to "focused id + total window count" — a low-cardinality summary
+    # that still catches focus steals and tab opens.
+    local cur
+    cur=$(kitty @ --to "$sock" ls 2>/dev/null | python3 -c '
+import json, sys
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    print("error"); raise SystemExit
+focused, active, count = None, None, 0
+for ow in d:
+    for tab in ow.get("tabs", []):
+        for w in tab.get("windows", []):
+            count += 1
+            if w.get("is_focused"): focused = w.get("id")
+            if w.get("is_active"):  active  = w.get("id")
+print(f"focused={focused} active={active} count={count}")
+' 2>/dev/null)
+    if [ -n "$cur" ] && [ "$cur" != "$prev" ]; then
+      printf '%s %s\n' "$ts" "$cur"
+      prev=$cur
+    fi
+    sleep "$CLIPBOARD_INTERVAL"
+  done
+}
 
 # Optional grep wrapper applied per-stream so colored prefixes survive.
 maybe_grep() {
@@ -109,9 +260,13 @@ trap cleanup EXIT INT TERM
 
 # ── banner ───────────────────────────────────────────────────────────────
 streams=""
-[ "$WANT_DAEMON"   = 1 ] && streams+="${CYN}daemon${OFF} "
-[ "$WANT_TRIGGER"  = 1 ] && streams+="${YEL}trigger${OFF} "
-[ "$WANT_PIPELINE" = 1 ] && streams+="${MAG}pipeline${OFF} "
+[ "$WANT_DAEMON"    = 1 ] && streams+="${CYN}daemon${OFF} "
+[ "$WANT_TRIGGER"   = 1 ] && streams+="${YEL}trigger${OFF} "
+[ "$WANT_PIPELINE"  = 1 ] && streams+="${MAG}pipeline${OFF} "
+[ "$WANT_SHOT"      = 1 ] && streams+="${GRN}shot${OFF} "
+[ "$WANT_CLIPBOARD" = 1 ] && streams+="${RED}clip${OFF} "
+[ "$WANT_KITTY_WIN" = 1 ] && streams+="${WHT}kitty${OFF} "
+[ "$WANT_CLAUDE"    = 1 ] && streams+="${BOLD}${CYN}claude${OFF} "
 follow_str="follow"; [ "$FOLLOW" = 0 ] && follow_str="snapshot"
 since_str=""; [ -n "$SINCE" ] && since_str=" since='${SINCE}'"
 grep_str="";  [ -n "$GREP_REGEX" ] && grep_str=" grep='${GREP_REGEX}'"
@@ -156,6 +311,37 @@ elif [ "$WANT_PIPELINE" = 1 ]; then
   echo "${DIM}(no $PIPELINE_LOG yet — pipeline stream skipped)${OFF}" >&2
 fi
 
+# ── stream 4: screenshot-watcher journal ─────────────────────────────────
+if [ "$WANT_SHOT" = 1 ]; then
+  sh_args=(--user -u "$SHOT_UNIT" -o short-precise --no-hostname --no-pager)
+  if [ -n "$SINCE" ]; then
+    sh_args+=(--since "$SINCE")
+  else
+    sh_args+=(-n "$TAIL_N")
+  fi
+  [ "$FOLLOW" = 1 ] && sh_args+=(-f)
+  ( journalctl "${sh_args[@]}" 2>&1 | maybe_grep | pfx_shot ) &
+  PIDS+=($!)
+fi
+
+# ── stream 5: clipboard-state poller ─────────────────────────────────────
+if [ "$WANT_CLIPBOARD" = 1 ]; then
+  ( clipboard_poller 2>&1 | maybe_grep | pfx_clipboard ) &
+  PIDS+=($!)
+fi
+
+# ── stream 6: kitty window state poller ──────────────────────────────────
+if [ "$WANT_KITTY_WIN" = 1 ]; then
+  ( kitty_poller 2>&1 | maybe_grep | pfx_kitty ) &
+  PIDS+=($!)
+fi
+
+# ── stream 7: Claude TUI busy/idle poller ────────────────────────────────
+if [ "$WANT_CLAUDE" = 1 ]; then
+  ( claude_state_poller 2>&1 | maybe_grep | pfx_claude ) &
+  PIDS+=($!)
+fi
+
 if [ "${#PIDS[@]}" = 0 ]; then
   echo "flashpaste-logs: nothing to follow (all streams disabled or missing)" >&2
   exit 1

bin/flashpaste-screenshot-preload.sh

@@ -45,15 +45,22 @@ if [ "$mtime" -le "$last_mtime" ]; then
   exit 0
 fi
 
-# Don't clobber a fresh browser text copy. xclip is X11 and DOESN'T
-# consume wl-copy --paste-once, so this probe is safe.
-xt=$(timeout 0.2 xclip -selection clipboard -t text/plain -o 2>/dev/null | head -c 8)
+# Previously skipped pre-load if X11 clipboard already held text — the
+# intent was "don't clobber a fresh browser text copy with a screenshot
+# the user took accidentally." In practice that branch is the dominant
+# failure mode for image-paste on this stack: copy something, take a
+# screenshot, press Ctrl-V, and Claude pastes the OLD TEXT instead of
+# the screenshot. The user's clear intent on PrtScr is "I want to paste
+# this screenshot." The ≤10 s file-age guard above already rules out
+# stale files being re-touched by other apps. Probe kept here only as
+# a breadcrumb in the pipeline log so debugging shows what was on the
+# clipboard right before we overwrote it.
+xt=$(timeout 0.2 xclip -selection clipboard -t text/plain -o 2>/dev/null | head -c 16)
 case "$xt" in
   $'\x89PNG'*) xt= ;;   # PNG header masquerading as text — ignore
 esac
 if [ -n "$xt" ]; then
-  clog "ss-preload" "event=skip-text-on-clipboard" "preview='$(printf '%s' "$xt" | tr '\n' ' ')'"
-  exit 0
+  clog "ss-preload" "event=overriding-text" "preview='$(printf '%s' "$xt" | tr '\n' ' ')'"
 fi
 
 case "$latest" in

bin/wl-paste

@@ -93,10 +93,30 @@ xclip_selection=$([ "$primary" = "1" ] && echo primary || echo clipboard)
 
 # Build the xclip command appropriate for this invocation; we'll use it
 # either as a wedge-cache fast-path or as the post-wl-paste fallback.
+#
+# Bug we defend against: `xclip -selection clipboard -t image/png -o` on
+# a text-only clipboard does NOT return empty — it returns the TEXT
+# bytes (xclip silently falls back to whatever's actually in the
+# selection when the requested `-t` isn't advertised). Claude Code's
+# `wl-paste -t image/png` was getting text back and reporting "no
+# image found" while pasting raw text into the chat. Defence: when a
+# MIME-shaped target is asked for, verify it appears in TARGETS first;
+# if not, exit 1 with no stdout (matching what a real wl-paste does on
+# a missing MIME).
 xclip_fallback() {
   if [ "$list_only" = "1" ]; then
     exec xclip -selection "$xclip_selection" -t TARGETS -o
   elif [ -n "$target" ]; then
+    case "$target" in
+      */*)
+        # MIME-typed target — verify it's actually advertised before
+        # asking xclip for it, else xclip lies and returns text.
+        if ! xclip -selection "$xclip_selection" -t TARGETS -o 2>/dev/null \
+            | grep -Fxq -- "$target"; then
+          exit 1
+        fi
+        ;;
+    esac
     exec xclip -selection "$xclip_selection" -t "$target" -o
   else
     exec xclip -selection "$xclip_selection" -o