diff --git a/agent/agent_init.py b/agent/agent_init.py
index f1666a1aafb..0f9376d6c79 100644
--- a/agent/agent_init.py
+++ b/agent/agent_init.py
@@ -302,6 +302,7 @@ def init_agent(
notice_callback: callable = None,
notice_clear_callback: callable = None,
event_callback: Optional[Callable[[str, dict], None]] = None,
+ reaction_callback: Optional[Callable[[str], None]] = None,
max_tokens: int = None,
reasoning_config: Dict[str, Any] = None,
service_tier: str = None,
@@ -535,6 +536,7 @@ def init_agent(
agent.notice_callback = notice_callback
agent.notice_clear_callback = notice_clear_callback
agent.event_callback = event_callback
+ agent.reaction_callback = reaction_callback
agent.tool_gen_callback = tool_gen_callback
diff --git a/agent/reactions.py b/agent/reactions.py
new file mode 100644
index 00000000000..375366ff709
--- /dev/null
+++ b/agent/reactions.py
@@ -0,0 +1,56 @@
+"""Token-free detection of user *reactions* to the agent.
+
+Currently the only reaction is ``vibe`` — an expression of affection or
+gratitude toward the agent (``ily``, ``<3``, ``love you``, ``good bot``, a heart
+emoji, …). Detection is a curated regex/lexicon: **no model call, no tokens**.
+
+This is the single source of truth shared by every surface — the CLI pet, the
+TUI heart, and the desktop floating hearts all react off the same signal,
+delivered via ``AIAgent.reaction_callback`` (wired per interactive host).
+
+Generalized on purpose: :func:`detect_reaction` returns a reaction *kind*
+string, so new kinds (other emoji reactions, etc.) can be added here without
+touching any caller. We match affection specifically — not general positive
+sentiment — so "this is great" does NOT fire, but "good bot" / "❤️" do.
+"""
+
+from __future__ import annotations
+
+import re
+
+#: The affection/gratitude reaction — the only kind today.
+VIBE = "vibe"
+
+# Curated affection lexicon. Kept deliberately narrow: gratitude + love aimed at
+# the agent, heart emoji, and ``<3`` (but not the broken heart `` str | None:
+ """Return the reaction kind for *text* (currently :data:`VIBE`), or ``None``.
+
+ Pure, token-free, and safe to call on every user turn.
+ """
+ if not text:
+ return None
+
+ return VIBE if _VIBE_RE.search(text) else None
diff --git a/agent/turn_context.py b/agent/turn_context.py
index 4fd6ddff2c3..a5e738588e4 100644
--- a/agent/turn_context.py
+++ b/agent/turn_context.py
@@ -319,6 +319,20 @@ def build_turn_context(
current_turn_user_idx = len(messages) - 1
agent._persist_user_message_idx = current_turn_user_idx
+ # Cosmetic side-signal: detect an affection "reaction" (ily / <3 / good bot)
+ # and notify the host so it can play hearts. Token-free, never touches the
+ # conversation, and never fatal — a purely optional UI beat.
+ reaction_callback = getattr(agent, "reaction_callback", None)
+ if reaction_callback is not None:
+ try:
+ from agent.reactions import detect_reaction
+
+ kind = detect_reaction(original_user_message)
+ if kind:
+ reaction_callback(kind)
+ except Exception:
+ pass
+
if not agent.quiet_mode:
_print_preview = summarize_user_message_for_log(user_message)
agent._safe_print(
diff --git a/apps/desktop/src/app/chat/index.tsx b/apps/desktop/src/app/chat/index.tsx
index bece9b49152..fb8175102b0 100644
--- a/apps/desktop/src/app/chat/index.tsx
+++ b/apps/desktop/src/app/chat/index.tsx
@@ -12,6 +12,7 @@ import { useLocation } from 'react-router-dom'
import { Thread } from '@/components/assistant-ui/thread'
import { Backdrop } from '@/components/Backdrop'
+import { COMPOSER_HEART_CONFIG, HeartField } from '@/components/chat/vibe-hearts'
import { PromptOverlays } from '@/components/prompt-overlays'
import { Button } from '@/components/ui/button'
import { Codicon } from '@/components/ui/codicon'
@@ -30,6 +31,8 @@ import { useIncrementalExternalStoreRuntime } from '@/lib/incremental-external-s
import { cn } from '@/lib/utils'
import type { ComposerAttachment } from '@/store/composer'
import { $pinnedSessionIds } from '@/store/layout'
+import { $petActive } from '@/store/pet'
+import { $petOverlayActive } from '@/store/pet-overlay'
import { $gatewaySwapTarget } from '@/store/profile'
import {
$activeSessionId,
@@ -297,6 +300,10 @@ export function ChatView({
const currentCwd = useStore($currentCwd)
const currentModel = useStore($currentModel)
const currentProvider = useStore($currentProvider)
+ // A pet anywhere (in-window or popped out) owns the hearts; composer only when none.
+ const petActive = useStore($petActive)
+ const petOverlayActive = useStore($petOverlayActive)
+ const petPresent = petActive || petOverlayActive
const freshDraftReady = useStore($freshDraftReady)
const gatewayState = useStore($gatewayState)
const gatewaySwapTarget = useStore($gatewaySwapTarget)
@@ -491,6 +498,18 @@ export function ChatView({
)}
{showChatBar && }
+ {/* Vibe hearts rise from the composer only when no pet is out (else
+ they play on the pet). Fired by the core `reaction` event. */}
+ {!petPresent && (
+
+ )}
diff --git a/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx b/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx
index ae3c1860b7c..d635186e34e 100644
--- a/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx
+++ b/apps/desktop/src/app/pet-overlay/pet-overlay-app.tsx
@@ -1,6 +1,7 @@
import { useStore } from '@nanostores/react'
import { useCallback, useEffect, useRef, useState } from 'react'
+import { PetHeartField, playVibeHearts } from '@/components/chat/vibe-hearts'
import { PetBubble } from '@/components/pet/pet-bubble'
import { PetSprite } from '@/components/pet/pet-sprite'
import { type PetZoomAnchor, usePetZoomGesture } from '@/components/pet/use-pet-zoom-gesture'
@@ -72,6 +73,8 @@ export function PetOverlayApp() {
const zoomAnchorRef = useRef(null)
const petRef = useRef(null)
const inputRef = useRef(null)
+ // Last mirrored reaction id — a bump means the main window fired a reaction.
+ const lastReactionRef = useRef(null)
const ignoreRef = useRef(true)
const composerOpenRef = useRef(false)
const clickTimerRef = useRef | undefined>(undefined)
@@ -91,6 +94,19 @@ export function PetOverlayApp() {
setBusy(Boolean(payload.busy))
setAwaitingResponse(Boolean(payload.awaiting))
setUnread(Boolean(payload.unread))
+
+ // Play a reaction on a new id (ignore the first sync, which just primes it).
+ const reaction = payload.reaction ?? null
+
+ if (lastReactionRef.current === null) {
+ lastReactionRef.current = reaction?.id ?? 0
+ } else if (reaction && reaction.id > lastReactionRef.current) {
+ lastReactionRef.current = reaction.id
+
+ if (reaction.kind === 'vibe') {
+ playVibeHearts()
+ }
+ }
})
// Tell the main renderer we're mounted so it pushes the current frame (the
@@ -416,6 +432,12 @@ export function PetOverlayApp() {
+ {/* Hearts on the popped-out pet — identical to in-window. */}
+
+
{/* Mail icon: only when a finish landed while you were away. Jumps to
the app's most recent thread. Anchored to the sprite (kept inside
its box so the overlay's click-through hit-test still catches it);
diff --git a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
index f057bca4f24..664e4b9d53e 100644
--- a/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
+++ b/apps/desktop/src/app/session/hooks/use-message-stream/gateway-event.ts
@@ -4,6 +4,7 @@ import { type MutableRefObject, useCallback } from 'react'
import { writeAgentTerminalChunk } from '@/app/right-sidebar/terminal/agent-terminal-stream'
import { readActiveTerminal } from '@/app/right-sidebar/terminal/buffer'
import { closeAgentTerminalByProc } from '@/app/right-sidebar/terminal/terminals'
+import { burstVibeHearts } from '@/components/chat/vibe-hearts'
import { translateNow } from '@/i18n'
import { type GatewayEventPayload, textPart } from '@/lib/chat-messages'
import { coerceGatewayText, coerceThinkingText, normalizePersonalityValue } from '@/lib/chat-runtime'
@@ -264,6 +265,12 @@ export function useGatewayEventHandler(deps: GatewayEventDeps) {
// KawaiiSpinner), not real reasoning. The bottom-of-thread loading
// indicator already covers that UX, so we ignore these events to
// avoid a duplicative "Thinking" disclosure showing spinner text.
+ } else if (event.type === 'reaction') {
+ // Core-detected affection (ily / <3 / good bot) on the user's message.
+ // Play hearts only for the visible session so background turns stay quiet.
+ if (isActiveEvent && (payload?.kind ?? 'vibe') === 'vibe') {
+ burstVibeHearts()
+ }
} else if (event.type === 'reasoning.delta') {
if (sessionId) {
appendReasoningDelta(sessionId, coerceThinkingText(payload?.text))
diff --git a/apps/desktop/src/components/chat/vibe-hearts.tsx b/apps/desktop/src/components/chat/vibe-hearts.tsx
new file mode 100644
index 00000000000..b4f5e7e1a24
--- /dev/null
+++ b/apps/desktop/src/components/chat/vibe-hearts.tsx
@@ -0,0 +1,119 @@
+import { type CSSProperties } from 'react'
+
+import {
+ createParticleEmitter,
+ ParticleField,
+ type ParticleFieldConfig
+} from '@/components/particles/particle-field'
+import { $petActive, flashPetActivity } from '@/store/pet'
+import { $petOverlayActive, forwardPetReaction } from '@/store/pet-overlay'
+
+/**
+ * TikTok-style floating hearts — a thin skin over {@link ParticleField} (pixel
+ * heart glyph + pink). Placed two ways: rising from the composer when no pet is
+ * out, or from the pet when one is. Fired by the core `reaction` event (affection
+ * in a user message) via {@link burstVibeHearts}.
+ */
+
+// Light pink reads on both light and dark chat surfaces.
+const HEART_COLORS = ['#ff9ec4'] as const
+
+/** Composer placement: hearts rise the thread height (rise = % of the tall lane). */
+export const COMPOSER_HEART_CONFIG: Partial = {
+ count: 12,
+ size: [6, 13],
+ rise: [6.75, 15.75],
+ duration: [320, 700]
+}
+
+/** Pet placement: a compact puff off the pet. The field box spans feet→head, so
+ * rise ≥100% carries hearts from the feet to ~10-20% above the pet before fading. */
+const PET_HEART_CONFIG: Partial = {
+ count: 10,
+ spawnWindowMs: 450,
+ size: [6, 12],
+ rise: [98, 118],
+ duration: [480, 880],
+ swayAmp: [5, 14],
+ bank: [6, 14]
+}
+
+// Pixel-art heart from @nous-research/ui (14×12), crisp + `currentColor`.
+const HEART_GLYPH = (
+
+)
+
+const emitter = createParticleEmitter()
+
+/** Play hearts in THIS window (whichever HeartField is mounted). The overlay
+ * window calls this directly off the mirrored vibe signal. */
+export const playVibeHearts = (count?: number) => emitter.burst(count)
+
+/**
+ * Fire a vibe burst (from the core `reaction` event). Routes to where the
+ * affection should land:
+ * - pet popped out → forward to the overlay window + celebrate (mirrored)
+ * - pet in-window → play here (on the pet) + celebrate
+ * - no pet → play here (composer)
+ */
+export const burstVibeHearts = (count?: number) => {
+ const overlay = $petOverlayActive.get()
+
+ if (overlay || $petActive.get()) {
+ flashPetActivity({ celebrate: true })
+ }
+
+ if (overlay) {
+ forwardPetReaction('vibe')
+ } else {
+ playVibeHearts(count)
+ }
+}
+
+export interface HeartFieldProps {
+ config?: Partial
+ className?: string
+ style?: CSSProperties
+}
+
+/** Heart-skinned particle field. Caller supplies placement + a config preset. */
+export function HeartField({ config, className, style }: HeartFieldProps) {
+ return (
+
+ )
+}
+
+/**
+ * Pet-anchored hearts, feet→~10-20% above. One place owns the geometry so the
+ * in-window pet and the popped-out overlay stay identical. `petW`/`petH` are the
+ * rendered sprite dimensions (frame × scale).
+ */
+export function PetHeartField({ petW, petH }: { petW: number; petH: number }) {
+ return (
+
+ )
+}
diff --git a/apps/desktop/src/components/particles/particle-field.css b/apps/desktop/src/components/particles/particle-field.css
new file mode 100644
index 00000000000..94bf2258aae
--- /dev/null
+++ b/apps/desktop/src/components/particles/particle-field.css
@@ -0,0 +1,126 @@
+/* ── Particle field ─────────────────────────────────────────────────────────
+ Reusable float-up emitter. Three nested layers, each owning ONE transform so
+ they never fight:
+ .particle — full-height track: vertical rise + fade (linear)
+ .particle__sway — horizontal weave + bank/tilt on its OWN period
+ (ease-in-out, alternating), so the path desyncs from
+ the rise and never repeats — the organic-motion trick
+ .particle__glyph — one-shot springy pop-in scale
+ The track is full-height and anchored at the field bottom, so the rise's
+ `translateY(-rise%)` measures against the field height, not the glyph's. All
+ tuning arrives as inline `--particle-*` custom properties. */
+.particle-field {
+ pointer-events: none;
+ overflow: visible;
+}
+
+.particle {
+ position: absolute;
+ inset-block: 0;
+ left: var(--particle-left);
+ display: flex;
+ align-items: flex-end;
+ justify-content: center;
+ width: var(--particle-size);
+ margin-left: calc(var(--particle-size) / -2);
+ will-change: transform, opacity;
+ animation: particle-rise var(--particle-duration) linear var(--particle-delay) both;
+}
+
+.particle__sway {
+ display: block;
+ will-change: transform;
+ animation: particle-sway var(--particle-sway-duration) ease-in-out var(--particle-sway-delay)
+ infinite alternate;
+}
+
+.particle__glyph {
+ display: block;
+ width: var(--particle-size);
+ color: var(--particle-color);
+ will-change: transform;
+ animation: particle-pop 260ms cubic-bezier(0.34, 1.56, 0.64, 1) var(--particle-delay) both;
+}
+
+.particle__glyph > svg {
+ display: block;
+ width: 100%;
+ height: auto;
+}
+
+/* Rise: straight up the field, holds opacity through most of the climb, fades
+ near the top. */
+@keyframes particle-rise {
+ 0% {
+ opacity: 0;
+ transform: translate3d(0, 0, 0);
+ }
+
+ 6% {
+ opacity: 1;
+ transform: translate3d(0, calc(var(--particle-rise) * -0.06%), 0);
+ }
+
+ 70% {
+ opacity: 1;
+ transform: translate3d(0, calc(var(--particle-rise) * -0.7%), 0);
+ }
+
+ 100% {
+ opacity: 0;
+ transform: translate3d(0, calc(var(--particle-rise) * -1%), 0);
+ }
+}
+
+/* Sway + bank: swings left↔right and tilts INTO the direction of travel, like a
+ leaf on a breeze. Runs on its own clock. */
+@keyframes particle-sway {
+ from {
+ transform: translateX(calc(var(--particle-sway) * -1)) rotate(calc(var(--particle-bank) * -1));
+ }
+
+ to {
+ transform: translateX(var(--particle-sway)) rotate(var(--particle-bank));
+ }
+}
+
+/* Pop: a springy scale-in overshoot (the bezier is a spring, not a path wobble). */
+@keyframes particle-pop {
+ 0% {
+ transform: scale(0.3);
+ }
+
+ 100% {
+ transform: scale(1);
+ }
+}
+
+@media (prefers-reduced-motion: reduce) {
+ .particle {
+ inset-block: auto 0;
+ height: var(--particle-size);
+ animation: particle-flash 650ms ease-out var(--particle-delay) both;
+ }
+
+ .particle__sway,
+ .particle__glyph {
+ animation: none;
+ }
+
+ @keyframes particle-flash {
+ 0% {
+ opacity: 0;
+ transform: translate3d(0, 0, 0) scale(0.6);
+ }
+
+ 20% {
+ opacity: 1;
+ transform: translate3d(0, -0.5rem, 0) scale(1.1);
+ }
+
+ 100% {
+ opacity: 0;
+ transform: translate3d(0, -1rem, 0) scale(1);
+ }
+ }
+}
diff --git a/apps/desktop/src/components/particles/particle-field.tsx b/apps/desktop/src/components/particles/particle-field.tsx
new file mode 100644
index 00000000000..a7e70c933c6
--- /dev/null
+++ b/apps/desktop/src/components/particles/particle-field.tsx
@@ -0,0 +1,204 @@
+import './particle-field.css'
+
+import { type CSSProperties, type ReactNode, useEffect, useMemo, useRef, useState } from 'react'
+
+import { cn } from '@/lib/utils'
+
+/**
+ * Reusable float-up particle emitter. It owns the motion (rise + organic sway +
+ * springy pop) and lifecycle (staggered burst, lifetime, cleanup); callers just
+ * hand it a `glyph` (any element using `currentColor`) and `colors`, then place
+ * it with `className` / `style`. See {@link VibeHearts} for the chat-hearts use.
+ */
+
+type Range = readonly [min: number, max: number]
+
+const rand = ([min, max]: Range) => min + Math.random() * (max - min)
+/** Sample a range along `t` (0→min, 1→max) — couples travel/lifetime to `life`. */
+const lerp = ([min, max]: Range, t: number) => min + (max - min) * t
+
+export interface ParticleFieldConfig {
+ /** Particles per burst when `burst()` is called without a count. */
+ count: number
+ /** Window (ms) over which a burst releases its particles — small = one poof. */
+ spawnWindowMs: number
+ /** Glyph edge size (px), uniform. */
+ size: Range
+ /** Vertical travel before fade-out (% of field height), `life`-biased. */
+ rise: Range
+ /** Rise duration (ms), `life`-biased so short-lived particles also rise less. */
+ duration: Range
+ /** Sway amplitude each side of center (px), uniform. */
+ swayAmp: Range
+ /** Peak tilt into the sway (deg), uniform. */
+ bank: Range
+ /** Sway period (ms), uniform — independent of the rise so paths never repeat. */
+ swayDuration: Range
+ /** Cap on simultaneously-alive particles. */
+ maxAlive: number
+}
+
+export const DEFAULT_PARTICLE_CONFIG: ParticleFieldConfig = {
+ count: 12,
+ spawnWindowMs: 550,
+ size: [6, 13],
+ rise: [6.75, 15.75],
+ duration: [320, 700],
+ swayAmp: [9, 24],
+ bank: [7, 16],
+ swayDuration: [1300, 2800],
+ maxAlive: 200
+}
+
+export interface ParticleEmitter {
+ /** Fire a burst (defaults to the field's configured `count`). */
+ burst: (count?: number) => void
+ /** Internal: field subscription. */
+ subscribe: (fn: (count?: number) => void) => () => void
+}
+
+/** Create an emitter handle. `burst()` is safe to call from anywhere. */
+export function createParticleEmitter(): ParticleEmitter {
+ const listeners = new Set<(count?: number) => void>()
+
+ return {
+ burst: count => listeners.forEach(fn => fn(count)),
+ subscribe: fn => {
+ listeners.add(fn)
+
+ return () => void listeners.delete(fn)
+ }
+ }
+}
+
+interface Particle {
+ id: number
+ leftPct: number
+ size: number
+ color: string
+ delayMs: number
+ durationMs: number
+ rise: number
+ swayAmp: number
+ bank: number
+ swayDurationMs: number
+ swayDelayMs: number
+}
+
+let nextId = 1
+
+function spawn(cfg: ParticleFieldConfig, colors: readonly string[]): Particle {
+ // Short-lived particles fade out lower; a few live longer and rise higher.
+ const life = Math.random() ** 1.7
+ const swayDurationMs = Math.round(rand(cfg.swayDuration))
+
+ return {
+ id: nextId++,
+ // Spread edge to edge across the lane, not clustered near center.
+ leftPct: 4 + Math.random() * 92,
+ size: rand(cfg.size),
+ color: colors[Math.floor(Math.random() * colors.length)]!,
+ delayMs: Math.round(Math.random() * 120),
+ durationMs: Math.round(lerp(cfg.duration, life)),
+ rise: lerp(cfg.rise, life),
+ swayAmp: rand(cfg.swayAmp),
+ bank: rand(cfg.bank),
+ swayDurationMs,
+ // Negative delay drops each particle in mid-swing (desynced phases).
+ swayDelayMs: -Math.round(Math.random() * swayDurationMs)
+ }
+}
+
+const prefersReducedMotion = () =>
+ typeof window !== 'undefined' && Boolean(window.matchMedia?.('(prefers-reduced-motion: reduce)').matches)
+
+export interface ParticleFieldProps {
+ emitter: ParticleEmitter
+ /** Any element that paints with `currentColor` (SVG, glyph, …). */
+ glyph: ReactNode
+ colors: readonly string[]
+ config?: Partial
+ className?: string
+ style?: CSSProperties
+}
+
+export function ParticleField({ emitter, glyph, colors, config, className, style }: ParticleFieldProps) {
+ const cfg = useMemo(() => ({ ...DEFAULT_PARTICLE_CONFIG, ...config }), [config])
+ const [particles, setParticles] = useState([])
+ const timers = useRef>>(new Set())
+
+ useEffect(() => {
+ const pool = timers.current
+ const add = () => setParticles(prev => [...prev, spawn(cfg, colors)].slice(-cfg.maxAlive))
+
+ // Release a burst across a tight window so it reads as one poof, each node
+ // with its own random birth time; reduced motion gets a single flash.
+ const onBurst = (count?: number) => {
+ const n = Math.max(1, Math.min(cfg.maxAlive, Math.round(count ?? cfg.count)))
+
+ if (prefersReducedMotion()) {
+ add()
+
+ return
+ }
+
+ for (let i = 0; i < n; i++) {
+ const timer = setTimeout(() => {
+ pool.delete(timer)
+ add()
+ }, Math.random() * cfg.spawnWindowMs)
+
+ pool.add(timer)
+ }
+ }
+
+ const unsubscribe = emitter.subscribe(onBurst)
+
+ return () => {
+ unsubscribe()
+ pool.forEach(clearTimeout)
+ pool.clear()
+ }
+ }, [cfg, colors, emitter])
+
+ const remove = (id: number) => setParticles(prev => prev.filter(p => p.id !== id))
+
+ if (particles.length === 0) {
+ return null
+ }
+
+ return (
+