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

package/lib/types/index.js

@@ -1,24 +1,27 @@
-import { createReadStream, existsSync } from 'node:fs';
+import { embeddingModel } from './environment/model-catalog.js';
+import { createReadStream } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
-import { dirname, extname, isAbsolute, join, resolve, sep } from 'node:path';
+import { dirname, extname, isAbsolute, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { operationId } from './oplog.js';
 import { AXIS_GUIDANCE_KINDS } from './axis-registry.js';
-import { DEFAULT_KNOWLEDGE_CONFIG, } from './types.js';
+import { DEFAULT_COMPILE_MODEL, DEFAULT_KNOWLEDGE_CONFIG, } from './types.js';
 import { KnowledgeRuntime, MAX_IMPORT_SOURCES, SOURCE_PREVIEW_CHARS, VERSION_DIFF_CHARS, success, failure, } 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 { runWikiTrial, trialSummary } from './wiki-trial.js';
 import { extractionRunId } from './extraction-runs.js';
-import { agentLayout, defaultAgentRoot, ensureAgentLayout, intentRoot, knowledgeBaseRoot, legacyDefaultKnowledgeRoot, memoryRoot, presetSourceDir, resourceRegistry, resourceRoot, } from './layout.js';
-import { migrateLegacyKnowledgeTree, migrateLegacyMemory, migrateLegacyResources } from './migrate.js';
-import { legacyResourceHome } from './types.js';
+import { agentLayout, defaultAgentRoot, ensureAgentLayout, intentRoot, knowledgeBaseRoot, memoryRoot, resourceRegistry, resourceRoot, } from './layout.js';
 import { PickerError, createDirectory, listDirectory, pickDirectory, pickerKind, pickerOf, } from './directory-picker.js';
 import { KNOWLEDGE_SETTINGS_SCHEMA, SETTINGS_NAMESPACE } from './settings-schema.js';
 import { DEFAULT_KB_ID, KnowledgeBases } from './knowledge-bases.js';
+import { ImagePublishError, publishKnowledgeImage } from './images.js';
 import { applyConvert, CONVERT_SETTINGS_NAMESPACE, CONVERT_SETTINGS_SCHEMA, MOUNT_PATH as CONVERT_MOUNT_PATH, } from './convert/host.js';
 import { applyIntent, INTENT_MOUNT_PATH, INTENT_SERVICE, } from './intent/host.js';
+import { registerIntentTools } from './intent/tools.js';
 export * from './types.js';
 export * from './runtime.js';
 export * from './knowledge-bases.js';
@@ -31,14 +34,14 @@ export const name = 'dsh-data-domain-knowledge';
  * `settings` 在 0.1.7 之后**不再需要**：设置已经是本 entry 的 config
  * （见下面的 `Config`），`settings.installSection` 那条路已经整个删除。
  */
-export const inject = ['tools', 'webServer'];
+export const inject = ['tools', 'webServer', 'systemPrompt'];
 // 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，改成
@@ -47,7 +50,7 @@ export { CONVERT_SETTINGS_SCHEMA };
  * 客户端按**路径**寻址（例如 `{op:'set', path:['knowledge','recallTopK']}`）。
  */
 import { Config } 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, recallCallView, recallMetaOf, recallResultMarkdown, rebuildCallView, rebuildMetaOf, rebuildResultMarkdown, writeCardsCallView, writeCardsMetaOf, writeCardsResultMarkdown, } from './present.js';
 export { Config };
 /**
@@ -198,7 +201,7 @@ function escapeHtml(value) {
 /**
  * 独立整页的 HTML 外壳。
  *
- * 与 Notebook 的整页同一个形状，而且**只做三件事**：标题、挂载点、把自己那个 bundle
+ * 与知识库原文整页相同的挂载形状，而且**只做三件事**：标题、挂载点、把自己那个 bundle
  * 拉起来。正文不在外壳里 —— 页面自己去 `/knowledge/documents/:docId/content` 一页一页地取，
  * 所以这份 HTML 的大小与文档大小无关。
  */
@@ -307,27 +310,21 @@ function normalizeKnowledge(next) {
     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, pluginConfig = {}) {
-    /**
-     * 0029：配置里现在有两个路径字段，但只有 `agentRoot` 是「设置」。
-     *
-     * `rootDir` 是旧布局的知识树根，只作为迁移来源存在。初始值给空串而不是旧默认值
-     * ——迁移的来源由下面的 `legacySource()` 决定，它还要考虑「没设过 rootDir 的
-     * 用户，旧树在旧默认位置」这一种情况。
-     *
-     * 0.1.7：值来自本 entry 的 `config`（`apply` 的第二个参数），不再是
-     * `settings.installSection` 推回来的命名空间。这里先 `normalizeKnowledge` 补齐，
-     * 之后的迁移与 runtime 都只认这一份配置。
-     */
     let config = normalizeKnowledge(pluginConfig.knowledge);
     /**
      * entry config 的另外两组，**按需求值**。
      *
-     * 为什么是函数而不是先解包成一个值：0.1.7 的设置字段全标了 volatile，schema
+     * 为什么是函数而不是先解包成一个值：`convert` 的可编辑字段标了 volatile，schema
      * 解析出来是引用；解包一次就是一张快照，而 volatile 改动**不会重载插件**
      * （loader 只就地改引用、再发一个 `loader/volatile-update`）。函数让下游每次
      * 「重灌」都从同一个引用重新读值，改设置才真的会生效。
@@ -342,37 +339,16 @@ export function apply(ctx, pluginConfig = {}) {
      * `applyIntent`）。
      */
     let convertHost;
-    /** 知识树迁移的结论。`/knowledge/layout` 会带上它，界面据此如实交代数据搬没搬。 */
-    let migration = { status: 'skipped', reason: '尚未解析设置' };
-    /** 家当（模型 / Python 环境 / 注册表）迁移的结论。 */
-    let resourceMigration = { status: 'skipped', reason: '尚未解析设置' };
-    /** 记忆段（知识树 → `<agentRoot>/memory/<库 id>`）迁移的结论（0032）。 */
-    let memoryMigration = { status: 'skipped', reason: '尚未解析设置' };
     /**
      * 初始化失败的原因（如果有）。字段名保持 `settingsError`：`/knowledge/layout`
      * 与面板上的告警都按这个名字读，改名的收益不如改语义的成本高。
      *
      * 旧的理由是「设置分区注册失败会被静默吞掉」（v0.7.5 的
      * `z.string().min(1).default('')` 让整个命名空间注册不上）。0.1.7 之后 schema
-     * 错误会在装载 entry 时就抛、插件直接加载失败，不再是静默的；但**迁移**仍可能
-     * 因为一个权限问题失败，而那条失败不该让插件起不来，所以这里依旧接住并上报。
+     * 错误会在装载 entry 时就抛、插件直接加载失败，不再是静默的；这里仍保留错误
+     * 视图，便于报告布局初始化失败。
      */
     let settingsError;
-    /**
-     * 迁移只该发生一次 —— 实际含义是「每次 apply 最多一次」。
-     *
-     * 0.1.7 下改设置会让插件**整个重载**，apply 因此会再跑一遍。用「已经跑过」而不是
-     * 「结果如何」做闸门，是为了不让一个失败的迁移在重载时被反复重试。
-     */
-    let migrationDone = false;
-    /**
-     * 迁移的旧位置来源。
-     *
-     * 显式设过 `rootDir` 就用它；否则退回旧默认位置（`DSH_KNOWLEDGE_ROOT` 或
-     * `~/Desktop/titaagent/domain_knowledge`）。判据交给 `migrateLegacyKnowledgeTree`，
-     * 这里只负责「谁可能是旧树」。
-     */
-    const legacySource = () => config.rootDir.trim() || legacyDefaultKnowledgeRoot();
     /**
      * #3b：把 **DSH 的默认模型**包成运行时认识的纯文本调用。
      *
@@ -380,10 +356,12 @@ export function apply(ctx, pluginConfig = {}) {
      * DSH 自己的 `agentDefaultModel`（设置里那一项）。插件再存一份，就会出现「设置里显示
      * A、实际调的是 B」—— 0029 想收拢的正是这类两处说法。
      *
-     * 取不到 `llm` 或默认模型时返回 undefined，链路**退回纯规则抽取**：模型是增强，
-     * 不是前提。
+     * 取不到 `llm` 或所选模型时返回原因，链路**退回纯规则抽取**：模型是增强，不是前提。
+     * 选择“跟随默认”时才读取 `agentDefaultModel`；固定模型不依赖默认模型服务。
      */
-    const modelSeamFor = () => {
+    /** 注册表在默认 runtime 之后才构造；用一个可替换的读取器避开构造期 TDZ。 */
+    let compileModelForBase = () => ({ ...DEFAULT_COMPILE_MODEL });
+    const modelSeamFor = (kbId = DEFAULT_KB_ID) => {
         /**
          * **只能用 `ctx.get(name)`，不能用属性访问。**
          *
@@ -407,16 +385,49 @@ export function apply(ctx, pluginConfig = {}) {
          * 所以那个类自己也是用 `this.config.provider.get()` 读的。第一版就是按普通属性读的，
          * 结果是永远拿到 undefined —— 模型接缝静默失效。
          */
-        const service = ctx.get('agentDefaultModel');
-        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;
+        let defaultModel;
+        let reasoningEffort;
+        if (configured.mode === 'default') {
+            const service = ctx.get('agentDefaultModel');
+            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 实机验证第三～五批）。
                  *
@@ -427,16 +438,31 @@ export function apply(ctx, pluginConfig = {}) {
                  * （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));
+                /**
+                 * 流在**半路**结束要重发，不要一次失败就作废整份文档。
+                 *
+                 * 知识抽取是本插件里最长的一次模型调用（实机：约四万输出 token、两三分钟），
+                 * 而上游网关 / 本机代理 / 账号额度任何一处抖一下，流就会在没给
+                 * `finish_reason` 的情况下结束。适配器把这件事报成
+                 * `TRANSPORT: Stream ended without finish_reason`，过去一次抖动就等于
+                 * 「这份文档抽取失败」，人在界面上看到的是「全部失败」。
+                 *
+                 * 重发用的是**同一个请求**：提示词、sessionId、reasoningEffort 全不变，
+                 * 所以缓存亲和仍然成立。不可重试的错误（凭据、请求体、截断、用户取消）
+                 * 由 `isRetryableModelFailure` 放行，不在错的地方多等两分钟。
+                 */
+                return callModelWithRetry(onDeltaOfAttempt => collectModelText(llm.stream(request), onUsage, onDeltaOfAttempt), { ...(onDelta ? { onDelta } : {}) });
             },
         };
     };
+    let environment;
     const runtimeOptions = () => ({
+        environmentGuard: kind => environment.requireReady(kind),
         // 0029：家当目录。配置里三个路径为空时，运行时从这里解析模型与解释器。
         resourceRoot: resourceRoot(config.agentRoot),
         // 0032：记忆段。默认库的记忆落在 `<agentRoot>/memory/default`，与知识树平级。
@@ -472,10 +498,122 @@ export function apply(ctx, pluginConfig = {}) {
         // 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'];
+            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) => {
+                const group = pluginConfig.knowledge;
+                if (!group)
+                    throw new Error('模型设置不可写');
+                for (const key of keys) {
+                    const reference = group[key];
+                    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);
+    const compileModelCatalog = async (kbId, queryModelRoute = {}) => {
+        const service = ctx.get('agentDefaultModel');
+        const defaultRoute = service?.currentSelection?.() ?? {};
+        const llm = ctx.get('llm');
+        const providers = [...new Set([...(llm?.listProviders?.() ?? []).map(provider => provider.id), defaultRoute.provider, compileModelForBase(kbId).provider].filter((value) => Boolean(value)))];
+        const models = [];
+        const failures = [];
+        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) => {
         if (value === undefined || value === null)
             return bases.defaultId;
@@ -487,7 +625,7 @@ export function apply(ctx, pluginConfig = {}) {
      *
      * `Entry._commitVolatile()` 只调 `updateVolatile()` 就地改引用，再发一个
      * `loader/volatile-update` 事件。所以「设置存下了但没生效」这件事只能在这里兜住 ——
-     * 设置 schema 里的字段全部标了 volatile（见 `settings-volatile.ts`），这两件事必须成对。
+     * 设置 schema 里的可编辑字段标了 volatile（见 `settings-volatile.ts`），这两件事必须成对。
      *
      * 就地更新之所以够用，是因为 `pluginConfig` 就是宿主那份被改过的对象：重新
      * `normalizeKnowledge` 一下就能拿到新值。
@@ -507,6 +645,7 @@ export function apply(ctx, pluginConfig = {}) {
         const previousAgentRoot = config.agentRoot;
         config = normalizeKnowledge(pluginConfig.knowledge);
         runtime.updateConfig(config);
+        bases.updateRuntimeConfig(config);
         /**
          * 转换设置挂在同一个 entry 上，volatile 事件需要让转换宿主重新读取。
          */
@@ -540,68 +679,12 @@ export function apply(ctx, pluginConfig = {}) {
         return run(target);
     };
     /**
-     * 给每个知识库搬记忆段（0032）。
+     * 初始化：只创建新布局，再构造 runtime。
      *
-     * 结论只保留**最后一个非 skipped 的**：默认库才是用户实际在用的那个，而面板上
-     * 一行位置有限。真有多个库搬失败时，`/knowledge/layout` 的 `resourceMigration`
-     * 与知识库列表里的路径仍然能对上账。
-     */
-    const migrateAllMemory = () => {
-        const bases = activeKnowledgeBases;
-        if (!bases)
-            return { status: 'skipped', reason: '知识库注册表尚未就绪' };
-        let outcome = { 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。
-     *
-     * 顺序是**硬要求**：配置已由外层的 `normalizeKnowledge` 补齐，这里先迁移（迁移要读
-     * 新的 `agentRoot` 与旧的 `rootDir`），最后才构造 runtime。反过来的话，runtime 会在
-     * 数据搬完之前就指着新路径，于是「刚启动时知识库是空的」——而那正是最容易让人以为
-     * 数据丢了的时刻。
-     *
-     * 0.1.7：这段以前挂在 `settings.installSection` 的 `setSource`/`onChange` 回调里，
-     * 因为配置要等设置层推回来。现在配置是 `apply` 的入参，所以直接在 apply 时跑一次；
-     * 改设置会让插件**整个重载**，于是它会随重载再跑，由 `migrationDone` 挡住重复迁移。
+     * 旧版的 `rootDir`、旧 Agent 根路径和旧家当目录都不再参与启动流程。这样新安装的
+     * 数据路径是确定的，也不会因为启动而改动用户现有目录。
      */
     const initialize = () => {
-        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());
@@ -612,9 +695,9 @@ export function apply(ctx, pluginConfig = {}) {
     /**
      * 初始化失败必须留下痕迹。
      *
-     * 迁移会因为权限、占用、半个快照这类原因失败；而它抛出的异常如果没人接，就只是
-     * 一次没人看见的失败 —— 面板照常显示，数据却没搬。抓住它、记下来、让
-     * `/knowledge/layout` 报出去，界面于是能说「为什么不对」，而不是只显示症状。
+     * 创建新布局或构造 runtime 会因为权限、占用等原因失败；而它抛出的异常如果没人接，
+     * 就只是一次没人看见的失败。抓住它、记下来、让 `/knowledge/layout` 报出去，
+     * 界面于是能说「为什么不对」，而不是只显示症状。
      *
      * 注意这里**不吞配置错误**：schema 不合法的 config 在装载 entry 时就已经让插件
      * 加载失败了（那是响亮的）。这里接住的只是初始化期的数据问题。
@@ -654,44 +737,119 @@ export function apply(ctx, pluginConfig = {}) {
         // 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.
+        // 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) => {
-            const target = kbId ? runtimeOf(kbId) : undefined;
-            return target ? { runtime: target, knowledgeRoot: target.rootDir } : { runtime, knowledgeRoot: runtime.rootDir };
+            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);
+    /**
+     * `intent_*` 工具在 Host 层注册，使标准模式可以调用它们；工具执行端只接受
+     * standard 会话，其他 preset 不会写入或读取意图记录。
+     */
+    ctx.effect(() => registerIntentTools(ctx, 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(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, { 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) => {
+        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) => {
         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, 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, 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) => 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) => 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 的**发现入口**。
      *
@@ -718,6 +876,30 @@ export function apply(ctx, pluginConfig = {}) {
             buildVersion: base.buildVersion,
         })),
     })));
+    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) => 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)),
@@ -737,7 +919,7 @@ export function apply(ctx, pluginConfig = {}) {
      * `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 改了）。
      *
@@ -750,9 +932,9 @@ export function apply(ctx, pluginConfig = {}) {
      * 这个工具服务于另一条路：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,
@@ -767,7 +949,7 @@ export function apply(ctx, pluginConfig = {}) {
      * 有效评分压到 `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 } : {}),
         ...(args.kind ? { kind: args.kind } : {}),
@@ -791,7 +973,7 @@ export function apply(ctx, pluginConfig = {}) {
         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, 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),
@@ -834,7 +1016,7 @@ export function apply(ctx, pluginConfig = {}) {
          * - `canLoadSample` 是空态的开关 —— 这个库还什么都没有时才为真。
          */
         const diagnosisPayload = (snapshot) => ({
-            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,
         });
@@ -855,11 +1037,25 @@ export function apply(ctx, pluginConfig = {}) {
                     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', path: '/knowledge/models', handler: async (req, res) => {
+                    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', path: '/knowledge/stats', handler: async (req, res) => {
                     const resolved = resolveBase(query(req).searchParams.get('kb'));
@@ -867,6 +1063,22 @@ export function apply(ctx, pluginConfig = {}) {
                         return sendEnvelope(res, resolved.failure);
                     return send(res, 200, success(await resolved.runtime.stats()));
                 } },
+            { kind: 'exact', path: '/knowledge/cases', handler: async (req, res) => {
+                    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', path: '/knowledge/events', handler: async (req, res) => {
+                    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', path: '/knowledge/search', handler: async (req, res) => {
                     const url = query(req);
                     const resolved = resolveBase(url.searchParams.get('kb'));
@@ -885,6 +1097,28 @@ export function apply(ctx, pluginConfig = {}) {
                         ...(url.searchParams.get('detail') === 'true' ? { detail: true } : {}),
                     }));
                 } },
+            { kind: 'exact', path: '/knowledge/environment', handler: async (req, res) => {
+                    if (req.method !== 'GET')
+                        return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '只支持 GET'));
+                    return send(res, 200, success(environment.view()));
+                } },
+            { kind: 'exact', path: '/knowledge/environment/prepare', handler: async (req, res) => {
+                    if (req.method !== 'POST')
+                        return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', '只支持 POST'));
+                    try {
+                        const body = await readBody(req, 4000);
+                        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', path: '/knowledge/embedding/health', handler: async (req, res) => {
                     const resolved = resolveBase(query(req).searchParams.get('kb'));
                     if ('failure' in resolved)
@@ -928,6 +1162,97 @@ export function apply(ctx, pluginConfig = {}) {
                         return sendEnvelope(res, resolved.failure);
                     return send(res, 200, success({ progress: resolved.runtime.compileProgressView(url.searchParams.get('runId') ?? undefined) }));
                 } },
+            { kind: 'exact', path: '/knowledge/pipeline', handler: async (req, res) => {
+                    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, { 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', path: '/knowledge/pipeline-tasks', handler: async (req, res) => {
+                    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', path: '/knowledge/pipeline-task', handler: async (req, res) => {
+                    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', path: '/knowledge/extraction-tasks', handler: async (req, res) => {
+                    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', path: '/knowledge/extraction-task', handler: async (req, res) => {
+                    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 末）。
              *
@@ -971,7 +1296,7 @@ export function apply(ctx, pluginConfig = {}) {
                         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 } : {}),
                         })));
                     }
@@ -1001,7 +1326,7 @@ export function apply(ctx, pluginConfig = {}) {
                                 ...(item?.external_id ? { externalId: String(item.external_id) } : {}),
                                 ...(item?.metadata && typeof item.metadata === 'object' ? { metadata: item.metadata } : {}),
                             })),
-                            ...(body.compile === false ? { compile: false } : {}),
+                            compile: body.compile === true,
                             lineage: lineageOf(body),
                         }));
                     }
@@ -1024,7 +1349,7 @@ export function apply(ctx, pluginConfig = {}) {
                         const resolved = resolveBase(url.searchParams.get('kb'));
                         if ('failure' in resolved)
                             return sendEnvelope(res, resolved.failure);
-                        return send(res, 200, await resolved.runtime.sourceTruth(url.searchParams.get('query') ?? '', Number(url.searchParams.get('limit') ?? 20) || 20, Number(url.searchParams.get('max_chars') ?? 40000) || 40000, lineageFromUrl(url), Number(url.searchParams.get('offset') ?? 0) || 0));
+                        return send(res, 200, await resolved.runtime.sourceTruth(url.searchParams.get('query') ?? '', Number(url.searchParams.get('limit') ?? 20) || 20, 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)));
@@ -1094,7 +1419,8 @@ export function apply(ctx, pluginConfig = {}) {
                          * 任何一条轨迹 —— 「这个实体是哪次抽出来的」就答不上了。
                          */
                         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({
@@ -1102,14 +1428,17 @@ export function apply(ctx, pluginConfig = {}) {
                             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）。**与真编译下发同一份** —— 试跑看到的世界与真编译看到的
@@ -1117,9 +1446,14 @@ export function apply(ctx, pluginConfig = {}) {
                              */
                             ...(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);
                         /**
                          * 落库。写不进去**不改这次试跑的结论** —— 报告照样返回，只是多一句
@@ -1133,24 +1467,7 @@ export function apply(ctx, pluginConfig = {}) {
                             report: { ...report, summary },
                             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)));
@@ -1199,7 +1516,9 @@ export function apply(ctx, pluginConfig = {}) {
                          * 必须分开：`get()` 给 `''`，缺席给 `null`，这个区别正好用得上。
                          */
                         const status = url.searchParams.get('status');
+                        const kind = url.searchParams.get('kind');
                         const filter = {
+                            ...(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') }),
@@ -1292,24 +1611,46 @@ export function apply(ctx, pluginConfig = {}) {
                     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)
@@ -1381,7 +1722,10 @@ export function apply(ctx, pluginConfig = {}) {
                     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=…`（单独一条路由，不是路径参数：
@@ -1395,8 +1739,11 @@ export function apply(ctx, pluginConfig = {}) {
                     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),
                     });
@@ -1421,7 +1768,7 @@ export function apply(ctx, pluginConfig = {}) {
                 } },
             // ---------------------------------------------------------- 目录选择（0029）
             /**
-             * 根路径的**只读**视图：四段布局、两次迁移的结论、家当解析结果、宿主提供的是哪种选择交互。
+             * 根路径的**只读**视图：新布局、家当解析结果、宿主提供的是哪种选择交互。
              *
              * 设置面板要显示「你这个根路径下会长出哪几段」，而那是服务端算出来的
              * （`layout.ts` 是唯一真源），所以不能让前端自己拼字符串。
@@ -1429,22 +1776,13 @@ export function apply(ctx, pluginConfig = {}) {
             { kind: 'exact', path: '/knowledge/layout', handler: async (req, res) => {
                     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 } : {}),
@@ -1526,10 +1864,8 @@ export function apply(ctx, pluginConfig = {}) {
                     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', path: '/diagnosis/run', handler: async (req, res) => {
                     if (req.method !== 'POST')
@@ -1544,9 +1880,9 @@ export function apply(ctx, pluginConfig = {}) {
                     }
                     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 抬分。
@@ -1636,6 +1972,7 @@ export function apply(ctx, pluginConfig = {}) {
                          * ```
                          * /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 的方案说明
@@ -1664,11 +2001,13 @@ export function apply(ctx, pluginConfig = {}) {
                                 ? '抽取试跑'
                                 : rest[1] === 'run'
                                     ? '抽取轨迹'
-                                    : rest[1] === 'help' && rest[2] === 'intent'
-                                        ? '意图的逻辑'
-                                        : rest[1] === 'help' && rest[2] === 'compile'
-                                            ? '编译链路'
-                                            : rest[1] === 'help' && rest[2] === 'overview' ? 'Agent 方案说明' : '整页';
+                                    : rest[1] === 'tasks'
+                                        ? '抽取任务'
+                                        : rest[1] === 'help' && rest[2] === 'intent'
+                                            ? '意图的逻辑'
+                                            : rest[1] === 'help' && rest[2] === 'compile'
+                                                ? '编译链路'
+                                                : rest[1] === 'help' && rest[2] === 'overview' ? 'Agent 方案说明' : '整页';
                             res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-cache' });
                             res.end(standalonePageHtml(title));
                             return;
@@ -1700,9 +2039,37 @@ export function apply(ctx, pluginConfig = {}) {
                             if (rest.length === 2) {
                                 if (method === 'PATCH') {
                                     const body = await readBody(req);
+                                    if (body.compileModel && typeof body.compileModel === 'object') {
+                                        const selection = body.compileModel;
+                                        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);
@@ -1849,8 +2216,7 @@ export function apply(ctx, pluginConfig = {}) {
                         }
                         // ----------------------------------------------- /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);
@@ -1914,7 +2280,8 @@ export function apply(ctx, pluginConfig = {}) {
                             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 }));
@@ -1922,6 +2289,7 @@ export function apply(ctx, pluginConfig = {}) {
                             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)
@@ -1943,6 +2311,27 @@ export function apply(ctx, pluginConfig = {}) {
                                 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 = {};
+                                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);
@@ -1953,7 +2342,7 @@ export function apply(ctx, pluginConfig = {}) {
                                  * 两件事。放成并列的一张表，前端按 `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);
@@ -2091,7 +2480,7 @@ export function apply(ctx, pluginConfig = {}) {
                 } },
         ];
         const disposers = routes.map(register);
-        return () => { runtime.close(); for (const dispose of disposers)
+        return () => { environment.close(); runtime.close(); bases.closeAll(); for (const dispose of disposers)
             void dispose(); };
     });
 }