11 files changed, 175 insertions, 14 deletions

diff --git a/app/controllers/node_actions_controller.rb b/app/controllers/node_actions_controller.rb
index 6e46719..9b97b45 100644
--- a/app/controllers/node_actions_controller.rb
+++ b/app/controllers/node_actions_controller.rb
@@ -6,7 +6,11 @@ class NodeActionsController < ApplicationController
 
   def index
     @actions = NodeAction.order(:occurred_at => :desc, :id => :desc)
-    @actions = @actions.where(:node_id => params[:node_id]) if params[:node_id].present?
+    if params[:node_id].present?
+      @actions = @actions.joins(:action_participants)
+                         .where(:action_participants => { :subject_type => "Node",
+                                                          :subject_id   => params[:node_id] })
+    end
     @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)
diff --git a/app/models/action_participant.rb b/app/models/action_participant.rb
new file mode 100644
index 0000000..f179a48
--- /dev/null
+++ b/app/models/action_participant.rb
@@ -0,0 +1,4 @@
+class ActionParticipant < ApplicationRecord
+  belongs_to :node_action
+  belongs_to :subject, :polymorphic => true
+end
diff --git a/app/models/node.rb b/app/models/node.rb
index a5a40d3..7a93e79 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -4,7 +4,14 @@ class Node < ApplicationRecord
 
   # Associations
   has_many    :pages, -> { order("revision ASC") }, :dependent => :destroy
+
+  # Entries where this node is the primary subject (fast-path column).
+  # For a *complete* history -- including subtree trash/destroy entries
+  # recorded at an ancestor -- use participated_actions instead.
   has_many    :node_actions, :dependent => :nullify
+  has_many    :action_participations, :class_name => "ActionParticipant", :as => :subject
+  has_many    :participated_actions, :through => :action_participations, :source => :node_action
+
   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
@@ -312,14 +319,14 @@ class Node < ApplicationRecord
       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
+      subtree = [self] + descendants.to_a
+      demoted_nodes = subtree.select do |node|
+        next false unless node.head_id
         former        = node.head
         node.head     = nil
         node.draft_id = former.id if node.draft_id.nil?
         node.save!
-        demoted += 1
+        true
       end
 
       self.reload
@@ -332,9 +339,10 @@ class Node < ApplicationRecord
       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
+      metadata[:demoted_heads]      = demoted_nodes.size if demoted_nodes.any?
 
-      NodeAction.record!(:node => self, :user => current_user, :action => "trash", **metadata)
+      NodeAction.record!(:participants => subtree, :user => current_user,
+                          :action => "trash", **metadata)
       self
     end
   end
@@ -382,7 +390,8 @@ class Node < ApplicationRecord
       metadata = { :path => unique_name }
       metadata[:destroyed_descendants] = doomed.size - 1 if doomed.size > 1
 
-      NodeAction.record!(:node => self, :user => current_user, :action => "destroy", **metadata)
+      NodeAction.record!(:participants => doomed, :user => current_user,
+                          :action => "destroy", **metadata)
       doomed.each(&:destroy!)
     end
   end
diff --git a/app/models/node_action.rb b/app/models/node_action.rb
index 63a99ae..8a3dd8b 100644
--- a/app/models/node_action.rb
+++ b/app/models/node_action.rb
@@ -3,6 +3,8 @@ class NodeAction < ApplicationRecord
   belongs_to :page, optional: true
   belongs_to :user, optional: true
 
+  has_many :action_participants, :dependent => :destroy
+
   validates :action, presence: true
   validates :occurred_at, presence: true
 
@@ -81,10 +83,15 @@ class NodeAction < ApplicationRecord
   # 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)
+  def self.record!(node: nil, participants: [], action:, user: nil, page: nil,
+                    locale: nil, occurred_at: nil, inferred_from: nil, **extra)
+    participants = participants.presence || [node].compact
+    raise ArgumentError, "NodeAction.record! needs at least one participant" if participants.empty?
+
+    primary_node = node || (participants.first if participants.first.is_a?(Node))
+
     create!(
-      :node          => node,
+      :node          => primary_node,
       :page          => page,
       :user          => user,
       :action        => action,
@@ -94,10 +101,12 @@ class NodeAction < ApplicationRecord
       :metadata      => {
         "username"                 => user&.login,
         "human_readable_node_name" => Globalize.with_locale(I18n.default_locale) {
-                                        node&.head&.title || node&.draft&.title
+                                        primary_node&.head&.title || primary_node&.draft&.title
                                       },
       }.merge(extra.stringify_keys)
-    )
+    ).tap do |na|
+      participants.each { |subject| na.action_participants.create!(:subject => subject) }
+    end
   end
 
   # Computes the publish-entry diff between an outgoing head and the
diff --git a/db/migrate/20260723011350_create_action_participants.rb b/db/migrate/20260723011350_create_action_participants.rb
new file mode 100644
index 0000000..493ac50
--- /dev/null
+++ b/db/migrate/20260723011350_create_action_participants.rb
@@ -0,0 +1,13 @@
+class CreateActionParticipants < ActiveRecord::Migration[8.1]
+  def change
+    create_table :action_participants do |t|
+      t.references :node_action, null: false, foreign_key: true, index: false
+      t.references :subject, polymorphic: true, null: false, index: false
+    end
+    add_index :action_participants, [:subject_type, :subject_id, :node_action_id],
+              :name => "index_action_participants_on_subject_and_action"
+    add_index :action_participants, [:node_action_id, :subject_type, :subject_id],
+              :unique => true,
+              :name => "index_action_participants_uniqueness"
+  end
+end
diff --git a/lib/tasks/node_actions.rake b/lib/tasks/node_actions.rake
index fdd286c..c378db2 100644
--- a/lib/tasks/node_actions.rake
+++ b/lib/tasks/node_actions.rake
@@ -58,4 +58,18 @@ namespace :node_actions do
 
     puts "Created #{created} inferred entries"
   end
+
+  desc "Backfill action_participants for existing single-subject entries. " \
+       "Idempotent: entries that already have a participant row are skipped. " \
+       "Multi-node trash/destroy entries predating this feature are NOT " \
+       "reconstructable (only a count was ever stored) and are left as-is."
+  task :backfill_participants => :environment do
+    scope = NodeAction.where.missing(:action_participants).where.not(:node_id => nil)
+    created = 0
+    scope.find_each do |action|
+      action.action_participants.create!(:subject => action.node)
+      created += 1
+    end
+    puts "Created #{created} participant rows"
+  end
 end
diff --git a/test/controllers/assets_controller_test.rb b/test/controllers/assets_controller_test.rb
index f834541..05fc6de 100644
--- a/test/controllers/assets_controller_test.rb
+++ b/test/controllers/assets_controller_test.rb
@@ -92,6 +92,47 @@ class AssetsControllerTest < ActionController::TestCase
     end
   end
 
+  # --- create with attach ---
+
+  test "create with node_id attaches the asset to the node's draft" do
+    node = Node.root.children.create!(:slug => "asset_attach_target")
+
+    post :create, params: { asset: { name: 'Attach me' }, node_id: node.id }
+
+    assert_response :redirect
+    asset = Asset.last
+    assert_includes node.draft.assets.reload, asset
+    assert_match /attached/, flash[:notice]
+  end
+
+  test "create against a foreign-locked node keeps the asset but refuses the attach" do
+    node = Node.root.children.create!(:slug => "asset_attach_locked")
+    node.lock_for_editing!(users(:aaron))
+
+    assert_difference 'Asset.count', 1 do
+      post :create, params: { asset: { name: 'Orphaned for now' }, node_id: node.id }
+    end
+
+    assert_empty node.draft.assets.reload
+    assert_equal node_path(node), flash[:locked_node_path]
+    assert_equal "aaron", flash[:locked_by]
+  end
+
+  test "create with headline against a page that has one keeps the incumbent and warns" do
+    node = Node.root.children.create!(:slug => "asset_attach_headline")
+    incumbent = Asset.create!(:name => 'Incumbent', :upload_content_type => 'image/png')
+    node.draft.related_assets.create!(:asset => incumbent, :headline => true)
+
+    uploaded = Rack::Test::UploadedFile.new(
+      Rails.root.join('test', 'fixtures', 'files', 'test_image.png'), 'image/png')
+    post :create, params: { asset: { name: 'Challenger', upload: uploaded },
+                            node_id: node.id, headline: "1" }
+
+    assert_includes node.draft.assets.reload, Asset.last
+    assert_equal incumbent, node.draft.reload.headline_asset
+    assert_equal node_path(node), flash[:headline_kept_path]
+  end
+
   # --- edit ---
 
   test "get edit" do
diff --git a/test/controllers/node_actions_controller_test.rb b/test/controllers/node_actions_controller_test.rb
index 8bc68ec..cfc5a31 100644
--- a/test/controllers/node_actions_controller_test.rb
+++ b/test/controllers/node_actions_controller_test.rb
@@ -48,4 +48,14 @@ class NodeActionsControllerTest < ActionController::TestCase
     get :index
     assert_response :redirect
   end
+
+  test "zooming on a node finds subtree entries recorded at its ancestor" do
+    parent = Node.root.children.create!(:slug => "zoom_participant_parent")
+    child  = parent.children.create!(:slug => "zoom_participant_child")
+    parent.trash!(users(:quentin))
+
+    get :index, params: { :node_id => child.id }
+    assert_response :success
+    assert_includes assigns(:actions).map(&:action), "trash"
+  end
 end
diff --git a/test/controllers/nodes_controller_test.rb b/test/controllers/nodes_controller_test.rb
index 55da524..d777108 100644
--- a/test/controllers/nodes_controller_test.rb
+++ b/test/controllers/nodes_controller_test.rb
@@ -79,6 +79,35 @@ class NodesControllerTest < ActionController::TestCase
     end
   end
 
+  test "create with asset_id attaches the asset to the new draft, as headline when asked" do
+    login_as :quentin
+    asset = Asset.create!(:name => 'Birth attachment', :upload_content_type => 'image/png')
+
+    post :create, params: { :kind => "generic", :parent_id => Node.root.id,
+                            :title => "Born Attached",
+                            :asset_id => asset.id, :asset_headline => "1" }
+
+    assert_response :redirect
+    node = Node.last
+    assert_includes node.draft.assets, asset
+    assert_equal asset, node.draft.headline_asset
+    assert_match /attached/, flash[:notice]
+  end
+
+  test "the attach notice survives the redirect into the editor" do
+    login_as :quentin
+    asset = Asset.create!(:name => 'Flash survivor', :upload_content_type => 'image/png')
+
+    post :create, params: { :kind => "generic", :parent_id => Node.root.id,
+                            :title => "Notice Carrier", :asset_id => asset.id }
+    assert_redirected_to edit_node_path(Node.last)
+
+    get :edit, params: { :id => Node.last.id }
+    assert_response :success
+    assert_match /attached/, flash[:notice]
+    assert_no_match /ready to edit/, flash[:notice]
+  end
+
   test "editing a node" do
     login_as :quentin
 
diff --git a/test/models/node_action_test.rb b/test/models/node_action_test.rb
index b177cca..849b36f 100644
--- a/test/models/node_action_test.rb
+++ b/test/models/node_action_test.rb
@@ -118,11 +118,29 @@ class NodeActionTest < ActiveSupport::TestCase
 
   test "record! passes provenance and historical timestamps through" do
     long_ago = 2.years.ago
-    action = NodeAction.record!(:node => nil, :action => "publish",
+    node = Node.root.children.create!(:slug => "provenance_backfill_test")
+    action = NodeAction.record!(:node => node, :action => "publish",
                                  :occurred_at => long_ago,
                                  :inferred_from => "from_page_revision")
 
     assert_equal "from_page_revision", action.inferred_from
     assert_in_delta long_ago.to_f, action.occurred_at.to_f, 1.0
   end
+
+
+  test "record! with participants: writes one action_participant per subject" do
+    n1, n2 = Node.root.children.create!(:slug => "participant_a"), Node.root.children.create!(:slug => "participant_b")
+    action = NodeAction.record!(:participants => [n1, n2], :action => "trash", :user => users(:quentin))
+    assert_equal [n1, n2], action.action_participants.map(&:subject)
+  end
+
+  test "record! with node: alone still writes exactly one participant" do
+    node = Node.root.children.create!(:slug => "participant_sugar")
+    action = NodeAction.record!(:node => node, :action => "create", :user => users(:quentin))
+    assert_equal [node], action.action_participants.map(&:subject)
+  end
+
+  test "record! refuses an empty participant set" do
+    assert_raises(ArgumentError) { NodeAction.record!(:action => "create", :user => users(:quentin)) }
+  end
 end
diff --git a/test/models/node_test.rb b/test/models/node_test.rb
index ba38340..0083b08 100644
--- a/test/models/node_test.rb
+++ b/test/models/node_test.rb
@@ -756,6 +756,16 @@ class NodeTest < ActiveSupport::TestCase
     assert node.valid?
   end
 
+  test "trash! records every subtree node as a participant, not just the root" do
+    parent = Node.root.children.create!(:slug => "trash_participants_parent")
+    child  = parent.children.create!(:slug => "trash_participants_child")
+
+    parent.trash!(users(:quentin))
+
+    action = parent.node_actions.where(:action => "trash").last
+    assert_includes action.action_participants.map(&:subject), child
+  end
+
   test "destroying a node with children is refused" do
     parent = Node.root.children.create!(:slug => "destroy_guard_parent")
     parent.children.create!(:slug => "destroy_guard_child")