insika 0.2.0 → 0.3.0

data/lib/insika/wiring/graph.rb

@@ -45,6 +45,10 @@ module Insika
         pending_action_store = Insika::PendingActionStore.new(store: backend)
         delegation_store     = Insika::DelegationStore.new(store: backend)
         memory_store         = Insika::MemoryStore.new(store: backend)
+        # the append-only, content-free audit of OPERATOR memory
+        # mutations. Built unconditionally (empty and free when nothing writes)
+        # so a deployment that turns it on later finds its audit already durable.
+        memory_audit_store  = Insika::MemoryAuditStore.new(store: backend)
         token_store          = Insika::TokenStore.new(store: backend)
         budget_ledger        = Insika::BudgetLedger.new(store: backend)
         circuit_state        = Insika::CircuitState.new(store: backend)
@@ -54,11 +58,41 @@ module Insika
         # (they are empty and free when no channel is registered) so a deployment
         # that turns a channel on later finds its state already durable.
         outbox_store         = Insika::OutboxStore.new(store: backend)
+        # the shadow pair store — one durable record per mirrored
+        # exchange, written by our half and the incumbent's. Built unconditionally
+        # (empty and free when shadow is off) so turning it on later finds the
+        # state already durable, beside the outbox on the same runtime backend.
+        shadow_pair_store    = Insika::ShadowPairStore.new(store: backend)
         inbound_log          = Insika::InboundLog.new(store: backend)
+        # WS7: business outcomes per conversation, recorded by the operator or
+        # the integration (POST /v1/outcomes). Built unconditionally (empty and
+        # free when nothing records) so the Studio's scorecard always has a store.
+        outcome_store        = Insika::OutcomeStore.new(store: backend)
+        # the funnel's durable aggregates — per-day stage counts,
+        # fold cursors and baseline snapshots. Built unconditionally (empty and
+        # free when no pack declares a funnel) so the fold, the doctor and the
+        # Studio always have a store to read/write.
+        funnel_store        = Insika::FunnelStore.new(store: backend)
+        # the contact-state cells and the follow-up schedule
+        # records. Built unconditionally (empty and free when no pack declares
+        # followup) so the engine, the tools and the Studio always have stores.
+        contact_store       = Insika::ContactStore.new(store: backend)
+        followup_store      = Insika::FollowupStore.new(store: backend)
+        # the distilled proposals + the latched dedup ledger +
+        # the per-session markers. Built unconditionally (empty and free when
+        # no pack declares distill) so the wiki, the engine and the LGPD
+        # purges always have a store.
+        proposal_store      = Insika::ProposalStore.new(store: backend)
         # refinement RUNS (reports over real traffic). Runtime data,
         # same backend as sessions/tasks — the collector and the command that write it
         # are the root's business (deployment-only, like the memory commands).
         refinement_store     = Insika::RefinementStore.new(store: backend)
+        # the harvest's durable half — mining runs, the per-
+        # candidate lifecycle, the append-only promotion log, the snapshots
+        # and the per-session markers. Built unconditionally (empty and free
+        # when no pack declares harvest) so the engine, the Studio and the
+        # LGPD purges always have a store.
+        harvest_store        = Insika::HarvestStore.new(store: backend)
 
         code_tool_registry = Insika::ToolRegistry.new
         workflow_registry  = Insika::WorkflowRegistry.new
@@ -74,9 +108,17 @@ module Insika
           session_store: session_store, task_store: task_store,
           checkpoint_store: checkpoint_store, pending_action_store: pending_action_store,
           delegation_store: delegation_store,
-          memory_store: memory_store, refinement_store: refinement_store,
+          memory_store: memory_store, memory_audit_store: memory_audit_store,
+          refinement_store: refinement_store,
+          harvest_store: harvest_store,
           token_store: token_store, budget_ledger: budget_ledger, circuit_state: circuit_state,
-          outbox_store: outbox_store, inbound_log: inbound_log,
+          outbox_store: outbox_store, shadow_pair_store: shadow_pair_store,
+          inbound_log: inbound_log,
+          outcome_store: outcome_store,
+          funnel_store: funnel_store,
+          contact_store: contact_store,
+          followup_store: followup_store,
+          proposal_store: proposal_store,
           code_tool_registry: code_tool_registry,
           workflow_registry: workflow_registry, policy_registry: policy_registry,
           capability_registry: Insika::CapabilityRegistry.new, hooks: Insika::Hooks.new,
@@ -115,7 +157,8 @@ module Insika
         # only production exercises.
         channel_delivery = Insika::ChannelDelivery.new(
           channels: spine.channel_registry, outbox: spine.outbox_store,
-          session_store: spine.session_store, event_stream: spine.event_stream
+          session_store: spine.session_store, event_stream: spine.event_stream,
+          shadow_pairs: spine.shadow_pair_store
         )
 
 # WS3 provider reliability (retries/backoff/fallback/breaker) is ALWAYS wired —
@@ -135,23 +178,118 @@ module Insika
         delegation_store: spine.delegation_store, # async delegation durability
         channel_delivery: channel_delivery, # out-of-band reply delivery
         reliability: reliability, # WS3: retries/fallback/breaker (data-gated)
+        grounding_enforcer: guardrails.grounding_enforcer, # :enforce cut
+        # the follow-up stores — the ChatBuilder wires the
+        # schedule/cancel_followup tools on them (parity when no pack declares).
+        contact_store: spine.contact_store,
+        followup_store: spine.followup_store,
+        # 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),
         **executor_extra
       )
 
-        bus = build_core_bus(spine: spine, profiles: profiles, executor: executor)
+        # the ONE path that writes proposals, shared by the
+        # automatic DistillEngine loop and the bus command behind the Studio's
+        # "Run distillation now" button (one code path for both).
+        run_distillation = Insika::Commands::RunDistillation.new(
+          profiles: profiles, proposal_store: spine.proposal_store,
+          session_store: spine.session_store, memory_store: spine.memory_store,
+          settings_store: executor_extra[:settings_store],
+          event_stream: spine.event_stream
+        )
+
+        bus = build_core_bus(spine: spine, profiles: profiles, executor: executor,
+                             executor_extra: executor_extra, skill_catalog: skill_catalog,
+                             run_distillation: run_distillation)
 
         # the periodic tick (outbox drain + stale recovery sweep). Built
         # here, after the bus, because its recovery half dispatches resume_task
         # through it; handed to the Executor, which starts it as a child of the
         # turn supervisor in serving mode. `INSIKA_TICK_INTERVAL=0` disables.
+        # WS8 retention rides the tick: always built, the settings knob
+        # (`retention_days`) gates it — the base graph (no settings_store)
+        # reads as OFF.
         executor.tick = Insika::Tick.new(
           store: spine.backend, channel_delivery: channel_delivery,
           recovery: Insika::Recovery.new(
             task_store: spine.task_store, checkpoint_store: spine.checkpoint_store, command_bus: bus
           ),
+          retention: Insika::Retention.new(
+            store: spine.backend, session_store: spine.session_store,
+            task_store: spine.task_store, checkpoint_store: spine.checkpoint_store,
+            memory_store: spine.memory_store, outcome_store: spine.outcome_store,
+            tool_trace_store: executor_extra[:tool_trace_store],
+            context_trace_store: executor_extra[:context_trace_store],
+            # the model-visible traces die with their checkpoints.
+            model_visible_trace_store: Insika::ModelVisibleTraceStore.new(store: spine.backend),
+            outbox_store: spine.outbox_store,
+            shadow_pair_store: spine.shadow_pair_store,
+            settings_store: executor_extra[:settings_store],
+            budget_ledger: spine.budget_ledger, # WS2 counter GC (retention-independent)
+            funnel_store: spine.funnel_store, # fold dies with its source
+            followup_store: spine.followup_store, # records age out too
+            contact_store: spine.contact_store, # cells age out too
+            proposal_store: spine.proposal_store, # proposals age out too
+            harvest_store: spine.harvest_store # candidates/log/snapshots too
+          ),
           interval: tick_env("INSIKA_TICK_INTERVAL") || Insika::Tick::DEFAULT_INTERVAL,
           stale_after: tick_env("INSIKA_TICK_STALE_AFTER") || Insika::Tick::DEFAULT_STALE_AFTER
         )
+        # the tick-driven outcome fold — wired here, after the
+        # Tick, because it reads the outcome/funnel stores of the spine and the
+        # profiles; the per-pair declaration gates it (nil funnel everywhere =
+        # an inert fold). Always built: a pack that declares a funnel later
+        # finds its fold already on the tick.
+        executor.tick.funnel = Insika::FunnelFold.new(
+          outcome_store: spine.outcome_store, funnel_store: spine.funnel_store,
+          profiles: profiles, store: spine.backend
+        )
+        # the tick-driven follow-up firer — the tick's third
+        # duty, wired here after the Tick, gated by its own claim window.
+        # Always built: a pack that declares followup later finds its firer
+        # already on the tick (inert when no profile declares followup).
+        executor.tick.followup = Insika::FollowupEngine.new(
+          store: spine.backend, followup_store: spine.followup_store,
+          contact_store: spine.contact_store, task_store: spine.task_store,
+          profiles: profiles, executor: executor, event_stream: spine.event_stream
+        )
+        # 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).
+        # Always built: a pack that declares `distill:` later finds its engine
+        # already wired — and INERT until one does (the engine gates its start
+        # and its passes on a declaring profile).
+        executor.distill_engine = Insika::DistillEngine.new(
+          store: spine.backend, proposal_store: spine.proposal_store,
+          session_store: spine.session_store,
+          runner: run_distillation,
+          profiles: profiles,
+          window: Insika::DistillEngine::DEFAULT_WINDOW
+        )
+        # the harvest engine — the tick-duty that finds idle,
+        # unmined sessions whose agent declares `harvest.enabled` and mines
+        # them on its own worker fiber (a supervisor child, started in serving
+        # mode next to the tick). Always built: INERT until a profile declares
+        # harvest (the engine gates its start and its passes on data). The
+        # runner is the same RunHarvest the bus serves, so the manual CLI and
+        # the automated loop share one code path.
+        run_harvest = Insika::Commands::RunHarvest.new(
+          profiles: profiles, harvest_store: spine.harvest_store,
+          session_store: spine.session_store, task_store: spine.task_store,
+          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,
+          event_stream: spine.event_stream
+        )
+        executor.harvest_engine = Insika::HarvestEngine.new(
+          store: spine.backend, harvest_store: spine.harvest_store,
+          session_store: spine.session_store, runner: run_harvest,
+          profiles: profiles, window: Insika::HarvestEngine::DEFAULT_WINDOW
+        )
         # WS6 operator alerts: answers budget_warning / breaker_open /
         # delivery_failed per agent (`alerts.webhook`) via the outbox+claim
         # pipeline. Always wired — the per-agent data gates it (parity).
@@ -166,8 +304,16 @@ module Insika
           session_store: spine.session_store, task_store: spine.task_store,
           checkpoint_store: spine.checkpoint_store, pending_action_store: spine.pending_action_store,
           delegation_store: spine.delegation_store,
-          memory_store: spine.memory_store, refinement_store: spine.refinement_store,
-          outbox_store: spine.outbox_store, inbound_log: spine.inbound_log,
+          memory_store: spine.memory_store, memory_audit_store: spine.memory_audit_store,
+          refinement_store: spine.refinement_store,
+          harvest_store: spine.harvest_store,
+          outbox_store: spine.outbox_store, shadow_pair_store: spine.shadow_pair_store,
+          inbound_log: spine.inbound_log,
+          outcome_store: spine.outcome_store,
+          funnel_store: spine.funnel_store,
+          contact_store: spine.contact_store,
+          followup_store: spine.followup_store,
+          proposal_store: spine.proposal_store,
           token_store: spine.token_store, budget_ledger: spine.budget_ledger,
           circuit_state: spine.circuit_state,
           channel_registry: spine.channel_registry, channel_delivery: channel_delivery,
@@ -184,7 +330,8 @@ module Insika
       # The CORE command surface every root needs — turn essentials + the operator
       # controls (pause/approve) the Studio dispatches. Registering pause_task/
       # approve_action HERE is the crux of: it retires the config.ru:28-34 patch.
-      def build_core_bus(spine:, profiles:, executor:)
+      def build_core_bus(spine:, profiles:, executor:, executor_extra: {}, skill_catalog: nil,
+                         run_distillation: nil)
         bus = Insika::CommandBus.new
         bus.register(:create_session,
                      Insika::Commands::CreateSession.new(session_store: spine.session_store, event_stream: spine.event_stream))
@@ -198,7 +345,10 @@ module Insika
         bus.register(:send_message,
                      Insika::Commands::SendMessage.new(profiles: profiles, session_store: spine.session_store,
                                                         task_store: spine.task_store, executor: executor,
-                                                        inbound_log: spine.inbound_log))
+                                                        inbound_log: spine.inbound_log,
+                                                        contact_store: spine.contact_store,
+                                                        followup_store: spine.followup_store,
+                                                        store: spine.backend))
         bus.register(:resume_task,
                      Insika::Commands::ResumeTask.new(profiles: profiles, task_store: spine.task_store,
                                                        checkpoint_store: spine.checkpoint_store, executor: executor))
@@ -214,6 +364,135 @@ module Insika
         bus.register(:rotate_tenant_token,
                      Insika::Commands::RotateTenantToken.new(token_store: spine.token_store,
                                                              event_stream: spine.event_stream))
+        # WS7: a business outcome per conversation (operator or integration).
+        bus.register(:record_outcome,
+                     Insika::Commands::RecordOutcome.new(outcome_store: spine.outcome_store,
+                                                         event_stream: spine.event_stream))
+        # the incumbent's half of a shadow pair, one command behind
+        # both mirror shapes (the mirror call itself + the follow-up route).
+        bus.register(:record_shadow_reply,
+                     Insika::Commands::RecordShadowReply.new(shadow_pairs: spine.shadow_pair_store,
+                                                             event_stream: spine.event_stream))
+        # WS8 (LGPD): purge one customer's memory + the whole footprint of their
+        # sessions (traces, tasks, checkpoints, outbox). The trace stores are
+        # deployment components (nil at the base — skipped). the
+        # audit collaborator records a content-free purge line.
+        bus.register(:forget_customer,
+                     Insika::Commands::ForgetCustomer.new(
+                       memory_store: spine.memory_store, session_store: spine.session_store,
+                       tool_trace_store: executor_extra[:tool_trace_store],
+                       context_trace_store: executor_extra[:context_trace_store],
+                       # the model-visible traces die with the
+                       # checkpoints (the same SessionPurge list).
+                       model_visible_trace_store: Insika::ModelVisibleTraceStore.new(store: spine.backend),
+                       task_store: spine.task_store, checkpoint_store: spine.checkpoint_store,
+                       outbox_store: spine.outbox_store,
+                       shadow_pairs: spine.shadow_pair_store,
+                       audit_store: spine.memory_audit_store,
+                       followup_store: spine.followup_store,
+                       contact_store: spine.contact_store,
+                       proposal_store: spine.proposal_store,
+                       event_stream: spine.event_stream
+                     ))
+        # the LGPD access right — export one customer's memory
+        # cell as content (the Studio download); the event stays counts-only.
+        bus.register(:export_customer_memory,
+                     Insika::Commands::ExportCustomerMemory.new(
+                       memory_store: spine.memory_store, event_stream: spine.event_stream
+                     ))
+        # WS8 (LGPD): purge ONE TENANT's data — sessions and their footprint,
+        # memory cells and outcomes. Operator-only by construction (ingress).
+        bus.register(:delete_tenant_data,
+                     Insika::Commands::DeleteTenantData.new(
+                       memory_store: spine.memory_store, session_store: spine.session_store,
+                       tool_trace_store: executor_extra[:tool_trace_store],
+                       context_trace_store: executor_extra[:context_trace_store],
+                       # the model-visible traces die with the tenant.
+                       model_visible_trace_store: Insika::ModelVisibleTraceStore.new(store: spine.backend),
+                       outcome_store: spine.outcome_store,
+                       funnel_store: spine.funnel_store, # the fold dies with the tenant
+                       followup_store: spine.followup_store,
+                       contact_store: spine.contact_store,
+                       proposal_store: spine.proposal_store,
+                       harvest_store: spine.harvest_store,
+                       task_store: spine.task_store, checkpoint_store: spine.checkpoint_store,
+                       outbox_store: spine.outbox_store,
+                       shadow_pairs: spine.shadow_pair_store,
+                       token_store: spine.token_store, # revoked BEFORE the sweep
+                       event_stream: spine.event_stream
+                     ))
+        # the operator's baseline freeze — the number
+        # read. Synchronous control command, dispatched from the Studio.
+        bus.register(:freeze_funnel_baseline,
+                     Insika::Commands::FreezeFunnelBaseline.new(
+                       funnel_store: spine.funnel_store, profiles: profiles,
+                       event_stream: spine.event_stream
+                     ))
+        # the follow-up mutations — the Studio's Cancel button
+        # and the channel opt-out event (a tenant principal never reaches the
+        # generic command ingress; these ride the same operator-grade path).
+        bus.register(:cancel_followup,
+                     Insika::Commands::CancelFollowup.new(followup_store: spine.followup_store,
+                                                          event_stream: spine.event_stream))
+        bus.register(:revoke_contact,
+                     Insika::Commands::RevokeContact.new(contact_store: spine.contact_store,
+                                                         followup_store: spine.followup_store,
+                                                         store: spine.backend,
+                                                         event_stream: spine.event_stream))
+        # the human's answer on a distilled proposal — the ONLY
+        # mutation behind the Facts (wiki) page. Synchronous control command.
+        bus.register(:resolve_proposal,
+                     Insika::Commands::ResolveProposal.new(
+                       proposal_store: spine.proposal_store,
+                       memory_store: spine.memory_store,
+                       event_stream: spine.event_stream
+                     ))
+        #  /C10: the gated harvest — the mining pass, the double
+        # gate, the human's promote/rollback/dismiss. The BASE graph wires the
+        # nil factories (no eval surface, no criterion, no funnel): every flow
+        # refuses with a named reason or skips (parity). The deployment root
+        # re-registers with the real gate/criterion/negative list.
+        bus.register(:run_harvest,
+                     Insika::Commands::RunHarvest.new(
+                       profiles: profiles, harvest_store: spine.harvest_store,
+                       session_store: spine.session_store, task_store: spine.task_store,
+                       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,
+                       event_stream: spine.event_stream
+                     ))
+        bus.register(:gate_harvest,
+                     Insika::Commands::GateHarvest.new(
+                       harvest_store: spine.harvest_store, gate: nil,
+                       conversion_gate: nil, criterion: nil,
+                       event_stream: spine.event_stream
+                     ))
+        bus.register(:promote_harvest,
+                     Insika::Commands::PromoteHarvest.new(
+                       harvest_store: spine.harvest_store,
+                       skill_store: skill_catalog.store,
+                       skill_catalog: skill_catalog,
+                       profile_source: profiles, criterion: nil, conversion_gate: nil,
+                       event_stream: spine.event_stream
+                     ))
+        bus.register(:rollback_harvest,
+                     Insika::Commands::RollbackHarvest.new(
+                       harvest_store: spine.harvest_store,
+                       skill_store: skill_catalog.store,
+                       skill_catalog: skill_catalog,
+                       profile_source: profiles, event_stream: spine.event_stream
+                     ))
+        bus.register(:reject_harvest,
+                     Insika::Commands::RejectHarvest.new(
+                       harvest_store: spine.harvest_store, event_stream: spine.event_stream
+                     ))
+        # the ONE path that writes proposals, served to the
+        # Studio's "Run distillation now" button. The same instance the
+        # DistillEngine's loop uses, so the manual and the automatic share one
+        # code path; the engine keeps the automatic pass when the root does
+        # not pass a runner here (nil = the command is not on the bus).
+        bus.register(:run_distillation, run_distillation) if run_distillation
         bus
       end
 
@@ -221,9 +500,13 @@ module Insika
       # them to their historic public constants (SESSION_STORE, REGISTRY, ...).
       Spine = Struct.new(
         :backend, :event_stream, :session_store, :task_store, :checkpoint_store,
-        :pending_action_store, :delegation_store, :memory_store, :refinement_store,
-        :token_store, :budget_ledger, :circuit_state, :outbox_store, :inbound_log, :code_tool_registry,
-        :workflow_registry, :policy_registry, :capability_registry, :hooks,
+        :pending_action_store, :delegation_store, :memory_store, :memory_audit_store,
+        :refinement_store,
+        :harvest_store,
+        :token_store, :budget_ledger, :circuit_state, :outbox_store, :shadow_pair_store,
+        :inbound_log, :outcome_store, :funnel_store,
+        :contact_store, :followup_store, :proposal_store,
+        :code_tool_registry, :workflow_registry, :policy_registry, :capability_registry, :hooks,
         :channel_registry, keyword_init: true
       )
 
@@ -233,8 +516,12 @@ module Insika
       Result = Struct.new(
         :backend, :event_stream,
         :session_store, :task_store, :checkpoint_store, :pending_action_store, :delegation_store,
-        :memory_store, :refinement_store, :outbox_store, :inbound_log, :token_store,
-        :budget_ledger, :circuit_state, :channel_registry, :channel_delivery,
+        :memory_store, :memory_audit_store, :refinement_store, :outbox_store, :shadow_pair_store,
+        :inbound_log, :token_store,
+        :budget_ledger, :circuit_state, :outcome_store, :funnel_store,
+        :contact_store, :followup_store, :proposal_store,
+        :harvest_store,
+        :channel_registry, :channel_delivery,
         :code_tool_registry, :tool_registry, :workflow_registry, :policy_registry, :capability_registry,
         :tool_catalog, :skill_catalog, :prompt_catalog,
         :hooks, :guardrails, :middleware,

data/lib/insika.rb

@@ -2,12 +2,32 @@
 
 require_relative "insika/version"
 require_relative "insika/errors"
+# the payload selection + the domain-boundary audit yardstick.
+# Pure module — loaded by the gemspec too, so it carries no app requires.
+require_relative "insika/packaging"
 require_relative "insika/provider_error_classifier"
 require_relative "insika/token_store"
 require_relative "insika/budget_ledger"
 require_relative "insika/circuit_state"
 require_relative "insika/reliability"
+require_relative "insika/routing"
+require_relative "insika/media"
 require_relative "insika/alert_dispatcher"
+require_relative "insika/outcome_store"
+require_relative "insika/retention"
+require_relative "insika/funnel_declaration"
+require_relative "insika/funnel_store"
+require_relative "insika/funnel_fold"
+# the parsed follow-up policy of ONE agent — the ONLY shape the
+# engine accepts (tool/engine/doctor/Studio share it). Pure value object.
+require_relative "insika/followup_policy"
+# the contact-state cells and the follow-up schedule records.
+# Both are dumb domain stores over the injected backend.
+require_relative "insika/contact_store"
+require_relative "insika/followup_store"
+# the tick-driven firer — rides the same tick as retention/funnel.
+require_relative "insika/followup_engine"
+require_relative "insika/commands/freeze_funnel_baseline"
 require_relative "insika/channels/webhook"
 require_relative "insika/coercion"
 require_relative "insika/message_origin"
@@ -21,6 +41,9 @@ require_relative "insika/model_selection"
 require_relative "insika/model_resolver"
 require_relative "insika/tool_definition"
 require_relative "insika/tool_manifest"
+# the pack's grounding policy (Insika::Grounding + the
+# GroundingMatcher it wraps). Pure Ruby — profile data, parsed per turn.
+require_relative "insika/grounding"
 require_relative "insika/frontmatter"
 require_relative "insika/token_estimator"
 require_relative "insika/checkpoint"
@@ -33,9 +56,12 @@ require_relative "insika/usage_ledger"
 require_relative "insika/budget_ledger"
 require_relative "insika/edge_limiter"
 require_relative "insika/tool_output_compressor"
-# Content safety / guardrails. detectors.rb is self-contained (the eval
-# requires it directly); the rest hang off Middleware/hooks seams. No ruby_llm
-# at load-time — Factory requires the gem lazily, like the Executor's create_chat.
+# Content safety / guardrails. The pattern SOURCE is the
+# language-tagged data in safety/corpus.rb; detectors.rb compiles it. Both are
+# self-contained (the eval requires detectors.rb directly); the rest hang off
+# Middleware/hooks seams. No ruby_llm at load-time — Factory requires the gem
+# lazily, like the Executor's create_chat.
+require_relative "insika/safety/corpus"
 require_relative "insika/safety/detectors"
 require_relative "insika/safety/safe_responses"
 require_relative "insika/safety/config"
@@ -56,6 +82,11 @@ require_relative "insika/context/providers/skill_trigger"
 require_relative "insika/context/providers/tool_search"
 require_relative "insika/context/providers/memory"
 require_relative "insika/context/providers/session"
+require_relative "insika/context/providers/briefing"
+# 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"
+require_relative "insika/cache_series_store"
 require_relative "insika/policy/policy"
 require_relative "insika/policy/engine"
 require_relative "insika/registry"
@@ -78,8 +109,12 @@ require_relative "insika/delegation_store"
 # Channels: the outbound record + the inbound retry window. Both are
 # plain stores; the channel objects themselves come after the HTTP client.
 require_relative "insika/outbox_store"
+require_relative "insika/shadow_pair_store"
 require_relative "insika/inbound_log"
 require_relative "insika/memory_store"
+# the operator-mutation audit trail. After memory_store (no
+# mutual deps). Pure stdlib — `load_guard_spec` stays green.
+require_relative "insika/memory_audit_store"
 require_relative "insika/config_store"
 require_relative "insika/profile_source"
 require_relative "insika/agent_file_store"
@@ -88,6 +123,10 @@ require_relative "insika/secret_masking"
 require_relative "insika/tool_store"
 require_relative "insika/tool_trace_store"
 require_relative "insika/context_trace_store"
+# the model-visible payload of one ask + its durable trace —
+# "model-visible means logged" (the conformance suite's reconstruction half).
+require_relative "insika/model_visible"
+require_relative "insika/model_visible_trace_store"
 # Refinement: the run record + the evidence half of the loop.
 # Reads sessions/tasks/traces above; requires Safety::Detectors (loaded earlier) for
 # the PII redaction of the snippets it puts in a report.
@@ -101,6 +140,9 @@ require_relative "insika/refinement/candidate"
 require_relative "insika/refinement/proposer"
 require_relative "insika/egress_guard"
 require_relative "insika/schema_guard"
+# the evidence contract (Spec + Processor + EvidenceLedger). Pure Ruby.
+# Required BEFORE tool_envelope.rb — the envelope references it at runtime.
+require_relative "insika/evidence"
 require_relative "insika/sandbox"
 require_relative "insika/http_client"
 # Channels: the registry, the bundled relay adapter and the
@@ -130,6 +172,10 @@ require_relative "insika/evals/runner"
 require_relative "insika/evals/report"
 require_relative "insika/evals/baseline"
 require_relative "insika/evals/transport"
+# shadow parity: the frozen criterion and the mechanical
+# fold over the pair store (C6). Pure — no store, no provider gem.
+require_relative "insika/parity/criterion"
+require_relative "insika/parity/verdict"
 # Authored eval cases: the corpus becomes editable without a
 # checkout. Requires the loader above (it is the one validator).
 require_relative "insika/golden_store"
@@ -177,6 +223,42 @@ require_relative "insika/commands/delete_llm_provider"
 require_relative "insika/commands/issue_tenant_token"
 require_relative "insika/commands/revoke_token"
 require_relative "insika/commands/rotate_tenant_token"
+require_relative "insika/commands/record_outcome"
+require_relative "insika/commands/record_shadow_reply"
+require_relative "insika/commands/judge_shadow_pairs"
+require_relative "insika/commands/session_purge"
+require_relative "insika/commands/forget_customer"
+require_relative "insika/commands/delete_tenant_data"
+# the LGPD access right — export one customer's memory cell as
+# content (the Studio download); the event stays counts-only.
+require_relative "insika/commands/export_customer_memory"
+# the operator/integration follow-up mutations (cancel one
+# record; revoke a contact + fall its pending records atomically).
+require_relative "insika/commands/cancel_followup"
+require_relative "insika/commands/revoke_contact"
+# session distillation — the distiller (pure, injected ask)
+# and the proposal store (proposals + the latched dedup ledger + the
+# per-session distilled marker).
+require_relative "insika/distill"
+require_relative "insika/proposal_store"
+require_relative "insika/commands/run_distillation"
+require_relative "insika/distill_engine"
+require_relative "insika/commands/resolve_proposal"
+# the gated harvest — the miner (pure, injected ask), the
+# frozen conversion criterion and the versioned negative list. The provider
+# touch stays inside MinerFactory's lazy ask (load_guard stays green).
+require_relative "insika/harvest"
+require_relative "insika/harvest/criterion"
+require_relative "insika/harvest/negative_list"
+require_relative "insika/harvest/conversion_gate"
+require_relative "insika/harvest/gate"
+require_relative "insika/harvest_store"
+require_relative "insika/commands/run_harvest"
+require_relative "insika/commands/gate_harvest"
+require_relative "insika/commands/promote_harvest"
+require_relative "insika/commands/rollback_harvest"
+require_relative "insika/commands/reject_harvest"
+require_relative "insika/harvest_engine"
 require_relative "insika/commands/upsert_mcp"
 require_relative "insika/commands/delete_mcp"
 require_relative "insika/commands/write_system_file"
@@ -195,6 +277,7 @@ require_relative "insika/skill_catalog"
 require_relative "insika/tool_catalog"
 require_relative "insika/steer_injector"
 require_relative "insika/loop_detector"
+require_relative "insika/balloon_splitter"
 require_relative "insika/turn_output"
 require_relative "insika/turn_state"
 require_relative "insika/turn_timing"
@@ -211,6 +294,12 @@ require_relative "insika/telemetry"
 # Strict config + diagnosis. Doctor reads the config stores above;
 # EnvSchema (required at the top) is its env layer.
 require_relative "insika/doctor"
+# Soak: the 72h uptime-degradation harness. Pure stdlib — the
+# envelope and the report fold are deterministic, the runner only talks Net::HTTP.
+require_relative "insika/soak/envelope"
+require_relative "insika/soak/report"
+require_relative "insika/soak/runner"
+require_relative "insika/vitals"
 # Shared composition core for both roots (config/wiring.rb + config/deployment.rb).
 # Only references the classes above at call-time, so require order is unconstrained.
 require_relative "insika/wiring/graph"