ask-decisions 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e64f40bca45e7b9bc9a11f33fabe1e178c30cfd9e61f4460395b77eb8092cc5a
-  data.tar.gz: 4e32792a9c4bdc411731beb94d9a078e98d92f3135aaa4da779090fd6c4f96c9
+  metadata.gz: 9969a46203cf5653cacf020b9e5399945d137c846b88fcc52b1b6d91828de484
+  data.tar.gz: e172bd808e1a61019d9dd65dc2073f41776d46ee64e0233fa5333017a2c6945b
 SHA512:
-  metadata.gz: e6338ccd1b049f19612e7b33d4e7dbedce5192d4789c29ac62bf6fa075107fa7184764b71c3df9e0edc6284e8d9ed0013225d5ee84a6be9858b5d3ca49d2b874
-  data.tar.gz: f9c69aca54eaae484d182ab78c7265de776fafff15e5b4813908028dac1857e8df4f85428fc9474282dd54b4418a6c9981e8cb5e76673f028593daff8be3102b
+  metadata.gz: 2e9547a817b4b6e6dc2d21b00c4ca0118fb087505781937e9ad1e591eb4737b60c3eb156a32f76a346120bd0344ba376678522dd30151739bb25153adb0d7ff6
+  data.tar.gz: bea3578951f0d0df5473f8a65412021cc040c044f9244ba484d1e2dc91577065aedf87b457176b8397f933150ed1cb1e760a187ca545af2f6c93d8db44cf48f2

data/CHANGELOG.md

@@ -4,6 +4,23 @@ 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

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,8 +146,8 @@ module Ask
       end
 
       # First message and the most recent +preserve_recent+ messages are pinned.
-      # Pinned messages are never removed, but their tool calls are still
-      # evaluated by Jev — a recent tool result can still be irrelevant.
+      # 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
@@ -154,11 +155,6 @@ module Ask
         pinned
       end
 
-      # Whether a message index is safe to remove (not pinned).
-      def removable?(idx, pinned)
-        !pinned.include?(idx)
-      end
-
       # ── State ────────────────────────────────────────────────────────
 
       # Build the state Jev sees: full conversation with tool results replaced
@@ -276,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|
@@ -312,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]]
@@ -319,13 +331,24 @@ module Ask
 
           case decision[:action]
           when :drop
-            # Only remove messages that are not pinned.
-            if removable?(pair[:call_msg_idx], pinned)
-              remove_indices.add(pair[:call_msg_idx])
-            end
-            if removable?(pair[:result_msg_idx], pinned)
-              remove_indices.add(pair[:result_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
@@ -337,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
@@ -364,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.4"
+    VERSION = "0.2.5"
   end
 end

metadata

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