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

package/src/client/KnowledgeBaseTab.tsx

@@ -15,8 +15,10 @@
  *    那一个设置抽屉，只是落到对应的分块上。
  * 2. **设置抽屉装方案级参数**（存储 / 收录闸门 / 构建 / 召回 / 重排 / 追加行为规则）：
  *    一个 namespace，整个方案一份。
- * 3. **编译设置抽屉装本库坐标实体**：按知识库持久化，切库就换一套。
- *    它与设置是**两种作用域**，所以是两个容器而不是一个 —— 见 `TypeDefinitionDrawer.tsx`。
+ * 3. **编译设置是知识处理整页里的一个视图**：按知识库持久化，切库就换一套。
+ *    它与面板顶部的方案级设置是**两种作用域**，所以是两个容器而不是一个 ——
+ *    见 `CompileSettingsView.tsx`。2026-10-28 前它是工具栏上的一只抽屉；
+ *    搬进整页的理由是它改的参数**紧挨着**要用它们的那几段。
  *
  * 产品逻辑参考腾讯 WeKnora：知识库是一等对象（独立配置、独立内容）。每个知识库有自己的
  * 根目录与知识矩阵实体注册表；知识库下有文件列表，每个文件有详情页与版本
@@ -35,8 +37,8 @@
 
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, type ChangeEvent, type ReactNode } from 'react'
 import {
-  AlertCircle, Check, ChevronDown, Eye, ExternalLink, FileText, FileUp, FolderOpen,
-  Layers3, RefreshCw, Sparkles, Tags, Trash2, TriangleAlert, Upload, X,
+  AlertCircle, Check, ChevronDown, Eye, ExternalLink, FileText, FolderOpen,
+  Layers3, RefreshCw, Sparkles, Trash2, TriangleAlert, Upload, X,
 } from '@tita-agent/ui/icons'
 import type { LucideIcon } from '@tita-agent/ui/icons'
 import {
@@ -44,7 +46,7 @@ import {
 } from '@tita-agent/ui/components'
 import {
   Dialog, DialogContent, DialogHeader, DialogTitle, Drawer, DrawerBody, DrawerContent, DrawerDescription, DrawerHeader, DrawerTitle,
-  openAppPath, useFullPage,
+  useFullPage,
 } from '@tita-agent/ui/overlays'
 import { RestoreDialog, type VersionManagerEntry } from '@tita-agent/ui/versions'
 import { readRemembered, readRememberedId, remember } from './panel-state.ts'
@@ -77,7 +79,7 @@ import { WikiCardPreview } from './WikiCardPreview.tsx'
 import { ListPager, PAGE_SIZE, pageSlice, usePage } from './ListPager.tsx'
 import { COMPILE_STEP_TITLE, CompileConfirmDialog, CompileProgressDialog, type CompileProgressView } from './CompileDialogs.tsx'
 import { ImportFilesDialog, type ImportItemView, type ImportStage } from './ImportFilesDialog.tsx'
-import { TypeDefinitionDrawer, type CompileModelSelectionView } from './TypeDefinitionDrawer.tsx'
+import { newSourceId } from '../source-identity.ts'
 import { DeleteDocumentDialog } from './DeleteDocumentDialog.tsx'
 import { InfoHint } from './InfoHint.tsx'
 import { PipelineNotice } from './PipelineNotice.tsx'
@@ -93,7 +95,6 @@ export interface KnowledgeBase {
   isDefault: boolean
   /** 这一库的坐标提取备注（0068）。逐字进每一次抽取的提示词。 */
   extractionNote?: string
-  compileModel?: CompileModelSelectionView
   createdAt: string
   updatedAt: string
   sourceCount: number
@@ -442,12 +443,16 @@ export interface KnowledgeCardView {
 interface CardMatrixResult {
   view: MatrixView
   sceneOnly: number
+  factCount: number
+  wayCount: number
+  unclassifiedCount: number
 }
 
 interface CardMatrixFilter {
   objectId?: string
   actionId?: string
   sceneId?: string
+  wikiKind?: 'fact' | 'way' | 'unclassified'
 }
 
 /**
@@ -458,18 +463,37 @@ interface CardMatrixFilter {
  * 不再新增一条服务端聚合接口，避免两份统计在编译刚结束时短暂不同步。
  */
 function cardMatrixOf(cards: readonly KnowledgeCardView[], lookup: AxisLookup): CardMatrixResult {
-  interface Bucket { object: string | null; action: string | null; scene: string | null; count: number }
+  interface Bucket { object: string | null; action: string | null; scene: string | null; count: number; factCount: number; wayCount: number; unclassifiedCount: number }
   const buckets = new Map<string, Bucket>()
   let noCoordinate = 0
   let sceneOnly = 0
-  const add = (coordinate: Bucket): void => {
+  let factCount = 0
+  let wayCount = 0
+  let unclassifiedCount = 0
+  const add = (coordinate: Omit<Bucket, 'count' | 'factCount' | 'wayCount' | 'unclassifiedCount'>, wikiKind: 'fact' | 'way' | 'unclassified'): void => {
     const key = JSON.stringify([coordinate.object, coordinate.action, coordinate.scene])
     const previous = buckets.get(key)
-    if (previous) previous.count += 1
-    else buckets.set(key, { ...coordinate, count: 1 })
+    if (previous) {
+      previous.count += 1
+      if (wikiKind === 'fact') previous.factCount += 1
+      else if (wikiKind === 'way') previous.wayCount += 1
+      else previous.unclassifiedCount += 1
+    } else buckets.set(key, {
+      ...coordinate,
+      count: 1,
+      factCount: wikiKind === 'fact' ? 1 : 0,
+      wayCount: wikiKind === 'way' ? 1 : 0,
+      unclassifiedCount: wikiKind === 'unclassified' ? 1 : 0,
+    })
   }
 
   for (const card of cards) {
+    const wikiKind = card.metadata?.wiki_kind === 'fact' || card.metadata?.wiki_kind === 'way'
+      ? card.metadata.wiki_kind
+      : 'unclassified'
+    if (wikiKind === 'fact') factCount += 1
+    else if (wikiKind === 'way') wayCount += 1
+    else unclassifiedCount += 1
     const coordinate = card.coordinate
     if (coordinate === undefined) { noCoordinate += 1; continue }
     const object = coordinate.objectId === '' ? null : lookup.nameOf('object', coordinate.objectId)
@@ -477,7 +501,7 @@ function cardMatrixOf(cards: readonly KnowledgeCardView[], lookup: AxisLookup):
     const scene = coordinate.sceneId === '' ? null : lookup.nameOf('scene', coordinate.sceneId)
     if (object === null && action === null && scene === null) { noCoordinate += 1; continue }
     if (object === null && action === null) { sceneOnly += 1; continue }
-    add({ object, action, scene, count: 1 })
+    add({ object, action, scene }, wikiKind)
   }
 
   const totals = (pick: (bucket: Bucket) => string | null): Map<string, number> => {
@@ -493,6 +517,11 @@ function cardMatrixOf(cards: readonly KnowledgeCardView[], lookup: AxisLookup):
     .map(([name]) => name)
   const objects = rank(totals(bucket => bucket.object))
   const actions = rank(totals(bucket => bucket.action))
+  const breakdownFor = (selected: readonly Bucket[]) => [
+    { id: 'fact', label: 'F', title: 'Wiki Fact', count: selected.reduce((sum, bucket) => sum + bucket.factCount, 0) },
+    { id: 'way', label: 'W', title: 'Wiki Way', count: selected.reduce((sum, bucket) => sum + bucket.wayCount, 0) },
+    { id: 'unclassified', label: '未', title: '未归类 Wiki', count: selected.reduce((sum, bucket) => sum + bucket.unclassifiedCount, 0) },
+  ].filter(item => item.count > 0)
   const groupsFor = (object: string | null, action: string | null) => [...buckets.values()]
     .filter(bucket => bucket.object === object && bucket.action === action)
     .sort((left, right) => (left.scene === null ? -1 : right.scene === null ? 1 : 0)
@@ -500,15 +529,19 @@ function cardMatrixOf(cards: readonly KnowledgeCardView[], lookup: AxisLookup):
     .map(bucket => ({ scene: bucket.scene ?? '', count: bucket.count }))
   const cells = objects.flatMap(object => actions.flatMap(action => {
     const groups = groupsFor(object, action)
-    return groups.length > 0 ? [{ object, action, groups }] : []
+    if (groups.length === 0) return []
+    const cellBuckets = [...buckets.values()].filter(bucket => bucket.object === object && bucket.action === action)
+    return [{ object, action, groups, breakdown: breakdownFor(cellBuckets) }]
   }))
   const noAction = objects.flatMap(object => {
     const groups = groupsFor(object, null)
-    return groups.length > 0 ? [{ name: object, groups }] : []
+    const looseBuckets = [...buckets.values()].filter(bucket => bucket.object === object && bucket.action === null)
+    return groups.length > 0 ? [{ name: object, groups, breakdown: breakdownFor(looseBuckets) }] : []
   })
   const noObject = actions.flatMap(action => {
     const groups = groupsFor(null, action)
-    return groups.length > 0 ? [{ name: action, groups }] : []
+    const looseBuckets = [...buckets.values()].filter(bucket => bucket.object === null && bucket.action === action)
+    return groups.length > 0 ? [{ name: action, groups, breakdown: breakdownFor(looseBuckets) }] : []
   })
 
   return {
@@ -519,6 +552,9 @@ function cardMatrixOf(cards: readonly KnowledgeCardView[], lookup: AxisLookup):
       unitLabel: '卡片',
     },
     sceneOnly,
+    factCount,
+    wayCount,
+    unclassifiedCount,
   }
 }
 
@@ -582,11 +618,11 @@ interface Props {
   onActiveBaseChange?: (base: { id: string; name: string } | null) => void
   /** 知识库设置作用域：召回 / 重排面板读它算默认参数，收录闸门读它决定能不能上传。 */
   knowledge?: SettingsScopeLike
-  /** 架构图节点跳转过来时要落到哪一栏。`nonce` 变化即重新应用。 */
-  focus?: { tab: KnowledgeTab; nonce: number }
+  /** 外部跳转落到哪一栏；可选 Wiki ID 会在目标栏加载后打开原卡片。`nonce` 变化即重新应用。 */
+  focus?: { tab: KnowledgeTab; nonce: number; wikiEntityId?: string; wikiEntityType?: string }
   /**
    * 卡片头的「参数」chip 落到设置抽屉的哪一块（0034）。**设置不在这一层** —— 这里只
-   * 转交一个「打开并定位」的意图，抽屉与它读写的 scope 都还在 `KnowledgePanel` 手里。
+   * 转交一个「打开并定位」的动作，抽屉与它读写的 scope 都还在 `KnowledgePanel` 手里。
    */
   onOpenSettings?: (target: SettingsNode) => void
 }
@@ -601,6 +637,8 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
   const [bases, setBases] = useState<KnowledgeBase[]>([])
   const [activeId, setActiveId] = useState('')
   const [documents, setDocuments] = useState<KnowledgeDocument[]>([])
+  /** Avoid opening a same-ID card from the previous base while a base switch is still loading. */
+  const [cardsBaseId, setCardsBaseId] = useState('')
   /**
    * 每份文档有几条抽取轨迹（0063）。它是**审计计数**，不是「这份文档是什么」，
    * 所以它不进 `KnowledgeDocument`，单独一张按 docId 查的表。
@@ -750,8 +788,6 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     changeTab('knowledge')
     setKnowledgeContent('event')
   }, [changeTab])
-  /** 编译设置抽屉：本库的编译模型、坐标实体与抽取备注。 */
-  const [typeDef, setTypeDef] = useState(false)
   const [detail, setDetail] = useState<{ document: KnowledgeDocumentDetail; versions: DocumentVersion[] } | null>(null)
   const [detailLoading, setDetailLoading] = useState(false)
   const [restoreTarget, setRestoreTarget] = useState<VersionManagerEntry | null>(null)
@@ -892,7 +928,11 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     try {
       const payload = await requestJson<{ cards: KnowledgeCardView[] }>(`/knowledge/cards?kb=${encodeURIComponent(baseId)}`)
       setCards(payload.data?.cards ?? [])
-    } catch { setCards([]) }
+      setCardsBaseId(baseId)
+    } catch {
+      setCards([])
+      setCardsBaseId(baseId)
+    }
   }, [])
 
   /**
@@ -1006,65 +1046,18 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
 
   // ----------------------------------------------------------------- actions
 
-  /**
-   * 保存坐标提取备注（0068）。
-   *
-   * 与知识矩阵实体**同一条写路径**（PATCH 那个库），因为它就住在同一个注册表里 ——
-   * 同一份数据不因为多了一个入口就多一个写入口。
-   */
-  const saveExtractionNote = async (note: string): Promise<void> => {
-    const base = active
-    if (!base) return
-    setBusy('extraction-note')
-    try {
-      await requestJson(`/knowledge/bases/${encodeURIComponent(base.id)}`, {
-        method: 'PATCH',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ extractionNote: note }),
-      })
-      await loadBases(base.id)
-      say('success', note.trim() === ''
-        ? '备注已清空 —— 下一次抽取不再带这段约定'
-        : `备注已保存（${note.trim().length} 字），下一次抽取会逐字带上它`)
-    } catch (error) {
-      say('error', error instanceof Error ? error.message : String(error))
-    } finally {
-      setBusy(null)
-    }
-  }
-
-  /** 保存本库的编译模型路由；配置落在知识库注册表，不复制 DSH 的模型目录。 */
-  const saveCompileModel = async (selection: CompileModelSelectionView): Promise<void> => {
-    const base = active
-    if (!base) return
-    setBusy('compile-model')
-    try {
-      await requestJson(`/knowledge/bases/${encodeURIComponent(base.id)}`, {
-        method: 'PATCH',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ compileModel: selection }),
-      })
-      await loadBases(base.id)
-      say('success', selection.mode === 'default' ? '编译模型已改为跟随 DSH 默认模型' : `编译模型已固定为 ${selection.provider} / ${selection.model}`)
-    } catch (error) {
-      say('error', error instanceof Error ? error.message : String(error))
-    } finally {
-      setBusy(null)
-    }
-  }
-
   /**
    * @returns 写入时那些**必须让人看见**的话（图片一张都没进来、标题重复…）。
    *   调用方把它挂到这个文件的 `note` 上：一份 40 张图的文档只上传了 `.md`，后果要到
    *   编译之后才在卡片里显形 —— 那时人已经不知道是哪一步丢的了。
    */
-  const writeSource = async (title: string, content: string, externalId: string): Promise<string[]> => {
+  const writeSource = async (title: string, content: string, sourceId: string): Promise<string[]> => {
     const base = active
     if (!base) throw new Error('请先选择一个知识库')
     const payload = await requestJson<{ assets?: { refs: number; missing: number } }>('/knowledge/sources', {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ kb: base.id, title, external_id: externalId, content }),
+      body: JSON.stringify({ kb: base.id, source_id: sourceId, title, external_id: `upload:${sourceId}`, content, allow_duplicate_title: true, metadata: { original_filename: title } }),
     })
     const assets = payload.data?.assets
     /*
@@ -1072,13 +1065,12 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
      * 长的那一句（服务端的 warning）留给处理日志与 Agent 那条路 —— 同一件事在两处的
      * 篇幅本来就该不同。
      */
-    return assets !== undefined && assets.missing > 0 && assets.missing === assets.refs
-      ? [`正文引用的 ${assets.refs} 张图片一张都没进库`]
-      : []
+    return [...(payload.warnings ?? []), ...(assets !== undefined && assets.missing > 0 && assets.missing === assets.refs
+      ? [`正文引用的 ${assets.refs} 张图片一张都没进库`] : [])]
   }
 
   /** Convert one file with the kernel, then ingest the delivery into the active base. */
-  const convertAndIngest = async (file: File, onNote?: (note: string) => void): Promise<string[]> => {
+  const convertAndIngest = async (file: File, sourceId: string, onNote?: (note: string) => void): Promise<string[]> => {
     const base = active
     if (!base) throw new Error('请先选择一个知识库')
     const form = new FormData()
@@ -1104,7 +1096,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     const ingested = await requestJson('/convert/api/ingest', {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ task_id: taskId, kb: base.id, title: file.name }),
+      body: JSON.stringify({ task_id: taskId, kb: base.id, title: file.name, source_id: sourceId, allow_duplicate_title: true }),
     })
     /*
      * 内核那条路的备注取自它的 warning：那一层已经会说出「N 个图片资产未复制」这类话，
@@ -1180,6 +1172,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     if (files.length === 0 || importRunning || busy === 'compile') return
     setImportItems(current => [...current, ...files.map(file => ({
       id: `import-${importSeq.current++}`,
+      sourceId: newSourceId(),
       file,
       name: file.name,
       ext: (file.name.slice(file.name.lastIndexOf('.') + 1) || '').toLowerCase(),
@@ -1237,14 +1230,10 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         let notes: string[] = []
         if (DIRECT_READ_EXT.has(ext)) {
           const content = await directReadText(item.file)
-          /*
-           * 文件名是浏览器直读上传的稳定身份。lastModified 只能描述这一次
-           * 选择文件的时间，不能进入 external_id；否则同一文件更新后会被当成新来源，
-           * 随后又被同标题校验拒绝，永远进不了版本链。
-           */
-          notes = await writeSource(item.name, content, `upload:${item.name}`)
+          // Queue identity is allocated before reading; filenames never select an existing source.
+          notes = await writeSource(item.name, content, item.sourceId)
         } else {
-          notes = await convertAndIngest(item.file, note => patchImportItem(item.id, { note }))
+          notes = await convertAndIngest(item.file, item.sourceId, note => patchImportItem(item.id, { note }))
         }
         const note = notes.length === 0 ? undefined : notes.join('；')
         patchImportItem(item.id, { stage: 'ingested', ...(note === undefined ? { note: undefined } : { note }) })
@@ -1630,6 +1619,19 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     }
   }
 
+  /** 智能归因中的召回条目可以跳回 Wiki，并在这里打开同一张卡片的原始预览。 */
+  const openedWikiFocusRef = useRef<string | null>(null)
+  useEffect(() => {
+    if (!visible || focus?.tab !== 'wiki' || !focus.wikiEntityId || !activeId || cardsBaseId !== activeId) return
+    const focusKey = `${focus.nonce}:${activeId}:${focus.wikiEntityId}`
+    if (openedWikiFocusRef.current === focusKey) return
+    const card = cards.find(item => item.entityId === focus.wikiEntityId
+      && (focus.wikiEntityType === undefined || item.entityType === focus.wikiEntityType))
+    if (!card) return
+    openedWikiFocusRef.current = focusKey
+    void openCard(card)
+  }, [visible, focus?.tab, focus?.nonce, focus?.wikiEntityId, focus?.wikiEntityType, activeId, cardsBaseId, cards])
+
   const compareCardVersion = async (entry: VersionManagerEntry): Promise<void> => {
     const baseId = activeIdRef.current
     const current = cardDetail
@@ -1964,6 +1966,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       const cell = {
         object: cardMatrixFilter.objectId === '' ? null : axisLookup.nameOf('object', cardMatrixFilter.objectId!),
         action: cardMatrixFilter.actionId === '' ? null : axisLookup.nameOf('action', cardMatrixFilter.actionId!),
+        ...(cardMatrixFilter.wikiKind ? { breakdownId: cardMatrixFilter.wikiKind } : {}),
       }
       return hasScene
         ? { cell, group: { ...cell, scene: cardMatrixFilter.sceneId === '' ? '' : axisLookup.nameOf('scene', cardMatrixFilter.sceneId!) } }
@@ -1987,6 +1990,20 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     const same = cardMatrixFilter.objectId === next.objectId
       && cardMatrixFilter.actionId === next.actionId
       && cardMatrixFilter.sceneId === undefined
+      && cardMatrixFilter.wikiKind === undefined
+    setCardMatrixFilter(same ? {} : next)
+  }
+  const pickCardBreakdown = (pick: MatrixCellPick, breakdownId: string): void => {
+    if (breakdownId !== 'fact' && breakdownId !== 'way' && breakdownId !== 'unclassified') return
+    const next: CardMatrixFilter = {
+      objectId: cardAxisId('object', pick.object),
+      actionId: cardAxisId('action', pick.action),
+      wikiKind: breakdownId,
+    }
+    const same = cardMatrixFilter.objectId === next.objectId
+      && cardMatrixFilter.actionId === next.actionId
+      && cardMatrixFilter.sceneId === undefined
+      && cardMatrixFilter.wikiKind === next.wikiKind
     setCardMatrixFilter(same ? {} : next)
   }
   const pickCardGroup = (pick: MatrixPick): void => {
@@ -1998,13 +2015,14 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     const same = cardMatrixFilter.objectId === next.objectId
       && cardMatrixFilter.actionId === next.actionId
       && cardMatrixFilter.sceneId === next.sceneId
+      && cardMatrixFilter.wikiKind === undefined
     setCardMatrixFilter(same ? {} : next)
   }
   const pickCardAxis = (pick: MatrixAxisPick): void => {
     const id = cardAxisId(pick.axis, pick.name)
     const same = pick.axis === 'object'
-      ? cardMatrixFilter.objectId === id && cardMatrixFilter.actionId === undefined && cardMatrixFilter.sceneId === undefined
-      : cardMatrixFilter.actionId === id && cardMatrixFilter.objectId === undefined && cardMatrixFilter.sceneId === undefined
+      ? cardMatrixFilter.objectId === id && cardMatrixFilter.actionId === undefined && cardMatrixFilter.sceneId === undefined && cardMatrixFilter.wikiKind === undefined
+      : cardMatrixFilter.actionId === id && cardMatrixFilter.objectId === undefined && cardMatrixFilter.sceneId === undefined && cardMatrixFilter.wikiKind === undefined
     setCardMatrixFilter(same ? {} : pick.axis === 'object' ? { objectId: id } : { actionId: id })
   }
 
@@ -2017,6 +2035,10 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       && (cardMatrixFilter.objectId === undefined || (card.coordinate?.objectId ?? '') === cardMatrixFilter.objectId)
       && (cardMatrixFilter.actionId === undefined || (card.coordinate?.actionId ?? '') === cardMatrixFilter.actionId)
       && (cardMatrixFilter.sceneId === undefined || (card.coordinate?.sceneId ?? '') === cardMatrixFilter.sceneId)
+      && (cardMatrixFilter.wikiKind === undefined
+        || (cardMatrixFilter.wikiKind === 'unclassified'
+          ? card.metadata?.wiki_kind !== 'fact' && card.metadata?.wiki_kind !== 'way'
+          : card.metadata?.wiki_kind === cardMatrixFilter.wikiKind))
       && (!needle || `${card.title}\n${card.entityId}\n${card.summary ?? ''}`.toLocaleLowerCase().includes(needle)))
   }, [cards, cardMatrixFilter, cardQuery, cardStatus])
 
@@ -2198,32 +2220,34 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       <AxisMatrix
         view={cardMatrixView}
         selection={cardMatrixSelection}
-        ariaLabel="WikiCard 矩阵：对象 × 动作 × 场景"
+        ariaLabel="Wiki 矩阵：对象 × 动作，显示 Wiki Fact 与 Wiki Way 数量"
         frame={false}
         bounded
         onPickCell={pickCardCell}
+        onPickBreakdown={pickCardBreakdown}
         onPickGroup={pickCardGroup}
         onPickAxis={pickCardAxis}
         onExpand={() => setCardMatrixFull(true)}
-        title={<>卡片矩阵<span className={styles.blockSub}>(对象 × 动作 × 场景)</span></>}
-        note="格内 = 卡片数 · 选中后筛选卡片"
-        meta={<>{cardMatrixView.withKnowledge} / {cardMatrixView.slots} 格有卡片</>}
+        title={<>Wiki 矩阵<span className={styles.blockSub}>(对象 × 动作 × 场景)</span></>}
+        note="总数 + 类型数：F = Wiki Fact · W = Wiki Way；点类型数筛选"
+        meta={<>Fact {cardMatrix.factCount} · Way {cardMatrix.wayCount}</>}
         footer={<>
           {cardMatrix.sceneOnly > 0 && <p className={styles.trialMore}>另有 {cardMatrix.sceneOnly} 张卡片只有场景，两个主轴为空。</p>}
           {cardMatrixView.noCoordinate > 0 && <p className={styles.trialMore}>另有 {cardMatrixView.noCoordinate} 张卡片没有坐标。</p>}
+          {cardMatrix.unclassifiedCount > 0 && <p className={styles.trialMore}>其中有 {cardMatrix.unclassifiedCount} 张 Wiki 尚未归类为 Fact 或 Way；点击格内“未”可筛选有坐标的未归类 Wiki。</p>}
         </>}
       />
     </section> : null}
     <Card className={styles.kbCard}>
       <div className={styles.kbCardHead}>
-        <div><h3><FileText size={13} />卡片</h3></div>
+        <div><h3><FileText size={13} />Wiki</h3></div>
         {/* 构建设置的入口落在这里（2026-10-05 随「知识图谱」分栏一起搬）：构建把这批
             卡片编成可召回的索引（索引版本写在步骤轨「物化」那一步的第二行），所以参数
             留在它加工的东西旁边 —— 与召回、重排把参数放在自己卡头上是同一条规矩。
             打开的还是那**一个**设置抽屉，只是落到「构建」分块。 */}
         <span className={styles.kbCardActions}>
           <span className={styles.kbCount}>
-            {visibleCards.length === cards.length ? `${cards.length} 张` : `筛出 ${visibleCards.length} / ${cards.length} 张`}
+            {visibleCards.length === cards.length ? `${cards.length} 张 Wiki` : `筛出 ${visibleCards.length} / ${cards.length} 张 Wiki`}
           </span>
           {onOpenSettings && <SettingsChip target="build" onOpen={onOpenSettings} />}
         </span>
@@ -2261,20 +2285,21 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     <Dialog open={cardMatrixFull} onOpenChange={setCardMatrixFull}>
       <DialogContent className={styles.matrixDialog}>
         <DialogHeader>
-          <DialogTitle className={styles.matrixDialogTitle}>卡片矩阵<span className={styles.blockSub}>(对象 × 动作 × 场景)</span></DialogTitle>
+          <DialogTitle className={styles.matrixDialogTitle}>Wiki 矩阵<span className={styles.blockSub}>(对象 × 动作 × 场景)</span></DialogTitle>
         </DialogHeader>
         <div className={styles.matrixDialogBody}>
           <AxisMatrix
             view={cardMatrixView}
             selection={cardMatrixSelection}
-            ariaLabel="WikiCard 矩阵：对象 × 动作 × 场景（全屏）"
+            ariaLabel="Wiki 矩阵：对象 × 动作，显示 Wiki Fact 与 Wiki Way 数量（全屏）"
             frame={false}
             onPickCell={pickCardCell}
+            onPickBreakdown={pickCardBreakdown}
             onPickGroup={pickCardGroup}
             onPickAxis={pickCardAxis}
-            title={<>卡片矩阵<span className={styles.blockSub}>(对象 × 动作 × 场景)</span></>}
-            note="格内 = 卡片数 · 选中后筛选卡片"
-            meta={<>{cardMatrixView.withKnowledge} / {cardMatrixView.slots} 格有卡片</>}
+            title={<>Wiki 矩阵<span className={styles.blockSub}>(对象 × 动作 × 场景)</span></>}
+            note="总数 + 类型数：F = Wiki Fact · W = Wiki Way；点类型数筛选"
+            meta={<>Fact {cardMatrix.factCount} · Way {cardMatrix.wayCount}</>}
           />
         </div>
       </DialogContent>
@@ -2302,10 +2327,13 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
    * 还是在讲卡片？现在它自己一栏，Wiki 只回答后半个问题。
    */
   const renderKnowledge = (): ReactNode => <Tabs value={knowledgeContent} onValueChange={value => setKnowledgeContent(value as 'knowledge' | 'procedure' | 'event')}>
-    <TabsList className={cn(styles.tabsList, styles.kbViewTabs)} aria-label="Fact、Procedure 与 Case 分类">
-      <TabsTrigger value="knowledge">Fact</TabsTrigger>
-      <TabsTrigger value="procedure">Procedure</TabsTrigger>
-      <TabsTrigger value="event">Case · {events.length}</TabsTrigger>
+    {/* 三个页签同时给中文名与英文术语：英文是工具与 Wiki 里的正式名（Fact / Procedure /
+        Case），中文是读它的人先认得的词。**页签不挂计数** —— 一栏里已经有分面计数与
+        块头计数，页签再写一个就会变成第三个「有多少」。 */}
+    <TabsList className={cn(styles.tabsList, styles.kbViewTabs)} aria-label="事实、方法与案例分类">
+      <TabsTrigger value="knowledge">事实 <span className="text-[9.5px] font-normal text-tita-ink-faint">Fact</span></TabsTrigger>
+      <TabsTrigger value="procedure">方法 <span className="text-[9.5px] font-normal text-tita-ink-faint">Procedure</span></TabsTrigger>
+      <TabsTrigger value="event">案例 <span className="text-[9.5px] font-normal text-tita-ink-faint">Case</span></TabsTrigger>
     </TabsList>
     <TabsContent value="knowledge" className={styles.viewStack}>
       {orphanNotice()}
@@ -2327,8 +2355,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     <TabsContent value="event" className={styles.viewStack}>
       <div className="flex min-w-0 items-center justify-between gap-2">
         <div className="flex min-w-0 items-center gap-2">
-          <h3 className="text-[12px] font-semibold text-tita-ink">Case</h3>
-          <Badge tone="neutral">{events.length}</Badge>
+          <h3 className="text-[12px] font-semibold text-tita-ink">案例 <span className="text-[10px] font-normal text-tita-ink-faint">Case</span></h3>
         </div>
         <Button variant="ghost" size="icon" aria-label="刷新 Case" title="刷新 Case" disabled={eventsLoading || !activeId} onClick={() => void loadEvents(activeId)}>
           <RefreshCw size={13} className={eventsLoading ? 'animate-spin' : undefined} />
@@ -2366,8 +2393,9 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         还和库选择器里那行菜单重复了一遍 —— 同一件事两个入口，就会有人改完一处
         以为另一处也跟着变了。库路径也不在这里了：它是「存储位置」设置，
         入口在面板顶部的齿轮里。
-        0034：「编译设置」挂在这一行 —— 它是**按库**的动作；而它**不是**第六个步骤：
-        步骤轨是一条流水线，定义不属于任何一段（理由见 `TypeDefinitionDrawer.tsx`）。
+        0034：「编译设置」曾挂在这一行 —— 它是**按库**的动作，而它**不是**第六个步骤：
+        步骤轨是一条流水线，定义不属于任何一段。2026-10-28 起它搬进知识处理整页，
+        与「解析内核」一起，只在那一个页面上留入口。
         0035：**计数撤出这一行**，动作左对齐。计数没有丢 —— 步骤轨每一步第二行写的就是
         「这一段现在有多少东西」（`stepFacts`），而这一行只回答「能对它做什么」。
         2026-10-05：**知识库入口整条撤掉**（用户要求）。它原先在最左边，显示库名或选择器，
@@ -2376,41 +2404,18 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         去改它，等于把一个部署级的事实伪装成一个可以随手切换的视图。默认库由
         `seedDefault()` 保证存在，所以撤掉「新建」也不会留下一个建不出库的空部署。 */}
     <div className={styles.kbToolbar}>
-      {/* 三个动作同形：图标 + 文字的 outline 按钮，同一个 30px 高。
-          「解析内核」此前是一枚 `<a target="_blank">`，靠 `Button asChild` 拿外观。
-          看起来对，但桌面壳里跑不通：应用地址是 `dsh-app://app/...`，而壳的
-          `setWindowOpenHandler` 只放行 http/https —— `/convert/` 被解析成应用内地址、
-          直接 deny，表现就是「点了没有任何反应，也不报错」。
-          现在走 `openAppPath()`：浏览器态开新标签页，桌面壳里换成 Host 的绝对地址再交给
-          系统浏览器。**同一枚按钮，两种外壳做各自成立的那件事。**
-          0042：「编译」原本在 wiki 栏的统计卡里（增量 + 全量两枚），现在它是**工具栏的
-          一个动作** —— 编译是「对这个库做什么」，它和「选哪个库」「编译设置」同层，
-          不属于任何一栏的内容。 */}
+      {/* 一行一个动作：outline + 图标，同一个 30px 高。
+          0042：「编译」原本在 wiki 栏的统计卡里，后来是工具栏的一个动作。
+          2026-10-28：编译设置与解析内核的入口都搬进知识处理整页 —— 面板不再同时
+          兼任「处理现场」与「参数 / 上游工具」两种角色。 */}
       <span className={styles.kbToolbarActions}>
-        <Button
-          variant="outline"
-          size="sm"
-          disabled={!active}
-          title={active ? `编辑 ${active.name} 的编译设置` : '先选择一个知识库'}
-          onClick={() => setTypeDef(true)}
-        ><Tags size={13} />编译设置</Button>
-        {/* 一行顶栏里**一个入口**。此前这里是两枚（「知识处理」与「任务历史」），
-            打开的却是同一个地址的两个位置 —— 同一样东西两个入口，人就会以为它们是两件事，
-            点完一个再点另一个来确认「历史是不是同一份」。整合后只剩这一枚：
-            页面上半段是四段阶段，下半段右侧就是运行记录，一屏之内都读得到。 */}
-        <Button variant="outline" size="sm" disabled={!active} title="运行阶段、处理范围与运行记录" onClick={() => {
-          if (active) void fullPage.open({ src: `/knowledge/pages/tasks?kb=${encodeURIComponent(active.id)}`, title: '知识处理与运行记录' })
+        {/* 一行顶栏里**一个入口**。此前这里是三枚（编译设置 / 知识处理 / 解析内核），
+            打开的是同一件事的三个位置 —— 编译设置改的就是这条流水线的模型与坐标，
+            解析内核是它的上游。2026-10-28 起它们都住在知识处理整页里：
+            面板这一行只回答「去哪处理这个库」，不再兼任设置与上游工具。 */}
+        <Button variant="outline" size="sm" disabled={!active} title="运行阶段、处理范围、编译设置与轨迹" onClick={() => {
+          if (active) void fullPage.open({ src: `/knowledge/pages/tasks?kb=${encodeURIComponent(active.id)}`, title: '知识处理' })
         }}><Layers3 size={14} />知识处理</Button>
-        <Button
-          variant="outline"
-          size="sm"
-          title="打开解析内核控制台"
-          onClick={() => { void openAppPath('/convert/').then(opened => {
-            // 打不开就如实说。桌面壳拿不到 Host 地址时 `window.open` 会被静默拒绝 ——
-            // 那种「点了没反应」正是这次要修掉的东西，不能换个地方再犯一次。
-            if (!opened) setNotice({ tone: 'error', text: '打不开解析内核控制台：当前外壳下拿不到它的地址。' })
-          }) }}
-        ><FileUp size={14} />解析内核</Button>
       </span>
       {/* 说明靠右、动作靠左：这一行的主语是一排按钮，`?` 是这一排的脚注，
           所以它自己站在最右侧，而不是挤进按钮之间（挤进去会被读成某一枚按钮的附件）。 */}
@@ -2494,18 +2499,6 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
       onRetryFailed={() => void runImportQueue()}
     />
 
-    {/* 本库的坐标实体与抽取备注：按库持久化，和方案级设置分开。 */}
-    {active && <TypeDefinitionDrawer
-      open={typeDef}
-      onOpenChange={setTypeDef}
-      kbId={active.id}
-      busy={busy}
-      extractionNote={active.extractionNote ?? ''}
-      onSaveExtractionNote={saveExtractionNote}
-      compileModel={active.compileModel ?? { mode: 'default' }}
-      onSaveCompileModel={saveCompileModel}
-    />}
-
     <RestoreDialog
       open={restoreTarget !== null}
       onOpenChange={open => { if (!open) setRestoreTarget(null) }}