privateboard 0.1.11 → 0.1.13

package/public/new-agent.js

@@ -422,29 +422,107 @@
     });
   }
 
-  function open() {
+  /** Module-scoped overrides set by `open(options)`. Cleared on
+   *  close so the next default open() starts clean. */
+  let _submitOverride = null;
+  let _onCancelOverride = null;
+  let _classificationOverride = null;
+  let _footMetaOverride = null;
+  let _createLabelOverride = null;
+
+  /** Open the overlay. With no args, this is the default Signal
+   *  manual-config flow (POST /api/agents on Create). With options,
+   *  callers can pre-fill the form, intercept submit, and tweak
+   *  the chrome — this lets the Full-persona save flow reuse the
+   *  exact same overlay instead of forking the UI.
+   *
+   *    options.prefill = { name, bio, instruction, modelV,
+   *                        avatarSeed, avatarPath }
+   *    options.onSubmit = async (data, helpers) => {}
+   *      data    · { name, handle, bio, instruction, modelV,
+   *                  avatarPath, avatarSeed }
+   *      helpers · { close }
+   *      Throw / reject to keep the overlay open and surface an
+   *      error toast (alert).
+   *    options.onCancel · fired before close() when the user clicks
+   *      cancel / X / backdrop · use to e.g. preserve build state.
+   *    options.classificationLeft · text shown in the upper-left
+   *      classification bar (default · "DIRECTOR · NEW")
+   *    options.footMeta · text shown in the foot-meta line
+   *    options.createLabel · text on the Create button (default ·
+   *      "Create director")
+   */
+  function open(options) {
     if (!overlay) return;
-    // Reset form to a clean slate every time.
-    modal.querySelector(".na-name-input").value = "";
-    modal.querySelector(".na-desc-input").value = "";
-    modal.querySelector(".na-instr-input").value = "";
-    avatarState = { placeholder: true, seed: null, roll: 0 };
+    options = options || null;
+    const prefill = (options && options.prefill) || null;
+
+    // Reset form. When prefill is supplied, populate after reset.
+    modal.querySelector(".na-name-input").value = prefill && prefill.name ? prefill.name : "";
+    modal.querySelector(".na-desc-input").value = prefill && prefill.bio ? prefill.bio : "";
+    modal.querySelector(".na-instr-input").value = prefill && prefill.instruction ? prefill.instruction : "";
+
+    // Avatar · pre-seed when caller provides one (e.g. Full-mode
+    // build's stashed seed). Falls back to the placeholder otherwise.
+    if (prefill && prefill.avatarSeed) {
+      avatarState = { placeholder: false, seed: prefill.avatarSeed, roll: 1 };
+    } else {
+      avatarState = { placeholder: true, seed: null, roll: 0 };
+    }
     paintAvatar();
     refreshAll();
 
-    // Paint the model dropdown's current label · the chip uses the
-    // same agent-model state as the AI composer (loadAgentComposerModel),
-    // so re-opening the overlay reflects the user's last pick.
+    // Model · push prefill model into the shared agent-composer
+    // state so the chip + downstream readers (na-create POST etc.)
+    // pick it up. Cleared by the user via the chip dropdown.
+    if (prefill && prefill.modelV
+        && window.app && typeof window.app.setAgentComposerModel === "function") {
+      try { window.app.setAgentComposerModel(prefill.modelV); } catch (_) { /* */ }
+    }
     paintModelLabel();
 
+    // Apply chrome overrides.
+    _submitOverride = (options && typeof options.onSubmit === "function") ? options.onSubmit : null;
+    _onCancelOverride = (options && typeof options.onCancel === "function") ? options.onCancel : null;
+    _classificationOverride = (options && options.classificationLeft) ? String(options.classificationLeft) : null;
+    _footMetaOverride = (options && options.footMeta) ? String(options.footMeta) : null;
+    _createLabelOverride = (options && options.createLabel) ? String(options.createLabel) : null;
+    applyChromeOverrides();
+
     overlay.classList.add("open");
     overlay.setAttribute("aria-hidden", "false");
     document.body.style.overflow = "hidden";
     setTimeout(() => modal.querySelector(".na-name-input").focus(), 80);
     applyNewAgentI18n();
+    // applyChromeOverrides runs AFTER applyNewAgentI18n on i18n
+    // events too · the i18n pass would otherwise reset our custom
+    // strings.
+    applyChromeOverrides();
     refreshProviderStatus();
   }
 
+  /** Mirror the override state into the actual DOM. Re-runs after
+   *  i18n applies so user-facing labels survive locale changes. */
+  function applyChromeOverrides() {
+    if (!modal) return;
+    const classEl = modal.querySelector(".na-classification > span:first-child");
+    if (classEl && _classificationOverride) {
+      classEl.innerHTML = `<span class="dot">●</span> ${escape(_classificationOverride)}`;
+    }
+    const footEl = modal.querySelector(".na-foot-meta");
+    if (footEl && _footMetaOverride) {
+      footEl.textContent = _footMetaOverride;
+      footEl.classList.add("na-foot-meta-override");
+    } else if (footEl) {
+      footEl.classList.remove("na-foot-meta-override");
+    }
+    const createBtn = modal.querySelector(".na-create");
+    if (createBtn && _createLabelOverride) {
+      const labelSpan = createBtn.querySelector("span:not(.na-create-mark)");
+      if (labelSpan) labelSpan.textContent = _createLabelOverride;
+    }
+  }
+
   /** Read the user's current agent-model selection (shared with the
    *  AI composer) and paint it into the overlay's `cmp-dd-value` span.
    *  Falls back to a dash when app or its model resolver isn't ready. */
@@ -465,11 +543,25 @@
     span.textContent = label;
   }
 
-  function close() {
+  function close(opts) {
     if (!overlay) return;
+    const fromCancel = !!(opts && opts.fromCancel);
+    // Notify the caller (e.g. Full-mode persona flow) that the user
+    // dismissed without saving · lets them preserve the build so it
+    // can be re-opened. Fired BEFORE we wipe the override state so
+    // the callback can still see options it set.
+    if (fromCancel && _onCancelOverride) {
+      try { _onCancelOverride(); } catch (_) { /* */ }
+    }
     overlay.classList.remove("open");
     overlay.setAttribute("aria-hidden", "true");
     document.body.style.overflow = "";
+    // Reset overrides so the next default open() starts clean.
+    _submitOverride = null;
+    _onCancelOverride = null;
+    _classificationOverride = null;
+    _footMetaOverride = null;
+    _createLabelOverride = null;
   }
 
   function slugify(s) {
@@ -628,16 +720,18 @@
     overlay = document.getElementById("new-agent-overlay");
     modal = overlay.querySelector(".new-agent-modal");
 
-    // Close
-    modal.querySelector(".na-close").addEventListener("click", close);
-    modal.querySelector(".na-cancel").addEventListener("click", close);
+    // Close · all dismissal paths flag fromCancel:true so the
+    // override hook fires (Full-mode persona flow uses it to
+    // preserve the build state when the overlay is dismissed).
+    modal.querySelector(".na-close").addEventListener("click", () => close({ fromCancel: true }));
+    modal.querySelector(".na-cancel").addEventListener("click", () => close({ fromCancel: true }));
     overlay.addEventListener("click", (e) => {
-      if (e.target === overlay) close();
+      if (e.target === overlay) close({ fromCancel: true });
     });
     document.addEventListener("keydown", (e) => {
       if (e.key === "Escape" && overlay.classList.contains("open")) {
         e.stopImmediatePropagation();
-        close();
+        close({ fromCancel: true });
       }
     });
 
@@ -702,39 +796,56 @@
       create.innerHTML = `<span class="na-create-mark">◆</span><span>${escape(t("na_creating"))}</span>`;
 
       try {
-        const res = await fetch("/api/agents", {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ name, bio, instruction, modelV, avatarPath }),
-        });
-        if (!res.ok) {
-          const err = await res.json().catch(() => ({}));
-          throw new Error(err.error || res.statusText);
-        }
-        const created = await res.json();
-        // Refresh app.agents so the sidebar + agentsById register the
-        // new director immediately. Falls back gracefully if app isn't
-        // booted (shouldn't happen in normal flows).
-        if (window.app && typeof window.app.refreshAgents === "function") {
-          await window.app.refreshAgents();
+        if (_submitOverride) {
+          // Caller-supplied submit path · used by the Full-persona
+          // save flow to POST to /generate-persona/:jobId/save
+          // instead of the default /api/agents. The override
+          // owns success-state handling (refresh, close, etc.)
+          // but we still close on resolve as a safety.
+          await _submitOverride({
+            name, bio, instruction, modelV, avatarPath,
+            avatarSeed, avatarRoll,
+          }, { close, escape, t });
+          // Close `fromCancel:false` so the override's onCancel
+          // hook doesn't fire (we just saved successfully).
+          close();
+        } else {
+          const res = await fetch("/api/agents", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ name, bio, instruction, modelV, avatarPath }),
+          });
+          if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.error || res.statusText);
+          }
+          const created = await res.json();
+          // Refresh app.agents so the sidebar + agentsById register the
+          // new director immediately. Falls back gracefully if app isn't
+          // booted (shouldn't happen in normal flows).
+          if (window.app && typeof window.app.refreshAgents === "function") {
+            await window.app.refreshAgents();
+          }
+          // Hand the new agent's id to anyone watching for the event.
+          try {
+            window.dispatchEvent(new CustomEvent("boardroom:agent-created", { detail: created }));
+          } catch (_) { /* */ }
+          close();
         }
-        // Hand the new agent's id to anyone watching for the event.
-        try {
-          window.dispatchEvent(new CustomEvent("boardroom:agent-created", { detail: created }));
-        } catch (_) { /* */ }
-        close();
       } catch (e) {
         const msg = e && e.message ? e.message : String(e);
         alert(t("na_create_fail", { msg }));
         create.disabled = false;
         create.innerHTML = `<span class="na-create-mark">◆</span><span data-i18n-na="na_create"></span>`;
         applyNewAgentI18n();
+        applyChromeOverrides();
       }
     });
   }
 
-  // Public API
-  window.openNewAgent  = function () { if (!overlay) init(); open(); };
+  // Public API · options pass-through lets the Full-persona save
+  // flow open the same overlay with prefill + custom submit.
+  window.openNewAgent  = function (options) { if (!overlay) init(); open(options); };
   window.closeNewAgent = close;
 
   if (document.readyState === "loading") {

package/public/quote-cta.css

@@ -87,13 +87,15 @@
 
 /* ─── Save toast ─────────────────────────────────────────────
    Lightweight feedback after a successful POST /api/notes (or a
-   failure). Bottom-center anchored, fades in/out. Lime for ok,
+   failure). Top-center anchored so it doesn't overlap with the
+   bottom bar's input controls + voice-replay panel — which were
+   covering the previous bottom-center placement. Lime for ok,
    red-tinted for error. Click to dismiss early. */
 .qcta-toast {
   position: fixed;
-  bottom: 24px;
+  top: 72px;             /* clears the topbar / classification strip */
   left: 50%;
-  transform: translate(-50%, 8px);
+  transform: translate(-50%, -8px); /* starts above resting, slides DOWN */
   z-index: 1600;
   background: var(--panel, #131312);
   border: 0.5px solid var(--lime, #6FB572);
@@ -107,6 +109,8 @@
   opacity: 0;
   transition: opacity 0.16s ease-out, transform 0.16s ease-out;
   white-space: nowrap;
+  /* Drop shadow flipped so the elevation hint reads as "tray
+     dropping from above" rather than "rising from below." */
   box-shadow: 0 14px 30px -14px rgba(0, 0, 0, 0.55);
 }
 .qcta-toast.open {

package/public/quote-cta.js

@@ -494,8 +494,28 @@
   // some paths but not all; using a self-contained one keeps this
   // module independent. Lime for ok, red-tinted for error. Auto-
   // dismisses after 1.8s; click to dismiss early.
+  //
+  // Horizontal anchor · the toast sits over the CHAT COLUMN, not
+  // the viewport center. Centering on the viewport pulls the
+  // toast right of the chat (the sidebar eats ~280px on the left)
+  // and reads as visually skewed. Recomputed every show so the
+  // toast tracks sidebar collapse / window resize.
   let toastEl = null;
   let toastTimer = null;
+  function positionToast() {
+    if (!toastEl) return;
+    const chat = document.querySelector(".chat-col") || document.querySelector('[data-main-view="room"]');
+    if (!chat) {
+      // Fallback · centre on viewport when the chat column isn't
+      // mounted (e.g. notes page · toast still useful but anchor
+      // missing). Same behaviour as before this fix.
+      toastEl.style.left = "50%";
+      return;
+    }
+    const r = chat.getBoundingClientRect();
+    const cx = r.left + r.width / 2;
+    toastEl.style.left = cx + "px";
+  }
   function toast(msg, kind) {
     if (!toastEl) {
       toastEl = document.createElement("div");
@@ -506,6 +526,7 @@
     toastEl.classList.remove("kind-ok", "kind-error");
     toastEl.classList.add("kind-" + (kind === "error" ? "error" : "ok"));
     toastEl.textContent = msg;
+    positionToast();
     toastEl.classList.add("open");
     if (toastTimer) clearTimeout(toastTimer);
     toastTimer = setTimeout(() => {

package/public/report.html

@@ -131,6 +131,11 @@
                    U+FF00-FFEF;
   }
 
+  /* Print-paper backstop · hidden on screen; shown only during the
+     print render. Inside @media print (below) it expands to a
+     position:fixed full-page background. */
+  [data-print-paper-fill] { display: none; }
+
   @media print {
     *, *::before, *::after {
       print-color-adjust: exact !important;
@@ -194,14 +199,36 @@
 
     /* Page-frame background · matches body's printed colour per spine
        so any PDF engine that paints html beyond body's box (some
-       legacy print pipelines) stays coherent. Modern Chrome with
-       @page margin: 0 fills the page from body alone, but this is
-       belt-and-braces. Default white; per-spine `:has()` selectors
-       below override for the light-paper spines. */
+       legacy print pipelines) stays coherent. Default white; per-
+       spine selectors below override for the light-paper spines.
+       The earlier `:has()` selector silently failed on browsers
+       that don't support `:has()` in print mode (some Chrome
+       versions, headless / Save-as-PDF pipelines), leaving html
+       white and the dark spine PDF unreadable. We now mirror the
+       `data-spine` attribute onto `<html>` itself in `swapSpine`
+       (see JS below), so a plain attribute selector picks up the
+       light-paper colour reliably. */
     html { background: #FFFFFF !important; }
-    html:has(body[data-spine="anthropic-essay"]) { background: #F4F0E8 !important; }
-    html:has(body[data-spine="a16z-thesis"])     { background: #F7F3E8 !important; }
-    html:has(body[data-spine="boardroom-dark"])  { background: #FAF7F0 !important; }
+    html[data-spine="anthropic-essay"] { background: #F4F0E8 !important; }
+    html[data-spine="a16z-thesis"]     { background: #F7F3E8 !important; }
+    html[data-spine="boardroom-dark"]  { background: #FAF7F0 !important; }
+
+    /* Print-paper backstop · a `position: fixed; inset: 0` div with
+       `print-color-adjust: exact` reliably paints on every printed
+       page in Chrome, where `html { background }` and `body {
+       background }` are inconsistently honoured. JS sets the
+       background colour per spine in `swapSpine` so this paints the
+       cream / white paper colour edge-to-edge. z-index: -1 keeps it
+       behind all content. */
+    [data-print-paper-fill] {
+      display: block !important;
+      position: fixed !important;
+      inset: 0 !important;
+      z-index: -1 !important;
+      print-color-adjust: exact !important;
+      -webkit-print-color-adjust: exact !important;
+      pointer-events: none !important;
+    }
 
     /* Container resets so .doc fills the printable area instead of
        being clipped at its 880px on-screen max-width. */
@@ -2822,6 +2849,16 @@
 </head>
 <body>
 
+<!-- Print-only paper background · a position:fixed div that fills the
+     entire page on every printed sheet. Chrome's print pipeline is
+     historically unreliable about painting `html { background }` and
+     `body { background }` (even with print-color-adjust: exact),
+     causing dark-spine reports to save as PDFs with the wrong (white)
+     bleed colour. A real DIV with print-color-adjust paints reliably
+     on every page. JS sets the background colour per spine in
+     `swapSpine`. Hidden on screen. -->
+<div class="print-paper-fill" data-print-paper-fill aria-hidden="true"></div>
+
 <div class="top-rule">
   <span class="crumb">Boardroom <span class="accent">·</span> Insights</span>
   <div class="top-actions">
@@ -2897,6 +2934,15 @@
     const href = `report/spines/${safe}.css`;
     if (link.getAttribute("href") !== href) link.setAttribute("href", href);
     document.body.setAttribute("data-spine", safe);
+    // Mirror the spine onto <html> too so the @media print rule
+    // `html[data-spine="..."] { background: ... }` resolves
+    // reliably in every Chrome / Save-as-PDF pipeline. The
+    // earlier `:has()`-based selector silently failed in some
+    // print pipelines, leaving html white and the dark-spine PDF
+    // showing wrong text colours against an unintended white
+    // page bleed. Setting data-spine on the root element bypasses
+    // `:has()` entirely.
+    document.documentElement.setAttribute("data-spine", safe);
     // Mark the document as CJK when the brief is in Chinese (or any
     // CJK script). Several spines — anthropic-essay, a16z-thesis,
     // boardroom-dark in the bottom-line callout — use `font-style:
@@ -2909,10 +2955,27 @@
     const sample = ((brief && brief.title) || "") + " " + ((brief && brief.bodyMd) || "");
     const isCjk = /[㐀-鿿぀-ヿ가-힯]/.test(sample);
     document.body.classList.toggle("is-cjk", isCjk);
-    // Inject (or replace) the per-spine @page background rule so the
-    // PDF page bleed matches the paper colour. Replaces any prior
-    // injected rule for this same id, so swapping spines repaints
-    // cleanly without stacking style nodes.
+    // Inject (or replace) the per-spine print-paper rule. We paint
+    // the cream / white paper colour at THREE levels because Chrome
+    // / Save-as-PDF pipelines silently drop one or another:
+    //   · `@page { background }` — paints the @page bleed
+    //     (technically the canonical surface, but historically buggy
+    //     and ignored by some print pipelines)
+    //   · `html { background }` — paints the document canvas;
+    //     overridden by the static `html { background: #FFFFFF }`
+    //     default in @media print, but THIS injected rule wins on
+    //     specificity (it loads after the static stylesheet)
+    //   · `body { background }` — paints the body's content box;
+    //     the most reliable surface but only fills inside @page
+    //     margins
+    // With all three forced to the same paper colour AND
+    // print-color-adjust: exact !important, the saved PDF reliably
+    // shows the spine's paper colour edge-to-edge regardless of
+    // which surface Chrome ends up honouring on a given OS / Chrome
+    // version. The earlier single-`@page`-rule injection was the
+    // root cause of the "dark report → white PDF" bug — Chrome
+    // dropped the @page background and the static `html {
+    // background: #FFFFFF }` default won.
     const paper = SPINE_PAPER[safe] || "#FFFFFF";
     let pageStyle = document.getElementById("spine-page-bg");
     if (!pageStyle) {
@@ -2920,7 +2983,24 @@
       pageStyle.id = "spine-page-bg";
       document.head.appendChild(pageStyle);
     }
-    pageStyle.textContent = `@media print { @page { background: ${paper}; } }`;
+    pageStyle.textContent = `
+      @media print {
+        @page { background: ${paper}; }
+        html, body {
+          background: ${paper} !important;
+          print-color-adjust: exact !important;
+          -webkit-print-color-adjust: exact !important;
+        }
+      }
+    `;
+    // Print-paper backstop · the position:fixed div in <body> needs
+    // its background colour set directly (inline style) so it paints
+    // the right paper colour on every printed page. This is the
+    // FALLBACK surface — Chrome's print pipeline drops `html` and
+    // `body` backgrounds inconsistently, but always paints a real
+    // div with print-color-adjust: exact.
+    const fill = document.querySelector("[data-print-paper-fill]");
+    if (fill) fill.style.background = paper;
   }
 
   function escape(s) {
@@ -3400,6 +3480,23 @@
   // bullets, ordered lists, paragraphs, blockquotes, fenced code blocks
   // (incl. ```mermaid for diagrams), and pipe tables.
   function renderMarkdown(md) {
+    // Pre-pre-pass · normalise fenced-block openers that the LLM
+    // sometimes glues onto the tail of a paragraph (`...end of prose.```views-compared`).
+    // The fence-recognition regex below requires the opener to be on
+    // its OWN line (`/^```.../`), so a mid-line opener falls through
+    // and the fenced body renders as raw text full of `{` / `}` / `:`
+    // / quote symbols — exactly the "符号导致内容混乱" report we
+    // get when the brief writer writes the closing prose without a
+    // newline before the dispatch fence. Insert a blank line in
+    // front of every fence opener that isn't already at the start
+    // of a line. Keep paired closing fences alone (they're always
+    // preceded by content inside the block — that's fine).
+    // Match openers only · `[\w-]+` requires a non-empty lang tag so
+    // bare closing fences (`\`\`\`\n`) don't get rewritten too. Without
+    // that distinction, every closing fence also picks up an extra
+    // blank line and the body slice includes a trailing empty line.
+    md = String(md || "").replace(/([^\n])(\n?)```([\w-]+)\s*\n/g,
+      (_m, before, _newline, lang) => `${before}\n\n\`\`\`${lang}\n`);
     // Pre-pass · pull out fenced ```code blocks before splitting on blank
     // lines, since a code block can legally contain blank lines.
     const placeholders = [];

package/public/room-settings.css

@@ -472,6 +472,73 @@
   color: var(--lime, #6FB572);
 }
 
+/* Vote-trigger radio group · two cells per row (Auto / Manual)
+   with the radio glyph + name pinned to the top line and a single
+   compact description line beneath. The previous stacked-column
+   layout wasted vertical space for two short binary options; the
+   2-up grid sits the choices side-by-side at content height so the
+   panel stays dense. The section's own .rs-config-row-hint above
+   carries the "when the chair opens the round-end vote" framing,
+   so each cell only needs its own short rationale. */
+.rs-vote-trigger-grp {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 6px;
+}
+.rs-radio-row {
+  display: grid;
+  grid-template-columns: 13px 1fr;
+  align-items: center;
+  column-gap: 8px;
+  row-gap: 2px;
+  padding: 7px 9px;
+  background: var(--bg, #0A0A0A);
+  border: 0.5px solid var(--line-bright, #2A2A26);
+  cursor: pointer;
+  transition: border-color 0.12s, background 0.12s;
+}
+.rs-radio-row:hover { border-color: var(--text-faint, #3A382F); }
+.rs-radio-row input[type="radio"] {
+  grid-row: 1;
+  grid-column: 1;
+  margin: 0;
+  accent-color: var(--lime, #6FB572);
+  cursor: pointer;
+  width: 13px;
+  height: 13px;
+  flex-shrink: 0;
+}
+.rs-radio-label {
+  grid-row: 1 / span 2;
+  grid-column: 2;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  min-width: 0;
+}
+.rs-radio-name {
+  font-family: var(--font-human);
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-soft, #8E8B83);
+  letter-spacing: -0.005em;
+  line-height: 1.2;
+}
+.rs-radio-desc {
+  font-family: var(--font-human);
+  font-size: 11px;
+  color: var(--text-faint, #5C5A4D);
+  letter-spacing: -0.003em;
+  line-height: 1.35;
+}
+.rs-radio-row.active {
+  border-color: var(--lime, #6FB572);
+  background: var(--panel-2, #1A1A18);
+}
+.rs-radio-row.active .rs-radio-name {
+  color: var(--lime, #6FB572);
+}
+
 /* Section label · matches the new composer's mono micro-type kicker.
    No leading lime bullet — the inline count chip carries enough
    visual weight, and dropping the bullet lets the labels sit flush