ariadna 1.2.0 → 1.2.2

data/data/statusline/ariadna-statusline.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# Ariadna statusline for Claude Code
+
+input=$(cat)
+
+# Require jq
+if ! command -v jq &>/dev/null; then
+  echo "ariadna: jq required for statusline"
+  exit 0
+fi
+
+MODEL=$(echo "$input" | jq -r '.model.display_name // "unknown"')
+PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
+CWD=$(echo "$input" | jq -r '.cwd // ""')
+
+# Scale to 80% effective limit (Claude Code compresses at ~80%)
+SCALED=$(( PCT * 100 / 80 ))
+[ "$SCALED" -gt 100 ] && SCALED=100
+
+# Color based on scaled percentage
+if [ "$SCALED" -ge 80 ]; then
+  COLOR='\033[31m'    # Red
+elif [ "$SCALED" -ge 60 ]; then
+  COLOR='\033[33m'    # Yellow
+else
+  COLOR='\033[32m'    # Green
+fi
+
+# Progress bar (10 chars)
+FILLED=$(( SCALED / 10 ))
+EMPTY=$(( 10 - FILLED ))
+BAR=$(printf "%${FILLED}s" | tr ' ' '█')$(printf "%${EMPTY}s" | tr ' ' '░')
+
+# Phase info from STATE.md
+PHASE=""
+if [ -n "$CWD" ] && [ -f "$CWD/.ariadna_planning/STATE.md" ]; then
+  PHASE=$(grep -m1 '^Phase:' "$CWD/.ariadna_planning/STATE.md" | sed 's/^Phase:[[:space:]]*//')
+fi
+
+# Build output
+DIM='\033[2m'
+RESET='\033[0m'
+if [ -n "$PHASE" ]; then
+  echo -e "${DIM}${MODEL}${RESET} │ ${PHASE} ${COLOR}${BAR}${RESET} ${PCT}%"
+else
+  echo -e "${DIM}${MODEL}${RESET} ${COLOR}${BAR}${RESET} ${PCT}%"
+fi

data/data/templates.md

@@ -2,7 +2,7 @@
 
 ## Context
 
-The templates in `data/ariadna/templates/codebase/` are used by Ariadna's codebase mapping agents to generate `.planning/codebase/` documents when analyzing a Rails project. Currently, all templates except `architecture.md` are generic/framework-agnostic with JavaScript/TypeScript examples (Next.js, Vitest, npm, etc.). Since Ariadna is targeting Ruby on Rails applications, these templates should use Rails-specific terminology, examples, tools, and patterns.
+The templates in `data/ariadna/templates/codebase/` are used by Ariadna's codebase mapping agents to generate `.ariadna_planning/codebase/` documents when analyzing a Rails project. Currently, all templates except `architecture.md` are generic/framework-agnostic with JavaScript/TypeScript examples (Next.js, Vitest, npm, etc.). Since Ariadna is targeting Ruby on Rails applications, these templates should use Rails-specific terminology, examples, tools, and patterns.
 
 `architecture.md` has already been updated and serves as the reference for style and approach.
 

data/exe/ariadna

@@ -9,6 +9,7 @@ case command
 when "install"
   global = ARGV.include?("--global") || ARGV.include?("-g")
   local = ARGV.include?("--local") || ARGV.include?("-l")
+  force_statusline = ARGV.include?("--force-statusline")
 
   unless global || local
     warn "Usage: ariadna install --global   (install to ~/.claude/)"
@@ -16,7 +17,7 @@ when "install"
     exit 1
   end
 
-  Ariadna::Installer.new(local: local).install
+  Ariadna::Installer.new(local: local, force_statusline: force_statusline).install
 when "uninstall"
   require "ariadna/uninstaller"
   global = ARGV.include?("--global") || ARGV.include?("-g")

data/lib/ariadna/installer.rb

@@ -7,9 +7,10 @@ module Ariadna
     MANIFEST_NAME = "ariadna-manifest.json"
     PATCHES_DIR = "ariadna-local-patches"
 
-    def initialize(target_dir: nil, local: false)
+    def initialize(target_dir: nil, local: false, force_statusline: false)
       @local = local
       @target_dir = target_dir || default_target_dir
+      @force_statusline = force_statusline
     end
 
     def install
@@ -23,6 +24,7 @@ module Ariadna
       copy_guides
       copy_content
       write_version
+      install_statusline
       write_manifest
 
       report_local_patches
@@ -135,6 +137,7 @@ module Ariadna
           keys << rel
         end
       end
+      keys << "ariadna-statusline.sh"
       keys
     end
 
@@ -154,6 +157,28 @@ module Ariadna
       end
     end
 
+    # --- Statusline ---
+
+    def install_statusline
+      src = File.join(source_dir, "statusline", "ariadna-statusline.sh")
+      dest = File.join(@target_dir, "ariadna-statusline.sh")
+
+      FileUtils.cp(src, dest)
+      FileUtils.chmod(0o755, dest)
+
+      settings_path = File.join(@target_dir, "settings.json")
+      settings = File.exist?(settings_path) ? JSON.parse(File.read(settings_path)) : {}
+
+      if settings.key?("statusLine") && !@force_statusline
+        puts "  i  Existing statusLine config found \u2014 skipping (use --force-statusline to replace)"
+        return
+      end
+
+      settings["statusLine"] = { "type" => "command", "command" => dest }
+      File.write(settings_path, JSON.pretty_generate(settings))
+      puts "  \u2713 Installed statusline"
+    end
+
     # --- Copy operations ---
 
     def copy_commands
@@ -226,6 +251,10 @@ module Ariadna
           entries[rel] = Digest::SHA256.file(file).hexdigest
         end
       end
+
+      statusline_path = File.join(@target_dir, "ariadna-statusline.sh")
+      entries["ariadna-statusline.sh"] = Digest::SHA256.file(statusline_path).hexdigest if File.exist?(statusline_path)
+
       entries
     end
 

data/lib/ariadna/tools/config_manager.rb

@@ -21,7 +21,7 @@ module Ariadna
       }.freeze
 
       def self.load_config(cwd = Dir.pwd)
-        config_path = File.join(cwd, ".planning", "config.json")
+        config_path = File.join(cwd, ".ariadna_planning", "config.json")
         return DEFAULTS.dup unless File.exist?(config_path)
 
         raw = File.read(config_path)
@@ -63,7 +63,13 @@ module Ariadna
           "verifier" => nil_or.call(get.call("verifier", { section: "workflow", field: "verifier" }), DEFAULTS["verifier"]),
           "parallelization" => parallelization,
           "execution_mode" => get.call("execution_mode", { section: "execution", field: "mode" }) || DEFAULTS["execution_mode"],
-          "team_execution" => nil_or.call(get.call("team_execution", { section: "execution", field: "team" }), DEFAULTS["team_execution"])
+          "team_execution" => begin
+            val = get.call("team_execution", { section: "execution", field: "team" })
+            case val
+            when "auto", true, false then val
+            else DEFAULTS["team_execution"]
+            end
+          end
         }
       rescue JSON::ParserError
         DEFAULTS.dup
@@ -71,8 +77,8 @@ module Ariadna
 
       def self.ensure_section(argv, raw: false)
         cwd = Dir.pwd
-        config_path = File.join(cwd, ".planning", "config.json")
-        planning_dir = File.join(cwd, ".planning")
+        config_path = File.join(cwd, ".ariadna_planning", "config.json")
+        planning_dir = File.join(cwd, ".ariadna_planning")
 
         FileUtils.mkdir_p(planning_dir) unless File.directory?(planning_dir)
 
@@ -99,7 +105,7 @@ module Ariadna
         }
 
         File.write(config_path, JSON.pretty_generate(defaults))
-        Output.json({ created: true, path: ".planning/config.json" }, raw: raw, raw_value: "created")
+        Output.json({ created: true, path: ".ariadna_planning/config.json" }, raw: raw, raw_value: "created")
       end
 
       def self.set(argv, raw: false)
@@ -108,7 +114,7 @@ module Ariadna
         Output.error("Usage: config-set <key.path> <value>") unless key_path
 
         cwd = Dir.pwd
-        config_path = File.join(cwd, ".planning", "config.json")
+        config_path = File.join(cwd, ".ariadna_planning", "config.json")
 
         config = {}
         if File.exist?(config_path)

data/lib/ariadna/tools/git_integration.rb

@@ -22,14 +22,14 @@ module Ariadna
           return
         end
 
-        if git_ignored?(cwd, ".planning")
+        if git_ignored?(cwd, ".ariadna_planning")
           Output.json({ committed: false, hash: nil, reason: "skipped_gitignored" }, raw: raw, raw_value: "skipped")
           return
         end
 
         # Stage files
         if files.empty?
-          exec_git(cwd, ["add", ".planning/"])
+          exec_git(cwd, ["add", ".ariadna_planning/"])
         else
           files.each { |f| exec_git(cwd, ["add", f]) }
         end

data/lib/ariadna/tools/init.rb

@@ -83,14 +83,19 @@ module Ariadna
           milestone_version: milestone[:version],
           milestone_name: milestone[:name],
           milestone_slug: generate_slug(milestone[:name]),
-          state_exists: path_exists?(cwd, ".planning/STATE.md"),
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md"),
-          config_exists: path_exists?(cwd, ".planning/config.json")
+          team_execution: config["team_execution"],
+          execution_mode: config["execution_mode"],
+          backend_executor_model: resolve_model(cwd, "ariadna-backend-executor"),
+          frontend_executor_model: resolve_model(cwd, "ariadna-frontend-executor"),
+          test_executor_model: resolve_model(cwd, "ariadna-test-executor"),
+          state_exists: path_exists?(cwd, ".ariadna_planning/STATE.md"),
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md"),
+          config_exists: path_exists?(cwd, ".ariadna_planning/config.json")
         }
 
-        result[:state_content] = safe_read_file(File.join(cwd, ".planning", "STATE.md")) if includes.include?("state")
-        result[:config_content] = safe_read_file(File.join(cwd, ".planning", "config.json")) if includes.include?("config")
-        result[:roadmap_content] = safe_read_file(File.join(cwd, ".planning", "ROADMAP.md")) if includes.include?("roadmap")
+        result[:state_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "STATE.md")) if includes.include?("state")
+        result[:config_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "config.json")) if includes.include?("config")
+        result[:roadmap_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "ROADMAP.md")) if includes.include?("roadmap")
 
         Output.json(result, raw: raw)
       end
@@ -119,13 +124,13 @@ module Ariadna
           has_context: phase_info&.dig(:has_context) || false,
           has_plans: (phase_info&.dig(:plans)&.length || 0) > 0,
           plan_count: phase_info&.dig(:plans)&.length || 0,
-          planning_exists: path_exists?(cwd, ".planning"),
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md")
+          planning_exists: path_exists?(cwd, ".ariadna_planning"),
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md")
         }
 
-        result[:state_content] = safe_read_file(File.join(cwd, ".planning", "STATE.md")) if includes.include?("state")
-        result[:roadmap_content] = safe_read_file(File.join(cwd, ".planning", "ROADMAP.md")) if includes.include?("roadmap")
-        result[:requirements_content] = safe_read_file(File.join(cwd, ".planning", "REQUIREMENTS.md")) if includes.include?("requirements")
+        result[:state_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "STATE.md")) if includes.include?("state")
+        result[:roadmap_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "ROADMAP.md")) if includes.include?("roadmap")
+        result[:requirements_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "REQUIREMENTS.md")) if includes.include?("requirements")
 
         if includes.include?("context") && phase_info&.dig(:directory)
           phase_dir_full = File.join(cwd, phase_info[:directory])
@@ -176,13 +181,13 @@ module Ariadna
           synthesizer_model: resolve_model(cwd, "ariadna-research-synthesizer"),
           roadmapper_model: resolve_model(cwd, "ariadna-roadmapper"),
           commit_docs: config["commit_docs"],
-          project_exists: path_exists?(cwd, ".planning/PROJECT.md"),
-          has_codebase_map: path_exists?(cwd, ".planning/codebase"),
-          planning_exists: path_exists?(cwd, ".planning"),
+          project_exists: path_exists?(cwd, ".ariadna_planning/PROJECT.md"),
+          has_codebase_map: path_exists?(cwd, ".ariadna_planning/codebase"),
+          planning_exists: path_exists?(cwd, ".ariadna_planning"),
           has_existing_code: has_code,
           has_package_file: has_package_file,
           is_brownfield: has_code || has_package_file,
-          needs_codebase_map: (has_code || has_package_file) && !path_exists?(cwd, ".planning/codebase"),
+          needs_codebase_map: (has_code || has_package_file) && !path_exists?(cwd, ".ariadna_planning/codebase"),
           has_git: path_exists?(cwd, ".git")
         }
 
@@ -202,9 +207,9 @@ module Ariadna
           research_enabled: config["research"],
           current_milestone: milestone[:version],
           current_milestone_name: milestone[:name],
-          project_exists: path_exists?(cwd, ".planning/PROJECT.md"),
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md"),
-          state_exists: path_exists?(cwd, ".planning/STATE.md")
+          project_exists: path_exists?(cwd, ".ariadna_planning/PROJECT.md"),
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md"),
+          state_exists: path_exists?(cwd, ".ariadna_planning/STATE.md")
         }
 
         Output.json(result, raw: raw)
@@ -216,7 +221,7 @@ module Ariadna
         now = Time.now.utc
         slug = description && !description.empty? ? generate_slug(description)&.slice(0, 40) : nil
 
-        quick_dir = File.join(cwd, ".planning", "quick")
+        quick_dir = File.join(cwd, ".ariadna_planning", "quick")
         next_num = 1
         if File.directory?(quick_dir)
           existing = Dir.children(quick_dir)
@@ -233,10 +238,10 @@ module Ariadna
           description: description && !description.empty? ? description : nil,
           date: now.strftime("%Y-%m-%d"),
           timestamp: now.iso8601,
-          quick_dir: ".planning/quick",
-          task_dir: slug ? ".planning/quick/#{next_num}-#{slug}" : nil,
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md"),
-          planning_exists: path_exists?(cwd, ".planning")
+          quick_dir: ".ariadna_planning/quick",
+          task_dir: slug ? ".ariadna_planning/quick/#{next_num}-#{slug}" : nil,
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md"),
+          planning_exists: path_exists?(cwd, ".ariadna_planning")
         }
 
         Output.json(result, raw: raw)
@@ -247,14 +252,14 @@ module Ariadna
         config = ConfigManager.load_config(cwd)
 
         interrupted_agent_id = nil
-        agent_file = File.join(cwd, ".planning", "current-agent-id.txt")
+        agent_file = File.join(cwd, ".ariadna_planning", "current-agent-id.txt")
         interrupted_agent_id = File.read(agent_file).strip if File.exist?(agent_file)
 
         result = {
-          state_exists: path_exists?(cwd, ".planning/STATE.md"),
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md"),
-          project_exists: path_exists?(cwd, ".planning/PROJECT.md"),
-          planning_exists: path_exists?(cwd, ".planning"),
+          state_exists: path_exists?(cwd, ".ariadna_planning/STATE.md"),
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md"),
+          project_exists: path_exists?(cwd, ".ariadna_planning/PROJECT.md"),
+          planning_exists: path_exists?(cwd, ".ariadna_planning"),
           has_interrupted_agent: !interrupted_agent_id.nil?,
           interrupted_agent_id: interrupted_agent_id,
           commit_docs: config["commit_docs"]
@@ -302,8 +307,8 @@ module Ariadna
           has_plans: (phase_info&.dig(:plans)&.length || 0) > 0,
           has_verification: phase_info&.dig(:has_verification) || false,
           plan_count: phase_info&.dig(:plans)&.length || 0,
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md"),
-          planning_exists: path_exists?(cwd, ".planning")
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md"),
+          planning_exists: path_exists?(cwd, ".ariadna_planning")
         }
 
         Output.json(result, raw: raw)
@@ -314,7 +319,7 @@ module Ariadna
         config = ConfigManager.load_config(cwd)
         now = Time.now.utc
 
-        pending_dir = File.join(cwd, ".planning", "todos", "pending")
+        pending_dir = File.join(cwd, ".ariadna_planning", "todos", "pending")
         count = 0
         todo_list = []
 
@@ -330,7 +335,7 @@ module Ariadna
             count += 1
             todo_list << {
               file: File.basename(file), created: created, title: title, area: todo_area,
-              path: File.join(".planning", "todos", "pending", File.basename(file))
+              path: File.join(".ariadna_planning", "todos", "pending", File.basename(file))
             }
           end
         end
@@ -342,11 +347,11 @@ module Ariadna
           todo_count: count,
           todos: todo_list,
           area_filter: area,
-          pending_dir: ".planning/todos/pending",
-          completed_dir: ".planning/todos/completed",
-          planning_exists: path_exists?(cwd, ".planning"),
-          todos_dir_exists: path_exists?(cwd, ".planning/todos"),
-          pending_dir_exists: path_exists?(cwd, ".planning/todos/pending")
+          pending_dir: ".ariadna_planning/todos/pending",
+          completed_dir: ".ariadna_planning/todos/completed",
+          planning_exists: path_exists?(cwd, ".ariadna_planning"),
+          todos_dir_exists: path_exists?(cwd, ".ariadna_planning/todos"),
+          pending_dir_exists: path_exists?(cwd, ".ariadna_planning/todos/pending")
         }
 
         Output.json(result, raw: raw)
@@ -357,7 +362,7 @@ module Ariadna
         config = ConfigManager.load_config(cwd)
         milestone = get_milestone_info(cwd)
 
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         phase_count = 0
         completed_phases = 0
 
@@ -370,7 +375,7 @@ module Ariadna
           end
         end
 
-        archive_dir = File.join(cwd, ".planning", "archive")
+        archive_dir = File.join(cwd, ".ariadna_planning", "archive")
         archived_milestones = []
         if File.directory?(archive_dir)
           archived_milestones = Dir.children(archive_dir).select { |e| File.directory?(File.join(archive_dir, e)) }
@@ -386,11 +391,11 @@ module Ariadna
           all_phases_complete: phase_count > 0 && phase_count == completed_phases,
           archived_milestones: archived_milestones,
           archive_count: archived_milestones.length,
-          project_exists: path_exists?(cwd, ".planning/PROJECT.md"),
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md"),
-          state_exists: path_exists?(cwd, ".planning/STATE.md"),
-          archive_exists: path_exists?(cwd, ".planning/archive"),
-          phases_dir_exists: path_exists?(cwd, ".planning/phases")
+          project_exists: path_exists?(cwd, ".ariadna_planning/PROJECT.md"),
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md"),
+          state_exists: path_exists?(cwd, ".ariadna_planning/STATE.md"),
+          archive_exists: path_exists?(cwd, ".ariadna_planning/archive"),
+          phases_dir_exists: path_exists?(cwd, ".ariadna_planning/phases")
         }
 
         Output.json(result, raw: raw)
@@ -400,7 +405,7 @@ module Ariadna
         cwd = Dir.pwd
         config = ConfigManager.load_config(cwd)
 
-        codebase_dir = File.join(cwd, ".planning", "codebase")
+        codebase_dir = File.join(cwd, ".ariadna_planning", "codebase")
         existing_maps = []
         existing_maps = Dir.children(codebase_dir).select { |f| f.end_with?(".md") } if File.directory?(codebase_dir)
 
@@ -409,11 +414,11 @@ module Ariadna
           commit_docs: config["commit_docs"],
           search_gitignored: config["search_gitignored"],
           parallelization: config["parallelization"],
-          codebase_dir: ".planning/codebase",
+          codebase_dir: ".ariadna_planning/codebase",
           existing_maps: existing_maps,
           has_maps: existing_maps.any?,
-          planning_exists: path_exists?(cwd, ".planning"),
-          codebase_dir_exists: path_exists?(cwd, ".planning/codebase")
+          planning_exists: path_exists?(cwd, ".ariadna_planning"),
+          codebase_dir_exists: path_exists?(cwd, ".ariadna_planning/codebase")
         }
 
         Output.json(result, raw: raw)
@@ -424,7 +429,7 @@ module Ariadna
         config = ConfigManager.load_config(cwd)
         milestone = get_milestone_info(cwd)
 
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         phases = []
         current_phase = nil
         next_phase = nil
@@ -458,7 +463,7 @@ module Ariadna
 
             phase_entry = {
               number: phase_number, name: phase_name,
-              directory: File.join(".planning", "phases", dir),
+              directory: File.join(".ariadna_planning", "phases", dir),
               status: status, plan_count: plans.length,
               summary_count: summaries.length, has_research: has_research
             }
@@ -470,7 +475,7 @@ module Ariadna
         end
 
         paused_at = nil
-        state_path = File.join(cwd, ".planning", "STATE.md")
+        state_path = File.join(cwd, ".ariadna_planning", "STATE.md")
         if File.exist?(state_path)
           state_content = File.read(state_path)
           pause_match = state_content.match(/\*\*Paused At:\*\*\s*(.+)/)
@@ -491,15 +496,15 @@ module Ariadna
           next_phase: next_phase,
           paused_at: paused_at,
           has_work_in_progress: !current_phase.nil?,
-          project_exists: path_exists?(cwd, ".planning/PROJECT.md"),
-          roadmap_exists: path_exists?(cwd, ".planning/ROADMAP.md"),
-          state_exists: path_exists?(cwd, ".planning/STATE.md")
+          project_exists: path_exists?(cwd, ".ariadna_planning/PROJECT.md"),
+          roadmap_exists: path_exists?(cwd, ".ariadna_planning/ROADMAP.md"),
+          state_exists: path_exists?(cwd, ".ariadna_planning/STATE.md")
         }
 
-        result[:state_content] = safe_read_file(File.join(cwd, ".planning", "STATE.md")) if includes.include?("state")
-        result[:roadmap_content] = safe_read_file(File.join(cwd, ".planning", "ROADMAP.md")) if includes.include?("roadmap")
-        result[:project_content] = safe_read_file(File.join(cwd, ".planning", "PROJECT.md")) if includes.include?("project")
-        result[:config_content] = safe_read_file(File.join(cwd, ".planning", "config.json")) if includes.include?("config")
+        result[:state_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "STATE.md")) if includes.include?("state")
+        result[:roadmap_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "ROADMAP.md")) if includes.include?("roadmap")
+        result[:project_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "PROJECT.md")) if includes.include?("project")
+        result[:config_content] = safe_read_file(File.join(cwd, ".ariadna_planning", "config.json")) if includes.include?("config")
 
         Output.json(result, raw: raw)
       end
@@ -509,7 +514,7 @@ module Ariadna
       def self.find_phase_internal(cwd, phase)
         return nil unless phase
 
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         normalized = normalize_phase(phase)
 
         return nil unless File.directory?(phases_dir)
@@ -539,7 +544,7 @@ module Ariadna
         end
 
         {
-          directory: File.join(".planning", "phases", match),
+          directory: File.join(".ariadna_planning", "phases", match),
           phase_number: phase_number,
           phase_name: phase_name,
           phase_slug: phase_slug,
@@ -555,7 +560,7 @@ module Ariadna
       end
 
       def self.get_milestone_info(cwd)
-        roadmap = File.read(File.join(cwd, ".planning", "ROADMAP.md"))
+        roadmap = File.read(File.join(cwd, ".ariadna_planning", "ROADMAP.md"))
         version_match = roadmap.match(/v(\d+\.\d+)/)
         name_match = roadmap.match(/## .*v\d+\.\d+[:\s]+([^\n(]+)/)
         {

data/lib/ariadna/tools/phase_manager.rb

@@ -60,7 +60,7 @@ module Ariadna
         Output.error("phase identifier required") unless phase
 
         cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         normalized = normalize_phase_name(phase)
         not_found = { found: false, directory: nil, phase_number: nil, phase_name: nil, plans: [], summaries: [] }
 
@@ -88,7 +88,7 @@ module Ariadna
 
         result = {
           found: true,
-          directory: File.join(".planning", "phases", match),
+          directory: File.join(".ariadna_planning", "phases", match),
           phase_number: phase_number,
           phase_name: phase_name,
           plans: plans,
@@ -104,7 +104,7 @@ module Ariadna
         Output.error("phase required") unless phase
 
         cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         normalized = normalize_phase_name(phase)
 
         unless File.directory?(phases_dir)
@@ -128,15 +128,33 @@ module Ariadna
           fm = Frontmatter.extract(content)
           summary_name = f.sub(/-PLAN\.md$/i, "-SUMMARY.md")
           has_summary = File.exist?(File.join(dir_path, summary_name))
-          { file: f, phase: fm["phase"], plan: fm["plan"], wave: fm["wave"], type: fm["type"], completed: has_summary }
+          {
+            file: f, phase: fm["phase"], plan: fm["plan"], wave: fm["wave"],
+            type: fm["type"], completed: has_summary,
+            domain: fm["domain"] || "general",
+            depends_on: fm["depends_on"] || [],
+            files_modified: fm["files_modified"] || [],
+            autonomous: fm.key?("autonomous") ? fm["autonomous"] : true,
+            objective: fm["objective"],
+            task_count: content.scan(/<task\b/).count
+          }
         end
 
-        Output.json({ plans: plans, count: plans.size }, raw: raw)
+        domains = plans.map { |p| p[:domain] }.uniq
+        non_general = domains.reject { |d| d == "general" }
+
+        Output.json({
+                      plans: plans, count: plans.size,
+                      domains: domains,
+                      domain_count: non_general.size,
+                      multi_domain: non_general.size >= 2,
+                      recommend_team: plans.size >= 3 && non_general.size >= 2
+                    }, raw: raw)
       end
 
       def self.list(options, raw: false)
         cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
 
         unless File.directory?(phases_dir)
           key = options[:type] ? :files : :directories
@@ -174,7 +192,7 @@ module Ariadna
       def self.next_decimal(base_phase, raw: false)
         Output.error("base phase required") unless base_phase
         cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         normalized = normalize_phase_name(base_phase)
 
         unless File.directory?(phases_dir)
@@ -204,8 +222,8 @@ module Ariadna
       def self.add(description, raw: false)
         Output.error("description required") unless description && !description.empty?
         cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".planning", "phases")
-        roadmap_path = File.join(cwd, ".planning", "ROADMAP.md")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
+        roadmap_path = File.join(cwd, ".ariadna_planning", "ROADMAP.md")
 
         existing = if File.directory?(phases_dir)
                      Dir.children(phases_dir)
@@ -234,7 +252,7 @@ module Ariadna
       def self.insert(after, description, raw: false)
         Output.error("after phase and description required") unless after && description && !description.empty?
         cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         normalized = normalize_phase_name(after)
 
         # Calculate next decimal
@@ -259,7 +277,7 @@ module Ariadna
       def self.remove(phase, force: false, raw: false)
         Output.error("phase required") unless phase
         cwd = Dir.pwd
-        phases_dir = File.join(cwd, ".planning", "phases")
+        phases_dir = File.join(cwd, ".ariadna_planning", "phases")
         normalized = normalize_phase_name(phase)
 
         unless File.directory?(phases_dir)
@@ -290,7 +308,7 @@ module Ariadna
       def self.complete(phase, raw: false)
         Output.error("phase required") unless phase
         cwd = Dir.pwd
-        roadmap_path = File.join(cwd, ".planning", "ROADMAP.md")
+        roadmap_path = File.join(cwd, ".ariadna_planning", "ROADMAP.md")
         normalized = normalize_phase_name(phase)
 
         # Mark in ROADMAP.md
@@ -309,7 +327,7 @@ module Ariadna
         cwd = Dir.pwd
 
         # Create milestone archive
-        archive_dir = File.join(cwd, ".planning", "milestones")
+        archive_dir = File.join(cwd, ".ariadna_planning", "milestones")
         FileUtils.mkdir_p(archive_dir)
 
         milestone_name = name || "v#{version}"