dsh-synapse 0.4.5 → 0.5.1

package/README.md

@@ -22,11 +22,24 @@
 
 ## 快速安装
 
-需要 DeepSeek Harness `>= 0.1.7-rc.2`（本插件依赖该版本的 Host 会话与 Client 服务接口）、Node.js `>= 22.19.0`，以及 `web` profile。
+需要 DeepSeek Harness `>= 0.1.7-rc.2`（本插件依赖该版本的 Host 会话与 Client 服务接口）和 Node.js `>= 22.19.0`。
 
 > **兼容性提示：** 本版本包含破坏性变更，仅支持 DeepSeek Harness `>= 0.1.7-rc.2`，不再兼容更早版本。
 
+**先确认插件要装进哪一套 profile**。DSH 按 profile 分套安装插件，桌面 App 和命令行各用一套，互不影响：
+
+| 你平时怎么用 DSH | 要装的 profile | 安装命令 |
+|---|---|---|
+| 桌面 App（DeepSeek Harness 客户端） | `desktop` | `corepack pnpm dsh plugin --profile desktop add dsh-synapse` |
+| 命令行 `dsh web` / 浏览器访问 | `web` | `corepack pnpm dsh plugin --profile web add dsh-synapse` |
+| 两种都用 | 两套各装一次 | 两条命令都执行 |
+
+- 从 App 内的插件页面安装时，App 会自动装进它自己用的那套，不用管 profile。
+- **自检口诀：装完顶部看不到「会话地图」开关，就是装到另一套去了**，换成另一条命令再装一次即可。
+- 桌面 App 装完需要**重启 App**（Host 侧插件在启动时加载）；命令行装的，重启 `dsh web` 并刷新页面。
+
 ```powershell
+# 命令行方式：装好后启动
 corepack pnpm dsh plugin --profile web add dsh-synapse
 corepack pnpm dsh web
 ```
@@ -60,9 +73,9 @@ corepack pnpm dsh web
 ## 与 DSH 的边界
 
 - DSH session log 保存真实会话内容；Synapse 只投影已提交的事件。
-- Synapse 的画布布局数据保存在 `$DSH_HOME/synapse/`，删除它不会删除 DSH 会话。
+- Synapse 只保存画布布局和每轮对话的短预览，消息正文始终从 DSH 会话记录按需读取；`$DSH_HOME/synapse/` 删除后不会丢会话，只会丢布局。
 - 插件不修改 prompt、模型请求、工具 schema、provider 路由或可复用 KV-cache 前缀。
-- 内置 patch 仅支持 DSH 的 `web` profile。
+- 内置 patch 由 profile 的 bundle 列表引入，桌面 App（`desktop`）与命令行（`web`）都适用。
 
 ## 开发
 

package/app.js

@@ -57,6 +57,10 @@ const state = {
   summaries: [], workspace: null, activeId: null, selectedCardId: null, mode: 'canvas', zoom: 1, currentDsh: null, sidebarCollapsed: false,
   dshWorkspaces: [], selectedDshWorkspaceId: null,
   historyBySession: new Map(), historyRequests: new Map(), pendingReplies: new Map(), pendingRpc: new Map(), liveReplies: new Map(),
+  // Message bodies are not part of the workspace payload; they are fetched per
+  // screenful and cached here (issue #42).
+  bodies: new Map(), bodyRequests: new Set(), bodyFailures: new Set(), bodiesLoaded: new Set(),
+  archivedSessionIds: new Set(),
   draft: null, error: '', workspaceLoad: 0, branchAnchors: new Map(savedBranchAnchors), cardPositions: new Map(savedCardPositions), collapsedCardIds: new Set(savedCollapsedCards), quickPhrases: savedQuickPhrases, quickPhraseEditorOpen: false,
   dragging: false, canvasGesture: false, canvasRefreshAfter: 0, canvasViewInitialized: false, canvasCamera: { x: 0, y: 0 }, mapCardSessionSwitches: new Set(),
   expandedMessageIds: new Set(),
@@ -299,6 +303,8 @@ async function archiveThread(thread) {
   } else {
     state.activeId = null
   }
+  // Archive in DSH as well, so both sides agree on one archive set (#21 / #19).
+  if (thread.dshSessionId !== null) post('synapse:archive-session', { sessionId: thread.dshSessionId })
   await refreshSummaries()
 }
 
@@ -392,10 +398,25 @@ async function submitDraft() {
 }
 
 function threadsById() { return new Map((state.workspace?.threads ?? []).map(thread => [thread.id, thread])) }
+
+/**
+ * A session archived in DSH must not keep drawing cards here: the canvas and
+ * the sidebar both read this filtered list (issue #21 / #19). Threads without a
+ * DSH session (canvas-only notes) are never hidden by DSH's state.
+ */
+function visibleThreads(threads) {
+  if (state.archivedSessionIds.size === 0) return threads
+  return threads.filter(thread => thread.dshSessionId === null || !state.archivedSessionIds.has(thread.dshSessionId))
+}
 function persistedMessagesFor(thread) { return state.historyBySession.get(thread.dshSessionId) ?? thread.messages ?? [] }
 
 function pendingUserIndex(messages, pending) {
-  return messages.findLastIndex(message => message.kind === 'user' && message.text === pending.text && new Date(message.at).getTime() >= pending.at - 2_000)
+  // The stored copy may be a preview, so match by full length and by the
+  // preview prefix instead of by exact text equality.
+  return messages.findLastIndex(message => message.kind === 'user'
+    && new Date(message.at).getTime() >= pending.at - 2_000
+    && (message.text === pending.text
+      || (typeof message.text === 'string' && pending.text.startsWith(message.text.replace(/…$/, '')))))
 }
 
 function settlePendingReply(thread, messages) {
@@ -411,7 +432,15 @@ function messagesFor(thread) {
   // A runtime-context snapshot is internal DSH state, never a user turn.
   // Filter here as well as during persistence so existing saved workspaces
   // immediately render one question and its answer as one card.
-  const messages = persistedMessagesFor(thread).filter(message => !(message.kind === 'user' && typeof message.text === 'string' && message.text.trimStart().startsWith('Current runtime context. This snapshot supersedes earlier runtime-context snapshots.')))
+  const stored = persistedMessagesFor(thread).filter(message => !(message.kind === 'user' && typeof message.text === 'string' && message.text.trimStart().startsWith('Current runtime context. This snapshot supersedes earlier runtime-context snapshots.')))
+  // Swap in hydrated bodies where present: the stored text is only a preview.
+  const bodies = state.bodies.get(thread.id)
+  const messages = bodies === undefined || bodies.size === 0
+    ? stored
+    : stored.map(message => {
+      const body = bodies.get(message.sourceSeq)
+      return body === undefined ? message : { ...message, text: body.text, process: Array.isArray(body.process) ? body.process : message.process, truncated: body.truncated === true, hydrated: true }
+    })
   const pending = state.pendingReplies.get(thread.dshSessionId)
   if (pending === undefined) return messages
   if (settlePendingReply(thread, messages)) {
@@ -700,6 +729,7 @@ function conversationCards(threads) {
         position,
         positionLocked,
         question: question.text,
+        questionMessage: question,
         answer,
         error,
         processCount,
@@ -1034,7 +1064,7 @@ function syncCanvasViewport() {
 }
 
 function renderCanvas() {
-  const threads = state.workspace?.threads ?? []
+  const threads = visibleThreads(state.workspace?.threads ?? [])
   if (threads.length === 0 && state.draft?.kind !== 'new') return `<section class="empty-canvas"><strong>当前工作目录还没有 DSH 对话。</strong><p>点击新会话，在画布中输入第一条消息。</p><div><button class="primary" type="button" data-action="create-session">新建会话</button></div></section>`
   const allCards = conversationCards(threads)
   const graph = conversationGraphView(allCards)
@@ -1086,16 +1116,35 @@ function threadMessage(thread, message) {
   return `<article class="message message-${message.kind}${message.pending ? ' message-pending' : ''}${collapsible ? ' message-collapsible' : ''}${expanded ? ' expanded' : ''}" data-message-seq="${Number.isInteger(message.sourceSeq) ? message.sourceSeq : ''}"><header>${avatar}<span class="message-role">${label}</span><time>${formatTime(message.at)}</time>${branch}${fold}</header><div class="message-body">${body}</div></article>`
 }
 
+/**
+ * Stored process entries carry a `status` (`pending` / `done` / `failed`);
+ * records folded in from a v3-era message still carry `error` / `result`. Read
+ * both shapes, otherwise a finished tool renders as a failure only because the
+ * newer shape has no `error` key at all (`undefined !== null`).
+ */
+function processState(entry) {
+  if (entry.status === 'failed') return 'failed'
+  if (entry.status === 'pending') return 'pending'
+  if (entry.status === 'done') return 'done'
+  if (typeof entry.error === 'string') return entry.error === '' ? (entry.result === null || entry.result === undefined ? 'pending' : 'done') : 'failed'
+  if (entry.error !== null && entry.error !== undefined) return 'failed'
+  return entry.result === null || entry.result === undefined ? 'pending' : 'done'
+}
+
 function processRecords(process, messageId) {
   const key = `${messageId}:process`
   const expanded = state.expandedMessageIds.has(key)
   const entries = process.map((entry, index) => {
     const entryKey = `${key}:${index}`
     const entryExpanded = state.expandedMessageIds.has(entryKey)
-    const status = entry.error !== null ? '失败' : entry.result === null ? '等待结果' : '完成'
-    const argumentsHtml = entry.arguments === null || entry.arguments === '' ? '' : `<pre class="process-args">${escapeHtml(entry.arguments)}</pre>`
-    const outcomeHtml = entry.error !== null ? `<pre class="process-error">${escapeHtml(entry.error)}</pre>` : entry.result === null ? '' : `<pre class="process-result">${escapeHtml(entry.result)}</pre>`
-    return `<div class="process-entry${entryExpanded ? ' expanded' : ''}"><button class="process-entry-fold" data-action="toggle-message" data-message="${escapeHtml(entryKey)}"><span class="process-entry-name">${escapeHtml(entry.name)}</span><span class="process-status${entry.error !== null ? ' process-status-error' : entry.result === null ? ' process-status-pending' : ' process-status-done'}">${status}</span></button>${entryExpanded ? `<div class="process-entry-body">${argumentsHtml}${outcomeHtml}</div>` : ''}</div>`
+    const state_ = processState(entry)
+    const status = state_ === 'failed' ? '失败' : state_ === 'pending' ? '等待结果' : '完成'
+    const statusClass = state_ === 'failed' ? ' process-status-error' : state_ === 'pending' ? ' process-status-pending' : ' process-status-done'
+    const argumentsHtml = typeof entry.arguments === 'string' && entry.arguments !== '' ? `<pre class="process-args">${escapeHtml(entry.arguments)}</pre>` : ''
+    const outcomeHtml = state_ === 'failed' && typeof entry.error === 'string' && entry.error !== ''
+      ? `<pre class="process-error">${escapeHtml(entry.error)}</pre>`
+      : typeof entry.result === 'string' && entry.result !== '' ? `<pre class="process-result">${escapeHtml(entry.result)}</pre>` : ''
+    return `<div class="process-entry${entryExpanded ? ' expanded' : ''}"><button class="process-entry-fold" data-action="toggle-message" data-message="${escapeHtml(entryKey)}"><span class="process-entry-name">${escapeHtml(entry.name)}</span><span class="process-status${statusClass}">${status}</span></button>${entryExpanded ? `<div class="process-entry-body">${argumentsHtml}${outcomeHtml}</div>` : ''}</div>`
   }).join('')
   return `<section class="process-records${expanded ? ' expanded' : ''}"><button class="process-records-fold" data-action="toggle-message" data-message="${escapeHtml(key)}"><span>${expanded ? '收起过程记录' : '过程记录'}</span><span class="process-count">${process.length}</span></button>${expanded ? entries : ''}</section>`
 }
@@ -1127,13 +1176,15 @@ function inspectorProcessEntries(messages) {
       continue
     }
     if (message.kind === 'tool') {
-      entries.push({ name: processSummary(message.text), arguments: message.text, result: null, error: null })
+      entries.push({ name: processSummary(message.text), arguments: message.text, status: 'pending' })
       continue
     }
     if (message.kind === 'tool-result') {
       const previous = entries.at(-1)
-      if (previous !== undefined && previous.result === null && previous.error === null) previous.result = message.text
-      else entries.push({ name: '工具结果', arguments: null, result: message.text, error: null })
+      if (previous !== undefined && processState(previous) === 'pending') {
+        previous.status = 'done'
+        previous.result = message.text
+      } else entries.push({ name: '工具结果', arguments: null, status: 'done', result: message.text })
     }
   }
   return entries
@@ -1194,7 +1245,7 @@ function render() {
     }
   }
   const workspace = state.workspace
-  const threads = workspace?.threads ?? []
+  const threads = visibleThreads(workspace?.threads ?? [])
   const view = state.mode === 'thread' ? renderThread() : renderCanvas()
   const choices = workspaceChoices()
   const selectedWorkspaceId = state.selectedDshWorkspaceId ?? workspace?.id
@@ -1239,6 +1290,74 @@ function render() {
       if (target instanceof HTMLElement) target.scrollIntoView({ block: 'start' })
     })
   }
+  // Card faces and the detail view only hold previews: pull the real bodies for
+  // whatever is on screen right now (issue #42).
+  void hydrateBodies()
+}
+
+/**
+ * Ask the Host for the bodies of the messages currently on screen. The
+ * workspace payload carries previews only, so each newly mounted card and each
+ * opened detail view hydrates from the DSH session log.
+ */
+async function hydrateBodies() {
+  const wanted = new Map()
+  const add = (threadId, message) => {
+    if (threadId === undefined || message === null || message === undefined) return
+    if (!Number.isInteger(message.sourceSeq)) return
+    if (state.bodies.get(threadId)?.has(message.sourceSeq) === true) return
+    const key = `${threadId}:${message.sourceSeq}`
+    if (state.bodyRequests.has(key) || state.bodyFailures.has(key)) return
+    const seqs = wanted.get(threadId) ?? new Set()
+    seqs.add(message.sourceSeq)
+    wanted.set(threadId, seqs)
+  }
+  const addCard = card => {
+    if (card === undefined) return
+    add(card.dshThreadId, card.questionMessage)
+    add(card.dshThreadId, card.answer)
+    add(card.dshThreadId, card.error)
+  }
+  if (state.mode === 'thread' && state.activeId !== null) {
+    const thread = currentThread()
+    if (thread !== null && !state.bodiesLoaded.has(thread.id)) {
+      for (const message of persistedMessagesFor(thread)) add(thread.id, message)
+    }
+  } else if (state.mode === 'canvas') {
+    for (const cardId of state.mountedCardIds) addCard(state.canvasCardsById?.get(cardId))
+  }
+  if (state.inspectorCardId !== null) addCard(state.canvasCardsById?.get(state.inspectorCardId))
+  for (const [threadId, seqs] of wanted) void fetchBodies(threadId, [...seqs])
+}
+
+async function fetchBodies(threadId, seqs) {
+  if (seqs.length === 0) return
+  const keys = seqs.map(seq => `${threadId}:${seq}`)
+  for (const key of keys) state.bodyRequests.add(key)
+  try {
+    const body = await api(`/synapse/api/threads/${threadId}/full?seqs=${seqs.join(',')}`)
+    const cached = state.bodies.get(threadId) ?? new Map()
+    for (const [seq, payload] of Object.entries(body.messages ?? {})) {
+      if (payload === null || typeof payload !== 'object') continue
+      cached.set(Number(seq), payload)
+    }
+    state.bodies.set(threadId, cached)
+    if (state.mode === 'thread' && state.activeId === threadId) state.bodiesLoaded.add(threadId)
+    if (body.unavailable === true) {
+      // Archived or already removed from DSH: keep the previews, stop asking.
+      for (const message of persistedMessagesFor(currentThread() ?? { messages: [] })) {
+        if (Number.isInteger(message.sourceSeq)) state.bodyFailures.add(`${threadId}:${message.sourceSeq}`)
+      }
+      state.bodiesLoaded.add(threadId)
+    }
+    if (state.mode === 'thread' || state.inspectorCardId !== null) render()
+    else if (canReplaceView()) render()
+    else deferCanvasRefresh(400)
+  } catch {
+    for (const key of keys) state.bodyFailures.add(key)
+  } finally {
+    for (const key of keys) state.bodyRequests.delete(key)
+  }
 }
 
 function renderPreservingDetailScroll() {
@@ -1699,6 +1818,9 @@ window.addEventListener('message', event => {
   }
   if (data.type === 'synapse:workspaces') {
     state.dshWorkspaces = Array.isArray(data.workspaces) ? data.workspaces.filter(workspace => typeof workspace?.id === 'string' && typeof workspace.title === 'string' && Array.isArray(workspace.sessionIds)) : []
+    // DSH owns the archive set; mirror it so an archived session stops drawing
+    // cards here too (issue #21 / #19).
+    state.archivedSessionIds = new Set(Array.isArray(data.archivedSessionIds) ? data.archivedSessionIds.filter(id => typeof id === 'string') : [])
     const current = currentDshWorkspace()
     if (current !== undefined && current.id !== state.selectedDshWorkspaceId) void openDshWorkspace(current.id).catch(setError)
     else if (state.selectedDshWorkspaceId !== null) void openDshWorkspace(state.selectedDshWorkspaceId).catch(setError)

package/client.js

@@ -31,6 +31,13 @@ window.__ModuleLoader__.load({
         { id: 'dsh-ungrouped', title: '未分组', path: null, sessionIds: sessions.ids.filter(id => !accounted.has(id)) },
       ]
     }
+    // DSH owns which Sessions are archived. The map mirrors that set so an
+    // archived Session stops drawing cards, and archives through the same
+    // Workspace action instead of keeping a second hidden list (#21 / #19).
+    const archivedSessionIds = ctx => {
+      const snapshot = ctx.workspaces.list.getSnapshot()
+      return Array.isArray(snapshot.archivedSessionIds) ? snapshot.archivedSessionIds.map(String) : []
+    }
 
     module.exports.inject = ['sessions', 'workspaces', 'uiWorkspace', 'uiConversation']
     module.exports.apply = ctx => {
@@ -225,7 +232,7 @@ window.__ModuleLoader__.load({
         publishLiveSessions()
         syncTheme()
         if (!overlay.hidden) {
-          send('synapse:workspaces', { workspaces: workspaceSnapshot(ctx) })
+          send('synapse:workspaces', { workspaces: workspaceSnapshot(ctx), archivedSessionIds: archivedSessionIds(ctx) })
           send('synapse:current-session', { session: currentSession(ctx) })
         }
       }
@@ -261,7 +268,7 @@ window.__ModuleLoader__.load({
         if (event.data.type === 'synapse:close') return close()
         if (event.data.type === 'synapse:map-ready') return showMapOverlay()
         if (event.data.type === 'synapse:request-current') {
-          send('synapse:workspaces', { workspaces: workspaceSnapshot(ctx) })
+          send('synapse:workspaces', { workspaces: workspaceSnapshot(ctx), archivedSessionIds: archivedSessionIds(ctx) })
           return send('synapse:current-session', { session: currentSession(ctx) })
         }
         if (event.data.type === 'synapse:open-session') {
@@ -307,6 +314,18 @@ window.__ModuleLoader__.load({
           try { ctx.uiWorkspace.openSession(event.data.sessionId) } catch { send('synapse:bridge-error', { message: NO_SESSION }) }
           return
         }
+        if (event.data.type === 'synapse:archive-session') {
+          // One archive set only: archive through the Workspace action so DSH's
+          // sidebar and this map agree, then report the refreshed set.
+          const sessionId = event.data.sessionId
+          if (typeof sessionId !== 'string' || sessionId === '') return
+          if (typeof ctx.workspaces.archiveSession !== 'function') return send('synapse:bridge-error', { message: '当前 DSH 版本不支持归档接口' })
+          Promise.resolve()
+            .then(() => ctx.workspaces.archiveSession(sessionId))
+            .then(() => send('synapse:workspaces', { workspaces: workspaceSnapshot(ctx), archivedSessionIds: archivedSessionIds(ctx) }))
+            .catch(() => send('synapse:bridge-error', { message: 'DSH 归档失败，请稍后重试' }))
+          return
+        }
         if (event.data.type === 'synapse:fork-session') {
           const atSeq = Number.isInteger(event.data.atSeq) ? event.data.atSeq : undefined
           ctx.sessions.fork({ sessionId: event.data.sessionId, atSeq, increaseTitle: true }).then(id => {

package/docs/architecture.md

@@ -4,16 +4,16 @@
 
 `dsh-synapse` is a presentation and organization layer for DeepSeek Harness conversations. It turns existing DSH sessions, turns, and forks into a visual map without replacing the systems that own those conversations.
 
-## Web profile integration
+## Profile integration
 
-The package contributes `cordis.patch.yml`, which inserts the `dsh-synapse` service into the DSH `web` profile. It reuses the existing DSH Web server and client runtime.
+The package contributes `cordis.patch.yml`, which inserts the `dsh-synapse` service into whichever DSH profile lists the package as a bundle — `desktop` for the desktop app, `web` for the `dsh web` command. It reuses the existing DSH Web server and client runtime.
 
 The plugin:
 
 - does not start a second HTTP server;
 - does not create a second model or agent runtime;
 - does not replace DSH authentication or permission checks;
-- does not support non-Web profiles unless those profiles explicitly add the plugin.
+- stays inert in a profile that does not list it, so installing it into the wrong profile only means the map never appears (see the installation table in the user guide).
 
 ## Conversation ownership
 
@@ -78,10 +78,14 @@ Each user question becomes a conversation card. The following assistant messages
 
 Only a turn a person typed becomes a card. The harness also writes its own `user/message` rows — the runtime-context snapshot, the skill catalogue `<system-reminder>` — and those carry a structured `data.source.kind`; injected kinds (`skill-catalog`, plus the runtime snapshot's text marker) are not projected, so they neither occupy a card nor steal the answer from the real question. Existing projections are pruned the same way when the store loads.
 
-Projected card text is capped at 8000 characters. Longer messages receive a truncation marker in the card, while their complete content remains available from the conversation detail view.
+Projected messages keep only a preview (280 characters), not the body. The body already lives in the DSH session log, and a workspace file full of copies is what made one workspace reach several megabytes and stall the canvas (issue #42). The canvas asks the Host for the bodies of the cards it actually mounts (`GET /synapse/api/threads/:id/full`), and the detail view asks for a whole thread at once; when a session is archived or gone from DSH the previews stay and the card is marked unavailable instead of rendering blank.
+
+Projected card text is capped at 8000 characters on the detail fetch, while the preview stays short.
 
 Projection writes are coalesced during event bursts, and live updates reuse cached Markdown and patch the active card instead of rebuilding the complete canvas. Card coordinates remain visual metadata only and never determine conversation lineage.
 
+Archiving is owned by DSH. The map mirrors `archivedSessionIds` from the Workspace snapshot to stop drawing cards for archived sessions, and its own archive action calls the Workspace `archiveSession` so both sides share one archive set (issue #21 / #19).
+
 ## Tool process folding
 
 Live events pair tool calls and results by `callId` and render them inside the related assistant reply instead of as standalone conversation cards.
@@ -115,7 +119,7 @@ As a result, the plugin has no direct model-experience effect and does not inval
 
 ## Operational limitations
 
-- Only the `web` profile is supported by the bundled patch.
+- The bundled patch applies to any profile that lists the package as a bundle (`desktop`, `web`); a profile that does not list it stays untouched.
 - Canvas metadata and session content have different owners and backup requirements.
 - A single shared metadata file is not a multi-writer database.
 - Browser state can be cleared independently from DSH Home data.

package/docs/en/README.md

@@ -8,13 +8,31 @@ The plugin does not replace DSH models, tools, sessions, permissions, or the Web
 
 - 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.
+- The right profile: the desktop app uses `desktop`, the `dsh web` command uses `web` (see below).
+
+## Which profile to install into
+
+DSH installs plugins per profile. Each profile keeps its own plugin list and `node_modules`, so the desktop app and the command line do not affect each other.
+
+| How you run DSH | Profile to use |
+|---|---|
+| Desktop app (DeepSeek Harness client) | `desktop` |
+| `dsh web` on the command line | `web` |
+| Both | Install once per profile |
+
+- Installing from the app's plugin page already targets the profile the app uses, so you do not pick one there.
+- **Quick self-check: if the "会话地图 / Session map" switch never appears, the plugin went into the other profile** — run the other command and install again.
+- A desktop install takes effect after **restarting the app**; a command-line install takes effect after restarting `dsh web` and refreshing the page.
 
 ## Installation
 
 ### Install from npm
 
 ```powershell
+# Desktop app
+corepack pnpm dsh plugin --profile desktop add dsh-synapse
+
+# Command line (dsh web)
 corepack pnpm dsh plugin --profile web add dsh-synapse
 ```
 
@@ -30,7 +48,7 @@ GitHub installs run the package `prepare` script, which validates JavaScript syn
 
 ### pnpm 10+ allowBuilds
 
-pnpm 10 and later may block build scripts for Git dependencies by default. If installation is blocked, copy the **complete key printed by pnpm** into the DSH Web profile's `pnpm-workspace.yaml`:
+pnpm 10 and later may block build scripts for Git dependencies by default. If installation is blocked, copy the **complete key printed by pnpm** into the matching profile's `pnpm-workspace.yaml`:
 
 ```yaml
 allowBuilds:
@@ -45,7 +63,7 @@ Use the complete key containing the tarball URL and commit, not the bare package
 corepack pnpm dsh plugin --profile web add link:E:\path\to\dsh-synapse
 ```
 
-The `link:` form references the local checkout directly and is recommended for development. In a normal run, restart `dsh web` and refresh the page after editing the plugin.
+The `link:` form references the local checkout directly and is recommended for development. In a normal run, restart the host (the desktop app or `dsh web`) and refresh the page after editing the plugin.
 
 ## Start DSH Web
 
@@ -150,7 +168,7 @@ Does not invalidate. The plugin never changes request headers, system prompts, o
 
 ## Known limitations
 
-- Only the `web` profile is supported.
+- Both the `desktop` (desktop app) and `web` (`dsh web`) profiles are supported; any other profile has to add the package to its own bundle list. Installing into the wrong profile does not error — the Session map switch simply never appears.
 - Two DSH Web instances sharing one profile write the same `workspaces.json`. A cross-process write lock and external-modification warnings exist, but last-writer-wins replacement remains possible; run one instance.
 - During v3 migration, legacy tool cards pair each call with the next result by order. Live events pair by `callId`.
 

package/docs/zh-CN/README.md

@@ -8,13 +8,31 @@
 
 - DeepSeek Harness `>= 0.1.7-rc.2`（本插件依赖该版本的 Host 会话与 Client 服务接口）。
 - Node.js `>= 22.19.0`。
-- 使用 `web` profile；其他 profile 暂不支持。
+- 选对 profile：桌面 App 用 `desktop`，命令行 `dsh web` 用 `web`（见下节）。
+
+## 装到哪一套 profile
+
+DSH 按 profile 分套安装插件：每套 profile 有自己的插件清单和 `node_modules`，桌面 App 和命令行各用一套，互不影响。
+
+| 你平时怎么用 DSH | 要装的 profile |
+|---|---|
+| 桌面 App（DeepSeek Harness 客户端） | `desktop` |
+| 命令行 `dsh web` / 浏览器访问 | `web` |
+| 两种都用 | 两套各装一次 |
+
+- 从 App 内的插件页面安装时，App 会自动装进它自己用的那套，无需关心 profile。
+- **自检口诀：装完顶部看不到「会话地图」开关，就是装到另一套去了**，换成另一条命令再装一次即可。
+- 桌面 App 装完需要**重启 App**；命令行装的，重启 `dsh web` 并刷新页面。
 
 ## 安装
 
 ### 从 npm 安装
 
 ```powershell
+# 桌面 App
+corepack pnpm dsh plugin --profile desktop add dsh-synapse
+
+# 命令行 dsh web
 corepack pnpm dsh plugin --profile web add dsh-synapse
 ```
 
@@ -30,7 +48,7 @@ GitHub 安装会运行本包的 `prepare` 脚本，通过 `node --check` 验证
 
 ### pnpm 10+ 的 allowBuilds
 
-pnpm 10 及之后版本默认可能阻止 Git 依赖执行构建脚本。如果安装被拦截，请将 pnpm 输出的**完整键**复制到 DSH Web profile 的 `pnpm-workspace.yaml`：
+pnpm 10 及之后版本默认可能阻止 Git 依赖执行构建脚本。如果安装被拦截，请将 pnpm 输出的**完整键**复制到对应 profile 的 `pnpm-workspace.yaml`：
 
 ```yaml
 allowBuilds:
@@ -45,7 +63,7 @@ allowBuilds:
 corepack pnpm dsh plugin --profile web add link:E:\path\to\dsh-synapse
 ```
 
-`link:` 会直接引用本地 checkout，适合开发和调试。普通运行模式下修改代码后，建议重启 `dsh web` 并刷新页面。
+`link:` 会直接引用本地 checkout，适合开发和调试。普通运行模式下修改代码后，建议重启宿主（桌面 App 或 `dsh web`）并刷新页面。
 
 ## 启动
 
@@ -143,7 +161,7 @@ $DSH_HOME/synapse/
 
 ## 已知限制
 
-- 仅支持 `web` profile。
+- 支持 `desktop`（桌面 App）与 `web`（命令行 `dsh web`）两套 profile；其他自定义 profile 需要自己把插件加入 bundle 列表。装错 profile 时插件不会报错，只是顶部不会出现「会话地图」。
 - 两个 DSH Web 实例共享同一个 profile 时会写入同一个 `workspaces.json`。虽然存在跨进程写锁和外部修改警告，仍可能出现最后写入覆盖，请只运行一个实例。
 - v3 数据迁移时，旧工具卡片按顺序将每次调用与下一条结果配对；实时事件使用 `callId`。
 

package/index.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises'
+import { copyFile, mkdir, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises'
 import { randomUUID } from 'node:crypto'
 import { dirname } from 'node:path'
 
@@ -10,8 +10,16 @@ const MAX_TITLE_LENGTH = 120
 const MAX_NOTE_LENGTH = 4_000
 // Projected message text cap: longer replies truncate with a marker pointing
 // at the detail view instead of silently cutting mid-sentence.
-const MAX_PROJECTION_LENGTH = 8_000
+// Projected messages keep only a short preview: the body already lives in the
+// DSH session log, and a canvas full of copies is what made one workspace file
+// grow to megabytes (issue #42). Bodies are streamed back on demand by
+// `/synapse/api/threads/:id/full`.
+const EXCERPT_CHARS = 280
+// On-demand bodies are capped so a single enormous tool result cannot stall the
+// browser while its card is rendered.
+const MAX_BODY_CHARS = 200_000
 const PROJECTION_TRUNCATED_SUFFIX = '\n——…（详情查看全文）'
+const BODY_TRUNCATED_SUFFIX = '\n——…（正文过长，其余请在 DSH 中查看）'
 const TOPIC_COLORS = ['#0f766e', '#2563eb', '#be123c', '#7c3aed', '#b45309']
 // The harness writes `user/message` rows of its own (runtime snapshots, skill
 // catalogues). A canvas card must stand for a turn a person actually typed, so
@@ -55,6 +63,20 @@ export class WorkspaceStore {
     return structuredClone(workspace)
   }
 
+  /**
+   * Read-only lookup used by on-demand body loading: returns the live thread
+   * (no clone) together with its workspace, or null when the id is unknown.
+   */
+  async locateThread(threadId) {
+    await this.ready
+    for (const workspace of this.state.workspaces) {
+      for (const thread of workspace.threads ?? []) {
+        if (thread.id === threadId) return { workspace, thread }
+      }
+    }
+    return null
+  }
+
   async create(title) {
     return this.mutate(() => {
       const now = new Date().toISOString()
@@ -250,10 +272,15 @@ export class WorkspaceStore {
       const parsed = JSON.parse(await readFile(this.dataFile, 'utf8'))
       const { state, migrated } = normalizeState(parsed)
       this.state = state
-      if (migrated) await this.save()
+      if (migrated) {
+        // Dropping stored bodies is the one migration that cannot be undone by
+        // re-projection alone, so keep the pre-v5 file next to the new one.
+        if (Number(parsed?.version) < 5) await copyFile(this.dataFile, `${this.dataFile}.v4-backup`).catch(() => {})
+        await this.save()
+      }
     } catch (error) {
       if (error?.code !== 'ENOENT') throw new Error(`synapse: cannot read ${this.dataFile}: ${error.message}`)
-      this.state = { version: 4, hiddenSessionIds: [], workspaces: [] }
+      this.state = { version: 5, hiddenSessionIds: [], workspaces: [] }
       await this.save()
     }
   }
@@ -451,6 +478,8 @@ export class WorkspaceStore {
     const message = {
       id: randomUUID(),
       text: projection.text,
+      length: projection.length,
+      truncated: projection.truncated,
       kind: projection.kind,
       sourceSeq: event.seq,
       at,
@@ -484,21 +513,21 @@ export class WorkspaceStore {
     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)
+    // Process records keep only identity and status: tool arguments and results
+    // are the bulk of the old file (issue #42) and are reloaded on demand.
     if (event.type === 'tool/call') {
       if (entry === undefined) {
-        process.push({ callId, turn: data.turn, step: data.step, name: data.name, arguments: data.arguments, result: null, error: null })
+        process.push({ callId, turn: data.turn, step: data.step, name: data.name, status: 'pending' })
       } else {
         entry.name = data.name
-        entry.arguments = data.arguments
       }
     } else {
-      const outcome = contentText(data.message?.content)
-      const error = errorText(data.error)
+      const failed = errorText(data.error) !== null
       if (entry === undefined) {
-        process.push({ callId, turn: data.turn, step: data.step, name: '工具调用', arguments: null, result: outcome, error })
+        process.push({ callId, turn: data.turn, step: data.step, name: '工具调用', status: failed ? 'failed' : 'done' })
       } else {
-        entry.result = outcome
-        entry.error = error
+        entry.status = failed ? 'failed' : 'done'
+        if (typeof entry.name !== 'string' || entry.name === '') entry.name = '工具调用'
       }
     }
     thread.updatedAt = at
@@ -539,7 +568,7 @@ class NotFoundError extends Error {}
 function normalizeState(value) {
   let migrated = false
   let state
-  if ((value?.version === 2 || value?.version === 3 || value?.version === 4) && Array.isArray(value.workspaces)) {
+  if ((value?.version === 2 || value?.version === 3 || value?.version === 4 || value?.version === 5) && Array.isArray(value.workspaces)) {
     const hiddenSessionIds = Array.isArray(value.hiddenSessionIds) ? value.hiddenSessionIds.filter(item => typeof item === 'string') : []
     migrated = value.version < 3 || !Array.isArray(value.hiddenSessionIds)
     const workspaces = value.workspaces.map(workspace => ({
@@ -580,16 +609,54 @@ function normalizeState(value) {
     }
     migrated = true
   } else {
-    throw new Error('expected Synapse data version 1, 2, 3, or 4')
+    throw new Error('expected Synapse data version 1, 2, 3, 4, or 5')
   }
-  if (state.version !== 4) {
+  if (state.version < 4) {
     if (foldLegacyToolCards(state.workspaces)) migrated = true
     state.version = 4
     migrated = true
   }
+  // v5 drops message bodies and tool payloads from the workspace file: they are
+  // re-read from the DSH session log on demand. Existing bodies become previews.
+  if (state.version < 5) {
+    for (const workspace of state.workspaces) {
+      for (const thread of workspace.threads ?? []) {
+        if (Array.isArray(thread.messages)) thread.messages = thread.messages.map(toStoredMessage)
+        if (Array.isArray(thread.pendingProcess)) thread.pendingProcess = thread.pendingProcess.map(toStoredProcess)
+      }
+    }
+    state.version = 5
+    migrated = true
+  }
   return { state, migrated }
 }
 
+/** v4 message → v5 message: keep identity and a preview, drop the body. */
+function toStoredMessage(message) {
+  const normalized = typeof message?.text === 'string' ? message.text.trim() : ''
+  const text = normalized === '' ? '' : excerptOf(normalized)
+  const process = Array.isArray(message?.process) ? message.process.map(toStoredProcess) : message?.process
+  return {
+    ...message,
+    text,
+    length: normalized.length,
+    truncated: text.length < normalized.length,
+    ...(process === undefined ? {} : { process }),
+  }
+}
+
+/** v4 process record → v5 record: keep identity and status, drop the payload. */
+function toStoredProcess(entry) {
+  if (entry === null || typeof entry !== 'object') return entry
+  const { arguments: _arguments, result, error, ...rest } = entry
+  const status = error !== null && error !== undefined && error !== ''
+    ? 'failed'
+    : result === null || result === undefined
+      ? 'pending'
+      : 'done'
+  return { ...rest, status: typeof entry.status === 'string' ? entry.status : status }
+}
+
 /**
  * Fold v3-era standalone tool cards (kinds `tool` / `tool-result`) into the
  * preceding assistant message's `process` list, pairing each call with the
@@ -656,30 +723,88 @@ function requiredText(value, maxLength, field) {
   return text
 }
 
-function projectableEvent(event) {
-  switch (event.type) {
-    case 'user/message': {
-      if (isInjectedUserSource(event.data?.source)) return null
-      const text = contentText(event.data.content)
-      return isRuntimeContextText(text) ? null : noteProjection('user', text)
-    }
-    case 'assistant/message':
-      return noteProjection('assistant', contentText(event.data?.message?.content))
-    case 'todo/write':
-      return noteProjection('todo', Array.isArray(event.data?.todos) ? event.data.todos.map(todo => `[${todo.status}] ${todo.content}`).join('\n') : '')
+/** Event → canvas message kind, or null when the event is not a message. */
+function eventKind(event) {
+  switch (event?.type) {
+    case 'user/message': return 'user'
+    case 'assistant/message': return 'assistant'
+    case 'todo/write': return 'todo'
     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', '本轮已取消')
+      if (reason?.kind === 'error') return 'error'
+      if (reason?.kind === 'cancelled' || reason?.kind === 'canceled' || reason?.kind === 'aborted') return '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
+      return /(?:error|failed|failure|cancel(?:led)?|abort)/i.test(event?.type ?? '') ? 'error' : null
   }
 }
 
+/**
+ * Full body of one event. Shared by the projection (which stores a preview) and
+ * the on-demand loader (which returns the whole text), so both read the same
+ * fields instead of keeping two parsers in step.
+ */
+function eventBody(event) {
+  switch (event?.type) {
+    case 'user/message': return contentText(event.data?.content)
+    case 'assistant/message': return contentText(event.data?.message?.content)
+    case 'todo/write': return 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 errorText(reason.error) ?? '本轮执行失败'
+      return '本轮已取消'
+    }
+    default:
+      return eventKind(event) === 'error' ? errorText(event.data?.error ?? event.data?.reason ?? event.data) ?? 'Harness 运行失败' : ''
+  }
+}
+
+function projectableEvent(event) {
+  const kind = eventKind(event)
+  if (kind === null) return null
+  const text = eventBody(event)
+  if (kind === 'user' && (isInjectedUserSource(event.data?.source) || isRuntimeContextText(text))) return null
+  return noteProjection(kind, text)
+}
+
+/**
+ * Full bodies for the requested stored messages, assembled from one session's
+ * event log. Exported so the on-demand loader is testable without a Host.
+ * `seqs === null` returns every projected message of the thread.
+ */
+export function bodiesFromEvents(thread, events, seqs) {
+  const wanted = seqs === null ? null : new Set(seqs)
+  const messages = {}
+  const eventsBySeq = new Map(events.map(event => [event?.seq, event]))
+  const calls = new Map()
+  for (const event of events) {
+    if (event?.type !== 'tool/call' && event?.type !== 'tool/result') continue
+    const callId = String(event.type === 'tool/call' ? event.data?.callId : event.data?.message?.source?.callId ?? '')
+    if (callId === '') continue
+    const record = calls.get(callId) ?? {}
+    if (event.type === 'tool/call') {
+      record.arguments = typeof event.data?.arguments === 'string' ? event.data.arguments : null
+    } else {
+      record.result = contentText(event.data?.message?.content) || null
+      record.error = errorText(event.data?.error)
+    }
+    calls.set(callId, record)
+  }
+  for (const message of thread.messages ?? []) {
+    if (wanted !== null && !wanted.has(message.sourceSeq)) continue
+    const event = eventsBySeq.get(message.sourceSeq)
+    if (event === undefined) continue
+    const body = eventBody(event).trim()
+    const capped = body.length > MAX_BODY_CHARS ? `${body.slice(0, MAX_BODY_CHARS)}${BODY_TRUNCATED_SUFFIX}` : body
+    const process = Array.isArray(message.process)
+      ? message.process.map(entry => ({ ...entry, ...(calls.get(String(entry.callId)) ?? {}) }))
+      : []
+    messages[String(message.sourceSeq)] = { text: capped, truncated: capped.length < body.length, process }
+  }
+  return messages
+}
+
 function errorText(value) {
   if (typeof value === 'string') return value.trim() || null
   if (value === null || value === undefined || typeof value !== 'object') return null
@@ -693,8 +818,14 @@ function errorText(value) {
 function noteProjection(kind, text) {
   const normalized = text.trim()
   if (normalized === '') return null
-  if (normalized.length <= MAX_PROJECTION_LENGTH) return { kind, text: normalized }
-  return { kind, text: `${normalized.slice(0, MAX_PROJECTION_LENGTH)}${PROJECTION_TRUNCATED_SUFFIX}` }
+  const excerpt = excerptOf(normalized)
+  return { kind, text: excerpt, length: normalized.length, truncated: excerpt.length < normalized.length }
+}
+
+/** Short preview kept in the workspace file, with an ellipsis when cut. */
+function excerptOf(text) {
+  if (text.length <= EXCERPT_CHARS) return text
+  return `${text.slice(0, EXCERPT_CHARS).trimEnd()}…`
 }
 
 function isRuntimeContextText(text) {
@@ -825,6 +956,27 @@ export function apply(ctx, config) {
     ctx.on('session/event', enqueueProjection)
     for (const session of ctx.sessions.list()) replaySession(session)
   }
+  // Bodies live in the session log, not in the workspace file (issue #42). The
+  // canvas pulls them for the cards it actually renders; the detail view pulls a
+  // whole thread at once. An archived or already-removed session cannot be
+  // re-read, so the caller is told instead of receiving silently empty text.
+  const threadBodies = async (threadId, seqs) => {
+    const located = await store.locateThread(threadId)
+    if (located === null) throw new NotFoundError('会话不存在')
+    const { thread } = located
+    const wanted = seqs === null ? null : new Set(seqs)
+    if (thread.dshSessionId === null) {
+      const messages = {}
+      for (const message of thread.messages ?? []) {
+        if (wanted !== null && !wanted.has(message.sourceSeq)) continue
+        messages[String(message.sourceSeq)] = { text: message.text, truncated: message.truncated === true, process: message.process ?? [], local: true }
+      }
+      return { messages }
+    }
+    const session = ctx.sessions.list().find(candidate => candidate.id === thread.dshSessionId)
+    if (session === undefined) return { messages: {}, unavailable: true }
+    return { messages: bodiesFromEvents(thread, session.snapshotEvents(), seqs) }
+  }
   // The DSH /api browser-trust fence does not cover /synapse routes, so this
   // handler checks the Host header itself: localhost is allowed by default and
   // additional authorities opt in through config.trustedHosts (mirrors the
@@ -850,6 +1002,14 @@ export function apply(ctx, config) {
       if (path === '/synapse/api/sessions/sync' && req.method === 'POST') { const body = await readJson(req); return sendJson(res, 200, { workspaces: await store.syncSessions(body.sessions, body.removedSessionIds) }) }
       const messages = /^\/synapse\/api\/threads\/([0-9a-f-]+)\/messages$/i.exec(path)
       if (messages !== null && req.method === 'POST') return sendJson(res, 201, { thread: await store.addMessage(messages[1], (await readJson(req)).text) })
+      const full = /^\/synapse\/api\/threads\/([0-9a-f-]+)\/full$/i.exec(path)
+      if (full !== null && req.method === 'GET') {
+        const raw = new URL(req.url ?? '/', 'http://dsh.local').searchParams.get('seqs')
+        const seqs = raw === null || raw.trim() === ''
+          ? null
+          : raw.split(',').map(value => Number.parseInt(value, 10)).filter(value => Number.isInteger(value) && value >= 0)
+        return sendJson(res, 200, await threadBodies(full[1], seqs))
+      }
       const thread = /^\/synapse\/api\/threads\/([0-9a-f-]+)$/i.exec(path)
       if (thread !== null && req.method === 'PATCH') return sendJson(res, 200, { thread: await store.updateThread(thread[1], await readJson(req)) })
       if (thread !== null && req.method === 'DELETE') return sendJson(res, 200, await store.removeThread(thread[1]))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-synapse",
-  "version": "0.4.5",
+  "version": "0.5.1",
   "description": "A visual, non-linear conversation workspace plugin for DeepSeek Harness.",
   "type": "module",
   "main": "index.js",