orchestrix-yuri 1.0.0

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

@@ -0,0 +1,258 @@
+# Phase 1: Create Project
+
+**Command**: `*create`
+**Purpose**: Collect project information from user and scaffold a complete Orchestrix project.
+
+---
+
+## Prerequisites
+
+- None (this is the entry point)
+
+## Resource Directory
+
+```bash
+RESOURCE_DIR="${CLAUDE_SKILL_DIR}/resources"
+# Resolves to: ~/.claude/skills/yuri/resources/
+```
+
+---
+
+## Step 0: Check Resumption
+
+- If `.yuri/memory.yaml` exists AND `phase1_create: complete` → offer skip to Phase 2
+- If `.yuri/memory.yaml` exists AND `phase1_create: in_progress` → resume from last saved step
+- Otherwise → proceed to Step 1
+
+---
+
+## Step 1: Collect Orchestrix License Key
+
+Ask the user for their Orchestrix license key.
+
+**Validation rules**:
+- Must start with `orch_live_` or `orch_trial_`
+- No key → inform: "Apply at https://orchestrix-mcp.youlidao.ai"
+- User says "configure later" → record empty, use `YOUR_LICENSE_KEY_HERE` placeholder
+- Invalid format → prompt again with format hint
+
+---
+
+## Step 2: Collect Project Basics
+
+Ask the user for:
+1. **Project name** (Chinese or English)
+2. **Core problem** (1-3 sentences describing what the project solves)
+
+Auto-generate the directory name:
+- Chinese → translate to English meaning, kebab-case (e.g. "智能柜管理系统" → `smart-locker-management`)
+- English → kebab-case
+- Max 30 characters
+
+---
+
+## Step 3: Confirm Summary
+
+Present this confirmation to the user:
+
+```
+## 📋 Project Understanding Confirmation
+
+| Item | Content |
+|------|---------|
+| **Project Name** | {name} |
+| **Project Directory** | ~/Codes/{kebab-name}/ |
+| **Core Problem** | {description} |
+| **License Key** | {provided / pending} |
+
+Confirm? (Y/N, or specify what to change)
+```
+
+Wait for `Y`. If `N` → return to the specific question the user wants to change.
+
+---
+
+## Step 4: Create Directory Structure
+
+After user confirms, create the project skeleton:
+
+```bash
+PROJECT_DIR=~/Codes/{dir-name}
+mkdir -p "$PROJECT_DIR/docs"
+mkdir -p "$PROJECT_DIR/.claude/commands"
+mkdir -p "$PROJECT_DIR/.claude/hooks"
+mkdir -p "$PROJECT_DIR/.orchestrix-core/scripts"
+mkdir -p "$PROJECT_DIR/.yuri/phase-logs"
+mkdir -p "$PROJECT_DIR/.yuri/checkpoints"
+```
+
+---
+
+## Step 5: Generate .mcp.json
+
+```bash
+RESOURCE_DIR="${CLAUDE_SKILL_DIR}/resources"
+```
+
+1. Read `$RESOURCE_DIR/mcp.json.template`
+2. Replace `{{ORCHESTRIX_LICENSE_KEY}}` → user's key (or `YOUR_LICENSE_KEY_HERE`)
+3. Write → `$PROJECT_DIR/.mcp.json`
+
+If a non-template `mcp.json` exists in resources, use it directly.
+
+---
+
+## Step 6: Copy Orchestrix Infrastructure
+
+```bash
+RESOURCE_DIR="${CLAUDE_SKILL_DIR}/resources"
+
+cp "$RESOURCE_DIR/settings.local.json"     "$PROJECT_DIR/.claude/settings.local.json"
+cp "$RESOURCE_DIR/handoff-detector.sh"     "$PROJECT_DIR/.claude/hooks/handoff-detector.sh"
+chmod +x "$PROJECT_DIR/.claude/hooks/handoff-detector.sh"
+cp "$RESOURCE_DIR/o.md"                    "$PROJECT_DIR/.claude/commands/o.md"
+cp "$RESOURCE_DIR/o-help.md"               "$PROJECT_DIR/.claude/commands/o-help.md"
+cp "$RESOURCE_DIR/o-status.md"             "$PROJECT_DIR/.claude/commands/o-status.md"
+cp "$RESOURCE_DIR/start-orchestrix.sh"     "$PROJECT_DIR/.orchestrix-core/scripts/start-orchestrix.sh"
+chmod +x "$PROJECT_DIR/.orchestrix-core/scripts/start-orchestrix.sh"
+```
+
+---
+
+## Step 7: Generate core-config.yaml
+
+1. Read `$RESOURCE_DIR/core-config.template.yaml`
+2. Replace placeholders:
+   - `{{PROJECT_NAME}}` → project name
+   - `{{REPO_ID}}` → english directory name (kebab-case)
+   - `{{TEST_COMMAND}}` → infer from tech stack:
+
+| Tech Stack | Test Command |
+|------------|-------------|
+| Node.js / React / Next.js / Vue | `npm test` |
+| Python / Django / Flask / FastAPI | `pytest` |
+| Go | `go test ./...` |
+| Java / Spring | `./gradlew test` |
+| Deno | `deno test -A` |
+| Other / Unknown | (empty, auto-detect later) |
+
+3. Write → `$PROJECT_DIR/.orchestrix-core/core-config.yaml`
+
+---
+
+## Step 8: Generate .gitignore
+
+Write to `$PROJECT_DIR/.gitignore`:
+
+```
+node_modules/
+vendor/
+venv/
+__pycache__/
+.env
+.env.local
+.env.*.local
+.DS_Store
+Thumbs.db
+dist/
+build/
+out/
+*.log
+.idea/
+.vscode/
+*.swp
+*.swo
+.orchestrix-core/runtime/
+```
+
+If a `.gitignore.template` exists in resources, use that instead.
+
+---
+
+## Step 9: Initialize Memory
+
+Read the memory template from `${CLAUDE_SKILL_DIR}/templates/memory.template.yaml` and populate it with collected data:
+
+- `project.name` → project name
+- `project.dir_name` → kebab-case directory name
+- `project.project_root` → absolute path to project directory
+- `project.license_key` → collected key or empty
+- `project.description` → core problem statement
+- `project.created_at` → current ISO 8601 timestamp
+- `lifecycle.current_phase` → 1
+- `lifecycle.current_step` → "phase1.step9.memory_init"
+- `lifecycle.phase_status.phase1_create` → "in_progress"
+
+Write → `$PROJECT_DIR/.yuri/memory.yaml`
+
+---
+
+## Step 10: Git Init + Commit
+
+```bash
+cd "$PROJECT_DIR" && git init && git add .
+git commit -m "chore: init project with Orchestrix
+
+- Project brief generated from interactive session
+- Orchestrix infrastructure: MCP config, hooks, slash commands
+- Core config with project-specific settings
+
+🤖 Generated with [Orchestrix](https://orchestrix-mcp.youlidao.ai)"
+```
+
+---
+
+## Step 11: Output Result
+
+Display to the user:
+
+```
+## ✅ Project Created
+**Path**: ~/Codes/{dir-name}/
+
+### Files created
+- `.mcp.json` — Orchestrix MCP Server config
+- `.claude/settings.local.json` — Claude Code hooks config
+- `.claude/hooks/handoff-detector.sh` — HANDOFF auto-detection hook
+- `.claude/commands/o.md` — /o command (Agent activation)
+- `.claude/commands/o-help.md` — /o-help command
+- `.claude/commands/o-status.md` — /o-status command
+- `.orchestrix-core/core-config.yaml` — Project config
+- `.orchestrix-core/scripts/start-orchestrix.sh` — tmux multi-window automation
+- `.gitignore` — Git ignore rules
+```
+
+IF license key is empty, add warning:
+
+```
+⚠️ License Key not configured. Edit .mcp.json, replace YOUR_LICENSE_KEY_HERE.
+Apply at: https://orchestrix-mcp.youlidao.ai
+```
+
+Update memory:
+- `lifecycle.phase_status.phase1_create` → "complete"
+- `lifecycle.current_phase` → 1
+- `lifecycle.current_step` → "phase1.complete"
+
+Save checkpoint → `.yuri/checkpoints/checkpoint-phase1.yaml`
+
+---
+
+## Step 12: Ask Whether to Start Planning
+
+```
+🚀 **Start project planning now?**
+
+| Step | Agent | Task | Output |
+|------|-------|------|--------|
+| 0 | Analyst | Create project brief | docs/project-brief.md |
+| 1 | PM | Generate PRD | docs/prd/*.md |
+| 2 | UX Expert | Frontend spec | docs/front-end-spec*.md |
+| 3 | Architect | Architecture doc | docs/architecture*.md |
+| 4 | PO | Validate + shard | Reports + sharded files |
+
+Reply: **Y** (start now) or **N** (plan manually later)
+```
+
+- If Y → execute `tasks/yuri-plan-project.md`
+- If N → save state, end with reminder: "Run `/yuri *plan` when ready."

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

@@ -0,0 +1,139 @@
+# Phase 5: Deploy Project
+
+**Command**: `*deploy`
+**Purpose**: Present deployment options, execute the user's chosen deployment strategy, and verify the deployment is healthy.
+
+---
+
+## Prerequisites
+
+- Phase 4 (Test) must be complete
+- `.yuri/memory.yaml` must exist with `phase4_test: complete`
+
+---
+
+## Step 0: Load Memory and Validate
+
+1. Read `.yuri/memory.yaml` — restore project context
+2. Verify `lifecycle.phase_status.phase4_test == complete`
+   - If not → "Phase 4 not complete. Run `*test` first."
+3. Set `PROJECT_DIR` from `project.project_root`
+4. If `phase5_deploy == in_progress` → resume from last step
+5. If `phase5_deploy == complete` → show deployed URL, offer re-deploy
+
+Update memory:
+- `lifecycle.current_phase` → 5
+- `lifecycle.phase_status.phase5_deploy` → "in_progress"
+- Save immediately
+
+---
+
+## Step 1: Present Deployment Options
+
+Read deployment options from `${CLAUDE_SKILL_DIR}/data/deployment-options.yaml` and present to user:
+
+```
+## 🚀 Deployment Options
+
+### 🇨🇳 China Region
+
+| # | Provider | Best For | Description |
+|---|----------|----------|-------------|
+| 1 | Sealos | Prototype / MVP | One-click container deployment, zero ops |
+| 2 | Aliyun ECS + Docker Compose | Production | Full control with ECS instances |
+| 3 | Vercel (CN-accessible) | Frontend / SSR | Static and SSR deployment |
+
+### 🌍 Overseas
+
+| # | Provider | Best For | Description |
+|---|----------|----------|-------------|
+| 4 | Vercel | Frontend / Full-stack (Next.js) | Zero-config deployment |
+| 5 | Railway | Backend APIs | Simple container deployment |
+| 6 | AWS / GCP | Enterprise scale | Full cloud infrastructure |
+
+Select a number (1-6), or describe your deployment preference:
+```
+
+---
+
+## Step 2: User Selects Strategy
+
+Record the user's choice:
+- `deployment.strategy` → selected option ID (e.g. `china-sealos`, `overseas-vercel`)
+- Save memory immediately
+
+---
+
+## Step 3: Execute Deployment
+
+Based on the selected strategy, generate and execute the necessary deployment configuration:
+
+### Common steps for all strategies:
+
+1. **Generate Dockerfile** (if not exists):
+   - Analyze project tech stack from `project.tech_stack`
+   - Create appropriate multi-stage Dockerfile
+
+2. **Generate docker-compose.yml** (if applicable):
+   - For strategies that use Docker Compose (e.g. `china-aliyun-ecs`)
+
+3. **Generate CI/CD config** (if applicable):
+   - Vercel: `vercel.json`
+   - Railway: `railway.json`
+   - AWS: basic deployment scripts
+
+4. **Execute deployment commands**:
+   - Run the appropriate deployment CLI commands
+   - Handle authentication prompts
+
+### Self-solve problems:
+
+- Max 2 retries for any failed step
+- Analyze error output and attempt fix
+- Only ask user for:
+  - **Credentials** (API keys, tokens)
+  - **DNS configuration** (domain names, CNAME records)
+  - **Environment secrets** (database URLs, API secrets)
+
+---
+
+## Step 4: Health Check and Report
+
+1. Wait for deployment to complete
+2. Run health check on the deployed URL:
+```bash
+curl -s -o /dev/null -w "%{http_code}" "$DEPLOYED_URL"
+```
+
+3. IF healthy (2xx response):
+
+Save final state:
+- `deployment.url` → deployed URL
+- `deployment.status` → "healthy"
+- `lifecycle.phase_status.phase5_deploy` → "complete"
+- `lifecycle.current_step` → "phase5.complete"
+- Write checkpoint → `.yuri/checkpoints/checkpoint-phase5.yaml`
+
+Report:
+```
+## ✅ Deployment Complete!
+
+| Item | Detail |
+|------|--------|
+| **URL** | {deployed_url} |
+| **Strategy** | {strategy_name} |
+| **Status** | ✅ Healthy |
+| **Health Check** | HTTP {status_code} |
+
+🎉 Your project is live! From idea to deployment — mission complete.
+
+### What's Next?
+- Monitor your application at the deployed URL
+- Run `/yuri *change "{description}"` to handle new requirements
+- Run `/yuri *status` to check project state at any time
+```
+
+4. IF unhealthy:
+- Capture error details
+- Attempt fix (max 2 retries)
+- If still failing → report to user with diagnostics and ask for guidance

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

@@ -0,0 +1,150 @@
+# Phase 3: Develop Project
+
+**Command**: `*develop`
+**Purpose**: Launch the automated development loop (SM → Architect → Dev → QA) via tmux and monitor progress until all stories are complete.
+
+---
+
+## Prerequisites
+
+- Phase 2 (Plan) must be complete
+- Sharded docs must exist (`docs/prd/epic-*.yaml`)
+- `.yuri/memory.yaml` must exist with `phase2_plan: complete`
+
+---
+
+## Step 0: Load Memory and Validate
+
+1. Read `.yuri/memory.yaml` — restore project context
+2. Verify `lifecycle.phase_status.phase2_plan == complete`
+   - If not → "Phase 2 not complete. Run `*plan` first."
+3. Set `PROJECT_DIR` from `project.project_root`
+4. Count total epics/stories from `docs/prd/epic-*.yaml`:
+```bash
+TOTAL_STORIES=$(grep -r 'stories:' "$PROJECT_DIR/docs/prd/epic-"*.yaml 2>/dev/null | wc -l)
+```
+5. If `phase3_develop == in_progress` → resume monitoring loop
+6. If `phase3_develop == complete` → offer skip to Phase 4
+
+Update memory:
+- `lifecycle.current_phase` → 3
+- `lifecycle.phase_status.phase3_develop` → "in_progress"
+- `development.total_stories` → counted total
+- Save immediately
+
+---
+
+## Step 1: Launch Dev Automation
+
+Use the lazy session creation script:
+
+```bash
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
+```
+
+This creates an `orchestrix-{repo-id}` tmux session with 4 windows:
+- Window 0: Architect
+- Window 1: SM (Scrum Master)
+- Window 2: Dev
+- Window 3: QA
+
+SM auto-starts the development loop upon session creation.
+
+Update memory:
+- `tmux.dev_session` → `$SESSION`
+- Save immediately
+
+Report to user:
+```
+🚀 Development session started: {SESSION}
+4 agents active: Architect, SM, Dev, QA
+SM is beginning the development loop...
+```
+
+---
+
+## Step 2: Monitoring Loop
+
+Poll every 5 minutes until all stories are done.
+
+```
+WHILE stories_done < total_stories:
+```
+
+### 2.1 Scan Story Statuses
+
+```bash
+SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
+RESULT=$(bash "$SCRIPT_DIR/scan-stories.sh" "$PROJECT_DIR")
+```
+
+Output: count by status (Blocked, InProgress, Review, Done, etc.)
+
+### 2.2 Report to User
+
+```
+📊 Progress: {done}/{total} stories
+✅ Done: {list of done story IDs}
+🔄 In Progress: {list}
+⏳ Remaining: {count}
+```
+
+### 2.3 Stuck Detection
+
+IF no progress for 15 minutes (3 consecutive polls with same done count):
+1. Capture all 4 tmux window contents:
+```bash
+for W in 0 1 2 3; do
+  tmux capture-pane -t "$SESSION:$W" -p -S -50
+done
+```
+2. Analyze for error patterns (exceptions, stuck loops, missing handoffs)
+3. Attempt recovery:
+   - Resend handoff to target window
+   - `/clear` → restart agent
+4. Increment `development.stuck_count`
+
+IF `stuck_count > 3`:
+- Report to user with full diagnostics
+- Request human intervention
+- Pause monitoring loop
+
+### 2.4 Save Memory
+
+After each poll cycle:
+- `development.stories_done` → current done count
+- `development.stories_in_progress` → list of in-progress story IDs
+- `development.last_progress_at` → timestamp of last progress change
+- Save immediately
+
+---
+
+## Step 3: All Stories Done
+
+1. Save checkpoint:
+- `lifecycle.phase_status.phase3_develop` → "complete"
+- `lifecycle.current_step` → "phase3.complete"
+- Write checkpoint → `.yuri/checkpoints/checkpoint-phase3.yaml`
+
+2. Report:
+```
+## ✅ Development Phase Complete
+
+All {total} stories implemented!
+
+| Status | Count |
+|--------|-------|
+| Done | {done} |
+| Total | {total} |
+
+Development session: {SESSION} (still running for QA phase)
+```
+
+3. Ask:
+```
+🚀 Ready to start smoke testing? (Y/N)
+```
+
+- If Y → execute `tasks/yuri-test-project.md`
+- If N → save state, end with reminder: "Run `/yuri *test` when ready."