@bongos/core 1.19.963 → 1.19.964

package/docs/module-api-changelog.md

@@ -2400,5 +2400,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.961 with no explicit bump. run 35761137402. (task 1002620)
   1.19.963 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.962 with no explicit bump. run 35770645163. (task 1002620)
+  1.19.964 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.963 with no explicit bump. run 35787848112. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/hall-ui/public/goal-forest-lib.js

@@ -0,0 +1,229 @@
+// goal-forest-lib.js — the per-goal dependency forest's model and layout, pure
+// (task 1003480, goal 1000089, ADR 0227 §6 item 4 and its §10.5 amendment).
+//
+// NOT A ZOOM OF A GLOBAL MAP (ADR 0227 §1). This draws the tasks INSIDE one
+// already-open goal that depend on each other, at full resolution — there is
+// no aggregation to do, because a per-goal forest is small by measurement
+// (§10.5: largest 127 tasks, median 9). goal-map-lib.js earns its clustering
+// and stand-alone-list machinery because ~half of ~70 GOALS have no edge; here
+// every task this file is ever handed already has one (the server omits the
+// rest, §3's own finding), so there is no isolated set to split out and no
+// shelf-packing needed for many small independent clusters — one layered
+// picture is the whole page.
+//
+// THE LAYERING IS THE SAME IDEA as the goal map's: a task sits one column
+// right of the furthest task it depends on, deterministic (no random seed),
+// so two disjoint chains in one goal share the picture without overlapping —
+// they simply occupy different rows within whichever columns their own depths
+// land on.
+//
+// THE TABLE IS THE PAGE, THE PICTURE IS THE ENHANCEMENT (ADR 0227 §5) — every
+// fact here is also a tableRows() row, and the page ships the table by default.
+//
+// Pure — no window, no DOM, no fetch — and Node-require-safe (the
+// goal-map-lib.js / goals-lib.js precedent) so tests/goal_forest_lib.mjs runs
+// the real layout instead of agreeing with a copy of it.
+(function (root, factory) {
+  var mod = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = mod;
+  else root.OTBGoalForestLib = mod;
+}(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  var NODE_W = 168;
+  var NODE_H = 52;
+  var GAP_X = 52;
+  var GAP_Y = 14;
+  var PAD = 16;
+  var TITLE_CHARS = 24;
+
+  function num(id) { return Number(id); }
+  function byNumericId(a, b) { return num(a) - num(b); }
+  function clip(text, max) {
+    var t = String(text == null ? '' : text);
+    return t.length > max ? t.slice(0, max - 1).replace(/\s+$/, '') + '…' : t;
+  }
+  function plural(n, one, many) { return n + ' ' + (n === 1 ? one : (many || one + 's')); }
+
+  // analyse — nodes by id, who each task waits on and who needs it, and the
+  // components (for the table's grouping and the summary sentence only — the
+  // layout itself does not need them, unlike the goal map's shelf-packing).
+  function analyse(payload) {
+    var rawNodes = (payload && Array.isArray(payload.nodes)) ? payload.nodes : [];
+    var rawEdges = (payload && Array.isArray(payload.edges)) ? payload.edges : [];
+    var byId = {};
+    var order = [];
+    rawNodes.forEach(function (n) {
+      var id = String(n.task_id);
+      if (byId[id]) return;
+      byId[id] = Object.assign({}, n, { id: id });
+      order.push(id);
+    });
+
+    var waits = {};
+    var needed = {};
+    var edges = [];
+    var seen = {};
+    rawEdges.forEach(function (e) {
+      var from = String(e.from);
+      var to = String(e.to);
+      if (from === to || !byId[from] || !byId[to] || seen[from + '>' + to]) return;
+      seen[from + '>' + to] = true;
+      edges.push({ from: from, to: to });
+      (waits[from] = waits[from] || []).push(to);
+      (needed[to] = needed[to] || []).push(from);
+    });
+    Object.keys(waits).forEach(function (k) { waits[k].sort(byNumericId); });
+    Object.keys(needed).forEach(function (k) { needed[k].sort(byNumericId); });
+
+    var parent = {};
+    function find(x) { while (parent[x] !== x) { parent[x] = parent[parent[x]]; x = parent[x]; } return x; }
+    function union(a, b) { var ra = find(a); var rb = find(b); if (ra !== rb) parent[rb] = ra; }
+    order.forEach(function (id) { parent[id] = id; });
+    edges.forEach(function (e) { union(e.from, e.to); });
+    var groups = {};
+    order.forEach(function (id) { (groups[find(id)] = groups[find(id)] || []).push(id); });
+    var chains = Object.keys(groups).map(function (k) { return groups[k].sort(byNumericId); });
+    chains.sort(function (a, b) { return (b.length - a.length) || byNumericId(a[0], b[0]); });
+    var chainOf = {};
+    chains.forEach(function (ids, i) { ids.forEach(function (id) { chainOf[id] = { index: i + 1, size: ids.length }; }); });
+
+    return { order: order, byId: byId, edges: edges, waits: waits, needed: needed, chains: chains, chainOf: chainOf };
+  }
+
+  // A task sits one column right of the furthest task it depends on. A cycle
+  // (illegal by DB constraint for task deps, but this file trusts nothing it
+  // did not check itself) cannot advance past it, matching goal-map-lib.js.
+  function layerOf(ids, waits) {
+    var depth = {};
+    var state = {};
+    function visit(id) {
+      if (state[id] === 2) return depth[id];
+      if (state[id] === 1) return -1;
+      state[id] = 1;
+      var d = 0;
+      (waits[id] || []).forEach(function (dep) {
+        var dd = visit(dep);
+        if (dd >= 0) d = Math.max(d, dd + 1);
+      });
+      state[id] = 2;
+      depth[id] = d;
+      return d;
+    }
+    ids.forEach(visit);
+    return depth;
+  }
+
+  function orderColumns(columns, neighbours) {
+    var pos = {};
+    columns.forEach(function (col) { col.forEach(function (id, i) { pos[id] = i; }); });
+    var layerOfId = {};
+    columns.forEach(function (col, li) { col.forEach(function (id) { layerOfId[id] = li; }); });
+    for (var sweep = 0; sweep < 4; sweep++) {
+      var down = sweep % 2 === 0;
+      var from = down ? 1 : columns.length - 2;
+      var to = down ? columns.length : -1;
+      for (var li = from; li !== to; li += down ? 1 : -1) {
+        var col = columns[li];
+        var key = {};
+        col.forEach(function (id) {
+          var ns = (neighbours[id] || []).filter(function (n) { return down ? layerOfId[n] < li : layerOfId[n] > li; });
+          key[id] = ns.length ? ns.reduce(function (s, n) { return s + pos[n]; }, 0) / ns.length : pos[id];
+        });
+        col.sort(function (a, b) { return (key[a] - key[b]) || byNumericId(a, b); });
+        col.forEach(function (id, i) { pos[id] = i; });
+      }
+    }
+  }
+
+  function edgePath(dep, dependent) {
+    var x1 = dep.x + NODE_W;
+    var y1 = dep.y + NODE_H / 2;
+    var x2 = dependent.x;
+    var y2 = dependent.y + NODE_H / 2;
+    var dx = x2 > x1 ? (x2 - x1) / 2 : 44;
+    return 'M' + x1 + ' ' + y1 + ' C' + (x1 + dx) + ' ' + y1 + ' ' + (x2 - dx) + ' ' + y2 + ' ' + x2 + ' ' + y2;
+  }
+
+  // layout — ONE layered picture over every node `analyse` returned (they all
+  // carry an edge by construction — the server never hands this file a task
+  // with none). Returns the svg's own size; the page scrolls it inside its own
+  // box and NEVER lets the page body scroll sideways (ADR 0227 §5.2).
+  function layout(a) {
+    var depth = layerOf(a.order, a.waits);
+    var neighbours = {};
+    a.order.forEach(function (id) {
+      neighbours[id] = (a.waits[id] || []).concat(a.needed[id] || []);
+    });
+    var columns = [];
+    a.order.forEach(function (id) { (columns[depth[id]] = columns[depth[id]] || []).push(id); });
+    columns = columns.map(function (c) { return (c || []).sort(byNumericId); });
+    orderColumns(columns, neighbours);
+
+    var rows = columns.reduce(function (m, c) { return Math.max(m, c.length); }, 1);
+    var width = PAD * 2 + columns.length * NODE_W + Math.max(0, columns.length - 1) * GAP_X;
+    var height = PAD * 2 + rows * NODE_H + Math.max(0, rows - 1) * GAP_Y;
+    var abs = {};
+    var nodes = [];
+    columns.forEach(function (col, li) {
+      var colH = col.length * NODE_H + (col.length - 1) * GAP_Y;
+      var top = PAD + Math.round((height - PAD * 2 - colH) / 2);
+      col.forEach(function (id, i) {
+        var p = { x: PAD + li * (NODE_W + GAP_X), y: top + i * (NODE_H + GAP_Y) };
+        abs[id] = p;
+        nodes.push({ id: id, x: p.x, y: p.y, w: NODE_W, h: NODE_H });
+      });
+    });
+
+    var edges = a.edges.map(function (e) {
+      return { from: e.from, to: e.to, d: edgePath(abs[e.to], abs[e.from]) };
+    });
+    return { width: width, height: height, nodes: nodes, edges: edges, nodeW: NODE_W, nodeH: NODE_H };
+  }
+
+  var PRIORITY_LABEL = { 1: 'P1', 2: 'P2', 3: 'P3', 4: 'P4', 5: 'P5' };
+  function priorityLabel(p) { return p != null && PRIORITY_LABEL[p] ? PRIORITY_LABEL[p] : '—'; }
+
+  // tableRows — the primary surface. One row per task, both directions of its
+  // dependency by name.
+  function tableRows(a) {
+    function named(ids) {
+      return (ids || []).map(function (id) { return { id: id, title: a.byId[id] ? a.byId[id].title : ('task ' + id) }; });
+    }
+    var rows = a.order.map(function (id) {
+      var n = a.byId[id];
+      var ch = a.chainOf[id];
+      return {
+        id: id,
+        title: n.title || ('Task ' + id),
+        status: n.status || '',
+        priority: priorityLabel(n.priority),
+        waits: named(a.waits[id]),
+        needed: named(a.needed[id]),
+        chain: ch ? ch.index : 0,
+        chainSize: ch ? ch.size : 1,
+        chainLabel: ch && ch.size > 1 ? 'Chain ' + ch.index + ' · ' + plural(ch.size, 'task') : 'Its own pair',
+      };
+    });
+    rows.sort(function (x, y) { return (x.chain - y.chain) || byNumericId(x.id, y.id); });
+    return rows;
+  }
+
+  // describe — states the shape out loud, in numbers only. No `|| a.chains.length`
+  // fallback: every id in a.order arrived with at least one surviving edge (the
+  // server's own contract, restated at the top of this file), so a chain of size
+  // 1 cannot occur here — a fallback that could say so would be lying about data
+  // this file is never actually handed.
+  function describe(a) {
+    var n = a.order.length;
+    if (!n) return 'No task in this goal depends on another task in this goal.';
+    var multi = a.chains.filter(function (c) { return c.length > 1; }).length;
+    return plural(n, 'task') + ' in this goal ' + (n === 1 ? 'has' : 'have') + ' a dependency on another task in this goal, '
+      + 'in ' + plural(multi, 'chain') + '.';
+  }
+
+  return {
+    analyse: analyse, layout: layout, tableRows: tableRows, describe: describe,
+    clip: clip, plural: plural, priorityLabel: priorityLabel, TITLE_CHARS: TITLE_CHARS,
+  };
+}));

package/modules/hall-ui/public/goal-forest-render.js

@@ -0,0 +1,151 @@
+// goal-forest-render.js — draws the per-goal task dependency forest on the
+// Goals page (task 1003480, goal 1000089, ADR 0227 §6 item 4 and its §10.5
+// amendment). Carved out of goals-render.js on arrival: that file is at the
+// 1,500-line fitness ratchet with "neither half has much room" (its own
+// header), so a new self-contained feature is its own file — the same
+// separation goal-map.js already keeps from goals-render.js, one file down.
+//
+// NOT a band column, unlike Completion/Members/Conflicts on the same detail
+// page: a node-link picture needs real width, and this is bounded small BY
+// DESIGN (ADR 0227 §3's own finding — the tasks a forest omits are exactly
+// the ones with nothing to connect them to), so there is no cap-and-"view
+// all" split here. What renders is always the whole forest returned by GET
+// /goals/:id/dependency-forest. The model + layout are goal-forest-lib.js
+// (pure); this file only draws what it returns, with createElementNS +
+// textContent — the atlas / goal-map.js idiom — so a task title never
+// becomes markup.
+//
+// A factory, the goals-render.js precedent, because `state` keeps changing
+// after load: `createGoalForestRender(ctx)` takes the SAME `{ API, state,
+// sameId, getJSON }` slice of ctx goals-page.js already builds, and returns
+// `{ loadDependencyForest, renderDependencyForest }` for goals-render.js to
+// call from renderDetail() and for tests/goal_forest_page.mjs to call directly.
+(function () {
+  'use strict';
+
+  const SVGNS = 'http://www.w3.org/2000/svg';
+
+  window.OTBGoalForestRender = function createGoalForestRender(ctx) {
+    const { API, state, sameId, getJSON } = ctx;
+    const { escapeHtml, $ } = window.OTB;
+    const lib = window.OTBGoalForestLib;
+
+    function setCount(sel, n) {
+      const el = $(sel);
+      if (!el) return;
+      el.hidden = false;
+      el.textContent = String(n);
+    }
+
+    function svgEl(tag, attrs, parent) {
+      const el = document.createElementNS(SVGNS, tag);
+      Object.keys(attrs || {}).forEach((k) => el.setAttribute(k, attrs[k]));
+      if (parent) parent.appendChild(el);
+      return el;
+    }
+    function text(parent, cls, x, y, content) {
+      const t = svgEl('text', { class: cls, x, y }, parent);
+      t.textContent = content;
+      return t;
+    }
+    function drawForest(a, lay) {
+      const svg = svgEl('svg', {
+        class: 'gf-svg', viewBox: `0 0 ${lay.width} ${lay.height}`, width: lay.width, height: lay.height,
+        role: 'img', 'aria-labelledby': 'goal-deps-h', focusable: 'false',
+      });
+      const defs = svgEl('defs', {}, svg);
+      const marker = svgEl('marker', { id: 'gf-arrow', viewBox: '0 0 10 10', refX: 9, refY: 5, markerWidth: 7, markerHeight: 7, orient: 'auto' }, defs);
+      svgEl('path', { class: 'gf-arrowhead', d: 'M0 0 L10 5 L0 10 z' }, marker);
+
+      const edges = svgEl('g', { class: 'gf-edges' }, svg);
+      lay.edges.forEach((e) => {
+        const path = svgEl('path', { class: 'gf-edge', d: e.d, 'marker-end': 'url(#gf-arrow)' }, edges);
+        const dependent = a.byId[e.from];
+        const dependency = a.byId[e.to];
+        svgEl('title', {}, path).textContent = `#${e.from} ${dependent ? dependent.title : ''} waits on #${e.to} ${dependency ? dependency.title : ''}`;
+      });
+
+      const nodes = svgEl('g', { class: 'gf-nodes' }, svg);
+      lay.nodes.forEach((p) => {
+        const n = a.byId[p.id];
+        const g = svgEl('g', { class: 'gf-node', transform: `translate(${p.x} ${p.y})` }, nodes);
+        svgEl('title', {}, g).textContent = `#${p.id} ${n.title || ''} — ${n.status || ''} — waits on ${n.depends_on || 0}, needed by ${n.depended_on_by || 0}`;
+        svgEl('rect', { class: 'gf-card', width: p.w, height: p.h, rx: 8 }, g);
+        text(g, 'gf-name', 16, 21, `#${p.id} ${lib.clip(n.title || '', lib.TITLE_CHARS)}`);
+        text(g, 'gf-sub', 16, 37, `${lib.priorityLabel(n.priority)} · ${n.status || ''}`);
+      });
+      return svg;
+    }
+
+    function renderDependencyForest() {
+      const lede = $('#goal-deps-lede');
+      const body = $('#goal-deps-body');
+      if (!lede || !body) return;
+      if (state.forestError) {
+        lede.textContent = 'Couldn’t load this goal’s task dependencies right now.';
+        body.innerHTML = '';
+        const countPill = $('#goal-deps-count');
+        if (countPill) countPill.hidden = true;
+        return;
+      }
+      if (!state.forest) {
+        lede.textContent = 'Reading…';
+        body.innerHTML = '';
+        return;
+      }
+      const a = lib.analyse(state.forest);
+      const countPill = $('#goal-deps-count');
+      if (!a.order.length) {
+        if (countPill) countPill.hidden = true;
+        lede.textContent = 'No task in this goal depends on another task in this goal.';
+        body.innerHTML = '';
+        return;
+      }
+      setCount('#goal-deps-count', a.order.length);
+      lede.innerHTML = `${escapeHtml(lib.describe(a))} An arrow runs from the task that has to ship first to the task that waits on it. `
+        + 'Every task here, and every dependency, is also in the table below.';
+      const rows = lib.tableRows(a);
+      const taskHref = (id) => `#/task/${encodeURIComponent(id)}`;
+      const depList = (list) => (list.length
+        ? `<ul class="gf-deps">${list.map((x) => `<li><a href="${taskHref(x.id)}">#${escapeHtml(x.id)} ${escapeHtml(x.title)}</a></li>`).join('')}</ul>`
+        : '<span class="gf-none">—</span>');
+      const rowHtml = (r) => `<tr>
+          <td><a class="lb-name" href="${taskHref(r.id)}">#${escapeHtml(r.id)} ${escapeHtml(r.title)}</a></td>
+          <td>${escapeHtml(r.status)}</td>
+          <td>${escapeHtml(r.priority)}</td>
+          <td>${depList(r.waits)}</td>
+          <td>${depList(r.needed)}</td>
+          <td>${escapeHtml(r.chainLabel)}</td>
+        </tr>`;
+      body.innerHTML = `
+        <figure class="gf-figure">
+          <div class="gf-scroll" tabindex="0" role="region" aria-label="Task dependency forest — scrolls sideways inside this box"></div>
+        </figure>
+        <table class="ledger gf-table">
+          <thead><tr><th>Task</th><th>Status</th><th>Priority</th><th>Waits on</th><th>Needed by</th><th>Chain</th></tr></thead>
+          <tbody>${rows.map(rowHtml).join('')}</tbody>
+        </table>`;
+      body.querySelector('.gf-scroll').appendChild(drawForest(a, lib.layout(a)));
+    }
+
+    async function loadDependencyForest(goalId) {
+      state.forest = null;
+      state.forestError = false;
+      renderDependencyForest();
+      try {
+        const data = await getJSON(`${API}/goals/${encodeURIComponent(goalId)}/dependency-forest`);
+        if (!sameId(state.current, goalId)) return;
+        state.forest = data;
+        renderDependencyForest();
+      } catch (err) {
+        if (!sameId(state.current, goalId)) return;
+        if (err && err.message === 'redirecting to auth') return;
+        console.error('[goals] dependency forest load failed', err);
+        state.forestError = true;
+        renderDependencyForest();
+      }
+    }
+
+    return { loadDependencyForest, renderDependencyForest };
+  };
+})();

package/modules/hall-ui/public/goals-page.js

@@ -86,6 +86,12 @@
     // active" sort costs no extra request. A goal with no tasks is absent here
     // and falls back to its own goals.updated_at (see goalActivityMs).
     activity: new Map(),
+    // task 1003480 — the open goal's per-task dependency forest (GET
+    // /goals/:id/dependency-forest), the ADR 0227 §6 item 4 drill-down. null
+    // while loading; forestError distinguishes "still loading" from "the read
+    // failed" so the section can say which rather than looking permanently empty.
+    forest: null,
+    forestError: false,
   };
 
   async function getJSON(path) {

package/modules/hall-ui/public/goals-render.js

@@ -29,6 +29,7 @@
     const { DONE_STATUSES, CUT_STATUSES, isTodoStatus, ring, memberName,
       readinessOf, EMPTY_ROLLUP, goalRollLine, matchesTodoSearch,
       msOf, taskActivityMs, subtitleAttr, subtitleLine, applyGoalProse } = window.OTBGoalsLib;
+    const forestRender = window.OTBGoalForestRender(ctx);
 
   const CONFLICT_CAP = 3;
   // task 1828 — the band's Completion / Members / Conflicts columns each cap
@@ -622,6 +623,12 @@
     const back = $('#goal-conflicts-back');
     if (back && state.current != null) back.setAttribute('href', `#/goal/${state.current}`);
   }
+  // task 1003480 — the per-goal task dependency forest is drawn by its own
+  // module now (goal-forest-render.js, carved out to keep this file under the
+  // ratchet); `forestRender` below is that module's factory, given the same
+  // ctx slice it needs.
+  const { loadDependencyForest, renderDependencyForest } = forestRender;
+
   const isPending = (c) => !c.satisfied && !!c.pending_review;
   // criterionlessTaskCount: task 1003157's DONE WHEN item 2 — the count of this
   // goal's tasks linked to no criterion, rendered beside the criteria rollup so
@@ -901,6 +908,7 @@
     renderMembers();
 
     loadGoalTasks(g.id);
+    loadDependencyForest(g.id);
     // task 1953 — my own pending request (any viewer) + the goal's pending queue
     // (managers only); async, re-renders Actions + the pending panel on arrival.
     loadGoalMembership(g.id, canManage);
@@ -1461,6 +1469,6 @@
     return d;
   }
 
-    return { GOAL_SORTS, WORK_SORT_HEADERS, errCode, errDetails, friendlyClaimError, goalSel, goalSelTotal, loadDetail, loadDirectory, loadGoalTasks, pagers, reflectSortHeaders, renderDetail, renderGoalBulkToolbar, renderList, renderTodoCards, renderWork };
+    return { GOAL_SORTS, WORK_SORT_HEADERS, errCode, errDetails, friendlyClaimError, goalSel, goalSelTotal, loadDependencyForest, loadDetail, loadDirectory, loadGoalTasks, pagers, reflectSortHeaders, renderDependencyForest, renderDetail, renderGoalBulkToolbar, renderList, renderTodoCards, renderWork };
   };
 })();

package/modules/hall-ui/public/goals.css

@@ -483,3 +483,29 @@
 .arch-panel__foot { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
 .arch-panel__foot input { flex: 1; min-width: 200px; }
 .arch-panel__err { margin-top: 8px; font-size: 12.5px; color: var(--danger); }
+
+/* task 1003480 — the per-goal task dependency forest (ADR 0227 §6 item 4). The
+   TABLE is the section (below); this is only the node-link figure, drawn with
+   createElementNS (goal-map.css's sibling — a plain card + edge, no category
+   colour channel here, since a task carries a priority, not a category).
+   The figure scrolls INSIDE its own box and names BOTH overflow axes (task
+   1004130) so the page itself never scrolls sideways. */
+.gf-figure { margin: 0 0 14px; }
+.gf-scroll {
+  overflow-x: auto;
+  overflow-y: hidden;
+  max-width: 100%;
+  border: var(--line) solid var(--rule-soft);
+  border-radius: var(--radius);
+  background: color-mix(in srgb, var(--ink) 3%, var(--bg-card));
+}
+.gf-scroll:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
+.gf-svg { display: block; }
+.gf-edge { fill: none; stroke: var(--ink-faint); stroke-width: 1.5; opacity: 0.85; }
+.gf-arrowhead { fill: var(--ink-faint); }
+.gf-card { fill: var(--bg-card); stroke: var(--rule); stroke-width: 1; }
+.gf-name { font: 600 12.5px var(--font-body); fill: var(--ink); }
+.gf-sub { font: 500 11px var(--font-body); fill: var(--ink-faint); }
+.gf-table .gf-deps { margin: 0; padding: 0; list-style: none; min-width: 12rem; }
+.gf-table .gf-deps li { font-size: 12.5px; line-height: 1.4; }
+.gf-none { color: var(--ink-faint); }

package/modules/hall-ui/public/goals.html

@@ -130,6 +130,18 @@
             </div>
           </div>
 
+          <!-- task 1003480 (ADR 0227 §6 item 4 + §10.5): the per-goal task
+               dependency forest. Its own full-width section, not a band
+               column — a node-link picture needs real width, and (unlike
+               Completion/Members/Conflicts) this is bounded small BY DESIGN
+               (ADR 0227 §3's own finding), so there is no "view all" split:
+               what renders here is the whole forest, every time. -->
+          <div class="scroll" style="margin-top:20px" id="goal-deps-scroll">
+            <h2 class="scroll__h" id="goal-deps-h">Task dependencies<span class="count-pill" id="goal-deps-count" hidden></span></h2>
+            <p class="scroll__lede" id="goal-deps-lede">Reading…</p>
+            <div id="goal-deps-body"></div>
+          </div>
+
           <div class="scroll" style="margin-top:20px">
             <div class="goal-work__head">
               <h2 class="scroll__h">Tasks</h2>
@@ -234,6 +246,13 @@
 <script src="/builders/task-detail.js?v=2026-07-03-taskdetail"></script>
 <script src="/builders/brand-apply.js?v=2026-06-27-r75"></script>
 <script src="/builders/goals-lib.js?v=2026-08-21-goalslib1"></script>
+<!-- task 1003480: the per-goal dependency forest's pure model + layout —
+     goal-map-lib.js's sibling, loaded before the renderer that draws it. -->
+<script src="/builders/goal-forest-lib.js"></script>
+<!-- task 1003480: the forest's own drawing module — goal-map.js's sibling,
+     carved out of goals-render.js to keep that file under the size ratchet.
+     Loaded before goals-render.js, which calls window.OTBGoalForestRender(ctx). -->
+<script src="/builders/goal-forest-render.js"></script>
 <!-- task 1003206: the page RENDERERS, the second half of the carve goals-lib.js
      began — goals-lib took the pure helpers, this takes the view painters.
      Loaded BEFORE goals-page.js, which calls window.OTBGoalsRender(ctx). -->

package/modules/lifecycle/goal-forest.js

@@ -0,0 +1,135 @@
+'use strict';
+
+// modules/lifecycle/goal-forest.js — the per-goal dependency forest: the DRILL-
+// DOWN behind GET /goals/:id/dependency-forest (task 1003480, goal 1000089,
+// ADR 0227 §6 item 4 and its §10.5 amendment).
+//
+// NOT A ZOOM OF THE GOAL MAP (ADR 0227 §1). goal-graph.js draws goal-to-goal
+// edges, aggregated; this draws the TASK-to-task edges INSIDE one goal, at full
+// resolution — queried only when that one goal is opened, never as a slice of a
+// global read. A dependency whose two tasks sit in DIFFERENT goals belongs to
+// the goal map instead (goal-graph.js's own header says exactly the reverse of
+// this filter), so the two views partition the corpus rather than overlapping.
+//
+// SCOPED, NOT SAMPLED. ADR 0227 §3 measured this as covering 3–40% of the
+// corpus and never 100%, and §10.5 confirmed it against the real database
+// (23.61% of tasks carry an edge) — that is the finding, not a gap. The tasks
+// left out are exactly the ones with nothing to connect them to, so this file
+// returns ONLY the tasks that have an edge within this goal; a goal whose tasks
+// carry none returns an empty forest and the page says so plainly.
+//
+// A private goal's own gate has already run by the time this is asked for — a
+// forest is requested from an already-open goal detail page, never cold — so
+// this file re-derives no visibility of its own.
+
+const api = require('../../src/module-api');
+const { pool } = api;
+
+// goalForestRows — the two raw reads. `edges`: one row per task-level dependency
+// whose BOTH endpoints sit in `goalId` (the ADR 0227 §10.5 measurement's own
+// filter — see scripts/gds/spike-task-map.js's per-goal grouping). `tasks`: the
+// facts for exactly the task ids that appear in at least one such edge — never
+// the goal's whole task list, which the page already holds from GET
+// /tasks?goal_id=.
+async function goalForestRows(goalId, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const edges = await activePool.query(
+    `SELECT ft.id::text AS from_task_id,
+            tt.id::text AS to_task_id
+       FROM dependencies d
+       JOIN tasks ft ON d.from_kind = 'task' AND ft.id = d.from_id
+       JOIN tasks tt ON d.to_kind   = 'task' AND tt.id = d.to_id
+      WHERE ft.goal_id = $1 AND tt.goal_id = $1
+      ORDER BY ft.id, tt.id`,
+    [goalId]
+  );
+  const ids = new Set();
+  for (const r of edges.rows) { ids.add(r.from_task_id); ids.add(r.to_task_id); }
+  if (!ids.size) return { edges: [], tasks: [] };
+  const tasks = await activePool.query(
+    `SELECT id::text, title, status, priority
+       FROM tasks
+      WHERE id = ANY($1::bigint[])
+      ORDER BY id`,
+    [[...ids].map(Number)]
+  );
+  return { edges: edges.rows, tasks: tasks.rows };
+}
+
+// shapeForest — the wire shape. Pure, so a test pins it with no database.
+//
+//   nodes: [{ task_id, title, status, priority, depends_on, depended_on_by }]
+//   edges: [{ from, to }]      — `from` waits on `to`
+//   counts: { tasks, edges }
+//
+// An edge whose endpoint task is missing from `tasks` (a stale row racing a
+// delete) is dropped, not drawn to nowhere — the same rule goal-graph.js's
+// shapeGraph applies for the same reason.
+function shapeForest({ edges = [], tasks = [] } = {}) {
+  const known = new Set(tasks.map((t) => String(t.id)));
+  const kept = [];
+  const seen = new Set();
+  for (const e of edges) {
+    const from = String(e.from_task_id);
+    const to = String(e.to_task_id);
+    if (from === to || !known.has(from) || !known.has(to)) continue;
+    const key = `${from}>${to}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    kept.push({ from, to });
+  }
+
+  const waitsOn = new Map();
+  const blocks = new Map();
+  for (const e of kept) {
+    if (!waitsOn.has(e.from)) waitsOn.set(e.from, new Set());
+    waitsOn.get(e.from).add(e.to);
+    if (!blocks.has(e.to)) blocks.set(e.to, new Set());
+    blocks.get(e.to).add(e.from);
+  }
+
+  // Only tasks touched by a KEPT edge become nodes — a task whose only edge was
+  // dropped above (stale endpoint) must not appear as a lone, edge-less node.
+  const touched = new Set();
+  kept.forEach((e) => { touched.add(e.from); touched.add(e.to); });
+  const nodes = tasks.filter((t) => touched.has(String(t.id))).map((t) => {
+    const id = String(t.id);
+    return {
+      task_id: id,
+      title: t.title,
+      status: t.status,
+      priority: t.priority != null ? Number(t.priority) : null,
+      depends_on: (waitsOn.get(id) || new Set()).size,
+      depended_on_by: (blocks.get(id) || new Set()).size,
+    };
+  });
+
+  return { nodes, edges: kept, counts: { tasks: nodes.length, edges: kept.length } };
+}
+
+// goalForest — read + shape.
+async function goalForest(goalId, deps = {}) {
+  const rows = await goalForestRows(goalId, deps);
+  return shapeForest(rows);
+}
+
+// goalForestHandler — GET /goals/:id/dependency-forest. A factory (the
+// goal-category.js / goal-graph.js precedent) so a test drives it with a stub
+// read and no database.
+function goalForestHandler({ getGoal, read = goalForest, parseId, log = console } = {}) {
+  return async function getGoalForest(req, res) {
+    const id = parseId(req, res, { code: 'bad_goal_id' });
+    if (id === null) return;
+    try {
+      const goal = await getGoal(id);
+      if (!goal) return res.fail('goal_not_found', 404);
+      const forest = await read(id);
+      return res.json({ ok: true, goal_id: Number(id), ...forest });
+    } catch (err) {
+      log.error('[gds] GET /goals/:id/dependency-forest', err);
+      return res.fail('forest_failed', { status: 500, message: 'internal error' });
+    }
+  };
+}
+
+module.exports = { goalForest, goalForestRows, shapeForest, goalForestHandler };