@p-dsh-market/conversation-knowledge-map 0.1.17 → 0.1.19

package/README.md

@@ -13,7 +13,7 @@ DSH 的“知识视图”插件，把同一工作路径下用户明确选择的
 
 摘要阶段按对话并行处理，并发上限固定为 3；每个对话按约 5000 字、优先在完整段落边界分段，只有单段本身超长时才按句末或硬边界拆分。同一对话的分段保持顺序处理。思维导图使用合并后的会话摘要；知识图谱直接使用保留来源的分段摘要，避免长对话在二次压缩后丢失实体。知识图谱按证据分段多次生成，最多 2 批并行；单批限制在 10–18 个实体、最多 24 条关系，若达到输出 Token 上限则只降低并重试当前批次。所有成功批次由 Host 按实体类型与名称、关系起点/终点/类型确定性去重并合并来源，最终结果再根据已读取文本量和有效分段数裁剪为 30–100 个实体、最多 200 条关系。单个批次连续失败只跳过该批，不会推翻其他成功批次。结构化输出失败时会完全重置并最多重试 3 次；单个对话摘要连续失败后只跳过该对话，不阻断其他对话和最终报告。“同时生成”模式下，一个最终视图失败也不会阻断另一个视图保存。进度区域和最终知识视图都会按时间线显示读取、摘要、具体失败原因、重试、跳过、合并、生成及保存过程；知识图谱时间线还会显示批次数、模型返回数量和合并去重后的保留数量。模型可以保留 thinking，但结果提取只读取最终文本并过滤 reasoning 内容；摘要和每次图谱调用分别预留 12000 与 24000 个输出 Token。最终模型若返回未选择的 Session 引用，会过滤该引用；严格模式下无有效来源的内容项会被跳过，最终页面列出实际总结的对话、失败对话和过滤数量。
 
-生成过程时间线支持折叠和展开：进行中的任务默认展开，已完成结果中的历史时间线默认折叠。思维导图使用递归树形布局并绘制父子连接线。知识图谱按关联度使用中心节点与内外双环布局，节点卡片内显示类型和最多两行名称，关系以带方向箭头的弱化曲线呈现，并通过描边区分推测或冲突内容；画布提供 50%–200% 缩放和一键恢复 100%，缩放不会影响实体筛选、点击和详情查看，也不会产生横向滚动条。
+生成过程时间线支持折叠和展开：进行中的任务默认展开，已完成结果中的历史时间线默认折叠。仅生成一种视图时会保留工作区中已有的另一种视图，不再用 `null` 覆盖其存储。思维导图使用递归树形布局并绘制父子连接线；严格来源过滤后少于 2 个有效节点的退化结果不会再作为成功视图保存，而会进入重试。知识图谱按关联度使用中心节点与自动扩展的多层环形布局，节点卡片内显示类型和最多两行名称，关系以带方向箭头的弱化曲线呈现，并通过描边区分推测或冲突内容；画布首次打开自动居中，可按住空白区域拖动，并提供 50%–200% 缩放、独立的 80%–220% 节点间距以及选中实体的一跳局部视图。
 
 节点“继续对话”只形成一个可编辑的后续问题。确认导航后，插件使用公开的 Session 导航入口；如果当前 Runtime 没有向该槽位暴露草稿镜像，则提供“打开并复制问题”的安全降级，不自动发送消息。
 

package/lib/client.js

@@ -380,6 +380,7 @@ window.__ModuleLoader__.load({
       return React.createElement('div', { className: 'ckm-workspace' }, [
         React.createElement('section', { key: 'canvas', className: 'ckm-mind-canvas' }, [
           React.createElement('div', { key: 'hint', className: 'ckm-panel-hint' }, '节点代表阶段性认知；点击后可形成问题，但不会直接修改脑图。'),
+          map && map.nodes.length < 2 ? React.createElement('div', { key: 'coverage-warning', className: 'ckm-warning' }, '本次思维导图仅保留了根节点，没有可展开的子节点。请使用修复后的版本重新生成。') : null,
           tree ? React.createElement('ul', { key: 'tree', className: 'ckm-tree ckm-tree-root' }, React.createElement(MindTreeBranch, { branch: tree, selectedNodeId: props.selectedNodeId, setSelectedNodeId: props.setSelectedNodeId })) : null
         ]),
         React.createElement('aside', { key: 'detail', className: 'ckm-detail' }, [
@@ -424,7 +425,7 @@ window.__ModuleLoader__.load({
       ]))
     }
 
-    function graphLayout(entities, relations) {
+    function graphLayout(entities, relations, spacing) {
       var degree = Object.create(null)
       entities.forEach(function (entity) { degree[entity.id] = 0 })
       relations.forEach(function (relation) {
@@ -434,20 +435,30 @@ window.__ModuleLoader__.load({
       var ordered = entities.slice().sort(function (left, right) {
         return (degree[right.id] || 0) - (degree[left.id] || 0) || String(left.name || '').localeCompare(String(right.name || ''))
       })
-      if (!ordered.length) return []
-      var positions = [{ entity: ordered[0], x: 450, y: 310, width: 164, height: 68, central: true }]
+      if (!ordered.length) return { positions: [], width: 900, height: 620 }
+      var density = Math.max(0.8, Math.min(2.2, Number(spacing) || 1))
+      var nodeWidth = 150
+      var nodeHeight = 64
       var remaining = ordered.slice(1)
-      var inner = remaining.slice(0, Math.min(6, remaining.length))
-      var outer = remaining.slice(inner.length)
-      function placeRing(items, radiusX, radiusY, phase) {
-        items.forEach(function (entity, index) {
-          var angle = phase + index / Math.max(1, items.length) * Math.PI * 2
-          positions.push({ entity: entity, x: 450 + Math.cos(angle) * radiusX, y: 310 + Math.sin(angle) * radiusY, width: 138, height: 60, central: false })
-        })
+      var rings = []
+      var ringIndex = 1
+      while (remaining.length) {
+        var radius = ringIndex * 205 * density
+        var capacity = Math.max(8, Math.floor(Math.PI * 2 * radius / (nodeWidth + 34 * density)))
+        rings.push({ radius: radius, items: remaining.splice(0, capacity) })
+        ringIndex += 1
       }
-      placeRing(inner, 205, 145, -Math.PI / 2)
-      placeRing(outer, 350, 255, -Math.PI / 2 + Math.PI / Math.max(2, outer.length))
-      return positions
+      var maxRadius = rings.length ? rings[rings.length - 1].radius : 0
+      var size = Math.max(620, Math.ceil((maxRadius + nodeWidth / 2 + 110) * 2))
+      var center = size / 2
+      var positions = [{ entity: ordered[0], x: center, y: center, width: 174, height: 72, central: true }]
+      rings.forEach(function (ring, index) {
+        ring.items.forEach(function (entity, itemIndex) {
+          var angle = -Math.PI / 2 + (index % 2 ? Math.PI / Math.max(2, ring.items.length) : 0) + itemIndex / Math.max(1, ring.items.length) * Math.PI * 2
+          positions.push({ entity: entity, x: center + Math.cos(angle) * ring.radius, y: center + Math.sin(angle) * ring.radius, width: nodeWidth, height: nodeHeight, central: false })
+        })
+      })
+      return { positions: positions, width: size, height: size }
     }
 
     function graphLabelLines(value) {
@@ -493,32 +504,91 @@ window.__ModuleLoader__.load({
       var zoomPair = React.useState(1)
       var zoom = zoomPair[0]
       var setZoom = zoomPair[1]
+      var spacingPair = React.useState(1)
+      var spacing = spacingPair[0]
+      var setSpacing = spacingPair[1]
+      var localPair = React.useState(false)
+      var localOnly = localPair[0]
+      var setLocalOnly = localPair[1]
+      var panRef = React.useRef(null)
       if (!graph) return React.createElement(EmptyState, { title: '尚未生成知识图谱', copy: '从标题栏打开知识视图并选择生成知识图谱。' })
-      var entities = graph.entities.filter(function (entity) {
+      var filteredEntities = graph.entities.filter(function (entity) {
         return (confidence === 'all' || entity.confidence === confidence) && (!query.trim() || (entity.name + ' ' + entity.summary).toLowerCase().indexOf(query.trim().toLowerCase()) >= 0)
       })
       var visible = Object.create(null)
-      entities.forEach(function (entity) { visible[entity.id] = true })
-      var relations = graph.relations.filter(function (relation) { return visible[relation.from] && visible[relation.to] })
-      var positions = graphLayout(entities, relations)
+      filteredEntities.forEach(function (entity) { visible[entity.id] = true })
+      var filteredRelations = graph.relations.filter(function (relation) { return visible[relation.from] && visible[relation.to] })
+      var localIds = Object.create(null)
+      if (localOnly && selected && visible[selected.id]) {
+        localIds[selected.id] = true
+        filteredRelations.forEach(function (relation) {
+          if (relation.from === selected.id || relation.to === selected.id) {
+            localIds[relation.from] = true
+            localIds[relation.to] = true
+          }
+        })
+      }
+      var entities = localOnly && selected && visible[selected.id] ? filteredEntities.filter(function (entity) { return localIds[entity.id] }) : filteredEntities
+      var shown = Object.create(null)
+      entities.forEach(function (entity) { shown[entity.id] = true })
+      var relations = filteredRelations.filter(function (relation) { return shown[relation.from] && shown[relation.to] })
+      var layout = graphLayout(entities, relations, spacing)
+      var positions = layout.positions
       var byId = Object.create(null)
       positions.forEach(function (item) { byId[item.entity.id] = item })
-      var viewWidth = 900 / zoom
-      var viewHeight = 620 / zoom
-      var viewBox = [(900 - viewWidth) / 2, (620 - viewHeight) / 2, viewWidth, viewHeight].join(' ')
+      var viewBox = ['0', '0', layout.width, layout.height].join(' ')
+      var centerSignature = [layout.width, layout.height, zoom, spacing, localOnly ? selected && selected.id : 'all'].join(':')
+      function centerCanvas(node) {
+        if (!node || node.dataset.centered === centerSignature) return
+        node.dataset.centered = centerSignature
+        window.requestAnimationFrame(function () {
+          var viewport = node.parentElement
+          if (!viewport) return
+          viewport.scrollLeft = Math.max(0, (viewport.scrollWidth - viewport.clientWidth) / 2)
+          viewport.scrollTop = Math.max(0, (viewport.scrollHeight - viewport.clientHeight) / 2)
+        })
+      }
+      function beginPan(event) {
+        if (event.button !== 0 || (event.target.closest && event.target.closest('.ckm-graph-node'))) return
+        var viewport = event.currentTarget.parentElement
+        panRef.current = { pointerId: event.pointerId, x: event.clientX, y: event.clientY, left: viewport.scrollLeft, top: viewport.scrollTop }
+        event.currentTarget.setPointerCapture(event.pointerId)
+        event.currentTarget.dataset.dragging = 'true'
+        event.preventDefault()
+      }
+      function movePan(event) {
+        var pan = panRef.current
+        if (!pan || pan.pointerId !== event.pointerId) return
+        var viewport = event.currentTarget.parentElement
+        viewport.scrollLeft = pan.left - (event.clientX - pan.x)
+        viewport.scrollTop = pan.top - (event.clientY - pan.y)
+      }
+      function endPan(event) {
+        var pan = panRef.current
+        if (!pan || pan.pointerId !== event.pointerId) return
+        panRef.current = null
+        event.currentTarget.dataset.dragging = 'false'
+        if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId)
+      }
       return React.createElement('div', { className: 'ckm-workspace ckm-graph-layout' }, [
         React.createElement('section', { key: 'graph', className: 'ckm-graph-canvas' }, [
           React.createElement('div', { key: 'toolbar', className: 'ckm-graph-toolbar' }, [
             React.createElement('input', { key: 'search', value: query, placeholder: '搜索实体…', onChange: function (event) { setQuery(event.target.value) } }),
             React.createElement('select', { key: 'confidence', value: confidence, onChange: function (event) { setConfidence(event.target.value) } }, [React.createElement('option', { key: 'all', value: 'all' }, '全部置信度'), React.createElement('option', { key: 'confirmed', value: 'confirmed' }, '已确认'), React.createElement('option', { key: 'inferred', value: 'inferred' }, '推测'), React.createElement('option', { key: 'conflicted', value: 'conflicted' }, '有冲突')]),
+            Button({ key: 'local', className: 'ckm-secondary', disabled: !selected, title: selected ? '只显示选中实体及其直接相邻实体' : '请先选择一个实体', onClick: function () { setLocalOnly(!localOnly) } }, localOnly ? '全部视图' : '局部一跳'),
+            React.createElement('div', { key: 'spacing', className: 'ckm-graph-zoom', 'aria-label': '知识图谱节点间距控制' }, [
+              Button({ key: 'compact', title: '缩小节点间距', disabled: spacing <= 0.8, onClick: function () { setSpacing(Math.max(0.8, Number((spacing - 0.2).toFixed(1)))) } }, '−'),
+              Button({ key: 'value', title: '重置节点间距', className: 'ckm-zoom-value', onClick: function () { setSpacing(1) } }, '间距 ' + Math.round(spacing * 100) + '%'),
+              Button({ key: 'loose', title: '增大节点间距', disabled: spacing >= 2.2, onClick: function () { setSpacing(Math.min(2.2, Number((spacing + 0.2).toFixed(1)))) } }, '+')
+            ]),
             React.createElement('div', { key: 'zoom', className: 'ckm-graph-zoom', 'aria-label': '知识图谱缩放控制' }, [
               Button({ key: 'out', title: '缩小', 'aria-label': '缩小知识图谱', disabled: zoom <= 0.5, onClick: function () { setZoom(Math.max(0.5, Number((zoom - 0.1).toFixed(1)))) } }, '−'),
               Button({ key: 'reset', title: '重置缩放', className: 'ckm-zoom-value', onClick: function () { setZoom(1) } }, Math.round(zoom * 100) + '%'),
               Button({ key: 'in', title: '放大', 'aria-label': '放大知识图谱', disabled: zoom >= 2, onClick: function () { setZoom(Math.min(2, Number((zoom + 0.1).toFixed(1)))) } }, '+')
             ])
           ]),
-          React.createElement('p', { key: 'static', className: 'ckm-panel-hint' }, '知识图谱是静态结果，可缩放查看；只能通过菜单栏完整重新生成，不支持直接编辑或节点发散。'),
-          React.createElement('svg', { key: 'svg', className: 'ckm-graph-svg', viewBox: viewBox, role: 'img', 'aria-label': '知识图谱' }, [
+          React.createElement('p', { key: 'static', className: 'ckm-panel-hint' }, '知识图谱是静态结果；可按住空白区域拖动画布，画布缩放与节点间距可分别调整，选择实体后可查看一跳局部子图。只能通过菜单栏完整重新生成，不支持直接编辑或节点发散。'),
+          React.createElement('svg', { key: 'svg', ref: centerCanvas, className: 'ckm-graph-svg', viewBox: viewBox, width: layout.width * zoom, height: layout.height * zoom, style: { width: layout.width * zoom + 'px', height: layout.height * zoom + 'px' }, role: 'img', 'aria-label': '知识图谱', onPointerDown: beginPan, onPointerMove: movePan, onPointerUp: endPan, onPointerCancel: endPan }, [
             React.createElement('defs', { key: 'defs' }, React.createElement('marker', { id: 'ckm-arrow', markerWidth: 7, markerHeight: 7, refX: 6, refY: 3.5, orient: 'auto', markerUnits: 'strokeWidth' }, React.createElement('path', { d: 'M0,0 L7,3.5 L0,7 Z', className: 'ckm-arrow-head' }))),
             React.createElement('g', { key: 'edges', className: 'ckm-graph-edges' }, relations.map(function (relation) {
               var from = byId[relation.from]
@@ -714,6 +784,8 @@ window.__ModuleLoader__.load({
       '.ckm-modal-backdrop{position:fixed;inset:0;z-index:120;display:flex;align-items:center;justify-content:center;padding:20px;background:rgba(0,0,0,.46)}.ckm-modal{width:min(680px,calc(100vw - 40px));max-height:min(760px,calc(100vh - 40px));overflow:auto;padding:22px;border:1px solid var(--dsw-alias-border-l2);border-radius:14px;box-shadow:0 18px 56px #0008}.ckm-modal h3{margin:0;font-size:17px}.ckm-modal p{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.65}.ckm-modal-head{display:flex;align-items:center;justify-content:space-between}.ckm-icon-close{border:0;background:transparent;color:var(--dsw-alias-label-secondary);font-size:20px;cursor:pointer}.ckm-workspace-label{padding:9px;border-radius:8px;background:var(--dsw-alias-bg-layer-1);word-break:break-all}.ckm-field{display:flex;flex-direction:column;gap:7px;margin:14px 0;color:var(--dsw-alias-label-secondary);font-size:12px}.ckm-field textarea{resize:vertical}.ckm-session-list{display:flex;max-height:220px;flex-direction:column;gap:5px;overflow:auto}.ckm-session-option{display:flex;align-items:flex-start;gap:8px;padding:8px;border:1px solid transparent;border-radius:8px;background:var(--dsw-alias-bg-layer-1);cursor:pointer}.ckm-session-option:hover{border-color:var(--dsw-alias-border-l2)}.ckm-session-option input,.ckm-inline-field input{margin-top:3px}.ckm-session-option span{display:flex;flex-direction:column;gap:3px}.ckm-session-option small{color:var(--dsw-alias-label-secondary);font-size:10px}.ckm-inline-field{display:flex;align-items:flex-start;gap:7px;margin:10px 0;color:var(--dsw-alias-label-secondary);font-size:11px;line-height:1.5}.ckm-confirm-summary{display:grid;grid-template-columns:100px 1fr;gap:7px 12px;margin:18px 0;font-size:12px}.ckm-confirm-summary dt{color:var(--dsw-alias-label-secondary)}.ckm-confirm-summary dd{margin:0;word-break:break-all}.ckm-warning{padding:10px;border-radius:8px;background:#d29c2518;color:var(--dsw-alias-label-secondary)}.ckm-error{color:#ff9898!important}.ckm-modal-actions{justify-content:flex-end;margin-top:18px}.ckm-header-pending{border-color:var(--dsw-alias-state-business-primary);background:var(--dsw-alias-state-business-tertiary)}' +
       '@media(max-width:800px){.ckm-workspace,.ckm-graph-layout{display:flex;flex-direction:column}.ckm-detail{border-top:1px solid var(--dsw-alias-border-l2);border-left:0}.ckm-page-header{align-items:flex-start;flex-direction:column}.ckm-page-actions{width:100%;flex-wrap:wrap}}'
 
+    CSS += '.ckm-graph-canvas{overflow:auto}.ckm-graph-toolbar{position:sticky;left:0;z-index:2;max-width:calc(100vw - 410px);padding-bottom:4px;background:var(--dsw-alias-bg-base)}.ckm-graph-zoom{margin-left:0}.ckm-graph-zoom:last-child{margin-left:auto}.ckm-graph-svg{width:auto;max-width:none;height:auto;min-width:620px;min-height:620px;cursor:grab;touch-action:none}.ckm-graph-svg[data-dragging="true"]{cursor:grabbing;user-select:none}'
+
     function apply(ctx) {
       var sessions = ctx.sessions || (ctx.get && ctx.get('sessions'))
       ctx.effect(function () {

package/lib/generation-orchestrator.js

@@ -80,7 +80,7 @@ function expectedObject(value, kind = '') {
   if (!kind) return true
   if (kind === 'summary') return typeof value?.summary === 'string' || typeof value?.narrative === 'string' || typeof value?.text === 'string'
   if (kind === 'mind-map') return Array.isArray(value?.nodes)
-  if (kind === 'knowledge-graph') return Array.isArray(value?.entities) && Array.isArray(value?.relations)
+  if (kind === 'knowledge-graph') return Array.isArray(value?.entities) && (value.relations === undefined || Array.isArray(value.relations))
   if (kind === 'follow-up') return typeof value?.question === 'string'
   return true
 }
@@ -197,10 +197,16 @@ function jsonParseDiagnostics(value, kind = '') {
 
 export function parseStructuredOutput(value, kind = '') {
   const object = asObject(value)
-  if (object && expectedObject(object, kind)) return object
+  if (object && expectedObject(object, kind)) {
+    if (kind === 'knowledge-graph' && object.relations === undefined) return { ...object, relations: [] }
+    return object
+  }
   const text = textFromContent(value).replace(/^\uFEFF/, '').trim()
   const parsed = findJsonObject(text, kind)
-  if (parsed) return parsed
+  if (parsed) {
+    if (kind === 'knowledge-graph' && parsed.relations === undefined) return { ...parsed, relations: [] }
+    return parsed
+  }
   if (!text) throw new Error('模型没有返回 JSON 对象。')
   throw new Error('模型返回了文本，但其中没有可解析的 JSON 对象。')
 }
@@ -504,9 +510,10 @@ function outputPrompt(kind, summaries, prompt, strict, options = {}) {
   ]
   const context = JSON.stringify(summaries)
   if (kind === 'mind-map') {
+    const minNodes = Math.max(2, Math.min(6, Number(options.mindMapMinNodes) || 4))
     return [
       '请根据以下多个对话摘要生成阶段性思维导图。节点不是关键词，narrative 必须是至少一段完整说明，包含背景、当前认识和下一步/未决点。',
-      '最多生成 12 个节点；每个 narrative 控制在 300 字以内。不要输出 schema 之外的字段。确保最终内容是可被 JSON.parse 直接解析的完整 JSON。',
+      `生成 ${minNodes}–12 个有效节点，至少包含根节点和覆盖不同对话/阶段的子节点；每个 narrative 控制在 300 字以内。不要输出 schema 之外的字段。确保最终内容是可被 JSON.parse 直接解析的完整 JSON。`,
       'JSON 形状：{"rootId":"...","nodes":[{"id":"...","parentId":null,"type":"theme|stage|question|decision|solution|risk|conclusion","title":"...","narrative":"...","primarySourceSessionId":"...","sourceRefs":[{"sessionId":"...","eventSeqs":[1]}],"openQuestions":[]}]}。',
       ...rules,
       `额外要求：${shortText(prompt, 2000) || '没有额外要求。'}`,
@@ -903,7 +910,8 @@ export class KnowledgeGenerationOrchestrator {
       if (request.outputMode === 'mind-map' || request.outputMode === 'both') {
         this.recordTimeline(task, 'view-start', '开始生成思维导图。')
         this.update(task, 'building-mind-map', { progress: { percent: 78, current: sources.length, total: sources.length, label: '生成思维导图' } })
-        const baseMindMapPrompt = outputPrompt('mind-map', summaries, request.prompt, request.strict === true)
+        const mindMapTargetNodes = Math.min(6, Math.max(2, summarizedSources.length + 1))
+        const baseMindMapPrompt = outputPrompt('mind-map', summaries, request.prompt, request.strict === true, { mindMapMinNodes: mindMapTargetNodes })
         const generateMindMap = async (prompt) => this.runModel({
           kind: 'mind-map', prompt, cwd: request.cwd, strict: request.strict === true,
           selectedSessionIds: sourceSessionIds, model: request.model, signal: task.controller.signal
@@ -914,7 +922,7 @@ export class KnowledgeGenerationOrchestrator {
             const prompt = attempt === 0 ? baseMindMapPrompt : `${baseMindMapPrompt}\n\n第 ${attempt} 次输出未通过校验：${shortText(errorMessage(mindMapError), 500)}。请完全重置并从头生成，只输出完整、严格合法且更精简的 JSON。`
             const value = await generateMindMap(prompt)
             const sanitized = sanitizeMindMapSources(value, summarizedSources, request.strict === true)
-            mindMap = validateMindMap(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
+            mindMap = validateMindMap(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true, minNodes: 2 })
             sourceWarnings.skippedRefs += sanitized.skippedRefs
             sourceWarnings.skippedItems += sanitized.skippedItems
             mindMapError = null
@@ -943,6 +951,7 @@ export class KnowledgeGenerationOrchestrator {
         this.recordTimeline(task, 'view-start', `开始分 ${graphBatches.length} 批生成知识图谱（最多 ${GRAPH_CONCURRENCY} 批并行）。`)
         this.update(task, 'building-knowledge-graph', { progress: { percent: 86, current: 0, total: graphBatches.length, label: '分批生成知识图谱' } })
         let completedGraphBatches = 0
+        let graphRetryCount = 0
         const graphBatchResults = await mapWithConcurrency(graphBatches, GRAPH_CONCURRENCY, async (batch, batchIndex) => {
           let graphError = null
           for (let attempt = 0; attempt <= MAX_MODEL_RETRIES; attempt += 1) {
@@ -967,7 +976,8 @@ export class KnowledgeGenerationOrchestrator {
               graphError = error
               logMessage(this.logger, 'warn', 'knowledge graph batch invalid id=%s batch=%d attempt=%d error=%s', logId(task.id), batchIndex + 1, attempt + 1, errorMessage(error))
               if (attempt < MAX_MODEL_RETRIES) {
-                this.recordTimeline(task, 'retry', `知识图谱第 ${batchIndex + 1}/${graphBatches.length} 批失败（${shortText(errorMessage(graphError), 160)}），降低本批输出预算后重试 ${attempt + 1}/${MAX_MODEL_RETRIES}。`)
+                graphRetryCount += 1
+                this.recordTimeline(task, 'retry', `知识图谱第 ${batchIndex + 1}/${graphBatches.length} 批输出无效（${shortText(errorMessage(graphError), 160)}），正在降低本批输出预算并重试 ${attempt + 1}/${MAX_MODEL_RETRIES}。`)
               }
             }
           }
@@ -981,7 +991,8 @@ export class KnowledgeGenerationOrchestrator {
           knowledgeGraph = validateKnowledgeGraph(mergedGraph, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
           const rawEntities = successfulGraphBatches.reduce((total, result) => total + result.rawEntities, 0)
           const rawRelations = successfulGraphBatches.reduce((total, result) => total + result.rawRelations, 0)
-          this.recordTimeline(task, 'graph-coverage', `知识图谱 ${successfulGraphBatches.length}/${graphBatches.length} 批成功，模型共返回 ${rawEntities} 个实体、${rawRelations} 条关系；合并去重后保留 ${knowledgeGraph.entities.length} 个实体、${knowledgeGraph.relations.length} 条关系。`, { entityLimit: graphBudget.entities, relationLimit: graphBudget.relations })
+          const retrySummary = graphRetryCount ? `；期间发生 ${graphRetryCount} 次批次重试${successfulGraphBatches.length === graphBatches.length ? '，已全部恢复' : ''}` : ''
+          this.recordTimeline(task, 'graph-coverage', `知识图谱 ${successfulGraphBatches.length}/${graphBatches.length} 批成功，模型共返回 ${rawEntities} 个实体、${rawRelations} 条关系；合并去重后保留 ${knowledgeGraph.entities.length} 个实体、${knowledgeGraph.relations.length} 条关系${retrySummary}。`, { entityLimit: graphBudget.entities, relationLimit: graphBudget.relations })
           this.recordTimeline(task, 'view-complete', '知识图谱分批生成与合并完成。')
         } else {
           const graphError = graphBatchResults.find((result) => result.error)?.error || new Error('所有知识图谱批次均生成失败。')
@@ -1019,7 +1030,7 @@ export class KnowledgeGenerationOrchestrator {
         knowledgeGraph
       })
       task.revision = saved.revision
-      task.result = { revision: saved.revision, manifest: saved.manifest, mindMap, knowledgeGraph, sourceSessions: saved.manifest.sourceSessions, failedSources, sourceWarnings }
+      task.result = { revision: saved.revision, manifest: saved.manifest, mindMap: saved.mindMap, knowledgeGraph: saved.knowledgeGraph, sourceSessions: saved.manifest.sourceSessions, failedSources, sourceWarnings }
       this.recordTimeline(task, 'complete', '知识视图已保存，生成流程完成。')
       logMessage(this.logger, 'info', 'generation completed id=%s revision=%d elapsedMs=%d', logId(task.id), saved.revision, this.now() - task.createdAt)
       this.update(task, 'completed', {

package/lib/mind-map-schema.js

@@ -45,10 +45,11 @@ function detectCycle(nodes) {
   for (const node of nodes) visit(node.id)
 }
 
-export function validateMindMap(input, { selectedSessionIds = [], strict = false } = {}) {
+export function validateMindMap(input, { selectedSessionIds = [], strict = false, minNodes = 1 } = {}) {
   if (!input || typeof input !== 'object') throw new MindMapValidationError('思维导图结果必须是对象。')
   const rawNodes = Array.isArray(input.nodes) ? input.nodes : []
-  if (!rawNodes.length) throw new MindMapValidationError('思维导图至少需要一个节点。')
+  const requiredNodes = Math.max(1, Math.floor(Number(minNodes) || 1))
+  if (rawNodes.length < requiredNodes) throw new MindMapValidationError(`思维导图至少需要 ${requiredNodes} 个有效节点，当前仅有 ${rawNodes.length} 个。`)
   if (rawNodes.length > MAX_MIND_MAP_NODES) throw new MindMapValidationError(`思维导图节点不能超过 ${MAX_MIND_MAP_NODES} 个。`)
   const rootId = asText(input.rootId || rawNodes[0]?.id, '思维导图 rootId', 256)
   const ids = new Set()

package/lib/workspace-storage.js

@@ -192,13 +192,17 @@ export class WorkspaceStorage {
         generatedAt: this.now()
       }
       const navigationHistory = current.navigationHistory || []
+      // A generation request may target only one view. Keep the other view intact
+      // instead of replacing its persisted JSON with null.
+      const nextMindMap = mindMap || current.mindMap || null
+      const nextKnowledgeGraph = knowledgeGraph || current.knowledgeGraph || null
       await replaceBundle(this.resolveDataDir(normalizedCwd), {
         manifest,
-        mindMap: mindMap || null,
-        knowledgeGraph: knowledgeGraph || null,
+        mindMap: nextMindMap,
+        knowledgeGraph: nextKnowledgeGraph,
         navigationHistory
       })
-      return { revision, manifest, dataDir: this.resolveDataDir(normalizedCwd) }
+      return { revision, manifest, dataDir: this.resolveDataDir(normalizedCwd), mindMap: nextMindMap, knowledgeGraph: nextKnowledgeGraph }
     })
     this.locks.set(key, operation)
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p-dsh-market/conversation-knowledge-map",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "DSH 多对话思维导图与静态知识图谱",
   "keywords": [
     "dsh",