superlocalmemory 4.0.9 → 4.1.0

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

@@ -189,6 +189,18 @@
             '</select>' +
           '</div>' +
           '<div id="' + id + '-sum-out" style="font-size:13px;color:var(--fg-2)">Pick a summary above.</div>' +
+          // Knowledge Overview.
+          //
+          // The Today/Yesterday buttons above are a date filter over
+          // atomic_facts and have never had any link to a cluster, so the
+          // Summaries tab could not show what the store actually knows ABOUT
+          // anything. This card fills that: cluster summaries, read from the
+          // display-only table, which is where they belong now that they are
+          // out of the retrieval corpus.
+          '<div id="' + id + '-kover" style="margin-top:26px;' +
+            'border-top:1px solid var(--border);padding-top:20px">' +
+            _loading('Loading what your memory knows…') +
+          '</div>' +
         '</div>' +
         // Recall Lab pane — exact IDs required by recall-lab.js:
         //   #recall-lab-query (input), #recall-lab-search (button — click check),
@@ -363,7 +375,7 @@
     if (pane) pane.classList.add('active');
     if (tab === 'timeline') _loadTimeline(id);
     if (tab === 'clusters')  _loadClusters(id);
-    if (tab === 'summary')   _loadProjectOptions(id);
+    if (tab === 'summary') { _loadProjectOptions(id); _loadKnowledgeOverview(id); }
   }
 
   /* Populate the project picker from projects SLM has actually recorded.
@@ -446,6 +458,25 @@
         meta.style.cssText = 'margin-top:10px;font-size:12px;color:var(--fg-3);line-height:1.6';
         meta.textContent = _summaryProvenance(d);
         out.appendChild(meta);
+
+        /* Why it came out this way, and what to do about it.
+         *
+         * The provenance line above says a summary was assembled from the
+         * user's own notes rather than written. It never said why. Someone in
+         * Mode A — which has no language model by design — saw a plainer
+         * result than they expected with no way to learn that a written one
+         * needs a model, and would reasonably read the feature as broken.
+         */
+        var cap = d.capability;
+        if (cap && cap.message) {
+          var hint = document.createElement('div');
+          hint.style.cssText = 'margin-top:10px;font-size:12px;line-height:1.6;' +
+            'color:var(--fg-2);background:var(--card-2);border:1px solid var(--border);' +
+            'border-left:3px solid var(--accent, var(--border));' +
+            'border-radius:var(--r-md);padding:10px 12px';
+          hint.textContent = cap.message;
+          out.appendChild(hint);
+        }
       })
       .catch(function (e) {
         out.textContent = 'Could not build summary: ' + (e && e.message ? e.message : 'error');
@@ -815,6 +846,183 @@
 
   // ── Clusters fetch & render ──────────────────────────────────────────────────
 
+  /* Knowledge Overview — cluster summaries, plus an honest health line.
+   *
+   * Two rules this card exists to obey.
+   *
+   * IT READS ONLY THE DISPLAY TABLE. These summaries were in the retrieval
+   * corpus until 4.0.10, where they out-ranked the user's own words. Moving
+   * them out is only worth anything if exactly one surface shows them, and
+   * this is that surface.
+   *
+   * IT DOES NOT DRESS UP JUNK AS INSIGHT. Some stored summaries are a model's
+   * non-answer -- "Unfortunately, there is no information available about
+   * 'State'..." -- and rendering those as a heading called Knowledge Overview
+   * makes the product look broken. The endpoint labels each row's quality; the
+   * usable ones are shown and the rest are counted in one plain sentence. Not
+   * hidden: hiding them would hide the very problem the release fixes, and a
+   * reader who is told "3 could not be generated" trusts the other 47 more.
+   */
+  function _loadKnowledgeOverview(id) {
+    var box = document.getElementById(id + '-kover');
+    if (!box) return;
+    // Guarded on the element, not a module flag — same reason as
+    // _loadProjectOptions: a stale "already loaded" boolean outlives the DOM
+    // it described and leaves a permanent spinner after a re-render.
+    if (box.dataset.loaded === '1') return;
+
+    Promise.all([
+      fetch('/api/v3/abstraction/consolidated?limit=24')
+        .then(function (r) { return r.ok ? r.json() : { summaries: [], unusable: 0 }; })
+        .catch(function () { return { summaries: [], unusable: 0 }; }),
+      fetch('/api/v3/abstraction/health')
+        .then(function (r) { return r.ok ? r.json() : null; })
+        .catch(function () { return null; })
+    ]).then(function (res) {
+      box.dataset.loaded = '1';
+      box.innerHTML = _koverHtml(res[0] || {}, res[1]);
+    });
+  }
+
+  function _koverHtml(data, health) {
+    var all = data.summaries || [];
+    var usable = all.filter(function (s) { return s.quality === 'ok'; });
+    var unusable = typeof data.unusable === 'number' ? data.unusable
+                 : (all.length - usable.length);
+
+    var html = '<h3 style="font-size:15px;margin:0 0 4px">What your memory knows</h3>' +
+      '<p style="font-size:12px;color:var(--fg-2);margin:0 0 14px">' +
+        'Written by the summarizer from groups of your memories. These are a ' +
+        'view of your memory, not memories themselves — they are never returned ' +
+        'as answers.' +
+      '</p>';
+
+    if (health) html += _koverHealth(health);
+
+    if (usable.length === 0) {
+      html += '<div style="padding:20px;color:var(--fg-2);font-size:13px">' +
+        (all.length === 0
+          ? 'No summaries yet. They are written in the background as related ' +
+            'memories accumulate.'
+          : 'None of the ' + all.length + ' stored summaries came back usable. ' +
+            'That usually means the summarizer had nothing in common to merge.') +
+        '</div>';
+      return html;
+    }
+
+    html += '<div style="display:grid;gap:12px;' +
+      'grid-template-columns:repeat(auto-fill,minmax(280px,1fr))">';
+    usable.forEach(function (s) { html += _koverCard(s); });
+    html += '</div>';
+
+    var notes = [];
+    if (unusable > 0) {
+      notes.push(unusable + (unusable === 1 ? ' summary' : ' summaries') +
+        ' could not be generated and are not shown. The memories they were ' +
+        'built from are unaffected.');
+    }
+    if (data.near_duplicates > 0) {
+      notes.push(data.near_duplicates + ' near-identical ' +
+        (data.near_duplicates === 1 ? 'summary was' : 'summaries were') +
+        ' collapsed into the ones above.');
+    }
+    if (notes.length) {
+      html += '<p style="font-size:12px;color:var(--fg-2);margin-top:12px">' +
+        notes.map(_esc).join(' ') + '</p>';
+    }
+    return html;
+  }
+
+  function _koverCard(s) {
+    // Every field is escaped. Anything in a memory can reach this screen: the
+    // summarizer merges fact content verbatim, so a memory containing markup
+    // would otherwise render as markup.
+    var body = _koverPlain(s.content);
+    var clipped = body.length > 320;
+    var shown = clipped ? body.slice(0, 320).replace(/\s+\S*$/, '') + '…' : body;
+
+    var meta = [];
+    if (s.source_count) {
+      meta.push(s.source_count + (s.source_count === 1 ? ' memory' : ' memories'));
+    }
+    var span = _koverSpan(s.source_earliest, s.source_latest);
+    if (span) meta.push(span);
+
+    return '<div style="background:var(--card-2);border:1px solid var(--border);' +
+        'border-radius:var(--r-md);padding:14px">' +
+      (s.entity_name
+        ? '<div style="font-size:13px;font-weight:600;margin-bottom:6px">' +
+            _esc(s.entity_name) + '</div>'
+        : '') +
+      '<div style="font-size:13px;line-height:1.5">' + _esc(shown) + '</div>' +
+      (meta.length
+        ? '<div style="margin-top:10px;display:flex;gap:6px;flex-wrap:wrap">' +
+            meta.map(_koverChip).join('') +
+          '</div>'
+        : '') +
+    '</div>';
+  }
+
+  /* Flatten a summary to plain prose for display.
+   *
+   * Mode B/C summaries come back with markdown in them — "**Audit Round**",
+   * "**Findings**:" — because a chat-tuned model formats for a chat window.
+   * Rendered as text those asterisks read as broken output to exactly the
+   * reader this card is for. Escaping is still what protects the page; this
+   * only removes the emphasis marks that carry no meaning here.
+   */
+  function _koverPlain(text) {
+    return String(text || '')
+      .replace(/```[\s\S]*?```/g, ' ')     // fenced blocks: no room for them
+      .replace(/`([^`]*)`/g, '$1')          // inline code marks
+      .replace(/\*\*([^*]+)\*\*/g, '$1')   // bold
+      .replace(/(^|\s)\*([^*\s][^*]*)\*/g, '$1$2')  // italic, not bullets
+      .replace(/^#{1,6}\s+/gm, '')          // headings
+      .replace(/^\s*[-*+]\s+/gm, '')        // list bullets
+      .replace(/\s+/g, ' ')                 // collapse whitespace + newlines
+      .trim();
+  }
+
+  /* A chip, not a keyword dump.
+   *
+   * The neighbouring community-summary API returns its `summary` field as
+   * "Topics: CCQ, Resume, P07…", which printed verbatim reads as a broken
+   * page. Counts and date spans are rendered as discrete labels instead.
+   */
+  function _koverChip(text) {
+    return '<span style="font-size:11px;padding:2px 8px;border-radius:999px;' +
+      'background:var(--card);border:1px solid var(--border);color:var(--fg-2)">' +
+      _esc(text) + '</span>';
+  }
+
+  function _koverSpan(earliest, latest) {
+    var a = String(earliest || '').slice(0, 10);
+    var b = String(latest || '').slice(0, 10);
+    if (!a && !b) return '';
+    if (!a || !b || a === b) return a || b;
+    return a + ' to ' + b;
+  }
+
+  /* Whether the memories behind all this can actually be found.
+   *
+   * The one question no screen answered before. A machine ran for months with
+   * 43.7% of its store unreachable by meaning while every status line it showed
+   * said healthy, because nothing counted the reachable share.
+   */
+  function _koverHealth(h) {
+    var lines = h.summary || [];
+    if (!lines.length) return '';
+    var bad = h.healthy === false;
+    return '<div style="margin:0 0 16px;padding:12px 14px;border-radius:var(--r-md);' +
+        'background:var(--card-2);border-left:3px solid ' +
+        (bad ? 'var(--warn)' : 'var(--ok)') + '">' +
+      lines.map(function (l) {
+        return '<div style="font-size:12px;color:var(--fg-2);line-height:1.5">' +
+          _esc(l) + '</div>';
+      }).join('') +
+    '</div>';
+  }
+
   function _loadClusters(id) {
     if (_st.cluLoaded) return;
     var grid = document.getElementById(id + '-clu-grid');

package/src/superlocalmemory/ui/js/od-ops-health.js

@@ -1,4 +1,4 @@
-/* od-ops-health.js — Wave-3 Admin Operations & Health panel
+/* od-ops-health.js — Admin Operations & Health panel
  * Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar — AGPL-3.0-or-later
  *
  * Injects an "Admin: Ops Health" tab into the Governance pane tab bar

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

@@ -222,6 +222,71 @@
   }
 
   /* ── Layout ───────────────────────────────────────────────── */
+  /* Decay preview — three curves, one per source-trust level.
+     Shows what the kappa setting actually does before it is saved: the same
+     memory strength fading at three different rates depending on where the
+     memory came from. At kappa 0 the three curves coincide, which is the
+     honest picture of trust-modulation being off. */
+  var DECAY_TRUSTS = [
+    { trust: 0.0, color: '#e0245e', label: 'low trust' },
+    { trust: 0.5, color: '#f59e0b', label: 'medium' },
+    { trust: 1.0, color: '#10b981', label: 'trusted' }
+  ];
+
+  function buildDecayPreview() {
+    var wrap = el('div', null, { display:'flex', flexDirection:'column', gap:'6px' });
+    var cvs = el('canvas', { id: P + '-forg-decay' });
+    cvs.width = 300; cvs.height = 96;
+    Object.assign(cvs.style, {
+      border:'1px solid var(--border)', borderRadius:'4px', display:'block'
+    });
+    wrap.appendChild(cvs);
+    var key = el('div', null, { display:'flex', gap:'10px' });
+    DECAY_TRUSTS.forEach(function (t) {
+      key.appendChild(el('span', { text: t.label },
+        { fontSize:'10.5px', color: t.color, fontFamily:'var(--font-mono)' }));
+    });
+    wrap.appendChild(key);
+    return wrap;
+  }
+
+  /* The decay rate is per HOUR, and the window is chosen so the three curves
+     are actually distinguishable. At a strong memory's strength (100, the
+     configured maximum) retention over sixty days is indistinguishable from
+     zero for every trust level, so a two-month preview would draw three flat
+     lines along the bottom and say nothing. Three days separates them. */
+  var DECAY_HOURS = 72;
+  var DECAY_STRENGTH = 100.0;
+
+  function retentionAt(hours, kappa, trust) {
+    // Mirrors math/ebbinghaus.trust_modulated_retention exactly:
+    //   lambda_eff = (1 / S) * (1 + kappa * (1 - trust))
+    //   retention  = exp(-lambda_eff * hours)
+    var lambdaEff = (1.0 / DECAY_STRENGTH) * (1.0 + kappa * (1.0 - trust));
+    return Math.exp(-lambdaEff * hours);
+  }
+
+  function drawDecayCurve(kappa) {
+    var cvs = q('forg-decay');
+    if (!cvs || !cvs.getContext) return;
+    var ctx = cvs.getContext('2d');
+    var W = cvs.width, H = cvs.height, STEPS = 72;
+    ctx.clearRect(0, 0, W, H);
+    DECAY_TRUSTS.forEach(function (t) {
+      ctx.beginPath();
+      for (var i = 0; i <= STEPS; i++) {
+        var hours = (i / STEPS) * DECAY_HOURS;
+        var retention = retentionAt(hours, kappa, t.trust);
+        var x = (i / STEPS) * (W - 2) + 1;
+        var y = H - 2 - retention * (H - 4);
+        if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
+      }
+      ctx.strokeStyle = t.color;
+      ctx.lineWidth = 1.6;
+      ctx.stroke();
+    });
+  }
+
   function makeRow(lbl, desc, key, ctrl) {
     var d = el('div', { 'data-set':'', 'data-txt':(lbl + ' ' + key).toLowerCase() });
     Object.assign(d.style, { display:'flex', alignItems:'center',
@@ -719,10 +784,16 @@
     intInp.style.minWidth = '80px'; intInp.style.maxWidth = '100px';
     var statsEl = el('span', { id: P + '-forg-stats', text:'Loading…' },
       { fontSize:'12px', color:'var(--fg-2)', fontFamily:'var(--font-mono)' });
+    var kapR = makeRange('forg-kap', '0', '5', '0.1', '2.0');
+    var decayEl = buildDecayPreview();
     var saveBtn = makeBtn('forg-save', 'Save Forgetting', true);
     var st = makeSt('forg');
     var restNote = makeRestartNote('forg');
     saveBtn.addEventListener('click', saveForgetting);
+    kapR.querySelector('input').addEventListener('input', function () {
+      drawDecayCurve(parseFloat(this.value));
+    });
+    kapR.querySelector('input').addEventListener('change', saveForgetting);
     onSw.addEventListener('od-toggle',  saveForgetting);
     immSw.addEventListener('od-toggle', saveForgetting);
     arcR.querySelector('input').addEventListener('change', saveForgetting);
@@ -734,6 +805,11 @@
       makeRow('Archive threshold', 'Memories below this strength move to cold archive', 'forgetting.archive_threshold', arcR),
       makeRow('Forget threshold', 'Memories below this strength are permanently deleted', 'forgetting.forget_threshold', fgtR),
       makeRow('Run every (minutes)', 'How often the forgetting engine runs in the background', 'forgetting.scheduler_interval_minutes', intInp),
+      makeRow('Fade untrusted sources faster (\u03ba)',
+              'Memories from sources you trust less decay quicker. 0 = every memory fades at the same rate.',
+              'forgetting.trust_kappa', kapR),
+      makeRow('Decay preview', 'Retention over 3 days at three source-trust levels',
+              '', decayEl),
       makeRow('Memory zone stats', '', 'forgetting.stats', statsEl),
       makeRow('Actions', '', '', bRow(saveBtn, st, restNote))
     ]);
@@ -751,6 +827,15 @@
         var fgt = q('forg-fgt');
         if (fgt) { fgt.value = d.forget_threshold || 0.05; var dF = q('forg-fgt-disp'); if (dF) dF.textContent = Number(d.forget_threshold || 0.05).toFixed(2); }
         var it = q('forg-int'); if (it) it.value = d.scheduler_interval_minutes || 30;
+        // == null, not ||: kappa 0 is a real setting (trust-modulation off) and
+        // a falsy check would silently redraw it as the 2.0 default.
+        var kap = q('forg-kap');
+        var kv = (d.trust_kappa == null) ? 2.0 : Number(d.trust_kappa);
+        if (kap) {
+          kap.value = kv;
+          var dK = q('forg-kap-disp'); if (dK) dK.textContent = kv.toFixed(2);
+        }
+        drawDecayCurve(kv);
       }).catch(function () {});
     fetch('/api/v3/forgetting/stats').then(function (r) { return r.ok ? r.json() : null; })
       .then(function (d) {
@@ -773,7 +858,8 @@
       core_memory_immune:         q('forg-imm') ? q('forg-imm').classList.contains('on') : true,
       archive_threshold:  parseFloat(q('forg-arc') ? q('forg-arc').value : '0.20'),
       forget_threshold:   parseFloat(q('forg-fgt') ? q('forg-fgt').value : '0.05'),
-      scheduler_interval_minutes: parseInt(q('forg-int') ? q('forg-int').value : '30') || 30
+      scheduler_interval_minutes: parseInt(q('forg-int') ? q('forg-int').value : '30') || 30,
+      trust_kappa: q('forg-kap') ? parseFloat(q('forg-kap').value) : 2.0
     }).then(function (r) { return r.json(); })
       .then(function (d) {
         setSt('forg', 'Saved', true);

package/src/superlocalmemory/ui/js/recall-lab.js

@@ -7,8 +7,63 @@ var recallLabState = {
     perPage: 10,
     query: '',
     synthesis: '',
+    channelStatus: {},
 };
 
+// How each channel status reads to someone looking at a thin result set.
+// 'empty', 'disabled' and 'not_configured' are muted on purpose: the first is a
+// valid finding and the other two are the operator's own configuration. Only a
+// genuine degradation is coloured as a problem.
+var CHANNEL_STATUS_STYLE = {
+    ok:             {cls: 'bg-success',   label: 'ok'},
+    empty:          {cls: 'bg-secondary', label: 'no hits'},
+    disabled:       {cls: 'bg-secondary', label: 'off'},
+    not_configured: {cls: 'bg-secondary', label: 'n/a'},
+    error:          {cls: 'bg-danger',    label: 'failed'},
+    timeout:        {cls: 'bg-warning',   label: 'timed out'},
+    no_embedding:   {cls: 'bg-danger',    label: 'no embedding'},
+};
+
+var CHANNEL_FAULTS = ['error', 'timeout', 'no_embedding'];
+
+// Built with createElement and textContent throughout — the status strings come
+// from the server, and this pane has no reason to be an injection sink.
+function buildChannelHealth(statuses) {
+    var names = Object.keys(statuses || {});
+    if (names.length === 0) return null;
+    names.sort();
+
+    var wrap = document.createElement('div');
+    wrap.className = 'mt-2 d-flex flex-wrap align-items-center gap-1';
+
+    var degraded = names.filter(function(n) {
+        return CHANNEL_FAULTS.indexOf(statuses[n]) !== -1;
+    });
+
+    var lead = document.createElement('span');
+    lead.className = degraded.length ? 'me-1 text-danger fw-semibold' : 'me-1 text-muted';
+    lead.style.fontSize = '0.75rem';
+    // Said plainly, because the reason this strip exists is that a partly-broken
+    // retrieval path and a store with nothing to say produced the same answer.
+    lead.textContent = degraded.length
+        ? 'Retrieval degraded — this answer is missing what ' +
+          degraded.length + ' channel' + (degraded.length === 1 ? '' : 's') + ' would have found:'
+        : 'Channels:';
+    wrap.appendChild(lead);
+
+    names.forEach(function(name) {
+        var status = statuses[name];
+        var style = CHANNEL_STATUS_STYLE[status] || {cls: 'bg-dark', label: String(status)};
+        var badge = document.createElement('span');
+        badge.className = 'badge ' + style.cls;
+        badge.style.fontSize = '0.68rem';
+        badge.textContent = name + ' \u00b7 ' + style.label;
+        wrap.appendChild(badge);
+    });
+
+    return wrap;
+}
+
 // Delegation handles the case where the recall-lab tab pane is injected after parse time.
 document.addEventListener('click', function(e) {
     if (!e.target || e.target.id !== 'recall-lab-search') return;
@@ -54,6 +109,14 @@ document.addEventListener('click', function(e) {
 
         recallLabState.allResults = data.results || [];
         recallLabState.synthesis = data.synthesis || '';
+        recallLabState.channelStatus = data.channel_status || {};
+
+        // Rendered BEFORE the no-results branch below, and that ordering is the
+        // whole point: every channel failing produces exactly zero results, so
+        // the case most in need of an explanation is the one that would
+        // otherwise show a bare 'No results found'.
+        var health = buildChannelHealth(recallLabState.channelStatus);
+        if (health) metaDiv.appendChild(health);
 
         if (recallLabState.allResults.length === 0) {
             resultsDiv.textContent = '';
@@ -118,9 +181,21 @@ function renderRecallPage() {
         numLabel.textContent = '#' + (globalIndex + 1);
         scoreRow.appendChild(numLabel);
         var scoreBadges = document.createElement('div');
-        scoreBadges.innerHTML = '<span class="badge bg-primary me-1">Score: ' + r.score + '</span>' +
-            '<span class="badge bg-secondary me-1">Trust: ' + r.trust_score + '</span>' +
-            '<span class="badge bg-outline-info" style="border:1px solid #0dcaf0;color:#0dcaf0;">Conf: ' + r.confidence + '</span>';
+        // Built element by element rather than as an HTML string. The values are
+        // server-supplied, and this file's sibling panes are held to the same
+        // rule: this pane renders DOM, it does not parse markup.
+        [
+            ['badge bg-primary me-1', 'Score: ' + r.score, ''],
+            ['badge bg-secondary me-1', 'Trust: ' + r.trust_score, ''],
+            ['badge bg-outline-info', 'Conf: ' + r.confidence,
+             'border:1px solid #0dcaf0;color:#0dcaf0;'],
+        ].forEach(function(spec) {
+            var badge = document.createElement('span');
+            badge.className = spec[0];
+            badge.textContent = spec[1];
+            if (spec[2]) badge.style.cssText = spec[2];
+            scoreBadges.appendChild(badge);
+        });
         scoreRow.appendChild(scoreBadges);
         item.appendChild(scoreRow);