create-pmos 0.52.0 → 0.53.1

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

@@ -0,0 +1,74 @@
+/* pm/new-initiative-sheet.js — the New-initiative form (pm-os-absorb Run 2, slice 2D; PRD R17, R25).
+ *
+ * Title, Lane, Anchor, Add. An initiative with no anchor is refused here, before any request, and again by the server.
+ * The new initiative starts in Later: only the PM's press moves it into Now. The anchors on offer are the ones the List
+ * already shows (a KR or a `health:<id>`), plus one typed by hand.
+ *
+ *   openNewInitiative({ repo, ws, anchors: string[], prefill?: { title, lane, from }, onAdded(id) })
+ *   `prefill` is a triaged capture that still needs an anchor: the title and the lane are filled in, and `from` names the capture.
+ */
+
+import { el } from './dom.js';
+import { button, field, sheet, toast, ensureComponentsCss } from './primitives.js';
+import { repoLanes, repoProfile } from './data.js';
+import { COPY } from './initiatives-copy.js';
+import { createInitiative } from './initiatives-api.js';
+import { changed } from './initiative-sheet.js';
+
+const OTHER = '__other__';
+
+/** The lanes the engine names for this repository's profile, or null when the server did not say. The server refuses a lane it does not take. */
+export function laneNames(repo) {
+  const set = repoLanes(repo, repoProfile(repo));
+  const lanes = Array.isArray(set) ? set.map((l) => (typeof l === 'string' ? l : l && l.name)).filter(Boolean) : [];
+  return lanes.length ? lanes : null;
+}
+
+export function openNewInitiative({ repo, ws, anchors, prefill, onAdded }) {
+  ensureComponentsCss();
+  const anchorList = Array.from(new Set((anchors || []).filter(Boolean)));
+  const t = field({ label: COPY.newForm.titleLabel, kind: 'title', value: prefill && prefill.title, attrs: { 'data-in-new-title': '' } });
+  const lanes = laneNames(repo);
+  const l = lanes
+    ? field({ label: COPY.newForm.laneLabel, kind: 'select', value: prefill && lanes.includes(prefill.lane) ? prefill.lane : lanes[0], options: lanes.map((x) => ({ value: x, label: x })), attrs: { 'data-in-new-lane': '' } })
+    : field({ label: COPY.newForm.laneLabel, kind: 'text', value: prefill && prefill.lane, placeholder: COPY.newForm.laneHint, attrs: { 'data-in-new-lane': '' } });
+  const opts = [{ value: '', label: COPY.newForm.anchorPick }, ...anchorList.map((a) => ({ value: a, label: a })), { value: OTHER, label: COPY.newForm.anchorOther }];
+  const a = field({ label: COPY.newForm.anchorLabel, kind: 'select', value: '', options: opts, attrs: { 'data-in-new-anchor': '' } });
+  const typed = field({ label: COPY.newForm.anchorLabel, kind: 'text', placeholder: COPY.newForm.anchorHint, attrs: { 'data-in-new-anchor-text': '' } });
+  typed.hidden = true;
+  a.control.addEventListener('change', () => { typed.hidden = a.control.value !== OTHER; if (!typed.hidden) typed.control.focus(); });
+  const err = el('p', { class: 'in-error', role: 'alert', 'data-in-error': '' });
+  err.hidden = true;
+  const lands = el('p', { class: 'in-note' }, COPY.newForm.lands);
+  const fail = (text) => { err.textContent = text; err.hidden = false; };
+
+  let busy = false;
+  const add = button({
+    label: COPY.newForm.add, variant: 'primary', attrs: { 'data-in-new-add': '' },
+    onClick: async () => {
+      if (busy) return;
+      err.hidden = true;
+      const title = t.control.value.trim();
+      const pick = a.control.value;
+      const anchor = (pick === OTHER ? typed.control.value : pick).trim();
+      if (!title) { fail(COPY.newForm.noTitle); t.control.focus(); return; }
+      if (!anchor) { fail(COPY.newForm.noAnchor); return; }
+      busy = true; add.disabled = true;
+      const out = await createInitiative(ws, { title, ...(l.control.value.trim() ? { lane: l.control.value.trim() } : {}), anchor, ...(prefill && prefill.from ? { from: prefill.from } : {}) });
+      busy = false; add.disabled = false;
+      if (out && out.ok) {
+        const id = (out.initiative && out.initiative.id) || out.id || (out.ids && out.ids[0]) || null;
+        s.close();
+        toast({ text: COPY.newForm.added(title), timeout: 4000 });
+        changed();
+        if (onAdded) onAdded(id);
+      } else fail(COPY.refused((out && out.error) || 'The server did not answer.'));
+    },
+  });
+  const s = sheet({
+    mode: 'auto', title: COPY.newForm.title, body: [t, l, a, typed, lands, err], attrs: { 'data-in-sheet': 'new' },
+    actions: [button({ label: COPY.cancel, variant: 'outline', onClick: () => s.close(), attrs: { 'data-in-cancel': '' } }), add],
+  });
+  t.control.focus();
+  return s;
+}

package/workspace/public/pm/next-step-ui.js

@@ -14,6 +14,7 @@
  */
 import { el } from './dom.js';
 import { state, setState, FIXTURE } from './state.js';
+import { askText } from './dialogs.js';
 
 let dataMod = null;
 const dataReady = import('./data.js').then((m) => { dataMod = m; }).catch(() => { dataMod = null; });
@@ -22,7 +23,7 @@ import('./panel-initiatives.js').then((m) => { iniMod = m; }).catch(() => { iniM
 
 const LAB = 'font-family:var(--mono);font-size:9.5px;letter-spacing:.12em;text-transform:uppercase;color:var(--muted-foreground)';
 const BTN = 'font-family:var(--mono);font-size:10px;padding:2px 7px;background:var(--secondary);border:1px solid var(--border);color:var(--foreground);cursor:pointer;min-height:24px';
-const GO = 'font-family:var(--mono);font-size:10.5px;padding:3px 10px;background:var(--brand);border:1px solid var(--brand);color:oklch(0.987 0.002 197.1);cursor:pointer;min-height:26px';
+const GO = 'font:11px var(--mono);padding:3px 10px;background:var(--primary);border:1px solid var(--primary);color:var(--primary-foreground);cursor:pointer;min-height:26px';
 const iv = (t) => el('span', null, t == null ? '' : String(t));
 
 /* per-item UI state, keyed by item id: { loading, plan, judgment, profile, note, summary } */
@@ -58,7 +59,7 @@ async function review(slug, it, verdict) {
   const u = slot(it.id);
   let note = '';
   if (verdict === 'send-back') {
-    note = typeof window !== 'undefined' && window.prompt ? window.prompt('Send “' + (it.key || it.text) + '” back — what should change? (one line)', '') : '';
+    note = await askText({ title: 'Send “' + (it.key || it.text) + '” back', label: 'What should change? One line.', confirmLabel: 'Send back' });
     if (note === null || !String(note).trim()) return;
   }
   const out = await dataMod.nextStepPost('review', { session_id: it.run.session_id, verdict, note: String(note).trim() });

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

@@ -0,0 +1,51 @@
+/* pm/palette-copy.js — every word the ⌘K palette shows (pm-os-absorb Run 3, slice 3C).
+ *
+ * Pure data and pure functions. No DOM and no import, so `glossary.test.js` can load this file in Node and check every
+ * string against the glossary rules. Written in the PMOS-STE instructional register: short sentences, one instruction
+ * each, the same word for the same thing.
+ */
+
+export const COPY = {
+  title: 'Search or run',
+  sub: 'Open anything, run a command, or keep a note.',
+  inputLabel: 'Search or type a command',
+  placeholder: 'Type a name, a command, or a note',
+  memoryEntry: { title: 'Memory entry', close: 'Close' },
+  scopeLabel: 'Search in',
+  scopes: { all: 'All', knowledge: 'Knowledge', memory: 'Memory', guide: 'Guide' },
+  kinds: {
+    command: 'Command', destination: 'Go to', initiative: 'Initiative', repository: 'Repository', session: 'Session',
+    tab: 'Tab', view: 'View', knowledge: 'Document', memory: 'Memory', guide: 'Guide', capture: 'Note', ask: 'Ask',
+  },
+  hint: 'Type to search. Press Enter to open the first row.',
+  hintTyped: 'Type to search. Capture as note keeps what you typed.',
+  noMatch: (q) => `Nothing matches "${q}".`,
+  loading: (scope) => `Reading ${scope}.`,
+  unreadable: (scope, why) => `The ${scope} could not be read. ${why}`,
+  noScopeMatch: (scope) => `No ${scope} entry matches.`,
+  capture: {
+    label: 'Capture as note',
+    hint: 'Keeps what you typed as a note. Nothing else changes.',
+    saved: (id) => `Saved as a note: ${id}.`,
+    failed: (why) => `The note was not saved. ${why}`,
+    needsRepo: 'Select a repository first. A note is kept in one repository.',
+  },
+  ask: {
+    label: (name) => `Ask ${name}`,
+    hint: 'Sends what you typed to this session, then presses Enter.',
+    sent: (name) => `Sent to ${name}.`,
+    failed: (name) => `${name} is not connected. Nothing was sent.`,
+  },
+  compose: {
+    label: 'Message to the session',
+    placeholder: 'Type a message for this session',
+    send: 'Send',
+    sendLabel: 'Send the message to this session',
+    sent: (name) => `Sent to ${name}.`,
+    failed: (name) => `${name} is not connected. Nothing was sent. Your message is still here.`,
+  },
+  keys: 'Up and Down move. Enter opens. Esc closes.',
+};
+
+/** Rules that are right here and wrong elsewhere. Nothing is lifted: every glossary rule holds on this surface. */
+export const GLOSSARY = { exempt: {}, extra: [], guide: 'command-palette.md' };

package/workspace/public/pm/palette.js

@@ -0,0 +1,312 @@
+/* pm/palette.js — the ⌘K palette (pm-os-absorb Run 3, slice 3C; PRD R11, R1 and R16).
+ *
+ * ⌘K is the one input outside the terminal. Its rows are, in this order:
+ *   1. the rows that match what is typed: commands first (each with its CLI form, R11), then destinations, then
+ *      initiatives, repositories, sessions, tabs and views, then a few hits from the Knowledge, Memory and Guide scopes;
+ *   2. Capture as note, whenever something is typed. It keeps the words as a note file and decides nothing, so it is
+ *      always safe (D71). When nothing else matches, it is the top row;
+ *   3. Ask <bound session>, when a session is open: the typed text goes to that session as if typed there.
+ * Knowledge, Memory and Guide are search scopes (the tabs above the field). They read the routes that already exist
+ * (/api/library, /api/memory, /api/guide), so ⌘K reaches strategy documents and decision records as files, never as rows
+ * of the Initiatives views (D86 point 4).
+ *
+ * The palette is the shared sheet (primitives.js `sheet`), driven by `state.paletteOpen`: app.js sets that key on ⌘K and
+ * on Esc, and panel-cockpit.js `renderPalette` calls `paintPalette` on every render. The field and the scope tabs are made
+ * once while it is open, so a repaint never moves the caret. The list is rebuilt only when its rows change, so a press in
+ * the middle of a poll is not lost.
+ *
+ * What this file does not own: the commands (each run registers its own, pm/registry.js `registerCommand`), the base rows
+ * (panel-cockpit.js `paletteItems`), and the capture note itself (lib/capture.js, POST /api/capture).
+ */
+
+import { el } from './dom.js';
+import { state, setState, FIXTURE } from './state.js';
+import { sheet, field, tabs, row, badge, signal, toast, button, dialogText, ensureComponentsCss } from './primitives.js';
+import { ensureSprite } from './icons.js';
+import { pmGet, pmPost } from './http.js';
+import { COPY } from './palette-copy.js';
+
+/* The sheet and the rows are primitives, so their stylesheet is asked for at load, not at the first ⌘K: a palette opened before
+ * it arrives would flash unstyled. Fixture mode loads none (the parity lock). */
+if (!FIXTURE) ensureComponentsCss();
+
+const TTL = 15000;
+const SCOPES = ['all', 'knowledge', 'memory', 'guide'];
+/** The order the kinds are listed in. A kind not named here keeps the order the base rows came in, after these. */
+const KIND_ORDER = ['command', 'destination'];
+const CAP = { command: 8, knowledge: 5, memory: 3, guide: 3 };
+const CAP_DEFAULT = 6;
+const MAX_ROWS = 40;
+const MAX_DOCS = 2000;
+
+let ui = null;                    // the open palette: { sheet, input, list, note, scopes, deps, sig }
+let q = '';
+let scope = 'all';
+let sel = 0;
+let rows = [];                    // what the list shows now
+let noteKey = '';                 // the note on show, so a repaint does not rebuild it
+let pinned = null;                // a message that stays until the next keystroke or scope change: { text, error }
+let busy = false;                 // a capture or an ask is in flight
+const reads = new Map();          // key -> { state: 'loading' | 'ok' | 'error', data, error, at }
+
+/* ── reads: the three scopes ─────────────────────────────────────────────────────────────────────────────────────── */
+
+function read(key, path) {
+  if (FIXTURE) return null;
+  const hit = reads.get(key);
+  if (hit && (hit.state === 'loading' || Date.now() - hit.at < TTL)) return hit;
+  const next = { state: 'loading', data: hit ? hit.data : null, error: null, at: hit ? hit.at : 0 };
+  reads.set(key, next);
+  pmGet(path).then((data) => {
+    reads.set(key, data && data.ok === false ? { state: 'error', data: null, error: String(data.error || ''), at: Date.now() } : { state: 'ok', data, error: null, at: Date.now() });
+    if (ui) setState({});
+  });
+  return next;
+}
+const wsId = () => state.wsId || '';
+const readLibrary = () => read('library:' + wsId(), '/api/library?ws=' + encodeURIComponent(wsId()));
+const readMemory = () => read('memory:' + wsId(), '/api/memory?ws=' + encodeURIComponent(wsId()));
+const readGuide = () => read('guide', '/api/guide');
+
+/** Every markdown document in the library answer: the repository's folders, its governance files, its knowledge bundles and its notes. */
+function docsOf(data) {
+  const out = []; const seen = new Set();
+  const walk = (node, depth) => {
+    if (!node || out.length >= MAX_DOCS || depth > 9) return;
+    for (const d of node.docs || []) {
+      if (!d || typeof d.path !== 'string' || seen.has(d.path) || out.length >= MAX_DOCS) continue;
+      if (d.md === false || !/\.(?:md|markdown)$/i.test(d.path || d.name || '')) continue;
+      seen.add(d.path);
+      out.push({ path: d.path, name: d.name || d.path.split('/').pop(), category: d.category || '' });
+    }
+    for (const sub of node.dirs || []) walk(sub, depth + 1);
+  };
+  for (const key of ['knowledge', 'roots', 'notes']) for (const t of (data && data[key]) || []) walk(t, 0);
+  walk({ docs: (data && data.governance) || [] }, 0);
+  return out;
+}
+
+const words = (s) => String(s || '').toLowerCase().split(/\s+/).filter(Boolean);
+const hay = (it) => `${it.label} ${it.hint || ''} ${it.cli || ''} ${it.kind} ${it.tag || ''}`.toLowerCase();
+const matches = (it, w) => w.every((x) => hay(it).includes(x));
+
+/** The category the classifier gave a document, as a row signal. Empty and 'undetermined' say nothing to the PM, so they show no signal. */
+const tagOf = (category) => { const c = String(category || '').trim(); return !c || c.toLowerCase() === 'undetermined' ? '' : c; };
+
+/** A memory entry opens as a sheet that shows its whole text. The Memory view is cut (R29): the entries are read here, never edited. */
+function showMemory(e) {
+  ensureComponentsCss();
+  const h = sheet({
+    mode: 'auto', title: COPY.memoryEntry.title, sub: String(e.target || 'memory'),
+    body: [dialogText(String(e.text || ''))],
+    actions: [button({ label: COPY.memoryEntry.close, variant: 'outline', onClick: () => h.close() })],
+    attrs: { 'data-pl': 'memory-entry' },
+  });
+}
+
+/** The hits one scope offers for the typed words, as rows. Null while the first read is under way. */
+function scopeRows(name, w, deps) {
+  if (name === 'knowledge') {
+    const r = readLibrary(); if (!r || !r.data) return r;
+    const out = docsOf(r.data).map((d) => ({ kind: 'knowledge', label: d.name, hint: d.path, tag: tagOf(d.category), run: () => deps.openDoc(null, d.path, 'FILE', { ws: wsId(), branch: null, linked: true }) }));
+    return { state: 'ok', rows: out.filter((it) => matches(it, w)).sort((a, b) => Number(!w.every((x) => a.label.toLowerCase().includes(x))) - Number(!w.every((x) => b.label.toLowerCase().includes(x)))) };
+  }
+  if (name === 'memory') {
+    const r = readMemory(); if (!r || !r.data) return r;
+    const out = ((r.data && r.data.entries) || []).map((e) => ({ kind: 'memory', label: String(e.text || '').replace(/\s+/g, ' ').slice(0, 90), hint: String(e.target || 'memory'), run: () => showMemory(e) }));
+    return { state: 'ok', rows: out.filter((it) => matches(it, w)) };
+  }
+  const r = readGuide(); if (!r || !r.data) return r;
+  const out = ((r.data && r.data.pages) || []).map((pg) => ({ kind: 'guide', label: String(pg.title || pg.page), hint: String(pg.page),
+    run: () => deps.openTab({ id: 'guide:' + pg.page, kind: 'doc', title: pg.title || pg.page, guide: true, readonly: true, path: pg.page, slug: null, repo: state.product || null, role: 'GUIDE' }) }));
+  return { state: 'ok', rows: out.filter((it) => matches(it, w)) };
+}
+
+/* ── the bound session, Capture and Ask ──────────────────────────────────────────────────────────────────────────── */
+
+/** The session ⌘K asks: the open terminal tab, else the one bound to the selected initiative, else the latest in this repository. */
+export function boundSession() {
+  const terms = (state.tabs || []).filter((t) => t.kind === 'term');
+  return terms.find((t) => t.id === state.active)
+    || (state.sel && terms.find((t) => t.slug === state.sel))
+    || [...terms].reverse().find((t) => !t.repo || t.repo === state.product)
+    || null;
+}
+
+/** Show a message under the list and keep it through repaints (a poll repaints the page) until the next keystroke or scope change. */
+function say(text, error) {
+  if (!ui) return;
+  pinned = text ? { text, error: !!error } : null;
+  noteKey = '';
+  refresh();
+}
+
+async function doCapture() {
+  const text = q.trim();
+  if (!text || busy) return false;
+  if (!wsId()) { say(COPY.capture.needsRepo, true); return false; }
+  busy = true;
+  const r = await pmPost('/api/capture', { ws: wsId(), text });
+  busy = false;
+  if (!r || r.ok !== true) { say(COPY.capture.failed(String((r && r.error) || '')), true); return false; }
+  toast({ text: COPY.capture.saved(r.id) });
+  return true;
+}
+
+async function doAsk() {
+  const text = q.trim(); const b = boundSession();
+  if (!text || !b || busy) return false;
+  const name = String(b.title || b.id);
+  let term = null;
+  try { term = await import('./tab-term.js'); } catch { term = null; }
+  if (!term || typeof term.sendToTerm !== 'function' || !term.sendToTerm(b, text + '\n')) { say(COPY.ask.failed(name), true); return false; }
+  setState({ active: b.id });
+  toast({ text: COPY.ask.sent(name) });
+  return true;
+}
+
+/* ── the rows ────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function build(deps) {
+  const w = words(q);
+  let list = [];
+  let status = null;                       // { kind: 'loading' | 'error' | 'none', scope?, why? } for the note
+  if (scope === 'all') {
+    const base = deps.rows().filter((it) => !w.length || matches(it, w));
+    const seen = {};
+    const capped = (w.length ? base : base.filter((it) => (seen[it.kind] = (seen[it.kind] || 0) + 1) <= (CAP[it.kind] || CAP_DEFAULT)));
+    const rank = (it) => { const i = KIND_ORDER.indexOf(it.kind); return i < 0 ? KIND_ORDER.length : i; };
+    list = capped.map((it, i) => [rank(it), i, it]).sort((a, b) => a[0] - b[0] || a[1] - b[1]).map((x) => x[2]).slice(0, MAX_ROWS);
+    if (w.length) {
+      for (const name of ['knowledge', 'memory', 'guide']) {
+        const r = scopeRows(name, w, deps);
+        if (r && r.rows) list.push(...r.rows.slice(0, CAP[name]));
+      }
+    }
+  } else {
+    const r = scopeRows(scope, words(q), deps);
+    const sc = COPY.scopes[scope].toLowerCase();
+    if (!r || r.state === 'loading') status = { kind: 'loading', scope: sc };
+    else if (r.state === 'error') status = { kind: 'error', scope: sc, why: r.error };
+    else { list = r.rows.slice(0, MAX_ROWS); if (!list.length) status = { kind: 'none', scope: sc }; }
+  }
+  const found = list.length;
+  if (q.trim() && !FIXTURE) {
+    list.push({ kind: 'capture', label: COPY.capture.label, hint: COPY.capture.hint, async: doCapture });
+    const b = boundSession();
+    if (b) list.push({ kind: 'ask', label: COPY.ask.label(String(b.title || b.id)), hint: COPY.ask.hint, async: doAsk });
+  }
+  return { list, found, status };
+}
+
+function noteFor(found, status) {
+  if (pinned) return ['pinned:' + pinned.error + pinned.text, pinned.text, pinned.error ? 'error' : 'note'];
+  if (status && status.kind === 'loading') return ['loading', COPY.loading(status.scope), 'note'];
+  if (status && status.kind === 'error') return ['error:' + status.why, COPY.unreadable(status.scope, status.why), 'error'];
+  if (status && status.kind === 'none') return ['none:' + status.scope, COPY.noScopeMatch(status.scope), 'empty'];
+  if (q.trim() && !found) return ['nomatch:' + q, COPY.noMatch(q.trim()), 'empty'];
+  return q.trim() ? ['typed', COPY.hintTyped, 'note'] : ['hint', COPY.hint, 'note'];
+}
+
+function choose(it) {
+  if (!it) return;
+  if (it.async) { it.async().then((done) => { if (done) closePalette(); }); return; }
+  closePalette();
+  try { it.run(); } catch (e) { console.warn('[palette] a row failed:', (e && e.message) || e); }
+}
+
+function itemRow(it, i, id) {
+  const sigs = [];
+  if (it.cli) sigs.push(el('code', { class: 'pl-cli' }, it.cli));
+  else if (it.tag) sigs.push(signal({ text: it.tag }));
+  return row({
+    title: it.label,
+    meta: [it.hint].filter(Boolean),
+    signals: sigs,
+    lead: [badge({ text: COPY.kinds[it.kind] || it.kind, tone: 'muted' })],
+    onOpen: () => choose(it),
+    openAttrs: { 'data-palette': 'item', 'data-kind': it.kind, tabindex: '-1' },
+    attrs: { class: 'pl-item', id, role: 'option', 'aria-selected': i === sel ? 'true' : 'false' },
+  });
+}
+
+function refresh() {
+  if (!ui) return;
+  const { list, found, status } = build(ui.deps);
+  rows = list;
+  if (sel >= rows.length) sel = Math.max(0, rows.length - 1);
+  const sig = rows.map((it) => `${it.kind}|${it.label}|${it.hint || ''}|${it.cli || ''}`).join('\n') + '#' + sel;
+  if (sig !== ui.sig) {
+    ui.sig = sig;
+    ui.list.replaceChildren(...rows.map((it, i) => itemRow(it, i, ui.listId + '-' + i)));
+    const cur = ui.list.children[sel];
+    ui.input.control.setAttribute('aria-activedescendant', cur ? cur.id : '');
+    if (cur && cur.scrollIntoView) cur.scrollIntoView({ block: 'nearest' });
+  }
+  const [key, text, tone] = noteFor(found, status);
+  if (key !== noteKey) {
+    noteKey = key;
+    ui.note.textContent = text;
+    ui.note.className = tone === 'error' ? 'pl-note pl-note--error' : 'pl-note';
+    ui.note.setAttribute('data-palette', tone);
+  }
+}
+
+/* ── open, close, keys ───────────────────────────────────────────────────────────────────────────────────────────── */
+
+function setScope(next) {
+  if (!ui || !SCOPES.includes(next) || next === scope) return;
+  scope = next; sel = 0; noteKey = ''; pinned = null;
+  ui.scopes.replaceWith(ui.scopes = scopeTabs());
+  refresh();
+  ui.input.control.focus();
+}
+
+const scopeTabs = () => tabs({ variant: 'line', items: SCOPES.map((id) => ({ id, label: COPY.scopes[id] })), value: scope, onChange: setScope, ariaLabel: COPY.scopeLabel, attrs: { 'data-palette': 'scopes' } });
+
+function onKey(e) {
+  if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+    e.preventDefault();
+    const n = rows.length; if (!n) return;
+    sel = Math.max(0, Math.min(n - 1, sel + (e.key === 'ArrowDown' ? 1 : -1)));
+    if (ui) { ui.sig = ''; refresh(); }
+  } else if (e.key === 'Enter' && !e.isComposing) {
+    e.preventDefault();
+    choose(rows[sel]);
+  }
+}
+
+function openPalette(deps) {
+  ensureComponentsCss();
+  ensureSprite();
+  q = ''; scope = 'all'; sel = 0; noteKey = ''; pinned = null; busy = false;
+  const listId = 'pl-list-' + Math.random().toString(36).slice(2, 7);
+  const input = field({ label: COPY.inputLabel, hideLabel: true, placeholder: COPY.placeholder,
+    attrs: { 'data-palette': 'input', role: 'combobox', 'aria-expanded': 'true', 'aria-controls': listId, 'aria-autocomplete': 'list', spellcheck: 'false' } });
+  const list = el('div', { class: 'pl-list', role: 'listbox', id: listId, 'aria-label': COPY.title, 'data-palette': 'list' });
+  const note = el('p', { class: 'pl-note', role: 'status', 'data-palette': 'note' });
+  const scopes = scopeTabs();
+  const dlg = sheet({ mode: 'auto', title: COPY.title, sub: COPY.sub, body: [scopes, input, list, note], attrs: { 'data-palette': 'overlay' },
+    onClose: () => { ui = null; if (state.paletteOpen) setState({ paletteOpen: false }); } });
+  ui = { sheet: dlg, input, list, note, scopes, deps, sig: null, listId };
+  input.control.addEventListener('input', () => { input.control.resetCommitted(input.control.value); q = input.control.value; sel = 0; pinned = null; if (ui) { ui.sig = null; refresh(); } });
+  input.control.addEventListener('keydown', onKey);
+  readLibrary(); readMemory(); readGuide();
+  input.control.focus();
+}
+
+function closePalette() {
+  const u = ui;
+  ui = null;
+  if (u && u.sheet.open) u.sheet.close();
+  if (state.paletteOpen) setState({ paletteOpen: false });
+}
+
+/** Called by panel-cockpit.js `renderPalette` on every render. `deps`: { rows() → the base rows, openView, openDoc, openTab }. */
+export function paintPalette(host, deps) {
+  if (!state.paletteOpen) { if (ui) closePalette(); return host; }
+  if (!ui) openPalette(deps);
+  ui.deps = deps;
+  refresh();
+  return host;
+}