ace-task 0.39.3 → 0.41.0

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

@@ -57,12 +57,8 @@ module Ace
             else
               generate_slugs(title)
             end
-            folder_slug = slugs[:folder]
-            file_slug = slugs[:file]
-
-            # Create folder with folder_slug
-            folder_name = Atoms::TaskIdFormatter.folder_name(formatted_id, folder_slug)
-            task_dir = File.join(@root_dir, folder_name)
+            paths = destination_paths_for(formatted_id, slugs)
+            task_dir = paths[:dir]
             FileUtils.mkdir_p(task_dir)
 
             begin
@@ -79,9 +75,8 @@ module Ace
                 remote_issue: remote_issue
               )
 
-              # Write spec file with file_slug
-              spec_filename = Atoms::TaskIdFormatter.spec_filename(formatted_id, file_slug)
-              spec_file = File.join(task_dir, spec_filename)
+              # Write the spec file with the title-derived file slug
+              spec_file = paths[:spec]
               content = build_spec_content(frontmatter: frontmatter, title: title)
               File.write(spec_file, content)
 
@@ -95,8 +90,32 @@ module Ace
           end
         end
 
+        # Non-mutating preview of the directory and spec file a create call
+        # with this title would write at the given time. Pre-write checks use
+        # it to inspect the real generated ID and title-derived slugs instead
+        # of sampling representative names; create uses the same naming helper.
+        # The CLI never requests LLM slugs, so the preview is deterministic.
+        #
+        # @param title [String] Task title
+        # @param time [Time] Creation time used for the generated ID
+        # @return [Array<String>] Task directory and spec file path
+        def destination_paths(title, time: Time.now.utc)
+          raise ArgumentError, "Title is required" if title.nil? || title.strip.empty?
+
+          formatted_id = Atoms::TaskIdFormatter.generate(time).formatted_id
+          paths = destination_paths_for(formatted_id, generate_slugs(title))
+          [paths[:dir], paths[:spec]]
+        end
+
         private
 
+        def destination_paths_for(formatted_id, slugs)
+          folder_name = Atoms::TaskIdFormatter.folder_name(formatted_id, slugs[:folder])
+          task_dir = File.join(@root_dir, folder_name)
+          spec_filename = Atoms::TaskIdFormatter.spec_filename(formatted_id, slugs[:file])
+          {dir: task_dir, spec: File.join(task_dir, spec_filename)}
+        end
+
         def task_id_exists?(formatted_id)
           Dir.glob(File.join(@root_dir, "**", "#{formatted_id}-*")).any? do |path|
             File.directory?(path)

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 "git_ignored_path"
 require_relative "task_family_completion"
 
 module Ace
@@ -459,7 +460,22 @@ module Ace
             description = "Moved parent task to _archive/ (all subtasks terminal)"
           end
 
+          # A Git-ignored task path is not part of the committed tree; the
+          # repository archive policy neither applies nor authorizes a move.
+          # The destination is checked too: moving into an ignored archive
+          # bucket would expose the family content to normal staging.
           source_spec = find_primary_spec(source_dir)
+          mover = Ace::Support::Items::Molecules::FolderMover.new(@root_dir)
+          destination = mover.destination_path(
+            Struct.new(:path).new(source_dir), to: "archive", date: archive_time
+          )
+          if Molecules::GitIgnoredPath.ignored_family?(source_dir) ||
+              Molecules::GitIgnoredPath.ignored_after_relocation?(source_dir, destination)
+            log_fix(source_dir, "Skipped archive move: Git-ignored task path")
+            @skipped_count += 1
+            return false
+          end
+
           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"]
@@ -475,7 +491,6 @@ module Ace
             return true
           end
 
-          mover = Ace::Support::Items::Molecules::FolderMover.new(@root_dir)
           mover.move(Struct.new(:path).new(source_dir), to: "archive", date: archive_time)
           log_fix(source_dir, description)
           @fixed_count += 1

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

@@ -6,6 +6,7 @@ require "time"
 require "ace/support/items"
 require "ace/b36ts"
 require_relative "path_utils"
+require_relative "task_config_loader"
 
 module Ace
   module Task
@@ -20,7 +21,7 @@ module Ace
         end
 
         def cache_dir
-          File.join(Dir.pwd, @cache_root, @task_id)
+          File.join(project_root, @cache_root, @task_id)
         end
 
         def prompts_dir
@@ -162,7 +163,11 @@ module Ace
           return "" if path.nil? || path.to_s.empty?
           return path if path.start_with?("/")
 
-          File.expand_path(path, Dir.pwd)
+          File.expand_path(path, project_root)
+        end
+
+        def project_root
+          Ace::Task::Molecules::TaskConfigLoader.project_root
         end
 
         def relative_path(path)

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

@@ -35,6 +35,32 @@ module Ace
           end
         end
 
+        # Destination paths a reparent will create, without mutating anything.
+        # Returns the destination directories and every generated spec file
+        # (order is not significant): the task's own renamed spec plus each
+        # descendant's spec, whose basename follows the descendant's new ID.
+        # Used by pre-flight checks such as the --git-commit ignored-path
+        # guard, which must test the names the move will actually write.
+        #
+        # @param task [Models::Task] Task to reparent
+        # @param target [String] "none", "self", or a parent ref
+        # @param resolve_ref [Proc] Resolves a parent ref to a Task
+        # @return [Array<String>] Destination directories and spec file paths
+        def destination_paths(task, target:, resolve_ref:)
+          case target.downcase
+          when "none"
+            promoted_destination_paths(task)
+          when "self"
+            orchestrator_destination_paths(task)
+          else
+            parent_task = resolve_ref.call(target)
+            raise ArgumentError, "Parent task '#{target}' not found" unless parent_task
+            raise ArgumentError, "Cannot reparent task to itself" if task.id == parent_task.id
+
+            demoted_destination_paths(task, parent_task)
+          end
+        end
+
         private
 
         # Promote a subtask to a standalone task at root level.
@@ -44,17 +70,10 @@ module Ace
             raise ArgumentError, "Task #{task.id} is already a standalone task"
           end
 
-          # Generate new standalone ID preserving the original timestamp
-          raw_b36ts = Atoms::TaskIdFormatter.reconstruct(base_task_id(task.id))
-          new_item_id = Atoms::TaskIdFormatter.format(raw_b36ts)
-          new_id = new_item_id.formatted_id
-
-          # Extract slug from current folder name
-          slug = extract_slug(task.path, task.id)
-
-          # Build new folder/file names
-          new_folder_name = Atoms::TaskIdFormatter.folder_name(new_id, slug)
-          new_dir = File.join(@root_dir, new_folder_name)
+          paths = promoted_paths(task)
+          new_id = paths[:id]
+          new_dir = paths[:dir]
+          new_folder_name = paths[:folder_name]
 
           raise ArgumentError, "Destination already exists: #{new_dir}" if File.exist?(new_dir)
 
@@ -63,7 +82,7 @@ module Ace
 
           # Rename spec file and update frontmatter
           old_spec_basename = File.basename(task.file_path)
-          new_spec_basename = "#{new_folder_name}.s.md"
+          new_spec_basename = paths[:spec_basename]
           old_spec_in_new_dir = File.join(new_dir, old_spec_basename)
           new_spec_path = File.join(new_dir, new_spec_basename)
 
@@ -91,20 +110,16 @@ module Ace
             raise ArgumentError, "Cannot convert subtask #{task.id} to orchestrator — promote first"
           end
 
-          slug = extract_slug(task.path, task.id)
-
-          # Create subtask ID using first subtask char (0)
-          next_char = SubtaskCreator::SUBTASK_CHARS[0]
-          subtask_id = "#{task.id}.#{next_char}"
-          subtask_folder_name = "#{next_char}-#{slug}"
-          subtask_dir = File.join(task.path, subtask_folder_name)
+          paths = orchestrator_paths(task)
+          subtask_id = paths[:id]
+          subtask_dir = paths[:dir]
+          subtask_spec_name = paths[:spec_basename]
 
           raise ArgumentError, "Subtask directory already exists: #{subtask_dir}" if File.exist?(subtask_dir)
 
           FileUtils.mkdir_p(subtask_dir)
 
           # Move current spec file into subtask dir with renamed filename
-          subtask_spec_name = "#{subtask_id}-#{slug}.s.md"
           subtask_spec_path = File.join(subtask_dir, subtask_spec_name)
           FileUtils.mv(task.file_path, subtask_spec_path)
 
@@ -140,15 +155,10 @@ module Ace
             raise ArgumentError, "Cannot reparent task to itself"
           end
 
-          # Allocate next subtask char
-          existing_chars = scan_existing_subtask_chars(parent_task.path, parent_task.id)
-          next_char = allocate_next_char(existing_chars)
-
-          # Build new subtask ID
-          new_id = "#{parent_task.id}.#{next_char}"
-          slug = extract_slug(task.path, task.id)
-          new_folder_name = "#{next_char}-#{slug}"
-          new_dir = File.join(parent_task.path, new_folder_name)
+          paths = demoted_paths(task, parent_task)
+          new_id = paths[:id]
+          new_dir = paths[:dir]
+          new_spec_basename = paths[:spec_basename]
 
           raise ArgumentError, "Destination already exists: #{new_dir}" if File.exist?(new_dir)
 
@@ -157,7 +167,6 @@ module Ace
 
           # Rename spec file
           old_spec_basename = File.basename(task.file_path)
-          new_spec_basename = "#{new_id}-#{slug}.s.md"
           old_spec_in_new_dir = File.join(new_dir, old_spec_basename)
           new_spec_path = File.join(new_dir, new_spec_basename)
 
@@ -234,6 +243,94 @@ module Ace
           end
         end
 
+        # Destination naming shared by the move and its pre-flight preview.
+
+        def promoted_paths(task)
+          raw_b36ts = Atoms::TaskIdFormatter.reconstruct(base_task_id(task.id))
+          new_id = Atoms::TaskIdFormatter.format(raw_b36ts).formatted_id
+          slug = extract_slug(task.path, task.id)
+          folder_name = Atoms::TaskIdFormatter.folder_name(new_id, slug)
+          dir = File.join(@root_dir, folder_name)
+          {id: new_id, dir: dir, folder_name: folder_name, spec_basename: "#{folder_name}.s.md"}
+        end
+
+        def orchestrator_paths(task)
+          slug = extract_slug(task.path, task.id)
+          next_char = SubtaskCreator::SUBTASK_CHARS[0]
+          subtask_id = "#{task.id}.#{next_char}"
+          folder_name = "#{next_char}-#{slug}"
+          dir = File.join(task.path, folder_name)
+          {id: subtask_id, dir: dir, folder_name: folder_name, spec_basename: "#{subtask_id}-#{slug}.s.md"}
+        end
+
+        def demoted_paths(task, parent_task)
+          existing_chars = scan_existing_subtask_chars(parent_task.path, parent_task.id)
+          next_char = allocate_next_char(existing_chars)
+          new_id = "#{parent_task.id}.#{next_char}"
+          slug = extract_slug(task.path, task.id)
+          folder_name = "#{next_char}-#{slug}"
+          dir = File.join(parent_task.path, folder_name)
+          {id: new_id, dir: dir, folder_name: folder_name, spec_basename: "#{new_id}-#{slug}.s.md"}
+        end
+
+        # Destination previews pair each naming plan with the spec files the
+        # move will actually write: the task's renamed spec and every
+        # descendant spec renamed to the new ID.
+        def promoted_destination_paths(task)
+          paths = promoted_paths(task)
+          [
+            paths[:dir],
+            File.join(paths[:dir], paths[:spec_basename]),
+            *descendant_destination_specs(task.path, paths[:dir], new_parent_id: paths[:id])
+          ]
+        end
+
+        def orchestrator_destination_paths(task)
+          paths = orchestrator_paths(task)
+          [
+            task.path,
+            File.join(task.path, "#{File.basename(task.path)}.s.md"),
+            paths[:dir],
+            File.join(paths[:dir], paths[:spec_basename])
+          ]
+        end
+
+        def demoted_destination_paths(task, parent_task)
+          paths = demoted_paths(task, parent_task)
+          [
+            paths[:dir],
+            File.join(paths[:dir], paths[:spec_basename]),
+            *descendant_destination_specs(task.path, paths[:dir], new_parent_id: paths[:id])
+          ]
+        end
+
+        # Spec paths descendants receive after their ancestor's ID changes.
+        # Folder names stay, spec basenames follow the new IDs, and an entry
+        # without a spec file is not renamed by rewrite_descendants either.
+        def descendant_destination_specs(source_dir, destination_dir, new_parent_id:)
+          specs = []
+          Dir.entries(source_dir).sort.each do |entry|
+            next if entry.start_with?(".")
+
+            match = entry.match(/\A([a-z0-9])-(.+)\z/)
+            next unless match
+
+            child_source = File.join(source_dir, entry)
+            next unless File.directory?(child_source)
+
+            char = match[1]
+            slug = match[2]
+            child_destination = File.join(destination_dir, entry)
+            unless Dir.glob(File.join(child_source, "*.s.md")).empty?
+              specs << File.join(child_destination, "#{new_parent_id}.#{char}-#{slug}.s.md")
+            end
+            specs.concat(descendant_destination_specs(
+              child_source, child_destination, new_parent_id: "#{new_parent_id}.#{char}"
+            ))
+          end
+          specs
+        end
+
         # Extract the base task ID (without subtask char) from a potentially dotted ID
         # "8pp.t.q7w.a" => "8pp.t.q7w"
         def base_task_id(id)

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

@@ -39,7 +39,8 @@ module Ace
           @scanner.scan.reject { |sr| subtask_folder?(sr.folder_name) }
         end
 
-        # Scan and filter by special folder or virtual filter
+        # Scan and filter by special folder or virtual filter.
+        # `next` is the ordinary root view; `all` includes every special folder.
         # @param folder [String, nil] Folder name, virtual filter ("next", "all"), or nil for all
         # @return [Array<ScanResult>] Filtered scan results
         def scan_in_folder(folder)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../molecules/task_scanner"
+require_relative "../molecules/git_ignored_path"
 require_relative "../molecules/task_frontmatter_validator"
 require_relative "../molecules/task_structure_validator"
 require_relative "../molecules/task_doctor_fixer"
@@ -153,6 +154,12 @@ module Ace
             frontmatter, _body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
             next unless frontmatter.is_a?(Hash)
 
+            # A Git-ignored task path (folder or spec file) is not part of the
+            # committed task tree: repository archive policy neither applies
+            # nor authorizes a move.
+            next if Molecules::GitIgnoredPath.ignored?(scan_result.dir_path) ||
+              Molecules::GitIgnoredPath.ignored?(scan_result.file_path)
+
             status = frontmatter["status"]
             special_folder = scan_result.special_folder
 

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

@@ -4,6 +4,7 @@ require "digest"
 require "tmpdir"
 
 require_relative "../molecules/task_config_loader"
+require_relative "../molecules/git_ignored_path"
 require_relative "../molecules/task_scanner"
 require_relative "../molecules/task_resolver"
 require_relative "../molecules/task_loader"
@@ -13,6 +14,7 @@ require_relative "../molecules/task_family_completion"
 require_relative "../molecules/task_reparenter"
 require_relative "../molecules/issue_link"
 require_relative "../atoms/task_validation_rules"
+require_relative "../atoms/task_frontmatter_defaults"
 module Ace
   module Task
     module Organisms
@@ -22,6 +24,10 @@ module Ace
         CREATE_RETRY_LIMIT = 3
         class CreateRetriesExhaustedError < StandardError; end
 
+        # Minimal item shape FolderMover#destination_path reads for a preview;
+        # the guard only needs the destination path, not a loaded task.
+        PlacementItem = Struct.new(:path)
+
         attr_reader :last_list_total, :last_folder_counts, :last_list_cycle_ids
 
         # @param root_dir [String, nil] Override root directory for tasks
@@ -43,6 +49,9 @@ module Ace
         # @param tags [Array<String>] Tags
         # @param dependencies [Array<String>] Dependency task IDs
         # @param use_llm_slug [Boolean] Whether to attempt LLM slug generation
+        # @param time [Time, nil] Creation time for the generated ID and
+        #   created_at; a caller that pre-flighted generated paths passes the
+        #   same value so the checked paths are the ones create writes
         # @return [Models::Task] Created task
         def create(
           title,
@@ -52,11 +61,13 @@ module Ace
           dependencies: [],
           use_llm_slug: false,
           estimate: nil,
-          remote_issue: nil
+          remote_issue: nil,
+          time: nil
         )
           ensure_root_dir
           creator = Molecules::TaskCreator.new(root_dir: @root_dir, config: @config)
           attempts = 0
+          creation_time = time || Time.now.utc
 
           # Authoritative validation precedes the task write: an offline or
           # conflicting link must not create a task artifact at all. Offline
@@ -81,7 +92,7 @@ module Ace
                   tags: tags,
                   dependencies: dependencies,
                   use_llm_slug: use_llm_slug,
-                  time: Time.now.utc + ((attempts - 1) * 2),
+                  time: creation_time + ((attempts - 1) * 2),
                   estimate: estimate,
                   remote_issue: remote_issue
                 )
@@ -137,9 +148,66 @@ module Ace
             special_folder: scan_result.special_folder)
         end
 
+        # Paths a --git-commit guard must validate for an update: every spec of
+        # the moving family at its current location and at the destination the
+        # relocation would create. Resolved before mutation, so a rejected
+        # commit leaves state unchanged.
+        #
+        # @param ref [String] Task reference
+        # @param move_to [String, nil] Requested folder move
+        # @param move_as_child_of [String, nil] Requested reparent target
+        # @return [Array<String>] Directory and spec paths to test with Git
+        def commit_guard_paths(ref, move_to: nil, move_as_child_of: nil)
+          task = show(ref)
+          return [] unless task
+
+          source_roots = [task.path]
+          destination_roots = []
+          extra_paths = []
+
+          if move_to
+            source_root, destination_root = relocation_roots(task, move_to)
+            source_roots = [source_root] if source_root
+            destination_roots << destination_root if destination_root
+          elsif move_as_child_of
+            # A reparent renames the family's spec files, so the guard must
+            # check the generated destination names, not the pre-move ones.
+            extra_paths.concat(reparenter_destination_paths(task, move_as_child_of))
+          end
+
+          paths = [task.path, task.file_path]
+          source_roots.each { |root| paths.concat(task_specs(root)) }
+          destination_roots.each do |destination_root|
+            paths << destination_root
+            source_roots.each do |source_root|
+              source_root_path = File.expand_path(source_root)
+              task_specs(source_root).each do |spec|
+                relative = spec.delete_prefix(source_root_path + File::SEPARATOR)
+                paths << File.join(destination_root, relative)
+              end
+            end
+          end
+          (paths + extra_paths).compact.uniq
+        end
+
+        # Destination directory a relocation would create, without mutating.
+        # Submitting an archive move of a subtask archives the parent family.
+        #
+        # @param task_or_ref [Models::Task, String]
+        # @param move_to [String]
+        # @return [String, nil]
+        def relocation_destination_path(task_or_ref, move_to)
+          task = task_or_ref.is_a?(Models::Task) ? task_or_ref : show(task_or_ref)
+          return nil unless task
+
+          _source_root, destination_root = relocation_roots(task, move_to)
+          destination_root
+        end
+
         # List tasks with optional filtering and sorting.
         # @param status [String, nil] Filter by status
-        # @param in_folder [String, nil] Filter by special folder (default: "next" = root items only)
+        # @param in_folder [String, nil] Filter by special folder
+        #   (default: "next" = ordinary root view)
         # @param tags [Array<String>] Filter by tags (any match)
         # @param filters [Array<String>, nil] Generic filter strings
         # @param sort [String] Sort order: "smart" (default, dependency-aware), "id", "priority", "created"
@@ -572,6 +640,38 @@ module Ace
           show_after_sync(created_subtask) || created_subtask
         end
 
+        # Paths a create call would write, resolved without mutating anything.
+        # The preview uses the real generated ID and title-derived slugs (or the
+        # next subtask character) plus the placement folder, so a pre-write
+        # --git-commit guard judges Git ignore rules against the actual
+        # operation instead of sample names. Pass the same `time` to create so
+        # both resolve the same ID.
+        #
+        # @param title [String] Task or subtask title
+        # @param in_folder [String, nil] Requested placement folder
+        # @param child_of [String, nil] Parent task reference for a subtask
+        # @param time [Time] Creation time used for the generated ID
+        # @return [Array<String>] Task directory and spec file path
+        def planned_creation_paths(title, in_folder: nil, child_of: nil, time: Time.now.utc)
+          if child_of
+            parent = show(child_of)
+            return [] unless parent
+
+            creator = Molecules::SubtaskCreator.new(config: @config)
+            return creator.destination_paths(parent, title)
+          end
+
+          creator = Molecules::TaskCreator.new(root_dir: @root_dir, config: @config)
+          dir, spec = creator.destination_paths(title, time: time)
+          detector = Ace::Support::Items::Atoms::SpecialFolderDetector
+          return [dir, spec] unless in_folder && !detector.move_to_root?(in_folder)
+
+          mover = Ace::Support::Items::Molecules::FolderMover.new(@root_dir)
+          placed_dir = mover.destination_path(PlacementItem.new(dir), to: in_folder,
+            date: planned_archive_date(time))
+          [placed_dir, File.join(placed_dir, File.basename(spec))]
+        end
+
         def issue_sync(ref: nil, all: false, pending: false)
           raise ArgumentError, "Provide --all or a task reference" if !all && !pending && (ref.nil? || ref.strip.empty?)
           raise ArgumentError, "--all and --pending are mutually exclusive" if all && pending
@@ -855,6 +955,8 @@ 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.
+        # A Git-ignored family is not part of the committed task tree, so its
+        # completion never triggers a repository relocation.
         def check_auto_archive(task, new_status)
           return unless Atoms::TaskValidationRules.terminal_status?(new_status.to_s.downcase)
           return unless task.subtask?
@@ -864,14 +966,62 @@ module Ace
 
           parent = show(current.parent_id)
           return unless parent && family_completion.complete?(parent.path, id: parent.id)
+          # A Git-ignored family is not part of the committed task tree, and a
+          # relocation into an ignored destination would expose its content to
+          # normal staging: neither case triggers an automatic archive.
+          return if Molecules::GitIgnoredPath.ignored_family?(parent.path)
+
+          destination = relocation_destination_path(parent, "archive")
+          return if destination && Molecules::GitIgnoredPath.ignored_after_relocation?(parent.path, destination)
 
           archive_parent_via_update(parent)
         end
 
+        # Destination directory and generated spec paths a reparent would
+        # create, without mutating. Empty when the reparent itself is invalid.
+        def reparenter_destination_paths(task, target)
+          reparenter = Molecules::TaskReparenter.new(root_dir: @root_dir, config: @config)
+          reparenter.destination_paths(task, target: target, resolve_ref: ->(ref) { show(ref) })
+        rescue ArgumentError
+          []
+        end
+
+        # Source family root and destination root for a folder move.
+        # A subtask archive move relocates the whole parent family.
+        def relocation_roots(task, move_to)
+          detector = Ace::Support::Items::Atoms::SpecialFolderDetector
+          return [task.path, File.join(@root_dir, File.basename(task.path))] if detector.move_to_root?(move_to)
+
+          normalized = detector.normalize(move_to)
+          mover = Ace::Support::Items::Molecules::FolderMover.new(@root_dir)
+          if task.subtask? && normalized == "_archive"
+            parent = show(task.parent_id)
+            return [nil, nil] unless parent
+
+            [parent.path, mover.destination_path(parent, to: "archive", date: parse_archive_date(parent))]
+          else
+            [task.path, mover.destination_path(task, to: normalized, date: parse_archive_date(task))]
+          end
+        end
+
+        def task_specs(root)
+          Dir.glob(File.join(root.to_s, "**", "*.s.md"))
+        end
+
         def family_completion
           Molecules::TaskFamilyCompletion.new(@root_dir)
         end
 
+        # Archive placement derives its partition from the task's stored
+        # created_at, which frontmatter records as zone-less UTC wall time and
+        # parse_archive_date parses in the local zone. Mirror that parse so the
+        # preview names the bucket the placement actually writes.
+        def planned_archive_date(time)
+          Time.parse(Atoms::TaskFrontmatterDefaults.format_time(time))
+        rescue
+          time
+        end
+
         def parse_archive_date(task)
           raw = task.metadata["completed_at"] || task.metadata["created_at"]
           return nil unless raw

data/lib/ace/task/version.rb

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

data/lib/ace/task.rb

@@ -18,6 +18,7 @@ require_relative "task/models/task"
 
 # Molecules
 require_relative "task/molecules/task_config_loader"
+require_relative "task/molecules/git_ignored_path"
 require_relative "task/molecules/task_scanner"
 require_relative "task/molecules/task_resolver"
 require_relative "task/molecules/task_loader"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-task
 version: !ruby/object:Gem::Version
-  version: 0.39.3
+  version: 0.41.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-12 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-core
@@ -195,6 +195,7 @@ files:
 - lib/ace/task/cli/commands/update.rb
 - lib/ace/task/models/task.rb
 - lib/ace/task/molecules/dependency_aware_smart_sorter.rb
+- lib/ace/task/molecules/git_ignored_path.rb
 - lib/ace/task/molecules/issue_link.rb
 - lib/ace/task/molecules/issue_sync_adapter.rb
 - lib/ace/task/molecules/path_utils.rb