ariadna 1.2.0 → 1.2.2

data/data/ariadna/workflows/execute-phase.md

@@ -19,11 +19,11 @@ Load all context in one call:
 INIT=$(ariadna-tools init execute-phase "${PHASE_ARG}")
 ```
 
-Parse JSON for: `executor_model`, `verifier_model`, `commit_docs`, `parallelization`, `branching_strategy`, `branch_name`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `plans`, `incomplete_plans`, `plan_count`, `incomplete_count`, `state_exists`, `roadmap_exists`.
+Parse JSON for: `executor_model`, `verifier_model`, `commit_docs`, `parallelization`, `branching_strategy`, `branch_name`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `plans`, `incomplete_plans`, `plan_count`, `incomplete_count`, `team_execution`, `execution_mode`, `backend_executor_model`, `frontend_executor_model`, `test_executor_model`, `state_exists`, `roadmap_exists`.
 
 **If `phase_found` is false:** Error — phase directory not found.
 **If `plan_count` is 0:** Error — no plans found in phase.
-**If `state_exists` is false but `.planning/` exists:** Offer reconstruct or continue.
+**If `state_exists` is false but `.ariadna_planning/` exists:** Offer reconstruct or continue.
 
 When `parallelization` is false, plans within a wave execute sequentially.
 </step>
@@ -54,7 +54,7 @@ Load plan inventory with wave grouping in one call:
 PLAN_INDEX=$(ariadna-tools phase-plan-index "${PHASE_NUMBER}")
 ```
 
-Parse JSON for: `phase`, `plans[]` (each with `id`, `wave`, `autonomous`, `objective`, `files_modified`, `task_count`, `has_summary`), `waves` (map of wave number → plan IDs), `incomplete`, `has_checkpoints`.
+Parse JSON for: `plans[]` (each with `file`, `phase`, `plan`, `wave`, `type`, `completed`, `domain`, `depends_on`, `files_modified`, `autonomous`, `objective`, `task_count`), `count`, `domains`, `domain_count`, `multi_domain`, `recommend_team`.
 
 **Filtering:** Skip plans where `has_summary: true`. If `--gaps-only`: also skip non-gap_closure plans. If all filtered: "No matching incomplete plans" → exit.
 
@@ -71,6 +71,28 @@ Report:
 ```
 </step>
 
+<step name="decide_execution_mode">
+**Determine execution mode:**
+
+1. If `--team` flag → team execution
+2. If `--no-team` flag → wave execution
+3. If `team_execution` from init is `true` → team execution
+4. If `team_execution` from init is `false` → wave execution
+5. If `team_execution` is `"auto"` → check plan index:
+   - Parse `multi_domain` and `recommend_team` from PLAN_INDEX
+   - If `recommend_team` is true (3+ plans, 2+ non-general domains) → team execution
+   - Otherwise → wave execution
+
+Report:
+```
+**Execution mode:** {Team | Wave}
+{If auto: "Auto-detected: {plan_count} plans across {domains}"}
+```
+
+If team mode: proceed to `team_execution` step.
+If wave mode: proceed to `execute_waves` step.
+</step>
+
 <step name="execute_waves">
 Execute each wave in sequence. Within a wave: parallel if `PARALLELIZATION=true`, sequential if `false`.
 
@@ -135,8 +157,8 @@ Execute each wave in sequence. Within a wave: parallel if `PARALLELIZATION=true`
        <files_to_read>
        Read these files at execution start using the Read tool:
        - Plan: {phase_dir}/{plan_file}
-       - State: .planning/STATE.md
-       - Config: .planning/config.json (if exists)
+       - State: .ariadna_planning/STATE.md
+       - Config: .ariadna_planning/config.json (if exists)
        </files_to_read>
 
        <success_criteria>
@@ -249,6 +271,17 @@ If `TEAM_MODE` is `true` OR `--team` flag present → use team execution. Otherw
    - Assign unblocked tasks to idle agents of the matching domain
    - Cross-domain handoffs: if a frontend task depends on a backend task, the frontend executor can read the backend SUMMARY.md for context
 
+   **Progress reporting (on each task completion message from an agent):**
+   Check `TaskList` and display:
+   ```
+   ## Team Progress
+   | Agent             | Status  | Current Task | Completed |
+   |-------------------|---------|-------------|-----------|
+   | backend-executor  | working | Plan 03-01  | 1/3       |
+   | frontend-executor | idle    | waiting     | 0/2       |
+   | test-executor     | working | Plan 03-03  | 0/1       |
+   ```
+
 6. **Handle checkpoints:** Same as wave-based — agent sends message to orchestrator, orchestrator presents checkpoint to user, spawns continuation agent.
 
 7. **Shutdown team:** When all tasks are complete:
@@ -261,6 +294,10 @@ If `TEAM_MODE` is `true` OR `--team` flag present → use team execution. Otherw
    ```
 
 **Conflict prevention:** File ownership is enforced by `files_modified` frontmatter — the planner ensures no overlap between concurrent plans assigned to different agents.
+
+**STATE.md serialization:** Agents do NOT update STATE.md in team mode.
+The orchestrator reads each SUMMARY.md after all tasks complete and
+updates STATE.md sequentially. This prevents concurrent write corruption.
 </step>
 
 <step name="checkpoint_handling">
@@ -296,12 +333,28 @@ Plans with `autonomous: false` require user interaction.
 </step>
 
 <step name="aggregate_results">
-After all waves:
+After all waves (or after all team tasks complete):
+
+**Team mode state aggregation (if team execution was used):**
+
+For each completed task's SUMMARY.md, in plan order:
+```bash
+ariadna-tools state advance-plan
+ariadna-tools state record-metric \
+  --phase "${PHASE}" --plan "${PLAN}" --duration "${DURATION}" \
+  --tasks "${TASK_COUNT}" --files "${FILE_COUNT}"
+```
+This runs sequentially from the orchestrator to prevent concurrent writes.
+
+**Aggregate requirements coverage:** Parse `requirements_covered` from all SUMMARY.md frontmatter in this phase. Cross-check against `requirements_content` (from INIT or re-read REQUIREMENTS.md) for requirements mapped to this phase. Flag uncovered requirements. Show coverage count.
+
+If covered requirements exist, update REQUIREMENTS.md traceability table: set status to "Complete" for each covered REQ-ID, with evidence from the SUMMARY frontmatter.
 
 ```markdown
 ## Phase {X}: {Name} Execution Complete
 
 **Waves:** {N} | **Plans:** {M}/{total} complete
+**Requirements:** {covered}/{total_for_phase} covered
 
 | Wave | Plans | Status |
 |------|-------|--------|
@@ -313,6 +366,14 @@ After all waves:
 1. **03-01**: [one-liner from SUMMARY.md]
 2. **03-02**: [one-liner from SUMMARY.md]
 
+### Requirements Coverage
+| REQ-ID | Requirement | Evidence |
+|--------|-------------|----------|
+| {id} | {description} | {evidence from SUMMARY} |
+| {id} | {description} | ⚠ Not covered |
+
+[Omit section if no REQUIREMENTS.md or no requirements for this phase]
+
 ### Issues Encountered
 [Aggregate from SUMMARYs, or "None"]
 ```
@@ -339,8 +400,8 @@ grep "^status:" "$PHASE_DIR"/*-VERIFICATION.md | cut -d: -f2 | tr -d ' '
 
 | Status | Action |
 |--------|--------|
-| `passed` | → update_roadmap |
-| `human_needed` | Present items for human testing, get approval or feedback |
+| `passed` | → user_acceptance |
+| `human_needed` | Present items for human testing, get approval or feedback → user_acceptance |
 | `gaps_found` | Present gap summary, offer `/ariadna:plan-phase {phase} --gaps` |
 
 **If human_needed:**
@@ -378,11 +439,38 @@ Also: `/ariadna:verify-work {X}` — manual testing first
 Gap closure cycle: `/ariadna:plan-phase {X} --gaps` reads VERIFICATION.md → creates gap plans with `gap_closure: true` → user runs `/ariadna:execute-phase {X} --gaps-only` → verifier re-runs.
 </step>
 
+<step name="user_acceptance">
+**Trigger:** After verifier returns `passed` (or `human_needed` items are approved by user).
+
+**Skip if:** `--no-review` flag, or ALL plans in this phase have `domain: backend` or `domain: testing` only (no user-facing deliverables).
+
+**Otherwise:** Show a lightweight acceptance gate. Gather one-liners from each SUMMARY.md + key decisions Claude made during execution:
+
+```
+questions: [
+  {
+    header: "Acceptance",
+    question: "Phase {X}: {Name} — verified and passing.\n\nWhat was built:\n- {one-liner from SUMMARY 1}\n- {one-liner from SUMMARY 2}\n\nKey decisions made:\n- {decision 1 from SUMMARY}\n- {decision 2 from SUMMARY}\n\nDoes the direction look right?",
+    multiSelect: false,
+    options: [
+      { label: "Looks good", description: "Mark phase complete and continue" },
+      { label: "Test first", description: "Run /ariadna:verify-work before marking complete" },
+      { label: "Issues", description: "Record blocker and suggest gap closure" }
+    ]
+  }
+]
+```
+
+- **"Looks good":** Proceed to `update_roadmap`.
+- **"Test first":** Display: `Run /ariadna:verify-work {X} to test, then re-run /ariadna:execute-phase {X} to continue.` Exit without marking phase complete.
+- **"Issues":** Ask user to describe the issue. Record as blocker in STATE.md via `ariadna-tools state add-blocker "{issue}"`. Display: `Blocker recorded. Run /ariadna:plan-phase {X} --gaps to create fix plans.` Exit without marking phase complete.
+</step>
+
 <step name="update_roadmap">
 Mark phase complete in ROADMAP.md (date, status).
 
 ```bash
-ariadna-tools commit "docs(phase-{X}): complete phase execution" --files .planning/ROADMAP.md .planning/STATE.md .planning/phases/{phase_dir}/*-VERIFICATION.md .planning/REQUIREMENTS.md
+ariadna-tools commit "docs(phase-{X}): complete phase execution" --files .ariadna_planning/ROADMAP.md .ariadna_planning/STATE.md .ariadna_planning/phases/{phase_dir}/*-VERIFICATION.md .ariadna_planning/REQUIREMENTS.md
 ```
 </step>
 

data/data/ariadna/workflows/execute-plan.md

@@ -26,14 +26,14 @@ STATE_CONTENT=$(echo "$INIT" | jq -r '.state_content // empty')
 CONFIG_CONTENT=$(echo "$INIT" | jq -r '.config_content // empty')
 ```
 
-If `.planning/` missing: error.
+If `.ariadna_planning/` missing: error.
 </step>
 
 <step name="identify_plan">
 ```bash
 # Use plans/summaries from INIT JSON, or list files
-ls .planning/phases/XX-name/*-PLAN.md 2>/dev/null | sort
-ls .planning/phases/XX-name/*-SUMMARY.md 2>/dev/null | sort
+ls .ariadna_planning/phases/XX-name/*-PLAN.md 2>/dev/null | sort
+ls .ariadna_planning/phases/XX-name/*-SUMMARY.md 2>/dev/null | sort
 ```
 
 Find first PLAN without matching SUMMARY. Decimal phases supported (`01.1-hotfix/`):
@@ -61,7 +61,7 @@ PLAN_START_EPOCH=$(date +%s)
 
 <step name="parse_segments">
 ```bash
-grep -n "type=\"checkpoint" .planning/phases/XX-name/{phase}-{plan}-PLAN.md
+grep -n "type=\"checkpoint" .ariadna_planning/phases/XX-name/{phase}-{plan}-PLAN.md
 ```
 
 **Routing by checkpoint type:**
@@ -83,12 +83,12 @@ Fresh context per subagent preserves peak quality. Main context stays lean.
 
 <step name="init_agent_tracking">
 ```bash
-if [ ! -f .planning/agent-history.json ]; then
-  echo '{"version":"1.0","max_entries":50,"entries":[]}' > .planning/agent-history.json
+if [ ! -f .ariadna_planning/agent-history.json ]; then
+  echo '{"version":"1.0","max_entries":50,"entries":[]}' > .ariadna_planning/agent-history.json
 fi
-rm -f .planning/current-agent-id.txt
-if [ -f .planning/current-agent-id.txt ]; then
-  INTERRUPTED_ID=$(cat .planning/current-agent-id.txt)
+rm -f .ariadna_planning/current-agent-id.txt
+if [ -f .ariadna_planning/current-agent-id.txt ]; then
+  INTERRUPTED_ID=$(cat .ariadna_planning/current-agent-id.txt)
   echo "Found interrupted agent: $INTERRUPTED_ID"
 fi
 ```
@@ -121,14 +121,14 @@ Pattern B only (verify-only checkpoints). Skip for A/C.
 
 <step name="load_prompt">
 ```bash
-cat .planning/phases/XX-name/{phase}-{plan}-PLAN.md
+cat .ariadna_planning/phases/XX-name/{phase}-{plan}-PLAN.md
 ```
 This IS the execution instructions. Follow exactly. If plan references CONTEXT.md: honor user's vision throughout.
 </step>
 
 <step name="previous_phase_check">
 ```bash
-ls .planning/phases/*/SUMMARY.md 2>/dev/null | sort -r | head -2 | tail -1
+ls .ariadna_planning/phases/*/SUMMARY.md 2>/dev/null | sort -r | head -2 | tail -1
 ```
 If previous SUMMARY has unresolved "Issues Encountered" or "Next Phase Readiness" blockers: AskUserQuestion(header="Previous Issues", options: "Proceed anyway" | "Address first" | "Review previous").
 </step>
@@ -312,16 +312,27 @@ fi
 
 <step name="generate_user_setup">
 ```bash
-grep -A 50 "^user_setup:" .planning/phases/XX-name/{phase}-{plan}-PLAN.md | head -50
+grep -A 50 "^user_setup:" .ariadna_planning/phases/XX-name/{phase}-{plan}-PLAN.md | head -50
 ```
 
 If user_setup exists: create `{phase}-USER-SETUP.md` using template `~/.claude/ariadna/templates/user-setup.md`. Per service: env vars table, account setup checklist, dashboard config, local dev notes, verification commands. Status "Incomplete". Set `USER_SETUP_CREATED=true`. If empty/missing: skip.
 </step>
 
 <step name="create_summary">
-Create `{phase}-{plan}-SUMMARY.md` at `.planning/phases/XX-name/`. Use `~/.claude/ariadna/templates/summary.md`.
+Create `{phase}-{plan}-SUMMARY.md` at `.ariadna_planning/phases/XX-name/`. Use `~/.claude/ariadna/templates/summary.md`.
 
-**Frontmatter:** phase, plan, subsystem, tags | requires/provides/affects | tech-stack.added/patterns | key-files.created/modified | key-decisions | duration ($DURATION), completed ($PLAN_END_TIME date).
+**Frontmatter:** phase, plan, subsystem, tags | requires/provides/affects | tech-stack.added/patterns | key-files.created/modified | key-decisions | requirements_covered | duration ($DURATION), completed ($PLAN_END_TIME date).
+
+**Requirements traceability:** Cross-reference plan tasks against `requirements_content` (from INIT, or read `.ariadna_planning/REQUIREMENTS.md`). For each requirement mapped to this phase that was implemented by tasks in this plan, populate the `requirements_covered` frontmatter:
+```yaml
+requirements_covered:
+  - id: "AUTH-01"
+    description: "User can sign up with email and password"
+    evidence: "SessionsController#create + User model with has_secure_password"
+```
+Use the actual REQ-ID and description from REQUIREMENTS.md. Evidence should reference the specific file/class/method that implements the requirement. Omit the `requirements_covered` field entirely if no REQUIREMENTS.md exists or no requirements map to this plan.
+
+Also populate the `## Requirements Covered` markdown section (after Accomplishments) with the same data in table format.
 
 Title: `# Phase [X] Plan [Y]: [Name] Summary`
 
@@ -386,12 +397,12 @@ More plans → update plan count, keep "In progress". Last plan → mark phase "
 Task code already committed per-task. Commit plan metadata:
 
 ```bash
-ariadna-tools commit "docs({phase}-{plan}): complete [plan-name] plan" --files .planning/phases/XX-name/{phase}-{plan}-SUMMARY.md .planning/STATE.md .planning/ROADMAP.md
+ariadna-tools commit "docs({phase}-{plan}): complete [plan-name] plan" --files .ariadna_planning/phases/XX-name/{phase}-{plan}-SUMMARY.md .ariadna_planning/STATE.md .ariadna_planning/ROADMAP.md
 ```
 </step>
 
 <step name="update_codebase_map">
-If .planning/codebase/ doesn't exist: skip.
+If .ariadna_planning/codebase/ doesn't exist: skip.
 
 ```bash
 FIRST_TASK=$(git log --oneline --grep="feat({phase}-{plan}):" --grep="fix({phase}-{plan}):" --grep="test({phase}-{plan}):" --reverse | head -1 | cut -d' ' -f1)
@@ -401,7 +412,7 @@ git diff --name-only ${FIRST_TASK}^..HEAD 2>/dev/null
 Update only structural changes: new src/ dir → STRUCTURE.md | deps → STACK.md | file pattern → CONVENTIONS.md | API client → INTEGRATIONS.md | config → STACK.md | renamed → update paths. Skip code-only/bugfix/content changes.
 
 ```bash
-ariadna-tools commit "" --files .planning/codebase/*.md --amend
+ariadna-tools commit "" --files .ariadna_planning/codebase/*.md --amend
 ```
 </step>
 
@@ -409,8 +420,8 @@ ariadna-tools commit "" --files .planning/codebase/*.md --amend
 If `USER_SETUP_CREATED=true`: display `⚠️ USER SETUP REQUIRED` with path + env/config tasks at TOP.
 
 ```bash
-ls -1 .planning/phases/[current-phase-dir]/*-PLAN.md 2>/dev/null | wc -l
-ls -1 .planning/phases/[current-phase-dir]/*-SUMMARY.md 2>/dev/null | wc -l
+ls -1 .ariadna_planning/phases/[current-phase-dir]/*-PLAN.md 2>/dev/null | wc -l
+ls -1 .ariadna_planning/phases/[current-phase-dir]/*-SUMMARY.md 2>/dev/null | wc -l
 ```
 
 | Condition | Route | Action |

data/data/ariadna/workflows/help.md

@@ -38,7 +38,7 @@ One command takes you from idea to ready-for-planning:
 - Requirements definition with v1/v2/out-of-scope scoping
 - Roadmap creation with phase breakdown and success criteria
 
-Creates all `.planning/` artifacts:
+Creates all `.ariadna_planning/` artifacts:
 - `PROJECT.md` — vision and requirements
 - `config.json` — workflow mode (interactive/yolo)
 - `research/` — domain research (if selected)
@@ -52,7 +52,7 @@ Usage: `/ariadna:new-project`
 Map an existing codebase for brownfield projects.
 
 - Analyzes codebase with parallel Explore agents
-- Creates `.planning/codebase/` with 7 focused documents
+- Creates `.ariadna_planning/codebase/` with 7 focused documents
 - Covers stack, architecture, structure, conventions, testing, integrations, concerns
 - Use before `/ariadna:new-project` on existing codebases
 
@@ -91,13 +91,13 @@ Usage: `/ariadna:list-phase-assumptions 3`
 **`/ariadna:plan-phase <number>`**
 Create detailed execution plan for a specific phase.
 
-- Generates `.planning/phases/XX-phase-name/XX-YY-PLAN.md`
+- Generates `.ariadna_planning/phases/XX-phase-name/XX-YY-PLAN.md`
 - Breaks phase into concrete, actionable tasks
 - Includes verification criteria and success measures
 - Multiple plans per phase supported (XX-01, XX-02, etc.)
 
 Usage: `/ariadna:plan-phase 1`
-Result: Creates `.planning/phases/01-foundation/01-01-PLAN.md`
+Result: Creates `.ariadna_planning/phases/01-foundation/01-01-PLAN.md`
 
 ### Execution
 
@@ -118,13 +118,13 @@ Execute small, ad-hoc tasks with Ariadna guarantees but skip optional agents.
 
 Quick mode uses the same system with a shorter path:
 - Spawns planner + executor (skips researcher, checker, verifier)
-- Quick tasks live in `.planning/quick/` separate from planned phases
+- Quick tasks live in `.ariadna_planning/quick/` separate from planned phases
 - Updates STATE.md tracking (not ROADMAP.md)
 
 Use when you know exactly what to do and the task is small enough to not need research or verification.
 
 Usage: `/ariadna:quick`
-Result: Creates `.planning/quick/NNN-slug/PLAN.md`, `.planning/quick/NNN-slug/SUMMARY.md`
+Result: Creates `.ariadna_planning/quick/NNN-slug/PLAN.md`, `.ariadna_planning/quick/NNN-slug/SUMMARY.md`
 
 ### Roadmap Management
 
@@ -222,10 +222,10 @@ Usage: `/ariadna:pause-work`
 Systematic debugging with persistent state across context resets.
 
 - Gathers symptoms through adaptive questioning
-- Creates `.planning/debug/[slug].md` to track investigation
+- Creates `.ariadna_planning/debug/[slug].md` to track investigation
 - Investigates using scientific method (evidence → hypothesis → test)
 - Survives `/clear` — run `/ariadna:debug` with no args to resume
-- Archives resolved issues to `.planning/debug/resolved/`
+- Archives resolved issues to `.ariadna_planning/debug/resolved/`
 
 Usage: `/ariadna:debug "login button doesn't work"`
 Usage: `/ariadna:debug` (resume active session)
@@ -236,7 +236,7 @@ Usage: `/ariadna:debug` (resume active session)
 Capture idea or task as todo from current conversation.
 
 - Extracts context from conversation (or uses provided description)
-- Creates structured todo file in `.planning/todos/pending/`
+- Creates structured todo file in `.ariadna_planning/todos/pending/`
 - Infers area from file paths for grouping
 - Checks for duplicates before creating
 - Updates STATE.md todo count
@@ -297,7 +297,7 @@ Configure workflow toggles and model profile interactively.
 
 - Toggle researcher, plan checker, verifier agents
 - Select model profile (quality/balanced/budget)
-- Updates `.planning/config.json`
+- Updates `.ariadna_planning/config.json`
 
 Usage: `/ariadna:settings`
 
@@ -337,7 +337,7 @@ Usage: `/ariadna:join-discord`
 ## Files & Structure
 
 ```
-.planning/
+.ariadna_planning/
 ├── PROJECT.md            # Project vision
 ├── ROADMAP.md            # Current phase breakdown
 ├── STATE.md              # Project memory & context
@@ -380,24 +380,24 @@ Set during `/ariadna:new-project`:
 - Executes plans without confirmation
 - Only stops for critical checkpoints
 
-Change anytime by editing `.planning/config.json`
+Change anytime by editing `.ariadna_planning/config.json`
 
 ## Planning Configuration
 
-Configure how planning artifacts are managed in `.planning/config.json`:
+Configure how planning artifacts are managed in `.ariadna_planning/config.json`:
 
 **`planning.commit_docs`** (default: `true`)
 - `true`: Planning artifacts committed to git (standard workflow)
 - `false`: Planning artifacts kept local-only, not committed
 
 When `commit_docs: false`:
-- Add `.planning/` to your `.gitignore`
+- Add `.ariadna_planning/` to your `.gitignore`
 - Useful for OSS contributions, client projects, or keeping planning private
 - All planning files still work normally, just not tracked in git
 
 **`planning.search_gitignored`** (default: `false`)
 - `true`: Add `--no-ignore` to broad ripgrep searches
-- Only needed when `.planning/` is gitignored and you want project-wide searches to include it
+- Only needed when `.ariadna_planning/` is gitignored and you want project-wide searches to include it
 
 Example config:
 ```json
@@ -463,8 +463,8 @@ Example config:
 
 ## Getting Help
 
-- Read `.planning/PROJECT.md` for project vision
-- Read `.planning/STATE.md` for current context
-- Check `.planning/ROADMAP.md` for phase status
+- Read `.ariadna_planning/PROJECT.md` for project vision
+- Read `.ariadna_planning/STATE.md` for current context
+- Check `.ariadna_planning/ROADMAP.md` for phase status
 - Run `/ariadna:progress` to check where you're up to
 </reference>

data/data/ariadna/workflows/insert-phase.md

@@ -39,7 +39,7 @@ INIT=$(ariadna-tools init phase-op "${after_phase}")
 
 Check `roadmap_exists` from init JSON. If false:
 ```
-ERROR: No roadmap found (.planning/ROADMAP.md)
+ERROR: No roadmap found (.ariadna_planning/ROADMAP.md)
 ```
 Exit.
 </step>
@@ -55,7 +55,7 @@ The CLI handles:
 - Verifying target phase exists in ROADMAP.md
 - Calculating next decimal phase number (checking existing decimals on disk)
 - Generating slug from description
-- Creating the phase directory (`.planning/phases/{N.M}-{slug}/`)
+- Creating the phase directory (`.ariadna_planning/phases/{N.M}-{slug}/`)
 - Inserting the phase entry into ROADMAP.md after the target phase with (INSERTED) marker
 
 Extract from result: `phase_number`, `after_phase`, `name`, `slug`, `directory`.
@@ -64,7 +64,7 @@ Extract from result: `phase_number`, `after_phase`, `name`, `slug`, `directory`.
 <step name="update_project_state">
 Update STATE.md to reflect the inserted phase:
 
-1. Read `.planning/STATE.md`
+1. Read `.ariadna_planning/STATE.md`
 2. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
    ```
    - Phase {decimal_phase} inserted after Phase {after_phase}: {description} (URGENT)
@@ -79,12 +79,12 @@ Present completion summary:
 ```
 Phase {decimal_phase} inserted after Phase {after_phase}:
 - Description: {description}
-- Directory: .planning/phases/{decimal-phase}-{slug}/
+- Directory: .ariadna_planning/phases/{decimal-phase}-{slug}/
 - Status: Not planned yet
 - Marker: (INSERTED) - indicates urgent work
 
-Roadmap updated: .planning/ROADMAP.md
-Project state updated: .planning/STATE.md
+Roadmap updated: .ariadna_planning/ROADMAP.md
+Project state updated: .ariadna_planning/STATE.md
 
 ---
 

data/data/ariadna/workflows/list-phase-assumptions.md

@@ -24,7 +24,7 @@ Exit workflow.
 Validate phase exists in roadmap:
 
 ```bash
-cat .planning/ROADMAP.md | grep -i "Phase ${PHASE}"
+cat .ariadna_planning/ROADMAP.md | grep -i "Phase ${PHASE}"
 ```
 
 **If phase not found:**

data/data/ariadna/workflows/map-codebase.md

@@ -1,9 +1,9 @@
 <purpose>
-Orchestrate parallel codebase mapper agents to analyze codebase and produce structured documents in .planning/codebase/
+Orchestrate parallel codebase mapper agents to analyze codebase and produce structured documents in .ariadna_planning/codebase/
 
 Each agent has fresh context, explores a specific focus area, and **writes documents directly**. The orchestrator only receives confirmation + line counts, then writes a summary.
 
-Output: .planning/codebase/ folder with 7 structured documents about the codebase state.
+Output: .ariadna_planning/codebase/ folder with 7 structured documents about the codebase state.
 </purpose>
 
 <philosophy>
@@ -33,17 +33,17 @@ Extract from init JSON: `mapper_model`, `commit_docs`, `codebase_dir`, `existing
 </step>
 
 <step name="check_existing">
-Check if .planning/codebase/ already exists using `has_maps` from init context.
+Check if .ariadna_planning/codebase/ already exists using `has_maps` from init context.
 
 If `codebase_dir_exists` is true:
 ```bash
-ls -la .planning/codebase/
+ls -la .ariadna_planning/codebase/
 ```
 
 **If exists:**
 
 ```
-.planning/codebase/ already exists with these documents:
+.ariadna_planning/codebase/ already exists with these documents:
 [List files found]
 
 What's next?
@@ -54,7 +54,7 @@ What's next?
 
 Wait for user response.
 
-If "Refresh": Delete .planning/codebase/, continue to create_structure
+If "Refresh": Delete .ariadna_planning/codebase/, continue to create_structure
 If "Update": Ask which documents to update, continue to spawn_agents (filtered)
 If "Skip": Exit workflow
 
@@ -63,10 +63,10 @@ Continue to create_structure.
 </step>
 
 <step name="create_structure">
-Create .planning/codebase/ directory:
+Create .ariadna_planning/codebase/ directory:
 
 ```bash
-mkdir -p .planning/codebase
+mkdir -p .ariadna_planning/codebase
 ```
 
 **Expected output files:**
@@ -104,7 +104,7 @@ Focus: tech
 
 Analyze this codebase for technology stack and external integrations.
 
-Write these documents to .planning/codebase/:
+Write these documents to .ariadna_planning/codebase/:
 - STACK.md - Languages, runtime, frameworks, dependencies, configuration
 - INTEGRATIONS.md - External APIs, databases, auth providers, webhooks
 
@@ -127,7 +127,7 @@ Focus: arch
 
 Analyze this codebase architecture and directory structure.
 
-Write these documents to .planning/codebase/:
+Write these documents to .ariadna_planning/codebase/:
 - ARCHITECTURE.md - Pattern, layers, data flow, abstractions, entry points
 - STRUCTURE.md - Directory layout, key locations, naming conventions
 
@@ -150,7 +150,7 @@ Focus: quality
 
 Analyze this codebase for coding conventions and testing patterns.
 
-Write these documents to .planning/codebase/:
+Write these documents to .ariadna_planning/codebase/:
 - CONVENTIONS.md - Code style, naming, patterns, error handling
 - TESTING.md - Framework, structure, mocking, coverage
 
@@ -173,7 +173,7 @@ Focus: concerns
 
 Analyze this codebase for technical debt, known issues, and areas of concern.
 
-Write this document to .planning/codebase/:
+Write this document to .ariadna_planning/codebase/:
 - CONCERNS.md - Tech debt, bugs, security, performance, fragile areas
 
 Explore thoroughly. Write document directly using template. Return confirmation only.
@@ -193,8 +193,8 @@ Read each agent's output file to collect confirmations.
 
 **Focus:** {focus}
 **Documents written:**
-- `.planning/codebase/{DOC1}.md` ({N} lines)
-- `.planning/codebase/{DOC2}.md` ({N} lines)
+- `.ariadna_planning/codebase/{DOC1}.md` ({N} lines)
+- `.ariadna_planning/codebase/{DOC2}.md` ({N} lines)
 
 Ready for orchestrator summary.
 ```
@@ -210,8 +210,8 @@ Continue to verify_output.
 Verify all documents created successfully:
 
 ```bash
-ls -la .planning/codebase/
-wc -l .planning/codebase/*.md
+ls -la .ariadna_planning/codebase/
+wc -l .ariadna_planning/codebase/*.md
 ```
 
 **Verification checklist:**
@@ -230,7 +230,7 @@ Run secret pattern detection:
 
 ```bash
 # Check for common API key patterns in generated docs
-grep -E '(sk-[a-zA-Z0-9]{20,}|sk_live_[a-zA-Z0-9]+|sk_test_[a-zA-Z0-9]+|ghp_[a-zA-Z0-9]{36}|gho_[a-zA-Z0-9]{36}|glpat-[a-zA-Z0-9_-]+|AKIA[A-Z0-9]{16}|xox[baprs]-[a-zA-Z0-9-]+|-----BEGIN.*PRIVATE KEY|eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.)' .planning/codebase/*.md 2>/dev/null && SECRETS_FOUND=true || SECRETS_FOUND=false
+grep -E '(sk-[a-zA-Z0-9]{20,}|sk_live_[a-zA-Z0-9]+|sk_test_[a-zA-Z0-9]+|ghp_[a-zA-Z0-9]{36}|gho_[a-zA-Z0-9]{36}|glpat-[a-zA-Z0-9_-]+|AKIA[A-Z0-9]{16}|xox[baprs]-[a-zA-Z0-9-]+|-----BEGIN.*PRIVATE KEY|eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.)' .ariadna_planning/codebase/*.md 2>/dev/null && SECRETS_FOUND=true || SECRETS_FOUND=false
 ```
 
 **If SECRETS_FOUND=true:**
@@ -262,7 +262,7 @@ Continue to commit_codebase_map.
 Commit the codebase map:
 
 ```bash
-ariadna-tools commit "docs: map existing codebase" --files .planning/codebase/*.md
+ariadna-tools commit "docs: map existing codebase" --files .ariadna_planning/codebase/*.md
 ```
 
 Continue to offer_next.
@@ -273,7 +273,7 @@ Present completion summary and next steps.
 
 **Get line counts:**
 ```bash
-wc -l .planning/codebase/*.md
+wc -l .ariadna_planning/codebase/*.md
 ```
 
 **Output format:**
@@ -281,7 +281,7 @@ wc -l .planning/codebase/*.md
 ```
 Codebase mapping complete.
 
-Created .planning/codebase/:
+Created .ariadna_planning/codebase/:
 - STACK.md ([N] lines) - Technologies and dependencies
 - ARCHITECTURE.md ([N] lines) - System design and patterns
 - STRUCTURE.md ([N] lines) - Directory layout and organization
@@ -305,7 +305,7 @@ Created .planning/codebase/:
 
 **Also available:**
 - Re-run mapping: `/ariadna:map-codebase`
-- Review specific file: `cat .planning/codebase/STACK.md`
+- Review specific file: `cat .ariadna_planning/codebase/STACK.md`
 - Edit any document before proceeding
 
 ---
@@ -317,7 +317,7 @@ End workflow.
 </process>
 
 <success_criteria>
-- .planning/codebase/ directory created
+- .ariadna_planning/codebase/ directory created
 - 4 parallel ariadna-codebase-mapper agents spawned with run_in_background=true
 - Agents write documents directly (orchestrator doesn't receive document contents)
 - Read agent output files to collect confirmations