kward 0.74.0 → 0.75.0

data/lib/kward/cli/git.rb

@@ -14,6 +14,8 @@ module Kward
           return
         end
 
+        previous_git_hook_conversation = @git_hook_conversation
+        @git_hook_conversation = agent.conversation
         root = interactive_workspace_root(agent)
         git_root = git_repository_root(root)
         if git_root.empty?
@@ -33,6 +35,8 @@ module Kward
           git_commit(git_root, message)
         end
         print_git_commit_result(result)
+      ensure
+        @git_hook_conversation = previous_git_hook_conversation
       end
 
       def git_repository_root(root)
@@ -48,7 +52,9 @@ module Kward
         output, status = Open3.capture2e("git", "status", "--short", "--untracked-files=normal", chdir: root.to_s)
         return ["Unable to read Git status: #{output.strip}"] unless status.success?
 
-        output.lines.map(&:chomp)
+        lines = output.lines.map(&:chomp)
+        git_lifecycle_hook("git_status_after", root: root, payload: { status_count: lines.length })
+        lines
       rescue StandardError => e
         ["Unable to read Git status: #{e.message}"]
       end
@@ -70,7 +76,13 @@ module Kward
         entry = parse_git_status_line(status_line)
         return { path: "Git diff", content: "Unable to read Git status entry.\n" } if entry.nil?
 
+        before = git_lifecycle_hook("git_diff_before", root: root, payload: { path: entry[:path], untracked: entry[:untracked] })
+        if before.denied? || before.approval_required?
+          return { path: entry[:path], content: "Declined: #{before.decision.message || "git diff denied"}\n" }
+        end
+
         output = entry[:untracked] ? git_untracked_file_diff(root, entry[:path]) : git_tracked_file_diff(root, entry[:path])
+        git_lifecycle_hook("git_diff_after", root: root, payload: { path: entry[:path], untracked: entry[:untracked], bytes: output.bytesize })
         { path: entry[:path], content: output.empty? ? "No diff for #{entry[:path]}\n" : output }
       end
 
@@ -96,8 +108,13 @@ module Kward
         entry = parse_git_status_line(status_line)
         return if entry.nil?
 
+        action = entry[:staged] ? "unstage" : "stage"
+        before = git_lifecycle_hook("git_stage_before", root: root, payload: { path: entry[:path], action: action })
+        return if before.denied? || before.approval_required?
+
         command = entry[:staged] ? ["restore", "--staged", "--", entry[:path]] : ["add", "--", entry[:path]]
-        Open3.capture2e("git", *command, chdir: root.to_s)
+        output, status = Open3.capture2e("git", *command, chdir: root.to_s)
+        git_lifecycle_hook("git_stage_after", root: root, payload: { path: entry[:path], action: action, success: status.success?, output: output })
       rescue StandardError
         nil
       end
@@ -115,6 +132,9 @@ module Kward
       end
 
       def git_commit(root, message)
+        before = git_lifecycle_hook("git_commit_before", root: root, payload: { message: message.to_s })
+        return { success: false, output: "Declined: #{before.decision.message || "git commit denied"}" } if before.denied? || before.approval_required?
+
         return git_commit_staged(root, message) if git_staged_changes?(root)
 
         add_output, add_status = Open3.capture2e("git", "add", "--all", chdir: root.to_s)
@@ -134,11 +154,18 @@ module Kward
 
       def git_commit_staged(root, message)
         commit_output, commit_status = Open3.capture2e("git", "commit", "-m", message.to_s, chdir: root.to_s)
-        { success: commit_status.success?, output: commit_output }
+        result = { success: commit_status.success?, output: commit_output }
+        git_lifecycle_hook("git_commit_after", root: root, payload: { message: message.to_s, success: result[:success], output: result[:output] })
+        result
       rescue StandardError => e
         { success: false, output: e.message }
       end
 
+      def git_lifecycle_hook(name, root:, payload: {})
+        conversation = @git_hook_conversation || new_conversation(workspace_root: root.to_s)
+        run_lifecycle_hook(name, conversation: conversation, payload: { root: root.to_s }.merge(payload))
+      end
+
       def print_git_commit_result(result)
         output = result[:output].to_s.strip
         output = result[:success] ? "Commit created." : "Git commit failed." if output.empty?

data/lib/kward/cli/hook_commands.rb

@@ -0,0 +1,258 @@
+require "json"
+require "uri"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # Interactive lifecycle hook inspection commands.
+    module HookCommands
+      private
+
+      def handle_hooks_command(argument)
+        subcommand, rest = argument.to_s.strip.split(/\s+/, 2)
+        subcommand = "list" if subcommand.to_s.empty?
+
+        case subcommand
+        when "list"
+          print_hooks_list
+        when "events"
+          print_hooks_events
+        when "logs"
+          print_hooks_logs(rest)
+        when "doctor"
+          print_hooks_doctor
+        when "trust"
+          trust_workspace_hooks
+        when "untrust"
+          untrust_workspace_hooks
+        else
+          runtime_output("Usage: /hooks [list|events|logs|doctor|trust|untrust]")
+        end
+      end
+
+      def print_hooks_list
+        lines = ["Lifecycle hooks"]
+        entries = configured_hook_entries + workspace_hook_entries + plugin_hook_entries
+        if entries.empty?
+          lines << "No lifecycle hooks are configured."
+        else
+          entries.each do |entry|
+            details = [entry.fetch(:id), entry.fetch(:event)]
+            details << "source=#{entry.fetch(:source)}"
+            details << "order=#{entry.fetch(:order)}"
+            details << "failure_policy=#{entry[:failure_policy]}" if entry[:failure_policy]
+            details << "disabled" if entry[:disabled]
+            lines << "- #{details.join(' ')}"
+          end
+        end
+        runtime_output(lines.join("\n"))
+      end
+
+      def print_hooks_events
+        lines = ["Lifecycle hook events"]
+        Hooks::Catalog.event_names.each do |event_name|
+          definition = Hooks::Catalog.definition(event_name)
+          fields = Array(definition&.modifiable_fields)
+          suffix = fields.empty? ? "" : " modifies=#{fields.join(',')}"
+          lines << "- #{event_name} failure_policy=#{Hooks::Catalog.failure_policy(event_name)}#{suffix}"
+        end
+        runtime_output(lines.join("\n"))
+      end
+
+      def print_hooks_logs(argument)
+        count = argument.to_s.strip.empty? ? 20 : argument.to_i
+        count = 20 unless count.positive?
+        path = hooks_log_path
+        unless File.file?(path)
+          runtime_output("No lifecycle hook audit log found at #{path}.")
+          return
+        end
+
+        records = File.readlines(path, chomp: true).last(count).filter_map do |line|
+          JSON.parse(line)
+        rescue JSON::ParserError
+          nil
+        end
+        if records.empty?
+          runtime_output("No readable lifecycle hook audit records found at #{path}.")
+          return
+        end
+
+        lines = ["Lifecycle hook audit log: #{path}"]
+        records.each do |record|
+          lines << format_hook_log_record(record)
+        end
+        runtime_output(lines.join("\n"))
+      end
+
+      def print_hooks_doctor
+        lines = ["Lifecycle hook diagnostics"]
+        begin
+          diagnostics = hook_config_diagnostics(ConfigFiles.read_config, "config") + hook_config_diagnostics(ConfigFiles.read_trusted_workspace_hooks_config(current_workspace_root), "workspace")
+          manager = diagnostics.empty? ? Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(current_workspace_root)).manager : nil
+          lines << "Config and trusted workspace hooks: #{manager ? manager.handlers.length : "not loaded due diagnostics"}"
+          lines << "Plugin hooks: #{plugin_registry.hook_handlers.length}"
+          lines << "Audit log: #{hooks_log_path}"
+          lines << "Workspace hook config: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}"
+          lines << "Workspace hooks trusted: #{ConfigFiles.workspace_hooks_trusted?(current_workspace_root)}"
+          lines << "Known events: #{Hooks::Catalog.event_names.length}"
+          if diagnostics.empty?
+            lines << "OK"
+          else
+            lines.concat(diagnostics.map { |diagnostic| "Warning: #{diagnostic}" })
+          end
+        rescue StandardError => e
+          lines << "Error: #{e.message}"
+        end
+        runtime_output(lines.join("\n"))
+      end
+
+      def configured_hook_entries
+        hook_entries_from_config(ConfigFiles.read_config, "config")
+      end
+
+      def workspace_hook_entries
+        hook_entries_from_config(ConfigFiles.read_trusted_workspace_hooks_config(current_workspace_root), "workspace")
+      end
+
+      def plugin_hook_entries
+        plugin_registry.hook_handlers.map do |hook|
+          {
+            id: hook.id,
+            event: hook.event,
+            source: hook.path || "plugin",
+            order: hook.order,
+            failure_policy: hook.failure_policy,
+            disabled: false
+          }
+        end
+      end
+
+      def hook_entries_from_config(config, source)
+        hooks = config["hooks"] || config[:hooks]
+        return [] unless hooks.is_a?(Hash)
+
+        hooks.flat_map do |event, entries|
+          Array(entries).each_with_index.map do |entry, index|
+            entry = entry.is_a?(Hash) ? entry.transform_keys(&:to_s) : { "command" => entry.to_s }
+            {
+              id: entry["id"] || "#{source}:#{event}:#{index + 1}",
+              event: event.to_s,
+              source: source,
+              order: entry.fetch("order", 100),
+              failure_policy: entry["failure_policy"],
+              disabled: truthy_hook_value?(entry["disabled"])
+            }
+          end
+        end
+      end
+
+      def hook_config_diagnostics(config, source)
+        hooks = config["hooks"] || config[:hooks]
+        return [] unless hooks.is_a?(Hash)
+
+        hooks.flat_map do |event, entries|
+          Array(entries).each_with_index.flat_map do |entry, index|
+            validate_hook_entry(event.to_s, normalize_hook_entry(entry), source, index + 1)
+          end
+        end
+      end
+
+      def normalize_hook_entry(entry)
+        entry.is_a?(Hash) ? entry.transform_keys(&:to_s) : { "type" => "command", "command" => entry.to_s }
+      end
+
+      def validate_hook_entry(event, entry, source, number)
+        label = entry["id"] || "#{source}:#{event}:#{number}"
+        diagnostics = []
+        diagnostics << "#{label}: unknown event #{event}" unless Hooks::Catalog.known?(event)
+        diagnostics.concat(validate_hook_failure_policy(label, entry))
+        diagnostics.concat(validate_hook_timeout(label, entry))
+        diagnostics.concat(validate_hook_type(label, entry))
+        diagnostics
+      end
+
+      def validate_hook_failure_policy(label, entry)
+        policy = entry["failure_policy"]
+        return [] if policy.to_s.empty? || Hooks::Catalog::VALID_FAILURE_POLICIES.include?(policy.to_s)
+
+        ["#{label}: unknown failure_policy #{policy}"]
+      end
+
+      def validate_hook_timeout(label, entry)
+        value = entry["timeout_seconds"]
+        return [] if value.nil? || value.to_f.positive?
+
+        ["#{label}: timeout_seconds must be positive"]
+      end
+
+      def validate_hook_type(label, entry)
+        type = (entry["type"] || "command").to_s
+        case type
+        when "command"
+          validate_command_hook(label, entry)
+        when "http"
+          validate_http_hook(label, entry)
+        else
+          ["#{label}: unsupported hook type #{type}"]
+        end
+      end
+
+      def validate_command_hook(label, entry)
+        command = entry["command"].to_s.strip
+        return ["#{label}: command is required"] if command.empty?
+
+        executable = command.split(/\s+/, 2).first
+        return [] if executable.include?(File::SEPARATOR) ? File.executable?(File.expand_path(executable)) : system_command_available?(executable)
+
+        ["#{label}: command executable not found: #{executable}"]
+      end
+
+      def validate_http_hook(label, entry)
+        uri = URI.parse(entry["url"].to_s)
+        return [] if %w[http https].include?(uri.scheme) && uri.host
+
+        ["#{label}: url must be http or https"]
+      rescue URI::InvalidURIError
+        ["#{label}: url must be http or https"]
+      end
+
+      def system_command_available?(name)
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+          File.executable?(File.join(dir, name))
+        end
+      end
+
+      def trust_workspace_hooks
+        ConfigFiles.trust_workspace_hooks!(current_workspace_root)
+        runtime_output("Trusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
+      rescue StandardError => e
+        runtime_output("Workspace hook trust error: #{e.message}")
+      end
+
+      def untrust_workspace_hooks
+        ConfigFiles.untrust_workspace_hooks!(current_workspace_root)
+        runtime_output("Untrusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
+      rescue StandardError => e
+        runtime_output("Workspace hook trust error: #{e.message}")
+      end
+
+      def hooks_log_path
+        File.join(ConfigFiles.config_dir, "logs", "hooks.jsonl")
+      end
+
+      def format_hook_log_record(record)
+        parts = [record["timestamp"], record["kind"], record["event"]].compact
+        parts << "hook=#{record['hook_id']}" if record["hook_id"]
+        parts << "decision=#{record['decision']}" if record["decision"]
+        parts << record["message"] if record["message"]
+        "- #{parts.join(' ')}"
+      end
+
+      def truthy_hook_value?(value)
+        value == true || value.to_s == "true"
+      end
+    end
+  end
+end

data/lib/kward/cli/memory_commands.rb

@@ -102,11 +102,7 @@ module Kward
       end
 
       def prepare_memory_context(conversation, input)
-        manager = Memory::Manager.new
-        retrieval = manager.retrieve_relevant(input: input, workspace_root: conversation.workspace_root)
-        conversation.last_memory_retrieval = retrieval
-        conversation.memory_context = manager.memory_block(retrieval)
-        conversation.refresh_system_message!
+        Memory::TurnContext.apply(conversation: conversation, input: input)
       rescue StandardError => e
         warn "Memory retrieval failed: #{e.message}"
         nil

data/lib/kward/cli/plugins.rb

@@ -37,6 +37,39 @@ module Kward
         runtime_output("Plugins reloaded.")
       end
 
+      def lifecycle_hook_manager(conversation)
+        manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(conversation.workspace_root)).manager
+        plugin_registry.hook_handlers.each do |hook|
+          manager.register(hook.event, id: hook.id, source: hook.path, order: hook.order, match: hook.match, failure_policy: hook.failure_policy) do |event, context|
+            hook.handler.call(event, context)
+          end
+        end
+        manager
+      end
+
+      def lifecycle_hook_context(conversation)
+        plugin_context(conversation, "")
+      end
+
+      def run_lifecycle_hook(name, conversation:, payload: {}, session: @active_session)
+        lifecycle_hook_manager(conversation).run(Hooks::Event.new(
+          name: name,
+          session: session_payload(session),
+          workspace: { root: conversation.respond_to?(:workspace_root) ? conversation.workspace_root : current_workspace_root },
+          payload: payload
+        ), context: lifecycle_hook_context(conversation))
+      end
+
+      def session_payload(session)
+        return {} unless session
+
+        {
+          id: session.respond_to?(:id) ? session.id : nil,
+          name: session.respond_to?(:name) ? session.name : nil,
+          path: session.respond_to?(:path) ? session.path : nil
+        }.compact
+      end
+
       def reserved_slash_command_names
         builtin_slash_command_names + prompt_templates.map(&:command)
       end
@@ -76,9 +109,16 @@ module Kward
             argument_hint: template.argument_hint
           }
         end
+        skill_entries = ConfigFiles.skills.map do |skill|
+          {
+            name: "skill:#{skill.name}",
+            description: skill.description,
+            argument_hint: ""
+          }
+        end
         plugin_entries = plugin_commands.map(&:entry)
         interactive_entries = interactive_commands.map(&:entry)
-        builtin_slash_commands + prompt_entries + plugin_entries + interactive_entries
+        builtin_slash_commands + prompt_entries + skill_entries + plugin_entries + interactive_entries
       end
 
       def prompt_template_for(command)

data/lib/kward/cli/prompt_interface.rb

@@ -37,7 +37,9 @@ module Kward
           editor_bar_cursor: ConfigFiles.editor_bar_cursor?,
           editor_bar_cursor_source: -> { ConfigFiles.editor_bar_cursor? },
           editor_line_numbers: ConfigFiles.editor_line_numbers,
-          editor_line_numbers_source: -> { ConfigFiles.editor_line_numbers }
+          editor_line_numbers_source: -> { ConfigFiles.editor_line_numbers },
+          diff_view: ConfigFiles.diff_view,
+          diff_view_source: -> { ConfigFiles.diff_view }
         )
         if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
           @prompt.start(render: false)
@@ -69,11 +71,13 @@ module Kward
         return unless @prompt.respond_to?(:print_visual_banner)
 
         @prompt.print_visual_banner(startup_info_screen)
+        refresh_startup_update_check if prompt_interface?
       end
 
       def startup_info_screen
         [
           startup_status_line,
+          *startup_update_notice_lines,
           "",
           startup_info_line("Workspace", startup_workspace_label),
           startup_info_line("Branch", startup_branch_value),
@@ -116,7 +120,32 @@ module Kward
       end
 
       def startup_status_line
-        "#{ANSI.colorize("●", :green, enabled: @color_enabled)} Kward v#{Kward::VERSION} is online."
+        color = startup_update_notice ? :yellow : :green
+        "#{ANSI.colorize("●", color, enabled: @color_enabled)} Kward v#{Kward::VERSION} is online."
+      end
+
+      def startup_update_notice_lines
+        notice = startup_update_notice
+        return [] unless notice
+
+        [
+          "  New version available: #{notice.latest_version}",
+          "  Run: gem update kward"
+        ]
+      end
+
+      def startup_update_notice
+        return @startup_update_notice if defined?(@startup_update_notice)
+
+        @startup_update_check = UpdateCheck.new(current_version: Kward::VERSION)
+        @startup_update_notice = @startup_update_check.notice
+      end
+
+      def refresh_startup_update_check
+        checker = @startup_update_check || UpdateCheck.new(current_version: Kward::VERSION)
+        return unless checker.enabled?
+
+        Thread.new { checker.refresh_if_stale }
       end
 
       def startup_info_line(label, value)
@@ -218,7 +247,7 @@ module Kward
       def composer_context_usage(provider, model)
         context_window = composer_context_window(provider, model)
         context_parts = if @client.respond_to?(:current_context_parts)
-                          @client.current_context_parts(current_footer_conversation.context_messages, footer_tool_schemas)
+                          @client.current_context_parts(current_footer_conversation.context_messages, footer_tool_schemas, provider: provider, model: model)
                         else
                           { provider: provider, model: model, messages: current_footer_conversation.context_messages, tools: footer_tool_schemas }
                         end

data/lib/kward/cli/rendering.rb

@@ -183,7 +183,7 @@ module Kward
       end
 
       def tool_call_id(tool_call)
-        tool_call["id"] || tool_call[:id]
+        ToolCall.id(tool_call)
       end
 
       # Writes the user transcript output for the terminal CLI flow.

data/lib/kward/cli/runtime_helpers.rb

@@ -52,19 +52,25 @@ module Kward
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
         workspace = configured_workspace(root: conversation.workspace_root)
         writer_id = worker_writer_id(role)
+        hook_manager = lifecycle_hook_manager(conversation)
+        hook_context = lifecycle_hook_context(conversation)
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: @prompt,
           allowed_tool_names: Workers::ToolPolicy.allowed_tool_names(role),
           write_lock: @worker_write_lock,
-          writer_id: writer_id
+          writer_id: writer_id,
+          hook_manager: hook_manager,
+          hook_context: hook_context
         )
         @footer_conversation = conversation
         @footer_tool_registry = tool_registry
         Agent.new(
           client: @client,
           tool_registry: tool_registry,
-          conversation: conversation
+          conversation: conversation,
+          hook_manager: hook_manager,
+          hook_context: hook_context
         )
       end
 
@@ -356,7 +362,7 @@ module Kward
         queued_inputs = []
         result = nil
         error = nil
-        @prompt.begin_busy_input("You>", activity: activity) if @prompt.respond_to?(:begin_busy_input)
+        begin_local_busy_command(activity)
 
         worker = Thread.new do
           result = yield
@@ -365,7 +371,8 @@ module Kward
         end
 
         while worker.alive?
-          collect_queued_input(queued_inputs)
+          poll_result = collect_queued_input(queued_inputs)
+          handle_busy_local_tab_action(poll_result, activity: activity) if busy_local_tab_action?(poll_result)
           sleep 0.02
         end
         worker.join
@@ -374,7 +381,7 @@ module Kward
 
         [result, queued_inputs]
       ensure
-        @prompt.finish_busy_input if prompt_interface? && @prompt.respond_to?(:finish_busy_input)
+        finish_local_busy_command(activity)
       end
 
       def run_busy_local_command_and_requeue(activity: "loading")
@@ -385,6 +392,38 @@ module Kward
         result
       end
 
+      def begin_local_busy_command(activity)
+        active_tab.local_busy_activity = activity if active_tab
+        @prompt.begin_busy_input("You>", activity: activity) if @prompt.respond_to?(:begin_busy_input)
+        update_prompt_tabs if respond_to?(:update_prompt_tabs, true)
+      end
+
+      def finish_local_busy_command(activity)
+        tab = local_busy_tab(activity)
+        tab.local_busy_activity = nil if tab
+        update_prompt_tabs if respond_to?(:update_prompt_tabs, true)
+        @prompt.finish_busy_input if prompt_interface? && @prompt.respond_to?(:finish_busy_input) && (!active_tab || active_tab == tab)
+      end
+
+      def local_busy_tab(activity)
+        Array(@tabs).find { |tab| tab.local_busy_activity.to_s == activity.to_s }
+      end
+
+      def busy_local_tab_action?(poll_result)
+        poll_result.is_a?(Hash) && poll_result[:tab_action]
+      end
+
+      def handle_busy_local_tab_action(action, activity:)
+        return unless respond_to?(:handle_tab_action, true)
+
+        @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+        handle_tab_action(action, @session_store)
+        tab = active_tab
+        return unless tab&.local_busy?
+
+        @prompt.begin_busy_input("You>", activity: tab.local_busy_activity) if @prompt.respond_to?(:begin_busy_input)
+      end
+
       def current_workspace_root
         return @active_session.cwd.to_s unless @active_session&.cwd.to_s.empty?
         return @working_directory if @working_directory

data/lib/kward/cli/sessions.rb

@@ -49,6 +49,7 @@ module Kward
         reset_session_diff
         conversation = new_conversation(workspace_root: session_store.cwd)
         @active_session.attach(conversation)
+        run_lifecycle_hook("session_create", conversation: conversation, payload: { action: "create" })
         build_interactive_agent(conversation)
       end
 
@@ -95,6 +96,7 @@ module Kward
         cleanup_replaced_session(previous_session)
         conversation = new_conversation(workspace_root: session_store.cwd)
         @active_session.attach(conversation)
+        run_lifecycle_hook("session_create", conversation: conversation, payload: { action: "create" })
         update_assistant_prompt(conversation)
         clear_prompt_transcript
         print_visual_banner
@@ -125,6 +127,7 @@ module Kward
           runtime_output("#{message}: #{@active_session.path}") if message
           render_conversation_transcript(conversation)
         end
+        run_lifecycle_hook("session_resume", conversation: conversation, payload: { action: "resume", path: @active_session.path })
         agent = build_interactive_agent(conversation)
         @prompt.redraw if @prompt.respond_to?(:redraw) && !@prompt.respond_to?(:restore_transcript)
         agent
@@ -413,7 +416,9 @@ module Kward
           return
         end
 
+        old_name = @active_session.name
         @active_session.rename(name)
+        run_lifecycle_hook("session_rename", conversation: new_conversation(workspace_root: current_workspace_root), session: @active_session, payload: { old_name: old_name, new_name: @active_session.name })
         label = @active_session.name ? "Named session: #{@active_session.name}" : "Cleared session name."
         runtime_output(label)
       end
@@ -425,6 +430,7 @@ module Kward
         @active_session = track_session(session_store.create_from_conversation(agent.conversation, parent_session: previous_session))
         reset_session_diff(@active_session.path)
         cleanup_replaced_session(previous_session)
+        run_lifecycle_hook("session_clone", conversation: agent.conversation, payload: { source_path: previous_session&.path, path: @active_session.path })
         runtime_output("Cloned session: #{@active_session.path}")
         render_conversation_transcript(agent.conversation)
         agent
@@ -497,6 +503,7 @@ module Kward
         reset_session_diff(@active_session.path)
         cleanup_replaced_session(previous_session)
         update_assistant_prompt(conversation)
+        run_lifecycle_hook("session_fork", conversation: conversation, payload: { source_path: previous_session.path, path: @active_session.path, entry_id: point.dig(:entry, "id") })
         restore_prompt_transcript do
           runtime_output("Forked session: #{@active_session.path}")
           render_conversation_transcript(conversation)
@@ -679,7 +686,13 @@ module Kward
 
       def export_session(conversation, argument)
         path = export_path(argument)
+        before = run_lifecycle_hook("session_export_before", conversation: conversation, payload: { path: path })
+        if before.denied? || before.approval_required?
+          runtime_output("Declined: #{before.decision.message || "session export denied"}")
+          return
+        end
         File.write(path, markdown_transcript(conversation))
+        run_lifecycle_hook("session_export_after", conversation: conversation, payload: { path: path })
         runtime_output("Exported session: #{path}")
       rescue StandardError => e
         runtime_output("Error: #{e.message}")