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

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/PipelineRunView.tsx

@@ -0,0 +1,173 @@
+import { useEffect, useRef, useState, type ReactNode } from 'react'
+import { Badge, Button } from '@tita-agent/ui/components'
+import { Progress } from '@tita-agent/ui/ui/progress'
+import { Activity, AlertCircle, Check, Clock3, ExternalLink, LoaderCircle, Pause, Play, X } from '@tita-agent/ui/icons'
+import { openAppPath } from '@tita-agent/ui/overlays'
+import { PIPELINE_ACTIVE_STATES, PIPELINE_STAGE_LABEL, PIPELINE_STAGE_ORDER, type PipelineActivity, type PipelineEvent, type PipelineTask, type PipelineWorkStage } from '../pipeline/types.js'
+import { PIPELINE_STATE_LABEL } from '../pipeline/progress.js'
+import { requestJson } from './request.ts'
+import { formatDateTime } from './format.ts'
+
+const ACTIVITY_LABEL: Record<PipelineActivity['phase'], string> = {
+  preparing: '正在准备', processing: '正在处理', 'waiting-model': '等待模型返回', receiving: '正在接收模型输出',
+  validating: '正在校验结果', saving: '正在保存结果', retrying: '等待自动重试', splitting: '正在拆分长分片',
+  reused: '已复用保存结果', completed: '已保存结果', failed: '有未完成内容',
+}
+
+/** Keep observing even when raw output is collapsed. A failed read preserves the last snapshot. */
+export function useTaskFeed(kb: string, id: string | undefined, onTask: (task: PipelineTask) => void): { events: PipelineEvent[]; failure: string } {
+  const [feed, setFeed] = useState<{ id?: string; events: PipelineEvent[]; failure: string }>({ events: [], failure: '' })
+  const callback = useRef(onTask)
+  callback.current = onTask
+  useEffect(() => {
+    if (!id) return
+    let active = true, busy = false, cursor = 0, terminal = false
+    setFeed({ id, events: [], failure: '' })
+    const read = async (): Promise<void> => {
+      if (busy || terminal) return
+      busy = true
+      try {
+        let more = true
+        while (active && more) {
+          const result = await requestJson<{ task: PipelineTask; events: PipelineEvent[]; next: number; hasMore: boolean }>(`/knowledge/pipeline-task?${new URLSearchParams({ kb, id, after: String(cursor) })}`)
+          if (!active) return
+          if (!result.data) throw new Error('任务响应缺少数据')
+          const page = result.data
+          cursor = page.next
+          more = page.hasMore
+          terminal = !more && !PIPELINE_ACTIVE_STATES.includes(page.task.state)
+          callback.current(page.task)
+          setFeed(current => {
+            const all = [...(current.id === id ? current.events : []), ...page.events]
+            // Streaming output must not evict all meaningful activity and warning events.
+            const keep = new Set([...all.filter(event => event.kind === 'output').slice(-600), ...all.filter(event => event.kind !== 'output').slice(-150)].map(event => event.seq))
+            return { id, events: all.filter(event => keep.has(event.seq)), failure: '' }
+          })
+        }
+      } catch (cause) { if (active) setFeed(current => ({ ...current, id, failure: cause instanceof Error ? cause.message : String(cause) })) }
+      finally { busy = false }
+    }
+    void read()
+    const timer = window.setInterval(() => { void read() }, 1200)
+    return () => { active = false; window.clearInterval(timer) }
+  }, [kb, id])
+  return feed.id === id ? feed : { events: [], failure: '' }
+}
+
+function duration(ms: number): string {
+  const seconds = Math.max(0, Math.floor(ms / 1000))
+  return seconds < 60 ? `${seconds} 秒` : seconds < 3600 ? `${Math.floor(seconds / 60)} 分 ${seconds % 60} 秒` : `${Math.floor(seconds / 3600)} 小时 ${Math.floor(seconds / 60) % 60} 分`
+}
+
+export function RunSummary({ task, events, failure, busy, onAct, onFollow, onRecovery, following, queueCount, queuePosition, objectTitle }: {
+  task: PipelineTask; events: PipelineEvent[]; failure: string; busy: boolean
+  onAct: (id: string, action: string) => void; onFollow: () => void; onRecovery: (id: string) => void
+  following: boolean; queueCount: number; queuePosition: number; objectTitle?: string
+}): ReactNode {
+  const active = PIPELINE_ACTIVE_STATES.includes(task.state)
+  const [now, setNow] = useState(Date.now)
+  useEffect(() => {
+    setNow(Date.now())
+    if (!active) return
+    const timer = window.setInterval(() => setNow(Date.now()), 1000)
+    return () => window.clearInterval(timer)
+  }, [active, task.id])
+  const activity = task.activity
+  const lastEvent = events.at(-1)
+  const lastAt = Math.max(Date.parse(activity?.at ?? task.startedAt ?? task.queuedAt), Date.parse(lastEvent?.at ?? task.queuedAt))
+  const chunks = activity?.chunks
+  const stage = task.currentStage ?? (task.stage === 'all' ? 'extract' : task.stage)
+  const unit = stage === 'materialize' ? '个分组' : stage === 'derive' ? '个 Case' : stage === 'build' ? '次构建' : '份文档'
+  const end = task.finishedAt ? Date.parse(task.finishedAt) : now
+  const failed = ['failed', 'partial', 'interrupted'].includes(task.state)
+  const currentLabel = !active || task.state === 'paused' || task.state === 'queued' || task.state === 'pausing' || task.state === 'cancelling'
+    ? PIPELINE_STATE_LABEL[task.state] : activity ? ACTIVITY_LABEL[activity.phase] : '正在运行，详细进展见本次活动'
+  return <section className="ktCurrent" aria-label="本次任务">
+    <div className="flex flex-wrap items-start justify-between gap-3">
+      <div className="min-w-0">
+        <div className="flex flex-wrap items-center gap-2">
+          <h2 className="m-0 text-base font-semibold text-tita-ink">{task.stage === 'all' ? '全链路处理' : `仅运行${PIPELINE_STAGE_LABEL[task.stage]}`}</h2>
+          <Badge tone={failed ? 'warning' : task.state === 'succeeded' ? 'success' : active && task.state !== 'paused' ? 'blue' : 'neutral'}>
+            {active && task.state !== 'paused' && <LoaderCircle size={12} className="motion-safe:animate-spin" />}{task.state === 'succeeded' && <Check size={12} />}{PIPELINE_STATE_LABEL[task.state]}
+          </Badge>
+        </div>
+        <p className="ktCurrentScope">本次范围：{task.stage === 'build' ? '整个知识库' : task.selection.sourceIds ? `${task.selection.sourceIds.length} 份指定来源` : task.stage === 'materialize' ? '待物化分组' : '全部来源'}{task.selection.groupKeys ? ` · ${task.selection.groupKeys.length} 个指定分组` : ''} · {formatDateTime(task.startedAt ?? task.queuedAt)}{task.selection.force ? ' · 强制重跑' : ''}</p>
+      </div>
+      <div className="flex flex-wrap items-center gap-2">
+        {active && <>
+          <Button disabled={busy || task.state === 'pausing' || task.state === 'cancelling'} onClick={() => onAct(task.id, task.state === 'paused' ? 'resume' : 'pause')}>
+            {task.state === 'paused' ? <Play size={13} /> : <Pause size={13} />}{task.state === 'paused' ? '继续' : task.state === 'pausing' ? '等待暂停' : '暂停'}
+          </Button>
+          <Button variant="ghost" disabled={busy || task.state === 'cancelling'} onClick={() => onAct(task.id, 'cancel')}><X size={13} />停止</Button>
+        </>}
+        {!active && task.recoveryTaskId && <Button onClick={() => onRecovery(task.recoveryTaskId!)}>查看自动续跑<ExternalLink size={12} /></Button>}
+        {!active && !task.recoveryTaskId && task.state !== 'succeeded' && <Button disabled={busy} onClick={() => onAct(task.id, 'retry')}><Play size={13} />继续未完成部分</Button>}
+        {active && !following && task.currentStage && <Button variant="ghost" onClick={onFollow}>返回运行阶段</Button>}
+      </div>
+    </div>
+    <div className="ktCurrentWork" role="status" aria-live="polite">
+      <strong>{PIPELINE_STAGE_LABEL[stage]}{activity?.objectTitle || objectTitle ? ` · ${activity?.objectTitle ?? objectTitle}` : ''}</strong>
+      <span><Activity size={13} />{currentLabel}{activity?.attempt && activity.attempt > 1 ? ` · 第 ${activity.attempt} 次尝试` : ''}</span>
+    </div>
+    <div className="ktCurrentCounts">
+      <span>已处理 <strong>{task.done}/{task.total || '待确定'}</strong> {unit}</span>
+      <span>成功 {Math.max(0, task.done - task.failed)} · 复用 {task.reused} · 失败 {task.failed}</span>
+      {chunks && <span>分片已保存 <strong>{chunks.saved}/{chunks.total}</strong> · 复用 {chunks.reused} · 失败 {chunks.failed}{chunks.total !== chunks.initial ? ` · 初始 ${chunks.initial} 片，计划已拆分` : ''}</span>}
+    </div>
+    {(chunks?.total || task.total > 0) ? <Progress
+      value={chunks ? chunks.saved : task.done} max={chunks?.total || task.total}
+      aria-label={chunks ? '当前文档已保存分片进度' : '当前阶段已处理进度'}
+      getValueLabel={(value, max) => `${value}/${max}${chunks ? ' 片已保存' : ` ${unit}已处理`}`}
+    /> : null}
+    <div className="ktCurrentTiming">
+      <span><Clock3 size={12} />{task.startedAt ? '已用时（含暂停）' : '已等待'} {duration(end - Date.parse(task.startedAt ?? task.queuedAt))}</span>
+      {active && task.state !== 'paused' && <span>最近活动 {duration(now - lastAt)}前</span>}
+      {queueCount > 0 && <span>另有 {queueCount} 个任务排队</span>}
+      {task.state === 'queued' && queuePosition > 0 && <span>本次在等待队列第 {queuePosition} 位</span>}
+      {task.model.model && <span>模型：{task.model.model}</span>}
+      {task.model.maxTokens !== undefined && <span>单次最大输出：{task.model.maxTokens.toLocaleString('zh-CN')} token</span>}
+      {task.extractionTimeoutMinutes !== undefined && (task.stage === 'extract' || task.stage === 'all') && <span>文档抽取时限：{task.extractionTimeoutMinutes} 分钟 / 每轮</span>}
+    </div>
+    {active && <p className="ktCurrentHint">{task.state === 'pausing' || task.state === 'cancelling' ? task.summary : '暂停在安全点生效；停止会保留已保存的结果。关闭页面后任务继续运行。'}</p>}
+    {!active && <div className="ktCompletion">
+      <p>{task.summary}</p>
+      <ul>{PIPELINE_STAGE_ORDER.filter(id => task.results?.[id]).map(id => {
+        const result = task.results![id]!
+        return <li key={id}><strong>{PIPELINE_STAGE_LABEL[id]}</strong><span>{result.summary ?? `成功 ${result.done - result.failed}/${result.total} · 复用 ${result.reused} · 失败 ${result.failed}`}</span></li>
+      })}</ul>
+      <p>{task.results?.build && !task.results.build.failed ? task.results.build.skipped ? '检索索引无变化，继续使用已有版本。' : '本次检索索引已发布。' : '本次未更新检索索引。抽取、归一或物化完成后，仍需构建索引才能更新检索结果。'}</p>
+    </div>}
+    {failure && <p className="ktError" role="alert"><AlertCircle size={14} /><span>进度连接中断，正在自动重连。保留上次状态；任务是否仍在运行需重连后确认。{failure}</span></p>}
+  </section>
+}
+
+export function RunActivity({ task, events, onInspect }: { task: PipelineTask; events: PipelineEvent[]; onInspect: (id: string, stage?: PipelineWorkStage) => void }): ReactNode {
+  const [showAll, setShowAll] = useState(false)
+  const recent = events.filter(event => event.kind === 'progress' || event.kind === 'warning').slice(-8).reverse()
+  return <div className="ktActivity">
+    <h3>本次活动</h3>
+    <p className="ktActivityHint">保存、复用、拆分与重试会记录在这里。</p>
+    {task.warnings.length > 0 && <div className="ktWarnings">
+      <strong><AlertCircle size={13} />{task.warnings.length} 条需要关注</strong>
+      <ul>{(showAll ? task.warnings : task.warnings.slice(0, 3)).map((warning, index) => <li key={index}>{warning}</li>)}</ul>
+      {task.warnings.length > 3 && <Button variant="ghost" onClick={() => setShowAll(value => !value)}>{showAll ? '收起提醒' : '查看全部提醒'}</Button>}
+    </div>}
+    {recent.length ? <ol className="ktActivityList">{recent.map(event => <li key={event.seq} data-warning={event.kind === 'warning' || undefined}>
+      <time dateTime={event.at}>{new Date(event.at).toLocaleTimeString('zh-CN', { hour12: false })}</time>
+      <div><p>{event.text}</p>{(event.activity?.objectId || event.sourceId) && event.stage !== 'derive' && <Button variant="ghost" size="sm" className="ktLink" onClick={() => onInspect(event.activity?.objectId ?? event.sourceId!, event.stage)}>定位处理对象</Button>}</div>
+    </li>)}</ol> : <p className="ktActivityHint">{task.state === 'queued' ? '任务已入队，轮到后开始处理。' : '正在读取活动记录；历史任务可能只有原始输出。'}</p>}
+  </div>
+}
+
+export function RawTaskOutput({ kb, task, events, stage, onOpenFailed }: { kb: string; task: PipelineTask; events: PipelineEvent[]; stage: PipelineWorkStage; onOpenFailed: (message: string) => void }): ReactNode {
+  const scoped = events.filter(event => event.stage === stage || (!event.stage && task.stage === stage))
+  const output = scoped.filter(event => event.kind === 'output').map(event => event.text).join('').slice(-200000)
+  const reports = scoped.filter(event => event.kind === 'report')
+  return <div className="ktOutputBody">
+    <p>仅显示本次任务在当前阶段的模型原始输出。进展与警告见「本次活动」。</p>
+    <pre className="ktPre" tabIndex={0} aria-label={`${PIPELINE_STAGE_LABEL[stage]}原始输出`}>{output || '本阶段尚无原始模型输出。'}</pre>
+    <div className="ktReportsInline">{reports.map(event => <Button key={event.seq} variant="ghost" className="ktLink" onClick={() => {
+      void openAppPath(`/knowledge/pages/run?${new URLSearchParams({ kb, run: event.text })}`).then(opened => { if (!opened) onOpenFailed('无法打开阶段轨迹，请重试。') })
+    }}>查看阶段轨迹<ExternalLink size={12} /></Button>)}</div>
+  </div>
+}

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':