kward 0.79.0 → 0.80.0

data/lib/kward/rpc/session_manager.rb

@@ -66,8 +66,8 @@ module Kward
       WORKER_STOP_TIMEOUT = 2.0
       WORKER_STOP = Object.new.freeze
 
-      RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :prompt, :plugin_output, :queue, :worker, :running_turn_id, :footer_worker, :last_footer_text, keyword_init: true)
-      Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, :options, :tool_registry, :mutex, keyword_init: true)
+      RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :execution_profile, :prompt, :plugin_output, :queue, :worker, :running_turn_id, :footer_worker, :last_footer_text, keyword_init: true)
+      Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, :options, :tool_registry, :execution_profile, :mutex, keyword_init: true)
 
       # Creates an object for RPC session lifecycle and turn coordination.
       def initialize(
@@ -77,7 +77,8 @@ module Kward
         config_manager: ConfigManager.new(config_path: File.join(config_dir, "config.json")),
         context_usage: ContextUsage.new,
         session_trash: SessionTrash.new,
-        worker_stop_timeout: WORKER_STOP_TIMEOUT
+        worker_stop_timeout: WORKER_STOP_TIMEOUT,
+        event_listener: nil
       )
         @server = server
         @client = client
@@ -87,6 +88,7 @@ module Kward
         @session_metrics = SessionMetrics.new(context_usage: context_usage)
         @session_trash = session_trash
         @worker_stop_timeout = worker_stop_timeout
+        @event_listeners = event_listener ? [event_listener] : []
         @sessions = {}
         @turns = {}
         @mutex = Mutex.new
@@ -97,26 +99,28 @@ module Kward
       # Returns the normalized session payload expected by RPC clients. The RPC
       # session id is separate from the persisted session id so one persisted file
       # can be closed and reopened by different client connections.
-      def create_session(workspace_root: Dir.pwd, name: nil, resume_last: false)
+      def create_session(workspace_root: Dir.pwd, name: nil, resume_last: false, execution_profile: nil)
+        execution_profile = validate_execution_profile(execution_profile)
         workspace_root = validate_workspace_root(workspace_root)
         store = SessionStore.new(config_dir: @config_dir, cwd: workspace_root)
         if resume_last && session_auto_resume_enabled? && name.to_s.strip.empty?
           path = store.remembered_last_session_path
-          return resume_session(path: path, workspace_root: workspace_root, include_transcript: true) if path
+          return resume_session(path: path, workspace_root: workspace_root, include_transcript: true, execution_profile: execution_profile) if path
         end
 
-        conversation = new_conversation(workspace_root: workspace_root)
+        conversation = new_conversation(workspace_root: workspace_root, execution_profile: execution_profile)
         session = store.create(provider: conversation.provider, model: conversation.model, reasoning_effort: conversation.reasoning_effort)
         session.rename(name) unless name.to_s.strip.empty?
         session.attach(conversation)
-        rpc_session = build_rpc_session(store, session, conversation, workspace_root)
+        rpc_session = build_rpc_session(store, session, conversation, workspace_root, execution_profile: execution_profile)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
         emit_footer_update(rpc_session)
         session_payload(rpc_session)
       end
 
-      def resume_session(path:, workspace_root: nil, include_transcript: false)
+      def resume_session(path:, workspace_root: nil, include_transcript: false, execution_profile: nil)
+        execution_profile = validate_execution_profile(execution_profile)
         root = validate_workspace_root(workspace_root || Dir.pwd)
         store = SessionStore.new(config_dir: @config_dir, cwd: root)
         location = store.session_location(path)
@@ -129,7 +133,8 @@ module Kward
           model: current_model_id,
           reasoning_effort: current_reasoning_effort
         )
-        rpc_session = build_rpc_session(store, session, conversation, root)
+        conversation.update_execution_profile_context!(execution_profile.prompt_context) if execution_profile
+        rpc_session = build_rpc_session(store, session, conversation, root, execution_profile: execution_profile)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
         emit_footer_update(rpc_session)
@@ -197,6 +202,17 @@ module Kward
         { tools: registry.schemas }
       end
 
+      # Subscribes to frontend-neutral runtime notifications.
+      #
+      # Subscribers are isolated from session execution: an exception is logged
+      # and does not interrupt the RPC notification or active turn.
+      def subscribe_events(&listener)
+        raise ArgumentError, "event subscription requires a block" unless listener
+
+        @mutex.synchronize { @event_listeners << listener }
+        listener
+      end
+
       # Returns the plugin registry shared by RPC sessions and plugin chats.
       def plugin_registry
         @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_plugin_command_names)
@@ -213,7 +229,8 @@ module Kward
       def clone_session(session_id:)
         source = fetch_session(session_id)
         session, conversation = source.store.create_independent_from_conversation(source.conversation, parent_session: source.session)
-        rpc_session = build_rpc_session(source.store, session, conversation, source.workspace_root)
+        conversation.update_execution_profile_context!(source.execution_profile.prompt_context) if source.execution_profile
+        rpc_session = build_rpc_session(source.store, session, conversation, source.workspace_root, execution_profile: source.execution_profile)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
         emit_footer_update(rpc_session)
@@ -272,7 +289,8 @@ module Kward
           parent_session: source.session
         )
 
-        rpc_session = build_rpc_session(source.store, session, conversation, source.workspace_root)
+        conversation.update_execution_profile_context!(source.execution_profile.prompt_context) if source.execution_profile
+        rpc_session = build_rpc_session(source.store, session, conversation, source.workspace_root, execution_profile: source.execution_profile)
         remember_session(rpc_session)
         cleanup_other_unused_sessions(rpc_session)
         {
@@ -386,12 +404,20 @@ module Kward
       # queue a follow-up, or steer the running turn when the active provider
       # supports native steering. The returned turn id is used for status,
       # cancellation, and event replay.
-      def start_turn(session_id:, input:, streaming_behavior: nil, attachments: [], options: {}, context: nil)
+      def start_turn(session_id:, input:, streaming_behavior: nil, attachments: [], options: {}, context: nil, execution_profile: nil)
         rpc_session = fetch_session(session_id)
-        normalized_options = normalize_turn_options(options)
+        execution_profile = validate_execution_profile(execution_profile)
+        normalized_options = enforce_execution_profile_options(normalize_turn_options(options), execution_profile)
         normalized_context = TurnContext.normalize(context)
         normalized_attachments = normalize_attachments(attachments)
-        plugin_command, plugin_arguments = plugin_command_turn(input, normalized_attachments)
+        if execution_profile && !execution_profile.attachments && !normalized_attachments.empty?
+          raise ArgumentError, "transport execution profile does not allow attachments"
+        end
+        plugin_command, plugin_arguments = if execution_profile && !execution_profile.plugin_commands
+                                              [nil, ""]
+                                            else
+                                              plugin_command_turn(input, normalized_attachments)
+                                            end
         display_input = input.to_s if input.is_a?(String)
         content = plugin_command ? input.to_s : user_turn_content(turn_input_with_context(expand_prompt_input(input), normalized_context), normalized_attachments)
         streaming_behavior = validate_streaming_behavior(default_streaming_behavior(rpc_session, streaming_behavior), rpc_session: rpc_session)
@@ -414,6 +440,7 @@ module Kward
           plugin_arguments: plugin_arguments,
           options: normalized_options,
           tool_registry: scoped_tool_registry(rpc_session, normalized_options),
+          execution_profile: execution_profile,
           mutex: Mutex.new
         )
         @mutex.synchronize { @turns[turn.id] = turn }
@@ -429,7 +456,7 @@ module Kward
           turn.cancel_requested = true
           [turn.status == "queued", append_turn_event_locked(turn, "turnCancelRequested", {})]
         end
-        @server.notify("turn/event", event)
+        notify("turn/event", event)
         turn.cancellation&.cancel!
         finish_turn(turn, "canceled") if queued
         turn_payload(turn)
@@ -518,6 +545,11 @@ module Kward
         normalized
       end
 
+      def refresh_models(provider: nil)
+        @client.refresh_available_models(provider: provider) if @client.respond_to?(:refresh_available_models)
+        available_models
+      end
+
       def current_model
         provider = @client.respond_to?(:current_provider) ? @client.current_provider : nil
         model = @client.respond_to?(:current_model) ? @client.current_model : nil
@@ -623,7 +655,9 @@ module Kward
       end
 
       def session_modified_at(session)
-        File.exist?(session.path) ? File.mtime(session.path) : nil
+        return nil unless File.exist?(session.path)
+
+        session.respond_to?(:modified_at) ? session.modified_at : nil
       end
 
       def validate_workspace_root(root)
@@ -635,9 +669,22 @@ module Kward
 
       private
 
-      def new_conversation(workspace_root: Dir.pwd)
+      def notify(method, payload)
+        @server.notify(method, payload)
+        listeners = @mutex.synchronize { @event_listeners.dup }
+        listeners.each do |listener|
+          begin
+            listener.call(method, payload)
+          rescue StandardError => e
+            @server.log_error(e) if @server.respond_to?(:log_error)
+          end
+        end
+      end
+
+      def new_conversation(workspace_root: Dir.pwd, execution_profile: nil)
         Conversation.new(
           workspace_root: workspace_root,
+          execution_profile_context: execution_profile&.prompt_context,
           provider: (@client.current_provider if @client.respond_to?(:current_provider)),
           model: (@client.current_model if @client.respond_to?(:current_model)),
           reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort)),
@@ -780,6 +827,7 @@ module Kward
           reasoning_effort: current_reasoning_effort
         )
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
+        conversation.update_execution_profile_context!(rpc_session.execution_profile.prompt_context) if rpc_session.execution_profile
         rpc_session.session = session
         rpc_session.conversation = conversation
         rebuild_session_tools(rpc_session)
@@ -856,6 +904,30 @@ module Kward
         PromptCommands.expand(input) || input
       end
 
+      def validate_execution_profile(profile)
+        return nil if profile.nil?
+        return profile if profile.is_a?(Kward::Transport::ExecutionProfile)
+
+        raise ArgumentError, "execution_profile must be a Transport::ExecutionProfile"
+      end
+
+      def enforce_execution_profile_options(options, profile)
+        return options unless profile
+
+        options = options.dup
+        case profile.tool_mode
+        when :none
+          options.delete(:disabled_tools)
+          options[:allowed_tools] = []
+        when :allowlist
+          options.delete(:disabled_tools)
+          options[:allowed_tools] = profile.allowed_tools
+        end
+        options[:approval_mode] = "none" if profile.approval_mode == :deny
+        options[:approval_mode] = "ask" if profile.approval_mode == :ask
+        options
+      end
+
       def plugin_command_turn(input, attachments)
         return [nil, ""] unless input.is_a?(String)
         return [nil, ""] unless attachments.empty?
@@ -966,10 +1038,10 @@ module Kward
       # This is the RPC counterpart to the CLI interactive setup: attach plugin
       # context, create a prompt bridge for UI questions/footer output, advertise
       # tools with the workspace guardrail policy, and build the shared `Agent`.
-      def build_rpc_session(store, session, conversation, workspace_root)
+      def build_rpc_session(store, session, conversation, workspace_root, execution_profile: nil)
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
         id = SecureRandom.uuid
-        prompt = PromptBridge.new(server: @server, session_id: id)
+        prompt = PromptBridge.new(notify: method(:notify), session_id: id)
         hook_context = lifecycle_hook_context(conversation: conversation, session: session, workspace_root: workspace_root)
         hook_manager = lifecycle_hook_manager(workspace_root)
         tool_registry = build_tool_registry(workspace_root, prompt, hook_manager: hook_manager, hook_context: hook_context)
@@ -988,6 +1060,7 @@ module Kward
           conversation: conversation,
           agent: agent,
           tool_registry: tool_registry,
+          execution_profile: execution_profile,
           prompt: prompt,
           plugin_output: [],
           queue: Queue.new,
@@ -1020,7 +1093,7 @@ module Kward
       end
 
       def emit_lifecycle_hook_event(event, result)
-        @server.notify("hook/event", {
+        notify("hook/event", {
           event: {
             id: event.id,
             name: event.name,
@@ -1048,7 +1121,7 @@ module Kward
           args: "",
           session: session,
           workspace_root: workspace_root,
-          say_callback: lambda { |message| @server.notify("hook/message", { message: message.to_s }) }
+          say_callback: lambda { |message| notify("hook/message", { message: message.to_s }) }
         )
       end
 
@@ -1189,6 +1262,10 @@ module Kward
       # This method is intentionally the only place that calls `Agent#ask` for RPC
       # turns. Keep event translation near this boundary so CLI rendering and RPC
       # protocol details do not leak into `Agent`.
+      def memory_disabled?(turn)
+        turn.execution_profile&.memory == :none
+      end
+
       def run_turn(rpc_session, turn)
         previous_turn_id = Thread.current[:kward_rpc_turn_id]
         Thread.current[:kward_rpc_turn_id] = turn.id
@@ -1203,7 +1280,7 @@ module Kward
         end
         return unless started
 
-        @server.notify("turn/event", event)
+        notify("turn/event", event)
 
         if turn.cancel_requested
           finish_turn(turn, "canceled")
@@ -1214,15 +1291,17 @@ module Kward
           run_plugin_turn(rpc_session, turn)
         else
           auto_name_session(rpc_session, turn.display_input || turn.input)
-          prepare_memory_context(rpc_session.conversation, turn.input)
+          prepare_memory_context(rpc_session.conversation, turn.input) unless memory_disabled?(turn)
           rpc_session.agent.ask(turn.input, display_input: turn_display_input(turn), cancellation: turn.cancellation, steering: turn.steering, options: turn.options || {}, tool_registry: turn.tool_registry) do |event|
             next if turn.cancel_requested
 
             notify_plugin_transcript_event(rpc_session, event)
             handle_agent_event(turn, event)
           end
-          persist_memory_state(rpc_session)
-          auto_summarize_memory(rpc_session) unless turn.cancel_requested
+          unless memory_disabled?(turn)
+            persist_memory_state(rpc_session)
+            auto_summarize_memory(rpc_session) unless turn.cancel_requested
+          end
           finish_turn(turn, turn.cancel_requested ? "canceled" : "completed")
         end
       rescue Cancellation::CancelledError
@@ -1372,7 +1451,7 @@ module Kward
         end
         return unless event
 
-        @server.notify("turn/event", event)
+        notify("turn/event", event)
         rpc_session = @mutex.synchronize { @sessions[turn.session_id] }
         emit_footer_update(rpc_session) if rpc_session
       end
@@ -1391,19 +1470,19 @@ module Kward
         return if rpc_session.last_footer_text == text
 
         rpc_session.last_footer_text = text
-        @server.notify("ui/footer", { sessionId: rpc_session.id, text: text })
+        notify("ui/footer", { sessionId: rpc_session.id, text: text })
       end
 
       def clear_footer_update(rpc_session)
         return if rpc_session.last_footer_text.to_s.empty?
 
         rpc_session.last_footer_text = ""
-        @server.notify("ui/footer", { sessionId: rpc_session.id, text: "" })
+        notify("ui/footer", { sessionId: rpc_session.id, text: "" })
       end
 
       def emit_turn_event(turn, type, payload)
         event = turn.mutex.synchronize { append_turn_event_locked(turn, type, payload) }
-        @server.notify("turn/event", event)
+        notify("turn/event", event)
         event
       end
 
@@ -1423,7 +1502,7 @@ module Kward
       end
 
       def emit_session_event(rpc_session, type, payload)
-        @server.notify("session/event", {
+        notify("session/event", {
           timestamp: now,
           sessionId: rpc_session.id,
           type: type,

data/lib/kward/session_store.rb

@@ -29,6 +29,9 @@ module Kward
   class SessionStore
     VERSION = 2
     LAST_SESSION_FILENAME = "last_session.json"
+    NON_ACTIVITY_RECORD_TYPES = %w[session session_info system_prompt].freeze
+    RECORD_TYPE_PATTERN = /\A\{\s*"type"\s*:\s*"([^"]+)"/
+    RECORD_TIMESTAMP_PATTERN = /"timestamp"\s*:\s*"([^"]+)"/
 
     SessionInfo = Struct.new(:id, :path, :cwd, :created_at, :modified_at, :name, :first_message, :message_count, :provider, :model, :reasoning_effort, :parent_id, :parent_path, :depth, :is_last, :ancestor_continues, keyword_init: true)
 
@@ -47,6 +50,8 @@ module Kward
       attr_reader :cwd
       # @return [Time] creation timestamp used for sorting and filenames
       attr_reader :created_at
+      # @return [Time] timestamp of the latest persisted conversation activity
+      attr_reader :modified_at
       # @return [String, nil] source session id when this session was cloned or forked
       attr_reader :parent_id
       # @return [String, nil] source session path when this session was cloned or forked
@@ -57,16 +62,18 @@ module Kward
       attr_accessor :leaf_id
 
       # Creates an object for JSONL session persistence.
-      def initialize(store:, id:, path:, cwd:, created_at:, name: nil, parent_id: nil, parent_path: nil, leaf_id: nil)
+      def initialize(store:, id:, path:, cwd:, created_at:, name: nil, parent_id: nil, parent_path: nil, leaf_id: nil, modified_at: nil, system_prompt_hash: nil)
         @store = store
         @id = id
         @path = path
         @cwd = cwd
         @created_at = created_at
+        @modified_at = modified_at || created_at
         @name = name
         @parent_id = parent_id
         @parent_path = parent_path
         @leaf_id = leaf_id
+        @system_prompt_hash = system_prompt_hash
       end
 
       # Installs persistence callbacks on `conversation`.
@@ -89,6 +96,7 @@ module Kward
         record = @store.build_tree_record(@path, "message", @leaf_id, message: message)
         @leaf_id = record[:id]
         @store.append_record(@path, record)
+        mark_modified(record)
       end
 
       # Persists a compaction summary entry and makes it the active leaf.
@@ -96,26 +104,36 @@ module Kward
         record = @store.build_tree_record(@path, "compaction", @leaf_id, message: message)
         @leaf_id = record[:id]
         @store.append_record(@path, record)
+        mark_modified(record)
       end
 
       # Persists normalized tool execution metadata alongside transcript messages.
       def append_tool_execution(tool_call, content)
-        @store.append_record(@path, RPC::ToolEventNormalizer.new(tool_call, content: content).execution_record)
+        record = RPC::ToolEventNormalizer.new(tool_call, content: content).execution_record
+        @store.append_record(@path, record)
+        mark_modified(record)
       end
 
       # Persists the current system prompt as audit metadata when it changes.
       def append_system_prompt_snapshot(system_message, reason: "changed")
-        @store.append_system_prompt_snapshot(@path, system_message, reason: reason)
+        @system_prompt_hash = @store.append_system_prompt_snapshot(
+          @path,
+          system_message,
+          reason: reason,
+          latest_hash: @system_prompt_hash
+        )
       end
 
       # Persists the session memory snapshot used when the session is restored.
       def update_memory_state(session_memories:, last_retrieval: nil)
-        @store.append_record(@path, {
+        record = {
           type: "memory_state",
           timestamp: Time.now.utc.iso8601(3),
           sessionMemories: Array(session_memories),
           lastRetrieval: last_retrieval
-        })
+        }
+        @store.append_record(@path, record)
+        mark_modified(record)
       end
 
       # Persists a user-visible session name without rewriting earlier records.
@@ -131,7 +149,8 @@ module Kward
       # Moves the active leaf to an existing entry so future messages fork there.
       def branch(entry_id)
         @leaf_id = entry_id.to_s.empty? ? nil : entry_id.to_s
-        @store.append_leaf_change(@path, @leaf_id)
+        record = @store.append_leaf_change(@path, @leaf_id)
+        mark_modified(record)
       end
 
       # Clears the active leaf so the next append starts a fresh root branch.
@@ -141,7 +160,8 @@ module Kward
 
       # Persists a display label override for one tree entry.
       def append_label_change(entry_id, label)
-        @store.append_label_change(@path, entry_id, label)
+        record = @store.append_label_change(@path, entry_id, label)
+        mark_modified(record)
       end
 
       # Adds a branch-summary node under `parent_id` and selects it as the leaf.
@@ -149,6 +169,7 @@ module Kward
         record = @store.build_tree_record(@path, "branch_summary", parent_id, fromId: from_id, summary: summary, details: details || {})
         @leaf_id = record[:id]
         @store.append_record(@path, record)
+        mark_modified(record)
         record[:id]
       end
 
@@ -168,6 +189,15 @@ module Kward
       def delete_if_unused
         @store.delete_unused_session(self)
       end
+
+      private
+
+      def mark_modified(record)
+        timestamp = record[:timestamp] || record["timestamp"]
+        @modified_at = Time.iso8601(timestamp.to_s) || Time.now.utc
+      rescue ArgumentError
+        @modified_at = Time.now.utc
+      end
     end
 
     # Creates an object for JSONL session persistence.
@@ -211,7 +241,7 @@ module Kward
       end
       File.chmod(0o600, path)
 
-      Session.new(store: self, id: id, path: path, cwd: @cwd, created_at: created_at, parent_id: parent_id, parent_path: parent_path, leaf_id: nil)
+      Session.new(store: self, id: id, path: path, cwd: @cwd, created_at: created_at, parent_id: parent_id, parent_path: parent_path, leaf_id: nil, modified_at: created_at)
     end
 
     def create_from_conversation(conversation, parent_session: nil)
@@ -291,16 +321,19 @@ module Kward
       )
       restore_tool_output_artifacts(records, conversation)
       conversation.mark_last_entry_compaction! if latest_record_type(records) == "compaction"
+      created_at = parse_time(header["timestamp"]) || File.mtime(resolved_path)
       session = Session.new(
         store: self,
         id: header["id"],
         path: resolved_path,
         cwd: header["cwd"].to_s,
-        created_at: parse_time(header["timestamp"]) || File.mtime(resolved_path),
+        created_at: created_at,
         name: name,
         parent_id: header["parentId"],
         parent_path: header["parentPath"],
-        leaf_id: leaf_id
+        leaf_id: leaf_id,
+        modified_at: session_modified_at(records, fallback: created_at),
+        system_prompt_hash: latest_system_prompt_hash(records)
       )
       session.attach(conversation)
       [session, conversation]
@@ -391,21 +424,25 @@ module Kward
     end
 
     def append_leaf_change(path, leaf_id)
-      append_record(path, {
+      record = {
         type: "leaf",
         timestamp: Time.now.utc.iso8601(3),
         targetId: leaf_id
-      })
+      }
+      append_record(path, record)
+      record
     end
 
     def append_label_change(path, entry_id, label)
-      append_record(path, {
+      record = {
         type: "label",
         id: next_entry_id(path),
         timestamp: Time.now.utc.iso8601(3),
         targetId: entry_id.to_s,
         label: label.to_s.strip.empty? ? nil : label.to_s.strip
-      })
+      }
+      append_record(path, record)
+      record
     end
 
     # @return [Array<Hash>] nested session tree roots for the given session file
@@ -463,18 +500,22 @@ module Kward
       end
     end
 
-    def append_system_prompt_snapshot(path, system_message, reason: "changed")
+    def append_system_prompt_snapshot(path, system_message, reason: "changed", latest_hash: nil)
       content = MessageAccess.content(system_message).to_s
-      return if content.empty?
-      return if latest_system_prompt_hash(records_from_file(path)) == system_prompt_hash(content)
+      return latest_hash if content.empty?
+
+      hash = system_prompt_hash(content)
+      latest_hash ||= latest_system_prompt_hash(records_from_file(path))
+      return latest_hash if latest_hash == hash
 
       append_record(path, {
         type: "system_prompt",
         timestamp: Time.now.utc.iso8601(3),
         reason: reason.to_s,
-        hash: system_prompt_hash(content),
+        hash: hash,
         content: content
       })
+      hash
     end
 
     def self.safe_cwd(cwd)
@@ -483,6 +524,16 @@ module Kward
 
     private
 
+    def session_modified_at(records, fallback:)
+      records.reverse_each do |record|
+        next if NON_ACTIVITY_RECORD_TYPES.include?(record["type"].to_s)
+
+        timestamp = parse_time(record["timestamp"])
+        return timestamp if timestamp
+      end
+      fallback
+    end
+
     def latest_system_prompt_hash(records)
       records.reverse_each do |record|
         next unless record["type"] == "system_prompt"
@@ -751,7 +802,7 @@ module Kward
     end
 
     def next_entry_id(_path)
-      SecureRandom.hex(4)
+      SecureRandom.hex(16)
     end
 
     def message_entry_id(message)
@@ -797,7 +848,7 @@ module Kward
       keep_empty_paths = Array(keep_empty_path).filter_map do |path|
         File.expand_path(path) unless path.to_s.empty?
       end
-      paths = Dir.glob(File.join(session_dir, "*.jsonl")).sort_by { |path| session_file_mtime(path) }.reverse
+      paths = Dir.glob(File.join(session_dir, "*.jsonl")).sort_by { |path| session_file_activity_time(path) }.reverse
       sessions = []
 
       paths.each do |path|
@@ -824,8 +875,16 @@ module Kward
       false
     end
 
-    def session_file_mtime(path)
-      File.mtime(path)
+    def session_file_activity_time(path)
+      latest_timestamp = nil
+      File.foreach(path) do |line|
+        type = line[RECORD_TYPE_PATTERN, 1]
+        next if NON_ACTIVITY_RECORD_TYPES.include?(type.to_s)
+
+        timestamp = line[RECORD_TIMESTAMP_PATTERN, 1]
+        latest_timestamp = timestamp if timestamp
+      end
+      parse_time(latest_timestamp) || File.mtime(path)
     rescue StandardError
       Time.at(0)
     end
@@ -893,13 +952,14 @@ module Kward
       runtime = session_runtime(records, header)
       first_message = messages.find { |message| ["user", "compactionSummary"].include?(message_role(message)) }
       stats = File.stat(path)
+      created_at = parse_time(header["timestamp"]) || stats.mtime
 
       SessionInfo.new(
         id: header["id"],
         path: path,
         cwd: header["cwd"].to_s,
-        created_at: parse_time(header["timestamp"]) || stats.mtime,
-        modified_at: stats.mtime,
+        created_at: created_at,
+        modified_at: session_modified_at(records, fallback: stats.mtime),
         name: name,
         first_message: first_message ? message_text(first_message) : "",
         message_count: messages.count { |message| ["user", "assistant", "tool", "toolResult", "compactionSummary"].include?(message_role(message)) },

data/lib/kward/tab_driver.rb

@@ -3,11 +3,12 @@ module Kward
   # Adapts a session-backed agent to the tab runtime interface. Plugin tab
   # drivers implement the same small surface without becoming Kward sessions.
   class SessionTabDriver
-    attr_reader :session, :agent
+    attr_reader :session, :agent, :worktree
 
-    def initialize(session:, agent:)
+    def initialize(session:, agent:, worktree: nil)
       @session = session
       @agent = agent
+      @worktree = worktree
     end
 
     def messages
@@ -26,7 +27,9 @@ module Kward
     end
 
     def descriptor
-      { "kind" => "session", "session_path" => session.path }
+      descriptor = { "kind" => "session", "session_path" => session.path }
+      descriptor["worktree"] = worktree.descriptor if worktree
+      descriptor
     end
 
     def session?