orchestrix-yuri 1.0.0

package/skill/tasks/yuri-handle-change.md

@@ -0,0 +1,239 @@
+# Change Management
+
+**Command**: `*change "{description}"`
+**Purpose**: Handle mid-project requirement changes by assessing scope and routing to the appropriate workflow.
+
+---
+
+## Step 0: Load Memory and Context
+
+1. Read `.yuri/memory.yaml` — restore project context
+2. Set `PROJECT_DIR` from `project.project_root`
+3. Determine current phase from `lifecycle.current_phase`
+4. Extract the change description from the user's command argument
+
+Update memory:
+- `lifecycle.current_step` → "change_management"
+- Save immediately
+
+---
+
+## Step 1: Scope Assessment
+
+Assess the change size based on the current phase and change description.
+
+### Scope Assessment Matrix
+
+| Current Phase | Change Size | Action | Needs Planning Session? |
+|---------------|-------------|--------|------------------------|
+| Phase 2 | Any | Modify current/subsequent planning step inputs | Already exists |
+| Phase 3 | Small (≤5 files) | Dev `*solo "{description}"` | No |
+| Phase 3 | Medium | PO `*route-change` → standard workflow | **Yes** |
+| Phase 3 | Large (cross-module/DB/security) | Pause dev → partial Phase 2 re-plan | **Yes** |
+| Phase 4 | Any | Queue for next iteration | No (record only) |
+| Phase 5+ | New iteration | PM `*start-iteration` → plan → dev → test | **Yes** |
+
+Present assessment to user:
+
+```
+## 📋 Change Assessment
+
+| Item | Detail |
+|------|--------|
+| **Current Phase** | Phase {n} ({phase_name}) |
+| **Change** | {description} |
+| **Assessed Size** | {Small / Medium / Large} |
+| **Recommended Action** | {action} |
+
+Proceed with this approach? (Y/N, or specify alternative)
+```
+
+Wait for user confirmation.
+
+---
+
+## Step 2: Execute Based on Scope
+
+### Small Change (Phase 3, ≤5 files)
+
+No planning session needed. Use Dev directly:
+
+```bash
+SESSION="{tmux.dev_session}"
+# Ensure dev session is alive
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
+
+# Send to Dev
+tmux send-keys -t "$SESSION:2" "/clear" Enter
+sleep 2
+tmux send-keys -t "$SESSION:2" "/o dev" Enter
+sleep 12
+tmux send-keys -t "$SESSION:2" "*solo \"$CHANGE_DESCRIPTION\"" Enter
+```
+
+Monitor Dev completion, then resume normal Phase 3 monitoring.
+
+### Medium Change (Phase 3)
+
+Requires planning session for PO routing:
+
+```bash
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+
+# 1. Ensure planning session
+PLAN_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" planning "$PROJECT_DIR")
+
+# 2. Activate PO and route change
+tmux send-keys -t "$PLAN_SESSION:0" "/o po" Enter
+sleep 15
+tmux send-keys -t "$PLAN_SESSION:0" "*route-change \"$CHANGE_DESCRIPTION\"" Enter
+```
+
+Wait for PO routing result. Then:
+
+- IF routes to **Architect**:
+```bash
+tmux send-keys -t "$PLAN_SESSION:0" "/clear" Enter
+sleep 2
+tmux send-keys -t "$PLAN_SESSION:0" "/o architect" Enter
+sleep 15
+tmux send-keys -t "$PLAN_SESSION:0" "*resolve-change" Enter
+```
+
+- IF routes to **PM**:
+```bash
+tmux send-keys -t "$PLAN_SESSION:0" "/clear" Enter
+sleep 2
+tmux send-keys -t "$PLAN_SESSION:0" "/o pm" Enter
+sleep 15
+tmux send-keys -t "$PLAN_SESSION:0" "*revise-prd" Enter
+```
+
+Wait for Proposal output (PCP/TCP).
+
+Then switch to dev session:
+```bash
+DEV_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
+
+# In SM window: apply proposal
+tmux send-keys -t "$DEV_SESSION:1" "/clear" Enter
+sleep 2
+tmux send-keys -t "$DEV_SESSION:1" "/o sm" Enter
+sleep 12
+tmux send-keys -t "$DEV_SESSION:1" "*apply-proposal {proposal_id}" Enter
+```
+
+SM → Architect → Dev → QA auto-loop resumes.
+
+### Large Change (Phase 3, cross-module/DB/security)
+
+Same as medium change flow but with explicit pause notification:
+
+```
+⚠️ Large change detected. Pausing development loop for re-planning...
+```
+
+Follow the medium change flow, then resume Phase 3 monitoring.
+
+### Phase 4 Change (Queue for next iteration)
+
+Record only — do not execute during testing:
+
+```
+📝 Change recorded for next iteration: {description}
+Current testing will continue. This change will be addressed in the next development cycle.
+```
+
+### Post-MVP Iteration (Phase 5+)
+
+Full iteration flow using PM `*start-iteration`:
+
+```bash
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+
+# Step 1: PM generates next-steps.md
+PLAN_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" planning "$PROJECT_DIR")
+tmux send-keys -t "$PLAN_SESSION:0" "/o pm" Enter
+sleep 15
+tmux send-keys -t "$PLAN_SESSION:0" "*start-iteration" Enter
+```
+
+Monitor PM completion. PM creates: `docs/prd/epic-*.yaml` + `docs/prd/*next-steps.md`
+
+**Step 2: Parse next-steps.md**
+
+Read the generated next-steps file. Split on `🎯 HANDOFF TO {agent}:` markers.
+Build ordered execution queue:
+```
+[{agent: "ux-expert", content: "..."},
+ {agent: "architect", content: "..."},
+ {agent: "sm", content: "..."}]
+```
+
+**Step 3: Execute each HANDOFF section (STOP before SM)**
+
+FOR EACH section WHERE agent != "sm":
+1. Create new window in planning tmux session
+2. Start `cc`, wait for startup
+3. Activate agent: `/o {agent}`
+4. Paste the section content as instructions to the agent
+5. Monitor completion (detect "Xed for Ns" / ○ idle)
+6. Report to user, offer review
+7. Save progress to memory
+
+**Step 4: SM handoff → transition to dev automation**
+
+When reaching `🎯 HANDOFF TO sm:`:
+1. Kill planning session (done)
+2. Ensure dev session:
+```bash
+DEV_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
+```
+3. In SM window (window 1) of dev session:
+```bash
+tmux send-keys -t "$DEV_SESSION:1" "/clear" Enter
+sleep 2
+tmux send-keys -t "$DEV_SESSION:1" "/o sm" Enter
+sleep 12
+tmux send-keys -t "$DEV_SESSION:1" "*draft" Enter
+```
+SM creates first story → handoff chain auto-starts (SM → Arch → Dev → QA)
+
+**Step 5: Resume Phase 3 monitoring**
+
+Enter standard development monitoring loop (see `tasks/yuri-develop-project.md` Step 2).
+When all new stories complete → Phase 4 testing → Phase 5 incremental deployment if needed.
+
+---
+
+## Step 3: Record Change
+
+Save change record to memory regardless of scope:
+
+```yaml
+changes.history:
+  - timestamp: "{ISO 8601}"
+    phase: {current_phase}
+    description: "{change_description}"
+    scope: "{small/medium/large}"
+    action_taken: "{what was done}"
+```
+
+Save memory immediately.
+
+---
+
+## Step 4: Resume Normal Flow
+
+After change is handled:
+- If in Phase 3 → resume development monitoring loop
+- If in Phase 4 → continue testing
+- If post-MVP iteration → follow through Phase 3 → 4 → 5 cycle
+
+Report to user:
+```
+✅ Change handled: {description}
+Action taken: {action_summary}
+Resuming {current_phase_name}...
+```

package/skill/tasks/yuri-plan-project.md

@@ -0,0 +1,158 @@
+# Phase 2: Plan Project
+
+**Command**: `*plan`
+**Purpose**: Drive all planning agents (Analyst → PM → UX-Expert → Architect → PO) via tmux to generate complete project documentation.
+
+---
+
+## Prerequisites
+
+- Phase 1 (Create) must be complete
+- `.yuri/memory.yaml` must exist with `phase1_create: complete`
+
+---
+
+## Step 0: Load Memory and Validate
+
+1. Read `.yuri/memory.yaml` — restore project context
+2. Verify `lifecycle.phase_status.phase1_create == complete`
+   - If not → "Phase 1 not complete. Run `*create` first."
+3. Set `PROJECT_DIR` from `project.project_root`
+4. If `phase2_plan == in_progress` → find last completed planning step, resume from next
+5. If `phase2_plan == complete` → offer skip to Phase 3
+
+Update memory:
+- `lifecycle.current_phase` → 2
+- `lifecycle.phase_status.phase2_plan` → "in_progress"
+- Save immediately
+
+---
+
+## Step 1: Create Planning tmux Session
+
+Use the lazy session creation script:
+
+```bash
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" planning "$PROJECT_DIR")
+```
+
+This creates an `op-{project-name}` tmux session with an initial window running Claude Code.
+
+Update memory:
+- `tmux.planning_session` → `$SESSION`
+- Save immediately
+
+---
+
+## Step 2: Execute Planning Agents
+
+Execute each agent step sequentially. Each step runs in a NEW tmux window.
+
+### Agent Sequence
+
+| Window | Agent | Command | Expected Output |
+|--------|-------|---------|-----------------|
+| 0 | analyst | `*create-doc project-brief` | `docs/project-brief.md` |
+| 1 | pm | `*create-doc prd` | `docs/prd.md` |
+| 2 | ux-expert | `*create-doc front-end-spec` | `docs/front-end-spec.md` |
+| 3 | architect | `*create-doc fullstack-architecture` | `docs/architecture.md` |
+| 4 | po | `*execute-checklist po-master-validation` | Validation report |
+| 5 | po | `*shard` | `docs/prd/` + `docs/architecture/` |
+
+### FOR EACH step (window_idx = 0..5):
+
+**2.1** Report to user:
+```
+Starting {agent} ({n}/6)...
+```
+
+**2.2** Create new tmux window + start Claude Code:
+```bash
+if [ "$WINDOW_IDX" -gt 0 ]; then
+  tmux new-window -t "$SESSION:$WINDOW_IDX" -n "{agent}" -c "$PROJECT_DIR"
+fi
+tmux send-keys -t "$SESSION:$WINDOW_IDX" "cc" C-m
+sleep 2  # Wait for Claude Code to start
+```
+
+**2.3** Activate agent and send command:
+```bash
+tmux send-keys -t "$SESSION:$WINDOW_IDX" "/o {agent}" Enter
+sleep 15  # Wait for agent to load
+tmux send-keys -t "$SESSION:$WINDOW_IDX" "{command}" Enter
+```
+
+**2.4** Monitor completion:
+```bash
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+RESULT=$(bash "$SCRIPT_DIR/monitor-agent.sh" "$SESSION" "$WINDOW_IDX" "{expected_file}" 30 30)
+```
+
+Detection priority:
+1. `/[A-Z][a-z]*ed for [0-9]/` — Claude Code completion (e.g. "Baked for 31s")
+2. `○` idle indicator
+3. `◐` approval prompt → auto-send `y` Enter
+4. Content hash stable 3 polls (90s)
+
+**2.5** Verify output file exists (if applicable):
+```bash
+test -f "$PROJECT_DIR/{expected_file}"
+```
+
+**2.6** Report to user and confirm:
+```
+✅ {agent} complete. Output: {file}
+Continue / Review / Modify?
+```
+
+- **Continue** → next step
+- **Review** → show file content summary
+- **Modify** → user specifies changes, resend to agent in same window
+
+**2.7** Save memory:
+```
+planning.steps[n].status = complete
+planning.steps[n].output = "{expected_file}"
+planning.steps[n].completed_at = "{ISO 8601 timestamp}"
+```
+
+### Special: Steps 4-5 (PO validate + shard)
+
+Steps 4 and 5 share the same window (window 4):
+1. Run `*execute-checklist po-master-validation` first, monitor completion
+2. Then send `*shard` in the same window, monitor completion
+
+---
+
+## Step 3: All Complete
+
+1. Kill planning session:
+```bash
+tmux kill-session -t "$SESSION"
+```
+
+2. Save checkpoint:
+- `lifecycle.phase_status.phase2_plan` → "complete"
+- `lifecycle.current_step` → "phase2.complete"
+- Write checkpoint → `.yuri/checkpoints/checkpoint-phase2.yaml`
+
+3. Output summary:
+```
+## ✅ Planning Phase Complete
+
+All planning documents generated:
+- `docs/project-brief.md` — Project brief
+- `docs/prd/*.md` — Product requirements (sharded)
+- `docs/front-end-spec*.md` — Frontend spec (if applicable)
+- `docs/architecture*.md` — Architecture doc (sharded)
+- Sharded context files for development
+```
+
+4. Ask:
+```
+🚀 Ready to start automated development? (Y/N)
+```
+
+- If Y → execute `tasks/yuri-develop-project.md`
+- If N → save state, end with reminder: "Run `/yuri *develop` when ready."

package/skill/tasks/yuri-resume.md

@@ -0,0 +1,132 @@
+# Resume from Checkpoint
+
+**Command**: `*resume`
+**Purpose**: Detect interrupted state and resume project execution from the last saved checkpoint.
+
+---
+
+## Step 1: Read Memory
+
+```bash
+MEMORY_FILE=".yuri/memory.yaml"
+```
+
+- If `.yuri/memory.yaml` not found → "No project state found. Use `*create` to start a new project."
+- If found → read and parse full memory state
+
+---
+
+## Step 2: Display Status Summary
+
+Present current project state:
+
+```
+## 📊 Project Status
+
+| Item | Detail |
+|------|--------|
+| **Project** | {project.name} |
+| **Path** | {project.project_root} |
+| **Current Phase** | Phase {lifecycle.current_phase} |
+| **Current Step** | {lifecycle.current_step} |
+| **Last Active** | {timestamp from memory file mtime} |
+
+### Phase Progress
+| Phase | Status |
+|-------|--------|
+| 1. Create | {phase1_create} |
+| 2. Plan | {phase2_plan} |
+| 3. Develop | {phase3_develop} |
+| 4. Test | {phase4_test} |
+| 5. Deploy | {phase5_deploy} |
+```
+
+If in Phase 3 (Develop), also show:
+```
+### Development Progress
+- Stories: {stories_done}/{total_stories}
+- In Progress: {stories_in_progress}
+- Stuck Count: {stuck_count}
+```
+
+---
+
+## Step 3: Check Recoverability
+
+Perform diagnostic checks:
+
+1. **tmux sessions alive?**
+```bash
+# Check planning session
+tmux has-session -t "{tmux.planning_session}" 2>/dev/null && echo "ALIVE" || echo "DEAD"
+
+# Check dev session
+tmux has-session -t "{tmux.dev_session}" 2>/dev/null && echo "ALIVE" || echo "DEAD"
+```
+
+2. **Expected files exist?**
+   - Check for output files of completed planning steps
+   - Check for story files if in development phase
+
+3. **Incomplete operations?**
+   - Any planning step marked `in_progress`?
+   - Any stories stuck in `InProgress` or `Review`?
+
+Report findings:
+```
+### Recovery Diagnostics
+- Planning session: {ALIVE/DEAD}
+- Dev session: {ALIVE/DEAD}
+- Expected files: {all present / missing: list}
+- Incomplete operations: {none / list}
+```
+
+---
+
+## Step 4: Offer Resume Options
+
+Based on the interrupted state, present options:
+
+```
+Detected interruption at Phase {n}, Step {m}.
+
+Options:
+  1. **Resume from checkpoint** — Continue from last saved state
+  2. **Re-execute current step** — Retry the step that was interrupted
+  3. **Skip to next phase** — Mark current phase complete and advance
+
+Select (1/2/3):
+```
+
+Wait for user selection.
+
+---
+
+## Step 5: Execute Recovery
+
+Based on user's choice:
+
+### Option 1: Resume from checkpoint
+
+1. Load the latest checkpoint from `.yuri/checkpoints/`
+2. Recreate any needed tmux sessions using `ensure-session.sh`
+3. Call the appropriate phase task file with resume context:
+   - Phase 2 → `tasks/yuri-plan-project.md` (will detect `in_progress` and resume)
+   - Phase 3 → `tasks/yuri-develop-project.md` (will re-enter monitoring loop)
+   - Phase 4 → `tasks/yuri-test-project.md` (will resume from last untested epic)
+   - Phase 5 → `tasks/yuri-deploy-project.md` (will resume deployment)
+
+### Option 2: Re-execute current step
+
+1. Reset the current step status to `pending` in memory
+2. Recreate any needed tmux sessions
+3. Call the appropriate phase task file (step will re-run from beginning)
+
+### Option 3: Skip to next phase
+
+1. Mark current phase as `complete` in memory
+2. Write checkpoint
+3. Advance `lifecycle.current_phase` by 1
+4. Call the next phase task file
+
+After any option, save updated memory immediately.

package/skill/tasks/yuri-status.md

@@ -0,0 +1,156 @@
+# Project Status Query
+
+**Command**: `*status`
+**Purpose**: Display comprehensive project status without modifying any state.
+
+---
+
+## Step 1: Read Memory
+
+```bash
+MEMORY_FILE=".yuri/memory.yaml"
+```
+
+- If `.yuri/memory.yaml` not found → "No project state found. Use `*create` to start a new project."
+- If found → read and parse full memory state
+
+---
+
+## Step 2: Display Project Overview
+
+```
+## 📊 Project Status: {project.name}
+
+| Item | Detail |
+|------|--------|
+| **Project** | {project.name} |
+| **Path** | {project.project_root} |
+| **Description** | {project.description} |
+| **Tech Stack** | {project.tech_stack} |
+| **Created** | {project.created_at} |
+| **License** | {configured / pending} |
+```
+
+---
+
+## Step 3: Display Phase Progress
+
+```
+### Lifecycle Progress
+
+| Phase | Status | Detail |
+|-------|--------|--------|
+| 1. Create | {✅/🔄/⏳} {status} | Project scaffold |
+| 2. Plan | {✅/🔄/⏳} {status} | Planning docs |
+| 3. Develop | {✅/🔄/⏳} {status} | Story implementation |
+| 4. Test | {✅/🔄/⏳} {status} | Smoke testing |
+| 5. Deploy | {✅/🔄/⏳} {status} | Deployment |
+
+**Current**: Phase {current_phase} — {current_step}
+```
+
+Status icons:
+- `✅` = complete
+- `🔄` = in_progress
+- `⏳` = pending
+- `❌` = failed
+
+---
+
+## Step 4: Display Phase-Specific Details
+
+### If Phase 2 (Plan) is in progress or complete:
+
+```
+### Planning Progress
+
+| Step | Agent | Status | Output |
+|------|-------|--------|--------|
+| 0 | Analyst | {status} | {output file} |
+| 1 | PM | {status} | {output file} |
+| 2 | UX Expert | {status} | {output file} |
+| 3 | Architect | {status} | {output file} |
+| 4 | PO Validate | {status} | {output file} |
+| 5 | PO Shard | {status} | {output file} |
+```
+
+### If Phase 3 (Develop) is in progress or complete:
+
+Scan current story statuses:
+```bash
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+bash "$SCRIPT_DIR/scan-stories.sh" "$PROJECT_DIR"
+```
+
+```
+### Development Progress
+
+| Metric | Value |
+|--------|-------|
+| Total Stories | {total} |
+| Done | {done} |
+| In Progress | {in_progress} |
+| In Review | {review} |
+| Blocked | {blocked} |
+| Remaining | {remaining} |
+
+Progress: [{done}/{total}] {'█' * pct}{'░' * (100-pct)} {pct}%
+```
+
+### If Phase 4 (Test) is in progress or complete:
+
+```
+### Testing Progress
+
+| Epic | Status | Rounds |
+|------|--------|--------|
+| {id} | {✅ Pass / ❌ Fail / ⏳ Pending} | {n} |
+| ... | ... | ... |
+```
+
+### If Phase 5 (Deploy) is complete:
+
+```
+### Deployment
+
+| Item | Detail |
+|------|--------|
+| Strategy | {strategy} |
+| URL | {url} |
+| Status | {status} |
+```
+
+---
+
+## Step 5: Display tmux Session Status
+
+Check if tmux sessions are alive:
+
+```bash
+# Planning session
+tmux has-session -t "{tmux.planning_session}" 2>/dev/null && echo "ALIVE" || echo "DEAD"
+
+# Dev session
+tmux has-session -t "{tmux.dev_session}" 2>/dev/null && echo "ALIVE" || echo "DEAD"
+```
+
+```
+### Active Sessions
+
+| Session | Name | Status |
+|---------|------|--------|
+| Planning | {planning_session} | {ALIVE/DEAD/N/A} |
+| Development | {dev_session} | {ALIVE/DEAD/N/A} |
+```
+
+If any change history exists:
+```
+### Change History
+
+| # | Timestamp | Phase | Description | Action |
+|---|-----------|-------|-------------|--------|
+| 1 | {ts} | {phase} | {desc} | {action} |
+| ... | ... | ... | ... | ... |
+```
+
+**Note**: This command is read-only. No state is modified.