dsh-plugin-mobile-gateway 0.7.3 → 0.7.4

package/lib/dsh-host-adapter.mjs

@@ -13,88 +13,52 @@ function requireArray(value, endpoint) {
   return value
 }
 
-function chunkRowLength(event) {
-  if (event.type === 'chunkrow/tool-call-chunks') return requireArray(event.data?.args, event.type).length
-  return requireArray(event.data?.texts, event.type).length
+export const DSH_VERSION = '0.1.5-rc.2'
+export const SESSION_FORMAT_VERSION = 3
+
+export function readHistoryRecords(records) {
+  return requireArray(records, 'session history').map(record => {
+    const value = requireRecord(record, 'session history record')
+    if (value.type !== 'event') throw new Error('DSH 0.1.5-rc.2 history requires event records')
+    const event = requireRecord(value.event, 'session history event')
+    if (!Number.isSafeInteger(event.seq) || event.seq < 0) throw new Error('invalid history sequence')
+    return event
+  })
 }
 
-// DSH 0.1.2 compresses consecutive assistant deltas inside history pages.
-// dsh-mobile-v1 predates that storage shape, so restore the exact logical
-// SessionEvent sequence at this boundary instead of teaching every client a
-// Host-specific encoding detail.
-function expandChunkRow(event) {
-  const data = requireRecord(event.data, event.type)
-  const values = event.type === 'chunkrow/tool-call-chunks'
-    ? requireArray(data.args, event.type)
-    : requireArray(data.texts, event.type)
-  const gaps = requireArray(data.dt, event.type)
-  if (gaps.length !== Math.max(0, values.length - 1)) {
-    throw new Error(`${event.type} returned invalid timing data`)
-  }
-  const events = []
-  let time = event.time
-  for (let index = 0; index < values.length; index += 1) {
-    if (index > 0) time += gaps[index - 1]
-    let chunk
-    if (event.type === 'chunkrow/text-chunks') {
-      chunk = { type: 'text-delta', index: data.index, text: values[index] }
-    } else if (event.type === 'chunkrow/reasoning-chunks') {
-      chunk = { type: 'reasoning-delta', index: data.index, text: values[index] }
-    } else {
-      chunk = {
-        type: 'tool-call-delta',
-        index: data.index,
-        id: data.id,
-        ...(Object.hasOwn(data, 'name') ? { name: data.name } : {}),
-        argumentsDelta: values[index],
-      }
-    }
-    events.push({
-      type: 'assistant/chunk',
-      seq: event.seq + index,
-      time,
-      data: { turn: data.turn, step: data.step, chunk },
+export function readSessionSnapshot(frame, sessionId) {
+  requireRecord(frame, 'session/follow')
+  if (frame.type !== 'snapshot' || !Number.isSafeInteger(frame.cursor) || frame.cursor < -1
+    || frame.header?.id !== sessionId) throw new Error('session/follow returned an invalid snapshot')
+  if (frame.header.version !== SESSION_FORMAT_VERSION) {
+    throw Object.assign(new Error('mobile-gateway requires DSH 0.1.5-rc.2 Session format 3'), {
+      code: 'unsupported-session-format',
     })
   }
-  return events
-}
-
-export function expandHistoryRecords(records) {
-  const events = []
-  for (const record of requireArray(records, 'session history')) {
-    const value = requireRecord(record, 'session history record')
-    const event = requireRecord(value.event, 'session history event')
-    if (value.type === 'event') {
-      events.push(event)
-      continue
-    }
-    if (value.type !== 'chunks' || ![
-      'chunkrow/text-chunks',
-      'chunkrow/reasoning-chunks',
-      'chunkrow/tool-call-chunks',
-    ].includes(event.type)) {
-      throw new Error('session history returned an unsupported record')
-    }
-    if (chunkRowLength(event) === 0) throw new Error(`${event.type} returned an empty run`)
-    events.push(...expandChunkRow(event))
+  return {
+    events: readHistoryRecords(frame.records).map(event => ({ event })),
+    hasMore: frame.hasMore === true,
+    projections: requireRecord(frame.projections, 'session/follow projections'),
+    historyFormatVersion: frame.header.version,
+    cursor: frame.cursor,
   }
-  return events
 }
 
 async function firstStreamFrame(gateway, namespace, method, args, signal) {
-  const ownedAbort = signal === undefined ? new AbortController() : null
-  const streamSignal = signal ?? ownedAbort.signal
-  const iterable = await gateway.stream({ namespace, method, args, signal: streamSignal })
-  const iteratorFactory = iterable?.[Symbol.asyncIterator] ?? iterable?.[Symbol.iterator]
-  if (typeof iteratorFactory !== 'function') throw new Error(`${namespace}/${method} returned an invalid stream`)
-  const iterator = iteratorFactory.call(iterable)
+  const ownedAbort = new AbortController()
+  const streamSignal = signal ? AbortSignal.any([signal, ownedAbort.signal]) : ownedAbort.signal
+  let iterator
   try {
+    const iterable = await gateway.stream({ namespace, method, args, signal: streamSignal })
+    const iteratorFactory = iterable?.[Symbol.asyncIterator] ?? iterable?.[Symbol.iterator]
+    if (typeof iteratorFactory !== 'function') throw new Error(`${namespace}/${method} returned an invalid stream`)
+    iterator = iteratorFactory.call(iterable)
     const first = await iterator.next()
     if (first.done) throw new Error(`${namespace}/${method} ended before its opening frame`)
     return first.value
   } finally {
-    ownedAbort?.abort()
-    if (typeof iterator.return === 'function') await iterator.return()
+    ownedAbort.abort()
+    if (typeof iterator?.return === 'function') await iterator.return()
   }
 }
 
@@ -102,7 +66,7 @@ function requestArgs(request) {
   return { request }
 }
 
-// The RC.1 SessionController intentionally names its reserved list argument
+// The 0.1.5-rc.2 SessionController names its reserved list argument
 // `_request`. Typert descriptors preserve that source parameter name exactly,
 // so this endpoint cannot share the normal `{ request }` wrapper.
 function sessionListArgs(request) {
@@ -134,10 +98,7 @@ export function createDshHostAdapter(typertGateway) {
       requestArgs(request),
       signal,
     ), 'session/follow')
-    if (frame.type !== 'snapshot' || !Number.isSafeInteger(frame.cursor)) {
-      throw new Error('session/follow returned an invalid opening snapshot')
-    }
-    return frame
+    return readSessionSnapshot(frame, request.address.sessionId)
   }
 
   const history = async (payload, signal) => {
@@ -146,8 +107,8 @@ export function createDshHostAdapter(typertGateway) {
       ...(payload.maxMessages === undefined ? {} : { maxMessages: payload.maxMessages }),
     }
     const snapshot = await sessionSnapshot(request, signal)
-    let records = snapshot.records
-    let hasMore = snapshot.hasMore === true
+    let events = snapshot.events
+    let hasMore = snapshot.hasMore
     if (payload.beforeSeq !== undefined) {
       const page = requireRecord(await invoke('session', 'page', requestArgs({
         address: request.address,
@@ -155,13 +116,13 @@ export function createDshHostAdapter(typertGateway) {
         beforeSeq: payload.beforeSeq,
         ...(payload.maxMessages === undefined ? {} : { maxMessages: payload.maxMessages }),
       }), signal), 'session/page')
-      records = page.records
+      events = readHistoryRecords(page.records).map(event => ({ event }))
       hasMore = page.hasMore === true
     }
     return {
-      events: expandHistoryRecords(records).map(event => ({ event })),
+      ...snapshot,
+      events,
       hasMore,
-      projections: requireRecord(snapshot.projections, 'session/follow projections'),
     }
   }
 
@@ -172,10 +133,13 @@ export function createDshHostAdapter(typertGateway) {
 
   const commands = {
     list: (sessionId, signal) => invoke('commands', 'list', { agentId: sessionId }, signal),
-    execute: (sessionId, line, images, signal) => invoke(
+    // DSH 0.1.5-rc.2 accepts `submittedAttachments`. The parsed
+    // wire images already carry the { type: 'image', ... } shape it expects, so
+    // only the field name changes.
+    execute: (sessionId, line, attachments, signal) => invoke(
       'commands',
       'execute',
-      { agentId: sessionId, line, images },
+      { agentId: sessionId, line, submittedAttachments: attachments },
       signal,
     ),
   }
@@ -196,6 +160,8 @@ export function createDshHostAdapter(typertGateway) {
     ])
     return {
       version: 'remote-gateway',
+      dshVersion: DSH_VERSION,
+      historyFormatVersion: SESSION_FORMAT_VERSION,
       cwd: os.homedir(),
       attachedSessions: Array.isArray(sessions?.items) ? sessions.items.length : 0,
       canOpenPath: canOpenPath === true,
@@ -301,6 +267,13 @@ export function createDshHostAdapter(typertGateway) {
       describe: (_payload = {}, signal) => describeHost(signal),
     },
     describeHost,
+    openSessionStream(sessionId, signal) {
+      return typertGateway.stream({
+        namespace: 'session', method: 'follow',
+        args: requestArgs({ address: { kind: 'session', sessionId }, assistantStream: true }),
+        signal,
+      })
+    },
     openControlStream(signal) {
       return typertGateway.stream({ namespace: 'session', method: 'control', args: {}, signal })
     },

package/lib/index.mjs

@@ -128,7 +128,8 @@ import crypto from 'node:crypto'
 import Schema from '@deepseek-ai/schemastery'
 import { WebSocketServer } from 'ws'
 import devicesModule from './devices.js'
-import { createDshHostAdapter } from './dsh-host-adapter.mjs'
+import { createDshHostAdapter, DSH_VERSION, SESSION_FORMAT_VERSION } from './dsh-host-adapter.mjs'
+import { createSessionFollower } from './session-follower.mjs'
 import { createGatewayState, GATEWAY_MODES } from './gateway-state.mjs'
 import QRCode from 'qrcode'
 
@@ -264,7 +265,10 @@ function imagesOf(blocks) {
 // Build the small, owned JSON wire record for one session event. Reads only
 // leaf fields of the live SessionEvent — never serializes live objects.
 function buildWireEvent(session, event) {
-  const base = { kind: 'event', sessionId: String(session.id), seq: event.seq, time: event.time }
+  const base = { kind: 'event', sessionId: String(session.id), seq: event.seq, time: event.time,
+    ...(event.surfaceOp === undefined ? {} : { surfaceOp: event.surfaceOp }),
+    ...(event.sourceEventSeqs === undefined ? {} : { sourceEventSeqs: event.sourceEventSeqs }),
+  }
   const d = event.data || {}
   switch (event.type) {
     case 'user/message': {
@@ -278,15 +282,6 @@ function buildWireEvent(session, event) {
         },
       })
     }
-    case 'assistant/chunk': {
-      const chunk = d.chunk || {}
-      const ev = { type: 'assistant/chunk', turn: d.turn, step: d.step, chunkType: chunk.type }
-      if (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta') ev.text = chunk.text
-      if (chunk.type === 'tool-call-delta') ev.tool = { id: chunk.id, name: chunk.name, argumentsDelta: chunk.argumentsDelta }
-      if (chunk.type === 'usage') ev.usage = chunk.usage
-      if (chunk.type === 'finish') ev.finish = { kind: chunk.reason && chunk.reason.kind }
-      return Object.assign(base, { event: ev })
-    }
     case 'assistant/message': {
       const blocks = (d.message && d.message.content) || []
       let text = ''
@@ -300,9 +295,15 @@ function buildWireEvent(session, event) {
         else if (block.type === 'tool-call') toolCalls.push({ id: block.id, name: block.name, arguments: block.arguments })
       }
       return Object.assign(base, {
-        event: { type: 'assistant/message', turn: d.turn, step: d.step, text, reasoning, toolCalls, ...(images.length ? { images } : {}) },
+        event: { type: 'assistant/message', turn: d.turn, step: d.step, text, reasoning, toolCalls,
+          ...(d.interrupted === true ? { interrupted: true } : {}),
+          ...(d.usage === undefined ? {} : { usage: d.usage }),
+          ...(images.length ? { images } : {}),
+        },
       })
     }
+    case 'assistant/attempt':
+      return Object.assign(base, { event: { type: event.type, turn: d.turn, step: d.step, stream: d.stream } })
     case 'session/title':
       return Object.assign(base, {
         event: {
@@ -329,7 +330,7 @@ function buildWireEvent(session, event) {
           turn: d.turn,
           step: d.step,
           callId: d.message && d.message.source && d.message.source.callId,
-          isError: !!d.error,
+          isError: !!d.error || ((d.message && d.message.content) || []).some(block => block?.type === 'tool-result' && block.isError === true),
           preview,
         },
       })
@@ -479,7 +480,7 @@ async function admitCommand(host, msg) {
     if (!descriptor) {
       return { kind: 'error', code: 'unknown-command', message: `command not found: /${name}`, requestType: 'command-execute', sessionId: sessionId.value }
     }
-    if (parsedImages.value.length > 0 && descriptor.input?.images !== true) {
+    if (parsedImages.value.length > 0 && !commandAcceptsAttachments(descriptor)) {
       return { kind: 'error', code: 'bad-request', message: `/${name} does not accept image attachments`, requestType: 'command-execute', sessionId: sessionId.value }
     }
     return executeHostCommand(host, sessionId.value, line, parsedImages.value, 'command-execute')
@@ -1037,8 +1038,15 @@ function trimConversationEvent(event) {
   switch (event.type) {
     case 'assistant/chunk':
     case 'request/header':
+    case 'request/context':
+    case 'system/message':
       // token-level replay / system-prompt header: not rendered on the chat page
       return null
+    case 'assistant/message':
+    case 'assistant/attempt': {
+      const { stream, ...data } = event.data || {}
+      return { ...event, data }
+    }
     case 'tool/result': {
       const d = event.data || {}
       const message = d.message
@@ -1088,12 +1096,46 @@ function capHistoryEvents(events, maxBytes, trim) {
   return { events: processed.slice(keptStart), bytes: total, dropped: keptStart }
 }
 
+function validateHistoryCursor(msg, sessionId, field) {
+  if (msg[field] === undefined && msg.historyFormatVersion === undefined) return null
+  if (msg.historyFormatVersion !== SESSION_FORMAT_VERSION) {
+    return { kind: 'error', code: 'history-format-mismatch', requestType: msg.type, sessionId,
+      historyFormatVersion: SESSION_FORMAT_VERSION, resetRequired: true,
+      message: 'Reload the Session baseline before using a history or fork cursor; historyFormatVersion must be 3' }
+  }
+  if (msg[field] !== undefined && (!Number.isSafeInteger(msg[field]) || msg[field] < 0)) {
+    return { kind: 'error', code: 'bad-request', requestType: msg.type, sessionId,
+      message: `${field} must be a non-negative safe integer` }
+  }
+  return null
+}
+
+function historyPage(value, msg) {
+  const rawEvents = value.events.map(entry => entry.event)
+  const maxBytes = Number.isSafeInteger(msg.maxBytes) && msg.maxBytes > 0 ? msg.maxBytes : HISTORY_DEFAULT_MAX_BYTES
+  const trim = msg.view === 'conversation'
+  const capped = capHistoryEvents(rawEvents, maxBytes, trim)
+  const hasMore = value.hasMore === true || capped.dropped > 0
+  // An all-hidden page still needs a cursor so callers can reach older text.
+  const oldest = capped.events[0]?.seq ?? rawEvents[0]?.seq
+  return { ...value, kind: 'history', sessionId: msg.sessionId,
+    events: capped.events, bytes: capped.bytes, hasMore,
+    ...(trim ? { view: 'conversation' } : {}),
+    ...(hasMore && oldest !== undefined ? { nextBeforeSeq: oldest } : {}),
+  }
+}
+
 function resolveCommandCatalogCopy(locale) {
   return typeof locale === 'string' && !locale.toLowerCase().startsWith('zh')
     ? COMMAND_CATALOG_COPY.en
     : COMMAND_CATALOG_COPY.zh
 }
 
+// DSH 0.1.5-rc.2 command descriptors use input.attachments.
+function commandAcceptsAttachments(command) {
+  return command?.input?.attachments === true
+}
+
 function commandUiDescriptor(command, copy) {
   const override = COMMAND_UI_OVERRIDES[command.name]
   if (override) return { ...override, insertText: `/${command.name}` }
@@ -1104,7 +1146,7 @@ function commandUiDescriptor(command, copy) {
       insertText: `/${command.name} `,
       hint: command.input.hint,
       ...(displayHint ? { displayHint } : {}),
-      images: command.input.images === true,
+      images: commandAcceptsAttachments(command),
       submitRequest: 'command-execute',
     }
   }
@@ -1279,33 +1321,13 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
     if (!sessionId) {
       return { kind: 'error', code: 'bad-request', message: 'history requires a sessionId', requestType: 'history' }
     }
+    const cursorError = validateHistoryCursor(msg, sessionId, 'beforeSeq')
+    if (cursorError) return cursorError
     const payload = { sessionId }
     if (typeof msg.beforeSeq === 'number' && Number.isFinite(msg.beforeSeq)) payload.beforeSeq = msg.beforeSeq
     if (typeof msg.maxMessages === 'number' && Number.isFinite(msg.maxMessages)) payload.maxMessages = msg.maxMessages
     const frame = await proxyQuery(api, 'history', api.sessions.history.bind(api.sessions), payload)
-    if (frame.kind === 'history') {
-      // Scheme A base: pass the raw SessionEvent list through (drop the host
-      // render intent); keep the projections block and echo the sessionId.
-      const rawEvents = Array.isArray(frame.events) ? frame.events.map((entry) => entry.event) : []
-      // Byte budget + optional conversation trim — keeps the frame under the
-      // client's WebSocket limit and pages the rest via nextBeforeSeq.
-      const maxBytes = typeof msg.maxBytes === 'number' && Number.isFinite(msg.maxBytes) && msg.maxBytes > 0
-        ? Math.floor(msg.maxBytes)
-        : HISTORY_DEFAULT_MAX_BYTES
-      const trim = msg.view === 'conversation'
-      const capped = capHistoryEvents(rawEvents, maxBytes, trim)
-      frame.events = capped.events
-      frame.sessionId = sessionId
-      frame.bytes = capped.bytes
-      if (trim) frame.view = 'conversation'
-      // hasMore combines the host's message-count pagination with byte-drop.
-      const apiHasMore = frame.hasMore === true
-      const byteDropped = capped.dropped > 0
-      frame.hasMore = apiHasMore || byteDropped > 0
-      if (frame.hasMore && capped.events.length > 0) {
-        frame.nextBeforeSeq = capped.events[0].seq // oldest kept event: page back from here
-      }
-    }
+    if (frame.kind === 'history') return historyPage(frame, { ...msg, sessionId })
     return frame
   }
   if (msg.type === 'attachment') {
@@ -1363,6 +1385,8 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
   if (msg.type === 'fork') {
     const sessionId = requireSessionId(msg)
     if (sessionId.error) return sessionId.error
+    const cursorError = validateHistoryCursor(msg, sessionId.value, 'atSeq')
+    if (cursorError) return cursorError
     const payload = { sessionId: sessionId.value }
     if (typeof msg.atSeq === 'number' && Number.isFinite(msg.atSeq)) payload.atSeq = Math.floor(msg.atSeq)
     const frame = await proxyQuery(api, 'fork', api.sessions.fork.bind(api.sessions), payload)
@@ -1515,7 +1539,7 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
           action: 'execute',
           ui: commandUiDescriptor(command, copy),
           ...(command.input && typeof command.input.hint === 'string'
-            ? { input: { hint: command.input.hint, ...(command.input.images === true ? { images: true } : {}) } }
+            ? { input: { hint: command.input.hint, ...(commandAcceptsAttachments(command) ? { images: true } : {}) } }
             : {}),
         }))
       if (!commands.some((command) => command.name === 'model')) {
@@ -2053,6 +2077,7 @@ const plugin = {
     const backgroundStreamAbort = new AbortController()
     let archivedSessionIds = null
     let sessionQueues = null
+    let sessionProjectionBaselines = {}
     let counter = 0
     let gatewayMode = gatewayState.mode ?? options.gatewayMode ?? (options.gatewayEnabled === true ? 'persistent' : 'disabled')
     let gatewayEnabled = gatewayMode !== 'disabled'
@@ -2539,6 +2564,26 @@ const plugin = {
             log('mobile gateway wait completed: device connected')
           }
 
+          const sendFrame = frame => {
+            if (ws.readyState === 1) ws.send(JSON.stringify(frame))
+          }
+          ws.sessionFollower = createSessionFollower(api, {
+            onFrame(frame, context) {
+              if (frame.type === 'snapshot') {
+                sendFrame({ ...historyPage(frame.history, { sessionId: context.sessionId, view: 'conversation' }),
+                  kind: 'session-snapshot', ...context, assistantStream: frame.assistantStream, replace: true })
+              } else if (frame.type === 'event') {
+                sendFrame({ ...buildWireEvent({ id: context.sessionId }, frame.event), ...context })
+              } else {
+                sendFrame({ kind: 'assistant-stream', ...context, frame: frame.frame })
+              }
+            },
+            onError(error, context) {
+              sendFrame({ kind: 'session-stream-reset', ...context,
+                code: error.code || 'stream-interrupted', message: error.message })
+            },
+          })
+
           ws.on('message', (data) => {
             let msg
             try {
@@ -2558,12 +2603,32 @@ const plugin = {
             if (msg.type === 'ping') {
               ws.send(JSON.stringify({ kind: 'pong', at: Date.now() }))
             } else if (msg.type === 'subscribe') {
-              ws.filterSessionId = typeof msg.sessionId === 'string' ? msg.sessionId : undefined
-              ws.send(JSON.stringify({ kind: 'subscribed', sessionId: ws.filterSessionId || null }))
+              if (msg.assistantStream !== undefined && typeof msg.assistantStream !== 'boolean') {
+                sendFrame({ kind: 'error', code: 'bad-request', requestType: 'subscribe', message: 'assistantStream must be a boolean' })
+                return
+              }
+              const sessionId = typeof msg.sessionId === 'string' && msg.sessionId.trim() ? msg.sessionId.trim() : undefined
+              if (msg.assistantStream === true && !sessionId) {
+                sendFrame({ kind: 'error', code: 'bad-request', requestType: 'subscribe', message: 'assistantStream requires a sessionId' })
+                return
+              }
+              ws.sessionFollower.stop()
+              ws.filterSessionId = sessionId
+              ws.sessionFollowerActive = msg.assistantStream === true
+              const subscriptionId = crypto.randomUUID()
+              sendFrame({ kind: 'subscribed', sessionId: sessionId || null, subscriptionId, assistantStream: ws.sessionFollowerActive })
+              if (ws.sessionFollowerActive) {
+                void ws.sessionFollower.start(sessionId, subscriptionId).catch(error => {
+                  log(`session follower failed: ${error.message}`)
+                  if (ws.readyState === 1) ws.close(1011, 'session follower failed')
+                })
+              }
               replayPendingInteractions(ws, 'subscribe')
             } else if (msg.type === 'unsubscribe') {
+              ws.sessionFollower.stop()
+              ws.sessionFollowerActive = false
               ws.filterSessionId = undefined
-              ws.send(JSON.stringify({ kind: 'subscribed', sessionId: null }))
+              sendFrame({ kind: 'subscribed', sessionId: null, assistantStream: false })
             } else if (msg.type === 'question-answer' || msg.type === 'question-cancel') {
               respondToQuestion(msg, msg.type === 'question-cancel').then((frame) => {
                 if (frame && ws.readyState === 1) ws.send(JSON.stringify(frame))
@@ -2601,6 +2666,7 @@ const plugin = {
           })
 
           ws.on('close', () => {
+            ws.sessionFollower.stop()
             clients.delete(ws)
             if (ws.deviceId) registry.disconnected(ws.deviceId)
             releaseUnclaimedInteractions()
@@ -2623,8 +2689,13 @@ const plugin = {
             kind: 'hello',
             ...gatewayIdentity,
             protocol: 3,
+            dshVersion: DSH_VERSION,
+            historyFormatVersion: SESSION_FORMAT_VERSION,
             capabilities: [
               'split-channels',
+              'assistant-stream-v1',
+              'history-format-version',
+              'projection-baseline',
               'images',
               'session-create',
               'commands',
@@ -2647,6 +2718,9 @@ const plugin = {
           if (ws.mobileChannel !== 'conversation' && sessionQueues !== null) {
             ws.send(JSON.stringify({ kind: 'session-queues', queues: Object.fromEntries(sessionQueues) }))
           }
+          if (ws.mobileChannel !== 'conversation') {
+            sendFrame({ kind: 'projection-baseline', projections: sessionProjectionBaselines })
+          }
           replayPendingInteractions(ws, 'connect')
         })
     }
@@ -2716,7 +2790,7 @@ const plugin = {
       }
       const payload = JSON.stringify(wire)
       for (const client of clients) {
-        if (client.mobileChannel === 'control') continue
+        if (client.mobileChannel === 'control' || client.sessionFollowerActive) continue
         if (client.filterSessionId && client.filterSessionId !== String(session.id)) continue
         if (client.readyState === 1) client.send(payload)
       }
@@ -2849,6 +2923,33 @@ const plugin = {
       log(`session queue forwarded: session=${sessionId} items=${items.length}`)
     }
 
+    const projectionFrame = (sessionId, key, value, seq) => ({
+      kind: key === 'todos' ? 'tasks-updated' : 'goal-updated', sessionId, asOfSeq: seq,
+      [key]: value,
+    })
+
+    const installProjectionBaseline = value => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid projection baseline')
+      const next = {}
+      for (const [sessionId, baseline] of Object.entries(value)) {
+        if (!Number.isSafeInteger(baseline?.asOfSeq) || !baseline.values || typeof baseline.values !== 'object' || Array.isArray(baseline.values)) {
+          throw new Error('invalid session projection baseline')
+        }
+        Object.defineProperty(next, sessionId, { enumerable: true, configurable: true, writable: true,
+          value: { asOfSeq: baseline.asOfSeq, values: { todos: baseline.values.todos ?? null, goal: baseline.values.goal ?? null } } })
+      }
+      const previous = sessionProjectionBaselines
+      sessionProjectionBaselines = next
+      broadcastSessionMetadataFrame({ kind: 'projection-baseline', projections: next })
+      for (const sessionId of new Set([...Object.keys(previous), ...Object.keys(next)])) {
+        const baseline = Object.hasOwn(next, sessionId) ? next[sessionId] : null
+        for (const key of ['todos', 'goal']) {
+          broadcastInteractionFrame(projectionFrame(sessionId, key, baseline?.values[key] ?? null,
+            baseline?.asOfSeq ?? previous[sessionId].asOfSeq))
+        }
+      }
+    }
+
     const workspaceTask = (async () => {
       while (!backgroundStreamAbort.signal.aborted) {
         try {
@@ -2877,19 +2978,16 @@ const plugin = {
           const stream = await api.openControlStream(backgroundStreamAbort.signal)
           for await (const frame of stream) {
             if (frame?.type === 'baseline') {
+              installProjectionBaseline(frame.value?.projections)
               installSessionQueueBaseline(frame.value?.queues)
             } else if (frame?.type === 'queue') {
               installSessionQueue(frame.sessionId, frame.items)
             } else if (frame?.type === 'projection' && (frame.key === 'todos' || frame.key === 'goal')) {
               const sessionId = String(frame.sessionId)
-              const kind = frame.key === 'todos' ? 'tasks-updated' : 'goal-updated'
-              const valueKey = frame.key === 'todos' ? 'todos' : 'goal'
-              broadcastInteractionFrame({
-                kind,
-                sessionId,
-                asOfSeq: frame.seq,
-                [valueKey]: frame.value,
-              })
+              const previous = Object.hasOwn(sessionProjectionBaselines, sessionId) ? sessionProjectionBaselines[sessionId] : null
+              Object.defineProperty(sessionProjectionBaselines, sessionId, { enumerable: true, configurable: true, writable: true,
+                value: { asOfSeq: frame.seq, values: { ...previous?.values, [frame.key]: frame.value } } })
+              broadcastInteractionFrame(projectionFrame(sessionId, frame.key, frame.value, frame.seq))
               log(`projection forwarded: key=${frame.key} session=${sessionId} seq=${frame.seq}`)
             }
           }
@@ -2920,7 +3018,10 @@ const plugin = {
       disposeQuestions()
       disposeApprovals()
       if (lanServer) lanServer.close()
-      for (const client of clients) client.terminate()
+      for (const client of clients) {
+        client.sessionFollower?.stop()
+        client.terminate()
+      }
       clients.clear()
       wss.close()
       log('plugin stopped, all sockets closed')