dsh-data-domain-knowledge 0.1.0-alpha.13 → 0.1.0-alpha.14

package/src/client/ExtractionTasksPage.tsx

@@ -1,189 +1,142 @@
-import { useEffect, useRef, useState, type ReactNode } from 'react'
-import { ChevronDown, CircleX, Clock3, ListOrdered, Pause, Play, RefreshCw } from '@tita-agent/ui/icons'
-import { Badge, Button } from '@tita-agent/ui/components'
-import { CompileStepList, type CompileStepView } from './CompileDialogs.tsx'
+import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react'
+import { Badge, Button, Tabs, TabsContent, TabsList, TabsTrigger } from '@tita-agent/ui/components'
+import { Check, ExternalLink, Pause, Play, RefreshCw, X } from '@tita-agent/ui/icons'
+import { PIPELINE_ACTIVE_STATES, PIPELINE_STAGE_LABEL, type PipelineEvent, type PipelineStage, type PipelineState, type PipelineStatus, type PipelineTask } from '../pipeline/types.js'
 import { formatDateTime } from './format.ts'
 import { requestJson } from './request.ts'
+import type { ExtractionRunSummary } from './wiki-trial.ts'
 
-type TaskState = 'queued' | 'running' | 'pausing' | 'paused' | 'cancelling' | 'succeeded' | 'failed' | 'cancelled'
-type TaskAction = 'pause' | 'resume' | 'cancel'
+const STATES: Record<PipelineState, string> = { queued: '排队中', running: '进行中', pausing: '暂停中', paused: '已暂停', cancelling: '停止中', succeeded: '已完成', partial: '部分完成', failed: '失败', cancelled: '已停止', interrupted: '已中断' }
+const SOURCE_STATES = { pending: '待抽取', extracted: '待归一', normalized: '已归一', outdated: '来源已更新' }
+const GROUP_STATES = { new: '待新建', changed: '待更新', current: '已物化', withdrawn: '待停用', blocked: '先归一来源' }
+interface History { tasks: PipelineTask[]; total: number; extractions: { runs: ExtractionRunSummary[]; total: number } | null }
+const toggle = (ids: string[], id: string): string[] => ids.includes(id) ? ids.filter(value => value !== id) : [...ids, id]
 
-interface ExtractionTask {
-  runId: string
-  only: string
-  state: TaskState
-  queuedAt: string
-  startedAt: string
-  finishedAt?: string
-  queued?: boolean
-  sourcesTotal: number
-  sourcesDone: number
-  steps: CompileStepView[]
-  outcome?: string
-  failed?: boolean
-}
-
-const STATE_LABEL: Record<TaskState, string> = {
-  queued: '排队中', running: '进行中', pausing: '暂停中', paused: '已暂停',
-  cancelling: '停止中', succeeded: '已完成', failed: '失败', cancelled: '已停止',
-}
-
-const STATE_TONE: Record<TaskState, 'neutral' | 'success' | 'warning' | 'blue'> = {
-  queued: 'neutral', running: 'blue', pausing: 'warning', paused: 'warning',
-  cancelling: 'warning', succeeded: 'success', failed: 'warning', cancelled: 'neutral',
-}
-
-const TASK_LABEL: Record<string, string> = {
-  all: '全量重编', wiki: '增量编译', schema: 'Schema 更新', embeddings: '向量重建',
-}
-
-async function loadTasks(kb: string): Promise<ExtractionTask[]> {
-  const params = new URLSearchParams({ kb })
-  const envelope = await requestJson<{ tasks: ExtractionTask[] }>(`/knowledge/extraction-tasks?${params}`)
-  return envelope.data?.tasks ?? []
-}
-
-async function updateTask(kb: string, runId: string, action: TaskAction): Promise<ExtractionTask> {
-  const envelope = await requestJson<{ task: ExtractionTask }>('/knowledge/extraction-task', {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ kb, run_id: runId, action }),
-  })
-  if (!envelope.data?.task) throw new Error('任务状态没有返回')
-  return envelope.data.task
-}
-
-function stateOf(task: ExtractionTask): TaskState {
-  return task.state ?? (task.finishedAt ? (task.failed ? 'failed' : 'succeeded') : task.queued ? 'queued' : 'running')
-}
-
-function taskDetail(task: ExtractionTask): string {
-  const state = stateOf(task)
-  if (state === 'queued') return '等待前面的任务结束'
-  const step = task.steps.find(item => item.state === 'running')
-  const progress = task.sourcesTotal > 0 ? `文档 ${task.sourcesDone}/${task.sourcesTotal}` : ''
-  if (state === 'running' || state === 'pausing' || state === 'paused' || state === 'cancelling') {
-    return [step?.facts[0] ?? step?.id, progress].filter(Boolean).join(' · ') || '正在准备编译'
-  }
-  return task.outcome ?? (state === 'succeeded' ? '任务完成' : state === 'cancelled' ? '任务已停止' : '任务失败')
-}
-
-function TaskActions({ task, kb, onChange }: {
-  task: ExtractionTask
-  kb: string
-  onChange: (task: ExtractionTask) => void
-}): ReactNode {
-  const [busy, setBusy] = useState(false)
-  const [failure, setFailure] = useState('')
-  const state = stateOf(task)
-  const active = ['queued', 'running', 'pausing', 'paused', 'cancelling'].includes(state)
-  const act = async (action: TaskAction): Promise<void> => {
-    setBusy(true)
-    setFailure('')
-    try { onChange(await updateTask(kb, task.runId, action)) }
-    catch (cause) { setFailure(cause instanceof Error ? cause.message : String(cause)) }
-    finally { setBusy(false) }
-  }
-  if (!active) return null
-  return <span className="extractTaskActions">
-    {failure && <span className="extractTaskActionError" role="alert">{failure}</span>}
-    {state !== 'cancelling' && <>
-      {state === 'paused'
-        ? <Button size="sm" variant="outline" disabled={busy} onClick={() => void act('resume')}><Play size={13} />继续</Button>
-        : <Button size="sm" variant="outline" disabled={busy || state === 'pausing'} onClick={() => void act('pause')}><Pause size={13} />暂停</Button>}
-      <Button size="sm" variant="destructive" disabled={busy} onClick={() => void act('cancel')}><CircleX size={13} />停止</Button>
-    </>}
-  </span>
-}
-
-function TaskRow({ task, kb, onChange }: {
-  task: ExtractionTask
-  kb: string
-  onChange: (task: ExtractionTask) => void
-}): ReactNode {
-  const [stepsOpen, setStepsOpen] = useState(() => ['queued', 'running', 'pausing', 'paused', 'cancelling'].includes(stateOf(task)))
-  const state = stateOf(task)
-  return <article className="extractTaskRow">
-    <div className="extractTaskMain">
-      <div className="extractTaskTitle">
-        <strong>{TASK_LABEL[task.only] ?? '编译任务'}</strong>
-        <Badge tone={STATE_TONE[state]}>{STATE_LABEL[state]}</Badge>
-      </div>
-      <p>{taskDetail(task)}</p>
-      <span className="extractTaskTime"><Clock3 size={12} />{formatDateTime(task.startedAt || task.queuedAt)}</span>
-    </div>
-    <div className="extractTaskControls">
-      <Button size="sm" variant="ghost" className="extractTaskStepToggle" aria-expanded={stepsOpen}
-        onClick={() => setStepsOpen(value => !value)}>
-        {stepsOpen ? '收起步骤' : '查看步骤'}<ChevronDown size={13} />
-      </Button>
-      <TaskActions task={task} kb={kb} onChange={onChange} />
-    </div>
-    {stepsOpen && <div className="extractTaskSteps"><CompileStepList steps={task.steps} /></div>}
-  </article>
-}
-
-export function ExtractionTasksPage({ kb }: { kb: string }): ReactNode {
-  const [tasks, setTasks] = useState<ExtractionTask[] | null>(null)
-  const [kbName, setKbName] = useState('')
+function TaskOutput({ kb, id, onTask }: { kb: string; id: string; onTask: (task: PipelineTask) => void }) {
+  const [events, setEvents] = useState<PipelineEvent[]>([])
   const [failure, setFailure] = useState('')
-  const [refreshing, setRefreshing] = useState(false)
-  const busyRef = useRef(false)
-
+  const callback = useRef(onTask)
+  callback.current = onTask
   useEffect(() => {
-    if (!kb) return undefined
     let active = true
-    const load = async (): Promise<void> => {
-      if (busyRef.current) return
-      busyRef.current = true
+    let busy = false
+    let cursor = 0
+    let terminal = false
+    setFailure('')
+    setEvents([])
+    const read = async (): Promise<void> => {
+      if (busy || terminal) return
+      busy = true
       try {
-        const [nextTasks, basesResponse] = await Promise.all([
-          loadTasks(kb),
-          requestJson<{ bases?: Array<{ id: string; name: string }> }>('/knowledge/bases'),
-        ])
-        if (!active) return
-        setTasks(nextTasks)
-        setKbName(basesResponse.data?.bases?.find(base => base.id === kb)?.name ?? kb)
-        setFailure('')
-      } catch (cause) {
-        if (active) setFailure(cause instanceof Error ? cause.message : String(cause))
-      } finally {
-        busyRef.current = false
-        if (active) setRefreshing(false)
-      }
+        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 || !result.data) return
+          const page = result.data
+          cursor = page.next
+          more = page.hasMore
+          terminal = !more && !PIPELINE_ACTIVE_STATES.includes(page.task.state)
+          callback.current(page.task)
+          setEvents(current => [...current, ...page.events].slice(-600))
+          setFailure('')
+        }
+      } catch (cause) { if (active) setFailure(cause instanceof Error ? cause.message : String(cause)) }
+      finally { busy = false }
     }
-    void load()
-    const timer = window.setInterval(() => { void load() }, 2000)
+    void read()
+    const timer = window.setInterval(() => { void read() }, 1200)
     return () => { active = false; window.clearInterval(timer) }
-  }, [kb])
+  }, [kb, id])
+  const output = events.filter(event => event.kind !== 'report').map(event => event.kind === 'output' ? event.text : `\n${event.text}\n`).join('').slice(-200000)
+  return <div className="mt-3 grid min-w-0 gap-2">
+    <p className="m-0 text-xs text-tita-ink-muted">模型正式输出持续返回；刷新后可以补读。预览保留最近内容，完整返回保存在报告中。</p>
+    {failure && <p className="m-0 text-xs text-tita-danger" role="alert">{failure}</p>}
+    <pre className="m-0 max-h-96 overflow-auto whitespace-pre-wrap break-words rounded-tita-control bg-tita-surface-muted p-3 text-xs leading-relaxed text-tita-ink" tabIndex={0} aria-label="实时输出">{output || '等待模型返回内容…'}</pre>
+    <div className="flex flex-wrap gap-3">{events.filter(event => event.kind === 'report').map(event => <a key={event.seq} className="text-xs text-tita-primary underline underline-offset-2" target="_blank" rel="noreferrer" href={`/knowledge/pages/run?${new URLSearchParams({ kb, run: event.text })}`}>查看抽取报告 <ExternalLink size={11} className="inline" /></a>)}</div>
+  </div>
+}
 
-  const replaceTask = (task: ExtractionTask): void => {
-    setTasks(current => current?.map(item => item.runId === task.runId ? task : item) ?? [task])
+export function ExtractionTasksPage({ kb }: { kb: string }): ReactNode {
+  const params = new URLSearchParams(typeof window === 'undefined' ? '' : window.location.search)
+  const [status, setStatus] = useState<PipelineStatus>()
+  const [history, setHistory] = useState<History>()
+  const [sourceIds, setSourceIds] = useState<string[]>(() => params.get('source') ? [params.get('source')!] : [])
+  const [groupKeys, setGroupKeys] = useState<string[]>([])
+  const [selectedTask, setSelectedTask] = useState(() => params.get('task') ?? '')
+  const [failure, setFailure] = useState('')
+  const [busy, setBusy] = useState(false)
+  const [page, setPage] = useState(0)
+  const refreshSequence = useRef(0)
+  const refresh = useCallback(async (): Promise<void> => {
+    if (!kb) return
+    const sequence = ++refreshSequence.current
+    try {
+      const [nextStatus, nextHistory] = await Promise.all([
+        requestJson<PipelineStatus>(`/knowledge/pipeline?kb=${encodeURIComponent(kb)}`),
+        requestJson<History>(`/knowledge/pipeline-tasks?${new URLSearchParams({ kb, offset: String(page * 20) })}`),
+      ])
+      if (sequence !== refreshSequence.current) return
+      if (nextStatus.data) setStatus(nextStatus.data)
+      if (nextHistory.data) setHistory(nextHistory.data)
+      setFailure('')
+    } catch (cause) { if (sequence === refreshSequence.current) setFailure(cause instanceof Error ? cause.message : String(cause)) }
+  }, [kb, page])
+  const activeCount = history?.tasks.filter(task => PIPELINE_ACTIVE_STATES.includes(task.state)).length ?? 0
+  useEffect(() => {
+    void refresh()
+    const focus = (): void => { void refresh() }
+    window.addEventListener('focus', focus)
+    const timer = activeCount ? window.setInterval(focus, 2500) : undefined
+    return () => { if (timer) window.clearInterval(timer); window.removeEventListener('focus', focus) }
+  }, [refresh, activeCount])
+  const start = async (stage: PipelineStage, force = false): Promise<void> => {
+    setBusy(true); setFailure('')
+    try {
+      const result = await requestJson<{ task: PipelineTask }>('/knowledge/pipeline', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ kb, stage, ...(sourceIds.length ? { sourceIds } : {}), ...(groupKeys.length ? { groupKeys } : {}), force }) })
+      if (result.data?.task) { setSelectedTask(result.data.task.id); setPage(0) }
+      await refresh()
+    } catch (cause) { setFailure(cause instanceof Error ? cause.message : String(cause)) }
+    finally { setBusy(false) }
   }
-
-  if (!kb) return <section className="page-state"><h2>缺少知识库</h2><p>从知识库工具栏打开抽取任务页。</p></section>
-
-  const activeCount = tasks?.filter(task => ['queued', 'running', 'pausing', 'paused', 'cancelling'].includes(stateOf(task))).length ?? 0
-  return <>
-    <div className="extractTasksHead">
-      <div>
-        <h2>抽取任务</h2>
-        <p>{kbName || kb} · {activeCount > 0 ? `${activeCount} 项未结束` : '当前没有进行中的任务'}</p>
-      </div>
-      <Button size="sm" variant="outline" disabled={refreshing} onClick={() => {
-        setRefreshing(true)
-        void loadTasks(kb).then(setTasks).catch(cause => setFailure(cause instanceof Error ? cause.message : String(cause))).finally(() => setRefreshing(false))
-      }}><RefreshCw size={13} className={refreshing ? 'extractTaskSpin' : undefined} />刷新</Button>
-    </div>
-
-    <p className="extractTasksNote">暂停会在当前文档或阶段处理完成后生效。停止不会回滚已写入的内容。</p>
-    {failure && <p className="page-notice" role="alert">读取任务失败：{failure}</p>}
-    {tasks === null
-      ? <p className="page-loading" role="status">正在读取任务…</p>
-      : tasks.length === 0
-        ? <div className="extractTasksEmpty"><ListOrdered size={17} /><span>还没有编译任务。导入文档或重新编译后，任务会显示在这里。</span></div>
-        : <div className="extractTaskList">
-          {tasks.map(task => <TaskRow key={task.runId} task={task} kb={kb} onChange={replaceTask} />)}
-        </div>}
-  </>
+  const act = async (id: string, action: string): Promise<void> => {
+    setBusy(true)
+    try {
+      const result = await requestJson<{ task: PipelineTask }>('/knowledge/pipeline-task', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ kb, id, action }) })
+      if (result.data?.task) setSelectedTask(result.data.task.id)
+      await refresh()
+    } catch (cause) { setFailure(cause instanceof Error ? cause.message : String(cause)) }
+    finally { setBusy(false) }
+  }
+  const replaceTask = useCallback((task: PipelineTask) => setHistory(current => current ? { ...current, tasks: current.tasks.map(row => row.id === task.id ? task : row) } : current), [])
+  if (!kb) return <p role="alert">缺少知识库，请从知识库工具栏打开知识处理。</p>
+  const total = Math.max(history?.total ?? 0, history?.extractions?.total ?? 0)
+  return <div className="grid min-w-0 gap-7 text-tita-ink">
+    <section className="grid gap-3" aria-label="独立运行知识阶段">
+      <div className="flex flex-wrap items-center justify-between gap-3"><h2 className="m-0 text-xl font-semibold">知识处理</h2><Button variant="outline" size="sm" onClick={() => { void refresh() }}><RefreshCw size={13} />刷新状态</Button></div>
+      <p className="m-0 text-sm leading-relaxed text-tita-ink-muted">来源默认只入库。单独运行抽取、归一合并和物化，最后发布检索索引。</p>
+      <div className="flex flex-wrap gap-2">{(['extract', 'normalize', 'materialize', 'build'] as const).map(stage => <Button key={stage} variant="outline" size="sm" disabled={busy || !status || ((stage === 'extract' || stage === 'normalize') && !status.sources.length)} onClick={() => { void start(stage) }}>{PIPELINE_STAGE_LABEL[stage]}</Button>)}<Button size="sm" disabled={busy || !status?.sources.length} onClick={() => { void start('all') }}>全链路运行</Button></div>
+      <p className="m-0 text-xs leading-relaxed text-tita-ink-muted" role="status">{status ? `${status.pendingNew} 张待新建 · ${status.pendingUpdated} 张待更新 · ${status.pendingWithdrawn} 张待停用${status.blocked ? ` · ${status.blocked} 条暂不可物化` : ''}${status.indexPending ? ' · 索引待更新' : ''}` : '正在读取处理状态…'}</p>
+      {failure && <p className="m-0 text-sm text-tita-danger" role="alert">{failure}</p>}
+    </section>
+    <Tabs defaultValue="sources">
+      <TabsList><TabsTrigger value="sources">来源范围</TabsTrigger><TabsTrigger value="groups">WikiCard 分组</TabsTrigger></TabsList>
+      <TabsContent value="sources" className="mt-3">
+        <div className="mb-2 flex flex-wrap items-center justify-between gap-2"><p className="m-0 text-xs text-tita-ink-muted">{sourceIds.length ? `已选 ${sourceIds.length} 份文档` : '未选择文档：处理全部来源，未变化结果自动复用'}</p><Button size="sm" variant="ghost" disabled={!sourceIds.length} onClick={() => setSourceIds([])}>清除选择</Button></div>
+        <ul className="m-0 grid max-h-80 list-none overflow-auto p-0" aria-label="来源选择">{status?.sources.map(source => <li key={source.id} className="flex min-w-0 items-center gap-3 border-b border-tita-line py-2"><Button variant={sourceIds.includes(source.id) ? 'default' : 'ghost'} size="sm" aria-pressed={sourceIds.includes(source.id)} onClick={() => setSourceIds(current => toggle(current, source.id))}>{sourceIds.includes(source.id) && <Check size={13} />}选择</Button><span className="min-w-0 flex-1 break-words text-sm">{source.title}<span className="ml-2 text-xs text-tita-ink-muted">v{source.version}</span></span><Badge tone="neutral">{SOURCE_STATES[source.state]}</Badge></li>)}</ul>
+        {sourceIds.length > 0 && <Button className="mt-3" size="sm" variant="outline" disabled={busy} onClick={() => { void start('extract', true) }}>强制重抽选中的 {sourceIds.length} 份文档</Button>}
+      </TabsContent>
+      <TabsContent value="groups" className="mt-3">
+        <div className="mb-2 flex flex-wrap items-center justify-between gap-2"><p className="m-0 text-xs text-tita-ink-muted">{groupKeys.length ? `已选 ${groupKeys.length} 张完整卡片分组` : '未选择分组：物化全部待办，同坐标的知识和事件一起处理'}</p><Button size="sm" variant="ghost" disabled={!groupKeys.length} onClick={() => setGroupKeys([])}>清除选择</Button></div>
+        {!status?.groups.length && <p className="text-sm text-tita-ink-muted">还没有可物化分组。先抽取并归一文档内容。</p>}
+        <ul className="m-0 grid max-h-96 list-none overflow-auto p-0" aria-label="卡片分组选择">{status?.groups.map(group => <li key={group.key} className="flex min-w-0 items-center gap-3 border-b border-tita-line py-2"><Button variant={groupKeys.includes(group.key) ? 'default' : 'ghost'} size="sm" aria-pressed={groupKeys.includes(group.key)} onClick={() => setGroupKeys(current => toggle(current, group.key))}>{groupKeys.includes(group.key) && <Check size={13} />}选择</Button><div className="min-w-0 flex-1"><p className="m-0 break-words text-sm">{group.title}</p><p className="m-0 mt-1 text-xs text-tita-ink-muted">{group.knowledgeCount} 条 Knowledge · {group.eventCount} 个 Event · {group.sourceIds.length} 份来源</p>{group.reason && <p className="m-0 mt-1 text-xs text-tita-warning">{group.reason}</p>}</div><Badge tone={group.state === 'current' ? 'success' : 'neutral'}>{GROUP_STATES[group.state]}</Badge></li>)}</ul>
+      </TabsContent>
+    </Tabs>
+    <section id="history" className="min-w-0 border-t border-tita-line pt-5" aria-labelledby="pipeline-history">
+      <h2 id="pipeline-history" className="m-0 text-lg font-semibold">任务历史</h2><p className="mt-2 text-xs text-tita-ink-muted">{activeCount ? `${activeCount} 项未结束。` : '当前没有运行中的任务。'} 暂停与停止在当前文档或卡片处理完成后生效。</p>
+      {!history?.tasks.length && <p className="text-sm text-tita-ink-muted">还没有阶段任务；已有文档抽取记录在下方保留。</p>}
+      {history?.tasks.map(task => <article key={task.id} className="min-w-0 border-b border-tita-line py-4"><div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between"><div className="min-w-0 flex-1"><div className="flex flex-wrap items-center gap-2"><strong className="text-sm">{PIPELINE_STAGE_LABEL[task.stage]}</strong><Badge tone={task.state === 'succeeded' ? 'success' : ['failed', 'partial', 'interrupted'].includes(task.state) ? 'warning' : 'neutral'}>{STATES[task.state]}</Badge></div><p className="mb-0 mt-2 break-words text-xs leading-relaxed">{task.summary}</p><p className="mb-0 mt-1 text-xs text-tita-ink-muted">{formatDateTime(task.queuedAt)}{task.model.model ? ` · ${task.model.provider ?? ''} / ${task.model.model}` : ''}{task.model.reasoningEffort ? ` · ${task.model.reasoningEffort}` : ''}</p></div><div className="flex flex-wrap gap-1"><Button size="sm" variant="ghost" aria-expanded={selectedTask === task.id} onClick={() => setSelectedTask(current => current === task.id ? '' : task.id)}>{selectedTask === task.id ? '收起输出' : '查看输出'}</Button>{PIPELINE_ACTIVE_STATES.includes(task.state) ? <><Button size="sm" variant="outline" disabled={busy || task.state === 'cancelling' || task.state === 'pausing'} onClick={() => { void act(task.id, task.state === 'paused' ? 'resume' : 'pause') }}>{task.state === 'paused' ? <Play size={12} /> : <Pause size={12} />}{task.state === 'paused' ? '继续' : '暂停'}</Button><Button size="sm" variant="ghost" disabled={busy || task.state === 'cancelling'} onClick={() => { void act(task.id, 'cancel') }}><X size={12} />停止</Button></> : <Button size="sm" variant="outline" disabled={busy} onClick={() => { void act(task.id, 'retry') }}>重新运行</Button>}</div></div>{selectedTask === task.id && <TaskOutput kb={kb} id={task.id} onTask={replaceTask} />}</article>)}
+      {total > 20 && <div className="mt-3 flex items-center gap-3"><Button size="sm" variant="outline" disabled={page === 0} onClick={() => setPage(current => current - 1)}>上一页</Button><span className="text-xs text-tita-ink-muted">第 {page + 1} 页</span><Button size="sm" variant="outline" disabled={(page + 1) * 20 >= total} onClick={() => setPage(current => current + 1)}>下一页</Button></div>}
+    </section>
+    <section className="border-t border-tita-line pt-5"><h2 className="m-0 text-lg font-semibold">文档抽取记录</h2><p className="mt-2 text-xs text-tita-ink-muted">保留现有抽取报告。早期记录按文档展示，不补造批次。</p>{history?.extractions?.runs.map(run => <a key={run.id} className="flex min-w-0 flex-wrap items-center justify-between gap-2 border-b border-tita-line py-3 text-sm text-tita-ink underline-offset-2 hover:underline" target="_blank" rel="noreferrer" href={`/knowledge/pages/run?${new URLSearchParams({ kb, run: run.id })}`}><span className="min-w-0 break-words">{run.title} · {run.summary}</span><span className="text-xs text-tita-ink-muted">{formatDateTime(run.createdAt)} <ExternalLink size={12} className="inline" /></span></a>)}{history?.extractions?.total === 0 && <p className="text-sm text-tita-ink-muted">还没有抽取记录。</p>}</section>
+  </div>
 }

package/src/client/KnowledgeBaseTab.tsx

@@ -78,6 +78,7 @@ import { ImportFilesDialog, type ImportItemView, type ImportStage } from './Impo
 import { TypeDefinitionDrawer, type CompileModelSelectionView } from './TypeDefinitionDrawer.tsx'
 import { DeleteDocumentDialog } from './DeleteDocumentDialog.tsx'
 import { InfoHint } from './InfoHint.tsx'
+import { PipelineNotice } from './PipelineNotice.tsx'
 
 // ------------------------------------------------------------------ contract
 // Mirrors the plugin HTTP contract (see plugins/dsh-data-domain-knowledge/README.md).
@@ -613,6 +614,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
   const [eventsLoading, setEventsLoading] = useState(false)
   const [eventsError, setEventsError] = useState('')
   const [knowledgeContent, setKnowledgeContent] = useState<'knowledge' | 'event'>('knowledge')
+  const [focusedEventId, setFocusedEventId] = useState<string>()
   const eventsRequestRef = useRef(0)
   /** 当前打开的文档的轨迹列表（不含报告本体）。报告整页读（见 `openRunPage`）。 */
   const [detailRuns, setDetailRuns] = useState<ExtractionRunSummary[]>([])
@@ -725,6 +727,11 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     setTab(next)
     remember('knowledgeTab', next)
   }, [])
+  const openEvent = useCallback((eventId: string): void => {
+    setFocusedEventId(eventId)
+    changeTab('knowledge')
+    setKnowledgeContent('event')
+  }, [changeTab])
   /** 编译设置抽屉：本库的编译模型、坐标实体与抽取备注。 */
   const [typeDef, setTypeDef] = useState(false)
   const [detail, setDetail] = useState<{ document: KnowledgeDocumentDetail; versions: DocumentVersion[] } | null>(null)
@@ -1203,15 +1210,10 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     }
     await loadBases(base.id)
     await Promise.all([loadDocuments(base.id, query), loadCards(base.id)])
-    let report: RebuildReportView | null = null
     if (done > 0) {
-      setCompileProgress(null)
-      report = await rebuild('wiki')
-      await Promise.all([loadCards(base.id), loadStats(base.id), loadKnowledge(base.id)])
-      say(failedCount === 0 ? 'success' : 'error',
-        failedCount === 0
-          ? `已导入并编译 ${done} 个文件到「${base.name}」`
-          : `导入 ${done} 个、失败 ${failedCount} 个 —— 已对成功的那些跑了增量编译`)
+      say(failedCount === 0 ? 'success' : 'error', failedCount === 0
+        ? `已保存 ${done} 个文件到「${base.name}」，可单独运行抽取`
+        : `已保存 ${done} 个文件，失败 ${failedCount} 个；成功文件可单独抽取`)
     }
     /**
      * 收尾摘要。它是**这一批处理结果的唯一一处汇总** —— 对话框下半截显示它，处理日志里
@@ -1220,46 +1222,15 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
     const summary: ImportSummaryView = {
       files: outcomes,
       done, failed: failedCount,
-      compile: report === null ? null : {
-        version: report.version,
-        skipped: report.skipped === true,
-        entities: report.detail?.entities ?? null,
-        phases: report.detail?.phases ?? null,
-        cards: report.detail?.cards ?? null,
-        notes: report.detail?.notes ?? null,
-        relatedLinks: report.detail?.relatedLinks,
-        deadLinks: report.detail?.deadLinks,
-        build: report.graphNodes === undefined
-          ? null
-          : {
-              graphNodes: report.graphNodes,
-              graphEdges: report.graphEdges ?? 0,
-              embedding: report.embedding ?? 'skipped',
-              embeddingItems: report.embeddingItems ?? 0,
-              embeddingReused: report.embeddingReused ?? 0,
-            },
-        extractModel: (report.warnings ?? []).some(warning => warning.includes('模型抽取已开启')) ? 'unavailable' : 'ok',
-      },
+      compile: null,
     }
     setImportSummary(summary)
     await settleBatchLog(batch, {
       status: failedCount === 0 ? 'done' : done > 0 ? 'partial' : 'failed',
       summary: done === 0
         ? `${failedCount} 个文件全部失败，没有东西进入知识库。`
-        : `入库 ${done} 个${failedCount > 0 ? `、失败 ${failedCount} 个` : ''}；`
-          /**
-           * `report === null` 说的是**这一批的编译没读到结论**，不是「没有编译」（0066）。
-           *
-           * 这句原来是「这一批没有触发编译。」—— 而面板从没有过判断这件事的依据：它只知道
-           * 自己那条请求的结局。实机上那条请求在 300 秒被切断，编译在 312 秒成功，于是日志
-           * 里留下了一句与事实相反的话。**只写自己知道的事**：
-           */
-          + (report === null
-            ? '编译已发起，但没读到它的结论（可能仍在跑）；结论看那一次的处理日志。'
-            : report.skipped === true
-              ? `编译：语料没变化，索引仍为 v${report.version}。`
-              : `编译：新建 ${report.detail?.cards?.created.length ?? 0} 张、并入 ${report.detail?.cards?.updated.length ?? 0} 张、复用 ${report.detail?.cards?.reused.length ?? 0} 张，索引 v${report.version}。`),
-      detail: { files: outcomes, ...(report?.detail === undefined ? {} : { compile: report.detail }) },
+        : `入库 ${done} 个${failedCount > 0 ? `、失败 ${failedCount} 个` : ''}；本次只保存来源，可在知识处理中运行抽取。`,
+      detail: { files: outcomes },
     })
     setImportRunning(false)
   }
@@ -1768,7 +1739,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         headers: { 'content-type': 'application/json' },
         // 面板的「重新编译」也承担存量数据修复：明确开启抽取，并绕过旧指纹，
         // 否则旧版本留下的空坐标会被当成未变化结果永久复用。
-        body: JSON.stringify({ only, kb: baseId, extract: true, forceExtract: only === 'all' }),
+        body: JSON.stringify({ only, kb: baseId, extract: false, forceExtract: false }),
       })
       compileStartPendingRef.current = false
       runId = started.data?.runId ?? null
@@ -2305,7 +2276,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
         ? <p className="rounded-md border border-tita-line bg-tita-surface-muted px-2.5 py-2 text-[10.5px] leading-relaxed text-tita-danger" role="alert">Event 加载失败：{eventsError}</p>
         : eventsLoading && events.length === 0
           ? <p className="py-5 text-center text-[11px] text-tita-ink-muted" role="status">正在读取 Event…</p>
-          : <EventView events={events} />}
+          : <EventView events={events} focusEventId={focusedEventId} />}
     </TabsContent>
   </Tabs>
 
@@ -2361,36 +2332,12 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
           title={active ? `编辑 ${active.name} 的编译设置` : '先选择一个知识库'}
           onClick={() => setTypeDef(true)}
         ><Tags size={13} />编译设置</Button>
-        {/* 一枚按钮，一个含义：**全量重新编译**。
-            原先它是一枚带下拉的「编译 ⌄」，两档（增量 / 全量）让人选。撤掉下拉的理由：
-            增量编译**已经是默认行为** —— 写入来源时服务端会顺手跑一次增量编译
-            （`importSources` 的 `compile: 'wiki'`），而它本身在语料未变时是空操作。
-            把它摆成一枚需要人选的按钮，是让人替机器做机器的决定。
-            留下的这一档是「我怀疑产物不对，强制重来一次」—— 那才需要人明确说出来，
-            所以它带一个确认浮层。 */}
-        <span className="kbCompileAction">
-          <Button
-            variant="outline"
-            size="sm"
-            className="kbCompileActionMain"
-            disabled={busy !== null || !active}
-            title={active ? `重新编译「${active.name}」的全部 SourceRaw` : '先选择一个知识库'}
-            onClick={() => setConfirmOpen(true)}
-          ><RefreshCw size={14} />{busy === 'compile' ? '编译中…' : '重新编译'}</Button>
-          <DropdownMenu>
-            <DropdownMenuTrigger asChild disabled={!active}>
-              <Button variant="outline" size="sm" className="kbCompileActionMenu" aria-label="编译任务">
-                <ChevronDown size={13} />
-              </Button>
-            </DropdownMenuTrigger>
-            <DropdownMenuContent align="end" sideOffset={5}>
-              <DropdownMenuItem onSelect={() => {
-                const kb = activeIdRef.current
-                if (kb) void fullPage.open({ src: `/knowledge/pages/tasks?kb=${encodeURIComponent(kb)}`, title: '抽取任务' })
-              }}><ListOrdered size={14} />抽取任务</DropdownMenuItem>
-            </DropdownMenuContent>
-          </DropdownMenu>
-        </span>
+        <Button variant="outline" size="sm" disabled={!active} onClick={() => {
+          if (active) void fullPage.open({ src: `/knowledge/pages/tasks?kb=${encodeURIComponent(active.id)}`, title: '知识处理与任务历史' })
+        }}><Layers3 size={14} />知识处理</Button>
+        <Button variant="ghost" size="sm" disabled={!active} onClick={() => {
+          if (active) void fullPage.open({ src: `/knowledge/pages/tasks?kb=${encodeURIComponent(active.id)}#history`, title: '任务历史' })
+        }}><ListOrdered size={14} />任务历史</Button>
         <Button
           variant="outline"
           size="sm"
@@ -2414,6 +2361,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
 
     {/* 分栏是**一条流水线**，所以切换器是步骤轨而不是一排等宽 tab：收录 → 抽取归一 →
         物化 → 检索精排。方向本身就是信息（写入侧在左、读取侧在右）。 */}
+    {active && <PipelineNotice kb={active.id} revision={active.updatedAt} onOpen={() => { void fullPage.open({ src: `/knowledge/pages/tasks?kb=${encodeURIComponent(active.id)}`, title: '知识处理' }) }} />}
     <KnowledgeStepRail tab={tab} onChange={changeTab} facts={stepFacts} />
 
     {/* 删除确认：**先查账再弹框**（见 `askDeleteDocument`）。 */}
@@ -2622,7 +2570,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
               ? <p className={styles.kbHint}>
                 {detailKnowledgeLoading
                   ? '正在取这份来源抽出的知识…'
-                  : <>这份来源还没有抽出知识。导入文档后会自动抽取；也可以点工具栏的「重新编译」。</>}
+                  : <>这份来源还没有抽出知识。请在「知识处理」中运行抽取，再运行归一合并。</>}
               </p>
               : <>
                 <ul className={styles.knowledgeList}>
@@ -2676,6 +2624,9 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
           <div className={styles.drawerSection}>
             <div className={styles.kbSubHead}>
               <h4><Sparkles size={13} />抽取轨迹</h4>
+              <Button variant="outline" size="sm" onClick={() => {
+                if (active) void fullPage.open({ src: `/knowledge/pages/tasks?kb=${encodeURIComponent(active.id)}&source=${encodeURIComponent(detail.document.docId)}`, title: '单文档抽取' })
+              }}>单独抽取此文档</Button>
               <span>{detailRuns.length > 0 ? `${detailRuns.length} 次` : '还没有'}</span>
             </div>
             {detail !== null && compileProgress !== null && compileProgress.finishedAt === undefined
@@ -2711,7 +2662,7 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
               </p>
               : detailRuns.length === 0
                 ? <p className={styles.kbHint}>
-                  这份文档还没有抽取轨迹。导入后会自动生成；重新编译也会新增一条轨迹。
+                  这份文档还没有抽取轨迹。保存来源后，在「知识处理」中单独运行抽取。
                 </p>
                 : <ul className={styles.trialRunList}>
                   {detailRuns.map(run => <li key={run.id}>
@@ -2786,6 +2737,8 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
               onCompare={entry => void compareCardVersion(entry)}
               versionDiff={cardDiff}
               onOpenRelated={link => void openCard(link)}
+              onOpenEvent={openEvent}
+              events={events}
               sourceTitles={sourceTitles}
             />
           </DrawerBody>
@@ -2817,6 +2770,8 @@ export function KnowledgeBaseTab({ visible, onChanged, onActiveBaseChange, knowl
             onCompare={entry => void compareCardVersion(entry)}
             versionDiff={cardDiff}
             onOpenRelated={link => void openCard(link)}
+            onOpenEvent={openEvent}
+            events={events}
             sourceTitles={sourceTitles}
           />
         </DrawerBody>

package/src/client/NodeSettings.tsx

@@ -87,10 +87,10 @@ export const NODE_SETTINGS: Record<SettingsNode, NodeSpec> = {
   // 0025：`compile` 设置组已撤。卡片编译模板是系统固定契约，不是用户设置项。
   build: {
     scope: 'knowledge',
-    title: '向量模型',
+    title: '向量运行设置',
     fields: [
       { key: 'embeddingProvider', label: '向量来源', kind: 'select', fallback: 'wemm-python', options: [{ value: 'wemm-python', label: '本地模型' }, { value: 'ollama', label: 'Ollama' }, { value: 'none', label: '关闭向量' }] },
-      { key: 'embeddingModel', label: '模型路径或名称', kind: 'text', fallback: '', hint: '本地模型留空时自动选择；Ollama 填模型名称。' },
+      { key: 'embeddingModel', label: 'Ollama 模型名称', kind: 'text', fallback: '', hint: '填写 Ollama 中已安装的模型名称。', visibleWhen: { key: 'embeddingProvider', value: 'ollama' } },
       { key: 'embeddingBaseUrl', label: 'Ollama 地址', kind: 'text', fallback: 'http://127.0.0.1:11434', visibleWhen: { key: 'embeddingProvider', value: 'ollama' } },
       { key: 'embeddingDevice', label: '运行设备', kind: 'select', fallback: 'auto', advanced: true, options: [{ value: 'auto', label: '自动' }, { value: 'mps', label: 'Apple MPS' }, { value: 'cpu', label: 'CPU' }] },
       { key: 'embeddingDimension', label: '向量维度', kind: 'number', fallback: 512, min: 1, step: 1, advanced: true, hint: '必须与所选模型输出维度一致；修改后需要重建向量索引。' },
@@ -107,7 +107,6 @@ export const NODE_SETTINGS: Record<SettingsNode, NodeSpec> = {
       { key: 'keywordThreshold', label: '关键词阈值', kind: 'number', fallback: 0.3, min: 0, max: 1, step: 0.01, advanced: true, hint: '0–1 的归一化 BM25 分数；适合过滤弱命中，不能单独判断整批结果是否相关。' },
       { key: 'vectorThreshold', label: '向量阈值', kind: 'number', fallback: 0.5, min: -1, max: 1, step: 0.01, advanced: true, hint: '原始余弦分数。默认 0.5 是当前本地模型与语料的起点，换模型后应按召回诊断校准。' },
       { key: 'rerankThreshold', label: '重排最低分', kind: 'number', fallback: 0.2, min: -10, max: 10, step: 0.1, advanced: true },
-      { key: 'rerankModel', label: '模型路径或名称', kind: 'text', fallback: '', advanced: true },
       { key: 'rerankTimeoutMs', label: '重排超时（毫秒）', kind: 'number', fallback: 60000, min: 1000, max: 600000, step: 1000, advanced: true },
       { key: 'contextMaxChars', label: '上下文字符上限', kind: 'number', fallback: 20000, min: 0, max: 1000000, step: 1000, hint: '0 表示不限', advanced: true },
     ],

package/src/client/PipelineNotice.tsx

@@ -0,0 +1,26 @@
+import { useEffect, useState } from 'react'
+import { Button } from '@tita-agent/ui/components'
+import type { PipelineStatus } from '../pipeline/types.js'
+import { requestJson } from './request.ts'
+
+export function PipelineNotice({ kb, revision, onOpen }: { kb: string; revision?: string; onOpen: () => void }) {
+  const [status, setStatus] = useState<PipelineStatus>()
+  useEffect(() => {
+    let active = true
+    const refresh = (): void => { void requestJson<PipelineStatus>(`/knowledge/pipeline?kb=${encodeURIComponent(kb)}`).then(result => { if (active && result.data) setStatus(result.data) }).catch(() => undefined) }
+    refresh()
+    window.addEventListener('focus', refresh)
+    return () => { active = false; window.removeEventListener('focus', refresh) }
+  }, [kb, revision])
+  if (!status) return null
+  const pending = status.pendingNew + status.pendingUpdated + status.pendingWithdrawn
+  const parts = [
+    status.sources.filter(source => source.state === 'pending' || source.state === 'outdated').length,
+    status.sources.filter(source => source.state === 'extracted').length,
+  ]
+  if (!parts.some(Boolean) && !pending && !status.indexPending) return null
+  return <div className="mx-3 flex min-w-0 items-center gap-2 border-b border-tita-line py-2 text-xs text-tita-ink-muted" role="status">
+    <span className="min-w-0 flex-1 leading-relaxed">{[parts[0] ? `${parts[0]} 份待抽取` : '', parts[1] ? `${parts[1]} 份待归一` : '', pending ? `${pending} 张 WikiCard 待物化` : '', status.indexPending ? '索引待更新' : ''].filter(Boolean).join(' · ')}</span>
+    <Button size="sm" variant="ghost" onClick={onOpen}>处理</Button>
+  </div>
+}

package/src/client/TabGuide.tsx

@@ -162,9 +162,9 @@ const COMPILE_PROMPT_SECTIONS: GuideSection[] = [
   {
     title: '这一步发给模型的提示词',
     points: [
-      '四段里只有两段调模型：**抽取 Knowledge**（Extract）与 **物化 WikiCard 里的组织**（Organize）。',
-      '**归一坐标**（Resolve）不调模型：作用域内 canonical → alias → 全局唯一 → 新建候选，全是查注册表。',
-      '**建索引**（Index）也不调模型：切召回单元、写索引页、检查断链，都是确定性计算。',
+      '抽取 Knowledge / Event 使用 LLM；归一遇到歧义时调用模型补判；WikiCard 可选择模型组织。三个阶段独立运行。',
+      '**归一坐标**（Resolve）优先查 canonical、alias 与作用域；需要语义比较时由模型在已有候选中补判，不确定就保留待处理。',
+      '**建索引**（Index）从已保存卡片切召回单元，构建关键词、向量和图谱；向量编码使用所选向量模型，不重复文档抽取。',
       '所以下面两段就是这条链路全部的模型输入。它们都是 **system 段**；user 段每次都不同（文档正文、这一坐标下的知识清单），列不出固定文本。',
     ],
   },
@@ -176,7 +176,7 @@ const COMPILE_PROMPT_SECTIONS: GuideSection[] = [
       '这是**稳定前缀**：同一份契约每份文档都发一遍，所以它进 system 而不是 user。',
       '运行时在这段之后还会注入两样随库与文档变化的东西，所以不在上面那段里：本库**已有的坐标清单**（对象 / 动作 / 场景，含定义与别名），以及**本库骨架允许的小节名**。',
       '已有坐标刻意放在 user 段 —— system 保持稳定，上游缓存才命中得了（`sessionId` 被钉成 `knowledge:<库 id>` 就是为了这件事）。',
-      '模型回一个 JSON：`knowledge` 是抽出来的知识（每条只挂一个坐标），`objects` / `actions` / `scenes` 是它用到的原始说法与定义，`dropped` 是它丢掉且说得出理由的片段。',
+      '模型默认回 TOON 固定列表格，历史 JSON 仍兼容：`knowledge` 是抽出来的知识（每条只挂一个坐标），`objects` / `actions` / `scenes` 是它用到的原始说法与定义，`dropped` 是它丢掉且说得出理由的片段。',
     ],
     wide: true,
   },