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

package/src/index.ts

@@ -38,7 +38,7 @@ import { runWikiTrial, trialSummary } from './wiki-trial.js'
 import { extractionRunId } from './extraction-runs.js'
 import type { PipelineStage } from './pipeline/types.js'
 import {
-  agentLayout, defaultAgentRoot, ensureAgentLayout, intentRoot, knowledgeBaseRoot,
+  agentLayout, defaultAgentRoot, ensureAgentLayout, knowledgeBaseRoot,
   memoryRoot, resourceRegistry, resourceRoot, type AgentLayout,
 } from './layout.js'
 import {
@@ -55,21 +55,11 @@ import {
   type ConvertHost,
 } from './convert/host.js'
 import type { ConvertPluginConfig } from './convert/types.js'
-import {
-  applyIntent, INTENT_MOUNT_PATH, INTENT_SERVICE,
-  type IntentHost,
-  type IntentLineageService,
-  type IntentService,
-} from './intent/host.js'
-import { registerIntentTools } from './intent/tools.js'
 
 export * from './types.js'
 export * from './runtime.js'
 export * from './knowledge-bases.js'
-export * from './intent/types.js'
-export * from './intent/engine.js'
 export { applyConvert as applyConvertHost, CONVERT_SETTINGS_NAMESPACE, CONVERT_MOUNT_PATH, type ConvertHost }
-export { applyIntent as applyIntentHost, INTENT_MOUNT_PATH, INTENT_SERVICE, type IntentHost, type IntentLineageService }
 
 export const name = 'dsh-data-domain-knowledge'
 /**
@@ -93,6 +83,7 @@ export { CONVERT_SETTINGS_SCHEMA }
  */
 import { Config, type KnowledgePluginConfig } from './config-schema.js'
 import { buildModelRequest, callModelWithRetry, collectModelText } from './model-text.js'
+import { agentRecallEnvelope } from './recall-delivery.js'
 import {
   addSourceCallView, addSourceMetaOf, addSourceResultMarkdown,
   importCallView, importMetaOf, importResultMarkdown,
@@ -123,7 +114,7 @@ type WebServerLike = { register(route: { kind: 'exact' | 'prefix'; path: string;
  * `src/client/KnowledgeToolRow.tsx` 读它渲染专用卡片（值必须是 JSON 可序列化的 ——
  * 会话日志会整份校验，塞个函数或 Date 会在写日志时炸）。
  *
- * `call` / `result` 是与工具名无关的渲染意图（标题 / 分类 / 一段 Markdown），
+ * `call` / `result` 是与工具名无关的渲染参数（标题 / 分类 / 一段 Markdown），
  * 给终端界面和「没有专用卡片的界面」兜底。三个都是**纯函数**：界面在实时流和会话回放
  * 两条路径上都会调它们。
  *
@@ -212,7 +203,7 @@ function lineageOf(args: Args, exec?: ToolRunContext): LineageContext | undefine
   const sessionId = typeof args.session_key === 'string' && args.session_key.trim() ? args.session_key.trim() : exec?.agent?.session.header.id
   if (sessionId) lineage.sessionId = sessionId
   const fields: Array<[keyof LineageContext, string]> = [
-    ['turnId', 'turn_id'], ['intentId', 'intent_id'], ['taskId', 'task_id'],
+    ['turnId', 'turn_id'], ['taskId', 'task_id'],
     ['subtaskId', 'subtask_id'], ['parentSubtaskId', 'parent_subtask_id'], ['runId', 'run_id'], ['traceId', 'trace_id'], ['domain', 'domain'],
   ]
   for (const [target, source] of fields) if (typeof args[source] === 'string' && args[source].trim()) lineage[target] = args[source].trim().slice(0, 160)
@@ -223,7 +214,6 @@ function lineageFromUrl(url: URL): LineageContext | undefined {
   return lineageOf({
     session_key: url.searchParams.get('session_key') ?? undefined,
     turn_id: url.searchParams.get('turn_id') ?? undefined,
-    intent_id: url.searchParams.get('intent_id') ?? undefined,
     task_id: url.searchParams.get('task_id') ?? undefined,
     subtask_id: url.searchParams.get('subtask_id') ?? undefined,
     parent_subtask_id: url.searchParams.get('parent_subtask_id') ?? undefined,
@@ -407,8 +397,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
   /**
    * 这两组的把手，`loader/volatile-update` 时调 `reprocess()` 按新值重灌。
    *
-   * 先声明后赋值：事件只在运行时触发，而两组的装配在下面（`applyConvert` /
-   * `applyIntent`）。
+   * 先声明后赋值：事件只在运行时触发，转换宿主在下面的 `applyConvert` 中装配。
    */
   let convertHost: ConvertHost | undefined
   /**
@@ -806,7 +795,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     /**
      * 交付物落在**工作项目**下：`<工作区>/output/<日期>/`，不是 Agent 根路径。
      *
-     * 根路径下的四段（知识 / 记忆 / 意图 / 家当）是**这个 Agent 自己的东西**，跨项目
+     * 根路径下的几段（知识 / 记忆 / 家当）是**这个 Agent 自己的东西**，跨项目
      * 累积；交付物是**某个项目的产物**，换一个项目打开就不该再看见。两者判据不同，
      * 所以落点也不同。
      *
@@ -827,30 +816,6 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     },
   })
 
-  // 意图记录模块 (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 `/intent/**` audit endpoints,
-  // and — critically — the `titaDataAgentIntent` Cordis service that `data-table`
-  // resolves by name.
-  // 意图只保留固定的会话审计契约；可编辑词表不再属于插件配置。
-  applyIntent(ctx, {
-    intentRoot: () => intentRoot(config.agentRoot),
-  })
-  // `applyIntent` provides this service from the same plugin fiber. During
-  // `apply()`, that fiber is still starting, so Cordis's default strict lookup
-  // hides the just-provided service until startup completes. The non-strict
-  // lookup is safe here because `applyIntent` ran immediately above.
-  const intentService = ctx.get(INTENT_SERVICE, false) as IntentService
-  /**
-   * `intent_*` 工具在 Host 层注册，使标准模式可以调用它们；工具执行端只接受
-   * standard 会话，其他 preset 不会写入或读取意图记录。
-   */
-  ctx.effect(
-    () => registerIntentTools(ctx as unknown as { tools: { register(definition: unknown): unknown } }, intentService),
-    'tita knowledge: global intent tools',
-  )
-
   /**
    * 规则正文由当前会话 preset 决定；设置里的 volatile 引用在每次组装提示词时解包，
    * 因此开关保存后立即生效，不需要重建 Agent 会话。
@@ -895,12 +860,16 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
     if (writeTools.has(exec.name)) return Promise.resolve({ kind: 'ask', reason: '该操作会写入 Tita Knowledge Store，需要本轮用户审批。' })
     return next()
   })
-  ctx.tools.register(tool('recall_knowledge', 'Recall Wiki Fact and Wiki Way through H2 title and body search. Use the current subquestion as query when seeking a Procedure. Return complete Wiki files with conditions and evidence. Use get_knowledge_cases for historical Case evidence; a past root cause does not establish the current root cause.', { query: { type: 'string', required: true }, limit: { type: 'integer' }, top_k: { type: 'integer' }, top_n: { type: 'integer' }, rerank: { type: 'boolean' }, context_max_chars: { type: 'integer', description: '这次召回的上下文字符上限；省略则用设置里的值（默认 20000，0 = 不限）。超出部分落在系统临时目录，响应里的 budget.overflow_path 就是它的绝对路径 —— 需要更多信息时直接读那个文件。' }, include_problems: { type: 'boolean' }, mode: { type: 'string', enum: ['fts', 'vector', 'hybrid'] }, kb: { type: 'string' }, session_key: { type: 'string' }, task_id: { type: 'string' }, subtask_id: { type: 'string' }, parent_subtask_id: { type: 'string' }, run_id: { type: 'string' }, turn_id: { type: 'string' }, trace_id: { type: 'string' }, domain: { type: 'string' } }, async (args, exec) => withRuntime(args.kb, target => target.recall(args.query, args.top_k ?? args.limit, args.include_problems ?? false, args.mode as RecallMode | undefined, lineageOf(args, exec), { contextTopN: args.top_n, rerank: args.rerank, ...(typeof args.context_max_chars === 'number' ? { contextMaxChars: args.context_max_chars } : {}) })), {
+  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. Follow Wiki links with read_knowledge_wiki; browse Object coordinates with its object_id filter. 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, async target => agentRecallEnvelope(await target.recall(args.query, args.top_k ?? args.limit, args.include_problems ?? false, args.mode as RecallMode | undefined, lineageOf(args, exec), { contextTopN: args.top_n, rerank: args.rerank, ...(typeof args.context_max_chars === 'number' ? { contextMaxChars: args.context_max_chars } : {}) }))), {
     call: recallCallView,
     // 查询词从参数来，命中从结果来 —— 两者拼成一张能看懂的账本。
     meta: (args, value) => recallMetaOf({ ...dataOf(value), query: args?.query }),
     result: resultViewOf(recallResultMarkdown),
   }))
+  ctx.tools.register(tool('read_knowledge_wiki', 'Read a complete Wiki through a [[type/entityId|label]] link or stable target. Browse an Object by object_id or unique object name; optional action_id, scene_id and wiki_kind select exact coordinates. Omitted axes mean all; empty axes match empty only. Object browsing returns a paged directory by default. Set include_content to read complete selected files. Follow outgoing links and backlinks as needed; do not fetch every neighbor automatically.', {
+    target: { type: 'string' }, object_id: { type: 'string' }, object: { type: 'string' }, action_id: { type: 'string' }, scene_id: { type: 'string' }, wiki_kind: { type: 'string', enum: ['fact', 'way'] },
+    include_content: { type: 'boolean' }, limit: { type: 'integer' }, offset: { type: 'integer' }, kb: { type: 'string' },
+  }, async args => withRuntime(args.kb, target => target.readWiki({ target: args.target, objectId: args.object_id, object: args.object, actionId: args.action_id, sceneId: args.scene_id, wikiKind: args.wiki_kind as 'fact' | 'way' | undefined, includeContent: args.include_content, limit: args.limit, offset: args.offset }))))
   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.' },
@@ -1000,10 +969,10 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
    * 两者的差别只在「一次多少份」，落盘路径、分类闸门、编译链路完全共用 ——
    * 这个工具的 `execute` 就是循环调 `importSources`，而后者逐条调 `addSource`。
    *
-   * `compile` 默认开：批量导入的意图几乎总是「进来就能用」。关掉它的场景是「先全部
-   * 落盘、稍后统一编译」——那时卡片还没生成，工具返回里会明说 `compile: null`。
+   * `compile` 默认关闭：先保存来源，再由调用方决定何时处理。显式 true 才跑全链路；
+   * 未触发处理时工具返回 `compile: null`。
    */
-  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) }))
+  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: `来源数组，每项 { source_id?, title?, content, external_id?, metadata?, allow_duplicate_title? }；文件导入前分配唯一 source_id，重试沿用；更新旧来源必须传其 source_id；一次最多 ${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?.source_id ? { sourceId: item.source_id } : {}), ...(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 改了）。
    *
@@ -1146,6 +1115,16 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
         if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
         return send(res, 200, success(await resolved.runtime.stats()))
       } },
+      { kind: 'exact' as const, path: '/knowledge/wiki', handler: async (req: IncomingMessage, res: ServerResponse) => {
+        if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', 'Wiki 读取只接受 GET'))
+        const url = query(req)
+        const resolved = resolveBase(url.searchParams.get('kb'))
+        if ('failure' in resolved) return sendEnvelope(res, resolved.failure)
+        return sendEnvelope(res, await resolved.runtime.readWiki({ target: url.searchParams.get('target') ?? undefined, objectId: url.searchParams.get('object_id') ?? undefined, object: url.searchParams.get('object') ?? undefined,
+          actionId: url.searchParams.get('action_id') ?? undefined, sceneId: url.searchParams.get('scene_id') ?? undefined, wikiKind: (url.searchParams.get('wiki_kind') ?? undefined) as 'fact' | 'way' | undefined,
+          includeContent: url.searchParams.has('include_content') ? url.searchParams.get('include_content') === 'true' : undefined,
+          limit: url.searchParams.has('limit') ? Number(url.searchParams.get('limit')) : undefined, offset: url.searchParams.has('offset') ? Number(url.searchParams.get('offset')) : undefined }))
+      } },
       { kind: 'exact' as const, path: '/knowledge/cases', handler: async (req: IncomingMessage, res: ServerResponse) => {
         if (req.method !== 'GET') return send(res, 405, envelopeError('METHOD_NOT_ALLOWED', 'Case 只接受 GET'))
         const resolved = resolveBase(query(req).searchParams.get('kb'))
@@ -1362,8 +1341,10 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
             sources: (Array.isArray(body.sources) ? body.sources : []).map((item: Record<string, unknown>) => ({
               ...(item?.title ? { title: String(item.title) } : {}),
               content: item?.content as string,
+              ...(item?.source_id ? { sourceId: String(item.source_id) } : {}),
               ...(item?.external_id ? { externalId: String(item.external_id) } : {}),
               ...(item?.metadata && typeof item.metadata === 'object' ? { metadata: item.metadata as Record<string, unknown> } : {}),
+              ...(item?.allow_duplicate_title === true ? { allowDuplicateTitle: true } : {}),
             })),
             compile: body.compile === true,
             lineage: lineageOf(body),
@@ -1966,7 +1947,6 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
            * /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 的方案说明
            * ```
            *
@@ -1993,9 +1973,7 @@ export function apply(ctx: Context, pluginConfig: KnowledgePluginConfig = {}): v
                 ? '抽取轨迹'
                 : rest[1] === 'tasks'
                   ? '抽取任务'
-                : rest[1] === 'help' && rest[2] === 'intent'
-                  ? '意图的逻辑'
-                  : rest[1] === 'help' && rest[2] === 'compile'
+                : 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' })

package/src/knowledge-contract.ts

@@ -18,8 +18,13 @@ export interface KnowledgeContent {
 }
 
 export function wikiProjection(kind: KnowledgeKind, coordinate: { objectId: string; actionId: string; sceneId: string }): { objectId: string; actionId: string; sceneId: string } | undefined {
-  if (kind === 'case' || !coordinate.objectId || (kind === 'procedure' && !coordinate.actionId)) return undefined
-  return { objectId: coordinate.objectId, actionId: kind === 'procedure' ? coordinate.actionId : '', sceneId: '' }
+  if (kind === 'case' || !coordinate.objectId) return undefined
+  return { ...coordinate }
+}
+
+/** Wiki identity preserves the full coordinate and separates Fact from Way. Empty axes are exact values. */
+export function wikiGroupKey(kind: WikiKind, coordinate: { objectId: string; actionId: string; sceneId: string }): string {
+  return `wiki:${kind}:${coordinate.objectId}\u0001${coordinate.actionId}\u0001${coordinate.sceneId}`
 }
 
 export function procedureText(value: ProcedureContent): string {

package/src/layout.ts

@@ -1,5 +1,5 @@
 /**
- * Tita Agent 在磁盘上的布局（0029 定四段，0032 扩到六段，0062 v2 **取消了知识库里的段**）。
+ * Tita Agent 在磁盘上的布局（Agent 根路径固定四段，知识库内部不再使用段目录）。
  *
  * ## 为什么要有这个文件
  *
@@ -8,7 +8,7 @@
  * 都可能指向不同的卷，于是「这个 Agent 的东西在哪」这个问题没有唯一答案 ——
  * 备份要记得两个路径，换机器要改两处，用户也没法一眼看出磁盘上哪块是它的。
  *
- * 现在**只有一个设置**：Tita Agent 根路径。根路径下固定六段，职责互不重叠：
+ * 现在**只有一个设置**：Tita Agent 根路径。根路径下固定四段，职责互不重叠：
  *
  * ```
  * <agentRoot>/
@@ -24,7 +24,6 @@
  *       extraction-runs.sqlite 抽取轨迹
  *       access-audit.ndjson    访问审计
  *       feedback.ndjson        反馈
- *   intent/                    意图：intent.db（会话审计留痕）
  *   tmp/                       运行期临时文件：转换工作区、任务状态
  *     <YYYY-MM-DD>/            二级按日期分桶
  *   resource/                  Agent 跑起来所需要的家当（不是它的产出）
@@ -100,11 +99,7 @@
  *    不可重建的命名决定。按原理 5 的判据（「要不要跟着知识一起备份、迁移、删除」）它们
  *    必须跟着知识走，所以 0062 把它们搬进了 `knowledge.db`。今天 `memory/` 里**没有一样
  *    东西是不可重建的知识**，这才是这条原理想要的终态。
- * 6. **意图（`intent/`）与记忆平级，但它不分库。** 意图是**会话级**的：同一句话
- *    在哪个知识库下说，理解方式不该变。它的两份东西 —— 分类/act 注册表（配置）
- *    与每轮记录（留痕）—— 原来一个住在宿主的 settings 文档里、一个只在内存里，
- *    都不是「这个 Agent 自己的文件」；落进根路径之后，它们和知识、记忆一样可以
- *    被备份、被 diff、被用户直接读。
+ * 6. 会话目标由当前请求和坐标直接提供，不在 Agent 根路径下复制分类词表或会话记录库。
  *
  * 这个文件是布局的**唯一真源**：运行时、知识库注册表、转换内核、设置面板读到的
  * 都是这里算出来的路径，不在别处再拼一次字符串。
@@ -121,8 +116,8 @@ import { basename, dirname, join, resolve } from 'node:path'
  *
  * 分两组看，判据不同：
  *
- * - **Agent 自己的东西**：`domain_knowledge`（知识）、`memory`（记忆）、`intent`
- *   （意图记录）、`tmp`（运行期临时态）。判据是「能不能重建」。
+ * - **Agent 自己的东西**：`domain_knowledge`（知识）、`memory`（审计与版本记录）、
+ *   `tmp`（运行期临时态）。判据是「能不能重建」。
  * - **跑起来所需的依赖**：`resource`（模型、Python 环境、注册表）。判据是「属于谁」。
  *
  * **`output` 不在这里。** 交付物是**某个工作项目的产物**，不是这个 Agent 的固有状态：
@@ -130,7 +125,7 @@ import { basename, dirname, join, resolve } from 'node:path'
  * 所以它落在**当前工作区**的 `output/<日期>/` 下，而不是跟着 Agent 的家走。
  * 约定写在知识插件追加到标准模式系统提示词的行为规则里。
  */
-export const AGENT_DIRS = ['domain_knowledge', 'memory', 'intent', 'tmp', 'resource'] as const
+export const AGENT_DIRS = ['domain_knowledge', 'memory', 'tmp', 'resource'] as const
 export type AgentDirName = typeof AGENT_DIRS[number]
 
 /** 知识树那一段的目录名。 */
@@ -162,19 +157,10 @@ export const RESOURCE_DIR = 'resource'
  * 反馈与访问审计。它从知识树里**搬出来**了，理由见文件头第 5 条原理。
  */
 export const MEMORY_DIR = 'memory'
-/**
- * 意图那一段的目录名（0032）。
- *
- * 里面装的是意图的**会话审计留痕**：`intent.db`（当前记录 + 追加历史）。旧的
- * `records.ndjson` 只在首次打开时迁移，不再继续写入。
- * 分类与 act 是固定契约，不属于 Agent 的可编辑配置。
- */
-export const INTENT_DIR = 'intent'
-
 /**
  * 默认根路径：`~/.dsh/tita-agent`。
  *
- * `.dsh` 是 DSH 的用户级数据根；`tita-agent` 是本插件的专属目录。知识、记忆、意图、
+ * `.dsh` 是 DSH 的用户级数据根；`tita-agent` 是本插件的专属目录。知识、记忆、
  * 临时态与运行所需家当都收在这里，用户不需要再管理一条插件自己的路径。
  */
 export function defaultAgentRoot(): string {
@@ -223,7 +209,7 @@ export function knowledgeBaseRoot(agentRoot: string, kbId: string): string {
  * 交付物的落点：`<工作区>/output`。
  *
  * 刻意**不**由 `agentRoot` 推出来。交付物是**某个工作项目的产物** —— 同一个 Agent
- * 换一个项目打开，不该再看见上一个项目产出的图和数据。知识、记忆、意图记录是 Agent
+ * 换一个项目打开，不该再看见上一个项目产出的图和数据。知识与记忆是 Agent
  * 自己的、跨项目累积的东西，所以留在 `agentRoot`；交付物属于项目，所以跟着项目走。
  *
  * 二级目录按日期分桶（`output/<YYYY-MM-DD>/`），由转换内核的 `bucketByDay` 打开；
@@ -297,11 +283,9 @@ export interface AgentLayout {
   resource: string
   /** 记忆那一段（版本快照 / 反馈 / 访问审计），二级按知识库 id 分叉（0032）。 */
   memory: string
-  /** 意图那一段（intent.db）（0032）。 */
-  intent: string
 }
 
-/** 由根路径算出六段布局。纯函数，测试直接断言。 */
+/** 由根路径算出四段布局。纯函数，测试直接断言。 */
 export function agentLayout(agentRoot: string): AgentLayout {
   const root = resolve(agentRoot)
   return {
@@ -310,7 +294,6 @@ export function agentLayout(agentRoot: string): AgentLayout {
     tmp: join(root, TMP_DIR),
     resource: join(root, RESOURCE_DIR),
     memory: join(root, MEMORY_DIR),
-    intent: join(root, INTENT_DIR),
   }
 }
 
@@ -326,11 +309,6 @@ export function memoryRoot(agentRoot: string, kbId: string): string {
   return join(resolve(agentRoot), MEMORY_DIR, kbId)
 }
 
-/** `<agentRoot>/intent`：会话意图审计留痕（0032）。意图不分库。 */
-export function intentRoot(agentRoot: string): string {
-  return join(resolve(agentRoot), INTENT_DIR)
-}
-
 /**
  * 一个知识库根目录里**固定存在的三样东西**（PRD v2 §0.2）。
  *
@@ -396,7 +374,7 @@ export function looksLikeLegacyKnowledgeRoot(path: string): boolean {
  */
 export function ensureAgentLayout(agentRoot: string): AgentLayout {
   const layout = agentLayout(agentRoot)
-  for (const dir of [layout.domainKnowledge, layout.tmp, layout.resource, layout.memory, layout.intent]) {
+  for (const dir of [layout.domainKnowledge, layout.tmp, layout.resource, layout.memory]) {
     try {
       mkdirSync(dir, { recursive: true })
     } catch {

package/src/materialize-snapshot.ts

@@ -33,6 +33,7 @@ export interface MaterializationSnapshot {
   blockedAmbiguous: number
   /** 来源已变化 / 新抽取尚未归一的 Knowledge 条数。 */
   blockedAwaitingNormalize: number
+  blockedItems: Array<{ knowledgeId: string; sourceIds: string[]; groupKey?: string }>
   /** key → 这一组参与成卡的知识。 */
   knowledge: Map<string, Knowledge[]>
   /** key → 这一组的 Event。 */

package/src/migrate.ts

@@ -87,7 +87,9 @@ function skipped(reason: string, from?: string, to?: string): MigrationOutcome {
  * 把旧版完整的 Agent 根目录合并到新的固定根目录。
  *
  * 这和 `migrateLegacyKnowledgeTree` 不同：后者只认识一棵知识库树，而这里要把
- * `domain_knowledge`、`memory`、`intent`、`resource` 与 `tmp` 一起搬走。目标里已经有
+ * `domain_knowledge`、`memory`、`resource` 与 `tmp` 一起搬走。历史 `intent` 目录不再由插件
+ * 读取或迁移；如果它仍在旧根路径中，会阻止旧根目录被清空，保留原始数据供用户自行处理。
+ * 目标里已经有
  * 同名目录时逐层合并，任何同名文件都不覆盖，并把冲突留下来交给界面报告。
  */
 export function migrateLegacyAgentRoot(input: { agentRoot: string; legacyRoot: string }): MigrationOutcome {

package/src/organize-contract.ts

@@ -19,7 +19,7 @@ export function buildOrganizeSystem(wikiKind: 'fact' | 'way' = 'fact'): string {
   return [
     '你在把一批已经抽好的知识组织成一张 Wiki 卡片。',
     '',
-    `文件类型：${wikiKind === 'way' ? 'Wiki Way；同 Object + Action 的 Procedure' : 'Wiki Fact；同 Object 的 Fact'}。Scene 可以不同，必须保留每条的条件、状态与限制。`,
+    `文件类型：${wikiKind === 'way' ? 'Wiki Way；同一 Object × Action × Scene 坐标下的 Procedure' : 'Wiki Fact；同一 Object × Action × Scene 坐标下的 Fact'}。不得把不同坐标的内容合并。空坐标分量不表示通用，保留每条的条件、状态与限制。`,
     '这些条目是 Knowledge 真源。你不许新增、',
     '删除或改动它们说的事实。你能做的是：分小节、定顺序、把它们改写成读得下去的',
     '叙述、给卡片起一个自然的标题、写一句概述。',
@@ -33,6 +33,7 @@ export function buildOrganizeSystem(wikiKind: 'fact' | 'way' = 'fact'): string {
     '3. **每句都要挂引用。** 陈述事实的句子末尾挂 `[^知识id]`，可以挂多个。',
     '   只有很短的导语（「这一节讲取数流程」）可以不挂。长句子不挂引用 = 没有来源的',
     '   断言，整份方案会被打回。',
+    '涉及其他 Object 的定义或方法时，使用给定目标的双链，不把另一份 Wiki 的全文复制进来。无法唯一定位时保留对象原名，由程序补充导航，不编造链接或新坐标。',
     '4. **标题只做归纳，不要机械拼接。** 标题要能让人一眼知道卡片讲什么；不要照抄候选卡名，',
     '   不要写成「对象的动作」「动作的动作」这类重复结构，不要加入知识里没有的新事实。',
     '   保留区分这张卡所需的业务对象、字段名和动作词。知识条目附带的原文标题路径是定位线索，',

package/src/pipeline/engine.ts

@@ -26,6 +26,7 @@ export interface PipelineHost {
   derive?(sourceIds: string[] | undefined, context: PipelineContext, force: boolean, output: (text: string) => void, checkpoint: () => Promise<void>): Promise<{ done: number; total: number; reused: number; summary: string }>
   groups(context: PipelineContext): Promise<MaterializationBatch>
   materialize(group: MaterializationGroup, context: PipelineContext, output: (text: string) => void, snapshot: unknown): Promise<void>
+  link?(): Promise<string>
   build(taskId: string, checkpoint: () => Promise<void>): Promise<PipelineBuildResult>
   record(checkpoint: ExtractionCheckpoint): Promise<void>
 }
@@ -186,10 +187,13 @@ export class KnowledgePipeline {
            * 「坐标有歧义」与「来源变了、抽取结果还没归一」是两件事，报同一句话会让读的人
            * 去查错的地方。更要紧的是范围：按 `sourceIds` / `groupKeys` 缩小的那一趟，
            * 如果拿全库的数字报 `partial`，调用方会去重试一件它明确排除的事 —— 而它其实
-           * 全都做完了。坐标有歧义的那些行不属于任何分组，无法按来源归属，所以只在
-           * 没有选择范围时才计入。
+           * 全都做完了。被阻断的 Knowledge 保留来源归属和可确定的分组键，因此也按
+           * 同一选择范围计数；尚无坐标的行只参与来源范围与全库统计。
            */
-          const ambiguous = scoped ? 0 : batch.blockedAmbiguous
+          const ambiguous = scoped
+            ? (batch.blockedItems ?? []).filter(item => (!affectedSources || item.sourceIds.some(id => affectedSources.has(id)))
+              && (!selected || (item.groupKey !== undefined && selected.has(item.groupKey)))).length
+            : batch.blockedAmbiguous
           const awaiting = scoped
             ? groups.filter(group => group.state === 'blocked' && inScope(group)).reduce((sum, group) => sum + group.knowledgeCount, 0)
             : batch.blockedAwaitingNormalize
@@ -220,6 +224,8 @@ export class KnowledgePipeline {
             const current = this.store.task(id)!
             this.patch(id, { done: current.done + 1, summary: `已物化 ${current.done + 1}/${pending.length} 张：${group.title}` })
           }
+          await this.checkpoint(id)
+          if (this.host.link) this.store.event(id, 'output', await this.host.link(), undefined, stage)
           const current = this.store.task(id)!
           /**
            * 阶段结论要给 `summary`：任务列表的四段步轨读的是 `results[stage]`，

package/src/pipeline/types.ts

@@ -74,6 +74,8 @@ export interface MaterializationBatch {
   blocked: number
   blockedAmbiguous: number
   blockedAwaitingNormalize: number
+  /** Rows outside publishable groups still retain their source scope. */
+  blockedItems?: Array<{ knowledgeId: string; sourceIds: string[]; groupKey?: string }>
   snapshot: unknown
 }
 

package/src/present.ts

@@ -13,7 +13,7 @@
  * 1. `presentationMeta` —— 结构化的小账本，随 `tool/result` 落进会话日志，
  *    Web 端的卡片读它渲染（`src/client/KnowledgeToolRow.tsx`）。它必须
  *    **可 JSON 序列化**（会话日志会整份校验），所以这里不塞函数、不塞 Date；
- * 2. `present*View` —— 与工具名无关的渲染意图（标题 / 分类 / 一段 Markdown），
+ * 2. `present*View` —— 与工具名无关的渲染参数（标题 / 分类 / 一段 Markdown），
  *    给终端界面和「没有专用卡片的界面」用。
  *
  * ## 一条规矩：数字必须来自真实的产物

package/src/preset-ids.ts

@@ -1,6 +1,2 @@
 /** Preset ids persisted in DSH session headers. */
 export const STANDARD_PRESET_ID = 'standard'
-
-export function isIntentEnabledPreset(presetId: unknown): boolean {
-  return presetId === STANDARD_PRESET_ID
-}

package/src/query-analysis.ts

@@ -2,8 +2,6 @@ import type { AxisEntity, AxisKind, AxisRelation } from './axis-registry.js'
 import { normalizeAxisName } from './axis-registry.js'
 import type { CardCoordinate } from './types.js'
 
-export type QueryIntent = 'lookup' | 'explain' | 'procedure' | 'troubleshoot' | 'compare' | 'unknown'
-
 export interface QueryAxisMatch {
   id: string
   kind: AxisKind
@@ -30,7 +28,6 @@ export interface QueryRelationCandidate extends QueryCoordinateCandidate {
 
 export interface QueryAnalysis {
   query: string
-  intent: { id: QueryIntent; confidence: number }
   axes: Record<AxisKind, QueryAxisMatch[]>
   coordinates: QueryCoordinateCandidate[]
   unresolved: string[]
@@ -39,22 +36,6 @@ export interface QueryAnalysis {
 type RegistryEntity = AxisEntity & { aliases: string[] }
 type CoordinateCard = { cardKey: string; coordinate?: CardCoordinate }
 
-const INTENT_RULES: Array<{ id: Exclude<QueryIntent, 'unknown'>; confidence: number; terms: string[] }> = [
-  { id: 'troubleshoot', confidence: 0.9, terms: ['怎么排查', '如何排查', '异常', '报错', '失败', '原因', '为什么', '定位', '故障', '不工作'] },
-  { id: 'procedure', confidence: 0.88, terms: ['怎么做', '如何做', '怎么', '如何', '步骤', '流程', '操作', '配置', '接入', '实现'] },
-  { id: 'compare', confidence: 0.86, terms: ['区别', '差异', '对比', '比较', '哪个好', '不同点'] },
-  { id: 'explain', confidence: 0.86, terms: ['什么是', '是什么', '定义', '含义', '解释', '指什么'] },
-  { id: 'lookup', confidence: 0.78, terms: ['多少', '口径', '计算', '查询', '查看', '数据', '指标', '有哪些'] },
-]
-
-function classifyIntent(query: string): QueryAnalysis['intent'] {
-  const normalized = normalizeAxisName(query)
-  for (const rule of INTENT_RULES) {
-    if (rule.terms.some(term => normalized.includes(normalizeAxisName(term)))) return { id: rule.id, confidence: rule.confidence }
-  }
-  return { id: 'unknown', confidence: 0.35 }
-}
-
 function validMention(mention: string): boolean {
   const normalized = normalizeAxisName(mention)
   // 单字中文命中率很高，不能作为坐标证据；两个字符以上的中文或 ASCII 标识可以保留。
@@ -187,7 +168,6 @@ export function analyzeQuery(query: string, entities: RegistryEntity[], cards: C
     .filter(kind => axes[kind].length === 0)
   return {
     query,
-    intent: classifyIntent(query),
     axes,
     coordinates: coordinateCandidates(axes, cards),
     unresolved,

package/src/recall-delivery.ts

@@ -0,0 +1,19 @@
+import type { ContextItem, Envelope, RecallHit, RecallResult } from './types.js'
+
+const compactHit = (hit: RecallHit) => ({ unitId: hit.unitId, entityId: hit.entityId, entityType: hit.entityType, title: hit.title,
+  ...(hit.heading ? { heading: hit.heading } : {}), score: hit.score,
+  ...(hit.rerankScore === undefined ? {} : { rerankScore: hit.rerankScore }) })
+
+/** Section references explain retrieval; the complete body is already in item.wiki. */
+export const agentContextItem = (item: ContextItem) => ({ ...item,
+  ...(item.note ? { note: compactHit(item.note) } : {}), notes: item.notes.map(compactHit),
+})
+
+/** Agent delivery carries each complete Wiki once, only inside the budgeted context. */
+export function agentRecallEnvelope(value: Envelope<RecallResult>): Envelope<unknown> {
+  return { ...value, data: { ...value.data,
+    hits: value.data.hits.map(compactHit),
+    wiki: value.data.wiki.map(card => ({ entityId: card.entityId, entityType: card.entityType, title: card.title })),
+    context: value.data.context.map(agentContextItem),
+  } }
+}