pwn 0.5.643 → 0.5.650

data/lib/pwn/ai/agent/extrospection.rb

@@ -1722,14 +1722,24 @@ module PWN
           c = opts[:claim].to_s
           return :doc     if opts[:url] || c =~ URI::DEFAULT_PARSER.make_regexp(%w[http https])
           return :cve     if c =~ /CVE-\d{4}-\d{4,}/i
-          return :version if c =~ /\bv?\d+\.\d+(?:\.\d+)?\b/
+          # P26 — full semver (x.y.z) OR "latest X is [v]N.N" product claims.
+          # Bare two-part floats alone stay :generic (metrics like "cap 0.2").
+          return :version if c =~ /\b[A-Za-z][\w.+-]{2,}\s+v?\d+\.\d+\.\d+\b/
+          return :version if c =~ /\blatest\b.+\bis\b\s+v?\d+\.\d+/i
 
           :generic
         end
 
         private_class_method def self.commit_verdict(opts = {})
-          claim = opts[:claim]
+          claim = opts[:claim].to_s
           ev    = Array(opts[:evidence]).first
+          # P26 — never pollute learning.jsonl with :unknown on metric crumbs
+          # or sub-8-char blobs; those are not human-reviewable world claims.
+          junk_unknown = opts[:verdict].to_s == 'unknown' && (
+            claim.length < 12 ||
+            claim.match?(/\A(?:cap|share|proxy|judge|success|only|now|clears|gap|score|rate|mean|brier|overconf|distrust|trajectory_fraction|handler|orm|prm|delta|limit|window|pct|percent|ms|iter|budget|conf|confidence|ruby|python|linux|kernel|host|cwd|e\.g)\b/i) ||
+            (claim.match?(/\d+\.\d+/) && !claim.match?(/CVE-|\d+\.\d+\.\d+/i))
+          )
           case opts[:verdict]
           when :refuted
             Mistakes.record(tool: 'assumption', error: "REFUTED (extro_verify #{opts[:kind]}, conf=#{opts[:confidence].round(2)}): #{claim}", args: ev&.dig(:final_url), source: :model) if defined?(Mistakes)
@@ -1739,8 +1749,12 @@ module PWN
             observe(source: 'extro_verify', category: :intel, target: ev&.dig(:final_url), data: claim, tags: %w[verify confirmed], ttl: 30 * 24 * 3600)
             :extro_observe
           else
-            Learning.note_outcome(task: "extro_verify: #{claim[0, 120]}", success: false, details: 'verdict :unknown - needs human review', tags: %w[needs_human extro_verify]) if defined?(Learning) && Learning.respond_to?(:note_outcome)
-            :learning_note
+            if junk_unknown
+              :skipped_junk
+            else
+              Learning.note_outcome(task: "extro_verify: #{claim[0, 120]}", success: false, details: 'verdict :unknown - needs human review', tags: %w[needs_human extro_verify]) if defined?(Learning) && Learning.respond_to?(:note_outcome)
+              :learning_note
+            end
           end
         rescue StandardError
           nil

data/lib/pwn/ai/agent/learning.rb

@@ -25,8 +25,41 @@ module PWN
       module Learning
         LEARNING_FILE      = File.join(Dir.home, '.pwn', 'learning.jsonl')
         FINETUNE_DIR       = File.join(Dir.home, '.pwn', 'finetune')
+        # P0 — post-answer introspect must not train "stop early" while
+        # spending the iteration budget after the final. Soft cap skips
+        # expensive stages (tool critic, PRM-LLM, reflect, extrospect);
+        # hard cap keeps only note_outcome + judge(heuristic) + sentinel.
+        INTROSPECT_SOFT_MS = 2_500
+        INTROSPECT_HARD_MS = 8_000
+        INTROSPECT_MIN_STAGES = %i[judge note_outcome fold_judge sentinel].freeze
+
         MAX_MEMORY_ENTRIES = 200
-        CLAIM_RX           = /CVE-\d{4}-\d{4,7}|\b[A-Za-z][\w.+-]{2,}\s+v?\d+\.\d+(?:\.\d+)?\b/
+        # E3/P26 — only CVE-ids or software-name + full semver (x.y.z).
+        # Two-part floats ("cap 0.2", "proxy 1.0", "judge 37.0") are RL
+        # metric crumbs that were scraped by verify_as_reward and flooded
+        # learning.jsonl with extro_verify :unknown failures.
+        CLAIM_METRIC_WORDS = %w[
+          cap share proxy judge success only now clears gap score rate mean
+          brier overconf distrust trajectory_fraction handler orm prm delta
+          limit window pct percent ms iter budget conf confidence n
+          ruby python linux kernel host cwd e.g e.g.
+        ].freeze
+        CLAIM_RX = /
+          CVE-\d{4}-\d{4,7}
+          |
+          \b
+          (?!
+            (?:cap|share|proxy|judge|success|only|now|clears|gap|score|rate|mean|
+               brier|overconf|distrust|trajectory_fraction|handler|orm|prm|delta|
+               limit|window|pct|percent|ms|iter|budget|conf|confidence|
+               ruby|python|linux|kernel|host|cwd|e\.g)
+            \b
+          )
+          [A-Za-z][\w.+-]{2,}
+          \s+
+          v?\d+\.\d+\.\d+(?:[-+][\w.]+)?
+          \b
+        /x
 
         # Supported Method Parameters::
         # entry = PWN::AI::Agent::Learning.note_outcome(
@@ -168,7 +201,10 @@ module PWN
           # C2 — strict success:true only (excludes HER success:'soft'). Also
           # down-weight any residual hindsight-tagged rows so partial failures
           # never launder into full-strength few-shot exemplars.
+          # P20 — strict success:true AND prefer high judge scores. Drop rows
+          # with explicit low ORM score so proxy-true / judge-low cannot be few-shot.
           pool = outcomes(limit: 500, success: true).reject { |r| r[:session_id].to_s.empty? }
+          pool = pool.reject { |r| r.key?(:score) && r[:score].to_f < 0.6 }
           scored = pool.map do |r|
             sim   = tokens.count { |t| r[:task].to_s.downcase.include?(t) }.to_f / tokens.length
             age_d = (now - Time.parse(r[:timestamp].to_s)) / 86_400.0
@@ -202,26 +238,65 @@ module PWN
         # Modelfile` over the export - the only path to ACTUAL parity with a
         # frontier model, because it changes the weights not just the scaffold.
 
+        # P12 — SFT quality gate (as hard as DPO source-cap): drop HER/soft,
+        # low judge_score, auto-only noise without score, and PRM-compress
+        # trajectories so LoRA is not 5MB of "how we flailed".
+        SFT_MIN_SCORE = 0.6
+        SFT_MAX_TOOL_CHARS = 1_200
+
         public_class_method def self.export_finetune(opts = {})
           fmt       = (opts[:format] || :sharegpt).to_sym
           min_tools = (opts[:min_tools] || 1).to_i
+          min_score = (opts[:min_score] || SFT_MIN_SCORE).to_f
+          compress  = opts.key?(:compress) ? opts[:compress] : true
           FileUtils.mkdir_p(FINETUNE_DIR)
           out = opts[:out] || File.join(FINETUNE_DIR, "pwn-#{Time.now.utc.strftime('%Y%m%d')}.jsonl")
 
-          # 4.1 — exclude HER soft-success from SFT gold (success: 'soft' or tags)
+          # 4.1 / P12 — exclude HER soft-success + low-score + untagged auto flail
           gold = outcomes(limit: 10_000, success: true).reject do |r|
-            r[:success].to_s == 'soft' ||
-              Array(r[:tags]).any? { |t| %w[hindsight her].include?(t.to_s) }
+            tags = Array(r[:tags]).map(&:to_s)
+            soft = r[:success].to_s == 'soft' || tags.intersect?(%w[hindsight her soft])
+            low  = !r[:score].nil? && r[:score].to_f < min_score
+            # require a score when present in corpus era that has scores
+            soft || low
           end
-          sids = gold.map { |r| r[:session_id] }.compact.uniq
+          # prefer highest-score outcome per session
+          by_sid = {}
+          gold.each do |r|
+            sid = r[:session_id].to_s
+            next if sid.empty?
+
+            prev = by_sid[sid]
+            by_sid[sid] = r if prev.nil? || r[:score].to_f >= prev[:score].to_f
+          end
+          sids = by_sid.keys
           rows = 0
+          dropped = { tools: 0, empty: 0, load: 0 }
           File.open(out, 'w') do |f|
             sids.each do |sid|
-              t = PWN::Sessions.load(session_id: sid)
-              next if t.count { |e| e[:role].to_s == 'tool' } < min_tools
+              t = begin
+                PWN::Sessions.load(session_id: sid)
+              rescue StandardError
+                dropped[:load] += 1
+                next
+              end
+              tool_n = t.count { |e| e[:role].to_s == 'tool' }
+              if tool_n < min_tools
+                dropped[:tools] += 1
+                next
+              end
+
+              conv = if compress
+                       compress_finetune_trace(transcript: t, max_tool_chars: SFT_MAX_TOOL_CHARS)
+                     else
+                       t.map { |e| { role: e[:role].to_s, content: e[:content].to_s } }
+                        .reject { |e| e[:role] == 'system' && e[:content].start_with?('Session started') }
+                     end
+              if conv.nil? || conv.empty? || conv.none? { |m| m[:role].to_s == 'assistant' }
+                dropped[:empty] += 1
+                next
+              end
 
-              conv = t.map { |e| { role: e[:role].to_s, content: e[:content].to_s } }
-                      .reject { |e| e[:role] == 'system' && e[:content].start_with?('Session started') }
               line = case fmt
                      when :openai_jsonl then { messages: conv }
                      else { conversations: conv.map { |m| { from: sharegpt_role(role: m[:role]), value: m[:content] } } }
@@ -230,7 +305,11 @@ module PWN
               rows += 1
             end
           end
-          { path: out, format: fmt, sessions: sids.length, samples: rows, bytes: File.size(out) }
+          {
+            path: out, format: fmt, sessions: sids.length, samples: rows,
+            bytes: File.size(out), min_score: min_score, compressed: compress,
+            dropped: dropped
+          }
         end
 
         # Supported Method Parameters::
@@ -313,10 +392,33 @@ module PWN
           return unless session_id
           return unless auto_introspect_enabled?
 
+          t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          stages_run = []
+          stages_skipped = []
+          budget_hot = begin
+            defined?(Loop) && Loop.respond_to?(:budget_exhaustion_hot?, true) &&
+              Loop.send(:budget_exhaustion_hot?)
+          rescue StandardError
+            false
+          end
+
+          elapsed_ms = lambda do
+            ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round
+          end
+          # soft = skip expensive; hard = stop almost everything
+          over_soft = lambda do
+            ms = elapsed_ms.call
+            ms >= INTROSPECT_SOFT_MS || budget_hot
+          end
+          over_hard = lambda do
+            ms = elapsed_ms.call
+            ms >= INTROSPECT_HARD_MS
+          end
+
           proxy_ok = infer_success(session_id: session_id, final: opts[:final])
-          # S3 — tool-armed constitutional critic runs BEFORE the reward
-          # model so its verdict is evidence, not hindsight.
-          # P7 — force critic when W3 says this engine is overconfident
+
+          # S3 critic — BEFORE reward so verdict is evidence.
+          # P24/P0 — budget_hot or soft-cap → text_only or skip.
           force_critic = begin
             eng = (PWN::Env.dig(:ai, :active) if defined?(PWN::Env))
             cal = defined?(Metrics) ? Metrics.calibration(engine: eng) : { n: 0 }
@@ -324,35 +426,63 @@ module PWN
           rescue StandardError
             false
           end
-          crit = if defined?(Curriculum)
-                   if force_critic
-                     prev = (PWN::Env[:ai][:agent][:critic] if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash))
-                     begin
-                       PWN::Env[:ai][:agent][:critic] = true if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash) && !PWN::Env[:ai][:agent].frozen?
-                       Curriculum.critic(request: opts[:request], final: opts[:final], session_id: session_id)
-                     ensure
-                       PWN::Env[:ai][:agent][:critic] = prev if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash) && !PWN::Env[:ai][:agent].frozen?
-                     end
-                   else
-                     Curriculum.critic(request: opts[:request], final: opts[:final], session_id: session_id)
-                   end
-                 else
-                   { verdict: :pass }
-                 end
-          # R1 — LLM Outcome Reward Model (falls back to calibrated heuristic)
+          # P0 — when W1 mix urgently needs :critic pairs, prefer running critic
+          need_critic_mix = begin
+            mix = defined?(Reward) && Reward.respond_to?(:generator_mix) ? Reward.generator_mix : {}
+            Array(mix[:urgent]).include?('critic')
+          rescue StandardError
+            false
+          end
+
+          crit = { verdict: :pass, source: :skipped }
+          # Single skip path (Lint/DuplicateBranch): hard-budget OR no Curriculum.
+          if !defined?(Curriculum) || (over_hard.call && !need_critic_mix)
+            stages_skipped << :critic
+          elsif budget_hot || (over_soft.call && !force_critic && !need_critic_mix)
+            stages_run << :critic_text_only
+            crit = Curriculum.critic(
+              request: opts[:request],
+              final: opts[:final],
+              session_id: session_id,
+              text_only: true
+            )
+          elsif force_critic
+            stages_run << :critic_forced
+            prev = (PWN::Env[:ai][:agent][:critic] if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash))
+            begin
+              PWN::Env[:ai][:agent][:critic] = true if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash) && !PWN::Env[:ai][:agent].frozen?
+              crit = Curriculum.critic(request: opts[:request], final: opts[:final], session_id: session_id)
+            ensure
+              PWN::Env[:ai][:agent][:critic] = prev if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash) && !PWN::Env[:ai][:agent].frozen?
+            end
+          else
+            stages_run << :critic
+            crit = Curriculum.critic(request: opts[:request], final: opts[:final], session_id: session_id)
+          end
+
+          # R1 judge — always attempt (heuristic is cheap; LLM gated inside)
+          stages_run << :judge
           v = Reward.judge(request: opts[:request], final: opts[:final], session_id: session_id, proxy_ok: proxy_ok) if defined?(Reward)
           v ||= { score: proxy_ok ? 1.0 : 0.0, success: proxy_ok, verdict: proxy_ok ? :solved : :wrong }
           v[:score] = [v[:score], 0.3].min if crit[:verdict] == :flaw
           ok = v[:score] >= 0.6
 
-          # W1 — complete any pending (rejected, chosen) pair from a
-          # user correction on the previous turn.
+          # W1 pending user_correction pair
           pend = Thread.current[:pwn_pending_pref]
           if pend && ok && defined?(Reward)
-            Reward.record_preference(prompt: pend[:prompt], rejected: pend[:rejected], chosen: opts[:final].to_s, source: :user_correction)
+            stages_run << :user_correction_pref
+            Reward.record_preference(
+              prompt: pend[:prompt],
+              rejected: pend[:rejected],
+              chosen: opts[:final].to_s,
+              source: :user_correction,
+              shape: :revised_answer,
+              force: true
+            )
             Thread.current[:pwn_pending_pref] = nil
           end
 
+          stages_run << :note_outcome
           note_outcome(
             task: opts[:request].to_s[0, 120],
             success: ok,
@@ -361,32 +491,69 @@ module PWN
             session_id: session_id,
             tags: ['auto', 'loop', v[:verdict].to_s]
           )
-          # R2 — per-step credit assignment ALWAYS (1.6): failed trajectories
-          # are where step credit matters; feed negative steps into counterfactual.
-          # C3 — HER soft-relabel on failure only.
-          Reward.prm(request: opts[:request], session_id: session_id) if defined?(Reward)
-          Curriculum.hindsight(request: opts[:request], final: opts[:final], session_id: session_id) if !ok && defined?(Curriculum)
-          # W3 — calibration: predicted (from plan_first) vs actual
-          Curriculum.calibrate(predicted: opts[:predicted], actual: v[:score], engine: PWN::Env.dig(:ai, :active)) if opts[:predicted] && defined?(Curriculum)
-          reflect(session_id: session_id) if ok
-          Reward.sentinel if defined?(Reward)
-          Extrospection.auto_extrospect(session_id: session_id) if defined?(Extrospection)
+
+          stages_run << :fold_judge
+          fold_judge_into_metrics(session_id: session_id, score: v[:score], confidence: v[:confidence])
+
+          # R2 PRM — skip under hard cap (expensive LLM); keep under soft if heuristic path
+          if over_hard.call
+            stages_skipped << :prm
+          elsif defined?(Reward)
+            stages_run << :prm
+            Reward.prm(request: opts[:request], session_id: session_id)
+          end
+
+          # C3 HER — only on failure; skip hard
+          if !ok && defined?(Curriculum) && !over_hard.call
+            stages_run << :hindsight
+            Curriculum.hindsight(request: opts[:request], final: opts[:final], session_id: session_id)
+          else
+            stages_skipped << :hindsight unless ok
+          end
+
+          # W3 calibrate — cheap; always when predicted available
+          predicted = opts[:predicted]
+          predicted = recover_predicted_from_session(session_id: session_id) if predicted.nil?
+          if !predicted.nil? && defined?(Curriculum)
+            stages_run << :calibrate
+            Curriculum.calibrate(predicted: predicted, actual: v[:score], engine: PWN::Env.dig(:ai, :active))
+          end
+
+          # reflect on success — skip soft/hard (LLM + memory writes)
+          if ok && !over_soft.call
+            stages_run << :reflect
+            reflect(session_id: session_id)
+          elsif ok
+            stages_skipped << :reflect
+          end
+
+          # R3 sentinel — cheap disk math; always
+          if defined?(Reward)
+            stages_run << :sentinel
+            Reward.sentinel
+          end
+
+          # E ambient extrospect — skip soft (can launch probes)
+          if defined?(Extrospection) && !over_soft.call
+            stages_run << :extrospect
+            Extrospection.auto_extrospect(session_id: session_id)
+          else
+            stages_skipped << :extrospect
+          end
+
+          {
+            ok: ok,
+            score: v[:score],
+            elapsed_ms: elapsed_ms.call,
+            budget_hot: budget_hot,
+            stages_run: stages_run,
+            stages_skipped: stages_skipped
+          }
         rescue StandardError => e
           warn "[pwn-ai/learning] auto_introspect swallowed: #{e.class}: #{e.message}"
           nil
         end
 
-        # Supported Method Parameters::
-        # PWN::AI::Agent::Learning.flip_last_outcome(
-        #   session_id: 'optional - only flip if the newest outcome belongs to this session',
-        #   reason: 'optional - why it is being flipped (usually the user correction text)'
-        # )
-        #
-        # Rewrites the most-recently-appended learning.jsonl entry from
-        # success:true to success:false. Called by Mistakes.check_user_correction
-        # when the user's next message rejects the previous answer, so the
-        # 100 %-success illusion is broken and the failure enters the corpus.
-
         public_class_method def self.flip_last_outcome(opts = {})
           return { flipped: false } unless File.exist?(LEARNING_FILE)
 
@@ -473,6 +640,47 @@ module PWN
         # privates
         # -------------------------------------------------------------
 
+        # P20 — attribute episode judge score to every tool used in session.
+        private_class_method def self.fold_judge_into_metrics(opts = {})
+          return unless defined?(Metrics) && Metrics.respond_to?(:record_judge)
+
+          sid = opts[:session_id]
+          score = opts[:score]
+          conf = opts[:confidence]
+          return if sid.to_s.empty? || score.nil?
+          return unless defined?(PWN::Sessions)
+
+          names = PWN::Sessions.load(session_id: sid)
+                               .select { |e| e[:role].to_s == 'tool' }
+                               .map { |e| e[:content].to_s[/\A([a-z0-9_]+)\s*→/i, 1] }
+                               .compact
+                               .uniq
+          names.each { |n| Metrics.record_judge(name: n, score: score, confidence: conf) }
+        rescue StandardError
+          nil
+        end
+
+        # P22 — recover plan_first p(success)= from session transcript when
+        # the live return floated away (rescue path / degrade).
+        private_class_method def self.recover_predicted_from_session(opts = {})
+          # Prefer live stash from plan_first in this process.
+          stash = Thread.current[:pwn_plan_predicted]
+          return stash.to_f.clamp(0.0, 1.0) unless stash.nil?
+
+          sid = opts[:session_id]
+          return nil if sid.to_s.empty? || !defined?(PWN::Sessions)
+
+          entries = PWN::Sessions.load(session_id: sid)
+          plan = entries.reverse.find do |e|
+            e[:role].to_s == 'assistant' && e[:content].to_s.match?(/\bPLAN:\b|p\(success\)\s*=/i)
+          end
+          return nil unless plan
+
+          plan[:content].to_s[/p\(success\)\s*=\s*([01](?:\.\d+)?)/i, 1]&.to_f
+        rescue StandardError
+          nil
+        end
+
         private_class_method def self.auto_introspect_enabled?
           return false unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
 
@@ -562,6 +770,23 @@ module PWN
           lessons.uniq.first(5)
         end
 
+        # P26 — is this CLAIM_RX hit worth spending a headless browser on?
+        # Reject metric crumbs, OS/runtime banner lines, and bare versions.
+        private_class_method def self.checkable_claim?(opts = {})
+          c = opts[:claim].to_s.strip
+          return false if c.empty? || c.length < 8
+          return true if c.match?(/CVE-\d{4}-\d{4,7}/i)
+
+          head = c[/\A[A-Za-z][\w.+-]*/].to_s
+          return false if CLAIM_METRIC_WORDS.any? { |w| head.casecmp?(w) }
+          # require full semver x.y.z for non-CVE claims
+          return false unless c.match?(/\bv?\d+\.\d+\.\d+/)
+
+          true
+        rescue StandardError
+          false
+        end
+
         # Auto fact-check post-filter: local models hallucinate CVEs /
         # versions ~5-10x more than frontier ones. When the active engine is
         # :ollama, scan the final for CVE / version-shaped claims and hand
@@ -572,12 +797,41 @@ module PWN
           return unless defined?(PWN::Env) && PWN::Env.dig(:ai, :active).to_s.downcase.to_sym == :ollama
           return unless defined?(Extrospection) && Extrospection.respond_to?(:verify)
 
-          claims = opts[:final].to_s.scan(CLAIM_RX).flatten.compact.uniq.first(3)
+          claims = opts[:final].to_s.scan(CLAIM_RX).flatten.compact.uniq
+          claims = claims.select { |c| checkable_claim?(claim: c) }.first(3)
           claims.each { |c| Extrospection.verify(claim: c, commit: true) }
         rescue StandardError => e
           warn "[pwn-ai/learning] fact_check swallowed: #{e.class}: #{e.message}"
         end
 
+        # P12 — PRM-aware SFT trace: keep user + reward>0 tools (else first N) +
+        # final assistant, truncate tool payloads. Drops system noise.
+        private_class_method def self.compress_finetune_trace(opts = {})
+          t = Array(opts[:transcript])
+          cap = (opts[:max_tool_chars] || SFT_MAX_TOOL_CHARS).to_i
+          fin_idx = t.rindex { |e| e[:role].to_s == 'assistant' && !e[:content].to_s.strip.empty? }
+          return [] if fin_idx.nil?
+
+          user_idx = t[0...fin_idx].rindex { |e| e[:role].to_s == 'user' }
+          return [] if user_idx.nil?
+
+          window = t[user_idx..fin_idx]
+          tools = window.select { |e| e[:role].to_s == 'tool' }
+          rewarded = tools.select { |e| e[:step_reward].to_i.positive? }
+          tools = rewarded unless rewarded.empty?
+          tools = tools.first(8)
+
+          out = []
+          out << { role: 'user', content: t[user_idx][:content].to_s[0, 2_000] }
+          tools.each do |e|
+            out << { role: 'tool', content: e[:content].to_s[0, cap] }
+          end
+          out << { role: 'assistant', content: t[fin_idx][:content].to_s[0, 4_000] }
+          out
+        rescue StandardError
+          []
+        end
+
         private_class_method def self.compress_exemplar(opts = {})
           sid = opts[:session_id]
           cap = opts[:max_msgs] || 6