0xray 2.1.0 → 2.1.2

package/xray/codex.json

@@ -0,0 +1,598 @@
+{
+  "version": "2.0.1",
+  "lastUpdated": "2026-06-05",
+  "errorPreventionTarget": 0.998,
+  "terms": {
+    "1": {
+      "number": 1,
+      "title": "Progressive Prod-Ready Code",
+      "description": "All code must be production-ready from the first commit. No placeholder, stub, or incomplete implementations. Every function, class, and module must be fully functional and ready for deployment.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "2": {
+      "number": 2,
+      "title": "No Patches/Boiler/Stubs/Bridge Code",
+      "description": "Prohibit temporary patches, boilerplate code, stub implementations, and bridge code. All code must have clear, permanent purpose and complete implementation.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "3": {
+      "number": 3,
+      "title": "Do Not Over-Engineer the Solution",
+      "description": "Solutions should be simple and direct. Focus on the actual problem. Avoid unnecessary abstractions, patterns, or complexity. Keep it minimal and maintainable.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "4": {
+      "number": 4,
+      "title": "Fit for Purpose and Prod-Level Code",
+      "description": "Every piece of code must solve the specific problem it was created for, meet production standards (error handling, logging, monitoring), be maintainable, follow established patterns, and include appropriate tests.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "5": {
+      "number": 5,
+      "title": "Surgical Fixes Where Needed",
+      "description": "Apply precise, targeted fixes. Fix the root cause, not symptoms. Make minimal changes to resolve the issue. Avoid refactoring unrelated code. Preserve existing functionality.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "6": {
+      "number": 6,
+      "title": "Batched Introspection Cycles",
+      "description": "Group introspection and analysis into intentional cycles. Review code in batches, not line-by-line. Combine related improvements. Avoid micro-optimizations during development.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "low"
+    },
+    "7": {
+      "number": 7,
+      "title": "Resolve All Errors (90% Runtime Prevention)",
+      "description": "Zero-tolerance for unresolved errors. All errors must be resolved before proceeding. No console.log debugging or ignored errors. Systematic error handling with proper recovery. 90% of runtime errors prevented through systematic checks.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "8": {
+      "number": 8,
+      "title": "Prevent Infinite Loops",
+      "description": "Guarantee termination in all iterative processes. All loops must have clear termination conditions. Recursive functions must have base cases. Event loops must have exit strategies. Async operations must have timeout mechanisms.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "9": {
+      "number": 9,
+      "title": "Use Shared Global State Where Possible",
+      "description": "Prefer shared state over duplicated state. Single source of truth for data. Centralized state management. Avoid prop-drilling through multiple layers.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "10": {
+      "number": 10,
+      "title": "Single Source of Truth",
+      "description": "Maintain one authoritative source for each piece of information. Configuration stored in one place. Data models defined once. API contracts specified in a single location.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "11": {
+      "number": 11,
+      "title": "Type Safety First",
+      "description": "Never use any, @ts-ignore, or @ts-expect-error. Leverage TypeScript's type system fully. Use discriminated unions for complex state. Type errors are blocking issues.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "12": {
+      "number": 12,
+      "title": "Early Returns and Guard Clauses",
+      "description": "Validate inputs at function boundaries. Return early for invalid conditions. Reduce nesting with guard clauses. Keep the happy path at the top level.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "13": {
+      "number": 13,
+      "title": "Error Boundaries and Graceful Degradation",
+      "description": "Wrap components in error boundaries. Provide fallback UI when components fail. Implement circuit breakers for external dependencies. Maintain user experience during failures.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "14": {
+      "number": 14,
+      "title": "Immutability Where Possible",
+      "description": "Prefer const over let. Use immutable data structures. Avoid mutating function parameters. Use spread operator or array methods instead of mutation.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "15": {
+      "number": 15,
+      "title": "Separation of Concerns",
+      "description": "Keep UI separate from business logic. Separate data fetching from rendering. Isolate side effects. Clear boundaries between layers. Each component/module has one responsibility.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "16": {
+      "number": 16,
+      "title": "DRY - Don't Repeat Yourself",
+      "description": "Extract repeated logic into reusable functions. Use composition over inheritance. Create shared utilities for common operations. Avoid copy-pasting code.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "17": {
+      "number": 17,
+      "title": "YAGNI - You Aren't Gonna Need It",
+      "description": "Don't implement features that aren't needed now. Avoid 'just in case' code. Build for current requirements, not hypothetical ones. Keep codebase lean and focused.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "18": {
+      "number": 18,
+      "title": "Meaningful Naming",
+      "description": "Variables, functions, and classes should be self-documenting. Use verbs for functions, nouns for classes. Boolean variables should be clear (isLoading, hasError).",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "19": {
+      "number": 19,
+      "title": "Small, Focused Functions",
+      "description": "Each function should do one thing well. Keep functions under 20-30 lines when possible. Reduce complexity by breaking down large functions. Pure functions are easier to test.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "20": {
+      "number": 20,
+      "title": "Consistent Code Style",
+      "description": "Follow existing patterns in the codebase. Use linters and formatters. Maintain consistent formatting. Follow language idioms.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "low"
+    },
+    "21": {
+      "number": 21,
+      "title": "Dependency Injection",
+      "description": "Pass dependencies as parameters. Avoid hardcoded dependencies. Make code testable by injecting mocks. Reduce coupling between components.",
+      "category": "architecture",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "22": {
+      "number": 22,
+      "title": "Interface Segregation",
+      "description": "Define specific, focused interfaces. Avoid god interfaces with too many methods. Clients shouldn't depend on methods they don't use.",
+      "category": "architecture",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "23": {
+      "number": 23,
+      "title": "Open/Closed Principle",
+      "description": "Open for extension, closed for modification. Use polymorphism to add new behavior. Avoid changing existing code when adding features.",
+      "category": "architecture",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "24": {
+      "number": 24,
+      "title": "Single Responsibility Principle",
+      "description": "Each class/module should have one reason to change. Separate concerns into different modules. Keep functions focused on one task.",
+      "category": "architecture",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "25": {
+      "number": 25,
+      "title": "Code Rot Prevention",
+      "description": "Monitor code consolidation. Refactor code that has grown organically. Remove unused code and dependencies. Update deprecated APIs.",
+      "category": "architecture",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "26": {
+      "number": 26,
+      "title": "Test Coverage >85%",
+      "description": "Maintain 85%+ behavioral test coverage. Focus on behavior, not implementation details. Integration tests for critical paths. Unit tests for pure functions.",
+      "category": "testing",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "27": {
+      "number": 27,
+      "title": "Fast Feedback Loops",
+      "description": "Provide immediate validation feedback. Show loading states for async operations. Real-time error messages. Clear success confirmation.",
+      "category": "testing",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "28": {
+      "number": 28,
+      "title": "Performance Budget Enforcement",
+      "description": "Bundle size <2MB. First Contentful Paint <2s. Time to Interactive <5s. Lazy load non-critical components.",
+      "category": "performance",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "29": {
+      "number": 29,
+      "title": "Security by Design",
+      "description": "Validate all inputs. Sanitize data before rendering. Use HTTPS for all requests. Implement rate limiting. Never expose sensitive data.",
+      "category": "security",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "30": {
+      "number": 30,
+      "title": "Accessibility First",
+      "description": "Semantic HTML elements. ARIA labels for interactive elements. Keyboard navigation support. Screen reader compatibility.",
+      "category": "accessibility",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "31": {
+      "number": 31,
+      "title": "Async/Await Over Callbacks",
+      "description": "Use async/await for asynchronous code. Avoid callback hell. Proper error handling with try/catch. Parallel async operations with Promise.all.",
+      "category": "core",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "32": {
+      "number": 32,
+      "title": "Proper Error Handling",
+      "description": "Never ignore errors. Provide context in error messages. Log errors for debugging. Implement retry logic for transient failures.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "33": {
+      "number": 33,
+      "title": "Logging and Monitoring",
+      "description": "Log important events and errors. Use structured logging. Monitor performance metrics. Set up error tracking.",
+      "category": "operations",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "34": {
+      "number": 34,
+      "title": "Documentation Updates",
+      "description": "Update README when adding features. Document API endpoints. Include inline comments for complex logic. Keep architecture diagrams current.",
+      "category": "documentation",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "35": {
+      "number": 35,
+      "title": "Version Control Best Practices",
+      "description": "Atomic commits. Descriptive commit messages. Use feature branches. Pull requests for code review.",
+      "category": "process",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "36": {
+      "number": 36,
+      "title": "Continuous Integration",
+      "description": "Automated testing on every commit. Linting and formatting checks. Build verification. Fast feedback on quality.",
+      "category": "ci-cd",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "37": {
+      "number": 37,
+      "title": "Configuration Management",
+      "description": "Environment variables for secrets. Config files for environment-specific settings. Never commit secrets. Validate configuration on startup.",
+      "category": "operations",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "38": {
+      "number": 38,
+      "title": "Functionality Retention",
+      "description": "Preserve existing functionality when refactoring. Regression testing before changes. Maintain backward compatibility when possible.",
+      "category": "testing",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "39": {
+      "number": 39,
+      "title": "Avoid Syntax Errors",
+      "description": "Code must compile without errors. No syntax violations. No broken builds. TypeScript compilation must succeed.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "40": {
+      "number": 40,
+      "title": "Modular Design",
+      "description": "Clear module boundaries. Low coupling, high cohesion. Reusable components. Pluggable architecture.",
+      "category": "architecture",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "41": {
+      "number": 41,
+      "title": "State Management Patterns",
+      "description": "Choose appropriate state management. Keep state as close to where it's used as possible. Minimize global state. Derive computed state.",
+      "category": "architecture",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "42": {
+      "number": 42,
+      "title": "Code Review Standards",
+      "description": "At least one reviewer for all changes. Focus on correctness, not style. Verify tests are added. Check documentation updates.",
+      "category": "process",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "43": {
+      "number": 43,
+      "title": "Deployment Safety",
+      "description": "Zero-downtime deployments. Feature flags for risky changes. Rollback capability. Monitor deployments closely.",
+      "category": "ci-cd",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "44": {
+      "number": 44,
+      "title": "Infrastructure as Code Validation",
+      "description": "All infrastructure and configuration files must be validated. YAML/JSON syntax validation. Configuration file linting. Schema validation.",
+      "category": "infrastructure",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "45": {
+      "number": 45,
+      "title": "Test Execution Optimization",
+      "description": "Test execution must be optimized. Run unit tests with multiple workers. Stop execution if 5+ tests fail. Use chunked output processing.",
+      "category": "testing",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "46": {
+      "number": 46,
+      "title": "Import Consistency",
+      "description": "All imports must use consistent patterns. No mixed import styles. Use absolute imports with aliased paths. No relative path confusion.",
+      "category": "quality",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "47": {
+      "number": 47,
+      "title": "Module System Consistency",
+      "description": "Use consistent module system throughout. No mixing CommonJS and ESM. Use .js for JS modules, .mjs for ESM. Consistent file extensions.",
+      "category": "quality",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "48": {
+      "number": 48,
+      "title": "Regression Prevention",
+      "description": "All changes must preserve existing functionality. Run full test suite before completion. Verify no functionality is broken. Validate integration points.",
+      "category": "testing",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "49": {
+      "number": 49,
+      "title": "Comprehensive Validation",
+      "description": "Validate all changes against multiple criteria. Syntax, type safety, tests, security. No single-point validation failures.",
+      "category": "validation",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "50": {
+      "number": 50,
+      "title": "Self-Healing Validation",
+      "description": "Automated systems must detect and recover from failures. Self-correction mechanisms for common errors. Automatic retry with backoff.",
+      "category": "resilience",
+      "zeroTolerance": false,
+      "enforcementLevel": "medium"
+    },
+    "51": {
+      "number": 51,
+      "title": "Graceful Degradation",
+      "description": "Systems must handle failures gracefully. Provide meaningful error messages. Fallback behavior when primary path fails.",
+      "category": "resilience",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "52": {
+      "number": 52,
+      "title": "Agent Spawn Governance",
+      "description": "All agent spawning must go through the AgentSpawnGovernor. No unauthorized agent creation. All spawns must be authorized, tracked, and monitored. Rate limits and concurrent limits must be enforced.",
+      "category": "governance",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "53": {
+      "number": 53,
+      "title": "Subagent Spawning Prevention",
+      "description": "Subagents cannot spawn other subagents. Only the main orchestrator may spawn agents. Prevents infinite loops and resource exhaustion. Violations result in immediate termination.",
+      "category": "governance",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "54": {
+      "number": 54,
+      "title": "Concurrent Agent Limits",
+      "description": "Maximum concurrent agents must be limited. Default limit: 8 total concurrent. Per-agent type limits enforced. Exceeding limits requires authorization.",
+      "category": "governance",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "55": {
+      "number": 55,
+      "title": "Emergency Memory Cleanup",
+      "description": "Automatic cleanup when memory threshold exceeded. Emergency threshold: 80MB. Trigger cleanup when exceeded. Log all cleanup actions.",
+      "category": "governance",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "56": {
+      "number": 56,
+      "title": "Infinite Spawn Pattern Detection",
+      "description": "Detect and prevent recursive spawning patterns. Monitor spawn history. Block patterns that indicate infinite recursion. Log all blocked attempts.",
+      "category": "governance",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "57": {
+      "number": 57,
+      "title": "Spawn Rate Limiting",
+      "description": "Limit on how many agents can spawn per time window. Prevents rapid spawn accumulation. Requires cooldown period between spawns.",
+      "category": "governance",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "58": {
+      "number": 58,
+      "title": "PostProcessor Validation Chain",
+      "description": "All code changes must pass through PostProcessor validation. Pre-deployment validation required. Security scanning required. Regression detection required.",
+      "category": "governance",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "59": {
+      "number": 59,
+      "title": "Multi-Agent Coordination",
+      "description": "Complex tasks require multi-agent coordination through orchestrator. Direct agent-to-agent communication prohibited. All coordination through coordinator.",
+      "category": "governance",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "60": {
+      "number": 60,
+      "title": "Regression Analysis Integration",
+      "description": "Changes must be analyzed for regression potential. Cascade pattern detection. Code removal attempt detection. AI degradation pattern detection.",
+      "category": "governance",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "61": {
+      "number": 61,
+      "title": "Do One Thing at a Time",
+      "description": "Focus on a single task until completion. Do not multitask or juggle multiple changes simultaneously. Complete one fix, feature, or refactor before starting the next. Context switching reduces quality and increases error rate.",
+      "category": "process",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "62": {
+      "number": 62,
+      "title": "Triage. Fix. Loop.",
+      "description": "When addressing issues: first triage to assess scope and severity, then fix the root cause, then loop back to verify. Never skip triage. Never fix without verification. Repeat for each issue independently.",
+      "category": "process",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "63": {
+      "number": 63,
+      "title": "Watch Commands for Errors",
+      "description": "Always monitor command output for errors, warnings, and unexpected behavior. Do not assume success based on exit codes alone. Read stderr and stdout for clues. Investigate any unexpected output before proceeding.",
+      "category": "core",
+      "zeroTolerance": true,
+      "enforcementLevel": "blocking"
+    },
+    "64": {
+      "number": 64,
+      "title": "Always Add .gitignore",
+      "description": "Every project must have an appropriate .gitignore file covering build artifacts, dependencies, environment files, OS files, IDE files, and runtime-generated files. Never commit generated, transient, or sensitive files.",
+      "category": "operations",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "65": {
+      "number": 65,
+      "title": "Write Tests for New Code or Functions",
+      "description": "Any new code, function, module, or component must have corresponding tests. Unit tests for pure logic, integration tests for boundaries. No production code without test coverage. Tests must validate behavior, not implementation.",
+      "category": "testing",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "66": {
+      "number": 66,
+      "title": "Modular Integration and E2E Tests",
+      "description": "Write integration and end-to-end tests in a modular, independently-runnable fashion so each test can be individually triaged and fixed. Run the full battery of integration/E2E tests only after major subsystem development, builds, commits, or releases. During active development, run only the relevant subset for fast feedback.",
+      "category": "testing",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "67": {
+      "number": 67,
+      "title": "Use Best Subagents, Reuse Session Context",
+      "description": "Delegate work to the best-suited subagent for each task. Stay responsive to user inquiries, additional todos, and course corrections. Reuse the same subagent via session ID to preserve context and avoid restarting from zero. Do not spawn fresh agents when an existing one has the relevant context.",
+      "category": "process",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    },
+    "68": {
+      "number": 68,
+      "title": "Lead Dev Mindset — Ownership to Completion",
+      "description": "Act as the lead developer. Take ownership. Implement production-ready code without asking for permission or confirmation. Loop, iterate, and test until fully functional. Do not ask questions — make decisions and execute. Deliver complete, tested solutions.",
+      "category": "process",
+      "zeroTolerance": false,
+      "enforcementLevel": "high"
+    }
+  },
+  "interweaves": [
+    "Error Prevention Interweave",
+    "Performance Interweave",
+    "Security Interweave",
+    "Governance Interweave"
+  ],
+  "lenses": [
+    "Code Quality Lens",
+    "Maintainability Lens",
+    "Performance Lens",
+    "Governance Lens"
+  ],
+  "principles": [
+    "SOLID Principles",
+    "DRY Principles",
+    "KISS Principles",
+    "YAGNI Principles"
+  ],
+  "antiPatterns": [
+    "Spaghetti code",
+    "Lasagna code",
+    "Ravioli code",
+    "Tight coupling",
+    "Circular dependencies",
+    "Golden hammer",
+    "Cowboy coding"
+  ],
+  "validationCriteria": {
+    "All functions have implementations": true,
+    "No TODO comments in production code": true,
+    "All error paths are handled": true,
+    "Edge cases are covered": true,
+    "TypeScript compilation succeeds": true,
+    "Tests pass (unit, integration, E2E)": true,
+    "Integration and E2E tests are modular and individually triageable": true,
+    "Subagent selection uses best fit with context reuse": true,
+    "Lead dev ownership drives code to completion": true,
+    "No security vulnerabilities": true,
+    "No type errors or any usage": true,
+    "Agent spawns go through governor": true,
+    "Subagent spawning prevented": true,
+    "PostProcessor validation passes": true
+  },
+  "frameworkAlignment": {
+    "OpenCode": "v1.1.1",
+    "0xRay": "v2.0.0"
+  }
+}

package/xray/config.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "./config.schema.json",
+  "version": "2.0.1",
+  "description": "0xRay Framework - Token Management & Performance Configuration",
+  "token_management": {
+    "maxPromptTokens": 20000,
+    "warningThreshold": 15000,
+    "modelLimits": {},
+    "contextPruning": {
+      "enabled": true,
+      "aggressivePruning": true,
+      "preserveCriticalContext": true
+    }
+  },
+  "cache_settings": {
+    "enabled": true,
+    "max_size_mb": 25,
+    "ttl_seconds": 120,
+    "auto_cleanup_interval_seconds": 60
+  },
+  "memory_management": {
+    "max_heap_mb": 512,
+    "gc_interval_ms": 30000,
+    "force_gc_on_threshold": true
+  }
+}