superlocalmemory 2.7.2 → 2.7.4

package/src/trust_scorer.py

@@ -12,10 +12,23 @@ Attribution must be preserved in all copies or derivatives.
 """
 
 """
-TrustScorer — Silent trust signal collection for AI agents.
+TrustScorer — Bayesian Beta-Binomial trust scoring for AI agents.
+
+Scoring Model:
+    Each agent's trust is modeled as a Beta(alpha, beta) distribution.
+    - alpha accumulates evidence of trustworthy behavior
+    - beta accumulates evidence of untrustworthy behavior
+    - Trust score = alpha / (alpha + beta)  (posterior mean)
+
+    Prior: Beta(2.0, 1.0) → initial trust = 0.667
+    This gives new agents a positive-but-not-maximal starting trust,
+    well above the 0.3 enforcement threshold but with room to grow.
+
+    This follows the MACLA Beta-Binomial approach (arXiv:2512.18950)
+    already used in pattern_learner.py for confidence scoring.
 
 v2.5 BEHAVIOR (this version):
-    - All agents start at trust 1.0
+    - All agents start at Beta(2.0, 1.0) → trust 0.667
     - Signals are collected silently (no enforcement, no ranking, no blocking)
     - Trust scores are updated in agent_registry.trust_score
     - Dashboard shows scores but they don't affect recall ordering yet
@@ -30,31 +43,26 @@ v3.0 BEHAVIOR (future):
     - Admin approval workflow for untrusted agents
 
 Trust Signals (all silently collected):
-    POSITIVE (increase trust):
+    POSITIVE (increase alpha — build trust):
         - Memory recalled by other agents (cross-agent validation)
         - Memory updated (shows ongoing relevance)
         - High importance memories (agent writes valuable content)
         - Consistent write patterns (not spam-like)
 
-    NEGATIVE (decrease trust):
+    NEGATIVE (increase beta — erode trust):
         - Memory deleted shortly after creation (low quality)
         - Very high write volume in short time (potential spam/poisoning)
         - Content flagged or overwritten by user
 
     NEUTRAL:
-        - Normal read/write patterns
+        - Normal read/write patterns (tiny alpha nudge to reward activity)
         - Agent disconnects/reconnects
 
-Scoring Algorithm:
-    Bayesian-inspired moving average. Each signal adjusts the score
-    by a small delta. Score is clamped to [0.0, 1.0].
-
-    new_score = old_score + (delta * decay_factor)
-    decay_factor = 1 / (1 + signal_count * 0.01)  # Stabilizes over time
-
-    This means early signals have more impact, and the score converges
-    as more data is collected. Similar to MACLA Beta-Binomial approach
-    (arXiv:2512.18950) but simplified for local computation.
+Decay:
+    Every DECAY_INTERVAL signals per agent, both alpha and beta are
+    multiplied by DECAY_FACTOR (0.995). This slowly forgets very old
+    signals so recent behavior matters more. Floors prevent total
+    information loss: alpha >= 1.0, beta >= 0.5.
 
 Security (OWASP for Agentic AI):
     - Memory poisoning (#1 threat): Trust scoring is the first defense layer
@@ -64,7 +72,6 @@ Security (OWASP for Agentic AI):
 
 import json
 import logging
-import math
 import threading
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -72,24 +79,59 @@ from typing import Optional, Dict, List
 
 logger = logging.getLogger("superlocalmemory.trust")
 
-# Signal deltas (how much each signal moves the trust score)
-SIGNAL_DELTAS = {
-    # Positive signals
-    "memory_recalled_by_others": +0.02,
-    "memory_updated": +0.01,
-    "high_importance_write": +0.015,   # importance >= 7
-    "consistent_pattern": +0.01,
-
-    # Negative signals
-    "quick_delete": -0.03,             # deleted within 1 hour of creation
-    "high_volume_burst": -0.02,        # >20 writes in 5 minutes
-    "content_overwritten_by_user": -0.01,
-
-    # Neutral (logged but no score change)
-    "normal_write": 0.0,
-    "normal_recall": 0.0,
+# ---------------------------------------------------------------------------
+# Beta-Binomial signal weights
+# ---------------------------------------------------------------------------
+# Positive signals increment alpha (building trust).
+# Negative signals increment beta (eroding trust).
+# Neutral signals give a tiny alpha nudge to reward normal activity.
+#
+# Asymmetry: negative weights are larger than positive weights.
+# This means it's harder to build trust than to lose it — the system
+# is intentionally skeptical. One poisoning event takes many good
+# actions to recover from.
+# ---------------------------------------------------------------------------
+
+SIGNAL_WEIGHTS = {
+    # Positive signals → alpha += weight
+    "memory_recalled_by_others": ("positive", 0.30),   # cross-agent validation
+    "memory_updated":            ("positive", 0.15),   # ongoing relevance
+    "high_importance_write":     ("positive", 0.20),   # valuable content (importance >= 7)
+    "consistent_pattern":        ("positive", 0.15),   # stable write behavior
+
+    # Negative signals → beta += weight
+    "quick_delete":              ("negative", 0.50),   # deleted within 1 hour
+    "high_volume_burst":         ("negative", 0.40),   # >20 writes in 5 minutes
+    "content_overwritten_by_user": ("negative", 0.25), # user had to fix output
+
+    # Neutral signals → tiny alpha nudge
+    "normal_write":              ("neutral", 0.01),
+    "normal_recall":             ("neutral", 0.01),
 }
 
+# Backward-compatible: expose SIGNAL_DELTAS as a derived dict so that
+# bm6_trust.py (which imports SIGNAL_DELTAS) and any other consumer
+# continues to work. The values represent the *direction* and *magnitude*
+# of each signal: positive for alpha, negative for beta, zero for neutral.
+SIGNAL_DELTAS = {}
+for _sig, (_direction, _weight) in SIGNAL_WEIGHTS.items():
+    if _direction == "positive":
+        SIGNAL_DELTAS[_sig] = +_weight
+    elif _direction == "negative":
+        SIGNAL_DELTAS[_sig] = -_weight
+    else:
+        SIGNAL_DELTAS[_sig] = 0.0
+
+# ---------------------------------------------------------------------------
+# Beta prior and decay parameters
+# ---------------------------------------------------------------------------
+INITIAL_ALPHA = 2.0        # Slight positive prior
+INITIAL_BETA = 1.0         # → initial trust = 2/(2+1) = 0.667
+DECAY_FACTOR = 0.995       # Multiply alpha & beta every DECAY_INTERVAL signals
+DECAY_INTERVAL = 50        # Apply decay every N signals per agent
+ALPHA_FLOOR = 1.0          # Never decay alpha below this
+BETA_FLOOR = 0.5           # Never decay beta below this
+
 # Thresholds
 QUICK_DELETE_HOURS = 1       # Delete within 1 hour = negative signal
 BURST_THRESHOLD = 20         # >20 writes in burst window = negative
@@ -98,9 +140,12 @@ BURST_WINDOW_MINUTES = 5     # Burst detection window
 
 class TrustScorer:
     """
-    Silent trust signal collector for AI agents.
+    Bayesian Beta-Binomial trust scorer for AI agents.
+
+    Each agent is modeled as Beta(alpha, beta). Positive signals
+    increment alpha, negative signals increment beta. The trust
+    score is the posterior mean: alpha / (alpha + beta).
 
-    v2.5: Collection only, no enforcement. All agents start at 1.0.
     Thread-safe singleton per database path.
     """
 
@@ -136,19 +181,26 @@ class TrustScorer:
         self._write_timestamps: Dict[str, list] = {}
         self._timestamps_lock = threading.Lock()
 
-        # Signal count per agent (for decay factor calculation)
+        # Signal count per agent (for decay interval tracking)
         self._signal_counts: Dict[str, int] = {}
 
+        # In-memory cache of Beta parameters per agent
+        # Key: agent_id, Value: (alpha, beta)
+        self._beta_params: Dict[str, tuple] = {}
+        self._beta_lock = threading.Lock()
+
         self._init_schema()
-        logger.info("TrustScorer initialized (v2.5 — silent collection, no enforcement)")
+        logger.info("TrustScorer initialized (Beta-Binomial — alpha=%.1f, beta=%.1f prior)",
+                     INITIAL_ALPHA, INITIAL_BETA)
 
     def _init_schema(self):
-        """Create trust_signals table for audit trail."""
+        """Create trust_signals table and add alpha/beta columns to agent_registry."""
         try:
             from db_connection_manager import DbConnectionManager
             mgr = DbConnectionManager.get_instance(self.db_path)
 
             def _create(conn):
+                # Trust signals audit trail
                 conn.execute('''
                     CREATE TABLE IF NOT EXISTS trust_signals (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -169,6 +221,18 @@ class TrustScorer:
                     CREATE INDEX IF NOT EXISTS idx_trust_created
                     ON trust_signals(created_at)
                 ''')
+
+                # Add trust_alpha and trust_beta columns to agent_registry
+                # (backward compatible — old databases get these columns added)
+                for col_name, col_default in [("trust_alpha", INITIAL_ALPHA),
+                                               ("trust_beta", INITIAL_BETA)]:
+                    try:
+                        conn.execute(
+                            f'ALTER TABLE agent_registry ADD COLUMN {col_name} REAL DEFAULT {col_default}'
+                        )
+                    except Exception:
+                        pass  # Column already exists
+
                 conn.commit()
 
             mgr.execute_write(_create)
@@ -189,11 +253,108 @@ class TrustScorer:
             ''')
             conn.execute('CREATE INDEX IF NOT EXISTS idx_trust_agent ON trust_signals(agent_id)')
             conn.execute('CREATE INDEX IF NOT EXISTS idx_trust_created ON trust_signals(created_at)')
+
+            # Add trust_alpha and trust_beta columns (backward compatible)
+            for col_name, col_default in [("trust_alpha", INITIAL_ALPHA),
+                                           ("trust_beta", INITIAL_BETA)]:
+                try:
+                    conn.execute(
+                        f'ALTER TABLE agent_registry ADD COLUMN {col_name} REAL DEFAULT {col_default}'
+                    )
+                except sqlite3.OperationalError:
+                    pass  # Column already exists
+
             conn.commit()
             conn.close()
 
     # =========================================================================
-    # Signal Recording
+    # Beta Parameter Management
+    # =========================================================================
+
+    def _get_beta_params(self, agent_id: str) -> tuple:
+        """
+        Get (alpha, beta) for an agent. Checks in-memory cache first,
+        then database, then falls back to prior defaults.
+
+        Returns:
+            (alpha, beta) tuple
+        """
+        with self._beta_lock:
+            if agent_id in self._beta_params:
+                return self._beta_params[agent_id]
+
+        # Not in cache — read from database
+        alpha, beta = None, None
+        try:
+            from db_connection_manager import DbConnectionManager
+            mgr = DbConnectionManager.get_instance(self.db_path)
+
+            with mgr.read_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                    "SELECT trust_alpha, trust_beta FROM agent_registry WHERE agent_id = ?",
+                    (agent_id,)
+                )
+                row = cursor.fetchone()
+                if row:
+                    alpha = row[0]
+                    beta = row[1]
+        except Exception:
+            pass
+
+        # Fall back to defaults if NULL or missing
+        if alpha is None or beta is None:
+            alpha = INITIAL_ALPHA
+            beta = INITIAL_BETA
+
+        with self._beta_lock:
+            self._beta_params[agent_id] = (alpha, beta)
+
+        return (alpha, beta)
+
+    def _set_beta_params(self, agent_id: str, alpha: float, beta: float):
+        """
+        Update (alpha, beta) in cache and persist to agent_registry.
+        Also computes and stores the derived trust_score = alpha/(alpha+beta).
+        """
+        trust_score = alpha / (alpha + beta) if (alpha + beta) > 0 else 0.0
+
+        with self._beta_lock:
+            self._beta_params[agent_id] = (alpha, beta)
+
+        try:
+            from db_connection_manager import DbConnectionManager
+            mgr = DbConnectionManager.get_instance(self.db_path)
+
+            def _update(conn):
+                conn.execute(
+                    """UPDATE agent_registry
+                       SET trust_score = ?, trust_alpha = ?, trust_beta = ?
+                       WHERE agent_id = ?""",
+                    (round(trust_score, 4), round(alpha, 4), round(beta, 4), agent_id)
+                )
+                conn.commit()
+
+            mgr.execute_write(_update)
+        except Exception as e:
+            logger.error("Failed to persist Beta params for %s: %s", agent_id, e)
+
+    def _apply_decay(self, agent_id: str, alpha: float, beta: float) -> tuple:
+        """
+        Apply periodic decay to alpha and beta to forget very old signals.
+
+        Called every DECAY_INTERVAL signals per agent.
+        Multiplies both by DECAY_FACTOR with floor constraints.
+
+        Returns:
+            (decayed_alpha, decayed_beta)
+        """
+        new_alpha = max(ALPHA_FLOOR, alpha * DECAY_FACTOR)
+        new_beta = max(BETA_FLOOR, beta * DECAY_FACTOR)
+        return (new_alpha, new_beta)
+
+    # =========================================================================
+    # Signal Recording (Beta-Binomial Update)
     # =========================================================================
 
     def record_signal(
@@ -203,50 +364,68 @@ class TrustScorer:
         context: Optional[dict] = None,
     ) -> bool:
         """
-        Record a trust signal for an agent.
+        Record a trust signal for an agent using Beta-Binomial update.
 
-        Silently adjusts the agent's trust score based on the signal type.
-        The signal and score change are logged to trust_signals table.
+        Positive signals increment alpha (trust evidence).
+        Negative signals increment beta (distrust evidence).
+        Neutral signals give a tiny alpha nudge.
+
+        Trust score = alpha / (alpha + beta) — the posterior mean.
 
         Args:
             agent_id: Agent that generated the signal
-            signal_type: One of SIGNAL_DELTAS keys
+            signal_type: One of SIGNAL_WEIGHTS keys
             context: Additional context (memory_id, etc.)
+
+        Returns:
+            True if signal was recorded successfully
         """
-        if signal_type not in SIGNAL_DELTAS:
+        if signal_type not in SIGNAL_WEIGHTS:
             logger.warning("Unknown trust signal: %s", signal_type)
-            return
+            return False
+
+        direction, weight = SIGNAL_WEIGHTS[signal_type]
 
-        delta = SIGNAL_DELTAS[signal_type]
+        # Get current Beta parameters
+        alpha, beta = self._get_beta_params(agent_id)
+        old_score = alpha / (alpha + beta) if (alpha + beta) > 0 else 0.0
 
-        # Get current trust score from agent registry
-        old_score = self._get_agent_trust(agent_id)
-        if old_score is None:
-            old_score = 1.0  # Default for unknown agents
+        # Apply Beta-Binomial update
+        if direction == "positive":
+            alpha += weight
+        elif direction == "negative":
+            beta += weight
+        else:  # neutral — tiny alpha nudge
+            alpha += weight
 
-        # Apply decay factor (score stabilizes over time)
-        count = self._signal_counts.get(agent_id, 0)
-        decay = 1.0 / (1.0 + count * 0.01)
-        adjusted_delta = delta * decay
+        # Apply periodic decay
+        count = self._signal_counts.get(agent_id, 0) + 1
+        self._signal_counts[agent_id] = count
 
-        # Calculate new score (clamped to [0.0, 1.0])
-        new_score = max(0.0, min(1.0, old_score + adjusted_delta))
+        if count % DECAY_INTERVAL == 0:
+            alpha, beta = self._apply_decay(agent_id, alpha, beta)
 
-        # Update signal count
-        self._signal_counts[agent_id] = count + 1
+        # Compute new trust score (posterior mean)
+        new_score = alpha / (alpha + beta) if (alpha + beta) > 0 else 0.0
+
+        # Compute delta for audit trail (backward compatible with trust_signals table)
+        delta = new_score - old_score
 
         # Persist signal to audit trail
-        self._persist_signal(agent_id, signal_type, adjusted_delta, old_score, new_score, context)
+        self._persist_signal(agent_id, signal_type, delta, old_score, new_score, context)
 
-        # Update agent trust score (if score actually changed)
-        if abs(new_score - old_score) > 0.0001:
-            self._update_agent_trust(agent_id, new_score)
+        # Persist updated Beta parameters and derived trust_score
+        self._set_beta_params(agent_id, alpha, beta)
 
         logger.debug(
-            "Trust signal: agent=%s, type=%s, delta=%.4f, score=%.4f→%.4f",
-            agent_id, signal_type, adjusted_delta, old_score, new_score
+            "Trust signal: agent=%s, type=%s (%s, w=%.2f), "
+            "alpha=%.2f, beta=%.2f, score=%.4f->%.4f",
+            agent_id, signal_type, direction, weight,
+            alpha, beta, old_score, new_score
         )
 
+        return True
+
     def _persist_signal(self, agent_id, signal_type, delta, old_score, new_score, context):
         """Save signal to trust_signals table."""
         try:
@@ -265,7 +444,12 @@ class TrustScorer:
             logger.error("Failed to persist trust signal: %s", e)
 
     def _get_agent_trust(self, agent_id: str) -> Optional[float]:
-        """Get current trust score from agent_registry."""
+        """
+        Get current trust score from agent_registry.
+
+        This reads the derived trust_score column (which is always kept
+        in sync with alpha/(alpha+beta) by _set_beta_params).
+        """
         try:
             from db_connection_manager import DbConnectionManager
             mgr = DbConnectionManager.get_instance(self.db_path)
@@ -282,7 +466,13 @@ class TrustScorer:
             return None
 
     def _update_agent_trust(self, agent_id: str, new_score: float):
-        """Update trust score in agent_registry."""
+        """
+        Update trust score in agent_registry (legacy compatibility method).
+
+        In Beta-Binomial mode, this is a no-op because _set_beta_params
+        already updates trust_score alongside alpha and beta. Kept for
+        backward compatibility if any external code calls it directly.
+        """
         try:
             from db_connection_manager import DbConnectionManager
             mgr = DbConnectionManager.get_instance(self.db_path)
@@ -373,16 +563,40 @@ class TrustScorer:
     # =========================================================================
 
     def get_trust_score(self, agent_id: str) -> float:
-        """Get current trust score for an agent. Returns 1.0 if unknown."""
-        score = self._get_agent_trust(agent_id)
-        return score if score is not None else 1.0
+        """
+        Get current trust score for an agent.
+
+        Computes alpha/(alpha+beta) from cached or stored Beta params.
+        Returns INITIAL_ALPHA/(INITIAL_ALPHA+INITIAL_BETA) = 0.667 for
+        unknown agents.
+        """
+        alpha, beta = self._get_beta_params(agent_id)
+        if (alpha + beta) > 0:
+            return alpha / (alpha + beta)
+        return INITIAL_ALPHA / (INITIAL_ALPHA + INITIAL_BETA)
+
+    def get_beta_params(self, agent_id: str) -> Dict[str, float]:
+        """
+        Get the Beta distribution parameters for an agent.
+
+        Returns:
+            {"alpha": float, "beta": float, "trust_score": float}
+        """
+        alpha, beta = self._get_beta_params(agent_id)
+        score = alpha / (alpha + beta) if (alpha + beta) > 0 else 0.0
+        return {
+            "alpha": round(alpha, 4),
+            "beta": round(beta, 4),
+            "trust_score": round(score, 4),
+        }
 
     def check_trust(self, agent_id: str, operation: str = "write") -> bool:
         """
         Check if agent is trusted enough for the given operation.
 
         v2.6 enforcement: blocks write/delete for agents with trust < 0.3.
-        New agents start at 1.0 — only repeated bad behavior triggers blocking.
+        New agents start at Beta(2,1) → trust 0.667 — only repeated bad
+        behavior triggers blocking.
 
         Args:
             agent_id: The agent identifier
@@ -394,14 +608,12 @@ class TrustScorer:
         if operation == "read":
             return True  # Reads are always allowed
 
-        score = self._get_agent_trust(agent_id)
-        if score is None:
-            return True  # Unknown agent = first-time = allowed (starts at 1.0)
+        score = self.get_trust_score(agent_id)
 
         threshold = 0.3  # Block write/delete below this
         if score < threshold:
             logger.warning(
-                "Trust enforcement: agent '%s' blocked from '%s' (trust=%.2f < %.2f)",
+                "Trust enforcement: agent '%s' blocked from '%s' (trust=%.4f < %.2f)",
                 agent_id, operation, score, threshold
             )
             return False
@@ -479,7 +691,9 @@ class TrustScorer:
                 "total_signals": total_signals,
                 "by_signal_type": by_type,
                 "by_agent": by_agent,
-                "avg_trust_score": round(avg, 4) if avg else 1.0,
+                "avg_trust_score": round(avg, 4) if avg else INITIAL_ALPHA / (INITIAL_ALPHA + INITIAL_BETA),
+                "scoring_model": "Beta-Binomial",
+                "prior": f"Beta({INITIAL_ALPHA}, {INITIAL_BETA})",
                 "enforcement": "enabled (v2.6 — write/delete blocked below 0.3 trust)",
             }
 

package/ui/app.js

@@ -1445,9 +1445,9 @@ async function loadAgents() {
 
             // Trust score
             var tdTrust = document.createElement('td');
-            var trustScore = agent.trust_score != null ? agent.trust_score : 1.0;
-            tdTrust.className = trustScore < 0.7 ? 'text-danger fw-bold'
-                : trustScore < 0.9 ? 'text-warning fw-bold' : 'text-success fw-bold';
+            var trustScore = agent.trust_score != null ? agent.trust_score : 0.667;
+            tdTrust.className = trustScore < 0.3 ? 'text-danger fw-bold'
+                : trustScore < 0.5 ? 'text-warning fw-bold' : 'text-success fw-bold';
             tdTrust.textContent = trustScore.toFixed(2);
             tr.appendChild(tdTrust);
 
@@ -1524,7 +1524,7 @@ async function loadTrustOverview() {
         card2.className = 'border rounded p-3 text-center';
         var val2 = document.createElement('div');
         val2.className = 'fs-4 fw-bold';
-        val2.textContent = (stats.avg_trust_score || 1.0).toFixed(3);
+        val2.textContent = (stats.avg_trust_score || 0.667).toFixed(3);
         card2.appendChild(val2);
         var lbl2 = document.createElement('small');
         lbl2.className = 'text-muted';

package/ui/index.html

@@ -742,6 +742,10 @@
             </li>
         </ul>
 
+        <!-- Privacy Notice & Feedback Progress (v2.7.4) -->
+        <div id="privacy-notice"></div>
+        <div id="feedback-progress" class="mb-3"></div>
+
         <div class="tab-content">
             <!-- Graph Visualization -->
             <div class="tab-pane fade show active" id="graph-pane">
@@ -956,6 +960,20 @@
                     </div>
                 </div>
 
+                <!-- What We Learned (v2.7.4 — Summary Card) -->
+                <div class="card p-3 mb-3" id="what-we-learned-card">
+                    <div class="d-flex justify-content-between align-items-center mb-3">
+                        <h6 class="mb-0"><i class="bi bi-lightbulb"></i> What SuperLocalMemory Learned About You</h6>
+                        <span class="badge bg-success" id="learned-profile-badge">default</span>
+                    </div>
+                    <div id="what-we-learned-content">
+                        <div class="text-center text-muted py-3">
+                            <i class="bi bi-hourglass-split" style="font-size: 1.5rem;"></i>
+                            <p class="mt-2 mb-0 small">Loading learned insights...</p>
+                        </div>
+                    </div>
+                </div>
+
                 <div class="row g-3">
                     <!-- Tech Preferences (Layer 1) -->
                     <div class="col-md-6">
@@ -1239,6 +1257,25 @@
                         </div>
                     </div>
                 </div>
+                <!-- Learning Data Management (v2.7.4) -->
+                <div class="card p-3 mb-3">
+                    <h5 class="mb-3"><i class="bi bi-brain"></i> Learning Data</h5>
+                    <p class="text-muted small mb-3">
+                        SuperLocalMemory learns from your usage patterns to improve recall results.
+                        All learning data is stored locally in <code>~/.claude-memory/learning.db</code>.
+                    </p>
+                    <div id="learning-data-stats" class="mb-3"></div>
+                    <div class="d-flex gap-2">
+                        <button class="btn btn-outline-danger" onclick="resetLearningData()">
+                            <i class="bi bi-arrow-counterclockwise"></i> Reset Learning Data
+                        </button>
+                        <button class="btn btn-outline-info" onclick="backupLearningDb()">
+                            <i class="bi bi-download"></i> Backup Learning DB
+                        </button>
+                    </div>
+                    <small class="text-muted mt-2 d-block">Reset clears all learned preferences, feedback signals, and patterns. Your memories are preserved.</small>
+                </div>
+
                 <!-- Backup History -->
                 <div class="card p-3">
                     <h5 class="mb-3"><i class="bi bi-clock-history"></i> Backup History</h5>
@@ -1319,6 +1356,7 @@
     <script src="static/js/events.js"></script>
     <script src="static/js/agents.js"></script>
     <script src="static/js/learning.js"></script>
+    <script src="static/js/feedback.js"></script>
     <script src="static/js/init.js"></script>
 
     <footer>

package/ui/js/agents.js

@@ -78,9 +78,9 @@ async function loadAgents() {
             tr.appendChild(tdProto);
 
             var tdTrust = document.createElement('td');
-            var trustScore = agent.trust_score != null ? agent.trust_score : 1.0;
-            tdTrust.className = trustScore < 0.7 ? 'text-danger fw-bold'
-                : trustScore < 0.9 ? 'text-warning fw-bold' : 'text-success fw-bold';
+            var trustScore = agent.trust_score != null ? agent.trust_score : 0.667;
+            tdTrust.className = trustScore < 0.3 ? 'text-danger fw-bold'
+                : trustScore < 0.5 ? 'text-warning fw-bold' : 'text-success fw-bold';
             tdTrust.textContent = trustScore.toFixed(2);
             tr.appendChild(tdTrust);
 
@@ -133,7 +133,7 @@ async function loadTrustOverview() {
 
         var cardData = [
             { value: (stats.total_signals || 0).toLocaleString(), label: 'Total Signals Collected', cls: '' },
-            { value: (stats.avg_trust_score || 1.0).toFixed(3), label: 'Average Trust Score', cls: '' },
+            { value: (stats.avg_trust_score || 0.667).toFixed(3), label: 'Average Trust Score', cls: '' },
             { value: stats.enforcement || 'disabled', label: 'Enforcement Status', cls: 'text-info' }
         ];