insika 0.2.0 → 0.7.0

data/lib/insika/studio/assets/dist/favicon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#15161b"/>
+  <circle cx="32" cy="32" r="17" fill="#e8b23a" opacity=".18"/>
+  <circle cx="32" cy="32" r="12" fill="#e8b23a"/>
+  <circle cx="32" cy="32" r="4.5" fill="#15161b"/>
+</svg>

data/lib/insika/studio/forms.rb

@@ -7,6 +7,10 @@ module Studio
   # per-request state (`@agent`) exactly as before. Pure extraction — the bodies
   # moved verbatim from app.rb; app_spec's POST cases are the safety net.
   module Forms
+    # The agent config form OWNS every rendered field: a save reflects the
+    # whole form state, so a blank field is a deliberate "clear to default",
+    # never a carry-over. The one exception is keys the form cannot express —
+    # those ride the `carry` merge below (the guardrails corpora precedent).
     def config_patch(r)
       limits = @agent.limits.dup
       # Always present via DEFAULT_LIMITS (tool_concurrency defaults to 1 = serial),
@@ -26,6 +30,21 @@ module Studio
           limits[field.to_sym] = v
         end
       end
+      # Burst policy (QueuePolicy). Opt-in keys, same convention as the edge
+      # overrides above: blank DELETES (inherit platform / DEFAULTS — followup,
+      # steer_max 5); an explicit value pins it for this agent. steer_max 0 is
+      # a legitimate "never steer" and is stored, not deleted.
+      if (qm = presence(r.params["queue_mode"]))
+        unless Insika::QueuePolicy::MODES.map(&:to_s).include?(qm)
+          raise Insika::ValidationError, "queue_mode must be one of: #{Insika::QueuePolicy::MODES.join(', ')}"
+        end
+
+        limits[:queue_mode] = qm
+      else
+        limits.delete(:queue_mode)
+      end
+      smm = edge_int(r.params["steer_max_messages"], "steer_max_messages")
+      smm.nil? ? limits.delete(:steer_max_messages) : limits[:steer_max_messages] = smm
       {
         id: @agent.id,
         model: presence(r.params["model"]),
@@ -34,14 +53,276 @@ module Studio
         limits: limits,
         params: params_patch(r),
         model_policy: model_policy_patch(r),
-        guardrails: guardrails_patch(r)
+        guardrails: guardrails_patch(r),
+        # Every remaining AgentProfile field is editable here — the pack
+        # import is one door, this form is the other (hot, no restart).
+        grounding: grounding_patch(r),
+        funnel: funnel_patch(r),
+        followup: followup_patch(r),
+        schedules: schedules_patch(r),
+        distill: distill_patch(r),
+        harvest: harvest_patch(r),
+        refinement: refinement_patch(r),
+        budget: budget_patch(r),
+        reliability: reliability_patch(r),
+        routes: json_patch(r, "routes"),
+        outputs: json_patch(r, "outputs"),
+        stt_prompt: presence(r.params["stt_prompt"]),
+        metadata: json_patch(r, "metadata") || {},
+        alerts: alerts_patch(r),
+        edge_stream: edge_stream_patch(r),
+        stuck_signal: r.params["stuck_signal"] == "1",
+        prompt_caching: r.params["prompt_caching"] == "1",
+        # The one opt-out flag: checked (the rendered default) saves true, an
+        # unchecked box saves an explicit false — both spellings of ON collapse.
+        tool_persistence: r.params["tool_persistence"] == "1",
+        tool_output_compression: r.params["tool_output_compression"] == "1",
+        subagents: list_patch(r, "subagents"),
+        capabilities: list_patch(r, "capabilities"),
+        tools_deferred: list_patch(r, "tools_deferred"),
+        briefing_fields: list_patch(r, "briefing_fields"),
+        context_providers: allowlist_patch(r, "context_providers"),
+        workflows_allow: allowlist_patch(r, "workflows_allow"),
+        approvals_required: list_patch(r, "approvals_required"),
+        policies: list_patch(r, "policies").map(&:to_sym),
+        prompt_refs: list_patch(r, "prompt_refs"),
+        capabilities_declared: list_patch(r, "capabilities_declared"),
+        skills_eager: skills_eager_patch(r)
       }
     end
 
-    # Guardrails config from the form. The config form OWNS these fields,
-    # so the patch reflects the whole guardrails state. String values round-trip
-    # cleanly through the JSON store; Safety::Config normalizes on read. A blank
-    # moderator drops the key (deterministic only).
+    # grounding — { "mode" => "flag"|"enforce", "matcher" =>
+    # { "sku" => "sku:…", "name_keys" => [...] } }. Blank mode = no grounding
+    # (parity). The matcher keys are carried only while a mode is declared.
+    def grounding_patch(r)
+      mode = presence(r.params["grounding_mode"])
+      return nil unless %w[flag enforce].include?(mode)
+
+      matcher = {}
+      (sku = presence(r.params["grounding_matcher_sku"])) && (matcher["sku"] = sku)
+      keys = list(r.params["grounding_name_keys"])
+      matcher["name_keys"] = keys unless keys.empty?
+      { "mode" => mode, "matcher" => matcher }
+    end
+
+    # the outcome funnel — the pack's own stage vocabulary, edited
+    # hot. Blank stages = no funnel (parity). Stages: one per line.
+    def funnel_patch(r)
+      stages = lines(r.params["funnel_stages"])
+      return nil if stages.empty?
+
+      out = { "stages" => stages }
+      (p = presence(r.params["funnel_primary"])) && (out["primary"] = p)
+      (w = presence(r.params["funnel_attribution_window"])) && (out["attribution_window"] = w)
+      advance = json_block(r.params["funnel_advance_on"], "funnel advance_on")
+      out["advance_on"] = advance unless advance.nil? || advance.empty?
+      out
+    end
+
+    # the follow-up declaration. Blank arm = the feature is off
+    # (parity). The policy keys are all rendered; a blank one drops the key.
+    def followup_patch(r)
+      arm = presence(r.params["followup_arm"])
+      return nil unless arm
+
+      policy = {}
+      tz = presence(r.params["followup_tz"])
+      if tz
+        quiet = { "timezone" => tz }
+        (s = presence(r.params["followup_quiet_start"])) && (quiet["start"] = s)
+        (e = presence(r.params["followup_quiet_end"])) && (quiet["end"] = e)
+        policy["quiet_hours"] = quiet
+      end
+      (f = presence(r.params["followup_max_frequency"])) && (policy["max_frequency"] = f)
+      keywords = list(r.params["followup_cancel_keywords"])
+      policy["cancel_keywords"] = keywords unless keywords.empty?
+      silence = edge_int(r.params["followup_silence_after_sends"], "followup_silence_after_sends")
+      policy["silence_after_sends"] = silence unless silence.nil?
+      { "arm" => arm, "policy" => policy }
+    end
+
+    # recurring schedules — a JSON array of declarations
+    # (name / trigger / tz / message / session mode / overrides / enabled).
+    # Same honest shape as routes/metadata: the list is unbounded, and a
+    # JSON textarea is the CSP-safe editor. Blank = no schedules (parity).
+    def schedules_patch(r)
+      parsed = json_block(r.params["schedules"], "schedules")
+      return nil if parsed.nil?
+
+      parsed = parsed.is_a?(Hash) ? [parsed] : parsed
+      raise Insika::ValidationError, "schedules must be an array of declarations" unless parsed.is_a?(Array)
+
+      parsed
+    end
+
+    # distillation — enabled checkbox + the forge's knobs. Blank
+    # prompt/model drop the keys (the engine defaults take over).
+    def distill_patch(r)
+      enabled = r.params["distill_enabled"] == "1"
+      out = { "enabled" => enabled }
+      (p = presence(r.params["distill_prompt"])) && (out["prompt"] = p)
+      (m = presence(r.params["distill_model"])) && (out["model"] = m)
+      %w[idle_hours min_messages max_proposals].each do |key|
+        v = edge_int(r.params["distill_#{key}"], "distill_#{key}")
+        out[key] = v unless v.nil?
+      end
+      out
+    end
+
+    # the gated harvest. Same shape discipline as distill; the
+    # negative list is a JSON array of { rule, pattern, note }.
+    def harvest_patch(r)
+      enabled = r.params["harvest_enabled"] == "1"
+      out = { "enabled" => enabled }
+      (p = presence(r.params["harvest_prompt"])) && (out["prompt"] = p)
+      %w[idle_hours min_messages].each do |key|
+        v = edge_int(r.params["harvest_#{key}"], "harvest_#{key}")
+        out[key] = v unless v.nil?
+      end
+      negative = json_block(r.params["harvest_negative_list"], "harvest negative_list")
+      out["negative_list"] = negative unless negative.nil?
+      miner = harvest_miner_patch(r)
+      out["miner"] = miner unless miner.empty?
+      out
+    end
+
+    def harvest_miner_patch(r)
+      miner = {}
+      (m = presence(r.params["harvest_miner_model"])) && (miner["model"] = m)
+      window = {}
+      (w = edge_int(r.params["harvest_miner_window"], "harvest_miner_window")) && (window["last_sessions"] = w)
+      miner["window"] = window unless window.empty?
+      (m = edge_int(r.params["harvest_miner_max_proposals"], "harvest_miner_max_proposals")) && (miner["max_proposals"] = m)
+      budget = {}
+      (t = edge_int(r.params["harvest_miner_budget_tokens"], "harvest_miner_budget_tokens")) && (budget["tokens"] = t)
+      miner["budget"] = budget unless budget.empty?
+      miner
+    end
+
+    # Refinement: mode select + the report/propose/auto_apply knobs. Blank
+    # mode = report-only (the no-opt-in default — the form's "report" option
+    # writes it down explicitly).
+    def refinement_patch(r)
+      mode = presence(r.params["refinement_mode"])
+      out = { "mode" => mode } if mode
+      (w = edge_int(r.params["refinement_window"], "refinement_window")) && (out["window"] = { "last_sessions" => w })
+      (f = edge_int(r.params["refinement_max_findings"], "refinement_max_findings")) && (out["max_findings"] = f)
+      files = list(r.params["refinement_files"])
+      out["files"] = files unless files.empty?
+      proposers = list(r.params["refinement_proposers"])
+      out["proposers"] = proposers unless proposers.empty?
+      (t = edge_int(r.params["refinement_budget_tokens"], "refinement_budget_tokens")) && (out["budget"] = { "tokens" => t })
+      (e = edge_int(r.params["refinement_auto_apply_max_edits"], "refinement_auto_apply_max_edits")) && (out["auto_apply_max_edits"] = e)
+      out
+    end
+
+    # WS2: the calendar spend caps. All blank = no budget (parity).
+    def budget_patch(r)
+      daily = edge_int(r.params["budget_daily"], "budget_daily")
+      monthly = edge_int(r.params["budget_monthly"], "budget_monthly")
+      return nil if daily.nil? && monthly.nil?
+
+      out = {}
+      out["daily"] = daily unless daily.nil?
+      out["monthly"] = monthly unless monthly.nil?
+      (a = edge_float(r.params["budget_alert_at"], "budget_alert_at")) && (out["alert_at"] = a)
+      out["soft"] = r.params["budget_soft"] == "1"
+      out
+    end
+
+    # WS3: retries/backoff/fallback/breaker/timeout. All blank = the plain
+    # single attempt (parity).
+    def reliability_patch(r)
+      retries = edge_int(r.params["reliability_retries"], "reliability_retries")
+      backoff = presence(r.params["reliability_backoff"])
+      timeout = edge_int(r.params["reliability_timeout"], "reliability_timeout")
+      fallback = list(r.params["reliability_fallback"])
+      return nil if retries.nil? && backoff.nil? && timeout.nil? && fallback.empty?
+
+      out = {}
+      out["retries"] = retries unless retries.nil?
+      out["backoff"] = backoff if backoff
+      out["timeout"] = timeout unless timeout.nil?
+      out["fallback"] = fallback unless fallback.empty?
+      breaker = {}
+      %w[after within cooldown].each do |key|
+        v = edge_int(r.params["reliability_breaker_#{key}"], "reliability_breaker_#{key}")
+        breaker[key] = v unless v.nil?
+      end
+      out["circuit_breaker"] = breaker unless breaker.empty?
+      out
+    end
+
+    # WS6: the operator-alert webhook. Blank = no webhook (parity).
+    def alerts_patch(r)
+      url = presence(r.params["alerts_webhook"])
+      url ? { "webhook" => url } : nil
+    end
+
+    # Which internal channels may cross to the customer. Both checkboxes are
+    # rendered, so the patch reflects the whole state (false = held back).
+    def edge_stream_patch(r)
+      { "thinking" => r.params["edge_thinking"] == "1",
+        "intermediate" => r.params["edge_intermediate"] == "1" }
+    end
+
+    # skills_eager: blank = none (progressive disclosure, parity); "all" =
+    # blanket eager; otherwise a comma list of exactly these.
+    def skills_eager_patch(r)
+      raw = r.params["skills_eager"].to_s.strip
+      return nil if raw.empty?
+
+      raw == "all" ? true : list(raw)
+    end
+
+    # A JSON textarea -> parsed Hash/Array, or nil when blank. Malformed JSON
+    # is a ValidationError (a red flash, never a silent drop).
+    def json_patch(r, field)
+      json_block(r.params[field], field)
+    end
+
+    def json_block(raw, field)
+      text = raw.to_s.strip
+      return nil if text.empty?
+
+      begin
+        JSON.parse(text)
+      rescue JSON::ParserError => e
+        raise Insika::ValidationError, "#{field}: invalid JSON (#{e.message.lines.first.to_s.strip})"
+      end
+    end
+
+    # A comma-separated list field. Blank = [] (none) — the explicit empty
+    # reading; an allowlist-style field wants nil=all and should not use this.
+    def list_patch(r, field)
+      list(r.params[field])
+    end
+
+    # An ALLOWLIST-style field (nil = all, [] = none). Blank → nil (all), the
+    # open reading; a typed list closes it to exactly those names.
+    def allowlist_patch(r, field)
+      names = list(r.params[field])
+      names.empty? ? nil : names
+    end
+
+    def list(str)
+      str.to_s.split(/[,\n]/).map(&:strip).reject(&:empty?).uniq
+    end
+
+    # One non-blank token per line.
+    def lines(str)
+      str.to_s.lines.map(&:strip).reject(&:empty?)
+    end
+
+    # Guardrails config from the form. The config form OWNS the fields it
+    # renders, so the patch reflects the whole rendered state. String values
+    # round-trip cleanly through the JSON store; Safety::Config normalizes on
+    # read. A blank moderator drops the key (deterministic only).
+    #
+    # `corpora` (the removability knob — languages/extra) has NO
+    # form field: it is DSL/pack data (docs/domain.md), not Studio UI. The
+    # form must not erase it on save — carry the existing value through
+    # (the shallow patch merge would otherwise wipe it, the halt_when class).
     def guardrails_patch(r)
       out = {
         "input" => r.params["guardrail_input"] == "1",
@@ -51,6 +332,8 @@ module Studio
       (mod = presence(r.params["guardrail_moderator"])) && (out["moderator"] = mod)
       responses = guardrail_responses_patch(r)
       out["responses"] = responses unless responses.empty?
+      existing = @agent.guardrails || {}
+      out["corpora"] = existing["corpora"] if existing["corpora"]
       out
     end
 
@@ -173,6 +456,11 @@ module Studio
         v = presence(r.params[f])
         patch[f] = Integer(v) if v
       end
+      # memory TTL (days). Blank = off (nil); a number sets the
+      # platform default for EVERY cell. Saving here replaces an ops-authored
+      # per-tenant map in the record — the view says so.
+      v = presence(r.params["memory_ttl_days"])
+      patch["memory_ttl_days"] = v.nil? ? nil : Integer(v)
       patch
     end
 
@@ -302,19 +590,24 @@ module Studio
       }
     end
 
-    # MCP instance from the form. `env` comes as "KEY=value" lines (CSP
-    # forbids inline JS for add/remove line; a textarea is the simple, honest
-    # path). Masked values come back as a sentinel — keeping them preserves
-    # the secret; changing replaces; deleting the line clears it.
+    # MCP instance from the form (transport-aware, but the
+    # form always submits every field regardless of which the JS shows;
+    # McpStore stores them all either way). `env`/`headers` come as
+    # "KEY=value" lines, `args` as one argv token per line (CSP forbids
+    # inline JS for add/remove line; a textarea is the simple, honest path).
+    # Masked credential values come back as a sentinel — keeping them
+    # preserves the secret; changing replaces; deleting the line clears it.
     def mcp_patch(r)
       {
         name: presence(r.params["name"]),
         transport: presence(r.params["transport"]) || "stdio",
         command: r.params["command"].to_s,
+        args: split_lines(r.params["args"]),
         url: r.params["url"].to_s,
         description: r.params["description"].to_s,
         enabled: r.params["enabled"] == "1",
-        env: parse_kv_lines(r.params["env"])
+        env: parse_kv_lines(r.params["env"]),
+        headers: parse_kv_lines(r.params["headers"])
       }
     end
 
@@ -331,5 +624,10 @@ module Studio
         [k, v.to_s.strip]
       end.to_h
     end
+
+    # One argv token per line (stdio's `args`). Ignores blank lines/comments.
+    def split_lines(text)
+      text.to_s.each_line.map(&:strip).reject { |l| l.empty? || l.start_with?("#") }
+    end
   end
 end

data/lib/insika/studio/nav_icons.rb

@@ -20,12 +20,30 @@ module Studio
       tasks: '<path d="M11 12H3"/><path d="M16 6H3"/><path d="M16 18H3"/><path d="m18 9 3 3-3 3"/>',
       approvals: '<path d="M9 12l2 2 4-4"/><path d="M12 3a9 9 0 1 0 9 9"/>',
       refinement: '<path d="M21 12a9 9 0 1 1-3-6.7"/><path d="M21 3v5h-5"/><path d="m9 12 2 2 4-4"/>',
-      evals: '<path d="M9 11l3 3L22 4"/><path d="M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"/>'
+      evals: '<path d="M9 11l3 3L22 4"/><path d="M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11"/>',
+      parity: '<path d="M7 21h10"/><path d="M12 3v12"/><path d="m8 11 4 4 4-4"/><path d="M3 17h4l1.5-1.5L6 13 3 15.5z"/><path d="M21 17h-4l-1.5-1.5L18 13l3 2.5z"/>',
+      funnel: '<path d="M3 5h18l-8 9v6l-2 1v-7z"/>',
+      followups: '<path d="M18 8a6 6 0 0 0-12 0c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.7 21a2 2 0 0 1-3.4 0"/>',
+      facts: '<path d="M7 3h11a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H7z"/><path d="M7 3v18"/><path d="M11 8h5"/><path d="M11 12h5"/><path d="M11 16h3"/>',
+      harvest: '<path d="M4 20V10"/><path d="M20 20V4"/><path d="M4 10h4v10"/><path d="M20 4h-4v16"/><path d="M4 20h16"/><path d="m8 8 4-4 4 4"/>',
+      knowledge: '<path d="M9 18h6"/><path d="M10 22h4"/><path d="M12 2a7 7 0 0 0-4 12.7V17h8v-2.3A7 7 0 0 0 12 2z"/>',
+      artifacts: '<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><path d="M14 2v6h6"/><path d="m9.5 13 2 2 3.5-3.5"/><path d="M12 15v-4"/>'
     }.freeze
 
     def nav_icon(key)
       %(<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" ) +
         %(stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">#{NAV_ICONS[key]}</svg>)
     end
+
+    # Transcript event-chip icons: a tool call, a result, a
+    # skill, an artifact, a guardrail — each reuses a nav icon (same inline-SVG
+    # grammar, CSP-safe). Sized by the chip CSS, colored per kind.
+    CHIP_ICONS = { call: :tools, result: :approvals, skill: :skills,
+                   artifact: :artifacts, guardrail: :system }.freeze
+
+    def chip_icon(kind)
+      key = CHIP_ICONS[kind]
+      key ? %(<span class="chip-ic">#{nav_icon(key)}</span>) : ""
+    end
   end
 end

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

@@ -0,0 +1,25 @@
+<!-- ── Cache  ─────────────────────────────────────────────────── -->
+<section class="section" id="cache" data-tabs-target="panel">
+  <div class="section-head">
+    <h2>Cache</h2>
+    <p class="muted">prefix cache-hit per turn (provider-reported) — the invalidation reason names the first block whose bytes changed vs the previous turn.</p>
+  </div>
+  <div class="card">
+    <% if @cache_series.empty? %>
+      <p class="muted">No turns recorded.</p>
+    <% else %>
+      <ul class="kv">
+        <% @cache_series.last(20).reverse.each do |c| %>
+          <li>
+            <span class="k mono"><%= c["at"] %></span>
+            <span class="v">
+              <%== c["hit_pct"].nil? ? "—" : "#{c['hit_pct']}% cached" %>
+              · <%= c["cached_tokens"] %>/<%= c["prompt_tokens"] %> tokens
+              <% if c["invalidation_reason"] %><span class="lat">broke: <%= c["invalidation_reason"] %></span><% end %>
+            </span>
+          </li>
+        <% end %>
+      </ul>
+    <% end %>
+  </div>
+</section>