@linxin666/dsh-pet 0.1.18 → 0.1.19

package/src/service.ts

@@ -5,6 +5,10 @@
  * persistence through `persist`. The API gateway maps these methods onto
  * `pet.state` / `pet.pets` / `pet.interact` / `pet.setVisible` /
  * `pet.setConfig` / `pet.setName` / `pet.setPet` for browser consumers.
+ *
+ * Concurrent sessions each keep their own machine: the sprite animation
+ * follows the most recent meaningful event (the display session) while the
+ * state view carries one bubble per active session.
  * @module @linxin666/dsh-pet/service
  */
 
@@ -91,12 +95,37 @@ export interface PetSettingsSection {
 /** Settings namespace of the pet capability. Spelled here rather than imported: the browser half spells the same value. */
 export const PET_SETTINGS_NAMESPACE = 'pet'
 
+/**
+ * One active session as the pet displays it. Sessions run in parallel, so
+ * each gets its own bubble while the sprite itself follows the most recent
+ * meaningful event (the display session).
+ */
+export interface PetSessionView {
+  /** Session identity (stringified for the wire; never exposed as a key). */
+  sessionId: string
+  /** The animation this session's activity maps onto. */
+  animation: PetStateSnapshot['animation']
+  /** This session's status bubble copy. */
+  bubble: string
+  /** This session's raw activity phase. */
+  phase: PetStateSnapshot['phase']
+}
+
+/** Hard cap on simultaneously displayed session bubbles (most recent first). */
+export const MAX_SESSION_BUBBLES = 12
+
 /** Snapshot returned by `pet.state`. */
 export interface PetStateView {
   animation: PetStateSnapshot['animation']
   bubble?: string
   phase: PetStateSnapshot['phase']
   sessionActive: boolean
+  /**
+   * Per-session bubbles for every concurrently active session, most recent
+   * first; optional so older hosts without the multi-session view stay
+   * consumable. The single 'bubble' above mirrors the display session.
+   */
+  sessions?: PetSessionView[]
   /** Affinity ledger snapshot. */
   affinity: PetAffinityView
   /** Display configuration. */
@@ -130,6 +159,14 @@ declare module '@deepseek-ai/cordis' {
   }
 }
 
+/** Per-session pet activity: projection runtime plus the session's own machine. */
+interface SessionActivity {
+  runtime: ProjectionRuntime
+  machine: PetStateMachine
+  /** The session's most recent meaningful input (for display fallback). */
+  lastInput?: PetStateInput
+}
+
 /**
  * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
  * written until an economic event or interaction arrives; event listeners
@@ -140,6 +177,7 @@ export class PetService extends Service {
   static inject: string[] = []
 
   private readonly machine: PetStateMachine
+  private readonly stateConfig: PetStateConfig
   private readonly ledger: PetLedger
   private readonly registry: PetRegistry
   private readonly persistDir: string
@@ -147,7 +185,12 @@ export class PetService extends Service {
   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>()
+  /**
+   * Per-session activity, most recent last (Map insertion order). Bounded by
+   * MAX_SESSION_BUBBLES so a burst of sessions cannot grow it without bound;
+   * disposed sessions are removed by the 'session/disposed' listener.
+   */
+  private readonly sessionActivity = new Map<Session, SessionActivity>()
 
   constructor(ctx: Context, config: PetConfig = {}) {
     super(ctx, 'pet')
@@ -166,12 +209,15 @@ export class PetService extends Service {
       // copied pet.json): fall back to the registry default.
       persist = { ...persist, petId: this.registry.defaultEntry().id }
     }
-    const ledgerConfig: LedgerConfig = { affinity: config.affinity, treats: config.treats }
+    const selected = this.registry.byId(persist.petId) ?? this.registry.defaultEntry()
+    const ledgerConfig: LedgerConfig = {
+      affinity: config.affinity,
+      treats: config.treats,
+      remarks: selected.remarks,
+    }
     this.ledger = new PetLedger(persist, ledgerConfig)
-    this.machine = new PetStateMachine({
-      ...defaultPetStateConfig,
-      ...(config.state ?? {}),
-    })
+    this.stateConfig = { ...defaultPetStateConfig, ...(config.state ?? {}) }
+    this.machine = new PetStateMachine(this.stateConfig)
     this.enabled = config.enabled ?? true
 
     this.syncActivity()
@@ -224,6 +270,7 @@ export class PetService extends Service {
     const entry = this.registry.byId(petId)
     if (entry === undefined) return { ok: false, error: 'unknown-pet' }
     this.ledger.setPetId(entry.id)
+    this.ledger.setRemarks(entry.remarks)
     this.flush()
     this.syncSettingsFromPet()
     return { ok: true, petId: entry.id }
@@ -244,7 +291,7 @@ export class PetService extends Service {
     this.disposeActivity = (() => {
       const disposers = [
         this.ctx.on('session/event', (session: Session, event: SessionEvent) => {
-          const runtime = this.activityRuntime(session)
+          const runtime = this.activityOf(session).runtime
           // `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.
@@ -274,27 +321,60 @@ export class PetService extends Service {
           }
         }),
         this.ctx.on('session/disposed', (session: Session) => {
+          this.ledger.forgetSession(String(session.id))
+          this.sessionActivity.delete(session)
           if (session !== this.displaySession) return
+          // The display session is gone: fall back to the most recent
+          // remaining session's last input, or settle to idle when none.
           this.displaySession = undefined
-          this.machine.onSessionDisposed()
+          const remaining = [...this.sessionActivity.entries()].at(-1)
+          if (remaining !== undefined) {
+            const [nextSession, activity] = remaining
+            this.displaySession = nextSession
+            if (activity.lastInput !== undefined) this.machine.onActivityStatus(activity.lastInput)
+            this.machine.onSessionActive()
+          } else {
+            this.machine.onSessionDisposed()
+          }
         }),
       ]
       return () => { for (const dispose of disposers) dispose() }
     })()
   }
 
-  /** 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 the per-session activity record, creating it on first sight. */
+  private activityOf(session: Session): SessionActivity {
+    let activity = this.sessionActivity.get(session)
+    if (activity === undefined) {
+      activity = {
+        runtime: emptyProjectionRuntime(),
+        machine: new PetStateMachine(this.stateConfig),
+      }
+      this.sessionActivity.set(session, activity)
     }
-    return runtime
+    return activity
   }
 
-  /** Commit one activity as the host-global pet's most recent display state. */
+  /**
+   * Commit one activity: the session's own machine renders its bubble, and
+   * the session becomes the host-global display session (most recent
+   * meaningful event wins the sprite animation).
+   */
   private applyActivity(session: Session, input: PetStateInput): void {
+    const activity = this.activityOf(session)
+    activity.lastInput = input
+    activity.machine.onActivityStatus(input)
+    activity.machine.onSessionActive()
+    // Move to the tail so map order reads most-recent-last, then trim the
+    // oldest session states beyond the bubble cap. The display session is
+    // reassigned below, so trimming its stale predecessor is safe.
+    this.sessionActivity.delete(session)
+    this.sessionActivity.set(session, activity)
+    while (this.sessionActivity.size > MAX_SESSION_BUBBLES) {
+      const oldest = this.sessionActivity.keys().next().value
+      if (oldest === undefined) break
+      this.sessionActivity.delete(oldest)
+    }
     this.displaySession = session
     this.machine.onActivityStatus(input)
     this.machine.onSessionActive()
@@ -345,8 +425,10 @@ export class PetService extends Service {
    * @param section - the resolved settings section.
    */
   applySettingsSection(section: PetSettingsSection): void {
-    if (typeof section.petId === 'string' && this.registry.byId(section.petId) !== undefined) {
-      this.ledger.setPetId(section.petId)
+    const selected = typeof section.petId === 'string' ? this.registry.byId(section.petId) : undefined
+    if (selected !== undefined) {
+      this.ledger.setPetId(selected.id)
+      this.ledger.setRemarks(selected.remarks)
     } else if (section.petId !== undefined) {
       // The stored selection names a pet the registry no longer has: keep the
       // current selection and repair the settings document.
@@ -390,6 +472,21 @@ export class PetService extends Service {
   private view(): PetStateView {
     const snapshot = this.machine.render()
     const entry = this.activeEntry()
+    // One bubble per concurrently active session, most recent first.
+    // Sessions whose own machine has settled (no bubble copy) drop out, so a
+    // finished turn does not leave a stale bubble behind.
+    const sessions: PetSessionView[] = []
+    for (const [session, activity] of [...this.sessionActivity.entries()].reverse()) {
+      if (sessions.length >= MAX_SESSION_BUBBLES) break
+      const perSession = activity.machine.render()
+      if (perSession.bubble === undefined) continue
+      sessions.push({
+        sessionId: String(session.id),
+        animation: perSession.animation,
+        bubble: perSession.bubble,
+        phase: perSession.phase,
+      })
+    }
     // Read-only: the ledger settles on economic events only, never on a read,
     // so polling the state cannot trigger pet.json writes.
     return {
@@ -397,6 +494,7 @@ export class PetService extends Service {
       ...(snapshot.bubble === undefined ? {} : { bubble: snapshot.bubble }),
       phase: snapshot.phase,
       sessionActive: snapshot.sessionActive,
+      sessions,
       affinity: this.ledger.affinityView(Date.now()),
       display: { ...this.ledger.snapshot.display },
       pet: {

package/src/state.test.ts

@@ -43,6 +43,15 @@ describe('PetStateMachine', () => {
     expect(machine.render().bubble).toBeUndefined()
   })
 
+  it('never bubbles a settled idle session, even with a projected line', () => {
+    // An aborted turn projects idle + '已停止'; a stopped session must not
+    // linger in the bubble stack.
+    const machine = new PetStateMachine(defaultPetStateConfig, () => 1_000)
+    machine.onActivityStatus({ phase: 'idle', line: '已停止' })
+    expect(machine.render().bubble).toBeUndefined()
+    expect(machine.render()).toMatchObject({ animation: 'idle', phase: 'idle' })
+  })
+
   it('resets on session dispose', () => {
     const machine = new PetStateMachine(defaultPetStateConfig, () => 1_000)
     machine.onSessionActive()

package/src/state.ts

@@ -144,11 +144,11 @@ export class PetStateMachine {
         animation = 'idle'
       }
     }
-    const bubble = this.phase === 'done'
-      && this.doneAt !== undefined
-      && nowMs - this.doneAt >= this.config.celebrateMs
-      ? undefined
-      : this.phrase ?? this.line
+    // Settled sessions never bubble: idle (e.g. an aborted/stopped turn)
+    // and done past its celebration window both fall silent.
+    const settled = this.phase === 'idle'
+      || (this.phase === 'done' && this.doneAt !== undefined && nowMs - this.doneAt >= this.config.celebrateMs)
+    const bubble = settled ? undefined : this.phrase ?? this.line
     return {
       animation,
       ...(bubble === undefined ? {} : { bubble }),

package/src/treats.test.ts

@@ -7,20 +7,22 @@ import {
 } from './treats.ts'
 
 describe('settleTreatGrants', () => {
-  it('grants one treat per turnsPerTreat completed turns', () => {
+  it('grants one treat per 30 completed turns (10x difficulty)', () => {
     const ledger = { ...emptyTreatLedger(), turnsAtLastTreatGrant: 0 }
-    const s = settleTreatGrants(ledger, 6, 1_000, defaultTreatConfig)
+    const s = settleTreatGrants(ledger, 60, 1_000, defaultTreatConfig)
     expect(s.gained).toBe(2)
     expect(s.ledger.treats).toBe(2)
-    expect(s.ledger.turnsAtLastTreatGrant).toBe(6)
+    expect(s.ledger.turnsAtLastTreatGrant).toBe(60)
+    // 29 turns are no longer enough for a treat.
+    expect(settleTreatGrants(emptyTreatLedger(), 29, 1_000, defaultTreatConfig).gained).toBe(0)
   })
 
-  it('grants time-output treats per elapsed period', () => {
+  it('grants time-output treats per 300-minute period (10x difficulty)', () => {
     const ledger = { ...emptyTreatLedger(), lastTreatGrantAt: 1_000 }
-    const s = settleTreatGrants(ledger, 0, 1_000 + 90 * 60_000, defaultTreatConfig)
+    const s = settleTreatGrants(ledger, 0, 1_000 + 900 * 60_000, defaultTreatConfig)
     expect(s.gained).toBe(3)
     expect(s.ledger.treats).toBe(3)
-    expect(s.ledger.lastTreatGrantAt).toBe(1_000 + 90 * 60_000)
+    expect(s.ledger.lastTreatGrantAt).toBe(1_000 + 900 * 60_000)
   })
 
   it('does not backfill time output before the first settlement, but starts the clock', () => {
@@ -55,7 +57,7 @@ describe('settleTreatGrants', () => {
 
   it('caps stocked treats at maxTreats', () => {
     const ledger = { ...emptyTreatLedger(), treats: 19, lastTreatGrantAt: 1_000, turnsAtLastTreatGrant: 0 }
-    const s = settleTreatGrants(ledger, 6, 1_000 + 30 * 60_000, defaultTreatConfig)
+    const s = settleTreatGrants(ledger, 60, 1_000 + 30 * 60_000, defaultTreatConfig)
     expect(s.ledger.treats).toBe(defaultTreatConfig.maxTreats)
   })
 
@@ -73,17 +75,17 @@ describe('settleTreatGrants', () => {
   })
 
   it('a continuously working user still earns time treats (work does not reset the time anchor)', () => {
-    // First settlement: 3 completed turns grant one work treat and start the
+    // First settlement: 30 completed turns grant one work treat and start the
     // time clock without touching the work anchor's independence.
     let ledger = emptyTreatLedger()
-    const first = settleTreatGrants(ledger, 3, 1_000, defaultTreatConfig)
+    const first = settleTreatGrants(ledger, 30, 1_000, defaultTreatConfig)
     expect(first.gained).toBe(1)
     ledger = first.ledger
-    // Keep working in 3-turn steps well under one time period: every work
+    // Keep working in 30-turn steps well under one time period: every work
     // settlement must advance only the turn anchor, never the time anchor.
     const stepMs = defaultTreatConfig.timeTreatMs / 100
     for (let i = 0; i < 10; i++) {
-      const s = settleTreatGrants(ledger, 3 + ((i + 1) * 3), 1_000 + ((i + 1) * stepMs), defaultTreatConfig)
+      const s = settleTreatGrants(ledger, 30 + ((i + 1) * 30), 1_000 + ((i + 1) * stepMs), defaultTreatConfig)
       expect(s.gained).toBe(1)
       expect(s.ledger.lastTreatGrantAt).toBe(1_000)
       ledger = s.ledger

package/src/treats.ts

@@ -3,6 +3,9 @@
  * two sources, both tied to companionship:
  *  - work output: every N completed turns grant one treat;
  *  - time output: every T minutes of wall-clock time grant one treat.
+ * Difficulty tuned deliberately high (10x the original cadence): treats are
+ * a rare delicacy the pet earns through sustained companionship, not a
+ * routine drop.
  * Feeding consumes one treat. Settlement is lazy: it runs whenever the host
  * serves a state snapshot or an interaction, so there is no timer and no
  * drift — elapsed periods are computed from the persisted last-grant marks.
@@ -20,8 +23,8 @@ export interface TreatConfig {
 }
 
 export const defaultTreatConfig: TreatConfig = {
-  turnsPerTreat: 3,
-  timeTreatMs: 30 * 60_000,
+  turnsPerTreat: 30,
+  timeTreatMs: 300 * 60_000,
   maxTreats: 20,
 }
 

package/lib/state-CFyJv0sQ.js

@@ -1,213 +0,0 @@
-//#region src/affinity.ts
-const AFFINITY_MAX = 100;
-/** Affinity ranks by points; the pet visibly grows with its rank.
-*  Marker glyphs are plain ASCII (the repo bans all emoji characters);
-*  they read as a growing star trail alongside the rank name. */
-const AFFINITY_RANKS = [
-	{
-		min: 0,
-		name: "幼鲸",
-		emoji: "*"
-	},
-	{
-		min: 25,
-		name: "伙伴",
-		emoji: "**"
-	},
-	{
-		min: 50,
-		name: "挚友",
-		emoji: "***"
-	},
-	{
-		min: 80,
-		name: "深海羁绊",
-		emoji: "****"
-	}
-];
-const defaultAffinityConfig = {
-	turnReward: 1,
-	petReward: 1,
-	petCooldownMs: 1e4,
-	feedReward: 5,
-	feedCooldownMs: 3e4
-};
-function emptyAffinity() {
-	return {
-		points: 0,
-		lastPetAt: 0,
-		lastFeedAt: 0,
-		pets: 0,
-		feeds: 0,
-		turns: 0
-	};
-}
-/** Rank for a point total. */
-function rankOf(points) {
-	let rank = AFFINITY_RANKS[0];
-	for (const candidate of AFFINITY_RANKS) if (points >= candidate.min) rank = candidate;
-	return rank;
-}
-/** Derive the read-only view of one affinity state at a wall-clock instant. */
-function affinityViewOf(state, nowMs, config = defaultAffinityConfig) {
-	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) {
-	return Math.min(100, Math.max(0, points));
-}
-/**
-* Apply one interaction to a copy of the state (immutable style: returns a
-* new object; the caller replaces the persisted state). Cooldowns only
-* apply once the pet has been interacted with at least once (last*At === 0
-* means "never", so the first pet/feed always lands).
-*/
-function applyInteraction(state, kind, nowMs, config = defaultAffinityConfig) {
-	const next = { ...state };
-	if (kind === "pet") {
-		if (state.lastPetAt !== 0 && nowMs - state.lastPetAt < config.petCooldownMs) return {
-			affinity: state,
-			delta: 0,
-			reaction: "摸过头啦，让鲸鱼娘歇口气～",
-			accepted: false
-		};
-		next.lastPetAt = nowMs;
-		next.pets += 1;
-		next.points = clamp(state.points + config.petReward);
-		return {
-			affinity: next,
-			delta: config.petReward,
-			reaction: "咕噜咕噜～被摸摸好舒服！",
-			accepted: true
-		};
-	}
-	if (kind === "feed") {
-		if (state.lastFeedAt !== 0 && nowMs - state.lastFeedAt < config.feedCooldownMs) return {
-			affinity: state,
-			delta: 0,
-			reaction: "吃饱啦，晚点再喂～",
-			accepted: false
-		};
-		next.lastFeedAt = nowMs;
-		next.feeds += 1;
-		next.points = clamp(state.points + config.feedReward);
-		return {
-			affinity: next,
-			delta: config.feedReward,
-			reaction: "呜哇！小鱼干好好吃！",
-			accepted: true
-		};
-	}
-	return {
-		affinity: state,
-		delta: 0,
-		reaction: "",
-		accepted: false
-	};
-}
-/** Reward one completed turn (called by the host on `done`). */
-function applyTurnReward(state, config = defaultAffinityConfig) {
-	const next = { ...state };
-	next.turns += 1;
-	next.points = clamp(state.points + config.turnReward);
-	return next;
-}
-//#endregion
-//#region src/state.ts
-const defaultPetStateConfig = { celebrateMs: 2400 };
-/**
-* Map one activity phase onto the animation contract.
-* - 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).
-*/
-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";
-	}
-}
-/** The spritesheet row index for one animation track. */
-function rowOf(animation) {
-	return {
-		"idle": 0,
-		"running-right": 1,
-		"running-left": 2,
-		"waving": 3,
-		"jumping": 4,
-		"failed": 5,
-		"waiting": 6,
-		"running": 7,
-		"review": 8
-	}[animation];
-}
-/**
-* PetStateMachine — one instance per host process. Holds only the latest
-* input snapshot and the celebration timing; no storage, no side effects.
-*/
-var PetStateMachine = class {
-	config;
-	now;
-	phase = "idle";
-	line;
-	phrase;
-	sessionActive = false;
-	doneAt;
-	constructor(config = defaultPetStateConfig, now = Date.now) {
-		this.config = config;
-		this.now = now;
-	}
-	/** Consume one projected activity update. */
-	onActivityStatus(input) {
-		this.phase = input.phase;
-		this.line = input.line;
-		this.phrase = input.phrase;
-		if (input.phase === "done") this.doneAt = this.now();
-	}
-	/** A session became the active one (or a fresh session started). */
-	onSessionActive() {
-		this.sessionActive = true;
-	}
-	/** The active session was disposed (or none left). */
-	onSessionDisposed() {
-		this.sessionActive = false;
-		this.phase = "idle";
-		this.line = void 0;
-		this.phrase = void 0;
-		this.doneAt = void 0;
-	}
-	/** Render the current animation decision. */
-	render() {
-		const nowMs = this.now();
-		let animation = animationForPhase(this.phase);
-		if (this.phase === "done" && this.doneAt !== void 0) if (nowMs - this.doneAt < this.config.celebrateMs) animation = "jumping";
-		else animation = "idle";
-		const bubble = this.phase === "done" && this.doneAt !== void 0 && nowMs - this.doneAt >= this.config.celebrateMs ? void 0 : this.phrase ?? this.line;
-		return {
-			animation,
-			...bubble === void 0 ? {} : { bubble },
-			animationStartedAt: nowMs,
-			phase: this.phase,
-			sessionActive: this.sessionActive
-		};
-	}
-};
-//#endregion
-export { AFFINITY_MAX as a, applyInteraction as c, emptyAffinity as d, rankOf as f, rowOf as i, applyTurnReward as l, animationForPhase as n, AFFINITY_RANKS as o, defaultPetStateConfig as r, affinityViewOf as s, PetStateMachine as t, defaultAffinityConfig as u };