dsh-sidecard-ask 1.6.0 → 1.7.1

package/client.js

@@ -47,7 +47,7 @@ window.__ModuleLoader__.load({
      * the Host and the module's `api.version` both read it, so a report can
      * never claim a generation the browser is not actually running.
      */
-    const CLIENT_VERSION = '1.6.0'
+    const CLIENT_VERSION = '1.7.1'
 
     /**
      * Tab kind served by the DSH native right rail (also its implementation id).
@@ -98,6 +98,97 @@ window.__ModuleLoader__.load({
       sideProvider: 'auto',
       floatMode: 'capsule',
       floatMaxWidth: 340,
+      // Mirrors the Host's DEFAULT_CONFIG.quickActions (contract-asserted):
+      // `builtin:*` entries are resolved through QUICK_ACTION_BUILTINS, while
+      // custom entries (no builtin prefix) carry their own label/question.
+      quickActions: [
+        { id: 'builtin:explain', enabled: true, shortcut: '' },
+        { id: 'builtin:translate', enabled: true, shortcut: '' },
+        { id: 'builtin:summarize', enabled: true, shortcut: '' },
+        { id: 'builtin:polish', enabled: true, shortcut: '' },
+        { id: 'builtin:fix', enabled: true, shortcut: '' },
+      ],
+      notifyOnDone: false,
+      contextMenu: true,
+      historyMaxCards: 10,
+    }
+
+    /**
+     * Bounds for quick-action editing, mirrored by the Host validator. The
+     * settings page refuses anything outside these before it ever posts.
+     */
+    const QUICK_ACTION_LIMITS = {
+      maxEntries: 12,
+      idLength: 40,
+      labelLength: 20,
+      questionLength: 500,
+      shortcutLength: 40,
+    }
+
+    /**
+     * Built-in quick actions. The config list only carries `builtin:<id>`;
+     * the localized label and question live HERE so the wire/config layers
+     * stay language-neutral. Questions are instructions only — the Host
+     * fences the selection separately, so none of them needs to quote text.
+     */
+    const QUICK_ACTION_BUILTINS = {
+      'builtin:explain': { labelKey: 'qaExplain', questionKey: 'qaExplainQ' },
+      'builtin:translate': { labelKey: 'qaTranslate', questionKey: 'qaTranslateQ' },
+      'builtin:summarize': { labelKey: 'qaSummarize', questionKey: 'qaSummarizeQ' },
+      'builtin:polish': { labelKey: 'qaPolish', questionKey: 'qaPolishQ' },
+      'builtin:fix': { labelKey: 'qaFix', questionKey: 'qaFixQ' },
+    }
+
+    /**
+     * Fixed follow-up chips offered under a finished answer. They submit a
+     * follow-up TURN (the answer stays in history), so the questions refer to
+     * "the answer above" rather than restating the selection. Not user
+     * configurable in P1: they are four fixed, universally useful refinements.
+     */
+    const FOLLOW_UP_CHIPS = [
+      { labelKey: 'fuShorter', questionKey: 'fuShorterQ' },
+      { labelKey: 'fuLonger', questionKey: 'fuLongerQ' },
+      { labelKey: 'fuExample', questionKey: 'fuExampleQ' },
+      { labelKey: 'fuToEnglish', questionKey: 'fuToEnglishQ' },
+    ]
+
+    /** Resolve the fixed follow-up chips for the active language. */
+    function followUpChips() {
+      return FOLLOW_UP_CHIPS.map(meta => ({ label: t(meta.labelKey), question: t(meta.questionKey) }))
+    }
+
+    /**
+     * Format a side-answer elapsed time for the card meta line. Sub-second
+     * runs show as "<1s"; everything else rounds to whole seconds (and whole
+     * minutes past 60s). Pure so both the UI and the tests share one format.
+     * @param {number} ms - elapsed milliseconds.
+     * @returns {string}
+     */
+    function formatElapsed(ms) {
+      const value = Number(ms)
+      if (!Number.isFinite(value) || value < 0) return ''
+      if (value < 1000) return '<1s'
+      const seconds = Math.round(value / 1000)
+      if (seconds < 60) return `${seconds}s`
+      const minutes = Math.floor(seconds / 60)
+      const rest = seconds % 60
+      return rest === 0 ? `${minutes}m` : `${minutes}m${rest}s`
+    }
+
+    /**
+     * Deterministic local timestamp for the history manager: `YYYY-MM-DD
+     * HH:MM`. Returns '' for an absent/legacy entry (v1 entries had no
+     * createdAt) instead of showing 1970.
+     * @param {number} ts - epoch milliseconds.
+     * @returns {string}
+     */
+    function formatHistoryTime(ts) {
+      const value = Number(ts)
+      if (!Number.isFinite(value) || value <= 0) return ''
+      const date = new Date(value)
+      const pad = n => String(n).padStart(2, '0')
+      return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+        + `${pad(date.getHours())}:${pad(date.getMinutes())}`
     }
 
     /** Zone classification: slot-key patterns the harness itself renders. */
@@ -298,6 +389,73 @@ window.__ModuleLoader__.load({
         familyLegacyToast: '检测到旧版 dsh-selection-followup 同时启用，已由本版本接管；建议卸载旧包',
         familyLegacyDiag: '旧版共载',
         familyPeers: '同页实例',
+        retryEdit: '改问',
+        editQuestionPlaceholder: '修改问题后重新提问…',
+        retryAskSubmit: '重新提问',
+        copyCode: '复制代码',
+        qaExplain: '解释',
+        qaExplainQ: '请用简洁的语言解释这段内容的含义。',
+        qaTranslate: '翻译',
+        qaTranslateQ: '请把这段内容翻译成中文；如果原文已经是中文，则翻译成英文。只输出译文，不要加解释。',
+        qaSummarize: '总结',
+        qaSummarizeQ: '请用简短的要点总结这段内容。',
+        qaPolish: '润色',
+        qaPolishQ: '请润色这段文字：保持原意、修正语病与不通顺之处，只输出润色后的内容。',
+        qaFix: '纠错',
+        qaFixQ: '请检查这段内容中的事实性、逻辑性与文字错误，逐条列出问题并给出修正建议。',
+        setQuickActions: '快捷动作',
+        setQuickActionsHint: '选中文字后显示的一键动作。自定义问题中的 {selection} 会替换为选中内容；不写占位符时，原文会随问题自动附上。',
+        qaEnabled: '启用',
+        qaAdd: '＋ 添加动作',
+        qaDelete: '删除',
+        qaBuiltinBadge: '内置',
+        qaLabelPlaceholder: '动作名称（如：英译中）',
+        qaQuestionPlaceholder: '问题指令，可用 {selection} 引用选中内容',
+        qaShortcutPlaceholder: '如 Alt+T，留空表示无快捷键',
+        qaTooMany: '快捷动作最多 {n} 条',
+        qaMalformed: '存在格式不正确的动作',
+        qaBadId: '动作 id 缺失或超长',
+        qaDuplicateId: '存在重复的动作 id',
+        qaBadLabel: '动作名称必填，且不超过 {n} 个字符',
+        qaBadQuestion: '问题指令必填，且不超过 {n} 个字符',
+        qaBadShortcut: '“{label}”的快捷键格式不正确，请用 Alt+Q 这样的写法',
+        qaDuplicateShortcut: '“{label}”的快捷键与“{other}”冲突',
+        fuShorter: '更简短',
+        fuShorterQ: '请用更简短的方式重新回答上面的问题，保留关键信息。',
+        fuLonger: '更详细',
+        fuLongerQ: '请更详细地展开回答上面的问题，补充必要的细节。',
+        fuExample: '举个例子',
+        fuExampleQ: '请结合一个具体的例子来说明上面的回答。',
+        fuToEnglish: '译成英文',
+        fuToEnglishQ: 'Please give the same answer in English.',
+        metaElapsed: '耗时',
+        metaProvider: '模型',
+        setNotifyOnDone: '完成后桌面通知',
+        setNotifyOnDoneHint: '仅当页面切到后台（其它标签页或窗口）时，作答结束才弹系统通知；首次启用需要浏览器通知权限',
+        notifyGranted: '已获得通知权限',
+        notifyDenied: '通知权限被拒绝，可在浏览器站点设置中开启',
+        notifyUnsupported: '当前环境不支持系统通知',
+        notifyDoneTitle: '侧边追问已完成',
+        notifyErrorTitle: '侧边追问失败',
+        setContextMenu: '选区右键菜单',
+        setContextMenuHint: '在可触发区域右键选中文字时，菜单顶部显示追问与快捷动作；若与宿主自身右键菜单冲突可关闭',
+        setHistoryMax: '历史卡片保存数量',
+        setHistoryMaxHint: '0 = 不保存；上限 50 张，单卡文本最多 64K',
+        historyTitle: '历史追问卡片',
+        historyDesc: '已完成的侧边卡片保存在本浏览器中，可搜索、恢复到浮层或删除；清空浏览器数据会一并删除。',
+        historySearch: '搜索问题或答案…',
+        historyEmpty: '还没有历史卡片',
+        historyRestore: '恢复',
+        historyDelete: '删除',
+        historyClear: '清空全部',
+        historyClearConfirm: '确定清空全部历史卡片吗？此操作不可撤销。',
+        historyClearDone: '历史已清空',
+        historyRestored: '已恢复到浮层',
+        historyCount: '{n} 条',
+        historyDeleted: '已删除',
+        cardKeysHint: '键盘：R 重试 · C 复制 · Esc 取消聚焦',
+        familyLegacyDiag: '旧版共载',
+        familyPeers: '同页实例',
       },
       en: {
         triggerLabel: 'Ask about selection',
@@ -438,6 +596,71 @@ window.__ModuleLoader__.load({
         familyLegacyToast: 'Legacy dsh-selection-followup detected alongside this plugin; this build took over. Uninstall the old package.',
         familyLegacyDiag: 'Legacy co-load',
         familyPeers: 'Copies on page',
+        retryEdit: 'Edit & retry',
+        editQuestionPlaceholder: 'Edit the question, then ask again…',
+        retryAskSubmit: 'Ask again',
+        copyCode: 'Copy code',
+        qaExplain: 'Explain',
+        qaExplainQ: 'Explain what this passage means, concisely.',
+        qaTranslate: 'Translate',
+        qaTranslateQ: 'Translate this passage into English; if it is already in English, translate it into Chinese. Output the translation only, with no explanation.',
+        qaSummarize: 'Summarize',
+        qaSummarizeQ: 'Summarize the key points of this passage briefly.',
+        qaPolish: 'Polish',
+        qaPolishQ: 'Polish this text: keep the original meaning, fix grammar and awkward phrasing, and output only the polished version.',
+        qaFix: 'Proofread',
+        qaFixQ: 'Check this passage for factual, logical, and writing errors. List each issue with a suggested fix.',
+        setQuickActions: 'Quick actions',
+        setQuickActionsHint: 'One-click actions shown after selecting text. In a custom question, {selection} is replaced by the selected text; without it, the source text is attached automatically.',
+        qaEnabled: 'On',
+        qaAdd: '＋ Add action',
+        qaDelete: 'Delete',
+        qaBuiltinBadge: 'built-in',
+        qaLabelPlaceholder: 'Action name (e.g. EN→ZH)',
+        qaQuestionPlaceholder: 'Question; use {selection} for the selected text',
+        qaShortcutPlaceholder: 'e.g. Alt+T; blank for none',
+        qaTooMany: 'At most {n} quick actions',
+        qaMalformed: 'A malformed action exists',
+        qaBadId: 'An action id is missing or too long',
+        qaDuplicateId: 'Duplicate action ids exist',
+        qaBadLabel: 'Action names are required and at most {n} characters',
+        qaBadQuestion: 'Questions are required and at most {n} characters',
+        qaBadShortcut: 'The shortcut for "{label}" is invalid; use a form like Alt+Q',
+        qaDuplicateShortcut: 'The shortcut for "{label}" conflicts with "{other}"',
+        fuShorter: 'Shorter',
+        fuShorterQ: 'Answer the question above again, more briefly, keeping the key points.',
+        fuLonger: 'More detail',
+        fuLongerQ: 'Expand the answer above with more detail where it helps.',
+        fuExample: 'Give an example',
+        fuExampleQ: 'Illustrate the answer above with one concrete example.',
+        fuToEnglish: 'In English',
+        fuToEnglishQ: 'Please give the same answer in English.',
+        metaElapsed: 'Elapsed',
+        metaProvider: 'Model',
+        setNotifyOnDone: 'Notify when done',
+        setNotifyOnDoneHint: 'Only fires a system notification when the page is in the background (another tab or window) and the answer finishes; enabling asks for the browser notification permission once',
+        notifyGranted: 'Notification permission granted',
+        notifyDenied: 'Notification permission denied; enable it in the browser site settings',
+        notifyUnsupported: 'This environment does not support system notifications',
+        notifyDoneTitle: 'Side answer done',
+        notifyErrorTitle: 'Side answer failed',
+        setContextMenu: 'Selection context menu',
+        setContextMenuHint: 'Right-clicking a qualifying selection shows Ask plus quick actions at the top of the menu; turn off if it conflicts with the host own menu',
+        setHistoryMax: 'Saved history cards',
+        setHistoryMaxHint: '0 = do not save; up to 50 cards, at most 64K text each',
+        historyTitle: 'History cards',
+        historyDesc: 'Finished side cards are kept in this browser; search, restore to the floating layer, or delete them. Clearing browser data removes them too.',
+        historySearch: 'Search questions or answers…',
+        historyEmpty: 'No history cards yet',
+        historyRestore: 'Restore',
+        historyDelete: 'Delete',
+        historyClear: 'Clear all',
+        historyClearConfirm: 'Clear every history card? This cannot be undone.',
+        historyClearDone: 'History cleared',
+        historyRestored: 'Restored to the floating layer',
+        historyCount: '{n} cards',
+        historyDeleted: 'Deleted',
+        cardKeysHint: 'Keys: R retry · C copy · Esc unfocus',
       },
     }
 
@@ -661,7 +884,14 @@ window.__ModuleLoader__.load({
         sessionId: null,
         trigger: null,
         popover: null,
+        /** The custom selection context menu: {candidate, x, y} or null. */
+        contextMenu: null,
         cards: [],
+        /**
+         * The durable card history (localStorage v2), mirrored into the store
+         * so the settings-page manager can render/search it without IO.
+         */
+        history: [],
         toast: null,
         /** Whether the harness renders the `data-slot` zone anchors (null = unknown yet). */
         zoneAnchors: null,
@@ -1028,6 +1258,212 @@ window.__ModuleLoader__.load({
         && event.metaKey === facts.meta
     }
 
+    /**
+     * Resolve the configured quick actions into renderable, ENABLED entries.
+     * The Host validator keeps a saved list well-formed; this is the
+     * render-time guard for an in-memory/edited draft: unknown `builtin:*`
+     * ids and custom entries missing label/question are skipped.
+     * @param {object|Array} configOrList - the effective config or a raw list.
+     * @returns {Array<{id:string,label:string,question:string,shortcut:string,builtin:boolean}>}
+     */
+    function quickActionsOf(configOrList) {
+      const list = Array.isArray(configOrList) ? configOrList : configOrList?.quickActions
+      if (!Array.isArray(list)) return []
+      const out = []
+      for (const entry of list) {
+        if (entry === null || typeof entry !== 'object') continue
+        if (entry.enabled === false) continue
+        const id = String(entry.id ?? '')
+        const meta = QUICK_ACTION_BUILTINS[id]
+        if (meta !== undefined) {
+          out.push({
+            id,
+            label: t(meta.labelKey),
+            question: t(meta.questionKey),
+            shortcut: typeof entry.shortcut === 'string' ? entry.shortcut : '',
+            builtin: true,
+          })
+          continue
+        }
+        // An unknown builtin id resolves to nothing the client knows.
+        if (id.startsWith('builtin:')) continue
+        if (typeof entry.label === 'string' && entry.label.trim() !== ''
+          && typeof entry.question === 'string' && entry.question.trim() !== '') {
+          out.push({
+            id,
+            label: entry.label,
+            question: entry.question,
+            shortcut: typeof entry.shortcut === 'string' ? entry.shortcut : '',
+            builtin: false,
+          })
+        }
+      }
+      return out
+    }
+
+    /**
+     * The question actually sent for one quick action. A template containing
+     * `{selection}` embeds the (truncated) selection inline; a template
+     * without it is sent as-is, because the Host fences the selection in
+     * every prompt regardless.
+     * @param {{question?: string}} action - a resolved quick action.
+     * @param {string} selection - the raw selected text.
+     * @param {number} maxChars - the selection truncation budget.
+     * @returns {string}
+     */
+    function renderActionQuestion(action, selection, maxChars) {
+      const template = String(action?.question ?? '')
+      if (!template.includes('{selection}')) return template
+      const cut = truncateSelection(String(selection ?? ''), maxChars)
+      return template.split('{selection}').join(cut.text)
+    }
+
+    /** Canonical fingerprint of an accelerator, for duplicate detection. */
+    function shortcutFingerprint(accelerator) {
+      const facts = parseShortcut(accelerator)
+      if (facts === null) return null
+      return `${facts.ctrl ? 1 : 0}|${facts.alt ? 1 : 0}|${facts.shift ? 1 : 0}|${facts.meta ? 1 : 0}|${facts.key}`
+    }
+
+    /** Whether this browser exposes the Notification API at all. */
+    function notificationSupported() {
+      return typeof window !== 'undefined' && typeof window.Notification === 'function'
+    }
+
+    /** The Notification permission flag, or 'unsupported' in a bare WebView. */
+    function notificationPermission() {
+      if (!notificationSupported()) return 'unsupported'
+      const permission = window.Notification.permission
+      return typeof permission === 'string' ? permission : 'default'
+    }
+
+    /**
+     * Whether a finished run should raise a desktop notification right now.
+     * All four conditions must hold: the feature is enabled, the page is in
+     * the BACKGROUND (notifying a visible page is just noise), the browser
+     * granted permission, and this card has not been notified yet.
+     * @param {object} config - effective config.
+     * @param {boolean} hidden - document.hidden at the terminal moment.
+     * @param {string} permission - notificationPermission() result.
+     * @param {boolean} alreadyNotified - guard against duplicate notices.
+     */
+    function shouldNotifyFinish(config, hidden, permission, alreadyNotified) {
+      return config?.notifyOnDone === true
+        && hidden === true
+        && permission === 'granted'
+        && alreadyNotified !== true
+    }
+
+    /** Title/body for one card's finish notification (error vs done). */
+    function buildFinishNotification(card) {
+      const title = card?.status === 'error' ? t('notifyErrorTitle') : t('notifyDoneTitle')
+      const question = String(card?.question ?? '').trim()
+      return { title, body: Array.from(question).slice(0, 80).join('') }
+    }
+
+    /**
+     * Request the Notification permission once. Resolves to the resulting
+     * permission string; a rejecting/absent API degrades to 'denied' so the
+     * caller can render the toggle honestly without throwing.
+     */
+    async function requestNotificationPermission() {
+      if (!notificationSupported()) return 'unsupported'
+      try {
+        const result = await window.Notification.requestPermission()
+        return typeof result === 'string' ? result : notificationPermission()
+      } catch {
+        // Older Safari used a callback-only API; treat a thrown promise as a
+        // refusal rather than breaking the settings page.
+        return notificationPermission() === 'granted' ? 'granted' : 'denied'
+      }
+    }
+
+    /**
+     * Fire one notification for a finished card. Returns false when the
+     * feature/permission/hidden guard fails, so the caller can stay silent.
+     * Clicking the notification brings the tab forward.
+     */
+    function notifyCardFinish(card) {
+      const hidden = typeof document !== 'undefined' && document.hidden === true
+      if (!shouldNotifyFinish(store.state.config, hidden, notificationPermission(), card.notified === true)) {
+        return false
+      }
+      try {
+        const { title, body } = buildFinishNotification(card)
+        const notification = new window.Notification(title, { body, tag: `dsh-sidecard-ask:${card.id}` })
+        notification.onclick = () => {
+          try { window.focus() } catch { /* the WebView may refuse focus */ }
+          try { notification.close() } catch { /* already closed */ }
+        }
+        patchCard(card.id, { notified: true })
+        return true
+      } catch (error) {
+        console.warn(`[${PLUGIN_ID}] notification failed:`, error)
+        return false
+      }
+    }
+
+    /**
+     * Validate a settings-page quick-action draft BEFORE posting it, so the
+     * Host's all-or-nothing refusal never comes back as a surprise. Also
+     * checks that no action shortcut collides with another action or with the
+     * main popover shortcut.
+     * @param {unknown} list - the draft `quickActions` array.
+     * @param {string} mainShortcut - the configured popover shortcut.
+     * @returns {{ok: true}|{ok: false, key: string, vars?: object}}
+     */
+    function validateQuickActionsDraft(list, mainShortcut) {
+      if (!Array.isArray(list) || list.length > QUICK_ACTION_LIMITS.maxEntries) {
+        return { ok: false, key: 'qaTooMany' }
+      }
+      const ids = new Set()
+      const taken = new Map()
+      const mainFingerprint = shortcutFingerprint(mainShortcut)
+      if (mainFingerprint !== null) taken.set(mainFingerprint, '')
+      const labelOf = (entry) => {
+        const meta = QUICK_ACTION_BUILTINS[String(entry.id ?? '')]
+        return meta !== undefined ? t(meta.labelKey) : String(entry.label ?? '')
+      }
+      for (const entry of list) {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
+          return { ok: false, key: 'qaMalformed' }
+        }
+        const id = String(entry.id ?? '')
+        if (id === '' || id.length > QUICK_ACTION_LIMITS.idLength) return { ok: false, key: 'qaBadId' }
+        if (ids.has(id)) return { ok: false, key: 'qaDuplicateId' }
+        ids.add(id)
+        const meta = QUICK_ACTION_BUILTINS[id]
+        const label = labelOf(entry)
+        if (meta === undefined && !id.startsWith('builtin:')) {
+          const customLabel = String(entry.label ?? '')
+          const customQuestion = String(entry.question ?? '')
+          if (customLabel.trim() === '' || customLabel.length > QUICK_ACTION_LIMITS.labelLength) {
+            return { ok: false, key: 'qaBadLabel', vars: { n: QUICK_ACTION_LIMITS.labelLength } }
+          }
+          if (customQuestion.trim() === '' || customQuestion.length > QUICK_ACTION_LIMITS.questionLength) {
+            return { ok: false, key: 'qaBadQuestion', vars: { n: QUICK_ACTION_LIMITS.questionLength } }
+          }
+        }
+        const shortcut = String(entry.shortcut ?? '').trim()
+        if (shortcut !== '') {
+          if (parseShortcut(shortcut) === null) {
+            return { ok: false, key: 'qaBadShortcut', vars: { label } }
+          }
+          const fingerprint = shortcutFingerprint(shortcut)
+          if (taken.has(fingerprint)) {
+            const owner = taken.get(fingerprint)
+            return {
+              ok: false,
+              key: 'qaDuplicateShortcut',
+              vars: { label, other: owner === '' ? t('setShortcut') : owner },
+            }
+          }
+          taken.set(fingerprint, label)
+        }
+      }
+      return { ok: true }
+    }
+
     // ─────────────────────────────────────────────────────────────────────
     // §6 carriers
     // ─────────────────────────────────────────────────────────────────────
@@ -1363,7 +1799,7 @@ window.__ModuleLoader__.load({
    (\`html[data-platform] body>[data-dsh-better-sidebar]{-webkit-app-region:initial}\`
    plus \`[data-dsh-panel-host]>*{-webkit-app-region:no-drag}\`).
    Every surface we draw declares it. The property is inert in a browser. */
-.dsa-layer,.dsa-trigger,.dsa-pop,.dsa-float,.dsa-stack,.dsa-card,.dsa-toast,.dsa-settings{-webkit-app-region:no-drag}
+.dsa-layer,.dsa-trigger,.dsa-quickbar,.dsa-pop,.dsa-ctxmenu,.dsa-float,.dsa-stack,.dsa-card,.dsa-toast,.dsa-settings{-webkit-app-region:no-drag}
 .dsa-layer{pointer-events:none;position:relative;z-index:60}
 .dsa-trigger{pointer-events:auto;position:fixed;display:flex;align-items:center;gap:4px;
   padding:4px 8px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
@@ -1372,6 +1808,41 @@ window.__ModuleLoader__.load({
   font-family:inherit;white-space:nowrap}
 .dsa-trigger:hover{border-color:var(--dsw-alias-brand-primary, #4c8dff)}
 .dsa-trigger:focus-visible{outline:2px solid var(--dsw-alias-brand-primary, #4c8dff);outline-offset:1px}
+/* The one-click action bar: the trigger button plus compact chips, laid out
+   in one wrapping row under the selection. The container is positioned by the
+   component; chips keep their own pointer-events because .dsa-layer is a
+   click-through layer. */
+.dsa-quickbar{pointer-events:auto;position:fixed;display:flex;align-items:center;gap:6px;
+  max-width:min(620px, 92vw);flex-wrap:wrap;z-index:60}
+.dsa-chip{pointer-events:auto;padding:3px 10px;border-radius:999px;
+  border:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
+  background:var(--dsw-alias-bg-overlay, #fff);color:var(--dsw-alias-label-primary, #111);
+  font:inherit;font-size:12px;line-height:16px;cursor:pointer;white-space:nowrap;
+  box-shadow:0 2px 8px rgba(0,0,0,.14)}
+.dsa-chip:hover{border-color:var(--dsw-alias-brand-primary, #4c8dff)}
+.dsa-chip:focus-visible{outline:2px solid var(--dsw-alias-brand-primary, #4c8dff);outline-offset:1px}
+/* Chips rendered INSIDE the popover need no floating shadow. */
+.dsa-pop-chips{display:flex;gap:6px;flex-wrap:wrap}
+.dsa-pop-chips .dsa-chip{box-shadow:none}
+/* Post-answer follow-up chips live inside a card: quiet, pill-shaped, no
+   floating shadow; the row is shown only for a terminal answer with text. */
+.dsa-fu-chips{display:flex;gap:6px;flex-wrap:wrap}
+.dsa-fu-chips .dsa-chip{box-shadow:none;padding:2px 9px;font-size:11px;line-height:15px}
+/* The selection context menu: a compact vertical list at the cursor. */
+.dsa-ctxmenu{pointer-events:auto;position:fixed;z-index:65;display:flex;flex-direction:column;
+  min-width:168px;padding:4px;border-radius:10px;border:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
+  background:var(--dsw-alias-bg-overlay, #fff);color:var(--dsw-alias-label-primary, #111);
+  box-shadow:0 10px 30px rgba(0,0,0,.24);font-size:13px}
+.dsa-ctx-item{display:flex;align-items:center;gap:8px;width:100%;text-align:left;padding:6px 10px;
+  border:none;border-radius:7px;background:transparent;color:inherit;font:inherit;font-size:12px;
+  line-height:17px;cursor:pointer;white-space:nowrap}
+.dsa-ctx-item:hover,.dsa-ctx-item:focus-visible{background:var(--dsw-alias-bg-layer-2, rgba(127,127,127,.14));outline:none}
+.dsa-ctx-sep{height:1px;margin:4px 6px;background:var(--dsw-alias-border-l1, rgba(127,127,127,.25))}
+.dsa-ctx-badge{margin-left:auto;font-size:10px;color:var(--dsw-alias-label-secondary, #888)}
+/* Inside the trigger bar the main button and chips are one flex row: the
+   trigger drops its own fixed positioning, chips join the row directly. */
+.dsa-trigger-embedded{position:static;box-shadow:0 2px 10px rgba(0,0,0,.18)}
+.dsa-quickbar-chips{display:contents}
 .dsa-pop{pointer-events:auto;position:fixed;width:min(420px, 92vw);display:flex;flex-direction:column;gap:8px;
   padding:12px;border-radius:12px;border:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
   background:var(--dsw-alias-bg-overlay, #fff);color:var(--dsw-alias-label-primary, #111);
@@ -1456,6 +1927,11 @@ window.__ModuleLoader__.load({
 .dsa-table th,.dsa-table td{border:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
   padding:4px 8px;text-align:left;word-break:break-word;vertical-align:top}
 .dsa-table th{background:var(--dsw-alias-bg-layer-2, rgba(127,127,127,.12));font-weight:600}
+.dsa-pre-wrap{position:relative;margin:0 0 6px}
+.dsa-pre-wrap .dsa-pre{margin:0}
+.dsa-code-copy{position:absolute;top:4px;right:4px;padding:1px 7px;line-height:16px;
+  font-size:12px;opacity:.72;background:var(--dsw-alias-bg-overlay, #fff)}
+.dsa-code-copy:hover,.dsa-code-copy:focus-visible{opacity:1}
 .dsa-pre{margin:0 0 6px;padding:8px;border-radius:8px;overflow:auto;
   background:var(--dsw-alias-bg-layer-2, rgba(127,127,127,.12));font-size:12px;line-height:17px;
   font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
@@ -1474,6 +1950,22 @@ window.__ModuleLoader__.load({
   background:var(--dsw-alias-bg-layer-1, transparent);color:inherit}
 .dsa-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:10px}
 .dsa-check{display:flex;align-items:center;gap:6px;font-size:12px}
+/* Quick-action editor (settings page): one wrapped row per action. */
+.dsa-qa{display:flex;flex-direction:column;gap:8px}
+.dsa-qa-row{display:flex;align-items:center;gap:8px;flex-wrap:wrap;
+  padding:8px;border:1px solid var(--dsw-alias-border-l1, rgba(127,127,127,.3));border-radius:8px}
+.dsa-qa-row .dsa-input{flex:1;min-width:120px}
+.dsa-qa-question{flex-basis:100%!important;min-width:0!important}
+.dsa-qa-head{display:flex;align-items:center;gap:8px;font-size:12px;
+  color:var(--dsw-alias-label-secondary, #555)}
+/* History-card manager (settings page). */
+.dsa-hist{display:flex;flex-direction:column;gap:8px}
+.dsa-hist-row{display:flex;align-items:center;gap:8px;flex-wrap:wrap;
+  padding:8px;border:1px solid var(--dsw-alias-border-l1, rgba(127,127,127,.3));border-radius:8px}
+.dsa-hist-main{min-width:0;flex:1;display:flex;flex-direction:column;gap:2px}
+.dsa-hist-q{font-size:12px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;
+  color:var(--dsw-alias-label-primary, #111)}
+.dsa-hist-meta{font-size:11px;color:var(--dsw-alias-label-secondary, #777)}
 .dsa-diag{display:flex;flex-direction:column;gap:2px;font-size:12px;
   color:var(--dsw-alias-label-secondary, #555)}
 /* §4.5 legacy coexistence: an unmarked dsa-layer can only be the old
@@ -1559,7 +2051,33 @@ window.__ModuleLoader__.load({
             i += 1
           }
           i += 1
-          nodes.push(h('pre', { key: `f${key++}`, className: 'dsa-pre' }, h('code', null, body.join('\n'))))
+          const code = body.join('\n')
+          // A per-block copy button: answers are code-heavy, and dragging a
+          // selection across a scrollable <pre> used to miss lines. The
+          // click closes over the code text (never re-read from the DOM), and
+          // reuses the same clipboard API → selection fallback as card copy.
+          nodes.push(h('div', { key: `f${key++}`, className: 'dsa-pre-wrap' },
+            h('pre', { className: 'dsa-pre' }, h('code', null, code)),
+            h('button', {
+              type: 'button',
+              className: 'dsa-btn dsa-btn-icon dsa-code-copy',
+              title: t('copyCode'),
+              'aria-label': t('copyCode'),
+              onClick: (event) => {
+                try {
+                  const host = event?.currentTarget ?? event?.target
+                  const wrap = typeof host?.closest === 'function' ? host.closest('.dsa-pre-wrap') : null
+                  const codeNode = wrap !== null && typeof wrap?.querySelector === 'function'
+                    ? wrap.querySelector('code')
+                    : null
+                  void copyText(code, codeNode).then((result) => {
+                    toast(result === 'copied'
+                      ? t('copied')
+                      : result === 'selected' ? t('copySelectedHint') : t('copyFailed'))
+                  })
+                } catch { /* a clipboard failure must not break the card */ }
+              },
+            }, '⧉')))
           continue
         }
         if (line.includes('|') && i + 1 < lines.length && isTableSplit(lines[i + 1])) {
@@ -1706,15 +2224,15 @@ window.__ModuleLoader__.load({
     // ─────────────────────────────────────────────────────────────────────
 
     /** The in-place trigger button floating at the selection. */
-    function TriggerButton({ candidate, onOpen }) {
+    function TriggerButton({ candidate, onOpen, embedded = false }) {
       // The clamp width follows the live label: icon + gap + padding + border
       // (~38px of chrome) plus a safety margin, over the estimated label width.
       const width = Math.ceil(estimateLabelWidth(t('triggerLabel')) + 62)
-      const box = clampBox(candidate.rect, width, 30, 'below')
+      const box = embedded ? null : clampBox(candidate.rect, width, 30, 'below')
       return h('button', {
         type: 'button',
-        className: 'dsa-trigger',
-        style: { left: `${box.left}px`, top: `${box.top}px` },
+        className: embedded ? 'dsa-trigger dsa-trigger-embedded' : 'dsa-trigger',
+        style: embedded ? undefined : { left: `${box.left}px`, top: `${box.top}px` },
         title: t('triggerHint'),
         'aria-label': `${t('triggerLabel')}：${zoneLabel(candidate)}`,
         onMouseDown: (event) => { event.preventDefault() },
@@ -1726,14 +2244,141 @@ window.__ModuleLoader__.load({
       }, h('span', { 'aria-hidden': true }, '💬'), h('span', null, t('triggerLabel')))
     }
 
+    /**
+     * Compact quick-action chips, shared by the in-place trigger bar and the
+     * popover. The trigger bar lays chips out directly (`display:contents`);
+     * the popover wraps them in its own borderless chip row.
+     */
+    function QuickChips({ actions, onPick, inline = false, wrapClassName }) {
+      if (!Array.isArray(actions) || actions.length === 0) return null
+      // Roving focus with the arrow keys: chip rows sit beside the trigger
+      // button and inside the popover, and keyboard users must be able to walk
+      // them without Tabbing through the whole page.
+      const onChipKeyDown = (event, index) => {
+        if (event.key !== 'ArrowRight' && event.key !== 'ArrowLeft'
+          && event.key !== 'Home' && event.key !== 'End') return
+        const siblings = typeof event.currentTarget?.parentElement?.querySelectorAll === 'function'
+          ? [...event.currentTarget.parentElement.querySelectorAll('.dsa-chip')]
+          : []
+        if (siblings.length === 0) return
+        event.preventDefault()
+        let next = index
+        if (event.key === 'ArrowRight') next = (index + 1) % siblings.length
+        else if (event.key === 'ArrowLeft') next = (index - 1 + siblings.length) % siblings.length
+        else if (event.key === 'Home') next = 0
+        else next = siblings.length - 1
+        siblings[next]?.focus?.()
+      }
+      return h('div', { className: wrapClassName ?? (inline ? 'dsa-quickbar-chips' : 'dsa-pop-chips') },
+        actions.map((action, index) => h('button', {
+          key: action.id,
+          type: 'button',
+          className: 'dsa-chip',
+          title: typeof action.shortcut === 'string' && action.shortcut.trim() !== ''
+            ? `${action.question}\n${action.shortcut}`
+            : action.question,
+          'aria-label': `${action.label}：${action.question}`,
+          onMouseDown: (event) => { event.preventDefault() },
+          onKeyDown: event => onChipKeyDown(event, index),
+          onClick: (event) => {
+            event.preventDefault()
+            event.stopPropagation()
+            onPick(action)
+          },
+        }, action.label)))
+    }
+
+    /**
+     * The in-place trigger bar: the main "ask" button followed by every
+     * enabled quick action. A chip click skips the popover entirely — the
+     * question is fixed and the answer goes straight to the side card.
+     */
+    function TriggerBar({ candidate, config, onOpen, onQuick }) {
+      const actions = quickActionsOf(config)
+      const mainWidth = Math.ceil(estimateLabelWidth(t('triggerLabel')) + 62)
+      // Rough row width for viewport clamping: main button + 6px gap + an
+      // estimate per chip (label + ~24px padding/chrome). Wrapped rows cost
+      // height, not width, so the clamp stays usable even when it wraps.
+      const chipsWidth = actions.reduce(
+        (sum, action) => sum + Math.ceil(estimateLabelWidth(action.label) + 24), 0)
+      const rowWidth = Math.min(620, mainWidth + (actions.length > 0 ? 6 + chipsWidth : 0))
+      const box = clampBox(candidate.rect, rowWidth, 34, 'below')
+      return h('div', {
+        className: 'dsa-quickbar',
+        style: { left: `${box.left}px`, top: `${box.top}px` },
+        onMouseDown: event => event.stopPropagation(),
+      },
+        h(TriggerButton, { candidate, onOpen, embedded: true }),
+        h(QuickChips, { actions, onPick: onQuick, inline: true }))
+    }
+
+    /**
+     * The selection context menu (#8). Opens at the cursor with the main Ask
+     * entry plus the FIRST THREE enabled quick actions (kept short so it
+     * never grows past a normal context menu). This is a capability-gated
+     * overlay: the listener only suppresses the native menu when config
+     * allows it AND the candidate passes the same shouldOffer() gate as the
+     * trigger button.
+     */
+    const CONTEXT_MENU_ACTION_LIMIT = 3
+    function SelectionContextMenu({ candidate, position, config, onClose, onOpen, onQuick }) {
+      const actions = quickActionsOf(config).slice(0, CONTEXT_MENU_ACTION_LIMIT)
+      // Cursor rect: clampBox reads left/top/right/bottom.
+      const point = {
+        left: position?.x ?? 0,
+        top: position?.y ?? 0,
+        right: position?.x ?? 0,
+        bottom: position?.y ?? 0,
+        width: 0,
+        height: 0,
+      }
+      const box = clampBox(point, 200, 40 + actions.length * 31, 'below')
+      const item = (glyph, label, onClick, badge) => h('button', {
+        type: 'button',
+        className: 'dsa-ctx-item',
+        onMouseDown: event => event.preventDefault(),
+        onClick: (event) => {
+          event.preventDefault()
+          event.stopPropagation()
+          onClose()
+          onClick()
+        },
+      }, h('span', { 'aria-hidden': true }, glyph), h('span', null, label),
+        badge !== undefined ? h('span', { className: 'dsa-ctx-badge' }, badge) : null)
+      return h('div', {
+        className: 'dsa-ctxmenu',
+        role: 'menu',
+        'aria-label': t('askTitle'),
+        style: { left: `${box.left}px`, top: `${box.top}px` },
+        onMouseDown: event => event.stopPropagation(),
+        onKeyDown: (event) => { if (event.key === 'Escape') { event.stopPropagation(); onClose() } },
+      },
+        item('💬', t('triggerLabel'), () => onOpen(candidate), zoneLabel(candidate)),
+        actions.length > 0 ? h('div', { className: 'dsa-ctx-sep', 'aria-hidden': true }) : null,
+        actions.map(action => h('button', {
+          key: action.id,
+          type: 'button',
+          role: 'menuitem',
+          className: 'dsa-ctx-item',
+          onMouseDown: event => event.preventDefault(),
+          onClick: (event) => {
+            event.preventDefault()
+            event.stopPropagation()
+            onClose()
+            onQuick(action)
+          },
+        }, h('span', null, action.label))))
+    }
+
     /** The question popover. */
-    function AskPopover({ candidate, config, onClose, onSubmit }) {
+    function AskPopover({ candidate, config, onClose, onSubmit, onQuick }) {
       const [question, setQuestion] = React.useState('')
       const [carrier, setCarrier] = React.useState(config.defaultCarrier)
       const [busy, setBusy] = React.useState(false)
       const areaRef = React.useRef(null)
       const cut = truncateSelection(candidate.text, config.maxChars)
-      const box = clampBox(candidate.rect, 420, 260, 'below')
+      const box = clampBox(candidate.rect, 420, 300, 'below')
+      const quickActions = quickActionsOf(config)
 
       React.useEffect(() => {
         const area = areaRef.current
@@ -1763,6 +2408,19 @@ window.__ModuleLoader__.load({
             onClose()
             return
           }
+          // Alt+1..9 fires the Nth chip without leaving the keyboard. The alt
+          // modifier keeps it from colliding with ordinary digit input, and a
+          // composing IME sequence must pass through untouched.
+          if (event.altKey && !event.ctrlKey && !event.metaKey && !event.isComposing
+            && /^[1-9]$/.test(event.key)) {
+            const index = Number(event.key) - 1
+            const action = quickActions[index]
+            if (action !== undefined) {
+              event.preventDefault()
+              onQuick(action)
+            }
+            return
+          }
           if (event.key === 'Enter' && !event.shiftKey && !event.isComposing) {
             event.preventDefault()
             void submit()
@@ -1780,6 +2438,10 @@ window.__ModuleLoader__.load({
         codePointLength(candidate.text) > 400
           ? `${Array.from(candidate.text).slice(0, 400).join('')}…`
           : candidate.text),
+      // Same chips as the in-place bar: shortcut-only users reach them via
+      // Alt+Q, and a click here submits directly (the popover closes because
+      // submit/quickAsk both clear `popover`).
+      h(QuickChips, { actions: quickActions, onPick: action => onQuick(action) }),
       h('textarea', {
         ref: areaRef,
         className: 'dsa-textarea',
@@ -1854,8 +2516,8 @@ window.__ModuleLoader__.load({
         reasoning, renderRichText(card.text))
     }
 
-    /** Card footer: status, copy, follow-up, retry, close. */
-    function CardActions({ card, onCopy, onFollowUp, onRetry, onClose, onCancel, onSendToMain }) {
+    /** Card footer: status, copy, follow-up, retry/edit-retry, close. */
+    function CardActions({ card, onCopy, onFollowUp, onRetry, onRetryEdit, onClose, onCancel, onSendToMain }) {
       const terminal = card.status === 'done' || card.status === 'error' || card.status === 'stopped'
       return h('div', { className: 'dsa-row' },
         h('span', { className: 'dsa-muted' },
@@ -1865,9 +2527,15 @@ window.__ModuleLoader__.load({
         card.status === 'streaming'
           ? h('button', { type: 'button', className: 'dsa-btn', onClick: onCancel }, t('cancelAnswer'))
           : null,
-        terminal && card.status !== 'done'
+        terminal && card.status !== 'done' && card.carrier === 'side'
           ? h('button', { type: 'button', className: 'dsa-btn', onClick: onRetry }, t('retry'))
           : null,
+        // Edit & retry is available for EVERY terminal side card: a typo in
+        // the question used to invalidate the whole card (plain retry only
+        // resends verbatim), and an error card can be corrected the same way.
+        terminal && card.carrier === 'side'
+          ? h('button', { type: 'button', className: 'dsa-btn', onClick: onRetryEdit }, t('retryEdit'))
+          : null,
         card.status === 'error' && card.carrier === 'side'
           ? h('button', { type: 'button', className: 'dsa-btn', onClick: onSendToMain }, t('sendToMain'))
           : null,
@@ -1893,9 +2561,14 @@ window.__ModuleLoader__.load({
      * (the layer is the only surface that can cover the conversation). A host
      * tab that embeds the same card passes no callback and gets no buttons.
      */
-    function AnswerCard({ card, surfaceLabel, onCopy, onFollowUp, onRetry, onClose, onCancel, onSendToMain, onFloatMode }) {
+    function AnswerCard({ card, surfaceLabel, onCopy, onFollowUp, onRetry, onRetryEdit, onClose, onCancel, onSendToMain, onFloatMode }) {
       const [followOpen, setFollowOpen] = React.useState(false)
       const [draft, setDraft] = React.useState('')
+      // Edit-&-retry editor: prefilled with the card's CURRENT question and
+      // kept separate from the follow-up draft (follow-up appends a turn;
+      // edit-retry regenerates THIS turn, keeping the card's earlier turns).
+      const [editOpen, setEditOpen] = React.useState(false)
+      const [editDraft, setEditDraft] = React.useState('')
       const answerRef = React.useRef(null)
       const config = store.state.config
       // Icon-only, so the header row keeps one line: the full labels
@@ -1908,7 +2581,46 @@ window.__ModuleLoader__.load({
         'aria-label': t(labelKey),
         onClick: () => onFloatMode(mode),
       }, glyph)
-      return h('section', { className: 'dsa-card', 'aria-label': t('answerTitle') },
+      // #10: the card is keyboard-focusable; R retries a failed/stopped run,
+      // C copies the answer, Esc releases focus. Plain keys are accepted only
+      // without modifiers and never while composing or inside an editor.
+      const onCardKeyDown = (event) => {
+        if (event.ctrlKey || event.altKey || event.metaKey || event.isComposing) return
+        const tag = String(event.target?.tagName ?? '')
+        if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'BUTTON'
+          || event.target?.closest?.('[contenteditable=""],[contenteditable="true"]') !== null) {
+          if (event.key === 'Escape' && tag !== 'INPUT' && tag !== 'TEXTAREA') {
+            event.currentTarget?.blur?.()
+          }
+          return
+        }
+        const key = String(event.key ?? '').toLowerCase()
+        if (key === 'r' && (card.status === 'error' || card.status === 'stopped')) {
+          event.preventDefault()
+          onRetry()
+        } else if (key === 'c' && card.text !== '') {
+          event.preventDefault()
+          onCopy(answerRef.current)
+        } else if (event.key === 'Escape') {
+          event.currentTarget?.blur?.()
+        }
+      }
+      const terminalWithAnswer = (card.status === 'done' || card.status === 'stopped')
+        && card.carrier === 'side' && card.text !== ''
+      // #9: which model answered and how long it took. provider arrives on the
+      // start event; elapsed is measured client-side across the stream.
+      const metaBits = []
+      if (typeof card.provider === 'string' && card.provider !== '') metaBits.push(`${t('metaProvider')} ${card.provider}`)
+      if (typeof card.elapsedMs === 'number' && Number.isFinite(card.elapsedMs) && formatElapsed(card.elapsedMs) !== '') {
+        metaBits.push(`${t('metaElapsed')} ${formatElapsed(card.elapsedMs)}`)
+      }
+      return h('section', {
+        className: 'dsa-card',
+        'aria-label': t('answerTitle'),
+        tabIndex: 0,
+        title: t('cardKeysHint'),
+        onKeyDown: onCardKeyDown,
+      },
         h('div', { className: 'dsa-row' },
           h('span', { className: 'dsa-title' }, t('answerTitle')),
           h('span', { className: 'dsa-badge' }, zoneLabel(card)),
@@ -1920,6 +2632,7 @@ window.__ModuleLoader__.load({
               floatControl('off', 'floatHide', '×'))
             : null),
         h('pre', { className: 'dsa-quote' }, card.question),
+        metaBits.length > 0 ? h('div', { className: 'dsa-muted' }, metaBits.join(' · ')) : null,
         h(AnswerBody, { card, containerRef: answerRef }),
         card.toolFilter === 'unsupported'
           ? h('div', { className: 'dsa-muted' }, t('toolGuardUnavailable'))
@@ -1947,12 +2660,70 @@ window.__ModuleLoader__.load({
               },
             }))
           : null,
+        editOpen
+          ? h('div', { className: 'dsa-field' },
+            h('textarea', {
+              className: 'dsa-textarea',
+              value: editDraft,
+              placeholder: t('editQuestionPlaceholder'),
+              autoFocus: true,
+              onChange: event => setEditDraft(event.target.value),
+              onKeyDown: (event) => {
+                if (event.key === 'Enter' && !event.shiftKey && !event.isComposing) {
+                  event.preventDefault()
+                  const text = editDraft.trim()
+                  if (text === '') return
+                  setEditDraft('')
+                  setEditOpen(false)
+                  onRetryEdit(text)
+                }
+                if (event.key === 'Escape') {
+                  event.stopPropagation()
+                  setEditOpen(false)
+                }
+              },
+            }),
+            h('div', { className: 'dsa-row', style: { justifyContent: 'flex-end' } },
+              h('button', {
+                type: 'button',
+                className: 'dsa-btn',
+                onClick: () => setEditOpen(false),
+              }, t('askCancel')),
+              h('button', {
+                type: 'button',
+                className: 'dsa-btn dsa-btn-primary',
+                disabled: editDraft.trim() === '',
+                onClick: () => {
+                  const text = editDraft.trim()
+                  if (text === '') return
+                  setEditDraft('')
+                  setEditOpen(false)
+                  onRetryEdit(text)
+                },
+              }, t('retryAskSubmit'))))
+          : null,
+        // #7: one-tap refinements of a finished answer. They submit follow-up
+        // TURNS through the same handler as the textarea, so the answer stays
+        // in history and each chip costs one ordinary request.
+        terminalWithAnswer
+          ? h(QuickChips, {
+            wrapClassName: 'dsa-fu-chips',
+            actions: followUpChips(),
+            onPick: chip => onFollowUp(chip.question),
+          })
+          : null,
         h(CardActions, {
           card,
           onCopy: () => onCopy(answerRef.current),
           onRetry,
           onCancel,
           onSendToMain,
+          onRetryEdit: () => {
+            // Open with the live question, so reopening after an earlier edit
+            // re-edits the question actually asked, not the card's first one.
+            setEditDraft(card.question)
+            setEditOpen(open => !open)
+          },
           onFollowUp: () => setFollowOpen(open => !open),
           onClose,
         }),
@@ -2084,6 +2855,7 @@ window.__ModuleLoader__.load({
           onCopy: element => actions.copy(card, element),
           onFollowUp: text => actions.followUp(card, text),
           onRetry: () => actions.retry(card),
+          onRetryEdit: text => actions.retryEdit(card, text),
           onCancel: () => actions.cancel(card),
           onSendToMain: () => actions.sendToMain(card),
           onClose: () => actions.close(card),
@@ -2109,7 +2881,12 @@ window.__ModuleLoader__.load({
       },
         h(Styles, null),
         candidate !== null && popover === null && config.trigger !== 'shortcut'
-          ? h(TriggerButton, { candidate, onOpen: () => actions.openPopover(candidate) })
+          ? h(TriggerBar, {
+            candidate,
+            config,
+            onOpen: () => actions.openPopover(candidate),
+            onQuick: action => actions.quickAsk(candidate, action),
+          })
           : null,
         popover !== null
           ? h(AskPopover, {
@@ -2117,6 +2894,17 @@ window.__ModuleLoader__.load({
             config,
             onClose: () => actions.closePopover(),
             onSubmit: payload => actions.submit(popover.candidate, payload),
+            onQuick: action => actions.quickAsk(popover.candidate, action),
+          })
+          : null,
+        state.contextMenu !== null
+          ? h(SelectionContextMenu, {
+            candidate: state.contextMenu.candidate,
+            position: state.contextMenu.position,
+            config,
+            onClose: () => actions.closeContextMenu(),
+            onOpen: (candidate) => actions.openPopover(candidate),
+            onQuick: action => actions.quickAsk(state.contextMenu.candidate, action),
           })
           : null,
         h(FloatingLayer, { cards: state.cards, actions }),
@@ -2129,10 +2917,26 @@ window.__ModuleLoader__.load({
       const [draft, setDraft] = React.useState(state.config)
       const [status, setStatus] = React.useState('idle')
       const [diag, setDiag] = React.useState(null)
+      const [historyQuery, setHistoryQuery] = React.useState('')
+      const [notifyPerm, setNotifyPerm] = React.useState(
+        typeof notificationPermission === 'function' ? notificationPermission() : 'unsupported')
       const config = state.config
 
       React.useEffect(() => { setDraft(config) }, [config])
 
+      // #5: enabling the toggle asks for the Notification permission
+      // immediately, and the resulting verdict is shown beside the checkbox
+      // so a denied toggle never looks silently broken.
+      const onNotifyToggle = async (enabled) => {
+        setDraft({ ...draft, notifyOnDone: enabled })
+        if (enabled !== true) return
+        if (notifyPerm === 'granted') return
+        const result = await requestNotificationPermission()
+        setNotifyPerm(result)
+        if (result !== 'granted') toast(result === 'unsupported' ? t('notifyUnsupported') : t('notifyDenied'))
+        else toast(t('notifyGranted'))
+      }
+
       const field = (label, control, hint) => h('div', { className: 'dsa-field' },
         h('label', null, label),
         control,
@@ -2172,11 +2976,95 @@ window.__ModuleLoader__.load({
         }, options.map(name => h('option', { key: name, value: name }, name)))
       }
 
+      // ── quick-action list editor ───────────────────────────────────────
+      // The draft always carries the FULL list (the user layer replaces
+      // defaults wholesale): built-in rows are editable only in
+      // enabled/shortcut, custom rows also in label/question.
+      const qaList = () => (Array.isArray(draft.quickActions) ? draft.quickActions : [])
+      const patchAction = (index, patch) => {
+        const quickActions = qaList().map((entry, i) => (i === index ? { ...entry, ...patch } : entry))
+        setDraft({ ...draft, quickActions })
+      }
+      const addAction = () => {
+        const list = qaList()
+        // Host cap is enforced on save; do not even append beyond it.
+        if (list.length >= QUICK_ACTION_LIMITS.maxEntries) return
+        const id = `custom:${Date.now().toString(36)}-${list.length + 1}`
+        setDraft({ ...draft, quickActions: [...list, { id, label: '', question: '', enabled: true, shortcut: '' }] })
+      }
+      const removeAction = (index) => {
+        setDraft({ ...draft, quickActions: qaList().filter((_, i) => i !== index) })
+      }
+      const quickActionsEditor = h('div', { className: 'dsa-field' },
+        h('label', null, t('setQuickActions')),
+        h('div', { className: 'dsa-qa' },
+          qaList().map((entry, index) => {
+            const meta = QUICK_ACTION_BUILTINS[String(entry.id)]
+            const isBuiltin = meta !== undefined
+            return h('div', { key: `${entry.id}-${index}`, className: 'dsa-qa-row' },
+              h('label', { className: 'dsa-check', title: t('qaEnabled') },
+                h('input', {
+                  type: 'checkbox',
+                  checked: entry.enabled !== false,
+                  onChange: event => patchAction(index, { enabled: event.target.checked }),
+                }),
+                t('qaEnabled')),
+              isBuiltin ? h('span', { className: 'dsa-badge' }, t('qaBuiltinBadge')) : null,
+              isBuiltin
+                ? h('span', { className: 'dsa-title' }, t(meta.labelKey))
+                : h('input', {
+                  className: 'dsa-input',
+                  value: String(entry.label ?? ''),
+                  maxLength: QUICK_ACTION_LIMITS.labelLength,
+                  placeholder: t('qaLabelPlaceholder'),
+                  onChange: event => patchAction(index, { label: event.target.value }),
+                }),
+              h('input', {
+                className: 'dsa-input',
+                style: { maxWidth: '150px' },
+                value: String(entry.shortcut ?? ''),
+                maxLength: QUICK_ACTION_LIMITS.shortcutLength,
+                placeholder: t('qaShortcutPlaceholder'),
+                onChange: event => patchAction(index, { shortcut: event.target.value }),
+              }),
+              isBuiltin
+                ? null
+                : h('button', {
+                  type: 'button',
+                  className: 'dsa-btn',
+                  onClick: () => removeAction(index),
+                }, t('qaDelete')),
+              isBuiltin
+                ? h('div', { className: 'dsa-muted dsa-qa-question' }, t(meta.questionKey))
+                : h('input', {
+                  className: 'dsa-input dsa-qa-question',
+                  value: String(entry.question ?? ''),
+                  maxLength: QUICK_ACTION_LIMITS.questionLength,
+                  placeholder: t('qaQuestionPlaceholder'),
+                  onChange: event => patchAction(index, { question: event.target.value }),
+                }))
+          }),
+          h('div', null, h('button', {
+            type: 'button',
+            className: 'dsa-btn',
+            disabled: qaList().length >= QUICK_ACTION_LIMITS.maxEntries,
+            onClick: addAction,
+          }, t('qaAdd')))),
+        h('span', { className: 'dsa-muted' }, t('setQuickActionsHint')))
+
       const save = async () => {
         if (parseShortcut(draft.shortcut) === null) {
           setStatus(`error:${t('unsupportedTrigger')}`)
           return
         }
+        // Pre-flight the quick-action list: the Host would all-or-nothing
+        // refuse it anyway, but a local check names the offending row instead
+        // of surfacing a wire error after the save.
+        const qaResult = validateQuickActionsDraft(draft.quickActions, draft.shortcut)
+        if (qaResult.ok === false) {
+          setStatus(`error:${t(qaResult.key, qaResult.vars)}`)
+          return
+        }
         setStatus('saving')
         try {
           await actions.saveConfig(draft)
@@ -2186,6 +3074,73 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ── history manager (#6) ─────────────────────────────────────────
+      const zoneLabelOf = zone => (zone === 'chat' ? t('zoneChat') : zone === 'task' ? t('zoneTask') : t('zoneOther'))
+      const query = historyQuery.trim().toLowerCase()
+      const filteredHistory = query === ''
+        ? state.history
+        : state.history.filter(entry =>
+          String(entry.question ?? '').toLowerCase().includes(query)
+          || String(entry.text ?? '').toLowerCase().includes(query))
+      const historySection = h('div', { className: 'dsa-field' },
+        h('label', null, `${t('historyTitle')}（${t('historyCount', { n: state.history.length })}）`),
+        h('span', { className: 'dsa-muted' }, t('historyDesc')),
+        h('input', {
+          className: 'dsa-input',
+          value: historyQuery,
+          placeholder: t('historySearch'),
+          onChange: event => setHistoryQuery(event.target.value),
+        }),
+        state.history.length === 0
+          ? h('div', { className: 'dsa-muted' }, t('historyEmpty'))
+          : h('div', { className: 'dsa-hist' },
+            filteredHistory.length === 0 && query !== ''
+              ? h('div', { className: 'dsa-muted' }, t('historyEmpty'))
+              : null,
+            filteredHistory.map(entry => h('div', { key: entry.id, className: 'dsa-hist-row' },
+              h('div', { className: 'dsa-hist-main' },
+                h('div', { className: 'dsa-hist-q', title: entry.question }, entry.question),
+                h('div', { className: 'dsa-hist-meta' },
+                  [
+                    zoneLabelOf(entry.zone),
+                    formatHistoryTime(entry.createdAt),
+                    typeof entry.provider === 'string' && entry.provider !== ''
+                      ? `${t('metaProvider')} ${entry.provider}`
+                      : '',
+                    Number.isFinite(entry.elapsedMs) ? `${t('metaElapsed')} ${formatElapsed(entry.elapsedMs)}` : '',
+                  ].filter(part => part !== '').join(' · '))),
+              h('button', {
+                type: 'button',
+                className: 'dsa-btn',
+                onClick: () => actions.restoreHistoryCard(entry.id),
+              }, t('historyRestore')),
+              h('button', {
+                type: 'button',
+                className: 'dsa-btn',
+                onClick: () => {
+                  void copyText(String(entry.text ?? '')).then((result) => {
+                    toast(result === 'copied' ? t('copied') : result === 'selected' ? t('copySelectedHint') : t('copyFailed'))
+                  })
+                },
+              }, t('copy')),
+              h('button', {
+                type: 'button',
+                className: 'dsa-btn',
+                onClick: () => actions.deleteHistoryCard(entry.id),
+              }, t('historyDelete')))),
+            state.history.length > 0
+              ? h('div', null, h('button', {
+                type: 'button',
+                className: 'dsa-btn',
+                onClick: () => {
+                  // confirm() is optional in embedded WebViews; when absent,
+                  // clear immediately (the manager is explicitly user-driven).
+                  if (typeof window.confirm === 'function' && !window.confirm(t('historyClearConfirm'))) return
+                  actions.clearHistory()
+                },
+              }, t('historyClear')))
+              : null))
+
       // §4.5 a non-leader copy explains why its interaction surface is gone.
       const familyBanner = state.familyLeader === false
         ? h('div', { className: 'dsa-family-notice', role: 'status' },
@@ -2241,7 +3196,9 @@ window.__ModuleLoader__.load({
             ['inherit', t('setSideToolsInherit')],
           ])),
           field(t('setSideTimeout'), number('sideTimeoutMs', 5000, 3600000), t('setSideTimeoutHint')),
-          field(t('setSideProvider'), providerSelect(), t('setSideProviderHint'))),
+          field(t('setSideProvider'), providerSelect(), t('setSideProviderHint')),
+          field(t('setHistoryMax'), number('historyMaxCards', 0, 50), t('setHistoryMaxHint'))),
+        quickActionsEditor,
         h('label', { className: 'dsa-check' },
           h('input', {
             type: 'checkbox',
@@ -2249,6 +3206,29 @@ window.__ModuleLoader__.load({
             onChange: event => setDraft({ ...draft, showInUnclassified: event.target.checked }),
           }),
           t('setUnclassified')),
+        h('label', { className: 'dsa-check' },
+          h('input', {
+            type: 'checkbox',
+            checked: draft.contextMenu === true,
+            onChange: event => setDraft({ ...draft, contextMenu: event.target.checked }),
+          }),
+          t('setContextMenu')),
+        h('span', { className: 'dsa-muted' }, t('setContextMenuHint')),
+        h('label', { className: 'dsa-check' },
+          h('input', {
+            type: 'checkbox',
+            checked: draft.notifyOnDone === true,
+            disabled: notifyPerm === 'unsupported',
+            onChange: event => { void onNotifyToggle(event.target.checked) },
+          }),
+          t('setNotifyOnDone')),
+        h('span', { className: 'dsa-muted' },
+          notifyPerm === 'unsupported'
+            ? t('notifyUnsupported')
+            : notifyPerm === 'denied'
+              ? t('notifyDenied')
+              : t('setNotifyOnDoneHint')),
+        historySection,
         h('div', { className: 'dsa-row' },
           h('button', {
             type: 'button',
@@ -2403,28 +3383,52 @@ window.__ModuleLoader__.load({
         // server round-trip) and replayed on boot. Everything here is optional
         // by design — a private-mode window (throws on setItem), a full quota,
         // or a tampered payload must degrade to "no history", never break boot.
-        const PERSIST_KEY = 'dsh-sidecard-ask:cards:v1'
-        const PERSIST_MAX_CARDS = 10
+        // v2 (1.8.0): adds `createdAt`, a configurable cap
+        // (`historyMaxCards`, 0–50) and per-entry manager actions. The v1
+        // payload is read once and imported into v2 on boot; the v1 key is
+        // left untouched (no destructive migration), so a downgrade still
+        // finds it.
+        const PERSIST_KEY = 'dsh-sidecard-ask:cards:v2'
+        const PERSIST_LEGACY_KEY = 'dsh-sidecard-ask:cards:v1'
+        const PERSIST_FALLBACK_CARDS = 10
         const PERSIST_TEXT_LIMIT = 65536
 
+        /** Configured durable cap, clamped to the Host's 0–50 range. */
+        const historyCap = () => {
+          const value = Number(store.state.config.historyMaxCards)
+          if (!Number.isFinite(value)) return PERSIST_FALLBACK_CARDS
+          return Math.max(0, Math.min(50, Math.round(value)))
+        }
+
+        /** Parse one localStorage envelope of a given schema version. */
+        const parseEnvelope = (raw, version) => {
+          if (raw === null || raw === undefined) return []
+          try {
+            const value = JSON.parse(raw)
+            if (value?.version !== version || !Array.isArray(value.cards)) return []
+            return value.cards
+              .filter(entry => typeof entry?.id === 'string' && entry.id !== '' && typeof entry.question === 'string')
+          } catch { return [] }
+        }
+
         function readPersisted() {
           let raw = null
           try {
             raw = window.localStorage?.getItem(PERSIST_KEY)
           } catch { return [] }
-          if (raw === null || raw === undefined) return []
+          const v2 = parseEnvelope(raw, 2).slice(0, 50)
+          if (v2.length > 0 || (raw !== null && raw !== undefined)) return v2
+          // One-time v1 import: v1 entries carry no createdAt (0 = unknown).
+          let legacy = null
           try {
-            const value = JSON.parse(raw)
-            if (value?.version !== 1 || !Array.isArray(value.cards)) return []
-            return value.cards
-              .filter(entry => typeof entry?.id === 'string' && entry.id !== '' && typeof entry.question === 'string')
-              .slice(0, PERSIST_MAX_CARDS)
+            legacy = window.localStorage?.getItem(PERSIST_LEGACY_KEY)
           } catch { return [] }
+          return parseEnvelope(legacy, 1).slice(0, 50).map(entry => ({ ...entry, createdAt: 0 }))
         }
 
         function writePersisted(cards) {
           try {
-            window.localStorage?.setItem(PERSIST_KEY, JSON.stringify({ version: 1, cards }))
+            window.localStorage?.setItem(PERSIST_KEY, JSON.stringify({ version: 2, cards }))
           } catch (error) {
             // Quota or privacy mode — the cards stay on screen, just not durable.
             console.warn(`[${PLUGIN_ID}] card history not persisted:`, error)
@@ -2433,11 +3437,12 @@ window.__ModuleLoader__.load({
 
         /** Recompute the durable set from the live store and write it. */
         const syncPersisted = () => {
+          const cap = historyCap()
           const finished = store.state.cards
             .filter(card => card.carrier === 'side'
               && (card.status === 'done' || card.status === 'stopped')
               && card.text !== '')
-            .slice(0, PERSIST_MAX_CARDS)
+            .slice(0, cap)
             .map(card => ({
               id: card.id,
               question: card.question,
@@ -2450,15 +3455,38 @@ window.__ModuleLoader__.load({
               zone: card.zone,
               truncated: card.truncated === true,
               droppedChars: Number(card.droppedChars ?? 0),
+              createdAt: Number.isFinite(card.createdAt) ? card.createdAt : Date.now(),
+              provider: typeof card.provider === 'string' ? card.provider : '',
+              elapsedMs: Number.isFinite(card.elapsedMs) ? card.elapsedMs : null,
               history: Array.isArray(card.history) ? card.history.slice(-12) : [],
             }))
+          // cap === 0 disables persistence: do not touch the existing key
+          // (documented as "kept until an explicit clear"), just mirror the
+          // in-memory state (empty manager view).
+          if (cap === 0) {
+            store.set({ history: [] })
+            return
+          }
           writePersisted(finished)
+          store.set({ history: finished })
         }
 
         /** Replay finished cards from a previous page load into the store. */
         const restorePersisted = () => {
-          const saved = readPersisted()
+          // Detect the v1→v2 migration BEFORE reading: when the v2 key is
+          // absent but a legacy payload exists, the imported set is written
+          // out under v2 once (non-destructively; v1 is kept).
+          let v2Raw
+          try {
+            v2Raw = window.localStorage?.getItem(PERSIST_KEY)
+          } catch { v2Raw = null }
+          const cap = historyCap()
+          const saved = readPersisted().slice(0, cap)
+          store.set({ history: saved })
           if (saved.length === 0) return
+          if (cap > 0 && (v2Raw === null || v2Raw === undefined)) {
+            writePersisted(saved)
+          }
           const replayed = saved.map(entry => ({
             id: entry.id,
             question: entry.question,
@@ -2473,6 +3501,9 @@ window.__ModuleLoader__.load({
             droppedChars: Number(entry.droppedChars ?? 0),
             streaming: null,
             error: null,
+            provider: typeof entry.provider === 'string' && entry.provider !== '' ? entry.provider : null,
+            elapsedMs: Number.isFinite(entry.elapsedMs) ? entry.elapsedMs : null,
+            createdAt: Number.isFinite(entry.createdAt) ? entry.createdAt : 0,
             // A native/better tab cannot survive a reload, so history always
             // comes back on the flow stack where it is visible immediately.
             surface: 'flow',
@@ -2486,6 +3517,34 @@ window.__ModuleLoader__.load({
           store.set({ cards: [...replayed, ...store.state.cards] })
         }
 
+        /** Map one durable history entry back to a live flow card. */
+        const historyEntryToCard = (entry) => ({
+          id: entry.id,
+          question: entry.question,
+          selected: String(entry.selected ?? ''),
+          selection: String(entry.selection ?? ''),
+          text: String(entry.text ?? ''),
+          reasoning: String(entry.reasoning ?? ''),
+          status: entry.status === 'stopped' ? 'stopped' : 'done',
+          carrier: 'side',
+          zone: entry.zone,
+          truncated: entry.truncated === true,
+          droppedChars: Number(entry.droppedChars ?? 0),
+          streaming: null,
+          error: null,
+          provider: typeof entry.provider === 'string' && entry.provider !== '' ? entry.provider : null,
+          elapsedMs: Number.isFinite(entry.elapsedMs) ? entry.elapsedMs : null,
+          createdAt: Number.isFinite(entry.createdAt) ? entry.createdAt : 0,
+          notified: true,
+          surface: 'flow',
+          open: true,
+          history: Array.isArray(entry.history)
+            ? entry.history
+                .filter(turn => turn !== null && typeof turn === 'object')
+                .map(turn => ({ question: String(turn.question ?? ''), answer: String(turn.answer ?? '') }))
+            : [],
+        })
+
         const actions = {
           openPopover(candidate) {
             store.set({ popover: { candidate } })
@@ -2493,6 +3552,49 @@ window.__ModuleLoader__.load({
           closePopover() {
             store.set({ popover: null })
           },
+          openContextMenu(candidate, position) {
+            store.set({ contextMenu: { candidate, position } })
+          },
+          closeContextMenu() {
+            if (store.state.contextMenu !== null) store.set({ contextMenu: null })
+          },
+          /** Bring one durable card back onto the floating stack. */
+          restoreHistoryCard(id) {
+            const entry = store.state.history.find(item => item.id === id)
+            if (entry === undefined) return false
+            if (store.state.cards.some(card => card.id === id)) {
+              patchCard(id, { surface: 'flow', open: true })
+            } else {
+              store.set({ cards: [historyEntryToCard(entry), ...store.state.cards] })
+            }
+            // A hidden (off/capsule) layer would swallow the restored card;
+            // this is a session-only override, exactly like clicking expand.
+            setFloatMode('full')
+            toast(t('historyRestored'))
+            return true
+          },
+          /** Delete one entry from durable history (and its live card). */
+          deleteHistoryCard(id) {
+            const next = store.state.history
+              .filter(item => item.id !== id)
+              .slice(0, historyCap())
+            writePersisted(next)
+            store.set({
+              history: next,
+              cards: store.state.cards.filter(card => card.id !== id),
+            })
+            toast(t('historyDeleted'))
+          },
+          /** Empty the durable history without touching running cards. */
+          clearHistory() {
+            try {
+              window.localStorage?.removeItem(PERSIST_KEY)
+            } catch (error) {
+              console.warn(`[${PLUGIN_ID}] history clear failed:`, error)
+            }
+            store.set({ history: [] })
+            toast(t('historyClearDone'))
+          },
           async submit(candidate, payload) {
             store.set({ popover: null, trigger: null })
             const config = store.state.config
@@ -2514,6 +3616,13 @@ window.__ModuleLoader__.load({
               surface: 'flow',
               open: true,
               history: [],
+              // #9 transparency: provider from the start event, elapsed
+              // measured across the stream; createdAt feeds history v2.
+              provider: null,
+              elapsedMs: null,
+              createdAt: Date.now(),
+              // #5 guard: at most one notification per card.
+              notified: false,
             }
             if (payload.carrier === 'main') {
               store.set({ cards: [card, ...store.state.cards] })
@@ -2582,6 +3691,18 @@ window.__ModuleLoader__.load({
             }
             void runSideCard(card.id)
           },
+          /**
+           * One quick-action chip: resolve the template ({selection} is the
+           * only placeholder), then take the SAME path as a popover submit
+           * fixed to the side card — surface picking, render proof and the
+           * stream loop all live in submit(), so this stays a thin adapter.
+           */
+          quickAsk(candidate, action) {
+            const config = store.state.config
+            const question = renderActionQuestion(action, candidate.text, config.maxChars)
+            if (question.trim() === '') return
+            void actions.submit(candidate, { question, carrier: 'side' })
+          },
           copy(card, element) {
             void copyText(card.text, element).then((result) => {
               toast(result === 'copied' ? t('copied') : result === 'selected' ? t('copySelectedHint') : t('copyFailed'))
@@ -2622,6 +3743,25 @@ window.__ModuleLoader__.load({
             patchCard(card.id, { status: 'pending', text: '', reasoning: '', error: null, streaming: null })
             if (card.carrier === 'side') void runSideCard(card.id)
           },
+          /**
+           * Regenerate the CURRENT turn with an edited question. Unlike
+           * followUp, this does NOT push the old Q/A into `history`: the
+           * earlier turns on the card stay, the question text is replaced,
+           * and the answer streams again from scratch.
+           */
+          retryEdit(card, question) {
+            const trimmed = String(question ?? '').trim()
+            if (trimmed === '' || card.carrier !== 'side') return
+            patchCard(card.id, {
+              question: trimmed,
+              status: 'pending',
+              text: '',
+              reasoning: '',
+              error: null,
+              streaming: null,
+            })
+            void runSideCard(card.id)
+          },
           cancel(card) {
             const controller = controllers.get(card.id)
             if (controller !== undefined) {
@@ -2687,7 +3827,9 @@ window.__ModuleLoader__.load({
               } catch { /* the right rail owns its lifecycle */ }
             }
             store.set({ cards: store.state.cards.filter(item => item.id !== card.id) })
-            syncPersisted()
+            // #6: closing a card only removes it from the live surface; the
+            // durable history (written when the answer finished) is retained
+            // and managed explicitly in the settings-page history manager.
           },
           async saveConfig(patch) {
             const value = await postJson('config', patch)
@@ -2756,7 +3898,19 @@ window.__ModuleLoader__.load({
           if (card === undefined) return
           const controller = new AbortController()
           controllers.set(cardId, controller)
-          patchCard(cardId, { status: 'streaming', text: '', reasoning: '', error: null })
+          // #9: wall time from the (re)start of THIS attempt to its terminal
+          // frame. retry/retryEdit both run this function again, so the timer
+          // naturally measures the fresh attempt only.
+          const startedAt = Date.now()
+          patchCard(cardId, {
+            status: 'streaming',
+            text: '',
+            reasoning: '',
+            error: null,
+            provider: null,
+            elapsedMs: null,
+            notified: false,
+          })
           await streamAsk({
             id: cardId,
             question: card.question,
@@ -2774,6 +3928,7 @@ window.__ModuleLoader__.load({
                 // Reported by the host so the card can be honest about the
                 // read-only guard when the provider cannot take a tool filter.
                 toolFilter: typeof data?.toolFilter === 'string' ? data.toolFilter : null,
+                provider: typeof data?.provider === 'string' ? data.provider : (card.provider ?? null),
               })
             },
             onDelta: data => bufferStreamDelta(cardId, String(data?.text ?? '')),
@@ -2785,20 +3940,27 @@ window.__ModuleLoader__.load({
               if (controller.signal.aborted) return
               flushStreamBuffers()
               const current = store.state.cards.find(item => item.id === cardId)
+              const status = data?.aborted === true ? 'stopped' : 'done'
               patchCard(cardId, {
-                status: data?.aborted === true ? 'stopped' : 'done',
+                status,
                 streaming: data?.streaming === true,
                 text: typeof data?.text === 'string' && data.text !== '' ? data.text : (current?.text ?? ''),
                 reasoning: typeof data?.reasoning === 'string' ? data.reasoning : (current?.reasoning ?? ''),
+                elapsedMs: Date.now() - startedAt,
               })
               controllers.delete(cardId)
               syncPersisted()
+              // #5: background finish notification (guarded inside).
+              const finished = store.state.cards.find(item => item.id === cardId)
+              if (finished !== undefined) notifyCardFinish(finished)
             },
             onError: (error) => {
               if (controller.signal.aborted) return
               flushStreamBuffers()
-              patchCard(cardId, { status: 'error', error })
+              patchCard(cardId, { status: 'error', error, elapsedMs: Date.now() - startedAt })
               controllers.delete(cardId)
+              const failed = store.state.cards.find(item => item.id === cardId)
+              if (failed !== undefined) notifyCardFinish(failed)
             },
           })
         }
@@ -2857,12 +4019,41 @@ window.__ModuleLoader__.load({
           const element = elementOf(event.target)
           if (element !== null && element.closest('[data-dsa-root]') !== null) return
           if (store.state.popover !== null) store.set({ popover: null })
+          if (store.state.contextMenu !== null) store.set({ contextMenu: null })
+        }
+
+        // #8: right-click on a qualifying selection raises OUR menu instead
+        // of the native one. The same gates as the trigger button apply —
+        // leader, config toggle, editable-field exclusion, zone filter — and
+        // when any gate fails we do NOT preventDefault, so the host's native
+        // menu opens untouched (that is the documented conflict fallback).
+        const onContextMenu = (event) => {
+          if (store.state.familyLeader === false) return
+          const config = store.state.config
+          if (config.contextMenu !== true) return
+          const candidate = readSelection()
+          const decision = shouldOffer(candidate, config, { anchors: store.state.zoneAnchors !== false })
+          if (!decision.ok) {
+            if (store.state.contextMenu !== null) store.set({ contextMenu: null })
+            return
+          }
+          event.preventDefault()
+          event.stopPropagation()
+          actions.openContextMenu(candidate, { x: event.clientX, y: event.clientY })
         }
 
         const onKeyDown = (event) => {
           // §4.5 only the leader answers the shortcut; otherwise two copies
           // would each preventDefault and each open their own popover.
           if (store.state.familyLeader === false) return
+          // Never steal keys while the user is typing in our own popover or
+          // card editors (Enter/Escape there are handled by the components).
+          const target = elementOf(event.target)
+          if (target !== null && target.closest('[data-dsa-root]') !== null
+            && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA'
+              || target.closest('[contenteditable=""],[contenteditable="true"]') !== null)) {
+            return
+          }
           const config = store.state.config
           const facts = parseShortcut(config.shortcut)
           if (matchesShortcut(event, facts)) {
@@ -2873,13 +4064,27 @@ window.__ModuleLoader__.load({
               return
             }
           }
+          // Per-action shortcuts: the main shortcut wins on a collision, and
+          // the candidate falls back to the last raised trigger, exactly like
+          // the main shortcut. A chip then submits straight to a side card.
+          for (const action of quickActionsOf(config)) {
+            if (action.shortcut === '' || !matchesShortcut(event, parseShortcut(action.shortcut))) continue
+            const candidate = readSelection() ?? store.state.trigger
+            if (candidate !== null) {
+              event.preventDefault()
+              actions.quickAsk(candidate, action)
+              return
+            }
+          }
           if (event.key === 'Escape') {
             if (store.state.popover !== null) store.set({ popover: null })
+            if (store.state.contextMenu !== null) store.set({ contextMenu: null })
           }
         }
 
         const onScroll = () => {
           if (store.state.popover === null && store.state.trigger !== null) store.set({ trigger: null })
+          if (store.state.contextMenu !== null) store.set({ contextMenu: null })
         }
 
         if (typeof document !== 'undefined') {
@@ -2887,6 +4092,7 @@ window.__ModuleLoader__.load({
           document.addEventListener('pointerup', schedule, true)
           document.addEventListener('keyup', schedule, true)
           document.addEventListener('mousedown', onDocumentDown, true)
+          document.addEventListener('contextmenu', onContextMenu, true)
           document.addEventListener('keydown', onKeyDown, true)
           window.addEventListener('scroll', onScroll, true)
           window.addEventListener('resize', onScroll, true)
@@ -2895,6 +4101,7 @@ window.__ModuleLoader__.load({
             document.removeEventListener('pointerup', schedule, true)
             document.removeEventListener('keyup', schedule, true)
             document.removeEventListener('mousedown', onDocumentDown, true)
+            document.removeEventListener('contextmenu', onContextMenu, true)
             document.removeEventListener('keydown', onKeyDown, true)
             window.removeEventListener('scroll', onScroll, true)
             window.removeEventListener('resize', onScroll, true)
@@ -3288,6 +4495,7 @@ window.__ModuleLoader__.load({
               onCopy: element => actions.copy(card, element),
               onFollowUp: text => actions.followUp(card, text),
               onRetry: () => actions.retry(card),
+              onRetryEdit: text => actions.retryEdit(card, text),
               onCancel: () => actions.cancel(card),
               onSendToMain: () => { void actions.sendToMain(card) },
               onClose: () => actions.close(card),
@@ -3385,7 +4593,9 @@ window.__ModuleLoader__.load({
           store.set({
             trigger: null,
             popover: null,
+            contextMenu: null,
             cards: [],
+            history: [],
             toast: null,
             sessionId: null,
             surface: 'flow',
@@ -3423,6 +4633,22 @@ window.__ModuleLoader__.load({
           truncateSelection,
           parseShortcut,
           matchesShortcut,
+          quickActionsOf,
+          renderActionQuestion,
+          validateQuickActionsDraft,
+          shortcutFingerprint,
+          followUpChips,
+          formatElapsed,
+          formatHistoryTime,
+          notificationSupported,
+          notificationPermission,
+          shouldNotifyFinish,
+          buildFinishNotification,
+          requestNotificationPermission,
+          QUICK_ACTION_BUILTINS,
+          QUICK_ACTION_LIMITS,
+          FOLLOW_UP_CHIPS,
+          CONTEXT_MENU_ACTION_LIMIT,
           classifyZone,
           slotPathOf,
           shouldOffer,