npm - cokit-cli - Versions diffs - 1.2.7 → 1.4.0 - Mend

cokit-cli 1.2.7 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1206) hide show

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

@@ -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/templates/repo/.github/skills/backend-development/SKILL.md DELETED Viewed

@@ -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/templates/repo/.github/skills/brainstorm/SKILL.md DELETED Viewed

@@ -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.

package/templates/repo/.github/skills/code-review/SKILL.md DELETED Viewed

@@ -1,193 +0,0 @@
----
-name: code-review
-description: Review code quality, receive feedback with technical rigor, verify completion claims. Includes edge case scouting for multi-file features. Use before PRs, after implementing features, when claiming task completion, for agent reviews.
----
-# Code Review
-Guide proper code review practices emphasizing technical rigor, evidence-based claims, and verification over performative responses.
-## Overview
-| Practice | When | Protocol |
-|----------|------|----------|
-| **Edge Case Scouting** | Before any review on 3+ file features | `/ck-scout` for hidden paths and untested scenarios |
-| **Receiving Feedback** | Feedback from human or agent | READ → UNDERSTAND → VERIFY → EVALUATE → RESPOND → IMPLEMENT |
-| **Requesting Reviews** | After each task, before merge, after major features | Delegate to `code-reviewer` agent |
-| **Verification Gates** | Before any completion claim | Run command, read output, then claim |
-## Core Principle
-Always honoring **YAGNI**, **KISS**, and **DRY** principles.
-**Be honest, be brutal, straight to the point, and be concise.**
-**Technical correctness over social comfort.** Verify before implementing. Ask before assuming. Evidence before claims.
-## When to Use This Skill
-### Edge Case Scouting
-Trigger when:
-- Feature touches 3+ files
-- Implementing complex business logic
-- Before requesting formal code review
-- After implementation, before testing
-**Reference:** `references/requesting-code-review.md`
-### Receiving Feedback
-Trigger when:
-- Receiving code review comments from any source
-- Feedback seems unclear or technically questionable
-- Multiple review items need prioritization
-- External reviewer lacks full context
-- Suggestion conflicts with existing decisions
-**Reference:** `references/code-review-reception.md`
-### Requesting Review
-Trigger when:
-- Completing tasks in agent-driven development (after EACH task)
-- Finishing major features or refactors
-- Before merging to main branch
-- Stuck and need fresh perspective
-- After fixing complex bugs
-**Reference:** `references/requesting-code-review.md`
-### Verification Gates
-Trigger when:
-- About to claim tests pass, build succeeds, or work is complete
-- Before committing, pushing, or creating PRs
-- Moving to next task
-- Any statement suggesting success/completion
-- Expressing satisfaction with work
-**Reference:** `references/verification-before-completion.md`
-## Quick Decision Tree
-```
-SITUATION?
-│
-├─ Multi-file feature (3+ files)?
-│  └─ Run edge case scouting first → /ck-scout then request review
-│
-├─ Received feedback
-│  ├─ Unclear items? → STOP, ask for clarification first
-│  ├─ From human partner? → Understand, then implement
-│  └─ From external reviewer? → Verify technically before implementing
-│
-├─ Completed work
-│  ├─ Major feature/task? → Request `code-reviewer` agent review
-│  └─ Before merge? → Request `code-reviewer` agent review
-│
-└─ About to claim status
-   ├─ Have fresh verification? → State claim WITH evidence
-   └─ No fresh verification? → RUN verification command first
-```
-## Edge Case Scouting
-### When to Scout
-Before formal review of any multi-file feature (3+ files changed).
-### Process
-1. Use `/ck-scout` to search for hidden code paths, edge inputs, error branches
-2. Document untested scenarios found
-3. Add tests or guards for critical edge cases
-4. Then proceed to formal `code-reviewer` review
-### What to Look For
-- Null/undefined paths not covered by tests
-- Error branches lacking handlers
-- Boundary conditions (empty arrays, max values, concurrent calls)
-- Async race conditions
-- Permission/auth edge cases
-## Task-Managed Review Pipeline (Multi-File Features)
-For features spanning 3+ files, use a structured pipeline:
-```
-scout → review → fix → verify
-```
-**Steps:**
-1. **Scout** - Use `/ck-scout` or `/ck-scout ext` to identify edge cases and gaps
-2. **Review** - Delegate to `code-reviewer` agent with full context
-3. **Fix** - Implement critical and important feedback
-4. **Verify** - Run tests, confirm fixes, then claim completion
-Track progress using a checklist in your plan or task notes:
-```
-- [ ] Edge case scouting complete
-- [ ] `code-reviewer` review complete
-- [ ] Critical issues fixed
-- [ ] Verification passed
-```
-## Receiving Feedback Protocol
-### Response Pattern
-READ → UNDERSTAND → VERIFY → EVALUATE → RESPOND → IMPLEMENT
-### Key Rules
-- No performative agreement: "You're absolutely right!", "Great point!", "Thanks for [anything]"
-- No implementation before verification
-- Restate requirement, ask questions, push back with technical reasoning, or just start working
-- If unclear: STOP and ask for clarification on ALL unclear items first
-- YAGNI check: search for usage before implementing suggested "proper" features
-**Full protocol:** `references/code-review-reception.md`
-## Requesting Review Protocol
-### When to Request
-- After each task in agent-driven development
-- After major feature completion
-- Before merge to main
-### Process
-1. Scout edge cases (3+ file features): use `/ck-scout` first
-2. Get git SHAs: `BASE_SHA=$(git rev-parse HEAD~1)` and `HEAD_SHA=$(git rev-parse HEAD)`
-3. Delegate to `code-reviewer` agent with: WHAT_WAS_IMPLEMENTED, PLAN_OR_REQUIREMENTS, BASE_SHA, HEAD_SHA, DESCRIPTION
-4. Act on feedback: Fix Critical immediately, Important before proceeding, note Minor for later
-**Full protocol:** `references/requesting-code-review.md`
-## Verification Gates Protocol
-### The Iron Law
-**NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE**
-### Gate Function
-IDENTIFY command → RUN full command → READ output → VERIFY confirms claim → THEN claim
-Skip any step = lying, not verifying
-### Requirements
-- Tests pass: Test output shows 0 failures
-- Build succeeds: Build command exit 0
-- Bug fixed: Test original symptom passes
-- Requirements met: Line-by-line checklist verified
-### Red Flags - STOP
-Using "should"/"probably"/"seems to", expressing satisfaction before verification, committing without verification, trusting agent reports, ANY wording implying success without running verification
-**Full protocol:** `references/verification-before-completion.md`
-## Integration with Workflows
-- **Agent-Driven:** Scout edge cases first (3+ files), review after EACH task, verify before moving to next
-- **Pull Requests:** Scout → verify tests pass → request `code-reviewer` review before merge
-- **General:** Apply verification gates before any status claims, push back on invalid feedback
-- **Pipeline:** For complex features use the full `scout → review → fix → verify` pipeline
-## Bottom Line
-1. **Scout first** - Edge cases found before review save rework cycles
-2. Technical rigor over social performance - No performative agreement
-3. Systematic review processes - Use `code-reviewer` agent via pipeline
-4. Evidence before claims - Verification gates always
-Scout. Verify. Question. Then implement. Evidence. Then claim.