thanh-kit 2.5.1 → 2.5.2

package/templates/commands/investigate.md

@@ -1,324 +0,0 @@
-# Investigate Feature: $ARGUMENTS
-
-Investigate and explain how an existing feature or logic works using structured knowledge model construction.
-
-**KEY PRINCIPLE**: This is a **READ-ONLY exploration** - no code changes. Focus on understanding and explaining.
-
-## Variables
-
-- **FEATURE**: $ARGUMENTS (the feature/logic to investigate)
-- **ANALYSIS_FILE**: `ai_task_analysis_notes/$ARGUMENTS-investigation.ai_task_analysis_notes_temp.md`
-
----
-
-## INPUT: Scout Output Integration
-
-**If preceded by `/scout`:**
-
-1. **Use the numbered file list** from Scout results as your analysis targets
-2. **Prioritize in this order:**
-   - HIGH PRIORITY files (Domain Entities, Commands, Queries, Event Handlers, Controllers, Jobs, Consumers)
-   - Suggested Starting Points (if provided)
-   - MEDIUM PRIORITY files (Services, Helpers, Components)
-3. **Skip redundant discovery** - Scout already searched the codebase
-4. **Reference files by Scout's numbers** in your analysis (e.g., "File #3 from Scout")
-
-**Scout Output Format Reference:**
-```markdown
-### HIGH PRIORITY (Analyze First)
-| # | File | Purpose |
-|---|------|---------|
-| 1 | `path/Entity.cs` | Core domain entity |
-
-### Suggested Starting Points
-1. **[Most relevant file]** - [Why]
-```
-
-**If NO Scout output available:** Proceed with Phase 1A discovery as normal.
-
----
-
-## PHASE 1A: INITIALIZATION AND DISCOVERY
-
-### Step 1: Initialize Analysis File
-
-Create the analysis file at `ai_task_analysis_notes/[feature-name]-investigation.ai_task_analysis_notes_temp.md` with these required sections:
-
-```markdown
-## Metadata
-
-```markdown
-**Original Prompt:** [User's investigation question]
-**Task Description:** [What we're investigating]
-**Source Code Structure:** See ai-prompt-context.md
-```
-
-## Progress
-
-- **Phase**: 1A
-- **Items Processed**: 0
-- **Total Items**: 0
-- **Current Operation**: "initialization"
-- **Current Focus**: "[feature summary]"
-
-## Errors
-
-[None yet]
-
-## Assumption Validations
-
-| Assumption | Status | Evidence |
-|------------|--------|----------|
-| ... | Pending/Validated/Invalid | ... |
-
-## File List
-
-[Numbered list of files to analyze]
-
-## Knowledge Graph
-
-[Detailed analysis of each file]
-```
-
-### Step 2: Semantic Discovery
-
-Search for related code using multiple patterns:
-
-**Primary Patterns:**
-```
-*Command*{Feature}*           # CQRS Commands
-*Query*{Feature}*             # CQRS Queries
-*{Feature}*EventHandler*      # Entity Event Handlers
-*{Feature}*Consumer*          # Message Bus Consumers
-*{Feature}*BackgroundJob*     # Background Jobs
-*{Feature}*Controller*        # API Controllers
-```
-
-**Secondary Patterns:**
-```
-.*EventHandler.*{Feature}|{Feature}.*EventHandler
-.*BackgroundJob.*{Feature}|{Feature}.*BackgroundJob
-.*Consumer.*{Feature}|{Feature}.*Consumer
-.*Service.*{Feature}|{Feature}.*Service
-.*Helper.*{Feature}|{Feature}.*Helper
-```
-
-**File Types:** `**/*.{cs,ts,html}`
-
-### Step 3: Prioritize Files
-
-**HIGH PRIORITY (Must Analyze):**
-1. Domain Entities (`Domain/Entities/`)
-2. CQRS Commands (`UseCaseCommands/`)
-3. CQRS Queries (`UseCaseQueries/`)
-4. Entity Event Handlers (`UseCaseEvents/`)
-5. Controllers (`Controllers/`)
-6. Background Jobs (`*BackgroundJob*.cs`)
-7. Message Bus Consumers (`*Consumer.cs`)
-8. Frontend Components (`*.component.ts`)
-
-**MEDIUM PRIORITY:**
-- Services, Helpers, DTOs, Repositories
-
-Save ALL file paths as numbered list under `## File List` in analysis file.
-
----
-
-## PHASE 1B: KNOWLEDGE GRAPH CONSTRUCTION
-
-### Step 1: Batch Processing Setup
-
-Count total files, split into batches of 10. Use TodoWrite to create tasks:
-
-```
-- [ ] Analyze batch 1 (files 1-10)
-- [ ] Analyze batch 2 (files 11-20)
-...
-```
-
-### Step 2: File Analysis Schema
-
-For each file, add to `## Knowledge Graph` with this structure:
-
-```markdown
-### [#] [FileName]
-
-- **filePath**: Full path to file
-- **type**: Entity | Command | Query | EventHandler | Consumer | Controller | Job | Component | Service
-- **architecturalPattern**: CQRS | Repository | EventSourcing | MessageBus | etc.
-- **content**: Summary of purpose and logic
-- **symbols**: Key classes, interfaces, methods
-- **dependencies**: Imported modules / using statements
-- **businessContext**: How it contributes to business requirements
-- **referenceFiles**: Other files using this file's symbols
-- **relevanceScore**: 1-10 (10 = most relevant)
-- **evidenceLevel**: verified | inferred
-- **uncertainties**: Aspects you're unsure about
-- **platformAbstractions**: Base classes used (PlatformCqrsCommand, PlatformEntity, etc.)
-- **serviceContext**: Which microservice owns this
-- **dependencyInjection**: DI registrations
-- **genericTypeParameters**: Generic type relationships
-
-#### Targeted Analysis
-
-**For Backend:**
-- authorizationPolicies, commands, queries, domainEntities
-- repositoryPatterns, businessRuleImplementations
-
-**For Consumers:**
-- messageBusMessage: The `*BusMessage` type consumed
-- messageBusProducers: Files that SEND this message (grep across ALL services)
-- crossServiceIntegration: How services communicate
-
-**For Frontend:**
-- componentHierarchy, routeConfig, stateManagementStores
-- dataBindingPatterns, validationStrategies
-```
-
-### Step 3: Cross-Service Analysis (CRITICAL for Consumers)
-
-When analyzing `*Consumer.cs` files extending `PlatformApplicationMessageBusConsumer<T>`:
-
-1. Identify the `*BusMessage` type
-2. Grep search ALL services for files that **publish** this message
-3. Document producer files and their service locations
-4. Map the cross-service data flow
-
----
-
-## PHASE 2: CODE FLOW TRACING
-
-### Step 1: Entry Points
-
-Identify how the feature is triggered:
-- API Endpoint → Controller → Command/Query Handler
-- UI Action → Component → API Service → Backend
-- Scheduled Job → BackgroundJob → Handler
-- Message → Consumer → Handler
-
-### Step 2: Trace Execution Path
-
-Document in analysis file:
-
-```markdown
-## Data Flow
-
-[Request] → [Controller] → [Handler] → [Repository] → [Response]
-                              ↓
-                       [Event Handler] → [Side Effects]
-                              ↓
-                       [Message Bus] → [Consumer in Other Service]
-```
-
-### Step 3: Side Effects Mapping
-
-- Entity events raised
-- Messages published to bus
-- External service calls
-- Database operations
-- Notifications triggered
-
----
-
-## PHASE 3: PRESENT FINDINGS
-
-### Output Format
-
-```markdown
-## Executive Summary
-
-[1-2 paragraph direct answer to the investigation question]
-
-## How It Works
-
-### 1. [Entry Point]
-[Explanation with `file:line` reference]
-
-### 2. [Core Processing]
-[Explanation with `file:line` reference]
-
-### 3. [Side Effects]
-[Explanation with `file:line` reference]
-
-## Key Files
-
-| File | Type | Purpose | Relevance |
-|------|------|---------|-----------|
-| `path/file.cs:123` | Command | [Purpose] | 10/10 |
-
-## Data Flow Diagram
-
-```
-[Visual text diagram of the flow]
-```
-
-## Platform Patterns Used
-
-- **Pattern**: How it's applied
-- **Pattern**: How it's applied
-
-## Cross-Service Integration
-
-| Source Service | Message | Target Service | Consumer |
-|----------------|---------|----------------|----------|
-| ... | ... | ... | ... |
-
-## Unresolved Questions
-
-- [Question 1]
-- [Question 2]
-
-## Want to Know More?
-
-- [Related topic 1]
-- [Related topic 2]
-```
-
----
-
-## Anti-Hallucination Protocol
-
-Before ANY claim, verify:
-
-1. "What assumptions am I making?"
-2. "Have I verified with actual code evidence?"
-3. "Could I be wrong about how this works?"
-
-### Verification Checklist
-
-- [ ] Found actual code evidence for each claim?
-- [ ] Traced the full code path?
-- [ ] Checked cross-service message flows?
-- [ ] Documented ALL findings with `file:line`?
-- [ ] Answered the original question?
-- [ ] Listed unresolved questions?
-
-**If ANY unchecked → DO MORE INVESTIGATION**
-
----
-
-## Progress Tracking
-
-Update `## Progress` section after each batch:
-
-```markdown
-- **Phase**: 1B
-- **Items Processed**: 20
-- **Total Items**: 35
-- **Current Operation**: "analyzing batch 3"
-- **Current Focus**: "Event Handlers"
-```
-
----
-
-## Quick Reference
-
-| Looking for... | Search in... |
-|----------------|--------------|
-| Entity CRUD | `UseCaseCommands/`, `UseCaseQueries/` |
-| Business logic | `Domain/Entities/`, `*Service.cs` |
-| Side effects | `UseCaseEvents/`, `*EventHandler.cs` |
-| Cross-service | `*Consumer.cs`, `*BusMessage.cs` |
-| API endpoints | `Controllers/`, `*Controller.cs` |
-| Frontend | `libs/apps-domains/`, `*.component.ts` |
-| Background processing | `*BackgroundJob*.cs`, `*Job.cs` |

package/templates/commands/journal.md

@@ -1,7 +0,0 @@
----
-description: ⚡ Write some journal entries.
----
-
-Use the `journal-writer` subagent to explore the memories and recent code changes, and write some journal entries.
-Journal entries should be concise and focused on the most important events, key changes, impacts, and decisions.
-Keep journal entries in the `./docs/journals/` directory.

package/templates/commands/lint.md

@@ -1,47 +0,0 @@
----
-description: Run linters and fix issues for backend or frontend
-allowed-tools: Bash, Read, Edit, Glob, TodoWrite
----
-
-Run linting: $ARGUMENTS
-
-## Instructions
-
-1. **Parse arguments**:
-   - `backend` or `be` → Run .NET analyzers
-   - `frontend` or `fe` → Run ESLint/Prettier
-   - `fix` → Auto-fix issues where possible
-   - No argument → Run both, report only
-
-2. **For Backend (.NET)**:
-
-   ```bash
-   dotnet build EasyPlatform.sln /p:TreatWarningsAsErrors=false
-   ```
-
-   - Check for analyzer warnings (CA*, IDE*, etc.)
-   - Report code style violations
-
-3. **For Frontend (Angular/Nx)**:
-
-   ```bash
-   cd src/PlatformExampleAppWeb
-   nx lint playground-text-snippet
-   nx lint platform-core
-   ```
-
-   With auto-fix:
-
-   ```bash
-   nx lint playground-text-snippet --fix
-   npx prettier --write "apps/**/*.{ts,html,scss}" "libs/**/*.{ts,html,scss}"
-   ```
-
-4. **Report format**:
-   - Group issues by severity (error, warning, info)
-   - Show file paths and line numbers
-   - Suggest fixes for common issues
-
-5. **Auto-fix behavior**:
-   - If `fix` argument provided, apply safe auto-fixes
-   - Report what was fixed vs what needs manual attention

package/templates/commands/migration.md

@@ -1,111 +0,0 @@
-# Create Migration: $ARGUMENTS
-
-Create a data or schema migration following EasyPlatform patterns.
-
-## Phase 1: Analyze Requirements
-
-1. **Parse migration description** from: $ARGUMENTS
-2. **Identify migration type:**
-    - Schema migration (EF Core) - for SQL Server/PostgreSQL table changes
-    - Data migration (PlatformDataMigrationExecutor) - for data transformations
-    - MongoDB migration (PlatformMongoMigrationExecutor) - for MongoDB changes
-
-3. **Search for existing patterns:**
-    - `src/PlatformExampleApp/*/Persistence/Migrations/` for schema migrations
-    - Search for `PlatformDataMigrationExecutor` implementations
-
-## Phase 2: Design Migration
-
-1. **Determine affected entities and tables**
-2. **Plan rollback strategy if applicable**
-3. **Consider data volume and performance:**
-    - Use paging for large datasets (PageSize: 200-500)
-    - Set `dismissSendEvent: true` if entity events not needed
-    - Use `checkDiff: false` for bulk updates
-
-## Phase 3: Generate Migration
-
-Follow naming convention: `YYYYMMDDHHMMSS_MigrationName`
-
-**For EF Core Schema Migration:**
-
-```bash
-dotnet ef migrations add MigrationName --project src/PlatformExampleApp/{Service}/{Service}.Persistence
-```
-
-**For Data Migration (SQL Server/PostgreSQL):**
-
-```csharp
-public class YYYYMMDDHHMMSS_MigrationName : PlatformDataMigrationExecutor<{Service}DbContext>
-{
-    public override string Name => "YYYYMMDDHHMMSS_MigrationName";
-    public override DateTime? OnlyForDbsCreatedBeforeDate => new(YYYY, MM, DD);
-    public override bool AllowRunInBackgroundThread => true;
-
-    public override async Task Execute({Service}DbContext dbContext)
-    {
-        var queryBuilder = repository.GetQueryBuilder(q => q.Where(FilterExpr()));
-        await RootServiceProvider.ExecuteInjectScopedPagingAsync(
-            maxItemCount: await repository.CountAsync(q => queryBuilder(q)),
-            pageSize: 200,
-            ExecutePaging,
-            queryBuilder);
-    }
-
-    private static async Task<List<Entity>> ExecutePaging(
-        int skip, int take,
-        Func<IQueryable<Entity>, IQueryable<Entity>> qb,
-        IRepo<Entity> repo,
-        IPlatformUnitOfWorkManager uow)
-    {
-        using var unitOfWork = uow.Begin();
-        var items = await repo.GetAllAsync(q => qb(q).OrderBy(e => e.Id).Skip(skip).Take(take));
-        // Apply transformations
-        await repo.UpdateManyAsync(items, dismissSendEvent: true, checkDiff: false);
-        await unitOfWork.CompleteAsync();
-        return items;
-    }
-}
-```
-
-**For MongoDB Migration:**
-
-```csharp
-internal sealed class YYYYMMDDHHMMSS_MigrationName : PlatformMongoMigrationExecutor<{Service}DbContext>
-{
-    public override string Name => "YYYYMMDDHHMMSS_MigrationName";
-    public override DateTime? OnlyForDbInitBeforeDate => new(YYYY, MM, DD);
-    public override DateTime? ExpirationDate => new(YYYY, MM, DD); // Optional: auto-delete after date
-
-    public override async Task Execute({Service}DbContext dbContext)
-    {
-        // Ensure indexes
-        await dbContext.EnsureInboxBusMessageCollectionIndexesAsync(true);
-        await dbContext.EnsureOutboxBusMessageCollectionIndexesAsync(true);
-
-        // Or custom index/data operations
-        var collection = dbContext.GetCollection<Entity>();
-        await collection.Indexes.CreateOneAsync(
-            new CreateIndexModel<Entity>(
-                Builders<Entity>.IndexKeys.Ascending(e => e.Field),
-                new CreateIndexOptions { Unique = true }));
-    }
-}
-```
-
-## Phase 4: Verify
-
-- [ ] Migration is idempotent (safe to run multiple times)
-- [ ] Large datasets use paging
-- [ ] Proper error handling
-- [ ] Unit of work for transactions
-- [ ] `OnlyForDbsCreatedBeforeDate` set correctly
-- [ ] Tested with sample data
-
-## Phase 5: Wait for Approval
-
-**CRITICAL:** Present your migration design and wait for explicit user approval before creating files.
-
----
-
-Use `backend-data-migration` skill for detailed guidance.

package/templates/commands/performance.md

@@ -1,110 +0,0 @@
-# Analyze Performance: $ARGUMENTS
-
-Analyze and optimize performance for: $ARGUMENTS
-
-## Phase 1: Identify Bottleneck Type
-
-1. **Database queries:**
-    - N+1 query problems
-    - Missing indexes
-    - Inefficient projections
-    - Full table scans
-
-2. **API endpoint latency:**
-    - Serialization overhead
-    - Unnecessary data loading
-    - Missing caching
-    - Sequential operations that could be parallel
-
-3. **Frontend rendering:**
-    - Excessive change detection
-    - Large component trees
-    - Missing OnPush strategy
-    - Unnecessary re-renders
-
-4. **Memory issues:**
-    - Subscription leaks
-    - Large object retention
-    - Missing cleanup in ngOnDestroy
-
-## Phase 2: Investigation
-
-### Backend Analysis
-
-1. **Check repository patterns:**
-
-    ```csharp
-    // ✅ Eager load related entities
-    await repository.GetAllAsync(expr, ct, e => e.RelatedEntity, e => e.AnotherRelated)
-
-    // ❌ N+1 problem - separate query per item
-    foreach (item in items) { await repo.GetById(item.RelatedId) }
-    ```
-
-2. **Review query builders:**
-
-    ```csharp
-    // ✅ Use projections to reduce data transfer
-    .Select(e => new { e.Id, e.Name, e.Status })
-
-    // ❌ Loading full entities when only IDs needed
-    .Select(e => e).ToList().Select(e => e.Id)
-    ```
-
-3. **Check for parallel operations:**
-
-    ```csharp
-    // ✅ Parallel tuple queries
-    var (total, items, counts) = await (
-        repository.CountAsync(queryBuilder, ct),
-        repository.GetAllAsync(queryBuilder.PageBy(skip, take), ct),
-        repository.GetGroupedCountsAsync(queryBuilder, ct)
-    );
-
-    // ❌ Sequential when independent
-    var total = await repository.CountAsync(queryBuilder, ct);
-    var items = await repository.GetAllAsync(queryBuilder.PageBy(skip, take), ct);
-    ```
-
-4. **Review full-text search usage:**
-    ```csharp
-    // ✅ Use IPlatformFullTextSearchPersistenceService
-    .PipeIf(searchText.IsNotNullOrEmpty(), q =>
-        searchService.Search(q, searchText, Entity.SearchColumns()))
-    ```
-
-### Frontend Analysis
-
-1. **Check signal usage and change detection**
-2. **Review store patterns for unnecessary emissions**
-3. **Verify `untilDestroyed()` on all subscriptions**
-4. **Check for `trackBy` in `@for` loops**
-5. **Review `observerLoadingErrorState` usage**
-
-## Phase 3: Profiling Commands
-
-```bash
-# Backend - Check EF Core query logging
-# Enable in appsettings.Development.json:
-# "Logging": { "LogLevel": { "Microsoft.EntityFrameworkCore.Database.Command": "Information" } }
-
-# Frontend - Angular DevTools profiler
-# Use Angular DevTools Chrome extension
-```
-
-## Phase 4: Optimization Plan
-
-Present findings with:
-
-- Current performance metrics (if measurable)
-- Root cause identification with file:line references
-- Targeted fix recommendations
-- Expected improvement rationale
-
-## Phase 5: Wait for Approval
-
-**CRITICAL:** Present your findings and optimization plan. Wait for explicit user approval before making changes.
-
----
-
-Use `arch-performance-optimization` skill for detailed guidance.

package/templates/commands/plan/ci.md

@@ -1,33 +0,0 @@
----
-description: Analyze Github Actions logs and provide a plan to fix the issues
-argument-hint: [github-actions-url]
----
-
-Activate `planning` skill.
-
-## Github Actions URL
- $ARGUMENTS
-
-Use the `planner` subagent to read the github actions logs, analyze and find the root causes of the issues, then provide a detailed plan for implementing the fixes.
-
-**Plan File Specification:**
-- Every `plan.md` MUST start with YAML frontmatter:
-  ```yaml
-  ---
-  title: "{Brief title}"
-  description: "{One sentence for card preview}"
-  status: pending
-  priority: P1
-  effort: {estimated fix time}
-  branch: {current git branch}
-  tags: [ci, bugfix]
-  created: {YYYY-MM-DD}
-  ---
-  ```
-
-**Output:**
-Provide at least 2 implementation approaches with clear trade-offs, and explain the pros and cons of each approach, and provide a recommended approach.
-
-**IMPORTANT:** Ask the user for confirmation before implementing.
-**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
-**IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.

package/templates/commands/plan/cro.md

@@ -1,69 +0,0 @@
----
-description: Create a CRO plan for the given content
-argument-hint: [issues]
----
-
-You are an expert in conversion optimization. Analyze the content based on the given issues:
-<issues>$ARGUMENTS</issues>
-
-Activate `planning` skill.
-
-**IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
-**IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
-
-## Conversion Optimization Framework
-
-1. Headline 4-U Formula: **Useful, Unique, Urgent, Ultra-specific** (80% won't read past this)
-2. Above-Fold Value Proposition: Customer problem focus, no company story, zero scroll required
-3. CTA First-Person Psychology: "Get MY Guide" vs "Get YOUR Guide" (90% more clicks)
-4. 5-Field Form Maximum: Every field kills conversions, progressive profiling for the rest
-5. Message Match Precision: Ad copy, landing page headline, broken promises = bounce
-6. Social Proof Near CTAs: Testimonials with faces/names, results, placed at decision points
-7. Cognitive Bias Stack: Loss aversion (fear), social proof (FOMO), anchoring (pricing)
-8. PAS Copy Framework: Problem > Agitate > Solve, emotion before logic
-9. Genuine Urgency Only: Real deadlines, actual limits, fake timers destroy trust forever
-10. Price Anchoring Display: Show expensive option first, make real price feel like relief
-11. Trust Signal Clustering: Security badges, guarantees, policies all visible together
-12. Visual Hierarchy F-Pattern: Eyes scan F-shape, put conversions in the path
-13. Lead Magnet Hierarchy: Templates > Checklists > Guides (instant > delayed gratification)
-14. Objection Preemption: Address top 3 concerns before they think them, FAQ near CTA
-15. Mobile Thumb Zone: CTAs where thumbs naturally rest, not stretching required
-16. One-Variable Testing: Change one thing, measure impact, compound wins over time
-17. Post-Conversion Momentum: Thank you page sells next step while excitement peaks
-18. Cart Recovery Sequence: Email in 1 hour, retarget in 4 hours, incentive at 24 hours
-19. Reading Level Grade 6: Smart people prefer simple, 11-word sentences, short paragraphs
-20. TOFU/MOFU/BOFU Logic: Awareness content ≠ decision content, match intent precisely
-21. White Space = Focus: Empty space makes CTAs impossible to miss, crowded = confused
-22. Benefit-First Language: Features tell, benefits sell, transformations compel
-23. Micro-Commitment Ladder: Small yes leads to big yes, start with email only
-24. Performance Tracking Stack: Heatmaps show problems, recordings show why, events show what
-25. Weekly Optimization Ritual: Review metrics Monday, test Tuesday, iterate or scale
-
-## Workflow
-
-- If the user provides a screenshots or videos, use `ai-multimodal` skill to describe as detailed as possible the issue, make sure copywriter can fully understand the issue easily based on the description.
-- If the user provides a URL, use `web_fetch` tool to fetch the content of the URL and analyze the current issues.
-- You can use screenshot capture tools along with `ai-multimodal` skill to capture screenshots of the exact parent container and analyze the current issues with the appropriate Gemini analysis skills (`ai-multimodal`, `gemini-video-understanding`, or `gemini-document-processing`).
-- Use `/scout:ext` (preferred) or `/scout` (fallback) slash command to search the codebase for files needed to complete the task
-- Use `planner` agent to create a comprehensive CRO plan following the progressive disclosure structure:
-  - Create a directory using naming pattern from `## Naming` section.
-  - Every `plan.md` MUST start with YAML frontmatter:
-    ```yaml
-    ---
-    title: "{Brief title}"
-    description: "{One sentence for card preview}"
-    status: pending
-    priority: P2
-    effort: {sum of phases, e.g., 4h}
-    branch: {current git branch}
-    tags: [cro, conversion]
-    created: {YYYY-MM-DD}
-    ---
-    ```
-  - Save the overview access point at `plan.md`, keep it generic, under 80 lines, and list each phase with status/progress and links.
-  - For each phase, add `phase-XX-phase-name.md` files containing sections (Context links, Overview with date/priority/statuses, Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps).
-  - Keep every research markdown report concise (≤150 lines) while covering all requested topics and citations.
-- Do not start implementing the CRO plan yet, wait for the user to approve the plan first.
-
-**IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
-**IMPORTANT:** In reports, list any unresolved questions at the end, if any.