ariadna 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a59ce08ab4d7f1165dd59dac034ac04e5725263a3022bebbd2c3c39fdb0a3c23
-  data.tar.gz: 2eb175ba24a25c5114e3b76f83bbfef0275a21dc114f00d7376390508cb54a87
+  metadata.gz: d45bf8e96c2f2d1d07d2c3236cfaa5e3f6c6fa43cf5f4b785be66fc5160c9ee6
+  data.tar.gz: 69364ceaebbf8755a887e9a994dee5e6490d5144a9f681447d9a0946c3c1f095
 SHA512:
-  metadata.gz: 11f2127685615ea902f97bfc9fc813e20e74f354b055672568d39552d3d551d31896ba73b5ad3434d1ac84dc6d593f8d385818e78fc7cae24844f45720558f80
-  data.tar.gz: cec523e574d6182711229ddf5fa7519929f3c9fb9a144a0eb4928cf46a24d4761e9f718cf3678cf2dde812f9cd655647ca2c12776fcf29aa526831ad9df017a9
+  metadata.gz: 175abad4e06b132ae2f3489fbf7e7db92a0aaa2758d42fc8bb374b2b6151d891cf963a9e592757fd7e872443da3a46c871f8f66ad83ca48c6299a42a4782cb93
+  data.tar.gz: 0c011641fa6e541200d0e0bcbb1c83066ede0c65296c285a0e7d51970b4e626fb916c4798f7e59618bab07b867bcfc997efdd898677c917ce1e56e40b05a9f4c

data/data/agents/ariadna-backend-executor.md

@@ -236,7 +236,10 @@ When spawned as part of a team (via `TeamCreate`/`Task` with `team_name`), follo
 1. **Check for assigned tasks:** `TaskList` → find tasks owned by you with status `pending`
 2. **Claim a task:** `TaskUpdate(taskId=..., status="in_progress")` — prefer lowest ID first
 3. **Read the plan:** Extract the plan file path from the task description, read it with the Read tool
-4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → state_updates)
+4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → self_check)
+4b. **Skip STATE.md updates in team mode.** The orchestrator aggregates state.
+    Only create SUMMARY.md and commit plan files.
+    Do NOT call `ariadna-tools state advance-plan` or `ariadna-tools state record-metric`.
 5. **Mark task complete:** `TaskUpdate(taskId=..., status="completed")`
 6. **Check for more work:** `TaskList` → find next unblocked, unowned task matching your domain. If available, claim and execute it.
 7. **When no tasks remain:** `SendMessage(type="message", recipient="team-lead", content="All backend tasks complete. No remaining tasks.")` then go idle.

data/data/agents/ariadna-executor.md

@@ -397,7 +397,10 @@ When spawned as part of a team (via `TeamCreate`/`Task` with `team_name`), follo
 1. **Check for assigned tasks:** `TaskList` → find tasks owned by you with status `pending`
 2. **Claim a task:** `TaskUpdate(taskId=..., status="in_progress")` — prefer lowest ID first
 3. **Read the plan:** Extract the plan file path from the task description, read it with the Read tool
-4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → state_updates)
+4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → self_check)
+4b. **Skip STATE.md updates in team mode.** The orchestrator aggregates state.
+    Only create SUMMARY.md and commit plan files.
+    Do NOT call `ariadna-tools state advance-plan` or `ariadna-tools state record-metric`.
 5. **Mark task complete:** `TaskUpdate(taskId=..., status="completed")`
 6. **Check for more work:** `TaskList` → find next unblocked, unowned task. If available, claim and execute it.
 7. **When no tasks remain:** `SendMessage(type="message", recipient="team-lead", content="All assigned tasks complete. No remaining tasks.")` then go idle.

data/data/agents/ariadna-frontend-executor.md

@@ -234,7 +234,10 @@ When spawned as part of a team (via `TeamCreate`/`Task` with `team_name`), follo
 1. **Check for assigned tasks:** `TaskList` → find tasks owned by you with status `pending`
 2. **Claim a task:** `TaskUpdate(taskId=..., status="in_progress")` — prefer lowest ID first
 3. **Read the plan:** Extract the plan file path from the task description, read it with the Read tool
-4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → state_updates)
+4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → self_check)
+4b. **Skip STATE.md updates in team mode.** The orchestrator aggregates state.
+    Only create SUMMARY.md and commit plan files.
+    Do NOT call `ariadna-tools state advance-plan` or `ariadna-tools state record-metric`.
 5. **Mark task complete:** `TaskUpdate(taskId=..., status="completed")`
 6. **Check for more work:** `TaskList` → find next unblocked, unowned task matching your domain. If available, claim and execute it.
 7. **When no tasks remain:** `SendMessage(type="message", recipient="team-lead", content="All frontend tasks complete. No remaining tasks.")` then go idle.

data/data/agents/ariadna-test-executor.md

@@ -240,7 +240,10 @@ When spawned as part of a team (via `TeamCreate`/`Task` with `team_name`), follo
 1. **Check for assigned tasks:** `TaskList` → find tasks owned by you with status `pending`
 2. **Claim a task:** `TaskUpdate(taskId=..., status="in_progress")` — prefer lowest ID first
 3. **Read the plan:** Extract the plan file path from the task description, read it with the Read tool
-4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → state_updates)
+4. **Execute the plan:** Follow the standard execution flow (load_plan → execute_tasks → summary → self_check)
+4b. **Skip STATE.md updates in team mode.** The orchestrator aggregates state.
+    Only create SUMMARY.md and commit plan files.
+    Do NOT call `ariadna-tools state advance-plan` or `ariadna-tools state record-metric`.
 5. **Mark task complete:** `TaskUpdate(taskId=..., status="completed")`
 6. **Check for more work:** `TaskList` → find next unblocked, unowned task matching your domain. If available, claim and execute it.
 7. **When no tasks remain:** `SendMessage(type="message", recipient="team-lead", content="All testing tasks complete. No remaining tasks.")` then go idle.

data/data/ariadna/references/rails-conventions.md

@@ -216,6 +216,7 @@ class UserTest < ActiveSupport::TestCase
 
   test "validates email presence" do
     user = User.new(name: "Test")
+
     assert_not user.valid?
     assert_includes user.errors[:email], "can't be blank"
   end
@@ -238,6 +239,7 @@ class PostsControllerTest < ActionDispatch::IntegrationTest
 
   test "index returns posts" do
     get posts_url
+
     assert_response :success
     assert_select "h2", posts(:first).title
   end
@@ -341,11 +343,16 @@ Tasks:
 ### Add Turbo/Hotwire Feature
 ```
 Tasks:
-1. Add Turbo Frame wrapping + controller turbo_stream response
+1. Add Turbo Frame wrapping to target views + controller turbo_stream responses
    Files: app/views/[model]/*.html.erb, app/controllers/[model]_controller.rb
+   Conventions: 422 for validation errors, 303 for redirects, dom_id for frame IDs
 2. Add Stimulus controller (if interactive behavior needed)
    Files: app/javascript/controllers/[name]_controller.js
-3. Add system test for real-time behavior
+   Conventions: static values/targets/outlets first, connect/disconnect symmetry
+3. Add Turbo Stream broadcasts (if real-time updates needed)
+   Files: app/models/[model].rb (after_create_commit callbacks)
+   Conventions: prefer default stream actions, broadcast_append_to/replace_to
+4. Add system test for Turbo/Stimulus behavior
    Files: test/system/[feature]_test.rb
 ```
 

data/data/ariadna/templates/summary.md

@@ -38,6 +38,11 @@ patterns-established:
   - "Pattern 1: description"
   - "Pattern 2: description"
 
+requirements_covered:
+  - id: "REQ-ID"
+    description: "Requirement description"
+    evidence: "File/class implementing it"
+
 # Metrics
 duration: Xmin
 completed: YYYY-MM-DD
@@ -60,6 +65,12 @@ completed: YYYY-MM-DD
 - [Second key accomplishment]
 - [Third if applicable]
 
+## Requirements Covered
+| REQ-ID | Requirement | Evidence |
+|--------|-------------|----------|
+
+[Omit this section if no REQUIREMENTS.md exists or no requirements map to this phase/plan]
+
 ## Task Commits
 
 Each task was committed atomically:

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

@@ -19,7 +19,7 @@ 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.
@@ -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`.
 
@@ -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,6 +439,33 @@ 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).
 

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

@@ -321,7 +321,18 @@ If user_setup exists: create `{phase}-USER-SETUP.md` using template `~/.claude/a
 <step name="create_summary">
 Create `{phase}-{plan}-SUMMARY.md` at `.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 `.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`
 

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

@@ -27,7 +27,7 @@ Parse JSON for: `researcher_model`, `planner_model`, `checker_model`, `research_
 
 ## 2. Parse and Normalize Arguments
 
-Extract from $ARGUMENTS: phase number (integer or decimal like `2.1`), flags (`--research`, `--skip-research`, `--gaps`, `--skip-verify`, `--skip-context`).
+Extract from $ARGUMENTS: phase number (integer or decimal like `2.1`), flags (`--research`, `--skip-research`, `--gaps`, `--skip-verify`, `--skip-context`, `--skip-approval`).
 
 **If no phase number:** Detect next unplanned phase from roadmap.
 
@@ -56,32 +56,30 @@ Use `context_content` from init JSON (already loaded via `--include context`).
 
 Analyze the phase goal from `roadmap_content` and determine if there are implementation decisions the user should weigh in on.
 
-**Quick assessment — does this phase need context?**
+**Categorize the phase — determines context behavior:**
 
-- Pure infrastructure / setup / configuration → No context needed, skip
-- Standard CRUD (models, controllers, views) → No context needed, skip
-- User-facing features with UI/UX decisions → Context helpful
-- Features with multiple valid approaches → Context helpful
+- **Category A** (infrastructure, setup, config, standard CRUD, testing, migrations, background jobs) → Skip context entirely. Display: `Context: Skipped (infrastructure/standard phase)`. Continue to step 5.
+- **Category B** (user-facing features, UI/UX decisions, user workflows, multiple valid approaches) → Show context question below.
 
-**If context would be helpful:** Offer inline clarification with a single AskUserQuestion:
+**Category B only — offer inline clarification.** Identify 2-3 specific gray areas from the phase goal (e.g., "unclear: how should password reset flow work?" or "multiple options: modal vs. inline form for editing"). Include them in the question text:
 
 ```
 questions: [
   {
     header: "Context",
-    question: "Phase {X}: {Name} has some implementation choices. Want to discuss them before planning?",
+    question: "Phase {X}: {Name} has gray areas:\n- {gray_area_1}\n- {gray_area_2}\n- {gray_area_3}\nWant to clarify before planning?",
     multiSelect: false,
     options: [
-      { label: "Plan directly (Recommended)", description: "Planner will make reasonable choices, you review the plan" },
-      { label: "Quick discussion", description: "Clarify 2-3 key decisions inline" },
+      { label: "Quick discussion (Recommended)", description: "Clarify these decisions inline — prevents plan mismatches" },
+      { label: "Plan directly", description: "Planner will make reasonable choices, you review the plan" },
       { label: "Full discussion", description: "Run /ariadna:discuss-phase for detailed context gathering" }
     ]
   }
 ]
 ```
 
-- **"Plan directly":** Continue to step 5. Planner will use its judgment for ambiguous areas.
 - **"Quick discussion":** Identify 2-3 key gray areas and ask focused AskUserQuestion for each. Write a lightweight CONTEXT.md to the phase directory. Then continue to step 5.
+- **"Plan directly":** Continue to step 5. Planner will use its judgment for ambiguous areas.
 - **"Full discussion":** Exit and tell user to run `/ariadna:discuss-phase {X}` first, then return.
 
 **CRITICAL:** Use `context_content` from INIT — pass to planner and checker agents.
@@ -251,7 +249,7 @@ Task(
 
 ## 9. Handle Planner Return
 
-- **`## PLANNING COMPLETE`:** Display plan count. If `--skip-verify` or `plan_checker_enabled` is false (from init): skip to step 13. Otherwise: step 10.
+- **`## PLANNING COMPLETE`:** Display plan count. If `--skip-verify` or `plan_checker_enabled` is false (from init): skip to step 13 (approval gate). Otherwise: step 10.
 - **`## CHECKPOINT REACHED`:** Present to user, get response, spawn continuation (step 12)
 - **`## PLANNING INCONCLUSIVE`:** Show attempts, offer: Add context / Retry / Manual
 
@@ -306,7 +304,7 @@ Task(
 
 ## 11. Handle Checker Return
 
-- **`## VERIFICATION PASSED`:** Display confirmation, proceed to step 13.
+- **`## VERIFICATION PASSED`:** Display confirmation, proceed to step 13 (approval gate).
 - **`## ISSUES FOUND`:** Classify issues and proceed to step 12.
 
 ## 12. Handle Checker Issues (Inline Fix, No Revision Loop)
@@ -351,7 +349,7 @@ questions: [
 ]
 ```
 
-- **"Accept as-is":** Proceed to step 13.
+- **"Accept as-is":** Proceed to step 13 (approval gate).
 - **"Re-plan":** Spawn planner in revision mode (single attempt, not a loop):
 
 ```
@@ -363,11 +361,36 @@ Task(
 )
 ```
 
-After planner returns, proceed to step 13 (no re-check loop).
+After planner returns, proceed to step 13 (approval gate, no re-check loop).
 
 - **"Fix manually":** Display file paths and exit.
 
-## 13. Present Final Status
+## 13. User Plan Approval Gate
+
+**Skip if:** `--skip-approval` flag, `--gaps` mode (gap closures already user-directed), or `requirements_content` is null (no REQUIREMENTS.md).
+
+**Otherwise:** Cross-reference each requirement mapped to this phase (from `requirements_content`) against the plans' `must_haves.truths` (from plan frontmatter). Present a single `AskUserQuestion`:
+
+```
+questions: [
+  {
+    header: "Plan Review",
+    question: "Phase {X}: {Name} — {N} plan(s) covering these requirements:\n\n| REQ-ID | Requirement | Covered By |\n|--------|-------------|------------|\n| {id} | {description} | Plan {plan_number}: {what_it_builds} |\n| {id} | {description} | ⚠ Not covered |\n\nApprove plans for execution?",
+    multiSelect: false,
+    options: [
+      { label: "Approve", description: "Plans look good, proceed to execution" },
+      { label: "Review details", description: "Show full plan files before deciding" },
+      { label: "Adjust", description: "Give feedback for a single re-plan attempt" }
+    ]
+  }
+]
+```
+
+- **"Approve":** Proceed to step 14.
+- **"Review details":** Display full content of each PLAN.md file in the phase directory. Then re-ask the same question (Approve / Adjust only).
+- **"Adjust":** Ask user for feedback with a follow-up AskUserQuestion (freeform). Spawn planner in revision mode with user feedback (single attempt, no loop). Then proceed to step 14.
+
+## 14. Present Final Status
 
 Route to `<offer_next>`.
 
@@ -422,6 +445,7 @@ Verification: {Passed | Passed with fixes | Skipped}
 - [ ] ariadna-plan-checker spawned (unless --skip-verify)
 - [ ] Minor checker issues fixed inline by orchestrator (no revision loop)
 - [ ] Major checker issues presented to user for decision
+- [ ] User approved plans (or --skip-approval / --gaps flag used / no REQUIREMENTS.md)
 - [ ] User sees status between agent spawns
 - [ ] User knows next steps
 </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]"
+argument-hint: "<phase-number> [--gaps-only] [--team] [--no-team]"
 allowed-tools:
   - Read
   - Write
@@ -26,7 +26,7 @@ Orchestrator stays lean: discover plans, analyze dependencies, group into waves,
 
 **Execution modes:**
 - **Wave mode (default):** Sequential waves of parallel `Task()` spawns. Standard for most phases.
-- **Team mode (`--team` flag or `team_execution: true` in config):** Creates a team with domain-specialized executor agents that coordinate via shared task list. Better for large phases with domain-split plans.
+- **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.
 </objective>
@@ -42,6 +42,7 @@ 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.
 
 @.planning/ROADMAP.md
 @.planning/STATE.md
@@ -51,5 +52,5 @@ Phase: $ARGUMENTS
 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:** If `--team` flag is present or `team_execution: true` in config, use the `team_execution` step. Otherwise use the standard `execute_waves` step.
+**Mode selection:** Follow the `decide_execution_mode` step in the workflow to determine team vs wave execution based on flags, config, and plan analysis.
 </process>