ask-app-server 0.1.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 147a968eaddfd9ebce8ef4d0f04cb64c34e76a95e859a676ff79c75b270f6931
-  data.tar.gz: ce70ee81dfe2a5a0dcb4d1bd922b97d90f6aae5675c764df11bf99d1a585c7ae
+  metadata.gz: 58a83cf6f150e43e40a2e188ca05c8d196fc5225c1439f87d1797383836ce764
+  data.tar.gz: 41efacd1430104a977fbd05f334fb89f4e8477e23d12cad30f3601dca505ae86
 SHA512:
-  metadata.gz: 68a1c0af900543c31aedc96625c1df396507c44cc584267ad27e8ec9253d31029a79139537f3db0967b48ef6fee6cc33ace6ab1723b4b5741f6b436f40bdea0d
-  data.tar.gz: a4e0fa7e7a3004dbe8a7ca935254cb879d6a8125ee4e480520a28d5397653ed71fe40f896eacd3b0b98429bea3e8af88727684da590def6eb7d0d3b313aeb36d
+  metadata.gz: 250a42b9bfe5a2c4491083a643886fe41931b00c723640ddc56658b4d02880c2000c74e7cc1fce52cdf0e2bc0373ccd70fc4a6c288e2699ecbfc9c78c38402f8
+  data.tar.gz: 3d7918f44bc5cd5610faf1be139c3f23e6b739dd87b7d7fe35afe14d9c296deb877220896621dbb8f441f9741623b0178288f09f5ae1c0e8e7fb0c1b4aaf165b

data/CHANGELOG.md

@@ -1,5 +1,104 @@
 # Changelog
 
+## [0.4.0] - 2026-08-11
+
+### Added
+
+- **Herdr citizenship** — `HerdrReporter` keeps a herdr sidebar accurate
+  with first-party state when the host runs inside a herdr pane. Reads
+  `HERDR_SOCKET_PATH`/`HERDR_PANE_ID` (injected into every pane), reports
+  the aggregate pane state (`working` | `blocked` | `idle`) via
+  `pane.report_agent` on change, the ask session id via
+  `pane.report_agent_session` (for future resume), and model/session
+  tokens via `pane.report_metadata`. `HerdrReporter.attach(session_manager)`
+  returns nil outside herdr; the CLI attaches automatically.
+- **Session event observers** — `SessionManager#on_session_event` receives
+  every canonical event across all sessions as it happens; the observer
+  chain hooks the single emission point (`EventTranslator#on_event` →
+  `AgentAdapter#on_event`). Observers attach after store registration so
+  the store is settled, and the buffered `session.created` is replayed.
+
+## [0.3.0] - 2026-08-11
+
+### Added
+
+- **Unix-socket transport for multi-client attach** — `SocketServer`
+  (`ask-app-server --socket PATH` or `ASK_APP_SERVER_SOCKET`). Any number
+  of clients (terminal TUI, web console, bots) connect to the same host
+  and share sessions; each connection has its own reader thread, and
+  responses are routed back to the requesting connection. The stdio
+  transport runs alongside.
+- **Per-connection event delivery cursors** — the host no longer drains a
+  shared buffer. Each `Connection` tracks the last delivered seq per
+  subscribed session; `session/subscribe` with `afterSeq` replays exactly
+  what the client hasn't seen, and each client receives each event
+  exactly once (dedup by seq). `session/event` notifications fan out to
+  every subscribed connection.
+- **Host-side contract enforcement** — incoming requests on the canonical
+  surface are validated against `Ask::SessionProtocol::Methods` before
+  dispatch (invalid params → `-32602 invalid_params`). Params are
+  normalized to string keys so Ruby clients may send symbols.
+- **`Connection` class** — per-client I/O plus subscription cursors;
+  `EventTranslator` retains a capped event log (2000) for replay/polling.
+
+### Changed
+
+- `Server` is now the transport-agnostic protocol engine: `dispatch(msg,
+  connection)` processes one message and writes responses back to the
+  sending connection; `push_pending` delivers events to subscribed
+  connections. `Server#start` is the stdio transport (one connection).
+- `session/subscribe` now registers the *connection's* cursor (replay
+  default) instead of a global store flag.
+
+### Removed
+
+- `SessionManager#pending_notifications` (superseded by cursor-based
+  delivery).
+
+## [0.2.0] - 2026-08-11
+
+### Changed
+
+- **The host now speaks the canonical Ask::SessionProtocol** (ask-session-protocol
+  gem). The event vocabulary is the canonical contract — `turn.started`,
+  `model.streaming`, `model.thinking`, `tool.use/delta/result`,
+  `approval.required/updated`, `plan.proposed/approved/rejected`,
+  `todos.updated`, `session.created/ended`, `turn.completed/failed/aborted`,
+  `error` — in the validated `{type, seq, payload}` envelope with string-keyed
+  payloads. The old app-server vocabulary (`tool.updated`, `message.upserted`,
+  symbol-keyed payloads) is gone; `initialize` negotiates
+  `Ask::SessionProtocol::PROTOCOL_VERSION` and advertises capabilities.
+- **Approvals are canonical resolvable interactions.** The blocking
+  PermissionHandler flow is replaced by the ask-agent approval queue: gated
+  tools pause the turn, `approval.required` streams to every client, and any
+  client resolves by id via `interaction/approve`/`interaction/reject` (or
+  approve/reject-all). `interaction/list` reports pending approvals.
+- **Steer-based mid-execution injection.** `session/send` returns
+  `{accepted, status, turnId}` with `steered | queued | stale` semantics:
+  idle sessions run the prompt, running sessions queue it for the next turn
+  boundary (no abort), and `expectedTurnId` guards staleness. Queued steers
+  drain automatically when the running turn completes.
+- **New methods** — `session/close`, `interaction/list|approve|reject|
+  approve-all|reject-all`, `plan/approve|reject`. `interaction/respond`
+  returns `-32009 not_implemented` until elicitation exists in the runtime.
+- `workspace/readState` returns the canonical `{workspace: {path, name,
+  gitBranch, mode}}` shape (legacy `settings` retained for compatibility).
+- `session/subscribe` returns `{subscription: {sessionId, deliveryKind}}`
+  and can include a replay snapshot.
+
+### Added
+
+- `session.created` / `session.ended` lifecycle events, emitted on session
+  start and close.
+- Approval modes: `mode: "plan"` enables plan mode (read-only until
+  `plan/approve`); `"auto"` admits an inspectable queue that never blocks.
+
+### Removed
+
+- `Server#register_permission_handler` and the SessionManager permission
+  handler wiring (the PermissionHandler class remains for direct use).
+- `AgentAdapter#inject_message` (replaced by steer semantics).
+
 ## [0.1.0] - 2026-07-23
 
 ### Added

data/README.md

@@ -2,21 +2,22 @@
 
 [![Gem Version](https://badge.fury.io/rb/ask-app-server.svg)](https://badge.fury.io/rb/ask-app-server)
 
-**JSON-RPC/stdio app-server for ask-rb agents.** Exposes `Ask::Agent::Session`
-behind the standard app-server protocol: a vendor-neutral interface for
-driving an agent as a service, with sessions, streamed events, approvals, and
-turn lifecycle. Any client that implements the protocol can drive your agent,
-and the client never needs to know it's talking to Ruby. The same protocol is
-what several coding agents use behind their own app-servers (OpenAI's Codex
-app-server is one well-known implementation); ask-app-server isn't an
-extension of any of them — it simply speaks the standard.
+**JSON-RPC/stdio session host for ask-rb agents.** Exposes `Ask::Agent::Session`
+behind the canonical [ask-session-protocol](https://github.com/ask-rb/ask-session-protocol)
+wire contract: one versioned interface for driving an agent as a service,
+with sessions, streamed canonical events, resolvable interactions
+(approvals, plans), and turn lifecycle. Any client that speaks the protocol
+can drive your agent, and the client never needs to know it's talking to
+Ruby. The method surface is app-server compatible — the same shape Codex
+and ZCode expose — while the event vocabulary and interaction model are the
+ask ecosystem's own canonical contract.
 
 ## What is this?
 
-`ask-app-server` turns an ask-rb agent into a **programmable service** that speaks JSON-RPC over stdio. Any client that can speak the app-server protocol can drive your agent:
+`ask-app-server` turns an ask-rb agent into a **programmable service** that speaks JSON-RPC over stdio. Any client that speaks the canonical session protocol can drive your agent:
 
-- **IDE extensions and editors** — stream model deltas and tool events into an editor surface over stdio or a socket, the same way agent–editor integrations work today
-- **Custom chat UIs and desktop apps** — stream model deltas and tool events into your own interface
+- **IDE extensions and editors** — stream model deltas, tool events, and approvals into an editor surface over stdio or a socket
+- **Custom chat UIs and desktop apps** — stream canonical events into your own interface
 - **Bots and assistants** — drive sessions programmatically from any runtime that can spawn a subprocess
 - **Headless automation** — CI/CD pipelines, batch processing, scriptable agent tasks
 
@@ -37,8 +38,30 @@ gem "ask-app-server"
 ```bash
 # Start the server (reads JSON-RPC from stdin, writes to stdout)
 ask-app-server
+
+# Or expose a unix socket for multi-client attach (runs alongside stdio):
+ask-app-server --socket ~/.ask-app-server/app-server.sock
 ```
 
+Running inside a [herdr](https://herdr.dev) pane? Nothing to configure:
+herdr injects `HERDR_SOCKET_PATH`/`HERDR_PANE_ID` into the pane, the host
+detects them, and keeps the herdr sidebar accurate with first-party state —
+`working` while a turn runs, `blocked` while an approval is pending,
+`idle` otherwise — plus the session id (for future resume) and model
+tokens. No screen scraping needed; the host knows its own state.
+
+Clients connect to the socket and speak the same protocol as NDJSON lines
+(`ASK_APP_SERVER_SOCKET` env var works too):
+
+```bash
+nc -U ~/.ask-app-server/app-server.sock
+{"id":1, "method":"initialize", "params":{}}
+```
+
+Any number of clients can attach to the same sessions: each connection
+tracks its own event-delivery cursor, so `session/subscribe` replays what
+that client hasn't seen and every client receives each event exactly once.
+
 From another process, send JSON-RPC requests:
 
 ```json
@@ -52,27 +75,41 @@ From another process, send JSON-RPC requests:
 
 | Method | Description |
 |---|---|
-| `initialize` | Handshake, returns server capabilities |
+| `initialize` | Handshake; negotiates `protocolVersion` and capabilities |
 | `session/create` | Create a new agent session |
 | `session/list` | List active sessions |
 | `session/resume` | Resume an existing session |
-| `session/subscribe` | Subscribe to streaming events |
-| `session/send` | Send a message to a session |
+| `session/subscribe` | Subscribe to the event stream (with replay snapshot) |
+| `session/send` | Prompt an idle session or inject mid-run (`steered`/`queued`/`stale`) |
 | `session/events` | Poll for events after a sequence number |
 | `session/abort` | Abort the current turn |
-| `workspace/readState` | Read model and workspace settings |
+| `session/close` | Close the session |
+| `session/artifacts` · `session/artifact/get` | List and fetch tool artifacts |
+| `interaction/list` | List pending approval interactions |
+| `interaction/approve` · `interaction/reject` | Resolve an approval by id |
+| `interaction/approve-all` · `interaction/reject-all` | Resolve all approvals |
+| `interaction/respond` | Answer user-input elicitation (not yet implemented) |
+| `plan/approve` · `plan/reject` | Approve/reject the pending plan proposal |
+| `workspace/readState` | Read workspace and approval-mode state |
 
 ### Events (server → client notifications)
 
+Every event is a canonical `{type, seq, payload}` envelope, delivered as a
+`session/event` notification on subscribed sessions:
+
 | Event | When |
 |---|---|
-| `turn.started` | A new turn begins processing |
-| `model.streaming` | Text delta from the model |
-| `tool.updated` | Tool execution started/updated/completed/failed |
-| `turn.completed` | Turn finished successfully |
-| `turn.failed` | Turn ended with an error |
-
-Event payloads are delivered as `session/event` notifications on subscribed sessions. The server also sends `interaction/requestPermission` when a blocked tool needs approval and `interaction/requestUserInput` when it needs input from the user.
+| `session.created` · `session.ended` | Session lifecycle |
+| `turn.started` · `turn.completed` · `turn.failed` · `turn.aborted` | Turn lifecycle |
+| `model.streaming` · `model.thinking` | Model output deltas |
+| `tool.use` · `tool.delta` · `tool.result` | Tool execution |
+| `approval.required` · `approval.updated` | Resolvable approval interactions |
+| `plan.proposed` · `plan.approved` · `plan.rejected` | Plan mode |
+| `todos.updated` | Todo list changes |
+| `error` | Non-fatal errors |
+
+The full vocabulary, payload shapes, method specs, and versioning live in
+the ask-session-protocol gem (JSON Schema artifact included).
 
 ## Clients
 
@@ -95,7 +132,7 @@ Environment variables:
 |---|---|---|
 | `ASK_APP_SERVER_CONFIG` | auto-detected | Path to the config file |
 | `ASK_APP_SERVER_MODEL` | `opencode_go/deepseek-v4-flash` | Model identifier (overrides config file) |
-| `ASK_APP_SERVER_PERMISSIONS` | `on_request` | Permission mode (`on_request`, `never`) |
+| `ASK_APP_SERVER_PERMISSIONS` | `on_request` | Permission mode (`on_request`, `never`, `auto`) |
 | `DEBUG` | unset | Set to `1` for debug logging |
 
 ## Development

data/lib/ask/app_server/agent_adapter.rb

@@ -2,11 +2,14 @@
 
 module Ask
   module AppServer
-    # Wraps an Ask::Agent::Session and translates its events into the
-    # app-server protocol event format via EventTranslator.
+    # Wraps an Ask::Agent::Session and translates its events into canonical
+    # Ask::SessionProtocol events via EventTranslator.
     #
     # Each wrapper is associated with one session and maintains an
-    # EventTranslator that app-server clients poll or subscribe to.
+    # EventTranslator that clients poll or subscribe to. The adapter also
+    # owns the approval queue wiring (approval events surface as
+    # approval.required / approval.updated) and the interaction controls
+    # (approve/reject by id, plan approve/reject) that any client can call.
     class AgentAdapter
       # The underlying ask-agent session.
       attr_reader :session
@@ -23,14 +26,27 @@ module Ask
       # When the session was created.
       attr_reader :created_at
 
-      def initialize(model:, tools: nil, system_prompt: nil, agent_dir: nil, **session_opts)
+      # @param model [String] model identifier
+      # @param tools [Array<String, Class>] tool names or classes
+      # @param system_prompt [String, nil]
+      # @param agent_dir [String, nil] workspace path
+      # @param approval [Symbol] :off, :require, or :auto
+      # @param require_approval [Array<String>, nil] tool names gated behind
+      #   human approval when approval is :require
+      # @param session_opts [Hash] remaining options passed to
+      #   Ask::Agent::Session.new (hooks, plan_mode, todos, ...)
+      def initialize(model:, tools: nil, system_prompt: nil, agent_dir: nil,
+                     approval: :off, require_approval: nil, **session_opts)
         @model = model
         @system_prompt = system_prompt
         @tools = resolve_tools(tools)
         @session_opts = session_opts
+        @approval = approval
+        @require_approval = require_approval
         @agent_dir = agent_dir
         @session = nil
         @translator = nil
+        @on_event_block = nil
         @session_id = nil
         @running = false
         @running_mutex = Mutex.new
@@ -43,22 +59,12 @@ module Ask
       # Start a new ask-agent session.
       # Returns the session ID.
       def start_session
-        opts = @session_opts.dup
-
-        # Extract hooks from session opts and pass them to Session
-        hooks = opts.delete(:hooks) || {}
-
-        @session = Ask::Agent::Session.new(
-          model: @model,
-          tools: @tools,
-          system_prompt: @system_prompt,
-          agent_dir: @agent_dir,
-          hooks: hooks,
-          **opts
-        )
+        @translator = EventTranslator.new
+        @translator.on_event = @on_event_block if @on_event_block
+        @session = build_session
         @session_id = @session.id
-        @translator = EventTranslator.new(@session_id)
         @session.on_event { |event| handle_agent_event(event) }
+        @translator.session_created(@session_id)
         @session_id
       end
 
@@ -66,34 +72,45 @@ module Ask
       def resume(session)
         @session = session
         @session_id = session.id
-        @translator = EventTranslator.new(@session_id)
+        @translator = EventTranslator.new
+        @translator.on_event = @on_event_block if @on_event_block
         @session.on_event { |event| handle_agent_event(event) }
         @session_id
       end
 
-      # Send a message and start processing. Runs in a background thread.
-      # The caller should poll or subscribe to receive events.
-      def send_message(content)
-        raise "Session not started" unless @session
-        raise "Session already busy" if @running
-
-        @running_mutex.synchronize do
-          @abort_requested = false
-          @running = true
+      # Register an observer for every canonical event this session emits
+      # (translations plus approval/plan/session-lifecycle emissions).
+      # May be called before start_session; the block is applied when the
+      # translator exists so the observer sees session.created.
+      def on_event(&block)
+        if @translator
+          @translator.on_event = block
+        else
+          @on_event_block = block
         end
+      end
 
-        @run_thread = Thread.new do
-          begin
-            @session.run(content)
-          rescue => e
-            # Agent may have been aborted — that's fine
-            @logger.debug("Agent run error: #{e.message}") if ENV["DEBUG"]
-          ensure
-            @running_mutex.synchronize { @running = false }
-          end
-        end
+      # Send a message and start processing (idle session) or inject it
+      # mid-run (running session). Uses ask-agent's steer semantics:
+      #
+      #   steered — the message was added to the conversation immediately
+      #   queued  — the session is running; the message is queued for the
+      #             next turn boundary (no abort)
+      #   stale   — the caller's expected_turn_id no longer matches
+      #
+      # @param content [String]
+      # @param expected_turn_id [String, nil] staleness guard
+      # @return [Hash] { status: "steered"|"queued"|"stale", turn_id: }
+      def send_message(content, expected_turn_id: nil)
+        raise "Session not started" unless @session
 
-        true
+        if @running
+          result = @session.steer(content, expected_turn_id: expected_turn_id)
+          { status: result[:status].to_s, turn_id: result[:turn_id] }
+        else
+          start_run(content)
+          { status: "steered", turn_id: @session.turn_id }
+        end
       end
 
       # Request abort of the current turn.
@@ -117,23 +134,84 @@ module Ask
         !@running
       end
 
-      # Inject a message into a running session (mid-execution).
-      # Aborts the current turn; the message will be processed when
-      # the next turn starts.
-      # Note: ask-agent doesn't natively support mid-execution injection.
-      # We abort and queue the message for the next run.
-      def inject_message(content)
-        if @running
-          abort_turn!
-          # The caller should wait for idle, then call send_message again
-          false
-        else
-          send_message(content)
-          true
+      # ── Interactions (approvals) ───────────────────────────────────────
+
+      # Pending approval interactions, as canonical Interaction objects.
+      def pending_interactions
+        queue = @session&.approval_queue
+        return [] unless queue
+
+        queue.pending_actions.map do |action|
+          payload = { "toolName" => action.tool_name.to_s }
+          payload["args"] = action.args if action.args
+          payload["message"] = action.message if action.message
+          payload["autoApprovable"] = action.auto_approvable unless action.auto_approvable.nil?
+          Ask::SessionProtocol::Interactions.interaction(
+            id: "act_#{action.id}", kind: "approval", status: "pending", payload: payload
+          )
         end
       end
 
-      # The accumulated streaming text from the current/ last turn.
+      # Approve a pending approval interaction by canonical id ("act_N").
+      # @return [Boolean] whether an action was approved
+      def approve_interaction(interaction_id)
+        apply_interaction(interaction_id) { |queue, id| queue.approve(id) }
+      end
+
+      # Reject a pending approval interaction by canonical id ("act_N").
+      # @return [Boolean] whether an action was rejected
+      def reject_interaction(interaction_id)
+        apply_interaction(interaction_id) { |queue, id| queue.reject(id) }
+      end
+
+      # Approve every pending approval interaction.
+      # @return [Integer] number approved
+      def approve_all_interactions
+        queue = @session&.approval_queue
+        return 0 unless queue
+
+        queue.approve_all.size
+      end
+
+      # Reject every pending approval interaction.
+      # @return [Integer] number rejected
+      def reject_all_interactions
+        queue = @session&.approval_queue
+        return 0 unless queue
+
+        queue.reject_all.size
+      end
+
+      # ── Plan mode ───────────────────────────────────────────────────────
+
+      # Approve the pending plan proposal.
+      # @return [Boolean]
+      def plan_approve
+        queue = @session&.plan_queue
+        return false unless queue
+
+        queue.approve_all.any?
+      end
+
+      # Reject the pending plan proposal; the agent stays in plan mode.
+      # @return [Boolean]
+      def plan_reject
+        queue = @session&.plan_queue
+        return false unless queue
+
+        queue.reject_all.any?
+      end
+
+      # ── Lifecycle ───────────────────────────────────────────────────────
+
+      # Close the session: delete its state and emit session.ended.
+      def close!
+        @session&.delete if @session.respond_to?(:delete)
+        @translator&.session_ended(@session_id, reason: "closed")
+        true
+      end
+
+      # The accumulated streaming text from the current/last turn.
       def streaming_text
         @translator&.instance_variable_get(:@streaming_text).to_s
       end
@@ -155,15 +233,79 @@ module Ask
 
       # Events after a given sequence number.
       def events_after(after_seq)
-        pending_events.select { |e| e[:seq] > after_seq }
+        pending_events.select { |e| e.seq > after_seq }
       end
 
       private
 
+      def build_session
+        opts = @session_opts.dup
+        hooks = opts.delete(:hooks) || {}
+        approval_option = build_approval_option
+        opts[:approval] = approval_option if approval_option
+        opts[:plan_mode] = false unless opts.key?(:plan_mode)
+
+        Ask::Agent::Session.new(
+          model: @model,
+          tools: @tools,
+          system_prompt: @system_prompt,
+          agent_dir: @agent_dir,
+          hooks: hooks,
+          **opts
+        )
+      end
+
+      # Build the approval option for Ask::Agent::Session: an
+      # EmittingApprovalQueue whose events stream to the translator.
+      def build_approval_option
+        return nil if @approval == :off
+
+        queue = EmittingApprovalQueue.new(
+          on_submit: ->(action) { @translator.approval_required(action) },
+          on_status: ->(action) { @translator.approval_updated(action) }
+        )
+        return { queue: queue } if @approval == :auto
+
+        { queue: queue, require_approval: @require_approval }
+      end
+
+      def apply_interaction(interaction_id)
+        id = interaction_id.to_s[/\Aact_(\d+)\z/, 1]
+        return false unless id
+
+        queue = @session&.approval_queue
+        return false unless queue
+
+        yield(queue, id.to_i).any?
+      end
+
+      def start_run(content)
+        @running_mutex.synchronize do
+          @abort_requested = false
+          @running = true
+        end
+
+        @run_thread = Thread.new do
+          begin
+            @session.run(content, reset: false)
+            # Drain steers queued while the turn was running (mid-execution
+            # injection): each subsequent run processes one queued message.
+            while @session.queued_steers.positive?
+              @session.run("", reset: false)
+            end
+          rescue => e
+            # Agent may have been aborted — that's fine
+            @logger.debug("Agent run error: #{e.message}") if ENV["DEBUG"]
+          ensure
+            @running_mutex.synchronize { @running = false }
+          end
+        end
+
+        true
+      end
+
       def handle_agent_event(event)
-        translated = @translator.translate(event)
-        # Translated events are already stored in the translator's buffer.
-        # Nothing else to do here — clients poll or subscribe to get them.
+        @translator.translate(event)
       end
 
       def resolve_tools(tool_list)
@@ -202,5 +344,45 @@ module Ask
         ]
       end
     end
+
+    # Approval queue that emits canonical approval events through the
+    # session's EventTranslator whenever actions are submitted or change
+    # status, so clients can stream approval state in real time.
+    #
+    # The session wires its own apply/reject/submit callbacks onto the
+    # queue (see Session#build_approval); this subclass only adds
+    # observation hooks on top, using its own listeners so the session's
+    # on_submit (pending-tool registration) is never clobbered.
+    class EmittingApprovalQueue < Ask::Agent::ApprovalQueue
+      # @param on_submit [Proc, nil] called with the new {Action} after
+      #   submission (and after the auto-approval drain)
+      # @param on_status [Proc, nil] called with an {Action} whose status
+      #   changed to :approved or :rejected
+      def initialize(on_submit: nil, on_status: nil, **kwargs)
+        @on_action_submitted = on_submit
+        @on_status = on_status
+        super(**kwargs)
+      end
+
+      def submit(tool_call_id:, tool_name:, args: {}, auto_approvable: false, message: nil)
+        id = super
+        @on_action_submitted&.call(self[id])
+        id
+      end
+
+      private
+
+      def apply(action)
+        result = super
+        @on_status&.call(action.with(status: :approved))
+        result
+      end
+
+      def reject_action(action)
+        result = super
+        @on_status&.call(action.with(status: :rejected))
+        result
+      end
+    end
   end
 end