docs: Apply global fixes for v0.7.0 Temporal architecture

- Replace docker-compose.temporal.yaml → docker-compose.yml
- Replace Temporal UI port :8233 → :8080
- Replace repository URL fuzzforge.git → fuzzforge_ai.git

Affected files:
- concept/docker-containers.md
- concept/resource-management.md
- concept/sarif-format.md
- how-to/create-workflow.md
- how-to/debugging.md
- how-to/troubleshooting.md
- tutorial/getting-started.md

docs/blog/2025-01-16-v0.7.0-temporal-workers-release.md

@@ -0,0 +1,321 @@
+# FuzzForge v0.7.0: Temporal Orchestration & Vertical Workers Architecture
+
+We're excited to announce **FuzzForge v0.7.0**, a major release featuring two significant improvements:
+
+1. **Architectural Foundation**: Complete migration from Prefect to **Temporal** orchestration with **vertical workers** - pre-built containers for instant deployment
+2. **AI-Powered Secret Detection**: New workflows achieving 84% recall on obfuscated secrets using LLM semantic analysis
+
+This release transforms how security workflows are built, deployed, and scaled.
+
+<!-- truncate -->
+
+## 🚀 Flagship Features
+
+### Temporal Orchestration: Production-Ready Workflow Engine
+
+We've fully migrated from Prefect to [Temporal](https://temporal.io), bringing enterprise-grade workflow orchestration to FuzzForge:
+
+**Why Temporal?**
+
+- ✅ **Reliability**: Automatic retries, timeouts, and failure handling built-in
+- ✅ **Observability**: World-class UI for monitoring workflow execution, logs, and debugging
+- ✅ **Scalability**: Horizontal scaling across workers with intelligent load balancing
+- ✅ **Developer Experience**: Type-safe workflows, versioning, and zero downtime deployments
+
+**What This Means for You:**
+
+```bash
+# Start FuzzForge with Temporal
+docker compose up -d
+
+# Monitor workflows in real-time
+open http://localhost:8080  # Temporal UI
+
+# Submit workflows - everything just works
+cd your_project/
+ff workflow run security_assessment .
+```
+
+The Temporal UI gives you complete visibility into workflow execution:
+
+- Live activity timelines
+- Detailed logs for every step
+- Retry history and failure analysis
+- Performance metrics and bottleneck detection
+
+### Vertical Workers: Pre-Built Security Toolchains
+
+FuzzForge now uses **vertical workers** - long-lived containers pre-built with security toolchains for different languages and platforms:
+
+| Worker      | Toolchain                     | Status        | Available Workflows                   |
+| ----------- | ----------------------------- | ------------- | ------------------------------------- |
+| **python**  | Gitleaks, TruffleHog, Atheris | ✅ Production | Secret detection, security assessment |
+| **rust**    | cargo-fuzz                    | ⚠️ Early Dev  | Rust fuzzing                          |
+| **ossfuzz** | OSS-Fuzz infrastructure       | ⚠️ Heavy Dev  | Continuous fuzzing campaigns          |
+
+**Note:** Additional workers (web, android, Go) are planned but not yet available.
+
+**Key Benefits:**
+
+1. **Zero Build Time**: Workflows start instantly - no container builds per workflow
+2. **Instant Code Changes**: Modify workflow code, restart worker, done
+3. **Consistent Environment**: Same toolchain versions across all runs
+4. **Resource Efficiency**: Share workers across multiple concurrent workflows
+
+**Example: Running Secret Detection**
+
+```bash
+# Worker is already running with Gitleaks, TruffleHog installed
+ff workflow run gitleaks_detection .
+
+# Behind the scenes:
+# 1. CLI uploads project to MinIO
+# 2. Temporal schedules on python-worker
+# 3. Worker downloads from MinIO
+# 4. Gitleaks runs (already installed!)
+# 5. Results returned as SARIF
+```
+
+### MinIO Storage: Unified File Handling
+
+We've replaced volume mounts with **MinIO** (S3-compatible object storage):
+
+**Old Way (Volume Mounts):**
+
+```yaml
+# Had to mount directories, manage paths, cleanup manually
+volumes:
+  - ./my_project:/target
+```
+
+**New Way (MinIO):**
+
+```bash
+# CLI handles everything automatically
+ff workflow run security_assessment .
+# ✓ Creates tarball
+# ✓ Uploads to MinIO
+# ✓ Passes target_id to workflow
+# ✓ Worker downloads and extracts
+# ✓ Cleanup handled automatically
+```
+
+**Benefits:**
+
+- ✅ No path conflicts or permissions issues
+- ✅ Works seamlessly with remote Temporal clusters
+- ✅ Automatic cleanup and caching
+- ✅ Supports large targets (GB+)
+
+## 🔍 AI-Powered Secret Detection: Also in v0.7.0
+
+Alongside the architectural improvements, we're releasing a comprehensive **secret detection** system with three workflows:
+
+### Benchmark Results
+
+We tested on a controlled dataset of **32 documented secrets** (12 Easy, 10 Medium, 10 Hard):
+
+| Tool                  | Recall    | Secrets Found | Speed | Best For                    |
+| --------------------- | --------- | ------------- | ----- | --------------------------- |
+| **LLM (gpt-5-mini)**  | **84.4%** | 41            | 618s  | Obfuscated & hidden secrets |
+| **LLM (gpt-4o-mini)** | 56.2%     | 30            | 297s  | Balanced speed/accuracy     |
+| **Gitleaks**          | 37.5%     | 12            | 5s    | Fast pattern-based scanning |
+| **TruffleHog**        | 0.0%      | 1             | 5s    | Entropy analysis            |
+
+📊 [Full benchmark methodology and results →](https://github.com/FuzzingLabs/fuzzforge_ai/blob/dev/backend/benchmarks/by_category/secret_detection/results/comparison_report.md)
+
+### Why LLM-Based Detection Wins
+
+**Obfuscated Secrets (Medium Difficulty):**
+
+```python
+# Gitleaks: ❌ Missed (no pattern match)
+# LLM: ✅ Found (semantic understanding)
+aws_key = base64.b64decode("QUtJQUlPU0ZPRE5ON0VYQU1QTEU=").decode()
+```
+
+**Well-Hidden Secrets (Hard Difficulty):**
+
+```python
+# Gitleaks: ❌ Missed (no pattern)
+# LLM: ✅ Found (understands XOR + join)
+secret = ''.join(chr(ord(c) ^ 0x42) for c in "\x0b\x15\x04\x1b...")
+```
+
+**Standard Secrets (Easy Difficulty):**
+
+```python
+# Both find these:
+AWS_ACCESS_KEY = "AKIAIOSFODNN7EXAMPLE"
+```
+
+### Try It Yourself
+
+```bash
+# Start FuzzForge
+docker compose up -d
+
+# Run secret detection on your code
+cd your_project/
+ff workflow run gitleaks_detection .      # Fast pattern-based
+ff workflow run trufflehog_detection .    # Entropy analysis
+ff workflow run llm_secret_detection .    # AI semantic analysis
+
+# Get SARIF output
+ff finding <run-id>
+```
+
+## 📊 Real-World Impact
+
+**Before v0.7.0 (Pattern-Only Detection):**
+
+- Found: Standard API keys, simple patterns
+- Missed: Base64-encoded secrets, obfuscated credentials, split secrets
+
+**After v0.7.0 (LLM + Patterns):**
+
+- **84% recall** on comprehensive benchmark
+- Detects novel obfuscation techniques
+- Understands code context (not just regex)
+- Catches secrets in:
+  - Base64/hex encoding
+  - String concatenation
+  - XOR/ROT13 obfuscation
+  - Template strings
+  - Binary literals
+
+## 🔄 Migration Guide
+
+### What Changed
+
+**Docker Compose:**
+
+```bash
+# Old (Prefect)
+docker-compose up
+
+# New (Temporal)
+docker compose up -d
+```
+
+**Workflow Submission:**
+
+```bash
+# Old (volume mounts)
+ff workflow run security_assessment --volume ./project
+
+# New (automatic upload)
+ff workflow run security_assessment .
+# CLI handles upload automatically!
+```
+
+**Worker Management:**
+
+```bash
+# Old (per-workflow containers)
+# Each workflow built its own container
+
+# New (vertical workers)
+docker compose up -d  # All workers start
+# Workflows share workers - much faster!
+```
+
+### Configuration
+
+Set up AI workflows with API keys:
+
+```bash
+cp volumes/env/.env.example volumes/env/.env
+# Edit .env and add your API keys (OpenAI, Anthropic, etc.)
+```
+
+Required for:
+
+- `llm_secret_detection` workflow
+- AI agent features (`ff ai agent`)
+
+Basic security workflows (gitleaks, trufflehog, security_assessment) work without this.
+
+## 🏗️ Architecture Overview
+
+```
+┌─────────────┐
+│   User CLI  │ Upload → MinIO
+└──────┬──────┘
+       ↓ Submit
+┌─────────────┐
+│  Temporal   │ Schedule → Task Queue
+└──────┬──────┘
+       ↓ Execute
+┌─────────────┐
+│  Vertical   │ Download from MinIO → Run Tools → Upload Results
+│  Workers    │
+└─────────────┘
+  rust, python, web, android, ossfuzz
+```
+
+**Benefits:**
+
+- 🔄 Automatic retries and timeouts (Temporal)
+- 📦 No file path management (MinIO)
+- ⚡ Zero container build time (Vertical Workers)
+- 📈 Horizontal scaling ready (Temporal + Workers)
+
+## 🎯 Workflow Stability Status
+
+### ✅ Stable & Production-Ready
+
+- **Secret Detection**: `gitleaks_detection`, `trufflehog_detection`, `llm_secret_detection`
+- **Security Assessment**: `security_assessment`
+- Temporal orchestration with python worker
+- MinIO file storage
+
+### ⚠️ Early Development (Functional but not production-ready)
+
+- **Fuzzing workflows**:
+  - `atheris_fuzzing` - Python fuzzing with Atheris
+  - `cargo_fuzzing` - Rust fuzzing with cargo-fuzz
+- **OSS-Fuzz integration**: `ossfuzz_campaign` (under heavy active development)
+
+**Important:** Fuzzing workflows are functional for testing but not recommended for production use yet.
+
+## 📚 Resources
+
+- 🌐 [Website](https://fuzzforge.ai)
+- 📖 [Documentation](https://docs.fuzzforge.ai)
+- 💬 [Discord Community](https://discord.gg/8XEX33UUwZ)
+- 🎓 [FuzzingLabs Academy](https://academy.fuzzinglabs.com/?coupon=GITHUB_FUZZFORGE)
+- 📊 [Secret Detection Benchmarks](https://github.com/FuzzingLabs/fuzzforge_ai/blob/dev/backend/benchmarks/by_category/secret_detection/results/comparison_report.md)
+
+## 🙏 Acknowledgments
+
+Special thanks to:
+
+- [Temporal](https://temporal.io) for the amazing workflow engine
+- Our community for feedback during the migration
+
+## 🚀 Get Started
+
+```bash
+# Clone and install
+git clone https://github.com/fuzzinglabs/fuzzforge_ai.git
+cd fuzzforge_ai
+uv tool install --python python3.12 .
+
+# Start FuzzForge with Temporal
+docker compose up -d
+
+# Run your first workflow
+cd test_projects/vulnerable_app/
+fuzzforge init
+ff workflow run security_assessment .
+
+# Check Temporal UI
+open http://localhost:8080
+```
+
+---
+
+**FuzzForge v0.7.0** is a foundational release that sets the stage for scalable, production-ready security automation. Try it today and let us know what you think!
+
+Star us on [GitHub](https://github.com/FuzzingLabs/fuzzforge_ai) ⭐

docs/docs/concept/docker-containers.md

@@ -141,7 +141,7 @@ Example build:
 cd workers/rust
 docker build -t fuzzforge-worker-rust:latest .
 # Or via docker-compose
-docker-compose -f docker-compose.temporal.yaml build worker-rust
+docker-compose -f docker-compose.yml build worker-rust
 ```
 
 ---

docs/docs/concept/resource-management.md

@@ -124,7 +124,7 @@ docker ps -a --filter "name=fuzzforge-worker"
 
 ## Level 1: Docker Container Limits (Primary)
 
-Docker container limits are the **primary enforcement mechanism** for CPU and memory resources. These are configured in `docker-compose.temporal.yaml` and enforced by the Docker runtime.
+Docker container limits are the **primary enforcement mechanism** for CPU and memory resources. These are configured in `docker-compose.yml` and enforced by the Docker runtime.
 
 ### Configuration
 
@@ -267,10 +267,10 @@ Check how many workflows are running:
 
 ```bash
 # View worker logs
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "Starting"
+docker-compose -f docker-compose.yml logs worker-rust | grep "Starting"
 
 # Check Temporal UI
-# Open http://localhost:8233
+# Open http://localhost:8080
 # Navigate to "Task Queues" → "rust" → See pending/running counts
 ```
 
@@ -324,7 +324,7 @@ class SecurityAssessmentWorkflow:
 ```
 
 **Check timeout in Temporal UI:**
-1. Open http://localhost:8233
+1. Open http://localhost:8080
 2. Navigate to workflow execution
 3. See "Timeout" in workflow details
 4. If exceeded, status shows "TIMED_OUT"
@@ -383,7 +383,7 @@ Watch for these warning signs:
 
 ```bash
 # Check for OOM kills
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep -i "oom\|killed"
+docker-compose -f docker-compose.yml logs worker-rust | grep -i "oom\|killed"
 
 # Check for CPU throttling
 docker stats fuzzforge-worker-rust
@@ -413,7 +413,7 @@ To handle more workflows, scale worker containers horizontally:
 
 ```bash
 # Scale rust worker to 3 instances
-docker-compose -f docker-compose.temporal.yaml up -d --scale worker-rust=3
+docker-compose -f docker-compose.yml up -d --scale worker-rust=3
 
 # Now you can run:
 # - 3 workers × 5 concurrent activities = 15 workflows simultaneously
@@ -435,13 +435,13 @@ docker-compose -f docker-compose.temporal.yaml up -d --scale worker-rust=3
 **Diagnosis:**
 ```bash
 # Check worker is alive
-docker-compose -f docker-compose.temporal.yaml ps worker-rust
+docker-compose -f docker-compose.yml ps worker-rust
 
 # Check worker resource usage
 docker stats fuzzforge-worker-rust
 
 # Check for OOM kills
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep -i oom
+docker-compose -f docker-compose.yml logs worker-rust | grep -i oom
 ```
 
 **Solution:**
@@ -459,7 +459,7 @@ docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep -i oom
 docker exec fuzzforge-worker-rust env | grep MAX_CONCURRENT_ACTIVITIES
 
 # Check current workload
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "Starting"
+docker-compose -f docker-compose.yml logs worker-rust | grep "Starting"
 ```
 
 **Solution:**
@@ -557,10 +557,10 @@ Check cache size and cleanup logs:
 docker exec fuzzforge-worker-rust du -sh /cache
 
 # Monitor cache evictions
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "Evicted from cache"
+docker-compose -f docker-compose.yml logs worker-rust | grep "Evicted from cache"
 
 # Check download vs cache hit rate
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep -E "Cache (HIT|MISS)"
+docker-compose -f docker-compose.yml logs worker-rust | grep -E "Cache (HIT|MISS)"
 ```
 
 See the [Workspace Isolation](/docs/concept/workspace-isolation) guide for complete details on isolation modes and when to use each.
@@ -588,7 +588,7 @@ FuzzForge's resource management strategy:
 ---
 
 **Next Steps:**
-- Review `docker-compose.temporal.yaml` resource configuration
+- Review `docker-compose.yml` resource configuration
 - Profile your workflows to determine actual resource usage
 - Adjust limits based on monitoring data
 - Set up alerts for resource exhaustion

docs/docs/concept/sarif-format.md

@@ -45,7 +45,7 @@ Each FuzzForge workflow produces a SARIF "run" containing:
     "driver": {
       "name": "FuzzForge",
       "version": "1.0.0",
-      "informationUri": "https://github.com/FuzzingLabs/fuzzforge",
+      "informationUri": "https://github.com/FuzzingLabs/fuzzforge_ai",
       "organization": "FuzzingLabs",
       "rules": [ /* Security rules applied */ ]
     },

docs/docs/how-to/create-workflow.md

@@ -397,7 +397,7 @@ class DependencyAnalysisWorkflow:
 
 ```bash
 # Start FuzzForge with Temporal
-docker-compose -f docker-compose.temporal.yaml up -d
+docker-compose -f docker-compose.yml up -d
 
 # Wait for services to initialize
 sleep 10
@@ -445,7 +445,7 @@ client.close()
 
 ### Check Temporal UI
 
-Open http://localhost:8233 to see:
+Open http://localhost:8080 to see:
 - Workflow execution timeline
 - Activity results
 - Logs and errors

docs/docs/how-to/debugging.md

@@ -8,10 +8,10 @@ This guide shows you how to debug FuzzForge workflows and modules using Temporal
 
 When something goes wrong:
 
-1. **Check worker logs** - `docker-compose -f docker-compose.temporal.yaml logs worker-rust -f`
+1. **Check worker logs** - `docker-compose -f docker-compose.yml logs worker-rust -f`
-2. **Check Temporal UI** - http://localhost:8233 (visual execution history)
+2. **Check Temporal UI** - http://localhost:8080 (visual execution history)
 3. **Check MinIO console** - http://localhost:9001 (inspect uploaded files)
-4. **Check backend logs** - `docker-compose -f docker-compose.temporal.yaml logs fuzzforge-backend -f`
+4. **Check backend logs** - `docker-compose -f docker-compose.yml logs fuzzforge-backend -f`
 
 ---
 
@@ -41,12 +41,12 @@ When something goes wrong:
 
 4. **Check worker logs for discovery errors:**
    ```bash
-   docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "my_workflow"
+   docker-compose -f docker-compose.yml logs worker-rust | grep "my_workflow"
    ```
 
 **Solution:**
 - Ensure `metadata.yaml` has correct `vertical` field
-- Restart worker to reload: `docker-compose -f docker-compose.temporal.yaml restart worker-rust`
+- Restart worker to reload: `docker-compose -f docker-compose.yml restart worker-rust`
 - Check worker logs for discovery confirmation
 
 ---
@@ -55,10 +55,10 @@ When something goes wrong:
 
 ### Using Temporal Web UI
 
-The Temporal UI at http://localhost:8233 is your primary debugging tool.
+The Temporal UI at http://localhost:8080 is your primary debugging tool.
 
 **Navigate to a workflow:**
-1. Open http://localhost:8233
+1. Open http://localhost:8080
 2. Click "Workflows" in left sidebar
 3. Find your workflow by `run_id` or workflow name
 4. Click to see detailed execution
@@ -86,13 +86,13 @@ The Temporal UI at http://localhost:8233 is your primary debugging tool.
 
 ```bash
 # Follow logs from rust worker
-docker-compose -f docker-compose.temporal.yaml logs worker-rust -f
+docker-compose -f docker-compose.yml logs worker-rust -f
 
 # Follow logs from all workers
-docker-compose -f docker-compose.temporal.yaml logs worker-rust worker-android -f
+docker-compose -f docker-compose.yml logs worker-rust worker-android -f
 
 # Show last 100 lines
-docker-compose -f docker-compose.temporal.yaml logs worker-rust --tail 100
+docker-compose -f docker-compose.yml logs worker-rust --tail 100
 ```
 
 ### What Worker Logs Show
@@ -125,16 +125,16 @@ IndentationError: expected an indented block
 
 ```bash
 # Show only errors
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep ERROR
+docker-compose -f docker-compose.yml logs worker-rust | grep ERROR
 
 # Show workflow discovery
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "Discovered workflow"
+docker-compose -f docker-compose.yml logs worker-rust | grep "Discovered workflow"
 
 # Show specific workflow execution
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "security_assessment-abc123"
+docker-compose -f docker-compose.yml logs worker-rust | grep "security_assessment-abc123"
 
 # Show activity execution
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "activity"
+docker-compose -f docker-compose.yml logs worker-rust | grep "activity"
 ```
 
 ---
@@ -156,7 +156,7 @@ docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep "activity
 curl http://localhost:9000
 
 # List backend logs for upload
-docker-compose -f docker-compose.temporal.yaml logs fuzzforge-backend | grep "upload"
+docker-compose -f docker-compose.yml logs fuzzforge-backend | grep "upload"
 ```
 
 ### Check Worker Cache
@@ -230,12 +230,12 @@ Since toolbox is mounted as a volume, you can edit code on your host and reload:
 
 2. **Restart worker to reload:**
    ```bash
-   docker-compose -f docker-compose.temporal.yaml restart worker-rust
+   docker-compose -f docker-compose.yml restart worker-rust
    ```
 
 3. **Check discovery logs:**
    ```bash
-   docker-compose -f docker-compose.temporal.yaml logs worker-rust | tail -50
+   docker-compose -f docker-compose.yml logs worker-rust | tail -50
    ```
 
 ### Add Debug Logging
@@ -266,14 +266,14 @@ class MyWorkflow:
 
 Set debug logging:
 ```bash
-# Edit docker-compose.temporal.yaml
+# Edit docker-compose.yml
 services:
   worker-rust:
     environment:
       LOG_LEVEL: DEBUG  # Change from INFO to DEBUG
 
 # Restart
-docker-compose -f docker-compose.temporal.yaml restart worker-rust
+docker-compose -f docker-compose.yml restart worker-rust
 ```
 
 ---
@@ -285,7 +285,7 @@ docker-compose -f docker-compose.temporal.yaml restart worker-rust
 **Debug:**
 1. Check Temporal UI for last completed activity
 2. Check worker logs for errors
-3. Check if worker is still running: `docker-compose -f docker-compose.temporal.yaml ps worker-rust`
+3. Check if worker is still running: `docker-compose -f docker-compose.yml ps worker-rust`
 
 **Solution:**
 - Worker may have crashed - restart it
@@ -315,7 +315,7 @@ docker-compose -f docker-compose.temporal.yaml restart worker-rust
 
 **Solution:**
 - Re-upload file via CLI
-- Check MinIO is running: `docker-compose -f docker-compose.temporal.yaml ps minio`
+- Check MinIO is running: `docker-compose -f docker-compose.yml ps minio`
 - Check MinIO credentials in worker environment
 
 ---
@@ -337,7 +337,7 @@ docker-compose -f docker-compose.temporal.yaml restart worker-rust
 docker stats fuzzforge-worker-rust
 
 # Check worker logs for memory warnings
-docker-compose -f docker-compose.temporal.yaml logs worker-rust | grep -i "memory\|oom"
+docker-compose -f docker-compose.yml logs worker-rust | grep -i "memory\|oom"
 ```
 
 ### Profile Workflow Execution
@@ -368,7 +368,7 @@ class MyWorkflow:
 ### Enable Temporal Worker Debug Logs
 
 ```bash
-# Edit docker-compose.temporal.yaml
+# Edit docker-compose.yml
 services:
   worker-rust:
     environment:
@@ -376,7 +376,7 @@ services:
       LOG_LEVEL: DEBUG
 
 # Restart
-docker-compose -f docker-compose.temporal.yaml restart worker-rust
+docker-compose -f docker-compose.yml restart worker-rust
 ```
 
 ### Inspect Temporal Workflows via CLI
@@ -405,7 +405,7 @@ docker exec fuzzforge-worker-rust ping temporal
 docker exec fuzzforge-worker-rust curl http://minio:9000
 
 # From host to services
-curl http://localhost:8233  # Temporal UI
+curl http://localhost:8080  # Temporal UI
 curl http://localhost:9000  # MinIO
 curl http://localhost:8000/health  # Backend
 ```
@@ -431,10 +431,10 @@ If you're still stuck:
 1. **Collect diagnostic info:**
    ```bash
    # Save all logs
-   docker-compose -f docker-compose.temporal.yaml logs > fuzzforge-logs.txt
+   docker-compose -f docker-compose.yml logs > fuzzforge-logs.txt
 
    # Check service status
-   docker-compose -f docker-compose.temporal.yaml ps > service-status.txt
+   docker-compose -f docker-compose.yml ps > service-status.txt
    ```
 
 2. **Check Temporal UI** and take screenshots of:

docs/docs/how-to/troubleshooting.md

@@ -10,14 +10,14 @@ Before diving into specific errors, let’s check the basics:
 
 ```bash
 # Check all FuzzForge services
-docker-compose -f docker-compose.temporal.yaml ps
+docker-compose -f docker-compose.yml ps
 
 # Verify Docker registry config (if using workflow registry)
 docker info | grep -i "insecure registries"
 
 # Test service health endpoints
 curl http://localhost:8000/health
-curl http://localhost:8233  # Temporal Web UI
+curl http://localhost:8080  # Temporal Web UI
 curl http://localhost:9000  # MinIO API
 curl http://localhost:9001  # MinIO Console
 ```
@@ -54,13 +54,13 @@ The registry isn’t running or the port is blocked.
 **How to fix:**
 - Make sure the registry container is up (if using registry for workflow images):
   ```bash
-  docker-compose -f docker-compose.temporal.yaml ps registry
+  docker-compose -f docker-compose.yml ps registry
   ```
 - Check logs for errors:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml logs registry
+  docker-compose -f docker-compose.yml logs registry
   ```
-- If port 5001 is in use, change it in `docker-compose.temporal.yaml` and your Docker config.
+- If port 5001 is in use, change it in `docker-compose.yml` and your Docker config.
 
 **Note:** With Temporal architecture, target files use MinIO (port 9000), not the registry.
 
@@ -85,11 +85,11 @@ File upload to MinIO failed or worker can't download target.
 **How to fix:**
 - Check MinIO is running:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml ps minio
+  docker-compose -f docker-compose.yml ps minio
   ```
 - Check MinIO logs:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml logs minio
+  docker-compose -f docker-compose.yml logs minio
   ```
 - Verify MinIO is accessible:
   ```bash
@@ -106,13 +106,13 @@ File upload to MinIO failed or worker can't download target.
 **How to fix:**
 - Check worker logs for details:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml logs worker-rust | tail -50
+  docker-compose -f docker-compose.yml logs worker-rust | tail -50
   ```
-- Check Temporal Web UI at http://localhost:8233 for detailed execution history
+- Check Temporal Web UI at http://localhost:8080 for detailed execution history
 - Restart services:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml down
+  docker-compose -f docker-compose.yml down
-  docker-compose -f docker-compose.temporal.yaml up -d
+  docker-compose -f docker-compose.yml up -d
   ```
 - Reduce the number of concurrent workflows if your system is resource-constrained.
 
@@ -125,18 +125,18 @@ File upload to MinIO failed or worker can't download target.
 **How to fix:**
 - Check if the service is running:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml ps fuzzforge-backend
+  docker-compose -f docker-compose.yml ps fuzzforge-backend
-  docker-compose -f docker-compose.temporal.yaml ps temporal
+  docker-compose -f docker-compose.yml ps temporal
   ```
 - View logs for errors:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml logs fuzzforge-backend --tail 50
+  docker-compose -f docker-compose.yml logs fuzzforge-backend --tail 50
-  docker-compose -f docker-compose.temporal.yaml logs temporal --tail 20
+  docker-compose -f docker-compose.yml logs temporal --tail 20
   ```
 - Restart the affected service:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml restart fuzzforge-backend
+  docker-compose -f docker-compose.yml restart fuzzforge-backend
-  docker-compose -f docker-compose.temporal.yaml restart temporal
+  docker-compose -f docker-compose.yml restart temporal
   ```
 
 ---
@@ -216,9 +216,9 @@ File upload to MinIO failed or worker can't download target.
   ```
 - Recreate the network:
   ```bash
-  docker-compose -f docker-compose.temporal.yaml down
+  docker-compose -f docker-compose.yml down
   docker network prune -f
-  docker-compose -f docker-compose.temporal.yaml up -d
+  docker-compose -f docker-compose.yml up -d
   ```
 
 ---
@@ -245,9 +245,9 @@ File upload to MinIO failed or worker can't download target.
 
 ```bash
 export TEMPORAL_LOGGING_LEVEL=DEBUG
-docker-compose -f docker-compose.temporal.yaml down
+docker-compose -f docker-compose.yml down
-docker-compose -f docker-compose.temporal.yaml up -d
+docker-compose -f docker-compose.yml up -d
-docker-compose -f docker-compose.temporal.yaml logs fuzzforge-backend -f
+docker-compose -f docker-compose.yml logs fuzzforge-backend -f
 ```
 
 ### Collect diagnostic info
@@ -258,12 +258,12 @@ Save and run this script to gather info for support:
 #!/bin/bash
 echo "=== FuzzForge Diagnostics ==="
 date
-docker-compose -f docker-compose.temporal.yaml ps
+docker-compose -f docker-compose.yml ps
 docker info | grep -A 5 -i "insecure registries"
 curl -s http://localhost:8000/health || echo "Backend unhealthy"
-curl -s http://localhost:8233 >/dev/null && echo "Temporal UI healthy" || echo "Temporal UI unhealthy"
+curl -s http://localhost:8080 >/dev/null && echo "Temporal UI healthy" || echo "Temporal UI unhealthy"
 curl -s http://localhost:9000 >/dev/null && echo "MinIO healthy" || echo "MinIO unhealthy"
-docker-compose -f docker-compose.temporal.yaml logs --tail 10
+docker-compose -f docker-compose.yml logs --tail 10
 ```
 
 ### Still stuck?

docs/docs/tutorial/getting-started.md

@@ -17,7 +17,7 @@ Before we begin, ensure you have the following installed:
 First, let's clone the FuzzForge repository:
 
 ```bash
-git clone https://github.com/FuzzingLabs/fuzzforge.git
+git clone https://github.com/FuzzingLabs/fuzzforge_ai.git
 cd fuzzforge
 ```
 
@@ -85,7 +85,7 @@ docker pull localhost:5001/hello-world 2>/dev/null || echo "Registry not accessi
 Start all FuzzForge services:
 
 ```bash
-docker-compose -f docker-compose.temporal.yaml up -d
+docker-compose -f docker-compose.yml up -d
 ```
 
 This will start 6+ services:
@@ -101,7 +101,7 @@ Wait for all services to be healthy (this may take 2-3 minutes on first startup)
 
 ```bash
 # Check service health
-docker-compose -f docker-compose.temporal.yaml ps
+docker-compose -f docker-compose.yml ps
 
 # Verify FuzzForge is ready
 curl http://localhost:8000/health
@@ -228,7 +228,7 @@ Example output:
 
 You can monitor workflow execution in real-time using the Temporal Web UI:
 
-1. Open http://localhost:8233 in your browser
+1. Open http://localhost:8080 in your browser
 2. Navigate to "Workflows" to see workflow executions
 3. Click on a workflow to see detailed execution history and activity results