appiq-solution 1.1.0 → 1.3.0

package/#Tools/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "appiq-solution",
+  "version": "1.3.0",
+  "description": "🚀 APPIQ SOLUTION: Flutter Mobile Development Extension - Eine spezialisierte Erweiterung der BMAD Method für Flutter Mobile App Entwicklung",
+  "main": "tools/cli.js",
+  "bin": {
+    "appiq-solution": "tools/bmad-npx-wrapper.js",
+    "appiq": "tools/bmad-npx-wrapper.js",
+    "bmad": "tools/bmad-npx-wrapper.js",
+    "bmad-method": "tools/bmad-npx-wrapper.js"
+  },
+  "scripts": {
+    "build": "node tools/cli.js build",
+    "build:agents": "node tools/cli.js build --agents-only",
+    "build:teams": "node tools/cli.js build --teams-only",
+    "list:agents": "node tools/cli.js list:agents",
+    "validate": "node tools/cli.js validate",
+    "install:bmad": "node tools/installer/bin/bmad.js install",
+    "format": "prettier --write \"**/*.md\"",
+    "version:patch": "node tools/version-bump.js patch",
+    "version:minor": "node tools/version-bump.js minor",
+    "version:major": "node tools/version-bump.js major",
+    "version:expansion": "node tools/bump-expansion-version.js",
+    "version:expansion:set": "node tools/update-expansion-version.js",
+    "version:all": "node tools/bump-all-versions.js",
+    "version:all:minor": "node tools/bump-all-versions.js minor",
+    "version:all:major": "node tools/bump-all-versions.js major",
+    "version:all:patch": "node tools/bump-all-versions.js patch",
+    "version:expansion:all": "node tools/bump-all-versions.js",
+    "version:expansion:all:minor": "node tools/bump-all-versions.js minor",
+    "version:expansion:all:major": "node tools/bump-all-versions.js major",
+    "version:expansion:all:patch": "node tools/bump-all-versions.js patch",
+    "release": "semantic-release",
+    "release:test": "semantic-release --dry-run --no-ci || echo 'Config test complete - authentication errors are expected locally'",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@kayvan/markdown-tree-parser": "^1.5.0",
+    "bmad-method": "^4.30.3",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.0",
+    "fs-extra": "^11.3.0",
+    "glob": "^11.0.3",
+    "inquirer": "^8.2.6",
+    "js-yaml": "^4.1.0",
+    "ora": "^5.4.1"
+  },
+  "keywords": [
+    "ai-agents",
+    "development-workflow", 
+    "project-management",
+    "flutter",
+    "mobile-development",
+    "clean-architecture",
+    "cubit",
+    "bloc",
+    "dart",
+    "greenfield",
+    "brownfield",
+    "cursor",
+    "claude-code",
+    "windsurf",
+    "agile",
+    "ai",
+    "orchestrator",
+    "development",
+    "methodology",
+    "agents",
+    "bmad"
+  ],
+  "author": "Brian (BMad) Madison",
+  "license": "MIT",
+  "repository": {
+    "type": "git", 
+    "url": "git+https://github.com/Viktor-Hermann/APPIQ-METHOD.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.1",
+    "prettier": "^3.5.3",
+    "semantic-release": "^22.0.0",
+    "yaml-lint": "^1.7.0"
+  },
+  "lint-staged": {
+    "**/*.md": [
+      "prettier --write"
+    ]
+  }
+}

package/SuperClaude/.claude/commands/analyze.md

@@ -0,0 +1,36 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Command_Header
+
+Multi-dimensional analysis on code, arch, or problem in $ARGUMENTS.
+
+@include shared/command-templates.yml#Universal_Flags
+@see shared/thinking-modes.yml ∀ thinking flags
+@see shared/mcp-flags.yml ∀ MCP controls
+
+Examples:
+- `/user:analyze --code --think` - Code review w/ context
+- `/user:analyze --arch --think-hard` - Deep arch analysis  
+- `/user:analyze --security --ultrathink` - Comprehensive security audit
+
+Analysis modes:
+
+**--code:** Quality review→naming, structure, DRY, complexity | Bugs→null checks, boundaries, types | Security→injection, auth, validation | Perf→O(n²), N+1, memory
+
+**--arch:** System design & patterns | Layer coupling | Scalability bottlenecks | Maintainability assessment | Improvement suggestions
+
+**--profile:** CPU, memory, execution time | Network latency, DB queries | Frontend metrics | Bottleneck identification | Optimization recommendations  
+
+**--security:** OWASP top 10 | Auth & authorization | Data handling & encryption | Attack vector identification
+
+**--perf:** Bottleneck analysis | Algorithm complexity | DB queries & indexes | Caching strategies | Resource utilization
+
+**--watch:** Continuous file monitoring | Real-time quality tracking | Auto re-analysis | Live metrics
+
+**--interactive:** Guided exploration | Step-by-step fixes | Live improvement
+
+@include shared/command-templates.yml#Research_Requirements
+
+@include shared/command-templates.yml#Report_Output
+
+Deliverables: @include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/build.md

@@ -0,0 +1,35 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Command_Header
+
+Build project/feature based on req in $ARGUMENTS.
+
+@include shared/command-templates.yml#Universal_Flags
+@see shared/mcp-flags.yml ∀ MCP controls
+
+Examples:
+- `/user:build --react --magic` - React app w/ UI gen
+- `/user:build --api --c7` - API w/ docs
+- `/user:build --react --magic --pup` - Build & test UI
+
+Pre-build: Remove artifacts (dist/, build/, .next/) | Clean temp files & cache | Validate deps | Remove debug
+
+Build modes:
+**--init:** New project w/ stack (React|API|Fullstack|Mobile|CLI) | TS default | Testing setup | Git workflow
+**--feature:** Impl feature→existing patterns | Maintain consistency | Include tests  
+**--tdd:** Write failing tests→minimal code→pass tests→refactor
+
+Templates:
+- **React:** Vite|TS|Router|state mgmt|testing
+- **API:** Express|TS|auth|validation|OpenAPI  
+- **Fullstack:** React+Node.js+Docker
+- **Mobile:** React Native+Expo
+- **CLI:** Commander.js+cfg+testing
+
+**--watch:** Continuous build | Real-time feedback | Incremental | Live reload
+**--interactive:** Step-by-step cfg | Interactive deps | Build customization
+
+@include shared/command-templates.yml#Research_Requirements
+@include shared/execution-lifecycle.yml#Standard_Lifecycle
+
+Deliverables: @include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/cleanup.md

@@ -0,0 +1,46 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Clean up project artifacts, code & cfg specified in $ARGUMENTS.
+
+--code flag:
+- Remove unused imports & dead code | Clean console.log & debug code
+- Remove commented blocks | Fix style inconsistencies | Remove TODO>30 days
+
+--files flag:
+- Remove build artifacts & temp files | Clean node_modules if corrupted
+- Remove logs & cache dirs | Clean test outputs | Remove OS files (.DS_Store, thumbs.db)
+
+--deps flag:
+- Remove unused deps from package.json | Update vulnerable deps
+- Clean duplicate deps | Optimize dep tree | Check outdated packages
+
+--git flag:
+- Remove untracked files (w/ confirmation) | Clean merged branches
+- Remove large/unwanted files from history | Optimize git (.git/objects cleanup) | Clean stale refs
+
+--cfg flag:
+- Remove deprecated cfg settings | Clean unused env vars
+- Update outdated cfg formats | Validate cfg consistency | Remove duplicate entries
+
+--all flag:
+- Comprehensive cleanup all areas | Generate detailed report
+- Suggest maintenance schedule | Provide perf impact analysis
+
+--dry-run flag:
+- Show what would be cleaned w/o changes | Estimate space savings & perf impact | ID risks before cleanup
+
+--watch flag:
+- Monitor & auto-clean new artifacts | Continuous cleanup during dev | Prevent temp file accumulation | Real-time maintenance
+
+## Integration & Best Practices
+
+@include shared/command-templates.yml#Research_Requirements
+
+@include shared/command-templates.yml#Report_Output
+- Space savings: `.claudedocs/metrics/cleanup-savings-<timestamp>.md`
+- Ensure dirs: `mkdir -p .claudedocs/reports/ .claudedocs/metrics/`
+- Include location: "📄 Cleanup report saved to: [path]"
+
+Deliverables: Cleanup report w/ space saved, perf improvements, maintenance recommendations, safety analysis & cleanup strategy docs.

package/SuperClaude/.claude/commands/deploy.md

@@ -0,0 +1,55 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Deploy application to env specified in $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→multi-service deployment coordination
+- --think-hard→complex infrastructure & rollback planning
+- --ultrathink→complete deployment architecture & disaster recovery
+
+Examples:
+- `/user:deploy --env staging --think` - Staging w/ coordination analysis
+- `/user:deploy --env prod --think-hard` - Prod w/ comprehensive planning
+- `/user:deploy --rollback --ultrathink` - Critical rollback w/ full impact analysis
+
+Pre-deploy cleanup:
+- Clean previous artifacts | Remove dev-only files (.env.local, debug cfgs)
+- Validate prod cfg (no debug flags, correct URLs) | Clean old versions→free space
+
+--env flag:
+- dev: Deploy→dev env for testing | staging: Deploy→staging for pre-prod validation
+- prod: Deploy→prod w/ all safety checks
+
+--rollback flag:
+- Revert→previous stable deployment | Maintain deployment history→audit trail
+- Verify rollback success w/ health checks
+
+Deployment workflow:
+1. Validate→Check prerequisites & cfg 2. Build→Create artifacts 3. Test→Run smoke tests
+4. Deploy→Execute strategy 5. Verify→Confirm health & functionality
+
+Deployment strategies:
+- Blue-green: Two envs, switch traffic→zero downtime | Canary: Gradual rollout→% users
+- Rolling: Update instances sequentially w/ health checks
+
+Pre-deployment checks:
+- Verify tests pass | Check deployment cfg | Ensure rollback plan exists
+- Validate env vars | Confirm DB migrations completed
+
+Post-deployment:
+- Run health checks & smoke tests | Monitor error rates & perf
+- Check critical user journeys | Verify logging & monitoring | Ready→rollback if issues
+
+## Safety & Best Practices
+
+Safety:
+- Always have rollback plan | Backups before deployment
+- Monitor key metrics during deployment | Gradual rollout→major changes
+
+@include shared/command-templates.yml#Research_Requirements
+
+@include shared/command-templates.yml#Report_Output
+
+@include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/design.md

@@ -0,0 +1,91 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Design & architect software solutions based on requirements in $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→standard design patterns & component architecture
+- --think-hard→system-wide architecture & scalability planning
+- --ultrathink→complete system redesign or critical architectural decisions
+
+Examples:
+- `/user:design --api --think` - REST API design w/ patterns
+- `/user:design --ddd --think-hard` - Deep domain modeling
+- `/user:design --api --ddd --ultrathink` - Complete system architecture
+
+Design focus w/ flags:
+
+--api flag:
+- Design REST or GraphQL APIs
+- w/ --openapi: Generate OpenAPI 3.0 spec | w/ --graphql: Create GraphQL schema & resolvers
+- Include auth, rate limiting & error handling | Design→scalability & maintainability
+
+--ddd flag:
+- Apply DDD principles | w/ --bounded-context: Define context boundaries & mappings
+- Design entities, value objects & aggregates | Create domain services & events | Impl repository patterns
+
+--prd flag:
+- Create PRD | w/ --template: Use template (feature/api/integration/migration)
+- Include user stories w/ acceptance criteria | Define success metrics & timelines | Document tech requirements
+
+## API Design Mode (--api)
+
+REST API principles:
+- Resource-oriented URLs w/ proper HTTP verbs | Consistent status codes & error formats
+- Versioning strategy (URL/header/accept) | Pagination, filtering & sorting | HATEOAS→discoverability | OpenAPI docs
+
+GraphQL principles:
+- Clear type system w/ schemas | Efficient queries & mutations | Real-time subscriptions where needed
+- DataLoader patterns→N+1 prevention | Field-level auth | Error handling practices
+
+Common API elements:
+- Auth (JWT/OAuth/API keys) | Rate limiting & throttling | Request/response validation
+- Caching strategies | CORS & security headers | Monitoring & logging
+
+## DDD Mode (--ddd)
+
+Building blocks:
+- **Entities**: Objects w/ unique identity | **Value Objects**: Immutable objects by attributes
+- **Aggregates**: Consistency boundaries w/ roots | **Domain Services**: Business logic not in entities
+- **Repositories**: Abstract data access | **Domain Events**: Capture business events
+
+Strategic patterns:
+- Bounded contexts w/ clear boundaries | Context mapping (shared kernel, anti-corruption layer)
+- Ubiquitous language within contexts | Event-driven architecture | CQRS where appropriate
+
+Structure:
+```
+domain/          # Core business logic
+application/     # Use cases & orchestration  
+infrastructure/  # External concerns
+presentation/    # UI/API layer
+```
+
+## PRD Mode (--prd)
+
+Structure:
+1. **Executive Overview**: Problem statement & solution | Expected impact & ROI | Key stakeholders
+2. **Goals & Success Metrics**: Primary objectives (must-have) | Secondary goals (nice-to-have) | KPIs & measurement
+3. **User Stories & Requirements**: User personas & journeys | Functional requirements | Non-functional requirements | Acceptance criteria
+4. **Technical Specs**: Architecture overview | Tech choices | Integration points | Security requirements | Perf targets  
+5. **Timeline & Risks**: Dev phases | Dependencies & blockers | Risk mitigation strategies
+
+## Integration
+
+Combined modes:
+- API+DDD: Design domain-driven APIs | API+PRD: Create API product requirements
+- DDD+PRD: Document domain-driven architecture | All three: Complete system design
+
+Best practices:
+- Start w/ user needs & business goals | Design→change & evolution | Consider non-functional early
+- Document decisions & rationale | Include examples & diagrams | Plan→testing & monitoring
+
+Research requirements:
+- Architecture patterns→C7 & industry practices | API standards→reference OpenAPI/REST/GraphQL specs
+- DDD patterns→verify w/ Evans' book or official DDD | Tech choices→WebSearch recent comparisons & case studies
+- Never design on assumptions - verify patterns | All decisions cite authoritative sources
+
+Deliverables:
+- API: Complete spec, impl guide, docs | DDD: Domain model, bounded contexts, architecture diagrams, code structure
+- PRD: Requirements doc, user stories, success metrics, timeline

package/SuperClaude/.claude/commands/dev-setup.md

@@ -0,0 +1,37 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Setup comprehensive dev env or CI/CD pipeline based on $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→multi-tool env coordination
+- --think-hard→complex CI/CD pipeline architecture  
+- --ultrathink→enterprise dev infrastructure design
+
+Examples:
+- `/user:dev-setup --install --think` - Tool installation w/ dependency analysis
+- `/user:dev-setup --ci --think-hard` - CI/CD pipeline w/ comprehensive workflow design
+- `/user:dev-setup --monitor --ultrathink` - Complete observability infrastructure
+
+--install flag:
+- Install & cfg dev tools (Node.js, Git, Docker, DBs) | Setup IDE cfgs→consistent dev experience
+- Create npm scripts→common tasks | Cfg pre-commit hooks→code quality | Setup linting & testing frameworks
+
+--ci flag:
+- Cfg CI/CD pipelines (GitHub Actions, GitLab CI, other platforms) | Setup build, test & deployment stages
+- Cfg envs: dev, staging & prod | Add security scanning & dep checking | Setup deployment automation
+
+--monitor flag:
+- Cfg observability tools | Setup logging & monitoring | Add perf tracking
+- Cfg error reporting | Setup alerts→critical issues
+
+## Best Practices & Security
+
+Ensure all cfgs follow security practices & include comprehensive docs.
+
+@include shared/command-templates.yml#Research_Requirements
+
+@include shared/command-templates.yml#Report_Output
+
+@include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/document.md

@@ -0,0 +1,99 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Create comprehensive docs for code, API, or system specified in $ARGUMENTS.
+
+Flags:
+- --api: Generate API docs | --user: Generate user-friendly guides
+- --ultracompressed, --uc: Generate docs w/ ~70% fewer tokens using telegram-style
+
+--api flag:
+- Document all endpoints w/ examples | Include request/response formats
+- Specify auth requirements | Document error codes & meanings | Add rate limiting info | Provide code samples→multiple languages
+
+--user flag:
+- Create user-friendly guides | Include step-by-step tutorials | Add screenshots or diagrams
+- Write FAQ section | Include troubleshooting guide | Provide real-world examples
+
+Documentation types:
+
+README Documentation:
+- Project overview and purpose
+- Installation instructions
+- Quick start guide
+- Configuration options
+- Basic usage examples
+- Contributing guidelines
+
+Architecture Documentation:
+- System design overview
+- Component relationships
+- Data flow diagrams
+- Technology choices rationale
+- Scalability considerations
+- Security architecture
+
+API Documentation:
+- Endpoint descriptions
+- HTTP methods and status codes
+- Request/response schemas
+- Authentication methods
+- Example requests with curl/code
+- Webhook documentation
+- WebSocket events (if applicable)
+
+User Guides:
+- Getting started tutorial
+- Feature walkthroughs
+- Best practices guide
+- Common use cases
+- Integration guides
+- Migration guides
+
+Developer Documentation:
+- Code structure overview
+- Development setup
+- Testing guidelines
+- Deployment process
+- Debugging tips
+- Performance optimization
+
+Documentation standards:
+- Use clear, concise language
+- Include practical examples
+- Add visual aids where helpful
+- Keep information current
+- Make it searchable
+- Version-specific when needed
+- Test all code examples
+
+When --ultracompressed flag is present:
+- Apply shared/ultracompressed.yml rules
+- Generate legend at doc start
+- Remove articles, conjunctions, fillers
+- Use symbols: →&@+- w/ w/o
+- Use abbreviations: cfg fn impl req resp
+- Headings <20 chars, sentences <50 chars
+- Format: YAML>JSON>prose, tables>lists>paragraphs
+- Target ~70% token reduction
+
+Structure guidelines:
+- Logical organization
+- Progressive disclosure
+- Cross-references
+- Glossary for terms
+- Index for quick lookup
+- Change log maintenance
+
+Documentation Output:
+- API documentation: `/docs/api/`
+- User guides: `/docs/guides/`
+- Architecture docs: `/docs/architecture/`
+- Developer docs: `/docs/development/`
+- README files: `/docs/README.md` (main), subdirectory READMEs as needed
+- Ensure directory exists: `mkdir -p /docs/[category]/`
+- Include location in output: "📚 Documentation created: [path]"
+- Update `/docs/index.md` with new documentation links
+
+Deliverables: Complete documentation matching the specified type, working code examples, visual aids or diagrams as needed, and quick reference guide.

package/SuperClaude/.claude/commands/estimate.md

@@ -0,0 +1,69 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Provide comprehensive time & complexity estimates for task in $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→multi-component estimation w/ deps
+- --think-hard→complex project estimation w/ risk analysis
+- --ultrathink→enterprise-scale estimation w/ full uncertainty modeling
+
+Examples:
+- `/user:estimate --detailed --think` - Detailed breakdown w/ dependency analysis
+- `/user:estimate --worst-case --think-hard` - Risk-based estimation w/ comprehensive scenarios
+- `/user:estimate "migrate to microservices" --ultrathink` - Complex architectural estimation
+
+Relevant factors:
+
+Time components:
+- Dev time→impl | Code review & feedback cycles | Testing (unit, integration, E2E)
+- Deployment & verification | Docs updates
+
+Complexity multipliers:
+- New feature from scratch: 1x baseline | Refactoring existing: 1.5x (understanding + changing)
+- Working w/ legacy: 2x (constraints + unknowns) | Cross-team deps: 1.5x (coordination overhead)
+
+Uncertainty factors:
+- Clear requirements, known tech: ±10%
+- Some unknowns, new patterns: ±25%
+- Significant unknowns, research needed: ±50%
+- Completely new territory: ±100%
+
+Estimation workflow:
+1. Break down task into subtasks
+2. Estimate each subtask individually
+3. Apply complexity multipliers
+4. Add appropriate uncertainty buffer
+5. Provide a realistic range, not a single number
+
+Formula: Base time × Complexity × Uncertainty = Time range
+
+Include in estimates:
+- Best case scenario (everything goes smoothly)
+- Realistic case (normal friction and discoveries)
+- Worst case scenario (significant obstacles)
+
+## Additional Considerations
+
+Context factors:
+- Developer experience level with the codebase
+- Availability of documentation and examples
+- Required coordination with other teams
+- Potential blockers or dependencies
+
+Research requirements for estimation:
+- Technology patterns → Research implementation complexity via C7 and official docs
+- Architecture patterns → WebSearch for similar project timelines and case studies
+- Team velocity → Check historical data and industry benchmarks
+- Risk assessment → Must verify common pitfalls and mitigation strategies
+- Never estimate based on gut feeling - always research comparable scenarios
+- All estimates must cite sources: // Source: [estimation data reference]
+
+Report Output:
+- Estimate summaries: `.claudedocs/summaries/estimate-<timestamp>.md`
+- Risk assessments: `.claudedocs/reports/risk-analysis-<timestamp>.md`
+- Ensure directory exists: `mkdir -p .claudedocs/summaries/ .claudedocs/reports/`
+- Include report location in output: "📄 Estimate saved to: [path]"
+
+Deliverables: Time estimate range (min-max), complexity assessment, required resources, key assumptions, risk analysis, and potential blockers that could affect the estimate.

package/SuperClaude/.claude/commands/explain.md

@@ -0,0 +1,85 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Provide comprehensive explanations of concepts, code, or systems in $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→multi-concept explanation w/ connections
+- --think-hard→complex system explanations w/ deep analysis
+- --ultrathink→comprehensive knowledge synthesis & teaching
+
+MCP flags (optional):
+- --c7→fetch official lib/framework docs | --seq→step-by-step concept breakdown
+- --no-mcp→explain using only codebase context
+
+Doc flags:
+- --ultracompressed or --uc→7 0% token reduction in explanations
+
+Examples:
+- `/user:explain --c7 "React hooks" --think` - React hooks w/ contextual connections
+- `/user:explain --seq "OAuth flow" --think-hard` - Deep OAuth analysis w/ security implications
+- `/user:explain --depth advanced --c7 --ultrathink` - Comprehensive system explanation
+
+--depth flag levels:
+- ELI5: Simple analogies, avoid jargon, focus→concepts
+- Beginner: Cover basics, step-by-step guidance, simple examples
+- Intermediate: Tech details, best practices, common patterns
+- Expert: Deep impl details, edge cases, perf considerations
+
+When --visual flag is present:
+- Create diagrams using Mermaid syntax
+- Use ASCII art for simple visualizations
+- Include flowcharts for processes
+- Add sequence diagrams for interactions
+
+Structure the explanation:
+1. Start with a high-level overview
+2. Break down into logical components
+3. Explain each component with appropriate depth
+4. Show relationships and interactions
+5. Provide concrete examples
+
+Include relevant formats:
+- Code examples that can be run and tested
+- Comparison tables for alternatives
+- Pros and cons lists for decisions
+- Links to authoritative resources
+
+For technical concepts:
+- Explain the "what" before the "how"
+- Connect to familiar concepts when possible
+- Build understanding incrementally
+- Address common misconceptions
+
+For code explanations:
+- Walk through logic step by step
+- Explain design decisions
+- Highlight important patterns
+- Point out potential gotchas
+
+## UltraCompressed Mode
+
+When --ultracompressed flag is present:
+- Apply shared/ultracompressed.yml rules
+- Generate legend for symbols/abbreviations used
+- Compress explanations to ~30% of normal size
+- Use telegram-style: remove articles, use symbols
+- Format: lists>paragraphs, tables>prose
+- Example: "fn takes 3 params→bool" instead of "The function takes three parameters and returns a boolean value"
+
+Research requirements for explanations:
+- Technical concepts → C7 documentation for authoritative explanations and examples
+- Framework patterns → Must verify with official guides and documentation
+- Best practices → WebSearch for current industry standards and expert opinions
+- Code examples → Research working patterns from official documentation
+- Never explain without verification - always cite authoritative sources
+- All explanations must include sources: // Source: [documentation reference]
+
+Report Output:
+- Explanation summaries: `.claudedocs/summaries/explanation-<topic>-<timestamp>.md`
+- Learning resources: `.claudedocs/reports/learning-resources-<timestamp>.md`
+- Ensure directory exists: `mkdir -p .claudedocs/summaries/ .claudedocs/reports/`
+- Include report location in output: "📚 Explanation saved to: [path]"
+
+Deliverables: Clear explanation at the appropriate depth level, working examples, visual aids if requested, curated resources for further learning, and comprehensive source references.