insika 0.7.0 → 0.8.0

data/lib/insika/context/providers/briefing.rb

@@ -5,9 +5,20 @@ module Insika
     module Providers
       # Read path for the session briefing: the per-session
       # working-state the agent keeps and asks for. Thin adapter over the
-      # SessionStore, same pattern as Memory: one `:system` fragment,
-      # deterministic. The MISSING list is rendered, never implied — that list
-      # is what stops the model re-asking for a field already given.
+      # SessionStore, same pattern as Memory, deterministic. The MISSING list is
+      # rendered, never implied — that list is what stops the model re-asking
+      # for a field already given.
+      #
+      # TWO fragments, and the split is the whole point:
+      #   · `<briefing>` (:system) — the DURABLE facts, what is already known.
+      #     Head of the prompt, where reference material belongs.
+      #   · `<recitation>` (:tail) — what is still missing and what the next step
+      #     is, rendered AFTER the whole history, as the last thing before the
+      #     current user message.
+      # Attention is strongest at the END of the context: a goal stated only in
+      # the head is the first thing a 30-call turn forgets. The recitation lives
+      # in exactly one place — it was MOVED out of the head, never duplicated, so
+      # a turn pays for it once.
       class Briefing < ContextProvider
         def initialize(session_store:)
           @session_store = session_store
@@ -34,12 +45,10 @@ module Insika
           declared = Array(request.profile.briefing_fields)
           return [] if declared.empty? # defensive; enabled_for? already gates
 
-          block = format_block(declared, fields, briefing["next_step"])
-          return [] if block.nil?
+          missing = declared.reject { |name| Coercion.present?(fields[name]) }
+          next_step = briefing["next_step"]
 
-          [ContextFragment.build(content: block, placement: :system,
-                                 priority: Context::Priority::BRIEFING,
-                                 source: id)]
+          [head_fragment(declared, fields), tail_fragment(missing, next_step)].compact
         end
 
         private
@@ -52,37 +61,57 @@ module Insika
           @session_store.find(session.id)&.briefing || {}
         end
 
-        # Byte contract (the specs assert this shape):
+        # The HEAD block — durable facts only. Byte contract:
         #   <briefing>
         #   known:
         #     size: M
-        #   still missing: delivery_day
-        #   next step: send the payment link tomorrow at 10
         #   </briefing>
-        # Rules: `known` renders only when at least one declared field has a
-        # stored value; `still missing` renders every declared field with no
-        # stored value (including the all-missing case — that is the block's
-        # job); `next step` renders only when non-nil; stored keys NOT in the
-        # declaration are never rendered (they stay in the store and reappear if
-        # the pack re-declares them).
-        def format_block(declared, fields, next_step)
+        # Nothing known yet -> no fragment at all (an empty `known:` header
+        # teaches the model nothing and still costs a cache invalidation).
+        # Stored keys NOT in the declaration are never rendered (they stay in the
+        # store and reappear if the pack re-declares them).
+        def head_fragment(declared, fields)
           known = declared.filter_map do |name|
             "  #{name}: #{flatten(fields[name])}" if Coercion.present?(fields[name])
           end
-          missing = declared.reject { |name| Coercion.present?(fields[name]) }
+          return nil if known.empty?
 
+          block = <<~BLOCK.strip
+            <briefing>
+            known:
+            #{known.join("\n")}
+            </briefing>
+          BLOCK
+          ContextFragment.build(content: block, placement: :system,
+                                priority: Context::Priority::BRIEFING, source: id)
+        end
+
+        # The TAIL recitation — two lines, no more. Byte contract:
+        #   <recitation>
+        #   still missing: delivery_day
+        #   next step: send the payment link tomorrow at 10
+        #   </recitation>
+        # `still missing` renders every declared field with no stored value
+        # (including the all-missing case — that is this block's job); `next step`
+        # renders only when non-nil. Neither -> no fragment.
+        #
+        # A `user` message, like every other engine append inside a turn
+        # (LoopDetector, TurnBudget): the system prefix stays byte-stable, so the
+        # cache breakpoint at its end keeps hitting.
+        def tail_fragment(missing, next_step)
           lines = []
-          lines << "known:" unless known.empty?
-          lines.concat(known)
           lines << "still missing: #{missing.join(', ')}" unless missing.empty?
           lines << "next step: #{flatten(next_step)}" if Coercion.present?(next_step)
           return nil if lines.empty?
 
-          <<~BLOCK.strip
-            <briefing>
+          block = <<~BLOCK.strip
+            <recitation>
             #{lines.join("\n")}
-            </briefing>
+            </recitation>
           BLOCK
+          ContextFragment.build(content: { role: :user, content: block },
+                                placement: :tail,
+                                priority: Context::Priority::RECITATION, source: id)
         end
 
         # utf8 the value and flatten newlines/whitespace so a value can never

data/lib/insika/context/providers/session.rb

@@ -14,8 +14,8 @@ module Insika
         end
 
         def call(request)
-          messages = transcript_for(request)
-          return [] if messages.nil? || messages.empty?
+          messages, compaction = transcript_for(request)
+          return [] if messages.nil? || (messages.empty? && compaction.nil?)
 
           # A3/C3 opt-in: identical tool results in the transcript collapse to a
           # back-reference (the cheap half of compaction). CHANGES WHAT THE MODEL
@@ -28,7 +28,7 @@ module Insika
           # the fragment level means the budget cut (apply_budget) drops a whole
           # tool cycle atomically — a tool_use is NEVER seeded without its result
           # (which providers reject), without touching apply_budget itself.
-          eviction_units(messages).each_with_index.map do |unit, idx|
+          fragments = eviction_units(messages).each_with_index.map do |unit, idx|
             ContextFragment.build(
               # single message stays a Hash (compat with existing fragments); a
               # multi-message cycle is an Array (seed_history flattens it back).
@@ -39,6 +39,7 @@ module Insika
               source: id
             )
           end
+          compaction ? [compaction_fragment(compaction)] + fragments : fragments
         end
 
         private
@@ -90,15 +91,50 @@ module Insika
         end
 
         # Precedence: checkpoint -> explicit history -> store.
-        # The first present source wins; no merge.
+        # The first present source wins; no merge. -> [messages, compaction|nil].
+        # The compaction state (RFC-0044) applies to the STORE source only: a
+        # checkpoint resume replays the checkpoint's own tape (which already
+        # contains whatever summary the original turn saw) and an explicit
+        # vars[:history] is the caller's contract — neither is rewritten.
         def transcript_for(request)
-          return request.checkpoint.messages if request.checkpoint
+          return [request.checkpoint.messages, nil] if request.checkpoint
 
           explicit = explicit_history(request)
-          return explicit if explicit
-          return session_messages(request.session) if request.session
+          return [explicit, nil] if explicit
+          return compacted_session_messages(request.session) if request.session
 
-          nil
+          [nil, nil]
+        end
+
+        # Splits the stored transcript at the persisted compaction boundary:
+        # messages[0...upto] are represented by the summary, messages[upto..]
+        # stay verbatim. `upto` is clamped to the transcript size (defensive —
+        # the store is append-only, so it should never outrun it).
+        def compacted_session_messages(session)
+          fresh = fresh_session(session)
+          return [[], nil] if fresh.nil?
+
+          messages = fresh.messages || []
+          state = fresh.respond_to?(:compaction) ? fresh.compaction : nil
+          upto = state ? state["upto"].to_i : 0
+          return [messages, nil] unless upto.positive? && Coercion.present?(state["summary"])
+
+          [messages.drop([upto, messages.size].min), state]
+        end
+
+        # The compacted prefix as ONE history fragment, rendered FIRST (the
+        # Builder keeps history in production order). role "user" because it is
+        # provider-agnostic (a mid-history "system" message is not). Priority
+        # COMPACTION (59): the "oldest unit" — under budget it drops before any
+        # verbatim message. source "compaction" -> its own context-trace category.
+        def compaction_fragment(state)
+          ContextFragment.build(
+            content: { role: "user",
+                       content: "<conversation_summary>\n#{state['summary']}\n</conversation_summary>" },
+            placement: :history,
+            priority: Context::Priority::COMPACTION,
+            source: "compaction"
+          )
         end
 
         # Source 2 (explicit history): the handler passes it in request.vars[:history].
@@ -111,8 +147,8 @@ module Insika
         # CONDITIONAL requiredness: when a session is requested, a read
         # failure becomes a ContextError (aborts the turn); the base required?
         # does not receive the request, so the behavior lives here.
-        def session_messages(session)
-          @session_store.find(session.id)&.messages || []
+        def fresh_session(session)
+          @session_store.find(session.id)
         rescue StandardError => e # read failure (exception/StoreError)
           raise ContextError.new("Session provider failed with a requested session: #{e.message}",
                                  provider: id)

data/lib/insika/context_trace_store.rb

@@ -80,10 +80,20 @@ module Insika
         "tools" => { "count" => int(tools[:count] || tools["count"]),
                      "tokens" => int(tools[:tokens] || tools["tokens"]) },
         "fingerprints" => fingerprints_of(e[:fingerprints] || e["fingerprints"]),
-        "cache" => cache_of(e[:cache] || e["cache"])
+        "cache" => cache_of(e[:cache] || e["cache"]),
+        "compaction" => compaction_of(e[:compaction] || e["compaction"])
       }.compact
     end
 
+    # { upto, runs } — present only when the session was compacted (RFC-0044).
+    # Counts only, like everything else here; the summary text never lands.
+    def compaction_of(raw)
+      return nil unless raw.is_a?(Hash)
+
+      { "upto" => int(raw[:upto] || raw["upto"]),
+        "runs" => int(raw[:runs] || raw["runs"]) }
+    end
+
     # { name => sha256-hex }; names stringified, non-strings
     # dropped. Absent when the caller passed nothing (a trace recorded before
     # this feature has no key and the view guards on nil).

data/lib/insika/doctor.rb

@@ -179,7 +179,8 @@ module Insika
                     check_relay_channel check_web_widget check_skill_eager check_skill_drift check_shadow_parity
                     check_soak_envelope check_turn_timing check_grounding check_cache_layers
                     check_memory_scopes check_funnel_declarations check_followup check_distill
-                    check_harvest check_schedules check_guardrail_corpora]
+                    check_compaction check_harvest check_schedules check_guardrail_corpora
+                    check_tool_allowlist_policy]
 
     def safe(check)
       Array(send(check))
@@ -722,26 +723,59 @@ module Insika
 # the mangled prompt on every turn, and nothing else would ever say so: the file is
 # present, non-empty, and the agent answers — worse than a crash. Found on the pilot
 # by an `insika refine` report, three weeks after the fact.
+#
+# The same sweep also WARNS (never errors) on a file that outgrew a prompt.
+# Merchant packs are LLM-generated (generate-merchant-pack), and generated prose
+# bloats: the pilot's 28 KB AGENTS.md is the local example, and the ETH Zurich
+# instruction-file study puts the cost of that shape at 20%+ extra tokens per
+# turn for no extra instruction-following. The thresholds are deliberately
+# generous — a hand-written file never meets them; only the generated shape does.
 def check_prompt_files
   return [] unless @agent_file_store
 
   agents = @agent_file_store.agents
-  wrapped = agents.flat_map do |agent|
-    @agent_file_store.list(agent).filter_map do |name|
-      next unless wrapped_content?(@agent_file_store.read(agent, name))
-
-      Finding.new(check: "prompt-files", severity: :error, fix: nil,
-                  message: "agent '#{agent}' file '#{name}' holds a serialized object, not text — " \
-                           "the model receives `{\"content\" => …}` on one line, escapes and all. " \
-                           "Recover the markdown from inside the wrapper and write it back.")
+  wrapped = []
+  oversized = []
+  agents.each do |agent|
+    @agent_file_store.list(agent).each do |name|
+      content = @agent_file_store.read(agent, name)
+      if wrapped_content?(content)
+        wrapped << Finding.new(check: "prompt-files", severity: :error, fix: nil,
+                               message: "agent '#{agent}' file '#{name}' holds a serialized object, not text — " \
+                                        "the model receives `{\"content\" => …}` on one line, escapes and all. " \
+                                        "Recover the markdown from inside the wrapper and write it back.")
+      elsif (finding = oversized_prompt(agent, name, content))
+        oversized << finding
+      end
     end
   end
-  return wrapped if wrapped.any?
+  return wrapped + oversized if wrapped.any? || oversized.any?
 
   total = agents.sum { |a| @agent_file_store.list(a).length }
   [ok("prompt-files", "#{total} prompt file(s) across #{agents.length} agent(s): all text")]
 end
 
+# WARN thresholds for one prompt file. ~6 000 estimated tokens (~24 KB) or 600
+# lines: the pilot's generated 28 KB / 292-line AGENTS.md trips the token bar,
+# every hand-written demo file stays far under both. Estimate = chars/4, the
+# same yardstick as Insika::TokenEstimator — cheap and honest about being ±15%.
+PROMPT_FILE_WARN_TOKENS = 6_000
+PROMPT_FILE_WARN_LINES = 600
+
+def oversized_prompt(agent, name, content)
+  text = content.to_s
+  tokens = Insika::TokenEstimator.estimate(text)
+  lines = text.lines.count
+  return nil if tokens <= PROMPT_FILE_WARN_TOKENS && lines <= PROMPT_FILE_WARN_LINES
+
+  Finding.new(check: "prompt-files", severity: :warn, fix: nil,
+              message: "agent '#{agent}' file '#{name}' is ~#{tokens} tokens over #{lines} line(s) " \
+                       "(threshold: #{PROMPT_FILE_WARN_TOKENS} tokens / #{PROMPT_FILE_WARN_LINES} lines) — " \
+                       "a prompt this large costs 20%+ more tokens on every turn for no better " \
+                       "instruction-following. Trim it, or split the reference material into skills " \
+                       "the agent loads on demand.")
+end
+
 # Cheap and specific: Ruby's inspect of a Hash whose first key is a string. A real
 # prompt does not open with `{"…" =>`.
 def wrapped_content?(content) = /\A\s*\{\s*"[^"]+"\s*=>/.match?(content.to_s)
@@ -868,6 +902,46 @@ def wrapped_content?(content) = /\A\s*\{\s*"[^"]+"\s*=>/.match?(content.to_s)
     # harmless but useless — every claim passes and the audit reads zero. A
     # warning, never an error: the pack owns matcher quality; the engine refuses
     # only uncompileable data.
+    # A stored agent that declares `tools_allow` / `tools_deny` /
+    # `tools_allow_groups` but does not name the `tool_allowlist` policy. Only
+    # that policy applies the lists, and the Policy::Engine runs ONLY the
+    # policies a profile names — so as written on disk the lists are inert and
+    # the model receives every registered tool (hundreds of schemas, tens of
+    # thousands of tokens, per request).
+    #
+    # AgentProfile.build now adds the policy whenever a list is declared, so a
+    # live turn off this record is already safe. The record itself stays wrong
+    # until something re-saves it, and anything that reads the stored shape
+    # directly — an older engine, a pack export, an operator auditing the
+    # Studio form — still sees an allowlist that does nothing. That is why this
+    # reads the RAW record and not `all`.
+    def check_tool_allowlist_policy
+      return [] unless @profile_source.respond_to?(:all_raw)
+
+      records = @profile_source.all_raw
+      bad = records.select { |r| tool_lists_declared?(r) && !names_tool_allowlist?(r) }
+      return [ok("tool-allowlist", "#{records.length} stored agent(s): every declared tool list names the policy")] if bad.empty?
+
+      bad.map do |r|
+        Finding.new(check: "tool-allowlist", severity: :error, fix: nil,
+                    message: "agent '#{r["id"]}' declares a tool allow/deny list but its policies " \
+                             "(#{Array(r["policies"]).join(", ").then { |p| p.empty? ? "none" : p }}) " \
+                             "do not include tool_allowlist — as stored, the list is never applied and " \
+                             "the model receives every registered tool. The engine repairs this when it " \
+                             "loads the agent; re-save it (Studio, or the pack) so the stored policies " \
+                             "match the intent.")
+      end
+    end
+
+    # Presence, not emptiness, for the two nil-able lists: `tools_allow: []`
+    # means "no tools" and is as much a declaration as a list of names.
+    # `tools_deny` has no nil state, so only a non-empty one counts.
+    def tool_lists_declared?(raw)
+      !raw["tools_allow"].nil? || !raw["tools_allow_groups"].nil? || !Array(raw["tools_deny"]).empty?
+    end
+
+    def names_tool_allowlist?(raw) = Array(raw["policies"]).any? { |p| p.to_s == "tool_allowlist" }
+
     def check_grounding
       return [] unless @profile_source
 
@@ -1230,6 +1304,27 @@ def wrapped_content?(content) = /\A\s*\{\s*"[^"]+"\s*=>/.match?(content.to_s)
         stale: @proposal_store.stale(limit: 10_000).size }
     end
 
+    # the in-session compaction check (RFC-0044): platform-gated,
+    # so ONE line — enabled with no resolvable model (no compaction.model, no
+    # platform utility_model) can never run; the warn is the same "declared
+    # but dead" signal as check_distill's (the engine never guesses a model).
+    def check_compaction
+      return [] unless @settings_store
+
+      settings = @settings_store.get
+      config = settings["compaction"] || {}
+      return [ok("compaction", "in-session compaction off")] unless Coercion.truthy?(config["enabled"])
+
+      if Coercion.presence(config["model"]).nil? && Coercion.presence(settings["utility_model"]).nil?
+        [Finding.new(check: "compaction", severity: :warn, fix: nil,
+                     message: "in-session compaction is enabled but has no model slot — it will " \
+                              "never run (set compaction.model or the platform utility_model).")]
+      else
+        [ok("compaction", "in-session compaction on — keep_last #{config['keep_last']}, " \
+                          "compact_after #{config['compact_after']}")]
+      end
+    end
+
     # the harvest check — per profile WITH a harvest hash:
     #   declared-without-model warn (D12), no grounding matcher warn (D3),
     #   malformed negative list error (D4), else ok with the pending counts.

data/lib/insika/dsl/runtime.rb

@@ -236,6 +236,10 @@ module Insika
           Insika::Context::Providers::ToolSearch.new(catalog: c[:tool_catalog]),
           Insika::Context::Providers::Memory.new(store: spine.memory_store),
           Insika::Context::Providers::Knowledge.new(store: spine.knowledge_store),
+          # Session briefing: read path. Inert for agents without briefing_fields.
+          # Before Session, so the durable head renders above the transcript and
+          # the tail recitation lands after it.
+          Insika::Context::Providers::Briefing.new(session_store: spine.session_store),
           Insika::Context::Providers::Session.new(session_store: spine.session_store)
         ] # NOT frozen: load_plugins appends plugin providers at boot
       end

data/lib/insika/env_schema.rb

@@ -72,10 +72,10 @@ module Insika
 
     # Prefixes the engine fully OWNS: an unknown key under one of these is a typo, not
     # a foreign var. INSIKA_ (current) and HARNESS_ (legacy, still honored during the
-    # deprecation window). Deliberately NOT OPENCLAW_ (shared with the OpenClaw gateway
-    # product, which sets its own OPENCLAW_HOME/_STATE_DIR/… — the engine merely borrows
-    # 3 names for interop), nor LITESTREAM_ (the sidecar owns it), nor OTEL_ (the
-    # OpenTelemetry SDK owns its env).
+    # deprecation window). Deliberately NOT OPENCLAW_ (the OpenClaw gateway product
+    # sets its own OPENCLAW_HOME/_STATE_DIR/… on the same host; the engine reads none
+    # of them), nor LITESTREAM_ (the sidecar owns it), nor OTEL_ (the OpenTelemetry
+    # SDK owns its env).
     OWNED_PREFIXES = [PREFIX, LEGACY_PREFIX].freeze
 
     BOOLEANS = %w[1 0 true false yes no on off].freeze
@@ -142,8 +142,7 @@ module Insika
       spec(name: "INSIKA_ROUTER_BACKEND_TIMEOUT", type: :integer, description: "`insika-router`'s connect/read timeout to a backend, in seconds (default 10)."),
       spec(name: "INSIKA_ROUTER_HOST", description: "bind address for `insika-router` itself (default 0.0.0.0)."),
       spec(name: "INSIKA_ROUTER_PORT", type: :integer, description: "listen port for `insika-router` itself (default 9090)."),
-      spec(name: "OPENCLAW_GATEWAY_TOKEN", secret: true, description: "Bearer for /v1 + /a2a (falls back to ADMIN_TOKEN)."),
-      spec(name: "OPENCLAW_AGENTS_DIR", type: :path, description: "Directory of OpenClaw-style agent packs."),
+      spec(name: "INSIKA_GATEWAY_TOKEN", secret: true, description: "Bearer for /v1 + /a2a (falls back to ADMIN_TOKEN when unset)."),
       spec(name: "INSIKA_PLUGIN_DIR", type: :path, description: "Workspace plugin root (directories with insika.plugin.yml). Loaded at boot; ids still need INSIKA_PLUGINS."),
       spec(name: "INSIKA_PLUGINS", type: :csv, description: "Plugin ids to enable from the workspace/bundled roots. Announced gems are enabled by installing them."),
       spec(name: "INSIKA_PLUGINS_DISABLED", type: :csv, description: "Plugin ids that never load — the absolute veto, wins over INSIKA_PLUGINS and over an announced gem."),

data/lib/insika/evals/transport.rb

@@ -135,7 +135,7 @@ module Insika
         req["Authorization"] = "Bearer #{@token}"
         req["Content-Type"] = "application/json"
         req["Accept"] = "text/event-stream"
-        req.body = JSON.generate(model: "openclaw:#{agent}", user: conv, stream: true, input: message)
+        req.body = JSON.generate(model: "insika:#{agent}", user: conv, stream: true, input: message)
 
         t0 = mono
         ttfb = nil

data/lib/insika/executor.rb

@@ -1038,6 +1038,11 @@ module Insika
                          tokens: estimate_tools_tokens(state.allowed_tools) },
                 fingerprints: fingerprints,
                 cache: { invalidation_reason: reason } }
+      # the compaction state this turn was BUILT over (RFC-0044) —
+      # {upto, runs}, counts only; the summary fragment itself already shows
+      # as the trace's own "compaction" category via its fragment source.
+      compaction = state.session.respond_to?(:compaction) ? state.session.compaction : nil
+      entry[:compaction] = { upto: compaction["upto"], runs: compaction["runs"] } if compaction
       # Park the SANITIZED entry (string keys) — the stage-8 stamp merges into
       # it and re-records the same key; a raw entry would add a SECOND "cache"
       # key that sanitize would then ignore (the symbol one wins).
@@ -2476,6 +2481,12 @@ module Insika
       # next door to the other two, for the same reason: it fires for a fresh
       # turn and a recovered one.
       finalize_knowledge_extraction(task, profile, new_messages)
+
+      # in-session compaction (RFC-0044): when the uncompacted
+      # transcript crossed the threshold this turn, summarize the old prefix
+      # with the cheap model and move the boundary — off the critical path,
+      # same terminal hook, same best-effort discipline as the other three.
+      finalize_compaction(task, profile)
     end
 
     # Records the answer in the outbox and dispatches it. The discriminator is the
@@ -2607,6 +2618,59 @@ module Insika
       @settings_store.get["utility_model"]
     end
 
+    # in-session compaction (RFC-0044). Platform-gated
+    # (Settings compaction.enabled — parity when off), planned over the
+    # POST-append transcript (persist_turn already wrote this turn's messages),
+    # dispatched off the critical path — the SAME shape as
+    # finalize_knowledge_extraction: inline when non-supervised, a child of the
+    # turn supervisor when serving. Best-effort: any failure leaves the session
+    # record untouched and the next turn re-plans.
+    def finalize_compaction(task, profile)
+      return unless task.session_id && @settings_store
+
+      config = Coercion.deep_stringify(@settings_store.get["compaction"])
+      return unless config && Coercion.truthy?(config["enabled"])
+
+      session = @session_store.find(task.session_id)
+      return unless session
+
+      state = session.respond_to?(:compaction) ? session.compaction : nil
+      plan = Insika::Compaction.plan(messages: session.messages, state: state, config: config)
+      return unless plan
+
+      # compaction.model -> platform utility_model -> inert (never a guess);
+      # `insika doctor` warns on enabled-with-no-model. @llm rides along so a
+      # deployment (or spec) that injects its LLM seam covers this call too.
+      summarizer = Compaction::SummarizerFactory.build(config, utility_model: utility_model, llm: @llm)
+      return unless summarizer
+
+      run = lambda { run_compaction(task, profile, session, state, plan, config, summarizer) }
+      return run.call unless @supervised
+
+      turn_parent.async do |t|
+        t.annotate("compaction:#{task.id}")
+        run.call
+      end
+    end
+
+    def run_compaction(task, profile, session, state, plan, config, summarizer)
+      prompt = Insika::Compaction.prompt(messages: session.messages, plan: plan,
+                                         previous: state && state["summary"],
+                                         base: config["prompt"])
+      result = summarizer.summarize(prompt: prompt)
+      updated = @session_store.set_compaction(task.session_id, summary: result[:summary],
+                                              upto: plan.upto, model: summarizer.model)
+      # counts and ids only — the summary text never enters the stream. Feeds
+      # the insika.context.compacted counter (Telemetry::Recorder).
+      emit(:context_compacted,
+           { task_id: task.id, agent: profile.id, from: plan.from, upto: plan.upto,
+             messages: plan.count, runs: updated.compaction && updated.compaction["runs"],
+             model: summarizer.model, cost: result[:cost] },
+           task: task)
+    rescue StandardError
+      nil # best-effort: compaction never re-fails an already-committed turn.
+    end
+
     # ONE supervisor fiber for the whole chain. Sequential deliver
     # calls, so balloon N+1 cannot overtake balloon N on the wire. Still off the
     # session's FIFO — the customer's next message does not wait on this turn's

data/lib/insika/loop_detector.rb

@@ -50,9 +50,7 @@ module Insika
       @streak = 0
       @intervened = false  # the ONE warning of this turn has been delivered
       @pending = false     # detection fired; waiting for the batch boundary
-      @expected = nil      # tool calls announced by the batch in flight
-      @seen = 0
-      @halted = false
+      @batch = ToolBatch.new
     end
 
     # From ChatBuilder's before_tool_call. Raises BEFORE the call executes once
@@ -80,41 +78,21 @@ module Insika
 
     # From ChatBuilder's after_tool_result, with the RAW result — the only place
     # a Tool::Halt is still recognizable (SteerInjector's comment applies here).
-    def tool_result(result)
-      @halted = true if defined?(RubyLLM::Tool::Halt) && result.is_a?(RubyLLM::Tool::Halt)
-    end
+    def tool_result(result) = @batch.halt!(result)
 
     # RubyLLM after_message. An assistant message carrying tool calls OPENS a
     # batch; the Nth tool result CLOSES it — the one boundary where appending
-    # is valid.
+    # is valid (ToolBatch owns that arithmetic; TurnBudget follows the same rule).
     def message_ended(message)
-      role = field(message, :role).to_s
-      return open_batch(message) if role == "assistant"
-      return unless role == "tool" && @expected
-
-      @seen += 1
-      intervene! if @seen >= @expected
+      intervene! if @batch.closed?(message)
     end
 
     private
 
-    def open_batch(message)
-      calls = field(message, :tool_calls)
-      size = calls.respond_to?(:size) ? calls.size : 0
-      # No tool call = the model talking; the turn is ending and a pending
-      # warning is moot — the loop resolved itself.
-      return @expected = nil if size.zero?
-
-      @expected = size
-      @seen = 0
-      @halted = false
-    end
-
     def intervene!
-      @expected = nil
       return unless @pending
       @pending = false
-      return if @halted # nothing will read it (halt_when): drop, never deliver
+      return if @batch.halted? # nothing will read it (halt_when): drop, never deliver
 
       @intervened = true
       name, = @last
@@ -132,12 +110,5 @@ module Insika
       else value
       end
     end
-
-    def field(message, name)
-      return message.public_send(name) if message.respond_to?(name)
-      return message[name] || message[name.to_s] if message.respond_to?(:[])
-
-      nil
-    end
   end
 end

data/lib/insika/profile_source.rb

@@ -74,6 +74,13 @@ module Insika
 
     def delete(id) = @cs.delete(SCOPE, id.to_s)
 
+    # The STORED records, unbuilt (string keys, straight off the JSON
+    # round-trip). `all` runs every record through AgentProfile.build, which
+    # normalizes — and repairs — what it reads, so a caller that needs to judge
+    # the truth ON DISK (the doctor) cannot use it: a repaired-on-read profile
+    # is indistinguishable there from a well-formed record.
+    def all_raw = @cs.all(SCOPE)
+
     private
 
     # Rebuilds the AgentProfile from the record (the JSON round-trip turns symbols

data/lib/insika/server/responses.rb

@@ -12,9 +12,9 @@ module Insika
     # OpenAI Responses SSE frame (or nil for events with no counterpart). Follows the
     # constitutional rule: no business logic, no store access here.
     #
-    # Request: { model: "openclaw:<agent>", user: "<chat.id>", stream: true,
+    # Request: { model: "insika:<agent>", user: "<chat.id>", stream: true,
     #            input: "<string with already-composed blocks>" } + header
-    # X-Openclaw-Agent (agent fallback). The `input` enters VERBATIM as the
+    # X-Insika-Agent (agent fallback). The `input` enters VERBATIM as the
     # turn's message — the blocks (<memoria>/<dados_conhecidos>/directives) already come
     # composed by the consumer (the engine does not interpret them).
     module Responses
@@ -32,8 +32,8 @@ module Insika
       # gets that filtered structurally instead of by a regex on the leading tag.
       # Omitted = a customer typed it, which is what every turn meant before.
       def parse_request(body, req)
-        agent = body[:model].to_s.sub(/\Aopenclaw:/, "")
-        agent = req.get_header("HTTP_X_OPENCLAW_AGENT").to_s if agent.empty?
+        agent = body[:model].to_s.sub(/\Ainsika:/, "")
+        agent = req.get_header("HTTP_X_INSIKA_AGENT").to_s if agent.empty?
         raise Insika::ValidationError, "model/agent missing" if agent.strip.empty?
 
         user = body[:user].to_s