dsh-data-domain-knowledge 0.1.0-alpha.2 → 0.1.0-alpha.4

package/src/client/KnowledgeBaseTab.tsx

@@ -35,21 +35,26 @@
 
 import { useCallback, useEffect, useMemo, useRef, useState, type ChangeEvent, type ReactNode } from 'react'
 import {
-  AlertCircle, Check, Eye, FileText, FileUp, FolderOpen,
-  Layers3, RefreshCw, Search, ShieldCheck, Tags, Trash2, Upload, X,
+  AlertCircle, Check, ChevronDown, Eye, ExternalLink, FileText, FileUp, FolderOpen,
+  Layers3, RefreshCw, Search, Tags, Trash2, Upload, X,
 } from '@tita-data-agent/ui/icons'
 import type { LucideIcon } from '@tita-data-agent/ui/icons'
-import { Badge, Button, Card, Input, Label, SelectMenu, cn } from '@tita-data-agent/ui/components'
+import {
+  Badge, Button, Card, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger,
+  Field, Input, SelectMenu, Tabs, TabsContent, TabsList, TabsTrigger, cn,
+} from '@tita-data-agent/ui/components'
 import {
   Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle,
   Drawer, DrawerBody, DrawerContent, DrawerDescription, DrawerHeader, DrawerTitle,
 } from '@tita-data-agent/ui/overlays'
 import { ObjectPicker } from '@tita-data-agent/ui/workspace'
 import { RestoreDialog, type VersionManagerEntry } from '@tita-data-agent/ui/versions'
+import { readRemembered, readRememberedId, remember } from './panel-state.ts'
 import { styles } from './styles.ts'
 import { formatBytes, formatDateTime, formatTime } from './format.ts'
-import { PreviewContent, PreviewMeta, PreviewVersions } from './PreviewSections.tsx'
-import type { KnowledgeTab } from './architecture.tsx'
+import { PreviewContent, PreviewMeta, PreviewRelated, PreviewVersions, type PreviewRow } from './PreviewSections.tsx'
+import type { AssetRef } from './asset-images.ts'
+import { KNOWLEDGE_TABS, type KnowledgeTab } from './architecture.tsx'
 import { KnowledgeStepRail } from './KnowledgeStepRail.tsx'
 import { NodeSettingsPanel, SettingsChip, useScope, type SettingsNode, type SettingsScopeLike } from './NodeSettings.tsx'
 import { RecallPanel } from './RecallPanel.tsx'
@@ -57,7 +62,8 @@ import { KnowledgeGraphView } from './KnowledgeGraphView.tsx'
 import type { GraphEdgeView, GraphNodeView } from './graph/layout.ts'
 import type { WikiTypeView } from './WikiTypeEditor.tsx'
 import { WikiFlowCard } from './WikiFlowCard.tsx'
-import { TypeDefinitionDrawer } from './TypeDefinitionDrawer.tsx'
+import { TypeDefinitionDrawer, type TypeDefinitionSection } from './TypeDefinitionDrawer.tsx'
+import { WikiCardReview } from './WikiCardReview.tsx'
 
 // ------------------------------------------------------------------ contract
 // Mirrors the plugin HTTP contract (see plugins/dsh-data-domain-knowledge/README.md).
@@ -77,9 +83,19 @@ export interface SourceTypeDef {
   enabled: boolean
   builtin: boolean
   fallback: boolean
+  /** 这一类来源该带哪些元数据字段（0048）。缺省 = 没有声明。 */
+  metadataFields?: SourceMetadataField[]
   sourceCount: number
 }
 
+/** 一个元数据字段声明。`key` 是 front matter 顶层键，或 `sources[0].author` 这种路径。 */
+export interface SourceMetadataField {
+  key: string
+  label: string
+  description?: string
+  required?: boolean
+}
+
 export interface SourceClassifierStep {
   type: string
   rule: string
@@ -121,6 +137,8 @@ export interface SourceTypeDraft {
   description: string
   signals: string
   excludes: string
+  /** 这一类来源该带哪些元数据字段（0048）。空行在保存前会被丢掉。 */
+  metadataFields?: SourceMetadataField[]
 }
 
 export interface KnowledgeBase {
@@ -133,7 +151,6 @@ export interface KnowledgeBase {
   /** Wiki 卡片类型注册表（0024）。 */
   wikiTypes: WikiTypeView[]
   /** `report` 只标记问题，`strict` 拒绝不合规的写入。 */
-  wikiSchemaMode: 'strict' | 'report'
   /** 计算字段：这套 schema 是否已偏离出厂定义。 */
   wikiTypesCustomized: boolean
   createdAt: string
@@ -165,8 +182,15 @@ export interface KnowledgeDocument {
 
 export interface KnowledgeDocumentDetail extends KnowledgeDocument {
   content: string
+  /**
+   * 正文总字符数。`content` 可能只是前一段 —— 明细接口按 `SOURCE_PREVIEW_CHARS`
+   * 封顶（4000），所以**不能**再用 `content.length` 当「全文有多少」。
+   */
+  contentChars: number
+  /** `content` 是不是被截断过。为真时给「新页面打开」。 */
+  contentTruncated: boolean
   frontmatter: Record<string, unknown>
-  assets: Array<{ rel: string; bytes: number; url: string }>
+  assets: AssetRefView[]
   lineage?: Record<string, string>
 }
 
@@ -181,6 +205,98 @@ export interface DocumentVersion {
 }
 
 /** Wiki 卡片（0025：带上 metadata，界面要能显示 schema 待补项）。 */
+/** 图片素材的客户端形状。解析规则住在 `asset-images.ts`，两个预览抽屉共用它。 */
+export type AssetRefView = AssetRef
+
+/**
+ * 格式类 → 人话（0049）。
+ *
+ * `source_format` 是转换内核的词汇（`web_page` / `office` / `anydoc@0.2.4/pptx` 这一类），
+ * 直接摆在界面上等于让人先学一遍实现。表里没有的格式**原样显示**：一个看得出是原始值
+ * 的字符串，好过猜一个像人话的错标签。
+ */
+const SOURCE_FORMAT_LABEL: Record<string, string> = {
+  web_page: '网页',
+  html: '网页',
+  markdown: 'Markdown',
+  text: '纯文本',
+  csv: '表格',
+  json: 'JSON',
+  office: 'Office 文档',
+  pdf: 'PDF',
+  image: '图片',
+  audio: '音频',
+  video: '视频',
+}
+
+function sourceFormatLabel(format: string | undefined): string {
+  if (!format) return 'unknown'
+  return SOURCE_FORMAT_LABEL[format] ?? format
+}
+
+/** `generated.by`（谁把它转出来的）。它只在悬停里出现，所以不给它一行。 */
+function generatorOf(frontmatter: Record<string, unknown>): string {
+  const generated = (frontmatter.generated ?? {}) as Record<string, unknown>
+  return typeof generated.by === 'string' && generated.by.trim() ? `生成者 ${generated.by}` : ''
+}
+
+/**
+ * OKF 的那几个顶层键 → 元信息行（0048）。
+ *
+ * 只显示**文件里真的有**的键：没有就不占一行。`sources[]` 取第一条（这份文件的来源），
+ * 它里面最要紧的两项是作者与发布时间 —— 0048 之前它们被抽出来就扔了，知识库里
+ * 没有任何一份来源记得住「谁写的、什么时候发的」。
+ */
+function sourceProvenanceRows(frontmatter: Record<string, unknown>): PreviewRow[] {
+  const rows: PreviewRow[] = []
+  const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '')
+  const resource = text(frontmatter.resource)
+  if (resource) rows.push({ label: '来源链接', value: /^https?:/i.test(resource) ? <a href={resource} target="_blank" rel="noreferrer">{resource}</a> : resource, code: true })
+  const generated = (frontmatter.generated ?? {}) as Record<string, unknown>
+  const at = text(generated.at)
+  if (at) rows.push({ label: '采集时间', value: formatDateTime(at) })
+  const first = Array.isArray(frontmatter.sources) ? (frontmatter.sources[0] as Record<string, unknown> | undefined) : undefined
+  const author = text(first?.author)
+  if (author) rows.push({ label: '作者 / 账号', value: author })
+  const lastModified = text(first?.last_modified)
+  if (lastModified) rows.push({ label: '来源更新时间', value: formatDateTime(lastModified) })
+  const description = text(frontmatter.description)
+  if (description) rows.push({ label: '摘要', value: description })
+  return rows
+}
+
+/**
+ * 分类声明的元数据字段 → 元信息行（0048）。
+ *
+ * 缺的字段**照样列出来**并写「缺」：那一行本身就是提示（「这类来源通常要带作者」），
+ * 藏起来等于让人自己去猜分类声明了什么。
+ */
+function declaredMetadataRows(fields: SourceMetadataField[] | undefined, frontmatter: Record<string, unknown>): PreviewRow[] {
+  if (!fields || fields.length === 0) return []
+  const valueAt = (key: string): string => {
+    let current: unknown = frontmatter
+    for (const part of key.split('.')) {
+      const name = part.replace(/\[\d+\]/g, '')
+      if (name) {
+        if (current === null || typeof current !== 'object') return ''
+        current = (current as Record<string, unknown>)[name]
+      }
+      for (const index of part.matchAll(/\[(\d+)\]/g)) {
+        current = Array.isArray(current) ? current[Number(index[1])] : undefined
+      }
+    }
+    return typeof current === 'string' ? current.trim() : current === undefined || current === null ? '' : String(current)
+  }
+  return fields.map(field => {
+    const value = valueAt(field.key)
+    return {
+      label: field.label,
+      value: value !== '' ? value : <span className={styles.kbHint}>缺{field.required === true ? '（这一类通常要带）' : ''}</span>,
+      ...(field.description ? { title: field.description } : {}),
+    } as PreviewRow
+  })
+}
+
 export interface KnowledgeCardView {
   entityId: string
   entityType: string
@@ -191,6 +307,26 @@ export interface KnowledgeCardView {
   sourceRefs: string[]
   metadata?: Record<string, unknown>
   updatedAt: string
+  /** 人工备注（0044）。正文之外的东西 —— 编译不碰它，也不进召回正文。 */
+  annotations?: Array<{ id: string; kind: 'note' | 'anomaly'; note: string; author?: string; createdAt?: string; sourceRef?: string }>
+  /** review 结论与评分（0044）。缺省 = 还没人看过。 */
+  review?: { state: 'unreviewed' | 'reviewed'; score: number; reviewedAt?: string; reviewedBy?: string }
+}
+
+/**
+ * 一张卡片的相关卡片（0049）：出链与入链。服务端按图上的关系边与「同一份来源」算好
+ * 之后给过来，界面只负责显示成可点的行 —— 客户端不解析正文里那块 `## 相关`。
+ */
+export interface CardRelatedView {
+  outgoing: CardRelatedEntry[]
+  incoming: CardRelatedEntry[]
+}
+
+export interface CardRelatedEntry {
+  entityId: string
+  entityType: string
+  title: string
+  reason: 'relation' | 'source'
 }
 
 /** 一张 wiki 卡片的历史版本快照。 */
@@ -205,25 +341,7 @@ export interface WikiCardVersionView {
   isCurrent: boolean
 }
 
-interface Envelope<T> { ok?: boolean; data?: T; warnings?: string[]; error?: { code?: string; message?: string; suggestion?: string } | null }
-
-async function requestJson<T>(url: string, init?: RequestInit): Promise<Envelope<T>> {
-  const response = await fetch(url, init)
-  const text = await response.text()
-  if (!text.trim()) throw new Error(`服务端返回空响应（HTTP ${response.status}）`)
-  let payload: Envelope<T>
-  try {
-    payload = JSON.parse(text) as Envelope<T>
-  } catch {
-    throw new Error(`服务端返回了无效响应（HTTP ${response.status}）`)
-  }
-  const error = payload.error
-  if (!response.ok || payload.ok === false) {
-    const detail = [error?.code, error?.message].filter(Boolean).join(' · ') || `请求失败（${response.status}）`
-    throw new Error(error?.suggestion ? `${detail} — ${error.suggestion}` : detail)
-  }
-  return payload
-}
+import { requestJson, type Envelope } from './request.ts'
 
 /** Text-ish formats the browser can read and POST as SourceRaw directly. */
 const DIRECT_READ_EXT = new Set(['.md', '.markdown', '.txt', '.json', '.tsv', '.csv', '.html'])
@@ -275,7 +393,22 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
   const [loading, setLoading] = useState(false)
   const [busy, setBusy] = useState<string | null>(null)
   const [notice, setNotice] = useState<{ tone: 'success' | 'error'; text: string } | null>(null)
-  const [tab, setTab] = useState<KnowledgeTab>('source-raw')
+  /**
+   * 分栏与选中的知识库。**起始值来自记住的位置**（`panel-state.ts`）：面板会被 DSH
+   * 重新挂载（刷新页面必然），只放在 `useState` 里的话，用户每次回来都落回
+   * 「SourceRaw + 默认知识库」。分栏存的是上一版的 id 时先对着 `KNOWLEDGE_TABS` 校验；
+   * 知识库 id 是服务端数据、没有注册表可校验，所以由 `loadBases` 用它自己的
+   * 「不存在就退回默认库」那条规则兜底。
+   */
+  const [tab, setTab] = useState<KnowledgeTab>(() => readRemembered('knowledgeTab', KNOWLEDGE_TABS.map(item => item.id)) ?? 'source-raw')
+  /**
+   * wiki 栏内部的二级 tab（0042）：卡片 / 抽取流程。
+   *
+   * **不记进 `panel-state.ts`**：那里记的是「上次看到哪儿」的三个大位置（一级 tab、
+   * 分栏、知识库），而这是某一栏内部的两种读法 —— 面板重新挂载时落回「卡片」
+   * （这一栏的第一件事）是正确的默认，而且不必为一个二级 tab 去改那个模块的 key 表。
+   */
+  const [wikiTab, setWikiTab] = useState<'cards' | 'flow'>('cards')
   const [editOpen, setEditOpen] = useState(false)
   const [draft, setDraft] = useState({ id: '', name: '', description: '' })
   /**
@@ -284,18 +417,39 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
    * 拉取，因为停用的分类要在提示词里标记出来。
    */
   const [catalog, setCatalog] = useState<SourceTypeCatalog | null>(null)
+
+  /**
+   * 换分栏的**唯一入口**：顺手记一笔，下次挂载落回同一栏。两个调用点（步骤轨点击、
+   * 从架构图节点跳过来）都走它，所以不会出现「这个入口记得、那个入口不记得」。
+   */
+  const changeTab = useCallback((next: KnowledgeTab): void => {
+    setTab(next)
+    remember('knowledgeTab', next)
+  }, [])
   /**
    * 「类型定义」抽屉（0034）：本库的词汇表 —— 来源分类 + Wiki 卡片 schema。
    * 弹窗草稿在抽屉内部，这里只留开关与写路径。
    */
-  const [typeDefOpen, setTypeDefOpen] = useState(false)
+  /**
+   * 类型定义抽屉的打开状态 + **该落在哪一节**。
+   *
+   * 两件事合成一个 state 是有意的：分开写时，「打开」与「看哪一节」会在两次渲染里生效，
+   * 抽屉先按默认节滚一次、再滚一次到目标节 —— 人看到的是闪一下。
+   */
+  const [typeDef, setTypeDef] = useState<{ open: boolean; section: TypeDefinitionSection }>({ open: false, section: 'source' })
   /** 上传 / 导入时用的来源分类；注册表变了要跟着回退，不能指向一个已停用的 id。 */
   const [uploadType, setUploadType] = useState('document')
   const [detail, setDetail] = useState<{ document: KnowledgeDocumentDetail; versions: DocumentVersion[] } | null>(null)
   const [detailLoading, setDetailLoading] = useState(false)
   const [restoreTarget, setRestoreTarget] = useState<VersionManagerEntry | null>(null)
   /** Wiki 卡片详情与版本（0025）。 */
-  const [cardDetail, setCardDetail] = useState<{ card: KnowledgeCardView; versions: WikiCardVersionView[] } | null>(null)
+  /**
+   * 卡片详情的三个部分：卡片本体、历史版本、图片素材。
+   *
+   * `assets` 是服务端把卡片正文里的图解析成的可加载 URL（0047）。少了它，预览抽屉里
+   * 卡片的图只能按 GUI 的地址去解析 `_assets/...`，全是 404。
+   */
+  const [cardDetail, setCardDetail] = useState<{ card: KnowledgeCardView; versions: WikiCardVersionView[]; assets: AssetRefView[]; related?: CardRelatedView } | null>(null)
   const [cardLoading, setCardLoading] = useState(false)
   const [cardRestore, setCardRestore] = useState<VersionManagerEntry | null>(null)
   const [graph, setGraph] = useState<{ nodes: GraphNodeView[]; edges: GraphEdgeView[] }>({ nodes: [], edges: [] })
@@ -349,7 +503,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
 
   /** 架构图节点跳转：落到对应分栏。 */
   useEffect(() => {
-    if (visible && focus) setTab(focus.tab)
+    if (visible && focus) changeTab(focus.tab)
   }, [visible, focus?.tab, focus?.nonce]) // eslint-disable-line react-hooks/exhaustive-deps
 
   /** `sourceId → wiki cards`, so a file row can say how many slices it produced. */
@@ -369,13 +523,16 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
   const loadBases = useCallback(async (preferred?: string): Promise<{ next: KnowledgeBase[]; resolved: string }> => {
     const payload = await requestJson<{ bases: KnowledgeBase[]; defaultBaseId: string }>('/knowledge/bases')
     const next = payload.data?.bases ?? []
-    const requested = preferred ?? activeIdRef.current
+    // 优先级：显式指定（新建 / 编辑后回到那一个）→ 本次挂载里已经选中的 → **记住的那个**。
+    // 最后一档就是「刷新之后还在原来那个库」，而它不合法时下面那句会退回默认库。
+    const requested = preferred ?? (activeIdRef.current !== '' ? activeIdRef.current : readRememberedId('knowledgeBase'))
     const resolved = next.some(base => base.id === requested)
       ? requested
       : payload.data?.defaultBaseId ?? next[0]?.id ?? ''
     setBases(next)
     setActiveId(resolved)
     activeIdRef.current = resolved
+    remember('knowledgeBase', resolved)
     return { next, resolved }
   }, [])
 
@@ -531,6 +688,9 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       description: draft.description.trim(),
       signals: draft.signals.split('\n').map(line => line.trim()).filter(Boolean),
       excludes: draft.excludes.split('\n').map(line => line.trim()).filter(Boolean),
+      // 元数据字段声明（0048）：与 signals / excludes 同一条约定 —— 「没传」不改动磁盘上
+      // 已有的声明，传了空数组才是清空。
+      ...(draft.metadataFields === undefined ? {} : { metadataFields: draft.metadataFields }),
     }
     const isNew = draft.mode === 'create'
     setBusy('source-type')
@@ -610,44 +770,6 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     }
   }
 
-  const patchWikiSchemaMode = async (mode: 'strict' | 'report'): Promise<void> => {
-    const base = active
-    if (!base) return
-    setBusy('wiki-mode')
-    try {
-      await requestJson(`/knowledge/bases/${encodeURIComponent(base.id)}`, {
-        method: 'PATCH',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ wikiSchemaMode: mode }),
-      })
-      await loadBases(base.id)
-      say('success', mode === 'strict' ? '已开启严格模式：缺必填小节 / 字段将拒绝写入' : '已切回 report 模式：只标记问题，不拦截写入')
-    } catch (error) {
-      say('error', error instanceof Error ? error.message : String(error))
-    } finally {
-      setBusy(null)
-    }
-  }
-
-  /** 清除 wiki 类型与模式上的用户层覆盖，回到出厂 11 个类型。 */
-  const resetWikiTypes = async (): Promise<void> => {
-    const base = active
-    if (!base) return
-    setBusy('wiki-types')
-    try {
-      await requestJson(`/knowledge/bases/${encodeURIComponent(base.id)}`, {
-        method: 'PATCH',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ resetWikiTypes: true }),
-      })
-      await loadBases(base.id)
-      say('success', '已恢复出厂 Wiki 类型')
-    } catch (error) {
-      say('error', error instanceof Error ? error.message : String(error))
-    } finally {
-      setBusy(null)
-    }
-  }
 
   const writeSource = async (title: string, content: string, externalId: string): Promise<void> => {
     const base = active
@@ -738,11 +860,18 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     // 的**原文状态重新满足 `open`，于是面板「自己又弹回来」——互斥必须两边都成立。
     setCardDetail(null)
     setDetailLoading(true)
-    setDetail({ document: { ...document, content: '', frontmatter: {}, assets: [] }, versions: [] })
+    setDetail({ document: { ...document, content: '', contentChars: 0, contentTruncated: false, frontmatter: {}, assets: [] }, versions: [] })
     try {
       const q = `?kb=${encodeURIComponent(baseId)}`
-      const docPayload = await requestJson<{ document: KnowledgeDocumentDetail }>(`/knowledge/documents/${encodeURIComponent(document.docId)}${q}`)
-      const versionPayload = await requestJson<{ versions: DocumentVersion[] }>(`/knowledge/documents/${encodeURIComponent(document.docId)}/versions${q}`)
+      /**
+       * 两条请求**并行**。原来是串行的（先详情、再版本），于是一次打开弹层的等待
+       * 是两段的和 —— 而它们之间没有任何依赖。详情返回之后弹层就能读，
+       * 版本时间线自己在 `detailLoading` 里补。
+       */
+      const [docPayload, versionPayload] = await Promise.all([
+        requestJson<{ document: KnowledgeDocumentDetail }>(`/knowledge/documents/${encodeURIComponent(document.docId)}${q}`),
+        requestJson<{ versions: DocumentVersion[] }>(`/knowledge/documents/${encodeURIComponent(document.docId)}/versions${q}`),
+      ])
       if (docPayload.data?.document) {
         setDetail({ document: docPayload.data.document, versions: versionPayload.data?.versions ?? [] })
       }
@@ -796,20 +925,41 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
 
   // ------------------------------------------------------------ Wiki 详情
 
-  /** 点开一张卡片：内容 + 版本历史。版本由服务端在每次正文变化前快照。 */
-  const openCard = async (card: KnowledgeCardView): Promise<void> => {
+  /**
+   * 点开一张卡片：内容 + 版本历史（版本由服务端在每次正文变化前快照）。
+   *
+   *
+   * 入参只要求 `entityId` + `entityType`：正文列表里有完整卡片对象，而「相关卡片」
+   * 那一列（0049）只知道对方的身份与标题 —— 详情随后由接口取回，占位对象只在取数
+   * 失败时用得上，所以它由这里就地补全，不要求每个调用方都造一份假的 KnowledgeCardView。
+   */
+  const openCard = async (card: Pick<KnowledgeCardView, 'entityId' | 'entityType'> & Partial<KnowledgeCardView>): Promise<void> => {
     const baseId = activeIdRef.current
     if (!baseId) return
     setDetail(null)
     setCardLoading(true)
-    setCardDetail({ card, versions: [] })
+    setCardDetail({
+      card: {
+        entityId: card.entityId, entityType: card.entityType, title: card.title ?? card.entityId,
+        status: card.status ?? 'unreviewed', content: card.content ?? '', sourceRefs: card.sourceRefs ?? [], updatedAt: card.updatedAt ?? '',
+      },
+      versions: [], assets: [],
+    })
     try {
       const q = `?kb=${encodeURIComponent(baseId)}&entity_type=${encodeURIComponent(card.entityType)}`
       const [detailPayload, versionPayload] = await Promise.all([
-        requestJson<{ card: KnowledgeCardView }>(`/knowledge/cards/${encodeURIComponent(card.entityId)}${q}`),
+        requestJson<{ card: KnowledgeCardView; assets?: AssetRefView[]; related?: CardRelatedView }>(`/knowledge/cards/${encodeURIComponent(card.entityId)}${q}`),
         requestJson<{ versions: WikiCardVersionView[] }>(`/knowledge/cards/${encodeURIComponent(card.entityId)}/versions${q}`),
       ])
-      setCardDetail({ card: detailPayload.data?.card ?? card, versions: versionPayload.data?.versions ?? [] })
+      setCardDetail(current => ({
+        card: detailPayload.data?.card ?? current?.card ?? {
+          entityId: card.entityId, entityType: card.entityType, title: card.title ?? card.entityId,
+          status: card.status ?? 'unreviewed', content: card.content ?? '', sourceRefs: card.sourceRefs ?? [], updatedAt: card.updatedAt ?? '',
+        },
+        versions: versionPayload.data?.versions ?? [],
+        assets: detailPayload.data?.assets ?? [],
+        ...(detailPayload.data?.related ? { related: detailPayload.data.related } : {}),
+      }))
     } catch (error) {
       setNotice({ tone: 'error', text: error instanceof Error ? error.message : String(error) })
       setCardDetail(null)
@@ -818,6 +968,33 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     }
   }
 
+  /**
+   * 抽屉里做完一次写（review / 备注）之后，把**这张卡片**和**卡片列表**都重新读一遍。
+   *
+   * 为什么不复用 `openCard`：它先把 `cardDetail` 清成 `{versions: []}` 再拉全量，
+   * 那会在人刚点完「review 通过」时把卡片正文闪成空的。这里只覆盖数据、保住抽屉
+   * 已经渲染出来的东西。
+   *
+   * 列表也必须刷：行上的「已 review / 异常点 N」徽标就是列表回答的那个问题。
+   */
+  const refreshCardAfterReview = async (): Promise<void> => {
+    const baseId = activeIdRef.current
+    const current = cardDetail
+    if (!baseId || !current) return
+    try {
+      const q = `?kb=${encodeURIComponent(baseId)}&entity_type=${encodeURIComponent(current.card.entityType)}`
+      const payload = await requestJson<{ card: KnowledgeCardView }>(`/knowledge/cards/${encodeURIComponent(current.card.entityId)}${q}`)
+      // 用函数式更新：人可能在这两次往返之间点了别的卡片，闭包里的 `current` 已经不是
+      // 抽屉里现在那一张了。
+      setCardDetail(previous => previous && previous.card.entityId === current.card.entityId
+        ? { ...previous, card: payload.data?.card ?? previous.card }
+        : previous)
+    } catch (error) {
+      setNotice({ tone: 'error', text: error instanceof Error ? error.message : String(error) })
+    }
+    void loadCards(baseId)
+  }
+
   const revertCard = async (): Promise<void> => {
     const target = cardRestore
     const current = cardDetail
@@ -917,14 +1094,38 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       .map(([ext, count]) => ({ value: ext, label: `${ext}（${count}）` }))
   }, [documents])
   /**
-   * `/knowledge/stats` 在这里是 `Record<string, unknown>`（它同时承载编译设置快照），
-   * 所以 `lastBuild` 要显式收窄一次再读 —— 否则每个字段都得写一遍类型断言。
+   * 一次性迁移里没有静默处理掉的事（来源分类改名冲突、卡片改名迁移失败）。
+   *
+   * 它必须显示出来：**迁移失败而没人知道，等价于数据已经丢了**。放在卡片列表上方，
+   * 因为它比「库里有什么」更紧急。
    */
-  const lastBuild = (stats.lastBuild ?? {}) as Record<string, unknown>
+  const migrationProblems = Array.isArray(stats.migrationProblems) ? stats.migrationProblems as string[] : []
   const currentVersionId = detail?.versions.find(version => version.isCurrent)?.versionId
   const currentCardVersionId = cardDetail?.versions.find(version => version.isCurrent)?.versionId
   const detailCards = detail ? cardsBySource.get(detail.document.docId) ?? [] : []
   const pendingCards = cards.filter(card => schemaIssuesOf(card).length > 0)
+  /**
+   * 需要人看一眼的卡片数：**没人看过**，或者**被标了异常点**（0044）。
+   *
+   * 0044 之前这里是一整块待办区，逐条列出正文与动作。现在 review 长在卡片预览里，
+   * 列表只需要回答「有几张要我动手」—— 具体是哪几张、缺什么、谁说过什么，点开就见。
+   */
+  const unreviewedCards = cards.filter(card =>
+    card.review?.state !== 'reviewed' || (card.annotations ?? []).some(item => item.kind === 'anomaly')).length
+
+  /**
+   * 在独立整页里读这份原文。
+   *
+   * 抽屉宽 380px，而原文可能是一份几十万字的转换文档 —— 那里只显示前 4000 字符
+   * （`SOURCE_PREVIEW_CHARS`），剩下的出口是这个整页：新标签、可整页搜索、自带分页，
+   * 一次只取一段。
+   */
+  const openFullDocument = useCallback((document: KnowledgeDocument): void => {
+    const kb = activeIdRef.current
+    if (!kb) return
+    const url = `/knowledge/documents/${encodeURIComponent(document.docId)}/view?kb=${encodeURIComponent(kb)}`
+    window.open(url, '_blank', 'noopener,noreferrer')
+  }, [])
 
   /**
    * 文件类型筛在客户端做（接口没有这个过滤口），其余两个筛选在服务端。
@@ -949,14 +1150,21 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
   /**
    * 步骤轨上每一步的真实事实。计数来自落盘与设置：`active` 的计数是服务端算的，
    * 图谱计数优先读 `/knowledge/stats`（它统计的是全量），拿不到才退回这一页拉到的前 50 条。
+   *
+   * 0042：wiki 这一步的 note 补上 wikiNotes 数、索引版本、增量指纹与卡片快照 ——
+   * 它们原来在「编译 wiki 与 wikiNotes」那张卡里，卡删掉之后这几条数得有地方去。
+   * 顺序按重要性排：窄栏下 note 会省略号截断，先看到的必须是更该看到的。
    */
   const stepFacts = useMemo(() => ({
     'source-raw': { value: active ? `${active.sourceCount} 个文件` : '—', note: '按格式路由解析，同 external_id 幂等' },
-    wiki: { value: active ? `${active.cardCount} 张卡片` : '—', note: '卡片 → wikiNotes，未变的逐字复用' },
+    wiki: {
+      value: active ? `${active.cardCount} 张卡片` : '—',
+      note: `${active?.noteCount ?? 0} 条 wikiNotes · 索引 v${active?.buildVersion ?? 0} · 指纹 ${String(stats.trackedCards ?? '—')} · 快照 ${String(stats.cardVersions ?? 0)}`,
+    },
     graph: { value: `${stats.graphNodes ?? graph.nodes.length} 节点 / ${stats.graphEdges ?? graph.edges.length} 边`, note: 'supported_by 溯源边 + relates_to 关系边' },
-    recall: { value: `topK ${String(knowledgeValue?.recallTopK ?? 10)}`, note: `${String(knowledgeValue?.recallMode ?? 'hybrid')} 三路融合` },
+    recall: { value: `topK ${String(knowledgeValue?.recallTopK ?? 10)}`, note: `${String(knowledgeValue?.recallMode ?? 'hybrid')} 关键词 + 向量融合` },
     rerank: { value: `topN ${String(knowledgeValue?.contextTopN ?? 5)}`, note: 'BERT cross-encoder 精排' },
-  }), [active, stats.graphNodes, stats.graphEdges, graph.nodes.length, graph.edges.length, knowledgeValue?.recallTopK, knowledgeValue?.recallMode, knowledgeValue?.contextTopN])
+  }), [active, stats.graphNodes, stats.graphEdges, stats.trackedCards, stats.cardVersions, graph.nodes.length, graph.edges.length, knowledgeValue?.recallTopK, knowledgeValue?.recallMode, knowledgeValue?.contextTopN])
 
   // --------------------------------------------------------------- 分栏内容
 
@@ -1056,9 +1264,40 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         这里不再留任何指路文字：工具栏与卡片头各自带着入口，路牌只是搬迁留下的债。 */}
   </div>
 
-  /** Wiki：卡片列表（一等内容）+ 编译 + 抽取流程 + schema 注册表。 */
+  /**
+   * Wiki：**两种内容，两枚 tab**（0042）。
+   *
+   * 0042 之前这里是三块竖排：卡片列表 → 「编译 wiki 与 wikiNotes」→ 抽取流程。
+   * 中间那一块同时讲动作（增量 / 全量按钮）与结果（8 行计数）—— 动作是「对这个库
+   * 做什么」，归工具栏；结果是「这一段现在有多少东西」，归步骤轨。把它留在这里，
+   * 等于让一栏内容替工具栏收着一枚按钮，还占掉一屏。
+   *
+   * **review 不进这一栏**（0044 第二次改）：它第一版在这里插了一块「入库后的 review」
+   * 待办区，按卡片逐条列出正文、校验与动作。那等于把同一张卡片摊在两个地方，而人点开
+   * 卡片看内容的那一刻，正是他要判断这张卡对不对的那一刻。现在它长在卡片预览抽屉里
+   * （`WikiCardReview`），列表只用行上的徽标回答「哪几张需要我看」。
+   */
   const renderWiki = (): ReactNode => <div className={styles.viewStack}>
-    {/* 卡片列表排在第一位，和 SourceRaw 的文件列表同一个位置、同一套筛选行 ——
+    {/* 迁移里没静默处理掉的事排在最前面：**迁移失败而没人知道，等价于数据已经丢了**。
+        它比「库里有什么」更紧急，所以不藏在统计里、也不只进日志。 */}
+    {migrationProblems.length > 0 && <p className={cn(styles.kbNotice, styles.kbNoticeError)} role="alert">
+      <AlertCircle size={13} />
+      <span>
+        <b>有 {migrationProblems.length} 处改名迁移没有生效</b>，旧文件都留在原地（没有覆盖、没有删除）：
+        {migrationProblems.join('；')}
+      </span>
+    </p>}
+    {/* Pass 0 的候选 / 建卡计数（`candidatesExtracted` / `cardsCreated` / `cardsUpdated`）
+        不在这一屏上显示。0042 撤掉的理由仍然成立：这三个数**没有指向任何可动手的东西** ——
+        「上一轮抽出 0 个候选」既不是待办，也不是这一栏的内容。数字本身还在
+        build-manifest 里，排查编译问题时从产物读，不占这一屏。 */}
+    <Tabs className={styles.kbSubTabs} value={wikiTab} onValueChange={next => setWikiTab(next as 'cards' | 'flow')}>
+      <TabsList className={cn(styles.tabsList, styles.kbSubTabsList)}>
+        <TabsTrigger value="cards"><FileText size={12} />卡片</TabsTrigger>
+        <TabsTrigger value="flow"><Layers3 size={12} />抽取流程</TabsTrigger>
+      </TabsList>
+      <TabsContent value="cards">
+    {/* 卡片列表和 SourceRaw 的文件列表同一个位置、同一套筛选行 ——
         两栏的「这一层有什么」都应该是打开就能看到的第一件东西。0027 之前这里
         先是一张编译统计卡，卡片列表在第三位，得先读过参数才看得到内容。 */}
     <Card className={styles.kbCard}>
@@ -1092,62 +1331,50 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         />
         <Button variant="ghost" size="icon" title="刷新" aria-label="刷新卡片列表" onClick={() => void loadCards(activeIdRef.current)}><RefreshCw size={14} /></Button>
       </div>
-      {pendingCards.length > 0 && <p className={styles.kbFilterHint}>有 <b>{pendingCards.length}</b> 张卡片缺必填小节 / 字段（report 模式只标记不拦截）。筛「待补」请用状态筛选，或在工具栏「类型定义」里切换生效方式。</p>}
+      {/* 两件事分开说：**「有没有人看过」和「卡片填完没有」不是一回事**。
+          合成一句「有 N 张有问题」，人既不知道要不要动手，也不知道动手做什么。 */}
+      {(unreviewedCards > 0 || pendingCards.length > 0) && <p className={styles.kbFilterHint}>
+        {unreviewedCards > 0 && <>有 <b>{unreviewedCards}</b> 张还没人看过或带着异常点 —— 点开任意一张卡片，review 与备注在它的预览侧栏里。</>}
+        {unreviewedCards > 0 && pendingCards.length > 0 && ' '}
+        {pendingCards.length > 0 && <>另有 <b>{pendingCards.length}</b> 张缺必填小节 / 字段。这不是错误：缺信息也入库，后面有涉及到的文档会补上。</>}
+      </p>}
       {visibleCards.length === 0 && <p className={styles.kbEmpty}>
         {cards.length > 0
           ? '当前筛选没有命中的卡片。清掉筛选条件就能看到这个知识库的全部卡片。'
-          : <>还没有卡片。先「增量编译」（Pass 0 会从正文标题、<b>[[链接]]</b> 与 frontmatter 抽候选），或让 Agent 用 <b>write_knowledge_card</b> 写入 —— 写入前会按 wiki 类型的 schema 校验。</>}
+          : <>还没有卡片。先录入一份来源（或上传文件），再点「编译」—— 编译器会按 wiki 类型的 schema 抽出实体并直接入库；缺信息也照进，后面有涉及到的文档会慢慢补上。</>}
       </p>}
       <ul className={styles.cardList}>
         {visibleCards.map(card => {
           const issues = schemaIssuesOf(card)
-          // Pass 0 抽出来的卡片是**机器猜的**，与 Agent 写入的卡片必须能一眼分开：
-          // 前者的状态永远是 unreviewed，但「没审核」和「是抽出来的」是两件事。
-          const extracted = card.metadata?.extraction === 'pass0'
+          // 编译期抽出来的卡片是**机器写的**，与 Agent 直接写入的必须能一眼分开：
+          // 两者的状态都可能是 unreviewed，但「没人看过」和「是抽出来的」是两件事。
+          const extracted = card.metadata?.extraction === 'pass0' || card.metadata?.extraction === 'model'
+          // 异常点是这张卡片**已经被指出有问题**：它照样召回得到（评分被压低），
+          // 但列表里必须显眼 —— 看不见的异常点等于没有异常点。
+          const anomalies = (card.annotations ?? []).filter(item => item.kind === 'anomaly').length
           return <li key={card.entityId} className={styles.cardRow}>
             <button type="button" className={styles.cardRowMain} onClick={() => void openCard(card)}>
-              <div className={styles.cardRowHead}>
+              {/* 一行一条：状态 + 标题 + 两枚状态徽标 +（右侧）类型与时间。
+                  0042 撤掉了摘要行与「类型 · id · 出处」行 —— 三行内容让每一张卡片都
+                  长成一个框，一屏三张卡就是三个框。扫一眼只需要认出「是哪一张」，
+                  摘要、entity_id、出处数都进抽屉（title 里挂 id 与出处数）。 */}
+              <span className={styles.cardRowHead}>
                 <Badge tone={card.status === 'active' || card.status === 'reviewed' ? 'success' : card.status === 'problem' ? 'warning' : 'neutral'}>{card.status}</Badge>
-                <span className={styles.cardRowTitle} title={card.entityId}>{card.title}</span>
-                {extracted && <Badge tone="blue">候选</Badge>}
+                <span className={styles.cardRowTitle} title={`${card.entityId} · ${card.sourceRefs.length} 个出处`}>{card.title}</span>
+                {extracted && <Badge tone="blue">编译产出</Badge>}
+                {card.review?.state === 'reviewed' && <Badge tone="success">已 review</Badge>}
+                {anomalies > 0 && <Badge tone="warning">异常点 {anomalies}</Badge>}
                 {issues.length > 0 && <Badge tone="warning">待补 {issues.length}</Badge>}
-                <span className={styles.kbTypeCount}>{formatTime(card.updatedAt)}</span>
-              </div>
-              <p className={styles.cardRowText}>{card.summary || card.content.replace(/!\[[^\]]*\]\([^)]*\)/g, ' ').replace(/\s+/g, ' ').slice(0, 160) || '（空卡片）'}</p>
-              <span className={styles.kbCode}>{card.entityType} · {card.entityId} · {card.sourceRefs.length} 个出处</span>
+                <span className={styles.kbTypeCount}>{card.entityType} · {formatTime(card.updatedAt)}</span>
+              </span>
             </button>
           </li>
         })}
       </ul>
     </Card>
-
-    <Card className={styles.kbCard}>
-      <div className={styles.kbCardHead}>
-        <div><h3><Layers3 size={13} />编译 wiki 与 wikiNotes</h3></div>
-        <div className={styles.kbCardActions}>
-          <Button variant="outline" size="sm" onClick={() => void rebuild('wiki')} disabled={busy !== null}><RefreshCw size={13} />{busy === 'compile' ? '编译中…' : '增量编译'}</Button>
-          <Button variant="ghost" size="sm" onClick={() => void rebuild('all')} disabled={busy !== null}>全量重编</Button>
-        </div>
-      </div>
-      <p className={styles.kbHint}>
-        <b>增量</b>：只有正文 / 标题 / 状态 / 出处变过的卡片会重新切分成 wikiNotes，其余卡片的召回单元**逐字复用**（unitId 不变，向量也不重编码）。
-        语料完全没变时这一次编译是**空操作**：不写产物、不升版本，因为升版本会让整份向量缓存作废。
-      </p>
-      <div className={styles.infoList}>
-        <div><span>wiki 卡片</span><strong>{active?.cardCount ?? 0}</strong></div>
-        <div><span>wikiNotes</span><strong>{active?.noteCount ?? 0}</strong></div>
-        <div><span>已纳入增量指纹</span><strong>{String(stats.trackedCards ?? '—')}</strong></div>
-        <div><span>卡片版本快照</span><strong>{String(stats.cardVersions ?? 0)}</strong></div>
-        <div><span>索引版本</span><strong>v{active?.buildVersion ?? 0}</strong></div>
-        <div><span>待补 schema 的卡片</span><strong>{pendingCards.length}</strong></div>
-        {/* Pass 0 的四个诚实计数：抽了几个候选、拒了几个、建了几张、并进几张。
-            它们来自上一轮编译的 build-manifest，不是估算。 */}
-        <div><span>上一轮抽出候选</span><strong>{String(lastBuild.candidatesExtracted ?? '—')}</strong></div>
-        <div><span>新建 / 合并卡片</span><strong>{stats.lastBuild ? `${lastBuild.cardsCreated ?? 0} / ${lastBuild.cardsMerged ?? 0}` : '—'}</strong></div>
-      </div>
-    </Card>
-
-    <WikiFlowCard />
+      </TabsContent>
+      <TabsContent value="flow"><WikiFlowCard /></TabsContent>
+    </Tabs>
 
     {/* **Wiki 类型**（卡片 schema）也不在这一栏了（0034）：它和来源类型是同一类东西
         —— 按库持久化的词汇表，一个决定「一份文件以什么业务身份进来」，一个决定「一张
@@ -1208,6 +1435,8 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         <SettingsChip target="context" onOpen={onOpenSettings} />
       </> } : {})}
       resetKey={`${active?.id ?? ''}:${String(knowledgeValue?.recallTopK ?? '')}:${String(knowledgeValue?.recallMode ?? '')}:${String(knowledgeValue?.contextTopN ?? '')}`}
+      /* 召回结果里的卡片点得开：抽屉是**宿主的**，面板只负责喊一声（它不认识抽屉）。 */
+      onOpenWiki={card => { void openCard(card) }}
       defaults={{
         ...(typeof knowledgeValue?.recallMode === 'string' ? { mode: knowledgeValue.recallMode } : {}),
         ...(typeof knowledgeValue?.recallTopK === 'number' ? { topK: knowledgeValue.recallTopK } : {}),
@@ -1247,16 +1476,42 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       />
       {/* 三个动作同形：图标 + 文字的 outline 按钮，同一个 30px 高。内核控制台是一个
           **链接**，所以它走 `Button asChild` 拿到同一套外观 —— 早先它是一枚裸的
-          `.tita-uiButton` 锚点，在这两枚按钮旁边读起来像第三种控件。 */}
+          `.tita-uiButton` 锚点，在这两枚按钮旁边读起来像第三种控件。
+          0042：「编译」原本在 wiki 栏的统计卡里（增量 + 全量两枚），现在它是**工具栏的
+          一个动作**，两档收进同一枚按钮的下拉里 —— 编译是「对这个库做什么」，
+          它和「选哪个库」「类型定义」同层，不属于任何一栏的内容。 */}
       <span className={styles.kbToolbarActions}>
         <Button
           variant="outline"
           size="sm"
           disabled={!active}
           title={active ? `编辑 ${active.name} 的来源类型与 Wiki 类型` : '先选择一个知识库'}
-          onClick={() => setTypeDefOpen(true)}
+          onClick={() => setTypeDef({ open: true, section: 'source' })}
         ><Tags size={13} />类型定义</Button>
-        <Button variant="outline" size="sm" onClick={() => void rebuild('wiki')} disabled={busy !== null || !active}><RefreshCw size={14} />{busy === 'compile' ? '编译中…' : '编译'}</Button>
+        <DropdownMenu>
+          <DropdownMenuTrigger asChild>
+            <Button variant="outline" size="sm" disabled={busy !== null || !active}>
+              <RefreshCw size={14} />{busy === 'compile' ? '编译中…' : '编译'}<ChevronDown size={12} />
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end" className={styles.kbCompileMenu}>
+            {/* 每一项是「名字 + 一行说明」两层，不是一句长句子。
+                共享组件的菜单默认把宽度锁成触发器的宽度（`编译 ⌄` 只有 90px 上下），
+                长句子进去就是一根 8 个字一行的竖条 —— 宽度由 CSS 纠正，句子由这里拆短。 */}
+            <DropdownMenuItem onSelect={() => void rebuild('wiki')}>
+              <span className={styles.kbCompileItem}>
+                <b>增量编译</b>
+                <small>只重切变过的卡片，其余 wikiNotes 逐字复用</small>
+              </span>
+            </DropdownMenuItem>
+            <DropdownMenuItem onSelect={() => void rebuild('all')}>
+              <span className={styles.kbCompileItem}>
+                <b>全量重编</b>
+                <small>全部重切，并把索引版本加一</small>
+              </span>
+            </DropdownMenuItem>
+          </DropdownMenuContent>
+        </DropdownMenu>
         <Button variant="outline" size="sm" asChild>
           <a href="/convert/" target="_blank" rel="noreferrer" title="打开解析内核控制台"><FileUp size={14} />解析内核</a>
         </Button>
@@ -1265,7 +1520,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
 
     {/* 分栏是**一条流水线**，所以切换器是步骤轨而不是一排等宽 tab：收录 → 编译 →
         关联 → 检索 → 精排。方向本身就是信息（写入侧在左、读取侧在右）。 */}
-    <KnowledgeStepRail tab={tab} onChange={setTab} facts={stepFacts} />
+    <KnowledgeStepRail tab={tab} onChange={changeTab} facts={stepFacts} />
 
     {notice && <p className={cn(styles.kbNotice, notice.tone === 'error' && styles.kbNoticeError)} role="status">
       <AlertCircle size={13} /><span>{notice.text}</span>
@@ -1291,13 +1546,12 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       {editOpen && <DialogContent>
         <DialogHeader><DialogTitle>{draft.id ? '编辑知识库' : '新建知识库'}</DialogTitle></DialogHeader>
         <div className={styles.kbForm}>
-          <label className={styles.kbField}><Label>名称</Label>
+          <Field label="名称">
             <Input value={draft.name} onChange={(event: ChangeEvent<HTMLInputElement>) => setDraft({ ...draft, name: event.target.value })} placeholder="例如：产品文档" />
-          </label>
-          <label className={styles.kbField}><Label>描述</Label>
+          </Field>
+          <Field label="描述" hint="每个知识库有自己的根目录、来源分类与 Wiki 类型注册表；默认知识库沿用现有的知识库根目录。">
             <Input value={draft.description} onChange={(event: ChangeEvent<HTMLInputElement>) => setDraft({ ...draft, description: event.target.value })} placeholder="这个知识库放什么" />
-          </label>
-          <p className={styles.kbHint}>每个知识库有自己的根目录、来源分类与 Wiki 类型注册表；默认知识库沿用现有的知识库根目录。</p>
+          </Field>
         </div>
         <DialogFooter>
           <Button variant="ghost" onClick={() => setEditOpen(false)}>取消</Button>
@@ -1310,13 +1564,13 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         它**不是**设置抽屉里的第七块 —— 那两个注册表按库持久化，而设置是整个方案一份。
         弹窗状态在这个组件内部；写路径仍走上面那几个 `patch*` / `saveSourceType`。 */}
     {active && <TypeDefinitionDrawer
-      open={typeDefOpen}
-      onOpenChange={setTypeDefOpen}
+      open={typeDef.open}
+      onOpenChange={open => setTypeDef(current => ({ ...current, open }))}
+      section={typeDef.section}
       kbId={active.id}
       kbName={active.name}
       sourceTypes={active.sourceTypes ?? []}
       wikiTypes={active.wikiTypes ?? []}
-      schemaMode={active.wikiSchemaMode ?? 'report'}
       customized={active.wikiTypesCustomized === true}
       catalog={catalog}
       busy={busy}
@@ -1324,8 +1578,6 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       onToggleSourceType={toggleSourceType}
       onRemoveSourceType={removeSourceType}
       onApplyWikiTypes={patchWikiTypes}
-      onModeChange={patchWikiSchemaMode}
-      onResetWikiTypes={resetWikiTypes}
     />}
 
     <RestoreDialog
@@ -1355,34 +1607,70 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         一个 state —— 「同时开两个」在这里变成不可表达的状态。 */}
     <Drawer open={detail !== null && cardDetail === null} onOpenChange={next => { if (!next) setDetail(null) }}>
       {detail && <DrawerContent className={styles.drawer} resizable resizeKey="tita-source-preview">
+        {/* 抽屉头：标题 + 一行「它是什么」。
+            0042 把「新页面打开」搬进头里，是为了让它位置固定、不随正文是否被截断而出现；
+            0049 又把它挪到「内容」小节头那一行 —— 用户的原话是「放到内容旁边」。
+            它确实是「读这份内容的另一个去处」，与「内容」同处一行比挂在抽屉头更贴近它
+            服务的那件事；而显隐仍然固定（不依赖正文长度），0042 那条约束没有被破坏。 */}
         <DrawerHeader>
-          <DrawerTitle>{detail.document.title}</DrawerTitle>
-          <DrawerDescription>{detail.document.relativePath}</DrawerDescription>
+          <div className={styles.drawerHead}>
+            <div className={styles.drawerHeadCopy}>
+              <DrawerTitle>{detail.document.title}</DrawerTitle>
+              <DrawerDescription>{detail.document.relativePath}</DrawerDescription>
+            </div>
+          </div>
         </DrawerHeader>
         <DrawerBody className={styles.drawerStack}>
           {/* 0035：两种预览是**同一套分块**（元信息 → 内容 → 版本），SourceRaw 只多一块
-              「编译产物」。顺序不是随手排的：先确认「这是什么」（元信息，含 hash 与分类），
+              「编译产物」。顺序不是随手排的：先确认「这是什么」（元信息，含分类与来源），
               再读「它写了什么」（内容），再看「它编译出了什么」（派生结论），最后才是
               「改过几次」（版本）。0030 那条「原文在编译产物之前」在这里仍然成立。
-              时间一律用标准格式（`formatDateTime`）—— 抽屉里是逐字核对事实的地方。 */}
+              时间一律用标准格式（`formatDateTime`）—— 抽屉里是逐字核对事实的地方。
+
+              0049 按 **front matter 的键**重排了这一块，并撤掉纯技术项：
+              - 行与键对得上（分类 = `type`，来源链接 = `resource`，作者 = `sources[0].author`，
+                采集时间 = `generated.at`…），人读界面与读文件是同一件事；
+              - `external_id`（业务系统里的 id）、`content_hash`（内容指纹）、`解析器`
+                （`anydoc@0.2.4/pptx` 这种版本串）都不占一行 —— 它们是排查用的，
+                不是「这份东西是什么」。前两项在文件里、在版本列表里都查得到；
+                解析器与生成者收进「文件格式」那一行的悬停说明。 */}
           <PreviewMeta rows={[
-            { label: '类型', value: `${detail.document.ext} · ${detail.document.sourceFormat || 'unknown'}` },
-            { label: '解析器', value: detail.document.parser || '—' },
             { label: '来源分类', value: `${sourceTypeLabel(detail.document.sourceType)} · ${detail.document.sourceType}` },
-            { label: 'external_id', value: detail.document.externalId || '—', code: true },
-            { label: 'content_hash', value: detail.document.contentHash || '—', code: true },
+            {
+              label: '文件格式',
+              value: `${sourceFormatLabel(detail.document.sourceFormat)} · ${detail.document.ext}`,
+              title: [
+                detail.document.parser ? `解析器 ${detail.document.parser}` : '',
+                generatorOf(detail.document.frontmatter),
+              ].filter(Boolean).join(' · '),
+            },
+            // 0048：OKF 的那几个顶层键（链接、作者、发布时间、采集时间）就排在分类下面
+            // —— 它们是「这份东西是什么」的一部分，不该埋进 metadata 里让人去翻 JSON。
+            ...sourceProvenanceRows(detail.document.frontmatter),
             { label: '大小', value: formatBytes(detail.document.bytes) },
             { label: '创建', value: formatDateTime(detail.document.createdAt) },
             { label: '更新', value: formatDateTime(detail.document.updatedAt) },
+            // 分类声明的元数据字段：有的显示值，缺的显示「缺」——「缺」本身就是信息，
+            // 而且它指得出该去补什么。
+            ...declaredMetadataRows(active?.sourceTypes.find(def => def.id === detail.document.sourceType)?.metadataFields, detail.document.frontmatter),
           ]} />
 
-          <PreviewContent content={detail.document.content} assets={detail.document.assets} />
+          <PreviewContent
+            content={detail.document.content}
+            assets={detail.document.assets}
+            totalChars={detail.document.contentChars}
+            action={<Button
+              variant="outline" size="sm" className={styles.drawerHeadAction}
+              title="在一个独立的整页里读完整原文（新标签页，可分页搜索）"
+              onClick={() => openFullDocument(detail.document)}
+            ><ExternalLink size={12} />新页面打开</Button>}
+          />
 
           <div className={styles.drawerSection}>
           {/* WeKnora 的详情页在文件下面列分块；这里列的是这个 SourceRaw 编译出的 wiki 卡片。 */}
           <div className={styles.kbSubHead}><h4><Layers3 size={13} />编译产物</h4><span>{detailCards.length} 张卡片</span></div>
           {detailCards.length === 0
-            ? <p className={styles.kbHint}>还没有从这个文件编译出 wiki 卡片。先「编译」，或在概览里让 Agent 用 <b>write_knowledge_card</b> 引用它。</p>
+            ? <p className={styles.kbHint}>还没有从这个文件编译出 wiki 卡片。先「编译」—— 编译器会按 wiki 类型的 schema 抽出实体并直接入库。</p>
             : <ul className={styles.cardList}>
               {detailCards.map(card => <li key={card.entityId} className={styles.cardRow}>
                 <button type="button" className={styles.cardRowMain} onClick={() => void openCard(card)}>
@@ -1427,15 +1715,27 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
             { label: '出处', value: cardDetail.card.sourceRefs.join(', ') || '—', code: true },
           ]} />
 
-          {/* schema 待补紧跟在元信息后面：它是对「状态」那一行的展开，不是正文的一部分。 */}
-          {schemaIssuesOf(cardDetail.card).length > 0 && <details className={styles.kbPrompt} open>
-            <summary><ShieldCheck size={12} /> schema 待补 {schemaIssuesOf(cardDetail.card).length} 项（report 模式：只标记不拦截）</summary>
-            <ul className={styles.kbPromptSteps}>
-              {schemaIssuesOf(cardDetail.card).map((issue, index) => <li key={`${issue.message ?? index}`}><code>{issue.level ?? 'warning'}</code> {issue.message}</li>)}
-            </ul>
-          </details>}
+          {/* review 与备注排在元信息之后、正文之前（0044）。
+              位置的理由：它是**人对这张卡做的判断**，与元信息同属「这张卡是什么」，
+              而正文是要读的东西，可能很长。放在正文下面，人得先滚过全文才够得着按钮；
+              放在正文上面，点开就能看见它现在是什么状态、别人说过什么。 */}
+          <WikiCardReview
+            kbId={activeId}
+            card={cardDetail.card}
+            onChanged={() => void refreshCardAfterReview()}
+            /* 从卡片进来是奔着 Wiki 类型去的：让抽屉直接落在那一节，不用人再滚一遍。 */
+            onOpenWikiTypes={() => { setCardDetail(null); setTypeDef({ open: true, section: 'wiki' }) }}
+          />
+
+          <PreviewContent content={cardDetail.card.content} assets={cardDetail.assets} />
 
-          <PreviewContent content={cardDetail.card.content} />
+          {/* 相关卡片排在正文之后（0049）：读完这张卡片，接着看它跟谁有关。放在正文
+              之前会挡住「这张卡片到底说了什么」，而相关是读完之后才想做的事。 */}
+          <PreviewRelated
+            outgoing={cardDetail.related?.outgoing ?? []}
+            incoming={cardDetail.related?.incoming ?? []}
+            onOpen={link => void openCard(link)}
+          />
 
           <PreviewVersions
             hint="卡片正文每次变化前都会留一份快照；回滚是往前的写入，所以回滚前的那一版也会被快照 —— 回滚本身也可以回滚。"