ariadna 1.3.0 → 2.0.0

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

@@ -1,178 +0,0 @@
-<purpose>
-Surface Claude's assumptions about a phase before planning, enabling users to correct misconceptions early.
-
-Key difference from discuss-phase: This is ANALYSIS of what Claude thinks, not INTAKE of what user knows. No file output - purely conversational to prompt discussion.
-</purpose>
-
-<process>
-
-<step name="validate_phase" priority="first">
-Phase number: $ARGUMENTS (required)
-
-**If argument missing:**
-
-```
-Error: Phase number required.
-
-Usage: /ariadna:list-phase-assumptions [phase-number]
-Example: /ariadna:list-phase-assumptions 3
-```
-
-Exit workflow.
-
-**If argument provided:**
-Validate phase exists in roadmap:
-
-```bash
-cat .ariadna_planning/ROADMAP.md | grep -i "Phase ${PHASE}"
-```
-
-**If phase not found:**
-
-```
-Error: Phase ${PHASE} not found in roadmap.
-
-Available phases:
-[list phases from roadmap]
-```
-
-Exit workflow.
-
-**If phase found:**
-Parse phase details from roadmap:
-
-- Phase number
-- Phase name
-- Phase description/goal
-- Any scope details mentioned
-
-Continue to analyze_phase.
-</step>
-
-<step name="analyze_phase">
-Based on roadmap description and project context, identify assumptions across five areas:
-
-**1. Technical Approach:**
-What libraries, frameworks, patterns, or tools would Claude use?
-- "I'd use X library because..."
-- "I'd follow Y pattern because..."
-- "I'd structure this as Z because..."
-
-**2. Implementation Order:**
-What would Claude build first, second, third?
-- "I'd start with X because it's foundational"
-- "Then Y because it depends on X"
-- "Finally Z because..."
-
-**3. Scope Boundaries:**
-What's included vs excluded in Claude's interpretation?
-- "This phase includes: A, B, C"
-- "This phase does NOT include: D, E, F"
-- "Boundary ambiguities: G could go either way"
-
-**4. Risk Areas:**
-Where does Claude expect complexity or challenges?
-- "The tricky part is X because..."
-- "Potential issues: Y, Z"
-- "I'd watch out for..."
-
-**5. Dependencies:**
-What does Claude assume exists or needs to be in place?
-- "This assumes X from previous phases"
-- "External dependencies: Y, Z"
-- "This will be consumed by..."
-
-Be honest about uncertainty. Mark assumptions with confidence levels:
-- "Fairly confident: ..." (clear from roadmap)
-- "Assuming: ..." (reasonable inference)
-- "Unclear: ..." (could go multiple ways)
-</step>
-
-<step name="present_assumptions">
-Present assumptions in a clear, scannable format:
-
-```
-## My Assumptions for Phase ${PHASE}: ${PHASE_NAME}
-
-### Technical Approach
-[List assumptions about how to implement]
-
-### Implementation Order
-[List assumptions about sequencing]
-
-### Scope Boundaries
-**In scope:** [what's included]
-**Out of scope:** [what's excluded]
-**Ambiguous:** [what could go either way]
-
-### Risk Areas
-[List anticipated challenges]
-
-### Dependencies
-**From prior phases:** [what's needed]
-**External:** [third-party needs]
-**Feeds into:** [what future phases need from this]
-
----
-
-**What do you think?**
-
-Are these assumptions accurate? Let me know:
-- What I got right
-- What I got wrong
-- What I'm missing
-```
-
-Wait for user response.
-</step>
-
-<step name="gather_feedback">
-**If user provides corrections:**
-
-Acknowledge the corrections:
-
-```
-Key corrections:
-- [correction 1]
-- [correction 2]
-
-This changes my understanding significantly. [Summarize new understanding]
-```
-
-**If user confirms assumptions:**
-
-```
-Assumptions validated.
-```
-
-Continue to offer_next.
-</step>
-
-<step name="offer_next">
-Present next steps:
-
-```
-What's next?
-1. Discuss context (/ariadna:discuss-phase ${PHASE}) - Let me ask you questions to build comprehensive context
-2. Plan this phase (/ariadna:plan-phase ${PHASE}) - Create detailed execution plans
-3. Re-examine assumptions - I'll analyze again with your corrections
-4. Done for now
-```
-
-Wait for user selection.
-
-If "Discuss context": Note that CONTEXT.md will incorporate any corrections discussed here
-If "Plan this phase": Proceed knowing assumptions are understood
-If "Re-examine": Return to analyze_phase with updated understanding
-</step>
-
-</process>
-
-<success_criteria>
-- Phase number validated against roadmap
-- Assumptions surfaced across five areas: technical approach, implementation order, scope, risks, dependencies
-- Confidence levels marked where appropriate
-- "What do you think?" prompt presented
-- User feedback acknowledged
-- Clear next steps offered
-</success_criteria>

data/data/ariadna/workflows/pause-work.md

@@ -1,122 +0,0 @@
-<purpose>
-Create `.continue-here.md` handoff file to preserve complete work state across sessions. Enables seamless resumption with full context restoration.
-</purpose>
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-
-<process>
-
-<step name="detect">
-Find current phase directory from most recently modified files:
-
-```bash
-# Find most recent phase directory with work
-ls -lt .ariadna_planning/phases/*/PLAN.md 2>/dev/null | head -1 | grep -oP 'phases/\K[^/]+'
-```
-
-If no active phase detected, ask user which phase they're pausing work on.
-</step>
-
-<step name="gather">
-**Collect complete state for handoff:**
-
-1. **Current position**: Which phase, which plan, which task
-2. **Work completed**: What got done this session
-3. **Work remaining**: What's left in current plan/phase
-4. **Decisions made**: Key decisions and rationale
-5. **Blockers/issues**: Anything stuck
-6. **Mental context**: The approach, next steps, "vibe"
-7. **Files modified**: What's changed but not committed
-
-Ask user for clarifications if needed via conversational questions.
-</step>
-
-<step name="write">
-**Write handoff to `.ariadna_planning/phases/XX-name/.continue-here.md`:**
-
-```markdown
----
-phase: XX-name
-task: 3
-total_tasks: 7
-status: in_progress
-last_updated: [timestamp from current-timestamp]
----
-
-<current_state>
-[Where exactly are we? Immediate context]
-</current_state>
-
-<completed_work>
-
-- Task 1: [name] - Done
-- Task 2: [name] - Done
-- Task 3: [name] - In progress, [what's done]
-</completed_work>
-
-<remaining_work>
-
-- Task 3: [what's left]
-- Task 4: Not started
-- Task 5: Not started
-</remaining_work>
-
-<decisions_made>
-
-- Decided to use [X] because [reason]
-- Chose [approach] over [alternative] because [reason]
-</decisions_made>
-
-<blockers>
-- [Blocker 1]: [status/workaround]
-</blockers>
-
-<context>
-[Mental state, what were you thinking, the plan]
-</context>
-
-<next_action>
-Start with: [specific first action when resuming]
-</next_action>
-```
-
-Be specific enough for a fresh Claude to understand immediately.
-
-Use `current-timestamp` for last_updated field. You can use init todos (which provides timestamps) or call directly:
-```bash
-timestamp=$(ariadna-tools current-timestamp full --raw)
-```
-</step>
-
-<step name="commit">
-```bash
-ariadna-tools commit "wip: [phase-name] paused at task [X]/[Y]" --files .ariadna_planning/phases/*/.continue-here.md
-```
-</step>
-
-<step name="confirm">
-```
-✓ Handoff created: .ariadna_planning/phases/[XX-name]/.continue-here.md
-
-Current state:
-
-- Phase: [XX-name]
-- Task: [X] of [Y]
-- Status: [in_progress/blocked]
-- Committed as WIP
-
-To resume: /ariadna:resume-work
-
-```
-</step>
-
-</process>
-
-<success_criteria>
-- [ ] .continue-here.md created in correct phase directory
-- [ ] All sections filled with specific content
-- [ ] Committed as WIP
-- [ ] User knows location and how to resume
-</success_criteria>

data/data/ariadna/workflows/plan-milestone-gaps.md

@@ -1,256 +0,0 @@
-<purpose>
-Create all phases necessary to close gaps identified by `/ariadna:audit-milestone`. Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in ROADMAP.md, and offers to plan each phase. One command creates all fix phases — no manual `/ariadna:add-phase` per gap.
-</purpose>
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-
-<process>
-
-## 1. Load Audit Results
-
-```bash
-# Find the most recent audit file
-ls -t .ariadna_planning/v*-MILESTONE-AUDIT.md 2>/dev/null | head -1
-```
-
-Parse YAML frontmatter to extract structured gaps:
-- `gaps.requirements` — unsatisfied requirements
-- `gaps.integration` — missing cross-phase connections
-- `gaps.flows` — broken E2E flows
-
-If no audit file exists or has no gaps, error:
-```
-No audit gaps found. Run `/ariadna:audit-milestone` first.
-```
-
-## 2. Prioritize Gaps
-
-Group gaps by priority from REQUIREMENTS.md:
-
-| Priority | Action |
-|----------|--------|
-| `must` | Create phase, blocks milestone |
-| `should` | Create phase, recommended |
-| `nice` | Ask user: include or defer? |
-
-For integration/flow gaps, infer priority from affected requirements.
-
-## 3. Group Gaps into Phases
-
-Cluster related gaps into logical phases:
-
-**Grouping rules:**
-- Same affected phase → combine into one fix phase
-- Same subsystem (auth, API, UI) → combine
-- Dependency order (fix stubs before wiring)
-- Keep phases focused: 2-4 tasks each
-
-**Example grouping:**
-```
-Gap: DASH-01 unsatisfied (Dashboard doesn't fetch)
-Gap: Integration Phase 1→3 (Auth not passed to API calls)
-Gap: Flow "View dashboard" broken at data fetch
-
-→ Phase 6: "Wire Dashboard to API"
-  - Add controller action for dashboard data
-  - Include authentication before_action
-  - Load data into @instance_vars
-  - Render user data in ERB view
-```
-
-## 4. Determine Phase Numbers
-
-Find highest existing phase:
-```bash
-# Get sorted phase list, extract last one
-PHASES=$(ariadna-tools phases list)
-HIGHEST=$(echo "$PHASES" | jq -r '.directories[-1]')
-```
-
-New phases continue from there:
-- If Phase 5 is highest, gaps become Phase 6, 7, 8...
-
-## 5. Present Gap Closure Plan
-
-```markdown
-## Gap Closure Plan
-
-**Milestone:** {version}
-**Gaps to close:** {N} requirements, {M} integration, {K} flows
-
-### Proposed Phases
-
-**Phase {N}: {Name}**
-Closes:
-- {REQ-ID}: {description}
-- Integration: {from} → {to}
-Tasks: {count}
-
-**Phase {N+1}: {Name}**
-Closes:
-- {REQ-ID}: {description}
-- Flow: {flow name}
-Tasks: {count}
-
-{If nice-to-have gaps exist:}
-
-### Deferred (nice-to-have)
-
-These gaps are optional. Include them?
-- {gap description}
-- {gap description}
-
----
-
-Create these {X} phases? (yes / adjust / defer all optional)
-```
-
-Wait for user confirmation.
-
-## 6. Update ROADMAP.md
-
-Add new phases to current milestone:
-
-```markdown
-### Phase {N}: {Name}
-**Goal:** {derived from gaps being closed}
-**Requirements:** {REQ-IDs being satisfied}
-**Gap Closure:** Closes gaps from audit
-
-### Phase {N+1}: {Name}
-...
-```
-
-## 7. Create Phase Directories
-
-```bash
-mkdir -p ".ariadna_planning/phases/{NN}-{name}"
-```
-
-## 8. Commit Roadmap Update
-
-```bash
-ariadna-tools commit "docs(roadmap): add gap closure phases {N}-{M}" --files .ariadna_planning/ROADMAP.md
-```
-
-## 9. Offer Next Steps
-
-```markdown
-## ✓ Gap Closure Phases Created
-
-**Phases added:** {N} - {M}
-**Gaps addressed:** {count} requirements, {count} integration, {count} flows
-
----
-
-## ▶ Next Up
-
-**Plan first gap closure phase**
-
-`/ariadna:plan-phase {N}`
-
-<sub>`/clear` first → fresh context window</sub>
-
----
-
-**Also available:**
-- `/ariadna:execute-phase {N}` — if plans already exist
-- `cat .ariadna_planning/ROADMAP.md` — see updated roadmap
-
----
-
-**After all gap phases complete:**
-
-`/ariadna:audit-milestone` — re-audit to verify gaps closed
-`/ariadna:complete-milestone {version}` — archive when audit passes
-```
-
-</process>
-
-<gap_to_phase_mapping>
-
-## How Gaps Become Tasks
-
-**Requirement gap → Tasks:**
-```yaml
-gap:
-  id: DASH-01
-  description: "User sees their data"
-  reason: "Dashboard exists but doesn't fetch from API"
-  missing:
-    - "Turbo Frame with controller action for /dashboards/show"
-    - "Instance variables for user data"
-    - "Render user data in ERB"
-
-becomes:
-
-phase: "Wire Dashboard Data"
-tasks:
-  - name: "Add data fetching"
-    files: [app/views/dashboards/show.html.erb, app/controllers/dashboards_controller.rb]
-    action: "Add Turbo Frame that loads user data via controller action"
-
-  - name: "Add data loading"
-    files: [app/controllers/dashboards_controller.rb]
-    action: "Load user data into @user_data, handle loading and error states"
-
-  - name: "Render user data"
-    files: [app/views/dashboards/show.html.erb]
-    action: "Replace placeholder with @user_data rendering in ERB partial"
-```
-
-**Integration gap → Tasks:**
-```yaml
-gap:
-  from_phase: 1
-  to_phase: 3
-  connection: "Auth token → API calls"
-  reason: "Dashboard API calls don't include auth header"
-  missing:
-    - "Auth header in fetch calls"
-    - "Token refresh on 401"
-
-becomes:
-
-phase: "Add Auth to Dashboard Actions"
-tasks:
-  - name: "Add authentication to controller"
-    files: [app/controllers/dashboards_controller.rb, app/services/api_client.rb]
-    action: "Add before_action :authenticate_user! and include auth token in API calls"
-
-  - name: "Handle 401 responses"
-    files: [app/services/api_client.rb]
-    action: "Add error handling to refresh token or redirect to login on 401"
-```
-
-**Flow gap → Tasks:**
-```yaml
-gap:
-  name: "User views dashboard after login"
-  broken_at: "Dashboard data load"
-  reason: "No fetch call"
-  missing:
-    - "Fetch user data on mount"
-    - "Display loading state"
-    - "Render user data"
-
-becomes:
-
-# Usually same phase as requirement/integration gap
-# Flow gaps often overlap with other gap types
-```
-
-</gap_to_phase_mapping>
-
-<success_criteria>
-- [ ] MILESTONE-AUDIT.md loaded and gaps parsed
-- [ ] Gaps prioritized (must/should/nice)
-- [ ] Gaps grouped into logical phases
-- [ ] User confirmed phase plan
-- [ ] ROADMAP.md updated with new phases
-- [ ] Phase directories created
-- [ ] Changes committed
-- [ ] User knows to run `/ariadna:plan-phase` next
-</success_criteria>

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

@@ -1,154 +0,0 @@
-<purpose>
-Remove an unstarted future phase from the project roadmap, delete its directory, renumber all subsequent phases to maintain a clean linear sequence, and commit the change. The git commit serves as the historical record of removal.
-</purpose>
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-
-<process>
-
-<step name="parse_arguments">
-Parse the command arguments:
-- Argument is the phase number to remove (integer or decimal)
-- Example: `/ariadna:remove-phase 17` → phase = 17
-- Example: `/ariadna:remove-phase 16.1` → phase = 16.1
-
-If no argument provided:
-
-```
-ERROR: Phase number required
-Usage: /ariadna:remove-phase <phase-number>
-Example: /ariadna:remove-phase 17
-```
-
-Exit.
-</step>
-
-<step name="init_context">
-Load phase operation context:
-
-```bash
-INIT=$(ariadna-tools init phase-op "${target}")
-```
-
-Extract: `phase_found`, `phase_dir`, `phase_number`, `commit_docs`, `roadmap_exists`.
-
-Also read STATE.md and ROADMAP.md content for parsing current position.
-</step>
-
-<step name="validate_future_phase">
-Verify the phase is a future phase (not started):
-
-1. Compare target phase to current phase from STATE.md
-2. Target must be > current phase number
-
-If target <= current phase:
-
-```
-ERROR: Cannot remove Phase {target}
-
-Only future phases can be removed:
-- Current phase: {current}
-- Phase {target} is current or completed
-
-To abandon current work, use /ariadna:pause-work instead.
-```
-
-Exit.
-</step>
-
-<step name="confirm_removal">
-Present removal summary and confirm:
-
-```
-Removing Phase {target}: {Name}
-
-This will:
-- Delete: .ariadna_planning/phases/{target}-{slug}/
-- Renumber all subsequent phases
-- Update: ROADMAP.md, STATE.md
-
-Proceed? (y/n)
-```
-
-Wait for confirmation.
-</step>
-
-<step name="execute_removal">
-**Delegate the entire removal operation to ariadna-tools:**
-
-```bash
-RESULT=$(ariadna-tools phase remove "${target}")
-```
-
-If the phase has executed plans (SUMMARY.md files), ariadna-tools will error. Use `--force` only if the user confirms:
-
-```bash
-RESULT=$(ariadna-tools phase remove "${target}" --force)
-```
-
-The CLI handles:
-- Deleting the phase directory
-- Renumbering all subsequent directories (in reverse order to avoid conflicts)
-- Renaming all files inside renumbered directories (PLAN.md, SUMMARY.md, etc.)
-- Updating ROADMAP.md (removing section, renumbering all phase references, updating dependencies)
-- Updating STATE.md (decrementing phase count)
-
-Extract from result: `removed`, `directory_deleted`, `renamed_directories`, `renamed_files`, `roadmap_updated`, `state_updated`.
-</step>
-
-<step name="commit">
-Stage and commit the removal:
-
-```bash
-ariadna-tools commit "chore: remove phase {target} ({original-phase-name})" --files .ariadna_planning/
-```
-
-The commit message preserves the historical record of what was removed.
-</step>
-
-<step name="completion">
-Present completion summary:
-
-```
-Phase {target} ({original-name}) removed.
-
-Changes:
-- Deleted: .ariadna_planning/phases/{target}-{slug}/
-- Renumbered: {N} directories and {M} files
-- Updated: ROADMAP.md, STATE.md
-- Committed: chore: remove phase {target} ({original-name})
-
----
-
-## What's Next
-
-Would you like to:
-- `/ariadna:progress` — see updated roadmap status
-- Continue with current phase
-- Review roadmap
-
----
-```
-</step>
-
-</process>
-
-<anti_patterns>
-
-- Don't remove completed phases (have SUMMARY.md files) without --force
-- Don't remove current or past phases
-- Don't manually renumber — use `ariadna-tools phase remove` which handles all renumbering
-- Don't add "removed phase" notes to STATE.md — git commit is the record
-- Don't modify completed phase directories
-</anti_patterns>
-
-<success_criteria>
-Phase removal is complete when:
-
-- [ ] Target phase validated as future/unstarted
-- [ ] `ariadna-tools phase remove` executed successfully
-- [ ] Changes committed with descriptive message
-- [ ] User informed of changes
-</success_criteria>