total-recall-brain 3.28.2 → 3.30.0

package/bin/total-recall.mjs

@@ -40,6 +40,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLI_DIR = path.join(__dirname, '..', 'src', 'cli');
 
 const COMMANDS = {
+  app:      'app/index.mjs',
   init:     'init.mjs',
   setup:    'setup.mjs',
   start:    'start.mjs',
@@ -98,6 +99,8 @@ const COMMANDS = {
   agents:   'agent.mjs',
   plugin:   'plugin/index.mjs',
   plugins:  'plugin/index.mjs',
+  scaffold: 'plugin/scaffold-cmd.mjs',
+  'scaffold-plugin': 'plugin/scaffold-cmd.mjs',
 };
 function printHelp() {
   console.log(`
@@ -188,6 +191,26 @@ async function main() {
         }
       }
 
+      // Check for custom global-level commands next
+      let globalAgentDir = null;
+      try {
+        const gBrain = resolveBrainLayer('global');
+        globalAgentDir = gBrain.agentDir;
+      } catch (e) { /* ignore */ }
+
+      if (globalAgentDir) {
+        const customCmdPath = path.join(globalAgentDir, 'commands', `${command}.mjs`);
+        if (fs.existsSync(customCmdPath)) {
+          const handler = await import(customCmdPath);
+          if (handler.run) {
+            await handler.run(process.argv);
+          } else {
+            await handler.default(process.argv.slice(3));
+          }
+          process.exit(0);
+        }
+      }
+
       const integrationPath = path.join(agentDir, 'skills', 'total-recall', 'integrations', `${command}.md`);
       
       if (fs.existsSync(integrationPath)) {
@@ -235,7 +258,7 @@ async function main() {
               } else if (handler.default) {
                 await handler.default(process.argv.slice(3));
               }
-              process.exit(0);
+              process.exit(process.exitCode ?? 0);
             }
           }
         }

package/docs/ARCHITECTURE.md

@@ -236,27 +236,35 @@ Total Recall features a native terminal-based chat REPL (`npx total-recall chat`
 
 ---
 
-## 🧩 Plugin System & Extension Architecture
+## 🧩 Plugin System — Peer-to-Peer Customization
 
-Total Recall features a decentralized, filesystem-native plugin system that allows modular capability suites, background scholarly daemons, and custom SSSS graph schemas to extend the memory kernel without modifying core packages.
+Plugins shape one Total Recall install for a particular use (software development, research, operations, …). They can be shared **directly with another user through a hash-pinned HTTPS link**, with private mesh sharing retained for one user's own nodes. There is no central catalog, and nothing about a plugin is shown that the node cannot verify: no ratings, reviews, install counts or "verified" badges.
 
-### 1. Plugin Manifest Specification (`plugin.json`)
-Every plugin is a self-contained directory under `.agent/plugins/<id>/` (or global `~/.agent/plugins/<id>/`) containing a validated `plugin.json` conforming to `metadata.plugin.schema.json`:
-- **Metadata**: Unique lowercase kebab-case `id`, semantic `version`, `name`, and `description`.
-- **Custom SSSS Categories**: Declares domain-specific memory node categories (`ssss_schemas.categories`) with schemas and templates automatically registered during vault builds.
-- **Surface Compilation Hook**: Defines a custom context generator script (`compile.generator`) and watch triggers that assemble prioritized evolving context surfaces (up to 500k tokens).
-- **Background Tasks & Daemons**: Registers recurring cron envelopes (`tasks`) and execution entrypoints (`entrypoint`) automatically picked up by the daemon loop.
-- **Pure Unix CLI Commands**: Exposes first-class CLI commands (`cli.command` and `cli.handler`) seamlessly routed under `total-recall <command>`.
+### 1. Manifest (`plugin.json`, schema: `metadata.plugin.schema.json`)
+- **Metadata**: kebab-case `id`, semver `version`, `name`, `description`, optional `author`, `license`, `homepage`.
+- **`use_cases`**: kebab-case tags saying what the plugin is for; list/search/UI filter on them.
+- **`ssss_schemas.categories`**: memory categories the plugin adds.
+- **`compile.generator` / `compile.watch`**: a module whose `generateContext()` output is added to compiled instruction surfaces.
+- **`cli`**: a command routed as `total-recall <command>`.
+- **`tasks`**: `{ intent, schedule (5-field cron), command }` — the plugin's own CLI subcommand, run on schedule by the daemon in a child process. Every run is a `plugin.task_run` event.
+- **`openwiki_hubs`**: markdown hubs ingested into OpenWiki.
 
-### 2. Plugin Discovery & Lifecycle (`src/core/plugin-loader.mjs`)
-- **Layered Discovery**: Scans project-level (`.agent/plugins/`) and global-level (`~/.agent/plugins/`) directories. Project plugins take precedence over global plugins with identical IDs.
-- **Strict Schema Validation**: Validates all manifests against the plugin schema prior to runtime execution, flagging errors without breaking host brain stability.
-- **Symlink & Development Linking**: Developers can link in-progress plugins using `total-recall plugin install <path> --link` (or via the web UI) to enable real-time edits without reinstallation.
+### 2. Where plugins live
+- Project: `<project>/.agent/skills/total-recall/plugins/<id>/`; machine-wide: `~/.agent/skills/total-recall/plugins/<id>/`. Project shadows global by id. Installed plugins are per-brain state (`src/core/brain-state.json`) and never ship in the scaffold.
+- Bundled: `plugins/<id>/` in the package, installable on any node by id.
 
-### 3. Web Dashboard & Rating System (`frontend/src/pages/PluginsPage.tsx`)
-- **Plugin Management UI**: Dedicated `/plugins` dashboard view for browsing installed extensions, inspecting raw manifests, exploring documentation, and one-click uninstallation.
-- **Curated Discovery Catalog**: Browsable catalog of ecosystem plugins (Scientific Frontiers Engine, Meta-Harness, Code Quality & SSSS Conformance, Chrome DevTools) with single-click installation.
-- **Interactive 5-Star Rating System**: Persistent local ratings and reviews (`.agent/config/plugin-ratings.json`), verified badges, and sorting by rating, reviews, or alphabetical order.
+### 3. Install sources (`src/core/plugin-store.mjs`)
+`<bundled id>` · direct HTTPS share link · `peer:<host>/<id>` · git URL · local path (`--link` for development). Copies are written to a dot-prefixed staging directory and renamed into place. Each install writes a `plugin_record` (`system/plugins/<id>.md`: scope, source, sha256, shared, public_shared, task_runs) through the Core Contract plus a `plugin.installed` event.
+
+### 4. Peer-to-peer sharing
+- `total-recall plugin share <id>` marks a plugin shared in its record.
+- Public sharing requires a fresh `public_shared: true` opt-in. Legacy mesh-only `shared: true` records do not become public. `TR_PUBLIC_BASE_URL` supplies the externally reachable HTTPS origin; the sender gives the recipient a direct URL with `#sha256=<hash>`. The installer pins DNS to a public address and verifies the bundle hash before writing files. `GET /api/public/plugins/:id/bundle` exposes only opted-in bundles and has no listing route.
+- Peers query `GET /api/mesh/plugins` and fetch `GET /api/mesh/plugins/:id/bundle` (`src/server/routes/plugins-mesh.mjs`), guarded by `requireMeshSyncAuth` (mesh/loopback source + `TR_MESH_SYNC_TOKEN`). Read-only; only shared plugins are visible.
+- Bundles are JSON (`tr-plugin-bundle/1`) with a SHA-256 over a canonical file list (`src/core/plugin-bundle.mjs`). The installer verifies the bytes against both the bundle header and the hash the peer advertised; a mismatch installs nothing. Paths are checked for traversal; size/file-count capped.
+- `GET /api/plugins/peers` / `total-recall plugin peers` report each peer as observed: `ok`, `offline`, `unreachable`, `not_configured`, `unsupported` (older version), or `error`.
+
+### 5. Execution
+Plugin code never runs inside the brain server: the dashboard runner (`POST /api/plugins/:id/run`, `config:write`) and scheduled tasks use `src/core/plugin-runner.mjs` — a child `node` process with a timeout, an output cap, and `TR_PACKAGE_ROOT` / `TR_PLUGIN_DIR` in its environment.
 
 ---
 
@@ -285,7 +293,7 @@ The Meta-Harness treats external AI CLI tools and local neural models as pluggab
 | `ollama` | Ollama Local LLM | `pipe_stdin` | Zero-token-cost local neural inference |
 
 - **Multi-Harness Council (`total-recall harness council "<task>"`)**: Runs concurrent deliberative queries across all available local harnesses, compiling multiple perspectives into a structured comparative report.
-- **Cross-Node Harness Dispatch (`total-recall harness dispatch <id> --node <node> "<task>"`)**: Dispatches tasks to a specific harness located on another mesh node (e.g. running `ollama` models on a dedicated local machine like `macmini`).
+- **Cross-Node Harness Dispatch (`total-recall harness dispatch <id> --node <node> "<task>"`)**: Dispatches tasks to a specific harness located on another mesh node (e.g. running `ollama` models on a dedicated local machine like `build-box`).
 
 ### 3. Agent Process Management (`src/core/agent-manager.mjs`)
 

package/extension/background.js

@@ -1,115 +1,290 @@
-// Total Recall — Background Service Worker
-// Handles context menus, message routing, and passive browsing buffer.
+// Total Recall — service worker
+// Context menus, keyboard commands, omnibox search, per-tab "related memories"
+// badge, and capture. The side panel and content script talk to the brain
+// through here or through BrainClient directly.
 
-importScripts('lib/preconfigured.js', 'lib/brain-client.js');
+importScripts('lib/brain-client.js', 'lib/ui-helpers.js');
 
-// Destructure for convenience after importScripts populates self.BrainClient
-const { share, search, healthCheck } = self.BrainClient;
+const Brain = self.BrainClient;
+const UI = self.TRUi;
+
+const SETTINGS_DEFAULTS = { pageRecall: false, showPill: true, blocklist: [] };
+
+async function getSettings() {
+  return chrome.storage.sync.get(SETTINGS_DEFAULTS);
+}
 
 // ---------------------------------------------------------------------------
-// Context menu registration
+// Install / startup
 // ---------------------------------------------------------------------------
-chrome.runtime.onInstalled.addListener(() => {
-  if (chrome.sidePanel && chrome.sidePanel.setPanelBehavior) {
-    chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true }).catch(console.error);
+
+function registerPanelBehavior() {
+  chrome.sidePanel?.setPanelBehavior?.({ openPanelOnActionClick: true }).catch(() => {});
+}
+registerPanelBehavior();
+
+chrome.runtime.onInstalled.addListener(async (details) => {
+  registerPanelBehavior();
+  await chrome.contextMenus.removeAll();
+  const menus = [
+    { id: 'remember-page', title: 'Remember this page', contexts: ['page'] },
+    { id: 'remember-selection', title: 'Remember selection', contexts: ['selection'] },
+    { id: 'ask-selection', title: 'Ask Total Recall about “%s”', contexts: ['selection'] },
+    { id: 'research-selection', title: 'Research “%s”', contexts: ['selection'] },
+    { id: 'remember-link', title: 'Remember link', contexts: ['link'] },
+  ];
+  for (const menu of menus) {
+    chrome.contextMenus.create({ ...menu, documentUrlPatterns: ['http://*/*', 'https://*/*'] });
   }
+  if (details.reason === 'install') chrome.runtime.openOptionsPage();
+});
 
-  chrome.contextMenus.create({
-    id: 'send-to-brain',
-    title: 'Send to Brain',
-    contexts: ['page']
-  });
-  chrome.contextMenus.create({
-    id: 'remember-this',
-    title: 'Remember This',
-    contexts: ['selection']
-  });
-  chrome.contextMenus.create({
-    id: 'research-this',
-    title: 'Research This',
-    contexts: ['selection']
+// ---------------------------------------------------------------------------
+// Page context + feedback via the content script
+// ---------------------------------------------------------------------------
+
+function sendToTab(tabId, message, timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(null), timeoutMs);
+    try {
+      chrome.tabs.sendMessage(tabId, message, (response) => {
+        clearTimeout(timer);
+        // No content script (tab predates install, or a restricted page).
+        if (chrome.runtime.lastError) return resolve(null);
+        resolve(response || null);
+      });
+    } catch {
+      clearTimeout(timer);
+      resolve(null);
+    }
   });
-});
+}
+
+async function pageContext(tab) {
+  const ctx = await sendToTab(tab.id, { type: 'GET_PAGE_CONTEXT' });
+  return ctx || { url: tab.url, title: tab.title, description: '', selection: '', text: '' };
+}
+
+function flashBadge(tabId, ok) {
+  chrome.action.setBadgeBackgroundColor({ tabId, color: ok ? '#34d399' : '#f87171' });
+  chrome.action.setBadgeText({ tabId, text: ok ? '✓' : '!' });
+  setTimeout(() => refreshRelatedBadge(tabId), 2500);
+}
+
+function notifyTab(tabId, text, tone) {
+  sendToTab(tabId, { type: 'TR_TOAST', text, tone });
+}
 
 // ---------------------------------------------------------------------------
-// Context menu click handler
+// Capture
 // ---------------------------------------------------------------------------
-chrome.contextMenus.onClicked.addListener(async (info, tab) => {
+
+/**
+ * @param {chrome.tabs.Tab} tab
+ * @param {{action?: 'remember'|'research', selection?: string, linkUrl?: string, linkText?: string, note?: string}} opts
+ */
+async function capture(tab, opts = {}) {
+  const action = opts.action || 'remember';
+  let payload;
+
+  if (opts.linkUrl) {
+    if (!UI.isCapturableUrl(opts.linkUrl)) throw new Error('Only web links can be remembered.');
+    payload = {
+      url: opts.linkUrl,
+      title: (opts.linkText || '').trim() || opts.linkUrl,
+      excerpt: UI.buildCaptureExcerpt({ url: opts.linkUrl, note: opts.note || (tab?.title ? `Linked from “${tab.title}”` : '') }),
+      tags: ['web', 'link', UI.hostnameOf(opts.linkUrl)].filter(Boolean),
+    };
+  } else {
+    if (!tab || !UI.isCapturableUrl(tab.url)) throw new Error('This page can’t be captured.');
+    const ctx = await pageContext(tab);
+    const selection = opts.selection !== undefined ? opts.selection : ctx.selection;
+    const url = ctx.url || tab.url;
+    payload = {
+      url,
+      title: ctx.title || tab.title || url,
+      excerpt: action === 'research'
+        ? (selection || ctx.description || '').trim()
+        : UI.buildCaptureExcerpt({ url, description: ctx.description, selection, text: ctx.text, note: opts.note }),
+      tags: ['web', UI.hostnameOf(url)].filter(Boolean),
+    };
+    if (action === 'research' && selection && selection.trim()) {
+      // Researching a selection: the selection is the topic, the page is context.
+      payload.title = UI.clip(selection, 140);
+      payload.excerpt = `From ${url}`;
+    }
+  }
+
+  const result = await Brain.share({ ...payload, action, source: 'chrome-extension' });
+  chrome.runtime.sendMessage({ type: 'CAPTURED', action, result }).catch(() => {});
+  return result;
+}
+
+async function captureWithFeedback(tab, opts) {
+  const verb = opts.action === 'research' ? 'Research queued' : 'Saved to your brain';
   try {
-    if (info.menuItemId === 'send-to-brain') {
-      await share({
-        url: tab.url,
-        title: tab.title,
-        action: 'remember',
-        source: 'chrome-extension'
-      });
-      showBadge('\u2713', '#22c55e');
-    } else if (info.menuItemId === 'remember-this') {
-      await share({
-        url: tab.url,
-        title: tab.title,
-        excerpt: info.selectionText,
-        action: 'remember',
-        source: 'chrome-extension'
-      });
-      showBadge('\u2713', '#22c55e');
-    } else if (info.menuItemId === 'research-this') {
-      await share({
-        excerpt: info.selectionText,
-        action: 'research',
-        source: 'chrome-extension'
-      });
-      showBadge('\u2713', '#22c55e');
+    await capture(tab, opts);
+    if (tab?.id) {
+      flashBadge(tab.id, true);
+      notifyTab(tab.id, verb, 'success');
     }
   } catch (err) {
-    console.error('Brain API error:', err);
-    showBadge('!', '#ef4444');
+    console.warn('[Total Recall] capture failed:', err);
+    if (tab?.id) {
+      flashBadge(tab.id, false);
+      notifyTab(tab.id, err.message || 'Capture failed', 'error');
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Context menus + commands
+// ---------------------------------------------------------------------------
+
+chrome.contextMenus.onClicked.addListener((info, tab) => {
+  switch (info.menuItemId) {
+    case 'remember-page':
+      captureWithFeedback(tab, { action: 'remember', selection: '' });
+      break;
+    case 'remember-selection':
+      captureWithFeedback(tab, { action: 'remember', selection: info.selectionText || '' });
+      break;
+    case 'research-selection':
+      captureWithFeedback(tab, { action: 'research', selection: info.selectionText || '' });
+      break;
+    case 'remember-link':
+      captureWithFeedback(tab, { action: 'remember', linkUrl: info.linkUrl, linkText: info.selectionText });
+      break;
+    case 'ask-selection':
+      // sidePanel.open must run inside the user gesture, before any await.
+      if (tab?.id) chrome.sidePanel.open({ tabId: tab.id }).catch(() => {});
+      chrome.storage.session.set({
+        pendingAsk: { text: info.selectionText || '', url: tab?.url || '', title: tab?.title || '', at: Date.now() },
+      });
+      break;
   }
 });
 
+chrome.commands.onCommand.addListener(async (command, tab) => {
+  if (command !== 'remember-page') return;
+  const target = tab || (await chrome.tabs.query({ active: true, currentWindow: true }))[0];
+  captureWithFeedback(target, { action: 'remember' });
+});
+
 // ---------------------------------------------------------------------------
-// Badge helper
+// Omnibox: `tr <query>` searches the brain from the address bar
 // ---------------------------------------------------------------------------
-function showBadge(text, color) {
-  chrome.action.setBadgeText({ text });
-  chrome.action.setBadgeBackgroundColor({ color });
-  setTimeout(() => chrome.action.setBadgeText({ text: '' }), 3000);
+
+function xmlEscape(text) {
+  return String(text || '').replace(/[<>&"']/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&apos;' }[c]));
 }
 
+chrome.omnibox.setDefaultSuggestion({ description: 'Search your Total Recall brain for <match>%s</match>' });
+
+let omniboxTimer = null;
+chrome.omnibox.onInputChanged.addListener((text, suggest) => {
+  clearTimeout(omniboxTimer);
+  const query = text.trim();
+  if (query.length < 2) return;
+  omniboxTimer = setTimeout(async () => {
+    try {
+      const results = await Brain.search(query, { topK: 6 });
+      suggest(results
+        .filter((r) => r.type !== 'session' && r.slug && r.title)
+        .map((r) => ({
+          content: `slug:${r.slug}`,
+          description: `${xmlEscape(r.title)} <dim>— ${xmlEscape(r.category || 'memory')}</dim>`,
+        })));
+    } catch {
+      suggest([]);
+    }
+  }, 250);
+});
+
+chrome.omnibox.onInputEntered.addListener(async (text, disposition) => {
+  const slug = text.startsWith('slug:') ? text.slice(5) : null;
+  const url = await Brain.dashboardUrl(slug ? `/memory?slug=${encodeURIComponent(slug)}` : '/memory');
+  if (disposition === 'currentTab') chrome.tabs.update({ url });
+  else chrome.tabs.create({ url, active: disposition !== 'newBackgroundTab' });
+});
+
 // ---------------------------------------------------------------------------
-// Message listener (popup, content-script, sidepanel → background)
+// Related memories (page recall) + per-tab badge
 // ---------------------------------------------------------------------------
-chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
-  if (msg.type === 'QUERY_BRAIN') {
-    search(msg.query, msg.topK || 3)
-      .then(data => sendResponse({ memories: data.results || [] }))
-      .catch(err => sendResponse({ memories: [], error: err.message }));
-    return true; // keep channel open for async response
-  }
 
-  if (msg.type === 'SHARE') {
-    share(msg.data)
-      .then(data => sendResponse({ success: true, ...data }))
-      .catch(err => sendResponse({ success: false, error: err.message }));
-    return true;
+const relatedByTab = new Map(); // tabId -> count
+
+function refreshRelatedBadge(tabId) {
+  const count = relatedByTab.get(tabId) || 0;
+  chrome.action.setBadgeBackgroundColor({ tabId, color: '#3b82f6' });
+  chrome.action.setBadgeText({ tabId, text: count ? String(count) : '' }).catch(() => {});
+}
+
+async function queryRelated({ url, title, description }, tabId) {
+  const settings = await getSettings();
+  if (!settings.pageRecall || !UI.isCapturableUrl(url) || UI.isBlocked(url, settings.blocklist)) return [];
+  const query = [title, description].filter(Boolean).join(' — ').slice(0, 300);
+  if (!query.trim()) return [];
+  const results = await Brain.search(query, { topK: 10 });
+  const related = UI.filterRelated(results, { excludeUrl: url, limit: 5 });
+  if (tabId !== undefined) {
+    relatedByTab.set(tabId, related.length);
+    refreshRelatedBadge(tabId);
   }
+  return related;
+}
 
-  if (msg.type === 'HEALTH_CHECK') {
-    healthCheck()
-      .then(data => sendResponse({ connected: true, ...data }))
-      .catch(() => sendResponse({ connected: false }));
-    return true;
+chrome.tabs.onUpdated.addListener((tabId, changeInfo) => {
+  if (changeInfo.status === 'loading' && changeInfo.url) {
+    relatedByTab.delete(tabId);
+    refreshRelatedBadge(tabId);
   }
+});
+chrome.tabs.onRemoved.addListener((tabId) => relatedByTab.delete(tabId));
 
-  if (msg.type === 'OPEN_SIDE_PANEL') {
-    const tabId = sender.tab?.id;
-    if (!chrome.sidePanel?.open || !tabId) {
-      sendResponse({ success: false, error: 'Side panel is unavailable for this tab.' });
-      return false;
+// ---------------------------------------------------------------------------
+// Messages from the content script and side panel
+// ---------------------------------------------------------------------------
+
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+  switch (msg && msg.type) {
+    case 'QUERY_RELATED':
+      queryRelated(msg.page || {}, sender.tab?.id)
+        .then((memories) => sendResponse({ memories }))
+        .catch((err) => sendResponse({ memories: [], error: err.message }));
+      return true;
+
+    case 'CAPTURE': {
+      const run = async () => {
+        const tab = msg.tabId
+          ? await chrome.tabs.get(msg.tabId)
+          : sender.tab || (await chrome.tabs.query({ active: true, currentWindow: true }))[0];
+        return capture(tab, msg.options || {});
+      };
+      run()
+        .then((result) => sendResponse({ success: true, result }))
+        .catch((err) => sendResponse({ success: false, error: err.message, code: err.code }));
+      return true;
+    }
+
+    case 'OPEN_SIDE_PANEL': {
+      const tabId = sender.tab?.id;
+      if (!tabId || !chrome.sidePanel?.open) {
+        sendResponse({ success: false });
+        return false;
+      }
+      chrome.sidePanel.open({ tabId })
+        .then(() => sendResponse({ success: true }))
+        .catch((err) => sendResponse({ success: false, error: err.message }));
+      return true;
     }
-    chrome.sidePanel.open({ tabId })
-      .then(() => sendResponse({ success: true }))
-      .catch(err => sendResponse({ success: false, error: err.message }));
-    return true;
+
+    case 'OPEN_MEMORY':
+      Brain.dashboardUrl(`/memory?slug=${encodeURIComponent(msg.slug || '')}`)
+        .then((url) => chrome.tabs.create({ url }));
+      return false;
+
+    default:
+      return false;
   }
 });

package/extension/content-script.css

@@ -1,16 +1,10 @@
-/* Total Recall — Content Script Styles
- * The floating pill uses Shadow DOM for style isolation,
- * so this file only contains the host-level positioning.
- * Keeping it minimal to avoid conflicts with host pages. */
-
-#total-recall-pill-host {
-  /* Position is handled inline via Shadow DOM :host styles.
-   * This rule serves as a fallback and ensures the element
-   * doesn't inherit unintended styles from the host page. */
-  all: initial;
+/* Total Recall — the overlay host element only. Everything visible lives in a
+ * closed shadow root styled from content-script.js; these rules just keep the
+ * host itself from inheriting page styles. */
+total-recall-overlay#total-recall-overlay {
+  all: initial !important;
   position: fixed !important;
-  bottom: 20px !important;
   right: 20px !important;
-  z-index: 2147483647 !important;
-  pointer-events: auto !important;
+  bottom: 20px !important;
+  z-index: 2147483646 !important;
 }