zrb 1.15.3__py3-none-any.whl → 1.21.29__py3-none-any.whl

zrb/task/llm/default_workflow/javascript/workflow.md

@@ -0,0 +1,158 @@
+---
+description: "A workflow for developing with JavaScript and TypeScript, including project analysis and best practices."
+---
+Follow this workflow to deliver robust, maintainable JavaScript/TypeScript code that follows project conventions.
+
+# Core Mandates
+
+- **Type Safety First:** Use TypeScript when available, proper typing in JavaScript
+- **Modern Standards:** Follow ES6+ features and best practices
+- **Framework Consistency:** Adhere to project's framework conventions
+- **Tool Integration:** Leverage comprehensive JavaScript tooling ecosystem
+
+# Tool Usage Guideline
+- Use `read_from_file` to analyze package.json and configuration files
+- Use `search_files` to find JavaScript/TypeScript patterns
+- Use `run_shell_command` for npm/yarn/pnpm operations
+- Use `list_files` to understand project structure
+
+# Step 1: Project Analysis
+
+1. **Package Management:** Examine `package.json` and lock files (`package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`)
+2. **TypeScript Configuration:** Check for `tsconfig.json` and TypeScript usage
+3. **Linting Configuration:** Look for `.eslintrc.js`, `.prettierrc`, ESLint config in `package.json`
+4. **Build Configuration:** Analyze `webpack.config.js`, `vite.config.ts`, `rollup.config.js`
+5. **Testing Framework:** Check for `jest.config.js`, `vitest.config.ts`, test directories
+6. **Framework Usage:** Identify React, Vue, Angular, or other framework usage
+
+# Step 2: Understand Conventions
+
+1. **Module System:** Determine ES Modules (`import/export`) vs CommonJS (`require/module.exports`)
+2. **TypeScript Strictness:** Adhere to project's TypeScript configuration
+3. **Framework Patterns:** Follow established component, state management, and routing patterns
+4. **Styling Approach:** Understand CSS-in-JS, CSS modules, or traditional CSS usage
+5. **Testing Strategy:** Follow established test patterns and mocking approaches
+
+# Step 3: Implementation Planning
+
+1. **File Structure:** Plan where new code should be placed based on project conventions
+2. **Type Definitions:** Plan TypeScript interfaces and types for new functionality
+3. **Component Design:** Design React/Vue/Angular components following established patterns
+4. **State Management:** Determine appropriate state management approach
+5. **Testing Strategy:** Plan comprehensive unit, integration, and end-to-end tests
+
+# Step 4: Write Code
+
+## Code Quality Standards
+- **Formatting:** Use Prettier with project configuration
+- **Linting:** Follow ESLint rules and address all warnings
+- **Type Safety:** Use TypeScript strictly when available
+- **Naming:** Use clear, descriptive names following project conventions
+- **Documentation:** Add JSDoc/TSDoc for complex functions and public APIs
+
+## Framework-Specific Patterns
+
+### React
+- **Functional Components:** Use hooks-based functional components
+- **State Management:** Follow established patterns (useState, useReducer, Redux, etc.)
+- **Performance:** Use React.memo, useMemo, useCallback appropriately
+- **Testing:** Use React Testing Library and established testing patterns
+
+### Vue
+- **Composition API:** Prefer Composition API over Options API
+- **State Management:** Use Pinia or Vuex following project patterns
+- **Component Structure:** Follow single-file component conventions
+- **Testing:** Use Vue Test Utils and established testing patterns
+
+### Angular
+- **Component Structure:** Follow Angular module and component conventions
+- **Dependency Injection:** Use Angular's DI system appropriately
+- **RxJS:** Follow established reactive programming patterns
+- **Testing:** Use Angular Testing utilities and established patterns
+
+# Step 5: Testing and Verification
+
+1. **Write Tests:** Create comprehensive tests for all new functionality
+2. **Run Tests:** Execute `npm test` or framework-specific test commands
+3. **Type Checking:** Run `npm run typecheck` or `tsc --noEmit`
+4. **Linting:** Run `npm run lint` to catch code quality issues
+5. **Build Verification:** Run `npm run build` to ensure code compiles correctly
+
+# Step 6: Quality Assurance
+
+## Testing Standards
+- **Unit Tests:** Test individual functions and components in isolation
+- **Integration Tests:** Test component interactions and API integrations
+- **End-to-End Tests:** Test complete user workflows (if configured)
+- **Mocking:** Use appropriate mocking libraries and patterns
+- **Coverage:** Aim for high test coverage of business logic
+
+## Code Review Checklist
+- [ ] Code follows project formatting and linting standards
+- [ ] All tests pass with good coverage
+- [ ] TypeScript compiles without errors (if applicable)
+- [ ] No ESLint warnings
+- [ ] Documentation is complete for complex logic
+- [ ] Performance considerations addressed
+- [ ] Accessibility requirements met
+
+# Step 7: Package Management
+
+## Dependency Management
+- **npm:** Use `npm install <package>` for new dependencies
+- **yarn:** Use `yarn add <package>` for new dependencies
+- **pnpm:** Use `pnpm add <package>` for new dependencies
+- **Version Management:** Follow project's versioning strategy
+
+## Script Execution
+- `npm install` / `yarn install` / `pnpm install`: Install dependencies
+- `npm run dev` / `yarn dev` / `pnpm dev`: Start development server
+- `npm run build` / `yarn build` / `pnpm build`: Build for production
+- `npm run lint` / `yarn lint` / `pnpm lint`: Run linting
+
+# Step 8: Finalize and Deliver
+
+1. **Verify Dependencies:** Ensure dependency versions are consistent
+2. **Run Full Test Suite:** Verify all existing tests still pass
+3. **Type Checking:** Ensure TypeScript compilation succeeds
+4. **Build Verification:** Confirm production build works correctly
+5. **Documentation:** Update relevant documentation and comments
+
+# Common Commands Reference
+
+## Development
+- `npm run dev`: Start development server
+- `npm run build`: Build for production
+- `npm run typecheck`: Type check TypeScript code
+- `npm run lint`: Run ESLint
+- `npm run format`: Format code with Prettier
+
+## Testing
+- `npm test`: Run tests
+- `npm run test:watch`: Run tests in watch mode
+- `npm run test:coverage`: Run tests with coverage
+- `npm run test:e2e`: Run end-to-end tests (if configured)
+
+## Debugging
+- Browser developer tools for frontend debugging
+- `node --inspect` for Node.js debugging
+- Framework-specific debugging tools
+
+# Risk Assessment Guidelines
+
+## Low Risk (Proceed Directly)
+- Adding tests to existing test suites
+- Implementing utility functions following established patterns
+- Creating new components in established patterns
+
+## Moderate Risk (Explain and Confirm)
+- Modifying core application state
+- Changing public API interfaces
+- Adding new dependencies
+- Modifying build configuration
+
+## High Risk (Refuse and Explain)
+- Breaking TypeScript strict mode compliance
+- Modifying critical security components
+- Changes affecting multiple applications
+- Operations that could break the build system

zrb/task/llm/default_workflow/python/workflow.md

@@ -0,0 +1,160 @@
+---
+description: "A workflow for developing with Python, including project analysis and best practices."
+---
+Follow this workflow to deliver clean, maintainable Python code that follows PEP standards and project conventions.
+
+# Core Mandates
+
+- **PEP 8 Compliance:** Follow Python style guide unless project specifies otherwise
+- **Type Safety:** Use type hints when project supports them
+- **Virtual Environments:** Always work within appropriate Python environments
+- **Testing Excellence:** Write comprehensive tests for all functionality
+
+# Tool Usage Guideline
+- Use `read_from_file` to analyze pyproject.toml, requirements.txt, and source code
+- Use `search_files` to find Python patterns and conventions
+- Use `run_shell_command` for Python toolchain operations
+- Use `list_files` to understand project structure
+
+# Step 1: Project Analysis
+
+1. **Dependency Management:** Examine `pyproject.toml`, `requirements.txt`, `setup.py`
+2. **Virtual Environment:** Check for `.venv`, `venv`, or other environment indicators
+3. **Python Version:** Look for `.python-version` or configuration in `pyproject.toml`
+4. **Linting Configuration:** Check for `ruff.toml`, `.flake8`, `.pylintrc`
+5. **Type Checking:** Look for `mypy.ini`, `pyrightconfig.json`
+6. **Testing Framework:** Analyze `tests/` directory, `pytest.ini`, `tox.ini`
+
+# Step 2: Environment Setup
+
+1. **Activate Virtual Environment:**
+   ```bash
+   source .venv/bin/activate  # Linux/Mac
+   .venv\Scripts\activate     # Windows
+   ```
+2. **Create Environment if Missing:**
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   pip install -e .  # Install project in development mode
+   ```
+3. **Install Dependencies:** Use appropriate package manager (pip, poetry, pdm)
+
+# Step 3: Understand Conventions
+
+1. **Code Style:** Adhere to project's configured linter (ruff, flake8, pylint)
+2. **Type Hints:** Use type hints if project supports them, following existing patterns
+3. **Import Organization:** Follow project's import sorting (isort, ruff)
+4. **Docstring Format:** Match existing format (Google, NumPy, reStructuredText)
+5. **Testing Patterns:** Follow established pytest or unittest patterns
+
+# Step 4: Implementation Planning
+
+1. **Module Structure:** Plan where new code should be placed
+2. **Class Design:** Design classes following Pythonic principles
+3. **Function Design:** Create focused, single-responsibility functions
+4. **Type Annotations:** Plan appropriate type hints for new code
+5. **Testing Strategy:** Plan comprehensive unit and integration tests
+
+# Step 5: Write Code
+
+## Code Quality Standards
+- **Formatting:** Use black, autopep8, or ruff format with project configuration
+- **Linting:** Address all linter warnings (ruff, flake8, pylint)
+- **Type Hints:** Add comprehensive type annotations
+- **Documentation:** Write clear docstrings following project format
+- **Naming:** Use snake_case for variables/functions, PascalCase for classes
+
+## Pythonic Patterns
+- **List Comprehensions:** Use for simple transformations
+- **Context Managers:** Use `with` statements for resource management
+- **Generators:** Use for large datasets or streaming data
+- **Decorators:** Use for cross-cutting concerns
+- **Data Classes:** Use for simple data containers (Python 3.7+)
+
+# Step 6: Testing and Verification
+
+1. **Write Tests:** Create comprehensive tests using project's test framework
+2. **Run Tests:** Execute `pytest` or `python -m unittest`
+3. **Type Checking:** Run `mypy` or `pyright` if configured
+4. **Linting:** Run `ruff check` or project's linter
+5. **Formatting:** Run `black` or project's formatter
+
+# Step 7: Quality Assurance
+
+## Testing Standards
+- **Test Organization:** Follow project's test structure and naming
+- **Fixtures:** Use pytest fixtures for test setup
+- **Mocking:** Use unittest.mock or pytest-mock appropriately
+- **Coverage:** Aim for high test coverage of business logic
+- **Parametrized Tests:** Use for testing multiple input scenarios
+
+## Code Review Checklist
+- [ ] Code follows PEP 8 and project formatting standards
+- [ ] All tests pass with good coverage
+- [ ] Type checking passes (if configured)
+- [ ] No linter warnings
+- [ ] Docstrings are complete and follow project format
+- [ ] Error handling is appropriate
+- [ ] Performance considerations addressed
+
+# Step 8: Package Management
+
+## Dependency Management
+- **pip:** Add to `requirements.txt` and run `pip install -r requirements.txt`
+- **poetry:** Use `poetry add <package>` and `poetry install`
+- **pdm:** Use `pdm add <package>` and `pdm install`
+
+## Common Commands
+- `python -m pytest`: Run tests with pytest
+- `python -m mypy .`: Run type checking with mypy
+- `python -m black .`: Format code with black
+- `python -m ruff check .`: Lint code with ruff
+- `python -m isort .`: Sort imports with isort
+
+# Step 9: Finalize and Deliver
+
+1. **Verify Environment:** Ensure virtual environment is active and dependencies installed
+2. **Run Full Test Suite:** Verify all existing tests still pass
+3. **Static Analysis:** Address any remaining linting or type issues
+4. **Documentation:** Update relevant documentation, docstrings, and README
+5. **Packaging:** Verify package can be built and installed if applicable
+
+# Advanced Python Features
+
+## Modern Python (3.8+)
+- **Walrus Operator:** Use `:=` for assignment in expressions
+- **Structural Pattern Matching:** Use `match`/`case` for complex conditionals
+- **Positional-only Parameters:** Use `/` in function definitions
+- **Dataclasses:** Use for simple data containers
+
+## Performance Optimization
+- **Profiling:** Use cProfile for performance analysis
+- **Caching:** Use functools.lru_cache for expensive function calls
+- **Async/Await:** Use for I/O-bound operations
+- **C Extensions:** Consider for performance-critical code
+
+## Security Considerations
+- **Input Validation:** Validate and sanitize all user inputs
+- **Dependency Security:** Use tools like safety or bandit
+- **Secret Management:** Never hardcode secrets in code
+- **SQL Injection:** Use parameterized queries
+
+# Risk Assessment Guidelines
+
+## Low Risk (Proceed Directly)
+- Adding tests to existing test suites
+- Implementing utility functions following established patterns
+- Creating new modules in established patterns
+
+## Moderate Risk (Explain and Confirm)
+- Modifying core business logic
+- Changing public API interfaces
+- Adding new dependencies
+- Modifying virtual environment or dependency configuration
+
+## High Risk (Refuse and Explain)
+- Breaking backward compatibility
+- Modifying critical security components
+- Changes affecting multiple packages
+- Operations that could break the virtual environment

zrb/task/llm/default_workflow/researching/workflow.md

@@ -0,0 +1,153 @@
+---
+description: "A workflow for finding, synthesizing, and analyzing information from various sources."
+---
+Follow this workflow to deliver accurate, well-sourced, and synthesized research findings.
+
+# Core Mandates
+
+- **Unyielding Objectivity:** Report facts, identify biases, never inject opinions
+- **Source Hierarchy:** Prioritize authoritative sources over secondary ones
+- **Synthesis Excellence:** Connect information into coherent narratives
+- **Comprehensive Attribution:** Cite all significant claims and data points
+
+# Tool Usage Guideline
+- Use `search_internet` for web research and information gathering
+- Use `open_web_page` to read and analyze web content
+- Use `read_from_file` to analyze provided documents and materials
+- Use `write_to_file` to organize research findings and notes
+
+# Step 1: Deconstruct and Strategize
+
+1. **Isolate Core Questions:** Break down the user's request into specific, answerable questions
+2. **Develop Search Strategy:** Create precise keywords, phrases, and boolean operators
+3. **Identify Source Types:** Determine what types of sources will be most valuable
+4. **Plan Research Approach:** Outline the sequence of research activities
+
+# Step 2: Source Evaluation and Collection
+
+## Source Hierarchy (The 3 Tiers)
+
+### Tier 1 (Ground Truth)
+- Official documentation and specifications
+- Peer-reviewed academic papers
+- Direct source code and technical specifications
+- Primary legal/government documents
+- Statistical data from authoritative sources
+
+### Tier 2 (Reputable Reporting)
+- Established news organizations
+- Respected industry publications
+- Books by credible authors and experts
+- Conference proceedings from reputable organizations
+
+### Tier 3 (Qualified Sources)
+- Blog posts by known experts
+- Conference talks and presentations
+- Forum answers from high-reputation users
+- **Always qualify these sources** (e.g., "According to a senior engineer at Google...")
+
+## Research Execution
+1. **Iterative Searching:** Start with best queries, refine based on results
+2. **Cross-Reference:** Verify information across multiple sources
+3. **Source Vetting:** Quickly assess source credibility and potential biases
+4. **Information Extraction:** Pull out relevant facts, figures, and arguments
+
+# Step 3: Information Synthesis
+
+1. **Identify Patterns:** Look for consensus, debates, or evolving understanding
+2. **Connect Dots:** Find relationships between different pieces of information
+3. **Identify Gaps:** Note where information is missing or contradictory
+4. **Structure Findings:** Organize information logically for presentation
+
+# Step 4: Analysis and Reporting
+
+## Report Structure
+- **Bottom Line Up Front (BLUF):** Start with direct, concise answer to main question
+- **Supporting Evidence:** Present synthesized facts and data supporting the BLUF
+- **Methodology:** Explain research approach and sources used
+- **Nuance and Limitations:** Acknowledge conflicting information or data gaps
+- **Citations:** Provide clear attribution for all significant claims
+
+## Quality Standards
+- **Accuracy:** Verify all facts and figures before inclusion
+- **Clarity:** Present complex information in accessible language
+- **Completeness:** Address all aspects of the original question
+- **Objectivity:** Present balanced view without personal bias
+
+# Step 5: Task-Specific Execution
+
+## Comparative Analysis
+- **Structured Comparison:** Use tables or detailed bullet points
+- **Like-for-Like Basis:** Compare items on equivalent criteria
+- **Implication Analysis:** Explain what differences mean in practice
+- **Objective Assessment:** Avoid subjective preferences
+
+## Technical Research
+- **Documentation Analysis:** Read and interpret technical specifications
+- **Code Examination:** Analyze source code when available
+- **Performance Data:** Include benchmarks and performance characteristics
+- **Compatibility Analysis:** Consider integration and compatibility factors
+
+## Market/Industry Research
+- **Market Size:** Include relevant statistics and growth projections
+- **Competitive Landscape:** Analyze key players and their positions
+- **Trend Analysis:** Identify emerging patterns and future directions
+- **Regulatory Environment:** Consider legal and compliance factors
+
+# Step 6: Verification and Quality Control
+
+1. **Fact Checking:** Verify all critical information across multiple sources
+2. **Bias Assessment:** Identify and acknowledge potential biases in sources
+3. **Logical Consistency:** Ensure conclusions follow logically from evidence
+4. **Citation Verification:** Confirm all citations are accurate and accessible
+
+# Step 7: Final Presentation
+
+## Formatting Standards
+- **Clear Headings:** Use descriptive section headings
+- **Bulleted Lists:** Present information in scannable format
+- **Citations:** Use consistent format (e.g., `[Source Name](URL)`)
+- **Visual Organization:** Use tables, charts, or diagrams when helpful
+
+## Delivery Considerations
+- **Executive Summary:** Include high-level findings for quick understanding
+- **Detailed Analysis:** Provide comprehensive information for deep dives
+- **Actionable Insights:** Highlight implications and recommended actions
+- **Further Reading:** Suggest additional resources for interested readers
+
+# Risk Assessment Guidelines
+
+## Low Risk (Proceed Directly)
+- Researching publicly available information
+- Synthesizing information from authoritative sources
+- Creating comparative analyses of established products
+
+## Moderate Risk (Explain and Confirm)
+- Research involving proprietary or sensitive information
+- Analysis that could have legal or compliance implications
+- Research requiring access to paid or restricted sources
+
+## High Risk (Refuse and Explain)
+- Research involving personal or private information
+- Analysis that could violate terms of service
+- Activities that could be considered hacking or unauthorized access
+
+# Best Practices
+
+## Research Ethics
+- **Respect Copyright:** Properly attribute all sources
+- **Avoid Plagiarism:** Always cite and paraphrase appropriately
+- **Respect Privacy:** Never research personal or private information
+- **Maintain Integrity:** Report findings honestly, even if unexpected
+
+## Efficiency Techniques
+- **Source Tracking:** Keep organized notes of sources and findings
+- **Template Usage:** Use consistent formats for similar research tasks
+- **Tool Proficiency:** Master research tools and techniques
+- **Time Management:** Allocate research time based on question complexity
+
+## Continuous Improvement
+- **Learn from Results:** Analyze what research approaches work best
+- **Update Methods:** Stay current with new research tools and techniques
+- **Expand Knowledge:** Build expertise in relevant domains
+- **Share Insights:** Document successful research strategies

zrb/task/llm/default_workflow/rust/workflow.md

@@ -0,0 +1,162 @@
+---
+description: "A workflow for developing with Rust, including project analysis and best practices."
+---
+Follow this workflow to deliver safe, efficient, and idiomatic Rust code that respects project conventions.
+
+# Core Mandates
+
+- **Memory Safety:** Leverage Rust's ownership system for safe code
+- **Zero-Cost Abstractions:** Use Rust's features without runtime overhead
+- **Idiomatic Patterns:** Follow established Rust conventions and practices
+- **Tool Integration:** Use Cargo and Rust tooling effectively
+
+# Tool Usage Guideline
+- Use `read_from_file` to analyze Cargo.toml and source code
+- Use `search_files` to find Rust patterns and conventions
+- Use `run_shell_command` for Cargo operations
+- Use `list_files` to understand project structure
+
+# Step 1: Project Analysis
+
+1. **Crate Information:** Examine `Cargo.toml` for dependencies, features, and workspace members
+2. **Toolchain Version:** Check `rust-toolchain.toml` for Rust version and components
+3. **Formatting Configuration:** Look for `rustfmt.toml` or `.rustfmt.toml`
+4. **Linting Configuration:** Check `clippy.toml` or `[lints]` section in `Cargo.toml`
+5. **Module Structure:** Analyze `src/lib.rs`, `src/main.rs`, and `src/bin/` directory
+6. **Workspace Configuration:** Check for workspace members in `Cargo.toml`
+
+# Step 2: Understand Conventions
+
+1. **Formatting:** `cargo fmt` is mandatory for all code
+2. **Linting:** `cargo clippy` must pass with project configuration
+3. **Safety:** Avoid `unsafe` blocks unless absolutely necessary and documented
+4. **Error Handling:** Follow project's error handling strategy (anyhow, thiserror, etc.)
+5. **Testing:** Use established test patterns and organization
+
+# Step 3: Implementation Planning
+
+1. **Type Design:** Plan structs, enums, and traits based on project patterns
+2. **Ownership Strategy:** Consider ownership, borrowing, and lifetime requirements
+3. **Error Handling:** Plan appropriate error types and handling
+4. **Concurrency:** Consider async/await or threading requirements
+5. **Testing Strategy:** Plan comprehensive unit and integration tests
+
+# Step 4: Write Code
+
+## Code Quality Standards
+- **Formatting:** All code must be `cargo fmt` compliant
+- **Linting:** Address all `cargo clippy` warnings
+- **Documentation:** Add rustdoc comments for public APIs
+- **Naming:** Follow Rust naming conventions (snake_case for variables/functions, PascalCase for types)
+- **Safety:** Write safe Rust without unnecessary `unsafe` blocks
+
+## Rust Idioms
+- **Result and Option:** Use for error and optional value handling
+- **Ownership System:** Leverage borrowing and lifetimes correctly
+- **Iterators:** Prefer iterator methods over manual loops
+- **Pattern Matching:** Use `match` and `if let` for control flow
+- **Traits:** Use for polymorphism and code organization
+
+# Step 5: Testing and Verification
+
+1. **Write Tests:** Create comprehensive tests using `#[cfg(test)]` modules
+2. **Run Tests:** Execute `cargo test` to verify functionality
+3. **Format Code:** Run `cargo fmt` to ensure proper formatting
+4. **Lint Code:** Run `cargo clippy -- -D warnings` to catch issues
+5. **Build Verification:** Run `cargo check` for fast compilation checking
+
+# Step 6: Quality Assurance
+
+## Testing Standards
+- **Unit Tests:** Place in `#[cfg(test)]` modules within source files
+- **Integration Tests:** Create in `tests/` directory for crate-level testing
+- **Documentation Tests:** Include examples in rustdoc comments
+- **Property Testing:** Use proptest or quickcheck for comprehensive testing
+
+## Code Review Checklist
+- [ ] Code follows project formatting standards
+- [ ] All tests pass with good coverage
+- [ ] No clippy warnings
+- [ ] Error handling is appropriate and idiomatic
+- [ ] Documentation is complete for public APIs
+- [ ] Performance considerations addressed
+- [ ] Memory safety verified
+
+# Step 7: Cargo Operations
+
+## Development Commands
+- `cargo check`: Fast compilation checking
+- `cargo build`: Build the project
+- `cargo run`: Build and run the project
+- `cargo test`: Run all tests
+- `cargo fmt`: Format code
+- `cargo clippy`: Run linter
+
+## Dependency Management
+- `cargo add <dependency>`: Add a new dependency
+- `cargo update`: Update dependencies
+- `cargo tree`: Show dependency tree
+- `cargo audit`: Check for security vulnerabilities
+
+# Step 8: Advanced Rust Features
+
+## Async/Await
+- **Async Runtime:** Use tokio, async-std, or smol based on project
+- **Futures:** Understand and use futures appropriately
+- **Concurrency:** Use channels and synchronization primitives
+
+## Macros
+- **Declarative Macros:** Use for code generation when appropriate
+- **Procedural Macros:** Use for advanced metaprogramming
+- **Attribute Macros:** Use for annotations and code transformation
+
+## Unsafe Code (Use Sparingly)
+- **FFI:** For foreign function interface
+- **Memory Management:** For low-level memory operations
+- **Performance Optimization:** Only when measurements justify
+- **Documentation:** Must document safety invariants
+
+# Step 9: Finalize and Deliver
+
+1. **Verify Dependencies:** Ensure dependency versions are appropriate
+2. **Run Full Test Suite:** Verify all existing tests still pass
+3. **Security Audit:** Run `cargo audit` for security vulnerabilities
+4. **Performance Testing:** Benchmark critical code paths if applicable
+5. **Documentation:** Generate and verify rustdoc documentation
+
+# Common Patterns
+
+## Error Handling
+- **thiserror:** For defining custom error types
+- **anyhow:** For application-level error handling
+- **Result Propagation:** Use `?` operator appropriately
+
+## Concurrency
+- **std::thread:** For CPU-bound parallelism
+- **tokio::spawn:** For async task spawning
+- **std::sync:** For synchronization primitives
+- **crossbeam:** For advanced concurrency patterns
+
+## Performance
+- **Profiling:** Use perf, flamegraph, or cargo instruments
+- **Benchmarking:** Use criterion for reliable benchmarks
+- **Optimization:** Focus on measured bottlenecks
+
+# Risk Assessment Guidelines
+
+## Low Risk (Proceed Directly)
+- Adding tests to existing test modules
+- Implementing utility functions following established patterns
+- Creating new modules in established patterns
+
+## Moderate Risk (Explain and Confirm)
+- Modifying core data structures
+- Changing public trait implementations
+- Adding new dependencies
+- Using `unsafe` blocks
+
+## High Risk (Refuse and Explain)
+- Breaking memory safety guarantees
+- Modifying critical system components
+- Changes affecting multiple crates in workspace
+- Operations that could introduce security vulnerabilities