dsh-goal-ledger 0.2.2 → 0.3.0

package/README.md

@@ -41,7 +41,7 @@ embedding 距离衡量的是「目标与输出的字面语义分离度」，有
 DSH 的插件市场读取你**自己配置的索引地址**。本插件已发布到 npm，索引随包提供，在 设置 → 插件 → 发现（Discover）里添加：
 
 ```
-https://unpkg.com/dsh-goal-ledger@0.2.2/market-index.json
+https://unpkg.com/dsh-goal-ledger@0.3.0/market-index.json
 ```
 
 然后在市场里搜索「目标台账」或 `dsh-goal-ledger` 安装即可。
@@ -78,7 +78,7 @@ dsh plugin --profile desktop add file:C:/Project/dsh-goal-ledger
 1. 打开 设置 → 目标台账
 2. 点「开始分析」（首次扫描约几十秒；嵌入打分需要 embedding 凭据）
 3. 切换六个标签页查看：
-   - **漂移场**：光点图，半径 = 离目标多远（见下）
+   - **漂移场**：光点图，一个光点一个目标，半径 = 平均离目标多远（见下）
    - **失败聚类**：按次数排序，点行展开原始错误与出现位置
    - **目标漂移**：按平均距离排序，标注判定档位
    - **漂移轮次**：单轮最漂移的 10 条
@@ -116,17 +116,23 @@ dsh plugin --profile desktop add file:C:/Project/dsh-goal-ledger
 
 ## 漂移场怎么看
 
-灰蓝底、金色光点，Canvas 2D 实时绘制（无图表库，无动画依赖）：
-
-- **中心亮点** = 「最初的目标」。它是标尺的原点，不是一个会话。
-- **每个光点** = 一个目标。**半径就是距离** —— 越靠外，整段会话偏离最初措辞越远。
-- **虚线圈** = 档位阈值 0.35 / 0.50 / 0.65，和表格里的标签是同一套数字，图和数不会互相矛盾。
-- **颜色**：灰蓝 = 聚焦，浅金 = 有偏离，橙金 = 偏题，亮金 = 严重漂移。颜色只强化档位，不额外编码信息。
-- **光点大小** = 该目标经历的轮次数（取对数，防止单个长会话压掉其他点）。
-- **角度没有含义** —— 黄金角螺旋 + 按 goalId 哈希的抖动，只为了不让点叠在一起，并保证同一目标每次渲染位置一致。
-- **悬停**看目标原文、轮次、调用数、失败数。
-
-纯装饰元素（光尘、核心光晕、轨道弧、光点周围的喷溅）都在 `drawField()` 里，和几何布局分开：改观感不用碰布局，改布局不用碰观感。
+Canvas 2D 实时绘制（无图表库，无动画依赖）：
+
+- **中心亮点** = 「最初的目标」，是标尺原点，不是一个会话。
+- **一个光点 = 一个目标**（整段会话的那个目标），**不是一轮对话**。轮次级明细去「漂移轮次」Tab 看。
+- **半径** = 该目标整段会话里**可计分轮次的平均距离**（`meanDistance`）。明确一句：不是最终值、不是最大值；纯工具调用轮次（无文字输出）不参与平均。
+- **虚线圈** = 档位阈值 0.35 / 0.50 / 0.65，数字和档位名（有偏离 / 偏题 / 严重）**直接标在环上**，和表格里的标签是同一套数字。环标签的方位不是写死的，也**不是三环共用**：每个环独立在自己的候选方位里挑代价最小的，并同时避让已放好的环标签 + 严重档的数值标签 + 光点本身 + 12 点接缝。两件事值得记下来：
+  - 31 个目标的真实数据下，**59 个候选方位没有一个能完全不碰光点**（最低代价 302）。环面就那么大，光点铺满之后「完全不重叠」不存在，所以这是择优而不是求解。
+  - 三环共用同一个方位会让它们挤在一根射线上（实测出现过 99° 和 102°，只差 3°，框不相交但看着是一坨）。所以加了一条**方位间隔下限**（`MIN_CHIP_SEP`，约 22°），低于就重罚，把三个环推向不同方向。
+- **颜色四档**，四种可区分色相，不再有两个几乎同色的档位：纯蓝 = 聚焦，青绿 = 有偏离，橙 = 偏题，亮金 = 严重漂移。颜色只强化档位，不额外编码信息。
+- **角度** = 会话开始时间，**顺时针**推进（旧 → 新）。注意是**按开始时间的次序等角分布**，不是按时间间隔比例：真实数据里开始时间跨一周、最小间隔 10ms，按比例映射会把几十个点压在同一根射线上。角度编码**先后顺序**，具体时间点看悬停。12 点方向留了一道**接缝**（虚线楔形），是「最新的点回绕到最旧的点」的地方，图上用 旧 / 新 两个标号标出来了。
+- **光点之间的连线 = 目标与目标之间的相似度**：1 − cos(目标A向量, 目标B向量)。细线 = 同一主题（距离 ≤ 0.42）；亮线 = 几乎同一个目标被重复提问（距离 ≤ 0.18），这种情况上一次的路径通常可以直接复用。这两档边的选取规则在 `src/distance.js` 的 `buildGoalLinks()`（每个目标最多连 3 条最近的边）。连线用的向量就是打分时已经算好的目标向量，不额外调用 embedding。
+- **光点与中心之间不再有装饰性螺旋线**。之前那层曲线不编码任何数据，容易被误读成「对话轮次轨迹」，所以移除了；要看真实轮次轨迹请用「漂移轮次」Tab。
+- **光点大小** = 该目标的轮次数（取对数，防止单个长会话压掉其他点）。
+- **数值标签**：只有严重档（亮金）常驻标数值，其余光点悬停才显示，保证全图规则统一。
+- **悬停** = 目标原文、轮次、调用数、失败数。
+
+纯装饰元素（光尘、核心光晕、核心周围的轨道弧、光点周围的喷溅）与语义层（半径 / 角度 / 连线 / 环标签）在代码里是分开的：装饰集中在 `drawField()`，几何布局在 `layoutPoints()`，改观感不碰布局。**连线与环标签属于语义层，不是装饰**。
 
 ## Embedding 配置
 

package/lib/client.js

@@ -79,10 +79,10 @@ window.__ModuleLoader__.load({
 .gl-table tr:hover td { background:rgba(128,128,128,.06); }
 .gl-num { font-variant-numeric:tabular-nums; white-space:nowrap; }
 .gl-tag { display:inline-block; padding:1px 7px; border-radius:10px; font-size:11px; white-space:nowrap; }
-.gl-tag-red { background:rgba(255,201,77,.20); color:#a8710a; }
-.gl-tag-orange { background:rgba(216,168,96,.20); color:#8f6224; }
-.gl-tag-yellow { background:rgba(148,174,192,.24); color:#41677f; }
-.gl-tag-green { background:rgba(125,156,179,.22); color:#3a5c73; }
+.gl-tag-red { background:rgba(255,210,74,.24); color:#8a6800; }
+.gl-tag-orange { background:rgba(232,148,74,.20); color:#96551c; }
+.gl-tag-yellow { background:rgba(53,214,176,.20); color:#1d7f6a; }
+.gl-tag-green { background:rgba(77,159,254,.18); color:#2f6fb8; }
 .gl-tag-grey { background:rgba(128,128,128,.14); opacity:.85; }
 .gl-obj { max-width:420px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
 .gl-mono { font-family:ui-monospace, Consolas, monospace; font-size:11px; }
@@ -98,13 +98,18 @@ window.__ModuleLoader__.load({
 /* --- drift field ------------------------------------------------------- */
 .gl-field-wrap { position:relative; border-radius:12px; overflow:hidden;
   border:1px solid rgba(120,150,180,.28); background:#0b1219; }
-.gl-field-canvas { display:block; width:100%; height:340px; cursor:crosshair; }
+.gl-field-canvas { display:block; width:100%; height:400px; cursor:crosshair; }
 .gl-field-legend { position:absolute; left:12px; bottom:10px; display:flex; gap:12px;
-  flex-wrap:wrap; font-size:11px; color:rgba(198,214,228,.82);
+  flex-wrap:wrap; align-items:center; font-size:11px; color:rgba(198,214,228,.82);
   background:rgba(8,14,20,.55); padding:5px 9px; border-radius:6px;
   backdrop-filter:blur(3px); pointer-events:none; }
 .gl-legend-dot { display:inline-block; width:7px; height:7px; border-radius:50%;
   margin-right:5px; vertical-align:middle; }
+.gl-legend-sep { opacity:.35; }
+.gl-legend-line { display:inline-block; width:14px; height:0; margin-right:5px;
+  vertical-align:middle; border-top:1px solid; }
+.gl-legend-line-weak { border-color:rgba(140,186,220,.75); }
+.gl-legend-line-strong { border-color:rgba(255,214,140,.95); }
 .gl-field-tip { position:absolute; pointer-events:none; z-index:3; max-width:320px;
   background:rgba(10,17,24,.94); border:1px solid rgba(140,180,215,.35);
   border-radius:8px; padding:8px 10px; font-size:11.5px; line-height:1.5;
@@ -153,33 +158,55 @@ window.__ModuleLoader__.load({
     }
 
     // ---------------------------------------------------------------------
-    // Drift field: cold gray-blue canvas, one gold light per goal.
-    // The radius IS the drift — the bright core is the objective as asked,
-    // the rim is maximal distance from it. Angle is decorative (golden-angle
-    // spacing + a hash-derived jitter, so a goal keeps its spot between
-    // renders). Colors match the band tags used in the tables.
+    // Drift field: dark starfield, one light per goal.
+    //
+    // Every channel carries data, and each one answers a different question:
+    //   radius  — how far this goal's session drifted from the goal as asked
+    //             (mean cosine distance over its scorable turns)
+    //   angle   — WHEN the session started, clockwise from 12 o'clock, old→new
+    //   colour  — the distance band, same numbers as the tables
+    //   size    — turn count (log), so one long session cannot dwarf the rest
+    //   edges   — similarity BETWEEN goals: same topic (faint) or the same
+    //             request asked twice (bright, usually a reusable path)
+    //
+    // The edges are what makes this a network instead of a star: goal-to-goal
+    // similarity is already computed for scoring, so the links cost no extra
+    // embedding call. Decoration (dust, core bloom, orbital arcs, point spray)
+    // is confined to drawField() and never encodes anything.
     // ---------------------------------------------------------------------
 
-    // Cold gray-blue field, gold light. Gold means "drifted", gray-blue means
-    // "focused" — the color carries the same meaning as the table tags instead
-    // of being decoration, and the palette stays within the gray-blue brief.
+    // Four bands, four distinguishable hues — the first two used to be two
+    // near-identical gray-blues on a near-black field, which read as three
+    // bands. Blue = still on target, teal = slightly off, orange = off topic,
+    // bright gold = badly drifted. Same palette drives the table tags.
     const BAND_COLORS = {
-      green: '#7d9cb3',
-      yellow: '#94aec0',
-      orange: '#d8a860',
-      red: '#ffc94d',
-      grey: '#75899b'
+      green: '#4d9ffe',
+      yellow: '#35d6b0',
+      orange: '#e8944a',
+      red: '#ffd24a',
+      grey: '#8fa7bb'
     }
     const BAND_GLOW = {
-      green: [125, 156, 179],
-      yellow: [148, 174, 192],
-      orange: [216, 168, 96],
-      red: [255, 201, 77],
-      grey: [117, 137, 155]
+      green: [77, 159, 254],
+      yellow: [53, 214, 176],
+      orange: [232, 148, 74],
+      red: [255, 210, 74],
+      grey: [143, 167, 187]
     }
     const GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5))
     /** Distance that maps to the outer rim; leaves headroom past the 0.65 band. */
     const R_MAX_DIST = 0.8
+    /** Band thresholds, in the same numbers the tables print. */
+    const BANDS = [
+      { at: 0.35, key: 'yellow', label: '有偏离' },
+      { at: 0.50, key: 'orange', label: '偏题' },
+      { at: 0.65, key: 'red', label: '严重' }
+    ]
+    /** Edge classes: same topic vs the same request asked twice. */
+    const LINK_STRONG = 0.18
+    const LINK_WEAK = 0.42
+    /** Wedge at 12 o'clock where the time axis wraps (old→new seam). */
+    const ANGLE_SEAM = Math.PI * 0.16
 
     /** Stable 32-bit string hash → [0,1). Keeps each goal's jitter constant. */
     function hash01(text) {
@@ -192,12 +219,65 @@ window.__ModuleLoader__.load({
       return ((hh >>> 0) % 100000) / 100000
     }
 
+    /**
+     * Sessions by start time → clockwise angle from 12 o'clock.
+     *
+     * Angle used to be pure decoration (golden-angle spacing), which wasted a
+     * whole visual channel: you could not tell "drifted late" from "drifted,
+     * got pulled back, drifted again". With the angle ordered by start time,
+     * reading clockwise answers exactly that.
+     *
+     * Rank-based, not time-proportional, on purpose: real start times here
+     * span a week with a 10 ms minimum gap, so mapping times linearly puts
+     * dozens of goals on the same ray. Equal angular spacing keeps the field
+     * readable and the old→new order exact; the spacing encodes ORDER, not the
+     * size of the time gaps (that is what the tooltip timestamp is for).
+     */
+    function angleByStartTime(entries) {
+      const ordered = [...entries].sort((a, b) => {
+        const ta = typeof a.startedAt === 'number' ? a.startedAt : Infinity
+        const tb = typeof b.startedAt === 'number' ? b.startedAt : Infinity
+        if (ta !== tb) return ta - tb
+        // Same instant: stable, deterministic tie-break so a re-render cannot
+        // shuffle two goals that started together.
+        return String(a.id).localeCompare(String(b.id))
+      })
+      const out = new Map()
+      if (!ordered.some(e => typeof e.startedAt === 'number')) {
+        // No timestamps at all: keep a deterministic spiral instead of a
+        // meaningless time axis.
+        ordered.forEach((e, i) => {
+          out.set(e.id, i * GOLDEN_ANGLE + (hash01(e.id) - 0.5) * 0.12)
+        })
+        return out
+      }
+      const n = ordered.length
+      // A full turn would put the newest goal back on the oldest one's ray, so
+      // "clockwise = later" would be false for the last point. A half turn
+      // wastes the left side. The answer is a full turn with a reserved seam:
+      // time runs over 360° minus a small wedge at the top, and the seam is
+      // drawn explicitly as the old→new arrow, so the wrap is visible instead
+      // of being a coordinate trick.
+      const span = Math.PI * 2 - ANGLE_SEAM
+      ordered.forEach((e, i) => {
+        const f = n === 1 ? 0 : i / (n - 1)
+        out.set(e.id, -Math.PI / 2 + ANGLE_SEAM / 2 + f * span)
+      })
+      return out
+    }
+
     /** Distance payload → normalized polar points. */
     function layoutPoints(items) {
       const scored = (items ?? []).filter(g => typeof g.meanDistance === 'number')
       const sorted = [...scored].sort((a, b) => b.meanDistance - a.meanDistance)
+      const entries = sorted.map((g, i) => ({
+        id: g.goalId,
+        startedAt: g.sessionStartedAt ?? g.createdAt ?? null,
+        // Golden-angle order is only the fallback for untimed data.
+        seedIndex: i
+      }))
+      const angles = angleByStartTime(entries)
       return sorted.map((g, i) => {
-        const jitter = hash01(g.goalId) - 0.5
         return {
           id: g.goalId,
           objective: g.objective ?? '',
@@ -206,7 +286,8 @@ window.__ModuleLoader__.load({
           calls: g.totalCalls ?? 0,
           failed: g.failedCalls ?? 0,
           band: band(g.meanDistance)[1],
-          angle: i * GOLDEN_ANGLE + jitter * 0.55,
+          startedAt: entries[i].startedAt,
+          angle: angles.get(g.goalId) ?? i * GOLDEN_ANGLE,
           // The floor keeps a well-focused goal off the core sprite, which would
           // otherwise read as the core itself and hide the light.
           radius: Math.max(0.13, Math.min(1, g.meanDistance / R_MAX_DIST)),
@@ -216,6 +297,39 @@ window.__ModuleLoader__.load({
       })
     }
 
+    /**
+     * Drop the decorative filaments.
+     *
+     * The old spiral curves read as "the trajectory of the conversation" and
+     * encoded nothing — a static picture cannot say whether they were real
+     * turns or art. They are gone; real turn trajectories live in the
+     * 漂移轮次 tab. What replaces them is real adjacency between goals.
+     */
+
+    /**
+     * Resolve the similarity links into drawable segments.
+     *
+     * `links` comes from src/distance.js (goal vectors, 1−cos), so the edges
+     * are data, not decoration. Anything without a rendered endpoint is
+     * skipped rather than guessed at.
+     */
+    function layoutLinks(links, positionById) {
+      const out = []
+      for (const l of links ?? []) {
+        const a = positionById.get(l.a)
+        const b = positionById.get(l.b)
+        if (!a || !b) continue
+        if (typeof l.distance !== 'number') continue
+        out.push({
+          a: l.a,
+          b: l.b,
+          distance: l.distance,
+          strong: l.distance <= LINK_STRONG
+        })
+      }
+      return out
+    }
+
     /**
      * Sparks around one goal point: the sprayed-light texture of the reference.
      *
@@ -271,10 +385,194 @@ window.__ModuleLoader__.load({
     }
     const DUST = makeDust(260, 20261027)
 
+    /**
+     * Pick the bearing for the ring chips where they collide with least.
+     *
+     * Ring chips are drawn on the rings themselves, so a fixed bearing will
+     * eventually sit on top of a light once sessions accumulate. Counting by
+     * angle alone is not enough: a chip covers ~46×13px, so a goal at a
+     * neighbouring bearing but a different radius still overlaps it. This
+     * scores candidate bearings against the ACTUAL projected point positions
+     * and picks the cheapest.
+     *
+     * The seam wedge is excluded on purpose: it is empty BY CONSTRUCTION, so
+     * without the filter every render would park the chips in the old→new
+     * seam and collide with its labels.
+     */
+    /**
+     * Pick the bearing for one ring chip that collides least.
+     *
+     * Ring chips are drawn on the rings themselves, so a fixed bearing will
+     * eventually sit on top of a light once sessions accumulate. Counting by
+     * angle alone is not enough: a chip covers ~46×13px, so a goal at a
+     * neighbouring bearing but a different radius still overlaps it. This
+     * scores candidate bearings against the ACTUAL projected point positions
+     * and picks the cheapest.
+     *
+     * Value labels count too. Severe-band points carry a permanent three-digit
+     * label pinned at a fixed offset, and it used to be invisible to this
+     * function — so the chips could park on top of it (measured: one collision
+     * on 31 goals, while 66 of 72 bearings were clear).
+     *
+     * Chips already placed are passed in as boxes: one bearing shared by all
+     * three rings put them on a single ray, where they crowd each other. On a
+     * dense field no bearing is fully clear anyway (measured: 0 of 59 score
+     * zero with 31 goals), so each ring picks its own instead.
+     *
+     * The seam wedge is excluded on purpose: it is empty BY CONSTRUCTION, so
+     * without the filter every render would park the chips in the old→new
+     * seam and collide with its labels.
+     *
+     * @param ringRadius  radius of the ring this chip sits on
+     * @param placedChips boxes ({x0,y0,x1,y1}) of chips already drawn
+     */
+    function emptiestAngle(points, cx, cy, maxR, ringRadius = (0.5 / R_MAX_DIST) * maxR, placedChips = []) {
+      const CANDIDATES = 72
+      const CHIP_W = 26
+      const CHIP_H = 12
+      const LABEL_W = 34
+      const LABEL_H = 11
+      const seamCentre = ((-Math.PI / 2) % (Math.PI * 2) + Math.PI * 2) % (Math.PI * 2)
+      const seamHalf = ANGLE_SEAM / 2 + 0.30
+
+      const pointPos = points.map(p => ({
+        x: cx + Math.cos(p.angle) * p.radius * maxR,
+        y: cy + Math.sin(p.angle) * p.radius * maxR * 0.9
+      }))
+
+      // Mirrors the value-label placement in drawField(): severe band only,
+      // anchored left-of-top at (x + size + 8, y - (size + 8) * 0.55).
+      const labelBoxes = points
+        .filter(p => p.band === 'red')
+        .map(p => {
+          const pos = { x: cx + Math.cos(p.angle) * p.radius * maxR, y: cy + Math.sin(p.angle) * p.radius * maxR * 0.9 }
+          const off = p.size + 8
+          return {
+            x0: pos.x + off,
+            x1: pos.x + off + LABEL_W,
+            y0: pos.y - off * 0.55 - LABEL_H / 2,
+            y1: pos.y - off * 0.55 + LABEL_H / 2
+          }
+        })
+
+      // Two penalties with deliberately different shapes:
+      //
+      // - Points use the ORIGINAL centre-distance form (`|Δ| - full size`).
+      //   Rewriting it in box terms is not equivalent — the box form penalises
+      //   a ring of offsets the original ignores, which made chips avoid lights
+      //   far too strongly and shove themselves into a crowded bearing.
+      //   Verified numerically: at Δx=44 the original scores 0, the box form
+      //   scores 169.
+      // - Labels use a box test, because a label is a rectangle anchored at a
+      //   corner rather than a centred sprite, and centre-distance against its
+      //   anchor puts the penalty in the wrong place.
+      const pointCost = (q, lx, ly) => {
+        const dx = Math.max(0, Math.abs(q.x - lx) - CHIP_W)
+        const dy = Math.max(0, Math.abs(q.y - ly) - CHIP_H)
+        const d = Math.hypot(dx, dy)
+        return d < 18 ? (18 - d) * (18 - d) : 0
+      }
+      const boxCost = (x0, y0, x1, y1, q) => {
+        const dx = Math.max(0, Math.max(x0 - q.x1, q.x0 - x1))
+        const dy = Math.max(0, Math.max(y0 - q.y1, q.y0 - y1))
+        const d = Math.hypot(dx, dy)
+        return d < 18 ? (18 - d) * (18 - d) : 0
+      }
+
+      let best = -Math.PI / 2
+      let bestScore = Infinity
+      for (let c = 0; c < CANDIDATES; c++) {
+        const a = (c / CANDIDATES) * Math.PI * 2
+        let delta = Math.abs(a - seamCentre)
+        if (delta > Math.PI) delta = Math.PI * 2 - delta
+        if (delta < seamHalf) continue
+
+        const lx = cx + Math.cos(a) * ringRadius
+        const ly = cy + Math.sin(a) * ringRadius * 0.9
+        const x0 = lx - CHIP_W / 2
+        const x1 = lx + CHIP_W / 2
+        const y0 = ly - CHIP_H / 2
+        const y1 = ly + CHIP_H / 2
+
+        let score = 0
+        for (const q of pointPos) score += pointCost(q, lx, ly)
+        for (const q of labelBoxes) score += boxCost(x0, y0, x1, y1, q)
+        // Already-placed chips are scored harder than background noise: two
+        // chips overlapping each other is far worse than a chip near a light,
+        // because both become unreadable rather than merely busy.
+        for (const q of placedChips) score += boxCost(x0, y0, x1, y1, q) * 3
+        /*
+         * Angular separation, independent of the box test.
+         *
+         * Chips sit on different radii, so two chips 3° apart can be
+         * box-disjoint and still read as one clump — measured: orange at 102°
+         * and red at 99° on real data. Penalising near-identical bearings
+         * spreads the three chips around the field instead of stacking them.
+         */
+        for (const q of placedChips) {
+          if (q.bearing === undefined) continue
+          let sep = Math.abs(a - q.bearing)
+          if (sep > Math.PI) sep = Math.PI * 2 - sep
+          if (sep < MIN_CHIP_SEP) score += (MIN_CHIP_SEP - sep) * 900
+        }
+        // Keep the chips away from the rim and the core so they stay on their
+        // own ring instead of drifting into other geometry.
+        if (lx < 30 || lx > cx * 2 - 30) score += 400
+        if (score < bestScore) { bestScore = score; best = a }
+      }
+      return best
+    }
+
+      /** Font stack for canvas: CJK-capable first, then mono for digits. */
+    const FIELD_FONT = '"Microsoft YaHei", "PingFang SC", ui-monospace, Consolas, monospace'
+
+    /**
+     * Chip plate half-extents, shared by the chip drawer and the bearing picker.
+     * drawChip() sizes the plate by text width (at least 46×13); these are the
+     * conservative halves used for collision scoring.
+     */
+    const CHIP_HALF_W = 23
+    const CHIP_HALF_H = 7
+    /** Minimum bearing gap between two ring chips, in radians (~22 degrees). */
+    const MIN_CHIP_SEP = Math.PI * 0.12
+
+    /**
+     * A tiny labelled pill, used for the ring thresholds.
+     *
+     * Canvas has no layout, so this draws the plate itself and keeps the text
+     * legible over the starfield: a bare 9px number at 55% alpha was invisible
+     * in practice, which is why the rings looked unlabelled.
+     */
+    function drawChip(g, x, y, text, rgb) {
+      g.font = '9px ' + FIELD_FONT
+      g.textAlign = 'center'
+      g.textBaseline = 'middle'
+      const w = Math.max(46, g.measureText(text).width + 10)
+      const hgt = 13
+      g.beginPath()
+      g.fillStyle = 'rgba(10,17,24,0.82)'
+      g.strokeStyle = 'rgba(' + rgb.join(',') + ',0.55)'
+      g.lineWidth = 0.8
+      // roundRect is not in every canvas build; fall back to a plain rect.
+      if (typeof g.roundRect === 'function') {
+        g.roundRect(x - w / 2, y - hgt / 2, w, hgt, 6)
+      } else {
+        g.rect(x - w / 2, y - hgt / 2, w, hgt)
+      }
+      g.fill()
+      g.stroke()
+      g.fillStyle = 'rgba(' + rgb.join(',') + ',0.95)'
+      g.fillText(text, x, y)
+    }
+
     /**
      * Paint one frame. Returns projected points so the caller can hit-test.
+     *
+     * `links` carries the goal-to-goal similarity edges; the caller resolves
+     * them against the same projection the points use, so an edge can never
+     * land next to a point that is not actually there.
      */
-    function drawField(g, width, height, points, time, hoverId) {
+    function drawField(g, width, height, points, time, hoverId, links = []) {
       const cx = width / 2
       const cy = height / 2
       const maxR = Math.min(width * 0.42, height * 0.46)
@@ -320,49 +618,118 @@ window.__ModuleLoader__.load({
         g.fill()
       }
 
-      // --- band rings ------------------------------------------------------
-      // Labels sit on the upper-left diagonal, where the ring is empty, instead
-      // of at 3 o'clock where the goal points crowd the rim.
-      for (const ring of [0.35, 0.5, 0.65]) {
-        const r = (ring / R_MAX_DIST) * maxR
+      // --- band rings, labelled --------------------------------------------
+      // The rings used to be unlabelled hairlines: the four bands were only
+      // inferable from colour, and colour was exactly the thing that failed.
+      // Numbers and band names now sit ON the ring, in the same notation the
+      // tables use, so a reader never has to reverse-engineer a colour.
+      //
+      // The label bearing is picked per render from the emptiest sector rather
+      // than hardcoded: goal positions move as sessions accumulate, and a fixed
+      // diagonal eventually lands a chip on top of a light.
+      //
+      // Each ring is placed independently, and each placement also avoids the
+      // chips already placed. One shared bearing forced all three chips onto a
+      // single ray, where they crowded each other and together sat on whichever
+      // light happened to be on that bearing — with 31 goals the field is dense
+      // enough that no single bearing is fully clear (measured: 0 of 59
+      // candidates score zero), so sharing one makes the collision certain
+      // instead of merely likely.
+      const placedChips = []
+      for (const b of BANDS) {
+        const r = (b.at / R_MAX_DIST) * maxR
         g.beginPath()
-        g.setLineDash([1, 6])
-        g.strokeStyle = ring >= 0.65
-          ? 'rgba(150,190,222,0.26)'
-          : 'rgba(120,158,192,0.15)'
+        g.setLineDash([1, 5])
+        g.strokeStyle = 'rgba(' + (BAND_GLOW[b.key] ?? BAND_GLOW.grey).join(',') + ',0.30)'
         g.lineWidth = 1
         g.ellipse(cx, cy, r, r * 0.9, 0, 0, Math.PI * 2)
         g.stroke()
         g.setLineDash([])
 
-        const la = Math.PI * 1.18
-        g.font = '9px ui-monospace, Consolas, monospace'
-        g.fillStyle = 'rgba(150,186,214,0.55)'
-        g.textAlign = 'center'
-        g.textBaseline = 'middle'
-        g.fillText(ring.toFixed(2), cx + Math.cos(la) * r, cy + Math.sin(la) * r * 0.9)
+        const labelAngle = emptiestAngle(points, cx, cy, maxR, r, placedChips)
+        const lx = cx + Math.cos(labelAngle) * r
+        const ly = cy + Math.sin(labelAngle) * r * 0.9
+        drawChip(g, lx, ly, b.at.toFixed(2) + ' ' + b.label, BAND_GLOW[b.key] ?? BAND_GLOW.grey)
+        // Same plate dimensions drawChip() uses; measured here would need the
+        // context font, and a fixed conservative box is enough for avoidance.
+        placedChips.push({ x0: lx - CHIP_HALF_W, x1: lx + CHIP_HALF_W, y0: ly - CHIP_HALF_H, y1: ly + CHIP_HALF_H, bearing: labelAngle })
       }
 
-      // --- filaments: the light's threads ----------------------------------
-      // Each one is drawn three times at widening width and falling alpha, which
-      // gives the soft bloom of the reference instead of a hard hairline.
+      // --- the time axis ----------------------------------------------------
+      // Angle means session start time, clockwise from 12 o'clock. The seam at
+      // the top is where the axis wraps from newest back to oldest, so it is
+      // drawn rather than left implicit: without it the last point would look
+      // "earlier" than the first.
+      const seamR = maxR * 1.02
+      g.beginPath()
+      g.strokeStyle = 'rgba(160,194,222,0.22)'
+      g.lineWidth = 1
+      g.setLineDash([2, 4])
+      g.moveTo(cx + Math.cos(-Math.PI / 2 + ANGLE_SEAM / 2) * maxR * 0.18,
+        cy + Math.sin(-Math.PI / 2 + ANGLE_SEAM / 2) * maxR * 0.18 * 0.9)
+      g.lineTo(cx + Math.cos(-Math.PI / 2 + ANGLE_SEAM / 2) * seamR,
+        cy + Math.sin(-Math.PI / 2 + ANGLE_SEAM / 2) * seamR * 0.9)
+      g.moveTo(cx + Math.cos(-Math.PI / 2 - ANGLE_SEAM / 2) * maxR * 0.18,
+        cy + Math.sin(-Math.PI / 2 - ANGLE_SEAM / 2) * maxR * 0.18 * 0.9)
+      g.lineTo(cx + Math.cos(-Math.PI / 2 - ANGLE_SEAM / 2) * seamR,
+        cy + Math.sin(-Math.PI / 2 - ANGLE_SEAM / 2) * seamR * 0.9)
+      g.stroke()
+      g.setLineDash([])
+
+      g.font = '9px ' + FIELD_FONT
+      g.textAlign = 'center'
+      g.textBaseline = 'middle'
+      g.fillStyle = 'rgba(160,194,222,0.62)'
+      g.fillText('旧', cx - maxR * 0.20, cy - maxR * 1.02)
+      g.fillText('新', cx + maxR * 0.20, cy - maxR * 1.02)
+      g.fillStyle = 'rgba(160,194,222,0.34)'
+      g.fillText('顺时针 = 更晚', cx, cy + maxR * 1.16)
+
+      // --- goal geometry, shared by the link layer and the point pass -------
+      const posById = new Map()
       for (const p of points) {
-        const x = cx + Math.cos(p.angle) * p.radius * maxR
-        const y = cy + Math.sin(p.angle) * p.radius * maxR * 0.9
-        const bend = 0.34 + (hash01(p.id) - 0.5) * 0.5
-        const mx = cx + Math.cos(p.angle + bend) * p.radius * maxR * 0.52
-        const my = cy + Math.sin(p.angle + bend) * p.radius * maxR * 0.52 * 0.9
-        const hot = p.band === 'red' || p.band === 'orange'
-        const base = hot ? [255, 198, 96] : [150, 186, 214]
-        const strength = hot ? 1 : 0.5
-        for (let layer = 0; layer < 3; layer++) {
+        posById.set(p.id, {
+          x: cx + Math.cos(p.angle) * p.radius * maxR,
+          y: cy + Math.sin(p.angle) * p.radius * maxR * 0.9
+        })
+      }
+
+      // --- links: similarity BETWEEN goals ---------------------------------
+      // This is what makes the field a network instead of a star. It replaces
+      // the old decorative filaments, which connected every goal to the core
+      // and encoded nothing: a static picture cannot distinguish "real turn
+      // trajectory" from "art", so it read as data it did not carry.
+      for (const l of links) {
+        const a = posById.get(l.a)
+        const bpos = posById.get(l.b)
+        if (!a || !bpos) continue
+        const hot = hoverId === l.a || hoverId === l.b
+        // Bow the line so overlapping edges stay countable, deterministically.
+        const bendSign = hash01(l.a + '|' + l.b) > 0.5 ? 1 : -1
+        const mx = (a.x + bpos.x) / 2 + (bpos.y - a.y) * 0.12 * bendSign
+        const my = (a.y + bpos.y) / 2 + (a.x - bpos.x) * 0.12 * bendSign
+        const base = l.strong ? [255, 214, 140] : [140, 186, 220]
+        const alpha = l.strong
+          ? (hot ? 0.62 : 0.30)
+          : (hot ? 0.34 : 0.13)
+        g.beginPath()
+        g.moveTo(a.x, a.y)
+        g.quadraticCurveTo(mx, my, bpos.x, bpos.y)
+        g.strokeStyle = 'rgba(' + base.join(',') + ',' + alpha + ')'
+        g.lineWidth = l.strong ? (hot ? 2 : 1.3) : (hot ? 1.4 : 0.8)
+        g.stroke()
+
+        // A single travelling spark on "same request asked twice" edges: the
+        // reuse is the point of those links, so they get a pulse, not a glow.
+        if (l.strong) {
+          const u = ((t * 0.12 + hash01(l.a + l.b)) % 1)
+          const iu = 1 - u
+          const sx = iu * iu * a.x + 2 * iu * u * mx + u * u * bpos.x
+          const sy = iu * iu * a.y + 2 * iu * u * my + u * u * bpos.y
           g.beginPath()
-          g.moveTo(cx, cy)
-          g.quadraticCurveTo(mx, my, x, y)
-          g.strokeStyle = 'rgba(' + base.join(',') + ',' +
-            ((hot ? 0.10 : 0.055) * strength * (1 - layer * 0.32)).toFixed(3) + ')'
-          g.lineWidth = 0.6 + layer * 1.7
-          g.stroke()
+          g.fillStyle = 'rgba(255,236,186,' + (hot ? 0.95 : 0.72) + ')'
+          g.arc(sx, sy, hot ? 1.9 : 1.3, 0, Math.PI * 2)
+          g.fill()
         }
       }
 
@@ -413,8 +780,9 @@ window.__ModuleLoader__.load({
       // --- goal points -----------------------------------------------------
       const projected = []
       for (const p of points) {
-        const x = cx + Math.cos(p.angle) * p.radius * maxR
-        const y = cy + Math.sin(p.angle) * p.radius * maxR * 0.9
+        const pos = posById.get(p.id)
+        const x = pos.x
+        const y = pos.y
         projected.push({ point: p, x, y })
 
         const rgb = BAND_GLOW[p.band] ?? BAND_GLOW.grey
@@ -460,6 +828,25 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // --- permanent numbers, severe band only ------------------------------
+      // One rule for the whole field: the severe (bright gold) points always
+      // print their distance, everything else is on hover. Previously three
+      // numbers floated over the left side with no visible rule behind them,
+      // which read as arbitrary; this makes "why is this one labelled" obvious.
+      g.font = '10px ' + FIELD_FONT
+      g.textAlign = 'left'
+      g.textBaseline = 'middle'
+      for (const p of points) {
+        if (p.band !== 'red') continue
+        const pos = posById.get(p.id)
+        if (!pos) continue
+        const isHover = hoverId === p.id
+        const label = p.distance.toFixed(3)
+        const off = (p.size + 8)
+        g.fillStyle = isHover ? 'rgba(255,240,205,0.98)' : 'rgba(255,224,158,0.88)'
+        g.fillText(label, pos.x + off, pos.y - off * 0.55)
+      }
+
       return projected
     }
 
@@ -467,6 +854,7 @@ window.__ModuleLoader__.load({
       const canvasRef = useRef(null)
       const wrapRef = useRef(null)
       const pointsRef = useRef([])
+      const linksRef = useRef([])
       const hoverRef = useRef(null)
       const [hover, setHover] = useState(null)
       const [tip, setTip] = useState(null)
@@ -477,6 +865,26 @@ window.__ModuleLoader__.load({
       )
       pointsRef.current = points
 
+      // Links are resolved once per snapshot, not per frame: they only depend on
+      // which goals are present, and the draw loop should stay allocation-light.
+      const links = useMemo(() => {
+        const byId = new Map(points.map(p => [p.id, p]))
+        return layoutLinks(distance ? distance.links : [], byId)
+      }, [distance, points])
+      linksRef.current = links
+
+      // How many goals share each strong link — used to name the reuse idea in
+      // the tooltip instead of leaving the bright edges unexplained.
+      const reuseById = useMemo(() => {
+        const m = new Map()
+        for (const l of links) {
+          if (!l.strong) continue
+          m.set(l.a, (m.get(l.a) ?? 0) + 1)
+          m.set(l.b, (m.get(l.b) ?? 0) + 1)
+        }
+        return m
+      }, [links])
+
       useEffect(() => {
         const canvas = canvasRef.current
         if (!canvas || !points.length) return undefined
@@ -505,21 +913,25 @@ window.__ModuleLoader__.load({
         const frame = (time) => {
           if (!alive) return
           resize()
-          const projected = drawField(ctx2d, lastW, lastH, pointsRef.current, time, hoverRef.current)
+          const projected = drawField(
+            ctx2d, lastW, lastH, pointsRef.current, time, hoverRef.current, linksRef.current
+          )
           canvas.__glPoints = projected
           raf = window.requestAnimationFrame(frame)
         }
 
         resize()
         // First paint is synchronous so the panel is never briefly empty.
-        canvas.__glPoints = drawField(ctx2d, lastW, lastH, pointsRef.current, 0, null)
+        canvas.__glPoints = drawField(
+          ctx2d, lastW, lastH, pointsRef.current, 0, null, linksRef.current
+        )
         raf = window.requestAnimationFrame(frame)
 
         return () => {
           alive = false
           if (raf) window.cancelAnimationFrame(raf)
         }
-      }, [points.length])
+      }, [points.length, links.length])
 
       const onMove = useCallback((e) => {
         const canvas = canvasRef.current
@@ -577,6 +989,18 @@ window.__ModuleLoader__.load({
                 : b === 'yellow' ? '有偏离 0.35+'
                   : b === 'orange' ? '偏题 0.50+' : '严重 0.65+'
             )
+          ),
+          // The link classes only exist once a snapshot carries `links`. A
+          // cached snapshot from before this layer landed has none, and showing
+          // the key for edges that are not on screen would be a lie.
+          links.length > 0 && h('span', { className: 'gl-legend-sep' }, '|'),
+          links.length > 0 && h('span', null,
+            h('i', { className: 'gl-legend-line gl-legend-line-weak' }),
+            '同主题 ≤' + LINK_WEAK.toFixed(2)
+          ),
+          links.length > 0 && h('span', null,
+            h('i', { className: 'gl-legend-line gl-legend-line-strong' }),
+            '几乎同题 ≤' + LINK_STRONG.toFixed(2)
           )
         ),
         tip && h('div', {
@@ -588,9 +1012,16 @@ window.__ModuleLoader__.load({
           h('span', { className: 'gl-tag gl-tag-' + tip.point.band }, band(tip.point.distance)[0]),
           h('span', { className: 'gl-tip-obj' }, tip.point.objective),
           h('span', { className: 'gl-tip-meta' },
-            `${tip.point.turns} 轮 · ${tip.point.calls} 次调用 · ${tip.point.failed} 次失败`)
+            `${tip.point.turns} 轮 · ${tip.point.calls} 次调用 · ${tip.point.failed} 次失败`
+            + (tip.point.startedAt ? ` · 开始于 ${fmtTime(tip.point.startedAt)}` : '')
+            + (reuseCountOf(tip.point.id) ? ` · 与 ${reuseCountOf(tip.point.id)} 个目标几乎同题（可复用上次路径）` : '')
+          )
         )
       )
+
+      function reuseCountOf(id) {
+        return reuseById.get(id) ?? 0
+      }
     }
 
     // ---------------------------------------------------------------------
@@ -1141,7 +1572,9 @@ window.__ModuleLoader__.load({
         tab === 'field' && h(React.Fragment, null,
           h('div', { className: 'gl-section-title' }, '漂移场（半径 = 距离目标的远近）'),
           h('div', { className: 'gl-muted', style: { marginBottom: 8 } },
-            '中心亮点是「最初的目标」，每个光点是一个目标在整段会话里偏离它的程度 —— 越靠外越远。颜色与下方表格的档位一致。'),
+            '中心亮点是「最初的目标」。每个光点是一个目标，半径 = 它整段会话里可计分轮次的平均距离，越靠外离最初的要求越远；'
+            + '角度按会话开始时间顺时针排列（顶部接缝是旧→新的回绕处）；光点之间的连线 = 目标之间的相似度，'
+            + '亮线代表几乎是同一个目标被重复提问，上次的路径通常可以直接复用。'),
           h(DriftField, { distance: snap && snap.distance })
         ),
 

package/market-index.json

@@ -81,8 +81,8 @@
       },
       "versions": [
         {
-          "version": "0.2.2",
-          "publishTimestamp": 1793169063,
+          "version": "0.3.0",
+          "publishTimestamp": 1793172958,
           "source": {
             "type": "npm"
           },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-goal-ledger",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Goal-distance ledger and failure-cluster panel for DeepSeek Harness — audits your own sessions, shows where goals drifted and where tool calls actually failed.",
   "type": "module",
   "license": "MIT",
@@ -58,9 +58,12 @@
     "test:correction": "node test/correction.mjs && node test/correction-wiring.mjs",
     "test:full": "node test/full.mjs",
     "test:render-field": "node test/render-field.mjs",
+    "test:links": "node test/links.mjs",
     "check": "node --check lib/index.js && node --check lib/client.js && node --check src/session-reader.js && node --check src/failure-cluster.js && node --check src/embed-config.js && node --check src/correction.js && node --check src/distance.js",
     "test:manifest": "node test/manifest.mjs",
-    "test:published": "node test/published-matches-tag.mjs"
+    "test:published": "node test/published-matches-tag.mjs",
+    "test:labels": "node test/label-collisions.mjs",
+    "test:bearing": "node test/bearing-cost.mjs"
   },
   "devDependencies": {
     "jsdom": "^26.1.0",

package/src/distance.js

@@ -57,6 +57,115 @@ function cosineDistance(a, b) {
 
 export { cosineDistance }
 
+/**
+ * Goal-to-goal links: the point-to-point edges the chart is missing today.
+ *
+ * Every goal already has a vector — its objective was embedded in the same
+ * scoring pass as its turns — but the chart only ever draws goal -> turn rays,
+ * so every goal connects to its own centre and nothing else. That hides the one
+ * pattern worth acting on: "similar failures cluster" (several goals drifting
+ * the same way) and "successful paths are reusable" (goals that ended up doing
+ * nearly the same thing). Both are goal-to-goal questions, and both can be
+ * answered from vectors that are already in memory, i.e. at zero extra API
+ * cost. This builds those edges offline: pure function, no I/O, no embeddings.
+ *
+ * Pairs are undirected and deduped by unordered pair. Selection is seeded as
+ * the union of each node's nearest surviving pairs — so a pair that is in goal
+ * i's top-k but not goal j's is still kept — and then a deterministic hard cap
+ * trims any node left above `maxDegree` down to its nearest neighbours. Without
+ * that cap one dense hub turns the whole chart into a hairball; the cap is per
+ * node, so `maxDegree: 0` means "no links at all". Where a hub's neighbours all
+ * pick the hub but the hub already has `maxDegree` closer ones, the cap wins and
+ * the farthest of those edges is dropped — a node never exceeds `maxDegree`.
+ *
+ * Deterministic by construction: distance ties inside a node's neighbourhood
+ * break on node index, and the emitted list sorts by distance then `a` then `b`,
+ * so two runs over the same input compare deep-equal. Inputs are never mutated.
+ *
+ * @param vectors  number[][] goal objective vectors, index-aligned with `ids`;
+ *                 null/undefined/empty entries are skipped, not errors
+ * @param ids      string[] goalIds, same length/order as `vectors`
+ * @param options.maxDistance  cosine-distance ceiling; pairs strictly above it
+ *                             are dropped, so exactly-at-ceiling is kept
+ *                             (default 0.42)
+ * @param options.maxDegree    per-node cap on kept links (default 3, 0 = off)
+ * @returns {{a: string, b: string, distance: number}[]} ascending by distance,
+ *          ties broken by `a` then `b`; a !== b; distances rounded to 4 dp
+ */
+export function buildGoalLinks(vectors, ids, { maxDistance = 0.42, maxDegree = 3 } = {}) {
+  const n = Math.min(vectors?.length ?? 0, ids?.length ?? 0)
+  if (n < 2) return []
+
+  const cap = Number.isFinite(maxDegree) ? Math.max(0, Math.floor(maxDegree)) : 0
+  if (cap === 0) return []
+  const ceiling = Number.isFinite(maxDistance) ? maxDistance : 0.42
+  const usable = v => Array.isArray(v) && v.length > 0
+
+  // 1. Every unordered pair that survives the distance ceiling.
+  const candidate = new Map()
+  const byNode = new Map()
+  for (let i = 0; i < n; i++) {
+    if (!usable(vectors[i])) continue
+    for (let j = i + 1; j < n; j++) {
+      if (!usable(vectors[j])) continue
+      const d = cosineDistance(vectors[i], vectors[j])
+      if (d > ceiling) continue
+      const key = i * n + j
+      candidate.set(key, { i, j, d, key })
+      if (!byNode.has(i)) byNode.set(i, [])
+      if (!byNode.has(j)) byNode.set(j, [])
+      byNode.get(i).push({ other: j, key, d })
+      byNode.get(j).push({ other: i, key, d })
+    }
+  }
+  if (!candidate.size) return []
+
+  // 2. Seed with the union of each node's nearest pairs: a pair chosen by only
+  //    one endpoint still counts (it is that endpoint's neighbour, not a vote).
+  const kept = new Set()
+  for (const list of byNode.values()) {
+    list.sort((x, y) => x.d - y.d || x.other - y.other)
+    for (let k = 0; k < list.length && k < cap; k++) kept.add(list[k].key)
+  }
+
+  // 3. Enforce the degree cap for real. The union in step 2 can push a node above
+  //    `cap` because every neighbour also chose it, so walk the kept edges from
+  //    farthest to nearest and drop any edge whose endpoint is still over cap.
+  //    Removing never raises a degree, so one ordered pass bounds every node at
+  //    `cap` without a fixed-point loop. Farthest goes first on purpose: keeping
+  //    the strongest edges is the whole point of a similarity layer.
+  const keptEdges = [...kept].map(key => candidate.get(key))
+  keptEdges.sort((x, y) => y.d - x.d || y.i - x.i || y.j - x.j)
+  const degree = new Map()
+  for (const e of keptEdges) {
+    degree.set(e.i, (degree.get(e.i) ?? 0) + 1)
+    degree.set(e.j, (degree.get(e.j) ?? 0) + 1)
+  }
+  for (const e of keptEdges) {
+    if ((degree.get(e.i) ?? 0) <= cap && (degree.get(e.j) ?? 0) <= cap) continue
+    kept.delete(e.key)
+    degree.set(e.i, degree.get(e.i) - 1)
+    degree.set(e.j, degree.get(e.j) - 1)
+  }
+
+  // 4. Emit, sorted on the rounded value actually printed.
+  const round = v => Math.round(v * 10000) / 10000
+  const out = []
+  for (const key of kept) {
+    const { i, j, d } = candidate.get(key)
+    out.push({ a: ids[i], b: ids[j], distance: round(d) })
+  }
+  out.sort((x, y) => x.distance - y.distance || cmpStr(x.a, y.a) || cmpStr(x.b, y.b))
+  return out
+}
+
+/** Code-unit string compare: locale-independent, so ordering is reproducible. */
+function cmpStr(a, b) {
+  const x = String(a)
+  const y = String(b)
+  return x < y ? -1 : x > y ? 1 : 0
+}
+
 /**
  * Embed a small set of texts with the configured endpoint.
  *
@@ -226,6 +335,15 @@ export async function scoreGoals(items, options = {}) {
     if (w.kind === 'turn') turnIndex.set(`${w.gi}:${w.ti}`, i)
   })
 
+  // Goal objective vectors, in item order. These were embedded above as part of
+  // the normal scoring work, so the link layer below costs no extra API calls.
+  const goalVectors = []
+  const goalIds = []
+  for (let gi = 0; gi < items.length; gi++) {
+    goalVectors.push(vectors[goalIndex.get(gi)])
+    goalIds.push(items[gi].goalId)
+  }
+
   const scored = []
   const worst = []
   for (let gi = 0; gi < items.length; gi++) {
@@ -261,6 +379,11 @@ export async function scoreGoals(items, options = {}) {
       completed: goal.completed,
       cwd: goal.cwd,
       sessionId: goal.sessionId,
+      // Timestamps for the chart's angle encoding. Both already exist upstream
+      // (collectGoals / session-reader); absent values stay explicitly null so
+      // the client can tell "no data" from "not provided by this version".
+      createdAt: goal.createdAt ?? null,
+      sessionStartedAt: goal.turns?.[0]?.started ?? null,
       turnCount: turnsOut.length,
       scorableTurns: dists.length,
       failedCalls: goal.failedCalls ?? 0,
@@ -280,6 +403,11 @@ export async function scoreGoals(items, options = {}) {
     turns: scored.reduce((s, g) => s + g.turnCount, 0),
     scorableTurns: scored.reduce((s, g) => s + g.scorableTurns, 0),
     items: scored,
+    // Goal-to-goal edges from the vectors already computed above. Empty when
+    // no goal is close enough to another — that is a real answer, not an error.
+    links: buildGoalLinks(goalVectors, goalIds),
+    // Echo the rules so the client and README cannot drift from the server.
+    linkRules: { maxDistance: 0.42, maxDegree: 3 },
     worstTurns: worst.slice(0, 20)
   }
 }