@linxin666/dsh-pet 0.1.13 → 0.1.15

package/lib/types/service.js

@@ -1,46 +1,44 @@
 /**
- * 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 { Service } from '@deepseek-ai/cordis';
-import { applyInteraction, applyTurnReward, defaultAffinityConfig, rankOf, } from "./affinity.js";
-import { loadPetPersist, petHomeDir, savePetPersist, DISPLAY_SIZE_MAX, DISPLAY_SIZE_MIN, DISPLAY_INSET_MAX, PET_NAME_MAX_LENGTH, } from "./persist.js";
-import { defaultTreatConfig, settleTreatGrants, consumeTreat, } from "./treats.js";
+import { emptyProjectionRuntime, isActivityPhase, projectOfficialEvent, } from "./event-projection.js";
+import { PetLedger } from "./ledger.js";
+import { DISPLAY_INSET_MAX, DISPLAY_SIZE_MAX, DISPLAY_SIZE_MIN, PET_NAME_MAX_LENGTH, loadPetPersist, petHomeDir, savePetPersist, } from "./persist.js";
 import { defaultPetStateConfig, PetStateMachine, } from "./state.js";
 /** Settings namespace of the pet capability. Spelled here rather than imported: the browser half spells the same value. */
 export const PET_SETTINGS_NAMESPACE = 'pet';
 /**
  * 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 = [];
     machine;
-    affinityConfig;
-    treatConfig;
+    ledger;
     persistDir;
-    persist;
-    /** Completed turns already rewarded, per session (turn numbers are per-session). */
-    rewardedTurns = new Map();
     enabled;
     disposeActivity;
+    /** Session whose most recent meaningful event currently drives the global pet. */
+    displaySession;
+    sessionActivity = new WeakMap();
     constructor(ctx, config = {}) {
         super(ctx, 'pet');
         this.persistDir = config.persistDir ?? petHomeDir();
-        this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) };
-        this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) };
+        const 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();
     }
@@ -54,11 +52,11 @@ export class PetService extends Service {
     }
     /** Current persisted display config (read-only view). */
     display() {
-        return { ...this.persist.display };
+        return { ...this.ledger.snapshot.display };
     }
     /** Current persisted pet name (read-only view). */
     petName() {
-        return this.persist.name;
+        return this.ledger.snapshot.name;
     }
     /** Start or stop the session-activity listeners that drive the pet. */
     setEnabled(enabled) {
@@ -75,38 +73,40 @@ export class PetService extends Service {
         this.disposeActivity = (() => {
             const disposers = [
                 this.ctx.on('session/event', (session, event) => {
-                    // 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 === 'activity/status') {
+                        const payload = (event.data ?? {});
+                        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) => {
+                    if (session !== this.displaySession)
+                        return;
+                    this.displaySession = undefined;
                     this.machine.onSessionDisposed();
                 }),
             ];
@@ -114,55 +114,46 @@ export class PetService extends Service {
                 dispose(); };
         })();
     }
+    /** Return the projection state associated with one live session. */
+    activityRuntime(session) {
+        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. */
+    applyActivity(session, input) {
+        this.displaySession = session;
+        this.machine.onActivityStatus(input);
+        this.machine.onSessionActive();
+    }
     /** RPC: pet or feed the pet. */
     async interact(kind) {
         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 };
+        const result = this.ledger.interact(kind, nowMs);
+        if (this.ledger.takeDirty())
             this.flush();
-        }
-        const affinity = this.affinityView(outcome.affinity);
-        return { reaction: outcome.reaction, delta: outcome.delta, affinity };
+        return result;
     }
     /** RPC: show or hide the pet. */
     async setVisible(visible) {
-        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) {
-        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). */
     async setName(name) {
@@ -171,7 +162,7 @@ export class PetService extends Service {
             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 };
@@ -183,12 +174,13 @@ export class PetService extends Service {
      * @param section - the resolved settings section.
      */
     applySettingsSection(section) {
-        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();
     }
     /** Mirror the persisted display config into the settings document (best-effort). */
@@ -196,73 +188,48 @@ export class PetService extends Service {
         const settings = this.ctx.get('settings', false);
         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.
         });
     }
     /** Award the turn reward once per completed turn (idempotent per session + turn). */
     rewardTurn(sessionId, turn) {
-        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.
-     */
-    settleTreats(nowMs) {
-        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 };
+    /** Preserve turn rewards for installations that only emit legacy activity. */
+    rewardLegacyTurn() {
+        if (this.ledger.rewardLegacyTurn(Date.now()))
             this.flush();
-        }
     }
     view() {
         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,
             },
         };
     }
-    affinityView(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,
-        };
-    }
     flush() {
         try {
-            savePetPersist(this.persist, this.persistDir);
+            savePetPersist(this.ledger.snapshot, this.persistDir);
         }
         catch {
             // Persistence is best-effort; the in-memory ledger keeps working.

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.15",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"

package/src/affinity.ts

@@ -84,6 +84,39 @@ export function rankOf(points: number): (typeof AFFINITY_RANKS)[number] {
   return rank
 }
 
+/** Read-only affinity snapshot suited for the RPC view shape. */
+export interface PetAffinityView {
+  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
+}
+
+/** Derive the read-only view of one affinity state at a wall-clock instant. */
+export function affinityViewOf(
+  state: AffinityState,
+  nowMs: number,
+  config: AffinityConfig = defaultAffinityConfig,
+): PetAffinityView {
+  const rank = rankOf(state.points)
+  return {
+    points: state.points,
+    rank: rank.name,
+    rankEmoji: rank.emoji,
+    pets: state.pets,
+    feeds: state.feeds,
+    turns: state.turns,
+    petCooldown: nowMs - state.lastPetAt < config.petCooldownMs,
+    feedCooldown: nowMs - state.lastFeedAt < config.feedCooldownMs,
+  }
+}
+
 function clamp(points: number): number {
   return Math.min(AFFINITY_MAX, Math.max(0, points))
 }