insika 0.8.0 → 1.0.1

data/lib/insika/dsl.rb

@@ -122,13 +122,13 @@ module Insika
       # `agent { }` block that needs it instead, where `Builder#mcp` auto-adds
       # "mcp:<name>" to THAT agent's `tools_allow_groups` (below).
       def mcp(name, transport: nil, command: nil, args: nil, url: nil,
-              headers: nil, env: nil, description: nil, enabled: true)
+              headers: nil, env: nil, description: nil, enabled: true, tools: nil)
         n = name.to_s
         raise ArgumentError, "duplicate mcp instance in system: #{n}" if @mcp_instances.any? { |m| m[:name] == n }
 
         @mcp_instances << { name: n, transport: transport&.to_s, command: command, args: args,
                              url: url, headers: headers, env: env, description: description,
-                             enabled: enabled }
+                             enabled: enabled, tools: tools }
         n
       end
     end
@@ -251,20 +251,22 @@ module Insika
       # gives its own tool name; `deny_tools` has no group-string equivalent
       # yet, so a whole MCP group cannot be denied by name today.
       def mcp(name, transport: nil, command: nil, args: nil, url: nil,
-              headers: nil, env: nil, description: nil, enabled: true)
+              headers: nil, env: nil, description: nil, enabled: true, tools: nil)
         n = name.to_s
         raise ArgumentError, "duplicate mcp instance in agent: #{n}" if @mcp_instances.any? { |m| m[:name] == n }
 
         @mcp_instances << { name: n, transport: transport&.to_s, command: command, args: args,
                              url: url, headers: headers, env: env, description: description,
-                             enabled: enabled }
+                             enabled: enabled, tools: tools }
         group = "mcp:#{n}"
         (@config[:tools_allow_groups] ||= []) << group unless Array(@config[:tools_allow_groups]).include?(group)
         n
       end
 
       # --- knobs -----------------------------------------------------------
+      def shared_conversations(on = true) = @config[:shared_conversations] = on
       def memory(on = true) = @config[:memory] = on
+      def memory_retrieval(hash) = (@config[:memory_retrieval] ||= {}).merge!(hash.transform_keys(&:to_s))
 
       # Spend caps per calendar window (WS2): daily/monthly token budgets for
       # this agent, per (tenant, agent) when multi-tenant. HARD is the default:
@@ -403,7 +405,7 @@ module Insika
       # the transcriber should expect on THIS agent's voice notes — passed
       # straight through to the Whisper-family provider's `prompt:`. Falls
       # back to INSIKA_STT_PROMPT (deployment default) when unset.
-      #   stt_prompt "Ocean Drop, tênis, boné trucker, chinelo"
+      #   stt_prompt "Acme Surf, tênis, boné trucker, chinelo"
       def stt_prompt(text) = @config[:stt_prompt] = text.to_s
 
       # The engine's "Tool discipline" block in the system prompt (retry a
@@ -417,6 +419,18 @@ module Insika
       # SEES: repeated identical tool results collapse to a back-reference.
       def tool_output_compression(on = true) = @config[:tool_output_compression] = on
 
+      # Third-party text is sanitized before the model reads it (tool results,
+      # memory, knowledge) and a one-sentence notice names those blocks as data.
+      # Opt-in this release — the goldens were baselined on unfenced bytes:
+      #   fencing true
+      def fencing(on = true) = @config[:fencing] = on
+
+      # Tools the CUSTOMER confirms. The call is held, the reply asks, and the
+      # next message decides through confirm_pending / cancel_pending. Unlike an
+      # operator approval the turn ENDS instead of suspending.
+      #   customer_confirm "create_order"
+      def customer_confirm(*names) = @config[:customer_confirm] = names.flatten.map(&:to_s)
+
       # Content-safety guardrails — opt-in and configurable per agent.
       # Pure config-over-code: the hash is stored on the profile and consumed by
       # Safety::Config.from_profile. Merges, so repeated calls accumulate.

data/lib/insika/edge_limiter.rb

@@ -57,7 +57,7 @@ module Insika
       @event_stream = event_stream
     end
 
-    def call(state, &nxt)
+    def call(state, prepare: nil, &nxt)
       edge = platform_edge
       limits = state.profile.limits || {}
       # A resume (crash/pause recovery) re-enters the pipeline for a turn that was
@@ -100,9 +100,12 @@ module Insika
       # turn  rides the same rule: the follow-up policy is the
       # volume control, not the budget wall.
       budget_on = budget_configured?(state)
-      budget_enforce(state) unless resumed || scheduled
+      budget_notes = []
+      budget_enforce(state, notes: budget_notes) unless resumed || scheduled
 
       result = begin
+        prepare&.call(state)
+        budget_notes.each { |note| inject_budget_note(state, note) }
         nxt.call(state)
       ensure
         # A turn that FAILED after burning tokens still SPENT them: record the
@@ -154,14 +157,22 @@ module Insika
     # blind. Same billed-spend rule as `Evals::Runner#billed_tokens`.
     # nil usage (workflow turn / provider without counts) records nothing.
     def record_usage(state, window)
-      usage = state.usage || {}
-      tokens = usage[:total_tokens].to_i + usage[:cached_tokens].to_i +
-               usage[:cache_creation_tokens].to_i
+      tokens = billed_tokens(state)
       return if tokens.zero?
 
       @ledger.add(TOKENS_KIND, state.profile.id.to_s, window: window, by: tokens)
     end
 
+    # Native rerank counts remain separate from chat usage and retain unknown
+    # fields. Only reported token buckets contribute to spend enforcement.
+    def billed_tokens(state)
+      usage = state.usage || {}
+      usage[:total_tokens].to_i + usage[:cached_tokens].to_i + usage[:cache_creation_tokens].to_i +
+        Array(state.rerank_usage).sum do |entry|
+          %w[input_tokens output_tokens cache_read_tokens cache_write_tokens].sum { |key| entry[key].to_i }
+        end
+    end
+
     # Graceful halt: safe reply + audit metadata, short-circuit (no nxt).
     # `detail` carries only ids/counters — never message content.
     def block(state, edge, category:, detail:)
@@ -187,7 +198,7 @@ module Insika
 
     # -> truthy (the budget hash) when budget checks ran. Raises BudgetExceeded
     # on a HARD cap breach.
-    def budget_enforce(state, now: Time.now)
+    def budget_enforce(state, notes:, now: Time.now)
       budget = state.profile.respond_to?(:budget) ? state.profile.budget : nil
       return nil if budget.nil? || @budget_ledger.nil?
 
@@ -202,9 +213,9 @@ module Insika
               retry_after: @budget_ledger.reset_in(w[:window], now: now)
             )
           end
-          warn_budget(state, tenant, agent, w, spent, now, level: "cap")
+          warn_budget(state, tenant, agent, w, spent, now, level: "cap", notes: notes)
         elsif spent >= w[:alert_at]
-          warn_budget(state, tenant, agent, w, spent, now, level: "alert_at")
+          warn_budget(state, tenant, agent, w, spent, now, level: "alert_at", notes: notes)
         end
       end
       budget
@@ -240,10 +251,9 @@ module Insika
     # (window) cell: the `alert_at` crossing and the real soft-cap crossing are
     # separate markers, so the cap event is never swallowed by the 80% one that
     # fired earlier (WS2).
-    def warn_budget(state, tenant, agent, w, spent, now, level:)
-      inject_budget_note(state,
-                         "[budget: agent '#{agent}' is at #{spent}/#{w[:cap]} tokens this " \
-                         "#{w[:window]} window — keep this turn cheap]")
+    def warn_budget(state, tenant, agent, w, spent, now, level:, notes:)
+      notes << "[budget: agent '#{agent}' is at #{spent}/#{w[:cap]} tokens this " \
+               "#{w[:window]} window — keep this turn cheap]"
       return if @budget_ledger.mark_alert(tenant: tenant, agent: agent, window: w[:window],
                                           level: level, now: now)
 
@@ -263,12 +273,15 @@ module Insika
 
     # Appends the note to the assembled system prompt: the real Data package is
     # immutable (with), the specs' minimal Struct is mutable — both duck-typed.
+    # The note is per-turn data, so it also lands in the volatile layer — below
+    # the cache breakpoint, never inside the cached identity prefix.
     def inject_budget_note(state, note)
       ctx = state.context
       return if ctx.nil?
 
       if ctx.respond_to?(:with)
-        state.context = ctx.with(system: "#{ctx.system}\n\n#{note}")
+        volatile = [ctx.system_volatile, note].reject { |s| s.to_s.empty? }.join("\n\n")
+        state.context = ctx.with(system: "#{ctx.system}\n\n#{note}", system_volatile: volatile)
       elsif ctx.respond_to?(:system=)
         ctx.system = "#{ctx.system}\n\n#{note}"
       end
@@ -277,9 +290,7 @@ module Insika
     # The turn's REAL billed spend (input + output + cached + cache_creation —
     # the A4 rule) on the calendar windows.
     def record_budget_usage(state, now: Time.now)
-      usage = state.usage || {}
-      tokens = usage[:total_tokens].to_i + usage[:cached_tokens].to_i +
-               usage[:cache_creation_tokens].to_i
+      tokens = billed_tokens(state)
       return if tokens.zero?
 
       @budget_ledger.add(tenant: budget_tenant(state), agent: state.profile.id.to_s,

data/lib/insika/egress_guard.rb

@@ -31,7 +31,11 @@ module Insika
     module_function
 
     # -> nil (allowed) | String (block reason).
-    def violation(url, allow_http: false, host_allowlist: nil, allow_private: false)
+    #
+    # `pin_private_only:` applies the allowlist to private destinations only, for
+    # a URL the operator fixed and the model cannot shape (an MCP server): a
+    # public host passes, a private one still needs allow_private AND the list.
+    def violation(url, allow_http: false, host_allowlist: nil, allow_private: false, pin_private_only: false)
       uri = begin
         URI.parse(url.to_s)
       rescue URI::InvalidURIError
@@ -43,13 +47,17 @@ module Insika
 
       host = uri.host
       return "missing host" if host.nil? || host.empty?
-      return "host not in allowlist" if host_allowlist && !host_allowlist.include?(host)
+      listed = host_allowlist.nil? || host_allowlist.include?(host)
+      return "host not in allowlist" unless listed || pin_private_only
 
       addrs = resolve(host)
       return "host did not resolve" if addrs.empty?
+      return nil unless addrs.any? { |ip| blocked?(ip) }
+
       # allow_private skips the private-network block (trusted internal API,
       # Without it, a private/loopback/metadata target is always blocked.
-      return "private-network destination blocked" if !allow_private && addrs.any? { |ip| blocked?(ip) }
+      return "private-network destination blocked" unless allow_private
+      return "host not in allowlist" unless listed
 
       nil
     end

data/lib/insika/env_schema.rb

@@ -9,7 +9,7 @@ module Insika
   #   · `validate(env)` — returns structured Findings: a value that fails its type
   #     (INSIKA_PORT=abc), an UNKNOWN key inside a namespace the engine owns
   #     (INSIKA_EGRES_ALLOW_HTTP — a typo the runtime would otherwise ignore in
-  #     silence), and a DEPRECATED legacy key still set under the old HARNESS_ prefix.
+  #     silence), and a REMOVED legacy key still set under the old HARNESS_ prefix.
   #     Unknown-key detection is scoped to the OWNED prefixes only, so the platform's
   #     own vars (Railway's RAILWAY_*, PORT, PATH, the litestream sidecar's
   #     LITESTREAM_*, the deployment's DEEPSEEK_*/CONSUMER_*) are never flagged.
@@ -19,12 +19,10 @@ module Insika
   #     RAISES ConfigError only when strictness is on (INSIKA_CONFIG_STRICT truthy,
   #     or `strict: true`).
   #
-  # RENAME (env pass 2): the engine's owned prefix is now INSIKA_. The old HARNESS_
-  # names still work — `reconcile_legacy!` backfills INSIKA_* from any HARNESS_* alias
-  # at boot (new name wins), and `read` gives the same dual-read to the self-contained
-  # readers (Telemetry, TurnTiming, SubagentGraph) that receive an env hash directly.
-  # A legacy name in use surfaces as a `:deprecated` warning (never fatal) so operators
-  # get a clear "rename to INSIKA_*" without a broken boot.
+  # RENAME: the engine's owned prefix is INSIKA_. The old HARNESS_ names were removed
+  # in 1.0 and are no longer read. HARNESS_ stays an OWNED prefix only so a forgotten
+  # legacy name is reported (`:removed`, an error) instead of ignored in silence — a
+  # stale HARNESS_DB would otherwise boot the engine on the ephemeral memory backend.
   #
   # Insika::Doctor reuses `validate` for its `env:*` checks; the boot roots call
   # `enforce!`. A deployment layers its own keys on via `extra:` (see
@@ -66,13 +64,13 @@ module Insika
       def to_h = { "key" => key, "kind" => kind.to_s, "severity" => severity.to_s, "message" => message }
     end
 
-    # The engine's owned prefix and its deprecated predecessor.
+    # The engine's owned prefix and its removed predecessor.
     PREFIX = "INSIKA_"
     LEGACY_PREFIX = "HARNESS_"
 
     # Prefixes the engine fully OWNS: an unknown key under one of these is a typo, not
-    # a foreign var. INSIKA_ (current) and HARNESS_ (legacy, still honored during the
-    # deprecation window). Deliberately NOT OPENCLAW_ (the OpenClaw gateway product
+    # a foreign var. INSIKA_ (current) and HARNESS_ (removed in 1.0, reported so it is
+    # not silently ignored). Deliberately NOT OPENCLAW_ (the OpenClaw gateway product
     # sets its own OPENCLAW_HOME/_STATE_DIR/… on the same host; the engine reads none
     # of them), nor LITESTREAM_ (the sidecar owns it), nor OTEL_ (the OpenTelemetry
     # SDK owns its env).
@@ -95,19 +93,26 @@ module Insika
     # The engine's own keys. Deployment/app keys (DEEPSEEK_*, CONSUMER_*, …) are NOT
     # here — a root passes them as `extra:`.
     DEFAULT = [
+      spec(name: "INSIKA_DATABASE_URL", type: :string, secret: true, description: "Postgres URL for the store (postgres://...). Set, it replaces INSIKA_DB: N workers write without SQLite's single file lock. Needs the pg gem."),
+      spec(name: "INSIKA_DATABASE_POOL", type: :integer, description: "Postgres connections per process (default 10)."),
       spec(name: "INSIKA_DB", type: :path, description: "SQLite path; durable config+state. Unset -> ephemeral memory."),
       spec(name: "INSIKA_BIND", description: "Bind address for the transport server."),
       spec(name: "INSIKA_PORT", type: :integer, description: "Port for the transport server."),
+      spec(name: "INSIKA_CONVERSATIONS_URL", type: :url, description: "Required central history URL for shared_conversations profiles."),
+      spec(name: "INSIKA_CONVERSATIONS_TOKEN", secret: true, description: "Scoped central history bearer token."),
       spec(name: "INSIKA_PUBLIC_URL", type: :url, description: "Public base URL (A2A agent card, links)."),
       spec(name: "INSIKA_ENV", description: "Environment name shown in the Studio (falls back to RACK_ENV)."),
       spec(name: "INSIKA_A2A_AGENT", description: "Agent id to expose over inbound A2A (opt-in)."),
       spec(name: "INSIKA_A2A_REMOTES", type: :csv, description: "Comma-separated remote A2A endpoints."),
       spec(name: "INSIKA_EGRESS_ALLOW_HTTP", type: :boolean, description: "Allow plain http egress from data-tools, channel callbacks and media fetches (default: https only)."),
       spec(name: "INSIKA_EGRESS_ALLOW_PRIVATE", type: :boolean, description: "Allow egress to private/loopback ranges (SSRF guard off)."),
-      spec(name: "INSIKA_EGRESS_HOSTS", type: :csv, description: "Comma-separated host allowlist for data-tool egress (media fetches are NOT pinned by it)."),
+      spec(name: "INSIKA_EGRESS_HOSTS", type: :csv, description: "Comma-separated host allowlist for data-tool egress (media fetches are NOT pinned by it; MCP servers only when they resolve to a private address)."),
       spec(name: "INSIKA_OTEL", type: :boolean, description: "Turn on OpenTelemetry export (opt-in)."),
+      spec(name: "INSIKA_MODEL_REFRESH_HOURS", type: :integer, description: "Hours between refreshes of RubyLLM's model catalog (ids, prices), kept in the store and shared by every worker. Default 24; 0 disables (the gem's bundled catalog stays)."),
       spec(name: "INSIKA_MODEL_PRICING", description: "JSON rates table (USD per million tokens) for the estimated-cost attribute; unset -> no cost reported."),
-      spec(name: "INSIKA_TURN_TIMING", type: :boolean, description: "Emit per-turn TTFB breakdown in responses (opt-in)."),
+      spec(name: "INSIKA_SLOW_STORE_MS", type: :integer, description: "Log every SQLite store call that takes at least this many ms, with its caller (off when unset)."),
+      spec(name: "INSIKA_MODEL_VISIBLE_TRACES", type: :boolean, description: "Record the full model request per turn (model_visible_traces). Default on; 0 stops the write (heavy on SQLite)."),
+      spec(name: "INSIKA_TURN_TIMING", type: :boolean, description: "Expose the per-turn TTFB breakdown in responses (opt-in; Studio always records it)."),
       spec(name: "INSIKA_SUBAGENT_DEPTH_CAP", type: :integer, description: "Max delegation depth in the subagent graph (default 5)."),
       spec(name: "INSIKA_SUBAGENT_FANOUT_CAP", type: :integer, description: "Max parallel children in spawn_subagents (default 8)."),
       spec(name: "INSIKA_ARTIFACT_SIGNING_KEY", secret: true, description: "HMAC key for signed artifact links (INSIKA_ARTIFACT_SIGNING_TTL). Unset -> no signed artifact surface."),
@@ -139,6 +144,8 @@ module Insika
       spec(name: "INSIKA_ROUTER_BACKEND_PORT", type: :integer, description: "the engine port on every DNS-resolved backend pod (required with INSIKA_ROUTER_BACKENDS_DNS)."),
       spec(name: "INSIKA_ROUTER_DNS_INTERVAL", type: :integer, description: "seconds between `insika-router` DNS re-resolves (default 15)."),
       spec(name: "INSIKA_ROUTER_BODY_MAX_BYTES", type: :integer, description: "size cap `insika-router` will parse looking for a session key before falling back to round-robin (default 262144; never bounds what is forwarded)."),
+      spec(name: "INSIKA_WORKERS", type: :integer, description: "Engine processes behind the session-sticky `insika-router` in one container (deploy/workers.sh). Unset or 1 = one process, no router."),
+      spec(name: "INSIKA_WORKER_BASE_PORT", type: :integer, description: "First local port for the INSIKA_WORKERS processes (default 9300)."),
       spec(name: "INSIKA_ROUTER_BACKEND_TIMEOUT", type: :integer, description: "`insika-router`'s connect/read timeout to a backend, in seconds (default 10)."),
       spec(name: "INSIKA_ROUTER_HOST", description: "bind address for `insika-router` itself (default 0.0.0.0)."),
       spec(name: "INSIKA_ROUTER_PORT", type: :integer, description: "listen port for `insika-router` itself (default 9090)."),
@@ -150,54 +157,12 @@ module Insika
       spec(name: "OTEL_SERVICE_NAME", description: "Service name for OTEL spans (default: insika).")
     ].freeze
 
-    # -- dual-read (rename compat) -------------------------------------
-
-    # HARNESS_X -> INSIKA_X for the deprecated alias of a canonical key; nil if `name`
-    # is not an INSIKA_ key.
-    def legacy_alias(name)
-      s = name.to_s
-      s.start_with?(PREFIX) ? LEGACY_PREFIX + s[PREFIX.length..] : nil
-    end
-
-    # The current (canonical) name for any owned key: HARNESS_X -> INSIKA_X; an INSIKA_
-    # key or any non-owned key is returned unchanged.
-    def canonical(name)
-      s = name.to_s
-      s.start_with?(LEGACY_PREFIX) ? PREFIX + s[LEGACY_PREFIX.length..] : s
-    end
-
     def legacy?(name) = name.to_s.start_with?(LEGACY_PREFIX)
     def owned?(name) = OWNED_PREFIXES.any? { |p| name.to_s.start_with?(p) }
 
-    # Reads a canonical INSIKA_* key, falling back to the deprecated HARNESS_* alias
-    # (new name wins). For the self-contained readers that get an env hash directly and
-    # so never see `reconcile_legacy!`'s process-wide backfill. -> value | nil.
-    def read(canonical_name, env = ENV)
-      value = env[canonical_name]
-      return value if present?(value)
-
-      (legacy = legacy_alias(canonical_name)) ? env[legacy] : value
-    end
-
-    # BOOT backfill: copies every still-set HARNESS_* var to its INSIKA_* name (new name
-    # wins if both are set) so the process ENV speaks the new names before any read.
-    # Generic (not schema-bound) so plugin/deployment HARNESS_* keys migrate too. WARNS
-    # once with the migrated list. -> [migrated legacy names]. Idempotent.
-    def reconcile_legacy!(env = ENV, warn: method(:default_warn))
-      migrated = env.keys.map(&:to_s).select { |k| k.start_with?(LEGACY_PREFIX) }.sort.each_with_object([]) do |legacy, acc|
-        canonical = PREFIX + legacy[LEGACY_PREFIX.length..]
-        next if present?(env[canonical]) # the new name already wins
-        next if env[legacy].nil?
-
-        env[canonical] = env[legacy]
-        acc << legacy
-      end
-      unless migrated.empty?
-        warn.call("deprecation: #{migrated.join(', ')} — HARNESS_* env vars are renamed to INSIKA_*; " \
-                  "honored via the new names this run, please update your environment (legacy names removed in a future release)")
-      end
-      migrated
-    end
+    # Reads an INSIKA_* key from `env`. The single reader for the self-contained
+    # readers (Telemetry, TurnTiming, SubagentGraph) that get an env hash directly.
+    def read(name, env = ENV) = env[name]
 
     # -- validation ----------------------------------------------------
 
@@ -208,33 +173,28 @@ module Insika
       findings = []
 
       # VALUE + required checks over the KNOWN specs (owned or not — DEEPSEEK_API_KEY
-      # is not prefixed). Dual-read: the canonical name wins, the legacy alias is honored.
+      # is not prefixed).
       specs.each_value do |s|
-        legacy = legacy_alias(s.name)
-        set_name = if env.key?(s.name) then s.name
-                   elsif legacy && env.key?(legacy) then legacy
-                   end
-
-        if set_name.nil?
+        unless env.key?(s.name)
           findings << Finding.new(key: s.name, kind: :missing_required, severity: :error,
                                   message: "#{s.name} is required (unset)") if s.required?
           next
         end
 
-        msg = s.error_for(env[set_name])
-        findings << Finding.new(key: set_name, kind: :invalid, severity: :error, message: "#{set_name} #{msg}") if msg
+        msg = s.error_for(env[s.name])
+        findings << Finding.new(key: s.name, kind: :invalid, severity: :error, message: "#{s.name} #{msg}") if msg
       end
 
-      # OWNED-PREFIX scan: a legacy alias of a known key is DEPRECATED (warn); any other
-      # owned key with no matching spec is UNKNOWN (a typo the runtime would ignore).
+      # OWNED-PREFIX scan: a HARNESS_ key is REMOVED (no longer read); any other owned
+      # key with no matching spec is UNKNOWN (a typo the runtime would ignore).
       env.each_key do |raw|
         key = raw.to_s
         next unless owned?(key)
 
-        if legacy?(key) && specs.key?(canonical(key))
-          findings << Finding.new(key: key, kind: :deprecated, severity: :warn,
-                                  message: "#{key} is deprecated — rename to #{canonical(key)}")
-        elsif !specs.key?(canonical(key)) && !specs.key?(key)
+        if legacy?(key)
+          findings << Finding.new(key: key, kind: :removed, severity: :error,
+                                  message: "#{key} was removed in 1.0 and is ignored — rename to #{PREFIX}#{key.delete_prefix(LEGACY_PREFIX)}")
+        elsif !specs.key?(key)
           findings << Finding.new(key: key, kind: :unknown, severity: :error,
                                   message: "#{key} is not a known config key (typo? unknown key in an owned namespace)")
         end
@@ -248,7 +208,7 @@ module Insika
 
     # BOOT GATE. Validates the environment, WARNS every finding via `warn` (a callable
     # taking a String), and RAISES ConfigError only when strict. `strict` defaults to
-    # the INSIKA_CONFIG_STRICT flag (HARNESS_CONFIG_STRICT still honored). -> [Finding]
+    # the INSIKA_CONFIG_STRICT flag. -> [Finding]
     # (also on the happy path). The root keeps booting on warnings (last-known-good).
     def enforce!(env = ENV, extra: [], strict: nil, warn: method(:default_warn))
       strict = truthy?(read("INSIKA_CONFIG_STRICT", env)) if strict.nil?

data/lib/insika/errors.rb

@@ -8,6 +8,7 @@ module Insika
 
   class ValidationError < Error; end  # Malformed Command -> HTTP 422, no Task created
   class NotFoundError   < Error; end  # nonexistent session/task/agent -> HTTP 404
+  class ConflictError   < Error; end  # the write contradicts state that already exists -> HTTP 409
 
   # Policy Engine denied -> :policy_denied event, task :failed
   class PolicyDenied < Error