ask-decisions 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e94c483511119929cad9bbdf2d0925ca498e4b4f98f1119c05ac3c26a239edfc
-  data.tar.gz: e09632e3fbaa5f2dca5ffc8692afe586d1818b985db8afaa600f3498e614ab9f
+  metadata.gz: 9969a46203cf5653cacf020b9e5399945d137c846b88fcc52b1b6d91828de484
+  data.tar.gz: e172bd808e1a61019d9dd65dc2073f41776d46ee64e0233fa5333017a2c6945b
 SHA512:
-  metadata.gz: a55fb6e583a983afd05acde0048d203d2e81c3098ef3cfa9d278214a3e4cd2de47ba2bd0f78fcb572f078da1c246fc4dc2aa22f2d23380cd79dc7d5c5fdbfe70
-  data.tar.gz: 57e4a24f195eb27e518e88e7340850e27a90499c2a22ac5a3069cca63d787fee3623f350ccf893fb0794f4eb13667656fd82abff369b9ce71c0c62b30f1a0490
+  metadata.gz: 2e9547a817b4b6e6dc2d21b00c4ca0118fb087505781937e9ad1e591eb4737b60c3eb156a32f76a346120bd0344ba376678522dd30151739bb25153adb0d7ff6
+  data.tar.gz: bea3578951f0d0df5473f8a65412021cc040c044f9244ba484d1e2dc91577065aedf87b457176b8397f933150ed1cb1e760a187ca545af2f6c93d8db44cf48f2

data/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.2.5] - 2026-09-18
+
+### Fixed
+
+- **Dropping one of several tool calls no longer orphans its siblings.**
+  When an assistant message carried multiple tool calls and Jev dropped
+  one, the Compactor removed the whole message — including the calls Jev
+  said to keep, stranding their results without a call. A drop now removes
+  the dropped call from its message; the message survives when it still
+  has text or surviving calls, and disappears only when the drop empties it.
+- **A drop touching a pinned message keeps the compactor's promises.** A
+  result is never left without its call, and a pinned message is never
+  removed — a drop against either now downgrades to keeping the pair
+  (truncating the result when only the call is pinned), and the stats say
+  what actually happened: fully pinned pairs report `pinned` instead of
+  counting as evaluated work.
+
+## [0.2.4] - 2026-09-18
+
+### Fixed
+
+- **`resolve_provider` memoizes the provider instance.** Every call to
+  `resolve_provider` previously created a new `Typesafe` (or other provider)
+  object. In a pipeline with 10+ decision calls per cycle, this meant 10+
+  redundant allocations with identical configuration. The provider is now
+  cached for the lifetime of the process — it holds only read-only state
+  (API key, base URL, model, timeout) set once at boot.
+
 ## [0.2.3] - 2026-09-18
 
 ### Added

data/README.md

@@ -213,6 +213,31 @@ policy.evaluate(tool: "bash", confidence: 0.6).action   # => :act
 policy.evaluate(tool: "rm", confidence: 0.8).action      # => :review
 ```
 
+## Compactor
+
+Decision-based conversation compaction. Summaries are lossy — a file path,
+an exact error, a one-time constraint can vanish. The Compactor never
+rewrites anything: Jev scores every tool call and result, and the irrelevant
+ones are dropped or truncated. Everything kept stays verbatim.
+
+```ruby
+compactor = Ask::Decisions::Compactor.new(provider, preserve_recent: 6)
+result = compactor.compact(session.messages)
+
+result.messages          # => pruned conversation
+result.stats             # => { kept: 12, dropped: 5, truncated: 3, reduction_ratio: 0.29, ... }
+result.reduction_ratio   # => 0.29
+```
+
+Three tiers per tool call: result still needed → keep both verbatim; call
+matters, result doesn't → keep the call, truncate the result to a short
+head; neither matters → remove both. The first message and the most recent
+`preserve_recent:` messages are pinned — never touched, never scored.
+
+Fail open: a failed decision call means keep the transcript and fall back to
+summarization. A compaction that doesn't happen this turn happens next turn;
+a lost constraint is gone for good.
+
 ## Calibration
 
 Measure whether confidence is trustworthy on YOUR decisions:

data/lib/ask/decisions/compactor.rb

@@ -81,6 +81,7 @@ module Ask
         questions = build_questions(pairs, pinned)
         batch = batch_and_execute(state, questions)
         decisions = extract_decisions(batch, pairs)
+        mark_pinned_pairs(decisions, pairs, pinned)
         pruned = apply_decisions(messages, decisions, pinned)
         stats = compute_stats(messages, pruned, decisions)
 
@@ -145,6 +146,8 @@ module Ask
       end
 
       # First message and the most recent +preserve_recent+ messages are pinned.
+      # Pinned messages are never removed, and a pair living entirely inside
+      # them is never scored — Jev does not see pinned content.
       def compute_pinned(messages)
         pinned = Set.new([0])
         start = [messages.size - @preserve_recent, 1].max
@@ -162,7 +165,6 @@ module Ask
         pairs.each { |p| result_index[p[:result_msg_idx]] = p }
 
         lines = messages.each_with_index.map do |msg, idx|
-          role = msg[:role] || "unknown"
           content = msg[:content].to_s
 
           if result_index[idx]
@@ -180,7 +182,6 @@ module Ask
           end
         end
 
-        goal_section = @goal ? "\n\nGoal: #{@goal}" : ""
         { conversation: lines, goal: @goal }.compact
       end
 
@@ -195,6 +196,8 @@ module Ask
       def build_questions(pairs, pinned)
         questions = {}
         pairs.each do |pair|
+          # Skip pairs where both the call and result live in pinned messages.
+          # Pinned messages are never touched — Jev does not score them.
           next if pinned.include?(pair[:call_msg_idx]) && pinned.include?(pair[:result_msg_idx])
 
           call_id = pair[:call_id]
@@ -269,6 +272,19 @@ module Ask
 
       # ── Decisions ────────────────────────────────────────────────────
 
+      # A pair whose call and result both live in pinned messages was never
+      # scored. Record that as its own action so the stats describe Jev's
+      # work, not the pinning.
+      def mark_pinned_pairs(decisions, pairs, pinned)
+        pairs.each do |pair|
+          next unless pinned.include?(pair[:call_msg_idx]) && pinned.include?(pair[:result_msg_idx])
+
+          if (decision = decisions[pair[:call_id]])
+            decision[:action] = :pinned
+          end
+        end
+      end
+
       def extract_decisions(batch, pairs)
         decisions = {}
         pairs.each do |pair|
@@ -305,6 +321,9 @@ module Ask
         pairs = build_pairs(messages)
         remove_indices = Set.new
         truncate_indices = {}
+        # call_id => true when the call survives although its result does not
+        # (a :drop whose result is pinned downgrades to keeping the call).
+        dropped_results = Set.new
 
         pairs.each do |pair|
           decision = decisions[pair[:call_id]]
@@ -312,8 +331,24 @@ module Ask
 
           case decision[:action]
           when :drop
-            remove_indices.add(pair[:call_msg_idx])
+            call_pinned = pinned.include?(pair[:call_msg_idx])
+            result_pinned = pinned.include?(pair[:result_msg_idx])
+
+            if call_pinned || result_pinned
+              # A result is never left without its call, and a pinned message
+              # is never removed. A drop touching a pinned message keeps the
+              # pair — the call verbatim, the result truncated to its head.
+              if result_pinned
+                decision[:action] = :keep
+              else
+                truncate_indices[pair[:result_msg_idx]] = pair[:call]
+                decision[:action] = :truncate
+              end
+              next
+            end
+
             remove_indices.add(pair[:result_msg_idx])
+            dropped_results.add(pair[:call_id])
           when :truncate
             truncate_indices[pair[:result_msg_idx]] = pair[:call]
           end
@@ -325,11 +360,29 @@ module Ask
           if truncate_indices[idx]
             truncate_message(msg, truncate_indices[idx])
           else
-            msg
+            prune_dropped_calls(msg, dropped_results)
           end
         end
       end
 
+      # A drop removes the tool result message; the call itself leaves the
+      # assistant message that carried it. A message survives when it has text
+      # or surviving calls — it is removed only when the drop empties it.
+      def prune_dropped_calls(msg, dropped_results)
+        return msg unless msg[:tool_calls] && dropped_results.any?
+
+        surviving = msg[:tool_calls].reject { |tc| dropped_results.include?(tc[:id]) }
+        return msg if surviving.size == msg[:tool_calls].size
+
+        if surviving.empty? && msg[:content].to_s.empty?
+          nil
+        elsif surviving.empty?
+          msg.except(:tool_calls)
+        else
+          msg.merge(tool_calls: surviving)
+        end
+      end
+
       def truncate_message(msg, call)
         original = msg[:content].to_s
         return msg if original.length <= @truncate_head_chars
@@ -342,7 +395,7 @@ module Ask
       # ── Stats ────────────────────────────────────────────────────────
 
       def compute_stats(original, pruned, decisions)
-        action_counts = decisions.values.tally { |d| d[:action] }
+        action_counts = decisions.values.map { |d| d[:action] }.tally
         original_chars = original.sum { |m| m[:content].to_s.length }
         pruned_chars = pruned.sum { |m| m[:content].to_s.length }
 
@@ -352,7 +405,8 @@ module Ask
           kept: action_counts[:keep] || 0,
           truncated: action_counts[:truncate] || 0,
           dropped: action_counts[:drop] || 0,
-          tool_pairs_evaluated: decisions.size,
+          pinned: action_counts[:pinned] || 0,
+          tool_pairs_evaluated: decisions.size - (action_counts[:pinned] || 0),
           chars_before: original_chars,
           chars_after: pruned_chars,
           reduction_ratio: original_chars > 0 ? (1.0 - pruned_chars.to_f / original_chars) : 0.0

data/lib/ask/decisions/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Decisions
-    VERSION = "0.2.3"
+    VERSION = "0.2.5"
   end
 end

data/lib/ask-decisions.rb

@@ -122,13 +122,19 @@ module Ask
       end
 
       # Resolve a provider by name, raising on unknown.
+      # Memoized: the provider is stateless after boot (API key,
+      # base URL, model, timeout are all read-only), so one instance
+      # per configuration lifetime is safe and avoids redundant
+      # allocations across the pipeline.
       def resolve_provider(name)
-        klass = Ask::DecisionProvider.resolve(name)
-
-        if configuration.provider_options.any?
-          klass.new(**configuration.provider_options)
-        else
-          klass.new
+        @resolved_provider ||= begin
+          klass = Ask::DecisionProvider.resolve(name)
+
+          if configuration.provider_options.any?
+            klass.new(**configuration.provider_options)
+          else
+            klass.new
+          end
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-decisions
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Kaka Ruto