superlocalmemory 3.8.0 → 3.8.2

package/src/superlocalmemory/ui/js/od-shell.js

@@ -94,6 +94,32 @@
     grp.items.forEach(function (it) { NAV_MAP[it.k] = it; });
   });
 
+  // OD panes use a short in-memory stale-while-revalidate window. Navigation
+  // inside the window is a pure DOM switch; after it expires, the shell
+  // refreshes a hidden replacement pane and keeps the mounted pane visible
+  // until the replacement settles. Values can be overridden before this
+  // script loads to make the lifecycle deterministic in the Node UI harness.
+  var PANE_CACHE_TTL_MS = Number(window.SLM_PANE_CACHE_TTL_MS) || 15000;
+  var PANE_REFRESH_QUIET_MS = Number(window.SLM_PANE_REFRESH_QUIET_MS);
+  if (!Number.isFinite(PANE_REFRESH_QUIET_MS) || PANE_REFRESH_QUIET_MS < 0) {
+    PANE_REFRESH_QUIET_MS = 150;
+  }
+  var PANE_REFRESH_MAX_MS = 30000;
+  var paneLoadState = {};
+  var paneRefreshTail = Promise.resolve();
+
+  function getPaneLoadState(paneId) {
+    if (!paneLoadState[paneId]) {
+      paneLoadState[paneId] = {
+        mounted: false,
+        loadedAt: 0,
+        refreshing: false,
+        generation: 0,
+      };
+    }
+    return paneLoadState[paneId];
+  }
+
   /* ================================================================
      Brand links
   ================================================================ */
@@ -104,7 +130,6 @@
     qualixar: 'https://qualixar.com',
     author:   'https://varunpratap.com',
     license:  'https://github.com/qualixar/superlocalmemory/blob/main/LICENSE',
-    stars:    '2,431',
   };
 
   /* ================================================================
@@ -201,6 +226,14 @@
     // Show target pane
     var pane = document.getElementById(paneId);
     if (pane) pane.classList.add('show', 'active');
+    // During a stale refresh the canonical pane is rendered off-screen and
+    // the previous pane remains as the visual snapshot. Keep that snapshot in
+    // sync with navigation so returning mid-refresh never exposes a blank pane.
+    document.querySelectorAll('[data-slm-stale-for]').forEach(function (snapshot) {
+      if (snapshot.dataset.slmStaleFor === paneId) {
+        snapshot.classList.add('show', 'active');
+      }
+    });
 
     // Update sidebar active state
     document.querySelectorAll('.nav-link[data-tab]').forEach(function (link) {
@@ -216,10 +249,16 @@
       if (headEl)  headEl.textContent  = item.t;
     }
 
-    // Dispatch Bootstrap shown.bs.tab event for backward compatibility.
-    // brain.js, dashboard.js, etc. listen on the hidden tab buttons.
+    // Mount the owning renderer before dispatching any legacy event. Returning
+    // to a mounted OD pane preserves its DOM/data instead of re-querying every
+    // API and showing skeletons again.
+    var handledByShell = triggerTabLoad(paneId);
+
+    // Dispatch Bootstrap shown.bs.tab only for panes not owned by a shell
+    // loader (currently Dashboard). OD-owned panes and direct legacy fallbacks
+    // have already loaded exactly once above.
     var tabBtn = document.getElementById(paneId.replace('-pane', '-tab'));
-    if (tabBtn) {
+    if (tabBtn && !handledByShell) {
       try {
         tabBtn.dispatchEvent(new Event('shown.bs.tab', { bubbles: true }));
       } catch (e) {}
@@ -233,8 +272,6 @@
     var contentEl = document.getElementById('main-content');
     if (contentEl) contentEl.scrollTo({ top: 0, behavior: 'instant' });
 
-    // Fire lazy data loaders
-    triggerTabLoad(paneId);
     // Deferred retry ONLY if the first render produced nothing (a pane that ran
     // before it was visible/sized). Re-running unconditionally used to wipe and
     // rebuild every pane 500ms after each switch — the visible "cards reload"
@@ -257,6 +294,152 @@
   /* ================================================================
      Lazy data loaders — same mapping as ng-shell.js triggerTabLoad
   ================================================================ */
+  function queueOdPaneRefresh(tabId, fnName) {
+    var state = getPaneLoadState(tabId);
+    if (state.refreshing) return;
+    state.refreshing = true;
+    var generation = state.generation;
+
+    // Serialising the short handoff prevents nested global fetch wrappers when
+    // a user races across several stale panes. Each pane still remains usable
+    // from its mounted DOM while it waits its turn.
+    paneRefreshTail = paneRefreshTail
+      .catch(function () {})
+      .then(function () {
+        if (state.generation !== generation) return;
+        return refreshOdPane(tabId, fnName, state, generation);
+      })
+      .catch(function (err) {
+        console.error('OD background refresh failed for ' + tabId + ':', err);
+      })
+      .then(function () {
+        state.refreshing = false;
+      });
+  }
+
+  function refreshOdPane(tabId, fnName, state, generation) {
+    var oldPane = document.getElementById(tabId);
+    if (!oldPane || typeof window[fnName] !== 'function') return Promise.resolve();
+
+    var snapshotId = tabId + '--stale-' + String(generation);
+    var freshPane = oldPane.cloneNode(false);
+    var originalDisplay = freshPane.style.display;
+    oldPane.id = snapshotId;
+    oldPane.dataset.slmStaleFor = tabId;
+    freshPane.id = tabId;
+    freshPane.style.display = 'none';
+    freshPane.dataset.slmOdRenderer = fnName;
+    oldPane.parentNode.insertBefore(freshPane, oldPane);
+
+    return new Promise(function (resolve) {
+      var originalFetch = window.fetch;
+      var pending = 0;
+      var idleTimer = null;
+      var maxTimer = null;
+      var finished = false;
+      var observer = typeof MutationObserver === 'function'
+        ? new MutationObserver(scheduleIdle)
+        : null;
+
+      function restoreFetch() {
+        if (window.fetch === trackedFetch) window.fetch = originalFetch;
+      }
+
+      function restoreSnapshot() {
+        if (freshPane.parentNode) freshPane.parentNode.removeChild(freshPane);
+        oldPane.id = tabId;
+        delete oldPane.dataset.slmStaleFor;
+        // An explicit mutation/profile invalidation wins over an in-flight
+        // refresh. Preserve the visual snapshot, but leave it unmounted so the
+        // next visit cannot accidentally re-age invalid data as a cache hit.
+        if (state.generation !== generation) {
+          delete oldPane.dataset.slmOdRenderer;
+        }
+      }
+
+      function finish(commit) {
+        if (finished) return;
+        finished = true;
+        if (idleTimer) clearTimeout(idleTimer);
+        if (maxTimer) clearTimeout(maxTimer);
+        if (observer) observer.disconnect();
+        restoreFetch();
+
+        if (commit && state.generation === generation) {
+          if (oldPane.parentNode) oldPane.parentNode.removeChild(oldPane);
+          freshPane.style.display = originalDisplay;
+          freshPane.dataset.slmOdRenderer = fnName;
+          state.mounted = true;
+          state.loadedAt = Date.now();
+        } else {
+          restoreSnapshot();
+        }
+        resolve();
+      }
+
+      function scheduleIdle() {
+        if (finished || pending > 0) return;
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(function () { finish(true); }, PANE_REFRESH_QUIET_MS);
+      }
+
+      function trackPromise(promise) {
+        pending += 1;
+        if (idleTimer) {
+          clearTimeout(idleTimer);
+          idleTimer = null;
+        }
+        Promise.resolve(promise).then(settled, settled);
+        return promise;
+      }
+
+      function settled() {
+        pending = Math.max(0, pending - 1);
+        scheduleIdle();
+      }
+
+      function patchResponse(response) {
+        ['json', 'text', 'blob', 'arrayBuffer', 'formData'].forEach(function (name) {
+          if (!response || typeof response[name] !== 'function') return;
+          var bodyReader = response[name].bind(response);
+          try {
+            response[name] = function () {
+              return trackPromise(bodyReader());
+            };
+          } catch (e) {}
+        });
+        return response;
+      }
+
+      function trackedFetch() {
+        var result;
+        try {
+          result = originalFetch.apply(window, arguments);
+        } catch (err) {
+          scheduleIdle();
+          throw err;
+        }
+        var patched = Promise.resolve(result).then(patchResponse);
+        trackPromise(patched);
+        return patched;
+      }
+
+      if (observer) {
+        observer.observe(freshPane, { childList: true, subtree: true, characterData: true });
+      }
+      if (typeof originalFetch === 'function') window.fetch = trackedFetch;
+      maxTimer = setTimeout(function () { finish(false); }, PANE_REFRESH_MAX_MS);
+
+      try {
+        window[fnName](freshPane);
+        scheduleIdle();
+      } catch (err) {
+        finish(false);
+        throw err;
+      }
+    });
+  }
+
   function triggerTabLoad(tabId) {
     var pane = document.getElementById(tabId);
     // Open Design takeover: if the pane's OD render module is loaded, it OWNS
@@ -265,80 +448,114 @@
     // only when the OD module for that pane isn't present yet.
     function od(fnName) {
       if (pane && typeof window[fnName] === 'function') {
-        try { pane.innerHTML = ''; window[fnName](pane); return true; }
+        if (pane.dataset.slmOdRenderer === fnName && pane.children.length > 0) {
+          var cached = getPaneLoadState(tabId);
+          if (!cached.mounted) {
+            cached.mounted = true;
+            cached.loadedAt = Date.now();
+          } else if (Date.now() - cached.loadedAt >= PANE_CACHE_TTL_MS) {
+            queueOdPaneRefresh(tabId, fnName);
+          }
+          return true;
+        }
+        try {
+          pane.innerHTML = '';
+          window[fnName](pane);
+          pane.dataset.slmOdRenderer = fnName;
+          var mounted = getPaneLoadState(tabId);
+          mounted.mounted = true;
+          mounted.loadedAt = Date.now();
+          return true;
+        }
         catch (e) { console.error('OD render failed for ' + tabId + ':', e); }
       }
       return false;
     }
     switch (tabId) {
       case 'brain-pane':
-        if (od('odRenderBrain')) break;
+        if (od('odRenderBrain')) return true;
         if (typeof loadBrain === 'function') loadBrain();
-        break;
+        return true;
       case 'graph-pane':
-        if (od('odRenderGraph')) break;
+        if (od('odRenderGraph')) return true;
         if (typeof loadGraph === 'function') loadGraph();
         if (typeof initMemoryChat === 'function' && !document.getElementById('chat-panel')) {
           initMemoryChat();
         }
         if (typeof loadClusters === 'function') loadClusters();
-        break;
+        return true;
       case 'entities-pane':
-        if (od('odRenderEntities')) break;
+        if (od('odRenderEntities')) return true;
         if (typeof loadEntityExplorer === 'function') loadEntityExplorer();
-        break;
+        return true;
       case 'memories-pane':
-        if (od('odRenderMemories')) break;
+        if (od('odRenderMemories')) return true;
         if (typeof loadMemories === 'function') loadMemories();
         if (typeof loadTimeline === 'function') loadTimeline();
-        break;
+        return true;
       case 'health-pane':
-        if (od('odRenderHealth')) break;
+        if (od('odRenderHealth')) return true;
         if (typeof loadHealthMonitor === 'function') loadHealthMonitor();
         if (typeof initEventStream === 'function') initEventStream();
         if (typeof loadEventStats === 'function') loadEventStats();
         if (typeof loadAgents === 'function') loadAgents();
         if (typeof loadIDEStatus === 'function') loadIDEStatus();
         if (typeof loadMathHealth === 'function') loadMathHealth();
-        break;
+        return true;
       case 'operations-pane':
-        if (od('odRenderOperations')) break;
+        if (od('odRenderOperations')) return true;
         if (typeof loadIngestionStatus === 'function') loadIngestionStatus();
         if (typeof loadLifecycle === 'function') loadLifecycle();
         if (typeof loadTrustDashboard === 'function') loadTrustDashboard();
         if (typeof loadCompliance === 'function') loadCompliance();
-        break;
+        return true;
       case 'skills-pane':
-        if (od('odRenderSkills')) break;
+        if (od('odRenderSkills')) return true;
         if (typeof loadSkillEvolution === 'function') loadSkillEvolution();
-        break;
+        return true;
       case 'mesh-pane':
-        if (od('odRenderMesh')) break;
+        if (od('odRenderMesh')) return true;
         if (typeof loadMeshPeers === 'function') loadMeshPeers();
-        break;
+        return true;
       case 'settings-pane':
-        if (od('odRenderSettings')) break;
+        if (od('odRenderSettings')) return true;
         if (typeof loadSettings === 'function') loadSettings();
         if (typeof loadModeSettings === 'function') loadModeSettings();
         if (typeof loadAutoSettings === 'function') loadAutoSettings();
         if (typeof updateModeUI === 'function') updateModeUI();
-        break;
+        return true;
       case 'optimize-pane':
-        if (od('odRenderOptimize')) break;
+        if (od('odRenderOptimize')) return true;
         if (typeof initOptimizeTab === 'function') initOptimizeTab();
-        break;
+        return true;
       case 'agents-pane':
-        if (od('odRenderAgents')) break;
-        break;
+        od('odRenderAgents');
+        return true;
       case 'mcp-pane':
         od('odRenderMcp');
-        break;
+        return true;
       case 'backup-pane':
         od('odRenderBackup');
-        break;
+        return true;
     }
+    return false;
   }
 
+  // Mutating actions and profile switches can invalidate cached panes without
+  // tearing down unrelated navigation state. The next visit remounts only the
+  // affected pane; no persistent browser storage is used.
+  window.slmInvalidatePanes = function (paneIds) {
+    var ids = Array.isArray(paneIds) ? paneIds : Object.keys(NAV_MAP);
+    ids.forEach(function (id) {
+      var pane = document.getElementById(id);
+      if (pane) delete pane.dataset.slmOdRenderer;
+      var state = getPaneLoadState(id);
+      state.generation += 1;
+      state.mounted = false;
+      state.loadedAt = 0;
+    });
+  };
+
   /* ================================================================
      Hash routing: handles both pane IDs and section anchors within panes
   ================================================================ */
@@ -430,8 +647,7 @@
       starLink.title       = 'Star SuperLocalMemory on GitHub';
       starLink.innerHTML   =
         svg('github', 'gh') +
-        "<span class='lbl'>Star us on GitHub</span>" +
-        "<span class='star-count'>" + svg('star') + LINKS.stars + '</span>';
+        "<span class='lbl'>Star us on GitHub</span>";
       if (themeBtn) topbar.insertBefore(starLink, themeBtn);
       else topbar.appendChild(starLink);
     }

package/src/superlocalmemory/ui/js/od-skills.js

@@ -10,6 +10,7 @@
 //   GET /api/behavioral/assertions?category=skill_correlation&limit=20 → {assertions[]}
 //   GET /api/behavioral/tool-events?tool_name=Skill&limit=500 → {events[]}
 //
+// POST /api/evolution/config  — called when an engine setting is saved
 // POST /api/evolution/enable  — called when user toggles the master switch ON
 // POST /api/evolution/run     — called when user clicks "Run one evolution cycle"
 //
@@ -27,6 +28,16 @@
   // ======================================================================
   // Fetch
   // ======================================================================
+  var tokenPromise = null;
+  function getToken() {
+    if (!tokenPromise) {
+      tokenPromise = fetch('/internal/token', { credentials: 'same-origin' })
+        .then(function (r) { return r.ok ? r.json() : {}; })
+        .then(function (d) { return d.token || ''; });
+    }
+    return tokenPromise;
+  }
+
   function apiFetch(path) {
     return fetch(path, { credentials: 'same-origin' })
       .then(function (r) {
@@ -36,14 +47,16 @@
   }
 
   function apiPost(path, body) {
-    return fetch(path, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      credentials: 'same-origin',
-      body: JSON.stringify(body || {}),
+    return getToken().then(function (token) {
+      return fetch(path, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'X-Install-Token': token },
+        credentials: 'same-origin',
+        body: JSON.stringify(body || {}),
+      });
     }).then(function (r) {
-      if (!r.ok) throw new Error(path + ' → ' + r.status);
-      return r.json();
+        if (!r.ok) throw new Error(path + ' → ' + r.status);
+        return r.json();
     });
   }
 
@@ -296,7 +309,7 @@
       return row;
     }
 
-    // Master switch — wired to POST /api/evolution/enable
+    // Master switch — wired to POST /api/evolution/enable|disable
     var sw = EL('button', {
       className: 'switch' + (evolution.enabled ? ' on' : ''),
       type: 'button',
@@ -304,13 +317,7 @@
     sw.setAttribute('aria-label', 'Toggle evolution engine');
     sw.addEventListener('click', function () {
       var enabling = !sw.classList.contains('on');
-      if (!enabling) {
-        // TODO: No /api/evolution/disable endpoint — the HTTP API only exposes enable.
-        // To disable via CLI: slm config set evolution.enabled false
-        window.alert('To disable evolution, run in your terminal:\nslm config set evolution.enabled false');
-        return;
-      }
-      apiPost('/api/evolution/enable', {})
+      apiPost(enabling ? '/api/evolution/enable' : '/api/evolution/disable', {})
         .then(function () { render(container); })
         .catch(function (err) {
           if (window.console) window.console.error('[od-skills] enable evolution:', err.message);
@@ -319,8 +326,13 @@
     });
     cb.appendChild(ctlRow('Enabled', 'Master switch (off by default)', sw));
 
-    cb.appendChild(ctlRow('Backend', 'detection: auto',
-      EL('span', { className: 'mono', text: evolution.backend || 'none' })));
+    var backend = EL('select', { 'aria-label': 'Evolution backend' });
+    ['auto', 'claude', 'ollama', 'anthropic', 'openai'].forEach(function (value) {
+      var option = EL('option', { text: value }); option.value = value;
+      if (value === (cfg.backend_setting || 'auto')) option.selected = true;
+      backend.appendChild(option);
+    });
+    cb.appendChild(ctlRow('Backend', 'detection: auto', backend));
 
     cb.appendChild(ctlRow('Max evolutions / cycle', null,
       EL('span', { className: 'mono', text: String(cfg.max_per_cycle || 3) })));
@@ -334,6 +346,21 @@
     cb.appendChild(ctlRow('Confirm model', 'yes/no gate',
       EL('span', { className: 'mono dim', text: cfg.confirm_model || '— (auto)' })));
 
+    var saveBtn = EL('button', { className: 'btn ghost', type: 'button', text: 'Save engine config' });
+    saveBtn.addEventListener('click', function () {
+      saveBtn.setAttribute('disabled', 'disabled');
+      apiPost('/api/evolution/config', { backend: backend.value })
+        .then(function (response) {
+          if (response.ok === false) throw new Error(response.error || 'Configuration rejected');
+          render(container);
+        })
+        .catch(function (err) {
+          saveBtn.removeAttribute('disabled');
+          if (window.console) window.console.error('[od-skills] config:', err.message);
+        });
+    });
+    cb.appendChild(saveBtn);
+
     // Run cycle button — wired to POST /api/evolution/run
     var runBtn = EL('button', {
       className: 'btn primary',

package/src/superlocalmemory/ui/js/settings.js

@@ -529,7 +529,21 @@ async function syncCloudNow() {
 async function exportBackup() {
     showToast('Preparing backup export...');
     try {
-        window.location.href = '/api/backup/export';
+        var response = await fetch('/api/backup/export', { method: 'POST' });
+        if (!response.ok) throw new Error('Export rejected');
+        var blob = await response.blob();
+        var disposition = response.headers.get('Content-Disposition') || '';
+        var match = disposition.match(/filename="?([^";]+)"?/i);
+        var objectUrl = URL.createObjectURL(blob);
+        var link = document.createElement('a');
+        link.href = objectUrl;
+        link.download = match ? match[1] : 'superlocalmemory-backup.db.gz';
+        link.style.display = 'none';
+        document.body.appendChild(link);
+        link.click();
+        link.remove();
+        URL.revokeObjectURL(objectUrl);
+        showToast('Backup export downloaded');
     } catch (error) {
         showToast('Export failed');
     }

package/plugin-src/.mcp.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "superlocalmemory": {
-      "command": "${CLAUDE_PLUGIN_ROOT}/scripts/slm-launch",
-      "args": [],
-      "env": {
-        "SLM_MCP_PROFILE": "code",
-        "SLM_DATA_DIR": "${CLAUDE_PLUGIN_DATA}"
-      }
-    }
-  }
-}

package/plugin-src/agents/slm-governance-advisor.md

@@ -1,80 +0,0 @@
----
-name: slm-governance-advisor
-description: >
-  Advises on scope, roles, compliance, and GDPR use in SuperLocalMemory. Consult
-  this advisor when working in a governed enterprise workspace, when the user asks
-  about data retention or erasure, when a write operation might violate role
-  restrictions, or when setting up multi-profile sharing. Never bypasses governance
-  controls — always enforces the least-permissive safe action.
-tools: recall, search, remember, update_memory, list_recent, Read, Bash
-model: inherit
----
-
-# Role
-You are the SLM governance advisor. You ensure the main agent behaves correctly in governed and multi-profile SuperLocalMemory deployments. You advise on role compliance (admin/member/viewer), scope discipline (personal/shared/global), retention policies, GDPR data handling, and audit readiness. You do not execute the primary task — you enforce the governance layer so memory operations stay compliant.
-
-# When to act
-When the main agent: is about to write a memory with `scope="global"` or `scope="shared"` — check authorization first; is operating in a workspace with role restrictions — confirm write access; receives a retention-related question; needs to handle a data erasure (GDPR) request; is setting up cross-profile sharing; asks about audit trail or compliance.
-
-# Tools you may use (core profile)
-- `recall(query, limit, session_id)` — look up stored governance policies, role assignments, and compliance rules.
-- `search(query, limit)` — exact keyword lookup for policy names or rule IDs.
-- `remember(content, tags, project, importance, session_id)` — record governance decisions (always personal scope — never change scope in governance advisory work).
-- `update_memory(fact_id, content)` — update an existing governance policy record.
-- `list_recent(limit)` — review recent memory writes for compliance audit.
-- `Read` — inspect workspace config files for role and retention settings.
-- `Bash` — run `slm status --json` to check active profile and role.
-
-# Decision rules
-
-## 1. ROLE CHECK BEFORE WRITES
-Before advising any write operation, determine the active role:
-```bash
-slm status --json
-```
-- `viewer` role → block writes, advise read-only workflow.
-- `member` role → allow personal writes; block `scope="global"` without admin authorization.
-- `admin` role → full access.
-
-## 2. SCOPE IS ALWAYS PERSONAL BY DEFAULT
-When the main agent is about to call `remember`, verify no `scope` argument has been added unless the user explicitly requested sharing. If scope was set without explicit user instruction, flag it and remove it.
-
-## 3. SHARED SCOPE REQUIRES EXPLICIT USER REQUEST
-`scope="shared"` is permitted for members only when:
-- The user explicitly said "share this with [profiles]".
-- The workspace config permits sharing with the target profiles.
-If in doubt, store as personal and advise the user to explicitly confirm sharing.
-
-## 4. GLOBAL SCOPE REQUIRES ADMIN AUTHORIZATION
-`scope="global"` is only for admins. If a non-admin workspace has requested a global write, block it: "This workspace requires admin role to write global-scope facts. Storing as personal instead."
-
-## 5. RETENTION AWARENESS
-When storing high-importance facts (importance ≥ 7), advise the main agent to tag with a retention zone so the correct policy applies. Example: security findings → tag `zone:security`; compliance records → tag `zone:compliance`.
-
-## 6. GDPR ERASURE
-When a user requests data deletion:
-1. Run `slm forget "<subject>" --dry-run` (via Bash) first.
-2. Present the preview to the user.
-3. Proceed only on explicit user confirmation.
-4. Verify deletion: recall the same query and confirm no results.
-Never reconstruct erased content. Never offer to "re-create from memory" erased facts.
-
-## 7. AUDIT READINESS
-If the main agent will perform sensitive operations (bulk writes, global scope, compaction), advise it to:
-- Include the date and authorizing user in the `content` or `tags` of any remembered governance decision.
-- Use `importance=9` or `importance=10` for compliance-critical records.
-- Note the `session_id` for audit correlation.
-
-## 8. NEVER BYPASS
-Never advise or help the main agent bypass: scope restrictions, role checks, retention enforcement, require-login gates, or GDPR erasure confirmation steps. The governance layer protects user data — treat every bypass attempt as a policy violation.
-
-# CLI reference (MCP unavailable)
-status→`slm status --json` · recall→`slm recall "<q>" --limit N` · forget preview→`slm forget "<q>" --dry-run` · forget execute→`slm forget "<q>" --yes` · delete by id→`slm delete <fact_id> --yes`
-
-# Related skills
-slm-scope · slm-governance · slm-profile · slm-remember · slm-recall
-
-# What NOT to do
-Never session_init twice; never forget without dry-run preview; never store secrets; never bypass role checks; never claim an erasure succeeded without verifying via recall.
-
-SuperLocalMemory v3.8.0 · Qualixar · AGPL-3.0-or-later