@try-works/dsh-memory 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@try-works/dsh-memory",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Git-backed, workspace-scoped memory for the DeepSeek Harness (global layer + per-workspace layers)",
   "type": "module",
   "main": "src/index.js",
@@ -48,7 +48,8 @@
     "client": {
       "platform": "web",
       "inject": [
-        "@deepseek-ai/dsh-client-ui-settings"
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-conversation"
       ],
       "external": []
     }

package/src/client/index.js

@@ -338,6 +338,77 @@ window.__ModuleLoader__.load({
       const bodyStyle = { padding: '16px', display: 'flex', flexDirection: 'column', gap: '14px' }
       return box(cardStyle, [head, box(Object.assign({ key: 'b' }, bodyStyle), body)]);
     }
+
+    /**
+     * The Memory tab: this session's memory activity, in one place.
+     *
+     * Its data is the most recent memory_map result in this session. That is not a
+     * convenience: a browser half cannot ask the host for anything, so the session record is
+     * the only channel, and a tool result carries its structured value on `meta` (ui-chat's
+     * conversation-nodes/tool.ts does `meta: match.event.data.meta`).
+     *
+     * READING IT: a conversation view gets data through a registered standard hook, so the
+     * plugin provides `memoryMap` via ctx.uiSession.provide and this component receives
+     * `useMemoryMap` as a prop, the way ui-tool's rows receive their history hook. The hook
+     * resolves by scanning the Trajectory target's event nodes for a settled memory_map tool
+     * call; the Trajectory target is the shipped assembly of this session's nodes, and its
+     * snapshot contract is eventNodes: ConversationNode[] with { kind: 'tool', root }.
+     */
+    function findMemorySnapshot(snapshot) {
+      if (!snapshot || !Array.isArray(snapshot.eventNodes)) return null
+      // Newest first: the tab describes the session as it stands now, not as it first was.
+      for (let i = snapshot.eventNodes.length - 1; i >= 0; i -= 1) {
+        const node = snapshot.eventNodes[i]
+        const root = node && node.kind === 'tool' ? node.root : null
+        if (!root || root.isError) continue
+        const name = root.call && root.call.name
+        if (name !== 'memory_map') continue
+        if (root.meta && typeof root.meta === 'object') return root.meta
+      }
+      return null
+    }
+
+    function MemoryTabView(props) {
+      const useMemoryMap = props ? props.useMemoryMap : null
+      const meta = typeof useMemoryMap === 'function' ? useMemoryMap() : null
+      const page = { padding: '32px 28px 0 28px', display: 'flex', flexDirection: 'column', gap: '0' }
+      if (!meta) {
+        // Nothing to draw yet, and saying so beats drawing an empty chart that reads as zero.
+        const empty = { display: 'flex', flexDirection: 'column', gap: '10px', maxWidth: '520px' }
+        return box(page, [box(empty, [
+          react.createElement('div', { key: 'h', style: { fontFamily: GEIST, fontSize: '15px', fontWeight: 500, color: INK } }, 'No memory snapshot in this session yet'),
+          react.createElement('div', { key: 'p', style: { fontFamily: GEIST, fontSize: '13px', lineHeight: 1.6, color: MUTED } }, 'This tab shows what memory put in front of this conversation, what the conversation wrote back, and the state of the store. It fills in once memory_map runs in this session.'),
+        ])]);
+      }
+      const store = meta.store || null
+      const session = meta.session || null
+      const parts = []
+      if (session) {
+        const who = session.workspace ? 'workspace ' + session.workspace : 'global layer'
+        parts.push(react.createElement('div', { key: 'id', style: { fontFamily: GEIST, fontSize: '13px', color: '#3A3A38', paddingBottom: '26px' } }, 'This session · ' + who));
+        if (session.received) parts.push(box({ key: 'r', display: 'flex', flexDirection: 'column', gap: '12px', maxWidth: '460px' }, [react.createElement(ReceivedPanel, { key: 'p', received: session.received })]));
+        if (session.written) parts.push(box({ key: 'w', marginTop: '34px', paddingTop: '26px', borderTop: '1px solid ' + LINE, display: 'flex', flexDirection: 'column' }, [react.createElement(WrittenPanel, { key: 'p', written: session.written })]));
+      }
+      if (store) {
+        const attention = (store.queue && store.queue.attention) || []
+        const chips = attention.slice(0, 3).map(function (row) { return react.createElement(Chip, { key: row.state + row.reason, text: fmt(row.count) + ' ' + row.state, hot: true }) });
+        if (store.queue && store.queue.waiting) chips.push(react.createElement(Chip, { key: 'waiting', text: fmt(store.queue.waiting) + ' waiting' }));
+        parts.push(box({ key: 's', marginTop: '34px', paddingTop: '26px', borderTop: '1px solid ' + LINE, display: 'flex', flexDirection: 'column', gap: '15px' }, [
+          sectionLabel('SNAPSHOT', fmt(store.total) + ' entries · ' + fmt(store.scopeTotal) + ' scopes'),
+          react.createElement(LayerBar, { key: 'bar', layers: store.layers, height: '30px' }),
+          react.createElement(Legend, { key: 'leg', layers: store.layers }),
+          box({ key: 'f', display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: '16px' }, [
+            box({ key: 'st', display: 'flex', gap: '18px' }, [
+              react.createElement(Stat, { key: 'a', value: fmt(store.freshness.fresh), label: 'fresh' }),
+              store.freshness.stale ? react.createElement(Stat, { key: 'b', value: fmt(store.freshness.stale), label: 'stale', color: RUST }) : null,
+              store.freshness.skip ? react.createElement(Stat, { key: 'c', value: fmt(store.freshness.skip), label: 'superseded' }) : null,
+            ]),
+            box({ key: 'q', display: 'flex', gap: '5px', flexWrap: 'wrap' }, chips),
+          ]),
+        ]));
+      }
+      return box(page, parts);
+    }
     /** Fields rendered on this page, in order. */
     const FIELDS = [
       { key: 'memoryRoot', label: 'Memory root', hint: 'Local folder or drive that holds the store.', placeholder: 'D:\\Memory' },
@@ -547,18 +618,54 @@ window.__ModuleLoader__.load({
           name: 'tool.call.toolview',
           key: 'memory_map',
         }, MemoryMapCard)))
+        // The settings page registers FIRST, and deliberately. It is the established surface;
+        // the tab below is newer and depends on two services the page does not need. Ordering
+        // the proven surface before the unproven one means a failure in the tab cannot take the
+        // settings page down with it - both halves share one file and one apply().
         disposers.push(ctx.slots.inject('settings.section', () => ctx.slots.register({
           name: 'settings.section',
           id: 'memory',
           order: 80,
           label: 'Memory',
         }, () => react.createElement(MemorySettings))))
+        // The Memory tab. Data arrives through a registered standard hook, because a
+        // conversation view is a slot and slots are fed by hooks, not by direct reads.
+        // The Trajectory target is the shipped assembly of this session's nodes, so the
+        // source re-derives the memory snapshot from it on every projection.
+        try {
+          ctx.effect(() => ctx.uiSession.provide({
+            hooks: ['memoryMap'],
+            resolve: (binding) => {
+              const target = ctx.uiConversation.binding(binding).target('trajectory')
+              return {
+                hooks: {
+                  memoryMap: {
+                    getSnapshot: () => findMemorySnapshot(target.getSnapshot()),
+                    subscribe: (listener) => target.subscribe(listener),
+                  },
+                },
+              }
+            },
+          }), 'dsh-memory: memory map hook')
+          disposers.push(ctx.slots.inject('conversation.view', () => ctx.slots.register({
+            name: 'conversation.view',
+            id: 'memory',
+            // ui-chat holds 0 and ui-trajectory 10, so Memory sits after both without
+            // reordering anyone else's tab.
+            order: 20,
+            label: 'Memory',
+          }, MemoryTabView)))
+        } catch (error) {
+          // Loud, not silent. A tab that fails to register is invisible by definition, so this
+          // warning is the only trace the failure can leave.
+          ctx.logger.warn('dsh-memory: Memory tab unavailable: ' + (error && error.message ? error.message : String(error)))
+        }
         return () => { for (const dispose of disposers) dispose() }
       }, 'dsh-memory: settings section')
     }
 
     exports.name = 'dsh-memory'
-    exports.inject = ['slots', 'configForms', 'remote.session']
+    exports.inject = ['slots', 'configForms', 'remote.session', 'uiSession', 'uiConversation']
     exports.apply = apply
     return module.exports
   },