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

package/src/index.ts

@@ -1,17 +1,21 @@
+import { embeddingModel } from './environment/model-catalog.js'
 import type { IncomingMessage, ServerResponse } from 'node:http'
-import { createReadStream, existsSync } from 'node:fs'
+import { createReadStream } from 'node:fs'
 import { readFile, stat } from 'node:fs/promises'
 import { dirname, extname, isAbsolute, join, resolve, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { Context } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-agent'
+import type {} from '@deepseek-ai/dsh-system-prompt'
 import z from '@deepseek-ai/schemastery'
 import { defineTool, type PreToolDecision, type ToolRunContext } from '@deepseek-ai/dsh-tools'
-import type { LineageContext } from 'dsh-data-contracts/refs'
+import type { LineageContext } from '#contracts'
 import { operationId, type OperationLog } from './oplog.js'
 import { AXIS_GUIDANCE_KINDS, type AxisGuidanceKind } from './axis-registry.js'
 import type { OperationDetail } from './types.js'
 import {
-  DEFAULT_KNOWLEDGE_CONFIG, type CardStatus, type Envelope, type KnowledgeBase, type KnowledgeConfig,
+  DEFAULT_COMPILE_MODEL, DEFAULT_KNOWLEDGE_CONFIG, type CardStatus, type CompileModelSelection,
+  type Envelope, type KnowledgeBase, type KnowledgeConfig,
   type KnowledgeStatus, type RecallMode, type SchemaType,
 } from './types.js'
 import {
@@ -26,16 +30,17 @@ import {
   type ModelSeam,
 } from './runtime.js'
 import { unwrapGroup } from './settings-volatile.js'
+import { behaviorPromptForPreset } from './agent-behavior-rules.js'
+import { KnowledgeEnvironment } from './environment/service.js'
 import { DOC_PAGE_CHARS, DOC_PAGE_CHARS_MAX, documentContentPage } from './document-page.js'
 import type { ModelCall } from './extract-model.js'
 import { runWikiTrial, trialSummary } from './wiki-trial.js'
 import { extractionRunId } from './extraction-runs.js'
+import type { PipelineStage } from './pipeline/types.js'
 import {
-  agentLayout, defaultAgentRoot, ensureAgentLayout, intentRoot, knowledgeBaseRoot, legacyDefaultKnowledgeRoot,
-  memoryRoot, presetSourceDir, resourceRegistry, resourceRoot, type AgentLayout,
+  agentLayout, defaultAgentRoot, ensureAgentLayout, intentRoot, knowledgeBaseRoot,
+  memoryRoot, resourceRegistry, resourceRoot, type AgentLayout,
 } from './layout.js'
-import { migrateLegacyKnowledgeTree, migrateLegacyMemory, migrateLegacyResources, type MigrationOutcome } from './migrate.js'
-import { legacyResourceHome } from './types.js'
 import {
   PickerError, createDirectory, listDirectory, pickDirectory, pickerKind, pickerOf,
 } from './directory-picker.js'
@@ -44,6 +49,7 @@ import type { DiagnosisRunRecord } from './diagnosis/types.js'
 import { KNOWLEDGE_SETTINGS_SCHEMA, SETTINGS_NAMESPACE } from './settings-schema.js'
 import { DEFAULT_KB_ID, KnowledgeBases } from './knowledge-bases.js'
 import type { KnowledgeQuery } from './knowledge.js'
+import { ImagePublishError, publishKnowledgeImage } from './images.js'
 import {
   applyConvert, CONVERT_SETTINGS_NAMESPACE, CONVERT_SETTINGS_SCHEMA, MOUNT_PATH as CONVERT_MOUNT_PATH,
   type ConvertHost,
@@ -53,7 +59,9 @@ import {
   applyIntent, INTENT_MOUNT_PATH, INTENT_SERVICE,
   type IntentHost,
   type IntentLineageService,
+  type IntentService,
 } from './intent/host.js'
+import { registerIntentTools } from './intent/tools.js'
 
 export * from './types.js'
 export * from './runtime.js'
@@ -68,14 +76,14 @@ export const name = 'dsh-data-domain-knowledge'
  * `settings` 在 0.1.7 之后**不再需要**：设置已经是本 entry 的 config
  * （见下面的 `Config`），`settings.installSection` 那条路已经整个删除。
  */
-export const inject = ['tools', 'webServer'] as const
+export const inject = ['tools', 'webServer', 'systemPrompt'] as const
 // schema 与命名空间搬到了 `settings-schema.ts`（可测）。这里再导出一次，保持
 // `dsh-data-domain-knowledge` 的既有出口不变。
 export { KNOWLEDGE_SETTINGS_SCHEMA, SETTINGS_NAMESPACE }
 export { CONVERT_SETTINGS_SCHEMA }
 /**
  * 组合 schema 与它的取值形态住在 `./config-schema.js`：那里**没有工具层依赖**，
- * 所以 `tests/settings-schema.test.mjs` 能 import 它并把两组设置解析一遍（装载器
+ * 所以 `tests/settings-schema.test.mjs` 能 import 它并把设置解析一遍（装载器
  * 仍然要从**本模块**读到 `Config`，所以这里 import 之后再 re-export）。
  *
  * 0.1.7 删掉了「设置命名空间 + `settings.installSection`」这一整套 API，改成
@@ -84,7 +92,7 @@ export { CONVERT_SETTINGS_SCHEMA }
  * 客户端按**路径**寻址（例如 `{op:'set', path:['knowledge','recallTopK']}`）。
  */
 import { Config, type KnowledgePluginConfig } from './config-schema.js'
-import { buildModelRequest, collectModelText } from './model-text.js'
+import { buildModelRequest, callModelWithRetry, collectModelText } from './model-text.js'
 import {
   addSourceCallView, addSourceMetaOf, addSourceResultMarkdown,
   importCallView, importMetaOf, importResultMarkdown,
@@ -263,7 +271,7 @@ function escapeHtml(value: string): string {
 /**
  * 独立整页的 HTML 外壳。
  *
- * 与 Notebook 的整页同一个形状，而且**只做三件事**：标题、挂载点、把自己那个 bundle
+ * 与知识库原文整页相同的挂载形状，而且**只做三件事**：标题、挂载点、把自己那个 bundle
  * 拉起来。正文不在外壳里 —— 页面自己去 `/knowledge/documents/:docId/content` 一页一页地取，
  * 所以这份 HTML 的大小与文档大小无关。
  */
@@ -372,29 +380,23 @@ function normalizeKnowledge(next: Partial<KnowledgeConfig> | undefined): Knowled
   return {
     ...DEFAULT_KNOWLEDGE_CONFIG,
     ...plain,
-    agentRoot: typeof plain.agentRoot === 'string' && plain.agentRoot.trim() ? plain.agentRoot : defaultAgentRoot(),
-    rootDir: typeof plain.rootDir === 'string' ? plain.rootDir : '',
+    // 根目录是 DSH 下的 Tita Agent 专属目录，不再是用户可切换的设置。
+    // 旧值即使还存在于宿主配置中，也不参与路径解析。
+    agentRoot: defaultAgentRoot(),
+    // 仅保留字段形状，避免旧配置无法解析；新逻辑不读取旧知识树。
+    rootDir: '',
+    // 产品检索固定使用多路径融合。旧版单路选择仍可解析，但不再改变运行行为。
+    recallMode: 'hybrid',
   }
 }
 
 
 export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): void {
-  /**
-   * 0029：配置里现在有两个路径字段，但只有 `agentRoot` 是「设置」。
-   *
-   * `rootDir` 是旧布局的知识树根，只作为迁移来源存在。初始值给空串而不是旧默认值
-   * ——迁移的来源由下面的 `legacySource()` 决定，它还要考虑「没设过 rootDir 的
-   * 用户，旧树在旧默认位置」这一种情况。
-   *
-   * 0.1.7：值来自本 entry 的 `config`（`apply` 的第二个参数），不再是
-   * `settings.installSection` 推回来的命名空间。这里先 `normalizeKnowledge` 补齐，
-   * 之后的迁移与 runtime 都只认这一份配置。
-   */
   let config: KnowledgeConfig = normalizeKnowledge(pluginConfig.knowledge)
   /**
    * entry config 的另外两组，**按需求值**。
    *
-   * 为什么是函数而不是先解包成一个值：0.1.7 的设置字段全标了 volatile，schema
+   * 为什么是函数而不是先解包成一个值：`convert` 的可编辑字段标了 volatile，schema
    * 解析出来是引用；解包一次就是一张快照，而 volatile 改动**不会重载插件**
    * （loader 只就地改引用、再发一个 `loader/volatile-update`）。函数让下游每次
    * 「重灌」都从同一个引用重新读值，改设置才真的会生效。
@@ -409,38 +411,16 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
    * `applyIntent`）。
    */
   let convertHost: ConvertHost | undefined
-  /** 知识树迁移的结论。`/knowledge/layout` 会带上它，界面据此如实交代数据搬没搬。 */
-  let migration: MigrationOutcome = { status: 'skipped', reason: '尚未解析设置' }
-  /** 家当（模型 / Python 环境 / 注册表）迁移的结论。 */
-  let resourceMigration: MigrationOutcome = { status: 'skipped', reason: '尚未解析设置' }
-  /** 记忆段（知识树 → `<agentRoot>/memory/<库 id>`）迁移的结论（0032）。 */
-  let memoryMigration: MigrationOutcome = { status: 'skipped', reason: '尚未解析设置' }
   /**
    * 初始化失败的原因（如果有）。字段名保持 `settingsError`：`/knowledge/layout`
    * 与面板上的告警都按这个名字读，改名的收益不如改语义的成本高。
    *
    * 旧的理由是「设置分区注册失败会被静默吞掉」（v0.7.5 的
    * `z.string().min(1).default('')` 让整个命名空间注册不上）。0.1.7 之后 schema
-   * 错误会在装载 entry 时就抛、插件直接加载失败，不再是静默的；但**迁移**仍可能
-   * 因为一个权限问题失败，而那条失败不该让插件起不来，所以这里依旧接住并上报。
+   * 错误会在装载 entry 时就抛、插件直接加载失败，不再是静默的；这里仍保留错误
+   * 视图，便于报告布局初始化失败。
    */
   let settingsError: string | undefined
-  /**
-   * 迁移只该发生一次 —— 实际含义是「每次 apply 最多一次」。
-   *
-   * 0.1.7 下改设置会让插件**整个重载**，apply 因此会再跑一遍。用「已经跑过」而不是
-   * 「结果如何」做闸门，是为了不让一个失败的迁移在重载时被反复重试。
-   */
-  let migrationDone = false
-
-  /**
-   * 迁移的旧位置来源。
-   *
-   * 显式设过 `rootDir` 就用它；否则退回旧默认位置（`DSH_KNOWLEDGE_ROOT` 或
-   * `~/Desktop/titaagent/domain_knowledge`）。判据交给 `migrateLegacyKnowledgeTree`，
-   * 这里只负责「谁可能是旧树」。
-   */
-  const legacySource = (): string => config.rootDir.trim() || legacyDefaultKnowledgeRoot()
 
   /**
    * #3b：把 **DSH 的默认模型**包成运行时认识的纯文本调用。
@@ -449,10 +429,13 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
    * DSH 自己的 `agentDefaultModel`（设置里那一项）。插件再存一份，就会出现「设置里显示
    * A、实际调的是 B」—— 0029 想收拢的正是这类两处说法。
    *
-   * 取不到 `llm` 或默认模型时返回 undefined，链路**退回纯规则抽取**：模型是增强，
-   * 不是前提。
+   * 取不到 `llm` 或所选模型时返回原因，链路**退回纯规则抽取**：模型是增强，不是前提。
+   * 选择“跟随默认”时才读取 `agentDefaultModel`；固定模型不依赖默认模型服务。
    */
-  const modelSeamFor = (): ModelSeam => {
+  /** 注册表在默认 runtime 之后才构造；用一个可替换的读取器避开构造期 TDZ。 */
+  let compileModelForBase: (id: string) => CompileModelSelection = () => ({ ...DEFAULT_COMPILE_MODEL })
+
+  const modelSeamFor = (kbId = DEFAULT_KB_ID): ModelSeam => {
     /**
      * **只能用 `ctx.get(name)`，不能用属性访问。**
      *
@@ -464,8 +447,11 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
      *
      * 本机探针（cordis 4.0.4）实测：`ctx.get` 能看见后来才注册的服务，属性访问抛异常。
      */
-    const llm = ctx.get('llm') as
-      { stream(options: Record<string, unknown>): AsyncIterable<{ type?: string; text?: string }> } | undefined
+    const llm = ctx.get('llm') as {
+      stream(options: Record<string, unknown>): AsyncIterable<{ type?: string; text?: string }>
+      resolveCallConfig?: (config: Record<string, unknown>) => Promise<unknown>
+      listModels?: (provider: string) => Promise<Array<{ id: string; name?: string; description?: string }>>
+    } | undefined
     if (!llm) return { why: '当前上下文里取不到 `llm` 服务（模型调用入口）' }
 
     /**
@@ -477,16 +463,48 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
      * 所以那个类自己也是用 `this.config.provider.get()` 读的。第一版就是按普通属性读的，
      * 结果是永远拿到 undefined —— 模型接缝静默失效。
      */
-    const service = ctx.get('agentDefaultModel') as
-      { currentSelection?: () => { provider?: string; model?: string; reasoningEffort?: string } } | undefined
-    if (!service) return { why: '当前上下文里取不到 `agentDefaultModel` 服务 —— 默认模型那一行可能没挂上' }
-    const route = service.currentSelection?.()
-    if (!route?.provider || !route?.model) {
-      return { why: `默认模型没有选好（provider=${route?.provider ?? '空'} / model=${route?.model ?? '空'}）` }
+    const configured = compileModelForBase(kbId)
+    let defaultProvider: string | undefined
+    let defaultModel: string | undefined
+    let reasoningEffort: string | undefined
+    if (configured.mode === 'default') {
+      const service = ctx.get('agentDefaultModel') as
+        { currentSelection?: () => { provider?: string; model?: string; reasoningEffort?: string } } | undefined
+      if (!service) return { why: '当前上下文里取不到 `agentDefaultModel` 服务 —— 默认模型那一行可能没挂上' }
+      const route = service.currentSelection?.()
+      defaultProvider = route?.provider
+      defaultModel = route?.model
+      reasoningEffort = route?.reasoningEffort
+      if (!defaultProvider || !defaultModel) {
+        return { why: `默认模型没有选好（provider=${defaultProvider ?? '空'} / model=${defaultModel ?? '空'}）` }
+      }
+    }
+    const provider = configured.mode === 'fixed' ? configured.provider : defaultProvider
+    const model = configured.mode === 'fixed' ? configured.model : defaultModel
+    const effectiveReasoningEffort = configured.reasoningEffort || (configured.mode === 'default' ? reasoningEffort : undefined)
+    if (!provider || !model) {
+      return { why: `编译模型没有选好（provider=${provider ?? '空'} / model=${model ?? '空'}）` }
     }
-    const { provider, model, reasoningEffort } = route
     return {
-      call: async ({ system, prompt, sessionId }) => {
+      provider,
+      model,
+      ...(effectiveReasoningEffort ? { reasoningEffort: effectiveReasoningEffort } : {}),
+      call: async ({ system, prompt, sessionId, onUsage, onDelta }) => {
+        /**
+         * 先走 DSH 的公开解析接口，再开始发 prompt。这样固定模型过期、默认模型失效时，
+         * 编译会在模型调用边界明确失败，而不是落成一次看似成功的规则抽取。
+         */
+        if (llm.resolveCallConfig) {
+          try {
+            await llm.resolveCallConfig({
+              provider, model,
+              ...(effectiveReasoningEffort ? { reasoningEffort: effectiveReasoningEffort } : {}),
+            })
+          } catch (cause) {
+            const detail = cause instanceof Error ? cause.message : String(cause)
+            throw new Error(`编译模型不可用（${provider}/${model}）：${detail}`)
+          }
+        }
         /**
          * 请求形状与收流都交给 `model-text.ts`（0044 实机验证第三～五批）。
          *
@@ -497,16 +515,34 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
          * （OpenCode 系路由回 400 `MissingSessionID`）。
          */
         const request = buildModelRequest({
-          provider, model, reasoningEffort, system, prompt,
+          provider, model, reasoningEffort: effectiveReasoningEffort, system, prompt,
           // 运行时按知识库给；接缝被单独调用时（测试）退回一个稳定值，
           // 而不是留空 —— 留空会在 OpenCode 路由上 400。
           sessionId: sessionId ?? 'knowledge:default',
         })
-        return collectModelText(llm.stream(request) as AsyncIterable<never>)
+        /**
+         * 流在**半路**结束要重发，不要一次失败就作废整份文档。
+         *
+         * 知识抽取是本插件里最长的一次模型调用（实机：约四万输出 token、两三分钟），
+         * 而上游网关 / 本机代理 / 账号额度任何一处抖一下，流就会在没给
+         * `finish_reason` 的情况下结束。适配器把这件事报成
+         * `TRANSPORT: Stream ended without finish_reason`，过去一次抖动就等于
+         * 「这份文档抽取失败」，人在界面上看到的是「全部失败」。
+         *
+         * 重发用的是**同一个请求**：提示词、sessionId、reasoningEffort 全不变，
+         * 所以缓存亲和仍然成立。不可重试的错误（凭据、请求体、截断、用户取消）
+         * 由 `isRetryableModelFailure` 放行，不在错的地方多等两分钟。
+         */
+        return callModelWithRetry(
+          onDeltaOfAttempt => collectModelText(llm.stream(request) as AsyncIterable<never>, onUsage, onDeltaOfAttempt),
+          { ...(onDelta ? { onDelta } : {}) },
+        )
       },
     }
   }
+  let environment: KnowledgeEnvironment
   const runtimeOptions = (): KnowledgeRuntimeOptions => ({
+    environmentGuard: kind => environment.requireReady(kind),
     // 0029：家当目录。配置里三个路径为空时，运行时从这里解析模型与解释器。
     resourceRoot: resourceRoot(config.agentRoot),
     // 0032：记忆段。默认库的记忆落在 `<agentRoot>/memory/default`，与知识树平级。
@@ -543,10 +579,119 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     // 0044：非默认库的 runtime 也要拿到模型接缝。只传 `config` 不够 —— 默认库走上面
     // 那个 `new KnowledgeRuntime(... runtimeOptions())`，别的库走注册表这条支路，
     // 两边必须都带上，否则「新建一个库 → 导入文档」静默变成规则抽取。
-    runtimeOptions: () => ({ modelSeam: modelSeamFor }),
+  runtimeOptions: () => ({ resourceRoot: resourceRoot(config.agentRoot), modelSeam: modelSeamFor, environmentGuard: kind => environment.requireReady(kind) }),
   })
+  compileModelForBase = id => bases.compileModelOf(id)
   runtime.baseId = bases.defaultId
   activeKnowledgeBases = bases
+  environment = new KnowledgeEnvironment({
+    resourceRoot: resourceRoot(config.agentRoot),
+    snapshot: () => ({ config: runtime.config, paths: runtime.resourcePaths() }),
+    probe: kind => runtime.environmentProbe(kind),
+    compileStatus: () => runtime.compileModelStatus(),
+    reload: () => { runtime.reloadResources(); bases.reloadResources() },
+    activateSelection: async selection => {
+      const keys = ['embeddingProvider', 'embeddingModel', 'embeddingDimension', 'rerankProvider', 'rerankModel'] as const
+      const previous = Object.fromEntries(keys.map(key => [key, config[key]]))
+      const managed = { embeddingProvider: 'wemm-python', embeddingModel: '', embeddingDimension: embeddingModel(selection.embedding).dimension, rerankProvider: 'bert-python', rerankModel: '' }
+      const write = async (values: Record<string, unknown>): Promise<void> => {
+        const group = pluginConfig.knowledge as unknown as Record<string, unknown> | undefined
+        if (!group) throw new Error('模型设置不可写')
+        for (const key of keys) {
+          const reference = group[key] as { write?: (value: unknown) => unknown } | undefined
+          if (reference && typeof reference.write === 'function') await reference.write(values[key])
+          else group[key] = values[key]
+        }
+        config = normalizeKnowledge(pluginConfig.knowledge)
+        runtime.updateConfig(config); bases.updateRuntimeConfig(config)
+      }
+      try { await write(managed) } catch (cause) { await write(previous); throw cause }
+      return () => {
+        const current = normalizeKnowledge(pluginConfig.knowledge)
+        // A later manual setting change belongs to the user and must survive rollback.
+        const restored = Object.fromEntries(keys.map(key => [key, current[key] === managed[key] ? previous[key] : current[key]]))
+        return write(restored)
+      }
+    },
+  })
+  // Reuse a matching persisted probe after restart; only stale or missing reports need a resource check.
+  if (environment.view().report.state !== 'ready') void environment.check(false).catch(() => undefined)
+
+  type CompileModelCatalogItem = { provider: string; id: string; name: string; description?: string; available: boolean; current?: boolean; reasoning?: { efforts: Array<{ id: string; name: string; description?: string }>; defaultEffort?: string } }
+  const compileModelCatalog = async (kbId: string, queryModelRoute: { provider?: string; model?: string } = {}): Promise<{
+    selection: CompileModelSelection
+    default: { provider?: string; model?: string; reasoningEffort?: string; available: boolean }
+    models: CompileModelCatalogItem[]
+    why?: string
+  }> => {
+    const service = ctx.get('agentDefaultModel') as
+      { currentSelection?: () => { provider?: string; model?: string; reasoningEffort?: string } } | undefined
+    const defaultRoute = service?.currentSelection?.() ?? {}
+    const llm = ctx.get('llm') as {
+      listModels?: (provider: string) => Promise<Array<{ id: string; name?: string; description?: string }>>
+      listProviders?: () => Array<{ id: string; name: string }>
+      resolveModelInfo?: (provider: string, model: string) => Promise<{ reasoning?: CompileModelCatalogItem['reasoning'] }>
+    } | undefined
+    const providers = [...new Set([...(llm?.listProviders?.() ?? []).map(provider => provider.id), defaultRoute.provider, compileModelForBase(kbId).provider].filter((value): value is string => Boolean(value)))]
+    const models: CompileModelCatalogItem[] = []
+    const failures: string[] = []
+    if (!llm?.listModels) {
+      failures.push('当前上下文没有 DSH 模型目录服务')
+    } else {
+      for (const provider of providers) {
+        try {
+          const entries = await llm.listModels(provider)
+          for (const entry of entries) {
+            if (!entry?.id) continue
+            models.push({
+              provider,
+              id: entry.id,
+              name: entry.name?.trim() || entry.id,
+              ...(entry.description ? { description: entry.description } : {}),
+              available: true,
+              ...(entry.id === defaultRoute.model && provider === defaultRoute.provider ? { current: true } : {}),
+            })
+          }
+        } catch (cause) {
+          failures.push(`${provider}: ${cause instanceof Error ? cause.message : String(cause)}`)
+        }
+      }
+    }
+
+    const selection = compileModelForBase(kbId)
+    const effortProvider = selection.mode === 'fixed' ? selection.provider : defaultRoute.provider
+    const effortModel = selection.mode === 'fixed' ? selection.model : defaultRoute.model
+    const requestedProvider = queryModelRoute.provider || effortProvider
+    const requestedModel = queryModelRoute.model || effortModel
+    if (requestedProvider && requestedModel && llm?.resolveModelInfo) {
+      const item = models.find(model => model.provider === requestedProvider && model.id === requestedModel)
+      if (item) {
+        try { item.reasoning = (await llm.resolveModelInfo(requestedProvider, requestedModel)).reasoning }
+        catch (cause) { failures.push(`思考强度目录：${cause instanceof Error ? cause.message : String(cause)}`) }
+      }
+    }
+    const selected = selection.mode === 'fixed' && selection.provider && selection.model
+      ? models.find(item => item.provider === selection.provider && item.id === selection.model)
+      : undefined
+    if (selection.mode === 'fixed' && selection.provider && selection.model && !selected) {
+      models.unshift({ provider: selection.provider, id: selection.model, name: selection.model, available: false, current: true })
+    }
+    const defaultAvailable = Boolean(
+      defaultRoute.provider && defaultRoute.model
+      && models.some(item => item.provider === defaultRoute.provider && item.id === defaultRoute.model && item.available),
+    )
+    return {
+      selection,
+      default: {
+        ...(defaultRoute.provider ? { provider: defaultRoute.provider } : {}),
+        ...(defaultRoute.model ? { model: defaultRoute.model } : {}),
+        ...(defaultRoute.reasoningEffort ? { reasoningEffort: defaultRoute.reasoningEffort } : {}),
+        available: defaultAvailable,
+      },
+      models,
+      ...(failures.length > 0 ? { why: failures.join('；') } : {}),
+    }
+  }
 
   const kbIdOf = (value: unknown): string => {
     if (value === undefined || value === null) return bases.defaultId
@@ -559,7 +704,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
    *
    * `Entry._commitVolatile()` 只调 `updateVolatile()` 就地改引用，再发一个
    * `loader/volatile-update` 事件。所以「设置存下了但没生效」这件事只能在这里兜住 ——
-   * 设置 schema 里的字段全部标了 volatile（见 `settings-volatile.ts`），这两件事必须成对。
+   * 设置 schema 里的可编辑字段标了 volatile（见 `settings-volatile.ts`），这两件事必须成对。
    *
    * 就地更新之所以够用，是因为 `pluginConfig` 就是宿主那份被改过的对象：重新
    * `normalizeKnowledge` 一下就能拿到新值。
@@ -579,6 +724,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     const previousAgentRoot = config.agentRoot
     config = normalizeKnowledge(pluginConfig.knowledge)
     runtime.updateConfig(config)
+    bases.updateRuntimeConfig(config)
     /**
      * 转换设置挂在同一个 entry 上，volatile 事件需要让转换宿主重新读取。
      */
@@ -613,66 +759,12 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
   }
 
   /**
-   * 给每个知识库搬记忆段（0032）。
-   *
-   * 结论只保留**最后一个非 skipped 的**：默认库才是用户实际在用的那个，而面板上
-   * 一行位置有限。真有多个库搬失败时，`/knowledge/layout` 的 `resourceMigration`
-   * 与知识库列表里的路径仍然能对上账。
-   */
-  const migrateAllMemory = (): MigrationOutcome => {
-    const bases = activeKnowledgeBases
-    if (!bases) return { status: 'skipped', reason: '知识库注册表尚未就绪' }
-    let outcome: MigrationOutcome = { status: 'skipped', reason: '每个知识库的记忆都在新位置' }
-    const roots = bases.list()
-    const defaultBase = roots.find(item => item.id === bases.defaultId)
-    // 默认库的根由配置推出来，可能还没出现在注册表里（首启）；补上它。
-    const plan = defaultBase ? roots : [{ id: bases.defaultId, rootDir: defaultBaseRoot() }, ...roots]
-    for (const base of plan) {
-      try {
-        const moved = migrateLegacyMemory({ agentRoot: config.agentRoot, kbRoot: base.rootDir, kbId: base.id })
-        if (moved.status !== 'skipped') outcome = moved
-      } catch (cause) {
-        outcome = {
-          status: 'failed',
-          from: join(base.rootDir, '04_memory'),
-          to: memoryRoot(config.agentRoot, base.id),
-          reason: cause instanceof Error ? cause.message : String(cause),
-        }
-      }
-    }
-    return outcome
-  }
-
-  /**
-   * 初始化：迁移 → 布局 → 构造 runtime。
+   * 初始化：只创建新布局，再构造 runtime。
    *
-   * 顺序是**硬要求**：配置已由外层的 `normalizeKnowledge` 补齐，这里先迁移（迁移要读
-   * 新的 `agentRoot` 与旧的 `rootDir`），最后才构造 runtime。反过来的话，runtime 会在
-   * 数据搬完之前就指着新路径，于是「刚启动时知识库是空的」——而那正是最容易让人以为
-   * 数据丢了的时刻。
-   *
-   * 0.1.7：这段以前挂在 `settings.installSection` 的 `setSource`/`onChange` 回调里，
-   * 因为配置要等设置层推回来。现在配置是 `apply` 的入参，所以直接在 apply 时跑一次；
-   * 改设置会让插件**整个重载**，于是它会随重载再跑，由 `migrationDone` 挡住重复迁移。
+   * 旧版的 `rootDir`、旧 Agent 根路径和旧家当目录都不再参与启动流程。这样新安装的
+   * 数据路径是确定的，也不会因为启动而改动用户现有目录。
    */
   const initialize = (): void => {
-    if (!migrationDone) {
-      migrationDone = true
-      // 顺序：先把知识树搬进新根路径，再把家当搬进来。家当要在 runtime 构造**之前**
-      // 到位 —— 否则模型与解释器会先按旧位置解析一次，那一轮跑的是旧环境。
-      migration = migrateLegacyKnowledgeTree({ agentRoot: config.agentRoot, legacyRoot: legacySource() })
-      resourceMigration = migrateLegacyResources({ agentRoot: config.agentRoot, legacyHome: legacyResourceHome() })
-      /**
-       * 0032：记忆段从知识树搬出去。**每个知识库各搬一次** —— 它按库分叉，而
-       * 非默认库的 runtime 是懒建的（`runtimeOf`），懒建里做迁移会把「打开一个库」
-       * 变成一次可能的搬盘。放在这里，顺序与另外两个迁移一致：搬完才构造 runtime。
-       *
-       * 逐个 try：一个库搬不动不该让其余的也不搬，更不该让插件起不来。
-       */
-      memoryMigration = migrateAllMemory()
-      // 注册表可能刚被搬进来：让它按新位置重新读一遍。
-      void bases.repoint()
-    }
     ensureAgentLayout(config.agentRoot)
     runtime.close()
     runtime = new KnowledgeRuntime(defaultBaseRoot(), config, runtimeOptions())
@@ -684,9 +776,9 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
   /**
    * 初始化失败必须留下痕迹。
    *
-   * 迁移会因为权限、占用、半个快照这类原因失败；而它抛出的异常如果没人接，就只是
-   * 一次没人看见的失败 —— 面板照常显示，数据却没搬。抓住它、记下来、让
-   * `/knowledge/layout` 报出去，界面于是能说「为什么不对」，而不是只显示症状。
+   * 创建新布局或构造 runtime 会因为权限、占用等原因失败；而它抛出的异常如果没人接，
+   * 就只是一次没人看见的失败。抓住它、记下来、让 `/knowledge/layout` 报出去，
+   * 界面于是能说「为什么不对」，而不是只显示症状。
    *
    * 注意这里**不吞配置错误**：schema 不合法的 config 在装载 entry 时就已经让插件
    * 加载失败了（那是响亮的）。这里接住的只是初始化期的数据问题。
@@ -726,45 +818,122 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     // 0.1.7：转换的设置不再走命名空间，随本 entry 的 config 一起下来。
     // 给函数而不是值：字段是 volatile 引用，解包一次就是快照（见 `convertGroup`）。
     config: convertGroup,
-    // 0019: a delivery can target one knowledge base (the panel imports into the
-    // base the user selected). Unknown/absent id falls back to the default base
-    // instead of failing the ingest.
-    resolveTarget: (kbId?: string) => {
-      const target = kbId ? runtimeOf(kbId) : undefined
-      return target ? { runtime: target, knowledgeRoot: target.rootDir } : { runtime, knowledgeRoot: runtime.rootDir }
+    // 0019: an omitted id selects the default base in the host. An explicit id
+    // must resolve here; otherwise ingestion fails instead of writing to a
+    // different knowledge base while reporting the requested id.
+    resolveTarget: (kbId: string) => {
+      const target = runtimeOf(kbId)
+      return target ? { runtime: target, knowledgeRoot: target.rootDir } : undefined
     },
   })
 
   // 意图记录模块 (issue 0020). The 意图 view was already one of this plugin's
   // five panel tabs, but its Host lived in a second mount unit; 0020 folds it in
   // so the declared information architecture and the code layout agree again.
-  // It keeps the `intent_record` / `intent_store_view` tools and the `/intent/**` read-only surface,
+  // It keeps the `intent_record` / `intent_store_view` tools and `/intent/**` audit endpoints,
   // and — critically — the `titaDataAgentIntent` Cordis service that `data-table`
   // resolves by name.
   // 意图只保留固定的会话审计契约；可编辑词表不再属于插件配置。
-  applyIntent(ctx, { intentRoot: () => intentRoot(config.agentRoot) })
+  applyIntent(ctx, {
+    intentRoot: () => intentRoot(config.agentRoot),
+  })
+  // `applyIntent` provides this service from the same plugin fiber. During
+  // `apply()`, that fiber is still starting, so Cordis's default strict lookup
+  // hides the just-provided service until startup completes. The non-strict
+  // lookup is safe here because `applyIntent` ran immediately above.
+  const intentService = ctx.get(INTENT_SERVICE, false) as IntentService
+  /**
+   * `intent_*` 工具在 Host 层注册，使标准模式可以调用它们；工具执行端只接受
+   * standard 会话，其他 preset 不会写入或读取意图记录。
+   */
+  ctx.effect(
+    () => registerIntentTools(ctx as unknown as { tools: { register(definition: unknown): unknown } }, intentService),
+    'tita knowledge: global intent tools',
+  )
+
+  /**
+   * 规则正文由当前会话 preset 决定；设置里的 volatile 引用在每次组装提示词时解包，
+   * 因此开关保存后立即生效，不需要重建 Agent 会话。
+   */
+  ctx.effect(() => ctx.systemPrompt.section({
+    name: 'dsh-data-domain-knowledge:behavior-rules',
+    order: ctx.systemPrompt.getSectionOrder('TOOLS_SDK') + 1,
+    text: ({ agent }) => {
+      return behaviorPromptForPreset(
+        agent?.session?.header?.agentPreset,
+        unwrapGroup<{ enabled?: boolean }>(pluginConfig.behaviorRules).enabled !== false,
+      )
+    },
+  }), 'tita knowledge: agent behavior rules')
 
   /**
-   * 需要本轮用户审批的写工具。
+   * 需要本轮用户审批的知识写工具。`image_publish` 只写入本地素材目录，按用户要求免审批。
    *
    * 0044 换过一批名字：`write_knowledge_card`（只接受已确认提议）退役了，因为正文现在
    * 只读、卡片由编译直接写入；`list_card_proposals` 也退役了，因为待办队列不存在了。
    * 新增的两个是**入库之后**的动作：加备注、review 抬分。
    */
-  const writeTools = new Set(['add_source', 'import_sources', 'propose_wiki_cards', 'annotate_wiki_card', 'review_wiki_card', 'set_knowledge_status', 'rebuild_knowledge', 'record_feedback'])
+  ctx.tools.register(tool('run_knowledge_pipeline', 'Run one independent knowledge stage. Import only saves sources by default. Stages: extract Fact/Procedure/Case, normalize axes, derive Procedure from Case, materialize Wiki Fact/Wiki Way, build section indexes, or all. Returns a durable background task; inspect it with get_knowledge_pipeline.', {
+    stage: { type: 'string', required: true, enum: ['extract', 'normalize', 'derive', 'materialize', 'build', 'all'] },
+    kb: { type: 'string' }, source_ids: { type: 'array', description: 'Optional explicit source IDs; omit for all sources. An empty selection is rejected.' },
+    group_keys: { type: 'array', description: 'Optional full card group keys returned by get_knowledge_pipeline.' }, force: { type: 'boolean', description: 'Explicitly rerun the selected stage despite an unchanged checkpoint.' },
+  }, async args => withRuntime(args.kb, async target => {
+    const pipeline = await target.pipeline()
+    const { task } = pipeline.start(args.stage as PipelineStage, { sourceIds: args.source_ids, groupKeys: args.group_keys, force: args.force === true })
+    return success({ task, url: `/knowledge/pages/tasks?kb=${encodeURIComponent(target.baseId)}&task=${encodeURIComponent(task.id)}` })
+  })))
+  ctx.tools.register(tool('get_knowledge_pipeline', 'Read pending stages, materializable card groups, persistent task history, or incremental public model output. Use the returned next cursor as after on the next call.', {
+    kb: { type: 'string' }, task_id: { type: 'string' }, after: { type: 'integer' },
+  }, async args => withRuntime(args.kb, async (target): Promise<Envelope<Record<string, unknown>>> => {
+    const pipeline = await target.pipeline()
+    return args.task_id
+      ? success({ task: pipeline.store.task(args.task_id) ?? null, ...pipeline.store.events(args.task_id, Math.max(0, args.after ?? 0)) })
+      : success({ status: await target.pipelineStatus(), ...pipeline.store.tasks() })
+  })))
+  const writeTools = new Set(['add_source', 'import_sources', 'propose_wiki_cards', 'annotate_wiki_card', 'review_wiki_card', 'set_knowledge_status', 'rebuild_knowledge', 'run_knowledge_pipeline', 'record_feedback'])
   ctx.on('tools/pre-execute', (exec, next): Promise<PreToolDecision> => {
     if (writeTools.has(exec.name)) return Promise.resolve({ kind: 'ask', reason: '该操作会写入 Tita Knowledge Store，需要本轮用户审批。' })
     return next()
   })
-  ctx.tools.register(tool('recall_knowledge', 'Recall compiled knowledge through keyword and vector candidate routes, rerank wiki sections, then return the top wiki cards with their matched sections and provenance.', { query: { type: 'string', required: true }, limit: { type: 'integer' }, top_k: { type: 'integer' }, top_n: { type: 'integer' }, rerank: { type: 'boolean' }, context_max_chars: { type: 'integer', description: '这次召回的上下文字符上限；省略则用设置里的值（默认 20000，0 = 不限）。超出部分落在系统临时目录，响应里的 budget.overflow_path 就是它的绝对路径 —— 需要更多信息时直接读那个文件。' }, include_problems: { type: 'boolean' }, mode: { type: 'string', enum: ['fts', 'vector', 'hybrid'] }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, parent_subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.recall(args.query, args.top_k ?? args.limit, args.include_problems ?? false, args.mode as RecallMode | undefined, lineageOf(args, exec), { contextTopN: args.top_n, rerank: args.rerank, ...(typeof args.context_max_chars === 'number' ? { contextMaxChars: args.context_max_chars } : {}) })), {
+  ctx.tools.register(tool('recall_knowledge', 'Recall Wiki Fact and Wiki Way through H2 title and body search. Use the current subquestion as query when seeking a Procedure. Return complete Wiki files with conditions and evidence. Use get_knowledge_cases for historical Case evidence; a past root cause does not establish the current root cause.', { query: { type: 'string', required: true }, limit: { type: 'integer' }, top_k: { type: 'integer' }, top_n: { type: 'integer' }, rerank: { type: 'boolean' }, context_max_chars: { type: 'integer', description: '这次召回的上下文字符上限；省略则用设置里的值（默认 20000，0 = 不限）。超出部分落在系统临时目录，响应里的 budget.overflow_path 就是它的绝对路径 —— 需要更多信息时直接读那个文件。' }, include_problems: { type: 'boolean' }, mode: { type: 'string', enum: ['fts', 'vector', 'hybrid'] }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, parent_subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.recall(args.query, args.top_k ?? args.limit, args.include_problems ?? false, args.mode as RecallMode | undefined, lineageOf(args, exec), { contextTopN: args.top_n, rerank: args.rerank, ...(typeof args.context_max_chars === 'number' ? { contextMaxChars: args.context_max_chars } : {}) })), {
     call: recallCallView,
     // 查询词从参数来，命中从结果来 —— 两者拼成一张能看懂的账本。
     meta: (args, value) => recallMetaOf({ ...dataOf(value), query: args?.query }),
     result: resultViewOf(recallResultMarkdown),
   }))
+  ctx.tools.register(tool('get_knowledge_cases', 'Read historical Case records referenced by Wiki metadata.case_refs. Timelines are evidence from a past instance, not proof of the present diagnosis.', {
+    case_ids: { type: 'array', required: true, description: 'Case IDs from Wiki metadata.case_refs; maximum 50 IDs.' },
+    version: { type: 'integer', description: 'Optional historical Case version from metadata.case_refs; requires exactly one case ID.' },
+    kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' },
+    run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' },
+  }, async args => withRuntime(args.kb, async target => {
+    const ids = [...new Set((Array.isArray(args.case_ids) ? args.case_ids : [])
+      .filter((id): id is string => typeof id === 'string' && id.trim() !== '').map(id => id.trim()))]
+    if (ids.length === 0) return failure({ cases: [], missing_ids: [] }, 'CASE_IDS_REQUIRED', '请传入 Wiki 的 case_refs 中的 Case ID。', false)
+    if (ids.length > 50) return failure({ cases: [], missing_ids: [] }, 'CASE_IDS_LIMIT', '一次最多读取 50 个 Case ID。', false)
+    if (args.version !== undefined && (ids.length !== 1 || !Number.isInteger(args.version) || args.version < 1)) return failure({ cases: [], missing_ids: ids }, 'CASE_VERSION_INVALID', '读取历史版本时，请传一个 Case ID 和正整数 version。', false)
+    const records = await Promise.all(ids.map(id => target.readCase(id, args.version)))
+    return success({ cases: records.filter(record => record !== undefined), missing_ids: ids.filter((_, index) => records[index] === undefined) })
+  })))
+  ctx.tools.register(tool('get_knowledge_events', 'Read Event records referenced by recalled WikiCards. Pass event IDs from card metadata.event_refs; the result includes full timelines, evidence, outcomes, and missing fields.', {
+    event_ids: { type: 'array', required: true, description: 'Event IDs from WikiCard metadata.event_refs; maximum 50 IDs.' },
+    kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' },
+    run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' },
+  }, async args => withRuntime(args.kb, async target => {
+    const ids = [...new Set((Array.isArray(args.event_ids) ? args.event_ids : [])
+      .filter((id): id is string => typeof id === 'string' && id.trim() !== '').map(id => id.trim()))]
+    if (ids.length === 0) return failure({ events: [], missing_ids: [] }, 'EVENT_IDS_REQUIRED', '请传入 WikiCard 的 event_refs 中的 Event ID。', false)
+    if (ids.length > 50) return failure({ events: [], missing_ids: [] }, 'EVENT_IDS_LIMIT', '一次最多读取 50 个 Event ID；请分批读取该 WikiCard 的 event_refs。', false)
+    const byId = new Map((await target.loadEvents()).map(event => [event.id, event]))
+    const events = ids.flatMap(id => {
+      const event = byId.get(id)
+      return event ? [event] : []
+    })
+    return success({ events, missing_ids: ids.filter(id => !byId.has(id)) })
+  })))
   ctx.tools.register(tool('check_knowledge_embeddings', 'Inspect the local embedding provider and binary/int8 vector index without loading the model.', { kb: { type: 'string' }, session_key: { type: 'string' } }, async args => withRuntime(args.kb, target => target.embeddingHealth())))
   ctx.tools.register(tool('query_knowledge_graph', 'Query entities, neighbors, paths, lists and relation types in the compiled knowledge graph.', { action: { type: 'string', enum: ['entity', 'neighbors', 'path', 'list', 'types'], required: true }, entity_id: { type: 'string' }, id: { type: 'string' }, entity_type: { type: 'string' }, from_id: { type: 'string' }, to_id: { type: 'string' }, type: { type: 'string' }, status: { type: 'string' }, include_problem: { type: 'boolean' }, limit: { type: 'integer' }, depth: { type: 'integer' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, parent_subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.graphQuery(args.action, args.entity_id ?? args.id, args.entity_type ?? args.type, args.depth ?? 1, { fromId: args.from_id, toId: args.to_id, status: args.status, includeProblem: args.include_problem ?? false, limit: args.limit ?? 50 }, lineageOf(args, exec)))))
-  ctx.tools.register(tool('query_source_truth', 'Read SourceRaw (原始可追溯文档) with access audit. Returns the top max_chars characters (default and hard max 40000) shared across the matched sources. Each source carries `returnedChars`, `totalChars` and `offset` (where this slice starts inside that source), and the envelope carries `offset` and `truncated`. When truncated is true the content is INCOMPLETE — call again with `offset` set to the number of characters you have already read in this pass (the running sum of `returnedChars`), and keep paging until `truncated` is false. Do not answer from a partial document.', { query: { type: 'string', required: true }, limit: { type: 'integer' }, max_chars: { type: 'integer' }, offset: { type: 'integer' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.sourceTruth(args.query, args.limit ?? 20, args.max_chars ?? 40000, lineageOf(args, exec), args.offset ?? 0))))
+  ctx.tools.register(tool('query_source_truth', 'Read SourceRaw (原始可追溯文档) with access audit. Each call returns up to `limit` matched sources and `max_chars` total characters. If `hasMoreInCurrentPage` is true, continue with `offset += returnedChars`. When it is false and `hasMoreSources` is true, continue with `source_offset = nextSourceOffset` and reset `offset` to 0. `truncated` stays true until both the current source page and all matching source pages are complete. Do not answer from partial content.', { query: { type: 'string', required: true }, limit: { type: 'integer' }, max_chars: { type: 'integer' }, offset: { type: 'integer' }, source_offset: { type: 'integer', description: '来源分页游标；当前页字符已读完后才使用 nextSourceOffset，并将 offset 重置为 0' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.sourceTruth(args.query, args.limit ?? 20, args.max_chars ?? 40000, lineageOf(args, exec), args.offset ?? 0, args.source_offset ?? 0))))
   /**
    * 知识库 id 的**发现入口**。
    *
@@ -792,6 +961,29 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     })),
   })))
 
+  const imagePublishParameters = {
+    file_path: { type: 'string', description: '宿主可读取的本地图片文件路径；与 content_base64 二选一' },
+    content_base64: { type: 'string', description: '图片的标准 Base64，或 data:image/...;base64,...；与 file_path 二选一' },
+    filename: { type: 'string', description: '可选文件名；默认使用 file_path 的文件名，Base64 输入默认 image-<hash>.<ext>' },
+    mime_type: { type: 'string', description: '可选 MIME 类型；必须与图片二进制内容一致' },
+    kb: { type: 'string', description: '知识库 id；省略时写入默认库' },
+  }
+  const publishImage = async (args: Args) => withRuntime(args.kb, async target => {
+    try {
+      return success(await publishKnowledgeImage(target.rootDir, target.baseId, {
+        filePath: args.file_path,
+        contentBase64: args.content_base64,
+        filename: args.filename,
+        mimeType: args.mime_type,
+      }))
+    } catch (cause) {
+      if (cause instanceof ImagePublishError) return failure({}, cause.code, cause.message, false, cause.suggestion)
+      return failure({}, 'IMAGE_PUBLISH_FAILED', `图片写入失败：${cause instanceof Error ? cause.message : String(cause)}`, true)
+    }
+  })
+  const imagePublishDescription = 'Publish one local image into a knowledge base assets bucket without user approval. Pass exactly one of `file_path` or `content_base64` (standard Base64 or a data URI); optional `filename` overrides the stored name, and optional `mime_type` must match the file bytes. Supports PNG, JPEG, GIF, WebP, AVIF, BMP and SVG up to 20 MiB. Returns the local asset URL and Markdown image reference.'
+  ctx.tools.register(tool('image_publish', imagePublishDescription, imagePublishParameters, publishImage))
+
   ctx.tools.register(tool('add_source', 'Add or update a SourceRaw document (原始可追溯文档). DSH requests one user approval before execution.', { title: { type: 'string' }, content: { type: 'string', required: true }, external_id: { type: 'string' }, metadata: { type: 'json' }, source_id: { type: 'string' }, allow_duplicate_title: { type: 'boolean', description: '默认 false：标题与已有来源重复时拒收（SOURCE_TITLE_DUPLICATED），要求改标题。传 true 才允许并存。' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.addSource({ title: args.title, content: args.content, externalId: args.external_id, metadata: args.metadata, sourceId: args.source_id, ...(args.allow_duplicate_title === true ? { allowDuplicateTitle: true } : {}), lineage: lineageOf(args, exec) })), {
     call: addSourceCallView,
     meta: (args, value) => addSourceMetaOf(args, dataOf(value)),
@@ -811,7 +1003,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
    * `compile` 默认开：批量导入的意图几乎总是「进来就能用」。关掉它的场景是「先全部
    * 落盘、稍后统一编译」——那时卡片还没生成，工具返回里会明说 `compile: null`。
    */
-  ctx.tools.register(tool('import_sources', 'Import many SourceRaw documents and compile them into Wiki cards in ONE call (one approval, one compile, per-source failures reported instead of aborting the batch). Use this instead of calling add_source repeatedly. DSH requests one user approval before execution.', { sources: { type: 'array', required: true, description: `来源数组，每项 { title?, content, external_id?, metadata?, allow_duplicate_title? }；一次最多 ${MAX_IMPORT_SOURCES} 份，超了请分批。标题与已有来源重复的那一份会被拒（SOURCE_TITLE_DUPLICATED），逐条报出来而不是整批失败` }, compile: { type: 'boolean', description: '默认 true：写入后立刻编译成 WikiCard。false 表示只落盘' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.importSources({ sources: (Array.isArray(args.sources) ? args.sources : []).map(item => ({ ...(item?.title ? { title: item.title } : {}), content: item?.content, ...(item?.external_id ? { externalId: item.external_id } : {}), ...(item?.metadata ? { metadata: item.metadata } : {}), ...(item?.allow_duplicate_title === true ? { allowDuplicateTitle: true } : {}) })), ...(args.compile === false ? { compile: false } : {}), lineage: lineageOf(args, exec) })), { call: importCallView, meta: (_args, value) => importMetaOf(dataOf(value)), result: resultViewOf(importResultMarkdown) }))
+  ctx.tools.register(tool('import_sources', 'Import many SourceRaw documents in one call. By default only stores sources. Explicit compile:true runs extract, normalize, materialize, and index publication for the imported documents. Per-source import failures are reported without aborting the batch. DSH requests one user approval before execution.', { sources: { type: 'array', required: true, description: `来源数组，每项 { title?, content, external_id?, metadata?, allow_duplicate_title? }；一次最多 ${MAX_IMPORT_SOURCES} 份，超了请分批。标题与已有来源重复的那一份会被拒（SOURCE_TITLE_DUPLICATED），逐条报出来而不是整批失败` }, compile: { type: 'boolean', description: '默认 false：只保存来源；显式 true 才运行完整抽取、归一与物化' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.importSources({ sources: (Array.isArray(args.sources) ? args.sources : []).map(item => ({ ...(item?.title ? { title: item.title } : {}), content: item?.content, ...(item?.external_id ? { externalId: item.external_id } : {}), ...(item?.metadata ? { metadata: item.metadata } : {}), ...(item?.allow_duplicate_title === true ? { allowDuplicateTitle: true } : {}) })), compile: args.compile === true, lineage: lineageOf(args, exec) })), { call: importCallView, meta: (_args, value) => importMetaOf(dataOf(value)), result: resultViewOf(importResultMarkdown) }))
   /**
    * `propose_wiki_cards` —— 把一批卡片**直接写进 `02_wiki`**（工具名不变，语义在 0044 改了）。
    *
@@ -824,9 +1016,9 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
    * 这个工具服务于另一条路：Agent 手里已经有结构化的卡片草案（例如从一次排查里读出来的），
    * 直接写进来，不必再走一遍抽取。
    */
-  ctx.tools.register(tool('propose_wiki_cards', 'Write Wiki cards compiled from a SourceRaw directly into 02_wiki. The confirmation gate was retired in 0044: cards land immediately and are marked unreviewed, so a human reviews them AFTER entry (review raises the card score; the body itself is read-only). Use the system fixed card template and coordinate entity identity. DSH requests one user approval before execution.', { source_id: { type: 'string', required: true, description: '这批卡片引用的那条 SourceRaw 的 source_id（先 add_source）' }, proposals: { type: 'array', required: true, description: '卡片数组，每项 { action?, entity_type, entity_id, title, summary?, content, source_refs?, metadata? }；content 使用系统固定卡片模板' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.writeCards({
+  ctx.tools.register(tool('propose_wiki_cards', 'Write Wiki cards compiled from a SourceRaw directly into 02_wiki. The confirmation gate was retired in 0044: cards land immediately and are marked unreviewed, so a human reviews them AFTER entry (review raises the card score; the body itself is read-only). Use the system fixed card template and coordinate entity identity. Existing cards are safely merged by appending new content and unioning source references; the only supported explicit action is `merge`. DSH requests one user approval before execution.', { source_id: { type: 'string', required: true, description: '这批卡片引用的那条 SourceRaw 的 source_id（先 add_source）' }, proposals: { type: 'array', required: true, description: '卡片数组，每项 { entity_type, entity_id, title, summary?, content, source_refs?, metadata? }；content 使用系统固定卡片模板。不要传 action；兼容旧调用只接受 action=merge。' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.writeCards({
     sourceId: args.source_id,
-    cards: (Array.isArray(args.proposals) ? args.proposals : []).map(item => ({ action: item?.action, entityType: item?.entity_type, entityId: item?.entity_id, title: item?.title, summary: item?.summary, content: item?.content, sourceRefs: item?.source_refs, metadata: item?.metadata })),
+    cards: (Array.isArray(args.proposals) ? args.proposals : []).map(item => ({ ...(item?.action ? { action: item.action } : {}), entityType: item?.entity_type, entityId: item?.entity_id, title: item?.title, summary: item?.summary, content: item?.content, sourceRefs: item?.source_refs, metadata: item?.metadata })),
     lineage: lineageOf(args, exec),
   })), {
     call: writeCardsCallView,
@@ -842,7 +1034,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
    * 有效评分压到 `ANOMALY_SCORE` —— 异常卡片照样召回得到，只是排在后面，
    * 而不是被藏起来（藏起来就没人会去修它）。
    */
-  ctx.tools.register(tool('annotate_wiki_card', 'Attach a human annotation to a Wiki card, or remove one. Wiki bodies are read-only — this is how a person records a judgement about a card ("this number disagrees with the source", "these two definitions conflict"). kind=anomaly additionally lowers the card score for recall ranking while keeping it retrievable. DSH requests one user approval before execution.', { entity_id: { type: 'string', required: true }, entity_type: { type: 'string' }, kind: { type: 'string', enum: ['note', 'anomaly'], description: '默认 note；anomaly 表示异常点' }, note: { type: 'string', description: '备注正文；撤销一条时省略并给 remove_id' }, author: { type: 'string' }, source_ref: { type: 'string', description: '这条备注针对哪一份来源（可选）' }, remove_id: { type: 'string', description: '要撤销的备注 id' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.annotateCard({
+  ctx.tools.register(tool('annotate_wiki_card', 'Attach a human annotation to a Wiki card, or remove one. Wiki bodies are read-only — this is how a person records a judgement about a card ("this number disagrees with the source", "these two definitions conflict"). kind=anomaly additionally lowers the card score for recall ranking while keeping it retrievable. Provide `note` to add, or `remove_id` to delete; do not provide both. DSH requests one user approval before execution.', { entity_id: { type: 'string', required: true }, entity_type: { type: 'string' }, kind: { type: 'string', enum: ['note', 'anomaly'], description: '默认 note；anomaly 表示异常点' }, note: { type: 'string', description: '备注正文；添加备注时提供' }, author: { type: 'string' }, source_ref: { type: 'string', description: '这条备注针对哪一份来源（可选）' }, remove_id: { type: 'string', description: '要撤销的备注 id；删除时只传此字段，不要同时传 note' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.annotateCard({
     entityId: args.entity_id,
     ...(args.entity_type ? { entityType: args.entity_type as SchemaType } : {}),
     ...(args.kind ? { kind: args.kind as 'note' | 'anomaly' } : {}),
@@ -867,7 +1059,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     lineage: lineageOf(args, exec),
   }))))
   ctx.tools.register(tool('set_knowledge_status', 'Change a Wiki card status. This status belongs to the Card lifecycle; it does not change Knowledge truth status. problem requires problem_note and recovery must pass through unreviewed. DSH requests one user approval before execution.', { entity_id: { type: 'string', required: true }, status: { type: 'string', enum: ['unreviewed', 'draft', 'reviewed', 'active', 'deprecated', 'problem'], required: true }, problem_note: { type: 'string' }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.setStatus(args.entity_id, args.status as CardStatus, args.problem_note, lineageOf(args, exec)))))
-  ctx.tools.register(tool('rebuild_knowledge', 'Rebuild schema/wiki/compiled knowledge indexes. DSH requests one user approval before execution.', { only: { type: 'string', enum: ['all', 'schema', 'wiki', 'embeddings'] }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.rebuild(args.only ?? 'all', lineageOf(args, exec))), {
+  ctx.tools.register(tool('rebuild_knowledge', 'Rebuild schema/wiki/compiled knowledge indexes from saved cards without document extraction. Use run_knowledge_pipeline for extract, normalize, materialize, or the full chain. DSH requests one user approval before execution.', { only: { type: 'string', enum: ['all', 'schema', 'wiki', 'embeddings'] }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.rebuild(args.only ?? 'all', lineageOf(args, exec), { extract: false })), {
     call: rebuildCallView,
     meta: (args, value) => rebuildMetaOf(args?.only ?? 'all', dataOf(value)),
     result: resultViewOf(rebuildResultMarkdown),
@@ -912,7 +1104,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
      * - `canLoadSample` 是空态的开关 —— 这个库还什么都没有时才为真。
      */
     const diagnosisPayload = (snapshot: Awaited<ReturnType<DiagnosisStore['snapshot']>>): Record<string, unknown> => ({
-      graph: snapshot.graph, cases: snapshot.cases, issues: snapshot.issues,
+      graph: snapshot.graph, cases: snapshot.cases, events: snapshot.events, issues: snapshot.issues,
       seeded: snapshot.seeded, migrated: snapshot.migrated, source: snapshot.source,
       canLoadSample: snapshot.canLoadSample, problems: snapshot.problems,
     })
@@ -931,17 +1123,41 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
         const swept = await resolved.runtime.sweepOrphans()
         if (swept === null) return sendEnvelope(res, failure({}, 'KNOWLEDGE_UNAVAILABLE', '这个部署上没有 Knowledge 库', false))
-        const { knowledge, cards } = swept
-        const total = knowledge.knowledgeDeleted + cards.deleted
+        const { knowledge, cards, events } = swept
+        const total = knowledge.knowledgeDeleted + cards.deleted + events.deleted + events.updated + swept.assets.files
         return send(res, 200, success(swept, total === 0
-          ? ['没有孤儿：每条知识的出处都还在库里。']
-          : [`清掉了 ${knowledge.knowledgeDeleted} 条没有出处的知识与 ${cards.deleted} 张没有依据的卡片。`]))
+          ? ['没有孤儿：Knowledge、Event 和 WikiCard 的来源都还在库里。']
+          : [`清掉了 ${knowledge.knowledgeDeleted} 条无来源 Knowledge、${events.deleted} 个无来源 Event（更新 ${events.updated} 个共享 Event）、${cards.deleted} 张无依据 WikiCard。`]))
+      } },
+      /**
+       * DSH 模型目录（知识库编译设置）。编译模型不是插件再维护一套供应商列表，
+       * 而是每次从 DSH 的 `llm.listModels()` 读取；这样固定模型下拉框与真正可调用的
+       * 模型来源保持一致，默认模型失效时也能把状态说清楚。
+       */
+      { kind: 'exact' as const, path: '/knowledge/models', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '该 knowledge endpoint 只接受 GET'))
+        const url = query(req)
+        const id = kbIdOf(url.searchParams.get('kb'))
+        if (!bases.get(id)) return sendEnvelope(res, failure({}, 'BASE_NOT_FOUND', `知识库不存在: ${id}`, true, '先 GET /knowledge/bases 拿到可用 id。'))
+        return send(res, 200, success(await compileModelCatalog(id, { provider: url.searchParams.get('provider') ?? undefined, model: url.searchParams.get('model') ?? undefined })))
       } },
       { kind: 'exact' as const, path: '/knowledge/stats', handler: async (req: IncomingMessage, res: ServerResponse) => {
         const resolved = resolveBase(query(req).searchParams.get('kb'))
         if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
         return send(res, 200, success(await resolved.runtime.stats()))
       } },
+      { kind: 'exact' as const, path: '/knowledge/cases', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', 'Case 只接受 GET'))
+        const resolved = resolveBase(query(req).searchParams.get('kb'))
+        if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+        return send(res, 200, success({ cases: await resolved.runtime.loadEvents() }))
+      } },
+      { kind: 'exact' as const, path: '/knowledge/events', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', 'Event 只接受 GET'))
+        const resolved = resolveBase(query(req).searchParams.get('kb'))
+        if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+        return send(res, 200, success({ events: await resolved.runtime.diagnosisStore().listEvents() }))
+      } },
       { kind: 'exact' as const, path: '/knowledge/search', handler: async (req: IncomingMessage, res: ServerResponse) => {
         const url = query(req)
         const resolved = resolveBase(url.searchParams.get('kb'))
@@ -966,6 +1182,19 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
           },
         ))
       } },
+      { kind: 'exact' as const, path: '/knowledge/environment', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '只支持 GET'))
+        return send(res, 200, success(environment.view()))
+      } },
+      { kind: 'exact' as const, path: '/knowledge/environment/prepare', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'POST') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '只支持 POST'))
+        try {
+          const body = await readBody(req, 4000) as { action?: string; selection?: unknown } | null
+          if (body?.action === 'cancel') { environment.cancel(); return send(res, 200, success(environment.view())) }
+          if (body?.action !== 'check' && body?.action !== 'install') return send(res, 400, failure({}, 'ACTION_INVALID', 'action 必须是 check、install 或 cancel', false))
+          return send(res, 200, success(environment.start(body.action, body.selection)))
+        } catch (cause) { return send(res, 400, envelopeError('REQUEST_INVALID', cause instanceof Error ? cause.message : String(cause))) }
+      } },
       { kind: 'exact' as const, path: '/knowledge/embedding/health', handler: async (req: IncomingMessage, res: ServerResponse) => {
         const resolved = resolveBase(query(req).searchParams.get('kb'))
         if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
@@ -1005,6 +1234,72 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
         return send(res, 200, success({ progress: resolved.runtime.compileProgressView(url.searchParams.get('runId') ?? undefined) }))
       } },
+      { kind: 'exact' as const, path: '/knowledge/pipeline', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        try {
+          const body = req.method === 'POST' ? await readBody(req, 100_000) : {}
+          const resolved = resolveBase(body.kb ?? query(req).searchParams.get('kb'))
+          if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+          if (req.method === 'GET') return send(res, 200, success(await resolved.runtime.pipelineStatus()))
+          if (req.method !== 'POST') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '知识处理只接受 GET 或 POST'))
+          const pipeline = await resolved.runtime.pipeline()
+          const started = pipeline.start(body.stage as PipelineStage, { sourceIds: body.sourceIds, groupKeys: body.groupKeys, force: body.force === true })
+          return send(res, 202, success({ task: started.task }))
+        } catch (cause) { return send(res, 400, envelopeError('PIPELINE_INVALID', cause instanceof Error ? cause.message : String(cause))) }
+      } },
+      { kind: 'exact' as const, path: '/knowledge/pipeline-tasks', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        try {
+          if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '任务历史只接受 GET'))
+          const url = query(req)
+          const resolved = resolveBase(url.searchParams.get('kb'))
+          if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+          const pipeline = await resolved.runtime.pipeline()
+          const limit = Math.min(100, Math.max(1, Number(url.searchParams.get('limit')) || 20))
+          const offset = Math.max(0, Number(url.searchParams.get('offset')) || 0)
+          return send(res, 200, success({ ...pipeline.store.tasks(limit, offset), extractions: await resolved.runtime.listExtractionRuns({ limit, offset }) }))
+        } catch (cause) { return send(res, 400, envelopeError('PIPELINE_HISTORY_FAILED', cause instanceof Error ? cause.message : String(cause))) }
+      } },
+      { kind: 'exact' as const, path: '/knowledge/pipeline-task', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        try {
+          const url = query(req)
+          const body = req.method === 'POST' ? await readBody(req, 20_000) : {}
+          const resolved = resolveBase(body.kb ?? url.searchParams.get('kb'))
+          if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+          const pipeline = await resolved.runtime.pipeline()
+          const id = typeof body.id === 'string' ? body.id : url.searchParams.get('id') ?? ''
+          const task = pipeline.store.task(id)
+          if (!task) return send(res, 404, envelopeError('PIPELINE_NOT_FOUND', '任务不存在'))
+          if (req.method === 'GET') return send(res, 200, success({ task, ...pipeline.store.events(id, Math.max(0, Number(url.searchParams.get('after')) || 0)) }))
+          if (req.method !== 'POST') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '任务只接受 GET 或 POST'))
+          if (body.action === 'retry') return send(res, 202, success({ task: pipeline.start(task.stage, { ...task.selection, force: false }).task }))
+          if (!['pause', 'resume', 'cancel'].includes(body.action)) throw new Error('不支持的任务操作')
+          return send(res, 200, success({ task: pipeline.control(id, body.action) }))
+        } catch (cause) { return send(res, 409, envelopeError('PIPELINE_TASK_REJECTED', cause instanceof Error ? cause.message : String(cause))) }
+      } },
+      { kind: 'exact' as const, path: '/knowledge/extraction-tasks', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '抽取任务只接受 GET'))
+        const resolved = resolveBase(query(req).searchParams.get('kb'))
+        if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+        return send(res, 200, success({ tasks: resolved.runtime.listCompileTasks() }))
+      } },
+      { kind: 'exact' as const, path: '/knowledge/extraction-task', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'POST') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '抽取任务控制只接受 POST'))
+        try {
+          const body = await readBody(req, 20_000)
+          const resolved = resolveBase(body.kb ?? query(req).searchParams.get('kb'))
+          if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+          const runId = typeof body.run_id === 'string' ? body.run_id.trim() : ''
+          const action = body.action
+          if (!runId || (action !== 'pause' && action !== 'resume' && action !== 'cancel')) {
+            return send(res, 400, envelopeError('REQUEST_INVALID', '需要 run_id 和 pause / resume / cancel 操作'))
+          }
+          const result = resolved.runtime.controlCompileTask(runId, action)
+          return result.ok
+            ? send(res, 200, success({ task: result.task }))
+            : send(res, 409, envelopeError('TASK_CONTROL_REJECTED', result.why ?? '任务状态不支持此操作'))
+        } catch (cause) {
+          return send(res, 400, envelopeError('REQUEST_INVALID', cause instanceof Error ? cause.message : String(cause)))
+        }
+      } },
       /**
        * 把一个知识库**导出成目录形态**（0062 v2 §3.7 末）。
        *
@@ -1043,7 +1338,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
           const resolved = resolveBase(body.kb ?? query(req).searchParams.get('kb'))
           if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
           return send(res, 202, success(resolved.runtime.startCompile(body.only ?? 'all', lineageOf(body), {
-            ...(typeof body.extract === 'boolean' ? { extract: body.extract } : {}),
+            extract: body.extract === true,
             ...(body.forceExtract === true ? { forceExtract: true } : {}),
           })))
         } catch (cause) {
@@ -1070,7 +1365,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
               ...(item?.external_id ? { externalId: String(item.external_id) } : {}),
               ...(item?.metadata && typeof item.metadata === 'object' ? { metadata: item.metadata as Record<string, unknown> } : {}),
             })),
-            ...(body.compile === false ? { compile: false } : {}),
+            compile: body.compile === true,
             lineage: lineageOf(body),
           }))
         } catch (cause) {
@@ -1095,6 +1390,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
             Number(url.searchParams.get('max_chars') ?? 40000) || 40000,
             lineageFromUrl(url),
             Number(url.searchParams.get('offset') ?? 0) || 0,
+            Number(url.searchParams.get('source_offset') ?? 0) || 0,
           ))
         } catch (cause) {
           return send(res, 400, envelopeError('REQUEST_INVALID', cause instanceof Error ? cause.message : String(cause)))
@@ -1162,7 +1458,8 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
            * 任何一条轨迹 —— 「这个实体是哪次抽出来的」就答不上了。
            */
           const runId = extractionRunId()
-          const seam = modelSeamFor()
+          const seam = modelSeamFor(resolved.runtime.baseId)
+          const draft = await (await resolved.runtime.axisRegistry())?.draft()
           const axesBlock = await resolved.runtime.axisPromptBlockView()
           const note = resolved.runtime.extractionNote()
           const report = await runWikiTrial({
@@ -1170,14 +1467,17 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
             text,
             ...(docId ? { docId } : {}),
             ...(typeof body.subject === 'string' && body.subject.trim() ? { subject: body.subject.trim() } : {}),
-            /**
-             * Resolve 第 2 步的**真实入口**：交给轴注册表。没有注册表时它返回 null，
-             * 报告里如实写 `no-registry` —— 不假装查过。
-             */
-            resolveAxis: (kind, mention, parentMention, extra) => resolved.runtime.resolveAxisMention({
-              kind, mention, parentMention, runId,
-              ...(extra?.preferMention ? { preferMention: extra.preferMention } : {}),
-              ...(extra?.description ? { description: extra.description } : {}),
+            /** 与编译相同：先查注册表，再把有候选的坐标合并成一次模型补判。 */
+            resolveAxisSet: axes => resolved.runtime.resolveTrialAxisSet({
+              registry: draft?.registry, axes,
+              axesBlock,
+              runId,
+              call: seam.call,
+              modelRequest: {
+                ...(seam.provider ? { provider: seam.provider } : {}),
+                ...(seam.model ? { model: seam.model } : {}),
+                ...(seam.reasoningEffort ? { reasoningEffort: seam.reasoningEffort } : {}),
+              },
             }),
             /**
              * 已有坐标（0068）。**与真编译下发同一份** —— 试跑看到的世界与真编译看到的
@@ -1185,9 +1485,14 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
              */
             ...(axesBlock === undefined ? {} : { axes: axesBlock }),
             ...(note ? { note } : {}),
+            modelRequest: {
+              ...(seam.provider ? { provider: seam.provider } : {}),
+              ...(seam.model ? { model: seam.model } : {}),
+              ...(seam.reasoningEffort ? { reasoningEffort: seam.reasoningEffort } : {}),
+            },
             ...('call' in seam ? { call: seam.call } : {}),
             ...('why' in seam ? { callWhy: seam.why } : {}),
-          })
+          }).finally(() => draft?.close())
           const summary = trialSummary(report)
 
           /**
@@ -1203,24 +1508,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
             lineage: lineageOf(body),
           })
 
-          /**
-           * 把这次抽出来的 Knowledge 收进真源（0063 §2）。
-           *
-           * **只在跑一份已入库的文档时收。** 理由有两条：来源要指得回一份**真实的**
-           * 文档（临时正文的 `documentId` 是一个标题字符串，存下来就是悬空引用）；
-           * 而「这条知识是哪份文档说的」正是它可验证的前提。
-           *
-           * **只收引文核对得上的那些。** 引文对不上原文 = 模型改写了，那条判断不是从
-           * 原文推出来的（§5.7 的引文核验）。把它当知识存进真源，等于让一句编出来的话
-           * 看起来像有出处 —— 而报告里已经把它报成例外了，那里才是它该待的地方。
-           */
-          const ingest = docId
-            ? await resolved.runtime.ingestTrialKnowledge({
-              runId, knowledge: report.knowledge,
-              objects: report.objects, actions: report.actions, scenes: report.scenes,
-            })
-            : { saved: 0, merged: 0, skipped: 0 }
-          return send(res, 200, success({ ...report, summary, run, ingest }))
+          return send(res, 200, success({ ...report, summary, run }))
         } catch (cause) {
           return send(res, 400, envelopeError('REQUEST_INVALID', cause instanceof Error ? cause.message : String(cause)))
         }
@@ -1266,7 +1554,9 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
            * 必须分开：`get()` 给 `''`，缺席给 `null`，这个区别正好用得上。
            */
           const status = url.searchParams.get('status')
+          const kind = url.searchParams.get('kind')
           const filter: KnowledgeQuery = {
+            ...(kind === 'fact' || kind === 'procedure' ? { kind } : {}),
             ...(status === 'candidate' || status === 'active' || status === 'disputed' || status === 'deprecated' ? { status } : {}),
             ...(url.searchParams.get('run_id') === null ? {} : { runId: url.searchParams.get('run_id')! }),
             ...(url.searchParams.get('object_id') === null ? {} : { objectId: url.searchParams.get('object_id')! }),
@@ -1352,22 +1642,40 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         const kind = kindParam === 'object' || kindParam === 'action' || kindParam === 'scene' ? kindParam : undefined
         const status = statusParam === 'candidate' || statusParam === 'active' || statusParam === 'deprecated' || statusParam === 'merged' ? statusParam : undefined
         if (req.method === 'GET') {
-          const [entities, stats] = await Promise.all([
+          const [entities, stats, relations] = await Promise.all([
             resolved.runtime.listAxisEntities(kind, status),
             resolved.runtime.axisStats(),
+            resolved.runtime.listAxisRelations(),
           ])
-          if (entities === null || stats === null) return send(res, 200, success({ entities: [], stats: null, guidance: {}, available: false }))
+          if (entities === null || stats === null || relations === null) return send(res, 200, success({ entities: [], stats: null, guidance: {}, relations: [], available: false }))
           /*
            * 指导随实体一起给（0068）。分开一条路由要多一次往返，而两样东西永远一起显示 ——
            * 一条指导离开它挂着的那个实体就没有意义。
            */
           const guidance = await resolved.runtime.axisGuidanceMap()
-          return send(res, 200, success({ entities, stats, guidance, available: true }))
+          return send(res, 200, success({ entities, stats, guidance, relations, available: true }))
         }
         if (req.method !== 'POST') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '轴注册表只接受 GET 或 POST'))
         const body = await readBody(req)
         const id = typeof body.id === 'string' ? body.id.trim() : ''
         const action = typeof body.action === 'string' ? body.action.trim() : ''
+        if (action === 'relation-add') {
+          const fromId = typeof body.from_id === 'string' ? body.from_id.trim() : ''
+          const toId = typeof body.to_id === 'string' ? body.to_id.trim() : ''
+          const relationType = typeof body.relation_type === 'string' ? body.relation_type.trim() : 'related_to'
+          const evidence = typeof body.evidence === 'string' ? body.evidence : ''
+          if (!fromId || !toId) return send(res, 400, envelopeError('REQUEST_INVALID', '添加相关对象关系需要 from_id 与 to_id'))
+          if (relationType !== 'related_to') return send(res, 400, envelopeError('REQUEST_INVALID', '当前只支持 related_to 对象关系'))
+          const relation = await resolved.runtime.addAxisRelation(fromId, toId, evidence)
+          if (relation === null) return sendEnvelope(res, failure({}, 'AXIS_RELATION_INVALID', '关系无效：两个对象必须存在、未合并且不能是同一个对象', false))
+          return send(res, 200, success({ relation }))
+        }
+        if (action === 'relation-remove') {
+          const relationId = typeof body.relation_id === 'string' ? body.relation_id.trim() : ''
+          if (!relationId) return send(res, 400, envelopeError('REQUEST_INVALID', '移除关系需要 relation_id'))
+          const removed = await resolved.runtime.removeAxisRelation(relationId)
+          return send(res, 200, success({ removed }))
+        }
         if (action === 'merge') {
           const into = typeof body.into === 'string' ? body.into.trim() : ''
           if (!id || !into) return send(res, 400, envelopeError('REQUEST_INVALID', '并两个实体要同时给 id 与 into'))
@@ -1430,7 +1738,10 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         return send(res, 400, envelopeError('REQUEST_INVALID', `不认识的 action: ${action || '（空）'}`))
       } },
       /**
-       * 抽取轨迹（`extraction_run`）：按文档列、按 id 读全文。
+       * 轨迹（`extraction_run`）：按文档或阶段列、按 id 读全文。
+       *
+       * 2026-10-18 起三段共用这张表（`stage` 列：`extract` / `normalize` / `materialize`）。
+       * `stage` 省略 = 三段一起 —— 面板里那份「这份文档的轨迹」就是这么读的。
        *
        * 列表**不返回报告本体** —— 一条报告几十到几百 KB，翻一页列表不该按全文付费。
        * 点开某一条走 `/knowledge/extraction-run?id=…`（单独一条路由，不是路径参数：
@@ -1442,8 +1753,11 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         const resolved = resolveBase(url.searchParams.get('kb'))
         if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
         const docId = url.searchParams.get('doc_id')
+        const stageParam = url.searchParams.get('stage')
+        const stage = stageParam === 'extract' || stageParam === 'normalize' || stageParam === 'materialize' ? stageParam : undefined
         const page = await resolved.runtime.listExtractionRuns({
           ...(docId === null ? {} : { docId }),
+          ...(stage === undefined ? {} : { stage }),
           limit: clampInt(url.searchParams.get('limit'), 20, 1, 100),
           offset: clampInt(url.searchParams.get('offset'), 0, 0, Number.MAX_SAFE_INTEGER),
         })
@@ -1463,7 +1777,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
       } },
       // ---------------------------------------------------------- 目录选择（0029）
       /**
-       * 根路径的**只读**视图：四段布局、两次迁移的结论、家当解析结果、宿主提供的是哪种选择交互。
+       * 根路径的**只读**视图：新布局、家当解析结果、宿主提供的是哪种选择交互。
        *
        * 设置面板要显示「你这个根路径下会长出哪几段」，而那是服务端算出来的
        * （`layout.ts` 是唯一真源），所以不能让前端自己拼字符串。
@@ -1471,22 +1785,13 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
       { kind: 'exact' as const, path: '/knowledge/layout', handler: async (req: IncomingMessage, res: ServerResponse) => {
         const dirs = agentLayout(config.agentRoot)
         const resources = runtime.resourcePaths()
-        // preset 的真源目录。它随插件分发，所以路径由插件自己算 —— 客户端不该拼这个
-        // 字符串，也不该猜包装在哪。`exists` 是给界面用的：路径不在时如实说「这个安装
-        // 里没有 preset 真源」，而不是给一个点了弹空目录的按钮。
-        const presetDir = presetSourceDir()
         return send(res, 200, success({
           ...dirs,
-          presetDir,
-          presetDirExists: existsSync(presetDir),
-          migration,
-          resourceMigration,
-          memoryMigration,
           // 三个「家当」路径**解析后**的值。设置面板用它显示「自动」到底指向哪里 ——
           // 配置里是空串（= 自动），但用户要看到的是真实路径。
           resources,
-          // 家当有没有真的落在 `resource/` 下（0029 的目标）。`resource` 是家当目录本身，
-          // 用它做前缀判断：不在里面的就是「还在旧位置」或「是一个裸的 HuggingFace 仓库名」。
+          // 家当有没有真的落在 `resource/` 下。`resource` 是家当目录本身，
+          // 用它做前缀判断：不在里面的可能是一个裸的 HuggingFace 仓库名。
           resourcesOutsideResource: outsideResource(resources, dirs.resource),
           // 设置分区没注册上时的原因。有它，「设置服务不可用」才不是一句空话。
           ...(settingsError ? { settingsError } : {}),
@@ -1559,10 +1864,8 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         return send(res, 200, success({ cases: (await storeOf(resolved.runtime).snapshot()).cases }))
       } },
       /**
-       * 一次排查结束：落一条 `agent_diagnosis_case` 的 SourceRaw，并写入一张案例卡片。
-       *
-       * 0044：卡片不再只提议 —— 它直接入库并标成 `unreviewed`。响应给 `sourceId` 与
-       * `entityId`，界面据此说清「记录留下了，卡片也建了，等人 review」。
+       * 一次排查结束只落一条 SourceRaw。Case 视图从记录派生；Knowledge / Event 的抽取、
+       * 归一和 WikiCard 物化由知识处理阶段分别执行。
        */
       { kind: 'exact' as const, path: '/diagnosis/run', handler: async (req: IncomingMessage, res: ServerResponse) => {
         if (req.method !== 'POST') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '该 endpoint 只接受 POST'))
@@ -1575,9 +1878,9 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         }
         const outcome = await storeOf(resolved.runtime).recordRun(record)
         if (outcome.problems.length > 0 && outcome.sourceId === undefined) {
-          return send(res, 200, failure({ sourceId: '', entityId: '' }, 'RUN_WRITE_FAILED', outcome.problems.join('；'), true))
+          return send(res, 200, failure({ sourceId: '' }, 'RUN_WRITE_FAILED', outcome.problems.join('；'), true))
         }
-        return send(res, 200, success({ sourceId: outcome.sourceId ?? '', entityId: outcome.entityId ?? '' }, outcome.problems))
+        return send(res, 200, success({ sourceId: outcome.sourceId ?? '' }, outcome.problems))
       } },
       /**
        * 入库之后的两个人工动作（0044）：加备注、review 抬分。
@@ -1661,6 +1964,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
            * ```
            * /knowledge/pages/trial?kb=<知识库 id>     抽取试跑
            * /knowledge/pages/run?kb=<库 id>&run=<轨迹 id>   一次抽取的完整报告
+           * /knowledge/pages/tasks?kb=<知识库 id>    抽取任务
            * /knowledge/pages/help/compile             编译链路
            * /knowledge/pages/help/intent              意图的逻辑
            * /knowledge/pages/help/overview?node=...   五个 Tab 的方案说明
@@ -1687,6 +1991,8 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
               ? '抽取试跑'
               : rest[1] === 'run'
                 ? '抽取轨迹'
+                : rest[1] === 'tasks'
+                  ? '抽取任务'
                 : rest[1] === 'help' && rest[2] === 'intent'
                   ? '意图的逻辑'
                   : rest[1] === 'help' && rest[2] === 'compile'
@@ -1722,9 +2028,30 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
             if (rest.length === 2) {
               if (method === 'PATCH') {
                 const body = await readBody(req)
+                if (body.compileModel && typeof body.compileModel === 'object') {
+                  const selection = body.compileModel as CompileModelSelection
+                  const catalog = await compileModelCatalog(baseId)
+                  const provider = selection.mode === 'fixed' ? selection.provider : catalog.default.provider
+                  const model = selection.mode === 'fixed' ? selection.model : catalog.default.model
+                  if (selection.mode !== 'fixed' && selection.mode !== 'default') return send(res, 400, envelopeError('MODEL_INVALID', '请选择跟随默认或固定模型'))
+                  if (selection.mode === 'fixed' && (!provider || !model)) return send(res, 400, envelopeError('MODEL_INVALID', '固定模型需要 provider 和 model'))
+                  const llm = ctx.get('llm')
+                  if (provider && model && llm?.resolveCallConfig) {
+                    try {
+                      const info = selection.reasoningEffort ? await llm.resolveModelInfo(provider, model) : undefined
+                      const effort = info?.reasoning?.efforts.find(item => item.id === selection.reasoningEffort)
+                      if (selection.reasoningEffort && !effort) throw new Error('所选模型不支持这个思考强度，请重新选择')
+                      await llm.resolveCallConfig({ provider, model, ...(effort ? { reasoningEffort: effort.id } : {}) })
+                    }
+                    catch (cause) { return send(res, 400, envelopeError('MODEL_INVALID', cause instanceof Error ? cause.message : String(cause))) }
+                  } else if (selection.reasoningEffort) return send(res, 400, envelopeError('MODEL_INVALID', '模型不可用，无法校验思考强度'))
+                }
                 const updated = await bases.update(baseId, {
                   name: body.name, description: body.description,
                   extractionNote: typeof body.extractionNote === 'string' ? body.extractionNote : undefined,
+                  compileModel: body.compileModel && typeof body.compileModel === 'object'
+                    ? body.compileModel
+                    : undefined,
                 })
                 if (!updated.ok) return sendEnvelope(res, updated)
                 return send(res, 200, success({ base: updated.data }, updated.warnings))
@@ -1858,8 +2185,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
 
           // ----------------------------------------------- /knowledge/cards
           // wiki 卡片详情与版本（0025）。列表走上面的 exact 路由；这里只处理
-          // `/cards/:entityId` 及其 `/versions`、`/revert` 子路径 —— 卡片和
-          // SourceRaw 一样有历史，用户点开一张卡片要能看到它被改过几次。
+          // `/cards/:entityId` 与 `/versions` 子路径 —— 卡片保留只读历史，供查看和比较。
           if (rest[0] === 'cards' && rest.length >= 2) {
             const kbParam = url.searchParams.get('kb')
             const resolved = resolveBase(kbParam)
@@ -1915,12 +2241,14 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
             }
             if (rest.length === 4 && rest[2] === 'versions') {
               if (method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '该 knowledge endpoint 只接受 GET'))
-              const version = await resolved.runtime.readCardVersion(entityId, rest[3]!, entityType)
+              const previewChars = clampInt(url.searchParams.get('preview_chars'), VERSION_DIFF_CHARS, 0, VERSION_DIFF_CHARS)
+              const version = await resolved.runtime.readCardVersion(entityId, rest[3]!, entityType, previewChars)
               if (version === undefined) return sendEnvelope(res, failure({}, 'VERSION_NOT_FOUND', `版本不存在: ${rest[3]}`, true))
               return send(res, 200, success({ version }))
             }
             if (rest.length === 3 && rest[2] === 'revert') {
               if (method !== 'POST') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '该 knowledge endpoint 只接受 POST'))
+              // 兼容旧客户端的路径；运行时会明确拒绝恢复 WikiCard。
               const body = await readBody(req)
               const reverted = await resolved.runtime.revertCard(entityId, String(body.versionId ?? ''), entityType)
               if (!reverted.ok) return sendEnvelope(res, reverted)
@@ -1939,6 +2267,26 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
               let documents = await resolved.runtime.listDocuments()
               const search = (url.searchParams.get('query') ?? '').trim().toLocaleLowerCase()
               if (search) documents = documents.filter(item => `${item.docId}\n${item.title}\n${item.externalId}`.toLocaleLowerCase().includes(search))
+              /**
+               * 文件类型的计数对着**搜索之后、类型筛选之前**的集合算。
+               *
+               * 下拉要能切换类型，所以每个类型的数量必须是「当前搜索下有多少份」，
+               * 而不是「当前这一页里有多少份」—— 后者会让选项随翻页变来变去。
+               */
+              const extCounts: Record<string, number> = {}
+              for (const item of documents) {
+                const key = item.ext || '—'
+                extCounts[key] = (extCounts[key] ?? 0) + 1
+              }
+              /**
+               * 文件类型筛选**在服务端**做（0070）。
+               *
+               * 原来是「客户端取前 500 份、再在这一页里筛」：超过 500 份的库，第 501 份起
+               * 在面板上根本不可达，而表头把这种截断显示成「筛出 500 / 600 个」——
+               * 读起来像用户自己开了筛选。既然这里已经支持 `offset`，筛选就该和分页同层。
+               */
+              const ext = (url.searchParams.get('ext') ?? '').trim()
+              if (ext) documents = documents.filter(item => item.ext === ext)
               const total = documents.length
               const offset = clampInt(url.searchParams.get('offset'), 0, 0, Number.MAX_SAFE_INTEGER)
               const limit = clampInt(url.searchParams.get('limit'), 50, 1, 500)
@@ -1949,7 +2297,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
                * 两件事。放成并列的一张表，前端按 `docId` 查，文档类型不用为审计字段让步。
                */
               const extractionRuns = await resolved.runtime.extractionRunCounts()
-              return send(res, 200, success({ documents: documents.slice(offset, offset + limit), total, extractionRuns }))
+              return send(res, 200, success({ documents: documents.slice(offset, offset + limit), total, extCounts, extractionRuns }))
             }
             const docId = rest[1]!
             const resolved = resolveBase(kbParam)
@@ -2067,6 +2415,6 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
       } },
     ]
     const disposers = routes.map(register)
-    return () => { runtime.close(); for (const dispose of disposers) void dispose() }
+    return () => { environment.close(); runtime.close(); bases.closeAll(); for (const dispose of disposers) void dispose() }
   })
 }