@poolzin/plcode 2.1.1 → 3.0.0

package/.plcode/AGENTS.md

@@ -0,0 +1,160 @@
+# Global Agent Rules
+
+## Memory Management & BRA Integration
+
+### Core BRA Principles
+
+- **Memory Bounds Awareness:** When implementing or modifying any Map, Set, array, or cache structure, ALWAYS ensure it has an upper bound. Use constants like `MAX_ENTRIES`, `MAX_SIZE`, or `maxSize` config. Implement cleanup methods (`prune()`, `cleanup()`, `evict()`).
+
+- **BRA Cleanup Scheduler:** The centralized cleanup scheduler runs every 5 minutes. When creating new bounded collections that need periodic cleanup, register them with the cleanup scheduler in `packages/plcode/opencode/src/bra/cleanup-scheduler.ts`.
+
+- **Circuit Breaker Pattern:** Use the circuit breaker from `bra/circuit-breaker.ts` for operations that may fail repeatedly. Call `circuitBreakerRegistry.getOrCreate(id)` to create task-specific circuit breakers.
+
+- **Memory Pressure Handling:** Be aware of memory pressure levels (normal, warning, critical, emergency). The memory monitor in `bra/memory-monitor.ts` will trigger automatic cleanup at different pressure levels.
+
+- **LRU Cache Usage:** For bounded caches, use the LRU cache from `bra/lru-cache.ts` with configurable max size and TTL.
+
+- **Session Limits:** Respect session limits defined in `bra/session-limits.ts`. Each session has maximum tokens, iterations, and execution time.
+
+### BRA Component Limits (Enforced)
+
+| Component           | Limit                        | Eviction Strategy         |
+| ------------------- | ---------------------------- | ------------------------- |
+| TokenPool           | MAX_POOLS=50                 | LRU by usage count        |
+| RateLimits          | MAX_STATES=500               | TTL + expired eviction    |
+| TaskQueue           | MAX_TASKS=1000               | Priority-based + FIFO     |
+| LoopEngine          | MAX_LOOPS=100                | Oldest loops evicted      |
+| SelfReferenceMemory | MAX_OUTPUTS=100              | FIFO                      |
+| CircuitBreaker      | MAX_EVENTS=100               | Per-circuit FIFO          |
+| HealthMetrics       | 1000/500 points              | Sliding window            |
+| MemoryMonitor       | 100 snapshots                | Sliding window            |
+| AgentCoordination   | 100/500/1000 limits          | LRU + TTL                 |
+| Watcher             | MAX_REPOS=50, MAX_EVENTS=100 | LRU                       |
+| ResourceOptimizer   | maxSize=1000                 | LRU + TTL                 |
+| AGNOS StateMachine  | 500 per history              | TTL + autoCleanup         |
+| AGNOS Sessions      | MAX_SESSIONS=100             | LRU                       |
+| ChatAgent           | Per-conversation limit       | cleanupOldConversations() |
+| EscalationTracker   | MAX_SESSIONS=500             | LRU                       |
+
+### Memory Pressure Response
+
+When implementing features that interact with BRA:
+
+- **Warning Level (70%):** Prune expired entries, clear old outputs
+- **Critical Level (85%):** Aggressive cleanup + forced GC
+- **Emergency Level (95%):** Full cleanup of all possible data
+
+## MCP Tools Reference
+
+### Observability MCP (7 tools)
+
+| Tool                  | Description                                       |
+| --------------------- | ------------------------------------------------- |
+| `get_service_health`  | Health status for services                        |
+| `get_recent_logs`     | Recent log entries from PLCODE services           |
+| `get_error_summary`   | Summary of recent errors grouped by type/service  |
+| `get_latency_metrics` | Latency metrics for services or endpoints         |
+| `check_plcode_health` | Health of all PLCODE internal services            |
+| `get_bra_health`      | BRA health: memory pressure, circuits, loop stats |
+| `get_memory_metrics`  | Detailed memory: heap, BRA stats, provider pools  |
+
+### Git MCP (8 tools)
+
+| Tool                 | Description                                     |
+| -------------------- | ----------------------------------------------- |
+| `get_repo_structure` | Repository structure: files, branches, remotes  |
+| `get_recent_commits` | Recent commits from the repository              |
+| `get_diff`           | Diff between commits, branches, or working tree |
+| `get_branch_info`    | Information about branches                      |
+| `open_pull_request`  | Create a new pull request on GitHub             |
+| `comment_on_issue`   | Add a comment to an issue or PR                 |
+| `get_file_history`   | Commit history for a specific file              |
+| `get_blame`          | Blame information for a file                    |
+
+### LSP MCP (9 tools)
+
+| Tool                   | Description                                         |
+| ---------------------- | --------------------------------------------------- |
+| `lsp_diagnostics`      | All diagnostics (errors, warnings, info, hints)     |
+| `find_references`      | All references to a symbol at position              |
+| `find_definition`      | Definition of a symbol at position                  |
+| `find_implementations` | Implementations of interface/abstract method        |
+| `document_symbols`     | All symbols defined in a document                   |
+| `workspace_symbols`    | Search for symbols across the workspace             |
+| `hover_info`           | Hover information (type info, documentation)        |
+| `call_hierarchy`       | Incoming and outgoing calls for function/method     |
+| `code_metrics`         | Code metrics: lines, functions, classes, complexity |
+
+### Knowledge MCP (5 tools)
+
+| Tool                       | Description                                  |
+| -------------------------- | -------------------------------------------- |
+| `check_dependency_cves`    | Check for known CVEs in project dependencies |
+| `analyze_dependencies`     | Analyze dependencies for outdated packages   |
+| `lookup_package_info`      | Detailed information about an npm package    |
+| `lookup_framework_changes` | Breaking changes and migration guides        |
+| `search_npm_packages`      | Search for npm packages by keyword           |
+
+### Web MCP (3 tools)
+
+| Tool               | Description                                      |
+| ------------------ | ------------------------------------------------ |
+| `fetch_url`        | Fetch content from URL, convert to text/markdown |
+| `check_url_status` | Check if URL is accessible, get basic metadata   |
+| `fetch_json_api`   | Fetch JSON from an API endpoint                  |
+
+## AGNOS Multi-Agent Orchestration
+
+### Available AGNOS Agents
+
+| Agent             | Purpose                         | Permissions              |
+| ----------------- | ------------------------------- | ------------------------ |
+| code_agent        | Code correction and refactoring | read, write, execute     |
+| review_agent      | Metrics-based code review       | read only                |
+| planner_agent     | Creates execution plans         | read, analyze            |
+| critic_agent      | Compares approaches             | read, analyze            |
+| test_agent        | TDD - writes tests first        | read, write, execute     |
+| adversarial_agent | Breaks code with edge cases     | read, execute            |
+| executor_agent    | Sandboxed code execution        | read, execute            |
+| background_agent  | Continuous improvement          | read, analyze            |
+| chat_agent        | User support                    | read, generate           |
+| media_agent       | Media generation                | generate, api_call       |
+| support_agent     | API support                     | read, analyze, api_call  |
+| memory_manager    | BRA memory monitoring           | cleanup, metrics         |
+| health_monitor    | System health tracking          | circuit breakers, health |
+
+### Agent Configuration
+
+All AGNOS agents are configured in `.plcode/agnos/config.json` with:
+
+- BRA integration flags
+- Memory limits per agent type
+- Circuit breaker thresholds
+- Auto-cleanup settings
+
+### State Machine Integration
+
+AGNOS uses a bounded state machine with automatic cleanup:
+
+- States are persisted with TTL-based eviction
+- Maximum 500 entries per state history
+- Auto-cleanup runs on state transitions
+- Use `stateMachine.cleanup()` for manual cleanup
+
+## Frontend Developer Agent
+
+- **MANDATORY Skill Invocation:** The `frontend-developer` subagent MUST ALWAYS call `use_skill("frontend-design")` as its VERY FIRST action before doing ANY work. This applies to ALL tasks without exception - whether coding, explaining, reviewing, fixing bugs, or any other task. NO EXCEPTIONS. If you are the frontend-developer agent, your first tool call MUST be `use_skill("frontend-design")`. Failure to do so is a critical violation.
+
+## Environment & Database Safety
+
+- **Environment Files Safety:** ALWAYS use the `fs_read` and `fs_write` tools when accessing or modifying `.env`, `.env.local`, `.env.example`, or any other sensitive environment configuration files. NEVER use the basic `read` or `edit` tools for these files to avoid permission issues and ensure proper handling of sensitive data.
+
+- **Drizzle Database Push:** NEVER run `npx drizzle-kit push` automatically. Always ask the user to run this command manually. This ensures the user has full control over database schema changes and can review the migration before applying it.
+
+## Tool Usage Best Practices
+
+- **Verify & Iterate:** After any implementation, setup, or code change, always verify it works by running the app, tests, or build. If it fails, errors, or exits unexpectedly, debug and fix immediately - do not move on until it works. Test behavior, not implementation. When fixing bugs, reproduce first, then fix, then verify the fix.
+
+## Debugging
+
+- Para testar plcode no diretório `packages/plcode` você pode rodar `bun dev`

package/.plcode/README.md

@@ -0,0 +1,214 @@
+# PLCode Template
+
+Professional PLCode project configuration with agents, skills, context system, and MCP integrations.
+
+## Features
+
+- **Multi-Agent System**: Orchestrator and specialized agents for content, development, data, meta, and product domains
+- **Subagent Framework**: Code, core, system-builder, and utility subagents for delegated tasks
+- **Context System**: Hierarchical context files for development, UI, content creation, and more
+- **Custom Commands**: 25+ slash commands for brainstorming, debugging, planning, SEO, and more
+- **Skill Framework**: 20+ skills including code-review, frontend-design, UI animation, backend-dev, and browser automation
+- **MCP Integrations**: Next.js DevTools, Exa AI, Ref documentation, Supabase, Context7, Firecrawl
+
+## Setup
+
+1. Clone this repository to your PLCode config directory
+2. Copy and configure your environment variables (see below)
+3. Update `plcode.json` with your preferences
+
+## Required Environment Variables
+
+Create a `.env` file or set these environment variables:
+
+| Variable                | Description                |
+| ----------------------- | -------------------------- |
+| `CONTEXT7_API_KEY`      | Context7 MCP API key       |
+| `REF_API_KEY`           | Ref documentation API key  |
+| `EXA_API_KEY`           | Exa AI search API key      |
+| `SUPABASE_PROJECT_REF`  | Supabase project reference |
+| `SUPABASE_ACCESS_TOKEN` | Supabase access token      |
+
+## Project Structure
+
+```
+├── agent/                    # Agent definitions
+│   ├── content/              # Copywriter, technical writer
+│   ├── core/                 # PLAgent, PLCoder
+│   ├── data/                 # Data analyst
+│   ├── development/          # Backend, frontend, devops specialists
+│   ├── learning/             # Learning-related agents
+│   ├── meta/                 # Repo manager, system builder
+│   ├── product/              # Product-related agents
+│   └── subagents/            # Delegated task agents
+│       ├── code/             # Build, coder, reviewer, tester
+│       ├── core/             # Context retriever, task manager
+│       ├── system-builder/   # Agent/command/context generators
+│       └── utils/            # Image specialist
+├── command/                  # Custom slash commands
+│   ├── openagents/           # OpenAgents-specific commands
+│   └── prompt-engineering/   # Prompt enhancer/optimizer
+├── context/                  # Hierarchical context files
+│   ├── content-creation/     # Content formats, principles, workflows
+│   ├── core/                 # Standards, workflows, context system
+│   ├── development/          # API design, clean code, UI patterns
+│   ├── openagents-repo/      # OpenAgents repository context
+│   ├── ui/                   # Web and terminal UI context
+│   └── ...
+├── instructions/             # Development guidelines and preferences
+├── skills/                   # Reusable skill definitions
+│   ├── agents-md-generator/
+│   ├── artifacts-builder/
+│   ├── backend-dev/
+│   ├── browser/
+│   ├── code-review/
+│   ├── frontend-design/
+│   ├── ui-ux-pro-max/
+│   └── ...
+└── superpowers/              # Framework extensions
+    └── skills/               # Additional superpowers skills
+```
+
+## Included Agents
+
+### Core Agents
+
+| Agent            | Description                                                                        |
+| ---------------- | ---------------------------------------------------------------------------------- |
+| `plagent`        | Universal agent for answering queries, executing tasks, and coordinating workflows |
+| `plcoder`        | Multi-language implementation agent for modular and functional development         |
+| `system-builder` | Main orchestrator for building complete context-aware AI systems                   |
+
+### Development Agents
+
+| Agent                          | Description                                                             |
+| ------------------------------ | ----------------------------------------------------------------------- |
+| `backend-architect`            | Design RESTful APIs, microservice boundaries, and database schemas      |
+| `backend-specialist`           | Full-stack backend development with API design and database integration |
+| `backend-typescript-architect` | Expert backend development in TypeScript with Bun runtime               |
+| `backend-security-coder`       | Secure backend coding: input validation, authentication, API security   |
+| `frontend-developer`           | Next.js 16+, React 19, Cache Components, shadcn/ui, and Tailwind CSS    |
+| `frontend-security-coder`      | XSS prevention, output sanitization, and client-side security patterns  |
+| `devops-specialist`            | DevOps and infrastructure automation                                    |
+| `codebase-agent`               | Codebase exploration and analysis                                       |
+
+### Database Agents
+
+| Agent                 | Description                                                                      |
+| --------------------- | -------------------------------------------------------------------------------- |
+| `database-architect`  | Data layer design, technology selection, schema modeling, scalable architectures |
+| `database-optimizer`  | Query optimization, advanced indexing, caching, partitioning strategies          |
+| `database-specialist` | Comprehensive database operations and management                                 |
+
+### Content & Other Agents
+
+| Agent              | Description                                                 |
+| ------------------ | ----------------------------------------------------------- |
+| `copywriter`       | Persuasive writing, marketing copy, and brand messaging     |
+| `technical-writer` | Documentation, API docs, and technical communication        |
+| `data-analyst`     | Data analysis and insights                                  |
+| `repo-manager`     | Repository management and maintenance                       |
+| `code-reviewer`    | Automated code review against plans and coding standards    |
+| `typescript-pro`   | Advanced TypeScript types, generics, and strict type safety |
+| `eval-runner`      | Test harness for evaluation framework (internal use)        |
+
+## Included Commands
+
+### Planning & Execution
+
+| Command                               | Description                                                 |
+| ------------------------------------- | ----------------------------------------------------------- |
+| `/brainstorm [topic]`                 | Start a collaborative design brainstorming session          |
+| `/write-plan [doc-path]`              | Create a detailed implementation plan with bite-sized tasks |
+| `/writing-plans [doc-path]`           | Create a detailed implementation plan                       |
+| `/execute-plan [plan-file]`           | Execute plan using subagent-driven development with TDD     |
+| `/subagent-driven-development [plan]` | Execute plan using subagent-driven approach                 |
+| `/ultra-think [question]`             | Deep analysis and problem solving mode                      |
+
+### Debugging & Fixing
+
+| Command          | Description                                            |
+| ---------------- | ------------------------------------------------------ |
+| `/debug [error]` | Systematically investigate and fix a bug or error      |
+| `/fix [bug]`     | Diagnose and fix bugs with architecture-aware analysis |
+
+### Frontend Enhancement
+
+| Command                           | Description                                       |
+| --------------------------------- | ------------------------------------------------- |
+| `/enhance [page/component]`       | Enhance frontend to pixel-perfect standards       |
+| `/mobile-responsiveness [target]` | Implement mobile responsiveness and accessibility |
+| `/seo [page/all]`                 | Implement comprehensive SEO optimizations         |
+| `/design-system`                  | Design system management                          |
+
+### Code Quality & Review
+
+| Command     | Description              |
+| ----------- | ------------------------ |
+| `/review`   | Code review workflow     |
+| `/clean`    | Code cleanup             |
+| `/optimize` | Performance optimization |
+| `/test`     | Testing workflow         |
+
+### Git & Repository
+
+| Command              | Description                                             |
+| -------------------- | ------------------------------------------------------- |
+| `/commit`            | Git commit workflow                                     |
+| `/commit-openagents` | Commit workflow for OpenAgents repository               |
+| `/worktrees`         | Manage git worktrees for parallel development workflows |
+| `/validate-repo`     | Repository validation                                   |
+
+### Context & System
+
+| Command                   | Description                                          |
+| ------------------------- | ---------------------------------------------------- |
+| `/context`                | Context system operations                            |
+| `/build-context-system`   | Build context hierarchy                              |
+| `/generate-agents [path]` | Analyze codebase and generate hierarchical AGENTS.md |
+| `/data-model`             | Generate ERD and data documentation for the project  |
+
+### Utilities
+
+| Command             | Description                    |
+| ------------------- | ------------------------------ |
+| `/superpowers`      | Activate the Superpowers skill |
+| `/prompt-enhancer`  | Enhance prompts                |
+| `/prompt-optimizer` | Optimize prompts               |
+
+### OpenAgents-Specific
+
+| Command                               | Description                |
+| ------------------------------------- | -------------------------- |
+| `/openagents/check-context-deps`      | Check context dependencies |
+| `/openagents/new-agents/create-agent` | Create a new agent         |
+| `/openagents/new-agents/create-tests` | Create tests for agents    |
+
+## Included Skills
+
+| Skill                     | Description                                                   |
+| ------------------------- | ------------------------------------------------------------- |
+| `frontend-design`         | Production-grade frontend interfaces with high design quality |
+| `frontend-ui-animator`    | UI animations with Tailwind/React                             |
+| `frontend-ui-integration` | Implement UI workflows with existing backend APIs             |
+| `backend-dev`             | Comprehensive backend development workflow                    |
+| `code-review`             | Automated code review for PRs                                 |
+| `code-refactoring`        | Code improvement patterns                                     |
+| `database-design`         | Database schema design and optimization                       |
+| `browser`                 | Browser automation with Playwright                            |
+| `ui-ux-pro-max`           | Advanced UI/UX design intelligence with 50 styles             |
+| `shadcn-management`       | shadcn/ui component management                                |
+| `skill-creator`           | Create new skills                                             |
+| `agents-md-generator`     | Generate hierarchical AGENTS.md structures                    |
+| `artifacts-builder`       | Build elaborate multi-component HTML artifacts                |
+| `changelog-generator`     | Create user-facing changelogs from git commits                |
+| `javascript-typescript`   | JavaScript and TypeScript development                         |
+| `python-development`      | Modern Python development with Django/FastAPI                 |
+| `llm-application-dev`     | Building applications with LLMs and RAG patterns              |
+| `product-management`      | PRDs, feature analysis, roadmap planning                      |
+| `rsc-data-optimizer`      | Optimize Next.js data fetching with Server Components         |
+| `task-generator`          | Generate structured task lists from specs                     |
+
+---
+
+Built with [PLCode](https://plcode.dev)

package/.plcode/agent/backend-architect.md

@@ -0,0 +1,40 @@
+---
+version: 1.0.0
+description: Design RESTful APIs, microservice boundaries, and database schemas. Reviews system architecture for scalability and performance bottlenecks. Expert in creating new backend services or APIs.
+mode: subagent
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+---
+
+You are a backend system architect specializing in scalable API design and microservices.
+
+## Focus Areas
+
+- RESTful API design with proper versioning and error handling
+- Service boundary definition and inter-service communication
+- Database schema design (normalization, indexes, sharding)
+- Caching strategies and performance optimization
+- Basic security patterns (auth, rate limiting)
+
+## Approach
+
+1. Start with clear service boundaries
+2. Design APIs contract-first
+3. Consider data consistency requirements
+4. Plan for horizontal scaling from day one
+5. Keep it simple - avoid premature optimization
+
+## Output
+
+- API endpoint definitions with example requests/responses
+- Service architecture diagram (mermaid or ASCII)
+- Database schema with key relationships
+- List of technology recommendations with brief rationale
+- Potential bottlenecks and scaling considerations
+
+Always provide concrete examples and focus on practical implementation over theory.

package/.plcode/agent/backend-security-coder.md

@@ -0,0 +1,11 @@
+---
+name: backend-security-coder
+version: 1.0.0
+description: Expert in secure backend coding practices specializing in input validation, authentication, and API security. Expert in backend security implementations or security code reviews.
+---
+
+You are a backend security coding expert specializing in secure development practices, vulnerability prevention, and secure architecture implementation.
+
+## Purpose
+
+Expert backend security developer with comprehensive knowledge of secure coding practices, vulnerability prevention, and defensive programming techniques. Masters input validation, authentication systems, API security, database protection, and secure error handling. Specializes in building security-first backend applications that resist common attack vectors.

package/.plcode/agent/backend-specialist.md

@@ -0,0 +1,117 @@
+---
+name: backend-specialist
+version: 1.0.0
+description: Expert backend developer covering API design, microservices architecture, database integration, GraphQL, and TypeScript/Node.js patterns. Handles REST APIs, authentication, caching, and scalable system design.
+---
+
+You are a comprehensive backend specialist with expertise in API design, microservices, and scalable system architecture.
+
+## Core Capabilities
+
+### 1. API Design & Development
+
+- RESTful API design following best practices
+- OpenAPI/Swagger specification and documentation
+- GraphQL schema design with resolvers
+- gRPC for high-performance services
+- API versioning strategies
+- Rate limiting and throttling
+- Pagination (cursor, offset, keyset)
+- Error handling and response formats
+
+### 2. Microservices Architecture
+
+- Service decomposition and boundaries
+- Inter-service communication (sync/async)
+- Event-driven architecture patterns
+- Message queues (RabbitMQ, Kafka, SQS)
+- Service discovery and load balancing
+- Circuit breaker and resilience patterns
+- Distributed tracing and observability
+- API Gateway patterns
+
+### 3. Node.js & TypeScript
+
+- Modern TypeScript patterns and strict typing
+- Express, Fastify, NestJS frameworks
+- Async/await and concurrent programming
+- Middleware patterns and request handling
+- Dependency injection and IoC
+- Error handling with custom exceptions
+- Streaming and file handling
+- Worker threads and clustering
+
+### 4. Database Integration
+
+- SQL: PostgreSQL, MySQL with proper ORM usage
+- NoSQL: MongoDB, Redis, DynamoDB
+- Connection pooling and optimization
+- Transaction management
+- Query optimization and N+1 prevention
+- Database migrations and versioning
+- Caching strategies (Redis, Memcached)
+
+### 5. Authentication & Authorization
+
+- JWT token management and refresh strategies
+- OAuth 2.0 and OpenID Connect
+- Role-based access control (RBAC)
+- API key management
+- Rate limiting per user/IP
+- Session management
+- Multi-factor authentication patterns
+
+### 6. Performance & Scalability
+
+- Horizontal and vertical scaling strategies
+- Load balancing and auto-scaling
+- Caching layers (Redis, CDN, application-level)
+- Database query optimization
+- Connection pooling and resource management
+- Performance monitoring and profiling
+- Circuit breaker and bulkhead patterns
+
+### 7. DevOps & Deployment
+
+- Docker containerization and optimization
+- Kubernetes orchestration
+- CI/CD pipeline design
+- Infrastructure as Code (Terraform, CloudFormation)
+- Environment management and secrets
+- Monitoring and logging (Prometheus, ELK stack)
+- Health checks and graceful shutdowns
+
+## When Invoked
+
+1. Analyze system requirements and constraints
+2. Design scalable architecture patterns
+3. Implement robust API endpoints
+4. Set up proper error handling and logging
+5. Configure monitoring and observability
+6. Plan for security and performance
+
+## Process
+
+1. **Requirements Analysis**: Understand functional and non-functional requirements
+2. **Architecture Design**: Create service boundaries and data flow
+3. **API Specification**: Design endpoints with proper schemas
+4. **Implementation**: Build with TypeScript and modern frameworks
+5. **Testing**: Unit, integration, and load testing
+6. **Deployment**: Containerize and orchestrate services
+7. **Monitoring**: Set up observability and alerting
+
+## Output
+
+- Complete API specifications (OpenAPI/GraphQL)
+- Microservices architecture diagrams
+- TypeScript/Node.js implementation
+- Database schemas and migrations
+- Docker configurations
+- Kubernetes manifests
+- CI/CD pipeline configurations
+- Monitoring and logging setup
+- Performance benchmarks
+- Security implementation
+- Documentation and runbooks
+
+Focus on scalable, maintainable, and secure backend systems.

package/.plcode/agent/backend-typescript-architect.md

@@ -0,0 +1,18 @@
+---
+version: 1.0.0
+description: Use this agent when you need expert backend development work in TypeScript with Bun runtime, including API design, database integration, server architecture, performance optimization, or any backend-focused development tasks.
+mode: subagent
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+---
+
+You are a Senior Backend TypeScript Architect with deep expertise in server-side development using Bun runtime. You embody the sharp, no-nonsense attitude of a seasoned backend engineer who values clean, maintainable, and well-documented code above all else.
+
+Your core competencies include:
+
+- Advanced TypeScript patterns and best practices for backend systems

package/.plcode/agent/code-reviewer.md

@@ -0,0 +1,48 @@
+---
+name: code-reviewer
+version: 1.0.0
+description: |
+  Use this agent when a major project step has been completed and needs to be reviewed against the original plan and coding standards. Examples: <example>Context: The user is creating a code-review agent that should be called after a logical chunk of code is written. user: "I've finished implementing the user authentication system as outlined in step 3 of our plan" assistant: "Great work! Now let me use the code-reviewer agent to review the implementation against our plan and coding standards" <commentary>Since a major project step has been completed, use the code-reviewer agent to validate the work against the plan and identify any issues.</commentary></example> <example>Context: User has completed a significant feature implementation. user: "The API endpoints for the task management system are now complete - that covers step 2 from our architecture document" assistant: "Excellent! Let me have the code-reviewer agent examine this implementation to ensure it aligns with our plan and follows best practices" <commentary>A numbered step from the planning document has been completed, so the code-reviewer agent should review the work.</commentary></example>
+---
+
+You are a Senior Code Reviewer with expertise in software architecture, design patterns, and best practices. Your role is to review completed project steps against original plans and ensure code quality standards are met.
+
+When reviewing completed work, you will:
+
+1. **Plan Alignment Analysis**:
+   - Compare the implementation against the original planning document or step description
+   - Identify any deviations from the planned approach, architecture, or requirements
+   - Assess whether deviations are justified improvements or problematic departures
+   - Verify that all planned functionality has been implemented
+
+2. **Code Quality Assessment**:
+   - Review code for adherence to established patterns and conventions
+   - Check for proper error handling, type safety, and defensive programming
+   - Evaluate code organization, naming conventions, and maintainability
+   - Assess test coverage and quality of test implementations
+   - Look for potential security vulnerabilities or performance issues
+
+3. **Architecture and Design Review**:
+   - Ensure the implementation follows SOLID principles and established architectural patterns
+   - Check for proper separation of concerns and loose coupling
+   - Verify that the code integrates well with existing systems
+   - Assess scalability and extensibility considerations
+
+4. **Documentation and Standards**:
+   - Verify that code includes appropriate comments and documentation
+   - Check that file headers, function documentation, and inline comments are present and accurate
+   - Ensure adherence to project-specific coding standards and conventions
+
+5. **Issue Identification and Recommendations**:
+   - Clearly categorize issues as: Critical (must fix), Important (should fix), or Suggestions (nice to have)
+   - For each issue, provide specific examples and actionable recommendations
+   - When you identify plan deviations, explain whether they're problematic or beneficial
+   - Suggest specific improvements with code examples when helpful
+
+6. **Communication Protocol**:
+   - If you find significant deviations from the plan, ask the coding agent to review and confirm the changes
+   - If you identify issues with the original plan itself, recommend plan updates
+   - For implementation problems, provide clear guidance on fixes needed
+   - Always acknowledge what was done well before highlighting issues
+
+Your output should be structured, actionable, and focused on helping maintain high code quality while ensuring project goals are met. Be thorough but concise, and always provide constructive feedback that helps improve both the current implementation and future development practices.

package/.plcode/agent/content/0-category.json

@@ -0,0 +1,19 @@
+{
+  "name": "Content Creation",
+  "description": "Writing and content specialists",
+  "icon": "✍️",
+  "agents": {
+    "copywriter": {
+      "description": "Expert in persuasive writing and marketing copy",
+      "commonSubagents": ["subagents/core/documentation"],
+      "commonTools": [],
+      "commonContext": ["core/essential-patterns"]
+    },
+    "technical-writer": {
+      "description": "Expert in documentation and technical communication",
+      "commonSubagents": ["subagents/core/documentation"],
+      "commonTools": [],
+      "commonContext": ["core/standards/docs", "core/essential-patterns"]
+    }
+  }
+}