@linxin666/dsh-pet 0.1.20 → 0.2.1

package/src/client/settings-card.module.css

@@ -290,6 +290,92 @@
   border-color: var(--dsw-alias-label-error);
 }
 
+.selectWrap {
+  position: relative;
+}
+
+.selectButton {
+  appearance: none;
+  width: 100%;
+  text-align: left;
+  cursor: pointer;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  display: flex;
+}
+
+.selectLabel {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.selectChevron {
+  color: var(--dsw-alias-label-tertiary);
+  flex: none;
+  transition: transform 0.16s;
+}
+
+.selectChevronOpen {
+  transform: rotate(180deg);
+}
+
+.selectPopup {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  right: 0;
+  z-index: 40;
+  flex-direction: column;
+  max-height: 240px;
+  overflow-y: auto;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 8px;
+  background: var(--dsw-alias-bg-layer-3);
+  box-shadow: 0 8px 24px var(--dsw-alias-bg-mask-2);
+  padding: 4px;
+  opacity: 0;
+  transform: translateY(-4px);
+  transition: opacity 0.1s ease, transform 0.1s ease;
+  display: flex;
+}
+
+.selectPopupOpen {
+  opacity: 1;
+  transform: none;
+}
+
+.selectPopupClose {
+  opacity: 0;
+  transform: translateY(-4px);
+  pointer-events: none;
+}
+
+.selectOption {
+  border-radius: 6px;
+  padding: 6px 10px;
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-primary);
+  cursor: pointer;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.selectOption:hover,
+.selectOptionActive {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+.selectOptionSelected {
+  color: var(--dsw-alias-brand-primary);
+  font-weight: 500;
+  background: color-mix(in srgb, var(--dsw-alias-brand-primary-new-colorprimary-new-color) 10%, transparent);
+}
+
 .invalid {
   color: var(--dsw-alias-label-error);
   margin: 0;
@@ -310,7 +396,10 @@
   .chevron,
   .chevronOpen,
   .discard,
-  .save {
+  .save,
+  .selectChevron,
+  .selectChevronOpen,
+  .selectPopup {
     transition: none;
   }
 }

package/src/event-projection.ts

@@ -3,11 +3,17 @@
  * vocabulary onto the pet's visual phases and carries an optional completed-
  * turn reward for the ledger. Holds no state of its own; callers keep a
  * {@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
+ * 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 } from './chatter.ts'
 
 /** Runtime shape of the optional legacy activity event. */
 export interface ActivityStatusEventLike {
@@ -21,23 +27,35 @@ export interface ProjectionRuntime {
   activeTools: 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. */
+  whispers: WhisperEngine
 }
 
 /** One official event projection, optionally carrying a completed turn reward. */
 export interface PetActivityTransition {
   input: PetStateInput
   completedTurn?: number
+  /** A fresh inner whisper woken by this event's model output, when any. */
+  whisper?: string
 }
 
 /** Fresh projection runtime for a newly seen session. */
 export function emptyProjectionRuntime(): ProjectionRuntime {
-  return { activeTools: new Set(), officialEventsSeen: false, stepHadFailure: false }
+  return {
+    activeTools: new Set(),
+    officialEventsSeen: false,
+    stepHadFailure: false,
+    voice: new StatusVoice(),
+    whispers: new WhisperEngine(),
+  }
 }
 
 /** Keep tool names readable inside the compact status bubble. */
 function displayToolName(name: string): string {
   const compact = name.replace(/\s+/g, ' ').trim() || '工具'
-  return compact.length <= 24 ? compact : `${compact.slice(0, 21)}...`
+  return compact.length <= 24 ? compact : compact.slice(0, 21) + '...'
 }
 
 /** Whether a legacy phase is part of the pet's supported vocabulary. */
@@ -48,38 +66,53 @@ export function isActivityPhase(phase: string): phase is PetStateInput['phase']
 /**
  * Project the durable DSH session vocabulary into the pet's visual phases.
  * Unknown and log-only events do not disturb the last meaningful activity.
+ * @param nowMs - injected wall clock for copy rotation and whisper pacing.
  */
 export function projectOfficialEvent(
   event: SessionEvent,
   runtime: ProjectionRuntime,
+  nowMs: number = Date.now(),
 ): PetActivityTransition | undefined {
   switch (event.type) {
     case 'turn/start':
       runtime.activeTools.clear()
       runtime.stepHadFailure = false
-      return { input: { phase: 'waiting', line: '准备开始' } }
+      return { input: { phase: 'waiting', line: runtime.voice.scene('prepare', nowMs) } }
     case 'step/start':
       runtime.activeTools.clear()
       runtime.stepHadFailure = false
-      return { input: { phase: 'waiting', line: '等待模型响应' } }
+      return { input: { phase: 'waiting', line: runtime.voice.scene('waiting', nowMs) } }
     case 'assistant/chunk': {
       const { chunk } = event.data
       if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
-        return { input: { phase: 'thinking', line: '正在思考' } }
+        const whisper = runtime.whispers.feed(chunk.text, nowMs)
+        return {
+          input: { phase: 'thinking', line: runtime.voice.scene('thinking', nowMs) },
+          ...(whisper === undefined ? {} : { whisper }),
+        }
       }
       if (chunk.type === 'text-delta' && chunk.text.length > 0) {
-        return { input: { phase: 'review', line: '整理回复中' } }
+        const whisper = runtime.whispers.feed(chunk.text, nowMs)
+        return {
+          input: { phase: 'review', line: runtime.voice.scene('review', nowMs) },
+          ...(whisper === undefined ? {} : { whisper }),
+        }
       }
       return undefined
     }
     case 'assistant/message':
-      return { input: { phase: 'review', line: '整理回复中' } }
+      return { input: { phase: 'review', line: runtime.voice.scene('review', nowMs) } }
     case 'tool/call':
       runtime.activeTools.add(String(event.data.callId))
       return {
         input: {
           phase: 'tool',
-          line: `正在使用 ${displayToolName(event.data.name)}`,
+          line: runtime.voice.tool(
+            event.data.name,
+            displayToolName(event.data.name),
+            toolArgHint(event.data.name, event.data.arguments),
+            nowMs,
+          ),
         },
       }
     case 'tool/result': {
@@ -90,30 +123,30 @@ export function projectOfficialEvent(
         return {
           input: {
             phase: 'tool',
-            line: `还有 ${runtime.activeTools.size} 个工具运行中`,
+            line: runtime.voice.toolRemaining(runtime.activeTools.size, nowMs),
           },
         }
       }
       return runtime.stepHadFailure
-        ? { input: { phase: 'failed', line: '工具执行失败' } }
-        : { input: { phase: 'thinking', line: '处理工具结果' } }
+        ? { input: { phase: 'failed', line: runtime.voice.scene('toolFailed', nowMs) } }
+        : { input: { phase: 'thinking', line: runtime.voice.scene('toolResult', nowMs) } }
     }
     case 'turn/end': {
       runtime.activeTools.clear()
       switch (event.data.reason.kind) {
         case 'completed':
           return {
-            input: { phase: 'done', line: '完成啦' },
+            input: { phase: 'done', line: runtime.voice.scene('done', nowMs) },
             completedTurn: event.data.turn,
           }
         case 'error':
-          return { input: { phase: 'failed', line: '执行失败' } }
+          return { input: { phase: 'failed', line: runtime.voice.scene('failed', nowMs) } }
         case 'max-tokens':
-          return { input: { phase: 'failed', line: '达到输出上限' } }
+          return { input: { phase: 'failed', line: runtime.voice.scene('maxTokens', nowMs) } }
         case 'interrupted':
-          return { input: { phase: 'failed', line: '执行意外中断' } }
+          return { input: { phase: 'failed', line: runtime.voice.scene('interrupted', nowMs) } }
         case 'blocked':
-          return { input: { phase: 'waiting', line: '等待继续' } }
+          return { input: { phase: 'waiting', line: runtime.voice.scene('blocked', nowMs) } }
         case 'aborted':
           // A stopped session settles to idle without a bubble: the pet
           // visibly calms down and the session drops out of the bubble stack.

package/src/ledger.test.ts

@@ -3,6 +3,7 @@ import { defaultTreatConfig } from './treats.ts'
 import { defaultAffinityConfig } from './affinity.ts'
 import { emptyPersist } from './persist.ts'
 import { PetLedger } from './ledger.ts'
+import { BUILTIN_REMARKS } from './remarks.ts'
 
 describe('PetLedger', () => {
   it('settles the economy on completed turns (work treat per 30 turns)', () => {
@@ -66,13 +67,53 @@ describe('PetLedger', () => {
     expect(ledger.interact('feed', n + 2).reaction).toBe('没有小鱼干了，多陪我工作一会儿吧～')
   })
 
+  it('selects success remarks from persisted lifetime interaction counts', () => {
+    const n = 1_000_000
+    const persist = emptyPersist()
+    persist.affinity.pets = 1
+    persist.affinity.feeds = 1
+    persist.treats.treats = 1
+    persist.treats.lastTreatGrantAt = n
+    const ledger = new PetLedger(persist, {
+      remarks: {
+        pet: ['摸头一', '摸头二'],
+        feed: ['喂食一', '喂食二'],
+      },
+    })
+    expect(ledger.interact('pet', n).reaction).toBe('摸头二')
+    expect(ledger.interact('feed', n).reaction).toBe('喂食二')
+  })
+
+  it('rotates cooldown remarks by persisted rejection counts', () => {
+    const n = 1_000_000
+    const remarks = {
+      petCooldown: ['摸头冷却一', '摸头冷却二', '摸头冷却三'],
+      feedCooldown: ['喂食冷却一', '喂食冷却二', '喂食冷却三'],
+    }
+    const persist = emptyPersist()
+    persist.affinity.lastPetAt = n
+    persist.affinity.lastFeedAt = n
+    const ledger = new PetLedger(persist, { remarks })
+    expect(ledger.interact('pet', n + 1).reaction).toBe('摸头冷却一')
+    expect(ledger.interact('pet', n + 2).reaction).toBe('摸头冷却二')
+    expect(ledger.interact('feed', n + 1).reaction).toBe('喂食冷却一')
+    expect(ledger.interact('feed', n + 2).reaction).toBe('喂食冷却二')
+    expect(ledger.snapshot.affinity.petRejects).toBe(2)
+    expect(ledger.snapshot.affinity.feedRejects).toBe(2)
+
+    const restored = new PetLedger(ledger.snapshot, { remarks })
+    expect(restored.interact('pet', n + 3).reaction).toBe('摸头冷却三')
+    expect(restored.interact('feed', n + 3).reaction).toBe('喂食冷却三')
+  })
+
   it('swaps remark pools when the selected pet changes', () => {
     const ledger = new PetLedger(emptyPersist(), { remarks: { pet: ['旧宠物台词'] } })
     expect(ledger.interact('pet', 1_000_000).reaction).toBe('旧宠物台词')
     ledger.setRemarks({ pet: ['新宠物台词'] })
     expect(ledger.interact('pet', 1_011_000).reaction).toBe('新宠物台词')
     ledger.setRemarks(undefined)
-    expect(ledger.interact('pet', 1_022_000).reaction).toBe('咕噜咕噜～被摸摸好舒服！')
+    // Changing pools does not reset the persisted lifetime interaction count.
+    expect(ledger.interact('pet', 1_022_000).reaction).toBe(BUILTIN_REMARKS.pet[2])
   })
 
   it('refuses a feed on an empty stock without burning anything', () => {

package/src/ledger.ts

@@ -182,12 +182,19 @@ export class PetLedger {
    */
   interact(kind: PetInteraction, nowMs: number): LedgerInteractionResult {
     if (kind === 'feed') this.settleTreats(nowMs)
-    const outcome = applyInteraction(this.current.affinity, kind, nowMs, this.affinityConfig)
+    const before = this.current.affinity
+    const outcome = applyInteraction(before, kind, nowMs, this.affinityConfig)
     // Reactions come from the picker pools (custom per-pet slots override
     // the built-in library per slot); outcome.reaction stays the fallback
     // copy for direct applyInteraction callers.
     if (kind === 'feed' && !outcome.accepted) {
-      return { reaction: this.picker.pick('feedCooldown'), delta: 0, affinity: this.affinityView(nowMs) }
+      this.current = { ...this.current, affinity: outcome.affinity }
+      this.dirty = true
+      return {
+        reaction: this.picker.pickAt('feedCooldown', before.feedRejects),
+        delta: 0,
+        affinity: this.affinityView(nowMs),
+      }
     }
     if (kind === 'feed') {
       const consume = consumeTreat(this.current.treats)
@@ -201,12 +208,13 @@ export class PetLedger {
       this.current = { ...this.current, treats: consume.ledger }
       this.dirty = true
     }
-    if (outcome.accepted) {
-      this.current = { ...this.current, affinity: outcome.affinity }
-      this.dirty = true
-    }
+    this.current = { ...this.current, affinity: outcome.affinity }
+    this.dirty = true
+    const count = kind === 'pet'
+      ? outcome.accepted ? before.pets : before.petRejects
+      : before.feeds
     return {
-      reaction: this.picker.pick(outcome.accepted ? kind : 'petCooldown'),
+      reaction: this.picker.pickAt(outcome.accepted ? kind : 'petCooldown', count),
       delta: outcome.delta,
       affinity: this.affinityView(nowMs),
     }

package/src/loopback.ts

@@ -0,0 +1,63 @@
+// Generated by scripts/sync-shared.mjs from shared/host/loopback.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * Loopback trust fence shared by the host route families: socket address,
+ * Host header, and browser same-origin markers. Packages receive this file as
+ * a generated copy via scripts/sync-shared.mjs; edit the shared source and
+ * re-run the sync instead of editing a copy.
+ *
+ * Semantics: RFC 5735 IPv4 127/8, ::1, IPv4-mapped ::ffff:127/8 (matching the
+ * remote-web-ui gate), localhost hostnames, plus the browser same-origin
+ * markers (sec-fetch-site and Origin) for the request-level fence.
+ * @module dsh-web-ui-shared/host/loopback
+ */
+
+import type { IncomingMessage } from 'node:http'
+
+/** IPv4 127/8 predicate (four decimal octets, first == 127). */
+export function isIPv4Loopback(v4: string): boolean {
+  const parts = v4.split('.')
+  return parts.length === 4
+    && parts[0] === '127'
+    && parts.every(part => /^\d{1,3}$/.test(part) && Number(part) <= 255)
+}
+
+/** Whether a socket remote address names the loopback range (127/8, ::1, IPv4-mapped). */
+export function isLoopbackAddress(address: string | undefined): boolean {
+  if (address === undefined) return false
+  const normalized = address.toLowerCase()
+  if (normalized === '::1') return true
+  if (normalized.startsWith('::ffff:')) return isIPv4Loopback(normalized.slice('::ffff:'.length))
+  return isIPv4Loopback(normalized)
+}
+
+/** Whether a normalized URL hostname names the loopback authority (localhost, [::1], 127/8). */
+export function isLoopbackHostname(hostname: string): boolean {
+  if (hostname === 'localhost' || hostname === '[::1]') return true
+  return isIPv4Loopback(hostname)
+}
+
+/**
+ * Request-level trust fence: a loopback socket address AND a loopback Host
+ * header, plus browser same-origin markers. The socket address is
+ * authoritative; X-Forwarded-For is never trusted.
+ */
+export function isLoopbackRequest(request: IncomingMessage): boolean {
+  if (!isLoopbackAddress(request.socket.remoteAddress)) return false
+  const host = request.headers.host
+  if (typeof host !== 'string') return false
+  let hostUrl: URL
+  try {
+    hostUrl = new URL('http://' + host)
+  } catch {
+    return false
+  }
+  if (!isLoopbackHostname(hostUrl.hostname)) return false
+  if (request.headers['sec-fetch-site'] === 'cross-site') return false
+  const origin = request.headers.origin
+  if (origin === undefined) return true
+  try {
+    return new URL(origin).host === hostUrl.host
+  } catch {
+    return false
+  }
+}

package/src/persist.test.ts

@@ -20,6 +20,10 @@ function tempDir(): string {
 }
 
 describe('loadPetPersist', () => {
+  it('reserves enough default space for the hover panel below the pet', () => {
+    expect(defaultDisplayConfig.bottom).toBeGreaterThanOrEqual(100)
+  })
+
   it('falls back to defaults when the file is missing', () => {
     const dir = tempDir()
     try {
@@ -67,6 +71,8 @@ describe('loadPetPersist', () => {
       expect(loaded.petId).toBe(DEFAULT_PET_ID)
       expect(loaded.names).toEqual({ [DEFAULT_PET_ID]: '泡泡' })
       expect(loaded.affinity.points).toBe(5)
+      expect(loaded.affinity.petRejects).toBe(0)
+      expect(loaded.affinity.feedRejects).toBe(0)
       expect(loaded.display).toEqual(defaultDisplayConfig)
     } finally {
       rmSync(dir, { recursive: true, force: true })
@@ -108,7 +114,16 @@ describe('loadPetPersist', () => {
       writeFileSync(join(dir, 'pet.json'), JSON.stringify({
         name: '   ',
         names: { bad: '  ' },
-        affinity: { points: AFFINITY_MAX + 5000, lastPetAt: -5, lastFeedAt: 'x', pets: -1, feeds: 1.5, turns: 0 },
+        affinity: {
+          points: AFFINITY_MAX + 5000,
+          lastPetAt: -5,
+          lastFeedAt: 'x',
+          pets: -1,
+          feeds: 1.5,
+          turns: 0,
+          petRejects: 4,
+          feedRejects: -2,
+        },
         treats: { treats: 150, lastTreatGrantAt: -1, turnsAtLastTreatGrant: 0 },
         display: { visible: 'yes', size: -10, right: 1e12, bottom: 20 },
       }), 'utf8')
@@ -120,6 +135,8 @@ describe('loadPetPersist', () => {
       expect(loaded.affinity.lastFeedAt).toBe(0)
       expect(loaded.affinity.pets).toBe(0)
       expect(loaded.affinity.feeds).toBe(1.5) // finite numbers pass through
+      expect(loaded.affinity.petRejects).toBe(4)
+      expect(loaded.affinity.feedRejects).toBe(0)
       expect(loaded.treats.treats).toBe(defaultTreatConfig.maxTreats)
       expect(loaded.treats.lastTreatGrantAt).toBe(0)
       expect(loaded.display.visible).toBe(defaultDisplayConfig.visible)

package/src/persist.ts

@@ -27,7 +27,7 @@ export const defaultDisplayConfig: PetDisplayConfig = {
   visible: true,
   size: 160,
   right: 24,
-  bottom: 20,
+  bottom: 120,
 }
 
 /** Display value bounds (shared by load-time validation and setConfig). */
@@ -117,6 +117,8 @@ export function loadPetPersist(dir: string = petHomeDir()): PetPersist {
       lastFeedAt: clamp(finiteNum(rawAffinity.lastFeedAt, 0), Number.MAX_SAFE_INTEGER),
       pets: clamp(finiteNum(rawAffinity.pets, 0), Number.MAX_SAFE_INTEGER),
       feeds: clamp(finiteNum(rawAffinity.feeds, 0), Number.MAX_SAFE_INTEGER),
+      petRejects: clamp(finiteNum(rawAffinity.petRejects, 0), Number.MAX_SAFE_INTEGER),
+      feedRejects: clamp(finiteNum(rawAffinity.feedRejects, 0), Number.MAX_SAFE_INTEGER),
       turns: clamp(finiteNum(rawAffinity.turns, 0), Number.MAX_SAFE_INTEGER),
     }
     const rawTreats = (parsed.treats ?? {}) as Partial<TreatLedger>

package/src/registry.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import {
@@ -7,6 +7,7 @@ import {
   DEFAULT_PET_CELL,
   codexPetsDir,
   loadPetRegistry,
+  petAtlasFile,
   resolvePetManifest,
 } from './registry.ts'
 
@@ -25,6 +26,7 @@ describe('resolvePetManifest', () => {
     expect(entry!.id).toBe('otter')
     expect(entry!.cell).toEqual(DEFAULT_PET_CELL)
     expect(entry!.columns).toBe(8)
+    expect(entry!.atlasRows).toBe(9)
     expect(entry!.rows).toEqual([...DEFAULT_FRAME_COUNTS])
     expect(entry!.atlasUrl).toBe('/pet/otter/spritesheet.webp')
     expect(entry!.manifestUrl).toBe('/pet/otter/pet.json')
@@ -37,6 +39,21 @@ describe('resolvePetManifest', () => {
     expect(entry!.tracks.running.loop).toBe(true)
   })
 
+  it('marks v2 (spriteVersionNumber 2) atlases with 11 rows', () => {
+    const entry = resolvePetManifest({
+      id: 'firefly',
+      displayName: 'Firefly',
+      spritesheetPath: 'spritesheet.webp',
+      spriteVersionNumber: 2,
+    }, join(tmpdir(), 'firefly'))
+    expect(entry).toBeDefined()
+    // v2 atlases carry 11 rows: the 9 animation rows plus 2 look rows.
+    expect(entry!.atlasRows).toBe(11)
+    // The 9 animation rows still resolve the hatch-pet contract.
+    expect(entry!.rows).toEqual([...DEFAULT_FRAME_COUNTS])
+    expect(entry!.tracks.idle.frames.length).toBe(entry!.rows[0])
+  })
+
   it('keeps the legacy whale-girl frame counts and its own durations', () => {
     const entry = resolvePetManifest({
       id: 'whale-girl',
@@ -51,6 +68,36 @@ describe('resolvePetManifest', () => {
     expect(entry!.tracks['running-right'].durations.length).toBe(8)
   })
 
+  it('normalizes valid per-scene animation sequences', () => {
+    const entry = resolvePetManifest({
+      id: 'whale-girl',
+      displayName: '鲸鱼娘',
+      spritesheetPath: 'spritesheet.webp',
+      sequences: {
+        thinking: ['running', 'running-right', 'running', 'running-left', 'waiting'],
+      },
+    }, join(tmpdir(), 'whale'))
+    expect(entry!.sequences).toEqual({
+      thinking: ['running', 'running-right', 'running', 'running-left', 'waiting'],
+    })
+  })
+
+  it('drops invalid or undersized per-scene animation sequences', () => {
+    const warnings: string[] = []
+    const entry = resolvePetManifest({
+      id: 'whale-girl',
+      displayName: '鲸鱼娘',
+      spritesheetPath: 'spritesheet.webp',
+      sequences: {
+        waiting: ['waiting', 'idle'],
+        thinking: ['running', 'bogus', 'running', 'running-left', 'waiting'],
+      },
+    }, join(tmpdir(), 'whale'), { warnings })
+    expect(entry!.sequences).toBeUndefined()
+    expect(warnings).toContain('manifest whale-girl: sequence waiting must contain at least 5 animations')
+    expect(warnings).toContain('manifest whale-girl: sequence thinking contains unknown animation "bogus"')
+  })
+
   it('cycles short override durations up to the row frame count', () => {
     const entry = resolvePetManifest({
       id: 'fox',
@@ -134,6 +181,33 @@ describe('loadPetRegistry', () => {
     }
   })
 
+  it('resolves a composed extra atlas to the real file (no doubled directory)', () => {
+    const root = tempDir()
+    try {
+      // The atlas sits at <root>/pets/otter/spritesheet.webp.
+      mkdirSync(join(root, 'pets', 'otter'), { recursive: true })
+      writeFileSync(join(root, 'pets', 'otter', 'spritesheet.webp'), 'png', 'utf8')
+
+      const registry = loadPetRegistry({
+        packageRoot: root,
+        petsDir: '',
+        extra: [{ id: 'otter', displayName: '水獭', spritesheetPath: 'pets/otter/spritesheet.webp' }],
+      })
+      const entry = registry.byId('otter')
+      expect(entry).toBeDefined()
+      // dir is the spritesheet's parent; the stored path is its basename, so
+      // joining them resolves to the real file instead of applying the
+      // directory twice.
+      expect(entry!.dir).toBe(join(root, 'pets', 'otter'))
+      expect(entry!.spritesheetPath).toBe('spritesheet.webp')
+      const atlas = petAtlasFile(entry!)
+      expect(atlas).toBe(join(root, 'pets', 'otter', 'spritesheet.webp'))
+      expect(existsSync(atlas)).toBe(true)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
   it('defaults to the built-in pet even when custom pets sort first', () => {
     const root = tempDir()
     try {
@@ -152,8 +226,9 @@ describe('loadPetRegistry', () => {
 
 describe('codexPetsDir', () => {
   it('honors CODEX_HOME and expands a leading tilde', () => {
-    expect(codexPetsDir({ CODEX_HOME: '/opt/codex' }, '/home/user')).toBe('/opt/codex/pets')
-    expect(codexPetsDir({ CODEX_HOME: '~/codex' }, '/home/user')).toBe('/home/user/codex/pets')
-    expect(codexPetsDir({}, '/home/user')).toBe('/home/user/.codex/pets')
+    // Expected values join through the platform separator (POSIX on CI).
+    expect(codexPetsDir({ CODEX_HOME: '/opt/codex' }, '/home/user')).toBe(join('/opt/codex', 'pets'))
+    expect(codexPetsDir({ CODEX_HOME: '~/codex' }, '/home/user')).toBe(join('/home/user', 'codex', 'pets'))
+    expect(codexPetsDir({}, '/home/user')).toBe(join('/home/user', '.codex', 'pets'))
   })
 })