dsh-data-domain-knowledge 0.1.0-alpha.2 → 0.1.0-alpha.4

package/src/client/arch/model.ts

@@ -21,7 +21,7 @@
  */
 
 import {
-  NODE_LANES, NODE_META, NODE_STATUS_LABEL, NODE_STATUS_SHORT, NODE_STATUS_TONE, memoryCountOf, nodeMetrics, sourceCountOf,
+  NODE_LANES, NODE_META, NODE_STATUS_LABEL, NODE_STATUS_SHORT, memoryCountOf, nodeMetrics, sourceCountOf,
   type KnowledgeStats, type LaneId, type LaneMeta, type NodeId, type NodeMetric, type NodeStatus,
 } from '../architecture.tsx'
 import { PROBLEM_BASE_NOTE, PROBLEM_DOMAINS, type ProblemDomain } from '../problem-domains.ts'
@@ -40,12 +40,54 @@ export const GUTTER = 116
 export const NODE_W = 180
 /** 卡片高度要装下四层：标题行、两行说明、统计行。 */
 export const NODE_H = 96
-/** 堆叠节点（Table/Notebook、情节/操作记忆）用略矮的规格。 */
+/** 竖排两到三张时用的规格。两张那一列装得下计数行，三张那一列装不下。 */
 export const NODE_H_STACKED = 80
+/**
+ * 一列竖排**三张**时的卡片高度（2026-09-26 加画布带来的第三张）。
+ *
+ * 它比两排矮一档，不是审美选择，是算术：三张要挤进同一条带，而带高是全图共享的。
+ * 内容也正好只差一行 —— 这一列的 Table / Notebook / 画布都没有计数行，两行文字
+ * （标题 + 说明）加 8px 上下内边距正好 52px；而情节 / 操作记忆两张带计数行，需要 73px，
+ * 所以它们仍用 80。写死一个高度给两种内容，不是裁掉计数就是白留一条空带。
+ */
+export const NODE_H_STACKED_TRIO = 52
 export const COL_GAP = 32
-/** 堆叠两个节点时，各自中心相对带中心线的偏移。80 + 2×47 = 174 = 内容区高度，
- * 且 80 ≤ 2×47 —— 这是两张卡不重叠的条件，不是审美偏好。 */
-export const STACK_OFFSET = 47
+/**
+ * 竖排卡片之间的间隙。**它与卡片高度一起决定列间距**，所以只写一处：
+ * 两张那一列 = 2×80 + 14 = 174，三张那一列 = 3×52 + 2×14 = 184。
+ */
+export const STACK_GAP = 14
+/**
+ * **先写「哪一列竖排几张」，再算带高。**
+ *
+ * 带高由最高的一列决定（`CONTENT_H`），而带高又决定画布高度 —— 都是模块初始化的常量，
+ * 所以这张表必须在它们之前出现。它与 `ARCH_SLOTS` 里的 `stack` 序号是同一件事的两面，
+ * 测试会断言两者一致（一处写三张、另一处只放两张是最容易犯的错，而且肉眼看不出来）。
+ */
+export const STACK_COLUMNS: ReadonlyArray<{ lane: number; col: number; count: number }> = [
+  { lane: 0, col: 4, count: 3 },
+  { lane: 2, col: 3, count: 2 },
+]
+
+/** 一列竖排 `count` 张时的卡片高度。 */
+export function stackHeight(count: number): number {
+  return count >= 3 ? NODE_H_STACKED_TRIO : NODE_H_STACKED
+}
+
+/**
+ * 一列竖排 `count` 张时需要的内容区高度 = `count × 卡高 + (count-1) × 间隙`。
+ *
+ * 卡片在列内**等距**排：第 i 张的中心偏移 = (i - (count-1)/2) × (卡高 + 间隙)。
+ * 所以最外两张的外沿正好落在 ±CONTENT_H/2 上，不多不少。
+ */
+export function columnHeight(count: number): number {
+  return count <= 0 ? 0 : count * stackHeight(count) + (count - 1) * STACK_GAP
+}
+
+/** 一列竖排 `count` 张时，第 `index` 张相对带中心线的偏移。 */
+export function stackOffset(count: number, index: number): number {
+  return (index - (count - 1) / 2) * (stackHeight(count) + STACK_GAP)
+}
 /** 带名条的高度：一枚字母徽标 + 链路名。 */
 export const LANE_HEAD_H = 30
 /**
@@ -62,8 +104,8 @@ export const LANE_HEAD_W = 224
  */
 export const BAND_GAP = 24
 export const LANE_PAD = 12
-/** 带的内容区高度：按最高的那种排布（两个堆叠节点）定，单节点在其中居中。 */
-export const CONTENT_H = NODE_H_STACKED + 2 * STACK_OFFSET
+/** 带的内容区高度：**由最高的那一列决定**（三张 52 的那列 = 184），单节点在其中居中。 */
+export const CONTENT_H = Math.max(...STACK_COLUMNS.map(column => columnHeight(column.count)))
 /** 带高 = 带名条 + 上下内边距 + 内容区。三条带等高，网格才对得齐。 */
 export const BAND_H = LANE_HEAD_H + LANE_PAD + CONTENT_H + LANE_PAD
 /** 两条带的上沿间距 = 带高 + 通道。 */
@@ -140,15 +182,16 @@ export interface ArchBox { x: number; y: number; width: number; height: number }
  * 出来，经过记忆与质量门，最后回到最左边的「资金化」—— 反向流不是排版花招，
  * 它就是闭环的方向，也是 A→C 那条连线能画得短的原因。
  */
-interface Slot { lane: number; col: number; stack?: 'upper' | 'lower' }
+interface Slot { lane: number; col: number; /** 在竖排里的序号（0 起）。见 `STACK_COLUMNS`。 */ stack?: number }
 
 export const ARCH_SLOTS: Record<NodeId, Slot> = {
   conversation: { lane: 0, col: 0 },
   intent: { lane: 0, col: 1 },
   runtime: { lane: 0, col: 2 },
   answer: { lane: 0, col: 3 },
-  'data-sheet': { lane: 0, col: 4, stack: 'upper' },
-  'data-notebook': { lane: 0, col: 4, stack: 'lower' },
+  'data-sheet': { lane: 0, col: 4, stack: 0 },
+  'data-notebook': { lane: 0, col: 4, stack: 1 },
+  'data-canvas': { lane: 0, col: 4, stack: 2 },
 
   'source-raw': { lane: 1, col: 0 },
   compile: { lane: 1, col: 1 },
@@ -159,8 +202,8 @@ export const ARCH_SLOTS: Record<NodeId, Slot> = {
   'funded-value': { lane: 2, col: 0 },
   'daily-update': { lane: 2, col: 1 },
   'memory-quality': { lane: 2, col: 2 },
-  'episodic-memory': { lane: 2, col: 3, stack: 'upper' },
-  'procedural-memory': { lane: 2, col: 3, stack: 'lower' },
+  'episodic-memory': { lane: 2, col: 3, stack: 0 },
+  'procedural-memory': { lane: 2, col: 3, stack: 1 },
   interaction: { lane: 2, col: 4 },
 }
 
@@ -182,14 +225,14 @@ export function isDecoration(id: string): boolean {
 
 export function boxOf(id: NodeId): ArchBox {
   const slot = ARCH_SLOTS[id]
-  const height = slot.stack ? NODE_H_STACKED : NODE_H
+  const column = STACK_COLUMNS.find(item => item.lane === slot.lane && item.col === slot.col)
+  const height = column ? stackHeight(column.count) : NODE_H
   const center = laneCenter(slot.lane)
-  const y = slot.stack
-    ? center + (slot.stack === 'upper' ? -STACK_OFFSET : STACK_OFFSET)
-    : center
+  const y = column ? center + stackOffset(column.count, slot.stack ?? 0) : center
   return { x: columnX(slot.col), y, width: NODE_W, height }
 }
 
+
 // ----------------------------------------------------------------- 连边
 
 /**
@@ -222,6 +265,8 @@ export const ARCH_EDGES: ArchEdge[] = [
   { id: 'a3', source: 'runtime', target: 'answer', kind: 'flow' },
   { id: 'a4', source: 'answer', target: 'data-sheet', kind: 'branch' },
   { id: 'a5', source: 'answer', target: 'data-notebook', kind: 'branch' },
+  // 画布与 Table / Notebook 是同一格的三种输出产物，所以也是同一种边。
+  { id: 'a6', source: 'answer', target: 'data-canvas', kind: 'branch' },
 
   // B · 知识编译与召回链路（写入侧 → 读取侧）
   { id: 'b1', source: 'source-raw', target: 'compile', kind: 'flow' },
@@ -246,6 +291,77 @@ export const ARCH_EDGES: ArchEdge[] = [
   { id: 'x4', source: 'context', target: 'runtime', kind: 'inject', label: 'Context Pack 注入' },
 ]
 
+/**
+ * 「同一个发点出去的两条以上」或「汇进同一个落点的两条以上」的边 —— 它们**走一条总线**。
+ *
+ * ## 为什么不能各走各的（2026-09-26 GUI 反馈）
+ *
+ * 原来 `branch` 用 `router: { type: 'orth' }`。路由器是**每条边各算各的**：它把每条线
+ * 连到「离自己最近的那两个边界点」，于是回答那一格的右边被三条线在三个高度上分别咬开 ——
+ * 一张卡片伸出三根箭头，各自还带一个小台阶。用户的原话是「箭头改成从一个地方出，
+ * 这样样式不好看」。
+ *
+ * ## 判据是**边的邻居**，不是边的种类
+ *
+ * 一个节点只要有两条及以上的同带相邻列连线，那几条就共用一段总线。所以 2026-09-26 把
+ * 画布加成第三张输出产物时，这条规则**没有改一个字** —— 它自己就把新边算了进去。
+ * 反过来若按「`branch` 就走总线」写，多对一的那种（情节 / 操作记忆 → 记忆质量检查，
+ * 那是两条 `flow`）就漏了，而它们看着是同一毛病。
+ *
+ * 跨链路的四条长线不在这里：它们不同带，本来就有自己的正交路由与避障。
+ */
+const BUS_EDGE_IDS: ReadonlySet<string> = (() => {
+  const local = ARCH_EDGES.filter(edge => {
+    const from = ARCH_SLOTS[edge.source]
+    const to = ARCH_SLOTS[edge.target]
+    return from !== undefined && to !== undefined && from.lane === to.lane && Math.abs(from.col - to.col) === 1
+  })
+  const out = new Map<string, number>()
+  const into = new Map<string, number>()
+  for (const edge of local) {
+    out.set(edge.source, (out.get(edge.source) ?? 0) + 1)
+    into.set(edge.target, (into.get(edge.target) ?? 0) + 1)
+  }
+  return new Set(local
+    .filter(edge => (out.get(edge.source) ?? 0) > 1 || (into.get(edge.target) ?? 0) > 1)
+    .map(edge => edge.id))
+})()
+
+/** 这条边是否参与总线（测试与 `toGraphData` 读它，两处不可能各算一遍）。 */
+export function isBusEdge(edgeId: string): boolean {
+  return BUS_EDGE_IDS.has(edgeId)
+}
+
+/**
+ * 一条总线上的**拐点**。给 G6 的 `controlPoints`，它就按我们算的点画，不再自己找出口。
+ *
+ * 从发点出来先汇到一个 x（两条列之间的中线），再竖直走到目标那一行，最后横向进盒子：
+ *
+ * ```
+ *  回答 ──┐                      拐点 1 把三条边锁在同一个 y（发点的中心），
+ *         ├──▶ Table             所以三根箭头从**同一个点**出来；
+ *         ├──▶ Notebook          拐点 2 各自落在目标那一行。
+ *         └──▶ 画布
+ * ```
+ *
+ * 一对多是「汇出去再分开」，多对一是「各自汇过来再进同一个点」—— 同一组拐点同时满足
+ * 两种读法：前者共用第一段，后者共用最后一段。
+ *
+ * 返回 `null` 表示不必给拐点：不在总线上，或者发点与落点本来就同高（那时一条直线就是
+ * 总线，它的出口与总线的出口是同一个点）。
+ */
+export function busControlPoints(edge: ArchEdge): Array<[number, number]> | null {
+  if (!BUS_EDGE_IDS.has(edge.id)) return null
+  const from = boxOf(edge.source)
+  const to = boxOf(edge.target)
+  if (Math.abs(from.y - to.y) < 0.5) return null
+  const goingRight = to.x > from.x
+  const startX = from.x + (goingRight ? NODE_W / 2 : -NODE_W / 2)
+  const endX = to.x + (goingRight ? -NODE_W / 2 : NODE_W / 2)
+  const trunkX = (startX + endX) / 2
+  return [[trunkX, from.y], [trunkX, to.y]]
+}
+
 /**
  * 边的外观。灰 / 蓝两档，没有第三档色相。
  *
@@ -316,21 +432,39 @@ function escapeHtml(value: string): string {
 /**
  * 一张节点卡片的 DOM 字符串。
  *
- * 用 G6 的 HTML 节点（而不是 canvas 文本）是因为这张卡片要写**四层信息**：
- * 标题、一句话说明、数据统计、实现状态。canvas 文本只有一种字号与字重，
- * 四层挤成一样大就等于没有层次。
+ * 用 G6 的 HTML 节点（而不是 canvas 文本）是因为这张卡片要写**三层信息**：
+ * 标题、一句话说明、数据统计。canvas 文本只有一种字号与字重，三层挤成一样大
+ * 就等于没有层次。
  *
  * 关键样式全部内联：卡片是画布里的 DOM，不保证和插件样式表同时到位，
  * 靠类名会得到一张没有边框的白块。类名只用于选中态这类可选增强。
  *
- * 视觉上是「白卡 + 1px 发丝边 + 6px 圆角 + 几乎看不见的投影」。状态不是一块色底，
- * 而是一枚小圆点加状态文字 —— 四张卡并排时，色底会比标题还响。
+ * 视觉上是「白卡 + 1px 发丝边 + 6px 圆角 + 几乎看不见的投影」。
+ *
+ * ## 状态字（宿主 / 待实现 / 已实现）从卡片上撤掉了（2026-09-26）
+ *
+ * 它原来在每一张卡的右上角：一枚小圆点 + 一个词。撤掉的理由不是「不好看」，
+ * 是**它同时出现十六次，于是十几张卡片的标题全被它挤窄**（`shortTitle` 就是为它
+ * 让位而存在的），而它说的是同一件事的四个值。
+ *
+ * 实现状态没有丢，只是换了三个更合适的地方：
+ * - 每条链路的名条上写着**逐带计数**（`A 已实现 1 · 宿主 5 · …`）——「整条链路做完了没」
+ *   本来就比「这一格做完了没」更接近用户要问的。
+ * - 点开任意节点，浮层标题旁就是同一档状态（`Badge` + `statusNote` 依据）。
+ * - 卡片自身的 `title` 悬停仍然给出完整状态依据，无障碍列表也照旧逐节点列出。
  */
 export function cardHtml(id: NodeId, metrics: NodeMetric[], selected = false): string {
   const meta = NODE_META[id]
   const lane = LANE_PALETTE[meta.lane]
-  const status = NODE_STATUS_TONE[meta.status]
-  const compact = Boolean(ARCH_SLOTS[id].stack)
+  const slot = ARCH_SLOTS[id]
+  const column = STACK_COLUMNS.find(item => item.lane === slot.lane && item.col === slot.col)
+  const compact = column !== undefined
+  /**
+   * 竖排卡片的内边距**收到 8px**：三张那一列的高度是 52（见 `NODE_H_STACKED_TRIO`），
+   * 而「标题 16 + 间隙 5 + 说明 15」已经占掉 36 —— 上下各 8 正好 52，各 10 就溢出 4px。
+   * 这一列没有计数行，所以省下的就是这一圈的空气。
+   */
+  const padY = compact ? 8 : 10
   /**
    * 卡片上最多两个计数，而且是**一行纯文字**，不是会自动换行的 chip 组。
    *
@@ -342,11 +476,10 @@ export function cardHtml(id: NodeId, metrics: NodeMetric[], selected = false): s
   const chips = metrics.slice(0, 2).map(metric =>
     `<span style="display:inline-flex;align-items:baseline;gap:3px;white-space:nowrap;font-size:10px;line-height:16px;color:${INK_FAINT}">${escapeHtml(metric.label)}<b style="color:${INK};font-weight:600;font-variant-numeric:tabular-nums">${escapeHtml(metric.value)}</b></span>`).join('')
   // 悬停给出完整名字与状态依据：卡片上的名字可能被省略号截短，但信息不能丢。
-  return `<div class="tita-archCard${selected ? ' tita-archCardOn' : ''}" title="${escapeHtml(`${meta.title} —— ${meta.statusNote}`)}" style="box-sizing:border-box;width:100%;height:100%;display:flex;flex-direction:column;gap:5px;padding:10px 11px;border-radius:6px;background:${SURFACE};border:1px solid ${selected ? lane.accent : RULE};box-shadow:${selected ? `0 0 0 3px ${lane.soft}` : '0 1px 2px rgba(16,24,40,.04)'};font-family:${FONT};overflow:hidden">
+  return `<div class="tita-archCard${selected ? ' tita-archCardOn' : ''}" title="${escapeHtml(`${meta.title} —— ${meta.statusNote}`)}" style="box-sizing:border-box;width:100%;height:100%;display:flex;flex-direction:column;gap:5px;padding:${padY}px 11px;border-radius:6px;background:${SURFACE};border:1px solid ${selected ? lane.accent : RULE};box-shadow:${selected ? `0 0 0 3px ${lane.soft}` : '0 1px 2px rgba(16,24,40,.04)'};font-family:${FONT};overflow:hidden">
   <div style="display:flex;align-items:center;gap:6px">
     <span style="width:6px;height:6px;border-radius:999px;background:${lane.accent};flex:0 0 auto"></span>
     <strong style="font-size:12.5px;font-weight:600;color:${INK};line-height:1.25;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">${escapeHtml(meta.shortTitle ?? meta.title)}</strong>
-    <span style="margin-left:auto;flex:0 0 auto;display:inline-flex;align-items:center;gap:4px;font-size:10px;font-weight:600;color:${status.text}"><i style="width:5px;height:5px;border-radius:999px;background:${status.dot}"></i>${escapeHtml(NODE_STATUS_SHORT[meta.status])}</span>
   </div>
   <div style="font-size:11px;line-height:1.4;color:${INK_MUTED};display:-webkit-box;-webkit-line-clamp:${compact ? 1 : 2};-webkit-box-orient:vertical;overflow:hidden">${escapeHtml(meta.subtitle)}</div>
   ${chips ? `<div style="margin-top:auto;display:flex;align-items:baseline;gap:10px;overflow:hidden">${chips}</div>` : ''}
@@ -526,7 +659,7 @@ function decorations(): ArchNodeDatum[] {
 
 /** 带上按阅读顺序排好的节点（自进化带是反向的，由 ARCH_SLOTS 的列号决定）。 */
 export function nodesOfLane(lane: number): NodeId[] {
-  const rank = (slot: Slot): number => slot.stack === 'upper' ? -1 : slot.stack === 'lower' ? 1 : 0
+  const rank = (slot: Slot): number => slot.stack ?? 0
   return (Object.keys(ARCH_SLOTS) as NodeId[])
     .filter(id => ARCH_SLOTS[id].lane === lane)
     .sort((left, right) => ARCH_SLOTS[left].col - ARCH_SLOTS[right].col || rank(ARCH_SLOTS[left]) - rank(ARCH_SLOTS[right]))
@@ -582,6 +715,11 @@ export function toGraphData(stats: KnowledgeStats, version: number, selected: No
       // 正交 + 自动避障：这几条是长线，斜着连会横穿中间的卡片。
       style.radius = 10
       style.router = { type: 'shortest-path', enableObstacleAvoidance: true, offset: 14, gridSize: 8 }
+    } else if (busControlPoints(edge) !== null) {
+      // 总线上的边：拐点是我们算的，**不要路由器** —— 路由器每条边各找一个出口，
+      // 那正是「三根箭头从三个高度出来、各自还带一个小台阶」的原因。
+      style.radius = 8
+      style.controlPoints = busControlPoints(edge)
     } else if (edge.kind === 'branch') {
       style.radius = 8
       style.router = { type: 'orth', padding: 14 }

package/src/client/architecture.css

@@ -16,20 +16,26 @@
 
 /* ---------------------------------------------------------------- 版式 */
 
-/* **一个表面。** 画布拥有边框、圆角、投影；详情浮层浮在它里面，
-   不另起一列、不另起一张卡。 */
+/* **一块画布，带一圈发丝线。**
+   0042 撤过这圈边框（那时它同时接管视口与滚动条，两种语汇缝在一起，两头都不像）。
+   0050 又把它加回来：现在这一栏既不拖也不滚，「图在哪」不再有歧义，一圈边框正好
+   回答「这张图画在哪一块里」—— 没有它，图与面板底色之间连边界都没有。
+   高度由面板给（`flex: 1 1 auto`），底色显式给一个：全屏时这一块要自己不透明，
+   否则背后是浏览器的黑底。全屏是独占一屏，那一档不要圆角（贴边更像全屏）。 */
 .tita-archStage {
   position: relative;
   display: flex;
   min-width: 0;
+  min-height: 0;
+  flex: 1 1 auto;
   flex-direction: column;
   border: 1px solid var(--tita-line);
   border-radius: 10px;
-  background: var(--tita-surface);
+  background: var(--tita-canvas);
   overflow: hidden;
 }
-
 .tita-archStage:fullscreen { border: 0; border-radius: 0; }
+
 .tita-archStage:fullscreen .tita-archPane { flex: 1 1 auto; min-height: 0; }
 
 /* 画布那一列。**浮层的定位上下文是它**，不是整块表面 —— 否则右上角那排操作
@@ -65,18 +71,27 @@
 
 /* 画布容器：**画布永远是设计尺寸，缩放由板上的 transform 承担**。
    这张画布设计宽 1172px、高 1132px（三条链路 + 一条问题域带），宿主右侧栏只有
-   380–840px。所以外层不去「适配」画布，而是按缩放比把整块板缩下来：`fit` 档下板宽
-   正好等于栏宽（没有可滚的余量），`1:1` 档下板保持设计尺寸、由滚动条承载。
+   380–840px。所以外层不去「适配」画布，而是按缩放比把整块板缩下来。
    缩放比由组件按设计常量算出（`CANVAS_WIDTH/HEIGHT`），不写进 CSS，避免两处各写一份。 */
-.tita-archScroll { width: 100%; min-width: 0; overflow: auto; background: var(--tita-surface); }
-.tita-archStage:fullscreen .tita-archScroll {
+.tita-archScroll { width: 100%; min-width: 0; overflow: auto; background: var(--tita-canvas); }
+/* 舞台模式：**整图居中摆好**（0050）。
+   `fit: 'both'` 之下图永远完整落在框里，所以「适应」档既没有可滚余量、也不需要拖拽；
+   `safe center` 而不是 `center`：1:1 档放不下时，普通居中会把左上角推到视口外
+   且滚不回去，`safe` 让它退回从左上角开始、由滚动条负责其余部分。
+   `overflow: auto` 保留 —— 1:1 档的出路就是它。 */
+.tita-archScrollStage {
+  display: flex;
   flex: 1 1 auto;
   min-height: 0;
-  /* 全屏下 `fit` 档两边都可能有余量，居中；`safe` 保证 1:1 档溢出时左上角不被裁掉。 */
-  display: flex;
   align-items: safe center;
   justify-content: safe center;
 }
+/* **按比例定尺寸的框。** `transform` 不改布局尺寸，只写 transform 的话滚动区永远是
+   1172×1132 —— 「适应」档缩到 0.32 也照样能往虚空里拖出 770px。框的尺寸等于缩完的
+   尺寸，于是可平移的范围正好是图的边界：适应档只有纵向，1:1 档两个方向。 */
+.tita-archFrame { position: relative; flex: 0 0 auto; overflow: hidden; }
+/* 全屏：同一套居中规则（居中已经写在 `.tita-archScrollStage` 上），这里只把高度交回面板。 */
+.tita-archStage:fullscreen .tita-archScroll { flex: 1 1 auto; min-height: 0; }
 .tita-archBoard { min-width: 0; flex: 0 0 auto; }
 .tita-archCanvas { width: 100%; height: 100%; min-width: 0; }
 

package/src/client/architecture.tsx

@@ -12,7 +12,7 @@
 
 import {
   BarChart3, Box, BrainCircuit, ClipboardCheck, Clock3, Database, FileCode2, FileText,
-  Gauge, GitBranch, HardDrive, Layers3, MessageCircle, RefreshCw, Search, Share2,
+  Gauge, GitBranch, HardDrive, Layers3, MessageCircle, PenTool, RefreshCw, Search, Share2,
   Table2, UserRound,
 } from '@tita-data-agent/ui/icons'
 import type { LucideIcon } from '@tita-data-agent/ui/icons'
@@ -37,11 +37,28 @@ export type PanelTab = 'overview' | 'intent' | 'knowledge' | 'attribution' | 'me
  * 合并不是因为「两个阶段变成一个」—— 它们在流水线上仍然是两步。合的是**界面**：
  * 这两栏回答的是同一个问题（「跑一次真实召回，结果长什么样」），而且分成两栏时
  * 用户必须先跑「召回」再切到「重排」才能看到同一次运行的全貌，两栏各自还有一个
- * 测试按钮和一套 topK/topN 输入。一栏里从上到下就是一条链：三路各自命中什么 →
+ * 测试按钮和一套 topK/topN 输入。一栏里从上到下就是一条链：两路各自命中什么 →
  * 融合后的排序 → cross-encoder 丢了多少 → 最终进上下文的 topN。
  */
 export type KnowledgeTab = 'source-raw' | 'wiki' | 'graph' | 'recall'
 
+/**
+ * 「回答 / 数据工具」这个节点能打开的**工作区页面**。
+ *
+ * 三个 kind 各由一个别的插件注册（`dsh-data-table` / `dsh-data-notebook` /
+ * `dsh-data-excalidraw`）—— 这里只写 kind 字符串，不 import 它们的代码，所以某个
+ * 插件没装时按钮依然在，宿主会就着这个 kind 显示「没有页面类型能打开它」。
+ *
+ * 联合写在一处：`NodeLogicPanel` 用它画按钮、`KnowledgePanel` 转发它、客户端入口
+ * 把它交给宿主的 `openTab`。三处各写一份，迟早出现「面板多了一个按钮，入口的类型
+ * 还不认它」——加画布这次就正好会踩到。
+ *
+ * 「回答 / 数据工具」的输出产物就是这三样：可编辑表格、可复现 Notebook、可编辑画布。
+ * 画布是 2026-09-26 补上的第四个出口：Excalidraw 画布已经在宿主里跑着，而这张架构图
+ * 上原先只列了 Table 与 Notebook，读起来像是「Agent 出不了图」。
+ */
+export type WorkspaceTabKind = 'data-sheet' | 'data-notebook' | 'data-excalidraw'
+
 /**
  * 五个分栏的顺序、名字与图标。**定义在这里而不是在 `KnowledgeBaseTab` 里**：
  * 渲染它的地方有两个 —— 面板外壳顶部那一条分栏 tab，和知识库内容本身。
@@ -83,7 +100,7 @@ export const NODE_LANES: LaneMeta[] = [
 ]
 
 export type NodeId =
-  | 'conversation' | 'intent' | 'runtime' | 'answer' | 'data-sheet' | 'data-notebook'
+  | 'conversation' | 'intent' | 'runtime' | 'answer' | 'data-sheet' | 'data-notebook' | 'data-canvas'
   | 'source-raw' | 'compile' | 'build' | 'recall' | 'context'
   | 'interaction' | 'episodic-memory' | 'procedural-memory' | 'memory-quality' | 'daily-update' | 'funded-value'
 
@@ -103,9 +120,12 @@ export const NODE_STATUS_LABEL: Record<NodeStatus, string> = {
 }
 
 /**
- * 卡片上的状态文字。**只有「宿主提供」需要缩短** —— 它是四个字，而卡片右侧那点宽度
- * 是从标题里借的：省下两个字，`记忆整理与质量检查` 这种九字标题才放得下。
- * 面板、无障碍列表和状态记录读的仍是完整措辞，缩的只是图上那一处。
+ * 带名条上的状态文字（`A 宿主 5 · 部分实现 1 · …`）。**只有「宿主提供」需要缩短** ——
+ * 它是四个字，而带名条右侧那条计数是十几个字挤在一行里。
+ * 面板、卡片悬停与无障碍列表读的仍是完整措辞，缩的只是带名条那一处。
+ *
+ * 它原来还负责卡片右上角那枚状态字；2026-09-26 那枚撤掉了（同时出现十六次，
+ * 把每张卡的标题都挤窄），卡片上的状态现在只在悬停的 `title` 里。
  */
 export const NODE_STATUS_SHORT: Record<NodeStatus, string> = {
   ...NODE_STATUS_LABEL,
@@ -113,25 +133,17 @@ export const NODE_STATUS_SHORT: Record<NodeStatus, string> = {
 }
 
 /**
- * 状态色：**四档只用三种颜色，而且只在文字上**。
- *
- * 「已实现」是常态，所以它拿绿（`--tita-success`，白底 5.7:1）；「部分实现」是唯一需要
- * 人动手的一档，拿琥珀（`--tita-warning`，5.4:1）；「待实现」和「宿主提供」都不是我们的
- * 进度，拿两级灰：文字分两级（faint / muted），圆点合并成 faint 一档 —— 共享词表里只有
- * 三级墨色，而这两档圆点本来就只差一格，区分它们的是文字。
- * 四档不各配一个背景色药丸 —— 那样四张卡片并排时，颜色比标题还响。
+ * 状态色表**已删除**（2026-09-26），连同它最后一个消费者。
  *
- * `fill` 仍然保留，但它只用在**需要一整块底**的地方（例如图例上的小色块）；
- * 卡片上的状态是「一个小圆点 + 状态文字」，不是一块色底。
+ * 它服务的是卡片右上角那枚「小圆点 + 状态字」。那枚撤掉之后，画布上唯一的状态读数
+ * 是问题域带名条里一行灰字计数（`A 宿主 5 · 部分实现 1 · …`）—— 计数不分色。
+ * 也就是说四档状态在画布上不再有「颜色」这个说法，留下一张 `fill/text/dot` 的表
+ * 只会让人以为某处还在按它上色。
  *
- * 这些值进的是 G6 **HTML 节点**的 innerHTML，也就是真实 DOM，所以可以用共享令牌。
+ * 状态**照旧要如实标注**，只是改由这三处承担：带名条的逐带计数、点开节点后浮层标题
+ * 旁的 `Badge`（`NodeLogicPanel` 的 `STATUS_BADGE`）、以及卡片悬停 `title` 与无障碍
+ * 列表里的 `statusNote` 依据。
  */
-export const NODE_STATUS_TONE: Record<NodeStatus, { fill: string; text: string; dot: string }> = {
-  live: { fill: 'var(--tita-tone-green-tint)', text: 'var(--tita-success)', dot: 'var(--tita-success)' },
-  partial: { fill: 'var(--tita-tone-amber-tint)', text: 'var(--tita-warning)', dot: 'var(--tita-warning)' },
-  planned: { fill: 'var(--tita-surface-muted)', text: 'var(--tita-ink-faint)', dot: 'var(--tita-ink-faint)' },
-  host: { fill: 'var(--tita-surface-muted)', text: 'var(--tita-ink-muted)', dot: 'var(--tita-ink-faint)' },
-}
 
 /** 一个执行步骤。/  `state` 决定面板里显示对勾、半勾还是空心圈。 */
 export interface NodeStep {
@@ -145,6 +157,10 @@ export interface NodeMeta {
   /**
    * 卡片上的短名。只给放不进 180px 卡片的标题用 —— 卡片是示意图，它旁边还站着
    * 十来个同宽的字；面板里写的始终是完整名字，卡片的 `title` 悬停也给出完整名字。
+   *
+   * 右上角那枚状态字撤掉之后（2026-09-26），卡片的标题行确实空出了一截。这里**没有**
+   * 因此把短名换回全名：短名当初是按「180px 里读得顺」挑的，不只是为了躲开那枚状态字，
+   * 而且面板与悬停里全名一直都在。哪条短名读起来不如全名，单独改那一条即可。
    */
   shortTitle?: string
   subtitle: string
@@ -204,13 +220,13 @@ icon: Box, lane: 'interaction',
   },
   answer: {
     title: '回答 / 数据工具', subtitle: '生成结果、可视化与方案',
-    detail: '输出解释、引用和数据结果，并把结构化结果继续交给 Table 或 Notebook 处理。',
-    input: '模型回答 + 工具返回值', output: '可读回答、可编辑表格、可复现 Notebook',
+    detail: '输出解释、引用和数据结果，并把结构化结果继续交给 Table、Notebook 或画布处理。',
+    input: '模型回答 + 工具返回值', output: '可读回答、可编辑表格、可复现 Notebook、可编辑画布',
     steps: [
       { label: '回答与引用', detail: '每一条结论都能指回 wiki 与 SourceRaw', state: 'done' },
-      { label: '转交数据工具', detail: '结构化结果可继续在 Table / Notebook 里加工', state: 'done' },
+      { label: '转交数据工具', detail: '结构化结果可继续在 Table / Notebook / 画布里加工', state: 'done' },
     ],
-    status: 'host', statusNote: '回答渲染与 Table / Notebook 由宿主工作区提供。',
+    status: 'host', statusNote: '回答渲染与 Table / Notebook / 画布由宿主工作区提供。',
 icon: BarChart3, lane: 'interaction',
   },
   'data-sheet': {
@@ -229,6 +245,14 @@ icon: Table2, lane: 'interaction',
     status: 'host', statusNote: '属于 `dsh-data-notebook` 插件，这里只画调用关系。',
 icon: FileCode2, lane: 'interaction',
   },
+  'data-canvas': {
+    title: '画布', subtitle: '生成 / 编辑 Excalidraw 画布',
+    detail: '把结构化结果画成一张可继续手工编辑的画布：架构草图、流程、方案对比。它是「输出产物」里唯一能被人接着改的那一种。',
+    input: '结构化结果 / 画布指令', output: '可编辑的画布文件与导出图',
+    steps: [{ label: '打开画布面板', detail: '由宿主的 Excalidraw 插件承载', state: 'done' }],
+    status: 'host', statusNote: '属于 `dsh-data-excalidraw` 插件，这里只画调用关系。',
+icon: PenTool, lane: 'interaction',
+  },
 
   'source-raw': {
     title: 'SourceRaw', subtitle: '原始可追溯文档',
@@ -248,12 +272,12 @@ icon: Database, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'source-raw',
     detail: '把 SourceRaw 按主题聚合为 wiki 卡片，并切分出召回单元 wikiNotes。类型与名称一起定，判重按 slug。',
     input: 'SourceRaw 文档 + Wiki 类型注册表', output: 'wiki 卡片（含版本）+ 可召回的 wikiNotes',
     steps: [
-      { label: 'Pass 0 · 候选抽取', detail: '从正文标题、[[链接]]、frontmatter 与显式 candidates 抽实体 / 概念 / 关系，类型 + 名称 + 证据一起定', state: 'done' },
-      { label: '归一 · 与库内判重', detail: '按 slug 与别名比对，同指一物就复用（合并 source_refs），related ≠ same', state: 'done' },
-      { label: '落卡 · 按 schema 写入', detail: 'write_knowledge_card 校验必填小节 / 字段，命中则增量合并', state: 'done' },
-      { label: 'Finalize · 索引与质检', detail: '索引页、死链、交叉链接与三层质检，不调模型', state: 'partial' },
+      { label: '抽取实体', detail: '模型按每个 wiki 类型的必填小节与字段抽实体（规则抽取兜底：正文标题、[[链接]]、frontmatter candidates）', state: 'done' },
+      { label: '合并实体', detail: '按 entityId / title / aliases 比对，同指一物就追加正文与 source_refs，related ≠ same', state: 'done' },
+      { label: '写入 wiki', detail: '命中则增量追加，未命中则新建；缺必填小节 / 字段也照写，只标成待补', state: 'done' },
+      { label: '编译结果', detail: '索引页、断链、相关卡片与三层质检，不调模型', state: 'done' },
     ],
-    status: 'partial', statusNote: 'Pass 0 抽取与归一判重已实现（规则抽取，不调模型：候选写进 02_wiki 后仍需人复核）；落卡已实现。Finalize 的索引页 / 死链 / 交叉链接还缺，所以这一格仍是「部分实现」。',
+    status: 'live', statusNote: '四段都已实现：按 schema 抽实体、判重合并、直接入库，收尾段写索引页与相关卡片并检查断链（模型不可用时退回规则抽取，此时正文按小节切）。入库后的 review 与备注在卡片的预览侧栏里。',
 icon: RefreshCw, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'wiki',
   },
   build: {
@@ -270,15 +294,15 @@ icon: RefreshCw, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'wiki',
 icon: HardDrive, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'graph',
   },
   recall: {
-    title: '召回', subtitle: 'wikiNotes 三路召回（关键词 / 向量 / 知识图谱）',
-    detail: '对 wikiNotes 做三路召回：关键词、向量和知识图谱（沿 wiki 链接关系扩展），三路融合后取 topK，再解析各自的父级 wiki。',
+    title: '召回', subtitle: 'wikiNotes 两路召回（关键词 / 向量）',
+    detail: '对 wikiNotes 做两路召回（关键词、向量），融合后取 topK；知识图谱不给候选，只给已在候选池里的条目加权。',
     input: '查询语句 + topK + 路线', output: '带命中路线与得分的 wikiNotes',
     steps: [
-      { label: '三路并行召回', detail: 'FTS 关键词、向量近邻、图谱 1 跳扩展', state: 'done' },
+      { label: '两路并行召回', detail: 'FTS 关键词 + 向量近邻（图谱只加权，不给候选）', state: 'done' },
       { label: '融合与截断', detail: '按融合分数排序取 topK，逐条标明是哪一路命中的', state: 'done' },
       { label: '回溯父级 wiki', detail: '每条 wikiNote 通过 wikiId 解析回权威卡片', state: 'done' },
     ],
-    status: 'live', statusNote: '三路召回与召回测试（含命中切片、得分、路线）都在知识库 → 召回重排里可跑。',
+    status: 'live', statusNote: '两路召回与召回测试（含命中切片、得分、路线）都在知识库 → 召回重排里可跑。',
 icon: Search, lane: 'knowledge', tab: 'knowledge', knowledgeTab: 'recall',
   },
   context: {
@@ -391,11 +415,12 @@ export interface KnowledgeStats {
     cardsRemoved?: number
     notesReused?: number
     notesRecompiled?: number
-    /** Pass 0 · 候选抽取 + 归一的诚实计数（0028）。 */
+    /** Pass 0 · 候选抽取 + 归一的诚实计数（0028 / v1.5）。 */
     candidatesExtracted?: number
     candidatesRejected?: number
-    cardsCreated?: number
-    cardsMerged?: number
+    /** v1.5：Pass 0 只提议，不落卡 —— 这两个计数数的是**提议**（原名 cardsCreated / cardsMerged）。 */
+    proposalsCreated?: number
+    proposalsMerged?: number
     relationsExtracted?: number
     relationsDropped?: number
     sourcesExtracted?: number
@@ -417,9 +442,9 @@ export interface KnowledgeStats {
   searchBackend?: string
 }
 
-/** SourceRaw 计数有两个来源：`stats.sourceCount` 与磁盘布局 `01_source_truth`。 */
+/** SourceRaw 计数有两个来源：`stats.sourceCount` 与磁盘布局 `01_source_raw`。 */
 export function sourceCountOf(stats: KnowledgeStats): number {
-  return stats.sourceCount ?? Number(stats.layout?.['01_source_truth'] ?? 0)
+  return stats.sourceCount ?? Number(stats.layout?.['01_source_raw'] ?? 0)
 }
 
 /** wikiNotes 计数在接口里有 `notes` / `units` 两个别名。 */
@@ -504,7 +529,7 @@ export function metricsByNode(stats: KnowledgeStats, version: number): Partial<R
 
 /** 节点在图上出现的顺序：按链路，再按链内阅读顺序。它就是键盘可达列表的顺序。 */
 export const NODE_ORDER: NodeId[] = [
-  'conversation', 'intent', 'runtime', 'answer', 'data-sheet', 'data-notebook',
+  'conversation', 'intent', 'runtime', 'answer', 'data-sheet', 'data-notebook', 'data-canvas',
   'source-raw', 'compile', 'build', 'recall', 'context',
   'interaction', 'episodic-memory', 'procedural-memory', 'memory-quality', 'daily-update', 'funded-value',
 ]