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

package/src/client/KnowledgePanel.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useState, type ReactNode } from 'react'
 import {
   Activity, AlertCircle, BarChart3, Box, BrainCircuit, Compass, Database, FileText, HardDrive,
-  Layers3, History, Settings2, Stethoscope, Workflow, Wrench, X, Zap,
+  Layers3, History, Settings2, Stethoscope, Wrench, X, Zap,
 } from '@tita-agent/ui/icons'
 import type { LucideIcon } from '@tita-agent/ui/icons'
 import { Badge, Button, Card, Tabs, TabsContent, TabsList, TabsTrigger, cn } from '@tita-agent/ui/components'
@@ -22,7 +22,6 @@ import { PROBLEM_DOMAINS } from './problem-domains.ts'
 import { AttributionTab } from './attribution/AttributionTab.tsx'
 import { KnowledgeBaseTab } from './KnowledgeBaseTab.tsx'
 import { OperationLogTab } from './OperationLogTab.tsx'
-import { IntentTab } from './IntentTab.tsx'
 import { RecallPanel } from './RecallPanel.tsx'
 import { InfoHint } from './InfoHint.tsx'
 import { readRemembered, remember } from './panel-state.ts'
@@ -55,7 +54,6 @@ type Selection = NodeId | null
  */
 const VIEWS: Record<ViewId, { label: string; icon: LucideIcon }> = {
   overview: { label: 'Agent 概览', icon: Layers3 },
-  intent: { label: '意图', icon: Workflow },
   knowledge: { label: '知识库', icon: Database },
   attribution: { label: '智能归因', icon: Stethoscope },
   memory: { label: '记忆', icon: BrainCircuit },
@@ -63,14 +61,13 @@ const VIEWS: Record<ViewId, { label: string; icon: LucideIcon }> = {
   operations: { label: '操作日志', icon: History },
 }
 
-const VIEW_ORDER: ViewId[] = ['overview', 'intent', 'knowledge', 'attribution', 'memory', 'eval', 'operations']
+const VIEW_ORDER: ViewId[] = ['overview', 'knowledge', 'attribution', 'memory', 'eval', 'operations']
 
 /**
  * 说明入口只放在五个有完整产品说明的 Tab 上。它们统一落到一张总览页，`node` 是
  * 页面内的稳定定位键；这样说明入口不会再各自开一套孤立页面。
  */
 const TAB_GUIDE: Partial<Record<ViewId, { label: string; node: string }>> = {
-  intent: { label: '意图', node: 'intent' },
   knowledge: { label: '知识库', node: 'knowledge' },
   attribution: { label: '智能归因', node: 'attribution' },
   memory: { label: '记忆', node: 'memory' },
@@ -210,7 +207,14 @@ export function KnowledgePanel({ visible, currentQuestion, onOpenTab, settings,
   const [selectedDomain, setSelectedDomain] = useState<string | null>(null)
   const [notice, setNotice] = useState<{ tone: 'success' | 'error'; text: string } | null>(null)
   /** 从架构图节点跳到知识库分栏：tab + 一个递增的 nonce（同栏再点也要生效）。 */
-  const [knowledgeFocus, setKnowledgeFocus] = useState<{ tab: KnowledgeTab; nonce: number } | undefined>(undefined)
+  const [knowledgeFocus, setKnowledgeFocus] = useState<{
+    tab: KnowledgeTab
+    nonce: number
+    wikiEntityId?: string
+    wikiEntityType?: string
+  } | undefined>(undefined)
+  /** Attribution and Wiki inspection must read the same selected knowledge base. */
+  const [activeKnowledgeBase, setActiveKnowledgeBase] = useState<{ id: string; name: string } | null>(null)
   /** 设置抽屉入口。`null` = 关闭；否则定位到对应分组。 */
   const [settingsTarget, setSettingsTarget] = useState<KnowledgeSettingsTarget | null>(null)
   /**
@@ -374,9 +378,6 @@ export function KnowledgePanel({ visible, currentQuestion, onOpenTab, settings,
           <span className={styles.srOnly} role="status" aria-live="polite">{jumpLabel ?? ''}</span>
         </TabsContent>
 
-        <TabsContent value="intent">
-          <IntentTab visible={visible && activeTab === 'intent'} />
-        </TabsContent>
 
         {/* `forceMount`：知识库这一栏**不要在离开 tab 时卸载**。
             它有一整套已经拉回来的状态（库列表、文件、卡片、图谱、统计），而 Radix 的
@@ -388,6 +389,7 @@ export function KnowledgePanel({ visible, currentQuestion, onOpenTab, settings,
           <KnowledgeBaseTab
             visible={visible && activeTab === 'knowledge'}
             onChanged={() => void refreshStats()}
+            onActiveBaseChange={setActiveKnowledgeBase}
             {...(settings?.knowledge ? { knowledge: settings.knowledge } : {})}
             {...(knowledgeFocus ? { focus: knowledgeFocus } : {})}
             onOpenSettings={openSettings}
@@ -400,7 +402,12 @@ export function KnowledgePanel({ visible, currentQuestion, onOpenTab, settings,
           <AttributionTab
             visible={visible && activeTab === 'attribution'}
             {...(currentQuestion ? { activeQuestion: currentQuestion } : {})}
+            {...(activeKnowledgeBase ? { kbId: activeKnowledgeBase.id } : {})}
             onOpenKnowledge={() => changeTab('knowledge')}
+            onOpenWiki={card => {
+              changeTab('knowledge')
+              setKnowledgeFocus({ tab: 'wiki', nonce: Date.now(), wikiEntityId: card.entityId, wikiEntityType: card.entityType })
+            }}
           />
         </TabsContent>
 

package/src/client/OperationLogTab.tsx

@@ -6,7 +6,7 @@
  * 那一栏的四个分栏（SourceRaw / Wiki / 知识图谱 / 召回重排）是**知识链路的一段**，
  * 每一栏回答「这一段现在长什么样」。操作日志回答的是另一个问题：「**刚才那一下**
  * 到底做了什么」—— 它横着切过所有分栏（导入落在 SourceRaw、编译落在 Wiki），
- * 而且要看得出「同一次导入里文件与卡片的关系」。所以它跟 意图 / 记忆 / 评测 并列，
+ * 而且要看得出「同一次导入里文件与卡片的关系」。所以它跟 记忆 / 评测 并列，
  * 是**时间轴上的账本**，不是链路上的一个工位。
  *
  * ## 一次操作一条，明细在条目里

package/src/client/RecallPanel.tsx

@@ -10,7 +10,7 @@
  */
 
 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 { ArrowRight, ArrowUpDown, CircleHelp, GitBranch, Layers3, Play, Search, Shapes } from '@tita-agent/ui/icons'
 import { Button, Card, Input, cn } from '@tita-agent/ui/components'
 import { ExpansionGraph } from './ExpansionGraph.tsx'
 import { requestJson } from './request.ts'
@@ -91,7 +91,6 @@ export interface QueryAxisMatchView {
 
 export interface QueryAnalysisView {
   query: string
-  intent: { id: string; confidence: number }
   axes: Record<QueryAxisKind, QueryAxisMatchView[]>
   coordinates: Array<{ cardKey: string; score: number; matchedAxes: QueryAxisKind[] }>
   unresolved: QueryAxisKind[]
@@ -134,7 +133,7 @@ export interface RecallResultView {
   abstention?: string
   diagnosticsReason?: string
   encoder?: { ok: boolean; reason?: string }
-  /** 本次查询的意图与 OAS 解析结果。 */
+  /** 本次查询的 Object / Action / Scene 坐标解析结果。 */
   queryAnalysis?: QueryAnalysisView
   hits: RecallHitView[]
   context: ContextItemView[]
@@ -197,20 +196,15 @@ export function LedgerList({ rows, scoreLabel, droppedLabel, emptyLabel }: {
   </ul>
 }
 
-const QUERY_INTENT_LABEL: Record<string, string> = {
-  lookup: '查事实', explain: '解释概念', procedure: '执行步骤', troubleshoot: '排查问题', compare: '比较差异', unknown: '未识别',
-}
-
 const QUERY_AXIS_LABEL: Record<QueryAxisKind, string> = { object: 'Object', action: 'Action', scene: 'Scene' }
 
-/** 运行时查询解析：把「意图」与坐标轴放在召回发生的位置，不和会话审计记录混为一谈。 */
+/** 运行时解析当前查询中的 Object、Action、Scene 坐标。 */
 export function QueryAnalysisSummary({ analysis }: { analysis: QueryAnalysisView }): ReactNode {
   const axisKinds: QueryAxisKind[] = ['object', 'action', 'scene']
   const matchedCount = axisKinds.reduce((total, kind) => total + analysis.axes[kind].length, 0)
-  return <section className={styles.recallAnalysis} aria-label="本次查询意图识别">
+  return <section className={styles.recallAnalysis} aria-label="本次查询坐标解析">
     <div className={styles.recallAnalysisHead}>
-      <div className={styles.recallAnalysisTitle}><BrainCircuit size={13} /><div><h4>意图识别</h4><span>Query → Intent + Object / Action / Scene</span></div></div>
-      <span className={styles.recallAnalysisIntent}>{QUERY_INTENT_LABEL[analysis.intent.id] ?? analysis.intent.id}<b>{analysis.intent.confidence.toFixed(2)}</b></span>
+      <div className={styles.recallAnalysisTitle}><GitBranch size={13} /><div><h4>坐标解析</h4><span>Query → Object / Action / Scene</span></div></div>
     </div>
     <div className={styles.recallAnalysisAxes}>
       {axisKinds.map(kind => {
@@ -537,7 +531,6 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
         }
         queryAnalysis?: {
           query?: string
-          intent?: { id?: string; confidence?: number }
           axes?: Partial<Record<QueryAxisKind, QueryAxisMatchView[]>>
           coordinates?: Array<{ cardKey?: string; score?: number; matchedAxes?: QueryAxisKind[] }>
           unresolved?: QueryAxisKind[]
@@ -557,10 +550,6 @@ export function RecallPanel({ kbId, kbName, visible, variant = 'recall', default
       const data = payload.data ?? {}
       const queryAnalysis: QueryAnalysisView | undefined = data.queryAnalysis === undefined ? undefined : {
         query: data.queryAnalysis.query ?? trimmed,
-        intent: {
-          id: data.queryAnalysis.intent?.id ?? 'unknown',
-          confidence: Number(data.queryAnalysis.intent?.confidence ?? 0),
-        },
         axes: {
           object: data.queryAnalysis.axes?.object ?? [],
           action: data.queryAnalysis.axes?.action ?? [],

package/src/client/TabGuide.tsx

@@ -71,11 +71,7 @@ interface GuideNode {
 /** 与服务端抽取提示词共用同一份固定坐标契约，页面不再维护第二份文案。 */
 const AXIS_JUDGMENT_PROMPT = AXIS_CONTRACT_LINES.join('\n')
 
-const TAB_SECTIONS: Record<'intent' | 'attribution' | 'memory' | 'eval', GuideSection[]> = {
-  intent: [
-    { title: '它解决什么问题', points: ['把“用户想做什么”从聊天文本中单独提出来。', '意图记录保留置信度、槽位和来源，方便复盘，不直接代替业务控制流。'] },
-    { title: '与其他模块怎么协作', points: ['意图会参与知识召回和上下文组织，帮助系统判断哪些内容相关。', '它是检索的输入之一；坐标、关键词和向量仍然共同决定召回结果。'] },
-  ],
+const TAB_SECTIONS: Record<'attribution' | 'memory' | 'eval', GuideSection[]> = {
   attribution: [
     { title: '它解决什么问题', points: ['不是只给出“可能原因”，而是保留从现象到结论的证据链。', '每次排查是一条 Event，Event 可以关联 SourceRaw、Knowledge 和 WikiCard。'] },
     { title: '具体步骤', points: ['记录异常症状与影响范围。', '调用知识召回和数据工具，生成候选原因与排查动作。', '把检查结果、证据和结论写入 Event，保留可回放的关系链。'] },
@@ -103,7 +99,7 @@ const CONCEPT_GUIDES: GuideNode[] = [
           { label: 'Document', text: '来源。保存原文、事实和出处，是后续抽取与追溯的依据。' },
           { label: 'Knowledge', text: '可复用内容。一条可独立检索、验证或执行的最小知识单元。' },
           { label: 'Event', text: 'Knowledge 的一次使用或验证。记录实际过程、结果、证据和反馈。' },
-          { label: 'WikiCard', text: 'Knowledge 的坐标化组织。按 Object × Action × Scene 组织和交付，坐标是主键，标题只是可读名称。' },
+          { label: 'WikiCard', text: 'Knowledge 的坐标化组织。按 Object × Action × Scene 分别组织 Wiki Fact、Wiki Way，完整坐标与类型共同确定身份。相关文件通过双链按需读取。' },
         ],
       },
       {
@@ -193,7 +189,7 @@ const COMPILE_PROMPT_SECTIONS: GuideSection[] = [
   },
 ]
 
-const ARCHITECTURE_SECTIONS: Partial<Record<NodeId, GuideSection[]>> = { intent: TAB_SECTIONS.intent, compile: COMPILE_PROMPT_SECTIONS }
+const ARCHITECTURE_SECTIONS: Partial<Record<NodeId, GuideSection[]>> = { compile: COMPILE_PROMPT_SECTIONS }
 
 const ARCHITECTURE_GUIDES: GuideNode[] = NODE_ORDER.map((id): GuideNode => {
   const meta = NODE_META[id]

package/src/client/WikiFlowPanel.tsx

@@ -249,14 +249,13 @@ const RECALL_STAGES: RecallStage[] = [
     id: 'parse',
     icon: FileText,
     tone: 'violet',
-    name: '意图识别',
-    io: 'User Query → Intent + Object / Action / Scene',
+    name: '坐标解析',
+    io: 'User Query → Object / Action / Scene',
     body: [
-      '从 User Query 识别用户要完成的事，再用 Axis Registry 的 canonical 名称和 alias 解析 Object、Action、Scene。',
+      '用 Axis Registry 的 canonical 名称和 alias 解析 Object、Action、Scene。',
       '解析结果保留标准 id、置信度和歧义候选；匹配不唯一时不猜，未解析的原文仍交给关键词和向量路线。',
-      '`Intent` 表示用户要完成的事，例如查原因、核事实、回顾历史或执行修复；它不是 Coordinate 的第四个分量。',
     ],
-    boundary: '解析失败不应让结果归零。坐标首先是排序信号，只有高置信度且明确要求时才考虑硬过滤。',
+    boundary: '解析失败不应让结果归零。坐标补充候选，未解析的原文继续进入关键词、向量和重排。',
   },
   {
     id: 'candidate',
@@ -276,13 +275,13 @@ const RECALL_STAGES: RecallStage[] = [
     icon: GitBranch,
     tone: 'violet',
     name: 'Coordinate Card 召回',
-    io: 'Intent + Object / Action / Scene → Wiki Card → 候选 Section',
+    io: 'Object / Action / Scene → Wiki Card → 候选 Section',
     body: [
-      '高置信度识别出 OAS 后，直接找到对应 Wiki Card，再把 Card 拆成候选 Section。',
+      '高置信度识别出 OAS 后，找到对应 Wiki Card，再把 Card 拆成候选 Section。',
       '匹配不唯一时保留多个坐标候选；Coordinate 是强先验，不直接替代 Section 重排。',
       'Coordinate 路、FTS 路和 Vector 路最终都统一成 Section 候选，才能使用同一套重排逻辑。',
     ],
-    boundary: 'Coordinate 是三个轴 id 的复合键，不是第四个实体；Intent 决定任务目标，不是坐标第四维。',
+    boundary: 'Coordinate 是三个轴 id 的复合键；空轴不会被猜成通用范围。',
   },
   {
     id: 'merge',
@@ -304,7 +303,7 @@ const RECALL_STAGES: RecallStage[] = [
     name: 'Section 统一重排',
     io: '统一候选 Section → Top K Section',
     body: [
-      '用 Cross-Encoder 判断 Query 与 Section 的语义相关性，并结合 Intent、OAS 和候选路线信息排序。',
+      '用 Cross-Encoder 判断 Query 与 Section 的语义相关性，并结合坐标解析结果排序。',
       '重排对象是 Section，不是整张 Card；这样每条结果都能说明“具体命中了哪一章”。',
       '先取足够大的 `sectionTopK`，再按 Card 归并，避免同一张 Card 占满最终结果。',
     ],
@@ -352,8 +351,8 @@ const COMPILE_PIPELINE: PipelineGroup[] = [
 ]
 
 const RECALL_PIPELINE: PipelineGroup[] = [
-  { id: 'intent', title: '意图识别', input: 'User Query', output: 'Intent / OAS', tone: 'violet', stageIds: ['parse'] },
-  { id: 'candidate-recall', title: '三路候选生成', input: 'Intent / OAS', output: 'Card + Section 候选', tone: 'blue', stageIds: ['coordinate', 'candidate'] },
+  { id: 'coordinate-parse', title: '坐标解析', input: 'User Query', output: 'Object / Action / Scene', tone: 'violet', stageIds: ['parse'] },
+  { id: 'candidate-recall', title: '三路候选生成', input: 'Query + 坐标', output: 'Card + Section 候选', tone: 'blue', stageIds: ['coordinate', 'candidate'] },
   { id: 'section-merge', title: 'Section 候选归并', input: '三路候选', output: '统一 Section 池', tone: 'violet', stageIds: ['merge'] },
   { id: 'section-rerank', title: 'Section 统一重排', input: '统一 Section 池', output: 'Top K Section', tone: 'green', stageIds: ['rerank'] },
   { id: 'card-merge', title: 'Wiki Card 归并', input: 'Top K Section', output: 'Top 5 完整 Wiki Card', tone: 'amber', stageIds: ['section'] },

package/src/client/arch/NodeLogicPanel.tsx

@@ -5,8 +5,8 @@
  * 一列：图被挤窄、面板和图各占一块表面，读起来是两件事。现在它是画布内的浮层，
  * 由 `AgentArchitectureGraph` 的 `inspector` 插槽承载，壳（边框、圆角、投影）由浮层给。
  *
- * 这里**没有设置项**，一个都没有。设置已经回到它们真正生效的地方（意图 Tab、
- * 知识库的各个分栏），面板只回答三个问题：这个节点是干什么的、它现在的数字是多少、
+ * 这里**没有设置项**，一个都没有。设置已经回到它们真正生效的地方（知识库的各个分栏），
+ * 面板只回答三个问题：这个节点是干什么的、它现在的数字是多少、
  * 它实现到哪一步，以及「要改它就去哪」。
  *
  * 空态已经撤掉：画布上不再有「未选中」这一态 —— 没选中时浮层根本不出现，
@@ -123,7 +123,7 @@ export function NodeLogicPanel({ selected, stats, version, onJump, onOpenTab, on
           ? <Button variant="default" size="sm" onClick={() => onJump(jump.tab, jump.knowledgeTab)}>
             去配置<ArrowRight size={14} />
           </Button>
-          : <p className={styles.archPanelHint}><CircleHelp size={13} />这个节点没有可配置页：{meta.status === 'host' ? '它由宿主提供' : meta.status === 'planned' ? '它还没实现，先在这里说明设计意图' : '它的行为由代码决定，没有可调参数'}。</p>}
+          : <p className={styles.archPanelHint}><CircleHelp size={13} />这个节点没有可配置页：{meta.status === 'host' ? '它由宿主提供' : meta.status === 'planned' ? '它还没实现，当前只记录设计方案' : '它的行为由代码决定，没有可调参数'}。</p>}
         {(selected === 'answer' || selected === 'data-sheet' || selected === 'data-canvas') && onOpenTab && <div className={styles.archPanelActions}>
           <Button variant="outline" size="sm" onClick={() => onOpenTab('data-sheet')}><ChevronRight size={13} />打开 Table</Button>
           {/* 画布与 Table 并列，都是可编辑的工作区产物。 */}

package/src/client/arch/model.ts

@@ -94,7 +94,7 @@ export const LANE_HEAD_H = 30
  * 带名条**只占自己内容的宽度**，不铺满整条带。
  *
  * 铺满的话它就是一块横贯全图的障碍物，垂直的跨链路走线只能绕到它的左边或右边 ——
- * 「记忆质量检查 → 意图」本来要从「编译」与「构建」之间的列缝里直穿 B 带，
+ * 一条跨链路反馈本来要从「编译」与「构建」之间的列缝里直穿 B 带，
  * 被逼成「上、左、上、右」四段绕行，而且正好从带名文字上穿过去。缩成一块牌子之后，
  * 垂直走线从牌子右边自由通过。
  */
@@ -206,7 +206,6 @@ interface Slot { lane: number; col: number; /** 在竖排里的序号（0 起）
 
 export const ARCH_SLOTS: Record<NodeId, Slot> = {
   conversation: { lane: 0, col: 0 },
-  intent: { lane: 0, col: 1 },
   runtime: { lane: 0, col: 2 },
   answer: { lane: 0, col: 3 },
   'data-sheet': { lane: 0, col: 4, stack: 0 },
@@ -279,8 +278,7 @@ export interface ArchEdge {
  */
 export const ARCH_EDGES: ArchEdge[] = [
   // A · 用户操作链路
-  { id: 'a1', source: 'conversation', target: 'intent', kind: 'flow' },
-  { id: 'a2', source: 'intent', target: 'runtime', kind: 'flow' },
+  { id: 'a1', source: 'conversation', target: 'runtime', kind: 'flow' },
   { id: 'a3', source: 'runtime', target: 'answer', kind: 'flow' },
   { id: 'a4', source: 'answer', target: 'data-sheet', kind: 'branch' },
   // 画布与 Table 是同一格的两种可编辑输出产物。
@@ -312,7 +310,6 @@ export const ARCH_EDGES: ArchEdge[] = [
    * 「记忆自己就能变成卡片」，那正是它不该说的话。
    */
   { id: 'x2', source: 'daily-update', target: 'source-raw', kind: 'feedback', label: '沉淀进知识库' },
-  { id: 'x3', source: 'memory-quality', target: 'intent', kind: 'feedback', label: '反馈到意图理解' },
   { id: 'x4', source: 'context', target: 'runtime', kind: 'inject', label: 'Agent Context 返回' },
 ]
 
@@ -333,7 +330,7 @@ export const ARCH_EDGES: ArchEdge[] = [
  * 反过来若按「`branch` 就走总线」写，多对一的那种（情节 / 操作记忆 → 记忆质量检查，
  * 那是两条 `flow`）就漏了，而它们看着是同一毛病。
  *
- * 跨链路的四条长线不在这里：它们不同带，本来就有自己的正交路由与避障。
+ * 跨链路的长线不在这里：它们不同带，本来就有自己的正交路由与避障。
  */
 const BUS_EDGE_IDS: ReadonlySet<string> = (() => {
   const local = ARCH_EDGES.filter(edge => {
@@ -386,103 +383,6 @@ export function busControlPoints(edge: ArchEdge): Array<[number, number]> | null
   return [[trunkX, from.y], [trunkX, to.y]]
 }
 
-// ----------------------------------------------------------------- 手工走线的跨链路边
-
-/**
- * 跨链路边里**唯一一条自己给拐点的**：「记忆质量检查 → 意图」。
- *
- * ## 为什么其余三条不用管（2026-10-05 实测）
- *
- * 四条跨链路边都交给 G6 的正交路由器（`shortest-path` + `enableObstacleAvoidance`）。
- * 那个「避障」**看不见这张图的卡片**：卡片是 HTML 节点（`cardHtml` 产出的是 DOM），
- * 路由器手里只有它自己认得的图形。另外三条碰巧走到了空处 —— 实测的走线是：
- * 回答 → 用户交互绕到最右侧外圈、每日更新 → SourceRaw 走 B 带下沿、
- * 重排 → Runtime 走 A/B 带之间的通道，三段都不压卡片。
- *
- * 「记忆质量检查 → 意图」不走运：它的最短路径是「从卡片正上方升到目标那一行，再横着
- * 进目标」。那条竖线从「构建」直穿到「Agent Runtime」—— 两张卡把它中间的两段挡住，
- * 屏幕上剩下的是一条断线；而剩下的那一头正好落在「意图与上下文」的**右边**，
- * 与带内流量「意图 → Runtime」的箭头合成一对左右箭头，读起来像两个节点在互相指。
- *
- * ## 这条路怎么走
- *
- * 两个判断：
- * 1. **竖着走 1/2 列之间的列缝**（`columnGapX`）。列缝是带内唯一不压卡片的纵向通道；
- *    从「记忆质量检查」的左边出去、贴着列缝升到 A/B 带之间的通道，全程没有一张卡。
- * 2. **从下方进入「意图与上下文」**。带内流量已经从它的右边出去了，回程走它的下边 ——
- *    两条线各占一条边，那对左右箭头就不会再出现。
- */
-interface CrossRoute {
-  controlPoints: Array<[number, number]>
-  /** 标签压在第几段的中点（0 起）。这一段上不许有卡片 —— 标签带白底，压上去就是糊掉一张卡。 */
-  labelSegment: number
-}
-
-const CROSS_ROUTES: Record<string, CrossRoute> = {
-  x3: {
-    controlPoints: [
-      /* 1. 出「记忆质量检查」的左边，落到 1/2 列缝上（与源节点同高 → 出口在左边中点）。 */
-      [columnGapX(1), laneCenter(2)],
-      /* 2. 沿列缝升到 A/B 带之间的通道。 */
-      [columnGapX(1), laneGapY(0)],
-      /* 3. 在通道里横着走到「意图与上下文」正下方（与目标同 x → 箭头落在下边中点）。 */
-      [columnX(1), laneGapY(0)],
-    ],
-    /* 通道那一段（第 2 段）没有卡片，标签放它中点。 */
-    labelSegment: 2,
-  },
-}
-
-/** 射线（节点中心 → 目标点）与节点盒子边界的交点 —— 与 G6 取两端出口的规则一致。 */
-function boundaryOf(id: NodeId, toward: [number, number]): [number, number] {
-  const box = boxOf(id)
-  const dx = toward[0] - box.x
-  const dy = toward[1] - box.y
-  const scale = Math.min(
-    dx === 0 ? Number.POSITIVE_INFINITY : (box.width / 2) / Math.abs(dx),
-    dy === 0 ? Number.POSITIVE_INFINITY : (box.height / 2) / Math.abs(dy),
-  )
-  return [box.x + dx * scale, box.y + dy * scale]
-}
-
-/**
- * 一条走线的**完整折线**：首尾是节点边界点（G6 自己算的那两个点），中间是拐点。
- *
- * 它只服务一件事 —— 算标签的弧长比例。绘制用的仍然只有 `controlPoints`：两端由 G6 取，
- * 我们复算一遍是为了知道标签会落在哪一段上。
- */
-export function routePoints(edge: Pick<ArchEdge, 'source' | 'target'>, controlPoints: Array<[number, number]>): Array<[number, number]> {
-  return [
-    boundaryOf(edge.source, controlPoints[0]),
-    ...controlPoints,
-    boundaryOf(edge.target, controlPoints[controlPoints.length - 1]),
-  ]
-}
-
-/**
- * 折线第 `segment` 段中点对应的弧长比例（0..1），给 G6 的 `labelPlacement`。
- *
- * 为什么不用默认的中点：G6 把标签摆在**弧长中点**上，而跨链路走线的中点常常正好落在
- * 卡片行上（竖线最长，它的中点就在卡片高度上）。标签带白底，压上去就是把一张卡片糊掉一块。
- */
-export function labelRatioOf(points: Array<[number, number]>, segment: number): number {
-  const lengths = points.slice(1).map((point, index) =>
-    Math.hypot(point[0] - points[index]![0], point[1] - points[index]![1]))
-  const total = lengths.reduce((sum, value) => sum + value, 0)
-  const before = lengths.slice(0, segment).reduce((sum, value) => sum + value, 0)
-  return (before + lengths[segment]! / 2) / total
-}
-
-/** 这个 id 的跨链路边是否有手工走线。测试与 `toGraphData` 读同一个判据。 */
-export function crossRouteOf(edge: Pick<ArchEdge, 'id' | 'source' | 'target'>): { controlPoints: Array<[number, number]>; labelPlacement?: number } | null {
-  const route = CROSS_ROUTES[edge.id]
-  if (!route) return null
-  return {
-    controlPoints: route.controlPoints,
-    labelPlacement: labelRatioOf(routePoints(edge, route.controlPoints), route.labelSegment),
-  }
-}
-
 /**
  * 边的外观。灰 / 蓝两档，没有第三档色相。
  *
@@ -833,16 +733,8 @@ export function toGraphData(stats: KnowledgeStats, version: number, selected: No
       endArrow: true, endArrowType: 'triangle', endArrowSize: 8,
     }
     if (CROSS_LANE.includes(edge.kind)) {
-      const route = crossRouteOf(edge)
       style.radius = 10
-      if (route) {
-        // 手工走线的那一条：拐点是我们算的，**不要路由器**（见 `CROSS_ROUTES` 那段说明）。
-        style.controlPoints = route.controlPoints
-        if (route.labelPlacement !== undefined) style.labelPlacement = route.labelPlacement
-      } else {
-        // 其余三条：正交路由 + 自动避障。它们实测都走在空处（见 `CROSS_ROUTES` 那段说明）。
-        style.router = { type: 'shortest-path', enableObstacleAvoidance: true, offset: 14, gridSize: 8 }
-      }
+      style.router = { type: 'shortest-path', enableObstacleAvoidance: true, offset: 14, gridSize: 8 }
     } else if (busControlPoints(edge) !== null) {
       // 总线上的边：拐点是我们算的，**不要路由器** —— 路由器每条边各找一个出口，
       // 那正是「三根箭头从三个高度出来、各自还带一个小台阶」的原因。
@@ -938,7 +830,7 @@ export function recordRows(id: NodeId, stats: KnowledgeStats, version: number):
       rows.push(['模型 / 设备', `${stats.embeddingModel ?? '本地 embedding'} · ${stats.embeddingDevice ?? 'auto'}`])
       break
     case 'interaction':
-      rows.push(['意图审计流', '每轮一条 intent 记录（只标注不拦截）'])
+      rows.push(['交互采集', '待实现'])
       rows.push(['memory/ 落盘', `${memoryCountOf(stats)} 个文件`])
       break
     case 'episodic-memory':

package/src/client/architecture.css

@@ -11,7 +11,7 @@
    读法在带名、卡片状态字与浮层正文里，画布上不留说明板。
 
    这个文件跟着架构视图走，不并进插件通用 styles.css：它是「一张图 + 一个
-   浮层」的版式，和知识库 / 意图 / 记忆那些卡片页没有共同词汇。
+   浮层」的版式，和知识库 / 记忆那些卡片页没有共同词汇。
    ===================================================================== */
 
 /* ---------------------------------------------------------------- 版式 */

package/src/client/architecture.tsx

@@ -25,7 +25,7 @@ import type { LucideIcon } from '@tita-agent/ui/icons'
 export type Tone = 'blue' | 'violet' | 'green' | 'amber' | 'neutral'
 
 /** 面板的一级 tab。`KnowledgePanel` 的 `ViewId` 就是它，避免两处各写一个联合。 */
-export type PanelTab = 'overview' | 'intent' | 'knowledge' | 'attribution' | 'memory' | 'eval' | 'operations'
+export type PanelTab = 'overview' | 'knowledge' | 'attribution' | 'memory' | 'eval' | 'operations'
 
 /**
  * 知识库内部的分栏。**每一栏都对着知识链路上的一段**：链路有五个节点，界面有四个
@@ -74,11 +74,11 @@ export type WorkspaceTabKind = 'data-sheet' | 'data-excalidraw'
  */
 export const KNOWLEDGE_TABS: Array<{ id: KnowledgeTab; label: string; step: string; icon: LucideIcon }> = [
   { id: 'source-raw', label: 'SourceRaw', step: '收录', icon: Database },
-  /* Knowledge 与 Event 都是抽取真源，放在同一栏用二级切换区分；两者都属于 Extract 与 Resolve。 */
-  { id: 'knowledge', label: 'Knowledge & Event', step: '抽取 · 归一', icon: Quote },
-  /* WikiCard 这一栏现在只回答一件事：**这些知识被组织成了哪些页**（Materialize）。
+  /* Fact、Procedure 与 Case 都是 Knowledge 层内容，在同一栏用二级切换区分。 */
+  { id: 'knowledge', label: 'Knowledge', step: '抽取 · 归一', icon: Quote },
+  /* Wiki 这一栏现在只回答一件事：**这些知识被组织成了哪些页**（Materialize）。
      构建（向量 + 图谱）没有自己的栏，它的参数 chip 挂在这一栏的卡片头上。 */
-  { id: 'wiki', label: 'WikiCard', step: '物化', icon: Layers3 },
+  { id: 'wiki', label: 'Wiki', step: '物化', icon: Layers3 },
   { id: 'recall', label: '召回重排', step: '检索 · 精排', icon: Search },
 ]
 
@@ -107,7 +107,7 @@ export const NODE_LANES: LaneMeta[] = [
 ]
 
 export type NodeId =
-  | 'conversation' | 'intent' | 'runtime' | 'answer' | 'data-sheet' | 'data-canvas'
+  | 'conversation' | 'runtime' | 'answer' | 'data-sheet' | 'data-canvas'
   | 'source-raw' | 'compile' | 'build' | 'recall' | 'context'
   | 'interaction' | 'episodic-memory' | 'procedural-memory' | 'memory-quality' | 'daily-update'
 
@@ -199,25 +199,11 @@ export const NODE_META: Record<NodeId, NodeMeta> = {
     ],
     status: 'host', statusNote: '对话入口由宿主（DSH Web）提供，本插件不实现它，只在链路里标明位置。',
 icon: MessageCircle, lane: 'interaction',
-  },
-  intent: {
-    title: '意图与上下文', subtitle: '会话意图审计 + 召回查询意图 / OAS',
-    detail: '会话层记录 category、act 与任务链路；知识召回层对当前 Query 解析 Intent、Object、Action、Scene，二者分别服务审计和候选生成。',
-    input: '用户原文 + 会话 + 当前 Query', output: 'intent 记录 + Query Analysis（Intent / OAS）',
-    steps: [
-      { label: '固定审计契约', detail: '按内置分类、act 与 relation 规则记录会话事实', state: 'done' },
-      { label: '数据域门控', detail: '只有标准模式的数据轮次进入意图链路，普通聊天不生成记录', state: 'done' },
-      { label: '记录不拦截执行', detail: '模型无法判定时记录 unknown，不阻塞后续请求；非数据轮次不补记录', state: 'done' },
-      { label: '置信度与兜底', detail: '低于阈值的记录标 lowConfidence；数据轮次漏调由 Host 补一条 fallback', state: 'done' },
-      { label: '召回侧解析', detail: '当前 Query 解析 Intent + Object / Action / Scene，交给 Coordinate 路', state: 'done' },
-    ],
-    status: 'live', statusNote: '会话意图记录已落盘；召回侧 Query Analysis 在知识库 → 召回重排中实时展示。',
-icon: BrainCircuit, lane: 'interaction', tab: 'intent',
   },
   runtime: {
     title: 'Tita Agent Runtime', shortTitle: 'Agent Runtime', subtitle: '规划、调用工具、执行分析',
     detail: 'Agent 核心运行时：编排知识召回、数据表格和自进化记忆，组织结果并返回给用户。',
-    input: '意图与上下文 + 召回得到的知识', output: '回答、引用、结构化数据',
+    input: '会话上下文 + 召回得到的知识', output: '回答、引用、结构化数据',
     steps: [
       { label: '接收 Agent Context', detail: '重排后的 Section 归并为完整 WikiCard，连同 Knowledge 与 Source provenance 返回', state: 'done' },
       { label: '调用工具', detail: '取数、表格、知识写入都由工具完成', state: 'done' },
@@ -296,14 +282,14 @@ icon: HardDrive, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'wiki',
   },
   recall: {
     title: '召回', subtitle: '三路 Section 候选（Coordinate / FTS / Vector）',
-    detail: '先解析 Query 的 Intent 与 Object / Action / Scene，再由 Coordinate、FTS、Vector 三路生成 Section 候选；图谱不参与候选生成。',
+    detail: '解析 Query 中的 Object / Action / Scene，再由 Coordinate、FTS、Vector 三路生成 Section 候选；图谱不参与候选生成。',
     input: 'User Query + topK + 路线', output: '统一 Section 候选池',
     steps: [
       { label: '三路候选生成', detail: 'Coordinate 由 Card 展开 Section；FTS / Vector 直接召回 Section', state: 'done' },
       { label: 'Section 归并', detail: '三路统一成同一个 Section 候选池，保留命中路线与分数', state: 'done' },
       { label: '交给统一重排', detail: '同一套 Section 排序逻辑，不在召回阶段提前合并 Card', state: 'done' },
     ],
-    status: 'live', statusNote: '意图识别、三路候选和路线账本都在知识库 → 召回重排里可跑。',
+    status: 'live', statusNote: '坐标解析、三路候选和路线账本都在知识库 → 召回重排里可跑。',
 icon: Search, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'recall',
   },
   context: {
@@ -322,12 +308,12 @@ icon: Layers3, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'recall',
   interaction: {
     title: '用户与 Agent 交互', shortTitle: '用户交互', subtitle: '对话、分析、使用功能的全过程',
     detail: '记录用户做了什么、采用了什么结果，以及对分析结果的反馈，为自进化闭环提供输入。',
-    input: '每一轮的意图记录与工具调用', output: '可回溯的交互审计流',
+    input: '用户对话与工具调用', output: '可回溯的交互审计流',
     steps: [
-      { label: '意图审计流', detail: '每个数据轮次一条 intent 记录，只标注不拦截', state: 'done' },
+      { label: '工具操作日志', detail: '记录真实的数据读取、修改与交付结果', state: 'done' },
       { label: '结果采纳与反馈', detail: '用户是否采用了结果、事后评价还没采集', state: 'todo' },
     ],
-    status: 'partial', statusNote: '意图记录已经是一条真实的审计流；「结果是否被采用」这类反馈还没有采集入口。',
+    status: 'partial', statusNote: '工具操作日志已经落盘；「结果是否被采用」这类反馈还没有采集入口。',
 icon: UserRound, lane: 'evolution', tab: 'memory',
   },
   'episodic-memory': {
@@ -523,7 +509,7 @@ export function metricsByNode(stats: KnowledgeStats, version: number): Partial<R
 
 /** 节点在图上出现的顺序：按链路，再按链内阅读顺序。它就是键盘可达列表的顺序。 */
 export const NODE_ORDER: NodeId[] = [
-  'conversation', 'intent', 'runtime', 'answer', 'data-sheet', 'data-canvas',
+  'conversation', 'runtime', 'answer', 'data-sheet', 'data-canvas',
   'source-raw', 'compile', 'build', 'recall', 'context',
   'interaction', 'episodic-memory', 'procedural-memory', 'memory-quality', 'daily-update',
 ]