collavre 0.23.0 → 0.24.0

data/app/models/collavre/creative/describable.rb

@@ -18,7 +18,7 @@ module Collavre
 
         validates :description, presence: true, unless: -> { origin_id.present? }
         validate :description_cannot_change_if_has_origin, on: :update
-        validate :description_cannot_change_if_github_source, on: :update
+        validate :description_cannot_change_if_read_only_source, on: :update
 
         before_validation :convert_markdown_to_html
         before_save :sanitize_description_html
@@ -29,7 +29,13 @@ module Collavre
       # Linked Creative의 description을 안전하게 반환
       def effective_description(variation_id = nil, html = true)
         if variation_id.present?
-          variation_tag = tags.find_by(label_id: variation_id)
+          # `find_by` on a loaded association still round-trips; the browse tree
+          # preloads tags per level and reaches here once per node.
+          variation_tag = if tags.loaded?
+            tags.find { |tag| tag.label_id.to_s == variation_id.to_s }
+          else
+            tags.find_by(label_id: variation_id)
+          end
           return variation_tag.value if variation_tag&.value.present?
         end
         description_val = origin_id.nil? ? description : origin.description
@@ -44,11 +50,11 @@ module Collavre
         CGI.unescapeHTML(ActionController::Base.helpers.strip_tags(effective_origin.description || "")).truncate(24, omission: "...")
       end
 
-      # GitHub-synced creatives reject any description change
-      # (description_cannot_change_if_github_source), so embedding would raise
+      # Read-only-source creatives reject any description change
+      # (description_cannot_change_if_read_only_source), so embedding would raise
       # and orphan the blob. Callers MUST check this before creating the blob.
       def attachments_embeddable?
-        !effective_origin.github_markdown?
+        !effective_origin.read_only_source?
       end
 
       # Append an attachment node and save; after_save reconcile attaches the
@@ -362,12 +368,12 @@ module Collavre
         end
       end
 
-      def description_cannot_change_if_github_source
+      def description_cannot_change_if_read_only_source
         return unless will_save_change_to_description?
-        return unless github_markdown?
-        return if @skip_github_validation
+        return unless read_only_source?
+        return if skip_read_only_source_validation
 
-        errors.add(:description, "cannot be changed directly for GitHub synced content")
+        errors.add(:description, I18n.t("collavre.creatives.errors.description_read_only_source"))
       end
     end
   end

data/app/models/collavre/creative/linkable.rb

@@ -7,6 +7,15 @@ module Collavre
         belongs_to :origin, class_name: "Collavre::Creative", optional: true
         has_many :linked_creatives, class_name: "Collavre::Creative", foreign_key: :origin_id, dependent: :destroy
 
+        # origin_id is immutable once a record is persisted. Permission
+        # resolution (PermissionChecker / PermissionFilter) treats a linked
+        # creative as its origin, and the permission cache has no invalidation
+        # path for a moved origin link. Promote the "origin_id is immutable"
+        # invariant from controller param-stripping to a model-level guard so
+        # no mutation path (mass-assignment, console, future controllers) can
+        # silently repoint a link and desync permissions.
+        attr_readonly :origin_id
+
         validate :origin_cannot_be_self
         before_validation :redirect_parent_to_origin
       end

data/app/models/collavre/creative/permissible.rb

@@ -3,13 +3,30 @@ module Collavre
     module Permissible
       extend ActiveSupport::Concern
 
+      # Single declarative registry of which persisted-attribute changes
+      # invalidate the permission cache, and how each is rebuilt. A single
+      # after_commit dispatcher maps the accumulated changes through this map so
+      # a new mutation path can never silently skip a required rebuild.
+      #
+      #   :rebuild       -> rebuild_for_creative (self + descendant subtree)
+      #   :rebuild_owner -> update_owner (move the owner cache entry)
+      #
+      # origin_id is immutable after create (see Linkable#attr_readonly), so its
+      # entry only fires on link creation and is defensive.
+      PERMISSION_INVALIDATING_ATTRIBUTES = {
+        "parent_id" => :rebuild,
+        "user_id"   => :rebuild_owner,
+        "origin_id" => :rebuild
+      }.freeze
+
       included do
         has_many :creative_shares, class_name: "Collavre::CreativeShare", dependent: :destroy
         has_many :creative_shares_caches, class_name: "Collavre::CreativeSharesCache", dependent: :delete_all
 
-        after_commit :rebuild_permission_cache, if: :saved_change_to_parent_id?, unless: :destroyed?
+        after_save :accumulate_permission_cache_changes
+        after_commit :dispatch_permission_cache_invalidation, unless: :destroyed?
         after_commit :cache_owner_permission, on: :create
-        after_commit :update_owner_cache, if: :saved_change_to_user_id?, unless: :destroyed?
+        after_rollback :clear_accumulated_permission_changes
       end
 
       def has_permission?(user, required_permission = :read)
@@ -23,42 +40,21 @@ module Collavre
         children_ids = children_scope.pluck(:id)
         return [] if children_ids.empty?
 
-        min_rank = CreativeShare.permissions[min_permission.to_s]
-        accessible_ids = Set.new
-
-        if user
-          user_entries = CreativeSharesCache
-            .where(creative_id: children_ids, user_id: user.id)
-            .pluck(:creative_id, :permission)
-
-          user_has_entry = Set.new
-          user_entries.each do |cid, perm|
-            user_has_entry << cid
-            perm_rank = CreativeSharesCache.permissions[perm]
-            if perm_rank && perm_rank >= min_rank && perm_rank != CreativeSharesCache.permissions[:no_access]
-              accessible_ids << cid
-            end
-          end
-
-          public_accessible = CreativeSharesCache
-            .where(creative_id: children_ids, user_id: nil)
-            .where("permission >= ?", min_rank)
-            .where.not(permission: :no_access)
-            .pluck(:creative_id)
-          accessible_ids.merge(public_accessible - user_has_entry.to_a)
-
-          owned_ids = children_scope.where(user_id: user.id).pluck(:id)
-          accessible_ids.merge(owned_ids)
-        else
-          accessible_ids = CreativeSharesCache
-            .where(creative_id: children_ids, user_id: nil)
-            .where("permission >= ?", min_rank)
-            .where.not(permission: :no_access)
-            .pluck(:creative_id)
-            .to_set
-        end
-
-        children_scope.where(id: accessible_ids.to_a).order(:sequence).to_a
+        # The deny-invariant (owner wins → user entry, incl. a no_access deny,
+        # beats public → effective-origin resolution) now lives in exactly one
+        # place: PermissionFilter. This site used to re-implement it inline.
+        accessible_ids = Collavre::Creatives::PermissionFilter.new(user: user)
+          .readable_ids(children_ids, min_permission: min_permission)
+
+        # readable_ids gates a linked shell on its origin being readable AND the
+        # viewer being able to see the shell's placement (owns it, or it sits in
+        # a subtree shared with the viewer). Listing one's OWN tree keeps the
+        # prior policy that a viewer always sees their own children — including a
+        # shell they own whose origin is no longer shared with them — so union
+        # those owned rows back in. (Owner has admin, so this is rank-independent.)
+        accessible_ids |= children_scope.where(user_id: user.id).pluck(:id) if user
+
+        children_scope.where(id: accessible_ids).order(:sequence).to_a
       end
 
       def all_shared_users(required_permission = :no_access)
@@ -105,21 +101,73 @@ module Collavre
 
       private
 
-      def rebuild_permission_cache
-        PermissionCacheJob.perform_later(:rebuild_for_creative, creative_id: id)
+      # Accumulate permission-affecting changes across every save in the
+      # transaction. after_commit sees only the *final* save's saved_changes, so
+      # if a permission attribute changes in one save and a later same-
+      # transaction save of this record touches only untracked columns, that
+      # permission change is clobbered out of saved_changes and a saved_changes-
+      # gated dispatcher would skip the rebuild, leaving the permission cache
+      # stale (fail-open, with no TTL/self-heal). Merging each save's changes
+      # keeps the invariant regardless of save ordering. This mirrors the fail-
+      # closed intent of the CreativeShare fix (#1393 / 00502d7d); it is
+      # centralized here via cross-save accumulation rather than an
+      # unconditional refresh so that permission-irrelevant Creative updates
+      # (progress rollup, description edits — a hot write path) stay cheap.
+      #
+      # No production path performs two real saves touching a permission
+      # attribute then an untracked column on one Creative in a single
+      # transaction today (the reorderer re-saves :sequence via update_column,
+      # which does not run changes_applied and so preserves saved_changes), so
+      # this is a defensive/latent fix. Note: update_column bypasses this
+      # callback too, which is why the reorderer's parent change still refreshes.
+      def accumulate_permission_cache_changes
+        changes = saved_changes.slice(*PERMISSION_INVALIDATING_ATTRIBUTES.keys)
+        return if changes.empty?
+
+        @accumulated_permission_changes ||= {}
+        changes.each do |attribute, (old_value, new_value)|
+          existing = @accumulated_permission_changes[attribute]
+          # Keep the earliest "old" and the latest "new" across saves.
+          @accumulated_permission_changes[attribute] = [ existing ? existing.first : old_value, new_value ]
+        end
       end
 
-      def cache_owner_permission
-        PermissionCacheJob.perform_later(:cache_owner, creative_id: id)
+      def clear_accumulated_permission_changes
+        @accumulated_permission_changes = nil
       end
 
-      def update_owner_cache
-        old_user_id, new_user_id = saved_change_to_user_id
-        PermissionCacheJob.perform_later(:update_owner,
-          creative_id: id,
-          old_user_id: old_user_id,
-          new_user_id: new_user_id
-        )
+      # Single dispatch point for permission-cache invalidation. Maps the
+      # accumulated permission-attribute changes through
+      # PERMISSION_INVALIDATING_ATTRIBUTES and enqueues each distinct rebuild
+      # exactly once.
+      def dispatch_permission_cache_invalidation
+        accumulated = @accumulated_permission_changes || {}
+        clear_accumulated_permission_changes
+
+        operations = accumulated.keys
+          .map { |attr| PERMISSION_INVALIDATING_ATTRIBUTES[attr] }
+          .uniq
+        return if operations.empty?
+
+        operations.each { |operation| run_permission_cache_operation(operation, accumulated) }
+      end
+
+      def run_permission_cache_operation(operation, accumulated)
+        case operation
+        when :rebuild
+          PermissionCacheJob.perform_later(:rebuild_for_creative, creative_id: id)
+        when :rebuild_owner
+          old_user_id, new_user_id = accumulated["user_id"]
+          PermissionCacheJob.perform_later(:update_owner,
+            creative_id: id,
+            old_user_id: old_user_id,
+            new_user_id: new_user_id
+          )
+        end
+      end
+
+      def cache_owner_permission
+        PermissionCacheJob.perform_later(:cache_owner, creative_id: id)
       end
     end
   end

data/app/models/collavre/creative.rb

@@ -5,6 +5,40 @@ module Collavre
   class Creative < ApplicationRecord
     self.table_name = "creatives"
 
+    # ---------------------------------------------------------------------------
+    # Reserved metadata key registry — engines register their own namespaces so
+    # `update_metadata` preserves them without core naming vendor-specific keys.
+    # ---------------------------------------------------------------------------
+    BUILTIN_RESERVED_METADATA_KEYS = %w[markdown_source content_type editor].freeze
+
+    class << self
+      def registered_reserved_metadata_keys
+        @registered_reserved_metadata_keys ||= []
+      end
+
+      def register_reserved_metadata_key(key)
+        registered_reserved_metadata_keys << key.to_s unless registered_reserved_metadata_keys.include?(key.to_s)
+      end
+
+      def reserved_metadata_keys
+        (BUILTIN_RESERVED_METADATA_KEYS + registered_reserved_metadata_keys).freeze
+      end
+
+      # ------------------------------------------------------------------------
+      # Read-only source registry — vendor engines register the `data.source.type`
+      # values whose content is owned by an external system (e.g. a synced GitHub
+      # repository) and therefore must not be edited in-app. Core enforces the
+      # read-only behavior via `read_only_source?` without naming any vendor.
+      # ------------------------------------------------------------------------
+      def read_only_source_types
+        @read_only_source_types ||= Set.new
+      end
+
+      def register_read_only_source(type)
+        read_only_source_types << type.to_s
+      end
+    end
+
     # Use non-namespaced partial path for backward compatibility
     def to_partial_path
       "creatives/creative"
@@ -43,10 +77,28 @@ module Collavre
       data&.dig("kind") == "inbox"
     end
 
-    attr_accessor :skip_github_validation
+    # Bypass the read-only-source guard for a single save (used by the vendor
+    # sync services that legitimately write the synced content into core).
+    attr_accessor :skip_read_only_source_validation
+
+    # The registered source identifier for this creative, or nil when the
+    # description is authored in-app.
+    def source_type
+      data.is_a?(Hash) ? data.dig("source", "type") : nil
+    end
+
+    # Whether this creative's description is owned by an external, registered
+    # source and therefore read-only in-app.
+    def read_only_source?
+      type = source_type
+      type.present? && self.class.read_only_source_types.include?(type)
+    end
 
+    # GitHub-sourced content still needs a vendor-specific predicate for the
+    # comment view's inline-image rendering (a GitHub-only concern, distinct
+    # from the neutral read-only behavior above).
     def github_markdown?
-      data.is_a?(Hash) && data.dig("source", "type") == "github_markdown"
+      source_type == "github_markdown"
     end
 
     # Find or create the "System" topic for this inbox creative.
@@ -133,7 +185,14 @@ module Collavre
 
     after_save :update_parent_progress
     after_destroy :update_parent_progress
-    after_save :update_mcp_tools
+    # Re-derive MCP tools only when the description (the tool source of truth)
+    # actually changed, and defer the HTML parsing to a background job so it
+    # never runs inline on progress/move/autosave writes. The dirty flag is
+    # captured in after_save (where saved_change_to_description? is reliable);
+    # a later same-transaction save can clobber saved_changes before the
+    # after_commit hook runs.
+    after_save :mark_mcp_tools_sync_pending, if: :saved_change_to_description?
+    after_commit :enqueue_mcp_tools_sync, if: :mcp_tools_sync_pending?
 
     # --- Drop Trigger ---
     def drop_trigger_enabled?
@@ -292,8 +351,17 @@ module Collavre
       @progress_service ||= Collavre::Creatives::ProgressService.new(self)
     end
 
-    def update_mcp_tools
-      McpService.new.update_from_creative(self)
+    def mark_mcp_tools_sync_pending
+      @mcp_tools_sync_pending = true
+    end
+
+    def mcp_tools_sync_pending?
+      @mcp_tools_sync_pending == true
+    end
+
+    def enqueue_mcp_tools_sync
+      @mcp_tools_sync_pending = false
+      UpdateMcpToolsJob.perform_later(id)
     end
 
     def progress_cannot_change_if_has_origin

data/app/models/collavre/creative_share.rb

@@ -20,11 +20,32 @@ module Collavre
     validates :permission, presence: true
     validates :user_id, uniqueness: { scope: :creative_id }, allow_nil: true
 
+    # Single declarative registry mirroring Creative::Permissible: which
+    # persisted CreativeShare attributes affect the permission cache, and how.
+    # Every create and update re-propagates the share unconditionally (see
+    # dispatch_share_cache_invalidation) — a fail-closed refresh that matches
+    # the prior propagate_cache and survives a multi-save transaction clobbering
+    # an earlier permission change out of the final saved_changes. This map
+    # governs the *extra* cleanup a move or reassignment needs on top of that
+    # base refresh, so a new share-mutation path still can't silently skip it:
+    #
+    #   :relocate    -> creative_id moved: purge this share's rows and rebuild
+    #                   the vacated (old creative, old user) subtree
+    #   :reassign    -> user_id changed: purge this share's rows and rebuild the
+    #                   old user's subtree at the current creative
+    #   :repropagate -> permission changed: covered by the unconditional
+    #                   re-propagate above (listed to document the invariant)
+    PERMISSION_INVALIDATING_ATTRIBUTES = {
+      "creative_id" => :relocate,
+      "user_id"     => :reassign,
+      "permission"  => :repropagate
+    }.freeze
+
     after_create_commit :notify_recipient, unless: :no_access?
     after_save :touch_creative_subtree
     after_destroy :touch_creative_subtree
 
-    after_commit :propagate_cache, on: [ :create, :update ]
+    after_commit :dispatch_share_cache_invalidation, on: [ :create, :update ]
     after_commit :broadcast_share_change, on: [ :create, :update ]
     after_destroy_commit :remove_cache
     after_destroy_commit :broadcast_share_destroy
@@ -92,34 +113,65 @@ module Collavre
       Creative.exists?(origin_id: creative.id, user_id: user.id)
     end
 
-    def propagate_cache
-      # If creative_id or user_id changed, handle old cache entries properly
-      if saved_change_to_creative_id? || saved_change_to_user_id?
-        # Delete only caches created by THIS share (fast operation, keep synchronous)
-        CreativeSharesCache.where(source_share_id: id).delete_all
-
-        # Rebuild caches for old user in old subtree (background job)
-        if saved_change_to_creative_id?
-          old_creative_id = creative_id_before_last_save
-          old_user_id = user_id_before_last_save || user_id
-          if old_creative_id
-            PermissionCacheJob.perform_later(:rebuild_user_cache_for_subtree,
-              creative_id: old_creative_id,
-              user_id: old_user_id
-            )
-          end
-        elsif saved_change_to_user_id?
-          old_user_id = user_id_before_last_save
-          if old_user_id
-            PermissionCacheJob.perform_later(:rebuild_user_cache_for_subtree,
-              creative_id: creative_id,
-              user_id: old_user_id
-            )
-          end
+    # Single dispatch point for permission-cache invalidation on share writes.
+    # Every create and update re-propagates the share unconditionally — a
+    # fail-closed refresh matching the prior propagate_cache, correct even when
+    # a multi-save transaction clobbers an earlier permission change out of the
+    # final saved_changes. On an update, a move (creative_id) or reassignment
+    # (user_id) additionally purges the stale rows this share left behind — the
+    # purge is carried on the same propagate_share job (purge_stale:) rather than
+    # deleted synchronously, so timing is uniform and it no longer blocks commit.
+    def dispatch_share_cache_invalidation
+      propagate_args = { creative_share_id: id }
+
+      unless previously_new_record?
+        operations = (saved_changes.keys & PERMISSION_INVALIDATING_ATTRIBUTES.keys)
+          .map { |attr| PERMISSION_INVALIDATING_ATTRIBUTES[attr] }
+          .uniq
+
+        # A move (creative_id) or reassignment (user_id) leaves stale rows keyed
+        # to this share. The purge rides ON the propagate_share job (purge_stale:
+        # true), which deletes those rows immediately before re-propagating — in
+        # one job, never as a standalone enqueue. The authz queue runs two
+        # threads, so a separate purge could otherwise run AFTER propagate and
+        # delete the freshly written rows (both key on source_share_id), dropping
+        # the share's access until an unrelated rebuild. Folding it in keeps the
+        # work async (off the commit path) so the revoke of the vacated access is
+        # merely deferred by the queue latency (~1-2s) — it only PROLONGS an
+        # already-granted permission by that window, never grants a new one,
+        # which the CTO judged acceptable for the perf win. Then rebuild the
+        # vacated subtree. creative_id takes precedence when both change,
+        # preserving the prior branch order.
+        if operations.include?(:relocate) || operations.include?(:reassign)
+          propagate_args[:purge_stale] = true
+          rebuild_vacated_subtree(relocated: operations.include?(:relocate))
         end
       end
 
-      PermissionCacheJob.perform_later(:propagate_share, creative_share_id: id)
+      PermissionCacheJob.perform_later(:propagate_share, **propagate_args)
+    end
+
+    # Rebuild the cache the moved/reassigned share vacated, for the old user in
+    # the old location, so an ancestor share (or its absence) is re-applied.
+    def rebuild_vacated_subtree(relocated:)
+      if relocated
+        old_creative_id = creative_id_before_last_save
+        old_user_id = user_id_before_last_save || user_id
+        return unless old_creative_id
+
+        PermissionCacheJob.perform_later(:rebuild_user_cache_for_subtree,
+          creative_id: old_creative_id,
+          user_id: old_user_id
+        )
+      else
+        old_user_id = user_id_before_last_save
+        return unless old_user_id
+
+        PermissionCacheJob.perform_later(:rebuild_user_cache_for_subtree,
+          creative_id: creative_id,
+          user_id: old_user_id
+        )
+      end
     end
 
     def remove_cache

data/app/models/collavre/inbox_item.rb

@@ -16,10 +16,10 @@ module Collavre
     after_commit :broadcast_badge_update, on: %i[create update destroy]
     after_create_commit :enqueue_push_notification
 
-    attribute :state, :string, default: "new"
-    validates :state, inclusion: { in: %w[new read archived] }
+    enum :state, { new: "new", read: "read", archived: "archived" }, default: :new, scopes: false
     validates :message_key, presence: true
 
+    # Kept explicit (not enum's generated `.new` class-scope, which collides with the constructor).
     scope :new_items, -> { where(state: "new") }
 
     def localized_message(locale: I18n.locale)

data/app/models/collavre/task.rb

@@ -11,6 +11,18 @@ module Collavre
 
     validates :name, presence: true
 
+    enum :status, {
+      pending: "pending",
+      queued: "queued",
+      running: "running",
+      delegated: "delegated",
+      pending_approval: "pending_approval",
+      done: "done",
+      failed: "failed",
+      cancelled: "cancelled",
+      escalated: "escalated"
+    }, default: :pending
+
     after_update_commit :check_trigger_loop_completion, if: :trigger_loop_candidate?
     after_update_commit :broadcast_stop_button_removal, if: :became_terminal?
 

data/app/models/collavre/user.rb

@@ -132,12 +132,14 @@ module Collavre
     end
 
     # Whether this agent uses stateful sessions (incremental messaging).
-    # nil in agent_conf = auto-detect by vendor (openclaw → true).
+    # nil in agent_conf = auto-detect via the AiClient adapter layer, which
+    # vendor engines register into (core never string-matches a vendor name).
     def supports_session?
       explicit = parsed_agent_conf.dig("session", "enabled")
       return ActiveModel::Type::Boolean.new.cast(explicit) unless explicit.nil?
+      return false if llm_vendor.blank?
 
-      llm_vendor&.downcase == "openclaw"
+      Collavre::AiClient.vendor_supports_session?(llm_vendor)
     end
 
     encrypts :llm_api_key, deterministic: false
@@ -183,12 +185,17 @@ module Collavre
       device_on && location_on
     end
 
-    LLM_VENDOR_OPTIONS = [
-      [ "Google (Gemini)", "google" ],
-      [ "OpenAI", "openai" ],
-      [ "Anthropic", "anthropic" ],
-      [ "OpenClaw", "openclaw" ]
-    ].freeze
+    # LLM_VENDOR_OPTIONS is resolved dynamically from the AiClient vendor-option
+    # registry so core lists only its built-in providers while vendor engines
+    # (e.g. OpenClaw) contribute their own. Resolved lazily via const_missing so
+    # the value always reflects registrations made after this class first loads
+    # (they run in a to_prepare hook), and existing views keep referring to the
+    # constant unchanged.
+    def self.const_missing(name)
+      return Collavre::AiClient.vendor_options if name == :LLM_VENDOR_OPTIONS
+
+      super
+    end
 
     SUPPORTED_LLM_MODELS = [
       "gemini-3.1-flash-lite",
@@ -314,7 +321,24 @@ module Collavre
     # Destroy creatives deepest-first so closure_tree always finds its parent
     def destroy_creatives_leaf_first
       all_creatives = creatives.flat_map { |c| c.self_and_descendants.to_a }.uniq
-      all_creatives.sort_by { |c| -c.self_and_ancestors.count }.each do |c|
+
+      # Order by depth in memory. The subtree is contiguous within all_creatives
+      # (every node between an owned root and its descendant is itself a
+      # descendant), so following parent_id links yields the same leaf-first
+      # ordering as self_and_ancestors.count without firing a COUNT query per
+      # creative (the previous N+1).
+      by_id = all_creatives.index_by(&:id)
+      depth_of = lambda do |creative|
+        depth = 0
+        node = creative
+        while node&.parent_id && (parent = by_id[node.parent_id])
+          depth += 1
+          node = parent
+        end
+        depth
+      end
+
+      all_creatives.sort_by { |c| -depth_of.call(c) }.each do |c|
         c.reload.destroy! if Creative.exists?(c.id)
       end
     end

data/app/models/concerns/collavre/indexed_json_columns.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Collavre
+  # Keeps denormalized real columns in lockstep with keys stored inside a JSON
+  # column, so database indexes can be defined over plain columns instead of
+  # JSON expressions.
+  #
+  # WHY: A JSON-expression index serializes per-adapter --
+  # `json_extract(config, '$.x')` on SQLite vs `config->>'x'` on PostgreSQL.
+  # Because schema.rb is dumped from the SQLite dev DB, it carries the
+  # `json_extract` form, which is not a PostgreSQL function, so
+  # `db:schema:load` crashes on the prod PostgreSQL database. Promote the JSON
+  # key to a real column (which indexes and dumps identically on both adapters)
+  # and keep it synced from the JSON column on every save. The JSON column
+  # stays the source of truth; the promoted columns are re-derived on each save.
+  #
+  # Usage:
+  #   include Collavre::IndexedJsonColumns
+  #
+  #   indexed_json_columns json: :config, columns: {
+  #     repo_full_name: "repo_full_name",
+  #     pr_number:      "pr_number",
+  #   }
+  #
+  # `json:` names the JSON attribute (source of truth). `columns:` maps each
+  # promoted column to the JSON key it mirrors. A before_save re-derives every
+  # promoted column from the JSON attribute so the plain-column indexes enforce
+  # the same guarantees the JSON-expression indexes did.
+  module IndexedJsonColumns
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :indexed_json_source, instance_writer: false, default: nil
+      class_attribute :indexed_json_column_map, instance_writer: false, default: {}.freeze
+    end
+
+    class_methods do
+      def indexed_json_columns(json:, columns:)
+        self.indexed_json_source = json.to_sym
+        self.indexed_json_column_map =
+          columns.each_with_object({}) { |(col, key), m| m[col.to_s] = key.to_s }.freeze
+        before_save :sync_indexed_json_columns
+      end
+    end
+
+    private
+
+    # Re-derive each promoted column from its JSON key. Reads the JSON attribute
+    # (source of truth) and writes through `[]=` so subtype reader overrides are
+    # bypassed and only genuinely changed values dirty the record.
+    def sync_indexed_json_columns
+      json = public_send(indexed_json_source) || {}
+      indexed_json_column_map.each do |column, json_key|
+        self[column] = json[json_key]
+      end
+    end
+  end
+end

data/app/services/collavre/agent_type_classifier.rb

@@ -0,0 +1,23 @@
+module Collavre
+  # Classifies an AI user/agent into a coarse role type by scanning its
+  # system prompt. Shared by the orchestration and system-events context
+  # builders so the prompt-to-type mapping lives in exactly one place.
+  module AgentTypeClassifier
+    module_function
+
+    # Returns the agent type string ("developer", "pm", "qa", "researcher",
+    # "marketer", "planner") or "agent" as the default when nothing matches.
+    def classify(user)
+      prompt = user.system_prompt.to_s.downcase
+      case prompt
+      when /developer|개발/ then "developer"
+      when /pm|project.?manager|프로젝트/ then "pm"
+      when /qa|test|quality|테스트|품질/ then "qa"
+      when /research|조사|연구/ then "researcher"
+      when /market|마케팅/ then "marketer"
+      when /plan|기획/ then "planner"
+      else "agent"
+      end
+    end
+  end
+end