dsh-sidebar-suite 0.2.9 → 0.4.0

package/lib/client.js

@@ -19,8 +19,15 @@ window.__ModuleLoader__.load({
     'use strict'
 
     var ENTRY = 'dsh-sidebar-suite'
+    // Reported to tab consumers so they can feature-detect. Kept in lockstep
+    // with package.json by tests/test_030.mjs.
+    var VERSION = '0.4.0'
     var NS = 'sidebar-suite'
     var LS_KEY = 'dsh-sidebar-suite:state'
+    // Where the third-party tab choice lives. Kept out of LS_KEY on purpose:
+    // the config form describes the sidebar, this describes the user's
+    // current position inside it, and the two have different lifetimes.
+    var TAB_STORE_KEY = 'dsh-sidebar-suite:active-tab'
     var STYLE_ID = 'dsh-sidebar-suite-style'
     // Where feedback goes. A plugin bundle cannot open a mail client or post a
     // form without a server, so the entry point assembles a ready-to-send
@@ -79,6 +86,10 @@ window.__ModuleLoader__.load({
         'tab.to.ext.hint': 'Switch the shared space to the panels group.',
         'tab.to.ws': 'Show workspaces',
         'tab.to.ws.hint': 'Switch the shared space to the workspaces group.',
+        'tab.ext': 'Panels',
+        'tab.ws': 'Workspaces',
+        'tabs.label': 'Sidebar pages',
+        'tabs.own': 'This page is provided by {name}.',
         'pop.open': 'Open panels',
         'pop.close': 'Close panels',
         'pop.hint': 'Open or close the panels overlay.',
@@ -95,6 +106,15 @@ window.__ModuleLoader__.load({
         'temp.feedbackHint': 'Report it on the plugin detail page.',
         'temp.restartHint': 'Fully quit DSH (tray icon → Quit) and reopen it — a hot reload does not reload the plugin host.',
         'temp.badge': 'TEMP',
+        'temp.menu.label': 'Temporary session actions',
+        'temp.menu.keep': 'Keep as a normal session',
+        'temp.menu.keep.hint': 'It will no longer be deleted when DSH quits.',
+        'temp.menu.delete': 'Delete now',
+        'temp.menu.delete.hint': 'Removes this session from disk. It cannot be undone.',
+        'temp.menu.kept': 'Kept as a normal session — it now survives quitting DSH.',
+        'temp.menu.deleted': 'Temporary session deleted.',
+        'temp.menu.hidden': 'Files were locked, so the row was hidden instead. Deletion is retried next launch.',
+        'temp.menu.failed': 'Action failed: ',
         'policy.title': 'Temporary session cleanup',
         'policy.help': 'Choose when temporary sessions are removed. Defaults: delete on quit = on, daily cleanup = off. Saved to the plugin settings file and applied immediately — no restart.',
         'policy.onQuit': 'Delete when DSH quits',
@@ -129,6 +149,10 @@ window.__ModuleLoader__.load({
         'tab.to.ext.hint': '把共用的一栏切换到扩展区。',
         'tab.to.ws': '显示工作区',
         'tab.to.ws.hint': '把共用的一栏切换到工作区。',
+        'tab.ext': '扩展',
+        'tab.ws': '工作区',
+        'tabs.label': '侧栏页签',
+        'tabs.own': '这一页由 {name} 提供。',
         'pop.open': '展开扩展',
         'pop.close': '收起扩展',
         'pop.hint': '打开或收起扩展浮层。',
@@ -145,6 +169,15 @@ window.__ModuleLoader__.load({
         'temp.feedbackHint': '可在插件详情页反馈。',
         'temp.restartHint': '请从托盘图标彻底退出 DSH 再打开 —— 热重载不会重载插件后端。',
         'temp.badge': '临时',
+        'temp.menu.label': '临时会话操作',
+        'temp.menu.keep': '保留为正式会话',
+        'temp.menu.keep.hint': '退出 DSH 时不再删除它。',
+        'temp.menu.delete': '立即删除',
+        'temp.menu.delete.hint': '把这个会话从磁盘删掉，无法恢复。',
+        'temp.menu.kept': '已保留为正式会话：退出 DSH 时不会再删除它。',
+        'temp.menu.deleted': '临时会话已删除。',
+        'temp.menu.hidden': '文件被占用，已先把它从列表里隐藏，下次启动再删。',
+        'temp.menu.failed': '操作失败：',
         'policy.title': '临时会话自动删除',
         'policy.help': '决定临时会话什么时候被清掉。默认：退出 DSH 时删除=开，每天定时清理=关。写入插件设置文件，改完立即生效，不用重启。',
         'policy.onQuit': '退出 DSH 时删除',
@@ -191,6 +224,8 @@ window.__ModuleLoader__.load({
       'options.styleOwn': '独占一行 / Own row',
       'options.expandAll': '会话默认全展开 / Always expand sessions',
       'options.expandHint': '关掉后恢复 DSH 原来的折叠行为；已经展开的列表要切换一次工作区才会收回去。 / Turning it off restores host folding; already-expanded groups collapse after you switch workspaces once.',
+      'options.rowMenu': '临时会话右键菜单 / Right-click menu on temp sessions',
+      'options.rowMenuHint': '右键临时会话可「保留为正式会话」或「立即删除」。若和别的插件抢右键菜单，关掉这一项即可。 / Right-clicking a temp session offers "keep as normal" or "delete now". Turn this off if another plugin owns the context menu.',
       'options.maxKept': '最多保留 / Keep at most',
       'options.maxKeptHint': '个临时会话（1–200） / temp sessions (1–200)',
       'options.purge': '立即清理临时会话 / Clean up now',
@@ -299,6 +334,19 @@ window.__ModuleLoader__.load({
       // In the collapsed rail there is no horizontal room for two buttons.
       'html[data-dsbs-temp-solo="true"] [data-dsbs-temp-slot]{display:none!important}',
       'html[data-dsbs-temp-solo="true"]:not([data-dsbs-chat-mode]) [data-dsbs-newchat] button[class*="newSession"]{width:auto!important;height:38px!important;font-size:14px!important;line-height:22px!important;margin:0 calc(var(--dsh-sidebar-paint-inset,3px) + 1px) 10px!important}',
+      // ---- per-row menu on temporary sessions (0.4.0) -------------------
+      // Right-clicking a temporary row offers "keep as normal" and "delete
+      // now". Styled from host tokens like every other surface here; the row
+      // itself gains no children, so React re-renders cannot wipe it.
+      '[data-dsbs-temp-menu]{position:fixed;z-index:9400;min-width:196px;max-width:min(280px,calc(100vw - 16px));box-sizing:border-box;padding:4px;display:flex;flex-direction:column;gap:1px;border-radius:10px;background:var(--dsw-alias-bg-overlay,var(--dsw-alias-bg-base,#1f1f1f));color:var(--dsw-alias-label-primary,inherit);border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.3));box-shadow:0 12px 32px rgba(0,0,0,.32)}',
+      '[data-dsbs-temp-menu][hidden]{display:none!important}',
+      '[data-dsbs-temp-menu-head]{padding:4px 8px 6px;margin-bottom:2px;border-bottom:1px solid var(--dsw-alias-border-l1,rgba(127,127,127,.22));font-size:11px;line-height:1.5;color:var(--dsw-alias-label-tertiary,rgba(127,127,127,.9));overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+      '[data-dsbs-temp-menu] button{appearance:none;-webkit-appearance:none;display:block;width:100%;box-sizing:border-box;border:0;background:transparent;color:inherit;font:inherit;font-size:12px;line-height:1.45;text-align:left;padding:6px 8px;border-radius:7px;cursor:pointer;white-space:normal}',
+      '[data-dsbs-temp-menu] button:hover,[data-dsbs-temp-menu] button:focus-visible{background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.16));outline:none}',
+      '[data-dsbs-temp-menu] button:focus-visible{outline:2px solid var(--dsw-alias-label-primary,currentColor);outline-offset:-2px}',
+      '[data-dsbs-temp-menu] button[data-dsbs-temp-action="delete"]{color:var(--dsw-alias-state-business-danger,#d9534f)}',
+      '[data-dsbs-temp-menu-sub]{display:block;font-size:10px;line-height:1.4;opacity:.68}',
+      'html[data-dsbs-temp-menu="false"] [data-dsbs-temp-menu]{display:none!important}',
       // A temporary session is a NORMAL DSH session, so its sidebar row is the
       // host's own row. Nothing is added to the DOM: we tag the row and let CSS
       // draw the badge, which survives every React re-render of the list.
@@ -356,6 +404,34 @@ window.__ModuleLoader__.load({
       '[data-row-key^="session:"]{transition:background-color .13s ease,box-shadow .13s ease,color .13s ease;font-variant-numeric:tabular-nums}',
       '[data-row-key^="session:"][aria-selected="true"]{box-shadow:inset 2px 0 0 var(--dsw-alias-state-business-primary,var(--dsw-alias-label-primary,#4d6bfe))!important}',
       'html[data-dsbs-rail="true"] [data-row-key^="session:"][aria-selected="true"]{box-shadow:none!important}',
+
+      // ---- third-party page strip (0.3.0) ------------------------------
+      // The strip only exists while at least one plugin registered a tab, so a
+      // stock profile never sees it. Everything inherits currentColor, which
+      // is what keeps it legible in both host themes without a palette here.
+      '[data-dsbs-tabs]{display:flex;align-items:center;gap:2px;padding:3px 4px 0;flex:none;overflow-x:auto;overflow-y:hidden;scrollbar-width:none}',
+      '[data-dsbs-tabs][hidden]{display:none!important}',
+      '[data-dsbs-tabs]::-webkit-scrollbar{display:none}',
+      '[data-dsbs-tabs] button{position:relative;display:inline-flex;align-items:center;gap:5px;flex:none;min-width:0;max-width:150px;padding:4px 9px;border:0;border-radius:7px 7px 0 0;background:transparent;color:inherit;font:inherit;font-size:11px;line-height:1.3;opacity:.6;cursor:pointer;white-space:nowrap;transition:opacity .14s ease,background-color .14s ease}',
+      '[data-dsbs-tabs] button:hover{opacity:.92;background:color-mix(in srgb,currentColor 8%,transparent)}',
+      '[data-dsbs-tabs] button[aria-selected="true"]{opacity:1;font-weight:600;background:color-mix(in srgb,currentColor 12%,transparent);box-shadow:inset 0 -2px 0 var(--dsw-alias-state-business-primary,currentColor)}',
+      '[data-dsbs-tablabel]{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}',
+      '[data-dsbs-tabicon]{display:inline-flex;align-items:center;justify-content:center;width:14px;height:14px;flex:none}',
+      '[data-dsbs-tabicon] svg{width:14px;height:14px;display:block;fill:none;stroke:currentColor;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round}',
+      '[data-dsbs-tabicon-text]{font-size:12px;line-height:1}',
+      '[data-dsbs-tabbadge]{flex:none;min-width:15px;padding:0 4px;border-radius:7px;font-size:10px;line-height:15px;text-align:center;background:color-mix(in srgb,currentColor 16%,transparent);font-variant-numeric:tabular-nums}',
+      // The tab's own container inherits the column the two groups gave up.
+      '[data-dsbs-tabpanel]{display:none;flex:1 1 auto;min-height:0;min-width:0;overflow:auto;flex-direction:column}',
+      '[data-dsbs-tabpanel][data-dsbs-visible="true"]{display:flex}',
+      'html[data-dsbs-ptab="true"] nav[data-dsbs-ext]{display:none!important}',
+      'html[data-dsbs-ptab="true"] div:has(> [data-slot="sidebar.workspaces"]){display:none!important}',
+      // Narrow: icon-only pages, the same rule the control bar follows. A tab
+      // without an icon keeps its label instead of becoming an empty box.
+      'html[data-dsbs-narrow="true"] [data-dsbs-tabs] button{max-width:64px;padding:4px 6px}',
+      'html[data-dsbs-narrow="true"] [data-dsbs-tabs] button[data-dsbs-hasicon] [data-dsbs-tablabel]{display:none}',
+      'html[data-dsbs-narrow="true"] [data-dsbs-tabs] button[data-dsbs-hasicon] [data-dsbs-tabbadge]{display:none}',
+      'html[data-dsbs-rail="true"] [data-dsbs-tabs]{padding:2px 2px 0}',
+      'html[data-dsbs-rail="true"] [data-dsbs-tabs] button{max-width:40px;padding:4px 5px}',
     ].join('\n')
 
     function assign(target) {
@@ -504,6 +580,11 @@ window.__ModuleLoader__.load({
         return DICTS[lang][key] || DICTS.en[key] || key
       }
       t.refresh = refresh
+      // Third-party tab titles may arrive as `{ zh, en }`; resolving them needs
+      // the same detector the dictionaries use, not a second guess.
+      t.langName = function () {
+        return lang
+      }
       return t
     }
 
@@ -559,6 +640,100 @@ window.__ModuleLoader__.load({
         resizeObserver: null,
         mutationObserver: null,
         raf: 0,
+        // 0.3.0 — third-party tabs. `activeTab` holds a registered id (or null
+        // for the built-in groups); `tabPanels` caches one live container per
+        // tab so a mount callback runs once and its disposer stays reachable.
+        activeTab: readActiveTab(),
+        seenTabs: Object.create(null),
+        tabStrip: null,
+        tabPanels: Object.create(null),
+        tabSignature: '',
+      }
+
+      // The public surface other plugins see. Everything here is either a
+      // function declaration (hoisted, so the object can be built before the
+      // implementations read below) or a getter that touches live state only
+      // when called.
+      var sidebarService = {
+        version: VERSION,
+        // Returns its own disposer, which is exactly what `ctx.effect(() => …)`
+        // wants, so a consumer never has to remember to unregister.
+        registerTab: function (descriptor) {
+          return registerTab(descriptor)
+        },
+        unregisterTab: function (id) {
+          return unregisterTab(id)
+        },
+        getTabs: function () {
+          return tabSnapshot()
+        },
+        activateTab: function (id) {
+          return activateTab(id)
+        },
+        getActiveTab: function () {
+          return runtime.activeTab && findTab(runtime.activeTab) ? runtime.activeTab : null
+        },
+        // A consumer can follow the strip instead of polling it: called with
+        // (tabs, reason, activeId) whenever the list or the selection changes.
+        subscribe: function (listener) {
+          if (typeof listener !== 'function') return function () {}
+          tabListeners.push(listener)
+          var off = false
+          return function () {
+            if (off) return
+            off = true
+            var at = tabListeners.indexOf(listener)
+            if (at >= 0) tabListeners.splice(at, 1)
+          }
+        },
+        // Reading the current shape lets a consumer align with the layout
+        // instead of sniffing classes off <html>.
+        getLayout: function () {
+          return {
+            mode: config.values.mode,
+            tab: config.values.tab,
+            activeTab: runtime.activeTab,
+            narrow: runtime.narrow === true,
+            rail: runtime.rail === true,
+          }
+        },
+      }
+
+      // Publish the service once the slot system is live.
+      //
+      // Two dead ends measured against this client context, both of which take
+      // the whole sidebar down:
+      //   * ctx.provide() directly inside apply() stalls the plugin loader on
+      //     "Loading plugins..." forever;
+      //   * a static `inject: ['slots']` never activates, so apply() never runs.
+      // Publishing from inside a dependency callback is the shape that works.
+      function publishService() {
+        try {
+          if (typeof ctx.provide === 'function') ctx.provide('sidebarSuite', sidebarService)
+        } catch (error) {
+          try {
+            console.warn('[dsh-sidebar-suite] could not publish the sidebarSuite service:', error)
+          } catch (inner) {
+            void inner
+          }
+        }
+      }
+      if (typeof ctx.inject === 'function') {
+        try {
+          ctx.inject(['slots'], function () { publishService() })
+        } catch (error) {
+          publishService()
+        }
+      } else {
+        publishService()
+      }
+      // One window handle for the same object. Not a second API: it exists so a
+      // consumer can reach the service from a plain browser context (and so the
+      // release checks can drive the strip over CDP).
+      try {
+        window.__dshSidebarSuite = sidebarService
+      } catch (error) {
+        void error
       }
 
       var manualCleanups = []
@@ -572,6 +747,12 @@ window.__ModuleLoader__.load({
       var configPollPending = false
       var tempChatGuard = null
       var tempIds = [] // session ids the Host half will delete on quit
+      // 0.4.0 — per-row menu. `tempMenuEnabled` mirrors TEMP_ROW_MENU and is the
+      // escape hatch if another plugin wants the context menu on these rows.
+      var tempMenuEnabled = true
+      var tempRowMenu = null
+      var tempMenuRow = null
+      var tempMenuDismiss = null
       var tempBusy = false
       var tempToastTimer = 0
 
@@ -840,6 +1021,275 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ---- per-row menu on temporary rows (0.4.0) -----------------------
+      // A temporary session used to be all-or-nothing: either it vanished at
+      // quit, or you turned DELETE_ON_EXIT off and every temp session became a
+      // normal one. Now a single row can be promoted ("keep as a normal
+      // session") or deleted on the spot.
+      //
+      // Both actions already existed on the Host half — `untrack` and the new
+      // `remove` route — so this is purely a missing entrance. It never touches
+      // rows that are not temporary: no preventDefault, no stopPropagation, the
+      // host's own context menu keeps working everywhere else.
+
+      /** Nearest ancestor carrying data-row-key="session:<id>". */
+      function tempRowOf(node) {
+        var el = node
+        var guard = 0
+        while (el && el !== document && guard < 60) {
+          guard += 1
+          var key = el.getAttribute ? el.getAttribute('data-row-key') : ''
+          if (key && key.indexOf('session:') === 0) return el
+          el = el.parentNode
+        }
+        return null
+      }
+
+      function tempMenuButtons() {
+        var out = []
+        if (!tempRowMenu) return out
+        var list = null
+        try { list = tempRowMenu.querySelectorAll('button[data-dsbs-temp-action]') } catch (error) { void error }
+        if (!list) return out
+        for (var i = 0; i < list.length; i++) out.push(list[i])
+        return out
+      }
+
+      function closeTempMenu(restoreFocus) {
+        if (!tempRowMenu) return false
+        var row = tempMenuRow
+        try { if (tempRowMenu.parentNode) tempRowMenu.parentNode.removeChild(tempRowMenu) } catch (error) { void error }
+        tempRowMenu = null
+        tempMenuRow = null
+        detachTempMenuDismiss()
+        if (restoreFocus && row && typeof row.focus === 'function') {
+          try { row.focus() } catch (error) { void error }
+        }
+        return true
+      }
+
+      function detachTempMenuDismiss() {
+        var handlers = tempMenuDismiss
+        if (!handlers) return
+        tempMenuDismiss = null
+        try { document.removeEventListener('pointerdown', handlers.onDown, true) } catch (error) { void error }
+        try { document.removeEventListener('keydown', handlers.onKey, true) } catch (error) { void error }
+        try { window.removeEventListener('resize', handlers.onViewport) } catch (error) { void error }
+        try { window.removeEventListener('scroll', handlers.onViewport, true) } catch (error) { void error }
+      }
+
+      function attachTempMenuDismiss() {
+        if (tempMenuDismiss) return
+        var handlers = {
+          onDown: function (event) {
+            if (!tempRowMenu) return
+            var target = event && event.target
+            if (target && tempRowMenu.contains && tempRowMenu.contains(target)) return
+            closeTempMenu(false)
+          },
+          onKey: function (event) {
+            if (!tempRowMenu || !event) return
+            var key = event.key
+            if (key === 'Escape') {
+              event.preventDefault()
+              event.stopPropagation()
+              closeTempMenu(true)
+              return
+            }
+            if (key === 'Tab') { closeTempMenu(false); return }
+            if (key !== 'ArrowDown' && key !== 'ArrowUp') return
+            var buttons = tempMenuButtons()
+            if (!buttons.length) return
+            event.preventDefault()
+            var active = document.activeElement
+            var at = buttons.indexOf(active)
+            var next
+            if (key === 'ArrowDown') next = at < 0 ? 0 : (at + 1) % buttons.length
+            else next = at <= 0 ? buttons.length - 1 : at - 1
+            try { buttons[next].focus() } catch (error) { void error }
+          },
+          // The menu is positioned in viewport coordinates, so any scroll or
+          // resize would leave it floating next to the wrong row.
+          onViewport: function () { closeTempMenu(false) },
+        }
+        tempMenuDismiss = handlers
+        try { document.addEventListener('pointerdown', handlers.onDown, true) } catch (error) { void error }
+        try { document.addEventListener('keydown', handlers.onKey, true) } catch (error) { void error }
+        try { window.addEventListener('resize', handlers.onViewport) } catch (error) { void error }
+        try { window.addEventListener('scroll', handlers.onViewport, true) } catch (error) { void error }
+      }
+
+      function makeTempMenuItem(action, labelKey, hintKey, onClick) {
+        var button = document.createElement('button')
+        button.type = 'button'
+        button.setAttribute('role', 'menuitem')
+        button.setAttribute('data-dsbs-temp-action', action)
+        var label = document.createElement('span')
+        label.textContent = t(labelKey)
+        button.appendChild(label)
+        var hint = t(hintKey)
+        if (hint) {
+          var sub = document.createElement('span')
+          sub.setAttribute('data-dsbs-temp-menu-sub', '')
+          sub.textContent = hint
+          button.appendChild(sub)
+        }
+        button.addEventListener('click', function (event) {
+          if (event) {
+            event.preventDefault()
+            event.stopPropagation()
+          }
+          closeTempMenu(false)
+          onClick()
+        })
+        return button
+      }
+
+      function openTempMenu(row, id, x, y) {
+        closeTempMenu(false)
+        var menu = document.createElement('div')
+        menu.setAttribute('data-dsbs-temp-menu', '')
+        menu.setAttribute('role', 'menu')
+        menu.setAttribute('aria-label', t('temp.menu.label'))
+        // The row's own text is the only title available (the host owns the
+        // session list), and it is what the user just pointed at.
+        var text = (row.textContent || '').replace(/\s+/g, ' ').trim()
+        if (text) {
+          var head = document.createElement('div')
+          head.setAttribute('data-dsbs-temp-menu-head', '')
+          head.textContent = text.length > 48 ? text.slice(0, 48) + '…' : text
+          menu.appendChild(head)
+        }
+        menu.appendChild(makeTempMenuItem('keep', 'temp.menu.keep', 'temp.menu.keep.hint', function () {
+          keepTempSession(id)
+        }))
+        menu.appendChild(makeTempMenuItem('delete', 'temp.menu.delete', 'temp.menu.delete.hint', function () {
+          deleteTempSession(id)
+        }))
+        document.body.appendChild(menu)
+
+        // Measure first, then flip near the viewport edges. Both reads are
+        // wrapped: a detached or unmeasured node must not break the menu.
+        var width = 0
+        var height = 0
+        try {
+          var rect = menu.getBoundingClientRect ? menu.getBoundingClientRect() : null
+          width = (rect && rect.width) || menu.offsetWidth || 0
+          height = (rect && rect.height) || menu.offsetHeight || 0
+        } catch (error) { void error }
+        if (!width) width = 220
+        if (!height) height = 96
+        var vw = window.innerWidth || 1024
+        var vh = window.innerHeight || 768
+        var left = Number.isFinite(x) ? x : 0
+        var top = Number.isFinite(y) ? y : 0
+        if (left + width > vw - 8) left = Math.max(8, vw - width - 8)
+        if (top + height > vh - 8) top = Math.max(8, vh - height - 8)
+        menu.style.left = Math.round(left) + 'px'
+        menu.style.top = Math.round(top) + 'px'
+
+        tempRowMenu = menu
+        tempMenuRow = row
+        attachTempMenuDismiss()
+        var buttons = tempMenuButtons()
+        if (buttons.length) {
+          try { buttons[0].focus() } catch (error) { void error }
+        }
+      }
+
+      /** Promote one session: it stops being temporary, nothing is deleted. */
+      function keepTempSession(id) {
+        tempCall('api/dsh-temp-session.untrack?sessionId=' + encodeURIComponent(id), { method: 'POST' })
+          .then(function (data) {
+            if (!data || data.ok !== true) throw new Error((data && data.error) || 'untrack failed')
+            applyTempIdList(data.ids, id)
+            toast(t('temp.menu.kept'), false)
+            scheduleSync()
+          })
+          .catch(function (error) {
+            toast(t('temp.menu.failed') + String((error && error.message) || error), true)
+          })
+      }
+
+      /** Delete one session now, with the same fallback `purgeAll` uses. */
+      function deleteTempSession(id) {
+        tempCall('api/dsh-temp-session.remove?sessionId=' + encodeURIComponent(id), { method: 'POST' })
+          .then(function (data) {
+            if (!data || data.ok !== true) throw new Error((data && data.error) || 'delete failed')
+            applyTempIdList(data.ids, id)
+            toast(t(data.hidden ? 'temp.menu.hidden' : 'temp.menu.deleted'), false)
+            refreshHostSessions()
+            scheduleSync()
+          })
+          .catch(function (error) {
+            toast(t('temp.menu.failed') + String((error && error.message) || error), true)
+          })
+      }
+
+      /** Adopt the id list the Host returned, or just drop the one id. */
+      function applyTempIdList(ids, removedId) {
+        if (Array.isArray(ids)) tempIds = ids.slice()
+        else tempIds = tempIds.filter(function (item) { return item !== removedId })
+        applyTempRows()
+        if (tempRowMenu && tempMenuRow) {
+          var key = tempMenuRow.getAttribute('data-row-key') || ''
+          if (tempIds.indexOf(key.slice('session:'.length)) < 0) closeTempMenu(false)
+        }
+      }
+
+      /**
+       * Ask the host's own session list to re-read. There is no documented API
+       * for this, so every common name is tried and failure is silent: a row
+       * that outlives its files disappears on the next list refresh anyway.
+       */
+      function refreshHostSessions() {
+        try {
+          var ui = uiWorkspace()
+          var sessions = ui && ui.sessions
+          var names = ['reload', 'refresh', 'reloadSessions', 'invalidate']
+          for (var i = 0; i < names.length; i++) {
+            if (sessions && typeof sessions[names[i]] === 'function') {
+              sessions[names[i]]()
+              return true
+            }
+          }
+        } catch (error) {
+          void error
+        }
+        return false
+      }
+
+      function onTempContextMenu(event) {
+        if (runtime.disposed || !tempMenuEnabled || !event) return
+        var row = tempRowOf(event.target)
+        if (!row) return
+        var key = row.getAttribute('data-row-key') || ''
+        var id = key.slice('session:'.length)
+        // Not one of ours: leave the event completely alone so the host (or
+        // whichever plugin owns that row) still gets its own menu.
+        if (!id || tempIds.indexOf(id) < 0) return
+        event.preventDefault()
+        event.stopPropagation()
+        openTempMenu(row, id, event.clientX, event.clientY)
+      }
+
+      var tempMenuUnmount = null
+      function mountTempRowMenu() {
+        if (typeof document === 'undefined' || typeof document.addEventListener !== 'function') return
+        document.addEventListener('contextmenu', onTempContextMenu)
+        tempMenuUnmount = function () {
+          try { document.removeEventListener('contextmenu', onTempContextMenu) } catch (error) { void error }
+          closeTempMenu(false)
+        }
+      }
+
+      function applyTempMenuSetting(data) {
+        var next = !data || data.rowMenu !== false
+        if (next === tempMenuEnabled) return
+        tempMenuEnabled = next
+        if (!next) closeTempMenu(false)
+      }
+
       function refreshTempIds() {
         return tempCall('api/dsh-temp-session.list')
           .then(function (data) {
@@ -947,6 +1397,8 @@ window.__ModuleLoader__.load({
         expandAll = !data || data.expandAllSessions !== false
         expandAllKnown = true
         applyExpandFlag()
+        // 0.4.0 — same treatment: a Host without this key keeps the menu on.
+        applyTempMenuSetting(data)
         syncChatMode()
         expandAllSessions()
         scheduleSync()
@@ -1140,11 +1592,32 @@ window.__ModuleLoader__.load({
         return bar
       }
 
+      // A paint must be able to leave the tree exactly as it found it. Asking
+      // for an exact neighbour is not enough: the 0.3.0 tab strip (and an
+      // active plugin's panel) legitimately sit between the control bar and
+      // the host's panels nav, so `bar.nextSibling === nav` can never be true
+      // once those exist. Moving the bar on every paint mutates the observed
+      // root, which fires the MutationObserver, which schedules another paint
+      // -- a microtask loop that never returns to the event loop and hangs DSH
+      // on "Loading plugins..." with the renderer at 100%. Compare ORDER, not
+      // adjacency.
+      function isBefore(node, reference) {
+        if (!node || !reference || !node.parentNode || node.parentNode !== reference.parentNode) return false
+        var list = node.parentNode.children
+        var at = -1
+        var before = -1
+        for (var i = 0; i < list.length; i++) {
+          if (list[i] === node) at = i
+          if (list[i] === reference) before = i
+        }
+        return at >= 0 && before >= 0 && at < before
+      }
+
       function ensureBar(fx) {
         var bar = runtime.bar
         if (bar && bar.parentNode !== fx.root) {
           try {
-            bar.parentNode.removeChild(bar)
+            if (bar.parentNode) bar.parentNode.removeChild(bar)
           } catch (error) {
             void error
           }
@@ -1156,13 +1629,442 @@ window.__ModuleLoader__.load({
         }
         var anchor = fx.nav || fx.regionArea
         if (anchor && anchor.parentNode === fx.root) {
-          if (bar.nextSibling !== anchor) fx.root.insertBefore(bar, anchor)
+          if (bar.parentNode !== fx.root || !isBefore(bar, anchor)) fx.root.insertBefore(bar, anchor)
         } else if (bar.parentNode !== fx.root) {
           fx.root.appendChild(bar)
         }
         return bar
       }
 
+      // ---- third-party tabs (0.3.0) --------------------------------------
+      // Another plugin cannot reach into this bundle, so the whole feature is
+      // one service object handed to the client context (`ctx.provide` at the
+      // bottom of this file). The contract is deliberately DOM-shaped rather
+      // than React-shaped: a consumer receives a plain container and paints
+      // into it, which works for every plugin no matter how it was built.
+      //
+      // Deliberately absent: any way for a tab to restructure the sidebar.
+      // A tab owns its own container and nothing else.
+      var TAB_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,47}$/
+      var tabRecords = []
+      var tabListeners = []
+      var tabSeq = 0
+
+      function readActiveTab() {
+        try {
+          var raw = localStorage.getItem(TAB_STORE_KEY)
+          return typeof raw === 'string' && raw ? raw : null
+        } catch (error) {
+          return null
+        }
+      }
+
+      function writeActiveTab(id) {
+        try {
+          if (id) localStorage.setItem(TAB_STORE_KEY, id)
+          else localStorage.removeItem(TAB_STORE_KEY)
+        } catch (error) {
+          void error
+        }
+      }
+
+      function findTab(id) {
+        for (var i = 0; i < tabRecords.length; i++) {
+          if (tabRecords[i].id === id) return tabRecords[i]
+        }
+        return null
+      }
+
+      // `title` may be a plain string or `{ zh, en }`. Resolving it here keeps
+      // the two languages in one descriptor instead of making every consumer
+      // read the locale itself.
+      function tabTitle(record) {
+        var title = record.title
+        if (title && typeof title === 'object') {
+          var zh = typeof title.zh === 'string' ? title.zh : ''
+          var en = typeof title.en === 'string' ? title.en : ''
+          var preferred = t.langName() === 'zh' ? zh || en : en || zh
+          return preferred || record.id
+        }
+        return typeof title === 'string' && title ? title : record.id
+      }
+
+      function tabSnapshot() {
+        var out = []
+        for (var i = 0; i < tabRecords.length; i++) {
+          var record = tabRecords[i]
+          out.push({
+            id: record.id,
+            title: tabTitle(record),
+            icon: record.icon,
+            order: record.order,
+            badge: record.badge,
+            hidden: record.hidden,
+            owner: record.owner,
+          })
+        }
+        return out
+      }
+
+      function notifyTabs(reason) {
+        if (!tabListeners.length) return
+        var list = tabSnapshot()
+        var active = runtime.activeTab
+        for (var i = 0; i < tabListeners.length; i++) {
+          try {
+            tabListeners[i](list, reason, active)
+          } catch (error) {
+            void error
+          }
+        }
+      }
+
+      function tabContext(record) {
+        return {
+          id: record.id,
+          t: function (key) {
+            return t(key)
+          },
+          lang: function () {
+            return t.langName()
+          },
+          // Lets a consumer close its own tab once the user is done with it,
+          // rather than leaving a dead page in the strip.
+          close: function () {
+            if (runtime.activeTab === record.id) activateTab(null)
+          },
+        }
+      }
+
+      function createTabPanel(record) {
+        var panel = document.createElement('div')
+        panel.setAttribute('data-dsbs-tabpanel', record.id)
+        panel.setAttribute('role', 'tabpanel')
+        panel.setAttribute('aria-label', tabTitle(record))
+        panel.setAttribute('data-dsbs-visible', 'false')
+        var entry = { el: panel, cleanup: null, record: record, mounted: false }
+        runtime.tabPanels[record.id] = entry
+        return entry
+      }
+
+      // Mounting is deferred until the first activation: a tab that is never
+      // opened should cost nothing, and a container that is still `display:
+      // none` has no geometry to measure.
+      function mountTabPanel(entry) {
+        if (!entry || entry.mounted) return
+        entry.mounted = true
+        var record = entry.record
+        if (typeof record.mount !== 'function') return
+        try {
+          var result = record.mount(entry.el, tabContext(record))
+          if (typeof result === 'function') entry.cleanup = result
+          else if (result && typeof result.dispose === 'function') {
+            entry.cleanup = function () {
+              result.dispose()
+            }
+          }
+        } catch (error) {
+          // A broken consumer must never take the sidebar down with it: the
+          // failure is reported inside its own tab and logged once.
+          try {
+            entry.el.textContent = '[dsh-sidebar-suite] tab "' + record.id + '" failed to mount: '
+              + (error && error.message ? error.message : String(error))
+          } catch (inner) {
+            void inner
+          }
+          try {
+            console.error('[dsh-sidebar-suite] tab mount failed:', record.id, error)
+          } catch (inner) {
+            void inner
+          }
+        }
+      }
+
+      function disposeTabPanel(id) {
+        var entry = runtime.tabPanels[id]
+        if (!entry) return
+        delete runtime.tabPanels[id]
+        try {
+          if (typeof entry.cleanup === 'function') entry.cleanup()
+        } catch (error) {
+          void error
+        }
+        try {
+          if (entry.el && entry.el.parentNode) entry.el.parentNode.removeChild(entry.el)
+        } catch (error) {
+          void error
+        }
+      }
+
+      function disposeAllTabPanels() {
+        var ids = []
+        for (var id in runtime.tabPanels) ids.push(id)
+        for (var i = 0; i < ids.length; i++) disposeTabPanel(ids[i])
+      }
+
+      function unregisterTab(id) {
+        var record = findTab(id)
+        if (!record) return false
+        tabRecords.splice(tabRecords.indexOf(record), 1)
+        disposeTabPanel(id)
+        if (runtime.activeTab === id) {
+          runtime.activeTab = null
+          writeActiveTab(null)
+        }
+        notifyTabs('unregister')
+        scheduleSync()
+        return true
+      }
+
+      function registerTab(descriptor) {
+        if (!descriptor || typeof descriptor !== 'object') {
+          throw new TypeError('[dsh-sidebar-suite] registerTab(descriptor) needs an object')
+        }
+        var id = String(descriptor.id == null ? '' : descriptor.id).trim()
+        if (!TAB_ID_RE.test(id)) {
+          throw new TypeError('[dsh-sidebar-suite] registerTab: id must match ' + TAB_ID_RE + ', got "' + id + '"')
+        }
+        if (id === 'ext' || id === 'ws') {
+          throw new TypeError('[dsh-sidebar-suite] registerTab: "' + id + '" is reserved for a built-in group')
+        }
+        var mount = descriptor.mount || descriptor.render
+        if (typeof mount !== 'function') {
+          throw new TypeError('[dsh-sidebar-suite] registerTab: "' + id + '" needs mount(container) or render(container)')
+        }
+        var record = {
+          id: id,
+          title: descriptor.title,
+          icon: typeof descriptor.icon === 'string' ? descriptor.icon : null,
+          order: typeof descriptor.order === 'number' && isFinite(descriptor.order) ? descriptor.order : 100,
+          badge: descriptor.badge == null ? null : descriptor.badge,
+          hidden: descriptor.hidden === true,
+          mount: mount,
+          owner: descriptor.owner == null ? null : String(descriptor.owner),
+          seq: (tabSeq += 1),
+        }
+        // Re-registering the same id is exactly what a hot client reload looks
+        // like, so it replaces in place instead of stacking a duplicate page.
+        var previous = findTab(id)
+        if (previous) {
+          disposeTabPanel(id)
+          tabRecords.splice(tabRecords.indexOf(previous), 1)
+        }
+        tabRecords.push(record)
+        runtime.seenTabs[id] = true
+        notifyTabs('register')
+        scheduleSync()
+        var disposed = false
+        return function disposeTab() {
+          if (disposed) return
+          disposed = true
+          unregisterTab(id)
+        }
+      }
+
+      // Built-in groups only appear as pages in layout b. Layout a folds the
+      // two groups independently and layout c floats the panels, so a page
+      // switcher for them there would contradict what those layouts mean --
+      // third-party tabs still work in all three.
+      function tabEntries() {
+        var out = []
+        var showBuiltin = config.values.mode === 'b' && !!runtime.nav
+        if (showBuiltin) {
+          out.push({ id: 'ext', builtin: true, title: t('tab.ext'), icon: null, order: -20, badge: null })
+          out.push({ id: 'ws', builtin: true, title: t('tab.ws'), icon: null, order: -10, badge: null })
+        }
+        for (var i = 0; i < tabRecords.length; i++) {
+          var record = tabRecords[i]
+          if (record.hidden === true) continue
+          out.push({
+            id: record.id,
+            builtin: false,
+            title: tabTitle(record),
+            icon: record.icon,
+            order: record.order,
+            seq: record.seq,
+            badge: record.badge,
+          })
+        }
+        out.sort(function (left, right) {
+          if (left.builtin !== right.builtin) return left.builtin ? -1 : 1
+          if (left.order !== right.order) return left.order - right.order
+          return (left.seq || 0) - (right.seq || 0)
+        })
+        return out
+      }
+
+      function ensureTabStrip(fx) {
+        var strip = runtime.tabStrip
+        if (strip && strip.parentNode !== fx.root) {
+          try {
+            if (strip.parentNode) strip.parentNode.removeChild(strip)
+          } catch (error) {
+            void error
+          }
+          strip = null
+        }
+        if (!strip) {
+          strip = document.createElement('div')
+          strip.setAttribute('data-dsbs-tabs', '')
+          strip.setAttribute('role', 'tablist')
+          strip.setAttribute('aria-label', t('tabs.label'))
+          runtime.tabStrip = strip
+        }
+        // Sits under the control bar so the two read as one header. A plugin
+        // panel may sit after it, so "immediately after the bar" is too strict
+        // a condition for the steady state: demanding an exact previousSibling
+        // moves the strip on every paint and spins the observer loop.
+        if (strip.parentNode === fx.root && (!runtime.bar || isBefore(runtime.bar, strip))) return strip
+        var anchor = runtime.bar && runtime.bar.parentNode === fx.root
+          ? runtime.bar.nextSibling
+          : (fx.nav || fx.regionArea)
+        if (anchor === strip) return strip
+        if (anchor && anchor.parentNode === fx.root) fx.root.insertBefore(strip, anchor)
+        else fx.root.appendChild(strip)
+        return strip
+      }
+
+      function buildTabButton(entry, selected) {
+        var button = document.createElement('button')
+        button.setAttribute('type', 'button')
+        button.setAttribute('data-dsbs-tabid', entry.id)
+        button.setAttribute('role', 'tab')
+        button.setAttribute('aria-selected', selected ? 'true' : 'false')
+        button.setAttribute('title', entry.title)
+        if (selected) button.setAttribute('data-dsbs-selected', 'true')
+        if (entry.builtin) button.setAttribute('data-dsbs-builtin', entry.id)
+
+        if (typeof entry.icon === 'string' && entry.icon) {
+          var glyph = document.createElement('span')
+          glyph.setAttribute('data-dsbs-tabicon', '')
+          glyph.setAttribute('aria-hidden', 'true')
+          button.setAttribute('data-dsbs-hasicon', '')
+          if (entry.icon.charAt(0) === '<') {
+            // A consumer-supplied mark. Plugins already run arbitrary code in
+            // this page, so this grants nothing new -- but the icon still gets
+            // its own element so the label stays a text node.
+            glyph.innerHTML = entry.icon
+          } else {
+            glyph.textContent = entry.icon
+            glyph.setAttribute('data-dsbs-tabicon-text', '')
+          }
+          button.appendChild(glyph)
+        }
+
+        var label = document.createElement('span')
+        label.setAttribute('data-dsbs-tablabel', '')
+        label.textContent = entry.title
+        button.appendChild(label)
+
+        if (entry.badge != null && entry.badge !== '') {
+          var badge = document.createElement('span')
+          badge.setAttribute('data-dsbs-tabbadge', '')
+          badge.textContent = String(entry.badge)
+          button.appendChild(badge)
+        }
+
+        button.addEventListener('click', function () {
+          if (entry.builtin) {
+            // Built-ins drive the existing group switcher, so a click keeps
+            // meaning what the same click meant before 0.3.0.
+            var tookOver = runtime.activeTab !== null
+            runtime.activeTab = null
+            writeActiveTab(null)
+            setField('tab', entry.id)
+            // A click here takes the column away from a consumer tab exactly
+            // like clicking another tab does, so subscribers hear about it the
+            // same way. Without this a consumer that trusts `subscribe` would
+            // keep believing it is still on screen.
+            if (tookOver) notifyTabs('active')
+          } else {
+            activateTab(entry.id)
+          }
+        })
+        return button
+      }
+
+      function renderTabStrip() {
+        var strip = runtime.tabStrip
+        if (!strip) return
+        var entries = tabEntries()
+        var hasPlugin = false
+        for (var p = 0; p < entries.length; p++) {
+          if (!entries[p].builtin) hasPlugin = true
+        }
+        // Nothing registered: stay out of the way entirely, so a profile with
+        // no tab consumers looks exactly like 0.2.x.
+        if (!hasPlugin) {
+          strip.setAttribute('hidden', '')
+          runtime.tabSignature = ''
+          return
+        }
+        strip.removeAttribute('hidden')
+
+        var activePlugin = runtime.activeTab && findTab(runtime.activeTab) ? runtime.activeTab : null
+        var signature = (activePlugin || '-') + '|' + config.values.mode + '|' + config.values.tab + '|'
+        for (var s = 0; s < entries.length; s++) {
+          signature += entries[s].id + ':' + entries[s].title + ':' + entries[s].icon + ':' + entries[s].badge + ';'
+        }
+        if (signature === runtime.tabSignature) return
+        runtime.tabSignature = signature
+
+        while (strip.firstChild) strip.removeChild(strip.firstChild)
+        for (var i = 0; i < entries.length; i++) {
+          var entry = entries[i]
+          var selected = entry.builtin
+            ? (!activePlugin && config.values.tab === entry.id)
+            : (activePlugin === entry.id)
+          strip.appendChild(buildTabButton(entry, selected))
+        }
+      }
+
+      function placeTabPanel(panel, fx) {
+        if (panel.parentNode === fx.root) return
+        var anchor = fx.nav || fx.regionArea
+        if (anchor && anchor.parentNode === fx.root) fx.root.insertBefore(panel, anchor)
+        else fx.root.appendChild(panel)
+      }
+
+      function syncTabPanels(fx, activeId) {
+        var i
+        // The container is created the first time its tab owns the column, not
+        // at registration: a tab that is never opened should cost nothing, and
+        // a display:none container has no geometry to measure anyway.
+        if (activeId && !runtime.tabPanels[activeId]) {
+          var owning = findTab(activeId)
+          if (owning) createTabPanel(owning)
+        }
+        // Panels that are no longer registered are gone already; the ones that
+        // remain are shown only while they own the column.
+        for (var id in runtime.tabPanels) {
+          var entry = runtime.tabPanels[id]
+          if (!entry || !entry.el) continue
+          if (id === activeId) {
+            placeTabPanel(entry.el, fx)
+            entry.el.setAttribute('data-dsbs-visible', 'true')
+            entry.el.removeAttribute('aria-hidden')
+            if (!entry.mounted) mountTabPanel(entry)
+          } else {
+            entry.el.setAttribute('data-dsbs-visible', 'false')
+            entry.el.setAttribute('aria-hidden', 'true')
+          }
+        }
+        void i
+      }
+
+      function activateTab(id) {
+        if (id != null && id !== '' && !findTab(id)) return false
+        var next = id == null || id === '' ? null : String(id)
+        // Clicking the tab that already owns the column returns to the groups,
+        // which is the only way back out of a tab in layouts a and c.
+        if (next && runtime.activeTab === next) next = null
+        runtime.activeTab = next
+        writeActiveTab(next)
+        notifyTabs('active')
+        scheduleSync()
+        return true
+      }
+
       function barButton(key) {
         if (key === 'temp') return tempButton
         if (!runtime.bar) return null
@@ -1271,6 +2173,8 @@ window.__ModuleLoader__.load({
 
         if (fx.nav && !fx.nav.hasAttribute('data-dsbs-ext')) fx.nav.setAttribute('data-dsbs-ext', '')
         ensureBar(fx)
+        ensureTabStrip(fx)
+        renderTabStrip()
         placeTempButton()
         applyTempButtonVisibility()
         loadTempStatus()
@@ -1339,7 +2243,28 @@ window.__ModuleLoader__.load({
 
         var extHidden
         var wsHidden
-        if (state.mode === 'a') {
+        // A registered tab owning the column outranks every layout rule: the
+        // two groups step aside and the tab's own container takes the space.
+        var pluginTab = null
+        if (runtime.activeTab) {
+          if (findTab(runtime.activeTab)) {
+            pluginTab = runtime.activeTab
+          } else if (runtime.seenTabs[runtime.activeTab]) {
+            // It registered once and is gone now: its owner unloaded while the
+            // page was open. Fall back instead of leaving an empty column with
+            // no way out of it.
+            runtime.activeTab = null
+            writeActiveTab(null)
+            notifyTabs('orphan')
+          }
+          // Not seen yet: another plugin may still be registering during
+          // startup, so the stored id is kept and retried on the next paint.
+        }
+        setFlag(html, 'data-dsbs-ptab', !!pluginTab)
+        if (pluginTab) {
+          extHidden = true
+          wsHidden = true
+        } else if (state.mode === 'a') {
           extHidden = state.foldExt === true
           wsHidden = state.foldWs === true
         } else if (state.mode === 'b') {
@@ -1352,6 +2277,13 @@ window.__ModuleLoader__.load({
         }
         setGroupHidden(fx.nav, 'ext', extHidden)
         setGroupHidden(fx.regionArea, 'ws', wsHidden)
+        syncTabPanels(fx, pluginTab)
+        // The strip is the only affordance that survives a hidden bar, so it
+        // is repainted on every sync rather than only when its content changed.
+        if (runtime.tabStrip && pluginTab) {
+          var selectedTab = runtime.tabStrip.querySelector('[data-dsbs-tabid="' + pluginTab + '"]')
+          if (selectedTab) selectedTab.setAttribute('aria-selected', 'true')
+        }
 
         observeRoot(fx.root)
         positionPop(fx)
@@ -1437,8 +2369,32 @@ window.__ModuleLoader__.load({
       }
 
       var pending = false
+      var syncStreak = 0
+      var streakTimer = null
+      var streakDeferred = false
+      // Safety net for the observer feedback loop: a paint that mutates the
+      // observed root chains MutationObserver -> scheduleSync -> paint in
+      // microtasks forever, so the renderer never gets a turn and DSH hangs on
+      // "Loading plugins...". A healthy startup needs only a handful of syncs
+      // between two macrotasks. Cap the streak, yield once, then resume; this
+      // cannot lose a state change, and it keeps unrelated future regressions
+      // from taking the whole app down.
       function scheduleSync() {
         if (runtime.disposed || pending) return
+        if (!streakTimer) {
+          streakTimer = setTimeout(function () {
+            streakTimer = null
+            syncStreak = 0
+            var again = streakDeferred
+            streakDeferred = false
+            if (again && !runtime.disposed) scheduleSync()
+          }, 0)
+        }
+        if (syncStreak >= 16) {
+          streakDeferred = true
+          return
+        }
+        syncStreak += 1
         pending = true
         Promise.resolve().then(function () {
           pending = false
@@ -1892,6 +2848,8 @@ window.__ModuleLoader__.load({
               inChatMode: data.inChatMode === 'show' ? 'show' : 'hide',
               buttonStyle: data.buttonStyle === 'own' ? 'own' : 'pair',
               expandAllSessions: data.expandAllSessions !== false,
+              // Older Host halves have no rowMenu key; the menu ships on.
+              rowMenu: data.rowMenu !== false,
               maxKept: kept > 0 ? Math.min(Math.round(kept), 200) : 20,
               configRevision: typeof data.configRevision === 'number' ? data.configRevision : null,
               configFile: typeof data.configFile === 'string' ? data.configFile : '',
@@ -2094,6 +3052,10 @@ window.__ModuleLoader__.load({
                       persist({ expandAllSessions: next })
                     }),
                     h('div', { style: dim }, t('options.expandHint')),
+                    policyRow(t('options.rowMenu'), policy.rowMenu === true, function (next) {
+                      persist({ rowMenu: next })
+                    }),
+                    h('div', { style: dim }, t('options.rowMenuHint')),
                     h('div', { style: { display: 'flex', alignItems: 'center', gap: '8px', flexWrap: 'wrap' } },
                       h('span', { style: { fontSize: '12px', color: 'var(--dsw-alias-label-primary,inherit)' } }, t('options.maxKept')),
                       h('input', {
@@ -2397,6 +3359,14 @@ window.__ModuleLoader__.load({
         }
       }, 'sidebar-suite: dismissal')
 
+      effect(function () {
+        // 0.4.0 — right-click on a temporary row. One delegated listener on the
+        // document, because the host recreates session rows on every list
+        // refresh; per-row listeners would need re-binding after each render.
+        mountTempRowMenu()
+        return tempMenuUnmount
+      }, 'sidebar-suite: temp row menu')
+
       effect(function () {
         // Safety net: the sidebar root is created and destroyed by the host, so
         // a root replacement is invisible to an observer that watches the old
@@ -2442,6 +3412,13 @@ window.__ModuleLoader__.load({
         teardown = function () {
           if (runtime.disposed) return
           runtime.disposed = true
+          try {
+            if (streakTimer) clearTimeout(streakTimer)
+            streakTimer = null
+            streakDeferred = false
+          } catch (error) {
+            void error
+          }
           try {
             clearTimeout(tempToastTimer)
             var toastNode = document.querySelector('[data-dsbs-temp-toast]')
@@ -2495,16 +3472,51 @@ window.__ModuleLoader__.load({
           } catch (error) {
             void error
           }
+          try {
+            // 0.4.0 — the row menu lives in <body> and its document listeners
+            // outlive the sidebar if they are not dropped explicitly.
+            closeTempMenu(false)
+            detachTempMenuDismiss()
+            if (tempMenuUnmount) { tempMenuUnmount(); tempMenuUnmount = null }
+            tempRowMenu = null
+            tempMenuRow = null
+          } catch (error) {
+            void error
+          }
           try {
             if (runtime.bar && runtime.bar.parentNode) runtime.bar.parentNode.removeChild(runtime.bar)
           } catch (error) {
             void error
           }
+          try {
+            // Unmount every live tab first: a consumer's disposer may still
+            // touch its container, so removing the DOM afterwards is safer
+            // than yanking it out from under a cleanup callback.
+            disposeAllTabPanels()
+            if (runtime.tabStrip && runtime.tabStrip.parentNode) runtime.tabStrip.parentNode.removeChild(runtime.tabStrip)
+          } catch (error) {
+            void error
+          }
+          try {
+            runtime.tabStrip = null
+            runtime.tabSignature = ''
+            tabListeners.length = 0
+            tabRecords.length = 0
+          } catch (error) {
+            void error
+          }
           try {
             if (window[OWNER_KEY] === owner) delete window[OWNER_KEY]
           } catch (error) {
             void error
           }
+          try {
+            // Only drop the handle if it is still ours: a newer generation may
+            // already have replaced it, and that one must keep working.
+            if (window.__dshSidebarSuite === sidebarService) delete window.__dshSidebarSuite
+          } catch (error) {
+            void error
+          }
           try {
             if (runtime.root) runtime.root.style.removeProperty('--dsbs-pop-top')
           } catch (error) {
@@ -2538,6 +3550,7 @@ window.__ModuleLoader__.load({
             'data-dsbs-narrow',
             'data-dsbs-temp-solo',
             'data-dsbs-temp-style',
+            'data-dsbs-ptab',
           ]
           for (var i = 0; i < attributes.length; i++) {
             html.removeAttribute(attributes[i])
@@ -2564,7 +3577,6 @@ window.__ModuleLoader__.load({
       }, 'sidebar-suite: teardown')
       owner.teardown = teardown
     }
-
     return { inject: ['locale'], apply: apply }
   },
 })