create-pmos 0.55.4 → 0.56.0

package/workspace/public/pm/components.css

@@ -2362,6 +2362,9 @@
 .td-day__r[data-goal-tie="true"] { border-left: 3px solid var(--foreground); }
 .td-day__lead { min-width: 44px; font: 12px var(--mono); color: var(--muted-foreground); font-variant-numeric: tabular-nums; }
 .td-day__chips { display: inline-flex; gap: 4px; }
+.td-day__chips { align-items: center; flex-wrap: wrap; justify-content: flex-end; }
+.td-day__repo { font: inherit; font-size: 12px; color: var(--foreground); background: var(--background); border: 1px solid var(--border); border-radius: 0; padding: 2px 6px; max-width: 160px; }
+.td-day__repo:focus-visible { outline: 2px solid color-mix(in oklab, var(--ring) 50%, var(--foreground)); outline-offset: 2px; }
 .td-day__nowrow { display: flex; align-items: center; gap: 8px; padding: 0 8px; font: 11px var(--mono); color: var(--destructive); }
 .td-day__nowrow::after { content: ""; flex: 1; border-top: 2px solid var(--destructive); }
 .td-day__gh { display: flex; align-items: center; gap: 6px; margin: 4px 8px 2px; font-size: 12px; font-weight: 600; color: var(--muted-foreground); }
@@ -4064,6 +4067,152 @@
   }
 }
 
+/* Docs (docs-three-way-sync): one line per copy — a status dot, the title over the copy's link, one sentence, one action. */
+.rp-docs {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-docs-top {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 12px;
+}
+.rp-docs-top > .rp-head__title {
+  margin-right: auto;
+}
+.rp-docs-find {
+  flex: 1 1 260px;
+  max-width: 420px;
+}
+.rp-docs-body {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-docs-views {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 12px;
+  border-bottom: 1px solid var(--border);
+}
+.rp-docs-when {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  margin-left: auto;
+  font-size: 12px;
+  color: var(--muted-foreground);
+}
+.rp-docs-group__title {
+  margin: 0;
+  padding: 8px 0;
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--muted-foreground);
+}
+.rp-docs-row {
+  border-top: 1px solid var(--border);
+}
+.rp-docs-row:last-child {
+  border-bottom: 1px solid var(--border);
+}
+.rp-docs-dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  background: var(--muted-foreground);
+}
+.rp-docs-dot--ok {
+  background: var(--muted-foreground);
+}
+.rp-docs-dot--warn {
+  background: var(--warning);
+}
+.rp-docs-dot--bad {
+  background: var(--destructive);
+}
+.rp-docs-dot--none {
+  background: transparent;
+  border: 1px solid var(--muted-foreground);
+}
+.rp-docs-open {
+  font-size: 12px;
+  color: var(--muted-foreground);
+  white-space: nowrap;
+  text-underline-offset: 2px;
+}
+.rp-docs-detail {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 12px;
+  padding: 4px 0 16px 24px;
+}
+.rp-docs-side {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 4px;
+  min-width: 0;
+  padding: 12px;
+  border: 1px solid var(--border);
+}
+.rp-docs-side--new {
+  border-color: var(--foreground);
+}
+.rp-docs-side__label {
+  font-size: 12px;
+  color: var(--muted-foreground);
+}
+.rp-docs-side__where {
+  max-width: 100%;
+  font-family: var(--mono);
+  font-size: 12px;
+  overflow-wrap: anywhere;
+}
+.rp-docs-side__edit {
+  margin-bottom: 8px;
+  font-size: 14px;
+}
+.rp-docs-diff {
+  grid-column: 1 / -1;
+  margin: 0;
+  padding: 8px 10px;
+  border: 1px solid var(--border);
+  font-family: var(--mono);
+  font-size: 12px;
+  overflow-wrap: anywhere;
+}
+.rp-docs-more {
+  grid-column: 1 / -1;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.rp-docs-add {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 0 12px 24px;
+}
+.rp-docs-add__input {
+  flex: 1 1 240px;
+}
+.rp-docs-add__err {
+  flex-basis: 100%;
+  font-size: 12px;
+  color: var(--destructive);
+}
+@media (max-width: 640px) {
+  .rp-docs-detail {
+    grid-template-columns: 1fr;
+    padding-left: 0;
+  }
+}
+
 /* -- 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 {

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

@@ -0,0 +1,405 @@
+/* pm/dest-docs.js — the Docs destination: is each document the same as its Google Docs and Confluence copy, and use
+ * one version over the other on the PM's press (initiative docs-three-way-sync, PRD R-D1 to R-D6 and R-F1 to R-F4).
+ *
+ * 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):
+ *   - Docs, a search box, Needs you · All, and when the copies were last compared, with a control that compares again;
+ *   - the copies grouped by initiative, ONE line per copy: a status dot, the title, a link that opens the copy, one
+ *     sentence (which side is newer, and who edited it last) and at most one button (Use PMOS version, Use Confluence
+ *     version, or Choose… when both changed);
+ *   - a click on a line: both sides with where they live and their last edit, a Use … version button for each, the first
+ *     difference the check saw, Compare again and Stop tracking this copy;
+ *   - search: every markdown file that matches; a file without a copy offers Add copy, in place.
+ * The signal is decided on the server (lib/doc-sync.js) from what a check session read. Nothing here reads or writes
+ * Google Docs or Confluence. Use … version waits five seconds behind Undo, then asks the server to start ONE doc-sync
+ * session for that copy, which writes one side with the PM's own connectors (the PM's ruling, amended 2026-10-06).
+ * In fixture mode it reads nothing.
+ */
+
+import { el } from './dom.js';
+import { button, row, field, toast, empty, tabs, 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';
+
+const LABEL = { google: 'Google Docs', confluence: 'Confluence' };
+const UNDO_MS = 5000;
+
+export const COPY = Object.freeze({
+  title: 'Docs',
+  fixture: 'Docs shows linked documents in a real session.',
+  noRepo: 'Open a repository to see its documents.',
+  loading: 'Reading…',
+  readError: 'The documents could not be read.',
+  find: 'Find a document',
+  needs: 'Needs you',
+  all: 'All',
+  compared: (iso) => 'Compared ' + ago(iso),
+  never: 'Not compared yet',
+  comparing: 'Comparing…',
+  compareAll: 'Compare every copy again',
+  none: 'No document has a copy yet. Find a document above and press Add copy.',
+  nothingNeeds: 'Nothing needs you. Every copy matches PMOS.',
+  noMatch: (q) => `No document matches “${q}”.`,
+  other: 'Other',
+  usePmos: 'Use PMOS version',
+  useCopy: (label) => `Use ${label} version`,
+  choose: 'Choose…',
+  noCopy: 'No copy',
+  addCopy: 'Add copy',
+  add: 'Add',
+  cancel: 'Cancel',
+  paste: 'Paste a Google Docs or Confluence link',
+  badPaste: 'Paste the address of a Google Doc or a Confluence page.',
+  added: 'Copy added. Compare to see which side is newer.',
+  compareAgain: 'Compare again',
+  stop: 'Stop tracking this copy',
+  stopped: (label) => `Stopped tracking the ${label} copy. Nothing was deleted.`,
+  undo: 'Undo',
+  pushing: (label) => `Updating ${label} with the PMOS version.`,
+  pulling: (label) => `Updating PMOS with the ${label} version.`,
+  cancelled: 'Nothing was changed.',
+  started: 'Compare started. It reads every copy and changes nothing.',
+});
+
+// Docs is not in the top bar (the bar holds at most 7 controls); ⌘K and `g d` open it.
+registerCommand({ id: 'docs-open', label: 'Docs', hint: 'Is each document the same as its Google Docs and Confluence copy', cli: 'pmos docs list', run: () => openDestination('docs') });
+
+/* ── words ───────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function ago(iso) {
+  if (!iso) return 'never';
+  const m = Math.round((Date.now() - Date.parse(iso)) / 60000);
+  if (m < 1) return 'just now';
+  if (m < 60) return `${m} min ago`;
+  if (m < 48 * 60) return `${Math.round(m / 60)} h ago`;
+  return `${Math.round(m / 1440)} days ago`;
+}
+/** "today 09:12", "yesterday 17:55", "Mon 14:05", "Sep 30". */
+function when(iso) {
+  const t = new Date(iso);
+  if (Number.isNaN(t.getTime())) return '';
+  const hm = t.toTimeString().slice(0, 5);
+  const day = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+  const days = Math.round((day(new Date()) - day(t)) / 86400000);
+  if (days === 0) return 'today ' + hm;
+  if (days === 1) return 'yesterday ' + hm;
+  if (days > 1 && days < 7) return t.toLocaleDateString('en-US', { weekday: 'short' }) + ' ' + hm;
+  return t.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+const edit = (by, at) => [by, at ? when(at) : null].filter(Boolean).join(', ');
+const keyOf = (doc, link) => `${doc.path}|${link.kind}`;
+/** Which kind a pasted address names. The server checks it again; this only picks the kind. */
+function kindOf(target) {
+  const t = String(target || '');
+  if (/atlassian|confluence|\/wiki\/|pageId=/i.test(t)) return 'confluence';
+  if (/google|docs\.|drive\./i.test(t)) return 'google';
+  return null;
+}
+
+/** One dot, one sentence and at most one button per copy. The newer side's last edit is the only detail on the line. */
+function stateOf(inst, doc, link) {
+  const L = link.label || LABEL[link.kind];
+  const pend = inst.pending.get(keyOf(doc, link));
+  const syncing = link.syncing || (pend ? { use: pend.use } : null);
+  if (syncing) return { dot: 'none', strong: syncing.use === 'pmos' ? `Updating ${L}…` : `Updating PMOS from ${L}…` };
+  const by = (s) => (link.basis === 'date' ? s + ' · by date' : s);
+  let st;
+  switch (link.signal) {
+    case 'same': st = { dot: 'ok', rest: 'Same' }; break;
+    case 'ahead': st = { dot: 'warn', strong: 'PMOS is newer', rest: by(edit(doc.repo && doc.repo.modified_by, doc.repo && doc.repo.modified_at)), btn: 'pmos' }; break;
+    case 'behind': st = { dot: 'warn', strong: `${L} is newer`, rest: by(edit(link.remote_modified_by, link.remote_modified_at)), btn: 'copy' }; break;
+    case 'diverged': st = { dot: 'bad', strong: 'Edited on both sides', btn: 'choose' }; break;
+    case 'unchecked': st = { dot: 'none', rest: COPY.never }; break;
+    case 'unreadable': st = { dot: 'bad', strong: `Can't open in ${L}`, rest: String(link.words || '').replace(/^Could not check — /, '') }; break;
+    case 'missing-remote': st = { dot: 'bad', strong: `Not found in ${L}` }; break;
+    case 'missing-repo': st = { dot: 'bad', strong: 'Not in PMOS any more' }; break;
+    default: st = { dot: 'none', rest: link.words || '' };
+  }
+  if (link.sync_failed) return { ...st, dot: 'bad', strong: 'Sync failed', rest: link.sync_failed.reason };
+  return st;
+}
+
+/* ── 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-docs', 'data-docs': '' }), head: null, body: el('div', { class: 'rp-docs-body' }),
+      ws: null, loaded: false, error: null, view: null, filter: 'needs', q: '', files: [], open: null, adding: null,
+      pending: new Map(), busy: false, seq: 0, fseq: 0, last: '', timer: null, ftimer: null };
+    insts.set(host, inst);
+  }
+  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;
+  if (ws !== inst.ws) {
+    stopPoll(inst);
+    Object.assign(inst, { ws, loaded: false, error: null, view: null, last: '', open: null, adding: null, files: [] });
+    if (ws) { ensureSprite(); refresh(inst); }
+    draw(inst);
+    return;
+  }
+  // Coming back to Docs reads again (at most every few seconds): a file edited since shows its new signal.
+  if (Date.now() - (inst.readAt || 0) > REREAD_MS) refresh(inst);
+  if (!inst.last) draw(inst);
+}
+
+export function disposeDestination(host) {
+  const inst = insts.get(host);
+  if (!inst) return;
+  stopPoll(inst);
+  inst.seq++;
+  inst.root.remove();
+  insts.delete(host);
+}
+
+function stopPoll(inst) { if (inst.timer) { clearInterval(inst.timer); inst.timer = null; } }
+/** While a compare or a sync runs, read again every few seconds so its result lands without a reload; stop when it ends. */
+function pollWhileRunning(inst) {
+  const v = inst.view;
+  const running = v && (v.open || v.session || v.docs.some((d) => d.links.some((l) => l.syncing)));
+  if (running && !inst.timer) inst.timer = setInterval(() => refresh(inst), 4000);
+  if (!running) stopPoll(inst);
+}
+
+async function refresh(inst) {
+  const ws = inst.ws;
+  if (!ws) return;
+  const seq = ++inst.seq;
+  inst.readAt = Date.now();
+  const v = await pmGet('/api/docs?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; }
+  pollWhileRunning(inst);
+  draw(inst);
+}
+
+/** The repository's files that match the search and have no copy yet: what Add copy is offered on. */
+function searchFiles(inst) {
+  if (inst.ftimer) clearTimeout(inst.ftimer);
+  const q = inst.q.trim();
+  if (!q) { inst.files = []; return; }
+  inst.ftimer = setTimeout(async () => {
+    const seq = ++inst.fseq;
+    const r = await pmGet('/api/docs/files?ws=' + encodeURIComponent(inst.ws) + '&q=' + encodeURIComponent(q));
+    if (seq !== inst.fseq || q !== inst.q.trim()) return;
+    inst.files = (r && r.ok && r.files) || [];
+    draw(inst);
+  }, 200);
+}
+
+/* ── actions ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+async function compareAll(inst) {
+  inst.busy = true; draw(inst);
+  const r = await pmPost('/api/docs/check', { ws: inst.ws });
+  inst.busy = false;
+  if (r && r.ok) toast({ text: COPY.started, timeout: 4000 });
+  else toast({ text: (r && r.error) || 'The compare could not start.', tone: 'error' });
+  await refresh(inst);
+}
+
+/** Use one version over the other. Held for five seconds behind Undo; only then is the session asked for. */
+function useVersion(inst, doc, link, use) {
+  const key = keyOf(doc, link);
+  if (inst.pending.has(key)) return;
+  const L = link.label || LABEL[link.kind];
+  const p = { use, timer: null, toast: null };
+  p.timer = setTimeout(async () => {
+    inst.pending.delete(key);
+    const r = await pmPost('/api/docs/sync', { ws: inst.ws, path: doc.path, kind: link.kind, use });
+    if (!r || !r.ok) toast({ text: (r && r.error) || 'The sync could not start.', tone: 'error' });
+    await refresh(inst);
+  }, UNDO_MS);
+  p.toast = toast({ text: use === 'pmos' ? COPY.pushing(L) : COPY.pulling(L), actionLabel: COPY.undo, timeout: UNDO_MS,
+    onAction: () => { clearTimeout(p.timer); inst.pending.delete(key); draw(inst); toast({ text: COPY.cancelled, timeout: 3000 }); } });
+  inst.pending.set(key, p);
+  inst.open = null;
+  draw(inst);
+}
+
+async function stopTracking(inst, doc, link) {
+  const r = await pmPost('/api/docs/unlink', { ws: inst.ws, path: doc.path, kind: link.kind });
+  if (!r || !r.ok) { toast({ text: (r && r.error) || 'The copy is still tracked.', tone: 'error' }); return; }
+  inst.open = null;
+  toast({ text: COPY.stopped(link.label || LABEL[link.kind]), actionLabel: COPY.undo, timeout: 6000,
+    onAction: async () => { await pmPost('/api/docs/link', { ws: inst.ws, path: doc.path, kind: link.kind, target: link.target }); refresh(inst); } });
+  refresh(inst);
+}
+
+async function addCopy(inst, path, target, err) {
+  const kind = kindOf(target);
+  if (!kind) { err.textContent = COPY.badPaste; return; }
+  const r = await pmPost('/api/docs/link', { ws: inst.ws, path, kind, target });
+  if (!r || !r.ok) { err.textContent = (r && r.error) || 'The copy was not added.'; return; }
+  inst.adding = null;
+  inst.files = inst.files.filter((f) => f.path !== path);
+  toast({ text: COPY.added, timeout: 4000 });
+  refresh(inst);
+}
+
+/* ── lines ───────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function copyLine(inst, doc, link) {
+  const key = keyOf(doc, link);
+  const L = link.label || LABEL[link.kind];
+  const st = stateOf(inst, doc, link);
+  const open = inst.open === key;
+  const toggle = () => { inst.open = open ? null : key; draw(inst); };
+  let act = null;
+  if (st.btn === 'pmos' || st.btn === 'copy') {
+    act = button({ label: st.btn === 'pmos' ? COPY.usePmos : COPY.useCopy(L), variant: 'primary', size: 'sm',
+      attrs: { 'data-docs-act': 'use-' + st.btn, 'data-docs-key': key }, onClick: () => useVersion(inst, doc, link, st.btn) });
+  } else if (st.btn === 'choose') {
+    act = button({ label: COPY.choose, variant: 'outline', size: 'sm', attrs: { 'data-docs-act': 'choose', 'data-docs-key': key, 'aria-expanded': open ? 'true' : 'false' },
+      onClick: toggle });
+  }
+  const opener = link.url
+    ? el('a', { class: 'rp-docs-open', href: link.url, target: '_blank', rel: 'noopener noreferrer', 'data-docs-open': link.kind }, L + ' ↗')
+    : el('span', { class: 'rp-docs-open' }, L);
+  const line = row({
+    title: doc.title,
+    meta: [st.strong, st.rest].filter(Boolean),
+    lead: [el('span', { class: 'rp-docs-dot rp-docs-dot--' + st.dot, 'aria-hidden': 'true' })],
+    trail: [opener, act].filter(Boolean),
+    onOpen: toggle,
+    openLabel: `${doc.title}, ${L}: ${[st.strong, st.rest].filter(Boolean).join(', ')}`,
+    openAttrs: { 'aria-expanded': open ? 'true' : 'false', title: doc.path, 'data-docs-toggle': key },
+    attrs: { 'data-docs-line': key, 'data-docs-signal': link.signal, 'data-docs-kind': link.kind, 'data-docs-title': doc.title,
+      'data-docs-state': [st.strong, st.rest].filter(Boolean).join(' · ') },
+  });
+  const wrap = el('div', { class: 'rp-docs-row', role: 'listitem', 'data-docs-doc': doc.path }, line);
+  if (open) wrap.appendChild(details(inst, doc, link, st));
+  return wrap;
+}
+
+/** The details, on a click: where each side lives, its last edit, both choices, and the first difference the check saw. */
+function details(inst, doc, link, st) {
+  const L = link.label || LABEL[link.kind];
+  const can = !st.strong || !/^Updating/.test(st.strong);
+  const offer = can && ['ahead', 'behind', 'diverged'].includes(link.signal);
+  const pNew = link.signal === 'ahead';
+  const cNew = link.signal === 'behind';
+  const side = (name, where, last, isNew, use) => el('div', { class: 'rp-docs-side' + (isNew ? ' rp-docs-side--new' : ''), 'data-docs-side': use },
+    el('span', { class: 'rp-docs-side__label' }, name + (isNew ? ' · newer' : '')),
+    el('span', { class: 'rp-docs-side__where' }, where),
+    el('span', { class: 'rp-docs-side__edit' }, last ? 'Last edit: ' + last : 'Last edit: read at the next compare'),
+    offer ? button({ label: use === 'pmos' ? COPY.usePmos : COPY.useCopy(L), variant: isNew ? 'primary' : 'outline', size: 'sm',
+      attrs: { 'data-docs-act': 'use-' + use, 'data-docs-key': keyOf(doc, link) }, onClick: () => useVersion(inst, doc, link, use) }) : null);
+  const diff = link.note && link.signal !== 'same' && link.signal !== 'unchecked'
+    ? el('p', { class: 'rp-docs-diff', 'data-docs-diff': '' }, 'First difference: ' + link.note) : null;
+  return el('div', { class: 'rp-docs-detail', 'data-docs-detail': keyOf(doc, link) },
+    side('PMOS', doc.path, edit(doc.repo && doc.repo.modified_by, doc.repo && doc.repo.modified_at), pNew, 'pmos'),
+    side(L, link.target, edit(link.remote_modified_by, link.remote_modified_at), cNew, 'copy'),
+    diff,
+    el('div', { class: 'rp-docs-more' },
+      button({ label: COPY.compareAgain, variant: 'ghost', size: 'sm', disabled: !!(inst.view && (inst.view.open || inst.view.session)) || inst.busy,
+        attrs: { 'data-docs-act': 'compare-one' }, onClick: () => compareAll(inst) }),
+      button({ label: COPY.stop, variant: 'ghost', size: 'sm', attrs: { 'data-docs-act': 'stop', 'data-docs-key': keyOf(doc, link) },
+        onClick: () => stopTracking(inst, doc, link) })));
+}
+
+/** A file with no copy: "No copy" and Add copy, which opens a paste field in place. */
+function fileLine(inst, f) {
+  const start = () => { inst.adding = f.path; draw(inst); };
+  const adding = inst.adding === f.path;
+  const line = row({
+    title: f.title,
+    meta: [COPY.noCopy],
+    lead: [el('span', { class: 'rp-docs-dot rp-docs-dot--none', 'aria-hidden': 'true' })],
+    trail: adding ? [] : [button({ label: COPY.addCopy, variant: 'outline', size: 'sm', attrs: { 'data-docs-act': 'add-copy', 'data-docs-key': f.path }, onClick: start })],
+    attrs: { 'data-docs-file-line': f.path, title: f.path },
+  });
+  const wrap = el('div', { class: 'rp-docs-row', role: 'listitem', 'data-docs-file': f.path }, line);
+  if (!adding) return wrap;
+  const err = el('span', { class: 'rp-docs-add__err', role: 'alert' });
+  const inp = field({ label: `Copy of ${f.title}`, hideLabel: true, placeholder: COPY.paste, attrs: { 'data-docs-field': 'target' } });
+  inp.control.addEventListener('keydown', (e) => {
+    if (e.key === 'Enter') addCopy(inst, f.path, inp.control.value.trim(), err);
+    if (e.key === 'Escape') { inst.adding = null; draw(inst); }
+  });
+  setTimeout(() => inp.control.focus(), 0);
+  wrap.appendChild(el('div', { class: 'rp-docs-add' }, el('div', { class: 'rp-docs-add__input' }, inp),
+    button({ label: COPY.add, variant: 'primary', size: 'sm', attrs: { 'data-docs-act': 'add-save' }, onClick: () => addCopy(inst, f.path, inp.control.value.trim(), err) }),
+    button({ label: COPY.cancel, variant: 'ghost', size: 'sm', onClick: () => { inst.adding = null; draw(inst); } }),
+    err));
+  return wrap;
+}
+
+/* ── the page ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function header(inst) {
+  if (inst.head) return inst.head;
+  const find = field({ label: COPY.find, hideLabel: true, placeholder: COPY.find, attrs: { 'data-docs-find': '' } });
+  const q = find.control;
+  q.addEventListener('input', () => { inst.q = q.value; inst.open = null; inst.adding = null; searchFiles(inst); draw(inst); });
+  // The field restores its last committed text on Escape; here Escape clears the search instead.
+  q.addEventListener('keydown', (e) => { if (e.key === 'Escape') { q.resetCommitted(''); inst.q = ''; searchFiles(inst); draw(inst); } });
+  inst.head = el('div', { class: 'rp-docs-top' }, el('h2', { class: 'rp-head__title' }, COPY.title), el('div', { class: 'rp-docs-find' }, find));
+  return inst.head;
+}
+
+function grouped(inst, docs) {
+  const by = new Map();
+  for (const d of docs) {
+    const k = d.initiative ? d.initiative.id : '';
+    if (!by.has(k)) by.set(k, { title: d.initiative ? d.initiative.title : COPY.other, docs: [] });
+    by.get(k).docs.push(d);
+  }
+  return [...by.entries()].sort((a, b) => (a[0] === '') - (b[0] === '')).map(([k, g]) =>
+    el('section', { class: 'rp-docs-group', 'data-docs-group': k || 'other' },
+      el('h3', { class: 'rp-docs-group__title' }, g.title),
+      el('div', { role: 'list' }, g.docs.flatMap((d) => d.links.map((l) => copyLine(inst, d, l))))));
+}
+
+function body(inst) {
+  const v = inst.view;
+  const q = inst.q.trim().toLowerCase();
+  if (q) {
+    const hits = v.docs.filter((d) => [d.title, d.path, d.initiative ? d.initiative.title : ''].join(' ').toLowerCase().includes(q));
+    const rows = [...hits.flatMap((d) => d.links.map((l) => copyLine(inst, d, l))), ...inst.files.map((f) => fileLine(inst, f))];
+    return rows.length ? [el('div', { role: 'list', class: 'rp-docs-group', 'data-docs-results': '' }, rows)] : [el('p', { class: 'rp-section__empty' }, COPY.noMatch(inst.q.trim()))];
+  }
+  const all = v.docs.reduce((n, d) => n + d.links.length, 0);
+  const needs = v.docs.reduce((n, d) => n + d.links.filter((l) => l.signal !== 'same' || l.syncing).length, 0);
+  const running = !!(v.open || v.session) || inst.busy;
+  const out = [el('div', { class: 'rp-docs-views' },
+    tabs({ variant: 'line', items: [{ id: 'needs', label: COPY.needs, count: needs }, { id: 'all', label: COPY.all, count: all }],
+      value: inst.filter, ariaLabel: 'Filter', attrs: { 'data-docs-filter': '' }, onChange: (val) => { inst.filter = val; draw(inst); } }),
+    el('span', { class: 'rp-docs-when', 'data-docs-summary': '' },
+      running ? COPY.comparing : (v.last ? COPY.compared(v.last.finished_at) : COPY.never),
+      button({ label: '↻', variant: 'ghost', size: 'sm', disabled: running || !all,
+        attrs: { 'data-docs-act': 'check', 'aria-label': COPY.compareAll, title: COPY.compareAll }, onClick: () => compareAll(inst) })))];
+  if (!v.docs.length) { out.push(el('p', { class: 'rp-section__empty' }, COPY.none)); return out; }
+  const shown = inst.filter === 'needs'
+    ? v.docs.map((d) => ({ ...d, links: d.links.filter((l) => l.signal !== 'same' || l.syncing || inst.pending.has(keyOf(d, l))) })).filter((d) => d.links.length)
+    : v.docs;
+  if (!shown.length) { out.push(el('p', { class: 'rp-section__empty' }, COPY.nothingNeeds)); return out; }
+  out.push(...grouped(inst, shown));
+  return out;
+}
+
+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.filter, inst.busy, inst.q, inst.files, inst.open, inst.adding, [...inst.pending.keys()]]);
+  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; }
+  inst.body.replaceChildren(...body(inst));
+}

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

@@ -125,7 +125,10 @@ function build(ctx0) {
   // the open day takes the list into its left column ("Also waiting for you"), so Today shows one layout; a folded day
   // leaves it below, as before
   const owed = { list, more, count: n };
-  const day = daySection({ ws: dayWs, setState: ctx0.setState || setState, openIni: dayRepo ? (id) => openInitiative(dayRepo, id) : null, owed });
+  // one day for every repository: the day is the same everywhere; the Show switch narrows it to the repository Today
+  // was opened from (`here`) or shows all of it
+  const here = sc.repo ? wsOf(sc.repo) : null;
+  const day = daySection({ ws: dayWs, setState: ctx0.setState || setState, openIni: dayRepo ? (id) => openInitiative(dayRepo, id) : null, owed, here, all: sc.all });
   const inDay = !!(day && day.contains(list));
   return { children: inDay ? [head, day, health] : [head, day, health, list, more], sig: JSON.stringify([sc.all, sc.repo, n, ready, expanded, banner]) + daySig(dayWs) + nodes.map((x) => x.outerHTML).join('') };
 }

package/workspace/public/pm/registry.js

@@ -48,6 +48,8 @@ export const DESTINATIONS = Object.freeze([
   Object.freeze({ id: 'initiatives', label: 'Initiatives', key: 'g i', module: 'dest-initiatives.js', run: 2 }),
   Object.freeze({ id: 'board', label: 'Board', key: 'g b', module: 'dest-board.js', run: 4 }),
   Object.freeze({ id: 'reports', label: 'Reports', key: 'g r', module: 'dest-reports.js', run: 5 }),
+  // Not a pm-os-absorb run (run: null): docs-three-way-sync added it — is each linked document the same as its copies.
+  Object.freeze({ id: 'docs', label: 'Docs', key: 'g d', module: 'dest-docs.js', run: null }),
   Object.freeze({ id: 'settings', label: 'Settings', key: null, module: 'dest-settings.js', run: 3 }),
 ]);
 export const EXTENSIONS = Object.freeze([

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

@@ -133,6 +133,11 @@ export const COPY = {
       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.` },
     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.',