insika 0.0.1 → 0.2.0

data/lib/insika/skill_catalog.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Insika
+  # OpenClaw / AgentSkills convention: each skill is a directory with a
+  # SKILL.md (YAML frontmatter + markdown body). Progressive disclosure:
+  # level 1 = name+description in the system prompt; level 2 = body loaded
+  # on demand by the load_skill tool.
+  #
+  # Consumed by the Executor (skill_catalog:) and by stage 3
+  # (effective/format_for_prompt).
+  class SkillCatalog
+    # Eagerness is NOT here. It used to be a frontmatter flag, i.e. a property of the
+    # SKILL — but skills are shared between agents, so one flag forced one decision
+    # onto every allowlist holding the skill. It is a property of the AGENT
+    # (`profile.skills_eager`, see #eager_for).
+    #
+    # companions: names of the skills this one cannot work without. Injecting or
+    # loading a skill brings them along, so the half-recipe state cannot be assembled —
+    # a reference table arriving without the procedure that reads it is worse than
+    # nothing, because the model then never asks for the other half.
+    Skill = Data.define(:name, :description, :path, :body, :triggers, :companions)
+
+    # roots ordered by PRECEDENCE (highest first): workspace, managed,
+    # bundled. Same name in more than one root: the first wins.
+    #
+    # store (optional): a SkillStore with the skills AUTHORED in the Studio.
+    # They overlay the on-disk ones (seed) — the Store wins, it is the source of truth.
+    # Nil = disk-only behavior, zero regression.
+    def initialize(roots, store: nil)
+      @roots = Array(roots)
+      @store = store
+      @skills, @agent_skills = load_all
+    end
+
+    # `agent` (an agent id) resolves the AGENT SCOPE first, then the shared one — the
+    # same precedence chain the catalog already runs for store-over-disk and
+    # workspace-over-managed-over-bundled, with one more dimension.
+    #
+    # Three cases fall out of that one rule: SHARED (only the shared record exists),
+    # OVERRIDE (both exist, the agent's wins) and AGENT-PRIVATE (only the agent record
+    # exists — invisible elsewhere, and its name may collide freely).
+    #
+    # Without `agent` the shared scope is all there is, which is what every caller
+    # that has no agent in hand (the Studio's shared editor, a bare catalog) means.
+    def all(agent: nil)
+      shared = @skills
+      overrides = agent_scope(agent)
+      return shared.values if overrides.empty?
+
+      shared.merge(overrides).values
+    end
+
+    def find(name, agent: nil)
+      agent_scope(agent)[name.to_s] || @skills[name.to_s]
+    end
+
+    # Reloads from disk + Store and SWAPS the index atomically: an
+    # authored/edited skill takes effect without a restart. A turn in progress
+    # captured @skills at dispatch, so it does not see the swap mid-flight.
+    def reload
+      @skills, @agent_skills = load_all
+      self
+    end
+
+    # Per-agent allowlist: nil -> all | [] -> none | [names] -> subset. `agent`
+    # selects WHICH body each allowed name resolves to (see #find); the allowlist is
+    # by NAME either way, so specializing a skill never touches the allowlist.
+    def effective(skills_policy, agent: nil)
+      Allowlist.filter(all(agent: agent), skills_policy) { |s| s.name }
+    end
+
+    # THE single definition of "always in the prompt", consulted by all three
+    # surfaces that must agree: the body provider (injects these), the level-1
+    # catalog (hides them) and load_skill (refuses them). Split the rule across three
+    # files and they drift — which is the failure this whole feature came from.
+    #
+    # `profile.skills_eager` — a PER-AGENT decision, so a shared skill stays shared:
+    #   nil | false  -> none (progressive disclosure; the default)
+    #   true         -> every allowed skill (blanket; only for a corpus that fits the budget)
+    #   [names]      -> exactly these
+    #
+    # Deliberately NOT `Allowlist.filter`: there nil means ALL, which is the safe
+    # default for `skills`/`tools_allow` where nil is "no policy". Here nil must mean
+    # NONE — an unconfigured agent waking up with every skill body on every turn is
+    # the opposite of a safe default. A name that is not in the agent's `skills`
+    # allowlist is a silent no-op here (the intersection with `effective`); `doctor`
+    # flags it, because the operator who wrote the name meant it.
+    def eager_for(profile)
+      allowed = effective(profile.skills, agent: profile.id)
+      spec = profile.skills_eager
+      return allowed if blanket?(spec)
+      return [] if spec.nil? || spec == false
+
+      names = Array(spec).map { |n| n.to_s.strip }
+      allowed.select { |s| names.include?(s.name) }
+    end
+
+    # The complement: what the model still has to ASK for — and therefore what the
+    # level-1 list advertises and load_skill will serve.
+    def lazy_for(profile) = effective(profile.skills, agent: profile.id) - eager_for(profile)
+
+    # Level 1: compact list injected into the system prompt. Metadata only.
+    # Receives the set already filtered by the agent.
+    #
+    # `when=` carries the skill's `triggers:` — THE ROUTING TABLE, GENERATED. What
+    # actually made activation reliable on the pilot was a hand-written companion file
+    # listing each skill with its trigger phrases, and nothing checked it against the
+    # catalog: a skill created at 11:28 was invisible to a table written the day
+    # before, and the model obeyed the table. Rendering the same information from the
+    # catalog means it cannot disagree with the allowlist — a newly allowed skill
+    # appears the moment it is allowed. Detecting that drift would have been strictly
+    # worse than removing its source.
+    def format_for_prompt(skills = all)
+      return "" if skills.empty?
+
+      entries = skills.map do |s|
+        when_attr = Array(s.triggers).empty? ? "" : %( when="#{Array(s.triggers).join('; ')}")
+        %(  <skill name="#{s.name}"#{when_attr}>#{s.description}</skill>)
+      end.join("\n")
+
+      <<~PROMPT.strip
+        <available_skills>
+        #{entries}
+        </available_skills>
+
+        Before ANY reply or tool call: scan the skills above. If one matches
+        or is even partially relevant to the task, you MUST call
+        `load_skill("name")` FIRST and follow what it returns. Err on the
+        side of loading. Only skip when genuinely none apply.
+      PROMPT
+    end
+
+    private
+
+    # The blanket switch, tolerant of the strings a form / JSON round-trip produces
+    # ("1" from a checkbox, "true" from a pack) — same reading as
+    # AgentProfile#stream_public?. Anything else (a list, nil, false) is not blanket.
+    def blanket?(spec) = Coercion.truthy?(spec)
+
+    # An agent's override index; {} for a nil agent or one that specialized nothing.
+    def agent_scope(agent) = agent.nil? ? {} : (@agent_skills[agent.to_s] || {})
+
+    # -> [shared index, { agent_id => index }].
+    def load_all
+      found = {}
+      @roots.each do |root|
+        Dir.glob(File.join(root, "**", "SKILL.md")).sort.each do |file|
+          skill = parse_content(File.read(file, encoding: "UTF-8"), path: file)
+          next unless skill
+
+          found[skill.name] ||= skill # precedence: first root wins
+        end
+      end
+      overlay_store(found)
+      [found, load_agent_scopes]
+    end
+
+    # Store skills overlay the on-disk ones (authored > seed). Sentinel path
+    # "store:<name>" — not a real file (load_skill uses `body`, not the path).
+    def overlay_store(found)
+      return unless @store
+
+      @store.all.each do |name, content|
+        skill = parse_content(content.to_s, path: "store:#{name}", key: name)
+        found[name.to_s] = skill if skill # Store wins
+      end
+    end
+
+    # Per-agent overrides / private skills, one index per agent. A store that predates
+    # the agent dimension answers nothing here, so this is {} and every lookup falls
+    # straight through to the shared scope.
+    def load_agent_scopes
+      return {} unless @store.respond_to?(:agents)
+
+      @store.agents.each_with_object({}) do |agent, acc|
+        index = {}
+        @store.all(agent: agent).each do |name, content|
+          skill = parse_content(content.to_s, path: "store:#{agent}/#{name}", key: name)
+          index[name.to_s] = skill if skill
+        end
+        acc[agent.to_s] = index unless index.empty?
+      end
+    end
+
+    # `key` = THE STORE POSITION, and it wins over the frontmatter `name:`. An override
+    # authored for one agent still says `name: escalation-to-human` inside — that is
+    # deliberate, it is the same skill specialized — and indexing by the parsed name
+    # would clobber the shared record globally, which is the exact bug the agent scope
+    # exists to fix. It also makes a pack whose directory name and frontmatter name
+    # disagree resolvable: the allowlist is written from the directory.
+    def parse_content(raw, path:, key: nil)
+      match = raw.match(/\A---\s*\n(.*?)\n---\s*\n(.*)\z/m)
+      return nil unless match
+
+      # Tolerant frontmatter: real packs have `: ` in the description prose, which
+      # strict YAML rejected (the pack would not load).
+      meta = Insika::Frontmatter.parse(match[1])
+      name = key || meta["name"]
+      return nil unless name && Coercion.present?(meta["name"])
+
+      Skill.new(
+        name: name.to_s,
+        description: meta["description"].to_s,
+        path: path,
+        body: match[2].strip,
+        triggers: parse_list(meta["triggers"]),
+        companions: parse_list(meta["companions"])
+      )
+    end
+
+    # `triggers:` / `companions:` frontmatter. YAML list, or comma-separated string
+    # under the lenient parse (which yields the whole value as one String).
+    def parse_list(raw)
+      list = raw.is_a?(String) ? raw.split(",") : Array(raw)
+      list.map { |t| t.to_s.strip }.reject(&:empty?)
+    end
+  end
+end

data/lib/insika/skill_store.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Insika
+  # AUTHORED skills, in two scopes.
+  # Holds the complete SKILL.md (frontmatter + body) in the durable Store. The
+  # SkillCatalog overlays these skills on top of the on-disk ones (seed), with the Store
+  # winning — so editing/creating a skill in the Studio takes effect without a restart (via reload).
+  #
+  # SHARED scope (`agent:` omitted) — one record per skill in the ConfigStore
+  # (scope "skills"), keyed by the skill name:
+  #   { "content" => "<entire SKILL.md>",
+  #     "updated_at" => iso8601,
+  #     "history" => [ { "content" =>, "at" => }, ... ] }
+  #
+  # AGENT scope (`agent:` given) — one record per AGENT (scope "agent_skills"), the
+  # skills nested under it, exactly the AgentFileStore shape:
+  #   { "skills" => { "<name>" => { "content" =>, "updated_at" =>, "history" => [] } } }
+  #
+  # The agent dimension is a SECOND ARGUMENT, never part of the key. A composite
+  # `"agent/name"` key would put a `/` inside what the Studio serves as a single path
+  # segment (`GET /skills/:name`, the editor, the versions list) — the class of route
+  # bug that ships green and 404s in production. Two arguments become two route
+  # segments (`/agents/:id/skills/:name`) and nothing needs encoding.
+  #
+  # Two scopes and not one: the shared records are untouched by the arrival of the
+  # agent dimension, so there is no migration and a live deployment keeps serving
+  # exactly what it served.
+  #
+  # THE STORE POSITION IS THE IDENTITY. Which scope a record sits in — and under which
+  # key — is what decides which skill it is; the frontmatter `name:` inside an override
+  # stays the bare shared name. See SkillCatalog#find.
+  class SkillStore
+    SCOPE = "skills"
+    AGENT_SCOPE = "agent_skills"
+    HISTORY_MAX = 20
+
+    def initialize(config_store:)
+      @cs = config_store
+    end
+
+    # -> String | nil (complete SKILL.md).
+    def get(name, agent: nil)
+      record(name, agent)&.fetch("content", nil)
+    end
+
+    # -> [String] names in the scope, lexicographic order.
+    def names(agent: nil)
+      agent.nil? ? @cs.keys(SCOPE) : agent_skills(agent).keys.sort
+    end
+
+    # -> { name => content } of the scope's authored skills.
+    def all(agent: nil)
+      names(agent: agent).each_with_object({}) { |n, acc| acc[n] = get(n, agent: agent) }
+    end
+
+    # -> [String] every agent that has specialized at least one skill. What the
+    # catalog overlays and `doctor` sweeps.
+    def agents = @cs.keys(AGENT_SCOPE).sort
+
+    # Writes (upsert). create_only refuses to overwrite. -> Hash (the stored record).
+    def write(name, content, agent: nil, create_only: false)
+      key = name.to_s
+      current = record(key, agent)
+      raise Insika::ValidationError, "skill '#{key}' already exists#{" for agent '#{agent}'" if agent}" if create_only && current
+
+      rec = build_record(content.to_s, current)
+      put(key, rec, agent)
+      rec
+    end
+
+    # -> bool (did it exist?).
+    def delete(name, agent: nil)
+      key = name.to_s
+      return @cs.delete(SCOPE, key) if agent.nil?
+
+      wrapper = @cs.get(AGENT_SCOPE, agent.to_s)
+      return false unless wrapper&.dig("skills", key)
+
+      wrapper["skills"].delete(key)
+      @cs.put(AGENT_SCOPE, agent.to_s, wrapper)
+      true
+    end
+
+    # -> [ { "content" =>, "at" => } ] most recent first.
+    def versions(name, agent: nil) = record(name, agent)&.fetch("history", []) || []
+
+    # Restores version `index` as the current content (a new write). -> Hash.
+    def restore(name, index, agent: nil)
+      hist = versions(name, agent: agent)
+      i = Integer(index)
+      raise Insika::NotFoundError, "skill '#{name}' not found" unless record(name.to_s, agent)
+      raise Insika::ValidationError, "version #{index} does not exist" if i.negative? || i >= hist.length
+
+      write(name, hist[i]["content"], agent: agent)
+    end
+
+    private
+
+    def record(name, agent)
+      return @cs.get(SCOPE, name.to_s) if agent.nil?
+
+      agent_skills(agent)[name.to_s]
+    end
+
+    def put(key, rec, agent)
+      return @cs.put(SCOPE, key, rec) if agent.nil?
+
+      wrapper = @cs.get(AGENT_SCOPE, agent.to_s) || { "skills" => {} }
+      wrapper["skills"] ||= {}
+      wrapper["skills"][key] = rec
+      @cs.put(AGENT_SCOPE, agent.to_s, wrapper)
+    end
+
+    def agent_skills(agent) = (@cs.get(AGENT_SCOPE, agent.to_s) || {})["skills"] || {}
+
+    def build_record(content, current)
+      history = current ? current.fetch("history", []) : []
+      if current
+        history = [{ "content" => current["content"], "at" => current["updated_at"] }] + history
+        history = history.first(HISTORY_MAX)
+      end
+      { "content" => content, "updated_at" => Time.now.utc.iso8601, "history" => history }
+    end
+  end
+end

data/lib/insika/steer_injector.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Insika
+  # WHERE a message that arrived mid-run is allowed to enter the
+  # conversation.
+  #
+  # A customer who corrects themselves while the agent is calling tools ("1234567",
+  # three seconds after "queria saber do pedido") should have that land before the
+  # model's next reasoning step, not after the whole run. RubyLLM runs the entire tool
+  # loop inside `chat.ask`, so the only place to append is from inside its callbacks —
+  # which is enough, because they are public and additive:
+  #
+  #   complete_once
+  #     ├─ provider_completion         → assistant message announcing N tool_calls
+  #     ├─ after_message(assistant)    ← N is read here
+  #     └─ handle_tool_calls
+  #          ├─ add_tool_result_message ×N
+  #          │    └─ after_message(tool)  ← counted; the Nth is THE BOUNDARY
+  #          └─ halt_result || complete   ← the next model step sees what we appended
+  #
+  # Counting to N is not an optimization, it is the correctness condition. A `user`
+  # message inserted BETWEEN tool results is rejected outright by Anthropic (all tool
+  # results of a batch must sit together) and merely tolerated by OpenAI.
+  #
+  # Two invariants this object exists to keep:
+  #
+  # · **Tail-append only.** Nothing already sent to the provider is edited, reordered
+  #   or removed. That is what keeps the prompt cache valid, and a cache miss on a
+  #   ~48k-token identity is a real cost, not a theoretical one.
+  # · **A halted batch injects nothing.** With `halt_when` there is no next model step
+  #   (`handle_tool_calls` returns the Halt), so an appended message would sit in the
+  #   transcript unanswered forever. The messages stay in the mailbox and the Executor
+  #   releases them as a follow-up turn.
+  class SteerInjector
+    # chat:   the turn's RubyLLM::Chat (already assembled).
+    # actor:  the turn's TaskActor — the mailbox the steered messages arrive in.
+    # policy: the turn's QueuePolicy (`frame` decides how the text is worded).
+    # emit:   ->(type, data) — the Executor's emitter, already bound to the task.
+    def initialize(chat:, actor:, policy:, emit:)
+      @chat = chat
+      @actor = actor
+      @policy = policy
+      @emit = emit
+      @expected = nil # tool calls announced by the batch in flight (nil = not in one)
+      @seen = 0
+      @halted = false
+      @injected = 0
+    end
+
+    # How many messages this run absorbed (read by specs and by the turn's event).
+    attr_reader :injected
+
+    # RubyLLM `after_tool_result`, with the RAW result — the only place a `Tool::Halt`
+    # is still recognizable. By the time it becomes a `role: tool` message its content
+    # is the payload, indistinguishable from an ordinary result.
+    def tool_result(result)
+      @halted = true if halt?(result)
+    end
+
+    # RubyLLM `after_message`. An assistant message carrying tool calls OPENS a batch;
+    # the Nth tool result CLOSES it, and that is the one boundary where appending is
+    # valid.
+    def message_ended(message)
+      role = field(message, :role).to_s
+      return open_batch(message) if role == "assistant"
+      return unless role == "tool" && @expected
+
+      @seen += 1
+      inject! if @seen >= @expected
+    end
+
+    private
+
+    def open_batch(message)
+      calls = field(message, :tool_calls)
+      size = calls.respond_to?(:size) ? calls.size : 0
+      # A message with no tool call is the model talking, not a batch: leave any
+      # pending message where it is (the turn is about to end, and the Executor
+      # releases it as a follow-up turn rather than answering it half-way).
+      return @expected = nil if size.zero?
+
+      @expected = size
+      @seen = 0
+      @halted = false
+    end
+
+    def inject!
+      @expected = nil
+      return if @halted # nothing will read it: leave it in the mailbox
+
+      texts = @actor.take_user_messages!
+      return if texts.empty?
+
+      texts.each { |text| @chat.add_message(role: :user, content: @policy.frame(text)) }
+      @injected += texts.size
+      # Counts only, never content — the text is already in the transcript, which is the
+      # surface that is allowed to carry it. `task_id`/`session_id` are the event's meta.
+      @emit.call(:turn_steered, { count: texts.size, total: @injected })
+    end
+
+    def halt?(result) = defined?(RubyLLM::Tool::Halt) && result.is_a?(RubyLLM::Tool::Halt)
+
+    def field(message, name)
+      return message.public_send(name) if message.respond_to?(name)
+      return message[name] || message[name.to_s] if message.respond_to?(:[])
+
+      nil
+    end
+  end
+end

data/lib/insika/store.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Insika
+  # Minimal persistence contract.
+  # Namespace-scoped KV, transactional when the backend supports it.
+  # Every implementation passes the SAME contract suite
+  # (lib/insika/testing/store_contract.rb — requirable from outside the repo,
+  # Values must be JSON-serializable.
+  #
+  # scope: String — separates domains/tenants (e.g. "sessions", "tasks:tenant_x")
+  # key:   Hierarchical String (e.g. "task:123", "checkpoint:123:turn:4")
+  #
+  # Contract rules (verified by the suite):
+  # - get on a nonexistent key -> nil (never an exception)
+  # - set overwrites silently (last-write-wins)
+  # - round-trip preserves JSON types; Symbols become Strings (the domain
+  #   normalizes at the boundary)
+  # - list(scope) returns only keys of the scope, ordered lexicographically;
+  #   prefix filters by start_with?
+  # - a nested transaction reuses the outer transaction (no SAVEPOINT)
+  # - a serialization failure on write -> Insika::StoreError (fail-fast)
+  #
+  # Backends `include Store` and override the five methods; any forgotten
+  # method raises NotImplementedError (fail-fast, better than a distant
+  # NoMethodError).
+  module Store
+    # -> Object | nil (deserialized)
+    def get(scope, key)
+      raise NotImplementedError, "#{self.class}#get"
+    end
+
+    # -> value (the SAME object passed in, not the round-trip)
+    def set(scope, key, value)
+      raise NotImplementedError, "#{self.class}#set"
+    end
+
+    # -> true | false (did it exist?)
+    def delete(scope, key)
+      raise NotImplementedError, "#{self.class}#delete"
+    end
+
+    # -> [String] keys ordered lexicographically
+    def list(scope, prefix = nil)
+      raise NotImplementedError, "#{self.class}#list"
+    end
+
+    # -> the block's result; atomic if the backend supports it
+    def transaction(&blk)
+      raise NotImplementedError, "#{self.class}#transaction"
+    end
+  end
+end

data/lib/insika/stores/memory.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Insika
+  module Stores
+    # In-memory backend for dev/test.
+    # Serializes JSON even in memory: exact parity of type semantics
+    # with SQLite — the contract suite is honest.
+    # No lock: cooperative fibers do not preempt in the middle of a Hash
+    # operation.
+    class Memory
+      include Store
+
+      def initialize
+        @data = new_store
+        @tx_depth = 0
+        @snapshot = nil
+      end
+
+      def get(scope, key)
+        raw = @data[scope][key]
+        return nil if raw.nil?
+
+        JSON.parse(raw)
+      end
+
+      def set(scope, key, value)
+        @data[scope][key] = serialize(value)
+        value
+      end
+
+      def delete(scope, key)
+        !@data[scope].delete(key).nil?
+      end
+
+      def list(scope, prefix = nil)
+        keys = @data[scope].keys.sort
+        prefix ? keys.select { |k| k.start_with?(prefix) } : keys
+      end
+
+      # Snapshot at the start of the outermost transaction; an exception at any
+      # level -> restore the snapshot and re-propagate (a REAL rollback).
+      # A nested one reuses the outer (no SAVEPOINT).
+      def transaction
+        if @tx_depth.positive?
+          @tx_depth += 1
+          begin
+            return yield
+          ensure
+            @tx_depth -= 1
+          end
+        end
+
+        @snapshot = deep_snapshot
+        @tx_depth = 1
+        begin
+          yield
+        rescue StandardError
+          restore_snapshot
+          raise
+        ensure
+          @tx_depth = 0
+          @snapshot = nil
+        end
+      end
+
+      # JSON model types + Symbol (coerced to String on write).
+      # Any other type is "garbage" and must be rejected.
+      JSONABLE = [NilClass, TrueClass, FalseClass, Integer, Float,
+                  String, Symbol].freeze
+      private_constant :JSONABLE
+
+      private
+
+      def new_store
+        Hash.new { |h, scope| h[scope] = {} }
+      end
+
+      # Enforces the contract's type model at the boundary:
+      # Symbol/symbol-key become String; a type outside the JSON model ->
+      # StoreError on WRITE (fail-fast; never writes garbage).
+      #
+      # Does not use `JSON.generate(strict: true)`: under json 2.7.1 (the pinned
+      # version) `strict` rejects Symbol, which would violate the Symbol coercion.
+      # The explicit validation is independent of the json version and gives the
+      # SAME semantics as SQLite.
+      # The transaction block's exception (from the caller) propagates without
+      # wrapping; only a backend error becomes StoreError.
+      def serialize(value)
+        ensure_jsonable!(value)
+        JSON.generate(value)
+      rescue JSON::GeneratorError => e
+        raise Insika::StoreError, "value not serializable: #{e.message}"
+      end
+
+      def ensure_jsonable!(value)
+        case value
+        when *JSONABLE then nil
+        when Array then value.each { |v| ensure_jsonable!(v) }
+        when Hash then value.each { |k, v| ensure_jsonable!(k); ensure_jsonable!(v) }
+        else
+          raise Insika::StoreError,
+                "value not serializable: #{value.class} not allowed in JSON"
+        end
+      end
+
+      # Deep dup: the values are already JSON strings (immutable in practice),
+      # so a per-scope dup is enough — there is no nested mutable structure.
+      def deep_snapshot
+        @data.each_with_object({}) { |(scope, kv), acc| acc[scope] = kv.dup }
+      end
+
+      # Recreates the Hash with the default proc (otherwise @data[scope] on a
+      # new scope after rollback would raise) and restores only the snapshot's
+      # scopes — scopes created inside the transaction disappear.
+      def restore_snapshot
+        @data = new_store
+        @snapshot.each { |scope, kv| @data[scope] = kv }
+      end
+    end
+  end
+end