open-loam 0.1.1 → 0.3.0

data/lib/generators/{loam → open_loam}/primary_key_options.rb

@@ -1,8 +1,8 @@
-module Loam
+module OpenLoam
   module Generators
-    # Shared primary-key shaping for `loam:install` and `loam:entity`.
+    # Shared primary-key shaping for `open_loam:install` and `open_loam:entity`.
     #
-    # Loam's migrations used to spell every key `bigint` — implicitly in
+    # OpenLoam's migrations used to spell every key `bigint` — implicitly in
     # `create_table`, and explicitly in `t.references` and the polymorphic
     # `*_id` columns. In an app whose own tables use string or uuid keys the
     # foreign keys then do not line up with the tables they point at, and every
@@ -10,7 +10,7 @@ module Loam
     #
     # The key type is taken from, in order: an explicit --primary-key-type, the
     # host app's own `config.generators` setting (so an app that already told
-    # Rails what its keys look like does not have to tell Loam separately), and
+    # Rails what its keys look like does not have to tell OpenLoam separately), and
     # bigint as the Rails default.
     #
     # The templates ask for the *rendered fragment* rather than the type, so
@@ -34,15 +34,15 @@ module Loam
 
       private
 
-      def loam_key_type
-        @loam_key_type ||= begin
+      def open_loam_key_type
+        @open_loam_key_type ||= begin
           requested = (options[:primary_key_type] || host_app_primary_key_type).to_s
           requested = "bigint" if requested.empty?
 
           unless SUPPORTED.include?(requested)
             raise Thor::Error,
-                  "Unsupported --primary-key-type #{requested.inspect}. Loam generates #{SUPPORTED.join(', ')}. " \
-                  "A key type Loam does not know how to size would produce migrations that look right and " \
+                  "Unsupported --primary-key-type #{requested.inspect}. OpenLoam generates #{SUPPORTED.join(', ')}. " \
+                  "A key type OpenLoam does not know how to size would produce migrations that look right and " \
                   "do not line up with your tables."
           end
 
@@ -60,40 +60,40 @@ module Loam
         nil
       end
 
-      def loam_key_limit
+      def open_loam_key_limit
         return options[:key_limit].to_i if options[:key_limit]
 
-        loam_key_type == :string ? DEFAULT_STRING_LIMIT : nil
+        open_loam_key_type == :string ? DEFAULT_STRING_LIMIT : nil
       end
 
       # Appended to `create_table :x` — "" for bigint, so the default path is
       # byte-for-byte what it was.
-      def loam_id_option
-        return "" if loam_key_type == :bigint
+      def open_loam_id_option
+        return "" if open_loam_key_type == :bigint
 
-        "#{loam_key_fragment.sub('type:', 'id:')}"
+        "#{open_loam_key_fragment.sub('type:', 'id:')}"
       end
 
       # Appended inside `t.references :x, ...`.
-      def loam_type_option
-        return "" if loam_key_type == :bigint
+      def open_loam_type_option
+        return "" if open_loam_key_type == :bigint
 
-        loam_key_fragment
+        open_loam_key_fragment
       end
 
       # The bare column type for a polymorphic or un-constrained `*_id`, which
       # cannot use t.references.
-      def loam_key_column_type
-        loam_key_type
+      def open_loam_key_column_type
+        open_loam_key_type
       end
 
-      def loam_key_limit_option
-        loam_key_limit ? ", limit: #{loam_key_limit}" : ""
+      def open_loam_key_limit_option
+        open_loam_key_limit ? ", limit: #{open_loam_key_limit}" : ""
       end
 
-      def loam_key_fragment
-        fragment = ", type: :#{loam_key_type}"
-        fragment += ", limit: #{loam_key_limit}" if loam_key_limit
+      def open_loam_key_fragment
+        fragment = ", type: :#{open_loam_key_type}"
+        fragment += ", limit: #{open_loam_key_limit}" if open_loam_key_limit
         fragment
       end
     end

data/lib/open-loam.rb

@@ -1,5 +1,5 @@
 # Bundler auto-requires the gem's name ("open-loam") on load. The library's
-# entry point and whole namespace are `loam` / `Loam::` — the gem is only
+# entry point and whole namespace are `open_loam` / `OpenLoam::` — the gem is only
 # *distributed* as open-loam (the plain `loam` name is taken on RubyGems). This
 # shim bridges the two so `gem "open-loam"` works with the default require.
-require_relative "loam"
+require_relative "open_loam"

data/lib/{loam → open_loam}/attachable.rb

@@ -1,10 +1,10 @@
-module Loam
+module OpenLoam
   # Files on a record, via ActiveStorage:
   #
   #   equipment.files.attach(io: File.open(path), filename: "manual.pdf")
   #   equipment.files.each { |file| url_for(file) }
   #
-  # KNOWN BOUNDARY: ActiveStorage blobs live in global tables that Loam does
+  # KNOWN BOUNDARY: ActiveStorage blobs live in global tables that OpenLoam does
   # NOT tenant-scope. The association is scoped (a record only ever lists its
   # own files, and the record is tenant-scoped), but a signed blob URL is a
   # bearer capability: whoever holds the link can fetch the file, with no
@@ -15,8 +15,8 @@ module Loam
 
     included do
       unless respond_to?(:has_many_attached)
-        raise Loam::Error,
-              "#{name} includes Loam::Attachable but ActiveStorage is not available. " \
+        raise OpenLoam::Error,
+              "#{name} includes OpenLoam::Attachable but ActiveStorage is not available. " \
               "Run `bin/rails active_storage:install && bin/rails db:migrate`, or remove the include " \
               "(this app was probably generated with --skip-active-storage)."
       end

data/lib/{loam → open_loam}/auditable.rb

@@ -1,6 +1,6 @@
-module Loam
+module OpenLoam
   # Audit-by-default. Included in every generated entity: create/update/destroy
-  # writes a Loam::AuditRecord tagged with tenant + actor + changeset. "Who
+  # writes a OpenLoam::AuditRecord tagged with tenant + actor + changeset. "Who
   # changed the excavator's price, and when" is answered structurally, not by
   # remembering to log.
   module Auditable
@@ -9,54 +9,54 @@ module Loam
     IGNORED_ATTRIBUTES = %w[updated_at created_at].freeze
 
     included do
-      after_create  { loam_audit("create") }
-      after_update  { loam_audit(loam_audit_action) if loam_audit_changes.any? }
-      after_destroy { loam_audit("destroy") }
+      after_create  { open_loam_audit("create") }
+      after_update  { open_loam_audit(open_loam_audit_action) if open_loam_audit_changes.any? }
+      after_destroy { open_loam_audit("destroy") }
     end
 
     private
 
-    # Relabel the audit that the save inside the block writes. Loam::SoftDeletable
+    # Relabel the audit that the save inside the block writes. OpenLoam::SoftDeletable
     # uses this to record a soft-delete (an UPDATE) as "soft_delete"/"restore"
     # rather than the "update" it would otherwise be — one audit path, reused,
     # not a second one to keep in sync.
-    def loam_audit_as(action)
-      previous = @loam_audit_action
-      @loam_audit_action = action
+    def open_loam_audit_as(action)
+      previous = @open_loam_audit_action
+      @open_loam_audit_action = action
       yield
     ensure
-      @loam_audit_action = previous
+      @open_loam_audit_action = previous
     end
 
-    def loam_audit_action
-      @loam_audit_action || "update"
+    def open_loam_audit_action
+      @open_loam_audit_action || "update"
     end
 
-    def loam_audit(action)
-      Loam::AuditRecord.create!(
+    def open_loam_audit(action)
+      OpenLoam::AuditRecord.create!(
         auditable_type: self.class.name,
         auditable_id: id,
         action: action,
-        actor_id: Loam::Current.actor&.id,
-        changeset: action == "destroy" ? {} : loam_audit_changes
+        actor_id: OpenLoam::Current.actor&.id,
+        changeset: action == "destroy" ? {} : open_loam_audit_changes
       )
     end
 
-    def loam_audit_changes
+    def open_loam_audit_changes
       changes = saved_changes.except(*IGNORED_ATTRIBUTES)
-      loam_redact_encrypted(changes)
+      open_loam_redact_encrypted(changes)
     end
 
     # The audit trail must record the FACT that an encrypted field changed, never
     # its value — neither the plaintext nor the ciphertext (a ciphertext still
     # leaks length and, over time, correlations). So an encrypted column's change
     # becomes "[encrypted]", and its blind-index sibling is dropped entirely.
-    # A no-op for models without Loam::Encryptable.
-    def loam_redact_encrypted(changes)
-      return changes unless self.class.respond_to?(:loam_encrypted_attributes)
+    # A no-op for models without OpenLoam::Encryptable.
+    def open_loam_redact_encrypted(changes)
+      return changes unless self.class.respond_to?(:open_loam_encrypted_attributes)
 
-      encrypted = self.class.loam_encrypted_attributes.map(&:to_s)
-      hash_columns = self.class.loam_searchable_encrypted_attributes.map { |name| "#{name}_hash" }
+      encrypted = self.class.open_loam_encrypted_attributes.map(&:to_s)
+      hash_columns = self.class.open_loam_searchable_encrypted_attributes.map { |name| "#{name}_hash" }
 
       changes.each_with_object({}) do |(column, values), redacted|
         next if hash_columns.include?(column)

data/lib/{loam → open_loam}/auth_throttle.rb

@@ -1,12 +1,12 @@
-module Loam
+module OpenLoam
   # Rate-limiting + lockout for authentication, to blunt online brute-force of
   # passwords and (especially) 6-digit TOTP codes. A DB-backed counter keyed by
   # the submitted identifier: after N failures within a window, the identifier is
   # locked; a success clears the counter.
   #
-  #   Loam::AuthThrottle.locked?(email)                      # refuse if true
-  #   Loam::AuthThrottle.record_failure(email, kind: "password", ip: request.ip)
-  #   Loam::AuthThrottle.clear(email)                        # on success
+  #   OpenLoam::AuthThrottle.locked?(email)                      # refuse if true
+  #   OpenLoam::AuthThrottle.record_failure(email, kind: "password", ip: request.ip)
+  #   OpenLoam::AuthThrottle.clear(email, kind: "password")      # on success
   #
   # PER-IDENTIFIER is the primary defense (an attacker targets one account /
   # code). A per-ip throttle to blunt spraying across accounts is a clean
@@ -15,7 +15,7 @@ module Loam
   # (needs a cache store + a gem); this DB counter is the portable,
   # single-process-correct prototype.
   #
-  # Thresholds come from Loam::Configs (per-tenant-overridable, but read globally
+  # Thresholds come from OpenLoam::Configs (per-tenant-overridable, but read globally
   # here at the auth layer with sane defaults):
   #   security.max_auth_attempts   (default 10)
   #   security.auth_window_minutes (default 15) — failures counted in this window
@@ -24,15 +24,15 @@ module Loam
     module_function
 
     def max_attempts
-      Loam::Configs.get("security.max_auth_attempts", default: 10).to_i
+      OpenLoam::Configs.get("security.max_auth_attempts", default: 10).to_i
     end
 
     def window
-      Loam::Configs.get("security.auth_window_minutes", default: 15).to_i.minutes
+      OpenLoam::Configs.get("security.auth_window_minutes", default: 15).to_i.minutes
     end
 
     def lockout
-      Loam::Configs.get("security.auth_lockout_minutes", default: 15).to_i.minutes
+      OpenLoam::Configs.get("security.auth_lockout_minutes", default: 15).to_i.minutes
     end
 
     # Log a failed attempt. Recorded for ANY submitted identifier — existing or
@@ -41,11 +41,14 @@ module Loam
       identifier = normalize(identifier)
       return if identifier.blank?
 
-      Loam::AuthAttempt.create!(identifier: identifier, kind: kind.to_s, ip: ip)
+      OpenLoam::AuthAttempt.create!(identifier: identifier, kind: kind.to_s, ip: ip)
     end
 
     # Locked if there are >= max failures within the window. Old attempts age out
     # of the window automatically (the window query IS the expiry — no reaper).
+    #
+    # Both auth call sites ask WITHOUT a kind on purpose: failures on either
+    # factor lock both, so grinding TOTP also costs the attacker the password form.
     def locked?(identifier, kind: nil)
       recent_failures(identifier, kind: kind) >= max_attempts
     end
@@ -58,8 +61,13 @@ module Loam
 
     # Reset the counter — call on a SUCCESSFUL auth so a legitimate user who
     # eventually gets in isn't left throttled.
-    def clear(identifier)
-      attempts(identifier).delete_all
+    #
+    # Pass `kind:` — clearing every kind on one factor's success lets an attacker
+    # holding the password reset the TOTP counter before each guess.
+    def clear(identifier, kind: nil)
+      scope = attempts(identifier)
+      scope = scope.where(kind: Array(kind).map(&:to_s)) if kind
+      scope.delete_all
     end
 
     # Seconds until the identifier unlocks (for the "try again in N" message),
@@ -73,7 +81,7 @@ module Loam
     end
 
     def attempts(identifier)
-      Loam::AuthAttempt.where(identifier: normalize(identifier))
+      OpenLoam::AuthAttempt.where(identifier: normalize(identifier))
     end
 
     def normalize(identifier)

data/lib/{loam → open_loam}/base32.rb

@@ -1,4 +1,4 @@
-module Loam
+module OpenLoam
   # RFC 4648 Base32 — the encoding authenticator apps expect for a TOTP secret.
   # Ruby ships Base64 but not Base32, and this is ~15 lines, so no dependency.
   # No padding on encode (authenticators don't want it); decode ignores case,

data/lib/{loam → open_loam}/bulk.rb

@@ -1,11 +1,11 @@
-module Loam
+module OpenLoam
   # Datatable bulk actions over selected records — policy-checked PER record and
   # tenant-scoped. The ids are resolved THROUGH the tenant scope
   # (`model.where(id: ids)`), so a forged cross-tenant id is simply not found —
   # a bulk op can never reach another tenant's rows.
   #
-  #   Loam::Bulk.soft_delete(Equipment, params[:ids])
-  #   Loam::Bulk.set_field(Equipment, params[:ids], field: "status", value: "retired")
+  #   OpenLoam::Bulk.soft_delete(Equipment, params[:ids])
+  #   OpenLoam::Bulk.set_field(Equipment, params[:ids], field: "status", value: "retired")
   #
   # Returns the number of records actually affected (a record the actor may not
   # touch, or an id from another tenant, is silently skipped).
@@ -32,7 +32,7 @@ module Loam
     end
 
     # A relation for "export selected" — tenant-scoped, so it composes with
-    # Loam::Export.csv and can't leak another tenant's rows.
+    # OpenLoam::Export.csv and can't leak another tenant's rows.
     def selected(model, ids)
       model.where(id: Array(ids))
     end
@@ -40,20 +40,20 @@ module Loam
     def each_permitted(model, ids)
       count = 0
       selected(model, ids).find_each do |record|
-        count += 1 if yield(record, Loam::Policy.for(record))
+        count += 1 if yield(record, OpenLoam::Policy.for(record))
       end
       count
     end
 
     def writable_column?(model, field)
-      model.column_names.include?(field) && Loam::Import::PLUMBING.exclude?(field) && !workflow_column?(model, field)
+      model.column_names.include?(field) && OpenLoam::Import::PLUMBING.exclude?(field) && !workflow_column?(model, field)
     end
 
     # A workflow status column may ONLY change through a transition (role-gated).
     # Skip it here so a bulk set-field can't self-"approve" (the model guard is
     # the backstop; this keeps the bulk op a clean no-op rather than an error).
     def workflow_column?(model, field)
-      model.respond_to?(:loam_workflow) && model.loam_workflow&.column == field
+      model.respond_to?(:open_loam_workflow) && model.open_loam_workflow&.column == field
     end
   end
 end

data/lib/{loam → open_loam}/business_rules/actions.rb

@@ -1,4 +1,4 @@
-module Loam
+module OpenLoam
   module BusinessRules
     # The typed action vocabulary — a FIXED, safe set the engine dispatches. No
     # arbitrary code: an action is a json descriptor with a `type` and known
@@ -9,7 +9,7 @@ module Loam
 
       # Run one action against the record that triggered the rule. Returns a
       # short label of what it did (for the execution log). `:veto` is the
-      # block_transition signal (see Loam::BusinessRules.veto?).
+      # block_transition signal (see OpenLoam::BusinessRules.veto?).
       def self.run(action, record)
         case action["type"].to_s
         when "notify"           then run_notify(action, record)
@@ -24,10 +24,10 @@ module Loam
         title = action["title"].to_s
         body = action["body"]
         if action["role"].present?
-          Loam::Notifications.notify_role(action["role"], title: title, body: body)
+          OpenLoam::Notifications.notify_role(action["role"], title: title, body: body)
         elsif action["user_id"].present?
           user = User.find_by(id: action["user_id"])
-          Loam::Notifications.notify(user, title: title, body: body) if user
+          OpenLoam::Notifications.notify(user, title: title, body: body) if user
         end
         "notify"
       end
@@ -35,7 +35,7 @@ module Loam
       # Publish validates the name format (raising InvalidEventNameError), so a
       # malformed event name is caught by the engine's per-rule isolation.
       def self.run_emit_event(action)
-        Loam::Events.publish(action["name"], (action["payload"] || {}).symbolize_keys)
+        OpenLoam::Events.publish(action["name"], (action["payload"] || {}).symbolize_keys)
         "emit_event(#{action["name"]})"
       end
 
@@ -65,7 +65,7 @@ module Loam
       end
 
       def self.refuse_workflow_column!(record, field)
-        return unless record.class.respond_to?(:loam_workflow) && record.class.loam_workflow&.column == field
+        return unless record.class.respond_to?(:open_loam_workflow) && record.class.open_loam_workflow&.column == field
 
         raise ArgumentError, "set_field must not write the workflow column #{field.inspect} — use a transition"
       end
@@ -83,7 +83,7 @@ module Loam
       # but never write one whose tenant is not the tenant in context.
       def self.refuse_cross_tenant!(record)
         return unless record.respond_to?(:tenant_id)
-        return if record.tenant_id == Loam.tenant!.id
+        return if record.tenant_id == OpenLoam.tenant!.id
 
         raise ArgumentError, "set_field refuses a record outside the current tenant"
       end

data/lib/{loam → open_loam}/business_rules/condition.rb

@@ -1,4 +1,4 @@
-module Loam
+module OpenLoam
   module BusinessRules
     # The SAFE condition evaluator — the critical security boundary of the rules
     # engine. A rule is DATA an admin edits, so this must NEVER run arbitrary
@@ -8,7 +8,7 @@ module Loam
     # else is refused — no `send` of arbitrary methods, no SQL, no eval.
     module Condition
       OPS = %w[eq neq gt gte lt lte in contains present blank].freeze
-      REFUSED = :__loam_field_refused__
+      REFUSED = :__open_loam_field_refused__
 
       def self.matches?(node, record)
         node = node.is_a?(Hash) ? node : {}
@@ -48,7 +48,7 @@ module Loam
         elsif custom_field?(record, field)
           begin
             record.custom_field(field)
-          rescue Loam::UnknownCustomFieldError
+          rescue OpenLoam::UnknownCustomFieldError
             REFUSED
           end
         else
@@ -59,8 +59,8 @@ module Loam
       def self.refused_column?(klass, field)
         return true if field == "tenant_id"
 
-        klass.respond_to?(:loam_encrypted_attributes) &&
-          klass.loam_encrypted_attributes.map(&:to_s).include?(field)
+        klass.respond_to?(:open_loam_encrypted_attributes) &&
+          klass.open_loam_encrypted_attributes.map(&:to_s).include?(field)
       end
 
       def self.custom_field?(record, field)

data/lib/{loam → open_loam}/business_rules.rb

@@ -1,12 +1,12 @@
-require "loam/business_rules/condition"
-require "loam/business_rules/actions"
+require "open_loam/business_rules/condition"
+require "open_loam/business_rules/actions"
 
-module Loam
-  # The engine that evaluates Loam::BusinessRule rows: WHEN a trigger fires and
+module OpenLoam
+  # The engine that evaluates OpenLoam::BusinessRule rows: WHEN a trigger fires and
   # the condition holds, THEN run the actions — in the event's tenant context,
   # in priority order, each rule isolated so one failure never breaks dispatch.
   #
-  # It listens to every Loam event (like Loam::Webhooks), so a tenant can add a
+  # It listens to every OpenLoam event (like OpenLoam::Webhooks), so a tenant can add a
   # rule from the admin without a reboot. Evaluation runs INLINE in whatever
   # published the event — cheap for the prototype; a job-based dispatcher is the
   # scaling path.
@@ -15,19 +15,19 @@ module Loam
                   # rules, but only so deep, so a self-triggering rule terminates.
 
     class << self
-      # Wired once from Loam::Engine. Idempotent — subscribing twice would run
-      # every rule twice (see Loam::Webhooks.subscribe!).
+      # Wired once from OpenLoam::Engine. Idempotent — subscribing twice would run
+      # every rule twice (see OpenLoam::Webhooks.subscribe!).
       def subscribe!
-        @subscription ||= Loam::Events.subscribe_all { |event_name, payload| on_event(event_name, payload) }
+        @subscription ||= OpenLoam::Events.subscribe_all { |event_name, payload| on_event(event_name, payload) }
       end
 
       def on_event(event_name, payload)
-        tenant = Loam::Tenant.find_by(id: payload[:tenant_id])
+        tenant = OpenLoam::Tenant.find_by(id: payload[:tenant_id])
         return if tenant.nil?
 
-        Loam.as_tenant(tenant) do
+        OpenLoam.as_tenant(tenant) do
           within_depth_guard do
-            Loam::BusinessRule.active.by_priority.each do |rule|
+            OpenLoam::BusinessRule.active.by_priority.each do |rule|
               next unless rule.matches_trigger?(event_name)
 
               run_rule(rule, subject_for(rule, payload), event_name)
@@ -40,7 +40,7 @@ module Loam
       # active rules for the record's entity type (optionally filtered to a
       # trigger) in priority order.
       def evaluate(record, trigger: nil)
-        Loam::BusinessRule.active.for_entity(record.class.base_class.name).by_priority.each do |rule|
+        OpenLoam::BusinessRule.active.for_entity(record.class.base_class.name).by_priority.each do |rule|
           next if trigger && !rule.matches_trigger?(trigger)
 
           run_rule(rule, record, trigger)
@@ -51,7 +51,7 @@ module Loam
       # holds, veto this transition? Consulted by a workflow BEFORE it moves (see
       # the demo's DamageReport). Evaluate-only — no actions run, nothing logged.
       def veto?(record, trigger)
-        Loam::BusinessRule.active.for_entity(record.class.base_class.name).by_priority.any? do |rule|
+        OpenLoam::BusinessRule.active.for_entity(record.class.base_class.name).by_priority.any? do |rule|
           rule.matches_trigger?(trigger) &&
             rule.action_list.any? { |action| action["type"].to_s == "block_transition" } &&
             Condition.matches?(rule.condition_tree, record)
@@ -81,7 +81,7 @@ module Loam
         # deterministic "condition didn't match" ones (readable from the rule).
         return if !matched && error.nil?
 
-        Loam::BusinessRuleRun.create!(
+        OpenLoam::BusinessRuleRun.create!(
           business_rule: rule,
           subject_type: record&.class&.base_class&.name,
           subject_id: record&.id,
@@ -102,21 +102,21 @@ module Loam
         # A rule may ONLY target a tenant-scoped model. This is the security
         # boundary: a global model like `User` has no tenant default scope, so a
         # find_by(id:) would reach across tenants — refusing anything that is not
-        # a Loam::TenantRecord closes that, and a TenantRecord.find_by can only
+        # a OpenLoam::TenantRecord closes that, and a TenantRecord.find_by can only
         # ever return a record in the CURRENT tenant even if an id is injected.
-        return nil unless klass.is_a?(Class) && klass < Loam::TenantRecord
+        return nil unless klass.is_a?(Class) && klass < OpenLoam::TenantRecord
 
         klass.find_by(id: payload[:id])
       end
 
       def within_depth_guard
-        depth = Thread.current[:loam_rule_depth] ||= 0
+        depth = Thread.current[:open_loam_rule_depth] ||= 0
         return if depth >= MAX_DEPTH
 
-        Thread.current[:loam_rule_depth] = depth + 1
+        Thread.current[:open_loam_rule_depth] = depth + 1
         yield
       ensure
-        Thread.current[:loam_rule_depth] = depth if depth
+        Thread.current[:open_loam_rule_depth] = depth if depth
       end
     end
   end

data/lib/{loam → open_loam}/commentable.rb

@@ -1,8 +1,8 @@
-module Loam
+module OpenLoam
   # Discussion on a record:
   #
-  #   equipment.comment!("Hydraulics serviced")   # as Loam.actor
-  #   equipment.loam_comments.oldest_first
+  #   equipment.comment!("Hydraulics serviced")   # as OpenLoam.actor
+  #   equipment.open_loam_comments.oldest_first
   #
   # Included by every generated entity. Comments are tenant-scoped like their
   # subject, so a discussion can never be read from another tenant.
@@ -10,13 +10,13 @@ module Loam
     extend ActiveSupport::Concern
 
     included do
-      has_many :loam_comments, as: :commentable, class_name: "Loam::Comment", dependent: :destroy
+      has_many :open_loam_comments, as: :commentable, class_name: "OpenLoam::Comment", dependent: :destroy
     end
 
     # Author defaults to whoever is acting — the same person the audit trail
     # and the event payload would name.
-    def comment!(body, author: Loam::Current.actor)
-      loam_comments.create!(body: body, author: author)
+    def comment!(body, author: OpenLoam::Current.actor)
+      open_loam_comments.create!(body: body, author: author)
     end
   end
 end