create-pmos 0.51.0 → 0.53.0

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

@@ -0,0 +1,270 @@
+/* pm/dest-reports.js — the Reports destination (pm-os-absorb Run 5, slice 5C; PRD R9, R22.5, R25, R29).
+ *
+ * A DESTINATION MODULE (registry.js): mountDestination(host, ctx) on every render with the same host, disposeDestination(host).
+ * It keeps ONE persistent root per host and rebuilds it only when its own data changed.
+ *
+ * What it shows, for the repository the tab names (or the open one):
+ *   - the report schedules of that repository, joined to their report by the schedule's `skill` (report-biweekly →
+ *     biweekly), never by its cadence; Pause and Resume write through the schedules route; one press sets the recommended
+ *     schedules up; the schedules that feed no report are one disclosure, "Other schedules (n)";
+ *   - the reports, newest first: the 4 newest, and "Show older";
+ *   - the selected report, read from its file: Edit notes, Redraft, Issue, and for an issued report Print / PDF and Copy as
+ *     markdown. Issue is the PM's act and takes 2 taps (report-view.js openIssueSheet).
+ * Nothing here sends a report anywhere. The writes go through /api/report/* (lib/routes-reports.js), which calls the guards.
+ *
+ * It reads /api/report and /api/schedules?all=1 once, then again when its own `sig` changes (sig-watch.js, seams §4.9) or
+ * after its own writes. In fixture mode it reads nothing and starts no watcher.
+ */
+
+import { el } from './dom.js';
+import { button, iconButton, row, signal, menu, toast, empty, ensureComponentsCss } from './primitives.js';
+import { ensureSprite } from './icons.js';
+import { pmGet, pmPost } from './http.js';
+import { watchSig } from './sig-watch.js';
+import { wsOf } from './data.js';
+import { COPY, cadenceName } from './reports-copy.js';
+import { renderReport, openIssueSheet, openNotesSheet, draftNow, printReport, copyMarkdown, clearPrint, ensurePrintCss } from './report-view.js';
+
+const SHOWN = 4;                                      // the reports listed before "Show older"
+const insts = new WeakMap();                          // host -> instance
+
+/** report-biweekly -> biweekly. The same join as lib/report-needs.js cadenceOfSkill. */
+const cadenceOfSkill = (skill) => { const m = /^report-([a-z][a-z0-9-]{0,39})$/.exec(String(skill || '')); return m ? m[1] : null; };
+const keyOf = (r) => r.cadence + ':' + r.slot;
+
+function whenOf(s) {
+  const c = String(s.cadence || '');
+  const on = c === 'weekly' || c === 'bi-weekly' || c === 'biweekly' ? s.day : c === 'monthly' && s.dayOfMonth ? 'day ' + s.dayOfMonth : '';
+  return [c, on, s.time].filter(Boolean).join(' ');
+}
+
+function make(host) {
+  const root = el('div', { class: 'rp-page', 'data-reports': '' });
+  const inst = {
+    host, root, ws: null, loaded: false, error: null, reports: [], flags: [], sig: null, schedules: [], doc: null, docKey: null,
+    sel: null, showAll: false, otherOpen: false, stop: null, seq: 0, last: '',
+  };
+  return inst;
+}
+
+export function mountDestination(host, ctx) {
+  let inst = insts.get(host);
+  if (!inst) { inst = make(host); 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) {
+    if (inst.stop) { inst.stop(); inst.stop = null; }
+    Object.assign(inst, { ws, loaded: false, error: null, reports: [], flags: [], sig: null, schedules: [], doc: null, docKey: null, sel: null, showAll: false, last: '' });
+    if (ws) {
+      ensureSprite();
+      ensurePrintCss();
+      inst.stop = watchSig(() => pmGet('/api/report?ws=' + encodeURIComponent(ws)).then((j) => (j && j.ok ? j.sig : null)), () => refresh(inst));
+      refresh(inst);
+    }
+    draw(inst);
+    return;
+  }
+  if (!inst.last) draw(inst);
+}
+
+export function disposeDestination(host) {
+  const inst = insts.get(host);
+  if (!inst) return;
+  if (inst.stop) inst.stop();
+  inst.stop = null; inst.seq++;
+  clearPrint();
+  inst.root.remove();
+  insts.delete(host);
+}
+
+/* ── reads ────────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** Read the list and the schedules, then the selected report; draw only when something changed. */
+async function refresh(inst) {
+  const ws = inst.ws;
+  if (!ws) return;
+  const seq = ++inst.seq;
+  const [list, sched] = await Promise.all([pmGet('/api/report?ws=' + encodeURIComponent(ws)), pmGet('/api/schedules?all=1')]);
+  if (seq !== inst.seq || ws !== inst.ws) return;
+  inst.loaded = true;
+  if (!list || list.ok === false) { inst.error = (list && list.error) || COPY.readError; inst.reports = []; }
+  else { inst.error = null; inst.reports = list.reports || []; inst.flags = list.flags || []; inst.sig = list.sig; }
+  inst.schedules = sched && Array.isArray(sched.schedules) ? sched.schedules.filter((s) => s && s.ws === ws) : [];
+  const keys = inst.reports.map(keyOf);
+  if (!inst.sel || !keys.includes(inst.sel)) inst.sel = keys[0] || null;
+  await readDoc(inst, seq);
+  if (seq === inst.seq) draw(inst);
+}
+
+async function readDoc(inst, seq) {
+  const r = inst.reports.find((x) => keyOf(x) === inst.sel);
+  if (!r) { inst.doc = null; inst.docKey = null; return; }
+  const out = await pmGet('/api/report/draft?ws=' + encodeURIComponent(inst.ws) + '&cadence=' + encodeURIComponent(r.cadence) + '&slot=' + encodeURIComponent(r.slot));
+  if (seq !== inst.seq) return;
+  inst.doc = out && out.ok && out.exists ? out : null;
+  inst.docKey = inst.doc ? inst.sel : null;
+}
+
+const selectReport = async (inst, key) => {
+  inst.sel = key; inst.doc = null; inst.docKey = null;
+  draw(inst);
+  const seq = ++inst.seq;
+  await readDoc(inst, seq);
+  if (seq === inst.seq) draw(inst);
+};
+
+/* ── the page ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const selected = (inst) => inst.reports.find((x) => keyOf(x) === inst.sel) || null;
+/** A report that is not issued can still be read, noted and issued, whoever wrote it (X36). */
+const isDraft = (r) => !!r && !r.issued;
+
+/** Which cadence "Draft now" writes: the selected report's, else the first report schedule's, else biweekly. */
+function draftCadence(inst) {
+  const r = selected(inst);
+  if (r) return r.cadence;
+  const s = inst.schedules.map((x) => cadenceOfSkill(x.skill)).find(Boolean);
+  return s || 'biweekly';
+}
+const knownCadences = (inst) => [...new Set([...inst.reports.map((r) => r.cadence), ...inst.schedules.map((s) => cadenceOfSkill(s.skill)).filter(Boolean)])].sort();
+
+async function afterDraft(inst, r) {
+  if (r && r.ok && r.slot) inst.sel = (r.cadence || draftCadence(inst)) + ':' + r.slot;
+  await refresh(inst);
+}
+
+function primaryAction(inst) {
+  const r = selected(inst);
+  if (isDraft(r)) {
+    return button({ label: COPY.issue, variant: 'primary', attrs: { 'data-rp-act': 'issue', 'data-rp-key': 'primary' },
+      onClick: () => openIssueSheet({ ws: inst.ws, cadence: r.cadence, slot: r.slot, onDone: () => refresh(inst) }) });
+  }
+  const cadence = draftCadence(inst);
+  return button({ label: COPY.draftNow, variant: 'primary', attrs: { 'data-rp-act': 'draft-now', 'data-rp-key': 'primary' },
+    onClick: async () => afterDraft(inst, await draftNow({ ws: inst.ws, cadence })) });
+}
+
+/* the schedules, split by what they feed */
+function schedulesBlock(inst) {
+  const feeds = inst.schedules.filter((s) => cadenceOfSkill(s.skill));
+  const others = inst.schedules.filter((s) => !cadenceOfSkill(s.skill));
+  const sec = el('section', { class: 'rp-section', 'data-rp-section': 'schedules', 'aria-label': COPY.schedulesTitle }, el('h3', { class: 'rp-section__title' }, COPY.schedulesTitle));
+  if (!feeds.length) {
+    sec.appendChild(el('p', { class: 'rp-section__empty' }, COPY.schedulesNone));
+    sec.appendChild(button({ label: COPY.schedulesSeed, variant: 'outline', size: 'sm', attrs: { 'data-rp-act': 'seed', 'data-rp-key': 'seed' }, onClick: async () => {
+      const r = await pmPost('/api/schedules/seed', { ws: inst.ws, set: 'reports' });
+      if (r && r.ok) toast({ text: COPY.schedulesSeeded((r.created || []).length), timeout: 4000 }); else toast({ text: COPY.schedulesFailed + (r && r.error ? ' ' + r.error : ''), tone: 'error' });
+      await refresh(inst);
+    } }));
+  }
+  const list = el('div', { class: 'rp-list', role: 'list' });
+  for (const s of feeds) {
+    const on = s.enabled !== false;
+    const cadence = cadenceOfSkill(s.skill);
+    list.appendChild(row({
+      title: s.name || cadenceName(cadence),
+      meta: [COPY.scheduleMeta(whenOf(s), s.lastRun ? COPY.lastRan(s.lastRun) : COPY.neverRan)],
+      signals: on ? [] : [signal({ text: COPY.paused, tone: 'warning' })],
+      trail: [button({ label: on ? COPY.pause : COPY.resume, variant: 'outline', size: 'sm', attrs: { 'data-rp-act': on ? 'pause' : 'resume', 'data-rp-key': 'sched:' + s.id }, onClick: async () => {
+        const r = await pmPost('/api/schedules/update', { id: s.id, enabled: !on });
+        if (!r || !r.ok) { toast({ text: COPY.schedulesFailed + (r && r.error ? ' ' + r.error : ''), tone: 'error' }); }
+        await refresh(inst);
+      } })],
+      attrs: { 'data-schedule': s.id, 'data-cadence': cadence, role: 'listitem' },
+    }));
+  }
+  if (feeds.length) sec.appendChild(list);
+  if (others.length) {
+    sec.appendChild(button({ label: COPY.otherSchedules(others.length), variant: 'ghost', size: 'sm', icon: inst.otherOpen ? 'chevron-down' : 'chevron-right',
+      attrs: { 'data-rp-act': 'other', 'data-rp-key': 'other', 'aria-expanded': inst.otherOpen ? 'true' : 'false' }, onClick: () => { inst.otherOpen = !inst.otherOpen; draw(inst); } }));
+    if (inst.otherOpen) {
+      sec.appendChild(el('div', { class: 'rp-list', role: 'list', 'data-rp-section': 'other-schedules' }, others.map((s) => row({
+        title: s.name || s.skill, meta: [COPY.scheduleMeta(whenOf(s), s.lastRun ? COPY.lastRan(s.lastRun) : COPY.neverRan)],
+        signals: s.enabled === false ? [signal({ text: COPY.paused, tone: 'warning' })] : [], attrs: { 'data-schedule': s.id, role: 'listitem' } }))));
+    }
+  }
+  return sec;
+}
+
+/* the reports, newest first */
+function listBlock(inst) {
+  const sec = el('section', { class: 'rp-section', 'data-rp-section': 'list', 'aria-label': COPY.list }, el('h3', { class: 'rp-section__title' }, COPY.list));
+  if (!inst.reports.length) { sec.appendChild(el('p', { class: 'rp-section__empty' }, COPY.none)); return sec; }
+  const shown = inst.showAll ? inst.reports : inst.reports.slice(0, SHOWN);
+  // the selected report stays on screen even when it is older than the shown ones
+  const sel = selected(inst);
+  const rows = sel && !shown.includes(sel) ? [...shown, sel] : shown;
+  const list = el('div', { class: 'rp-list', role: 'list' });
+  for (const r of rows) {
+    const key = keyOf(r);
+    list.appendChild(row({
+      title: COPY.rowTitle(r.cadence, r.slot),
+      meta: [r.issued ? COPY.issued(r.issued.at, r.issued.by) : COPY.draft],
+      signals: r.edited ? [signal({ text: COPY.edited, tone: 'warning', title: COPY.editedWhy })] : [],
+      owed: isDraft(r),
+      onOpen: () => selectReport(inst, key),
+      openAttrs: { 'aria-current': key === inst.sel ? 'true' : null, 'data-rp-key': 'row:' + key },
+      attrs: { class: key === inst.sel ? 'rp-list__row rp-list__row--on' : 'rp-list__row', 'data-report': key, 'data-status': r.issued ? 'issued' : 'draft', role: 'listitem' },
+    }));
+  }
+  sec.appendChild(list);
+  if (inst.reports.length > SHOWN) {
+    sec.appendChild(button({ label: inst.showAll ? COPY.showFewer : COPY.showOlder(inst.reports.length - SHOWN), variant: 'ghost', size: 'sm',
+      icon: inst.showAll ? 'chevron-down' : 'chevron-right', attrs: { 'data-rp-act': 'older', 'data-rp-key': 'older' }, onClick: () => { inst.showAll = !inst.showAll; draw(inst); } }));
+  }
+  return sec;
+}
+
+/* the selected report and what can be done to it */
+function viewerBlock(inst) {
+  const r = selected(inst);
+  const sec = el('section', { class: 'rp-section rp-viewer', 'data-rp-section': 'viewer', 'aria-label': r ? COPY.reportName(r.cadence, r.slot) : COPY.title });
+  if (!r) return sec;
+  const doc = inst.doc && inst.docKey === inst.sel ? inst.doc : null;
+  const bar = el('div', { class: 'rp-toolbar', role: 'toolbar', 'aria-label': COPY.reportName(r.cadence, r.slot) });
+  bar.appendChild(el('h3', { class: 'rp-section__title rp-toolbar__title' }, COPY.reportName(r.cadence, r.slot)));
+  const acts = el('div', { class: 'rp-toolbar__acts' });
+  if (r.issued) {
+    acts.appendChild(button({ label: COPY.print, variant: 'outline', size: 'sm', attrs: { 'data-rp-act': 'print', 'data-rp-key': 'print' }, disabled: !doc, onClick: () => doc && printReport(doc.markdown) }));
+    acts.appendChild(button({ label: COPY.copyMd, variant: 'outline', size: 'sm', attrs: { 'data-rp-act': 'copy', 'data-rp-key': 'copy' }, disabled: !doc, onClick: () => doc && copyMarkdown(doc.markdown) }));
+  } else {
+    acts.appendChild(button({ label: COPY.editNotes, variant: 'outline', size: 'sm', attrs: { 'data-rp-act': 'notes', 'data-rp-key': 'notes' }, disabled: !doc,
+      onClick: () => doc && openNotesSheet({ ws: inst.ws, cadence: r.cadence, slot: r.slot, markdown: doc.markdown, onSaved: () => refresh(inst) }) }));
+    acts.appendChild(button({ label: COPY.redraft, variant: 'outline', size: 'sm', attrs: { 'data-rp-act': 'redraft', 'data-rp-key': 'redraft' },
+      onClick: async () => afterDraft(inst, await draftNow({ ws: inst.ws, cadence: r.cadence, slot: r.slot, redraft: true })) }));
+    const more = iconButton({ icon: 'ellipsis', ariaLabel: COPY.more, expanded: false, size: 'sm', attrs: { 'data-rp-act': 'more', 'data-rp-key': 'more' }, onClick: (e) => {
+      const items = [{ label: COPY.draftNow, onSelect: async () => afterDraft(inst, await draftNow({ ws: inst.ws, cadence: r.cadence })) }];
+      for (const c of knownCadences(inst)) if (c !== r.cadence) items.push({ label: COPY.draftNow + ' · ' + c, onSelect: async () => afterDraft(inst, await draftNow({ ws: inst.ws, cadence: c })) });
+      items.push({ sep: true }, { label: COPY.print, onSelect: () => doc && printReport(doc.markdown) }, { label: COPY.copyMd, onSelect: () => doc && copyMarkdown(doc.markdown) });
+      menu({ anchor: e.currentTarget, items, ariaLabel: COPY.more });
+    } });
+    acts.appendChild(more);
+  }
+  bar.appendChild(acts);
+  sec.appendChild(bar);
+  if (r.issued) sec.appendChild(el('p', { class: 'rp-viewer__state' }, r.edited ? COPY.editedWhy : COPY.frozen));
+  sec.appendChild(doc ? renderReport(doc.markdown) : el('p', { class: 'rp-section__empty' }, COPY.loading));
+  return sec;
+}
+
+/** Rebuild the persistent root from the instance, if what it shows changed; keep the focus on the same control. */
+function draw(inst) {
+  const root = inst.root;
+  if (!inst.ws) { root.replaceChildren(empty({ text: COPY.noRepo })); inst.last = 'none'; return; }
+  const fingerprint = JSON.stringify([inst.loaded, inst.error, inst.reports, inst.flags, inst.schedules, inst.sel, inst.doc && inst.doc.sha, inst.showAll, inst.otherOpen]);
+  if (fingerprint === inst.last && root.childNodes.length) return;
+  inst.last = fingerprint;
+  const keep = document.activeElement && root.contains(document.activeElement) ? document.activeElement.getAttribute('data-rp-key') : null;
+  const scroll = root.querySelector('.rp-viewer') ? root.scrollTop : 0;
+  if (!inst.loaded) { root.replaceChildren(el('p', { class: 'rp-section__empty' }, COPY.loading)); return; }
+  const kids = [el('div', { class: 'rp-head' }, el('h2', { class: 'rp-head__title' }, COPY.title), inst.error ? null : primaryAction(inst))];
+  if (inst.error) kids.push(el('p', { class: 'rp-section__empty rp-section__empty--bad', role: 'alert' }, inst.error));
+  if (inst.flags && inst.flags.length) kids.push(el('p', { class: 'rp-flag' }, signal({ text: COPY.flagTitle, tone: 'warning', title: inst.flags[0].why })));
+  if (!inst.error) kids.push(el('div', { class: 'rp-cols' }, el('div', { class: 'rp-col rp-col--list' }, schedulesBlock(inst), listBlock(inst)), el('div', { class: 'rp-col rp-col--doc' }, viewerBlock(inst))));
+  root.replaceChildren(...kids.filter(Boolean));
+  root.scrollTop = scroll;
+  if (keep) { const again = root.querySelector('[data-rp-key="' + keep.replace(/"/g, '') + '"]'); if (again && !again.disabled) again.focus({ preventScroll: true }); }
+}

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

@@ -0,0 +1,217 @@
+/* pm/dest-settings.js — the Settings destination, the frame's ⚙ (pm-os-absorb Run 3, slice 3A; PRD R9).
+ *
+ * Settings holds settings only, in five 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)
+ *   Theme              Dark or Light
+ * The work itself (what needs you, initiatives, items, reports) is never here.
+ *
+ * The mount contract (registry.js): mountDestination(host, ctx) is called on every render with the same host. The page
+ * keeps one root per host and rebuilds it only when what it shows changed, and never while the PM types in it, so a
+ * focused control keeps its focus across the workspace's polls.
+ */
+
+import { el, setChildren } from './dom.js';
+import { state, setState, FIXTURE } from './state.js';
+import { pmGet, pmPost } from './http.js';
+import { button, iconButton, field, badge, row, tabs, menu, empty } from './primitives.js';
+import { repoTuples, activeProduct, renameRepo, removeRepo } from './panel-repos.js';
+import { repoRow } from './fixture.js';
+import { sessionDefaults, setSessionDefaults } from './dock.js';
+import { COPY } from './frame-copy.js';
+
+const P = COPY.page;
+const roots = new WeakMap();      // host -> { root, sig }
+const consentByWs = new Map();    // ws -> { on: boolean | null, error, at, pending }
+let addOpen = false;
+let addMod = null;
+
+const frame = () => (window.pmApp && window.pmApp.frame) || null;
+const dataMod = () => (window.pmApp && window.pmApp.mods && window.pmApp.mods.data) || null;
+const wsOfRepo = (name) => { const d = dataMod(); return name && d && typeof d.wsOf === 'function' ? d.wsOf(name) : null; };
+
+function readConsent(ws) {
+  if (!ws || FIXTURE) return;
+  const have = consentByWs.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 };
+  consentByWs.set(ws, entry);
+  pmGet('/api/validate/repo?ws=' + encodeURIComponent(ws)).then((j) => {
+    entry.pending = false; entry.at = Date.now();
+    if (j && j.ok !== false) { entry.on = !!j.consent; entry.error = null; } else entry.error = (j && j.error) || P.validateUnread;
+    setState({});
+  });
+}
+
+async function setConsent(ws, on) {
+  const j = await pmPost('/api/validate/repo', { ws, consent: on });
+  consentByWs.set(ws, { on: j && j.ok !== false ? !!j.consent : null, error: j && j.ok !== false ? null : ((j && j.error) || P.validateUnread), at: Date.now() });
+  setState({});
+}
+
+const section = (id, title, kids, action) => el('section', { class: 'fr-set__section', 'data-fr-section': id },
+  el('div', { class: 'fr-set__head' }, el('h2', { class: 'fr-set__title' }, title), action || null),
+  kids);
+
+/* ── the five sections ──────────────────────────────────────────────────────────────────────────────────────────── */
+
+function reposSection(scope) {
+  const tuples = repoTuples();
+  const current = scope === 'all' ? null : activeProduct(tuples);
+  const rows = tuples.map((t) => {
+    const rp = repoRow(t);
+    const on = rp.name === current;
+    const use = () => { const f = frame(); if (f) f.chooseRepo(rp.name); };
+    const more = iconButton({
+      icon: 'ellipsis', ariaLabel: P.more(rp.name), attrs: { 'data-fr': 'repo-more' },
+      onClick: () => menu({
+        anchor: more, ariaLabel: P.more(rp.name),
+        items: [
+          { label: P.use, onSelect: use },
+          { label: P.show, onSelect: () => { use(); const f = frame(); if (f) f.go('initiatives'); } },
+          { label: P.rename, onSelect: () => renameRepo(rp.name) },
+          { label: P.remove, onSelect: () => removeRepo(rp.name) },
+        ],
+      }),
+    });
+    return row({
+      title: rp.name, meta: [rp.kindLabel], signals: on ? [badge({ text: P.current, tone: 'outline' })] : [],
+      onOpen: use, openLabel: P.use + ': ' + rp.name, trail: [more],
+      attrs: { 'data-fr-row': 'repo', 'data-repo': rp.name, 'data-current': on ? 'true' : 'false' },
+    });
+  });
+  const add = button({
+    label: addOpen ? P.addClose : P.add, variant: 'outline', size: 'sm', icon: addOpen ? 'x' : 'plus',
+    attrs: { 'data-fr': 'add-repo', 'aria-expanded': addOpen ? 'true' : 'false' },
+    onClick: () => { addOpen = !addOpen; if (addOpen && !addMod) loadAdd(); setState({}); },
+  });
+  const kids = rows.length ? rows : [empty({ text: P.reposEmpty })];
+  if (addOpen) kids.push(addBoard());
+  return section('repositories', P.repos, kids, add);
+}
+
+function loadAdd() {
+  import('./view-addrepo.js').then((m) => { addMod = m; setState({}); }).catch(() => { addMod = false; setState({}); });
+}
+
+/** The existing add-repository board, drawn in place: the same form, scan review and confirm as the old tab. */
+function addBoard() {
+  const host = el('div', { class: 'fr-set__add', 'data-fr': 'add-board' });
+  if (!addMod || typeof addMod.renderBoard !== 'function') return host;
+  const cockpit = window.pmApp && window.pmApp.mods ? window.pmApp.mods.cockpit : null;
+  try {
+    addMod.renderBoard(host, {
+      tab: { id: 'settings:addrepo', kind: 'view', view: 'addrepo' }, view: 'addrepo', renderMode: () => {}, ready: true,
+      el, setChildren, state, setState, FIXTURE, openView: cockpit ? cockpit.openView : () => {}, repo: state.product || null,
+    });
+  } catch (e) { console.error('[pm] Add repository failed:', e); }
+  return host;
+}
+
+function profilesSection() {
+  const open = () => setState({ detail: { kind: 'prof' }, col2: true });
+  // every row has its ⋯, here as on the repositories: on a phone it is the one control a row is known by
+  const more = iconButton({
+    icon: 'ellipsis', ariaLabel: P.more(P.profilesRow), attrs: { 'data-fr': 'profiles-more' },
+    onClick: () => menu({ anchor: more, ariaLabel: P.more(P.profilesRow), items: [{ label: P.profilesOpen, onSelect: open }] }),
+  });
+  return section('profiles', P.profiles, [row({
+    title: P.profilesRow, meta: [P.profilesMeta], onOpen: open, openLabel: P.profilesOpen, trail: [more],
+    attrs: { 'data-fr-row': 'profiles' },
+  })]);
+}
+
+function sessionsSection() {
+  const d = sessionDefaults();
+  const cli = field({
+    label: P.cli, kind: 'select', value: d.cli,
+    options: [{ value: 'shell', label: P.cliShell }, { value: 'claude', label: P.cliClaude }],
+    onCommit: (v) => { setSessionDefaults({ cli: v }); setState({}); },
+    attrs: { 'data-fr': 'default-cli' },
+  });
+  const model = field({
+    label: P.model, kind: 'select', value: d.tier,
+    options: [['auto', P.modelAuto], ['fast', P.modelFast], ['balanced', P.modelBalanced], ['deep', P.modelDeep]].map(([value, label]) => ({ value, label })),
+    onCommit: (v) => { setSessionDefaults({ tier: v }); setState({}); },
+    attrs: { 'data-fr': 'default-model' },
+  });
+  return section('sessions', P.sessions, [el('div', { class: 'fr-set__fields' }, cli, model), el('p', { class: 'fr-set__note' }, P.sessionsNote)]);
+}
+
+function validateSection(scope) {
+  const repo = scope === 'all' ? null : activeProduct();
+  const ws = wsOfRepo(repo);
+  if (!ws) return section('validate', P.validate, [empty({ text: P.validateNoRepo })]);
+  readConsent(ws);
+  const c = consentByWs.get(ws) || {};
+  const known = c.on === true || c.on === false;
+  const line = c.error ? P.validateUnread : !known ? '' : c.on ? P.validateOn : P.validateOff;
+  const toggle = known ? button({
+    label: c.on ? P.turnOff : P.turnOn, variant: 'outline', size: 'sm',
+    attrs: { 'data-fr': 'consent-toggle' }, onClick: () => setConsent(ws, !c.on),
+  }) : null;
+  // Validate itself is a tool, not a place: it opens as a tab in the dock, from here only
+  const open = button({
+    label: P.validateOpen, variant: 'outline', size: 'sm', attrs: { 'data-fr': 'open-validate' },
+    onClick: () => {
+      const cockpit = window.pmApp && window.pmApp.mods ? window.pmApp.mods.cockpit : null;
+      if (cockpit && typeof cockpit.openView === 'function') cockpit.openView('validate');
+      const f = frame(); if (f) f.openDock();
+    },
+  });
+  return section('validate', P.validate, [el('div', { class: 'fr-set__line' },
+    el('span', { 'data-fr': 'consent-state', 'data-on': known ? String(c.on) : 'unread' }, line), toggle, open)]);
+}
+
+function themeSection() {
+  return section('theme', P.theme, [tabs({
+    variant: 'segmented', role: 'radiogroup', ariaLabel: P.theme, value: state.theme,
+    items: [{ id: 'dark', label: P.dark }, { id: 'light', label: P.light }],
+    onChange: (id) => setState({ theme: id }),
+    attrs: { 'data-fr': 'theme' },
+  })]);
+}
+
+/* ── mount ────────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function signature(scope) {
+  const ws = wsOfRepo(scope === 'all' ? null : activeProduct());
+  const addKeys = addOpen ? Object.keys(state).filter((k) => /^add[A-Z]/.test(k)).sort().map((k) => [k, state[k]]) : null;
+  let add = '';
+  try { add = JSON.stringify(addKeys); } catch { add = String(Date.now()); }
+  return JSON.stringify([repoTuples(), activeProduct(), scope, state.theme, sessionDefaults(), ws, consentByWs.get(ws) || null, addOpen, !!addMod]) + add;
+}
+
+/** True while the PM is typing in the page or a menu of it is open: a rebuild then would take the focus away. */
+function busy(root) {
+  const a = document.activeElement;
+  return !!a && root.contains(a) && /^(INPUT|TEXTAREA|SELECT)$/.test(a.tagName);
+}
+
+export function mountDestination(host, ctx) {
+  const scope = ctx && ctx.tab && ctx.tab.scope === 'all' ? 'all' : 'repo';
+  let r = roots.get(host);
+  if (!r) {
+    r = { root: el('div', { class: 'fr-set', 'data-fr': 'settings' }), sig: null };
+    roots.set(host, r);
+  }
+  if (r.root.parentNode !== host) setChildren(host, [r.root]);
+  const sig = signature(scope);
+  if (sig === r.sig || busy(r.root)) return;
+  r.sig = sig;
+  setChildren(r.root, [
+    el('header', { class: 'fr-set__intro' }, el('h1', { class: 'fr-set__h1' }, P.title), el('p', { class: 'fr-set__note' }, P.intro)),
+    reposSection(scope),
+    profilesSection(),
+    sessionsSection(),
+    validateSection(scope),
+    themeSection(),
+  ]);
+}
+
+export function disposeDestination(host) {
+  roots.delete(host);
+}