cokit-cli 1.3.0 → 1.4.0

package/templates/repo/.github/skills/ck-agent-browser/SKILL.md

@@ -0,0 +1,294 @@
+---
+name: ck-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).
+license: Apache-2.0
+argument-hint: "[url or task]"
+---
+
+# 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 (vs chrome-devtools)
+
+| Use agent-browser | Use chrome-devtools |
+|-------------------|---------------------|
+| Long autonomous AI sessions | Quick one-off screenshots |
+| Context-constrained workflows | Custom Puppeteer scripts needed |
+| Video recording for debugging | WebSocket full frame debugging |
+| Cloud browsers (Browserbase) | Existing workflow integration |
+| Multi-tab handling | Need Sharp auto-compression |
+| Self-verifying build loops | Session with auth injection |
+
+**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/templates/repo/.github/skills/ck-backend-development/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: ck-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/templates/repo/.github/skills/ck-bootstrap/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: ck-bootstrap
+description: "Bootstrap new projects with research, tech stack, design, planning, and implementation. Modes: full (interactive), auto (default), fast (skip research), parallel (multi-agent)."
+license: MIT
+argument-hint: "[requirements] [--full|--auto|--fast|--parallel]"
+---
+
+# Bootstrap - New Project Scaffolding
+
+End-to-end project bootstrapping from idea to running code.
+
+**Principles:** YAGNI, KISS, DRY | Token efficiency | Concise reports
+
+## Usage
+
+```
+/ck-bootstrap <user-requirements>
+```
+
+**Flags** (optional, default `--auto`):
+
+| Flag | Mode | Thinking | User Gates | Planning Skill | Cook Skill |
+|------|------|----------|------------|----------------|------------|
+| `--full` | Full interactive | Ultrathink | Every phase | `--hard` | (interactive) |
+| `--auto` | Automatic | Ultrathink | Design only | `--auto` | `--auto` |
+| `--fast` | Quick | Think hard | None | `--fast` | `--auto` |
+| `--parallel` | Multi-agent | Ultrathink | Design only | `--parallel` | `--parallel` |
+
+**Example:**
+```
+/ck-bootstrap "Build a SaaS dashboard with auth" --fast
+/ck-bootstrap "E-commerce platform with Stripe" --parallel
+```
+
+## Workflow Overview
+
+```
+[Git Init] → [Research?] → [Tech Stack?] → [Design?] → [Planning] → [Implementation] → [Test] → [Review] → [Docs] → [Onboard] → [Final]
+```
+
+Each mode loads a specific workflow reference + shared phases.
+
+## Mode Detection
+
+If no flag provided, default to `--auto`.
+
+Load the appropriate workflow reference:
+- `--full`: Load `references/workflow-full.md`
+- `--auto`: Load `references/workflow-auto.md`
+- `--fast`: Load `references/workflow-fast.md`
+- `--parallel`: Load `references/workflow-parallel.md`
+
+All modes share: Load `references/shared-phases.md` for implementation through final report.
+
+## Step 0: Git Init (ALL modes)
+
+Check if Git initialized. If not:
+- `--full`: Ask user if they want to init → `ck-git-manager` subagent (`main` branch)
+- Others: Auto-init via `ck-git-manager` subagent (`main` branch)
+
+## Skill Triggers (MANDATORY)
+
+After early phases (research, tech stack, design), trigger downstream skills:
+
+### Planning Phase
+Activate **plan** skill with mode-appropriate flag:
+- `--full` → `/ck-plan --hard <requirements>` (thorough research + validation)
+- `--auto` → `/ck-plan --auto <requirements>` (auto-detect complexity)
+- `--fast` → `/ck-plan --fast <requirements>` (skip research)
+- `--parallel` → `/ck-plan --parallel <requirements>` (file ownership + dependency graph)
+
+Planning skill outputs a plan path. Pass this to cook.
+
+### Implementation Phase
+Activate **cook** skill with the plan path and mode-appropriate flag:
+- `--full` → `/ck-cook <plan-path>` (interactive review gates)
+- `--auto` → `/ck-cook --auto <plan-path>` (skip review gates)
+- `--fast` → `/ck-cook --auto <plan-path>` (skip review gates)
+- `--parallel` → `/ck-cook --parallel <plan-path>` (multi-agent execution)
+
+## Role
+
+Elite software engineering expert specializing in system architecture and technical decisions. Brutally honest about feasibility and trade-offs.
+
+## Critical Rules
+
+- Activate relevant skills from catalog during the process
+- Keep all research reports ≤150 lines
+- All docs written to `./docs` directory
+- Plans written to `./plans` directory using naming from `## Naming` section
+- DO NOT implement code directly — delegate through planning + cook skills
+- Sacrifice grammar for concision in reports
+- List unresolved questions at end of reports
+- Run `/ck-journal` to write a concise technical journal entry upon completion
+
+## References
+
+- `references/workflow-full.md` - Full interactive workflow
+- `references/workflow-auto.md` - Auto workflow (default)
+- `references/workflow-fast.md` - Fast workflow
+- `references/workflow-parallel.md` - Parallel workflow
+- `references/shared-phases.md` - Common phases (implementation → final report)

package/templates/repo/.github/skills/ck-bootstrap/references/shared-phases.md

@@ -0,0 +1,59 @@
+# Shared Phases (All Modes)
+
+These phases apply after planning is complete and cook skill is activated.
+Cook skill handles most of these — this reference documents bootstrap-specific guidance.
+
+## Implementation
+
+Handled by **cook** skill. Bootstrap-specific notes:
+- Use main agent to implement step by step per plan in `./plans`
+- Use `ck-ui-ux-designer` subagent for frontend per `./docs/design-guidelines.md`
+- Asset pipeline: `ai-multimodal` (if available) (generate/analyze) → `imagemagick` (crop/resize) → background removal if needed
+- Run type checking and compile after each phase
+
+## Testing
+
+Handled by **cook** skill. Bootstrap-specific notes:
+- Write real tests — NO fake data, mocks, cheats, tricks, temporary solutions
+- `ck-tester` subagent runs tests → report to main agent
+- If failures: `ck-debugger` subagent → fix → repeat until all pass
+- DO NOT ignore failed tests to pass build/CI
+
+## Code Review
+
+Handled by **cook** skill. Bootstrap-specific notes:
+- `ck-code-reviewer` subagent reviews code
+- If critical issues: fix → retest → repeat
+- Report summary to user when all tests pass and code reviewed
+
+## Documentation
+
+After code review passes. Use `ck-docs-manager` subagent to create/update:
+- `./docs/README.md` (≤300 lines)
+- `./docs/codebase-summary.md`
+- `./docs/project-overview-pdr.md` (Product Development Requirements)
+- `./docs/code-standards.md`
+- `./docs/system-architecture.md`
+
+Use `ck-project-manager` subagent to create:
+- `./docs/project-roadmap.md`
+- Update plan/phase status to complete
+
+## Onboarding
+
+Guide user to get started with the project:
+- Ask 1 question at a time, wait for answer before next
+- Example: instruct user to obtain API key → ask for key → add to env vars
+- If user requests config changes, repeat until approved
+
+## Final Report
+
+1. Summary of all changes, brief explanations
+2. Guide user to get started + suggest next steps
+3. Ask user if they want to commit/push:
+   - If yes: `ck-git-manager` subagent to commit (and push if requested)
+   - `--fast` mode: auto-commit (no push) without asking
+
+**Report rules:**
+- Sacrifice grammar for concision
+- List unresolved questions at end, if any

package/templates/repo/.github/skills/ck-bootstrap/references/workflow-auto.md

@@ -0,0 +1,52 @@
+# Auto Workflow (`--auto`) — Default
+
+**Thinking level:** Ultrathink
+**User gates:** Design approval only. All other phases proceed automatically.
+
+## Step 1: Research
+
+Spawn multiple `ck-researcher` subagents in parallel:
+- Explore request, idea validation, challenges, best solutions
+- Keep every report ≤150 lines
+
+No user gate — proceed automatically.
+
+## Step 2: Tech Stack
+
+1. Use `ck-planner` + multiple `ck-researcher` subagents in parallel for best-fit stack
+2. Write tech stack to `./docs` directory
+
+No user gate — auto-select best option.
+
+## Step 3: Wireframe & Design
+
+1. Use `ck-ui-ux-designer` + `ck-researcher` subagents in parallel:
+   - Research style, trends, fonts (predict Google Fonts name, NOT just Inter/Poppins), colors, spacing, positions
+   - Describe assets for `ai-multimodal` (if available) skill generation
+2. `ck-ui-ux-designer` creates:
+   - Design guidelines at `./docs/design-guidelines.md`
+   - Wireframes in HTML at `./docs/wireframe/`
+3. If no logo provided: generate with `ai-multimodal` (if available) skill
+4. Screenshot wireframes with `chrome-devtools` (if available) → save to `./docs/wireframes/`
+
+**Gate:** Ask user to approve design. Repeat if rejected.
+
+**Image tools:** `ai-multimodal` (if available) for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+## Step 4: Planning
+
+Activate **plan** skill: `/ck-plan --auto <requirements>`
+- Planning skill auto-detects complexity and picks appropriate mode
+- Creates plan directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+
+No user gate — proceed to implementation.
+
+## Step 5: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **cook** skill: `/ck-cook --auto <plan-path>`
+- Skips all review gates
+- Auto-approves if score≥9.5 and 0 critical issues
+- Continues through all phases without stopping

package/templates/repo/.github/skills/ck-bootstrap/references/workflow-fast.md

@@ -0,0 +1,50 @@
+# Fast Workflow (`--fast`)
+
+**Thinking level:** Think hard
+**User gates:** None. Fully autonomous from start to finish.
+
+## Step 1: Combined Research & Planning
+
+All research happens in parallel, then feeds into planning:
+
+**Parallel research batch** (spawn these simultaneously):
+- 2 `ck-researcher` subagents (max 5 sources each): explore request, validate idea, find solutions
+- 2 `ck-researcher` subagents (max 5 sources each): find best-fit tech stack
+- 2 `ck-researcher` subagents (max 5 sources each): research design style, trends, fonts, colors, spacing, positions
+  - Predict Google Fonts name (NOT just Inter/Poppins)
+  - Describe assets for `ai-multimodal` (if available) generation
+
+Keep all reports ≤150 lines.
+
+## Step 2: Design
+
+1. `ck-ui-ux-designer` subagent analyzes research, creates:
+   - Design guidelines at `./docs/design-guidelines.md`
+   - Wireframes in HTML at `./docs/wireframe/`
+2. If no logo provided: generate with `ai-multimodal` (if available) skill
+3. Screenshot wireframes with `chrome-devtools` (if available) → save to `./docs/wireframes/`
+
+**Image tools:** `ai-multimodal` (if available) for generation/analysis, `imagemagick` for crop/resize, background removal tool as needed.
+
+No user gate — proceed directly.
+
+## Step 3: Planning
+
+Activate **plan** skill: `/ck-plan --fast <requirements>`
+- Skip research (already done above)
+- Read codebase docs → create plan directly
+- Plan directory using `## Naming` pattern
+- Overview at `plan.md` (<80 lines) + `phase-XX-*.md` files
+
+No user gate — proceed to implementation.
+
+## Step 4: Implementation → Final Report
+
+Load `references/shared-phases.md` for remaining phases.
+
+Activate **cook** skill: `/ck-cook --auto <plan-path>`
+- Skips all review gates (fast planning pairs with fast execution)
+- Auto-approves if score≥9.5 and 0 critical issues
+- Continues through all phases without stopping
+
+**Note:** Fast mode uses `ck-git-manager` to auto-commit (no push) at the end.