create-pmos 0.188.0 → 0.189.0

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.188.0",
+  "version": "0.189.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.188.0",
+      "version": "0.189.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

package/workspace/public/pm/c3-doc-sheet.js

@@ -251,6 +251,11 @@ const olGet = () => { try { return localStorage.getItem(OL_KEY) !== 'off'; } cat
 const olSet = (on) => { try { localStorage.setItem(OL_KEY, on ? 'on' : 'off'); } catch { /* no storage here */ } };
 const ESTATE = { ok: 'in step', drift: 'out of step', conflict: 'conflict', missing: 'missing', ahead: 'PMOS ahead' };
 
+/** Parts another module puts under the sheet's header and tabs, ahead of the text (the Horizon scan's "Proposed next steps"). Each is
+ *  ({ ws, doc, text, key }) => Node|null, called on every draw with the text read so far; `key` is stable for one open sheet, so a part
+ *  keeps its node (and its own state) in a WeakMap on it. A part that throws is left out. */
+export const docAbove = [];
+
 export function openDocSheet({ ws, doc, mode = 'read', prompt = '', relations, onChanged, generated, secExtra, library, openGraph, report }) {
   const S = { mode: MODE[mode] || mode, prompt, text: null, err: '', revs: null, texts: {}, health: null, hAsk: false, busy: false, changed: false,
     meta: null, metaFor: null, props: null, propsErr: '', log: null, logErr: '', asking: null, closed: false, who: false, src: false, preview: {},
@@ -1115,7 +1120,8 @@ export function openDocSheet({ ws, doc, mode = 'read', prompt = '', relations, o
     const body = S.mode === 'read' ? readBody() : S.mode === 'edit' ? editBody() : S.mode === 'ask' ? propsBody() : S.mode === 'hist' ? logBody() : S.mode === 'health' ? healthBody() : linksBody();
     const keep = ui.body.querySelector('textarea:focus,input[type=text]:focus');
     const had = keep ? { id: keep.id, s: keep.selectionStart } : null;
-    ui.body.replaceChildren(el('div', { class: 'dpn ds' }, top(), copiesPanel(), body));
+    const above = docAbove.map((fn) => { try { return fn({ ws, doc, text: S.text, key: S }); } catch { return null; } });
+    ui.body.replaceChildren(el('div', { class: 'dpn ds' }, top(), above, copiesPanel(), body));
     const sh = ui.body.closest('.sheet'); if (sh) sh.classList.toggle('dwx', S.mode === 'read' && S.ol && !!ui.body.querySelector('.ds-ol'));
     const sb = ui.body.closest('.sb');
     if (sb && !sb.__dsTrack) { sb.__dsTrack = true; sb.addEventListener('scroll', trackCur, { passive: true }); }

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

@@ -49,8 +49,8 @@ import { TEMPLATES, BOARD_TEMPLATES, isBuildStage, templateBuilds, offered, wfOf
 import { timeline, tlInit, tlRange } from './c3-ini-timeline.js';
 import { RECORD_META, recordToolsFor } from './c3-ini-records.js';
 import { agentSetting, loadAgentMode, MODES as AGENT_MODES } from './c3-driver.js';
+import { scanPortfolioSection, scanPointer } from './c3-scan-setup.js';
 import { lifeBanner, pageMenu, ensureLifeCss } from './c3-ini-life.js';
-import { scanSetting, takeSettingsFor } from './c3-scan.js';
 
 export { btn, geo };
 export { TEMPLATES, CATS };
@@ -256,6 +256,8 @@ export function mountInitiatives(pane, opts) {
         pbtn('primary', 'New board', 'plus', { 'data-ini': 'new-board', onclick: () => openNewBoard() }))),
       el('div', { class: 'calbody', 'data-ini': 'portfolio' },
         lh('cols', sentenceOf(bad, warn), PORTFOLIO + ': boards hold initiatives, initiatives hold epics, epics hold stories, tasks and bugs. Stages roll up into Discover, Plan, Do and Learn so boards compare.'),
+        // The Horizon scan runs for the whole portfolio (c3-scan-setup.js): its section is here, with Scan now always visible. Not in demo mode.
+        opts.demo ? null : scanPortfolioSection({ ws: opts.ws || (boards[0] && boards[0].ws) || '', boardCount: boards.length, showTab: opts.showTab }),
         cols(left, right),
         sect({ ic: 'cal', title: 'Timeline across boards', right: mono('Board > initiative > epic') }, tlHost)));
     /* the cross-board timeline: board > the initiatives that are featured, at risk or carry work > their epics */
@@ -328,7 +330,6 @@ export function mountInitiatives(pane, opts) {
         segTabs(tabs, tab, (k) => openBoard(b.id, k), 'Board views', { 'data-ini': 'board-tabs' }),
         host));
     mountTab(host, tab === 'summary' ? mountSummary : null, (BOARD_TAB_LIST.find((t) => t[0] === tab) || [])[1], makeCtx(b, { tab, filter: P.loc.filter || {} }), token);
-    if (!opts.demo && takeSettingsFor(b.id)) openBoardSettings(b);   // "Scan settings" on the Briefing's Horizon scan card
   }
 
   /* Summary: initiatives at a glance, where they stand, what needs attention */
@@ -392,8 +393,8 @@ export function mountInitiatives(pane, opts) {
     loadItems(makeCtx(b, {})).then((r) => { usage = r; render(); });
     // The Agent setting (c3-driver.js): read once, and saved at once when a mode is pressed (POST /api/driver/mode). Not in demo mode.
     const A = { mode: null, err: '', busy: false };
-    // The Horizon scan block (c3-scan.js): one node that reads and presses by itself, so a redraw of this form keeps it. Not in demo mode.
-    const scanNode = opts.demo ? null : scanSetting({ api: apiFor(b.ws), board: b.id, boardName: b.name });
+    // The Horizon scan runs for the whole portfolio: Board settings holds only a pointer to its setup (c3-scan-setup.js). Not in demo mode.
+    const scanNode = opts.demo ? null : scanPointer(b.ws || opts.ws || '');
     if (!opts.demo) loadAgentMode(apiFor(b.ws), b.id).then((r) => { if (r.ok) A.mode = r.mode; else A.err = r.error; render(); });
     async function pickAgent(mode) {
       if (A.busy || mode === A.mode) return;

package/workspace/public/pm/c3-scan-api.js

@@ -0,0 +1,167 @@
+/* pm/c3-scan-api.js — every call the portfolio Horizon scan makes to the server, in ONE place (initiative horizon-scan-portfolio, PRD section 7).
+ * The pages never write a scan route name: they call a function here. If the server names a route or a field differently, change it here only.
+ *
+ *   GET  /api/scan/portfolio?ws          getPortfolio(ws)           the setting, watch list, last and next scan, open scan, reports, proposals
+ *   GET  /api/scan/report?ws&id          getReport(ws, id)          { report, markdown, body, written, proposals }
+ *   POST /api/scan/watch                 postWatch(ws, body)        { ws, op: keep|edit|remove|add, id?, name?, kind?, why?, boards?, restore? }
+ *   POST /api/scan/setting               postSetting(ws, body)      { ws, cadence?, repo?, types? }   types is an array of type keys
+ *   POST /api/scan/now                   postNow(ws, sel)           { ws, items: [id], repo, types: [key] }
+ *   POST /api/scan/stop                  postStop(ws)               { ws }
+ *   POST /api/scan/proposal              postProposal(ws, body)     { ws, id, action: approve|change|dismiss|undo, fields?, why? }   undo takes back a dismissal or a change, never an approval
+ *
+ * The page sends no `by`: the server takes the PM from the call path (http.js adds the nonce and the page Origin).
+ * The answers are read into one shape (readPortfolio): a field the server leaves out reads as empty, never as a thrown error.
+ * The names are the server's (lib/routes-scan.js header): items, proposals_waiting, open.scan, steps[].id, proposal.finding, dismissed_why, result.
+ * Pure parts (Node-testable): readPortfolio, readProposal, readOut, evidenceKind, scanNowWords, typeKeys, proposalFields, frontOf.
+ */
+import { pmGet, pmPost } from './http.js';
+
+export const ROUTES = Object.freeze({
+  portfolio: '/api/scan/portfolio', report: '/api/scan/report', watch: '/api/scan/watch', setting: '/api/scan/setting',
+  now: '/api/scan/now', stop: '/api/scan/stop', proposal: '/api/scan/proposal',
+});
+
+/** The report types, in the order the sheets show them. [key, name, help, repository only]. */
+export const TYPES = [
+  ['benchmark', 'Benchmark report', 'Compares our flow with named products, point by point.', false],
+  ['competitive', 'Competitive analysis', 'Positioning, features, pricing signals, threats and openings.', false],
+  ['insight', 'Insight report', 'Themes across boards from Jira, friction, notes and Slack, plus web trends.', false],
+  ['productivity', 'Productivity report', 'Delivery health from the repository and Jira. No web.', true],
+];
+export const TYPE_KEYS = TYPES.map((t) => t[0]);
+export const typeName = (k) => (TYPES.find((t) => t[0] === k) || [0, k])[1];
+export const KINDS = ['product', 'domain', 'approach'];
+
+/** A types answer as a list of keys: an array of keys, or an object of key to on/off. */
+export function typeKeys(v) {
+  if (Array.isArray(v)) return TYPE_KEYS.filter((k) => v.includes(k));
+  if (v && typeof v === 'object') return TYPE_KEYS.filter((k) => v[k]);
+  return TYPE_KEYS.slice();
+}
+/** The kind of an evidence pointer: a public page (http or https), a Jira key, a path in the repository, or a note. The backend keeps only { label, ref }. */
+export const evidenceKind = (ref) => {
+  const r = String(ref || '').trim();
+  return /^https?:\/\//i.test(r) ? 'web' : /^[A-Z][A-Z0-9_]+-\d+$/.test(r) ? 'jira' : /^[\w.-]+(\/[\w.@-]+)+$/.test(r) ? 'repo' : 'note';
+};
+/** The fields of a proposal under the backend's names, each as a string: create { title, board, lane, anchor, intent }, research { question, depth },
+ * attach { initiative }. `title` is the proposal's own title (a change edits it through `fields.title`). */
+export function proposalFields(kind, f, title) {
+  const o = f && typeof f === 'object' ? f : {};
+  const str = (v) => (v == null ? '' : String(v));
+  if (kind === 'create') return { title: str(title), board: str(o.board), lane: str(o.lane), anchor: str(o.anchor), intent: str(o.intent) };
+  if (kind === 'research') return { question: str(o.question), depth: str(o.depth) || 'standard' };
+  return { initiative: str(o.initiative) };
+}
+/** What an approved proposal made or started, from a proposal's `result` (or the answer of the approve press): { id, board, stage, scan, report }. The initiative is a
+ * string on a stored proposal and an object in the approve answer. Null when there is none. */
+export function readOut(res) {
+  if (!res || typeof res !== 'object') return null;
+  const i = res.initiative;
+  const id = typeof i === 'string' ? i : i && i.id ? String(i.id) : '';
+  return { id, board: String(res.board || ''), stage: String(res.stage || ''), scan: String(res.scan || ''), report: String(res.report || '') };
+}
+/** One proposal as the page uses it: the backend's fields, `from` (the finding it came from), `reason` (the dismissal), `out` (what approve made) and a state of
+ * open | done (approved) | dismissed. A research proposal that is approved while its scan is still open reads `running` (getReport sets that). */
+export function readProposal(p) {
+  const kind = ['create', 'research', 'attach'].includes(p.kind) ? p.kind : 'create';
+  const state = p.state === 'approved' ? 'done' : p.state === 'dismissed' ? 'dismissed' : 'open';
+  return { id: String(p.id), report: String(p.report || ''), reportTitle: p.report_title || '', kind, title: p.title || '', why: p.why || '', from: p.finding || '',
+    evidence: (Array.isArray(p.evidence) ? p.evidence : []).map((e) => ({ label: String((e && e.label) || ''), ref: String((e && e.ref) || ''), kind: evidenceKind(e && e.ref) })).filter((e) => e.ref),
+    fields: proposalFields(kind, p.fields, p.title), state, changed: !!p.changed, reason: p.dismissed_why || '', out: readOut(p.result), steps: null, at: p.at || '', decidedAt: p.decided_at || '' };
+}
+
+/** The plain words for a refused Scan now: 409 running or quiet hours, 429 manual-limit. The server's own sentence is the fallback. */
+export function scanNowWords(r) {
+  const why = r && r.why;
+  if (why === 'running') return 'A scan is running now. Wait for it to end, or stop it.';
+  if (why === 'quiet-hours') return 'Quiet hours hold, so a manual scan does not start now. Try again when they end.';
+  if (why === 'manual-limit') return 'You used all ' + ((r && r.limit) || 3) + ' manual scans today. The scheduled scan still runs. Try again tomorrow.';
+  return (r && r.error) || 'the workspace did not answer';
+}
+const readManual = (m) => ({ limit: Number(m && m.limit) || 3, used: Number(m && m.used) || 0, left: m && m.left != null ? Number(m.left) : 3, ok: !m || m.ok !== false, why: (m && m.why) || '', error: (m && m.error) || '' });
+
+/** The portfolio answer in one shape. The names are the server's: items (suggested | kept), proposals_waiting as `waiting`, open.scan, steps[].id. */
+export function readPortfolio(r) {
+  const s = (r && r.setting) || {};
+  const o = r && r.open;
+  return {
+    ok: !!(r && r.ok !== false), error: r && r.ok === false ? r.error || '' : '',
+    setting: { cadence: ['daily', 'weekly', 'off'].includes(s.cadence) ? s.cadence : 'daily', repo: s.repo !== false, types: typeKeys(s.types) },
+    items: (Array.isArray(r && r.items) ? r.items : []).map((w) => ({ id: String(w.id), kind: KINDS.includes(w.kind) ? w.kind : 'product', name: w.name || '', why: w.why || '',
+      boards: Array.isArray(w.boards) ? w.boards.map(String) : [], ini: w.ini || '', added: !!w.added, state: w.state === 'kept' ? 'kept' : 'suggested' })),
+    last: r && r.last ? { ...r.last } : null, next: (r && r.next) || '', manual: readManual(r && r.manual), switchedOff: !!(r && r.switched_off),
+    open: o ? { scan: String(o.scan || ''), mode: o.mode || 'scan', stopping: !!o.stopping, steps: (Array.isArray(o.steps) ? o.steps : []).map((x) => ({ id: String(x.id || ''), label: x.label || x.id || '', state: x.state || 'pending' })),
+      reports: Array.isArray(o.reports) ? o.reports : [], research: o.research || null } : null,
+    reports: (Array.isArray(r && r.reports) ? r.reports : []).map((x) => ({ id: String(x.id), type: x.type || '', label: x.label || '', title: x.title || '', path: x.path || '', scan: x.scan || '', at: x.at || '', parent: x.parent || '',
+      written: x.written === true, origin: x.origin || '', open: Number(x.proposals && x.proposals.open) || 0, total: Number(x.proposals && x.proposals.total) || 0 })),
+    waiting: Number(r && r.proposals_waiting) || 0,
+    proposals: (Array.isArray(r && r.proposals) ? r.proposals : []).map(readProposal),
+    boards: Array.isArray(r && r.boards) ? r.boards : null,
+  };
+}
+
+/** The front matter of a markdown text as { key: value }, or {} when it has none. */
+export function frontOf(text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(String(text || ''));
+  const out = {};
+  if (!m) return out;
+  for (const line of m[1].split(/\r?\n/)) { const k = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(line); if (k) out[k[1]] = k[2].replace(/^["']|["']$/g, '').trim(); }
+  return out;
+}
+
+/* ── reads ── */
+const fail = (e) => ({ ok: false, error: (e && e.message) || 'the workspace did not answer' });
+const q = (o) => new URLSearchParams(o).toString();
+export async function getPortfolio(ws) {
+  const r = await pmGet(ROUTES.portfolio + '?' + q({ ws })).catch(fail);
+  return readPortfolio(r);
+}
+/** A report: { report, markdown, body, written, proposals }. A research proposal that was approved while its scan is still open reads `running`, with the steps of that scan. */
+export async function getReport(ws, id) {
+  const r = await pmGet(ROUTES.report + '?' + q({ ws, id })).catch(fail);
+  if (!r || r.ok === false) return { ok: false, error: (r && r.error) || 'the report could not be read', report: null, markdown: '', body: '', written: false, proposals: [] };
+  const proposals = (Array.isArray(r.proposals) ? r.proposals : []).map(readProposal);
+  const live = proposals.filter((p) => p.kind === 'research' && p.state === 'done' && p.out && p.out.scan);
+  if (live.length) {
+    const d = await getPortfolio(ws);
+    if (d.ok && d.open) for (const p of live) if (d.open.scan === p.out.scan) { p.state = 'running'; p.steps = d.open.steps; }
+  }
+  return { ok: true, error: '', report: r.report || null, markdown: r.markdown || '', body: r.body || '', written: r.written === true, proposals };
+}
+/** The proposals the PM dismissed, newest first, read from the reports that hold a decided proposal (the portfolio answer lists only those still waiting). */
+export async function getDismissed(ws, reports) {
+  const held = reports.filter((x) => x.total > x.open).slice(0, 12);
+  const all = await Promise.all(held.map((x) => getReport(ws, x.id)));
+  return all.flatMap((r) => (r.ok ? r.proposals : [])).filter((p) => p.state === 'dismissed').sort((a, b) => String(b.decidedAt).localeCompare(String(a.decidedAt)));
+}
+
+/* ── presses: each answers the server's JSON, or { ok:false, error } ── */
+const post = (route, ws, body) => pmPost(route, { ws, ...(body || {}) }).catch(fail);
+export const postWatch = (ws, body) => post(ROUTES.watch, ws, body);
+export const postSetting = (ws, body) => post(ROUTES.setting, ws, body);
+export const postNow = (ws, sel) => post(ROUTES.now, ws, { items: sel.items, repo: !!sel.repo, types: sel.types });
+export const postStop = (ws) => post(ROUTES.stop, ws, {});
+export const postProposal = (ws, body) => post(ROUTES.proposal, ws, body);
+
+/** The boards of the workspace as [{ id, name }] (the page already reads this list for the Portfolio). */
+export async function getBoards(ws) {
+  const b = await pmGet('/api/boards?' + q({ ws })).catch(fail);
+  return b && b.ok && Array.isArray(b.boards) ? b.boards.filter((x) => !ws || !x.ws || x.ws === ws).map((x) => ({ id: x.id, name: x.name || x.id })) : [];
+}
+
+/* ── choices for the Change first form: the boards, the anchors and the initiatives the page already reads elsewhere ── */
+export async function loadChoices(ws) {
+  const boards = await getBoards(ws);
+  const first = boards[0] ? boards[0].id : '';
+  const a = first ? await pmGet('/api/boards/anchors?' + q({ ws, board: first })).catch(fail) : null;
+  const anchors = a && a.ok && Array.isArray(a.anchors) ? a.anchors.map((x) => ({ value: x.value, label: x.label || x.value })) : [];
+  const per = await Promise.all(boards.map((x) => pmGet('/api/boards/items?' + q({ ws, board: x.id })).catch(fail)));
+  const initiatives = [];
+  per.forEach((r) => { if (r && r.ok && Array.isArray(r.initiatives)) for (const i of r.initiatives) if (i.id && !initiatives.some((y) => y.id === i.id)) initiatives.push({ id: i.id, title: i.title || '' }); });
+  return { boards, anchors, initiatives };
+}
+
+/* ── a change anywhere tells every part of the page that draws the scan ── */
+const subs = new Set();
+export const onScanChange = (fn) => { subs.add(fn); return () => subs.delete(fn); };
+export const scanChanged = () => { for (const fn of [...subs]) { try { fn(); } catch { /* one part failing never stops the rest */ } } };

package/workspace/public/pm/c3-scan-next.js

@@ -0,0 +1,248 @@
+/* pm/c3-scan-next.js — the "Proposed next steps (N)" panel of a Horizon scan document, and the way a scan document opens (initiative
+ * horizon-scan-portfolio, PRD section 4; mockup 42-hscan.js X.panel).
+ *
+ * A scan report is a markdown file in the state folder (`<state>/reports/scan-<type>/<date>.md`) whose front matter says `source: scan:portfolio`
+ * and `report: <record id>`. It opens in the EXISTING document sheet (c3-doc-sheet.js) by its path: GET /api/doc reads any file inside the
+ * workspace root, and the state folder is inside it. This module adds the one thing the sheet does not know: the panel of proposals. It joins the
+ * sheet through the `docAbove` list that c3-doc-sheet.js exports, so the sheet holds no scan code. The panel shows only for a document whose front
+ * matter has `source: scan:*`. It sits under the sheet's header and tabs, collapsed, and scrolls with the text.
+ *
+ * Each proposal has a kind: create (title, board, lane, anchor, intent, starts in), research (question, depth, result) or attach
+ * (initiative). Each has FROM (the finding in the document), EVIDENCE chips, Approve, Change first (the fields as a form, then
+ * Approve with changes) and Dismiss (a one-line reason is required). Nothing acts without a press. Calls: c3-scan-api.js only.
+ *   openScanDoc(ws, report, { panel })    open a report in the document sheet; panel: true opens it with the proposals showing
+ *   proposalsPanel({ ws, path, text })    the panel node (the sheet's hook calls it)
+ *   goBoard(board, tab)                   open a board on the Initiatives tab
+ * Undo takes back a dismissal, and a change made with Change first. Approve has no Undo: create made a real initiative and research started runs.
+ * Pure parts (Node-testable): outOf, evidenceHref, shortRef, sumLine.
+ */
+import { el } from './dom.js';
+import { icon, pbtn, lk, btn, chip, kv, put } from './c3-ini-ui.js';
+import { toast } from './c3-toast.js';
+import { docAbove } from './c3-doc-sheet.js';
+import { frontOf, getReport, getPortfolio, getBoards, loadChoices, postProposal, postStop, readOut, scanChanged, onScanChange } from './c3-scan-api.js';
+
+export const KIND_WORDS = { create: ['Create initiative', 'init'], research: ['Research more', 'search'], attach: ['Add to an existing initiative', 'plus'] };
+export const LANES = [['feature', 'Feature'], ['discovery', 'Discovery'], ['chore', 'Chore'], ['content', 'Content']];
+export const DEPTHS = [['quick', 'Quick', 'About 8 public pages, 5 minutes'], ['standard', 'Standard', 'About 20 public pages, 10 minutes'], ['deep', 'Deep', 'About 50 public pages, 30 minutes']];
+const EV_IC = { web: 'out', jira: 'org', note: 'doc', slack: 'mail', repo: 'repo' };
+const EV_T = { web: 'Public page', jira: 'Jira item', note: 'Note', slack: 'Slack thread', repo: 'Repository' };
+const isOpen = (p) => p.state === 'open' || p.state === 'running';
+const cap = (s) => (s ? s[0].toUpperCase() + s.slice(1) : '');
+
+/** What an approve press made, from the server's answer: { id, board, stage } (the initiative is an object in the answer: result.initiative.id). */
+export function outOf(r) {
+  const o = readOut(r && r.result);
+  return o ? { id: o.id, board: o.board, stage: o.stage } : { id: '', board: '', stage: '' };
+}
+/** The address a public-page evidence chip opens, or '' for a chip that opens nothing (a Jira key, a note, a path, or a scheme other than http). */
+export function evidenceHref(e) {
+  const ref = String(e && e.ref || '').trim();
+  if (!ref || (e && e.kind && e.kind !== 'web')) return '';
+  if (/^https?:\/\//i.test(ref)) return ref;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(ref)) return '';
+  return /^[\w-]+(\.[\w-]+)+(\/\S*)?$/.test(ref) ? 'https://' + ref : '';
+}
+export const shortRef = (ref) => String(ref || '').replace(/^https?:\/\/(www\.)?/i, '').replace(/\/$/, '');
+/** "1 create initiative, 1 research more, 1 add to an existing initiative", or "All handled." */
+export function sumLine(list) {
+  const open = list.filter(isOpen);
+  if (!open.length) return 'All handled.';
+  return ['create', 'research', 'attach'].map((k) => [k, open.filter((p) => p.kind === k).length]).filter((x) => x[1]).map(([k, c]) => c + ' ' + KIND_WORDS[k][0].toLowerCase()).join(', ');
+}
+
+/* ── open a scan document ── */
+const WANT_PANEL = new Set();
+export async function openScanDoc(ws, r, o = {}) {
+  if (!r || !r.path || r.written === false) { toast({ text: 'This report is not written yet. It opens when the scan ends.', tone: 'error' }); return; }
+  if (o.panel) WANT_PANEL.add(r.path);
+  const { openDocSheet } = await import('./c3-doc-sheet.js');
+  return openDocSheet({ ws, doc: { path: r.path, name: r.title || r.path, ty: 'Report', v: '', st: 'current', ini: '', iniName: 'Portfolio' }, mode: 'read' });
+}
+
+/** Open a board on the Initiatives tab (the way the Briefing's old card did: the address, then the shell's own go). */
+export function goBoard(board, tab = 'initiatives') {
+  try { const u = new URL(location.href); u.searchParams.set('init', 'board:' + encodeURIComponent(board) + ':' + tab); history.replaceState(history.state, '', u); } catch { /* no history */ }
+  return import('./c3-brief.js').then((m) => { if (m.hooks && m.hooks.go) m.hooks.go({ action: 'goinit' }); try { window.dispatchEvent(new CustomEvent('pmos:ini-go', { detail: { board, tab } })); } catch { /* no events */ } });
+}
+
+/* ── the panel ── */
+export function proposalsPanel({ ws, path, text }) {
+  const F = frontOf(text);
+  const S = { list: [], loaded: false, err: '', open: WANT_PANEL.delete(path), busy: new Set(), ui: {}, boards: [], choices: null, reportId: F.report || '', timer: null, seen: new Map() };
+  const root = el('section', { class: 'sc-next', 'aria-label': 'Proposed next steps', 'data-scan-next': '', hidden: true });
+  const st = (id) => (S.ui[id] ||= { mode: 'view', draft: {}, why: '', bad: false });
+  const name = (b) => (S.boards.find((x) => x.id === b) || { name: b || '' }).name;
+
+  async function load() {
+    let id = S.reportId;
+    if (!id) { const d = await getPortfolio(ws); const r = d.reports.find((x) => x.path === path); id = r ? r.id : ''; S.reportId = id; }
+    if (!id) { S.loaded = true; draw(); return; }
+    const r = await getReport(ws, id);
+    S.loaded = true; S.err = r.ok ? '' : r.error;
+    if (r.ok) {
+      for (const p of r.proposals) { const was = S.seen.get(p.id); if (was === 'running' && p.state === 'done' && p.kind === 'research') toast('Research finished. The follow-up document is in Documents, linked to this one.'); S.seen.set(p.id, p.state); }
+      S.list = r.proposals;
+    }
+    draw();
+    clearTimeout(S.timer);
+    if (S.list.some((p) => p.state === 'running')) S.timer = setTimeout(() => { if (root.isConnected) load(); }, 2500);
+  }
+  // The form draws once the boards and anchors are in, so a redraw never replaces a field the PM is typing in.
+  async function choices() { if (!S.choices) { try { S.choices = await loadChoices(ws); } catch { S.choices = { boards: [], anchors: [], initiatives: [] }; } } draw(); }
+  async function press(p, body, after) {
+    if (S.busy.has(p.id)) return null;
+    S.busy.add(p.id); draw();
+    const r = await postProposal(ws, { id: p.id, ...body });
+    S.busy.delete(p.id);
+    if (!r || r.ok === false) { toast({ text: 'That did not work: ' + ((r && r.error) || 'the workspace did not answer') + '.', tone: 'error', timeout: 6000 }); draw(); return null; }
+    if (after) after(r);
+    await load(); scanChanged();
+    return r;
+  }
+  const undo = (p, what = 'dismissal') => press(p, { action: 'undo' }, () => toast(what === 'dismissal' ? 'Undone. The proposal waits for you again.' : 'Your changes are undone. The proposal is as the agent filed it.'));
+  const valOf = (p, k) => { const d = st(p.id).draft; return k in d ? d[k] : p.fields[k]; };
+  async function approve(p) {
+    const u = st(p.id); const target = valOf(p, 'initiative');
+    if (u.mode === 'change' && Object.keys(u.draft).length) {
+      const c = await press(p, { action: 'change', fields: { ...u.draft } });
+      if (!c) return;
+    }
+    u.mode = 'view'; u.draft = {};
+    // Approve has no Undo: create makes a real initiative on the board and research starts runs. The toast says what happened.
+    await press(p, { action: 'approve' }, (r) => {
+      if (p.kind === 'create') { const o = outOf(r); const stage = o.stage || 'its first stage'; toast({ text: (o.id ? o.id + ' created' : 'Initiative created') + (o.board ? ' on ' + name(o.board) : '') + ' in ' + stage + ', with the report as evidence. The Initiative Driver starts on ' + stage + '.', timeout: 8000 }); }
+      else if (p.kind === 'attach') toast({ text: 'Attached to ' + (target || 'the initiative') + ' as evidence. Nothing else changed.', timeout: 8000 });
+      else toast('Research started. It reads public pages by topic only and sends nothing.');
+    });
+  }
+  async function dismiss(p) {
+    const u = st(p.id); const why = u.why.trim();
+    if (!why) { u.bad = true; draw(); const f = root.querySelector('[data-scan-f="why"][data-id="' + p.id + '"]'); if (f) f.focus(); return; }
+    u.mode = 'view'; u.bad = false;
+    await press(p, { action: 'dismiss', why }, () => toast({ text: 'Dismissed. Counted as a correction. The scan will not raise this again.', onAction: () => undo(p), timeout: 8000 }));
+  }
+  function jump(p) {
+    const sheet = root.closest('.sheet') || document;
+    const rb = sheet.querySelector('[data-dmode="read"]');
+    if (rb && rb.getAttribute('aria-pressed') !== 'true') rb.click();
+    setTimeout(() => {
+      const want = String(p.from || '').toLowerCase(); const head = want.split(':')[0].trim();
+      const nodes = [...sheet.querySelectorAll('h1,h2,h3,h4,h5,li,p,td,th')].filter((n) => !root.contains(n));
+      const hit = nodes.find((n) => want && n.textContent.toLowerCase().includes(want)) || nodes.find((n) => head && n.textContent.toLowerCase().includes(head));
+      if (hit) { hit.scrollIntoView({ block: 'center' }); hit.classList.remove('flash'); void hit.offsetWidth; hit.classList.add('flash'); }
+    }, 60);
+  }
+  async function openFollowUp(p) {
+    const d = await getPortfolio(ws);
+    const r = d.reports.find((x) => p.out && p.out.report && x.id === p.out.report) || d.reports.find((x) => x.parent === p.report) || d.reports.find((x) => x.parent && x.parent === S.reportId);
+    if (r) openScanDoc(ws, r, { panel: true }); else toast({ text: 'The follow-up document is not in the list yet.', tone: 'error' });
+  }
+
+  /* ── drawing ── */
+  const field = (label, ctl) => el('label', { class: 'sc-f' }, el('span', { class: 'dim mono' }, label), ctl);
+  const opts = (list, cur) => { const l = list.map((o) => (Array.isArray(o) ? o : [o, o])); if (cur && !l.some((o) => String(o[0]) === String(cur))) l.unshift([cur, cur]); return l.map(([v, t]) => el('option', { value: v, selected: String(v) === String(cur) }, t)); };
+  const input = (p, k, label, attrs) => el('input', { type: 'text', value: valOf(p, k) || '', 'aria-label': label, 'data-scan-f': k, 'data-id': p.id, oninput: (e) => { st(p.id).draft[k] = e.target.value; }, ...(attrs || {}) });
+  const area = (p, k, label) => { const a = el('textarea', { rows: '2', 'aria-label': label, 'data-scan-f': k, 'data-id': p.id, oninput: (e) => { st(p.id).draft[k] = e.target.value; } }); a.value = valOf(p, k) || ''; return a; };
+  const select = (p, k, label, list) => el('select', { 'aria-label': label, 'data-scan-f': k, 'data-id': p.id, onchange: (e) => { st(p.id).draft[k] = e.target.value; } }, ...opts(list, valOf(p, k)));
+
+  function details(p) {
+    const f = p.fields; const ch = st(p.id).mode === 'change'; const C = S.choices || { boards: [], anchors: [], initiatives: [] };
+    if (ch && !S.choices) return el('div', { class: 'sc-form', 'data-scan-form': p.id, 'aria-busy': 'true' }, el('span', { class: 'dim' }, 'Reading the boards and anchors…'));
+    if (p.kind === 'create') {
+      if (!ch) return kv([['Title', f.title], ['Board', [name(f.board) || 'the agent will choose', ' ', el('span', { class: 'tag' }, p.changed ? 'changed by you' : 'chosen by the agent')]], ['Lane', cap(f.lane)], ['Anchor', f.anchor],
+        ['Intent', f.intent], ['Starts in', "The first stage of the board's workflow, with this document as evidence"]], { 'data-scan-kv': 'create' });
+      return el('div', { class: 'sc-form', 'data-scan-form': p.id },
+        field('TITLE', input(p, 'title', 'Initiative title')),
+        el('div', { class: 'sc-row' }, field('BOARD', select(p, 'board', 'Board', (C.boards.length ? C.boards : [{ id: f.board, name: name(f.board) }]).map((b) => [b.id, b.name + (b.id === f.board && !p.changed ? ' (agent choice)' : '')]))),
+          field('LANE', select(p, 'lane', 'Lane', LANES))),
+        field('ANCHOR (A KEY RESULT OR A HEALTH BUDGET)', C.anchors.length ? select(p, 'anchor', 'Anchor', C.anchors.map((a) => [a.value, a.label])) : input(p, 'anchor', 'Anchor', { placeholder: 'A key result or health:<id>' })),
+        field('INTENT', area(p, 'intent', 'Intent')));
+    }
+    if (p.kind === 'research') {
+      const dp = DEPTHS.find((x) => x[0] === valOf(p, 'depth')) || DEPTHS[1];
+      if (!ch) return kv([['Question', f.question], ['Sources', 'Public pages on the topic. Nothing from the repository is sent.'], ['Depth', dp[1] + ': ' + dp[2]], ['Result', 'A new document in Documents, linked to this one']], { 'data-scan-kv': 'research' });
+      return el('div', { class: 'sc-form', 'data-scan-form': p.id }, field('QUESTION', area(p, 'question', 'Research question')),
+        field('DEPTH', select(p, 'depth', 'Depth', DEPTHS.map((x) => [x[0], x[1] + ': ' + x[2]]))), el('div', { class: 'dim sc-sm' }, 'Public pages on the topic. Nothing from the repository is sent.'));
+    }
+    if (!ch) return kv([['Attach to', f.initiative ? chip(icon('init', 'sm'), (C.initiatives.find((i) => i.id === f.initiative) ? f.initiative + ' ' + C.initiatives.find((i) => i.id === f.initiative).title : f.initiative)) : '—'], ['What it adds', p.why], ['Shown in', 'Evidence and research on that initiative']], { 'data-scan-kv': 'attach' });
+    return el('div', { class: 'sc-form', 'data-scan-form': p.id }, field('ATTACH TO', C.initiatives.length ? select(p, 'initiative', 'Initiative', C.initiatives.map((i) => [i.id, i.id + ' ' + i.title])) : input(p, 'initiative', 'Initiative', { placeholder: 'An initiative id, e.g. IDPF-12' })),
+      el('div', { class: 'dim sc-sm' }, p.why));
+  }
+  function acts(p) {
+    const u = st(p.id); const busy = S.busy.has(p.id); const ch = u.mode === 'change';
+    const verb = p.kind === 'research' ? 'Approve and start' : p.kind === 'attach' ? 'Approve and attach' : 'Approve';
+    if (u.mode === 'dismiss') {
+      const why = el('input', { type: 'text', value: u.why, placeholder: 'For example: we already decided this', 'aria-label': 'Reason for dismissing', 'data-scan-f': 'why', 'data-id': p.id, class: u.bad ? 'bad' : '',
+        oninput: (e) => { u.why = e.target.value; u.bad = false; }, onkeydown: (e) => { if (e.key === 'Enter' && !e.isComposing) { e.preventDefault(); dismiss(p); } } });
+      return el('div', { class: 'sc-form' }, field('WHY DO YOU DISMISS IT? ONE LINE', why),
+        u.bad ? el('div', { class: 'fold w', role: 'alert', 'data-scan-need-why': '' }, icon('alert', 'sm'), 'Say why. The reason is kept and the scan will not raise this again.') : null,
+        el('div', { class: 'dim sc-sm' }, 'A dismissal counts as a correction. The scan will not raise the same thing again.'),
+        el('div', { class: 'chips2' }, pbtn('primary', 'Dismiss', 'x', { 'data-scan-act': 'dismiss-ok', 'data-id': p.id, disabled: busy, onclick: () => dismiss(p) }), pbtn('ghost', 'Cancel', null, { 'data-scan-act': 'cancel', 'data-id': p.id, onclick: () => { u.mode = 'view'; u.bad = false; draw(); } })));
+    }
+    return el('div', { class: 'chips2' }, pbtn('primary', ch ? 'Approve with changes' : verb, 'check', { 'data-scan-act': 'approve', 'data-id': p.id, disabled: busy, onclick: () => approve(p) }),
+      p.changed ? pbtn('ghost', 'Undo my changes', null, { 'data-scan-act': 'undo-change', 'data-id': p.id, disabled: busy, onclick: () => { u.mode = 'view'; u.draft = {}; undo(p, 'change'); } }) : null,
+      ch ? pbtn('outline', 'Cancel', null, { 'data-scan-act': 'cancel', 'data-id': p.id, onclick: () => { u.mode = 'view'; u.draft = {}; draw(); } })
+        : pbtn('outline', 'Change first', 'edit', { 'data-scan-act': 'change', 'data-id': p.id, disabled: busy, onclick: () => { u.mode = 'change'; draw(); choices(); } }),
+      pbtn('ghost', 'Dismiss', 'x', { 'data-scan-act': 'dismiss', 'data-id': p.id, disabled: busy, onclick: () => { u.mode = 'dismiss'; draw(); const f = root.querySelector('[data-scan-f="why"][data-id="' + p.id + '"]'); if (f) f.focus(); } }));
+  }
+  function result(p) {
+    if (p.state === 'dismissed') return el('div', { class: 'fold', 'data-scan-result': 'dismissed' }, icon('x', 'sm'), ' Dismissed' + (p.reason ? ': ' + p.reason : '') + '. Counted as a correction. The scan will not raise this again. ', pbtn('ghost', 'Undo', null, { 'data-scan-act': 'undo', 'data-id': p.id, onclick: () => undo(p) }));
+    if (p.kind === 'research') return el('div', { class: 'fold a', 'data-scan-result': 'research' }, icon('check', 'sm'), ' Research finished. ', pbtn('primary', 'Open the follow-up document', 'out', { 'data-scan-act': 'follow-up', 'data-id': p.id, onclick: () => openFollowUp(p) }));
+    if (p.kind === 'attach') return el('div', { class: 'fold a', 'data-scan-result': 'attach' }, icon('check', 'sm'), ' Attached to ' + ((p.out && p.out.id) || valOf(p, 'initiative')) + ' as evidence.');
+    const o = p.out || {};
+    return el('div', { class: 'fold a', 'data-scan-result': 'create' }, icon('check', 'sm'), ' Created ' + (o.id || 'the initiative') + (o.board ? ' on ' + name(o.board) : '') + (o.stage ? ', in ' + o.stage + '. The Initiative Driver starts on ' + o.stage : '') + '. ',
+      o.board ? pbtn('outline', 'Open in the board', 'out', { 'data-scan-act': 'go-board', 'data-id': p.id, onclick: () => goBoard(o.board) }) : null);
+  }
+  function runBox(p) {
+    const steps = Array.isArray(p.steps) && p.steps.length ? p.steps : [{ label: 'Research is running', state: 'running' }];
+    return el('div', { class: 'sc-run', role: 'status', 'aria-label': 'Research running', 'data-scan-run': p.id },
+      el('ul', { class: 'chgl' }, ...steps.map((s) => el('li', null, icon(s.state === 'done' ? 'check' : s.state === 'failed' ? 'alert' : s.state === 'pending' || s.state === 'skipped' ? 'info' : 'clock', 'sm'), el('span', { class: s.state === 'pending' || s.state === 'skipped' ? 'dim' : '' }, s.label), el('span', { class: 'dim' }, s.state === 'done' ? 'done' : s.state === 'running' ? 'now' : s.state === 'failed' ? 'failed' : s.state === 'skipped' ? 'skipped' : '')))),
+      el('div', { class: 'chips2' }, pbtn('outline', 'Stop', 'x', { 'data-scan-act': 'rstop', 'data-id': p.id, onclick: async () => { const r = await postStop(ws); if (r && r.ok === false) toast({ text: 'Stop did not work: ' + (r.error || 'no answer') + '.', tone: 'error' }); else toast('Research stopped. Nothing was written.'); await load(); scanChanged(); } }),
+        el('span', { class: 'dim sc-sm' }, 'Reads public pages by topic only. Sends nothing.')));
+  }
+  function item(p) {
+    const fin = p.state === 'done' || p.state === 'dismissed';
+    const k = KIND_WORDS[p.kind];
+    return el('li', { class: 'sc-p', 'data-scan-prop': p.id, 'data-scan-kind': p.kind, 'data-scan-state': p.state },
+      el('div', { class: 'l1' }, el('span', { class: 'sc-ki' }, icon(k[1], 'sm')), el('b', null, p.title), el('span', { class: 'tag' + (p.kind === 'create' ? ' acc' : '') }, k[0])),
+      p.why ? el('p', null, p.why) : null,
+      p.from ? el('div', { class: 'chips' }, el('span', { class: 'dim mono sc-sm' }, 'FROM'), lk({ 'data-scan-act': 'jump', 'data-id': p.id, onclick: () => jump(p) }, icon('eye', 'sm'), p.from)) : null,
+      p.evidence.length ? el('div', { class: 'chips' }, el('span', { class: 'dim mono sc-sm' }, 'EVIDENCE'), ...p.evidence.map(evChip)) : null,
+      fin ? result(p) : p.state === 'running' ? runBox(p) : [details(p), acts(p)]);
+  }
+  function draw() {
+    const l = S.list;
+    root.hidden = !l.length;
+    if (!l.length) { put(root); return; }
+    const n = l.filter(isOpen).length;
+    put(root,
+      el('div', { class: 'hd' },
+        btn({ class: 'sc-tg', 'data-scan-act': 'panel', 'aria-expanded': String(S.open), onclick: () => { S.open = !S.open; draw(); } }, icon('next', 'sm'), el('b', null, 'Proposed next steps (' + n + ')'), el('span', { class: 'dim' }, sumLine(l))),
+        el('span', { class: 'tag acc' }, icon('spark', 'sm'), 'Nothing happens until you click')),
+      S.open ? el('ul', { class: 'sc-pl' }, ...l.map(item)) : null,
+      S.open ? el('div', { class: 'dim sc-sm' }, 'Approve, change or dismiss each one. A dismissal needs a reason and counts as a correction. The scan does not raise it again.') : null);
+  }
+
+  getBoards(ws).then((b) => { S.boards = b; draw(); });
+  load();
+  const off = onScanChange(() => { if (!root.isConnected) { off(); clearTimeout(S.timer); return; } load(); });
+  return root;
+}
+
+function evChip(e) {
+  const k = EV_IC[e.kind] ? e.kind : 'note';
+  const inner = [icon(EV_IC[k], 'sm'), el('span', { class: 'mono' }, shortRef(e.ref))];
+  const tip = (e.label ? e.label + '. ' : '') + EV_T[k];
+  const href = evidenceHref(e);
+  if (href) return el('a', { class: 'chip2 lk sc-link', href, target: '_blank', rel: 'noopener noreferrer', title: tip, 'data-scan-ev': k }, ...inner);
+  return el('span', { class: 'chip2', title: tip, 'data-scan-ev': k }, ...inner);
+}
+
+/* ── the sheet's hook: a panel for a document that says `source: scan:*`, one node per open sheet ── */
+const NODES = new WeakMap();
+docAbove.push(({ ws, doc, text, key }) => {
+  if (text == null || !/^scan:/.test(frontOf(text).source || '')) return null;
+  if (!NODES.has(key)) NODES.set(key, proposalsPanel({ ws, path: doc.path, text }));
+  return NODES.get(key);
+});