feat(gui): goal wire domain, client goal state, and docked goal bar

- apiproxy goals RPC domain (get/create/edit/pause/resume/complete/clear)
  with CAS refs, zod schemas, and fetch client/handler wiring
- client runtime session goal state: live goal/change meta triggers a
  coalesced refetch; mutations fold transport errors into RpcResult
- web GoalBar: docked strip above the composer (sparkle, phase label,
  truncated objective, inline edit, clear; resume when paused); creation
  stays on the /goal command
- GoalBarActions in the ui-conversation contract layer; IconSparkle16
  moves to ui-primitives icons

packages/client/runtime/src/client/index.ts

@@ -28,6 +28,7 @@ export type {
   ToolResultNode, UnknownSurfaceNode, UserMessageNode,
 } from './sessions/conversation.ts'
 export type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
+export type { GoalView, GoalRef, GoalPhase, GoalBlockReason } from '@deepseek-ai/dsh-client-connection/client'
 
 // ---- Narrowed aliases (the single narrowing point of the slot type chain:
 // ui-slots/web-react stay generic and dependency-inverted; the client-tree

packages/client/runtime/src/client/sessions/conversation.ts

@@ -4,7 +4,7 @@
 // string here (narrow to real brands when convenient).
 
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types'
-import type { RpcError, RpcId, SessionId, ToolCallView, ToolResultView } from '@deepseek-ai/dsh-client-connection/client'
+import type { GoalView, RpcError, RpcId, SessionId, ToolCallView, ToolResultView } from '@deepseek-ai/dsh-client-connection/client'
 
 /** Assistant content blocks sorted by what the UI cares about
  *  (text body / collapsible reasoning / tool-call card head / other fallback). */
@@ -162,4 +162,7 @@ export interface ConversationSnapshot {
   loadingOlder: boolean
   promptError: PromptError | null
   lastAgentError: string | null
+  /** Current goal projection (fetched on open / refreshed when a live context/message carries
+   *  goal/change meta). undefined = not yet loaded. */
+  goal: GoalView | null | undefined
 }

packages/client/runtime/src/client/sessions/session.ts

@@ -5,7 +5,7 @@
 
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types'
 import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
-import type { HistoryEntry, IApiClient, MuxFrame, RpcError, RpcId, RpcResult, SessionId, ToolEventView } from '@deepseek-ai/dsh-client-connection/client'
+import type { GoalView, HistoryEntry, IApiClient, MuxFrame, RpcError, RpcId, RpcResult, SessionId, ToolEventView } from '@deepseek-ai/dsh-client-connection/client'
 import { transportError } from '@deepseek-ai/dsh-client-connection/client'
 import type { ObservableSnapshot, SnapshotSelectorHook } from '@deepseek-ai/dsh-client-web-react'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
@@ -61,6 +61,13 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
   private removed = false
   private promptError: PromptError | null = null
   private lastAgentError: string | null = null
+  /** Current goal projection; undefined = not yet fetched, null = no goal set. */
+  private goal: GoalView | null | undefined = undefined
+  /** Coalesced goal refetch (the open() idiom): live goal-change events share one in-flight get. */
+  private goalFetch: Promise<void> | null = null
+  /** Bumped on every local goal write; a get result older than the latest write is stale and
+   *  dropped (a mutation response that landed mid-fetch is always newer than the get's read). */
+  private goalWriteRev = 0
   /** Buffer for live events arriving while open/resync is in flight (stitched by seq once history lands, §D.3). */
   private liveBuffer: { event: SessionEvent; view: ToolEventView | undefined }[] = []
   /** Gap-repair (resync-lite) in flight: acceptLiveEvent detours to liveBuffer until the tail page lands (audit S3). */
@@ -120,6 +127,180 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     return result
   }
 
+  /** Fetch the current goal, coalesced: concurrent triggers share the in-flight get (identity-guarded
+   *  like openPromise — a superseded fetch must not null out the one that replaced it). */
+  private fetchGoal(): Promise<void> {
+    if (this.goalFetch !== null) return this.goalFetch
+    const promise = this.doFetchGoal().finally(() => {
+      if (this.goalFetch === promise) this.goalFetch = null
+    })
+    this.goalFetch = promise
+    return promise
+  }
+
+  /** The get behind fetchGoal: folds transport failures (fail-soft like loadOlder, logged) and
+   *  drops the result when a mutation response landed mid-flight (write revision moved on). */
+  private async doFetchGoal(): Promise<void> {
+    const writeRev = this.goalWriteRev
+    try {
+      const { result } = await this.api.goals.get({ sessionId: this.sessionId })
+      if (!result.ok) return
+      if (writeRev !== this.goalWriteRev) return
+      this.goal = result.value.goal
+      this.notifier.markDirty()
+    } catch (error) {
+      console.error('[web-runtime] goal fetch failed:', error)
+    }
+  }
+
+  /**
+   * Create a goal for this session.
+   * @param objective - the goal's objective text.
+   * @param maxGoalRounds - optional cap on admitted goal rounds (host default when absent).
+   * @returns the created goal view; transport failures fold into a failed result, never a rejection.
+   */
+  async createGoal(objective: string, maxGoalRounds?: number): Promise<RpcResult<{ goal: GoalView }>> {
+    let result: RpcResult<{ goal: GoalView }>
+    try {
+      result = (await this.api.goals.create({
+        sessionId: this.sessionId, objective, ...(maxGoalRounds !== undefined ? { maxGoalRounds } : {}),
+      })).result
+    } catch (error) {
+      result = transportError(error)
+    }
+    if (result.ok) {
+      this.goal = result.value.goal
+      this.goalWriteRev++
+      this.notifier.markDirty()
+    }
+    return result
+  }
+
+  /**
+   * Edit this session's goal objective or round cap (CAS with the locally held revision).
+   * @param objective - replacement objective text; absent leaves it unchanged.
+   * @param maxGoalRounds - replacement round cap; absent leaves it unchanged.
+   * @returns the updated goal view; fails without a current goal, and transport failures fold into a failed result.
+   */
+  async editGoal(objective?: string, maxGoalRounds?: number): Promise<RpcResult<{ goal: GoalView }>> {
+    if (this.goal === null || this.goal === undefined) {
+      return { ok: false, error: { code: 'internal', message: 'No goal to edit', details: {} } }
+    }
+    let result: RpcResult<{ goal: GoalView }>
+    try {
+      result = (await this.api.goals.edit({
+        sessionId: this.sessionId,
+        ref: { id: this.goal.id, revision: this.goal.revision },
+        ...(objective !== undefined ? { objective } : {}),
+        ...(maxGoalRounds !== undefined ? { maxGoalRounds } : {}),
+      })).result
+    } catch (error) {
+      result = transportError(error)
+    }
+    if (result.ok) {
+      this.goal = result.value.goal
+      this.goalWriteRev++
+      this.notifier.markDirty()
+    }
+    return result
+  }
+
+  /**
+   * Pause the current goal (CAS with the locally held revision).
+   * @returns the updated goal view; fails without a current goal, and transport failures fold into a failed result.
+   */
+  async pauseGoal(): Promise<RpcResult<{ goal: GoalView }>> {
+    if (this.goal === null || this.goal === undefined) {
+      return { ok: false, error: { code: 'internal', message: 'No goal to pause', details: {} } }
+    }
+    let result: RpcResult<{ goal: GoalView }>
+    try {
+      result = (await this.api.goals.pause({
+        sessionId: this.sessionId, ref: { id: this.goal.id, revision: this.goal.revision },
+      })).result
+    } catch (error) {
+      result = transportError(error)
+    }
+    if (result.ok) {
+      this.goal = result.value.goal
+      this.goalWriteRev++
+      this.notifier.markDirty()
+    }
+    return result
+  }
+
+  /**
+   * Resume a paused/blocked goal (CAS with the locally held revision).
+   * @returns the updated goal view; fails without a current goal, and transport failures fold into a failed result.
+   */
+  async resumeGoal(): Promise<RpcResult<{ goal: GoalView }>> {
+    if (this.goal === null || this.goal === undefined) {
+      return { ok: false, error: { code: 'internal', message: 'No goal to resume', details: {} } }
+    }
+    let result: RpcResult<{ goal: GoalView }>
+    try {
+      result = (await this.api.goals.resume({
+        sessionId: this.sessionId, ref: { id: this.goal.id, revision: this.goal.revision },
+      })).result
+    } catch (error) {
+      result = transportError(error)
+    }
+    if (result.ok) {
+      this.goal = result.value.goal
+      this.goalWriteRev++
+      this.notifier.markDirty()
+    }
+    return result
+  }
+
+  /**
+   * Complete the current goal (CAS with the locally held revision).
+   * @returns the updated goal view; fails without a current goal, and transport failures fold into a failed result.
+   */
+  async completeGoal(): Promise<RpcResult<{ goal: GoalView }>> {
+    if (this.goal === null || this.goal === undefined) {
+      return { ok: false, error: { code: 'internal', message: 'No goal to complete', details: {} } }
+    }
+    let result: RpcResult<{ goal: GoalView }>
+    try {
+      result = (await this.api.goals.complete({
+        sessionId: this.sessionId, ref: { id: this.goal.id, revision: this.goal.revision },
+      })).result
+    } catch (error) {
+      result = transportError(error)
+    }
+    if (result.ok) {
+      this.goal = result.value.goal
+      this.goalWriteRev++
+      this.notifier.markDirty()
+    }
+    return result
+  }
+
+  /**
+   * Clear the current goal (tombstone; CAS with the locally held revision).
+   * @returns a cleared marker; fails without a current goal, and transport failures fold into a failed result.
+   */
+  async clearGoal(): Promise<RpcResult<{ cleared: true }>> {
+    if (this.goal === null || this.goal === undefined) {
+      return { ok: false, error: { code: 'internal', message: 'No goal to clear', details: {} } }
+    }
+    let result: RpcResult<{ cleared: true }>
+    try {
+      result = (await this.api.goals.clear({
+        sessionId: this.sessionId, ref: { id: this.goal.id, revision: this.goal.revision },
+      })).result
+    } catch (error) {
+      result = transportError(error)
+    }
+    if (result.ok) {
+      this.goal = null
+      this.goalWriteRev++
+      this.notifier.markDirty()
+    }
+    return result
+  }
+
   /** First open: pull the tail page (idempotent — in-flight/already-open returns the existing promise). */
   open(): Promise<void> {
     if (this.openState === 'open') return Promise.resolve()
@@ -317,6 +498,8 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
         if (result.ok) this.installWindow(result.value.events, result.value.hasMore)
       }
       this.openState = 'open'
+      // Fetch the current goal eagerly after the window lands.
+      void this.fetchGoal()
     } catch (error) {
       if (generation !== this.openGeneration) return
       this.openState = 'error'
@@ -353,6 +536,13 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     this.views.push(view)
     this.foldAdapter.append(event, view)
     this.applyEventSideEffects(event, view)
+    // Goal mutations surface as goal/change meta on a context/message (clear tombstones carry no
+    // goal key, so match the meta kind). LIVE events only: window rebuilds replay the same meta
+    // and would storm goal.get on open/resync/loadOlder; the refetch coalesces via goalFetch.
+    if (event.type === 'context/message'
+      && (event.data.meta as { kind?: unknown } | undefined)?.kind === 'goal/change') {
+      void this.fetchGoal()
+    }
   }
 
   /** Land a live session/event (open/repair in flight -> buffer; overlapping seq -> drop;
@@ -522,6 +712,7 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
       loadingOlder: this.loadingOlder,
       promptError: this.promptError,
       lastAgentError: this.lastAgentError,
+      goal: this.goal,
     }
   }
 }

packages/client/runtime/tests/fake-api.ts

@@ -74,6 +74,16 @@ export class FakeApiClient implements IApiClient {
     describe: (payload: unknown) => this.record('host.describe', payload, this.onDescribe(payload)),
   }
 
+  readonly goals: IApiClient['goals'] = {
+    get: payload => this.record('goal.get', payload, Promise.resolve(ok({ goal: null }))),
+    create: payload => this.record('goal.create', payload, Promise.resolve(ok({ goal: null as unknown as never }))),
+    edit: payload => this.record('goal.edit', payload, Promise.resolve(ok({ goal: null as unknown as never }))),
+    pause: payload => this.record('goal.pause', payload, Promise.resolve(ok({ goal: null as unknown as never }))),
+    resume: payload => this.record('goal.resume', payload, Promise.resolve(ok({ goal: null as unknown as never }))),
+    complete: payload => this.record('goal.complete', payload, Promise.resolve(ok({ goal: null as unknown as never }))),
+    clear: payload => this.record('goal.clear', payload, Promise.resolve(ok({ cleared: true as const }))),
+  }
+
   /** When true, streams never fire onOpen (misbehaving-carrier material for the handshake timeout guard). */
   suppressStreamOpen = false
 

packages/client/runtime/tests/session.spec.ts

@@ -7,6 +7,7 @@
  */
 
 import { describe, expect, it, vi } from 'vitest'
+import type { GoalView } from '@deepseek-ai/dsh-client-connection/client'
 import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
 import { Session } from '../src/client/sessions/session.ts'
@@ -623,3 +624,233 @@ describe('reference stability (the memo contract)', () => {
     expect(resolved.pending).toBe(after.pending)
   })
 })
+
+describe('goal session methods', () => {
+  const GID = 'g-1' as never
+  function makeGoal(overrides: Partial<GoalView> = {}): GoalView {
+    return {
+      id: GID, revision: 1, objective: 'test-goal', phase: 'active',
+      maxGoalRounds: 256, roundsStarted: 0, createdAt: 100, updatedAt: 100,
+      activation: 'armed',
+      ...overrides,
+    }
+  }
+
+  it('createGoal calls the API and updates snapshot.goal', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    const r = await session.createGoal('test-goal')
+    expect(r).toEqual({ ok: true, value: { goal } })
+    expect(session.getSnapshot().goal).toEqual(goal)
+  })
+
+  it('editGoal sends the current ref and updates snapshot', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+    const edited = makeGoal({ revision: 2, objective: 'edited' })
+    api.goals.edit = () => Promise.resolve(ok({ goal: edited }))
+    const r = await session.editGoal('edited')
+    expect(r).toEqual({ ok: true, value: { goal: edited } })
+    expect(session.getSnapshot().goal).toEqual(edited)
+  })
+
+  it('editGoal returns an error when no goal exists', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const r = await session.editGoal('nothing')
+    expect(r.ok).toBe(false)
+    expect((r as { error: { code: string } }).error.code).toBe('internal')
+  })
+
+  it('pauseGoal pauses and updates snapshot', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+    const paused = makeGoal({ revision: 2, phase: 'paused', activation: 'disarmed' })
+    api.goals.pause = () => Promise.resolve(ok({ goal: paused }))
+    const r = await session.pauseGoal()
+    expect(r).toEqual({ ok: true, value: { goal: paused } })
+    expect(session.getSnapshot().goal).toEqual(paused)
+  })
+
+  it('resumeGoal resumes a paused goal', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal({ phase: 'paused', activation: 'disarmed' })
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+    const resumed = makeGoal({ revision: 2, phase: 'active', activation: 'armed' })
+    api.goals.resume = () => Promise.resolve(ok({ goal: resumed }))
+    const r = await session.resumeGoal()
+    expect(r).toEqual({ ok: true, value: { goal: resumed } })
+    expect(session.getSnapshot().goal).toEqual(resumed)
+  })
+
+  it('completeGoal marks the goal complete', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+    const completed = makeGoal({ revision: 2, phase: 'complete', activation: 'disarmed' })
+    api.goals.complete = () => Promise.resolve(ok({ goal: completed }))
+    const r = await session.completeGoal()
+    expect(r).toEqual({ ok: true, value: { goal: completed } })
+    expect(session.getSnapshot().goal).toEqual(completed)
+  })
+
+  it('clearGoal removes the goal from snapshot', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+    api.goals.clear = () => Promise.resolve(ok({ cleared: true as const }))
+    const r = await session.clearGoal()
+    expect(r).toEqual({ ok: true, value: { cleared: true } })
+    expect(session.getSnapshot().goal).toBeNull()
+  })
+
+  it('error responses from the API do not mutate local state', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+    const before = session.getSnapshot().goal
+    api.goals.pause = () => Promise.resolve(err({ code: 'agent-busy', message: 'stale revision', details: { reason: 'stale revision' } }))
+    const r = await session.pauseGoal()
+    expect(r.ok).toBe(false)
+    expect(session.getSnapshot().goal).toBe(before)
+  })
+
+  it('fetchGoal runs on session open and populates goal', async () => {
+    const goal = makeGoal()
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse([])
+    api.goals.get = () => Promise.resolve(ok({ goal }))
+    await session.open()
+    expect(session.getSnapshot().goal).toEqual(goal)
+  })
+
+  const goalChangeEvent = (seq: number, operation: string): SessionEvent =>
+    at(seq, {
+      type: 'context/message', surfaceOp: 'append',
+      data: {
+        content: [{ type: 'text', text: `goal ${operation}` }],
+        source: { kind: 'goal', goalId: 'g-1', revision: 1, round: 0 },
+        meta: {
+          kind: 'goal/change', version: 1, operation,
+          goal: { id: 'g-1', revision: 1, objective: 'x', phase: 'active', maxGoalRounds: 256 },
+          roundsStarted: 0, createdAt: 100, updatedAt: 100,
+        },
+      },
+    })
+
+  // Clear tombstones carry no goal key — the trigger matches the meta kind, not a goal field.
+  const goalClearEvent = (seq: number): SessionEvent =>
+    at(seq, {
+      type: 'context/message', surfaceOp: 'append',
+      data: {
+        content: [{ type: 'text', text: 'goal cleared' }],
+        source: { kind: 'goal', goalId: 'g-1', revision: 2, round: 0 },
+        meta: { kind: 'goal/change', version: 1, operation: 'clear', cleared: { id: 'g-1', revision: 2 }, clearedAt: 100 },
+      },
+    })
+
+  it('live goal-change meta triggers one coalesced refetch; window replays never refetch', async () => {
+    const { api, session } = makeSession()
+    // The history window replays goal-change meta (a snapshot change AND a clear tombstone).
+    api.onHistory = () => histResponse([...plainTurn(0, 0, 'a', 'b'), goalChangeEvent(6, 'create'), goalClearEvent(7)])
+    await session.open()
+    await Promise.resolve()
+    expect(api.callsOf('goal.get')).toHaveLength(1) // the eager open fetch only — no replay storm
+
+    // A plain live context message is not a goal change.
+    let refetches = 0
+    const gate = deferred<Awaited<ReturnType<FakeApiClient['goals']['get']>>>()
+    api.goals.get = () => { refetches++; return gate.promise } // replacement bypasses record(): count locally
+    session.handleMuxEnvelope('r0' as never, {
+      type: 'session/event', sessionId: SID,
+      event: at(8, { type: 'context/message', surfaceOp: 'append', data: { content: [{ type: 'text', text: 'plain' }], source: { kind: 'system' } } }),
+    })
+    expect(refetches).toBe(0)
+
+    // Two live goal events (change + clear tombstone) coalesce into a single refetch.
+    session.handleMuxEnvelope('r1' as never, { type: 'session/event', sessionId: SID, event: goalChangeEvent(9, 'edit') })
+    session.handleMuxEnvelope('r2' as never, { type: 'session/event', sessionId: SID, event: goalClearEvent(10) })
+    expect(refetches).toBe(1)
+    const goal = makeGoal({ revision: 3 })
+    gate.resolve(ok({ goal }))
+    await vi.waitFor(() => { expect(session.getSnapshot().goal).toEqual(goal) })
+  })
+
+  it('drops a goal.get result older than a mutation response that landed mid-flight', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+
+    let refetches = 0
+    const gate = deferred<Awaited<ReturnType<FakeApiClient['goals']['get']>>>()
+    api.goals.get = () => { refetches++; return gate.promise } // replacement bypasses record(): count locally
+    session.handleMuxEnvelope('r' as never, { type: 'session/event', sessionId: SID, event: goalChangeEvent(6, 'edit') })
+    expect(refetches).toBe(1) // the live refetch is parked on the gate
+    const completed = makeGoal({ revision: 2, phase: 'complete', activation: 'disarmed' })
+    api.goals.complete = () => Promise.resolve(ok({ goal: completed }))
+    await session.completeGoal() // newer write lands while the get is in flight
+    gate.resolve(ok({ goal: makeGoal({ objective: 'stale-read' }) }))
+    await new Promise(resolve => setTimeout(resolve, 0))
+    expect(session.getSnapshot().goal).toEqual(completed) // the stale read never overwrote it
+  })
+
+  it('folds transport rejections from goal mutations into { ok: false } without rejecting', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    api.goals.create = () => Promise.reject(new Error('goal wire down'))
+    const created = await session.createGoal('test-goal')
+    expect(created).toMatchObject({ ok: false, error: { code: 'internal', message: 'goal wire down' } })
+    expect(session.getSnapshot().goal).toBeNull()
+
+    const goal = makeGoal()
+    api.goals.create = () => Promise.resolve(ok({ goal }))
+    await session.createGoal('test-goal')
+    api.goals.pause = () => Promise.reject(new Error('pause wire down'))
+    const paused = await session.pauseGoal()
+    expect(paused).toMatchObject({ ok: false, error: { code: 'internal', message: 'pause wire down' } })
+    expect(session.getSnapshot().goal).toEqual(goal) // local state untouched
+  })
+
+  it('a goal.get transport rejection on a live refetch is logged and swallowed', async () => {
+    const { api, session } = makeSession()
+    api.onHistory = () => histResponse(plainTurn(0, 0, 'a', 'b'))
+    await session.open()
+    api.goals.get = () => Promise.reject(new Error('get wire down'))
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined)
+    try {
+      session.handleMuxEnvelope('r' as never, { type: 'session/event', sessionId: SID, event: goalChangeEvent(6, 'create') })
+      await vi.waitFor(() => { expect(errorSpy).toHaveBeenCalled() })
+      expect(session.getSnapshot().goal).toBeNull() // fail-soft: state untouched
+    } finally {
+      errorSpy.mockRestore()
+    }
+  })
+})