insika 0.9.0 → 1.0.1

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
 
@@ -536,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,
@@ -561,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,
@@ -575,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,
@@ -583,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(
@@ -601,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,
@@ -618,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,
@@ -636,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,
@@ -653,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
@@ -685,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/workflow.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json_schemer"
+
 module Insika
   # Workflow surface (COMPETITIVE-ANALYSIS). A workflow is a Ruby
   # callable orchestrating RubyLLM Agents/Workflows FROM WITHIN (RubyLLM First);
@@ -13,9 +15,7 @@ module Insika
   # A schema is any dry-schema-compatible validator: `#call(value)` returning a
   # result that responds to `#success?` and `#errors` (dry-schema's own contract).
   # As a batteries-included default, a plain JSON Schema Hash (the interlingua the
-  # ToolDefinition already speaks) is accepted and validated by the zero-dependency
-  # Schema below — "config over convention": bring dry-schema for richer contracts,
-  # or hand a JSON Schema for the common case.
+  # ToolDefinition already speaks) is accepted and validated by JSONSchemer.
   module Workflow
     # Bundles a registered workflow's callable factory with its metadata (schemas +
     # description). Built lazily by WorkflowRegistry#definition — it does NOT resolve
@@ -74,13 +74,8 @@ module Insika
       end
     end
 
-    # Zero-dependency instance validator for a plain JSON Schema Hash, speaking the
-    # same safe subset (object/array/string/number/integer/boolean + enum) the
-    # ToolDefinition validates its parameters against. It implements the SAME
-    # `#call(value) -> result{#success?, #errors}` contract as dry-schema, so the
-    # Definition treats both uniformly. Not a full JSON Schema engine (no
-    # composition/$ref — the subset the insika supports everywhere); permissive on
-    # unknown keys (JSON Schema's additionalProperties default).
+    # JSON Schema validation with the same result contract as dry-schema.
+    # References may resolve within the supplied document, never over the network.
     class Schema
       # dry-schema-compatible result. `errors` is { "field.path" => ["message", …] }.
       Result = Data.define(:errors) do
@@ -104,66 +99,33 @@ module Insika
         end
 
         @json_schema = Insika::Coercion.deep_stringify(json_schema)
+        @validator = JSONSchemer.schema(@json_schema, ref_resolver: ->(uri) {
+          raise Insika::ValidationError, "external schema reference is not allowed: #{uri}"
+        })
       end
 
       def call(value)
-        Result.new(errors: collect(@json_schema, value, "").freeze)
-      end
-
-      private
-
-      # -> { path => [messages] }. Empty = valid.
-      def collect(schema, value, path)
-        type = schema["type"].to_s
-        return { key(path) => ["must be #{type}, got #{ruby_type(value)}"] } unless type.empty? || matches?(type, value)
-
         errors = {}
-        case type
-        when "object" then check_object(schema, value, path, errors)
-        when "array"  then check_array(schema, value, path, errors)
-        end
-        check_enum(schema, value, path, errors)
-        errors
-      end
-
-      def check_object(schema, value, path, errors)
-        props = schema["properties"] || {}
-        Array(schema["required"]).each do |name|
-          errors[key(join(path, name))] = ["is required"] unless value.key?(name.to_s) || value.key?(name.to_sym)
-        end
-        props.each do |name, subschema|
-          next unless value.key?(name.to_s) || value.key?(name.to_sym)
-
-          sub = value[name.to_s] || value[name.to_sym]
-          errors.merge!(collect(subschema || {}, sub, join(path, name)))
+        @validator.validate(Insika::Coercion.deep_stringify(value)).each do |error|
+          path = error["data_pointer"].split("/").drop(1).map { |part| part.gsub("~1", "/").gsub("~0", "~") }.join(".")
+          if error["type"] == "required"
+            error.fetch("details").fetch("missing_keys").each do |name|
+              (errors[join(path, name)] ||= []) << "is required"
+            end
+          else
+            message = case error["type"]
+                      when "object", "array", "string", "integer", "number", "boolean", "null"
+                        "must be #{error['type']}, got #{ruby_type(error['data'])}"
+                      when "enum" then "must be one of #{error['schema']['enum'].inspect}"
+                      else error["error"]
+                      end
+            (errors[path.empty? ? "(root)" : path] ||= []) << message
+          end
         end
+        Result.new(errors: errors.freeze)
       end
 
-      def check_array(schema, value, path, errors)
-        items = schema["items"]
-        return if items.nil?
-
-        value.each_with_index { |el, i| errors.merge!(collect(items, el, "#{join(path, i)}")) }
-      end
-
-      def check_enum(schema, value, path, errors)
-        return unless schema.key?("enum")
-
-        allowed = Array(schema["enum"])
-        errors[key(path)] = ["must be one of #{allowed.inspect}"] unless allowed.include?(value)
-      end
-
-      def matches?(type, value)
-        case type
-        when "object"  then value.is_a?(Hash)
-        when "array"   then value.is_a?(Array)
-        when "string"  then value.is_a?(String)
-        when "integer" then value.is_a?(Integer) && !value.is_a?(TrueClass) && !value.is_a?(FalseClass)
-        when "number"  then value.is_a?(Numeric) && !value.is_a?(TrueClass) && !value.is_a?(FalseClass)
-        when "boolean" then value == true || value == false
-        else true # unknown type in the schema -> do not block (permissive)
-        end
-      end
+      private
 
       def ruby_type(value)
         case value
@@ -179,7 +141,6 @@ module Insika
       end
 
       def join(path, segment) = path.empty? ? segment.to_s : "#{path}.#{segment}"
-      def key(path) = path.empty? ? "(root)" : path
     end
   end
 end

data/lib/insika.rb

@@ -45,6 +45,7 @@ require_relative "insika/cron"
 require_relative "insika/schedule"
 require_relative "insika/schedule_store"
 require_relative "insika/schedule_engine"
+require_relative "insika/model_registry"
 # the report destination — one record per run, no
 # versioning; the signing half of the sharing link (HMAC, no secret stored).
 require_relative "insika/artifact_store"
@@ -72,6 +73,7 @@ require_relative "insika/checkpoint"
 require_relative "insika/command"
 require_relative "insika/hooks"
 require_relative "insika/middleware"
+require_relative "insika/memory_trim"
 # Production edge: windowed counters + the rate-limit/cost
 # Middleware. Both inert until configured (nil/0 = off).
 require_relative "insika/usage_ledger"
@@ -85,9 +87,11 @@ require_relative "insika/tool_output_compressor"
 # lazily, like the Executor's create_chat.
 require_relative "insika/safety/corpus"
 require_relative "insika/safety/detectors"
+require_relative "insika/safety/prompt_echo"
 require_relative "insika/safety/safe_responses"
 require_relative "insika/safety/config"
 require_relative "insika/safety/moderator"
+require_relative "insika/safety/judge_moderator"
 require_relative "insika/safety/output_filter"
 require_relative "insika/safety/input_guardrail"
 require_relative "insika/safety/output_validator"
@@ -104,9 +108,11 @@ require_relative "insika/context/providers/skill"
 require_relative "insika/context/providers/skill_trigger"
 require_relative "insika/context/providers/tool_search"
 require_relative "insika/context/providers/memory"
+require_relative "insika/context/reranker"
 require_relative "insika/context/providers/knowledge"
 require_relative "insika/context/providers/session"
 require_relative "insika/context/providers/briefing"
+require_relative "insika/context/providers/pending_confirmation"
 # the cache-prefix hash chain + the per-agent cache-hit series.
 # Both are referenced by the Executor at runtime, so they load before it.
 require_relative "insika/prefix_fingerprint"
@@ -123,8 +129,11 @@ require_relative "insika/prompt_catalog"
 require_relative "insika/plugin"
 require_relative "insika/plugin/loader"
 require_relative "insika/store"
+require_relative "insika/stores/json_value"
 require_relative "insika/stores/memory"
+require_relative "insika/stores/turn_counter"
 require_relative "insika/stores/sqlite"
+require_relative "insika/stores/postgres"
 require_relative "insika/session_store"
 require_relative "insika/task_store"
 require_relative "insika/checkpoint_store"
@@ -147,6 +156,8 @@ require_relative "insika/skill_store"
 require_relative "insika/secret_masking"
 require_relative "insika/tool_store"
 require_relative "insika/tool_trace_store"
+require_relative "insika/llm_trace_store"
+require_relative "insika/model_metrics_store"
 require_relative "insika/tool_usage_report"
 require_relative "insika/context_trace_store"
 # the model-visible payload of one ask + its durable trace —
@@ -182,6 +193,8 @@ require_relative "insika/overlay_tool_registry"
 require_relative "insika/settings_store"
 require_relative "insika/llm_provider_store"
 require_relative "insika/llm_configurator"
+require_relative "insika/agent_defaults"
+require_relative "insika/kits"
 # LLM-first onboarding surface: serves start.md + models.json + the
 # public docs. Reads the settings/provider stores above at call-time (order is free).
 require_relative "insika/onboarding"
@@ -193,6 +206,7 @@ require_relative "insika/onboarding"
 require_relative "insika/evals/golden"
 require_relative "insika/evals/assertions"
 require_relative "insika/evals/judge"
+require_relative "insika/evals/moderator_compare"
 require_relative "insika/evals/pairwise"
 require_relative "insika/evals/runner"
 require_relative "insika/evals/report"
@@ -217,8 +231,6 @@ require_relative "insika/refinement/gate"
 # candidate format and the gate's Report shape, so it loads after both.
 require_relative "insika/refinement/panel"
 require_relative "insika/mcp_store"
-require_relative "insika/mcp_http_client"
-require_relative "insika/mcp_tool_ingestor"
 # require "ruby_llm/mcp" itself is LAZY, inside .for — this require_relative only
 # loads the thin factory (see spec/insika/load_guard_spec.rb).
 require_relative "insika/mcp_client"
@@ -257,6 +269,8 @@ require_relative "insika/commands/gate_refinement"
 require_relative "insika/commands/resolve_refinement"
 require_relative "insika/commands/write_golden"
 require_relative "insika/commands/update_settings"
+require_relative "insika/commands/write_kit"
+require_relative "insika/commands/delete_kit"
 require_relative "insika/commands/upsert_llm_provider"
 require_relative "insika/commands/delete_llm_provider"
 require_relative "insika/commands/issue_tenant_token"
@@ -278,6 +292,7 @@ require_relative "insika/commands/revoke_contact"
 # the report destination's Studio mutation — delete one artifact
 # (a bus command, like every Studio mutation).
 require_relative "insika/commands/delete_artifact"
+require_relative "insika/commands/review_guardrail_flag"
 # in-session compaction (RFC-0044) — the summarizer (pure, injected
 # ask) and the boundary math; the trigger lives in the Executor, the
 # persistence in SessionStore, the read path in the Session provider.
@@ -323,7 +338,6 @@ require_relative "insika/commands/write_data_tool"
 require_relative "insika/commands/delete_data_tool"
 require_relative "insika/commands/restore_data_tool"
 require_relative "insika/commands/import_tools"
-require_relative "insika/commands/import_mcp_tools"
 require_relative "insika/commands/refresh_mcp_tools"
 # the demo seed (OSS onboarding): one bundled agent + golden
 # set + the Seeder that populates every loop's stores at once, and its bus
@@ -344,6 +358,7 @@ require_relative "insika/loop_detector"
 require_relative "insika/turn_budget"
 require_relative "insika/balloon_splitter"
 require_relative "insika/turn_output"
+require_relative "insika/text_tool_call"
 require_relative "insika/turn_state"
 require_relative "insika/turn_timing"
 require_relative "insika/capability/resolved_tool"
@@ -352,6 +367,7 @@ require_relative "insika/spoken_transcript"
 require_relative "insika/tool_envelope"
 require_relative "insika/tool_assembly"
 require_relative "insika/chat_builder"
+require_relative "insika/shared_conversations"
 require_relative "insika/executor"
 require_relative "insika/shutdown"
 require_relative "insika/tick"