insika 0.8.0 → 1.0.1

data/lib/insika/tools/tool_search.rb

@@ -6,13 +6,13 @@ module Insika
   module Tools
     # Level 2 of TOOLS progressive disclosure (analog of LoadSkill):
     # searches the deferred catalog and PROMOTES the relevant ones into the live chat via
-    # chat.with_tools (verified to propagate on the next round of the same `ask`
-    # in ruby_llm 1.16). `require "ruby_llm"` stays in THIS file (it inherits from
+    # chat.with_tools (propagates on the next round of the same `ask`).
+    # `require "ruby_llm"` stays in THIS file (it inherits from
     # RubyLLM::Tool) — it does not enter lib/insika.rb; the Executor loads it lazily in
     # configure_chat (like LoadSkill).
     class ToolSearch < RubyLLM::Tool
       description "Searches and enables additional tools by describing the need"
-      param :query, desc: "What you need to do (e.g.: 'send email', 'generate invoice')"
+      parameter :query, description: "What you need to do (e.g.: 'send email', 'generate invoice')"
 
       # RubyLLM::Tool#name derives from self.class.name — for a nested class
       # (Insika::Tools::ToolSearch) it produces "insika--tools--tool_search", not
@@ -21,7 +21,7 @@ module Insika
       def name = "tool_search"
 
       def initialize(catalog, deferred_allowed, chat, tool_registry:, event_stream:,
-                     checkpoint_store:, state:)
+                     checkpoint_store:, state:, trace_recorder: nil)
         @catalog = catalog
         @deferred_allowed = Array(deferred_allowed).map(&:to_s)
         @chat = chat
@@ -29,6 +29,7 @@ module Insika
         @event_stream = event_stream
         @checkpoint_store = checkpoint_store
         @state = state
+        @trace_recorder = trace_recorder
         @promoted = [] # names already promoted IN THIS chat — idempotency
         super()
       end
@@ -59,7 +60,8 @@ module Insika
           @promoted << entry.name
           ToolEnvelope.new(tool, state: @state, checkpoint_store: @checkpoint_store,
                                  tool_registry: @tool_registry, timeout: timeout,
-                                 skip_side_effects: Array(@state.skip_side_effects))
+                                 skip_side_effects: Array(@state.skip_side_effects),
+                                 event_stream: @event_stream, trace_recorder: @trace_recorder)
         rescue Insika::NotFoundError
           nil
         end
@@ -79,11 +81,13 @@ module Insika
 
       def describe(entry)
         tool = @tool_registry.resolve(entry.name)
+        schema = Coercion.deep_stringify(tool.parameters_schema || {})
         {
           name: entry.name,
           description: entry.description,
-          parameters: tool.parameters.transform_values do |p|
-            { type: p.type, description: p.description, required: p.required }
+          parameters: schema.fetch("properties", {}).to_h do |name, property|
+            [name.to_sym, { type: property["type"], description: property["description"],
+                            required: Array(schema["required"]).include?(name) }]
           end
         }
       rescue Insika::NotFoundError

data/lib/insika/tools/tts.rb

@@ -20,8 +20,8 @@ module Insika
       description "Synthesize speech for the reply — a voice clip travels as an " \
                   "output part in the envelope, the channel supports it. Use when the " \
                   "customer should HEAR the answer rather than read it."
-      param :text, desc: "The words to speak"
-      param :voice, desc: "Optional voice override (default from the agent config)",
+      parameter :text, description: "The words to speak"
+      parameter :voice, description: "Optional voice override (default from the agent config)",
             required: false
 
       def name = "tts"

data/lib/insika/tools/update_briefing.rb

@@ -53,8 +53,8 @@ module Insika
         names.empty? ? BASE_DESCRIPTION : "#{BASE_DESCRIPTION} field must be one of: #{names.join(', ')}."
       end
 
-      param :field, desc: "The briefing field name (one of the declared list)"
-      param :value, desc: "The value learned. Blank clears the field."
+      parameter :field, description: "The briefing field name (one of the declared list)"
+      parameter :value, description: "The value learned. Blank clears the field."
 
       def name = "update_briefing"
 
@@ -72,7 +72,7 @@ module Insika
 
       # The declared names become the `field` enum in the schema the provider
       # sees — per-turn data, like the subagent allowlist (Tools::AgentEnum).
-      def params_schema
+      def parameters_schema
         @field_enum_schema ||= Insika::Tools::AgentEnum.inject(super, @fields, path: %i[field])
       end
 
@@ -99,7 +99,7 @@ module Insika
 
         description "Records the next step agreed with the customer " \
                     "(e.g. 'send the payment link tomorrow at 10'). Blank clears it."
-        param :text, desc: "The agreed next step, in one sentence"
+        parameter :text, description: "The agreed next step, in one sentence"
 
         def name = "set_next_step"
 

data/lib/insika/turn_output.rb

@@ -49,12 +49,12 @@ module Insika
     # public_intermediate: the agent opted this channel in (`edge_stream`), so the
     #   narration is TAGGED and `/v1/responses` gives it its own frame. Default false:
     #   an internal event stays internal unless someone said otherwise.
-    def initialize(filter:, emit:, public_intermediate: false)
+    def initialize(filter:, emit:, public_intermediate: false, halt_text: "")
       @filter = filter
       @emit = emit
       @public_intermediate = public_intermediate
       @pending = +""           # text of the message currently streaming
-      @last_intermediate = +"" # text of the last message that turned out NOT to be the answer
+      @last_intermediate = halt_text.to_s # already filtered when checkpointed
       @candidate = nil
     end
 

data/lib/insika/turn_state.rb

@@ -6,6 +6,10 @@ module Insika
   class TurnState
     attr_reader :task, :profile, :turn # turn identity (1-based)
     attr_accessor :message,            # input (Middleware may rewrite)
+                  :caller_context,     # payload `context`: text the caller sends WITH the message
+                  #                      (channel rules, what the customer already saw). The model
+                  #                      and the transcript get it ahead of the message; guardrails
+                  #                      and retrieval read `message` alone. nil = none.
                   :context,            # ContextPackage from the Builder
                   :allowed_tools,      # Resolution from the Policy Engine
                   :allowed_skills,
@@ -61,9 +65,16 @@ module Insika
                   #                      context via an evidence-declared tool (the envelope
                   #                      appends; the validator/enforcer read it). Built per
                   #                      turn by the Executor; nil = no session/no evidence.
-                  :evidence_attachments, # [ {type, url, caption} ] hoarded by the
+                  :evidence_attachments, # [ {type, url, caption, id} ] hoarded by the
                   #                      envelope this turn; read by the Executor at stage 8
                   #                      for the channel delivery. Reset per turn.
+                  :presentations,      # [ {component, title, items: [{id,url,caption}]} ] —
+                  #                      what a presentation tool SELECTED this turn, in call
+                  #                      order. Non-empty = the channel delivery sends these
+                  #                      instead of every hoarded card. Reset per turn.
+                  :fence_max_chars,    # per-leaf cap the ToolEnvelope applies when the
+                  #                      agent has `fencing` on — the platform's
+                  #                      `fencing.max_chars`, set per turn by the Executor.
                   :context_trace_entry  # the sanitized trace entry parked at
                   #                      prepare_turn (fingerprints + invalidation_reason);
                   #                      the stage-8 stamp merges the cache-hit fields into
@@ -104,7 +115,9 @@ module Insika
     # to serialize the turn's real exchange — user + assistant(tool_calls) + tool
     # results + final assistant — into the transcript. nil = no chat recorded
     # (workflow/halt) → persist_turn falls back to the {user, assistant} pair.
+    attr_accessor :shared_conversations
     attr_accessor :chat_baseline
+    attr_accessor :tool_halt
 
     # Internal: impl_name(String) -> STABLE name of the capability that
     # resolved it, computed by resolve_capabilities BEFORE the policy_request and
@@ -134,6 +147,9 @@ module Insika
     # Internal (memory): the turn's tenant (from the Command), scope of the write path
     # (`remember` tool). Set in run_pipeline; nil = DEFAULT_TENANT in the MemoryStore.
     attr_accessor :tenant
+    # The phrase an injection-flagging InputGuardrail matched (nil = none). The
+    # ChatBuilder hands the model a per-turn notice built from it.
+    attr_accessor :security_notice
 
     # Internal: turn context deposited into the data-tools to
     # resolve {{ctx.*}} (chat_id/agent_id/tenant/store_id) and emit
@@ -148,6 +164,9 @@ module Insika
     # (workflow) or provider without counts.
     attr_accessor :usage
 
+    # Native rerank usage events, separate from the chat/Responses token totals.
+    attr_accessor :rerank_usage
+
     # Internal (Tool Search): ids of side-effects already completed in the
     # interrupted turn, propagated to the tools PROMOTED by tool_search (the same `skip`
     # that the eager tools' wrap_tools receives). Set in run_pipeline;
@@ -159,6 +178,12 @@ module Insika
     # creates the PendingAction/suspends/waits; `actor` = the turn's mailbox (used
     # by the coordinator for await(:approval)).
     attr_accessor :requires_approval, :approval_coordinator, :actor
+    attr_accessor :native_approvals, :approval_continuation, :turn_output
+
+    # Customer confirmation: the store a `customer_confirm` call is held in by the
+    # ToolEnvelope and resolved from by confirm_pending/cancel_pending. nil = the
+    # deployment has no PendingActionStore (a hold then fails loud, like approval).
+    attr_accessor :pending_action_store
 
     # Internal: the turn's shared in-flight cap for tool calls —
     # ONE Async::Semaphore(tool_concurrency), installed by ToolAssembly#wrap_tools
@@ -167,6 +192,10 @@ module Insika
     # nil = concurrency off: no gate, no overhead, serial execution unchanged.
     attr_accessor :tool_gate
 
+    # Turns of one session already run serially through SessionActor. This gate
+    # prevents overlapping writes within a parallel batch of the current turn.
+    attr_accessor :side_effect_gate
+
     # parallel tool calls, resolved PER TURN and read by ChatBuilder
     # (whether to hand the gem `concurrency:`) and ToolAssembly (the gate's size).
     #
@@ -199,6 +228,7 @@ module Insika
       @output_parts = []
       @channel_capabilities = []
       @evidence_attachments = []
+      @presentations = []
       # Fiber storage is INHERITED by fibers created later, so a turn spawned from
       # inside a tool call (a subagent child) would start out carrying its
       # parent's correlation. Clearing at turn start keeps a child from keying its

data/lib/insika/turn_timing.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
 module Insika
-  # Opt-in per-turn latency breakdown (locate the
-  # TTFB cost with real-turn data). OFF unless INSIKA_TURN_TIMING is set — when
-  # off the Executor never allocates one and the hot path pays only `nil&.mark`.
+  # Per-turn latency clock. Every turn runs one (a few clock reads); the turn's
+  # numbers land in ModelMetricsStore's turn rows (#metrics). INSIKA_TURN_TIMING
+  # only decides what the RESPONSE exposes (#to_h) and whether store calls count.
   #
   # Splits a turn into the three windows that answer "is TTFB local or provider?":
   #   prep_ms  — prep_start -> ask: ALL local work before the provider call
   #              (context build, policy, guardrail detectors, chat assembly).
   #   ttft_ms  — ask -> first_token: the provider round-trip to the 1st token.
   #   gen_ms   — first_token -> done: streaming the rest of the response.
+  #   store_calls — store calls this turn made (+ store_calls_by: "op scope" => n).
   #
   # Marks are monotonic; `mark` is first-write-wins so `first_token` records the
   # FIRST content chunk even though it is called on every chunk.
@@ -26,26 +27,35 @@ module Insika
       Insika::EnvSchema.truthy?(Insika::EnvSchema.read("INSIKA_TURN_TIMING", env))
     end
 
-    # The marks that only mean something under INSIKA_TURN_TIMING. A `breakdown:
-    # false` clock (a channel turn with the flag off) ignores them and measures
-    # only first_balloon_ms.
-    BREAKDOWN_MARKS = %i[prep_start ask first_token done].freeze
-    private_constant :BREAKDOWN_MARKS
+    # Fiber-storage slot holding the running turn's clock. Child fibers (parallel
+    # tool calls, context providers) inherit it, so their store calls count too.
+    FIBER_KEY = :insika_turn_timing
 
-    # breakdown: true (the default) is the flag-on clock: prep/ttft/gen/total.
-    # false is the   channel clock: only :inbound -> :first_balloon,
-    # so a channel turn with the flag off still answers H-latência.
+    def self.current = Fiber[FIBER_KEY]
+
+    # "config:<scope>" keeps its config scope; any other scope keeps its first
+    # segment, so ids embedded in scope names do not split the breakdown.
+    def self.scope_group(scope)
+      parts = scope.to_s.split(":")
+      parts.first == "config" ? parts.first(2).join(":") : parts.first.to_s
+    end
+
+    # breakdown: true (the default) exposes prep/ttft/gen/total in #to_h.
+    # false exposes only first_balloon_ms (the flag-off contract); every mark is
+    # still taken, so #metrics is complete either way.
     def initialize(breakdown: true)
       @marks = {}
       @breakdown = breakdown
+      @tools = []
     end
 
     def mark(name)
-      return unless @breakdown || !BREAKDOWN_MARKS.include?(name)
-
       @marks[name] ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
+    # One tool call of this turn (ToolEnvelope#trace): [name, ok, ms].
+    def tool(name, ok, ms) = @tools << [name.to_s, ok, ms]
+
     # Has this mark fired? Used by `SendMessage` to prove the channel clock was
     # stamped at 202 acceptance (`:inbound` before the debounce window), and by
     # the pipeline to know a threaded clock already started.
@@ -56,13 +66,40 @@ module Insika
     # first_balloon_ms is the inbound -> first outbox flush window.
     # A missing number is never a zero — no mark, no key.
     def to_h
-      {
+      h = {
         prep_ms: delta(:prep_start, :ask),
         ttft_ms: delta(:ask, :first_token),
         gen_ms: delta(:first_token, :done),
         total_ms: delta(:prep_start, :done),
         first_balloon_ms: delta(:inbound, :first_balloon)
       }.compact
+      h = h.slice(:first_balloon_ms) unless @breakdown
+      return h unless @store_calls
+
+      h.merge(store_calls: @store_calls.values.sum,
+              store_calls_by: @store_calls.sort_by { |call, n| [-n, call] }.to_h)
+    end
+
+    # The turn row ModelMetricsStore keeps: every window, whatever the flag.
+    # queue_ms is inbound -> pipeline start (debounce + FIFO wait), the part of
+    # first_balloon_ms that is not the turn's own work. tools_ms sums the calls,
+    # so parallel calls count more than their wall time.
+    def metrics
+      {
+        "prep_ms" => delta(:prep_start, :ask), "ttft_ms" => delta(:ask, :first_token),
+        "gen_ms" => delta(:first_token, :done), "total_ms" => delta(:prep_start, :done),
+        "first_balloon_ms" => delta(:inbound, :first_balloon), "queue_ms" => delta(:inbound, :prep_start),
+        "tools_ms" => (@tools.sum { |_, _, ms| ms.to_i } unless @tools.empty?),
+        "tools" => (@tools unless @tools.empty?)
+      }.compact
+    end
+
+    # One store call made during this turn (see Stores::TurnCounter).
+    def count_store(op, scope)
+      return unless @breakdown
+
+      @store_calls ||= Hash.new(0)
+      @store_calls["#{op} #{self.class.scope_group(scope)}"] += 1
     end
 
     private

data/lib/insika/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Insika
-  VERSION = "0.8.0"
+  VERSION = "1.0.1"
 end

data/lib/insika/wiring/graph.rb

@@ -24,14 +24,37 @@ module Insika
 
       # Backend by config: INSIKA_DB set → durable SQLite (survives restart, the
       # prerequisite for Recovery); missing → ephemeral Memory (dev/demo). The same
-      # rule lived verbatim in both roots. Dual-read honors the legacy HARNESS_DB alias.
+      # rule lived verbatim in both roots.
+      # LITESTREAM_REPLICA_URL is the same switch deploy/entrypoint.sh uses: set, and
+      # Litestream owns the checkpoints.
+      # Every backend counts its calls into the running turn (TurnTiming).
       def backend_from_env(env = ENV)
+        Insika::Stores::TurnCounter.attach(raw_backend_from_env(env))
+      end
+
+      def raw_backend_from_env(env = ENV)
+        url = Insika::EnvSchema.read("INSIKA_DATABASE_URL", env)
+        if url && !url.empty?
+          pool = Insika::EnvSchema.read("INSIKA_DATABASE_POOL", env)
+          return Insika::Stores::Postgres.new(url: url, pool: pool && !pool.empty? ? Integer(pool) : 10)
+        end
+
         db = Insika::EnvSchema.read("INSIKA_DB", env)
-        db && !db.empty? ? Insika::Stores::SQLite.new(path: db) : Insika::Stores::Memory.new
+        return Insika::Stores::Memory.new unless db && !db.empty?
+
+        slow = Insika::EnvSchema.read("INSIKA_SLOW_STORE_MS", env)
+        Insika::Stores::SQLite.new(path: db, autocheckpoint: env["LITESTREAM_REPLICA_URL"].to_s.empty?,
+                                   slow_ms: slow && Float(slow))
+      end
+
+      # On unless INSIKA_MODEL_VISIBLE_TRACES is set to a false value.
+      def model_visible_traces?(env = ENV)
+        value = Insika::EnvSchema.read("INSIKA_MODEL_VISIBLE_TRACES", env)
+        value.nil? || Insika::EnvSchema.truthy?(value)
       end
 
       # an integer tick knob from the env, nil when unset (the caller's
-      # default wins). Dual-read honors the deprecated HARNESS_* alias.
+      # default wins).
       def tick_env(name, env = ENV)
         value = Insika::EnvSchema.read(name, env)
         value&.to_i
@@ -43,6 +66,8 @@ module Insika
       def spine(backend:, extra_policy_builtins: {})
         session_store        = Insika::SessionStore.new(store: backend)
         task_store           = Insika::TaskStore.new(store: backend)
+        llm_trace_store       = Insika::LLMTraceStore.new(store: backend)
+        model_metrics_store  = Insika::ModelMetricsStore.new(store: backend)
         checkpoint_store     = Insika::CheckpointStore.new(store: backend)
         pending_action_store = Insika::PendingActionStore.new(store: backend)
         delegation_store     = Insika::DelegationStore.new(store: backend)
@@ -122,7 +147,7 @@ module Insika
 
         Spine.new(
           backend: backend, event_stream: Insika::EventStream.new,
-          session_store: session_store, task_store: task_store,
+          session_store: session_store, task_store: task_store, llm_trace_store: llm_trace_store, model_metrics_store: model_metrics_store,
           checkpoint_store: checkpoint_store, pending_action_store: pending_action_store,
           delegation_store: delegation_store,
           memory_store: memory_store, memory_audit_store: memory_audit_store,
@@ -168,6 +193,12 @@ module Insika
         # expose it. The gem's require lives IN the factory block (loaded on
         # the 1st instance, turn time -> wiring-load stays gem-free).
         register_artifact_tool(spine)
+        # Turns read profiles with the platform agent defaults applied; the
+        # authoring commands the roots register keep the agent's own record.
+        if (settings_store = executor_extra[:settings_store])
+          profiles = Insika::AgentDefaults::ProfileSource.new(Insika::ProfileSource.coerce(profiles),
+                                                              settings_store: settings_store)
+        end
         spine.hooks.register(:task, after: guardrails.output_validator)
         middleware = Insika::MiddlewareStack.new([edge_limiter, guardrails.input_guardrail].compact)
 
@@ -192,11 +223,16 @@ module Insika
       # the profile's `reliability` data gates it, so the bare wiring is unchanged.
       reliability = Insika::Reliability.new(circuit_store: spine.circuit_state,
                                             event_stream: spine.event_stream)
+      if (url = Insika::Coercion.presence(Insika::EnvSchema.read("INSIKA_CONVERSATIONS_URL")))
+        executor_extra = {shared_conversations: Insika::SharedConversations.new(
+          url: url, token: Insika::EnvSchema.read("INSIKA_CONVERSATIONS_TOKEN"), store: spine.backend)}.merge(executor_extra)
+      end
       executor = Insika::Executor.new(
         context_builder: context_builder, policy_engine: policy_engine,
         middleware: middleware, hooks: spine.hooks,
         tool_registry: tool_registry, skill_catalog: skill_catalog, profiles: profiles,
         session_store: spine.session_store, task_store: spine.task_store,
+        llm_trace_store: spine.llm_trace_store, model_metrics_store: spine.model_metrics_store,
         checkpoint_store: spine.checkpoint_store, event_stream: spine.event_stream,
         workflow_registry: spine.workflow_registry, pending_action_store: spine.pending_action_store,
         capability_registry: spine.capability_registry, tool_catalog: tool_catalog,
@@ -213,11 +249,14 @@ module Insika
         # the model-visible trace rides executor_extra like the
         # context trace — a module graph that omits it still builds (nil =
         # parity). The base graph wires it over the same backend the context
-        # trace uses.
-        model_visible_trace_store: Insika::ModelVisibleTraceStore.new(store: spine.backend),
+        # trace uses. INSIKA_MODEL_VISIBLE_TRACES=0 stops the WRITE only (nothing in
+        # the product reads it back; it was ~80% of the bytes a turn wrote): the
+        # purge paths below keep their own store, so old records still go.
+        model_visible_trace_store: model_visible_traces? ? Insika::ModelVisibleTraceStore.new(store: spine.backend) : nil,
         # the per-turn extraction hook (nil = the loop is off,
         # parity). Gated per-agent by `profile.knowledge`.
         knowledge_store: spine.knowledge_store,
+        # llm stays graph-scoped; Executor binds instrumentation on operation copies.
         **executor_extra
       )
 
@@ -228,6 +267,10 @@ module Insika
           profiles: profiles, proposal_store: spine.proposal_store,
           session_store: spine.session_store, memory_store: spine.memory_store,
           settings_store: executor_extra[:settings_store],
+          distiller_factory: ->(config) {
+            Insika::Distill::DistillerFactory.build(config,
+              utility_model: executor_extra[:settings_store]&.get&.[]("utility_model"), llm: executor_extra[:llm])
+          },
           event_stream: spine.event_stream
         )
 
@@ -297,6 +340,11 @@ module Insika
           profiles: profiles, executor: executor, budget_ledger: spine.budget_ledger,
           event_stream: spine.event_stream
         )
+        # RubyLLM's model catalog (prices included) in the store, refreshed
+        # daily by one worker and reloaded by the rest.
+        executor.tick.model_registry = Insika::ModelRegistry.new(
+          store: spine.backend, interval: (tick_env("INSIKA_MODEL_REFRESH_HOURS") || 24) * 3600
+        )
         # the distillation engine — the tick-duty that finds idle
         # customer sessions and distills them on its own worker fiber (a
         # supervisor child, started in serving mode next to the tick).
@@ -323,7 +371,11 @@ module Insika
           skill_store: skill_catalog.store, # the harvest's dedup reads the authored skills
           tool_trace_store: executor_extra[:tool_trace_store],
           settings_store: executor_extra[:settings_store],
-          negative_list: nil, miner_factory: nil,
+          negative_list: nil,
+          miner_factory: ->(config) {
+            Insika::Harvest::MinerFactory.build(config,
+              utility_model: executor_extra[:settings_store]&.get&.[]("utility_model"), llm: executor_extra[:llm])
+          },
           event_stream: spine.event_stream
         )
         executor.harvest_engine = Insika::HarvestEngine.new(
@@ -343,6 +395,7 @@ module Insika
         Graph::Result.new(
           backend: spine.backend, event_stream: spine.event_stream,
           session_store: spine.session_store, task_store: spine.task_store,
+          llm_trace_store: spine.llm_trace_store, model_metrics_store: spine.model_metrics_store,
           checkpoint_store: spine.checkpoint_store, pending_action_store: spine.pending_action_store,
           delegation_store: spine.delegation_store,
           memory_store: spine.memory_store, memory_audit_store: spine.memory_audit_store,
@@ -367,7 +420,8 @@ module Insika
           tool_catalog: tool_catalog, skill_catalog: skill_catalog, prompt_catalog: prompt_catalog,
           hooks: spine.hooks, guardrails: guardrails, middleware: middleware,
           context_providers: context_providers, context_builder: context_builder,
-          policy_engine: policy_engine, profiles: profiles, executor: executor, bus: bus
+          # the agent's own records: the Studio and the roots author through them
+          policy_engine: policy_engine, profiles: Insika::AgentDefaults.own(profiles), executor: executor, bus: bus
         )
       end
 
@@ -422,6 +476,13 @@ module Insika
         bus = Insika::CommandBus.new
         bus.register(:create_session,
                      Insika::Commands::CreateSession.new(session_store: spine.session_store, event_stream: spine.event_stream))
+        # A snapshot loaded into a conversation before its first turn — what an eval
+        # case declares as `state:`. The HTTP route and the in-process eval transport
+        # both dispatch this one command.
+        bus.register(:seed_session,
+                     Insika::Commands::SeedSession.new(session_store: spine.session_store,
+                                                       memory_store: spine.memory_store,
+                                                       event_stream: spine.event_stream))
         bus.register(:cancel_task,
                      Insika::Commands::CancelTask.new(task_store: spine.task_store, executor: executor))
         bus.register(:pause_task,
@@ -529,6 +590,11 @@ module Insika
         bus.register(:delete_artifact,
                      Insika::Commands::DeleteArtifact.new(artifact_store: spine.artifact_store,
                                                           event_stream: spine.event_stream))
+        # a person's verdict on a guardrail flag (false positive / resolved)
+        # — the Session viewer's button and the Review inbox.
+        bus.register(:review_guardrail_flag,
+                     Insika::Commands::ReviewGuardrailFlag.new(session_store: spine.session_store,
+                                                               event_stream: spine.event_stream))
         bus.register(:revoke_contact,
                      Insika::Commands::RevokeContact.new(contact_store: spine.contact_store,
                                                          followup_store: spine.followup_store,
@@ -554,7 +620,11 @@ module Insika
                        skill_store: skill_catalog.store,
                        tool_trace_store: executor_extra[:tool_trace_store],
                        settings_store: executor_extra[:settings_store],
-                       negative_list: nil, miner_factory: nil,
+                       negative_list: nil,
+                       miner_factory: ->(config) {
+                         Insika::Harvest::MinerFactory.build(config,
+                           utility_model: executor_extra[:settings_store]&.get&.[]("utility_model"), llm: executor_extra[:llm])
+                       },
                        event_stream: spine.event_stream
                      ))
         bus.register(:gate_harvest,
@@ -568,7 +638,7 @@ module Insika
                        harvest_store: spine.harvest_store,
                        skill_store: skill_catalog.store,
                        skill_catalog: skill_catalog,
-                       profile_source: profiles, criterion: nil, conversion_gate: nil,
+                       profile_source: Insika::AgentDefaults.own(profiles), criterion: nil, conversion_gate: nil,
                        event_stream: spine.event_stream
                      ))
         bus.register(:rollback_harvest,
@@ -576,7 +646,7 @@ module Insika
                        harvest_store: spine.harvest_store,
                        skill_store: skill_catalog.store,
                        skill_catalog: skill_catalog,
-                       profile_source: profiles, event_stream: spine.event_stream
+                       profile_source: Insika::AgentDefaults.own(profiles), event_stream: spine.event_stream
                      ))
         bus.register(:reject_harvest,
                      Insika::Commands::RejectHarvest.new(
@@ -594,7 +664,7 @@ module Insika
         # dispatches this bus command; nothing else writes the demo agent.
         config_store = Insika::ConfigStore.new(store: spine.backend)
         demo_seeder = Insika::Demo::Seeder.new(
-          profiles: profiles, store: spine.backend, session_store: spine.session_store,
+          profiles: Insika::AgentDefaults.own(profiles), store: spine.backend, session_store: spine.session_store,
           task_store: spine.task_store, outcome_store: spine.outcome_store,
           funnel_store: spine.funnel_store, followup_store: spine.followup_store,
           refinement_store: spine.refinement_store, pending_action_store: spine.pending_action_store,
@@ -611,7 +681,7 @@ module Insika
       # Infra spine (phase 1 output). Value object — the roots read these to promote
       # them to their historic public constants (SESSION_STORE, REGISTRY, ...).
       Spine = Struct.new(
-        :backend, :event_stream, :session_store, :task_store, :checkpoint_store,
+        :backend, :event_stream, :session_store, :task_store, :llm_trace_store, :model_metrics_store, :checkpoint_store,
         :pending_action_store, :delegation_store, :memory_store, :memory_audit_store,
         :refinement_store,
         :harvest_store,
@@ -629,7 +699,7 @@ module Insika
       # deployment's overlay, or the same code registry at the base).
       Result = Struct.new(
         :backend, :event_stream,
-        :session_store, :task_store, :checkpoint_store, :pending_action_store, :delegation_store,
+        :session_store, :task_store, :llm_trace_store, :model_metrics_store, :checkpoint_store, :pending_action_store, :delegation_store,
         :memory_store, :memory_audit_store, :refinement_store, :outbox_store, :shadow_pair_store,
         :inbound_log, :token_store,
         :budget_ledger, :circuit_state, :outcome_store, :funnel_store,
@@ -646,7 +716,7 @@ module Insika
         :profiles, :executor, :bus,
         keyword_init: true
       ) do
-        def durable? = backend.is_a?(Insika::Stores::SQLite)
+        def durable? = Insika::Stores.durable?(backend)
       end
 
       # The save_artifact tool, registered OPTIONAL on the shared code registry
@@ -678,7 +748,9 @@ module Insika
           require "ruby_llm"
           require_relative "../tools/run_persona_eval"
           Insika::Tools::RunPersonaEval.new(
-            golden_store: golden_store, profiles: graph.profiles, tool_registry: graph.tool_registry,
+            golden_store: golden_store, tool_registry: graph.tool_registry,
+            # the target as its turns see it: kit tools count in the derived swap list
+            profiles: Insika::AgentDefaults.for_turns(graph.profiles, settings_store),
             runtime: GraphChat.new(graph: graph), graph: graph, settings_store: settings_store,
             budget_ledger: graph.budget_ledger, event_stream: graph.event_stream, llm: llm
           )

data/lib/insika/wiring/graph_chat.rb

@@ -18,6 +18,10 @@ module Insika
         @graph = graph
       end
 
+      # The graph this seam speaks for — an eval transport reaches its bus and
+      # event stream through here.
+      attr_reader :graph
+
       # One turn, in-process -> the assistant's text. `agent:` is REQUIRED —
       # this seam has no notion of "the default agent" (that is a DSL::Runtime
       # concept, filled in by its own caller before delegating here). Raises