plutonium 0.61.0 → 0.62.0

data/docs/superpowers/plans/2026-07-02-kanban-drop-interactions.md.tasks.json

@@ -0,0 +1,68 @@
+{
+  "planPath": "docs/superpowers/plans/2026-07-02-kanban-drop-interactions.md",
+  "tasks": [
+    {
+      "id": 0,
+      "subject": "Task 0: Column#drop_interaction + derived action key",
+      "status": "completed",
+      "description": "Add drop_interaction: option to Plutonium::Kanban::Column; expose reader, drop_interaction? predicate, drop_interaction_key derivation (MarkLostInteraction -> :mark_lost); raise ArgumentError on non-interaction. Verify dsl.rb passthrough.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/kanban/column.rb\", \"test/plutonium/kanban/column_test.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/plutonium/kanban/column_test.rb\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 1,
+      "subject": "Task 1: Register drop_interaction as hidden record action",
+      "status": "completed",
+      "blockedBy": [0],
+      "description": "At kanban compile time register each column's drop_interaction as an interactive record action flagged kanban_drop: true; exclude kanban_drop? actions from toolbars.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/definition/index_views.rb\", \"lib/plutonium/action/base.rb\", \"lib/plutonium/action/interactive/factory.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/plutonium/definition/index_views_test.rb\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 2,
+      "subject": "Task 2: Add GET kanban_move_form member route",
+      "status": "completed",
+      "blockedBy": [1],
+      "description": "Add GET <member>/kanban_move_form -> kanban_actions#kanban_move_form, named. POST kanban_move unchanged.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/routing/mapper_extensions.rb\"], \"verifyCommand\": \"cd test/dummy && bin/rails routes | grep kanban_move\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 3,
+      "subject": "Task 3: kanban_move_form GET renders interaction modal",
+      "status": "completed",
+      "blockedBy": [2],
+      "description": "Build drop interaction as record action; render its form in remote modal; form action=kanban_move with hidden from/to_column, to_index; authorize transition; 422 when no drop_interaction.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/resource/controllers/kanban_actions.rb\", \"app/views/plutonium/resource/kanban_move_form.html.erb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/integration\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 4,
+      "subject": "Task 4: kanban_move POST — atomic interaction + on_drop + reposition",
+      "status": "completed",
+      "blockedBy": [2, 3],
+      "description": "Single transaction: authorize transition -> on_drop (membership) -> interaction.call (extras) -> reposition. Failure -> Rollback + 422 modal. Success -> column streams. Guards before interaction; plain columns + seed path unchanged.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/resource/controllers/kanban_actions.rb\", \"test/integration\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/integration\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 5,
+      "subject": "Task 5: Emit data-kanban-drop-* on drop-interaction columns",
+      "status": "completed",
+      "blockedBy": [4],
+      "description": "Column component renders data-kanban-drop-interaction=true + data-kanban-drop-form-url-template with __ID__; plain columns render neither.\n\n```json:metadata\n{\"files\": [\"lib/plutonium/ui/kanban/column.rb\", \"lib/plutonium/resource/controllers/kanban_actions.rb\", \"test/integration/admin_portal/kanban_dom_contract_test.rb\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/integration/admin_portal/kanban_dom_contract_test.rb\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 6,
+      "subject": "Task 6: Stimulus — open modal on drop (no snap-back; card never moves in DOM)",
+      "status": "completed",
+      "blockedBy": [5],
+      "description": "On drop into drop-interaction column navigate remote-modal frame to kanban_move_form with move params; hold pending; snap back on dismiss without success; plain columns keep direct POST. yarn build.\n\n```json:metadata\n{\"files\": [\"src/js/controllers/kanban_controller.js\", \"app/assets/plutonium.js\"], \"verifyCommand\": \"yarn build\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 7,
+      "subject": "Task 7: Document drop_interaction (guide + DSL ref + skill)",
+      "status": "completed",
+      "blockedBy": [6],
+      "description": "Guide section w/ worked example + MarkLostInteraction; two-flow model + author contract + def mark_lost? gate; DSL table row; skill Column-options + Authorization updates; yarn docs:build.\n\n```json:metadata\n{\"files\": [\"docs/guides/kanban.md\", \"docs/reference/kanban/dsl.md\", \".claude/skills/plutonium-kanban/SKILL.md\"], \"verifyCommand\": \"yarn docs:build\", \"requiresUserVerification\": false}\n```"
+    },
+    {
+      "id": 8,
+      "subject": "Task 8: E2E dummy drive + system test",
+      "status": "completed",
+      "blockedBy": [7, 6],
+      "description": "Dummy resource/interaction via generators + migration for lost_reason (inline index); system test covers commit-with-reason, blank-reason error, cancel snap-back; def mark_lost? on policy; manual browser drive.\n\n```json:metadata\n{\"files\": [\"test/system\", \"test/dummy\"], \"verifyCommand\": \"bundle exec appraisal rails-8.1 ruby -Itest test/system\", \"requiresUserVerification\": false}\n```"
+    }
+  ],
+  "lastUpdated": "2026-07-02"
+}

data/docs/superpowers/specs/2026-07-03-kanban-auth-simplification.md

@@ -0,0 +1,159 @@
+# Kanban authorization & `accepts:` simplification
+
+**Status:** implemented (full suite green — 0 failures; 12 pre-existing `model_name` errors unrelated)
+**Branch:** `feat/kanban-drop-interactions` (PR #67)
+**Supersedes:** the earlier `enter_interaction_key` collision fix idea (never shipped)
+
+## Why
+
+The thread started from a real bug in how `enter_interaction`'s policy key is derived:
+
+```ruby
+# Plutonium::Kanban::Column#enter_interaction_key (today)
+@enter_interaction.name.demodulize.sub(/Interaction\z/, "").underscore.to_sym
+# BlockTaskInteraction → :block_task
+```
+
+That key is used **both** as the internal action-registration key **and** as the
+authorization method name (`block_task?`). Because it's derived only from the
+class basename, it isn't unique:
+
+- **Same class on two columns** → same key → shared policy method, no per-column auth.
+- **Different classes, same demodulized name** (`Leads::CloseInteraction` vs
+  `Deals::CloseInteraction` → `:close`) → last-writer-wins registration → one
+  column silently runs the other column's interaction. Genuine, silent bug.
+
+Chasing a fix surfaced a deeper inconsistency: **per-column authorization only
+exists as a side effect of declaring an interaction.** A plain column can't say
+"only managers may drop here" without smuggling `current_user` into an `accepts:`
+Proc — authorization in the wrong layer.
+
+## Decisions
+
+### 1. One authorization method: `kanban_move?`
+
+Collapse all move authorization to a single `kanban_move?`. No `enter_<column>?`
+convention, no per-interaction derived policy method.
+
+- Default stays argument-less and delegates to `update?` (unchanged for existing boards).
+- Advanced boards branch on `from`/`to`, supplied via **authorization context**
+  (ActionPolicy rules take no positional args — context is the sanctioned channel).
+
+```ruby
+# controller (kanban_move)
+authorize_current! record, to: :kanban_move?,
+  context: { kanban_from: from, kanban_to: to }
+
+# policy — opt in only when you need it
+def kanban_move?
+  return super unless authorization_context[:kanban_to]&.key == :closed_won
+  user.admin?
+end
+```
+
+Consequence: **`enter_interaction` stops needing a policy method entirely.** It's
+authorized by `kanban_move?` like every other move. The class-derived key is
+demoted to an internal form/param routing key only.
+
+### 2. `enter_interaction` registration key becomes internal + column-scoped
+
+Since the key is no longer an authorization name, uniqueness only has to hold for
+internal action routing. Scope it to the column so it's collision-free by
+construction and never surfaces to the author:
+
+```ruby
+def enter_interaction_key
+  return nil unless @enter_interaction
+  :"#{key}_enter_interaction"   # :blocked → :blocked_enter_interaction
+end
+```
+
+The registered hidden action's policy check delegates to `kanban_move?` (it does
+NOT get its own author-facing policy method).
+
+### 3. Strip the Proc form of `accepts:`
+
+`accepts:` keeps only its structural, client-hintable forms:
+
+- `true` / `false` / `Array` of source keys → workflow topology + drag-time drop
+  hints (the browser reads `data-kanban-accepts`; a policy can't run client-side).
+
+The **Proc form is removed outright — no deprecation bridge.** It's server-only
+(gives no client hint), record-based, and overlaps with `kanban_move?`.
+Record-conditional rejection moves to `kanban_move?`, which now sees both the
+record and `to` via context.
+
+The constructor **raises** on a `Proc` accepts value (`ArgumentError`), in every
+env. "Let it break" means fail loud — NOT silently fall through `accepts?`'s
+`else` branch to `accepts: true`, which would quietly *open up* a column that used
+to restrict drops. No `on_drop`-style env-gated bridge; a plain raise.
+
+Delete `Column#accepts_record?` (the per-card evaluator) — with no Proc form the
+move handler just calls `accepts?(source_key)`.
+
+### 4. No exit authorization method
+
+Considered `exit_<column>?` for symmetry with `on_exit`. Rejected as
+over-built: exit-gating is an order of magnitude rarer than entry-gating, and it
+doubles the auth surface plus makes a denial ambiguous (from vs to). The
+structural "never lets go" case stays as `locked:`; per-user exit rules are
+expressible in `kanban_move?` via the `from` context when actually needed.
+
+## Net model
+
+| Layer | Mechanism |
+|---|---|
+| Structure (definition, client-hintable) | `accepts:` (true/false/Array), `locked:`, `wip:` |
+| Authorization (policy) | **`kanban_move?`** only — argument-less default → `update?`; reads `from`/`to` from context |
+| Behavior | `on_enter` / `on_exit`; `enter_interaction` (input collection, authorized by `kanban_move?`) |
+
+Deletes: `accepts:` Proc + `accepts_record?`, the `enter_<column>?` idea, the
+class-derived interaction policy method. Adds: `from`/`to` in the move's auth
+context. Simpler on every axis.
+
+## Migration (in-repo)
+
+**`lib/plutonium/kanban/column.rb`**
+- `enter_interaction_key` → column-scoped (decision 2).
+- `accepts:` Proc → deprecate (raise local / warn+permissive deployed), drop `accepts_record?`.
+
+**`lib/plutonium/resource/controllers/kanban_actions.rb`**
+- Pass `context: { kanban_from: from, kanban_to: to }` to the `kanban_move?` authorize.
+- Replace `accepts_record?(record, from.key)` with `accepts?(from.key)`.
+- Registered enter_interaction action authorizes via `kanban_move?`, not a derived method.
+
+**`lib/plutonium/definition/index_views.rb`**
+- Register the enter_interaction under the column-scoped key.
+
+**Dummy (`test/dummy/app/…`)**
+- `task_definition.rb`: `:done` `accepts: ->(t){ t.status=="doing" }` → `accepts: [:doing]`.
+- `task_policy.rb`: delete `mark_lost?`, `block_task?`, `archive_task?` and their
+  `deny_*` toggles; fold the "denied" test path into `kanban_move?` (context-aware) or
+  a `deny_kanban_move` toggle.
+
+**Tests**
+- `column_test.rb`: `enter_interaction_key` now `:lost_enter_interaction`; add an
+  `accepts:` Proc deprecation test (raise-in-test + warn-map-in-prod) mirroring `on_drop`.
+- `kanban_drop_interaction_test.rb`: the denied-drop cases assert via `kanban_move?`
+  (no more per-interaction policy method).
+- `kanban_move_test.rb` / dom-contract: drop `accepts:` Proc assertions; assert
+  `[:doing]` topology + `data-kanban-accepts` hint instead.
+
+**Docs / skill**
+- `docs/reference/kanban/{dsl,authorization}.md`, `docs/guides/kanban.md`,
+  `.claude/skills/plutonium-kanban/SKILL.md`: remove `accepts:` Proc; document
+  `from`/`to` context on `kanban_move?`; state enter_interaction has no policy method.
+
+## Open questions
+
+1. **Context key names — RESOLVED: declared optional targets.** ActionPolicy
+   *strips* undeclared context keys (verified: a per-call `context: {kanban_to:}`
+   comes back nil unless declared). So `authorize :kanban_from, optional: true` /
+   `authorize :kanban_to, optional: true` on the base `Resource::Policy` — same
+   shape as `parent` (nil for every non-move authorization), with clean readers
+   (`kanban_to&.key`). Pure per-call context is not possible.
+2. **`accepts: false` vs `locked:`** — both now purely structural. Keep both
+   (entry-refuse vs exit-refuse), they're not redundant.
+3. **`accepts:` Proc removal — DECIDED: hard-remove, raise, no bridge.** Delete the
+   Proc branch + `accepts_record?`; constructor raises `ArgumentError` on a `Proc`
+   value so broken definitions fail loud rather than silently going permissive.

data/gemfiles/rails_8.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.60.4)
+    plutonium (0.61.0)
       action_policy (~> 0.7.0)
       csv
       listen (~> 3.8)

data/lib/generators/pu/gem/active_shrine/active_shrine_generator.rb

@@ -18,6 +18,11 @@ module Pu
 
       def start
         bundle "active_shrine"
+        # The generated shrine.rb determine_mime_type analyzer refines
+        # marcel's `text/plain` (e.g. CSV/TXT uploads) via Shrine's :mime_types
+        # analyzer, which does `require "mime/types"` — bundle it so the first
+        # text/plain upload doesn't 500 with `cannot load such file -- mime/types`.
+        bundle "mime-types"
         bundle "aws-sdk-s3" if options[:s3]
         bundle "fastimage" if options[:store_dimensions]
 

data/lib/plutonium/action/base.rb

@@ -23,6 +23,7 @@ module Plutonium
         @collection_record_action = options[:collection_record_action] || false
         @record_action = options[:record_action] || false
         @resource_action = options[:resource_action] || false
+        @kanban_drop = options[:kanban_drop] || false
         @category = ActiveSupport::StringInquirer.new((options[:category] || :secondary).to_s)
         @position = options[:position] || 50
         @modal_mode = options[:modal]
@@ -68,6 +69,12 @@ module Plutonium
       def record_action? = @record_action
       def resource_action? = @resource_action
 
+      # True when this action was auto-registered for a kanban column's
+      # `enter_interaction`. Such actions exist only so their policy method,
+      # form, and params machinery are wired up — they are reachable by
+      # dropping a card, never rendered as a normal toolbar/row button.
+      def kanban_drop? = @kanban_drop
+
       def permitted_by?(policy)
         policy.allowed_to?(:"#{name}?")
       end
@@ -112,6 +119,7 @@ module Plutonium
           collection_record_action: @collection_record_action,
           record_action: @record_action,
           resource_action: @resource_action,
+          kanban_drop: @kanban_drop,
           category: @category.to_sym,
           position: @position,
           modal: @modal_mode,

data/lib/plutonium/configuration.rb

@@ -40,6 +40,18 @@ module Plutonium
     #   or proxy the service.
     attr_accessor :navii_host_url
 
+    # @return [String, false, nil] the currency unit (symbol) used when rendering
+    #   a currency value that has no unit configured on `has_cents` or the display.
+    #   `nil` (default) falls back to the i18n `number.currency.format.unit` when
+    #   the locale defines it, otherwise no symbol. Set a literal like `"£"` to
+    #   change the default, or `false` (or `""`) for no symbol application-wide.
+    attr_accessor :default_currency_unit
+
+    # @return [String, nil] the default country (ISO2 code, e.g. "gh") for phone
+    #   (`as: :phone`) inputs that don't set their own `initial_country:`. `nil`
+    #   (default) leaves it to the intl-tel-input library (no country preselected).
+    attr_accessor :default_phone_country
+
     # Map of version numbers to their default configurations
     VERSION_DEFAULTS = {
       1.0 => proc do |config|

data/lib/plutonium/definition/index_views.rb

@@ -132,6 +132,22 @@ module Plutonium
                 confirmation: col_action.confirmation
               )
             end
+
+            # Register each column's enter_interaction as an interactive record
+            # action too, so its form and params extraction exist and route the
+            # standard way. It is flagged `kanban_drop: true` so it is excluded
+            # from the normal show/row/index toolbars — it is reachable only by
+            # dropping a card. The key is column-scoped (enter_interaction_key →
+            # :<column>_enter_interaction), so it is unique by construction and
+            # never collides with another column's interaction. It carries NO
+            # policy method of its own — the drop is authorized by kanban_move?.
+            if col.enter_interaction?
+              action(
+                col.enter_interaction_key,
+                interaction: col.enter_interaction,
+                kanban_drop: true
+              )
+            end
           end
         end
       end

data/lib/plutonium/kanban/column.rb

@@ -5,27 +5,80 @@ module Plutonium
     class Column
       ROLE_PRESETS = {
         backlog: {add: true},
-        done: {color: :green, collapsed: true}
+        # Terminal columns: collapsed by default, colour signals the outcome.
+        # :done is the positive close (green); :lost is the negative close
+        # (red) — the natural pair for won/lost pipelines (leads, deals, tickets).
+        done: {color: :green, collapsed: true},
+        lost: {color: :red, collapsed: true}
       }.freeze
 
-      attr_reader :key, :label, :color, :wip, :scope, :on_drop, :accepts, :actions
+      attr_reader :key, :label, :color, :wip, :scope, :on_enter, :on_exit, :accepts, :actions, :enter_interaction
+
+      def initialize(key, label: nil, color: nil, wip: nil, scope: nil, on_enter: nil, on_exit: nil, on_drop: nil,
+        collapsed: nil, add: nil, accepts: nil, locked: nil, role: nil, enter_interaction: nil, drop_interaction: nil)
+        # on_drop:/drop_interaction: were renamed to on_enter:/enter_interaction:.
+        # Resolve the deprecated aliases first (dev/test raise; deployed envs warn
+        # and map — see resolve_renamed_option) so the rest of initialize only
+        # ever sees the new names.
+        on_enter = resolve_renamed_option(:on_drop, on_drop, :on_enter, on_enter)
+        enter_interaction = resolve_renamed_option(:drop_interaction, drop_interaction, :enter_interaction, enter_interaction)
 
-      def initialize(key, label: nil, color: nil, wip: nil, scope: nil, on_drop: nil,
-        collapsed: nil, add: nil, accepts: nil, locked: nil, role: nil)
         preset = role ? ROLE_PRESETS.fetch(role) { raise ArgumentError, "Unknown column role: #{role.inspect}. Valid: #{ROLE_PRESETS.keys.inspect}" } : {}
+        if enter_interaction && !(enter_interaction.is_a?(Class) && enter_interaction < Plutonium::Resource::Interaction)
+          raise ArgumentError, "enter_interaction: must be a Plutonium::Resource::Interaction subclass, got #{enter_interaction.inspect}"
+        end
+        # An enter_interaction acts on the SINGLE dropped card — the move handler
+        # binds it as `resource:`. It must therefore be record-shaped (declare a
+        # `resource` attribute), never collection/bulk-shaped (`resources`). Reject
+        # anything else at definition time so a mis-shaped interaction can't (a) blow
+        # up at drop time on the `resource=` assignment, or (b) get auto-classified
+        # by Action::Interactive::Factory as a bulk action and leak into the
+        # bulk-actions bar (which does not filter kanban_drop actions).
+        if enter_interaction && !enter_interaction.attribute_names.map(&:to_sym).include?(:resource)
+          raise ArgumentError, "enter_interaction: #{enter_interaction} must operate on a single record (declare `attribute :resource`); collection/bulk interactions cannot be used as an enter_interaction."
+        end
+        # accepts: is purely structural (topology + client drop hints): true/false
+        # or an Array of source keys. The Proc form was removed — record/user
+        # conditions belong in the kanban_move? policy, which sees the record and
+        # the from/to columns. Fail loud rather than silently treating a stale Proc
+        # as permissive (which would OPEN UP a column that used to restrict drops).
+        if accepts.is_a?(Proc)
+          raise ArgumentError, "kanban column `accepts:` no longer accepts a Proc; use true/false or an Array of source keys, and put record/user conditions in the kanban_move? policy."
+        end
         @key = key.to_sym
         @label = label || key.to_s.titleize
         @color = color.nil? ? preset[:color] : color
         @wip = wip
         @scope = scope
-        @on_drop = on_drop
+        @on_enter = on_enter
+        @on_exit = on_exit
         @collapsed = collapsed.nil? ? preset[:collapsed] : collapsed
         @add = add.nil? ? preset[:add] : add
         @accepts = accepts.nil? || accepts
         @locked = locked || false
+        @enter_interaction = enter_interaction
         @actions = []
       end
 
+      # A column may run an input-collecting Interaction when a card ENTERS it
+      # (e.g. "mark lead as lost with a reason"). When set, the drop opens the
+      # interaction's form as a modal before the move is committed.
+      def enter_interaction? = !!@enter_interaction
+
+      # Internal action-registration key for the enter interaction, scoped to the
+      # column: :blocked → :blocked_enter_interaction. Nil when unset.
+      #
+      # Column-scoped (not class-name-derived) so it is unique by construction — a
+      # column has at most one enter_interaction, so two columns can never collide
+      # even if they reuse the same interaction class. This key is ONLY an internal
+      # form/param routing handle; it is NOT an authorization name. The move (and
+      # therefore the interaction) is authorized solely by kanban_move? — the
+      # interaction has no policy method of its own.
+      def enter_interaction_key
+        return nil unless @enter_interaction
+        :"#{key}_enter_interaction"
+      end
+
       def action(key, interaction:, on: :all, label: nil, icon: nil, confirmation: nil)
         @actions << Action.new(key: key.to_sym, interaction:, on:, label:, icon:, confirmation:)
       end
@@ -34,35 +87,35 @@ module Plutonium
       def add? = !!@add
       def locked? = @locked
 
-      # Column-level accepts check — used for client-side drop hints and as the
-      # first gate in the move handler (before the record is needed).
-      # Proc accepts: is treated as permissive at the column level; call
-      # accepts_record? with the actual record to evaluate the predicate.
+      # Whether a card from `source_key` may be dropped into this column. Purely
+      # structural — @accepts is normalized to true/false or an Array of source
+      # keys (the constructor rejects a Proc). Drives both the server-side gate in
+      # the move handler and the client-side drop hint (data-kanban-accepts).
       def accepts?(source_key)
         case @accepts
         when Array then @accepts.include?(source_key)
-        when true, false then @accepts
-        # Proc/predicate case: permit at the column level here; the move handler
-        # evaluates the predicate per-card via accepts_record? with the actual record.
-        else true
+        else @accepts # true or false
         end
       end
 
-      # Per-card accepts check — evaluates a Proc accepts: against the actual
-      # record.  Called by the move handler after the record is loaded.
-      #
-      # Convention for Proc accepts:
-      #   accepts: ->(card) { … }   # receives the record, returns true/false
-      #
-      # For non-Proc values the behaviour matches accepts?(source_key) exactly,
-      # so the move handler can unconditionally switch to accepts_record?.
-      def accepts_record?(record, source_key)
-        case @accepts
-        when Array then @accepts.include?(source_key)
-        when true, false then @accepts
-        when Proc then @accepts.call(record)
-        else true
+      private
+
+      # Bridge a renamed column option. `on_drop:`/`drop_interaction:` became
+      # `on_enter:`/`enter_interaction:`. To avoid breaking live deployments on
+      # upgrade we DON'T hard-fail in deployed envs — we log a deprecation and map
+      # the old value onto the new name. But local envs (development/test) raise,
+      # so the rename is caught during development and can't silently ship. If
+      # both the old and new names are given, the new one wins.
+      def resolve_renamed_option(old_name, old_value, new_name, new_value)
+        return new_value if old_value.nil?
+
+        if Rails.env.local?
+          raise ArgumentError,
+            "kanban column `#{old_name}:` has been renamed to `#{new_name}:` — update your definition."
         end
+
+        Rails.logger.warn { "[plutonium] kanban column `#{old_name}:` is deprecated; rename it to `#{new_name}:`." }
+        new_value.nil? ? old_value : new_value
       end
     end
   end

data/lib/plutonium/models/has_cents.rb

@@ -76,6 +76,24 @@ module Plutonium
         class_attribute :has_cents_attributes, instance_writer: false, default: {}
       end
 
+      # Resolves the currency unit (symbol) configured for a has_cents decimal
+      # accessor, e.g. :price for `has_cents :price_cents, unit: "£"`.
+      #
+      # @param decimal_attribute [Symbol, String] The decimal accessor name.
+      # @return [String, nil] The unit — a String verbatim, the value of the
+      #   method named by a Symbol unit (per-row currencies), or nil when the
+      #   attribute has no unit configured / is not a has_cents accessor.
+      def has_cents_unit_for(decimal_attribute)
+        decimal_attribute = decimal_attribute.to_sym
+        config = self.class.has_cents_attributes.values.find { |opts| opts[:name] == decimal_attribute }
+        return unless config
+
+        case (unit = config[:unit])
+        when Symbol then public_send(unit)
+        else unit
+        end
+      end
+
       module ClassMethods
         # # Inherit validations from cents attribute to decimal attribute
         # def validate(*args, &block)
@@ -109,10 +127,20 @@ module Plutonium
         #   - rate: 1000 for dollars/mils (1 dollar = 1000 mils)
         #   - rate: 1 for a whole number representation
         # @param suffix [String] The suffix to append to the cents_name if name is not provided (default: "amount").
+        # @param unit [String, Symbol, nil] The currency unit used when the value is rendered as currency.
+        #   A String is used verbatim as the symbol ("£"); a Symbol names a method read off the record for
+        #   per-row currencies (`unit: :currency_symbol`); nil (default) renders with no symbol. Consumers
+        #   (the Currency display component, grid/kanban cards) read this via {#has_cents_unit_for}.
         #
         # @example Standard currency (dollars and cents)
         #   has_cents :price_cents
         #
+        # @example Static currency symbol
+        #   has_cents :price_cents, unit: "£"
+        #
+        # @example Per-row currency symbol read off the record
+        #   has_cents :price_cents, unit: :currency_symbol
+        #
         # @example Custom rate for a different currency division
         #   has_cents :amount_cents, name: :cost, rate: 1000
         #
@@ -121,14 +149,14 @@ module Plutonium
         #
         # @example Using custom suffix
         #   has_cents :total_cents, suffix: "value"
-        def has_cents(cents_name, name: nil, rate: 100, suffix: "amount")
+        def has_cents(cents_name, name: nil, rate: 100, suffix: "amount", unit: nil)
           cents_name = cents_name.to_sym
           name ||= cents_name.to_s.gsub(/_cents$/, "")
           name = name.to_sym
           name = (name == cents_name) ? :"#{cents_name}_#{suffix}" : name
 
           self.has_cents_attributes = has_cents_attributes.merge(
-            cents_name => {name: name, rate: rate}
+            cents_name => {name: name, rate: rate, unit: unit}
           )
 
           class_eval <<-RUBY, __FILE__, __LINE__ + 1

data/lib/plutonium/resource/controller.rb

@@ -163,13 +163,34 @@ module Plutonium
             extraction_record.respond_to?("#{k}=") &&
               extraction_record.class.reflect_on_association(k.to_sym).nil?
           }
-          extraction_record.assign_attributes(submitted.slice(*(base_keys | extra_keys)))
+          # Never assign attachment/file inputs to the throwaway extraction_record:
+          # the submitted value is a single-read Rack upload (UploadedFile), and a
+          # Shrine attacher consumes it to EOF on assign — so the later
+          # `resource_class.new(resource_params)` would re-read a closed stream
+          # ("IOError: closed stream"). Active Storage escaped this because its
+          # attachment reflects as an association (excluded above); Shrine's virtual
+          # `file=` accessor does not, so exclude file inputs explicitly. The value
+          # still reaches create/update via `extract_input` (which reads params, not
+          # this record), so nothing is dropped — the file is just read once, later.
+          assign_keys = (base_keys | extra_keys) - attachment_input_keys
+          extraction_record.assign_attributes(submitted.slice(*assign_keys))
           extracted = build_form(extraction_record, form_action: false)
             .extract_input(params, view_context:)[resource_param_key.to_sym].compact
           clean_structured_inputs(current_definition, extracted)
         end
       end
 
+      # Attachment/file input names (as Strings) declared on the current
+      # definition — inputs whose `as:` is a file type (`:file`/`:uppy`/
+      # `:attachment`). Excluded from the extraction-record pre-assignment so a
+      # single-read Rack upload isn't consumed before create/update reads it.
+      def attachment_input_keys
+        file_types = Plutonium::UI::Form::Base::Builder::FILE_INPUT_TYPES
+        current_definition.defined_inputs.filter_map { |name, config|
+          name.to_s if file_types.include?(config.dig(:options, :as)&.to_sym)
+        }
+      end
+
       # Returns the resource parameters, including scoped and parent parameters
       # @return [Hash] The resource parameters
       def resource_params

data/lib/plutonium/resource/controllers/crud_actions.rb

@@ -56,6 +56,7 @@ module Plutonium
               format.turbo_stream { render turbo_stream: turbo_stream.replace(helpers.turbo_scoped_dom_id("resource-form"), view_context.render(build_form(action: :new))) }
               format.html { render :new, status: :unprocessable_content }
             elsif resource_record!.save
+              after_create_persisted
               format.turbo_stream do
                 flash.notice = "#{resource_class.model_name.human} was successfully created."
                 render turbo_stream: stacked_modal_create_streams
@@ -164,6 +165,13 @@ module Plutonium
 
         private
 
+        # Hook fired once, immediately after a successful create-save and BEFORE
+        # the response is built. No-op by default. KanbanActions overrides it to
+        # apply a kanban quick-add column's on_enter + positioning to the freshly
+        # created (already-persisted) record; the reload/redirect response is built
+        # after this returns, so the board reflects the placement.
+        def after_create_persisted = nil
+
         # When the create came in through the secondary (stacked) modal
         # frame — i.e. the user clicked "+" next to an association field
         # while the parent form was already in a modal — we don't want to