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

package/src/client/TypeDefinitionDrawer.tsx

@@ -12,6 +12,7 @@ export interface CompileModelSelectionView {
   mode: 'default' | 'fixed'
   provider?: string
   model?: string
+  reasoningEffort?: string
 }
 
 interface CompileModelCatalogItem {
@@ -21,6 +22,7 @@ interface CompileModelCatalogItem {
   description?: string
   available: boolean
   current?: boolean
+  reasoning?: { efforts: Array<{ id: string; name: string; description?: string }>; defaultEffort?: string }
 }
 
 interface CompileModelCatalog {
@@ -50,6 +52,8 @@ export function TypeDefinitionDrawer({
 }: TypeDefinitionDrawerProps): ReactNode {
   const [noteDraft, setNoteDraft] = useState(extractionNote)
   const [modelDraft, setModelDraft] = useState(DEFAULT_MODEL_VALUE)
+  const [effortDraft, setEffortDraft] = useState(compileModel.reasoningEffort ?? '__default__')
+  useEffect(() => { setEffortDraft(compileModel.reasoningEffort ?? '__default__') }, [compileModel.reasoningEffort])
   const [catalog, setCatalog] = useState<CompileModelCatalog | null>(null)
   const [catalogError, setCatalogError] = useState('')
   useEffect(() => { setNoteDraft(extractionNote) }, [extractionNote])
@@ -64,14 +68,16 @@ export function TypeDefinitionDrawer({
     if (!open || onSaveCompileModel === undefined) return undefined
     let cancelled = false
     setCatalogError('')
-    setCatalog(null)
-    void requestJson<CompileModelCatalog>(`/knowledge/models?kb=${encodeURIComponent(kbId)}`).then(result => {
+    const route = modelDraft.startsWith('fixed:') ? modelDraft.split(':').slice(1).map(decodeURIComponent) : [catalog?.default.provider, catalog?.default.model]
+    const params = new URLSearchParams({ kb: kbId })
+    if (route[0] && route[1]) { params.set('provider', route[0]); params.set('model', route[1]) }
+    void requestJson<CompileModelCatalog>(`/knowledge/models?${params}`).then(result => {
       if (!cancelled) setCatalog(result.data ?? null)
     }).catch(error => {
       if (!cancelled) setCatalogError(error instanceof Error ? error.message : String(error))
     })
     return () => { cancelled = true }
-  }, [kbId, onSaveCompileModel, open])
+  }, [kbId, onSaveCompileModel, open, modelDraft, catalog?.default.provider, catalog?.default.model])
 
   const modelOptions = useMemo(() => {
     const options: SelectMenuOption[] = [{
@@ -100,20 +106,26 @@ export function TypeDefinitionDrawer({
     return options
   }, [catalog, compileModel.mode, compileModel.model, compileModel.provider])
 
-  const modelChanged = modelDraft !== (compileModel.mode === 'fixed' && compileModel.provider && compileModel.model
+  const modelChanged = effortDraft !== (compileModel.reasoningEffort ?? '__default__') || modelDraft !== (compileModel.mode === 'fixed' && compileModel.provider && compileModel.model
     ? fixedModelValue(compileModel.provider, compileModel.model)
     : DEFAULT_MODEL_VALUE)
   const saveCompileModel = async (): Promise<void> => {
     if (onSaveCompileModel === undefined) return
     if (modelDraft === DEFAULT_MODEL_VALUE) {
-      await onSaveCompileModel({ mode: 'default' })
+      await onSaveCompileModel({ mode: 'default', ...(effortDraft === '__default__' ? {} : { reasoningEffort: effortDraft }) })
       return
     }
     const selected = catalog?.models.find(item => fixedModelValue(item.provider, item.id) === modelDraft && item.available)
     if (!selected) return
-    await onSaveCompileModel({ mode: 'fixed', provider: selected.provider, model: selected.id })
+    await onSaveCompileModel({ mode: 'fixed', provider: selected.provider, model: selected.id, ...(effortDraft === '__default__' ? {} : { reasoningEffort: effortDraft }) })
   }
 
+  const selectedModel = catalog?.models.find(item => modelDraft === DEFAULT_MODEL_VALUE
+    ? item.provider === catalog.default.provider && item.id === catalog.default.model
+    : fixedModelValue(item.provider, item.id) === modelDraft)
+  const effortOptions: SelectMenuOption[] = [{ value: '__default__', label: '跟随模型默认强度' }, ...(selectedModel?.reasoning?.efforts ?? []).map(item => ({ value: item.id, label: item.name }))]
+  if (effortDraft !== '__default__' && !effortOptions.some(option => option.value === effortDraft)) effortOptions.push({ value: effortDraft, label: `当前不可用：${effortDraft}`, disabled: true })
+
   return <Drawer open={open} onOpenChange={onOpenChange}>
     {open && <DrawerContent
       className={styles.settingsDrawer}
@@ -129,10 +141,13 @@ export function TypeDefinitionDrawer({
             <div className={styles.settingsSectionHeader}>
               <div><h3>编译模型</h3></div>
             </div>
-            <Field as="div" label="模型" hint={modelDraft === DEFAULT_MODEL_VALUE ? undefined : '固定模型不可用时会降级为规则抽取。'}>
-              <SelectMenu value={modelDraft} disabled={busy !== null || (catalog === null && catalogError === '')} onValueChange={setModelDraft}
+            <Field as="div" label="模型" hint="用于抽取、归一补判与卡片组织；任务启动时保存实际选择。">
+              <SelectMenu value={modelDraft} disabled={busy !== null || (catalog === null && catalogError === '')} onValueChange={value => { setModelDraft(value); setEffortDraft('__default__') }}
                 options={modelOptions} placeholder="加载 DSH 模型目录…" aria-label="编译模型" />
             </Field>
+            <Field as="div" label="思考强度" hint={selectedModel?.reasoning?.efforts.length ? '档位来自当前模型的 DSH 目录。' : '当前模型未提供可选档位，使用模型默认值。'}>
+              <SelectMenu value={effortDraft} options={effortOptions} onValueChange={setEffortDraft} disabled={busy !== null || !selectedModel?.reasoning?.efforts.length} aria-label="编译模型思考强度" />
+            </Field>
             {catalog?.default && !catalog.default.available && <p className={styles.kbHint} role="status">
               DSH 默认模型不可用；可在 DSH 设置中修复，或选择固定模型。
             </p>}

package/src/client/WikiCardPreview.tsx

@@ -20,8 +20,8 @@
  */
 
 import { useEffect, useMemo, useState, type ReactNode } from 'react'
-import { AlertCircle, Check, GitCompare, RefreshCw } from '@tita-agent/ui/icons'
-import { Button, cn } from '@tita-agent/ui/components'
+import { AlertCircle, Check, CircleDot, GitCompare, RefreshCw } from '@tita-agent/ui/icons'
+import { Badge, Button, cn } from '@tita-agent/ui/components'
 import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from '@tita-agent/ui/overlays'
 import type { AssetRef } from './asset-images.ts'
 import type { VersionManagerEntry } from '@tita-agent/ui/versions'
@@ -34,13 +34,10 @@ import { STATUS_VIEW } from './WikiCardRow.tsx'
 import { styles } from './styles.ts'
 import { formatDateTime } from './format.ts'
 import type { CardRelatedView, KnowledgeCardView, WikiCardVersionView } from './KnowledgeBaseTab.tsx'
+import type { AttributionEvent } from './attribution/model.ts'
 
-/**
- * 正文档里那一节「相关」的小节名。与 `wiki-finalize.ts` 的 `RELATED_HEADING` 同值 ——
- * 客户端不能 import 服务端模块（那边拉 node: 内置），所以这里重列一次，并由一条测试
- * 钉住两边相等（同 `SOURCE_FORMAT_LABEL` 那类「契约重列」的处置）。
- */
-const RELATED_SECTION = ['相关']
+/** 正文里的生成式导航小节名；它们由结构化引用展示，不重复留在正文。 */
+const RELATED_SECTION = ['相关', '关联 Event', '关联 Events', '关联事件']
 
 /** 一张卡片的完整预览数据（正文 + 版本 + 图片 + 相关 + 坐标名字）。 */
 export interface CardPreviewDetail {
@@ -90,6 +87,9 @@ export interface WikiCardPreviewProps {
   onCompare?: (entry: VersionManagerEntry) => void
   versionDiff?: { data?: VersionContentDiffData; loading: boolean; error?: string }
   onOpenRelated: (link: { entityType: string; entityId: string; title: string }) => void
+  /** 打开 Event 栏并定位到这张卡片引用的事件。 */
+  onOpenEvent: (eventId: string) => void
+  events?: AttributionEvent[]
   /**
    * SourceRaw 的 docId → 文档标题。
    *
@@ -113,7 +113,7 @@ function sourceRefsText(refs: string[], titles?: Map<string, string>): string {
 
 export function WikiCardPreview({
   kbId, detail, versionEntries, currentVersionId, loading,
-  onChanged, onOpenRelated, sourceTitles,
+  onChanged, onOpenRelated, onOpenEvent, events = [], sourceTitles,
   onCompare, versionDiff = { loading: false },
 }: WikiCardPreviewProps): ReactNode {
   const [recompiling, setRecompiling] = useState(false)
@@ -122,9 +122,27 @@ export function WikiCardPreview({
   const status = STATUS_VIEW[detail.card.status]?.label ?? detail.card.status
   const refs = sourceRefsText(detail.card.sourceRefs, sourceTitles)
   const knowledge = useCardKnowledge(kbId, detail.card.entityId, sourceTitles)
+  const relatedEvents = useMemo(() => {
+    const raw = detail.card.metadata?.event_refs
+    let ids: string[] = []
+    if (Array.isArray(raw)) ids = raw.filter((item): item is string => typeof item === 'string')
+    else if (typeof raw === 'string') {
+      try {
+        const parsed: unknown = JSON.parse(raw)
+        if (Array.isArray(parsed)) ids = parsed.filter((item): item is string => typeof item === 'string')
+      } catch { /* 无效派生引用不显示 */ }
+    }
+    const byId = new Map(events.map(event => [event.id, event]))
+    return [...new Set(ids)].map(id => byId.get(id) ?? { id }).map(event => ({
+      id: event.id,
+      title: 'title' in event ? event.title : event.id,
+      summary: 'summary' in event ? event.summary : '',
+      occurredAt: 'occurredAt' in event ? event.occurredAt : undefined,
+    }))
+  }, [detail.card.metadata, events])
   useEffect(() => { setCompareOpen(false) }, [detail.card.entityId])
   /**
-   * 先移除旧版本只在面板下方由关系图展示的「相关」区块，再补普通引用清单。
+   * 移除旧版本正文里的生成式导航区块，再显示结构化卡片与 Event 引用。
    *
    * 投影顺序固定为：物化正文 → 去掉旧导航区 → 补引用清单。
    */
@@ -206,6 +224,21 @@ export function WikiCardPreview({
         {recompiling ? '编译中…' : '按坐标重新编译'}</Button>}
     />
 
+    {relatedEvents.length > 0 && <section className="flex min-w-0 flex-col gap-1.5" aria-label="关联 Event">
+      <h3 className="m-0 flex items-center gap-1.5 text-[11px] font-semibold text-tita-ink">
+        <CircleDot size={12} aria-hidden="true" />关联 Event <Badge tone="neutral">{relatedEvents.length}</Badge>
+      </h3>
+      <ul className="m-0 grid list-none gap-1 p-0">
+        {relatedEvents.map(event => <li key={event.id} className="min-w-0 rounded-md border border-tita-line px-2 py-1.5">
+          <Button variant="ghost" size="sm" className="h-auto max-w-full justify-start px-0 py-0 text-left text-[10.5px]" onClick={() => onOpenEvent(event.id)}>
+            <span className="min-w-0 truncate">{event.title}</span>
+            {event.occurredAt && <span className="shrink-0 text-[9px] text-tita-ink-faint">· {event.occurredAt}</span>}
+          </Button>
+          {event.summary && <p className="m-0 mt-0.5 line-clamp-2 text-[10px] leading-relaxed text-tita-ink-muted">{event.summary}</p>}
+        </li>)}
+      </ul>
+    </section>}
+
     {recompileNotice && <div className={cn(styles.cardRecompileNotice, recompileNotice.tone === 'error' ? styles.cardRecompileNoticeError : styles.cardRecompileNoticeSuccess)} role="status">
       {recompileNotice.tone === 'error' ? <AlertCircle size={12} aria-hidden="true" /> : <Check size={12} aria-hidden="true" />}
       <span>{recompileNotice.text}</span>

package/src/client/WikiFlowPanel.tsx

@@ -165,7 +165,7 @@ const STAGES: Stage[] = [
     body: [
       '**三个轴分别归一**：先找 canonical，再找 alias，最后才新建候选。匹配不唯一时，**不猜**。',
       '每条知识绑定一个**坐标**：三个轴实体 id 的**复合键**。**Coordinate 不是实体**，没有自己的表。',
-      '同义知识合并，`sources` 追加；相互矛盾的说法保留，并标记为 disputed。',
+      '归一化文本一致时合并并追加来源；语义相似只记候选，不自动合并。相互矛盾的说法需显式标记 disputed。',
     ],
     rule: {
       order: '2',
@@ -176,7 +176,7 @@ const STAGES: Stage[] = [
     produces: {
       layer: 'Canonical Knowledge',
       ask: '在哪里',
-      note: '轴已归一并绑成 id；同义合并过，冲突留着',
+      note: '轴绑定为 id；同文事实合并，语义候选待确认',
     },
   },
   {
@@ -198,7 +198,7 @@ const STAGES: Stage[] = [
       title: '坐标决定卡片身份，卡名只是显示',
       body: '一个坐标最多一张卡。坐标是数据库主键；标题由对象、场景和动作生成，只是**显示名**，不参与判重。',
     },
-    model: '系统（确定）',
+    model: '系统分组，可选模型组织',
     produces: {
       layer: 'Wiki Card',
       ask: '怎么组织这些知道的东西',
@@ -217,7 +217,7 @@ const STAGES: Stage[] = [
       '**Knowledge 是证据层，不是第二个检索入口**：命中 Section 后，再带出对应知识、状态和出处。',
       '向量、关键词和图谱 boost 都属于**可重建的派生层**（`derived.db`）。**轴注册表不是索引**，而是坐标解析时使用的命名真源。',
     ],
-    model: '不调模型',
+    model: '系统切分 + 向量编码',
     produces: {
       layer: '可检索 Wiki',
       /* 派生层，所以没有 ask —— 它不是实体，不回答上面那三个问题。 */

package/src/client/architecture.tsx

@@ -286,7 +286,7 @@ icon: Database, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'source-raw',
       { label: '物化 WikiCard', detail: '按 (对象, 动作, 场景) 分组，卡名由公式推导（对象名 + 场景 + 动作名）；小节与字段作为组织提示，卡片直接入库，review 与备注在预览中处理', state: 'done' },
       { label: '建索引', detail: '切召回单元、写索引页与相关卡片、检查断链，不调模型', state: 'done' },
     ],
-    status: 'live', statusNote: '四段都已实现：抽 Knowledge、归一坐标、按坐标物化卡片、切召回单元并建索引（模型不可用时退回规则抽取，此时没有坐标，正文按小节切）。入库后的 review 与备注在卡片的预览侧栏里。',
+    status: 'live', statusNote: '导入默认只保存来源；抽取 Knowledge / Event、归一、物化分别运行，也可全链路运行。未变文档复用检查点；构建成功后统一发布索引。模型不可用时任务明确失败，可查看输出与历史后重试。',
 icon: RefreshCw, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'wiki',
   },
   build: {

package/src/client/attribution/AttributionTab.tsx

@@ -37,8 +37,9 @@ interface DiagnosisPayload {
 
 /** 服务端的三种来源 → 徽标上那句人话。 */
 function sourceLabelOf(source: string | undefined): string {
-  if (source === 'cards') return '02_wiki/diagnosis'
-  if (source === 'jsonl') return '05_diagnosis（旧格式）'
+  if (source === 'cards') return '可复用诊断卡片'
+  if (source === 'records') return 'Event 与排查记录'
+  if (source === 'jsonl') return '旧格式历史快照'
   return '还没有排查知识'
 }
 
@@ -224,10 +225,9 @@ export function AttributionTab({ visible, activeQuestion, onOpenKnowledge }: {
   }, [visible, reloadToken, applyPayload])
 
   /**
-   * 载入内置示例：**显式的一次写**，写进的是这个库自己的 `01_source_raw/` 与 `02_wiki/`。
+   * 载入内置示例：**显式的一次写**，将来源记录与可复用诊断卡写入当前知识库。
    *
-   * 载完重新读一次，让图、案例、来源徽标全部换成真实数据 —— 载入之后它们就是普通卡片，
-   * 可以照常改、照常删，所以说明里必须把这件事讲清楚。
+   * 载完重新读一次，让图、只读排查视图、来源徽标全部换成当前库的数据。
    */
   const loadSample = async (): Promise<void> => {
     setSampleBusy(true); setSampleError(null)
@@ -236,7 +236,7 @@ export function AttributionTab({ visible, activeQuestion, onOpenKnowledge }: {
       const body = await response.json() as { ok?: boolean; data?: DiagnosisPayload; error?: { message?: string } }
       if (!response.ok || body.ok === false) throw new Error(body.error?.message ?? `HTTP ${response.status}`)
       applyPayload(body.data ?? {})
-      setSampleNotice('已载入内置示例：4 份来源写进 01_source_raw/，26 张卡片写进 02_wiki/diagnosis/。它们就是普通来源与卡片，可以照常改或删。')
+      setSampleNotice('已载入内置示例：7 条来源记录、23 张可复用诊断卡；3 条排查记录以只读案例视图呈现。')
     } catch (error) {
       setSampleError(error instanceof Error ? error.message : String(error))
     } finally {

package/src/client/attribution/CaseView.tsx

@@ -46,7 +46,9 @@ export function CaseView({ cases, activeId, onActiveChange }: {
           <h3 className="text-[13px] font-semibold leading-snug">{active.title}</h3>
           <p className="mt-0.5 text-[10.5px] text-tita-ink-muted">{active.id} · 耗时 {active.durationMinutes} min</p>
         </div>
-        <Badge tone="success">已确认根因</Badge>
+        <Badge tone={active.rootCauseStatus === 'unconfirmed' ? 'warning' : 'success'}>
+          {active.rootCauseStatus === 'unconfirmed' ? '根因未确认' : '已确认根因'}
+        </Badge>
       </header>
 
       {/* ── wiki 段 ── */}

package/src/client/attribution/EventView.tsx

@@ -1,5 +1,5 @@
 import { CircleDot, FileText, GitBranch, Search } from '@tita-agent/ui/icons'
-import type { ReactNode } from 'react'
+import { useEffect, type ReactNode } from 'react'
 import { Badge, Card } from '@tita-agent/ui/components'
 import type { AttributionEvent } from './model.ts'
 
@@ -15,7 +15,12 @@ function identityLabel(event: AttributionEvent): string {
   return '来源内独立记录'
 }
 
-export function EventView({ events }: { events: AttributionEvent[] }): ReactNode {
+export function EventView({ events, focusEventId }: { events: AttributionEvent[]; focusEventId?: string }): ReactNode {
+  useEffect(() => {
+    if (!focusEventId) return
+    const target = document.getElementById(`knowledge-event-${focusEventId}`)
+    target?.scrollIntoView({ block: 'center', behavior: 'smooth' })
+  }, [events, focusEventId])
   if (events.length === 0) return <p className="py-5 text-center text-[11px] text-tita-ink-muted">还没有从文档中提取 Event。</p>
 
   const groups = new Map<string, { label: string; events: AttributionEvent[] }>()
@@ -40,7 +45,12 @@ export function EventView({ events }: { events: AttributionEvent[] }): ReactNode
         <GitBranch size={12} className="mt-0.5 shrink-0 text-tita-primary" />
         {group.label}
       </h3>
-      {group.events.map(event => <Card key={event.id} className="gap-2 p-2.5">
+      {group.events.map(event => <article
+        key={event.id}
+        id={`knowledge-event-${event.id}`}
+        className={event.id === focusEventId ? 'rounded-lg ring-2 ring-tita-primary ring-offset-2 ring-offset-tita-surface' : undefined}
+        aria-label={event.id === focusEventId ? `已定位 Event：${event.title}` : undefined}
+      ><Card className="gap-2 p-2.5">
         <header className="flex items-start gap-2">
           <div className="min-w-0 flex-1">
             <h4 className="text-[12px] font-semibold leading-snug text-tita-ink">{event.title}</h4>
@@ -92,7 +102,7 @@ export function EventView({ events }: { events: AttributionEvent[] }): ReactNode
             : <span className="text-[9.5px] text-tita-ink-faint">暂无可显示的引文</span>}
           {event.missing.length > 0 && <p className="text-[9.5px] leading-relaxed text-tita-warning">待补：{event.missing.join('、')}</p>}
         </footer>
-      </Card>)}
+      </Card></article>)}
     </section>)}
   </div>
 }

package/src/client/attribution/RunView.tsx

@@ -177,9 +177,9 @@ export function RunView({ data, cases, symptoms, symptomId, onSymptomChange, onS
         不是一次进行中的排查 —— 没有「本次跑了哪些检查点、看到什么」的现场状态，
         按一个按钮只能编出一份路径来，而那正好是这个产品最不该做的事。
         真实的写回发生在排查进行时：Agent 调 `POST /diagnosis/run` 落一条
-        `agent_diagnosis_case` 的 SourceRaw，顺手提一张案例卡片等人确认。
+        `agent_diagnosis_case` 的 SourceRaw；Case 由这条记录只读派生，Knowledge / Event 由独立链路抽取和归一。
       */}
-      <Button className="w-full" size="sm" disabled title="写回发生在排查进行时：Agent 用 POST /diagnosis/run 落一条诊断日志并提议案例卡片。这一屏是只读的复盘视图。">
+      <Button className="w-full" size="sm" disabled title="Agent 在排查结束时用 POST /diagnosis/run 落 SourceRaw；Case 只读派生，Knowledge / Event 由知识链路处理。">
         写回由排查进行时完成（这一屏只读）
       </Button>
     </Card>

package/src/client/attribution/graph-options.ts

@@ -162,8 +162,8 @@ export function nodeStyleFor(
     lineDash: isGap ? [4, 3] : undefined,
     zIndex: node.layer === 'instance' ? 0 : 1,
     // 圆里放 id（直径由复用次数决定，中文标题塞不进）；胶囊放标题。
-    // 案例例外：它的标题来自案例卡片、不含 id，而案例要靠 id 才能在复盘里被指认 ——
-    // 所以由画布把 id 拼回去，标题本身保持单一份来源。
+    // Case 是排查 SourceRaw 的只读投影，不是 WikiCard。视图用症状标题；画布补上稳定的
+    // Case id，方便在复盘里指认这次排查。
     labelText: shape === 'circle' ? node.id : node.kind === 'case' ? `${node.id} ${node.title}` : node.title,
     labelPlacement: 'center',
     labelFill: palette.text,

package/src/client/pages.tsx

@@ -228,7 +228,7 @@ function App(): ReactNode {
 
   if (route.kind === 'run') return <RunPage kb={route.kb} runId={route.run} />
 
-  if (route.kind === 'tasks') return <PageShell title="抽取任务" column="trial"><ExtractionTasksPage kb={route.kb} /></PageShell>
+  if (route.kind === 'tasks') return <PageShell title="知识处理" column="trial"><ExtractionTasksPage kb={route.kb} /></PageShell>
 
   if (route.kind === 'help') {
     if (route.topic === 'overview') {
@@ -248,7 +248,7 @@ function App(): ReactNode {
     <p>整页的地址只有这几种：</p>
     <p><code>/knowledge/pages/trial?kb=&lt;知识库 id&gt;</code> · 抽取试跑<br />
       <code>/knowledge/pages/run?kb=&lt;知识库 id&gt;&amp;run=&lt;轨迹 id&gt;</code> · 一次抽取的报告<br />
-      <code>/knowledge/pages/tasks?kb=&lt;知识库 id&gt;</code> · 抽取任务<br />
+      <code>/knowledge/pages/tasks?kb=&lt;知识库 id&gt;</code> · 知识处理与任务历史<br />
       <code>/knowledge/pages/help/compile</code> · 编译和召回链路<br />
       <code>/knowledge/pages/help/intent</code> · 意图的逻辑<br />
       <code>/knowledge/pages/help/attribution</code> · 智能归因事件<br />

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 分钟的误导段