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

package/src/runtime.ts

@@ -1,4 +1,8 @@
-import { wikiProjection, procedureText, type ProcedureContent } from './knowledge-contract.js'
+import { compileWikiNavigation, scanWikiLinks, stripWikiNavigation, wikiIndexContent, wikiLinkCandidates, wikiReference, type WikiReference } from './wiki-links.js'
+import { wikiProjection, wikiGroupKey, procedureText, type ProcedureContent, type WikiKind } from './knowledge-contract.js'
+import { wikiUnavailableReason } from './wiki-availability.js'
+import { newSourceId } from './source-identity.js'
+import { agentContextItem } from './recall-delivery.js'
 import { buildDeriveSystem, DERIVE_CONTRACT_VERSION } from './derive-contract.js'
 import { createHash, randomUUID } from 'node:crypto'
 import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
@@ -40,7 +44,7 @@ import type { MaterializationGroup, PipelineStatus } from './pipeline/types.js'
 import type { MaterializationSnapshot } from './materialize-snapshot.js'
 import { candidatesFromReport, coordinateIdsOf, coordinateIsEmpty, type MaterializedCard } from './wiki-materialize.js'
 import {
-  sectionRecords,
+  sectionRecords, ORGANIZE_VERSION,
   buildOrganizePrompt, buildOrganizeSystem, checkOrganize, citationsFrom, layoutHash, layoutOf,
   parseOrganize, placementsOf, renderFootnoteDefinitions, renderOrganizeBody,
   type CardCitationRecord, type CardLayoutRecord, type OrganizeInput, type OrganizePlan,
@@ -1181,7 +1185,7 @@ function parseLineage(value: unknown): LineageContext | undefined {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined
   const record = value as Record<string, unknown>
   const lineage: LineageContext = {}
-  for (const key of ['sessionId', 'turnId', 'intentId', 'taskId', 'subtaskId', 'parentSubtaskId', 'runId', 'traceId', 'domain'] as const) {
+  for (const key of ['sessionId', 'turnId', 'taskId', 'subtaskId', 'parentSubtaskId', 'runId', 'traceId', 'domain'] as const) {
     if (typeof record[key] === 'string' && record[key].trim()) lineage[key] = record[key].trim().slice(0, 160)
   }
   return Object.keys(lineage).length > 0 ? lineage : undefined
@@ -1311,7 +1315,7 @@ export function splitWikiNotes(card: Pick<KnowledgeCard, 'summary' | 'content'>)
   const sections: Array<{ heading: string; lines: string[] }> = []
   let current: { heading: string; lines: string[] } | undefined
   let fence: string | undefined
-  for (const line of card.content.trim().split('\n')) {
+  for (const line of stripWikiNavigation(card.content).trim().split('\n')) {
     const code = line.match(/^\s*(?:(?:\d+[.)]|[-+*])\s+)?(`{3,}|~{3,})(.*)$/)
     if (code) {
       if (!fence) fence = code[1]!
@@ -3179,8 +3183,8 @@ export class KnowledgeRuntime {
    * 每条的原因仍然在 `sources[].message` 里。
    */
   async importSources(input: {
-    sources: Array<{ title?: string; content: string; externalId?: string; metadata?: Record<string, unknown>; allowDuplicateTitle?: boolean }>
-    /** 默认编译（`only: 'wiki'`）。关掉它就只做写入，留给调用方自己决定何时编译。 */
+    sources: Array<{ sourceId?: string; title?: string; content: string; externalId?: string; metadata?: Record<string, unknown>; allowDuplicateTitle?: boolean }>
+    /** 默认只保存 Source Raw；显式 true 才运行完整处理流程。 */
     compile?: boolean
     lineage?: LineageContext
   }): Promise<Envelope<ImportSourcesResult>> {
@@ -3201,6 +3205,7 @@ export class KnowledgeRuntime {
     for (const [index, item] of items.entries()) {
       const title = item?.title?.trim() || undefined
       const result = await this.addSource({
+        ...(item?.sourceId ? { sourceId: item.sourceId } : {}),
         ...(title ? { title } : {}),
         content: item?.content,
         ...(item?.externalId ? { externalId: item.externalId } : {}),
@@ -3321,7 +3326,7 @@ export class KnowledgeRuntime {
     provenance?: SourceProvenance
     /**
      * 允许与已有的来源同标题（0051）。默认 `false`：重名是错误，拒收并要求改标题。
-     * 传 `true` 时落成 `<标题>-<内容哈希前 6 位>.md`，并回一条 warning。
+     * 传 `true` 时按各自 Source Raw ID 并存，并回一条 warning。
      */
     allowDuplicateTitle?: boolean
   }): Promise<Envelope<{ sourceId: string; lineage?: LineageContext }>> {
@@ -3344,7 +3349,7 @@ export class KnowledgeRuntime {
     if (db === null) {
       return failure({ sourceId: '' }, 'STORE_UNAVAILABLE', this.storeProblem ?? '知识库不可用', true, '检查 Node 版本（正文进库之后需要 22.5+ 的 node:sqlite）与知识库文件的属主标记。')
     }
-    const sourceId = input.sourceId?.trim() || hash(input.externalId ?? input.content)
+    const sourceId = input.sourceId?.trim() || (input.externalId?.startsWith('upload:') ? newSourceId() : hash(input.externalId ?? input.content))
     if (!SAFE_ID.test(sourceId)) return failure({ sourceId: '' }, 'SOURCE_ID_INVALID', 'source_id 含有非法字符', false)
     const title = input.title?.trim() || sourceId
     /**
@@ -4386,7 +4391,8 @@ export class KnowledgeRuntime {
 
     const listed = input.knowledge ? { knowledge: input.knowledge, total: input.knowledge.length } : await store.list({
       objectId: input.coordinate.objectId,
-      ...(input.existing?.metadata.wiki_kind ? { kind: input.existing.metadata.wiki_kind === 'way' ? 'procedure' as const : 'fact' as const, ...(input.coordinate.actionId ? { actionId: input.coordinate.actionId } : {}) } : { actionId: input.coordinate.actionId, sceneId: input.coordinate.sceneId }),
+      actionId: input.coordinate.actionId, sceneId: input.coordinate.sceneId,
+      ...(input.existing?.metadata.wiki_kind ? { kind: input.existing.metadata.wiki_kind === 'way' ? 'procedure' as const : 'fact' as const } : {}),
       excludeWithdrawn: true,
       limit: MAX_ORGANIZE_KNOWLEDGE,
     })
@@ -4438,7 +4444,7 @@ export class KnowledgeRuntime {
       hash,
       layout,
       reuse,
-      system: buildOrganizeSystem(input.coordinate.actionId ? 'way' : 'fact'),
+      system: buildOrganizeSystem(input.existing?.metadata.wiki_kind === 'way' || listed.knowledge[0]?.kind === 'procedure' ? 'way' : 'fact'),
       prompt: buildOrganizePrompt(organizeInput),
     }
   }
@@ -4637,7 +4643,7 @@ export class KnowledgeRuntime {
       const plan = planRelated(cards, relations, await this.projectedRelated(cards))
       const entries = plan.get(cardKey(card))
       if (entries === undefined || entries.length === 0) return {}
-      return { related: entries.map(entry => ({ title: entry.title, entityType: entry.entityType, reason: entry.reason })) }
+      return { related: entries.map(entry => ({ title: entry.title, entityType: entry.entityType, entityId: entry.entityId, reason: entry.reason })) }
     } catch {
       // 相关投影是**增强**：算不出来时不给清单，于是正文里一个 `[[…]]` 都不许出现 —— 而不是把卡片卡住。
       return {}
@@ -4868,7 +4874,9 @@ export class KnowledgeRuntime {
     const createdAt = typeof existing?.frontmatter.created_at === 'string' && existing.frontmatter.created_at ? existing.frontmatter.created_at : updatedAt
     const provenance = [...(input.provenance ?? []), ...(input.lineage ? [{ ...input.lineage, role: 'created' as const, refType: 'knowledge_card', refId: input.entityId }] : [])]
     // 旧版本曾把 schema_issues 写入 metadata。重写卡片时主动摘掉它，避免旧的待补结果继续出现。
-    const { schema_issues: _staleIssues, ...metadata } = input.metadata ?? {}
+    const { schema_issues: _staleIssues, ...metadata } = input.metadata ?? previous?.metadata ?? {}
+    if (status === 'deprecated' && (input.origin === 'review' || input.origin === 'manual' || (input.origin === undefined && previous?.status !== 'deprecated'))) metadata.wiki_deprecation_origin = 'manual'
+    if (status !== 'deprecated') delete metadata.wiki_deprecation_origin
     void _staleIssues
     // 备注与 review **默认继承库里已有的**：不传不等于清空（见入参注释）。
     const annotations = input.annotations ?? previousAnnotations ?? []
@@ -4949,7 +4957,89 @@ export class KnowledgeRuntime {
     return success({ entityId: input.entityId, ...(input.lineage ? { lineage: input.lineage } : {}) })
   }
 
-  /** Resolve one card by id, optionally constrained to a type (ids are unique per type). */
+  /** Shared by direct reads, index publication and recall; always reads live contributions. */
+  private async wikiUnavailability(cards: readonly KnowledgeCard[], suppliedPlacements?: Map<string, CardKnowledgeRow[]>): Promise<Map<string, string>> {
+    const truth = await this.storeHandle()
+    const knowledge = await this.knowledgeStore()
+    if (!truth || !knowledge) return new Map(cards.map(card => [cardKey(card), '知识真源不可用，无法核验 Wiki。']))
+    const placements = suppliedPlacements ?? truth.placementsOf(cards.map(card => card.entityId))
+    const ids = [...new Set(cards.flatMap(card => [...(placements.get(card.entityId) ?? []).map(row => row.knowledgeId), ...Object.keys(card.metadata.knowledge_versions as object ?? {})]))]
+    const rows = new Map<string, Knowledge>()
+    for (let offset = 0; offset < ids.length; offset += 500) {
+      const page = await knowledge.list({ ids: ids.slice(offset, offset + 500), includeMerged: true, limit: 500 })
+      for (const row of page.knowledge) rows.set(row.id, row)
+    }
+    const sources = new Map((truth.raw('SELECT entity_id,head_version FROM source').all() as Array<{ entity_id: string; head_version: number }>).map(row => [row.entity_id, row.head_version]))
+    const cases = new Map<string, number | undefined>()
+    const result = new Map<string, string>()
+    for (const card of cards) {
+      const reason = wikiUnavailableReason(card, placements.get(card.entityId) ?? [], { knowledge: rows, sources, caseVersion: id => {
+        if (!cases.has(id)) cases.set(id, truth.event(id)?.version)
+        return cases.get(id)
+      } })
+      if (reason) result.set(cardKey(card), reason)
+    }
+    return result
+  }
+
+  /** Read a stable Wiki link or browse an Object's coordinates without flattening its files. */
+  async readWiki(input: { target?: string; objectId?: string; object?: string; actionId?: string; sceneId?: string; wikiKind?: WikiKind; includeContent?: boolean; limit?: number; offset?: number } = {}): Promise<Envelope<Record<string, unknown>>> {
+    const empty = { wikis: [], total: 0, offset: input.offset ?? 0, hasMore: false, outgoing: [], backlinks: [] }
+    const limit = input.limit ?? 20, offset = input.offset ?? 0
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100 || !Number.isInteger(offset) || offset < 0) return failure(empty, 'WIKI_PAGE_INVALID', 'limit 必须为 1–100 的整数，offset 必须为非负整数。', false)
+    if (input.wikiKind !== undefined && input.wikiKind !== 'fact' && input.wikiKind !== 'way') return failure(empty, 'WIKI_KIND_INVALID', 'wiki_kind 只能为 fact 或 way。', false)
+    if (!input.target?.trim() && !input.objectId?.trim() && !input.object?.trim()) return failure(empty, 'WIKI_SCOPE_REQUIRED', '请提供双链 target、object_id 或明确的 Object 名称。', false)
+    const cards = await this.loadCards()
+    let objectId = input.objectId
+    if (input.object !== undefined) {
+      const name = input.object.trim().toLocaleLowerCase()
+      const objects = (await this.listAxisEntities('object') ?? []).filter(object => object.status !== 'deprecated' && object.status !== 'merged'
+        && [object.id, object.name, ...object.aliases].some(value => value.toLocaleLowerCase() === name))
+      if (objects.length !== 1) return failure({ ...empty, candidates: objects.map(object => ({ id: object.id, name: object.name })) }, objects.length ? 'OBJECT_AMBIGUOUS' : 'OBJECT_NOT_FOUND', 'Object 名称未唯一解析，请使用明确的 object_id。', false)
+      if (objectId !== undefined && objectId !== objects[0]!.id) return failure(empty, 'OBJECT_SCOPE_CONFLICT', 'object 与 object_id 指向不同对象。', false)
+      objectId = objects[0]!.id
+    }
+    const inScope = (card: KnowledgeCard): boolean => (objectId === undefined || card.coordinate?.objectId === objectId)
+      && (input.actionId === undefined || card.coordinate?.actionId === input.actionId)
+      && (input.sceneId === undefined || card.coordinate?.sceneId === input.sceneId)
+      && (input.wikiKind === undefined || card.metadata.wiki_kind === input.wikiKind)
+    let selected = cards.filter(inScope)
+    if (input.target?.trim()) {
+      selected = wikiLinkCandidates(selected, input.target)
+      if (selected.length !== 1) return failure({ ...empty, candidates: selected.map(card => ({ ...wikiReference(card), coordinate: card.coordinate, wikiKind: card.metadata.wiki_kind })) }, selected.length ? 'WIKI_LINK_AMBIGUOUS' : 'WIKI_NOT_FOUND', '双链未唯一指向 Wiki，请从候选中使用稳定 target。', false)
+      if (selected[0]!.status === 'deprecated') return failure(empty, 'WIKI_UNAVAILABLE', '目标 Wiki 已停用，请按 Object 坐标查找当前文件。', false)
+    }
+    selected = selected.filter(card => card.status !== 'deprecated').sort((a, b) => wikiReference(a).target.localeCompare(wikiReference(b).target))
+    const page = selected.slice(offset, offset + limit)
+    const includeContent = input.includeContent ?? Boolean(input.target)
+    const truth = await this.storeHandle()
+    const placements = truth?.placementsOf(page.map(card => card.entityId)) ?? new Map<string, CardKnowledgeRow[]>()
+    const unavailableByKey = await this.wikiUnavailability(page, placements)
+    const wikis: Array<Record<string, unknown>> = []
+    for (const card of page) {
+      const unavailable = unavailableByKey.get(cardKey(card))
+      wikis.push({ ...wikiReference(card), coordinate: card.coordinate, wikiKind: card.metadata.wiki_kind, status: card.status, available: !unavailable,
+        ...(unavailable ? { reason: unavailable } : {}), ...(card.coordinate ? { coordinateLabels: await this.coordinateNames(card.coordinate) } : {}),
+        ...(includeContent && !unavailable ? { wiki: card } : {}),
+      })
+    }
+    const first = input.target ? page[0] : undefined
+    const live = cards.filter(card => card.status !== 'deprecated')
+    const outgoing = first ? [...new Map(scanWikiLinks(first.content).flatMap(link => {
+      const targets = wikiLinkCandidates(live, link.target)
+      return targets.length === 1 && targets[0]!.entityId !== first.entityId ? [[targets[0]!.entityId, wikiReference(targets[0]!)] as const] : []
+    })).values()] : []
+    const backlinks = first ? live.filter(card => card.entityId !== first.entityId && scanWikiLinks(card.content).some(link => {
+      const targets = wikiLinkCandidates(live, link.target)
+      return targets.length === 1 && targets[0]!.entityId === first.entityId
+    })).map(wikiReference) : []
+    const data = { wikis, total: selected.length, offset, hasMore: offset + page.length < selected.length,
+      nextOffset: offset + page.length < selected.length ? offset + page.length : null, outgoing, backlinks }
+    await this.audit('wiki.read', { target: input.target, objectId, actionId: input.actionId, sceneId: input.sceneId, wikiKind: input.wikiKind, includeContent, returned: page.length })
+    return success(data)
+  }
+
+  /** Resolve one card by its stable ID, optionally constrained to a type. */
   async readCard(entityId: string, entityType?: SchemaType): Promise<KnowledgeCard | undefined> {
     const db = await this.storeHandle()
     if (db === null) return undefined
@@ -5040,7 +5130,7 @@ export class KnowledgeRuntime {
     if (card.status === 'problem' && status !== 'unreviewed') return failure({ entityId, status }, 'STATUS_TRANSITION_INVALID', 'problem 不能直接恢复为其他状态，请先改为 unreviewed', false)
     const eventLineage = withRun(lineage, 'knowledge-status')
     const provenance = [...(card.provenance ?? []), ...(eventLineage ? [{ ...eventLineage, role: 'executed' as const, refType: 'knowledge_status', refId: entityId }] : [])]
-    const written = await this.writeCard({ ...card, status, sourceRefs: card.sourceRefs, provenance, metadata: { ...card.metadata, ...(problemNote?.trim() ? { problem_note: problemNote.trim() } : {}) } })
+    const written = await this.writeCard({ ...card, status, sourceRefs: card.sourceRefs, provenance, origin: 'review', metadata: { ...card.metadata, ...(problemNote?.trim() ? { problem_note: problemNote.trim() } : {}) } })
     if (written.ok === false) return failure({ entityId, status }, written.error.code, written.error.message, written.error.retryable, written.error.suggestion)
     return success({ entityId, status, ...(eventLineage ? { lineage: eventLineage } : {}) })
   }
@@ -5087,7 +5177,7 @@ export class KnowledgeRuntime {
      * `metadata.related_cards`；这里继续剥离旧版本正文里的标记，保证存量卡片迁移期间
      * 也不会把导航送进召回。
      */
-    const recallBody = stripEventReferenceSection(stripRelatedSection(card.content))
+    const recallBody = wikiIndexContent(stripEventReferenceSection(stripRelatedSection(card.content)))
     for (const [index, chunk] of splitWikiNotes({ ...card, content: recallBody }).entries()) {
       const baseId = `${card.entityType}:${card.entityId}`
       const stableSection = layoutOf(card.metadata)?.sections?.find(section => section.title === chunk.heading)
@@ -5649,7 +5739,7 @@ export class KnowledgeRuntime {
         existing: card,
         ...(input.imagePlan.byCard.get(key) === undefined ? {} : { images: input.imagePlan.byCard.get(key) }),
         ...(relatedPlan.get(key) === undefined ? {} : {
-          related: (relatedPlan.get(key) ?? []).map(entry => ({ title: entry.title, entityType: entry.entityType, reason: entry.reason })),
+          related: (relatedPlan.get(key) ?? []).map(entry => ({ title: entry.title, entityType: entry.entityType, entityId: entry.entityId, reason: entry.reason })),
         }),
         call: input.call,
       })
@@ -6211,12 +6301,11 @@ export class KnowledgeRuntime {
   // ------------------------------------------- Finalize · 索引 / 断链 / 相关（0049）
 
   /**
-   * 收尾段的**结构化数据层**：把相关卡片写进 `metadata.related_cards`，清理旧版本写进
-   * 正文的相关块，并把断链统计交给编译报告与索引页。
+   * 编译收尾：生成类型化 Wiki 的稳定双链与导航，更新 `metadata.related_cards`，
+   * 清理旧相关块，并把断链统计交给编译报告与索引页。
    *
-   * 相关卡片是派生导航数据，不是知识正文。它放在 metadata 里有三个好处：正文不会被
-   * 机器段落污染，召回不需要再剥离导航块，面板也能直接按结构展示。旧卡片上的
-   * `<!-- compiled:related -->` 只在这里做一次兼容清理。
+   * 导航只放链接，不复制目标正文；面板使用结构化元数据，检索排除生成的导航块。
+   * 旧卡片上的 `<!-- compiled:related -->` 在这里兼容清理。
    *
    * 三段都是确定性的，所以这个函数可以重复跑：正文和结构化相关数据都没变化时不写盘。
    */
@@ -6230,11 +6319,24 @@ export class KnowledgeRuntime {
      * 它是**算出来的**，不是谁声明的：这张卡里的知识引用了哪个轴实体，而那个轴自己
      * 有一张卡，就有了链接。模型抽出来的关系（`relations`）是第二层。
      */
-    const projected = await this.projectedRelated(cards)
-    const related = planRelated(cards, relations, projected)
-    /** 统计清理旧导航块之后的正文断链；相关卡片本身不再伪装成正文链接。 */
-    const nextCards = cards.map(card => ({ ...card, content: stripEventReferenceSection(stripRelatedSection(card.content)) }))
-    const deadLinks = deadLinksOf(nextCards)
+    const axes = (await this.listAxisEntities() ?? []).filter(axis => axis.status !== 'deprecated' && axis.status !== 'merged')
+    const objects = axes.filter(axis => axis.kind === 'object')
+    const names = new Map(axes.map(axis => [axis.id, axis.name]))
+    const labeled = cards.map(card => card.metadata.wiki_kind && card.coordinate ? { ...card, metadata: { ...card.metadata,
+      wiki_coordinate_labels: { object: names.get(card.coordinate.objectId) ?? card.coordinate.objectId, action: names.get(card.coordinate.actionId) ?? card.coordinate.actionId, scene: names.get(card.coordinate.sceneId) ?? card.coordinate.sceneId },
+    } } : card)
+    const live = labeled.filter(card => card.status !== 'deprecated')
+    const nextCards = labeled.map(card => {
+      const base = { ...card, content: stripEventReferenceSection(stripRelatedSection(card.content)) }
+      if (!card.metadata.wiki_kind || card.status === 'deprecated') return base
+      const navigation = compileWikiNavigation(base, live, objects)
+      return { ...base, content: navigation.content, metadata: { ...base.metadata,
+        wiki_links: navigation.outgoing, wiki_inline_targets: navigation.inlineTargets, wiki_object_refs: navigation.objectIds,
+      } }
+    })
+    const projected = await this.projectedRelated(nextCards)
+    const related = planRelated(live, relations, projected)
+    const deadLinks = deadLinksOf(nextCards.filter(card => card.status !== 'deprecated'))
     let rewritten = 0
     for (const [index, card] of cards.entries()) {
       const key = cardKey(card)
@@ -6242,7 +6344,7 @@ export class KnowledgeRuntime {
       const entries = related.get(key) ?? []
       const previousEntries = relatedEntriesOf(card.metadata)
       const contentChanged = nextCard.content !== card.content
-      const relatedChanged = JSON.stringify(previousEntries) !== JSON.stringify(entries)
+      const relatedChanged = JSON.stringify(previousEntries) !== JSON.stringify(entries) || JSON.stringify(card.metadata.wiki_coordinate_labels) !== JSON.stringify(nextCard.metadata.wiki_coordinate_labels) || JSON.stringify(card.metadata.wiki_links) !== JSON.stringify(nextCard.metadata.wiki_links) || JSON.stringify(card.metadata.wiki_inline_targets) !== JSON.stringify(nextCard.metadata.wiki_inline_targets) || JSON.stringify(card.metadata.wiki_object_refs) !== JSON.stringify(nextCard.metadata.wiki_object_refs)
       if (!contentChanged && !relatedChanged) continue
       /**
        * 没有来源的卡片写不进去（`writeCard` 要求 `source_refs` 非空），而这是**唯一**
@@ -6263,7 +6365,7 @@ export class KnowledgeRuntime {
         status: card.status,
         ...(card.owner ? { owner: card.owner } : {}),
         ...(card.provenance ? { provenance: card.provenance } : {}),
-        metadata: { ...card.metadata, [RELATED_METADATA_KEY]: entries },
+        metadata: { ...nextCard.metadata, [RELATED_METADATA_KEY]: entries },
         origin: 'compile',
       })
       if (written.ok === false) {
@@ -6387,13 +6489,9 @@ export class KnowledgeRuntime {
     }
   }
 
-  /** 一条上下文条目「值多少字符」：命中条目算它那些 note 的正文，扩展条目算标题 + 摘要（+ 正文）。 */
-  private contextCost(item: ContextItem, full: boolean): number {
-    const card = item.wiki
-    if (card === null) return 0
-    const shallow = card.title.length + (card.summary?.length ?? 0)
-    const knowledge = (item.knowledge ?? []).reduce((sum, row) => sum + row.text.length + row.state.length + 8, 0)
-    return knowledge + shallow + card.content.length
+  /** 与 Agent 实际收到的上下文条目使用同一序列化形状，包含完整 Wiki、依据和引用。 */
+  private contextCost(item: ContextItem): number {
+    return JSON.stringify(agentContextItem(item)).length
   }
 
   /** 溢出目录：**系统临时目录**，不随知识库走（0050 的取舍，见 issue）。 */
@@ -6421,17 +6519,14 @@ export class KnowledgeRuntime {
     const { items, maxChars, recallId } = input
     const hitCards = items.filter(item => item.reason === 'hit').length
     const expandedCards = items.length - hitCards
-    const totalChars = items.reduce((sum, item) => sum + this.contextCost(item, true), 0)
+    const totalChars = items.reduce((sum, item) => sum + this.contextCost(item), 0)
     if (!Number.isFinite(maxChars) || maxChars <= 0) {
       return { items, report: { maxChars: 0, usedChars: totalChars, omittedCards: 0, omittedChars: 0, hitCards, expandedCards } }
     }
     const keptItems: ContextItem[] = []
     let used = 0
     for (const item of items) {
-      const full = this.contextCost(item, true)
-      const shallow = this.contextCost(item, false)
-      // 命中条目按整条算（它的正文就是证据）；扩展条目可以先按「浅」那一档进。
-      const cost = item.reason === 'hit' ? full : shallow
+      const cost = this.contextCost(item)
       if (used + cost > maxChars) continue
       used += cost
       keptItems.push(item)
@@ -6442,7 +6537,7 @@ export class KnowledgeRuntime {
       maxChars,
       usedChars: used,
       omittedCards: omitted.length,
-      omittedChars: omitted.reduce((sum, item) => sum + this.contextCost(item, true), 0),
+      omittedChars: omitted.reduce((sum, item) => sum + this.contextCost(item), 0),
       hitCards: keptItems.filter(item => item.reason === 'hit').length,
       expandedCards: keptItems.filter(item => item.reason === 'expansion').length,
     }
@@ -6554,13 +6649,17 @@ export class KnowledgeRuntime {
    * 而不是报错：这一层是**增强**，它坏了不该让编译失败。
    */
   private async projectedRelated(cards: KnowledgeCard[]): Promise<Array<{ fromKey: string; toKey: string }>> {
+    const links = cards.flatMap(card => scanWikiLinks(card.content).flatMap(link => {
+      const candidates = wikiLinkCandidates(cards.filter(target => target.status !== 'deprecated'), link.target)
+      return candidates.length === 1 && candidates[0]!.entityId !== card.entityId ? [{ fromKey: cardKey(card), toKey: cardKey(candidates[0]!) }] : []
+    }))
     const knowledge = await this.knowledgeStore()
-    if (knowledge === null) return []
+    if (knowledge === null) return links
     const db = await this.storeHandle()
-    if (db === null) return []
+    if (db === null) return links
     let placements: Map<string, CardKnowledgeRow[]>
-    try { placements = db.placements() } catch { return [] }
-    if (placements.size === 0) return []
+    try { placements = db.placements() } catch { return links }
+    if (placements.size === 0) return links
     /**
      * 单轴卡：坐标里恰好只有一个分量非空。
      *
@@ -6585,11 +6684,11 @@ export class KnowledgeRuntime {
       bucket.push(key)
       byAxis.set(axis, bucket)
     }
-    if (byAxis.size === 0) return []
+    if (byAxis.size === 0) return links
     const ids = [...new Set([...placements.values()].flat().map(row => row.knowledgeId))]
-    if (ids.length === 0) return []
+    if (ids.length === 0) return links
     let axes: Map<string, { objectId: string; actionId: string; sceneId: string }>
-    try { axes = await knowledge.axesOf(ids) } catch { return [] }
+    try { axes = await knowledge.axesOf(ids) } catch { return links }
     const pairs = new Map<string, { fromKey: string; toKey: string }>()
     for (const [cardId, rows] of placements) {
       const fromKeys = keyById.get(cardId) ?? []
@@ -6609,7 +6708,7 @@ export class KnowledgeRuntime {
         }
       }
     }
-    return [...pairs.values()]
+    return [...pairs.values(), ...links]
   }
 
   /**
@@ -8127,7 +8226,7 @@ export class KnowledgeRuntime {
         : card.metadata.wiki_kind
           ? events.filter(event => {
             const c = event.coordinateIds
-            return c.objectId === card.coordinate!.objectId && (card.metadata.wiki_kind === 'fact' || c.actionId === card.coordinate!.actionId)
+            return coordinateKeyOf(c) === coordinateKeyOf(card.coordinate!)
           }).map(event => event.id).sort()
           : (eventsByCoordinate.get(coordinateKeyOf(card.coordinate)) ?? []).sort()
       const oldRaw = card.metadata.event_refs
@@ -8372,9 +8471,15 @@ export class KnowledgeRuntime {
         derive: (sourceIds, context, force, output, checkpoint) => this.deriveProcedures(sourceIds, context, force, output, checkpoint),
         groups: async context => {
           const snapshot = await this.materializationSnapshot(store, context)
-          return { groups: snapshot.groups, blocked: snapshot.blocked, blockedAmbiguous: snapshot.blockedAmbiguous, blockedAwaitingNormalize: snapshot.blockedAwaitingNormalize, snapshot }
+          return { groups: snapshot.groups, blocked: snapshot.blocked, blockedAmbiguous: snapshot.blockedAmbiguous, blockedAwaitingNormalize: snapshot.blockedAwaitingNormalize, blockedItems: snapshot.blockedItems, snapshot }
         },
         materialize: (group, context, output, snapshot) => this.materializePipelineGroup(store, group, context, output, snapshot as MaterializationSnapshot),
+        link: async () => {
+          const warnings: string[] = []
+          const finalized = await this.runFinalizeStage(await this.loadCards(), Object.values(await this.readExtractedRelations()).flat(), warnings)
+          if (warnings.length) throw new Error(warnings.join('；'))
+          return `已更新 Wiki 双链与导航：${finalized.rewritten} 份`
+        },
         build: async (taskId, checkpoint) => {
           let result: Envelope<RebuildReport>
           try { result = await this.compileOnce(taskId, 'all', undefined, { extract: false, checkpoint }) }
@@ -8568,7 +8673,7 @@ export class KnowledgeRuntime {
       const cards = await this.loadCards()
       const relations = Object.values(await this.readExtractedRelations()).flat()
       for (const [key, entries] of planRelated(cards, relations, await this.projectedRelated(cards))) {
-        if (entries.length > 0) plan.set(key, entries.map(entry => ({ title: entry.title, entityType: entry.entityType, reason: entry.reason })))
+        if (entries.length > 0) plan.set(key, entries.map(entry => ({ title: entry.title, entityType: entry.entityType, entityId: entry.entityId, reason: entry.reason })))
       }
     } catch { /* 增强项：算不出来就不给清单 */ }
     return plan
@@ -8591,17 +8696,18 @@ export class KnowledgeRuntime {
       const evidence = [...item.sources, ...item.timeline.flatMap(step => step.sources)]
       const sourceVersions = new Map(evidence.map(e => [e.documentId, db.source(e.documentId)?.version]))
       const fingerprint = contentHashOf(JSON.stringify({ contract: DERIVE_CONTRACT_VERSION, item: { ...item, updatedAt: undefined }, sourceVersions: [...sourceVersions], model: { provider: context.model.provider, model: context.model.model, reasoningEffort: context.model.reasoningEffort } }))
-      const receipt = db.raw('SELECT fingerprint, knowledge_ids FROM pipeline_derivations WHERE case_id=?').get(item.id) as { fingerprint: string; knowledge_ids: string } | undefined
-      if (!force && receipt?.fingerprint === fingerprint) { done++; reused++; continue }
+      const receipt = db.raw('SELECT fingerprint, response, knowledge_ids FROM pipeline_derivations WHERE case_id=?').get(item.id) as { fingerprint: string; response: string; knowledge_ids: string } | undefined
+      // Replay validated cached output through ingest too: normalization may have withdrawn its support.
+      const cachedResponse = !force && receipt?.fingerprint === fingerprint ? receipt.response : undefined
       const auditId = randomUUID()
       const request = { system: buildDeriveSystem(), prompt: JSON.stringify({ case: { ...item, version: caseVersion }, sourceEvidence: evidence, sourceVersions: [...sourceVersions] }) }
-      let response = '{"procedures":[],"skipped_cases":[]}'
+      let response = cachedResponse ?? '{"procedures":[],"skipped_cases":[]}'
       db.raw('INSERT INTO pipeline_derivation_runs VALUES (?,?,?,?,?,?,?,?,?)').run(auditId, item.id, caseVersion, fingerprint, JSON.stringify(request), '', 'running', null, new Date().toISOString())
       try {
-        if (item.timeline.some(step => step.type === 'check' || step.type === 'action')) {
+        if (cachedResponse === undefined && item.timeline.some(step => step.type === 'check' || step.type === 'action')) {
           if (!context.model.call) throw new Error(`提炼模型不可用：${context.model.why ?? '请选择模型'}`)
           response = await context.model.call({ ...request, sessionId: `knowledge:${this.baseId || 'default'}:derive`, onDelta: output })
-        } else output(`Case ${item.id} 没有已执行过程，不反推 Procedure。\n`)
+        } else if (cachedResponse === undefined) output(`Case ${item.id} 没有已执行过程，不反推 Procedure。\n`)
         const parsed = JSON.parse(response.trim().replace(/^```(?:json)?\s*/, '').replace(/\s*```$/, '')) as { procedures?: Array<Record<string, unknown>> }
         if (!Array.isArray(parsed.procedures)) throw new Error('Case 提炼返回缺少 procedures 数组')
         if (this.closed || db.event(item.id)?.version !== caseVersion || [...sourceVersions].some(([id, version]) => db.source(id)?.version !== version)) throw new Error('Case 或来源在提炼期间变化，请重试')
@@ -8636,6 +8742,7 @@ export class KnowledgeRuntime {
         db.raw("UPDATE pipeline_derivation_runs SET response=?,state='succeeded' WHERE id=?").run(response, auditId)
         output(`Case ${item.id}：保存 ${ids.length} 条候选 Procedure。\n`)
         done++
+        if (cachedResponse !== undefined) reused++
       } catch (cause) {
         db.raw("UPDATE pipeline_derivation_runs SET response=?,state='failed',error=? WHERE id=?").run(response, cause instanceof Error ? cause.message : String(cause), auditId)
         throw cause
@@ -8651,7 +8758,7 @@ export class KnowledgeRuntime {
    * 两处必须用同一个表达式，否则「什么算变化」就有两套说法。
    */
   private pipelineGroupFingerprint(knowledge: Knowledge[], context: PipelineContext): string {
-    return contentHashOf(JSON.stringify({ knowledge: knowledge.map(row => ({ id: row.id, kind: row.kind ?? 'fact', data: row.data, text: row.text, status: row.status, sources: row.sources.filter(source => !source.withdrawn) })).sort((a, b) => a.id.localeCompare(b.id)), profile: context.profile, organize: context.organize, model: context.organize ? { provider: context.model.provider, model: context.model.model, reasoningEffort: context.model.reasoningEffort } : undefined }))
+    return contentHashOf(JSON.stringify({ contract: 'coordinate-wiki-v2', organizeVersion: context.organize ? ORGANIZE_VERSION : undefined, knowledge: knowledge.map(row => ({ id: row.id, kind: row.kind ?? 'fact', data: row.data, text: row.text, status: row.status, sources: row.sources.filter(source => !source.withdrawn) })).sort((a, b) => a.id.localeCompare(b.id)), profile: context.profile, organize: context.organize, model: context.organize ? { provider: context.model.provider, model: context.model.model, reasoningEffort: context.model.reasoningEffort } : undefined }))
   }
 
   /**
@@ -8688,12 +8795,12 @@ export class KnowledgeRuntime {
     ].filter(Boolean).map(text => `- ${text}[^${row.id}]`).join('\n')
   }
 
-  private async freshGroupFingerprint(coordinate: CardCoordinate, context: PipelineContext, db: KnowledgeDb): Promise<string> {
+  private async freshGroupFingerprint(coordinate: CardCoordinate, wikiKind: WikiKind, context: PipelineContext, db: KnowledgeDb): Promise<string> {
     const store = await this.knowledgeStore()
     if (!store) return ''
     const raw: Knowledge[] = []
     for (let offset = 0;; offset += 500) {
-      const page = await store.list({ objectId: coordinate.objectId, kind: coordinate.actionId ? 'procedure' : 'fact', ...(coordinate.actionId ? { actionId: coordinate.actionId } : {}), excludeWithdrawn: true, limit: 500, offset })
+      const page = await store.list({ objectId: coordinate.objectId, kind: wikiKind === 'way' ? 'procedure' : 'fact', actionId: coordinate.actionId, sceneId: coordinate.sceneId, excludeWithdrawn: true, limit: 500, offset })
       raw.push(...page.knowledge)
       if (offset + page.knowledge.length >= page.total) break
     }
@@ -8705,7 +8812,7 @@ export class KnowledgeRuntime {
       if (source) bodies.set(id, { version: source.version, content: source.record.content })
     }
     const rows = raw
-      .filter(row => row.status !== 'deprecated' && (row.kind !== 'procedure' || (row.data?.procedure?.completeness === 'complete' && row.data.procedure.method.length > 0 && row.status !== 'disputed' && row.data.procedure.caseRefs.every(ref => db.event(ref.id)?.version === ref.version) && !row.sources.some(source => source.toVersion !== undefined && db.source(source.documentId)?.version !== source.toVersion))))
+      .filter(row => row.status !== 'deprecated' && (row.kind !== 'procedure' || (row.data?.procedure?.completeness === 'complete' && row.data.procedure.method.length > 0 && row.status !== 'disputed' && row.data.procedure.caseRefs.every(ref => db.event(ref.id)?.version === ref.version) && !row.sources.some(source => !source.withdrawn && source.toVersion !== undefined && db.source(source.documentId)?.version !== source.toVersion))))
       .map(row => assessKnowledgeEvidence(row, db, bodies))
       .map(row => ({ ...row, sources: row.sources.filter(source => !source.withdrawn && source.evidenceStatus !== 'missing') }))
       .filter(row => row.sources.length > 0)
@@ -8726,12 +8833,13 @@ export class KnowledgeRuntime {
      */
     const plans = options.plans !== false
     const unresolved = store.unresolvedKnowledge()
-    const grouped = new Map<string, { coordinate: CardCoordinate; knowledge: Knowledge[] }>()
+    const grouped = new Map<string, { coordinate: CardCoordinate; wikiKind: WikiKind; knowledge: Knowledge[] }>()
     let blockedAmbiguous = 0
     let blockedAwaitingNormalize = 0
-    const groupFor = (coordinate: CardCoordinate) => {
-      const key = coordinateKeyOf(coordinate)
-      if (!grouped.has(key)) grouped.set(key, { coordinate, knowledge: [] })
+    const blockedItems: MaterializationSnapshot['blockedItems'] = []
+    const groupFor = (coordinate: CardCoordinate, wikiKind: WikiKind) => {
+      const key = wikiGroupKey(wikiKind, coordinate)
+      if (!grouped.has(key)) grouped.set(key, { coordinate, wikiKind, knowledge: [] })
       return grouped.get(key)!
     }
     const caseStore = await this.storeHandle()
@@ -8739,24 +8847,29 @@ export class KnowledgeRuntime {
       if (row.kind === 'case') continue
       const coordinate = wikiProjection(row.kind ?? 'fact', row)
       const method = row.data?.procedure
-      if (!coordinate || (row.kind === 'procedure' && (!method || method.completeness !== 'complete' || !method.method.length || row.status === 'disputed' || method.caseRefs.some(ref => caseStore?.event(ref.id)?.version !== ref.version) || row.sources.some(source => source.toVersion !== undefined && caseStore?.source(source.documentId)?.version !== source.toVersion)))) { blockedAmbiguous += 1; continue }
-      groupFor(coordinate).knowledge.push(row)
+      if (!coordinate || (row.kind === 'procedure' && (!method || method.completeness !== 'complete' || !method.method.length || row.status === 'disputed' || method.caseRefs.some(ref => caseStore?.event(ref.id)?.version !== ref.version) || row.sources.some(source => source.toVersion !== undefined && caseStore?.source(source.documentId)?.version !== source.toVersion)))) {
+        blockedAmbiguous += 1
+        blockedItems.push({ knowledgeId: row.id, sourceIds: [...new Set(row.sources.map(source => source.documentId).filter(Boolean))], ...(coordinate ? { groupKey: wikiGroupKey(row.kind === 'procedure' ? 'way' : 'fact', coordinate) } : {}) })
+        continue
+      }
+      groupFor(coordinate, row.kind === 'procedure' ? 'way' : 'fact').knowledge.push(row)
     }
     const db = await this.storeHandle()
     const events = new Map<string, EventEntity[]>()
     for (const event of db?.events() ?? []) {
       const coordinate = event.coordinateIds
       if (!coordinate.objectId) continue
-      for (const projection of [wikiProjection('fact', coordinate), wikiProjection('procedure', coordinate)]) {
-        if (!projection) continue
-        const key = coordinateKeyOf(projection)
+      for (const kind of ['fact', 'way'] as const) {
+        const key = wikiGroupKey(kind, coordinate)
         const bucket = events.get(key) ?? []
         bucket.push(event)
         events.set(key, bucket)
       }
     }
     const cards = await this.loadCards()
-    const byCoordinate = new Map(cards.filter(card => card.coordinate).map(card => [coordinateKeyOf(card.coordinate!), card]))
+    const groupKeyOf = (card: KnowledgeCard): string => card.coordinate && (card.metadata.wiki_kind === 'fact' || card.metadata.wiki_kind === 'way')
+      ? wikiGroupKey(card.metadata.wiki_kind, card.coordinate) : card.coordinate ? coordinateKeyOf(card.coordinate) : ''
+    const byCoordinate = new Map(cards.filter(card => card.coordinate).map(card => [groupKeyOf(card), card]))
     const groups: MaterializationGroup[] = []
     const knowledge = new Map<string, Knowledge[]>()
     for (const [key, value] of grouped) {
@@ -8770,11 +8883,13 @@ export class KnowledgeRuntime {
       const needsNormalization = this.needsNormalizationForGroup(store, value.knowledge, unresolved, db)
       if (needsNormalization) blockedAwaitingNormalize += value.knowledge.length
       knowledge.set(key, value.knowledge)
-      groups.push({ key, wikiKind: value.coordinate.actionId ? 'way' : 'fact', title: existing?.title ?? `${names.object}${names.action ? ` · ${names.action}` : ''} · ${value.coordinate.actionId ? 'Wiki Way' : 'Wiki Fact'}`, coordinate: value.coordinate, knowledgeCount: value.knowledge.length, eventCount: events.get(key)?.length ?? 0, sourceIds: contributingSources, ...(existing ? { cardId: existing.entityId } : {}), state: needsNormalization ? 'blocked' : current ? 'current' : existing ? 'changed' : 'new', ...(needsNormalization ? { reason: '分组中的来源已变化、新抽取待归一或坐标有歧义，请先完成归一' } : {}), fingerprint })
+      groups.push({ key, wikiKind: value.wikiKind, title: existing?.title ?? `${names.object}${names.action ? ` · ${names.action}` : ''}${names.scene ? ` · ${names.scene}` : ''} · ${value.wikiKind === 'way' ? 'Wiki Way' : 'Wiki Fact'}`, coordinate: value.coordinate, knowledgeCount: value.knowledge.length, eventCount: events.get(key)?.length ?? 0, sourceIds: contributingSources, ...(existing ? { cardId: existing.entityId } : {}), state: needsNormalization ? 'blocked' : current ? 'current' : existing ? 'changed' : 'new', ...(needsNormalization ? { reason: '分组中的来源已变化、新抽取待归一或坐标有歧义，请先完成归一' } : {}), fingerprint })
     }
     for (const card of cards) {
-      if (!card.coordinate || grouped.has(coordinateKeyOf(card.coordinate)) || !store.materialization(coordinateKeyOf(card.coordinate)) || card.status === 'deprecated') continue
-      groups.push({ key: coordinateKeyOf(card.coordinate), title: card.title, coordinate: card.coordinate, knowledgeCount: 0, eventCount: 0, sourceIds: card.sourceRefs, cardId: card.entityId, state: card.sourceRefs.some(id => unresolved.sources.has(id)) ? 'blocked' : 'withdrawn', ...(card.sourceRefs.some(id => unresolved.sources.has(id)) ? { reason: '来源中的坐标仍有歧义，请先完成归一' } : {}), fingerprint: 'withdrawn' })
+      const key = groupKeyOf(card)
+      const legacyReceipt = card.coordinate ? store.materialization(coordinateKeyOf(card.coordinate)) : undefined
+      if (!card.coordinate || grouped.has(key) || (!store.materialization(key) && !legacyReceipt && card.metadata.pipeline_materialization !== true) || card.status === 'deprecated') continue
+      groups.push({ key, wikiKind: card.metadata.wiki_kind === 'way' ? 'way' : 'fact', title: card.title, coordinate: card.coordinate, knowledgeCount: 0, eventCount: 0, sourceIds: card.sourceRefs, cardId: card.entityId, state: card.sourceRefs.some(id => unresolved.sources.has(id)) ? 'blocked' : 'withdrawn', ...(card.sourceRefs.some(id => unresolved.sources.has(id)) ? { reason: '来源中的坐标仍有歧义，请先完成归一' } : {}), fingerprint: 'withdrawn' })
     }
     const sources = plans ? (await this.loadSources()).map(source => ({ sourceId: source.sourceId, content: source.content })) : []
     const imagePlan = plans
@@ -8805,7 +8920,7 @@ export class KnowledgeRuntime {
     return {
       groups: groups.sort((a, b) => a.title.localeCompare(b.title)),
       blocked: blockedAmbiguous + blockedAwaitingNormalize,
-      blockedAmbiguous, blockedAwaitingNormalize,
+      blockedAmbiguous, blockedAwaitingNormalize, blockedItems,
       knowledge, events, sources, images: imagePlan.byCard, related: relatedByKey,
     }
   }
@@ -8836,7 +8951,7 @@ export class KnowledgeRuntime {
       const statusBeforeDeprecate = (await this.readCard(existing.entityId))?.status
       if (statusBeforeDeprecate === undefined) throw new Error('卡片在处理期间已被删除，本次物化未提交，请刷新后重试')
       if (statusBeforeDeprecate !== existing.status) throw new Error(`卡片在处理期间被人工改动（状态 ${existing.status} → ${statusBeforeDeprecate}），本次物化未提交，请重试`)
-      const written = await this.writeCard({ ...existing, status: 'deprecated', origin: 'compile' })
+      const written = await this.writeCard({ ...existing, metadata: { ...existing.metadata, wiki_deprecation_origin: existing.status === 'deprecated' && existing.metadata.wiki_deprecation_origin !== 'withdrawal' ? 'manual' : 'withdrawal' }, status: 'deprecated', origin: 'compile' })
       if (!written.ok) throw new Error(written.error.message)
       store.materialized(group.key, group.fingerprint, existing.entityId)
       // 停用也是一次物化：卡片从可召回里退出，这一步发生过，就该留一条轨迹。
@@ -8855,7 +8970,7 @@ export class KnowledgeRuntime {
     let content = knowledge.map(row => `## ${row.data?.procedure?.question ?? row.text.split('\n')[0]!.slice(0, 60)}\n\n${this.organizeKnowledgeText(row)}[^${row.id}]${boundaries.get(row.id) ? `\n\n### 适用条件与边界\n\n${boundaries.get(row.id)}` : ''}`).join('\n\n')
     let summary = knowledge[0]?.text ?? ''
     let placements: CardKnowledgeRow[] = knowledge.map((row, index) => ({ knowledgeId: row.id, section: row.data?.procedure?.question ?? row.text.split('\n')[0]!.slice(0, 60), ordinal: index + 1, origin: 'compiler' }))
-    let metadata: Record<string, unknown> = { ...(existing?.metadata ?? {}), pipeline_materialization: true, wiki_kind: group.wikiKind ?? (group.coordinate.actionId ? 'way' : 'fact') }
+    let metadata: Record<string, unknown> = { ...(existing?.metadata ?? {}), pipeline_materialization: true, wiki_kind: group.wikiKind ?? 'fact', wiki_coordinate_version: 2, knowledge_versions: Object.fromEntries(knowledge.map(row => [row.id, row.version])) }
     const entityId = existing?.entityId ?? `coord-${hash(group.key)}`
     const images = snapshot.images.get(group.key) ?? []
     const related = existing && snapshot.related.has(group.key) ? { related: snapshot.related.get(group.key)! } : {}
@@ -8880,7 +8995,7 @@ export class KnowledgeRuntime {
      * 「只有知识行变了」；这条按坐标重算整组指纹，能把那种变化也挡住。
      */
     if (this.needsNormalizationForGroup(store, knowledge, store.unresolvedKnowledge(), db)) throw new Error('卡片组织期间事实发生变化，结果未提交，请重试')
-    if (await this.freshGroupFingerprint(group.coordinate, context, db) !== group.fingerprint) throw new Error('卡片分组在处理期间事实发生了变化，结果未提交，请重试')
+    if (await this.freshGroupFingerprint(group.coordinate, group.wikiKind ?? 'fact', context, db) !== group.fingerprint) throw new Error('卡片分组在处理期间事实发生了变化，结果未提交，请重试')
     if (this.closed) throw new Error('知识库已关闭，本次物化未提交')
     /**
      * 状态必须**在写之前**重读，并且和读到的旧值比对。
@@ -8896,7 +9011,8 @@ export class KnowledgeRuntime {
     if (statusAtWrite !== existing?.status) {
       throw new Error(`卡片在处理期间被人工改动（状态 ${existing?.status ?? '未知'} → ${statusAtWrite ?? '未知'}），本次物化未提交，请重试`)
     }
-    const written = await this.writeCard({ entityType, entityId, title, content, summary, sourceRefs: group.sourceIds, status: statusAtWrite === 'deprecated' ? 'unreviewed' : statusAtWrite ?? 'unreviewed', coordinate: group.coordinate, placements, metadata, origin: 'compile' })
+    const nextStatus = statusAtWrite === 'deprecated' && existing?.metadata.wiki_deprecation_origin === 'withdrawal' ? 'unreviewed' : statusAtWrite ?? 'unreviewed'
+    const written = await this.writeCard({ entityType, entityId, title, content, summary, sourceRefs: group.sourceIds, status: nextStatus, coordinate: group.coordinate, placements, metadata, origin: 'compile' })
     if (!written.ok) throw new Error(written.error.message)
     db.setCardEvents(entityId, eventIds)
     store.materialized(group.key, group.fingerprint, entityId)
@@ -8915,7 +9031,7 @@ export class KnowledgeRuntime {
       card: {
         id: entityId,
         title,
-        status: statusAtWrite === 'deprecated' ? 'unreviewed' : statusAtWrite ?? 'unreviewed',
+        status: nextStatus,
         characters: content.length,
         events: eventIds.length,
         images: images.length,
@@ -8939,7 +9055,9 @@ export class KnowledgeRuntime {
     const db = await this.derivedHandle()
     const manifest = db?.artifact('build-manifest.json')
     const hashes = manifest ? (JSON.parse(manifest) as { cardHashes?: Record<string, string> }).cardHashes ?? {} : {}
-    const cards = await this.loadCards()
+    const allCards = await this.loadCards()
+    const unavailable = await this.wikiUnavailability(allCards)
+    const cards = allCards.filter(card => !card.metadata.wiki_kind || !unavailable.has(cardKey(card)))
     const indexPending = cards.some(card => hashes[`${card.entityType}:${card.entityId}`] !== this.cardHashOf(card)) || Object.keys(hashes).length !== cards.length
     return { sources: rows, groups, blocked, pendingNew: groups.filter(group => group.state === 'new').length, pendingUpdated: groups.filter(group => group.state === 'changed').length, pendingWithdrawn: groups.filter(group => group.state === 'withdrawn').length, indexPending }
   }
@@ -9165,6 +9283,8 @@ export class KnowledgeRuntime {
           }
         this.publication.artifacts.set(COMPILE_SNAPSHOT, JSON.stringify(snapshot))
         await this.checkpointCompileTask(runId)
+        const changedWiki = await this.wikiUnavailability(snapshot.cards, new Map(snapshot.placements))
+        if (snapshot.cards.some(card => card.metadata.wiki_kind && changedWiki.has(cardKey(card)))) throw new Error('WIKI_CHANGED_DURING_BUILD: Wiki 的支撑知识在构建期间变化，请重新组织并构建索引')
         if (JSON.stringify({ config: this.config, fingerprint: this.embeddingFingerprint() }) !== configAtStart) throw new Error('COMPILE_CONFIG_CHANGED: 编译期间设置已变化，请重新编译')
         await options.checkpoint?.()
         db.publish(this.publication)
@@ -9173,6 +9293,8 @@ export class KnowledgeRuntime {
       return result
     } finally {
       this.publication = undefined
+      // Compilation filters unavailable projections; the browsing cache still represents all saved Wiki.
+      this.cards = await this.loadCards()
     }
   }
 
@@ -9436,6 +9558,9 @@ export class KnowledgeRuntime {
     await this.checkpointCompileTask(runId)
     // 相关 metadata 或旧正文清理刚落盘：stage 2 必须看到最新卡片。
     if (finalize.rewritten > 0) this.cards = await this.loadCards()
+    const unavailableWiki = await this.wikiUnavailability(this.cards)
+    for (const card of this.cards) if (card.metadata.wiki_kind && unavailableWiki.has(cardKey(card))) warnings.push(`Wiki「${card.title}」未进入索引：${unavailableWiki.get(cardKey(card))}`)
+    this.cards = this.cards.filter(card => !card.metadata.wiki_kind || !unavailableWiki.has(cardKey(card)))
     /**
      * 索引页也是这次编译的产物，所以它变了也算「语料变了」。
      *
@@ -9848,12 +9973,11 @@ export class KnowledgeRuntime {
   }
 
   /**
-   * Coordinate 路：先解析 Query 中出现的 Object / Action / Scene，再把命中的卡片拆成
+   * Coordinate 路：解析 Query 中出现的 Object / Action / Scene，再把命中的卡片拆成
    * Section 候选。它和 FTS / Vector 使用同一个 `unitId` 粒度，后面才能统一 RRF 与重排。
    *
    * 这里不让模型自由生成实体名：注册表负责 canonical / alias 命中，只有真实存在的
-   * 坐标 id 才能进入候选。意图目前使用轻量规则分类，结果会随 queryAnalysis 一起返回，
-   * 后续接入模型消歧时不需要改变召回合同。
+   * 坐标 id 才能进入候选。未解析的原文继续交给关键词、向量路线与统一重排。
    */
   private async coordinateRoute(
     query: string,
@@ -10443,18 +10567,8 @@ export class KnowledgeRuntime {
     for (const key of liveKeys) {
       if (snapshotCardByKey.get(key)?.sourceRefs.some(ref => !liveSourceIds.has(ref))) liveKeys.delete(key)
     }
-    // A method becomes unavailable immediately when its supporting Case or structured content changes.
-    // Do not wait for a later rebuild to stop serving the old instructions.
-    const unsafeProcedures = new Set(snapshot.knowledge.filter(row => {
-      if (row.kind !== 'procedure') return false
-      const current = truthAtRead?.raw('SELECT status,head_version FROM knowledge WHERE id=?').get(row.id) as { status: string; head_version: number } | undefined
-      return !current || current.status === 'deprecated' || current.status === 'disputed' || current.head_version !== row.version
-        || !row.data?.procedure || row.data.procedure.completeness !== 'complete'
-        || row.data.procedure.caseRefs.some(ref => truthAtRead?.event(ref.id)?.version !== ref.version)
-        || row.sources.some(source => source.toVersion !== undefined && truthAtRead?.source(source.documentId)?.version !== source.toVersion)
-    }).map(row => row.id))
-    const unsafeCardIds = new Set(snapshot.placements.filter(([, placements]) => placements.some(p => unsafeProcedures.has(p.knowledgeId))).map(([id]) => id))
-    for (const key of liveKeys) if (unsafeCardIds.has(snapshotCardByKey.get(key)?.entityId ?? '')) liveKeys.delete(key)
+    const unavailableWiki = await this.wikiUnavailability(snapshot.cards, new Map(snapshot.placements))
+    for (const key of unavailableWiki.keys()) liveKeys.delete(key)
     let publishedGraph = visibleGraph(snapshot.graph, truthAtRead ? liveGraphKeys(truthAtRead) : new Set())
     const currentByKey = new Map(liveCards.map(card => [cardKey(card), card]))
     let cards: KnowledgeCard[] = snapshot.cards.filter(card => liveKeys.has(cardKey(card))).map(card => {
@@ -10575,9 +10689,6 @@ export class KnowledgeRuntime {
     } else {
       const rerankQuery = [
         query,
-        ...(queryAnalysis.intent.id !== 'unknown' && queryAnalysis.intent.confidence >= 0.7
-          ? [`意图：${queryAnalysis.intent.id}`]
-          : []),
         ...(['object', 'action', 'scene'] as const).flatMap(kind => {
           const values = queryAnalysis.axes[kind].map(item => item.name).slice(0, 3)
           return values.length > 0 ? [`${kind}：${values.join('、')}`] : []
@@ -10720,8 +10831,7 @@ export class KnowledgeRuntime {
     /**
      * 上下文预算（0050）：装箱 + 溢出。
      *
-     * 让位顺序写死在 `packContext` 里：先保证命中 note 的正文完整（它是证据），
-     * 再给扩展卡片的标题 + 摘要 + 关系，最后才给扩展卡片的正文。
+     * 让位顺序写死在 `packContext` 里：优先交付命中的完整 Wiki，再交付扩展 Wiki。
      */
     /**
      * 每次调用可以覆盖预算（0050）：指路行里就写着「读不到就调大预算重新召回」，
@@ -10729,6 +10839,14 @@ export class KnowledgeRuntime {
      */
     const maxChars = options.contextMaxChars ?? this.config.contextMaxChars
     const packed = await this.packContext({ items, maxChars, recallId })
+    const deliveredKeys = new Set(packed.items.flatMap(item => item.wiki ? [cardKey(item.wiki)] : []))
+    // Diagnostic HTTP requests may inspect unbudgeted candidate text. Normal delivery cannot leak it.
+    const deliveredHits = options.detail ? hits : hits.map(hit => {
+      if (deliveredKeys.has(wikiKey(hit))) return hit
+      const { evidence: _evidence, knowledge: _knowledge, ...reference } = hit
+      return { ...reference, content: '' }
+    })
+    const deliveredWiki = options.detail ? wiki : wiki.filter(card => deliveredKeys.has(cardKey(card)))
     /** 哪些扩展卡片真的进了上下文（被预算挡住的也如实报出来）。 */
     expansion.included = packed.items
       .filter(item => item.reason === 'expansion' && item.wiki !== null)
@@ -10789,7 +10907,7 @@ export class KnowledgeRuntime {
     }
 
     const data: RecallResult = {
-      hits, context: packed.items, wiki, graph, backend, routes: ranRoutes, recallMode, rerank, recallTopK, candidatePool, fusedCount, contextTopN,
+      hits: deliveredHits, context: packed.items, wiki: deliveredWiki, graph, backend, routes: ranRoutes, recallMode, rerank, recallTopK, candidatePool, fusedCount, contextTopN,
       queryAnalysis,
       insufficientEvidence, diagnostics, recallId, timings,
       expansion, budget: packed.report,