Merge remote-tracking branch 'origin/master' into codex/basic-session-search

Conflict resolutions:

- `session.list`: master's projection columns fold into the PR's cancellable,
  batched `listVisibleSessionSummaries`, which `session.search` shares as its
  visibility baseline; master's goal helpers stay beside it.
- Client sessions face: master narrowed `ctx.sessions` to `ISessions`, so the
  search verb and its protocol-constant bound are declared there and the
  test-runtime double implements them (recorded, empty page unless a scenario
  stubs hits).
- `WorkspaceBrowser`: master's per-row Rename wiring rides the PR's search
  results view; the tree keeps the PR's query-free derivations.
- `dsh web` bin: the PR's shutdown-handlers-before-readiness order with
  master's boot-time LAN address snapshot.
- `session-query-sqlite`: master's `SCHEMA_VERSION` 7 stands; the PR's bump
  carried no schema change.
- Specs: master wraps assistant/steering message payloads and requires an
  `application/json` carrier request, so the search fixtures and tests follow.
- Web aria goldens keep master's recording plus the PR's search placeholder;
  the navigation-panes inventory keeps master's terminal-card golden next to
  the PR's search-results golden.

packages/session-query/session-query/README.i18n.yaml

@@ -3,4 +3,4 @@
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/session-query/session-query/README.md
 README.md: df97333be3b2c2cf71dd8c9287959bcbd83a5063
-README.zh.md: cc79a6f48b4c997a4e940f99aaab169291e2b900
+README.zh.md: 1a3df1ce38360975d88a9f578b071b29cefbba0f

packages/session-query/session-query/README.zh.md

@@ -10,47 +10,47 @@
 - `readSession(sessionId)` 在执行与恢复相同的核心回放验证后，返回一份完整、脱离存储的原始日志；它绝不会将该会话放入实时存储。
 - `filterSessions(filters, signal?)` 对同一份克隆逻辑语料库应用与提供方无关的会话元数据和可用性谓词。
 - `filterEvents(sessionId, filters)` 提取第一方语义文档，并按 seq 升序应用与提供方无关的元数据和字面文本谓词。
-- `readTitleSnapshots(sessionIds, signal?)` 从一次实时优先的语料库观察中解析唯一 id，将取消传递给持久化列表和检查，并按顺序返回每个会话的结算结果，使某个缺失或格式错误的标题来源不会丢弃其他来源。每个实时来源直接 fold，每个持久化 worker fold 为脱离存储的 header/标题结果，并在出队下一个 id 前释放完整日志。取消会拒绝整个批次。`readTitleSnapshot(sessionId, signal?)` 是单次观察视图；`readTitle(sessionId, signal?)` 只返回其可选的 folded `session/title`。
-- `listEvents(sessionId)` 加载实时优先的原始日志，将每个事件分类为 `current`、`shadowed` 或 `log-only`；该分类使用共享 `dsh-session` 接口 fold。
-- `readSurface(sessionId)` 返回一个克隆 header、原始日志捕获边界，以及按模型历史顺序排列的完整 folded 当前接口。实时会话优先于持久化；压缩只会在其替换追加之前或之后被观察，绝不会出现合成混合。
+- `readTitleSnapshots(sessionIds, signal?)` 从一次实时优先的语料库观察中解析唯一 id，将取消信号传递给持久化列表查询和检查，并按顺序返回每个会话的结算结果，使某个缺失或格式错误的标题来源不会丢弃其他来源。每个实时来源直接 fold，每个持久化 worker fold 为脱离存储的 header/标题结果，并在出队下一个 id 前释放完整日志。取消会拒绝整个批次。`readTitleSnapshot(sessionId, signal?)` 是单次观察视图；`readTitle(sessionId, signal?)` 只返回其可选的 folded `session/title`。
+- `listEvents(sessionId)` 加载实时优先的原始日志，将每个事件分类为 `current`、`shadowed` 或 `log-only`；该分类使用共享 `dsh-session` 表层 fold。
+- `readSurface(sessionId)` 返回一个克隆 header、原始日志捕获边界，以及按模型历史顺序排列的完整折叠后当前表层。实时会话优先于持久化；压缩（compaction）只会在其替换追加之前或之后被观察，绝不会出现合成混合。
 - `readEvent(request, signal?)` 返回一个克隆 header、完整目标事件和有界的原始 seq 窗口。`before` 和 `after` 默认为 0，且不得超过 `readWindowMax`。
-- `traceSession(sessionId, signal?)` 只读取一次语料库，返回从直接到向外的祖先，以及确定性的递归后代树。`complete: false` 标识第一个缺失父级；与目标相连的循环会以 `SESSION_QUERY_INVALID_LINEAGE` 失败。
+- `traceSession(sessionId, signal?)` 只读取一次语料库，返回从直接父级向外的祖先，以及确定性的递归后代树。`complete: false` 标识第一个缺失父级；与目标相连的循环会以 `SESSION_QUERY_INVALID_LINEAGE` 失败。
 - `traceEvent(request, signal?)` 只加载一次逻辑日志，返回其克隆源 header、直接位置替换和直接已记录来源信息。`replacementChain` 沿位置替换者跟踪到最终替换；来源链接仍不传递。
 
-持久化是可选的，可动态挂载或卸载。已挂载持久化无法读取时，跨语料库列表和血缘跟踪以 `SESSION_QUERY_PERSISTENCE_FAILED` 失败。针对已知实时会话的标题读取、事件跟踪或事件读取不会查询持久化，因此持久后端的健康状态无法使当前内存状态变得不可读。持久化标题和事件操作在加载前列表，并在元数据不匹配时拒绝，而不会组合不一致的观察。血缘跟踪取消传递到持久化列表；事件跟踪和事件读取取消传递到持久化列表和检查。每项操作都会等待已启动的后端调用结算，然后使用信号的精确原因拒绝，即使后端忽略了该信号。预先中止的已知实时标题读取、事件跟踪或事件读取会在 fold 或快照之前拒绝，且不查询持久化。批量标题观察执行一次元数据列表，使用最多 `persistedInspectConcurrency` 个 worker 检查唯一持久化 id，并保留每个标题自己观察到的 header，供下游授权使用。取消不会启动已排队检查，且只在已启动 worker 结算后拒绝。`listSessions()` 仍保持轻量，不加载日志或索引标题。
+持久化是可选的，可动态挂载或卸载。已挂载持久化无法读取时，跨语料库列表和血缘跟踪以 `SESSION_QUERY_PERSISTENCE_FAILED` 失败。针对已知实时会话的标题读取、事件跟踪或事件读取不会查询持久化，因此持久化后端的健康状态无法使当前内存状态变得不可读。持久化标题和事件操作在加载前先执行列表查询，并在元数据不匹配时拒绝，而不会组合不一致的观察。血缘跟踪的取消信号会传递给持久化列表查询；事件跟踪和事件读取的取消信号会传递给持久化列表查询和检查。每项操作都会等待已启动的后端调用结算，然后使用信号的精确原因拒绝，即使后端忽略了该信号。针对已知实时会话且预先中止的标题读取、事件跟踪或事件读取会在 fold 或快照之前拒绝，且不查询持久化。批量标题观察执行一次元数据列表查询，使用最多 `persistedInspectConcurrency` 个 worker 检查唯一持久化 id，并保留每个标题自己观察到的 header，供下游授权使用。取消不会启动已排队检查，且只在已启动 worker 结算后拒绝。`listSessions()` 仍保持轻量，不加载日志或索引标题。
 
 ## 过滤与提取
 
-`SessionResultFilter` 覆盖 id、可空 cwd、创建时间范围、可空父级和来源可用性。`SessionEventResultFilter` 覆盖 seq/时间范围、事件类型、接口和语义文本。过滤器数组使用 AND；同一列表子句内的值使用 OR。空列表值不匹配任何内容，范围包含端点，而格式错误的范围或封闭联合值以 `SESSION_QUERY_INVALID_FILTER` 失败。
+`SessionResultFilter` 覆盖 id、可空 cwd、创建时间范围、可空父级和来源可用性。`SessionEventResultFilter` 覆盖 seq/时间范围、事件类型、表层和语义文本。过滤器数组使用 AND；同一列表子句内的值使用 OR。空列表值不匹配任何内容，范围包含端点，而格式错误的范围或封闭联合值以 `SESSION_QUERY_INVALID_FILTER` 失败。
 
-文本子句刻意与 FTS 提供方无关：调用方文本会被转义为不区分大小写的 Unicode 正则表达式，每个空白运行匹配一个或多个空白字符。它是字面语义文本扫描，而非全文查询。`extractSessionEventText()` 和 `buildSessionEventSearchDocuments()` 定义共享的第一方文档投影；推理（reasoning）块、结构边界、流分片、请求 header 和未知声明合并变体不产生文档。
+文本子句刻意与 FTS 提供方无关：调用方文本会被转义为不区分大小写的 Unicode 正则表达式，每段连续空白匹配一个或多个空白字符。它是字面语义文本扫描，而非全文查询。`extractSessionEventText()` 和 `buildSessionEventSearchDocuments()` 定义共享的第一方文档投影；推理（reasoning）块、结构边界、流分片、请求 header 和未知声明合并变体不产生文档。
 
 ## 全文方法
 
-`SessionQueryService.searchSessions(request, exec?)` 按匹配最强的事件对逻辑语料库分组；`searchEvents(request, exec?)` 搜索一个逻辑会话。这两个是服务仅有的抽象方法。两者都返回分页结果，其延续信息是自有的品牌化 `SessionSearchCursor`；接受可选取消，并在不使用提供方专用数值分数的情况下公开 snippet。事件搜索分页结果还携带来自与命中相同索引世代的克隆目标 header，使授权消费方可将策略绑定到 payload 观察。搜索请求只接受元数据事件过滤器，因为字面文本过滤使用上文所述扫描路径。
+`SessionQueryService.searchSessions(request, exec?)` 按匹配最强的事件对逻辑语料库分组；`searchEvents(request, exec?)` 搜索一个逻辑会话。这两个是服务仅有的抽象方法。两者都返回分页结果，其延续信息是由服务持有的带品牌 `SessionSearchCursor`；接受可选取消，并在不使用提供方专用数值分数的情况下提供摘录。事件搜索分页结果还携带来自与命中相同索引世代的克隆目标 header，使授权消费方可将策略绑定到此次载荷观察。搜索请求只接受事件元数据过滤器，因为字面文本过滤使用上文所述扫描路径。
 
-该包没有提供方协调器、回退实现或独立具体插件。具体服务后端继承已实现的读取、过滤和跟踪，同时负责全文观察、对账、排名、游标世代和查询执行；第一个实现是 [`@deepseek-ai/dsh-session-query-sqlite`](../session-query-sqlite/README.md)。
+该包（package）没有提供方协调器、回退实现或独立具体插件。具体服务后端继承已实现的读取、过滤和跟踪，同时负责全文观察、对账、排名、游标世代和查询执行；第一个实现是 [`@deepseek-ai/dsh-session-query-sqlite`](../session-query-sqlite/README.md)。
 
-`SessionQueryError.code` 是一个封闭联合，覆盖请求验证、缺失目标、格式错误的接口、来源冲突、持久化/索引失败、取消，以及无效或陈旧游标；精确字面值在 [`src/config.ts`](src/config.ts) 中定义。
+`SessionQueryError.code` 是一个封闭联合，覆盖请求验证、缺失目标、格式错误的表层、来源冲突、持久化/索引失败、取消，以及无效或陈旧游标；精确字面值在 [`src/config.ts`](src/config.ts) 中定义。
 
-`listEvents()`、`readSurface()` 和 `traceEvent()` 执行同一个单遍 `dsh-session` 接口 fold。只有当事件 seq 从零开始且连续、接口标记符合事件类型资格、来源数组非空且无重复、引用指向较早事件，且每个位置替换都命名并引用它移除的每个接口节点时，加载的日志才有效；任何违规都以 `SESSION_QUERY_INVALID_SURFACE` 失败。
+`listEvents()`、`readSurface()` 和 `traceEvent()` 执行同一个单遍 `dsh-session` 表层 fold。只有当事件 seq 从零开始且连续、表层标记符合事件类型的适用性要求、来源数组非空且无重复、引用指向较早事件，且每个位置替换都命名并引用它移除的每个表层节点时，加载的日志才有效；任何违规都以 `SESSION_QUERY_INVALID_SURFACE` 失败。
 
 ## 配置
 
 | 键 | 默认值 | 契约 |
 |---|---:|---|
 | `readWindowMax` | `50` | `before` 或 `after` 的最大原始事件数。 |
-| `persistedInspectConcurrency` | `4` | 一次批量读取中的最大并发持久化日志检查数；必须是正安全整数。 |
+| `persistedInspectConcurrency` | `4` | 一次批量读取中的最大并发持久化日志检查数；必须是正的安全整数。 |
 
 ## 模型体验
 
 无。该可信查询服务只向调用方返回克隆会话记录，不注册面向模型的提示词、schema、工具或消息。
 
-#### KV 缓存影响
+#### KV Cache 影响
 
 无；该包既不组装也不发送提供方请求。
 
-## 已知限制与待完成工作
+## 已知限制与暂缓事项
 
 - **无调用方授权**：这是上下文范围内的可信基础设施；未来的模型工具或 UI 必须限制调用方可检查的会话。
 - **无注册表或面向模型工具**：尚未提供提取器和搜索提供方注册表、递归事件来源遍历以及面向模型的工具。[跟踪决策](../../../.agents/notes/implemented/feature/2026-07-13-session-query-tracing.md) 负责关系语义；SQLite 归属和 tokenizer 决策位于[已实现搜索记录](../../../.agents/notes/implemented/feature/2026-07-10-sqlite-session-query-provider.md)。

packages/session-query/session-query/src/config.ts

@@ -39,7 +39,7 @@ export class SessionQueryError extends HarnessError {
   declare readonly code: SessionQueryErrorCode
 
   // The base stores the value; this signature narrows its open string code.
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  // oxlint-disable-next-line typescript/no-useless-constructor
   constructor(message: string, code: SessionQueryErrorCode, options?: ErrorOptions) {
     super(message, code, options)
   }

packages/session-query/session-query/src/extraction.ts

@@ -13,14 +13,15 @@ import type { SessionEvent } from '@deepseek-ai/dsh-session'
 export function extractSessionEventText(event: SessionEvent): string {
   switch (event.type) {
     case 'user/message':
+      return contentText(event.data.content)
     case 'assistant/message':
     case 'steering/message':
-      return contentText(event.data.content)
+      return contentText(event.data.message.content)
     case 'tool/call':
       return joinText([event.data.name, event.data.arguments])
     case 'tool/result':
       return joinText([
-        contentText(event.data.content),
+        contentText(event.data.message.content),
         event.data.error?.name ?? '',
         event.data.error?.code ?? '',
       ])

packages/session-query/session-query/src/index.ts

@@ -5,7 +5,7 @@
  */
 
 import { Context, Service } from 'cordis'
-import { Session, type SessionId } from '@deepseek-ai/dsh-session'
+import { Session, snapshotSessionEvent, type SessionId } from '@deepseek-ai/dsh-session'
 import { foldSessionTitle } from '@deepseek-ai/dsh-session-title'
 import type { SessionTitleSnapshot } from '@deepseek-ai/dsh-session-title'
 import type {
@@ -146,7 +146,7 @@ export abstract class SessionQueryService extends Service {
     new Session(sessionId, loaded.events, loaded.header)
     return {
       session: structuredClone(loaded.header),
-      events: loaded.events.map(event => structuredClone(event)),
+      events: loaded.events.map(snapshotSessionEvent),
     }
   }
 
@@ -330,10 +330,15 @@ export abstract class SessionQueryService extends Service {
     }
     const startSeq = Math.max(0, seq - before)
     const endSeq = Math.min(loaded.events.length - 1, seq + after)
+    const targetSnapshot = snapshotSessionEvent(target)
+    const events = loaded.events.slice(startSeq, endSeq + 1)
+      .map(event => event === target
+        ? targetSnapshot
+        : snapshotSessionEvent(event))
     return {
-      session: loaded.header,
-      target,
-      events: loaded.events.slice(startSeq, endSeq + 1),
+      session: structuredClone(loaded.header),
+      target: targetSnapshot,
+      events,
       startSeq,
       endSeq,
     }

packages/session-query/session-query/src/tracing.ts

@@ -1,6 +1,6 @@
 /** One-shot session-lineage and event-relationship tracing helpers. */
 
-import { foldSurface, isSurfaceEvent } from '@deepseek-ai/dsh-session'
+import { foldSurface, isSurfaceEvent, snapshotSessionEvent } from '@deepseek-ai/dsh-session'
 import type { SessionEvent, SessionId, SurfaceEvent, SurfaceEventType } from '@deepseek-ai/dsh-session'
 import { SessionQueryError } from './config.ts'
 import type {
@@ -51,7 +51,7 @@ export function currentSurfaceEvents(
         'SESSION_QUERY_INVALID_SURFACE',
       )
     }
-    return structuredClone(event)
+    return snapshotSessionEvent(event)
   })
 }
 
@@ -91,7 +91,7 @@ export function traceEvent(
   }
 
   // The target check above proves the parallel record exists at this index.
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  // oxlint-disable-next-line typescript/no-non-null-assertion
   const targetRecord = analysis.records[seq]!
   const replacedBy = analysis.replacedBy.get(seq)
   return {
@@ -225,7 +225,7 @@ function buildDescendants(
   const stack = [{ sessionId, descendants }]
   while (stack.length > 0) {
     // The length guard proves a frame exists.
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    // oxlint-disable-next-line typescript/no-non-null-assertion
     const frame = stack.pop()!
     const nodes: SessionLineageNode[] = []
     for (const child of childrenByParent.get(frame.sessionId) ?? []) {
@@ -235,7 +235,7 @@ function buildDescendants(
     }
     for (let index = nodes.length - 1; index >= 0; index -= 1) {
       // The loop bounds prove this indexed node exists.
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      // oxlint-disable-next-line typescript/no-non-null-assertion
       const node = nodes[index]!
       stack.push({ sessionId: node.session.header.id, descendants: node.descendants })
     }

packages/session-query/session-query/tests/search-helpers.spec.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
-import { CallId } from '@deepseek-ai/dsh-llm'
-import SessionStore, { SESSION_FORMAT_VERSION, SessionId } from '@deepseek-ai/dsh-session'
+import { createUserMessage, CallId , createMessage, createToolResultMessage } from '@deepseek-ai/dsh-llm'
+import SessionStore, {
+  SESSION_FORMAT_VERSION,
+  SessionId,
+} from '@deepseek-ai/dsh-session'
 import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session'
 import {
   buildSessionEventRecords,
@@ -42,13 +45,58 @@ describe('session-query semantic extraction', () => {
       { type: 'future-content', payload: 'hidden' } as never,
     ]
     const events: SessionEvent[] = [
-      { type: 'user/message', seq: 0, time: 1, data: { content: messageContent, source: { kind: 'user' } }, surfaceOp: 'append' },
-      { type: 'assistant/message', seq: 1, time: 2, data: { turn: 1, step: 1, content: messageContent, provenance: { provider: 'mock', model: 'mock' } }, surfaceOp: 'append' },
-      { type: 'user/message', seq: 2, time: 3, data: { content: messageContent, source: { kind: 'plugin', plugin: 'test' } }, surfaceOp: 'append' },
-      { type: 'steering/message', seq: 3, time: 4, data: { turn: 1, content: messageContent, source: { kind: 'user' } }, surfaceOp: 'append' },
+      { type: 'user/message', seq: 0, time: 1, data: createUserMessage({
+        content: messageContent, source: { kind: 'user' },
+      }), surfaceOp: 'append' },
+      { type: 'assistant/message', seq: 1, time: 2, data: {
+        turn: 1, step: 1,
+        message: createMessage({
+          role: 'assistant',
+          content: messageContent,
+          source: {
+            kind: 'model',
+            ...{ provider: 'mock', model: 'mock' },
+          },
+        }),
+      }, surfaceOp: 'append' },
+      { type: 'user/message', seq: 2, time: 3, data: createUserMessage({
+        content: messageContent, source: { kind: 'plugin', plugin: 'test' },
+      }), surfaceOp: 'append' },
+      { type: 'steering/message', seq: 3, time: 4, data: {
+        turn: 1,
+        message: createUserMessage({
+          content: messageContent,
+          source: { kind: 'user' },
+        }),
+      }, surfaceOp: 'append' },
       { type: 'tool/call', seq: 4, time: 5, data: { turn: 1, step: 1, callId, name: 'bash', arguments: '{"cmd":"pwd"}' } },
-      { type: 'tool/result', seq: 5, time: 6, data: { turn: 1, step: 1, callId, content: [{ type: 'text', text: 'failed' }], isError: true, error: { name: 'Oops', code: 'E_OOPS' } }, surfaceOp: 'append' },
-      { type: 'tool/result', seq: 6, time: 7, data: { turn: 1, step: 1, callId, content: [], isError: false }, surfaceOp: 'append' },
+      {
+        type: 'tool/result',
+        seq: 5,
+        time: 6,
+        data: {
+          turn: 1,
+          step: 1,
+          message: createToolResultMessage({
+            callId,
+            content: [{ type: 'text', text: 'failed' }],
+            isError: true,
+          }),
+          error: { name: 'Oops', code: 'E_OOPS' },
+        },
+        surfaceOp: 'append',
+      },
+      {
+        type: 'tool/result',
+        seq: 6,
+        time: 7,
+        data: {
+          turn: 1,
+          step: 1,
+          message: createToolResultMessage({ callId, content: [], isError: false }),
+        },
+        surfaceOp: 'append',
+      },
       { type: 'todo/write', seq: 7, time: 8, data: { todos: [{ status: 'in_progress', content: 'ship search' }] } },
     ]
 
@@ -62,8 +110,11 @@ describe('session-query semantic extraction', () => {
       data: {
         turn: 1,
         step: 1,
-        content: [{ type: 'reasoning', text: 'private thought' }],
-        provenance: { provider: 'mock', model: 'mock' },
+        message: createMessage({
+          role: 'assistant',
+          content: [{ type: 'reasoning', text: 'private thought' }],
+          source: { kind: 'model', provider: 'mock', model: 'mock' },
+        }),
       },
       surfaceOp: 'append',
     })).toBe('')
@@ -102,9 +153,21 @@ describe('session-query semantic extraction', () => {
 
 describe('session-query document and filter helpers', () => {
   const events: SessionEvent[] = [
-    { type: 'user/message', seq: 0, time: 10, data: { content: [{ type: 'text', text: 'Hello\n(AI)+' }], source: { kind: 'user' } }, surfaceOp: 'append' },
+    { type: 'user/message', seq: 0, time: 10, data: createUserMessage({
+      content: [{ type: 'text', text: 'Hello\n(AI)+' }], source: { kind: 'user' },
+    }), surfaceOp: 'append' },
     { type: 'assistant/chunk', seq: 1, time: 11, data: { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: 'raw' } } },
-    { type: 'assistant/message', seq: 2, time: 12, data: { turn: 1, step: 1, content: [{ type: 'text', text: 'replacement' }], provenance: { provider: 'mock', model: 'mock' } }, surfaceOp: { op: 'replace', start: 0, end: 0 }, sourceEventSeqs: [0] },
+    { type: 'assistant/message', seq: 2, time: 12, data: {
+      turn: 1, step: 1,
+      message: createMessage({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'replacement' }],
+        source: {
+          kind: 'model',
+          ...{ provider: 'mock', model: 'mock' },
+        },
+      }),
+    }, surfaceOp: { op: 'replace', start: 0, end: 0 }, sourceEventSeqs: [0] },
     { type: 'turn/end', seq: 3, time: 13, data: { turn: 1, reason: { kind: 'interrupted' } } },
   ]
 
@@ -175,7 +238,17 @@ describe('session-query document and filter helpers', () => {
       type: 'assistant/message',
       seq: 0,
       time: 1,
-      data: { turn: 1, step: 1, content: [{ type: 'text', text: 'bad' }], provenance: { provider: 'mock', model: 'mock' } },
+      data: {
+        turn: 1, step: 1,
+        message: createMessage({
+          role: 'assistant',
+          content: [{ type: 'text', text: 'bad' }],
+          source: {
+            kind: 'model',
+            ...{ provider: 'mock', model: 'mock' },
+          },
+        }),
+      },
       surfaceOp: { op: 'replace', start: 9, end: 9 },
     }]
     expect(() => buildSessionEventRecords(id, malformed)).toThrow(expectCode('SESSION_QUERY_INVALID_SURFACE'))
@@ -211,8 +284,12 @@ describe('session-query document and filter helpers', () => {
     await ctx.plugin(SessionStore)
     await ctx.plugin(TestSessionQueryService)
     const session = ctx.sessions.create(id)
-    session.append('user/message', { content: [{ type: 'text', text: 'Alpha\n beta' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
-    session.append('user/message', { content: [{ type: 'text', text: 'other' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
+    session.append('user/message', createUserMessage({
+      content: [{ type: 'text', text: 'Alpha\n beta' }], source: { kind: 'user' },
+    }), { surfaceOp: 'append' })
+    session.append('user/message', createUserMessage({
+      content: [{ type: 'text', text: 'other' }], source: { kind: 'user' },
+    }), { surfaceOp: 'append' })
     await expect(ctx.sessionQuery.filterEvents(id, [{ kind: 'text', text: 'alpha beta' }]))
       .resolves.toMatchObject([{ seq: 0, text: 'Alpha\n beta' }])
   })

packages/session-query/session-query/tests/session-query.spec.ts

@@ -1,3 +1,4 @@
+import { createUserMessage, createMessage } from '@deepseek-ai/dsh-llm'
 import { describe, expect, it, vi } from 'vitest'
 import { Context, type Fiber } from 'cordis'
 import SessionStore, { SESSION_FORMAT_VERSION, SessionId } from '@deepseek-ai/dsh-session'
@@ -20,7 +21,9 @@ function eventLog(text = 'hello'): SessionEvent[] {
     type: 'user/message',
     seq: 0,
     time: 10,
-    data: { content: [{ type: 'text', text }], source: { kind: 'user' } },
+    data: createUserMessage({
+      content: [{ type: 'text', text }], source: { kind: 'user' },
+    }),
     surfaceOp: 'append',
   }]
 }
@@ -93,6 +96,11 @@ class TestPersistence extends SessionPersistence {
     return Promise.resolve(result)
   }
 
+  async readFrom(id: SessionIdType, fromSeq: number, signal?: AbortSignal): Promise<{ meta: SessionHeader; events: SessionEvent[] }> {
+    const whole = await this.inspect(id, signal)
+    return { meta: whole.meta, events: whole.events.filter(event => event.seq >= fromSeq) }
+  }
+
   list(signal?: AbortSignal): Promise<SessionHeader[]> {
     TestPersistence.listCalls += 1
     TestPersistence.listSignals.push(signal)
@@ -126,7 +134,7 @@ function expectCode(code: SessionQueryErrorCode): Error {
 function rejectUnknown<T>(reason: unknown): Promise<T> {
   return new Promise<T>((_resolve, reject) => {
     // Exercise containment for an implementation that violates the Error rejection convention.
-    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+    // oxlint-disable-next-line typescript/prefer-promise-reject-errors
     reject(reason)
   })
 }
@@ -855,7 +863,9 @@ describe('session-query exact reads', () => {
     const live = ctx.sessions.create(SessionId('live-filter'), { meta: { createdAt: 2 } })
     live.append(
       'user/message',
-      { content: [{ type: 'text', text: 'live' }], source: { kind: 'user' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'live' }], source: { kind: 'user' },
+      }),
       { surfaceOp: 'append' },
     )
     const persistence = await ctx.plugin(TestPersistence)
@@ -887,7 +897,9 @@ describe('session-query exact reads', () => {
     session.append('step/start', { turn: 1, step: 1 })
     const first = session.append(
       'user/message',
-      { content: [{ type: 'text', text: 'first' }], source: { kind: 'user' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'first' }], source: { kind: 'user' },
+      }),
       { surfaceOp: 'append' },
     )
     session.append('assistant/chunk', {
@@ -897,7 +909,17 @@ describe('session-query exact reads', () => {
     })
     session.append(
       'assistant/message',
-      { provenance: { provider: 'mock', model: 'mock' }, turn: 1, step: 1, content: [{ type: 'text', text: 'replacement' }] },
+      {
+        turn: 1, step: 1,
+        message: createMessage({
+          role: 'assistant',
+          content: [{ type: 'text', text: 'replacement' }],
+          source: {
+            kind: 'model',
+            ...{ provider: 'mock', model: 'mock' },
+          },
+        }),
+      },
       { surfaceOp: { op: 'replace', start: first.seq, end: first.seq }, sourceEventSeqs: [first.seq] },
     )
 
@@ -910,7 +932,9 @@ describe('session-query exact reads', () => {
     const session = ctx.sessions.create(SessionId('surface-snapshot'), { meta: { cwd: '/work' } })
     const first = session.append(
       'user/message',
-      { content: [{ type: 'text', text: 'old' }], source: { kind: 'user' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'old' }], source: { kind: 'user' },
+      }),
       { surfaceOp: 'append' },
     )
     session.append('assistant/chunk', {
@@ -920,22 +944,38 @@ describe('session-query exact reads', () => {
     })
     session.append(
       'user/message',
-      { content: [{ type: 'text', text: 'checkpoint' }], source: { kind: 'plugin', plugin: 'compact' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'checkpoint' }], source: { kind: 'plugin', plugin: 'compact' },
+      }),
       { surfaceOp: { op: 'replace', start: first.seq, end: first.seq }, sourceEventSeqs: [first.seq] },
     )
     const retained = session.append(
       'user/message',
-      { content: [{ type: 'text', text: 'retained tail' }], source: { kind: 'user' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'retained tail' }], source: { kind: 'user' },
+      }),
       { surfaceOp: 'append' },
     )
     session.append(
       'user/message',
-      { content: [{ type: 'text', text: 'latest checkpoint' }], source: { kind: 'plugin', plugin: 'compact' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'latest checkpoint' }], source: { kind: 'plugin', plugin: 'compact' },
+      }),
       { surfaceOp: { op: 'replace', start: 2, end: retained.seq }, sourceEventSeqs: [2, retained.seq] },
     )
     session.append(
       'assistant/message',
-      { provenance: { provider: 'mock', model: 'mock' }, turn: 2, step: 1, content: [{ type: 'text', text: 'latest answer' }] },
+      {
+        turn: 2, step: 1,
+        message: createMessage({
+          role: 'assistant',
+          content: [{ type: 'text', text: 'latest answer' }],
+          source: {
+            kind: 'model',
+            ...{ provider: 'mock', model: 'mock' },
+          },
+        }),
+      },
       { surfaceOp: 'append' },
     )
 
@@ -947,7 +987,9 @@ describe('session-query exact reads', () => {
       [5, 'assistant/message'],
     ])
     if (snapshot.events[0]?.type !== 'user/message') throw new Error('expected current user message')
-    snapshot.events[0].data.content = []
+    expect(() => {
+      (snapshot.events[0]!.data as { content: unknown[] }).content = []
+    }).toThrow()
     Object.assign(snapshot.session, { cwd: '/mutated' })
 
     expect(session.events[4]?.type === 'user/message' && session.events[4].data.content).toHaveLength(1)
@@ -970,7 +1012,9 @@ describe('session-query exact reads', () => {
     for (const text of ['one', 'two', 'three']) {
       session.append(
         'user/message',
-        { content: [{ type: 'text', text }], source: { kind: 'user' } },
+        createUserMessage({
+          content: [{ type: 'text', text }], source: { kind: 'user' },
+        }),
         { surfaceOp: 'append' },
       )
     }
@@ -980,7 +1024,9 @@ describe('session-query exact reads', () => {
     expect(result.session).toEqual(session.header)
     Object.assign(result.session, { createdAt: -1 })
     if (result.events[0]?.type !== 'user/message') throw new Error('expected user message')
-    result.events[0].data.content = []
+    expect(() => {
+      (result.events[0]!.data as { content: unknown[] }).content = []
+    }).toThrow()
     expect(session.header.createdAt).not.toBe(-1)
     expect(session.events[1]?.type === 'user/message' && session.events[1].data.content).toHaveLength(1)
 
@@ -1007,7 +1053,9 @@ describe('session-query exact reads', () => {
     live.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
     live.append(
       'user/message',
-      { content: [{ type: 'text', text: 'live' }], source: { kind: 'user' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'live' }], source: { kind: 'user' },
+      }),
       { surfaceOp: 'append' },
     )
     const persistence = await ctx.plugin(TestPersistence)
@@ -1045,7 +1093,9 @@ describe('session-query exact reads', () => {
     live.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
     live.append(
       'user/message',
-      { content: [{ type: 'text', text: 'available' }], source: { kind: 'user' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'available' }], source: { kind: 'user' },
+      }),
       { surfaceOp: 'append' },
     )
     await ctx.plugin(TestPersistence)
@@ -1097,7 +1147,9 @@ describe('session-query exact reads', () => {
         type: 'user/message',
         seq: 0,
         time: 1,
-        data: { content: [{ type: 'text', text: 'hidden' }], source: { kind: 'user' } },
+        data: createUserMessage({
+          content: [{ type: 'text', text: 'hidden' }], source: { kind: 'user' },
+        }),
       }],
     }])
     const persistence = await ctx.plugin(TestPersistence)

packages/session-query/session-query/tests/tracing.spec.ts

@@ -1,3 +1,4 @@
+import { createUserMessage, createMessage } from '@deepseek-ai/dsh-llm'
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import SessionStore, { SESSION_FORMAT_VERSION, SessionId } from '@deepseek-ai/dsh-session'
@@ -22,7 +23,9 @@ function appendEvent(seq: number, sources?: number[]): SessionEvent {
     type: 'user/message',
     seq,
     time: seq + 1,
-    data: { content: [{ type: 'text', text: `event ${seq}` }], source: { kind: 'user' } },
+    data: createUserMessage({
+      content: [{ type: 'text', text: `event ${seq}` }], source: { kind: 'user' },
+    }),
     surfaceOp: 'append',
     ...sources === undefined ? {} : { sourceEventSeqs: sources },
   }
@@ -73,6 +76,11 @@ class TracePersistence extends SessionPersistence {
     return Promise.resolve(structuredClone(entry))
   }
 
+  async readFrom(id: SessionIdType, fromSeq: number): Promise<{ meta: SessionHeader; events: SessionEvent[] }> {
+    const whole = await this.inspect(id)
+    return { meta: whole.meta, events: whole.events.filter(event => event.seq >= fromSeq) }
+  }
+
   list(): Promise<SessionHeader[]> {
     TracePersistence.listCalls += 1
     if (TracePersistence.listFailure !== undefined) return Promise.reject(TracePersistence.listFailure)
@@ -107,24 +115,48 @@ function appendTraceEvents(session: Session): void {
   })
   session.append(
     'user/message',
-    { content: [{ type: 'text', text: 'original' }], source: { kind: 'user' } },
+    createUserMessage({
+      content: [{ type: 'text', text: 'original' }], source: { kind: 'user' },
+    }),
     { surfaceOp: 'append', sourceEventSeqs: [2] },
   )
   session.append(
     'assistant/message',
-    { provenance: { provider: 'mock', model: 'mock' }, turn: 1, step: 1, content: [{ type: 'text', text: 'summary one' }] },
+    {
+      turn: 1, step: 1,
+      message: createMessage({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'summary one' }],
+        source: {
+          kind: 'model',
+          ...{ provider: 'mock', model: 'mock' },
+        },
+      }),
+    },
     { surfaceOp: { op: 'replace', start: 3, end: 3 }, sourceEventSeqs: [3, 2] },
   )
   session.append(
     'user/message',
-    { content: [{ type: 'text', text: 'context' }], source: { kind: 'plugin', plugin: 'test' } },
+    createUserMessage({
+      content: [{ type: 'text', text: 'context' }], source: { kind: 'plugin', plugin: 'test' },
+    }),
     { surfaceOp: 'append' },
   )
   session.append('step/end', { turn: 1, step: 1 })
   session.append('step/start', { turn: 1, step: 2 })
   session.append(
     'assistant/message',
-    { provenance: { provider: 'mock', model: 'mock' }, turn: 1, step: 2, content: [{ type: 'text', text: 'summary two' }] },
+    {
+      turn: 1, step: 2,
+      message: createMessage({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'summary two' }],
+        source: {
+          kind: 'model',
+          ...{ provider: 'mock', model: 'mock' },
+        },
+      }),
+    },
     { surfaceOp: { op: 'replace', start: 4, end: 4 }, sourceEventSeqs: [2, 4] },
   )
 }
@@ -319,7 +351,9 @@ describe('session event tracing', () => {
     live.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
     live.append(
       'user/message',
-      { content: [{ type: 'text', text: 'live' }], source: { kind: 'plugin', plugin: 'test' } },
+      createUserMessage({
+        content: [{ type: 'text', text: 'live' }], source: { kind: 'plugin', plugin: 'test' },
+      }),
       { surfaceOp: 'append' },
     )
     TracePersistence.listFailure = new Error('list unavailable')
@@ -352,7 +386,17 @@ describe('session event tracing', () => {
       type: 'assistant/message',
       seq: 1,
       time: 2,
-      data: { turn: 1, step: 1, content: [], provenance: { provider: 'mock', model: 'mock' } },
+      data: {
+        turn: 1, step: 1,
+        message: createMessage({
+          role: 'assistant',
+          content: [],
+          source: {
+            kind: 'model',
+            ...{ provider: 'mock', model: 'mock' },
+          },
+        }),
+      },
       surfaceOp: { op: 'replace', start: 9, end: 9 },
       sourceEventSeqs: [],
     }]