insika 0.3.0 → 0.8.0

data/lib/insika/studio/app.rb

@@ -53,6 +53,11 @@ module Studio
     # Strict CSP: no `unsafe-inline`. Everything comes from the same-origin bundle in
     # /studio/assets/dist. `connect-src 'self'` covers the playground's EventSource
     # (SSE from /studio/events, same origin). `img-src data:` covers inline SVG/icons.
+    # `frame-src 'self'` (explicit, not left to the `default-src 'none'` fallback):
+    # the artifact preview page frames /studio/artifacts/:id/content — same-origin,
+    # but frame-src does NOT inherit from default-src, so without this line the
+    # browser blocked its own iframe (found live: "Framing '...' violates ...
+    # default-src 'none' ... frame-src was not explicitly set").
     plugin :content_security_policy do |csp|
       csp.default_src :none
       csp.script_src :self
@@ -63,6 +68,7 @@ module Studio
       csp.form_action :self
       csp.base_uri :none
       csp.frame_ancestors :none
+      csp.frame_src :self
     end
 
     class << self
@@ -92,7 +98,9 @@ module Studio
                     followup_store: nil, contact_store: nil,
                     proposal_store: nil,
                     harvest_store: nil, harvest_criterion: nil, negative_list: nil,
-                    channel_registry: nil)
+                    channel_registry: nil,
+                    artifact_store: nil, artifact_signing: nil,
+                    knowledge_store: nil)
         @insika = {
           command_bus: command_bus, profile_source: profile_source,
           event_stream: event_stream, config: config,
@@ -158,15 +166,18 @@ module Studio
           # (boot-loaded, with its sha) and the negative list render the two
           # pre-registered artifacts. nil = the page renders its empty state.
           harvest_store: harvest_store, harvest_criterion: harvest_criterion,
-          negative_list: negative_list
+          negative_list: negative_list,
+          # the Artifacts tab reads the report store directly; its
+          # only mutation (delete) dispatches :delete_artifact on the bus.
+          # artifact_signing is a { key:, ttl:, base_url: } Hash when a signing
+          # key is configured (nil = no signed surface). nil stores = the
+          # pages render their empty states.
+          artifact_store: artifact_store, artifact_signing: artifact_signing,
+          # the Knowledge page reads the store directly (list/edit/
+          # conflict filter); its mutations (write/delete/restore) dispatch
+          # bus commands. nil = the page renders its empty state.
+          knowledge_store: knowledge_store
         }.freeze
-        # "restart recommended" flag — in memory, PER PROCESS. A
-        # config change that the runtime only re-reads at boot (e.g.: MCP instances are
-        # wired at startup) lights the flag; restarting the process clears it
-        # naturally (new process = `configure` runs again = flag reset).
-        # Deliberately not put in the session: the session survives the restart (the secret
-        # derives from the token) and the flag would stay stuck on.
-        @restart_needed = false
         secret = session_secret || derive_secret(config[:admin_token])
         plugin :sessions, key: "insika.studio", secret: secret,
                           max_seconds: SESSION_MAX_AGE, same_site: :lax
@@ -185,11 +196,6 @@ module Studio
       def derive_secret(admin_token)
         Digest::SHA512.hexdigest("insika-studio-session-v1:#{admin_token}")
       end
-
-      # --- Restart recommended — per-process state -------------------
-      def restart_needed? = @restart_needed == true
-      def mark_restart_needed! = (@restart_needed = true)
-      def clear_restart_needed! = (@restart_needed = false)
     end
 
     route do |r|
@@ -229,6 +235,18 @@ module Studio
         end
       end
 
+      # The signed artifact link: the ONLY path that serves an artifact without
+      # a Studio session (the point of a sharing link). Without a signing key
+      # there is NO signed surface — a forged link 404s, never a login redirect
+      # (a link that cannot exist must not advertise a door).
+      r.on "artifacts", "s" do
+        r.on String do |id|
+          r.get do
+            serve_signed_artifact(utf8(id), r.params["exp"], r.params["sig"])
+          end
+        end
+      end
+
       # --- FAIL-CLOSED: from here down requires an authenticated session ----
       r.redirect("/studio/login") unless authenticated?
 
@@ -238,14 +256,6 @@ module Studio
         r.redirect("/studio/login")
       end
 
-      # Dismisses the "restart recommended" banner without restarting (the operator
-      # acknowledges and moves on). A real restart clears the flag on its own.
-      r.post "restart-ack" do
-        check_csrf!
-        self.class.clear_restart_needed!
-        r.redirect(safe_back(r.params["back"]))
-      end
-
       # GET /studio/events — the live transcript's SSE, on the STUDIO's own auth.
       # `EventSource` cannot send an Authorization header, so the browser used to read
       # the server's `/v1/events` directly — which is why that route had to stay open to
@@ -282,6 +292,9 @@ module Studio
             # whole grid (a store scan per card would be n scans). Series live
             # on the agent detail — one agent's periods, not n charts here.
             @latest_outcomes = insika[:outcome_store]&.latest_per_agent
+            # "New from template" gallery — cheap (frontmatter
+            # parse only, no evaluation) so it's safe on every render.
+            @templates = Insika::Templates.all
             view("agents")
           end
 
@@ -301,6 +314,19 @@ module Studio
           end
         end
 
+        # /studio/agents/from_template/:name — "New from template" gallery.
+        # Must be declared BEFORE the generic `r.on String do |id|`
+        # below, or Roda would treat "from_template" as an agent id.
+        r.on "from_template", String do |name|
+          r.post do
+            check_csrf!
+            result = with_flash("Created from template '#{name}'.") do
+              create_agent_from_template(name)
+            end
+            r.redirect(result ? agent_path(result[:agent_id]) : "/studio/agents")
+          end
+        end
+
         # /studio/agents/:id — an agent's authoring page.
         r.on String do |id|
           id = utf8(id)
@@ -709,6 +735,26 @@ module Studio
             r.redirect("/studio/settings?s=llm")
           end
         end
+
+        # Demo data (OSS onboarding): populates the bundled "demo-store" agent
+        # so Funnels/Followups/Refinement/Approvals/Distillation/Evals all show
+        # real data at once. Same command the CLI's `insika demo:seed` runs —
+        # the Studio never seeds anything itself (constitutional rule).
+        r.post "seed-demo-data" do
+          check_csrf!
+          begin
+            result = dispatch(:seed_demo_data, { force: r.params["force"] == "1" })
+            flash["notice"] = if result[:seeded]
+                                 "Seeded '#{result[:agent]}': " +
+                                   result[:counts].map { |k, v| "#{v} #{k}" }.join(", ") + "."
+                               else
+                                 "Already seeded (#{result[:reason]}) — check 'reseed' to seed again."
+                               end
+          rescue Insika::ValidationError, Insika::NotFoundError => e
+            flash["error"] = e.message
+          end
+          r.redirect("/studio/settings?s=demo")
+        end
       end
 
       # --- MCP: instances with masked credentials ------------------
@@ -717,20 +763,56 @@ module Studio
           r.get { render_mcp }
           r.post do
             check_csrf!
-            with_flash("MCP instance saved.") do
-              dispatch(:upsert_mcp, mcp_patch(r))
-              # MCP servers are wired at runtime boot; the new instance
-              # only takes effect after a restart. Lights the "restart" banner.
-              self.class.mark_restart_needed!
+            name = nil
+            result = with_flash("MCP instance saved.") do
+              payload = mcp_patch(r)
+              name = payload[:name]
+              dispatch(:upsert_mcp, payload)
             end
-            r.redirect("/studio/mcp")
+            r.redirect(mcp_path(result ? name : presence(r.params["name"])))
           end
         end
         r.post "delete" do
           check_csrf!
           with_flash("MCP instance removed.") do
             dispatch(:delete_mcp, { name: presence(r.params["name"]) })
-            self.class.mark_restart_needed!
+          end
+          r.redirect("/studio/mcp")
+        end
+        # "Test connection": connects LIVE via the same
+        # :refresh_mcp_tools Command the CLI's `insika mcp test`/`refresh` and
+        # the /v1/mcp/:name/import route use — writes tools_cache either way,
+        # `test` vs `refresh` is purely a CLI naming distinction, moot here
+        # since the instance card already displays the cache persistently.
+        # Rescues StandardError, not just Insika::Error: a transport failure
+        # is the ruby_llm-mcp gem's own error class, and turning it into a
+        # clean flash instead of a 500 is this caller's job (same discipline
+        # as the CLI's `mcp_run`).
+        r.post "test" do
+          check_csrf!
+          name = presence(r.params["name"])
+          begin
+            tools = dispatch(:refresh_mcp_tools, { name: name })[:tools]
+            flash["notice"] = "MCP instance '#{name}': connected, #{tools.size} tool(s)."
+          rescue StandardError => e
+            flash["error"] = "MCP instance '#{name}': #{e.message}"
+          end
+          r.redirect(mcp_path(name))
+        end
+        # "Import JSON": the same `mcpServers` document CLI's
+        # `insika mcp import` and Claude Desktop/Cursor already use. Studio
+        # never writes a store directly (constitutional rule) — `import_mcp_json`
+        # fans the document out into the SAME :upsert_mcp Command a single
+        # instance save would use, one dispatch per entry.
+        r.post "import" do
+          check_csrf!
+          begin
+            records = import_mcp_json(r.params["json"].to_s)
+            flash["notice"] = "Imported #{records.size} MCP instance(s): #{records.map { |rec| rec["name"] }.join(", ")}."
+          rescue JSON::ParserError
+            flash["error"] = "Invalid JSON."
+          rescue Insika::ValidationError, Insika::NotFoundError => e
+            flash["error"] = e.message
           end
           r.redirect("/studio/mcp")
         end
@@ -777,6 +859,10 @@ module Studio
       end
 
       # --- History: read-only viewer of a session ------------------
+      # Three zones: conversation list | transcript |
+      # metadata margin. The master column is the same recent-sessions list
+      # the chats index renders; rows frame-navigate, so a Turbo-Frame request
+      # renders the two right zones alone.
       r.on "sessions" do
         r.on String do |sid|
           sid = utf8(sid)
@@ -784,6 +870,8 @@ module Studio
             @session = insika[:session_store]&.find(sid)
             next_404 unless @session
 
+            # master column: recent conversations, current one active
+            @sessions = recent_sessions(limit: 60)
             # Session's tool-call trace (debug): grouped by turn in the view.
             @tool_traces = (insika[:tool_trace_store]&.for_session(sid) || [])
                            .group_by { |t| t["turn"] }
@@ -792,7 +880,11 @@ module Studio
             # the stage history — the session's outcomes folded
             # into the agent's declared stages (unmapped kinds render raw).
             @stage_history = stage_history_for(sid)
-            view("session")
+            if turbo_frame?("session-detail")
+              render("session", locals: { frame_only: true }, layout: false)
+            else
+              view("session", locals: { frame_only: false })
+            end
           end
         end
       end
@@ -1051,6 +1143,77 @@ end
         end
       end
 
+      # --- Knowledge: concepts learned from finished conversations --
+      # Reads the KnowledgeStore directly (the Studio's constitutional split);
+      # every mutation — write (including an operator's hand-authored concept
+      # or a `provenance: policy` promotion), delete, restore — dispatches a
+      # bus command. Single-agent-scoped like Harvest, not shared like Skills:
+      # the store is a real per-agent (+ optional tenant) partition.
+      r.on "knowledge" do
+        r.is do
+          r.get { render_knowledge }
+          r.post do
+            check_csrf!
+            agent = presence(r.params["agent"])
+            name = presence(r.params["name"])
+            tenant = presence(r.params["tenant"])
+            with_flash("Concept saved.") do
+              dispatch(:write_concept, { agent: agent, name: name, tenant: tenant,
+                                        content: r.params["content"].to_s }.compact)
+            end
+            r.redirect(knowledge_path(agent, name, tenant))
+          end
+        end
+
+        r.get "new" do
+          @agents = insika[:profile_source].ids.sort
+          @agent = presence(r.params["agent"]) || @agents.first
+          @tenant = presence(r.params["tenant"])
+          load_knowledge_master(agent: @agent, tenant: @tenant)
+          @selected = ""
+          @concept_content = new_concept_template
+          view("knowledge")
+        end
+
+        r.on String do |name|
+          name = utf8(name)
+          r.is do
+            r.get do
+              @agents = insika[:profile_source].ids.sort
+              @agent = presence(r.params["agent"]) || @agents.first
+              @tenant = presence(r.params["tenant"])
+              load_knowledge_master(agent: @agent, tenant: @tenant)
+              @selected = name
+              @concept_content = concept_source(@agent, name, tenant: @tenant)
+              @selected_concept = Insika::Knowledge::Concept.parse(@concept_content)
+              @concept_versions = insika[:knowledge_store]&.versions(@agent, name, tenant: @tenant)
+              view("knowledge")
+            end
+          end
+
+          r.post "delete" do
+            check_csrf!
+            agent = presence(r.params["agent"])
+            tenant = presence(r.params["tenant"])
+            with_flash("Concept removed.") do
+              dispatch(:delete_concept, { agent: agent, name: name, tenant: tenant }.compact)
+            end
+            r.redirect("/studio/knowledge?agent=#{Rack::Utils.escape(agent.to_s)}")
+          end
+
+          r.post "restore" do
+            check_csrf!
+            agent = presence(r.params["agent"])
+            tenant = presence(r.params["tenant"])
+            with_flash("Version restored.") do
+              dispatch(:restore_concept, { agent: agent, name: name, tenant: tenant,
+                                          version: r.params["version"] }.compact)
+            end
+            r.redirect(knowledge_path(agent, name, tenant))
+          end
+        end
+      end
+
       # --- Facts: the human gate on distilled proposals  --------
       # Reads ProposalStore directly (the Studio's constitutional split — reads
       # hit the stores, mutations go through the bus); the ONLY mutation — the
@@ -1147,6 +1310,26 @@ end
         end
       end
 
+      # --- Artifacts: the report destination -------------------
+      # Reads the ArtifactStore directly (the list, the preview, the content);
+      # the ONLY mutation — delete — dispatches :delete_artifact on the bus
+      # (the Studio never writes a store directly).
+      r.on "artifacts" do
+        r.is { r.get { render_artifacts } }
+        r.on String do |id|
+          id = utf8(id)
+          r.get "content" do
+            serve_artifact_content(id)
+          end
+          r.post "delete" do
+            check_csrf!
+            with_flash("Artifact deleted.") { dispatch(:delete_artifact, { id: id }) }
+            r.redirect("/studio/artifacts?agent=#{Rack::Utils.escape(presence(r.params['agent']).to_s)}")
+          end
+          r.is { r.get { render_artifact(id) } }
+        end
+      end
+
       # Playground: sends `send_message` (the SAME Command as the API) and streams the
       # response live through the `live-transcript` island (SSE from /studio/events).
       r.on "playground" do
@@ -1234,12 +1417,18 @@ end
           # the Follow-ups page — scheduled, fired, blocked and
           # cancelled records per agent + the per-arm A/B readout card.
           ["Follow-ups", "/studio/followups", :followups],
+          # the Artifacts page — the report destination: per-agent
+          # list, sandboxed preview, signed sharing link.
+          ["Artifacts", "/studio/artifacts", :artifacts],
           # the Facts (wiki) page — the human gate on distilled
           # proposals (approve/reject/dismiss, the latch, the CAS re-present).
           ["Facts", "/studio/facts", :facts],
           # the Harvest page — the human gate on mined skills
           # (gate, promote, reject, rollback; the append-only promotion log).
           ["Harvest", "/studio/harvest", :harvest],
+          # the Knowledge page — concepts the engine extracted from
+          # finished conversations; edit, delete, resolve a conflict.
+          ["Knowledge", "/studio/knowledge", :knowledge],
           ["Tasks", "/studio/tasks", :tasks],
           ["Approvals", "/studio/approvals", :approvals],
           ["Refinement", "/studio/refinement", :refinement],
@@ -1253,6 +1442,16 @@ end
 
     def authenticated? = session["auth"] == true
 
+    # Is this request a Turbo frame navigation targeting `id`? Turbo sends
+    # `Turbo-Frame: <id>` on every frame fetch (links with data-turbo-frame,
+    # form submits inside a frame — including the GET after a 303 redirect).
+    # The miller-column routes render their DETAIL pane alone for such a
+    # request and the full two-column shell otherwise — the
+    # standard Rails check, spelled for Roda. Non-matching frame ids and plain
+    # browser hits both take the full page, so refresh/deep links always render
+    # the whole screen.
+    def turbo_frame?(id) = request.env["HTTP_TURBO_FRAME"] == id.to_s
+
     # Is the given nav href the current page? Robust to whether request.path
     # carries the "/studio" mount prefix (it does under serve_real/config.ru, it
     # doesn't in specs) — strip it from both sides, then exact- or prefix-match
@@ -1275,9 +1474,7 @@ end
     # styles. Memoized on the request instance so header and <meta> agree.
     def csp_nonce = (@csp_nonce ||= (session["csp_nonce"] ||= SecureRandom.base64(16)))
 
-    # --- Polish: theme, health chip, restart banner ----------------
-
-    def restart_needed? = self.class.restart_needed?
+    # --- Polish: theme, health chip -------------------------------
 
     # Environment label for the sidebar identity chip — reflects the REAL runtime
     # env (INSIKA_ENV → RACK_ENV → "local") so an operator always knows which box
@@ -1342,6 +1539,18 @@ end
       content.to_s
     end
 
+    # `save_artifact`'s tool-result content is a plain Hash#to_s (RubyLLM tool
+    # results are .to_s'd verbatim into the stored message — see Executor#
+    # serialize_chat_message — never JSON-encoded): `{id: "...", url: "/studio/
+    # artifacts/..."}`. A regex on purpose, not JSON.parse — it genuinely is
+    # not JSON. -> the artifact path, or nil when this tool result isn't one
+    # (every other tool's result renders exactly as before, unaffected).
+    def artifact_link_in(content)
+      return nil unless content.is_a?(String)
+
+      content[%r{url:\s*"(/studio/artifacts/[^"]+)"}, 1]
+    end
+
     # An activation label from the context trace, as the operator reads it:
     # "gift-concierge · trigger:presente". The REASON is the point of the card — a
     # bare list of names answers "was something injected", never "which one did I
@@ -1413,6 +1622,18 @@ end
 
     def render_agent_detail
       id = @agent.id
+      # Which subnav tab the frame should land on. Selecting a prompt file or
+      # a config group is a real navigation (advances the frame + history),
+      # which reconnects the `tabs` Stimulus controller — but Turbo's history
+      # push drops the URL fragment (it rewrites the frame's src to the fetch
+      # response's URL, which never carries one), so `location.hash` is gone
+      # by the time it reconnects. Without this, every such click falls back
+      # to the tabs' first tab ("config") instead of staying put.
+      @active_tab = if !@prompt_selected.nil?
+        "prompts"
+      elsif request.params["cfg"]
+        "config"
+      end
       @config_group = CONFIG_SECTIONS.include?(request.params["cfg"]) ? request.params["cfg"] : "model"
       store = insika[:agent_file_store]
       @prompt_files = Array(@agent.prompt_files).map do |name|
@@ -1442,7 +1663,18 @@ end
       # the per-agent cache-hit series (nil store -> the view's
       # empty state; same guard as the tool trace).
       @cache_series = insika[:cache_series_store]&.for_agent(id) || []
-      view("agent_detail")
+      # the agent's schedule rows (declaration + runtime state) —
+      # the card shows next fire and the last run/skip alongside the editor.
+      @schedules = insika[:schedule_store]&.for_agent(tenant: Insika::ScheduleEngine.tenant_for(@agent), agent: id) || []
+      # the master column: the detail page IS the shell when
+      # visited directly; only a frame request renders the pane alone.
+      @agents = insika[:profile_source].all.sort_by(&:id)
+      @latest_outcomes = insika[:outcome_store]&.latest_per_agent
+      if turbo_frame?("agent-detail")
+        render("agent_detail", locals: { frame_only: true }, layout: false)
+      else
+        view("agent_detail", locals: { frame_only: false })
+      end
     end
 
     # A generation param off the profile (string-keyed by AgentProfile.build). Used
@@ -1483,7 +1715,7 @@ end
       rows = options.map do |value, label|
         %(<option value="#{value}"#{' selected' if value.to_s == current.to_s}>#{label}</option>)
       end.join
-      %(<form method="get" action="#{path}" class="actions inline"><label>Agent <select name="agent" onchange="this.form.submit()">#{rows}</select></label></form>)
+      %(<form method="get" action="#{path}" class="actions inline"><label>Agent <select name="agent" data-controller="auto-submit" data-action="change->auto-submit#submit">#{rows}</select></label></form>)
     end
 
     # The sessions of one agent — the session stamps its agent in
@@ -1695,7 +1927,13 @@ end
       # default to the first agent so the pane is useful on landing.
       sel = request.params["a"]
       @sel_agent = (sel && @agents.find { |a| a.id == sel }) || @agents.first
-      view("tools")
+      # Miller columns: the master rows frame-navigate (?a=),
+      # so a Turbo-Frame request renders just the detail pane.
+      if turbo_frame?("tool-detail")
+        render("tools", locals: { frame_only: true }, layout: false)
+      else
+        view("tools", locals: { frame_only: false })
+      end
     end
 
     # nil = all; otherwise the list. Pre-checks the checkboxes per agent.
@@ -1825,7 +2063,8 @@ end
     # data the Studio already reads (one scan of the session store); no new
     # metrics pipeline. `active_now` = sessions touched in the last 5 minutes.
     # `?agent=` narrows every number to one agent (the sessions stamp their
-    # author in `vars["agent"]`).
+    # author in `vars["agent"]`). The live layer (live_home_controller) only
+    # repaints what this renders — it never computes its own baseline.
     def render_home
       ps = insika[:profile_source]
       @agent = presence(request.params["agent"])
@@ -1839,11 +2078,30 @@ end
         "providers" => insika[:llm_provider_store] ? insika[:llm_provider_store].all.size : 0,
         "MCP servers" => insika[:mcp_store] ? insika[:mcp_store].all.size : 0
       }
-      now = Time.now
+      # UTC, deliberately: sessions stamp `updated_at` with `Time.now.utc.iso8601`,
+      # and every bucket below is keyed by a calendar part (date, hour) of that
+      # stamp. A LOCAL `now` mixes two clocks — on a UTC-3 host, from 21:00 local
+      # onward "today" is already tomorrow in UTC, so the day buckets stopped
+      # matching and the 24h floor was built three hours in the future, silently
+      # emptying both charts. Instant comparisons (`cutoff`) never had the bug;
+      # calendar arithmetic did.
+      now = Time.now.utc
       cutoff = now - (5 * 60)
       @active_now = sessions.count { |s| (t = parse_time(s.updated_at)) && t >= cutoff }
       @recent = sessions.sort_by { |s| s.updated_at.to_s }.reverse.first(8)
       @activity = activity_by_day(sessions, days: 14, now: now)
+      # 24h sparkline: conversations touched per hour, oldest
+      # first — the same session scan, bucketed finer.
+      @activity_24h = activity_by_hour(sessions, hours: 24, now: now)
+      # Trend affordances on the traffic stat cards: today vs yesterday from
+      # the 14-day series (config counts — agents/skills/tools/providers —
+      # have no daily shape and honestly show no trend).
+      # `@activity` is OLDEST FIRST and ends at today, so the last pair reads
+      # [yesterday, today]. Destructured the other way round it reported a
+      # first-conversation-of-the-day as "−1", every day.
+      yesterday, today = @activity.last(2).map(&:last)
+      @conv_trend = today.to_i - yesterday.to_i
+      @msg_trend = message_delta(sessions, now)
       @persistence = insika.dig(:config, :persistence)
       view("home")
     end
@@ -1865,16 +2123,54 @@ end
     end
 
     # [[Date, count], …] — one bucket per day over the window, most-recent last.
+    # `now` is UTC (render_home) and so is every `t` — see #utc_time. Both sides
+    # of the bucket key must be read off the same clock or the join silently
+    # misses.
     def activity_by_day(sessions, days:, now:)
       today = now.to_date
       buckets = Hash.new(0)
       sessions.each do |s|
-        t = parse_time(s.updated_at) or next
+        t = utc_time(s.updated_at) or next
         buckets[t.to_date] += 1
       end
       (0...days).to_a.reverse.map { |i| d = today - i; [d, buckets[d]] }
     end
 
+    # [[hour_start, count], …] — one bucket per hour over the last `hours`,
+    # oldest first, each bucket labeled by its starting hour. Feeds the 24h
+    # sparkline; a session counts in the hour it was last
+    # touched — the same reading "conversations touched" the daily chart uses.
+    def activity_by_hour(sessions, hours:, now:)
+      floor = Time.utc(now.year, now.month, now.day, now.hour) - (hours - 1) * 3600
+      buckets = Hash.new(0)
+      sessions.each do |s|
+        t = utc_time(s.updated_at) or next
+        h = Time.utc(t.year, t.month, t.day, t.hour)
+        buckets[h] += 1 if h >= floor
+      end
+      (0...hours).map { |i| [floor + i * 3600, buckets[floor + i * 3600]] }
+    end
+
+    # Messages in sessions touched today vs yesterday (the delta the messages
+    # stat card shows). A conversation's whole message count lands in the day
+    # it was last updated — coarse, but it is the same data the card counts.
+    def message_delta(sessions, now)
+      today = now.to_date
+      sum = ->(date) do
+        sessions.sum { |s| (t = utc_time(s.updated_at)) && t.to_date == date ? Array(s.messages).size : 0 }
+      end
+      sum.call(today) - sum.call(today - 1)
+    end
+
+    # A stamp read for its CALENDAR parts, always in UTC. `Time.parse` honours
+    # whatever offset the string carries — ours are `Z`, but a record written by
+    # anything else would otherwise bucket by its own zone. `getutc`, not `utc`:
+    # the latter mutates the receiver.
+    def utc_time(value)
+      t = parse_time(value)
+      t&.getutc
+    end
+
     # --- History -------------------------------------------------------------
 
     # Recent conversations (all agents — the Session doesn't stamp the agent that
@@ -1904,21 +2200,24 @@ end
 
     def session_preview(session)
       last = Array(session.messages).reverse.find { |m| %w[user assistant].include?(m["role"]) }
-      last && last["content"].to_s
+      # Structured content previews as JSON (message_content), never #inspect —
+      # a hashrocket in a filter-text attribute is exactly the leak this guards.
+      last && message_content(last["content"])
     end
 
     # --- Settings + LLM providers ----------------------------------
 
     # The agent config tab's groups, in sidebar order. The view renders the
     # same keys; a bogus ?cfg= falls back to the first group.
-    CONFIG_SECTIONS = %w[model guardrails grounding funnel followups distill harvest refinement budget_rel routing advanced].freeze
+    CONFIG_SECTIONS = %w[model guardrails grounding funnel followups schedules distill harvest refinement budget_rel routing advanced].freeze
 
-    SETTINGS_SECTIONS = %w[general models edge evals llm].freeze
+    SETTINGS_SECTIONS = %w[general models edge evals llm demo].freeze
     def render_settings
       store = insika[:settings_store]
       @settings = store ? store.get : Insika::SettingsStore::DEFAULTS
       @providers = insika[:llm_provider_store] ? insika[:llm_provider_store].all : []
       @section = SETTINGS_SECTIONS.include?(request.params["s"]) ? request.params["s"] : "general"
+      @persistence = insika[:config][:persistence].to_s
       view("settings")
     end
 
@@ -1930,12 +2229,73 @@ end
     # --- MCP -------------------------------------------------------
 
     def render_mcp
-      @instances = insika[:mcp_store] ? insika[:mcp_store].all : []
-      view("mcp")
+      @instances = insika[:mcp_store] ? insika[:mcp_store].all.sort_by { |m| m["name"].to_s } : []
+      # Miller columns: ?i= selects the instance whose editor
+      # fills the detail pane. Absent = the first instance (the pane is useful
+      # on landing, same convention as the tools matrix); "?i=" (empty) = the
+      # empty state, which hosts the new/import forms — the master's "+ new"
+      # link points there. A Turbo-Frame request renders the pane alone.
+      raw = request.params["i"]
+      @selected_mcp = if raw.nil?
+                        @instances.first
+                      else
+                        @instances.find { |m| m["name"] == raw }
+                      end
+      if turbo_frame?("mcp-detail")
+        render("mcp", locals: { frame_only: true }, layout: false)
+      else
+        view("mcp", locals: { frame_only: false })
+      end
+    end
+
+    # Where an MCP write redirects back to: the miller shell with the touched
+    # instance still selected, so a frame submit lands on the saved editor
+    # rather than the empty state. A deleted instance falls back to the shell.
+    def mcp_path(name = nil)
+      return "/studio/mcp" if Insika::Coercion.blank?(name)
+
+      "/studio/mcp?i=#{Rack::Utils.escape(name)}"
     end
 
     # mcp_patch moved to Studio::Forms.
 
+    # Bulk `mcpServers` JSON import, routed through the bus:
+    # gives Insika::McpJson.import the `#upsert` duck-type it expects while
+    # every actual write still goes through :upsert_mcp — the adapter's
+    # block closes over `self` (the App instance), so `dispatch` resolves
+    # normally regardless of its own visibility. -> [Hash] masked records.
+    def import_mcp_json(json)
+      dispatcher = method(:dispatch)
+      adapter = Object.new
+      adapter.define_singleton_method(:upsert) { |attrs| dispatcher.call(:upsert_mcp, attrs) }
+      Insika::McpJson.import(json, mcp_store: adapter)
+    end
+
+    # Connection/discovery status chip for an ENABLED instance -
+    # durable state read from the record, not a live probe: "N
+    # tool(s)" means the last refresh cached that many, not that the server
+    # is reachable RIGHT NOW (only "Test connection" tells you that; a failed
+    # attempt surfaces as a flash, not a chip — McpStore holds no "last
+    # error" field to persist). -> [label, pill_css_class].
+    def mcp_status(record)
+      if record["transport"] == "stdio" && !Insika::EnvSchema.truthy?(Insika::EnvSchema.read("INSIKA_MCP_STDIO"))
+        return ["stdio disabled", "err"]
+      end
+
+      tools = Array(record["tools_cache"])
+      return ["untested", ""] if tools.empty?
+
+      ["#{tools.size} tool(s)", "ok"]
+    end
+
+    # Haystack for the /mcp list-filter box: name, transport, on/off, and the
+    # same status label the pill shows — so typing "stdio", "off", "err" or
+    # "untested" narrows the list, not just a name search.
+    def mcp_filter_text(record)
+      status_label, = mcp_status(record)
+      [record["name"], record["transport"], record["enabled"] ? "on enabled" : "off disabled", status_label].join(" ")
+    end
+
     # --- System-files ----------------------------------------------
 
     def render_system_files
@@ -2053,8 +2413,15 @@ end
 
 # The case as the YAML an operator edits — the same shape `evals/golden/**` holds,
 # so there is one format to learn and a pull request can review what was authored.
+# A SIMULATED case carries `persona:` instead of `turns:` — the two
+# shapes are the same YAML, and dropping either key would silently change what
+# the case tests.
 def golden_yaml(golden)
-  h = { "id" => golden.id, "agent" => golden.agent, "turns" => golden.turns }
+  h = if golden.simulated?
+        { "id" => golden.id, "agent" => golden.agent, "persona" => golden.persona.to_h }
+      else
+        { "id" => golden.id, "agent" => golden.agent, "turns" => golden.turns }
+      end
   h["requires"] = golden.requires unless golden.requires.empty? # dropping it would un-skip the case
   h["reference"] = golden.reference unless golden.reference.empty? # …and this would un-compare it
   YAML.dump(h.merge("expect" => golden.expect))
@@ -2119,6 +2486,93 @@ end
       view("parity")
     end
 
+    # --- Artifacts  ---------------------------------------------
+
+    # The restrictive CSP for artifact CONTENT (both the authenticated and the
+    # signed route): artifact content is LLM output — untrusted. No script, no
+    # external fetch, no forms; inline styles (the report's own styling) and
+    # data: images (inline SVG) are the two things a report legitimately needs.
+    ARTIFACT_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:"
+
+    def artifact_store = insika[:artifact_store]
+
+    # -> { key:, ttl:, base_url: } | nil (no signing configured -> no signed surface).
+    def artifact_signing = insika[:artifact_signing]
+
+    def artifact_tenant = presence(request.params["tenant"]) || "platform"
+
+    # The Artifacts page: per-agent list (the listing IS the history — newest
+    # first). Reads the store directly; the only mutation (delete) dispatches
+    # :delete_artifact on the bus.
+    def render_artifacts
+      @agents = insika[:profile_source].ids.sort
+      @agent = presence(request.params["agent"])
+      @signed_available = !artifact_signing.nil? && artifact_signing[:key].to_s.length.positive?
+      # #all, not #for_agent/#for_tenant: the Studio doesn't reliably know
+      # which tenant string an artifact was bound under (Playground turns
+      # bind tenant=agent; a plain single-tenant API turn binds "platform") —
+      # see ArtifactStore#all. Filtering by the record's own `agent` field
+      # sidesteps the guess.
+      @artifacts = artifact_store&.all(agent: @agent) || []
+      view("artifacts")
+    end
+
+    # The preview page: metadata + the artifact in a SANDBOXED iframe (no
+    # allow-scripts / allow-same-origin / allow-forms — on top of the content
+    # route's own restrictive CSP).
+    def render_artifact(id)
+      record = artifact_store&.find(id)
+      return next_404 if record.nil?
+
+      @artifact = record
+      @content_url = "/studio/artifacts/#{Rack::Utils.escape_path(id)}/content"
+      @signed_url = signed_artifact_url(record.id)
+      view("artifact")
+    end
+
+    # The authenticated content route: raw content + the restrictive CSP. The
+    # iframe (same-origin) and the channel-navigated operator read here.
+    def serve_artifact_content(id)
+      record = artifact_store&.find(id)
+      return next_404 if record.nil?
+
+      serve_artifact_bytes(record)
+    end
+
+    # The signed route: verifies the HMAC over (id, expiry) in constant time,
+    # serves only what verifies AND is unexpired. Bad/expired/absent-key ->
+    # 404 (never 403 — no oracle).
+    def serve_signed_artifact(id, exp, sig)
+      signing = artifact_signing
+      key = signing && signing[:key].to_s
+      return next_404 if key.to_s.empty?
+
+      return next_404 unless Insika::ArtifactSigning.valid?(id: id, token: sig, key: key, exp: exp)
+
+      record = artifact_store&.find(id)
+      return next_404 if record.nil?
+
+      serve_artifact_bytes(record)
+    end
+
+    # -> the signed sharing URL | nil (no key -> no signed surface).
+    def signed_artifact_url(id)
+      signing = artifact_signing
+      return nil unless signing && signing[:key] && signing[:key].to_s.length.positive?
+
+      Insika::ArtifactSigning.url_for(id: id, base: signing[:base_url],
+                                      key: signing[:key], ttl: signing[:ttl])
+    end
+
+    def serve_artifact_bytes(record)
+      response.headers["content-type"] = "#{record.mime}; charset=utf-8"
+      response.headers["Content-Security-Policy"] = ARTIFACT_CSP
+      response.headers["X-Content-Type-Options"] = "nosniff"
+      response.headers["Cache-Control"] = "no-store"
+      response.write(record.content)
+      request.halt
+    end
+
     # --- Funnel  ------------------------------------------------
 
     # One card per STORE (agent) that declares a funnel, each with a block per
@@ -2228,6 +2682,73 @@ end
       view("harvest")
     end
 
+    # --- Knowledge index -------------------------------------------------
+
+    # Master data for the Knowledge drill-down: every concept of ONE agent
+    # (+ optional tenant), parsed for the list columns (type/confidence/
+    # occurrences/updated_at). A record that fails to parse (corrupted by a
+    # hand edit) still shows by name, blank elsewhere, rather than vanishing.
+    def load_knowledge_master(agent:, tenant: nil)
+      @status ||= "all"
+      store = insika[:knowledge_store]
+      names = agent && store ? store.names(agent, tenant: tenant) : []
+      concepts = names.filter_map do |n|
+        Insika::Knowledge::Concept.parse(store.get(agent, n, tenant: tenant)) ||
+          { name: n, description: "", type: "", confidence: 0.0, occurrences: 0, updated_at: "", body: "" }
+      end.sort_by { |c| c[:name] }
+      @all_count = concepts.size
+      @conflict_count = concepts.count { |c| concept_conflict?(c) }
+      @concepts = @status == "conflict" ? concepts.select { |c| concept_conflict?(c) } : concepts
+    end
+
+    def render_knowledge
+      @agents = insika[:profile_source].ids.sort
+      @agent = presence(request.params["agent"]) || @agents.first
+      @tenant = presence(request.params["tenant"])
+      @status = presence(request.params["status"]) || "all"
+      load_knowledge_master(agent: @agent, tenant: @tenant)
+      # Auto-open the first concept (drill-down convention), respecting the
+      # active filter — the empty state only shows with nothing left to see.
+      @selected = @concepts.first&.dig(:name)
+      @concept_content = @selected ? concept_source(@agent, @selected, tenant: @tenant) : nil
+      @selected_concept = @concept_content && Insika::Knowledge::Concept.parse(@concept_content)
+      @concept_versions = @selected && insika[:knowledge_store]&.versions(@agent, @selected, tenant: @tenant)
+      view("knowledge")
+    end
+
+    # Raw content for the editor — the complete concept markdown, straight
+    # from the store (unlike a skill, there is no disk fallback to
+    # reconstruct: a concept only ever exists in the store).
+    def concept_source(agent, name, tenant: nil)
+      insika[:knowledge_store]&.get(agent, name, tenant: tenant) || new_concept_template(name)
+    end
+
+    # An operator authoring a concept by hand starts as curated content, not
+    # a claim to earn trust for — `provenance: policy`, full confidence, no
+    # sources (nothing extracted it).
+    def new_concept_template(name = "my-concept")
+      Insika::Knowledge::Concept.render(
+        name: name, description: "one sentence about what this concept says", type: "fact",
+        body: "The durable claim, in your own words.",
+        provenance: "policy", confidence: 1.0, sources: [], occurrences: 1,
+        created_at: Time.now.utc.iso8601, updated_at: Time.now.utc.iso8601
+      )
+    end
+
+    # A concept is flagged "conflict" status by the marker its own body
+    # carries (§3.5) — no extra store field, the marker IS the flag.
+    def concept_conflict?(parsed)
+      parsed && parsed[:body].to_s.include?(Insika::Knowledge::CONTRADICTION_HEADING)
+    end
+
+    # The redirect/link target after a knowledge write or restore — back to
+    # the concept's own detail pane when a name is known, else the index.
+    def knowledge_path(agent, name, tenant)
+      q = "agent=#{Rack::Utils.escape(agent.to_s)}"
+      q += "&tenant=#{Rack::Utils.escape(tenant)}" if tenant
+      name ? "/studio/knowledge/#{Rack::Utils.escape(name)}?#{q}" : "/studio/knowledge?#{q}"
+    end
+
     # The evidence excerpt for a candidate — the origin sessions' messages at
     # the stored indexes, read at request time (D7: ids and indexes only).
     #
@@ -2493,6 +3014,26 @@ end
       anchor ? "#{base}##{anchor}" : base
     end
 
+    # "New from template": evaluates the template (same isolated
+    # eval the CLI's `insika new` never even needs, since it just copies
+    # files — this is the OTHER door) and imports every pack through the
+    # SAME PackImporter a hand-written pack would use — E2's byte-identical
+    # promise. mcp_instances ride separately (never part of a
+    # pack, McpStore is its own store) — each dispatched as its own
+    # :upsert_mcp, the same Command a Studio-authored instance would use
+    # (Studio never writes a store directly). -> { agent_id: }, the
+    # template's primary agent (Definition#id / System#id: the first
+    # declared) — the redirect target when several agents were created.
+    def create_agent_from_template(name)
+      built = Insika::Templates.evaluate(name)
+      packs = built.respond_to?(:to_packs) ? built.to_packs : [built.to_pack]
+      importer = Insika::PackImporter.new(bus: insika[:command_bus], profiles: insika[:profile_source])
+      packs.each { |pack| importer.import(pack) }
+      declared_mcp = Array(built.mcp_instances)
+      declared_mcp.each { |decl| dispatch(:upsert_mcp, decl) }
+      { agent_id: built.id }
+    end
+
     # Deterministic avatar hue: the id's fingerprint, so agents/sessions are
     # scannable at a glance (Linear-style). CSP forbids inline styles, so the
     # hue is a class: avatar-h0..avatar-h9 in application.css.
@@ -2545,10 +3086,13 @@ end
     # forms: resubmitting without touching preserves the real secret in the store).
     def secret_sentinel = Insika::SecretMasking::SENTINEL
 
-    # An MCP instance's env (already MASKED) -> "KEY=value" text per line,
-    # for the textarea. Sorts by key (stable across renders).
+    # An MCP instance's env/headers (already MASKED) -> "KEY=value" text per
+    # line, for the textarea. Sorts by key (stable across renders).
     def env_lines(env)
       (env || {}).sort.map { |k, v| "#{k}=#{v}" }.join("\n")
     end
+
+    # An MCP instance's args (stdio argv) -> one token per line, for the textarea.
+    def list_lines(list) = Array(list).join("\n")
   end
 end