create-pmos 0.61.0 → 0.62.0

package/workspace/lib/people.js

@@ -0,0 +1,399 @@
+'use strict';
+/* people.js — the people the PM works with in a repository: the row rules and the one fold (initiative people-directory,
+ * PRD R1 to R10, proposed D90).
+ *
+ *   checkSighting(s)                 → { ok, row } | { ok:false, error }   one sighting an agent session records
+ *   checkMergeProposal(m)            → { ok, row } | { ok:false, error }
+ *   checkDecision(body)              → { ok, row } | { ok:false, error }   one PM press (add, ignore, merge, keep-separate,
+ *                                                                           edit, tone, note, note-remove, setting)
+ *   fold(rows, { now, items, meetings }) → { people, review, settings, counts }
+ *   handleKey(h) · slugOf(name) · toneProposal(interactions) · matchPeople(people, text)
+ *   SOURCES · HANDLE_KINDS · INTERACTION_KINDS · TONES · ACTS · LEDGER
+ *
+ * Pure: no file, no clock unless given, no network. lib/people-store.js reads and appends; the route, the CLI and the
+ * People place all answer from fold(), so the terminal and the page cannot hold two opinions about a person.
+ *
+ * WHO DECIDES (D90). A sighting row is anyone's: an agent session records it through `pmos people record`. Every
+ * decision row (a person added, a handle ignored or merged, a tone, a note, the calendar setting) counts only when its
+ * `by` is the PM (`pm:<slug>`), which only a page press writes. A decision row with any other `by` is skipped and
+ * counted in counts.skipped, so a hand-appended line cannot make an agent's choice the PM's.
+ *
+ * CALENDAR NAMES (R3). The setting is off until the PM turns it on. While it is off, the store refuses a calendar
+ * sighting, and this fold also drops the calendar sightings recorded while it was on.
+ */
+
+const LEDGER = 'people.jsonl';
+const SOURCES = Object.freeze(['gather', 'calendar', 'live', 'jira']);
+const HANDLE_KINDS = Object.freeze(['mail', 'slack', 'jira', 'confluence', 'speaker', 'name']);
+const INTERACTION_KINDS = Object.freeze(['Mail', 'Chat', 'Meeting', '1:1', 'Jira', 'Doc', 'Call', 'Mention']);
+const TONES = Object.freeze(['warm', 'neutral', 'cautious', 'tense']);
+const ACTS = Object.freeze(['add', 'ignore', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const ID_RE = /^[a-z0-9][a-z0-9-]{0,59}$/;
+const NOTE_ID_RE = /^n-[0-9a-z]{4,16}$/;
+const PM_BY_RE = /^pm:[a-z0-9_-]{1,40}$/;
+const TONE_WINDOW = 10;
+
+const isObj = (x) => !!x && typeof x === 'object' && !Array.isArray(x);
+const str = (v) => (typeof v === 'string' ? v.replace(/\s+/g, ' ').trim() : '');
+/** A text field: a string of 1 to `max` characters after its spaces are folded, or null when absent and optional. */
+function text(v, max, what, { required = false } = {}) {
+  if (v === undefined || v === null || v === '') return required ? { error: `${what} is required` } : { value: null };
+  if (typeof v !== 'string') return { error: `${what} must be text` };
+  const s = str(v);
+  if (!s) return required ? { error: `${what} is required` } : { value: null };
+  if (s.length > max) return { error: `${what} is over ${max} characters` };
+  return { value: s };
+}
+
+/** The key a handle is known by: its kind and its value, lower-cased. Two sightings of one key are one handle. */
+function handleKey(h) {
+  if (!isObj(h)) return '';
+  return `${String(h.kind || '')}:${str(h.value).toLowerCase()}`;
+}
+function checkHandle(h, what = 'handle') {
+  if (!isObj(h)) return { error: `${what} must be { kind, value }` };
+  if (!HANDLE_KINDS.includes(h.kind)) return { error: `${what}.kind must be one of: ${HANDLE_KINDS.join(', ')}` };
+  const v = text(h.value, 120, `${what}.value`, { required: true });
+  if (v.error) return v;
+  return { value: { kind: h.kind, value: v.value } };
+}
+
+/** "Mei Lin" → "mei-lin". A name with no letter or digit gives "person". */
+function slugOf(name) {
+  const s = str(name).toLowerCase().normalize('NFKD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 50);
+  return s || 'person';
+}
+
+/** One sighting, as `pmos people record` takes it. Returns the row to append, without v, at or by (the store adds them). */
+function checkSighting(s) {
+  if (!isObj(s)) return { ok: false, error: 'a sighting must be an object' };
+  if (!SOURCES.includes(s.source)) return { ok: false, error: `source must be one of: ${SOURCES.join(', ')}` };
+  const h = checkHandle(s.handle);
+  if (h.error) return { ok: false, error: h.error };
+  const name = text(s.name, 80, 'name', { required: true });
+  if (name.error) return { ok: false, error: name.error };
+  const role = text(s.role, 120, 'role');
+  if (role.error) return { ok: false, error: role.error };
+  const org = text(s.org, 80, 'org');
+  if (org.error) return { ok: false, error: org.error };
+  if (s.external !== undefined && typeof s.external !== 'boolean') return { ok: false, error: 'external must be true or false' };
+  const row = { kind: 'sighting', source: s.source, handle: h.value, name: name.value };
+  if (role.value) row.role = role.value;
+  if (org.value) row.org = org.value;
+  if (s.external === true) row.external = true;
+  if (s.interaction !== undefined && s.interaction !== null) {
+    const i = s.interaction;
+    if (!isObj(i)) return { ok: false, error: 'interaction must be an object' };
+    if (typeof i.date !== 'string' || !DATE_RE.test(i.date.slice(0, 10))) return { ok: false, error: 'interaction.date must be YYYY-MM-DD' };
+    if (!INTERACTION_KINDS.includes(i.kind)) return { ok: false, error: `interaction.kind must be one of: ${INTERACTION_KINDS.join(', ')}` };
+    const t = text(i.text, 200, 'interaction.text', { required: true });
+    if (t.error) return { ok: false, error: t.error };
+    const p = text(i.pointer, 200, 'interaction.pointer', { required: true });
+    if (p.error) return { ok: false, error: p.error };
+    if (i.tone !== undefined && i.tone !== null && !TONES.includes(i.tone)) return { ok: false, error: `interaction.tone must be one of: ${TONES.join(', ')}` };
+    if (i.initiative !== undefined && i.initiative !== null && (typeof i.initiative !== 'string' || !ID_RE.test(i.initiative))) return { ok: false, error: 'interaction.initiative must be an initiative id' };
+    row.interaction = { date: i.date.slice(0, 10), kind: i.kind, text: t.value, pointer: p.value };
+    if (i.tone) row.interaction.tone = i.tone;
+    if (i.initiative) row.interaction.initiative = i.initiative;
+  }
+  return { ok: true, row };
+}
+
+function checkMergeProposal(m) {
+  if (!isObj(m)) return { ok: false, error: 'a merge proposal must be an object' };
+  const a = checkHandle(m.a, 'a');
+  if (a.error) return { ok: false, error: a.error };
+  const b = checkHandle(m.b, 'b');
+  if (b.error) return { ok: false, error: b.error };
+  if (handleKey(a.value) === handleKey(b.value)) return { ok: false, error: 'a merge proposal needs two different handles' };
+  const why = text(m.why, 200, 'why', { required: true });
+  if (why.error) return { ok: false, error: why.error };
+  return { ok: true, row: { kind: 'merge-proposal', a: a.value, b: b.value, why: why.value } };
+}
+
+/** One PM press. The route passes the request body; the store adds v, at and by. */
+function checkDecision(body) {
+  if (!isObj(body)) return { ok: false, error: 'the body must be an object' };
+  const act = body.act;
+  if (!ACTS.includes(act)) return { ok: false, error: `act must be one of: ${ACTS.join(', ')}` };
+  const person = () => (typeof body.person === 'string' && ID_RE.test(body.person) ? body.person : null);
+  if (act === 'setting') {
+    if (typeof body.calendar_names !== 'boolean') return { ok: false, error: 'calendar_names must be true or false' };
+    return { ok: true, row: { kind: 'setting', calendar_names: body.calendar_names } };
+  }
+  if (act === 'add') {
+    const h = checkHandle(body.handle);
+    if (h.error) return { ok: false, error: h.error };
+    const name = text(body.name, 80, 'name', { required: true });
+    if (name.error) return { ok: false, error: name.error };
+    return { ok: true, row: { kind: 'add', handle: h.value, name: name.value } };
+  }
+  if (act === 'ignore') {
+    const h = checkHandle(body.handle);
+    if (h.error) return { ok: false, error: h.error };
+    return { ok: true, row: { kind: 'ignore', handle: h.value } };
+  }
+  if (act === 'merge') {
+    const h = checkHandle(body.handle);
+    if (h.error) return { ok: false, error: h.error };
+    if (!person()) return { ok: false, error: 'say which person the handle joins' };
+    return { ok: true, row: { kind: 'merge', person: person(), handle: h.value } };
+  }
+  if (act === 'keep-separate') {
+    const a = checkHandle(body.a, 'a');
+    if (a.error) return { ok: false, error: a.error };
+    const b = checkHandle(body.b, 'b');
+    if (b.error) return { ok: false, error: b.error };
+    return { ok: true, row: { kind: 'keep-separate', a: a.value, b: b.value } };
+  }
+  if (!person()) return { ok: false, error: 'say which person' };
+  if (act === 'edit') {
+    const row = { kind: 'edit', person: person() };
+    for (const [k, max] of [['name', 80], ['role', 120], ['org', 80]]) {
+      if (body[k] === undefined) continue;
+      if (body[k] === null || body[k] === '') { if (k === 'name') return { ok: false, error: 'name is required' }; row[k] = null; continue; }
+      const t = text(body[k], max, k, { required: k === 'name' });
+      if (t.error) return { ok: false, error: t.error };
+      row[k] = t.value;
+    }
+    if (body.external !== undefined) {
+      if (typeof body.external !== 'boolean') return { ok: false, error: 'external must be true or false' };
+      row.external = body.external;
+    }
+    if (Object.keys(row).length === 2) return { ok: false, error: 'nothing to change' };
+    return { ok: true, row };
+  }
+  if (act === 'tone') {
+    if (body.tone !== null && !TONES.includes(body.tone)) return { ok: false, error: `tone must be one of: ${TONES.join(', ')}, or null to clear it` };
+    return { ok: true, row: { kind: 'tone', person: person(), tone: body.tone } };
+  }
+  if (act === 'note') {
+    const t = text(body.text, 500, 'note', { required: true });
+    if (t.error) return { ok: false, error: t.error };
+    if (typeof body.id !== 'string' || !NOTE_ID_RE.test(body.id)) return { ok: false, error: 'the note needs an id (n- and 4 to 16 letters or digits)' };
+    return { ok: true, row: { kind: 'note', person: person(), id: body.id, text: t.value } };
+  }
+  // note-remove
+  if (typeof body.id !== 'string' || !NOTE_ID_RE.test(body.id)) return { ok: false, error: 'say which note' };
+  return { ok: true, row: { kind: 'note-remove', person: person(), id: body.id } };
+}
+
+/** The proposed overall tone: the most frequent tone of the latest TONE_WINDOW toned interactions; the latest of the
+ * tied tones wins a tie. `interactions` is newest first. null when no interaction has a tone. */
+function toneProposal(interactions) {
+  const toned = (interactions || []).filter((i) => i && TONES.includes(i.tone)).slice(0, TONE_WINDOW);
+  if (!toned.length) return null;
+  const n = {};
+  for (const i of toned) n[i.tone] = (n[i.tone] || 0) + 1;
+  const top = Math.max(...Object.values(n));
+  return toned.find((i) => n[i.tone] === top).tone;
+}
+
+const escRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Does `hay` name `needle` as a whole word, ignoring case? */
+function names(hay, needle) {
+  const n = str(needle);
+  if (n.length < 2) return false;
+  return new RegExp(`(^|[^\\p{L}\\p{N}])${escRe(n)}($|[^\\p{L}\\p{N}])`, 'iu').test(String(hay || ''));
+}
+/** The words a person is matched by in free text: the full name, a first name of three letters or more, and the
+ * values of their name and speaker handles. */
+function matchWords(p) {
+  const w = new Set();
+  const full = str(p.name);
+  if (full) w.add(full);
+  const first = full.split(' ')[0];
+  if (first && first.length >= 3 && first !== full) w.add(first);
+  for (const h of p.handles || []) if (h.kind === 'name' || h.kind === 'speaker' || h.kind === 'slack' || h.kind === 'jira') w.add(str(h.value).replace(/^@/, ''));
+  return [...w].filter((x) => x.length >= 2);
+}
+/** The people a free-text line names (an Agenda `with`, an item owner), each once, in list order. */
+function matchPeople(people, hay) {
+  if (!hay) return [];
+  return (people || []).filter((p) => matchWords(p).some((w) => names(hay, w)));
+}
+
+const sightKey = (r) => [handleKey(r.handle), r.interaction ? r.interaction.date : '', r.interaction ? r.interaction.pointer : '', r.interaction ? r.interaction.text : ''].join('\u0000');
+const pairKey = (a, b) => [handleKey(a), handleKey(b)].sort().join('\u0000');
+const isPm = (r) => typeof r.by === 'string' && PM_BY_RE.test(r.by);
+const DECISION_KINDS = new Set(['add', 'ignore', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
+
+/**
+ * The one fold. `rows` are the ledger's rows in file order (torn lines already dropped). `items` are plan items (the
+ * plan-items fold's values) and `meetings` the coming calendar events ({ start, title, with }); both are optional.
+ */
+function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
+  const counts = { rows: 0, skipped: 0, duplicates: 0, hiddenCalendar: 0 };
+  const settings = { calendar_names: false };
+  const people = new Map();       // id -> person
+  const owner = new Map();        // handle key -> person id
+  const ignored = new Set();      // handle keys
+  const closed = new Set();       // merge-proposal pair keys the PM kept separate
+  const sightings = [];
+  const proposals = [];
+
+  // 1 · decisions, in file order; the calendar setting first so the sightings below read the final value
+  for (const r of rows || []) {
+    if (!isObj(r)) continue;
+    counts.rows++;
+    if (DECISION_KINDS.has(r.kind) && !isPm(r)) { counts.skipped++; continue; }
+    if (r.kind === 'setting' && typeof r.calendar_names === 'boolean') settings.calendar_names = r.calendar_names;
+  }
+  const attach = (id, h) => {
+    const k = handleKey(h);
+    const prev = owner.get(k);
+    if (prev && prev !== id && people.has(prev)) { const pp = people.get(prev); pp.handles = pp.handles.filter((x) => handleKey(x) !== k); }
+    owner.set(k, id);
+    ignored.delete(k);
+    const p = people.get(id);
+    if (!p.handles.some((x) => handleKey(x) === k)) p.handles.push({ kind: h.kind, value: h.value });
+  };
+  for (const r of rows || []) {
+    if (!isObj(r)) continue;
+    if (r.kind === 'sighting') {
+      const c = checkSighting(r);
+      if (c.ok) sightings.push({ ...c.row, at: r.at || null });
+      continue;
+    }
+    if (r.kind === 'merge-proposal') {
+      const c = checkMergeProposal(r);
+      if (c.ok) proposals.push({ ...c.row, at: r.at || null });
+      continue;
+    }
+    if (!DECISION_KINDS.has(r.kind) || !isPm(r) || r.kind === 'setting') continue;
+    const c = checkDecision({ ...r, act: r.kind });
+    if (!c.ok) { counts.skipped++; continue; }
+    const d = c.row;
+    if (d.kind === 'add') {
+      const k = handleKey(d.handle);
+      if (owner.has(k) && people.has(owner.get(k))) continue;
+      let id = slugOf(d.name);
+      for (let n = 2; people.has(id); n++) id = `${slugOf(d.name).slice(0, 56)}-${n}`;
+      people.set(id, { id, name: d.name, role: null, org: null, external: null, handles: [], tone: null, notes: new Map(), addedAt: r.at || null, edited: {} });
+      attach(id, d.handle);
+    } else if (d.kind === 'ignore') {
+      const k = handleKey(d.handle);
+      if (!owner.has(k)) ignored.add(k);
+    } else if (d.kind === 'merge') {
+      if (people.has(d.person)) attach(d.person, d.handle);
+    } else if (d.kind === 'keep-separate') {
+      closed.add(pairKey(d.a, d.b));
+    } else if (people.has(d.person)) {
+      const p = people.get(d.person);
+      if (d.kind === 'edit') {
+        for (const k of ['name', 'role', 'org', 'external']) if (d[k] !== undefined) { p[k] = d[k]; p.edited[k] = true; }
+      } else if (d.kind === 'tone') p.tone = d.tone;
+      else if (d.kind === 'note') p.notes.set(d.id, { id: d.id, text: d.text, at: r.at || null });
+      else if (d.kind === 'note-remove') p.notes.delete(d.id);
+    }
+  }
+
+  // 2 · sightings: dedup, drop calendar ones while the setting is off, then hand each to its person or the review list
+  const seen = new Set();
+  const fresh = new Map();   // handle key -> { handle, name, role, org, external, count, sources, last }
+  const interactions = new Map();   // person id -> []
+  for (const s of sightings) {
+    const key = sightKey(s);
+    if (seen.has(key)) { counts.duplicates++; continue; }
+    seen.add(key);
+    if (s.source === 'calendar' && !settings.calendar_names) { counts.hiddenCalendar++; continue; }
+    const k = handleKey(s.handle);
+    const id = owner.get(k);
+    if (id && people.has(id)) {
+      const p = people.get(id);
+      for (const f of ['role', 'org']) if (s[f] && !p.edited[f]) p[f] = s[f];
+      if (s.external === true && !p.edited.external) p.external = true;
+      if (s.interaction) {
+        if (!interactions.has(id)) interactions.set(id, []);
+        interactions.get(id).push({ ...s.interaction, source: s.source, handle: s.handle, at: s.at });
+      }
+      continue;
+    }
+    if (ignored.has(k)) continue;
+    const f = fresh.get(k) || { handle: s.handle, name: s.name, role: null, org: null, external: false, count: 0, sources: [], last: null };
+    f.name = s.name;
+    if (s.role) f.role = s.role;
+    if (s.org) f.org = s.org;
+    if (s.external) f.external = true;
+    f.count++;
+    if (!f.sources.includes(s.source)) f.sources.push(s.source);
+    const d = s.interaction ? s.interaction.date : (s.at || '').slice(0, 10);
+    if (d && (!f.last || d > f.last)) f.last = d;
+    fresh.set(k, f);
+  }
+
+  // 3 · each person's page
+  const today = new Date(now).toISOString().slice(0, 10);
+  const list = [...people.values()].filter((p) => p.handles.length).map((p) => {
+    const ints = (interactions.get(p.id) || []).sort((a, b) => (b.date < a.date ? -1 : b.date > a.date ? 1 : String(b.at || '').localeCompare(String(a.at || ''))));
+    const mix = {};
+    for (const i of ints) if (i.tone) mix[i.tone] = (mix[i.tone] || 0) + 1;
+    const proposed = toneProposal(ints);
+    const inits = new Map();
+    for (const i of ints) if (i.initiative) {
+      const g = inits.get(i.initiative) || { id: i.initiative, count: 0, last: null };
+      g.count++; if (!g.last || i.date > g.last) g.last = i.date;
+      inits.set(i.initiative, g);
+    }
+    const person = {
+      id: p.id, name: p.name, role: p.role || null, org: p.org || null, external: p.external === true,
+      group: p.external === true ? 'External' : 'Team',
+      handles: p.handles.slice(),
+      interactions: ints,
+      tone: { proposed, confirmed: p.tone || null, mix, pending: !!proposed && !p.tone },
+      notes: [...p.notes.values()],
+      last: ints.length ? ints[0].date : (p.addedAt ? String(p.addedAt).slice(0, 10) : null),
+      count: ints.length,
+      shared: { initiatives: [...inits.values()].sort((a, b) => b.count - a.count || a.id.localeCompare(b.id)), items: [], meetings: [] },
+    };
+    return person;
+  });
+
+  // 4 · shared work from the repository: plan items owned by the person, and coming meetings that name them
+  for (const it of items || []) {
+    if (!it || it.state === 'withdrawn' || typeof it.owner !== 'string' || !it.owner.startsWith('person:')) continue;
+    const who = it.owner.slice(7);
+    for (const p of matchPeople(list, who)) {
+      p.shared.items.push({ id: it.id, title: it.title, initiative: it.initiative, state: it.state, blocked: !!it.blocked, reason: (it.blocked && ((typeof it.blocked === 'object' && it.blocked.reason) || it.reason)) || null, due: it.due || null });
+    }
+  }
+  if (settings.calendar_names) {
+    for (const m of meetings || []) {
+      if (!m || !m.with || !m.start || String(m.start).slice(0, 10) < today) continue;
+      for (const p of matchPeople(list, m.with)) if (p.shared.meetings.length < 5) p.shared.meetings.push({ start: m.start, title: m.title || '', with: m.with });
+    }
+    for (const p of list) p.shared.meetings.sort((a, b) => String(a.start).localeCompare(String(b.start)));
+  }
+  list.sort((a, b) => String(b.last || '').localeCompare(String(a.last || '')) || a.name.localeCompare(b.name));
+
+  // 5 · the review list: new handles, open merge proposals, tones the PM has not confirmed
+  const merges = [];
+  const shown = new Set();
+  for (const m of proposals) {
+    const pk = pairKey(m.a, m.b);
+    if (closed.has(pk) || shown.has(pk)) continue;
+    const oa = owner.get(handleKey(m.a)); const ob = owner.get(handleKey(m.b));
+    if (oa && ob && oa === ob) continue;
+    // Merge needs a person to join: the one holding a (or else b). Two handles nobody holds wait in "new" instead.
+    const into = oa && people.has(oa) ? oa : ob && people.has(ob) ? ob : null;
+    if (!into) continue;
+    const other = into === oa ? m.b : m.a;
+    if (ignored.has(handleKey(other))) continue;
+    shown.add(pk);
+    merges.push({ a: m.a, b: m.b, why: m.why, person: into, personName: people.get(into).name, handle: other });
+  }
+  const freshList = [...fresh.values()].sort((a, b) => String(b.last || '').localeCompare(String(a.last || '')) || b.count - a.count);
+  const tones = list.filter((p) => p.tone.pending).map((p) => p.id);
+  return {
+    people: list,
+    review: { new: freshList, merges, tones, count: freshList.length + merges.length + (tones.length ? 1 : 0) },
+    settings,
+    counts,
+  };
+}
+
+module.exports = {
+  LEDGER, SOURCES, HANDLE_KINDS, INTERACTION_KINDS, TONES, ACTS, TONE_WINDOW,
+  checkSighting, checkMergeProposal, checkDecision, fold, handleKey, slugOf, toneProposal, matchPeople, matchWords,
+};

package/workspace/lib/pmos-verbs.js

@@ -41,6 +41,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): docs-three-way-sync added it through the same table.
   docs: Object.freeze({ module: 'docs-cli.js', run: null, guide: 'docs.md',
     help: 'pmos docs [list|link|unlink|find] … — is each linked document the same as, ahead of or behind its Google Docs and Confluence copy, and record a sync (pmos docs help)' }),
+  // Not a pm-os-absorb verb (run: null): people-directory added it through the same table.
+  people: Object.freeze({ module: 'people-cli.js', run: null, guide: 'people.md',
+    help: 'pmos people list|show|record|settings … — the people you work with in this repository (pmos people help)' }),
   launcher: Object.freeze({ module: 'launcher-cli.js', run: null, guide: 'launcher.md',
     help: 'pmos launcher on|off|status — a PMOS app and a login item, so the workspace starts without a terminal' }),
 });

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.61.0",
+  "version": "0.62.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.61.0",
+  "version": "0.62.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/app.js

@@ -406,7 +406,7 @@ function render() {
 
 const FRAME = !FIXTURE && !LEGACY_LAYOUT_FLAG;
 const FRAME_KEY = 'pmos.workspace.pm.frame';
-const FRAME_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs', 'settings']);
+const FRAME_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs', 'people', 'settings']);
 
 function readFrame() {
   if (!FRAME) return {};
@@ -637,7 +637,7 @@ function pressIn(r, key) {
   if (b && !b.disabled) { b.click(); return true; }
   return false;
 }
-const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs' };
+const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs', p: 'people' };
 
 function frameKey(e) {
   const mod = e.metaKey || e.ctrlKey;

package/workspace/public/pm/components.css

@@ -4503,6 +4503,175 @@
   }
 }
 
+/* People (people-directory): what waits for the PM, the list beside the chosen person's page. */
+.rp-people {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-people-top {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 12px;
+}
+.rp-people-top > .rp-head__title {
+  margin-right: auto;
+}
+.rp-people-find {
+  flex: 1 1 260px;
+  max-width: 420px;
+}
+.rp-people-body {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-people-review {
+  padding: 12px;
+  border: 1px solid var(--border);
+}
+.rp-people-grid {
+  display: grid;
+  grid-template-columns: minmax(260px, 2fr) 3fr;
+  gap: 24px;
+  align-items: start;
+}
+.rp-people-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-width: 0;
+}
+.rp-people-views {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  border-bottom: 1px solid var(--border);
+}
+.rp-people-row {
+  border-top: 1px solid var(--border);
+}
+.rp-people-row:last-child {
+  border-bottom: 1px solid var(--border);
+}
+.rp-people-row--open {
+  box-shadow: inset 2px 0 0 var(--foreground);
+}
+.rp-people-page {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  min-width: 0;
+}
+.rp-people-who__name {
+  margin: 0;
+  font-size: 20px;
+  font-weight: 500;
+}
+.rp-people-sec {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.rp-people-sec__title {
+  margin: 0;
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--muted-foreground);
+}
+.rp-people-hint {
+  margin: 0;
+  font-size: 12px;
+  color: var(--muted-foreground);
+}
+.rp-people-tone {
+  margin: 0;
+  font-size: 14px;
+}
+.rp-people-acts {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.rp-people-ints,
+.rp-people-list-plain {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.rp-people-int {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid var(--border);
+}
+.rp-people-int__when,
+.rp-people-int__src {
+  font-size: 12px;
+  color: var(--muted-foreground);
+}
+.rp-people-int__src {
+  overflow-wrap: anywhere;
+}
+.rp-people-int__text,
+.rp-people-shared,
+.rp-people-handle {
+  font-size: 14px;
+}
+.rp-people-shared {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+}
+.rp-people-note {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 8px;
+  border: 1px solid var(--border);
+}
+.rp-people-note__text {
+  font-size: 14px;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+.rp-people-noteadd {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.rp-people-links {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+.rp-people-links:empty {
+  display: none;
+}
+.rp-people-rel {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.rp-people-file {
+  font-family: var(--mono);
+  overflow-wrap: anywhere;
+}
+@media (max-width: 760px) {
+  .rp-people-grid {
+    grid-template-columns: 1fr;
+  }
+}
+
 /* -- layouts · .lg- the legacy and fixture shells (Run 3, slice 3D) -- */
 /* The legacy and fixture cockpit's two columns: the list head (a stack) and the rail's tile column. */
 .lg-stack {