kward 0.72.0 → 0.73.0

data/lib/kward/rpc/server.rb

@@ -44,13 +44,20 @@ module Kward
         invalid_params: -32_602,
         internal_error: -32_603
       }.freeze
+      PROTOCOL_METHODS = ["initialize", "shutdown"].freeze
+      WORKSPACE_METHODS = ["workspace/validate", "workspace/info"].freeze
+      TOOL_METHODS = ["tools/list"].freeze
+      PROMPT_METHODS = ["prompts/list", "prompts/expand"].freeze
       SESSION_METHODS = [
         "sessions/create", "sessions/resume", "sessions/list", "sessions/rename",
         "sessions/clone", "sessions/compact", "sessions/forkMessages", "sessions/fork",
         "sessions/tree", "sessions/tree/setLabel", "sessions/tree/navigate",
         "sessions/export", "sessions/delete", "sessions/close", "sessions/transcript"
       ].freeze
+      TURN_METHODS = ["turns/start", "turns/cancel", "turns/status", "turns/events"].freeze
       MODEL_METHODS = ["models/list", "models/current", "models/set", "reasoning/set"].freeze
+      RUNTIME_METHODS = ["runtime/state", "runtime/stats"].freeze
+      RUNTIME_SETTING_METHODS = ["runtime/updateSetting", "runtime/reload"].freeze
       AUTH_METHODS = [
         "auth/status", "auth/providers", "auth/loginWithApiKey", "auth/logoutProvider",
         "auth/loginWithOAuth", "auth/startOpenAILogin", "auth/submitOpenAICode", "auth/loginStatus"
@@ -62,6 +69,36 @@ module Kward
         "memory/why", "memory/summarize"
       ].freeze
       WORKER_METHODS = ["workers/list", "workers/show"].freeze
+      COMMAND_METHODS = ["commands/list", "commands/run"].freeze
+      STARTUP_RESOURCE_METHODS = ["resources/startup"].freeze
+      CONFIG_METHODS = ["config/read", "config/update"].freeze
+      LOGGING_METHODS = ["logging/stats", "logging/tokenCsv"].freeze
+      UI_METHODS = ["ui/answerQuestion"].freeze
+      SESSION_EVENT_NOTIFICATION = "session/event"
+      SESSION_UPDATED_NOTIFICATION = "session/updated"
+      TURN_EVENT_NOTIFICATION = "turn/event"
+      UI_QUESTION_NOTIFICATION = "ui/question"
+      UI_FOOTER_NOTIFICATION = "ui/footer"
+      METHOD_GROUPS = {
+        protocol: PROTOCOL_METHODS,
+        workspace: WORKSPACE_METHODS,
+        tools: TOOL_METHODS,
+        prompts: PROMPT_METHODS,
+        sessions: SESSION_METHODS,
+        turns: TURN_METHODS,
+        models: MODEL_METHODS,
+        runtime: RUNTIME_METHODS,
+        runtime_settings: RUNTIME_SETTING_METHODS,
+        auth: AUTH_METHODS,
+        memory: MEMORY_METHODS,
+        workers: WORKER_METHODS,
+        commands: COMMAND_METHODS,
+        startup_resources: STARTUP_RESOURCE_METHODS,
+        config: CONFIG_METHODS,
+        logging: LOGGING_METHODS,
+        ui: UI_METHODS
+      }.freeze
+      RPC_METHODS = METHOD_GROUPS.values.flatten.freeze
 
       # Creates the RPC server and its stateful managers.
       def initialize(input: $stdin, output: $stdout, error_output: $stderr, client: Client.new, experimental_workers: false)
@@ -154,145 +191,145 @@ module Kward
       def dispatch(method, params)
         params = stringify_keys(params || {})
         case method
-        when "initialize"
+        when PROTOCOL_METHODS[0]
           initialize_result
-        when "shutdown"
+        when PROTOCOL_METHODS[1]
           @shutdown = true
           { ok: true }
-        when "workspace/validate"
+        when WORKSPACE_METHODS[0]
           { root: @session_manager.validate_workspace_root(params["workspaceRoot"] || Dir.pwd) }
-        when "workspace/info"
+        when WORKSPACE_METHODS[1]
           workspace_info(params["workspaceRoot"] || Dir.pwd)
-        when "tools/list"
+        when TOOL_METHODS[0]
           { tools: ToolRegistry.new(workspace: configured_workspace).schemas }
-        when "prompts/list"
+        when PROMPT_METHODS[0]
           prompts_list
-        when "prompts/expand"
+        when PROMPT_METHODS[1]
           prompts_expand(params)
-        when "models/list"
+        when MODEL_METHODS[0]
           models_list
-        when "models/current"
+        when MODEL_METHODS[1]
           models_current
-        when "models/set"
+        when MODEL_METHODS[2]
           models_set(params)
-        when "reasoning/set"
+        when MODEL_METHODS[3]
           reasoning_set(params)
-        when "runtime/state"
+        when RUNTIME_METHODS[0]
           @session_manager.runtime_state(session_id: params.fetch("sessionId"))
-        when "runtime/stats"
+        when RUNTIME_METHODS[1]
           @session_manager.runtime_stats(session_id: params.fetch("sessionId"))
-        when "runtime/updateSetting"
+        when RUNTIME_SETTING_METHODS[0]
           runtime_update_setting(params)
-        when "runtime/reload"
+        when RUNTIME_SETTING_METHODS[1]
           runtime_reload(params)
-        when "commands/list"
+        when COMMAND_METHODS[0]
           commands_list(params)
-        when "commands/run"
+        when COMMAND_METHODS[1]
           commands_run(params)
-        when "resources/startup"
+        when STARTUP_RESOURCE_METHODS[0]
           startup_resources(params)
-        when "config/read"
+        when CONFIG_METHODS[0]
           { path: @config_manager.config_path, config: @config_manager.read(redacted: params.fetch("redacted", true)) }
-        when "config/update"
+        when CONFIG_METHODS[1]
           config_update(params)
-        when "logging/stats"
+        when LOGGING_METHODS[0]
           logging_stats(params)
-        when "logging/tokenCsv"
+        when LOGGING_METHODS[1]
           logging_token_csv(params)
-        when "memory/status"
+        when MEMORY_METHODS[0]
           @session_manager.memory_status
-        when "memory/enable"
+        when MEMORY_METHODS[1]
           @session_manager.memory_enable
-        when "memory/disable"
+        when MEMORY_METHODS[2]
           @session_manager.memory_disable
-        when "memory/autoSummary/enable"
+        when MEMORY_METHODS[3]
           @session_manager.memory_auto_summary_enable
-        when "memory/autoSummary/disable"
+        when MEMORY_METHODS[4]
           @session_manager.memory_auto_summary_disable
-        when "memory/list"
+        when MEMORY_METHODS[5]
           @session_manager.memory_list(include_inactive: params["includeInactive"] || false, workspace_root: params["workspaceRoot"] || Dir.pwd)
-        when "memory/add"
+        when MEMORY_METHODS[6]
           @session_manager.memory_add(text: params.fetch("text"), scope: params["scope"], tags: params["tags"] || [])
-        when "memory/addCore"
+        when MEMORY_METHODS[7]
           @session_manager.memory_add_core(text: params.fetch("text"), scope: params["scope"], tags: params["tags"] || [])
-        when "memory/forget"
+        when MEMORY_METHODS[8]
           @session_manager.memory_forget(id: params.fetch("id"))
-        when "memory/promote"
+        when MEMORY_METHODS[9]
           @session_manager.memory_promote(id: params.fetch("id"))
-        when "memory/relax"
+        when MEMORY_METHODS[10]
           @session_manager.memory_relax(id: params.fetch("id"), workspace_root: params["workspaceRoot"] || Dir.pwd)
-        when "memory/inspect"
+        when MEMORY_METHODS[11]
           @session_manager.memory_inspect
-        when "memory/why"
+        when MEMORY_METHODS[12]
           @session_manager.memory_why(session_id: params["sessionId"])
-        when "memory/summarize"
+        when MEMORY_METHODS[13]
           @session_manager.memory_summarize(session_id: params.fetch("sessionId"))
-        when "workers/list"
+        when WORKER_METHODS[0]
           require_experimental_workers!
           workers_list(params)
-        when "workers/show"
+        when WORKER_METHODS[1]
           require_experimental_workers!
           workers_show(params)
-        when "auth/status"
+        when AUTH_METHODS[0]
           @auth_manager.status
-        when "auth/providers"
+        when AUTH_METHODS[1]
           @auth_manager.providers
-        when "auth/loginWithApiKey"
+        when AUTH_METHODS[2]
           auth_login_with_api_key(params)
-        when "auth/logoutProvider"
+        when AUTH_METHODS[3]
           auth_logout_provider(params)
-        when "auth/loginWithOAuth"
+        when AUTH_METHODS[4]
           @auth_manager.login_with_oauth(provider_id: params.fetch("providerId"), timeout_seconds: params["timeoutSeconds"] || 120)
-        when "auth/startOpenAILogin"
+        when AUTH_METHODS[5]
           @auth_manager.start_openai_login(timeout_seconds: params["timeoutSeconds"] || 120)
-        when "auth/submitOpenAICode"
+        when AUTH_METHODS[6]
           @auth_manager.submit_openai_code(login_id: params.fetch("loginId"), code: params.fetch("code"))
-        when "auth/loginStatus"
+        when AUTH_METHODS[7]
           @auth_manager.login_status(login_id: params.fetch("loginId"))
-        when "sessions/create"
+        when SESSION_METHODS[0]
           @session_manager.create_session(workspace_root: params["workspaceRoot"] || Dir.pwd, name: params["name"], resume_last: params["resumeLast"] != false)
-        when "sessions/resume"
+        when SESSION_METHODS[1]
           @session_manager.resume_session(path: params.fetch("path"), workspace_root: params["workspaceRoot"])
-        when "sessions/list"
+        when SESSION_METHODS[2]
           { sessions: @session_manager.list_sessions(workspace_root: params["workspaceRoot"] || Dir.pwd, limit: params["limit"], current_session_path: params["currentSessionPath"]) }
-        when "sessions/rename"
+        when SESSION_METHODS[3]
           @session_manager.rename_session(session_id: params.fetch("sessionId"), name: params["name"])
-        when "sessions/clone"
+        when SESSION_METHODS[4]
           @session_manager.clone_session(session_id: params.fetch("sessionId"))
-        when "sessions/compact"
+        when SESSION_METHODS[5]
           @session_manager.compact_session(session_id: params.fetch("sessionId"), custom_instructions: params["customInstructions"] || "")
-        when "sessions/forkMessages"
+        when SESSION_METHODS[6]
           @session_manager.fork_messages(session_id: params.fetch("sessionId"))
-        when "sessions/fork"
+        when SESSION_METHODS[7]
           @session_manager.fork_session(session_id: params.fetch("sessionId"), entry_id: params.fetch("entryId"))
-        when "sessions/tree"
+        when SESSION_METHODS[8]
           @session_manager.session_tree(session_id: params.fetch("sessionId"))
-        when "sessions/tree/setLabel"
+        when SESSION_METHODS[9]
           @session_manager.set_tree_label(session_id: params.fetch("sessionId"), entry_id: params.fetch("entryId"), label: params["label"])
-        when "sessions/tree/navigate"
+        when SESSION_METHODS[10]
           @session_manager.navigate_tree(session_id: params.fetch("sessionId"), entry_id: params.fetch("entryId"), summarize: params["summarize"], custom_instructions: params["customInstructions"])
-        when "sessions/export"
+        when SESSION_METHODS[11]
           @session_manager.export_session(session_id: params.fetch("sessionId"), path: params["path"], format: params["format"])
-        when "sessions/delete"
+        when SESSION_METHODS[12]
           @session_manager.delete_session(session_id: params.fetch("sessionId"))
-        when "sessions/close"
+        when SESSION_METHODS[13]
           @session_manager.close_session(session_id: params.fetch("sessionId"))
-        when "sessions/transcript"
+        when SESSION_METHODS[14]
           @session_manager.transcript(session_id: params.fetch("sessionId"))
-        when "turns/start"
+        when TURN_METHODS[0]
           @session_manager.start_turn(
             session_id: params.fetch("sessionId"),
             input: params.fetch("input"),
             streaming_behavior: params["streamingBehavior"],
             attachments: params["attachments"] || []
           )
-        when "turns/cancel"
+        when TURN_METHODS[1]
           @session_manager.cancel_turn(turn_id: params.fetch("turnId"))
-        when "turns/status"
+        when TURN_METHODS[2]
           @session_manager.turn_status(turn_id: params.fetch("turnId"))
-        when "turns/events"
+        when TURN_METHODS[3]
           @session_manager.turn_events(turn_id: params.fetch("turnId"), after_sequence: params["afterSequence"] || 0)
-        when "ui/answerQuestion"
+        when UI_METHODS[0]
           @session_manager.answer_question(session_id: params.fetch("sessionId"), question_request_id: params.fetch("questionRequestId"), answers: params.fetch("answers"))
         else
           raise NoMethodError, method
@@ -324,13 +361,13 @@ module Kward
             mode: "explicit",
             persistence: "jsonl",
             methods: SESSION_METHODS,
-            startupResume: { supported: true, method: "sessions/create", parameter: "resumeLast", default: session_auto_resume_enabled?, immediateTranscript: true, sessionActivePersonaLabel: true },
+            startupResume: { supported: true, method: SESSION_METHODS[0], parameter: "resumeLast", default: session_auto_resume_enabled?, immediateTranscript: true, sessionActivePersonaLabel: true },
             list: { supported: true, source: "rpc", ancestry: true, treeFields: true },
-            fork: { supported: true, methods: ["sessions/forkMessages", "sessions/fork"], entryIdFormat: "entry-id", selectedMessage: "excludedFromForkComposerTextReturned" },
-            compact: { supported: true, method: "sessions/compact", notification: "session/event", events: ["compactionStart", "compactionEnd"] },
+            fork: { supported: true, methods: SESSION_METHODS.values_at(6, 7), entryIdFormat: "entry-id", selectedMessage: "excludedFromForkComposerTextReturned" },
+            compact: { supported: true, method: SESSION_METHODS[5], notification: SESSION_EVENT_NOTIFICATION, events: ["compactionStart", "compactionEnd"] },
             import: { supported: false },
-            tree: { supported: true, method: "sessions/tree", labels: true, labelTimestamps: true, navigate: true, summarize: true, shape: "tauren-tree-items-v1" },
-            updates: { supported: false, notification: "session/updated" }
+            tree: { supported: true, method: SESSION_METHODS[8], labels: true, labelTimestamps: true, navigate: true, summarize: true, shape: "tauren-tree-items-v1" },
+            updates: { supported: false, notification: SESSION_UPDATED_NOTIFICATION }
           },
           turns: {
             mode: "async",
@@ -349,19 +386,19 @@ module Kward
             eventReplay: { behavior: "recent-in-memory", persisted: false, limit: SessionManager::RECENT_EVENT_LIMIT }
           },
           events: {
-            notification: "turn/event",
+            notification: TURN_EVENT_NOTIFICATION,
             assistantText: "assistantDelta",
             reasoning: { start: false, delta: true, end: false },
             modelRetry: { supported: true, event: "modelRetry" },
             steering: { supported: @session_manager.in_flight_steer_supported?, event: "turnSteered", mode: @session_manager.in_flight_steer_supported? ? "native" : "unsupported" },
-            tools: { call: true, update: false, result: true, normalizedMetadata: true, diffs: true, changedFiles: false, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
+            tools: { call: true, update: false, result: true, normalizedMetadata: true, diffs: true, changedFiles: true, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
             errors: true,
             sessionUpdates: false
           },
           attachments: {
             input: {
               supported: true,
-              method: "turns/start",
+              method: TURN_METHODS[0],
               encoding: "base64",
               mimeTypes: SessionManager::RPC_IMAGE_MIME_TYPES,
               maxBytes: SessionManager::RPC_ATTACHMENT_MAX_BYTES
@@ -376,13 +413,13 @@ module Kward
           },
           runtime: {
             supported: true,
-            methods: ["runtime/state", "runtime/stats"],
+            methods: RUNTIME_METHODS,
             state: { supported: true },
             stats: { messageCounts: true, tokens: false, cost: false, contextUsage: true, contextUsageEstimated: true }
           },
           runtimeSettings: {
             supported: true,
-            methods: ["runtime/updateSetting", "runtime/reload"],
+            methods: RUNTIME_SETTING_METHODS,
             settings: ["defaultModel", "defaultThinkingLevel"]
           },
           auth: {
@@ -396,18 +433,19 @@ module Kward
           },
           memory: { supported: true, optIn: true, defaultEnabled: false, autoSummaryDefaultEnabled: false, promptInjection: "interactive", storage: { core: "json", soft: "jsonl", events: "jsonl" }, methods: MEMORY_METHODS },
           workers: workers_capability,
-          commands: { supported: true, methods: ["commands/list", "commands/run"], method: "commands/list", runMethod: "commands/run", sources: ["builtin", "prompt", "skill", "plugin"], executableSources: ["builtin", "plugin"] },
-          startupResources: { supported: true, method: "resources/startup" },
+          commands: { supported: true, methods: COMMAND_METHODS, method: COMMAND_METHODS[0], runMethod: COMMAND_METHODS[1], sources: ["builtin", "prompt", "skill", "plugin"], executableSources: ["builtin", "plugin"] },
+          startupResources: { supported: true, method: STARTUP_RESOURCE_METHODS.first },
           starterPack: { supported: false, reason: "cliOnlyInstallCommand" },
           shell: { supported: false, reason: "interactiveTuiOnly" },
+          scratchpad: { supported: false, reason: "interactiveTuiOnly" },
           extensionUi: {
-            question: { supported: true, notification: "ui/question", method: "ui/answerQuestion", maxQuestions: 4, multiSelect: false, preview: false },
+            question: { supported: true, notification: UI_QUESTION_NOTIFICATION, method: UI_METHODS.first, maxQuestions: 4, multiSelect: false, preview: false },
             select: false,
             confirm: false,
             input: false,
             editor: false,
             widgets: false,
-            footer: { supported: true, notification: "ui/footer" },
+            footer: { supported: true, notification: UI_FOOTER_NOTIFICATION },
             custom: false,
             terminalInput: false
           },
@@ -425,9 +463,9 @@ module Kward
           logging: {
             supported: true,
             defaultEnabled: false,
-            methods: ["logging/stats", "logging/tokenCsv"],
-            stats: { supported: true, method: "logging/stats", defaultRange: TelemetryStats::DEFAULT_RANGE, units: %w[minutes hours days weeks months years] },
-            usageCsv: { supported: true, method: "logging/tokenCsv", defaultRange: TelemetryStats::DEFAULT_RANGE, buckets: %w[second minute hour day week month year] },
+            methods: LOGGING_METHODS,
+            stats: { supported: true, method: LOGGING_METHODS[0], defaultRange: TelemetryStats::DEFAULT_RANGE, units: %w[minutes hours days weeks months years] },
+            usageCsv: { supported: true, method: LOGGING_METHODS[1], defaultRange: TelemetryStats::DEFAULT_RANGE, buckets: %w[second minute hour day week month year] },
             config: "logging",
             envPrefix: "KWARD_LOGGING",
             directory: File.join(ConfigFiles.config_dir, "logs"),
@@ -641,6 +679,15 @@ module Kward
       end
 
       def provider_model_from(value)
+        if value.is_a?(Hash)
+          provider = value["provider"] || value[:provider] || @session_manager.current_model[:provider]
+          model = value["model"] || value[:model] || value["id"] || value[:id]
+          model = model.to_s.strip
+          raise ArgumentError, "Model must be a non-empty string" if model.empty?
+
+          return [provider, model]
+        end
+
         text = value.to_s.strip
         raise ArgumentError, "Model must be a non-empty string" if text.empty?
 

data/lib/kward/rpc/session_manager.rb

@@ -18,6 +18,7 @@ require_relative "../model/model_info"
 require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../session_store"
+require_relative "../session_naming"
 require_relative "../session_trash"
 require_relative "../steering"
 require_relative "../tools/tool_call"
@@ -26,6 +27,7 @@ require_relative "../transcript_export"
 require_relative "../workspace"
 require_relative "attachment_normalizer"
 require_relative "config_manager"
+require_relative "memory_methods"
 require_relative "prompt_bridge"
 require_relative "runtime_payloads"
 require_relative "session_metrics"
@@ -51,6 +53,8 @@ module Kward
     # `ToolRegistry`. This class should coordinate those pieces rather than own
     # their low-level mechanics.
     class SessionManager
+      include MemoryMethods
+
       RECENT_EVENT_LIMIT = 1_000
       RPC_ATTACHMENT_MAX_BYTES = AttachmentNormalizer::MAX_BYTES
       RPC_IMAGE_MIME_TYPES = AttachmentNormalizer::IMAGE_MIME_TYPES
@@ -391,78 +395,6 @@ module Kward
         run_plugin_command(session_id: session_id, command: name, arguments: arguments)
       end
 
-      def memory_manager
-        Memory::Manager.for_config_dir(@config_dir)
-      end
-
-      def memory_status
-        manager = memory_manager
-        { enabled: manager.enabled?, autoSummary: manager.auto_summary_enabled?, paths: manager.paths }
-      end
-
-      def memory_enable
-        memory_manager.enable
-        { enabled: true }
-      end
-
-      def memory_disable
-        memory_manager.disable
-        { enabled: false }
-      end
-
-      def memory_auto_summary_enable
-        memory_manager.auto_summary_enable
-        { autoSummary: true }
-      end
-
-      def memory_auto_summary_disable
-        memory_manager.auto_summary_disable
-        { autoSummary: false }
-      end
-
-      def memory_list(include_inactive: false, workspace_root: Dir.pwd)
-        memory_manager.hierarchy(include_inactive: include_inactive, workspace_root: workspace_root)
-      end
-
-      def memory_add(text:, scope: nil, tags: [])
-        { memory: memory_manager.add_soft(text, scope: scope || "global", tags: tags) }
-      end
-
-      def memory_add_core(text:, scope: nil, tags: [])
-        { memory: memory_manager.add_core(text, scope: scope || "global", tags: tags) }
-      end
-
-      def memory_forget(id:)
-        { forgotten: memory_manager.forget_memory(id) }
-      end
-
-      def memory_promote(id:)
-        { memory: memory_manager.promote_memory(id) }
-      end
-
-      def memory_relax(id:, workspace_root: Dir.pwd)
-        { memory: memory_manager.relax_core(id, workspace_root: workspace_root) }
-      end
-
-      def memory_inspect
-        memory_manager.inspect_memory
-      end
-
-      def memory_why(session_id: nil)
-        if session_id
-          rpc_session = fetch_session(session_id)
-          return rpc_session.conversation.last_memory_retrieval || memory_manager.explain_retrieval
-        end
-        memory_manager.explain_retrieval
-      end
-
-      def memory_summarize(session_id:)
-        rpc_session = fetch_session(session_id)
-        records = memory_manager.summarize_conversation(rpc_session.conversation, client: @client)
-        persist_memory_state(rpc_session)
-        { memories: records }
-      end
-
       def run_plugin_command(session_id:, command:, arguments: "")
         rpc_session = fetch_session(session_id)
         command = plugin_registry.command_for(command.to_s.delete_prefix("/")) || raise(ArgumentError, "Unknown plugin command: #{command}")
@@ -613,11 +545,15 @@ module Kward
       end
 
       def refresh_session_runtime_contexts
+        provider = current_model[:provider]
         model = current_model_id
         reasoning_effort = current_reasoning_effort
         sessions = @mutex.synchronize { @sessions.values }
         sessions.each do |rpc_session|
-          rpc_session.conversation.update_runtime_context!(provider: current_model[:provider], model: model, reasoning_effort: reasoning_effort)
+          conversation = rpc_session.conversation
+          runtime_changed = [conversation.provider, conversation.model, conversation.reasoning_effort] != [provider, model, reasoning_effort]
+          conversation.update_runtime_context!(provider: provider, model: model, reasoning_effort: reasoning_effort)
+          conversation.persist_runtime_context! if runtime_changed
         end
       end
 
@@ -1036,7 +972,7 @@ module Kward
       end
 
       def default_session_name(input)
-        input.to_s.gsub(/\s+/, " ").strip.slice(0, 120).to_s
+        SessionNaming.default_name(input)
       end
 
       def turn_display_input(turn)

data/lib/kward/rpc/tool_metadata.rb

@@ -75,6 +75,17 @@ module Kward
         index ? text.to_s[index..] : nil
       end
 
+      def changed_files_from_result(text, matching_call = nil)
+        path = matching_call&.dig(:arguments, :path) || matching_call&.dig(:arguments, "path")
+        return [path] if path
+
+        if (match = text.to_s.match(/\A(?:Wrote \d+ bytes to|Edited)\s+([^:\n]+)/))
+          [match[1].strip]
+        else
+          []
+        end
+      end
+
       def error_result?(text)
         text.to_s.start_with?("Error:", "Declined:", "Cancelled.")
       end

data/lib/kward/rpc/transcript_normalizer.rb

@@ -106,7 +106,7 @@ module Kward
           type: "toolCall",
           id: ToolCall.id(tool_call),
           name: normalize_tool_name(raw_name) || raw_name,
-          arguments: normalize_tool_arguments(raw_name, ToolCall.raw_arguments(tool_call))
+          arguments: ToolMetadata.normalize_tool_args(raw_name, ToolCall.parse_arguments(ToolCall.raw_arguments(tool_call)))
         }.compact
       end
 
@@ -235,7 +235,7 @@ module Kward
           type: "toolCall",
           id: ToolCall.value(part, :id),
           name: normalize_tool_name(raw_name) || raw_name,
-          arguments: normalize_tool_arguments(raw_name, arguments)
+          arguments: ToolMetadata.normalize_tool_args(raw_name, ToolCall.parse_arguments(arguments))
         }.compact
       end
 
@@ -244,10 +244,10 @@ module Kward
         details = explicit_details.is_a?(Hash) ? safe_details(explicit_details) : {}
         text = content_text(content)
 
-        diff = details[:diff] || details["diff"] || extract_unified_diff(text)
+        diff = details[:diff] || details["diff"] || ToolMetadata.extract_unified_diff(text)
         details[:diff] = diff if diff
 
-        changed_files = details[:changedFiles] || details["changedFiles"] || changed_files_from_result(text, matching_call)
+        changed_files = details[:changedFiles] || details["changedFiles"] || ToolMetadata.changed_files_from_result(text, matching_call)
         details[:changedFiles] = changed_files if changed_files && !changed_files.empty?
 
         details
@@ -262,21 +262,6 @@ module Kward
         allowed
       end
 
-      def extract_unified_diff(text)
-        ToolMetadata.extract_unified_diff(text)
-      end
-
-      def changed_files_from_result(text, matching_call)
-        path = matching_call&.dig(:arguments, :path) || matching_call&.dig(:arguments, "path")
-        return [path] if path
-
-        if (match = text.match(/\A(?:Wrote \d+ bytes to|Edited)\s+([^:\n]+)/))
-          [match[1].strip]
-        else
-          []
-        end
-      end
-
       def error_tool_result?(message, content)
         return ToolCall.value(message, :isError) if has_key?(message, :isError)
         return ToolCall.value(message, :is_error) if has_key?(message, :is_error)
@@ -299,26 +284,6 @@ module Kward
         ToolMetadata.normalize_tool_name(name)
       end
 
-      def normalize_tool_arguments(name, arguments)
-        args = ToolCall.parse_arguments(arguments)
-        case name.to_s
-        when "edit_file", "edit"
-          ToolMetadata.normalize_tool_args(name, args)
-        when "run_shell_command", "bash"
-          normalize_bash_args(args)
-        else
-          ToolCall.camelize_args(args)
-        end
-      end
-
-      def normalize_bash_args(args)
-        normalized = ToolCall.camelize_args(args)
-        timeout = ToolCall.value(args, :timeoutSeconds) || ToolCall.value(args, :timeout_seconds)
-        normalized[:timeoutSeconds] = timeout if timeout
-        normalized.delete(:timeout_seconds)
-        normalized
-      end
-
       def normalize_mime_type(mime_type)
         mime_type.to_s.downcase.sub("image/jpg", "image/jpeg")
       end

data/lib/kward/scratchpad_runner.rb

@@ -0,0 +1,56 @@
+require "open3"
+require "rbconfig"
+require "tempfile"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Executes scratchpad buffers and returns transformed buffer content.
+  module ScratchpadRunner
+    RUBY_END_MARKER_PATTERN = /^__END__\n?/.freeze
+
+    Result = Struct.new(:buffer, :exit_status, keyword_init: true)
+
+    module_function
+
+    def run(language, content)
+      case language&.to_sym
+      when :ruby
+        run_ruby(content)
+      else
+        raise ArgumentError, "Scratchpad language #{language.inspect} is not runnable"
+      end
+    end
+
+    def run_ruby(content)
+      content = content.to_s
+      output, status = capture_ruby_output(content)
+      Result.new(buffer: ruby_buffer_with_output(content, output, status.exitstatus), exit_status: status.exitstatus)
+    end
+
+    def capture_ruby_output(content)
+      Tempfile.create(["kward-scratchpad", ".rb"]) do |file|
+        file.write(content)
+        file.flush
+        Open3.capture2e(RbConfig.ruby, file.path)
+      end
+    end
+
+    def ruby_buffer_with_output(content, output, exit_status)
+      output = output.to_s
+      output += "\n" unless output.empty? || output.end_with?("\n")
+      output += "[exit status: #{exit_status}]\n" unless exit_status.to_i.zero?
+
+      if (match = content.match(RUBY_END_MARKER_PATTERN))
+        "#{content[0...match.begin(0)]}__END__\n#{output}"
+      else
+        "#{content}#{ruby_end_separator(content)}__END__\n#{output}"
+      end
+    end
+
+    def ruby_end_separator(content)
+      return "" if content.empty?
+
+      content.end_with?("\n") ? "\n" : "\n\n"
+    end
+  end
+end