ace-coworker 0.6.0

data/lib/ace/coworker/organisms/start_config_writer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "commission_orchestrator"
+
+module Ace
+  module Coworker
+    module Organisms
+      # Writes the planner's per-role start configs (L4.3) into the
+      # prepared worktree: `.ace-local/coworker/prepare/<role>.yml`, ONE
+      # file per sequence leg. Every config is expanded by the SAME
+      # commission primitive that writes the default `config.yml`, so the
+      # round-trip guarantee ("what commission writes, start accepts")
+      # holds by construction and the ownership split stays one writer per
+      # file: `prepare` owns `prepare/<role>.yml`; the default config.yml
+      # (or any `--config` target) remains `commission`'s alone.
+      # Idempotent: a leg whose file already holds the identical content
+      # is reported as "reused" without a write; changed content (e.g. a
+      # different overseer) is overwritten deterministically ("updated") —
+      # prepare is the single writer of these files. No secrets, no
+      # assignment steps: only the seven documented config fields.
+      class StartConfigWriter
+        PREPARE_DIR = File.join(".ace-local", "coworker", "prepare")
+
+        # @param worktree_path [String] absolute path of the prepared worktree
+        # @param commission_factory [#call] test seam building a
+        #   CommissionOrchestrator for (worktree_path, target)
+        def initialize(worktree_path:, commission_factory: nil)
+          @worktree_path = worktree_path
+          @commission_factory = commission_factory || method(:default_commission)
+        end
+
+        # @param task [String] canonical task id
+        # @param sequence [Array<Hash>] composed role-sequence entries
+        #   ({"role" =>, "assignment" =>, …} from RoleSequenceComposer)
+        # @param overseer [String] reporting address for every leg
+        # @param dry_run [Boolean] resolve and validate without writes
+        # @return [Array<Hash>] {"role", "assignment", "path", "disposition"}
+        #   disposition: "created" | "reused" | "updated" | "planned" (dry-run)
+        # @raise [Error] when a leg cannot be commissioned (unknown role,
+        #   task/assignment mismatch, invalid assembly)
+        def call(task:, sequence:, overseer:, dry_run: false)
+          validate_role_names!(Array(sequence))
+
+          # Pre-resolve EVERY leg first (dry-run commission pass): a late
+          # leg failure must not leave earlier leg configs on disk — the
+          # same all-or-nothing pattern RoleSequenceComposer established.
+          # Legs composed under dry_run (a planned sequence, no assignment
+          # id yet) cannot be identity-checked against ace-assign, so they
+          # are planned as-is; a real run requires a composed assignment.
+          resolved_legs = Array(sequence).map do |entry|
+            unless dry_run || !entry["assignment"].to_s.strip.empty?
+              raise Error, "role '#{entry['role']}' has no composed assignment; " \
+                "compose the sequence (prepare without --dry-run) before writing its start config"
+            end
+
+            entry = entry.dup
+            entry["task"] = task
+            entry["overseer"] = overseer
+            entry["resolved_config"] =
+              entry["assignment"].to_s.strip.empty? ? nil : resolve_leg(entry)
+            entry
+          end
+
+          resolved_legs.map { |entry| write_leg(entry, dry_run: dry_run) }
+        end
+
+        private
+
+        def validate_role_names!(sequence)
+          sequence.each do |entry|
+            role = entry["role"].to_s
+            unless role.match?(/\A[\w.-]+\z/) && !role.match?(/\A\.+\z/)
+              raise Error, "invalid role name '#{role}' for start config"
+            end
+          end
+        end
+
+        def resolve_leg(entry)
+          commission = @commission_factory.call(@worktree_path,
+            target_path(entry["role"]))
+          # dry-run commission resolves, identity-checks, and schema-validates
+          # the leg config without touching the disk.
+          resolved = commission.call(role: entry["role"], task: entry["task"],
+            assignment: entry["assignment"], overseer: entry["overseer"],
+            force: true, dry_run: true)
+          YAML.safe_dump(resolved.config)
+        end
+
+        def target_path(role)
+          File.join(@worktree_path, PREPARE_DIR, "#{role}.yml")
+        end
+
+        def write_leg(entry, dry_run:)
+          role = entry["role"]
+          content = entry["resolved_config"]
+          target = target_path(role)
+
+          existing = File.file?(target) ? File.read(target) : nil
+          disposition = if dry_run
+            "planned"
+          elsif existing == content
+            "reused"
+          else
+            commission = @commission_factory.call(@worktree_path, target)
+            commission.call(role: role, task: entry["task"],
+              assignment: entry["assignment"], overseer: entry["overseer"],
+              force: true, dry_run: false)
+            existing.nil? ? "created" : "updated"
+          end
+
+          {"role" => role, "assignment" => entry["assignment"],
+           "path" => File.join(PREPARE_DIR, "#{role}.yml"), "disposition" => disposition}
+        end
+
+        def default_commission(worktree_path, target)
+          CommissionOrchestrator.new(
+            project_root: worktree_path,
+            preset_loader: Molecules::RolePresetLoader.new(project_root: worktree_path),
+            task_probe: Molecules::TaskProbe.new(project_root: worktree_path),
+            assignment_metadata: Molecules::AssignmentMetadata.new(project_root: worktree_path),
+            config_path: target)
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/organisms/start_orchestrator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ace
+  module Coworker
+    module Organisms
+      # Orchestrates `ace-coworker start`: load+validate config, resolve the
+      # task in this worktree, verify the assignment exists and matches the
+      # config task, resolve the instruction source, and render the executor
+      # brief. Writes nothing; never creates a substitute assignment/worktree.
+      class StartOrchestrator
+        def initialize(project_root: nil, config_loader: nil, task_probe: nil, assignment_metadata: nil,
+          assignment_probe: nil, instruction_resolver: nil, config: nil)
+          @config = config || Ace::Coworker.config
+          @project_root = project_root || Molecules::ProjectRoot.new.resolve
+          @config_loader = config_loader || Molecules::ConfigLoader.new(project_root: @project_root, defaults: @config)
+          @task_probe = task_probe || Molecules::TaskProbe.new(project_root: @project_root)
+          @assignment_metadata = assignment_metadata || Molecules::AssignmentMetadata.new(project_root: @project_root)
+          @assignment_probe = assignment_probe || Molecules::AssignmentProbe.new(project_root: @project_root)
+          @instruction_resolver = instruction_resolver || Molecules::InstructionResolver.new(project_root: @project_root)
+        end
+
+        attr_reader :project_root
+
+        # @return [Models::Brief]
+        # @raise [Error] with a specific "not ready"/invalid/mismatch message
+        def call(config_path: nil)
+          cfg = @config_loader.load(path: config_path)
+
+          task_path = @task_probe.resolve!(cfg.task)
+          @assignment_metadata.verify_task_match!(cfg.assignment, cfg.task)
+          snapshot = @assignment_probe.snapshot(cfg.assignment)
+          instructions_source = @instruction_resolver.resolve!(cfg.instructions)
+
+          Models::Brief.new(
+            config: cfg,
+            instructions_source: instructions_source,
+            task_path: task_path,
+            assignment_snapshot: snapshot,
+            project_root: @project_root
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/organisms/status_orchestrator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ace
+  module Coworker
+    module Organisms
+      # Orchestrates `ace-coworker status`: readiness, resolved identity,
+      # assignment progress, completion verdict. A query — renders any state,
+      # including not-ready, without guessing.
+      class StatusOrchestrator
+        NotReady = Struct.new(:message, keyword_init: true)
+        Ready = Struct.new(:config, :snapshot, :project_root, :probe_error, :assignment, keyword_init: true)
+
+        def initialize(project_root: nil, config_loader: nil, assignment_metadata: nil,
+          assignment_probe: nil, config: nil)
+          @config = config || Ace::Coworker.config
+          @project_root = project_root || Molecules::ProjectRoot.new.resolve
+          @config_loader = config_loader || Molecules::ConfigLoader.new(project_root: @project_root, defaults: @config)
+          @assignment_metadata = assignment_metadata || Molecules::AssignmentMetadata.new(project_root: @project_root)
+          @assignment_probe = assignment_probe || Molecules::AssignmentProbe.new(project_root: @project_root)
+        end
+
+        attr_reader :project_root
+
+        # @return [NotReady, Ready]
+        def call(config_path: nil, assignment: nil)
+          # Same resolution rule as ConfigLoader: explicit paths are expanded
+          # against the project root, not the process working directory.
+          target = config_path ? File.expand_path(config_path, @project_root) : default_config_path
+          relative = relativize(target)
+          return NotReady.new(message: "not ready: #{relative} not found") unless File.file?(target)
+
+          begin
+            cfg = @config_loader.load(path: target)
+          rescue Error => e
+            return NotReady.new(message: e.message)
+          end
+
+          assignment_id = assignment.to_s.strip.empty? ? cfg.assignment : assignment.to_s.strip
+          begin
+            @assignment_metadata.verify_task_match!(assignment_id, cfg.task)
+            snapshot = @assignment_probe.snapshot(assignment_id)
+          rescue Error => e
+            return Ready.new(config: cfg, snapshot: nil, project_root: @project_root,
+              probe_error: e.message, assignment: assignment_id)
+          end
+
+          Ready.new(config: cfg, snapshot: snapshot, project_root: @project_root, assignment: assignment_id)
+        end
+
+        private
+
+        def default_config_path
+          @config_loader.config_path
+        end
+
+        def relativize(path)
+          path.start_with?(@project_root) ? path.delete_prefix("#{@project_root}/") : path
+        end
+      end
+    end
+  end
+end

data/lib/ace/coworker/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ace
+  module Coworker
+    VERSION = "0.6.0"
+  end
+end

data/lib/ace/coworker.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "ace/support/config"
+require_relative "coworker/version"
+require_relative "coworker/errors"
+
+module Ace
+  module Coworker
+    require_relative "coworker/models/config"
+    require_relative "coworker/models/brief"
+    require_relative "coworker/models/assignment_snapshot"
+    require_relative "coworker/models/outcome"
+    require_relative "coworker/models/resume_plan"
+    require_relative "coworker/models/preparation"
+
+    autoload :CLI, "ace/coworker/cli"
+
+    module Atoms
+      autoload :ConfigSchema, "ace/coworker/atoms/config_schema"
+      autoload :BriefFormatter, "ace/coworker/atoms/brief_formatter"
+      autoload :OutcomePlanner, "ace/coworker/atoms/outcome_planner"
+      autoload :ReportRecordFormatter, "ace/coworker/atoms/report_record_formatter"
+      autoload :ResumePlanner, "ace/coworker/atoms/resume_planner"
+      autoload :ResumeBriefFormatter, "ace/coworker/atoms/resume_brief_formatter"
+      autoload :PrepareDecision, "ace/coworker/atoms/prepare_decision"
+      autoload :ActiveExecutorRule, "ace/coworker/atoms/active_executor_rule"
+      autoload :RolePresetSchema, "ace/coworker/atoms/role_preset_schema"
+      autoload :PromptTemplate, "ace/coworker/atoms/prompt_template"
+      autoload :RoundRule, "ace/coworker/atoms/round_rule"
+      autoload :RoundRecordSchema, "ace/coworker/atoms/round_record_schema"
+      autoload :IntegrationGate, "ace/coworker/atoms/integration_gate"
+    end
+
+    module Molecules
+      autoload :ProjectRoot, "ace/coworker/molecules/project_root"
+      autoload :ConfigLoader, "ace/coworker/molecules/config_loader"
+      autoload :TaskProbe, "ace/coworker/molecules/task_probe"
+      autoload :AssignmentMetadata, "ace/coworker/molecules/assignment_metadata"
+      autoload :AssignmentProbe, "ace/coworker/molecules/assignment_probe"
+      autoload :InstructionResolver, "ace/coworker/molecules/instruction_resolver"
+      autoload :StepEvidenceReader, "ace/coworker/molecules/step_evidence_reader"
+      autoload :HitlReporter, "ace/coworker/molecules/hitl_reporter"
+      autoload :TaskRecordWriter, "ace/coworker/molecules/task_record_writer"
+      autoload :ReportStateStore, "ace/coworker/molecules/report_state_store"
+      autoload :StepReportReader, "ace/coworker/molecules/step_report_reader"
+      autoload :GitStateProbe, "ace/coworker/molecules/git_state_probe"
+      autoload :WorktreeProvisionProbe, "ace/coworker/molecules/worktree_provision_probe"
+      autoload :WorktreeExecutorProbe, "ace/coworker/molecules/worktree_executor_probe"
+      autoload :RolePresetLoader, "ace/coworker/molecules/role_preset_loader"
+      autoload :ReviewRoundStore, "ace/coworker/molecules/review_round_store"
+      autoload :RoleSequenceComposer, "ace/coworker/molecules/role_sequence_composer"
+    end
+
+    module Organisms
+      autoload :StartOrchestrator, "ace/coworker/organisms/start_orchestrator"
+      autoload :StatusOrchestrator, "ace/coworker/organisms/status_orchestrator"
+      autoload :ReportOrchestrator, "ace/coworker/organisms/report_orchestrator"
+      autoload :ResumeOrchestrator, "ace/coworker/organisms/resume_orchestrator"
+      autoload :PrepareOrchestrator, "ace/coworker/organisms/prepare_orchestrator"
+      autoload :CommissionOrchestrator, "ace/coworker/organisms/commission_orchestrator"
+      autoload :StartConfigWriter, "ace/coworker/organisms/start_config_writer"
+    end
+
+    def self.config
+      @config ||= begin
+        defaults = load_gem_defaults
+        user_config = Ace::Support::Config.create.resolve_namespace("coworker").to_h
+        Ace::Support::Config::Models::Config.wrap(defaults, user_config, source: "coworker")
+      end
+    end
+
+    def self.load_gem_defaults
+      gem_root = ::Gem.loaded_specs["ace-coworker"]&.gem_dir || File.expand_path("../..", __dir__)
+      defaults_path = File.join(gem_root, ".ace-defaults", "coworker", "config.yml")
+      raise Error, "Default config not found: #{defaults_path}" unless File.exist?(defaults_path)
+
+      YAML.safe_load_file(defaults_path, permitted_classes: [Date], aliases: true) || {}
+    end
+    private_class_method :load_gem_defaults
+
+    def self.reset_config!
+      @config = nil
+    end
+  end
+end

metadata

@@ -0,0 +1,319 @@
+--- !ruby/object:Gem::Specification
+name: ace-coworker
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Michal Czyz
+bindir: exe
+cert_chain: []
+date: 2026-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ace-support-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: ace-support-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+- !ruby/object:Gem::Dependency
+  name: ace-support-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: ace-support-fs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: ace-support-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+- !ruby/object:Gem::Dependency
+  name: ace-task
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.41'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.41'
+- !ruby/object:Gem::Dependency
+  name: ace-assign
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.72'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.72'
+- !ruby/object:Gem::Dependency
+  name: ace-hitl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: ace-git-worktree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.27'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.27'
+- !ruby/object:Gem::Dependency
+  name: ace-review
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+- !ruby/object:Gem::Dependency
+  name: ace-support-test-helpers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: ace-coworker composes the existing ace-assign lifecycle, ace-task ref
+  resolution, and ace-hitl reporting for a prepared executor role. It owns the .ace-local/coworker/
+  run configuration and renders the executor brief.
+email:
+- mc@cs3b.com
+executables:
+- ace-coworker
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ace-defaults/coworker/config.yml"
+- ".ace-defaults/coworker/roles/integrator.yml"
+- ".ace-defaults/coworker/roles/reviewer.yml"
+- ".ace-defaults/coworker/roles/spec.yml"
+- ".ace-defaults/coworker/roles/worker.yml"
+- ".ace-defaults/coworker/sequences/integrator.yml"
+- ".ace-defaults/coworker/sequences/reviewer.yml"
+- ".ace-defaults/coworker/sequences/spec.yml"
+- ".ace-defaults/coworker/sequences/worker.yml"
+- ".ace-defaults/nav/protocols/wfi-sources/ace-coworker.yml"
+- CHANGELOG.md
+- README.md
+- Rakefile
+- docs/usage.md
+- exe/ace-coworker
+- handbook/workflow-instructions/coworker/integrator.wf.md
+- handbook/workflow-instructions/coworker/reviewer.wf.md
+- handbook/workflow-instructions/coworker/spec.wf.md
+- handbook/workflow-instructions/coworker/worker.wf.md
+- lib/ace/coworker.rb
+- lib/ace/coworker/atoms/active_executor_rule.rb
+- lib/ace/coworker/atoms/brief_formatter.rb
+- lib/ace/coworker/atoms/config_schema.rb
+- lib/ace/coworker/atoms/integration_gate.rb
+- lib/ace/coworker/atoms/outcome_planner.rb
+- lib/ace/coworker/atoms/prepare_decision.rb
+- lib/ace/coworker/atoms/prompt_template.rb
+- lib/ace/coworker/atoms/report_record_formatter.rb
+- lib/ace/coworker/atoms/resume_brief_formatter.rb
+- lib/ace/coworker/atoms/resume_planner.rb
+- lib/ace/coworker/atoms/role_preset_schema.rb
+- lib/ace/coworker/atoms/round_record_schema.rb
+- lib/ace/coworker/atoms/round_rule.rb
+- lib/ace/coworker/cli.rb
+- lib/ace/coworker/cli/commands/commission.rb
+- lib/ace/coworker/cli/commands/gate.rb
+- lib/ace/coworker/cli/commands/prepare.rb
+- lib/ace/coworker/cli/commands/report.rb
+- lib/ace/coworker/cli/commands/resume.rb
+- lib/ace/coworker/cli/commands/roles.rb
+- lib/ace/coworker/cli/commands/rounds.rb
+- lib/ace/coworker/cli/commands/start.rb
+- lib/ace/coworker/cli/commands/status.rb
+- lib/ace/coworker/errors.rb
+- lib/ace/coworker/models/assignment_snapshot.rb
+- lib/ace/coworker/models/brief.rb
+- lib/ace/coworker/models/config.rb
+- lib/ace/coworker/models/outcome.rb
+- lib/ace/coworker/models/preparation.rb
+- lib/ace/coworker/models/resume_plan.rb
+- lib/ace/coworker/molecules/assignment_metadata.rb
+- lib/ace/coworker/molecules/assignment_probe.rb
+- lib/ace/coworker/molecules/config_loader.rb
+- lib/ace/coworker/molecules/git_state_probe.rb
+- lib/ace/coworker/molecules/hitl_reporter.rb
+- lib/ace/coworker/molecules/instruction_resolver.rb
+- lib/ace/coworker/molecules/project_root.rb
+- lib/ace/coworker/molecules/report_state_store.rb
+- lib/ace/coworker/molecules/review_round_store.rb
+- lib/ace/coworker/molecules/role_preset_loader.rb
+- lib/ace/coworker/molecules/role_sequence_composer.rb
+- lib/ace/coworker/molecules/step_evidence_reader.rb
+- lib/ace/coworker/molecules/step_report_reader.rb
+- lib/ace/coworker/molecules/task_probe.rb
+- lib/ace/coworker/molecules/task_record_writer.rb
+- lib/ace/coworker/molecules/worktree_executor_probe.rb
+- lib/ace/coworker/molecules/worktree_provision_probe.rb
+- lib/ace/coworker/organisms/commission_orchestrator.rb
+- lib/ace/coworker/organisms/prepare_orchestrator.rb
+- lib/ace/coworker/organisms/report_orchestrator.rb
+- lib/ace/coworker/organisms/resume_orchestrator.rb
+- lib/ace/coworker/organisms/start_config_writer.rb
+- lib/ace/coworker/organisms/start_orchestrator.rb
+- lib/ace/coworker/organisms/status_orchestrator.rb
+- lib/ace/coworker/version.rb
+homepage: https://github.com/cs3b/ace
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/cs3b/ace
+  source_code_uri: https://github.com/cs3b/ace/tree/main/ace-coworker/
+  changelog_uri: https://github.com/cs3b/ace/blob/main/ace-coworker/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Prepared executor that reads .ace-local/coworker/ and drives its ace-assign
+  assignment
+test_files: []