@linxin666/dsh-pet 0.1.20 → 0.2.0

package/src/client/pet.module.css

@@ -37,13 +37,58 @@
   background: rgba(56, 189, 248, 0.92);
 }
 
+/* 状态气泡：深色渐变玻璃 + 青色描边辉光 + 进场浮现，
+   让工作汇报从“标签”升级为“会呼吸的状态条”。 */
 .bubbleStatus {
   max-width: min(280px, calc(100vw - 24px));
   overflow: hidden;
   text-overflow: ellipsis;
-  background: rgba(15, 23, 42, 0.9);
-  border: 1px solid rgba(125, 211, 252, 0.5);
-  animation: none;
+  background: linear-gradient(160deg, rgba(30, 41, 59, 0.88), rgba(15, 23, 42, 0.92));
+  border: 1px solid rgba(125, 211, 252, 0.55);
+  box-shadow:
+    0 4px 14px rgba(2, 6, 23, 0.4),
+    0 0 0 1px rgba(125, 211, 252, 0.12),
+    0 0 18px rgba(56, 189, 248, 0.18);
+  backdrop-filter: blur(8px);
+  letter-spacing: 0.02em;
+  animation: pet-bubble-in 240ms ease-out;
+}
+
+/* 碎碎念气泡：宠物的内心悄悄话。紫粉渐变玻璃、虚线描边与斜体，
+   配合「」引号，与青色的工作状态气泡一眼区分；不可点击、自动消散。 */
+.bubbleWhisper {
+  position: relative;
+  max-width: min(260px, calc(100vw - 24px));
+  padding: 4px 12px;
+  border-radius: 999px;
+  font-size: 11.5px;
+  font-style: italic;
+  line-height: 1.45;
+  letter-spacing: 0.03em;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  color: #f5d0fe;
+  background: linear-gradient(150deg, rgba(88, 28, 135, 0.52), rgba(157, 23, 77, 0.44));
+  border: 1px dashed rgba(240, 171, 252, 0.55);
+  box-shadow:
+    0 3px 12px rgba(46, 16, 101, 0.4),
+    0 0 14px rgba(217, 70, 239, 0.16);
+  backdrop-filter: blur(8px);
+  pointer-events: none;
+  animation: pet-whisper-in 320ms cubic-bezier(0.22, 1, 0.36, 1);
+}
+
+.bubbleWhisper::before {
+  content: '「';
+  margin-right: 2px;
+  opacity: 0.75;
+}
+
+.bubbleWhisper::after {
+  content: '」';
+  margin-left: 2px;
+  opacity: 0.75;
 }
 
 /* 多会话气泡栈：并行会话各自一个气泡，自精灵头顶向上堆叠，
@@ -84,6 +129,42 @@
   box-shadow: 0 0 0 2px rgba(56, 189, 248, 0.85);
 }
 
+@keyframes pet-bubble-in {
+  from {
+    opacity: 0;
+    transform: translateY(6px) scale(0.96);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+@keyframes pet-whisper-in {
+  0% {
+    opacity: 0;
+    transform: translateY(8px) scale(0.9);
+  }
+  60% {
+    transform: translateY(-1px) scale(1.02);
+  }
+  100% {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+@keyframes pet-panel-in {
+  from {
+    opacity: 0;
+    transform: translateY(4px) scale(0.97);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
 @keyframes pet-bubble-pop {
   0% {
     opacity: 0;
@@ -105,39 +186,56 @@
   }
 }
 
-/* 悬浮面板位于精灵左侧（bottom 对齐），不再占据精灵上方的空间：
+/* 悬浮面板默认位于精灵脚下，不再占据精灵上方的空间：
    会话气泡栈独占精灵头顶区域，两者互不遮挡 —— 气泡因此可以始终
-   显示并保持可点击，不必在 hover 时让位给面板。 */
+   显示并保持可点击，不必在 hover 时让位给面板。仅当视口底部空间
+   不足时，面板才回退到精灵上方。 */
 .panel {
   position: absolute;
-  bottom: 0;
-  right: 100%;
-  margin-right: 8px;
-  background: rgba(15, 23, 42, 0.92);
-  border: 1px solid rgba(148, 163, 184, 0.35);
-  border-radius: 10px;
-  padding: 8px 10px;
+  top: 100%;
+  margin-top: 8px;
+  background: linear-gradient(165deg, rgba(30, 41, 59, 0.94), rgba(15, 23, 42, 0.96));
+  border: 1px solid rgba(148, 163, 184, 0.4);
+  border-radius: 12px;
+  padding: 10px 12px;
   color: #e2e8f0;
   font-size: 12px;
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.35);
-  backdrop-filter: blur(6px);
+  box-shadow:
+    0 8px 24px rgba(2, 6, 23, 0.45),
+    0 0 0 1px rgba(125, 211, 252, 0.08),
+    inset 0 1px 0 rgba(226, 232, 240, 0.08);
+  backdrop-filter: blur(10px);
   display: flex;
   flex-direction: column;
-  gap: 6px;
-  min-width: 132px;
+  gap: 7px;
+  min-width: 148px;
+  animation: pet-panel-in 200ms cubic-bezier(0.22, 1, 0.36, 1);
+  transform-origin: 50% 0;
 }
 
-/* 面板右缘与图标左缘之间的 hover 桥接（issue #49 的水平版）：
-   面板在图标左侧留有 8px 间隙，指针滑过间隙时会触发容器的
-   pointerleave，面板会在指针抵达按钮前收起。这段透明伪元素把命中区
-   向右延伸、覆盖间隙，使指针在图标与按钮之间始终停留在 hover 区域。 */
+/* 面板顶边与精灵底边之间的 hover 桥接（issue #49）：
+   面板在精灵下方留有 8px 间隙，透明伪元素向上覆盖间隙，
+   使指针在精灵与按钮之间始终停留在 hover 区域。 */
 .panel::after {
   content: '';
   position: absolute;
-  top: 0;
-  bottom: 0;
-  left: 100%;
-  width: 14px;
+  bottom: 100%;
+  left: 0;
+  right: 0;
+  height: 14px;
+}
+
+.panelAbove {
+  top: auto;
+  bottom: 100%;
+  margin-top: 0;
+  margin-bottom: 8px;
+  transform-origin: 50% 100%;
+}
+
+.panelAbove::after {
+  top: 100%;
+  bottom: auto;
 }
 
 .rankRow {
@@ -149,6 +247,28 @@
 
 .nameCell {
   font-weight: 600;
+  letter-spacing: 0.02em;
+  background: linear-gradient(90deg, #7dd3fc, #38bdf8 60%, #818cf8);
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+}
+
+/* 面板数值的专属配色：称号紫、小鱼干青、亲密度琥珀，
+   让两行数据扫一眼就能分辨。 */
+.statRank {
+  color: #c4b5fd;
+  font-weight: 600;
+}
+
+.statTreats {
+  color: #7dd3fc;
+  font-weight: 600;
+}
+
+.statPoints {
+  color: #fcd34d;
+  font-weight: 600;
 }
 
 .renameRow {
@@ -189,15 +309,20 @@
   cursor: pointer;
   color: #0f172a;
   background: linear-gradient(180deg, #7dd3fc, #38bdf8);
-  transition: filter 120ms ease, box-shadow 120ms ease;
+  box-shadow: 0 2px 6px rgba(56, 189, 248, 0.25);
+  transition: filter 120ms ease, box-shadow 120ms ease, transform 120ms ease;
 }
 
 .action:hover {
   filter: brightness(1.08);
+  transform: translateY(-1px);
+  box-shadow: 0 4px 10px rgba(56, 189, 248, 0.35);
 }
 
 .action:active {
   filter: brightness(0.94);
+  transform: translateY(0);
+  box-shadow: 0 1px 4px rgba(56, 189, 248, 0.25);
 }
 
 .action:focus-visible {
@@ -238,7 +363,10 @@
 /* Reduced motion: freeze the reaction bubble and kill the overlay transitions
    so the pet's motion is static or minimal without hiding interaction. */
 @media (prefers-reduced-motion: reduce) {
-  .bubble {
+  .bubble,
+  .bubbleStatus,
+  .bubbleWhisper,
+  .panel {
     animation: none;
     opacity: 1;
   }

package/src/client/sequences.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+import type { PetTrackDef } from '../registry.ts'
+import type { PetAnimation } from '../state.ts'
+import { sequenceFrameAt } from './sequences.ts'
+
+const track = (durations: number[]): PetTrackDef => ({
+  frames: durations.map((_, index) => index),
+  durations,
+  loop: true,
+})
+
+const tracks = {
+  running: track([100, 200]),
+  waiting: track([300, 100]),
+} as Record<PetAnimation, PetTrackDef>
+
+describe('sequenceFrameAt', () => {
+  const sequence: PetAnimation[] = ['running', 'waiting']
+
+  it('finishes every frame of one track before advancing', () => {
+    expect(sequenceFrameAt(sequence, tracks, 0)).toEqual({ animation: 'running', frameIndex: 0 })
+    expect(sequenceFrameAt(sequence, tracks, 100)).toEqual({ animation: 'running', frameIndex: 1 })
+    expect(sequenceFrameAt(sequence, tracks, 299)).toEqual({ animation: 'running', frameIndex: 1 })
+    expect(sequenceFrameAt(sequence, tracks, 300)).toEqual({ animation: 'waiting', frameIndex: 0 })
+    expect(sequenceFrameAt(sequence, tracks, 600)).toEqual({ animation: 'waiting', frameIndex: 1 })
+  })
+
+  it('loops the whole sequence and preserves overshoot', () => {
+    expect(sequenceFrameAt(sequence, tracks, 700)).toEqual({ animation: 'running', frameIndex: 0 })
+    expect(sequenceFrameAt(sequence, tracks, 850)).toEqual({ animation: 'running', frameIndex: 1 })
+    expect(sequenceFrameAt(sequence, tracks, 1_420)).toEqual({ animation: 'running', frameIndex: 0 })
+  })
+})

package/src/client/sequences.ts

@@ -0,0 +1,33 @@
+/** Pure timing helpers for manifest-defined scene animation sequences. */
+
+import type { PetTrackDef } from '../registry.ts'
+import type { PetAnimation } from '../state.ts'
+
+export interface SequenceFrame {
+  animation: PetAnimation
+  frameIndex: number
+}
+
+/** Resolve the active track and frame after elapsed milliseconds of a looping sequence. */
+export function sequenceFrameAt(
+  sequence: readonly PetAnimation[],
+  tracks: Record<PetAnimation, PetTrackDef>,
+  elapsedMs: number,
+): SequenceFrame {
+  const itemDurations = sequence.map(animation => tracks[animation].durations.reduce((sum, value) => sum + value, 0))
+  const sequenceDuration = itemDurations.reduce((sum, value) => sum + value, 0)
+  let offset = Math.max(0, elapsedMs) % sequenceDuration
+  let itemIndex = 0
+  while (itemIndex < sequence.length - 1 && offset >= itemDurations[itemIndex]!) {
+    offset -= itemDurations[itemIndex]!
+    itemIndex += 1
+  }
+  const animation = sequence[itemIndex]!
+  const track = tracks[animation]
+  let frameIndex = 0
+  while (frameIndex < track.frames.length - 1 && offset >= track.durations[frameIndex]!) {
+    offset -= track.durations[frameIndex]!
+    frameIndex += 1
+  }
+  return { animation, frameIndex }
+}

package/src/event-projection.ts

@@ -3,11 +3,17 @@
  * vocabulary onto the pet's visual phases and carries an optional completed-
  * turn reward for the ledger. Holds no state of its own; callers keep a
  * {@link ProjectionRuntime} per session and feed events in arrival order.
+ *
+ * Status copy comes from the chatter voice (big rotating pools, per-tool
+ * families, real-argument hints), and streamed model output feeds the murmur
+ * engine so the pet can whisper its inner voice (碎碎念). The wall clock is
+ * injected by the caller, keeping every projection reproducible.
  * @module @linxin666/dsh-pet/event-projection
  */
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import type { PetStateInput } from './state.ts'
+import { StatusVoice, toolArgHint, WhisperEngine } from './chatter.ts'
 
 /** Runtime shape of the optional legacy activity event. */
 export interface ActivityStatusEventLike {
@@ -21,23 +27,35 @@ export interface ProjectionRuntime {
   activeTools: Set<string>
   officialEventsSeen: boolean
   stepHadFailure: boolean
+  /** Round-robin status copy voice (scene-stable, cadence-rotated). */
+  voice: StatusVoice
+  /** Inner-whisper engine fed by the model's own streamed output. */
+  whispers: WhisperEngine
 }
 
 /** One official event projection, optionally carrying a completed turn reward. */
 export interface PetActivityTransition {
   input: PetStateInput
   completedTurn?: number
+  /** A fresh inner whisper woken by this event's model output, when any. */
+  whisper?: string
 }
 
 /** Fresh projection runtime for a newly seen session. */
 export function emptyProjectionRuntime(): ProjectionRuntime {
-  return { activeTools: new Set(), officialEventsSeen: false, stepHadFailure: false }
+  return {
+    activeTools: new Set(),
+    officialEventsSeen: false,
+    stepHadFailure: false,
+    voice: new StatusVoice(),
+    whispers: new WhisperEngine(),
+  }
 }
 
 /** Keep tool names readable inside the compact status bubble. */
 function displayToolName(name: string): string {
   const compact = name.replace(/\s+/g, ' ').trim() || '工具'
-  return compact.length <= 24 ? compact : `${compact.slice(0, 21)}...`
+  return compact.length <= 24 ? compact : compact.slice(0, 21) + '...'
 }
 
 /** Whether a legacy phase is part of the pet's supported vocabulary. */
@@ -48,38 +66,53 @@ export function isActivityPhase(phase: string): phase is PetStateInput['phase']
 /**
  * Project the durable DSH session vocabulary into the pet's visual phases.
  * Unknown and log-only events do not disturb the last meaningful activity.
+ * @param nowMs - injected wall clock for copy rotation and whisper pacing.
  */
 export function projectOfficialEvent(
   event: SessionEvent,
   runtime: ProjectionRuntime,
+  nowMs: number = Date.now(),
 ): PetActivityTransition | undefined {
   switch (event.type) {
     case 'turn/start':
       runtime.activeTools.clear()
       runtime.stepHadFailure = false
-      return { input: { phase: 'waiting', line: '准备开始' } }
+      return { input: { phase: 'waiting', line: runtime.voice.scene('prepare', nowMs) } }
     case 'step/start':
       runtime.activeTools.clear()
       runtime.stepHadFailure = false
-      return { input: { phase: 'waiting', line: '等待模型响应' } }
+      return { input: { phase: 'waiting', line: runtime.voice.scene('waiting', nowMs) } }
     case 'assistant/chunk': {
       const { chunk } = event.data
       if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
-        return { input: { phase: 'thinking', line: '正在思考' } }
+        const whisper = runtime.whispers.feed(chunk.text, nowMs)
+        return {
+          input: { phase: 'thinking', line: runtime.voice.scene('thinking', nowMs) },
+          ...(whisper === undefined ? {} : { whisper }),
+        }
       }
       if (chunk.type === 'text-delta' && chunk.text.length > 0) {
-        return { input: { phase: 'review', line: '整理回复中' } }
+        const whisper = runtime.whispers.feed(chunk.text, nowMs)
+        return {
+          input: { phase: 'review', line: runtime.voice.scene('review', nowMs) },
+          ...(whisper === undefined ? {} : { whisper }),
+        }
       }
       return undefined
     }
     case 'assistant/message':
-      return { input: { phase: 'review', line: '整理回复中' } }
+      return { input: { phase: 'review', line: runtime.voice.scene('review', nowMs) } }
     case 'tool/call':
       runtime.activeTools.add(String(event.data.callId))
       return {
         input: {
           phase: 'tool',
-          line: `正在使用 ${displayToolName(event.data.name)}`,
+          line: runtime.voice.tool(
+            event.data.name,
+            displayToolName(event.data.name),
+            toolArgHint(event.data.name, event.data.arguments),
+            nowMs,
+          ),
         },
       }
     case 'tool/result': {
@@ -90,30 +123,30 @@ export function projectOfficialEvent(
         return {
           input: {
             phase: 'tool',
-            line: `还有 ${runtime.activeTools.size} 个工具运行中`,
+            line: runtime.voice.toolRemaining(runtime.activeTools.size, nowMs),
           },
         }
       }
       return runtime.stepHadFailure
-        ? { input: { phase: 'failed', line: '工具执行失败' } }
-        : { input: { phase: 'thinking', line: '处理工具结果' } }
+        ? { input: { phase: 'failed', line: runtime.voice.scene('toolFailed', nowMs) } }
+        : { input: { phase: 'thinking', line: runtime.voice.scene('toolResult', nowMs) } }
     }
     case 'turn/end': {
       runtime.activeTools.clear()
       switch (event.data.reason.kind) {
         case 'completed':
           return {
-            input: { phase: 'done', line: '完成啦' },
+            input: { phase: 'done', line: runtime.voice.scene('done', nowMs) },
             completedTurn: event.data.turn,
           }
         case 'error':
-          return { input: { phase: 'failed', line: '执行失败' } }
+          return { input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) } }
         case 'max-tokens':
-          return { input: { phase: 'failed', line: '达到输出上限' } }
+          return { input: { phase: 'failed', line: runtime.voice.scene('maxTokens', nowMs) } }
         case 'interrupted':
-          return { input: { phase: 'failed', line: '执行意外中断' } }
+          return { input: { phase: 'failed', line: runtime.voice.scene('interrupted', nowMs) } }
         case 'blocked':
-          return { input: { phase: 'waiting', line: '等待继续' } }
+          return { input: { phase: 'waiting', line: runtime.voice.scene('blocked', nowMs) } }
         case 'aborted':
           // A stopped session settles to idle without a bubble: the pet
           // visibly calms down and the session drops out of the bubble stack.

package/src/ledger.test.ts

@@ -3,6 +3,7 @@ import { defaultTreatConfig } from './treats.ts'
 import { defaultAffinityConfig } from './affinity.ts'
 import { emptyPersist } from './persist.ts'
 import { PetLedger } from './ledger.ts'
+import { BUILTIN_REMARKS } from './remarks.ts'
 
 describe('PetLedger', () => {
   it('settles the economy on completed turns (work treat per 30 turns)', () => {
@@ -66,13 +67,53 @@ describe('PetLedger', () => {
     expect(ledger.interact('feed', n + 2).reaction).toBe('没有小鱼干了，多陪我工作一会儿吧～')
   })
 
+  it('selects success remarks from persisted lifetime interaction counts', () => {
+    const n = 1_000_000
+    const persist = emptyPersist()
+    persist.affinity.pets = 1
+    persist.affinity.feeds = 1
+    persist.treats.treats = 1
+    persist.treats.lastTreatGrantAt = n
+    const ledger = new PetLedger(persist, {
+      remarks: {
+        pet: ['摸头一', '摸头二'],
+        feed: ['喂食一', '喂食二'],
+      },
+    })
+    expect(ledger.interact('pet', n).reaction).toBe('摸头二')
+    expect(ledger.interact('feed', n).reaction).toBe('喂食二')
+  })
+
+  it('rotates cooldown remarks by persisted rejection counts', () => {
+    const n = 1_000_000
+    const remarks = {
+      petCooldown: ['摸头冷却一', '摸头冷却二', '摸头冷却三'],
+      feedCooldown: ['喂食冷却一', '喂食冷却二', '喂食冷却三'],
+    }
+    const persist = emptyPersist()
+    persist.affinity.lastPetAt = n
+    persist.affinity.lastFeedAt = n
+    const ledger = new PetLedger(persist, { remarks })
+    expect(ledger.interact('pet', n + 1).reaction).toBe('摸头冷却一')
+    expect(ledger.interact('pet', n + 2).reaction).toBe('摸头冷却二')
+    expect(ledger.interact('feed', n + 1).reaction).toBe('喂食冷却一')
+    expect(ledger.interact('feed', n + 2).reaction).toBe('喂食冷却二')
+    expect(ledger.snapshot.affinity.petRejects).toBe(2)
+    expect(ledger.snapshot.affinity.feedRejects).toBe(2)
+
+    const restored = new PetLedger(ledger.snapshot, { remarks })
+    expect(restored.interact('pet', n + 3).reaction).toBe('摸头冷却三')
+    expect(restored.interact('feed', n + 3).reaction).toBe('喂食冷却三')
+  })
+
   it('swaps remark pools when the selected pet changes', () => {
     const ledger = new PetLedger(emptyPersist(), { remarks: { pet: ['旧宠物台词'] } })
     expect(ledger.interact('pet', 1_000_000).reaction).toBe('旧宠物台词')
     ledger.setRemarks({ pet: ['新宠物台词'] })
     expect(ledger.interact('pet', 1_011_000).reaction).toBe('新宠物台词')
     ledger.setRemarks(undefined)
-    expect(ledger.interact('pet', 1_022_000).reaction).toBe('咕噜咕噜～被摸摸好舒服！')
+    // Changing pools does not reset the persisted lifetime interaction count.
+    expect(ledger.interact('pet', 1_022_000).reaction).toBe(BUILTIN_REMARKS.pet[2])
   })
 
   it('refuses a feed on an empty stock without burning anything', () => {

package/src/ledger.ts

@@ -182,12 +182,19 @@ export class PetLedger {
    */
   interact(kind: PetInteraction, nowMs: number): LedgerInteractionResult {
     if (kind === 'feed') this.settleTreats(nowMs)
-    const outcome = applyInteraction(this.current.affinity, kind, nowMs, this.affinityConfig)
+    const before = this.current.affinity
+    const outcome = applyInteraction(before, kind, nowMs, this.affinityConfig)
     // Reactions come from the picker pools (custom per-pet slots override
     // the built-in library per slot); outcome.reaction stays the fallback
     // copy for direct applyInteraction callers.
     if (kind === 'feed' && !outcome.accepted) {
-      return { reaction: this.picker.pick('feedCooldown'), delta: 0, affinity: this.affinityView(nowMs) }
+      this.current = { ...this.current, affinity: outcome.affinity }
+      this.dirty = true
+      return {
+        reaction: this.picker.pickAt('feedCooldown', before.feedRejects),
+        delta: 0,
+        affinity: this.affinityView(nowMs),
+      }
     }
     if (kind === 'feed') {
       const consume = consumeTreat(this.current.treats)
@@ -201,12 +208,13 @@ export class PetLedger {
       this.current = { ...this.current, treats: consume.ledger }
       this.dirty = true
     }
-    if (outcome.accepted) {
-      this.current = { ...this.current, affinity: outcome.affinity }
-      this.dirty = true
-    }
+    this.current = { ...this.current, affinity: outcome.affinity }
+    this.dirty = true
+    const count = kind === 'pet'
+      ? outcome.accepted ? before.pets : before.petRejects
+      : before.feeds
     return {
-      reaction: this.picker.pick(outcome.accepted ? kind : 'petCooldown'),
+      reaction: this.picker.pickAt(outcome.accepted ? kind : 'petCooldown', count),
       delta: outcome.delta,
       affinity: this.affinityView(nowMs),
     }

package/src/persist.test.ts

@@ -20,6 +20,10 @@ function tempDir(): string {
 }
 
 describe('loadPetPersist', () => {
+  it('reserves enough default space for the hover panel below the pet', () => {
+    expect(defaultDisplayConfig.bottom).toBeGreaterThanOrEqual(100)
+  })
+
   it('falls back to defaults when the file is missing', () => {
     const dir = tempDir()
     try {
@@ -67,6 +71,8 @@ describe('loadPetPersist', () => {
       expect(loaded.petId).toBe(DEFAULT_PET_ID)
       expect(loaded.names).toEqual({ [DEFAULT_PET_ID]: '泡泡' })
       expect(loaded.affinity.points).toBe(5)
+      expect(loaded.affinity.petRejects).toBe(0)
+      expect(loaded.affinity.feedRejects).toBe(0)
       expect(loaded.display).toEqual(defaultDisplayConfig)
     } finally {
       rmSync(dir, { recursive: true, force: true })
@@ -108,7 +114,16 @@ describe('loadPetPersist', () => {
       writeFileSync(join(dir, 'pet.json'), JSON.stringify({
         name: '   ',
         names: { bad: '  ' },
-        affinity: { points: AFFINITY_MAX + 5000, lastPetAt: -5, lastFeedAt: 'x', pets: -1, feeds: 1.5, turns: 0 },
+        affinity: {
+          points: AFFINITY_MAX + 5000,
+          lastPetAt: -5,
+          lastFeedAt: 'x',
+          pets: -1,
+          feeds: 1.5,
+          turns: 0,
+          petRejects: 4,
+          feedRejects: -2,
+        },
         treats: { treats: 150, lastTreatGrantAt: -1, turnsAtLastTreatGrant: 0 },
         display: { visible: 'yes', size: -10, right: 1e12, bottom: 20 },
       }), 'utf8')
@@ -120,6 +135,8 @@ describe('loadPetPersist', () => {
       expect(loaded.affinity.lastFeedAt).toBe(0)
       expect(loaded.affinity.pets).toBe(0)
       expect(loaded.affinity.feeds).toBe(1.5) // finite numbers pass through
+      expect(loaded.affinity.petRejects).toBe(4)
+      expect(loaded.affinity.feedRejects).toBe(0)
       expect(loaded.treats.treats).toBe(defaultTreatConfig.maxTreats)
       expect(loaded.treats.lastTreatGrantAt).toBe(0)
       expect(loaded.display.visible).toBe(defaultDisplayConfig.visible)

package/src/persist.ts

@@ -27,7 +27,7 @@ export const defaultDisplayConfig: PetDisplayConfig = {
   visible: true,
   size: 160,
   right: 24,
-  bottom: 20,
+  bottom: 120,
 }
 
 /** Display value bounds (shared by load-time validation and setConfig). */
@@ -117,6 +117,8 @@ export function loadPetPersist(dir: string = petHomeDir()): PetPersist {
       lastFeedAt: clamp(finiteNum(rawAffinity.lastFeedAt, 0), Number.MAX_SAFE_INTEGER),
       pets: clamp(finiteNum(rawAffinity.pets, 0), Number.MAX_SAFE_INTEGER),
       feeds: clamp(finiteNum(rawAffinity.feeds, 0), Number.MAX_SAFE_INTEGER),
+      petRejects: clamp(finiteNum(rawAffinity.petRejects, 0), Number.MAX_SAFE_INTEGER),
+      feedRejects: clamp(finiteNum(rawAffinity.feedRejects, 0), Number.MAX_SAFE_INTEGER),
       turns: clamp(finiteNum(rawAffinity.turns, 0), Number.MAX_SAFE_INTEGER),
     }
     const rawTreats = (parsed.treats ?? {}) as Partial<TreatLedger>