ace-task 0.39.1 → 0.39.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f78511a98128a2afd0cfd4d2120939912d8bc3ccc8865b3c40a032cff50fa6fd
-  data.tar.gz: ca39e7634c9e5276e546f4bb333b7920babfcc00f3e62675755f128b4c0f92e2
+  metadata.gz: bf3a2b4bdbf7c413363c5f9b81a0f0b4161e6b50e58cce724adcb67ba03fc1c2
+  data.tar.gz: b08a3d0f30ad8dfb455c6232bde690e632a9028a603ac37fa289a4768c2f0312
 SHA512:
-  metadata.gz: 69e57555803c7a2a9196559675bc1cf532955286e3704643bf1420c7484a525f41d9a1c7435e20349983ec70bcf0116d82bbd8fbfa49455cabf3fa57c86ea194
-  data.tar.gz: d6a7abcf1878a0799d0c34f195069f61b8ac20700700e0c82e83fa8cafe1beddde4141d3d374815f7bcb4b1ee01bac8453f7ddae66791c38e607cb7b01bef7bd
+  metadata.gz: ea63fb03267e6eb84875128ff0ec56becc9fbc0a650a40344cf9a1b11090a61791eed9c97a203ce8a231b132534d442d0238d93cac07162ecd96f522cdd930be
+  data.tar.gz: 2be684d6224ec2a57dc9cc4f84eafdee43c14e1b044116e470f12b51dd1cab952267ff9b4a05d96f6e2df5eb4ef1b10d0bd52e32a31e53275a8cdca7e43b0626

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.39.3] - 2026-10-12
+
+### Fixed
+
+- Route `ace-task create --in FOLDER` through the task manager's relocation API
+  and remove the newly created task artifacts when destination placement fails.
+
+## [0.39.2] - 2026-10-06
+
+### Fixed
+
+- Keep unresolved descendants from completing or archiving task families, return children correctly after legitimate archival, and prevent doctor from inferring completion from archive location.
+
 ## [0.39.1] - 2026-10-04
 
 ### Fixed

data/handbook/workflow-instructions/task/work.wf.md

@@ -74,6 +74,13 @@ Work through the plan checklist, step by step:
 - If a test fails: fix it before moving to the next step
 - If a test failure is undiagnosable after one attempt: stop and report
 
+**Diagnostic reruns and contract corrections:**
+- Before rerunning a failure, state the hypothesis and the observation that will distinguish it. Verify the runner's actual selected tests/count, effective configuration path and seed from its report or a narrow configuration probe; command arguments alone are not proof that options reached the child.
+- Resolve configuration against the runner's actual working directory. If it changes directories, use a verified absolute path. A reproduction with a different seed or zero selected tests does not satisfy the intended check.
+- Add bounded diagnostics at the failing boundary before repeating an opaque failure. Preserve earlier failures and distinguish product fixes, fixture corrections and diagnostic-only changes; do not rerun merely to obtain green output or silently increase deadlines.
+- Poll an owned live test handle to its terminal result. Quiet output is not a reason to start a duplicate run. After a meaningful fix or new hypothesis, rerun only the affected checks, then broaden when integration risk requires it.
+- When a contract changes, revise its current authoritative spec and consumer obligations together. Keep superseded decisions in history rather than leaving competing current addenda. A partial source commit cannot close an unverified acceptance criterion.
+
 **Task lifecycle:**
 - `draft` status: warn the user that the spec hasn't been reviewed, then continue only with explicit confirmation. In unattended/fork contexts where interactive confirmation is not possible, proceed after marking in-progress -- the assignment creation layer is responsible for blocking draft tasks before they reach this point.
 - Mark in-progress before first change, done after last verification

data/lib/ace/task/cli/commands/create.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ace/support/cli"
+require "fileutils"
 
 module Ace
   module Task
@@ -10,6 +11,9 @@ module Ace
         class Create < Ace::Support::Cli::Command
           include Ace::Support::Cli::Base
 
+          # "next" is a move-to-root alias and is validated separately.
+          BUILT_IN_DESTINATIONS = %w[maybe anytime archive].freeze
+
           desc <<~DESC.strip
             Create a new task
 
@@ -38,7 +42,8 @@ module Ace
           option :server, type: :string, desc: "Named forge server"
           option :"default-server", type: :boolean, desc: "Use the configured default forge server"
           option :"child-of", type: :string, desc: "Parent task reference (creates subtask)"
-          option :in, type: :string, aliases: %w[-i], desc: "Target folder (e.g. next, maybe)"
+          option :in, type: :string, aliases: %w[-i],
+            desc: "Top-level target (next, maybe, anytime, archive, or existing custom folder)"
           option :"dry-run", type: :boolean, aliases: %w[-n], desc: "Preview without writing"
 
           option :git_commit, type: :boolean, aliases: %w[--gc], desc: "Auto-commit changes"
@@ -72,6 +77,10 @@ module Ace
               end
             end
 
+            manager = Ace::Task::Organisms::TaskManager.new
+            validate_destination!(manager, in_folder) if in_folder && !child_of
+            placement_directories_before = directories_under(manager.root_dir) if in_folder && !child_of
+
             if dry_run
               puts "Would create task:"
               puts "  Title:    #{title}"
@@ -85,8 +94,6 @@ module Ace
               return
             end
 
-            manager = Ace::Task::Organisms::TaskManager.new
-
             task = begin
               if child_of
                 manager.create_subtask(
@@ -119,7 +126,7 @@ module Ace
 
             # Move to folder if specified
             if in_folder && !child_of
-              task = manager.move(task.id, to: in_folder)
+              task = place_created_task(manager, task, in_folder, placement_directories_before)
             end
 
             puts "Created task #{task.id}"
@@ -140,6 +147,117 @@ module Ace
 
           private
 
+          def validate_destination!(manager, target_folder)
+            detector = Ace::Support::Items::Atoms::SpecialFolderDetector
+            return if detector.move_to_root?(target_folder)
+
+            if detector.virtual_filter?(target_folder)
+              raise Ace::Support::Cli::Error,
+                "Destination '#{target_folder}' is a virtual list filter, not a physical folder."
+            end
+
+            normalized = detector.normalize(target_folder)
+            configured_path = File.join(manager.root_dir, normalized)
+            normalized_built_ins = BUILT_IN_DESTINATIONS.map { |name| detector.normalize(name) }
+            valid = !target_folder.strip.empty? &&
+              !normalized.include?(File::SEPARATOR) &&
+              !normalized.include?("..") &&
+              (normalized_built_ins.include?(normalized) || Dir.exist?(configured_path)) &&
+              destination_within_root?(manager.root_dir, configured_path)
+            return if valid
+
+            choices = (["next"] + BUILT_IN_DESTINATIONS).join(", ")
+            raise Ace::Support::Cli::Error,
+              "Destination '#{target_folder}' does not exist. " \
+                "Use #{choices}, or an existing custom task folder."
+          end
+
+          def destination_within_root?(root, destination)
+            return true unless File.exist?(destination)
+
+            root_path = File.realpath(root)
+            destination_path = File.realpath(destination)
+            destination_path.start_with?(root_path + File::SEPARATOR)
+          rescue Errno::ENOENT, Errno::EACCES
+            false
+          end
+
+          def place_created_task(manager, task, target_folder, directories_before)
+            placed_task = manager.update(task.id, move_to: target_folder)
+            expected_folder = if Ace::Support::Items::Atoms::SpecialFolderDetector.move_to_root?(target_folder)
+              nil
+            else
+              Ace::Support::Items::Atoms::SpecialFolderDetector.normalize(target_folder)
+            end
+
+            unless placed_task && placed_task.special_folder == expected_folder
+              actual_folder = if placed_task
+                placed_task.special_folder || "root"
+              else
+                "no task returned"
+              end
+              # This internal signal is wrapped below with rollback and an actionable CLI error.
+              raise "placement returned #{actual_folder.inspect}, expected #{expected_folder || "root"}"
+            end
+
+            placed_task
+          rescue Ace::Git::Error
+            # update retains linked tasks after post-placement sync failures as
+            # recovery records; those are not destination-placement failures.
+            raise
+          rescue StandardError => e
+            begin
+              remove_created_task_artifacts(manager, task)
+              remove_empty_directories_created_since(manager.root_dir, directories_before)
+            rescue StandardError => cleanup_error
+              raise Ace::Support::Cli::Error,
+                "Failed to create task in '#{target_folder}': #{e.message}. " \
+                  "Cleanup also failed: #{cleanup_error.message}"
+            end
+            raise Ace::Support::Cli::Error,
+              "Failed to create task in '#{target_folder}': #{e.message}. " \
+                "No task was created; fix the destination and retry."
+          end
+
+          def remove_created_task_artifacts(manager, task)
+            root = File.expand_path(manager.root_dir)
+            candidates = [task.path]
+            candidates.concat(
+              Dir.glob(File.join(root, "**", "#{task.id}-*")).select { |path| File.directory?(path) }
+            )
+
+            candidates.uniq.each do |path|
+              expanded = File.expand_path(path)
+              next unless expanded.start_with?(root + File::SEPARATOR)
+
+              FileUtils.rm_rf(expanded)
+            end
+
+            remaining = Dir.glob(File.join(root, "**", "#{task.id}-*")).select { |path| File.exist?(path) }
+            return if remaining.empty?
+
+            raise Ace::Support::Cli::Error,
+              "Failed to remove partial task artifacts after placement failure: #{remaining.join(", ")}"
+          end
+
+          def directories_under(root)
+            return [] unless Dir.exist?(root)
+
+            [File.expand_path(root)] + Dir.glob(File.join(root, "**", "*"))
+              .select { |path| File.directory?(path) }
+              .map { |path| File.expand_path(path) }
+          end
+
+          def remove_empty_directories_created_since(root, directories_before)
+            # Only directories created during this short command transaction
+            # are candidates, and non-empty concurrent directories are retained.
+            (directories_under(root) - directories_before).sort_by(&:length).reverse_each do |path|
+              Dir.rmdir(path)
+            rescue Errno::ENOENT, Errno::ENOTEMPTY
+              next
+            end
+          end
+
           def resolve_title(positional_title, flag_title)
             positional_present = present_string?(positional_title)
             flag_present = present_string?(flag_title)

data/lib/ace/task/molecules/task_doctor_fixer.rb

@@ -8,6 +8,7 @@ require_relative "../atoms/task_id_formatter"
 require_relative "../atoms/task_validation_rules"
 require_relative "../atoms/task_frontmatter_defaults"
 require_relative "task_scanner"
+require_relative "task_family_completion"
 
 module Ace
   module Task
@@ -218,7 +219,9 @@ module Ace
         end
 
         def fix_archive_status(file_path)
-          update_frontmatter_field(file_path, "status", "done", "Updated status to 'done' (in _archive/)")
+          log_fix(file_path, "Skipped status repair: archive location does not prove task completion")
+          @skipped_count += 1
+          false
         end
 
         def fix_maybe_terminal(file_path)
@@ -456,6 +459,16 @@ module Ace
             description = "Moved parent task to _archive/ (all subtasks terminal)"
           end
 
+          source_spec = find_primary_spec(source_dir)
+          source_frontmatter, = Ace::Support::Items::Atoms::FrontmatterParser.parse(File.read(source_spec))
+          unless TaskFamilyCompletion.new(@root_dir).descendants_terminal?(
+            source_dir, id: source_frontmatter["id"]
+          )
+            log_fix(source_dir, "Skipped archive move: descendants are not all terminal")
+            @skipped_count += 1
+            return false
+          end
+
           if @dry_run
             log_fix(source_dir, "Would #{description.downcase}")
             @fixed_count += 1
@@ -493,16 +506,7 @@ module Ace
         end
 
         def all_siblings_terminal?(parent_dir, parent_id)
-          scanner = TaskScanner.new(@root_dir)
-          subtasks = scanner.scan_subtasks(parent_dir, parent_id: parent_id)
-          return false if subtasks.empty?
-
-          subtasks.all? do |scan_result|
-            content = File.read(scan_result.file_path)
-            frontmatter, _body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
-            status = frontmatter.is_a?(Hash) ? frontmatter["status"] : nil
-            Atoms::TaskValidationRules.terminal_status?(status.to_s.downcase)
-          end
+          TaskFamilyCompletion.new(@root_dir).complete?(parent_dir, id: parent_id)
         end
       end
     end

data/lib/ace/task/molecules/task_family_completion.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "task_scanner"
+require_relative "../atoms/task_validation_rules"
+
+module Ace
+  module Task
+    module Molecules
+      # Task-aware traversal excludes evidence folders and the parent's own status.
+      class TaskFamilyCompletion
+        def initialize(root_dir)
+          @scanner = TaskScanner.new(root_dir)
+        end
+
+        def descendants_terminal?(path, id:)
+          @scanner.scan_subtasks(path, parent_id: id).all? do |child|
+            content = File.read(child.file_path)
+            frontmatter, = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+            Atoms::TaskValidationRules.terminal_status?(frontmatter["status"].to_s.downcase) &&
+              descendants_terminal?(child.dir_path, id: child.id)
+          end
+        end
+
+        def complete?(path, id:)
+          @scanner.scan_subtasks(path, parent_id: id).any? && descendants_terminal?(path, id: id)
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/organisms/task_manager.rb

@@ -9,6 +9,7 @@ require_relative "../molecules/task_resolver"
 require_relative "../molecules/task_loader"
 require_relative "../molecules/task_creator"
 require_relative "../molecules/subtask_creator"
+require_relative "../molecules/task_family_completion"
 require_relative "../molecules/task_reparenter"
 require_relative "../molecules/issue_link"
 require_relative "../atoms/task_validation_rules"
@@ -190,6 +191,13 @@ module Ace
             special_folder: scan_result.special_folder)
           return nil unless task
 
+          if Ace::Support::Items::Atoms::SpecialFolderDetector.normalize(move_to) == "_archive" &&
+              !task.subtask? && !family_completion.descendants_terminal?(task.path, id: task.id)
+            @last_update_note = "Task #{task.id} was not archived because descendants are not all terminal; " \
+              "resolve blocked or unfinished subtasks before archiving. No requested fields were changed."
+            return task
+          end
+
           # Apply field updates if any
           has_field_updates = [set, add, remove].any? { |h| h && !h.empty? }
           reject_issue_metadata_update!(set, add, remove)
@@ -258,11 +266,11 @@ module Ace
           # Auto-archive hook: if a subtask status was set to terminal,
           # check if all siblings are terminal and auto-move parent to archive
           if set && set.key?("status")
-            check_auto_archive(task, set["status"], loader)
+            check_auto_archive(task, set["status"])
           end
 
           # Reload and return updated task
-          updated_task = loader.load(current_path, id: current_id, special_folder: current_special)
+          updated_task = show(current_id)
           if sync_needed_after_update?(task, updated_task, set: set, add: add, remove: remove, move_to: move_to)
             sync_failed_definitively = false
             with_issue_identity_lock(linked_issue(updated_task) || {}) do
@@ -847,25 +855,23 @@ module Ace
 
         # Auto-archive: if a subtask reaches terminal status and all siblings
         # in the parent directory are also terminal, move the parent to archive.
-        def check_auto_archive(task, new_status, loader)
-          terminal = Ace::Support::Items::Atoms::FolderCompletionDetector::TERMINAL_STATUSES
-          return unless terminal.include?(new_status.to_s.downcase)
+        def check_auto_archive(task, new_status)
+          return unless Atoms::TaskValidationRules.terminal_status?(new_status.to_s.downcase)
+          return unless task.subtask?
 
-          # Only applies to subtasks (task dir is nested inside a parent dir)
-          parent_dir = File.dirname(task.path)
-          return if File.expand_path(parent_dir) == File.expand_path(@root_dir)
+          current = show(task.id)
+          return unless current && current.special_folder != "_archive"
 
-          # Check if all specs in the parent dir (recursive for subtask subdirs) are terminal
-          return unless Ace::Support::Items::Atoms::FolderCompletionDetector.all_terminal?(
-            parent_dir, recursive: true
-          )
-
-          parent = load_parent_from_directory(parent_dir, loader)
-          return unless parent
+          parent = show(current.parent_id)
+          return unless parent && family_completion.complete?(parent.path, id: parent.id)
 
           archive_parent_via_update(parent)
         end
 
+        def family_completion
+          Molecules::TaskFamilyCompletion.new(@root_dir)
+        end
+
         def parse_archive_date(task)
           raw = task.metadata["completed_at"] || task.metadata["created_at"]
           return nil unless raw
@@ -897,10 +903,7 @@ module Ace
             }
           end
 
-          parent_with_subtasks = loader.load(parent.path, id: parent.id, special_folder: parent.special_folder)
-          subtasks = parent_with_subtasks&.subtasks || []
-          all_terminal = subtasks.any? &&
-            subtasks.all? { |st| Atoms::TaskValidationRules.terminal_status?(st.status.to_s.downcase) }
+          all_terminal = family_completion.complete?(parent.path, id: parent.id)
 
           unless all_terminal
             @last_update_note = "Subtask #{task.id} was not archived because sibling subtasks are not all terminal."
@@ -941,16 +944,6 @@ module Ace
           archived_parent
         end
 
-        def load_parent_from_directory(parent_dir, loader)
-          parent_id = File.basename(parent_dir).split("-", 2).first
-          return nil unless parent_id
-
-          parent_special = Ace::Support::Items::Atoms::SpecialFolderDetector.detect_in_path(
-            parent_dir, root: @root_dir
-          )
-          loader.load(parent_dir, id: parent_id, special_folder: parent_special)
-        end
-
         # Value accessor for FilterApplier
         def task_value_accessor(item, key)
           case key

data/lib/ace/task/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Task
-    VERSION = "0.39.1"
+    VERSION = "0.39.3"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-task
 version: !ruby/object:Gem::Version
-  version: 0.39.1
+  version: 0.39.3
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-core
@@ -204,6 +204,7 @@ files:
 - lib/ace/task/molecules/task_display_formatter.rb
 - lib/ace/task/molecules/task_doctor_fixer.rb
 - lib/ace/task/molecules/task_doctor_reporter.rb
+- lib/ace/task/molecules/task_family_completion.rb
 - lib/ace/task/molecules/task_frontmatter_validator.rb
 - lib/ace/task/molecules/task_loader.rb
 - lib/ace/task/molecules/task_plan_cache.rb