ace-task 0.40.0 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e07d26b4b14644e4227398532fa33c32066628db686f51274628d8164608225
-  data.tar.gz: ae7def12a1bacbcd29744736de409970b612e943a48e291c8bdf6fdbb6480424
+  metadata.gz: a67866ad3602fb4570aca58dc63b0f60ea7575ce6baae62a6c1d6414970651c9
+  data.tar.gz: 7e547e93da96598b520866b605cf0368ec5beb2ff90c313c7118e649f029cae8
 SHA512:
-  metadata.gz: 49a85005d9283e2920f421957bc4d5e2f6b5a181c8259a3d8e63c5206a2fdcde6c4ea4342be3cbb84acce05fe12895f3a2e57301202c362b8a1a305ddd1e141b
-  data.tar.gz: dddf45e0bd3c18cef1cf1568987f91ab56b3f15567dee849ced55483e818fd147c4e0dfaadc95a872add0ab6510c4ded2538bd7a07051d04ec1306c44e6c48bb
+  metadata.gz: 9a86efa97d4a87a6e3de9561bb65a2cd9c0456ede8ece70e34c4a665776c4602c26977aa3557699c774118133571734c3266eba9b4523912225cf71f0f4aa4fd
+  data.tar.gz: e0301e6f51931b8b7320b01e362bab0d7988f67607660b0374e87b70b9bec524ed41e1640d7692bb914dc201553becb1a13057b036d949d6fef930ff0378929e

data/CHANGELOG.md

@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.41.0] - 2026-10-17
+
+### Added
+
+- Detect Git-ignored task paths through Git itself (`git check-ignore` on the
+  actual path), from any working directory and with a custom task root, so
+  behavior for uncommitted task folders needs no folder-name knowledge.
+
+### Changed
+
+- Remove all folder-name exceptions from `ace-task`: no private/shared scope
+  constants, no special `_overseer` create destination, and no special default
+  listing. The default `ace-task list` is the ordinary root view; any existing
+  special folder stays reachable with `--in FOLDER` or `--in all`.
+- Refuse `--git-commit` when the task path is Git-ignored — on create, subtask
+  creation, update, and move — instead of rejecting a named folder. The check
+  covers the task directory, individual children, the spec file, and the
+  destination paths a relocation would create (including archive partitions);
+  a rejected create rolls back the task artifacts and a rejected move/update
+  leaves the task unchanged.
+- Do not auto-archive a completed Git-ignored task (or ignored family), and do
+  not report or perform an archive move for it in `ace-task doctor`; a move is
+  also skipped when the resulting archive destination is Git-ignored. The
+  folder owner decides when to delete obsolete history. No private archive
+  folder or retention mechanism is created.
+- The canonical lab-flow contract records that the delegation tools
+  (`ace-git-worktree create --task`, `ace-assign create --task`) are role- and
+  folder-name agnostic: they do not reject management tasks and do not inspect
+  `.gitignore`; preparing a correct delegation stays with the caller. The
+  tools' own changelogs carry their release scope.
+- Resolve the project task root from the project root (not the current
+  directory) for `list --in FOLDER` validation and for the plan cache/context
+  resolution, so `ace-task list --in _maybe` and `plan` work from a
+  subdirectory. `--root` remains an explicit path override resolved from the
+  current directory.
+
+### Fixed
+
+- Judge the `--git-commit` preflight against the paths create actually writes:
+  the generated ID and title-derived slugs, or the allocated subtask character,
+  including the real placement folder. The previous sample-name probes could
+  reject a valid root task (for example with a `0-*/` ignore rule) even though
+  its generated path is tracked.
+- Check the generated destination names of a reparent's whole family. Demoting
+  or promoting a task renames its own spec and every descendant spec, so a
+  guard using the pre-move names could pass while the new child spec is
+  Git-ignored — the commit then lost the child from the repository. The guard
+  now previews the actual renamed spec paths before mutating.
+
 ## [0.40.0] - 2026-10-16
 
 ### Added

data/README.md

@@ -1,7 +1,7 @@
 <div align="center">
   <h1> ACE - Task </h1>
 
-  Draft, organize, and tackle tasks — for you and your agents.
+  Draft, organize, and tackle tasks -- for you and your agents.
 
   <img src="../docs/brand/AgenticCodingEnvironment.Logo.XS.jpg" alt="ACE Logo" width="480">
   <br><br>
@@ -14,6 +14,17 @@
 
 > Works with: Claude Code, Codex CLI, OpenCode, Gemini CLI, pi-agent, and more.
 
+> **State owner:** `.ace-tasks/` -- project task markdown files and frontmatter
+> owned by `ace-task`. Each project task gets one worktree under `.ace-wt/`.
+> `ace-task` is folder-name agnostic: behavior that depends on Git tracking
+> comes from Git's ignore rules for the actual path, never from a folder name.
+> `--git-commit` is refused for Git-ignored tasks, and completed ignored tasks
+> are neither auto-archived nor moved by `doctor --auto-fix`. A lab may prepare
+> `.ace-tasks/_overseer/` (gitignored) and manage it with
+> `ace-task --in _overseer`; the delegation tools are role- and folder-name
+> agnostic and do not reject management tasks. The canonical flow is
+> [docs/lab-flow.md](../docs/lab-flow.md).
+
 [Getting Started](docs/getting-started.md) | [Usage Guide](docs/usage.md) | [Handbook - Skills, Agents, Templates](docs/handbook.md)
 
 ![ace-task demo](docs/demo/ace-task-getting-started.gif)
@@ -41,13 +52,15 @@ Tasks are markdown specs living in git - attached to branches and worktrees, not
 
 **Plan the work** - generate a step-by-step implementation plan with `/as-task-plan` or `ace-task plan`. Define subtasks, configure which agent handles execution, and break scope into assignable units. The plan lives in the task spec so any agent can pick it up.
 
-**Run as dark factory** - hand a task to [ace-overseer](../ace-overseer) and it provisions a worktree, opens a tmux window, creates an assignment, and drives execution through the full lifecycle - onboard, implement, verify, create PR, review, ship. One command kicks it off:
+**Start task work in one command** - hand a task to [ace-overseer](../ace-overseer) and it provisions a worktree under `.ace-wt/`, prepares an assignment in `.ace-local/assign/`, and opens a terminal window (tmux or Herdr). One command kicks it off:
 
 ```bash
 ace-overseer work-on --task t.tt6 --preset work-on-task
 ```
 
-Under the hood this chains [ace-git-worktree](../ace-git-worktree) (isolated branch) -> [ace-tmux](../ace-tmux) (dedicated window and panes layout) -> [ace-assign](../ace-assign) (step-by-step execution). Switch to the tmux window and run `/as-assign-drive` to walk through each step.
+Under the hood this chains [ace-git-worktree](../ace-git-worktree) (isolated branch and worktree) → [ace-tmux](../ace-tmux) or [ace-herdr](../ace-herdr) (terminal) → [ace-assign](../ace-assign) (step-by-step plan). Switch to the window and run `/as-assign-drive` to walk through each step.
+
+> **Planned (L6):** the private overseer queue that automatically continues already delegated, unblocked work is not available yet.
 
 **Track progress** - `ace-task list` shows tasks by status - what is next, what is in progress, and what was recently completed. `ace-task status` gives a focused view of the current task with subtask progress.
 

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

@@ -2,6 +2,7 @@
 
 require "ace/support/cli"
 require "fileutils"
+require_relative "../../molecules/git_ignored_path"
 
 module Ace
   module Task
@@ -27,6 +28,7 @@ module Ace
             '"Setup DB" --child-of q7w                    # Create as subtask',
             '"Track issue" --issue 276 --server forgejo-lab # Link one exact issue',
             '"Quick task" --in maybe                      # Create in _maybe/ folder',
+            '"Filed task" --in _review                    # Create in an existing custom folder',
             '"Draft spec" --status draft --estimate TBD   # Create as draft with estimate',
             '"Preview only" --dry-run                     # Show what would be created'
           ]
@@ -43,7 +45,7 @@ module Ace
           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: "Top-level target (next, maybe, anytime, archive, or existing custom folder)"
+            desc: "Top-level target (next, maybe, anytime, archive, or an 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"
@@ -85,7 +87,18 @@ module Ace
               Ace::Task::Organisms::TaskManager.new
             end
             validate_destination!(manager, in_folder) if in_folder && !child_of
-            placement_directories_before = directories_under(manager.root_dir) if in_folder && !child_of
+            # The preflight and the write resolve the same creation time, so
+            # the checked paths are exactly the generated paths create writes.
+            creation_time = Time.now.utc
+            if options[:git_commit]
+              reject_ignored_creation_target!(manager, title: title, in_folder: in_folder,
+                child_of: child_of, time: creation_time)
+            end
+            # Snapshot before any write so a rejected --git-commit can remove
+            # exactly the artifacts this command created (including a placed
+            # task, a new subtask, or an empty destination folder).
+            placement_directories_before = directories_under(manager.root_dir) if
+              (in_folder && !child_of) || options[:git_commit]
 
             if dry_run
               puts "Would create task:"
@@ -118,7 +131,8 @@ module Ace
                   priority: priority,
                   tags: tags,
                   estimate: estimate,
-                  remote_issue: remote_issue
+                  remote_issue: remote_issue,
+                  time: creation_time
                 )
               end
             rescue Ace::Task::Organisms::TaskManager::CreateRetriesExhaustedError => e
@@ -135,6 +149,10 @@ module Ace
               task = place_created_task(manager, task, in_folder, placement_directories_before)
             end
 
+            if options[:git_commit]
+              reject_ignored_created_task!(manager, task, placement_directories_before)
+            end
+
             puts "Created task #{task.id}"
             puts "  Path: #{task.file_path}"
             if manager.last_update_note && !manager.last_update_note.strip.empty?
@@ -153,6 +171,63 @@ module Ace
 
           private
 
+          # --git-commit preflight: resolve the known destination (the parent
+          # family or the placement folder) and the exact task paths this
+          # create call would write — generated ID and title-derived slugs, or
+          # the next subtask character — so ignore rules are judged against the
+          # real operation, never against sample names. The post-creation check
+          # stays authoritative for ID-collision retries and concurrent changes.
+          def reject_ignored_creation_target!(manager, title:, in_folder:, child_of:, time:)
+            detector = Ace::Support::Items::Atoms::SpecialFolderDetector
+            target = if child_of
+              manager.show(child_of)&.path
+            elsif in_folder && !detector.move_to_root?(in_folder)
+              File.join(manager.root_dir, detector.normalize(in_folder))
+            else
+              manager.root_dir
+            end
+            return unless target
+
+            if Ace::Task::Molecules::GitIgnoredPath.ignored?(target)
+              raise Ace::Support::Cli::Error,
+                "Cannot --git-commit into a Git-ignored destination: #{target}. " \
+                  "Choose a tracked folder or omit --git-commit."
+            end
+
+            ignored = manager.planned_creation_paths(title, in_folder: in_folder, child_of: child_of, time: time)
+              .find { |path| Ace::Task::Molecules::GitIgnoredPath.ignored?(path) }
+            return unless ignored
+
+            raise Ace::Support::Cli::Error,
+              "Cannot --git-commit into a destination with Git-ignored child paths: #{ignored}. " \
+                "Choose a tracked folder or adjust the ignore rules."
+          end
+
+          # --git-commit must not stage a task whose directory or spec path Git
+          # ignores. The check runs on the created paths (covering generated
+          # IDs, subtask folders, and the placed destination) and rolls the
+          # creation back, so a rejected commit leaves no task behind.
+          def reject_ignored_created_task!(manager, task, directories_before)
+            return unless Ace::Task::Molecules::GitIgnoredPath.ignored_task?(task)
+
+            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,
+                "Cannot --git-commit a Git-ignored task path: #{task.path}. " \
+                  "Cleanup also failed: #{cleanup_error.message}"
+            end
+
+            raise_ignored_commit!(task.path)
+          end
+
+          def raise_ignored_commit!(path)
+            raise Ace::Support::Cli::Error,
+              "Cannot --git-commit a Git-ignored task path: #{path}. " \
+                "Move the task to a tracked folder or omit --git-commit."
+          end
+
           def validate_destination!(manager, target_folder)
             detector = Ace::Support::Items::Atoms::SpecialFolderDetector
             return if detector.move_to_root?(target_folder)

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

@@ -20,9 +20,10 @@ module Ace
           remove_const(:C)
 
           example [
-            "                           # Active tasks (root only, default)",
+            "                           # Root tasks (default next view)",
             "--in all                   # All tasks including archived/maybe",
             "--in maybe                 # Tasks in _maybe/",
+            "--in archive               # Archived tasks",
             "--status pending           # Filter by status",
             "--tags ux,design           # Tasks matching any tag",
             "--in next --status pending # Combined filters",
@@ -33,7 +34,8 @@ module Ace
 
           option :status, type: :string, aliases: %w[-s], desc: "Filter by status (pending, in-progress, done, blocked)"
           option :tags, type: :string, aliases: %w[-T], desc: "Filter by tags (comma-separated, any match)"
-          option :in, type: :string, aliases: %w[-i], desc: "Filter by folder (next=root only [default], all=everything, maybe, archive)"
+          option :in, type: :string, aliases: %w[-i],
+            desc: "Folder (next [default: root tasks], all, maybe, archive, or an existing special folder)"
           option :root, type: :string, aliases: %w[-r], desc: "Override root path (subpath within tasks root)"
           option :filter, type: :array, aliases: %w[-f], desc: "Filter by key:value (repeatable, supports key:a|b and key:!value)"
           option :sort, type: :string, aliases: %w[-S], desc: "Sort order: smart (default, dependency-aware), id, priority, created"

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

@@ -89,7 +89,8 @@ module Ace
 
           def capture_context_files(task)
             files = Array(task.metadata.dig("bundle", "files"))
-            expanded = files.map { |path| File.expand_path(path, Dir.pwd) }.uniq
+            project_root = Molecules::TaskConfigLoader.project_root
+            expanded = files.map { |path| File.expand_path(path, project_root) }.uniq
             resolved = expanded.select { |path| File.file?(path) }
 
             missing = expanded - resolved

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

@@ -2,6 +2,7 @@
 
 require "ace/support/cli"
 require "ace/support/items"
+require_relative "../../molecules/git_ignored_path"
 
 module Ace
   module Task
@@ -26,6 +27,7 @@ module Ace
             "q7w --set worktree.branch=my-branch",
             "q7w --set status=done --move-to archive",
             "q7w --move-to next",
+            "q7w --move-to _maybe             # Move to an existing special folder",
             "q7w.a --move-as-child-of none    # Promote subtask to standalone",
             "q7w --move-as-child-of self      # Convert to orchestrator",
             "q7w --move-as-child-of abc       # Demote to subtask of abc",
@@ -40,7 +42,8 @@ module Ace
           option :set, type: :array, desc: "Set field: key=value (comma-separated for multiple)"
           option :add, type: :array, desc: "Add to array field: key=value (comma-separated for multiple)"
           option :remove, type: :array, desc: "Remove from array field: key=value (comma-separated for multiple)"
-          option :move_to, type: :string, aliases: %w[-m], desc: "Move to folder (archive, maybe, anytime, next)"
+          option :move_to, type: :string, aliases: %w[-m],
+            desc: "Move to folder (archive, maybe, anytime, next, or an existing custom folder)"
           option :move_as_child_of, type: :string, desc: "Reparent: <parent_ref>, 'none' (promote), 'self' (orchestrator)"
           option :position, type: :string, aliases: %w[-p], desc: "Set position: first, last, after:<ref>, before:<ref>"
 
@@ -82,6 +85,8 @@ module Ace
             else
               Ace::Task::Organisms::TaskManager.new
             end
+            reject_ignored_git_commit!(manager, ref: ref, move_to: move_to,
+              move_as_child_of: move_as_child) if options[:git_commit]
 
             # Resolve --position into a set or remove operation
             if position_arg
@@ -126,6 +131,20 @@ module Ace
 
           private
 
+          # --git-commit must not stage a task whose path Git ignores. Both the
+          # current paths and the paths the relocation would create are
+          # resolved before mutation: an ignore rule may target the destination
+          # folder, its children, individual spec files, or archive partitions.
+          def reject_ignored_git_commit!(manager, ref:, move_to:, move_as_child_of:)
+            paths = manager.commit_guard_paths(ref, move_to: move_to, move_as_child_of: move_as_child_of)
+            ignored = paths.find { |path| Ace::Task::Molecules::GitIgnoredPath.ignored?(path) }
+            return unless ignored
+
+            raise Ace::Support::Cli::Error,
+              "Cannot --git-commit a Git-ignored task path: #{ignored}. " \
+                "Move the task to a tracked folder or omit --git-commit."
+          end
+
           # Resolve a --position argument into a B36TS value.
           # Supports: first, last, after:<ref>, before:<ref>
           def resolve_position(arg, manager)

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "ace/git"
+
+module Ace
+  module Task
+    module Molecules
+      # Detects whether a task path is ignored by Git.
+      #
+      # ace-task is a universal task tool: it does not know which folders a lab
+      # or a role reserves. When behavior has to differ for a path that is not
+      # committed, the decision comes from Git's own ignore rules for the actual
+      # path — never from a folder-name list. The same query covers a task
+      # directory or its spec file, a path that does not exist yet (a destination
+      # computed before a move), any working directory, and a custom task root:
+      # Git resolves the repository from the path itself.
+      class GitIgnoredPath
+        # @param path [String] Path to check (file or directory, may not exist)
+        # @return [Boolean] true when Git ignores the path (a commit would skip it)
+        def self.ignored?(path)
+          absolute = File.expand_path(path.to_s)
+          working_dir = File.directory?(absolute) ? absolute : File.dirname(absolute)
+          working_dir = File.dirname(working_dir) until Dir.exist?(working_dir) ||
+            File.dirname(working_dir) == working_dir
+          return false unless Dir.exist?(working_dir)
+
+          result = Ace::Git::Atoms::CommandExecutor.execute(
+            "git", "-C", working_dir, "check-ignore", "-q", "--", absolute
+          )
+          result[:success] == true
+        rescue StandardError
+          false
+        end
+
+        # A task is uncommittable when its directory or its spec file is ignored:
+        # ignore rules may target the folder, individual children, or spec names.
+        #
+        # @param task [Models::Task]
+        # @return [Boolean]
+        def self.ignored_task?(task)
+          ignored?(task.path) || ignored?(task.file_path)
+        end
+
+        # A task family is uncommittable when its directory or any spec file
+        # inside it is ignored (auto-archive and doctor move whole families).
+        #
+        # @param dir_path [String]
+        # @return [Boolean]
+        def self.ignored_family?(dir_path)
+          ignored?(dir_path) ||
+            Dir.glob(File.join(dir_path.to_s, "**", "*.s.md")).any? { |spec| ignored?(spec) }
+        end
+
+        # Relocating into an ignored destination would expose committed-looking
+        # content to normal staging, so both the destination directory and the
+        # destination paths of the moving specs must be checked before a move.
+        #
+        # @param source_dir [String] Current task/family directory
+        # @param destination_dir [String] Directory the move would create
+        # @return [Boolean]
+        def self.ignored_after_relocation?(source_dir, destination_dir)
+          return true if ignored?(destination_dir)
+
+          source_root = File.expand_path(source_dir.to_s)
+          Dir.glob(File.join(source_root, "**", "*.s.md")).any? do |spec|
+            relative = spec.delete_prefix(source_root + File::SEPARATOR)
+            ignored?(File.join(destination_dir.to_s, relative))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,20 +44,9 @@ module Ace
         )
           raise ArgumentError, "Title is required" if title.nil? || title.strip.empty?
 
-          # Find next available subtask character
-          existing_chars = scan_existing_subtask_chars(parent_task.path, parent_task.id)
-          next_char = allocate_next_char(existing_chars)
-
-          # Build subtask ID: parent_id + ".{char}"
-          subtask_id = "#{parent_task.id}.#{next_char}"
-
-          # Generate slugs (folder: 5 words, file: 7 words)
-          folder_slug = generate_folder_slug(title)
-          file_slug = generate_file_slug(title)
-
-          # Build folder and file names
-          folder_name = "#{next_char}-#{folder_slug}"
-          subtask_dir = File.join(parent_task.path, folder_name)
+          paths = destination_paths_for(parent_task, title)
+          subtask_id = paths[:id]
+          subtask_dir = paths[:dir]
           FileUtils.mkdir_p(subtask_dir)
 
           # Build frontmatter
@@ -74,8 +63,7 @@ module Ace
           )
 
           # Write spec file
-          spec_filename = "#{subtask_id}-#{file_slug}.s.md"
-          spec_file = File.join(subtask_dir, spec_filename)
+          spec_file = paths[:spec]
           content = build_spec_content(frontmatter: frontmatter, title: title)
           File.write(spec_file, content)
 
@@ -84,8 +72,33 @@ module Ace
           loader.load(subtask_dir, id: subtask_id, load_subtasks: false)
         end
 
+        # Non-mutating preview of the directory and spec file a subtask create
+        # call would write: the next allocated subtask character and the
+        # title-derived slugs, matching create exactly. Pre-write checks use it
+        # to judge Git ignore rules against the real generated names.
+        #
+        # @param parent_task [Models::Task] Parent task
+        # @param title [String] Subtask title
+        # @return [Array<String>] Subtask directory and spec file path
+        def destination_paths(parent_task, title)
+          raise ArgumentError, "Title is required" if title.nil? || title.strip.empty?
+
+          paths = destination_paths_for(parent_task, title)
+          [paths[:dir], paths[:spec]]
+        end
+
         private
 
+        def destination_paths_for(parent_task, title)
+          existing_chars = scan_existing_subtask_chars(parent_task.path, parent_task.id)
+          next_char = allocate_next_char(existing_chars)
+          subtask_id = "#{parent_task.id}.#{next_char}"
+          folder_slug = generate_folder_slug(title)
+          file_slug = generate_file_slug(title)
+          subtask_dir = File.join(parent_task.path, "#{next_char}-#{folder_slug}")
+          {id: subtask_id, dir: subtask_dir, spec: File.join(subtask_dir, "#{subtask_id}-#{file_slug}.s.md")}
+        end
+
         # Scan parent directory for existing subtask folders and extract their chars.
         def scan_existing_subtask_chars(parent_dir, _parent_id)
           chars = []

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

@@ -31,6 +31,12 @@ module Ace
           deep_merge(config, load_project_config)
         end
 
+        # Project root used to resolve relative configuration and file paths.
+        # @return [String] Absolute project root (current directory when no marker is found)
+        def self.project_root
+          Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
+        end
+
         # Get the root directory for tasks
         # @param config [Hash] Configuration hash
         # @return [String] Absolute path to tasks root directory
@@ -41,7 +47,7 @@ module Ace
           if dir.start_with?("/")
             dir
           else
-            File.join(Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current, dir)
+            File.join(project_root, dir)
           end
         end
 

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.40.0"
+    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.40.0
+  version: 0.41.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-16 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