create-pmos 0.65.0 → 0.65.2

package/workspace/public/pm/doc-graph.js

@@ -0,0 +1,272 @@
+/* pm/doc-graph.js — the library of every repository file and the links the files write, drawn two ways (initiative
+ * docs-library-graph, PRD R-G1 to R-G5 and R-N1 to R-N5).
+ *
+ *   getLibrary(ws)                      GET /api/docs/library once per workspace (kept for a short while), indexed
+ *   fileGraph(lib, path, { onOpen })    one file in the middle: the files that link to it on the left, the files it
+ *                                       links to on the right, at most 7 a side; a press on a file centres the graph on
+ *                                       it, Back returns; List all N links lists every link by kind
+ *   initiativeGraph(lib, paths, …)      an initiative's files as filled dots and the outside files they link to as hollow
+ *                                       dots (at most 14, the most-connected first); a press marks a dot's lines
+ *
+ * Every line is a link a file writes (lib/kg.js on the server): a markdown link, a path in the header, the initiative, the
+ * anchor, a decision number. Nothing is inferred. The layouts are computed from the files and links alone, so the same
+ * input draws the same picture. The pictures are an SVG of lines behind real buttons, placed with --rp-x and --rp-y. On a
+ * phone neither picture is drawn: the file graph shows its list, and the initiative sheet shows its own list.
+ */
+
+import { el } from './dom.js';
+import { button, narrowViewport } from './primitives.js';
+import { pmGet } from './http.js';
+
+const NS = 'http://www.w3.org/2000/svg';
+const MAX_SIDE = 7;
+const MAX_OUTSIDE = 14;
+const LIST_CAP = 12;
+const KEEP_MS = 30000;
+
+export const GROUP_OUT = [['initiative', 'Its initiative'], ['header', 'Named in its header'], ['link', 'Links to'], ['anchor', 'Anchored to'], ['cites', 'Decisions it cites']];
+export const GROUP_IN = [['initiative', 'Its initiative'], ['header', 'Named by'], ['link', 'Linked from'], ['anchor', 'Anchors'], ['cites', 'Cited by']];
+const ROLE = { spec: 'PRD', ini: 'Initiative record', exp: 'Explainer', proto: 'Prototype' };
+
+/* ── the library ─────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const libs = new Map();   // ws -> { at, promise }
+
+/** The workspace's library, indexed, or null when it could not be read. One request per workspace while it is fresh. */
+export function getLibrary(ws, { fresh = false } = {}) {
+  const hit = libs.get(ws);
+  if (hit && !fresh && Date.now() - hit.at < KEEP_MS) return hit.promise;
+  const promise = pmGet('/api/docs/library?ws=' + encodeURIComponent(ws)).then((r) => (r && r.ok ? indexed(r) : null));
+  libs.set(ws, { at: Date.now(), promise });
+  promise.then((v) => { if (!v) libs.delete(ws); });
+  return promise;
+}
+
+/** The response with lookups: byPath, out and inn (per file: [[neighbour, kind]]), and each file's initiative. */
+export function indexed(r) {
+  const byPath = new Map(r.files.map((f, i) => [f.path, i]));
+  const out = r.files.map(() => []);
+  const inn = r.files.map(() => []);
+  for (const [a, b, k] of r.edges) { out[a].push([b, r.kinds[k]]); inn[b].push([a, r.kinds[k]]); }
+  const ini = (f) => (f.initiative && r.initiatives[f.initiative]) ? { id: f.initiative, ...r.initiatives[f.initiative] } : null;
+  return { ...r, byPath, out, inn, ini };
+}
+
+const KIND_RANK = { initiative: 0, header: 1, link: 2, anchor: 3, cites: 4 };
+/** One entry per neighbour (its strongest kind), cites last, then the same initiative first, then newest first. */
+function neighbours(lib, i) {
+  const me = lib.files[i].initiative;
+  const uniq = (xs) => {
+    const m = new Map();
+    for (const x of xs) if (x[0] !== i && (!m.has(x[0]) || KIND_RANK[x[1]] < KIND_RANK[m.get(x[0])[1]])) m.set(x[0], x);
+    return [...m.values()].sort((a, b) => {
+      const A = lib.files[a[0]]; const B = lib.files[b[0]];
+      return (a[1] === 'cites') - (b[1] === 'cites')
+        || (B.initiative && B.initiative === me) - (A.initiative && A.initiative === me)
+        || String(B.date || '').localeCompare(String(A.date || ''))
+        || A.path.localeCompare(B.path);
+    });
+  };
+  return { out: uniq(lib.out[i]), inn: uniq(lib.inn[i]) };
+}
+
+const clip = (t, n) => (t.length > n ? t.slice(0, n - 1) + '…' : t);
+const svg = (tag, attrs = {}) => { const n = document.createElementNS(NS, tag); for (const [k, v] of Object.entries(attrs)) if (v != null) n.setAttribute(k, String(v)); return n; };
+const place = (node, vars) => { for (const [k, v] of Object.entries(vars)) node.style.setProperty('--rp-' + k, String(Math.round(v * 100) / 100)); return node; };
+
+/* ── one file's links ────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/**
+ * The links of one file. `onOpen(path, title)` opens a file in the reader. Returns an element that redraws itself: a press
+ * on a neighbour centres the graph on it, Back returns. On a phone the list is shown in place of the picture.
+ */
+export function fileGraph(lib, path, { onOpen } = {}) {
+  const start = lib.byPath.get(path);
+  const wrap = el('div', { class: 'rp-graph', 'data-graph': path });
+  if (start === undefined) { wrap.appendChild(el('p', { class: 'rp-graph__hint' }, 'This file is not in the library yet. It shows after its first commit.')); return wrap; }
+  const stack = [start];
+  const state = { list: false, more: new Set() };
+  const go = (j) => { stack.push(j); state.list = false; state.more.clear(); draw(); };
+  const draw = () => {
+    const i = stack[stack.length - 1];
+    const f = lib.files[i];
+    const { out, inn } = neighbours(lib, i);
+    const narrow = narrowViewport();
+    wrap.setAttribute('data-graph-focus', f.path);
+    const head = el('div', { class: 'rp-graph__head' },
+      stack.length > 1 ? button({ label: 'Back', icon: 'arrow-left', variant: 'ghost', size: 'sm', attrs: { 'data-graph-act': 'back' }, onClick: () => { stack.pop(); state.list = false; draw(); } }) : null,
+      el('span', { class: 'rp-graph__title' }, el('strong', null, clip(f.title, 80)), ` · ${inn.length === 1 ? '1 file links' : inn.length + ' files link'} here, it links to ${out.length}`),
+      onOpen ? button({ label: 'Open file', variant: 'outline', size: 'sm', attrs: { 'data-graph-act': 'open' }, onClick: () => onOpen(f.path, f.title) }) : null);
+    const kids = [head];
+    if (!inn.length && !out.length) {
+      kids.push(el('p', { class: 'rp-graph__hint' }, 'No file links to this one, and it links to none. Only links written in the files are shown.'));
+      wrap.replaceChildren(...kids);
+      return;
+    }
+    if (!narrow) kids.push(picture(lib, i, inn, out, go));
+    const total = inn.length + out.length;
+    if (!narrow) {
+      kids.push(button({ label: state.list ? 'Hide the list' : `List all ${total} links`, variant: 'ghost', size: 'sm',
+        attrs: { 'data-graph-act': 'list', 'aria-expanded': state.list ? 'true' : 'false' }, onClick: () => { state.list = !state.list; draw(); } }));
+    }
+    if (narrow || state.list) kids.push(lists(lib, inn, out, go, state, draw));
+    kids.push(el('p', { class: 'rp-graph__hint' }, 'Only links written in the files count: a link, a path in the header, the initiative, or a decision number like D65. A dashed line is a decision it cites. Press a file to see its own links.'));
+    wrap.replaceChildren(...kids);
+  };
+  draw();
+  return wrap;
+}
+
+/** The picture: who links here (left), this file (middle), what it links to (right). */
+function picture(lib, i, inn, out, go) {
+  const L = inn.slice(0, MAX_SIDE); const R = out.slice(0, MAX_SIDE);
+  const nL = L.length + (inn.length > MAX_SIDE ? 1 : 0); const nR = R.length + (out.length > MAX_SIDE ? 1 : 0);
+  const W = 820; const RH = 34; const NW = 250; const CW = 220;
+  const H = Math.max(nL, nR, 1) * RH + 16; const cx = W / 2; const cy = H / 2;
+  const yOf = (k, n) => cy + (k - (n - 1) / 2) * RH;
+  const pic = place(el('div', { class: 'rp-graph__pic', role: 'group', 'aria-label': `${lib.files[i].title}: ${inn.length} files link here, it links to ${out.length}` }), { ar: W / H });
+  const lines = svg('svg', { class: 'rp-graph__lines', viewBox: `0 0 ${W} ${H}`, preserveAspectRatio: 'none', 'aria-hidden': 'true' });
+  const curve = (x1, y1, x2, y2, kind) => svg('path', { class: 'rp-graph__edge' + (kind === 'cites' ? ' rp-graph__edge--cites' : ''), d: `M${x1},${y1} C${(x1 + x2) / 2},${y1} ${(x1 + x2) / 2},${y2} ${x2},${y2}` });
+  L.forEach(([, k], n) => lines.appendChild(curve(NW, yOf(n, nL), cx - CW / 2, cy, k)));
+  R.forEach(([, k], n) => lines.appendChild(curve(cx + CW / 2, cy, W - NW, yOf(n, nR), k)));
+  pic.appendChild(lines);
+  const node = (j, kind, x, y, side) => place(button({ label: clip(lib.files[j].title, 40), variant: 'outline', size: 'sm',
+    attrs: { class: 'rp-graph__node rp-graph__node--' + side + (kind === 'cites' ? ' rp-graph__node--cites' : ''), title: `${lib.files[j].title}\n${lib.files[j].path}`,
+      'data-graph-node': lib.files[j].path, 'data-graph-side': side, 'data-graph-kind': kind }, onClick: () => go(j) }), { x: (x / W) * 100, y: (y / H) * 100, w: (NW / W) * 100 });
+  L.forEach(([j, k], n) => pic.appendChild(node(j, k, 0, yOf(n, nL), 'in')));
+  R.forEach(([j, k], n) => pic.appendChild(node(j, k, W - NW, yOf(n, nR), 'out')));
+  const more = (n, x, y, side) => place(el('span', { class: 'rp-graph__more rp-graph__more--' + side }, `+ ${n} more in the list`), { x: (x / W) * 100, y: (y / H) * 100, w: (NW / W) * 100 });
+  if (inn.length > MAX_SIDE) pic.appendChild(more(inn.length - MAX_SIDE, 0, yOf(L.length, nL), 'in'));
+  if (out.length > MAX_SIDE) pic.appendChild(more(out.length - MAX_SIDE, W - NW, yOf(R.length, nR), 'out'));
+  pic.appendChild(place(el('span', { class: 'rp-graph__centre', title: lib.files[i].path }, clip(lib.files[i].title, 34)), { x: ((cx - CW / 2) / W) * 100, y: (cy / H) * 100, w: (CW / W) * 100 }));
+  pic.appendChild(el('span', { class: 'rp-graph__cap rp-graph__cap--in' }, 'Links here'));
+  pic.appendChild(el('span', { class: 'rp-graph__cap rp-graph__cap--out' }, 'It links to'));
+  return pic;
+}
+
+/** Every link, both directions, grouped by kind. A group longer than 12 shows its first 12 and a Show all. */
+function lists(lib, inn, out, go, state, draw) {
+  const col = (xs, groups, label, side) => el('div', { class: 'rp-graph__col', 'data-graph-list': side },
+    el('span', { class: 'rp-graph__label' }, label),
+    groups.map(([kind, name]) => {
+      const g = xs.filter((x) => x[1] === kind);
+      if (!g.length) return null;
+      const key = side + kind;
+      const shown = state.more.has(key) ? g : g.slice(0, LIST_CAP);
+      return el('div', { class: 'rp-graph__group' },
+        el('span', { class: 'rp-graph__label' }, `${name} · ${g.length}`),
+        shown.map(([j]) => button({ label: lib.files[j].title, variant: 'ghost', size: 'sm', attrs: { class: 'rp-graph__item', title: lib.files[j].path, 'data-graph-item': lib.files[j].path }, onClick: () => go(j) })),
+        g.length > shown.length ? button({ label: `Show all ${g.length}`, variant: 'ghost', size: 'sm', onClick: () => { state.more.add(key); draw(); } }) : null);
+    }));
+  return el('div', { class: 'rp-graph__lists' }, col(inn, GROUP_IN, 'Links here', 'in'), col(out, GROUP_OUT, 'It links to', 'out'));
+}
+
+/* ── an initiative's files ───────────────────────────────────────────────────────────────────────────────────────── */
+
+/** The short label of a dot: a decision's number, the role of an initiative's file, or else its title, shortened. */
+export function roleOf(f) {
+  const d = /^(D\d+)\b/.exec(f.title);
+  if (d) return d[1];
+  if (f.category === 'eval') return /rubric/i.test(f.title + ' ' + f.path) ? 'Rubric' : /verdict/i.test(f.path) ? 'Verdict' : 'Eval';
+  return ROLE[f.category] || clip(f.title.replace(/^[^:]{1,24}:\s+/, ''), 22);
+}
+
+/**
+ * The positions of an initiative's network: its files (inner) and the outside files they link to (outer, at most 14).
+ * Pure and deterministic: the same files and links give the same positions. Exported for the tests.
+ */
+export function networkLayout(lib, paths, { W = 820, H = 460 } = {}) {
+  const inner = [...new Set(paths.map((p) => lib.byPath.get(p)).filter((x) => x !== undefined))].sort((a, b) => lib.files[a].path.localeCompare(lib.files[b].path));
+  const isIn = new Set(inner);
+  const score = new Map();
+  for (const i of inner) for (const [j] of [...lib.out[i], ...lib.inn[i]]) if (!isIn.has(j)) score.set(j, (score.get(j) || 0) + 1);
+  const outside = [...score.entries()].sort((a, b) => b[1] - a[1] || String(lib.files[b[0]].date || '').localeCompare(String(lib.files[a[0]].date || '')) || lib.files[a[0]].path.localeCompare(lib.files[b[0]].path));
+  const outer = outside.slice(0, MAX_OUTSIDE).map((x) => x[0]);
+  const ids = [...inner, ...outer];
+  const on = new Set(ids);
+  const cx = W / 2; const cy = H / 2;
+  const pos = new Map();
+  ids.forEach((i, k) => {
+    const mine = isIn.has(i); const n = mine ? inner.length : outer.length; const kk = mine ? k : k - inner.length;
+    const a = (kk / Math.max(n, 1)) * Math.PI * 2 + (mine ? 0 : 0.3); const r = mine ? 70 : 190;
+    pos.set(i, { x: cx + r * Math.cos(a) * 1.6, y: cy + r * Math.sin(a), vx: 0, vy: 0 });
+  });
+  const edges = [];
+  const seen = new Set();
+  for (const i of ids) for (const [j, kind] of lib.out[i]) {
+    if (!on.has(j) || i === j || !(isIn.has(i) || isIn.has(j))) continue;
+    const key = i + '>' + j;
+    if (seen.has(key)) continue;
+    seen.add(key); edges.push([i, j, kind]);
+  }
+  for (let it = 0; it < 500; it++) {
+    for (let a = 0; a < ids.length; a++) for (let b = a + 1; b < ids.length; b++) {
+      const A = pos.get(ids[a]); const B = pos.get(ids[b]);
+      let dx = A.x - B.x; let dy = (A.y - B.y) * 1.6;
+      const d2 = Math.max(dx * dx + dy * dy, 25); const f = 26000 / d2; const d = Math.sqrt(d2);
+      dx /= d; dy /= d; A.vx += dx * f; A.vy += dy * f; B.vx -= dx * f; B.vy -= dy * f;
+    }
+    for (const [i, j] of edges) {
+      const A = pos.get(i); const B = pos.get(j);
+      const dx = B.x - A.x; const dy = B.y - A.y; const d = Math.sqrt(dx * dx + dy * dy) || 1; const f = (d - 150) * 0.02;
+      A.vx += (dx / d) * f; A.vy += (dy / d) * f; B.vx -= (dx / d) * f; B.vy -= (dy / d) * f;
+    }
+    for (const i of ids) {
+      const P = pos.get(i); const g = isIn.has(i) ? 0.02 : 0.005;
+      P.vx += (cx - P.x) * g; P.vy += (cy - P.y) * g * 1.4;
+      P.x += Math.max(-20, Math.min(20, P.vx * 0.5)); P.y += Math.max(-20, Math.min(20, P.vy * 0.5));
+      P.vx *= 0.5; P.vy *= 0.5;
+      P.x = Math.max(30, Math.min(W - 160, P.x)); P.y = Math.max(22, Math.min(H - 22, P.y));
+    }
+  }
+  const at = new Map(ids.map((i) => [i, { x: Math.round(pos.get(i).x * 10) / 10, y: Math.round(pos.get(i).y * 10) / 10 }]));
+  return { W, H, inner, outer, left: outside.length - outer.length, edges, at };
+}
+
+/**
+ * An initiative's files as a network. `onOpen(path, title)` opens a file. Returns null on a phone: the caller shows its
+ * list instead (R-N5).
+ */
+export function initiativeGraph(lib, paths, { onOpen } = {}) {
+  if (narrowViewport()) return null;
+  const L = networkLayout(lib, paths);
+  const isIn = new Set(L.inner);
+  const wrap = el('div', { class: 'rp-net', 'data-net': '' });
+  if (!L.inner.length) { wrap.appendChild(el('p', { class: 'rp-graph__hint' }, 'None of this initiative’s files is in the library yet. They show after their first commit.')); return wrap; }
+  let sel = null;
+  const draw = () => {
+    const pic = place(el('div', { class: 'rp-net__pic', role: 'group', 'aria-label': `${L.inner.length} files of this initiative and ${L.outer.length} files outside it that they link to` }), { ar: L.W / L.H });
+    const lines = svg('svg', { class: 'rp-net__lines', viewBox: `0 0 ${L.W} ${L.H}`, preserveAspectRatio: 'none', 'aria-hidden': 'true' });
+    for (const [i, j, kind] of L.edges) {
+      const A = L.at.get(i); const B = L.at.get(j);
+      const cls = ['rp-net__edge', kind === 'cites' && 'rp-net__edge--cites', isIn.has(i) && isIn.has(j) && 'rp-net__edge--in', sel !== null && (sel === i || sel === j) && 'rp-net__edge--hot'].filter(Boolean).join(' ');
+      lines.appendChild(svg('line', { class: cls, x1: A.x, y1: A.y, x2: B.x, y2: B.y, 'data-net-edge': `${lib.files[i].path}>${lib.files[j].path}` }));
+    }
+    pic.appendChild(lines);
+    for (const i of [...L.inner, ...L.outer]) {
+      const f = lib.files[i]; const mine = isIn.has(i); const P = L.at.get(i);
+      const label = mine ? roleOf(f) : ((/^(D\d+)\b/.exec(f.title) || [])[1] || clip(f.title, 22));
+      pic.appendChild(place(button({ label: [el('span', { class: 'rp-net__dot' + (mine ? ' rp-net__dot--in' : ''), 'aria-hidden': 'true' }), el('span', { class: 'rp-net__label' }, label)],
+        variant: 'ghost', size: 'sm',
+        attrs: { class: 'rp-net__node' + (mine ? ' rp-net__node--in' : '') + (sel === i ? ' rp-net__node--sel' : ''), title: `${f.title}\n${f.path}`, 'aria-label': f.title, 'aria-pressed': sel === i ? 'true' : 'false',
+          'data-net-node': f.path, 'data-net-side': mine ? 'in' : 'out' },
+        onClick: () => { sel = sel === i ? null : i; draw(); } }), { x: (P.x / L.W) * 100, y: (P.y / L.H) * 100 }));
+    }
+    const legend = el('div', { class: 'rp-net__legend' },
+      el('span', null, el('span', { class: 'rp-net__dot rp-net__dot--in', 'aria-hidden': 'true' }), 'This initiative'),
+      el('span', null, el('span', { class: 'rp-net__dot', 'aria-hidden': 'true' }), 'Outside it'),
+      el('span', null, el('span', { class: 'rp-net__dash', 'aria-hidden': 'true' }), 'Cites a decision'),
+      L.left ? el('span', { 'data-net-left': String(L.left) }, `${L.left} more outside files are left out. Open a file in Docs to see all its links.`) : null);
+    const kids = [pic, legend];
+    if (sel !== null) {
+      const f = lib.files[sel];
+      const ini = lib.ini(f);
+      kids.push(el('div', { class: 'rp-net__sel', 'data-net-sel': f.path },
+        el('span', { class: 'rp-net__sel-text' }, el('strong', null, f.title), el('span', { class: 'rp-net__path' }, f.path + (ini && !isIn.has(sel) ? ' · ' + ini.short : ''))),
+        onOpen ? button({ label: 'Open file', variant: 'outline', size: 'sm', attrs: { 'data-net-act': 'open' }, onClick: () => onOpen(f.path, f.title) }) : null));
+    }
+    wrap.replaceChildren(...kids);
+  };
+  draw();
+  return wrap;
+}

package/workspace/public/pm/initiative-sheet.js

@@ -3,7 +3,8 @@
  * About 70% of the width on a desktop and the whole screen on a phone. Top to bottom:
  *   line 1  the title, the horizon, the health reason (only when not on track), and a meta line: lane · anchor · id
  *   line 2  the stage stepper, then "Waiting on you: approval [Open gate ▸]" or "Waiting on agent: build [Hand to agent ▸]"
- *   tabs    Breakdown (the Run 1 pane, embedded: Tree · Board, and Timeline once Run 4 registers it), Files, History,
+ *   tabs    Breakdown (the Run 1 pane, embedded: Tree · Board, and Timeline once Run 4 registers it), Files (List · Graph:
+ *           the graph is doc-graph.js, initiative docs-library-graph), History,
  *           Jira tickets (sheet-jira.js, initiative jira-wbs: the tickets drafted from the PRD and their status in Jira),
  *           People (people-link.js, initiative people-directory: who owns its items or is named in interactions about it)
  *   ⋯       horizon, check-by, lifecycle and the anchor (both PM-only: the server's guard answers), Copy CLI, Export breakdown
@@ -22,6 +23,7 @@ import { mountBreakdown, unmountBreakdown } from './panel-breakdown.js';
 import { mountJira, unmountJira } from './sheet-jira.js';
 import { initiativePeople } from './people-link.js';
 import { openDoc } from './panel-initiatives.js';
+import { getLibrary, initiativeGraph } from './doc-graph.js';
 import { openNewSession } from './panel-newsess.js';
 import { wsOf, readDoc, saveDoc } from './data.js';
 import { state, setState } from './state.js';
@@ -67,6 +69,8 @@ export function openSheet(repo, slug) {
   ensureSprite();
   let data = null;
   let tab = 'breakdown';
+  let fview = 'list';      // the Files tab: 'list' or 'graph' (docs-library-graph R-N1)
+  let lib = null;          // the library, read on the first press on Graph
   let closed = false;
   const tabId = 'initiative:' + slug;
   const crumb = el('div', { class: 'in-sheet__crumb' });
@@ -277,9 +281,27 @@ export function openSheet(repo, slug) {
         onOpen: () => { s.close(); openDoc(slug, f.path, f.label, null, f.source === 'git' ? { readonly: true } : undefined); },
         attrs: { 'data-in-file': f.kind, 'data-in-file-source': f.source || 'record' }, openAttrs: { 'data-in-file-open': f.kind },
       }));
-      panel.replaceChildren(files.length ? el('div', { class: 'in-files' }, groups.map(([src, list]) => el('section', { class: 'in-files__group', 'data-in-files': src },
+      const listView = () => (files.length ? el('div', { class: 'in-files' }, groups.map(([src, list]) => el('section', { class: 'in-files__group', 'data-in-files': src },
         el('h3', { class: 'in-files__title' }, COPY.sheet.fileSource[src] || src),
         el('div', { class: 'in-sheet__rows', role: 'list' }, list.map(fileRow))))) : empty({ text: COPY.sheet.noFiles }));
+      // List · Graph (docs-library-graph R-N1): the graph is this initiative's markdown files (the ones its record names
+      // and the ones the library's index attributes to it; a file git changed for it is evidence, not one of its files)
+      // and the outside files they link to. On a phone initiativeGraph draws nothing and the list shows (R-N5).
+      const paths = files.filter((f) => f.kind !== 'note' && (f.source || 'record') !== 'git' && /\.md$/i.test(f.path || '')).map((f) => f.path);
+      const seg = tabs({ variant: 'segmented', ariaLabel: COPY.sheet.filesAs, value: fview,
+        items: [{ id: 'list', label: COPY.sheet.filesList }, { id: 'graph', label: COPY.sheet.filesGraph }], attrs: { 'data-in-files-view': '' },
+        onChange: (id) => { if (id === fview) return; fview = id; drawPanel(); const t = panel.querySelector('[data-in-files-view] [data-tab="' + id + '"]'); if (t) t.focus({ preventScroll: true }); } });
+      const bar = el('div', { class: 'in-files__bar' }, seg, el('span', { class: 'in-files__hint' }, fview === 'graph' ? COPY.sheet.graphHint : COPY.sheet.listHint));
+      if (fview === 'list' || !paths.length) { panel.replaceChildren(bar, listView()); return; }
+      const open = (p, title) => { s.close(); openDoc(slug, p, title); };
+      const graphNow = () => { const g = lib ? initiativeGraph(lib, paths, { onOpen: open }) : null; return g || el('div', null, el('p', { class: 'in-note' }, COPY.sheet.graphPhone), listView()); };
+      if (lib) { panel.replaceChildren(bar, graphNow()); return; }
+      panel.replaceChildren(bar, el('p', { class: 'in-note' }, COPY.sheet.graphReading));
+      getLibrary(ws).then((l) => {
+        if (tab !== 'files' || fview !== 'graph') return;
+        if (!l) { panel.replaceChildren(bar, el('p', { class: 'in-note' }, COPY.sheet.graphError), listView()); return; }
+        lib = l; drawPanel();
+      });
       return;
     }
     const hist = data.history || [];

package/workspace/public/pm/initiatives-copy.js

@@ -134,6 +134,14 @@ export const COPY = {
     openGate: 'Open gate',
     handToAgent: 'Hand to agent',
     noFiles: 'No files yet.',
+    filesAs: 'Show files as',
+    filesList: 'List',
+    filesGraph: 'Graph',
+    listHint: 'Every file this initiative owns.',
+    graphHint: 'This initiative’s files, and the files outside it that they link to.',
+    graphReading: 'Reading the links…',
+    graphError: 'The links could not be read. The list is below.',
+    graphPhone: 'On a small screen the files show as a list.',
     fileSource: { record: 'Named by the record', 'knowledge-graph': 'Linked documents', git: 'Changed for it in git' },
     commits: (n) => (n === 1 ? '1 commit' : `${n} commits`),
     shared: 'shared',

package/workspace/public/pm/today-agenda.js

@@ -10,13 +10,14 @@
  * One read feeds it: GET /api/proactive/agenda?month=YYYY-MM. The server derives every answer (how full, the key
  * meeting, readiness, no notes); this file only draws them. A day cell is a button: it picks that day. A week number
  * picks the week. The lens switch says which answer the cells show; the agenda under the month always shows them all.
- * Nothing here writes: the calendar memory changes only through the morning-brief session's brief.
+ * The calendar memory changes only through the morning-brief session's brief. The one write here is the PM's key-meeting
+ * mark (POST /api/proactive/agenda/mark): this time or every time, key or not key, over what the calendar says.
  */
 
 import { peopleLinks } from './people-link.js';
 import { el } from './dom.js';
-import { button, iconButton, badge, tabs } from './primitives.js';
-import { pmGet } from './http.js';
+import { button, iconButton, badge, tabs, toast } from './primitives.js';
+import { pmGet, pmPost } from './http.js';
 import { COPY } from './today-copy.js';
 
 const A = COPY.day.ag;
@@ -74,10 +75,12 @@ function current() {
   return c;
 }
 
+// a short hash of the days, so a change that keeps the length (a key mark set or cleared) still redraws
+const hash = (t) => { let h = 0; for (let i = 0; i < t.length; i++) h = (h * 31 + t.charCodeAt(i)) | 0; return h; };
 export function agendaSig() {
   const c = ag.month ? cache.get(ag.month) : cache.get('now');
   return JSON.stringify([ag, c ? [c.error, c.data && c.data.now ? String(c.data.now).slice(0, 16) : null, c.data && Object.keys(c.data.days || {}).length, c.data && c.data.memory] : null])
-    + (c && c.data ? JSON.stringify(c.data.days).length : 0);
+    + (c && c.data ? hash(JSON.stringify(c.data.days)) : 0);
 }
 
 /* ── finding a meeting across the months read ─────────────────────────────────────────────────────────────────── */
@@ -270,6 +273,26 @@ function whyLines(e) {
   return out;
 }
 
+async function setMark(e, scope, on) {
+  const r = await pmPost('/api/proactive/agenda/mark', { title: e.title, start: e.start, scope, on });
+  if (!r || r.ok === false) { toast({ text: A.key.failed((r && r.error) || 'the workspace did not answer'), tone: 'destructive' }); return; }
+  for (const k of [...cache.keys()]) loadMonth(k === 'now' ? undefined : k);
+}
+
+/** The key-meeting line of a meeting: what the PM marked, and the presses that change it. */
+function keyBlock(e) {
+  const K = A.key;
+  const b = (label, scope, on, id) => button({ label, variant: 'outline', size: 'sm', attrs: { 'data-ag-mark': id }, onClick: () => setMark(e, scope, on) });
+  const presses = e.mark ? [b(K.clear, e.mark, null, 'clear')]
+    : e.imp ? [b(K.unmark, 'one', false, 'not-one'), e.repeats ? b(K.unmarkAll, 'series', false, 'not-series') : null]
+      : [b(K.mark, 'one', true, 'one'), e.repeats ? b(K.markAll, 'series', true, 'series') : null];
+  const said = e.mark ? K[(e.imp ? 'marked' : 'not') + e.mark] : null;
+  return el('div', { class: 'td-day__phase', 'data-ag': 'key', 'data-ag-key': e.imp ? 'true' : 'false' },
+    e.imp ? el('h4', null, A.star + ' ' + K.title) : null,
+    said ? el('p', { class: 'td-day__note' }, said) : null,
+    el('div', { class: 'td-day__acts' }, ...presses));
+}
+
 /** The series of a meeting: how often it met, what is to come, and the last time, folded. Null when unknown. */
 export function memoryBlock(id) {
   const f = findEvent(id);
@@ -280,7 +303,8 @@ export function memoryBlock(id) {
   return el('div', { class: 'td-day__notes', 'data-ag': 'memory' },
     el('h4', null, A.means),
     el('p', null, A.kindWord[f.e.kind] + '. ' + (s.count > 1 ? A.series(s.past, s.coming) : A.once)),
-    ...whyLines(f.e).map((t) => el('p', null, t)),
+    ...(f.e.mark ? [] : whyLines(f.e)).map((t) => el('p', null, t)),
+    keyBlock(f.e),
     last ? el('details', { class: 'td-ag__last', 'data-ag': 'last' }, el('summary', null, A.lastTime(dayLabel(last.date))),
       last.notes ? el('p', null, last.notes) : el('p', { class: 'td-day__note' }, A.noLast),
       last.open && last.open.length ? el('ul', { class: 'td-day__chk' }, ...last.open.map((x) => el('li', null, x))) : null) : null);

package/workspace/public/pm/today-copy.js

@@ -136,16 +136,17 @@ export const COPY = {
     unreached: 'The workspace did not answer.',
     refused: (why) => `Nothing changed. ${why}`,
     oldServer: 'This workspace server has no day run yet. Only your goals show.',
-    panels: { summary: 'Agent results', calendar: 'Calendar', agenda: 'Agenda', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', waiting: 'Also waiting for you', detail: 'Detail' },
+    panels: { summary: 'Agent results', calendar: 'Calendar', agenda: 'Agenda', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', detail: 'Detail' },
     summary: (c) => [c.review ? `${c.review} ${c.review === 1 ? 'draft waits' : 'drafts wait'} for you` : null, c.done ? `${c.done} done` : null,
       c.working ? `${c.working} working` : null, c.failed ? `${c.failed} failed` : null].filter(Boolean).join(' · ') || 'No agent job yet.',
     summaryAll: (n) => `All ${n} agent ${n === 1 ? 'job has' : 'jobs have'} a result.`,
-    waitingHint: 'Outcome checks, reports and sessions from your repositories, outside today\'s jobs.',
     // one day for every repository: a goal or a place can carry a repository; the Show switch narrows the day to it
     repo: { label: 'Repository', none: 'No repository',
       goalHint: 'Its jobs show under this repository. With no repository, the goal is yours and shows under every repository.',
       placeHint: 'Repository: its mentions and jobs show under that repository. With none, they show under every repository.',
-      only: (name) => `Showing ${name} and your items with no repository. The calendar always shows.` },
+      only: (name) => `Showing ${name} and your items with no repository. The calendar always shows.`,
+      hiddenGoals: (n) => `${n} ${n === 1 ? 'goal belongs' : 'goals belong'} to another repository.`,
+      showAll: 'Show all repositories' },
     now: (at) => `now ${at}`,
     noCalendar: 'No events read for today.',
     noJobs: 'No jobs yet. Press Prepare my day. Each job shows here; select one to see what it needs.',
@@ -329,6 +330,13 @@ export const COPY = {
       kindWord: { one: 'One-to-one', onboard: 'Onboarding', group: 'Group meeting' },
       why: { present: 'You present.', decide: 'You decide.', external: 'People from outside the company join.', exec: 'Leadership joins.', many: (n) => `${n} people join.`, routine: 'It repeats, and nothing in it is for you.' },
       means: 'What it means',
+      key: {
+        title: 'Key meeting',
+        markedone: 'You marked this time as key.', markedseries: 'You marked it as key every time.',
+        notone: 'You marked this time as not key.', notseries: 'You marked it as not key every time.',
+        mark: 'Mark as key', markAll: 'Key every time', unmark: 'Not key', unmarkAll: 'Never key', clear: 'Remove my mark',
+        failed: (why) => `The mark was not saved: ${why}`,
+      },
       before: 'Before this meeting',
       prepLine: (done, need) => `${done} of ${need} prep steps done.`,
       readyNote: { ok: 'Your prep is done.', warn: 'Some prep is left, and there is time for it.', risk: 'The free time before it is short for the prep left.' },

package/workspace/public/pm/today-day.js

@@ -142,7 +142,9 @@ function model(d, view) {
   const today = d && d.today;
   const brief = d && d.brief && (!today || d.brief.date === today) ? d.brief : null;
   const plan = (d && d.plan) || null;
-  const goals = plan ? plan.goals || [] : [];
+  // a goal with no repository of its own takes the one its initiative is in (goal_repos, from the server)
+  const goalRepos = (d && d.goal_repos) || {};
+  const goals = (plan ? plan.goals || [] : []).map((g) => (g.repo || !goalRepos[g.id] ? g : { ...g, repo: goalRepos[g.id] }));
   const goalNo = new Map(goals.map((g, i) => [g.id, i + 1]));
   const run = (d && d.run) || null;
   const tasks = run && Array.isArray(run.tasks) ? run.tasks : [];
@@ -178,7 +180,7 @@ function model(d, view) {
   const shownIds = new Set(shownJobs.map((j) => j.task && j.task.id).filter(Boolean));
   const shownTasks = narrow ? tasks.filter((t) => shownIds.has(t.id)) : tasks;
   return {
-    d, brief, plan, goals: goals.filter((g) => inView(g.repo)), allGoals: goals, goalNo, run, tasks: shownTasks, jobs: shownJobs, events, now, settings, scopes, level,
+    d, brief, plan, goals: goals.filter((g) => inView(g.repo)), allGoals: goals, hiddenGoals: goals.filter((g) => !inView(g.repo)).length, goalNo, run, tasks: shownTasks, jobs: shownJobs, events, now, settings, scopes, level,
     digests: digests.filter((g) => inView(g.repo)), places, placeRepo, repos, repoName, here: v.here || null, narrow,
     stage: run ? (d.stage || deriveStage(run, brief)) : null,
     mentions: shownJobs.filter((j) => j.item && j.item.mention),
@@ -419,13 +421,31 @@ function jobRow(ctx, j) {
     dot: j.isNew && !seen.has(j.id) ? el('span', { class: 'td-day__newdot', 'data-day': 'new', role: 'img', 'aria-label': D.newItem }) : null });
 }
 
+/* What the repositories owe the PM outside today's jobs (outcome checks, report drafts, sessions) are jobs too: each one is a
+ * row of Needs you, and pressing it shows its card, with the card's own buttons, in the detail column. The Agenda has no
+ * separate section for them. */
+function owedItems(owed) {
+  if (!owed || !owed.list) return [];
+  return [...owed.list.children].filter((n) => n.getAttribute && n.getAttribute('data-today-id')).map((n) => {
+    const cause = n.querySelector('[data-today-cause]');
+    const ev = n.querySelector('.td-card__evidence');
+    const text = ((cause || n).textContent || '').trim().replace(/\s+/g, ' ');
+    return { id: n.getAttribute('data-today-id'), node: n, title: text, meta: ev ? ev.textContent.trim().replace(/\s+/g, ' ') : '' };
+  });
+}
+
+function owedRow(ctx, o) {
+  return rowBtn(ctx, 'owed', o.id, { lead: '·', title: o.title, meta: o.meta, trail: pill(D.status2.you, 'warn') });
+}
+
 function jobsPanel(ctx) {
   const { m } = ctx;
-  if (!m.jobs.length) return panel('jobs', null, note(m.run && m.stage === 'reading' ? D.readingJobs : D.noJobs, { 'data-day': 'no-jobs' }));
-  const groups = ['needs', 'working', 'done', 'worth'].map((g) => [g, m.jobs.filter((j) => j.group === g)]).filter(([, l]) => l.length);
-  return panel('jobs', D.jobsCount(m.needs, m.done), ...groups.map(([g, l]) => el('div', { class: 'td-day__group', 'data-day-group': g },
-    el('div', { class: 'td-day__gh' }, D.groups[g], pill(String(l.length), '')),
-    el('ul', { class: 'td-day__rows' }, ...l.map((j) => jobRow(ctx, j))))));
+  const owed = ctx.owed;
+  if (!m.jobs.length && !owed.length) return panel('jobs', null, note(m.run && m.stage === 'reading' ? D.readingJobs : D.noJobs, { 'data-day': 'no-jobs' }));
+  const groups = ['needs', 'working', 'done', 'worth'].map((g) => [g, m.jobs.filter((j) => j.group === g)]).filter(([g, l]) => l.length || (g === 'needs' && owed.length));
+  return panel('jobs', D.jobsCount(m.needs + owed.length, m.done), ...groups.map(([g, l]) => el('div', { class: 'td-day__group', 'data-day-group': g },
+    el('div', { class: 'td-day__gh' }, D.groups[g], pill(String(l.length + (g === 'needs' ? owed.length : 0)), '')),
+    el('ul', { class: 'td-day__rows', 'data-day-list': 'jobs-' + g }, ...l.map((j) => jobRow(ctx, j)), ...(g === 'needs' ? owed.map((o) => owedRow(ctx, o)) : [])))));
 }
 
 /* The coordinator's view of the run: what every agent job came back with, in one place. The server runs the jobs as one
@@ -455,14 +475,12 @@ function summaryPanel(ctx) {
 
 /* What waits for the PM outside today's jobs (the Today cards: outcome checks, reports, sessions). Today hands its list
  * in, so the cards keep their own controls and the open day shows one layout. */
-function waitingPanel(owed) {
-  if (!owed || !owed.list) return null;
-  return panel('waiting', owed.count ? String(owed.count) : null, note(D.waitingHint), owed.list, owed.more || null);
-}
-
 function goalsPanel(ctx) {
   const { m } = ctx;
-  return panel('goals', D.goalsCount(m.allGoals.filter((g) => g.status === 'open').length, m.maxGoals), goalRows(ctx), goalAdd(ctx));
+  // a goal of another repository is not lost: the panel says how many the Show switch hides, with the way to them
+  const hidden = m.hiddenGoals ? el('p', { class: 'td-day__note', 'data-day': 'goals-hidden' }, D.repo.hiddenGoals(m.hiddenGoals) + ' ',
+    button({ label: D.repo.showAll, variant: 'ghost', size: 'sm', attrs: { 'data-day': 'show-all' }, onClick: () => ctx.showAll() })) : null;
+  return panel('goals', D.goalsCount(m.allGoals.filter((g) => g.status === 'open').length, m.maxGoals), goalRows(ctx), hidden, goalAdd(ctx));
 }
 
 function mentionStatus(j) {
@@ -778,9 +796,10 @@ function sourcesDetail(ctx) {
   return [dhead(D.kind.settings, D.sources), note(D.sourcesIntro), box, el('div', { class: 'td-day__slist' }, ...rows)];
 }
 
-function defaultSel(m) {
+function defaultSel(m, owed) {
   const j = m.jobs.find((x) => x.group === 'needs');
   if (j) return { type: 'job', id: j.id };
+  if (owed && owed.length) return { type: 'owed', id: owed[0].id };
   const e = m.events.find((x) => !x.ended);
   if (e) return { type: 'event', id: e.id };
   return { type: 'step', id: String(Math.max(0, Math.min(3, stepIndex(m.stage)))) };
@@ -799,10 +818,11 @@ function detail(ctx) {
     if (s.type === 'step') return stepDetail(ctx, Math.max(0, Math.min(3, Number(s.id) || 0)));
     if (s.type === 'sources') return sourcesDetail(ctx);
     if (s.type === 'meeting') return meetingDetail(ctx, s.id, { dhead });
+    if (s.type === 'owed') { const o = ctx.owed.find((x) => x.id === s.id); if (o) o.node.hidden = false; return o ? [dhead(D.groups.needs), el('div', { class: 'td-day__owed', 'data-day': 'owed' }, o.node)] : null; }
     return null;
   };
   kids = find(sel);
-  if (!kids) { sel = defaultSel(m); kids = find(sel); }
+  if (!kids) { sel = defaultSel(m, ctx.owed); kids = find(sel); }
   return el('aside', { class: 'td-day__detail', 'aria-label': D.panels.detail, 'data-day': 'detail', 'data-day-detail': sel.type, 'data-day-detail-id': sel.id }, kids);
 }
 
@@ -847,9 +867,13 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
   const sel = ui.sel;
   const ctx = {
     ws, m, sel, openIni, reload: () => load(ws), rerender: () => rerender(), select, repoPicker,
-    cur: (type, id) => { const s = sel || defaultSel(m); return s.type === type && s.id === String(id) ? 'true' : 'false'; },
+    showAll: () => { if (setState) setState({ todayScope: 'all' }); },
+    cur: (type, id) => { const s = sel || defaultSel(m, ctx.owed); return s.type === type && s.id === String(id) ? 'true' : 'false'; },
+    owed: owedItems(owed),
   };
-  ctx.sel = sel || defaultSel(m);
+  ctx.sel = sel || defaultSel(m, ctx.owed);
+  // the open day takes what the repositories owe into its jobs: dest-today draws no second list under it
+  if (owed) owed.taken = true;
   if (ui.scroll) {
     ui.scroll = false;
     // on a narrow screen the detail is under the list: bring it into view once it is on the page
@@ -866,7 +890,7 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
     c.error ? el('p', { class: 'td-day__run td-day__run--failed', role: 'status', 'data-day': 'error' }, D.refused(c.error)) : null,
     m.d && m.d.legacy ? note(D.oldServer) : null,
     el('div', { class: 'td-day__cols' },
-      el('div', { class: 'td-day__left' }, agenda(ctx), summaryPanel(ctx), goalsPanel(ctx), jobsPanel(ctx), mentionsPanel(ctx), waitingPanel(owed)),
+      el('div', { class: 'td-day__left' }, agenda(ctx), summaryPanel(ctx), goalsPanel(ctx), jobsPanel(ctx), mentionsPanel(ctx)),
       detail(ctx)));
 }