feat: /buddy

src/buddy/CompanionCard.tsx

@@ -0,0 +1,110 @@
+/**
+ * Companion display card — shown by /buddy (no args).
+ * Mirrors official vc8 component: bordered box with sprite, stats, last reaction.
+ */
+import React from 'react';
+import { Box, Text } from '../ink.js';
+import { useInput } from '../ink.js';
+import { renderSprite } from './sprites.js';
+import { RARITY_COLORS, RARITY_STARS, STAT_NAMES, type Companion } from './types.js';
+
+const CARD_WIDTH = 40;
+const CARD_PADDING_X = 2;
+
+function StatBar({ name, value }: { name: string; value: number }) {
+  const clamped = Math.max(0, Math.min(100, value));
+  const filled = Math.round(clamped / 10);
+  const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
+  return (
+    <Text>
+      {name.padEnd(10)} {bar} {String(value).padStart(3)}
+    </Text>
+  );
+}
+
+export function CompanionCard({
+  companion,
+  lastReaction,
+  onDone,
+}: {
+  companion: Companion;
+  lastReaction?: string;
+  onDone?: (result?: string, options?: { display?: string }) => void;
+}) {
+  const color = RARITY_COLORS[companion.rarity];
+  const stars = RARITY_STARS[companion.rarity];
+  const sprite = renderSprite(companion, 0);
+
+  // Press any key to dismiss
+  useInput(
+    () => {
+      onDone?.(undefined, { display: 'skip' });
+    },
+    { isActive: onDone !== undefined },
+  );
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor={color}
+      paddingX={CARD_PADDING_X}
+      paddingY={1}
+      width={CARD_WIDTH}
+      flexShrink={0}
+    >
+      {/* Header: rarity + species */}
+      <Box justifyContent="space-between">
+        <Text bold color={color}>
+          {stars} {companion.rarity.toUpperCase()}
+        </Text>
+        <Text color={color}>{companion.species.toUpperCase()}</Text>
+      </Box>
+
+      {/* Shiny indicator */}
+      {companion.shiny && (
+        <Text color="warning" bold>
+          {'\u2728'} SHINY {'\u2728'}
+        </Text>
+      )}
+
+      {/* Sprite */}
+      <Box flexDirection="column" marginY={1}>
+        {sprite.map((line, i) => (
+          <Text key={i} color={color}>
+            {line}
+          </Text>
+        ))}
+      </Box>
+
+      {/* Name */}
+      <Text bold>{companion.name}</Text>
+
+      {/* Personality */}
+      <Box marginY={1}>
+        <Text dimColor italic>
+          &quot;{companion.personality}&quot;
+        </Text>
+      </Box>
+
+      {/* Stats */}
+      <Box flexDirection="column">
+        {STAT_NAMES.map(name => (
+          <StatBar key={name} name={name} value={companion.stats[name] ?? 0} />
+        ))}
+      </Box>
+
+      {/* Last reaction */}
+      {lastReaction && (
+        <Box flexDirection="column" marginTop={1}>
+          <Text dimColor>last said</Text>
+          <Box borderStyle="round" borderColor="inactive" paddingX={1}>
+            <Text dimColor italic>
+              {lastReaction}
+            </Text>
+          </Box>
+        </Box>
+      )}
+    </Box>
+  );
+}

src/buddy/CompanionSprite.tsx

@@ -368,4 +368,3 @@ function _temp2(s_0) {
 function _temp(s) {
   return s.companionReaction;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","figures","React","useEffect","useRef","useState","useTerminalSize","stringWidth","Box","Text","useAppState","useSetAppState","AppState","getGlobalConfig","isFullscreenActive","Theme","getCompanion","renderFace","renderSprite","spriteFrameCount","RARITY_COLORS","TICK_MS","BUBBLE_SHOW","FADE_WINDOW","PET_BURST_MS","IDLE_SEQUENCE","H","heart","PET_HEARTS","wrap","text","width","words","split","lines","cur","w","length","push","SpeechBubble","t0","$","_c","color","fading","tail","T0","borderColor","t1","t2","t3","t4","t5","t6","t7","l","i","undefined","map","bubble","t8","t9","MIN_COLS_FOR_FULL_SPRITE","SPRITE_BODY_WIDTH","NAME_ROW_PAD","SPRITE_PADDING_X","BUBBLE_WIDTH","NARROW_QUIP_CAP","spriteColWidth","nameWidth","Math","max","companionReservedColumns","terminalColumns","speaking","companion","companionMuted","name","CompanionSprite","ReactNode","reaction","s","companionReaction","petAt","companionPetAt","focused","footerSelection","setAppState","columns","tick","setTick","lastSpokeTick","petStartTick","forPetAt","setPetStart","timer","setInterval","setT","t","clearInterval","current","setTimeout","setA","prev","clearTimeout","rarity","colWidth","bubbleAge","petAge","Infinity","petting","quip","slice","label","frameCount","species","heartFrame","spriteFrame","blink","step","body","line","replaceAll","eye","sprite","spriteColumn","CompanionFloatingBubble","_temp","forReaction","_temp3","set","_temp2","s_0"],"sources":["CompanionSprite.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport figures from 'figures'\nimport React, { useEffect, useRef, useState } from 'react'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { stringWidth } from '../ink/stringWidth.js'\nimport { Box, Text } from '../ink.js'\nimport { useAppState, useSetAppState } from '../state/AppState.js'\nimport type { AppState } from '../state/AppStateStore.js'\nimport { getGlobalConfig } from '../utils/config.js'\nimport { isFullscreenActive } from '../utils/fullscreen.js'\nimport type { Theme } from '../utils/theme.js'\nimport { getCompanion } from './companion.js'\nimport { renderFace, renderSprite, spriteFrameCount } from './sprites.js'\nimport { RARITY_COLORS } from './types.js'\n\nconst TICK_MS = 500\nconst BUBBLE_SHOW = 20 // ticks → ~10s at 500ms\nconst FADE_WINDOW = 6 // last ~3s the bubble dims so you know it's about to go\nconst PET_BURST_MS = 2500 // how long hearts float after /buddy pet\n\n// Idle sequence: mostly rest (frame 0), occasional fidget (frames 1-2), rare blink.\n// Sequence indices map to sprite frames; -1 means \"blink on frame 0\".\nconst IDLE_SEQUENCE = [0, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 2, 0, 0, 0]\n\n// Hearts float up-and-out over 5 ticks (~2.5s). Prepended above the sprite.\nconst H = figures.heart\nconst PET_HEARTS = [\n  `   ${H}    ${H}   `,\n  `  ${H}  ${H}   ${H}  `,\n  ` ${H}   ${H}  ${H}   `,\n  `${H}  ${H}      ${H} `,\n  '·    ·   ·  ',\n]\n\nfunction wrap(text: string, width: number): string[] {\n  const words = text.split(' ')\n  const lines: string[] = []\n  let cur = ''\n  for (const w of words) {\n    if (cur.length + w.length + 1 > width && cur) {\n      lines.push(cur)\n      cur = w\n    } else {\n      cur = cur ? `${cur} ${w}` : w\n    }\n  }\n  if (cur) lines.push(cur)\n  return lines\n}\n\nfunction SpeechBubble({\n  text,\n  color,\n  fading,\n  tail,\n}: {\n  text: string\n  color: keyof Theme\n  fading: boolean\n  tail: 'down' | 'right'\n}): React.ReactNode {\n  const lines = wrap(text, 30)\n  const borderColor = fading ? 'inactive' : color\n  const bubble = (\n    <Box\n      flexDirection=\"column\"\n      borderStyle=\"round\"\n      borderColor={borderColor}\n      paddingX={1}\n      width={34}\n    >\n      {lines.map((l, i) => (\n        <Text\n          key={i}\n          italic\n          dimColor={!fading}\n          color={fading ? 'inactive' : undefined}\n        >\n          {l}\n        </Text>\n      ))}\n    </Box>\n  )\n  if (tail === 'right') {\n    return (\n      <Box flexDirection=\"row\" alignItems=\"center\">\n        {bubble}\n        <Text color={borderColor}>─</Text>\n      </Box>\n    )\n  }\n  return (\n    <Box flexDirection=\"column\" alignItems=\"flex-end\" marginRight={1}>\n      {bubble}\n      <Box flexDirection=\"column\" alignItems=\"flex-end\" paddingRight={6}>\n        <Text color={borderColor}>╲ </Text>\n        <Text color={borderColor}>╲</Text>\n      </Box>\n    </Box>\n  )\n}\n\nexport const MIN_COLS_FOR_FULL_SPRITE = 100\nconst SPRITE_BODY_WIDTH = 12\nconst NAME_ROW_PAD = 2 // focused state wraps name in spaces: ` name `\nconst SPRITE_PADDING_X = 2\nconst BUBBLE_WIDTH = 36 // SpeechBubble box (34) + tail column\nconst NARROW_QUIP_CAP = 24\n\nfunction spriteColWidth(nameWidth: number): number {\n  return Math.max(SPRITE_BODY_WIDTH, nameWidth + NAME_ROW_PAD)\n}\n\n// Width the sprite area consumes. PromptInput subtracts this so text wraps\n// correctly. In fullscreen the bubble floats over scrollback (no extra\n// width); in non-fullscreen it sits inline and needs BUBBLE_WIDTH more.\n// Narrow terminals: 0 — REPL.tsx stacks the one-liner on its own row\n// (above input in fullscreen, below in scrollback), so no reservation.\nexport function companionReservedColumns(\n  terminalColumns: number,\n  speaking: boolean,\n): number {\n  if (!feature('BUDDY')) return 0\n  const companion = getCompanion()\n  if (!companion || getGlobalConfig().companionMuted) return 0\n  if (terminalColumns < MIN_COLS_FOR_FULL_SPRITE) return 0\n  const nameWidth = stringWidth(companion.name)\n  const bubble = speaking && !isFullscreenActive() ? BUBBLE_WIDTH : 0\n  return spriteColWidth(nameWidth) + SPRITE_PADDING_X + bubble\n}\n\nexport function CompanionSprite(): React.ReactNode {\n  const reaction = useAppState(s => s.companionReaction)\n  const petAt = useAppState(s => s.companionPetAt)\n  const focused = useAppState(s => s.footerSelection === 'companion')\n  const setAppState = useSetAppState()\n  const { columns } = useTerminalSize()\n  const [tick, setTick] = useState(0)\n  const lastSpokeTick = useRef(0)\n  // Sync-during-render (not useEffect) so the first post-pet render already\n  // has petStartTick=tick and petAge=0 — otherwise frame 0 is skipped.\n  const [{ petStartTick, forPetAt }, setPetStart] = useState({\n    petStartTick: 0,\n    forPetAt: petAt,\n  })\n  if (petAt !== forPetAt) {\n    setPetStart({ petStartTick: tick, forPetAt: petAt })\n  }\n\n  useEffect(() => {\n    const timer = setInterval(\n      setT => setT((t: number) => t + 1),\n      TICK_MS,\n      setTick,\n    )\n    return () => clearInterval(timer)\n  }, [])\n\n  useEffect(() => {\n    if (!reaction) return\n    lastSpokeTick.current = tick\n    const timer = setTimeout(\n      setA =>\n        setA((prev: AppState) =>\n          prev.companionReaction === undefined\n            ? prev\n            : { ...prev, companionReaction: undefined },\n        ),\n      BUBBLE_SHOW * TICK_MS,\n      setAppState,\n    )\n    return () => clearTimeout(timer)\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- tick intentionally captured at reaction-change, not tracked\n  }, [reaction, setAppState])\n\n  if (!feature('BUDDY')) return null\n  const companion = getCompanion()\n  if (!companion || getGlobalConfig().companionMuted) return null\n\n  const color = RARITY_COLORS[companion.rarity]\n  const colWidth = spriteColWidth(stringWidth(companion.name))\n\n  const bubbleAge = reaction ? tick - lastSpokeTick.current : 0\n  const fading =\n    reaction !== undefined && bubbleAge >= BUBBLE_SHOW - FADE_WINDOW\n\n  const petAge = petAt ? tick - petStartTick : Infinity\n  const petting = petAge * TICK_MS < PET_BURST_MS\n\n  // Narrow terminals: collapse to one-line face. When speaking, the quip\n  // replaces the name beside the face (no room for a bubble).\n  if (columns < MIN_COLS_FOR_FULL_SPRITE) {\n    const quip =\n      reaction && reaction.length > NARROW_QUIP_CAP\n        ? reaction.slice(0, NARROW_QUIP_CAP - 1) + '…'\n        : reaction\n    const label = quip\n      ? `\"${quip}\"`\n      : focused\n        ? ` ${companion.name} `\n        : companion.name\n    return (\n      <Box paddingX={1} alignSelf=\"flex-end\">\n        <Text>\n          {petting && <Text color=\"autoAccept\">{figures.heart} </Text>}\n          <Text bold color={color}>\n            {renderFace(companion)}\n          </Text>{' '}\n          <Text\n            italic\n            dimColor={!focused && !reaction}\n            bold={focused}\n            inverse={focused && !reaction}\n            color={\n              reaction\n                ? fading\n                  ? 'inactive'\n                  : color\n                : focused\n                  ? color\n                  : undefined\n            }\n          >\n            {label}\n          </Text>\n        </Text>\n      </Box>\n    )\n  }\n  const frameCount = spriteFrameCount(companion.species)\n  const heartFrame = petting ? PET_HEARTS[petAge % PET_HEARTS.length] : null\n\n  let spriteFrame: number\n  let blink = false\n  if (reaction || petting) {\n    // Excited: cycle all fidget frames fast\n    spriteFrame = tick % frameCount\n  } else {\n    const step = IDLE_SEQUENCE[tick % IDLE_SEQUENCE.length]!\n    if (step === -1) {\n      spriteFrame = 0\n      blink = true\n    } else {\n      spriteFrame = step % frameCount\n    }\n  }\n\n  const body = renderSprite(companion, spriteFrame).map(line =>\n    blink ? line.replaceAll(companion.eye, '-') : line,\n  )\n  const sprite = heartFrame ? [heartFrame, ...body] : body\n\n  // Name row doubles as hint row — unfocused shows dim name + ↓ discovery,\n  // focused shows inverse name. The enter-to-open hint lives in\n  // PromptInputFooter's right column so this row stays one line and the\n  // sprite doesn't jump up when selected. flexShrink=0 stops the\n  // inline-bubble row wrapper from squeezing the sprite to fit.\n  const spriteColumn = (\n    <Box\n      flexDirection=\"column\"\n      flexShrink={0}\n      alignItems=\"center\"\n      width={colWidth}\n    >\n      {sprite.map((line, i) => (\n        <Text key={i} color={i === 0 && heartFrame ? 'autoAccept' : color}>\n          {line}\n        </Text>\n      ))}\n      <Text\n        italic\n        bold={focused}\n        dimColor={!focused}\n        color={focused ? color : undefined}\n        inverse={focused}\n      >\n        {focused ? ` ${companion.name} ` : companion.name}\n      </Text>\n    </Box>\n  )\n\n  if (!reaction) {\n    return <Box paddingX={1}>{spriteColumn}</Box>\n  }\n\n  // Fullscreen: bubble renders separately via CompanionFloatingBubble in\n  // FullscreenLayout's bottomFloat slot (the bottom slot's overflowY:hidden\n  // would clip a position:absolute overlay here). Sprite body only.\n  // Non-fullscreen: bubble sits inline beside the sprite (input shrinks)\n  // because floating into Static scrollback can't be cleared.\n  if (isFullscreenActive()) {\n    return <Box paddingX={1}>{spriteColumn}</Box>\n  }\n  return (\n    <Box flexDirection=\"row\" alignItems=\"flex-end\" paddingX={1} flexShrink={0}>\n      <SpeechBubble\n        text={reaction}\n        color={color}\n        fading={fading}\n        tail=\"right\"\n      />\n      {spriteColumn}\n    </Box>\n  )\n}\n\n// Floating bubble overlay for fullscreen mode. Mounted in FullscreenLayout's\n// bottomFloat slot (outside the overflowY:hidden clip) so it can extend into\n// the ScrollBox region. CompanionSprite owns the clear-after-10s timer; this\n// just reads companionReaction and renders the fade.\nexport function CompanionFloatingBubble(): React.ReactNode {\n  const reaction = useAppState(s => s.companionReaction)\n  const [{ tick, forReaction }, setTick] = useState({\n    tick: 0,\n    forReaction: reaction,\n  })\n\n  // Reset tick synchronously when reaction changes (not in useEffect, which\n  // runs post-render and would show one stale-faded frame). Storing the\n  // reaction the tick is counting FOR alongside the tick itself means the\n  // fade computation never sees a tick from a previous reaction.\n  if (reaction !== forReaction) {\n    setTick({ tick: 0, forReaction: reaction })\n  }\n\n  useEffect(() => {\n    if (!reaction) return\n    const timer = setInterval(\n      set => set(s => ({ ...s, tick: s.tick + 1 })),\n      TICK_MS,\n      setTick,\n    )\n    return () => clearInterval(timer)\n  }, [reaction])\n\n  if (!feature('BUDDY') || !reaction) return null\n  const companion = getCompanion()\n  if (!companion || getGlobalConfig().companionMuted) return null\n\n  return (\n    <SpeechBubble\n      text={reaction}\n      color={RARITY_COLORS[companion.rarity]}\n      fading={tick >= BUBBLE_SHOW - FADE_WINDOW}\n      tail=\"down\"\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/buddy/companion.ts

@@ -116,18 +116,21 @@ export function rollWithSeed(seed: string): Roll {
   return rollFrom(mulberry32(hashString(seed)))
 }
 
+export function generateSeed(): string {
+  return `rehatch-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`
+}
+
 export function companionUserId(): string {
   const config = getGlobalConfig()
   return config.oauthAccount?.accountUuid ?? config.userID ?? 'anon'
 }
 
-// Regenerate bones from userId, merge with stored soul. Bones never persist
-// so species renames and SPECIES-array edits can't break stored companions,
-// and editing config.companion can't fake a rarity.
+// Regenerate bones from seed or userId, merge with stored soul.
 export function getCompanion(): Companion | undefined {
   const stored = getGlobalConfig().companion
   if (!stored) return undefined
-  const { bones } = roll(companionUserId())
+  const seed = stored.seed ?? companionUserId()
+  const { bones } = rollWithSeed(seed)
   // bones last so stale bones fields in old-format configs get overridden
   return { ...stored, ...bones }
 }

src/buddy/companionReact.ts

@@ -0,0 +1,160 @@
+/**
+ * Companion reaction system — aligns with official ZUK + Dc8 pattern.
+ *
+ * Called from REPL.tsx after each query turn. Checks mute state, frequency
+ * limits, and @-mention detection, then calls the buddy_react API to
+ * generate a reaction shown in the CompanionSprite speech bubble.
+ */
+import { getCompanion } from './companion.js'
+import { getGlobalConfig } from '../utils/config.js'
+import { getClaudeAIOAuthTokens } from '../utils/auth.js'
+import { getOauthConfig } from '../constants/oauth.js'
+import { getUserAgent } from '../utils/http.js'
+import type { Message } from '../types/message.js'
+
+// ─── Rate limiting ──────────────────────────────────
+
+let lastReactTime = 0
+const MIN_INTERVAL_MS = 45_000 // official is roughly 30-60s
+
+// ─── Recent reactions (avoid repetition) ────────────
+
+const recentReactions: string[] = []
+const MAX_RECENT = 8
+
+// ─── Public API ─────────────────────────────────────
+
+/**
+ * Trigger a companion reaction after a query turn.
+ *
+ * Mirrors official `ZUK()`:
+ *  1. Check companion exists and is not muted
+ *  2. Detect if user @-mentioned companion by name
+ *  3. Apply rate limiting (skip if not addressed and too soon)
+ *  4. Build conversation transcript
+ *  5. Call buddy_react API
+ *  6. Pass reaction text to setReaction callback
+ */
+export function triggerCompanionReaction(
+  messages: Message[],
+  setReaction: (text: string | undefined) => void,
+): void {
+  const companion = getCompanion()
+  if (!companion || getGlobalConfig().companionMuted) return
+
+  const addressed = isAddressed(messages, companion.name)
+
+  const now = Date.now()
+  if (!addressed && now - lastReactTime < MIN_INTERVAL_MS) return
+
+  const transcript = buildTranscript(messages)
+  if (!transcript.trim()) return
+
+  lastReactTime = now
+
+  void callBuddyReactAPI(companion, transcript, addressed)
+    .then(reaction => {
+      if (!reaction) return
+      recentReactions.push(reaction)
+      if (recentReactions.length > MAX_RECENT) recentReactions.shift()
+      setReaction(reaction)
+    })
+    .catch(() => {})
+}
+
+// ─── Helpers ────────────────────────────────────────
+
+function isAddressed(messages: Message[], name: string): boolean {
+  const pattern = new RegExp(`\\b${escapeRegex(name)}\\b`, 'i')
+  for (
+    let i = messages.length - 1;
+    i >= Math.max(0, messages.length - 3);
+    i--
+  ) {
+    const m = messages[i]
+    if (m?.type !== 'user') continue
+    const content = (m as any).message?.content
+    if (typeof content === 'string' && pattern.test(content)) return true
+  }
+  return false
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function buildTranscript(messages: Message[]): string {
+  return messages
+    .slice(-12)
+    .filter(m => m.type === 'user' || m.type === 'assistant')
+    .map(m => {
+      const role = m.type === 'user' ? 'user' : 'claude'
+      const content = (m as any).message?.content
+      const text =
+        typeof content === 'string'
+          ? content.slice(0, 300)
+          : Array.isArray(content)
+            ? content
+                .filter((b: any) => b?.type === 'text')
+                .map((b: any) => b.text)
+                .join(' ')
+                .slice(0, 300)
+            : ''
+      return `${role}: ${text}`
+    })
+    .join('\n')
+    .slice(0, 5000)
+}
+
+// ─── API call ───────────────────────────────────────
+
+async function callBuddyReactAPI(
+  companion: {
+    name: string
+    personality: string
+    species: string
+    rarity: string
+    stats: Record<string, number>
+  },
+  transcript: string,
+  addressed: boolean,
+): Promise<string | null> {
+  const tokens = getClaudeAIOAuthTokens()
+  if (!tokens?.accessToken) return null
+
+  const orgId = getGlobalConfig().oauthAccount?.organizationUuid
+  if (!orgId) return null
+
+  const baseUrl = getOauthConfig().BASE_API_URL
+  const url = `${baseUrl}/api/organizations/${orgId}/claude_code/buddy_react`
+
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${tokens.accessToken}`,
+      'Content-Type': 'application/json',
+      'User-Agent': getUserAgent(),
+    },
+    body: JSON.stringify({
+      name: companion.name.slice(0, 32),
+      personality: companion.personality.slice(0, 200),
+      species: companion.species,
+      rarity: companion.rarity,
+      stats: companion.stats,
+      transcript,
+      reason: addressed ? 'addressed' : 'turn',
+      recent: recentReactions.map(r => r.slice(0, 200)),
+      addressed,
+    }),
+    signal: AbortSignal.timeout(10_000),
+  })
+
+  if (!resp.ok) return null
+
+  try {
+    const data = (await resp.json()) as { reaction?: string }
+    return data.reaction?.trim() || null
+  } catch {
+    return null
+  }
+}

src/buddy/observer.ts

@@ -1,79 +0,0 @@
-import { getCompanion } from './companion.js'
-
-type MessageLike = {
-  type?: string
-  message?: {
-    content?: unknown
-  }
-}
-
-function extractText(content: unknown): string {
-  if (typeof content === 'string') return content
-  if (!Array.isArray(content)) return ''
-
-  return content
-    .map(block => {
-      if (!block || typeof block !== 'object') return ''
-      const candidate = block as { type?: string; text?: string }
-      return candidate.type === 'text' && typeof candidate.text === 'string'
-        ? candidate.text
-        : ''
-    })
-    .join(' ')
-    .trim()
-}
-
-function findLastText(
-  messages: MessageLike[],
-  targetType: 'assistant' | 'user',
-): string {
-  for (let i = messages.length - 1; i >= 0; i -= 1) {
-    const message = messages[i]
-    if (message?.type !== targetType) continue
-    const text = extractText(message.message?.content)
-    if (text) return text
-  }
-  return ''
-}
-
-function chooseReaction(userText: string, assistantText: string): string | undefined {
-  const companion = getCompanion()
-  if (!companion) return undefined
-
-  const loweredUser = userText.toLowerCase()
-  const loweredAssistant = assistantText.toLowerCase()
-  const directMention =
-    loweredUser.includes(companion.name.toLowerCase()) ||
-    loweredUser.includes('buddy')
-
-  if (!directMention) return undefined
-
-  if (/\b(thanks|thank you|nice|great|good job|cute)\b/.test(loweredUser)) {
-    return `${companion.name} looks smug for exactly one second.`
-  }
-  if (/\b(help|idea|thought|opinion|what do you think)\b/.test(loweredUser)) {
-    return `${companion.name} votes for the less cursed option.`
-  }
-  if (/\b(refactor|bug|error|failed|fix)\b/.test(loweredAssistant)) {
-    return `${companion.name} squints at the bug like it owes rent.`
-  }
-  if (/\b(done|finished|fixed|works)\b/.test(loweredAssistant)) {
-    return `${companion.name} seems satisfied with the outcome.`
-  }
-  return `${companion.name} is paying attention from the edge of the prompt box.`
-}
-
-export async function fireCompanionObserver(
-  messages: MessageLike[],
-  onReaction: (reaction: string | undefined) => void,
-): Promise<void> {
-  const companion = getCompanion()
-  if (!companion) {
-    onReaction(undefined)
-    return
-  }
-
-  const userText = findLastText(messages, 'user')
-  const assistantText = findLastText(messages, 'assistant')
-  onReaction(chooseReaction(userText, assistantText))
-}

src/buddy/types.ts

@@ -111,6 +111,7 @@ export type CompanionBones = {
 export type CompanionSoul = {
   name: string
   personality: string
+  seed?: string
 }
 
 export type Companion = CompanionBones &

src/buddy/useBuddyNotification.tsx

@@ -10,12 +10,12 @@ import { getRainbowColor } from '../utils/thinking.js';
 // buzz instead of a single UTC-midnight spike, gentler on soul-gen load.
 // Teaser window: April 1-7, 2026 only. Command stays live forever after.
 export function isBuddyTeaserWindow(): boolean {
-  if ("external" === 'ant') return true;
+  if ((process.env.USER_TYPE) === 'ant') return true;
   const d = new Date();
   return d.getFullYear() === 2026 && d.getMonth() === 3 && d.getDate() <= 7;
 }
 export function isBuddyLive(): boolean {
-  if ("external" === 'ant') return true;
+  if ((process.env.USER_TYPE) === 'ant') return true;
   const d = new Date();
   return d.getFullYear() > 2026 || d.getFullYear() === 2026 && d.getMonth() >= 3;
 }
@@ -95,4 +95,3 @@ export function findBuddyTriggerPositions(text: string): Array<{
   }
   return triggers;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmZWF0dXJlIiwiUmVhY3QiLCJ1c2VFZmZlY3QiLCJ1c2VOb3RpZmljYXRpb25zIiwiVGV4dCIsImdldEdsb2JhbENvbmZpZyIsImdldFJhaW5ib3dDb2xvciIsImlzQnVkZHlUZWFzZXJXaW5kb3ciLCJkIiwiRGF0ZSIsImdldEZ1bGxZZWFyIiwiZ2V0TW9udGgiLCJnZXREYXRlIiwiaXNCdWRkeUxpdmUiLCJSYWluYm93VGV4dCIsInQwIiwiJCIsIl9jIiwidGV4dCIsInQxIiwibWFwIiwiX3RlbXAiLCJjaCIsImkiLCJ1c2VCdWRkeU5vdGlmaWNhdGlvbiIsImFkZE5vdGlmaWNhdGlvbiIsInJlbW92ZU5vdGlmaWNhdGlvbiIsImNvbmZpZyIsImNvbXBhbmlvbiIsImtleSIsImpzeCIsInByaW9yaXR5IiwidGltZW91dE1zIiwiZmluZEJ1ZGR5VHJpZ2dlclBvc2l0aW9ucyIsIkFycmF5Iiwic3RhcnQiLCJlbmQiLCJ0cmlnZ2VycyIsInJlIiwibSIsIlJlZ0V4cEV4ZWNBcnJheSIsImV4ZWMiLCJwdXNoIiwiaW5kZXgiLCJsZW5ndGgiXSwic291cmNlcyI6WyJ1c2VCdWRkeU5vdGlmaWNhdGlvbi50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZmVhdHVyZSB9IGZyb20gJ2J1bjpidW5kbGUnXG5pbXBvcnQgUmVhY3QsIHsgdXNlRWZmZWN0IH0gZnJvbSAncmVhY3QnXG5pbXBvcnQgeyB1c2VOb3RpZmljYXRpb25zIH0gZnJvbSAnLi4vY29udGV4dC9ub3RpZmljYXRpb25zLmpzJ1xuaW1wb3J0IHsgVGV4dCB9IGZyb20gJy4uL2luay5qcydcbmltcG9ydCB7IGdldEdsb2JhbENvbmZpZyB9IGZyb20gJy4uL3V0aWxzL2NvbmZpZy5qcydcbmltcG9ydCB7IGdldFJhaW5ib3dDb2xvciB9IGZyb20gJy4uL3V0aWxzL3RoaW5raW5nLmpzJ1xuXG4vLyBMb2NhbCBkYXRlLCBub3QgVVRDIOKAlCAyNGggcm9sbGluZyB3YXZlIGFjcm9zcyB0aW1lem9uZXMuIFN1c3RhaW5lZCBUd2l0dGVyXG4vLyBidXp6IGluc3RlYWQgb2YgYSBzaW5nbGUgVVRDLW1pZG5pZ2h0IHNwaWtlLCBnZW50bGVyIG9uIHNvdWwtZ2VuIGxvYWQuXG4vLyBUZWFzZXIgd2luZG93OiBBcHJpbCAxLTcsIDIwMjYgb25seS4gQ29tbWFuZCBzdGF5cyBsaXZlIGZvcmV2ZXIgYWZ0ZXIuXG5leHBvcnQgZnVuY3Rpb24gaXNCdWRkeVRlYXNlcldpbmRvdygpOiBib29sZWFuIHtcbiAgaWYgKFwiZXh0ZXJuYWxcIiA9PT0gJ2FudCcpIHJldHVybiB0cnVlXG4gIGNvbnN0IGQgPSBuZXcgRGF0ZSgpXG4gIHJldHVybiBkLmdldEZ1bGxZZWFyKCkgPT09IDIwMjYgJiYgZC5nZXRNb250aCgpID09PSAzICYmIGQuZ2V0RGF0ZSgpIDw9IDdcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzQnVkZHlMaXZlKCk6IGJvb2xlYW4ge1xuICBpZiAoXCJleHRlcm5hbFwiID09PSAnYW50JykgcmV0dXJuIHRydWVcbiAgY29uc3QgZCA9IG5ldyBEYXRlKClcbiAgcmV0dXJuIChcbiAgICBkLmdldEZ1bGxZZWFyKCkgPiAyMDI2IHx8IChkLmdldEZ1bGxZZWFyKCkgPT09IDIwMjYgJiYgZC5nZXRNb250aCgpID49IDMpXG4gIClcbn1cblxuZnVuY3Rpb24gUmFpbmJvd1RleHQoeyB0ZXh0IH06IHsgdGV4dDogc3RyaW5nIH0pOiBSZWFjdC5SZWFjdE5vZGUge1xuICByZXR1cm4gKFxuICAgIDw+XG4gICAgICB7Wy4uLnRleHRdLm1hcCgoY2gsIGkpID0+IChcbiAgICAgICAgPFRleHQga2V5PXtpfSBjb2xvcj17Z2V0UmFpbmJvd0NvbG9yKGkpfT5cbiAgICAgICAgICB7Y2h9XG4gICAgICAgIDwvVGV4dD5cbiAgICAgICkpfVxuICAgIDwvPlxuICApXG59XG5cbi8vIFJhaW5ib3cgL2J1ZGR5IHRlYXNlciBzaG93biBvbiBzdGFydHVwIHdoZW4gbm8gY29tcGFuaW9uIGhhdGNoZWQgeWV0LlxuLy8gSWRsZSBwcmVzZW5jZSBhbmQgcmVhY3Rpb25zIGFyZSBoYW5kbGVkIGJ5IENvbXBhbmlvblNwcml0ZSBkaXJlY3RseS5cbmV4cG9ydCBmdW5jdGlvbiB1c2VCdWRkeU5vdGlmaWNhdGlvbigpOiB2b2lkIHtcbiAgY29uc3QgeyBhZGROb3RpZmljYXRpb24sIHJlbW92ZU5vdGlmaWNhdGlvbiB9ID0gdXNlTm90aWZpY2F0aW9ucygpXG5cbiAgdXNlRWZmZWN0KCgpID0+IHtcbiAgICBpZiAoIWZlYXR1cmUoJ0JVRERZJykpIHJldHVyblxuICAgIGNvbnN0IGNvbmZpZyA9IGdldEdsb2JhbENvbmZpZygpXG4gICAgaWYgKGNvbmZpZy5jb21wYW5pb24gfHwgIWlzQnVkZHlUZWFzZXJXaW5kb3coKSkgcmV0dXJuXG4gICAgYWRkTm90aWZpY2F0aW9uKHtcbiAgICAgIGtleTogJ2J1ZGR5LXRlYXNlcicsXG4gICAgICBqc3g6IDxSYWluYm93VGV4dCB0ZXh0PVwiL2J1ZGR5XCIgLz4sXG4gICAgICBwcmlvcml0eTogJ2ltbWVkaWF0ZScsXG4gICAgICB0aW1lb3V0TXM6IDE1XzAwMCxcbiAgICB9KVxuICAgIHJldHVybiAoKSA9PiByZW1vdmVOb3RpZmljYXRpb24oJ2J1ZGR5LXRlYXNlcicpXG4gIH0sIFthZGROb3RpZmljYXRpb24sIHJlbW92ZU5vdGlmaWNhdGlvbl0pXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBmaW5kQnVkZHlUcmlnZ2VyUG9zaXRpb25zKFxuICB0ZXh0OiBzdHJpbmcsXG4pOiBBcnJheTx7IHN0YXJ0OiBudW1iZXI7IGVuZDogbnVtYmVyIH0+IHtcbiAgaWYgKCFmZWF0dXJlKCdCVUREWScpKSByZXR1cm4gW11cbiAgY29uc3QgdHJpZ2dlcnM6IEFycmF5PHsgc3RhcnQ6IG51bWJlcjsgZW5kOiBudW1iZXIgfT4gPSBbXVxuICBjb25zdCByZSA9IC9cXC9idWRkeVxcYi9nXG4gIGxldCBtOiBSZWdFeHBFeGVjQXJyYXkgfCBudWxsXG4gIHdoaWxlICgobSA9IHJlLmV4ZWModGV4dCkpICE9PSBudWxsKSB7XG4gICAgdHJpZ2dlcnMucHVzaCh7IHN0YXJ0OiBtLmluZGV4LCBlbmQ6IG0uaW5kZXggKyBtWzBdLmxlbmd0aCB9KVxuICB9XG4gIHJldHVybiB0cmlnZ2Vyc1xufVxuIl0sIm1hcHBpbmdzIjoiO0FBQUEsU0FBU0EsT0FBTyxRQUFRLFlBQVk7QUFDcEMsT0FBT0MsS0FBSyxJQUFJQyxTQUFTLFFBQVEsT0FBTztBQUN4QyxTQUFTQyxnQkFBZ0IsUUFBUSw2QkFBNkI7QUFDOUQsU0FBU0MsSUFBSSxRQUFRLFdBQVc7QUFDaEMsU0FBU0MsZUFBZSxRQUFRLG9CQUFvQjtBQUNwRCxTQUFTQyxlQUFlLFFBQVEsc0JBQXNCOztBQUV0RDtBQUNBO0FBQ0E7QUFDQSxPQUFPLFNBQVNDLG1CQUFtQkEsQ0FBQSxDQUFFLEVBQUUsT0FBTyxDQUFDO0VBQzdDLElBQUksVUFBVSxLQUFLLEtBQUssRUFBRSxPQUFPLElBQUk7RUFDckMsTUFBTUMsQ0FBQyxHQUFHLElBQUlDLElBQUksQ0FBQyxDQUFDO0VBQ3BCLE9BQU9ELENBQUMsQ0FBQ0UsV0FBVyxDQUFDLENBQUMsS0FBSyxJQUFJLElBQUlGLENBQUMsQ0FBQ0csUUFBUSxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUlILENBQUMsQ0FBQ0ksT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQzNFO0FBRUEsT0FBTyxTQUFTQyxXQUFXQSxDQUFBLENBQUUsRUFBRSxPQUFPLENBQUM7RUFDckMsSUFBSSxVQUFVLEtBQUssS0FBSyxFQUFFLE9BQU8sSUFBSTtFQUNyQyxNQUFNTCxDQUFDLEdBQUcsSUFBSUMsSUFBSSxDQUFDLENBQUM7RUFDcEIsT0FDRUQsQ0FBQyxDQUFDRSxXQUFXLENBQUMsQ0FBQyxHQUFHLElBQUksSUFBS0YsQ0FBQyxDQUFDRSxXQUFXLENBQUMsQ0FBQyxLQUFLLElBQUksSUFBSUYsQ0FBQyxDQUFDRyxRQUFRLENBQUMsQ0FBQyxJQUFJLENBQUU7QUFFN0U7QUFFQSxTQUFBRyxZQUFBQyxFQUFBO0VBQUEsTUFBQUMsQ0FBQSxHQUFBQyxFQUFBO0VBQXFCO0lBQUFDO0VBQUEsSUFBQUgsRUFBMEI7RUFBQSxJQUFBSSxFQUFBO0VBQUEsSUFBQUgsQ0FBQSxRQUFBRSxJQUFBO0lBRTNDQyxFQUFBLEtBQ0csS0FBSUQsSUFBSSxDQUFDLENBQUFFLEdBQUksQ0FBQ0MsS0FJZCxFQUFDLEdBQ0Q7SUFBQUwsQ0FBQSxNQUFBRSxJQUFBO0lBQUFGLENBQUEsTUFBQUcsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQUgsQ0FBQTtFQUFBO0VBQUEsT0FOSEcsRUFNRztBQUFBOztBQUlQO0FBQ0E7QUFiQSxTQUFBRSxNQUFBQyxFQUFBLEVBQUFDLENBQUE7RUFBQSxPQUlRLENBQUMsSUFBSSxDQUFNQSxHQUFDLENBQURBLEVBQUEsQ0FBQyxDQUFTLEtBQWtCLENBQWxCLENBQUFqQixlQUFlLENBQUNpQixDQUFDLEVBQUMsQ0FDcENELEdBQUMsQ0FDSixFQUZDLElBQUksQ0FFRTtBQUFBO0FBUWYsT0FBTyxTQUFBRSxxQkFBQTtFQUFBLE1BQUFSLENBQUEsR0FBQUMsRUFBQTtFQUNMO0lBQUFRLGVBQUE7SUFBQUM7RUFBQSxJQUFnRHZCLGdCQUFnQixDQUFDLENBQUM7RUFBQSxJQUFBWSxFQUFBO0VBQUEsSUFBQUksRUFBQTtFQUFBLElBQUFILENBQUEsUUFBQVMsZUFBQSxJQUFBVCxDQUFBLFFBQUFVLGtCQUFBO0lBRXhEWCxFQUFBLEdBQUFBLENBQUE7TUFDUixJQUFJLENBQUNmLE9BQU8sQ0FBQyxPQUFPLENBQUM7UUFBQTtNQUFBO01BQ3JCLE1BQUEyQixNQUFBLEdBQWV0QixlQUFlLENBQUMsQ0FBQztNQUNoQyxJQUFJc0IsTUFBTSxDQUFBQyxTQUFvQyxJQUExQyxDQUFxQnJCLG1CQUFtQixDQUFDLENBQUM7UUFBQTtNQUFBO01BQzlDa0IsZUFBZSxDQUFDO1FBQUFJLEdBQUEsRUFDVCxjQUFjO1FBQUFDLEdBQUEsRUFDZCxDQUFDLFdBQVcsQ0FBTSxJQUFRLENBQVIsUUFBUSxHQUFHO1FBQUFDLFFBQUEsRUFDeEIsV0FBVztRQUFBQyxTQUFBLEVBQ1Y7TUFDYixDQUFDLENBQUM7TUFBQSxPQUNLLE1BQU1OLGtCQUFrQixDQUFDLGNBQWMsQ0FBQztJQUFBLENBQ2hEO0lBQUVQLEVBQUEsSUFBQ00sZUFBZSxFQUFFQyxrQkFBa0IsQ0FBQztJQUFBVixDQUFBLE1BQUFTLGVBQUE7SUFBQVQsQ0FBQSxNQUFBVSxrQkFBQTtJQUFBVixDQUFBLE1BQUFELEVBQUE7SUFBQUMsQ0FBQSxNQUFBRyxFQUFBO0VBQUE7SUFBQUosRUFBQSxHQUFBQyxDQUFBO0lBQUFHLEVBQUEsR0FBQUgsQ0FBQTtFQUFBO0VBWHhDZCxTQUFTLENBQUNhLEVBV1QsRUFBRUksRUFBcUMsQ0FBQztBQUFBO0FBRzNDLE9BQU8sU0FBU2MseUJBQXlCQSxDQUN2Q2YsSUFBSSxFQUFFLE1BQU0sQ0FDYixFQUFFZ0IsS0FBSyxDQUFDO0VBQUVDLEtBQUssRUFBRSxNQUFNO0VBQUVDLEdBQUcsRUFBRSxNQUFNO0FBQUMsQ0FBQyxDQUFDLENBQUM7RUFDdkMsSUFBSSxDQUFDcEMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLE9BQU8sRUFBRTtFQUNoQyxNQUFNcUMsUUFBUSxFQUFFSCxLQUFLLENBQUM7SUFBRUMsS0FBSyxFQUFFLE1BQU07SUFBRUMsR0FBRyxFQUFFLE1BQU07RUFBQyxDQUFDLENBQUMsR0FBRyxFQUFFO0VBQzFELE1BQU1FLEVBQUUsR0FBRyxZQUFZO0VBQ3ZCLElBQUlDLENBQUMsRUFBRUMsZUFBZSxHQUFHLElBQUk7RUFDN0IsT0FBTyxDQUFDRCxDQUFDLEdBQUdELEVBQUUsQ0FBQ0csSUFBSSxDQUFDdkIsSUFBSSxDQUFDLE1BQU0sSUFBSSxFQUFFO0lBQ25DbUIsUUFBUSxDQUFDSyxJQUFJLENBQUM7TUFBRVAsS0FBSyxFQUFFSSxDQUFDLENBQUNJLEtBQUs7TUFBRVAsR0FBRyxFQUFFRyxDQUFDLENBQUNJLEtBQUssR0FBR0osQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDSztJQUFPLENBQUMsQ0FBQztFQUMvRDtFQUNBLE9BQU9QLFFBQVE7QUFDakIiLCJpZ25vcmVMaXN0IjpbXX0=

src/commands/buddy/buddy.ts

@@ -1,283 +1,169 @@
-import type { LocalCommandCall } from '../../types/command.js'
-import { companionUserId, getCompanion, roll } from '../../buddy/companion.js'
-import type { Species, StoredCompanion } from '../../buddy/types.js'
-import { RARITY_STARS } from '../../buddy/types.js'
-import { saveGlobalConfig } from '../../utils/config.js'
-
-const NAME_BANK: Record<Species, string[]> = {
-  duck: ['Pebble', 'Puddle', 'Nib', 'Mochi'],
-  goose: ['Brass', 'Comet', 'Honk', 'Marble'],
-  blob: ['Gloop', 'Boba', 'Murmur', 'Pixel'],
-  cat: ['Juniper', 'Miso', 'Static', 'Velvet'],
-  dragon: ['Ember', 'Cinder', 'Rune', 'Flare'],
-  octopus: ['Ink', 'Tangle', 'Coral', 'Nori'],
-  owl: ['Sumi', 'Orbit', 'Mote', 'Aster'],
-  penguin: ['Tux', 'Floe', 'Skipper', 'Chill'],
-  turtle: ['Moss', 'Harbor', 'Slate', 'Ripple'],
-  snail: ['Spiral', 'Dew', 'Button', 'Lilt'],
-  ghost: ['Wisp', 'Echo', 'Pale', 'Veil'],
-  axolotl: ['Bubble', 'Glim', 'Lotus', 'Sprig'],
-  capybara: ['Loaf', 'Basil', 'Drift', 'Sunny'],
-  cactus: ['Prickle', 'Agave', 'Dot', 'Needle'],
-  robot: ['Servo', 'Hex', 'Patch', 'Relay'],
-  rabbit: ['Thistle', 'Biscuit', 'Hopper', 'Fern'],
-  mushroom: ['Spore', 'Truffle', 'Pip', 'Toad'],
-  chonk: ['Boulder', 'Nugget', 'Mallow', 'Crumb'],
-}
-
-const PERSONALITY_BANK = [
-  'calm, observant, and quietly approving',
-  'chaotic, affectionate, and slightly smug',
-  'earnest, curious, and proud of tiny victories',
-  'sleepy, loyal, and unexpectedly insightful',
-  'dramatic, playful, and obsessed with good refactors',
-]
-
-const PET_LINES = [
-  'leans into the petting and radiates approval.',
-  'does a tiny bounce and looks extremely pleased.',
-  'blinks slowly like this is now an official ritual.',
-  'makes a happy little noise only you can hear.',
-]
-
-function pickFrom<T>(items: readonly T[], seed: number): T {
-  return items[seed % items.length]!
-}
-
-function normalizeName(name: string): string {
-  const trimmed = name.trim().replace(/\s+/g, ' ')
-  return trimmed.slice(0, 32)
-}
-
-function createSoul(customName?: string): StoredCompanion {
-  const { bones, inspirationSeed } = roll(companionUserId())
-  return {
-    name: customName
-      ? normalizeName(customName)
-      : pickFrom(NAME_BANK[bones.species], inspirationSeed),
-    personality: pickFrom(PERSONALITY_BANK, Math.floor(inspirationSeed / 7)),
-    hatchedAt: Date.now(),
-  }
-}
-
-function persistCompanion(soul: StoredCompanion): void {
-  saveGlobalConfig(current => ({
-    ...current,
-    companion: soul,
-    companionMuted: false,
-  }))
-}
-
-function renderCompanionStatus(): string {
-  const companion = getCompanion()
-  if (!companion) {
-    return 'No buddy yet. Run /buddy or /buddy hatch to summon one.'
-  }
-
-  const stats = Object.entries(companion.stats)
-    .map(([name, value]) => `${name}:${value}`)
-    .join(' ')
-
-  return [
-    `${RARITY_STARS[companion.rarity]} ${companion.name} the ${companion.species}`,
-    `eyes ${companion.eye} · hat ${companion.hat} · shiny ${companion.shiny ? 'yes' : 'no'}`,
-    `personality: ${companion.personality}`,
-    `stats: ${stats}`,
-  ].join('\n')
-}
-
-function setReaction(
-  context: Parameters<LocalCommandCall>[1],
-  reaction: string | undefined,
-): void {
-  context.setAppState(prev =>
-    prev.companionReaction === reaction
-      ? prev
-      : { ...prev, companionReaction: reaction },
-  )
+import React from 'react'
+import {
+  getCompanion,
+  rollWithSeed,
+  generateSeed,
+} from '../../buddy/companion.js'
+import { type StoredCompanion, RARITY_STARS } from '../../buddy/types.js'
+import { renderSprite } from '../../buddy/sprites.js'
+import { CompanionCard } from '../../buddy/CompanionCard.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+import { triggerCompanionReaction } from '../../buddy/companionReact.js'
+import type { ToolUseContext } from '../../Tool.js'
+import type {
+  LocalJSXCommandContext,
+  LocalJSXCommandOnDone,
+} from '../../types/command.js'
+
+// Species → default name fragments for hatch (no API needed)
+const SPECIES_NAMES: Record<string, string> = {
+  duck: 'Waddles',
+  goose: 'Goosberry',
+  blob: 'Gooey',
+  cat: 'Whiskers',
+  dragon: 'Ember',
+  octopus: 'Inky',
+  owl: 'Hoots',
+  penguin: 'Waddleford',
+  turtle: 'Shelly',
+  snail: 'Trailblazer',
+  ghost: 'Casper',
+  axolotl: 'Axie',
+  capybara: 'Chill',
+  cactus: 'Spike',
+  robot: 'Byte',
+  rabbit: 'Flops',
+  mushroom: 'Spore',
+  chonk: 'Chonk',
 }
 
-function hatch(context: Parameters<LocalCommandCall>[1], customName?: string) {
-  const soul = createSoul(customName)
-  persistCompanion(soul)
-  const companion = getCompanion()
-  const reaction = companion
-    ? `${companion.name} appears with a tiny ${companion.hat === 'none' ? 'flourish' : companion.hat}.`
-    : undefined
-  setReaction(context, reaction)
-  return companion
+const SPECIES_PERSONALITY: Record<string, string> = {
+  duck: 'Quirky and easily amused. Leaves rubber duck debugging tips everywhere.',
+  goose: 'Assertive and honks at bad code. Takes no prisoners in code reviews.',
+  blob: 'Adaptable and goes with the flow. Sometimes splits into two when confused.',
+  cat: 'Independent and judgmental. Watches you type with mild disdain.',
+  dragon:
+    'Fiery and passionate about architecture. Hoards good variable names.',
+  octopus:
+    'Multitasker extraordinaire. Wraps tentacles around every problem at once.',
+  owl: 'Wise but verbose. Always says "let me think about that" for exactly 3 seconds.',
+  penguin: 'Cool under pressure. Slides gracefully through merge conflicts.',
+  turtle: 'Patient and thorough. Believes slow and steady wins the deploy.',
+  snail: 'Methodical and leaves a trail of useful comments. Never rushes.',
+  ghost:
+    'Ethereal and appears at the worst possible moments with spooky insights.',
+  axolotl: 'Regenerative and cheerful. Recovers from any bug with a smile.',
+  capybara: 'Zen master. Remains calm while everything around is on fire.',
+  cactus:
+    'Prickly on the outside but full of good intentions. Thrives on neglect.',
+  robot: 'Efficient and literal. Processes feedback in binary.',
+  rabbit: 'Energetic and hops between tasks. Finishes before you start.',
+  mushroom: 'Quietly insightful. Grows on you over time.',
+  chonk:
+    'Big, warm, and takes up the whole couch. Prioritizes comfort over elegance.',
 }
 
-function ensureCompanion(): string | undefined {
-  if (!getCompanion()) {
-    return 'No buddy yet. Run /buddy or /buddy hatch first.'
-  }
+function speciesLabel(species: string): string {
+  return species.charAt(0).toUpperCase() + species.slice(1)
 }
 
-export const call: LocalCommandCall = async (args, context) => {
-  const raw = args.trim()
-  const [action = '', ...rest] = raw.split(/\s+/)
-  const normalizedAction = action.toLowerCase()
-  const remainder = raw.slice(action.length).trim()
-
-  if (normalizedAction === '' || normalizedAction === 'status') {
-    if (!getCompanion()) {
-      const companion = hatch(context)
-      return {
-        type: 'text',
-        value: companion
-          ? `Hatched ${companion.name}.\n${renderCompanionStatus()}`
-          : 'Buddy hatched.',
-      }
+export async function call(
+  onDone: LocalJSXCommandOnDone,
+  context: ToolUseContext & LocalJSXCommandContext,
+  args: string,
+): Promise<React.ReactNode> {
+  const sub = args?.trim().toLowerCase() ?? ''
+  const setState = context.setAppState
+
+  // ── /buddy off — mute companion ──
+  if (sub === 'off') {
+    saveGlobalConfig(cfg => ({ ...cfg, companionMuted: true }))
+    onDone('companion muted', { display: 'system' })
+    return null
+  }
+
+  // ── /buddy on — unmute companion ──
+  if (sub === 'on') {
+    saveGlobalConfig(cfg => ({ ...cfg, companionMuted: false }))
+    onDone('companion unmuted', { display: 'system' })
+    return null
+  }
+
+  // ── /buddy pet — trigger heart animation + auto unmute ──
+  if (sub === 'pet') {
+    const companion = getCompanion()
+    if (!companion) {
+      onDone('no companion yet \u00b7 run /buddy first', { display: 'system' })
+      return null
     }
-    return { type: 'text', value: renderCompanionStatus() }
-  }
-
-  if (normalizedAction === 'hatch') {
-    const customName = remainder
-    const existing = getCompanion()
-    if (existing) {
-      return {
-        type: 'text',
-        value: `Buddy already hatched.\n${renderCompanionStatus()}`,
-      }
-    }
-    const companion = hatch(context, customName || undefined)
-    return {
-      type: 'text',
-      value: companion
-        ? `Hatched ${companion.name}.\n${renderCompanionStatus()}`
-        : 'Buddy hatched.',
-    }
-  }
-
-  if (normalizedAction === 'pet') {
-    const missing = ensureCompanion()
-    if (missing) return { type: 'text', value: missing }
-    const companion = getCompanion()!
-    const petSeed = Date.now()
-    const line = pickFrom(PET_LINES, petSeed)
-    context.setAppState(prev => ({
-      ...prev,
-      companionPetAt: petSeed,
-      companionReaction: `${companion.name} ${line}`,
-    }))
-    return {
-      type: 'text',
-      value: `${companion.name} ${line}`,
-    }
-  }
 
-  if (normalizedAction === 'mute') {
-    const missing = ensureCompanion()
-    if (missing) return { type: 'text', value: missing }
-    saveGlobalConfig(current => ({ ...current, companionMuted: true }))
-    setReaction(context, undefined)
-    return { type: 'text', value: 'Buddy muted.' }
-  }
+    // Auto-unmute on pet + trigger heart animation
+    saveGlobalConfig(cfg => ({ ...cfg, companionMuted: false }))
+    setState?.(prev => ({ ...prev, companionPetAt: Date.now() }))
 
-  if (normalizedAction === 'unmute') {
-    const missing = ensureCompanion()
-    if (missing) return { type: 'text', value: missing }
-    saveGlobalConfig(current => ({ ...current, companionMuted: false }))
-    return { type: 'text', value: 'Buddy unmuted.' }
-  }
+    // Trigger a post-pet reaction
+    triggerCompanionReaction(context.messages ?? [], reaction =>
+      setState?.(prev =>
+        prev.companionReaction === reaction
+          ? prev
+          : { ...prev, companionReaction: reaction },
+      ),
+    )
 
-  if (normalizedAction === 'rename' || normalizedAction === 'name') {
-    const missing = ensureCompanion()
-    if (missing) return { type: 'text', value: missing }
-    const nextName = normalizeName(remainder)
-    if (!nextName) {
-      return { type: 'text', value: 'Usage: /buddy rename <name>' }
-    }
-    saveGlobalConfig(current => ({
-      ...current,
-      companion: current.companion
-        ? { ...current.companion, name: nextName }
-        : current.companion,
-    }))
-    setReaction(context, `${nextName} accepts the rename with theatrical dignity.`)
-    return { type: 'text', value: `Buddy renamed to ${nextName}.` }
+    onDone(`petted ${companion.name}`, { display: 'system' })
+    return null
   }
 
-  if (
-    normalizedAction === 'bio' ||
-    normalizedAction === 'persona' ||
-    normalizedAction === 'personality'
-  ) {
-    const missing = ensureCompanion()
-    if (missing) return { type: 'text', value: missing }
-    if (!remainder) {
-      return {
-        type: 'text',
-        value: 'Usage: /buddy bio <short personality line>',
-      }
-    }
-    const personality = remainder.slice(0, 160)
-    saveGlobalConfig(current => ({
-      ...current,
-      companion: current.companion
-        ? { ...current.companion, personality }
-        : current.companion,
-    }))
-    const companion = getCompanion()!
-    setReaction(context, `${companion.name} seems pleased with the new reputation.`)
-    return { type: 'text', value: `Buddy personality updated to: ${personality}` }
-  }
+  // ── /buddy (no args) — show existing or hatch ──
+  const companion = getCompanion()
 
-  if (normalizedAction === 'react' || normalizedAction === 'say') {
-    const missing = ensureCompanion()
-    if (missing) return { type: 'text', value: missing }
-    if (!remainder) {
-      return { type: 'text', value: 'Usage: /buddy react <message>' }
-    }
-    setReaction(context, remainder.slice(0, 120))
-    return { type: 'text', value: 'Buddy reaction queued.' }
+  // Auto-unmute when viewing
+  if (companion && getGlobalConfig().companionMuted) {
+    saveGlobalConfig(cfg => ({ ...cfg, companionMuted: false }))
   }
 
-  if (normalizedAction === 'dismiss' || normalizedAction === 'hide') {
-    setReaction(context, undefined)
-    return { type: 'text', value: 'Buddy bubble dismissed.' }
+  if (companion) {
+    // Return JSX card — matches official vc8 component
+    const lastReaction = context.getAppState?.()?.companionReaction
+    return React.createElement(CompanionCard, {
+      companion,
+      lastReaction,
+      onDone,
+    })
   }
 
-  if (normalizedAction === 'reset') {
-    saveGlobalConfig(current => ({
-      ...current,
-      companion: undefined,
-      companionMuted: false,
-    }))
-    context.setAppState(prev => ({
-      ...prev,
-      companionReaction: undefined,
-      companionPetAt: undefined,
-    }))
-    return {
-      type: 'text',
-      value: 'Buddy reset. Run /buddy to hatch a fresh companion.',
-    }
-  }
+  // ── No companion → hatch ──
+  const seed = generateSeed()
+  const r = rollWithSeed(seed)
+  const name = SPECIES_NAMES[r.bones.species] ?? 'Buddy'
+  const personality =
+    SPECIES_PERSONALITY[r.bones.species] ?? 'Mysterious and code-savvy.'
 
-  if (normalizedAction === 'help') {
-    return {
-      type: 'text',
-      value:
-        'Usage: /buddy, /buddy status, /buddy hatch [name], /buddy pet, /buddy rename <name>, /buddy bio <text>, /buddy mute, /buddy unmute, /buddy dismiss, /buddy react <text>, /buddy reset',
-    }
-  }
-
-  if (rest.length === 0 && !getCompanion()) {
-    const companion = hatch(context, raw)
-    return {
-      type: 'text',
-      value: companion
-        ? `Hatched ${companion.name}.\n${renderCompanionStatus()}`
-        : 'Buddy hatched.',
-    }
+  const stored: StoredCompanion = {
+    name,
+    personality,
+    seed,
+    hatchedAt: Date.now(),
   }
 
-  return {
-    type: 'text',
-    value:
-      'Unknown /buddy action. Use /buddy help for available actions.',
-  }
+  saveGlobalConfig(cfg => ({ ...cfg, companion: stored }))
+
+  const stars = RARITY_STARS[r.bones.rarity]
+  const sprite = renderSprite(r.bones, 0)
+  const shiny = r.bones.shiny ? ' \u2728 Shiny!' : ''
+
+  const lines = [
+    'A wild companion appeared!',
+    '',
+    ...sprite,
+    '',
+    `${name} the ${speciesLabel(r.bones.species)}${shiny}`,
+    `Rarity: ${stars} (${r.bones.rarity})`,
+    `"${personality}"`,
+    '',
+    'Your companion will now appear beside your input box!',
+    'Say its name to get its take \u00b7 /buddy pet \u00b7 /buddy off',
+  ]
+  onDone(lines.join('\n'), { display: 'system' })
+  return null
 }

src/commands/buddy/index.ts

@@ -1,12 +1,15 @@
 import type { Command } from '../../commands.js'
+import { isBuddyLive } from '../../buddy/useBuddyNotification.js'
 
 const buddy = {
-  type: 'local',
+  type: 'local-jsx',
   name: 'buddy',
-  description: 'Hatch and manage your companion',
-  supportsNonInteractive: false,
-  argumentHint:
-    '[status|hatch [name]|pet|rename <name>|bio <text>|mute|unmute|dismiss|reset]',
+  description: 'Hatch a coding companion · pet, off',
+  argumentHint: '[pet|off]',
+  immediate: true,
+  get isHidden() {
+    return !isBuddyLive()
+  },
   load: () => import('./buddy.js'),
 } satisfies Command
 

src/screens/REPL.tsx

@@ -276,7 +276,7 @@ const launchUltraplan: typeof import('../commands/ultraplan.js').launchUltraplan
 /* eslint-enable @typescript-eslint/no-require-imports */
 import { IssueFlagBanner } from '../components/PromptInput/IssueFlagBanner.js';
 import { useIssueFlagBanner } from '../hooks/useIssueFlagBanner.js';
-import { fireCompanionObserver } from '../buddy/observer.js';
+import { triggerCompanionReaction } from '../buddy/companionReact.js';
 import { CompanionSprite, CompanionFloatingBubble, MIN_COLS_FOR_FULL_SPRITE } from '../buddy/CompanionSprite.js';
 import { DevBar } from '../components/DevBar.js';
 // Session manager removed - using AppState now
@@ -2806,7 +2806,7 @@ export function REPL({
       onQueryEvent(event);
     }
     if (feature('BUDDY')) {
-      void fireCompanionObserver(messagesRef.current, reaction => setAppState(prev => prev.companionReaction === reaction ? prev : {
+      void triggerCompanionReaction(messagesRef.current, reaction => setAppState(prev => prev.companionReaction === reaction ? prev : {
         ...prev,
         companionReaction: reaction
       }));