claude_memory 0.10.0 → 0.12.0

data/lib/claude_memory/dashboard/index.html

@@ -1044,6 +1044,16 @@
   }
   .knowledge-card .kc-meta .src.project { background: var(--accent-dim); color: var(--accent); }
   .knowledge-card .kc-meta .src.global { background: var(--purple-dim); color: var(--purple); }
+  /* Generic .src badge used by Prompt Journey rows; knowledge-card rule above
+     wins by specificity for project/global tags inside knowledge cards. */
+  .src {
+    font-family: var(--mono);
+    font-size: 10px;
+    padding: 1px 6px;
+    border-radius: 3px;
+  }
+  .src.otel { background: var(--accent-dim); color: var(--accent); }
+  .src.activity { background: var(--purple-dim); color: var(--purple); }
   .knowledge-card.highlighted {
     border-color: var(--accent);
     box-shadow: 0 0 0 3px var(--accent-dim);
@@ -1230,6 +1240,7 @@
     <div class="drawer-tab" data-adv="efficacy">Efficacy</div>
     <div class="drawer-tab" data-adv="conflicts">Conflicts</div>
     <div class="drawer-tab" data-adv="activity">Raw log</div>
+    <div class="drawer-tab" data-adv="telemetry">Telemetry</div>
   </div>
 
   <div class="drawer-panel active" id="adv-knowledge">
@@ -1360,6 +1371,54 @@
       </table>
     </div>
   </div>
+
+  <div class="drawer-panel" id="adv-telemetry">
+    <div class="adv-card" id="telemetry-status" style="font-size: 12px; color: var(--text-dim);">
+      Loading telemetry status...
+    </div>
+    <div class="adv-card" style="font-size: 11px; color: var(--text-dim);">
+      Capturing only metrics by default. Prompts and bodies require explicit opt-in via
+      <code>claude-memory otel --capture-prompts</code>.
+    </div>
+    <div class="adv-card">
+      <h3 style="margin-top: 0;">Cost (last 7 days, hourly)</h3>
+      <table>
+        <thead><tr><th>Hour</th><th style="text-align: right;">Requests</th><th style="text-align: right;">Cost USD</th></tr></thead>
+        <tbody id="telemetry-cost-tbody"></tbody>
+      </table>
+    </div>
+    <div class="adv-card">
+      <h3 style="margin-top: 0;">Tokens by model</h3>
+      <table>
+        <thead><tr><th>Model</th><th>Type</th><th style="text-align: right;">Tokens</th></tr></thead>
+        <tbody id="telemetry-tokens-tbody"></tbody>
+      </table>
+    </div>
+    <div class="adv-card">
+      <h3 style="margin-top: 0;">Top tools by latency</h3>
+      <table>
+        <thead><tr><th>Tool</th><th style="text-align: right;">Calls</th><th style="text-align: right;">Avg duration (ms)</th></tr></thead>
+        <tbody id="telemetry-tools-tbody"></tbody>
+      </table>
+    </div>
+    <div class="adv-card">
+      <h3 style="margin-top: 0;">Recent token-usage points</h3>
+      <table>
+        <thead><tr><th>Recorded at</th><th>Model</th><th>Type</th><th style="text-align: right;">Tokens</th><th>Prompt</th></tr></thead>
+        <tbody id="telemetry-recent-tbody"></tbody>
+      </table>
+    </div>
+  </div>
+</div>
+
+<div class="modal-backdrop" id="prompt-journey-modal" role="dialog" aria-modal="true">
+  <div class="modal" role="document">
+    <div class="modal-header">
+      <h2 id="prompt-journey-title">Prompt journey</h2>
+      <button class="modal-close" aria-label="Close" onclick="closeModal('prompt-journey-modal')">&times;</button>
+    </div>
+    <div id="prompt-journey-body"></div>
+  </div>
 </div>
 
 <div id="toast" class="toast"></div>
@@ -2121,7 +2180,87 @@ function switchAdvTab(name) {
 
 // ==================== Advanced drawer loaders ====================
 async function loadAdvanced() {
-  await Promise.all([loadKnowledge(), loadOverview(), loadFacts(), loadEfficacy(), loadConflicts(), loadActivityLog()]);
+  await Promise.all([loadKnowledge(), loadOverview(), loadFacts(), loadEfficacy(), loadConflicts(), loadActivityLog(), loadTelemetry()]);
+}
+
+async function loadTelemetry() {
+  const data = await api('telemetry');
+
+  const status = data.status || {};
+  const statusEl = document.getElementById('telemetry-status');
+  const endpoint = status.endpoint ? esc(status.endpoint) : '<em>not configured</em>';
+  const banner = data.contains_prompt_content
+    ? '<div style="color: #c4863c; margin-top: 4px;">Captured payload contains prompt or body content. Disable with <code>claude-memory otel --no-capture-prompts</code>.</div>'
+    : '';
+  statusEl.innerHTML = `
+    Endpoint: ${endpoint}<br>
+    Metrics: ${status.metric_count || 0} · Events: ${status.event_count || 0} · Traces: ${status.trace_count || 0} (enabled: ${status.traces_enabled ? 'yes' : 'no'})<br>
+    Last metric: ${status.last_metric_at ? esc(status.last_metric_at) : 'never'}
+    ${banner}
+  `;
+
+  const costTbody = document.getElementById('telemetry-cost-tbody');
+  const cost = data.cost_over_time || [];
+  costTbody.innerHTML = cost.length === 0
+    ? `<tr><td colspan="3" style="color: var(--text-faint);">No cost metrics yet. Run <code>claude-memory otel --enable</code> and start a Claude session.</td></tr>`
+    : cost.map(row => `
+      <tr><td>${esc(row.hour)}</td><td style="text-align: right;">${row.requests}</td><td style="text-align: right;">$${row.cost_usd.toFixed(4)}</td></tr>
+    `).join('');
+
+  const tokensTbody = document.getElementById('telemetry-tokens-tbody');
+  const tokens = data.tokens_by_model || [];
+  tokensTbody.innerHTML = tokens.length === 0
+    ? `<tr><td colspan="3" style="color: var(--text-faint);">No token usage yet.</td></tr>`
+    : tokens.map(row => `
+      <tr><td>${esc(row.model)}</td><td>${esc(row.type)}</td><td style="text-align: right;">${row.tokens.toLocaleString()}</td></tr>
+    `).join('');
+
+  const toolsTbody = document.getElementById('telemetry-tools-tbody');
+  const tools = data.top_tools_by_latency || [];
+  toolsTbody.innerHTML = tools.length === 0
+    ? `<tr><td colspan="3" style="color: var(--text-faint);">No tool_result events yet.</td></tr>`
+    : tools.map(row => `
+      <tr><td>${esc(row.tool)}</td><td style="text-align: right;">${row.count}</td><td style="text-align: right;">${row.avg_duration_ms}</td></tr>
+    `).join('');
+
+  const recentTbody = document.getElementById('telemetry-recent-tbody');
+  const recent = data.recent_metrics || [];
+  recentTbody.innerHTML = recent.length === 0
+    ? `<tr><td colspan="5" style="color: var(--text-faint);">No recent token data points.</td></tr>`
+    : recent.map(row => {
+        const promptCell = row.prompt_id
+          ? `<a href="javascript:void(0)" onclick="openPromptJourney('${esc(row.prompt_id)}')">view</a>`
+          : '';
+        return `<tr>
+          <td>${esc(row.recorded_at || '')}</td>
+          <td>${esc(row.model || '')}</td>
+          <td>${esc(row.type || '')}</td>
+          <td style="text-align: right;">${(row.tokens || 0).toLocaleString()}</td>
+          <td>${promptCell}</td>
+        </tr>`;
+      }).join('');
+}
+
+async function openPromptJourney(promptId) {
+  const data = await api('prompt_journey', {prompt_id: promptId});
+  const body = document.getElementById('prompt-journey-body');
+  document.getElementById('prompt-journey-title').textContent = `Prompt journey · ${promptId}`;
+  const events = data.events || [];
+  body.innerHTML = events.length === 0
+    ? `<div style="padding: 12px; color: var(--text-faint);">No events recorded for prompt ${esc(promptId)} yet.</div>`
+    : `<table>
+        <thead><tr><th>Time</th><th>Source</th><th>Event</th><th>Model / Tool</th><th>Duration</th></tr></thead>
+        <tbody>${events.map(ev => `
+          <tr>
+            <td>${esc(ev.occurred_ago || ev.occurred_at || '')}</td>
+            <td><span class="src ${esc(ev.source)}">${esc(ev.source)}</span></td>
+            <td>${esc(ev.name || '')}</td>
+            <td>${esc(ev.model || ev.tool_name || '')}</td>
+            <td>${ev.duration_ms != null ? `${ev.duration_ms} ms` : ''}</td>
+          </tr>`).join('')}
+        </tbody>
+      </table>`;
+  openModal('prompt-journey-modal');
 }
 
 let knowledgeScope = 'all';

data/lib/claude_memory/dashboard/prompt_journey.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Dashboard
+    # Per-prompt waterfall view. Calls Store::PromptJourneyQuery to UNION
+    # otel_events and activity_events on prompt_id, then shapes results
+    # for the frontend (relative timestamps, parsed attributes).
+    class PromptJourney
+      def initialize(manager)
+        @manager = manager
+      end
+
+      def for(prompt_id)
+        @manager.ensure_global! if @manager.respond_to?(:ensure_global!) && !@manager.global_store
+        @manager.ensure_project! if @manager.respond_to?(:ensure_project!) && !@manager.project_store
+        return empty_payload(prompt_id) unless @manager.global_store || @manager.project_store
+
+        rows = ClaudeMemory::Store::PromptJourneyQuery.new(@manager).fetch(prompt_id)
+        {
+          prompt_id: prompt_id,
+          event_count: rows.size,
+          events: rows.map { |row| present(row) }
+        }
+      end
+
+      private
+
+      def empty_payload(prompt_id)
+        {prompt_id: prompt_id, event_count: 0, events: []}
+      end
+
+      def present(row)
+        attrs = OTel::Attributes.from_json(row[:attributes_json])
+        {
+          source: row[:source],
+          name: row[:name],
+          occurred_at: row[:occurred_at],
+          occurred_ago: Core::RelativeTime.format(row[:occurred_at]),
+          session_id: row[:session_id],
+          status: row[:status],
+          duration_ms: row[:duration_ms] || attrs.duration_ms,
+          model: attrs.model,
+          tool_name: attrs.tool_name
+        }.compact
+      end
+    end
+  end
+end

data/lib/claude_memory/dashboard/server.rb

@@ -18,6 +18,7 @@ module ClaudeMemory
       def start
         @server = WEBrick::HTTPServer.new(
           Port: @port,
+          BindAddress: "127.0.0.1",
           Logger: WEBrick::Log.new(File::NULL),
           AccessLog: []
         )
@@ -67,6 +68,91 @@ module ClaudeMemory
         @server.mount_proc("/api/trust") { |_req, res| with_fresh_connections { json_response(res, api.trust) } }
         @server.mount_proc("/api/knowledge") { |req, res| with_fresh_connections { json_response(res, api.knowledge(req.query)) } }
         @server.mount_proc("/api/reuse") { |req, res| with_fresh_connections { json_response(res, api.reuse(req.query)) } }
+        @server.mount_proc("/api/telemetry") { |_req, res| with_fresh_connections { json_response(res, api.telemetry) } }
+        @server.mount_proc("/api/prompt_journey") { |req, res|
+          with_fresh_connections {
+            prompt_id = req.query["prompt_id"].to_s
+            json_response(res, api.prompt_journey(prompt_id))
+          }
+        }
+
+        # OTel writer routes — high-frequency, no with_fresh_connections.
+        # Telemetry exports happen at sub-second cadence; the WAL stale-cache
+        # concern that motivates per-request connection release only affects
+        # readers.
+        @server.mount_proc("/v1/metrics") { |req, res| handle_otel(:metrics, req, res) }
+        @server.mount_proc("/v1/logs") { |req, res| handle_otel(:logs, req, res) }
+        @server.mount_proc("/v1/traces") { |req, res| handle_otel(:traces, req, res) }
+      end
+
+      # OTLP/HTTP/JSON receiver. Rejects non-JSON content with 415; returns
+      # 501 for /v1/traces unless the user opted in via
+      # `claude-memory otel --enable-traces`. On parse/persist failure
+      # returns 400 with the underlying error message — matches OTLP's
+      # tolerant retry semantics so Claude Code's exporter backs off.
+      def handle_otel(kind, req, res)
+        return otel_response(res, 415, "only application/json is accepted") unless json_content?(req)
+        if kind == :traces && !configuration.otel_traces_enabled?
+          return otel_response(res, 501, "traces ingestion disabled — run `claude-memory otel --enable-traces`")
+        end
+
+        payload = parse_json_body(req)
+        return otel_response(res, 400, "request body was not valid JSON") if payload.nil? || payload == {}
+
+        store = ensure_global_store
+        return otel_response(res, 503, "global store unavailable") unless store
+
+        rows = case kind
+        when :metrics then {metrics: ClaudeMemory::OTel::OtlpJsonEnvelope.parse_metrics(payload)}
+        when :logs then {events: ClaudeMemory::OTel::OtlpJsonEnvelope.parse_logs(payload)}
+        when :traces then {traces: ClaudeMemory::OTel::OtlpJsonEnvelope.parse_traces(payload)}
+        end
+
+        result = ClaudeMemory::OTel::Ingestor.new(store).ingest(rows)
+        if result.success?
+          back_tag_activity_events(rows[:events]) if kind == :logs
+          json_response(res, {})
+        else
+          otel_response(res, 400, result.error)
+        end
+      rescue => e
+        otel_response(res, 500, e.message)
+      end
+
+      # After OTel events with prompt.id are persisted, scan project +
+      # global activity_events and stamp prompt_id on matching rows so the
+      # Prompt Journey panel can UNION-join them. Hook events (session_id-
+      # bearing) match exactly; MCP recall/store_extraction rows (NULL
+      # session_id) fall back to time-window proximity. Best-effort —
+      # tagging failures never block the OTLP response.
+      def back_tag_activity_events(events)
+        return unless events && !events.empty?
+        @manager.ensure_project! if @manager.respond_to?(:ensure_project!) && !@manager.project_store
+        ClaudeMemory::OTel::PromptScope.new(@manager).tag(events)
+      rescue Sequel::DatabaseError, Extralite::Error
+        # never block the OTLP response on a tagging failure
+      end
+
+      def json_content?(req)
+        ct = req["content-type"].to_s.downcase
+        ct.start_with?("application/json")
+      end
+
+      def otel_response(res, status, message)
+        res.status = status
+        res["Content-Type"] = "application/json; charset=utf-8"
+        res.body = JSON.generate(error: message)
+      end
+
+      def configuration
+        @configuration ||= ClaudeMemory::Configuration.new
+      end
+
+      def ensure_global_store
+        @manager.ensure_global!
+        @manager.global_store
+      rescue Sequel::DatabaseError, Errno::ENOENT
+        nil
       end
 
       # WAL-mode SQLite caches pages on reader connections; when the MCP

data/lib/claude_memory/dashboard/telemetry.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Dashboard
+    # Cost & Tokens dashboard panel. Aggregates Claude Code's OTel metric
+    # exports — server-side via Sequel datasets so the API returns
+    # final-rendered bins and the JS does no reduce.
+    #
+    # Returns the empty shape ({status:, cost_over_time: [], ...}) when no
+    # store or no rows exist so the dashboard renders before the first
+    # ingest.
+    class Telemetry
+      LOOKBACK_DAYS = 7
+      TOP_TOOLS_LIMIT = 10
+
+      def initialize(manager)
+        @manager = manager
+      end
+
+      def snapshot
+        store = @manager.default_store(prefer: :global)
+        return empty_snapshot(store) unless store&.db&.table_exists?(:otel_metrics)
+
+        cutoff = (Time.now - LOOKBACK_DAYS * 86_400).utc.iso8601
+        metrics = store.otel_metrics.where { recorded_at >= cutoff }
+        events = events_dataset(store, cutoff)
+
+        {
+          status: status_payload(store),
+          cost_over_time: cost_over_time(metrics),
+          tokens_by_model: tokens_by_model(metrics),
+          top_tools_by_latency: top_tools(events),
+          error_rate: error_rate(events),
+          recent_metrics: recent_metrics(metrics),
+          contains_prompt_content: contains_prompt_content?(events)
+        }
+      end
+
+      private
+
+      def empty_snapshot(store)
+        {
+          status: status_payload(store),
+          cost_over_time: [],
+          tokens_by_model: [],
+          top_tools_by_latency: [],
+          error_rate: {total: 0, errors: 0, ratio: 0.0},
+          recent_metrics: [],
+          contains_prompt_content: false
+        }
+      end
+
+      def status_payload(store)
+        OTel::Status.new(store, configuration: ClaudeMemory::Configuration.new).snapshot
+      end
+
+      def cost_over_time(metrics)
+        rows = metrics
+          .where(name: OTel::MetricName::COST_USAGE)
+          .select_group(Sequel.lit("substr(recorded_at, 1, 13)").as(:hour))
+          .select_append { sum(value_float).as(:cost_usd) }
+          .select_append { count(id).as(:requests) }
+          .order(:hour)
+          .all
+        rows.map { |r|
+          {
+            hour: r[:hour],
+            cost_usd: (r[:cost_usd] || 0.0).to_f.round(6),
+            requests: r[:requests].to_i
+          }
+        }
+      end
+
+      # SQLite's json_extract was added in 3.38.0 (2022-02). Sequel runs it
+      # via Sequel.lit so we group by (model, type) at the DB layer instead
+      # of materializing the whole window into Ruby.
+      def tokens_by_model(metrics)
+        model_expr = Sequel.lit("json_extract(attributes_json, '$.model')")
+        type_expr = Sequel.lit("json_extract(attributes_json, '$.type')")
+        rows = metrics
+          .where(name: OTel::MetricName::TOKEN_USAGE)
+          .select_group(model_expr.as(:model), type_expr.as(:type))
+          .select_append { sum(Sequel.function(:coalesce, :value_int, :value_float)).as(:tokens) }
+          .order(Sequel.desc(:tokens))
+          .all
+        rows.map { |r|
+          {model: r[:model] || "unknown", type: r[:type] || "unknown", tokens: r[:tokens].to_i}
+        }
+      end
+
+      def top_tools(events)
+        return [] if events.nil?
+        tool_expr = Sequel.lit("json_extract(attributes_json, '$.tool_name')")
+        duration_expr = Sequel.lit("json_extract(attributes_json, '$.duration_ms')")
+        rows = events
+          .where(event_name: OTel::EventName::TOOL_RESULT)
+          .select_group(tool_expr.as(:tool))
+          .select_append { count(id).as(:count) }
+          .select_append { avg(duration_expr).as(:avg_duration_ms) }
+          .order(Sequel.desc(:avg_duration_ms))
+          .limit(TOP_TOOLS_LIMIT)
+          .all
+        rows.map { |r|
+          {tool: r[:tool] || "unknown", count: r[:count].to_i, avg_duration_ms: r[:avg_duration_ms].to_i}
+        }
+      end
+
+      def error_rate(events)
+        return {total: 0, errors: 0, ratio: 0.0} if events.nil?
+        total = events.where(event_name: OTel::EventName::API_PAIR).count
+        errors = events.where(event_name: OTel::EventName::API_ERROR).count
+        ratio = total.zero? ? 0.0 : (errors.to_f / total).round(4)
+        {total: total, errors: errors, ratio: ratio}
+      end
+
+      def recent_metrics(metrics)
+        rows = metrics
+          .where(name: OTel::MetricName::TOKEN_USAGE)
+          .order(Sequel.desc(:recorded_at))
+          .limit(100)
+          .all
+        rows.map { |row|
+          attrs = OTel::Attributes.from_json(row[:attributes_json])
+          {
+            recorded_at: row[:recorded_at],
+            model: attrs.model,
+            type: attrs.token_type,
+            tokens: OTel::Attributes.token_count(row),
+            session_id: attrs.session_id,
+            prompt_id: attrs.prompt_id
+          }.compact
+        }
+      end
+
+      def events_dataset(store, cutoff)
+        return nil unless store.db.table_exists?(:otel_events)
+        store.otel_events.where { occurred_at >= cutoff }
+      end
+
+      # SQL pre-filter via LIKE on each prompt-content key, short-circuited
+      # by .any?. JSON encodes object keys as `"key":` (compact), so the
+      # patterns can't false-match longer keys (e.g. "prompt_length").
+      def contains_prompt_content?(events)
+        return false if events.nil?
+        clauses = OTel::Attributes::PROMPT_CONTENT_KEYS.map { |key|
+          Sequel.lit("attributes_json LIKE ?", %("#{key}":))
+        }
+        events
+          .where(event_name: OTel::EventName::PROMPT_BODY_FAMILY)
+          .where(Sequel.|(*clauses))
+          .limit(1)
+          .any?
+      end
+    end
+  end
+end

data/lib/claude_memory/dashboard/trust.rb

@@ -2,20 +2,37 @@
 
 module ClaudeMemory
   module Dashboard
-    # Sidebar data for the feed-first dashboard. Three things:
+    # Sidebar data for the feed-first dashboard. Six surfaces, each
+    # answering a different "is memory helping/costing/clean?" question:
     #
-    # 1. Moments this week + week-over-week delta — the headline value number.
-    #    A moment is any meaningful activity event (recall hit, extraction,
-    #    context injection, conflict detected). Ingest-only events don't count
-    #    because they're not directly user-visible value.
+    # 1. Moments this week + week-over-week delta — the headline value
+    #    number. A moment is any meaningful activity event (recall hit,
+    #    extraction, context injection, conflict detected). Ingest-only
+    #    events don't count because they're not directly user-visible value.
     #
     # 2. "What memory knows about you" — up to 5 global facts rendered as
-    #    plain English. This is the trust panel's most compelling surface:
-    #    users can sanity-check what's being injected into their sessions.
+    #    plain English. The trust panel's most compelling surface: users
+    #    can sanity-check what's being injected into their sessions.
     #
-    # 3. Needs review — open conflicts plus facts that have gone stale
-    #    (active but never recalled in the last N days). A single actionable
-    #    count; the feed surfaces the individual items.
+    # 3. Needs review — open conflicts plus stale facts (active but never
+    #    recalled in the last N days) plus empty recalls (queries that
+    #    returned nothing). A single actionable count; the feed surfaces
+    #    the individual items.
+    #
+    # 4. Utilization (30d) — of facts extracted in the last 30 days, how
+    #    many has Claude actually surfaced via recall or context injection.
+    #    Low ratios are a signal too: memory accumulating knowledge that
+    #    Claude isn't reaching for.
+    #
+    # 5. Token budget (30d, 0.11.0+) — p50/p95/avg `context_tokens`
+    #    injected per SessionStart. Answers "what does memory cost per
+    #    session?" via numbers a skeptical user can read.
+    #
+    # 6. Quality score (live + historical, 0.11.0+) — hallucination-rate
+    #    proxy: 100 - (suspect_pct + bare_pct), clamped 0..100. Live is
+    #    over the last UTILIZATION_DAYS; historical mirrors the same
+    #    calculation across all active facts as a supplementary baseline.
+    #    See `quality_review.md` 2026-04-30 note for why the split exists.
     class Trust
       WEEK_SECONDS = 7 * 86_400
       UTILIZATION_DAYS = 30
@@ -31,8 +48,160 @@ module ClaudeMemory
           fingerprint: fingerprint,
           needs_review: needs_review,
           utilization: utilization,
-          feedback: feedback_summary
+          feedback: feedback_summary,
+          token_budget: token_budget,
+          quality_score: quality_score
+        }
+      end
+
+      # The trust panel's hallucination-rate proxy. Counts two pollution
+      # signals:
+      #
+      #   - suspect: facts that ReferenceMaterialDetector retagged from
+      #     `convention` to `reference` predicate (descriptions of external
+      #     projects mislabeled as user conventions).
+      #   - bare_conclusion: `decision` / `convention` facts whose object
+      #     skipped the prompt-mandated reason clause and so are dead
+      #     weight once the originating context is gone.
+      #
+      # Reports two windows so users can distinguish historical noise from
+      # live extraction quality (per `quality_review.md` 2026-04-30
+      # investigation): the headline `score` is computed over facts
+      # created within the last UTILIZATION_DAYS — that's the actionable
+      # signal. The `historical` block reports the same counts over all
+      # active facts so legacy data is visible without dominating.
+      #
+      # Score = 100 - (suspect_pct + bare_pct), clamped 0..100. Lower is
+      # worse. Returns 100 (perfect) when there are no facts in the
+      # window so a quiet week isn't penalized.
+      def quality_score
+        cutoff = (Time.now.utc - UTILIZATION_DAYS * 86_400).iso8601
+        live = compute_quality(cutoff: cutoff)
+        historical = compute_quality(cutoff: nil)
+
+        live.merge(
+          window_days: UTILIZATION_DAYS,
+          historical: historical
+        )
+      rescue Sequel::DatabaseError => e
+        ClaudeMemory.logger.debug("Trust#quality_score failed: #{e.message}")
+        quality_score_zero
+      end
+      public :quality_score
+
+      def quality_score_zero
+        {
+          total_active: 0,
+          suspect_count: 0,
+          bare_conclusion_count: 0,
+          suspect_pct: 0.0,
+          bare_pct: 0.0,
+          score: 100,
+          window_days: UTILIZATION_DAYS,
+          historical: {
+            total_active: 0,
+            suspect_count: 0,
+            bare_conclusion_count: 0,
+            suspect_pct: 0.0,
+            bare_pct: 0.0,
+            score: 100
+          }
+        }
+      end
+
+      def compute_quality(cutoff:)
+        breakdown = aggregate_quality_counts(cutoff: cutoff)
+        total = breakdown[:total_active]
+
+        return zero_breakdown if total.zero?
+
+        suspect_pct = (breakdown[:suspect_count] * 100.0 / total).round(1)
+        bare_pct = (breakdown[:bare_conclusion_count] * 100.0 / total).round(1)
+        score = (100 - (suspect_pct + bare_pct)).clamp(0, 100).round
+
+        breakdown.merge(
+          suspect_pct: suspect_pct,
+          bare_pct: bare_pct,
+          score: score
+        )
+      end
+
+      def zero_breakdown
+        {total_active: 0, suspect_count: 0, bare_conclusion_count: 0,
+         suspect_pct: 0.0, bare_pct: 0.0, score: 100}
+      end
+
+      def aggregate_quality_counts(cutoff: nil)
+        detector = Distill::BareConclusionDetector.new
+        suspect = 0
+        bare = 0
+        total = 0
+
+        %w[project global].each do |scope|
+          store = @manager.store_if_exists(scope)
+          next unless store
+          dataset = store.facts.where(status: "active")
+          dataset = dataset.where { created_at >= cutoff } if cutoff
+          total += dataset.count
+          suspect += dataset.where(predicate: "reference").count
+          dataset.where(predicate: %w[decision convention])
+            .select(:predicate, :object_literal)
+            .all
+            .each { |row| bare += 1 if detector.bare_conclusion?(row) }
+        end
+
+        {total_active: total, suspect_count: suspect, bare_conclusion_count: bare}
+      end
+
+      # What does memory cost? Aggregates `context_tokens` from successful
+      # `hook_context` activity events over the last UTILIZATION_DAYS so a
+      # skeptical user can see the per-session token cost in p50/p95.
+      #
+      # Shape: {p50:, p95:, avg:, sample_size:, window_days:}
+      # All ints. Returns zeros when there are no events in the window.
+      def token_budget
+        store = @manager.default_store(prefer: :project)
+        return token_budget_zero unless store
+
+        cutoff = (Time.now.utc - UTILIZATION_DAYS * 86_400).iso8601
+        rows = store.activity_events
+          .where(event_type: "hook_context", status: "success")
+          .where { occurred_at >= cutoff }
+          .select(:detail_json)
+          .all
+
+        tokens = rows.filter_map do |row|
+          details = row[:detail_json] ? JSON.parse(row[:detail_json]) : {}
+          value = details["context_tokens"]
+          value if value.is_a?(Integer) && value > 0
+        end
+
+        return token_budget_zero if tokens.empty?
+
+        sorted = tokens.sort
+        {
+          p50: percentile(sorted, 0.50),
+          p95: percentile(sorted, 0.95),
+          avg: (sorted.sum.to_f / sorted.size).round,
+          sample_size: sorted.size,
+          window_days: UTILIZATION_DAYS
         }
+      rescue Sequel::DatabaseError, JSON::ParserError => e
+        ClaudeMemory.logger.debug("Trust#token_budget failed: #{e.message}")
+        token_budget_zero
+      end
+      public :token_budget
+
+      def token_budget_zero
+        {p50: 0, p95: 0, avg: 0, sample_size: 0, window_days: UTILIZATION_DAYS}
+      end
+
+      def percentile(sorted, pct)
+        return 0 if sorted.empty?
+        idx = (sorted.size * pct).ceil - 1
+        idx = 0 if idx < 0
+        idx = sorted.size - 1 if idx >= sorted.size
+        sorted[idx]
       end
 
       private