kward 0.74.0 → 0.75.0

data/lib/kward/agent.rb

@@ -4,9 +4,13 @@ require_relative "compactor"
 require_relative "model/context_overflow"
 require_relative "conversation"
 require_relative "events"
+require_relative "deep_copy"
+require_relative "hooks"
+require_relative "message_access"
 require_relative "steering"
 require_relative "telemetry/logger"
 require_relative "tools/registry"
+require_relative "tools/tool_call"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -24,11 +28,13 @@ module Kward
   # lowest layer that owns the behavior, and use `Agent` only for cross-step turn
   # coordination.
   class Agent
-    def initialize(client:, tool_registry: ToolRegistry.new, conversation: Conversation.new, telemetry_logger: TelemetryLogger.new)
+    def initialize(client:, tool_registry: ToolRegistry.new, conversation: Conversation.new, telemetry_logger: TelemetryLogger.new, hook_manager: nil, hook_context: nil)
       @client = client
       @tool_registry = tool_registry
       @conversation = conversation
       @telemetry_logger = telemetry_logger
+      @hook_manager = hook_manager
+      @hook_context = hook_context
     end
 
     attr_reader :conversation, :tool_registry
@@ -39,15 +45,24 @@ module Kward
     # @param display_input [String, nil] alternate text kept for transcripts
     # @yieldparam event [Object] streamed turn event for frontends
     # @return [String] final assistant answer
-    def ask(input, display_input: nil, on_reasoning_delta: nil, on_retry: nil, cancellation: nil, steering: nil, &block)
+    def ask(input, display_input: nil, on_reasoning_delta: nil, on_retry: nil, cancellation: nil, steering: nil, options: {}, tool_registry: nil, &block)
       started_at = @telemetry_logger.monotonic_now
       status = "completed"
       error = nil
       cancellation&.raise_if_cancelled!
+      turn_start = run_hook("turn_start", payload: { input: input, display_input: display_input })
+      return hook_denied_answer(turn_start) if turn_start.denied?
+
+      input = turn_start.payload[:input] || turn_start.payload["input"] || input
+      display_input = turn_start.payload[:display_input] || turn_start.payload["display_input"] || display_input
       @conversation.refresh_system_message_if_workspace_agents_changed!
       @conversation.append_user(input, display_content: display_input)
+      run_hook("turn_context_build_before", payload: { message_count: @conversation.messages.length })
       auto_compact_if_needed
-      run_turn(on_reasoning_delta: on_reasoning_delta, on_retry: on_retry, cancellation: cancellation, steering: steering, &block)
+      run_hook("turn_context_build_after", payload: { message_count: @conversation.messages.length })
+      answer = run_turn(on_reasoning_delta: on_reasoning_delta, on_retry: on_retry, cancellation: cancellation, steering: steering, options: options, tool_registry: tool_registry, &block)
+      run_hook("turn_end", payload: { input: input, answer: answer })
+      answer
     rescue StandardError => e
       status = "failed"
       error = e
@@ -61,7 +76,7 @@ module Kward
     #
     # @yieldparam event [Object] streamed turn event for frontends
     # @return [String] final assistant answer
-    def run_turn(on_reasoning_delta: nil, on_retry: nil, cancellation: nil, steering: nil)
+    def run_turn(on_reasoning_delta: nil, on_retry: nil, cancellation: nil, steering: nil, options: {}, tool_registry: nil)
       overflow_retried = false
       steering_state = build_steering_state(steering) do |event|
         yield event if block_given?
@@ -69,7 +84,7 @@ module Kward
       loop do
         cancellation&.raise_if_cancelled!
         begin
-          message = chat(on_reasoning_delta: on_reasoning_delta, on_retry: on_retry, cancellation: cancellation, steering: steering) do |event|
+          message = chat(on_reasoning_delta: on_reasoning_delta, on_retry: on_retry, cancellation: cancellation, steering: steering, options: options, tool_registry: tool_registry) do |event|
             yield event if block_given?
           end
         rescue StandardError => e
@@ -85,11 +100,11 @@ module Kward
         steered_after_message = append_steering_events(steering_state)
         yield Events::SteeringApplied.new(count: steered_after_message) if block_given? && steered_after_message.positive?
 
-        tool_calls = message["tool_calls"] || message[:tool_calls] || []
+        tool_calls = MessageAccess.tool_calls(message)
         if tool_calls.empty?
           next if steered_after_message.positive?
 
-          answer = safe_answer(message.fetch("content", message[:content] || ""))
+          answer = safe_answer(MessageAccess.content(message).to_s)
           yield Events::Answer.new(content: answer) if block_given?
           return answer
         end
@@ -102,7 +117,7 @@ module Kward
           status = "completed"
           error = nil
           begin
-            content = @tool_registry.dispatch(tool_call, @conversation, cancellation: cancellation)
+            content = (tool_registry || @tool_registry).dispatch(tool_call, @conversation, cancellation: cancellation)
           rescue StandardError => e
             status = "failed"
             error = e
@@ -111,7 +126,11 @@ module Kward
             log_tool(tool_call, content: content, duration_ms: @telemetry_logger.duration_ms(tool_started_at), status: status, error: error)
           end
           cancellation&.raise_if_cancelled!
-          yield Events::ToolResult.new(tool_call: tool_call, content: content) if block_given?
+          if block_given?
+            elapsed_ms = @telemetry_logger.duration_ms(tool_started_at)
+            yield Events::ToolUpdate.new(tool_call: tool_call, content: content, elapsed_ms: elapsed_ms)
+            yield Events::ToolResult.new(tool_call: tool_call, content: content)
+          end
         end
         steered_after_tools = append_steering_events(steering_state)
         yield Events::SteeringApplied.new(count: steered_after_tools) if block_given? && steered_after_tools.positive?
@@ -154,7 +173,7 @@ module Kward
 
     def log_tool(tool_call, content:, duration_ms:, status:, error:)
       payload = {
-        "tool_name" => tool_name(tool_call),
+        "tool_name" => ToolCall.name(tool_call),
         "duration_ms" => duration_ms,
         "status" => status,
         "result_bytes" => content.to_s.bytesize
@@ -170,11 +189,6 @@ module Kward
       @telemetry_logger.log("errors", event, payload.merge(TelemetryLogger.error_payload(error)))
     end
 
-    def tool_name(tool_call)
-      function = tool_call["function"] || tool_call[:function] || {}
-      function["name"] || function[:name]
-    end
-
     def auto_compact_if_needed
       context_window = @client.current_context_window if @client.respond_to?(:current_context_window)
       Compactor.new(conversation: @conversation, client: @client).auto_compact_if_needed(context_window: context_window)
@@ -195,7 +209,7 @@ module Kward
       nil
     end
 
-    def chat(on_reasoning_delta: nil, on_retry: nil, cancellation: nil, steering: nil)
+    def chat(on_reasoning_delta: nil, on_retry: nil, cancellation: nil, steering: nil, options: {}, tool_registry: nil)
       reasoning_delta = lambda do |delta|
         cancellation&.raise_if_cancelled!
         on_reasoning_delta&.call(delta)
@@ -211,21 +225,37 @@ module Kward
         on_retry&.call(event)
         yield event if block_given?
       end
-      ChatInvocation.call(
+      registry = tool_registry || @tool_registry
+      request = {
+        messages: @conversation.context_messages,
+        tools: registry.schemas,
+        provider: options[:provider] || @conversation.provider,
+        model: options[:model] || @conversation.model,
+        reasoning: options[:reasoning] || @conversation.reasoning_effort
+      }
+      before = run_hook("model_request_before", payload: request)
+      request = DeepCopy.merge(request, before.payload) if before.decision.modify?
+      return { "role" => "assistant", "content" => hook_denied_answer(before) } if before.denied?
+
+      run_hook("turn_model_request_before", payload: request)
+      response = ChatInvocation.call(
         @client,
-        @conversation.context_messages,
+        request[:messages] || request["messages"],
         {
-          tools: @tool_registry.schemas,
+          tools: request[:tools] || request["tools"],
           on_reasoning_delta: reasoning_delta,
           on_assistant_delta: assistant_delta,
           on_retry: retry_callback,
           cancellation: cancellation,
           steering: steering,
-          provider: @conversation.provider,
-          model: @conversation.model,
-          reasoning: @conversation.reasoning_effort
+          provider: request[:provider] || request["provider"],
+          model: request[:model] || request["model"],
+          reasoning: request[:reasoning] || request["reasoning"]
         }
       )
+      run_hook("model_response_after_parse", payload: { message: response })
+      run_hook("turn_model_response_complete", payload: { message: response })
+      response
     end
 
     def update_conversation_runtime(message)
@@ -248,6 +278,26 @@ module Kward
       "I have not changed any files. I need to use write_file or edit_file successfully before claiming a file change."
     end
 
+    def run_hook(name, payload: {})
+      return Hooks::Manager::Result.new(event: nil, decision: Hooks::Decision.allow, decisions: [], warnings: [], messages: [], payload: payload) unless @hook_manager
+
+      @hook_manager.run(Hooks::Event.new(
+        name: name,
+        session: { id: @conversation.respond_to?(:session_id) ? @conversation.session_id : nil },
+        workspace: { root: @conversation.respond_to?(:workspace_root) ? @conversation.workspace_root : nil },
+        agent: {
+          provider: @conversation.provider,
+          model: @conversation.model,
+          reasoning: @conversation.reasoning_effort
+        },
+        payload: payload
+      ), context: @hook_context)
+    end
+
+    def hook_denied_answer(result)
+      "Declined: #{result.decision.message || "lifecycle hook denied the operation"}"
+    end
+
     def claims_file_edit?(text)
       text.match?(/\b(?:I|I've|I have)\s+(?:changed|updated|modified|edited|created|deleted|wrote)\s+(?:the\s+)?(?:file|files|[\w.\/-]+\.[\w-]+)\b/i)
     end

data/lib/kward/auth/anthropic_oauth.rb

@@ -1,18 +1,17 @@
 require "base64"
-require "digest"
 require "json"
-require "net/http"
-require "securerandom"
-require "socket"
 require "time"
 require "uri"
 require_relative "file"
+require_relative "oauth_helpers"
 require_relative "../config_files"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # OAuth helper for Anthropic Claude Pro/Max subscription credentials.
   class AnthropicOAuth
+    include OAuthHelpers
+
     AUTHORIZE_URL = "https://claude.ai/oauth/authorize"
     TOKEN_URL = URI("https://platform.claude.com/v1/oauth/token")
     DEFAULT_PORT = 53_692
@@ -189,49 +188,8 @@ module Kward
       DEFAULT_CLIENT_ID
     end
 
-    def generate_pkce
-      verifier = random_urlsafe(64)
-      challenge = Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false)
-      { verifier: verifier, challenge: challenge }
-    end
-
-    def random_urlsafe(bytes)
-      Base64.urlsafe_encode64(SecureRandom.random_bytes(bytes), padding: false)
-    end
-
     def start_callback_server
-      TCPServer.new("localhost", Integer(ENV.fetch("KWARD_ANTHROPIC_OAUTH_PORT", DEFAULT_PORT)))
-    rescue Errno::EADDRINUSE
-      TCPServer.new("localhost", 0)
-    end
-
-    def wait_for_callback(server, expected_state:, timeout_seconds:)
-      ready = IO.select([server], nil, nil, timeout_seconds)
-      return nil unless ready
-
-      socket = server.accept
-      request_line = socket.gets.to_s
-      path = request_line.split[1].to_s
-      params = URI.decode_www_form(URI.parse(path).query.to_s).to_h
-
-      code = nil
-      status = "200 OK"
-      body = "Login complete. You can close this window."
-      if params["error"]
-        body = "Login failed. Return to the terminal."
-      elsif params["state"].to_s != expected_state.to_s
-        status = "400 Bad Request"
-        body = "Invalid OAuth state. Return to the terminal."
-      else
-        code = params["code"]
-      end
-
-      socket.write("HTTP/1.1 #{status}\r\nContent-Type: text/plain\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}")
-      code
-    rescue URI::InvalidURIError
-      nil
-    ensure
-      socket&.close
+      oauth_callback_server(port_env: "KWARD_ANTHROPIC_OAUTH_PORT", default_port: DEFAULT_PORT)
     end
 
     def exchange_code_for_tokens(code:, redirect_uri:, code_verifier:)
@@ -245,47 +203,7 @@ module Kward
     end
 
     def post_json(uri, params)
-      request = Net::HTTP::Post.new(uri)
-      request["Content-Type"] = "application/json"
-      request["Accept"] = "application/json"
-      request.body = JSON.dump(params)
-
-      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
-    end
-
-    def token_expired?(auth)
-      expires_at = auth&.fetch("expires_at", nil)
-      return false unless expires_at
-
-      Time.parse(expires_at) <= Time.now.utc + 60
-    rescue ArgumentError
-      false
-    end
-
-    def expires_at_for(tokens)
-      expires_in = tokens["expires_in"] || tokens[:expires_in]
-      return tokens["expires_at"] || tokens[:expires_at] unless expires_in
-
-      (Time.now.utc + expires_in.to_i).iso8601
-    end
-
-    def parse_successful_json(response, label)
-      raise "#{label} failed with HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-
-      JSON.parse(response.body)
-    rescue JSON::ParserError
-      raise "#{label} returned invalid JSON"
-    end
-
-    def open_url(url)
-      command = if RUBY_PLATFORM.match?(/darwin/)
-                  "open"
-                elsif RUBY_PLATFORM.match?(/linux/)
-                  "xdg-open"
-                end
-      return false unless command
-
-      system(command, url, out: File::NULL, err: File::NULL)
+      super(uri, params, headers: { "Accept" => "application/json" })
     end
   end
 end

data/lib/kward/auth/oauth_helpers.rb

@@ -0,0 +1,105 @@
+require "base64"
+require "digest"
+require "json"
+require "net/http"
+require "securerandom"
+require "socket"
+require "time"
+require "uri"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Shared browser OAuth mechanics used by provider-specific credential flows.
+  module OAuthHelpers
+    private
+
+    def generate_pkce
+      verifier = random_urlsafe(64)
+      challenge = Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false)
+      { verifier: verifier, challenge: challenge }
+    end
+
+    def random_urlsafe(bytes)
+      Base64.urlsafe_encode64(SecureRandom.random_bytes(bytes), padding: false)
+    end
+
+    def oauth_callback_server(port_env:, default_port:)
+      TCPServer.new("localhost", Integer(ENV.fetch(port_env, default_port)))
+    rescue Errno::EADDRINUSE
+      TCPServer.new("localhost", 0)
+    end
+
+    def wait_for_callback(server, expected_state:, timeout_seconds:)
+      ready = IO.select([server], nil, nil, timeout_seconds)
+      return nil unless ready
+
+      socket = server.accept
+      request_line = socket.gets.to_s
+      path = request_line.split[1].to_s
+      params = URI.decode_www_form(URI.parse(path).query.to_s).to_h
+
+      code = nil
+      status = "200 OK"
+      body = "Login complete. You can close this window."
+      if params["error"]
+        body = "Login failed. Return to the terminal."
+      elsif params["state"].to_s != expected_state.to_s
+        status = "400 Bad Request"
+        body = "Invalid OAuth state. Return to the terminal."
+      else
+        code = params["code"]
+      end
+
+      socket.write("HTTP/1.1 #{status}\r\nContent-Type: text/plain\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}")
+      code
+    rescue URI::InvalidURIError
+      nil
+    ensure
+      socket&.close
+    end
+
+    def post_json(uri, params, headers: {})
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      headers.each { |key, value| request[key] = value }
+      request.body = JSON.dump(params)
+
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+    end
+
+    def token_expired?(auth)
+      expires_at = auth&.fetch("expires_at", nil)
+      return false unless expires_at
+
+      Time.parse(expires_at) <= Time.now.utc + 60
+    rescue ArgumentError
+      false
+    end
+
+    def expires_at_for(tokens)
+      expires_in = tokens["expires_in"] || tokens[:expires_in]
+      return tokens["expires_at"] || tokens[:expires_at] unless expires_in
+
+      (Time.now.utc + expires_in.to_i).iso8601
+    end
+
+    def parse_successful_json(response, label)
+      raise "#{label} failed with HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise "#{label} returned invalid JSON"
+    end
+
+    def open_url(url)
+      command = if RUBY_PLATFORM.match?(/darwin/)
+                  "open"
+                elsif RUBY_PLATFORM.match?(/linux/)
+                  "xdg-open"
+                end
+      return false unless command
+
+      system(command, url, out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/kward/auth/openai_oauth.rb

@@ -1,17 +1,17 @@
 require "base64"
-require "digest"
 require "json"
 require "net/http"
-require "securerandom"
-require "socket"
 require "time"
 require "uri"
 require_relative "file"
+require_relative "oauth_helpers"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # OAuth helper for ChatGPT/OpenAI Codex credentials.
   class OpenAIOAuth
+    include OAuthHelpers
+
     ISSUER = "https://auth.openai.com"
     TOKEN_URL = URI("#{ISSUER}/oauth/token")
     DEFAULT_PORT = 1455
@@ -200,49 +200,8 @@ module Kward
       raise "Invalid Kward config JSON: #{@config_path}"
     end
 
-    def generate_pkce
-      verifier = random_urlsafe(64)
-      challenge = Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false)
-      { verifier: verifier, challenge: challenge }
-    end
-
-    def random_urlsafe(bytes)
-      Base64.urlsafe_encode64(SecureRandom.random_bytes(bytes), padding: false)
-    end
-
     def start_callback_server
-      TCPServer.new("localhost", Integer(ENV.fetch("KWARD_OAUTH_PORT", DEFAULT_PORT)))
-    rescue Errno::EADDRINUSE
-      TCPServer.new("localhost", 0)
-    end
-
-    def wait_for_callback(server, expected_state:, timeout_seconds:)
-      ready = IO.select([server], nil, nil, timeout_seconds)
-      return nil unless ready
-
-      socket = server.accept
-      request_line = socket.gets.to_s
-      path = request_line.split[1].to_s
-      params = URI.decode_www_form(URI.parse(path).query.to_s).to_h
-
-      code = nil
-      status = "200 OK"
-      body = "Login complete. You can close this window."
-      if params["error"]
-        body = "Login failed. Return to the terminal."
-      elsif params["state"] != expected_state
-        status = "400 Bad Request"
-        body = "Invalid OAuth state. Return to the terminal."
-      else
-        code = params["code"]
-      end
-
-      socket.write("HTTP/1.1 #{status}\r\nContent-Type: text/plain\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}")
-      code
-    rescue URI::InvalidURIError
-      nil
-    ensure
-      socket&.close
+      oauth_callback_server(port_env: "KWARD_OAUTH_PORT", default_port: DEFAULT_PORT)
     end
 
     def exchange_code_for_tokens(code:, redirect_uri:, code_verifier:)
@@ -263,29 +222,6 @@ module Kward
       Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
     end
 
-    def post_json(uri, params)
-      request = Net::HTTP::Post.new(uri)
-      request["Content-Type"] = "application/json"
-      request.body = JSON.dump(params)
-
-      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
-    end
-
-    def token_expired?(auth)
-      expires_at = auth&.fetch("expires_at", nil)
-      return false unless expires_at
-
-      Time.parse(expires_at) <= Time.now.utc + 60
-    rescue ArgumentError
-      false
-    end
-
-    def expires_at_for(tokens)
-      expires_in = tokens["expires_in"] || tokens[:expires_in]
-      return tokens["expires_at"] || tokens[:expires_at] unless expires_in
-
-      (Time.now.utc + expires_in.to_i).iso8601
-    end
 
     def extract_account_id(tokens)
       [tokens["id_token"], tokens[:id_token], tokens["access_token"], tokens[:access_token]].each do |token|
@@ -305,23 +241,5 @@ module Kward
       {}
     end
 
-    def parse_successful_json(response, label)
-      raise "#{label} failed with HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
-
-      JSON.parse(response.body)
-    rescue JSON::ParserError
-      raise "#{label} returned invalid JSON"
-    end
-
-    def open_url(url)
-      command = if RUBY_PLATFORM.match?(/darwin/)
-                  "open"
-                elsif RUBY_PLATFORM.match?(/linux/)
-                  "xdg-open"
-                end
-      return false unless command
-
-      system(command, url, out: File::NULL, err: File::NULL)
-    end
   end
 end

data/lib/kward/cli/commands.rb

@@ -53,11 +53,12 @@ module Kward
             #{command.call("kward auth status")}                  Show saved credential status
             #{command.call("kward init")}                         Install starter prompts and PRINCIPLES.md
             #{command.call("kward doctor")}                       Check local Kward setup
+            #{command.call("kward hooks doctor")}                 Inspect lifecycle hook setup
             #{command.call("kward edit")} #{option.call("<filename>")}              Open a file in the integrated editor
             #{command.call("kward sysprompt")}                    Inspect the effective system prompt
             #{command.call("kward openrouter refresh")}           Refresh cached OpenRouter models
             #{command.call("kward pan")}                          Start Pan mode web UI
-            #{command.call("kward rpc")}                          Start the experimental JSON-RPC backend
+            #{command.call("kward rpc")}                          Start the JSON-RPC backend
 
           #{heading.call("Commands")}
             #{command.call("help")}                               Show this help
@@ -66,6 +67,7 @@ module Kward
             #{command.call("auth status|logout")}                 Show or clear saved credentials
             #{command.call("init")}                               Install starter prompts and PRINCIPLES.md
             #{command.call("doctor")}                             Check local Kward setup
+            #{command.call("hooks list|events|logs|doctor|trust|untrust")} Inspect lifecycle hooks
             #{command.call("edit")} #{option.call("<filename>")}                  Open a file in the integrated editor
             #{command.call("sysprompt")} [--raw]                  Inspect the effective system prompt
             #{command.call("stats tokens")} [range] [options]      Export local token telemetry as CSV
@@ -127,6 +129,11 @@ module Kward
             description: "Check local Kward configuration, workspace, auth hints, and writable directories.",
             examples: ["kward doctor", "kward --working-directory ~/code/project doctor"]
           },
+          "hooks" => {
+            usage: "kward hooks [list|events|logs|doctor|trust|untrust]",
+            description: "Inspect lifecycle hooks, recent audit records, diagnostics, and workspace hook trust.",
+            examples: ["kward hooks list", "kward hooks doctor", "kward hooks logs 50", "kward hooks trust"]
+          },
           "edit" => {
             usage: "kward edit <filename>",
             description: "Open a file in the integrated editor.",
@@ -154,7 +161,7 @@ module Kward
           },
           "rpc" => {
             usage: "kward rpc",
-            description: "Start the experimental JSON-RPC backend for UI clients.",
+            description: "Start the JSON-RPC backend for trusted local UI clients.",
             examples: ["kward rpc", "kward --working-directory ~/code/project rpc"]
           }
         }

data/lib/kward/cli/compaction.rb

@@ -7,11 +7,18 @@ module Kward
       private
 
       def compact_context(agent, argument)
+        before = run_lifecycle_hook("session_compact_before", conversation: agent.conversation, payload: { instructions: argument.to_s })
+        if before.denied? || before.approval_required?
+          runtime_output("Declined: #{before.decision.message || "session compaction denied"}")
+          return
+        end
+
         result = Compactor.new(
           conversation: agent.conversation,
           client: @client,
           tool_result_summarizer: lambda { |tool_call, content| tool_result_summary(tool_call, content) }
         ).compact(custom_instructions: argument)
+        run_lifecycle_hook("session_compact_after", conversation: agent.conversation, payload: { old_message_count: result.old_message_count, new_message_count: result.new_message_count })
         runtime_output("Compacted context: #{result.old_message_count} messages -> #{result.new_message_count} messages.")
         render_transcript_block("Assistant", result.summary)
       rescue Compactor::NothingToCompact, Compactor::AlreadyCompacted, Compactor::EmptySummary => e