cokit-cli 1.2.7 → 1.4.0

package/prompts/ck-spec-tasks.prompt.md

@@ -1,181 +0,0 @@
----
-agent: 'agent'
-description: 'Generate actionable, dependency-ordered tasks.md from design artifacts'
----
-
-## User Input
-
-```text
-${input}
-```
-
-You **MUST** consider the user input before proceeding (if not empty).
-
-## Outline
-
-1. **Setup**: Run `{SCRIPT}` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
-
-2. **Load design documents**: Read from FEATURE_DIR:
-   - **Required**: plan.md (tech stack, libraries, structure), spec.md (user stories with priorities)
-   - **Optional**: data-model.md (entities), contracts/ (API endpoints), research.md (decisions), quickstart.md (test scenarios)
-   - Note: Not all projects have all documents. Generate tasks based on what's available.
-
-3. **Execute task generation workflow**:
-   - Load plan.md and extract tech stack, libraries, project structure
-   - Load spec.md and extract user stories with their priorities (P1, P2, P3, etc.)
-   - If data-model.md exists: Extract entities and map to user stories
-   - If contracts/ exists: Map endpoints to user stories
-   - If research.md exists: Extract decisions for setup tasks
-   - Generate tasks organized by user story (see Task Generation Rules below)
-   - Generate dependency graph showing user story completion order
-   - Create parallel execution examples per user story
-   - Validate task completeness (each user story has all needed tasks, independently testable)
-
-4. **Generate hybrid task structure**: Create master file + individual phase files:
-
-   **4a. Create phase files** in `FEATURE_DIR/tasks/`:
-   - `phase-01-setup.md` - Project initialization
-   - `phase-02-foundation.md` - Blocking prerequisites for all user stories
-   - `phase-03-us1-[slug].md` - User Story 1 (P1 priority)
-   - `phase-04-us2-[slug].md` - User Story 2 (P2 priority)
-   - ... (one file per user story, in priority order)
-   - `phase-NN-polish.md` - Final phase: Cross-cutting concerns
-
-   **Phase file structure**:
-   ```markdown
-   # Phase N: [Phase Title]
-
-   **Status**: pending | in-progress | completed
-   **Dependencies**: [List phase dependencies, e.g., "Phase 2 must complete first"]
-
-   ## Goal
-   [Brief description of what this phase delivers]
-
-   ## Test Criteria
-   [How to verify this phase is complete - independently testable]
-
-   ## Tasks
-   - [ ] TXXX [P?] [Story?] Description with file path
-   - [ ] TXXX ...
-
-   ## Checkpoint
-   [What should be true when this phase completes]
-   ```
-
-   **4b. Create master tasks.md** in `FEATURE_DIR/`:
-   Use `spec-kit/templates/tasks-template.md` as reference, generate:
-   - Feature name and overview
-   - Phase summary table with status and links:
-     ```markdown
-     | Phase | Title | Status | Tasks | Dependencies |
-     |-------|-------|--------|-------|--------------|
-     | 1 | [Setup](tasks/phase-01-setup.md) | pending | 3 | - |
-     | 2 | [Foundation](tasks/phase-02-foundation.md) | pending | 6 | Phase 1 |
-     | 3 | [US1: Title](tasks/phase-03-us1-slug.md) | pending | 7 | Phase 2 |
-     ```
-   - Dependency graph (text diagram showing phase order)
-   - Parallel execution notes
-   - Implementation strategy (MVP first, incremental delivery)
-   - Quick reference: Total tasks, parallel opportunities, MVP scope
-
-5. **Report**: Output paths to generated files and summary:
-   - Files created: `tasks.md` + list of `tasks/phase-*.md` files
-   - Total task count and count per phase
-   - Parallel opportunities identified
-   - Independent test criteria for each story
-   - Suggested MVP scope (typically Phase 1-3: Setup + Foundation + US1)
-   - Format validation: Confirm ALL tasks follow the checklist format
-
-Context for task generation: {ARGS}
-
-**Hybrid Structure Benefits**:
-- Master `tasks.md` provides overview and navigation
-- Individual phase files enable parallel work by multiple agents/developers
-- Each phase file is self-contained with clear dependencies
-- Easy to track progress per phase independently
-
-The task files should be immediately executable - each task must be specific enough that an LLM can complete it without additional context.
-
-## Task Generation Rules
-
-**CRITICAL**: Tasks MUST be organized by user story to enable independent implementation and testing.
-
-**Tests are OPTIONAL**: Only generate test tasks if explicitly requested in the feature specification or if user requests TDD approach.
-
-### Checklist Format (REQUIRED)
-
-Every task MUST strictly follow this format:
-
-```text
-- [ ] [TaskID] [P?] [Story?] Description with file path
-```
-
-**Format Components**:
-
-1. **Checkbox**: ALWAYS start with `- [ ]` (markdown checkbox)
-2. **Task ID**: Sequential number (T001, T002, T003...) in execution order
-3. **[P] marker**: Include ONLY if task is parallelizable (different files, no dependencies on incomplete tasks)
-4. **[Story] label**: REQUIRED for user story phase tasks only
-   - Format: [US1], [US2], [US3], etc. (maps to user stories from spec.md)
-   - Setup phase: NO story label
-   - Foundational phase: NO story label  
-   - User Story phases: MUST have story label
-   - Polish phase: NO story label
-5. **Description**: Clear action with exact file path
-
-**Examples**:
-
-- ✅ CORRECT: `- [ ] T001 Create project structure per implementation plan`
-- ✅ CORRECT: `- [ ] T005 [P] Implement authentication middleware in src/middleware/auth.py`
-- ✅ CORRECT: `- [ ] T012 [P] [US1] Create User model in src/models/user.py`
-- ✅ CORRECT: `- [ ] T014 [US1] Implement UserService in src/services/user_service.py`
-- ❌ WRONG: `- [ ] Create User model` (missing ID and Story label)
-- ❌ WRONG: `T001 [US1] Create model` (missing checkbox)
-- ❌ WRONG: `- [ ] [US1] Create User model` (missing Task ID)
-- ❌ WRONG: `- [ ] T001 [US1] Create model` (missing file path)
-
-### Task Organization
-
-1. **From User Stories (spec.md)** - PRIMARY ORGANIZATION:
-   - Each user story (P1, P2, P3...) gets its own phase
-   - Map all related components to their story:
-     - Models needed for that story
-     - Services needed for that story
-     - Endpoints/UI needed for that story
-     - If tests requested: Tests specific to that story
-   - Mark story dependencies (most stories should be independent)
-
-2. **From Contracts**:
-   - Map each contract/endpoint → to the user story it serves
-   - If tests requested: Each contract → contract test task [P] before implementation in that story's phase
-
-3. **From Data Model**:
-   - Map each entity to the user story(ies) that need it
-   - If entity serves multiple stories: Put in earliest story or Setup phase
-   - Relationships → service layer tasks in appropriate story phase
-
-4. **From Setup/Infrastructure**:
-   - Shared infrastructure → Setup phase (Phase 1)
-   - Foundational/blocking tasks → Foundational phase (Phase 2)
-   - Story-specific setup → within that story's phase
-
-### Phase Structure
-
-- **Phase 1**: Setup (project initialization)
-- **Phase 2**: Foundational (blocking prerequisites - MUST complete before user stories)
-- **Phase 3+**: User Stories in priority order (P1, P2, P3...)
-  - Within each story: Tests (if requested) → Models → Services → Endpoints → Integration
-  - Each phase should be a complete, independently testable increment
-- **Final Phase**: Polish & Cross-Cutting Concerns
-
----
-
-## Suggested Next Steps
-
-| Command | Description | When to Use |
-|---------|-------------|-------------|
-| `/ck-spec-analyze` | Cross-artifact consistency check | Before implementation, validate spec/plan/tasks alignment |
-| `/ck-spec-implement` | Execute implementation | All tasks validated, ready to code |
-| `/ck-cook` | Quick flow — implement without full spec | Simple tasks that don't need spec-implement |
-
-**Workflow:** `/ck-spec-specify` → `/ck-spec-clarify` → `/ck-spec-plan` → `/ck-spec-tasks` → `/ck-spec-implement`

package/skills/agent-browser/SKILL.md

@@ -1,291 +0,0 @@
----
-name: agent-browser
-description: AI-optimized browser automation CLI with context-efficient snapshots. Use for long autonomous sessions, self-verifying workflows, video recording, and cloud browser testing (Browserbase).
----
-
-# agent-browser Skill
-
-Browser automation CLI designed for AI agents. Uses "snapshot + refs" paradigm for 93% less context than Playwright MCP.
-
-## Quick Start
-
-```bash
-# Install globally
-npm install -g agent-browser
-
-# Download Chromium (one-time)
-agent-browser install
-
-# Linux: include system deps
-agent-browser install --with-deps
-
-# Verify
-agent-browser --version
-```
-
-## Core Workflow
-
-The 4-step pattern for all browser automation:
-
-```bash
-# 1. Navigate
-agent-browser open https://example.com
-
-# 2. Snapshot (get interactive elements with refs)
-agent-browser snapshot -i
-# Output: button "Sign In" @e1, textbox "Email" @e2, ...
-
-# 3. Interact using refs
-agent-browser fill @e2 "user@example.com"
-agent-browser click @e1
-
-# 4. Re-snapshot after page changes
-agent-browser snapshot -i
-```
-
-## When to Use
-
-Best for:
-- Long autonomous AI sessions (context-efficient snapshots)
-- Self-verifying workflows and build loops
-- Video recording for debugging
-- Cloud browsers (Browserbase) for CI/CD
-- Multi-tab handling
-- Form automation and testing
-
-**Token efficiency:** ~280 chars/snapshot vs 8K+ for Playwright MCP.
-
-## Command Reference
-
-### Navigation
-```bash
-agent-browser open <url>       # Navigate to URL
-agent-browser back             # Go back
-agent-browser forward          # Go forward
-agent-browser reload           # Reload page
-agent-browser close            # Close browser
-```
-
-### Analysis (Snapshot)
-```bash
-agent-browser snapshot         # Full accessibility tree
-agent-browser snapshot -i      # Interactive elements only (recommended)
-agent-browser snapshot -c      # Compact output
-agent-browser snapshot -d 3    # Limit depth
-agent-browser snapshot -s "nav" # Scope to CSS selector
-```
-
-### Interactions (use @refs from snapshot)
-```bash
-agent-browser click @e1        # Click element
-agent-browser dblclick @e1     # Double-click
-agent-browser fill @e2 "text"  # Clear and fill input
-agent-browser type @e2 "text"  # Type without clearing
-agent-browser press Enter      # Press key
-agent-browser hover @e1        # Hover over element
-agent-browser check @e3        # Check checkbox
-agent-browser uncheck @e3      # Uncheck checkbox
-agent-browser select @e4 "opt" # Select dropdown option
-agent-browser scroll @e1       # Scroll element into view
-agent-browser scroll down 500  # Scroll page by pixels
-agent-browser drag @e1 @e2     # Drag from e1 to e2
-agent-browser upload @e5 file.pdf  # Upload file
-```
-
-### Information Retrieval
-```bash
-agent-browser get text @e1     # Get text content
-agent-browser get html @e1     # Get HTML
-agent-browser get value @e2    # Get input value
-agent-browser get attr @e1 href  # Get attribute
-agent-browser get title        # Page title
-agent-browser get url          # Current URL
-agent-browser get count "li"   # Count elements
-agent-browser get box @e1      # Bounding box
-```
-
-### State Checks
-```bash
-agent-browser is visible @e1   # Check visibility
-agent-browser is enabled @e1   # Check if enabled
-agent-browser is checked @e3   # Check if checked
-```
-
-### Media
-```bash
-agent-browser screenshot           # Capture viewport
-agent-browser screenshot --full    # Full page
-agent-browser screenshot -o ss.png # Save to file
-agent-browser pdf -o page.pdf      # Export PDF
-agent-browser record start         # Start video recording
-agent-browser record stop          # Stop and save video
-agent-browser record restart       # Restart recording
-```
-
-### Wait Conditions
-```bash
-agent-browser wait @e1                    # Wait for element
-agent-browser wait --text "Success"       # Wait for text to appear
-agent-browser wait --url "/dashboard"     # Wait for URL pattern
-agent-browser wait --load                 # Wait for page load
-agent-browser wait --idle                 # Wait for network idle
-agent-browser wait --fn "() => window.ready"  # Wait for JS condition
-```
-
-### Browser Configuration
-```bash
-agent-browser viewport 1920 1080   # Set viewport size
-agent-browser device "iPhone 14"   # Emulate device
-agent-browser geolocation 40.7 -74.0  # Set geolocation
-agent-browser offline true         # Enable offline mode
-agent-browser headers '{"X-Custom":"val"}'  # Set headers
-agent-browser credentials user pass  # HTTP auth
-agent-browser color-scheme dark    # Set color scheme
-```
-
-### Storage Management
-```bash
-agent-browser cookies              # List cookies
-agent-browser cookies set name=val # Set cookie
-agent-browser cookies clear        # Clear cookies
-agent-browser storage local        # Get localStorage
-agent-browser storage session      # Get sessionStorage
-agent-browser state save auth.json # Save browser state
-agent-browser state load auth.json # Load browser state
-```
-
-### Network Control
-```bash
-agent-browser network route "**/*.jpg" --abort    # Block requests
-agent-browser network route "**/api/*" --body '{"data":[]}'  # Mock response
-agent-browser network unroute "**/*.jpg"          # Remove specific route
-agent-browser network requests                    # List intercepted requests
-```
-
-### Semantic Finding
-```bash
-agent-browser find role button           # Find by ARIA role
-agent-browser find text "Submit"         # Find by text content
-agent-browser find label "Email"         # Find by label
-agent-browser find placeholder "Search"  # Find by placeholder
-agent-browser find testid "login-btn"    # Find by data-testid
-agent-browser find first "button"        # First matching element
-agent-browser find last "li"             # Last matching element
-agent-browser find nth 2 "li"            # Nth element (0-indexed)
-```
-
-### Advanced
-```bash
-agent-browser tabs                 # List tabs
-agent-browser tab new              # New tab
-agent-browser tab 2                # Switch to tab
-agent-browser tab close            # Close current tab
-agent-browser frame 0              # Switch to frame
-agent-browser dialog accept        # Accept dialog
-agent-browser dialog dismiss       # Dismiss dialog
-agent-browser eval "document.title"  # Execute JS
-agent-browser highlight @e1        # Highlight element visually
-agent-browser mouse move 100 200   # Move mouse to coordinates
-agent-browser mouse down           # Mouse button down
-agent-browser mouse up             # Mouse button up
-```
-
-## Global Options
-
-| Option | Description |
-|--------|-------------|
-| `--session <name>` | Named session for parallel testing |
-| `--json` | JSON output for parsing |
-| `--headed` | Show browser window |
-| `--cdp <port>` | Connect via Chrome DevTools Protocol |
-| `-p <provider>` | Cloud browser provider |
-| `--proxy <url>` | Proxy server |
-| `--headers <json>` | Custom HTTP headers |
-| `--executable-path` | Custom browser binary |
-| `--extension <path>` | Load browser extension |
-
-## Environment Variables
-
-| Variable | Description |
-|----------|-------------|
-| `AGENT_BROWSER_SESSION` | Default session name |
-| `AGENT_BROWSER_PROVIDER` | Cloud provider (e.g., browserbase) |
-| `AGENT_BROWSER_EXECUTABLE_PATH` | Browser binary location |
-| `AGENT_BROWSER_EXTENSIONS` | Comma-separated extension paths |
-| `AGENT_BROWSER_STREAM_PORT` | WebSocket streaming port |
-| `AGENT_BROWSER_HOME` | Custom installation directory |
-| `AGENT_BROWSER_PROFILE` | Browser profile directory |
-| `BROWSERBASE_API_KEY` | Browserbase API key |
-| `BROWSERBASE_PROJECT_ID` | Browserbase project ID |
-
-## Common Patterns
-
-### Form Submission
-```bash
-agent-browser open https://example.com/login
-agent-browser snapshot -i
-agent-browser fill @e1 "user@example.com"
-agent-browser fill @e2 "password123"
-agent-browser click @e3  # Submit button
-agent-browser wait url "/dashboard"
-```
-
-### State Persistence (Auth)
-```bash
-# Save authenticated state
-agent-browser open https://example.com/login
-# ... login steps ...
-agent-browser state save auth.json
-
-# Reuse in future sessions
-agent-browser state load auth.json
-agent-browser open https://example.com/dashboard
-```
-
-### Video Recording (Debugging)
-```bash
-agent-browser open https://example.com
-agent-browser record start
-# ... perform actions ...
-agent-browser record stop  # Saves to recording.webm
-```
-
-### Parallel Sessions
-```bash
-# Terminal 1
-agent-browser --session test1 open https://example.com
-
-# Terminal 2
-agent-browser --session test2 open https://example.com
-```
-
-## Cloud Browsers (Browserbase)
-
-For CI/CD or environments without local browser:
-
-```bash
-# Set credentials
-export BROWSERBASE_API_KEY="your-api-key"
-export BROWSERBASE_PROJECT_ID="your-project-id"
-
-# Use cloud browser
-agent-browser -p browserbase open https://example.com
-```
-
-See `references/browserbase-cloud-setup.md` for detailed setup.
-
-## Troubleshooting
-
-| Issue | Solution |
-|-------|----------|
-| Command not found | Run `npm install -g agent-browser` |
-| Chromium missing | Run `agent-browser install` |
-| Linux deps missing | Run `agent-browser install --with-deps` |
-| Session stale | Close browser: `agent-browser close` |
-| Element not found | Re-run `snapshot -i` after page changes |
-
-## Resources
-
-- [GitHub Repository](https://github.com/vercel-labs/agent-browser)
-- [Official Documentation](https://github.com/vercel-labs/agent-browser#readme)
-- [Browserbase Docs](https://docs.browserbase.com/)

package/skills/backend-development/SKILL.md

@@ -1,94 +0,0 @@
----
-name: backend-development
-description: Build backends with Node.js, Python, Go, C#/.NET (NestJS, FastAPI, Django, ASP.NET Core). Use for REST/GraphQL/gRPC APIs, auth (OAuth, JWT), databases, microservices, security (OWASP), Docker/K8s.
----
-
-# Backend Development Skill
-
-Production-ready backend development with modern technologies, best practices, and proven patterns.
-
-## When to Use
-
-- Designing RESTful, GraphQL, or gRPC APIs
-- Building authentication/authorization systems
-- Optimizing database queries and schemas
-- Implementing caching and performance optimization
-- OWASP Top 10 security mitigation
-- Designing scalable microservices
-- Testing strategies (unit, integration, E2E)
-- CI/CD pipelines and deployment
-- Monitoring and debugging production systems
-
-## Technology Selection Guide
-
-**Languages:** Node.js/TypeScript (full-stack), Python (data/ML), Go (concurrency), C#/.NET (enterprise), Rust (performance)
-**Frameworks:** NestJS, FastAPI, Django, Express, Gin, ASP.NET Core, Minimal APIs
-**Databases:** PostgreSQL (ACID), MongoDB (flexible schema), Redis (caching), SQL Server
-**APIs:** REST (simple), GraphQL (flexible), gRPC (performance)
-
-See: `references/backend-technologies.md` for detailed comparisons
-
-## Reference Navigation
-
-**Core Technologies:**
-- `backend-technologies.md` - Languages, frameworks, databases, message queues, ORMs
-- `backend-api-design.md` - REST, GraphQL, gRPC patterns and best practices
-
-**Security & Authentication:**
-- `backend-security.md` - OWASP Top 10 2025, security best practices, input validation
-- `backend-authentication.md` - OAuth 2.1, JWT, RBAC, MFA, session management
-
-**Performance & Architecture:**
-- `backend-performance.md` - Caching, query optimization, load balancing, scaling
-- `backend-architecture.md` - Microservices, event-driven, CQRS, saga patterns
-
-**Quality & Operations:**
-- `backend-testing.md` - Testing strategies, frameworks, tools, CI/CD testing
-- `backend-code-quality.md` - SOLID principles, design patterns, clean code
-- `backend-devops.md` - Docker, Kubernetes, deployment strategies, monitoring
-- `backend-debugging.md` - Debugging strategies, profiling, logging, production debugging
-- `backend-mindset.md` - Problem-solving, architectural thinking, collaboration
-
-## Key Best Practices (2025)
-
-**Security:** Argon2id passwords, parameterized queries (98% SQL injection reduction), OAuth 2.1 + PKCE, rate limiting, security headers
-
-**Performance:** Redis caching (90% DB load reduction), database indexing (30% I/O reduction), CDN (50%+ latency cut), connection pooling
-
-**Testing:** 70-20-10 pyramid (unit-integration-E2E), Vitest 50% faster than Jest, contract testing for microservices, 83% migrations fail without tests
-
-**DevOps:** Blue-green/canary deployments, feature flags (90% fewer failures), Kubernetes 84% adoption, Prometheus/Grafana monitoring, OpenTelemetry tracing
-
-## Quick Decision Matrix
-
-| Need | Choose |
-|------|--------|
-| Fast development | Node.js + NestJS |
-| Data/ML integration | Python + FastAPI |
-| High concurrency | Go + Gin |
-| Enterprise/.NET ecosystem | C# + ASP.NET Core |
-| Max performance | Rust + Axum |
-| ACID transactions | PostgreSQL / SQL Server |
-| Flexible schema | MongoDB |
-| Caching | Redis |
-| Internal services | gRPC |
-| Public APIs | GraphQL/REST |
-| Real-time events | Kafka |
-
-## Implementation Checklist
-
-**API:** Choose style → Design schema → Validate input → Add auth → Rate limiting → Documentation → Error handling
-
-**Database:** Choose DB → Design schema → Create indexes → Connection pooling → Migration strategy → Backup/restore → Test performance
-
-**Security:** OWASP Top 10 → Parameterized queries → OAuth 2.1 + JWT → Security headers → Rate limiting → Input validation → Argon2id passwords
-
-**Testing:** Unit 70% → Integration 20% → E2E 10% → Load tests → Migration tests → Contract tests (microservices)
-
-**Deployment:** Docker → CI/CD → Blue-green/canary → Feature flags → Monitoring → Logging → Health checks
-
-## Resources
-
-- OWASP Top 10: https://owasp.org/www-project-top-ten/
-- OAuth 2.1: https://oauth.net/2.1/
-- OpenTelemetry: https://opentelemetry.io/

package/skills/brainstorm/SKILL.md

@@ -1,74 +0,0 @@
----
-name: brainstorm
-description: Brainstorm solutions with trade-off analysis and brutal honesty. Use for ideation, architecture decisions, technical debates, feature exploration, feasibility assessment, design discussions.
----
-
-# Brainstorming Skill
-
-You are a Solution Brainstormer, an elite software engineering expert who specializes in system architecture design and technical decision-making. Your core mission is to collaborate with users to find the best possible solutions while maintaining brutal honesty about feasibility and trade-offs.
-
-## Communication Style
-If coding level guidelines were injected at session start (levels 0-5), follow those guidelines for response structure and explanation depth. The guidelines define what to explain, what not to explain, and required response format.
-
-## Core Principles
-You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
-
-## Your Expertise
-- System architecture design and scalability patterns
-- Risk assessment and mitigation strategies
-- Development time optimization and resource allocation
-- User Experience (UX) and Developer Experience (DX) optimization
-- Technical debt management and maintainability
-- Performance optimization and bottleneck identification
-
-## Your Approach
-1. **Question Everything**: Ask probing questions directly in your response to fully understand the user's request, constraints, and true objectives. Then stop and wait for user to answer. Don't assume - clarify until you're 100% certain.
-2. **Brutal Honesty**: Provide frank, unfiltered feedback about ideas directly in your response. If something is unrealistic, over-engineered, or likely to cause problems, say so directly. Your job is to prevent costly mistakes.
-3. **Explore Alternatives**: Always consider multiple approaches. Present 2-3 viable solutions with clear pros/cons, explaining why one might be superior.
-4. **Challenge Assumptions**: Question the user's initial approach directly in your response. Often the best solution is different from what was originally envisioned. Wait for user input.
-5. **Consider All Stakeholders**: Ask the user about impact on end users, developers, operations team, and business objectives. Wait for response.
-
-## Collaboration Tools
-- Consult the `planner` agent to research industry best practices and find proven solutions
-- Engage the `docs-manager` agent to understand existing project implementation and constraints
-- Use `WebSearch` tool to find efficient approaches and learn from others' experiences
-- Use `docs-seeker` skill to read latest documentation of external plugins/packages
-- Use screenshot tools to capture and analyze visual materials and mockups
-- Query `psql` command to understand current database structure and existing data
-- Employ `sequential-thinking` skill for complex problem-solving that requires structured analysis
-
-## Your Process
-1. **Scout Phase**: Use `scout` skill to discover relevant files and code patterns, read relevant docs in `<project-dir>/docs` directory, to understand the current state of the project
-2. **Discovery Phase**: Ask clarifying questions about requirements, constraints, timeline, and success criteria directly in your response. Wait for user answers.
-3. **Research Phase**: Gather information from other agents and external sources
-4. **Analysis Phase**: Evaluate multiple approaches using your expertise and principles
-5. **Debate Phase**: Present options directly, challenge user preferences, and work toward the optimal solution. Wait for user input.
-6. **Consensus Phase**: Ensure alignment on the chosen approach and document decisions
-7. **Documentation Phase**: Create a comprehensive markdown summary report with the final agreed solution
-8. **Finalize Phase**: Ask the user if they want to create a detailed implementation plan. Wait for response.
-   - If `Yes`: Run `/plan` command with the brainstorm summary context as the argument to ensure plan continuity.
-     **CRITICAL:** The invoked plan command will create `plan.md` with YAML frontmatter including `status: pending`.
-   - If `No`: End the session.
-
-## Report Output
-Use the naming pattern from the `## Naming` section in the injected context. The pattern includes the full path and computed date.
-
-## Output Requirements
-When brainstorming concludes with agreement, create a detailed markdown summary report including:
-- Problem statement and requirements
-- Evaluated approaches with pros/cons
-- Final recommended solution with rationale
-- Implementation considerations and risks
-- Success metrics and validation criteria
-- Next steps and dependencies
-* **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
-
-## Critical Constraints
-- You DO NOT implement solutions yourself - you only brainstorm and advise
-- You must validate feasibility before endorsing any approach
-- You prioritize long-term maintainability over short-term convenience
-- You consider both technical excellence and business pragmatism
-
-**Remember:** Your role is to be the user's most trusted technical advisor - someone who will tell them hard truths to ensure they build something great, maintainable, and successful.
-
-**IMPORTANT:** **DO NOT** implement anything, just brainstorm, answer questions and advise.