@bastani/atomic 0.5.11-0 → 0.5.12-0

package/.agents/skills/explain-code/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: explain-code
+description: Explain code functionality in detail.
+---
+
+# Analyze and Explain Code Functionality
+
+## Available Tools
+
+- **Playwright CLI** (`playwright-cli`): Use to retrieve external documentation, browse web content, and extract data from documentation sites, forums, and GitHub repositories — especially useful for understanding third-party dependencies and their APIs. Invoke via the `/playwright-cli` skill or run `npx playwright-cli` commands directly.
+
+<EXTREMELY_IMPORTANT>
+- PREFER to use the playwright-cli (refer to playwright-cli skill) OVER web fetch/search tools
+  - ALWAYS load the playwright-cli skill before usage with the Skill tool.
+  - ALWAYS ASSUME you have the playwright-cli tool installed (if the `playwright-cli` command fails, fallback to `npx playwright-cli`).
+</EXTREMELY_IMPORTANT>
+
+### Web Fetch Strategy (token-efficient order)
+
+When you need external documentation about a library, framework, or API, use the **playwright-cli** skill (or `curl`) and apply these techniques in order — stop as soon as you have what you need:
+
+1. **Check `/llms.txt` first** — Many modern docs sites publish an AI-friendly index at `/llms.txt` (spec: [llmstxt.org](https://llmstxt.org/llms.txt)). Try `curl https://<site>/llms.txt` before anything else; it often links directly to the most relevant pages in plain text.
+2. **Request Markdown via `Accept: text/markdown`** — For any HTML page, try `curl <url> -H "Accept: text/markdown"` first. Sites behind Cloudflare with [Markdown for Agents](https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/) will return pre-converted Markdown (look for `content-type: text/markdown` and the `x-markdown-tokens` header), which is far cheaper than raw HTML.
+3. **Fall back to HTML parsing** — If neither above yields usable content, navigate the page with `playwright-cli` to extract the rendered DOM, or `curl` the raw HTML and parse locally.
+
+**Persist useful findings to `research/web/`:** When you fetch a document worth keeping for future sessions (API references, SDK guides, troubleshooting docs), save it to `research/web/<YYYY-MM-DD>-<kebab-case-topic>.md` with a short header noting the source URL and fetch date. Check this directory first before re-fetching.
+
+## Instructions
+
+Follow this systematic approach to explain code: **$ARGUMENTS**
+
+1. **Code Context Analysis**
+    - Identify the programming language and framework
+    - Understand the broader context and purpose of the code
+    - Identify the file location and its role in the project
+    - Review related imports, dependencies, and configurations
+
+2. **High-Level Overview**
+    - Provide a summary of what the code does
+    - Explain the main purpose and functionality
+    - Identify the problem the code is solving
+    - Describe how it fits into the larger system
+
+3. **Code Structure Breakdown**
+    - Break down the code into logical sections
+    - Identify classes, functions, and methods
+    - Explain the overall architecture and design patterns
+    - Map out data flow and control flow
+
+4. **Line-by-Line Analysis**
+    - Explain complex or non-obvious lines of code
+    - Describe variable declarations and their purposes
+    - Explain function calls and their parameters
+    - Clarify conditional logic and loops
+
+5. **Algorithm and Logic Explanation**
+    - Describe the algorithm or approach being used
+    - Explain the logic behind complex calculations
+    - Break down nested conditions and loops
+    - Clarify recursive or asynchronous operations
+
+6. **Data Structures and Types**
+    - Explain data types and structures being used
+    - Describe how data is transformed or processed
+    - Explain object relationships and hierarchies
+    - Clarify input and output formats
+
+7. **Framework and Library Usage**
+    - Explain framework-specific patterns and conventions
+    - Describe library functions and their purposes
+    - Explain API calls and their expected responses
+    - Clarify configuration and setup code
+    - Use the **playwright-cli** skill (following the Web Fetch Strategy above) to look up external library documentation when needed
+
+8. **Error Handling and Edge Cases**
+    - Explain error handling mechanisms
+    - Describe exception handling and recovery
+    - Identify edge cases being handled
+    - Explain validation and defensive programming
+
+9. **Performance Considerations**
+    - Identify performance-critical sections
+    - Explain optimization techniques being used
+    - Describe complexity and scalability implications
+    - Point out potential bottlenecks or inefficiencies
+
+10. **Security Implications**
+    - Identify security-related code sections
+    - Explain authentication and authorization logic
+    - Describe input validation and sanitization
+    - Point out potential security vulnerabilities
+
+11. **Testing and Debugging**
+    - Explain how the code can be tested
+    - Identify debugging points and logging
+    - Describe mock data or test scenarios
+    - Explain test helpers and utilities
+    - Use `playwright-cli` to reproduce browser interactions and validate frontend behavior when applicable
+
+12. **Dependencies and Integrations**
+    - Explain external service integrations
+    - Describe database operations and queries
+    - Explain API interactions and protocols
+    - Clarify third-party library usage
+
+**Explanation Format Examples:**
+
+**For Complex Algorithms:**
+
+```
+This function implements a depth-first search algorithm:
+
+1. Line 1-3: Initialize a stack with the starting node and a visited set
+2. Line 4-8: Main loop - continue until stack is empty
+3. Line 9-11: Pop a node and check if it's the target
+4. Line 12-15: Add unvisited neighbors to the stack
+5. Line 16: Return null if target not found
+
+Time Complexity: O(V + E) where V is vertices and E is edges
+Space Complexity: O(V) for the visited set and stack
+```
+
+**For API Integration Code:**
+
+```
+This code handles user authentication with a third-party service:
+
+1. Extract credentials from request headers
+2. Validate credential format and required fields
+3. Make API call to authentication service
+4. Handle response and extract user data
+5. Create session token and set cookies
+6. Return user profile or error response
+
+Error Handling: Catches network errors, invalid credentials, and service unavailability
+Security: Uses HTTPS, validates inputs, and sanitizes responses
+```
+
+**For Database Operations:**
+
+```
+This function performs a complex database query with joins:
+
+1. Build base query with primary table
+2. Add LEFT JOIN for related user data
+3. Apply WHERE conditions for filtering
+4. Add ORDER BY for consistent sorting
+5. Implement pagination with LIMIT/OFFSET
+6. Execute query and handle potential errors
+7. Transform raw results into domain objects
+
+Performance Notes: Uses indexes on filtered columns, implements connection pooling
+```
+
+13. **Common Patterns and Idioms**
+    - Identify language-specific patterns and idioms
+    - Explain design patterns being implemented
+    - Describe architectural patterns in use
+    - Clarify naming conventions and code style
+
+14. **Potential Improvements**
+    - Suggest code improvements and optimizations
+    - Identify possible refactoring opportunities
+    - Point out maintainability concerns
+    - Recommend best practices and standards
+
+15. **Related Code and Context**
+    - Reference related functions and classes
+    - Explain how this code interacts with other components
+    - Describe the calling context and usage patterns
+    - Point to relevant documentation and resources
+
+16. **Debugging and Troubleshooting**
+    - Explain how to debug issues in this code
+    - Identify common failure points
+    - Describe logging and monitoring approaches
+    - Suggest testing strategies
+
+**Language-Specific Considerations:**
+
+**JavaScript/TypeScript:**
+
+- Explain async/await and Promise handling
+- Describe closure and scope behavior
+- Clarify this binding and arrow functions
+- Explain event handling and callbacks
+
+**Python:**
+
+- Explain list comprehensions and generators
+- Describe decorator usage and purpose
+- Clarify context managers and with statements
+- Explain class inheritance and method resolution
+
+**Java:**
+
+- Explain generics and type parameters
+- Describe annotation usage and processing
+- Clarify stream operations and lambda expressions
+- Explain exception hierarchy and handling
+
+**C#:**
+
+- Explain LINQ queries and expressions
+- Describe async/await and Task handling
+- Clarify delegate and event usage
+- Explain nullable reference types
+
+**Go:**
+
+- Explain goroutines and channel usage
+- Describe interface implementation
+- Clarify error handling patterns
+- Explain package structure and imports
+
+**Rust:**
+
+- Explain ownership and borrowing
+- Describe lifetime annotations
+- Clarify pattern matching and Option/Result types
+- Explain trait implementations
+
+Remember to:
+
+- Use clear, non-technical language when possible
+- Provide examples and analogies for complex concepts
+- Structure explanations logically from high-level to detailed
+- Include visual diagrams or flowcharts when helpful
+- Tailor the explanation level to the intended audience
+- Use the **playwright-cli** skill (following the Web Fetch Strategy above) to look up external library documentation when encountering unfamiliar dependencies, and for live browser inspection when static code analysis is not enough

package/.agents/skills/extract/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: extract
+description: Extract and consolidate reusable components, design tokens, and patterns into your design system. Identifies opportunities for systematic reuse and enriches your component library. Use when the user asks to create components, refactor repeated UI patterns, build a design system, or extract tokens.
+user-invocable: true
+argument-hint: "[target]"
+---
+
+Identify reusable patterns, components, and design tokens, then extract and consolidate them into the design system for systematic reuse.
+
+## Discover
+
+Analyze the target area to identify extraction opportunities:
+
+1. **Find the design system**: Locate your design system, component library, or shared UI directory (grep for "design system", "ui", "components", etc.). Understand its structure:
+   - Component organization and naming conventions
+   - Design token structure (if any)
+   - Documentation patterns
+   - Import/export conventions
+   
+   **CRITICAL**: If no design system exists, ask before creating one. Understand the preferred location and structure first.
+
+2. **Identify patterns**: Look for:
+   - **Repeated components**: Similar UI patterns used multiple times (buttons, cards, inputs, etc.)
+   - **Hard-coded values**: Colors, spacing, typography, shadows that should be tokens
+   - **Inconsistent variations**: Multiple implementations of the same concept (3 different button styles)
+   - **Reusable patterns**: Layout patterns, composition patterns, interaction patterns worth systematizing
+
+3. **Assess value**: Not everything should be extracted. Consider:
+   - Is this used 3+ times, or likely to be reused?
+   - Would systematizing this improve consistency?
+   - Is this a general pattern or context-specific?
+   - What's the maintenance cost vs benefit?
+
+## Plan Extraction
+
+Create a systematic extraction plan:
+
+- **Components to extract**: Which UI elements become reusable components?
+- **Tokens to create**: Which hard-coded values become design tokens?
+- **Variants to support**: What variations does each component need?
+- **Naming conventions**: Component names, token names, prop names that match existing patterns
+- **Migration path**: How to refactor existing uses to consume the new shared versions
+
+**IMPORTANT**: Design systems grow incrementally. Extract what's clearly reusable now, not everything that might someday be reusable.
+
+## Extract & Enrich
+
+Build improved, reusable versions:
+
+- **Components**: Create well-designed components with:
+  - Clear props API with sensible defaults
+  - Proper variants for different use cases
+  - Accessibility built in (ARIA, keyboard navigation, focus management)
+  - Documentation and usage examples
+  
+- **Design tokens**: Create tokens with:
+  - Clear naming (primitive vs semantic)
+  - Proper hierarchy and organization
+  - Documentation of when to use each token
+  
+- **Patterns**: Document patterns with:
+  - When to use this pattern
+  - Code examples
+  - Variations and combinations
+
+**NEVER**:
+- Extract one-off, context-specific implementations without generalization
+- Create components so generic they're useless
+- Extract without considering existing design system conventions
+- Skip proper TypeScript types or prop documentation
+- Create tokens for every single value (tokens should have semantic meaning)
+
+## Migrate
+
+Replace existing uses with the new shared versions:
+
+- **Find all instances**: Search for the patterns you've extracted
+- **Replace systematically**: Update each use to consume the shared version
+- **Test thoroughly**: Ensure visual and functional parity
+- **Delete dead code**: Remove the old implementations
+
+## Document
+
+Update design system documentation:
+
+- Add new components to the component library
+- Document token usage and values
+- Add examples and guidelines
+- Update any Storybook or component catalog
+
+Remember: A good design system is a living system. Extract patterns as they emerge, enrich them thoughtfully, and maintain them consistently.

package/.agents/skills/filesystem-context/SKILL.md

@@ -0,0 +1,287 @@
+---
+name: filesystem-context
+description: This skill should be used when the user asks to "offload context to files", "implement dynamic context discovery", "use filesystem for agent memory", "reduce context window bloat", or mentions file-based context management, tool output persistence, agent scratch pads, or just-in-time context loading. A core context engineering skill — also activates when the user mentions "context engineering" or "context-engineering" in the context of extending context beyond the window via filesystem strategies.
+---
+
+# Filesystem-Based Context Engineering
+
+Use the filesystem as the primary overflow layer for agent context because context windows are limited while tasks often require more information than fits in a single window. Files let agents store, retrieve, and update an effectively unlimited amount of context through a single interface.
+
+Prefer dynamic context discovery -- pulling relevant context on demand -- over static inclusion, because static context consumes tokens regardless of relevance and crowds out space for task-specific information.
+
+## When to Activate
+
+Activate this skill when:
+- Tool outputs are bloating the context window
+- Agents need to persist state across long trajectories
+- Sub-agents must share information without direct message passing
+- Tasks require more context than fits in the window
+- Building agents that learn and update their own instructions
+- Implementing scratch pads for intermediate results
+- Terminal outputs or logs need to be accessible to agents
+
+## Core Concepts
+
+Diagnose context failures against these four modes, because each requires a different filesystem remedy:
+
+1. **Missing context** -- needed information is absent from the total available context. Fix by persisting tool outputs and intermediate results to files so nothing is lost.
+2. **Under-retrieved context** -- retrieved content fails to encapsulate what the agent needs. Fix by structuring files for targeted retrieval (grep-friendly formats, clear section headers).
+3. **Over-retrieved context** -- retrieved content far exceeds what is needed, wasting tokens and degrading attention. Fix by offloading bulk content to files and returning compact references.
+4. **Buried context** -- niche information is hidden across many files. Fix by combining glob and grep for structural search alongside semantic search for conceptual queries.
+
+Use the filesystem as the persistent layer that addresses all four: write once, store durably, retrieve selectively.
+
+## Detailed Topics
+
+### The Static vs Dynamic Context Trade-off
+
+Treat static context (system instructions, tool definitions, critical rules) as expensive real estate -- it consumes tokens on every turn regardless of relevance. As agents accumulate capabilities, static context grows and crowds out dynamic information.
+
+Use dynamic context discovery instead: include only minimal static pointers (names, one-line descriptions, file paths) and load full content with search tools when relevant. This is more token-efficient and often improves response quality by reducing contradictory or irrelevant information in the window.
+
+Accept the trade-off: dynamic discovery requires the model to recognize when it needs more context. Current frontier models handle this well, but less capable models may fail to trigger loads. When in doubt, err toward including critical safety or correctness constraints statically.
+
+### Pattern 1: Filesystem as Scratch Pad
+
+Redirect large tool outputs to files instead of returning them directly to context, because a single web search or database query can dump thousands of tokens into message history where they persist for the entire conversation.
+
+Write the output to a scratch file, extract a compact summary, and return a file reference. The agent then uses targeted retrieval (grep for patterns, read with line ranges) to access only what it needs.
+
+```python
+def handle_tool_output(output: str, threshold: int = 2000) -> str:
+    if len(output) < threshold:
+        return output
+
+    file_path = f"scratch/{tool_name}_{timestamp}.txt"
+    write_file(file_path, output)
+
+    key_summary = extract_summary(output, max_tokens=200)
+    return f"[Output written to {file_path}. Summary: {key_summary}]"
+```
+
+Use grep to search the offloaded file and read_file with line ranges to retrieve targeted sections, because this preserves full output for later reference while keeping only ~100 tokens in the active context.
+
+### Pattern 2: Plan Persistence
+
+Write plans to the filesystem because long-horizon tasks lose coherence when plans fall out of attention or get summarized away. The agent re-reads its plan at any point, restoring awareness of the objective and progress.
+
+Store plans in structured format so they are both human-readable and machine-parseable:
+```yaml
+# scratch/current_plan.yaml
+objective: "Refactor authentication module"
+status: in_progress
+steps:
+  - id: 1
+    description: "Audit current auth endpoints"
+    status: completed
+  - id: 2
+    description: "Design new token validation flow"
+    status: in_progress
+  - id: 3
+    description: "Implement and test changes"
+    status: pending
+```
+
+Re-read the plan at the start of each turn or after any context refresh to re-orient, because this acts as "manipulating attention through recitation."
+
+### Pattern 3: Sub-Agent Communication via Filesystem
+
+Route sub-agent findings through the filesystem instead of message passing, because multi-hop message chains degrade information through summarization at each hop ("game of telephone").
+
+Have each sub-agent write directly to its own workspace directory. The coordinator reads these files directly, preserving full fidelity:
+```
+workspace/
+  agents/
+    research_agent/
+      findings.md
+      sources.jsonl
+    code_agent/
+      changes.md
+      test_results.txt
+  coordinator/
+    synthesis.md
+```
+
+Enforce per-agent directory isolation to prevent write conflicts and maintain clear ownership of each output artifact.
+
+### Pattern 4: Dynamic Skill Loading
+
+Store skills as files and include only skill names with brief descriptions in static context, because stuffing all instructions into the system prompt wastes tokens and can confuse the model with contradictory guidance.
+
+```
+Available skills (load with read_file when relevant):
+- database-optimization: Query tuning and indexing strategies
+- api-design: REST/GraphQL best practices
+- testing-strategies: Unit, integration, and e2e testing patterns
+```
+
+Load the full skill file (e.g., `skills/database-optimization/SKILL.md`) only when the current task requires it. This converts O(n) static token cost into O(1) per task.
+
+### Pattern 5: Terminal and Log Persistence
+
+Persist terminal output to files automatically and use grep for selective retrieval, because terminal output from long-running processes accumulates rapidly and manual copy-paste is error-prone.
+
+```
+terminals/
+  1.txt    # Terminal session 1 output
+  2.txt    # Terminal session 2 output
+```
+
+Query with targeted grep (`grep -A 5 "error" terminals/1.txt`) instead of loading entire terminal histories into context.
+
+### Pattern 6: Learning Through Self-Modification
+
+Have agents write learned preferences and patterns to their own instruction files so subsequent sessions load this context automatically, instead of requiring manual system prompt updates.
+
+```python
+def remember_preference(key: str, value: str):
+    preferences_file = "agent/user_preferences.yaml"
+    prefs = load_yaml(preferences_file)
+    prefs[key] = value
+    write_yaml(preferences_file, prefs)
+```
+
+Guard this pattern with validation because self-modification can accumulate incorrect or contradictory instructions over time. Treat it as experimental -- review persisted preferences periodically.
+
+### Filesystem Search Techniques
+
+Combine `ls`/`list_dir`, `glob`, `grep`, and `read_file` with line ranges for context discovery, because models are specifically trained on filesystem traversal and this combination often outperforms semantic search for technical content where structural patterns are clear.
+
+- `ls` / `list_dir`: Discover directory structure
+- `glob`: Find files matching patterns (e.g., `**/*.py`)
+- `grep`: Search file contents, returns matching lines with context
+- `read_file` with ranges: Read specific sections without loading entire files
+
+Use filesystem search for structural and exact-match queries, and semantic search for conceptual queries. Combine both for comprehensive discovery.
+
+## Practical Guidance
+
+### When to Use Filesystem Context
+
+Apply filesystem patterns when the situation matches these criteria, because they add I/O overhead that is only justified by token savings or persistence needs:
+
+**Use when:**
+- Tool outputs exceed ~2000 tokens
+- Tasks span multiple conversation turns
+- Multiple agents need shared state
+- Skills or instructions exceed comfortable system prompt size
+- Logs or terminal output need selective querying
+
+**Avoid when:**
+- Tasks complete in single turns (overhead not justified)
+- Context fits comfortably in window (no problem to solve)
+- Latency is critical (file I/O adds measurable delay)
+- Model lacks filesystem tool capabilities
+
+### File Organization
+
+Structure files for agent discoverability, because agents navigate by listing and reading directory names:
+```
+project/
+  scratch/           # Temporary working files
+    tool_outputs/    # Large tool results
+    plans/           # Active plans and checklists
+  memory/            # Persistent learned information
+    preferences.yaml # User preferences
+    patterns.md      # Learned patterns
+  skills/            # Loadable skill definitions
+  agents/            # Sub-agent workspaces
+```
+
+Use consistent naming conventions and include timestamps or IDs in scratch files for disambiguation.
+
+### Token Accounting
+
+Measure where tokens originate before and after applying filesystem patterns, because optimizing without measurement leads to wasted effort:
+- Track static vs dynamic context ratio
+- Monitor tool output sizes before and after offloading
+- Measure how often dynamically-loaded context is actually used
+
+## Examples
+
+**Example 1: Tool Output Offloading**
+```
+Input: Web search returns 8000 tokens
+Before: 8000 tokens added to message history
+After:
+  - Write to scratch/search_results_001.txt
+  - Return: "[Results in scratch/search_results_001.txt. Key finding: API rate limit is 1000 req/min]"
+  - Agent greps file when needing specific details
+Result: ~100 tokens in context, 8000 tokens accessible on demand
+```
+
+**Example 2: Dynamic Skill Loading**
+```
+Input: User asks about database indexing
+Static context: "database-optimization: Query tuning and indexing"
+Agent action: read_file("skills/database-optimization/SKILL.md")
+Result: Full skill loaded only when relevant
+```
+
+**Example 3: Chat History as File Reference**
+```
+Trigger: Context window limit reached, summarization required
+Action:
+  1. Write full history to history/session_001.txt
+  2. Generate summary for new context window
+  3. Include reference: "Full history in history/session_001.txt"
+Result: Agent can search history file to recover details lost in summarization
+```
+
+## Guidelines
+
+1. Write large outputs to files; return summaries and references to context
+2. Store plans and state in structured files for re-reading
+3. Use sub-agent file workspaces instead of message chains
+4. Load skills dynamically rather than stuffing all into system prompt
+5. Persist terminal and log output as searchable files
+6. Combine grep/glob with semantic search for comprehensive discovery
+7. Organize files for agent discoverability with clear naming
+8. Measure token savings to validate filesystem patterns are effective
+9. Implement cleanup for scratch files to prevent unbounded growth
+10. Guard self-modification patterns with validation
+
+## Gotchas
+
+1. **Scratch directory unbounded growth**: Agents create temp files without cleanup, eventually consuming disk and making directory listings noisy. Implement a retention policy (age-based or count-based) and run cleanup at session boundaries.
+2. **Race conditions in multi-agent file access**: Concurrent writes to the same file corrupt state silently. Enforce per-agent directory isolation or use append-only files with agent-prefixed entries.
+3. **Stale file references after moves/renames**: Agents hold paths from prior turns that no longer exist after refactors or file reorganization. Always verify file existence before reading a cached path; re-discover with glob if the check fails.
+4. **Glob pattern false matches**: Overly broad patterns (e.g., `**/*`) pull irrelevant files into context, wasting tokens and confusing the model. Scope globs to specific directories and extensions.
+5. **File size assumptions**: Reading a file without checking size can dump 100K+ tokens into context in a single tool call. Check file size before reading; use line-range reads for large files.
+6. **Missing file existence checks**: Agents assume files exist from prior turns, but they may have been deleted or moved. Always guard reads with existence checks and handle missing-file errors gracefully.
+7. **Scratch pad format drift**: Unstructured scratch pads become unparseable after many writes because format conventions erode over successive appends. Define and enforce a schema (YAML, JSON, or structured markdown) from the first write.
+8. **Hardcoded absolute paths**: Break when repositories are checked out at different locations or when running in containers. Use relative paths from the project root or resolve paths dynamically.
+
+## Integration
+
+This skill connects to:
+
+- context-optimization - Filesystem offloading is a form of observation masking
+- memory-systems - Filesystem-as-memory is a simple memory layer
+- multi-agent-patterns - Sub-agent file workspaces enable isolation
+- context-compression - File references enable lossless "compression"
+- tool-design - Tools should return file references for large outputs
+
+## References
+
+Internal reference:
+- [Implementation Patterns](./references/implementation-patterns.md) - Read when: implementing scratch pad, plan persistence, or tool output offloading and need concrete code beyond the inline examples
+
+Related skills in this collection:
+- context-optimization - Read when: applying token reduction techniques alongside filesystem offloading
+- memory-systems - Read when: building persistent storage that outlasts a single session
+- multi-agent-patterns - Read when: designing agent coordination with shared file workspaces
+
+External resources:
+- LangChain Deep Agents — Read when: implementing filesystem-based context patterns in LangChain/LangGraph pipelines
+- Cursor context discovery — Read when: studying how production IDEs implement dynamic context loading
+- Anthropic Agent Skills specification — Read when: building skills that leverage filesystem progressive disclosure
+
+---
+
+## Skill Metadata
+
+**Created**: 2026-01-07
+**Last Updated**: 2026-03-17
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.1.0