@p-dsh-market/conversation-knowledge-map 0.1.11 → 0.1.13

package/README.md

@@ -11,7 +11,9 @@ DSH 的“知识视图”插件，把同一工作路径下用户明确选择的
 
 配置面板会列出运行时可用的 Provider / Model，并默认带入 DSH 默认模型；本次选择会绑定到确认令牌、Agent 调用和 `manifest.json`，不会因为默认模型变化而被静默替换。提交任务后配置对话框立即关闭，失败原因会显示在知识视图页的任务条中。
 
-摘要阶段按对话并行处理，并发上限固定为 3；同一对话的超长分段保持顺序处理，随后先合并为一份对话摘要，再统一生成思维导图或知识图谱。进度区域同时显示最近处理动态。结构化生成关闭推理输出以减少等待和 Token 消耗；知识图谱最多生成 20 个实体、30 条关系。最终模型若返回未选择的 Session 引用，会过滤该引用；严格模式下无有效来源的内容项会被跳过，最终页面列出实际总结的对话和过滤数量。
+摘要阶段按对话并行处理，并发上限固定为 3；每个对话按约 5000 字、优先在完整段落边界分段，只有单段本身超长时才按句末或硬边界拆分。同一对话的分段保持顺序处理，随后先合并为一份对话摘要，再统一生成思维导图或知识图谱。结构化输出失败时会完全重置并最多重试 3 次；单个对话连续失败后只跳过该对话，不阻断其他对话和最终报告。“同时生成”模式下，一个最终视图失败也不会阻断另一个视图保存。进度区域和最终知识视图都会按时间线显示读取、摘要、具体失败原因、重试、跳过、合并、生成及保存过程。模型可以保留 thinking，但结果提取只读取最终文本并过滤 reasoning 内容；摘要和最终视图分别预留 12000 与 24000 个输出 Token。知识图谱最多生成 20 个实体、30 条关系。最终模型若返回未选择的 Session 引用，会过滤该引用；严格模式下无有效来源的内容项会被跳过，最终页面列出实际总结的对话、失败对话和过滤数量。
+
+生成过程时间线支持折叠和展开：进行中的任务默认展开，已完成结果中的历史时间线默认折叠。思维导图使用递归树形布局并绘制父子连接线；知识图谱提供 50%–200% 缩放和一键恢复 100%，缩放不会影响实体筛选、点击和详情查看。
 
 节点“继续对话”只形成一个可编辑的后续问题。确认导航后，插件使用公开的 Session 导航入口；如果当前 Runtime 没有向该槽位暴露草稿镜像，则提供“打开并复制问题”的安全降级，不自动发送消息。
 

package/lib/client.js

@@ -261,6 +261,7 @@ window.__ModuleLoader__.load({
         store.generation && store.generation.status !== 'completed' ? React.createElement(GenerationStrip, { key: 'generation', store: store }) : null,
         state && state.compatibility && !state.compatibility.supported ? React.createElement('div', { key: 'compatibility', className: 'ckm-warning ckm-compatibility-warning' }, state.compatibility.message) : null,
         state && state.manifest ? React.createElement(SourceSummary, { key: 'sources', manifest: state.manifest }) : null,
+        state && state.manifest && state.manifest.generationTimeline ? React.createElement(GenerationTimeline, { key: 'timeline', items: state.manifest.generationTimeline, defaultCollapsed: true }) : null,
         !state || (!state.mindMap && !state.knowledgeGraph) ? React.createElement(EmptyState, { key: 'empty', title: '尚未生成知识视图', copy: '从标题栏打开“知识视图”，选择同工作路径下的对话并确认生成。' }) : (mode === 'mind-map'
           ? React.createElement(MindMapPanel, { key: 'mind', store: store, selectedNodeId: selectedNodeId, setSelectedNodeId: setSelectedNodeId })
           : React.createElement(KnowledgeGraphPanel, { key: 'graph', store: store }))
@@ -273,16 +274,40 @@ window.__ModuleLoader__.load({
         ? manifest.sourceSessions
         : (manifest.sourceSessionIds || []).map(function (sessionId) { return { sessionId: sessionId, title: '' } })
       var warnings = manifest.sourceWarnings || {}
+      var failedSources = manifest.failedSources || []
       if (!sources.length) return null
       return React.createElement('section', { className: 'ckm-source-summary', 'aria-label': '本次总结来源' }, [
         React.createElement('div', { key: 'head', className: 'ckm-source-summary-head' }, [
           React.createElement('strong', { key: 'title' }, '已总结 ' + sources.length + ' 个对话'),
-          warnings.skippedItems || warnings.skippedRefs ? React.createElement('span', { key: 'warning', className: 'ckm-source-warning' }, '已过滤 ' + (warnings.skippedRefs || 0) + ' 个无效引用、跳过 ' + (warnings.skippedItems || 0) + ' 个内容项') : null
+          warnings.skippedItems || warnings.skippedRefs || failedSources.length ? React.createElement('span', { key: 'warning', className: 'ckm-source-warning' }, '失败对话 ' + failedSources.length + ' 个 · 已过滤 ' + (warnings.skippedRefs || 0) + ' 个无效引用、跳过 ' + (warnings.skippedItems || 0) + ' 个内容项') : null
         ]),
         React.createElement('div', { key: 'list', className: 'ckm-source-list' }, sources.map(function (source) {
           var sessionId = String(source.sessionId || '')
           var label = source.title ? source.title + ' · ' + sessionId.slice(0, 16) + '…' : sessionId
           return React.createElement('span', { key: sessionId, className: 'ckm-source-chip', title: sessionId }, label)
+        })),
+        failedSources.length ? React.createElement('div', { key: 'failed', className: 'ckm-source-failed' }, '未纳入最终报告：' + failedSources.map(function (source) { return source.title || source.sessionId }).join('、')) : null
+      ])
+    }
+
+    function GenerationTimeline(props) {
+      var items = (props.items || []).slice(-80)
+      var collapsedPair = React.useState(props.defaultCollapsed === true)
+      var collapsed = collapsedPair[0]
+      var setCollapsed = collapsedPair[1]
+      if (!items.length) return null
+      return React.createElement('section', { className: 'ckm-timeline', 'aria-label': '生成过程时间线' }, [
+        React.createElement('div', { key: 'head', className: 'ckm-timeline-head' }, [
+          React.createElement('strong', { key: 'title', className: 'ckm-timeline-title' }, '生成过程时间线 · ' + items.length + ' 条'),
+          Button({ key: 'toggle', className: 'ckm-timeline-toggle', 'aria-expanded': !collapsed, onClick: function () { setCollapsed(!collapsed) } }, collapsed ? '展开' : '折叠')
+        ]),
+        collapsed ? null : React.createElement('ol', { key: 'items' }, items.map(function (item, index) {
+          var time = ''
+          try { time = new Date(Number(item.at) || 0).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' }) } catch (_) {}
+          return React.createElement('li', { key: String(item.id || index), 'data-type': item.type || 'info' }, [
+            React.createElement('time', { key: 'time' }, time),
+            React.createElement('span', { key: 'message' }, item.message)
+          ])
         }))
       ])
     }
@@ -291,16 +316,6 @@ window.__ModuleLoader__.load({
       var generation = props.store.generation
       var progress = generation.progress || { percent: 0, current: 0, total: 0, label: '' }
       var percent = Math.max(0, Math.min(100, Number(progress.percent) || 0))
-      var seen = Object.create(null)
-      var activities = []
-      ;(generation.events || []).slice().reverse().some(function (event) {
-        var label = event && event.progress && event.progress.label
-        if (!label || seen[label]) return false
-        seen[label] = true
-        activities.push({ label: label, status: event.status })
-        return activities.length >= 6
-      })
-      activities.reverse()
       return React.createElement('div', { className: 'ckm-generation-strip', 'data-status': generation.status }, [
         React.createElement('div', { key: 'body', className: 'ckm-generation-body' }, [
           React.createElement('div', { key: 'status-row', className: 'ckm-generation-status-row' }, [
@@ -308,36 +323,46 @@ window.__ModuleLoader__.load({
             React.createElement('span', { key: 'detail' }, progress.total ? (progress.current + '/' + progress.total + ' 个对话 · ' + progress.label) : progress.label)
           ]),
           React.createElement('div', { key: 'progress', className: 'ckm-progress-track', role: 'progressbar', 'aria-valuemin': 0, 'aria-valuemax': 100, 'aria-valuenow': percent, 'aria-label': '知识视图生成进度' }, React.createElement('span', { className: 'ckm-progress-value', style: { width: percent + '%' } })),
-          activities.length ? React.createElement('div', { key: 'activity', className: 'ckm-progress-activity' }, [
-            React.createElement('strong', { key: 'title' }, '最近处理动态'),
-            React.createElement('ul', { key: 'list' }, activities.map(function (activity, index) {
-              return React.createElement('li', { key: activity.status + '-' + activity.label + '-' + index, 'data-status': activity.status }, activity.label)
-            }))
-          ]) : null
+          React.createElement(GenerationTimeline, { key: 'activity', items: generation.timeline || [] })
         ]),
         generation.error ? React.createElement('span', { key: 'error', className: 'ckm-generation-error' }, generation.error) : null,
         ['failed', 'cancelled'].includes(generation.status) ? null : Button({ key: 'cancel', className: 'ckm-danger', onClick: function () { request('/generations/' + encodeURIComponent(generation.id) + '/cancel', { method: 'POST' }).then(function (body) { applyGeneration(props.store, body.generation) }).catch(function (error) { props.store.error = error.message; notifyStore(props.store) }) } }, '取消')
       ])
     }
 
-    function mindNodes(map) {
+    function mindTree(map) {
       var nodes = (map && map.nodes) || []
       var byParent = Object.create(null)
       nodes.forEach(function (node) { var key = node.parentId || ''; (byParent[key] || (byParent[key] = [])).push(node) })
-      var result = []
-      function visit(node, depth) {
-        result.push({ node: node, depth: depth })
-        ;(byParent[node.id] || []).forEach(function (child) { visit(child, depth + 1) })
+      function branch(node, ancestors) {
+        var seen = Object.assign({}, ancestors || {})
+        if (seen[node.id]) return { node: node, children: [] }
+        seen[node.id] = true
+        return { node: node, children: (byParent[node.id] || []).map(function (child) { return branch(child, seen) }) }
       }
       var root = nodes.filter(function (node) { return node.id === map.rootId })[0]
-      if (root) visit(root, 0)
-      return result
+      return root ? branch(root, {}) : null
+    }
+
+    function MindTreeBranch(props) {
+      var branch = props.branch
+      var node = branch.node
+      return React.createElement('li', { className: 'ckm-tree-branch' }, [
+        Button({ key: 'node', className: 'ckm-tree-node', 'data-active': node.id === props.selectedNodeId, onClick: function () { props.setSelectedNodeId(node.id) } }, [
+          React.createElement('span', { key: 'type', className: 'ckm-node-type' }, node.type),
+          React.createElement('strong', { key: 'title' }, node.title),
+          React.createElement('span', { key: 'narrative' }, node.narrative)
+        ]),
+        branch.children.length ? React.createElement('ul', { key: 'children', className: 'ckm-tree-children' }, branch.children.map(function (child) {
+          return React.createElement(MindTreeBranch, { key: child.node.id, branch: child, selectedNodeId: props.selectedNodeId, setSelectedNodeId: props.setSelectedNodeId })
+        })) : null
+      ])
     }
 
     function MindMapPanel(props) {
       var map = props.store.state && props.store.state.mindMap
       var selected = map && map.nodes.filter(function (node) { return node.id === props.selectedNodeId })[0]
-      var rows = map ? mindNodes(map) : []
+      var tree = map ? mindTree(map) : null
       var followPair = React.useState(null)
       var followUp = followPair[0]
       var setFollowUp = followPair[1]
@@ -355,13 +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' }, '节点代表阶段性认知；点击后可形成问题，但不会直接修改脑图。'),
-          React.createElement('div', { key: 'tree', className: 'ckm-tree' }, rows.map(function (row) {
-            return Button({ key: row.node.id, className: 'ckm-tree-node', 'data-active': row.node.id === props.selectedNodeId, style: { marginLeft: (row.depth * 24) + 'px' }, onClick: function () { props.setSelectedNodeId(row.node.id) } }, [
-              React.createElement('span', { key: 'type', className: 'ckm-node-type' }, row.node.type),
-              React.createElement('strong', { key: 'title' }, row.node.title),
-              React.createElement('span', { key: 'narrative' }, row.node.narrative)
-            ])
-          }))
+          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' }, [
           selected ? [
@@ -416,6 +435,9 @@ window.__ModuleLoader__.load({
       var selectedPair = React.useState(null)
       var selected = selectedPair[0]
       var setSelected = selectedPair[1]
+      var zoomPair = React.useState(1)
+      var zoom = zoomPair[0]
+      var setZoom = zoomPair[1]
       if (!graph) return React.createElement(EmptyState, { title: '尚未生成知识图谱', copy: '从标题栏打开知识视图并选择生成知识图谱。' })
       var entities = graph.entities.filter(function (entity) {
         return (confidence === 'all' || entity.confidence === confidence) && (!query.trim() || (entity.name + ' ' + entity.summary).toLowerCase().indexOf(query.trim().toLowerCase()) >= 0)
@@ -429,11 +451,22 @@ window.__ModuleLoader__.load({
       var byId = Object.create(null)
       positions.forEach(function (item) { byId[item.entity.id] = item })
       var relations = graph.relations.filter(function (relation) { return visible[relation.from] && visible[relation.to] })
+      var viewWidth = 800 / zoom
+      var viewHeight = 460 / zoom
+      var viewBox = [(800 - viewWidth) / 2, (460 - viewHeight) / 2, viewWidth, viewHeight].join(' ')
       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' }, '有冲突')])]),
-          React.createElement('p', { key: 'static', className: 'ckm-panel-hint' }, '知识图谱是静态结果，只能通过菜单栏完整重新生成；画布不支持编辑或节点发散。'),
-          React.createElement('svg', { key: 'svg', className: 'ckm-graph-svg', viewBox: '0 0 800 460', role: 'img', 'aria-label': '知识图谱' }, [
+          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' }, '有冲突')]),
+            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': '知识图谱' }, [
             relations.map(function (relation) { var from = byId[relation.from]; var to = byId[relation.to]; return React.createElement('line', { key: relation.id, x1: from.x, y1: from.y, x2: to.x, y2: to.y, className: 'ckm-edge' }) }),
             positions.map(function (item) { return React.createElement('g', { key: item.entity.id, className: 'ckm-graph-node', 'data-active': selected && selected.id === item.entity.id, onClick: function () { setSelected(item.entity) } }, [React.createElement('circle', { key: 'circle', cx: item.x, cy: item.y, r: 26 }), React.createElement('text', { key: 'text', x: item.x, y: item.y + 44, textAnchor: 'middle' }, item.entity.name.slice(0, 18))]) })
           ])
@@ -608,9 +641,9 @@ window.__ModuleLoader__.load({
       '.ckm-page-header h2{margin:0;font-size:16px}.ckm-page-header p{margin:3px 0 0;color:var(--dsw-alias-label-secondary);font-size:11px;word-break:break-all}' +
       '.ckm-page-actions,.ckm-modal-actions{display:flex;align-items:center;gap:8px}.ckm-tab,.ckm-secondary,.ckm-primary,.ckm-danger,.ckm-header-action{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:7px 11px;background:transparent;color:var(--dsw-alias-label-primary);cursor:pointer;font:inherit;font-size:12px}.ckm-tab[data-active=true],.ckm-primary{border-color:var(--dsw-alias-button-info-fill);background:var(--dsw-alias-button-info-fill);color:var(--dsw-alias-label-primary-foreground)}.ckm-tab:hover,.ckm-secondary:hover,.ckm-header-action:hover{background:var(--dsw-alias-interactive-bg-hover)}.ckm-primary:hover{background:var(--dsw-alias-button-info-hover)}.ckm-danger{border-color:#d36b6b;color:#ffb7b7}.ckm-danger:hover{background:#d94a4a22}.ckm-page button:disabled,.ckm-modal button:disabled{opacity:.5;cursor:not-allowed}' +
       '.ckm-empty{display:flex;flex:1;min-height:260px;flex-direction:column;align-items:center;justify-content:center;padding:28px;text-align:center}.ckm-empty-icon{display:grid;place-items:center;width:44px;height:44px;margin-bottom:12px;border:1px solid var(--dsw-alias-border-l2);border-radius:14px;color:var(--dsw-alias-state-business-primary);font-size:24px}.ckm-empty h2{margin:0 0 8px;font-size:17px}.ckm-empty p{max-width:520px;margin:0;color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.7}' +
-      '.ckm-generation-strip{display:flex;align-items:flex-start;gap:12px;padding:10px 20px;border-bottom:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-state-business-tertiary);font-size:12px}.ckm-generation-body{display:grid;gap:7px;flex:1;min-width:0}.ckm-generation-status-row{display:flex;justify-content:space-between;gap:12px}.ckm-generation-status-row span{color:var(--dsw-alias-label-secondary);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ckm-progress-track{height:6px;overflow:hidden;border-radius:999px;background:var(--dsw-alias-bg-layer-1)}.ckm-progress-value{display:block;height:100%;border-radius:inherit;background:var(--dsw-alias-state-business-primary);transition:width .25s ease}.ckm-progress-activity{display:grid;grid-template-columns:auto 1fr;gap:6px 12px;color:var(--dsw-alias-label-secondary)}.ckm-progress-activity ul{display:flex;flex-wrap:wrap;gap:5px 12px;margin:0;padding:0;list-style:none}.ckm-progress-activity li:before{content:"·";margin-right:5px;color:var(--dsw-alias-state-business-primary)}.ckm-generation-error{color:#ff9898;max-width:38%;overflow-wrap:anywhere}.ckm-generation-strip .ckm-danger{margin-left:auto}.ckm-source-summary{display:grid;gap:8px;padding:10px 20px;border-bottom:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1)}.ckm-source-summary-head{display:flex;align-items:center;justify-content:space-between;gap:12px;font-size:12px}.ckm-source-warning{color:#d69a42}.ckm-source-list{display:flex;flex-wrap:wrap;gap:6px}.ckm-source-chip{max-width:360px;padding:4px 8px;border:1px solid var(--dsw-alias-border-l2);border-radius:999px;color:var(--dsw-alias-label-secondary);font-size:11px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}' +
-      '.ckm-workspace{display:grid;grid-template-columns:minmax(0,1fr) 330px;min-height:0;flex:1}.ckm-mind-canvas,.ckm-graph-canvas{min-width:0;min-height:0;overflow:auto;padding:20px;background:var(--dsw-alias-bg-base)}.ckm-detail{min-width:0;min-height:0;overflow:auto;padding:20px;border-left:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1)}.ckm-panel-hint{margin:0 0 14px;color:var(--dsw-alias-label-secondary);font-size:11px;line-height:1.6}.ckm-tree{display:flex;flex-direction:column;gap:8px;max-width:900px;margin:0 auto}.ckm-tree-node{display:flex;flex-direction:column;align-items:flex-start;gap:5px;width:calc(100% - 0px);padding:12px;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);text-align:left;cursor:pointer}.ckm-tree-node[data-active=true]{border-color:var(--dsw-alias-state-business-primary);background:var(--dsw-alias-state-business-tertiary)}.ckm-tree-node:hover{background:var(--dsw-alias-interactive-bg-hover)}.ckm-tree-node strong{font-size:13px}.ckm-tree-node span:last-child{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.65}.ckm-node-type{display:inline-block;color:var(--dsw-alias-state-business-primary);font-size:10px;letter-spacing:.04em;text-transform:uppercase}.ckm-detail-head{display:flex;flex-direction:column;gap:5px}.ckm-detail h3{margin:0;font-size:16px;line-height:1.45}.ckm-narrative{font-size:13px;line-height:1.8}.ckm-source-box{margin:16px 0;padding:12px;border:1px solid var(--dsw-alias-border-l2);border-radius:9px;background:var(--dsw-alias-bg-base);font-size:11px;line-height:1.6}.ckm-source-box strong{display:block;margin-bottom:5px}.ckm-source-box ul{margin:0;padding-left:18px;color:var(--dsw-alias-label-secondary)}.ckm-detail-empty{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.7}' +
-      '.ckm-graph-layout{grid-template-columns:minmax(0,1fr) 330px}.ckm-graph-toolbar{display:flex;gap:8px}.ckm-model-selectors{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1.4fr);gap:8px}.ckm-graph-toolbar input,.ckm-graph-toolbar select,.ckm-field textarea,.ckm-field select,.ckm-field input,.ckm-modal textarea,.ckm-modal select{box-sizing:border-box;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:8px 9px;background:var(--dsw-specific-input-major);color:var(--dsw-alias-label-primary);font:inherit;font-size:12px}.ckm-graph-toolbar input{flex:1}.ckm-graph-svg{display:block;width:100%;min-height:420px;margin-top:8px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:var(--dsw-alias-bg-layer-1)}.ckm-edge{stroke:var(--dsw-alias-border-l2);stroke-width:1.5}.ckm-graph-node{cursor:pointer}.ckm-graph-node circle{fill:var(--dsw-alias-state-business-tertiary);stroke:var(--dsw-alias-state-business-primary);stroke-width:1.5}.ckm-graph-node[data-active=true] circle{fill:var(--dsw-alias-button-info-fill);stroke:var(--dsw-alias-label-primary)}.ckm-graph-node text{fill:var(--dsw-alias-label-primary);font-size:11px}' +
+      '.ckm-generation-strip{display:flex;align-items:flex-start;gap:12px;padding:10px 20px;border-bottom:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-state-business-tertiary);font-size:12px}.ckm-generation-body{display:grid;gap:7px;flex:1;min-width:0}.ckm-generation-status-row{display:flex;justify-content:space-between;gap:12px}.ckm-generation-status-row span{color:var(--dsw-alias-label-secondary);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ckm-progress-track{height:6px;overflow:hidden;border-radius:999px;background:var(--dsw-alias-bg-layer-1)}.ckm-progress-value{display:block;height:100%;border-radius:inherit;background:var(--dsw-alias-state-business-primary);transition:width .25s ease}.ckm-generation-error{color:#ff9898;max-width:38%;overflow-wrap:anywhere}.ckm-generation-strip .ckm-danger{margin-left:auto}.ckm-source-summary{display:grid;gap:8px;padding:10px 20px;border-bottom:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1)}.ckm-source-summary-head{display:flex;align-items:center;justify-content:space-between;gap:12px;font-size:12px}.ckm-source-warning,.ckm-source-failed{color:#d69a42}.ckm-source-failed{font-size:11px}.ckm-source-list{display:flex;flex-wrap:wrap;gap:6px}.ckm-source-chip{max-width:360px;padding:4px 8px;border:1px solid var(--dsw-alias-border-l2);border-radius:999px;color:var(--dsw-alias-label-secondary);font-size:11px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ckm-timeline{display:grid;gap:9px;padding:12px 20px;border-bottom:1px solid var(--dsw-alias-border-l2);font-size:12px}.ckm-generation-strip .ckm-timeline{max-height:220px;overflow:auto;padding:6px 0 0;border:0}.ckm-timeline-head{display:flex;align-items:center;justify-content:space-between;gap:12px}.ckm-timeline-title{color:var(--dsw-alias-label-primary)}.ckm-timeline-toggle{border:0;padding:3px 7px;border-radius:6px;background:transparent;color:var(--dsw-alias-state-business-primary);cursor:pointer;font:inherit;font-size:11px}.ckm-timeline-toggle:hover{background:var(--dsw-alias-interactive-bg-hover)}.ckm-timeline ol{display:grid;gap:0;margin:0;padding:0;list-style:none}.ckm-timeline li{position:relative;display:grid;grid-template-columns:78px 1fr;gap:10px;padding:5px 0 5px 14px;color:var(--dsw-alias-label-secondary)}.ckm-timeline li:before{content:"";position:absolute;left:2px;top:11px;width:6px;height:6px;border-radius:50%;background:var(--dsw-alias-state-business-primary)}.ckm-timeline li:not(:last-child):after{content:"";position:absolute;left:4px;top:17px;bottom:-5px;width:1px;background:var(--dsw-alias-border-l2)}.ckm-timeline li[data-type="retry"]:before,.ckm-timeline li[data-type="skipped"]:before,.ckm-timeline li[data-type="view-failed"]:before{background:#d69a42}.ckm-timeline li[data-type="failed"]:before{background:#ff7070}.ckm-timeline time{color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums}' +
+      '.ckm-workspace{display:grid;grid-template-columns:minmax(0,1fr) 330px;min-height:0;flex:1}.ckm-mind-canvas,.ckm-graph-canvas{min-width:0;min-height:0;overflow:auto;padding:20px;background:var(--dsw-alias-bg-base)}.ckm-detail{min-width:0;min-height:0;overflow:auto;padding:20px;border-left:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1)}.ckm-panel-hint{margin:0 0 14px;color:var(--dsw-alias-label-secondary);font-size:11px;line-height:1.6}.ckm-tree{max-width:900px;margin:0 auto;padding:0;list-style:none}.ckm-tree-branch{position:relative;padding:6px 0 6px 30px;list-style:none}.ckm-tree-root>.ckm-tree-branch{padding-left:0}.ckm-tree-children{position:relative;margin:8px 0 0 20px;padding:0 0 0 22px;list-style:none}.ckm-tree-children>.ckm-tree-branch:before{content:"";position:absolute;left:-22px;top:-8px;bottom:50%;border-left:1px solid var(--dsw-alias-border-l2)}.ckm-tree-children>.ckm-tree-branch:not(:last-child):before{bottom:-8px}.ckm-tree-children>.ckm-tree-branch:after{content:"";position:absolute;left:-22px;top:50%;width:22px;border-top:1px solid var(--dsw-alias-border-l2)}.ckm-tree-node{display:flex;flex-direction:column;align-items:flex-start;gap:5px;width:min(720px,100%);padding:12px;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);text-align:left;cursor:pointer}.ckm-tree-node[data-active=true]{border-color:var(--dsw-alias-state-business-primary);background:var(--dsw-alias-state-business-tertiary)}.ckm-tree-node:hover{background:var(--dsw-alias-interactive-bg-hover)}.ckm-tree-node strong{font-size:13px}.ckm-tree-node span:last-child{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.65}.ckm-node-type{display:inline-block;color:var(--dsw-alias-state-business-primary);font-size:10px;letter-spacing:.04em;text-transform:uppercase}.ckm-detail-head{display:flex;flex-direction:column;gap:5px}.ckm-detail h3{margin:0;font-size:16px;line-height:1.45}.ckm-narrative{font-size:13px;line-height:1.8}.ckm-source-box{margin:16px 0;padding:12px;border:1px solid var(--dsw-alias-border-l2);border-radius:9px;background:var(--dsw-alias-bg-base);font-size:11px;line-height:1.6}.ckm-source-box strong{display:block;margin-bottom:5px}.ckm-source-box ul{margin:0;padding-left:18px;color:var(--dsw-alias-label-secondary)}.ckm-detail-empty{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1.7}' +
+      '.ckm-graph-layout{grid-template-columns:minmax(0,1fr) 330px}.ckm-graph-toolbar{display:flex;align-items:center;flex-wrap:wrap;gap:8px}.ckm-model-selectors{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1.4fr);gap:8px}.ckm-graph-toolbar input,.ckm-graph-toolbar select,.ckm-field textarea,.ckm-field select,.ckm-field input,.ckm-modal textarea,.ckm-modal select{box-sizing:border-box;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:8px 9px;background:var(--dsw-specific-input-major);color:var(--dsw-alias-label-primary);font:inherit;font-size:12px}.ckm-graph-toolbar input{flex:1;min-width:180px}.ckm-graph-zoom{display:flex;align-items:center;margin-left:auto;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;overflow:hidden}.ckm-graph-zoom button{min-width:32px;border:0;border-right:1px solid var(--dsw-alias-border-l2);padding:7px 9px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);cursor:pointer;font:inherit}.ckm-graph-zoom button:last-child{border-right:0}.ckm-graph-zoom button:hover{background:var(--dsw-alias-interactive-bg-hover)}.ckm-graph-zoom button:disabled{opacity:.4;cursor:not-allowed}.ckm-graph-zoom .ckm-zoom-value{min-width:58px;color:var(--dsw-alias-state-business-primary);font-size:11px}.ckm-graph-svg{display:block;width:100%;min-height:420px;margin-top:8px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:var(--dsw-alias-bg-layer-1)}.ckm-edge{stroke:var(--dsw-alias-border-l2);stroke-width:1.5}.ckm-graph-node{cursor:pointer}.ckm-graph-node circle{fill:var(--dsw-alias-state-business-tertiary);stroke:var(--dsw-alias-state-business-primary);stroke-width:1.5}.ckm-graph-node[data-active=true] circle{fill:var(--dsw-alias-button-info-fill);stroke:var(--dsw-alias-label-primary)}.ckm-graph-node text{fill:var(--dsw-alias-label-primary);font-size:11px}' +
       '.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}}'
 

package/lib/generation-orchestrator.js

@@ -6,9 +6,10 @@ import { clone, diagnosticSummary, errorMessage, logMessage, makeUserMessage, sh
 import { chunkSourceText, readSelectedSurfaces } from './session-source.js'
 
 const MAX_SUMMARY_CHARS = 2400
-const SUMMARY_MAX_TOKENS = 8000
-const VIEW_MAX_TOKENS = 12000
+const SUMMARY_MAX_TOKENS = 12000
+const VIEW_MAX_TOKENS = 24000
 const SUMMARY_CONCURRENCY = 3
+const MAX_MODEL_RETRIES = 3
 
 function modelLabel(selection) {
   const provider = String(selection?.provider || '').trim()
@@ -533,6 +534,7 @@ export class KnowledgeGenerationOrchestrator {
       revision: task.revision || 0,
       progress: task.progress ? clone(task.progress) : null,
       result: task.result ? clone(task.result) : null,
+      timeline: Array.isArray(task.timeline) ? clone(task.timeline) : [],
       events: task.events.slice(-40)
     }
   }
@@ -563,6 +565,11 @@ export class KnowledgeGenerationOrchestrator {
     }
   }
 
+  recordTimeline(task, type, message, details = {}) {
+    task.timeline.push({ id: task.nextTimelineId++, at: this.now(), type, message: shortText(message, 500), ...details })
+    if (task.timeline.length > 80) task.timeline.splice(0, task.timeline.length - 80)
+  }
+
   start(request) {
     const key = String(request.cwd || '').toLowerCase()
     if (this.busyByWorkspace.has(key)) throw new Error('当前工作路径已有生成任务在运行，请先取消或等待完成。')
@@ -577,7 +584,9 @@ export class KnowledgeGenerationOrchestrator {
       createdAt: this.now(),
       updatedAt: this.now(),
       nextEventId: 1,
+      nextTimelineId: 1,
       events: [],
+      timeline: [],
       listeners: new Set(),
       controller: new AbortController(),
       promise: null
@@ -606,6 +615,7 @@ export class KnowledgeGenerationOrchestrator {
 
   async run(task, request) {
     try {
+      this.recordTimeline(task, 'start', `开始处理 ${request.selectedSessionIds.length} 个已选对话。`)
       this.update(task, 'reading-sources', { progress: { percent: 5, current: 0, total: request.selectedSessionIds.length, label: '读取对话记录' } })
       const sources = await this.sourceReader({ sessionQuery: this.sessionQuery, sessions: this.sessions }, {
         cwd: request.cwd,
@@ -613,95 +623,158 @@ export class KnowledgeGenerationOrchestrator {
         fallbackSessionId: request.anchorSessionId,
         includeSubagents: request.includeSubagents === true
       })
-      const sourceSessionIds = [...new Set(sources.map((source) => source.sessionId))]
+      const loadedSessionIds = [...new Set(sources.map((source) => source.sessionId))]
       this.assertNotCancelled(task)
       logMessage(this.logger, 'info', 'generation sources loaded id=%s sources=%d events=%d', logId(task.id), sources.length, sources.reduce((total, source) => total + (Array.isArray(source.events) ? source.events.length : 0), 0))
+      this.recordTimeline(task, 'read', `已读取 ${sources.length} 个对话，开始并行摘要（最多 3 个并行）。`)
       this.update(task, 'summarizing', { sourceCount: sources.length, progress: { percent: 10, current: 0, total: sources.length, label: '准备整理对话' } })
       let completedSources = 0
       logMessage(this.logger, 'info', 'summary batch start id=%s sources=%d concurrency=%d', logId(task.id), sources.length, Math.min(SUMMARY_CONCURRENCY, sources.length))
-      const summaries = await mapWithConcurrency(sources, SUMMARY_CONCURRENCY, async (source, sourceIndex) => {
+      const summaryResults = await mapWithConcurrency(sources, SUMMARY_CONCURRENCY, async (source, sourceIndex) => {
+        this.recordTimeline(task, 'summary-start', `开始摘要：${source.title}`, { sessionId: source.sessionId })
         this.update(task, 'summarizing', {
           sourceCount: sources.length,
           progress: { percent: 10 + Math.floor(60 * completedSources / sources.length), current: completedSources, total: sources.length, label: `并行整理：${source.title}` }
         })
         const chunkSummaries = []
-        for (const chunk of chunkSourceText(source)) {
+        const chunks = chunkSourceText(source)
+        let finalError = null
+        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {
+          const chunk = chunks[chunkIndex]
           this.assertNotCancelled(task)
-          const prompt = summaryPrompt(source, chunk, request.strict === true)
+          const basePrompt = summaryPrompt(source, chunk, request.strict === true)
           const generateSummary = async (summaryInput) => this.runModel({
             kind: 'summary', prompt: summaryInput, cwd: request.cwd, strict: request.strict === true,
-            selectedSessionIds: sourceSessionIds, model: request.model, signal: task.controller.signal
+            selectedSessionIds: loadedSessionIds, model: request.model, signal: task.controller.signal
           })
-          try {
-            const value = await generateSummary(prompt)
-            chunkSummaries.push(normalizeSummary(value, source, chunk))
-          } catch (error) {
-            this.assertNotCancelled(task)
-            logMessage(this.logger, 'warn', 'summary first attempt invalid id=%s session=%s error=%s', logId(task.id), logId(source.sessionId), errorMessage(error))
-            this.update(task, 'summarizing', {
-              message: `对话 ${sourceIndex + 1}/${sources.length} 摘要结构无效，正在自动修复…`,
-              progress: { percent: 10 + Math.floor(60 * sourceIndex / sources.length), current: sourceIndex, total: sources.length, label: `自动修复：${source.title}` }
-            })
-            const retryPrompt = `${prompt}\n\n上一次输出未通过校验：${shortText(errorMessage(error), 500)}。请从头重新整理，缩短内容，只输出严格合法的顶层摘要 JSON。`
-            const retryValue = await generateSummary(retryPrompt)
-            chunkSummaries.push(normalizeSummary(retryValue, source, chunk))
+          for (let attempt = 0; attempt <= MAX_MODEL_RETRIES; attempt += 1) {
+            try {
+              const prompt = attempt === 0 ? basePrompt : `${basePrompt}\n\n第 ${attempt} 次输出未通过校验：${shortText(errorMessage(finalError), 500)}。请完全重置并从头生成，进一步缩短内容，只输出严格合法的顶层摘要 JSON。`
+              const value = await generateSummary(prompt)
+              chunkSummaries.push(normalizeSummary(value, source, chunk))
+              finalError = null
+              break
+            } catch (error) {
+              this.assertNotCancelled(task)
+              finalError = error
+              logMessage(this.logger, 'warn', 'summary attempt invalid id=%s session=%s chunk=%d attempt=%d error=%s', logId(task.id), logId(source.sessionId), chunkIndex + 1, attempt + 1, errorMessage(error))
+              if (attempt < MAX_MODEL_RETRIES) {
+                this.recordTimeline(task, 'retry', `摘要失败（${shortText(errorMessage(finalError), 160)}），重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}：${source.title}`, { sessionId: source.sessionId })
+                this.update(task, 'summarizing', {
+                  message: `对话 ${sourceIndex + 1}/${sources.length} 摘要无效，正在重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}…`,
+                  progress: { percent: 10 + Math.floor(60 * completedSources / sources.length), current: completedSources, total: sources.length, label: `重试 ${attempt + 1}/${MAX_MODEL_RETRIES}：${source.title}` }
+                })
+              }
+            }
           }
+          if (finalError) break
         }
         completedSources += 1
+        if (finalError) {
+          this.recordTimeline(task, 'skipped', `连续重试 ${MAX_MODEL_RETRIES} 次后仍失败，已跳过：${source.title}`, { sessionId: source.sessionId })
+          this.update(task, 'summarizing', {
+            message: `已跳过无法生成合法摘要的对话：${source.title}`,
+            sourceCount: sources.length,
+            progress: { percent: 10 + Math.floor(60 * completedSources / sources.length), current: completedSources, total: sources.length, label: `已跳过：${source.title}` }
+          })
+          return { source, error: errorMessage(finalError), summary: null }
+        }
+        this.recordTimeline(task, 'summary-complete', `摘要完成：${source.title}`, { sessionId: source.sessionId })
         this.update(task, 'summarizing', {
           sourceCount: sources.length,
           progress: { percent: 10 + Math.floor(60 * completedSources / sources.length), current: completedSources, total: sources.length, label: `已完成摘要：${source.title}` }
         })
-        return mergeSourceSummaries(source, chunkSummaries)
+        return { source, error: '', summary: mergeSourceSummaries(source, chunkSummaries) }
       })
       this.assertNotCancelled(task)
+      const successfulResults = summaryResults.filter((result) => result?.summary)
+      const failedSources = summaryResults.filter((result) => !result?.summary).map((result) => ({
+        sessionId: result.source.sessionId, title: result.source.title, error: result.error
+      }))
+      if (!successfulResults.length) throw new Error(`所选 ${sources.length} 个对话均未能生成合法摘要，已分别重试 ${MAX_MODEL_RETRIES} 次。`)
+      const summarizedSources = successfulResults.map((result) => result.source)
+      const summaries = successfulResults.map((result) => result.summary)
+      const sourceSessionIds = summarizedSources.map((source) => source.sessionId)
+      this.recordTimeline(task, 'merge', `已合并 ${summaries.length} 个对话摘要${failedSources.length ? `，跳过 ${failedSources.length} 个失败对话` : ''}，开始生成最终视图。`)
       let mindMap = null
       let knowledgeGraph = null
       const sourceWarnings = { skippedRefs: 0, skippedItems: 0 }
       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 mindMapPrompt = outputPrompt('mind-map', summaries, request.prompt, request.strict === true)
+        const baseMindMapPrompt = outputPrompt('mind-map', summaries, request.prompt, request.strict === true)
         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
         })
-        try {
-          const value = await generateMindMap(mindMapPrompt)
-          const sanitized = sanitizeMindMapSources(value, sources, request.strict === true)
-          mindMap = validateMindMap(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
-          sourceWarnings.skippedRefs += sanitized.skippedRefs
-          sourceWarnings.skippedItems += sanitized.skippedItems
-        } catch (error) {
-          this.assertNotCancelled(task)
-          logMessage(this.logger, 'warn', 'mind map first attempt invalid id=%s error=%s', logId(task.id), errorMessage(error))
-          this.update(task, 'building-mind-map', {
-            message: '首次结构无效，正在自动修复思维导图…',
-            progress: { percent: 82, current: sources.length, total: sources.length, label: '自动修复结构' }
-          })
-          const retryPrompt = `${mindMapPrompt}\n\n上一次输出未通过校验：${shortText(errorMessage(error), 500)}。请从头重新生成，不要复用上一次文本；只输出完整、严格合法的 JSON。`
-          const retryValue = await generateMindMap(retryPrompt)
-          const sanitized = sanitizeMindMapSources(retryValue, sources, request.strict === true)
-          mindMap = validateMindMap(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
-          sourceWarnings.skippedRefs += sanitized.skippedRefs
-          sourceWarnings.skippedItems += sanitized.skippedItems
+        let mindMapError = null
+        for (let attempt = 0; attempt <= MAX_MODEL_RETRIES; attempt += 1) {
+          try {
+            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 })
+            sourceWarnings.skippedRefs += sanitized.skippedRefs
+            sourceWarnings.skippedItems += sanitized.skippedItems
+            mindMapError = null
+            this.recordTimeline(task, 'view-complete', '思维导图生成完成。')
+            break
+          } catch (error) {
+            this.assertNotCancelled(task)
+            mindMapError = error
+            logMessage(this.logger, 'warn', 'mind map attempt invalid id=%s attempt=%d error=%s', logId(task.id), attempt + 1, errorMessage(error))
+            if (attempt < MAX_MODEL_RETRIES) {
+              this.recordTimeline(task, 'retry', `思维导图生成失败（${shortText(errorMessage(mindMapError), 160)}），重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}。`)
+              this.update(task, 'building-mind-map', {
+                message: `思维导图结构无效，正在重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}…`,
+                progress: { percent: 82, current: sources.length, total: sources.length, label: `思维导图重试 ${attempt + 1}/${MAX_MODEL_RETRIES}` }
+              })
+            }
+          }
+        }
+        if (mindMapError) {
+          this.recordTimeline(task, 'view-failed', `思维导图连续重试 ${MAX_MODEL_RETRIES} 次后仍失败，已跳过该视图。`)
+          if (request.outputMode === 'mind-map') throw mindMapError
         }
       }
       if (request.outputMode === 'knowledge-graph' || request.outputMode === 'both') {
+        this.recordTimeline(task, 'view-start', '开始生成知识图谱。')
         this.update(task, 'building-knowledge-graph', { progress: { percent: 86, current: sources.length, total: sources.length, label: '生成知识图谱' } })
-        const value = await this.runModel({
-          kind: 'knowledge-graph',
-          prompt: outputPrompt('knowledge-graph', summaries, request.prompt, request.strict === true),
-          cwd: request.cwd,
-          strict: request.strict === true,
-          selectedSessionIds: sourceSessionIds,
-          model: request.model,
-          signal: task.controller.signal
-        })
-        const sanitized = sanitizeKnowledgeGraphSources(value, sources, request.strict === true)
-        sourceWarnings.skippedRefs += sanitized.skippedRefs
-        sourceWarnings.skippedItems += sanitized.skippedItems
-        knowledgeGraph = validateKnowledgeGraph(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
+        const baseGraphPrompt = outputPrompt('knowledge-graph', summaries, request.prompt, request.strict === true)
+        let graphError = null
+        for (let attempt = 0; attempt <= MAX_MODEL_RETRIES; attempt += 1) {
+          try {
+            const prompt = attempt === 0 ? baseGraphPrompt : `${baseGraphPrompt}\n\n第 ${attempt} 次输出未通过校验：${shortText(errorMessage(graphError), 500)}。请完全重置并从头生成，只输出完整、严格合法且更精简的 JSON。`
+            const value = await this.runModel({
+              kind: 'knowledge-graph', prompt, cwd: request.cwd, strict: request.strict === true,
+              selectedSessionIds: sourceSessionIds, model: request.model, signal: task.controller.signal
+            })
+            const sanitized = sanitizeKnowledgeGraphSources(value, summarizedSources, request.strict === true)
+            knowledgeGraph = validateKnowledgeGraph(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
+            sourceWarnings.skippedRefs += sanitized.skippedRefs
+            sourceWarnings.skippedItems += sanitized.skippedItems
+            graphError = null
+            this.recordTimeline(task, 'view-complete', '知识图谱生成完成。')
+            break
+          } catch (error) {
+            this.assertNotCancelled(task)
+            graphError = error
+            logMessage(this.logger, 'warn', 'knowledge graph attempt invalid id=%s attempt=%d error=%s', logId(task.id), attempt + 1, errorMessage(error))
+            if (attempt < MAX_MODEL_RETRIES) {
+              this.recordTimeline(task, 'retry', `知识图谱生成失败（${shortText(errorMessage(graphError), 160)}），重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}。`)
+              this.update(task, 'building-knowledge-graph', {
+                message: `知识图谱结构无效，正在重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}…`,
+                progress: { percent: 88, current: sources.length, total: sources.length, label: `知识图谱重试 ${attempt + 1}/${MAX_MODEL_RETRIES}` }
+              })
+            }
+          }
+        }
+        if (graphError) {
+          this.recordTimeline(task, 'view-failed', `知识图谱连续重试 ${MAX_MODEL_RETRIES} 次后仍失败，已跳过该视图。`)
+          if (request.outputMode === 'knowledge-graph') throw graphError
+        }
       }
+      if (!mindMap && !knowledgeGraph) throw new Error('思维导图和知识图谱均未能生成有效结果。')
       if (sourceWarnings.skippedRefs || sourceWarnings.skippedItems) {
         logMessage(this.logger, 'warn', 'generation filtered invalid sources id=%s skippedRefs=%d skippedItems=%d', logId(task.id), sourceWarnings.skippedRefs, sourceWarnings.skippedItems)
         this.update(task, 'validating', {
@@ -709,17 +782,20 @@ export class KnowledgeGenerationOrchestrator {
           progress: { percent: 90, current: sources.length, total: sources.length, label: '过滤无效来源' }
         })
       }
-      assertOutputSourceRefs({ mindMap, knowledgeGraph }, sources)
+      assertOutputSourceRefs({ mindMap, knowledgeGraph }, summarizedSources)
       this.assertNotCancelled(task)
       this.update(task, 'validating', { progress: { percent: 92, current: sources.length, total: sources.length, label: '校验结构和来源' } })
+      this.recordTimeline(task, 'save', '最终结果已通过校验，正在保存知识视图。')
       this.update(task, 'saving', { progress: { percent: 97, current: sources.length, total: sources.length, label: '保存知识视图' } })
       const saved = await this.storage.saveBundle({
         cwd: request.cwd,
         expectedRevision: request.expectedRevision,
         generationId: task.id,
         sourceSessionIds,
-        sourceSessions: sources.map((source) => ({ sessionId: source.sessionId, title: source.title })),
+        sourceSessions: summarizedSources.map((source) => ({ sessionId: source.sessionId, title: source.title })),
+        failedSources,
         sourceWarnings,
+        generationTimeline: task.timeline,
         prompt: request.prompt,
         strict: request.strict,
         outputMode: request.outputMode,
@@ -728,19 +804,22 @@ export class KnowledgeGenerationOrchestrator {
         knowledgeGraph
       })
       task.revision = saved.revision
-      task.result = { revision: saved.revision, manifest: saved.manifest, mindMap, knowledgeGraph, sourceSessions: saved.manifest.sourceSessions, sourceWarnings }
+      task.result = { revision: saved.revision, manifest: saved.manifest, mindMap, 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', {
-        message: `知识视图生成完成，已总结 ${sources.length} 个对话${sourceWarnings.skippedItems ? `，跳过 ${sourceWarnings.skippedItems} 个无有效来源的内容项` : ''}。`,
+        message: `知识视图生成完成，已总结 ${summarizedSources.length} 个对话${failedSources.length ? `，跳过 ${failedSources.length} 个失败对话` : ''}${sourceWarnings.skippedItems ? `，过滤 ${sourceWarnings.skippedItems} 个无有效来源的内容项` : ''}。`,
         revision: saved.revision,
         result: task.result,
         progress: { percent: 100, current: sources.length, total: sources.length, label: '合并并生成最终报告完成' }
       })
     } catch (error) {
       if (task.controller.signal.aborted || /取消|cancel/i.test(errorMessage(error))) {
+        this.recordTimeline(task, 'cancelled', '用户取消了知识视图生成。')
         this.update(task, 'cancelled', { error: '' })
       } else {
         logMessage(this.logger, 'error', 'generation failed id=%s status=%s error=%s', logId(task.id), task.status, errorMessage(error))
+        this.recordTimeline(task, 'failed', `生成失败：${errorMessage(error)}`)
         this.update(task, 'failed', { error: errorMessage(error) })
       }
     }
@@ -835,7 +914,7 @@ export class KnowledgeGenerationOrchestrator {
       handle = await this.agents.create({
         sessionId,
         meta: { cwd: input.cwd, origin: 'subagent' },
-        agentOptions: { provider, model, reasoningEffort: 'off', maxTokens: input.kind === 'summary' ? SUMMARY_MAX_TOKENS : VIEW_MAX_TOKENS },
+        agentOptions: { provider, model, maxTokens: input.kind === 'summary' ? SUMMARY_MAX_TOKENS : VIEW_MAX_TOKENS },
         signal: input.signal,
         setup: async (agentCtx) => {
           agentCtx?.systemPrompt?.section?.({

package/lib/session-source.js

@@ -206,19 +206,86 @@ export async function readSelectedSurfaces({ sessionQuery, sessions }, { cwd, se
   return sources
 }
 
-export function chunkSourceText(source, maxChars = 16000) {
+export const DEFAULT_SOURCE_CHUNK_CHARS = 5000
+
+function paragraphRanges(text) {
+  const ranges = []
+  const separator = /\r?\n[\t ]*\r?\n/g
+  let start = 0
+  let match
+  while ((match = separator.exec(text)) !== null) {
+    const end = match.index + match[0].length
+    ranges.push({ start, end })
+    start = end
+  }
+  if (start < text.length) ranges.push({ start, end: text.length })
+  return ranges
+}
+
+function splitOversizedRange(text, range, maxChars) {
+  const ranges = []
+  let start = range.start
+  while (start < range.end) {
+    let end = Math.min(range.end, start + maxChars)
+    if (end < range.end) {
+      const candidate = text.slice(start, end)
+      const minimumBoundary = Math.floor(maxChars * 0.6)
+      let boundary = Math.max(candidate.lastIndexOf('\n'), candidate.lastIndexOf('。'), candidate.lastIndexOf('！'), candidate.lastIndexOf('？'), candidate.lastIndexOf('；'))
+      if (boundary + 1 >= minimumBoundary) end = start + boundary + 1
+    }
+    ranges.push({ start, end })
+    start = end
+  }
+  return ranges
+}
+
+function sourceEventRanges(source, text) {
+  const ranges = []
+  let cursor = 0
+  for (const event of source.events || []) {
+    const eventText = String(event?.text || '')
+    if (!eventText) continue
+    let start = text.indexOf(eventText, cursor)
+    if (start < 0) start = text.indexOf(eventText)
+    if (start < 0) continue
+    const end = start + eventText.length
+    ranges.push({ start, end, seq: event.seq })
+    cursor = end
+  }
+  return ranges
+}
+
+export function chunkSourceText(source, maxChars = DEFAULT_SOURCE_CHUNK_CHARS) {
   const text = String(source?.text || '')
   if (!text) return [{ text: '', sourceRefs: [] }]
+  const limit = Math.max(1, Number(maxChars) || DEFAULT_SOURCE_CHUNK_CHARS)
+  const units = paragraphRanges(text).flatMap((range) => (
+    range.end - range.start > limit ? splitOversizedRange(text, range, limit) : [range]
+  ))
+  const ranges = []
+  let current = null
+  for (const unit of units) {
+    if (!current) {
+      current = { ...unit }
+      continue
+    }
+    if (unit.end - current.start <= limit) {
+      current.end = unit.end
+    } else {
+      ranges.push(current)
+      current = { ...unit }
+    }
+  }
+  if (current) ranges.push(current)
+
+  const eventRanges = sourceEventRanges(source, text)
   const chunks = []
-  let start = 0
-  while (start < text.length) {
-    const end = Math.min(text.length, start + maxChars)
+  for (const { start, end } of ranges) {
     const chunkText = text.slice(start, end)
-    const refs = (source.events || [])
-      .filter((event) => event.text && text.indexOf(event.text, start) >= start && text.indexOf(event.text, start) < end)
+    const refs = eventRanges
+      .filter((event) => event.start < end && event.end > start)
       .map((event) => ({ sessionId: source.sessionId, eventSeqs: [event.seq] }))
     chunks.push({ text: chunkText, sourceRefs: refs })
-    start = end
   }
   return chunks
 }

package/lib/workspace-storage.js

@@ -151,7 +151,7 @@ export class WorkspaceStorage {
     }
   }
 
-  async saveBundle({ cwd, expectedRevision = 0, generationId, sourceSessionIds, sourceSessions, sourceWarnings, prompt, strict, outputMode, model, mindMap, knowledgeGraph }) {
+  async saveBundle({ cwd, expectedRevision = 0, generationId, sourceSessionIds, sourceSessions, failedSources, sourceWarnings, generationTimeline, prompt, strict, outputMode, model, mindMap, knowledgeGraph }) {
     const normalizedCwd = normalizeWorkspacePath(cwd)
     const key = workspaceKey(normalizedCwd)
     const previous = this.locks.get(key) || Promise.resolve()
@@ -174,6 +174,17 @@ export class WorkspaceStorage {
           skippedRefs: Math.max(0, Number(sourceWarnings?.skippedRefs) || 0),
           skippedItems: Math.max(0, Number(sourceWarnings?.skippedItems) || 0)
         },
+        failedSources: Array.isArray(failedSources) ? failedSources.map((source) => ({
+          sessionId: String(source?.sessionId || ''),
+          title: shortText(source?.title, 200),
+          error: shortText(source?.error, 500)
+        })).filter((source) => source.sessionId) : [],
+        generationTimeline: Array.isArray(generationTimeline) ? generationTimeline.slice(-80).map((item, index) => ({
+          id: Number(item?.id) || index + 1,
+          at: Number(item?.at) || this.now(),
+          type: shortText(item?.type, 40) || 'info',
+          message: shortText(item?.message, 500)
+        })) : [],
         promptSummary: shortText(prompt, 500),
         strict: strict === true,
         outputMode: String(outputMode || 'both'),

package/package.json

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