ace-overseer 0.22.0 → 0.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3913e2fb5bdc611dec02a5cb33fca48a5395e216a09ae477e4bb452e8e4ec3ef
-  data.tar.gz: fffdbb4d1b7cd1c28ad81595ce9bb064a23e8a7c708e1c693ccad7c1d54d99a1
+  metadata.gz: b00e42cea8d8748ae7bf4495d2ae97a16261bc9542882e47a8634ef7eac6f784
+  data.tar.gz: 44952270d2e973eb4c43b9412a30206b8a46c6fc96bb89c62e04ef072e942e5c
 SHA512:
-  metadata.gz: 979a9f3a8f9eff1155f458fa0c54112b01c234078a93f9e4c3eddc1b1b758b3608c30694ce9054b94b27c907cce0efd3fede25c37ba12e1ce85e1810f6820373
-  data.tar.gz: 4853d86cf0df5b06f3b5ed689ccd94483ea017c006836b358b1c805a337f85cccff266e353079766ac84bf4ffacb76508bf79f91ecf421429e57d145b6ab52d9
+  metadata.gz: c32caa5bd06bb268d3f0b1614af8dd5ba2c05537154b571c37314e0220eec8ffec6694fec40cddac76c036ffb6fb09a114999c44fc4cad73335d64460984954d
+  data.tar.gz: c93f4cd4d8c94de422486c65a2ab822e646ae2ac519832f8dc5e9e4b78b658c75789940b79e21af62b396628a489f20662287df4f28293eea84fd1b460259469

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.23.1] - 2026-10-17
+
+### Changed
+
+- Adapt status and prune collection to `ace-git-worktree`'s inventory-based
+  `list_all` (no `show_tasks:` argument) after the 0.27 active-worktree listing
+  rework, and raise the dependency floor to `ace-git-worktree ~> 0.27` so
+  overseer stays aligned with the current worktree minor release line.
+
+## [0.23.0] - 2026-10-16
+
+### Added
+
+- Add explicit ordinary preparation/launch/resume using existing worktree, native pane and provider mechanisms. Preserve original identities and dispatch intent on response loss; use native filesystem watches only as canonical-inspection hints.
+
+### Changed
+
+- Follow ace-review 0.61 campaign head-assessment contracts (dependency floor).
+
 ## [0.22.0] - 2026-10-16
 
 ### Added

data/docs/usage.md

@@ -12,6 +12,7 @@ ace-docs:
 ## Command Surface
 
 - `ace-overseer work-on`
+- `ace-overseer ordinary`
 - `ace-overseer status`
 - `ace-overseer prune`
 - `ace-overseer projects`
@@ -54,6 +55,50 @@ observation, never canonical terminal/release or physical cleanup permission.
 Recovery reports absent/mismatched local inputs separately from original canonical
 reservation attribution, without upload, reconstruction or retry.
 
+## `ace-overseer ordinary`
+
+Ordinary execution is explicit and uses the root-selected project's Assign owner.
+`work-on --project` keeps its protected contract and never falls back here.
+The native supervisor prepares each reviewed leaf in its own existing worktree
+and prepared pane, registers exact captured inputs, then launches its explicit
+provider profile:
+
+```sh
+ace-overseer ordinary --operation prepare --project atlas --task 8wr.t.abc --checkout /lab/projects/atlas \
+  --provider pi:zai/glm-5.3-flash:high --output /private/ordinary/task-one
+ace-overseer ordinary --operation launch --project atlas --context /private/ordinary/task-one/context.json
+ace-overseer ordinary --operation resume --project atlas --context /private/ordinary/task-one/context.json
+```
+
+Preparation validates the explicit checkout against the installed Git common directory, then uses WorktreeProvisioner, WindowOpener and PreparedWorkBuilder. Project configuration resolves inside the selected checkout/worktree even when the native supervisor runs from another project. The
+provider/model/thinking selection must resolve through the existing LLM builder.
+It retains exact IDs, HEAD, scope and worker pane before registration. If the
+registration reply is lost, inspect canonical status through that original
+context; if registration is absent, replay the original `prepared/request.json`
+with `ace-lab assignment request`. Do not create another preparation to bypass
+uncertainty. Partial preparation errors preserve their files for inspection.
+
+Launch verifies the actual current native supervisor against canonical ownership,
+retains a dispatch intent before native send and sends the worker's ordinary
+`/as-assign-drive` entry. Acknowledgement means accepted send, not process start.
+The worker must register its own actual start through the installed owner.
+An existing dispatch intent plus no start stays `dispatch_uncertain`; neither
+launch nor resume sends a second command. `status` and `resume` are read-only
+observations of the original assignment/attempt and current supervisor selection.
+
+The returned native `/watch add` command watches a result hint file. Install it
+once in the supervisor session, persist through a harmless turn, then resume the
+exact session without replaying add commands or restoring intentional removals.
+A watch is only a wake hint; canonical `ace-lab assignment drive --operation status`
+and `adopt` decide outcome. Existing progress-audit duties also reconcile lost
+hints. A replaced coordinator first performs explicit canonical supervisor
+adoption as documented in Lab usage; worker identities and requests survive it.
+
+For two workers, repeat prepare with two reviewed leaf tasks and separate output
+directories. Verify two distinct panes/attempts, two canonical starts and results,
+and sequential reviewed ordinary merges. This source interface does not claim
+installed watches, real provider turns, review, release or merge acceptance.
+
 ## `ace-overseer status`
 
 Show status for active task worktrees.

data/lib/ace/overseer/cli/commands/ordinary.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../../organisms/ordinary_work_on"
+
+module Ace
+  module Overseer
+    module CLI
+      module Commands
+        class Ordinary < Ace::Support::Cli::Command
+          desc "Prepare, launch or resume one ordinary execution through installed Assign"
+          option :operation, required: true, desc: "prepare, launch, status, resume (status/resume never dispatch)"
+          option :project, required: true, desc: "Installed ordinary project ID"
+          option :task, desc: "Reviewed leaf task for preparation"
+          option :checkout, desc: "Explicit project checkout validated against installed common directory"
+          option :output, desc: "New private retained input directory for preparation"
+          option :provider, desc: "Explicit interactive provider/model/thinking selection"
+          option :context, desc: "Original context.json for launch/status/resume"
+
+          def call(operation:, project:, **options)
+            entry = Organisms::OrdinaryWorkOn.new
+            result = case operation
+            when "prepare"
+              entry.prepare(project: project, task: options.fetch(:task), checkout: options.fetch(:checkout),
+                output: options.fetch(:output), provider: options.fetch(:provider))
+            when "launch" then entry.launch(project: project, context: options.fetch(:context))
+            when "status", "resume" then entry.resume(project: project, context: options.fetch(:context))
+            else raise ArgumentError, "unknown ordinary operation"
+            end
+            puts JSON.generate(result)
+          rescue ArgumentError, KeyError, SystemCallError, Ace::Overseer::Error, Ace::Assign::Error, Ace::Lab::Error, Ace::Runtime::Error, Ace::LLM::Error => error
+            raise Ace::Support::Cli::Error, "ordinary handoff incomplete: #{error.message}; retain its inputs and inspect the original context"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/overseer/cli.rb

@@ -10,6 +10,7 @@ require_relative "cli/commands/agents"
 require_relative "cli/commands/prompt"
 require_relative "cli/commands/review"
 require_relative "cli/commands/stop"
+require_relative "cli/commands/ordinary"
 
 module Ace
   module Overseer
@@ -20,6 +21,7 @@ module Ace
 
       REGISTERED_COMMANDS = [
         ["work-on", "Start local task work or one retained protected launch"],
+        ["ordinary", "Prepare, launch, inspect or resume one installed ordinary execution"],
         ["status", "Show status of task worktrees"],
         ["prune", "Remove stale task worktrees"],
         ["projects", "List visible public projects"],
@@ -36,6 +38,7 @@ module Ace
       ].freeze
 
       register "work-on", Commands::WorkOn
+      register "ordinary", Commands::Ordinary
       register "status", Commands::Status
       register "prune", Commands::Prune
       register "projects", Commands::Projects

data/lib/ace/overseer/organisms/ordinary_work_on.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "ace/lab/organisms/ordinary_assignment_client"
+require "ace/lab/molecules/ordinary_worktree_read"
+require "ace/assign/organisms/ordinary_driver"
+require "ace/assign/molecules/runtime_control_surface_runner"
+require "ace/llm"
+
+module Ace
+  module Overseer
+    module Organisms
+      # Ordinary entry: existing worktree/native launch mechanisms, immutable
+      # request inputs, and canonical Assign observations. No local execution.
+      class OrdinaryWorkOn
+        Files = Ace::Assign::Authority::RetainedInput
+
+        def initialize(config: nil, runtime: nil, provisioner: nil, windows: nil, builder: nil, client: nil, prepare: nil, observer: nil)
+          @config, @runtime = config, runtime
+          @provisioner = provisioner
+          @windows = windows
+          @builder = builder
+          @client = client
+          @prepare = prepare || Ace::Lab::Organisms::OrdinaryAssignmentClient.method(:prepare)
+          @observer = observer
+        end
+
+        def prepare(project:, task:, checkout:, output:, provider:)
+          config = selected(project)
+          caller = supervisor!(config)
+          checkout = File.realpath(checkout)
+          # The native coordinator can live in a different project. Explicit
+          # preparation cwd must resolve to this installed common directory.
+          source_reader = @observer || Ace::Lab::Molecules::OrdinaryWorktreeRead.new(root: checkout,
+            common_dir: config.worktrees.fetch("common_dir"), deadline: Process.clock_gettime(Process::CLOCK_MONOTONIC) + 30)
+          source_reader.observe(checkout)
+          directory = Files.create_output(output)
+          worktree = in_worktree(checkout) do
+            provisioner = @provisioner || Molecules::WorktreeProvisioner.new(
+              manager: Ace::Git::Worktree::Organisms::WorktreeManager.new(project_root: checkout))
+            provisioner.provision(task).fetch(:worktree_path)
+          end
+          cwd = validate_worktree!(config, worktree)
+          # Resolve actual provider arguments before creating any pane/agent.
+          prepared = in_worktree(cwd) do
+            (@builder || Ace::LLM::Molecules::InteractiveCommandBuilder.new).build(
+              provider_model: provider, prompt: "ordinary preparation", working_dir: cwd)
+            @prepare.call(project: project, task: task, pane: caller.fetch(:pane), output: File.join(directory, "prepared"))
+          end
+          window = (@windows || Molecules::WindowOpener.new(runtime: runtime)).open(worktree_path: cwd)
+          pane = runtime.prepare_pane(window: window)
+          context = {"version" => 1, "project_id" => project, "assignment_id" => prepared.fetch("assignment_id"),
+            "attempt_id" => SecureRandom.hex(16), "scope" => prepared.fetch("scope"), "pane" => pane,
+            "supervisor_pane" => caller.fetch(:pane), "cwd" => cwd,
+            "head" => observe(config, cwd).fetch("head"), "provider" => provider}
+          Files.write_file(directory, "context.json", JSON.generate(context) + "\n")
+          Files.write_file(directory, "result-hint.json", JSON.generate({"hint_only" => true}))
+          registration = client(project).request(input: prepared.fetch("request"))
+          unless registration.dig("data", "assignment_id") == prepared.fetch("assignment_id") &&
+              registration.dig("data", "project_id") == project
+            raise Error, "ordinary registration returned a different project or assignment; recover #{directory}/context.json"
+          end
+          describe(File.join(directory, "context.json"), context).merge("state" => "ready_not_dispatched", "window" => window)
+        end
+
+        def launch(project:, context:)
+          driver = driver(project, context)
+          selected_context = driver.context
+          config = selected(project)
+          caller = supervisor!(config)
+          supervisor = driver.supervisor
+          unless runtime.process_binding(pane: caller.fetch(:pane), caller_pid: Process.pid) == supervisor.fetch("binding")
+            raise Error, "ordinary launch belongs to the canonical native supervisor; adopt explicitly after its previous generation ends"
+          end
+          cwd = validate_worktree!(config, selected_context.fetch("cwd"))
+          directory = File.dirname(driver.path)
+          # Canonical supervisor lookup also proves registration. Recovery does
+          # not register again or reconstruct work from a local assignment cache.
+          observed = driver.status
+          return describe(driver.path, selected_context).merge("canonical" => observed) unless observed.fetch("state") == "not_started"
+          unless observe(config, cwd).fetch("head") == selected_context.fetch("head")
+            raise Error, "ordinary launch checkout moved; preserve original context and reconcile before dispatch"
+          end
+          invocation = in_worktree(cwd) do
+            (@builder || Ace::LLM::Molecules::InteractiveCommandBuilder.new).build(provider_model: selected_context.fetch("provider"),
+              prompt: "/as-assign-drive --ordinary #{driver.path.shellescape}", working_dir: cwd,
+              subprocess_env: {"ACE_ASSIGN_ORDINARY_CONTEXT" => driver.path,
+                "ACE_ASSIGN_ORDINARY_PROJECT" => project, "ACE_RUNTIME" => "herdr"})
+          end
+          # Create before native send. A lost send/reply cannot cause another
+          # invocation. Resume only observes; it never deletes this intent.
+          intent = {"pane" => selected_context.fetch("pane"), "assignment_id" => selected_context.fetch("assignment_id"),
+            "attempt_id" => selected_context.fetch("attempt_id"), "provider" => invocation.fetch(:provider),
+            "model" => invocation.fetch(:model), "thinking_level" => invocation[:thinking_level],
+            "command_sha256" => Digest::SHA256.hexdigest(invocation.fetch(:command).to_json)}
+          begin
+            Files.write_file(directory, "dispatch.json", JSON.generate(intent) + "\n")
+          rescue Errno::EEXIST
+            return describe(driver.path, selected_context).merge("state" => "dispatch_uncertain", "canonical" => observed,
+              "remediation" => "Inspect the original pane and canonical status; never launch a replacement from this context")
+          end
+          runner = Ace::Assign::Molecules::RuntimeControlSurfaceRunner.new(runtime: "herdr", adapter: runtime)
+          runner.run_invocation_in_pane(pane_target: selected_context.fetch("pane"), command: invocation.fetch(:command),
+            env: invocation[:env], working_dir: invocation.fetch(:working_dir), visible_handoff: invocation[:prompt])
+          describe(driver.path, selected_context).merge("state" => "accepted_not_started", "canonical" => driver.status)
+        end
+
+        # Restart/recovery is an observation of original IDs, never redispatch.
+        def resume(project:, context:)
+          driver = driver(project, context)
+          describe(driver.path, driver.context).merge("canonical" => driver.status,
+            "supervisor" => driver.supervisor,
+            "dispatch_intent" => File.file?(File.join(File.dirname(driver.path), "dispatch.json")))
+        end
+
+        private
+
+        def selected(project)
+          config = @config || Ace::Lab::Molecules::OrdinaryOwnerConfig.load(project: project)
+          raise Error, "ordinary project selection differs" unless config.project == project
+          config.verify_owner!
+          config
+        end
+
+        def client(project)
+          @client || Ace::Lab::Organisms::OrdinaryAssignmentClient.new(project: project)
+        end
+
+        def driver(project, context)
+          Ace::Assign::Organisms::OrdinaryDriver.new(path: context, project: project, transport: client(project))
+        end
+
+        def runtime
+          @runtime ||= Ace::Herdr::Organisms::RuntimeAdapter.new
+        end
+
+        def supervisor!(config)
+          participant = config.selected_principal!(Process.uid)
+          caller = runtime.context
+          unless caller[:in_runtime] && caller[:session] == participant.fetch("workspace") &&
+              participant.fetch("supervisor_panes").include?(caller[:pane])
+            raise Error, "ordinary preparation and launch require the selected native supervisor"
+          end
+          caller
+        end
+
+        def validate_worktree!(config, path)
+          actual = File.realpath(path)
+          root = File.realpath(config.worktrees.fetch("root"))
+          raise Error, "ordinary worktree is outside installed project selection" unless actual.start_with?(root + "/")
+          actual
+        end
+
+        def observe(config, cwd)
+          reader = @observer || Ace::Lab::Molecules::OrdinaryWorktreeRead.new(root: config.worktrees.fetch("root"),
+            common_dir: config.worktrees.fetch("common_dir"), deadline: Process.clock_gettime(Process::CLOCK_MONOTONIC) + 30)
+          reader.observe(cwd)
+        end
+
+        def in_worktree(path)
+          previous = ENV["PROJECT_ROOT_PATH"]
+          Dir.chdir(path) do
+            ENV["PROJECT_ROOT_PATH"] = path
+            Ace::Support::Fs::Molecules::ProjectRootFinder.clear_cache!
+            Ace::Assign.reset_config!
+            Ace::LLM.reset_configuration!
+            yield
+          end
+        ensure
+          ENV["PROJECT_ROOT_PATH"] = previous
+          Ace::Support::Fs::Molecules::ProjectRootFinder.clear_cache!
+          Ace::Assign.reset_config!
+          Ace::LLM.reset_configuration!
+        end
+
+        def describe(path, context)
+          read = "ace-lab assignment drive --project #{context.fetch('project_id').shellescape} --context #{path.shellescape} --operation status"
+          {"context" => path, **context.slice("project_id", "assignment_id", "attempt_id", "scope", "pane", "supervisor_pane", "cwd", "provider"),
+            "watch_command" => "/watch add ordinary-#{context.fetch('attempt_id')} --path #{File.join(File.dirname(path), 'result-hint.json').to_json} " \
+              "--message #{("Ordinary result hint only. Run #{read}; adopt only its exact canonical submitted result. Preserve original IDs on uncertainty.").to_json}",
+            "status_command" => read}
+        end
+      end
+    end
+  end
+end

data/lib/ace/overseer/organisms/prune_orchestrator.rb

@@ -45,7 +45,7 @@ module Ace
           progress = on_progress || ->(_msg) {}
 
           progress.call("Scanning worktrees...")
-          result = @worktree_manager.list_all(show_tasks: true)
+          result = @worktree_manager.list_all
           raise Error, result[:error] || "Failed to list worktrees" unless result[:success]
 
           all_worktrees = Array(result[:worktrees]).reject(&:bare)

data/lib/ace/overseer/organisms/status_collector.rb

@@ -14,7 +14,7 @@ module Ace
         end
 
         def collect
-          result = @worktree_manager.list_all(show_tasks: true)
+          result = @worktree_manager.list_all
           raise Error, result[:error] || "Failed to list worktrees" unless result[:success]
 
           all_worktrees = Array(result[:worktrees]).reject(&:bare)

data/lib/ace/overseer/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Overseer
-    VERSION = "0.22.0"
+    VERSION = "0.23.1"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-overseer
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.23.1
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-16 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -99,14 +99,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.27'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.27'
 - !ruby/object:Gem::Dependency
   name: ace-task
   requirement: !ruby/object:Gem::Requirement
@@ -183,14 +183,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.60.3
+        version: 0.61.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.60.3
+        version: 0.61.0
 - !ruby/object:Gem::Dependency
   name: ace-support-test-helpers
   requirement: !ruby/object:Gem::Requirement
@@ -286,6 +286,7 @@ files:
 - lib/ace/overseer/atoms/status_formatter.rb
 - lib/ace/overseer/cli.rb
 - lib/ace/overseer/cli/commands/agents.rb
+- lib/ace/overseer/cli/commands/ordinary.rb
 - lib/ace/overseer/cli/commands/projects.rb
 - lib/ace/overseer/cli/commands/prompt.rb
 - lib/ace/overseer/cli/commands/prune.rb
@@ -310,6 +311,7 @@ files:
 - lib/ace/overseer/molecules/worktree_context_collector.rb
 - lib/ace/overseer/molecules/worktree_provisioner.rb
 - lib/ace/overseer/organisms/launch_recovery.rb
+- lib/ace/overseer/organisms/ordinary_work_on.rb
 - lib/ace/overseer/organisms/protected_prune.rb
 - lib/ace/overseer/organisms/protected_review.rb
 - lib/ace/overseer/organisms/protected_status.rb