feat: Release v3.3.2 - Memory Panel Beta, Redis Config, Windows Compat

## Memory Panel (Beta)
- Re-enabled Memory panel with graceful fallback for no backend
- Added "(Beta)" labels to Memory view, commands, and settings
- Users configure their own Redis via REDIS_URL environment variable

## Redis Configuration
- Added REDIS_PUBLIC_URL support for Railway deployments
- Enhanced config source detection for Redis Labs, Railway, Heroku

## Windows Compatibility
- Added platform_utils module for cross-platform support
- Platform detection (is_windows, is_macos, is_linux)
- Platform-specific default directories
- asyncio event loop policy setup for Windows
- CI integration test for cross-platform compatibility

## VSCode Extension
- Excluded test files from compilation (glob/mocha compat issues)
- Full extension compilation verified

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: 2 people

.claude/CLAUDE.md

@@ -0,0 +1,103 @@
+# Cost Optimization Skill
+
+Use this skill when optimizing LLM costs in the Empathy Framework.
+
+## Smart Tier System
+
+### Tier Overview
+| Tier | Models | Cost/1M tokens | Use Case |
+|------|--------|----------------|----------|
+| **cheap** | GPT-4o-mini, Haiku | ~$0.15 | Summarization, extraction |
+| **capable** | GPT-4o, Sonnet 4.5 | ~$3.00 | Code review, bug fixing |
+| **premium** | o1, Opus 4.5 | ~$15.00 | Architecture decisions |
+
+### Potential Savings
+- Using `cheap` instead of `capable`: **80-95% savings**
+- Using `capable` instead of `premium`: **75-80% savings**
+
+## Task-to-Tier Mapping
+
+```python
+TASK_TIER_RECOMMENDATIONS = {
+    # CHEAP tier tasks
+    "summarize": "cheap",
+    "extract_keywords": "cheap",
+    "format_text": "cheap",
+    "simple_classification": "cheap",
+    "count_items": "cheap",
+
+    # CAPABLE tier tasks
+    "code_review": "capable",
+    "bug_fix": "capable",
+    "write_tests": "capable",
+    "explain_code": "capable",
+    "refactor": "capable",
+
+    # PREMIUM tier tasks
+    "architecture_design": "premium",
+    "security_audit": "premium",
+    "complex_reasoning": "premium",
+    "multi_step_planning": "premium",
+}
+```
+
+## Implementation Pattern
+
+```python
+async def optimized_workflow(self) -> WorkflowResult:
+    total_cost = 0.0
+
+    # Step 1: Use CHEAP for initial extraction (saves 90%+)
+    extraction = await self.executor.execute(
+        prompt="Extract key points from this text...",
+        tier="cheap"
+    )
+    total_cost += extraction.cost
+
+    # Step 2: Use CAPABLE for analysis (main task)
+    analysis = await self.executor.execute(
+        prompt=f"Analyze these points: {extraction.content}",
+        tier="capable"
+    )
+    total_cost += analysis.cost
+
+    # Step 3: Use CHEAP for formatting (saves 90%+)
+    formatted = await self.executor.execute(
+        prompt=f"Format this as markdown: {analysis.content}",
+        tier="cheap"
+    )
+    total_cost += formatted.cost
+
+    return WorkflowResult(cost=total_cost, ...)
+```
+
+## Cost Monitoring
+
+```bash
+# Check workflow costs
+python -m empathy_os.cli workflow code-review --path ./src
+
+# View cost breakdown in output
+# Example output:
+# Completed in 2450ms | Cost: $0.0234
+```
+
+## Token Estimation
+
+Before running expensive operations, estimate tokens:
+
+```python
+from empathy_os.models.token_estimator import estimate_tokens, estimate_cost
+
+tokens = estimate_tokens(my_prompt)
+estimated_cost = estimate_cost(tokens, model="claude-sonnet-4-5-20250514")
+print(f"Estimated cost: ${estimated_cost:.4f}")
+```
+
+## Cost Reduction Strategies
+
+1. **Batch Similar Tasks**: Combine multiple small prompts into one
+2. **Cache Responses**: Don't re-query for identical inputs
+3. **Truncate Context**: Only include relevant context, not full files
+4. **Use Streaming**: For long outputs, stream to catch early errors
+5. **Tier Fallback**: Start with `cheap`, only upgrade if quality insufficient

.claude/skills/cost-optimization.md

@@ -0,0 +1,66 @@
+# Debugging Skill
+
+Use this skill when debugging issues in the Empathy Framework.
+
+## Common Issue Categories
+
+### 1. Model/Provider Issues
+- **API Key Missing**: Check `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, or `OLLAMA_BASE_URL`
+- **Model Not Found**: Verify model ID in `src/empathy_os/models/registry.py`
+- **Rate Limits**: Check provider quotas, implement backoff
+
+### 2. Workflow Failures
+- **Import Errors**: Ensure workflow is registered in `workflows/__init__.py`
+- **Type Errors**: Run `python -m mypy src/empathy_os/`
+- **Missing Dependencies**: Check `pyproject.toml` dependencies
+
+### 3. VSCode Extension Issues
+- **Panel Not Loading**: Check webview HTML in `EmpathyDashboardPanel.ts`
+- **Commands Not Working**: Verify registration in `extension.ts` and `package.json`
+- **Message Passing**: Debug `_setWebviewMessageListener` handlers
+
+### 4. Cost Calculation Issues
+- **Zero Cost**: Ensure `result.cost` is accumulated from executor calls
+- **Token Estimation**: Check tiktoken encoding in `token_estimator.py`
+
+## Debugging Commands
+
+```bash
+# Type checking
+python -m mypy src/empathy_os/ --ignore-missing-imports
+
+# Linting
+ruff check src/empathy_os/
+
+# Run specific test
+python -m pytest tests/test_specific.py -v --tb=long
+
+# Check workflow registration
+python -c "from empathy_os.workflows import WORKFLOWS; print(list(WORKFLOWS.keys()))"
+
+# Test executor
+python -c "
+import asyncio
+from empathy_os.models.executor import get_executor
+async def test():
+    ex = get_executor()
+    r = await ex.execute('Say hello', tier='cheap')
+    print(f'Response: {r.content[:100]}...')
+    print(f'Cost: ${r.cost:.6f}')
+asyncio.run(test())
+"
+```
+
+## Log Locations
+- Audit logs: `/var/log/empathy/audit.jsonl`
+- Test output: `pytest --tb=long`
+- VSCode extension: Developer Tools Console
+
+## Quick Fixes
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| `ModuleNotFoundError` | Not installed in dev mode | `pip install -e .` |
+| `AttributeError: 'NoneType'` | Missing config/env | Check `.env` file |
+| `TypeError: cannot unpack` | API response changed | Check model provider docs |
+| `asyncio.TimeoutError` | Slow model response | Increase timeout or use faster tier |

.claude/skills/debugging.md

@@ -0,0 +1,83 @@
+# Security Review Skill
+
+Use this skill when reviewing code for security issues in the Empathy Framework.
+
+## Security Classification
+
+### Data Classification Levels
+- **PUBLIC**: General patterns, safe to share
+- **INTERNAL**: Proprietary algorithms, company-only
+- **SENSITIVE**: Healthcare/HIPAA data, requires encryption
+
+### PII Patterns to Detect
+```python
+# Healthcare PII (HIPAA)
+HEALTHCARE_PII = {
+    "mrn": r'\bMRN:?\s*\d{6,10}\b',       # Medical Record Number
+    "patient_id": r'\bPT\d{6,10}\b',       # Patient ID
+    "insurance_id": r'\bINS\d{8,12}\b',    # Insurance ID
+    "dob": r'\b\d{1,2}/\d{1,2}/\d{4}\b',   # Date of birth
+}
+
+# Software PII
+SOFTWARE_PII = {
+    "internal_id": r'\b[A-Z]{2,4}-\d{4,6}\b',  # JIRA tickets
+    "database_conn": r'(postgresql|mysql|mongodb)://[^"\s]+',
+}
+```
+
+## Security Checklist
+
+### API Keys & Secrets
+- [ ] No hardcoded API keys
+- [ ] Secrets loaded from environment variables
+- [ ] `.env` files in `.gitignore`
+- [ ] No secrets in logs or error messages
+
+### Input Validation
+- [ ] User input sanitized before use
+- [ ] SQL injection prevention (parameterized queries)
+- [ ] Command injection prevention (no `shell=True` with user input)
+- [ ] Path traversal prevention (validate file paths)
+
+### Healthcare Wizards (HIPAA)
+- [ ] All data classified as SENSITIVE
+- [ ] Encryption enabled for storage
+- [ ] 90-day retention policy enforced
+- [ ] Audit logging for all accesses
+
+### Dependencies
+- [ ] Run `pip-audit` for vulnerability scan
+- [ ] Check for outdated packages with known CVEs
+- [ ] Review new dependencies before adding
+
+## Security Tests
+
+```bash
+# Run security test suite
+pytest tests/test_security_controls.py -v
+pytest tests/test_pii_scrubbing.py -v
+pytest tests/test_secrets_detection.py -v
+pytest tests/test_pattern_classification.py -v
+
+# Scan for secrets in git history
+git log -p | grep -E "(api_key|password|secret|token)" --color
+
+# Check for hardcoded credentials
+grep -r "api_key\s*=" --include="*.py" | grep -v "os.getenv"
+```
+
+## Compliance Requirements
+
+| Standard | Requirement | Implementation |
+|----------|-------------|----------------|
+| GDPR | Data minimization | Scrub PII before storage |
+| HIPAA | PHI protection | SENSITIVE classification + encryption |
+| SOC2 | Audit trails | All LLM interactions logged |
+
+## Reporting Security Issues
+
+1. Do NOT commit the vulnerability
+2. Contact: [email protected]
+3. Use secure communication channel
+4. Provide reproduction steps

.claude/skills/security-review.md

@@ -0,0 +1,85 @@
+# Workflow Development Skill
+
+Use this skill when creating or modifying Empathy Framework workflows.
+
+## Context
+
+Empathy Framework workflows are in `src/empathy_os/workflows/`. Each workflow:
+- Inherits from `EmpathyWorkflow` base class
+- Implements `execute()` async method
+- Returns a dataclass result with `cost`, `duration_seconds`, and formatted `report`
+- Uses the multi-tier executor for cost optimization
+
+## Workflow Structure
+
+```python
+from dataclasses import dataclass
+from empathy_os.workflows.base import EmpathyWorkflow, WorkflowResult
+
+@dataclass
+class MyWorkflowResult(WorkflowResult):
+    """Custom result fields."""
+    specific_data: str = ""
+
+    def format_report(self) -> str:
+        """Format as human-readable report."""
+        lines = [
+            "# My Workflow Report",
+            "",
+            f"**Result**: {self.specific_data}",
+            "",
+            "---",
+            f"Completed in {self.duration_seconds * 1000:.0f}ms | Cost: ${self.cost:.4f}"
+        ]
+        return "\n".join(lines)
+
+class MyWorkflow(EmpathyWorkflow[MyWorkflowResult]):
+    """Description of what this workflow does."""
+
+    name = "my-workflow"
+    description = "Brief description"
+
+    async def execute(self, **kwargs) -> MyWorkflowResult:
+        start_time = time.time()
+        total_cost = 0.0
+
+        # Use appropriate tier for each task
+        # cheap: summarization, simple extraction
+        # capable: code review, bug fixing
+        # premium: architecture decisions
+
+        result = await self.executor.execute(
+            prompt="...",
+            tier="capable"
+        )
+        total_cost += result.cost
+
+        duration = time.time() - start_time
+        return MyWorkflowResult(
+            success=True,
+            cost=total_cost,
+            duration_seconds=duration,
+            specific_data=result.content
+        )
+```
+
+## Key Patterns
+
+1. **Tier Selection**: Use `cheap` for 80-96% cost savings on simple tasks
+2. **Cost Tracking**: Always accumulate `result.cost` from each executor call
+3. **Report Format**: Use milliseconds for duration, 4 decimal places for cost
+4. **Error Handling**: Set `success=False` and include error in report
+
+## Registration
+
+Add to `src/empathy_os/workflows/__init__.py`:
+```python
+from .my_workflow import MyWorkflow
+WORKFLOWS["my-workflow"] = MyWorkflow
+```
+
+## Testing
+
+```bash
+python -m empathy_os.cli workflow my-workflow --arg value
+```

.claude/skills/workflow-development.md

@@ -5,6 +5,57 @@ All notable changes to the Empathy Framework will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+**Windows Compatibility**
+- New `platform_utils` module for cross-platform support
+  - Platform detection functions (`is_windows()`, `is_macos()`, `is_linux()`)
+  - Platform-appropriate directory functions for logs, data, config, and cache
+  - Asyncio Windows event loop policy handling (`setup_asyncio_policy()`)
+  - UTF-8 encoding utilities for text files
+  - Path normalization helpers
+- Cross-platform compatibility checker script (`scripts/check_platform_compat.py`)
+  - Detects hardcoded Unix paths, missing encoding, asyncio issues
+  - JSON output mode for CI integration
+  - `--fix` mode with suggested corrections
+- CI integration for platform compatibility checks in GitHub Actions
+- Pre-commit hook for platform compatibility (manual stage)
+- Pytest integration test for platform compatibility (`test_platform_compat_ci.py`)
+
+### Fixed
+
+- Hardcoded Unix paths in `audit_logger.py` now use platform-appropriate defaults
+- Added `setup_asyncio_policy()` call in CLI entry point for Windows compatibility
+
+### Changed
+
+- Updated `.claude/python-standards.md` with cross-platform coding guidelines
+
+---
+
+## [3.3.1] - 2025-12-27
+
+### Fixed
+
+- Updated Anthropic capable tier from Sonnet 4 to Sonnet 4.5 (`claude-sonnet-4-5-20250514`)
+- Fixed model references in token_estimator and executor
+- Fixed Setup button not opening Initialize Wizard (added `force` parameter)
+- Fixed Cost Simulator layout for narrow panels (single-column layout)
+- Fixed cost display inconsistency between workflow report and CLI footer
+- Unified timing display to use milliseconds across all workflow reports
+- Removed redundant CLI footer (workflow reports now contain complete timing/cost info)
+- Fixed all mypy type errors across empathy_os and empathy_llm_toolkit
+- Fixed ruff linting warnings (unused variables in dependency_check.py, document_gen.py)
+
+### Changed
+
+- All workflow reports now display duration in milliseconds (e.g., `Review completed in 15041ms`)
+- Consistent footer format: `{Workflow} completed in {ms}ms | Cost: ${cost:.4f}`
+
+---
+
 ## [3.2.3] - 2025-12-24
 
 ### Fixed