dsh-data-domain-knowledge 0.1.0-alpha.9 → 0.1.1-alpha.2

package/src/client/PreviewSections.tsx

@@ -42,8 +42,8 @@ import { styles } from './styles.ts'
  * Markdown 原子的界面文案。必须是**模块级常量**：平台明确要求这个对象引用稳定
  * （换一个身份会让流式渲染的缓存整体作废），在渲染里现造一个对象正好踩中那条。
  *
- * 这三个词与 `plugins/dsh-data-notebook` 的同名常量逐字相同。没有抽回 `packages/ui`
- * 是刻意的：`MarkdownLabels` 的类型来自**宿主提供的**平台包，而 data-notebook 的
+ * 这三个词是预览区的显示文案。没有抽回 `packages/ui`
+ * 是刻意的：`MarkdownLabels` 的类型来自**宿主提供的**平台包，而各预览消费者的
  * 独立整页入口必须能把平台包整块排除在 bundle 之外 —— 共享层一旦引它，那条「独立
  * 页面不拉平台依赖」的约束就断了。三行文案不值得拿那条约束换。
  */
@@ -524,78 +524,128 @@ export interface VersionContentDiffData {
 }
 
 type ContentDiffLine = { kind: 'add' | 'remove' | 'same'; text: string }
-type ContentDiffDisplayLine = ContentDiffLine | { kind: 'skip'; count: number }
-
-/** Small, bounded LCS diff for Markdown/plain-text version bodies. */
-function contentDiffOf(before: string, after: string): ContentDiffLine[] {
-  const oldLines = before.replace(/\r\n/g, '\n').split('\n').slice(0, 600)
-  const newLines = after.replace(/\r\n/g, '\n').split('\n').slice(0, 600)
-  const matrix = Array.from({ length: oldLines.length + 1 }, () => new Uint16Array(newLines.length + 1))
-  for (let oldIndex = oldLines.length - 1; oldIndex >= 0; oldIndex -= 1) {
-    for (let newIndex = newLines.length - 1; newIndex >= 0; newIndex -= 1) {
-      matrix[oldIndex]![newIndex] = oldLines[oldIndex] === newLines[newIndex]
-        ? (matrix[oldIndex + 1]![newIndex + 1] ?? 0) + 1
-        : Math.max(matrix[oldIndex + 1]![newIndex] ?? 0, matrix[oldIndex]![newIndex + 1] ?? 0)
+type ContentDiffDisplayLine =
+  | { kind: 'pair'; before?: string; after?: string }
+  | { kind: 'skip'; count: number }
+
+/** Line diff for Markdown/plain-text version bodies. Full mode keeps every line. */
+function contentDiffOf(before: string, after: string, fullText = false): ContentDiffLine[] {
+  const oldLines = before.replace(/\r\n/g, '\n').split('\n')
+  const newLines = after.replace(/\r\n/g, '\n').split('\n')
+  if (!fullText) {
+    oldLines.length = Math.min(oldLines.length, 600)
+    newLines.length = Math.min(newLines.length, 600)
+  }
+
+  // Trim shared edges before LCS. Wiki cards often have a small edit in a long body.
+  let prefix = 0
+  let oldEnd = oldLines.length
+  let newEnd = newLines.length
+  if (fullText) {
+    while (prefix < oldEnd && prefix < newEnd && oldLines[prefix] === newLines[prefix]) prefix += 1
+    while (oldEnd > prefix && newEnd > prefix && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+      oldEnd -= 1
+      newEnd -= 1
     }
+  } else {
+    prefix = 0
+    oldEnd = oldLines.length
+    newEnd = newLines.length
   }
+
+  const oldMiddle = oldLines.slice(prefix, oldEnd)
+  const newMiddle = newLines.slice(prefix, newEnd)
   const lines: ContentDiffLine[] = []
-  let oldIndex = 0
-  let newIndex = 0
-  while (oldIndex < oldLines.length || newIndex < newLines.length) {
-    if (oldIndex < oldLines.length && newIndex < newLines.length && oldLines[oldIndex] === newLines[newIndex]) {
-      lines.push({ kind: 'same', text: oldLines[oldIndex]! })
-      oldIndex += 1
-      newIndex += 1
-    } else if (oldIndex < oldLines.length && (newIndex >= newLines.length || (matrix[oldIndex + 1]![newIndex] ?? 0) >= (matrix[oldIndex]![newIndex + 1] ?? 0))) {
-      lines.push({ kind: 'remove', text: oldLines[oldIndex]! })
-      oldIndex += 1
-    } else {
-      lines.push({ kind: 'add', text: newLines[newIndex]! })
-      newIndex += 1
+  for (let index = 0; index < prefix; index += 1) lines.push({ kind: 'same', text: oldLines[index]! })
+
+  // Bound the quadratic LCS allocation for unusually large, completely rewritten hunks.
+  // The full text remains visible; only that hunk is marked as remove/add when it exceeds the budget.
+  if (fullText && (oldMiddle.length + newMiddle.length > 20_000 || oldMiddle.length * newMiddle.length > 1_000_000)) {
+    for (const text of oldMiddle) lines.push({ kind: 'remove', text })
+    for (const text of newMiddle) lines.push({ kind: 'add', text })
+  } else {
+    const matrix = Array.from({ length: oldMiddle.length + 1 }, () => new Uint16Array(newMiddle.length + 1))
+    for (let oldIndex = oldMiddle.length - 1; oldIndex >= 0; oldIndex -= 1) {
+      for (let newIndex = newMiddle.length - 1; newIndex >= 0; newIndex -= 1) {
+        matrix[oldIndex]![newIndex] = oldMiddle[oldIndex] === newMiddle[newIndex]
+          ? (matrix[oldIndex + 1]![newIndex + 1] ?? 0) + 1
+          : Math.max(matrix[oldIndex + 1]![newIndex] ?? 0, matrix[oldIndex]![newIndex + 1] ?? 0)
+      }
+    }
+    let oldIndex = 0
+    let newIndex = 0
+    while (oldIndex < oldMiddle.length || newIndex < newMiddle.length) {
+      if (oldIndex < oldMiddle.length && newIndex < newMiddle.length && oldMiddle[oldIndex] === newMiddle[newIndex]) {
+        lines.push({ kind: 'same', text: oldMiddle[oldIndex]! })
+        oldIndex += 1
+        newIndex += 1
+      } else if (oldIndex < oldMiddle.length && (newIndex >= newMiddle.length || (matrix[oldIndex + 1]![newIndex] ?? 0) >= (matrix[oldIndex]![newIndex + 1] ?? 0))) {
+        lines.push({ kind: 'remove', text: oldMiddle[oldIndex]! })
+        oldIndex += 1
+      } else {
+        lines.push({ kind: 'add', text: newMiddle[newIndex]! })
+        newIndex += 1
+      }
     }
   }
+
+  for (let index = 0; index < oldLines.length - oldEnd; index += 1) {
+    lines.push({ kind: 'same', text: oldLines[oldEnd + index]! })
+  }
   return lines
 }
 
-function compactContentDiff(lines: ContentDiffLine[]): ContentDiffDisplayLine[] {
+function compactContentDiff(lines: ContentDiffLine[], fullText = false): ContentDiffDisplayLine[] {
   const out: ContentDiffDisplayLine[] = []
   let index = 0
   while (index < lines.length) {
-    if (lines[index]?.kind !== 'same') {
-      out.push(lines[index]!)
-      index += 1
+    if (lines[index]?.kind === 'same') {
+      const start = index
+      while (index < lines.length && lines[index]?.kind === 'same') index += 1
+      const count = index - start
+      const visible = fullText || count <= 6
+        ? lines.slice(start, index)
+        : [...lines.slice(start, start + 2), { kind: 'skip' as const, count: count - 4 }, ...lines.slice(index - 2, index)]
+      for (const line of visible) {
+        if (line.kind === 'skip') out.push(line)
+        else out.push({ kind: 'pair', before: line.text, after: line.text })
+      }
       continue
     }
-    const start = index
-    while (index < lines.length && lines[index]?.kind === 'same') index += 1
-    const count = index - start
-    if (count <= 6) out.push(...lines.slice(start, index))
-    else {
-      out.push(...lines.slice(start, start + 2))
-      out.push({ kind: 'skip', count: count - 4 })
-      out.push(...lines.slice(index - 2, index))
+    const removed: string[] = []
+    const added: string[] = []
+    while (index < lines.length && lines[index]?.kind !== 'same') {
+      const line = lines[index]!
+      if (line.kind === 'remove') removed.push(line.text)
+      if (line.kind === 'add') added.push(line.text)
+      index += 1
+    }
+    const count = Math.max(removed.length, added.length)
+    for (let pair = 0; pair < count; pair += 1) {
+      out.push({ before: removed[pair], after: added[pair], kind: 'pair' })
     }
   }
   return out
 }
 
 /** Read-only Markdown/plain-text comparison for SourceRaw and WikiCard. */
-export function VersionContentDiff({ data, loading = false, error }: {
+export function VersionContentDiff({ data, loading = false, error, fullText = false }: {
   data?: VersionContentDiffData
   loading?: boolean
   error?: string
+  fullText?: boolean
 }): ReactNode {
   if (loading) return <div className="tita-versionDiff"><div className="tita-versionStepHint">正在读取历史正文…</div></div>
   if (error !== undefined) return <div className="tita-versionDiff"><div className="tita-kbHint">读取版本差异失败：{error}</div></div>
   if (data === undefined) return null
-  const lines = contentDiffOf(data.before, data.after)
-  const displayed = compactContentDiff(lines)
+  const lines = contentDiffOf(data.before, data.after, fullText)
+  const displayed = compactContentDiff(lines, fullText)
   const added = lines.filter(line => line.kind === 'add').length
   const removed = lines.filter(line => line.kind === 'remove').length
   const changed = Math.min(added, removed)
   const truncated = data.beforeTruncated === true || data.afterTruncated === true
   return (
-    <div className="tita-versionDiff" aria-label="版本差异">
+    <div className={fullText ? 'tita-versionDiff tita-versionDiff-fullText' : 'tita-versionDiff'} aria-label="版本差异">
       <div className="tita-versionDiffBar">
         <p className="tita-versionDiffHead">
           {added === 0 && removed === 0 ? '正文没有差异' : '正文差异'}
@@ -605,14 +655,31 @@ export function VersionContentDiff({ data, loading = false, error }: {
         </p>
       </div>
       {truncated && <p className="tita-kbHint">只比较当前读取范围；正文过长，末尾内容未参与比较。</p>}
-      {lines.length > 0 && (added > 0 || removed > 0) && (
-        <div className="tita-versionDiffHunk">
-          <div className="tita-versionDiffHunkHead">{data.beforeLabel} → {data.afterLabel}</div>
-          <pre className="tita-versionDiffLines">
-            {displayed.map((line, index) => line.kind === 'skip'
-              ? <span className="tita-versionDiffSkip" key={`skip-${index}`}>⋯ {line.count} 行未变化</span>
-              : <span className={`tita-versionDiffLine tita-versionDiffLine-${line.kind}`} key={`${line.kind}-${index}`}>{`${line.kind === 'add' ? '+' : line.kind === 'remove' ? '-' : ' '} ${line.text}`}</span>)}
-          </pre>
+      {lines.length > 0 && (fullText || added > 0 || removed > 0) && (
+        <div className="tita-versionDiffTextSplit">
+          <div className="tita-versionDiffTextSplitHead">
+            <span>历史版本 · {data.beforeLabel}</span>
+            <span>当前版本 · {data.afterLabel}</span>
+          </div>
+          {displayed.map((line, index) => line.kind === 'skip'
+            ? <div className="tita-versionDiffTextSkip" key={`skip-${index}`}>⋯ {line.count} 行未变化</div>
+            : (() => {
+              const same = line.before !== undefined && line.after !== undefined && line.before === line.after
+              const beforeClass = line.before === undefined
+                ? 'tita-versionDiffTextCell tita-versionDiffTextCell-empty'
+                : same
+                  ? 'tita-versionDiffTextCell tita-versionDiffTextCell-same'
+                  : 'tita-versionDiffTextCell tita-versionDiffTextCell-before'
+              const afterClass = line.after === undefined
+                ? 'tita-versionDiffTextCell tita-versionDiffTextCell-empty'
+                : same
+                  ? 'tita-versionDiffTextCell tita-versionDiffTextCell-same'
+                  : 'tita-versionDiffTextCell tita-versionDiffTextCell-after'
+              return <div className="tita-versionDiffTextSplitRow" key={`pair-${index}`}>
+                <span className={beforeClass}>{line.before === undefined ? '' : `${same ? ' ' : '-'} ${line.before}`}</span>
+                <span className={afterClass}>{line.after === undefined ? '' : `${same ? ' ' : '+'} ${line.after}`}</span>
+              </div>
+            })())}
         </div>
       )}
     </div>

package/src/client/RecallPanel.tsx

@@ -9,10 +9,11 @@
  * `chunk_index` / `score` 一起给出 —— 只报「命中 N 条」看不出召回质量。
  */
 
-import { Fragment, useEffect, useState, type ReactNode } from 'react'
+import { Fragment, useEffect, useRef, useState, type ReactNode } from 'react'
 import { ArrowRight, ArrowUpDown, BrainCircuit, CircleHelp, GitBranch, Layers3, Play, Search, Shapes } from '@tita-agent/ui/icons'
-import { Button, Card, Input, SelectMenu, cn } from '@tita-agent/ui/components'
+import { Button, Card, Input, cn } from '@tita-agent/ui/components'
 import { ExpansionGraph } from './ExpansionGraph.tsx'
+import { requestJson } from './request.ts'
 import { styles } from './styles.ts'
 
 /** 一条命中的 wikiNote。`match` 是**真正贡献了这次命中**的路线。 */
@@ -96,7 +97,7 @@ export interface QueryAnalysisView {
   unresolved: QueryAxisKind[]
 }
 
-/** 召回链路的三个步骤：三路候选 → Section 重排 → 完整 WikiCard 交付。 */
+/** 召回链路的三个步骤：四路候选 → Section 重排 → 完整 WikiCard 交付。 */
 export type RecallStep = 'recall' | 'rerank' | 'deliver'
 
 export interface RecallResultView {
@@ -108,7 +109,7 @@ export interface RecallResultView {
   /** 融合与重排作用的候选池深度（0031）。它与 `recallTopK` 是两个数。 */
   candidatePool?: number
   /**
-   * 三路候选**去重后**的候选条数。
+   * 四路候选**去重后**的候选条数。
    *
    * 面板上这三个数必须各归各位：`candidatePool` 是每一路的超采深度（50），
    * `fusedCount` 是融合后的池子（实测「投资」那次是 17），`hits.length` 是重排之后
@@ -140,6 +141,7 @@ export interface RecallResultView {
   /** 面板账本（0050）：每一路的全部候选 + 重排的全部候选（含被丢弃的）。 */
   ledger?: {
     coordinate: LedgerRowView[]
+    relation?: LedgerRowView[]
     fts: LedgerRowView[]
     vector: LedgerRowView[]
     rerank: Array<LedgerRowView & { fused: number; logit?: number; rerankScore?: number; dropped: boolean }>
@@ -155,7 +157,7 @@ export interface RecallResultView {
    * 只给「这次测试很慢」的感受，人没法判断该不该管它。
    */
   timings?: {
-    ftsMs: number; coordinateMs: number; vectorMs: number; embedMs?: number; scanMs?: number
+    ftsMs: number; coordinateMs: number; relationMs?: number; vectorMs: number; embedMs?: number; scanMs?: number
     graphMs: number; fuseMs: number; rerankMs?: number; assembleMs: number; totalMs: number
   }
   /** 命中几张卡 + 1 跳扩展几张（0050）。 */
@@ -167,22 +169,6 @@ export interface RecallResultView {
   indexVersion?: number
 }
 
-interface Envelope<T> { ok?: boolean; data?: T; error?: { code?: string; message?: string; suggestion?: string } | null }
-
-async function requestJson<T>(url: string): Promise<Envelope<T>> {
-  const response = await fetch(url)
-  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
-}
-
 /**
  * 账本列表（0050）：**每一路的全部候选**，没过阈值的也在（虚线 + 淡色 + 一句原因）。
  *
@@ -316,43 +302,22 @@ export function DeliveryView({ wiki, onOpenWiki }: { wiki: WikiCardView[]; onOpe
 }
 
 /**
- * 召回是**三路**（Coordinate + 关键词 BM25 + 向量）加一个后置图谱 boost（0031）。
+ * 召回是四路（Coordinate + 对象关系 + 关键词 BM25 + 向量）加一个后置图谱 boost。
  *
  * 图谱不再是独立一路：它不能制造候选，只给已经在候选池里的条目加权。所以这一行显示的是
  * 「加权了几条」，而不是「跑没跑」—— 后者对它已经没有意义。
  */
 export const RECALL_ROUTES: Array<{ id: string; label: string; hint: string }> = [
   { id: 'coordinate', label: 'Coordinate', hint: 'Object × Action × Scene 坐标命中后展开为 Section' },
+  { id: 'relation', label: '关系', hint: '从命中的对象沿一跳 related_to 关系召回相关对象卡片' },
   { id: 'fts', label: '关键词', hint: 'FTS5 + BM25（中文按双字词切分）' },
   { id: 'vector', label: '向量', hint: 'WeMM 向量近邻（binary 预筛 + int8 精算余弦）' },
 ]
 
-/**
- * 路线选项保留 FTS / Vector 两个调试开关；默认 Hybrid 会额外启用 Coordinate 路。
- *
- * 图谱 boost 不是一条路（它不能制造候选，只给已在池里的条目加权），所以它不该出现在
- * 「选哪一路」的下拉里 —— 上一版那两条「融合 + 图谱 boost」「同融合」正是这个错：
- * 把加权当成了路线。融合是候选路的**组合方式**，写在选项文字里，不是一个独立选项。
- */
-export const RECALL_MODES: Array<{ id: string; label: string }> = [
-  { id: 'hybrid', label: 'Coordinate + 关键词 + 向量（融合，默认）' },
-  { id: 'fts', label: '仅关键词' },
-  { id: 'vector', label: '仅向量' },
-]
-
-/**
- * 参数摘要里用的短名字。
- *
- * `RECALL_MODES` 的 label 是给下拉用的**整句**（「Coordinate + 关键词 + 向量（融合，默认）」），
- * 直接塞进那行摘要会把行撑爆 —— 摘要是拿来扫的，不是拿来读的。两处各留一份是对的：
- * 下拉里要能说清「哪个是默认」，摘要里要短。
- */
-const MODE_SHORT: Record<string, string> = { hybrid: 'Coordinate + 关键词 + 向量', fts: '仅关键词', vector: '仅向量' }
-
 const HIT_ROUTES: Record<string, string> = {
-  coordinate: styles.hitRouteHybrid, fts: styles.hitRouteFts, vector: styles.hitRouteVector, graph: styles.hitRouteGraph, hybrid: styles.hitRouteHybrid,
+  coordinate: styles.hitRouteHybrid, relation: styles.hitRouteGraph, fts: styles.hitRouteFts, vector: styles.hitRouteVector, graph: styles.hitRouteGraph, hybrid: styles.hitRouteHybrid,
 }
-const HIT_ROUTE_LABEL: Record<string, string> = { coordinate: 'Coordinate', fts: '关键词', vector: '向量', hybrid: '多路', graph: '图谱加权' }
+const HIT_ROUTE_LABEL: Record<string, string> = { coordinate: 'Coordinate', relation: '关系扩展', fts: '关键词', vector: '向量', hybrid: '多路', graph: '图谱加权' }
 
 /** 去掉 markdown 脚手架，让命中读起来是一段正文而不是源码。 */
 export function snippetOf(content: string, limit = 200): string {
@@ -436,17 +401,16 @@ export interface RecallPanelProps {
   /** `recall` 看命中切片，`rerank` 看进入上下文的 topN，`runner` 是评测里的紧凑版。 */
   /**
    * `recall` = 知识库 → **召回重排**那一栏（0033 起召回与重排合成一栏，一次运行
- * 从上到下给出三路命中 → 融合排序 → 精排丢了多少 → 进上下文的 topN）。
+ * 从上到下给出四路命中 → 融合排序 → 精排丢了多少 → 进上下文的 topN）。
    * `runner` = 评测里的紧凑版单问题检查。
    */
   variant?: 'recall' | 'runner'
-  defaults?: { mode?: string; topK?: number; topN?: number }
+  defaults?: { topK?: number; topN?: number }
   /** 设置写完或知识库切换时，用它把面板重置回初始值。 */
   resetKey?: string
   /**
-   * 卡头上的「参数」入口（0033）。面板**不认识设置**：它只在自己的卡头上腾一个位置，
-   * 具体挂哪一块由调用方决定（召回栏挂召回设置、重排栏挂重排设置、评测栏不挂）。
-   * 参数住在设置抽屉里，这里只是那扇离现场更近的门。
+   * 卡头上的设置入口。面板**不认识设置**，只留一个位置让调用方挂最近的入口；
+   * 召回、重排与上下文共用同一组设置，评测栏不挂入口。
    */
   settingsChip?: ReactNode
   /** 点某张卡片时打开它的预览抽屉。不给就是纯文本（面板不自己造一个抽屉出来）。 */
@@ -462,18 +426,32 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
    * 提示语改成直说这一栏要什么：**要测试的内容**。
    */
   const [query, setQuery] = useState('')
-  const [mode, setMode] = useState(defaults?.mode ?? 'hybrid')
   const [topK, setTopK] = useState(defaults?.topK ?? 10)
   const [topN, setTopN] = useState(defaults?.topN ?? 5)
+  /**
+   * 两个参数框里**正在被敲的那串字**。
+   *
+   * 输入框原来直接吃数字、每次按键都夹一次（`Math.max(1, …)`），于是「全选删掉重打」
+   * 这一步永远做不到：清空的一瞬间就被改写回 1，人只能先选中再输入。**空串是一种
+   * 合法的中间态**，所以草稿留成字符串，只在失焦时夹一次。
+   */
+  const [topKDraft, setTopKDraft] = useState(String(defaults?.topK ?? 10))
+  const [topNDraft, setTopNDraft] = useState(String(defaults?.topN ?? 5))
   const [busy, setBusy] = useState(false)
   const [error, setError] = useState<string | null>(null)
   const [result, setResult] = useState<RecallResultView | null>(null)
+  /**
+   * 本次运行的票号。连按两次「测试」或连敲两次回车会发两个请求，先发的可能后回 ——
+   * 那一次的结果会把新一次盖掉，而屏幕上的参数是新一次的。每个 `setState` 前比票号，
+   * 过期的整段丢掉（与卡片列表 `eventsRequestRef` 同一条纪律）。
+   */
+  const runRef = useRef(0)
   /** 三个 tab：召回 / 重排 / 交付 —— 一条链路的三段，各自回答一个问题。 */
   const [tab, setTab] = useState<RecallStep>('recall')
   /** 召回 tab 里正在看哪一路（`all` = 看融合后的命中）。 */
-  const [routeView, setRouteView] = useState<'all' | 'coordinate' | 'fts' | 'vector'>('all')
+  const [routeView, setRouteView] = useState<'all' | 'coordinate' | 'relation' | 'fts' | 'vector'>('all')
   /**
-   * 三个参数旋钮默认**收起来**。
+   * 两个片段数量参数默认**收起来**。
    *
    * 它们此前常驻一整条横带，而那条横带压在步骤轨与命中列表上面 —— 列表之前一共五条
    * 横带，一屏里真正要读的东西被推下去。参数和命中列表不是同一件事，不该有同等高度：
@@ -491,20 +469,36 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
 
   // 知识库换了或设置存了：面板上的默认值跟着走，否则显示的还是上一个库的参数。
   // 用 effect 而不是渲染期 setState：这条同步是「外部输入变了」而不是渲染推导。
-  const modeDefault = defaults?.mode
   const topKDefault = defaults?.topK
   const topNDefault = defaults?.topN
   useEffect(() => {
     if (!visible) return
-    if (modeDefault) setMode(modeDefault)
-    if (topKDefault) setTopK(topKDefault)
-    if (topNDefault) setTopN(topNDefault)
+    if (topKDefault) { setTopK(topKDefault); setTopKDraft(String(topKDefault)) }
+    if (topNDefault) { setTopN(topNDefault); setTopNDraft(String(topNDefault)) }
     setResult(null)
-  }, [visible, resetKey, modeDefault, topKDefault, topNDefault])
+  }, [visible, resetKey, topKDefault, topNDefault])
+
+  /** 夹一次并写回草稿。数字为空或非数就退回当前值 —— 不合法的一律不落地。 */
+  const commitTopK = (): void => {
+    const next = Math.max(1, Math.min(50, Number(topKDraft) || topK))
+    setTopK(next); setTopKDraft(String(next))
+    // topN 的上限跟着 topK：改小 topK 之后原来那个 topN 可能已经越界。
+    setTopN(current => {
+      const capped = Math.min(current, next)
+      setTopNDraft(String(capped))
+      return capped
+    })
+  }
+  const commitTopN = (): void => {
+    const next = Math.max(1, Math.min(topK, Number(topNDraft) || topN))
+    setTopN(next); setTopNDraft(String(next))
+  }
 
   const run = async (): Promise<void> => {
     const trimmed = query.trim()
     if (!trimmed) { setError('请输入要测试的召回问题。'); return }
+    const ticket = runRef.current + 1
+    runRef.current = ticket
     setBusy(true); setError(null); setDroppedOpen(null)
     try {
       const boundedTopN = Math.min(topN, topK)
@@ -516,7 +510,7 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
        * 点下去却是「这一路没有候选」—— 计数来自 `diagnostics`，明细来自 `ledger`，
        * 两者来源不同，缺一半就自相矛盾。
        */
-      const params = new URLSearchParams({ query: trimmed, top_k: String(topK), top_n: String(boundedTopN), mode, detail: 'true' })
+      const params = new URLSearchParams({ query: trimmed, top_k: String(topK), top_n: String(boundedTopN), detail: 'true' })
       if (kbId) params.set('kb', kbId)
       const payload = await requestJson<{
         hits?: Array<Partial<RecallHitView> & { content?: string }>
@@ -551,6 +545,7 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         indexVersion?: number
         ledger?: {
           coordinate?: LedgerRowView[]
+          relation?: LedgerRowView[]
           fts?: LedgerRowView[]
           vector?: LedgerRowView[]
           rerank?: Array<LedgerRowView & { fused?: number; logit?: number; rerankScore?: number; dropped?: boolean }>
@@ -611,6 +606,8 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
           ...(expansion && item.via ? { via: `${item.via.title}（${item.via.relation}）` } : {}),
         }
       })
+      // 票号过期就整段丢掉：这份响应属于上一次点击，落地只会把新一次的结果盖掉。
+      if (runRef.current !== ticket) return
       setResult({
         count: hits.length,
         backend: data.backend ?? 'fts',
@@ -644,6 +641,7 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         // 而后者只可能出现在老服务端上。
         ledger: {
           coordinate: data.ledger?.coordinate ?? [],
+          relation: data.ledger?.relation ?? [],
           fts: data.ledger?.fts ?? [],
           vector: data.ledger?.vector ?? [],
           rerank: (data.ledger?.rerank ?? []).map(row => ({ ...row, fused: Number(row.fused ?? row.score ?? 0), dropped: row.dropped === true })),
@@ -673,15 +671,18 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         ...(data.indexVersion === undefined ? {} : { indexVersion: data.indexVersion }),
       })
     } catch (cause) {
+      if (runRef.current !== ticket) return
       setError(cause instanceof Error ? cause.message : String(cause))
     } finally {
-      setBusy(false)
+      // 只有还是当前这一次才关掉「测试中」：过期的那次把 busy 关掉，会让正在跑的那次
+      // 看起来已经结束（按钮重新可点，于是又多开一次请求）。
+      if (runRef.current === ticket) setBusy(false)
     }
   }
 
   const title = variant === 'runner' ? '单问题召回检查' : '召回 · 重排'
   // 这一栏没有「一句话说明」：那条步骤轨就是说明。每一步带自己的计数，
-  // 「三路各自命中了什么 → Section 重排 → 返回哪些完整 WikiCard」
+  // 「四路各自命中了什么 → Section 重排 → 返回哪些完整 WikiCard」
   // 这句话由轨上的真实数字说，比一句固定文案准，也不会随实现变化而过期。
 
   /**
@@ -704,9 +705,9 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
   const steps: Array<{ id: RecallStep; icon: typeof Search; label: string; verb: string; value: string; note: string; cost: string; costTitle: string }> = [
     {
       id: 'recall', icon: Search, label: '召回', verb: '找',
-      value: result ? `坐标 ${keptOf('coordinate') ?? 0} · 关键词 ${keptOf('fts') ?? 0} · 向量 ${keptOf('vector') ?? 0}` : '未运行',
-      note: '三路各自进入候选池的条数',
-      cost: timings ? ms(timings.coordinateMs + timings.ftsMs + timings.vectorMs) : '',
+      value: result ? `坐标 ${keptOf('coordinate') ?? 0} · 关系 ${keptOf('relation') ?? 0} · 关键词 ${keptOf('fts') ?? 0} · 向量 ${keptOf('vector') ?? 0}` : '未运行',
+      note: '四路各自进入候选池的条数',
+      cost: timings ? ms(timings.coordinateMs + (timings.relationMs ?? 0) + timings.ftsMs + timings.vectorMs) : '',
       costTitle: timings
         ? `关键词 ${ms(timings.ftsMs)}${timings.embedMs === undefined ? '' : ` · 查询编码 ${ms(timings.embedMs)}${timings.scanMs === undefined ? '' : ` · 索引扫描 ${ms(timings.scanMs)}`}`}`
         : '',
@@ -753,10 +754,9 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
    * 但界面上不写出来，人就只能靠记忆判断哪个数真的生效了。所以不一致时明说，
    * 并在 `title` 里给出设置里的那一组值。
    */
-  const overridden = (defaults?.mode !== undefined && mode !== defaults.mode)
-    || (defaults?.topK !== undefined && topK !== defaults.topK)
+  const overridden = (defaults?.topK !== undefined && topK !== defaults.topK)
     || (defaults?.topN !== undefined && topN !== defaults.topN)
-  const defaultHint = `设置里的默认：${MODE_SHORT[defaults?.mode ?? ''] ?? defaults?.mode ?? '未读到'} · 召回 topK ${defaults?.topK ?? '—'} · 上下文 topN ${defaults?.topN ?? '—'}`
+  const defaultHint = `设置里的默认：召回 topK ${defaults?.topK ?? '—'} · 上下文 topN ${defaults?.topN ?? '—'}`
 
   /*
    * 这一栏的横带节奏交给**容器**统一给（`.tita-recallPanel` 是一个 gap 14px 的网格），
@@ -781,20 +781,23 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
     <div className={styles.inputRow}>
       <Input value={query} placeholder="请输入要测试的内容"
         onChange={event => setQuery(event.target.value)}
-        onKeyDown={event => { if (event.key === 'Enter') void run() }} />
+        // 回车与按钮走**同一条判断**：按钮上写着 `disabled={busy}`，而回车原来没有这一条，
+        // 于是「测试中连敲回车」会同时开出好几个请求。空串也不打 —— 那时它在报一个
+        // 人还没写完的输入。
+        onKeyDown={event => { if (event.key === 'Enter' && !busy && query.trim() !== '') void run() }} />
       <Button variant="default" onClick={() => void run()} disabled={busy}>
         {variant === 'runner' && <Play size={13} />}{busy ? '测试中…' : variant === 'runner' ? '运行检查' : '测试'}
       </Button>
     </div>
     {result?.queryAnalysis && <QueryAnalysisSummary analysis={result.queryAnalysis} />}
     {/* 参数不再常驻一条横带（0050 第三版）：平时只留**一行只读摘要**，值与设置里的默认
-        都在这一行上说清；要改才点开三个旋钮。
-        为什么不是整块搬进设置抽屉：这一栏里的三个值是**这一次运行**的参数，设置抽屉里那
+        都在这一行上说清；要改才展开片段数量。
+        为什么不是整块搬进设置抽屉：这一栏里的两个值是**这一次运行**的参数，设置抽屉里那
         三个是**默认值** —— 搬过去就等于把「临时改一次」变成「改掉全方案的默认」。
         两者不一致时这一行会写明，这正是 0050 那版注释里记着的坑
         （「设置里 topK=20、召回面板还按 10 跑」）。 */}
     <p className={styles.recallParamLine}>
-      <b>{MODE_SHORT[mode] ?? mode}</b>
+      <b>多路径召回</b>
       <span>召回 topK <b>{topK}</b></span>
       <span>上下文 topN <b>{Math.min(topN, topK)}</b></span>
       {overridden && <span className={styles.recallParamOver} title={defaultHint}>非默认</span>}
@@ -802,18 +805,17 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         onClick={() => setParamOpen(open => !open)}>{paramOpen ? '收起参数' : '改参数'}</button>
     </p>
     {paramOpen && <div className={styles.recallControls}>
-      <div className={styles.recallControl}>
-        <span>路线</span>
-        <SelectMenu className="w-auto" value={mode} disabled={busy} onValueChange={setMode} aria-label="召回路线"
-          options={RECALL_MODES.map(item => ({ value: item.id, label: item.label }))} />
-      </div>
       <label>召回 topK
-        <Input type="number" min={1} max={50} value={topK} disabled={busy}
-          onChange={event => setTopK(Math.max(1, Math.min(50, Number(event.target.value) || 1)))} />
+        <Input type="number" min={1} max={50} value={topKDraft} disabled={busy}
+          onChange={event => setTopKDraft(event.target.value)}
+          onBlur={commitTopK}
+          onKeyDown={event => { if (event.key === 'Enter') commitTopK() }} />
       </label>
       <label>上下文 topN
-        <Input type="number" min={1} max={topK} value={Math.min(topN, topK)} disabled={busy}
-          onChange={event => setTopN(Math.max(1, Math.min(topK, Number(event.target.value) || 1)))} />
+        <Input type="number" min={1} max={topK} value={topNDraft} disabled={busy}
+          onChange={event => setTopNDraft(event.target.value)}
+          onBlur={commitTopN}
+          onKeyDown={event => { if (event.key === 'Enter') commitTopN() }} />
       </label>
     </div>}
     {error && <p className={cn(styles.kbNotice, styles.kbNoticeError)} role="alert">{error}</p>}
@@ -866,7 +868,7 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         但这枚 chip 不能删 —— 它是从单路视角回到合并视角的唯一入口。
       */}
       <button type="button" className={cn(styles.filterChip, routeView === 'all' && styles.filterChipOn)}
-        title={`全部：三路去重融合后的命中列表（这次 ${fusedCount} 条候选，重排留下 ${result?.hits.length ?? 0} 条）`}
+        title={`全部：四路去重融合后的命中列表（这次 ${fusedCount} 条候选，重排留下 ${result?.hits.length ?? 0} 条）`}
         onClick={() => setRouteView('all')}>
         全部
       </button>
@@ -874,7 +876,8 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         const detail = routesDetail.find(item => item.route === route.id)
         const rows = route.id === 'coordinate'
           ? result?.ledger?.coordinate ?? []
-          : route.id === 'fts' ? result?.ledger?.fts ?? [] : result?.ledger?.vector ?? []
+          : route.id === 'relation' ? result?.ledger?.relation ?? []
+            : route.id === 'fts' ? result?.ledger?.fts ?? [] : result?.ledger?.vector ?? []
         const kept = detail?.kept ?? rows.filter(row => row.kept).length
         const total = detail?.candidates ?? rows.length
         // 降级与「这一路没有候选」是两件事：前者要能一眼看出来（0031 的诚实边界）。
@@ -882,7 +885,7 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         return <button key={route.id} type="button"
           title={degraded && detail?.reason ? `${route.hint} —— ${detail.reason}` : route.hint}
           className={cn(styles.filterChip, routeView === route.id && styles.filterChipOn, degraded && styles.filterChipWarn)}
-          onClick={() => setRouteView(route.id as 'coordinate' | 'fts' | 'vector')}>
+          onClick={() => setRouteView(route.id as 'coordinate' | 'relation' | 'fts' | 'vector')}>
           {route.label} {degraded ? '降级' : `${kept}/${total}`}
         </button>
       })}
@@ -921,7 +924,8 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
           : <LedgerList
             rows={routeView === 'coordinate'
               ? result.ledger?.coordinate ?? []
-              : routeView === 'fts' ? result.ledger?.fts ?? [] : result.ledger?.vector ?? []}
+              : routeView === 'relation' ? result.ledger?.relation ?? []
+                : routeView === 'fts' ? result.ledger?.fts ?? [] : result.ledger?.vector ?? []}
             scoreLabel={row => row.score.toFixed(3)}
             droppedLabel="低于阈值"
           />}