feat: OpenVINO skill 1:1 parity with Coral TPU + README skill catalog update

OpenVINO detect.py:
- Add file_read timing metric (matches Coral TPU)
- Add frame-not-found guard in main loop (empty detections response)
- Add invalid JSON log message instead of silent continue

OpenVINO SKILL.md:
- Add description fields to all parameters
- Add Platform Setup (Linux/macOS/Windows) section
- Add Model section with compile instructions
- Add Bounding Box Format section

OpenVINO deploy.sh:
- Add find_docker() function pattern
- Add exit code 2 for partial success (CPU-only)
- Add architecture to platform progress event
- Add accelerator_found field in complete event

OpenVINO deploy.bat:
- Add Docker version reporting
- Add device probe result checking

New: scripts/compile_model.py
- Local model export (--model, --size, --precision, --output)
- FP16/INT8/FP32 via YOLO.export(format=openvino)

README.md:
- Add Coral TPU and OpenVINO to Skill Catalog (🧪 Testing)
- Add Detection & Segmentation Skills architecture section
- Add mermaid diagram showing native vs Docker detection paths
- Add LLM-Assisted Skill Installation explanation

Author: solderzzc

README.md

@@ -58,6 +58,8 @@ Each skill is a self-contained module with its own model, parameters, and [commu
 | Category | Skill | What It Does | Status |
 |----------|-------|--------------|:------:|
 | **Detection** | [`yolo-detection-2026`](skills/detection/yolo-detection-2026/) | Real-time 80+ class detection — auto-accelerated via TensorRT / CoreML / OpenVINO / ONNX | ✅|
+| | [`yolo-detection-2026-coral-tpu`](skills/detection/yolo-detection-2026-coral-tpu/) | Google Coral Edge TPU — ~4ms inference via USB accelerator ([Docker-based](#detection--segmentation-skills)) | 🧪 |
+| | [`yolo-detection-2026-openvino`](skills/detection/yolo-detection-2026-openvino/) | Intel NCS2 USB / Intel GPU / CPU — multi-device via OpenVINO ([Docker-based](#detection--segmentation-skills)) | 🧪 |
 | **Analysis** | [`home-security-benchmark`](skills/analysis/home-security-benchmark/) | [143-test evaluation suite](#-homesec-bench--how-secure-is-your-local-ai) for LLM & VLM security performance | ✅ |
 | **Privacy** | [`depth-estimation`](skills/transformation/depth-estimation/) | [Real-time depth-map privacy transform](#-privacy--depth-map-anonymization) — anonymize camera feeds while preserving activity | ✅ |
 | **Segmentation** | [`sam2-segmentation`](skills/segmentation/sam2-segmentation/) | Interactive click-to-segment with Segment Anything 2 — pixel-perfect masks, point/box prompts, video tracking | ✅ |
@@ -70,6 +72,54 @@ Each skill is a self-contained module with its own model, parameters, and [commu
 
 > **Registry:** All skills are indexed in [`skills.json`](skills.json) for programmatic discovery.
 
+### Detection & Segmentation Skills
+
+Detection and segmentation skills process visual data from camera feeds — detecting objects, segmenting regions, or analyzing scenes. All skills use the same **JSONL stdin/stdout protocol**: Aegis writes a frame to a shared volume, sends a `frame` event on stdin, and reads `detections` from stdout. This means every detection skill — whether running natively or inside Docker — is interchangeable from Aegis's perspective.
+
+```mermaid
+graph TB
+    CAM["📷 Camera Feed"] --> GOV["Frame Governor (5 FPS)"]
+    GOV --> |"frame.jpg → shared volume"| PROTO["JSONL stdin/stdout Protocol"]
+
+    PROTO --> NATIVE["🖥️ Native: yolo-detection-2026"]
+    PROTO --> DOCKER["🐳 Docker: Coral TPU / OpenVINO"]
+
+    subgraph Native["Native Skill (runs on host)"]
+        NATIVE --> ENV["env_config.py auto-detect"]
+        ENV --> TRT["NVIDIA → TensorRT"]
+        ENV --> CML["Apple Silicon → CoreML"]
+        ENV --> OV["Intel → OpenVINO IR"]
+        ENV --> ONNX["AMD / CPU → ONNX"]
+    end
+
+    subgraph Container["Docker Container"]
+        DOCKER --> CORAL["Coral TPU → pycoral"]
+        DOCKER --> OVIR["OpenVINO → Ultralytics OV"]
+        DOCKER --> CPU["CPU fallback"]
+        CORAL -.-> USB["USB/IP passthrough"]
+        OVIR -.-> DRI["/dev/dri · /dev/bus/usb"]
+    end
+
+    NATIVE --> |"stdout: detections"| AEGIS["Aegis IPC → Live Overlay + Alerts"]
+    DOCKER --> |"stdout: detections"| AEGIS
+```
+
+- **Native skills** run directly on the host — [`env_config.py`](skills/lib/env_config.py) auto-detects the GPU and converts models to the fastest format (TensorRT, CoreML, OpenVINO IR, ONNX)
+- **Docker skills** wrap hardware-specific runtimes in a container — cross-platform USB/device access without native driver installation
+- **Same output** — Aegis sees identical JSONL from all skills, so detection overlays, alerts, and forensic analysis work with any backend
+
+#### LLM-Assisted Skill Installation
+
+Skills are installed by an **autonomous LLM deployment agent** — not by brittle shell scripts. When you click "Install" in Aegis, a focused mini-agent session reads the skill's `SKILL.md` manifest and figures out what to do:
+
+1. **Probe** — reads `SKILL.md`, `requirements.txt`, and `package.json` to understand what the skill needs
+2. **Detect hardware** — checks for NVIDIA (CUDA), AMD (ROCm), Apple Silicon (MPS), Intel (OpenVINO), or CPU-only
+3. **Install** — runs the right commands (`pip install`, `npm install`, `docker build`) with the correct backend-specific dependencies
+4. **Verify** — runs a smoke test to confirm the skill loads before marking it complete
+5. **Determine launch command** — figures out the exact `run_command` to start the skill and saves it to the registry
+
+This means community-contributed skills don't need a bespoke installer — the LLM reads the manifest and adapts to whatever hardware you have. If something fails, it reads the error output and tries to fix it autonomously.
+
 
 ## 🚀 Getting Started with [SharpAI Aegis](https://www.sharpai.org)
 

skills/detection/yolo-detection-2026-openvino/SKILL.md

@@ -16,6 +16,7 @@ parameters:
     label: "Auto Start"
     type: boolean
     default: false
+    description: "Start this skill automatically when Aegis launches"
     group: Lifecycle
 
   - name: confidence
@@ -24,26 +25,30 @@ parameters:
     min: 0.1
     max: 1.0
     default: 0.5
+    description: "Minimum detection confidence (0.1–1.0)"
     group: Model
 
   - name: classes
     label: "Detect Classes"
     type: string
     default: "person,car,dog,cat"
+    description: "Comma-separated COCO class names (80 classes available)"
     group: Model
 
   - name: fps
     label: "Processing FPS"
     type: select
     options: [0.2, 0.5, 1, 3, 5, 15]
     default: 5
+    description: "Frames per second — OpenVINO on GPU/NCS2 handles 15+ FPS"
     group: Performance
 
   - name: input_size
     label: "Input Resolution"
     type: select
     options: [320, 640]
     default: 640
+    description: "640 is recommended for GPU/CPU accuracy, 320 for fastest inference"
     group: Performance
 
   - name: device
@@ -59,12 +64,13 @@ parameters:
     type: select
     options: ["FP16", "INT8", "FP32"]
     default: "FP16"
+    description: "FP16 is fastest on GPU/NCS2; INT8 is fastest on CPU; FP32 is most accurate"
     group: Performance
 
 capabilities:
   live_detection:
     script: scripts/detect.py
-    description: "Real-time object detection via OpenVINO"
+    description: "Real-time object detection via OpenVINO runtime"
 
 category: detection
 mutex: detection
@@ -99,6 +105,44 @@ Real-time object detection using Intel OpenVINO runtime. Runs inside Docker for
 └─────────────────────────────────────────────────────┘
 ```
 
+1. Aegis writes camera frame JPEG to shared `/tmp/aegis_detection/` volume
+2. Sends `frame` event via stdin JSONL to Docker container
+3. `detect.py` reads frame, runs inference via OpenVINO
+4. Returns `detections` event via stdout JSONL
+5. Same protocol as `yolo-detection-2026` — Aegis sees no difference
+
+## Platform Setup
+
+### Linux
+```bash
+# Intel GPU and NCS2 auto-detected via /dev/dri and /dev/bus/usb
+# Docker uses --device flags for direct device access
+./deploy.sh
+```
+
+### macOS (Docker Desktop 4.35+)
+```bash
+# Docker Desktop USB/IP handles NCS2 passthrough
+# CPU fallback always available
+./deploy.sh
+```
+
+### Windows
+```powershell
+# Docker Desktop 4.35+ with USB/IP support
+# Or WSL2 backend with usbipd-win for NCS2
+.\deploy.bat
+```
+
+## Model
+
+Ships without a pre-compiled model by default. On first run, `detect.py` will auto-download `yolo26n.pt` and export to OpenVINO IR format. To pre-export:
+
+```bash
+# Runs on any platform (unlike Edge TPU compilation)
+python scripts/compile_model.py --model yolo26n --size 640 --precision FP16
+```
+
 ## Supported Devices
 
 | Device | Flag | Precision | ~Speed |
@@ -113,14 +157,20 @@ Real-time object detection using Intel OpenVINO runtime. Runs inside Docker for
 
 Same JSONL as `yolo-detection-2026`:
 
+### Skill → Aegis (stdout)
 ```jsonl
 {"event": "ready", "model": "yolo26n_openvino", "device": "GPU", "format": "openvino_ir", "classes": 80}
 {"event": "detections", "frame_id": 42, "camera_id": "front_door", "objects": [{"class": "person", "confidence": 0.85, "bbox": [100, 50, 300, 400]}]}
 {"event": "perf_stats", "total_frames": 50, "timings_ms": {"inference": {"avg": 8.1, "p50": 7.9, "p95": 10.2}}}
 ```
 
+### Bounding Box Format
+`[x_min, y_min, x_max, y_max]` — pixel coordinates (xyxy).
+
 ## Installation
 
 ```bash
 ./deploy.sh
 ```
+
+The deployer builds the Docker image locally, probes for OpenVINO devices, and sets the runtime command. No packages pulled from external registries beyond Docker base images and pip dependencies.

skills/detection/yolo-detection-2026-openvino/deploy.bat

@@ -1,5 +1,10 @@
 @echo off
 REM deploy.bat — Docker-based bootstrapper for OpenVINO Detection Skill (Windows)
+REM
+REM Builds the Docker image locally and verifies device availability.
+REM Called by Aegis skill-runtime-manager during installation.
+REM
+REM Requires: Docker Desktop 4.35+ with USB/IP support (for NCS2)
 
 setlocal enabledelayedexpansion
 
@@ -8,40 +13,59 @@ set "IMAGE_NAME=aegis-openvino-detect"
 set "IMAGE_TAG=latest"
 set "LOG_PREFIX=[openvino-deploy]"
 
-REM ─── Check Docker ────────────────────────────────────────────────────────
+REM ─── Step 1: Check Docker ────────────────────────────────────────────────
+
 where docker >nul 2>&1
 if %errorlevel% neq 0 (
-    echo %LOG_PREFIX% ERROR: Docker not found. 1>&2
-    echo {"event": "error", "stage": "docker", "message": "Docker not found"}
+    echo %LOG_PREFIX% ERROR: Docker not found. Install Docker Desktop 4.35+ 1>&2
+    echo {"event": "error", "stage": "docker", "message": "Docker not found. Install Docker Desktop 4.35+"}
     exit /b 1
 )
 
 docker info >nul 2>&1
 if %errorlevel% neq 0 (
-    echo %LOG_PREFIX% ERROR: Docker daemon not running. 1>&2
+    echo %LOG_PREFIX% ERROR: Docker daemon not running. Start Docker Desktop. 1>&2
     echo {"event": "error", "stage": "docker", "message": "Docker daemon not running"}
     exit /b 1
 )
 
-echo {"event": "progress", "stage": "docker", "message": "Docker ready"}
+for /f "tokens=*" %%v in ('docker version --format "{{.Server.Version}}" 2^>nul') do set "DOCKER_VER=%%v"
+echo %LOG_PREFIX% Using Docker (version: %DOCKER_VER%) 1>&2
+echo {"event": "progress", "stage": "docker", "message": "Docker ready (%DOCKER_VER%)"}
+
+REM ─── Step 2: Build Docker image ──────────────────────────────────────────
 
-REM ─── Build Docker image ──────────────────────────────────────────────────
-echo %LOG_PREFIX% Building Docker image... 1>&2
+echo %LOG_PREFIX% Building Docker image: %IMAGE_NAME%:%IMAGE_TAG% ... 1>&2
 echo {"event": "progress", "stage": "build", "message": "Building Docker image..."}
 
 docker build -t %IMAGE_NAME%:%IMAGE_TAG% "%SKILL_DIR%"
 if %errorlevel% neq 0 (
+    echo %LOG_PREFIX% ERROR: Docker build failed 1>&2
     echo {"event": "error", "stage": "build", "message": "Docker image build failed"}
     exit /b 1
 )
 
 echo {"event": "progress", "stage": "build", "message": "Docker image ready"}
 
-REM ─── Probe devices ──────────────────────────────────────────────────────
+REM ─── Step 3: Probe for OpenVINO devices ──────────────────────────────────
+
+echo %LOG_PREFIX% Probing OpenVINO devices... 1>&2
+echo {"event": "progress", "stage": "probe", "message": "Checking OpenVINO devices..."}
+
 docker run --rm --privileged %IMAGE_NAME%:%IMAGE_TAG% python3 scripts/device_probe.py >nul 2>&1
+if %errorlevel% equ 0 (
+    echo %LOG_PREFIX% OpenVINO devices detected 1>&2
+    echo {"event": "progress", "stage": "probe", "message": "OpenVINO devices detected"}
+) else (
+    echo %LOG_PREFIX% WARNING: No accelerator detected - CPU fallback 1>&2
+    echo {"event": "progress", "stage": "probe", "message": "No GPU/NCS2 detected - CPU fallback"}
+)
+
+REM ─── Step 4: Set run command ──────────────────────────────────────────────
 
-REM ─── Set run command ─────────────────────────────────────────────────────
 set "RUN_CMD=docker run -i --rm --privileged -v /tmp/aegis_detection:/tmp/aegis_detection --env AEGIS_SKILL_ID --env AEGIS_SKILL_PARAMS --env PYTHONUNBUFFERED=1 %IMAGE_NAME%:%IMAGE_TAG%"
 
 echo {"event": "complete", "status": "success", "run_command": "%RUN_CMD%", "message": "OpenVINO skill installed"}
+
+echo %LOG_PREFIX% Done! 1>&2
 exit /b 0