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

package/src/client/styles.css

@@ -577,6 +577,14 @@ body {
    显示三条完整路径。400px 下两列会挤成一列，路径会被截成读不出。 */
 .tita-settingsDrawer { width: min(560px, 100vw); }
 .tita-settingsError { border: 1px solid var(--ddk-danger-line); border-radius: 9px; background: var(--ddk-danger-tint); color: var(--tita-danger); padding: 9px 11px; font-size: 12px; }
+/* 一个数字字段的草稿不合法：**不是错误框，是一句旁注**。它说的是「这一笔现在还写不了」，
+  而人正停在输入框里改它 —— 套一层带边框的红块会把一个中间打字状态说成一次故障。 */
+.tita-settingInvalid { color: var(--tita-danger); font-size: 11px; line-height: 1.5; }
+/* 「读不到，重试」那一行。它长在**字段自己身上**（就在路径输入框下面），因为失败的是
+   这一次读取，而不是整个设置分区 —— 报在分区头上会让人以为所有设置都读不到。 */
+.tita-settingsRetry { display: flex; align-items: center; gap: 6px; margin: 6px 0 0; color: var(--tita-danger); font-size: 11.5px; line-height: 1.5; }
+.tita-settingsRetry > svg { flex: 0 0 auto; }
+.tita-settingsRetry > span { min-width: 0; flex: 1 1 auto; }
 /*
  * 分组**不是一个卡片**。
  *
@@ -635,10 +643,13 @@ body {
  * 见 `InfoHint`），所以这里只需要管「一行多长」这一件事。
  */
 .tita-infoHintPanel.tita-infoHintPanel { display: block; max-width: 320px; padding: 8px 12px; line-height: 1.65; text-align: left; white-space: normal; }
-/* 小节标题旁的说明入口：图标常驻、说明悬停才出现（见 `InfoHint`）。 */
-.tita-infoHint { display: inline-flex; width: 16px; height: 16px; align-items: center; justify-content: center; padding: 0; border: 0; border-radius: 50%; background: transparent; color: var(--tita-subtle); cursor: help; }
+/* 小节标题旁的说明入口：图标常驻、说明悬停才出现（见 `InfoHint`）。
+   三个颜色原来指着 `--tita-subtle` / `--tita-blue` / `--tita-accent*` —— 这四个名字
+   在 `packages/ui` 与本插件里**都没有定义**。未定义的 `var()` 让整条声明在计算值阶段
+   失效：入口的常驻色回退成继承色、焦点圈回退成 `currentColor`。现在指向真实 token。 */
+.tita-infoHint { display: inline-flex; width: 16px; height: 16px; align-items: center; justify-content: center; padding: 0; border: 0; border-radius: 50%; background: transparent; color: var(--tita-ink-faint); cursor: help; }
 .tita-infoHint:hover { background: var(--tita-surface-muted); color: var(--tita-ink-muted); }
-.tita-infoHint:focus-visible { outline: 2px solid var(--tita-blue); outline-offset: 1px; }
+.tita-infoHint:focus-visible { outline: 2px solid var(--tita-focus-ring); outline-offset: 1px; }
 /* 可点击的那一枚（传了 `href`）：它从「说明」变成「入口」，所以光标从 help 换成 pointer ——
    同一个图标有两种含义时，光标是零成本的那条线索。 */
 .tita-infoHintAction { cursor: pointer; }
@@ -838,7 +849,10 @@ body {
 /* 琥珀：**是账，不是故障** —— 真源与来源对不上，而它是可以清掉的（判据确定、可重建）。 */
 .tita-kbNoticeWarn { border-color: var(--tita-tone-amber-line); background: var(--tita-tone-amber-tint); color: var(--tita-tone-amber); }
 .tita-kbNoticeWarn > span b { color: var(--tita-tone-amber); }
-.tita-kbNoticeClose { display: inline-flex; flex: 0 0 auto; align-items: center; justify-content: center; border: 0; border-radius: 6px; background: transparent; color: inherit; padding: 3px; cursor: pointer; opacity: .7; }
+/* 提示条右端的关闭动作。面板里的关闭按钮现在是共享的 `Button variant="ghost" size="icon"`，
+   所以这里只剩**这一条提示自己的**语气：比正文淡一点，悬停才回到满值。
+   `border`/`background`/`padding` 的复位撤掉 —— 那是按钮自己带的了。 */
+.tita-kbNoticeClose { flex: 0 0 auto; color: inherit; opacity: .7; }
 .tita-kbNoticeClose:hover { opacity: 1; }
 
 .tita-kbRoot { overflow: hidden; max-width: 100%; color: var(--tita-ink-faint); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 10px; text-overflow: ellipsis; white-space: nowrap; }
@@ -1497,6 +1511,40 @@ button.tita-trialMatrixGroup:focus-visible { outline: 2px solid var(--tita-focus
 .tita-trialCheckHit .tita-trialCheckHits { background: var(--tita-tone-amber-tint); color: var(--tita-tone-amber); }
 .tita-trialCheckWhat { color: var(--tita-ink); font-size: 10.5px; line-height: 1.6; }
 .tita-trialCheckNote { grid-column: 3; color: var(--tita-ink-muted); font-size: 10px; line-height: 1.6; }
+/* 区块导航（2026-10-18）。报告可以长到几百 KB，打开它的人第一件事是「跳到要看的那一段」。
+   **不吸顶**：上面那条常驻标题条是 `sticky; z-index: 2`，而它的高度随标题换行变化
+   （窄屏上 meta 会折成两行）。导航条吸在 `top: 0` 会正好钻到它下面 —— 看起来是「一滚就没了」。
+   让开它需要一个写不死的高度，而写死的高度在窄屏上会错位。所以它就在正文顶部，
+   加上每个区块的 `scroll-margin`，点一下照样落到该看的位置。 */
+.tita-trialNav {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 2px 14px;
+  border-bottom: 1px solid var(--tita-line);
+  padding: 0 0 7px;
+}
+.tita-trialNav a {
+  color: var(--tita-ink-muted);
+  font-size: 11.5px;
+  font-weight: 650;
+  text-decoration: none;
+}
+.tita-trialNav a:hover { color: var(--tita-primary); text-decoration: underline; text-underline-offset: 3px; }
+.tita-trialNav a:focus-visible { outline: 2px solid var(--tita-focus-ring); outline-offset: 2px; border-radius: 4px; }
+/* 一段说明（不是警告）。警告用 amber，这条是「报告的范围边界」，用中性底色。 */
+.tita-trialNote {
+  margin: 0 0 10px;
+  border-radius: 8px;
+  background: var(--tita-surface-muted);
+  padding: 8px 10px;
+  color: var(--tita-ink-muted);
+  font-size: 11px;
+  line-height: 1.6;
+}
+.tita-trialNote b { color: var(--tita-ink); }
+/* 锚点落点留一口气：`scroll-margin` 让标题不贴住吸顶的导航条。 */
+.tita-trialSection, .tita-trialOverview { scroll-margin-block-start: 44px; }
+
 .tita-trialReport { display: grid; gap: 22px; }
 .tita-trialOverview { display: grid; gap: 9px; border-bottom: 1px solid var(--tita-line-strong); padding-bottom: 13px; }
 .tita-trialSection { display: grid; min-width: 0; gap: 10px; border-top: 1px solid var(--tita-line); padding-top: 14px; }
@@ -1514,6 +1562,7 @@ button.tita-trialMatrixGroup:focus-visible { outline: 2px solid var(--tita-focus
 .tita-trialOverviewTitle { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 10px; margin: 0; }
 .tita-trialOverviewTitle strong { color: var(--tita-ink); font-size: 11.5px; font-weight: 700; overflow-wrap: anywhere; }
 .tita-trialOverviewTitle span { color: var(--tita-ink-muted); font-size: 10px; font-variant-numeric: tabular-nums; }
+.tita-trialOverviewEmpty { margin: 2px 0 0; color: var(--tita-ink-muted); font-size: 11.5px; line-height: 1.6; }
 .tita-trialOverviewSubject { margin: 0; color: var(--tita-ink-muted); font-size: 11px; line-height: 1.6; }
 .tita-trialOutputTabs { display: grid; min-width: 0; gap: 10px; }
 .tita-trialOutputTabs > [data-slot='tabs-list'] { max-width: 100%; overflow-x: auto; }
@@ -1616,6 +1665,10 @@ button.tita-trialMatrixGroup:focus-visible { outline: 2px solid var(--tita-focus
 .tita-trialRunFlags { display: flex; flex: 1 1 auto; flex-wrap: wrap; align-items: center; gap: 4px; }
 .tita-trialRunFlag { border-radius: 999px; background: var(--tita-surface-muted); color: var(--tita-ink); padding: 1px 6px; font-size: 9.5px; font-weight: 700; }
 .tita-trialRunFlag[data-ok="false"] { background: var(--tita-tone-amber-tint); color: var(--tita-tone-amber); }
+/* 阶段徽标（2026-10-18）。同一条列表里现在混着抽取与归一，两个都是「这一份文档的一次运行」，
+   所以它们必须是同一枚小徽标、只换颜色 —— 换成两种形状会读成两类东西。 */
+.tita-trialRunFlag[data-stage="normalize"] { background: var(--tita-primary-soft); color: var(--tita-primary); }
+.tita-trialRunFlag[data-stage="materialize"] { background: var(--tita-tone-violet-tint); color: var(--tita-tone-violet); }
 /* 行尾的外链图标：推到这一行最右，它是「点这里去浏览器」的记号。 */
 .tita-trialRunOpen { display: inline-flex; margin-left: auto; color: var(--tita-ink-faint); }
 .tita-trialRunRow:hover .tita-trialRunOpen { color: var(--tita-ink); }
@@ -1746,8 +1799,10 @@ button.tita-trialMatrixGroup:focus-visible { outline: 2px solid var(--tita-focus
  * 与 `.tita-knowledgeConfirm` 同一条理由。做成无边框小字而不是按钮：这一行里三百来个
  * 像素都归正文，动作是**注脚**，不该摆一个跟正文抢眼的东西。
  */
-.tita-knowledgeOpen { justify-self: end; margin-top: 2px; border: 0; background: none; padding: 0; color: var(--tita-accent); font: inherit; font-size: 10px; cursor: pointer; text-decoration: underline; text-underline-offset: 2px; }
-.tita-knowledgeOpen:hover { color: var(--tita-accent-strong, var(--tita-accent)); }
+.tita-knowledgeOpen { justify-self: end; margin-top: 2px; border: 0; background: none; padding: 0; color: var(--tita-primary); font: inherit; font-size: 10px; cursor: pointer; text-decoration: underline; text-underline-offset: 2px; }
+/* 悬停原来指着一对**没有定义**的变量，而 `var()` 失效时整条 `color` 声明作废 ——
+   这就是「悬停完全没有反馈」的原因。现在两档都是真 token：主色 → 它的深色档。 */
+.tita-knowledgeOpen:hover { color: var(--tita-primary-hover); }
 .tita-knowledgeSources { display: grid; margin: 2px 0 0; padding: 0; list-style: none; gap: 4px; }
 .tita-knowledgeNote { margin-top: 8px; border-top: 1px dashed var(--tita-line); padding-top: 8px; }
 /*

package/src/client/wiki-trial.ts

@@ -1,3 +1,4 @@
+import type { MaterializeTrajectoryReport, NormalizeTrajectoryReport, TrajectoryStage } from '../trajectory-types.js'
 import { requestJson } from './request.ts'
 
 /**
@@ -43,6 +44,11 @@ import type { TrialReport } from '../wiki-trial-types.ts'
  */
 export type TrialReportView = TrialReport & {
   summary?: string
+  /**
+   * `'extract-only'` = 这条记录是**流水线的抽取阶段**落的，报告里 ②③④ 段是试跑顺带算的
+   * 机械预览，不是这个库里真的做过的事。没有这个键 = 旧的全链路编译，四段都真跑过。
+   */
+  scope?: 'extract-only'
   /** 这一次的轨迹落库结果。`saved: false` 时 `why` 要显示出来 —— 不能假装存下来了。 */
   run?: { saved: boolean; id?: string; why?: string }
   /**
@@ -72,11 +78,31 @@ export interface ExtractionRunSummary {
   modelWhy?: string
   summary: string
   hasReport: boolean
+  /** 这条轨迹属于哪一段（2026-10-18 起三段共用一张表）。 */
+  stage: TrajectoryStage
 }
 
+/**
+ * 三份轨迹的报告本体，按 `stage` 分派。
+ *
+ * 它们**不共用一个形状**：抽取是整份 `TrialReport`（七步、矩阵、四条核验），
+ * 归一是一张「名字 → 坐标」的账，物化是「这一组 → 这一张卡」的账。
+ * 硬塞进一个形状只会让三份都变得半空。
+ */
+export type TrajectoryReportView = TrialReportView | NormalizeTrajectoryReport | MaterializeTrajectoryReport
+
+/**
+ * 这条记录属于哪一段。
+ *
+ * 「缺字段 = 抽取」是**与库同一条规则**（补 `stage` 列时默认值就是 `extract`）：
+ * 升级后服务端还没起来的那一小段窗口里，接口给的是旧形状；这时把它读成「没有轨迹」
+ * 会让列表整片空白，而它其实就在那儿。一处收口，别处不用各写一遍 `?? 'extract'`。
+ */
+export const trajectoryStageOf = (run: { stage?: TrajectoryStage }): TrajectoryStage => run.stage ?? 'extract'
+
 /** 一条完整轨迹：列表投影 + 报告本体。 */
 export interface ExtractionRunRecord extends ExtractionRunSummary {
-  report: TrialReportView
+  report: TrajectoryReportView
 }
 
 export interface ExtractionRunPage {
@@ -123,10 +149,13 @@ export async function requestTrial(input: {
 export async function requestExtractionRuns(input: {
   kb: string
   docId?: string
+  /** 只看某一段。省略 = 三段一起。 */
+  stage?: TrajectoryStage
   limit?: number
 }): Promise<ExtractionRunPage> {
   const params = new URLSearchParams({ kb: input.kb })
   if (input.docId) params.set('doc_id', input.docId)
+  if (input.stage) params.set('stage', input.stage)
   if (input.limit) params.set('limit', String(input.limit))
   const envelope = await requestJson<ExtractionRunPage>(`/knowledge/extraction-runs?${params.toString()}`)
   return envelope.data ?? { runs: [], total: 0, available: false }

package/src/convert/host.ts

@@ -506,6 +506,7 @@ export function applyConvert(ctx: Context, deps: ConvertHostDeps): ConvertHost {
       convert_task_id: { type: 'string', required: true },
       kb: { type: 'string', description: '目标知识库 id；省略则写入默认知识库' },
       title: { type: 'string' },
+      source_id: { type: 'string', description: '写进这一条已有的 SourceRaw（同一实体的新版本）。省略则按 external_id / 内容算一个新来源 —— 给一份「已经录进库的文档重新转换」时应当传它，否则会多出一条来源。' },
       plan_only: { type: 'boolean' },
       session_key: { type: 'string' },
       task_id: { type: 'string' },
@@ -531,6 +532,7 @@ export function applyConvert(ctx: Context, deps: ConvertHostDeps): ConvertHost {
         runtime: target.runtime,
         knowledgeRoot: target.knowledgeRoot,
         ...(typeof args.title === 'string' && args.title.trim() ? { title: args.title.trim() } : {}),
+        ...(typeof args.source_id === 'string' && args.source_id.trim() ? { sourceId: args.source_id.trim() } : {}),
         planOnly: args.plan_only === true,
         ...(lineageOf(args, exec) ? { lineage: lineageOf(args, exec)! } : {}),
       })
@@ -585,6 +587,7 @@ export function applyConvert(ctx: Context, deps: ConvertHostDeps): ConvertHost {
             runtime: target.runtime,
             knowledgeRoot: target.knowledgeRoot,
             ...(typeof body.title === 'string' && body.title.trim() ? { title: body.title.trim() } : {}),
+            ...(typeof body.source_id === 'string' && body.source_id.trim() ? { sourceId: body.source_id.trim() } : {}),
             planOnly: body.plan_only === true,
             ...(body.lineage && typeof body.lineage === 'object' ? { lineage: body.lineage as Record<string, string> } : {}),
           })

package/src/convert/ingest.ts

@@ -19,7 +19,9 @@
  */
 
 import { ASSETS_DIR, SOURCE_RAW_DIR } from '../layout.js'
-import { cp, mkdir, rm, stat } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { constants } from 'node:fs'
+import { copyFile, mkdir, readFile, rm, stat } from 'node:fs/promises'
 import { basename, dirname, join, resolve, sep } from 'node:path'
 import type { ConvertService, IngestPayload } from 'dsh-convert-core'
 import type { LineageContext } from 'dsh-data-contracts/refs'
@@ -66,6 +68,15 @@ export interface IngestOptions {
   /** Absolute knowledge root the runtime currently writes to. */
   knowledgeRoot: string
   title?: string
+  /**
+   * 写进**哪一条** SourceRaw（0070）。
+   *
+   * 省略时 `addSource` 按 `external_id ?? content` 算一个新 id —— 于是「把一份已经录进库
+   * 的文档重新转换一次（比如这次补上了它的图）」会**多出一条来源**，而旧那条仍挂着断引用、
+   * 它的卡片与知识也还指着旧 id。给出 `sourceId` 时走的是同一实体的新版本：
+   * 历史保留、卡片与知识的出处不变、正文与图片引用一起更新。
+   */
+  sourceId?: string
   metadata?: Record<string, unknown>
   lineage?: Record<string, unknown>
   /** Dry run: build the plan without copying assets or writing the source. */
@@ -178,6 +189,40 @@ function assetImageRef(hash: string, rel: string): string {
  * @param created 这一趟**新写进磁盘**的路径。被 `addSource` 拒收时调用方要按它回收 ——
  *   底稿和图片一样，先落盘后写库，不回收就会留下谁也指不到的文件。
  */
+/**
+ * 抢占式复制：返回**这一次是否真的由我创建了目标**。
+ *
+ * 用 `copyFile` + `COPYFILE_EXCL`，不用 `cp({errorOnExist:true})` —— 后者抛的是
+ * `ERR_FS_CP_EEXIST`（实测 Node 24），而这里判的是 `EEXIST`，于是「已存在」会被当成
+ * 复制失败：资产不进 `assetMapping`，正文里的引用就永久断掉。而 `copyFile` 的
+ * `COPYFILE_EXCL` 抛的正是 `EEXIST`。
+ */
+async function copyExclusive(from: string, to: string): Promise<boolean> {
+  try {
+    await copyFile(from, to, constants.COPYFILE_EXCL)
+    return true
+  } catch (cause) {
+    if ((cause as NodeJS.ErrnoException).code === 'EEXIST') return false
+    throw cause
+  }
+}
+
+/**
+ * 目标已经存在时，确认它就是**同一份内容**。
+ *
+ * 桶名是内容哈希的前 12 位，所以正常情况下「已存在」= 同一份文件。但前缀只有 12 位，
+ * 而同名也可能来自别的来源：直接采信会把别人的字节记成自己的（大小与哈希都对不上却
+ * 静默通过）。核对不过就保留已有那一份，并如实说一句。
+ */
+async function contentMatches(path: string, expected: { bytes: number; hash: string; algorithm: 'sha1' | 'sha256' }): Promise<boolean> {
+  try {
+    const info = await stat(path)
+    if (info.size !== expected.bytes) return false
+    const actual = createHash(expected.algorithm).update(await readFile(path)).digest('hex')
+    return actual === expected.hash
+  } catch { return false }
+}
+
 async function placeOriginal(
   knowledgeRoot: string,
   original: { rel: string; path: string; bytes: number; sha256: string },
@@ -190,10 +235,20 @@ async function placeOriginal(
   if (target === undefined) return undefined
   try {
     await mkdir(dirname(target), { recursive: true })
-    const existed = await stat(target).then(() => true, () => false)
-    await cp(original.path, target, { force: true })
+    /**
+     * 「是不是我建的」由文件系统回答，不能靠 `stat` 之后自己判断（0070）。
+     *
+     * 同一份原件并发导入两次时，两次 `stat` 都会说「不存在」，两次都会把自己记成创建者；
+     * 其中一次被 `addSource` 拒收时，`removeCreated` 就会删掉另一次正在引用的底稿。
+     * `COPYFILE_EXCL` 让「创建」变成原子的：只有一个赢家，输的那个知道不是自己建的。
+     */
+    const createdHere = await copyExclusive(original.path, target)
+    if (!createdHere && !await contentMatches(target, { bytes: original.bytes, hash: original.sha256, algorithm: 'sha256' })) {
+      // 同桶同名但不是同一份内容：不覆盖、也不把它记成自己的底稿。
+      return undefined
+    }
     const info = await stat(target)
-    if (!existed) created.push(target)
+    if (createdHere) created.push(target)
     return {
       rel: `${SOURCE_RAW_DIR}/${bucket}/${basename(original.rel)}`,
       target,
@@ -208,8 +263,9 @@ async function placeOriginal(
 /**
  * 把 store 拒绝的那一趟**新落盘的文件**收回去（图片与底稿一起）。
  *
- * 判据是「复制前不存在」：桶名是内容哈希，同一份内容重复导入会落在同一个桶里 ——
- * 删它等于删别人的图、别人的底稿。
+ * 判据是「**这一次真的由我创建**」：桶名是内容哈希，同一份内容重复导入会落在同一个桶里 ——
+ * 删别人的图、别人的底稿是不可逆的。所以 `created` 只收 `COPYFILE_EXCL` 抢到的那些，
+ * 而不是「复制前 `stat` 说没有」的那些（后者在并发下两边都会成立）。
  */
 async function removeCreated(paths: string[]): Promise<void> {
   for (const path of paths) {
@@ -307,11 +363,18 @@ export async function ingestDelivery(options: IngestOptions): Promise<Envelope<I
         continue
       }
       try {
-        const existed = await stat(target).then(() => true, () => false)
-        await cp(asset.path, target, { force: true })
+        /** 同 `placeOriginal`：创建权由 `COPYFILE_EXCL` 决定，不由 `stat` 猜。 */
+        const createdHere = await copyExclusive(asset.path, target)
+        /**
+         * 已存在时核对内容。**不能核对失败就跳过这张图** —— 那会让正文里的引用断掉
+         * （这正是本函数要避免的）。同一份内容照旧登记；不同内容才保留已有那份并说一句。
+         */
+        if (!createdHere && !await contentMatches(target, { bytes: asset.bytes, hash: asset.sha1, algorithm: 'sha1' })) {
+          warnings.push(`资产 ${asset.rel} 已存在且内容与本次不同，保留已有那一份`)
+        }
         const info = await stat(target)
         placed.push({ rel: asset.rel, target, bytes: info.size })
-        if (!existed) created.push(target)
+        if (createdHere) created.push(target)
         assetMapping.set(asset.rel, asset.rel)
       } catch (cause) {
         warnings.push(`资产复制失败（${asset.rel}）：${cause instanceof Error ? cause.message : String(cause)}`)
@@ -391,6 +454,7 @@ export async function ingestDelivery(options: IngestOptions): Promise<Envelope<I
       externalId,
       metadata,
       provenance,
+      ...(options.sourceId?.trim() ? { sourceId: options.sourceId.trim() } : {}),
       ...(options.lineage ? { lineage: options.lineage as LineageContext } : {}),
     })
 

package/src/diagnosis/cards.ts

@@ -7,7 +7,7 @@ import type {
 } from './types.js'
 
 /**
- * 诊断卡片的**编解码**：markdown 卡片 ⇄ 图上的节点与边（0021 §6.3）。
+ * 诊断域 WikiCard 的**编解码**：卡片 ⇄ 图上的可复用节点与关系（0021 §6.3）。
  *
  * ## 为什么这一层必须存在
  *
@@ -16,8 +16,8 @@ import type {
  * 编译器连 `diagnosis/hypothesis` 这个 entity_type 都不认 —— 于是它既不会被 wikiNote 化，
  * 也不会进向量索引，**召回永远召不到它**。而「遇到类似问题先召回」正是这个产品的主张。
  *
- * 这一层把图变成卡片的**投影**：卡片是手写的（人写、Agent 提议后由人确认），
- * 图是算出来的。§4「存图、显树」讲的是同一件事 —— 存的是知识，图是它的一种读法。
+ * 这一层把预先整理好的可复用诊断 Knowledge 投影为 WikiCard。新排查记录走 SourceRaw，
+ * Case 由读取层派生；`diagnosis/case` 只保留旧格式读取与迁移兼容。
  *
  * ## 卡片三段式与「谁由卡片定义」的边界
  *
@@ -31,9 +31,10 @@ import type {
  *
  * | 图上的东西 | 谁定义 | 为什么 |
  * | --- | --- | --- |
- * | symptom / hypothesis / check_point / failure_reason / case 节点 | **卡片** | 这五类是人确认过的知识（§6.4） |
+ * | symptom / hypothesis / check_point / failure_reason 节点 | **WikiCard** | 这些是可复用知识（§6.4） |
  * | asset 节点 | 引用反推 | 它随数据目录同步，不手写；卡片里只留 id |
- * | 现象→假设 / 假设→检查点 / 假设→失败原因 / 检查点→资产 / 资产→假设 / 案例→现象 边 | **卡片** | 都是卡片字段的确定性投影 |
+ * | 现象→假设 / 假设→检查点 / 假设→失败原因 / 检查点→资产 / 资产→假设 边 | **WikiCard** | 都是卡片字段的确定性投影 |
+ * | 历史 case 节点与案例→现象边 | **旧 WikiCard** | 仅为旧库迁移与读取兼容；新 Case 由排查 SourceRaw 派生 |
  * | evidence / cause 节点，produces / supports / refutes / confirmed_as 边 | **一次排查** | 它们是一次执行的结果，不是知识；由 `01_source_raw/agent_diagnosis_case/` 那条 SourceRaw 读时解析出来 |
  *
  * 最后一行不是妥协，是分层：把「上次查到什么」写进卡片，等于让一份可复用的知识
@@ -286,9 +287,13 @@ function splitSections(body: string): DiagnosisCardSection[] {
 /* ─────────────────────────────────────────────── 图 → 卡片 ── */
 
 /**
- * 类型层与案例 → 卡片。
+ * 类型层与历史 Case 卡 → 卡片的兼容编解码器。
  *
- * `asset` / `evidence` / `cause` 节点**不产出卡片**：它们不是手确认过的知识（§6.4）。
+ * 新样例会用它写入预先整理的可复用诊断 Knowledge；旧 Case 卡仅用于读取和兼容迁移。
+ * 新排查不会把 Case 写成 WikiCard。
+ *
+ * `case`、`asset` / `evidence` / `cause` 节点**不产出新卡片**：前者是排查记录视图，
+ * 后三者不是可复用 Knowledge（§6.4）。
  * 被引用的资产会在反序列化时按 id 补一个最小节点回来。
  */
 export function graphToCards(graph: AttributionGraphData, cases: AttributionCase[] = []): DiagnosisCard[] {
@@ -395,7 +400,7 @@ export interface CompiledDiagnosis {
 /**
  * 卡片 → 图。
  *
- * 只产出「卡片定义得了」的那部分（类型层 + 引用层的资产 + 案例，以及六种卡片边）；
+ * 只产出当前 WikiCard 定义得了的部分（Knowledge 类型 + 引用层资产及其关系）；历史 Case 卡仅用于读取兼容；
  * `evidence` / `cause` 与四条执行边由一次排查写入（`agent_diagnosis_case` 的 SourceRaw），
  * 不在这里合成 —— 否则一次执行的结果会被伪装成可复用的知识。
  */

package/src/diagnosis/run.ts

@@ -1,5 +1,5 @@
 import type {
-  AttributionEdge, AttributionGraphData, AttributionNode, CasePathStep, DiagnosisRunEvidence, DiagnosisRunRecord,
+  AttributionCase, AttributionEdge, AttributionGraphData, AttributionNode, CasePathStep, DiagnosisRunEvidence, DiagnosisRunRecord,
 } from './types.js'
 import type { DiagnosisCard } from './cards.js'
 
@@ -12,15 +12,15 @@ import type { DiagnosisCard } from './cards.js'
  * （分类、版本、检索），就得是一条 SourceRaw。自造一个 jsonl 格式，等于在知识库旁边
  * 再养一套只读不进链路的数据 —— 这也是 0021 §0.3 撤销 `05_diagnosis/` 的直接原因。
  *
- * ## 它与案例卡片的区别
+ * ## 它与排查视图的关系
  *
  * | | 谁写 | 性质 |
  * | --- | --- | --- |
  * | 这条 SourceRaw（`agent_diagnosis_case`） | **Agent**，每次排查结束自动写 | 跑出来的**过程记录** |
- * | 案例卡片（`diagnosis/case`） | Agent 提议 → **人确认** | 归纳出来的**结论** |
+ * | 排查视图（Case） | 从这条记录读取 | 只读展示，不再生成第二张 WikiCard |
  *
- * 同一件事可以有两条记录，它们不是重复：一个回答「当时怎么走的」，一个回答「结论是什么」。
- * 而案例卡片必须经人确认 —— 它落在类型层收敛的那一侧，见 0021 §6.1。
+ * Event 与 Knowledge 在归一层并列；WikiCard 由 Knowledge 组织生成，并可指向 Event。
+ * Case 仅是一次排查记录的展示视图，不是新的持久化实体。
  *
  * ## 三段式
  *
@@ -212,18 +212,28 @@ export function runReferenceProblems(record: DiagnosisRunRecord, knownIds: Reado
   return problems
 }
 
-/**
- * 把一次排查归纳成一张**案例卡片**（还只是提议，要人确认才生效）。
- *
- * 归纳这一步是「过程记录 → 可复用知识」的那一跳，也是唯一需要人看的一跳：
- * 路径里哪几步其实是误导、根因一句话怎么写，都是判断题。
- */
-/**
- * 一次排查的案例卡片草案（0044 前叫 `caseProposalOf`）。
- *
- * 改名是因为它产出的东西**直接落卡**，不再是一条提议：名字里留着 `Proposal` 会让下一个
- * 读的人继续在两个时代之间猜。函数体一行没动 —— 它本来就是「从一条排查记录编出一张案例卡」。
- */
+/** Read-only case presentation projected from a diagnosis source record. */
+export function caseViewOfRun(record: DiagnosisRunRecord, symptomTitle: string): AttributionCase {
+  const rootCause = record.rootCause?.text ?? '（这次没有确认根因）'
+  const firstMisleading = record.misleading?.[0]
+  return {
+    id: `CASE-${record.runId}`,
+    title: symptomTitle,
+    symptomId: record.symptomId,
+    sections: [
+      { heading: '现象', body: `入口现象 \`${record.symptomId}\`（${symptomTitle}），开始于 ${record.startedAt}。` },
+      { heading: '排查过程', body: record.path.map(step => `- \`${step.label}\` ${step.note}${step.refuted ? '（否定）' : ''}`).join('\n') || '（没有记录路径）' },
+      { heading: '检查结果', body: record.evidence.map(item => `- \`${item.checkPointId}\`：${item.result ?? ''}（${item.verdict}）${item.why ? `，${item.why}` : ''}`).join('\n') || '（没有记录检查结果）' },
+      { heading: '根因与处理', body: [rootCause, record.rootCause?.fixAction].filter(Boolean).join('\n\n') },
+    ],
+    path: record.path,
+    durationMinutes: record.durationMinutes,
+    ...(firstMisleading ? { misleading: firstMisleading } : {}),
+    rootCause,
+    rootCauseStatus: record.rootCause ? 'confirmed' : 'unconfirmed',
+  }
+}
+/** 兼容旧版案例卡片格式的转换器；新排查只写 SourceRaw，不调用此函数。 */
 export function caseCardOf(record: DiagnosisRunRecord, symptomTitle: string): DiagnosisCard {
   const rootCause = record.rootCause?.text ?? '（这次没有确认根因）'
   const firstMisleading = record.misleading?.[0]

package/src/diagnosis/schema.ts

@@ -247,8 +247,8 @@ export function validateDiagnosis(graph: AttributionGraphData): DiagnosisIssue[]
       if (!node.verdict) issues.push(fieldIssue(node, 'verdict', '证据必须给出结论：supports / refutes / inconclusive'))
       if (!node.why?.trim()) issues.push(fieldIssue(node, 'why', '证据必须说明「为什么这个结果算数或不算数」—— 采信与剔除都得能说理由'))
     }
-    // `case` 节点只是图上的桩：案例的正文与路径住在案例卡片里，由
-    // DiagnosisSnapshot.cases 校验，不在节点上重复要求。
+    // `case` 节点只是兼容旧图的桩；当前排查视图由 SourceRaw 记录派生，
+    // 新排查不会再写 diagnosis/case WikiCard。
   }
 
   // ── 第二层：引用完整性 ────────────────────────────────────────────────────

package/src/diagnosis/seed-source.ts

@@ -6,11 +6,12 @@
  * 所以 seed 也走完整条动线：
  *
  * ```
- * 这些文本（SourceRaw） → 五类卡片 → 编译 → 图
+ * 原文（SourceRaw） → 抽取 Knowledge / Event → 归一
+ * 排查运行记录（SourceRaw） → 只读 Case 视图
  * ```
  *
- * 手册与复盘是**人写的散文**（就是下面这些字面量），卡片是从它们编译出来的结构化提取。
- * 两者内容会有重叠 —— 那是正常的：卡片是散文的投影，不是它的替代品。
+ * 手册与复盘是**人写的散文**（就是下面这些字面量）。载入示例只保存来源与可复用诊断卡；
+ * Case 从独立的排查运行记录派生，不生成第二张诊断卡。
  */
 import { SEED_CASES, SEED_RUNS } from './seed.js'
 import { renderRunSource } from './run.js'
@@ -83,7 +84,7 @@ export const SEED_HANDBOOK = `# 日报指标异常排查手册（内部版）
 同一批假设被反复验证，而永远不会被剪掉 —— 图上会长出一堆僵尸边。
 `
 
-/** 三篇复盘：案例卡片的出处。正文就是案例的散文段（现象 / 影响面 / 排查过程 / 根因 / 修复）。 */
+/** 三篇复盘：供后续抽取 Knowledge / Event 的来源文档。 */
 export function seedCaseSources(): SeedSource[] {
   return SEED_CASES.map(item => ({
     id: item.id,

package/src/diagnosis/seed.ts

@@ -19,7 +19,7 @@ import type { AttributionCase, AttributionGraphData, DiagnosisRunRecord } from '
  * | `question` | 人 | 手册与复盘 —— 卡片 `source_refs` 指向这里 |
  * | `agent_diagnosis_case` | Agent | 一次排查的过程记录（`SEED_RUNS`） |
  *
- * `SEED_GRAPH` 里**只有卡片定义得了的东西**：类型层、引用层资产、案例桩，以及六种卡片边。
+ * `SEED_GRAPH` 里有可复用诊断 Knowledge 与引用层资产；历史案例桩只用于旧格式兼容夹具。
  * `evidence` / `cause` 与四条执行边由 `SEED_RUNS` 读时解析出来 —— 把「上次查到什么」
  * 写进卡片，等于让一份可复用的知识绑死在一次执行上。
  */
@@ -122,10 +122,8 @@ export const SEED_GRAPH: AttributionGraphData = {
     { id: 'metric_daily_gmv', kind: 'asset', layer: 'reference', title: 'metric_daily_gmv', assetType: 'metric' },
     { id: 'bi_daily_dashboard', kind: 'asset', layer: 'reference', title: 'bi_daily_dashboard', assetType: 'linkage' },
 
-    // ── 实例层：案例节点是**图上的桩**（正文与有序路径住在案例卡片里） ──────
-    // 标题必须与 `SEED_CASES[].title` 是同一个字符串，否则同一份知识会有两份标题
-    // （而且还真的不一致过：「只剩」vs「只有」）。画布要在标签前显示案例 id，
-    // 那是渲染层的事（见 `nodeStyleFor` 的 labelText）。
+    // ── 兼容层：旧格式里的案例节点桩。新样例的排查记录由 SEED_RUNS 派生为只读视图。 ──
+    // 保留稳定 ID，供旧卡片编解码与历史图迁移夹具使用。
     { id: 'CASE-001', kind: 'case', layer: 'instance', title: '日报 GMV 为 0' },
     { id: 'CASE-002', kind: 'case', layer: 'instance', title: '订单数只有昨日 12%' },
     { id: 'CASE-003', kind: 'case', layer: 'instance', title: 'DAU 突增 3.1 倍' },
@@ -197,7 +195,7 @@ export const SEED_GRAPH: AttributionGraphData = {
   ],
 }
 
-/** 三个 seed 案例卡片，与上面图谱里的节点 id 对齐（0021 §11）。 */
+/** 旧版示例 Case 投影夹具；仅供历史卡片编解码与来源文案使用，当前载入流程不落盘。 */
 export const SEED_CASES: AttributionCase[] = [
   {
     id: 'CASE-001',
@@ -280,8 +278,8 @@ export const SEED_CASES: AttributionCase[] = [
  * 三次排查的**过程记录**（`agent_diagnosis_case`）。
  *
  * 它们与 `SEED_CASES` 一一对应，但**不是同一份东西**：这里是 Agent 跑出来的原始记录
- * （每条检查点真跑了什么、看到什么、这个结果算不算数），`SEED_CASES` 是之后归纳出来的
- * 案例卡片（要经人确认才生效）。一个回答「当时怎么走的」，一个回答「结论是什么」。
+ * （每条检查点真跑了什么、看到什么、这个结果算不算数）；当前 Case 视图从运行记录派生，
+ * `SEED_CASES` 仅保留作旧卡片格式夹具。
  *
  * `E7` 是 CASE-001 里那次**贵的否定**：T7.2 直连明细对账推翻了 H7。它不在案例的
  * 主路径上（主路径早就确认了 H1），但它是这次排查最贵的一条知识 —— 40 分钟的误导段