37 files changed, 1086 insertions, 233 deletions

diff --git a/app/controllers/admin_controller.rb b/app/controllers/admin_controller.rb
index 37fd78b..d9cf1be 100644
--- a/app/controllers/admin_controller.rb
+++ b/app/controllers/admin_controller.rb
@@ -6,7 +6,7 @@ class AdminController < ApplicationController
 
   def index
     @drafts = Node.drafts_and_autosaves(current_user_id: current_user.id).limit(5)
-    @recent_changes = Node.recently_changed.limit(5)
+    @actions = NodeAction.order(:occurred_at => :desc, :id => :desc).limit(5)
   end
 
   def conventions
@@ -71,4 +71,11 @@ class AdminController < ApplicationController
       end
     end
   end
+
+  # Deliberately raises, to verify the error-log tripwire end to end.
+  # Behind login_required like the rest of the controller; harmless --
+  # the visitor gets the ordinary 500 page.
+  def boom
+    raise "Deliberate test exception via admin/boom"
+  end
 end
diff --git a/app/controllers/content_controller.rb b/app/controllers/content_controller.rb
index 8d33105..8be4bfb 100644
--- a/app/controllers/content_controller.rb
+++ b/app/controllers/content_controller.rb
@@ -31,7 +31,7 @@ class ContentController < ApplicationController
   def render_gallery
     unless @page.nil?
       @images = @page.assets.images
-      render :file => "content/gallery"
+      render :template => 'content/gallery'
     else
       head :not_found
     end
diff --git a/app/controllers/csp_reports_controller.rb b/app/controllers/csp_reports_controller.rb
new file mode 100644
index 0000000..a8f8edb
--- /dev/null
+++ b/app/controllers/csp_reports_controller.rb
@@ -0,0 +1,22 @@
+class CspReportsController < ApplicationController
+  # Browsers POST application/csp-report with no CSRF token, no session.
+  skip_before_action :verify_authenticity_token
+
+  def create
+    request.body.rewind if request.body.respond_to?(:rewind)
+    raw = request.body.read(8192)
+    raw = request.raw_post if raw.blank?
+
+    report = (JSON.parse(raw)["csp-report"] rescue nil)
+
+    if report
+      directive = report["effective-directive"] || report["violated-directive"]
+      at = (URI.parse(report["document-uri"]).path rescue "unparsed")
+      Rails.logger.warn("CSP violation: #{directive} blocked=#{report['blocked-uri']} at=#{at}")
+    else
+      Rails.logger.warn("CSP violation: unparseable report (#{raw.to_s.bytesize} bytes)")
+    end
+
+    head :no_content
+  end
+end
diff --git a/app/controllers/node_actions_controller.rb b/app/controllers/node_actions_controller.rb
new file mode 100644
index 0000000..6e46719
--- /dev/null
+++ b/app/controllers/node_actions_controller.rb
@@ -0,0 +1,14 @@
+class NodeActionsController < ApplicationController
+
+  before_action :login_required
+
+  layout 'admin'
+
+  def index
+    @actions = NodeAction.order(:occurred_at => :desc, :id => :desc)
+    @actions = @actions.where(:node_id => params[:node_id]) if params[:node_id].present?
+    @actions = @actions.where(:user_id => params[:user_id]) if params[:user_id].present?
+    @actions = @actions.includes(:node, :user)
+                       .paginate(:page => params[:page], :per_page => 50)
+  end
+end
diff --git a/app/controllers/nodes_controller.rb b/app/controllers/nodes_controller.rb
index bff1733..6caa827 100644
--- a/app/controllers/nodes_controller.rb
+++ b/app/controllers/nodes_controller.rb
@@ -13,7 +13,9 @@ class NodesController < ApplicationController
                               :publish,
                               :unlock,
                               :autosave,
-                              :revert
+                              :revert,
+                              :trash,
+                              :restore_from_trash
                             ]
 
   around_action :pin_to_default_locale, :only => [:show, :edit, :update, :autosave]
@@ -27,10 +29,7 @@ class NodesController < ApplicationController
   def new
     @node = Node.new node_params
     @selected_kind = CccConventions::NODE_KINDS.key?(params[:kind]) ? params[:kind] : "generic"
-    if params.has_key?(:parent_id)
-      @parent_id = params[:parent_id]
-      @parent_name = Node.find(@parent_id).title
-    end
+    @parent = Node.find(params[:parent_id]) if params.has_key?(:parent_id)
   end
 
   def create
@@ -48,14 +47,14 @@ class NodesController < ApplicationController
       @node.draft.save!
 
       @node.update!(default_template_name: config[:template]) if config && config[:template]
+      NodeAction.record!(:node => @node, :page => @node.draft, :user => current_user,
+                          :action => "create",
+                          :title => params[:title], :path => @node.unique_name)
 
       redirect_to(edit_node_path(@node))
     else
       @selected_kind = CccConventions::NODE_KINDS.key?(params[:kind]) ? params[:kind] : "generic"
-      if params[:parent_id].present?
-        @parent_id = params[:parent_id]
-        @parent_name = Node.find(@parent_id).title
-      end
+      @parent = Node.find(params[:parent_id]) if params.has_key?(:parent_id)
       render :new
     end
   end
@@ -63,6 +62,9 @@ class NodesController < ApplicationController
   def show
     @page = @node.draft || @node.head
     @translations = @page.translation_summary
+    @page_actions = NodeAction.where(:page_id => @node.pages.select(:id))
+                              .order(:occurred_at, :id)
+                              .group_by(&:page_id)
   end
 
   def edit
@@ -142,12 +144,44 @@ class NodesController < ApplicationController
     redirect_to node_path(@node)
   end
 
+ def trash
+    if @node.trash!(current_user)
+      flash[:notice] = "Page has been moved to the Trash"
+      redirect_to trashed_nodes_path
+    else
+      flash[:notice] = "Page is already in the Trash"
+      redirect_to node_path(@node)
+    end
+  rescue ActiveRecord::RecordInvalid, LockedByAnotherUser => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
+  def restore_from_trash
+    parent = Node.find(params[:parent_id])
+    @node.restore_from_trash!(parent, current_user)
+    flash[:notice] = "Page has been restored from the Trash"
+    redirect_to node_path(@node)
+  rescue ActiveRecord::RecordNotFound
+    flash[:error] = "Restore target not found"
+    redirect_to node_path(@node)
+  rescue ActiveRecord::RecordInvalid => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
+  end
+
   def destroy
-    @node.destroy
+    @node.destroy_from_trash!(current_user)
+    flash[:notice] = "Page has been permanently deleted"
+    redirect_to trashed_nodes_path
+
+  rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotDestroyed => e
+    flash[:error] = e.message
+    redirect_to node_path(@node)
   end
 
   def publish
-    @node.publish_draft!
+    @node.publish_draft!(current_user)
     flash[:notice] = "Draft has been published"
     redirect_to node_path(@node)
   end
@@ -217,6 +251,11 @@ class NodesController < ApplicationController
     @sitemap_descendant_counts = descendant_counts_for(@sitemap)
   end
 
+  def trashed
+    @nodes = Node.trash.children.order(:slug)
+                 .paginate(:page => params[:page], :per_page => 50)
+  end
+
   private
 
     def slug_for(title)
diff --git a/app/controllers/related_assets_controller.rb b/app/controllers/related_assets_controller.rb
index 479ebec..5af73fc 100644
--- a/app/controllers/related_assets_controller.rb
+++ b/app/controllers/related_assets_controller.rb
@@ -27,6 +27,8 @@ class RelatedAssetsController < ApplicationController
       asset_id: asset.id,
       name: asset.name,
       thumb_url: asset.upload.url(:thumb),
+      large_url: asset.upload.url(:large),
+      original_url: asset.upload.url,
       url: node_related_asset_path(@node, related)
     }
   end
diff --git a/app/controllers/revisions_controller.rb b/app/controllers/revisions_controller.rb
index c5932a4..c1237a9 100644
--- a/app/controllers/revisions_controller.rb
+++ b/app/controllers/revisions_controller.rb
@@ -49,7 +49,7 @@ class RevisionsController < ApplicationController
 
   def restore
     page = Page.find(params[:id])
-    page.node.restore_revision! page.revision
+    page.node.restore_revision! page.revision, current_user
     flash[:notice] = "Revision #{page.revision} restored"
     redirect_to node_path(page.node)
   end
diff --git a/app/helpers/admin_helper.rb b/app/helpers/admin_helper.rb
index 6c3cbc6..2684fff 100644
--- a/app/helpers/admin_helper.rb
+++ b/app/helpers/admin_helper.rb
@@ -7,10 +7,4 @@ module AdminHelper
       link_to raw('<span class="inactive">Deutsch</span>'), url_for(params.permit(:locale, :page_path).to_h.merge('locale' => 'de'))
     end
   end
-
-  def mtime_busted_path(path)
-    file = Rails.public_path.join(path.sub(%r{\A/}, ""))
-    raise "Static asset not found for cache-busting: #{path} (looked for #{file})" unless File.exist?(file)
-    "#{path}?v=#{File.mtime(file).to_i}"
-  end
 end
diff --git a/app/helpers/application_helper.rb b/app/helpers/application_helper.rb
index 87aa82c..0d28661 100644
--- a/app/helpers/application_helper.rb
+++ b/app/helpers/application_helper.rb
@@ -15,4 +15,18 @@ module ApplicationHelper
   def resolve_kind_text(value)
     value.respond_to?(:call) ? value.call : value
   end
+
+  # Cache-busts a static file living directly under public/, outside the
+  # asset pipeline -- used by both the admin and public layouts, since
+  # neither loads its static CSS/JS through Sprockets (admin_bundle.js is
+  # the one exception; it already gets pipeline fingerprinting for free).
+  # Raises rather than silently omitting the version param: a missing
+  # file here means the page is already broken, and failing loudly beats
+  # a confusing "why is the browser still showing the old version" report
+  # days later.
+  def mtime_busted_path(path)
+    file = Rails.public_path.join(path.sub(%r{\A/}, ""))
+    raise "Static asset not found for cache-busting: #{path} (looked for #{file})" unless File.exist?(file)
+    "#{path}?v=#{File.mtime(file).to_i}"
+  end
 end
diff --git a/app/helpers/node_actions_helper.rb b/app/helpers/node_actions_helper.rb
new file mode 100644
index 0000000..fd8cc36
--- /dev/null
+++ b/app/helpers/node_actions_helper.rb
@@ -0,0 +1,183 @@
+module NodeActionsHelper
+  include ERB::Util
+
+  # One glyph per verb, rendered before the sentence in _action_row.
+  # Unknown verbs get the dashed circle -- the unknown-verb principle
+  # extended to iconography: the log outlives its vocabulary.
+  VERB_ICONS = {
+    "create"             => "file-plus",
+    "publish"            => "send",
+    "move"               => "arrows-move",
+    "trash"              => "trash",
+    "restore_from_trash" => "arrow-back-up",
+    "destroy"            => "trash-x",
+    "discard_autosave"   => "eraser",
+    "destroy_draft"      => "eraser",
+  }.freeze
+
+  def verb_icon action
+    name = if action.action == "publish" && action.metadata["via"] == "revision"
+      "history"
+    else
+      VERB_ICONS.fetch(action.action, "circle-dashed")
+    end
+    content_tag(:span, icon(name, library: "tabler", "aria-hidden": true),
+                :class => "node_action_icon node_action_icon--#{name}",
+                :title => action.action)
+  end
+
+  # One sentence per entry, rendered from metadata alone, so entries
+  # stay renderable after the rows they reference are gone. Live
+  # associations only upgrade plain names to links. Every metadata
+  # value passes through h() here -- this helper is the escaping
+  # boundary; the locale sentences are trusted, the data never is.
+  def action_summary action
+    renderer = "summarize_#{action.action}"
+    return send(renderer, action) if respond_to?(renderer, true)
+
+    # Unknown-verb fallback: the log outlives the vocabulary. A renamed
+    # or future verb degrades to an ugly sentence, never to a 500.
+    t("node_actions.unknown", :actor => actor_ref(action),
+       :action => h(action.action), :subject => subject_ref(action)).html_safe
+  end
+
+
+  def action_details? action
+    m = action.metadata
+    return true if m["translation_diff"].present?
+    return true if m["title"].is_a?(Hash) && m.dig("title", "from") != m.dig("title", "to")
+    %w[author tags template_changed assets_changed
+       abstract_changed body_changed].any? { |key| m[key].present? }
+  end
+
+  # Plain strings by design -- safe_join in the template escapes them.
+  def default_locale_changes action
+    m = action.metadata
+    items = []
+    if m["title"].is_a?(Hash) && m.dig("title", "from") && m.dig("title", "from") != m.dig("title", "to")
+      items << t("node_actions.detail_title",
+                  :from => m.dig("title", "from"), :to => m.dig("title", "to"))
+    end
+    items << t("node_actions.detail_author",
+                :from => m.dig("author", "from"), :to => m.dig("author", "to")) if m["author"]
+    items << t("node_actions.detail_tags",
+                :from => Array(m.dig("tags", "from")).join(", "),
+                :to   => Array(m.dig("tags", "to")).join(", ")) if m["tags"]
+    items << t("node_actions.abstract_changed") if m["abstract_changed"]
+    items << t("node_actions.body_changed")     if m["body_changed"]
+    items << t("node_actions.template_changed") if m["template_changed"]
+    items << t("node_actions.assets_changed")   if m["assets_changed"]
+    items
+  end
+
+  def translation_changes diff
+    case diff["status"]
+    when "added"   then [t("node_actions.locale_added",   :title => diff.dig("title", "to"))]
+    when "removed" then [t("node_actions.locale_removed", :title => diff.dig("title", "from"))]
+    else
+      items = []
+      items << t("node_actions.detail_title",
+                  :from => diff.dig("title", "from"), :to => diff.dig("title", "to")) if diff["title"]
+      items << t("node_actions.abstract_changed") if diff["abstract_changed"]
+      items << t("node_actions.body_changed")     if diff["body_changed"]
+      items
+    end
+  end
+
+  def revision_lifecycle_badges actions
+    return "" if actions.blank?
+
+    badges = actions.map do |action|
+      key = case action.action
+            when "create"  then "node_actions.revision_created"
+            when "publish" then action.metadata["via"] == "revision" ?
+                                  "node_actions.revision_restored" :
+                                  "node_actions.revision_published"
+            end
+      next unless key
+
+      badge = h(t(key, :date => action.occurred_at.strftime("%Y-%m-%d"),
+                       :actor => action.actor_name))
+      if action.inferred_from
+        badge = safe_join([badge, content_tag(:span, t("node_actions.backfilled"),
+                                               :class => "node_action_inferred",
+                                               :title => action.inferred_from)], " ")
+      end
+      badge
+    end.compact
+
+    return "" if badges.empty?
+    safe_join(["— ", safe_join(badges, " · ")])
+  end
+
+  private
+
+  def revision_ref action, key
+    label = t(key)
+    return label unless action.node && action.page
+    link_to(label, node_revision_path(action.node, action.page))
+  end
+
+  def actor_ref action
+    action.user ? link_to(h(action.actor_name), admin_log_path(:user_id => action.user_id))
+                : h(action.actor_name)
+  end
+
+  def subject_ref action
+    action.node ? link_to(h(action.subject_name), node_path(action.node))
+                : h(action.subject_name)
+  end
+
+  def summarize_publish action
+    if action.metadata["via"] == "revision"
+      t("node_actions.publish_rollback",
+         :actor => actor_ref(action), :subject => subject_ref(action),
+         :revision => revision_ref(action, "node_actions.revision_earlier")).html_safe
+    elsif action.metadata.dig("title", "from").nil?
+      author = action.metadata.dig("author", "to")
+      key = author ? "node_actions.publish_first_with_author" : "node_actions.publish_first"
+      t(key, :actor => actor_ref(action), :subject => subject_ref(action),
+              :author => h(author)).html_safe
+    else
+      t("node_actions.publish",
+         :actor => actor_ref(action), :subject => subject_ref(action),
+         :revision => revision_ref(action, "node_actions.revision_new")).html_safe
+    end
+  end
+
+  def summarize_move action
+    t("node_actions.move", :actor => actor_ref(action), :subject => subject_ref(action),
+       :from => h(action.metadata.dig("path", "from")),
+       :to   => h(action.metadata.dig("path", "to"))).html_safe
+  end
+
+  def summarize_create action
+    t("node_actions.create", :actor => actor_ref(action), :subject => subject_ref(action),
+       :path => h(action.metadata["path"])).html_safe
+  end
+
+  def summarize_discard_autosave action
+    t("node_actions.discard_autosave",
+       :actor => actor_ref(action), :subject => subject_ref(action)).html_safe
+  end
+
+  def summarize_destroy_draft action
+    t("node_actions.destroy_draft",
+       :actor => actor_ref(action), :subject => subject_ref(action)).html_safe
+  end
+
+  def summarize_trash action
+    t("node_actions.trash", :actor => actor_ref(action), :subject => subject_ref(action),
+       :from => h(action.metadata.dig("path", "from"))).html_safe
+  end
+
+  def summarize_restore_from_trash action
+    t("node_actions.restore_from_trash", :actor => actor_ref(action), :subject => subject_ref(action),
+       :to => h(action.metadata.dig("path", "to"))).html_safe
+  end
+
+  def summarize_destroy action
+    t("node_actions.destroy", :actor => actor_ref(action), :subject => subject_ref(action),
+       :path => h(action.metadata["path"])).html_safe
+  end
+end
diff --git a/app/models/concerns/file_attachment.rb b/app/models/concerns/file_attachment.rb
index 0e99fa2..613a6f0 100644
--- a/app/models/concerns/file_attachment.rb
+++ b/app/models/concerns/file_attachment.rb
@@ -23,9 +23,10 @@ module FileAttachment
   extend ActiveSupport::Concern
 
   STYLES = {
-    medium:   { geometry: "300x300>",  format: nil },
-    thumb:    { geometry: "100x100>",  format: nil },
-    headline: { geometry: "460x250!",  format: nil }
+    medium:   { args: ["-resize", "300x300>"] },
+    thumb:    { args: ["-resize", "100x100>"] },
+    headline: { args: ["-resize", "460x250^", "-gravity", "center", "-extent", "460x250"] },
+    large:    { args: ["-resize", "1600x1600>"] }
   }.freeze
 
   IMAGE_CONTENT_TYPES    = %w[image/jpeg image/gif image/png image/webp].freeze
@@ -80,7 +81,7 @@ module FileAttachment
     STYLES.each do |style, options|
       dest_path = file_path(style)
       FileUtils.mkdir_p(File.dirname(dest_path))
-      system("magick", original_path, "-resize", options[:geometry], dest_path)
+      system("magick", original_path, *options[:args], dest_path)
     end
   end
 
diff --git a/app/models/concerns/nested_tree.rb b/app/models/concerns/nested_tree.rb
index 9a2eb0e..befcdb3 100644
--- a/app/models/concerns/nested_tree.rb
+++ b/app/models/concerns/nested_tree.rb
@@ -9,8 +9,6 @@ module NestedTree
   included do
     belongs_to :parent, class_name: name, foreign_key: :parent_id, optional: true, inverse_of: :children
     has_many :children, -> { order(:id) }, class_name: name, foreign_key: :parent_id, inverse_of: :parent
-
-    before_destroy :delete_descendants
   end
 
   class_methods do
@@ -77,10 +75,4 @@ module NestedTree
   def move_to_child_of(new_parent)
     update!(parent_id: new_parent.id)
   end
-
-  private
-
-  def delete_descendants
-    self.class.where(id: descendants.pluck(:id)).delete_all
-  end
 end
diff --git a/app/models/concerns/rrule_humanizer.rb b/app/models/concerns/rrule_humanizer.rb
index 8231de8..07141c1 100644
--- a/app/models/concerns/rrule_humanizer.rb
+++ b/app/models/concerns/rrule_humanizer.rb
@@ -15,8 +15,8 @@ module RruleHumanizer
   }.freeze
 
   ORDINAL_NAMES = {
-    de: { 1=>"ersten", 2=>"zweiten", 3=>"dritten", 4=>"vierten", -1=>"letzten", -2=>"vorletzten" },
-    en: { 1=>"first", 2=>"second", 3=>"third", 4=>"fourth", -1=>"last", -2=>"second-to-last" }
+    de: { 1=>"ersten", 2=>"zweiten", 3=>"dritten", 4=>"vierten", 5=>"fünften", -1=>"letzten", -2=>"vorletzten" },
+    en: { 1=>"first", 2=>"second", 3=>"third", 4=>"fourth", 5=>"fifth", -1=>"last", -2=>"second-to-last" }
   }.freeze
 
   MONTH_NAMES = {
@@ -35,7 +35,8 @@ module RruleHumanizer
     ordinals = ORDINAL_NAMES[loc] || ORDINAL_NAMES[:en]
     months   = MONTH_NAMES[loc]   || MONTH_NAMES[:en]
 
-    days = byday&.split(",")&.map do |d|
+    byday_values = byday&.split(",")
+    days = byday_values&.map do |d|
      if d =~ /^(-?\d+)([A-Z]{2})$/
         "#{ordinals[$1.to_i]} #{weekdays[$2]}"
       else
@@ -43,6 +44,32 @@ module RruleHumanizer
       end
     end
 
+    excluded_monthly_ordinal = nil
+    excluded_monthly_weekday = nil
+    selected_monthly_ordinals = nil
+    selected_monthly_weekday = nil
+    if freq == "MONTHLY" && byday_values.present?
+      ordinal_days = byday_values.map { |d| d.match(/^([1-5])([A-Z]{2})$/) }
+      if ordinal_days.all?
+        positions = ordinal_days.map { |match| match[1].to_i }.uniq.sort
+        weekdays_in_rule = ordinal_days.map { |match| match[2] }.uniq
+        if weekdays_in_rule.size == 1
+          selected_monthly_ordinals = positions
+          selected_monthly_weekday = weekdays_in_rule.first
+          missing_positions = (1..5).to_a - positions
+          if positions.size == 4 && missing_positions.size == 1
+            excluded_monthly_ordinal = missing_positions.first
+            excluded_monthly_weekday = selected_monthly_weekday
+          end
+        end
+      end
+    end
+
+    join_ordinals = lambda do |ordinal_values, conjunction|
+      names = ordinal_values.map { |ordinal| ordinals[ordinal] }
+      names.size > 1 ? "#{names[0..-2].join(', ')} #{conjunction} #{names.last}" : names.first
+    end
+
     base =
       case loc
       when :de
@@ -59,14 +86,26 @@ module RruleHumanizer
             interval == 2 ? "Alle zwei Wochen" : "Wöchentlich"
           end
         when "MONTHLY"
-          days ? "Jeden #{days.join(' und ')} im Monat" : "Monatlich"
+          if excluded_monthly_ordinal
+            "Jeden #{weekdays[excluded_monthly_weekday]} im Monat, außer dem #{ordinals[excluded_monthly_ordinal]} #{weekdays[excluded_monthly_weekday]}"
+          elsif selected_monthly_ordinals
+            "Jeden #{join_ordinals.call(selected_monthly_ordinals, 'und')} #{weekdays[selected_monthly_weekday]} im Monat"
+          else
+            days ? "Jeden #{days.join(' und ')} im Monat" : "Monatlich"
+          end
         end
       else
         case freq
         when "WEEKLY"
           days ? "#{interval == 2 ? 'Every other' : 'Every'} #{days.join(' and ')}" : (interval == 2 ? "Every other week" : "Weekly")
         when "MONTHLY"
-          days ? "Every #{days.join(' and ')} of the month" : "Monthly"
+          if excluded_monthly_ordinal
+            "Every #{weekdays[excluded_monthly_weekday]} of the month, except the #{ordinals[excluded_monthly_ordinal]} #{weekdays[excluded_monthly_weekday]}"
+          elsif selected_monthly_ordinals
+            "Every #{join_ordinals.call(selected_monthly_ordinals, 'and')} #{weekdays[selected_monthly_weekday]} of the month"
+          else
+            days ? "Every #{days.join(' and ')} of the month" : "Monthly"
+          end
         end
       end
     return nil unless base
diff --git a/app/models/node.rb b/app/models/node.rb
index 73eefd1..a440c2f 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -4,17 +4,23 @@ class Node < ApplicationRecord
 
   # Associations
   has_many    :pages, -> { order("revision ASC") }, :dependent => :destroy
-  belongs_to  :head,  :class_name => "Page",  :foreign_key => :head_id, :dependent => :destroy, optional: true
-  belongs_to  :draft, :class_name => "Page",  :foreign_key => :draft_id, :dependent => :destroy, optional: true
+  has_many    :node_actions, :dependent => :nullify
+  belongs_to  :head,  :class_name => "Page",  :foreign_key => :head_id, optional: true
+  belongs_to  :draft, :class_name => "Page",  :foreign_key => :draft_id, optional: true
+  # Autosave pages carry no node_id, so has_many :pages does not cover
+  # them -- this dependent: :destroy is their only cleanup on node destroy.
   belongs_to  :autosave, :class_name => "Page", :foreign_key => :autosave_id, :dependent => :destroy, optional: true
+
   has_many    :permissions, :dependent => :destroy
   has_many    :events, :dependent => :destroy
   belongs_to  :lock_owner, :class_name => "User", :foreign_key => :locking_user_id, optional: true
 
   # Callbacks
-  after_create  :initialize_empty_page
-  before_save   :check_for_changed_slug
-  after_save    :update_unique_names_of_children
+  after_create   :initialize_empty_page
+  before_save    :check_for_changed_slug
+  after_save     :update_unique_names_of_children
+  before_destroy :refuse_destroy_with_children
+  before_destroy :refuse_destroying_trash_node
 
   # Validations
   validates_length_of     :slug, :within => 1..255,    :unless => -> { parent_id.nil? || slug.blank? }
@@ -22,6 +28,21 @@ class Node < ApplicationRecord
   validates_uniqueness_of :slug, :scope => :parent_id, :unless => -> { parent_id.nil? }
   validates_presence_of   :parent_id,                  :unless => -> { Node.root.nil? }
 
+  validate :reserved_slug_stays_reserved
+  validate :no_head_inside_trash
+  validates :default_template_name,
+            :inclusion   => { :in => ->(_) { Page.custom_templates } },
+            :allow_blank => true,
+            :if          => :default_template_name_changed?
+
+  # Everything outside the Trash subtree, the Trash node included.
+  # Relies on unique_name being authoritative for tree position --
+  # the same trust public routing places in it.
+  scope :not_in_trash, -> {
+    where.not(:unique_name => CccConventions::TRASH_SLUG)
+      .where("unique_name NOT LIKE ?", "#{CccConventions::TRASH_SLUG}/%")
+  }
+
   # Class methods
 
   # Returns a page for a given node. If no revision is supplied, it returns
@@ -48,6 +69,19 @@ class Node < ApplicationRecord
     nil
   end
 
+  # The Trash container node. Lazily self-creating and idempotent, so
+  # every environment acquires it on first touch.
+  # Never call from validations. the positional predicates below
+  # exist for that.
+  def self.trash
+    root.children.find_by(:slug => CccConventions::TRASH_SLUG) ||
+      root.children.create!(:slug => CccConventions::TRASH_SLUG).tap do |node|
+        Globalize.with_locale(I18n.default_locale) do
+          node.draft.update!(:title => "Trash")
+        end
+      end
+  end
+
   # Instance Methods
 
   # Acquires (or reaffirms) the editing lock without creating a draft or
@@ -145,28 +179,6 @@ class Node < ApplicationRecord
     pairs
   end
 
-  def find_or_create_draft current_user
-    self.wipe_draft!
-    if draft && self.lock_owner == current_user
-      draft
-    elsif draft && self.lock_owner.nil?
-      lock_for! current_user
-      draft.user    = current_user if draft.user.nil?
-      draft.editor  = current_user
-      draft.save
-      draft
-    elsif draft && self.lock_owner != current_user
-      raise(
-        LockedByAnotherUser,
-        "Page is locked by another user who is working on it! " \
-        "Last modification: #{draft.updated_at.to_fs(:db)}"
-      )
-    else
-      lock_for! current_user
-      create_new_draft current_user
-    end
-  end
-
   def create_new_draft user
     empty_page        = self.pages.create!
     empty_page.user   = (self.head ? self.head.user : user)
@@ -192,10 +204,12 @@ class Node < ApplicationRecord
       self.autosave.destroy
       self.autosave_id = nil
       self.save!
+      NodeAction.record!(:node => self, :user => current_user, :action => "discard_autosave")
     elsif self.draft && self.head
       self.draft.destroy
       self.draft_id = nil
       self.save!
+      NodeAction.record!(:node => self, :user => current_user, :action => "destroy_draft")
     end
 
     self.unlock! unless self.draft
@@ -210,81 +224,187 @@ class Node < ApplicationRecord
     end
   end
 
-  def publish_draft!
+  def publish_draft! current_user = nil
     # Return nil if nothing to publish and no staged changes
     return nil unless self.draft || staged_slug || staged_parent_id
 
-    if self.draft
-      self.head = self.draft
-      self.head.published_at ||= Time.now
-      self.head.save!
-      self.draft = nil
+    if in_trash? || trash_node?
+      raise ActiveRecord::RecordInvalid.new(self), "Cannot publish a node in the Trash"
     end
 
-    if staged_slug && (staged_slug != slug)
-      self.slug = staged_slug
-      self.staged_slug = nil
-    end
+    path_before = self.unique_name
 
-    if staged_parent_id && (staged_parent_id != parent_id)
-      new_parent = Node.find(staged_parent_id)
+    ActiveRecord::Base.transaction do
+      if self.draft
+        outgoing_head = self.head
+        self.head = self.draft
+        self.head.published_at ||= Time.now
+        self.head.save!
+        self.draft = nil
 
-      if new_parent == self || self.descendants.include?(new_parent)
-        raise ActiveRecord::RecordInvalid.new(self), "Cannot move a node under itself or one of its own descendants"
+        NodeAction.record!(:node => self, :page => self.head, :user => current_user,
+                            :action => "publish", :via => "draft",
+                            **NodeAction.head_diff(outgoing_head, self.head))
       end
 
-      self.staged_parent_id = nil
-      self.save!
-      self.move_to_child_of(new_parent)
-    else
-      unless self.save
-        raise ActiveRecord::RecordInvalid.new(self)
+      if staged_slug && (staged_slug != slug)
+        self.slug = staged_slug
+        self.staged_slug = nil
       end
-    end
 
-    self.reload
-    self.update_unique_name
-    self.send(:update_unique_names_of_children)
-    self.unlock!
-    self
-  end
+      if staged_parent_id && (staged_parent_id != parent_id)
+        new_parent = Node.find(staged_parent_id)
 
-  # Releases whatever's stale and abandoned; never anything actively in
-  # use. Three independent cases share one rule -- nothing is touched
-  # unless it's been sitting untouched for over a day:
-  #  - a lock held with no draft or autosave at all (the editor opened
-  #    the page and never actually wrote anything)
-  #  - a fresh autosave older than a day, never promoted to a draft
-  #  - a draft older than a day that's still identical to head
-  def wipe_draft!
-    return if self.autosave && self.autosave.updated_at > 1.day.ago
+        if new_parent == self || self.descendants.include?(new_parent)
+          raise ActiveRecord::RecordInvalid.new(self), "Cannot move a node under itself or one of its own descendants"
+        end
 
-    unless self.draft
-      return if self.autosave.nil? && self.locked? && self.updated_at > 1.day.ago
-      self.autosave&.destroy
-      self.autosave_id = nil
+        self.staged_parent_id = nil
+        self.save!
+        self.move_to_child_of(new_parent)
+      else
+        unless self.save
+          raise ActiveRecord::RecordInvalid.new(self)
+        end
+      end
+
+      self.reload
+      self.update_unique_name
+      self.send(:update_unique_names_of_children)
+      if self.unique_name != path_before
+        NodeAction.record!(:node => self, :user => current_user, :action => "move",
+                            :path => { "from" => path_before, "to" => self.unique_name })
+      end
       self.unlock!
+      self
+    end
+  end
+
+  def restore_revision! revision, current_user = nil
+    page = self.pages.find_by_revision(revision)
+    return nil unless page
+
+    ActiveRecord::Base.transaction do
+      outgoing_head = self.head
+      self.head = page
       self.save!
-      return
+
+      NodeAction.record!(:node => self, :page => page, :user => current_user,
+                          :action => "publish", :via => "revision",
+                          **NodeAction.head_diff(outgoing_head, page))
+      self
     end
-    return unless self.head
-    return unless self.draft.updated_at < 1.day.ago
-    return if self.head.has_changes_to? self.draft
+  end
 
-    self.draft.destroy
-    self.draft_id = nil
-    self.unlock!
-    self.save!
-    self.reload
+
+  # Moves this node and its subtree into the Trash. Demotes every head
+  # in the subtree first (aggregators and search operate on heads
+  # regardless of tree position); where a node has no draft, the former
+  # head becomes its draft so content stays editable and restorable --
+  # otherwise the former head remains a plain revision. One log entry,
+  # at the root, carrying the leaving-public-view snapshot.
+  def trash! current_user = nil
+    return nil if in_trash?
+    raise ActiveRecord::RecordInvalid.new(self), "The Trash node itself cannot be trashed" if trash_node?
+
+    ActiveRecord::Base.transaction do
+      path_before        = unique_name
+      was_published      = head_id.present?
+      final_published_at = head&.published_at
+
+      demoted = 0
+      ([self] + descendants.to_a).each do |node|
+        next unless node.head_id
+        former        = node.head
+        node.head     = nil
+        node.draft_id = former.id if node.draft_id.nil?
+        node.save!
+        demoted += 1
+      end
+
+      self.reload
+      move_to_child_of(Node.trash)
+      self.reload
+      update_unique_name
+      send(:update_unique_names_of_children)
+      unlock!
+
+      metadata = { :path => { "from" => path_before, "to" => unique_name } }
+      metadata[:was_published]      = true if was_published
+      metadata[:final_published_at] = final_published_at.iso8601 if final_published_at
+      metadata[:demoted_heads]      = demoted if demoted > 0
+
+      NodeAction.record!(:node => self, :user => current_user, :action => "trash", **metadata)
+      self
+    end
   end
 
-  def restore_revision! revision
-    if page = self.pages.find_by_revision(revision)
-      self.head = page
-      self.save
-    else
-      nil
+  # Returns the node to the living tree under a chosen parent. The
+  # subtree comes back exactly as it sits in the Trash: all drafts,
+  # nothing published. Republication is a separate, witnessed act
+  # per node.
+  def restore_from_trash! new_parent, current_user = nil
+    return nil unless in_trash?
+
+    if new_parent.nil? || new_parent == self || descendants.include?(new_parent) ||
+       new_parent.trash_node? || new_parent.in_trash?
+      raise ActiveRecord::RecordInvalid.new(self), "Restore target must be a living node"
     end
+
+    ActiveRecord::Base.transaction do
+      path_before = unique_name
+      move_to_child_of(new_parent)
+      self.reload
+      update_unique_name
+      send(:update_unique_names_of_children)
+
+      NodeAction.record!(:node => self, :user => current_user, :action => "restore_from_trash",
+                          :path => { "from" => path_before, "to" => unique_name })
+      self
+    end
+  end
+
+  # Final deletion -- only from inside the Trash. Removes the whole
+  # subtree, deepest first, each node through a real destroy! so every
+  # per-node cascade runs (the categorical difference from the old
+  # delete_all nuke). refuse_destroy_with_children on bare destroy is
+  # untouched
+  # One log entry at the root, per the subtree rule, written before the
+  # rows die.
+  def destroy_from_trash! current_user = nil
+    raise ActiveRecord::RecordInvalid.new(self), "Nodes are only destroyed from the Trash" unless in_trash?
+
+    ActiveRecord::Base.transaction do
+      doomed = self_and_descendants_ordered_with_level
+                 .sort_by { |_, level| -level }
+                 .map(&:first)
+
+      metadata = { :path => unique_name }
+      metadata[:destroyed_descendants] = doomed.size - 1 if doomed.size > 1
+
+      NodeAction.record!(:node => self, :user => current_user, :action => "destroy", **metadata)
+      doomed.each(&:destroy!)
+    end
+  end
+
+  # The most recent trash entry. Its path.from is the restore hint.
+  def last_trash_entry
+    node_actions.where(:action => "trash").order(:occurred_at => :desc, :id => :desc).first
+  end
+
+  # The node's pre-trash parent, if a living node still answers to
+  # that path. Nil when the parent was itself trashed (its unique_name
+  # changed) or deleted; a different node that has since taken over
+  # the path is a legitimate suggestion.
+  def suggested_restore_parent
+    from = last_trash_entry&.metadata&.dig("path", "from")
+    return nil unless from
+
+    parent_path = from.rpartition("/").first
+    return Node.root if parent_path.empty?
+
+    candidate = Node.find_by(:unique_name => parent_path)
+    candidate unless candidate.nil? || candidate.in_trash? || candidate.trash_node?
   end
 
   # returns an array with all parts of a unique_name rather than a string
@@ -297,9 +417,12 @@ class Node < ApplicationRecord
     parent.nil? ? [slug] : parent.path_to_root.push(slug)
   end
 
+  def computed_unique_name
+    path_to_root[1..-1].join("/") # excluding root
+  end
+
   def current_unique_name
-    path = path_to_root[1..-1] # excluding root
-    self.unique_name = path.join("/")
+    self.unique_name = computed_unique_name
   end
 
   def update_unique_name
@@ -339,6 +462,20 @@ class Node < ApplicationRecord
     autosave || draft || head
   end
 
+  def trash_node?
+    parent&.root? && slug == CccConventions::TRASH_SLUG
+  end
+
+  # Inside the Trash subtree. False for the Trash node itself.
+  def in_trash?
+    current = parent
+    while current
+      return true if current.trash_node?
+      current = current.parent
+    end
+    false
+  end
+
   # Returns immutable node id for all new nodes so that the atom feed entry ids
   # stay the same eventhough the slug or positions changes.
   # Can be removed after a year or so ;)
@@ -379,7 +516,7 @@ class Node < ApplicationRecord
   end
 
   def self.drafts_and_autosaves(current_user_id: nil)
-    scope = where("draft_id IS NOT NULL OR autosave_id IS NOT NULL")
+    scope = where("draft_id IS NOT NULL OR autosave_id IS NOT NULL").not_in_trash
     return scope.order("updated_at DESC") unless current_user_id
 
     scope.order(
@@ -387,6 +524,15 @@ class Node < ApplicationRecord
     )
   end
 
+  # Nodes are never destroyed recursively
+  # Descendants must be removed or reparented individually first.
+  # The Trash feature will be the ordinary path to deletion.
+  def refuse_destroy_with_children
+    return unless children.exists?
+    errors.add(:base, "Cannot destroy a node that still has children")
+    throw :abort
+  end
+
   def self.recently_changed
     includes(:head).where(
       "pages.updated_at < ? AND pages.updated_at > ? AND nodes.parent_id IS NOT NULL",
@@ -443,4 +589,36 @@ class Node < ApplicationRecord
         end
       end
     end
+
+  private
+
+    def reserved_slug_stays_reserved
+      if parent&.root? && !trash_node_already_me?
+        errors.add(:slug, "is reserved for the Trash") if slug == CccConventions::TRASH_SLUG
+        errors.add(:staged_slug, "is reserved for the Trash") if staged_slug == CccConventions::TRASH_SLUG
+      end
+
+      if persisted? && slug_was == CccConventions::TRASH_SLUG && Node.find(id).trash_node?
+        errors.add(:slug, "of the Trash node cannot change") if slug_changed?
+        errors.add(:parent_id, "of the Trash node cannot change") if parent_id_changed?
+        errors.add(:staged_slug, "must stay empty on the Trash node") if staged_slug.present?
+        errors.add(:staged_parent_id, "must stay empty on the Trash node") if staged_parent_id.present?
+      end
+    end
+
+    def trash_node_already_me?
+      existing = Node.root&.children&.find_by(:slug => CccConventions::TRASH_SLUG)
+      existing.nil? || existing.id == id
+    end
+
+    def no_head_inside_trash
+      return unless head_id.present?
+      errors.add(:head_id, "cannot exist inside the Trash") if in_trash? || trash_node?
+    end
+
+    def refuse_destroying_trash_node
+      return unless trash_node?
+      errors.add(:base, "The Trash node cannot be destroyed")
+      throw :abort
+    end
 end
diff --git a/app/models/node_action.rb b/app/models/node_action.rb
new file mode 100644
index 0000000..13bd5ba
--- /dev/null
+++ b/app/models/node_action.rb
@@ -0,0 +1,169 @@
+class NodeAction < ApplicationRecord
+  belongs_to :node, optional: true
+  belongs_to :page, optional: true
+  belongs_to :user, optional: true
+
+  validates :action, presence: true
+  validates :occurred_at, presence: true
+
+  # == Metadata contract ==
+  #
+  # metadata is written once at creation, never updated. It is the
+  # single place anything that must survive deletion of the referenced
+  # rows lives; node_id/page_id/user_id are lookup and ordering only.
+  # All keys are strings. Pairs are always {"from" => x, "to" => y}.
+  # Optional pairs only when the sides differ; booleans only when
+  # true; required keys always present. Titles and names are read
+  # pinned to I18n.default_locale unless inside a locale-keyed block.
+  #
+  # Baseline, every entry (written here, not by call sites):
+  #   "username"                 -- actor's login at write time
+  #   "human_readable_node_name" -- node title, default locale
+  #
+  # "create":
+  #   "title" -- initial title, flat string (NOT a pair)
+  #   "path"  -- unique path at creation, flat string. Historical
+  #              value only; never a join key.
+  #
+  # "publish" (any promotion to head; diff computed BEFORE head is
+  # re-pointed, over the union of both pages' locales, by head_diff --
+  # shared with the backfill):
+  #   "via"    -- "draft" | "revision" (rollback). Always written;
+  #               absent means a pre-contract entry.
+  #   "title"  -- pair, always; "from" null on first publish
+  #   "author" -- pair, when the byline changed (incl. first publish)
+  #   "tags"   -- pair of arrays, when changed
+  #   "assets_changed", "template_changed",
+  #   "abstract_changed", "body_changed"
+  #            -- the last two for the default locale; page_id links
+  #               to the revision for the real diff (never stored)
+  #   "translation_diff" -- only when a non-default locale differs:
+  #     { "<locale>" => {
+  #         "status" -- "added" | "removed" | "changed"
+  #         "title"  -- pair, only when it differs; "from" null when
+  #                     added, "to" null when removed
+  #         "abstract_changed", "body_changed" -- status "changed" only
+  #     } }
+  #
+  # "move" (reparent and/or path change; one entry at the subtree
+  # root, descendants get none):
+  #   "path" -- pair
+  #
+  # "trash" (subtree into the Trash; every head in the subtree is
+  # demoted first; one entry at the root; snapshots the
+  # leaving-public-view state, since Trash holds no heads and destroy
+  # can no longer know):
+  #   "path"               -- pair; "from" doubles as the restore hint
+  #   "was_published"      -- boolean
+  #   "demoted_heads"      -- integer count, only when positive
+  #   "final_published_at" -- ISO8601 string, only when present
+  #
+  # "restore_from_trash" (reparent back to a living node; returns as
+  # drafts, republication is a separate witnessed act):
+  #   "path" -- pair
+  #
+  # "destroy" (only from inside the Trash, never with children; the
+  # entry is written in the same transaction before the row dies):
+  #   "path" -- final path, flat string (create-symmetric)
+  #   "destroyed_descendants" -- integer, only when positive; one entry
+  #                              at the root, per the subtree rule.
+  #
+  # Reserved: "demote" (via "trash" | "depublish") for an explicit
+  # depublish workflow, if ever built.
+  #
+  # Backfilled entries mirror this vocabulary; diff content is
+  # computed, only actor (page.editor) and occurred_at are inferred,
+  # inferred_from names the heuristic ("from_node_created_at",
+  # "from_page_revision"). Null = witnessed live.
+  #
+  # The "locale" column is written by no verb; retained.
+  #
+  # This log records; it does not undo. No IP, session, or user
+  # agent, ever. Success only.
+
+  def self.record!(node:, action:, user: nil, page: nil, locale: nil,
+                    occurred_at: nil, inferred_from: nil, **extra)
+    create!(
+      :node          => node,
+      :page          => page,
+      :user          => user,
+      :action        => action,
+      :locale        => locale,
+      :occurred_at   => occurred_at || Time.now,
+      :inferred_from => inferred_from,
+      :metadata      => {
+        "username"                 => user&.login,
+        "human_readable_node_name" => Globalize.with_locale(I18n.default_locale) {
+                                        node&.head&.title || node&.draft&.title
+                                      },
+      }.merge(extra.stringify_keys)
+    )
+  end
+
+  # Computes the publish-entry diff between an outgoing head and the
+  # page replacing it, in the exact metadata shape the contract above
+  # specifies. Pure function of its two arguments -- shared verbatim by
+  # publish_draft!, restore_revision!, and the backfill task. Reads
+  # translation rows directly, never locale-dependent accessors, so a
+  # fallback value is never mistaken for real content. Returns
+  # symbol-keyed top level for splatting into record!; nested keys are
+  # strings and jsonb serialization stringifies the rest at write time.
+  def self.head_diff old_page, new_page
+    default = I18n.default_locale
+
+    title_of = ->(page) { page&.translations&.find_by(:locale => default)&.title }
+    diff = { :title => { "from" => title_of.call(old_page),
+                         "to"   => title_of.call(new_page) } }
+    unless old_page
+      diff[:author] = { "from" => nil, "to" => new_page.user&.login } if new_page.user
+      return diff
+    end
+
+    old_author, new_author = old_page.user&.login, new_page.user&.login
+    diff[:author] = { "from" => old_author, "to" => new_author } if old_author != new_author
+
+    old_tags, new_tags = old_page.tag_list.sort, new_page.tag_list.sort
+    diff[:tags] = { "from" => old_tags, "to" => new_tags } if old_tags != new_tags
+
+    diff[:template_changed] = true if old_page.template_name != new_page.template_name
+    diff[:assets_changed]   = true if old_page.assets.map(&:id) != new_page.assets.map(&:id)
+
+    old_t = old_page.translations.find_by(:locale => default)
+    new_t = new_page.translations.find_by(:locale => default)
+    diff[:abstract_changed] = true if old_t&.abstract != new_t&.abstract
+    diff[:body_changed]     = true if old_t&.body != new_t&.body
+
+    locales = (old_page.translated_locales | new_page.translated_locales) - [default]
+    translation_diff = {}
+
+    locales.sort_by(&:to_s).each do |locale|
+      o = old_page.translations.find_by(:locale => locale)
+      n = new_page.translations.find_by(:locale => locale)
+
+      if o.nil?
+        translation_diff[locale.to_s] = { "status" => "added",
+                                          "title" => { "from" => nil, "to" => n.title } }
+      elsif n.nil?
+        translation_diff[locale.to_s] = { "status" => "removed",
+                                          "title" => { "from" => o.title, "to" => nil } }
+      elsif o.title != n.title || o.abstract != n.abstract || o.body != n.body
+        entry = { "status" => "changed" }
+        entry["title"]            = { "from" => o.title, "to" => n.title } if o.title != n.title
+        entry["abstract_changed"] = true if o.abstract != n.abstract
+        entry["body_changed"]     = true if o.body != n.body
+        translation_diff[locale.to_s] = entry
+      end
+    end
+
+    diff[:translation_diff] = translation_diff if translation_diff.any?
+    diff
+  end
+
+  def actor_name
+    metadata["username"] || "unknown"
+  end
+
+  def subject_name
+    metadata["human_readable_node_name"] || node&.unique_name || "deleted node"
+  end
+end
diff --git a/app/models/page.rb b/app/models/page.rb
index e5a8d9d..f33d88d 100644
--- a/app/models/page.rb
+++ b/app/models/page.rb
@@ -11,11 +11,21 @@ class Page < ApplicationRecord
 
   translates :title, :abstract, :body # Globalize2
 
+  # Template names render as filesystem paths; only names actually
+  # present in the public template directory are acceptable. Validated
+  # only on change so legacy rows whose template file has since
+  # vanished stay saveable -- valid_template already falls back to
+  # standard_template for those at render time.
+  validates :template_name,
+            :inclusion   => { :in => ->(_) { Page.custom_templates } },
+            :allow_blank => true,
+            :if          => :template_name_changed?
+
   # Associations
   belongs_to :node, optional: true
   belongs_to :user, optional: true
   belongs_to :editor, :class_name => "User", optional: true
-  has_many   :related_assets
+  has_many   :related_assets, :dependent => :destroy
   has_many   :assets, -> { order("position ASC") }, :through => :related_assets
 
   # Named scopes
@@ -77,7 +87,10 @@ class Page < ApplicationRecord
         .paginate(:page => page, :per_page => options[:limit])
     end
 
-    scope.order("#{options[:order_by]} #{direction}")
+    column = options[:order_by].to_s.sub(/\Apages\./, "")
+    column = "id" unless %w[id published_at created_at updated_at].include?(column)
+
+    scope.order("pages.#{column} #{direction}")
       .paginate(:page => page, :per_page => options[:limit])
   end
 
diff --git a/app/models/user.rb b/app/models/user.rb
index 92ac33a..5e47ae7 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -1,6 +1,10 @@
 require 'digest/sha1'
 
 class User < ApplicationRecord
+  has_secure_password(validations: false)
+
+  alias_method :authenticate_bcrypt, :authenticate
+
   # Mixins and Plugins
   include Authentication
   include Authentication::ByPassword
@@ -23,9 +27,30 @@ class User < ApplicationRecord
 
   # Authenticates a user by their login name and unencrypted password. Returns the user or nil.
   def self.authenticate(login, password)
-    return nil if login.blank? || password.blank?
-    u = find_by_login(login) # need to get the salt
-    u && u.authenticated?(password) ? u : nil
+    return if login.blank? || password.blank?
+
+    user = find_by(login: login)
+    return unless user
+
+    user&.authenticate(password)
+  end
+
+  def authenticate(password)
+    if password_digest.present?
+      return self if authenticate_bcrypt(password)
+      return nil
+    end
+
+    return nil unless authenticate_legacy(password)
+
+    transaction do
+      self.password = password
+      self.crypted_password = nil
+      self.salt = nil
+      save!(validate: false)
+    end
+
+    self
   end
 
   # TODO: Do we really want to have downcase logins only?
diff --git a/app/views/admin/_recent_changes.html.erb b/app/views/admin/_recent_changes.html.erb
deleted file mode 100644
index 88b5e93..0000000
--- a/app/views/admin/_recent_changes.html.erb
+++ /dev/null
@@ -1,24 +0,0 @@
-<h2>Recent Changes</h2>
-<div id="draft_list">
-  <table>
-    <tr class="header">
-      <th>Title</th>
-      <th>path</th>
-      <th>user</th>
-      <th>date</th>
-      <th></th>
-    </tr>
-    <% @recent_changes.each do |node| %>
-    <tr>
-      <td><%= truncated_title_for_node node %></td>
-      <td><%= node.unique_name %></td>
-      <td><%= node.draft.user.login rescue "" %></td>
-      <td><%= node.updated_at.to_fs(:db) %></td>
-      <td class="actions">
-        <%= link_to 'Show', node_path(node) %>
-        <%= link_to "Revisions", revision_path(:id => node.id) %>
-      </td>
-    </tr>
-    <% end %>
-  </table>
-</div>
\ No newline at end of file
diff --git a/app/views/admin/index.html.erb b/app/views/admin/index.html.erb
index bdb555e..319530d 100644
--- a/app/views/admin/index.html.erb
+++ b/app/views/admin/index.html.erb
@@ -42,21 +42,12 @@
 
   <div class="dashboard_widget">
     <h3>Recent changes</h3>
-    <ul>
-    <% @recent_changes.each do |node| %>
-      <li>
-        <div>
-          <%= link_to title_for_node(node), node_path(node) %>
-          <span class="field_hint"><%= link_to_path("#{node.unique_name} ↗", node.unique_name) %></span>
-        </div>
-        <span class="dashboard_widget_meta">
-          <%= (editor = node_head_editor(node)) ? t("published_by", editor: editor) : t("published") %>, <%= relative_time_phrase(node.head.updated_at) %>
-        </span>
-      </li>
-    <% end %>
-    </ul>
-    <%= link_to "See all recent changes →", recent_nodes_path %>
+    <table id="node_action_list">
+      <%= render partial: "node_actions/action_row", collection: @actions, as: :action %>
+    </table>
+    <%= link_to "See all recent changes →", admin_log_path %>
   </div>
+
 </div>
 
 <div id="dashboard_housekeeping">
@@ -77,5 +68,9 @@
     <%= link_to menu_items_path, class: "action_button" do %>
       <%= icon("menu-2", library: "tabler", "aria-hidden": true) %> Navigation
     <% end %>
+    <% trash_count = Node.trash.children.count %>
+    <%= link_to trashed_nodes_path, class: "action_button" do %>
+      <%= icon("trash", library: "tabler", "aria-hidden": true) %> Trash<%= " (#{trash_count})" if trash_count > 0 %>
+    <% end %>
   </div>
 </div>
diff --git a/app/views/custom/page_templates/public/chapter_detail.html.erb b/app/views/custom/page_templates/public/chapter_detail.html.erb
index f47353c..c4c2598 100644
--- a/app/views/custom/page_templates/public/chapter_detail.html.erb
+++ b/app/views/custom/page_templates/public/chapter_detail.html.erb
@@ -1,5 +1,6 @@
 <div class="article" lang="<%= @page.effective_lang %>">
   <h2 class="headline"><%= @page.title %></h2>
+  <%= headline_image %>
   <% if @page.node.external_url.present? %>
     <div class="chapter_url"><%= link_to @page.node.external_url, @page.node.external_url, target: '_blank', rel: 'noopener' %></div>
   <% end %>
diff --git a/app/views/custom/partials/_chapter.html.erb b/app/views/custom/partials/_chapter.html.erb
index 805559b..47f3950 100644
--- a/app/views/custom/partials/_chapter.html.erb
+++ b/app/views/custom/partials/_chapter.html.erb
@@ -1,19 +1,26 @@
 <div class="article_partial chapter_partial" lang="<%= page.effective_lang %>">
-  <h2 class="headline"><%= link_to_path page.title, page.node.unique_name %></h2>
-  <% if page.abstract.present? %>
-    <div class="chapter_location"><%= page.abstract %></div>
-  <% end %>
-  <% if page.node.external_url.present? %>
-    <div class="chapter_url"><%= link_to page.node.external_url, page.node.external_url, target: '_blank', rel: 'noopener' %></div>
-  <% end %>
-  <% open_days = page.node.events.tagged_with('open-day').order(:start_time) %>
-  <% if open_days.any? %>
-    <div class="chapter_open_days">
-      <span class="open_days_label"><%= t(:open_days_label) %>: </span>
-      <% open_days.each do |event| %>
-        <span class="event_schedule"><%= event_schedule_text(event) %></span>
+  <div class="chapter_partial_layout">
+    <% if page.assets.images.any? %>
+      <%= link_to_path image_tag(page.assets.images.first.upload.url(:thumb), :alt => ""), page.node.unique_name, class: "chapter_thumbnail" %>
+    <% end %>
+    <div class="chapter_partial_content">
+      <h2 class="headline"><%= link_to_path page.title, page.node.unique_name %></h2>
+      <% if page.abstract.present? %>
+        <div class="chapter_location"><%= page.abstract %></div>
       <% end %>
+      <% if page.node.external_url.present? %>
+        <div class="chapter_url"><%= link_to page.node.external_url, page.node.external_url, target: '_blank', rel: 'noopener' %></div>
+      <% end %>
+      <% open_days = page.node.events.tagged_with('open-day').order(:start_time) %>
+      <% if open_days.any? %>
+        <div class="chapter_open_days">
+          <span class="open_days_label"><%= t(:open_days_label) %>: </span>
+          <% open_days.each do |event| %>
+            <span class="event_schedule"><%= event_schedule_text(event) %></span>
+          <% end %>
+        </div>
+      <% end %>
+      <p class="excerpt"><%= sanitize page.body %></p>
     </div>
-  <% end %>
-  <p class="excerpt"><%= sanitize page.body %></p>
+  </div>
 </div>
diff --git a/app/views/events/_rrule_builder.html.erb b/app/views/events/_rrule_builder.html.erb
new file mode 100644
index 0000000..1ffec0a
--- /dev/null
+++ b/app/views/events/_rrule_builder.html.erb
@@ -0,0 +1,33 @@
+<div id="rrule_builder">
+  <p>
+    <label><%= radio_button_tag "rrule_freq", "weekly", true %> Weekly</label>
+    <label><%= radio_button_tag "rrule_freq", "monthly" %> Monthly</label>
+  </p>
+  <div id="rrule_weekly_options">
+    <p><label><%= check_box_tag "rrule_biweekly" %> Every 2 weeks</label></p>
+    <p>
+      <% %w[MO TU WE TH FR SA SU].each do |code| %>
+        <label><%= check_box_tag "rrule_byday_#{code}" %> <%= RruleHumanizer::WEEKDAY_NAMES_ABBR[:de][code] %></label>
+      <% end %>
+    </p>
+  </div>
+  <div id="rrule_monthly_options" style="display: none;">
+    <p><label><%= check_box_tag "rrule_monthly_ordinal" %> On a specific weekday each month</label></p>
+    <p id="rrule_ordinal_fields" style="display: none;">
+      <%= select_tag "rrule_ordinal", options_for_select([["1.", 1], ["2.", 2], ["3.", 3], ["4.", 4], ["letzter", -1], ["vorletzter", -2], ["Selected weeks", "custom"]]) %>
+      <%= select_tag "rrule_ordinal_day", options_for_select(%w[MO TU WE TH FR SA SU].map { |c| [RruleHumanizer::WEEKDAY_NAMES[:de][c], c] }) %>
+    </p>
+    <p id="rrule_custom_ordinal_fields" style="display: none;">
+      Weeks of the month:
+      <% (1..5).each do |ordinal| %>
+        <label><%= check_box_tag "rrule_custom_ordinal_#{ordinal}" %> <%= ordinal %>.</label>
+      <% end %>
+    </p>
+  </div>
+  <p>
+    <label><%= check_box_tag "rrule_exclude_month" %> Except in one month</label>
+    <%= select_tag "rrule_excluded_month", options_for_select((1..12).map { |m| [RruleHumanizer::MONTH_NAMES[:de][m-1], m] }), style: "display: none;" %>
+  </p>
+  <span class="field_hint">Builds the field below automatically. If your pattern is more complex than this covers, just edit it directly below - these controls won't touch it unless you use them.</span>
+</div>
+<%= f.text_field :rrule, id: "event_rrule" %>
diff --git a/app/views/events/edit.html.erb b/app/views/events/edit.html.erb
index b6564a4..4532ff2 100644
--- a/app/views/events/edit.html.erb
+++ b/app/views/events/edit.html.erb
@@ -40,33 +40,7 @@
 
       <div class="node_description">Recurrence</div>
       <div class="node_content">
-        <div id="rrule_builder">
-          <p>
-            <label><%= radio_button_tag "rrule_freq", "weekly", true %> Weekly</label>
-            <label><%= radio_button_tag "rrule_freq", "monthly" %> Monthly</label>
-          </p>
-          <div id="rrule_weekly_options">
-            <p><label><%= check_box_tag "rrule_biweekly" %> Every 2 weeks</label></p>
-            <p>
-              <% %w[MO TU WE TH FR SA SU].each do |code| %>
-                <label><%= check_box_tag "rrule_byday_#{code}" %> <%= RruleHumanizer::WEEKDAY_NAMES_ABBR[:de][code] %></label>
-              <% end %>
-            </p>
-          </div>
-          <div id="rrule_monthly_options" style="display: none;">
-            <p><label><%= check_box_tag "rrule_monthly_ordinal" %> On a specific weekday each month</label></p>
-            <p id="rrule_ordinal_fields" style="display: none;">
-              <%= select_tag "rrule_ordinal", options_for_select([["1.", 1], ["2.", 2], ["3.", 3], ["4.", 4], ["letzter", -1], ["vorletzter", -2]]) %>
-              <%= select_tag "rrule_ordinal_day", options_for_select(%w[MO TU WE TH FR SA SU].map { |c| [RruleHumanizer::WEEKDAY_NAMES[:de][c], c] }) %>
-            </p>
-          </div>
-          <p>
-            <label><%= check_box_tag "rrule_exclude_month" %> Except in one month</label>
-            <%= select_tag "rrule_excluded_month", options_for_select((1..12).map { |m| [RruleHumanizer::MONTH_NAMES[:de][m-1], m] }), style: "display: none;" %>
-          </p>
-          <span class="field_hint">Builds the field below automatically. If your pattern is more complex than this covers, just edit it directly below - these controls won't touch it unless you use them.</span>
-        </div>
-        <%= f.text_field :rrule, id: "event_rrule" %>
+        <%= render "rrule_builder", f: f %>
       </div>
 
       <div class="node_description">Title</div>
diff --git a/app/views/events/new.html.erb b/app/views/events/new.html.erb
index 7a1ee7a..028fce7 100644
--- a/app/views/events/new.html.erb
+++ b/app/views/events/new.html.erb
@@ -21,8 +21,8 @@
       <div class="node_description">End time</div>
       <div class="node_content"><%= f.datetime_select :end_time %></div>
 
-      <div class="node_description">Rrule</div>
-      <div class="node_content"><%= f.text_field :rrule %></div>
+      <div class="node_description">Recurrence</div>
+      <div class="node_content"><%= render "rrule_builder", f: f %></div>
 
       <div class="node_description">Title</div>
       <div class="node_content">
@@ -53,4 +53,3 @@
     </div>
   </div>
 <% end %>
-
diff --git a/app/views/layouts/admin.html.erb b/app/views/layouts/admin.html.erb
index 0856a0f..e220beb 100644
--- a/app/views/layouts/admin.html.erb
+++ b/app/views/layouts/admin.html.erb
@@ -7,19 +7,18 @@
     <%= csrf_meta_tags %>
   
     <title><%= "#{params[:controller]} | #{params[:action]}" %></title>
-    <%= javascript_tag "var AUTH_TOKEN = #{form_authenticity_token.inspect};" if protect_against_forgery? %>
     <%= javascript_include_tag 'admin_bundle' %>
     <%= tinymce_assets %>
     <link rel="stylesheet" href="<%= mtime_busted_path('/stylesheets/admin.css') %>">
     <script src="<%= mtime_busted_path('/javascripts/admin_search.js') %>"></script>
     <script src="<%= mtime_busted_path('/javascripts/admin_interface.js') %>"></script>
     <script src="<%= mtime_busted_path('/javascripts/related_assets.js') %>"></script>
-    <script>
+    <%= javascript_tag nonce: true do %>
       var ADMIN_SEARCH_URL = "<%= admin_search_path %>";
       var ADMIN_MENU_SEARCH_URL = "<%= admin_menu_search_path %>";
       var PARAMETERIZE_PREVIEW_URL = "<%= parameterize_preview_nodes_path %>";
       var DASHBOARD_SEARCH_URL = "<%= admin_dashboard_search_path %>";
-    </script>
+    <% end %>
   </head>
   
   <body>
diff --git a/app/views/layouts/application.html.erb b/app/views/layouts/application.html.erb
index 57d12e6..ca867ab 100644
--- a/app/views/layouts/application.html.erb
+++ b/app/views/layouts/application.html.erb
@@ -10,20 +10,20 @@
     <meta property="og:description" content="Der Chaos Computer Club ist eine galaktische Gemeinschaft von Lebewesen für Informationsfreiheit und Technikfolgenabschätzung." />
 
     <title><%= page_title %></title>
-    <link rel="stylesheet" href="/stylesheets/ccc.css">
-    <link rel="stylesheet" href="/stylesheets/glightbox.min.css">
-    <script src="/javascripts/glightbox.min.js"></script>
-    <script src="/javascripts/public.js"></script>
+    <link rel="stylesheet" href="<%= mtime_busted_path('/stylesheets/ccc.css') %>">
+    <link rel="stylesheet" href="<%= mtime_busted_path('/stylesheets/glightbox.min.css') %>">
+    <script src="<%= mtime_busted_path('/javascripts/glightbox.min.js') %>"></script>
+    <script src="<%= mtime_busted_path('/javascripts/public.js') %>"></script>
 
     <%= auto_discovery_link_tag(:atom, '/rss/updates.xml', title: "ATOM") %>
     <%= auto_discovery_link_tag(:rss,  '/rss/updates.rdf', title: "RSS") %>
 
-    <script>
-      (function() { document.addEventListener("DOMContentLoaded", function() {
-        if (localStorage.getItem('override-prefers-color-scheme', false))
+    <%= javascript_tag nonce: true do %>
+      document.addEventListener("DOMContentLoaded", function() {
+        if (localStorage.getItem('override-prefers-color-scheme'))
           document.getElementById("light-mode").checked = true;
-      }); })();
-    </script>
+      });
+    <% end %>
 
   </head>
 
diff --git a/app/views/node_actions/_action_row.html.erb b/app/views/node_actions/_action_row.html.erb
new file mode 100644
index 0000000..a9a3b8d
--- /dev/null
+++ b/app/views/node_actions/_action_row.html.erb
@@ -0,0 +1,18 @@
+<tr class="node_action node_action--<%= action.action %>">
+  <td class="node_action_time">
+    <span class="node_action_date"><%= action.occurred_at.strftime("%Y-%m-%d") %></span>
+    <%= verb_icon(action) %>
+    <span class="node_action_clock"><%= action.occurred_at.strftime("%H:%M") %></span>
+  </td>
+  <td class="node_action_body">
+    <%= action_summary(action) %>
+    <% if action.node_id && params[:node_id].blank? %>
+      <%= link_to t("node_actions.node_history"), admin_log_path(:node_id => action.node_id), :class => "node_action_zoom" %>
+    <% end %>
+    <% if action.inferred_from %>
+      <span class="node_action_inferred" title="<%= action.inferred_from %>"><%= t("node_actions.backfilled") %></span>
+    <% end %>
+    <%= render "node_actions/change_details", :action_entry => action if action_details?(action) %>
+  </td>
+</tr>
+
diff --git a/app/views/node_actions/_change_details.html.erb b/app/views/node_actions/_change_details.html.erb
new file mode 100644
index 0000000..2583e8b
--- /dev/null
+++ b/app/views/node_actions/_change_details.html.erb
@@ -0,0 +1,27 @@
+<details class="node_action_details">
+  <summary><%= t("node_actions.show_changes") %></summary>
+  <table>
+    <% if (default_items = default_locale_changes(action_entry)).any? %>
+      <tr>
+        <th><%= I18n.default_locale.to_s.upcase %></th>
+        <td>
+          <%= safe_join(default_items, ", ") %>
+          <% if action_entry.page && action_entry.node %>
+            <%= link_to t("node_actions.view_revision"), node_revision_path(action_entry.node, action_entry.page) %>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+    <% (action_entry.metadata["translation_diff"] || {}).each do |locale, diff| %>
+      <tr>
+        <th><%= locale.upcase %></th>
+        <td>
+          <%= safe_join(translation_changes(diff), ", ") %>
+          <% if action_entry.page && action_entry.node %>
+            <%= link_to t("node_actions.view_revision"), node_revision_path(action_entry.node, action_entry.page, :locale => locale) %>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  </table>
+</details>
diff --git a/app/views/node_actions/index.html.erb b/app/views/node_actions/index.html.erb
new file mode 100644
index 0000000..20ef5b3
--- /dev/null
+++ b/app/views/node_actions/index.html.erb
@@ -0,0 +1,13 @@
+<h1><%= t("node_actions.heading") %></h1>
+
+<% if params[:node_id].present? || params[:user_id].present? %>
+  <p><%= link_to t("node_actions.show_all"), admin_log_path %></p>
+<% end %>
+
+<%= will_paginate @actions %>
+
+<table id="node_action_list">
+  <%= render partial: "node_actions/action_row", collection: @actions, as: :action %>
+</table>
+
+<%= will_paginate @actions %>
diff --git a/app/views/nodes/_recent_change_item.html.erb b/app/views/nodes/_recent_change_item.html.erb
new file mode 100644
index 0000000..754a775
--- /dev/null
+++ b/app/views/nodes/_recent_change_item.html.erb
@@ -0,0 +1,9 @@
+<li>
+  <div>
+    <%= link_to title_for_node(node), node_path(node) %>
+    <span class="field_hint"><%= link_to_path("#{node.unique_name} ↗", node.unique_name) %></span>
+  </div>
+  <span class="dashboard_widget_meta">
+    <%= (editor = node_head_editor(node)) ? t("last_edited_by", editor: editor) : t("last_edited") %>, <%= relative_time_phrase(node.head.updated_at) %>
+  </span>
+</li>
diff --git a/app/views/nodes/destroy.html.erb b/app/views/nodes/destroy.html.erb
deleted file mode 100644
index 065cf1d..0000000
--- a/app/views/nodes/destroy.html.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<h1>Nodes#destroy</h1>
-<p>Find me in app/views/nodes/destroy.html.erb</p>
diff --git a/app/views/nodes/edit.html.erb b/app/views/nodes/edit.html.erb
index 9506995..25f15c2 100644
--- a/app/views/nodes/edit.html.erb
+++ b/app/views/nodes/edit.html.erb
@@ -81,7 +81,10 @@
              data-create-url="<%= node_related_assets_path(@node) %>">
           <ul id="related_asset_list" class="thumbnail_list">
             <% @page.related_assets.includes(:asset).each do |related| %>
-              <li data-url="<%= node_related_asset_path(@node, related) %>">
+              <li data-url="<%= node_related_asset_path(@node, related) %>"
+                  data-large-url="<%= related.asset.upload.url(:large) %>"
+                  data-original-url="<%= related.asset.upload.url %>"
+                  data-name="<%= related.asset.name %>">
                 <span class="related_asset_handle"><%= icon("grip-vertical", library: "tabler", "aria-hidden": true) %></span>
                 <%= image_tag related.asset.upload.url(:thumb) %>
                 <button type="button" class="related_asset_remove" aria-label="Remove image">
diff --git a/app/views/nodes/new.html.erb b/app/views/nodes/new.html.erb
index b63a606..890d46e 100644
--- a/app/views/nodes/new.html.erb
+++ b/app/views/nodes/new.html.erb
@@ -32,8 +32,8 @@
   <div id="parent_search_field" style="<%= @selected_kind == "generic" ? "" : "display: none;" %>">
     <div class="node_description">Parent</div>
     <div class="node_content">
-      <%= text_field_tag :parent_search_term, @parent_name %>
-      <%= hidden_field_tag :parent_id, @parent_id %>
+      <%= text_field_tag :parent_search_term, @parent&.title %>
+      <%= hidden_field_tag :parent_id, @parent&.id, data: { unique_name: @parent&.computed_unique_name } %>
       <div id="parent_search_results" class="search_results"></div>
     </div>
   </div>
diff --git a/app/views/nodes/recent.html.erb b/app/views/nodes/recent.html.erb
index 3602775..d256253 100644
--- a/app/views/nodes/recent.html.erb
+++ b/app/views/nodes/recent.html.erb
@@ -1,3 +1,7 @@
 <h1>Recently changed</h1>
 
-<%= render 'node_list' %>
+<%= will_paginate @nodes %>
+<ul id="recent_changes_full_list">
+  <%= render partial: "nodes/recent_change_item", collection: @nodes, as: :node %>
+</ul>
+<%= will_paginate @nodes %>
diff --git a/app/views/nodes/show.html.erb b/app/views/nodes/show.html.erb
index 66f04f9..af05778 100644
--- a/app/views/nodes/show.html.erb
+++ b/app/views/nodes/show.html.erb
@@ -46,7 +46,7 @@
         <% end %>
 
         <% unless locked_by_other %>
-          <% if @node.draft && !@node.autosave %>
+          <% if @node.draft && !@node.autosave && !@node.in_trash? && !@node.trash_node? %>
             <div class="node_info_item">
               <%= button_to 'Publish', publish_node_path(@node), method: :put,
                     form: { data: { confirm: "Publish this draft?" }, class: 'button_to state_changing' } %>
@@ -62,6 +62,15 @@
             <% end %>
             </div>
           <% end %>
+          <% unless @node.trash_node? || @node.in_trash? || @node.root? %>
+            <div class="node_info_item">
+              <%= button_to trash_node_path(@node), method: :put,
+                    form: { data: { confirm: "Move this page and everything beneath it to the Trash? All published content in it will go offline." }, class: 'button_to destructive' } do %>
+                <%= icon("trash", library: "tabler", "aria-hidden": true) %>
+                Move to Trash
+              <% end %>
+            </div>
+          <% end %>
         <% end %>
       </div>
 
@@ -70,6 +79,48 @@
       <% end %>
     </div>
 
+    <% if @node.in_trash? %>
+      <div class="node_description">Trash</div>
+      <div class="node_content node_info_group">
+        <div class="node_info_group_items">
+          <% if (entry = @node.last_trash_entry) && entry.metadata.dig("path", "from") %>
+            <div class="node_info_item">
+              <span class="node_info_label">Was at</span>
+              <%= entry.metadata.dig("path", "from") %>
+            </div>
+          <% end %>
+          <div class="node_info_item">
+            <span class="node_info_label">Restore to</span>
+            <% suggestion = @node.suggested_restore_parent %>
+            <%= form_tag restore_from_trash_node_path(@node), :method => :put, :class => "aligned_action_row" do %>
+              <div class="restore_picker">
+                <%= text_field_tag :restore_search_term,
+                      suggestion && (suggestion.head&.title || suggestion.draft&.title || suggestion.slug),
+                      :placeholder => "Search for a new parent…" %>
+                <div id="restore_search_results" class="search_results"></div>
+              </div>
+              <%= hidden_field_tag :parent_id, suggestion&.id %>
+              <%= submit_tag "Restore here", :class => "action_button action_button_no_margin_top" %>
+            <% end %>
+            <span class="field_hint">Restored pages come back unpublished. Republish each page deliberately.</span>
+          </div>
+        </div>
+        <div class="node_info_group_items">
+          <div class="node_info_item">
+            <% doomed_below = @node.descendants.count %>
+            <%= button_to node_path(@node), method: :delete,
+                  form: { data: { confirm: doomed_below > 0 ?
+                            "Delete this page and the #{doomed_below} pages beneath it permanently? This cannot be undone." :
+                            "Delete this page permanently? This cannot be undone." },
+                          class: 'button_to destructive' } do %>
+              <%= icon("trash-x", library: "tabler", "aria-hidden": true) %>
+              Delete permanently<%= " (including #{doomed_below} beneath)" if doomed_below > 0 %>
+            <% end %>
+          </div>
+        </div>
+      </div>
+    <% end %>
+
     <div class="node_description">Translations</div>
     <div class="node_content node_info_group">
       <div class="node_info_group_items">
@@ -170,19 +221,22 @@
       </div>
     </div>
 
-    <div class="node_description">Revisions</div>
+    <div class="node_description">History</div>
     <div class="node_content node_info_group">
       <details>
         <summary>
-          <%= pluralize(@node.pages.count, 'revision', 'revisions') %>
+          <%= pluralize(@node.pages.count, 'published revision', 'published revisions') %>
         </summary>
         <ul>
           <% @node.pages.order(:revision).each do |page| %>
-            <li><%= link_to "##{page.revision} — #{page.title} (#{page.editor.try(:login)}, #{page.updated_at})", node_revision_path(@node, page) %></li>
+            <li>
+              <%= link_to "##{page.revision} — #{page.title} (#{page.editor.try(:login)}, #{page.updated_at})", node_revision_path(@node, page) %>
+              <span class="revision_lifecycle"><%= revision_lifecycle_badges(@page_actions[page.id]) %></span>
+            </li>
           <% end %>
         </ul>
       </details>
-      <p class="revisions_full_history_link"><%= link_to 'Full history (diff / restore)', node_revisions_path(@node) %></p>
+      <p class="revisions_full_history_link"><%= link_to 'Revision history (diff / restore)', node_revisions_path(@node) %> | <%= link_to t("node_actions.heading"), admin_log_path(:node_id => @node.id) %></p>
     </div>
 
 
diff --git a/app/views/nodes/trashed.html.erb b/app/views/nodes/trashed.html.erb
new file mode 100644
index 0000000..9a4808e
--- /dev/null
+++ b/app/views/nodes/trashed.html.erb
@@ -0,0 +1,42 @@
+<h1>Trash</h1>
+
+<% if @nodes.empty? %>
+  <p class="field_hint">The Trash is empty.</p>
+<% else %>
+  <%= will_paginate @nodes %>
+  <table id="trashed_node_list">
+    <tr>
+      <th>Title</th>
+      <th>Was at</th>
+      <th>Trashed</th>
+      <th>Actions</th>
+    </tr>
+    <% @nodes.each do |node| %>
+      <% entry = node.last_trash_entry %>
+      <tr>
+        <% doomed_below = node.descendants.count %>
+        <td>
+          <%= link_to (node.draft&.title || node.slug), node_path(node) %><%= " (+ #{doomed_below} beneath)" if doomed_below > 0 %>
+        </td>
+        <td><%= entry&.metadata&.dig("path", "from") %></td>
+        <td>
+          <% if entry %>
+            <%= entry.occurred_at.strftime("%Y-%m-%d %H:%M") %> by <%= entry.actor_name %>
+          <% end %>
+        </td>
+        <td>
+          <%= button_to node_path(node), method: :delete,
+                        form: { data: { confirm: doomed_below > 0 ?
+                          "Delete \"#{node.draft&.title || node.slug}\" and the #{doomed_below} pages beneath it permanently? This cannot be undone." :
+                          "Delete \"#{node.draft&.title || node.slug}\" permanently? This cannot be undone." },
+                        class: 'button_to destructive' } do %>
+            <%= icon("trash-x", library: "tabler", "aria-hidden": true) %>
+            Delete permanently
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  </table>
+  <%= will_paginate @nodes %>
+  <p class="field_hint">To restore a page, open it and pick a new parent in its Trash section.</p>
+<% end %>
diff --git a/app/views/page_translations/edit.html.erb b/app/views/page_translations/edit.html.erb
index 0f64d40..00bf221 100644
--- a/app/views/page_translations/edit.html.erb
+++ b/app/views/page_translations/edit.html.erb
@@ -20,6 +20,15 @@
 </div>
 
 <div id="page_editor">
+  <ul id="related_asset_list" style="display:none">
+    <% @page.related_assets.includes(:asset).each do |related| %>
+      <li data-large-url="<%= related.asset.upload.url(:large) %>"
+          data-original-url="<%= related.asset.upload.url %>"
+          data-name="<%= related.asset.name %>">
+        <%= image_tag related.asset.upload.url(:thumb) %>
+      </li>
+    <% end %>
+  </ul>
   <%= form_with url: node_translation_path(@node, @locale), method: :patch, local: true, id: "translation_edit_form",
         data: { autosave_url: autosave_node_translation_path(@node, @locale), show_url: node_path(@node) } do |f| %>
     <div id="content">