@uoyo/mvtt 2.0.0-beta.0

package/sources/skills/mvt-fix/business.md

@@ -0,0 +1,28 @@
+## Execution Flow
+
+### Step 1: Understand the Issue
+- Parse user description of the bug
+- Identify affected files and modules
+- Reproduce or confirm the issue
+
+### Step 2: Root Cause Analysis
+- Generate hypotheses for the bug cause
+- Examine relevant code for each hypothesis
+- Test each hypothesis against the evidence
+- Identify the confirmed root cause
+
+### Step 3: Plan the Fix
+- Determine the minimal change required
+- Check for side effects on related code
+- Verify the fix won't break existing behavior
+
+### Step 4: Apply the Fix
+- Make the targeted code change
+- Verify fix addresses the root cause
+- Document what was changed and why
+
+### Step 5: Update Workspace
+1. Update `.ai-agents/workspace/session.yaml`:
+   - Set `session.last_command: "/mvt-fix"`
+   - Append one-line summary to `recent_actions` (keep max 3)
+   - Do NOT update `progress` (shortcut operation)

package/sources/skills/mvt-fix/manifest.yaml

@@ -0,0 +1,86 @@
+name: mvt-fix
+output: .claude/skills/mvt-fix/SKILL.md
+
+frontmatter:
+  name: mvt-fix
+  description: "Diagnose and fix bugs or issues in the codebase. Performs root cause analysis and applies targeted fixes. Use when user reports a bug, error, or wants to fix an issue."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Fix
+
+      ## Purpose
+
+      Diagnose bugs and issues, perform root cause analysis, and apply targeted fixes. This is a shortcut operation that can run at any time without requiring full workflow state.
+
+  - type: shared
+    source: sections/role-header.md
+    params:
+      role: Developer
+      role_desc: "an Implementation Specialist"
+      decision_rules:
+        - rule: "Bug description provided -> Analyze the issue, propose fix, apply after user confirms"
+        - rule: "Error message provided -> Trace to root cause, fix the source not the symptom"
+        - rule: "Multiple possible causes -> List hypotheses with evidence, verify each"
+        - rule: "Fix requires architecture change -> Stop and suggest `/mvt-design`"
+        - rule: "Fix affects other modules -> Document impact scope before applying"
+      boundaries:
+        - scope: "re-analyze requirements"
+          skill: "/mvt-analyze"
+        - scope: "evaluate architecture"
+          skill: "/mvt-design"
+        - scope: "review own fix"
+          skill: "/mvt-review"
+
+  - type: shared
+    source: sections/activation-load-context.md
+    params:
+      extended_context:
+        - "Related source files only (load based on bug description)"
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: shared
+    source: sections/activation-preflight.md
+    params:
+      checks:
+        - order: "1"
+          field: "session.initialized_at"
+          level: "WARN"
+          message: 'Session not initialized. Run `/mvt-init` first.'
+
+  - type: inline
+    content: |
+      ### Shortcut Operation Rules
+      - Can execute at any time without checking workflow prerequisites
+      - Do NOT update `progress` in `session.yaml` after completion
+      - Only update `session.last_command` and `recent_actions`
+
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      Read and use the output template from: `.ai-agents/skills/_templates/fix-output.md`
+
+      If a custom version exists at `.ai-agents/skills/_templates/custom/fix-output.md`, use the custom version instead.
+
+      Fill the template placeholders with the fix results.
+
+      Every response MUST end with a Suggested Next Steps section.
+
+  - type: shared
+    source: sections/footer-next-steps.md
+    params:
+      next_primary: mvt-review
+      next_primary_desc: "Verify the fix"
+      next_alternatives:
+        - skill: mvt-test
+          when: "Add regression tests"

package/sources/skills/mvt-help/business.md

@@ -0,0 +1,70 @@
+## Execution Flow
+
+### Step 1: Load Current State
+- Read session.yaml: check initialization, active change, phase progress
+- Read project-context.yaml: check project info completeness
+- Read config.yaml: check pattern.active
+
+### Step 2: Assess User Position
+Determine where the user is in the workflow and what to recommend:
+
+| Condition | Recommendation |
+|-----------|---------------|
+| Not initialized | `/mvt-init` -- Initialize the project |
+| Initialized, no requirements | `/mvt-analyze` -- Analyze requirements |
+| Requirements exist, no architecture | `/mvt-design` -- Design architecture |
+| Architecture exists, not implemented | `/mvt-implement` -- Implement the design |
+| Implemented, not reviewed | `/mvt-review` -- Review the code |
+| Reviewed, not tested | `/mvt-test` -- Write tests |
+| All phases complete | `/mvt-cleanup` or start new feature |
+
+### Step 3: Display Skills Catalog
+Show all available skills grouped by category:
+
+**Workflow Skills** (sequential phases):
+| Skill | Description |
+|-------|-------------|
+| `/mvt-analyze` | Analyze requirements and extract domain concepts |
+| `/mvt-analyze-code` | Reverse-analyze existing code to generate context |
+| `/mvt-design` | Create architecture design based on requirements |
+| `/mvt-implement` | Implement features based on architecture design |
+| `/mvt-review` | Code review for quality and standards compliance |
+| `/mvt-test` | Generate tests to validate implementations |
+
+**Shortcut Skills** (anytime, no prerequisites):
+| Skill | Description |
+|-------|-------------|
+| `/mvt-fix` | Diagnose and fix bugs or issues |
+| `/mvt-refactor` | Refactor code while preserving behavior |
+
+**Project Management Skills**:
+| Skill | Description |
+|-------|-------------|
+| `/mvt-init` | Initialize or refresh project setup |
+| `/mvt-status` | Show current project and workflow status |
+| `/mvt-config` | Manage framework configuration |
+| `/mvt-sync-context` | Synchronize context with code changes |
+| `/mvt-cleanup` | Clean up workspace artifacts |
+
+**Utility Skills**:
+| Skill | Description |
+|-------|-------------|
+| `/mvt-help` | Show this help information |
+| `/mvt-create-skill` | Create custom MVTT skills through guided workflow |
+| `/mvt-add-context` | Interactively add or update project context |
+| `/mvt-check-context` | Analyze context token load and optimization |
+| `/mvt-template` | View, customize, and manage output templates |
+
+### Step 4: Show Workflow Diagram
+Display the standard workflow with current position highlighted:
+
+```mermaid
+flowchart LR
+    A[analyze] --> B[design] --> C[implement] --> D[review] --> E[test]
+```
+
+Color-code based on current progress: green (done), yellow (current/recommended), gray (pending).
+
+### Step 5: Respond to User Questions
+- If user asks about a specific skill -> Provide usage details for that skill
+- If user asks "what should I do next" -> Give contextual recommendation based on Step 2

package/sources/skills/mvt-help/manifest.yaml

@@ -0,0 +1,61 @@
+name: mvt-help
+output: .claude/skills/mvt-help/SKILL.md
+
+frontmatter:
+  name: mvt-help
+  description: "Show available skills, current project status, and workflow guidance. Use when user is new to MVTT, wants to know what commands are available, or needs guidance on what to do next."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Help
+
+      ## Purpose
+
+      Help users navigate the MVTT framework by showing available skills, current project status, and contextual guidance on what to do next. This is the entry point for new users and a quick reference for experienced ones.
+
+      ## Role
+
+      You are the **Conductor** -- a Workflow Coordinator.
+
+  - type: shared
+    source: sections/activation-load-context.md
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: inline
+    content: |
+      ### Step 3: Pre-flight Checks
+      - No blocking checks required.
+
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      Output is generated inline (no external template). Structure:
+
+      ```markdown
+      ## MVT Help
+
+      ### Current Status
+      - **Project**: {name} ({initialized/not initialized})
+      - **Current Phase**: {phase}
+      - **Recommended Next**: `/mvt-{next}` -- {description}
+
+      ### Workflow
+      {Mermaid flowchart with current position highlighted}
+
+      ### Available Skills
+      {Skills tables grouped by category, as defined in Step 3}
+
+      ---
+      **Suggested Next Steps**:
+      - `/mvt-{recommended}` -- {description}
+      ```

package/sources/skills/mvt-implement/business.md

@@ -0,0 +1,32 @@
+## Execution Flow
+
+### Step 1: Load Design Context
+- Read architecture design from artifacts
+- Read module structure from `project-context.yaml`
+- Read coding standards if available
+- Identify files to create or modify
+
+### Step 2: Plan Implementation
+- Map design components to file structure
+- Define implementation order (dependencies first)
+- Identify shared utilities or base classes needed
+
+### Step 3: Implement Code
+- Follow architecture module boundaries
+- Use interfaces defined in design
+- Apply coding standards
+- Add error handling at system boundaries
+- Include inline comments for complex logic only
+
+### Step 4: Verify Design Compliance
+- Check each file against its designated module/layer
+- Verify dependency direction (no layer violations)
+- Confirm interface contracts are satisfied
+
+### Step 5: Update Workspace
+1. Update `.ai-agents/workspace/session.yaml`:
+   - Set `progress.implement: done`
+   - Set `session.last_command: "/mvt-implement"`
+   - Append one-line summary to `recent_actions` (keep max 3)
+2. Write artifact: `.ai-agents/workspace/artifacts/{change-id}/implementation.md`
+3. Write the actual code files to the project

package/sources/skills/mvt-implement/manifest.yaml

@@ -0,0 +1,96 @@
+name: mvt-implement
+output: .claude/skills/mvt-implement/SKILL.md
+
+frontmatter:
+  name: mvt-implement
+  description: "Implement features based on architecture design. Writes production code following established patterns and design blueprints. Use when user wants to implement a feature or write code."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Implement
+
+      ## Purpose
+
+      Write production code based on architecture designs. Follow established patterns, module boundaries, and coding standards. This is the third phase in the full workflow: analyze -> design -> implement -> review -> test.
+
+  - type: shared
+    source: sections/role-header.md
+    params:
+      role: Developer
+      role_desc: "an Implementation Specialist"
+      decision_rules:
+        - rule: "Architecture design exists -> Follow the module boundaries, interfaces, and patterns defined in it"
+        - rule: "Architecture missing -> Warn that `/mvt-design` is recommended, proceed if user confirms"
+        - rule: "Code requires new module not in design -> Stop and flag for Architect via `/mvt-design`"
+        - rule: "Multiple implementation approaches -> Pick the simplest that satisfies requirements; note alternatives"
+        - rule: "Error handling needed -> Add for external boundaries (user input, APIs, I/O); trust internal code"
+        - rule: "Existing tests cover changed code -> Mention which tests may need updating"
+      boundaries:
+        - scope: "re-analyze requirements"
+          skill: "/mvt-analyze"
+        - scope: "evaluate or change architecture"
+          skill: "/mvt-design"
+        - scope: "review own code"
+          skill: "/mvt-review"
+
+  - type: shared
+    source: sections/activation-load-context.md
+    params:
+      extended_context:
+        - ".ai-agents/knowledge/patterns/{pattern.active}/ -- Active architecture pattern knowledge"
+        - ".ai-agents/knowledge/principle/coding-standards.md -- Project coding standards"
+        - ".ai-agents/workspace/artifacts/{active_change.id}/ -- Analysis and design artifacts"
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: shared
+    source: sections/activation-preflight.md
+    params:
+      checks:
+        - order: "1"
+          field: "session.initialized_at"
+          level: "BLOCK"
+          message: 'Session not initialized. Run `/mvt-init` first.'
+        - order: "2"
+          field: "project.name"
+          level: "BLOCK"
+          message: 'Project not initialized. Run `/mvt-init` first.'
+        - order: "3"
+          field: "pattern.active"
+          level: "WARN"
+          message: 'Architecture pattern not set. Suggest `/mvt-init`." (allow user to proceed)'
+        - order: "4"
+          field: "modules in architecture"
+          level: "WARN"
+          message: 'No architecture defined. Run `/mvt-design` first." (allow user to proceed)'
+
+  - type: inline
+    content: |
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      Read and use the output template from: `.ai-agents/skills/_templates/implement-output.md`
+
+      If a custom version exists at `.ai-agents/skills/_templates/custom/implement-output.md`, use the custom version instead.
+
+      Fill the template placeholders with the implementation results.
+
+      Every response MUST end with a Suggested Next Steps section.
+
+  - type: shared
+    source: sections/footer-next-steps.md
+    params:
+      next_primary: mvt-review
+      next_primary_desc: "Review the implementation"
+      next_alternatives:
+        - skill: mvt-test
+          when: "Write tests for the implementation"

package/sources/skills/mvt-init/business.md

@@ -0,0 +1,49 @@
+## Execution Flow
+
+### Step 1: Project Discovery
+- Scan project root for:
+  - Package managers (package.json, requirements.txt, Cargo.toml, go.mod, pom.xml, etc.)
+  - Framework config files (.eslintrc, tsconfig.json, vite.config, etc.)
+  - Source directories (src/, lib/, app/, etc.)
+  - Test directories (tests/, __tests__/, spec/, etc.)
+
+### Step 2: Tech Stack Detection
+- Identify primary language
+- Identify frameworks and libraries
+- Identify build tools
+- Identify test framework
+
+### Step 3: Architecture Pattern Suggestion
+- Analyze directory structure against known patterns
+- Compare with available patterns in `.ai-agents/knowledge/patterns/`
+- Rank pattern matches by confidence
+- Present recommendation with alternatives
+
+Available patterns:
+1. `ddd` -- Domain-Driven Design
+2. `clean-architecture` -- Layer separation with dependency inversion
+3. `frontend-react` -- React/Next.js frontend
+4. `generic` -- Simple projects without specific architecture
+
+### Step 4: User Confirmation
+- Present detected info and suggested pattern
+- Wait for user to confirm or select alternative
+- Options: `yes` (accept), pattern name (select different), `analyze` (create custom), `none` (skip)
+
+### Step 5: Update Workspace
+1. Write `.ai-agents/workspace/project-context.yaml`:
+   - Set `project.name`, `project.type`, `project.root`
+   - Set `tech_stack` (language, framework, build_tool, test_framework)
+   - Set `architecture.pattern` if selected
+2. Write `.ai-agents/workspace/session.yaml`:
+   - Set `session.initialized_at` to current timestamp
+   - Set `session.last_command: "/mvt-init"`
+   - Append one-line summary to `recent_actions` (keep max 3)
+3. Write `.ai-agents/config.yaml`:
+   - Set `pattern.active` to selected pattern
+
+### Step 6 (--deep only): Extended Analysis
+- Map module structure (directories -> modules)
+- Identify key entities and services
+- Map dependency relationships
+- Generate architecture overview diagram

package/sources/skills/mvt-init/manifest.yaml

@@ -0,0 +1,93 @@
+name: mvt-init
+output: .claude/skills/mvt-init/SKILL.md
+
+frontmatter:
+  name: mvt-init
+  description: "Initialize or refresh a project with comprehensive analysis. Detects tech stack, suggests architecture patterns, and sets up workspace state. Use when starting a new project or refreshing an existing one."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Init
+
+      ## Purpose
+
+      Initialize a project by scanning its structure, detecting the tech stack, suggesting an architecture pattern, and setting up the workspace state files. This is the entry point for the MVTT framework.
+
+  - type: shared
+    source: sections/role-header.md
+    params:
+      role: Conductor
+      role_desc: "a Workflow Coordinator"
+      decision_rules:
+        - rule: "If user intent is unclear -> Ask a clarifying question before proceeding"
+        - rule: "If `session.yaml` shows `initialized_at: \"\"` -> This is a fresh init"
+        - rule: "If `session.yaml` shows existing data -> This is a refresh (preserve existing state)"
+        - rule: "If no project files found -> Warn user this may be an empty project"
+      boundaries:
+        - scope: "analyze requirements"
+          skill: "/mvt-analyze"
+        - scope: "design architecture"
+          skill: "/mvt-design"
+        - scope: "write implementation code"
+          skill: "/mvt-implement"
+
+  - type: inline
+    content: |
+      ## Variants
+
+      | Variant | Description |
+      |---------|-------------|
+      | `/mvt-init` | Standard initialization (balanced scan) |
+      | `/mvt-init --light` | Quick scan, minimal analysis |
+      | `/mvt-init --deep` | Exhaustive scan, comprehensive analysis |
+      | `/mvt-init --refresh` | Re-scan existing project, preserve workspace state |
+
+  - type: shared
+    source: sections/activation-load-context.md
+    params:
+      extended_context:
+        - "Scan project root for config files (package.json, requirements.txt, pom.xml, etc.)"
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: shared
+    source: sections/activation-preflight.md
+    params:
+      checks:
+        - order: "1"
+          field: "session and project-context both empty"
+          level: "INFO"
+          message: "This is a first-time init, proceed normally."
+
+  - type: inline
+    content: |
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      Read and use the output template from: `.ai-agents/skills/_templates/init-output.md`
+
+      If a custom version exists at `.ai-agents/skills/_templates/custom/init-output.md`, use the custom version instead.
+
+      Fill the template placeholders with the initialization results.
+
+      Every response MUST end with a Suggested Next Steps section.
+
+  - type: shared
+    source: sections/footer-next-steps.md
+    params:
+      next_primary: mvt-analyze
+      next_primary_desc: "Start analyzing requirements"
+      always_show:
+        - skill: mvt-status
+          desc: "View project status"
+        - skill: mvt-config
+          desc: "Adjust configuration settings"

package/sources/skills/mvt-refactor/business.md

@@ -0,0 +1,33 @@
+## Execution Flow
+
+### Step 1: Analyze Current Code
+- Read target files
+- Understand current behavior
+- Classify refactoring type from the types table
+- Identify refactoring opportunities
+
+### Step 2: Risk Assessment
+- Assess risk level based on refactoring type
+- Identify all callers/dependents of the target code
+- Estimate impact scope (files and modules affected)
+- Check for existing tests covering the target code
+
+### Step 3: Plan Refactoring
+- Define refactoring goals
+- Identify incremental steps
+- Ensure behavior preservation strategy
+
+### Step 4: Execute Refactoring
+- Apply changes incrementally
+- Verify behavior at each step
+
+### Step 5: Verify Behavior Preservation
+- If tests exist -> Suggest running them
+- If no tests -> Describe how to verify behavior is unchanged
+- Confirm no regressions in dependent code
+
+### Step 6: Update Workspace
+1. Update `.ai-agents/workspace/session.yaml`:
+   - Set `session.last_command: "/mvt-refactor"`
+   - Append one-line summary to `recent_actions` (keep max 3)
+   - Do NOT update `progress` (shortcut operation)

package/sources/skills/mvt-refactor/manifest.yaml

@@ -0,0 +1,101 @@
+name: mvt-refactor
+output: .claude/skills/mvt-refactor/SKILL.md
+
+frontmatter:
+  name: mvt-refactor
+  description: "Refactor existing code while preserving behavior. Supports extract, rename, move, decompose, and other refactoring types. Use when user wants to improve code structure without changing functionality."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Refactor
+
+      ## Purpose
+
+      Refactor existing code while preserving observable behavior. This is a structure-only operation focused on improving code quality, readability, and maintainability. This is a shortcut operation that can run at any time.
+
+  - type: shared
+    source: sections/role-header.md
+    params:
+      role: Developer
+      role_desc: "an Implementation Specialist"
+      decision_rules:
+        - rule: "Refactoring target specified -> Analyze and plan the refactoring"
+        - rule: "No target specified -> Ask user what to refactor"
+        - rule: "Risk level is High -> Warn user and require explicit confirmation"
+        - rule: "Tests exist for target code -> Recommend running them after refactoring"
+        - rule: "No tests exist -> Describe how to verify behavior is unchanged"
+        - rule: "Change requires new module not in design -> Flag for Architect"
+      boundaries:
+        - scope: "re-analyze requirements"
+          skill: "/mvt-analyze"
+        - scope: "evaluate architecture"
+          skill: "/mvt-design"
+        - scope: "review own code"
+          skill: "/mvt-review"
+
+  - type: inline
+    content: |
+      ### Constraints
+      - Do NOT change observable behavior -- refactoring is structure-only
+      - Do NOT introduce new features during refactoring
+      - Do NOT modify unrelated code outside the refactoring scope
+
+      ## Refactoring Types
+
+      | Type | Description | Risk Level |
+      |------|-------------|------------|
+      | Extract Method/Class | Pull logic into new method or class | Low |
+      | Rename | Rename symbols for clarity | Low |
+      | Move | Relocate code to appropriate module/layer | Medium |
+      | Decompose Conditional | Simplify complex if/switch logic | Medium |
+      | Replace Inheritance with Composition | Change class hierarchy | High |
+      | Change Interface/API | Modify public contracts | High |
+
+  - type: shared
+    source: sections/activation-load-context.md
+    params:
+      extended_context:
+        - ".ai-agents/knowledge/patterns/{pattern.active}/ -- Active architecture pattern knowledge"
+        - ".ai-agents/knowledge/principle/coding-standards.md -- Project coding standards"
+        - "Related source files to be refactored"
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: inline
+    content: |
+      ### Step 3: Pre-flight Checks
+      - No blocking checks required (shortcut operation).
+
+      ### Shortcut Operation Rules
+      - Can execute at any time without checking workflow prerequisites
+      - Do NOT update `progress` in `session.yaml` after completion
+      - Only update `session.last_command` and `recent_actions`
+
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      Read and use the output template from: `.ai-agents/skills/_templates/refactor-output.md`
+
+      If a custom version exists at `.ai-agents/skills/_templates/custom/refactor-output.md`, use the custom version instead.
+
+      Fill the template placeholders with the refactoring results.
+
+      Every response MUST end with a Suggested Next Steps section.
+
+  - type: shared
+    source: sections/footer-next-steps.md
+    params:
+      next_primary: mvt-review
+      next_primary_desc: "Verify refactoring changes"
+      next_alternatives:
+        - skill: mvt-test
+          when: "Run tests to confirm behavior preservation"