create-pmos 0.61.1 → 0.63.0

package/workspace/public/pm/dest-people.js

@@ -0,0 +1,385 @@
+/* pm/dest-people.js — the People destination: the people the PM works with in a repository, with their interactions,
+ * tone, notes and shared work (initiative people-directory, PRD R5 to R11, proposed D90).
+ *
+ * A DESTINATION MODULE (registry.js): mountDestination(host, ctx) on every render with the same host, disposeDestination(host).
+ * It keeps ONE persistent root per host; the header (title and search) is built once, so typing never loses focus, and
+ * only the body is rebuilt when its own data changed.
+ *
+ * What it shows, for the repository the tab names (or the open one):
+ *   - Waiting for you: new people agent sessions saw (Add to People · Ignore), possible duplicates (Merge · Keep
+ *     separate), and how many tones wait for a confirm;
+ *   - the list: search over names, handles and initiatives, All · Team · External, sort by latest, most or name;
+ *   - the person's page: who, interactions with where each came from, tone (Confirm · Set another · Change), shared
+ *     work (initiatives, items they own with Blocked shown, coming meetings), notes (Add · Remove), and identity and
+ *     sources (handles, how many interactions each source gave, the file the person lives in).
+ * Every press is a page press to POST /api/people/decide. Nothing here reads a source: agent sessions record what they
+ * saw through `pmos people record`. A link from another place opens a person through the tab's slug (people-link.js).
+ * In fixture mode it reads nothing.
+ */
+
+import { el } from './dom.js';
+import { button, row, field, toast, empty, tabs, badge, menu, ensureComponentsCss } from './primitives.js';
+import { ensureSprite } from './icons.js';
+import { pmGet, pmPost } from './http.js';
+import { wsOf } from './data.js';
+import { registerCommand, openDestination } from './registry.js';
+import { forgetPeople } from './people-link.js';
+
+const TONES = ['warm', 'neutral', 'cautious', 'tense'];
+const SOURCE = { gather: 'Gathered notes', calendar: 'Calendar', live: 'Live notes', jira: 'Jira' };
+const HANDLE = { mail: 'Mail', slack: 'Chat', jira: 'Jira', confluence: 'Confluence', speaker: 'Speaker', name: 'Name' };
+
+export const COPY = Object.freeze({
+  title: 'People',
+  fixture: 'People shows the people of a repository in a real session.',
+  noRepo: 'Open a repository to see its people.',
+  loading: 'Reading…',
+  readError: 'People could not be read.',
+  find: 'Find a person',
+  waiting: 'Waiting for you',
+  newPerson: (n, src) => `${n} sighting${n === 1 ? '' : 's'} · ${src}`,
+  add: 'Add to People',
+  ignore: 'Ignore',
+  same: (a, b) => `${a} may be the same person as ${b}`,
+  merge: 'Merge',
+  keep: 'Keep separate',
+  tonesWait: (n) => `${n} tone${n === 1 ? '' : 's'} to confirm. Open the person to confirm it.`,
+  all: 'All', team: 'Team', external: 'External',
+  latest: 'Latest', most: 'Most', name: 'Name',
+  none: 'Nobody yet. Agent sessions that gather requirements, take live notes or sync Jira record the people they see. They wait here for you to add them.',
+  noMatch: (q) => `Nobody matches “${q}”.`,
+  pick: 'Choose a person to see their page.',
+  interactions: 'Interactions',
+  noInteractions: 'No interaction recorded yet.',
+  tone: 'Tone',
+  noTone: 'No interaction has a tone yet.',
+  proposed: (t) => `Proposed: ${t}, from the latest interactions`,
+  confirmed: (t) => `Confirmed: ${t}`,
+  confirm: 'Confirm',
+  setAnother: 'Set another',
+  change: 'Change',
+  shared: 'Shared work',
+  noShared: 'No shared initiative, item or meeting yet.',
+  owns: 'Owns',
+  blocked: 'Blocked',
+  meeting: 'Meeting',
+  notes: 'Notes',
+  noNotes: 'No note yet. Only you can add one.',
+  addNote: 'Add note',
+  notePlaceholder: 'Something to remember about working with this person',
+  remove: 'Remove',
+  identity: 'Identity and sources',
+  lives: (f) => `Lives in ${f}`,
+  added: (n) => `${n} added to People.`,
+  ignored: (n) => `${n} is ignored. Later sightings stay hidden.`,
+  merged: 'Merged.',
+  kept: 'Kept separate.',
+  noteAdded: 'Note added.',
+  noteRemoved: 'Note removed.',
+  toneSaved: 'Tone saved.',
+});
+
+registerCommand({ id: 'people-open', label: 'People', hint: 'The people you work with in this repository', cli: 'pmos people list', run: () => openDestination('people') });
+
+/* ── words ───────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** "Oct 1" for a YYYY-MM-DD date; "today" and "yesterday" for the two nearest. */
+function day(d) {
+  if (!d) return '';
+  const t = new Date(d + 'T12:00:00');
+  if (Number.isNaN(t.getTime())) return d;
+  const today = new Date(); today.setHours(12, 0, 0, 0);
+  const n = Math.round((today - t) / 86400000);
+  if (n === 0) return 'today';
+  if (n === 1) return 'yesterday';
+  return t.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+const toneOf = (p) => p.tone.confirmed || p.tone.proposed || null;
+const handleText = (h) => `${HANDLE[h.kind] || h.kind}: ${h.value}`;
+const who = (p) => [p.role, p.org].filter(Boolean).join(' · ') || p.group;
+
+/* ── mount ───────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const insts = new WeakMap();
+const REREAD_MS = 5000;
+
+export function mountDestination(host, ctx) {
+  let inst = insts.get(host);
+  if (!inst) {
+    inst = { host, root: el('div', { class: 'rp-page rp-people', 'data-people': '' }), head: null, body: el('div', { class: 'rp-people-body' }),
+      ws: null, loaded: false, error: null, view: null, q: '', group: 'all', sort: 'latest', open: null, slug: null, busy: false,
+      seq: 0, last: '', readAt: 0 };
+    insts.set(host, inst);
+    // A redraw held back while a note was typed runs when the field is left.
+    const held = inst;
+    held.body.addEventListener('focusout', () => setTimeout(() => { if (!held.last && held.loaded) draw(held); }, 0));
+  }
+  ensureComponentsCss();
+  if (!inst.root.isConnected || inst.root.parentNode !== host) host.replaceChildren(inst.root);
+  if (ctx && ctx.FIXTURE) { inst.root.replaceChildren(empty({ text: COPY.fixture })); return; }
+  const repo = (ctx && ctx.tab && ctx.tab.repo) || (ctx && ctx.state && ctx.state.product) || null;
+  const ws = repo ? wsOf(repo) : null;
+  // A link from the Agenda, an initiative or an item names the person in the tab's slug.
+  const slug = (ctx && ctx.tab && ctx.tab.slug) || null;
+  if (slug !== inst.slug) { inst.slug = slug; if (slug) { inst.open = slug; inst.q = ''; if (inst.head) inst.head.find.control.resetCommitted(''); } }
+  if (ws !== inst.ws) {
+    Object.assign(inst, { ws, loaded: false, error: null, view: null, last: '' });
+    if (!slug) inst.open = null;
+    if (ws) { ensureSprite(); refresh(inst); }
+    draw(inst);
+    return;
+  }
+  if (Date.now() - inst.readAt > REREAD_MS) refresh(inst);
+  draw(inst);
+}
+
+export function disposeDestination(host) {
+  const inst = insts.get(host);
+  if (!inst) return;
+  inst.seq++;
+  inst.root.remove();
+  insts.delete(host);
+}
+
+async function refresh(inst) {
+  const ws = inst.ws;
+  if (!ws) return;
+  const seq = ++inst.seq;
+  inst.readAt = Date.now();
+  const v = await pmGet('/api/people?ws=' + encodeURIComponent(ws));
+  if (seq !== inst.seq || ws !== inst.ws) return;
+  inst.loaded = true;
+  if (!v || v.ok === false) { inst.error = (v && v.error) || COPY.readError; inst.view = null; }
+  else { inst.error = null; inst.view = v; }
+  draw(inst);
+}
+
+/* ── presses ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+async function decide(inst, body, done) {
+  if (inst.busy) return null;
+  inst.busy = true;
+  const r = await pmPost('/api/people/decide', { ws: inst.ws, ...body });
+  inst.busy = false;
+  forgetPeople(inst.ws);
+  if (!r || !r.ok) { toast({ text: (r && r.error) || 'Nothing was saved.', tone: 'error' }); await refresh(inst); return null; }
+  if (done) toast({ text: done, timeout: 3000 });
+  await refresh(inst);
+  return r;
+}
+
+/* ── the review list ─────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function review(inst) {
+  const r = inst.view.review;
+  if (!r.count) return null;
+  const rows = [];
+  for (const f of r.new) {
+    const key = f.handle.kind + ':' + f.handle.value;
+    rows.push(el('div', { class: 'rp-people-row', role: 'listitem', 'data-people-new': key },
+      row({
+        title: f.name,
+        meta: [[f.role, f.org].filter(Boolean).join(' · ') || handleText(f.handle), COPY.newPerson(f.count, f.sources.map((s) => SOURCE[s] || s).join(', '))],
+        trail: [
+          button({ label: COPY.add, variant: 'primary', size: 'sm', attrs: { 'data-people-act': 'add', 'data-people-key': key },
+            onClick: async () => { const x = await decide(inst, { act: 'add', handle: f.handle, name: f.name }, COPY.added(f.name)); if (x && x.person) { inst.open = x.person; draw(inst); } } }),
+          button({ label: COPY.ignore, variant: 'ghost', size: 'sm', attrs: { 'data-people-act': 'ignore', 'data-people-key': key },
+            onClick: () => decide(inst, { act: 'ignore', handle: f.handle }, COPY.ignored(f.name)) }),
+        ],
+        attrs: { title: handleText(f.handle) },
+      })));
+  }
+  for (const m of r.merges) {
+    const key = m.handle.kind + ':' + m.handle.value;
+    rows.push(el('div', { class: 'rp-people-row', role: 'listitem', 'data-people-merge': key },
+      row({
+        title: COPY.same(m.handle.value, m.personName),
+        meta: [m.why],
+        trail: [
+          button({ label: COPY.merge, variant: 'outline', size: 'sm', attrs: { 'data-people-act': 'merge', 'data-people-key': key },
+            onClick: () => decide(inst, { act: 'merge', person: m.person, handle: m.handle }, COPY.merged) }),
+          button({ label: COPY.keep, variant: 'ghost', size: 'sm', attrs: { 'data-people-act': 'keep-separate', 'data-people-key': key },
+            onClick: () => decide(inst, { act: 'keep-separate', a: m.a, b: m.b }, COPY.kept) }),
+        ],
+      })));
+  }
+  if (r.tones.length) rows.push(el('p', { class: 'rp-people-hint', 'data-people-tones': String(r.tones.length) }, COPY.tonesWait(r.tones.length)));
+  return el('section', { class: 'rp-people-review', 'data-people-review': '' },
+    el('h3', { class: 'rp-people-sec__title' }, `${COPY.waiting} · ${r.count}`),
+    el('div', { role: 'list' }, rows));
+}
+
+/* ── the list ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function matches(p, q) {
+  if (!q) return true;
+  const hay = [p.name, p.role, p.org, ...p.handles.map((h) => h.value), ...p.shared.initiatives.map((g) => g.id)].join(' ').toLowerCase();
+  return hay.includes(q);
+}
+function shownPeople(inst) {
+  const q = inst.q.trim().toLowerCase();
+  let list = inst.view.people.filter((p) => matches(p, q));
+  if (inst.group === 'team') list = list.filter((p) => !p.external);
+  if (inst.group === 'external') list = list.filter((p) => p.external);
+  if (inst.sort === 'most') list = list.slice().sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  if (inst.sort === 'name') list = list.slice().sort((a, b) => a.name.localeCompare(b.name));
+  return list;
+}
+
+function personLine(inst, p) {
+  const open = inst.open === p.id;
+  const t = toneOf(p);
+  return el('div', { class: 'rp-people-row' + (open ? ' rp-people-row--open' : ''), role: 'listitem', 'data-people-person': p.id },
+    row({
+      title: p.name,
+      meta: [who(p), p.last ? `${p.count} · ${day(p.last)}` : String(p.count)],
+      trail: t ? [badge({ text: p.tone.confirmed ? t : t + '?', tone: t === 'tense' ? 'destructive' : t === 'cautious' ? 'warning' : 'outline', attrs: { 'data-people-tone': t } })] : [],
+      onOpen: () => { inst.open = p.id; draw(inst); },
+      openLabel: `${p.name}, ${who(p)}`,
+      openAttrs: { 'aria-current': open ? 'true' : null, 'data-people-open': p.id },
+    }));
+}
+
+function listPane(inst) {
+  const v = inst.view;
+  const all = v.people.filter((p) => matches(p, inst.q.trim().toLowerCase()));
+  const controls = el('div', { class: 'rp-people-views' },
+    tabs({ variant: 'line', value: inst.group, ariaLabel: 'Group', attrs: { 'data-people-group': '' },
+      items: [{ id: 'all', label: COPY.all, count: all.length }, { id: 'team', label: COPY.team, count: all.filter((p) => !p.external).length },
+        { id: 'external', label: COPY.external, count: all.filter((p) => p.external).length }],
+      onChange: (val) => { inst.group = val; draw(inst); } }),
+    tabs({ variant: 'segmented', value: inst.sort, ariaLabel: 'Sort', attrs: { 'data-people-sort': '' },
+      items: [{ id: 'latest', label: COPY.latest }, { id: 'most', label: COPY.most }, { id: 'name', label: COPY.name }],
+      onChange: (val) => { inst.sort = val; draw(inst); } }));
+  const list = shownPeople(inst);
+  let rows;
+  if (!v.people.length) rows = [el('p', { class: 'rp-section__empty' }, COPY.none)];
+  else if (!list.length) rows = [el('p', { class: 'rp-section__empty' }, COPY.noMatch(inst.q.trim()))];
+  else rows = [el('div', { role: 'list', 'data-people-list': '' }, list.map((p) => personLine(inst, p)))];
+  return el('div', { class: 'rp-people-list' }, controls, ...rows);
+}
+
+/* ── the person's page ───────────────────────────────────────────────────────────────────────────────────────────── */
+
+function section(title, kids, attrs) {
+  return el('section', { class: 'rp-people-sec', ...(attrs || {}) }, el('h4', { class: 'rp-people-sec__title' }, title), ...kids);
+}
+
+function interactionsSec(p) {
+  if (!p.interactions.length) return section(COPY.interactions, [el('p', { class: 'rp-people-hint' }, COPY.noInteractions)], { 'data-people-sec': 'interactions' });
+  return section(`${COPY.interactions} · ${p.count}`, [el('ol', { class: 'rp-people-ints' }, p.interactions.slice(0, 50).map((i) =>
+    el('li', { class: 'rp-people-int', 'data-people-int': i.date },
+      el('span', { class: 'rp-people-int__when' }, `${day(i.date)} · ${i.kind}`),
+      el('span', { class: 'rp-people-int__text' }, i.text),
+      el('span', { class: 'rp-people-int__src' }, [SOURCE[i.source] || i.source, i.pointer, i.tone].filter(Boolean).join(' · ')))))],
+  { 'data-people-sec': 'interactions' });
+}
+
+function toneSec(inst, p) {
+  const t = p.tone;
+  const mix = TONES.filter((x) => t.mix[x]).map((x) => `${t.mix[x]} ${x}`).join(' · ');
+  const kids = [];
+  if (!t.proposed && !t.confirmed) kids.push(el('p', { class: 'rp-people-hint' }, COPY.noTone));
+  if (t.confirmed) kids.push(el('p', { class: 'rp-people-tone', 'data-people-confirmed': t.confirmed }, COPY.confirmed(t.confirmed)));
+  else if (t.proposed) kids.push(el('p', { class: 'rp-people-tone', 'data-people-proposed': t.proposed }, COPY.proposed(t.proposed)));
+  if (mix) kids.push(el('p', { class: 'rp-people-hint', 'data-people-mix': '' }, mix));
+  const acts = [];
+  if (!t.confirmed && t.proposed) acts.push(button({ label: COPY.confirm, variant: 'primary', size: 'sm', attrs: { 'data-people-act': 'tone-confirm' },
+    onClick: () => decide(inst, { act: 'tone', person: p.id, tone: t.proposed }, COPY.toneSaved) }));
+  const another = button({ label: COPY.setAnother, variant: 'outline', size: 'sm', iconEnd: 'chevron-down', attrs: { 'data-people-act': 'tone-set', 'aria-haspopup': 'menu' },
+    onClick: () => menu({ anchor: another, ariaLabel: COPY.setAnother,
+      items: TONES.map((x) => ({ label: x, onSelect: () => decide(inst, { act: 'tone', person: p.id, tone: x }, COPY.toneSaved) })) }) });
+  acts.push(another);
+  if (t.confirmed) acts.push(button({ label: COPY.change, variant: 'ghost', size: 'sm', attrs: { 'data-people-act': 'tone-clear' },
+    onClick: () => decide(inst, { act: 'tone', person: p.id, tone: null }, COPY.toneSaved) }));
+  kids.push(el('div', { class: 'rp-people-acts' }, acts));
+  return section(COPY.tone, kids, { 'data-people-sec': 'tone' });
+}
+
+function sharedSec(p) {
+  const s = p.shared;
+  const lines = [];
+  for (const g of s.initiatives) lines.push(el('li', { class: 'rp-people-shared', 'data-people-shared': 'initiative' }, `${g.id} · ${g.count} interaction${g.count === 1 ? '' : 's'}`));
+  for (const it of s.items) {
+    lines.push(el('li', { class: 'rp-people-shared', 'data-people-shared': 'item', 'data-people-item': it.id },
+      `${COPY.owns} ${it.title || it.id}${it.initiative ? ' · ' + it.initiative : ''} · ${it.state}`,
+      it.blocked ? badge({ text: COPY.blocked, tone: 'warning', attrs: { title: it.reason || COPY.blocked } }) : null));
+  }
+  for (const m of s.meetings) {
+    const when = new Date(m.start);
+    lines.push(el('li', { class: 'rp-people-shared', 'data-people-shared': 'meeting' },
+      `${COPY.meeting} · ${when.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' })} ${when.toTimeString().slice(0, 5)} · ${m.title}`));
+  }
+  return section(COPY.shared, lines.length ? [el('ul', { class: 'rp-people-list-plain' }, lines)] : [el('p', { class: 'rp-people-hint' }, COPY.noShared)], { 'data-people-sec': 'shared' });
+}
+
+function notesSec(inst, p) {
+  const list = p.notes.map((n) => el('li', { class: 'rp-people-note', 'data-people-note': n.id },
+    el('span', { class: 'rp-people-note__text' }, n.text),
+    button({ label: COPY.remove, variant: 'ghost', size: 'sm', attrs: { 'data-people-act': 'note-remove', 'data-people-key': n.id },
+      onClick: () => decide(inst, { act: 'note-remove', person: p.id, id: n.id }, COPY.noteRemoved) })));
+  const f = field({ label: COPY.addNote, kind: 'textarea', hideLabel: true, placeholder: COPY.notePlaceholder, attrs: { 'data-people-field': 'note' } });
+  const save = async () => {
+    const text = f.control.value.trim();
+    if (!text) return;
+    f.control.blur();
+    const r = await decide(inst, { act: 'note', person: p.id, text }, COPY.noteAdded);
+    if (r) f.control.value = '';
+  };
+  return section(COPY.notes, [
+    list.length ? el('ul', { class: 'rp-people-list-plain' }, list) : el('p', { class: 'rp-people-hint' }, COPY.noNotes),
+    el('div', { class: 'rp-people-noteadd' }, f, el('div', { class: 'rp-people-acts' }, button({ label: COPY.addNote, variant: 'outline', size: 'sm', attrs: { 'data-people-act': 'note-add' }, onClick: save }))),
+  ], { 'data-people-sec': 'notes' });
+}
+
+function identitySec(inst, p) {
+  const by = {};
+  for (const i of p.interactions) by[i.source] = (by[i.source] || 0) + 1;
+  const file = inst.view.file ? String(inst.view.file).split('/').slice(-3).join('/') : 'people.jsonl';
+  return section(COPY.identity, [
+    el('ul', { class: 'rp-people-list-plain' },
+      p.handles.map((h) => el('li', { class: 'rp-people-handle', 'data-people-handle': h.kind + ':' + h.value }, handleText(h))),
+      Object.entries(by).map(([s, n]) => el('li', { class: 'rp-people-hint' }, `${SOURCE[s] || s}: ${n} interaction${n === 1 ? '' : 's'}`))),
+    el('p', { class: 'rp-people-hint rp-people-file' }, COPY.lives(file)),
+  ], { 'data-people-sec': 'identity' });
+}
+
+function personPane(inst) {
+  const p = inst.view.people.find((x) => x.id === inst.open);
+  if (!p) return el('div', { class: 'rp-people-page' }, el('p', { class: 'rp-section__empty' }, COPY.pick));
+  return el('article', { class: 'rp-people-page', 'data-people-page': p.id },
+    el('header', { class: 'rp-people-who' },
+      el('h3', { class: 'rp-people-who__name' }, p.name),
+      el('p', { class: 'rp-people-hint' }, [who(p), p.external && (p.role || p.org) ? COPY.external : null].filter(Boolean).join(' · '))),
+    interactionsSec(p), toneSec(inst, p), sharedSec(p), notesSec(inst, p), identitySec(inst, p));
+}
+
+/* ── the page ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function header(inst) {
+  if (inst.head) return inst.head;
+  const find = field({ label: COPY.find, hideLabel: true, placeholder: COPY.find, attrs: { 'data-people-find': '' } });
+  const q = find.control;
+  q.addEventListener('input', () => { inst.q = q.value; draw(inst); });
+  q.addEventListener('keydown', (e) => { if (e.key === 'Escape') { q.resetCommitted(''); inst.q = ''; draw(inst); } });
+  inst.head = el('div', { class: 'rp-people-top' }, el('h2', { class: 'rp-head__title' }, COPY.title), el('div', { class: 'rp-people-find' }, find));
+  inst.head.find = find;
+  return inst.head;
+}
+
+function draw(inst) {
+  const root = inst.root;
+  if (!inst.ws) { root.replaceChildren(empty({ text: COPY.noRepo })); inst.last = 'none'; return; }
+  const fp = JSON.stringify([inst.loaded, inst.error, inst.view, inst.q, inst.group, inst.sort, inst.open]);
+  if (fp === inst.last && root.childNodes.length && root.contains(inst.body)) return;
+  inst.last = fp;
+  const head = header(inst);
+  if (head.parentNode !== root || inst.body.parentNode !== root) root.replaceChildren(head, inst.body);
+  if (!inst.loaded) { inst.body.replaceChildren(el('p', { class: 'rp-section__empty' }, COPY.loading)); return; }
+  if (inst.error) { inst.body.replaceChildren(el('p', { class: 'rp-section__empty rp-section__empty--bad', role: 'alert' }, inst.error)); return; }
+  if (!inst.open && inst.view.people.length) inst.open = inst.view.people[0].id;
+  // Focus stays in a note being typed: a redraw of the page would drop it, so it waits until the field is left.
+  const typing = document.activeElement && inst.body.contains(document.activeElement) && document.activeElement.matches('textarea');
+  if (typing) { inst.last = ''; return; }
+  inst.body.replaceChildren(...[review(inst), el('div', { class: 'rp-people-grid' }, listPane(inst), personPane(inst))].filter(Boolean));
+}

package/workspace/public/pm/dest-settings.js

@@ -1,11 +1,13 @@
 /* pm/dest-settings.js — the Settings destination, the frame's ⚙ (pm-os-absorb Run 3, slice 3A; PRD R9).
  *
- * Settings holds settings only, in seven sections and in this order:
+ * Settings holds settings only, in eight sections and in this order:
  *   Repositories       every registered repository as a row (open it to make it current; ⋯ for more), and Add repository,
  *                      which draws the existing add-repository flow (view-addrepo.js) in place
  *   Profiles           one row that opens the Claude profiles in the detail
  *   New sessions       the default CLI and the default model the dock's ＋ Session applies (dock.js)
  *   Validate consent   the current repository's consent switch (GET and POST /api/validate/repo)
+ *   People             the current repository's switch for calendar attendee names (GET /api/people, POST /api/people/decide;
+ *                      people-directory, D90)
  *   Online             the Online switch and its five settings (GET and POST /api/online; workspace-online-mode, D89)
  *   Theme              Dark or Light
  *   Updates            the workspace app's version and the current repository's kit version; Check for updates asks the
@@ -35,6 +37,7 @@ const roots = new WeakMap();      // host -> { root, sig }
 const consentByWs = new Map();    // ws -> { on: boolean | null, error, at, pending }
 const kitByWs = new Map();        // ws -> { st: GET /api/kit/status body | null, at, pending }
 const upd = { phase: null, latest: null, compare: null, message: '', error: '', output: '' };   // the Updates section
+const peopleByWs = new Map();   // ws -> { on: boolean | null, error, at, pending }
 const online = { data: null, error: null, note: null, at: 0, pending: false };   // GET /api/online, and the last refusal
 let addOpen = false;
 let addMod = null;
@@ -62,6 +65,27 @@ async function setConsent(ws, on) {
   setState({});
 }
 
+function readPeople(ws) {
+  if (!ws || FIXTURE) return;
+  const have = peopleByWs.get(ws);
+  if (have && (have.pending || Date.now() - have.at < 30000)) return;
+  const entry = { on: have ? have.on : null, error: null, at: Date.now(), pending: true };
+  peopleByWs.set(ws, entry);
+  pmGet('/api/people?ws=' + encodeURIComponent(ws)).then((j) => {
+    entry.pending = false; entry.at = Date.now();
+    if (j && j.ok !== false && j.settings) { entry.on = !!j.settings.calendar_names; entry.error = null; } else entry.error = (j && j.error) || P.peopleUnread;
+    setState({});
+  });
+}
+
+async function setPeopleCalendar(ws, on) {
+  const j = await pmPost('/api/people/decide', { ws, act: 'setting', calendar_names: on });
+  peopleByWs.delete(ws);
+  if (!j || j.ok === false) peopleByWs.set(ws, { on: null, error: (j && j.error) || P.peopleUnread, at: Date.now() });
+  else readPeople(ws);
+  setState({});
+}
+
 function readOnline(force) {
   if (FIXTURE || online.pending) return;
   if (!force && Date.now() - online.at < 10000) return;
@@ -84,7 +108,7 @@ const section = (id, title, kids, action) => el('section', { class: 'fr-set__sec
   el('div', { class: 'fr-set__head' }, el('h2', { class: 'fr-set__title' }, title), action || null),
   kids);
 
-/* ── the seven sections ────────────────────────────────────────────────────────────────────────────────────────── */
+/* ── the eight sections ────────────────────────────────────────────────────────────────────────────────────────── */
 
 function reposSection(scope) {
   const tuples = repoTuples();
@@ -194,6 +218,22 @@ function validateSection(scope) {
     el('span', { 'data-fr': 'consent-state', 'data-on': known ? String(c.on) : 'unread' }, line), toggle, open)]);
 }
 
+function peopleSection(scope) {
+  const repo = scope === 'all' ? null : activeProduct();
+  const ws = wsOfRepo(repo);
+  if (!ws) return section('people', P.people, [empty({ text: P.peopleNoRepo })]);
+  readPeople(ws);
+  const c = peopleByWs.get(ws) || {};
+  const known = c.on === true || c.on === false;
+  const line = c.error ? c.error : !known ? '' : c.on ? P.peopleOn : P.peopleOff;
+  const toggle = known ? button({
+    label: c.on ? P.turnOff : P.turnOn, variant: 'outline', size: 'sm',
+    attrs: { 'data-fr': 'people-calendar' }, onClick: () => setPeopleCalendar(ws, !c.on),
+  }) : null;
+  return section('people', P.people, [el('p', { class: 'fr-set__note' }, P.peopleNote),
+    el('div', { class: 'fr-set__line' }, el('span', { 'data-fr': 'people-state', 'data-on': known ? String(c.on) : 'unread' }, line), toggle)]);
+}
+
 function onlineSection() {
   readOnline(false);
   const d = online.data;
@@ -353,7 +393,7 @@ function signature(scope) {
   let add = '';
   try { add = JSON.stringify(addKeys); } catch { add = String(Date.now()); }
   const kit = ws ? kitByWs.get(ws) : null;
-  return JSON.stringify([repoTuples(), activeProduct(), scope, state.theme, sessionDefaults(), ws, consentByWs.get(ws) || null, addOpen, !!addMod, online.data, online.error, online.note,
+  return JSON.stringify([repoTuples(), activeProduct(), scope, state.theme, sessionDefaults(), ws, consentByWs.get(ws) || null, peopleByWs.get(ws) || null, addOpen, !!addMod, online.data, online.error, online.note,
     kit ? kit.st : null, upd]) + add;
 }
 
@@ -380,6 +420,7 @@ export function mountDestination(host, ctx) {
     profilesSection(),
     sessionsSection(),
     validateSection(scope),
+    peopleSection(scope),
     onlineSection(),
     themeSection(),
     updatesSection(scope),

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

@@ -27,6 +27,7 @@ export const COPY = {
     board: 'Board',
     reports: 'Reports',
     docs: 'Docs',
+    people: 'People',
     agent: 'Agent',
     settings: 'Settings',
   },
@@ -145,6 +146,12 @@ export const COPY = {
     validateUnread: 'The consent of this repository did not load.',
     validateNoRepo: 'Choose a repository to set its consent.',
     validateOpen: 'Open Validate',
+    people: 'People',
+    peopleOn: 'Calendar attendee names are kept. Agent sessions record who attends each meeting.',
+    peopleOff: 'Calendar attendee names are not kept. Agent sessions record no one from the calendar.',
+    peopleNote: 'Keep attendee names from the calendar, for this repository only. Turning it off also hides the names recorded before.',
+    peopleUnread: 'The People setting of this repository did not load.',
+    peopleNoRepo: 'Choose a repository to set what People keeps.',
     turnOn: 'Turn on',
     turnOff: 'Turn off',
     theme: 'Theme',

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

@@ -4,7 +4,8 @@
  *   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,
- *           Jira tickets (sheet-jira.js, initiative jira-wbs: the tickets drafted from the PRD and their status in Jira)
+ *           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
  * Nothing on this sheet says "plan". Everything it shows is read from GET /api/initiatives/<id>; every write goes through
  * initiatives-api.js. The Breakdown tab mounts with a tab id of the form `initiative:<slug>`, so it never meets a panel-4
@@ -19,6 +20,7 @@ import { sheet, button, iconButton, tabs, row, badge, menu, toast, empty, field,
 import { icon, ensureSprite } from './icons.js';
 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 { openNewSession } from './panel-newsess.js';
 import { wsOf, readDoc, saveDoc } from './data.js';
@@ -241,7 +243,7 @@ export function openSheet(repo, slug) {
   function drawTabs() {
     tabsHost.replaceChildren(tabs({
       variant: 'segmented', full: true, ariaLabel: COPY.sheet.tabs, value: tab,
-      items: [{ id: 'breakdown', label: COPY.sheet.breakdown }, { id: 'files', label: COPY.sheet.files }, { id: 'history', label: COPY.sheet.history }, { id: 'jira', label: COPY.sheet.jira }],
+      items: [{ id: 'breakdown', label: COPY.sheet.breakdown }, { id: 'files', label: COPY.sheet.files }, { id: 'history', label: COPY.sheet.history }, { id: 'jira', label: COPY.sheet.jira }, { id: 'people', label: COPY.sheet.people }],
       onChange: (id) => {
         if (id === tab) return;
         if (tab === 'breakdown') unmountBreakdown(bdHost);
@@ -263,6 +265,7 @@ export function openSheet(repo, slug) {
       return;
     }
     if (tab === 'jira') { mountJira(panel, { ws, slug }); return; }
+    if (tab === 'people') { panel.replaceChildren(initiativePeople(ws, slug, { onOpen: () => s.close() })); return; }
     if (tab === 'files') {
       const files = data.files || [];
       // Grouped by where the tie came from (scan-consistency R3): the record's own paths, the documents the library's

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

@@ -127,6 +127,7 @@ export const COPY = {
     files: 'Files',
     history: 'History',
     jira: 'Jira tickets',
+    people: 'People',
     waitingYou: (act) => `Waiting on you: ${act}`,
     waitingAgent: (act) => `Waiting on agent: ${act}`,
     nothingOwed: 'Nothing is owed.',

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

@@ -17,6 +17,7 @@ import { icon } from './icons.js';
 import { COPY, STATES, ago, dayOf, ownerLabel } from './breakdown-copy.js';
 import { stageLabel } from './bd-model.js';
 import { handoffBox } from './handoff-box.js';
+import { peopleOf, namedIn, openPerson } from './people-link.js';
 
 const ownerKind = (o) => (o === 'you' || o === 'agent' ? o : String(o || '').split(':')[0] || 'you');
 const ownerName = (o) => { const s = String(o || ''); const i = s.indexOf(':'); return i > 0 ? s.slice(i + 1) : ''; };
@@ -113,6 +114,20 @@ export function openItemSheet(ctx, id, { handoff = false } = {}) {
   });
   owner.setAttribute('data-bd-field', 'owner');
   const showOwnerName = (k) => { ownerNameField.hidden = !(k === 'person' || k === 'tracker'); };
+  // A person owner who is on People links to their page (people-directory R13). Nothing shows for anyone else.
+  const ownerPeople = el('span', { class: 'rp-people-links', 'data-bd-owner-people': '' });
+  let ownerShown = null;
+  const drawOwnerPeople = (o) => {
+    if (o === ownerShown) return;
+    ownerShown = o;
+    ownerPeople.replaceChildren();
+    if (ownerKind(o) !== 'person' || !ownerName(o)) return;
+    peopleOf(ctx.ws).then((v) => {
+      if (ownerShown !== o) return;
+      ownerPeople.replaceChildren(...namedIn(v, ownerName(o)).map((p) => button({ label: p.name, variant: 'ghost', size: 'sm', iconEnd: 'chevron-right',
+        attrs: { 'data-person-link': p.id, 'aria-label': `Open ${p.name} in People` }, onClick: () => { sh.close(); openPerson(p.id); } })));
+    });
+  };
   const stage = field({
     label: COPY.labels.stage, kind: 'select', value: it0.stage, attrs: { 'data-bd-input': 'stage' },
     options: (L0.stages || []).map((s) => ({ value: s.id, label: s.label })),
@@ -211,12 +226,13 @@ export function openItemSheet(ctx, id, { handoff = false } = {}) {
   const sh = sheet({
     mode: 'auto', title: it0.title, sub: ctx.slug + ' · ' + stageLabel(L0, it0.stage),
     attrs: { 'data-bd-sheet': id },
-    body: [stateSlot, noteSlot, title, el('div', { class: 'bd-grid2' }, el('div', { class: 'bd-group' }, owner, ownerNameField), stage),
+    body: [stateSlot, noteSlot, title, el('div', { class: 'bd-grid2' }, el('div', { class: 'bd-group' }, owner, ownerNameField, ownerPeople), stage),
       afterSlot, el('div', { class: 'bd-grid2' }, start, due), el('div', { class: 'bd-checks' }, milestone, blocked), reason, note, handSlot, history],
     actions: [withdraw, closeBtn],
     onClose: () => { if (ctx.onClose) ctx.onClose(id); },
   });
   showOwnerName(ownerKind(it0.owner));
+  drawOwnerPeople(it0.owner);
 
   const refresh = () => {
     const it = item();
@@ -230,6 +246,7 @@ export function openItemSheet(ctx, id, { handoff = false } = {}) {
     if (!focused(title.control)) title.control.resetCommitted(it.title);
     if (!focused(owner.control)) { owner.control.value = ownerKind(it.owner); showOwnerName(ownerKind(it.owner)); }
     if (!focused(ownerNameField.control) && ownerName(it.owner)) ownerNameField.control.resetCommitted(ownerName(it.owner));
+    drawOwnerPeople(it.owner);
     if (!focused(stage.control)) stage.control.value = it.stage;
     if (!afterSlot.contains(document.activeElement)) drawAfter(it);
     if (!focused(start.control)) start.control.value = it.start || '';

package/workspace/public/pm/panel-cockpit.js

@@ -44,6 +44,8 @@ export const VIEWS = {
   addrepo: { label: 'add repository', mode: null, scoped: false },
   // jev-live-notes Run 6: confirm each talking point as it arrives
   livenotes: { label: 'live notes', mode: null, scoped: true, palette: true, hint: 'confirm talking points' },
+  // meeting-notes Run 1: typed notes, dictation, meeting transcripts and summaries; the PM's own, the same in every repository
+  notes: { label: 'notes', mode: null, scoped: false, palette: true, hint: 'type, dictate or record a meeting' },
 };
 
 /** The view a list mode opens as, or null when the mode is not a view. `product` is the list itself. */
@@ -93,6 +95,7 @@ function modes() {
  * every `data-*` hook the suites use, and only adds the board's frame around it. A view with no board module draws as before. */
 export const BOARD_MODULES = {
   today: './view-today.js', validate: './view-validate.js', addrepo: './view-addrepo.js', livenotes: './view-livenotes.js',
+  notes: './view-notes.js',
 };
 const boardMods = {};   // view -> undefined (not tried) · null (loading or absent) · module
 function boardOf(view) {