kward 0.71.0 → 0.73.0

data/lib/kward/prompts/commands.rb

@@ -25,6 +25,15 @@ module Kward
       { name: "model", description: "Select the default model.", argument_hint: "" },
       { name: "reasoning", description: "Select reasoning effort.", argument_hint: "" },
       { name: "reload", description: "Reload installed plugins.", argument_hint: "" },
+      { name: "workers", description: "Open the worker pipeline.", argument_hint: "[new|do <task>]" },
+      { name: "queue", description: "Manage the tab-backed worker queue.", argument_hint: "[add|list|open|run|suspend|resume]" },
+      { name: "git", description: "Review uncommitted changes and commit them.", argument_hint: "" },
+      { name: "diff", description: "Open the file changes recorded in this session.", argument_hint: "" },
+      { name: "files", description: "Browse project files.", argument_hint: "" },
+      { name: "shell", description: "Open the embedded Kward shell.", argument_hint: "" },
+      { name: "scratchpad", description: "Open an unsaved editor buffer.", argument_hint: "[text|markdown|ruby]" },
+      { name: "pty", description: "Run a command in an interactive PTY passthrough session.", argument_hint: "<command>" },
+      { name: "tab", description: "Manage tabs.", argument_hint: "[1-n|move|close|new|name]" },
       { name: "status", description: "Show the current status message.", argument_hint: "" },
       { name: "stats", description: "Show telemetry logging stats.", argument_hint: "[range]" },
       { name: "memory", description: "Inspect and manage Kward memory.", argument_hint: "[enable|disable|auto-summary|core|add|list|forget|promote|relax|inspect|why|summarize]" }

data/lib/kward/prompts.rb

@@ -35,6 +35,8 @@ module Kward
         You are Kward, a concise practical CLI coding agent. Use tools to understand and modify software projects. Inspect files before changing them, make the smallest correct change, preserve existing style, and summarize what changed. Be honest about limitations.
 
         For web research, use web_search to discover sources, fetch_content for important human-readable pages, and fetch_raw for machine-readable resources such as JSON, YAML, XML, RSS, OpenAPI specs, and plain text. Prefer official or primary sources and cite or mention the URLs you relied on.
+
+        Manage code context deliberately. Prefer context_for_task, summarize_file_structure, and read_file mode="outline"/"preview" before broad reads. Escalate to read_file mode="range" for exact lines, and use mode="full" only when focused context is insufficient. Use context_budget_stats when asked about context savings.
       PROMPT
     end
 

data/lib/kward/rpc/memory_methods.rb

@@ -0,0 +1,83 @@
+require_relative "../memory/manager"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # JSON-RPC backend namespace used by UI clients.
+  module RPC
+    # Memory-related RPC method implementations mixed into SessionManager.
+    module MemoryMethods
+      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
+    end
+  end
+end

data/lib/kward/rpc/server.rb

@@ -5,6 +5,7 @@ require_relative "../memory/manager"
 require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../tools/registry"
+require_relative "../workers"
 require_relative "../workspace"
 require_relative "../telemetry/logger"
 require_relative "../telemetry/stats"
@@ -43,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"
@@ -60,14 +68,48 @@ module Kward
         "memory/forget", "memory/promote", "memory/relax", "memory/inspect",
         "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)
+      def initialize(input: $stdin, output: $stdout, error_output: $stderr, client: Client.new, experimental_workers: false)
         @transport = Transport.new(input: input, output: output)
         @error_output = error_output
+        @client = client
         @config_manager = ConfigManager.new
         @session_manager = SessionManager.new(server: self, client: client, config_manager: @config_manager)
         @auth_manager = AuthManager.new(server: self, config_manager: @config_manager)
+        @worker_store = Workers::Store.new
+        @experimental_workers = experimental_workers
         @shutdown = false
       end
 
@@ -88,7 +130,7 @@ module Kward
           end
         end
       ensure
-        @session_manager.cleanup_unused_sessions
+        @session_manager.shutdown_sessions
       end
 
       # Sends a redacted JSON-RPC notification to the client.
@@ -149,139 +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 "auth/status"
+        when WORKER_METHODS[0]
+          require_experimental_workers!
+          workers_list(params)
+        when WORKER_METHODS[1]
+          require_experimental_workers!
+          workers_show(params)
+        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
@@ -313,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",
@@ -338,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? },
+            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
@@ -365,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: {
@@ -384,17 +432,20 @@ module Kward
             logout: true
           },
           memory: { supported: true, optIn: true, defaultEnabled: false, autoSummaryDefaultEnabled: false, promptInjection: "interactive", storage: { core: "json", soft: "jsonl", events: "jsonl" }, methods: MEMORY_METHODS },
-          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" },
+          workers: workers_capability,
+          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
           },
@@ -412,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"),
@@ -426,6 +477,18 @@ module Kward
         }
       end
 
+      def workers_capability
+        return { supported: false, reason: "experimentalWorkersFlagRequired", flag: "--experimental-workers" } unless @experimental_workers
+
+        { supported: true, methods: WORKER_METHODS, roles: ["implementation", "request"], statuses: Workers::Worker::STATUSES, transcriptStorage: "sessions", metadataStorage: "json" }
+      end
+
+      def require_experimental_workers!
+        return if @experimental_workers
+
+        raise NoMethodError, "workers require --experimental-workers"
+      end
+
       def workspace_info(root)
         root = @session_manager.validate_workspace_root(root)
         { root: root, basename: File.basename(root), writable: File.writable?(root) }
@@ -571,6 +634,20 @@ module Kward
         { sections: sections }
       end
 
+      def workers_list(params)
+        include_archived = params["includeArchived"] == true
+        workers = @worker_store.list(include_archived: include_archived)
+        { workers: workers }
+      end
+
+      def workers_show(params)
+        id = params.fetch("id").to_s.delete_prefix("#")
+        worker = @worker_store.find(id)
+        return { worker: worker } if worker
+
+        raise ArgumentError, "Unknown worker: #{id}"
+      end
+
       def auth_login_with_api_key(params)
         result = @auth_manager.login_with_api_key(provider_id: params.fetch("providerId"), api_key: params.fetch("apiKey"))
         @session_manager.refresh_client_config
@@ -602,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?