@linxin666/dsh-pet 0.3.3 → 0.3.5

package/src/service.ts

@@ -56,6 +56,19 @@ import {
   type PetStateInput,
   type PetStateSnapshot,
 } from './state.ts'
+import {
+  applyGameplayEffects,
+  drawLotteryTier,
+  initialGameplayState,
+  rollTouchBranch,
+  rollWorkOutcome,
+  settleGameplay,
+  type PetGameplayManifest,
+  type PetGameplayState,
+} from './gameplay.ts'
+
+/** The unified gameplay currency: the shared treat (小鱼干) ledger. */
+const GAMEPLAY_TREATS_CURRENCY = 'treats'
 
 /** Plugin configuration. */
 export interface PetConfig {
@@ -124,6 +137,8 @@ export interface PetSessionView {
   bubble: string
   /** This session's raw activity phase. */
   phase: PetStateSnapshot['phase']
+  /** This session's fresh inner whisper (碎碎念), when one is within its TTL. */
+  whisper?: string
 }
 
 /** Hard cap on simultaneously displayed session bubbles (most recent first). */
@@ -136,10 +151,10 @@ export interface PetStateView {
   phase: PetStateSnapshot['phase']
   sessionActive: boolean
   /**
-   * Per-session bubbles for every concurrently active TOP-LEVEL session,
-   * most recent first; optional so older hosts without the multi-session
-   * view stay consumable. The single 'bubble' above mirrors the display
-   * session.
+   * Per-session bubbles for every concurrently active TOP-LEVEL session:
+   * the GUI's current session first when reported, the rest most recently
+   * active 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. */
@@ -164,23 +179,46 @@ export interface PetStateView {
     /** Stock cap. */
     max: number
   }
-  /**
-   * The display session's fresh inner whisper (碎碎念), when one is within
-   * its TTL — short inner-voice copy woken by the model's own output,
-   * rendered by the client as a distinct whisper bubble.
-   */
-  whisper?: string
   /**
    * The active status decoration (pet-center M5, #567), when the master
    * switch is on and the default decoration entry exists. Absent means the
    * browser half renders no ornament.
    */
   decoration?: DecorationView
+  /**
+   * The selected pet's gameplay view (miku-pet generalization), present
+   * when the pet declares a gameplay block. Read-only projection: polling
+   * settles the view in memory but never writes pet.json.
+   */
+  gameplay?: PetGameplayStateView
 }
 
 /** Result of `pet.interact`. */
 export type PetInteractResult = LedgerInteractionResult
 
+/** The gameplay slice of the state view (dynamic state only; defs ride the pet definition). */
+export interface PetGameplayStateView {
+  /** Stat values rounded for display. */
+  stats: Record<string, number>
+  mode: 'work' | 'sleep' | null
+}
+
+/** Result of the gameplay verbs (touch / setMode / workTick / buy). */
+export interface PetGameplayVerbResult {
+  ok: boolean
+  error?: string
+  /** Touch: whether a branch hit, plus its presentation. */
+  hit?: boolean
+  state?: string
+  stateMs?: number
+  phrase?: string
+  /** Work tick outcome. */
+  outcome?: 'success' | 'fail'
+  /** Shop purchase: the drawn prize, when the item was a lottery. */
+  prize?: { amount: number; currency: string }
+  view?: PetGameplayStateView
+}
+
 declare module '@deepseek-ai/cordis' {
   interface Context {
     pet: PetService
@@ -296,8 +334,8 @@ export class PetService extends Service {
   }
 
   /** RPC: current pet state snapshot. */
-  async state(): Promise<PetStateView> {
-    return this.view()
+  async state(currentSessionId?: string): Promise<PetStateView> {
+    return this.view(currentSessionId)
   }
 
   /** Current persisted display config (read-only view). */
@@ -483,6 +521,162 @@ export class PetService extends Service {
     return result
   }
 
+  /* ---------------------------------------------------------------- *
+   * Gameplay verbs (miku-pet generalization). The manifest block lives
+   * on the registry entry; dynamic state persists per pet id. Verbs
+   * settle and persist; the state view projects without writing.
+   * ---------------------------------------------------------------- */
+
+  /** The active pet's gameplay block, if it declares one. */
+  private gameplayDef(): PetGameplayManifest | undefined {
+    return this.activeEntry().gameplay
+  }
+
+  /** The persisted (or fresh) gameplay state of the selected pet. */
+  private gameplayState(def: PetGameplayManifest, now: number): { petId: string; state: PetGameplayState } {
+    const petId = this.selectedPetId()
+    const stored = this.ledger.snapshot.gameplay[petId]
+    return {
+      petId,
+      state: stored === undefined
+        ? initialGameplayState(def, now)
+        : { stats: { ...stored.stats }, currencies: { ...stored.currencies }, mode: stored.mode, settledAt: stored.settledAt },
+    }
+  }
+
+  /** Display view of one gameplay state (rounded stats; treats ride the shared treat ledger). */
+  private gameplayViewOf(state: PetGameplayState): PetGameplayStateView {
+    const stats: Record<string, number> = {}
+    for (const [name, value] of Object.entries(state.stats)) stats[name] = Math.round(value)
+    return { stats, mode: state.mode }
+  }
+
+  /**
+   * Move gameplay 'treats' currency (the unified post-wallet currency) from
+   * the engine's settle work area into the shared treat ledger, capped by
+   * the stock cap. The engine keeps its generic currency record for settle
+   * math; this drain is the only bridge to the wallet-free economy.
+   */
+  private drainGameplayTreats(state: PetGameplayState): void {
+    const pending = Math.floor(state.currencies[GAMEPLAY_TREATS_CURRENCY] ?? 0)
+    delete state.currencies[GAMEPLAY_TREATS_CURRENCY]
+    if (pending > 0) this.ledger.grantTreats(pending)
+  }
+
+  /** Persist the mutated gameplay state of one verb call. */
+  private commitGameplay(petId: string, state: PetGameplayState): void {
+    this.ledger.setGameplay(petId, state)
+    if (this.ledger.takeDirty()) this.flush()
+  }
+
+  /**
+   * RPC: a touch on the pet. 'zone' names a touch zone (roll a branch);
+   * omitted means a plain click while a touch animation holds (clickBoost).
+   */
+  async gameplayTouch(zone?: string): Promise<PetGameplayVerbResult> {
+    const def = this.gameplayDef()
+    if (def === undefined) return { ok: false, error: 'no-gameplay' }
+    const now = Date.now()
+    const { petId, state } = this.gameplayState(def, now)
+    settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive })
+    if (zone === undefined) {
+      const boost = def.touch?.clickBoost
+      if (boost === undefined) return { ok: false, error: 'no-touch' }
+      const amount = boost.min + Math.floor(Math.random() * (boost.max - boost.min + 1))
+      if (amount > 0) applyGameplayEffects(state, def, [{ stat: boost.stat, amount }])
+      this.drainGameplayTreats(state)
+      this.commitGameplay(petId, state)
+      return { ok: true, hit: false, view: this.gameplayViewOf(state) }
+    }
+    const target = def.touch?.zones.find(entry => entry.name === zone)
+    if (target === undefined) return { ok: false, error: 'unknown-zone' }
+    const branch = rollTouchBranch(target, Math.random)
+    if (branch === undefined) {
+      this.drainGameplayTreats(state)
+      this.commitGameplay(petId, state)
+      return { ok: true, hit: false, view: this.gameplayViewOf(state) }
+    }
+    if (branch.effects !== undefined) applyGameplayEffects(state, def, branch.effects)
+    const phrase = branch.phrases !== undefined && branch.phrases.length > 0
+      ? branch.phrases[Math.floor(Math.random() * branch.phrases.length)]
+      : undefined
+    this.drainGameplayTreats(state)
+    this.commitGameplay(petId, state)
+    return {
+      ok: true,
+      hit: true,
+      ...(branch.state === undefined ? {} : { state: branch.state }),
+      ...(branch.stateMs === undefined ? {} : { stateMs: branch.stateMs }),
+      ...(phrase === undefined ? {} : { phrase }),
+      view: this.gameplayViewOf(state),
+    }
+  }
+
+  /** RPC: enter or leave a gameplay mode ('work' | 'sleep' | null). */
+  async gameplaySetMode(mode: 'work' | 'sleep' | null): Promise<PetGameplayVerbResult> {
+    const def = this.gameplayDef()
+    if (def === undefined) return { ok: false, error: 'no-gameplay' }
+    if (mode === 'work' && def.work === undefined) return { ok: false, error: 'no-work' }
+    if (mode === 'sleep' && def.sleep === undefined) return { ok: false, error: 'no-sleep' }
+    const now = Date.now()
+    const { petId, state } = this.gameplayState(def, now)
+    settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive })
+    state.mode = mode
+    this.drainGameplayTreats(state)
+    this.commitGameplay(petId, state)
+    return { ok: true, view: this.gameplayViewOf(state) }
+  }
+
+  /** RPC: one work-round adjudication (only while the work mode holds). */
+  async gameplayWorkTick(): Promise<PetGameplayVerbResult> {
+    const def = this.gameplayDef()
+    if (def?.work === undefined) return { ok: false, error: 'no-work' }
+    const now = Date.now()
+    const { petId, state } = this.gameplayState(def, now)
+    if (state.mode !== 'work') return { ok: false, error: 'not-working' }
+    settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive })
+    const outcome = rollWorkOutcome(def.work, Math.random)
+    const effects = outcome === 'success' ? def.work.success?.effects : def.work.fail?.effects
+    if (effects !== undefined) applyGameplayEffects(state, def, effects)
+    this.drainGameplayTreats(state)
+    this.commitGameplay(petId, state)
+    return { ok: true, outcome, view: this.gameplayViewOf(state) }
+  }
+
+  /** RPC: buy one shop item (effects, currency swap, or a lottery draw). */
+  async gameplayBuy(itemId: string): Promise<PetGameplayVerbResult> {
+    const def = this.gameplayDef()
+    if (def === undefined) return { ok: false, error: 'no-gameplay' }
+    const item = def.shop?.items.find(entry => entry.id === itemId)
+    if (item === undefined) return { ok: false, error: 'unknown-item' }
+    const now = Date.now()
+    const { petId, state } = this.gameplayState(def, now)
+    settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive })
+    // The unified currency is the shared treat ledger (wallet removed): shop
+    // prices and prizes ride the same balance the panel shows and feeding
+    // consumes, capped by the stock cap.
+    const treats = item.currency === GAMEPLAY_TREATS_CURRENCY
+    const balance = treats ? this.ledger.snapshot.treats.treats : (state.currencies[item.currency] ?? 0)
+    if (balance < item.price) {
+      return { ok: false, error: 'insufficient-funds', view: this.gameplayViewOf(state) }
+    }
+    if (treats) this.ledger.spendTreats(item.price)
+    else state.currencies[item.currency] = balance - item.price
+    if (item.effects !== undefined) applyGameplayEffects(state, def, item.effects)
+    let prize: PetGameplayVerbResult['prize']
+    if (item.lottery !== undefined) {
+      if (item.lottery.effects !== undefined) applyGameplayEffects(state, def, item.lottery.effects)
+      const tier = drawLotteryTier(item.lottery, Math.random)
+      const prizeCurrency = tier.currency ?? item.lottery.currency ?? item.currency
+      if (prizeCurrency === GAMEPLAY_TREATS_CURRENCY) this.ledger.grantTreats(tier.prize)
+      else state.currencies[prizeCurrency] = (state.currencies[prizeCurrency] ?? 0) + tier.prize
+      prize = { amount: tier.prize, currency: prizeCurrency }
+    }
+    this.drainGameplayTreats(state)
+    this.commitGameplay(petId, state)
+    return { ok: true, ...(prize === undefined ? {} : { prize }), view: this.gameplayViewOf(state) }
+  }
+
   /** RPC: show or hide the pet. */
   async setVisible(visible: boolean): Promise<{ ok: true; display: PetDisplayConfig }> {
     this.ledger.setDisplay({ ...this.ledger.snapshot.display, visible })
@@ -565,38 +759,55 @@ export class PetService extends Service {
     if (this.ledger.rewardLegacyTurn(Date.now())) this.flush()
   }
 
-  private view(): PetStateView {
+  private view(currentSessionId?: string): PetStateView {
     const snapshot = this.machine.render()
     const entry = this.activeEntry()
-    // One bubble per concurrently active TOP-LEVEL session, most recent
-    // first. Subagent children render no bubble of their own (their activity
-    // already shows through the spawning conversation's bubble/display, and
-    // the bubble buttons navigate to GUI sessions, which subagents are not).
-    // Sessions whose own machine has settled (no bubble copy) drop out, so a
-    // finished turn does not leave a stale bubble behind.
+    // One bubble per concurrently active TOP-LEVEL session. The GUI's current
+    // session leads the stack when reported (the browser half passes its
+    // session list's 'current'); everything else keeps the most recent
+    // meaningful event order. Subagent children render no bubble of their own
+    // (their activity already shows through the spawning conversation's
+    // bubble/display, and the bubble buttons navigate to GUI sessions, which
+    // subagents are not). 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
       if (session.header?.origin === 'subagent') continue
       const perSession = activity.machine.render()
       if (perSession.bubble === undefined) continue
+      // Each session's whisper rides its own bubble while fresh; an expired
+      // whisper simply stops appearing (the client's 2 s poll drops it).
+      const whisper = activity.whisper
+      const freshWhisper = whisper !== undefined && Date.now() - whisper.at < WHISPER_TTL_MS
+        ? whisper.text
+        : undefined
       sessions.push({
         sessionId: String(session.id),
         animation: perSession.animation,
         bubble: perSession.bubble,
         phase: perSession.phase,
+        ...(freshWhisper === undefined ? {} : { whisper: freshWhisper }),
       })
     }
-    // The display session's inner whisper rides the global view while fresh;
-    // an expired whisper simply stops appearing (the client's 2s poll drops it).
-    const displayActivity = this.displaySession === undefined
-      ? undefined
-      : this.sessionActivity.get(this.displaySession)
-    const whisper = displayActivity?.whisper
-    const freshWhisper = whisper !== undefined && Date.now() - whisper.at < WHISPER_TTL_MS
-      ? whisper.text
-      : undefined
+    // The browser half reports the session the user is currently on; that
+    // session's bubble leads the stack (its whisper then speaks on the
+    // collapsed single bubble). An unreported or absent session keeps the
+    // legacy most-recent-first order.
+    if (currentSessionId !== undefined) {
+      const index = sessions.findIndex(session => session.sessionId === currentSessionId)
+      if (index > 0) sessions.unshift(sessions.splice(index, 1)[0]!)
+    }
     const decoration = this.activeDecoration()
+    // Gameplay view: a read-only projection. The settle runs on a copy, so
+    // polling never writes pet.json (verbs settle and persist).
+    const gameplayDef = this.gameplayDef()
+    let gameplay: PetGameplayStateView | undefined
+    if (gameplayDef !== undefined) {
+      const { state } = this.gameplayState(gameplayDef, Date.now())
+      settleGameplay(state, gameplayDef, Date.now(), { sessionActive: snapshot.sessionActive })
+      gameplay = this.gameplayViewOf(state)
+    }
     // Read-only: the ledger settles on economic events only, never on a read,
     // so polling the state cannot trigger pet.json writes.
     return {
@@ -605,7 +816,6 @@ export class PetService extends Service {
       phase: snapshot.phase,
       sessionActive: snapshot.sessionActive,
       sessions,
-      ...(freshWhisper === undefined ? {} : { whisper: freshWhisper }),
       ...(decoration === undefined ? {} : { decoration }),
       affinity: this.ledger.affinityView(Date.now()),
       display: { ...this.ledger.snapshot.display },
@@ -619,6 +829,7 @@ export class PetService extends Service {
         stocked: this.ledger.snapshot.treats.treats,
         max: this.ledger.treatMax,
       },
+      ...(gameplay === undefined ? {} : { gameplay }),
     }
   }
 

package/src/voice-pack.test.ts

@@ -12,7 +12,8 @@ import {
   normalizePanel,
   normalizePool,
   normalizeVoicePack,
-  normalizeWhisperRules,
+  normalizeWhisperCategories,
+  normalizeWhisperResults,
   PANEL_ACTIONS,
   PANEL_LABEL_KEYS,
   PANEL_STAT_KEYS,
@@ -21,7 +22,7 @@ import {
   VOICE_PACK_V1,
   WHISPER_KEYS,
 } from './voice-pack.ts'
-import { STATUS_SCENES, TOOL_CATEGORIES } from './chatter.ts'
+import { STATUS_SCENES, TOOL_CATEGORIES, WHISPER_CATEGORIES, WHISPER_RESULTS } from './chatter.ts'
 import { petPackageRoot } from './registry.ts'
 
 function collectWarnings(pack: unknown): { pack: ReturnType<typeof normalizeVoicePack>; warnings: string[] } {
@@ -85,31 +86,40 @@ describe('normalizePool', () => {
   })
 
   it('preserves an explicit empty array (mute semantics) but not absent', () => {
-    expect(normalizePool([], 'whisperGeneric')).toEqual([])
-    expect(normalizePool(undefined, 'whisperGeneric')).toBeUndefined()
+    expect(normalizePool([], 'whisperCategory')).toEqual([])
+    expect(normalizePool(undefined, 'whisperCategory')).toBeUndefined()
   })
 })
 
-describe('normalizeWhisperRules', () => {
-  it('lowercases and trims keywords, drops unusable rules', () => {
+describe('normalizeWhisperCategories', () => {
+  it('keeps known categories, keeps an explicit empty pool (mute) and warns on unknown keys', () => {
     const warnings: string[] = []
-    const rules = normalizeWhisperRules([
-      { keywords: ['  测试通过  ', 7], pool: ['全绿'] },
-      { keywords: [], pool: ['没有关键词'] },
-      { keywords: ['有词'], pool: [] },
-    ], m => warnings.push(m))
-    expect(rules).toEqual([{ keywords: ['测试通过'], pool: ['全绿'] }])
-    expect(warnings.length).toBeGreaterThan(0)
+    const pools = normalizeWhisperCategories({ thinking: ['自定义思考'], running: [], bogus: ['x'] }, m => warnings.push(m))
+    expect(pools).toEqual({ thinking: ['自定义思考'], running: [] })
+    expect(warnings.join('\n')).toContain('unknown whisper category')
   })
 
-  it('caps the rule count and keyword count', () => {
-    const many = Array.from({ length: 40 }, (_, i) => ({ keywords: ['k' + i], pool: ['p'] }))
-    expect(normalizeWhisperRules(many)).toHaveLength(32)
-    expect(normalizeWhisperRules([{ keywords: Array.from({ length: 20 }, (_, i) => 'k' + i), pool: ['p'] }])![0]!.keywords).toHaveLength(16)
+  it('returns undefined for an absent or non-object section', () => {
+    expect(normalizeWhisperCategories(undefined)).toBeUndefined()
+    const warnings: string[] = []
+    expect(normalizeWhisperCategories(['x'], m => warnings.push(m))).toBeUndefined()
+    expect(warnings.join('\n')).toContain('must be an object')
+  })
+})
+
+describe('normalizeWhisperResults', () => {
+  it('keeps known outcomes, keeps an explicit empty pool (mute) and warns on unknown keys', () => {
+    const warnings: string[] = []
+    const pools = normalizeWhisperResults({ pass: ['自定义全绿'], done: [], bogus: ['x'] }, m => warnings.push(m))
+    expect(pools).toEqual({ pass: ['自定义全绿'], done: [] })
+    expect(warnings.join('\n')).toContain('unknown whisper result')
   })
 
-  it('returns an explicit empty array (disables the keyword channel)', () => {
-    expect(normalizeWhisperRules([])).toEqual([])
+  it('returns undefined for an absent or non-object section', () => {
+    expect(normalizeWhisperResults(undefined)).toBeUndefined()
+    const warnings: string[] = []
+    expect(normalizeWhisperResults('x', m => warnings.push(m))).toBeUndefined()
+    expect(warnings.join('\n')).toContain('must be an object')
   })
 })
 
@@ -153,12 +163,22 @@ describe('mergeVoicePacks', () => {
     expect(merged?.panel?.labels).toEqual({ feed: '宠物投喂', hide: '宠物藏' })
   })
 
-  it('lets the pet pack replace whisper sections while the global stays', () => {
-    const global = normalizeVoicePack({ whispers: { generic: ['全局碎碎念'] } })
-    const pet = normalizeVoicePack({ whispers: { rules: [{ keywords: ['测试'], pool: ['宠物全绿'] }] } })
+  it('lets the pet pack replace whisper keys while the global stays', () => {
+    const global = normalizeVoicePack({ whispers: { categories: { thinking: ['全局思考'] }, results: { pass: ['全局全绿'] } } })
+    const pet = normalizeVoicePack({ whispers: { categories: { thinking: ['宠物思考'] } } })
     const merged = mergeVoicePacks(global, pet)
-    expect(merged?.overrides.whispers?.generic).toEqual(['全局碎碎念'])
-    expect(merged?.overrides.whispers?.rules).toEqual([{ keywords: ['测试'], pool: ['宠物全绿'] }])
+    expect(merged?.overrides.whispers?.categories?.thinking).toEqual(['宠物思考'])
+    expect(merged?.overrides.whispers?.results?.pass).toEqual(['全局全绿'])
+  })
+
+  it('warns and ignores the legacy generic / rules whisper fields', () => {
+    const { pack, warnings } = collectWarnings({
+      whispers: { generic: ['老环境池'], rules: [{ keywords: ['测试'], pool: ['老全绿'] }], categories: { thinking: ['新思考'] } },
+    })
+    expect(pack?.overrides.whispers?.categories?.thinking).toEqual(['新思考'])
+    expect(pack?.overrides.whispers?.categories?.generic).toBeUndefined()
+    expect(warnings.join('\n')).toContain('generic')
+    expect(warnings.join('\n')).toContain('rules')
   })
 
   it('returns undefined when every layer is empty', () => {
@@ -200,7 +220,10 @@ describe('voice-pack schema file drift lock', () => {
     const props = schema.properties
     expect(new Set(Object.keys(props.status?.properties ?? {}))).toEqual(new Set(STATUS_SCENES))
     expect(new Set(Object.keys(props.tools?.properties ?? {}))).toEqual(new Set(TOOL_CATEGORIES))
-    expect(new Set(Object.keys(props.whispers?.properties ?? {}))).toEqual(WHISPER_KEYS)
+    const whispers = props.whispers?.properties ?? {}
+    expect(new Set(Object.keys(whispers))).toEqual(WHISPER_KEYS)
+    expect(new Set(Object.keys((whispers.categories as { properties?: Record<string, unknown> })?.properties ?? {}))).toEqual(new Set(WHISPER_CATEGORIES))
+    expect(new Set(Object.keys((whispers.results as { properties?: Record<string, unknown> })?.properties ?? {}))).toEqual(new Set(WHISPER_RESULTS))
     const panel = props.panel?.properties ?? {}
     const labels = (panel.labels as { properties?: Record<string, unknown> } | undefined)?.properties ?? {}
     const stats = (panel.stats as { properties?: Record<string, unknown> } | undefined)?.properties ?? {}

package/src/voice-pack.ts

@@ -31,8 +31,11 @@
 import {
   STATUS_SCENES,
   TOOL_CATEGORIES,
+  WHISPER_CATEGORIES,
+  WHISPER_RESULTS,
   type VoicePackOverrides,
-  type WhisperRule,
+  type WhisperCategory,
+  type WhisperResult,
 } from './chatter.ts'
 
 /** Schema version this module normalizes (optional field; missing = 1). */
@@ -71,9 +74,6 @@ export interface VoicePack {
 /** Hard caps shared by every pool slot (mirrors the remarks discipline). */
 export const VOICE_POOL_LINES_MAX = 64
 export const VOICE_LINE_MAX = 160
-export const VOICE_KEYWORDS_PER_RULE_MAX = 16
-export const VOICE_KEYWORD_MAX = 40
-export const VOICE_RULES_MAX = 32
 export const VOICE_LABEL_MAX = 40
 export const VOICE_STAT_MAX = 80
 
@@ -87,7 +87,7 @@ const PLACEHOLDER_WHITELIST: Partial<Record<PoolKind, readonly string[]>> = {
   stat: ['{rank}', '{n}', '{points}'],
 }
 
-type PoolKind = 'status' | 'tools' | 'toolRemaining' | 'whisperGeneric' | 'whisperRule' | 'label' | 'stat'
+type PoolKind = 'status' | 'tools' | 'toolRemaining' | 'whisperCategory' | 'whisperResult' | 'label' | 'stat'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
@@ -151,51 +151,48 @@ export function normalizePool(
   return pool
 }
 
-/** Normalize the ordered keyword-rule list ([] disables the keyword channel). */
-export function normalizeWhisperRules(
+/** Normalize whisper category pools; a key replaces that category's built-in pool (an explicit empty pool mutes it). */
+export function normalizeWhisperCategories(
   raw: unknown,
   onWarning: (message: string) => void = () => {},
-): WhisperRule[] | undefined {
+): Partial<Record<WhisperCategory, readonly string[]>> | undefined {
   if (raw === undefined) return undefined
-  if (!Array.isArray(raw)) {
-    onWarning('whispers.rules must be an array')
+  if (!isRecord(raw)) {
+    onWarning('whispers.categories must be an object')
     return undefined
   }
-  if (raw.length > VOICE_RULES_MAX) {
-    onWarning('whispers.rules has more than ' + VOICE_RULES_MAX + ' rules; extra rules are ignored')
-  }
-  const rules: WhisperRule[] = []
-  for (const item of raw.slice(0, VOICE_RULES_MAX)) {
-    if (!isRecord(item)) {
-      onWarning('whisper rule must be an object')
+  const pools: Partial<Record<WhisperCategory, readonly string[]>> = {}
+  for (const key of Object.keys(raw)) {
+    if (!(WHISPER_CATEGORIES as readonly string[]).includes(key)) {
+      onWarning('unknown whisper category ' + key + ' ignored')
       continue
     }
-    for (const key of Object.keys(item)) {
-      if (key !== 'keywords' && key !== 'pool') onWarning('unknown whisper rule field ' + key + ' ignored')
-    }
-    const keywordsRaw: unknown = item.keywords
-    const keywords: string[] = []
-    if (Array.isArray(keywordsRaw)) {
-      for (const entry of keywordsRaw.slice(0, VOICE_KEYWORDS_PER_RULE_MAX)) {
-        if (typeof entry !== 'string') {
-          onWarning('non-string keyword dropped')
-          continue
-        }
-        const trimmed = entry.trim().toLowerCase().slice(0, VOICE_KEYWORD_MAX)
-        if (trimmed !== '') keywords.push(trimmed)
-      }
-      if (keywordsRaw.length > VOICE_KEYWORDS_PER_RULE_MAX) {
-        onWarning('rule has more than ' + VOICE_KEYWORDS_PER_RULE_MAX + ' keywords; extra keywords are ignored')
-      }
-    }
-    const pool = normalizePool(item.pool, 'whisperRule', onWarning)
-    if (keywords.length === 0 || pool === undefined || pool.length === 0) {
-      onWarning('whisper rule dropped (needs keywords and a non-empty pool)')
+    const pool = normalizePool(raw[key], 'whisperCategory', onWarning)
+    if (pool !== undefined) pools[key as WhisperCategory] = pool
+  }
+  return Object.keys(pools).length > 0 ? pools : undefined
+}
+
+/** Normalize whisper outcome pools; a key replaces that outcome's built-in pool (an explicit empty pool mutes it). */
+export function normalizeWhisperResults(
+  raw: unknown,
+  onWarning: (message: string) => void = () => {},
+): Partial<Record<WhisperResult, readonly string[]>> | undefined {
+  if (raw === undefined) return undefined
+  if (!isRecord(raw)) {
+    onWarning('whispers.results must be an object')
+    return undefined
+  }
+  const pools: Partial<Record<WhisperResult, readonly string[]>> = {}
+  for (const key of Object.keys(raw)) {
+    if (!(WHISPER_RESULTS as readonly string[]).includes(key)) {
+      onWarning('unknown whisper result ' + key + ' ignored')
       continue
     }
-    rules.push({ keywords, pool })
+    const pool = normalizePool(raw[key], 'whisperResult', onWarning)
+    if (pool !== undefined) pools[key as WhisperResult] = pool
   }
-  return rules
+  return Object.keys(pools).length > 0 ? pools : undefined
 }
 
 /** Normalize the panel block (labels / stats / actions; warn-and-drop). */
@@ -271,7 +268,7 @@ export function normalizePanel(
 export const VOICE_PACK_KEYS = new Set(['$schema', 'voicePackVersion', 'status', 'tools', 'toolRemaining', 'whispers', 'panel'])
 
 /** Allowed whisper-section fields (drift-locked in tests). */
-export const WHISPER_KEYS = new Set(['generic', 'rules'])
+export const WHISPER_KEYS = new Set(['categories', 'results'])
 
 /**
  * Normalize one raw voice.json document into a VoicePack, or undefined when
@@ -340,14 +337,20 @@ export function normalizeVoicePack(
       onWarning('whispers must be an object')
     } else {
       for (const key of Object.keys(whispersRaw)) {
-        if (!WHISPER_KEYS.has(key)) onWarning('unknown whispers field ' + key + ' ignored')
+        if (key === 'generic' || key === 'rules') {
+          // pet M6: keyword and ambient whisper channels are gone; legacy
+          // fields are ignored with a warning, never mapped to the new shape.
+          onWarning('whispers.' + key + ' is no longer supported and was ignored')
+        } else if (!WHISPER_KEYS.has(key)) {
+          onWarning('unknown whispers field ' + key + ' ignored')
+        }
       }
-      const generic = normalizePool(whispersRaw.generic, 'whisperGeneric', onWarning)
-      const rules = normalizeWhisperRules(whispersRaw.rules, onWarning)
-      if (generic !== undefined || rules !== undefined) {
+      const categories = normalizeWhisperCategories(whispersRaw.categories, onWarning)
+      const results = normalizeWhisperResults(whispersRaw.results, onWarning)
+      if (categories !== undefined || results !== undefined) {
         overrides.whispers = {
-          ...(generic === undefined ? {} : { generic }),
-          ...(rules === undefined ? {} : { rules }),
+          ...(categories === undefined ? {} : { categories }),
+          ...(results === undefined ? {} : { results }),
         }
       }
     }