kward 0.76.0 → 0.78.0

data/lib/kward/prompts/commands.rb

@@ -19,13 +19,11 @@ module Kward
       { name: "export", description: "Export the current session as Markdown.", argument_hint: "[path]" },
       { name: "compact", description: "Compact the current conversation context.", argument_hint: "[instructions]" },
       { name: "redraw", description: "Refresh the visible terminal.", argument_hint: "" },
-      { name: "settings", description: "Configure prompt overlays.", argument_hint: "" },
+      { name: "settings", description: "Configure Kward interactively.", argument_hint: "" },
       { name: "login", description: "Log in with an OAuth provider.", argument_hint: "" },
       { 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: "" },

data/lib/kward/prompts.rb

@@ -3,9 +3,25 @@ require_relative "config_files"
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # System prompt assembly from config, workspace instructions, memory, and plugins.
+  #
+  # Call {system_message} for the provider-ready message or {prompt_sections}
+  # when a frontend needs to inspect the labeled sources separately.
+  #
+  # @api public
   module Prompts
     module_function
 
+    # Builds the system message sent to a model provider.
+    #
+    # @param workspace_root [String] active workspace root
+    # @param include_workspace_personality [Boolean] include persona and plugin context
+    # @param model [String, nil] model used for persona matching
+    # @param reasoning_effort [String, nil] reasoning effort used for persona matching
+    # @param now [Time] time used for persona modifiers
+    # @param memory_context [String, nil] retrieved memory text
+    # @param plugin_context [String, nil] trusted plugin-provided instructions
+    # @return [Hash] role/content system message
+    # @api public
     def system_message(workspace_root: Dir.pwd, include_workspace_personality: true, model: nil, reasoning_effort: nil, now: Time.now, memory_context: nil, plugin_context: nil)
       {
         role: "system",
@@ -17,6 +33,10 @@ module Kward
       prompt_sections(workspace_root: workspace_root, include_workspace_personality: include_workspace_personality, model: model, reasoning_effort: reasoning_effort, now: now, memory_context: memory_context, plugin_context: plugin_context).map { |section| section[:content] }
     end
 
+    # Returns labeled prompt sections for inspection by CLI and RPC frontends.
+    #
+    # @return [Array<Hash>] section hashes with label, content, and optional source
+    # @api public
     def prompt_sections(workspace_root: Dir.pwd, include_workspace_personality: true, model: nil, reasoning_effort: nil, now: Time.now, memory_context: nil, plugin_context: nil)
       sections = [prompt_section("Built-in system prompt", base_prompt)]
       sections << prompt_section(config_agents_prompt_label, config_agents_prompt, source: config_agents_prompt_source)

data/lib/kward/rpc/plugin_chat_manager.rb

@@ -0,0 +1,299 @@
+require "securerandom"
+require "thread"
+require_relative "../cancellation"
+require_relative "../events"
+require_relative "../image_attachments"
+require_relative "../message_access"
+require_relative "../plugin_registry"
+require_relative "../tools/tool_call"
+require_relative "../tab_driver"
+require_relative "attachment_normalizer"
+require_relative "transcript_normalizer"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module RPC
+    # Coordinates optional RPC access to plugin-owned conversational runtimes.
+    # Unlike SessionManager, this manager never creates workspace sessions,
+    # agents, or tool registries: each plugin driver owns its chat and storage.
+    class PluginChatManager
+      EVENT_LIMIT = 1_000
+      WORKER_STOP = Object.new.freeze
+
+      Chat = Struct.new(:id, :type, :driver, :queue, :worker, :running_turn_id, keyword_init: true)
+      Turn = Struct.new(:id, :chat_id, :input, :display_input, :status, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :mutex, keyword_init: true)
+
+      def initialize(server:, client: Client.new)
+        @server = server
+        @client = client
+        @chats = {}
+        @turns = {}
+        @subscriptions = {}
+        @mutex = Mutex.new
+      end
+
+      def supported_types
+        plugin_registry.tab_types.select(&:rpc)
+      end
+
+      def list
+        { chats: supported_types.map { |type| type_payload(type) } }
+      end
+
+      def open(type_id:)
+        type = supported_types.find { |entry| entry.id == type_id.to_s } || raise(ArgumentError, "Unknown RPC plugin chat: #{type_id}")
+        chat = chat_for(type)
+        return chat_payload(chat) if chat.driver.respond_to?(:transcript_page)
+
+        chat_payload(chat).merge(messages: TranscriptNormalizer.new(chat.driver.messages).normalize)
+      end
+
+      def transcript(chat_id:, limit: nil, before: nil)
+        chat = fetch_chat(chat_id)
+        page = transcript_page(chat.driver, limit: limit, before: before)
+        {
+          chat: chat_payload(chat),
+          messages: TranscriptNormalizer.new(page.fetch(:messages)).normalize,
+          hasMore: page.fetch(:has_more),
+          nextBefore: page[:next_before]
+        }.compact
+      end
+
+      def subscribe(chat_id:)
+        chat = fetch_chat(chat_id)
+        @mutex.synchronize { @subscriptions[chat.id] = true }
+        { chat: chat_payload(chat), subscribed: true }
+      end
+
+      def unsubscribe(chat_id:)
+        chat = fetch_chat(chat_id)
+        @mutex.synchronize { @subscriptions.delete(chat.id) }
+        { chat: chat_payload(chat), subscribed: false }
+      end
+
+      def start_turn(chat_id:, input:, attachments: [])
+        chat = fetch_chat(chat_id)
+        normalized_attachments = AttachmentNormalizer.new.normalize(attachments)
+        turn = Turn.new(
+          id: SecureRandom.uuid,
+          chat_id: chat.id,
+          input: input_with_attachments(input, normalized_attachments),
+          display_input: input.to_s,
+          status: "queued",
+          cancellation: Cancellation.new,
+          created_at: Time.now.utc.iso8601(3),
+          events: [],
+          next_sequence: 1,
+          mutex: Mutex.new
+        )
+        @mutex.synchronize { @turns[turn.id] = turn }
+        chat.queue << turn.id
+        ensure_worker(chat)
+        emit_event(turn, "turnQueued", { status: "queued" })
+        turn_payload(turn)
+      end
+
+      def cancel_turn(turn_id:)
+        turn = fetch_turn(turn_id)
+        queued = turn.mutex.synchronize do
+          turn.cancellation.cancel!
+          turn.status == "queued"
+        end
+        emit_event(turn, "turnCancelRequested", {})
+        finish_turn(turn, "canceled") if queued
+        turn_payload(turn)
+      end
+
+      def turn_status(turn_id:)
+        turn_payload(fetch_turn(turn_id))
+      end
+
+      def turn_events(turn_id:, after_sequence: 0)
+        turn = fetch_turn(turn_id)
+        events = turn.mutex.synchronize { turn.events.select { |event| event[:sequence].to_i > after_sequence.to_i } }
+        { turn: turn_payload(turn), events: events }
+      end
+
+      def list_turns(chat_id: nil, active: false)
+        turns = @mutex.synchronize { @turns.values.dup }
+        turns.select! { |turn| turn.chat_id == chat_id.to_s } if chat_id
+        turns.select! { |turn| %w[queued running].include?(turn.status) } if active
+        { turns: turns.map { |turn| turn_payload(turn) } }
+      end
+
+      def shutdown
+        chats = @mutex.synchronize { @chats.values.dup }
+        chats.each do |chat|
+          chat.queue << WORKER_STOP if chat.worker&.alive?
+          chat.worker&.join(0.2)
+        end
+      end
+
+      private
+
+      def plugin_registry
+        @plugin_registry ||= PluginRegistry.load
+      end
+
+      def chat_for(type)
+        @mutex.synchronize do
+          @chats[type.id] ||= begin
+            descriptor = { "kind" => "plugin", "plugin_tab_type" => type.id, "label" => type.title }
+            driver = type.handler.call(PluginTabHost.new(client: @client, workspace_root: Dir.pwd), descriptor)
+            raise "Plugin chat #{type.id.inspect} did not return a tab driver." unless driver
+
+            Chat.new(id: type.id, type: type, driver: driver, queue: Queue.new)
+          end
+        end
+      end
+
+      def fetch_chat(chat_id)
+        @mutex.synchronize { @chats[chat_id.to_s] } || open(type_id: chat_id).then { @mutex.synchronize { @chats[chat_id.to_s] } }
+      end
+
+      def fetch_turn(turn_id)
+        @mutex.synchronize { @turns[turn_id.to_s] } || raise(ArgumentError, "Unknown plugin chat turn: #{turn_id}")
+      end
+
+      def ensure_worker(chat)
+        return if chat.worker&.alive?
+
+        chat.worker = Thread.new do
+          loop do
+            turn_id = chat.queue.pop
+            break if turn_id.equal?(WORKER_STOP)
+
+            turn = fetch_turn(turn_id)
+            run_turn(chat, turn) unless turn.cancellation.cancelled?
+          end
+        end
+        chat.worker.report_on_exception = false
+      end
+
+      def run_turn(chat, turn)
+        turn.mutex.synchronize do
+          return if terminal?(turn)
+
+          turn.status = "running"
+          turn.started_at = Time.now.utc.iso8601(3)
+        end
+        chat.running_turn_id = turn.id
+        emit_event(turn, "turnStarted", { status: "running" })
+        chat.driver.submit(turn.input, display_input: turn.display_input, cancellation: turn.cancellation) do |event|
+          handle_driver_event(chat, turn, event)
+        end
+        finish_turn(turn, turn.cancellation.cancelled? ? "canceled" : "completed")
+      rescue Cancellation::CancelledError
+        finish_turn(turn, "canceled")
+      rescue StandardError => e
+        turn.mutex.synchronize { turn.error = { message: e.message, code: e.class.name, fatal: false } }
+        finish_turn(turn, "failed")
+      ensure
+        chat.running_turn_id = nil if chat.running_turn_id == turn.id
+      end
+
+      def handle_driver_event(chat, turn, event)
+        notify_plugin_tab_transcript_event(chat, event) if chat.type.transcript_events
+
+        type, payload = case event
+        when Events::ReasoningDelta then ["reasoningDelta", { delta: event.delta }]
+        when Events::ReasoningBoundary then ["reasoningBoundary", {}]
+        when Events::AssistantDelta then ["assistantDelta", { delta: event.delta }]
+        when Events::AssistantMessage then ["assistantMessage", { message: TranscriptNormalizer.new([event.message]).normalize.first }]
+        when Events::Retry then ["modelRetry", retry_event_payload(event)]
+        when Events::ToolCall then ["toolCall", tool_call_payload(event.tool_call)]
+        when Events::ToolResult then ["toolResult", tool_result_payload(event.tool_call, event.content)]
+        when Events::Answer then ["answer", { content: event.content }]
+        end
+        emit_event(turn, type, payload) if type
+      end
+
+      def notify_plugin_tab_transcript_event(chat, event)
+        return if plugin_registry.transcript_event_handlers.empty?
+
+        context = PluginRegistry::Context.new(conversation: chat.driver, workspace_root: Dir.pwd)
+        plugin_registry.notify_transcript_event(event, context)
+      end
+
+      def retry_event_payload(event)
+        { provider: event.provider, model: event.model, attempt: event.attempt, maxAttempts: event.max_attempts, delaySeconds: event.delay_seconds, error: event.error, requestBytes: event.request_bytes }.compact
+      end
+
+      def tool_call_payload(tool_call)
+        { toolCallId: ToolCall.id(tool_call), toolName: ToolCall.name(tool_call), args: ToolCall.parse_arguments(ToolCall.raw_arguments(tool_call)) }.compact
+      end
+
+      def tool_result_payload(tool_call, content)
+        { toolCallId: ToolCall.id(tool_call), toolName: ToolCall.name(tool_call), result: { content: content.to_s, isError: content.to_s.start_with?("Unknown", "Invalid", "Research tool failed") } }.compact
+      end
+
+      def finish_turn(turn, status)
+        event = turn.mutex.synchronize do
+          next nil if terminal?(turn)
+
+          turn.status = status
+          turn.finished_at = Time.now.utc.iso8601(3)
+          append_event(turn, "turnFinished", { status: status, error: turn.error }.compact)
+        end
+        notify_event(event) if event
+      end
+
+      def emit_event(turn, type, payload)
+        event = turn.mutex.synchronize { append_event(turn, type, payload) }
+        notify_event(event)
+      end
+
+      def append_event(turn, type, payload)
+        event = {
+          sequence: turn.next_sequence,
+          timestamp: Time.now.utc.iso8601(3),
+          chatId: turn.chat_id,
+          turnId: turn.id,
+          type: type,
+          payload: payload
+        }
+        turn.next_sequence += 1
+        turn.events << event
+        turn.events.shift while turn.events.length > EVENT_LIMIT
+        event
+      end
+
+      def notify_event(event)
+        subscribed = @mutex.synchronize { @subscriptions[event[:chatId]] }
+        @server.notify("pluginChat/event", event) if subscribed
+      end
+
+      def input_with_attachments(input, attachments)
+        return input.to_s if attachments.empty?
+
+        [{ type: "text", text: input.to_s }] + attachments.map do |attachment|
+          { type: "image", media_type: attachment[:mimeType], data: attachment[:data], alt: attachment[:alt] }
+        end
+      end
+
+      def terminal?(turn)
+        %w[completed failed canceled].include?(turn.status)
+      end
+
+      def type_payload(type)
+        { id: type.id, name: type.name, title: type.title, singleton: type.singleton }.compact
+      end
+
+      def transcript_page(driver, limit:, before:)
+        return { messages: driver.messages, has_more: false } unless limit && driver.respond_to?(:transcript_page)
+
+        driver.transcript_page(limit: limit, before: before)
+      end
+
+      def chat_payload(chat)
+        type_payload(chat.type).merge(id: chat.id, subscribed: @mutex.synchronize { @subscriptions[chat.id] == true })
+      end
+
+      def turn_payload(turn)
+        turn.mutex.synchronize do
+          { id: turn.id, chatId: turn.chat_id, status: turn.status, createdAt: turn.created_at, startedAt: turn.started_at, finishedAt: turn.finished_at, error: turn.error }.compact
+        end
+      end
+    end
+  end
+end

data/lib/kward/rpc/server.rb

@@ -5,7 +5,6 @@ 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"
@@ -14,6 +13,7 @@ require_relative "config_manager"
 require_relative "mcp_status"
 require_relative "redactor"
 require_relative "session_manager"
+require_relative "plugin_chat_manager"
 require_relative "transport"
 
 # Namespace for the Kward CLI agent runtime.
@@ -33,6 +33,7 @@ module Kward
     # `SessionManager`, `AuthManager`, and `ConfigManager`. When adding an RPC
     # feature, update dispatch, capabilities, docs, and tests together so clients
     # can trust `initialize` as the source of supported behavior.
+    # @api public
     class Server
       PROTOCOL_VERSION = 1
       JSONRPC_VERSION = "2.0"
@@ -57,6 +58,7 @@ module Kward
         "sessions/export", "sessions/delete", "sessions/close", "sessions/transcript", "sessions/active"
       ].freeze
       TURN_METHODS = ["turns/start", "turns/cancel", "turns/status", "turns/events", "turns/list", "turns/listActive"].freeze
+      PLUGIN_CHAT_METHODS = ["pluginChats/list", "pluginChats/open", "pluginChats/transcript", "pluginChats/subscribe", "pluginChats/unsubscribe", "pluginChats/turns/start", "pluginChats/turns/cancel", "pluginChats/turns/status", "pluginChats/turns/events", "pluginChats/turns/list", "pluginChats/turns/listActive"].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
@@ -70,7 +72,6 @@ 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
@@ -93,12 +94,12 @@ module Kward
         prompts: PROMPT_METHODS,
         sessions: SESSION_METHODS,
         turns: TURN_METHODS,
+        plugin_chats: PLUGIN_CHAT_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,
@@ -110,15 +111,19 @@ module Kward
       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)
+      #
+      # @param input [IO] framed JSON-RPC input stream
+      # @param output [IO] framed JSON-RPC output stream
+      # @param error_output [IO, nil] redacted diagnostic stream
+      # @param client [Client] model-provider client shared by sessions
+      def initialize(input: $stdin, output: $stdout, error_output: $stderr, client: Client.new)
         @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)
+        @plugin_chat_manager = PluginChatManager.new(server: self, client: client)
         @auth_manager = AuthManager.new(server: self, config_manager: @config_manager)
-        @worker_store = Workers::Store.new
-        @experimental_workers = experimental_workers
         @shutdown = false
       end
 
@@ -139,6 +144,7 @@ module Kward
           end
         end
       ensure
+        @plugin_chat_manager.shutdown
         @session_manager.shutdown_sessions
       end
 
@@ -162,6 +168,10 @@ module Kward
         })
       end
 
+      # Writes a redacted server diagnostic without exposing error payload data.
+      #
+      # @param error [Exception]
+      # @return [void]
       def log_error(error)
         @error_output.puts("Kward RPC error: #{Redactor.redact_string(error.message)}") if @error_output
       end
@@ -277,12 +287,6 @@ module Kward
           @session_manager.memory_why(session_id: params["sessionId"])
         when MEMORY_METHODS[13]
           @session_manager.memory_summarize(session_id: params.fetch("sessionId"))
-        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_METHODS[1]
@@ -350,6 +354,28 @@ module Kward
           @session_manager.list_turns(session_id: params["sessionId"])
         when TURN_METHODS[5]
           @session_manager.list_turns(session_id: params["sessionId"], active: true)
+        when PLUGIN_CHAT_METHODS[0]
+          @plugin_chat_manager.list
+        when PLUGIN_CHAT_METHODS[1]
+          @plugin_chat_manager.open(type_id: params.fetch("typeId"))
+        when PLUGIN_CHAT_METHODS[2]
+          @plugin_chat_manager.transcript(chat_id: params.fetch("chatId"), limit: params["limit"], before: params["before"])
+        when PLUGIN_CHAT_METHODS[3]
+          @plugin_chat_manager.subscribe(chat_id: params.fetch("chatId"))
+        when PLUGIN_CHAT_METHODS[4]
+          @plugin_chat_manager.unsubscribe(chat_id: params.fetch("chatId"))
+        when PLUGIN_CHAT_METHODS[5]
+          @plugin_chat_manager.start_turn(chat_id: params.fetch("chatId"), input: params.fetch("input"), attachments: params["attachments"] || [])
+        when PLUGIN_CHAT_METHODS[6]
+          @plugin_chat_manager.cancel_turn(turn_id: params.fetch("turnId"))
+        when PLUGIN_CHAT_METHODS[7]
+          @plugin_chat_manager.turn_status(turn_id: params.fetch("turnId"))
+        when PLUGIN_CHAT_METHODS[8]
+          @plugin_chat_manager.turn_events(turn_id: params.fetch("turnId"), after_sequence: params["afterSequence"] || 0)
+        when PLUGIN_CHAT_METHODS[9]
+          @plugin_chat_manager.list_turns(chat_id: params["chatId"])
+        when PLUGIN_CHAT_METHODS[10]
+          @plugin_chat_manager.list_turns(chat_id: params["chatId"], active: true)
         when UI_METHODS[0]
           @session_manager.answer_question(session_id: params.fetch("sessionId"), question_request_id: params.fetch("questionRequestId"), answers: params.fetch("answers"))
         when TOOL_APPROVAL_METHODS[0]
@@ -393,6 +419,14 @@ module Kward
             tree: { supported: true, method: SESSION_METHODS[8], labels: true, labelTimestamps: true, navigate: true, summarize: true, shape: "kward-tree-items-v1" },
             updates: { supported: false, notification: SESSION_UPDATED_NOTIFICATION }
           },
+          pluginChats: {
+            supported: @plugin_chat_manager.supported_types.any?,
+            methods: PLUGIN_CHAT_METHODS,
+            notification: "pluginChat/event",
+            subscriptions: { supported: true, methods: PLUGIN_CHAT_METHODS.values_at(3, 4), requiredForLiveEvents: true },
+            attachments: { supported: true, method: PLUGIN_CHAT_METHODS[5], encoding: "base64", mimeTypes: SessionManager::RPC_IMAGE_MIME_TYPES, maxBytes: SessionManager::RPC_ATTACHMENT_MAX_BYTES },
+            types: @plugin_chat_manager.supported_types.map { |type| { id: type.id, name: type.name, title: type.title, singleton: type.singleton }.compact }
+          },
           turns: {
             mode: "async",
             perSessionConcurrency: 1,
@@ -429,7 +463,7 @@ module Kward
             reasoning: { start: false, delta: true, boundary: 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: true, result: true, normalizedMetadata: true, diffs: true, changedFiles: true, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
+            tools: { call: true, update: true, result: true, normalizedMetadata: true, diffs: true, firstChangedLine: true, changedFiles: true, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
             errors: true,
             sessionUpdates: false
           },
@@ -484,8 +518,7 @@ 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 },
-          workers: workers_capability,
-          stability: { protocol: "stable", compatibility: "additive-fields-unless-protocol-version-changes", experimentalCapabilities: ["workers"] },
+          stability: { protocol: "stable", compatibility: "additive-fields-unless-protocol-version-changes", experimentalCapabilities: [] },
           commands: { supported: true, methods: COMMAND_METHODS, method: COMMAND_METHODS[0], runMethod: COMMAND_METHODS[1], sources: ["builtin", "prompt", "skill", "plugin"], executableSources: ["builtin", "plugin"] },
           mcp: {
             supported: true,
@@ -543,18 +576,6 @@ 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) }
@@ -715,20 +736,6 @@ 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