dsh-data-domain-knowledge 0.1.0-alpha.13 → 0.1.0-alpha.14

package/src/diagnosis/store.ts

@@ -7,7 +7,7 @@ import {
   cardFromRecord, cardsToGraph, CARD_EDGE_KINDS, graphToCards, parseCard, serializeCard,
   RUN_EDGE_KINDS, type DiagnosisCard,
 } from './cards.js'
-import { caseCardOf, parseRunSource, renderRunSource, runReferenceProblems, runToGraph } from './run.js'
+import { caseViewOfRun, parseRunSource, renderRunSource, runReferenceProblems, runToGraph } from './run.js'
 import type {
   AttributionCase, AttributionEdge, AttributionEvent, AttributionGraphData, AttributionNode, AttributionNodeKind, DiagnosisRunRecord,
 } from './types.js'
@@ -22,7 +22,7 @@ import type { SchemaType } from '../types.js'
  * | 目录 | 内容 | 谁是真相 |
  * | --- | --- | --- |
  * | `01_source_raw/` | 手册、复盘与排查原文 | SourceRaw 的唯一真相 |
- * | `02_wiki/diagnosis/` | 五类卡片（三段式） | **知识侧的唯一真相**，由一次排查 / 载入示例 / 迁移直接写入（0044 起不经人确认） |
+ * | `02_wiki/diagnosis/` | 历史诊断卡片 | 仅为旧数据兼容读取；新排查不再写 diagnosis/case 卡片 |
  *
  * `05_diagnosis/` 在 v1.1 撤销了（0021 §0.3）。它同时装着两类东西 —— 「一次排查的产物」
  * （源头）与「五类模板卡」（配置）—— 一个编号段混装两种性质，`rebuild --only` 的语义
@@ -58,8 +58,8 @@ const LEGACY_RUN_SHARDS: Record<string, AttributionNodeKind> = {
   'causes.jsonl': 'cause',
 }
 
-/** 读取顺序的显式来源，界面据此说明「现在看到的是哪一份」。 */
-export type DiagnosisSource = 'cards' | 'jsonl' | 'empty'
+/** 读取来源，界面据此说明当前展示的是卡片、记录、旧快照还是空库。 */
+export type DiagnosisSource = 'cards' | 'records' | 'jsonl' | 'empty'
 
 export interface DiagnosisSnapshot {
   graph: AttributionGraphData
@@ -119,20 +119,21 @@ export class DiagnosisStore {
   }
 
   /**
-   * 载入**内置示例**：一份排查手册 + 三篇复盘 + 三次排查日志 → SourceRaw → 卡片 → 图。
+   * 载入**内置示例**：一份排查手册 + 三篇复盘 + 三次排查日志 → SourceRaw、可复用诊断卡与只读排查视图。
    *
    * 只有用户明确点了「载入内置示例」才走这里（`ensure()` 不再自动调用）。幂等：
    * `addSource` 按 `externalId`、`writeCard` 按 entityId，点两次不会写出第二份。
    *
-   * **它走的是「提议 → 确认」那条门，不是绕过它**（0021 §6.1）。区别只在确认者是谁：
-   * 用户点「载入内置示例」这个动作本身就是**对整批示例的确认**，所以这里给每条提议记下
-   * `confirmedBy = user:load-sample`，然后照常走 `writeCard`。这样做的两个好处：
-   * 待办区里能看到这批卡片是怎么来的；而「未确认不落 `02_wiki/`」这条规则没有被开一个
-   * 后门 —— 例外是**确认者的身份**，不是门的缺失。
+   * 示例里的可复用诊断 Knowledge 是预先整理好的演示数据，直接写入当前知识库。
+   * 三条排查记录作为 SourceRaw 写入，并由读取层派生只读 Case 视图；不创建 `diagnosis/case` WikiCard。
    */
   async loadSample(): Promise<{ seeded: boolean; migrated: boolean; problems: string[] }> {
     const { problems: sourceProblems, refs } = await this.writeSources(seedSources())
-    const cards = withSourceRefs(graphToCards(SEED_GRAPH, SEED_CASES), refs, SEED_CASES)
+    const cards = withSourceRefs(
+      graphToCards(SEED_GRAPH),
+      refs,
+      SEED_CASES,
+    )
     const problems = [...sourceProblems, ...await this.writeCards(cards, 'user:load-sample')]
     return { seeded: true, migrated: false, problems }
   }
@@ -146,40 +147,26 @@ export class DiagnosisStore {
     const { seeded, migrated, problems } = await this.ensure()
     const cards = await this.readCards()
     const events = await this.readEvents()
+    const baseGraph = cards.length > 0 ? { nodes: [], edges: [] } : await this.readLegacyGraph()
+    const baseCases = cards.length > 0 ? [] : await this.readLegacyCases()
+    const built = await this.buildGraph(cards, baseGraph, baseCases)
+    const runRecords = (await this.readRuns()).records
     /**
-     * 「什么都没有」= 没有卡片、也没有旧 jsonl。它是**可以载入内置示例**的唯一条件：
+     * 「什么都没有」= 没有卡片、Event、排查日志和旧 jsonl。它是**可以载入内置示例**的唯一条件：
      * 已经有知识（不管哪一代形态）时不该再往里塞示例 —— 那会变成第二份互相矛盾的知识。
      */
-    const canLoadSample = cards.length === 0 && events.length === 0 && (await this.legacyShardFiles()).length === 0
-
-    if (cards.length > 0) {
-      const built = await this.buildGraph(cards)
-      return {
-        graph: built.graph,
-        cases: built.cases,
-        events,
-        issues: validateDiagnosis(built.graph),
-        seeded,
-        migrated,
-        source: 'cards',
-        canLoadSample: false,
-        problems: [...problems, ...built.problems],
-      }
-    }
-
-    // 还没有卡片：旧 jsonl 就是当前可读的来源；两份都没有就是一个空库。
-    const graph = await this.readLegacyGraph()
-    const cases = await this.readLegacyCases()
+    const canLoadSample = cards.length === 0 && events.length === 0 && runRecords.length === 0
+      && baseGraph.nodes.length === 0 && baseCases.length === 0 && (await this.legacyShardFiles()).length === 0
     return {
-      graph,
-      cases,
+      graph: built.graph,
+      cases: built.cases,
       events,
-      issues: validateDiagnosis(graph),
+      issues: validateDiagnosis(built.graph),
       seeded,
       migrated,
-      source: canLoadSample ? 'empty' : events.length > 0 ? 'cards' : 'jsonl',
+      source: canLoadSample ? 'empty' : cards.length > 0 ? 'cards' : events.length > 0 || runRecords.length > 0 ? 'records' : 'jsonl',
       canLoadSample,
-      problems,
+      problems: [...problems, ...built.problems],
     }
   }
 
@@ -190,21 +177,27 @@ export class DiagnosisStore {
    * 与四条执行边全部来自 `agent_diagnosis_case` 的 SourceRaw。合成一张图是**读**的时候
    * 做的，不是写的时候 —— 写的时候合成，等于让一次执行的结果变成可复用的知识。
    */
-  private async buildGraph(cards: DiagnosisCard[]): Promise<{ graph: AttributionGraphData; cases: AttributionCase[]; problems: string[] }> {
+  private async buildGraph(cards: DiagnosisCard[], baseGraph: AttributionGraphData = { nodes: [], edges: [] }, baseCases: AttributionCase[] = []): Promise<{ graph: AttributionGraphData; cases: AttributionCase[]; problems: string[] }> {
     const compiled = cardsToGraph(cards)
     const problems = [...compiled.problems]
-    const nodes: AttributionNode[] = [...compiled.graph.nodes]
-    const edges: AttributionEdge[] = [...compiled.graph.edges]
+    const nodes: AttributionNode[] = [...baseGraph.nodes, ...compiled.graph.nodes]
+    const edges: AttributionEdge[] = [...baseGraph.edges, ...compiled.graph.edges]
+    const knownCardNodes = [...baseGraph.nodes, ...compiled.graph.nodes]
+    const cases = new Map<string, AttributionCase>()
+    for (const item of [...baseCases, ...compiled.cases]) cases.set(item.id, item)
 
     const runs = await this.readRuns()
     problems.push(...runs.problems)
     for (const record of runs.records) {
       const run = runToGraph(record)
       // 引用完整性要**连这次排查自己产出的 id 一起算**：路径里的 `E1` / `C1` 正是它写下的。
-      const known = new Set([...compiled.graph.nodes.map(node => node.id), ...run.nodes.map(node => node.id)])
+      const known = new Set([...knownCardNodes.map(node => node.id), ...run.nodes.map(node => node.id)])
       problems.push(...run.problems, ...runReferenceProblems(record, known))
       nodes.push(...run.nodes)
       edges.push(...run.edges)
+      const symptomTitle = knownCardNodes.find(node => node.id === record.symptomId)?.title ?? record.symptomId
+      const view = caseViewOfRun(record, symptomTitle)
+      cases.set(view.id, view)
     }
 
     /**
@@ -219,7 +212,7 @@ export class DiagnosisStore {
     nodes.push(...legacyRun.nodes)
     edges.push(...legacyRun.edges)
 
-    return { graph: dedupe({ nodes, edges }, problems), cases: compiled.cases, problems }
+    return { graph: dedupe({ nodes, edges }, problems), cases: [...cases.values()], problems }
   }
 
   /**
@@ -247,14 +240,15 @@ export class DiagnosisStore {
 
   async readGraph(): Promise<AttributionGraphData> {
     const cards = await this.readCards()
-    if (cards.length > 0) return (await this.buildGraph(cards)).graph
-    return await this.readLegacyGraph()
+    const baseGraph = cards.length > 0 ? { nodes: [], edges: [] } : await this.readLegacyGraph()
+    return (await this.buildGraph(cards, baseGraph)).graph
   }
 
   async readCases(): Promise<AttributionCase[]> {
     const cards = await this.readCards()
-    if (cards.length > 0) return cardsToGraph(cards).cases
-    return await this.readLegacyCases()
+    const baseGraph = cards.length > 0 ? { nodes: [], edges: [] } : await this.readLegacyGraph()
+    const baseCases = cards.length > 0 ? [] : await this.readLegacyCases()
+    return (await this.buildGraph(cards, baseGraph, baseCases)).cases
   }
 
   /* ────────────────────────────────────────────── 卡片：读写 ── */
@@ -326,15 +320,11 @@ export class DiagnosisStore {
   }
 
   /**
-   * 一次排查结束：写一条 SourceRaw，并**直接写入**一张案例卡片。
-   *
-   * 0044：案例卡片原来只提议、等人确认。与编译那条链路一样改成直接入库 ——
-   * 一次排查的价值就在于「当时是怎么走的」，让它停在待办队列里等于把经验丢掉。
-   * 卡片会被标成 `unreviewed`，人在「知识库 → Wiki」里 review 它。
-   *
-   * 幂等：`externalId` = runId，同一次排查重跑不会写出第二条来源；卡片按 entityId 写入。
+   * 一次排查结束只写一条 SourceRaw。案例视图从这条记录派生；Knowledge / Event 的抽取与归一
+   * 仍由知识处理阶段执行，避免把同一份排查过程再写成另一张 WikiCard。
+   * 幂等：`externalId` = runId，同一次排查重跑不会写出第二条来源。
    */
-  async recordRun(record: DiagnosisRunRecord): Promise<{ sourceId?: string; entityId?: string; problems: string[] }> {
+  async recordRun(record: DiagnosisRunRecord): Promise<{ sourceId?: string; problems: string[] }> {
     const problems: string[] = []
     const added = await this.host.addSource({
       title: `AI 诊断日志 · ${record.symptomId} · ${record.runId}`,
@@ -345,18 +335,7 @@ export class DiagnosisStore {
     if (added.ok === false) return { problems: [`诊断日志 ${record.runId} 写入失败：${added.error.code} ${added.error.message}`] }
     const sourceId = added.data.sourceId
 
-    const symptomTitle = (await this.readCards()).find(card => card.entityId === record.symptomId)?.title ?? record.symptomId
-    const draft = caseCardOf(record, symptomTitle)
-    const written = await this.host.writeCard({
-      entityType: draft.entityType as SchemaType,
-      entityId: draft.entityId,
-      title: draft.title,
-      content: renderCardBody(draft),
-      sourceRefs: [sourceId],
-      status: 'unreviewed',
-    })
-    if (written.ok === false) problems.push(`案例卡片 ${draft.entityId} 写入失败：${written.error.code} ${written.error.message}`)
-    return { sourceId, ...(written.ok === false ? {} : { entityId: draft.entityId }), problems }
+    return { sourceId, problems }
   }
 
   /* ────────────────────────────────────────────── 旧知识根迁移 ── */
@@ -499,8 +478,8 @@ export function renderCardBody(card: DiagnosisCard): string {
 /**
  * 给卡片挂出处。
  *
- * 规则是**数据驱动的**，不是凭印象分的：案例卡片与它自己的复盘原文一一对应；
- * 其它卡片取「第一篇走过它的复盘」，没有走过它的就挂那本手册。
+ * 规则是**数据驱动的**，不是凭印象分的：可复用诊断卡优先引用第一篇走过该节点的复盘；
+ * 没有经过复盘的节点引用手册。历史 Case 卡仍由旧数据读取，不在新示例里生成。
  */
 function withSourceRefs(
   cards: DiagnosisCard[],

package/src/diagnosis/types.ts

@@ -15,7 +15,8 @@ import type { ProblemClassId } from './problem-classes.js'
 export type NodeLayer = 'type' | 'reference' | 'instance'
 
 /**
- * 九类归因节点。与 wiki 卡片的 `entity_type` 一一对应（`asset` 与三类执行产物除外）。
+ * 九类归因图节点。当前 Knowledge 节点可对应 WikiCard；`case` 是排查记录视图，
+ * `asset` 与执行产物也不对应 WikiCard。历史 Case WikiCard 仅为兼容数据。
  *
  * **两个名字用的是下划线**（`check_point` / `failure_reason`），卡片类型用连字符
  * （`diagnosis/check-point` / `diagnosis/failure-reason`）：kind 是代码里的标识符，
@@ -187,18 +188,9 @@ export interface AttributionGraphData {
 }
 
 /**
- * 案例 = **一篇 wiki 定义 + 一条有序排查路径**。
- *
- * 它住在领域层而不是示例里（原来是 `seed.ts`）：案例是编译产物的一种
- * （`cardsToGraph()` 从卡片把它算出来，`/diagnosis/graph` 把它发给界面），
- * 而示例只是**一份**案例的取值来源。视图要渲染「服务端给的案例」，
- * 那它 import 的形状就不该从示例模块里拿。
- *
- * 两段各有明确消费者，不能合并：
- * - `sections` 是给人读、给向量召回的散文（可 diff、可评审、可追溯）；
- * - `path` 是给图和剪枝用的结构（有序、可判真假、带被否定的分支）。
- *
- * 序和枚举一旦写进散文，归并算法就再也读不到它们了 —— 所以路径单独成段。
+ * Case 是一次排查记录的只读展示投影，不是持久化实体。
+ * `sections` 供人阅读，`path` 保留检查顺序与被否定的分支；来源是 SourceRaw 运行记录。
+ * 历史 `diagnosis/case` WikiCard 仍可读取，但新的运行与示例载入不再生成它。
  */
 export interface CaseSection {
   heading: string
@@ -223,9 +215,11 @@ export interface AttributionCase {
   /** 误导段：最贵的那条知识。没有它，下次还会有人在同一个假设上烧掉四十分钟。 */
   misleading?: { nodeId: string; label: string; wastedMinutes: number; why: string }
   rootCause: string
+  /** 排查记录里的根因确认状态；旧案例卡片缺省时按已有内容展示。 */
+  rootCauseStatus?: 'confirmed' | 'unconfirmed'
 }
 
-/** 从通用 `event` Wiki 卡读取的一次具体发生，供智能归因的事件视图展示。 */
+/** 从独立 Event 实体读取的一次具体发生，供智能归因的事件视图展示。 */
 export interface AttributionEvent {
   id: string
   title: string
@@ -323,8 +317,8 @@ export interface DiagnosisRunCause {
 /**
  * 一次排查的完整记录。落到 SourceRaw 正文里的 ```json diagnosis-run 块。
  *
- * 它与案例卡片的区别是**谁写的、有没有被归纳过**：这里是 Agent 跑完一圈留下的
- * 原始记录，案例卡片是**之后**归纳出来的知识（而且必须经人确认才生效）。
+ * 它是 Agent 跑完一圈留下的原始记录。Case 视图从这条记录派生；可复用 Knowledge 与 Event
+ * 由独立抽取和归一阶段生成，不在这条记录写成第二张卡片。
  */
 export interface DiagnosisRunRecord {
   /** 本次排查的 runId。同时用作 SourceRaw 的 `externalId`，重跑不产生第二条记录。 */

package/src/environment/service.ts

@@ -1,28 +1,58 @@
 import { createHash, randomUUID } from 'node:crypto'
-import { readdirSync, statSync } from 'node:fs'
+import { readFileSync, readdirSync, statSync } from 'node:fs'
 import { mkdir, writeFile } from 'node:fs/promises'
-import { dirname, isAbsolute, join } from 'node:path'
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path'
 import { embeddingFingerprint } from '../compiler/embedding-identity.js'
 import type { RuntimeKnowledgeConfig } from '../types.js'
 import { installRequiredEnvironment, requirementsFile } from './install.js'
-import { modelOptionsView, parseModelSelection, type ModelSelection } from './model-catalog.js'
+import { EMBEDDING_MODELS, modelOptionsView, parseModelSelection, RERANK_MODELS, type ModelSelection } from './model-catalog.js'
 import { ENVIRONMENT_PROBE_VERSION } from './manifest.js'
 import { runProcess } from './process.js'
 import { readModelSelection, writeModelSelection } from './selection.js'
-import type { EnvironmentItem, EnvironmentItemId, EnvironmentReport, EnvironmentView } from './types.js'
+import type { EnvironmentCurrentModel, EnvironmentItem, EnvironmentItemId, EnvironmentReport, EnvironmentView } from './types.js'
 
 export interface EnvironmentOptions {
   resourceRoot: string
   snapshot: () => { config: RuntimeKnowledgeConfig; paths: { python: string; embeddingModel: string; rerankModel: string } }
   probe: (kind: 'embedding' | 'rerank') => Promise<{ ok: boolean; message: string }>
   reload: () => void
+  activateSelection?: () => Promise<() => Promise<void>>
   run?: typeof runProcess
   install?: typeof installRequiredEnvironment
 }
 
 const labels = { embedding: '向量模型', rerank: '重排模型' }
+const CHECK_FILE = 'environment-last-check.json'
+type ModelCatalogEntry = { id: string; label: string; directory: string; repo: string }
+function currentModel(root: string, path: string, catalog: readonly ModelCatalogEntry[], disabled: boolean, provider?: string): EnvironmentCurrentModel {
+  if (disabled) return { state: 'disabled', label: '未启用' }
+  if (provider) return { state: 'active', label: `${provider} · ${basename(path) || path || '未指定模型'}` }
+  const option = catalog.find(model => isAbsolute(path)
+    ? resolve(path) === resolve(join(root, 'models', model.directory))
+    : path === model.repo)
+  if (option) return { state: 'active', id: option.id, label: option.label }
+  const name = isAbsolute(path) ? basename(path) : basename(path.replaceAll('\\', '/'))
+  return { state: 'active', label: `自定义模型 · ${name || '未指定模型'}` }
+}
 function blankReport(): EnvironmentReport {
-  return { state: 'unchecked', required: true, items: (['embedding', 'rerank'] as const).map(id => ({ id, label: labels[id], state: 'unchecked', message: '首次使用前必须完成模型推理自检' })) }
+  return { state: 'unchecked', required: true, items: (['embedding', 'rerank'] as const).map(id => ({ id, label: labels[id], state: 'unchecked', message: '尚未完成模型推理自检' })) }
+}
+function readCachedReport(resourceRoot: string, fingerprint: string): EnvironmentReport | undefined {
+  try {
+    const cached = JSON.parse(readFileSync(join(resourceRoot, CHECK_FILE), 'utf8')) as Record<string, unknown>
+    if (cached.required !== true || cached.fingerprint !== fingerprint || typeof cached.checkedAt !== 'string'
+      || !Number.isFinite(Date.parse(cached.checkedAt)) || !Array.isArray(cached.items)) return undefined
+    const items: EnvironmentReport['items'] = []
+    for (const id of ['embedding', 'rerank'] as const) {
+      const item = cached.items.find((value): value is Record<string, unknown> => Boolean(value && typeof value === 'object' && (value as Record<string, unknown>).id === id))
+      if (!item || item.label !== labels[id] || typeof item.message !== 'string'
+        || !['unchecked', 'ready', 'missing', 'failed'].includes(String(item.state))) return undefined
+      items.push({ id, label: labels[id], state: item.state as EnvironmentReport['items'][number]['state'], message: item.message,
+        ...(typeof item.path === 'string' ? { path: item.path } : {}) })
+    }
+    return { state: items.every(item => item.state === 'ready') ? 'ready' : 'blocked', required: true,
+      checkedAt: cached.checkedAt, fingerprint, items }
+  } catch { return undefined }
 }
 function stamp(path: string): unknown { try { const value = statSync(path); return [value.size, value.mtimeMs] } catch { return null } }
 function sitePackagesPath(pythonPath: string): string {
@@ -52,14 +82,16 @@ export function modelFilesProblem(path: string): string | undefined {
 
 /** Preparation and readiness are shared by all bases in one deployment. */
 export class KnowledgeEnvironment {
-  private report = blankReport()
+  private report: EnvironmentReport
   private job?: EnvironmentView['job']
   private checkPending?: Promise<EnvironmentReport>
   private work?: Promise<void>
   private controller?: AbortController
   private checkController?: AbortController
   private disposed = false
-  constructor(private readonly options: EnvironmentOptions) {}
+  constructor(private readonly options: EnvironmentOptions) {
+    this.report = readCachedReport(options.resourceRoot, this.fingerprint()) ?? blankReport()
+  }
 
   private fingerprint(): string {
     const { config, paths } = this.options.snapshot()
@@ -73,24 +105,34 @@ export class KnowledgeEnvironment {
   }
 
   view(): EnvironmentView {
-    if (!this.checkPending && this.report.state === 'ready' && this.report.fingerprint !== this.fingerprint()) this.report = blankReport()
+    if (!this.checkPending && this.report.fingerprint && this.report.fingerprint !== this.fingerprint()) {
+      if (this.report.state === 'ready') this.report.state = 'unchecked'
+      this.report.items = this.report.items.map(item => item.state === 'ready' ? { ...item, state: 'unchecked', message: '自检后配置或资源发生变化，请重新自检' } : item)
+    }
+    const { config, paths } = this.options.snapshot()
     const selection = readModelSelection(this.options.resourceRoot)
-    return structuredClone({ report: this.report, selection, models: modelOptionsView(), ...(this.job ? { job: this.job } : {}) })
+    const current = {
+      embedding: currentModel(this.options.resourceRoot, paths.embeddingModel, EMBEDDING_MODELS, config.embeddingProvider === 'none', config.embeddingProvider === 'ollama' ? 'Ollama' : undefined),
+      rerank: currentModel(this.options.resourceRoot, paths.rerankModel, RERANK_MODELS, config.rerankProvider === 'none'),
+    }
+    return structuredClone({ report: this.report, selection, current, models: modelOptionsView(), ...(this.job ? { job: this.job } : {}) })
   }
   invalidate(): void { if (!this.checkPending) this.report = blankReport() }
 
-  async requireReady(): Promise<void> {
+  async requireReady(kind?: EnvironmentItemId): Promise<void> {
     if (this.disposed) throw new Error('环境服务已关闭')
     if (this.job?.state === 'running') throw new Error('环境正在准备或自检，请等待完成后再编译和召回')
     const view = this.view()
-    const recent = view.report.checkedAt && Date.now() - Date.parse(view.report.checkedAt) < 5 * 60_000
-    const report = view.report.state === 'ready' && recent ? view.report : await this.check(true)
-    if (report.state !== 'ready') throw new Error(`环境未就绪：${report.items.filter(item => item.state !== 'ready').map(item => `${item.label}：${item.message}`).join('；')}。请在 Tita 设置中完成环境准备`)
+    // A passing result stays valid while the model, provider, runtime, and device fingerprint stays the same.
+    // The operation itself still reports inference failures, and the user can always request a fresh probe.
+    const alreadyReady = kind ? view.report.items.find(item => item.id === kind)?.state === 'ready' : view.report.state === 'ready'
+    const report = alreadyReady ? view.report : await this.check(true, kind)
+    if (kind ? report.items.find(item => item.id === kind)?.state !== 'ready' : report.state !== 'ready') throw new Error(`环境未就绪：${report.items.filter(item => (!kind || item.id === kind) && item.state !== 'ready').map(item => `${item.label}：${item.message}`).join('；')}。请在 Tita 设置中完成环境准备`)
   }
 
-  check(deep = true): Promise<EnvironmentReport> {
-    if (this.checkPending) return this.checkPending
-    const pending = this.performCheck(deep)
+  check(deep = true, kind?: EnvironmentItemId): Promise<EnvironmentReport> {
+    if (this.checkPending) return this.checkPending.then(report => !kind || report.items.find(item => item.id === kind)?.state === 'ready' ? report : this.check(deep, kind))
+    const pending = this.performCheck(deep, kind)
     this.checkPending = pending
     void pending.finally(() => { if (this.checkPending === pending) this.checkPending = undefined }).catch(() => undefined)
     return pending
@@ -100,23 +142,28 @@ export class KnowledgeEnvironment {
     this.report.items = this.report.items.map(item => item.id === id ? { ...item, ...patch } : item)
   }
 
-  private async performCheck(deep: boolean): Promise<EnvironmentReport> {
+  private async performCheck(deep: boolean, kind?: EnvironmentItemId): Promise<EnvironmentReport> {
     const checkController = new AbortController()
     this.checkController = checkController
     const signal = this.controller ? AbortSignal.any([this.controller.signal, checkController.signal]) : checkController.signal
     const fingerprint = this.fingerprint()
     const { config, paths } = this.options.snapshot()
-    this.report = blankReport()
+    if (this.report.fingerprint !== fingerprint) this.report = blankReport()
     this.report.state = 'checking'
-    for (const id of ['embedding', 'rerank'] as const) {
+    for (const id of kind ? [kind] : ['embedding', 'rerank'] as const) {
       if (signal.aborted || this.disposed) break
       const path = id === 'embedding' ? paths.embeddingModel : paths.rerankModel
+      const cached = this.report.fingerprint === fingerprint ? this.report.items.find(item => item.id === id) : undefined
       this.item(id, { path })
       const disabled = id === 'embedding' ? config.embeddingProvider === 'none' : config.rerankProvider === 'none'
       const problem = disabled ? '此能力是必需项，请启用模型'
         : id === 'embedding' && config.embeddingProvider === 'ollama' ? undefined : modelFilesProblem(path)
       if (problem) { this.item(id, { state: 'missing', message: problem }); continue }
-      if (!deep) { this.item(id, { state: 'unchecked', message: '资源已找到，尚未完成实际推理自检' }); continue }
+      if (!deep) {
+        if (cached && cached.state !== 'unchecked' && cached.state !== 'checking') this.item(id, { state: cached.state, message: cached.message })
+        else this.item(id, { state: 'unchecked', message: '资源已找到，尚未完成实际推理自检' })
+        continue
+      }
       this.item(id, { state: 'checking', message: '加载模型并运行推理自检，首次加载可能较慢' })
       try {
         const result = await this.options.probe(id)
@@ -131,9 +178,15 @@ export class KnowledgeEnvironment {
       ? { ...item, state: 'unchecked', message: '自检已停止，请重新运行' }
       : item)
     this.report.state = this.report.items.every(item => item.state === 'ready') ? 'ready' : 'blocked'
-    this.report.checkedAt = new Date().toISOString()
+    if (deep) this.report.checkedAt = new Date().toISOString()
     this.report.fingerprint = fingerprint
     if (this.checkController === checkController) this.checkController = undefined
+    if (deep && !signal.aborted && !this.disposed) {
+      try {
+        await mkdir(this.options.resourceRoot, { recursive: true })
+        await writeFile(join(this.options.resourceRoot, CHECK_FILE), JSON.stringify(this.report, null, 2))
+      } catch { /* The current process can use the result; a later restart may need to probe again. */ }
+    }
     return structuredClone(this.report)
   }
 
@@ -151,6 +204,7 @@ export class KnowledgeEnvironment {
     const job = this.job
     const log = (line: string): void => { job.logs = [...job.logs, line.slice(-1500)].slice(-12) }
     const work = async (): Promise<void> => {
+      let rollbackSettings: (() => Promise<void>) | undefined
       try {
         // A first-use guard can already be checking. Do not install into that probe.
         if (this.checkPending) await this.checkPending
@@ -164,16 +218,18 @@ export class KnowledgeEnvironment {
             const id = label.includes('向量') ? 'embedding' : label.includes('重排') ? 'rerank' : undefined
             if (id) this.item(id, { state: 'checking', message: label })
           }, log, this.options.run ?? runProcess, selection)
+          rollbackSettings = await this.options.activateSelection?.()
           this.options.reload()
         } else this.options.reload()
         job.stage = '运行实际推理自检'
         const report = await this.check(true)
         if (controller.signal.aborted) throw new Error('ENVIRONMENT_CANCELLED')
         if (report.state !== 'ready') throw new Error(report.items.filter(item => item.state !== 'ready').map(item => `${item.label}：${item.message}`).join('；'))
-        await mkdir(this.options.resourceRoot, { recursive: true })
-        await writeFile(join(this.options.resourceRoot, 'environment-last-check.json'), JSON.stringify(report, null, 2))
         job.state = 'succeeded'; job.stage = '环境已就绪'
       } catch (cause) {
+        if (rollbackSettings) {
+          try { await rollbackSettings() } catch (rollbackCause) { log(`恢复模型设置失败：${rollbackCause instanceof Error ? rollbackCause.message : String(rollbackCause)}`) }
+        }
         if (action === 'install') {
           const activeSelection = readModelSelection(this.options.resourceRoot)
           if (activeSelection.embedding !== previousSelection.embedding || activeSelection.rerank !== previousSelection.rerank) {

package/src/environment/types.ts

@@ -17,6 +17,11 @@ export interface EnvironmentReport {
   fingerprint?: string
   items: EnvironmentItem[]
 }
+export interface EnvironmentCurrentModel {
+  id?: string
+  label: string
+  state: 'active' | 'disabled'
+}
 export interface EnvironmentJob {
   id: string
   state: 'running' | 'succeeded' | 'failed' | 'cancelled'
@@ -30,5 +35,6 @@ export interface EnvironmentView {
   report: EnvironmentReport
   job?: EnvironmentJob
   selection: ModelSelection
+  current: { embedding: EnvironmentCurrentModel; rerank: EnvironmentCurrentModel }
   models: { embedding: ModelOptionView[]; rerank: ModelOptionView[] }
 }

package/src/events.ts

@@ -46,6 +46,18 @@ export interface EventEntity {
   updatedAt: string
 }
 
+/** Remove the legacy generated Event list from a WikiCard body. References live in card_event. */
+export function stripEventReferenceSection(content: string): string {
+  const lines = content.split('\n')
+  for (let start = lines.length - 1; start >= 0; start -= 1) {
+    if (!/^##\s+关联\s*Events?\s*$|^##\s+关联事件\s*$/.test((lines[start] ?? '').trim())) continue
+    let end = start + 1
+    while (end < lines.length && !/^#{1,2}\s+/.test(lines[end] ?? '')) end += 1
+    lines.splice(start, end - start)
+  }
+  return lines.join('\n').trim()
+}
+
 export function compositeEventIdentity(occurredAt: string | null, coordinate: CardCoordinate, symptom: string | null): string {
   const payload = [occurredAt, coordinate.objectId, coordinate.actionId, coordinate.sceneId, normalizeKnowledge(symptom ?? '')]
   return 'composite:' + createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 24)

package/src/extract-contract.ts

@@ -13,6 +13,7 @@
  */
 
 import { AXIS_CONTRACT_LINES } from './axis-contract.js'
+import { TABLE_OUTPUT_CONTRACT } from './extract-table-contract.js'
 
 /**
  * 把骨架允许的小节拼成提示词里那一条。
@@ -37,14 +38,15 @@ function sectionRule(sections: string[] | undefined): string[] {
  * 编译链路用 `buildTrialSystem(profileSections)`；试跑面板用默认实例（不下发小节清单），
  * 因为那一层没有「本库骨架」这个概念。
  */
-export function buildTrialSystem(sections?: string[]): string {
-  return trialSystemBody(sectionRule(sections))
+export function buildTrialSystem(sections?: string[], format: 'table' | 'json' = 'table'): string {
+  return trialSystemBody(sectionRule(sections), format)
 }
 
-const trialSystemBody = (positionRule: string[]): string => [
+const trialSystemBody = (positionRule: string[], format: 'table' | 'json'): string => [
   '你在把一份业务文档拆成知识库要用的内容。知识以 Knowledge 为单位：',
   '一条可独立检索、验证或执行的最小知识单元。',
   '',
+  ...(format === 'table' ? TABLE_OUTPUT_CONTRACT : [
   '只回一个 JSON 对象，不要散文，不要代码围栏。',
   '',
   '输出形状：',
@@ -73,6 +75,7 @@ const trialSystemBody = (positionRule: string[]): string => [
   '  "dropped": [ { "quote": "原文片段", "why": "为什么丢掉" } ]',
   '}',
   '',
+  ]),
   '# 知识：一条只讲一个单元',
   '- text 是一条能脱离上下文独立阅读的最小知识单元。事实要能判断真假，操作步骤要能被执行。',
   '- 一段原文里有几个独立单元就写几条。不要压成一条，也不要拆碎。',

package/src/extract-model.ts

@@ -65,6 +65,8 @@ export type ModelCall = (request: {
   sessionId?: string
   /** 可选观察本次请求的 provider 用量；普通调用方可以忽略。 */
   onUsage?: (usage: TrialTokenUsage) => void
+  /** Public response text only; reasoning chunks are not exposed. */
+  onDelta?: (text: string) => void
 }) => Promise<string>
 
 /** 归并条目：与规则抽取的 `NormalizedCandidates['merges']` 保持同一形状。 */

package/src/extract-table-contract.ts

@@ -0,0 +1,29 @@
+/** Kept free of server dependencies so the architecture page shows the real contract. */
+export const TABLE_OUTPUT_CONTRACT = [
+  '只返回 TOON 固定列表格，不要 Markdown 围栏或说明。format 必须是 knowledge-table-v1。',
+  '每个数组头的 [N] 是本次实际行数；每行必须与 {列名} 的列数和顺序一致。空表写 名称[0]:。',
+  '逗号分列。字符串包含逗号、冒号、换行或首尾空格时用双引号包裹；内部双引号写 \\"，换行写 \\n，反斜杠写 \\\\。',
+  '缺失值写 null。字符串列表 heading_path 和 missing 写为 JSON 数组字符串。',
+  'evidence 表每个引文只写一次。其它表的 evidence 列写出处 ID，多个 ID 用空格分隔。所有 ID 必须存在。',
+  '以下是列定义和示例；示例内容必须换成当前文档的数据：',
+  'format: knowledge-table-v1',
+  'subject: 业务主体',
+  'knowledge[1]{id,text,object,action,scene,section,order,evidence}:',
+  '  k1,一条最小知识单元,对象名,动作名,场景名,字段,1,q1',
+  'events[1]{id,external_id,title,summary,object,action,scene,occurred_at,symptom,root_cause,root_cause_status,outcome,missing,evidence}:',
+  '  e1,null,一次具体发生,原文明确的概述,对象名,动作名,场景名,null,null,null,null,null,"[]",q1',
+  'timeline[1]{event_id,order,type,description,result,at,evidence}:',
+  '  e1,1,observation,原文记录的现象,null,null,q1',
+  'objects[1]{mention,definition,evidence,existing,parent}:',
+  '  对象名,对象的边界和含义,q1,null,null',
+  'actions[1]{mention,definition,evidence,existing,parent}:',
+  '  动作名,动作的含义,q1,null,null',
+  'scenes[1]{mention,definition,evidence,existing,parent}:',
+  '  场景名,场景的含义,q1,null,null',
+  'evidence[1]{id,quote,heading_path}:',
+  '  q1,原文逐字引文,"[]"',
+  'dropped[0]:',
+  'timeline.type 只能是 observation/check/action/result/conclusion；root_cause_status 只能是 confirmed/suspected/null。',
+  'dropped 非空时列为 {quote,why}。对象 parent 只填原文有证据的父对象；existing 填已有实体名。',
+  '',
+]