create-pmos 0.67.1 → 0.69.0

package/workspace/public/pm/primitives.js

@@ -25,6 +25,7 @@ export const SEL = Object.freeze({
   sprite: '.pmc-sprite',
   icon: 'svg.pmc-icon',
   btn: '.pmc-btn',
+  btnLabel: '.pmc-btn__label',
   primary: '.pmc-btn--primary',
   row: '.pmc-row',
   owed: '.pmc-row--owed',
@@ -256,16 +257,17 @@ function metaLine(cls, meta, signals) {
 
 /**
  * row({ title, titleIcon?, meta?: string[], signals?: Node[] (2 at most), lead?: Node[], trail?: Node[], onOpen?, openLabel?,
- *       owed?: boolean, done?: boolean, attrs? })
+ *       owed?: boolean, done?: boolean, compact?: boolean, attrs? })
+ * `compact` keeps the title and the meta line on one line each, cut with an ellipsis: for a narrow list such as the dock's.
  * One title, one meta line holding at most two signals. With `onOpen` the title and meta are one button (the row's
  * focus target); without it they are plain text.
  */
-export function row({ title, titleIcon, meta, signals, lead, trail, onOpen, openLabel, owed, done, proposed, attrs, openAttrs } = {}) {
+export function row({ title, titleIcon, meta, signals, lead, trail, onOpen, openLabel, owed, done, proposed, compact, attrs, openAttrs } = {}) {
   const body = [titleLine('pmc-row__title', title, titleIcon), metaLine('pmc-row__meta', meta, signals)];
   const main = onOpen
     ? el('button', { type: 'button', class: 'pmc-row__open', 'aria-label': openLabel || null, onClick: onOpen, ...(openAttrs || {}) }, body)
     : el('span', { class: 'pmc-row__main' }, body);
-  return el('div', withClass(cx('pmc-row', owed && 'pmc-row--owed', done && 'pmc-row--done', proposed && 'pmc-row--proposed'), attrs),
+  return el('div', withClass(cx('pmc-row', owed && 'pmc-row--owed', done && 'pmc-row--done', proposed && 'pmc-row--proposed', compact && 'pmc-row--compact'), attrs),
   lead && lead.length ? el('span', { class: 'pmc-row__lead' }, lead) : null,
   main,
   trail && trail.length ? el('span', { class: 'pmc-row__trail' }, trail) : null);
@@ -325,7 +327,8 @@ let openMenu = null;
 let lastMenuClose = { anchor: null, at: 0 };
 
 /**
- * menu({ anchor, items: [{ label, onSelect, danger?, sep? }], ariaLabel }): opens a popover menu under `anchor`.
+ * menu({ anchor, items: [{ label, onSelect, danger?, sep?, icon?, attrs? }], ariaLabel }): opens a popover menu under `anchor`.
+ * An item's `attrs` are data hooks for the suites (a class or a role is the menu's own).
  * Arrow keys move, Enter or Space chooses, Escape closes and returns focus to the anchor. Pressing the anchor again
  * closes it.
  */
@@ -349,6 +352,7 @@ export function menu({ anchor, items, ariaLabel } = {}) {
   for (const it of items || []) {
     if (it.sep) { node.appendChild(el('div', { class: 'pmc-menu__sep', role: 'separator' })); continue; }
     const b = el('button', {
+      ...(it.attrs || {}),
       type: 'button', role: 'menuitem', tabindex: '-1', class: cx('pmc-menu__item', it.danger && 'pmc-menu__item--danger'),
       onClick: (e) => { e.stopPropagation(); close(false); if (it.onSelect) it.onSelect(); },
     }, it.icon ? icon(it.icon) : null, el('span', null, it.label));

package/workspace/public/pm/state.js

@@ -129,6 +129,7 @@ function initialBase() {
     newSessIsolate: null, newSessError: null, newSessBusy: false,
     newSessBranches: null, preflightProfile: null, profiles: null, branchInfo: null,
     col0: true, col1: true, col2: true, scratchOpen: false, scratchText: '', copied: false,
+    dsFolded: {},               // the dock's session groups the PM folded (true) or opened (false), by group key — persisted
     tabsVertical: false,        // the cockpit's tabs as a vertical list instead of a strip — persisted, per browser
     /* The scratchpad drawer's height in px (panel-tabs.js). 96 is the prototype's literal and stays
      * the default; the PM can drag it, and the drag is clamped there rather than here — this store
@@ -238,6 +239,8 @@ const PERSIST = {
   scratchOpen: isBool,
   // the cockpit's tabs as a vertical list (true) or the horizontal strip (false, the default)
   tabsVertical: isBool,
+  // the dock's session groups, folded (true) or open (false) by the PM; a group with no entry takes its default
+  dsFolded: isFlagMap,
   /* A restored height is re-validated on the way IN, not merely on the way out: a corrupted or
    * hand-edited record must not be able to render a drawer with no textarea in it, or one taller
    * than any window it could be restored into. The upper bound here is deliberately generous (the

package/workspace/public/pm/tab-doc.js

@@ -32,6 +32,12 @@
  * 4-second session poll included — took a half-read document back to the top. `scrollPane` keeps one
  * element per tab and mode; see the block comment above it.
  *
+ * ── In live mode, a markdown file the PM can edit is edited in place (workspace-tabs-declutter) ─────────────
+ * The four modes are the prototype's, and the fixture keeps them. In live mode a markdown file the PM can write is
+ * drawn by doc-editor.js: read and edited in one surface, block by block, in the layout it is read in. `edit` stays as
+ * the whole file as markdown (the Markdown toggle) and `diff` as the Changes toggle; `raw` is the Source toggle of a
+ * file that cannot be edited. Beside the document, doc-rail.js holds its outline and its Connections.
+ *
  * ── What `view` renders it through ──────────────────────────────────────────────────────────
  * `markdown.js`, not `fixture.js`'s `mdParse`. The latter is a transcription of the design
  * prototype's four-branch stand-in (`# `/`## `/`- `/paragraph) pinned byte-for-byte by
@@ -43,7 +49,10 @@ import { state, setState, FIXTURE } from './state.js';
 import * as FX from './fixture.js';
 import { mdRender } from './markdown.js';
 import { openDoc } from './panel-initiatives.js';
-import { button } from './primitives.js';
+import { button, iconButton, menu } from './primitives.js';
+import { editorNode, disposeEditor, headsOf, goToBlock, isEditing } from './doc-editor.js';
+import { railNode, disposeRail, refreshGraph } from './doc-rail.js';
+import { copyChip, refreshCopies } from './doc-remote.js';
 
 /** `{{ expr }}` — one interpolated value in its own span, as the prototype's runtime emits it. */
 const iv = (v) => el('span', null, v === null || v === undefined ? '' : String(v));
@@ -165,6 +174,8 @@ function save(tab, text) {
       const final = out && typeof out.text === 'string' ? out.text : text;
       disk.set(path, final);
       claims.delete(wsOf(tab));          // the consistency record may move with the file; read it again
+      refreshCopies(wsOf(tab));          // …and so may the copy's state, and the file's ties
+      refreshGraph(wsOf(tab), tab.path);
       commit(final);
     },
     (e) => { saveErr.set(path, (e && e.message) || 'could not reach the workspace server'); setState({}); },
@@ -388,35 +399,26 @@ function editBox(tab) {
 /** Release what a closed doc tab held. Called by panel-tabs.js when the tab goes away. */
 export function disposeDoc(id) {
   boxes.delete(id);
+  docBars.delete(id);
   normNote.delete(id);
   frames.delete(id);
   scrollers.delete(id);
   running.delete(id);         // the grant belonged to this open document, and it is closed
-  alignOpen.delete(id);
-  alignSkip.delete(id);
-  alignNodes.delete(id);
+  disposeEditor(id);
+  disposeRail(id);
+  places.delete(id);
+  railHidden.delete(id);
 }
 
 
-/* ── the Alignment drawer (workspace-cockpit-nav Run 3, ViewAlignment.dc.html) ──────────────────
+/* ── the findings beside a document (was the Alignment drawer) ─────────────────────────────────────────────────────
  *
- * The board shows a drawer beside a document: the other documents with a CONCRETE tie to this one,
- * and what to do about each. Everything in it here is read from the consistency record the Validate
- * view already reads (`/api/claims`): which files a document is compared with, and which findings
- * name a source. Nothing is guessed from similarity, and nothing is drafted:
- *   · a tie is drawn only from `compared_with` and a finding's `source` — never from wording;
- *   · the board's "Apply" (a proposed edit to the other file, with its diff) has no backing — PMOS
- *     drafts no edit to another file — so it is not drawn, and the drawer says so;
- *   · a file the last check did not read is said to be unread, not shown as clean.
- * The drawer is closed by default, and closed it adds nothing to the pane: the pane is exactly
- * [mode bar, body] as before. Open, it is a third child laid over the right of the pane, and the
- * mode bar and body give it room with a margin. No node is re-parented, so a textarea keeps its
- * caret, a scroller its offset and a sandboxed frame its document. */
-const alignOpen = new Set();      // tab ids whose drawer is open
-const alignSkip = new Map();      // tab id -> Set of rels the PM skipped for this tab
+ * The Alignment drawer (workspace-cockpit-nav Run 3) listed the documents with a concrete tie to this one, from the
+ * consistency record the Validate view reads (`/api/claims`). The Connections rail (doc-rail.js) now draws every stated
+ * tie, so what the record adds is its FINDINGS: the ones in this file, and the ones in another file that name this
+ * file as their source. A tie is still never drawn from wording, and a file the last check did not read is not shown as
+ * clean: it has no findings to show, and the rail says only what was read. */
 const claims = new Map();         // ws -> { state: 'loading' | 'ok' | 'error', data?, error? }
-const ALIGN_W = 'min(420px, 50%)';
-const alignNodes = new Map();     // tab id -> the drawer element, kept so its scroll survives a repaint
 
 function readClaims(ws) {
   let c = claims.get(ws);
@@ -430,132 +432,24 @@ function readClaims(ws) {
   return c;
 }
 
-/** Whether a tab can have the drawer at all: a file in the checked-out tree, in real mode. */
-const canAlign = (tab) => !FIXTURE && !tab.guide && !tab.ref && !isReference(tab.path);
-
-const A_LBL = 'font-family:var(--mono);font-size:10px;font-weight:500;letter-spacing:.1em;text-transform:uppercase;color:var(--muted-foreground)';
-const A_NOTE = 'font-size:12px;line-height:1.5;color:var(--muted-foreground)';
-const A_BADGE = 'font-family:var(--sans);font-size:11px;font-weight:500;border:1px solid var(--border);border-radius:999px;padding:0 8px;line-height:18px;white-space:nowrap;color:var(--foreground)';
-const A_CARD = 'border:1px solid var(--border);background:var(--background);border-radius:10px;padding:12px 14px;display:flex;flex-direction:column;gap:8px';
-const A_BTN = 'font-family:var(--sans);font-size:12.5px;font-weight:500;padding:0 12px;min-height:30px;border-radius:8px;background:transparent;border:1px solid var(--input);color:var(--foreground)';
-const STATUS_TONE = { contradicted: 'var(--destructive)', stale: 'var(--warning)', suspected: 'var(--muted-foreground)', undecided: 'var(--muted-foreground)' };
-const STATUS_WORD = { contradicted: 'contradicted', stale: 'stale', suspected: 'suspected by Jev', undecided: 'worth a look' };
-
-const statusBadge = (st) => el('span', {
-  style: A_BADGE + ';border-color:transparent;color:' + (STATUS_TONE[st] || 'var(--muted-foreground)')
-    + ';background:color-mix(in oklab, ' + (STATUS_TONE[st] || 'var(--muted-foreground)') + ' 14%, transparent)',
-}, iv(STATUS_WORD[st] || st));
-
-/**
- * The documents tied to `rel`, each with the ties that put it there. Three kinds, all read:
- *   · this file is compared with it        (this file's `compared_with`)
- *   · it is compared with this file        (its `compared_with` names this file)
- *   · a finding in it names this file      (a finding whose `source` is this file)
- */
-function tiesFor(rel, docs) {
-  const out = new Map();
-  const add = (r, tie, finding) => {
-    if (!r || r === rel) return;
-    let c = out.get(r);
-    if (!c) { c = { rel: r, ties: new Set(), findings: [] }; out.set(r, c); }
-    c.ties.add(tie);
-    if (finding) c.findings.push(finding);
-  };
-  const self = docs.find((x) => x.rel === rel) || null;
-  if (self) for (const r of self.compared_with || []) add(r, 'this file checks against it');
+/** The findings that concern `rel`: its own, then each other file's finding whose source is `rel` (with that file). */
+function findingsFor(ws, rel) {
+  const c = readClaims(ws);
+  if (c.state !== 'ok') return [];
+  const docs = Array.isArray(c.data && c.data.docs) ? c.data.docs : [];
+  const out = [];
+  const self = docs.find((x) => x.rel === rel);
+  if (self) for (const f of self.findings || []) out.push({ status: f.status, sentence: f.sentence });
   for (const x of docs) {
     if (x.rel === rel) continue;
-    if ((x.compared_with || []).includes(rel)) add(x.rel, 'checks against this file');
-    for (const f of x.findings || []) if (f && f.source === rel) add(x.rel, 'a finding names this file', f);
-  }
-  return { self, list: [...out.values()] };
-}
-
-function alignDrawer(tab) {
-  const ws = wsOf(tab);
-  const rel = String(tab.path || '');
-  const close = () => { alignOpen.delete(tab.id); setState({}); };
-  const kids = [
-    el('div', { style: 'display:flex;align-items:center;justify-content:space-between;gap:8px' },
-      el('span', { style: 'font-weight:600;font-size:15px;font-family:var(--sans)', 'data-r29': 'align-title' }, 'Alignment'),
-      el('button', { onClick: close, 'data-r29': 'align-close', 'aria-label': 'close alignment', title: 'close the drawer',
-        style: 'background:transparent;border:0;color:var(--muted-foreground);font-size:15px;padding:2px 6px', hover: 'color:var(--foreground)' }, '⟩')),
-    el('div', { style: A_NOTE, 'data-r29': 'align-rule' }, 'Only documents with a concrete tie to this file are listed. No similarity guesses.'),
-  ];
-  const c = readClaims(ws);
-  if (c.state === 'loading') {
-    kids.push(el('div', { style: A_NOTE, 'data-r29': 'align-status', 'data-state': 'loading' }, 'Reading the consistency record…'));
-  } else if (c.state === 'error') {
-    kids.push(el('div', { style: A_NOTE + ';color:var(--destructive)', 'data-r29': 'align-status', 'data-state': 'error' },
-      iv('The consistency record could not be read: ' + c.error + '. Nothing is listed.')));
-  } else {
-    const d = c.data || {};
-    const docs = Array.isArray(d.docs) ? d.docs : [];
-    const openValidate = () => import('./panel-cockpit.js').then((m) => m.openView('validate')).catch(() => {});
-    if (d.verdict === 'not-checked' || !docs.length) {
-      kids.push(el('div', { style: A_NOTE, 'data-r29': 'align-status', 'data-state': 'not-checked' },
-        'This repository has not been checked yet, so no tie is known. Open Validate and press “check now”.'));
-      kids.push(el('div', null, el('button', { style: A_BTN, hover: 'border-color:var(--ring)', onClick: openValidate, 'data-r29': 'align-validate' }, 'open Validate')));
-    } else {
-      const { self, list } = tiesFor(rel, docs);
-      const skipped = alignSkip.get(tab.id) || new Set();
-      const shown = list.filter((x) => !skipped.has(x.rel));
-      kids.push(el('div', { style: A_NOTE, 'data-r29': 'align-status', 'data-state': self ? 'read' : 'unread' },
-        iv(self
-          ? 'This file: ' + (self.classified ? self.type : 'not classified') + ' · ' + self.verified + ' statement(s) verified'
-            + (self.findings.length ? ' · ' + self.findings.length + ' finding(s)' : ' · no open findings')
-          : 'The last check did not read this file, so its own findings are unknown. Ties from other files are still listed.')));
-      if (self && self.findings.length) {
-        kids.push(el('div', { style: A_LBL }, 'findings in this file'));
-        kids.push(el('div', { style: 'display:flex;flex-direction:column;gap:6px', 'data-r29': 'align-self' },
-          self.findings.map((f) => el('div', { 'data-r29': 'align-finding', 'data-status': f.status, style: 'display:flex;flex-direction:column;gap:3px' },
-            el('span', null, statusBadge(f.status)),
-            el('span', { style: 'font-size:12px;line-height:1.5;color:var(--foreground)' }, iv(f.sentence))))));
-      }
-      if (state.savedDocs[docKey(tab)] != null && list.length) {
-        kids.push(el('div', { style: A_NOTE + ';color:var(--warning)', 'data-r29': 'align-saved' },
-          iv('Saved. ' + list.length + ' other document' + (list.length === 1 ? '' : 's') + ' may now disagree with this change.')));
-      }
-      kids.push(el('div', { style: A_LBL }, iv('tied documents · ' + list.length)));
-      if (!list.length) kids.push(el('div', { style: A_NOTE, 'data-r29': 'align-none' }, 'No other document has a concrete tie to this file.'));
-      for (const x of shown) {
-        kids.push(el('div', { style: A_CARD, 'data-r29': 'align-cand', 'data-rel': x.rel },
-          el('b', { style: 'font-family:var(--mono);font-size:12px;font-weight:600;overflow-wrap:anywhere' }, iv(x.rel)),
-          el('div', { style: 'display:flex;gap:6px;flex-wrap:wrap' }, [...x.ties].map((t) => el('span', { style: A_BADGE, 'data-r29': 'align-tie' }, iv(t)))),
-          x.findings.map((f) => el('div', { style: 'display:flex;flex-direction:column;gap:3px' },
-            el('span', null, statusBadge(f.status)),
-            el('span', { style: A_NOTE }, iv(f.sentence)))),
-          el('div', { style: 'display:flex;gap:6px' },
-            el('button', { style: A_BTN, hover: 'border-color:var(--ring)', 'data-r29': 'align-open', onClick: () => openDoc(tab.slug, x.rel, 'FILE', tab.ws ? { ws: tab.ws, branch: tab.branch || null, linked: true } : undefined) }, 'Open to edit'),
-            el('button', { style: A_BTN, hover: 'border-color:var(--ring)', 'data-r29': 'align-skip',
-              onClick: () => { const s2 = new Set(skipped); s2.add(x.rel); alignSkip.set(tab.id, s2); setState({}); } }, 'Skip'))));
-      }
-      if (skipped.size) {
-        kids.push(el('button', { style: A_BTN + ';align-self:flex-start', hover: 'border-color:var(--ring)', 'data-r29': 'align-unskip',
-          onClick: () => { alignSkip.delete(tab.id); setState({}); } }, iv('show ' + skipped.size + ' skipped')));
-      }
-    }
-    kids.push(el('div', { style: 'display:flex;gap:6px' },
-      el('button', { style: A_BTN, hover: 'border-color:var(--ring)', 'data-r29': 'align-reread', onClick: () => { claims.delete(ws); setState({}); } }, 're-read')));
+    for (const f of x.findings || []) if (f && f.source === rel) out.push({ status: f.status, sentence: f.sentence, rel: x.rel });
   }
-  kids.push(el('div', { style: A_NOTE, 'data-r29': 'align-foot' },
-    'Ties come from the last consistency check. PMOS drafts no edit to another file: open it to change it. Git keeps the history.'));
-  /* One node per tab, kept like the scrollers above, so a repaint does not take the drawer's own
-   * scroll back to the top. */
-  let node = alignNodes.get(tab.id);
-  if (!node) { node = makeDrawerNode(); alignNodes.set(tab.id, node); }
-  setChildren(node, kids);
-  return node;
+  return out;
 }
 
-function makeDrawerNode() {
-  return el('div', {
-    'data-r29': 'align-drawer', 'data-board': 'alignment',
-    style: 'position:absolute;top:0;right:0;bottom:0;width:' + ALIGN_W + ';box-sizing:border-box;overflow-y:auto;'
-      + 'border-left:1px solid var(--border);background:var(--sidebar);color:var(--foreground);padding:16px;'
-      + 'display:flex;flex-direction:column;gap:12px;font-family:var(--sans);font-size:13px;line-height:1.5',
-  });
-}
+/** Whether a tab can have the rail at all: a file in the checked-out tree, in real mode. */
+const canRail = (tab) => !FIXTURE && !tab.guide && !tab.ref && !isReference(tab.path);
+const railHidden = new Set();     // tab ids whose outline and connections the PM put away
 
 /* ── mount ─────────────────────────────────────────────────────────────────────────────────── */
 
@@ -724,7 +618,10 @@ export function mountDoc(host, tab) {
   const raw = docText(tab);
   const text = state.docEdits[docKey(tab)] ?? raw;
   const nonMd = !FIXTURE && isSourcePath(tab.path);   // file-viewer-any-text: read-only, shown as source
-  const dm = ((tab.readonly || nonMd) && (state.docModes[tab.id] === 'edit' || state.docModes[tab.id] === 'diff')) ? 'view' : (state.docModes[tab.id] ?? 'view');
+  const writable = canWrite(tab, nonMd);
+  let dm = ((tab.readonly || nonMd) && (state.docModes[tab.id] === 'edit' || state.docModes[tab.id] === 'diff')) ? 'view' : (state.docModes[tab.id] ?? 'view');
+  if (writable && dm === 'raw') dm = 'view';          // in place, the file you can write IS its source: no read-only copy of it
+  if (!FIXTURE && !writable && (dm === 'edit' || dm === 'diff')) dm = 'view';   // only a markdown file can be saved
   const dirty = text !== raw;
   const err = saveErr.get(docKey(tab));
 
@@ -780,14 +677,7 @@ export function mountDoc(host, tab) {
   const canNormalize = !!(norm && typeof norm.normalize === 'function')
     && !isHtmlDoc(tab.path) && !isReference(tab.path) && !unread.has(docKey(tab)) && !nonMd;
   const normBtn = canNormalize ? el('button', {
-    onClick: () => {
-      const r = norm.normalize(text);
-      normNote.set(tab.id, r.changed
-        ? r.joins + ' line(s) joined' + (r.blanks ? ', ' + r.blanks + ' blank inserted' : '')
-        : 'already normalized — every paragraph is one line');
-      if (!r.changed) { setState({}); return; }
-      setState((s) => ({ docEdits: { ...s.docEdits, [docKey(tab)]: r.text } }));
-    },
+    onClick: () => normalizeBuffer(tab, norm),
     style: 'margin-left:8px;font-family:var(--mono);font-size:10.5px;padding:4px 10px;min-height:26px;background:var(--secondary);border:1px solid var(--border);color:var(--muted-foreground)',
     hover: 'border-color:var(--ring)',
     title: 'Join hard-wrapped paragraphs into one line each — what a Jira issue, a Google Doc or any'
@@ -812,21 +702,19 @@ export function mountDoc(host, tab) {
       hover: 'color:var(--foreground)', 'data-r1': 'measure',
       title: narrowOf(tab) ? 'use the full width of the tab' : 'limit lines to a 72-character reading measure',
     }, iv(narrowOf(tab) ? '↔ full width' : '⇥ 72ch')),
-    canAlign(tab) ? el('button', {
-      onClick: () => {
-        if (alignOpen.has(tab.id)) alignOpen.delete(tab.id);
-        else { alignOpen.add(tab.id); claims.delete(wsOf(tab)); }    // opening reads the record afresh
-        setState({});
-      },
-      style: 'margin-left:8px;font-family:var(--mono);font-size:10.5px;padding:4px 10px;min-height:26px;background:'
-        + (alignOpen.has(tab.id) ? 'var(--secondary)' : 'transparent') + ';border:1px solid '
-        + (alignOpen.has(tab.id) ? 'var(--brand)' : 'var(--border)') + ';color:var(--foreground)',
-      hover: 'border-color:var(--ring)', 'data-r29': 'align-toggle', 'data-open': alignOpen.has(tab.id) ? 'yes' : 'no',
-      title: 'Show the documents with a concrete tie to this one, from the last consistency check.',
-    }, 'alignment') : null,
     el('span', { style: 'margin-left:auto;font-family:var(--mono);font-size:10px;color:' + dirtyColor }, iv(dirtyLabel)),
   );
 
+  /* Live mode draws the bar from the design system (workspace-tabs-declutter): the four modes as one segmented control,
+   * the save state beside them, save and revert, and one ⋯ menu for what is used now and then (the reading width,
+   * normalize, alignment). Run scripts stays on the bar while a page can run: it grants a privilege, so its state is
+   * never one click away. The fixture keeps the prototype's bar above, which the parity suites pin. */
+  const bar = FIXTURE ? modeBar : docBar(tab, {
+    dm, readonly, writable, dirty, err, text, asPage, live, canNormalize, norm,
+    statusText: dirtyLabel,
+    tone: err ? 'error' : (dirty ? 'dirty' : 'clean'),
+  });
+
   let body;
   if (dm === 'raw') body = rawBody(tab, text);
   else if (dm === 'diff') body = diffBody(tab, raw, text, dirty);
@@ -839,16 +727,133 @@ export function mountDoc(host, tab) {
     if (body.defaultValue !== text) body.defaultValue = text;
     if (body.value !== text) body.value = text;
   } else if (!FIXTURE && (extOfPath(tab.path) === 'csv' || extOfPath(tab.path) === 'tsv')) body = gridBody(tab, text);
+  else if (writable) body = inPlace(tab, text, raw);
   else body = asPage ? htmlFrame(tab, text, live) : (nonMd && !unread.has(docKey(tab)) ? sourceBody(tab, text) : viewBody(tab, text));
 
-  /* The drawer, when open, lies over the right of the pane; the bar and the body give it room. The
-   * margin is written on every paint so a closed drawer leaves no gap behind on a kept node. */
-  const drawerOn = canAlign(tab) && alignOpen.has(tab.id);
-  host.style.position = drawerOn ? 'relative' : '';
-  modeBar.style.marginRight = drawerOn ? ALIGN_W : '';
-  body.style.marginRight = drawerOn ? ALIGN_W : '';
-  setChildren(host, drawerOn ? [modeBar, body, alignDrawer(tab)] : [modeBar, body]);
+  setChildren(host, [bar, body]);
   return host;
 }
 
+/* A markdown file the PM can write, in live mode: edited in place. A guide page ships with the app, a file from git is
+ * evidence, a reference names someone else's record, and a file that could not be read is a stub: none of those. */
+function canWrite(tab, nonMd) {
+  if (FIXTURE || tab.readonly || tab.guide || tab.ref || nonMd || isReference(tab.path) || isHtmlDoc(tab.path)) return false;
+  const PK = typeof window !== 'undefined' ? window.PreviewKind : null;
+  if (!PK || typeof PK.previewKind !== 'function' || PK.previewKind(String(tab.path || '')) !== 'markdown') return false;
+  const k = docKey(tab);
+  return state.savedDocs[k] != null || (disk.has(k) && !unread.has(k));
+}
+
+/* The in-place surface: the editor and, beside it, the rail. One scrolling node per tab, kept like the scrollers above,
+ * so neither a repaint nor a keystroke moves the page. */
+const places = new Map();     // tab id -> { node, grid }
+function inPlace(tab, text, raw) {
+  let pl = places.get(tab.id);
+  if (!pl) {
+    const grid = el('div', { class: 'fr-ed__grid' });
+    pl = { node: el('div', { class: 'fr-ed', 'data-ed': 'scroll' }, grid), grid };
+    places.set(tab.id, pl);
+  }
+  const ws = wsOf(tab);
+  const main = editorNode(tab, {
+    text, ctx: linkCtx(tab),
+    onChange: (t) => { saveErr.delete(docKey(tab)); setState((s) => { const de = { ...s.docEdits }; if (t === raw) delete de[docKey(tab)]; else de[docKey(tab)] = t; return { docEdits: de }; }); },
+    onSave: () => { const cur = state.docEdits[docKey(tab)]; if (cur != null && cur !== raw) save(tab, cur); },
+  });
+  const showRail = canRail(tab) && !railHidden.has(tab.id);
+  const rail = showRail ? railNode(tab, {
+    ws, rel: String(tab.path || ''), heads: headsOf(tab.id), findings: findingsFor(ws, String(tab.path || '')),
+    onGoto: (i) => goToBlock(tab.id, i),
+    onOpen: (rel) => openDoc(tab.slug, rel, 'FILE', tab.ws ? { ws: tab.ws, branch: tab.branch || null, linked: true } : undefined),
+  }) : null;
+  pl.grid.setAttribute('data-measure', narrowOf(tab) ? '72ch' : 'full');
+  pl.grid.toggleAttribute('data-rail', !!rail);
+  setChildren(pl.grid, [main, rail]);
+  if (isEditing(tab.id)) pl.node.setAttribute('data-editing', ''); else pl.node.removeAttribute('data-editing');
+  return pl.node;
+}
+
+/** normalize: the buffer's paragraphs joined into one line each. The buffer, never the file; a clean document says so. */
+function normalizeBuffer(tab, norm) {
+  const raw = docText(tab);
+  const text = state.docEdits[docKey(tab)] ?? raw;
+  const r = norm.normalize(text);
+  normNote.set(tab.id, r.changed
+    ? r.joins + ' line(s) joined' + (r.blanks ? ', ' + r.blanks + ' blank inserted' : '')
+    : 'already normalized — every paragraph is one line');
+  if (!r.changed) { setState({}); return; }
+  setState((s) => ({ docEdits: { ...s.docEdits, [docKey(tab)]: r.text } }));
+}
+
+/* ── the document bar in live mode ──────────────────────────────────────────────────────────────────────────────────
+ * One bar per tab, kept so the ⋯ control keeps its focus across a repaint; its children are rebuilt. The bar says whether
+ * the file is saved and what its copy holds, and carries what changes the view: Changes while there is something to
+ * compare, the whole file as markdown (or, for a file that cannot be edited, its source), and one ⋯ menu for what is used
+ * now and then. Run scripts stays on the bar while a page can run: it grants a privilege, so its state is never one
+ * click away. Every action is the prototype's: the same state keys, the same buffer, the same save path. */
+const docBars = new Map();     // tab id -> { node, more }
+
+function docBar(tab, o) {
+  let kept = docBars.get(tab.id);
+  if (!kept) {
+    const more = iconButton({ icon: 'ellipsis', ariaLabel: 'Document options', size: 'sm', attrs: { 'data-doc': 'more', class: 'fr-doc-bar__more' },
+      onClick: (e) => menu({ anchor: e.currentTarget, ariaLabel: 'Document options', items: docMenu(tab) }) });
+    kept = { node: el('div', { class: 'fr-doc-bar', 'data-doc': 'bar' }), more };
+    docBars.set(tab.id, kept);
+  }
+  const setMode = (m) => setState((s) => ({ docModes: { ...s.docModes, [tab.id]: m } }));
+  const status = el('span', { class: 'fr-doc-bar__status', 'data-doc': 'status', 'data-tone': o.tone }, o.statusText);
+  const copy = canRail(tab) && !o.readonly ? copyChip(wsOf(tab), String(tab.path || '')) : null;
+  const inDiff = o.dm === 'diff';
+  const changes = o.writable && (o.dirty || inDiff) ? button({
+    label: 'changes', variant: inDiff ? 'outline' : 'ghost', size: 'sm', icon: 'git-compare',
+    attrs: { 'data-doc': 'changes', 'aria-pressed': inDiff ? 'true' : 'false', title: 'What saving would change on disk, line by line' },
+    onClick: () => setMode(inDiff ? 'view' : 'diff'),
+  }) : null;
+  const srcMode = o.writable ? 'edit' : 'raw';
+  const inSrc = o.dm === srcMode;
+  const source = button({
+    label: o.writable ? 'markdown' : 'source', variant: inSrc ? 'outline' : 'ghost', size: 'sm', icon: 'file-code',
+    attrs: { 'data-doc': 'source', 'aria-pressed': inSrc ? 'true' : 'false',
+      title: o.writable ? 'Edit the whole file as markdown' : 'Show the file as it is written' },
+    onClick: () => setMode(inSrc ? 'view' : srcMode),
+  });
+  const saveB = o.dirty ? button({ label: 'save', variant: 'primary', size: 'sm', attrs: { 'data-doc': 'save', title: 'Save (Ctrl or ⌘ S)' }, onClick: () => save(tab, o.text) }) : null;
+  const revertB = o.dirty ? button({ label: 'revert', variant: 'ghost', size: 'sm', attrs: { 'data-doc': 'revert' }, onClick: () => revert(tab) }) : null;
+  const run = o.asPage && o.dm === 'view' ? button({
+    label: o.live ? 'scripts running — stop' : 'run scripts', variant: o.live ? 'danger' : 'outline', size: 'sm',
+    onClick: () => { if (o.live) running.delete(tab.id); else running.add(tab.id); setState({}); },
+    attrs: { 'data-doc': 'run', 'aria-pressed': o.live ? 'true' : 'false',
+      title: o.live
+        ? 'This document is running its own scripts, in a frame with no origin and no network. Stop discards it.'
+        : "Run this document's own scripts. It stays sandboxed: no origin, no network, nothing loaded from anywhere." },
+  }) : null;
+  const hasMenu = docMenu(tab).length > 0;
+  setChildren(kept.node, [status, copy, el('span', { class: 'fr-doc-bar__end' }, run, changes, revertB, saveB, source, hasMenu ? kept.more : null)]);
+  return kept.node;
+}
+
+/** The ⋯ menu's items, read afresh when it opens, so each one says what choosing it will do now. */
+function docMenu(tab) {
+  const items = [];
+  const dm = state.docModes[tab.id] ?? 'view';
+  if (dm === 'view' || dm === 'raw') {
+    const narrow = narrowOf(tab);
+    items.push({ label: narrow ? 'Use the full width' : 'Limit lines to 72 characters', icon: 'arrow-left-right', attrs: { 'data-r1': 'measure' },
+      onSelect: () => setState((s) => ({ docNarrow: { ...(s.docNarrow || {}), [tab.id]: !narrowOf(tab) } })) });
+  }
+  const norm = typeof window !== 'undefined' ? window.MdNormalize : null;
+  const nonMd = isSourcePath(tab.path);
+  if (norm && typeof norm.normalize === 'function' && !tab.readonly && !isHtmlDoc(tab.path) && !isReference(tab.path) && !unread.has(docKey(tab)) && !nonMd) {
+    items.push({ label: 'Normalize line breaks', icon: 'refresh-cw', attrs: { 'data-doc': 'normalize', title: 'Join hard-wrapped paragraphs into one line each. Writes the buffer, not the file: read it in Changes, then save.' },
+      onSelect: () => normalizeBuffer(tab, norm) });
+  }
+  if (canRail(tab) && canWrite(tab, nonMd)) {
+    const hidden = railHidden.has(tab.id);
+    items.push({ label: hidden ? 'Show the outline and connections' : 'Hide the outline and connections', icon: 'share-2', attrs: { 'data-doc': 'rail' },
+      onSelect: () => { if (hidden) railHidden.delete(tab.id); else railHidden.add(tab.id); setState({}); } });
+  }
+  return items;
+}
+
 export default mountDoc;

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

@@ -12,6 +12,8 @@
  * picks the week. The lens switch says which answer the cells show; the agenda under the month always shows them all.
  * The calendar memory changes only through the morning-brief session's brief. The one write here is the PM's key-meeting
  * mark (POST /api/proactive/agenda/mark): this time or every time, key or not key, over what the calendar says.
+ * A meeting's detail shows its meeting notes, and an event row a notes chip, from pm/notes-links.js (meeting-notes Run 4);
+ * Take notes writes there.
  */
 
 import { peopleLinks } from './people-link.js';
@@ -19,6 +21,7 @@ import { el } from './dom.js';
 import { button, iconButton, badge, tabs, toast } from './primitives.js';
 import { pmGet, pmPost } from './http.js';
 import { COPY } from './today-copy.js';
+import { notesBlock, notesFor } from './notes-links.js';
 
 const A = COPY.day.ag;
 const DAY0 = 9 * 60;
@@ -203,7 +206,8 @@ function eventRow(h, e) {
   const chips = el('span', { class: 'td-day__chips' },
     e.imp ? badge({ text: A.star, tone: 'outline', attrs: { title: A.means } }) : null,
     e.prep ? el('span', { class: 'td-ag__ready', 'data-ag-ready': e.ready || 'ok' }, A.readyBadge(e.prep_done || 0, e.prep.length)) : null,
-    e.ended && !e.notes && (e.imp || e.kind === 'one') ? el('span', { class: 'td-ag__nonotes' }, A.noNotes(1)) : null);
+    notesFor(e).length ? badge({ text: 'notes', tone: 'outline', attrs: { 'data-ag-notes': e.id, title: 'Meeting notes are linked to this event' } })
+      : e.ended && !e.notes && (e.imp || e.kind === 'one') ? el('span', { class: 'td-ag__nonotes' }, A.noNotes(1)) : null);
   return h.rowBtn(type, e.id, { lead: e.time, title: e.title, meta: A.kindWord[e.kind] + (e.attendees ? ' · ' + A.people(e.attendees) : ''), trail: chips },
     { 'data-past': e.ended ? 'true' : null, 'data-ag-event': e.id });
 }
@@ -327,5 +331,6 @@ export function meetingDetail(ctx, id, h) {
     e.ended ? el('div', { class: 'td-day__phase', 'data-ag': 'notes' }, el('h4', null, A.afterNotes),
       e.notes ? el('p', null, e.notes) : el('p', { class: 'td-day__note' }, A.noNotesYet),
       e.open && e.open.length ? [el('h4', null, A.openLines), el('ul', { class: 'td-day__chk' }, ...e.open.map((x) => el('li', null, x)))] : null) : null,
+    notesBlock(e, { ws: ctx && ctx.ws }),
   ];
 }

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

@@ -10,6 +10,8 @@
  *   - on the left, the calendar (with a line at the current time), the jobs (needs you, agent working, done), the goals
  *     and the mentions with the watched channels, projects and spaces;
  *   - on the right, the detail of what is selected: a meeting, a job, a goal, a mention, a step, the sources or a place.
+ *     A meeting's detail ends with its meeting notes: the summary and Open notes, or Take notes (pm/notes-links.js,
+ *     meeting-notes Run 4).
  * The presses go to the routes that own them: the goals route (add, done, drop, reopen, remove), /goals/plan (Prepare my
  * day), /day/decide (approve, revise, run again), /day/check (Check now) and the settings route (sources, levels, the
  * daytime check, websites). Nothing here sends anything outward: the agent sessions do that, after the PM approves.
@@ -30,6 +32,7 @@ import { COPY } from './today-copy.js';
 import { goalRows, goalAdd, goalDetail, addGoal, goalsSig } from './today-goals.js';
 import { peopleLinks } from './people-link.js';
 import { agendaPanel, meetingDetail, memoryBlock, refreshAgenda, agendaSig, onAgenda } from './today-agenda.js';
+import { notesBlock, onNotes } from './notes-links.js';
 
 const D = COPY.day;
 const SLOW_MS = 30000;
@@ -57,6 +60,7 @@ const ui = {
   revising: new Set(), notes: new Map(), siteDraft: '', placeDraft: {}, busy: new Set(), scroll: false,
 };
 let rerender = () => {};
+let notesSub = null;         // the redraw when the meeting notes list is read (pm/notes-links.js)
 let timer = null;
 
 /* ── the read ─────────────────────────────────────────────────────────────────────────────────────────────────── */
@@ -566,6 +570,7 @@ function eventDetail(ctx, e) {
     memoryBlock(e.id),
     !e.ended ? el('div', { class: 'td-day__acts' }, e.prep ? pill(D.needPrep, 'warn') : steps.before && steps.before.length ? pill(D.nothingToPrep, 'ok') : null) : null,
     after,
+    notesBlock(e, { ws: ctx.ws, initiative: ini }),
     !e.ended ? [list(D.phases.before, (steps.before || []).map(stepItem)), list(D.phases.during, (steps.during || []).map(stepItem)), list(D.phases.after, (steps.after || []).map(stepItem)), mailBlock] : null,
     Array.isArray(e.links) && e.links.length ? el('div', { class: 'td-day__acts', 'data-day': 'links' }, ...e.links.map((l) => extLink((l.label || l.url) + ' ↗', l.url))) : null,
   ];
@@ -856,6 +861,7 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
   // cause a whole-page render under whatever the PM is doing elsewhere
   if (setState) rerender = () => { if (document.querySelector('[data-today="day"]')) setState({}); };
   onAgenda(() => rerender());
+  if (!notesSub) notesSub = onNotes(() => rerender());
   ensure(ws);
   const c = cache.get(ws) || {};
   const m = model(c.data, { here: here || null, all: !!all });