nexo-brain 4.0.1 → 5.0.0

package/src/dashboard/templates/cortex.html

@@ -31,20 +31,20 @@
 <!-- Stats row -->
 <div class="grid grid-cols-4 gap-4 mb-6">
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Total Decisions</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Alt Evaluations</p>
     <p class="text-2xl font-display font-bold text-slate-100" id="stat-decisions">--</p>
   </div>
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Avg Confidence</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Accept Rate</p>
     <p class="text-2xl font-display font-bold text-nexo-400" id="stat-confidence">--</p>
   </div>
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Cortex Logs</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Linked Outcomes</p>
     <p class="text-2xl font-display font-bold text-slate-100" id="stat-logs">--</p>
   </div>
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Success Rate</p>
-    <p class="text-2xl font-display font-bold text-emerald-400" id="stat-success">--</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Override Rate</p>
+    <p class="text-2xl font-display font-bold text-amber-400" id="stat-success">--</p>
   </div>
 </div>
 
@@ -77,7 +77,7 @@
       <span class="text-[10px] text-slate-600 font-mono" id="decisions-count">--</span>
     </div>
     <div id="decisions-list" class="space-y-3 max-h-[600px] overflow-y-auto pr-1">
-      <div class="py-12 text-center text-sm text-slate-500">Loading decisions...</div>
+      <div class="py-12 text-center text-sm text-slate-500">Loading decision support...</div>
     </div>
   </div>
 </div>
@@ -94,6 +94,7 @@
 <script>
   let allLogs = [];
   let allDecisions = [];
+  let allEvaluations = [];
 
   const modeColors = {
     conservative: { bg: 'bg-blue-500/15', text: 'text-blue-400', border: 'border-blue-500/30' },
@@ -156,16 +157,69 @@
     }).join('');
   }
 
-  function renderDecisions(decisions) {
+  function renderDecisions(evaluations, decisions) {
     const container = document.getElementById('decisions-list');
-    document.getElementById('decisions-count').textContent = `${decisions.length} decisions`;
+    document.getElementById('decisions-count').textContent = `${evaluations.length} evaluations / ${decisions.length} decisions`;
 
-    if (!decisions.length) {
-      container.innerHTML = '<div class="py-12 text-center text-sm text-slate-500">No decisions recorded</div>';
+    if (!evaluations.length && !decisions.length) {
+      container.innerHTML = '<div class="py-12 text-center text-sm text-slate-500">No decision support recorded</div>';
       return;
     }
 
-    container.innerHTML = decisions.slice(0, 50).map((d, i) => `
+    const evaluationCards = evaluations.slice(0, 25).map((item, i) => {
+      const scores = Array.isArray(item.scores) ? item.scores : JSON.parse(item.scores || '[]');
+      const top = scores[0] || null;
+      const selectedChanged = item.selection_source === 'override';
+      return `
+      <div class="bg-slate-800/30 rounded-lg p-4 hover:bg-slate-800/50 transition-colors border border-transparent hover:border-slate-700/50 animate-fade-in" style="animation-delay: ${i * 35}ms">
+        <div class="flex items-center justify-between mb-2 gap-2">
+          <div class="flex items-center gap-2 flex-wrap">
+            ${item.impact_level ? `<span class="inline-flex items-center px-2 py-0.5 rounded-md text-[10px] font-semibold bg-red-500/15 text-red-300 uppercase tracking-wider">${escapeHtml(item.impact_level)}</span>` : ''}
+            ${item.area ? `<span class="inline-flex items-center px-2 py-0.5 rounded-md text-[10px] font-semibold bg-nexo-500/15 text-nexo-400 uppercase tracking-wider">${escapeHtml(item.area)}</span>` : ''}
+          </div>
+          <span class="text-[10px] text-slate-600">${relativeTime(item.created_at)}</span>
+        </div>
+        <p class="text-sm text-slate-200 mb-2">${escapeHtml(item.goal || '--')}</p>
+        <div class="grid grid-cols-2 gap-2 mb-2">
+          <div class="bg-slate-900/40 rounded-md p-2">
+            <p class="text-[10px] uppercase tracking-wider text-slate-500 mb-1">Recommended</p>
+            <p class="text-xs text-emerald-400 font-semibold">${escapeHtml(item.recommended_choice || '--')}</p>
+          </div>
+          <div class="bg-slate-900/40 rounded-md p-2">
+            <p class="text-[10px] uppercase tracking-wider text-slate-500 mb-1">Selected</p>
+            <p class="text-xs ${selectedChanged ? 'text-amber-400' : 'text-slate-200'} font-semibold">${escapeHtml(item.selected_choice || '--')}</p>
+          </div>
+        </div>
+        ${item.recommended_reasoning ? `<p class="text-xs text-slate-400 mb-2">${escapeHtml(item.recommended_reasoning)}</p>` : ''}
+        ${item.goal_profile_id ? `
+          <div class="mt-2 bg-slate-900/40 rounded px-2 py-1.5">
+            <p class="text-[10px] text-slate-500 uppercase tracking-wider font-semibold mb-0.5">Goal Profile</p>
+            <p class="text-xs text-nexo-300 font-semibold">${escapeHtml(item.goal_profile_id)}</p>
+            ${Array.isArray(item.goal_profile_labels) && item.goal_profile_labels.length ? `<p class="text-[10px] text-slate-400 mt-1">${escapeHtml(item.goal_profile_labels.join(' · '))}</p>` : ''}
+          </div>
+        ` : ''}
+        ${item.linked_outcome_id ? `
+          <div class="mt-2 text-[10px] text-slate-500">
+            outcome #${escapeHtml(String(item.linked_outcome_id))}
+            ${item.linked_outcome?.status ? `· <span class="text-slate-300">${escapeHtml(String(item.linked_outcome.status))}</span>` : ''}
+          </div>
+        ` : ''}
+        ${selectedChanged && item.selection_reason ? `
+          <div class="mt-2 bg-amber-500/10 rounded px-2 py-1.5">
+            <p class="text-[10px] text-amber-400 font-semibold uppercase tracking-wider mb-0.5">Override</p>
+            <p class="text-xs text-amber-200/90">${escapeHtml(item.selection_reason)}</p>
+          </div>
+        ` : ''}
+        ${top ? `
+          <div class="mt-2 text-[10px] text-slate-500 font-mono">
+            top=${Number(top.total_score || 0).toFixed(2)} impact=${Number(top.impact || 0).toFixed(1)} success=${Number(top.success_probability || 0).toFixed(1)} risk=${Number(top.risk_level || 0).toFixed(1)}
+          </div>
+        ` : ''}
+      </div>
+      `;
+    }).join('');
+
+    const decisionCards = decisions.slice(0, 20).map((d, i) => `
       <div class="bg-slate-800/30 rounded-lg p-4 hover:bg-slate-800/50 transition-colors border border-transparent hover:border-slate-700/50 animate-fade-in" style="animation-delay: ${i * 40}ms">
         <div class="flex items-center justify-between mb-2">
           <div class="flex items-center gap-2">
@@ -190,6 +244,15 @@
         </div>
       </div>
     `).join('');
+
+    const decisionSection = decisionCards ? `
+      <div class="pt-3 mt-3 border-t border-slate-800/80">
+        <p class="text-[10px] uppercase tracking-wider text-slate-500 font-semibold mb-3">Decision Log</p>
+        <div class="space-y-3">${decisionCards}</div>
+      </div>
+    ` : '';
+
+    container.innerHTML = evaluationCards + decisionSection;
   }
 
   function renderConfidenceChart(decisions) {
@@ -217,9 +280,10 @@
 
     const filteredLogs = modeFilter ? allLogs.filter(l => l.mode === modeFilter) : allLogs;
     const filteredDecisions = domainFilter ? allDecisions.filter(d => d.domain === domainFilter) : allDecisions;
+    const filteredEvaluations = domainFilter ? allEvaluations.filter(e => e.area === domainFilter) : allEvaluations;
 
     renderLogs(filteredLogs);
-    renderDecisions(filteredDecisions);
+    renderDecisions(filteredEvaluations, filteredDecisions);
   }
 
   async function loadData() {
@@ -228,29 +292,24 @@
 
     allLogs = data.cortex_logs || [];
     allDecisions = data.decisions || [];
+    allEvaluations = data.evaluations || [];
+    const summary = data.summary || {};
 
     // Populate domain filter
-    const domains = [...new Set(allDecisions.map(d => d.domain).filter(Boolean))];
+    const domains = [...new Set([
+      ...allDecisions.map(d => d.domain).filter(Boolean),
+      ...allEvaluations.map(e => e.area).filter(Boolean),
+    ])];
     const domainSelect = document.getElementById('filter-domain');
     const currentDomain = domainSelect.value;
     domainSelect.innerHTML = '<option value="">All Domains</option>' +
       domains.map(d => `<option value="${escapeHtml(d)}" ${d === currentDomain ? 'selected' : ''}>${escapeHtml(d)}</option>`).join('');
 
     // Stats
-    document.getElementById('stat-decisions').textContent = formatNumber(allDecisions.length);
-    document.getElementById('stat-logs').textContent = formatNumber(allLogs.length);
-
-    const confidences = allDecisions.filter(d => d.confidence != null).map(d => {
-      const v = typeof d.confidence === 'number' ? (d.confidence > 1 ? d.confidence : d.confidence * 100) : parseFloat(d.confidence);
-      return v;
-    });
-    const avgConf = confidences.length ? (confidences.reduce((a, b) => a + b, 0) / confidences.length) : 0;
-    document.getElementById('stat-confidence').textContent = avgConf.toFixed(0) + '%';
-
-    const outcomes = allDecisions.filter(d => d.outcome);
-    const successes = outcomes.filter(d => d.outcome === 'success' || d.outcome === 'positive' || d.outcome === 'good');
-    const successRate = outcomes.length ? ((successes.length / outcomes.length) * 100) : 0;
-    document.getElementById('stat-success').textContent = successRate.toFixed(0) + '%';
+    document.getElementById('stat-decisions').textContent = formatNumber(allEvaluations.length);
+    document.getElementById('stat-confidence').textContent = `${Number(summary.recommendation_accept_rate || 0).toFixed(0)}%`;
+    document.getElementById('stat-logs').textContent = formatNumber(summary.linked_outcomes_total || 0);
+    document.getElementById('stat-success').textContent = `${Number(summary.override_rate || 0).toFixed(0)}%`;
 
     renderConfidenceChart(allDecisions);
     applyFilters();

package/src/db/__init__.py

@@ -51,6 +51,9 @@ _watchers = _load_submodule("db._watchers")
 _personal_scripts = _load_submodule("db._personal_scripts")
 _skills = _load_submodule("db._skills")
 _hot_context = _load_submodule("db._hot_context")
+_drive = _load_submodule("db._drive")
+_outcomes = _load_submodule("db._outcomes")
+_goal_profiles = _load_submodule("db._goal_profiles")
 
 # Core: connection, constants, init, utils
 from db._core import (
@@ -87,6 +90,7 @@ from db._reminders import (
     create_followup, update_followup, complete_followup, delete_followup,
     restore_followup, add_followup_note, get_followups, get_followup, get_followup_history,
     find_similar_followups,
+    compute_followup_impact, score_followup, score_active_followups,
     add_item_history, get_item_history, validate_item_read_token,
 )
 
@@ -146,6 +150,10 @@ from db._protocol import (
     create_protocol_task, get_protocol_task, close_protocol_task,
     create_protocol_debt, resolve_protocol_debts, list_protocol_debts,
     protocol_compliance_summary,
+    create_cortex_evaluation, get_cortex_evaluation, list_cortex_evaluations,
+    cortex_evaluation_summary,
+    latest_cortex_evaluation_for_task, task_has_cortex_evaluation,
+    override_cortex_evaluation,
 )
 
 # Durable workflow runtime
@@ -184,9 +192,17 @@ from db._skills import (
     validate_skill_params, render_command_template, sync_skill_directories,
     import_skill_from_directory, approve_skill, collect_scriptable_skill_candidates,
     collect_skill_improvement_candidates, materialize_personal_skill_definition,
+    get_skill_outcome_evidence, list_skill_outcome_reviews,
     get_skill_health_report,
 )
 
+# Drive / Curiosity signals
+from db._drive import (
+    create_drive_signal, reinforce_drive_signal, get_drive_signals,
+    get_drive_signal, update_drive_signal_status, decay_drive_signals,
+    find_similar_drive_signal, drive_signal_stats,
+)
+
 # Hot context / recent continuity
 from db._hot_context import (
     DEFAULT_CONTEXT_TTL_HOURS,
@@ -198,6 +214,23 @@ from db._hot_context import (
     resolve_hot_context,
 )
 
+# Outcomes
+from db._outcomes import (
+    VALID_METRIC_SOURCES as OUTCOME_METRIC_SOURCES,
+    VALID_TARGET_OPERATORS as OUTCOME_TARGET_OPERATORS,
+    create_outcome, get_outcome, list_outcomes,
+    cancel_outcome, evaluate_outcome, pending_outcomes_due,
+    find_pending_outcomes_by_action, set_linked_outcomes_met,
+    list_outcome_pattern_candidates, capture_outcome_pattern,
+)
+
+# Goal Engine v1
+from db._goal_profiles import (
+    DEFAULT_GOAL_PROFILES,
+    ensure_default_goal_profiles, get_goal_profile, list_goal_profiles,
+    upsert_goal_profile, resolve_goal_profile,
+)
+
 
 def get_db():
     return _module("db._core").get_db()

package/src/db/_drive.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+"""NEXO DB — Drive/Curiosity signals for autonomous investigation."""
+
+import importlib
+import json
+import sys
+from datetime import datetime, timezone
+
+
+def _core():
+    module = sys.modules.get("db._core")
+    if module is None:
+        module = importlib.import_module("db._core")
+    return module
+
+
+MAX_ACTIVE_SIGNALS = 30
+REINFORCE_BOOST = 0.15
+RISING_THRESHOLD = 0.4
+READY_THRESHOLD = 0.7
+RISING_DECAY_RATE = 0.03  # slower decay once rising
+
+VALID_SIGNAL_TYPES = {"anomaly", "pattern", "connection", "gap", "opportunity"}
+VALID_STATUSES = {"latent", "rising", "ready", "acted", "dismissed"}
+
+
+def _table_exists(conn) -> bool:
+    row = conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='drive_signals' LIMIT 1"
+    ).fetchone()
+    return row is not None
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+
+
+def create_drive_signal(
+    signal_type: str,
+    source: str,
+    summary: str,
+    source_id: str = "",
+    area: str = "",
+    tension: float = 0.3,
+    decay_rate: float = 0.05,
+    evidence: list[str] | None = None,
+) -> dict:
+    """Create a new drive signal. Returns the created row as dict."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"ok": False, "error": "drive_signals table not yet created"}
+
+    if signal_type not in VALID_SIGNAL_TYPES:
+        return {"ok": False, "error": f"Invalid signal_type: {signal_type}. Must be one of {VALID_SIGNAL_TYPES}"}
+
+    tension = max(0.0, min(1.0, tension))
+    evidence_json = json.dumps(evidence or [summary[:200]], ensure_ascii=False)
+    now = _now_iso()
+
+    # Enforce max active signals — drop weakest latent if at limit
+    active_count = conn.execute(
+        "SELECT COUNT(*) FROM drive_signals WHERE status IN ('latent', 'rising', 'ready')"
+    ).fetchone()[0]
+    if active_count >= MAX_ACTIVE_SIGNALS:
+        conn.execute(
+            "DELETE FROM drive_signals WHERE id = ("
+            "  SELECT id FROM drive_signals"
+            "  WHERE status = 'latent'"
+            "  ORDER BY tension ASC, first_seen ASC"
+            "  LIMIT 1"
+            ")"
+        )
+        conn.commit()
+
+    cursor = conn.execute(
+        "INSERT INTO drive_signals "
+        "(signal_type, source, source_id, area, summary, tension, evidence, "
+        " status, first_seen, last_reinforced, decay_rate) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, 'latent', ?, ?, ?)",
+        (signal_type, source, source_id, area, summary, tension,
+         evidence_json, now, now, decay_rate),
+    )
+    conn.commit()
+    signal_id = cursor.lastrowid
+    return {"ok": True, "id": signal_id, "tension": tension, "status": "latent"}
+
+
+def reinforce_drive_signal(signal_id: int, observation: str) -> dict:
+    """Reinforce an existing signal: add evidence, boost tension, maybe promote status."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"ok": False, "error": "drive_signals table not yet created"}
+
+    row = conn.execute(
+        "SELECT * FROM drive_signals WHERE id = ?", (signal_id,)
+    ).fetchone()
+    if not row:
+        return {"ok": False, "error": f"Signal {signal_id} not found"}
+
+    status = row["status"]
+    if status in ("acted", "dismissed"):
+        return {"ok": False, "error": f"Signal {signal_id} is already {status}"}
+
+    # Update evidence
+    try:
+        evidence = json.loads(row["evidence"] or "[]")
+    except (json.JSONDecodeError, TypeError):
+        evidence = []
+    evidence.append(observation[:500])
+
+    # Boost tension
+    old_tension = float(row["tension"] or 0.3)
+    new_tension = min(1.0, old_tension + REINFORCE_BOOST)
+
+    # Status promotion
+    new_status = status
+    reinforce_count = len(evidence)
+    if new_tension >= READY_THRESHOLD or reinforce_count >= 3:
+        new_status = "ready"
+    elif new_tension >= RISING_THRESHOLD:
+        new_status = "rising"
+
+    # Rising signals decay slower
+    new_decay = RISING_DECAY_RATE if new_status in ("rising", "ready") else float(row["decay_rate"] or 0.05)
+
+    now = _now_iso()
+    conn.execute(
+        "UPDATE drive_signals SET tension = ?, evidence = ?, status = ?, "
+        "decay_rate = ?, last_reinforced = ? WHERE id = ?",
+        (new_tension, json.dumps(evidence, ensure_ascii=False),
+         new_status, new_decay, now, signal_id),
+    )
+    conn.commit()
+    return {
+        "ok": True, "id": signal_id,
+        "old_tension": old_tension, "new_tension": new_tension,
+        "old_status": status, "new_status": new_status,
+        "evidence_count": reinforce_count,
+    }
+
+
+def get_drive_signals(
+    status: str | None = None,
+    area: str | None = None,
+    limit: int = 30,
+) -> list[dict]:
+    """List active drive signals, optionally filtered."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return []
+
+    clauses = []
+    params: list = []
+    if status:
+        clauses.append("status = ?")
+        params.append(status)
+    else:
+        # Default: only active signals
+        clauses.append("status IN ('latent', 'rising', 'ready')")
+    if area:
+        clauses.append("area = ?")
+        params.append(area)
+
+    where = " AND ".join(clauses) if clauses else "1=1"
+    params.append(min(limit, 100))
+
+    rows = conn.execute(
+        f"SELECT * FROM drive_signals WHERE {where} ORDER BY tension DESC, last_reinforced DESC LIMIT ?",
+        params,
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def get_drive_signal(signal_id: int) -> dict | None:
+    """Get a single signal with full details."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return None
+
+    row = conn.execute(
+        "SELECT * FROM drive_signals WHERE id = ?", (signal_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def update_drive_signal_status(
+    signal_id: int,
+    status: str,
+    outcome: str = "",
+) -> dict:
+    """Transition a signal to a new status (acted/dismissed)."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"ok": False, "error": "drive_signals table not yet created"}
+
+    if status not in VALID_STATUSES:
+        return {"ok": False, "error": f"Invalid status: {status}"}
+
+    row = conn.execute(
+        "SELECT * FROM drive_signals WHERE id = ?", (signal_id,)
+    ).fetchone()
+    if not row:
+        return {"ok": False, "error": f"Signal {signal_id} not found"}
+
+    now = _now_iso()
+    updates = {"status": status}
+    if status == "acted":
+        updates["acted_at"] = now
+    if outcome:
+        updates["outcome"] = outcome
+
+    set_clause = ", ".join(f"{k} = ?" for k in updates)
+    params = list(updates.values()) + [signal_id]
+    conn.execute(f"UPDATE drive_signals SET {set_clause} WHERE id = ?", params)
+    conn.commit()
+    return {"ok": True, "id": signal_id, "new_status": status}
+
+
+def decay_drive_signals() -> dict:
+    """Apply daily decay to all active signals. Kill those at or below 0."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"decayed": 0, "killed": 0}
+
+    # Ready signals don't decay
+    rows = conn.execute(
+        "SELECT id, tension, decay_rate, status FROM drive_signals "
+        "WHERE status IN ('latent', 'rising')"
+    ).fetchall()
+
+    decayed = 0
+    killed = 0
+    for row in rows:
+        new_tension = float(row["tension"]) - float(row["decay_rate"] or 0.05)
+        if new_tension <= 0:
+            conn.execute("DELETE FROM drive_signals WHERE id = ?", (row["id"],))
+            killed += 1
+        else:
+            conn.execute(
+                "UPDATE drive_signals SET tension = ? WHERE id = ?",
+                (new_tension, row["id"]),
+            )
+            decayed += 1
+
+    conn.commit()
+    return {"decayed": decayed, "killed": killed}
+
+
+def find_similar_drive_signal(summary: str, area: str = "") -> dict | None:
+    """Find an existing active signal similar to the given summary.
+
+    Uses keyword overlap heuristic to avoid duplicates.
+    """
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return None
+
+    # Extract meaningful words (4+ chars) from summary
+    words = {w.lower() for w in summary.split() if len(w) >= 4}
+    if not words:
+        return None
+
+    clauses = ["status IN ('latent', 'rising', 'ready')"]
+    params: list = []
+    if area:
+        clauses.append("area = ?")
+        params.append(area)
+
+    where = " AND ".join(clauses)
+    rows = conn.execute(
+        f"SELECT * FROM drive_signals WHERE {where} ORDER BY tension DESC",
+        params,
+    ).fetchall()
+
+    best_match = None
+    best_score = 0.0
+    for row in rows:
+        row_words = {w.lower() for w in (row["summary"] or "").split() if len(w) >= 4}
+        if not row_words:
+            continue
+        overlap = len(words & row_words)
+        score = overlap / max(len(words | row_words), 1)
+        if score > best_score and score >= 0.4:  # 40% word overlap threshold
+            best_score = score
+            best_match = dict(row)
+
+    return best_match
+
+
+def drive_signal_stats() -> dict:
+    """Return aggregate stats about drive signals."""
+    conn = _core().get_db()
+    if not _table_exists(conn):
+        return {"total": 0, "by_status": {}, "by_type": {}, "by_area": {}}
+
+    total = conn.execute("SELECT COUNT(*) FROM drive_signals").fetchone()[0]
+
+    by_status = {}
+    for row in conn.execute(
+        "SELECT status, COUNT(*) as cnt FROM drive_signals GROUP BY status"
+    ).fetchall():
+        by_status[row["status"]] = row["cnt"]
+
+    by_type = {}
+    for row in conn.execute(
+        "SELECT signal_type, COUNT(*) as cnt FROM drive_signals "
+        "WHERE status IN ('latent', 'rising', 'ready') GROUP BY signal_type"
+    ).fetchall():
+        by_type[row["signal_type"]] = row["cnt"]
+
+    by_area = {}
+    for row in conn.execute(
+        "SELECT area, COUNT(*) as cnt FROM drive_signals "
+        "WHERE status IN ('latent', 'rising', 'ready') AND area != '' GROUP BY area"
+    ).fetchall():
+        by_area[row["area"]] = row["cnt"]
+
+    return {"total": total, "by_status": by_status, "by_type": by_type, "by_area": by_area}