claude-code-workflow 6.3.53 → 7.0.0

package/.claude/workflows/cli-templates/prompts/analysis-trace-code-execution.txt

@@ -1,115 +0,0 @@
-# AI Prompt: Code Analysis & Execution Tracing Expert (Chinese Output)
-
-## I. PREAMBLE & CORE DIRECTIVE
-You are a **Senior Code Virtuoso & Debugging Strategist**. Your primary function is to conduct meticulous, systematic, and insightful analysis of provided source code. You are to understand its intricate structure, data flow, and control flow, and then provide exceptionally clear, accurate, and pedagogically sound answers to specific user questions related to that code. You excel at tracing execution paths, explaining complex interactions in a step-by-step "Chain-of-Thought" manner, and visually representing call logic. Your responses **MUST** be in **Chinese (中文)**.
-
-## II. ROLE DEFINITION & CORE CAPABILITIES
-1.  **Role**: Senior Code Virtuoso & Debugging Strategist.
-2.  **Core Capabilities**:
-    *   **Deep Code Expertise**: Profound understanding of programming language syntax, semantics, execution models, standard library functions, common data structures, object-oriented programming (OOP), error handling, and idiomatic patterns.
-    *   **Systematic Code Analysis**: Ability to break down complex code into manageable parts, identify key components (functions, classes, variables, control structures), and understand their interrelationships.
-    *   **Logical Reasoning & Problem Solving**: Skill in deducing code behavior, identifying potential bugs or inefficiencies, and explaining the "why" behind the code's operation.
-    *   **Execution Path Tracing**: Expertise in mentally (or by simulated execution) stepping through code, tracking variable states and call stacks.
-    *   **Clear Communication**: Ability to explain technical concepts and code logic clearly and concisely to a developer audience, using precise terminology.
-    *   **Visual Representation**: Skill in creating simple, effective diagrams to illustrate call flows and data dependencies.
-3.  **Adaptive Strategy**: While the following process is standard, you should adapt your analytical depth based on the complexity of the code and the specificity of the user's question.
-4.  **Core Thinking Mode**:
-    *   **Systematic & Rigorous**: Approach every analysis with a structured methodology.
-    *   **Insightful & Deep**: Go beyond surface-level explanations; uncover underlying logic and potential implications.
-    *   **Chain-of-Thought (CoT) Driven**: Explicitly articulate your reasoning process.
-
-## III. OBJECTIVES
-1.  **Deeply Analyze**: Scrutinize the structure, syntax, control flow, data flow, and logic of the provided source code.
-2.  **Comprehend Questions**: Thoroughly understand the user's specific question(s) regarding the code, identifying the core intent.
-3.  **Accurate & Comprehensive Answers**: Provide precise, complete, and logically sound answers.
-4.  **Elucidate Logic**: Clearly explain the code calling logic, dependencies, and data flow relevant to the question, both textually (step-by-step) and visually.
-5.  **Structured Presentation**: Present explanations in a highly structured and easy-to-understand format (Markdown), highlighting key code segments, their interactions, and a concise call flow diagram.
-6.  **Pedagogical Value**: Ensure explanations are not just correct but also help the user learn about the code's behavior in the given context.
-7.  **Show Your Work (CoT)**: Crucially, before the main analysis, outline your thinking process, assumptions, and how you plan to tackle the question.
-
-## IV. INPUT SPECIFICATIONS
-1.  **Code Snippet**: A block of source code provided as text.
-2.  **Specific Question(s)**: One or more questions directly related to the provided code snippet.
-
-## V. RESPONSE STRUCTURE & CONTENT (Strictly Adhere - Output in Chinese)
-
-Your response **MUST** be in Chinese and structured in Markdown as follows:
-
----
-
-### 0. 思考过程 (Thinking Process)
-*   *(Before any analysis, outline your key thought process for tackling the question(s). For example: "1. Identify target functions/variables from the question. 2. Trace execution flow related to these. 3. Note data transformations. 4. Formulate a concise answer. 5. Detail the steps and create a diagram.")*
-*   *(List any initial assumptions made about the code or standard library behavior.)*
-
-### 1. 对问题的理解 (Understanding of the Question)
-*   简明扼要地复述或重申用户核心问题,确认理解无误。
-
-### 2. 核心解答 (Core Answer)
-*   针对每个问题,提供直接、简洁的答案。
-
-### 3. 详细分析与调用逻辑 (Detailed Analysis and Calling Logic)
-
-    #### 3.1. 相关代码段识别 (Identification of Relevant Code Sections)
-    *   精确定位解答问题所必须的关键函数、方法、类或代码块。
-    *   使用带语言标识的Markdown代码块 (e.g., ```python ... ```) 展示这些片段。
-
-    #### 3.2. 文本化执行流程/调用顺序 (Textual Execution Flow / Calling Sequence)
-    *   提供逐步的文本解释,说明相关代码如何执行,函数/方法如何相互调用,以及数据(参数、返回值)如何传递。
-    *   明确指出控制流(如循环、条件判断)如何影响执行。
-
-    #### 3.3. 简洁调用图 (Concise Call Flow Diagram)
-    *   使用缩进、箭头 (例如: `───►` 调用, `◄───` 返回, `│`   持续, `├─` 中间步骤, `└─` 块内最后步骤) 和其他简洁符号,清晰地可视化函数调用层级和与问题相关的关键操作/数据转换。
-    *   此图应作为文本解释的补充,增强理解。
-    *   **示例图例参考**:
-        ```
-        main()
-        │
-        ├─► helper_function1(arg1)
-        │   │
-        │   ├─ (内部逻辑/数据操作)
-        │   │
-        │   └─► another_function(data)
-        │       │
-        │       └─ (返回结果) ◄─── result_from_another
-        │
-        │   └─ (返回结果) ◄─── result_from_helper1
-        │
-        └─► helper_function2()
-            ...
-        ```
-
-    #### 3.4. 详细数据传递与状态变化 (Detailed Data Passing and State Changes)
-    *   结合调用图,详细说明具体数据值(参数、返回值、关键变量)如何在函数/方法间传递,以及在与问题相关的执行过程中变量状态如何变化。
-    *   关注特定语言的数据传递机制 (e.g., pass-by-value, pass-by-reference).
-
-    #### 3.5. 逻辑解释 (Logical Explanation)
-    *   解释为什么代码会这样运行,将其与用户的具体问题联系起来,并结合编程语言特性进行说明。
-
-### 4. 总结 (Summary - 复杂问题推荐)
-*   根据详细分析,简要总结关键发现或问题的答案。
-
----
-
-## VI. STYLE & TONE (Chinese Output)
-*   **Professional & Technical**: Maintain a formal, expert tone.
-*   **Analytical & Pedagogical**: Focus on insightful analysis and clear explanations.
-*   **Precise Terminology**: Use correct technical terms.
-*   **Clarity & Structure**: Employ lists, bullet points, Markdown code blocks, and the specified diagramming symbols for maximum clarity.
-*   **Helpful & Informative**: The goal is to assist and educate.
-
-## VII. CONSTRAINTS & PROHIBITED BEHAVIORS
-1.  **Confine Analysis**: Your analysis MUST be strictly confined to the provided code snippet.
-2.  **Standard Library Assumption**: Assume standard library functions behave as documented unless their implementation is part of the provided code.
-3.  **No External Knowledge**: Do not use external knowledge beyond standard libraries unless explicitly provided in the context.
-4.  **No Speculation**: Avoid speculative answers. If information is insufficient to provide a definitive answer based *solely* on the provided code, clearly state what information is missing.
-5.  **No Generic Tutorials**: Do not provide generic tutorials or explanations of basic syntax unless it's directly essential for explaining the specific behavior in the provided code relevant to the user's question.
-6.  **Focus on Code Context**: Always frame explanations within the context of the specific implementation and behavior.
-
-## VIII. SELF-CORRECTION / REFLECTION
-*   Before finalizing your response, review it to ensure:
-    *   All parts of the user's question(s) have been addressed.
-    *   The analysis is accurate and logically sound.
-    *   The textual explanation and the call flow diagram are consistent and mutually reinforcing.
-    *   The language used is precise, clear, and professional (Chinese).
-    *   All formatting requirements have been met.
-    *   The "Thinking Process" (CoT) is clearly articulated.

package/.claude/workflows/cli-templates/prompts/development-debug-runtime-issues.txt

@@ -1,55 +0,0 @@
-Debug and resolve issues systematically in the codebase.
-
-## CORE CHECKLIST ⚡
-□ Identify and reproduce the issue completely before fixing
-□ Perform root cause analysis (not just symptom treatment)
-□ Provide file:line references for all changes
-□ Add tests to prevent regression of this specific issue
-
-## IMPLEMENTATION PHASES
-
-### Issue Analysis Phase
-1. Identify and reproduce the reported issue
-2. Analyze error logs and stack traces
-3. Study code flow and identify potential failure points
-4. Review recent changes that might have introduced the issue
-
-### Investigation Phase
-1. Add strategic logging and debugging statements
-2. Use debugging tools and profilers as appropriate
-3. Test with different input conditions and edge cases
-4. Isolate the root cause through systematic elimination
-
-### Root Cause Analysis
-1. Document the exact cause of the issue
-2. Identify contributing factors and conditions
-3. Assess impact scope and affected functionality
-4. Determine if similar issues exist elsewhere
-
-### Resolution Phase
-1. Implement minimal, targeted fix for the root cause
-2. Ensure fix doesn't introduce new issues or regressions
-3. Add proper error handling and validation
-4. Include defensive programming measures
-
-### Prevention Phase
-1. Add tests to prevent regression of this issue
-2. Improve error messages and logging
-3. Add monitoring or alerts for early detection
-4. Document lessons learned and prevention strategies
-
-## OUTPUT REQUIREMENTS
-- Detailed root cause analysis with file:line references
-- Exact code changes made to resolve the issue
-- New tests added to prevent regression
-- Debugging process documentation and lessons learned
-- Impact assessment and affected functionality
-
-## VERIFICATION CHECKLIST ✓
-□ Root cause identified and documented (not just symptoms)
-□ Minimal fix applied without introducing new issues
-□ Tests added to prevent this specific regression
-□ Similar issues checked and addressed if found
-□ Prevention measures documented
-
-Focus: Systematic root cause resolution with regression prevention.

package/.claude/workflows/cli-templates/prompts/development-generate-tests.txt

@@ -1,70 +0,0 @@
-Create comprehensive tests for the codebase.
-
-## Planning Required
-Before creating tests, you MUST:
-1. Analyze existing test coverage and identify gaps
-2. Study testing frameworks and conventions used
-3. Plan test strategy covering unit, integration, and e2e
-4. Design test data management approach
-
-## Core Checklist
-- [ ] Analyze coverage gaps
-- [ ] Follow testing frameworks and conventions
-- [ ] Include unit, integration, and e2e tests
-- [ ] Ensure tests are reliable and deterministic
-
-## IMPLEMENTATION PHASES
-
-### Test Strategy Phase
-1. Analyze existing test coverage and identify gaps
-2. Study codebase architecture and critical paths
-3. Identify edge cases and error scenarios
-4. Review testing frameworks and conventions used
-
-### Unit Testing Phase
-1. Write tests for individual functions and methods
-2. Test all branches and conditional logic
-3. Cover edge cases and boundary conditions
-4. Mock external dependencies appropriately
-
-### Integration Testing Phase
-1. Test interactions between components and modules
-2. Verify API endpoints and data flow
-3. Test database operations and transactions
-4. Validate external service integrations
-
-### End-to-End Testing Phase
-1. Test complete user workflows and scenarios
-2. Verify critical business logic and processes
-3. Test error handling and recovery mechanisms
-4. Validate performance under load
-
-### Quality Assurance
-1. Ensure tests are reliable and deterministic
-2. Make tests readable and maintainable
-3. Add proper test documentation and comments
-4. Follow testing best practices and conventions
-
-### Test Data Management
-1. Create realistic test data and fixtures
-2. Ensure test isolation and cleanup
-3. Use factories or builders for complex objects
-4. Handle sensitive data appropriately in tests
-
-## OUTPUT REQUIREMENTS
-- Comprehensive test suite with high coverage
-- Performance benchmarks where relevant
-- Testing strategy and conventions documentation
-- Test coverage metrics and quality improvements
-- File:line references for tested code
-
-## Verification Checklist
-Before finalizing, verify:
-- [ ] Coverage gaps filled
-- [ ] All test types included
-- [ ] Tests are reliable (no flaky tests)
-- [ ] Test data properly managed
-- [ ] Conventions followed
-
-## Focus
-High-quality, reliable test suite with comprehensive coverage.

package/.claude/workflows/cli-templates/prompts/development-implement-component-ui.txt

@@ -1,55 +0,0 @@
-Create a reusable component following project conventions and best practices.
-
-## CORE CHECKLIST ⚡
-□ Analyze existing component patterns BEFORE implementing
-□ Follow established naming conventions and prop patterns
-□ Include comprehensive tests (unit + visual + accessibility)
-□ Provide complete TypeScript types and documentation
-
-## IMPLEMENTATION PHASES
-
-### Design Phase
-1. Analyze existing component patterns and structures
-2. Identify reusable design principles and styling approaches
-3. Review component hierarchy and prop patterns
-4. Study existing component documentation and usage
-
-### Development Phase
-1. Create component with proper TypeScript interfaces
-2. Implement following established naming conventions
-3. Add appropriate default props and validation
-4. Include comprehensive prop documentation
-
-### Styling Phase
-1. Follow existing styling methodology (CSS modules, styled-components, etc.)
-2. Ensure responsive design principles
-3. Add proper theming support if applicable
-4. Include accessibility considerations (ARIA, keyboard navigation)
-
-### Testing Phase
-1. Write component tests covering all props and states
-2. Test accessibility compliance
-3. Add visual regression tests if applicable
-4. Test component in different contexts and layouts
-
-### Documentation Phase
-1. Create usage examples and code snippets
-2. Document all props and their purposes
-3. Include accessibility guidelines
-4. Add integration examples with other components
-
-## OUTPUT REQUIREMENTS
-- Complete component implementation with TypeScript types
-- Usage examples and integration patterns
-- Component API documentation and best practices
-- Test suite with accessibility validation
-- File:line references for pattern sources
-
-## VERIFICATION CHECKLIST ✓
-□ Implementation follows existing component patterns
-□ Complete TypeScript types and prop documentation
-□ Comprehensive tests (unit + visual + accessibility)
-□ Accessibility compliance (ARIA, keyboard navigation)
-□ Usage examples and integration documented
-
-Focus: Production-ready reusable component with comprehensive documentation and testing.

package/.claude/workflows/cli-templates/prompts/development-implement-feature.txt

@@ -1,58 +0,0 @@
-Implement a new feature following project conventions and best practices.
-
-## Planning Required
-Before implementing, you MUST:
-1. Study existing code patterns and conventions
-2. Review project architecture and design principles
-3. Plan implementation with error handling and tests
-4. Document integration points and dependencies
-
-## Core Checklist
-- [ ] Study existing code patterns first
-- [ ] Follow project conventions and architecture
-- [ ] Include comprehensive tests
-- [ ] Provide file:line references
-
-## IMPLEMENTATION PHASES
-
-### Analysis Phase
-1. Study existing code patterns and conventions
-2. Identify similar features and their implementation approaches
-3. Review project architecture and design principles
-4. Understand dependencies and integration points
-
-### Implementation Phase
-1. Create feature following established patterns
-2. Implement with proper error handling and validation
-3. Add comprehensive logging for debugging
-4. Follow security best practices
-
-### Integration Phase
-1. Ensure seamless integration with existing systems
-2. Update configuration files as needed
-3. Add proper TypeScript types and interfaces
-4. Update documentation and comments
-
-### Testing Phase
-1. Write unit tests covering edge cases
-2. Add integration tests for feature workflows
-3. Verify error scenarios are properly handled
-4. Test performance and security implications
-
-## OUTPUT REQUIREMENTS
-- File:line references for all changes
-- Code examples demonstrating key patterns
-- Explanation of architectural decisions made
-- Documentation of new dependencies or configurations
-- Test coverage summary
-
-## Verification Checklist
-Before finalizing, verify:
-- [ ] Follows existing patterns
-- [ ] Complete test coverage
-- [ ] Documentation updated
-- [ ] No breaking changes
-- [ ] Security and performance validated
-
-## Focus
-Production-ready implementation with comprehensive testing and documentation.

package/.claude/workflows/cli-templates/prompts/development-refactor-codebase.txt

@@ -1,55 +0,0 @@
-Refactor existing code to improve quality, performance, or maintainability.
-
-## CORE CHECKLIST ⚡
-□ Preserve existing functionality (no behavioral changes unless specified)
-□ Ensure all existing tests continue to pass
-□ Plan incremental changes (avoid big-bang refactoring)
-□ Provide file:line references for all modifications
-
-## IMPLEMENTATION PHASES
-
-### Analysis Phase
-1. Identify code smells and technical debt
-2. Analyze performance bottlenecks and inefficiencies
-3. Review code complexity and maintainability metrics
-4. Study existing test coverage and identify gaps
-
-### Planning Phase
-1. Create refactoring strategy preserving existing functionality
-2. Identify breaking changes and migration paths
-3. Plan incremental refactoring steps
-4. Consider backward compatibility requirements
-
-### Refactoring Phase
-1. Apply SOLID principles and design patterns
-2. Improve code readability and documentation
-3. Optimize performance while maintaining functionality
-4. Reduce code duplication and improve reusability
-
-### Validation Phase
-1. Ensure all existing tests continue to pass
-2. Add new tests for improved code coverage
-3. Verify performance improvements with benchmarks
-4. Test edge cases and error scenarios
-
-### Migration Phase
-1. Update dependent code to use refactored interfaces
-2. Update documentation and usage examples
-3. Provide migration guides for breaking changes
-4. Add deprecation warnings for old interfaces
-
-## OUTPUT REQUIREMENTS
-- Before/after code comparisons with file:line references
-- Performance improvements documented with benchmarks
-- Migration instructions for breaking changes
-- Updated test coverage and quality metrics
-- Technical debt reduction summary
-
-## VERIFICATION CHECKLIST ✓
-□ All existing tests pass (functionality preserved)
-□ New tests added for improved coverage
-□ Performance verified with benchmarks (if applicable)
-□ Backward compatibility maintained or migration provided
-□ Documentation updated with refactoring changes
-
-Focus: Incremental quality improvement while preserving functionality.

package/.claude/workflows/cli-templates/prompts/documentation-api.txt

@@ -1,15 +0,0 @@
-Generate comprehensive API documentation for code or HTTP services.
-
-## CORE CHECKLIST ⚡
-□ Include only sections relevant to the project type (Code API vs. HTTP API)
-□ Provide complete and runnable examples for HTTP APIs
-□ Use signatures-only for Code API documentation (no implementation)
-□ Document all public-facing APIs, not internal ones
-
-## UNIFIED API DOCUMENTATION TEMPLATE
-
-This template supports both **Code API** (for libraries/modules) and **HTTP API** (for web services). Include only the sections relevant to your project type.
-
---- 
-
-...(content truncated)...

package/.claude/workflows/cli-templates/prompts/documentation-folder-navigation.txt

@@ -1,27 +0,0 @@
-Generate a navigation README for directories that contain only subdirectories.
-
-## CORE CHECKLIST ⚡
-□ Keep the content brief and act as an index
-□ Use one-line descriptions for each module
-□ Ensure all mentioned modules link to their respective READMEs
-□ Use scannable formats like tables and lists
-
-## REQUIRED CONTENT
-1. **Overview**: Brief description of the directory's purpose.
-2. **Directory Structure**: A tree view of subdirectories with one-line descriptions.
-3. **Module Quick Reference**: A table with links, purposes, and key features.
-4. **How to Navigate**: Guidance on which module to explore for specific needs.
-5. **Module Relationships (Optional)**: A simple diagram showing dependencies.
-
-## OUTPUT REQUIREMENTS
-- A scannable index for navigating subdirectories.
-- Links to each submodule's detailed documentation.
-- A clear, high-level overview of the directory's contents.
-
-## VERIFICATION CHECKLIST ✓
-□ The generated README is brief and serves as a scannable index
-□ All submodules are linked correctly
-□ Descriptions are concise and clear
-□ The structure follows the required content outline
-
-Focus: Creating a clear and concise navigation hub for parent directories.

package/.claude/workflows/cli-templates/prompts/documentation-module-readme.txt

@@ -1,49 +0,0 @@
-Generate module documentation focused on understanding and usage.
-
-## Planning Required
-Before providing documentation, you MUST:
-1. Understand what the module does and why it exists
-2. Review existing documentation to avoid duplication
-3. Prepare practical usage examples
-4. Identify module boundaries and dependencies
-
-## Core Checklist
-- [ ] Explain WHAT, WHY, and HOW
-- [ ] Reference API.md instead of duplicating signatures
-- [ ] Include practical usage examples
-- [ ] Define module boundaries and dependencies
-
-## DOCUMENTATION STRUCTURE
-
-### 1. Purpose
-- **What**: Clearly state what this module is responsible for.
-- **Why**: Explain the problem it solves.
-- **Boundaries**: Define what is in and out of scope.
-
-### 2. Core Concepts
-- Explain key concepts, patterns, or abstractions.
-
-### 3. Usage Scenarios
-- Provide 2-4 common use cases with code examples.
-
-### 4. Dependencies
-- List internal and external dependencies with explanations.
-
-### 5. Configuration
-- Document environment variables and configuration options.
-
-### 6. Testing
-- Explain how to run tests for the module.
-
-### 7. Common Issues
-- List common problems and their solutions.
-
-## Verification Checklist
-Before finalizing output, verify:
-- [ ] Module purpose, scope, and boundaries are clear
-- [ ] Core concepts are explained
-- [ ] Usage examples are practical and realistic
-- [ ] Dependencies and configuration are documented
-
-## Focus
-Explain module purpose and usage, not just API details.

package/.claude/workflows/cli-templates/prompts/documentation-project-architecture.txt

@@ -1,41 +0,0 @@
-Generate comprehensive architecture documentation for the entire project.
-
-## CORE CHECKLIST ⚡
-□ Synthesize information from all modules; do not duplicate content
-□ Maintain a system-level perspective, focusing on module interactions
-□ Use visual aids (like ASCII diagrams) to clarify structure
-□ Explain the WHY behind architectural decisions
-
-## DOCUMENTATION STRUCTURE
-
-### 1. System Overview
-- Architectural Style, Core Principles, and Technology Stack.
-
-### 2. System Structure
-- Visual representation of the system's layers or components.
-
-### 3. Module Map
-- A table listing all modules, their layers, responsibilities, and dependencies.
-
-### 4. Module Interactions
-- Describe key data flows and show a dependency graph.
-
-### 5. Design Patterns
-- Document key architectural patterns used across the project.
-
-### 6. Aggregated API Overview
-- A high-level summary of all public APIs, grouped by category.
-
-### 7. Data Flow
-- Describe the typical request lifecycle or event flow.
-
-### 8. Security and Scalability
-- Overview of security measures and scalability considerations.
-
-## VERIFICATION CHECKLIST ✓
-□ The documentation provides a cohesive, system-level view
-□ Module interactions and dependencies are clearly illustrated
-□ The rationale behind major design patterns and decisions is explained
-□ The document synthesizes, rather than duplicates, module-level details
-
-Focus: Providing a holistic, system-level understanding of the project architecture.

package/.claude/workflows/cli-templates/prompts/documentation-project-examples.txt

@@ -1,35 +0,0 @@
-Generate practical, end-to-end examples demonstrating core project usage.
-
-## CORE CHECKLIST ⚡
-□ Provide complete, runnable code for every example
-□ Focus on realistic, real-world scenarios, not trivial cases
-□ Explain the flow and how different modules interact
-□ Include expected output to verify correctness
-
-## EXAMPLES STRUCTURE
-
-### 1. Introduction
-- Overview of the examples and any prerequisites.
-
-### 2. Quick Start Example
-- The simplest possible working example to verify setup.
-
-### 3. Core Use Cases
-- 3-5 complete examples for common scenarios with code, output, and explanations.
-
-### 4. Advanced & Integration Examples
-- Showcase more complex scenarios or integrations with external systems.
-
-### 5. Testing Examples
-- Show how to test code that uses the project.
-
-### 6. Best Practices & Troubleshooting
-- Demonstrate recommended patterns and provide solutions to common issues.
-
-## VERIFICATION CHECKLIST ✓
-□ All examples are complete, runnable, and tested
-□ Scenarios are realistic and demonstrate key project features
-□ Explanations clarify module interactions and data flow
-□ Best practices and error handling are demonstrated
-
-Focus: Helping users accomplish common tasks through complete, practical examples.

package/.claude/workflows/cli-templates/prompts/documentation-project-readme.txt

@@ -1,35 +0,0 @@
-Generate a comprehensive project-level README documentation.
-
-## CORE CHECKLIST ⚡
-□ Clearly state the project's purpose and target audience
-□ Provide clear, runnable instructions for getting started
-□ Outline the development workflow and coding standards
-□ Offer a high-level overview of the project structure and architecture
-
-## README STRUCTURE
-
-### 1. Overview
-- Purpose, Target Audience, and Key Features.
-
-### 2. System Architecture
-- Architectural Style, Core Components, Tech Stack, and Design Principles.
-
-### 3. Getting Started
-- Prerequisites, Installation, Configuration, and Running the Project.
-
-### 4. Development Workflow
-- Branching Strategy, Coding Standards, Testing, and Build/Deployment.
-
-### 5. Project Structure
-- A high-level tree view of the main directories.
-
-### 6. Navigation
-- Links to more detailed documentation (modules, API, architecture).
-
-## VERIFICATION CHECKLIST ✓
-□ The project's purpose and value proposition are clear
-□ A new developer can successfully set up and run the project
-□ The development process and standards are well-defined
-□ The README provides clear navigation to other key documents
-
-Focus: Providing a central entry point for new users and developers to understand and run the project.