ace-task 0.39.3 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf3a2b4bdbf7c413363c5f9b81a0f0b4161e6b50e58cce724adcb67ba03fc1c2
-  data.tar.gz: b08a3d0f30ad8dfb455c6232bde690e632a9028a603ac37fa289a4768c2f0312
+  metadata.gz: a67866ad3602fb4570aca58dc63b0f60ea7575ce6baae62a6c1d6414970651c9
+  data.tar.gz: 7e547e93da96598b520866b605cf0368ec5beb2ff90c313c7118e649f029cae8
 SHA512:
-  metadata.gz: ea63fb03267e6eb84875128ff0ec56becc9fbc0a650a40344cf9a1b11090a61791eed9c97a203ce8a231b132534d442d0238d93cac07162ecd96f522cdd930be
-  data.tar.gz: 2be684d6224ec2a57dc9cc4f84eafdee43c14e1b044116e470f12b51dd1cab952267ff9b4a05d96f6e2df5eb4ef1b10d0bd52e32a31e53275a8cdca7e43b0626
+  metadata.gz: 9a86efa97d4a87a6e3de9561bb65a2cd9c0456ede8ece70e34c4a665776c4602c26977aa3557699c774118133571734c3266eba9b4523912225cf71f0f4aa4fd
+  data.tar.gz: e0301e6f51931b8b7320b01e362bab0d7988f67607660b0374e87b70b9bec524ed41e1640d7692bb914dc201553becb1a13057b036d949d6fef930ff0378929e

data/CHANGELOG.md

@@ -7,6 +7,61 @@ 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
+
+- Support exact --root selection in create, show and update so project objective queues can use the configured directory without changing the global _folder convention.
+
 ## [0.39.3] - 2026-10-12
 
 ### Fixed

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,11 +45,13 @@ 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"
 
+          option :root, type: :string, aliases: %w[-r], desc: "Exact task root directory (overrides project config)"
+
           option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
           option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
           option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
@@ -77,9 +81,24 @@ module Ace
               end
             end
 
-            manager = Ace::Task::Organisms::TaskManager.new
+            manager = if options[:root]
+              Ace::Task::Organisms::TaskManager.new(root_dir: File.expand_path(options[:root]))
+            else
+              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:"
@@ -112,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
@@ -129,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?
@@ -147,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/show.rb

@@ -31,12 +31,18 @@ module Ace
           option :content, type: :boolean, desc: "Print raw markdown content"
           option :tree, type: :boolean, desc: "Show parent + subtask tree view"
 
+          option :root, type: :string, aliases: %w[-r], desc: "Exact task root directory (overrides project config)"
+
           option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
           option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
           option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
 
           def call(ref:, **options)
-            manager = Ace::Task::Organisms::TaskManager.new
+            manager = if options[:root]
+              Ace::Task::Organisms::TaskManager.new(root_dir: File.expand_path(options[:root]))
+            else
+              Ace::Task::Organisms::TaskManager.new
+            end
             task = manager.show(ref)
 
             unless task

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,12 +42,15 @@ 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>"
 
           option :git_commit, type: :boolean, aliases: %w[--gc], desc: "Auto-commit changes"
 
+          option :root, type: :string, aliases: %w[-r], desc: "Exact task root directory (overrides project config)"
+
           option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
           option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
           option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
@@ -75,7 +80,13 @@ module Ace
             add_hash = parse_kv_pairs(add_args)
             remove_hash = parse_kv_pairs(remove_args)
 
-            manager = Ace::Task::Organisms::TaskManager.new
+            manager = if options[:root]
+              Ace::Task::Organisms::TaskManager.new(root_dir: File.expand_path(options[:root]))
+            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
@@ -120,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