dsh-hypatia-auto-memory 0.3.0 → 0.5.0

package/src/client/locales.ts

@@ -53,6 +53,46 @@ export const zh = {
   saveFailed: '保存失败：{message}',
   readOnly: '只读：当前上下文不可写入设置文档。',
   unsaved: '未保存',
+  viewMemory: '记忆',
+  memoryTitle: '本会话的记忆',
+  memoryUpdatedAt: '状态更新于 {time}',
+  memoryRefresh: '刷新',
+  memoryLoading: '正在读取记忆状态…',
+  memoryNoSnapshot: '插件还没有发布记忆状态。启用后完成一轮对话再回来看看。',
+  memoryLoadFailed: '无法读取记忆状态：{message}',
+  memoryUnknown: '这个会话还没有记忆记录。第一轮对话结束后会开始记录。',
+  memoryLogged: '对话记录',
+  memorySeqValue: '第 {seq} 条事件',
+  memoryConsolidated: '摘要整合',
+  memoryCaughtUp: '已结清',
+  memoryBehind: '较记录落后 {behind} 条',
+  memoryPending: '待整合内容',
+  memoryPendingValue: '约 {tokens} token',
+  memorySessionNode: '会话节点',
+  memorySessionNodeYes: '已建立',
+  memorySessionNodeNo: '未建立（宿主未提供会话摘要）',
+  memoryBelongTo: '已链接消息',
+  memoryBelongToValue: '{count} 条',
+  memoryDeferred: '等待会话载入的任务',
+  memoryFailedTitle: '失败任务',
+  memoryFailedItem: '{kind} 连续失败 {attempts} 次',
+  memoryContentTitle: '记忆内容',
+  memoryContentFailed: '无法读取 shelf 中的记忆内容：{message}',
+  memorySummariesTitle: '跨度摘要',
+  memoryWorkUnitsTitle: '工作单元',
+  memoryNoSummaries: '这个会话还没有产生摘要。整合运行后会出现在这里。',
+  memoryNoWorkUnits: '这个会话还没有提炼出工作单元。',
+  memoryCount: '显示 {shown} / 共 {total}',
+  memoryTier: '{level} 级',
+  memoryWorkUnit: '工作单元',
+  memoryEntryExpand: '展开',
+  memoryEntryCollapse: '收起',
+  memoryEntryEmpty: '这条条目的正文为空，或已超过展示上限。',
+  memoryCopyCode: '复制',
+  memoryCopiedCode: '已复制',
+  memoryFootnotes: '脚注',
+  memoryTruncated: '内容超出展示上限，较早的条目或过长的正文已被截断。',
+  memoryHint: '诊断视图：原始 msg-* 对话正文不在此显示，需要时让 Agent 通过 hypatia 检索。状态每 5 秒重读一次；「状态更新于」是宿主最近一次看到这些状态发生变化的时间（首次读取也算一次），不变说明这段时间没有新进展。两个条数都按会话日志的事件序号计（含工具调用，不是消息条数），所以它们之差就是还没总结的部分。',
 } as const satisfies Record<string, string>
 
 /** Key domain of the `hypatia-auto-memory` namespace. */
@@ -108,4 +148,44 @@ export const en = {
   saveFailed: 'Save failed: {message}',
   readOnly: 'Read-only: settings document is not writable in this context.',
   unsaved: 'Unsaved',
+  viewMemory: 'Memory',
+  memoryTitle: 'This session\'s memory',
+  memoryUpdatedAt: 'State updated {time}',
+  memoryRefresh: 'Refresh',
+  memoryLoading: 'Reading memory status…',
+  memoryNoSnapshot: 'The plugin has not published a status snapshot yet. Enable it, finish a turn, and come back.',
+  memoryLoadFailed: 'Unable to read memory status: {message}',
+  memoryUnknown: 'This session has no memory record yet. Logging starts once the first turn ends.',
+  memoryLogged: 'Conversation log',
+  memorySeqValue: 'event {seq}',
+  memoryConsolidated: 'Summarisation',
+  memoryCaughtUp: 'caught up',
+  memoryBehind: '{behind} events behind the log',
+  memoryPending: 'Waiting to summarise',
+  memoryPendingValue: '~{tokens} tokens',
+  memorySessionNode: 'Session node',
+  memorySessionNodeYes: 'created',
+  memorySessionNodeNo: 'not created (the Host supplied no session summary)',
+  memoryBelongTo: 'Linked messages',
+  memoryBelongToValue: '{count}',
+  memoryDeferred: 'Tasks waiting for the session to load',
+  memoryFailedTitle: 'Failed tasks',
+  memoryFailedItem: '{kind} failed {attempts} times',
+  memoryContentTitle: 'Memory content',
+  memoryContentFailed: 'Unable to read memory content from the shelf: {message}',
+  memorySummariesTitle: 'Span summaries',
+  memoryWorkUnitsTitle: 'Work units',
+  memoryNoSummaries: 'This session has produced no summary yet. They appear here once consolidation runs.',
+  memoryNoWorkUnits: 'This session has yielded no work units yet.',
+  memoryCount: 'showing {shown} of {total}',
+  memoryTier: 'tier {level}',
+  memoryWorkUnit: 'work unit',
+  memoryEntryExpand: 'Expand',
+  memoryEntryCollapse: 'Collapse',
+  memoryEntryEmpty: 'This entry has no body, or it exceeded the display cap.',
+  memoryCopyCode: 'Copy',
+  memoryCopiedCode: 'Copied',
+  memoryFootnotes: 'Footnotes',
+  memoryTruncated: 'Content exceeded the display cap: earlier entries or over-long bodies were cut.',
+  memoryHint: 'Diagnostic view: raw msg-* conversation text is not shown here — ask the agent to retrieve it through hypatia. Status is re-read every 5 seconds; the timestamp is when the Host last saw that state change (the first read counts as one), so an unchanged one means nothing new happened. Both counts index the session log\'s event sequence (tool calls included, not messages), so their difference is what is left to summarise.',
 } satisfies Record<AutoMemoryLocaleKey, string>

package/src/client/memory-client.ts

@@ -0,0 +1,246 @@
+/**
+ * The Memory tab's read side: one same-origin request per refresh.
+ *
+ * The Host half serves it from `/api/dsh-hypatia-auto-memory/session`
+ * (see `src/memory-api.js`), which is parameterized by session and authenticates
+ * itself — unlike a settings namespace, it can answer for the one session the
+ * tab is bound to instead of shipping every session's state to the browser.
+ *
+ * Zero runtime imports beyond `fetch`, so the parsing half is unit-tested under
+ * `node:test` like `shelves.ts`.
+ */
+
+/** Route prefix the Host claims; the tab appends `/session`. */
+export const MEMORY_API_PREFIX = '/api/dsh-hypatia-auto-memory'
+
+/** One task that exhausted its attempts. */
+export interface FailedMemoryTask {
+  kind: string
+  sessionId: string
+  attempts: number
+  error: string
+}
+
+/** What the Host derived for one session out of the state tables. */
+export interface SessionMemoryStatus {
+  sessionId: string
+  /** False when the Host has no row and no task for this session yet. */
+  known: boolean
+  loggedSeq: number
+  consolidatedSeq: number
+  /** True when consolidation has covered everything logged. */
+  caughtUp: boolean
+  pendingTokens: number
+  sessionNode: boolean
+  belongTo: number
+  deferred: number
+  failed: number
+  failedTasks: FailedMemoryTask[]
+  error: string
+}
+
+/** One distilled entry: a span summary or a work unit. */
+export interface MemoryEntry {
+  name: string
+  /** Markdown body, already capped by the Host. */
+  markdown: string
+  /** Archive tier, summaries only; 1 condenses messages. */
+  level: number
+  createdAt: string
+}
+
+/**
+ * The shelf half of a response.
+ *
+ * Kept as one object rather than spread across the payload so "the Host did not
+ * read the shelf" is representable: the five-second poll asks for status only,
+ * and a reader that cannot tell that apart from "the shelf is empty" wipes the
+ * content it already showed.
+ */
+export interface MemoryContent {
+  summaries: MemoryEntry[]
+  workUnits: MemoryEntry[]
+  /** How many the shelf holds, before the response caps. */
+  summaryCount: number
+  workUnitCount: number
+  /** True when a cap dropped entries or cut a body short. */
+  truncated: boolean
+  /** Non-empty when the shelf could not be read; the status half is still valid. */
+  error: string
+}
+
+/** One response from the Host. */
+export interface MemoryPayload {
+  session: SessionMemoryStatus
+  /** Epoch milliseconds the Host last saw this session's status change. */
+  updatedAt: number
+  /** Absent when this response carried status only. */
+  content: MemoryContent | undefined
+}
+
+/** Read one session's memory. `content` also asks the Host to read the shelf. */
+export type FetchMemory = (sessionId: string, options: { content: boolean }) => Promise<MemoryPayload>
+
+/**
+ * The URL one refresh reads.
+ * @param sessionId - the session the tab is bound to.
+ * @param content - whether to ask the Host to read the shelf as well.
+ * @returns a same-origin path with its query.
+ */
+export function memoryUrl(sessionId: string, content: boolean): string {
+  const query = new URLSearchParams({ session: sessionId })
+  if (content) query.set('content', '1')
+  return `${MEMORY_API_PREFIX}/session?${query.toString()}`
+}
+
+/** Fetch one session's memory from the Host. */
+export const fetchMemory: FetchMemory = async (sessionId, { content }) => {
+  const response = await fetch(memoryUrl(sessionId, content), {
+    method: 'GET',
+    credentials: 'same-origin',
+    headers: { accept: 'application/json' },
+  })
+  const body: unknown = await response.json().catch(() => undefined)
+  if (!response.ok) {
+    const message = isRecord(body) && typeof body.error === 'string' ? body.error : `HTTP ${String(response.status)}`
+    throw new Error(message)
+  }
+  const payload = parseMemoryPayload(body, sessionId)
+  if (payload === undefined) throw new Error('the Host returned an unreadable memory payload')
+  return payload
+}
+
+/**
+ * Session-log events that are recorded but not yet consolidated.
+ *
+ * Both watermarks index the same log, so their difference is exactly the work
+ * consolidation still owes. Clamped at zero: a consolidation run may cover a
+ * range the logging watermark has not caught up to yet, which is not a backlog.
+ *
+ * @param session - the session half of a payload.
+ * @returns the gap in session-log events.
+ */
+export function consolidationGap(session: SessionMemoryStatus): number {
+  return Math.max(0, session.loggedSeq - session.consolidatedSeq)
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function num(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0
+}
+
+function str(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function parseFailedTasks(value: unknown): FailedMemoryTask[] {
+  if (!Array.isArray(value)) return []
+  return value.flatMap((entry): FailedMemoryTask[] => isRecord(entry)
+    ? [{
+        kind: str(entry.kind),
+        sessionId: str(entry.sessionId),
+        attempts: num(entry.attempts),
+        error: str(entry.error),
+      }]
+    : [])
+}
+
+function parseEntries(value: unknown): MemoryEntry[] {
+  if (!Array.isArray(value)) return []
+  return value.flatMap((entry): MemoryEntry[] => {
+    if (!isRecord(entry)) return []
+    const name = str(entry.name)
+    if (name === '') return []
+    return [{
+      name,
+      markdown: str(entry.markdown),
+      level: num(entry.level) || 1,
+      createdAt: str(entry.createdAt),
+    }]
+  })
+}
+
+/**
+ * Read the Host's answer into the tab's shape, defensively.
+ *
+ * A malformed field falls back to its zero value rather than reaching the DOM;
+ * a payload with no usable `session` is rejected outright, because rendering a
+ * panel of zeros for a session the Host never answered about would be a lie.
+ *
+ * A status-only answer parses to `content: undefined` — never to empty lists,
+ * which is what made the five-second poll erase the shelf content. The Host also
+ * states which half it sent (`content`), and that flag is what this prefers; the
+ * key sniffing beside it keeps a bundle built after the flag from misreading a
+ * Host that predates it, so the fix does not need a profile restart to land.
+ *
+ * @param value - the parsed response body.
+ * @param sessionId - the session that was asked for.
+ * @returns the payload, or undefined when the body is not one.
+ */
+export function parseMemoryPayload(value: unknown, sessionId: string): MemoryPayload | undefined {
+  if (!isRecord(value) || !isRecord(value.session)) return undefined
+  const session = value.session
+  const carried = value.content === true
+    || Object.hasOwn(value, 'summaries')
+    || Object.hasOwn(value, 'contentError')
+  return {
+    session: {
+      sessionId: str(session.sessionId) || sessionId,
+      known: session.known === true,
+      loggedSeq: num(session.loggedSeq),
+      consolidatedSeq: num(session.consolidatedSeq),
+      caughtUp: session.caughtUp === true,
+      pendingTokens: num(session.pendingTokens),
+      sessionNode: session.sessionNode === true,
+      belongTo: num(session.belongTo),
+      deferred: num(session.deferred),
+      failed: num(session.failed),
+      failedTasks: parseFailedTasks(session.failedTasks),
+      error: str(session.error),
+    },
+    updatedAt: num(value.updatedAt),
+    content: carried
+      ? {
+          summaries: parseEntries(value.summaries),
+          workUnits: parseEntries(value.workUnits),
+          summaryCount: num(value.summaryCount),
+          workUnitCount: num(value.workUnitCount),
+          truncated: value.truncated === true,
+          error: str(value.contentError),
+        }
+      : undefined,
+  }
+}
+
+/**
+ * Fold a new answer onto the one on screen.
+ *
+ * Status is always the newest. Content is only replaced by an answer that
+ * carried content, so the poll cannot erase it. An answer whose shelf read
+ * failed keeps the content already shown — entries, counts and the truncation
+ * flag together, so the header still describes the list under it — and records
+ * the error beside it, because a transient hypatia failure should not blank
+ * what the reader was looking at.
+ *
+ * @param previous - the payload on screen, if any.
+ * @param next - the answer just parsed.
+ * @returns the payload to render.
+ */
+export function mergeMemory(
+  previous: MemoryPayload | undefined,
+  next: MemoryPayload,
+): MemoryPayload {
+  if (next.content === undefined) return { ...next, content: previous?.content }
+  // A failed read keeps whatever was on screen — the entries AND the counts that
+  // describe them — and replaces only the reason. The guard must not consult the
+  // previous error: on the SECOND consecutive failure it is already set, and
+  // testing for it fell through to the zeroed answer, blanking the panel the
+  // first failure had deliberately preserved.
+  if (next.content.error !== '' && previous?.content !== undefined) {
+    return { ...next, content: { ...previous.content, error: next.content.error } }
+  }
+  return next
+}

package/src/consolidator.js

@@ -19,9 +19,32 @@ import { countLoggableMessages, isCompactionReplacement, isLoggableMessage } fro
 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) {
@@ -263,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
@@ -388,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({
@@ -401,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)
     }
   }
 
@@ -491,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