insika 0.1.0 → 0.3.0

data/lib/insika/studio/views/settings.erb

@@ -1,7 +1,7 @@
 <%# Settings — drill-down (T2): section list | selected section's form(s).
    @section (general|models|llm) comes from ?s= and drives the detail. %>
 <% sections = [
-     ["general", "General", "streaming, timeouts, compaction"],
+     ["general", "General", "streaming, timeouts"],
      ["models",  "Model defaults", "platform model layer (Chat › Agent › platform)"],
      ["edge",    "Edge limits", "rate-limit per chat, token ceiling per agent"],
      ["evals",   "Evals", "who grades a rubric, and how a panel agrees"],
@@ -27,7 +27,7 @@
         <button type="submit" form="set-general" class="btn primary" data-turbo-submits-with="Saving…">Save</button>
       </div>
       <div class="drill-pane-body">
-        <p class="muted">Streaming, timeouts and compaction — saved via <code>update_settings</code> (durable, applies next turn).</p>
+        <p class="muted">Streaming and timeouts — saved via <code>update_settings</code> (durable, applies next turn).</p>
         <form id="set-general" method="post" action="/studio/settings">
           <%== csrf_tag %>
           <label class="check">
@@ -39,12 +39,9 @@
             <label>max_retries<input type="text" name="max_retries" value="<%= @settings["max_retries"] %>" inputmode="numeric"></label>
             <label>turn_timeout (s)<input type="text" name="turn_timeout" value="<%= @settings["turn_timeout"] %>" inputmode="numeric"></label>
             <label>tool_timeout (s)<input type="text" name="tool_timeout" value="<%= @settings["tool_timeout"] %>" inputmode="numeric"></label>
+            <label>Memory TTL (days)<input type="text" name="memory_ttl_days" value="<%= @settings["memory_ttl_days"] %>" inputmode="numeric" placeholder="blank = off"></label>
           </div>
-          <label class="check">
-            <input type="checkbox" name="compaction_enabled" value="1"<%== " checked" if @settings.dig("compaction", "enabled") %>>
-            context compaction
-          </label>
-          <label>compaction.keep_last (messages)<input type="text" name="keep_last" value="<%= @settings.dig("compaction", "keep_last") %>" inputmode="numeric"></label>
+          <p class="muted">Memory TTL: how many days a customer memory cell lives before the daily sweep prunes it (per-fact <code>expires_at</code> overrides always win). Editing here sets the platform default for <strong>every</strong> cell; a per-tenant map authored in the settings record is replaced by this save.</p>
         </form>
       </div>
 
@@ -58,11 +55,11 @@
         <form id="set-models" method="post" action="/studio/settings/models">
           <%== csrf_tag %>
           <div class="grid-2">
-            <label>default_model <span class="muted">(agents without their own model)</span><input type="text" name="default_model" value="<%= @settings["default_model"] %>" placeholder="deepseek-chat"></label>
+            <label>default_model <span class="muted">(agents without their own model)</span><input type="text" name="default_model" value="<%= @settings["default_model"] %>" placeholder="deepseek-v4-flash"></label>
             <label>default_provider <span class="muted">(optional)</span><input type="text" name="default_provider" value="<%= @settings["default_provider"] %>" placeholder="deepseek"></label>
           </div>
-          <label>fallback_models <span class="muted">(ordered chain; <code>provider/model</code> or <code>model</code>, comma or newline)</span><input type="text" name="fallback_models" value="<%= Array(@settings["fallback_models"]).join(", ") %>" placeholder="deepseek/deepseek-chat, openai/gpt-4o-mini"></label>
-          <label>utility_model <span class="muted">(cheap internal tasks — titles, distillation)</span><input type="text" name="utility_model" value="<%= @settings["utility_model"] %>" placeholder="deepseek-chat"></label>
+          <label>fallback_models <span class="muted">(ordered chain; <code>provider/model</code> or <code>model</code>, comma or newline)</span><input type="text" name="fallback_models" value="<%= Array(@settings["fallback_models"]).join(", ") %>" placeholder="deepseek/deepseek-v4-flash, openai/gpt-4o-mini"></label>
+          <label>utility_model <span class="muted">(cheap internal tasks — titles, distillation)</span><input type="text" name="utility_model" value="<%= @settings["utility_model"] %>" placeholder="deepseek-v4-flash"></label>
           <label>reasoning <span class="muted">(global default — off/on/effort; blank = provider default)</span>
             <%== thinking_select("thinking", @settings["thinking"], "provider default") %>
           </label>
@@ -107,7 +104,7 @@
     <p class="muted">Who grades a <a href="/studio/evals">case</a>'s rubric. <strong>One model per line</strong> as <code>provider/model</code> — several lines make a PANEL, and two different models disagreeing is the signal worth having (sampling one model N times mostly measures its own variance). Empty = deterministic assertions only, and rubric'd cases read as <code>judge_pending</code>.</p>
     <form id="set-evals" method="post" action="/studio/settings/evals">
       <%== csrf_tag %>
-      <label>judges<textarea name="judges" rows="4" spellcheck="false" placeholder="deepseek/deepseek-chat&#10;openai/gpt-5-mini"><%= Array(@settings.dig("evals", "judges")).map { |j| [j["provider"], j["model"]].compact.reject(&:empty?).join("/") }.join("\n") %></textarea></label>
+      <label>judges<textarea name="judges" rows="4" spellcheck="false" placeholder="deepseek/deepseek-v4-flash&#10;openai/gpt-5-mini"><%= Array(@settings.dig("evals", "judges")).map { |j| [j["provider"], j["model"]].compact.reject(&:empty?).join("/") }.join("\n") %></textarea></label>
       <div class="grid-2">
         <label>aggregate <span class="muted">(how the panel's scores combine)</span>
           <select name="aggregate">
@@ -147,7 +144,7 @@
                 <label>auth_header<input type="text" name="auth_header" value="<%= p["auth_header"] %>" placeholder="Authorization"></label>
               </div>
               <label>api_key<input type="password" name="api_key" value="<%= p["api_key"] %>" autocomplete="off"></label>
-              <label>models <span class="muted">(comma or newline)</span><input type="text" name="models" value="<%= Array(p["models"]).join(", ") %>" placeholder="deepseek-chat, deepseek-reasoner"></label>
+              <label>models <span class="muted">(comma or newline)</span><input type="text" name="models" value="<%= Array(p["models"]).join(", ") %>" placeholder="deepseek-v4-flash, deepseek-reasoner"></label>
               <div class="actions"><button type="submit" class="primary" data-turbo-submits-with="Saving…">Save provider</button></div>
             </form>
           </div>

data/lib/insika/studio/views/skills.erb

@@ -1,6 +1,9 @@
 <%# Skills — drill-down (T2): master list | detail editor + availability.
    Every skill route renders THIS view (index / new / :name); @selected drives
-   which skill is open (nil = none, "" = new). %>
+   which skill is open (nil = none, "" = new). @scope_agent set = editing THAT
+   agent's own version of the skill, not the shared one. %>
+<% scope = @scope_agent %>
+<% form_action = scope ? "/studio/agents/#{Rack::Utils.escape(scope)}/skills/#{Rack::Utils.escape(@selected.to_s)}" : "/studio/skills" %>
 <div class="drill" data-controller="list-filter">
   <aside class="drill-pane drill-master">
     <div class="drill-pane-head">
@@ -36,15 +39,29 @@
       <% new = @selected == "" %>
       <div class="drill-pane-head">
         <div class="title">
-          <nav class="crumbs"><a href="/studio/skills">skills</a> / <span><%= new ? "new" : @selected %></span></nav>
-          <strong class="mono"><%= new ? "New skill" : @selected %></strong>
+          <strong class="mono"><%= new ? "New skill" : @selected %><% if scope %> <span class="pill warn">specialized for <%= scope %></span><% end %></strong>
         </div>
         <button type="submit" form="skill-form" class="btn primary" data-turbo-submits-with="Saving…">Save skill</button>
       </div>
       <div class="drill-pane-body">
-        <form id="skill-form" method="post" action="/studio/skills" data-controller="dirty-guard">
+        <%# The specialization is one MORE record, not a fork: the name stays the bare
+            shared name everywhere the model and the operator see it, and deleting the
+            override falls back to the shared body. %>
+        <% if scope %>
+          <div class="drill-section">
+            <p class="muted">This is <strong><%= scope %></strong>'s own version of <code><%= @selected %></code>. Every
+              other agent keeps the <a href="/studio/skills/<%= Rack::Utils.escape(@selected.to_s) %>">shared skill</a>,
+              and the name does not change — the allowlist, <code>&lt;available_skills&gt;</code> and
+              <code>load_skill</code> all still say <code><%= @selected %></code>.</p>
+            <form method="post" action="/studio/agents/<%= Rack::Utils.escape(scope) %>/skills/<%= Rack::Utils.escape(@selected.to_s) %>/delete">
+              <%== csrf_tag %>
+              <div class="actions"><button type="submit" data-turbo-confirm="Remove this specialization? <%= scope %> falls back to the shared skill.">Stop specializing</button></div>
+            </form>
+          </div>
+        <% end %>
+        <form id="skill-form" method="post" action="<%= form_action %>" data-controller="dirty-guard">
           <%== csrf_tag %>
-          <% unless new %><input type="hidden" name="name" value="<%= @selected %>"><% end %>
+          <% if !new && !scope %><input type="hidden" name="name" value="<%= @selected %>"><% end %>
           <% if new %>
             <label>name <span class="muted">(canonical — same as <code>name:</code> in the frontmatter)</span>
               <input type="text" name="name" placeholder="my-skill" required>
@@ -56,29 +73,66 @@
           </div>
         </form>
 
-        <% unless new %>
+        <% if !new && !scope %>
           <div class="drill-section">
             <div class="drill-section-head">
               <h3>Availability</h3>
-              <span class="muted">which agents can <code>load_skill</code> this — an "all" allowlist is left untouched</span>
+              <span class="muted">per agent: <strong>allowed</strong> = can <code>load_skill</code> it; <strong>always on</strong> = the body
+                is in the prompt every turn. Both are the AGENT's decision, so one shared skill can be
+                always-on for one and discretionary for another. An "all" allowlist is left untouched.</span>
             </div>
             <form method="post" action="/studio/skills/<%= Rack::Utils.escape(@selected) %>/agents">
               <%== csrf_tag %>
               <% if @agents.empty? %>
                 <p class="muted">No agents configured.</p>
               <% else %>
-                <div class="check-grid">
+                <div class="check-grid agent-grid">
                   <% @agents.each do |a| %>
-                    <label class="check">
-                      <input type="checkbox" name="agent_ids[]" value="<%= a.id %>"<%== " checked" if skill_enabled_for?(a, @selected) %>>
-                      <span class="mono"><%= a.id %></span>
-                    </label>
+                    <% own = Array((@specialized || {})[@selected]).include?(a.id) %>
+                    <div class="agent-check">
+                      <div class="agent-check-name">
+                        <span class="mono"><%= a.id %></span>
+                        <% if own %>
+                          <a class="pill warn" href="/studio/agents/<%= Rack::Utils.escape(a.id) %>/skills/<%= Rack::Utils.escape(@selected) %>">own version</a>
+                        <% end %>
+                      </div>
+                      <label class="check tool-check">
+                        <input type="checkbox" name="agent_ids[]" value="<%= a.id %>"<%== " checked" if skill_enabled_for?(a, @selected) %>>
+                        <span class="mono">allowed</span>
+                      </label>
+                      <label class="check tool-check">
+                        <input type="checkbox" name="eager_ids[]" value="<%= a.id %>"<%== " checked" if skill_eager_for?(a, @selected) %>>
+                        <span class="mono">always on</span>
+                      </label>
+                    </div>
                   <% end %>
                 </div>
                 <div class="actions"><button type="submit" class="primary" data-turbo-submits-with="Applying…">Apply to agents</button></div>
               <% end %>
             </form>
           </div>
+
+          <%# Specializing is what keeps a shared skill shared: without it the only way
+              to give one agent a different version was to fork it under a new name and
+              edit the allowlist, which throws the sharing away. %>
+          <% others = @agents.reject { |a| Array((@specialized || {})[@selected]).include?(a.id) } %>
+          <% if others.any? %>
+            <div class="drill-section">
+              <div class="drill-section-head">
+                <h3>Specialize</h3>
+                <span class="muted">give ONE agent its own version of this skill, seeded from the body above — same name, no fork</span>
+              </div>
+              <form method="post" action="/studio/skills/<%= Rack::Utils.escape(@selected) %>/specialize">
+                <%== csrf_tag %>
+                <label>agent
+                  <select name="agent_id" required>
+                    <% others.each do |a| %><option value="<%= a.id %>"><%= a.id %></option><% end %>
+                  </select>
+                </label>
+                <div class="actions"><button type="submit" data-turbo-submits-with="Creating…">Specialize for this agent</button></div>
+              </form>
+            </div>
+          <% end %>
         <% end %>
       </div>
     <% end %>

data/lib/insika/studio/views/system_files.erb

@@ -5,7 +5,7 @@
   </div>
 </header>
 
-<p class="muted matrix-hint">GLOBAL prompts/rules: the runtime injects these files <strong>before</strong> each BIA's own identity, every turn. Store-backed and versioned (like per-agent prompts). Empty = no global injection (the prompt stays exactly as before).</p>
+<p class="muted matrix-hint">GLOBAL prompts/rules: the runtime injects these files <strong>before</strong> each agent's own identity, every turn. Store-backed and versioned (like per-agent prompts). Empty = no global injection (the prompt stays exactly as before).</p>
 
 <% if @system_files.empty? %>
   <div class="empty">No system files. Create one below (e.g. <code>HOUSE_RULES.md</code>) for a rule that applies to every agent.</div>

data/lib/insika/studio/views/task.erb

@@ -88,6 +88,19 @@
   <% end %>
 </section>
 
+<% if @task.timing && !@task.timing.empty? %>
+  <section class="section">
+    <div class="section-head"><h2>Timing <span class="muted">· the turn's latency windows</span></h2></div>
+    <div class="card">
+      <ul class="kv">
+        <% @task.timing.each do |key, value| %>
+          <li><span class="k mono"><%= key %></span><span class="v mono"><%= value %></span></li>
+        <% end %>
+      </ul>
+    </div>
+  </section>
+<% end %>
+
 <section class="section">
   <div class="section-head"><h2>Latest checkpoint</h2></div>
   <% if @checkpoint.nil? %>

data/lib/insika/studio/views/tasks.erb

@@ -3,7 +3,10 @@
     <nav class="crumbs"><span>tasks</span></nav>
     <h1>Tasks<span class="sub"><%= @tasks.size %> task(s)</span></h1>
   </div>
-  <a class="btn" href="/studio/approvals">Approvals →</a>
+  <div class="head-actions">
+    <%== agent_filter_form("/studio/tasks", @agent) %>
+    <a class="btn" href="/studio/approvals">Approvals →</a>
+  </div>
 </header>
 
 <% if @tasks.empty? %>

data/lib/insika/studio/views/tools.erb

@@ -47,7 +47,6 @@
       <% a = @sel_agent %>
       <div class="drill-pane-head">
         <div class="title">
-          <nav class="crumbs"><a href="/studio/tools">tools</a> / <span><%= a.id %></span></nav>
           <strong class="mono"><%= a.id %></strong>
         </div>
         <button type="submit" form="tools-form" class="btn primary" data-turbo-submits-with="Saving…">Save tools</button>

data/lib/insika/subagent_graph.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Insika
-  # Definition-time integrity of the subagent delegation graph (RFC-0010 §4.4,
-  # item 21). A pure function over `{id => [child_ids]}`: detects CYCLES and
+  # Definition-time integrity of the subagent delegation graph (
+  # A pure function over `{id => [child_ids]}`: detects CYCLES and
   # computes the max delegation DEPTH, raising a typed SubagentError so the
   # authoring Command (CreateAgent/UpdateAgent) fails cleanly and boot refuses a
   # bad static set. Cycle + bounded depth are exactly Flue's definition-time
@@ -21,7 +21,7 @@ module Insika
 
     # Max children a single `spawn_subagents` fan-out may run — also the concurrency
     # bound (N concurrent LLM calls hit the provider rate limit + the per-agent token
-    # ceiling of item 33). Override with INSIKA_SUBAGENT_FANOUT_CAP.
+    # ceiling of). Override with INSIKA_SUBAGENT_FANOUT_CAP.
     DEFAULT_FANOUT_CAP = 8
 
     module_function

data/lib/insika/task_actor.rb

@@ -9,7 +9,7 @@ module Insika
   # `await` as the cooperative SUSPENSION primitive. Cancellation/suspension only
   # at stage boundaries — never in the middle of an operation.
   class TaskActor
-    # `user_message` is posted by `Executor#steer_into_running` (RFC-0015 §5.1) and
+    # `user_message` is posted by `Executor#steer_into_running` and
     # consumed by `SteerInjector` at a tool-batch boundary. `pause`/`resume` (operator),
     # `approval` (human-in-the-loop), `timeout`/`heartbeat`
     # (watchdog/liveness, observation).
@@ -61,14 +61,14 @@ module Insika
     # the flag).
     def pause_requested? = @pause_requested
 
-    # RFC-0015 §5.2 — takes the steered messages and clears the buffer, WITHOUT
+    # takes the steered messages and clears the buffer, WITHOUT
     # observing anything else in the mailbox: whatever is not a `:user_message` is put
     # back, in the order it arrived.
     #
     # Why not `drain!`: this runs INSIDE RubyLLM's tool loop (a `after_message`
     # callback), and `drain!` raises on `:cancel`. Cancellation is only ever observed
     # at the Executor's own stage boundaries — that is what keeps a tool batch one
-    # unit of work (RFC-0015 §6.4, and D7 for the same rule under `turn_timeout`).
+    # unit of work (and for the same rule under `turn_timeout`).
     # Injecting a message must not quietly become a new place a turn can die.
     def take_user_messages!
       @mailbox.size.times do

data/lib/insika/task_store.rb

@@ -33,7 +33,7 @@ module Insika
     }.freeze
 
     Task      = Data.define(:id, :status, :command, :session_id, :executions,
-                            :mailbox_state, :created_at, :updated_at)
+                            :mailbox_state, :timing, :created_at, :updated_at)
     Execution = Data.define(:attempt, :started_at, :finished_at, :outcome, :error)
 
     def initialize(store:)
@@ -131,7 +131,19 @@ module Insika
       to_task(record)
     end
 
-    # RFC-0015 §5.3 (`collect`): appends a fragment to a task's message while it is
+    # writes the turn's timing breakdown onto the task record, once,
+    # when the turn completes. Best-effort by the caller's contract — a failure
+    # here must never re-fail an already-committed turn. `timing` is DATA (string
+    # keys, JSON types); deep_stringify makes a symbol-keyed to_h durable.
+    def record_timing(id, timing)
+      record = fetch!(id)
+      record["timing"] = deep_stringify(timing)
+      record["updated_at"] = timestamp
+      @store.set(SCOPE, key_for(id), record)
+      to_task(record)
+    end
+
+    # (`collect`): appends a fragment to a task's message while it is
     # still waiting at the door. -> Task.
     #
     # ONLY on :queued, and that guard is the whole safety of the feature: once a
@@ -185,6 +197,13 @@ module Insika
       end
     end
 
+    # -> true | false (did it exist?). For Retention (WS8) — a purged session's
+    # tasks go with it, terminal tasks only (a live :running task must never
+    # be deleted under its own fiber).
+    def delete(id)
+      @store.delete(SCOPE, key_for(id))
+    end
+
     private
 
     def key_for(id)
@@ -228,6 +247,7 @@ module Insika
         session_id: record["session_id"],
         executions: record["executions"].map { |e| to_execution(e) },
         mailbox_state: record["mailbox_state"],
+        timing: record["timing"],
         created_at: record["created_at"],
         updated_at: record["updated_at"]
       )

data/lib/insika/telemetry/pricing.rb

@@ -4,7 +4,7 @@ require "json"
 
 module Insika
   module Telemetry
-    # Estimated cost of a turn, from a rates table given as DATA (item 16 / P4).
+    # Estimated cost of a turn, from a rates table given as DATA.
     #
     # Insika never ships prices: they change weekly, differ per contract and per
     # region, and a stale table in the engine would be worse than no number at all.
@@ -13,11 +13,11 @@ module Insika
     #
     # Rates are **USD per million tokens** (the unit every provider publishes):
     #
-    #   { "deepseek-chat" => { "input" => 0.27, "output" => 1.10,
+    #   { "deepseek-v4-flash" => { "input" => 0.27, "output" => 1.10,
     #                          "cached_input" => 0.07, "cache_write" => 0.34 } }
     #
     # A key matches the model id the provider reports, with or without the
-    # `provider/` prefix (`deepseek/deepseek-chat` and `deepseek-chat` both hit the
+    # `provider/` prefix (`deepseek/deepseek-v4-flash` and `deepseek-v4-flash` both hit the
     # entry above). An UNKNOWN model -> nil: a missing price is not a zero cost, so
     # nothing is emitted and the dashboard shows a gap instead of a lie.
     #

data/lib/insika/telemetry/recorder.rb

@@ -12,7 +12,7 @@ module Insika
     # insika.data_tool), correlated by task_id. Latency is the span duration; the
     # agent/tenant/model/tokens/cost ride as ATTRIBUTES.
     #
-    # METRICS (item 16 / P4): the SAME events also feed counters and histograms, so
+    # METRICS: the SAME events also feed counters and histograms, so
     # volume/latency/tokens/cost are chartable WITHOUT span aggregation (which not
     # every backend does, and none does cheaply at retention). Metric attributes are
     # a deliberate LOW-CARDINALITY subset of the span attributes — never task_id or

data/lib/insika/telemetry.rb

@@ -5,7 +5,7 @@ require_relative "telemetry/pricing"
 require_relative "telemetry/recorder"
 
 module Insika
-  # OPT-IN observability (Phase 6): OTEL mounted at the edge, core untouched. Rides
+  # OPT-IN observability: OTEL mounted at the edge, core untouched. Rides
   # the Event Stream — the Recorder consumes the events and emits spans and metrics.
   # Off (the default) -> `setup` returns nil and nothing is loaded or instrumented
   # (parity, zero overhead). The OTEL gems are only REQUIRED lazily in `setup`
@@ -17,7 +17,7 @@ module Insika
   # OTEL_* keys are the OpenTelemetry SDK's own env and stay verbatim; only our opt-in
   # toggle is renamed (INSIKA_OTEL, with the HARNESS_OTEL alias still read).
   #
-  # Metrics (item 16 / P4) ride the same switch and the SAME standard env: the SDK
+  # Metrics ride the same switch and the SAME standard env: the SDK
   # registers a periodic metric reader when the OTLP metrics exporter is loadable,
   # and `OTEL_METRICS_EXPORTER=none` turns metrics off while traces stay on. No
   # Insika-specific toggle is invented for it.

data/lib/insika/testing/store_contract.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Contract suite for Insika::Store (doc 01 §7), exported for third-party
-# backends (RFC-0018 A4) — a gem like `insika-pg` writes its spec against THIS
+# Contract suite for Insika::Store, exported for third-party
+# backends — a gem like `insika-pg` writes its spec against THIS
 # file, not against a read of stores/sqlite.rb:
 #
 #   require "insika/testing/store_contract"
@@ -11,7 +11,7 @@
 #     it_behaves_like "an Insika store"
 #   end
 #
-# Two groups, on purpose (RFC-0018 §4 item 4):
+# Two groups, on purpose:
 #
 # - "an Insika store" — universal; every backend passes EXACTLY it (L2: the
 #   suite is honest — a test that passes on Memory passes on SQLite). The
@@ -27,89 +27,89 @@
 # races) — those belong to the backend's own spec.
 RSpec.shared_examples "an Insika store" do
   describe "#get / #set (round-trip)" do
-    it "C1 preserves Hash with string keys" do # C1
+    it " preserves Hash with string keys" do #
       store.set("s", "k", { "a" => 1, "b" => [1, 2] })
       expect(store.get("s", "k")).to eq({ "a" => 1, "b" => [1, 2] })
     end
 
-    it "C2 preserves Array" do # C2
+    it " preserves Array" do #
       store.set("s", "k", [1, "x", true, nil])
       expect(store.get("s", "k")).to eq([1, "x", true, nil])
     end
 
-    it "C3 preserves String" do # C3
+    it " preserves String" do #
       store.set("s", "k", "texto")
       expect(store.get("s", "k")).to eq("texto")
     end
 
-    it "C4 preserves Integer" do # C4
+    it " preserves Integer" do #
       store.set("s", "k", 42)
       value = store.get("s", "k")
       expect(value).to eq(42)
       expect(value).to be_a(Integer)
     end
 
-    it "C5 preserves Float" do # C5
+    it " preserves Float" do #
       store.set("s", "k", 3.14)
       value = store.get("s", "k")
       expect(value).to eq(3.14)
       expect(value).to be_a(Float)
     end
 
-    it "C6 preserves booleans" do # C6
+    it " preserves booleans" do #
       store.set("s", "t", true)
       store.set("s", "f", false)
       expect(store.get("s", "t")).to be(true)
       expect(store.get("s", "f")).to be(false)
     end
 
-    it "C7 preserves nil written without exception" do # C7
+    it " preserves nil written without exception" do #
       store.set("s", "k", nil)
       expect(store.get("s", "k")).to be_nil
     end
 
-    it "C8 converts Symbols (keys and values) to Strings" do # C8
-      store.set("s", "k", { chave: :valor })
-      expect(store.get("s", "k")).to eq({ "chave" => "valor" })
+    it " converts Symbols (keys and values) to Strings" do #
+      store.set("s", "k", { key: :value })
+      expect(store.get("s", "k")).to eq({ "key" => "value" })
     end
 
-    it "C9 returns nil for an absent key, never an exception" do # C9
-      expect(store.get("s", "nao-existe")).to be_nil
+    it " returns nil for an absent key, never an exception" do #
+      expect(store.get("s", "missing-key")).to be_nil
     end
 
-    it "C10 overwrites silently (last-write-wins)" do # C10
-      store.set("s", "k", "primeiro")
-      store.set("s", "k", "segundo")
-      expect(store.get("s", "k")).to eq("segundo")
+    it " overwrites silently (last-write-wins)" do #
+      store.set("s", "k", "first")
+      store.set("s", "k", "second")
+      expect(store.get("s", "k")).to eq("second")
     end
 
-    it "C11 set returns the same object passed in (not the round-trip)" do # C11
+    it " set returns the same object passed in (not the round-trip)" do #
       obj = { "a" => 1 }
       expect(store.set("s", "k", obj)).to equal(obj)
     end
   end
 
   describe "#delete" do
-    it "C12 removes existing and returns true" do # C12
+    it " removes existing and returns true" do #
       store.set("s", "k", 1)
       expect(store.delete("s", "k")).to be(true)
       expect(store.get("s", "k")).to be_nil
     end
 
-    it "C13 returns false for a nonexistent key" do # C13
+    it " returns false for a nonexistent key" do #
       expect(store.delete("s", "k")).to be(false)
     end
   end
 
   describe "#list" do
-    it "C14 returns scope keys sorted lexicographically" do # C14
+    it " returns scope keys sorted lexicographically" do #
       store.set("s", "b", 1)
       store.set("s", "a", 1)
       store.set("s", "c", 1)
       expect(store.list("s")).to eq(%w[a b c])
     end
 
-    it "C15 filters by prefix with start_with? (not include?)" do # C15
+    it " filters by prefix with start_with? (not include?)" do #
       store.set("s", "task:1", 1)
       store.set("s", "task:2", 1)
       store.set("s", "checkpoint:1", 1)
@@ -117,7 +117,7 @@ RSpec.shared_examples "an Insika store" do
       expect(store.list("s", "task:")).to eq(%w[task:1 task:2])
     end
 
-    it "C16 returns [] for an empty scope" do # C16
+    it " returns [] for an empty scope" do #
       expect(store.list("s")).to eq([])
     end
 
@@ -128,8 +128,29 @@ RSpec.shared_examples "an Insika store" do
     end
   end
 
+  describe "#scopes" do
+    it " returns scope names sorted lexicographically" do #
+      store.set("zeta", "k", 1)
+      store.set("alpha", "k", 1)
+      store.set("alpha:child", "k", 1)
+      expect(store.scopes).to eq(["alpha", "alpha:child", "zeta"])
+    end
+
+    it " filters by prefix with start_with? (not include?)" do #
+      store.set("s", "k", 1)
+      store.set("s:child", "k", 1)
+      store.set("s2", "k", 1) # trap: contains "s" but does not start with "s:"
+      expect(store.scopes("s:")).to eq(["s:child"])
+    end
+
+    it " returns [] when nothing matches (or the store is empty)" do #
+      expect(store.scopes("nope")).to eq([])
+      expect(store.scopes).to eq([])
+    end
+  end
+
   describe "scope isolation" do
-    it "C17 keeps scopes independent in get/list/delete" do # C17
+    it " keeps scopes independent in get/list/delete" do #
       store.set("s1", "k", 1)
       store.set("s2", "k", 2)
 
@@ -143,16 +164,16 @@ RSpec.shared_examples "an Insika store" do
   end
 
   describe "#transaction" do
-    it "C18 returns the block's value" do # C18
+    it " returns the block's value" do #
       expect(store.transaction { 42 }).to eq(42)
     end
 
-    it "C19 commits the block's writes" do # C19
+    it " commits the block's writes" do #
       store.transaction { store.set("s", "k", "commitado") }
       expect(store.get("s", "k")).to eq("commitado")
     end
 
-    it "C20 does a real rollback of set AND delete when the block raises" do # C20
+    it " does a real rollback of set AND delete when the block raises" do #
       store.set("s", "manter", "antigo")
       store.set("s", "apagar", "existe")
 
@@ -169,7 +190,7 @@ RSpec.shared_examples "an Insika store" do
       expect(store.get("s", "apagar")).to eq("existe")
     end
 
-    it "C21 reuses the outer transaction when nested" do # C21
+    it " reuses the outer transaction when nested" do #
       store.set("s", "k", "antigo")
 
       expect do
@@ -185,7 +206,7 @@ RSpec.shared_examples "an Insika store" do
   end
 
   describe "serialization errors" do
-    it "C22 raises StoreError and does not write a non-serializable value" do # C22
+    it " raises StoreError and does not write a non-serializable value" do #
       expect do
         store.set("s", "k", Object.new)
       end.to raise_error(Insika::StoreError)
@@ -194,7 +215,7 @@ RSpec.shared_examples "an Insika store" do
   end
 end
 
-# Multi-worker safety (RFC-0018 A3). Every RFC-0016 A1 claim (outbox, delegation
+# Multi-worker safety. Every claim (outbox, delegation
 # sweep, recovery) is a read-check-write inside `transaction` — on SQLite that is
 # atomic because the backend opens BEGIN IMMEDIATE; a backend whose transaction
 # only yields passes all 22 cases above and still double-claims under two
@@ -204,7 +225,7 @@ end
 # The `sleep` inside each transaction is deliberate: it holds the read state
 # open long enough that a backend without isolation ALWAYS lets a second
 # connection through, while a correct backend serializes the writers. Without
-# it a wrong backend could pass by scheduling luck — the failure E2 relies on.
+# it a wrong backend could pass by scheduling luck — the failure relies on.
 RSpec.shared_examples "an Insika store safe for N workers" do
   # Starts N threads, each holding its OWN connection to the same backend,
   # releases them together, and returns each block's value. Connections are