dsh-data-domain-knowledge 0.1.0-alpha.9 → 0.1.1-alpha.2

package/src/wiki-trial.ts

@@ -1,3 +1,4 @@
+import { normalizeKnowledgeExtraction } from './knowledge-contract.js'
 /**
  * Wiki 抽取试跑（0063）：**调一次模型**按新方案判一遍，不落盘。
  *
@@ -29,10 +30,11 @@
  * 顺序里有一条硬规矩：**先把"知识是什么"搞清楚，再决定"这些知识怎么组织成 Wiki Card"。**
  * Wiki Card 是组织结果，不是知识合并结果。
  *
- * ## 只调一次
+ * ## 主抽取只调一次
  *
- * 七步是给人 review 的，不是给模型分的工。一次调用输入全文，输出一个 JSON：
+ * 七步是给人 review 的，不是给模型分的工。主抽取一次输入全文，输出一个 JSON：
  * `subject` / `knowledge` / `objects` / `actions` / `scenes` / `dropped`。
+ * 编译时若坐标不能直接命中，系统会把有候选的坐标合并成一次受约束的补判请求；没有候选时不补判。
  * 分块只在文档塞不进上下文时才做。
  *
  * ## 对象 × 动作矩阵
@@ -53,16 +55,18 @@ import type { ModelCall } from './extract-model.js'
 // 类型定义在 `wiki-trial-types.ts`：客户端也 import 那一份，所以只有一份定义。
 // 这里再导出一次，让 `./wiki-trial.js` 仍然是一个完整的入口。
 export type {
-  TrialActor, TrialPhase, TrialSource, TrialKnowledge, TrialAxis, TrialPlacement,
+  TrialActor, TrialPhase, TrialSource, TrialKnowledge, TrialEvent, TrialEventStepKind, TrialAxis, TrialPlacement,
   TrialWikiCard, TrialMatrixGroup, TrialMatrixCell, TrialMatrixLoose, TrialMatrix,
-  TrialStepItem, TrialStep, TrialCheck, TrialAudit, TrialReport,
+  TrialStepItem, TrialStep, TrialCheck, TrialAudit, TrialModelCallTrace, TrialReport,
+  TrialTokenUsage,
 } from './wiki-trial-types.js'
 import type {
-  TrialActor, TrialPhase, TrialSource, TrialKnowledge, TrialAxis,
+  TrialActor, TrialPhase, TrialSource, TrialKnowledge, TrialEvent, TrialEventStepKind, TrialAxis,
   TrialWikiCard, TrialMatrixGroup, TrialMatrixCell, TrialMatrixLoose, TrialMatrix,
-  TrialStepItem, TrialStep, TrialCheck, TrialReport,
+  TrialStepItem, TrialStep, TrialCheck, TrialModelCallTrace, TrialReport, TrialTokenUsage,
 } from './wiki-trial-types.js'
-import { AXIS_CONTRACT_LINES } from './axis-contract.js'
+import { buildTrialSystem } from './extract-contract.js'
+import { decodeExtractionTable } from './extract-table.js'
 
 /**
  * 抽取契约（0063 §5.6）。**这是契约，不是要抄进代码的字符串。**
@@ -74,103 +78,9 @@ import { AXIS_CONTRACT_LINES } from './axis-contract.js'
  * 2. 三个分量**可以全空** —— §九 明写"允许 Knowledge 没有领域坐标"。
  *    文档 §5.6 里"每条至少挂一个 object 或一个 action"与它冲突。
  */
-/**
- * 把骨架允许的小节拼成提示词里那一条。
- *
- * §5.3.2 说「`section` 的合法取值来自类型定义」—— 那就应当**下发**给它，帮助模型
- * 使用一致的小节名。不下发的话，那句「合法取值来自类型定义」只是一句写在文档里的愿望。
- */
-function sectionRule(sections: string[] | undefined): string[] {
-  const legal = (sections ?? []).map(section => section.trim()).filter(Boolean)
-  if (legal.length === 0) {
-    return ['- section 是这条知识在卡片里的位置。拿不准就填「字段」。']
-  }
-  return [
-    `- section 只能填这几个之一：${legal.join(' / ')}，或者「字段」。`,
-    '- 拿不准就填「字段」。**不要自创小节名** —— 卡片是按骨架校验的，编出来的名字对不上。',
-  ]
-}
 
-/**
- * 抽取契约的 system 段。**骨架的小节随知识库变化，所以它是拼出来的，不是常量。**
- *
- * 编译链路用 `buildTrialSystem(profileSections)`；试跑面板用默认实例（不下发小节清单），
- * 因为那一层没有「本库骨架」这个概念。
- */
-export function buildTrialSystem(sections?: string[]): string {
-  return trialSystemBody(sectionRule(sections))
-}
-
-const trialSystemBody = (positionRule: string[]): string => [
-  '你在把一份业务文档拆成知识库要用的内容。知识以 Knowledge 为单位：',
-  '一条可独立检索、验证或执行的最小知识单元。',
-  '',
-  '只回一个 JSON 对象，不要散文，不要代码围栏。',
-  '',
-  '输出形状：',
-  '{',
-  '  "subject": "这份文档讲的业务主体",',
-  '  "knowledge": [',
-  '    { "id": "k1",',
-  '      "text": "一条可独立检索、验证或执行的最小知识单元",',
-  '      "object": "对象名或 null", "action": "动作名或 null", "scene": "场景名或 null",',
-  '      "section": "步骤", "order": 1,',
-  '      "sources": [ { "quote": "原文里原样复制的一段", "heading_path": ["一级", "二级"] } ] }',
-  '  ],',
-  '  "objects": [ { "mention": "原文中的对象叫法", "definition": "一句话说清它指什么、边界在哪", "evidence": "支持它的原文短引文", "existing": "已有对象的名字（没有就省略这个键）" } ],',
-  '  "actions": [ { "mention": "原文中的动作叫法", "definition": "同上", "evidence": "支持它的原文短引文", "existing": "…" } ],',
-  '  "scenes":  [ { "mention": "原文中的场景叫法", "definition": "同上", "evidence": "支持它的原文短引文", "existing": "…" } ],',
-  '  "dropped": [ { "quote": "原文片段", "why": "为什么丢掉" } ]',
-  '}',
-  '',
-  '# 知识：一条只讲一个单元',
-  '- text 是一条能脱离上下文独立阅读的最小知识单元。事实要能判断真假，操作步骤要能被执行。',
-  '- 一段原文里有几个独立单元就写几条。不要压成一条，也不要拆碎。',
-  '  不该拆：「SPM 由 spm_b、spm_c、spm_d 三部分构成」是一个完整事实。',
-  '  该拆：「spm_c 是楼层 ID」「楼层拖拽后 ID 会变化」「取数不能写死楼层 ID」是三条。',
-  '- 不许推理出原文没有的事实。只做压缩、归一化、结构化。不许编原文没有的步骤。',
-  '- 不要写「该字段」「上述」这种指代 —— 读者看不到上下文。',
-  '',
-  ...AXIS_CONTRACT_LINES,
-  '',
-  '- 一条 Knowledge 只挂一个 object、一个 action、一个 scene。那是它的家。',
-  '  别的卡片可以引用它 —— 那是卡片的事，不是坐标的事，不要为它多挂几个坐标。',
-  '- 三个都留 null 是允许的。它不进矩阵、不成卡，但仍然可被全库命中。',
-  '  不要为了让它成卡而编一个坐标。',
-  '- 不要造"动作实例"。「通天塔spm取数」不是动作，它是坐标（通天塔 × 取数 × SPM）推出来的卡名。',
-  '',
-  '# 坐标：定义与证据',
-  '- 每个 object / action / scene 都写 `definition`：一句话说清**它指什么、边界在哪**。',
-  '  它是下一次抽取的参考 —— 名字只能让人认出写法相同的东西，定义才能认出「换了说法但同一个」。',
-  '  写「通天塔坑位click：通天塔投放位上的一次点击上报」这种能判断的句子，不要写「一个对象」这种空话。',
-  '- 每个 object / action / scene 都写 `evidence`：从原文复制支持该坐标及其定义的最短片段。没有证据就不要抽这个坐标。',
-  '- `definition` 只能总结原文和已有坐标定义能支持的范围，不要补造原文没有的属性、状态或因果。',
-  '',
-  '# 坐标：先看用户消息里的「已有坐标」',
-  '- 你讲的东西如果就是清单里的某一个（哪怕原文用的是另一个说法），就写**它的名字**，',
-  '  并把 `existing` 写成那个名字。别造一个近似的名字 —— 那会让库里长出两个只在写法上不同的实体。',
-  '- 清单里没有的才写新名字（`existing` 留空）。拿不准就写新名字：解析那一步会兜底。',
-  '- 清单是**参考**，不是限制：库里没有的东西照样可以抽出来。',
-  '',
-  '# 来源：原样，别改写',
-  '- quote 必须一个字都不改，从原文原样复制。',
-  '- 挑最短的必要片段，不要整段照抄。',
-  '- 一段原文支撑多条知识时，每条都要各自写上它的 quote。',
-  '- heading_path 是从外到内的标题路径，只作定位线索。',
-  '',
-  '# 位置：这条知识在卡里排哪',
-  ...positionRule,
-  '- order 是同一小节内的第几位，从 1 开始。',
-  '- 不要写卡片正文，也不要写导语、备注、警告。你只给"哪条知识放在哪个小节、排第几"。',
-  '',
-  '# 别把排版当结构',
-  '- 原文里的小节标题只是作者写给"人顺着读"的排版，不是知识边界。',
-  '- 一个标题里可以装几件事，一件事也可以跨几个标题。不要按标题切。',
-  '',
-  '- 不含知识的片段放 dropped，写清 why。不许悄悄丢。',
-  '',
-  '每条 quote 必须从原文原样复制，一个字都不要改。没有 quote 的判断一律不要。',
-].join('\n')
+/** 抽取契约的 system 段搬到了 `extract-contract.ts`（说明页要显示它，而这里进不了浏览器）。 */
+export { buildTrialSystem } from './extract-contract.js'
 
 /** 默认的 system 段（不下发骨架小节）。试跑面板用它。 */
 export const TRIAL_SYSTEM = buildTrialSystem()
@@ -191,13 +101,14 @@ export function buildTrialPrompt(input: {
   axes?: AxisPromptBlock
   /** 这一库的坐标约定，人写的（0068）。 */
   note?: string
+  outputFormat?: 'table' | 'json'
 }): string {
   const sections: string[] = ['# 文档', `文件名：${input.title}`, '', input.text.trim(), '']
   const block = renderAxisBlock(input.axes)
   if (block !== '') sections.push(block, '')
   const note = (input.note ?? '').trim()
   if (note !== '') sections.push('# 本库的坐标约定（人写的，优先听它）', note, '')
-  sections.push('# 输出', '按 system 里说的形状，回一个 JSON 对象。')
+  sections.push('# 输出', `按 system 中的版本协议返回${input.outputFormat === 'json' ? ' JSON 对象' : ' TOON 表格'}，不要混用格式。`)
   return sections.join('\n')
 }
 
@@ -266,6 +177,8 @@ function renderAxisBlock(block: AxisPromptBlock | undefined): string {
 /** 从可能带 ``` 围栏的文本里取出 JSON。与 `extract-model.ts` 同构。 */
 function parseJsonObject(raw: string): unknown {
   const trimmed = raw.trim()
+  // Parse the transport first: code fences inside JSON string values are source data.
+  try { return JSON.parse(trimmed) } catch { /* tolerate an outer Markdown wrapper */ }
   const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/)
   const body = (fenced ? fenced[1] : trimmed).trim()
   try { return JSON.parse(body) } catch { /* 退一步取首尾大括号 */ }
@@ -294,7 +207,7 @@ function plainRecord(value: unknown): Record<string, unknown> {
  * 被误报为「清单外」并置空，最终整批 Knowledge 都变成「无坐标」。先把它们补回
  * 抽取清单，再走同一套 Entity Resolution，既不猜坐标，也不绕过注册表。
  */
-function axisMentionsFromKnowledge(raw: unknown): Record<AxisKind, Array<{ mention: string }>> {
+function axisMentionsFromItems(raw: unknown): Record<AxisKind, Array<{ mention: string }>> {
   const out: Record<AxisKind, Array<{ mention: string }>> = { object: [], action: [], scene: [] }
   if (!Array.isArray(raw)) return out
   const fields: Array<{ kind: AxisKind; keys: string[] }> = [
@@ -315,6 +228,14 @@ function axisMentionsFromKnowledge(raw: unknown): Record<AxisKind, Array<{ menti
   return out
 }
 
+function axisMentionsFromKnowledge(raw: unknown): Record<AxisKind, Array<{ mention: string }>> {
+  return axisMentionsFromItems(raw)
+}
+
+function axisMentionsFromEvents(raw: unknown): Record<AxisKind, Array<{ mention: string }>> {
+  return axisMentionsFromItems(raw)
+}
+
 /** 顶层轴清单优先，Knowledge 坐标只补缺项；readAxes 会按归一化名称去重。 */
 function mergeAxisMentions(raw: unknown, supplements: Array<{ mention: string }>): unknown[] {
   return [...(Array.isArray(raw) ? raw : []), ...supplements]
@@ -604,6 +525,9 @@ function readKnowledge(raw: unknown, options: ReadKnowledgeOptions): { knowledge
     const order = typeof rawOrder === 'number' && Number.isFinite(rawOrder) ? Math.trunc(rawOrder) : 1
     knowledge.push({
       id,
+      kind: record.kind === 'procedure' ? 'procedure' : 'fact',
+      ...(record.scope_identity === true ? { scopeIdentity: true } : {}),
+      ...(record.data && typeof record.data === 'object' ? { data: record.data as TrialKnowledge['data'] } : {}),
       text,
       object,
       action,
@@ -617,6 +541,136 @@ function readKnowledge(raw: unknown, options: ReadKnowledgeOptions): { knowledge
   return { knowledge, problems }
 }
 
+interface ReadEventOptions extends ReadKnowledgeOptions {}
+
+function readTrialSources(raw: unknown, options: Pick<ReadEventOptions, 'text' | 'documentId'>): TrialSource[] {
+  if (!Array.isArray(raw)) return []
+  const sources: TrialSource[] = []
+  for (const item of raw) {
+    if (item === null || typeof item !== 'object') continue
+    const source = item as Record<string, unknown>
+    const quote = str(source.quote)
+    if (!quote) continue
+    const located = locateQuote(options.text, quote)
+    sources.push({
+      documentId: options.documentId,
+      quote,
+      ...(located.locator ? { locator: located.locator } : {}),
+      headingPath: strList(source.heading_path),
+      found: located.found,
+    })
+  }
+  return sources
+}
+
+/** 读取一次具体事件；缺失字段保留为空，不用模型补猜。 */
+function readEvents(raw: unknown, options: ReadEventOptions): { events: TrialEvent[]; problems: string[] } {
+  if (!Array.isArray(raw)) return { events: [], problems: [] }
+  const objectMap = new Map(options.objects.flatMap(axis => [axis.name, ...axis.aliases].map(name => [normalizeAxisName(name), axis.name] as const)))
+  const actionMap = new Map(options.actions.flatMap(axis => [axis.name, ...axis.aliases].map(name => [normalizeAxisName(name), axis.name] as const)))
+  const sceneMap = new Map(options.scenes.flatMap(axis => [axis.name, ...axis.aliases].map(name => [normalizeAxisName(name), axis.name] as const)))
+  const events: TrialEvent[] = []
+  const problems: string[] = []
+  const ids = new Set<string>()
+  for (const entry of raw) {
+    if (entry === null || typeof entry !== 'object') continue
+    const record = entry as Record<string, unknown>
+    const id = str(record.id) || `e${events.length + 1}`
+    if (ids.has(id)) {
+      problems.push(`Event id「${id}」重复，后续条目已跳过`)
+      continue
+    }
+    ids.add(id)
+    const title = str(record.title)
+    const summary = str(record.summary) || title
+    if (!title && !summary) {
+      problems.push(`Event「${id}」没有标题或摘要，已跳过`)
+      continue
+    }
+    const coordinate = plainRecord(record.coordinate)
+    const resolve = (value: unknown, map: Map<string, string>, axis: string): string | null => {
+      const mention = str(value)
+      if (!mention) return null
+      const canonical = map.get(normalizeAxisName(mention))
+      if (canonical) return canonical
+      problems.push(`Event「${id}」的${axis}「${mention}」没有进入轴清单，已置空`)
+      return null
+    }
+    const object = resolve(coordinate.object_mention ?? coordinate.object, objectMap, '对象')
+    const action = resolve(coordinate.action_mention ?? coordinate.action, actionMap, '动作')
+    const scene = resolve(coordinate.scene_mention ?? coordinate.scene, sceneMap, '场景')
+
+    const timeline: TrialEvent['timeline'] = []
+    if (Array.isArray(record.timeline)) {
+      for (const [index, rawStep] of record.timeline.entries()) {
+        if (rawStep === null || typeof rawStep !== 'object') continue
+        const step = rawStep as Record<string, unknown>
+        const description = str(step.description)
+        if (!description) continue
+        const candidateType = str(step.type)
+        const type: TrialEventStepKind = ['observation', 'check', 'action', 'result', 'conclusion'].includes(candidateType)
+          ? candidateType as TrialEventStepKind
+          : 'observation'
+        const sources = readTrialSources(step.sources, options)
+        if (!sources.some(source => source.found)) problems.push(`Event「${id}」时间线第 ${index + 1} 项没有可核验的原文引文`)
+        timeline.push({
+          id: str(step.id) || `${id}.t${index + 1}`,
+          type,
+          description,
+          result: str(step.result) || null,
+          at: str(step.at) || null,
+          sources,
+        })
+      }
+    }
+    const sources = readTrialSources(record.sources, options)
+    const evidence = [...sources, ...timeline.flatMap(step => step.sources)]
+    if (!evidence.some(source => source.found)) {
+      problems.push(`Event「${id}」没有可核验的原文引文，已留在抽取轨迹但不进入 Event 真源`)
+      continue
+    }
+
+    const rawRootCause = record.root_cause
+    const root = typeof rawRootCause === 'string' ? { text: rawRootCause, status: 'suspected' } : plainRecord(rawRootCause)
+    const rootCause = str(root.text) || null
+    const rootStatus = str(root.status)
+    const rootCauseStatus: TrialEvent['rootCauseStatus'] = rootCause && (rootStatus === 'confirmed' || rootStatus === 'suspected')
+      ? rootStatus
+      : null
+    const missing = strList(record.missing)
+    const addMissing = (label: string, missingValue: unknown): void => {
+      if (!str(missingValue) && !missing.includes(label)) missing.push(label)
+    }
+    const occurredAt = str(record.occurred_at) || null
+    const symptom = str(record.symptom) || null
+    const outcome = str(record.outcome) || null
+    addMissing('发生时间', occurredAt)
+    addMissing('问题现象', symptom)
+    addMissing('根因', rootCause)
+    addMissing('处理结果', outcome)
+    addMissing('问题坐标', object || action || scene)
+    events.push({
+      id,
+      externalId: str(record.external_id) || null,
+      title: title || summary,
+      summary,
+      object,
+      action,
+      scene,
+      occurredAt,
+      symptom,
+      timeline,
+      rootCause,
+      rootCauseStatus,
+      outcome,
+      missing,
+      sources,
+      noCoordinate: !object && !action && !scene,
+    })
+  }
+  return { events, problems }
+}
+
 // ------------------------------------------------------------ 本地推导
 
 /**
@@ -631,27 +685,39 @@ function readKnowledge(raw: unknown, options: ReadKnowledgeOptions): { knowledge
  * **没有"要不要建卡"这个问题。** 一个坐标 + 至少一条知识，就天然要建。
  * 三个分量全空的知识不成卡 —— 它没有坐标。
  */
-export function materialize(knowledge: TrialKnowledge[]): TrialWikiCard[] {
+export function materialize(knowledge: TrialKnowledge[], events: TrialEvent[] = []): TrialWikiCard[] {
   const groups = new Map<string, TrialWikiCard>()
-  for (const item of knowledge) {
-    if (item.noCoordinate) continue
-    const key = `${item.object ?? ''}\u0001${item.action ?? ''}\u0001${item.scene ?? ''}`
+  const groupOf = (object: string | null, action: string | null, scene: string | null): TrialWikiCard => {
+    const key = `${object ?? ''}\u0001${action ?? ''}\u0001${scene ?? ''}`
     let card = groups.get(key)
     if (!card) {
       card = {
-        object: item.object,
-        action: item.action,
-        scene: item.scene,
-        name: cardNameFor(item.object, item.action, item.scene),
+        object,
+        action,
+        scene,
+        name: cardNameFor(object, action, scene),
         placements: [],
+        events: [],
       }
       groups.set(key, card)
     }
+    return card
+  }
+  for (const item of knowledge) {
+    if (item.noCoordinate) continue
+    const card = groupOf(item.object, item.action, item.scene)
     card.placements.push({ item: item.id, section: item.section, order: item.order })
   }
+  for (const event of events) {
+    if (event.noCoordinate) continue
+    const key = `${event.object ?? ''}\u0001${event.action ?? ''}\u0001${event.scene ?? ''}`
+    // A WikiCard is created by Knowledge. Event only adds a reference to an existing knowledge group.
+    groups.get(key)?.events.push(event.id)
+  }
   for (const card of groups.values()) {
     card.placements.sort((left, right) =>
       left.section.localeCompare(right.section) || left.order - right.order || left.item.localeCompare(right.item))
+    card.events.sort((left, right) => left.localeCompare(right))
   }
   return [...groups.values()]
 }
@@ -671,15 +737,15 @@ export function materialize(knowledge: TrialKnowledge[]): TrialWikiCard[] {
  * 组是**最小的可点单位**：点一个数字要看到的就是那一组的知识。
  */
 export function buildMatrix(
-  objects: string[], actions: string[], knowledge: TrialKnowledge[], wikiCards: TrialWikiCard[],
+  objects: string[], actions: string[], knowledge: TrialKnowledge[], wikiCards: TrialWikiCard[], events: TrialEvent[] = [],
 ): TrialMatrix {
   /** 一组一组的桶。键是 `object\u0001action\u0001scene`。 */
-  const buckets = new Map<string, { object: string | null; action: string | null; scene: string; knowledge: number; items: string[] }>()
+  const buckets = new Map<string, { object: string | null; action: string | null; scene: string; knowledge: number; events: number; items: string[]; eventItems: string[] }>()
   const bucketOf = (object: string | null, action: string | null, scene: string) => {
     const key = `${object ?? '\u0000'}\u0001${action ?? '\u0000'}\u0001${scene}`
     const hit = buckets.get(key)
     if (hit) return hit
-    const created = { object, action, scene, knowledge: 0, items: [] as string[] }
+    const created = { object, action, scene, knowledge: 0, events: 0, items: [] as string[], eventItems: [] as string[] }
     buckets.set(key, created)
     return created
   }
@@ -690,6 +756,12 @@ export function buildMatrix(
     bucket.knowledge += 1
     bucket.items.push(item.id)
   }
+  for (const event of events) {
+    if (event.noCoordinate) continue
+    const bucket = bucketOf(event.object, event.action, event.scene ?? '')
+    bucket.events += 1
+    bucket.eventItems.push(event.id)
+  }
 
   // 卡名叠进它自己那一组。一个 `(object, action, scene)` 至多一张卡，所以是赋值不是追加。
   const cardOf = new Map<string, string>()
@@ -704,8 +776,10 @@ export function buildMatrix(
       out.push({
         scene: bucket.scene,
         knowledge: bucket.knowledge,
+        events: bucket.events,
         card: cardOf.get(`${object ?? '\u0000'}\u0001${action ?? '\u0000'}\u0001${bucket.scene}`) ?? '',
         items: bucket.items,
+        eventItems: bucket.eventItems,
       })
     }
     // 场景名的阅读顺序：先空场景（它是「没有细分」的那一组），再按名字。
@@ -718,7 +792,7 @@ export function buildMatrix(
     for (const action of actions) {
       const groups = groupsFor(object, action)
       if (groups.length === 0) continue
-      cells.push({ object, action, groups, knowledge: groups.reduce((sum, group) => sum + group.knowledge, 0) })
+      cells.push({ object, action, groups, knowledge: groups.reduce((sum, group) => sum + group.knowledge, 0), events: groups.reduce((sum, group) => sum + group.events, 0) })
     }
   }
 
@@ -726,12 +800,12 @@ export function buildMatrix(
   const noAction: TrialMatrixLoose[] = []
   for (const object of objects) {
     const groups = groupsFor(object, null)
-    if (groups.length > 0) noAction.push({ name: object, groups, knowledge: groups.reduce((sum, group) => sum + group.knowledge, 0) })
+    if (groups.length > 0) noAction.push({ name: object, groups, knowledge: groups.reduce((sum, group) => sum + group.knowledge, 0), events: groups.reduce((sum, group) => sum + group.events, 0) })
   }
   const noObject: TrialMatrixLoose[] = []
   for (const action of actions) {
     const groups = groupsFor(null, action)
-    if (groups.length > 0) noObject.push({ name: action, groups, knowledge: groups.reduce((sum, group) => sum + group.knowledge, 0) })
+    if (groups.length > 0) noObject.push({ name: action, groups, knowledge: groups.reduce((sum, group) => sum + group.knowledge, 0), events: groups.reduce((sum, group) => sum + group.events, 0) })
   }
 
   return {
@@ -741,6 +815,7 @@ export function buildMatrix(
     noAction,
     noObject,
     noCoordinate: knowledge.filter(item => item.noCoordinate).length,
+    noCoordinateEvents: events.filter(item => item.noCoordinate).length,
     withKnowledge: cells.filter(cell => cell.knowledge > 0).length,
     filled: cells.length,
     slots: objects.length * actions.length,
@@ -789,7 +864,7 @@ function findTwins(knowledge: TrialKnowledge[]): Array<{ key: string; ids: strin
  * 每一步给两样：`rows`（按什么判、缺什么）和 `items`（**逐条判出的实际值**）。
  * 试跑面板是给人逐步 review 的，只有统计没有值就没法 review。
  *
- * 第 2、3 步里如实写明单文档试跑缺什么：归一缺库内注册表，同义与冲突缺第二次模型调用。
+ * 第 2、3 步里如实写明能力边界：轴归一需要库内注册表，候选歧义可在编译时补判；知识同义与冲突仍不做模型裁决。
  */
 export function buildReport(input: {
   title: string
@@ -799,18 +874,19 @@ export function buildReport(input: {
   actions: TrialAxis[]
   scenes: TrialAxis[]
   knowledge: TrialKnowledge[]
+  events: TrialEvent[]
   wikiCards: TrialWikiCard[]
   matrix: TrialMatrix
   problems: string[]
   dropped: Array<{ quote: string; why: string }>
-  model: { ok: boolean; why?: string; raw?: string }
+  model: TrialReport['model']
   promptUser: string
   /** 这一次**真的发出去**的 system 段。面板要摊开它，不能显示一份理想版。 */
   system?: string
   /** 这一次下发了多少已有坐标（0068）。省略 = 没有下发。 */
   axesContext?: { injected: number; totals: number; truncated: number; selection?: 'full' | 'relevant' | 'head' }
 }): TrialReport {
-  const { objects, actions, scenes, knowledge, wikiCards, matrix, dropped } = input
+  const { objects, actions, scenes, knowledge, events, wikiCards, matrix, dropped } = input
   const headings = scanHeadings(input.text)
   const axes = [...objects, ...actions, ...scenes]
   const aliased = axes.filter(axis => axis.aliases.length > 0)
@@ -827,8 +903,14 @@ export function buildReport(input: {
       if (!source.found) invented.push({ id: item.id, quote: source.quote })
     }
   }
+  for (const event of events) {
+    for (const source of [...event.sources, ...event.timeline.flatMap(step => step.sources)]) {
+      if (!source.found) invented.push({ id: event.id, quote: source.quote })
+    }
+  }
   const noSource = knowledge.filter(item => item.sources.length === 0)
   const noCoordinate = knowledge.filter(item => item.noCoordinate)
+  const noCoordinateEvents = events.filter(item => item.noCoordinate)
   const twins = findTwins(knowledge)
   const collisions = findCollisions(wikiCards)
   const sections = new Set(knowledge.flatMap(item => item.section))
@@ -837,30 +919,38 @@ export function buildReport(input: {
   const steps: TrialStep[] = [
     {
       id: 'extract', order: 1, name: '语义抽取', phase: '① Extract · 抽取', actor: '模型',
-      needsHuman: noCoordinate.length > 0 || noSource.length > 0 || knowledge.length === 0,
-      summary: `${knowledge.length} 条知识 · ${objects.length} 对象 · ${actions.length} 动作 · ${scenes.length} 场景 · 一次调用`,
+      needsHuman: noCoordinate.length > 0 || noSource.length > 0 || knowledge.length === 0 || events.some(event => event.missing.length > 0),
+      summary: `${knowledge.length} 条 Knowledge · ${events.length} 个 Event · ${objects.length} 对象 · ${actions.length} 动作 · ${scenes.length} 场景 · 一次调用`,
       rows: [
         { label: '输入', value: `${input.text.split(/\r?\n/).length} 行 / ${countChars(input.text)} 字 / ${headings.length} 个标题，全文进去，不切块` },
-        { label: '一次调用出全部', value: '不拆成"先抽对象再抽动作再抽知识" —— 拆开要把全文重发多遍，判"这段讲什么"时手上没有原话' },
+        { label: '一次调用出全部', value: '同一份 Document 并行抽取 Knowledge 与 Event，再提取 Object / Action / Scene mentions' },
         { label: '这一步不解决', value: '这是不是已有知识（第 3 步）· 这些名字是不是已有实体（第 2 步）· 应该生成哪张卡（第 5 步）' },
         { label: '五条规则', value: '一条只讲一个单元 · 不推理出原文没有的事实 · 不写「该字段」这种指代 · 坐标各一个 · quote 原样复制' },
-        { label: '没有出处', value: noSource.length > 0 ? `${noSource.length} 条知识一个 quote 都没给` : '无' },
+        { label: '没有出处', value: noSource.length > 0 ? `${noSource.length} 条 Knowledge 一个 quote 都没给` : 'Knowledge / Event 都有可核验出处' },
       ],
-      items: knowledge.map(item => makeItem(
+      items: [
+        ...knowledge.map(item => makeItem(
         item.id,
         shortQuote(item.text),
         `${coordLabel(item.object, item.action, item.scene)} · ${item.sources.length} 条出处`,
         item.noCoordinate || item.sources.length === 0 ? 'warn' : undefined,
-      )),
+        )),
+        ...events.map(event => makeItem(
+          `Event ${event.id}`,
+          event.title,
+          `${coordLabel(event.object, event.action, event.scene)} · ${event.timeline.length} 个时间线节点 · ${event.missing.length} 项待补`,
+          event.noCoordinate || event.missing.length > 0 ? 'warn' : undefined,
+        )),
+      ],
     },
     {
       id: 'entity', order: 2, name: '轴实体归一', phase: '② Resolve · 归一', actor: '系统',
       needsHuman: aliased.length > 0 || ambiguous.length > 0 || created.length > 0,
       summary: `${axes.length} 个轴实体 · 命中 ${matched.length} · 新建候选 ${created.length} · 不唯一 ${ambiguous.length}`,
       rows: [
-        { label: '顺序', value: '归一化（大小写 / 空格 / 符号）→ 作用域内 canonical → 作用域内 alias → 全局唯一 → 新建候选 + 例外上报' },
+        { label: '顺序', value: '注册表直接命中 → 对有候选的歧义坐标合并一次模型补判 → 未命中时新建候选' },
         { label: '三个轴同一套', value: 'Object / Action / Scene 走同一套流程，没有哪个更特殊' },
-        { label: '不唯一就不猜', value: '一个 mention 在多个作用域里都命中时保留原样并报出来。猜错等于把知识挂到错误的对象上，而那个错误会一路传到卡名' },
+        { label: '不唯一就不猜', value: '模型只在给定候选中选择；证据不足时保留歧义。猜错等于把知识挂到错误的对象上，而那个错误会一路传到卡名' },
         { label: '不机械拼前缀', value: '只有原文、章节、SourceRaw 元数据提供了作用域证据，才生成全限定名 —— 「通天塔」+ 每个对象会把「楼层」错加成「通天塔楼层」。人写的指导随已有坐标一起下发，由模型据此判断' },
         /*
          * 「这一次发了多少参考」必须露出来（0068）。模型看不到某条坐标时会以为库里没有它，
@@ -869,8 +959,10 @@ export function buildReport(input: {
         { label: '已有坐标', value: input.axesContext === undefined
           ? '这一次没有下发（没接注册表，或者库里还没有实体）—— 模型只能自己造名字'
           : `下发 ${input.axesContext.injected} / 共 ${input.axesContext.totals} 条${input.axesContext.truncated > 0 ? ` · 未下发 ${input.axesContext.truncated} 条` : ''}${input.axesContext.selection === 'relevant' ? ' · 当前文档相关候选' : input.axesContext.selection === 'full' ? ' · 全集' : ''}，含名字、别名、定义与人写的指导` },
-        { label: '模型可以指认', value: '模型说「这就是已有的某个」，代码会验（查得到 / 同类 / 没被并）；验不过就退回机械解析 —— 与卡片层 existing_id 同一条纪律' },
-        { label: '新建的是候选', value: '没命中就建一个 status=candidate 的实体，等人确认。入库在前、确认在后 —— 与卡片 review 同一条纪律' },
+        { label: '模型补判', value: input.model.axisResolution
+          ? '本次对无法直接命中的坐标发出了一次合并请求；模型只能返回候选 ID，代码会验（查得到 / 同类 / 没被并）'
+          : '本次坐标都可直接解析，或没有可比较的候选，因此没有额外模型请求' },
+        { label: '新建的是候选', value: '模型确认没有匹配项后才建 status=candidate；证据不足时保留歧义，等人确认' },
         { label: '三类绝不进别名', value: '上位概念（「通天塔spm取数」不能含「通天塔」）· 组成部分（不能含「spm取数」）· 相关但不同（不能含「通天塔埋点」）' },
         { label: '注册表', value: axes.some(axis => axis.outcome === 'no-registry')
           ? '这次没有查到库内注册表（这个部署上没有，或调用方没给）。所以只判得动文档内的写法变体'
@@ -918,20 +1010,20 @@ export function buildReport(input: {
     },
     {
       id: 'materialize', order: 5, name: '按坐标成卡', phase: '③ Materialize · 物化', actor: '系统',
-      needsHuman: collisions.length > 0 || noCoordinate.length > 0,
-      summary: `${wikiCards.length} 张 Wiki Card · ${placements} 条知识落位 · ${noCoordinate.length} 条无坐标不成卡`,
+      needsHuman: collisions.length > 0 || noCoordinate.length > 0 || events.some(event => event.noCoordinate),
+      summary: `${wikiCards.length} 张 Wiki Card · ${placements} 条 Knowledge · ${events.filter(event => !event.noCoordinate).length} 个 Event`,
       rows: [
         { label: '三步', value: '按 (object, action, scene) 分组 → 每组物化成一张 Wiki Card → 生成自然语言标题' },
         { label: '标题组织', value: '完整坐标写成「对象在场景下的动作」；缺少分量时退化为通顺的短标题；旧拼接标题保留为 alias' },
         { label: '为什么不让模型做', value: '坐标是卡片主键 · 标题是确定的展示投影 · 模型判会漂移（同一坐标每次给不同标题会污染召回）' },
-        { label: '没有"要不要建卡"', value: '一个坐标 + 至少一条知识，就天然要建。模型只回答判断类问题，机械类问题交给系统' },
-        { label: '不成卡的那些', value: noCoordinate.length > 0 ? `${noCoordinate.length} 条知识没有坐标，不进矩阵也不成卡 —— 它们仍然可被全库命中` : '无' },
+        { label: '卡片由 Knowledge 生成', value: '坐标下至少有一条 Knowledge 才物化 WikiCard；同坐标 Event 只建立引用，不单独建卡' },
+        { label: '不成卡的那些', value: noCoordinate.length + events.filter(event => event.noCoordinate).length > 0 ? `${noCoordinate.length} 条 Knowledge、${events.filter(event => event.noCoordinate).length} 个 Event 缺少坐标，不归入坐标卡` : '无' },
       ],
       items: wikiCards.length > 0
         ? wikiCards.map(card => makeItem(
           coordLabel(card.object, card.action, card.scene),
           card.name,
-          `${card.placements.length} 条知识`,
+          `${card.placements.length} 条 Knowledge · ${card.events.length} 个 Event`,
         ))
         : [makeItem('—', '没有成卡', '知识一条都没有坐标，或者模型没给出知识', 'warn')],
     },
@@ -971,7 +1063,7 @@ export function buildReport(input: {
       ],
       items: [
         makeItem('召回单元', `${sections.size} 个 section`, '卡片按 ## 小节切成一节一条'),
-        makeItem('Knowledge', `${knowledge.length} 条`, '落在这些 section 上的真源（试跑不建索引）'),
+        makeItem('Knowledge / Event', `${knowledge.length} / ${events.length}`, '两类并列真源；Knowledge 生成 WikiCard，Event 通过引用关联'),
         makeItem('轴注册表', `${axes.length} 条`, 'canonical name + aliases —— 不是索引'),
       ],
     },
@@ -1012,6 +1104,7 @@ export function buildReport(input: {
     exceptions.push({ step: '作用域不确定', message: `「${axis.name}」在多个作用域里都命中，没有足够证据选一个 —— ${axis.how}` })
   }
   for (const item of noCoordinate) exceptions.push({ step: '无坐标', message: `「${shortQuote(item.text)}」三个坐标分量都空。它不进矩阵、不成卡，但仍可被全库命中 —— 要人决定补坐标还是单独归档` })
+  for (const event of noCoordinateEvents) exceptions.push({ step: 'Event 无坐标', message: `Event「${shortQuote(event.title)}」没有坐标，因此没有归入 Wiki Card；Event 本身和出处仍保留` })
   for (const twin of twins) exceptions.push({ step: '同义候选', message: `${twin.ids.join(' / ')} 文本归一化后相同，要人确认是不是同一条知识` })
   for (const collision of collisions) {
     const where = collision.cards.map(card => coordLabel(card.object, card.action, card.scene)).join(' / ')
@@ -1029,6 +1122,7 @@ export function buildReport(input: {
     actions,
     scenes,
     knowledge,
+    events,
     wikiCards,
     matrix,
     checks,
@@ -1046,16 +1140,17 @@ function emptyReport(input: {
   title: string; text: string; subject: string; promptUser: string
   system?: string
   axesContext?: { injected: number; totals: number; truncated: number; selection?: 'full' | 'relevant' | 'head' }
-  model: { ok: boolean; why?: string; raw?: string }
+  model: TrialReport['model']
 }): TrialReport {
   const objects: TrialAxis[] = []
   const actions: TrialAxis[] = []
   const scenes: TrialAxis[] = []
   const knowledge: TrialKnowledge[] = []
+  const events: TrialEvent[] = []
   const wikiCards: TrialWikiCard[] = []
   return buildReport({
     title: input.title, text: input.text, subject: input.subject,
-    objects, actions, scenes, knowledge, wikiCards, dropped: [],
+    objects, actions, scenes, knowledge, events, wikiCards, dropped: [],
     matrix: buildMatrix([], [], [], []),
     problems: [],
     model: input.model, promptUser: input.promptUser,
@@ -1087,6 +1182,11 @@ export async function runWikiTrial(input: {
    * 能新建候选）；不给就退化成文档内的机械归一，报告里写 `no-registry`。
    */
   resolveAxis?: TrialAxisResolver
+  /**
+   * 编译链路的批量解析入口。先由注册表直接解析，再把仍有候选的 mention 合并成一次模型补判。
+   * 试跑面板保留 `resolveAxis` 的单条解析路径。
+   */
+  resolveAxisSet?: TrialAxisSetResolver
   /**
    * 已有坐标，**下发进用户提示词**（0068）。
    *
@@ -1108,14 +1208,20 @@ export async function runWikiTrial(input: {
    * 试跑面板不传，用默认值。
    */
   sessionId?: string
+  /** 实际模型选择。凭据不进入轨迹。 */
+  modelRequest?: Omit<NonNullable<TrialReport['model']['request']>, 'sessionId'>
   call?: ModelCall
   callWhy?: string
+  outputFormat?: 'table' | 'json'
+  onDelta?: (text: string) => void
 }): Promise<TrialReport> {
   const subject = (input.subject ?? '').trim()
   const docId = (input.docId ?? '').trim()
   // 提示词先组装好再走分支：模型不可用时它照样要回给界面 —— 用户要看的正是"本来会发出去什么"。
-  const promptUser = buildTrialPrompt({ title: input.title, text: input.text, ...(input.axes === undefined ? {} : { axes: input.axes }), ...(input.note ? { note: input.note } : {}) })
-  const system = buildTrialSystem(input.sections)
+  const promptUser = buildTrialPrompt({ title: input.title, text: input.text, ...(input.axes === undefined ? {} : { axes: input.axes }), ...(input.note ? { note: input.note } : {}), outputFormat: input.outputFormat })
+  const system = buildTrialSystem(input.sections, input.outputFormat)
+  const sessionId = input.sessionId ?? 'knowledge:trial'
+  const request = { ...input.modelRequest, sessionId }
   const axesContext = input.axes === undefined ? undefined : {
     injected: (['object', 'action', 'scene'] as AxisKind[]).reduce((sum, kind) => sum + (input.axes!.entries[kind]?.length ?? 0), 0),
     totals: (['object', 'action', 'scene'] as AxisKind[]).reduce((sum, kind) => sum + (input.axes!.totals[kind] ?? 0), 0),
@@ -1127,22 +1233,37 @@ export async function runWikiTrial(input: {
     return emptyReport({
       title: input.title, text: input.text, subject: subject || input.title, promptUser, system,
       axesContext,
-      model: { ok: false, why: input.callWhy ?? '模型不可用' },
+      model: { ok: false, why: input.callWhy ?? '模型不可用', request },
     })
   }
 
   let raw = ''
+  let usage: TrialTokenUsage | undefined
   try {
-    raw = await input.call({ system, prompt: promptUser, sessionId: input.sessionId ?? 'knowledge:trial' })
+    raw = await input.call({ system, prompt: promptUser, sessionId, onUsage: value => { usage = value }, onDelta: text => { raw += text; input.onDelta?.(text) } })
   } catch (cause) {
     return emptyReport({
       title: input.title, text: input.text, subject: subject || input.title, promptUser, system,
       axesContext,
-      model: { ok: false, why: `调用模型失败：${cause instanceof Error ? cause.message : String(cause)}` },
+      model: {
+        ok: false,
+        why: `调用模型失败：${cause instanceof Error ? cause.message : String(cause)}`,
+        request,
+        ...(raw ? { response: raw } : {}),
+        ...(usage ? { usage } : {}),
+      },
     })
   }
 
-  const parsed = parseJsonObject(raw)
+  let parsed: unknown
+  let outputFormat: 'table' | 'json' = 'json'
+  let parseError = ''
+  const body = raw.trim().replace(/^```(?:toon|text)?\s*\n/, '').replace(/\n```\s*$/, '')
+  try {
+    if (/^format:\s*knowledge-table-v[12]\s*$/m.test(body)) { parsed = decodeExtractionTable(body); outputFormat = 'table' }
+    else parsed = parseJsonObject(raw)
+    if (parsed) parsed = normalizeKnowledgeExtraction(parsed)
+  } catch (cause) { parseError = cause instanceof Error ? cause.message : String(cause) }
   const record = parsed !== null && typeof parsed === 'object' ? parsed as Record<string, unknown> : undefined
   if (!record) {
     return emptyReport({
@@ -1150,7 +1271,10 @@ export async function runWikiTrial(input: {
       axesContext,
       model: {
         ok: false,
-        why: '模型的回答里没有 JSON',
+        why: parseError || '模型返回不是有效的抽取表格或兼容 JSON',
+        request,
+        response: raw,
+        ...(usage ? { usage } : {}),
         // 把模型实际说的那一段带上：只报「不是 JSON」的话，人不知道该去改什么。
         ...(raw.trim() ? { raw: raw.trim().replace(/\s+/g, ' ').slice(0, 160) } : {}),
       },
@@ -1164,9 +1288,10 @@ export async function runWikiTrial(input: {
    */
   const mentions = plainRecord(record.axis_mentions)
   const knowledgeAxes = axisMentionsFromKnowledge(record.knowledge)
-  const objectRead = readAxes(mergeAxisMentions(mentions.objects ?? record.objects, knowledgeAxes.object), 'object')
-  const actionRead = readAxes(mergeAxisMentions(mentions.actions ?? record.actions, knowledgeAxes.action), 'action')
-  const sceneRead = readAxes(mergeAxisMentions(mentions.scenes ?? record.scenes, knowledgeAxes.scene), 'scene')
+  const eventAxes = axisMentionsFromEvents(record.events)
+  const objectRead = readAxes(mergeAxisMentions(mentions.objects ?? record.objects, [...knowledgeAxes.object, ...eventAxes.object]), 'object')
+  const actionRead = readAxes(mergeAxisMentions(mentions.actions ?? record.actions, [...knowledgeAxes.action, ...eventAxes.action]), 'action')
+  const sceneRead = readAxes(mergeAxisMentions(mentions.scenes ?? record.scenes, [...knowledgeAxes.scene, ...eventAxes.scene]), 'scene')
 
 
   /**
@@ -1179,18 +1304,39 @@ export async function runWikiTrial(input: {
    * （`坑位click` → `通天塔坑位click`），而 Knowledge 的坐标写的是 mention。
    * 顺序反了，那条知识就会因为「坐标不在清单里」被当成编造的坐标丢掉。
    */
-  const objects = await resolveAxes('object', objectRead.axes, input.resolveAxis)
-  const actions = await resolveAxes('action', actionRead.axes, input.resolveAxis)
-  const scenes = await resolveAxes('scene', sceneRead.axes, input.resolveAxis)
+  let objects: TrialAxis[]
+  let actions: TrialAxis[]
+  let scenes: TrialAxis[]
+  let axisResolution: TrialModelCallTrace | undefined
+  if (input.resolveAxisSet) {
+    const resolved = await input.resolveAxisSet({
+      objects: objectRead.axes,
+      actions: actionRead.axes,
+      scenes: sceneRead.axes,
+    })
+    objects = resolved.objects
+    actions = resolved.actions
+    scenes = resolved.scenes
+    axisResolution = resolved.trace
+  } else {
+    objects = await resolveAxes('object', objectRead.axes, input.resolveAxis)
+    actions = await resolveAxes('action', actionRead.axes, input.resolveAxis)
+    scenes = await resolveAxes('scene', sceneRead.axes, input.resolveAxis)
+  }
   const knowledgeRead = readKnowledge(record.knowledge, {
     text: input.text,
     // 有真文档就用它的 id：来源要指得回那份文档，而不是一个标题字符串。
     documentId: docId || input.title,
     objects, actions, scenes,
   })
+  const eventRead = readEvents(record.events, {
+    text: input.text,
+    documentId: docId || input.title,
+    objects, actions, scenes,
+  })
   // `dropped` 在新契约里收在 `audit` 下 —— 它是审计，不是知识模型的一部分（§5.5）。
   const dropped = readDropped(plainRecord(record.audit).dropped ?? record.dropped)
-  const wikiCards = materialize(knowledgeRead.knowledge)
+  const wikiCards = materialize(knowledgeRead.knowledge, eventRead.events)
   const modelSubject = str(record.subject) || subject || input.title
 
   return buildReport({
@@ -1199,13 +1345,25 @@ export async function runWikiTrial(input: {
     actions,
     scenes,
     knowledge: knowledgeRead.knowledge,
+    events: eventRead.events,
     wikiCards,
-    matrix: buildMatrix(objects.map(axis => axis.name), actions.map(axis => axis.name), knowledgeRead.knowledge, wikiCards),
-    problems: [...objectRead.problems, ...actionRead.problems, ...sceneRead.problems, ...knowledgeRead.problems],
+    matrix: buildMatrix(objects.map(axis => axis.name), actions.map(axis => axis.name), knowledgeRead.knowledge, wikiCards, eventRead.events),
+    problems: [...objectRead.problems, ...actionRead.problems, ...sceneRead.problems, ...knowledgeRead.problems, ...eventRead.problems],
     dropped,
-    model: knowledgeRead.knowledge.length > 0
-      ? { ok: true }
-      : { ok: false, why: '模型没有给出任何知识' },
+    model: {
+      ok: knowledgeRead.knowledge.length > 0 || eventRead.events.length > 0,
+      parsed: Array.isArray(record.knowledge) && Array.isArray(record.events ?? [])
+        && knowledgeRead.knowledge.length === record.knowledge.length
+        && eventRead.events.length === (Array.isArray(record.events) ? record.events.length : 0)
+        && knowledgeRead.knowledge.every(item => item.sources.length > 0 && item.sources.every(source => source.found))
+        && eventRead.events.every(item => [...item.sources, ...item.timeline.flatMap(step => step.sources)].every(source => source.found)),
+      outputFormat,
+      ...(!(knowledgeRead.knowledge.length > 0 || eventRead.events.length > 0) ? { why: '模型没有给出 Knowledge 或 Event' } : {}),
+      request,
+      response: raw,
+      ...(usage ? { usage } : {}),
+      ...(axisResolution ? { axisResolution } : {}),
+    },
     promptUser, system,
     ...(axesContext === undefined ? {} : { axesContext }),
   })
@@ -1227,6 +1385,18 @@ export type TrialAxisResolver = (
   extra?: { preferMention?: string; description?: string },
 ) => Promise<AxisResolution | null>
 
+export interface TrialAxisSet {
+  objects: TrialAxis[]
+  actions: TrialAxis[]
+  scenes: TrialAxis[]
+}
+
+export interface TrialAxisSetResolution extends TrialAxisSet {
+  trace?: TrialModelCallTrace
+}
+
+export type TrialAxisSetResolver = (axes: TrialAxisSet) => Promise<TrialAxisSetResolution>
+
 /** 命中方式 → 给人看的一句话。 */
 function describeHit(resolution: AxisResolution): string {
   switch (resolution.how) {
@@ -1263,33 +1433,35 @@ async function resolveAxes(
     })
     // `null` = 这个部署上没有注册表。那不是「没命中」，是「这一次没查过」。
     if (resolution === null) return axes
-    if ((resolution.outcome === 'matched' || resolution.outcome === 'created') && resolution.entity) {
-      const entity = resolution.entity
-      out.push({
-        name: entity.name,
-        id: entity.id,
-        // 原来的 mention 进别名：它可能只是这个实体的一种写法。
-        aliases: [...new Set([...axis.aliases, ...(entity.name === axis.name ? [] : [axis.name])])],
-        outcome: resolution.outcome === 'created' ? 'new' : 'matched',
-        how: describeHit(resolution),
-        // 报告里显示的是**库里那份**（模型这次给的可能没被采纳 —— 人写的定义不许覆盖）。
-        ...(entity.description ? { definition: entity.description } : axis.definition ? { definition: axis.definition } : {}),
-        ...(axis.evidence ? { evidence: axis.evidence } : {}),
-      })
-      continue
+    out.push(applyTrialAxisResolution(axis, resolution))
+  }
+  return out
+}
+
+/** 将注册表结论变成报告里的坐标。供批量补判复用同一套字段处理。 */
+export function applyTrialAxisResolution(axis: TrialAxis, resolution: AxisResolution | null): TrialAxis {
+  if (resolution === null) return { ...axis, outcome: 'no-registry', how: '只做了文档内的机械归一' }
+  if ((resolution.outcome === 'matched' || resolution.outcome === 'created') && resolution.entity) {
+    const entity = resolution.entity
+    return {
+      name: entity.name,
+      id: entity.id,
+      aliases: [...new Set([...axis.aliases, ...(entity.name === axis.name ? [] : [axis.name])])],
+      outcome: resolution.outcome === 'created' ? 'new' : 'matched',
+      how: describeHit(resolution),
+      ...(entity.description ? { definition: entity.description } : axis.definition ? { definition: axis.definition } : {}),
+      ...(axis.evidence ? { evidence: axis.evidence } : {}),
     }
-    if (resolution.outcome === 'ambiguous') {
-      const names = (resolution.candidates ?? []).map(candidate => candidate.name)
-      out.push({
-        ...axis,
-        outcome: 'ambiguous',
-        how: names.length > 0 ? `不唯一，候选：${names.join('、')}` : '不唯一，但注册表里没有候选',
-      })
-      continue
+  }
+  if (resolution.outcome === 'ambiguous') {
+    const names = (resolution.candidates ?? []).map(candidate => candidate.name)
+    return {
+      ...axis,
+      outcome: 'ambiguous',
+      how: names.length > 0 ? `不唯一，候选：${names.join('、')}` : '不唯一，但注册表里没有候选',
     }
-    out.push({ ...axis, outcome: 'no-registry', how: '只做了文档内的机械归一' })
   }
-  return out
+  return { ...axis, outcome: 'ambiguous', how: '坐标为空，无法解析' }
 }
 
 /** 读 `dropped`。它是**审计轨迹**（§5.5），不进知识模型。 */
@@ -1308,10 +1480,10 @@ function readDropped(raw: unknown): Array<{ quote: string; why: string }> {
 
 /** 给界面用的一句话规模描述。矩阵的规模由界面自己从 `matrix` 取。 */
 export function trialSummary(report: TrialReport): string {
-  const pieces = [
+    const pieces = [
     `${report.lines} 行`, `${report.chars} 字`,
     `${report.objects.length} 对象`, `${report.actions.length} 动作`, `${report.scenes.length} 场景`,
-    `${report.knowledge.length} 知识`, `${report.wikiCards.length} Wiki Card`,
+    `${report.knowledge.length} Knowledge`, `${report.events.length} Event`, `${report.wikiCards.length} Wiki Card`,
   ]
   const dropped = report.audit.dropped.length
   if (dropped > 0) pieces.push(`丢弃 ${dropped} 段`)