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

package/lib/types/wiki-trial.js

@@ -1,53 +1,6 @@
-/**
- * Wiki 抽取试跑（0063）：**调一次模型**按新方案判一遍，不落盘。
- *
- * ## 五层
- *
- * ```
- * Document ──▶ Knowledge ──▶ Canonical Knowledge ──▶ Wiki Card ──▶ 索引
- * ```
- *
- * - **Knowledge** 是知识：一条可独立检索、验证或执行的最小知识单元。
- *   **只有 `text` 是内容**；`object` / `action` / `scene` / `sources` 都是索引与出处。
- *   把索引当知识，是这套模型最常见的误解。
- * - **Coordinate** 是 `(object, action, scene)` 这个位置。它是**复合键，不是实体** ——
- *   所以没有 Coordinate 表，也没有"坐标实体"这一层。一条 Knowledge 只有一个坐标，
- *   那是它的「家」。别的卡可以引用它，那是卡的事，不是坐标的事。
- * - **Wiki Card** 是交付视图：一个坐标 + 至少一条 Knowledge 就物化成一张。
- *   标题是**坐标的自然语言投影**，由系统推导 —— 坐标是判重键，模型不参与命名。
- * - **索引**有三个：轴 / Knowledge / Wiki Card。前两个装内容，第三个装任务。
- *
- * ## 四个阶段，七个动作
- *
- * | 阶段 | 动作 |
- * |---|---|
- * | ① Extract | 1 Semantic Extraction |
- * | ② Resolve | 2 Entity Resolution · 3 Knowledge Resolution · 4 Coordinate Assignment |
- * | ③ Materialize | 5 Card Materialization · 6 Card Organization |
- * | ④ Index | 7 Build Index |
- *
- * 顺序里有一条硬规矩：**先把"知识是什么"搞清楚，再决定"这些知识怎么组织成 Wiki Card"。**
- * Wiki Card 是组织结果，不是知识合并结果。
- *
- * ## 只调一次
- *
- * 七步是给人 review 的，不是给模型分的工。一次调用输入全文，输出一个 JSON：
- * `subject` / `knowledge` / `objects` / `actions` / `scenes` / `dropped`。
- * 分块只在文档塞不进上下文时才做。
- *
- * ## 对象 × 动作矩阵
- *
- * 矩阵**不让模型再填一遍**。它是 Knowledge 坐标的二维排布，本地算出来的：行是对象，列是动作，
- * 多一行「无对象」收只有动作的知识，多一列「无动作」收只有对象的知识。
- *
- * **坐标是三维的，矩阵是它的二维投影。** 场景落在格子**内部**，不进坐标轴 ——
- * 一格里有几个场景，就有几张卡。
- *
- * ## 只读
- *
- * 它不写 SourceRaw、不建卡、不进索引。给一段正文，返回四个阶段的判定结果与矩阵。
- */
-import { AXIS_CONTRACT_LINES } from './axis-contract.js';
+import { normalizeKnowledgeExtraction } from './knowledge-contract.js';
+import { buildTrialSystem } from './extract-contract.js';
+import { decodeExtractionTable } from './extract-table.js';
 /**
  * 抽取契约（0063 §5.6）。**这是契约，不是要抄进代码的字符串。**
  *
@@ -58,101 +11,8 @@ import { AXIS_CONTRACT_LINES } from './axis-contract.js';
  * 2. 三个分量**可以全空** —— §九 明写"允许 Knowledge 没有领域坐标"。
  *    文档 §5.6 里"每条至少挂一个 object 或一个 action"与它冲突。
  */
-/**
- * 把骨架允许的小节拼成提示词里那一条。
- *
- * §5.3.2 说「`section` 的合法取值来自类型定义」—— 那就应当**下发**给它，帮助模型
- * 使用一致的小节名。不下发的话，那句「合法取值来自类型定义」只是一句写在文档里的愿望。
- */
-function sectionRule(sections) {
-    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) {
-    return trialSystemBody(sectionRule(sections));
-}
-const trialSystemBody = (positionRule) => [
-    '你在把一份业务文档拆成知识库要用的内容。知识以 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();
 /** 组装提示词。全文进去 —— 标题本来就在正文里，不必再列一遍。 */
@@ -172,7 +32,7 @@ export function buildTrialPrompt(input) {
     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');
 }
 const AXIS_BLOCK_TITLE = { object: '对象', action: '动作', scene: '场景' };
@@ -235,6 +95,11 @@ function renderAxisBlock(block) {
 /** 从可能带 ``` 围栏的文本里取出 JSON。与 `extract-model.ts` 同构。 */
 function parseJsonObject(raw) {
     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 {
@@ -269,7 +134,7 @@ function plainRecord(value) {
  * 被误报为「清单外」并置空，最终整批 Knowledge 都变成「无坐标」。先把它们补回
  * 抽取清单，再走同一套 Entity Resolution，既不猜坐标，也不绕过注册表。
  */
-function axisMentionsFromKnowledge(raw) {
+function axisMentionsFromItems(raw) {
     const out = { object: [], action: [], scene: [] };
     if (!Array.isArray(raw))
         return out;
@@ -292,6 +157,12 @@ function axisMentionsFromKnowledge(raw) {
     }
     return out;
 }
+function axisMentionsFromKnowledge(raw) {
+    return axisMentionsFromItems(raw);
+}
+function axisMentionsFromEvents(raw) {
+    return axisMentionsFromItems(raw);
+}
 /** 顶层轴清单优先，Knowledge 坐标只补缺项；readAxes 会按归一化名称去重。 */
 function mergeAxisMentions(raw, supplements) {
     return [...(Array.isArray(raw) ? raw : []), ...supplements];
@@ -581,6 +452,9 @@ function readKnowledge(raw, options) {
         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 } : {}),
             text,
             object,
             action,
@@ -593,6 +467,141 @@ function readKnowledge(raw, options) {
     }
     return { knowledge, problems };
 }
+function readTrialSources(raw, options) {
+    if (!Array.isArray(raw))
+        return [];
+    const sources = [];
+    for (const item of raw) {
+        if (item === null || typeof item !== 'object')
+            continue;
+        const source = item;
+        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, options) {
+    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])));
+    const actionMap = new Map(options.actions.flatMap(axis => [axis.name, ...axis.aliases].map(name => [normalizeAxisName(name), axis.name])));
+    const sceneMap = new Map(options.scenes.flatMap(axis => [axis.name, ...axis.aliases].map(name => [normalizeAxisName(name), axis.name])));
+    const events = [];
+    const problems = [];
+    const ids = new Set();
+    for (const entry of raw) {
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        const record = entry;
+        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, map, axis) => {
+            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 = [];
+        if (Array.isArray(record.timeline)) {
+            for (const [index, rawStep] of record.timeline.entries()) {
+                if (rawStep === null || typeof rawStep !== 'object')
+                    continue;
+                const step = rawStep;
+                const description = str(step.description);
+                if (!description)
+                    continue;
+                const candidateType = str(step.type);
+                const type = ['observation', 'check', 'action', 'result', 'conclusion'].includes(candidateType)
+                    ? candidateType
+                    : '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 = rootCause && (rootStatus === 'confirmed' || rootStatus === 'suspected')
+            ? rootStatus
+            : null;
+        const missing = strList(record.missing);
+        const addMissing = (label, missingValue) => {
+            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 };
+}
 // ------------------------------------------------------------ 本地推导
 /**
  * 物化 Wiki Card（第 5 步）。**系统做，确定性。**
@@ -606,27 +615,40 @@ function readKnowledge(raw, options) {
  * **没有"要不要建卡"这个问题。** 一个坐标 + 至少一条知识，就天然要建。
  * 三个分量全空的知识不成卡 —— 它没有坐标。
  */
-export function materialize(knowledge) {
+export function materialize(knowledge, events = []) {
     const groups = new Map();
-    for (const item of knowledge) {
-        if (item.noCoordinate)
-            continue;
-        const key = `${item.object ?? ''}\u0001${item.action ?? ''}\u0001${item.scene ?? ''}`;
+    const groupOf = (object, action, scene) => {
+        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()];
 }
@@ -644,7 +666,7 @@ export function materialize(knowledge) {
  *
  * 组是**最小的可点单位**：点一个数字要看到的就是那一组的知识。
  */
-export function buildMatrix(objects, actions, knowledge, wikiCards) {
+export function buildMatrix(objects, actions, knowledge, wikiCards, events = []) {
     /** 一组一组的桶。键是 `object\u0001action\u0001scene`。 */
     const buckets = new Map();
     const bucketOf = (object, action, scene) => {
@@ -652,7 +674,7 @@ export function buildMatrix(objects, actions, knowledge, wikiCards) {
         const hit = buckets.get(key);
         if (hit)
             return hit;
-        const created = { object, action, scene, knowledge: 0, items: [] };
+        const created = { object, action, scene, knowledge: 0, events: 0, items: [], eventItems: [] };
         buckets.set(key, created);
         return created;
     };
@@ -663,6 +685,13 @@ export function buildMatrix(objects, actions, knowledge, wikiCards) {
         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();
     for (const card of wikiCards) {
@@ -676,8 +705,10 @@ export function buildMatrix(objects, actions, knowledge, wikiCards) {
             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,
             });
         }
         // 场景名的阅读顺序：先空场景（它是「没有细分」的那一组），再按名字。
@@ -689,7 +720,7 @@ export function buildMatrix(objects, actions, knowledge, wikiCards) {
             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) });
         }
     }
     // 行头：这一行里「有对象、没动作」的那些知识。列头同理。
@@ -697,13 +728,13 @@ export function buildMatrix(objects, actions, knowledge, wikiCards) {
     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) });
+            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 = [];
     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) });
+            noObject.push({ name: action, groups, knowledge: groups.reduce((sum, group) => sum + group.knowledge, 0), events: groups.reduce((sum, group) => sum + group.events, 0) });
     }
     return {
         objects,
@@ -712,6 +743,7 @@ export function buildMatrix(objects, actions, knowledge, wikiCards) {
         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,
@@ -761,10 +793,10 @@ function findTwins(knowledge) {
  * 每一步给两样：`rows`（按什么判、缺什么）和 `items`（**逐条判出的实际值**）。
  * 试跑面板是给人逐步 review 的，只有统计没有值就没法 review。
  *
- * 第 2、3 步里如实写明单文档试跑缺什么：归一缺库内注册表，同义与冲突缺第二次模型调用。
+ * 第 2、3 步里如实写明能力边界：轴归一需要库内注册表，候选歧义可在编译时补判；知识同义与冲突仍不做模型裁决。
  */
 export function buildReport(input) {
-    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);
@@ -781,8 +813,15 @@ export function buildReport(input) {
                 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));
@@ -790,25 +829,28 @@ export function buildReport(input) {
     const steps = [
         {
             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(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)),
             ],
-            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)),
         },
         {
             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）。模型看不到某条坐标时会以为库里没有它，
@@ -817,8 +859,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')
                         ? '这次没有查到库内注册表（这个部署上没有，或调用方没给）。所以只判得动文档内的写法变体'
@@ -861,17 +905,17 @@ 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} 条知识`))
+                ? wikiCards.map(card => makeItem(coordLabel(card.object, card.action, card.scene), card.name, `${card.placements.length} 条 Knowledge · ${card.events.length} 个 Event`))
                 : [makeItem('—', '没有成卡', '知识一条都没有坐标，或者模型没给出知识', 'warn')],
         },
         {
@@ -907,7 +951,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 —— 不是索引'),
             ],
         },
@@ -950,6 +994,8 @@ export function buildReport(input) {
     }
     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) {
@@ -968,6 +1014,7 @@ export function buildReport(input) {
         actions,
         scenes,
         knowledge,
+        events,
         wikiCards,
         matrix,
         checks,
@@ -985,10 +1032,11 @@ function emptyReport(input) {
     const actions = [];
     const scenes = [];
     const knowledge = [];
+    const events = [];
     const wikiCards = [];
     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,
@@ -1007,8 +1055,10 @@ export async function runWikiTrial(input) {
     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'].reduce((sum, kind) => sum + (input.axes.entries[kind]?.length ?? 0), 0),
         totals: ['object', 'action', 'scene'].reduce((sum, kind) => sum + (input.axes.totals[kind] ?? 0), 0),
@@ -1019,21 +1069,44 @@ 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;
     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;
+    let outputFormat = '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 : undefined;
     if (!record) {
         return emptyReport({
@@ -1041,7 +1114,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) } : {}),
             },
@@ -1054,9 +1130,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');
     /**
      * Resolve 第 2 步：把 mention 交给**轴注册表**。
      *
@@ -1067,18 +1144,40 @@ 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;
+    let actions;
+    let scenes;
+    let axisResolution;
+    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({
         title: input.title, text: input.text, subject: modelSubject,
@@ -1086,13 +1185,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 }),
     });
@@ -1132,34 +1243,36 @@ async function resolveAxes(kind, axes, resolveAxis) {
         // `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;
-        }
-        if (resolution.outcome === 'ambiguous') {
-            const names = (resolution.candidates ?? []).map(candidate => candidate.name);
-            out.push({
-                ...axis,
-                outcome: 'ambiguous',
-                how: names.length > 0 ? `不唯一，候选：${names.join('、')}` : '不唯一，但注册表里没有候选',
-            });
-            continue;
-        }
-        out.push({ ...axis, outcome: 'no-registry', how: '只做了文档内的机械归一' });
+        out.push(applyTrialAxisResolution(axis, resolution));
     }
     return out;
 }
+/** 将注册表结论变成报告里的坐标。供批量补判复用同一套字段处理。 */
+export function applyTrialAxisResolution(axis, resolution) {
+    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);
+        return {
+            ...axis,
+            outcome: 'ambiguous',
+            how: names.length > 0 ? `不唯一，候选：${names.join('、')}` : '不唯一，但注册表里没有候选',
+        };
+    }
+    return { ...axis, outcome: 'ambiguous', how: '坐标为空，无法解析' };
+}
 /** 读 `dropped`。它是**审计轨迹**（§5.5），不进知识模型。 */
 function readDropped(raw) {
     if (!Array.isArray(raw))
@@ -1181,7 +1294,7 @@ export function trialSummary(report) {
     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)