claude_memory 0.9.1 → 0.11.0

data/lib/claude_memory/commands/digest_command.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module ClaudeMemory
+  module Commands
+    # Weekly digest — a markdown summary of what memory did over the last N days.
+    # Sections (in order): Activity, Context cost, Quality, New knowledge,
+    # Utilization, Conflicts, Feedback. The Context cost and Quality
+    # sections (added 0.11.0) read from `Dashboard::Trust#token_budget` and
+    # `#quality_score` so users see the cost/pollution side-by-side with
+    # the value side without needing to visit the dashboard.
+    #
+    # The data it aggregates all already exists (activity_events, facts,
+    # conflicts, moment_feedback); this command only shapes it into a report.
+    class DigestCommand < BaseCommand
+      def call(args)
+        opts = parse_options(args, {since_days: 7, output: nil}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory digest [options]"
+            parser.on("--since DAYS", Integer, "Coverage window in days (default: 7)") { |v| o[:since_days] = v }
+            parser.on("--output FILE", "Write to file instead of stdout") { |v| o[:output] = v }
+          end
+        end
+        return 1 if opts.nil?
+        return failure("--since must be positive") if opts[:since_days] <= 0
+
+        manager = Store::StoreManager.new
+        report = render_report(manager, opts[:since_days])
+        manager.close
+
+        if opts[:output]
+          File.write(opts[:output], report)
+          stderr.puts "Wrote digest to #{opts[:output]}"
+        else
+          stdout.puts report
+        end
+
+        0
+      end
+
+      private
+
+      def render_report(manager, days)
+        cutoff = (Time.now.utc - days * 86_400).iso8601
+        lines = []
+        lines << "# ClaudeMemory Digest"
+        lines << ""
+        lines << "_Coverage: last #{days} day#{"s" unless days == 1} (since #{cutoff})_"
+        lines << ""
+        lines << activity_section(manager, cutoff)
+        lines << ""
+        lines << context_cost_section(manager)
+        lines << ""
+        lines << quality_section(manager, cutoff)
+        lines << ""
+        lines << knowledge_section(manager, cutoff)
+        lines << ""
+        lines << utilization_section(manager)
+        lines << ""
+        lines << conflicts_section(manager)
+        lines << ""
+        lines << feedback_section(manager, cutoff)
+        lines.join("\n") + "\n"
+      end
+
+      def activity_section(manager, cutoff)
+        store = manager.default_store(prefer: :project)
+        return "## Activity\n\n_No project database._" unless store
+
+        by_kind = store.activity_events
+          .where { occurred_at >= cutoff }
+          .group_and_count(:event_type)
+          .all
+          .to_h { |r| [r[:event_type], r[:count]] }
+
+        total = by_kind.values.sum
+        out = ["## Activity", ""]
+        out << "**Moments recorded:** #{total}"
+        out << ""
+        if total.zero?
+          out << "_No activity in this window._"
+        else
+          %w[recall store_extraction hook_context hook_ingest hook_sweep].each do |event_type|
+            count = by_kind[event_type] || 0
+            next if count.zero?
+            out << "- #{humanize_event(event_type)}: #{count}"
+          end
+        end
+        out.join("\n")
+      rescue Sequel::DatabaseError => e
+        "## Activity\n\n_Unavailable: #{e.message}_"
+      end
+
+      def humanize_event(event_type)
+        case event_type
+        when "recall" then "Recalls"
+        when "store_extraction" then "Facts extracted"
+        when "hook_context" then "Context injections"
+        when "hook_ingest" then "Transcripts ingested"
+        when "hook_sweep" then "Maintenance sweeps"
+        else event_type
+        end
+      end
+
+      def knowledge_section(manager, cutoff)
+        out = ["## New knowledge", ""]
+        counts = {}
+        %w[project global].each do |scope|
+          store = manager.store_if_exists(scope)
+          next unless store
+          store.facts
+            .where(status: "active")
+            .where { created_at >= cutoff }
+            .group_and_count(:predicate)
+            .all
+            .each { |r| counts[r[:predicate]] = (counts[r[:predicate]] || 0) + r[:count] }
+        end
+
+        if counts.empty?
+          out << "_No new facts in this window._"
+        else
+          total = counts.values.sum
+          out << "**New active facts:** #{total}"
+          out << ""
+          counts.sort_by { |_, c| -c }.each { |predicate, count| out << "- #{predicate}: #{count}" }
+        end
+        out.join("\n")
+      rescue Sequel::DatabaseError => e
+        "## New knowledge\n\n_Unavailable: #{e.message}_"
+      end
+
+      # The token cost of every SessionStart context injection, measured over
+      # the last 30 days (Trust panel's window — intentionally wider than the
+      # digest's coverage window so percentiles stay statistically meaningful
+      # on quiet weeks). Reports zero state explicitly so users know whether a
+      # missing number means "no injections" vs. "telemetry didn't fire".
+      def context_cost_section(manager)
+        tb = Dashboard::Trust.new(manager).token_budget
+        out = ["## Context cost", ""]
+        if tb[:sample_size].zero?
+          out << "_No context injections in the last #{tb[:window_days]} days._"
+        else
+          out << "**Per-session injected tokens (last #{tb[:window_days]}d, n=#{tb[:sample_size]}):**"
+          out << "- p50: #{tb[:p50]} tokens"
+          out << "- p95: #{tb[:p95]} tokens"
+          out << "- avg: #{tb[:avg]} tokens"
+        end
+        out.join("\n")
+      rescue Sequel::DatabaseError => e
+        "## Context cost\n\n_Unavailable: #{e.message}_"
+      end
+
+      # Hallucination-rate proxy. Reports two numbers per the
+      # `quality_review.md` 2026-04-30 investigation:
+      #
+      #   - Live (last `window_days`, headline) — actionable signal of
+      #     ongoing extraction quality.
+      #   - Historical (all active facts, supplementary) — visible so
+      #     legacy noise isn't hidden, but the headline is the live one.
+      #
+      # The split exists because the unwindowed metric mixed pre-prompt-
+      # commit bare conclusions with live data; users read the combined
+      # number as "ongoing quality" and that's misleading.
+      def quality_section(manager, cutoff)
+        out = ["## Quality", ""]
+        qs = Dashboard::Trust.new(manager).quality_score
+
+        if qs[:total_active].zero?
+          if qs[:historical][:total_active].zero?
+            out << "_No active facts to score yet._"
+          else
+            out << "_No facts extracted in the last #{qs[:window_days]} days._"
+            out << "- Historical (all active): score #{qs[:historical][:score]}/100, " \
+              "#{qs[:historical][:total_active]} facts, " \
+              "#{qs[:historical][:bare_conclusion_count]} bare, " \
+              "#{qs[:historical][:suspect_count]} suspect"
+          end
+        else
+          out << "**Live score (last #{qs[:window_days]}d):** #{qs[:score]}/100 _(higher is cleaner)_"
+          out << "- Suspect (reference material): #{qs[:suspect_count]} (#{qs[:suspect_pct]}%)"
+          out << "- Bare conclusions (decision/convention without reason): #{qs[:bare_conclusion_count]} (#{qs[:bare_pct]}%)"
+          if qs[:historical][:total_active] > qs[:total_active]
+            out << ""
+            out << "_Historical (all active): score #{qs[:historical][:score]}/100, " \
+              "#{qs[:historical][:total_active]} facts, " \
+              "#{qs[:historical][:bare_conclusion_count]} bare, " \
+              "#{qs[:historical][:suspect_count]} suspect_"
+          end
+        end
+
+        rate = rejection_rate_in_window(manager, cutoff)
+        out << ""
+        out << "**Rejection rate (in window):** #{rate[:rejected]} of #{rate[:created]} extracted facts rejected (#{rate[:pct]}%)"
+
+        out.join("\n")
+      rescue Sequel::DatabaseError => e
+        "## Quality\n\n_Unavailable: #{e.message}_"
+      end
+
+      # How many facts created in the digest window have since been
+      # rejected? Counts across both stores.
+      def rejection_rate_in_window(manager, cutoff)
+        created = 0
+        rejected = 0
+
+        %w[project global].each do |scope|
+          store = manager.store_if_exists(scope)
+          next unless store
+          dataset = store.facts.where { created_at >= cutoff }
+          created += dataset.count
+          rejected += dataset.where(status: "rejected").count
+        end
+
+        pct = created.zero? ? 0.0 : (rejected * 100.0 / created).round(1)
+        {created: created, rejected: rejected, pct: pct}
+      end
+
+      def utilization_section(manager)
+        util = Dashboard::Trust.new(manager).utilization
+        pct = util[:ratio_pct]
+        <<~SECTION.strip
+          ## Utilization
+
+          **Ratio (last #{util[:window_days]}d):** #{pct}%
+          - Extracted: #{util[:extracted]}
+          - Used (of those extracted): #{util[:used_from_extracted]}
+          - Total fact uses across recalls + injections: #{util[:used]}
+        SECTION
+      end
+
+      def conflicts_section(manager)
+        counts = Dashboard::Conflicts.new(manager).distinct_open_counts
+        total = counts[:total]
+        out = ["## Conflicts", ""]
+        if total.zero?
+          out << "_No open conflicts._"
+        else
+          out << "**Open contradictions:** #{total} distinct"
+          out << "- Project: #{counts[:project]}"
+          out << "- Global: #{counts[:global]}"
+        end
+        out.join("\n")
+      rescue Sequel::DatabaseError => e
+        "## Conflicts\n\n_Unavailable: #{e.message}_"
+      end
+
+      def feedback_section(manager, cutoff)
+        store = manager.default_store(prefer: :project)
+        return "## Feedback\n\n_No project database._" unless store
+
+        rows = store.moment_feedback.where { recorded_at >= cutoff }.all
+        up = rows.count { |r| r[:verdict] == "up" }
+        down = rows.count { |r| r[:verdict] == "down" }
+        total = up + down
+
+        out = ["## Feedback", ""]
+        if total.zero?
+          out << "_No thumbs in this window._"
+        else
+          ratio = ((up.to_f / total) * 100).round
+          out << "**Moments rated:** #{total}"
+          out << "- 👍 Up: #{up}"
+          out << "- 👎 Down: #{down}"
+          out << "- Positive ratio: #{ratio}%"
+        end
+        out.join("\n")
+      rescue Sequel::DatabaseError => e
+        "## Feedback\n\n_Unavailable: #{e.message}_"
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/hook_command.rb

@@ -19,9 +19,9 @@ module ClaudeMemory
           return Hook::ExitCodes::ERROR
         end
 
-        unless %w[ingest sweep publish context].include?(subcommand)
+        unless %w[ingest sweep publish context nudge].include?(subcommand)
           stderr.puts "Unknown hook command: #{subcommand}"
-          stderr.puts "Available: ingest, sweep, publish, context"
+          stderr.puts "Available: ingest, sweep, publish, context, nudge"
           return Hook::ExitCodes::ERROR
         end
 
@@ -63,6 +63,8 @@ module ClaudeMemory
           hook_publish(handler, payload)
         when "context"
           hook_context(payload, opts[:db])
+        when "nudge"
+          hook_nudge(payload, opts[:db])
         end
 
         store.close
@@ -169,17 +171,42 @@ module ClaudeMemory
         Hook::ExitCodes::SUCCESS
       end
 
+      def hook_nudge(payload, db_path)
+        # Nudge needs to count past nudge events across both stores,
+        # so prefer the manager-aware path. db_path overrides only
+        # the project store (useful for tests).
+        project_path = payload["project_path"] || payload["cwd"]
+        manager = ClaudeMemory::Store::StoreManager.new(
+          project_db_path: db_path, project_path: project_path
+        )
+        manager.ensure_both!
+        store = manager.project_store || manager.global_store
+
+        handler = ClaudeMemory::Hook::Handler.new(store, manager: manager)
+        result = handler.nudge(payload)
+
+        stdout.puts result[:message] if result[:status] == :emitted
+
+        manager.close
+        Hook::ExitCodes::SUCCESS
+      rescue => e
+        classify_error(e)
+      end
+
       def hook_context(payload, db_path)
         project_path = payload["project_path"] || payload["cwd"]
         source = payload["source"]
+        session_id = payload["session_id"]
         manager = ClaudeMemory::Store::StoreManager.new(
           project_db_path: db_path,
           project_path: project_path
         )
         manager.ensure_both!
 
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         injector = ClaudeMemory::Hook::ContextInjector.new(manager, source: source)
         context_text = injector.generate_context
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round
 
         if context_text
           response = {
@@ -191,12 +218,44 @@ module ClaudeMemory
           stdout.puts JSON.generate(response)
         end
 
+        record_context_activity(manager, context_text, injector,
+          session_id: session_id, source: source, duration_ms: duration_ms)
+
         manager.close
         Hook::ExitCodes::SUCCESS
       rescue => e
         classify_error(e)
       end
 
+      CONTEXT_PREVIEW_BYTES = 400
+
+      def record_context_activity(manager, context_text, injector, session_id:, source:, duration_ms:)
+        store = manager.project_store || manager.global_store
+        return unless store
+
+        by_scope = injector.emitted_facts_by_scope.transform_values { |ids| ids.first(10) }
+        details = {
+          source: source,
+          context_length: context_text&.length,
+          context_tokens: ClaudeMemory::Core::TokenEstimator.estimate(context_text),
+          preview: context_text&.byteslice(0, CONTEXT_PREVIEW_BYTES),
+          truncated: context_text ? context_text.bytesize > CONTEXT_PREVIEW_BYTES : false,
+          top_fact_ids: injector.emitted_fact_ids.first(10),
+          top_facts_by_scope: (by_scope if by_scope.any?),
+          top_subjects: injector.emitted_subjects.uniq.first(10),
+          fact_count: injector.emitted_fact_ids.size
+        }.compact
+
+        ClaudeMemory::ActivityLog.record(store,
+          event_type: "hook_context",
+          status: context_text ? "success" : "skipped",
+          session_id: session_id,
+          duration_ms: duration_ms,
+          details: details)
+      rescue => e
+        ClaudeMemory.logger.debug("record_context_activity failed: #{e.message}")
+      end
+
       def classify_error(error)
         exit_code = Hook::ErrorClassifier.exit_code_for(error)
 

data/lib/claude_memory/commands/initializers/hooks_configurator.rb

@@ -19,8 +19,9 @@ module ClaudeMemory
           db_path = ClaudeMemory.project_db_path
           ingest_cmd = "claude-memory hook ingest --db #{db_path}"
           sweep_cmd = "claude-memory hook sweep --db #{db_path}"
+          nudge_cmd = "claude-memory hook nudge --db #{db_path}"
 
-          hooks_config = build_hooks_config(ingest_cmd, sweep_cmd)
+          hooks_config = build_hooks_config(ingest_cmd, sweep_cmd, nudge_cmd)
 
           existing = load_json_file(settings_path)
           existing["hooks"] ||= {}
@@ -37,8 +38,9 @@ module ClaudeMemory
           db_path = ClaudeMemory.global_db_path
           ingest_cmd = "claude-memory hook ingest --db #{db_path}"
           sweep_cmd = "claude-memory hook sweep --db #{db_path}"
+          nudge_cmd = "claude-memory hook nudge --db #{db_path}"
 
-          hooks_config = build_hooks_config(ingest_cmd, sweep_cmd)
+          hooks_config = build_hooks_config(ingest_cmd, sweep_cmd, nudge_cmd)
 
           existing = load_json_file(settings_path)
           existing["hooks"] ||= {}
@@ -96,7 +98,7 @@ module ClaudeMemory
 
         private
 
-        def build_hooks_config(ingest_cmd, sweep_cmd)
+        def build_hooks_config(ingest_cmd, sweep_cmd, nudge_cmd = "claude-memory hook nudge")
           context_cmd = "claude-memory hook context"
 
           {
@@ -132,7 +134,8 @@ module ClaudeMemory
                   {"type" => "command", "command" => ingest_cmd, "timeout" => 30,
                    "statusMessage" => "Saving memory..."},
                   {"type" => "command", "command" => sweep_cmd, "timeout" => 30,
-                   "statusMessage" => "Sweeping memory..."}
+                   "statusMessage" => "Sweeping memory..."},
+                  {"type" => "command", "command" => nudge_cmd, "timeout" => 5}
                 ]
               }],
               "TaskCompleted" => [{

data/lib/claude_memory/commands/reclassify_references_command.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module ClaudeMemory
+  module Commands
+    # One-time cleanup for historical convention facts that are actually
+    # descriptions of external projects (LOC counts, star counts, author
+    # attributions, "X is a plugin…" templates). The Distill::ReferenceMaterialDetector
+    # now guards new writes in ManagementHandlers#store_extraction; this
+    # command walks existing rows and retags them to predicate=reference.
+    class ReclassifyReferencesCommand < BaseCommand
+      def call(args)
+        opts = parse_options(args, {scope: "project", dry_run: false}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory reclassify-references [options]"
+            parser.on("--scope SCOPE", %w[project global], "Database scope (default: project)") { |v| o[:scope] = v }
+            parser.on("--dry-run", "Show what would be reclassified without writing") { o[:dry_run] = true }
+          end
+        end
+        return 1 if opts.nil?
+
+        manager = ClaudeMemory::Store::StoreManager.new
+        store = manager.store_for_scope(opts[:scope])
+
+        begin
+          result = Sweep::Maintenance.new(store).reclassify_references(dry_run: opts[:dry_run])
+        ensure
+          manager.close
+        end
+
+        print_result(opts, result)
+        0
+      end
+
+      private
+
+      def print_result(opts, result)
+        mode = opts[:dry_run] ? "DRY RUN" : "RECLASSIFY"
+        stdout.puts "#{mode}: scope=#{opts[:scope]}"
+        stdout.puts "=" * 50
+        stdout.puts "Active conventions inspected: #{result[:inspected]}"
+        stdout.puts "Reclassified as reference:    #{result[:reclassified]}"
+
+        return if result[:decisions].empty?
+
+        stdout.puts
+        stdout.puts "Decisions:"
+        result[:decisions].each do |d|
+          preview = d[:object].to_s[0, 100]
+          stdout.puts "  fact ##{d[:fact_id]}  #{preview}#{"…" if d[:object].to_s.length > 100}"
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/registry.rb

@@ -37,7 +37,13 @@ module ClaudeMemory
         "completion" => {class: CompletionCommand, description: "Generate shell completions"},
         "embeddings" => {class: EmbeddingsCommand, description: "Inspect embedding backend"},
         "reject" => {class: RejectCommand, description: "Mark a fact as rejected"},
-        "restore" => {class: RestoreCommand, description: "Restore superseded facts from obsolete single-value classification"}
+        "restore" => {class: RestoreCommand, description: "Restore superseded facts from obsolete single-value classification"},
+        "dedupe-conflicts" => {class: DedupeConflictsCommand, description: "Deduplicate historical open conflict rows that describe the same pair"},
+        "reclassify-references" => {class: ReclassifyReferencesCommand, description: "Retag existing convention facts that match reference-material heuristics"},
+        "census" => {class: CensusCommand, description: "Aggregate predicate usage across project databases"},
+        "dashboard" => {class: DashboardCommand, description: "Open debugging dashboard"},
+        "digest" => {class: DigestCommand, description: "Render a weekly markdown digest of memory activity"},
+        "show" => {class: ShowCommand, description: "Print what memory would inject at the next SessionStart"}
       }.freeze
 
       # Find a command class by name

data/lib/claude_memory/commands/show_command.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module ClaudeMemory
+  module Commands
+    # Prints what memory would inject on the next SessionStart.
+    #
+    # The trust answer to "is this still worth it?" requires
+    # inspectability: a user who can't see what memory will inject can't
+    # develop confidence in it. The CLAUDE.md alternative is `cat
+    # CLAUDE.md` — instant, plain English, no tooling. This command is
+    # the same one-line inspect surface for the curated facts the
+    # injector picks each session.
+    #
+    # Runs the exact `Hook::ContextInjector` path real sessions use, so
+    # what you see here is what Claude actually receives — not a
+    # rebuilt approximation that could drift.
+    #
+    # The default suppresses the "Pending Knowledge Extraction" dump
+    # (which contains raw transcript JSON intended for LLM distillation)
+    # so the output stays human-readable. Pass `--pending` to see the
+    # full fresh-session payload, including those raw items.
+    class ShowCommand < BaseCommand
+      VALID_SOURCES = %w[startup resume clear].freeze
+
+      # Any string outside FRESH_SESSION_SOURCES skips the pending-knowledge
+      # block. "preview" reads naturally in any debug log this surfaces in.
+      NON_FRESH_SOURCE = "preview"
+
+      def call(args)
+        opts = parse_options(args, {source: nil, pending: false}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory show [--source SOURCE] [--pending]"
+            parser.on("--source SOURCE", VALID_SOURCES,
+              "Simulate fresh-session source (#{VALID_SOURCES.join(", ")}). " \
+              "Forces inclusion of pending-knowledge and auto-memory-mirror " \
+              "sections regardless of --pending.") { |v| o[:source] = v }
+            parser.on("--pending",
+              "Include the pending-knowledge dump (raw transcript JSON " \
+              "for LLM distillation). Default suppresses it for readability.") { o[:pending] = true }
+          end
+        end
+        return 1 if opts.nil?
+
+        effective_source = opts[:source] || (opts[:pending] ? nil : NON_FRESH_SOURCE)
+
+        manager = Store::StoreManager.new
+        manager.ensure_both!
+        injector = Hook::ContextInjector.new(manager, source: effective_source)
+        context = injector.generate_context
+
+        print_header(opts[:source])
+        stdout.puts ""
+
+        if context.nil? || context.strip.empty?
+          stdout.puts "_Memory has no facts to inject yet._"
+          stdout.puts ""
+          stdout.puts "Run a few Claude Code sessions in this project, or use"
+          stdout.puts "`memory.store_extraction` from a session to seed facts."
+        else
+          stdout.puts context
+          stdout.puts ""
+          print_footer(injector, context)
+        end
+
+        manager.close
+        0
+      rescue Sequel::DatabaseError => e
+        failure("Database error: #{e.message}")
+      end
+
+      private
+
+      def print_header(source)
+        label = source ? " (source=#{source})" : ""
+        stdout.puts "## Memory snapshot — would be injected at next SessionStart#{label}"
+      end
+
+      def print_footer(injector, context)
+        tokens = Core::TokenEstimator.estimate(context)
+        fact_count = injector.emitted_fact_ids.size
+        stdout.puts "---"
+        stdout.puts "#{fact_count} fact#{"s" unless fact_count == 1} • " \
+          "~#{tokens} token#{"s" unless tokens == 1} • " \
+          "#{context.length} chars"
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/skills/distill-transcripts.md

@@ -35,12 +35,23 @@ For each content item, carefully read the raw_text and extract:
   architecture, uses_framework, uses_language, uses_database,
   deployment_platform, auth_method). Other snake_case predicates are
   accepted but fall through to the default multi-value policy.
-- object: The value
+- object: The value. For **decision** and **convention** predicates, the object
+  MUST embed the reason — append a compact "— because ..." / "so that ..." /
+  "to avoid ..." clause, or include the trigger ("caused by X", "breaks when Y").
+  Bare conclusions without rationale are dead weight once they become stale:
+  a fact with a reason is recoverable, a fact without one is not. Architecture
+  facts should note the design *trade-off* if non-obvious.
 - confidence: 0.0-1.0
 - quote: Source excerpt (max 200 chars)
 - strength: "stated" (explicitly said) or "inferred" (implied)
 - scope_hint: "project" (this project only) or "global" (all projects)
 
+Examples of the reasoning requirement:
+- ❌ Bare: "Configuration class has instance methods only"
+- ✅ With why: "Configuration class has instance methods only — stub with instance_double + allow(Configuration).to receive(:new) because class-level stubbing breaks isolation"
+- ❌ Bare: "MCP tools return dual content + structuredContent"
+- ✅ With why: "MCP tools return dual content + structuredContent so human-readable summaries and machine-parseable JSON ship in the same response; compact mode omits receipts for ~60% smaller payloads"
+
 **Decisions** — Choices made:
 - title: Short summary (max 100 chars)
 - summary: Full description
@@ -100,3 +111,4 @@ Return a summary:
 - Prefer "stated" strength over "inferred" unless clearly implied
 - Do NOT fabricate facts — only extract what's actually in the text
 - If text is mostly code/tool output with no conversational knowledge, mark as distilled with 0 facts
+- Prefer one fact-with-reason over two facts-without. Length cost is worth it — stale facts with reasoning are recoverable, stale facts without are dead weight