dsh-memory-cloud 1.0.1 → 1.1.0

package/README.md

@@ -15,8 +15,8 @@ DSH 没有独立的记忆库：每一条持久记忆都是 `$DSH_HOME/sessions`
   - **星云**（默认）：不规则絮状气体云（无球核、无硬边界，参考 NASA 星系云团），团间用细电弧连接；电流靠**沿线明暗渐变**表现传递，暗区纯黑、余晖自然衰减。
   - **神经元**：细胞体 + 递归分叉的树状树突 + 突触终扣 + 弯曲轴突，共用同一套信号波与流速。
 - **规模映射真实数据**：云团凝聚核数、光斑数、纤维/尘埃密度、记忆星数量、树突主干数与分叉深度，全部按该会话的实际碎片数/事件数归一化缩放。
-- **分级细节（LOD）**：缩放即钻取，每放大一级就多露出一层记忆——
-  | 等级 | 徽章 | 触发缩放 | 显示内容 |
+- **实时记忆流**：插件订阅 Host 的 `session/event`（提交后追加流），通过 SSE 把"记忆正在写入 / 正在被读取"推到页面。右下角 HUD 显示写入/读取计数、事件速率与滚动活动流；画布上同步出现**写入涟漪向外扩散、读取涟漪向内收拢**、新生记忆星，以及被激活星云团持续数秒的热晕。对话开始时若该会话还没落盘，会先长出一个**临时星云团**，落盘后自动并入正式数据。工具调用类噪声事件按 600ms 合并，避免刷屏。
+- **分级细节（LOD）**：缩放即钻取，每放大一级就多露出一层记忆——  | 等级 | 徽章 | 触发缩放 | 显示内容 |
   |---|---|---|---|
   | 0 | 全景 | < 1.5× | 云团 + 会话标题 |
   | 1 | 星团 | ≥ 1.5× | 标题 + 记忆条数/对话数/工具数 |
@@ -106,6 +106,14 @@ trustedHosts: []        # 额外允许访问插件路由的 Host
 { "id", "title", "workspaceLabel", "createdAt", "updatedAt", "counts", "fragments": [{ "kind", "text", "truncated", "time", "seq" }] }
 ```
 
+`GET /memory-cloud/api/live` —— **SSE 实时记忆活动流**（`text/event-stream`，15 秒心跳，连接建立时回放最近 24 条）：
+
+```json
+{ "seq", "sessionId", "sessionTitle", "kind": "write" | "read", "type", "text", "tool", "time" }
+```
+
+`kind` 语义：`write` = 一条记忆刚被提交写入会话日志（用户消息、助手消息、会话标题）；`read` = 一条记忆正被读取/引用（工具调用与结果、上下文注入、压缩整理、轮次结束）。
+
 插件对会话日志与 profile **只读**，不写入任何状态；唯一的持久化是浏览器 `localStorage` 里的皮肤选择。
 
 ## 许可

package/index.js

@@ -17,6 +17,133 @@ import { zstdDecompressSync } from 'node:zlib'
 
 export const inject = ['webServer']
 
+// Events that constitute a memory access. `session/event` is the post-commit
+// append feed, so every item we forward is already durable in the session log.
+// "write" = a memory being stored; "read" = a memory being consulted.
+const LIVE_EVENT_KINDS = new Map([
+  ['user/message', 'write'],
+  ['assistant/message', 'write'],
+  ['session/title', 'write'],
+  ['agent/inbox/spliced', 'read'],
+  ['request/context', 'read'],
+  ['tool/call', 'read'],
+  ['tool/result', 'read'],
+  ['compaction/summary', 'read'],
+  ['turn/end', 'read'],
+])
+
+/**
+ * Broadcast hub for live memory activity. One SSE connection per open nebula
+ * page; the registration is an effect so plugin unload tears every socket,
+ * listener and timer down cleanly.
+ */
+class LiveHub {
+  constructor() {
+    this.clients = new Set()
+    this.recent = []        // replay buffer so a fresh page sees the last burst
+    this.seq = 0
+    this.heartbeat = null
+    this.lastSent = new Map() // "session:kind:type:tool" -> timestamp
+  }
+
+  add(res) {
+    const client = { res, alive: true }
+    this.clients.add(client)
+    if (this.clients.size === 1) {
+      this.heartbeat = setInterval(() => {
+        for (const c of this.clients) if (c.alive) c.res.write(': ping\n\n')
+      }, 15000)
+    }
+    // Initial handshake + replay of the last few events.
+    res.write(`event: hello\ndata: ${JSON.stringify({ clients: this.clients.size })}\n\n`)
+    for (const item of this.recent) res.write(`data: ${JSON.stringify(item)}\n\n`)
+    const close = () => this.remove(client)
+    res.on('close', close)
+    res.on('error', close)
+    return () => this.remove(client)
+  }
+
+  remove(client) {
+    client.alive = false
+    this.clients.delete(client)
+    if (this.clients.size === 0 && this.heartbeat !== null) {
+      clearInterval(this.heartbeat)
+      this.heartbeat = null
+    }
+  }
+
+  publish(item) {
+    // A single agent step can emit dozens of tool/call + tool/result rows.
+    // Coalesce identical chatter inside a short window so the feed shows the
+    // shape of activity rather than drowning in duplicates.
+    const key = `${item.sessionId}:${item.kind}:${item.type}:${item.tool || ''}`
+    const now = Date.now()
+    const noisy = item.type === 'tool/call' || item.type === 'tool/result'
+    if (noisy) {
+      const last = this.lastSent.get(key) || 0
+      if (now - last < 600) return
+      this.lastSent.set(key, now)
+      if (this.lastSent.size > 200) this.lastSent.clear()
+    }
+    item.seq = ++this.seq
+    this.recent.push(item)
+    if (this.recent.length > 24) this.recent.shift()
+    const line = `data: ${JSON.stringify(item)}\n\n`
+    for (const c of this.clients) {
+      if (!c.alive) continue
+      try { c.res.write(line) } catch { this.remove(c) }
+    }
+  }
+
+  dispose() {
+    if (this.heartbeat !== null) clearInterval(this.heartbeat)
+    this.heartbeat = null
+    for (const c of this.clients) {
+      c.alive = false
+      try { c.res.end() } catch { /* already gone */ }
+    }
+    this.clients.clear()
+  }
+}
+
+/** Fold one raw committed session event into a compact live activity item. */
+function liveItemFromEvent(session, event) {
+  const kind = LIVE_EVENT_KINDS.get(event?.type)
+  if (kind === undefined) return null
+  const data = event.data || {}
+  const sessionId = typeof session?.id === 'string' ? session.id : ''
+  if (sessionId === '') return null
+  const text = livePreview(event, data)
+  const title = typeof session?.title === 'string' ? session.title : ''
+  return {
+    sessionId,
+    sessionTitle: title,
+    kind,
+    type: event.type,
+    text,
+    tool: typeof data.name === 'string' ? data.name : undefined,
+    time: typeof event.time === 'number' ? event.time : Date.now(),
+  }
+}
+
+function livePreview(event, data) {
+  let content
+  switch (event.type) {
+    case 'user/message': content = data.content; break
+    case 'assistant/message': content = data.message?.content; break
+    case 'tool/call': return typeof data.name === 'string' ? `调用 ${data.name}` : ''
+    case 'tool/result': return '工具返回'
+    case 'turn/end': return '一轮对话完成'
+    case 'compaction/summary': return '上下文压缩 / 记忆整理'
+    case 'request/context': return '读取运行时上下文'
+    default: content = null
+  }
+  if (content == null) return event.type === 'session/title' && typeof data.title === 'string' ? data.title : ''
+  const s = contentText(content)
+  if (s.startsWith(RUNTIME_CONTEXT_PREFIX)) return ''   // injected scaffolding
+  return s.replace(/\s+/g, ' ').slice(0, 90)
+}
+
 const ZSTD_MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd])
 const LOG_PATTERN = /^session(?:\.[\w-]+)*\.jsonl\.zstd$/
 const RUNTIME_CONTEXT_PREFIX = 'Current runtime context. This snapshot supersedes earlier runtime-context snapshots.'
@@ -564,6 +691,26 @@ export function apply(ctx, config) {
     ? config.sessionsDir
     : (process.env.DSH_HOME ? join(process.env.DSH_HOME, 'sessions') : '')
   const reader = new MemoryReader(sessionsDir, limits)
+  const live = new LiveHub()
+  // Title is not on the Session object for every event; keep a small map so the
+  // HUD can label the cluster being written to.
+  const liveTitles = new Map()
+  ctx.on('session/event', (session, event) => {
+    try {
+      if (event?.type === 'session/title' && typeof event.data?.title === 'string') {
+        liveTitles.set(session.id, event.data.title)
+      }
+      const item = liveItemFromEvent(session, event)
+      if (item === null) return
+      if (!item.sessionTitle) item.sessionTitle = liveTitles.get(item.sessionId) || ''
+      // Ignore empty scaffolding previews (runtime context, empty assistant).
+      if (item.type !== 'tool/call' && item.type !== 'tool/result' && item.text === '') return
+      live.publish(item)
+    } catch (error) {
+      ctx.logger.warn(error instanceof Error ? error : new Error(String(error)))
+    }
+  })
+  ctx.effect(() => () => live.dispose(), 'memory-cloud: live hub')
 
   // The DSH /api browser-trust fence does not cover these routes, so the
   // handler checks the Host header itself (DNS-rebinding defense), mirroring
@@ -587,6 +734,19 @@ export function apply(ctx, config) {
       if (req.method !== 'GET' && req.method !== 'HEAD') return sendJson(res, 405, { error: 'Method not allowed' })
       const path = new URL(req.url ?? '/', 'http://dsh.local').pathname
 
+      if (path === '/memory-cloud/api/live') {
+        res.writeHead(200, {
+          'content-type': 'text/event-stream; charset=utf-8',
+          'cache-control': 'no-cache, no-store',
+          connection: 'keep-alive',
+          'x-accel-buffering': 'no',
+        })
+        res.write(': connected\n\n')
+        const release = live.add(res)
+        req.on('close', release)
+        req.on('error', release)
+        return
+      }
       if (path === '/memory-cloud/api/memories') {
         const data = await reader.snapshot()
         return sendJson(res, 200, data)

package/nebula.css

@@ -132,6 +132,73 @@ body {
 .legend-item .count { margin-left: auto; color: var(--mc-muted); opacity: .8; font-variant-numeric: tabular-nums; }
 .legend-item.dim { opacity: .38; }
 
+/* ---------------------------------------------------------------------------
+   Live memory activity panel
+   --------------------------------------------------------------------------- */
+.live-panel {
+  position: fixed; z-index: 6; right: calc(20px + var(--mc-safe-r));
+  bottom: calc(76px + var(--mc-safe-b)); width: 248px;
+  background: var(--mc-panel); border: 1px solid var(--mc-line); border-radius: 11px;
+  backdrop-filter: blur(14px); box-shadow: 0 10px 32px rgba(0,0,0,.38);
+  overflow: hidden;
+}
+.live-head {
+  display: flex; align-items: center; gap: 8px; padding: 9px 11px;
+  border-bottom: 1px solid var(--mc-line);
+}
+.live-dot {
+  width: 8px; height: 8px; border-radius: 50%; flex: 0 0 auto;
+  background: #6fe0b0; box-shadow: 0 0 9px #6fe0b0;
+  animation: livePulse 2s ease-in-out infinite;
+}
+.live-panel[data-connected="false"] .live-dot { background: #d8a25a; box-shadow: 0 0 9px #d8a25a; animation: none; }
+.live-panel[data-active="true"] .live-dot { animation-duration: .55s; }
+@keyframes livePulse { 0%,100% { opacity: .45; transform: scale(.82) } 50% { opacity: 1; transform: scale(1.15) } }
+.live-title { font-size: 11.5px; font-weight: 650; color: var(--mc-fg); letter-spacing: .4px; }
+.live-toggle {
+  margin-left: auto; width: 20px; height: 20px; border: 1px solid var(--mc-line);
+  border-radius: 5px; background: transparent; color: var(--mc-muted); cursor: pointer;
+  font-size: 13px; line-height: 1;
+}
+.live-toggle:hover { color: var(--mc-fg); }
+.live-panel.collapsed #live-body { display: none; }
+.live-metrics {
+  display: flex; gap: 10px; flex-wrap: wrap; padding: 8px 11px 5px;
+  font-size: 10px; color: var(--mc-muted);
+}
+.live-metrics b { color: var(--mc-fg); font-size: 12px; font-variant-numeric: tabular-nums; }
+.live-metrics .live-rate { margin-left: auto; }
+.live-feed { max-height: 148px; overflow-y: auto; padding: 2px 11px 9px; scrollbar-width: none; }
+.live-feed::-webkit-scrollbar { display: none; }
+.live-row {
+  display: flex; align-items: baseline; gap: 7px; padding: 4px 0;
+  border-bottom: 1px solid rgba(150,170,255,.07); font-size: 10.5px; line-height: 1.45;
+  animation: liveIn .35s ease-out both;
+}
+.live-row:last-child { border-bottom: 0; }
+@keyframes liveIn { from { opacity: 0; transform: translateY(-5px) } to { opacity: 1; transform: none } }
+.live-tag { flex: 0 0 auto; font-size: 9px; font-weight: 700; letter-spacing: .3px; padding: 1px 5px; border-radius: 4px; }
+.live-row.write .live-tag { color: #9fe0ff; background: rgba(90,170,255,.18); }
+.live-row.write { border-left: 2px solid #6fc8ff; padding-left: 6px; }
+.live-row.write .live-text { color: #cfe4ff; }
+.live-row.read .live-tag { color: #e0c59a; background: rgba(220,180,100,.16); }
+.live-text { color: var(--mc-muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.live-text b { color: var(--mc-fg); font-weight: 550; }
+.live-empty { padding: 8px 0; font-size: 10.5px; color: var(--mc-muted); opacity: .7; }
+
+@media (max-width: 820px) {
+  .live-panel {
+    right: auto; left: calc(12px + var(--mc-safe-l));
+    bottom: calc(70px + var(--mc-safe-b)); width: min(220px, 58vw);
+  }
+  .live-feed { max-height: 88px; }
+}
+@media (max-width: 420px) {
+  .live-panel { width: min(190px, 54vw); }
+  .live-metrics { gap: 7px; font-size: 9px; }
+  .live-feed { max-height: 70px; }
+}
+
 .stats {
   position: fixed; left: calc(20px + var(--mc-safe-l)); bottom: calc(20px + var(--mc-safe-b)); z-index: 4;
   display: flex; flex-wrap: wrap; gap: 8px 18px; max-width: 62vw;

package/nebula.html

@@ -41,6 +41,22 @@
 
   <div id="relation-key" class="relation-key" aria-label="关联图例"></div>
 
+  <section id="live-panel" class="live-panel" aria-label="实时记忆活动">
+    <header class="live-head">
+      <span class="live-dot" aria-hidden="true"></span>
+      <span class="live-title">实时记忆流</span>
+      <button id="live-toggle" class="live-toggle" type="button" aria-pressed="true" title="收起/展开">−</button>
+    </header>
+    <div id="live-body">
+      <div class="live-metrics">
+        <span><b id="live-writes">0</b> 写入</span>
+        <span><b id="live-reads">0</b> 读取</span>
+        <span class="live-rate"><b id="live-rate">0</b> 事件/分</span>
+      </div>
+      <div id="live-feed" class="live-feed" aria-live="polite"></div>
+    </div>
+  </section>
+
   <div id="stats" class="stats" aria-label="统计信息"></div>
 
   <div id="tooltip" class="tooltip" hidden></div>

package/nebula.js

@@ -16,6 +16,12 @@
     legend: document.getElementById('legend'),
     relationKey: document.getElementById('relation-key'),
     stats: document.getElementById('stats'),
+    livePanel: document.getElementById('live-panel'),
+    liveFeed: document.getElementById('live-feed'),
+    liveWrites: document.getElementById('live-writes'),
+    liveReads: document.getElementById('live-reads'),
+    liveRate: document.getElementById('live-rate'),
+    liveToggle: document.getElementById('live-toggle'),
     skinButtons: [...document.querySelectorAll('.skin-btn')],
     tooltip: document.getElementById('tooltip'),
     detail: document.getElementById('detail'),
@@ -386,6 +392,17 @@
     w: 0, h: 0, dpr: 1,
     time: 0,
     quality: 1,      // 1 = full crest sampling; 0.5 under sustained load
+    // --- live memory activity ---
+    live: {
+      connected: false,
+      writes: 0,
+      reads: 0,
+      pulses: [],     // expanding rings on the target cloud
+      newborns: [],   // fresh stars that fade into the cloud
+      times: [],      // timestamps for the events/minute readout
+      lastBurst: 0,
+      liveClusters: new Map(), // sessions not on disk yet -> ephemeral nebula
+    },
     isMobile: false,
     // Two-finger pinch state, kept separate from the single-finger drag.
     pinch: null,      // { startDist, startZoom }
@@ -531,6 +548,223 @@
       : `${data.stats.sessions} 个会话记忆 · ${data.stats.fragments} 颗记忆星 · 拖拽以探索`
     if (state.isMobile) el.search.placeholder = '搜索记忆'
     updateHint()
+    connectLive()
+  }
+
+  // -------------------------------------------------------------------------
+  // Live memory activity
+  //
+  // `session/event` is the post-commit append feed, so each SSE item is a
+  // memory that was JUST written (or a memory being read back as context).
+  // A brand-new session has no cluster on disk yet, so we grow a small
+  // ephemeral cloud for it and retire it once the log appears on the next
+  // snapshot. This makes an active conversation visibly bloom.
+  // -------------------------------------------------------------------------
+
+  function escapeLive(s) {
+    return String(s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
+  }
+
+  function connectLive() {
+    if (typeof EventSource === 'undefined') return
+    let source
+    try { source = new EventSource('/memory-cloud/api/live') } catch { return }
+    source.onopen = () => {
+      state.live.connected = true
+      el.livePanel.dataset.connected = 'true'
+    }
+    source.onerror = () => {
+      state.live.connected = false
+      el.livePanel.dataset.connected = 'false'
+    }
+    source.onmessage = event => {
+      let item
+      try { item = JSON.parse(event.data) } catch { return }
+      if (!item || !item.sessionId) return
+      onLiveItem(item)
+    }
+  }
+
+  function clusterForLive(item) {
+    let cluster = state.clusters.find(c => c.session.id === item.sessionId)
+    if (cluster) return cluster
+    // Not yet on disk: create a temporary nebula at a free spot.
+    let ephemeral = state.live.liveClusters.get(item.sessionId)
+    if (!ephemeral) {
+      const idx = state.live.liveClusters.size
+      const rand = rng(hash(item.sessionId) ^ 0x51ab)
+      const angle = idx * 2.399 + rand()
+      const radius = 150 + rand() * 90
+      const center = [Math.cos(angle) * radius, (rand() - 0.5) * 170, Math.sin(angle) * radius]
+      const cloud = buildCloud(center, hash(item.sessionId) ^ 0x77, 0.8, 0.25)
+      ephemeral = {
+        session: {
+          id: item.sessionId,
+          title: item.sessionTitle || '正在进行的对话',
+          counts: { events: 0, user: 0, assistant: 0, tools: 0, turns: 0, fragments: 0 },
+          fragments: [], topics: [],
+        },
+        color: PALETTE[(idx + 3) % PALETTE.length],
+        center, cloud, stars: [], ephemeral: true,
+        dendrites: buildDendrites(center, hash(item.sessionId) ^ 0x2c91, 0.35),
+        core: null, weight: 0.25,
+        lobeCenters: cloud.lobeCenters,
+      }
+      // Reuse the normal hit-test core so tapping the new cloud works.
+      const core = {
+        kind: 'core', cluster: ephemeral, isClusterCore: true, fragment: null,
+        pos: center.slice(), size: 2.2, phase: 0, color: ephemeral.color,
+      }
+      ephemeral.core = core
+      state.stars.push(core)
+      state.live.liveClusters.set(item.sessionId, ephemeral)
+      state.clusters.push(ephemeral)
+    }
+    if (item.sessionTitle && ephemeral.session.title === '正在进行的对话') {
+      ephemeral.session.title = item.sessionTitle
+    }
+    return ephemeral
+  }
+
+  function onLiveItem(item) {
+    const now = performance.now()
+    const cluster = clusterForLive(item)
+    cluster.lastLiveAt = now
+    const isWrite = item.kind === 'write'
+    if (isWrite) state.live.writes += 1
+    else state.live.reads += 1
+    state.live.times.push(now)
+    if (state.live.times.length > 120) state.live.times.shift()
+
+    // Expanding ring on the target cloud: write rings ripple outward, read
+    // rings ripple inward (memory being consulted / pulled back).
+    state.live.pulses.push({
+      cluster, born: now, kind: isWrite ? 'write' : 'read',
+      color: isWrite ? [150, 215, 255] : [235, 195, 130],
+    })
+    if (state.live.pulses.length > 26) state.live.pulses.shift()
+
+    if (isWrite) {
+      const lobe = cluster.cloud.lobeCenters[
+        Math.floor(Math.random() * cluster.cloud.lobeCenters.length)] || cluster.center
+      state.live.newborns.push({
+        cluster, born: now,
+        pos: [lobe[0] + (Math.random() - 0.5) * 16, lobe[1] + (Math.random() - 0.5) * 12, lobe[2] + (Math.random() - 0.5) * 16],
+        color: cluster.color,
+        phase: Math.random() * Math.PI * 2,
+      })
+      if (state.live.newborns.length > 60) state.live.newborns.shift()
+      cluster.session.counts.fragments += 1
+    }
+
+    state.live.lastBurst = now
+    el.livePanel.dataset.active = 'true'
+    el.liveWrites.textContent = String(state.live.writes)
+    el.liveReads.textContent = String(state.live.reads)
+    appendLiveRow(item, cluster)
+    updateLiveRate(now)
+  }
+
+  function appendLiveRow(item, cluster) {
+    if (el.liveFeed.querySelector('.live-empty')) el.liveFeed.innerHTML = ''
+    const row = document.createElement('div')
+    row.className = `live-row ${item.kind}`
+    const label = item.kind === 'write' ? '写入' : '读取'
+    const body = item.text || item.tool || item.type || ''
+    const title = cluster.session.title || '会话'
+    row.innerHTML = `<span class="live-tag">${label}</span><span class="live-text" title="${escapeLive(body)}"><b>${escapeLive(title.slice(0, 14))}</b> ${escapeLive(body.slice(0, 60))}</span>`
+    el.liveFeed.prepend(row)
+    while (el.liveFeed.children.length > 14) el.liveFeed.lastChild.remove()
+  }
+
+  function updateLiveRate(now) {
+    const recent = state.live.times.filter(t => now - t < 60000)
+    el.liveRate.textContent = String(recent.length)
+  }
+
+  /** Draw the live rings and newborn stars on top of the scene. */
+  function drawLiveEffects() {
+    const now = performance.now()
+    const L = state.live
+    ctx.save()
+    ctx.globalCompositeOperation = 'lighter'
+
+    // A soft, lingering aura on any cloud touched in the last few seconds:
+    // the ring is brief, but the cluster itself keeps a "hot" edge so an
+    // active conversation is visible even between events.
+    for (const cluster of state.clusters) {
+      const last = cluster.lastLiveAt || 0
+      const heat = Math.max(0, 1 - (now - last) / 3200)
+      if (heat <= 0) continue
+      const pr = project(cluster.center)
+      const sprite = softSprite(cluster.color)
+      const d = 130 * pr.scale * (0.8 + heat * 0.5)
+      ctx.globalAlpha = heat * 0.16
+      ctx.drawImage(sprite, pr.x - d / 2, pr.y - d / 2, d, d)
+    }
+    ctx.globalAlpha = 1
+
+    for (let i = L.pulses.length - 1; i >= 0; i -= 1) {
+      const p = L.pulses[i]
+      const age = (now - p.born) / 1400
+      if (age >= 1) { L.pulses.splice(i, 1); continue }
+      const pr = project(p.cluster.center)
+      const baseR = 8 * pr.scale
+      const grow = p.kind === 'write' ? age : 1 - age
+      const r = Math.max(2, baseR + grow * 40 * pr.scale)
+      ctx.beginPath()
+      ctx.arc(pr.x, pr.y, r, 0, Math.PI * 2)
+      ctx.strokeStyle = rgba(p.color, (1 - age) * 0.5)
+      ctx.lineWidth = 1.2
+      ctx.stroke()
+    }
+    for (let i = L.newborns.length - 1; i >= 0; i -= 1) {
+      const s = L.newborns[i]
+      const age = (now - s.born) / 6000
+      if (age >= 1) { L.newborns.splice(i, 1); continue }
+      const pr = project(s.pos)
+      const twinkle = 0.75 + Math.sin(now * 0.004 + s.phase) * 0.25
+      const r = Math.max(0.8, (1.4 + (1 - age) * 1.6) * pr.scale * twinkle)
+      const sprite = softSprite([255, 255, 255])
+      const d = r * 7
+      ctx.globalAlpha = (1 - age) * 0.85
+      ctx.drawImage(sprite, pr.x - d / 2, pr.y - d / 2, d, d)
+      ctx.globalAlpha = 1
+      ctx.beginPath()
+      ctx.arc(pr.x, pr.y, r, 0, Math.PI * 2)
+      ctx.fillStyle = '#ffffff'
+      ctx.fill()
+    }
+    ctx.restore()
+    // Idle the activity dot shortly after the last event.
+    if (now - L.lastBurst > 1200) el.livePanel.dataset.active = 'false'
+  }
+
+  /** Fold an on-disk snapshot back in: drop ephemeral clouds now on disk. */
+  function refreshFromSnapshot() {
+    fetch('/memory-cloud/api/memories', { headers: { accept: 'application/json' } })
+      .then(r => (r.ok ? r.json() : Promise.reject(new Error(`HTTP ${r.status}`))))
+      .then(data => {
+        const ids = new Set((data.sessions || []).map(s => s.id))
+        for (const [id, cluster] of state.live.liveClusters) {
+          if (!ids.has(id)) continue
+          state.live.liveClusters.delete(id)
+          const ci = state.clusters.indexOf(cluster)
+          if (ci >= 0) state.clusters.splice(ci, 1)
+          // Remove its core from the flat hit-test list.
+          const si = state.stars.indexOf(cluster.core)
+          if (si >= 0) state.stars.splice(si, 1)
+        }
+        if (state.stats) {
+          state.stats.sessions = data.stats.sessions
+          state.stats.fragments = data.stats.fragments
+          buildStats(state.stats)
+          el.subtitle.textContent = state.isMobile
+            ? `${data.stats.sessions} 个会话 · ${data.stats.fragments} 颗记忆星 · 单指旋转 / 双指缩放`
+            : `${data.stats.sessions} 个会话记忆 · ${data.stats.fragments} 颗记忆星 · 拖拽以探索`
+        }
+      })
+      .catch(() => { /* transient; next tick retries */ })
   }
 
   const SKIN_KEY = 'dsh-memory-cloud:skin:v1'
@@ -632,7 +866,7 @@
     const q = state.query.trim().toLowerCase()
     if (q === '') return true
     if (cluster.session.title.toLowerCase().includes(q)) return true
-    if (cluster.session.workspaceLabel.toLowerCase().includes(q)) return true
+    if (cluster.session.workspaceLabel && cluster.session.workspaceLabel.toLowerCase().includes(q)) return true
     return (cluster.session.fragments || []).some(f => f.text.toLowerCase().includes(q))
   }
 
@@ -1206,6 +1440,7 @@
       drawRelationArcs()
       drawNebulaStars(projected)
     }
+    drawLiveEffects()
 
     // Captions only make sense once a cluster fills the view.
     if (lod >= 2) drawFragmentCaptions(lod)
@@ -1530,9 +1765,18 @@
       else if (window.parent !== window) window.parent.postMessage({ source: 'dsh-memory-cloud', type: 'close' }, location.origin)
     }
   })
+  el.liveToggle.addEventListener('click', () => {
+    const collapsed = el.livePanel.classList.toggle('collapsed')
+    el.liveToggle.textContent = collapsed ? '+' : '−'
+    el.liveToggle.setAttribute('aria-pressed', String(!collapsed))
+  })
+  el.liveFeed.innerHTML = '<div class="live-empty">等待对话记忆写入…</div>'
+  el.livePanel.dataset.connected = 'false'
   // The nebula is dark-only by design; no theme messages are exchanged.
   window.addEventListener('resize', resize)
   window.addEventListener('orientationchange', () => window.setTimeout(resize, 250))
+  // Periodically reconcile ephemeral live clouds with the on-disk snapshot.
+  window.setInterval(refreshFromSnapshot, 15000)
 
   // -------------------------------------------------------------------------
   // Boot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-cloud",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "type": "module",
   "description": "Visualize every DSH session memory as an interactive 3D nebula, with a neuron-signal skin and zoom-driven detail levels.",
   "license": "MIT",