dsh-hypatia-auto-memory 0.2.0 → 0.4.0

package/src/cascade.js

@@ -22,6 +22,7 @@
 import { createHash } from 'node:crypto'
 
 import { PLUGIN_NAME } from './consolidator.js'
+import { NULL_MODEL_LOG } from './model-log.js'
 
 /** Tag marking the tier an entry belongs to. */
 export function levelTag(level) {
@@ -80,9 +81,10 @@ function archiveInstruction(level, count) {
  *   selectRoute: (routes: any) => any,
  *   getConfig: () => any,
  *   status: import('./status.js').StatusLog,
+ *   modelLog?: ReturnType<import('./model-log.js').createModelLog>,
  * }} deps
  */
-export function createCascade({ cli, llm, selectRoute, getConfig, status }) {
+export function createCascade({ cli, llm, selectRoute, getConfig, status, modelLog = NULL_MODEL_LOG }) {
   /**
    * Ask the model to archive one batch.
    * @returns {Promise<{title: string, summary: string} | undefined>}
@@ -93,8 +95,11 @@ export function createCascade({ cli, llm, selectRoute, getConfig, status }) {
       return `### ${i + 1}. ${row.name}\n${data}`
     }).join('\n\n')
 
+    const attempt = modelLog.begin('memory-cascade', route)
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), timeoutMs)
+    let outcome = 'incomplete'
+    let detail = ''
     try {
       const { createUserMessage, BlockAssembler } = await import('@deepseek-ai/dsh-llm')
       const assembler = new BlockAssembler()
@@ -112,18 +117,38 @@ export function createCascade({ cli, llm, selectRoute, getConfig, status }) {
       })) {
         assembler.push(chunk)
       }
-      if (assembler.finish.kind !== 'stop') return undefined
+      if (assembler.finish.kind !== 'stop') {
+        detail = String(assembler.finish.kind)
+        return undefined
+      }
       const text = assembler.blocks().filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim()
       const fence = /^```(?:json)?\s*([\s\S]*?)```\s*$/.exec(text)
-      const parsed = JSON.parse(fence ? fence[1].trim() : text)
+      // Its own catch: a parse failure is an unusable reply, not a failed call,
+      // and Node's parse error quotes the reply's opening characters.
+      let parsed
+      try {
+        parsed = JSON.parse(fence ? fence[1].trim() : text)
+      } catch {
+        detail = 'unparseable reply'
+        return undefined
+      }
       const summary = typeof parsed?.summary === 'string' ? parsed.summary.trim() : ''
-      if (summary === '') return undefined
+      if (summary === '') {
+        detail = 'no summary'
+        return undefined
+      }
       const title = typeof parsed?.title === 'string' && parsed.title.trim() !== ''
         ? parsed.title.trim()
         : `Archive tier ${level}`
+      outcome = 'ok'
       return { title, summary }
+    } catch (error) {
+      outcome = 'error'
+      detail = error instanceof Error ? error.message : String(error)
+      throw error
     } finally {
       clearTimeout(timer)
+      void attempt.finish(outcome, detail)
     }
   }
 

package/src/collector.js

@@ -59,6 +59,26 @@ const RECORDED_TYPES = new Set([
   'tool/result',
 ])
 
+/**
+ * Whether an assistant/message event carries anything worth logging on its own.
+ *
+ * A turn that only issued tool calls (no text, no reasoning, no interruption
+ * marker) adds nothing to the conversation record — the tool outcomes already
+ * live in the session log if needed. Skipping these avoids msg-* entries whose
+ * entire body would be `(tool calls only)` or an empty placeholder.
+ *
+ * @param {any} event
+ * @returns {boolean}
+ */
+function hasAssistantContent(event) {
+  const blocks = event.data?.message?.content ?? []
+  for (const block of blocks) {
+    if (block.type === 'text' && String(block.text ?? '').trim() !== '') return true
+    if (block.type === 'image') return true
+  }
+  return false
+}
+
 /**
  * Whether this event becomes one `msg-*` entry.
  *
@@ -66,11 +86,17 @@ const RECORDED_TYPES = new Set([
  * output) are excluded: they are not things the human said, and re-logging them
  * would let memory amplify into itself.
  *
+ * Assistant turns whose only content is tool calls are also excluded: they have
+ * no substantive message to remember.
+ *
  * @param {any} event
  * @returns {boolean}
  */
 export function isLoggableMessage(event) {
-  if (event?.type === 'assistant/message') return true
+  if (event?.type === 'assistant/message') {
+    const interrupted = event.data?.interrupted === true
+    return interrupted || hasAssistantContent(event)
+  }
   return event?.type === 'user/message' && event.data?.source?.kind === 'user'
 }
 

package/src/config.js

@@ -35,7 +35,11 @@ export const DEFAULTS = {
     // User messages were never capped, so a pasted log went into hypatia whole.
     // Generous, because what the user typed is the part most worth keeping.
     maxUserChars: 32000,
-    toolLedger: true,
+    // Tool-call ledgers (name / count / success / duration) are intentionally
+    // off by default: they still reveal which tools were used and when, and the
+    // user has asked to avoid writing any tool-call-derived data to hypatia.
+    // Set this to true to restore the previous behavior.
+    toolLedger: false,
   },
   consolidation: {
     enabled: true,

package/src/consolidator.js

@@ -14,14 +14,37 @@
  * @module dsh-hypatia-auto-memory/consolidator
  */
 
-import { absolutizeDates, blocksToText, eventDate, flattenToolResult, redactSecrets } from './content-policy.js'
+import { absolutizeDates, blocksToText, eventDate, redactSecrets } from './content-policy.js'
 import { countLoggableMessages, isCompactionReplacement, isLoggableMessage } from './collector.js'
 import { messageName, summaryName } from './writer.js'
 import { EMPTY_PROGRESS, advanceProgress } from './progress.js'
 import { TaskDeferredError } from './queue.js'
+import { NULL_MODEL_LOG } from './model-log.js'
 
 export const PLUGIN_NAME = 'dsh-hypatia-auto-memory'
 
+/**
+ * Output budget for one adjudication.
+ *
+ * It is not 200 — the value it carried for as long as the call existed — because
+ * a thinking-enabled route spends the SAME cap on its reasoning and its answer.
+ * `deepseek-*` resolves an omitted `reasoningEffort` to `high` (the
+ * `llm-deepseek` profile default) and puts roughly half its output tokens into
+ * reasoning, so a 200-token adjudication ended with `max-tokens` before the
+ * verdict was ever emitted: every other work unit was silently stored with no
+ * relationship at all. `ADJUDICATION_REASONING_EFFORT` below usually removes
+ * the need for the headroom, but a route that cannot honour `off` — or a
+ * provider that ignores the control — still has to fit thinking plus a verdict.
+ */
+export const ADJUDICATION_MAX_TOKENS = 1024
+
+/**
+ * What the adjudication call asks for on a route that advertises it. A verdict
+ * is a six-way classification of two short texts: thinking there spends the
+ * output budget and the latency for nothing.
+ */
+export const ADJUDICATION_REASONING_EFFORT = 'off'
+
 /** Distinguishes permanent failures (no retry value) from transient ones. */
 export class PermanentConsolidationError extends Error {
   constructor(message) {
@@ -178,8 +201,11 @@ export function buildTranscript(events, config, now = new Date(), { before } = {
       const callId = event.data?.message?.source?.callId
       const name = toolNames.get(callId) ?? 'tool'
       const ok = event.data?.error === undefined
-      const first = clean(flattenToolResult(event), event).split('\n')[0] ?? ''
-      entries.push({ seq: event.seq, line: `T: ${name} ${ok ? '✅' : '❌'} ${first}`.trimEnd() })
+      // Tool outputs are intentionally kept out of the consolidation transcript.
+      // The model only sees that a tool was called and whether it succeeded;
+      // the actual result text never reaches the remote model or the summaries
+      // and work units derived from it.
+      entries.push({ seq: event.seq, line: `T: ${name} ${ok ? '✅' : '❌'}` })
     }
   }
 
@@ -260,13 +286,46 @@ export function parseConsolidationOutput(raw, maxWorkUnits) {
  *   writer: ReturnType<import('./writer.js').createWriter>,
  *   getConfig: () => any,
  *   status: import('./status.js').StatusLog,
+ *   modelLog?: ReturnType<import('./model-log.js').createModelLog>,
  *   projectFor: (session: any) => Promise<string>,
  * }} deps
  */
-export function createConsolidator({ queue, progress, sessions, llm, cli, writer, getConfig, status, projectFor }) {
+export function createConsolidator({ queue, progress, sessions, llm, cli, writer, getConfig, status, modelLog = NULL_MODEL_LOG, projectFor }) {
   let warnedNoRoute = false
   const selectRoute = createConsolidationRouteSelector()
 
+  /**
+   * Whether a route may be asked for {@link ADJUDICATION_REASONING_EFFORT},
+   * memoized per route for this instance.
+   *
+   * The core rejects a request whose effort the model does not advertise
+   * (`UNSUPPORTED_REASONING_EFFORT`, `llm`'s `resolveCallWithInfo`), so the
+   * control only follows a positive capability answer. A route that cannot be
+   * inspected — an adapter that throws, or the `llm` double a unit test hands
+   * in — simply gets no effort, which is what every call did before this.
+   * Capability does not change while an instance lives; a profile reload
+   * rebuilds the instance and the cache with it.
+   *
+   * @param {{provider: string, model: string}} route
+   * @param {AbortSignal} signal - the same signal the call carries, so a
+   * lookup cannot outlive the timeout it is part of.
+   */
+  const thinkingOff = new Map()
+  async function canDisableThinking(route, signal) {
+    const key = `${route.provider}\0${route.model}`
+    if (thinkingOff.has(key)) return thinkingOff.get(key)
+    let supported = false
+    try {
+      const info = await llm.resolveModelInfo?.(route.provider, route.model, signal)
+      supported = Array.isArray(info?.reasoning?.efforts)
+        && info.reasoning.efforts.some((effort) => effort?.id === ADJUDICATION_REASONING_EFFORT)
+    } catch (error) {
+      status.warn(`reasoning capability lookup failed for ${key.replace('\0', '/')}: ${String(error)}`)
+    }
+    thinkingOff.set(key, supported)
+    return supported
+  }
+
   /**
    * Turn-end trigger check. The turn threshold is a minimum interval between
    * accepted consolidation tasks, not a polling cadence: once the interval
@@ -385,9 +444,14 @@ export function createConsolidator({ queue, progress, sessions, llm, cli, writer
       listed,
     ].join('\n')
 
+    const attempt = modelLog.begin('memory-adjudication', route)
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), consolidation.timeoutMs)
+    let outcome = 'incomplete'
+    let detail = ''
     try {
+      // Asked for only when the route advertises it; see `canDisableThinking`.
+      const skipThinking = await canDisableThinking(route, controller.signal)
       const { createUserMessage, BlockAssembler } = await import('@deepseek-ai/dsh-llm')
       const assembler = new BlockAssembler()
       for await (const chunk of llm.stream({
@@ -398,20 +462,41 @@ export function createConsolidator({ queue, progress, sessions, llm, cli, writer
           content: [{ type: 'text', text: instruction }],
           source: { kind: 'plugin', plugin: PLUGIN_NAME },
         })],
-        maxTokens: 200,
+        maxTokens: ADJUDICATION_MAX_TOKENS,
+        ...skipThinking ? { reasoningEffort: ADJUDICATION_REASONING_EFFORT } : {},
         purpose: 'memory-adjudication',
         signal: controller.signal,
       })) {
         assembler.push(chunk)
       }
-      if (assembler.finish.kind !== 'stop') return undefined
+      if (assembler.finish.kind !== 'stop') {
+        detail = String(assembler.finish.kind)
+        return undefined
+      }
       const text = assembler.blocks().filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim()
       const fence = /^```(?:json)?\s*([\s\S]*?)```\s*$/.exec(text)
-      const parsed = JSON.parse(fence ? fence[1].trim() : text)
-      if (typeof parsed?.verdict !== 'string') return undefined
+      // Its own catch: a parse failure is an unusable reply, not a failed call,
+      // and Node's parse error quotes the reply's opening characters.
+      let parsed
+      try {
+        parsed = JSON.parse(fence ? fence[1].trim() : text)
+      } catch {
+        detail = 'unparseable reply'
+        return undefined
+      }
+      if (typeof parsed?.verdict !== 'string') {
+        detail = 'no verdict'
+        return undefined
+      }
+      outcome = 'ok'
       return { verdict: parsed.verdict, target: typeof parsed.target === 'string' ? parsed.target : '' }
+    } catch (error) {
+      outcome = 'error'
+      detail = error instanceof Error ? error.message : String(error)
+      throw error
     } finally {
       clearTimeout(timer)
+      void attempt.finish(outcome, detail)
     }
   }
 
@@ -488,44 +573,84 @@ export function createConsolidator({ queue, progress, sessions, llm, cli, writer
     // watermark and the next trigger resumes from exactly there.
     const coveredToSeq = complete ? task.toSeq : lastSeq + 1
 
+    const attempt = modelLog.begin('memory-consolidation', route)
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), consolidation.timeoutMs)
-    let assembled
+    let outcome = 'incomplete'
+    let detail = ''
+    let parsedOutput
     try {
-      const { createUserMessage, BlockAssembler } = await import('@deepseek-ai/dsh-llm')
-      const assembler = new BlockAssembler()
-      const request = createUserMessage({
-        content: [{ type: 'text', text: `${consolidationInstruction(consolidation.maxWorkUnitsPerRun)}\n\n<transcript>\n${transcript}\n</transcript>` }],
-        source: { kind: 'plugin', plugin: PLUGIN_NAME },
-      })
-      for await (const chunk of llm.stream({
-        provider: route.provider,
-        model: route.model,
-        system: 'You produce strict JSON only. You never add prose around it.',
-        messages: [request],
-        maxTokens: consolidation.maxOutputTokens,
-        purpose: 'memory-consolidation',
-        signal: controller.signal,
-      })) {
-        assembler.push(chunk)
+      let assembled
+      try {
+        const { createUserMessage, BlockAssembler } = await import('@deepseek-ai/dsh-llm')
+        const assembler = new BlockAssembler()
+        const request = createUserMessage({
+          content: [{ type: 'text', text: `${consolidationInstruction(consolidation.maxWorkUnitsPerRun)}\n\n<transcript>\n${transcript}\n</transcript>` }],
+          source: { kind: 'plugin', plugin: PLUGIN_NAME },
+        })
+        for await (const chunk of llm.stream({
+          provider: route.provider,
+          model: route.model,
+          system: 'You produce strict JSON only. You never add prose around it.',
+          messages: [request],
+          maxTokens: consolidation.maxOutputTokens,
+          purpose: 'memory-consolidation',
+          signal: controller.signal,
+        })) {
+          assembler.push(chunk)
+        }
+        assembled = assembler
+      } finally {
+        clearTimeout(timer)
       }
-      assembled = assembler
-    } finally {
-      clearTimeout(timer)
-    }
-    const finish = assembled.finish
-    if (finish.kind !== 'stop') {
-      if (finish.kind === 'max-tokens') {
-        throw new PermanentConsolidationError('consolidation hit the output token cap (truncated JSON)')
+      // The attempt stays open through parsing: a stream that ended with `stop`
+      // but yields no usable summary is `incomplete`, not `ok` — the cursor was
+      // consumed, nothing was stored, and a table that said otherwise would
+      // send a reader looking for a summary that does not exist. The throws are
+      // re-issued unchanged, so recording never changes which error the queue
+      // sees.
+      const finish = assembled.finish
+      if (finish.kind !== 'stop') {
+        // The thrown message is computed exactly as it was before this attempt
+        // was recorded: `error` AND `aborted` carry the provider's reason, and
+        // losing it for `aborted` would replace a timeout with a bare
+        // 'aborted' in the task row. `detail` uses the same message; `finish`
+        // caps it.
+        const message = finish.kind === 'error' || finish.kind === 'aborted'
+          ? finish.failure?.message ?? finish.kind
+          : finish.kind
+        if (finish.kind === 'error') outcome = 'error'
+        detail = String(message)
+        throw finish.kind === 'max-tokens'
+          ? new PermanentConsolidationError('consolidation hit the output token cap (truncated JSON)')
+          : new Error(`consolidation model call failed: ${message}`)
+      }
+      const text = assembled.blocks()
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('\n')
+      try {
+        parsedOutput = parseConsolidationOutput(text, consolidation.maxWorkUnitsPerRun)
+      } catch (parseError) {
+        // A parse failure is an unusable reply, not a failed call, and its
+        // message quotes the reply — so it never becomes `detail`. See the
+        // `detail` contract in model-log.js.
+        detail = 'unusable output'
+        throw parseError
       }
-      const message = finish.kind === 'error' || finish.kind === 'aborted' ? finish.failure?.message ?? finish.kind : finish.kind
-      throw new Error(`consolidation model call failed: ${message}`)
+      outcome = 'ok'
+    } catch (error) {
+      // Only a throw that arrived with nothing classified is a failed call
+      // rather than an unusable reply.
+      if (outcome === 'incomplete' && detail === '') {
+        outcome = 'error'
+        detail = error instanceof Error ? error.message : String(error)
+      }
+      throw error
+    } finally {
+      void attempt.finish(outcome, detail)
     }
-    const text = assembled.blocks()
-      .filter((block) => block.type === 'text')
-      .map((block) => block.text)
-      .join('\n')
-    const { summary, workUnits } = parseConsolidationOutput(text, consolidation.maxWorkUnitsPerRun)
+    const { summary, workUnits } = parsedOutput
 
     const span = summaryName(task.sessionId, fromSeq, coveredToSeq)
     // The entries the log executor actually wrote for this span. Both sides

package/src/content-policy.js

@@ -277,7 +277,11 @@ export function blocksToText(blocks) {
   for (const block of blocks ?? []) {
     if (block.type === 'text') parts.push(block.text)
     else if (block.type === 'image') parts.push('[image]')
-    else if (block.type === 'thinking') parts.push(`[thinking: ${String(block.text ?? '').slice(0, 200)}]`)
+    // Thinking / reasoning blocks are internal monologue, not something the
+    // assistant said to the user. Including them created `[reasoning]`
+    // placeholder entries with no substantive content; skip them so only the
+    // final text / image output reaches the log.
+    else if (block.type === 'thinking' || block.type === 'reasoning') continue
     else if (block.type === 'tool-result') parts.push(blocksToText(block.content ?? []))
     // A tool-call block is the model asking for a tool, not something it said.
     // Rendered as `[tool-call]` it filled the content of half the stored

package/src/index.js

@@ -37,6 +37,7 @@ import { TaskDeferredError, createQueue } from './queue.js'
 import { countLoggableMessages, createCollector, formatSpan } from './collector.js'
 import { createCascade } from './cascade.js'
 import { createConsolidator, PLUGIN_NAME } from './consolidator.js'
+import { openModelLog } from './model-log.js'
 import { createRecall } from './recall.js'
 import { createPersistedSessions } from './persisted-session.js'
 import { createAutoApprove } from './auto-approve.js'
@@ -93,6 +94,20 @@ function applyCollect(ctx, cordisConfig) {
       progress: shelfTable(openedState.progress, shelf),
       tasks: shelfTable(openedState.tasks, shelf),
     }
+    // Which model a background attempt ran on is otherwise unknowable from
+    // outside the process: the cursor that picks it is process-local, the host
+    // logger scrolls away, and the usage ledger cannot see plugin calls. Kept in
+    // its own domain so a diagnostics row can never reject the open of the
+    // watermarks (see model-log.js). Not shelf-scoped: the route list is config,
+    // and the question is about this process, not this shelf.
+    const openedModelLog = await openModelLog(ctx, { status })
+    if (disposed) {
+      // Same race as the state domain above: if the fiber went away while this
+      // was opening, its disposer may never run, so close the handle here.
+      await openedModelLog.domain?.close().catch(() => {})
+      return
+    }
+    const modelLog = openedModelLog.modelLog
     let announcedShelf = shelf
     configHandle.onChange((value) => {
       if (value.shelf === announcedShelf) return
@@ -364,6 +379,7 @@ function applyCollect(ctx, cordisConfig) {
           writer,
           getConfig: configHandle.get,
           status,
+          modelLog,
           projectFor: collector.projectFor,
         })
         queue.registerExecutor('consolidate', consolidator.execute)
@@ -376,6 +392,7 @@ function applyCollect(ctx, cordisConfig) {
           selectRoute: consolidator.selectRoute,
           getConfig: configHandle.get,
           status,
+          modelLog,
         })
         queue.registerExecutor('cascade', cascade.execute)
         shared.consolidator = consolidator