@linxin666/dsh-pet 0.1.13 → 0.1.15

package/src/ledger.ts

@@ -0,0 +1,183 @@
+/**
+ * Pet affinity economy (ledger) — composes the pure affinity and treats
+ * modules with the cooldown/dedup bookkeeping and emits updated persistence
+ * snapshots, marking dirty so the owning facade decides when to flush. Read
+ * paths (view) no longer settle the economy; settlements happen on explicit
+ * economic events: completed-turn rewards (official or legacy) and feeds.
+ * @module @linxin666/dsh-pet/ledger
+ */
+
+import {
+  applyInteraction,
+  affinityViewOf,
+  applyTurnReward,
+  defaultAffinityConfig,
+  type AffinityConfig,
+  type PetAffinityView,
+  type PetInteraction,
+} from './affinity.ts'
+import {
+  consumeTreat,
+  defaultTreatConfig,
+  settleTreatGrants,
+  type TreatConfig,
+} from './treats.ts'
+import type { PetDisplayConfig, PetPersist } from './persist.ts'
+
+/** Tuning overrides for the affinity economy. */
+export interface LedgerConfig {
+  affinity?: Partial<AffinityConfig>
+  treats?: Partial<TreatConfig>
+}
+
+/** Result of one ledger interaction (the shape the pet RPC returns). */
+export interface LedgerInteractionResult {
+  /** Reaction copy bubble. */
+  reaction: string
+  /** Points gained (0 when inside the cooldown). */
+  delta: number
+  /** Full affinity snapshot (same shape as the state view). */
+  affinity: PetAffinityView
+}
+
+/**
+ * Holds the current persistence snapshot and all economy bookkeeping. Every
+ * mutating call flags takeDirty so the facade persists exactly once per
+ * batch of changes; read methods (snapshot, affinityView) never write.
+ */
+export class PetLedger {
+  private readonly affinityConfig: AffinityConfig
+  private readonly treatConfig: TreatConfig
+  private current: PetPersist
+  /** Completed turns already rewarded, per session (turn numbers are per-session). */
+  private rewardedTurns = new Map<string, number>()
+  private lastLegacyTurnRewardAt = 0
+  private dirty = false
+
+  constructor(persist: PetPersist, config: LedgerConfig = {}) {
+    this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) }
+    this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) }
+    this.current = persist
+  }
+
+  /** Affinity cooldown/rank tuning (read-only). */
+  get affinity(): AffinityConfig {
+    return this.affinityConfig
+  }
+
+  /** The current persistence snapshot (trade a copy when mutating). */
+  get snapshot(): PetPersist {
+    return this.current
+  }
+
+  /** Stock cap reported to clients. */
+  get treatMax(): number {
+    return this.treatConfig.maxTreats
+  }
+
+  /** Consume the pending-write flag if any mutation occurred. */
+  takeDirty(): boolean {
+    const was = this.dirty
+    this.dirty = false
+    return was
+  }
+
+  /** Replace the display block (clamping stays a caller concern). */
+  setDisplay(display: PetDisplayConfig): void {
+    this.current = { ...this.current, display }
+    this.dirty = true
+  }
+
+  /** Replace the pet display name (validation stays a caller concern). */
+  setName(name: string): void {
+    this.current = { ...this.current, name }
+    this.dirty = true
+  }
+
+  /**
+   * Settle the treat economy (work + time output since the last settlement).
+   * A zero-gain first settlement still starts the time clock (anchor write),
+   * which is how the 30-minute time output can ever accrue. Returns true when
+   * the in-memory ledger changed and should be persisted.
+   */
+  settleTreats(nowMs: number): boolean {
+    const settlement = settleTreatGrants(
+      this.current.treats,
+      this.current.affinity.turns,
+      nowMs,
+      this.treatConfig,
+    )
+    if (settlement.ledger === this.current.treats) return false
+    this.current = { ...this.current, treats: settlement.ledger }
+    this.dirty = true
+    return true
+  }
+
+  /**
+   * Award the completed-turn reward once per session+turn (idempotent) and
+   * run the treat settlement that work output feeds. Returns true when the
+   * snapshot changed.
+   */
+  rewardTurn(sessionId: string, turn: number, nowMs: number): boolean {
+    const last = this.rewardedTurns.get(sessionId) ?? 0
+    if (turn <= last) return false
+    this.rewardedTurns.set(sessionId, turn)
+    let changed = this.applyTurnReward()
+    if (this.settleTreats(nowMs)) changed = true
+    return changed
+  }
+
+  /** Preserve turn rewards for installations that only emit legacy activity. */
+  rewardLegacyTurn(nowMs: number): boolean {
+    // A legacy done snapshot may repeat during the celebration window.
+    if (nowMs - this.lastLegacyTurnRewardAt < 5_000) return false
+    this.lastLegacyTurnRewardAt = nowMs
+    let changed = this.applyTurnReward()
+    if (this.settleTreats(nowMs)) changed = true
+    return changed
+  }
+
+  private applyTurnReward(): boolean {
+    this.current = {
+      ...this.current,
+      affinity: applyTurnReward(this.current.affinity, this.affinityConfig),
+    }
+    this.dirty = true
+    return true
+  }
+
+  /**
+   * Pet or feed the pet. Feeding settles first, then gates on the feed
+   * cooldown before spending stock — a feed inside the cooldown must not burn
+   * a treat for nothing.
+   */
+  interact(kind: PetInteraction, nowMs: number): LedgerInteractionResult {
+    if (kind === 'feed') this.settleTreats(nowMs)
+    const outcome = applyInteraction(this.current.affinity, kind, nowMs, this.affinityConfig)
+    if (kind === 'feed' && !outcome.accepted) {
+      return { reaction: outcome.reaction, delta: 0, affinity: this.affinityView(nowMs) }
+    }
+    if (kind === 'feed') {
+      const consume = consumeTreat(this.current.treats)
+      if (!consume.ok) {
+        return {
+          reaction: '没有小鱼干了，多陪鲸鱼娘工作一会儿吧～',
+          delta: 0,
+          affinity: this.affinityView(nowMs),
+        }
+      }
+      this.current = { ...this.current, treats: consume.ledger }
+      this.dirty = true
+    }
+    if (outcome.accepted) {
+      this.current = { ...this.current, affinity: outcome.affinity }
+      this.dirty = true
+    }
+    return { reaction: outcome.reaction, delta: outcome.delta, affinity: this.affinityView(nowMs) }
+  }
+
+  /** Current affinity view for the RPC snapshot. */
+  affinityView(nowMs: number): PetAffinityView {
+    return affinityViewOf(this.current.affinity, nowMs, this.affinityConfig)
+  }
+}

package/src/persist.ts

@@ -7,7 +7,7 @@
 
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { homedir } from 'node:os'
+import { dshHome } from './dsh-home.ts'
 import { AFFINITY_MAX, emptyAffinity, type AffinityState } from './affinity.ts'
 import { defaultTreatConfig, emptyTreatLedger, type TreatLedger } from './treats.ts'
 
@@ -60,9 +60,13 @@ export function emptyPersist(): PetPersist {
   }
 }
 
-/** Resolve the persistence directory ($DSH_HOME or ~/.dsh). */
+/**
+ * Resolve the persistence directory ($DSH_HOME or ~/.dsh). Delegates to the
+ * shared {@link dshHome} resolution so the plugin family keeps one DSH_HOME
+ * definition (env override, ~ expansion, cwd-joined relative values).
+ */
 export function petHomeDir(): string {
-  return process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  return dshHome()
 }
 
 /** Numeric field guard: finite numbers only, else the fallback. */

package/src/service.ts

@@ -1,45 +1,41 @@
 /**
- * Pet host service — the `pet.*` RPC domain. Owns the state machine wiring
- * (maps core rc.6 session events — turn/step/tool boundaries — and the
- * session lifecycle onto the pet phases), the affinity ledger, and the
- * persisted display config. The API gateway maps this service's methods onto
- * `pet.state` / `pet.interact` / `pet.setVisible` / `pet.setConfig`
- * for browser consumers.
+ * Pet host service — the `pet.*` RPC domain. A composition facade: it wires
+ * the pure event projection (`event-projection`) onto the state machine,
+ * delegates the affinity economy to the ledger (`ledger`), and routes
+ * persistence through `persist`. The API gateway maps these methods onto
+ * `pet.state` / `pet.interact` / `pet.setVisible` / `pet.setConfig` for
+ * browser consumers.
  * @module @linxin666/dsh-pet/service
  */
 
 import { Context, Service } from '@deepseek-ai/cordis'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+import type { AffinityConfig, PetAffinityView, PetInteraction } from './affinity.ts'
+import type { TreatConfig } from './treats.ts'
 import {
-  applyInteraction,
-  applyTurnReward,
-  defaultAffinityConfig,
-  rankOf,
-  type AffinityConfig,
-  type AffinityState,
-  type PetInteraction,
-} from './affinity.ts'
+  emptyProjectionRuntime,
+  isActivityPhase,
+  projectOfficialEvent,
+  type ActivityStatusEventLike,
+  type ProjectionRuntime,
+} from './event-projection.ts'
+import { PetLedger, type LedgerConfig, type LedgerInteractionResult } from './ledger.ts'
 import {
-  loadPetPersist,
-  petHomeDir,
-  savePetPersist,
+  DISPLAY_INSET_MAX,
   DISPLAY_SIZE_MAX,
   DISPLAY_SIZE_MIN,
-  DISPLAY_INSET_MAX,
   PET_NAME_MAX_LENGTH,
+  loadPetPersist,
+  petHomeDir,
+  savePetPersist,
   type PetDisplayConfig,
   type PetPersist,
 } from './persist.ts'
-import {
-  defaultTreatConfig,
-  settleTreatGrants,
-  consumeTreat,
-  type TreatConfig,
-} from './treats.ts'
 import {
   defaultPetStateConfig,
   PetStateMachine,
   type PetStateConfig,
+  type PetStateInput,
   type PetStateSnapshot,
 } from './state.ts'
 
@@ -87,18 +83,7 @@ export interface PetStateView {
   phase: PetStateSnapshot['phase']
   sessionActive: boolean
   /** Affinity ledger snapshot. */
-  affinity: {
-    points: number
-    rank: string
-    rankEmoji: string
-    pets: number
-    feeds: number
-    turns: number
-    /** True while the pet interaction is inside its cooldown. */
-    petCooldown: boolean
-    /** True while the feed is inside its cooldown. */
-    feedCooldown: boolean
-  }
+  affinity: PetAffinityView
   /** Display configuration. */
   display: PetDisplayConfig
   /** User-customizable pet display name. */
@@ -113,14 +98,7 @@ export interface PetStateView {
 }
 
 /** Result of `pet.interact`. */
-export interface PetInteractResult {
-  /** Reaction copy bubble. */
-  reaction: string
-  /** Points gained (0 when inside the cooldown). */
-  delta: number
-  /** Full affinity snapshot (same shape as state view). */
-  affinity: PetStateView['affinity']
-}
+export type PetInteractResult = LedgerInteractionResult
 
 declare module '@deepseek-ai/cordis' {
   interface Context {
@@ -130,33 +108,31 @@ declare module '@deepseek-ai/cordis' {
 
 /**
  * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
- * written until a query or interaction arrives; event listeners update only
- * in-memory state, and persistence happens on interaction/config changes
- * plus every completed turn.
+ * written until an economic event or interaction arrives; event listeners
+ * update only in-memory state, and persistence happens on economic changes
+ * (turn rewards, feeds, config/name changes) — never on a read.
  */
 export class PetService extends Service {
   static inject: string[] = []
 
   private readonly machine: PetStateMachine
-  private readonly affinityConfig: AffinityConfig
-  private readonly treatConfig: TreatConfig
+  private readonly ledger: PetLedger
   private readonly persistDir: string
-  private persist: PetPersist
-  /** Completed turns already rewarded, per session (turn numbers are per-session). */
-  private rewardedTurns = new Map<string, number>()
   private enabled: boolean
   private disposeActivity: (() => void) | undefined
+  /** Session whose most recent meaningful event currently drives the global pet. */
+  private displaySession: Session | undefined
+  private readonly sessionActivity = new WeakMap<Session, ProjectionRuntime>()
 
   constructor(ctx: Context, config: PetConfig = {}) {
     super(ctx, 'pet')
     this.persistDir = config.persistDir ?? petHomeDir()
-    this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) }
-    this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) }
+    const ledgerConfig: LedgerConfig = { affinity: config.affinity, treats: config.treats }
+    this.ledger = new PetLedger(loadPetPersist(this.persistDir), ledgerConfig)
     this.machine = new PetStateMachine({
       ...defaultPetStateConfig,
       ...(config.state ?? {}),
     })
-    this.persist = loadPetPersist(this.persistDir)
     this.enabled = config.enabled ?? true
 
     this.syncActivity()
@@ -174,12 +150,12 @@ export class PetService extends Service {
 
   /** Current persisted display config (read-only view). */
   display(): PetDisplayConfig {
-    return { ...this.persist.display }
+    return { ...this.ledger.snapshot.display }
   }
 
   /** Current persisted pet name (read-only view). */
   petName(): string {
-    return this.persist.name
+    return this.ledger.snapshot.name
   }
 
   /** Start or stop the session-activity listeners that drive the pet. */
@@ -197,37 +173,38 @@ export class PetService extends Service {
     this.disposeActivity = (() => {
       const disposers = [
         this.ctx.on('session/event', (session: Session, event: SessionEvent) => {
-          // rc.6 publishes no 'activity/status' event (the working-activity
-          // tracker is gone), so the pet derives its phases from the core
-          // session vocabulary instead.
-          switch (event.type) {
-            case 'turn/start':
-              this.machine.onSessionActive()
-              break
-            case 'step/start':
-              this.machine.onSessionActive()
-              this.machine.onActivityStatus({ phase: 'thinking' })
-              break
-            case 'tool/call':
-              this.machine.onSessionActive()
-              this.machine.onActivityStatus({ phase: 'tool', line: 'tool: ' + event.data.name })
-              break
-            case 'turn/end':
-              this.machine.onSessionActive()
-              if (event.data.reason.kind === 'completed') {
-                this.machine.onActivityStatus({ phase: 'done' })
-                this.rewardTurn(String(session.id), event.data.turn)
-              } else {
-                // Aborted / failed turns clear the working pose instead of
-                // freezing the pet on its last phase.
-                this.machine.onActivityStatus({ phase: 'idle' })
-              }
-              break
-            default:
-              break
+          const runtime = this.activityRuntime(session)
+          // `activity/status` is an optional compatibility input. It is not
+          // declared as a durable event type by this package because current
+          // Harness installations publish the official session vocabulary.
+          if ((event.type as string) === 'activity/status') {
+            const payload = ((event as unknown as { data?: unknown }).data ?? {}) as ActivityStatusEventLike
+            if (typeof payload.phase !== 'string' || !isActivityPhase(payload.phase)) return
+            this.applyActivity(session, {
+              phase: payload.phase,
+              ...(typeof payload.line === 'string' ? { line: payload.line } : {}),
+              ...(typeof payload.phrase === 'string' ? { phrase: payload.phrase } : {}),
+            })
+            // On a legacy-only stream the compatibility event owns turn
+            // rewards. Once any official activity is observed, turn/end owns
+            // them and a derived legacy `done` cannot double-count.
+            if (payload.phase === 'done' && !runtime.officialEventsSeen) {
+              this.rewardLegacyTurn()
+            }
+            return
+          }
+
+          const transition = projectOfficialEvent(event, runtime)
+          if (transition === undefined) return
+          runtime.officialEventsSeen = true
+          this.applyActivity(session, transition.input)
+          if (transition.completedTurn !== undefined) {
+            this.rewardTurn(String(session.id), transition.completedTurn)
           }
         }),
-        this.ctx.on('session/disposed', () => {
+        this.ctx.on('session/disposed', (session: Session) => {
+          if (session !== this.displaySession) return
+          this.displaySession = undefined
           this.machine.onSessionDisposed()
         }),
       ]
@@ -235,56 +212,49 @@ export class PetService extends Service {
     })()
   }
 
+  /** Return the projection state associated with one live session. */
+  private activityRuntime(session: Session): ProjectionRuntime {
+    let runtime = this.sessionActivity.get(session)
+    if (runtime === undefined) {
+      runtime = emptyProjectionRuntime()
+      this.sessionActivity.set(session, runtime)
+    }
+    return runtime
+  }
+
+  /** Commit one activity as the host-global pet's most recent display state. */
+  private applyActivity(session: Session, input: PetStateInput): void {
+    this.displaySession = session
+    this.machine.onActivityStatus(input)
+    this.machine.onSessionActive()
+  }
+
   /** RPC: pet or feed the pet. */
   async interact(kind: PetInteraction): Promise<PetInteractResult> {
     const nowMs = Date.now()
-    // Feeding consumes a treat: settle the economy first (work + time
-    // output since the last settlement), then gate on the feed cooldown
-    // BEFORE spending stock — a feed inside the cooldown must not burn a
-    // treat for nothing.
-    if (kind === 'feed') this.settleTreats(nowMs)
-    const outcome = applyInteraction(this.persist.affinity, kind, nowMs, this.affinityConfig)
-    if (kind === 'feed' && !outcome.accepted) {
-      return { reaction: outcome.reaction, delta: 0, affinity: this.affinityView(this.persist.affinity) }
-    }
-    if (kind === 'feed') {
-      const consume = consumeTreat(this.persist.treats)
-      if (!consume.ok) {
-        const affinity = this.affinityView(this.persist.affinity)
-        return {
-          reaction: '没有小鱼干了，多陪鲸鱼娘工作一会儿吧～',
-          delta: 0,
-          affinity,
-        }
-      }
-      this.persist = { ...this.persist, treats: consume.ledger }
-    }
-    if (outcome.accepted) {
-      this.persist = { ...this.persist, affinity: outcome.affinity }
-      this.flush()
-    }
-    const affinity = this.affinityView(outcome.affinity)
-    return { reaction: outcome.reaction, delta: outcome.delta, affinity }
+    const result = this.ledger.interact(kind, nowMs)
+    if (this.ledger.takeDirty()) this.flush()
+    return result
   }
 
   /** RPC: show or hide the pet. */
   async setVisible(visible: boolean): Promise<{ ok: true; display: PetDisplayConfig }> {
-    this.persist = { ...this.persist, display: { ...this.persist.display, visible } }
+    this.ledger.setDisplay({ ...this.ledger.snapshot.display, visible })
     this.flush()
     this.syncSettingsFromPet()
-    return { ok: true, display: this.persist.display }
+    return { ok: true, display: this.ledger.snapshot.display }
   }
 
   /** RPC: update display config (size / position). Values are clamped to whole pixels. */
   async setConfig(patch: Partial<PetDisplayConfig>): Promise<{ ok: true; display: PetDisplayConfig }> {
-    const next = { ...this.persist.display, ...patch }
+    const next = { ...this.ledger.snapshot.display, ...patch }
     next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, next.size)))
     next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.right)))
     next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.bottom)))
-    this.persist = { ...this.persist, display: next }
+    this.ledger.setDisplay(next)
     this.flush()
     this.syncSettingsFromPet()
-    return { ok: true, display: this.persist.display }
+    return { ok: true, display: this.ledger.snapshot.display }
   }
 
   /** RPC: rename the pet (trimmed, 1–20 chars). */
@@ -292,7 +262,7 @@ export class PetService extends Service {
     const trimmed = name.trim()
     if (trimmed === '') return { ok: false, error: 'name-empty' }
     if (trimmed.length > PET_NAME_MAX_LENGTH) return { ok: false, error: 'name-too-long' }
-    this.persist = { ...this.persist, name: trimmed }
+    this.ledger.setName(trimmed)
     this.flush()
     this.syncSettingsFromPet()
     return { ok: true, name: trimmed }
@@ -305,12 +275,13 @@ export class PetService extends Service {
    * @param section - the resolved settings section.
    */
   applySettingsSection(section: PetSettingsSection): void {
-    const next = { ...this.persist.display }
+    const next = { ...this.ledger.snapshot.display }
     next.visible = section.visible && (section.enabled ?? true)
     next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, section.size)))
     next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.right)))
     next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.bottom)))
-    this.persist = { ...this.persist, display: next, name: section.name.trim() }
+    this.ledger.setDisplay(next)
+    this.ledger.setName(section.name.trim())
     this.flush()
   }
 
@@ -318,12 +289,13 @@ export class PetService extends Service {
   private syncSettingsFromPet(): void {
     const settings = this.ctx.get('settings', false) as { update(ns: string, patch: object): Promise<void> } | undefined
     if (settings === undefined) return
+    const snapshot = this.ledger.snapshot
     void settings.update(PET_SETTINGS_NAMESPACE, {
-      visible: this.persist.display.visible,
-      size: this.persist.display.size,
-      right: this.persist.display.right,
-      bottom: this.persist.display.bottom,
-      name: this.persist.name,
+      visible: snapshot.display.visible,
+      size: snapshot.display.size,
+      right: snapshot.display.right,
+      bottom: snapshot.display.bottom,
+      name: snapshot.name,
     }).catch(() => {
       // A settings write failure must not break the pet's own persistence.
     })
@@ -331,69 +303,36 @@ export class PetService extends Service {
 
   /** Award the turn reward once per completed turn (idempotent per session + turn). */
   private rewardTurn(sessionId: string, turn: number): void {
-    const last = this.rewardedTurns.get(sessionId) ?? 0
-    if (turn <= last) return
-    this.rewardedTurns.set(sessionId, turn)
-    this.persist = { ...this.persist, affinity: applyTurnReward(this.persist.affinity, this.affinityConfig) }
-    this.flush()
+    if (this.ledger.rewardTurn(sessionId, turn, Date.now())) this.flush()
   }
 
-  /**
-   * Settle the treat economy (work + time output since the last settlement)
-   * and persist whenever the ledger changed. A zero-gain first settlement
-   * still starts the time clock (anchor write), which is what lets the
-   * 30-minute time output ever accrue.
-   */
-  private settleTreats(nowMs: number): void {
-    const settlement = settleTreatGrants(
-      this.persist.treats,
-      this.persist.affinity.turns,
-      nowMs,
-      this.treatConfig,
-    )
-    if (settlement.ledger !== this.persist.treats) {
-      this.persist = { ...this.persist, treats: settlement.ledger }
-      this.flush()
-    }
+  /** Preserve turn rewards for installations that only emit legacy activity. */
+  private rewardLegacyTurn(): void {
+    if (this.ledger.rewardLegacyTurn(Date.now())) this.flush()
   }
 
   private view(): PetStateView {
     const snapshot = this.machine.render()
-    // Time-output treats accrue while the host is idle too; settle on read.
-    this.settleTreats(Date.now())
+    // Read-only: the ledger settles on economic events only, never on a read,
+    // so polling the state cannot trigger pet.json writes.
     return {
       animation: snapshot.animation,
       ...(snapshot.bubble === undefined ? {} : { bubble: snapshot.bubble }),
       phase: snapshot.phase,
       sessionActive: snapshot.sessionActive,
-      affinity: this.affinityView(this.persist.affinity),
-      display: { ...this.persist.display },
-      name: this.persist.name,
+      affinity: this.ledger.affinityView(Date.now()),
+      display: { ...this.ledger.snapshot.display },
+      name: this.ledger.snapshot.name,
       treats: {
-        stocked: this.persist.treats.treats,
-        max: this.treatConfig.maxTreats,
+        stocked: this.ledger.snapshot.treats.treats,
+        max: this.ledger.treatMax,
       },
     }
   }
 
-  private affinityView(affinity: AffinityState): PetStateView['affinity'] {
-    const nowMs = Date.now()
-    const rank = rankOf(affinity.points)
-    return {
-      points: affinity.points,
-      rank: rank.name,
-      rankEmoji: rank.emoji,
-      pets: affinity.pets,
-      feeds: affinity.feeds,
-      turns: affinity.turns,
-      petCooldown: nowMs - affinity.lastPetAt < this.affinityConfig.petCooldownMs,
-      feedCooldown: nowMs - affinity.lastFeedAt < this.affinityConfig.feedCooldownMs,
-    }
-  }
-
   private flush(): void {
     try {
-      savePetPersist(this.persist, this.persistDir)
+      savePetPersist(this.ledger.snapshot, this.persistDir)
     } catch {
       // Persistence is best-effort; the in-memory ledger keeps working.
     }

package/src/state.test.ts

@@ -11,8 +11,10 @@ describe('animationForPhase', () => {
   it('maps each activity phase onto the animation contract', () => {
     expect(animationForPhase('thinking')).toBe('running')
     expect(animationForPhase('tool')).toBe('running-right')
+    expect(animationForPhase('review')).toBe('review')
     expect(animationForPhase('waiting')).toBe('waiting')
     expect(animationForPhase('done')).toBe('jumping')
+    expect(animationForPhase('failed')).toBe('failed')
     expect(animationForPhase('idle')).toBe('idle')
   })
 })
@@ -27,7 +29,8 @@ describe('PetStateMachine', () => {
     now += 2399
     expect(machine.render().animation).toBe('jumping')
     now += 2
-    expect(machine.render().animation).toBe('idle')
+    expect(machine.render()).toMatchObject({ animation: 'idle' })
+    expect(machine.render().bubble).toBeUndefined()
   })
 
   it('shows the phrase bubble when present, else the line', () => {