@linxin666/dsh-pet 0.3.4 → 0.3.6

package/lib/types/voice-pack.js

@@ -27,7 +27,8 @@
  * TypeScript mode: keep it erasable-syntax-only.
  * @module @linxin666/dsh-pet/voice-pack
  */
-import { STATUS_SCENES, TOOL_CATEGORIES, } from "./chatter.js";
+import { STATUS_SCENES, TOOL_CATEGORIES, WHISPER_CATEGORIES, WHISPER_RESULTS, } from "./chatter.js";
+import { normalizePetRemarks } from "./remarks.js";
 /** Schema version this module normalizes (optional field; missing = 1). */
 export const VOICE_PACK_V1 = 1;
 /** Hover-panel action buttons a pack can show or hide (canonical order). */
@@ -39,9 +40,6 @@ export const PANEL_STAT_KEYS = ['rank', 'treats', 'points'];
 /** 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;
 /** Any '{token}' placeholder (no nesting, no newlines). */
@@ -112,51 +110,45 @@ export function normalizePool(raw, kind, onWarning = () => { }) {
     }
     return pool;
 }
-/** Normalize the ordered keyword-rule list ([] disables the keyword channel). */
-export function normalizeWhisperRules(raw, onWarning = () => { }) {
+/** Normalize whisper category pools; a key replaces that category's built-in pool (an explicit empty pool mutes it). */
+export function normalizeWhisperCategories(raw, onWarning = () => { }) {
     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 = [];
-    for (const item of raw.slice(0, VOICE_RULES_MAX)) {
-        if (!isRecord(item)) {
-            onWarning('whisper rule must be an object');
+    const pools = {};
+    for (const key of Object.keys(raw)) {
+        if (!WHISPER_CATEGORIES.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 = item.keywords;
-        const keywords = [];
-        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] = 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, onWarning = () => { }) {
+    if (raw === undefined)
+        return undefined;
+    if (!isRecord(raw)) {
+        onWarning('whispers.results must be an object');
+        return undefined;
+    }
+    const pools = {};
+    for (const key of Object.keys(raw)) {
+        if (!WHISPER_RESULTS.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] = pool;
     }
-    return rules;
+    return Object.keys(pools).length > 0 ? pools : undefined;
 }
 /** Normalize the panel block (labels / stats / actions; warn-and-drop). */
 export function normalizePanel(raw, onWarning = () => { }) {
@@ -234,9 +226,9 @@ export function normalizePanel(raw, onWarning = () => { }) {
     return panel;
 }
 /** Voice-pack top-level fields ('$schema' mirrors the schema twin; drift-locked in tests). */
-export const VOICE_PACK_KEYS = new Set(['$schema', 'voicePackVersion', 'status', 'tools', 'toolRemaining', 'whispers', 'panel']);
+export const VOICE_PACK_KEYS = new Set(['$schema', 'voicePackVersion', 'status', 'tools', 'toolRemaining', 'whispers', 'panel', 'remarks', 'ranks']);
 /** 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
  * the file cannot serve as a pack at all (non-object root — structure is
@@ -307,28 +299,57 @@ export function normalizeVoicePack(raw, onWarning = () => { }) {
         }
         else {
             for (const key of Object.keys(whispersRaw)) {
-                if (!WHISPER_KEYS.has(key))
+                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 }),
                 };
             }
         }
     }
     const panel = raw.panel === undefined ? undefined : normalizePanel(raw.panel, onWarning);
+    const remarks = raw.remarks === undefined ? undefined : normalizePetRemarks(raw.remarks, onWarning);
+    const ranksRaw = raw.ranks;
+    let ranks;
+    if (ranksRaw !== undefined) {
+        if (!isRecord(ranksRaw)) {
+            onWarning('ranks must be an object');
+        }
+        else {
+            const out = {};
+            for (const [key, value] of Object.entries(ranksRaw)) {
+                if (typeof value === 'string' && value.trim() !== '') {
+                    out[key] = value.trim().slice(0, VOICE_STAT_MAX);
+                }
+                else {
+                    onWarning('invalid rank name for ' + key);
+                }
+            }
+            if (Object.keys(out).length > 0)
+                ranks = out;
+        }
+    }
     if (overrides.status === undefined && overrides.tools === undefined
         && overrides.toolRemaining === undefined && overrides.whispers === undefined
-        && panel === undefined) {
+        && panel === undefined && remarks === undefined && ranks === undefined) {
         return undefined;
     }
     return {
         overrides,
         ...(panel === undefined ? {} : { panel }),
+        ...(remarks === undefined ? {} : { remarks }),
+        ...(ranks === undefined ? {} : { ranks }),
     };
 }
 /**
@@ -341,6 +362,8 @@ export function mergeVoicePacks(...layers) {
     const overrides = {};
     const labels = {};
     const stats = {};
+    let remarks;
+    let ranks;
     let actions;
     let panelSeen = false;
     let any = false;
@@ -368,6 +391,12 @@ export function mergeVoicePacks(...layers) {
             if (layer.panel.actions !== undefined)
                 actions = layer.panel.actions;
         }
+        if (layer.remarks !== undefined) {
+            remarks = { ...(remarks ?? {}), ...layer.remarks };
+        }
+        if (layer.ranks !== undefined) {
+            ranks = { ...(ranks ?? {}), ...layer.ranks };
+        }
     }
     if (!any)
         return undefined;
@@ -380,5 +409,7 @@ export function mergeVoicePacks(...layers) {
     return {
         overrides,
         ...(panelSeen && !panelEmpty ? { panel } : {}),
+        ...(remarks !== undefined ? { remarks } : {}),
+        ...(ranks !== undefined ? { ranks } : {}),
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-pet",
   "description": "Multi-pet companion plugin for the dsh web GUI: a registry-driven floating pet that reacts to model activity, with per-pet naming, petting/feeding interactions and an affinity score",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"

package/src/access.ts

@@ -1,23 +1,13 @@
 /**
- * Pet trust fence: loopback (the desktop) always passes; a live paired-device
- * cookie is an additional allow path when remote-web-ui is loaded. The pet
- * never depends on that plugin — without the service the fence stays
- * loopback-only (same pattern as skill-explorer / aionui-panel).
+ * Pet trust fence: loopback (the desktop) always passes; a live
+ * paired-device cookie is an additional allow path when remote-web-ui is
+ * loaded. The pet never depends on that plugin — without the service the
+ * fence stays loopback-only. The decision logic lives in the generated
+ * pair-access.ts copy (shared by git-graph / pet / skill-explorer).
  */
 import type { IncomingMessage } from 'node:http'
 import type { Context } from '@deepseek-ai/cordis'
-import { isLoopbackRequest } from './loopback.ts'
-
-/** Structural pairing lookup (no package dependency on remote-web-ui). */
-interface PairingAccess {
-  isPairedDevice(request: IncomingMessage): boolean
-}
-
-/** ctx.get is optional on the test harness; production Context always has it. */
-type LookupCtx = Context & {
-  get?(name: string, strict?: boolean): unknown
-  remoteWebUiPairing?: PairingAccess
-}
+import { isPairedOrLoopbackAllowed } from './pair-access.ts'
 
 /**
  * Whether this request may enter any /api/pet or /pet asset route.
@@ -26,15 +16,5 @@ type LookupCtx = Context & {
  * @returns true for loopback, or a live paired-device cookie.
  */
 export function isPetAllowed(ctx: Context, request: IncomingMessage): boolean {
-  if (isLoopbackRequest(request)) return true
-  const bag = ctx as LookupCtx
-  const fromGet = typeof bag.get === 'function' ? bag.get('remoteWebUiPairing', false) : undefined
-  const pairing = (isPairingAccess(fromGet) ? fromGet : bag.remoteWebUiPairing)
-  return pairing?.isPairedDevice(request) === true
-}
-
-function isPairingAccess(value: unknown): value is PairingAccess {
-  return value !== undefined
-    && value !== null
-    && typeof (value as PairingAccess).isPairedDevice === 'function'
+  return isPairedOrLoopbackAllowed(ctx, request)
 }

package/src/affinity.ts

@@ -56,6 +56,19 @@ export const AFFINITY_RANKS = [
   { min: 100_000, name: '鲸生共渡', emoji: '*********' },
 ] as const
 
+/** English translations for the 9 built-in affinity rank names (#1226). */
+export const AFFINITY_RANKS_EN: Readonly<Record<string, string>> = {
+  '幼鲸': 'Baby Whale',
+  '伙伴': 'Companion',
+  '挚友': 'Close Friend',
+  '深海羁绊': 'Deep Sea Bond',
+  '心有灵犀': 'Kindred Spirit',
+  '传说羁绊': 'Legendary Bond',
+  '神话羁绊': 'Mythic Bond',
+  '永恒之契': 'Eternal Covenant',
+  '鲸生共渡': 'Lifelong Companion',
+}
+
 /** Interaction tuning (all in points / ms). */
 export interface AffinityConfig {
   /** Points per completed turn. */

package/src/chatter.test.ts

@@ -11,8 +11,9 @@ import {
   TOOL_POOLS,
   toolArgHint,
   toolCategory,
-  WHISPER_GENERIC_POOL,
-  WHISPER_RULES,
+  WHISPER_CATEGORY_POOLS,
+  WHISPER_RESULT_POOLS,
+  looksLikeTestTool,
   WhisperEngine,
   type VoicePackOverrides,
 } from './chatter.ts'
@@ -127,30 +128,65 @@ describe('toolArgHint', () => {
 })
 
 describe('WhisperEngine', () => {
-  it('wakes a themed whisper from a keyword in the model output', () => {
+  it('speaks a category line for the current situation, then respects the cooldown', () => {
     const engine = new WhisperEngine()
-    expect(engine.feed('这里有个错误需要处理', 0)).toBe(WHISPER_RULES[1]!.pool[0])
+    expect(engine.feed('thinking', 0)).toBe(WHISPER_CATEGORY_POOLS.thinking[0])
+    expect(engine.feed('writing', 1)).toBeUndefined()
   })
 
-  it('suppresses whispers during the cooldown, then rotates the pool', () => {
+  it('rotates within each category and keeps the category cursors apart', () => {
     const engine = new WhisperEngine()
-    expect(engine.feed('出现一个错误', 0)).toBe(WHISPER_RULES[1]!.pool[0])
-    expect(engine.feed('又一个错误', 1000)).toBeUndefined()
-    expect(engine.feed('还有一个错误', 9000)).toBe(WHISPER_RULES[1]!.pool[1])
+    expect(engine.feed('thinking', 0)).toBe(WHISPER_CATEGORY_POOLS.thinking[0])
+    expect(engine.feed('writing', 9001)).toBe(WHISPER_CATEGORY_POOLS.writing[0])
+    expect(engine.feed('thinking', 18002)).toBe(WHISPER_CATEGORY_POOLS.thinking[1])
   })
 
-  it('earns an ambient whisper from output volume alone', () => {
-    const engine = new WhisperEngine(undefined, 0, 10)
-    expect(engine.feed('aaaaaaaa', 0)).toBeUndefined()
-    expect(engine.feed('bbbb', 1)).toBe(WHISPER_GENERIC_POOL[0])
-    // The counter resets after speaking: another budget must accumulate.
-    expect(engine.feed('cccc', 2)).toBeUndefined()
-    expect(engine.feed('dddddddddd', 3)).toBe(WHISPER_GENERIC_POOL[1])
+  it('stays quiet on an explicitly muted category', () => {
+    const engine = new WhisperEngine(() => ({ whispers: { categories: { thinking: [] } } }))
+    expect(engine.feed('thinking', 0)).toBeUndefined()
   })
 
-  it('ignores empty chunks', () => {
-    const engine = new WhisperEngine(undefined, 0, 0)
-    expect(engine.feed('', 0)).toBeUndefined()
+  it('wakes outcome whispers on their own shorter cooldown and rotates per outcome', () => {
+    const engine = new WhisperEngine()
+    expect(engine.result('pass', 0)).toBe(WHISPER_RESULT_POOLS.pass[0])
+    expect(engine.result('fail', 1000)).toBeUndefined()
+    expect(engine.result('fail', 5001)).toBe(WHISPER_RESULT_POOLS.fail[0])
+    expect(engine.result('pass', 10002)).toBe(WHISPER_RESULT_POOLS.pass[1])
+  })
+
+  it('paces category and outcome whispers against one shared clock', () => {
+    const engine = new WhisperEngine()
+    expect(engine.feed('writing', 0)).toBe(WHISPER_CATEGORY_POOLS.writing[0])
+    // An outcome right after a category reply must wait the outcome cooldown.
+    expect(engine.result('done', 4999)).toBeUndefined()
+    expect(engine.result('done', 5000)).toBe(WHISPER_RESULT_POOLS.done[0])
+    // After an outcome, the category must wait the full category cooldown
+    // measured from the outcome whisper (5000), so 14000 is the next slot.
+    expect(engine.feed('thinking', 5001)).toBeUndefined()
+    expect(engine.feed('thinking', 14000)).toBe(WHISPER_CATEGORY_POOLS.thinking[0])
+  })
+
+  it('mutes an outcome with an explicit empty pool', () => {
+    const engine = new WhisperEngine(() => ({ whispers: { results: { fail: [] } } }))
+    expect(engine.result('fail', 0)).toBeUndefined()
+  })
+})
+
+describe('looksLikeTestTool', () => {
+  it('recognizes test tools by name and by shell command', () => {
+    expect(looksLikeTestTool('run_tests', undefined)).toBe(true)
+    expect(looksLikeTestTool('run_code', '{"command":"npm test"}')).toBe(true)
+    expect(looksLikeTestTool('run_code', '{"command":"pnpm run test -- --run"}')).toBe(true)
+    expect(looksLikeTestTool('bash', '{"command":"pytest -q"}')).toBe(true)
+    expect(looksLikeTestTool('bash', '{"command":"go test ./..."}')).toBe(true)
+    expect(looksLikeTestTool('run_code', '{"code":"import pytest"}')).toBe(true)
+  })
+
+  it('does not misfire on ordinary tools or mentions in generic code', () => {
+    expect(looksLikeTestTool('bash', '{"command":"node server.js"}')).toBe(false)
+    expect(looksLikeTestTool('grep', '{"pattern":"test"}')).toBe(false)
+    expect(looksLikeTestTool('read', '{"file_path":"/repo/test/fixture.txt"}')).toBe(false)
+    expect(looksLikeTestTool('run_code', '{"code":"server.listen(8080)"}')).toBe(false)
   })
 })
 
@@ -165,8 +201,8 @@ describe('voice-pack overrides (pet-center M4)', () => {
     },
     toolRemaining: ['后台还有 {n} 个'],
     whispers: {
-      generic: ['自定义碎碎念 A', '自定义碎碎念 B'],
-      rules: [{ keywords: ['测试通过'], pool: ['自定义全绿'] }],
+      categories: { thinking: ['自定义思考', '自定义思考二'] },
+      results: { pass: ['自定义全绿'] },
     },
   })
 
@@ -214,28 +250,22 @@ describe('voice-pack overrides (pet-center M4)', () => {
     expect(voice.scene('done', 5000)).toBe('换声了')
   })
 
-  it('replaces the whisper rules as a whole', () => {
+  it('replaces whisper category pools per key', () => {
     const engine = new WhisperEngine(PACK)
-    expect(engine.feed('这里有一个错误', 0)).toBeUndefined()
-    // The built-in error rule is gone; only the pack's rule fires.
-    expect(engine.feed('测试通过', 1000)).toBe('自定义全绿')
+    expect(engine.feed('thinking', 0)).toBe('自定义思考')
+    expect(engine.feed('writing', 9000)).toBe(WHISPER_CATEGORY_POOLS.writing[0])
+    expect(engine.feed('thinking', 18000)).toBe('自定义思考二')
   })
 
-  it('replaces the ambient generic pool', () => {
-    const engine = new WhisperEngine(PACK, 0, 3)
-    expect(engine.feed('aaaa', 0)).toBe('自定义碎碎念 A')
-    expect(engine.feed('bbbb', 1)).toBe('自定义碎碎念 B')
-  })
-
-  it('mutes ambient whispers when the generic pool is explicitly empty', () => {
-    const engine = new WhisperEngine(() => ({ whispers: { generic: [] } }), 0, 3)
-    expect(engine.feed('aaaa', 0)).toBeUndefined()
-    expect(engine.feed('bbbb', 1)).toBeUndefined()
+  it('replaces whisper outcome pools per key', () => {
+    const engine = new WhisperEngine(PACK)
+    expect(engine.result('pass', 0)).toBe('自定义全绿')
+    expect(engine.result('fail', 5001)).toBe(WHISPER_RESULT_POOLS.fail[0])
   })
 
-  it('disables keyword rules when the rules array is explicitly empty', () => {
-    const engine = new WhisperEngine(() => ({ whispers: { rules: [] } }), 0, 3)
-    // No keyword rule matches anymore; volume still earns a built-in ambient.
-    expect(engine.feed('测试通过', 0)).toBe(WHISPER_GENERIC_POOL[0])
+  it('mutes a whisper channel with an explicit empty override', () => {
+    const engine = new WhisperEngine(() => ({ whispers: { categories: { thinking: [] }, results: { done: [] } } }))
+    expect(engine.feed('thinking', 0)).toBeUndefined()
+    expect(engine.result('done', 0)).toBeUndefined()
   })
 })