kward 0.70.0 → 0.72.0

data/lib/kward/tools/context_for_task.rb

@@ -0,0 +1,202 @@
+require "pathname"
+require_relative "../workspace"
+require_relative "base"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model-callable tool wrappers and their argument schemas.
+  module Tools
+    # Builds a compact, task-shaped bundle from likely workspace files.
+    class ContextForTask < Base
+      DEFAULT_BUDGET = 4_000
+      MAX_BUDGET = 20_000
+      MAX_FILES = 8
+      MAX_MATCHES_PER_FILE = 8
+      DEFAULT_EXTENSIONS = %w[.rb .js .jsx .ts .tsx .py .go .rs .java .cs .cpp .c .h .hpp .md .yml .yaml .json .toml].freeze
+      SKIP_DIRECTORIES = %w[.git .yardoc _yardoc node_modules vendor tmp log coverage dist build .bundle].freeze
+
+      # Builds the tool schema and stores the execution dependency.
+      def initialize(workspace:)
+        @workspace = workspace
+        super(
+          "context_for_task",
+          "Build focused workspace context for a task from outlines and matching excerpts within a byte budget.",
+          properties: {
+            budget: { type: "integer", description: "Approximate byte budget for the returned context. Default 4000, maximum 20000." },
+            paths: { type: "array", items: { type: "string" }, description: "Optional workspace-relative files or directories to focus." },
+            task: { type: "string", description: "Task or question to gather context for." }
+          },
+          required: ["task"]
+        )
+      end
+
+      # Executes focused context retrieval.
+      def call(args, _conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        task = argument(args, :task, "").to_s.strip
+        return "Error: task is required" if task.empty?
+
+        budget = normalized_budget(argument(args, :budget))
+        return budget if budget.is_a?(String)
+
+        focus_paths = Array(argument(args, :paths, [])).map(&:to_s).reject(&:empty?)
+        files = candidate_files(focus_paths, cancellation: cancellation)
+        return "No readable candidate files found for focused context." if files.empty?
+
+        terms = search_terms(task)
+        ranked = rank_files(files, terms)
+        render_context(task: task, budget: budget, terms: terms, ranked: ranked, cancellation: cancellation)
+      rescue SecurityError, Errno::ENOENT => e
+        "Error: #{e.message}"
+      end
+
+      private
+
+      def normalized_budget(value)
+        return DEFAULT_BUDGET if value.nil?
+
+        budget = value.to_i
+        return "Error: budget must be positive" unless budget.positive?
+
+        [budget, MAX_BUDGET].min
+      end
+
+      def candidate_files(paths, cancellation:)
+        roots = paths.empty? ? [@workspace.root.to_s] : paths.map { |path| @workspace.resolved_path(path) }
+        files = roots.flat_map do |path|
+          cancellation&.raise_if_cancelled!
+          File.directory?(path) ? files_under(path, cancellation: cancellation) : [path]
+        end
+        files.uniq.select { |path| readable_context_file?(path) }.first(MAX_FILES * 8)
+      end
+
+      def files_under(root, cancellation:)
+        files = []
+        stack = [root]
+        until stack.empty? || files.length >= MAX_FILES * 8
+          cancellation&.raise_if_cancelled!
+          current = stack.pop
+          next if skipped_directory?(current)
+
+          entries = Dir.children(current).sort.map { |entry| File.join(current, entry) }
+          entries.each do |entry|
+            if File.directory?(entry)
+              stack << entry
+            else
+              files << entry if readable_context_file?(entry)
+            end
+          end
+        end
+        files
+      end
+
+      def readable_context_file?(path)
+        return false unless File.file?(path)
+        return false if File.size(path) > Workspace::MAX_FILE_BYTES
+        return false unless DEFAULT_EXTENSIONS.include?(File.extname(path)) || File.basename(path) == "Gemfile"
+
+        sample = File.open(path, "rb") { |file| file.read(4096).to_s }
+        !sample.include?("\x00")
+      rescue Errno::ENOENT, Errno::EACCES
+        false
+      end
+
+      def skipped_directory?(path)
+        SKIP_DIRECTORIES.include?(File.basename(path))
+      end
+
+      def search_terms(task)
+        task.scan(/[A-Za-z_][A-Za-z0-9_]{2,}/).map(&:downcase).reject { |term| stopword?(term) }.uniq.first(20)
+      end
+
+      def stopword?(term)
+        %w[the and for with from this that into when where what why how fix add update change implement review debug explain failing failure error issue].include?(term)
+      end
+
+      def rank_files(files, terms)
+        scored = files.map do |path|
+          content = File.read(path)
+          relative = relative_path(path)
+          score = score_file(relative, content, terms)
+          { path: path, relative: relative, content: content, score: score }
+        rescue Errno::ENOENT, Errno::EACCES
+          nil
+        end.compact
+        filtered = terms.empty? ? scored : scored.select { |file| file[:score].positive? }
+        filtered.sort_by { |file| [-file[:score], file[:relative]] }.first(MAX_FILES)
+      end
+
+      def score_file(relative, content, terms)
+        haystack = "#{relative}\n#{content}".downcase
+        terms.sum { |term| haystack.scan(term).length } + (terms.any? { |term| relative.downcase.include?(term) } ? 5 : 0)
+      end
+
+      def render_context(task:, budget:, terms:, ranked:, cancellation:)
+        lines = ["# Focused context", "- Task: #{task}", "- Budget: #{budget} bytes", "- Search terms: #{terms.empty? ? '(none)' : terms.join(', ')}", ""]
+        used = lines.join("\n").bytesize
+
+        ranked.each do |file|
+          cancellation&.raise_if_cancelled!
+          section = file_section(file, terms)
+          break if used + section.bytesize > budget && lines.length > 5
+
+          if used + section.bytesize > budget
+            remaining = budget - used
+            break if remaining < 200
+
+            section = section.byteslice(0, remaining).to_s.scrub << "\n[Context budget reached.]"
+          end
+          lines << section
+          used += section.bytesize
+        end
+
+        lines.join("\n")
+      end
+
+      def file_section(file, terms)
+        outline = @workspace.summarize_file_structure(file[:relative])
+        matches = matching_excerpt(file[:content], terms)
+        parts = ["## #{file[:relative]}", "- Score: #{file[:score]}"]
+        parts << outline unless outline.start_with?("No recognizable source structure")
+        parts << matches unless matches.empty?
+        parts.join("\n") << "\n"
+      end
+
+      def matching_excerpt(content, terms)
+        return "" if terms.empty?
+
+        lines = content.split("\n", -1)
+        indexes = matching_indexes(lines, terms)
+        return "" if indexes.empty?
+
+        selected = indexes.flat_map { |index| ([index - 2, 0].max..[index + 2, lines.length - 1].min).to_a }.uniq.sort
+        render_excerpt(lines, selected)
+      end
+
+      def matching_indexes(lines, terms)
+        indexes = []
+        lines.each_with_index do |line, index|
+          lower = line.downcase
+          indexes << index if terms.any? { |term| lower.include?(term) }
+          break if indexes.length >= MAX_MATCHES_PER_FILE
+        end
+        indexes
+      end
+
+      def render_excerpt(lines, selected)
+        output = ["### Matching excerpts"]
+        previous = nil
+        selected.each do |index|
+          output << "..." if previous && index > previous + 1
+          output << "%4d: %s" % [index + 1, lines[index]]
+          previous = index
+        end
+        output.join("\n")
+      end
+
+      def relative_path(path)
+        Pathname.new(path).relative_path_from(@workspace.root).to_s
+      end
+    end
+  end
+end

data/lib/kward/tools/read_file.rb

@@ -11,11 +11,13 @@ module Kward
         @workspace = workspace
         super(
           "read_file",
-          "Read a workspace text file. Output is capped; use offset/limit to continue.",
+          "Read a workspace text file. Output is capped; use offset/limit or mode to control context budget.",
           properties: {
             path: { type: "string", description: "Workspace-relative path." },
-            offset: { type: "integer", description: "1-indexed start line." },
-            limit: { type: "integer", description: "Maximum lines to return." }
+            limit: { type: "integer", description: "Maximum lines to return." },
+            max_bytes: { type: "integer", description: "Optional byte budget for this read, capped by Kward's workspace read limit." },
+            mode: { type: "string", enum: %w[preview outline range full], description: "Context mode. preview returns a short slice, outline returns source declarations, range reads offset/limit, full reads until Kward's cap." },
+            offset: { type: "integer", description: "1-indexed start line." }
           },
           required: ["path"]
         )
@@ -26,7 +28,9 @@ module Kward
         path = argument(args, :path, "")
         offset = argument(args, :offset)
         limit = argument(args, :limit)
-        content = @workspace.read_file(path, offset: offset, limit: limit)
+        mode = argument(args, :mode)
+        max_bytes = argument(args, :max_bytes)
+        content = @workspace.read_file(path, offset: offset, limit: limit, mode: mode, max_bytes: max_bytes)
         conversation.mark_read(@workspace.resolved_path(path)) unless content.start_with?("Error:")
         content
       end

data/lib/kward/tools/registry.rb

@@ -1,6 +1,9 @@
 require_relative "../config_files"
+require_relative "../conversation"
 require_relative "ask_user_question"
 require_relative "code_search"
+require_relative "context_budget_stats"
+require_relative "context_for_task"
 require_relative "edit_file"
 require_relative "fetch_content"
 require_relative "fetch_raw"
@@ -8,12 +11,16 @@ require_relative "list_directory"
 require_relative "read_file"
 require_relative "read_skill"
 require_relative "run_shell_command"
+require_relative "summarize_file_structure"
+require_relative "retrieve_tool_output"
 require_relative "web_search"
 require_relative "write_file"
 require_relative "search/code"
 require_relative "search/web"
 require_relative "search/web_fetch"
 require_relative "tool_call"
+require_relative "../telemetry/logger"
+require_relative "../tool_output_compactor"
 require_relative "../workspace"
 
 # Namespace for the Kward CLI agent runtime.
@@ -40,7 +47,7 @@ module Kward
     # Tool schemas advertised to the model for the current frontend and config.
     #
     # @return [Array<Hash>] tool schemas currently advertised to the model
-    attr_reader :schemas
+    attr_reader :schemas, :writer_id
 
     # Builds tool objects and the schema list for the current frontend/config.
     #
@@ -53,7 +60,7 @@ module Kward
     # @param web_search_enabled [Boolean, nil] override for web search exposure
     # @param skills [Array<ConfigFiles::Skill>, nil] override discovered skills
     # @param ask_user_question_enabled [Boolean, nil] override question exposure
-    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil)
+    def initialize(workspace: Workspace.new, prompt: nil, web_search: WebSearch.new, web_fetch: WebFetch.new, code_search: CodeSearch.new, web_search_enabled: nil, skills: nil, ask_user_question_enabled: nil, allowed_tool_names: nil, write_lock: nil, writer_id: nil, tool_output_compactor: ToolOutputCompactor.new, telemetry_logger: TelemetryLogger.new, context_budget_meter: nil)
       @workspace = workspace
       @prompt = prompt
       @web_search = web_search
@@ -62,6 +69,12 @@ module Kward
       @skills = skills
       @web_search_enabled = web_search_enabled
       @ask_user_question_enabled = ask_user_question_enabled
+      @allowed_tool_names = allowed_tool_names&.map(&:to_s)
+      @write_lock = write_lock
+      @writer_id = writer_id
+      @tool_output_compactor = tool_output_compactor
+      @telemetry_logger = telemetry_logger
+      @context_budget_meter = context_budget_meter
       @tools = build_tools.freeze
       @schemas = build_schema_tools.map(&:schema).freeze
     end
@@ -82,36 +95,96 @@ module Kward
       args = ToolCall.arguments(tool_call)
       tool = @tools[name]
 
-      content = if tool
-                  tool.call(args, conversation, cancellation: cancellation)
-                else
-                  "Unknown tool: #{name}"
-                end
-
+      original_content = if tool
+                           if mutation_tool?(name) && !write_lock_owned?
+                             "Workspace write denied: another worker owns the write lock."
+                           else
+                             tool.call(args, conversation, cancellation: cancellation)
+                           end
+                         else
+                           "Unknown tool: #{name}"
+                         end
+      original_content = Conversation.normalize_tool_content(original_content)
+      duplicate_id = conversation.tool_output_artifact_id_for(tool_name: name, content: original_content)
+      content = original_content
+      if reusable_duplicate_output?(name) && conversation.tool_output_artifacts.key?(duplicate_id)
+        content = "[Same as previous tool output #{duplicate_id}; not repeated. Use retrieve_tool_output to inspect it.]"
+      end
+
+      artifact_id = nil
+      model_content = @tool_output_compactor.compact(name, content) do
+        artifact_id ||= conversation.store_tool_output_artifact(tool_name: name, content: original_content)
+      end
+      record_context_budget(conversation, name, before: original_content, after: model_content)
+      log_tool_output_compaction(name, artifact_id: artifact_id, before: original_content, after: model_content) if model_content != original_content
       conversation.append_tool(
         tool_call_id: tool_call["id"] || tool_call[:id],
         name: name,
-        content: content
+        content: model_content
       )
-      conversation.append_tool_execution(tool_call: tool_call, content: content)
+      conversation.append_tool_execution(tool_call: tool_call, content: original_content)
 
-      content
+      model_content
     end
 
     private
 
+    def record_context_budget(conversation, name, before:, after:)
+      meter = conversation.respond_to?(:context_budget_meter) ? conversation.context_budget_meter : @context_budget_meter
+      return unless meter
+      return if name.to_s == "context_budget_stats"
+
+      saved = meter.record(tool_name: name, original_bytes: before.bytesize, returned_bytes: after.bytesize)
+      @telemetry_logger.log(
+        "compaction",
+        "context_budget",
+        "tool_name" => name,
+        "bytes_before" => before.bytesize,
+        "bytes_after" => after.bytesize,
+        "bytes_saved" => saved
+      )
+    end
+
+    def reusable_duplicate_output?(name)
+      name.to_s != "read_skill"
+    end
+
+    def log_tool_output_compaction(name, artifact_id:, before:, after:)
+      @telemetry_logger.log(
+        "compaction",
+        "tool_output",
+        "tool_name" => name,
+        "artifact_id" => artifact_id,
+        "bytes_before" => before.bytesize,
+        "bytes_after" => after.bytesize,
+        "bytes_saved" => before.bytesize - after.bytesize
+      )
+    end
+
+    def mutation_tool?(name)
+      ToolCall.write_lock_required?(name)
+    end
+
+    def write_lock_owned?
+      return true unless @write_lock
+
+      @write_lock.owned_by?(@writer_id)
+    end
+
     def build_tools
-      all_tools.to_h { |tool| [tool.name, tool] }
+      tools = all_tools
+      tools = tools.select { |tool| @allowed_tool_names.include?(tool.name) } if @allowed_tool_names
+      tools.to_h { |tool| [tool.name, tool] }
     end
 
     def build_schema_tools
       tools = @tools.values_at(
-        "list_directory", "read_file", "write_file", "edit_file", "run_shell_command", "code_search"
+        "list_directory", "read_file", "write_file", "edit_file", "run_shell_command", "code_search", "summarize_file_structure", "context_for_task", "context_budget_stats", "retrieve_tool_output"
       )
       tools.concat(@tools.values_at("web_search", "fetch_content", "fetch_raw")) if web_search_available?
       tools << @tools["read_skill"] if skills_available?
       tools << @tools["ask_user_question"] if ask_user_question_available?
-      tools
+      tools.compact
     end
 
     def all_tools
@@ -131,7 +204,11 @@ module Kward
         Tools::WriteFile.new(workspace: @workspace),
         Tools::EditFile.new(workspace: @workspace),
         Tools::RunShellCommand.new(workspace: @workspace),
-        Tools::CodeSearch.new(code_search: @code_search)
+        Tools::CodeSearch.new(code_search: @code_search),
+        Tools::SummarizeFileStructure.new(workspace: @workspace),
+        Tools::ContextForTask.new(workspace: @workspace),
+        Tools::ContextBudgetStats.new(context_budget_meter: @context_budget_meter),
+        Tools::RetrieveToolOutput.new
       ]
     end
 

data/lib/kward/tools/retrieve_tool_output.rb

@@ -0,0 +1,71 @@
+require_relative "base"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model-callable tool wrappers and their argument schemas.
+  module Tools
+    # Retrieves original tool outputs that were compacted out of model context.
+    class RetrieveToolOutput < Base
+      DEFAULT_LIMIT = 120
+
+      # Builds the retrieval tool schema.
+      def initialize
+        super(
+          "retrieve_tool_output",
+          "Retrieve original output from a compacted previous tool result.",
+          properties: {
+            id: { type: "string", description: "Tool output id, for example toolout_abc123." },
+            query: { type: "string", description: "Optional case-insensitive text search within the original output." },
+            offset: { type: "integer", description: "1-indexed line offset for returned output." },
+            limit: { type: "integer", description: "Maximum lines to return; default 120." }
+          },
+          required: ["id"]
+        )
+      end
+
+      # Executes retrieval from the active conversation artifact store.
+      def call(args, conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        id = argument(args, :id, "").to_s
+        return "Error: id is required" if id.empty?
+
+        artifact = conversation.tool_output_artifacts[id]
+        return "Error: unknown tool output id: #{id}" unless artifact
+
+        content = artifact[:content].to_s
+        query = argument(args, :query, "").to_s
+        lines = query.empty? ? content.split("\n", -1) : matching_lines(content, query)
+        return "No matching lines for #{query.inspect} in #{id}." if lines.empty?
+
+        slice_lines(id, lines, offset: argument(args, :offset), limit: argument(args, :limit), query: query)
+      end
+
+      private
+
+      def matching_lines(content, query)
+        needle = query.downcase
+        content.split("\n", -1).each_with_index.filter_map do |line, index|
+          next unless line.downcase.include?(needle)
+
+          "#{index + 1}: #{line}"
+        end
+      end
+
+      def slice_lines(id, lines, offset:, limit:, query:)
+        start_index = [offset.to_i - 1, 0].max
+        return "Error: offset #{offset} is beyond output (#{lines.length} lines total)" if start_index >= lines.length
+
+        line_limit = limit.to_i.positive? ? limit.to_i : DEFAULT_LIMIT
+        selected = lines[start_index, line_limit] || []
+        header = "[Retrieved tool output #{id}"
+        header << " matching #{query.inspect}" unless query.empty?
+        header << ": lines #{start_index + 1}-#{start_index + selected.length} of #{lines.length}]"
+        output = "#{header}\n#{selected.join("\n")}".rstrip
+        if start_index + selected.length < lines.length
+          output << "\n\n[#{lines.length - start_index - selected.length} more lines. Use offset=#{start_index + selected.length + 1} to continue.]"
+        end
+        output
+      end
+    end
+  end
+end

data/lib/kward/tools/search/web.rb

@@ -619,8 +619,8 @@ module Kward
       return web_config[snake] if web_config.key?(snake)
       return web_config[camel] if web_config.key?(camel)
       return config[prefixed] if config.key?(prefixed)
-      return config[snake] if config.key?(snake)
-      return config[camel] if config.key?(camel)
+      return config[snake] if key.to_s != "provider" && config.key?(snake)
+      return config[camel] if key.to_s != "provider" && config.key?(camel)
 
       nil
     end

data/lib/kward/tools/summarize_file_structure.rb

@@ -0,0 +1,29 @@
+require_relative "base"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Model-callable tool wrappers and their argument schemas.
+  module Tools
+    # Returns a compact symbol outline for a workspace source file.
+    class SummarizeFileStructure < Base
+      # Builds the tool schema and stores the execution dependency.
+      def initialize(workspace:)
+        @workspace = workspace
+        super(
+          "summarize_file_structure",
+          "Return a compact outline of classes, modules, methods, and functions in a workspace source file.",
+          properties: {
+            path: { type: "string", description: "Workspace-relative source file path." }
+          },
+          required: ["path"]
+        )
+      end
+
+      # Executes the structure summary tool.
+      def call(args, _conversation, cancellation: nil)
+        cancellation&.raise_if_cancelled!
+        @workspace.summarize_file_structure(argument(args, :path, ""))
+      end
+    end
+  end
+end

data/lib/kward/tools/tool_call.rb

@@ -17,6 +17,10 @@ module Kward
       "run_shell_command" => "bash",
       "list_directory" => "list_directory",
       "code_search" => "code_search",
+      "summarize_file_structure" => "summarize_file_structure",
+      "context_for_task" => "context_for_task",
+      "context_budget_stats" => "context_budget_stats",
+      "retrieve_tool_output" => "retrieve_tool_output",
       "web_search" => "web_search",
       "fetch_content" => "fetch_content",
       "fetch_raw" => "fetch_raw",
@@ -63,6 +67,14 @@ module Kward
       TOOL_NAME_MAP[name.to_s]
     end
 
+    def write_lock_required?(name)
+      %w[edit_file write_file run_shell_command edit write bash].include?(name.to_s)
+    end
+
+    def file_change_tool?(name)
+      %w[edit_file write_file edit write].include?(name.to_s)
+    end
+
     # Converts provider argument payloads into hashes.
     #
     # Providers normally send JSON strings, while tests and compatibility callers

data/lib/kward/version.rb

@@ -1,5 +1,5 @@
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Current gem version.
-  VERSION = "0.70.0"
+  VERSION = "0.72.0"
 end

data/lib/kward/workers/git_guard.rb

@@ -0,0 +1,68 @@
+require "open3"
+
+module Kward
+  module Workers
+    # Small git boundary used by write-lane workers to keep implementation work isolated.
+    class GitGuard
+      def initialize(root: Dir.pwd)
+        @root = root.to_s
+      end
+
+      def repository?
+        success?("rev-parse", "--is-inside-work-tree")
+      end
+
+      def clean?
+        return true unless repository?
+
+        status.empty?
+      end
+
+      def dirty?
+        !clean?
+      end
+
+      def status
+        run("status", "--porcelain").stdout
+      end
+
+      def head
+        result = run("rev-parse", "--verify", "HEAD")
+        result.success? ? result.stdout.strip : nil
+      end
+
+      def commit_all(message)
+        add = run("add", "-A")
+        return Result.new(success: false, stdout: add.stdout, stderr: add.stderr) unless add.success?
+
+        commit = run("commit", "-m", message)
+        return Result.new(success: false, stdout: commit.stdout, stderr: commit.stderr) unless commit.success?
+
+        Result.new(success: true, stdout: commit.stdout, stderr: commit.stderr, commit: head)
+      end
+
+      private
+
+      Result = Struct.new(:success, :stdout, :stderr, :commit, keyword_init: true) do
+        def success?
+          success
+        end
+
+        def output
+          [stdout, stderr].compact.reject(&:empty?).join("\n")
+        end
+      end
+
+      def success?(*args)
+        run(*args).success?
+      end
+
+      def run(*args)
+        stdout, stderr, status = Open3.capture3("git", "-C", @root, *args)
+        Result.new(success: status.success?, stdout: stdout.to_s, stderr: stderr.to_s)
+      rescue Errno::ENOENT
+        Result.new(success: false, stdout: "", stderr: "git executable not found")
+      end
+    end
+  end
+end

data/lib/kward/workers/live_view.rb

@@ -0,0 +1,49 @@
+module Kward
+  module Workers
+    # Drains a running worker's accumulated event history into a frontend renderer.
+    class LiveView
+      FINISHED_STATUSES = %w[ready failed cancelled archived].freeze
+
+      def initialize(worker:, agent:, renderer:, poll_interval: 0.05)
+        @worker = worker
+        @agent = agent
+        @renderer = renderer
+        @poll_interval = poll_interval
+        @seen_events = worker.event_history.length
+        @stop = false
+        @thread = nil
+      end
+
+      attr_reader :worker, :agent
+
+      def start
+        @thread = Thread.new { run }
+        @thread.report_on_exception = false
+        self
+      end
+
+      def stop
+        @stop = true
+        @thread&.join(0.2)
+      end
+
+      private
+
+      def run
+        until @stop
+          events = @worker.event_history[@seen_events..] || []
+          events.each { |event| @renderer.call(event, @agent) }
+          @seen_events += events.length
+          @renderer.call(:flush, @agent) if finished?
+          break if finished?
+
+          sleep @poll_interval
+        end
+      end
+
+      def finished?
+        FINISHED_STATUSES.include?(@worker.status)
+      end
+    end
+  end
+end