ace-assign 0.42.4 → 0.53.4

data/lib/ace/assign/molecules/skill_assign_source_resolver.rb

@@ -11,12 +11,44 @@ module Ace
       #
       # Flow:
       # 1) Find SKILL.md by skill name (e.g., "ace-task-work")
-      # 2) Read assign.source URI from skill frontmatter (e.g., wfi://task/work)
+      # 2) Read workflow binding from skill.execution.workflow (fallback: assign.source)
       # 3) Resolve workflow file from URI
       # 4) Parse workflow assign frontmatter (sub-steps/context)
       class SkillAssignSourceResolver
         ASSIGN_CAPABLE_KINDS = %w[workflow orchestration].freeze
 
+        class << self
+          def clear_caches!
+            @cache_store = {
+              frontmatter_and_body_cache: {},
+              skill_index_cache: {},
+              assign_capable_skill_names_cache: {},
+              assign_step_catalog_cache: {},
+              resolve_wfi_uri_cache: {}
+            }
+          end
+
+          def cache_store
+            @cache_store ||= {
+              frontmatter_and_body_cache: {},
+              skill_index_cache: {},
+              assign_capable_skill_names_cache: {},
+              assign_step_catalog_cache: {},
+              resolve_wfi_uri_cache: {}
+            }
+          end
+
+          private
+
+          def cached_value(store_key, key)
+            cache_store[store_key][key]
+          end
+
+          def store_cached_value(store_key, key, value)
+            cache_store[store_key][key] = value
+          end
+        end
+
         def initialize(project_root: nil, skill_paths: nil, workflow_paths: nil)
           @project_root = project_root || Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
           configured_skill_paths = skill_paths || Ace::Assign.config["skill_source_paths"]
@@ -29,6 +61,24 @@ module Ace
           @skill_paths = (canonical_paths + override_paths).uniq
           @workflow_paths = (canonical_workflow_paths + configured_workflow_paths).uniq
           @skill_index = nil
+          @cache_signature = nil
+        end
+
+        def clear_caches!
+          @skill_index = nil
+          @assign_capable_skill_names = nil
+          @assign_step_catalog = nil
+          @cache_signature = nil
+        end
+
+        def cache_signature
+          @cache_signature ||= begin
+            [
+              project_root,
+              skill_path_signature,
+              workflow_path_signature
+            ].join("|")
+          end
         end
 
         # Resolve assign config for a skill.
@@ -40,19 +90,17 @@ module Ace
           skill_path = skill_index[skill_name] || find_skill_by_convention(skill_name)
           return nil unless skill_path
 
-          skill_frontmatter = parse_frontmatter(File.read(skill_path))
-          if assign_capable_skill_frontmatter?(skill_frontmatter) && skill_frontmatter["assign"]
-            validate_assign_source!(skill_frontmatter["assign"], skill_name)
-          end
-
+          skill_frontmatter = cached_parse_frontmatter_from_file(skill_path)
           assign_block = skill_frontmatter["assign"]
           return nil unless assign_block.is_a?(Hash)
 
-          source = assign_block["source"]&.to_s&.strip
+          validate_workflow_binding!(skill_frontmatter, skill_name) if assign_capable_skill_frontmatter?(skill_frontmatter)
+
+          source = workflow_binding_for_skill_frontmatter(skill_frontmatter)
           return nil if source.nil? || source.empty?
 
           workflow_path = resolve_source_uri(source, skill_name)
-          workflow_frontmatter = parse_frontmatter(File.read(workflow_path))
+          workflow_frontmatter = cached_parse_frontmatter_from_file(workflow_path)
           parsed = Atoms::AssignFrontmatterParser.parse(workflow_frontmatter)
 
           unless parsed[:valid]
@@ -66,20 +114,26 @@ module Ace
         #
         # Assign-capable skills are canonical skills with:
         # - skill.kind: workflow|orchestration
-        # - assign.source present and non-empty
+        # - workflow binding present (skill.execution.workflow or assign.source)
         #
         # @return [Array<String>] Skill names
         # @raise [Ace::Assign::Error] When assign-capable skill has invalid assign metadata
         def assign_capable_skill_names
-          skill_index.keys.sort.filter do |skill_name|
-            skill_path = skill_index[skill_name]
-            frontmatter = parse_frontmatter(File.read(skill_path))
+          cached = self.class.send(:cached_value, :assign_capable_skill_names_cache, cache_signature)
+          return cached if cached
+
+          names = skill_index.keys.sort.filter do |skill_name|
+            frontmatter = skill_index_frontmatter(skill_name)
             next false unless assign_capable_skill_frontmatter?(frontmatter)
+            next false unless public_discovery_skill_frontmatter?(frontmatter)
             next false unless frontmatter["assign"].is_a?(Hash)
 
-            validate_assign_source!(frontmatter["assign"], skill_name)
+            validate_workflow_binding!(frontmatter, skill_name)
             true
           end
+
+          self.class.send(:store_cached_value, :assign_capable_skill_names_cache, cache_signature, names)
+          names
         end
 
         # Build assignment step entries from canonical skills.
@@ -90,12 +144,14 @@ module Ace
         #
         # @return [Array<Hash>] Step definitions keyed by canonical precedence
         def assign_step_catalog
+          cached = self.class.send(:cached_value, :assign_step_catalog_cache, cache_signature)
+          return cached if cached
+
           catalog = {}
 
           each_assign_capable_skill do |skill_name, frontmatter|
             steps = frontmatter.dig("assign", "steps")
-            workflow_source = frontmatter.dig("assign", "source")&.to_s&.strip
-            workflow_source = frontmatter.dig("skill", "execution", "workflow")&.to_s&.strip if workflow_source.nil? || workflow_source.empty?
+            workflow_source = workflow_binding_for_skill_frontmatter(frontmatter)
             next unless steps.is_a?(Array)
 
             steps.each do |step|
@@ -107,6 +163,7 @@ module Ace
 
               entry = step.dup
               entry["name"] = step_name
+              entry["source"] = "skill://#{skill_name}"
               entry["skill"] = skill_name
               entry["source_skill"] = skill_name
               entry["workflow"] = workflow_source if workflow_source && !workflow_source.empty?
@@ -115,7 +172,9 @@ module Ace
             end
           end
 
-          catalog.values
+          catalog_values = catalog.values
+          self.class.send(:store_cached_value, :assign_step_catalog_cache, cache_signature, catalog_values)
+          catalog_values
         end
 
         # Resolve canonical skill rendering details for a skill-backed step.
@@ -126,18 +185,16 @@ module Ace
           skill_path = skill_index[skill_name] || find_skill_by_convention(skill_name)
           return nil unless skill_path
 
-          frontmatter, skill_body = parse_frontmatter_and_body(File.read(skill_path))
-          workflow_source = frontmatter.dig("assign", "source")&.to_s&.strip
-          if workflow_source.nil? || workflow_source.empty?
-            workflow_source = frontmatter.dig("skill", "execution", "workflow")&.to_s&.strip
-          end
+          frontmatter, skill_body = cached_parse_frontmatter_and_body_from_file(skill_path)
+          workflow_source = workflow_binding_for_skill_frontmatter(frontmatter)
 
           workflow_path = resolve_workflow_path(workflow_source, skill_name)
-          workflow_body = workflow_path ? parse_frontmatter_and_body(File.read(workflow_path)).last.to_s.strip : ""
+          workflow_body = workflow_path ? cached_parse_frontmatter_and_body_from_file(workflow_path).last.to_s.strip : ""
 
           {
             "name" => frontmatter["name"] || skill_name,
             "description" => frontmatter["description"],
+            "source" => "skill://#{skill_name}",
             "skill" => skill_name,
             "workflow" => workflow_source,
             "workflow_path" => workflow_path,
@@ -152,10 +209,11 @@ module Ace
           workflow_path = resolve_workflow_path(workflow_ref, step_name || source_skill || workflow_ref)
           return nil unless workflow_path
 
-          frontmatter, body = parse_frontmatter_and_body(File.read(workflow_path))
+          frontmatter, body = cached_parse_frontmatter_and_body_from_file(workflow_path)
           {
             "name" => step_name || frontmatter["name"],
             "description" => frontmatter["description"],
+            "source" => workflow_ref,
             "workflow" => workflow_ref,
             "workflow_path" => workflow_path,
             "source_skill" => source_skill,
@@ -163,17 +221,57 @@ module Ace
           }
         end
 
+        # Resolve rendering details from canonical source reference.
+        #
+        # @param source [String]
+        # @return [Hash, nil]
+        def resolve_source_rendering(source, step_name: nil, source_skill: nil)
+          source_ref = source&.to_s&.strip
+          return nil if source_ref.nil? || source_ref.empty?
+
+          if source_ref.start_with?("skill://")
+            skill_name = source_ref.delete_prefix("skill://").strip
+            return nil if skill_name.empty?
+
+            return resolve_skill_rendering(skill_name)
+          end
+
+          return resolve_workflow_rendering(source_ref, step_name: step_name, source_skill: source_skill) if source_ref.start_with?("wfi://")
+
+          raise Error, "Unsupported source '#{source_ref}'. Supported: skill://..., wfi://..."
+        end
+
         def resolve_workflow_assign_config(workflow_source, step_name: nil, source_skill: nil)
           rendering = resolve_workflow_rendering(workflow_source, step_name: step_name, source_skill: source_skill)
           return nil unless rendering && rendering["workflow_path"]
 
-          workflow_frontmatter = parse_frontmatter(File.read(rendering["workflow_path"]))
+          workflow_frontmatter = cached_parse_frontmatter_from_file(rendering["workflow_path"])
           parsed = Atoms::AssignFrontmatterParser.parse(workflow_frontmatter)
           return nil unless parsed[:valid]
 
           parsed[:config]
         end
 
+        # Resolve assign config from canonical source reference.
+        #
+        # @param source [String]
+        # @return [Hash, nil]
+        def resolve_source_assign_config(source, step_name: nil, source_skill: nil)
+          source_ref = source&.to_s&.strip
+          return nil if source_ref.nil? || source_ref.empty?
+
+          if source_ref.start_with?("skill://")
+            skill_name = source_ref.delete_prefix("skill://").strip
+            return nil if skill_name.empty?
+
+            return resolve_assign_config(skill_name)
+          end
+
+          return resolve_workflow_assign_config(source_ref, step_name: step_name, source_skill: source_skill) if source_ref.start_with?("wfi://")
+
+          raise Error, "Unsupported source '#{source_ref}'. Supported: skill://..., wfi://..."
+        end
+
         # Resolve canonical rendering details for a public step name.
         #
         # @param step_name [String]
@@ -182,12 +280,17 @@ module Ace
           entry = assign_step_catalog.find { |step| step["name"] == step_name }
           return nil unless entry
 
-          workflow_rendering = resolve_workflow_rendering(
-            entry["workflow"],
+          source_rendering = resolve_source_rendering(
+            entry["source"] || entry["workflow"],
             step_name: entry["name"],
             source_skill: entry["source_skill"] || entry["skill"]
           )
-          return entry.merge(workflow_rendering) if workflow_rendering
+          if source_rendering
+            merged = entry.merge(source_rendering)
+            merged["name"] = entry["name"] if entry["name"]
+            merged["description"] = entry["description"] if entry["description"]
+            return merged
+          end
 
           rendering = resolve_skill_rendering(entry["skill"])
           return nil unless rendering
@@ -200,19 +303,22 @@ module Ace
         attr_reader :project_root, :skill_paths, :workflow_paths
 
         def skill_index
-          @skill_index ||= begin
-            index = {}
-            skill_paths.each do |base_path|
-              Dir.glob(File.join(base_path, "**", "SKILL.md")).sort.each do |path|
-                frontmatter = parse_frontmatter(File.read(path))
-                name = frontmatter["name"]&.to_s
-                index[name] ||= path if name && !name.empty?
-              rescue
-                next
-              end
+          cached = self.class.send(:cached_value, :skill_index_cache, cache_signature)
+          return cached if cached
+
+          index = {}
+          skill_paths.each do |base_path|
+            Dir.glob(File.join(base_path, "**", "SKILL.md")).sort.each do |path|
+              frontmatter = cached_parse_frontmatter_from_file(path)
+              name = frontmatter["name"]&.to_s
+              index[name] ||= path if name && !name.empty?
+            rescue
+              next
             end
-            index
           end
+
+          self.class.send(:store_cached_value, :skill_index_cache, cache_signature, index)
+          index
         end
 
         def normalize_paths(paths)
@@ -252,15 +358,51 @@ module Ace
           [frontmatter, body_lines.join]
         end
 
+        def cached_parse_frontmatter_from_file(path)
+          cached_parse_frontmatter_and_body_from_file(path).first
+        end
+
+        def cached_parse_frontmatter_and_body_from_file(path)
+          cache_key = cache_file_signature(path)
+          cached = self.class.send(:cached_value, :frontmatter_and_body_cache, path)
+          return cached[:value] if cached && cached[:signature] == cache_key
+
+          parsed = parse_frontmatter_and_body(File.read(path))
+          payload = {signature: cache_key, value: parsed}
+          self.class.send(:store_cached_value, :frontmatter_and_body_cache, path, payload)
+          parsed
+        end
+
+        def cache_file_signature(path)
+          stat = File.stat(path)
+          "#{stat.mtime.to_f}:#{stat.size}"
+        rescue
+          "missing"
+        end
+
+        def skill_index_frontmatter(skill_name)
+          skill_path = skill_index[skill_name]
+          return {} unless skill_path
+
+          cached_parse_frontmatter_from_file(skill_path)
+        end
+
         def assign_capable_skill_frontmatter?(frontmatter)
           kind = frontmatter.dig("skill", "kind")&.to_s
           ASSIGN_CAPABLE_KINDS.include?(kind)
         end
 
-        def validate_assign_source!(assign_block, skill_name)
-          source = assign_block["source"]&.to_s&.strip
+        def workflow_binding_for_skill_frontmatter(frontmatter)
+          source = frontmatter.dig("skill", "execution", "workflow")&.to_s&.strip
+          return source unless source.nil? || source.empty?
+
+          frontmatter.dig("assign", "source")&.to_s&.strip
+        end
+
+        def validate_workflow_binding!(frontmatter, skill_name)
+          source = workflow_binding_for_skill_frontmatter(frontmatter)
           if source.nil? || source.empty?
-            raise Error, "Missing assign.source for assign-capable skill '#{skill_name}'"
+            raise Error, "Missing workflow binding (skill.execution.workflow or assign.source) for assign-capable skill '#{skill_name}'"
           end
         end
 
@@ -273,15 +415,20 @@ module Ace
 
         def each_assign_capable_skill
           skill_index.each do |skill_name, skill_path|
-            frontmatter = parse_frontmatter(File.read(skill_path))
+            frontmatter = cached_parse_frontmatter_from_file(skill_path)
             next unless assign_capable_skill_frontmatter?(frontmatter)
+            next unless public_discovery_skill_frontmatter?(frontmatter)
             next unless frontmatter["assign"].is_a?(Hash)
 
-            validate_assign_source!(frontmatter["assign"], skill_name)
+            validate_workflow_binding!(frontmatter, skill_name)
             yield skill_name, frontmatter
           end
         end
 
+        def public_discovery_skill_frontmatter?(frontmatter)
+          frontmatter["user-invocable"] == true
+        end
+
         def discover_canonical_skill_source_paths
           discover_protocol_source_paths(
             protocol: "skill",
@@ -315,6 +462,24 @@ module Ace
           (registry_paths + discover_package_default_source_paths(package_glob)).uniq
         end
 
+        def skill_path_signature
+          @skill_path_signature ||= source_path_signature(skill_paths, "**/SKILL.md")
+        end
+
+        def workflow_path_signature
+          @workflow_path_signature ||= source_path_signature(workflow_paths, "**/*.wf.md")
+        end
+
+        def source_path_signature(base_paths, glob_pattern)
+          files = base_paths.flat_map do |base_path|
+            next [] unless File.directory?(base_path)
+
+            Dir.glob(File.join(base_path, glob_pattern)).sort
+          end
+
+          files.sort.map { |path| "#{path}:#{cache_file_signature(path)}" }.join("|")
+        end
+
         def with_project_root
           Dir.chdir(project_root) { yield }
         rescue Errno::ENOENT
@@ -371,23 +536,34 @@ module Ace
           if uri.start_with?("wfi://")
             resolve_wfi_uri(uri, skill_name)
           else
-            raise Error, "Unsupported assign.source '#{uri}' for skill '#{skill_name}'. Supported: wfi://..."
+            raise Error, "Unsupported workflow binding '#{uri}' for skill '#{skill_name}'. Supported: wfi://..."
           end
         end
 
         def resolve_wfi_uri(uri, skill_name)
+          cache_key = [
+            uri,
+            skill_name,
+            cache_signature
+          ].join("|")
+          cached = self.class.send(:cached_value, :resolve_wfi_uri_cache, cache_key)
+          return cached if cached
+
           workflow_name = uri.delete_prefix("wfi://").strip
           if workflow_name.empty?
-            raise Error, "Empty workflow name in assign.source '#{uri}' for skill '#{skill_name}'"
+            raise Error, "Empty workflow name in workflow binding '#{uri}' for skill '#{skill_name}'"
           end
 
           workflow_paths.each do |base_path|
             candidate = File.join(base_path, "#{workflow_name}.wf.md")
-            return candidate if File.exist?(candidate)
+            if File.exist?(candidate)
+              self.class.send(:store_cached_value, :resolve_wfi_uri_cache, cache_key, candidate)
+              return candidate
+            end
           end
 
           searched = workflow_paths.join(", ")
-          raise Error, "Could not resolve assign.source '#{uri}' for skill '#{skill_name}'. Searched: #{searched}"
+          raise Error, "Could not resolve workflow binding '#{uri}' for skill '#{skill_name}'. Searched: #{searched}"
         end
       end
     end

data/lib/ace/assign/molecules/tmux_fork_runner.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "shellwords"
+require "yaml"
+
+module Ace
+  module Assign
+    module Molecules
+      # Minimal tmux integration for forked subtree execution.
+      class TmuxForkRunner
+        DEFAULT_POLL_INTERVAL = 0.2
+
+        def initialize(tmux_binary: "tmux")
+          @tmux_binary = tmux_binary
+        end
+
+        def tmux_context?
+          !current_session.to_s.strip.empty?
+        end
+
+        def current_session
+          explicit = ENV["ACE_TMUX_SESSION"].to_s.strip
+          return explicit unless explicit.empty?
+          return nil if ENV["TMUX"].to_s.strip.empty?
+
+          capture([tmux_binary, "display-message", "-p", "#S"]).stdout
+        rescue
+          nil
+        end
+
+        def current_window
+          explicit = ENV["ACE_ASSIGN_FORK_WINDOW"].to_s.strip
+          return explicit unless explicit.empty?
+          session = ENV["ACE_TMUX_SESSION"].to_s.strip
+          if !session.empty?
+            window = capture([tmux_binary, "display-message", "-t", "#{session}:", "-p", "#W"]).stdout
+            return window unless window.empty?
+
+            return active_window_name(session)
+          end
+          return nil if ENV["TMUX"].to_s.strip.empty?
+
+          capture([tmux_binary, "display-message", "-p", "#W"]).stdout
+        rescue
+          nil
+        end
+
+        def fork_window_name(base_window)
+          base = base_window.to_s.strip
+          return base if base.end_with?("-fs")
+
+          "#{base}-fs"
+        end
+
+        def ensure_window(session:, name:, root:)
+          return {created: false, target: "#{session}:#{name}"} if window_exists?(session: session, name: name)
+
+          result = capture([tmux_binary, "new-window", "-t", "#{session}:", "-n", name, "-c", File.expand_path(root)])
+          raise Error, "Failed to create tmux fork window #{name}: #{result.stderr}" unless result.success?
+
+          {created: true, target: "#{session}:#{name}"}
+        end
+
+        def prepare_pane(session:, window:, root:, keep_existing:)
+          target = "#{session}:#{window}"
+          if keep_existing
+            pane = first_pane(target)
+            set_pane_remain_on_exit(pane)
+            select_layout(target)
+            return pane
+          end
+
+          result = capture([tmux_binary, "split-window", "-t", target, "-c", File.expand_path(root), "-P", "-F", '#{pane_id}'])
+          raise Error, "Failed to create tmux fork pane in #{window}: #{result.stderr}" unless result.success?
+
+          pane = result.stdout
+          set_pane_remain_on_exit(pane)
+          select_layout(target)
+          pane
+        end
+
+        def select_window(session:, window:)
+          run!([tmux_binary, "select-window", "-t", "#{session}:#{window}"], "select tmux fork window #{window}")
+        end
+
+        def run_script_in_pane(pane_target:, script_path:)
+          command = "bash #{Shellwords.escape(File.expand_path(script_path))}"
+          run!([tmux_binary, "send-keys", "-t", pane_target, command, "Enter"], "send tmux fork command")
+        end
+
+        def wait_for_completion(status_file:, timeout:)
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout.to_i
+          until File.exist?(status_file)
+            if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+              raise Error, "Timed out waiting for tmux fork pane to finish (#{File.basename(status_file)})"
+            end
+
+            sleep(DEFAULT_POLL_INTERVAL)
+          end
+
+          status = File.read(status_file).strip
+          Integer(status)
+        rescue ArgumentError
+          raise Error, "Invalid tmux fork status file: #{status_file}"
+        end
+
+        def merge_tmux_metadata(session_meta_file:, session:, window:, pane:)
+          data = if File.exist?(session_meta_file)
+            YAML.safe_load_file(session_meta_file) || {}
+          else
+            {}
+          end
+          data["launch_mode"] = "tmux"
+          data["tmux_session"] = session
+          data["tmux_window"] = window
+          data["tmux_pane_id"] = pane
+          File.write(session_meta_file, data.to_yaml)
+        end
+
+        private
+
+        attr_reader :tmux_binary
+
+        def window_exists?(session:, name:)
+          result = capture([tmux_binary, "list-windows", "-t", session, "-F", '#{window_name}'])
+          return false unless result.success?
+
+          result.stdout_lines.any? { |value| value == name }
+        end
+
+        def active_window_name(session)
+          result = capture([tmux_binary, "list-windows", "-t", session, "-F", '#{window_active} #{window_name}'])
+          return nil unless result.success?
+
+          active = result.stdout_lines.find { |line| line.start_with?("1 ") }
+          active&.sub(/\A1\s+/, "") || result.stdout_lines.first&.sub(/\A[01]\s+/, "")
+        end
+
+        def first_pane(target)
+          result = capture([tmux_binary, "list-panes", "-t", target, "-F", '#{pane_id}'])
+          raise Error, "Failed to inspect panes for #{target}: #{result.stderr}" unless result.success?
+
+          pane = result.stdout_lines.first
+          raise Error, "No panes found for #{target}" if pane.to_s.empty?
+
+          pane
+        end
+
+        def set_pane_remain_on_exit(pane_target)
+          run!([tmux_binary, "set-option", "-p", "-t", pane_target, "remain-on-exit", "on"], "enable remain-on-exit")
+        end
+
+        def select_layout(target)
+          run!([tmux_binary, "select-layout", "-t", target, "tiled"], "apply tiled layout")
+        end
+
+        def run!(cmd, action)
+          result = capture(cmd)
+          return if result.success?
+
+          raise Error, "Failed to #{action}: #{result.stderr}"
+        end
+
+        def capture(cmd)
+          stdout, stderr, status = Open3.capture3(*cmd)
+          Result.new(stdout: stdout, stderr: stderr, status: status)
+        end
+
+        Result = Struct.new(:stdout, :stderr, :status, keyword_init: true) do
+          def success?
+            status.success?
+          end
+
+          def stdout
+            self[:stdout].to_s.strip
+          end
+
+          def stderr
+            self[:stderr].to_s.strip
+          end
+
+          def stdout_lines
+            stdout.split("\n").map(&:strip).reject(&:empty?)
+          end
+        end
+      end
+    end
+  end
+end