@linxin666/dsh-pet 0.3.4 → 0.3.5

package/src/client/PetSprite.test.tsx

@@ -424,27 +424,18 @@ describe('PetSprite status bubble', () => {
     expect(screen.queryByText('正在使用 grep')).not.toBeNull()
   })
 
-  it('lets the inner whisper take over the status bubble', () => {
-    renderPet({ snapshot: { ...workingSnapshot, whisper: '哼哧哼哧，大脑转得飞快～' } })
-    // The whisper speaks THROUGH the bubble: it replaces (not accompanies)
-    // the status copy, so the pet never shows two bubbles at once.
-    expect(screen.queryByText('哼哧哼哧，大脑转得飞快～')).not.toBeNull()
-    expect(screen.queryByText('正在思考')).toBeNull()
-  })
-
-  it('lets the whisper take over the display session bubble in the stack', () => {
+  it('lets a session whisper take over its own bubble while others stay collapsed', () => {
     const { onOpenSession } = renderPet({
       snapshot: {
         ...workingSnapshot,
-        whisper: '我在这儿陪着你呢，别急别急',
         sessions: [
-          { sessionId: 's-a', animation: 'running', phase: 'thinking', bubble: '正在思考' },
+          { sessionId: 's-a', animation: 'running', phase: 'thinking', bubble: '正在思考', whisper: '我在这儿陪着你呢，别急别急' },
           { sessionId: 's-b', animation: 'running-right', phase: 'tool', bubble: '正在使用 grep' },
         ],
       },
     })
-    // The primary bubble (the display session) speaks the whisper instead
-    // of its status copy; the collapsed extra session hides behind the badge.
+    // The lead session's bubble speaks ITS whisper instead of its status
+    // copy; the collapsed extra session hides behind the badge.
     expect(screen.queryByText('我在这儿陪着你呢，别急别急')).not.toBeNull()
     expect(screen.queryByText('正在思考')).toBeNull()
     expect(screen.queryByText('正在使用 grep')).toBeNull()
@@ -456,9 +447,28 @@ describe('PetSprite status bubble', () => {
     expect(onOpenSession).toHaveBeenCalledWith('s-a')
   })
 
+  it('renders each session whisper on its own expanded bubble', () => {
+    renderPet({
+      snapshot: {
+        ...workingSnapshot,
+        sessions: [
+          { sessionId: 's-a', animation: 'running', phase: 'thinking', bubble: '正在思考', whisper: 'A 的碎碎念' },
+          { sessionId: 's-b', animation: 'running-right', phase: 'tool', bubble: '正在使用 grep', whisper: 'B 的碎碎念' },
+        ],
+      },
+    })
+    fireEvent.pointerOver(screen.getByText('A 的碎碎念').closest('div')!)
+    expect(screen.queryByText('A 的碎碎念')).not.toBeNull()
+    expect(screen.queryByText('B 的碎碎念')).not.toBeNull()
+    expect(screen.queryByText('正在思考')).toBeNull()
+  })
+
   it('lets transient interaction feedback take over the whisper too', () => {
     renderPet({
-      snapshot: { ...workingSnapshot, whisper: '哼哧哼哧，大脑转得飞快～' },
+      snapshot: {
+        ...workingSnapshot,
+        sessions: [{ sessionId: 's-a', animation: 'running', phase: 'thinking', bubble: '正在思考', whisper: '哼哧哼哧，大脑转得飞快～' }],
+      },
       feedback: { text: '摸摸成功', kind: 'pet', at: 1 },
     })
     expect(screen.queryByText('摸摸成功')).not.toBeNull()
@@ -754,7 +764,14 @@ describe('PetSprite status decoration (pet-center M5, #567)', () => {
   })
 
   it('yields the bubble to the whisper (voice moment hides the ornament)', () => {
-    renderPet({ snapshot: { ...snapshot, phase: 'thinking', whisper: '冲了冲了', decoration } })
+    renderPet({
+      snapshot: {
+        ...snapshot,
+        phase: 'thinking',
+        decoration,
+        sessions: [{ sessionId: 's-a', animation: 'running', phase: 'thinking', bubble: '正在思考', whisper: '冲了冲了' }],
+      },
+    })
     expect(ornament()).toBeNull()
     expect(document.body.textContent).toContain('冲了冲了')
   })

package/src/client/PetSprite.tsx

@@ -432,14 +432,14 @@ export function PetSprite(props: PetSpriteProps): ReactPortal {
   const statusBubble = feedback === null && sessionBubbles.length === 0
     ? snapshot?.bubble
     : undefined
-  // The display session's inner whisper (碎碎念) — short inner-voice copy
-  // woken by the model's output. Instead of a second bubble of its own, a
-  // fresh whisper takes over the display session's bubble (the stack top, or
-  // the single status bubble) and re-tints it, so the pet never wears two
-  // voices at once. Interaction feedback takes over the whole bubble area
-  // while it plays, so whispers yield to it like status copy.
-  const whisper = feedback === null ? snapshot?.whisper : undefined
-  const bubblePresent = feedback !== null || sessionBubbles.length > 0 || statusBubble !== undefined || whisper !== undefined
+  // Each session's inner whisper (碎碎念) rides its own bubble — short
+  // inner-voice copy woken by that session's activity, never the model's or
+  // another session's. Instead of a second bubble of its own, a fresh
+  // whisper takes over its session's bubble and re-tints it, so the pet
+  // never wears two voices at once. Interaction feedback takes over the
+  // whole bubble area while it plays, so whispers yield to it like status
+  // copy.
+  const bubblePresent = feedback !== null || sessionBubbles.length > 0 || statusBubble !== undefined
   const displayName = snapshot?.name ?? definition.displayName
   // The host-served status decoration (M5, #567); absent = text-only bubbles.
   const decoration = snapshot?.decoration
@@ -549,7 +549,7 @@ export function PetSprite(props: PetSpriteProps): ReactPortal {
           {feedback.text}
         </div>
       )}
-      {feedback === null && (sessionBubbles.length > 0 || statusBubble !== undefined || whisper !== undefined) && (
+      {feedback === null && (sessionBubbles.length > 0 || statusBubble !== undefined) && (
         <div
           ref={bubbleRef}
           className={styles.bubbleStack}
@@ -557,15 +557,14 @@ export function PetSprite(props: PetSpriteProps): ReactPortal {
           onPointerLeave={() => setStackPeek(false)}
         >
           {visibleSessions.map((session, index) => {
-            // The whisper rides the display session's bubble — the stack's
-            // primary entry (DOM-first, rendered bottom-most by the reversed
-            // column so it stays glued to the sprite when extras open above).
-            // The key swap restarts the entrance animation so the mood change
-            // reads as the bubble re-speaking.
-            const speaksWhisper = index === 0 && whisper !== undefined
+            // A session's whisper rides ITS OWN bubble (the stack lead when
+            // the current session has one, any bubble when the stack is
+            // expanded). The key swap restarts the entrance animation so the
+            // mood change reads as the bubble re-speaking.
+            const speaksWhisper = session.whisper !== undefined
             const bubble = (
               <button
-                key={speaksWhisper ? 'whisper:' + whisper : session.sessionId}
+                key={speaksWhisper ? 'whisper:' + session.whisper : session.sessionId}
                 type="button"
                 className={clsx(
                   styles.bubble,
@@ -579,7 +578,7 @@ export function PetSprite(props: PetSpriteProps): ReactPortal {
                 {index === 0 && !speaksWhisper && decoration !== undefined && (
                   <StatusOrnament decoration={decoration} phase={phase} />
                 )}
-                {speaksWhisper ? whisper : session.bubble}
+                {session.whisper ?? session.bubble}
               </button>
             )
             // The primary bubble carries the '+N' badge while other sessions
@@ -608,19 +607,17 @@ export function PetSprite(props: PetSpriteProps): ReactPortal {
               </span>
             )
           })}
-          {sessionBubbles.length === 0 && (statusBubble !== undefined || whisper !== undefined) && (
-            // The key swap (status copy <-> whisper) restarts the entrance
-            // animation on every mood change.
+          {sessionBubbles.length === 0 && statusBubble !== undefined && (
             <div
-              key={whisper === undefined ? 'status' : 'whisper:' + whisper}
-              className={clsx(styles.bubble, styles.bubbleStatus, whisper !== undefined && styles.bubbleWhisper)}
+              key="status"
+              className={clsx(styles.bubble, styles.bubbleStatus)}
               role="status"
               aria-live="polite"
             >
-              {whisper === undefined && decoration !== undefined && (
+              {decoration !== undefined && (
                 <StatusOrnament decoration={decoration} phase={phase} />
               )}
-              {whisper ?? statusBubble}
+              {statusBubble}
             </div>
           )}
         </div>

package/src/client/index.test.tsx

@@ -110,7 +110,16 @@ function fakeContext(): FakeClientLifecycle {
       },
       register: () => () => {},
     },
-    sessions: undefined,
+    sessions: {
+      list: {
+        getSnapshot: () => ({ current: undefined, byId: {} }),
+        subscribe: (listener: () => void) => {
+          const set = new Set<() => void>([listener])
+          return () => { set.delete(listener) }
+        },
+      },
+      open: () => {},
+    },
   } as unknown as ClientContext
   let disposed = false
   const lifecycle: FakeClientLifecycle = {

package/src/client/index.ts

@@ -36,7 +36,8 @@ import { reportDailyHeartbeat } from './telemetry.ts'
 
 /** The host pet API as the browser sees it (same-origin JSON endpoints). */
 interface PetHttpApi {
-  state(): Promise<PetStateView>
+  /** Poll the host snapshot; the GUI's current session id rides the query. */
+  state(currentSessionId?: string): Promise<PetStateView>
   pets(): Promise<PetDefinition[]>
   interact(kind: PetInteraction): Promise<PetInteractResult>
   setVisible(visible: boolean): Promise<{ ok: true; display: PetDisplayConfig }>
@@ -66,7 +67,8 @@ async function petFetch<T>(path: string, body?: unknown): Promise<T> {
 
 /** The live host API instance (always defined; failures surface per call). */
 const petApi: PetHttpApi = {
-  state: () => petFetch('/api/pet/state'),
+  state: (currentSessionId) => petFetch('/api/pet/state'
+    + (currentSessionId === undefined ? '' : '?current=' + encodeURIComponent(currentSessionId))),
   pets: () => petFetch('/api/pet/pets'),
   interact: (kind) => petFetch('/api/pet/interact', { kind }),
   setVisible: (visible) => petFetch('/api/pet/set-visible', { visible }),
@@ -197,6 +199,20 @@ export function apply(ctx: ClientContext): void {
       const setState = petStore.actions.setState
       const setFeedback = petStore.actions.setFeedback
 
+      // Clicking a session bubble jumps the GUI to that session; the same
+      // sessions face reports which session the user is currently on, so the
+      // host can lead the bubble stack with it. A bubble can outlive its
+      // disposed session by one poll tick, and the sessions service fails
+      // loud on unknown ids, so consult the live list first. The pet's type
+      // program also loads the host-side dsh-session package through the
+      // service types, whose Context merge declares a different 'sessions'
+      // face; pin the browser runtime's outward face here.
+      const sessions = ctx.sessions as unknown as ISessions
+      const currentSessionId = (): string | undefined => {
+        const current = sessions.list.getSnapshot().current
+        return current === undefined ? undefined : String(current)
+      }
+
       // The registry list is fetched lazily with retries baked into the poll
       // cycle: until it lands, the dock entry renders nothing and every 2s
       // tick tries again. After it lands, one list feeds both the sprite and
@@ -218,7 +234,7 @@ export function apply(ctx: ClientContext): void {
         }
         const seq = stateSeq + 1
         stateSeq = seq
-        petApi.state().then((snapshot) => {
+        petApi.state(currentSessionId()).then((snapshot) => {
           if (seq !== stateSeq) return
           setSnapshot(snapshot)
         }, () => {
@@ -261,13 +277,16 @@ export function apply(ctx: ClientContext): void {
         }
       }, 'pet: poll')
 
-      // Clicking a session bubble jumps the GUI to that session. A bubble
-      // can outlive its disposed session by one poll tick, and the sessions
-      // service fails loud on unknown ids, so consult the live list first.
-      // The pet's type program also loads the host-side dsh-session package
-      // through the service types, whose Context merge declares a different
-      // 'sessions' face; pin the browser runtime's outward face here.
-      const sessions = ctx.sessions as unknown as ISessions
+      // A current-session switch should re-order the bubble stack right away,
+      // not on the next 2s tick. Poll only while the tab is visible, as the
+      // poll loop itself does.
+      const disposeSessionWatch = ctx.effect(() => {
+        const unsubscribe = sessions.list.subscribe(() => {
+          if (document.visibilityState === 'visible') pollNow()
+        })
+        return unsubscribe
+      }, 'pet: current-session watch')
+
       const openSession = (sessionId: string): void => {
         const list = sessions.list.getSnapshot()
         if (list.byId[sessionId as SessionId] === undefined) return

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/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
@@ -338,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). */
@@ -763,37 +759,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 +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 },