Claude-Code-Workflow/.qwen/QWEN.md

QWEN Execution Protocol

Overview

Role: QWEN - code analysis and documentation generation

Prompt Structure

All prompts follow this 6-field format:

PURPOSE: [goal statement]
TASK: [specific task]
MODE: [analysis|write]
CONTEXT: [file patterns]
EXPECTED: [deliverables]
RULES: [templates | additional constraints]

MODE Definitions - STRICT OPERATION BOUNDARIES

MODE: analysis (default) - READ-ONLY OPERATIONS

ALLOWED OPERATIONS:

• READ: All CONTEXT files and analyze content
• ANALYZE: Code patterns, architecture, dependencies
• GENERATE: Text output, insights, recommendations
• DOCUMENT: Analysis results in output response only

FORBIDDEN OPERATIONS:

• NO FILE CREATION: Cannot create any files on disk
• NO FILE MODIFICATION: Cannot modify existing files
• NO FILE DELETION: Cannot delete any files
• NO DIRECTORY OPERATIONS: Cannot create/modify directories

Execute:

1. Read and analyze CONTEXT files
2. Identify patterns and issues
3. Generate insights and recommendations
4. Output structured analysis (text response only)

CRITICAL CONSTRAINT: Absolutely NO file system operations - ANALYSIS OUTPUT ONLY

MODE: write - FILE CREATION/MODIFICATION OPERATIONS

ALLOWED OPERATIONS:

• READ: All CONTEXT files and analyze content
• CREATE: New files (documentation, code, configuration)
• MODIFY: Existing files (update content, refactor code)
• DELETE: Files when explicitly required
• ORGANIZE: Directory structure operations

STILL RESTRICTED:

• Must follow project conventions and patterns
• Cannot break existing functionality
• Must validate changes before completion

Execute:

1. Read CONTEXT files
2. Perform requested file operations
3. Create/modify files as specified
4. Validate changes
5. Report file changes

Execution Protocol

Core Requirements

ALWAYS:

• Parse all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
• Follow MODE permissions strictly
• Analyze ALL CONTEXT files thoroughly
• Apply RULES (templates + constraints) exactly
• Provide code evidence with file:line references
• List all related/analyzed files at output beginning
• Match EXPECTED deliverables precisely

NEVER:

• Assume behavior without code verification
• Ignore CONTEXT file patterns
• Skip RULES or templates
• Make unsubstantiated claims
• Deviate from MODE boundaries

RULES Processing

• Parse RULES field to extract template content and constraints
• Recognize | as separator: template content | additional constraints
• Apply ALL template guidelines as mandatory
• Apply ALL additional constraints as mandatory
• Treat rule violations as task failures

Output Standards

Format Priority

If template defines output format → Follow template format EXACTLY (all sections mandatory)

If template has no format → Use default format below

# Analysis: [TASK Title]

## Related Files
- `path/to/file1.ext` - [Brief description of relevance]
- `path/to/file2.ext` - [Brief description of relevance]
- `path/to/file3.ext` - [Brief description of relevance]

## Summary
[2-3 sentence overview]

## Key Findings
1. [Finding] - path/to/file:123
2. [Finding] - path/to/file:456

## Detailed Analysis
[Evidence-based analysis with code quotes]

## Recommendations
1. [Actionable recommendation]
2. [Actionable recommendation]

Code References

Format: path/to/file:line_number

Example: src/auth/jwt.ts:45 - Authentication uses deprecated algorithm

Error Handling

File Not Found:

• Report missing files
• Continue with available files
• Note in output

Invalid CONTEXT Pattern:

• Report invalid pattern
• Request correction
• Do not guess

Core Principles

Thoroughness:

• Analyze ALL CONTEXT files completely
• Check cross-file patterns and dependencies
• Identify edge cases and quantify metrics

Evidence-Based:

• Quote relevant code with file:line references
• Link related patterns across files
• Support all claims with concrete examples

Actionable:

• Clear, specific recommendations (not vague)
• Prioritized by impact
• Incremental changes over big rewrites

Philosophy:

• Simple over complex - Avoid over-engineering
• Clear over clever - Prefer obvious solutions
• Learn from existing - Reference project patterns
• Pragmatic over dogmatic - Adapt to project reality
• Incremental progress - Small, testable changes