@kienha/anti-chaotic 1.0.8 → 1.0.9

package/.agent/skills/ai-engineer/SKILL.md

@@ -1,23 +1,28 @@
 ---
 name: ai-engineer
-description: AI Engineer role. Focuses on integrating AI models, building RAG pipelines, and optimizing prompts. Loads specific AI modality guides.
+description: Expert AI Engineer role (10+ Years Exp). Focuses on production-grade GenAI, Agentic Systems, Advanced RAG, and rigorous Evaluation.
 license: MIT
 metadata:
   role: AI Engineer
-  version: "1.0"
+  version: "2.0"
 ---
 
-# AI Engineer
+# Senior AI Engineer
 
-You build intelligence into the application.
+You are a Senior Staff AI Engineer with experience at top-tier tech companies (Google, OpenAI, Anthropic). You build robust, scalable, and intelligent systems. You do not just "call APIs"; you engineer reliability, observability, and performance into stochastic systems.
 
 ## Core Responsibilities
 
-1.  **Model Integration**: Connecting LLMs to Logic.
-2.  **Context Management**: RAG, Vector Search, Memory.
-3.  **Evaluation**: Testing AI quality.
+1.  **Agentic Systems & Architecture**: Designing multi-agent workflows, planning capabilities, and reliable tool-use patterns.
+2.  **Advanced RAG & Retrieval**: Implementing hybrid search, query expansion, re-ranking, and knowledge graphs.
+3.  **Evaluation & Reliability (Evals)**: Setting up rigorous evaluation pipelines (LLM-as-a-judge), regression testing, and guardrails.
+4.  **Model Integration & Optimization**: Function calling, structured outputs, prompt engineering, and choosing the right model for the task (latency vs. intelligence trade-offs).
+5.  **MLOps & Serving**: Observability, tracing, caching, and cost management.
 
 ## Dynamic Stack Loading
 
-- **LLMs & RAG**: [Read specific guide](references/llm.md)
-- **MLOps**: (Create `references/mlops.md` if needed)
+- **Agentic Patterns**: [Principles for reliable agents](references/agentic-patterns.md)
+- **Advanced RAG**: [Techniques for high-recall retrieval](references/rag-advanced.md)
+- **Evaluation Frameworks**: [Testing & Metrics](references/evaluation.md)
+- **Serving & Optimization**: [Performance & MLOps](references/serving-optimization.md)
+- **LLM Fundamentals**: [Prompting & SDKs](references/llm.md)

package/.agent/skills/ai-engineer/references/agentic-patterns.md

@@ -0,0 +1,47 @@
+# Agentic Patterns & Architectures
+
+Building agents is about engineering reliability into stochastic systems.
+
+## Core Patterns
+
+### 1. The ReAct Loop (Reason + Act)
+
+The fundamental loop of an agent:
+
+1.  **Thought**: Analyze the current state and goal.
+2.  **Act**: Decide on a tool to call.
+3.  **Obs**: Observe the output of the tool.
+4.  **Repeat**.
+
+### 2. Planning & Reflection
+
+- **Planning**: Break complex tasks into steps _before_ execution. (e.g., "First I will search for X, then I will calculate Y").
+- **Reflection**: After an output, ask the model "Does this answer the user's question? Is it accurate?". Use a separate "Critic" prompt.
+
+### 3. Memory Architectures
+
+- **Short-term**: Current context window (conversation history).
+- **Long-term**: Vector database (semantic search over past interactions).
+- **Procedural**: Storing successful "recipes" or tool sequences for future use.
+
+## Multi-Agent Architectures
+
+### 1. Orchestrator-Workers (Router)
+
+A central "Manager" LLM analyzes the request and delegates to specific "Worker" agents (e.g., Coder, Researcher, Reviewer).
+
+- **Pros**: Clear separation of concerns, easy to eval workers independently.
+- **Cons**: Latency (multiple hops).
+
+### 2. Autonomous Teams (CrewAI / AutoGen)
+
+Agents converse with each other to solve a problem.
+
+- **Role-Playing**: "You represent the User", "You are the QA Tester".
+- **Dynamic**: Can handle ambiguous tasks but harder to control.
+
+## Best Practices
+
+- **Deterministic Tools**: Tools should be as reliable as possible (APIs, Code execution).
+- **Human-in-the-Loop**: Always pause for confirmation before destructive actions (Write DB, Deploy).
+- **Fail Gracefully**: If a tool fails, the agent should catch the error and retry or ask for help, not crash.

package/.agent/skills/ai-engineer/references/evaluation.md

@@ -0,0 +1,42 @@
+# Evaluation & Reliability
+
+If you can't measure it, you can't improve it.
+
+## The Evaluation Hierarchy
+
+### 1. Unit Tests (Deterministic)
+
+- Does the output JSON parse?
+- Does the code compile?
+- Are forbidden words present?
+
+### 2. LLM-as-a-Judge (Semantic)
+
+Use a stronger model (GPT-4o) to evaluate the output of your application model.
+
+- **Frameworks**: Ragas, DeepEval, Promptfoo.
+- **Metrics**:
+  - **Faithfulness**: Is the answer derived _only_ from the retrieved context?
+  - **Answer Relevance**: Does the answer address the user's query?
+  - **Context Precision**: Was the relevant chunk ranked at the top?
+
+### 3. Human Review (Ground Truth)
+
+- Create a "Golden Dataset" of 50-100 Q&A pairs verified by experts.
+- Run regression tests against this dataset on every prompt change.
+
+## Techniques
+
+### Regression Testing
+
+Treat prompts like code.
+
+1. Change strictness in system prompt.
+2. Run `promptfoo eval` against 50 test cases.
+3. Compare pass rate (98% -> 92%? **Revert**).
+
+### Guardrails
+
+- **Input Rails**: PII detection, Jailbreak attempts.
+- **Output Rails**: Hallucination check, Tone check.
+- **Tools**: NeMo Guardrails, Llama Guard.

package/.agent/skills/ai-engineer/references/llm.md

@@ -1,13 +1,45 @@
-# Tech: LLMs & RAG
+# Tech: LLMs & Integration Patterns
 
-## Stack
+## Stack Selection
 
-- **SDK**: Vercel AI SDK or LangChain.
-- **Model**: GPT-4o, Claude 3.5 Sonnet.
-- **Vector DB**: Supabase `pgvector`.
+- **Inference Engine**:
+  - **Complex Reasoning**: GPT-4o, Claude 3.5 Sonnet.
+  - **Fast/Cheap**: Gemini Flash, Haiku, Llama 3 (Groq/Together).
+- **Orchestration**:
+  - **Production**: Vercel AI SDK (Type-safe, streaming first).
+  - **Prototyping**: LangChain (Use with caution in production due to abstraction overhead).
+- **Gateway**: Portkey or Helicone for observability and fallback.
 
-## Best Practices
+## Advanced Patterns
 
-- **Streaming**: Always stream responses using `AIStream`.
-- **Prompts**: Version control your system prompts.
-- **Embeddings**: Normalize text before embedding.
+### 1. Structured Outputs
+
+Stop parsing regex. Use native JSON mode or tool definitions to enforce strict schemas (Zod).
+
+```typescript
+// Example using Vercel AI SDK
+const { object } = await generateObject({
+  model: openai("gpt-4o"),
+  schema: z.object({
+    sentiment: z.enum(["positive", "negative"]),
+    reasoning: z.string(),
+  }),
+  prompt: "Analyze this customer feedback...",
+});
+```
+
+### 2. Reliable Prompt Engineering
+
+- **Chain of Thought (CoT)**: Force the model to "think" before answering. `Let's think step by step.`
+- **Few-Shot Prompting**: Provide 3-5 high-quality examples of input -> output.
+- **System Prompts**: strict role definition, output constraints, and "tone of voice" instructions. Version control these!
+
+### 3. Streaming & UI Integration
+
+- **Optimistic UI**: Show skeleton loaders or predicted text while waiting.
+- **Generative UI**: Stream React components directly from the LLM (Vercel AI SDK RSC).
+
+### 4. Cost Management
+
+- **Token Counting**: Always estimate tokens before sending requests.
+- **Caching**: Cache identical prompts at the edge/gateway layer.

package/.agent/skills/ai-engineer/references/rag-advanced.md

@@ -0,0 +1,42 @@
+# Advanced RAG Patterns
+
+Move beyond naive "chunk & retrieve".
+
+## Retrieval Optimization
+
+### 1. Hybrid Search (Keyword + Semantic)
+
+Dense vectors (semantic) miss exact matches (IDs, acronyms). Sparse vectors (BM25/Splade) miss intent.
+**Solution**: Combine both with Reciprocal Rank Fusion (RRF).
+
+- **Stack**: Pinecone (Hybrid), Weaviate, Supabase (pgvector + pg_search).
+
+### 2. Re-Ranking (Cross-Encoders)
+
+Retrieving 50 docs with a bi-encoder is fast but inaccurate.
+**Solution**: Retrieve 50 -> Re-rank top 5 with a Cross-Encoder (Cohere Rerank, bge-reranker). This dramatically improves precision.
+
+### 3. Query Transformations
+
+Users write bad queries.
+
+- **Expansion**: Generate synonyms or related questions.
+- **Decomposition**: Break complex questions into sub-queries.
+- **HyDE (Hypothetical Document Embeddings)**: Generate a fake answer, embed _that_, and search for similar real chunks.
+
+### 4. Contextual Compression
+
+Don't shove 10 full documents into the context.
+
+- Summarize retrieved docs relative to the query before passing to the LLM.
+
+## Knowledge Graphs (GraphRAG)
+
+For questions requiring global reasoning ("How do the themes in book A relate to book B?").
+
+- Extract entities and relationships -> Store in Graph DB (Neo4j) -> Traverse during retrieval.
+
+## Indexing Strategy
+
+- **Parent-Child Chunking**: Retrieve small chunks (better matching), but return the parent large chunk (better context).
+- **Multi-Vector Retrieval**: Embed summaries for search, but return full raw text for generation.

package/.agent/skills/ai-engineer/references/serving-optimization.md

@@ -0,0 +1,39 @@
+# Serving & Optimization (MLOps)
+
+Moving from "it works on my laptop" to "production scale".
+
+## Observability & Tracing
+
+You cannot debug a stochastic system with `console.log`.
+
+- **Tracing**: Visualize the entire chain (User -> RAG -> Tool -> LLM).
+- **Tools**: LangSmith, Arize Phoenix, Helicone.
+- **Key Metrics**:
+  - **Latency**: Time to First Token (TTFT), Total Latency.
+  - **Cost**: Cost per request, Token usage.
+  - **Quality**: User feedback (Thumbs up/down).
+
+## Optimization Techniques
+
+### 1. Caching (The Semantic Cache)
+
+Don't pay for the same answer twice.
+
+- **Exact Match**: Redis check on prompt string.
+- **Semantic Match**: Check vector distance of prompt embeddings (e.g., "How do I reset password" ~= "modify password steps").
+
+### 2. Latency Reduction
+
+- **Streaming**: Non-negotiable for UX.
+- **Speculative Decoding**: Use a small model to draft, large model to verify.
+- **Quantization**: Run int8/int4 models if self-hosting (vLLM).
+
+### 3. Cost Control
+
+- **Model Cascading**: Try a cheap model (Flash/Haiku) first. If confidence < X, retry with GPT-4.
+- **Fine-tuning**: Fine-tune a small model (Llama 3 8B) on your specific task to match GPT-4 performance at 1/10th the cost.
+
+## Deployment Stack
+
+- **Managed**: Vercel, AWS Bedrock.
+- **Self-Hosted**: vLLM, TGI (Text Generation Inference), Ray Serve.

package/.agent/skills/blockchain-engineer/SKILL.md

@@ -1,23 +1,53 @@
 ---
 name: blockchain-engineer
-description: Blockchain Engineer role. Focuses on smart contracts, web3 integration, and decentralized protocols. Loads specific chain guides.
+description: Expert Blockchain Engineer (10+ Years). Master of Protocol Architecture, Advanced Smart Contract Development, and Security.
 license: MIT
 metadata:
   role: Blockchain Engineer
-  version: "1.0"
+  version: "2.0"
 ---
 
 # Blockchain Engineer
 
-You build the decentralized layer.
+You are an expert Blockchain Engineer with 10+ years of experience at top tech firms. You build the decentralized layer with a focus on security, scalability, and economic robustness.
 
 ## Core Responsibilities
 
-1.  **Smart Contracts**: Immutable code on chain.
-2.  **Web3**: Connecting the frontend to the wallet.
-3.  **Security**: Protecting value.
+1.  **Protocol Architecture**: Design tokenomics, governance structures, and ensuring incentive alignment across the network.
+2.  **Smart Contract Mastery**: End-to-end lifecycle management of smart contracts on EVM (Solidity/Yul) and SVM (Rust/Anchor).
+3.  **Advanced Security**: Protect value through formal verification, fuzzing, and rigorous audit preparation.
+4.  **Scaling Solutions**: Architect solutions using L2s, Optimistic/ZK Rollups, and AppChains.
+
+## Technical Standards & Best Practices
+
+### Development Lifecycle
+
+- **Environment**: Master usage of Hardhat and Foundry (Forge/Cast/Anvil) for EVM; Anchor for Solana.
+- **Testing**: Beyond unit tests—implement invariant testing, fuzzing (Echo/Medusa), and fork testing.
+- **CI/CD**: Automated pipelines for linting, testing, and deterministic deployments.
+
+### Optimization & Quality
+
+- **Gas Golfing**: Optimize for gas efficiency using Yul/Assembly, storage layout packing, and calldata mastery.
+- **Code Quality**: Enforce NatSpec documentation, strict linting (Solhint/Clippy), and clean code patterns.
+
+### Deployment & Ops
+
+- **Patterns**: Use deterministic deployment (Create2) and manage upgrades via standard proxies (Transparent, UUPS, Diamond/EIP-2535).
+- **Security**: Manage keys via Multi-sig (Gnosis Safe) and Timelocks. Automate ops with scripting.
+
+## Architecture Patterns
+
+- **Upgradeability**: Future-proof contracts using Transparent, UUPS, or Diamond patterns.
+- **Interoperability**: Connect chains using Bridges, Atomic Swaps, and CCIP.
+- **Data Integration**: Index data with Subgraphs (The Graph) and secure external feeds via Oracles (Chainlink, Pyth).
 
 ## Dynamic Stack Loading
 
-- **EVM (Ethereum/Polygon)**: [Read specific guide](references/evm.md)
+- **EVM (Ethereum/Polygon/Arbitrum)**:
+  - [EVM Overview](references/evm.md)
+  - [Solidity Development](references/solidity.md)
+  - [Deployment & Ops](references/deployment.md)
+  - [Mechanisms & Internals](references/mechanisms.md)
 - **Solana**: (Create `references/solana.md` if needed)
+- **ZK & Privacy**: Focus on ZK-SNARKs/STARKs for privacy and scaling.

package/.agent/skills/blockchain-engineer/references/deployment.md

@@ -0,0 +1,28 @@
+# Tech: Smart Contract Deployment
+
+## Strategies
+
+- **Immutable**: Simple deployment. Code cannot be changed. High trust, low flexibility.
+- **Upgradeable Proxies**:
+  - **Transparent Upgradeable Proxy**: Admin logic separated. High gas overhead.
+  - **UUPS (Universal Upgradeable Proxy Standard)**: Upgrade logic in implementation. Cheaper gas.
+  - **Diamond (EIP-2535)**: Modular system, unlimited size, complex management.
+
+## Automation & Tooling
+
+- **Hardhat Ignition**: Declarative deployment modules. Handles dependency management and recovery.
+- **Foundry Script**: Solidity-based scripting (`forge script`). Fast and integrated with Forge tests.
+- **Deterministic Deployment**:
+  - Use `CREATE2` to deploy to the same address across multiple chains.
+  - Tool: `Nick's Method` factory / `Arachnid/deterministic-deployment-proxy`.
+
+## Verification
+
+- **Etherscan/Block Explorers**: ALWAYs verify source code.
+- **Sourcify**: Decentralized verification based on metadata hash.
+
+## Operational Safety
+
+- **Multisig (Gnosis Safe)**: Never deploy or manage admin keys with a single EOA (Externally Owned Account).
+- **Timelocks**: Enforce a delay (e.g., 48h) between proposing and executing sensitive admin actions.
+- **Access Control Rotation**: Plan for key rotation procedures.

package/.agent/skills/blockchain-engineer/references/mechanisms.md

@@ -0,0 +1,32 @@
+# Tech: Blockchain Mechanisms & Internals
+
+## Consensus
+
+- **PoS (Proof of Stake)**: Validators stake tokens to propose/attest blocks. (Ethereum, Solana).
+- **PoW (Proof of Work)**: Miners solve cryptographic puzzles. (Bitcoin).
+- **Finality**:
+  - **Probabilistic**: Bitcoin (wait ~6 blocks).
+  - **Deterministic**: Ethereum (after finalized epoch), Tendermint (instant).
+
+## State Management
+
+- **Account Model (Ethereum/Solana)**: Global state tracks account balances and nonce.
+- **UTXO (Bitcoin/Cardano)**: Unspent Transaction Outputs. State is the set of all unspent outputs.
+- **Data Structures**:
+  - **Merkle Patricia Trie (Ethereum)**: Storage, State, Transactions, Receipts.
+  - **Verkle Trees**: Future upgrade for stateless clients.
+
+## Transaction Lifecycle
+
+1.  **Creation**: User signs tx with private key.
+2.  **Propagation**: Gossip protocol sends tx to Mempool.
+3.  **Ordering**: Block Builders/Proposers select and order txs (MEV opportunity here).
+4.  **Execution**: EVM executes logic, updates state trie.
+5.  **Finalization**: Block is added to chain and finalized by consensus.
+
+## EVM Internals
+
+- **Stack**: 1024 depth, 256-bit words. Most gas efficient.
+- **Memory**: Linear, byte-addressable. Expanded in 32-byte chunks.
+- **Storage**: Key-value store (256-bit -> 256-bit). Most expensive. SLOAD/SSTORE.
+- **Logs**: Bloom filters used for event indexing. Cheaper than storage but not accessible by contracts.

package/.agent/skills/blockchain-engineer/references/solidity.md

@@ -0,0 +1,32 @@
+# Tech: Solidity Development
+
+## Best Practices
+
+- **Layout**: Follow [Solidty Style Guide](https://docs.soliditylang.org/en/latest/style-guide.html).
+  - Order: Pragma -> Import -> Interfaces -> Libraries -> Contracts.
+  - Inside Contract: Type declarations -> State vars -> Events -> Modifiers -> Functions.
+- **Naming**: `camelCase` for variables/functions, `CapWords` for contracts/structs/events, `UPPER_CASE` for constants.
+- **Error Handling**: Use custom errors (`error InsufficientFunds()`) instead of strings for gas efficiency.
+
+## Advanced Concepts
+
+- **Storage Layout**: Understand slot packing to minimize storage costs.
+  - Pack `uint128`, `address`, `bool` into single 256-bit slots where possible.
+- **Delegatecall**: Execution in the context of the caller (crucial for proxies).
+- **Assembly (Yul)**: Use `assembly { ... }` for low-level memory manipulation and gas optimization.
+- **EIP Standards**:
+  - **ERC-20/721/1155**: Token standards.
+  - **ERC-4626**: Tokenized Vaults.
+  - **ERC-2535**: Diamond Standard.
+
+## Security Patterns
+
+- **Checks-Effects-Interactions**: Update state _before_ making external calls to prevent reentrancy.
+- **Pull over Push**: Let users withdraw funds rather than pushing them to arrays of addresses (avoids DoS).
+- **Access Control**: Use `OwnableTwoStep` or `AccessControl` (RBAC).
+
+## Gas Optimization
+
+- **Calldata**: Use `calldata` instead of `memory` for read-only function arguments.
+- **Unchecked Math**: Use `unchecked { ... }` when overflow/underflow is impossible (Solidity 0.8+ default checks cost gas).
+- **Constants/Immutable**: Use `constant` for literal values and `immutable` for constructor-set values.

package/.agent/workflows/documentation.md

@@ -37,24 +37,81 @@ description: Generate comprehensive documentation (Architecture, API, Specs) fro
 
 1. **Invoke `[lead-architect]` skill** to analyze codebase structure
 2. Identify: tech stack, entry points, API routes, DB schemas
-3. **WAIT** for user to confirm understanding
+3. **Clarify & Confirm**:
+   - **CRITICAL**: If the codebase structure is unclear or ambiguous, **ASK** the user for clarification.
+   - Summarize findings and **WAIT** for user to confirm understanding
 
 ---
 
-## Step A2: Legacy Docs Generation (Architecture, API, Schema)
+## Step A2: Technical Documentation (Architecture, API, Schema)
 
 // turbo
 
 1. **Invoke `[lead-architect]` skill** to create:
    - System Context (C4 Context Diagram)
    - Component View (C4 Component Diagram)
+   - **Sequence Diagrams** for critical business flows
 2. **Invoke `[backend-developer]` skill** to:
-   - Document API endpoints
+   - Document API endpoints (OpenAPI/Swagger styled)
    - Generate Entity Relationship Diagram (ERD)
+   - Document key algorithms or data processing pipelines
 3. Save to `docs/030-Specs/` and `docs/030-Specs/Architecture/`
 
 ---
 
+## Step A3: Functional Documentation (Reverse Engineering)
+
+// turbo
+
+**Objective**: Derive business logic and requirements from the existing implementation.
+
+1. **Invoke `[business-analysis]` skill** to:
+   - Analyze the codebase (controllers, services, frontend views) to understand user flows.
+   - **Reverse Engineer** the PRD/Functional Specs:
+     - Identify high-level Epics.
+     - Document implied User Stories & Acceptance Criteria.
+     - Create Use Case definitions for main features.
+2. **Draft Artifacts**:
+   - `docs/020-Requirements/Reverse-Engineered-Specs.md`
+   - `docs/022-User-Stories/Implied-User-Stories.md`
+3. **Review**: Present these findings to the user to confirm they align with business reality.
+
+---
+
+## Step A4: Operational & Quality Documentation
+
+// turbo
+
+**Objective**: Document how to run, test, and deploy the system.
+
+1. **Invoke `[devops-engineer]` skill** to create:
+   - **Infrastructure**: Document cloud resources, Docker setup (`docs/030-Specs/Architecture/Infrastructure.md`).
+   - **Deployment**: CI/CD pipelines and release process (`docs/030-Specs/Architecture/Deployment.md`).
+   - **Configuration**: Environment variables reference (`docs/030-Specs/Configuration.md`).
+2. **Invoke `[qa-tester]` skill** to create:
+   - **Test Strategy**: Overview of testing tools and approach (`docs/035-QA/Test-Plans/Strategy.md`).
+   - **Coverage Report**: Summary of current test coverage and gaps (`docs/035-QA/Reports/Coverage.md`).
+3. **Invoke `[backend-developer]` skill** to create/update:
+   - **Onboarding**: `docs/060-Manuals/Admin-Guide/Setup-Guide.md` (Prerequisites, installation, running locally).
+   - **Scripts**: Document usage of `package.json` scripts (`docs/060-Manuals/Admin-Guide/Scripts.md`).
+
+---
+
+## Step A5: Project Planning & Strategy
+
+// turbo
+
+**Objective**: Establish high-level strategy and roadmap based on current state.
+
+1. **Invoke `[product-manager]` skill** to:
+   - **Analyze Maturity**: Assess current feature set against typical market standards.
+   - **Reverse Engineer Roadmap**: Draft `docs/010-Planning/Roadmap.md` based on implemented vs. missing features.
+   - **Define Objectives**: Draft `docs/010-Planning/OKRs.md` (Objectives and Key Results) aligned with the project's apparent direction.
+   - **Status Report**: Create a snapshot of current progress (`docs/010-Planning/Sprints/Current-Status.md`).
+2. **Review**: Present these strategic documents to the user for alignment.
+
+---
+
 # MODE B: From Requirements
 
 **Prerequisite**: Existing PRD (from `/brainstorm`).
@@ -68,13 +125,14 @@ description: Generate comprehensive documentation (Architecture, API, Specs) fro
 > - **MUST** use `sequential-thinking` for architectural decisions
 > - Use `context7` with `/vercel/next.js`, `/supabase/supabase` for tech stack research
 
-1. **Invoke `[lead-architect]` skill** to draft:
+1. **Analyze Requirements**: Review the PRD/Roadmap. If there are ambiguities, **ASK** the user to clarify.
+2. **Invoke `[lead-architect]` skill** to draft:
    - High-level system architecture
    - Technology stack decisions
    - Component diagram
    - Data flow overview
-2. Create `draft-sdd.md` artifact
-3. After approval → Save to `docs/030-Specs/Architecture/SDD-{ProjectName}.md`
+3. Create `draft-sdd.md` artifact
+4. After approval → Save to `docs/030-Specs/Architecture/SDD-{ProjectName}.md`
 
 ---
 
@@ -85,6 +143,7 @@ description: Generate comprehensive documentation (Architecture, API, Specs) fro
 1. **Invoke `[business-analysis]` skill** to:
    - Break PRD features into Epics (`docs/022-User-Stories/Epics/`)
    - Define Use Cases with Mermaid diagrams (`docs/020-Requirements/Use-Cases/`)
+   - **Note**: If requirements are vague, ask for clarification.
 2. Create artifacts for review before saving
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienha/anti-chaotic",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Anti-Chaotic - An agent kit for Antigravity to standardize the software development process",
   "main": "index.js",
   "publishConfig": {