ariadna 1.3.0 → 2.0.0

data/data/commands/ariadna/debug.md

@@ -1,162 +1,30 @@
 ---
 name: ariadna:debug
 description: Systematic debugging with persistent state across context resets
-argument-hint: [issue description]
+argument-hint: "[issue description]"
 allowed-tools:
   - Read
   - Bash
   - Task
   - AskUserQuestion
 ---
-
 <objective>
 Debug issues using scientific method with subagent isolation.
 
-**Orchestrator role:** Gather symptoms, spawn ariadna-debugger agent, handle checkpoints, spawn continuations.
-
-**Why subagent:** Investigation burns context fast (reading files, forming hypotheses, testing). Fresh 200k context per investigation. Main context stays lean for user interaction.
+Spawns `ariadna-debugger` with a fresh 200k context per investigation. Orchestrator stays lean: gather symptoms, spawn agent, handle checkpoints and continuations.
 </objective>
 
 <context>
-User's issue: $ARGUMENTS
-
-Check for active sessions:
-```bash
-ls .ariadna_planning/debug/*.md 2>/dev/null | grep -v resolved | head -5
-```
+Issue: $ARGUMENTS
 </context>
 
 <process>
-
-## 0. Initialize Context
-
-```bash
-INIT=$(ariadna-tools state load)
-```
-
-Extract `commit_docs` from init JSON. Resolve debugger model:
-```bash
-DEBUGGER_MODEL=$(ariadna-tools resolve-model ariadna-debugger --raw)
-```
-
-## 1. Check Active Sessions
-
-If active sessions exist AND no $ARGUMENTS:
-- List sessions with status, hypothesis, next action
-- User picks number to resume OR describes new issue
-
-If $ARGUMENTS provided OR user describes new issue:
-- Continue to symptom gathering
-
-## 2. Gather Symptoms (if new issue)
-
-Use AskUserQuestion for each:
-
-1. **Expected behavior** - What should happen?
-2. **Actual behavior** - What happens instead?
-3. **Error messages** - Any errors? (paste or describe)
-4. **Timeline** - When did this start? Ever worked?
-5. **Reproduction** - How do you trigger it?
-
-After all gathered, confirm ready to investigate.
-
-## 3. Spawn ariadna-debugger Agent
-
-Fill prompt and spawn:
-
-```markdown
-<objective>
-Investigate issue: {slug}
-
-**Summary:** {trigger}
-</objective>
-
-<symptoms>
-expected: {expected}
-actual: {actual}
-errors: {errors}
-reproduction: {reproduction}
-timeline: {timeline}
-</symptoms>
-
-<mode>
-symptoms_prefilled: true
-goal: find_and_fix
-</mode>
-
-<debug_file>
-Create: .ariadna_planning/debug/{slug}.md
-</debug_file>
-```
-
-```
-Task(
-  prompt=filled_prompt,
-  subagent_type="ariadna-debugger",
-  model="{debugger_model}",
-  description="Debug {slug}"
-)
-```
-
-## 4. Handle Agent Return
-
-**If `## ROOT CAUSE FOUND`:**
-- Display root cause and evidence summary
-- Offer options:
-  - "Fix now" - spawn fix subagent
-  - "Plan fix" - suggest /ariadna:plan-phase --gaps
-  - "Manual fix" - done
-
-**If `## CHECKPOINT REACHED`:**
-- Present checkpoint details to user
-- Get user response
-- Spawn continuation agent (see step 5)
-
-**If `## INVESTIGATION INCONCLUSIVE`:**
-- Show what was checked and eliminated
-- Offer options:
-  - "Continue investigating" - spawn new agent with additional context
-  - "Manual investigation" - done
-  - "Add more context" - gather more symptoms, spawn again
-
-## 5. Spawn Continuation Agent (After Checkpoint)
-
-When user responds to checkpoint, spawn fresh agent:
-
-```markdown
-<objective>
-Continue debugging {slug}. Evidence is in the debug file.
-</objective>
-
-<prior_state>
-Debug file: @.ariadna_planning/debug/{slug}.md
-</prior_state>
-
-<checkpoint_response>
-**Type:** {checkpoint_type}
-**Response:** {user_response}
-</checkpoint_response>
-
-<mode>
-goal: find_and_fix
-</mode>
-```
-
-```
-Task(
-  prompt=continuation_prompt,
-  subagent_type="ariadna-debugger",
-  model="{debugger_model}",
-  description="Continue debug {slug}"
-)
-```
-
+1. Run `ariadna-tools state load` and `ariadna-tools resolve-model ariadna-debugger --raw`.
+2. Check for active debug sessions: `ls .ariadna_planning/debug/*.md 2>/dev/null | grep -v resolved`.
+3. If active sessions and no $ARGUMENTS: list sessions, let user pick to resume or start new.
+4. If new issue: gather 5 symptoms via AskUserQuestion (expected, actual, errors, timeline, reproduction).
+5. Spawn `ariadna-debugger` with symptoms; agent creates `.ariadna_planning/debug/{slug}.md`.
+6. On `## ROOT CAUSE FOUND`: present cause, offer fix-now / plan-fix / manual.
+7. On `## CHECKPOINT REACHED`: collect user response, spawn continuation agent with debug file + response.
+8. On `## INVESTIGATION INCONCLUSIVE`: show what was eliminated, offer continue / manual / add context.
 </process>
-
-<success_criteria>
-- [ ] Active sessions checked
-- [ ] Symptoms gathered (if new)
-- [ ] ariadna-debugger spawned with context
-- [ ] Checkpoints handled correctly
-- [ ] Root cause confirmed before fixing
-</success_criteria>

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

@@ -1,7 +1,7 @@
 ---
 name: ariadna:execute-phase
 description: Execute all plans in a phase with wave-based parallelization
-argument-hint: "<phase-number> [--gaps-only] [--team] [--no-team]"
+argument-hint: "<phase-number> [--gaps-only]"
 allowed-tools:
   - Read
   - Write
@@ -11,46 +11,28 @@ allowed-tools:
   - Bash
   - Task
   - TodoWrite
-  - AskUserQuestion
-  - TeamCreate
-  - SendMessage
-  - TaskCreate
-  - TaskUpdate
-  - TaskList
-  - TeamDelete
 ---
 <objective>
-Execute all plans in a phase using wave-based parallel execution or team-based execution.
+Execute all plans in a phase using wave-based parallel execution.
 
-Orchestrator stays lean: discover plans, analyze dependencies, group into waves, spawn subagents, collect results. Each subagent loads the full execute-plan context and handles its own plan.
+Orchestrator stays lean: load context, group plans into waves, spawn `ariadna-executor` subagents, collect results. Each subagent loads its plan and handles its own work.
 
-**Execution modes:**
-- **Wave mode (default):** Sequential waves of parallel `Task()` spawns. Standard for most phases.
-- **Team mode (`--team` flag, `team_execution: true` or `"auto"` in config):** Creates a team with domain-specialized executor agents that coordinate via shared task list. Better for large phases with domain-split plans. When `team_execution: "auto"`, team mode activates for phases with 3+ plans across 2+ non-general domains.
-
-Context budget: ~15% orchestrator, 100% fresh per subagent.
+Context budget: ~10-15% orchestrator, 100% fresh per subagent.
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/execute-phase.md
-@~/.claude/ariadna/references/ui-brand.md
-</execution_context>
-
 <context>
 Phase: $ARGUMENTS
 
-**Flags:**
-- `--gaps-only` — Execute only gap closure plans (plans with `gap_closure: true` in frontmatter). Use after verify-work creates fix plans.
-- `--team` — Use team-based execution with domain-specialized agents instead of wave-based execution.
-- `--no-team` — Force wave-based execution even when auto-detection would choose team mode.
+- `--gaps-only` — Execute only gap closure plans (`gap_closure: true` in frontmatter). Use after verify-work creates fix plans.
 
-@.ariadna_planning/ROADMAP.md
-@.ariadna_planning/STATE.md
+Follow the workflow in `~/.claude/ariadna/workflows/execute-phase.md` end-to-end.
 </context>
 
 <process>
-Execute the execute-phase workflow from @~/.claude/ariadna/workflows/execute-phase.md end-to-end.
-Preserve all workflow gates (wave/team execution, checkpoint handling, verification, state updates, routing).
-
-**Mode selection:** Follow the `decide_execution_mode` step in the workflow to determine team vs wave execution based on flags, config, and plan analysis.
+1. Run `ariadna-tools init execute-phase "$PHASE_ARG"` to load phase context as JSON.
+2. Read `.ariadna_planning/STATE.md` for current project position.
+3. Group plans by wave; skip plans where `has_summary: true`.
+4. For each wave: spawn `ariadna-executor` per plan in parallel via Task tool.
+5. On completion: spawn `ariadna-verifier`, update STATE.md, commit.
+6. If gaps found: offer `/ariadna:plan-phase {N} --gaps`.
 </process>

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

@@ -7,27 +7,20 @@ allowed-tools:
   - Write
   - Bash
 ---
-
 <objective>
-Insert a decimal phase for urgent work discovered mid-milestone that must be completed between existing integer phases.
-
-Uses decimal numbering (72.1, 72.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions.
-
-Purpose: Handle urgent work discovered during execution without renumbering entire roadmap.
+Insert a decimal phase for urgent work discovered mid-milestone between existing integer phases. Uses decimal numbering (72.1, 72.2, etc.) to preserve logical sequence without renumbering the entire roadmap.
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/insert-phase.md
-</execution_context>
-
 <context>
 Arguments: $ARGUMENTS (format: <after-phase-number> <description>)
 
-@.ariadna_planning/ROADMAP.md
-@.ariadna_planning/STATE.md
+Follow the workflow in `~/.claude/ariadna/workflows/insert-phase.md` end-to-end.
 </context>
 
 <process>
-Execute the insert-phase workflow from @~/.claude/ariadna/workflows/insert-phase.md end-to-end.
-Preserve all validation gates (argument parsing, phase verification, decimal calculation, roadmap updates).
+1. Parse $ARGUMENTS: first token = integer phase to insert after, rest = description. Error if missing.
+2. Run `ariadna-tools init phase-op "$AFTER"` — check `roadmap_exists`.
+3. Run `ariadna-tools phase insert "$AFTER" "$DESCRIPTION"` — calculates decimal number, creates directory, updates ROADMAP.md with (INSERTED) marker.
+4. Update STATE.md "Roadmap Evolution" section with urgent insertion note.
+5. Display decimal phase number, directory, and next step: `/ariadna:plan-phase {N.M}`.
 </process>

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

@@ -10,62 +10,29 @@ allowed-tools:
   - Write
   - Task
 ---
-
 <objective>
-Analyze existing codebase using parallel ariadna-codebase-mapper agents to produce structured codebase documents.
-
-Each mapper agent explores a focus area and **writes documents directly** to `.ariadna_planning/codebase/`. The orchestrator only receives confirmations, keeping context usage minimal.
+Analyze existing codebase using 4 parallel `ariadna-codebase-mapper` agents to produce structured documents in `.ariadna_planning/codebase/`. Each agent writes directly; orchestrator receives only confirmations.
 
-Output: .ariadna_planning/codebase/ folder with 7 structured documents about the codebase state.
+**Output:** 7 documents — STACK.md, INTEGRATIONS.md, ARCHITECTURE.md, STRUCTURE.md, CONVENTIONS.md, TESTING.md, CONCERNS.md
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/map-codebase.md
-</execution_context>
-
 <context>
-Focus area: $ARGUMENTS (optional - if provided, tells agents to focus on specific subsystem)
-
-**Load project state if exists:**
-Check for .ariadna_planning/STATE.md - loads context if project already initialized
+Focus area: $ARGUMENTS (optional — directs agents to focus on a specific subsystem)
 
-**This command can run:**
-- Before /ariadna:new-project (brownfield codebases) - creates codebase map first
-- After /ariadna:new-project (greenfield codebases) - updates codebase map as code evolves
-- Anytime to refresh codebase understanding
+Follow the workflow in `~/.claude/ariadna/workflows/map-codebase.md` end-to-end.
 </context>
 
-<when_to_use>
-**Use map-codebase for:**
-- Brownfield projects before initialization (understand existing code first)
-- Refreshing codebase map after significant changes
-- Onboarding to an unfamiliar codebase
-- Before major refactoring (understand current state)
-- When STATE.md references outdated codebase info
-
-**Skip map-codebase for:**
-- Greenfield projects with no code yet (nothing to map)
-- Trivial codebases (<5 files)
-</when_to_use>
-
 <process>
-1. Check if .ariadna_planning/codebase/ already exists (offer to refresh or skip)
-2. Create .ariadna_planning/codebase/ directory structure
-3. Spawn 4 parallel ariadna-codebase-mapper agents:
-   - Agent 1: tech focus → writes STACK.md, INTEGRATIONS.md
-   - Agent 2: arch focus → writes ARCHITECTURE.md, STRUCTURE.md
-   - Agent 3: quality focus → writes CONVENTIONS.md, TESTING.md
-   - Agent 4: concerns focus → writes CONCERNS.md
-4. Wait for agents to complete, collect confirmations (NOT document contents)
-5. Verify all 7 documents exist with line counts
-6. Commit codebase map
-7. Offer next steps (typically: /ariadna:new-project or /ariadna:plan-phase)
+1. Run `ariadna-tools init map-codebase` to load context as JSON.
+2. If `.ariadna_planning/codebase/` exists: offer Refresh / Update / Skip.
+3. Create `.ariadna_planning/codebase/` directory.
+4. Spawn 4 parallel `ariadna-codebase-mapper` agents (run_in_background=true):
+   - Agent 1: tech → STACK.md, INTEGRATIONS.md
+   - Agent 2: arch → ARCHITECTURE.md, STRUCTURE.md
+   - Agent 3: quality → CONVENTIONS.md, TESTING.md
+   - Agent 4: concerns → CONCERNS.md
+5. Scan output files for accidentally leaked secrets before committing.
+6. Verify all 7 documents exist with `wc -l`; note any failures.
+7. Commit: `ariadna-tools commit "docs: map existing codebase" --files .ariadna_planning/codebase/*.md`
+8. Display line counts and next step: `/ariadna:new-project`.
 </process>
-
-<success_criteria>
-- [ ] .ariadna_planning/codebase/ directory created
-- [ ] All 7 codebase documents written by mapper agents
-- [ ] Documents follow template structure
-- [ ] Parallel agents completed without errors
-- [ ] User knows next steps
-</success_criteria>

data/data/commands/ariadna/new-milestone.md

@@ -14,38 +14,25 @@ Start a new milestone: questioning → research (optional) → requirements →
 
 Brownfield equivalent of new-project. Project exists, PROJECT.md has history. Gathers "what's next", updates PROJECT.md, then runs requirements → roadmap cycle.
 
-**Creates/Updates:**
-- `.ariadna_planning/PROJECT.md` — updated with new milestone goals
-- `.ariadna_planning/research/` — domain research (optional, NEW features only)
-- `.ariadna_planning/REQUIREMENTS.md` — scoped requirements for this milestone
-- `.ariadna_planning/ROADMAP.md` — phase structure (continues numbering)
-- `.ariadna_planning/STATE.md` — reset for new milestone
+**Creates/Updates:** `PROJECT.md`, `REQUIREMENTS.md`, `ROADMAP.md`, `STATE.md`
 
 **After:** `/ariadna:plan-phase [N]` to start execution.
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/new-milestone.md
-@~/.claude/ariadna/references/questioning.md
-@~/.claude/ariadna/references/ui-brand.md
-@~/.claude/ariadna/templates/project.md
-@~/.claude/ariadna/templates/requirements.md
-</execution_context>
-
 <context>
-Milestone name: $ARGUMENTS (optional - will prompt if not provided)
-
-**Load project context:**
-@.ariadna_planning/PROJECT.md
-@.ariadna_planning/STATE.md
-@.ariadna_planning/MILESTONES.md
-@.ariadna_planning/config.json
+Milestone name: $ARGUMENTS (optional — will prompt if not provided)
 
-**Load milestone context (if exists, from /ariadna:discuss-milestone):**
-@.ariadna_planning/MILESTONE-CONTEXT.md
+Follow the workflow in `~/.claude/ariadna/workflows/new-milestone.md` end-to-end.
 </context>
 
 <process>
-Execute the new-milestone workflow from @~/.claude/ariadna/workflows/new-milestone.md end-to-end.
-Preserve all workflow gates (validation, questioning, research, requirements, roadmap approval, commits).
+1. Run `ariadna-tools init new-milestone` to load context as JSON.
+2. Load PROJECT.md, STATE.md, MILESTONES.md; check for MILESTONE-CONTEXT.md.
+3. Gather milestone goals through conversation (or use existing MILESTONE-CONTEXT.md).
+4. Determine milestone version; update PROJECT.md and STATE.md; commit.
+5. Ask about research; optionally spawn 4 parallel researchers + synthesizer.
+6. Define requirements by category; write REQUIREMENTS.md; commit.
+7. Spawn `ariadna-roadmapper` with continuing phase numbering.
+8. Present roadmap for approval; commit on approval.
+9. Display next step: `/ariadna:plan-phase [N]`.
 </process>

data/data/commands/ariadna/new-project.md

@@ -4,41 +4,37 @@ description: Initialize a new project with deep context gathering and PROJECT.md
 argument-hint: "[--auto] [--research]"
 allowed-tools:
   - Read
-  - Bash
   - Write
+  - Bash
   - Task
   - AskUserQuestion
 ---
-<context>
-**Flags:**
-- `--auto` — Automatic mode. Skips config questions, runs requirements → roadmap without further interaction. Expects idea document via @ reference.
-- `--research` — Force domain research (4 parallel researchers + synthesizer). By default, research is skipped and Rails conventions are pre-loaded.
-</context>
-
 <objective>
-Initialize a new project through streamlined flow: questioning → requirements → roadmap. Research skipped by default (Rails conventions pre-loaded); use --research for non-standard domains.
+Initialize a new project through streamlined flow: questioning → requirements → roadmap. Research skipped by default (Rails conventions pre-loaded); use `--research` for non-standard domains.
 
-**Creates:**
-- `.ariadna_planning/PROJECT.md` — project context
-- `.ariadna_planning/config.json` — workflow preferences (opinionated defaults)
-- `.ariadna_planning/research/` — domain research (only with --research flag)
-- `.ariadna_planning/REQUIREMENTS.md` — scoped requirements
-- `.ariadna_planning/ROADMAP.md` — phase structure
-- `.ariadna_planning/STATE.md` — project memory
+**Flags:**
+- `--auto` — Automatic mode. Skips questions, runs requirements → roadmap without interaction. Requires idea document via @ reference.
+- `--research` — Force parallel domain research before requirements.
+
+**Creates:** `.ariadna_planning/PROJECT.md`, `config.json`, `REQUIREMENTS.md`, `ROADMAP.md`, `STATE.md`
 
-**After this command:** Run `/ariadna:plan-phase 1` to start planning.
+**After this command:** `/ariadna:plan-phase 1`
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/new-project.md
-@~/.claude/ariadna/references/questioning.md
-@~/.claude/ariadna/references/ui-brand.md
-@~/.claude/ariadna/references/rails-conventions.md
-@~/.claude/ariadna/templates/project.md
-@~/.claude/ariadna/templates/requirements.md
-</execution_context>
+<context>
+Arguments: $ARGUMENTS
+
+Follow the workflow in `~/.claude/ariadna/workflows/new-project.md` end-to-end.
+</context>
 
 <process>
-Execute the new-project workflow from @~/.claude/ariadna/workflows/new-project.md end-to-end.
-Preserve all workflow gates (validation, approvals, commits, routing).
+1. Run `ariadna-tools init new-project` to load context as JSON.
+2. Offer codebase mapping if existing code detected but no map present.
+3. Gather project context through deep questioning (or extract from `--auto` document).
+4. Write PROJECT.md, config.json; commit each atomically.
+5. Optionally spawn research agents (4 parallel + synthesizer) if `--research` flag.
+6. Define requirements by category (table stakes / differentiators / out of scope).
+7. Spawn `ariadna-roadmapper` to create ROADMAP.md and STATE.md.
+8. Present roadmap for approval; loop on revisions until approved.
+9. Commit all artifacts; display next step: `/ariadna:plan-phase 1`.
 </process>

data/data/commands/ariadna/plan-phase.md

@@ -1,11 +1,11 @@
 ---
 name: ariadna:plan-phase
 description: Create detailed execution plan for a phase (PLAN.md) with verification loop
-argument-hint: "[phase] [--research] [--skip-research] [--gaps] [--skip-verify] [--skip-context]"
-agent: ariadna-planner
+argument-hint: "[phase] [--research] [--gaps] [--skip-verify]"
 allowed-tools:
   - Read
   - Write
+  - Edit
   - Bash
   - Glob
   - Grep
@@ -14,33 +14,24 @@ allowed-tools:
   - mcp__context7__*
 ---
 <objective>
-Create executable phase prompts (PLAN.md files) for a roadmap phase. Research skipped by default (Rails conventions pre-loaded). Includes optional inline context gathering (replaces separate discuss-phase step).
+Produce PLAN.md files that `execute-phase` can run directly. Plans must have valid frontmatter (wave, domain, depends_on, files_modified) with tasks specific enough for autonomous execution.
 
-**Default flow:** Context (inline if needed) → Plan → Verify → Done
-
-**Orchestrator role:** Parse arguments, validate phase, offer inline context gathering, spawn ariadna-planner (with Rails conventions), verify with ariadna-plan-checker (single pass, inline fixes for minor issues), present results.
+Spawn `ariadna-planner` for planning and self-checking. Minor issues fixed inline; major issues presented to user.
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/plan-phase.md
-@~/.claude/ariadna/references/ui-brand.md
-@~/.claude/ariadna/references/rails-conventions.md
-</execution_context>
-
 <context>
-Phase number: $ARGUMENTS (optional — auto-detects next unplanned phase if omitted)
+Phase: $ARGUMENTS (optional — auto-detects next unplanned phase if omitted)
 
-**Flags:**
-- `--research` — Force research even if not enabled in config (for non-standard integrations)
-- `--skip-research` — Skip research, go straight to planning (default behavior)
-- `--gaps` — Gap closure mode (reads VERIFICATION.md, skips research)
-- `--skip-verify` — Skip plan verification
-- `--skip-context` — Skip inline context gathering, plan directly
+- `--research` — Force research for non-standard integrations
+- `--gaps` — Gap closure mode: reads VERIFICATION.md, creates `gap_closure: true` plans only
+- `--skip-verify` — Skip plan self-check pass
 
-Normalize phase input in step 2 before any directory lookups.
+Follow the workflow in `~/.claude/ariadna/workflows/plan-phase.md` end-to-end.
 </context>
 
 <process>
-Execute the plan-phase workflow from @~/.claude/ariadna/workflows/plan-phase.md end-to-end.
-Preserve all workflow gates (validation, research, planning, verification loop, routing).
+1. Run `ariadna-tools init plan-phase "$PHASE_ARG" --include state,roadmap,requirements,context,research,verification`.
+2. Spawn `ariadna-planner` with rails-conventions reference; planner handles research and self-check inline.
+3. Fix minor issues (wrong wave, missing tags, frontmatter typos) with Edit tool — no re-spawn.
+4. Update `memory/progress.md`; display next step: `/ariadna:execute-phase {N}` with `/clear` reminder.
 </process>

data/data/commands/ariadna/progress.md

@@ -9,16 +9,26 @@ allowed-tools:
   - SlashCommand
 ---
 <objective>
-Check project progress, summarize recent work and what's ahead, then intelligently route to the next action - either executing an existing plan or creating the next one.
+Check project progress, summarize recent work and what's ahead, then intelligently route to the next action — either executing an existing plan or creating the next one.
 
 Provides situational awareness before continuing work.
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/progress.md
-</execution_context>
+<context>
+Follow the workflow in `~/.claude/ariadna/workflows/progress.md` end-to-end.
+</context>
 
 <process>
-Execute the progress workflow from @~/.claude/ariadna/workflows/progress.md end-to-end.
-Preserve all routing logic (Routes A through F) and edge case handling.
+1. Run `ariadna-tools init progress --include state,roadmap,project,config` to load context as JSON.
+2. Run `ariadna-tools roadmap analyze` for structured phase/plan status.
+3. Find 2-3 recent SUMMARY.md files; extract one-liners with `ariadna-tools summary-extract`.
+4. Generate progress bar: `ariadna-tools progress bar --raw`.
+5. Present rich status report: recent work, current position, decisions, blockers, pending todos.
+6. Route to next action based on verified plan/summary counts:
+   - UAT gaps present → `/ariadna:plan-phase {N} --gaps`
+   - Unexecuted plans → `/ariadna:execute-phase {N}`
+   - Phase needs planning → `/ariadna:plan-phase {N}`
+   - Phase complete, more remain → `/ariadna:discuss-phase {N+1}`
+   - Milestone complete → `/ariadna:complete-milestone`
+   - Between milestones → `/ariadna:new-milestone`
 </process>

data/data/commands/ariadna/quick.md

@@ -1,7 +1,6 @@
 ---
 name: ariadna:quick
 description: Execute a quick task with Ariadna guarantees (atomic commits, state tracking) but skip optional agents
-argument-hint: ""
 allowed-tools:
   - Read
   - Write
@@ -15,24 +14,23 @@ allowed-tools:
 <objective>
 Execute small, ad-hoc tasks with Ariadna guarantees (atomic commits, STATE.md tracking) while skipping optional agents (research, plan-checker, verifier).
 
-Quick mode is the same system with a shorter path:
-- Spawns ariadna-planner (quick mode) + ariadna-executor(s)
-- Skips ariadna-phase-researcher, ariadna-plan-checker, ariadna-verifier
+- Spawns `ariadna-planner` (quick mode) + `ariadna-executor`
 - Quick tasks live in `.ariadna_planning/quick/` separate from planned phases
 - Updates STATE.md "Quick Tasks Completed" table (NOT ROADMAP.md)
 
 Use when: You know exactly what to do and the task is small enough to not need research or verification.
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/quick.md
-</execution_context>
-
 <context>
-@.ariadna_planning/STATE.md
+Follow the workflow in `~/.claude/ariadna/workflows/quick.md` end-to-end.
 </context>
 
 <process>
-Execute the quick workflow from @~/.claude/ariadna/workflows/quick.md end-to-end.
-Preserve all workflow gates (validation, task description, planning, execution, state updates, commits).
+1. Prompt user for task description via AskUserQuestion.
+2. Run `ariadna-tools init quick "$DESCRIPTION"` — validates ROADMAP.md exists; returns slug, next_num, paths.
+3. Create `.ariadna_planning/quick/{NNN}-{slug}/` directory.
+4. Spawn `ariadna-planner` (quick mode) → produces single PLAN.md with 1-3 focused tasks.
+5. Spawn `ariadna-executor` → executes plan, commits atomically, writes SUMMARY.md.
+6. Update STATE.md "Quick Tasks Completed" table with row + last activity.
+7. Commit STATE.md + plan + summary; display completion with commit hash.
 </process>

data/data/commands/ariadna/remove-phase.md

@@ -9,24 +9,21 @@ allowed-tools:
   - Glob
 ---
 <objective>
-Remove an unstarted future phase from the roadmap and renumber all subsequent phases to maintain a clean, linear sequence.
-
-Purpose: Clean removal of work you've decided not to do, without polluting context with cancelled/deferred markers.
-Output: Phase deleted, all subsequent phases renumbered, git commit as historical record.
+Remove an unstarted future phase from the roadmap and renumber all subsequent phases to maintain a clean linear sequence. Git commit serves as the historical record.
 </objective>
 
-<execution_context>
-@~/.claude/ariadna/workflows/remove-phase.md
-</execution_context>
-
 <context>
 Phase: $ARGUMENTS
 
-@.ariadna_planning/ROADMAP.md
-@.ariadna_planning/STATE.md
+Follow the workflow in `~/.claude/ariadna/workflows/remove-phase.md` end-to-end.
 </context>
 
 <process>
-Execute the remove-phase workflow from @~/.claude/ariadna/workflows/remove-phase.md end-to-end.
-Preserve all validation gates (future phase check, work check), renumbering logic, and commit.
+1. Validate $ARGUMENTS provided; error with usage if missing.
+2. Run `ariadna-tools init phase-op "$ARGUMENTS"` to load context; check `roadmap_exists`.
+3. Verify target is a future (unstarted) phase vs current phase in STATE.md; error if not.
+4. Present removal summary (what will be deleted/renumbered); confirm with user.
+5. Run `ariadna-tools phase remove "$ARGUMENTS"` — deletes directory, renumbers subsequent phases, updates ROADMAP.md and STATE.md. Use `--force` only if user confirms for phases with summaries.
+6. Commit: `ariadna-tools commit "chore: remove phase $ARGUMENTS ({name})" --files .ariadna_planning/`
+7. Display changes made and offer `/ariadna:progress` to review updated roadmap.
 </process>