open-loam 0.1.0

data/lib/generators/loam/entity/templates/api_controller.rb

@@ -0,0 +1,67 @@
+module Api
+  # JSON for <%= class_name %>. Same rules as the admin screen, same policy:
+  # the token's user is the actor, so a role that may not write a field cannot
+  # write it here either — `permitted_fields` drops it from the permit list.
+  class <%= plural_name.camelize %>Controller < BaseController
+    FIELDS = %i[<%= field_names.join(" ") %>].freeze
+
+    before_action :set_record, only: %i[show update destroy]
+
+    def index
+      records = <%= class_name %>.order(created_at: :desc).to_a
+      enriched = Loam::Enrichers.enrich_many(records)   # one batched pass, no N+1
+      render json: records.map { |record| entity_json(record, enrichments: enriched[record.id]) }
+    end
+
+    def show
+      authorize!(policy_for(@record), :read?)
+      render json: entity_json(@record)
+    end
+
+    def create
+      @record = <%= class_name %>.new
+      policy = policy_for(@record)
+      authorize!(policy, :create?)
+      @record.assign_attributes(permitted_params(policy))
+      assign_custom_fields!(@record, params, policy)
+
+      if @record.save
+        render json: entity_json(@record), status: :created
+      else
+        render json: { errors: @record.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      policy = policy_for(@record)
+      authorize!(policy, :update?)
+      @record.assign_attributes(permitted_params(policy))
+      assign_custom_fields!(@record, params, policy)
+
+      if @record.save
+        render json: entity_json(@record)
+      else
+        render json: { errors: @record.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
+    # Soft-delete here too, so DELETE is the ONE way to delete across both
+    # surfaces: the record is hidden and recoverable, not erased. The recycle
+    # bin itself is an admin concern; the API just gets the safer default.
+    def destroy
+      authorize!(policy_for(@record), :destroy?)
+      @record.soft_delete!
+      head :no_content
+    end
+
+    private
+
+    def set_record
+      @record = <%= class_name %>.find(params[:id])
+    end
+
+    def permitted_params(policy)
+      params.require(:<%= singular_name %>).permit(*policy.permitted_fields(FIELDS))
+    end
+  end
+end

data/lib/generators/loam/entity/templates/controller.rb

@@ -0,0 +1,181 @@
+module Admin
+  class <%= plural_name.camelize %>Controller < BaseController
+    FIELDS = %i[<%= field_names.join(" ") %>].freeze
+
+    before_action :set_record, only: %i[show edit update destroy]
+
+    helper_method :current_index_params
+
+    # The active index filters (search, saved view, custom-field filter, sort) as
+    # a plain hash, so pagination links, the sort headers and the export link all
+    # carry the SAME state — page 2 of a filtered/sorted view stays filtered.
+    def current_index_params
+      params.permit(:q, :perspective_id, :cf_field, :cf_op, :cf_value, :sort, :dir)
+            .to_h.symbolize_keys.reject { |_, v| v.blank? }
+    end
+
+    def index
+      @perspective = Loam::Perspectives.resolve("<%= class_name %>", user: current_actor, id: params[:perspective_id])
+      @perspectives = Loam::Perspectives.visible_to("<%= class_name %>", user: current_actor)
+      @records, @page, @has_next = paginate(index_scope)
+      @index_partial = params[:cf_field].present? && Loam::CustomFieldIndex.partial?  # incomplete-index warning (L-919)
+    end
+
+    # CSV of the CURRENT filtered/perspective view — manager-only, policy- and
+    # encryption-aware (Loam::Export).
+    def export
+      require_role!(:manager)
+      send_data Loam::Export.csv(index_scope, actor: current_actor),
+                filename: "<%= plural_name %>-#{Date.current}.csv", type: "text/csv"
+    end
+
+    # Datatable bulk actions on the selected ids — each is policy-checked per
+    # record and tenant-scoped (Loam::Bulk). Zero selection is a no-op.
+    def bulk
+      ids = Array(params[:ids])
+      case params[:bulk_action]
+      when "soft_delete"
+        count = Loam::Bulk.soft_delete(<%= class_name %>, ids)
+        redirect_to polymorphic_path([:admin, <%= class_name %>]), notice: "Deleted #{count} record(s)."
+      when "set_field"
+        count = Loam::Bulk.set_field(<%= class_name %>, ids, field: params[:field], value: params[:value])
+        redirect_to polymorphic_path([:admin, <%= class_name %>]), notice: "Updated #{count} record(s)."
+      when "export"
+        require_role!(:manager)  # same gate as the dedicated export action
+        send_data Loam::Export.csv(Loam::Bulk.selected(<%= class_name %>, ids), actor: current_actor),
+                  filename: "<%= plural_name %>-selected.csv", type: "text/csv"
+      else
+        redirect_to polymorphic_path([:admin, <%= class_name %>]), alert: "Unknown bulk action."
+      end
+    end
+
+    # The recycle bin: only_deleted stays tenant-scoped, so this never shows
+    # another tenant's deleted rows.
+    def deleted
+      authorize!(policy_for(<%= class_name %>.new), :read?)
+      scope = <%= class_name %>.only_deleted.order(deleted_at: :desc, id: :desc)
+      @records, @page, @has_next = paginate(scope)
+    end
+
+    def show
+      authorize!(policy_for(@record), :read?)
+    end
+
+    def new
+      @record = <%= class_name %>.new
+      authorize!(policy_for(@record), :create?)
+    end
+
+    def create
+      @record = <%= class_name %>.new
+      policy = policy_for(@record)
+      authorize!(policy, :create?)
+      @record.assign_attributes(permitted_params(policy))
+      assign_custom_fields!(@record, params, policy)
+      attach_files!(@record, policy)
+
+      if @record.save
+        redirect_to [:admin, @record], notice: t("loam.flash.created", name: <%= class_name %>.model_name.human)
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def edit
+      authorize!(policy_for(@record), :update?)
+      # Take the advisory lock (courtesy) or learn who holds it, for the banner.
+      @lock = Loam::RecordLocks.acquire(@record, by: current_actor) || Loam::RecordLocks.active_lock(@record)
+    end
+
+    def update
+      policy = policy_for(@record)
+      authorize!(policy, :update?)
+      assign_custom_fields!(@record, params, policy)
+      attach_files!(@record, policy)
+
+      if @record.update(permitted_params(policy))
+        Loam::RecordLocks.release(@record, by: current_actor)
+        redirect_to [:admin, @record], notice: t("loam.flash.updated", name: <%= class_name %>.model_name.human)
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    rescue ActiveRecord::StaleObjectError
+      # Someone saved between open and submit — show the diff, reload fresh, retry.
+      stale_conflict!(@record, FIELDS)
+      @lock = Loam::RecordLocks.acquire(@record, by: current_actor) || Loam::RecordLocks.active_lock(@record)
+      render :edit, status: :conflict
+    end
+
+    # Delete hides, it does not erase — the button is undoable. Reach for the
+    # model's `destroy` only when a row must genuinely leave the database.
+    def destroy
+      authorize!(policy_for(@record), :destroy?)
+      @record.soft_delete!
+      Loam::RecordLocks.release(@record, by: current_actor)
+      redirect_to [:admin, <%= class_name %>], notice: t("loam.flash.destroyed", name: <%= class_name %>.model_name.human)
+    end
+
+    # Restore looks through the deleted rows — the default scope hides them, so a
+    # plain find would 404 on the record we are trying to bring back.
+    def restore
+      @record = <%= class_name %>.with_deleted.find(params[:id])
+      authorize!(policy_for(@record), :update?)
+      @record.restore!
+      redirect_to [:deleted, :admin, <%= class_name %>], notice: t("loam.flash.restored", name: <%= class_name %>.model_name.human)
+    end
+
+    private
+
+    def set_record
+      @record = <%= class_name %>.find(params[:id])
+    end
+
+    # The same filtered/perspective/search scope the index shows — reused by
+    # export so the CSV matches what the manager is looking at.
+    def index_scope
+      scope = <%= class_name %>.all
+      perspective = Loam::Perspectives.resolve("<%= class_name %>", user: current_actor, id: params[:perspective_id])
+      scope = perspective.apply(scope) if perspective
+<% if searchable_attributes.any? -%>
+      scope = scope.search(params[:q])
+<% end -%>
+      scope = apply_custom_field_filter(scope)
+      apply_sort(scope)
+    end
+
+    # Column sort from the clickable index headers. The column is WHITELISTED
+    # against real columns (never interpolated from params — that would be SQL
+    # injection), and the direction is constrained to asc/desc. With no valid
+    # sort param, a perspective's own order is kept, else a stable default.
+    def apply_sort(scope)
+      column = params[:sort].to_s
+      if <%= class_name %>.column_names.include?(column)
+        dir = params[:dir].to_s.casecmp("asc").zero? ? :asc : :desc
+        scope.reorder(column => dir).order(id: dir)
+      elsif scope.order_values.empty?
+        scope.order(created_at: :desc, id: :desc)
+      else
+        scope
+      end
+    end
+
+    # A custom-field filter routed through the read-model index
+    # (Loam::CustomFieldIndex) — index-backed, not a JSON scan. An unknown field
+    # is ignored rather than raising.
+    def apply_custom_field_filter(scope)
+      return scope if params[:cf_field].blank?
+
+      scope.merge(Loam::CustomFieldIndex.filter(<%= class_name %>, params[:cf_field], params[:cf_op].presence || "eq", params[:cf_value]))
+    rescue Loam::Error
+      scope
+    end
+
+    # Field-level enforcement: the permit list comes from the policy, so a
+    # role without write access to a field cannot smuggle it in via params.
+    # lock_version rides outside the policy filter — it is optimistic-locking
+    # plumbing, and a forged value just produces a harmless conflict.
+    def permitted_params(policy)
+      params.require(:<%= singular_name %>).permit(*policy.permitted_fields(FIELDS), :lock_version)
+    end
+  end
+end

data/lib/generators/loam/entity/templates/entity_test.rb

@@ -0,0 +1,107 @@
+require "test_helper"
+
+# Generated guardrail tests for <%= class_name %>. They prove the Loam
+# invariants hold for THIS entity: tenant isolation, loud failure without
+# context, audit-by-default, lifecycle events, membership-gated policies.
+# Extend freely; never delete.
+class <%= class_name %>LoamTest < ActiveSupport::TestCase
+  setup do
+    @tenant_a = Loam::Tenant.create!(name: "Tenant A", slug: "a-<%= file_name %>")
+    @tenant_b = Loam::Tenant.create!(name: "Tenant B", slug: "b-<%= file_name %>")
+    @manager = User.create!(name: "Manager", email: "manager@example.test", password: "password")
+    @employee = User.create!(name: "Employee", email: "employee@example.test", password: "password")
+
+    with_tenant(@tenant_a) do
+      Loam::Membership.create!(user: @manager, role: "manager")
+      Loam::Membership.create!(user: @employee, role: "employee")
+    end
+  end
+
+  test "guardrail: records are invisible outside their tenant" do
+    record_id = with_tenant(@tenant_a) { <%= class_name %>.create!(<%= sample_attributes %>).id }
+
+    with_tenant(@tenant_a) { assert_equal 1, <%= class_name %>.count }
+
+    with_tenant(@tenant_b) do
+      assert_equal 0, <%= class_name %>.count
+      assert_raises(ActiveRecord::RecordNotFound) { <%= class_name %>.find(record_id) }
+    end
+  end
+
+  test "guardrail: touching the model with no tenant context raises" do
+    assert_raises(Loam::MissingTenantError) { <%= class_name %>.count }
+    assert_raises(Loam::MissingTenantError) { <%= class_name %>.new }
+  end
+
+  test "guardrail: a record cannot be written into a foreign tenant" do
+    record = with_tenant(@tenant_a) { <%= class_name %>.create!(<%= sample_attributes %>) }
+
+    with_tenant(@tenant_b) do
+      assert_raises(Loam::MissingTenantError) { record.update!(<%= sample_attributes(1) %>) }
+    end
+  end
+
+  test "every change is audited with actor and changeset" do
+    with_tenant(@tenant_a, actor: @manager) do
+      record = <%= class_name %>.create!(<%= sample_attributes %>)
+
+      audit = Loam::AuditRecord.find_by(
+        auditable_type: "<%= class_name %>", auditable_id: record.id, action: "create"
+      )
+      assert audit, "expected an audit record for the create"
+      assert_equal @manager.id, audit.actor_id
+      assert_includes audit.changeset.keys, "<%= first_field %>"
+    end
+  end
+
+  test "lifecycle events are published with the tenant stamped" do
+    received = []
+    subscription = Loam::Events.subscribe("<%= domain %>.<%= singular_name %>.created") do |_name, payload|
+      received << payload
+    end
+
+    with_tenant(@tenant_a, actor: @manager) { <%= class_name %>.create!(<%= sample_attributes %>) }
+
+    assert_equal 1, received.size
+    assert_equal @tenant_a.id, received.first[:tenant_id]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscription)
+  end
+
+  test "soft-delete hides a record by default, stays tenant-scoped, and restores" do
+    record_id = with_tenant(@tenant_a, actor: @manager) do
+      record = <%= class_name %>.create!(<%= sample_attributes %>)
+      record.soft_delete
+      record.id
+    end
+
+    with_tenant(@tenant_a) do
+      assert_equal 0, <%= class_name %>.count, "a soft-deleted record is gone from ordinary queries"
+      assert_equal 1, <%= class_name %>.with_deleted.count, "but the row still exists"
+      assert Loam::AuditRecord.exists?(auditable_type: "<%= class_name %>", auditable_id: record_id, action: "soft_delete")
+    end
+
+    # with_deleted lifts the deleted_at filter but NOT the tenant filter.
+    with_tenant(@tenant_b) do
+      assert_equal 0, <%= class_name %>.with_deleted.count, "the recycle bin must never cross tenants"
+    end
+
+    with_tenant(@tenant_a) do
+      <%= class_name %>.with_deleted.find(record_id).restore
+      assert_equal 1, <%= class_name %>.count, "restore returns the record to the default scope"
+    end
+  end
+
+  test "policy: only members of the current tenant may act" do
+    record = with_tenant(@tenant_a) { <%= class_name %>.create!(<%= sample_attributes %>) }
+
+    with_tenant(@tenant_a) do
+      assert <%= class_name %>Policy.new(@manager, record).update?
+
+      outsider = User.create!(name: "Outsider", email: "outsider@example.test", password: "password")
+      outsider_policy = <%= class_name %>Policy.new(outsider, record)
+      refute outsider_policy.update?
+      refute outsider_policy.writable?(:<%= first_field %>)
+    end
+  end
+end

data/lib/generators/loam/entity/templates/migration.rb

@@ -0,0 +1,26 @@
+class Create<%= table_name.camelize %> < ActiveRecord::Migration[<%= ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table :<%= table_name %><%= loam_id_option %> do |t|
+      t.references :tenant, null: false, foreign_key: { to_table: :loam_tenants }<%= loam_type_option %>
+<% attributes.each do |attribute| -%>
+<% if encrypted?(attribute) -%>
+      t.text :<%= attribute.name %>   # encrypted at rest (Loam::Encryptable) — text, since ciphertext outgrows varchar
+<% else -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+<% end -%>
+<% encrypt_searchable_names.each do |field| -%>
+      t.string :<%= field %>_hash   # per-tenant blind index of :<%= field %>, for exact-match lookup
+<% end -%>
+      t.json :custom_fields, null: false, default: {}
+      t.datetime :deleted_at
+      t.integer :lock_version, null: false, default: 0   # optimistic locking (Loam::RecordLock)
+      t.timestamps
+    end
+    # Loam::SoftDeletable filters `deleted_at IS NULL` on every query.
+    add_index :<%= table_name %>, :deleted_at
+<% encrypt_searchable_names.each do |field| -%>
+    add_index :<%= table_name %>, :<%= field %>_hash
+<% end -%>
+  end
+end

data/lib/generators/loam/entity/templates/model.rb

@@ -0,0 +1,27 @@
+# Tenant-scoped, audited, evented — by inheritance, not by remembering.
+class <%= class_name %> < Loam::TenantRecord
+  include Loam::Auditable
+  include Loam::Eventful
+  include Loam::CustomFields
+  include Loam::Commentable
+  include Loam::Attachable
+  include Loam::Searchable
+  include Loam::SoftDeletable
+<% if encrypted_field_names.any? -%>
+  include Loam::Encryptable
+<% end -%>
+
+  event_domain :<%= domain %>
+<% if searchable_attributes.any? -%>
+  searchable_by <%= searchable_attributes.map { |a| ":#{a.name}" }.join(", ") %>
+<% end -%>
+<% options[:encrypt].each do |field| -%>
+  encrypts :<%= field %>
+<% end -%>
+<% encrypt_searchable_names.each do |field| -%>
+  encrypts :<%= field %>, searchable: true   # exact-match lookup via <%= field %>_hash
+<% end -%>
+
+  # Business logic goes here. Publish business events explicitly:
+  #   Loam::Events.publish("<%= domain %>.something.happened", id: id)
+end

data/lib/generators/loam/entity/templates/policy.rb

@@ -0,0 +1,10 @@
+class <%= class_name %>Policy < Loam::Policy
+  # Action defaults: any member of the current tenant may read/create/update/
+  # destroy. Tighten by overriding, e.g.:
+  #
+  #   def destroy? = role == :manager
+  #
+  # Field-level write access is declared, not coded:
+  #
+  #   field :<%= first_field %>, writable: [:manager]
+end

data/lib/generators/loam/entity/templates/views/_form.html.erb

@@ -0,0 +1,63 @@
+<%% policy = Loam::Policy.for(@record) %>
+
+<%%# Optimistic-locking conflict: what the user typed vs what is now saved. %>
+<%% if @conflict.present? %>
+  <div class="conflict" style="border:2px solid #b00; padding:0.75rem; margin-bottom:1rem">
+    <p><strong>This changed while you were editing.</strong> Your entries were not saved. The form now shows the current values — re-apply your changes and save again.</p>
+    <table>
+      <thead><tr><th>Field</th><th>You entered</th><th>Now saved</th></tr></thead>
+      <tbody>
+        <%% @conflict.each do |field, values| %>
+          <tr><td><%%= field.humanize %></td><td><%%= values["yours"] %></td><td><%%= values["theirs"] %></td></tr>
+        <%% end %>
+      </tbody>
+    </table>
+  </div>
+<%% end %>
+
+<%%# Advisory lock: warn (do not block) when someone else is editing. %>
+<%% if @lock && @lock.locked_by_id != current_actor.id %>
+  <div class="lock-banner" style="background:#ffd; padding:0.5rem; margin-bottom:1rem">
+    Locked by <strong><%%= @lock.locked_by.name %></strong> until <%%= @lock.expires_at.strftime("%H:%M") %>.
+    You can still save (the version check protects you), but you may collide.
+    <%% if current_role == :manager %>
+      <%%= button_to "Take over", admin_record_lock_path(lockable_type: @record.class.name, lockable_id: @record.id), method: :delete, form: { style: "display:inline" } %>
+    <%% end %>
+  </div>
+<%% end %>
+
+<%%= form_with model: [:admin, @record] do |f| %>
+  <%%= f.hidden_field :lock_version %>
+  <%% if @record.errors.any? %>
+    <ul>
+      <%% @record.errors.full_messages.each do |message| %>
+        <li><%%= message %></li>
+      <%% end %>
+    </ul>
+  <%% end %>
+
+<% attributes.each do |attribute| -%>
+  <%% if policy.writable?(:<%= attribute.name %>) %>
+    <p>
+      <%%= f.label :<%= attribute.name %> %><br>
+      <%%= f.<%= form_field_helper(attribute) %> :<%= attribute.name %> %>
+    </p>
+  <%% else %>
+    <p>
+      <%%= f.label :<%= attribute.name %> %>: <%%= @record.<%= attribute.name %> %>
+      <em><%%= t("loam.form.read_only") %></em>
+    </p>
+  <%% end %>
+<% end -%>
+
+  <%%= render "loam/custom_fields/fields", record: @record, policy: policy, mode: :edit %>
+
+  <%% if policy.update? %>
+    <p>
+      <%%= f.label :files, t("loam.form.attach_files") %><br>
+      <%%= f.file_field :files, multiple: true %>
+    </p>
+  <%% end %>
+
+  <%%= f.submit %>
+<%% end %>

data/lib/generators/loam/entity/templates/views/deleted.html.erb

@@ -0,0 +1,41 @@
+<h1><%%= t("loam.actions.deleted_title", name: <%= class_name %>.model_name.human(count: 2)) %></h1>
+
+<p><%%= link_to t("loam.actions.back"), [:admin, <%= class_name %>] %></p>
+
+<%%# No Show/Edit here: these rows are hidden by the default scope, so a plain
+    find would 404. The one action a deleted record offers is Restore. %>
+<table>
+  <thead>
+    <tr>
+      <th><%%= t("loam.labels.id") %></th>
+<% attributes.each do |attribute| -%>
+      <th><%%= <%= class_name %>.human_attribute_name("<%= attribute.name %>") %></th>
+<% end -%>
+      <th><%%= <%= class_name %>.human_attribute_name("deleted_at") %></th>
+      <th></th>
+    </tr>
+  </thead>
+  <tbody>
+    <%% @records.each do |record| %>
+      <tr>
+        <td><%%= record.id %></td>
+<% attributes.each do |attribute| -%>
+        <td><%%= record.<%= attribute.name %> %></td>
+<% end -%>
+        <td><%%= record.deleted_at %></td>
+        <td><%%= button_to t("loam.actions.restore"), [:restore, :admin, record], method: :patch %></td>
+      </tr>
+    <%% end %>
+  </tbody>
+</table>
+
+<%%# Page links carry nothing but the page: the recycle bin has no filter box. %>
+<p>
+  <%% if @page > 1 %>
+    <%%= link_to t("loam.pagination.previous"), polymorphic_path([:deleted, :admin, <%= class_name %>], page: @page - 1) %>
+  <%% end %>
+  <%%= t("loam.pagination.page", page: @page) %>
+  <%% if @has_next %>
+    <%%= link_to t("loam.pagination.next"), polymorphic_path([:deleted, :admin, <%= class_name %>], page: @page + 1) %>
+  <%% end %>
+</p>

data/lib/generators/loam/entity/templates/views/edit.html.erb

@@ -0,0 +1,3 @@
+<h1><%%= t("loam.actions.edit_title", name: <%= class_name %>.model_name.human, id: @record.id) %></h1>
+
+<%%= render "form" %>

data/lib/generators/loam/entity/templates/views/index.html.erb

@@ -0,0 +1,90 @@
+<h1><%%= <%= class_name %>.model_name.human(count: 2) %></h1>
+
+<%% if @index_partial %>
+  <p style="color:#b00"><%%= t("loam.index.incomplete") %></p>
+<%% end %>
+
+<p>
+  <%%= link_to t("loam.actions.new", name: <%= class_name %>.model_name.human), new_polymorphic_path([:admin, <%= class_name %>]) %>
+  <%%= link_to t("loam.actions.deleted", name: <%= class_name %>.model_name.human(count: 2)), polymorphic_path([:deleted, :admin, <%= class_name %>]) %>
+  <%% if current_role == :manager %>
+    <%%= link_to t("loam.actions.export_csv"), url_for(action: :export, **current_index_params) %>
+    <%%= link_to t("loam.actions.import_csv"), new_admin_import_path(entity_type: "<%= class_name %>") %>
+  <%% end %>
+</p>
+
+<%%# Saved views (Loam::Perspectives): pick one to apply, or save the current one. %>
+<%% if @perspectives.any? %>
+  <%%= form_with url: [:admin, <%= class_name %>], method: :get do %>
+    <%%= select_tag :perspective_id,
+          options_for_select([[t("loam.views.all", name: <%= class_name %>.model_name.human(count: 2)), "none"]] + @perspectives.map { |p| [p.name, p.id] }, @perspective&.id),
+          onchange: "this.form.submit()" %>
+    <%%= link_to t("loam.views.manage"), admin_perspectives_path(entity_type: "<%= class_name %>") %>
+  <%% end %>
+<%% else %>
+  <p><%%= link_to t("loam.views.manage_saved"), admin_perspectives_path(entity_type: "<%= class_name %>") %></p>
+<%% end %>
+
+<%%= form_with url: admin_perspectives_path, method: :post do %>
+  <%%= hidden_field_tag :entity_type, "<%= class_name %>" %>
+  <%%= hidden_field_tag :q, params[:q] %>
+  <%%= text_field_tag :name, nil, placeholder: t("loam.views.name_placeholder") %>
+  <%%= submit_tag t("loam.views.save_current") %>
+<%% end %>
+<% if searchable_attributes.any? -%>
+
+<%%= form_with url: [:admin, <%= class_name %>], method: :get do |f| %>
+  <%%= text_field_tag :q, params[:q], placeholder: t("loam.views.filter_placeholder", name: <%= class_name %>.model_name.human(count: 2)) %>
+  <%%= f.submit t("loam.actions.filter") %>
+<%% end %>
+<% end -%>
+
+<%%# Bulk actions on selected rows (Loam::Bulk). Zero selection = no-op; each
+    action is policy-checked per record server-side. %>
+<%%= form_with url: url_for(action: :bulk), method: :post do %>
+  <p>
+    <%%= select_tag :bulk_action, options_for_select([[t("loam.bulk.delete_selected"), "soft_delete"], [t("loam.bulk.set_field"), "set_field"], [t("loam.bulk.export_selected"), "export"]]) %>
+    <%%= select_tag :field, options_for_select(%i[<%= field_names.join(" ") %>]) %>
+    <%%= text_field_tag :value, nil, placeholder: t("loam.bulk.new_value") %>
+    <%%= submit_tag t("loam.bulk.apply"), data: { turbo_confirm: t("loam.bulk.confirm") } %>
+  </p>
+
+  <table>
+    <thead>
+      <tr>
+        <th><input type="checkbox" onclick="document.querySelectorAll('.bulk-select').forEach(function(c){c.checked=this.checked}.bind(this))"></th>
+        <th><%%= t("loam.labels.id") %></th>
+<% attributes.each do |attribute| -%>
+        <th><%%= sort_link("<%= attribute.name %>", <%= class_name %>.human_attribute_name("<%= attribute.name %>")) %></th>
+<% end -%>
+        <th></th>
+      </tr>
+    </thead>
+    <tbody>
+      <%% @records.each do |record| %>
+        <tr>
+          <td><%%= check_box_tag "ids[]", record.id, false, class: "bulk-select" %></td>
+          <td><%%= record.id %></td>
+<% attributes.each do |attribute| -%>
+          <td><%%= record.<%= attribute.name %> %></td>
+<% end -%>
+          <td>
+            <%%= link_to t("loam.actions.show"), [:admin, record] %>
+            <%%= link_to t("loam.actions.edit"), edit_polymorphic_path([:admin, record]) %>
+          </td>
+        </tr>
+      <%% end %>
+    </tbody>
+  </table>
+<%% end %>
+
+<%%# Page links carry the full filter state, or page 2 would quietly drop it. %>
+<p>
+  <%% if @page > 1 %>
+    <%%= link_to t("loam.pagination.previous"), polymorphic_path([:admin, <%= class_name %>], **current_index_params, page: @page - 1) %>
+  <%% end %>
+  <%%= t("loam.pagination.page", page: @page) %>
+  <%% if @has_next %>
+    <%%= link_to t("loam.pagination.next"), polymorphic_path([:admin, <%= class_name %>], **current_index_params, page: @page + 1) %>
+  <%% end %>
+</p>

data/lib/generators/loam/entity/templates/views/new.html.erb

@@ -0,0 +1,3 @@
+<h1><%%= t("loam.actions.new_title", name: <%= class_name %>.model_name.human) %></h1>
+
+<%%= render "form" %>

data/lib/generators/loam/entity/templates/views/show.html.erb

@@ -0,0 +1,36 @@
+<%% policy = Loam::Policy.for(@record) %>
+
+<h1><%%= t("loam.actions.show_title", name: <%= class_name %>.model_name.human, id: @record.id) %></h1>
+
+<% attributes.each do |attribute| -%>
+<p><strong><%%= <%= class_name %>.human_attribute_name("<%= attribute.name %>") %>:</strong> <%%= @record.<%= attribute.name %> %></p>
+<% end -%>
+
+<%%= render "loam/custom_fields/fields", record: @record, policy: policy, mode: :show %>
+
+<%%# Computed cross-module blocks (Loam::Enrichers) — no section when none registered. %>
+<%% enrichments = Loam::Enrichers.enrich(@record) %>
+<%% if enrichments.any? %>
+  <h2><%%= t("loam.labels.enrichments") %></h2>
+  <dl>
+    <%% enrichments.each do |key, value| %>
+      <dt><strong><%%= key.humanize %></strong></dt>
+      <dd><%%= value %></dd>
+    <%% end %>
+  </dl>
+<%% end %>
+
+<p>
+  <%%= link_to t("loam.actions.edit"), edit_polymorphic_path([:admin, @record]) %>
+  <%%= link_to "History", admin_history_path(type: @record.class.name, record_id: @record.id) %>
+  <%% if @record.class.respond_to?(:loam_translatable_attributes) && @record.class.loam_translatable_attributes.any? && current_role == :manager %>
+    <%%= link_to t("loam.actions.translations"), admin_translations_path(translatable_type: @record.class.name, translatable_id: @record.id) %>
+  <%% end %>
+  <%%# Delete soft-deletes: the record moves to the recycle bin, not oblivion. %>
+  <%%= button_to t("loam.actions.destroy"), [:admin, @record], method: :delete if policy.destroy? %>
+  <%%= link_to t("loam.actions.back"), [:admin, <%= class_name %>] %>
+</p>
+
+<%%= render "loam/attachments/attachments", record: @record %>
+
+<%%= render "loam/comments/comments", record: @record %>