@try-works/dsh-memory 0.1.17 → 0.1.19

package/STATUS.md

@@ -145,7 +145,8 @@ the flag on did not change what the user sees.
 
 ### Blocked on a restart
 
-- [ ] **Restart, then check the tasks layer — THE BLOCKER.** It writes to ANOTHER plugin's storage through
+- [x] **Restart, then check the tasks layer — DONE 2026-10-09.** The restart confirmed it. See the
+      tasks-layer section above for the two log entries and the counts. It writes to ANOTHER plugin's storage through
       that plugin's service, so it deserves a real observation rather than a passing suite. After
       the restart, ask for `memory_tasks` and expect a report with `live: 2`, `backedUp: 2` and
       `pending.present: 2`. Then check `logs/memory.log` for a `tasks-backup` entry and a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@try-works/dsh-memory",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Git-backed, workspace-scoped memory for the DeepSeek Harness (global layer + per-workspace layers)",
   "type": "module",
   "main": "src/index.js",

package/src/client/index.js

@@ -342,10 +342,17 @@ window.__ModuleLoader__.load({
     /**
      * The Memory tab: this session's memory activity, in one place.
      *
-     * Its data is the most recent memory_map result of this conversation. 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` - the very
-     * object ui-chat's conversation-nodes/tool.ts forwards as `meta: match.event.data.meta`.
+     * Its data is the newest memory snapshot in this conversation, from either of two routes.
+     *
+     * The one that matters is memory/map: a browser half cannot ask the host for anything, so the
+     * session record is the only channel - and rather than wait for someone to call a tool, the HOST
+     * publishes the map into that record itself. SessionEventMap is merge-extensible by design and a
+     * log-only event never reaches the model surface, so this is the harness's own answer for a view
+     * that must report state nobody asked about.
+     *
+     * A memory_map TOOL RESULT is still honoured, newest wins, because a session whose snapshots
+     * predate the publisher would otherwise draw nothing. That route carries its value on `meta` -
+     * the object ui-chat's conversation-nodes/tool.ts forwards as `meta: match.event.data.meta`.
      *
      * READING IT: the session's contiguous event window is published as the documented
      * public member SessionBinding.eventSource (ObservableSnapshot<SessionEventWindow>, see
@@ -365,11 +372,13 @@ window.__ModuleLoader__.load({
     const MEMORY_STATE_NESTED = { kind: 'nested', meta: null, seq: null, time: null }
 
     /**
-     * Find the newest memory_map result in the window and say what it carried.
+     * Find the newest memory snapshot in the window and say what it carried.
      *
-     * A tool/result event names its call only by id, so the call events are indexed first.
-     * A result whose tool/call pair has been paged out or pruned is still recognised by the
-     * shape of its own value: nothing but memory_map produces { scope, generatedAt }.
+     * Two routes, newest wins. The host publishes a memory/map event on its own cadence, which is
+     * what lets the tab draw with no tool call. A memory_map tool/result is also honoured: a
+     * tool/result event names its call only by id, so call events are indexed first, and a result
+     * whose pair has been paged out is still recognised by the shape of its own value, since
+     * nothing else produces { scope, generatedAt }.
      */
     function readMemoryState(window) {
       const entries = window && Array.isArray(window.entries) ? window.entries : null
@@ -387,7 +396,17 @@ window.__ModuleLoader__.load({
       for (let i = entries.length - 1; i >= 0; i -= 1) {
         const entry = entries[i]
         const event = entry && entry.type === 'event' ? entry.event : null
-        if (!event || event.type !== 'tool/result') continue
+        if (!event) continue
+        // The host PUBLISHES the map into the log itself, so the tab fills in on its own and needs
+        // nobody to call a tool first. This is the route that matters; the tool/result route below
+        // is kept so a session whose snapshots predate the publisher still draws.
+        if (event.type === 'memory/map') {
+          const published = event.data
+          if (published === null || typeof published !== 'object') continue
+          if (typeof published.generatedAt !== 'string' || typeof published.scope !== 'string') continue
+          return { kind: 'ready', meta: published, seq: event.seq, time: event.time }
+        }
+        if (event.type !== 'tool/result') continue
         const data = event.data || {}
         const message = data.message || null
         const callId = message && message.source ? message.source.callId : undefined
@@ -479,8 +498,10 @@ window.__ModuleLoader__.load({
     /**
      * What the tab says when there is nothing to draw.
      *
-     * The distinctions matter: 'this session never ran memory_map' and 'the call ran but its
-     * result carries no snapshot' are different facts, and neither of them is zero entries.
+     * The distinctions matter: 'nothing has been published for this session yet' and 'a call ran but
+     * its result carries no snapshot' are different facts, and neither of them is zero entries.
+     * None of them is ever fixed by asking the reader to do something - the host publishes on its
+     * own, so an empty tab is a statement about the session, not a task for the user.
      */
     function emptyMemoryCopy(state) {
       if (state.kind === 'unavailable') {
@@ -497,7 +518,7 @@ window.__ModuleLoader__.load({
           title: 'The last memory_map result carried no snapshot',
           lines: [
             'The call is part of this session, but no structured value is attached to its result: a call that failed, or one whose result was replaced while the context was compacted.',
-            'Running memory_map again puts a fresh snapshot here.',
+            'The host publishes a fresh snapshot on its own cadence, so this clears itself.',
           ],
         }
       }
@@ -511,10 +532,10 @@ window.__ModuleLoader__.load({
         }
       }
       return {
-        title: 'No memory_map result in this session yet',
+        title: 'Nothing published for this session yet',
         lines: [
-          'This tab draws the most recent memory_map result of this conversation: the same snapshot the agent was shown, read back from the session record rather than fetched again.',
-          'Run memory_map once - scope "session" or "all" - and the panels appear here.',
+          'This tab draws the memory snapshot the host publishes into this conversation as it runs, so nothing here has to be asked for.',
+          'Nothing has been published for this session yet. It arrives with the first turn and refreshes as the store changes.',
         ],
       }
     }
@@ -579,7 +600,7 @@ window.__ModuleLoader__.load({
       parts.push(react.createElement('div', {
         key: 'src',
         style: { fontFamily: GEIST, fontSize: '11px', color: 'var(--dsw-alias-label-tertiary)', lineHeight: 1.6 },
-      }, 'Read from this session\u2019s most recent memory_map result (event #' + fmt(props.seq) + '), not re-read from the store. Run memory_map again to refresh it.'))
+      }, 'Published by the host into this session (event #' + fmt(props.seq) + '), not re-read from the store. It refreshes on its own as the store changes.'))
       return box({ display: 'flex', flexDirection: 'column', gap: '18px' }, parts)
     }
 

package/src/host.js

@@ -16,6 +16,7 @@ import { due, problems, readQueue, reapStalled, REASONS, STATES, summarize as su
 import { planRecovery, recoverOne } from './recover.js'
 import { logRun, noteActivity, readMetrics, record } from './telemetry.js'
 import { GitRunner, SyncScheduler, classifyGitResult, commitMessage } from './git.js'
+import { buildMap } from './map.js'
 import { backupTasks, defaultSchedulePath, planRestore, readScheduleStore } from './tasks.js'
 import { autoAssociateSession } from './session.js'
 import { readAssociations } from './workspace.js'
@@ -23,6 +24,7 @@ import { readAssociations } from './workspace.js'
 const PLUGIN = 'dsh-memory'
 
 /** How often the idle ticker checks whether a cadence is due (the cadences self-throttle). */
+const MAP_PUBLISH_MS = 60 * 1000
 const TASKS_BACKUP_MS = 30 * 60 * 1000
 const IDLE_TICK_MS = 60_000
 
@@ -70,6 +72,8 @@ export function wireHost(ctx, store, cfg) {
   let lastRefreshAttempt = 0
   let lastTasksBackupAttempt = 0
   let restoreAttempted = false
+  const lastMapPublish = new Map()
+  const lastMapSignature = new Map()
   let lastHistoryAttempt = 0
   let syncInFlight = false
 
@@ -695,6 +699,52 @@ export function wireHost(ctx, store, cfg) {
     }
   }
 
+  /**
+   * Publish the memory map into the session log, so a UI can draw it without anyone calling a tool.
+   *
+   * WHY AN EVENT AND NOT A TOOL CALL. The Memory tab used to read the newest memory_map TOOL RESULT
+   * out of the session, which meant it stayed empty until an agent happened to call the tool - the
+   * reader had to be shown the data before the tab could show it back. That is backwards for a view
+   * whose whole job is to report state nobody asked about. Session.append is the harness's own
+   * answer: SessionEventMap is documented as "the merge-extensible, append-only source of truth",
+   * plugins add their own event types (session/title does exactly this), and a log-only event never
+   * reaches the model surface or the derived history. So the map is published BY the host, INTO the
+   * log, and the client reads it from the same event window it already subscribes to.
+   *
+   * TWO GUARDS, both about not making the log grow without limit:
+   *   - a time throttle, because building the map walks the ledger;
+   *   - a signature comparison that ignores generatedAt, so an unchanged store appends nothing.
+   * The signature is the point. Without it every turn would add an identical snapshot to a log that
+   * is the durable record of the conversation.
+   */
+  function publishMemoryMap(session, { agent, force = false } = {}) {
+    try {
+      if (!session || typeof session.append !== 'function' || !session.id) return
+      if (isSubagentSession(session)) return
+      const now = Date.now()
+      if (!force && now - (lastMapPublish.get(session.id) ?? 0) < MAP_PUBLISH_MS) return
+      lastMapPublish.set(session.id, now)
+      const key = keyBySession.get(session.id) ?? 'global'
+      const scope = key === 'global' ? 'global' : 'workspace'
+      // goals.get() takes an AGENT, not a session (goal/src/index.ts:277), so the goal is only
+      // available on the pre-step path. Elsewhere the map is published without it, which is honest:
+      // it describes what it can see.
+      const goal = agent ? ctx.get('goals')?.get(agent)?.objective : undefined
+      const map = buildMap(store, { scope: 'all', sessionId: session.id, memoryScope: scope, key, goal, now, maxChars: cfg.injectionMaxChars })
+      // JSON round-trip is not decoration: append() REJECTS data containing undefined, and the
+      // round-trip is what guarantees we hand it lossless JSON.
+      const payload = JSON.parse(JSON.stringify(map))
+      const signature = JSON.stringify({ ...payload, generatedAt: '' })
+      if (!force && lastMapSignature.get(session.id) === signature) return
+      lastMapSignature.set(session.id, signature)
+      session.append('memory/map', payload)
+      logRun(store.root, 'map-publish', { ok: true, scope, key: key ?? '', bytes: signature.length })
+    } catch (error) {
+      // Never let a view break the conversation it is describing.
+      logRun(store.root, 'map-publish', { ok: false, error: String((error && error.message) || error).slice(0, 160) })
+    }
+  }
+
   function maybeSync() {
     if (syncInFlight || !git) return
     if (!scheduler.shouldCommit() && !scheduler.shouldSync()) return
@@ -709,8 +759,17 @@ export function wireHost(ctx, store, cfg) {
 
   // session lifecycle: associate workspace + capture on turn end
   ctx.on('session/event', (session, event) => {
-    if (event.type === 'turn/start') void resolveKey(session)
-    else if (event.type === 'turn/end') maybeCapture(session)
+    // DEFERRED, and it has to be. This handler runs INSIDE an append - the harness sets a reentrancy
+    // flag for the duration of the session/event emission - and Session.append refuses to reenter:
+    // "session append cannot reenter while another append is being published". Measured in the live
+    // log, exactly half the publishes failed with that message while the pre-step ones succeeded.
+    // A macrotask lands after the append has settled, so the guard is satisfied.
+    if (event.type === 'turn/start') {
+      void resolveKey(session).then(() => setTimeout(() => publishMemoryMap(session), 0))
+    } else if (event.type === 'turn/end') {
+      maybeCapture(session)
+      setTimeout(() => publishMemoryMap(session), 0)
+    }
   })
 
   // Disposal is the LAST chance to capture a session, so it bypasses the throttle.
@@ -751,6 +810,10 @@ export function wireHost(ctx, store, cfg) {
     // Injection writes nothing, so without this it is invisible: the one hook whose effect is
     // entirely in the conversation could break and leave no trace anywhere on disk.
     record(store.root, 'inject', { detail: { scope, key: key ?? '', subagent, step, chars: text.length } })
+    // Published here as well as on turn boundaries, because this is the only place the AGENT (and
+    // so the session's goal) is in reach - and the received panel is supposed to describe what was
+    // actually injected, goal included.
+    publishMemoryMap(agent.session, { agent })
     return {
       ...decision,
       messages: [...decision.messages, createUserMessage({ content: [{ type: 'text', text }], source: { kind: PLUGIN, form: 'memory-context', version: 1 } })],