dsh-synapse 0.4.0 → 0.4.2

package/client.js

@@ -2,12 +2,18 @@ window.__ModuleLoader__.load({
   id: 'dsh-synapse',
   factory: () => {
     const module = { exports: {} }
+    // Consumer identity for owned Session references. The Client records
+    // positive reference counts per source; nothing else reads this string.
+    const SESSION_SOURCE = 'synapse'
+    // Shown when a Session is gone or no longer reachable from this browser.
+    const NO_SESSION = '关联的 DSH 会话已不可用'
     const currentSession = ctx => {
       const snapshot = ctx.sessions.list.getSnapshot()
-      const id = snapshot.current
-      if (id === undefined) return null
-      const session = snapshot.byId[id]
-      return session === undefined ? null : { id, title: session.displayTitle, cwd: session.cwd ?? null }
+      // 0.1.7 removed `list.current`: the Main view's own reference count is the
+      // Client's current-Session signal. `ui-workspace` derives the highlighted
+      // Session row from the same fact, so both stay in step by construction.
+      const session = Object.values(snapshot.byId).find(row => (row.retainedBy?.mainView ?? 0) > 0)
+      return session === undefined ? null : { id: session.id, title: session.displayTitle, cwd: session.cwd ?? null }
     }
     const sessionSnapshot = ctx => {
       const snapshot = ctx.sessions.list.getSnapshot()
@@ -26,14 +32,25 @@ window.__ModuleLoader__.load({
       ]
     }
 
-    module.exports.inject = ['sessions', 'workspaces']
+    module.exports.inject = ['sessions', 'workspaces', 'uiWorkspace', 'uiConversation']
     module.exports.apply = ctx => {
       const prompt = async (sessionId, text) => {
-        const scope = ctx.sessions.scope(sessionId)
-        const session = scope === undefined ? undefined : ctx.sessions.sessionOf(scope)
-        if (session === undefined) throw new Error('关联的 DSH 会话已不可用')
-        const result = await session.prompt([{ type: 'text', text }], 'queue')
-        if (!result.ok) throw new Error(result.error?.message ?? 'DSH 未接受这条消息')
+        // 0.1.7 owns Session lifetime explicitly: `scope()` only borrows an
+        // already-retained generation, so sending needs a reference of our own.
+        let reference
+        try {
+          reference = ctx.sessions.retain(sessionId, { source: SESSION_SOURCE })
+          await reference.ready
+        } catch {
+          reference?.release()
+          throw new Error(NO_SESSION)
+        }
+        try {
+          const result = await reference.binding.session.prompt([{ type: 'text', text }], 'queue')
+          if (!result.ok) throw new Error(result.error?.message ?? 'DSH 未接受这条消息')
+        } finally {
+          reference.release()
+        }
       }
       const style = document.createElement('style')
       style.textContent = '.dsh-synapse-switch{position:fixed;z-index:80;top:12px;left:50%;display:flex;gap:2px;transform:translateX(-50%);border:1px solid #d1d5db;border-radius:999px;background:rgba(255,255,255,.96);padding:3px;backdrop-filter:blur(10px)}.dsh-synapse-switch button{height:28px;border:0;border-radius:999px;background:transparent;padding:0 11px;color:#6b7280;font:600 12px Inter,system-ui,sans-serif;cursor:pointer;white-space:nowrap}.dsh-synapse-switch button:hover{background:#f3f4f6;color:#111827}.dsh-synapse-switch button.active{background:#111827;color:#fff}.dsh-synapse-switch button:focus-visible{outline:2px solid #111827;outline-offset:2px}.dsh-synapse-overlay{position:fixed;z-index:100;inset:0;background:#f5f7fa}.dsh-synapse-overlay.is-opening{visibility:hidden}.dsh-synapse-overlay[hidden]{display:none}.dsh-synapse-overlay iframe{display:block;width:100%;height:100%;border:0}'
@@ -64,25 +81,91 @@ window.__ModuleLoader__.load({
       const send = (type, payload) => { frame.contentWindow?.postMessage({ source: 'dsh-synapse', type, ...payload }, location.origin) }
       let syncQueued = false
       let knownSessionIds = new Set()
-      const liveUnsubscribers = new Map()
+      // One live record per catalogued Session. The pre-0.1.7 Client minted a
+      // Session scope on demand for any listed id, so live state was readable
+      // for every card; 0.1.7 mints none, so a Chat view is readable only while
+      // something holds a reference. A card whose Session is not observable
+      // still reports its `running` flag from the list row, because only the
+      // streaming text needs the view.
+      const liveSessions = new Map()
+      // References this plugin owns, so it can read a running Session's Chat
+      // view without depending on another surface retaining it.
+      const ownReferences = new Map()
+
+      const publishLiveSession = id => {
+        if (overlay.hidden) return
+        const text = liveSessions.get(id)?.chat?.getSnapshot()?.legacy.partial?.blocks
+          .filter(block => block.kind === 'text').map(block => block.text).join('\n') ?? ''
+        const running = ctx.sessions.list.getSnapshot().byId[id]?.running === true
+        send('synapse:live-reply', { sessionId: id, running, text })
+      }
+
+      const detachLiveSession = record => {
+        for (const unsubscribe of record.unsubscribers) unsubscribe()
+      }
+
+      // A running Session is the only kind that produces live text, so it is the
+      // only kind worth opening a reference — and its history read — for.
+      const syncObservedSessions = () => {
+        const rows = ctx.sessions.list.getSnapshot()
+        for (const id of rows.ids) {
+          const held = ownReferences.has(id)
+          const wanted = rows.byId[id]?.running === true && ctx.sessions.binding(id) === undefined
+          if (wanted && !held) {
+            try {
+              const reference = ctx.sessions.retain(id, { source: SESSION_SOURCE })
+              void reference.ready.catch(() => {})
+              ownReferences.set(id, reference)
+            } catch { /* the Session is not retainable right now */ }
+          } else if (!wanted && held) {
+            ownReferences.get(id).release()
+            ownReferences.delete(id)
+          }
+        }
+        for (const [id, reference] of ownReferences) {
+          if (rows.ids.includes(id)) continue
+          reference.release()
+          ownReferences.delete(id)
+        }
+      }
+
       const syncLiveSessions = () => {
-        const snapshot = ctx.sessions.list.getSnapshot()
-        for (const id of snapshot.ids) {
-          if (liveUnsubscribers.has(id)) continue
-          const scope = ctx.sessions.scope(id)
-          const session = scope === undefined ? undefined : ctx.sessions.sessionOf(scope)
-          if (session === undefined) continue
-          const publish = () => {
-            if (overlay.hidden) return
-            const state = session.getSnapshot()
-            const text = state.partial?.blocks.filter(block => block.kind === 'text').map(block => block.text).join('\n') ?? ''
-            send('synapse:live-reply', { sessionId: id, running: state.running, text })
+        syncObservedSessions()
+        const ids = ctx.sessions.list.getSnapshot().ids
+        for (const id of ids) {
+          const binding = ctx.sessions.binding(id)
+          let record = liveSessions.get(id)
+          // Rebuild when the observable source appears or disappears, and when a
+          // same-id generation replaced the borrowed binding.
+          if (record !== undefined && record.binding !== binding) {
+            detachLiveSession(record)
+            record = undefined
           }
-          liveUnsubscribers.set(id, session.subscribe(publish))
-          publish()
+          if (record === undefined) {
+            let chat
+            if (binding !== undefined) {
+              try { chat = ctx.uiConversation.binding(id).target('chat') } catch { chat = undefined }
+            }
+            liveSessions.set(id, {
+              binding,
+              chat,
+              // `target('chat')` is the only reader that activates the view
+              // target: its snapshot stays undefined until something subscribes.
+              unsubscribers: chat === undefined
+                ? []
+                : [chat.subscribe(() => publishLiveSession(id)), binding.session.subscribe(() => publishLiveSession(id))],
+            })
+          }
+        }
+        for (const [id, record] of liveSessions) {
+          if (ids.includes(id)) continue
+          detachLiveSession(record)
+          liveSessions.delete(id)
         }
-        for (const [id, unsubscribe] of liveUnsubscribers) if (!snapshot.ids.includes(id)) { unsubscribe(); liveUnsubscribers.delete(id) }
       }
+      // Always runs after `syncLiveSessions`, so a newly attached Session gets
+      // its first report here rather than publishing twice on the same sync.
+      const publishLiveSessions = () => { for (const id of liveSessions.keys()) publishLiveSession(id) }
       const syncSessions = () => {
         if (syncQueued) return
         syncQueued = true
@@ -102,6 +185,7 @@ window.__ModuleLoader__.load({
       const syncCurrentSession = () => {
         syncSessions()
         syncLiveSessions()
+        publishLiveSessions()
         syncTheme()
         if (!overlay.hidden) {
           send('synapse:workspaces', { workspaces: workspaceSnapshot(ctx) })
@@ -144,14 +228,46 @@ window.__ModuleLoader__.load({
           return send('synapse:current-session', { session: currentSession(ctx) })
         }
         if (event.data.type === 'synapse:open-session') {
-          try { ctx.sessions.open(event.data.sessionId); close() } catch { send('synapse:bridge-error', { message: '关联的 DSH 会话已不可用' }) }
+          // 0.1.7 moved navigation out of the Session Controller: selecting a
+          // Session and showing its Conversation is one Workspace UI action.
+          try { ctx.uiWorkspace.openSession(event.data.sessionId); close() } catch { send('synapse:bridge-error', { message: NO_SESSION }) }
+          // Best-effort anchor to the requested turn: chat nodes expose their
+          // source event seq (anchorSeq) and render with data-chat-anchor-key,
+          // so resolve seq -> node key -> scroll once the view materializes.
+          const seq = event.data.seq
+          if (Number.isInteger(seq)) {
+            const tryScroll = attempt => {
+              const record = liveSessions.get(event.data.sessionId)
+              if (record === undefined) {
+                if (attempt < 3) window.setTimeout(() => tryScroll(attempt + 1), 500)
+                return
+              }
+              let key = undefined
+              for (const node of record.chat.getSnapshot()?.nodes.values() ?? []) {
+                if (node.anchorSeq === seq) { key = node.key; break }
+              }
+              if (key !== undefined) {
+                const row = document.querySelector(`[data-chat-anchor-key="${CSS.escape(key)}"]`)
+                if (row instanceof HTMLElement) row.scrollIntoView({ block: 'start' })
+                return
+              }
+              // The requested turn may sit outside the loaded window; the jump
+              // loader pages history back through the seq, then the retry reads
+              // the rebuilt node set.
+              if (attempt === 0 && typeof record.session.loadThrough === 'function') {
+                void record.session.loadThrough(seq).catch(() => {})
+              }
+              if (attempt < 3) window.setTimeout(() => tryScroll(attempt + 1), 500)
+            }
+            window.setTimeout(() => tryScroll(0), 300)
+          }
           return
         }
         if (event.data.type === 'synapse:activate-session') {
           // Bidirectional current-session sync: switch DSH's current session
           // without closing the map; the sessions-list subscription re-sends
           // synapse:current-session so the map follows the new highlight.
-          try { ctx.sessions.open(event.data.sessionId) } catch { send('synapse:bridge-error', { message: '关联的 DSH 会话已不可用' }) }
+          try { ctx.uiWorkspace.openSession(event.data.sessionId) } catch { send('synapse:bridge-error', { message: NO_SESSION }) }
           return
         }
         if (event.data.type === 'synapse:fork-session') {
@@ -207,7 +323,10 @@ window.__ModuleLoader__.load({
         themeObserver?.disconnect()
         unsubscribeSessions()
         unsubscribeWorkspaces()
-        for (const unsubscribe of liveUnsubscribers.values()) unsubscribe()
+        for (const record of liveSessions.values()) detachLiveSession(record)
+        liveSessions.clear()
+        for (const reference of ownReferences.values()) reference.release()
+        ownReferences.clear()
         host.remove()
         style.remove()
       }, 'synapse: web workspace switch')

package/docs/architecture.md

@@ -28,6 +28,29 @@ DSH session logs remain the source of truth for conversation content and lifecyc
 
 Synapse projects committed DSH events into cards and sends user actions back through the native DSH session bridge.
 
+## Harness compatibility
+
+This revision is built and verified against DeepSeek Harness `0.1.7-rc.2`. Both halves call Harness APIs directly, so a Harness release that changes them requires a matching plugin release.
+
+Host half (`index.js`) calls:
+
+- `ctx.webServer.register({ kind, path, handler })`, the route registry of `@deepseek-ai/dsh-host-webserver`;
+- `ctx.sessions.list()`, the live `Session` objects of `@deepseek-ai/dsh-session`;
+- the untagged (global) `session/created` and `session/event` listeners;
+- `session.snapshotEvents()` for a projection replay, `session.inheritedEventCount` for the durable fork cut, and `session.header.cwd` for workspace grouping.
+
+Client half (`client.js`), through `dsh.client.inject` in `package.json`:
+
+- `sessions.list`, `sessions.binding`, `sessions.create`, `sessions.fork` from `@deepseek-ai/dsh-api-session-controller`, plus `sessions.retain`/`release` for two purposes: owning a reference across a prompt round-trip, and owning one for every *running* Session whose live reply the map mirrors, because no Harness release mints a Session scope implicitly any more and an unowned Session has no readable Chat view;
+- `workspaces.list` from `@deepseek-ai/dsh-api-workspace-controller`;
+- `uiWorkspace.openSession` from `@deepseek-ai/dsh-client-ui-workspace` for selecting a Session;
+- `uiConversation.binding(sessionId).target('chat')` from `@deepseek-ai/dsh-client-ui-conversation` for the streaming reply and the turn anchor index, because the Client builds a view snapshot only after something subscribes to its target. A Session the browser does not observe still reports its `running` flag, which the list row carries.
+
+Two Harness dependencies are worth re-checking on every upgrade:
+
+- `snapshotEvents()` is marked deprecated: Harness is moving complete session logs out of memory. Rebuilding this canvas from history needs the full sequence, so the call remains, and it needs a storage-backed successor (an asynchronous paged read) before Harness removes it.
+- The browser half must acquire its own `SessionReference` before sending a prompt; borrowing an Agent scope no longer opens one.
+
 ## Canvas metadata
 
 By default, Synapse stores canvas metadata at:

package/docs/development.md

@@ -5,6 +5,7 @@ This document covers local validation, package inspection, GitHub Actions, and n
 ## Requirements
 
 - Node.js `>= 22.19.0`
+- DeepSeek Harness `>= 0.1.7-rc.2` for integration runs; the test suite itself installs no Harness
 - pnpm through Corepack
 - A checkout of this repository
 

package/docs/en/README.md

@@ -6,7 +6,7 @@ The plugin does not replace DSH models, tools, sessions, permissions, or the Web
 
 ## Prerequisites
 
-- A DeepSeek Harness release with the `dsh plugin` profile mechanism (2026-08 or later).
+- DeepSeek Harness `>= 0.1.7-rc.2`; this revision targets that release's Host session and Client service interfaces.
 - Node.js `>= 22.19.0`.
 - The `web` profile; other profiles are not currently supported.
 

package/docs/zh-CN/README.md

@@ -6,7 +6,7 @@
 
 ## 前提条件
 
-- 支持 `dsh plugin` profile 插件机制的 DeepSeek Harness（2026-08 或之后版本）。
+- DeepSeek Harness `>= 0.1.7-rc.2`（本插件依赖该版本的 Host 会话与 Client 服务接口）。
 - Node.js `>= 22.19.0`。
 - 使用 `web` profile；其他 profile 暂不支持。
 

package/index.js

@@ -200,7 +200,11 @@ export class WorkspaceStore {
       if (this.state.hiddenSessionIds.includes(session.id)) return null
       const workspace = this.dshWorkspace(sessionCwd(session), workspaceTitle)
       const thread = this.dshThread(workspace, session)
-      for (const event of session.events) {
+      // `snapshotEvents()` replaces the removed `session.events` getter. It is
+      // marked deprecated because DSH is moving complete logs out of memory, but
+      // rebuilding this canvas from history needs the full sequence and the
+      // reader is the only complete-log access a plugin still has.
+      for (const event of session.snapshotEvents()) {
         if (event.seq >= replayFrom) this.projectEventInto(workspace, thread, event)
       }
       return structuredClone(thread)
@@ -380,9 +384,9 @@ export class WorkspaceStore {
         thread.title = title
         thread.dshSessionTitle = title
       }
-      // `seedLength` is DSH's durable fork cut. Keep it even after the
-      // session has been restored, when its in-process `firstLiveSeq` moves.
-      const seedLength = session.header?.seedLength
+      // `inheritedEventCount` is DSH's durable fork cut, the successor of the
+      // removed `header.seedLength`. It survives restore, unlike `firstLiveSeq`.
+      const seedLength = session.inheritedEventCount
       if (Number.isSafeInteger(seedLength) && seedLength >= 0) thread.sourceSeedLength = seedLength
       return thread
     }
@@ -395,7 +399,7 @@ export class WorkspaceStore {
       title: typeof session.title === 'string' && session.title.trim() !== '' ? session.title.slice(0, MAX_TITLE_LENGTH) : (parent === undefined ? 'DSH 会话' : `${parent.title} 分支`),
       parentId: parent?.id ?? null,
       sourceParentSessionId: parentSessionId,
-      sourceSeedLength: Number.isSafeInteger(session.header?.seedLength) && session.header.seedLength >= 0 ? session.header.seedLength : null,
+      sourceSeedLength: Number.isSafeInteger(session.inheritedEventCount) && session.inheritedEventCount >= 0 ? session.inheritedEventCount : null,
       dshSessionId: session.id,
       dshSessionTitle: typeof session.title === 'string' ? session.title.slice(0, MAX_TITLE_LENGTH) : null,
       color: TOPIC_COLORS[workspace.threads.length % TOPIC_COLORS.length],
@@ -406,6 +410,7 @@ export class WorkspaceStore {
       createdAt: now,
       updatedAt: now,
       messages: [],
+      pendingProcess: [],
     }
     workspace.threads.push(thread)
     // A child may arrive before its parent during startup replay. Repair that
@@ -439,10 +444,11 @@ export class WorkspaceStore {
       kind: projection.kind,
       sourceSeq: event.seq,
       at,
-      ...(projection.kind === 'assistant'
-        ? { turn: event.data.turn, step: event.data.step, process: [] }
+      ...(projection.kind === 'assistant' || projection.kind === 'error'
+        ? { turn: event.data?.turn, step: event.data?.step, process: [] }
         : {}),
     }
+    this.attachPendingProcess(thread, message)
     thread.messages.push(message)
     thread.updatedAt = at
     workspace.updatedAt = at
@@ -455,31 +461,31 @@ export class WorkspaceStore {
   /**
    * Fold one tool call or result into the assistant message of its own
    * turn/step, keyed by `callId`, so a tool invocation never becomes a
-   * separate canvas card. A legacy assistant message without `turn`/`step` is
-   * the fallback target; an event with no such target is dropped.
+   * separate canvas card. If a tool result arrives before its associated
+   * assistant/error message, retain it on the thread until that turn appears.
    */
   foldToolProcess(thread, event) {
     const at = new Date(event.time).toISOString()
+    const data = event.data ?? {}
     const target = [...thread.messages].reverse().find(message =>
-      message.kind === 'assistant'
-      && (message.turn === event.data.turn && message.step === event.data.step
+      (message.kind === 'assistant' || message.kind === 'error')
+      && (message.turn === data.turn && message.step === data.step
         || message.turn === undefined && message.step === undefined))
-    if (target === undefined) return
-    const process = target.process ??= []
-    const callId = String(event.type === 'tool/call' ? event.data.callId : event.data.message?.source?.callId ?? '')
+    const process = target === undefined ? (thread.pendingProcess ??= []) : (target.process ??= [])
+    const callId = String(event.type === 'tool/call' ? data.callId : data.message?.source?.callId ?? '')
     const entry = process.find(item => item.callId === callId)
     if (event.type === 'tool/call') {
       if (entry === undefined) {
-        process.push({ callId, name: event.data.name, arguments: event.data.arguments, result: null, error: null })
+        process.push({ callId, turn: data.turn, step: data.step, name: data.name, arguments: data.arguments, result: null, error: null })
       } else {
-        entry.name = event.data.name
-        entry.arguments = event.data.arguments
+        entry.name = data.name
+        entry.arguments = data.arguments
       }
     } else {
-      const outcome = contentText(event.data.message?.content)
-      const error = event.data.error === undefined ? null : `${event.data.error.name}: ${event.data.error.code}`
+      const outcome = contentText(data.message?.content)
+      const error = errorText(data.error)
       if (entry === undefined) {
-        process.push({ callId, name: '工具调用', arguments: null, result: outcome, error })
+        process.push({ callId, turn: data.turn, step: data.step, name: '工具调用', arguments: null, result: outcome, error })
       } else {
         entry.result = outcome
         entry.error = error
@@ -488,6 +494,14 @@ export class WorkspaceStore {
     thread.updatedAt = at
   }
 
+  attachPendingProcess(thread, message) {
+    if (!Array.isArray(thread.pendingProcess) || thread.pendingProcess.length === 0 || !Array.isArray(message.process)) return
+    const matching = thread.pendingProcess.filter(entry => entry.turn === message.turn && entry.step === message.step)
+    if (matching.length === 0) return
+    message.process.push(...matching.map(({ turn, step, ...entry }) => entry))
+    thread.pendingProcess = thread.pendingProcess.filter(entry => entry.turn !== message.turn || entry.step !== message.step)
+  }
+
   thread({ title, parentId, dshSessionId, dshSessionTitle, position, color, now, order }) {
     return {
       id: randomUUID(),
@@ -500,6 +514,7 @@ export class WorkspaceStore {
       createdAt: now,
       updatedAt: now,
       messages: [],
+      pendingProcess: [],
     }
   }
 
@@ -528,7 +543,7 @@ function normalizeState(value) {
         migrated = true
         const notes = Array.isArray(thread.notes) ? thread.notes : []
         const { notes: _notes, ...rest } = thread
-        return { ...rest, messages: notes }
+        return { ...rest, messages: notes, pendingProcess: [] }
       }) : [],
     }))
     state = { ...value, version: value.version, hiddenSessionIds, workspaces }
@@ -638,16 +653,32 @@ function projectableEvent(event) {
       return isRuntimeContextText(text) ? null : noteProjection('user', text)
     }
     case 'assistant/message':
-      return noteProjection('assistant', contentText(event.data.message.content))
+      return noteProjection('assistant', contentText(event.data?.message?.content))
     case 'todo/write':
-      return noteProjection('todo', event.data.todos.map(todo => `[${todo.status}] ${todo.content}`).join('\n'))
-    case 'turn/end':
-      return event.data.reason.kind === 'error' ? noteProjection('error', event.data.reason.error.message) : null
-    default:
+      return noteProjection('todo', Array.isArray(event.data?.todos) ? event.data.todos.map(todo => `[${todo.status}] ${todo.content}`).join('\n') : '')
+    case 'turn/end': {
+      const reason = event.data?.reason
+      if (reason?.kind === 'error') return noteProjection('error', errorText(reason.error) ?? '本轮执行失败')
+      if (reason?.kind === 'cancelled' || reason?.kind === 'canceled' || reason?.kind === 'aborted') return noteProjection('error', '本轮已取消')
       return null
+    }
+    default:
+      return /(?:error|failed|failure|cancel(?:led)?|abort)/i.test(event.type)
+        ? noteProjection('error', errorText(event.data?.error ?? event.data?.reason ?? event.data) ?? 'Harness 运行失败')
+        : null
   }
 }
 
+function errorText(value) {
+  if (typeof value === 'string') return value.trim() || null
+  if (value === null || value === undefined || typeof value !== 'object') return null
+  const name = typeof value.name === 'string' && value.name.trim() !== '' ? value.name.trim() : ''
+  const code = typeof value.code === 'string' && value.code.trim() !== '' ? value.code.trim() : ''
+  const message = typeof value.message === 'string' && value.message.trim() !== '' ? value.message.trim() : ''
+  if (message !== '') return [name, code].filter(Boolean).concat(message).join(': ')
+  return [name, code].filter(Boolean).join(': ') || null
+}
+
 function noteProjection(kind, text) {
   const normalized = text.trim()
   if (normalized === '') return null
@@ -679,7 +710,9 @@ function titleFromText(text) {
 }
 
 function sessionCwd(session) {
-  const cwd = session.header?.meta?.cwd ?? session.header?.cwd
+  // The Session header defines `cwd` as its only working-directory carrier; the
+  // old `header.meta.cwd` fallback never matched a real header field.
+  const cwd = session.header?.cwd
   return typeof cwd === 'string' && cwd.trim() !== '' ? cwd : '未指定工作目录'
 }
 
@@ -726,8 +759,9 @@ export function apply(ctx, config) {
   }
   const replaySession = session => {
     // Forks inherit their parent's log. The canvas already represents that
-    // history through the parent node, so only project the child's live tail.
-    const replayFrom = session.header?.parentSession === undefined ? 0 : session.firstLiveSeq
+    // history through the parent node, so only project the child's live tail:
+    // `inheritedEventCount` is 0 without a fork and the durable cut with one.
+    const replayFrom = session.inheritedEventCount ?? 0
     void store.projectSession(session, replayFrom, projectionWorkspaceTitle).catch(reportProjectionFailure)
   }
   // Buffer live events per session and flush them in one write per microtask,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-synapse",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "A visual, non-linear conversation workspace plugin for DeepSeek Harness.",
   "type": "module",
   "main": "index.js",
@@ -32,7 +32,10 @@
     "client": {
       "platform": "web",
       "inject": [
-        "@deepseek-ai/dsh-client-runtime"
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-api-workspace-controller",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-workspace"
       ],
       "immediately": false
     }