@linxin666/dsh-pet 0.1.11 → 0.1.13

package/src/service.ts

@@ -1,14 +1,15 @@
 /**
  * Pet host service — the `pet.*` RPC domain. Owns the state machine wiring
- * (consumes `activity/status` session events and session lifecycle), 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.
+ * (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.
  * @module @linxin666/dsh-pet/service
  */
 
 import { Context, Service } from '@deepseek-ai/cordis'
-import type { Session } from '@deepseek-ai/dsh-session'
+import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 import {
   applyInteraction,
   applyTurnReward,
@@ -127,13 +128,6 @@ declare module '@deepseek-ai/cordis' {
   }
 }
 
-/** One session/event guard: only the latest activity snapshot matters. */
-interface ActivityStatusEventLike {
-  phase?: string
-  line?: string
-  phrase?: string
-}
-
 /**
  * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
  * written until a query or interaction arrives; event listeners update only
@@ -148,7 +142,8 @@ export class PetService extends Service {
   private readonly treatConfig: TreatConfig
   private readonly persistDir: string
   private persist: PetPersist
-  private lastTurnRewardAt = 0
+  /** Completed turns already rewarded, per session (turn numbers are per-session). */
+  private rewardedTurns = new Map<string, number>()
   private enabled: boolean
   private disposeActivity: (() => void) | undefined
 
@@ -201,20 +196,36 @@ export class PetService extends Service {
     if (!this.enabled) return
     this.disposeActivity = (() => {
       const disposers = [
-        this.ctx.on('session/event', (_session: Session, event: { type: string; data?: unknown }) => {
-          if (event.type !== 'activity/status') return
-          const payload = (event.data ?? {}) as ActivityStatusEventLike
-          if (payload.phase === undefined) return
-          const phase = payload.phase as PetStateSnapshot['phase']
-          // Guard against unknown phases from newer activity trackers.
-          if (!['idle', 'waiting', 'thinking', 'tool', 'done'].includes(phase)) return
-          this.machine.onActivityStatus({
-            phase,
-            ...(typeof payload.line === 'string' ? { line: payload.line } : {}),
-            ...(typeof payload.phrase === 'string' ? { phrase: payload.phrase } : {}),
-          })
-          this.machine.onSessionActive()
-          if (phase === 'done') this.rewardTurn()
+        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
+          }
         }),
         this.ctx.on('session/disposed', () => {
           this.machine.onSessionDisposed()
@@ -318,19 +329,20 @@ export class PetService extends Service {
     })
   }
 
-  /** Award the turn reward once per done phase (idempotent per transition). */
-  private rewardTurn(): void {
-    const nowMs = Date.now()
-    // A done phase can repeat while celebrating; only reward the first.
-    if (nowMs - this.lastTurnRewardAt < 5_000) return
-    this.lastTurnRewardAt = nowMs
+  /** 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()
   }
 
   /**
-   * Settle the treat economy (work + time output since the last
-   * settlement); persists only when treats were actually granted.
+   * 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(
@@ -339,7 +351,7 @@ export class PetService extends Service {
       nowMs,
       this.treatConfig,
     )
-    if (settlement.gained > 0) {
+    if (settlement.ledger !== this.persist.treats) {
       this.persist = { ...this.persist, treats: settlement.ledger }
       this.flush()
     }

package/src/state.ts

@@ -1,8 +1,8 @@
 /**
- * Pet state machine — pure, clock-injected. Maps the DSH `activity/status`
- * phase vocabulary (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 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).
  *
  * 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,7 +11,7 @@
  * @module @linxin666/dsh-pet/state
  */
 
-/** The DSH `activity/status` phase vocabulary (wire contract of session events). */
+/** The pet's working-phase vocabulary (derived from core session events by the service). */
 export type ActivityPhase = 'idle' | 'waiting' | 'thinking' | 'tool' | 'done'
 
 /** The Codex-compatible 9-state animation contract (spritesheet rows). */
@@ -28,7 +28,7 @@ export type PetAnimation =
 
 /** One input snapshot consumed by the machine. */
 export interface PetStateInput {
-  /** Current activity/status phase of the active session. */
+  /** Current working phase of the active session. */
   phase: ActivityPhase
   /** Human-readable status line (plain text). */
   line?: string
@@ -110,7 +110,7 @@ export class PetStateMachine {
     private readonly now: () => number = Date.now,
   ) {}
 
-  /** Consume one `activity/status` session event. */
+  /** Consume one phase snapshot (fed by the service from session events). */
   onActivityStatus(input: PetStateInput): void {
     this.phase = input.phase
     this.line = input.line

package/src/treats.test.ts

@@ -23,11 +23,34 @@ describe('settleTreatGrants', () => {
     expect(s.ledger.lastTreatGrantAt).toBe(1_000 + 90 * 60_000)
   })
 
-  it('does not backfill time output before the first settlement', () => {
+  it('does not backfill time output before the first settlement, but starts the clock', () => {
     const ledger = emptyTreatLedger() // lastTreatGrantAt === 0
     const s = settleTreatGrants(ledger, 0, 1_000 + 10 * 60 * 60_000, defaultTreatConfig)
     expect(s.gained).toBe(0)
-    expect(s.ledger).toBe(ledger)
+    expect(s.ledger.treats).toBe(0)
+    expect(s.ledger.lastTreatGrantAt).toBe(1_000 + 10 * 60 * 60_000)
+  })
+
+  it('starts the time clock on a zero-gain settlement so later time output accrues (anchor deadlock)', () => {
+    // Regression for issue #99: the old code returned the ledger untouched
+    // when nothing was due, so lastTreatGrantAt stayed 0 forever and the
+    // 30-minute time output could never begin.
+    let ledger = emptyTreatLedger()
+    const first = settleTreatGrants(ledger, 0, 1_000, defaultTreatConfig)
+    expect(first.gained).toBe(0)
+    expect(first.ledger.lastTreatGrantAt).toBe(1_000)
+    expect(first.ledger.treats).toBe(0)
+    ledger = first.ledger
+    // Anchored and nothing due: the same object comes back (no persistence
+    // churn) and the anchor must not move.
+    const same = settleTreatGrants(ledger, 0, 1_000 + 10_000, defaultTreatConfig)
+    expect(same.gained).toBe(0)
+    expect(same.ledger).toBe(ledger)
+    // One full period after the anchor: the time treat finally lands.
+    const grant = settleTreatGrants(ledger, 0, 1_000 + defaultTreatConfig.timeTreatMs, defaultTreatConfig)
+    expect(grant.gained).toBe(1)
+    expect(grant.ledger.treats).toBe(1)
+    expect(grant.ledger.lastTreatGrantAt).toBe(1_000 + defaultTreatConfig.timeTreatMs)
   })
 
   it('caps stocked treats at maxTreats', () => {

package/src/treats.ts

@@ -58,8 +58,12 @@ function cap(treats: number, max: number): number {
  * time output counts whole periods since the time anchor
  * (`lastTreatGrantAt`) and advances only the time anchor. The two sources
  * are independent so a continuously working user still earns time treats.
- * 0 time history never backfills — the clock starts at the first settlement.
- * Both sources are clamped by the stock cap.
+ * 0 time history never backfills — the clock starts at the first settlement,
+ * and even a zero-gain first settlement writes the time anchor so the next
+ * elapsed period can accrue (anchor deadlock fix). Both sources are clamped
+ * by the stock cap. When the anchor is already set and nothing is due, the
+ * input ledger is returned unchanged (same object), so callers can skip
+ * persistence cheaply.
  */
 export function settleTreatGrants(
   ledger: TreatLedger,
@@ -74,7 +78,15 @@ export function settleTreatGrants(
   const timeAnchor = ledger.lastTreatGrantAt === 0 ? nowMs : ledger.lastTreatGrantAt
   const timeGrants = Math.floor(Math.max(0, nowMs - timeAnchor) / config.timeTreatMs)
   const gained = workGrants + timeGrants
-  if (gained <= 0) return { ledger, gained: 0 }
+  if (gained <= 0) {
+    if (ledger.lastTreatGrantAt === 0) {
+      // Zero-gain first settlement: persist the clock start anyway, so the
+      // 30-minute time output can begin. Before this fix the anchor stayed 0
+      // forever (the deadlock: no grant means no anchor write means no grant).
+      return { ledger: { ...ledger, lastTreatGrantAt: nowMs }, gained: 0 }
+    }
+    return { ledger, gained: 0 }
+  }
   return {
     ledger: {
       treats: cap(ledger.treats + gained, config.maxTreats),