@linxin666/dsh-pet 0.1.13 → 0.1.14

package/lib/types/state.d.ts

@@ -1,8 +1,7 @@
 /**
- * Pet state machine — pure, clock-injected. Maps the pet's working-phase
- * vocabulary (the service derives it from core session events) onto the
- * 9-state Codex pet animation contract, plus the session lifecycle
- * transitions the web UI exposes (turn end celebration, no-session idle).
+ * Pet state machine — pure, clock-injected. Maps official DSH session activity
+ * and the legacy `activity/status` vocabulary onto the 9-state Codex pet
+ * animation contract, plus turn-end celebration and no-session idle.
  *
  * The machine is deliberately dumb: it holds the last input phase, the
  * animation decision, and a one-shot "celebration" window after `done` so the
@@ -10,13 +9,13 @@
  * function of (input, nowMs); persistence and RPC live in the service.
  * @module @linxin666/dsh-pet/state
  */
-/** The pet's working-phase vocabulary (derived from core session events by the service). */
-export type ActivityPhase = 'idle' | 'waiting' | 'thinking' | 'tool' | 'done';
+/** Activity phases understood by the pet host. */
+export type ActivityPhase = 'idle' | 'waiting' | 'thinking' | 'tool' | 'review' | 'done' | 'failed';
 /** The Codex-compatible 9-state animation contract (spritesheet rows). */
 export type PetAnimation = 'idle' | 'running-right' | 'running-left' | 'waving' | 'jumping' | 'failed' | 'waiting' | 'running' | 'review';
 /** One input snapshot consumed by the machine. */
 export interface PetStateInput {
-    /** Current working phase of the active session. */
+    /** Current activity phase of the active session. */
     phase: ActivityPhase;
     /** Human-readable status line (plain text). */
     line?: string;
@@ -44,13 +43,12 @@ export interface PetStateConfig {
 export declare const defaultPetStateConfig: PetStateConfig;
 /**
  * Map one activity phase onto the animation contract.
- * - thinking / tool → `running` (focused work), with `running-right` as the
- *   side-alternating variant the client may use for tool activity.
+ * - thinking → `running` and tool → `running-right` (focused work).
+ * - review → `review` while answer text is streaming.
  * - waiting → `waiting` (expectant pose, needs user input).
  * - done → `jumping` (celebration), then back to `idle` after the window.
+ * - failed → `failed` until another activity event arrives.
  * - idle → `idle` (calm breathing loop).
- * `failed` has no DSH phase source yet; the machine keeps the mapping table
- * so a future error event can light it up.
  */
 export declare function animationForPhase(phase: ActivityPhase): PetAnimation;
 /** The spritesheet row index for one animation track. */
@@ -68,7 +66,7 @@ export declare class PetStateMachine {
     private sessionActive;
     private doneAt;
     constructor(config?: PetStateConfig, now?: () => number);
-    /** Consume one phase snapshot (fed by the service from session events). */
+    /** Consume one projected activity update. */
     onActivityStatus(input: PetStateInput): void;
     /** A session became the active one (or a fresh session started). */
     onSessionActive(): void;

package/lib/types/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,4FAA4F;AAC5F,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAA;AAE7E,0EAA0E;AAC1E,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,eAAe,GACf,cAAc,GACd,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,SAAS,GACT,SAAS,GACT,QAAQ,CAAA;AAEZ,kDAAkD;AAClD,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,KAAK,EAAE,aAAa,CAAA;IACpB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,4DAA4D;AAC5D,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,SAAS,EAAE,YAAY,CAAA;IACvB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,oEAAoE;IACpE,kBAAkB,EAAE,MAAM,CAAA;IAC1B,oEAAoE;IACpE,KAAK,EAAE,aAAa,CAAA;IACpB,0DAA0D;IAC1D,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,6BAA6B;AAC7B,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,qBAAqB,EAAE,cAAsC,CAAA;AAE1E;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAQpE;AAED,yDAAyD;AACzD,wBAAgB,KAAK,CAAC,SAAS,EAAE,YAAY,GAAG,MAAM,CAarD;AAED;;;GAGG;AACH,qBAAa,eAAe;IAQxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IARtB,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,MAAM,CAAoB;gBAGf,MAAM,GAAE,cAAsC,EAC9C,GAAG,GAAE,MAAM,MAAiB;IAG/C,2EAA2E;IAC3E,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAO5C,oEAAoE;IACpE,eAAe,IAAI,IAAI;IAIvB,sDAAsD;IACtD,iBAAiB,IAAI,IAAI;IAQzB,6CAA6C;IAC7C,MAAM,IAAI,gBAAgB;CAoB3B"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,kDAAkD;AAClD,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAA;AAEnG,0EAA0E;AAC1E,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,eAAe,GACf,cAAc,GACd,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,SAAS,GACT,SAAS,GACT,QAAQ,CAAA;AAEZ,kDAAkD;AAClD,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,KAAK,EAAE,aAAa,CAAA;IACpB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,4DAA4D;AAC5D,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,SAAS,EAAE,YAAY,CAAA;IACvB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,oEAAoE;IACpE,kBAAkB,EAAE,MAAM,CAAA;IAC1B,oEAAoE;IACpE,KAAK,EAAE,aAAa,CAAA;IACpB,0DAA0D;IAC1D,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,6BAA6B;AAC7B,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,qBAAqB,EAAE,cAAsC,CAAA;AAE1E;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAUpE;AAED,yDAAyD;AACzD,wBAAgB,KAAK,CAAC,SAAS,EAAE,YAAY,GAAG,MAAM,CAarD;AAED;;;GAGG;AACH,qBAAa,eAAe;IAQxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IARtB,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,MAAM,CAAoB;gBAGf,MAAM,GAAE,cAAsC,EAC9C,GAAG,GAAE,MAAM,MAAiB;IAG/C,6CAA6C;IAC7C,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAO5C,oEAAoE;IACpE,eAAe,IAAI,IAAI;IAIvB,sDAAsD;IACtD,iBAAiB,IAAI,IAAI;IAQzB,6CAA6C;IAC7C,MAAM,IAAI,gBAAgB;CAwB3B"}

package/lib/types/state.js

@@ -1,8 +1,7 @@
 /**
- * Pet state machine — pure, clock-injected. Maps the pet's working-phase
- * vocabulary (the service derives it from core session events) onto the
- * 9-state Codex pet animation contract, plus the session lifecycle
- * transitions the web UI exposes (turn end celebration, no-session idle).
+ * Pet state machine — pure, clock-injected. Maps official DSH session activity
+ * and the legacy `activity/status` vocabulary onto the 9-state Codex pet
+ * animation contract, plus turn-end celebration and no-session idle.
  *
  * The machine is deliberately dumb: it holds the last input phase, the
  * animation decision, and a one-shot "celebration" window after `done` so the
@@ -13,20 +12,21 @@
 export const defaultPetStateConfig = { celebrateMs: 2400 };
 /**
  * Map one activity phase onto the animation contract.
- * - thinking / tool → `running` (focused work), with `running-right` as the
- *   side-alternating variant the client may use for tool activity.
+ * - thinking → `running` and tool → `running-right` (focused work).
+ * - review → `review` while answer text is streaming.
  * - waiting → `waiting` (expectant pose, needs user input).
  * - done → `jumping` (celebration), then back to `idle` after the window.
+ * - failed → `failed` until another activity event arrives.
  * - idle → `idle` (calm breathing loop).
- * `failed` has no DSH phase source yet; the machine keeps the mapping table
- * so a future error event can light it up.
  */
 export function animationForPhase(phase) {
     switch (phase) {
         case 'thinking': return 'running';
         case 'tool': return 'running-right';
+        case 'review': return 'review';
         case 'waiting': return 'waiting';
         case 'done': return 'jumping';
+        case 'failed': return 'failed';
         case 'idle': return 'idle';
     }
 }
@@ -61,7 +61,7 @@ export class PetStateMachine {
         this.config = config;
         this.now = now;
     }
-    /** Consume one phase snapshot (fed by the service from session events). */
+    /** Consume one projected activity update. */
     onActivityStatus(input) {
         this.phase = input.phase;
         this.line = input.line;
@@ -94,7 +94,11 @@ export class PetStateMachine {
                 animation = 'idle';
             }
         }
-        const bubble = this.phrase ?? this.line;
+        const bubble = this.phase === 'done'
+            && this.doneAt !== undefined
+            && nowMs - this.doneAt >= this.config.celebrateMs
+            ? undefined
+            : this.phrase ?? this.line;
         return {
             animation,
             ...(bubble === undefined ? {} : { bubble }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-pet",
   "description": "鲸鱼娘宠物插件 for the dsh web GUI: a soft healing whale-girl companion that reacts to model activity (idle/waiting/thinking/tool/done), with petting/feeding interactions and an affinity score",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"

package/src/client/WhalePet.test.tsx

@@ -55,7 +55,7 @@ afterEach(() => {
 })
 
 /** Render the pet with mocked callbacks; returns the rename spy. */
-function renderPet(): { onRename: ReturnType<typeof vi.fn> } {
+function renderPet(overrides: Partial<WhalePetProps> = {}): { onRename: ReturnType<typeof vi.fn> } {
   const onRename = vi.fn()
   const props: WhalePetProps = {
     snapshot,
@@ -68,6 +68,7 @@ function renderPet(): { onRename: ReturnType<typeof vi.fn> } {
     onRename,
     onFeedbackDone: vi.fn(),
     t,
+    ...overrides,
   }
   render(<WhalePet {...props} />)
   return { onRename }
@@ -136,3 +137,26 @@ describe('WhalePet rename input', () => {
     expect(screen.queryByPlaceholderText('输入新名字')).toBeNull()
   })
 })
+
+describe('WhalePet status bubble', () => {
+  const workingSnapshot: PetStateView = {
+    ...snapshot,
+    animation: 'running',
+    phase: 'thinking',
+    bubble: '正在思考',
+  }
+
+  it('renders host activity when no interaction feedback is active', () => {
+    renderPet({ snapshot: workingSnapshot })
+    expect(screen.queryByText('正在思考')).not.toBeNull()
+  })
+
+  it('lets transient interaction feedback replace host activity', () => {
+    renderPet({
+      snapshot: workingSnapshot,
+      feedback: { text: '摸摸成功', kind: 'pet', at: 1 },
+    })
+    expect(screen.queryByText('摸摸成功')).not.toBeNull()
+    expect(screen.queryByText('正在思考')).toBeNull()
+  })
+})

package/src/client/WhalePet.tsx

@@ -228,6 +228,7 @@ export function WhalePet(props: WhalePetProps): ReactPortal {
   const pos = dragPos ?? { right: display.right, bottom: display.bottom }
   const spriteWidth = Math.round(FRAME_WIDTH * spriteScale)
   const spriteHeight = Math.round(FRAME_HEIGHT * spriteScale)
+  const statusBubble = feedback === null && !hovered ? snapshot?.bubble : undefined
 
   const float = (
     <div
@@ -281,6 +282,11 @@ export function WhalePet(props: WhalePetProps): ReactPortal {
           {feedback.text}
         </div>
       )}
+      {statusBubble !== undefined && (
+        <div className={`${styles.bubble} ${styles.bubbleStatus}`} role="status" aria-live="polite">
+          {statusBubble}
+        </div>
+      )}
       {hovered && dragRef.current === null && (
         <div
           className={styles.panel}

package/src/client/pet.module.css

@@ -37,6 +37,15 @@
   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;
+}
+
 @keyframes pet-bubble-pop {
   0% {
     opacity: 0;

package/src/service.ts

@@ -1,10 +1,9 @@
 /**
  * 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.
+ * (projects official session events and accepts legacy `activity/status`), 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.
  * @module @linxin666/dsh-pet/service
  */
 
@@ -40,6 +39,7 @@ import {
   defaultPetStateConfig,
   PetStateMachine,
   type PetStateConfig,
+  type PetStateInput,
   type PetStateSnapshot,
 } from './state.ts'
 
@@ -128,6 +128,119 @@ declare module '@deepseek-ai/cordis' {
   }
 }
 
+/** Runtime shape of the optional legacy activity event. */
+interface ActivityStatusEventLike {
+  phase?: string
+  line?: string
+  phrase?: string
+}
+
+/** Per-session facts needed to project the official event stream. */
+interface SessionActivityRuntime {
+  activeTools: Set<string>
+  officialEventsSeen: boolean
+  stepHadFailure: boolean
+}
+
+/** One official event projection, optionally carrying a completed turn reward. */
+interface PetActivityTransition {
+  input: PetStateInput
+  completedTurn?: number
+}
+
+/** 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)}...`
+}
+
+/** Whether a legacy phase is part of the pet's supported vocabulary. */
+function isActivityPhase(phase: string): phase is PetStateInput['phase'] {
+  return ['idle', 'waiting', 'thinking', 'tool', 'review', 'done', 'failed'].includes(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.
+ */
+function projectOfficialEvent(
+  event: SessionEvent,
+  runtime: SessionActivityRuntime,
+): PetActivityTransition | undefined {
+  switch (event.type) {
+    case 'turn/start':
+      runtime.activeTools.clear()
+      runtime.stepHadFailure = false
+      return { input: { phase: 'waiting', line: '准备开始' } }
+    case 'step/start':
+      runtime.activeTools.clear()
+      runtime.stepHadFailure = false
+      return { input: { phase: 'waiting', line: '等待模型响应' } }
+    case 'assistant/chunk': {
+      const { chunk } = event.data
+      if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
+        return { input: { phase: 'thinking', line: '正在思考' } }
+      }
+      if (chunk.type === 'text-delta' && chunk.text.length > 0) {
+        return { input: { phase: 'review', line: '整理回复中' } }
+      }
+      return undefined
+    }
+    case 'assistant/message':
+      return { input: { phase: 'review', line: '整理回复中' } }
+    case 'tool/call':
+      runtime.activeTools.add(String(event.data.callId))
+      return {
+        input: {
+          phase: 'tool',
+          line: `正在使用 ${displayToolName(event.data.name)}`,
+        },
+      }
+    case 'tool/result': {
+      const block = event.data.message.content[0]
+      runtime.activeTools.delete(String(event.data.message.source.callId))
+      runtime.stepHadFailure ||= event.data.error !== undefined || block.isError === true
+      if (runtime.activeTools.size > 0) {
+        return {
+          input: {
+            phase: 'tool',
+            line: `还有 ${runtime.activeTools.size} 个工具运行中`,
+          },
+        }
+      }
+      return runtime.stepHadFailure
+        ? { input: { phase: 'failed', line: '工具执行失败' } }
+        : { input: { phase: 'thinking', line: '处理工具结果' } }
+    }
+    case 'turn/end': {
+      runtime.activeTools.clear()
+      switch (event.data.reason.kind) {
+        case 'completed':
+          return {
+            input: { phase: 'done', line: '完成啦' },
+            completedTurn: event.data.turn,
+          }
+        case 'error':
+          return { input: { phase: 'failed', line: '执行失败' } }
+        case 'max-tokens':
+          return { input: { phase: 'failed', line: '达到输出上限' } }
+        case 'interrupted':
+          return { input: { phase: 'failed', line: '执行意外中断' } }
+        case 'blocked':
+          return { input: { phase: 'waiting', line: '等待继续' } }
+        case 'aborted':
+          return { input: { phase: 'idle', line: '已停止' } }
+        default:
+          // TurnEndReasonMap is merge-extensible; a newer ending must not
+          // leave the pet showing stale in-progress work.
+          return { input: { phase: 'idle' } }
+      }
+    }
+    default:
+      return undefined
+  }
+}
+
 /**
  * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
  * written until a query or interaction arrives; event listeners update only
@@ -146,6 +259,10 @@ export class PetService extends Service {
   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, SessionActivityRuntime>()
+  private lastLegacyTurnRewardAt = 0
 
   constructor(ctx: Context, config: PetConfig = {}) {
     super(ctx, 'pet')
@@ -197,37 +314,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,6 +353,27 @@ export class PetService extends Service {
     })()
   }
 
+  /** Return the projection state associated with one live session. */
+  private activityRuntime(session: Session): SessionActivityRuntime {
+    let runtime = this.sessionActivity.get(session)
+    if (runtime === undefined) {
+      runtime = {
+        activeTools: new Set(),
+        officialEventsSeen: false,
+        stepHadFailure: false,
+      }
+      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()
@@ -334,6 +473,20 @@ export class PetService extends Service {
     const last = this.rewardedTurns.get(sessionId) ?? 0
     if (turn <= last) return
     this.rewardedTurns.set(sessionId, turn)
+    this.applyTurnReward()
+  }
+
+  /** Preserve turn rewards for installations that only emit legacy activity. */
+  private rewardLegacyTurn(): void {
+    const nowMs = Date.now()
+    // A legacy `done` snapshot may repeat during the celebration window.
+    if (nowMs - this.lastLegacyTurnRewardAt < 5_000) return
+    this.lastLegacyTurnRewardAt = nowMs
+    this.applyTurnReward()
+  }
+
+  /** Persist one accepted completed-turn reward. */
+  private applyTurnReward(): void {
     this.persist = { ...this.persist, affinity: applyTurnReward(this.persist.affinity, this.affinityConfig) }
     this.flush()
   }

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', () => {

package/src/state.ts

@@ -1,8 +1,7 @@
 /**
- * Pet state machine — pure, clock-injected. Maps the pet's working-phase
- * vocabulary (the service derives it from core session events) onto the
- * 9-state Codex pet animation contract, plus the session lifecycle
- * transitions the web UI exposes (turn end celebration, no-session idle).
+ * Pet state machine — pure, clock-injected. Maps official DSH session activity
+ * and the legacy `activity/status` vocabulary onto the 9-state Codex pet
+ * animation contract, plus turn-end celebration and no-session idle.
  *
  * The machine is deliberately dumb: it holds the last input phase, the
  * animation decision, and a one-shot "celebration" window after `done` so the
@@ -11,8 +10,8 @@
  * @module @linxin666/dsh-pet/state
  */
 
-/** The pet's working-phase vocabulary (derived from core session events by the service). */
-export type ActivityPhase = 'idle' | 'waiting' | 'thinking' | 'tool' | 'done'
+/** Activity phases understood by the pet host. */
+export type ActivityPhase = 'idle' | 'waiting' | 'thinking' | 'tool' | 'review' | 'done' | 'failed'
 
 /** The Codex-compatible 9-state animation contract (spritesheet rows). */
 export type PetAnimation =
@@ -28,7 +27,7 @@ export type PetAnimation =
 
 /** One input snapshot consumed by the machine. */
 export interface PetStateInput {
-  /** Current working phase of the active session. */
+  /** Current activity phase of the active session. */
   phase: ActivityPhase
   /** Human-readable status line (plain text). */
   line?: string
@@ -60,20 +59,21 @@ export const defaultPetStateConfig: PetStateConfig = { celebrateMs: 2400 }
 
 /**
  * Map one activity phase onto the animation contract.
- * - thinking / tool → `running` (focused work), with `running-right` as the
- *   side-alternating variant the client may use for tool activity.
+ * - thinking → `running` and tool → `running-right` (focused work).
+ * - review → `review` while answer text is streaming.
  * - waiting → `waiting` (expectant pose, needs user input).
  * - done → `jumping` (celebration), then back to `idle` after the window.
+ * - failed → `failed` until another activity event arrives.
  * - idle → `idle` (calm breathing loop).
- * `failed` has no DSH phase source yet; the machine keeps the mapping table
- * so a future error event can light it up.
  */
 export function animationForPhase(phase: ActivityPhase): PetAnimation {
   switch (phase) {
     case 'thinking': return 'running'
     case 'tool': return 'running-right'
+    case 'review': return 'review'
     case 'waiting': return 'waiting'
     case 'done': return 'jumping'
+    case 'failed': return 'failed'
     case 'idle': return 'idle'
   }
 }
@@ -110,7 +110,7 @@ export class PetStateMachine {
     private readonly now: () => number = Date.now,
   ) {}
 
-  /** Consume one phase snapshot (fed by the service from session events). */
+  /** Consume one projected activity update. */
   onActivityStatus(input: PetStateInput): void {
     this.phase = input.phase
     this.line = input.line
@@ -144,7 +144,11 @@ export class PetStateMachine {
         animation = 'idle'
       }
     }
-    const bubble = this.phrase ?? this.line
+    const bubble = this.phase === 'done'
+      && this.doneAt !== undefined
+      && nowMs - this.doneAt >= this.config.celebrateMs
+      ? undefined
+      : this.phrase ?? this.line
     return {
       animation,
       ...(bubble === undefined ? {} : { bubble }),