synabun 2.0.7 → 2.0.10

package/neural-interface/public/shared/ocp-v2/ocp-v2-modelpicker.js

@@ -6,6 +6,7 @@
 // ─────────────────────────────────────────────────────────────────────────────
 
 import { fetchProvidersFull } from './ocp-v2-providers.js';
+import { opencodeProviders } from '../opencode-providers.js';
 import { modelRowMeta } from './ocp-v2-status-logic.js';
 import { openProviderSettings } from './ocp-v2-settings-link.js';
 import { getDefaultStore } from './ocp-v2-state.js';
@@ -49,6 +50,7 @@ let _unsubscribe = null;
 let _outsideHandler = null;
 let _providersChangedHandler = null;
 let _hiddenModelsChangedHandler = null;
+let _providersCacheStop = null;
 
 let _providers = [];               // [{ id, name, models: [...] }]
 let _connected = new Set();
@@ -88,7 +90,15 @@ export function mountModelPicker(rootEl, store = getDefaultStore()) {
   _dd.addEventListener('click', async (event) => {
     if (event.target.closest('.ocpv2-dd-menu')) return;
     if (_dd.classList.contains('open')) { closeMenu(); return; }
-    if (!_loaded) { try { await ensureLoaded(); } catch {} }
+    // The kept list opens the menu at once; only a list never read shows "Loading…" until it arrives.
+    if (!_loaded) adoptKeptProviders();
+    if (!_loaded) {
+      paintMenu('');
+      openMenu();
+      try { await ensureLoaded(); } catch {}
+      repaintOpenMenu();
+      return;
+    }
     paintMenu('');
     openMenu();
   });
@@ -101,11 +111,11 @@ export function mountModelPicker(rootEl, store = getDefaultStore()) {
   document.addEventListener('mousedown', _outsideHandler);
 
   _providersChangedHandler = () => { refreshProviders(); };
-  _hiddenModelsChangedHandler = () => {
-    if (_dd?.classList.contains('open')) paintMenu(_searchInput?.value || '');
-  };
+  _hiddenModelsChangedHandler = () => { repaintOpenMenu(); };
   document.addEventListener('ocp-providers-changed', _providersChangedHandler);
   document.addEventListener('ocp-hidden-models-changed', _hiddenModelsChangedHandler);
+  // A background read of the kept list brought another one: the open menu follows in place.
+  _providersCacheStop = opencodeProviders.subscribe(() => { refreshProviders(); });
 
   _unsubscribe = subscribe((event) => {
     if (event?.type === 'config:model') applyLabelFromState();
@@ -120,6 +130,8 @@ export function unmountModelPicker() {
   if (_outsideHandler) document.removeEventListener('mousedown', _outsideHandler);
   if (_providersChangedHandler) document.removeEventListener('ocp-providers-changed', _providersChangedHandler);
   if (_hiddenModelsChangedHandler) document.removeEventListener('ocp-hidden-models-changed', _hiddenModelsChangedHandler);
+  try { _providersCacheStop?.(); } catch {}
+  _providersCacheStop = null;
   _outsideHandler = null;
   _providersChangedHandler = null;
   _hiddenModelsChangedHandler = null;
@@ -134,6 +146,26 @@ export function unmountModelPicker() {
 
 // ── Loading providers ──────────────────────────────────────────────────────
 
+function applyProviders(res) {
+  if (res?.ok === false) throw new Error(res.error || 'provider metadata unavailable');
+  const data = res?.data || {};
+  _providers = data.all || data.providers || (Array.isArray(data) ? data : []);
+  _connected = new Set(data.connected || []);
+  // If the server didn't tell us which providers are "connected", assume all
+  // returned providers are connected so the menu isn't empty.
+  if (!_connected.size && _providers.length) {
+    _connected = new Set(_providers.map((p) => p.id).filter(Boolean));
+  }
+  _loaded = true;
+}
+
+// The list the page already holds (data cache, read at launch or by another module): no request.
+function adoptKeptProviders() {
+  const kept = opencodeProviders.peek('');
+  if (!kept || kept.ok === false) return;
+  try { applyProviders(kept); } catch { /* not a list: read it */ }
+}
+
 async function ensureLoaded() {
   if (_loaded) return;
   if (_loadInflight) return _loadInflight;
@@ -142,16 +174,7 @@ async function ensureLoaded() {
     try {
       const res = await fetchProvidersFull();
       if (generation !== _loadGeneration) return;
-      if (res?.ok === false) throw new Error(res.error || 'provider metadata unavailable');
-      const data = res?.data || {};
-      _providers = data.all || data.providers || (Array.isArray(data) ? data : []);
-      _connected = new Set(data.connected || []);
-      // If the server didn't tell us which providers are "connected", assume all
-      // returned providers are connected so the menu isn't empty.
-      if (!_connected.size && _providers.length) {
-        _connected = new Set(_providers.map((p) => p.id).filter(Boolean));
-      }
-      _loaded = true;
+      applyProviders(res);
     } catch (err) {
       console.warn('[ocp-v2-modelpicker] providers fetch failed', err);
     } finally {
@@ -165,9 +188,23 @@ function refreshProviders() {
   _loaded = false;
   _loadInflight = null;
   _loadGeneration += 1;
-  return ensureLoaded().finally(() => {
-    if (_dd?.classList.contains('open')) paintMenu(_searchInput?.value || '');
-  });
+  return ensureLoaded().finally(() => { repaintOpenMenu(); });
+}
+
+// The open menu drawn again from the current list: the search text, its caret and the scroll position stay,
+// and focus is put back only where it was.
+function repaintOpenMenu() {
+  if (!_dd?.classList.contains('open') || !_menu) return;
+  const input = _searchInput;
+  const typing = !!input && document.activeElement === input;
+  const caret = typing ? [input.selectionStart, input.selectionEnd] : null;
+  const scrollTop = _menu.scrollTop;
+  paintMenu(input?.value || '');
+  _menu.scrollTop = scrollTop;
+  if (typing && _searchInput) {
+    try { _searchInput.focus({ preventScroll: true }); } catch { _searchInput.focus(); }
+    try { if (caret) _searchInput.setSelectionRange(caret[0], caret[1]); } catch { /* not a text field */ }
+  }
 }
 
 // ── Label sync ─────────────────────────────────────────────────────────────

package/neural-interface/public/shared/ocp-v2/ocp-v2-panel.js

@@ -12,9 +12,10 @@ import { state, emit, on } from '../state.js';
 import { storage } from '../storage.js';
 import { fetchProjects } from '../api.js';
 import { injectStyles } from './ocp-v2-styles.js';
-import { connect, api, hasSessionStore, onSessionCompacted, onEvent, supports, isDescendantSession } from './ocp-v2-ws.js';
+import { connect, api, hasSessionStore, onSessionCompacted, onEvent, onReconnect, supports, isDescendantSession } from './ocp-v2-ws.js';
 import {
   menuSessions, pickReusableEmptySession, shareView, SHARE_CONFIRM_TEXT, createPendingRenames, createStoppedShares,
+  sessionBusyFromEvent, sessionBusyFromStatus, tabPillState, automationTurnPhase,
 } from './ocp-v2-sessions-logic.js';
 import {
   forkSession, shareSession, unshareSession, undoLastTurn, restoreReverted,
@@ -82,6 +83,9 @@ let OCP_WINDOW_ID = (() => {
 let STOR_TABS = `opencode-v2-tabs-${OCP_WINDOW_ID}`;
 let STOR_AUTOMATIONS = `opencode-v2-automations-${OCP_WINDOW_ID}`;
 let STOR_TITLE_STATES = `opencode-v2-title-states-${OCP_WINDOW_ID}`;
+// The tabs whose session was working when last seen: after a reload their placeholder pills say so and
+// the panel boots to ask OpenCode (ui-sidepanel-tray.js). Never read as the truth: OpenCode's answer is.
+let STOR_BUSY = `opencode-v2-busy-${OCP_WINDOW_ID}`;
 const STOR_WINDOW_REGISTRY = 'opencode-v2-windows';
 const HEAL_DEBOUNCE_MS = 800;
 const HEAL_RETRY_MAX_MS = 30000;
@@ -94,6 +98,13 @@ let _tabPills = new Map();      // sessionId -> pill element
 let _tabInfoCache = new Map();  // sessionId -> last-known session info (title, etc.)
 const _automationRunIds = new Map(); // sessionId -> native loop runId
 const _automationRunning = new Set();
+// sessionId → what a live automation run's turn does ('working', 'waiting' on the user, 'idle' between turns:
+// automationTurnPhase of the run's descriptor): its pill follows the turn, not the run.
+const _automationTurn = new Map();
+// sessionId → working (true) or idle (false), for the tabs that are not on screen: OpenCode's run events
+// and session:status answers say it (noteSessionBusy); the session on screen leaves its own run state
+// here when the user moves on (renderPill), so its pill keeps moving while its turn goes on.
+const _sessionBusy = new Map();
 const _automationContinuedManually = new Set();
 const _automationManualSendInFlight = new Set();
 const _foreignActiveAutomationSessions = new Set();
@@ -173,6 +184,7 @@ function forkClonedOpenCodePersistence() {
     STOR_TABS = `opencode-v2-tabs-${OCP_WINDOW_ID}`;
     STOR_AUTOMATIONS = `opencode-v2-automations-${OCP_WINDOW_ID}`;
     STOR_TITLE_STATES = `opencode-v2-title-states-${OCP_WINDOW_ID}`;
+    STOR_BUSY = `opencode-v2-busy-${OCP_WINDOW_ID}`;
     if (transferableTabs.length) storage.setItem(STOR_TABS, JSON.stringify(transferableTabs));
     if (transferableRows.length) storage.setItem(STOR_AUTOMATIONS, JSON.stringify(transferableRows));
     if (Object.keys(transferableTitleStates).length) storage.setItem(STOR_TITLE_STATES, JSON.stringify(transferableTitleStates));
@@ -188,6 +200,7 @@ function cleanStaleOpenCodeWindows() {
       storage.removeItem(`opencode-v2-tabs-${windowId}`);
       storage.removeItem(`opencode-v2-automations-${windowId}`);
       storage.removeItem(`opencode-v2-title-states-${windowId}`);
+      storage.removeItem(`opencode-v2-busy-${windowId}`);
       delete registry[windowId];
     }
     registry[OCP_WINDOW_ID] = now;
@@ -243,6 +256,8 @@ function saveAutomationTabs() {
       sessionId,
       runId,
       running: _automationRunning.has(sessionId),
+      // What its turn did when this was written (automationTurnPhase): a reload's placeholder pill follows it.
+      turn: _automationTurn.get(sessionId) || null,
       ownerId: nativeLoopWindowId,
       continuedManually: _automationContinuedManually.has(sessionId),
     }));
@@ -264,6 +279,44 @@ function saveAutomationTabs() {
   } catch {}
 }
 
+// ── What the tabs that are not on screen are doing (_sessionBusy) ──
+
+function saveBusySessions() {
+  try {
+    const busy = _tabSessionIds.filter((sid) => _sessionBusy.get(sid) === true);
+    if (busy.length) storage.setItem(STOR_BUSY, JSON.stringify(busy));
+    else storage.removeItem(STOR_BUSY);
+  } catch {}
+}
+
+/** Record what a session is doing; true when that changed. */
+function rememberBusy(sessionId, busy) {
+  if (!sessionId || _sessionBusy.get(sessionId) === !!busy) return false;
+  _sessionBusy.set(sessionId, !!busy);
+  saveBusySessions();
+  return true;
+}
+
+/** A tab's session started or ended a turn while another one is on screen: its pill follows. */
+function noteSessionBusy(sessionId, busy) {
+  if (rememberBusy(sessionId, busy) && _tabSessionIds.includes(sessionId)) renderPill();
+}
+
+/**
+ * Ask OpenCode what every tab that is not on screen is doing: after a boot (only the session on screen
+ * is read back by its rehydrate) and after the socket came back (their events of the outage reached no
+ * one). A server that does not answer session:status leaves what is known.
+ */
+async function probeTabStatuses() {
+  const activeSid = getState().sessionId;
+  await Promise.all(_tabSessionIds.filter((sid) => sid && sid !== activeSid).map(async (sid) => {
+    let res = null;
+    try { res = await api.sessionStatus({ sessionId: sid, cwd: _tabInfoCache.get(sid)?.directory || undefined }); } catch { res = null; }
+    const busy = sessionBusyFromStatus(res);
+    if (busy !== null && sid !== getState().sessionId && _tabSessionIds.includes(sid)) noteSessionBusy(sid, busy);
+  }));
+}
+
 try {
   const rows = JSON.parse(storage.getItem(STOR_AUTOMATIONS) || '[]');
   for (const row of Array.isArray(rows) ? rows : []) {
@@ -608,6 +661,9 @@ function buildPanel() {
   // Sessions change outside this panel too (another window, the CLI, a title
   // OpenCode generated): keep the open menu and the tab list in step.
   onEvent((eventType, ev) => {
+    // A tab that is not on screen goes on running its turn: its pill says what OpenCode says it does.
+    const run = sessionBusyFromEvent(eventType, ev);
+    if (run && run.sessionId !== getState().sessionId && _tabSessionIds.includes(run.sessionId)) noteSessionBusy(run.sessionId, run.busy);
     if (eventType !== 'session.updated' && eventType !== 'session.deleted' && eventType !== 'session.created') return;
     if (eventType === 'session.deleted') {
       const sid = ev?.info?.id || ev?.sessionID || ev?.sessionId;
@@ -626,6 +682,11 @@ function buildPanel() {
     const sid = getState().sessionId;
     if (sid) refreshSessionMessages(sid).catch((err) => console.warn('[ocp-v2-panel] post-compaction refresh failed', err));
   });
+
+  // Back after an outage: what the other tabs did meanwhile reached no one (the session on screen heals itself).
+  onReconnect(() => {
+    if (_booted) probeTabStatuses().catch((err) => console.warn('[ocp-v2-panel] tab status probe failed', err));
+  });
 }
 
 // A reverted prompt goes back into the composer with what it carried, each
@@ -671,10 +732,13 @@ function syncHeader() {
   // The footer row gives the text only the room that is left: the tooltip
   // says it in full when just the dot fits.
   _statusEl.setAttribute('data-tooltip', status.text);
+  const title = sessionTitleFor(s);
   // Skip label update while user is mid-rename (input is mounted in the label).
   if (_sessionLabelEl && !_sessionLabelEl.querySelector('.ocpv2-rename-input')) {
-    _sessionLabelEl.textContent = sessionTitleFor(s);
+    _sessionLabelEl.textContent = title;
   }
+  // The whole name, for when the header shows only part of it.
+  if (_sessionBtnEl) _sessionBtnEl.title = title;
   if (_renameBtnEl) {
     _renameBtnEl.disabled = !s.sessionId;
   }
@@ -1669,6 +1733,10 @@ async function boot() {
           create: (nav) => startFreshSession({ cwd: lastProject || undefined, nav }),
         });
       }
+      // The other tabs: their turns may have outlived the page too. Asked before the placeholders go
+      // (a short wait at most), so a working tab's pill does not blink idle in between.
+      const probed = probeTabStatuses().catch((err) => console.warn('[ocp-v2-panel] tab status probe failed', err));
+      await Promise.race([probed, new Promise((resolveWait) => setTimeout(resolveWait, 600))]);
       _booted = true;
       // Tell ui-sidepanel-tray we own opencode pills now — it drops any
       // placeholder pills it was rendering from storage.
@@ -2385,9 +2453,11 @@ function removeTab(sessionId, { byUser = false } = {}) {
   _automationRunIds.delete(sessionId);
   unregisterAutomationSession(sessionId);
   _automationRunning.delete(sessionId);
+  _automationTurn.delete(sessionId);
   _automationContinuedManually.delete(sessionId);
   _automationManualSendInFlight.delete(sessionId);
   saveAutomationTabs();
+  if (_sessionBusy.delete(sessionId)) saveBusySessions();
   const pill = _tabPills.get(sessionId);
   if (pill?.isConnected) pill.remove();
   _tabPills.delete(sessionId);
@@ -2478,6 +2548,8 @@ function renderPill() {
   if (!tray) return;
   const activeSid = getState().sessionId;
   if (activeSid) ensureTab(activeSid, getState().sessionInfo);
+  // What the session on screen is doing stays known for its tab once the user moves on.
+  if (activeSid) rememberBusy(activeSid, !!getState().running);
 
   // Drop pills for sessions no longer in the tab list
   for (const [sid, pill] of Array.from(_tabPills.entries())) {
@@ -2498,7 +2570,14 @@ function renderPill() {
     if (labelEl) labelEl.textContent = tabLabelFor(sid);
     const isActive = sid === activeSid;
     pill.classList.toggle('ocpv2-pill-active', isActive);
-    pill.classList.toggle('ocpv2-pill-running', _automationRunning.has(sid) || (isActive && !!getState().running));
+    // One pill per session, each with its own state: a tab the user left goes on showing its turn, an
+    // automation its turn (not its run), and a session that waits on the user says so.
+    const state = tabPillState({
+      sessionId: sid, activeSessionId: activeSid, running: !!getState().running,
+      busy: _sessionBusy.get(sid) === true, automation: _automationTurn.get(sid) || null,
+    });
+    pill.classList.toggle('ocpv2-pill-running', state === 'working');
+    pill.classList.toggle('ocpv2-pill-waiting', state === 'waiting');
     pill.style.display = (isActive && _visible) ? 'none' : '';
   }
   // The sub-agent pills of the session on screen sit under its pill.
@@ -2621,6 +2700,16 @@ export async function endHostedOpenCodeSessions() {
 
 export function isOpencodePanelOpen() { return _visible || isChildPanelOpen(); }
 
+/**
+ * Boot the panel without showing it (ui-sidepanel-tray.js, when a tab saved while it worked comes back
+ * after a reload): its tabs come back and OpenCode is asked what each session does, so their pills say it.
+ */
+export async function bootOpencodePanel() {
+  if (!_panelEl) buildPanel();
+  await connect();
+  await boot();
+}
+
 export async function toggleOpencodePanel() {
   if (_visible || isChildPanelOpen()) {
     requestOpencodeView({ hideAll: true });
@@ -2650,6 +2739,10 @@ export async function attachOpenCodeAutomation(run, { focus = !!run?.focus, isCa
   }
   if (running) _automationRunning.add(sessionId);
   else _automationRunning.delete(sessionId);
+  // Every update of the run (its turn starts, waits on you, ends) comes through here: the pill follows it.
+  const phase = automationTurnPhase(run);
+  if (phase) _automationTurn.set(sessionId, phase);
+  else _automationTurn.delete(sessionId);
   saveAutomationTabs();
   const info = {
     id: sessionId,
@@ -2708,6 +2801,7 @@ export async function detachOpenCodeAutomation(runId) {
   const [sessionId] = entry;
   _automationRunIds.delete(sessionId);
   _automationRunning.delete(sessionId);
+  _automationTurn.delete(sessionId);
   _automationContinuedManually.delete(sessionId);
   _automationManualSendInFlight.delete(sessionId);
   saveAutomationTabs();

package/neural-interface/public/shared/ocp-v2/ocp-v2-projectbar.js

@@ -12,6 +12,7 @@ import { captureBinding, latestOnly } from './ocp-v2-binding.js';
 import { setSessionMcpProfile } from './ocp-v2-session-actions.js';
 import { storage } from '../storage.js';
 import { on } from '../state.js';
+import { escapeHtml } from '../utils.js';
 
 let _currentStore = getDefaultStore();
 const getState = () => _currentStore.getState();
@@ -507,7 +508,7 @@ function paintProfileMenu() {
     const opt = document.createElement('div');
     opt.className = 'ocpv2-dd-option' + (p.id === _currentProfile ? ' selected' : '');
     opt.style.gap = '6px';
-    opt.innerHTML = `<span>${p.label}</span><span class="ocpv2-dd-hint">${p.hint}</span>`;
+    opt.innerHTML = `<span>${escapeHtml(p.label)}</span><span class="ocpv2-dd-hint">${escapeHtml(p.hint)}</span>`;
     opt.addEventListener('click', async (event) => {
       event.stopPropagation();
       ddClose(_profileDd);
@@ -603,7 +604,7 @@ function paintRecallMenu() {
     const opt = document.createElement('div');
     opt.className = 'ocpv2-dd-option' + (p.id === _recallProfile ? ' selected' : '');
     opt.style.gap = '6px';
-    opt.innerHTML = `<span>${p.label}</span><span class="ocpv2-dd-hint">${p.hint}</span>`;
+    opt.innerHTML = `<span>${escapeHtml(p.label)}</span><span class="ocpv2-dd-hint">${escapeHtml(p.hint)}</span>`;
     opt.addEventListener('click', async (event) => {
       event.stopPropagation();
       ddClose(_recallDd);

package/neural-interface/public/shared/ocp-v2/ocp-v2-providers.js

@@ -1,11 +1,15 @@
 // ─────────────────────────────────────────────────────────────────────────────
 // OpenCode V2 — one read of the provider list for every module
 // The model picker, the variant picker, the context gauge and the composer
-// each need `GET /api/opencode/providers/full` (the whole models.dev catalog,
-// a few hundred kilobytes). They ask through here, so opening the panel reads
-// it once. A change (`ocp-providers-changed`) drops the copy.
+// each need the provider list. They ask through here, so opening the panel
+// reads it once: the compact view of GET /api/opencode/providers/full (the
+// connected providers, opencode-providers.js), kept in the page's data cache
+// and given at once on every later open. A change (`ocp-providers-changed`)
+// drops the copy and reads it again.
 // ─────────────────────────────────────────────────────────────────────────────
 
+import { fetchOpencodeProviders, opencodeProviders } from '../opencode-providers.js';
+
 // Long enough to cover the burst of readers at mount and at a refresh, short
 // enough that a later, deliberate refresh reads the server again.
 export const PROVIDERS_SHARE_MS = 3000;
@@ -27,9 +31,7 @@ export function createSharedFetch(fetchJson, { shareMs = PROVIDERS_SHARE_MS, now
   return read;
 }
 
-/** The parsed body of GET /api/opencode/providers/full: `{ ok, data: { all, default, connected } }`. */
-export const fetchProvidersFull = createSharedFetch(() => fetch('/api/opencode/providers/full').then((r) => r.json()));
-
-if (typeof document !== 'undefined') {
-  document.addEventListener('ocp-providers-changed', () => fetchProvidersFull.invalidate());
-}
+/** The parsed body of the provider list: `{ ok, data: { all, default, connected } }` (connected providers). */
+export const fetchProvidersFull = Object.assign(() => fetchOpencodeProviders(), {
+  invalidate: () => opencodeProviders.invalidate(''),
+});

package/neural-interface/public/shared/ocp-v2/ocp-v2-rehydrate.js

@@ -41,16 +41,27 @@ export const ANCESTRY_MAX_DEPTH = 12;
  *                 anything that is not a string means "unknown"
  * Unknown is false: ancestry that cannot be established is not ancestry.
  */
-export async function verifyDescendant(sessionId, ancestorId, { parentOf, roots, fetchParent } = {}) {
+export async function verifyDescendant(sessionId, ancestorId, options = {}) {
+  return (await descendantState(sessionId, ancestorId, options)) === true;
+}
+
+/**
+ * The same walk, with "could not be read" kept apart from "no": true, false
+ * (the chain ends, or loops, without `ancestorId`), or null when a link could
+ * not be read (no `fetchParent`, a failed or odd reply). For a caller that
+ * must not take an unread link for an answer (readOpenAsks).
+ */
+export async function descendantState(sessionId, ancestorId, { parentOf, roots, fetchParent } = {}) {
   if (!sessionId || !ancestorId || sessionId === ancestorId) return false;
   const seen = new Set([sessionId]);
   let cursor = sessionId;
   for (let depth = 0; depth < ANCESTRY_MAX_DEPTH; depth++) {
     let parent = parentOf?.get(cursor);
     if (parent === undefined) {
-      if (roots?.has(cursor) || typeof fetchParent !== 'function') return false;
-      try { parent = await fetchParent(cursor); } catch { return false; }
-      if (typeof parent !== 'string') return false;
+      if (roots?.has(cursor)) return false;
+      if (typeof fetchParent !== 'function') return null;
+      try { parent = await fetchParent(cursor); } catch { return null; }
+      if (typeof parent !== 'string') return null;
       if (parent) parentOf?.set(cursor, parent);
       else roots?.add(cursor);
     }

package/neural-interface/public/shared/ocp-v2/ocp-v2-render.js

@@ -49,7 +49,7 @@ let _markedLoading = false;
 function ensureMarked() {
   if (_marked || _markedLoading || typeof window === 'undefined') return;
   _markedLoading = true;
-  import('https://cdn.jsdelivr.net/npm/marked@14/lib/marked.esm.js')
+  import('/vendor/marked/marked-14.1.4.esm.js')
     .then((mod) => {
       _marked = mod?.marked || mod?.default || null;
       if (_marked?.setOptions) _marked.setOptions({ breaks: true, gfm: true });