orchestrix-yuri 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dorayo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# Orchestrix Yuri — Meta-Orchestrator
+
+Yuri is a **Meta-Orchestrator** that takes natural language from users and autonomously drives all [Orchestrix](https://orchestrix-mcp.youlidao.ai) agents through the full project lifecycle.
+
+```
+User describes idea → Yuri drives: Create → Plan → Develop → Test → Deploy
+```
+
+## How It Works
+
+Yuri is a [Claude Code skill](https://code.claude.com/docs/en/skills) that orchestrates specialized AI agents via tmux sessions:
+
+| Phase | What Yuri Does | Agents Involved |
+|-------|---------------|-----------------|
+| **1. Create** | Collects project info, scaffolds directory, configures Orchestrix | — |
+| **2. Plan** | Drives planning agents sequentially via tmux | Analyst → PM → UX-Expert → Architect → PO |
+| **3. Develop** | Launches 4-agent dev automation, monitors progress | SM ↔ Architect ↔ Dev ↔ QA |
+| **4. Test** | Runs smoke tests per epic, fixes bugs, regression tests | QA + Dev |
+| **5. Deploy** | Recommends and executes deployment strategy | — |
+
+## Installation
+
+```bash
+npx orchestrix-yuri install
+```
+
+This installs the Yuri skill globally to `~/.claude/skills/yuri/`.
+
+### Prerequisites
+
+- [Claude Code](https://claude.com/claude-code) CLI installed
+- [tmux](https://github.com/tmux/tmux) installed (`brew install tmux`)
+- An Orchestrix License Key (get one at [orchestrix-mcp.youlidao.ai](https://orchestrix-mcp.youlidao.ai))
+
+## Usage
+
+In any Claude Code session:
+
+```
+/yuri
+```
+
+Then either:
+- Describe your project idea in natural language
+- Use a specific command: `*create`, `*plan`, `*develop`, `*test`, `*deploy`
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `*create` | Create a new project (Phase 1) |
+| `*plan` | Start/resume project planning (Phase 2) |
+| `*develop` | Start/resume automated development (Phase 3) |
+| `*test` | Start/resume smoke testing (Phase 4) |
+| `*deploy` | Start/resume deployment (Phase 5) |
+| `*status` | Show current project phase and progress |
+| `*resume` | Resume from last saved checkpoint |
+| `*change "{desc}"` | Handle mid-project requirement change |
+
+## Architecture
+
+```
+~/.claude/skills/yuri/          ← Globally installed skill
+├── SKILL.md                    ← Agent persona + activation protocol
+├── tasks/                      ← Phase workflow instructions
+├── scripts/                    ← Shell scripts (tmux control, monitoring)
+├── templates/                  ← Memory schema
+├── data/                       ← Decision rules (deployment, routing)
+└── resources/                  ← Files copied to new projects
+```
+
+### Memory System
+
+Yuri maintains per-project state in `.yuri/memory.yaml`, enabling:
+- **Resumption**: Pick up from any interruption point
+- **Progress tracking**: Real-time story/epic completion counts
+- **Change management**: History of requirement changes and actions taken
+- **Error recovery**: Automatic retry with escalation
+
+### tmux Sessions
+
+| Session | Purpose | Windows |
+|---------|---------|---------|
+| `op-{project}` | Planning phase | One per agent (Analyst, PM, UX, Architect, PO) |
+| `orchestrix-{repo-id}` | Development phase | 4 fixed (Architect, SM, Dev, QA) |
+
+Sessions are **lazily created and recreated** — if a session dies or is killed, Yuri automatically rebuilds it when needed.
+
+### Completion Detection
+
+Yuri monitors agent completion in tmux panes using a priority-based detection system:
+
+1. **Claude Code completion message**: Pattern like "Baked for 31s" (`[A-Z][a-z]*ed for [0-9]`)
+2. **TUI idle indicator**: `○` symbol
+3. **Approval prompt**: `◐` → auto-approved
+4. **Content stability**: Pane unchanged for 90 seconds
+
+## Change Management
+
+Yuri handles mid-project changes based on scope:
+
+| Scope | Action |
+|-------|--------|
+| Small (≤5 files) | Dev `*solo` directly |
+| Medium | PO `*route-change` → standard workflow |
+| Large | Pause dev, partial re-plan |
+| New iteration | PM `*start-iteration` → parse next-steps.md → drive agents → resume dev |
+
+## Deployment Options
+
+| Region | Provider | Best For |
+|--------|----------|----------|
+| China | Sealos | Prototype / MVP |
+| China | Aliyun ECS + Docker | Production |
+| China | Vercel (CN) | Frontend / SSR |
+| Overseas | Vercel | Frontend / Full-stack |
+| Overseas | Railway | Backend APIs |
+| Overseas | AWS / GCP | Enterprise |
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+'use strict';
+
+const { install } = require('../lib/installer');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (command === 'install') {
+  install();
+} else if (command === '--help' || command === '-h' || !command) {
+  console.log(`
+  orchestrix-yuri — Meta-Orchestrator for Orchestrix
+
+  Usage:
+    npx orchestrix-yuri install    Install Yuri skill globally (~/.claude/skills/yuri/)
+    npx orchestrix-yuri --help     Show this help message
+
+  After installation, type /yuri in any Claude Code session to activate.
+  `);
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error('Run "npx orchestrix-yuri --help" for usage information.');
+  process.exit(1);
+}

package/lib/installer.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SKILL_SOURCE = path.join(__dirname, '..', 'skill');
+const SKILL_TARGET = path.join(os.homedir(), '.claude', 'skills', 'yuri');
+
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function makeScriptsExecutable(dir) {
+  if (!fs.existsSync(dir)) return;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      makeScriptsExecutable(fullPath);
+    } else if (entry.name.endsWith('.sh')) {
+      fs.chmodSync(fullPath, 0o755);
+    }
+  }
+}
+
+function install() {
+  console.log('');
+  console.log('  Installing Yuri Meta-Orchestrator...');
+  console.log('');
+
+  // Check source exists
+  if (!fs.existsSync(SKILL_SOURCE)) {
+    console.error('  Error: Skill source directory not found.');
+    console.error(`  Expected: ${SKILL_SOURCE}`);
+    process.exit(1);
+  }
+
+  // Check for existing installation
+  if (fs.existsSync(SKILL_TARGET)) {
+    console.log(`  Existing installation found at ${SKILL_TARGET}`);
+    console.log('  Overwriting...');
+    fs.rmSync(SKILL_TARGET, { recursive: true, force: true });
+  }
+
+  // Ensure parent directory exists
+  const parentDir = path.dirname(SKILL_TARGET);
+  if (!fs.existsSync(parentDir)) {
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+
+  // Copy skill directory
+  copyDirRecursive(SKILL_SOURCE, SKILL_TARGET);
+
+  // Make all .sh files executable
+  makeScriptsExecutable(path.join(SKILL_TARGET, 'scripts'));
+  makeScriptsExecutable(path.join(SKILL_TARGET, 'resources'));
+
+  console.log('  Skill location: ~/.claude/skills/yuri/');
+  console.log('');
+  console.log('  Usage: Type /yuri in any Claude Code session to activate.');
+  console.log('');
+  console.log('  Yuri will:');
+  console.log('  1. Collect your project idea');
+  console.log('  2. Create a project skeleton with Orchestrix infrastructure');
+  console.log('  3. Drive planning, development, testing, and deployment automatically');
+  console.log('');
+}
+
+module.exports = { install };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "orchestrix-yuri",
+  "version": "1.0.0",
+  "description": "Yuri — Meta-Orchestrator for Orchestrix. Drive your entire project lifecycle with natural language.",
+  "main": "lib/installer.js",
+  "bin": {
+    "orchestrix-yuri": "bin/install.js"
+  },
+  "scripts": {
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "orchestrix",
+    "ai-agent",
+    "meta-orchestrator",
+    "claude-code",
+    "skill",
+    "project-lifecycle",
+    "tmux-automation"
+  ],
+  "author": "dorayo",
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "lib/",
+    "skill/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/skill/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: yuri
+description: >
+  Meta-Orchestrator for full project lifecycle management.
+  Drives all Orchestrix agents autonomously: Create, Plan, Develop, Test, Deploy.
+  Use when starting a new project, resuming an existing one, or managing changes.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, WebSearch
+argument-hint: "[*create | *plan | *develop | *test | *deploy | *status | *resume | *change]"
+---
+
+# Yuri — Meta-Orchestrator
+
+You are **Yuri**, a Meta-Orchestrator that controls all Orchestrix agents via tmux
+to deliver complete projects from a single natural language description.
+
+## Core Principles
+
+1. **NEVER implement code directly.** You orchestrate, not execute.
+2. **ALWAYS check .yuri/memory.yaml on activation.** If exists, offer to resume.
+3. **Save state BEFORE asking user, AFTER receiving response, AFTER each tmux operation.**
+4. **Ask user ONLY for:** phase transition confirmation, planning output review, deployment choice, genuine ambiguity.
+5. **Self-solve problems.** Escalate to user only after 2 failed retries.
+6. **Proactive reporting** at phase boundaries and every 5 minutes during monitoring.
+7. **Default language is English.** Switch to Chinese only if user explicitly requests it.
+
+## Available Commands
+
+| # | Command | Description |
+|---|---------|-------------|
+| 1 | *create | Create a new project (Phase 1) |
+| 2 | *plan | Start/resume project planning (Phase 2) |
+| 3 | *develop | Start/resume automated development (Phase 3) |
+| 4 | *test | Start/resume smoke testing (Phase 4) |
+| 5 | *deploy | Start/resume deployment (Phase 5) |
+| 6 | *status | Show current project phase and progress |
+| 7 | *resume | Resume from last saved checkpoint |
+| 8 | *change "{desc}" | Handle mid-project requirement change |
+
+## Activation Protocol
+
+1. Adopt Yuri persona completely.
+2. Check for `.yuri/memory.yaml` in the current working directory.
+3. If memory exists: display project status summary, offer resume options.
+4. If no memory: show greeting and command table.
+5. If user provides natural language (not a `*command`): interpret intent using
+   [phase-routing.yaml](data/phase-routing.yaml) and route to appropriate phase.
+6. If user provides `$ARGUMENTS`: parse and execute the matching command.
+
+## Greeting (no existing project)
+
+```
+🚀 Hello! I'm Yuri, your project lifecycle Meta-Orchestrator.
+
+I can take you from a one-sentence idea to a fully deployed project:
+**Create → Plan → Develop → Test → Deploy**
+
+| # | Command | Description |
+|---|---------|-------------|
+| 1 | *create | Create a new project (Phase 1) |
+| 2 | *plan | Start/resume project planning (Phase 2) |
+| 3 | *develop | Start/resume automated development (Phase 3) |
+| 4 | *test | Start/resume smoke testing (Phase 4) |
+| 5 | *deploy | Start/resume deployment (Phase 5) |
+| 6 | *status | Show current project phase and progress |
+| 7 | *resume | Resume from last saved checkpoint |
+| 8 | *change "{desc}" | Handle mid-project requirement change |
+
+Tell me what you'd like to build, or pick a command to get started.
+```
+
+## Greeting (existing project detected)
+
+```
+🚀 Welcome back! I'm Yuri. I found your project state:
+
+**Project**: {project.name}
+**Phase**: Phase {lifecycle.current_phase} — {lifecycle.current_step}
+**Progress**: {phase-specific summary}
+**Last active**: {lifecycle.started_at}
+
+Would you like to resume from where we left off? Or tell me what you need.
+```
+
+## Phase Execution
+
+Each command maps to a task file. **Read the task file and execute it step by step.**
+
+| Command | Task File |
+|---------|-----------|
+| *create | [yuri-create-project.md](tasks/yuri-create-project.md) |
+| *plan | [yuri-plan-project.md](tasks/yuri-plan-project.md) |
+| *develop | [yuri-develop-project.md](tasks/yuri-develop-project.md) |
+| *test | [yuri-test-project.md](tasks/yuri-test-project.md) |
+| *deploy | [yuri-deploy-project.md](tasks/yuri-deploy-project.md) |
+| *resume | [yuri-resume.md](tasks/yuri-resume.md) |
+| *status | [yuri-status.md](tasks/yuri-status.md) |
+| *change | [yuri-handle-change.md](tasks/yuri-handle-change.md) |
+
+## Memory Contract
+
+- **Location**: `{project_root}/.yuri/memory.yaml`
+- **Schema**: See [memory.template.yaml](templates/memory.template.yaml)
+- **Read** at the start of every task execution.
+- **Write** after every significant operation (tmux command sent, phase transition, user response received).
+- **Checkpoint** at phase boundaries: copy memory to `.yuri/checkpoints/checkpoint-phase{N}.yaml`.
+
+## tmux Session Management
+
+- **Planning session**: `op-{project-name}` — created during Phase 2, one window per agent step.
+- **Dev session**: `orchestrix-{repo-id}` — created during Phase 3 via `start-orchestrix.sh`, 4 windows (Architect/SM/Dev/QA).
+- **Lazy recreation**: If a session is needed but doesn't exist, recreate it using [ensure-session.sh](scripts/ensure-session.sh).
+- **Never assume sessions are alive** — always check with `tmux has-session` first.
+
+## Completion Detection
+
+When monitoring an agent in a tmux window, use [monitor-agent.sh](scripts/monitor-agent.sh):
+
+| Priority | Signal | Pattern |
+|----------|--------|---------|
+| 1 | Claude Code completion | `/[A-Z][a-z]*ed for [0-9]/` (e.g., "Baked for 31s") |
+| 2 | TUI idle indicator | `○` in last lines of pane |
+| 3 | Approval prompt | `◐` → auto-send "y" + Enter |
+| 4 | Content stability | Pane hash unchanged 3 consecutive polls |
+
+## Error Recovery
+
+- **Max 2 auto-retries** per operation, then escalate to user.
+- **Agent load failure**: `/clear` → retry `/o {agent}`.
+- **tmux session death**: Lazy recreation via `ensure-session.sh`.
+- **Stuck agent** (no change 5min): `/clear` → restart.
+- **Handoff chain break** (Phase 3): Manually resend handoff command to target window.
+
+## Resource Directory
+
+Files copied to new projects during Phase 1 are in [resources/](resources/).
+Reference them as `${CLAUDE_SKILL_DIR}/resources/` in Bash commands.

package/skill/data/deployment-options.yaml

@@ -0,0 +1,44 @@
+# Yuri Deployment Options
+# Used by Phase 5 to present deployment strategies to the user.
+
+china:
+  - id: china-sealos
+    provider: Sealos
+    best_for: Prototype / MVP
+    description: One-click container deployment, zero ops
+
+  - id: china-aliyun-ecs
+    provider: Aliyun ECS + Docker Compose
+    best_for: Production
+    description: Full control with ECS instances, Nginx reverse proxy, SSL
+
+  - id: china-vercel
+    provider: Vercel (CN-accessible)
+    best_for: Frontend / SSR
+    description: Static and SSR deployment, accessible from China
+
+  - id: china-aliyun-oss-cdn
+    provider: Aliyun OSS + CDN
+    best_for: Static sites
+    description: Static asset hosting with CDN acceleration
+
+overseas:
+  - id: overseas-vercel
+    provider: Vercel
+    best_for: Frontend / Full-stack (Next.js)
+    description: Zero-config deployment, edge functions
+
+  - id: overseas-railway
+    provider: Railway
+    best_for: Backend APIs
+    description: Simple container deployment with built-in databases
+
+  - id: overseas-aws
+    provider: AWS (ECS / Lambda)
+    best_for: Enterprise scale
+    description: Full cloud infrastructure with auto-scaling
+
+  - id: overseas-fly
+    provider: Fly.io
+    best_for: Global edge deployment
+    description: Deploy containers close to users worldwide

package/skill/data/phase-routing.yaml

@@ -0,0 +1,50 @@
+# Yuri Phase Routing Rules
+# Determines which phase to route to based on user intent.
+
+routes:
+  - intent_patterns: ["create", "new project", "start a project", "build something", "I want to make"]
+    target_phase: 1
+    command: "*create"
+
+  - intent_patterns: ["plan", "planning", "design", "specification", "PRD", "architecture"]
+    target_phase: 2
+    command: "*plan"
+
+  - intent_patterns: ["develop", "implement", "code", "build", "start development"]
+    target_phase: 3
+    command: "*develop"
+
+  - intent_patterns: ["test", "smoke test", "QA", "quality", "verify"]
+    target_phase: 4
+    command: "*test"
+
+  - intent_patterns: ["deploy", "ship", "release", "go live", "publish", "launch"]
+    target_phase: 5
+    command: "*deploy"
+
+  - intent_patterns: ["status", "progress", "where are we", "what's happening"]
+    target_phase: 0
+    command: "*status"
+
+  - intent_patterns: ["change", "modify", "update requirement", "add feature", "new feature"]
+    target_phase: 0
+    command: "*change"
+
+  - intent_patterns: ["resume", "continue", "pick up", "where we left off"]
+    target_phase: 0
+    command: "*resume"
+
+change_scope_rules:
+  small:
+    max_files: 5
+    no_db_changes: true
+    no_security_changes: true
+    action: dev_solo
+
+  medium:
+    action: po_route_change
+    requires_planning_session: true
+
+  large:
+    action: pause_and_replan
+    requires_planning_session: true

package/skill/resources/.gitignore.template

@@ -0,0 +1,29 @@
+# Dependencies
+node_modules/
+vendor/
+venv/
+__pycache__/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Build
+dist/
+build/
+out/
+*.log
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Orchestrix runtime
+.orchestrix-core/runtime/

package/skill/resources/core-config.template.yaml

@@ -0,0 +1,67 @@
+title: Orchestrix Core System
+description: >
+  The core agent framework for Orchestrix, providing the essential agents,
+  workflows, and data for building and managing AI-driven development teams.
+markdownExploder: true
+project:
+  name: '{{PROJECT_NAME}}'
+  mode: monolith
+  testCommand: '{{TEST_COMMAND}}'
+  multi_repo:
+    role: implementation
+    repository_id: '{{REPO_ID}}'
+    product_repo_path: ''
+    auto_filter_stories: false
+    assigned_stories: []
+prd:
+  prdFile: docs/prd.md
+  prdSharded: false
+  prdShardedLocation: docs/prd
+architecture:
+  architectureFile: docs/architecture.md
+  architectureSharded: false
+  architectureShardedLocation: docs/architecture
+  storyReviewsLocation: docs/architecture/story-reviews
+customTechnicalDocuments: null
+devLoadAlwaysFiles:
+  - docs/architecture/*coding-standards.md
+  - docs/architecture/*tech-stack.md
+  - docs/architecture/*source-tree.md
+devDebugLog: .ai/debug-log.md
+devStoryLocation: docs/stories
+verticalSliceStrategy: true
+dev:
+  devLogLocation: docs/dev/logs
+  devLogEnabled: true
+architect:
+  storyReviewsLocation: docs/architecture/story-reviews
+qa:
+  qaLocation: docs/qa
+  qaReviewsLocation: docs/qa/reviews
+  evidenceLocation: docs/qa/evidence
+  testDesignThresholds:
+    simple:
+      maxComplexity: 0
+      minQualityScore: 8.5
+      securitySensitive: false
+      tasks: []
+    standard:
+      maxComplexity: 2
+      minQualityScore: 7
+      tasks:
+        - test-design
+    comprehensive:
+      minComplexity: 3
+      securitySensitive: true
+      tasks:
+        - test-design
+        - risk-profile
+slashPrefix: Orchestrix
+version: 15.14.0
+i18n:
+  default_language: en
+  supported_languages:
+    - en
+    - zh
+  fallback_to_default: true
+  file_pattern: '{name}.{lang}.{ext}'