@linxin666/dsh-pet 0.3.4 → 0.3.6

package/src/event-projection.ts

@@ -5,15 +5,26 @@
  * {@link ProjectionRuntime} per session and feed events in arrival order.
  *
  * Status copy comes from the chatter voice (big rotating pools, per-tool
- * families, real-argument hints), and streamed model output feeds the murmur
- * engine so the pet can whisper its inner voice (碎碎念). The wall clock is
+ * families, real-argument hints), and the projection feeds the murmur engine
+ * (碎碎念) with the SITUATION — thinking/writing during the stream, the
+ * running tool family on tool calls, and the STRUCTURED outcome on
+ * tool/result and turn/end — so the pet's inner voice always roughly knows
+ * what is going on and never mis-fires on output text. The wall clock is
  * injected by the caller, keeping every projection reproducible.
  * @module @linxin666/dsh-pet/event-projection
  */
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import type { PetStateInput } from './state.ts'
-import { StatusVoice, toolArgHint, WhisperEngine, type VoicePoolsProvider } from './chatter.ts'
+import {
+  StatusVoice,
+  toolArgHint,
+  toolCategory,
+  WhisperEngine,
+  whisperCategoryOf,
+  looksLikeTestTool,
+  type VoicePoolsProvider,
+} from './chatter.ts'
 
 /** Runtime shape of the optional legacy activity event. */
 export interface ActivityStatusEventLike {
@@ -25,11 +36,13 @@ export interface ActivityStatusEventLike {
 /** Per-session facts needed to project the official event stream. */
 export interface ProjectionRuntime {
   activeTools: Set<string>
+  /** callIds whose tool looked like a test run, marked at tool/call (pet M6). */
+  testCalls: Set<string>
   officialEventsSeen: boolean
   stepHadFailure: boolean
   /** Round-robin status copy voice (scene-stable, cadence-rotated). */
   voice: StatusVoice
-  /** Inner-whisper engine fed by the model's own streamed output. */
+  /** Inner-whisper engine fed by the projection's situation and outcomes. */
   whispers: WhisperEngine
 }
 
@@ -37,7 +50,7 @@ export interface ProjectionRuntime {
 export interface PetActivityTransition {
   input: PetStateInput
   completedTurn?: number
-  /** A fresh inner whisper woken by this event's model output, when any. */
+  /** A fresh inner whisper woken by this event, when any. */
   whisper?: string
 }
 
@@ -50,6 +63,7 @@ export interface PetActivityTransition {
 export function emptyProjectionRuntime(pools?: VoicePoolsProvider): ProjectionRuntime {
   return {
     activeTools: new Set(),
+    testCalls: new Set(),
     officialEventsSeen: false,
     stepHadFailure: false,
     voice: new StatusVoice(pools),
@@ -81,6 +95,7 @@ export function projectOfficialEvent(
   switch (event.type) {
     case 'turn/start':
       runtime.activeTools.clear()
+      runtime.testCalls.clear()
       runtime.stepHadFailure = false
       return { input: { phase: 'waiting', line: runtime.voice.scene('prepare', nowMs) } }
     case 'step/start':
@@ -90,14 +105,14 @@ export function projectOfficialEvent(
     case 'assistant/chunk': {
       const { chunk } = event.data
       if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
-        const whisper = runtime.whispers.feed(chunk.text, nowMs)
+        const whisper = runtime.whispers.feed('thinking', nowMs)
         return {
           input: { phase: 'thinking', line: runtime.voice.scene('thinking', nowMs) },
           ...(whisper === undefined ? {} : { whisper }),
         }
       }
       if (chunk.type === 'text-delta' && chunk.text.length > 0) {
-        const whisper = runtime.whispers.feed(chunk.text, nowMs)
+        const whisper = runtime.whispers.feed('writing', nowMs)
         return {
           input: { phase: 'review', line: runtime.voice.scene('review', nowMs) },
           ...(whisper === undefined ? {} : { whisper }),
@@ -107,8 +122,13 @@ export function projectOfficialEvent(
     }
     case 'assistant/message':
       return { input: { phase: 'review', line: runtime.voice.scene('review', nowMs) } }
-    case 'tool/call':
-      runtime.activeTools.add(String(event.data.callId))
+    case 'tool/call': {
+      const callId = String(event.data.callId)
+      runtime.activeTools.add(callId)
+      // A test-looking call is remembered so its result (the only place the
+      // outcome is known) can wake the test-green mood later.
+      if (looksLikeTestTool(event.data.name, event.data.arguments)) runtime.testCalls.add(callId)
+      const whisper = runtime.whispers.feed(whisperCategoryOf(toolCategory(event.data.name)), nowMs)
       return {
         input: {
           phase: 'tool',
@@ -119,33 +139,54 @@ export function projectOfficialEvent(
             nowMs,
           ),
         },
+        ...(whisper === undefined ? {} : { whisper }),
       }
+    }
     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
+      const callId = String(event.data.message.source.callId)
+      const failed = event.data.error !== undefined || block.isError === true
+      const wasTest = runtime.testCalls.delete(callId)
+      runtime.activeTools.delete(callId)
+      runtime.stepHadFailure ||= failed
+      const whisper = failed
+        ? runtime.whispers.result('fail', nowMs)
+        : wasTest
+          ? runtime.whispers.result('pass', nowMs)
+          : undefined
+      const whisperSpread = whisper === undefined ? {} : { whisper }
       if (runtime.activeTools.size > 0) {
         return {
           input: {
             phase: 'tool',
             line: runtime.voice.toolRemaining(runtime.activeTools.size, nowMs),
           },
+          ...whisperSpread,
         }
       }
       return runtime.stepHadFailure
-        ? { input: { phase: 'failed', line: runtime.voice.scene('toolFailed', nowMs) } }
-        : { input: { phase: 'thinking', line: runtime.voice.scene('toolResult', nowMs) } }
+        ? { input: { phase: 'failed', line: runtime.voice.scene('toolFailed', nowMs) }, ...whisperSpread }
+        : { input: { phase: 'thinking', line: runtime.voice.scene('toolResult', nowMs) }, ...whisperSpread }
     }
     case 'turn/end': {
       runtime.activeTools.clear()
+      runtime.testCalls.clear()
       switch (event.data.reason.kind) {
-        case 'completed':
+        case 'completed': {
+          const whisper = runtime.whispers.result('done', nowMs)
           return {
             input: { phase: 'done', line: runtime.voice.scene('done', nowMs) },
             completedTurn: event.data.turn,
+            ...(whisper === undefined ? {} : { whisper }),
           }
-        case 'error':
-          return { input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) } }
+        }
+        case 'error': {
+          const whisper = runtime.whispers.result('fail', nowMs)
+          return {
+            input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) },
+            ...(whisper === undefined ? {} : { whisper }),
+          }
+        }
         case 'max-tokens':
           return { input: { phase: 'failed', line: runtime.voice.scene('maxTokens', nowMs) } }
         case 'interrupted':

package/src/ledger.ts

@@ -32,6 +32,8 @@ export interface LedgerConfig {
   treats?: Partial<TreatConfig>
   /** Per-pet remark pools for the selected pet (custom slots override built-ins). */
   remarks?: PetRemarks
+  /** Voice-pack fallback remark pools (global or pet voice pack). */
+  voiceRemarks?: PetRemarks
 }
 
 /** Result of one ledger interaction (the shape the pet RPC returns). */
@@ -63,7 +65,7 @@ export class PetLedger {
   constructor(persist: PetPersist, config: LedgerConfig = {}) {
     this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) }
     this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) }
-    this.picker = new RemarkPicker(config.remarks)
+    this.picker = new RemarkPicker(config.remarks, config.voiceRemarks)
     this.current = persist
   }
 
@@ -124,10 +126,10 @@ export class PetLedger {
 
   /**
    * Swap the reaction pools to another pet's custom remarks (called on pet
-   * selection). Slots the pet does not declare fall back to built-ins.
+   * selection). Slots the pet does not declare fall back to voice packs or built-ins.
    */
-  setRemarks(remarks?: PetRemarks): void {
-    this.picker = new RemarkPicker(remarks)
+  setRemarks(remarks?: PetRemarks, voiceRemarks?: PetRemarks): void {
+    this.picker = new RemarkPicker(remarks, voiceRemarks)
   }
 
   /**

package/src/pair-access.ts

@@ -0,0 +1,49 @@
+// Generated by scripts/sync-shared.mjs from shared/host/pair-access.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * Pairing trust fence shared by plugins that expose host routes: loopback
+ * (the desktop) always passes; a live paired-device cookie is an additional
+ * allow path when remote-web-ui is loaded. The consuming plugin never
+ * depends on that plugin — without the service the fence stays
+ * loopback-only.
+ *
+ * Per-package wrappers (access.ts) call this with their own name so each
+ * plugin keeps a self-describing export; the security decision lives only
+ * here.
+ */
+import type { IncomingMessage } from 'node:http'
+import { isLoopbackRequest } from './loopback.ts'
+
+/** Structural pairing lookup (no package dependency on remote-web-ui). */
+interface PairingAccess {
+  isPairedDevice(request: IncomingMessage): boolean
+}
+
+/**
+ * Structural host-context shape: shared sources carry no @deepseek-ai
+ * dependency (the shared package must typecheck standalone), so the fence
+ * reads only the two members it needs; cordis Context satisfies this.
+ * ctx.get is optional on the test harness; production Context always has it.
+ */
+interface LookupCtx {
+  get?(name: string, strict?: boolean): unknown
+  remoteWebUiPairing?: PairingAccess
+}
+
+/**
+ * Whether this request may enter the plugin's host routes.
+ * @param ctx - host context; may expose remoteWebUiPairing.
+ * @param request - the incoming HTTP request.
+ * @returns true for loopback, or a live paired-device cookie.
+ */
+export function isPairedOrLoopbackAllowed(ctx: LookupCtx, request: IncomingMessage): boolean {
+  if (isLoopbackRequest(request)) return true
+  const fromGet = typeof ctx.get === 'function' ? ctx.get('remoteWebUiPairing', false) : undefined
+  const pairing = (isPairingAccess(fromGet) ? fromGet : ctx.remoteWebUiPairing)
+  return pairing?.isPairedDevice(request) === true
+}
+
+function isPairingAccess(value: unknown): value is PairingAccess {
+  return value !== undefined
+    && value !== null
+    && typeof (value as PairingAccess).isPairedDevice === 'function'
+}

package/src/remarks.test.ts

@@ -54,6 +54,16 @@ describe('RemarkPicker', () => {
     expect(picker.pick('pet')).toBe('专属摸头台词')
     expect(picker.pick('feed')).toBe(BUILTIN_REMARKS.feed[0])
   })
+
+  it('layers pet custom lines over voice pack lines, falling back to built-ins (#1226)', () => {
+    const picker = new RemarkPicker(
+      { pet: ['Pet-level line'] },
+      { pet: ['Voice-level pet line'], feed: ['Voice-level feed line'] },
+    )
+    expect(picker.pick('pet')).toBe('Pet-level line')
+    expect(picker.pick('feed')).toBe('Voice-level feed line')
+    expect(picker.pick('noTreats')).toBe(BUILTIN_REMARKS.noTreats[0])
+  })
 })
 
 describe('normalizePetRemarks', () => {

package/src/remarks.ts

@@ -184,11 +184,18 @@ export class RemarkPicker {
   private readonly counters = new Map<RemarkKind, number>()
   private readonly pools: Record<RemarkKind, readonly string[]>
 
-  constructor(overrides?: PetRemarks) {
+  constructor(overrides?: PetRemarks, voiceOverrides?: PetRemarks) {
     this.pools = {} as Record<RemarkKind, readonly string[]>
     for (const kind of REMARK_KINDS) {
       const custom = overrides?.[kind]
-      this.pools[kind] = custom !== undefined && custom.length > 0 ? custom : BUILTIN_REMARKS[kind]
+      const voice = voiceOverrides?.[kind]
+      if (custom !== undefined && custom.length > 0) {
+        this.pools[kind] = custom
+      } else if (voice !== undefined && voice.length > 0) {
+        this.pools[kind] = voice
+      } else {
+        this.pools[kind] = BUILTIN_REMARKS[kind]
+      }
     }
   }
 

package/src/routes.ts

@@ -112,15 +112,15 @@ function guard(ctx: Context, req: IncomingMessage, res: ServerResponse): boolean
   return false
 }
 
-/** Wrap one async service call as a GET JSON route. */
-function getRoute(ctx: Context, path: string, run: () => Promise<unknown>): WebRoute {
+/** Wrap one async service call as a GET JSON route (request passed through for query params). */
+function getRoute(ctx: Context, path: string, run: (req: IncomingMessage) => Promise<unknown>): WebRoute {
   return {
     kind: 'exact',
     path,
     handler: (req: IncomingMessage, res: ServerResponse): void => {
       if (!guard(ctx, req, res)) return
       if (!requireMethod(req, res, 'GET')) return
-      run().then((value) => writeJson(res, 200, value), (error) => {
+      run(req).then((value) => writeJson(res, 200, value), (error) => {
         writeJson(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) })
       })
     },
@@ -525,7 +525,12 @@ function decorationHandler(ctx: Context, registry: PetRegistry, caps: PetAssetCa
 export function makePetRoutes(deps: { service: PetService; ctx: Context; assetCaps?: PetAssetCaps } & PetRuntimeRoots): WebRoute[] {
   const { service, ctx } = deps
   const apiRoutes: WebRoute[] = [
-    getRoute(ctx, PET_API_PREFIX + '/state', () => service.state()),
+    getRoute(ctx, PET_API_PREFIX + '/state', (req) => {
+      // The browser half reports the GUI's current session id so the bubble
+      // stack can lead with the session the user is actually looking at.
+      const current = new URL(req.url ?? '/', 'http://pet.local').searchParams.get('current')
+      return service.state(current === null || current === '' ? undefined : current)
+    }),
     getRoute(ctx, PET_API_PREFIX + '/pets', () => service.pets()),
     getRoute(ctx, PET_API_PREFIX + '/diagnostics', () => service.diagnostics()),
     postRoute(ctx, PET_API_PREFIX + '/interact', (body) => {

package/src/service.ts

@@ -137,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). */
@@ -149,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. */
@@ -177,12 +179,6 @@ 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
@@ -301,10 +297,12 @@ export class PetService extends Service {
       persist = { ...persist, petId: this.registry.defaultEntry().id }
     }
     const selected = this.registry.byId(persist.petId) ?? this.registry.defaultEntry()
+    const voiceRemarks = mergeVoicePacks(this.registry.globalVoice, selected.voice)?.remarks
     const ledgerConfig: LedgerConfig = {
       affinity: config.affinity,
       treats: config.treats,
       remarks: selected.remarks,
+      voiceRemarks,
     }
     this.ledger = new PetLedger(persist, ledgerConfig)
     this.stateConfig = { ...defaultPetStateConfig, ...(config.state ?? {}) }
@@ -338,8 +336,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). */
@@ -394,7 +392,8 @@ 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)
+    const voiceRemarks = mergeVoicePacks(this.registry.globalVoice, entry.voice)?.remarks
+    this.ledger.setRemarks(entry.remarks, voiceRemarks)
     this.flush()
     this.syncSettingsFromPet()
     return { ok: true, petId: entry.id }
@@ -763,37 +762,45 @@ 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).
@@ -812,7 +819,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 },

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[] } {
@@ -52,6 +53,45 @@ describe('normalizeVoicePack structure', () => {
     expect(warnings.join('\n')).toContain('mystery')
     expect(warnings.join('\n')).toContain('voicePackVersion')
   })
+
+  it('normalizes top-level remarks and ranks (#1226)', () => {
+    const { pack, warnings } = collectWarnings({
+      remarks: {
+        pet: ['Purr~ So comfortable!'],
+        feed: 'Yummy fish!',
+      },
+      ranks: {
+        '0': 'Baby Whale',
+        '幼鲸': 'Little Whale',
+      },
+    })
+    expect(pack).toBeDefined()
+    expect(pack?.remarks?.pet).toEqual(['Purr~ So comfortable!'])
+    expect(pack?.remarks?.feed).toEqual(['Yummy fish!'])
+    expect(pack?.ranks).toEqual({
+      '0': 'Baby Whale',
+      '幼鲸': 'Little Whale',
+    })
+    expect(warnings).toHaveLength(0)
+  })
+
+  it('merges remarks and ranks across layers (#1226)', () => {
+    const base = normalizeVoicePack({
+      remarks: { pet: ['Base pet'], feed: ['Base feed'] },
+      ranks: { '0': 'Base 0', '25': 'Base 25' },
+    })
+    const layer = normalizeVoicePack({
+      remarks: { pet: ['Layer pet'] },
+      ranks: { '0': 'Layer 0' },
+    })
+    const merged = mergeVoicePacks(base, layer)
+    expect(merged?.remarks?.pet).toEqual(['Layer pet'])
+    expect(merged?.remarks?.feed).toEqual(['Base feed'])
+    expect(merged?.ranks).toEqual({
+      '0': 'Layer 0',
+      '25': 'Base 25',
+    })
+  })
 })
 
 describe('normalizePool', () => {
@@ -85,31 +125,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 +202,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 +259,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 ?? {}