dsh-plugin-mobile-gateway 0.7.3 → 0.7.5

package/lib/index.mjs

@@ -1,3 +1,4 @@
+import { stringifyWireFrame } from './wire-json.mjs'
 // dsh-plugin-mobile-gateway — persistent Host plugin.
 //
 // Two directions:
@@ -128,7 +129,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 +266,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': {
@@ -274,19 +279,11 @@ function buildWireEvent(session, event) {
           type: 'user/message',
           text: textOf(d.content || []),
           source: d.source && d.source.kind,
+          ...(typeof d.id === 'string' && d.id ? { raw: { id: d.id } } : {}),
           ...(images.length ? { images } : {}),
         },
       })
     }
-    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 +297,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 +332,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 +482,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')
@@ -561,6 +564,13 @@ async function proxyQuery(api, type, method, payload, signal) {
   }
 }
 
+// Projection queries must keep the caller's request identity on failure.
+// They need the opening cut and projections, not the full conversation body.
+async function querySessionProjection(api, requestType, sessionId) {
+  const history = await proxyQuery(api, 'history', api.sessions.history.bind(api.sessions), { sessionId, maxMessages: 1 })
+  return history.kind === 'error' ? { ...history, requestType, sessionId } : history
+}
+
 function fileTransferError(code, message, requestType, sessionId) {
   return {
     kind: 'error',
@@ -1024,6 +1034,9 @@ async function mutateGoal(api, type, method, payload) {
 // and truncates oversized tool-result text.
 // ---------------------------------------------------------------------------
 const HISTORY_DEFAULT_MAX_BYTES = 4 * 1024 * 1024 // 4 MiB per frame
+// Opening snapshots should be readable before older history is requested.
+// Keep the newest indivisible message even when it alone exceeds this budget.
+const HISTORY_OPENING_MAX_BYTES = 256 * 1024
 const HISTORY_TOOL_RESULT_MAX_CHARS = 2000 // per text block in conversation view
 
 function eventBytes(event) {
@@ -1037,8 +1050,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 +1108,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 +1158,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 +1333,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 +1397,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 +1551,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')) {
@@ -1600,7 +1636,9 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
     }
     const sessionId = typeof msg.sessionId === 'string' && msg.sessionId.trim() !== '' ? msg.sessionId.trim() : null
     if (sessionId) {
-      const hist = await proxyQuery(api, 'history', api.sessions.history.bind(api.sessions), { sessionId })
+      out.sessionId = sessionId
+      const hist = await querySessionProjection(api, msg.type, sessionId)
+      if (hist.kind === 'error') return hist
       if (hist.kind === 'history' && hist.projections && hist.projections.values) {
         out.sessionPermissions = hist.projections.values.permissions || null
       }
@@ -1648,7 +1686,7 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
   if (msg.type === 'context-usage') {
     const sessionId = requireSessionId(msg)
     if (sessionId.error) return sessionId.error
-    const hist = await proxyQuery(api, 'history', api.sessions.history.bind(api.sessions), { sessionId: sessionId.value })
+    const hist = await querySessionProjection(api, msg.type, sessionId.value)
     if (hist.kind !== 'history') return hist
     const values = (hist.projections && hist.projections.values) || {}
     return {
@@ -1662,7 +1700,7 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
   if (msg.type === 'session-stats') {
     const sessionId = requireSessionId(msg)
     if (sessionId.error) return sessionId.error
-    const hist = await proxyQuery(api, 'history', api.sessions.history.bind(api.sessions), { sessionId: sessionId.value })
+    const hist = await querySessionProjection(api, msg.type, sessionId.value)
     if (hist.kind !== 'history') return hist
     const values = (hist.projections && hist.projections.values) || {}
     return {
@@ -2053,6 +2091,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'
@@ -2154,7 +2193,7 @@ const plugin = {
     })
 
     const broadcastInteractionFrame = (frame) => {
-      const wire = JSON.stringify(frame)
+      const wire = stringifyWireFrame(frame)
       for (const client of clients) {
         if (client.mobileChannel === 'conversation') continue
         if (client.filterSessionId && client.filterSessionId !== frame.sessionId) continue
@@ -2166,7 +2205,7 @@ const plugin = {
     // subscribed to one conversation. Subscriptions only scope the heavier
     // conversation and interaction streams.
     const broadcastSessionMetadataFrame = (frame) => {
-      const wire = JSON.stringify(frame)
+      const wire = stringifyWireFrame(frame)
       for (const client of clients) {
         if (client.mobileChannel === 'conversation') continue
         if (client.readyState === 1) client.send(wire)
@@ -2179,12 +2218,12 @@ const plugin = {
       let approvalCount = 0
       for (const pending of pendingQuestions.values()) {
         if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(JSON.stringify(questionFrameFor(pending.rpcId, pending, true)))
+        ws.send(stringifyWireFrame(questionFrameFor(pending.rpcId, pending, true)))
         questionCount += 1
       }
       for (const pending of pendingApprovals.values()) {
         if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(JSON.stringify(approvalFrameFor(pending.rpcId, pending, true)))
+        ws.send(stringifyWireFrame(approvalFrameFor(pending.rpcId, pending, true)))
         approvalCount += 1
       }
       log(`interaction replay: trigger=${trigger} filtered=${Boolean(ws.filterSessionId)} questions=${questionCount} approvals=${approvalCount}`)
@@ -2539,47 +2578,87 @@ const plugin = {
             log('mobile gateway wait completed: device connected')
           }
 
+          const sendFrame = frame => {
+            if (ws.readyState === 1) ws.send(stringifyWireFrame(frame))
+          }
+          ws.sessionFollower = createSessionFollower(api, {
+            onFrame(frame, context) {
+              if (frame.type === 'snapshot') {
+                sendFrame({ ...historyPage(frame.history, { sessionId: context.sessionId, view: 'conversation', maxBytes: HISTORY_OPENING_MAX_BYTES }),
+                  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 {
               msg = JSON.parse(data.toString())
             } catch (error) {
-              ws.send(JSON.stringify({ kind: 'error', message: 'invalid json' }))
+              ws.send(stringifyWireFrame({ kind: 'error', message: 'invalid json' }))
               return
             }
             if (!msg || typeof msg.type !== 'string') return
             const conversationRequest = ['message', 'history', 'subscribe', 'unsubscribe'].includes(msg.type)
             if ((ws.mobileChannel === 'control' && conversationRequest) ||
                 (ws.mobileChannel === 'conversation' && !conversationRequest && msg.type !== 'ping')) {
-              ws.send(JSON.stringify({ kind: 'error', code: 'wrong-channel', requestType: msg.type, message: 'Request belongs to the other mobile channel' }))
+              ws.send(stringifyWireFrame({ kind: 'error', code: 'wrong-channel', requestType: msg.type, message: 'Request belongs to the other mobile channel' }))
               return
             }
 
             if (msg.type === 'ping') {
-              ws.send(JSON.stringify({ kind: 'pong', at: Date.now() }))
+              ws.send(stringifyWireFrame({ 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))
+                if (frame && ws.readyState === 1) ws.send(stringifyWireFrame(frame))
               })
             } else if (msg.type === 'approval-response') {
               respondToApproval(msg).then((frame) => {
-                if (frame && ws.readyState === 1) ws.send(JSON.stringify(frame))
+                if (frame && ws.readyState === 1) ws.send(stringifyWireFrame(frame))
               })
             } else if (msg.type === 'file-list' || msg.type === 'file-download-open' ||
                        msg.type === 'file-download-read' || msg.type === 'file-download-cancel') {
               fileTransfers.handle(ws, msg).then((frame) => {
-                if (frame && ws.readyState === 1) ws.send(JSON.stringify(frame))
+                if (frame && ws.readyState === 1) ws.send(stringifyWireFrame(frame))
               })
             } else if (msg.type === 'message') {
               admitMessage(api, msg).then((frame) => {
-                if (frame && ws.readyState === 1) ws.send(JSON.stringify(frame))
+                if (frame && ws.readyState === 1) ws.send(stringifyWireFrame(frame))
               })
             } else if (msg.type === 'workspaces' || msg.type === 'sessions' || msg.type === 'history' || msg.type === 'attachment' ||
                        msg.type === 'search' || msg.type === 'host' || msg.type === 'directories' || msg.type === 'directory-create' ||
@@ -2593,14 +2672,15 @@ const plugin = {
                        msg.type === 'tasks' || msg.type === 'goal' || msg.type === 'goal-edit' ||
                        msg.type === 'goal-pause' || msg.type === 'goal-resume' || msg.type === 'goal-clear') {
               handleQuery(api, host, agentDefaultModel, msg).then((frame) => {
-                if (frame && ws.readyState === 1) ws.send(JSON.stringify(frame))
+                if (frame && ws.readyState === 1) ws.send(stringifyWireFrame(frame))
               })
             } else {
-              ws.send(JSON.stringify({ kind: 'error', message: 'unknown message type: ' + msg.type }))
+              ws.send(stringifyWireFrame({ kind: 'error', message: 'unknown message type: ' + msg.type }))
             }
           })
 
           ws.on('close', () => {
+            ws.sessionFollower.stop()
             clients.delete(ws)
             if (ws.deviceId) registry.disconnected(ws.deviceId)
             releaseUnclaimedInteractions()
@@ -2612,19 +2692,24 @@ const plugin = {
 
           log(`client connected (id=${id}, total=${clients.size})${device ? ' device=' + device.name : ''}`)
           if (paired) {
-            ws.send(JSON.stringify({
+            ws.send(stringifyWireFrame({
               kind: 'paired',
               token: paired.token,
               device: paired.device,
               ...gatewayIdentity,
             }))
           }
-          ws.send(JSON.stringify({
+          ws.send(stringifyWireFrame({
             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',
@@ -2642,10 +2727,13 @@ const plugin = {
             ...(device ? { device: { id: device.id, name: device.name } } : {}),
           }))
           if (ws.mobileChannel !== 'conversation' && archivedSessionIds !== null) {
-            ws.send(JSON.stringify({ kind: 'session-archives', archivedSessionIds }))
+            ws.send(stringifyWireFrame({ kind: 'session-archives', archivedSessionIds }))
           }
           if (ws.mobileChannel !== 'conversation' && sessionQueues !== null) {
-            ws.send(JSON.stringify({ kind: 'session-queues', queues: Object.fromEntries(sessionQueues) }))
+            ws.send(stringifyWireFrame({ kind: 'session-queues', queues: Object.fromEntries(sessionQueues) }))
+          }
+          if (ws.mobileChannel !== 'conversation') {
+            sendFrame({ kind: 'projection-baseline', projections: sessionProjectionBaselines })
           }
           replayPendingInteractions(ws, 'connect')
         })
@@ -2714,9 +2802,9 @@ const plugin = {
           ...(event.data.source ? { source: event.data.source } : {}),
         })
       }
-      const payload = JSON.stringify(wire)
+      const payload = stringifyWireFrame(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 +2937,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 +2992,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 +3032,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')