diff --git a/.env.example b/.env.example
index c173375..b077781 100644
--- a/.env.example
+++ b/.env.example
@@ -4,7 +4,8 @@ RADA_EVENT_BUS_MODE=inmemory
 
 RADA_REDIS_URL=redis://localhost:6379/0
 RADA_DATABASE_URL=postgresql+asyncpg://rada:rada@localhost:5432/rada
-RADA_SQLITE_URL=sqlite+aiosqlite:///./rada.db
+RADA_SQLITE_URL=sqlite:///./rada.db
+RADA_API_KEY=
 
 # Change these in real environments.
 POSTGRES_USER=rada
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3cda530..a3c95ed 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -26,3 +26,26 @@ jobs:
 
       - name: Unit tests
         run: pytest tests/unit -q --strict-markers -m "not gpu and not integration"
+
+      - name: Integration tests
+        run: pytest tests/integration -q --strict-markers -m integration
+
+  dashboard:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: npm
+          cache-dependency-path: dashboard/package-lock.json
+
+      - name: Install dashboard dependencies
+        working-directory: dashboard
+        run: npm ci
+
+      - name: Build dashboard
+        working-directory: dashboard
+        run: npm run build
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 98ce855..4d70d03 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -2,6 +2,8 @@ name: Integration (manual)
 
 on:
   workflow_dispatch:
+  pull_request:
+    branches: [main, develop]
 
 jobs:
   integration:
@@ -27,3 +29,9 @@ jobs:
       - uses: actions/checkout@v4
       - name: Build Docker image
         run: docker build -t rada:ci .
+      - name: Smoke test image health
+        run: |
+          docker run -d --name rada-ci -p 18000:8000 rada:ci
+          sleep 5
+          curl -fsS http://127.0.0.1:18000/health
+          docker rm -f rada-ci
diff --git a/Makefile b/Makefile
index 8500b56..6dd1517 100644
--- a/Makefile
+++ b/Makefile
@@ -10,7 +10,7 @@ down:
 	docker compose down
 
 test:
-	pytest
+	pytest tests/unit -m "not gpu and not integration"
 
 lint:
 	ruff check .
diff --git a/apps/streamlit/dashboard.py b/apps/streamlit/dashboard.py
index bfa552c..2bb8322 100644
--- a/apps/streamlit/dashboard.py
+++ b/apps/streamlit/dashboard.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 
 import httpx
@@ -10,6 +11,14 @@
 from rada.utils.metrics import get_metrics_snapshot
 
 API_URL = os.getenv("RADA_API_URL", "http://localhost:8000")
+API_KEY = os.getenv("RADA_API_KEY", "")
+
+
+def _headers() -> dict[str, str]:
+    headers: dict[str, str] = {}
+    if API_KEY:
+        headers["X-API-Key"] = API_KEY
+    return headers
 
 
 def _submit(*, client_action: str, decision_id: str, note: str) -> None:
@@ -21,7 +30,12 @@ def _submit(*, client_action: str, decision_id: str, note: str) -> None:
     }
     try:
         with httpx.Client(timeout=10.0) as client:
-            client.post(f"{API_URL}/feedback/submit", json=payload)
+            response = client.post(
+                f"{API_URL}/feedback/submit",
+                json=payload,
+                headers=_headers(),
+            )
+            response.raise_for_status()
         st.success(f"{client_action} submitted for {decision_id}")
     except httpx.HTTPError as exc:
         st.error(str(exc))
@@ -42,7 +56,13 @@ def _submit(*, client_action: str, decision_id: str, note: str) -> None:
     st.subheader("Flagged decisions")
     try:
         with httpx.Client(timeout=10.0) as client:
-            pending = client.get(f"{API_URL}/feedback/pending").json().get("pending", [])
+            response = client.get(f"{API_URL}/feedback/pending", headers=_headers())
+            response.raise_for_status()
+            try:
+                pending = response.json().get("pending", [])
+            except json.JSONDecodeError as exc:
+                st.error(f"Invalid JSON from feedback API: {exc}")
+                pending = []
     except httpx.HTTPError as exc:
         st.error(f"Cannot reach feedback API at {API_URL}: {exc}")
         pending = []
diff --git a/dashboard/nginx.conf b/dashboard/nginx.conf
index bd58c98..c922610 100644
--- a/dashboard/nginx.conf
+++ b/dashboard/nginx.conf
@@ -4,31 +4,76 @@ server {
     root /usr/share/nginx/html;
     index index.html;
 
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
     location / {
         try_files $uri $uri/ /index.html;
     }
 
     location /health {
         proxy_pass http://rada:8000/health;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
     }
 
     location /metrics {
+        limit_except GET {
+            deny all;
+        }
         proxy_pass http://rada:8000/metrics;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
     }
 
     location /ingest {
+        limit_except POST {
+            deny all;
+        }
         proxy_pass http://rada:8000/ingest;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-API-Key $http_x_api_key;
     }
 
     location /bootstrap-demo {
+        limit_except POST {
+            deny all;
+        }
         proxy_pass http://rada:8000/bootstrap-demo;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-API-Key $http_x_api_key;
     }
 
     location /audit/ {
+        limit_except GET {
+            deny all;
+        }
         proxy_pass http://rada:8000/audit/;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-API-Key $http_x_api_key;
     }
 
     location /feedback/ {
         proxy_pass http://rada:8000/feedback/;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-API-Key $http_x_api_key;
     }
 }
diff --git a/dashboard/src/pages/Decisions.jsx b/dashboard/src/pages/Decisions.jsx
index 8287533..a42e50e 100644
--- a/dashboard/src/pages/Decisions.jsx
+++ b/dashboard/src/pages/Decisions.jsx
@@ -2,6 +2,14 @@ import { useState } from "react";
 import { useMutation } from "@tanstack/react-query";
 import { apiFetch } from "../api/rest";
 
+function parsePositiveNumber(value, field) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${field} must be a positive number`);
+  }
+  return parsed;
+}
+
 export function Decisions() {
   const [symbol, setSymbol] = useState("BTCUSD");
   const [price, setPrice] = useState("42000");
@@ -10,12 +18,22 @@ export function Decisions() {
   const [audit, setAudit] = useState(null);
   const [error, setError] = useState("");
 
+  const loadAudit = async (decisionId) => {
+    try {
+      const chain = await apiFetch(`/audit/decision/${decisionId}`);
+      setAudit(chain);
+    } catch (err) {
+      setError(`Audit fetch failed: ${err.message}`);
+      setAudit(null);
+    }
+  };
+
   const ingest = useMutation({
     mutationFn: async () => {
       const body = {
         symbol,
-        price: Number(price),
-        volume: Number(volume),
+        price: parsePositiveNumber(price, "Price"),
+        volume: parsePositiveNumber(volume, "Volume"),
         timestamp: new Date().toISOString(),
       };
       return apiFetch("/ingest", { method: "POST", body: JSON.stringify(body) });
@@ -23,8 +41,7 @@ export function Decisions() {
     onSuccess: async (data) => {
       setError("");
       setLastDecisionId(data.decision_id);
-      const chain = await apiFetch(`/audit/decision/${data.decision_id}`);
-      setAudit(chain);
+      await loadAudit(data.decision_id);
     },
     onError: (err) => setError(err.message),
   });
@@ -34,8 +51,7 @@ export function Decisions() {
     onSuccess: async (data) => {
       setError("");
       setLastDecisionId(data.decision_id);
-      const chain = await apiFetch(`/audit/decision/${data.decision_id}`);
-      setAudit(chain);
+      await loadAudit(data.decision_id);
     },
     onError: (err) => setError(err.message),
   });
diff --git a/dashboard/src/pages/Overview.jsx b/dashboard/src/pages/Overview.jsx
index c79c53a..fe705d1 100644
--- a/dashboard/src/pages/Overview.jsx
+++ b/dashboard/src/pages/Overview.jsx
@@ -42,15 +42,24 @@ export function Overview() {
           <p className="mt-2 text-sm text-rose-400">Unreachable: {health.error.message}</p>
         )}
         {health.isSuccess && (
-          <p className="mt-2 text-sm text-emerald-400">Healthy — {health.data.status}</p>
+          <p className="mt-2 text-sm text-emerald-400">
+            Healthy — {health.data?.status ?? "unknown"}
+          </p>
         )}
       </div>
 
-      <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
-        <MetricCard label="Decisions processed" value={legacy.decisions_processed ?? obs.decisions_total ?? "—"} />
-        <MetricCard label="Risk gate passes" value={legacy.risk_gate_passes ?? "—"} />
-        <MetricCard label="Reflection queued" value={legacy.reflection_enqueued ?? "—"} />
-      </div>
+      {metrics.isLoading && <p className="text-sm dark:text-slate-400">Loading metrics…</p>}
+      {metrics.isError && (
+        <p className="text-sm text-rose-400">Metrics unavailable: {metrics.error.message}</p>
+      )}
+
+      {metrics.isSuccess && (
+        <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
+          <MetricCard label="Decisions processed" value={legacy.decisions_processed ?? obs.decisions_total ?? "—"} />
+          <MetricCard label="Risk gate passes" value={legacy.risk_gate_passes ?? "—"} />
+          <MetricCard label="Reflection queued" value={legacy.reflection_enqueued ?? "—"} />
+        </div>
+      )}
     </div>
   );
 }
diff --git a/dashboard/src/pages/ReviewQueue.jsx b/dashboard/src/pages/ReviewQueue.jsx
index af22518..f31aa1b 100644
--- a/dashboard/src/pages/ReviewQueue.jsx
+++ b/dashboard/src/pages/ReviewQueue.jsx
@@ -4,7 +4,7 @@ import { apiFetch } from "../api/rest";
 
 export function ReviewQueue() {
   const qc = useQueryClient();
-  const [note, setNote] = useState("");
+  const [notes, setNotes] = useState({});
 
   const pending = useQuery({
     queryKey: ["feedback-pending"],
@@ -15,8 +15,12 @@ export function ReviewQueue() {
   const submit = useMutation({
     mutationFn: (payload) =>
       apiFetch("/feedback/submit", { method: "POST", body: JSON.stringify(payload) }),
-    onSuccess: () => {
-      setNote("");
+    onSuccess: (_data, variables) => {
+      setNotes((prev) => {
+        const next = { ...prev };
+        delete next[variables.decision_id];
+        return next;
+      });
       qc.invalidateQueries({ queryKey: ["feedback-pending"] });
     },
   });
@@ -34,6 +38,7 @@ export function ReviewQueue() {
 
       {pending.isLoading && <p className="text-sm dark:text-slate-400">Loading queue…</p>}
       {pending.isError && <p className="text-sm text-rose-400">{pending.error.message}</p>}
+      {submit.isError && <p className="text-sm text-rose-400">Submit failed: {submit.error.message}</p>}
 
       {items.length === 0 && pending.isSuccess && (
         <p className="text-sm dark:text-slate-500">No pending reviews.</p>
@@ -42,7 +47,7 @@ export function ReviewQueue() {
       <ul className="space-y-4">
         {items.map((item) => (
           <li
-            key={item.feedback_id}
+            key={item.feedback_id || item.decision_id}
             className="rounded-lg border dark:border-slate-800 light:border-slate-200 p-4"
           >
             <div className="font-mono text-xs dark:text-slate-400">{item.decision_id}</div>
@@ -51,8 +56,10 @@ export function ReviewQueue() {
               Review note
               <input
                 className="mt-1 w-full rounded border dark:border-slate-700 light:border-slate-300 dark:bg-slate-900 light:bg-white px-3 py-2"
-                value={note}
-                onChange={(e) => setNote(e.target.value)}
+                value={notes[item.decision_id] || ""}
+                onChange={(e) =>
+                  setNotes((prev) => ({ ...prev, [item.decision_id]: e.target.value }))
+                }
               />
             </label>
             <div className="mt-3 flex gap-2">
@@ -65,7 +72,7 @@ export function ReviewQueue() {
                     submit.mutate({
                       decision_id: item.decision_id,
                       action,
-                      note,
+                      note: notes[item.decision_id] || "",
                       reviewer: "dashboard",
                     })
                   }
diff --git a/docker-compose.monitoring.yml b/docker-compose.monitoring.yml
index a9ae449..4d569db 100644
--- a/docker-compose.monitoring.yml
+++ b/docker-compose.monitoring.yml
@@ -18,7 +18,7 @@ services:
     ports:
       - "3000:3000"
     environment:
-      GF_SECURITY_ADMIN_USER: admin
-      GF_SECURITY_ADMIN_PASSWORD: admin
+      GF_SECURITY_ADMIN_USER: ${GRAFANA_ADMIN_USER:-admin}
+      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD:-CHANGE_ME}
     depends_on:
       - prometheus
diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml
index 55a83e5..aa07514 100644
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -40,10 +40,13 @@ services:
     networks:
       - default
     environment:
+      RADA_ENV: production
       RADA_DATA_STORE_MODE: sqlite
       RADA_SQLITE_URL: sqlite:////app/data/rada.db
       RADA_EVENT_BUS_MODE: redis
-      RADA_DATABASE_URL: postgresql://rada:${RADA_POSTGRES_PASSWORD:-rada}@postgres:5432/rada
+      RADA_REDIS_URL: redis://redis:6379/0
+      RADA_DATABASE_URL: postgresql://rada:${RADA_POSTGRES_PASSWORD:-CHANGE_ME}@postgres:5432/rada
+      RADA_API_KEY: ${RADA_API_KEY:-}
       RADA_REASONER_MODE: mock
       RADA_OTEL_ENABLED: ${RADA_OTEL_ENABLED:-false}
     volumes:
diff --git a/docs/audit.md b/docs/audit.md
index e5fa836..8ecdb02 100644
--- a/docs/audit.md
+++ b/docs/audit.md
@@ -4,13 +4,16 @@ Append-only audit events for every pipeline step.
 
 ## API
 
+All audit endpoints require `X-API-Key` when `RADA_API_KEY` is set (required in production).
+
 - `GET /audit/decision/{id}` — events for one decision
-- `GET /audit/export` — NDJSON export
+- `GET /audit/export?from=&to=&limit=` — NDJSON export (default limit 1000, max 10000)
 
 ## CLI
 
 ```bash
 python scripts/export_audit.py --output audit.ndjson
+python scripts/export_audit.py --db ./rada_audit.db --from 2026-06-01T00:00:00Z --limit 5000
 ```
 
 Audit store rejects DELETE operations; events are immutable.
diff --git a/docs/conf.py b/docs/conf.py
index 32aec66..44f60df 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -11,7 +11,7 @@
 
 project = "RADA"
 author = "Risk-Aware AI"
-release = "0.1.0"
+release = "1.0.0"
 
 extensions = [
     "sphinx.ext.autodoc",
diff --git a/docs/human-validation.md b/docs/human-validation.md
index b37b0f3..a92f053 100644
--- a/docs/human-validation.md
+++ b/docs/human-validation.md
@@ -4,9 +4,21 @@ Expert review queue for flagged decisions.
 
 ## Feedback API
 
-- `POST /feedback/submit`
-- `GET /feedback/pending`
-- `POST /feedback/{id}/approve`
+Requires `X-API-Key` when `RADA_API_KEY` is set.
+
+- `POST /feedback/submit` — submit approve/reject/flag/annotate (server assigns `feedback_id` and timestamp)
+- `GET /feedback/pending` — list deduplicated pending FLAG items
+
+Example submit body:
+
+```json
+{
+  "decision_id": "dec-100",
+  "action": "APPROVE",
+  "note": "Reviewed manually",
+  "reviewer": "operator"
+}
+```
 
 ## Streamlit
 
@@ -14,4 +26,6 @@ Expert review queue for flagged decisions.
 streamlit run apps/streamlit/dashboard.py
 ```
 
+Set `RADA_API_URL` and optional `RADA_API_KEY` for authenticated deployments.
+
 Auto-flagging triggers on CVaR threshold breaches, low LLM confidence, and anomaly scores. Approved feedback flows into the reflection loop.
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000..71bcab9
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,14 @@
+# RADA Documentation
+
+Risk-Aware Decision Agent — technical documentation for operators and developers.
+
+## Quick links
+
+- [Architecture overview](architecture-overview.md)
+- [Operator runbook](runbook.md)
+- [Production runbook](runbook-production.md)
+- [Calc engine](calc.md)
+- [Audit trail](audit.md)
+- [Human validation](human-validation.md)
+
+See the repository [README](../README.md) for setup and quick start.
diff --git a/docs/monitoring.md b/docs/monitoring.md
index 6011967..589698c 100644
--- a/docs/monitoring.md
+++ b/docs/monitoring.md
@@ -7,9 +7,10 @@ Observability hooks for RADA align with post-MVP **S9 production monitoring** in
 | Endpoint | Format | Purpose |
 |----------|--------|---------|
 | `GET /health` | JSON | Liveness (`{"status":"ok"}`) |
-| `GET /metrics` | Prometheus text | Counters/gauges from `src/rada/utils/metrics.py` |
+| `GET /metrics` | Prometheus text | Legacy (`utils/metrics.py`) + observability (`observability/metrics.py`) |
+| `GET /metrics/json` | JSON | Debug snapshot of both metric facades |
 
-### Exposed metrics (MVP)
+### Legacy metrics (`src/rada/utils/metrics.py`)
 
 | Metric | Type | Description |
 |--------|------|-------------|
@@ -21,6 +22,16 @@ Observability hooks for RADA align with post-MVP **S9 production monitoring** in
 | `rada_reflection_mean_faithfulness` | gauge | Rolling mean faithfulness from audits |
 | `rada_search_invocations_total` | counter | Search loop invocations when enabled |
 
+### Observability metrics (`src/rada/observability/metrics.py`)
+
+| Metric | Type | Description |
+|--------|------|-------------|
+| `rada_decisions_total` | counter | Decisions completed (decision loop) |
+| `rada_risk_gate_rejections_total` | counter | Risk gate rejections |
+| `rada_loop_errors_total` | counter | Background loop errors |
+| `rada_audit_queue_drops_total` | counter | Audit events dropped when queue is full |
+| `rada_reflection_queue_drops_total` | counter | Reflection decisions dropped when queue is full |
+
 ## Log structure
 
 Logs should be structured JSON in production (plain text acceptable in dev).
diff --git a/docs/runbook.md b/docs/runbook.md
index e9ba2a4..eb0f9b5 100644
--- a/docs/runbook.md
+++ b/docs/runbook.md
@@ -26,8 +26,9 @@ Copy `.env.example` to `.env` and adjust for the target environment.
 | `RADA_LOG_LEVEL` | Log verbosity | `INFO` |
 | `RADA_EVENT_BUS_MODE` | Event bus backend: `inmemory`, `redis`, `kafka`, `zeromq` | `inmemory` |
 | `RADA_REDIS_URL` | Redis connection string | `redis://localhost:6379/0` |
-| `RADA_DATABASE_URL` | Postgres/Timescale URL | `postgresql+asyncpg://rada:rada@localhost:5432/rada` |
-| `RADA_SQLITE_URL` | SQLite fallback for local/CI | `sqlite+aiosqlite:///./rada.db` |
+| `RADA_DATABASE_URL` | Postgres/Timescale URL (required when `RADA_DATA_STORE_MODE=timescale`) | _(unset — set explicitly)_ |
+| `RADA_SQLITE_URL` | SQLite fallback for local/CI | `sqlite:///./rada.db` |
+| `RADA_API_KEY` | API key for `/ingest`, `/audit/*`, `/feedback/*` | _(empty in dev — optional)_ |
 | `RADA_KAFKA_BOOTSTRAP` | Kafka brokers (when overlay enabled) | `localhost:9092` |
 | `RADA_ZMQ_ENDPOINT` | ZeroMQ bind/connect endpoint | `tcp://127.0.0.1:5555` |
 | `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Postgres container bootstrap | `rada` |
diff --git a/env.example.prod b/env.example.prod
index 736a669..d585d64 100644
--- a/env.example.prod
+++ b/env.example.prod
@@ -1,10 +1,18 @@
 # RADA production environment (copy to .env for docker compose)
 
+RADA_ENV=production
 RADA_PORT=8000
-RADA_POSTGRES_PASSWORD=rada
+RADA_API_KEY=CHANGE_ME
+RADA_POSTGRES_PASSWORD=CHANGE_ME
 RADA_DATA_STORE_MODE=sqlite
 RADA_SQLITE_URL=sqlite:////app/data/rada.db
 RADA_EVENT_BUS_MODE=redis
+RADA_REDIS_URL=redis://redis:6379/0
 RADA_REASONER_MODE=mock
 RADA_OTEL_ENABLED=false
 RADA_API_URL=http://localhost:8000
+RADA_DASHBOARD_PORT=5173
+RADA_AUDIT_DB_PATH=/app/data/rada_audit.db
+RADA_FEEDBACK_DB_PATH=/app/data/rada_feedback.db
+GRAFANA_ADMIN_USER=admin
+GRAFANA_ADMIN_PASSWORD=CHANGE_ME
diff --git a/mkdocs.yml b/mkdocs.yml
index 3f7fc5e..7a52294 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -4,13 +4,12 @@ repo_url: https://github.com/artaasd95/RADA
 
 theme:
   name: material
-  logo: assets/logo.png
   palette:
     - scheme: default
       primary: indigo
 
 nav:
-  - Home: README.md
+  - Home: index.md
   - Architecture: architecture-overview.md
   - Calc engine: calc.md
   - Observability: observability.md
diff --git a/pyproject.toml b/pyproject.toml
index 7e1eaee..2af7ccb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -11,11 +11,10 @@ requires-python = ">=3.11"
 authors = [
   { name = "RADA Team" }
 ]
-license = { text = "MIT" }
+license = { text = "Apache-2.0" }
 dependencies = [
   "fastapi>=0.111.0",
   "pydantic>=2.7.0",
-  "asyncio>=3.4.3",
   "redis>=5.0.4",
   "asyncpg>=0.29.0",
   "uvicorn[standard]>=0.30.0",
diff --git a/runpod/train.py b/runpod/train.py
index 55499e4..69fcc24 100644
--- a/runpod/train.py
+++ b/runpod/train.py
@@ -32,8 +32,11 @@ def flush(self) -> None:
             stream.flush()
 
 
-def _find_latest_checkpoint(root: Path) -> Path | None:
-    patterns = [str(root / "checkpoints" / "checkpoint-*"), str(root / "**" / "checkpoint-*")]
+def _find_latest_checkpoint(adapter_dir: Path) -> Path | None:
+    patterns = [
+        str(adapter_dir / "checkpoints" / "checkpoint-*"),
+        str(adapter_dir / "**" / "checkpoint-*"),
+    ]
     candidates: list[Path] = []
     for pattern in patterns:
         candidates.extend(Path(p) for p in glob.glob(pattern, recursive=True))
@@ -62,6 +65,13 @@ def _load_config(path: Path) -> dict:
         return yaml.safe_load(handle)
 
 
+def _adapter_dir(run_id: str, model_id: str) -> Path:
+    sys.path.insert(0, str(REPO_ROOT / "src"))
+    from rada.models.resolver import get_adapter_root
+
+    return get_adapter_root() / run_id / model_id
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description="RunPod reflection training wrapper")
     parser.add_argument("--config", default=str(DEFAULT_CONFIG))
@@ -70,7 +80,9 @@ def main() -> int:
 
     cfg = _load_config(Path(args.config))
     run_id = cfg.get("output_run_id", "runpod")
-    log_dir = REPO_ROOT / "experiments" / "adapters" / run_id
+    model_id = cfg["model_id"]
+    adapter_dir = _adapter_dir(run_id, model_id)
+    log_dir = adapter_dir
     log_dir.mkdir(parents=True, exist_ok=True)
     log_path = log_dir / "train.log"
 
@@ -80,7 +92,7 @@ def main() -> int:
         "--backend",
         cfg.get("backend", "unsloth"),
         "--model-id",
-        cfg["model_id"],
+        model_id,
         "--data-source",
         cfg.get("data_source", "distilled"),
         "--epochs",
@@ -91,17 +103,30 @@ def main() -> int:
         run_id,
         "--method",
         cfg.get("method", "reflection"),
+        "--lora-rank",
+        str(cfg.get("lora_rank", 16)),
     ]
     if cfg.get("distilled_name"):
         cmd.extend(["--distilled-name", cfg["distilled_name"]])
+    if cfg.get("data_path"):
+        cmd.extend(["--data", cfg["data_path"]])
+    if cfg.get("distilled_root"):
+        cmd.extend(["--distilled-root", cfg["distilled_root"]])
 
-    env = {**os.environ}
+    resume_from = os.environ.get("RADA_RESUME_FROM")
     if args.resume == "auto":
-        latest = _find_latest_checkpoint(log_dir)
+        latest = _find_latest_checkpoint(adapter_dir)
         if latest is not None:
-            env["RADA_RESUME_FROM"] = str(latest)
+            resume_from = str(latest)
             print(f"[runpod] auto-resume from {latest}")
 
+    if resume_from:
+        cmd.extend(["--resume-from", resume_from])
+
+    env = {**os.environ}
+    if resume_from:
+        env["RADA_RESUME_FROM"] = resume_from
+
     stop_event = threading.Event()
     monitor = threading.Thread(target=_disk_sync_loop, args=(stop_event,), daemon=True)
     monitor.start()
diff --git a/scripts/compare_pre_post_train.py b/scripts/compare_pre_post_train.py
index b0b98dc..22b80d3 100644
--- a/scripts/compare_pre_post_train.py
+++ b/scripts/compare_pre_post_train.py
@@ -9,8 +9,9 @@
 from pathlib import Path
 
 _REPO_ROOT = Path(__file__).resolve().parents[1]
-if str(_REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(_REPO_ROOT))
+_SRC_ROOT = _REPO_ROOT / "src"
+if str(_SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SRC_ROOT))
 
 from rada.evaluation.pre_post_compare import run_pre_post_compare, write_report  # noqa: E402
 
diff --git a/scripts/export_audit.py b/scripts/export_audit.py
new file mode 100644
index 0000000..c8ddf3f
--- /dev/null
+++ b/scripts/export_audit.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Export audit events to NDJSON."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+_REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(_REPO_ROOT / "src"))
+
+from rada.audit.store import AuditStore  # noqa: E402
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Export audit events to NDJSON")
+    parser.add_argument("--db", default="./rada_audit.db", help="Audit SQLite database path")
+    parser.add_argument("--output", "-o", default="audit.ndjson", help="Output NDJSON file")
+    parser.add_argument("--from", dest="from_", default=None, help="ISO timestamp lower bound")
+    parser.add_argument("--to", default=None, help="ISO timestamp upper bound")
+    parser.add_argument("--limit", type=int, default=10_000, help="Maximum rows to export")
+    return parser.parse_args()
+
+
+async def main() -> int:
+    args = parse_args()
+    store = AuditStore(db_path=args.db)
+    from_ts = datetime.fromisoformat(args.from_.replace("Z", "+00:00")) if args.from_ else None
+    to_ts = datetime.fromisoformat(args.to.replace("Z", "+00:00")) if args.to else None
+    events = await store.export_range(from_ts, to_ts)
+    events = events[: args.limit]
+
+    out_path = Path(args.output)
+    with out_path.open("w", encoding="utf-8") as handle:
+        for event in events:
+            handle.write(json.dumps(event.model_dump(mode="json")) + "\n")
+    print(f"exported {len(events)} events to {out_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(asyncio.run(main()))
diff --git a/scripts/reflection_train.py b/scripts/reflection_train.py
index dd3ae39..d596d1e 100644
--- a/scripts/reflection_train.py
+++ b/scripts/reflection_train.py
@@ -5,12 +5,14 @@
 
 import argparse
 import json
+import os
 import sys
 from pathlib import Path
 
 _REPO_ROOT = Path(__file__).resolve().parents[1]
-if str(_REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(_REPO_ROOT))
+_SRC_ROOT = _REPO_ROOT / "src"
+if str(_SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SRC_ROOT))
 
 from rada.training.config import TrainingConfig  # noqa: E402
 from rada.training.dataset import load_training_dataset  # noqa: E402
@@ -49,11 +51,13 @@ def parse_args() -> argparse.Namespace:
         default="reflection",
     )
     parser.add_argument("--lora-rank", type=int, default=16)
+    parser.add_argument("--resume-from", default=None, help="Checkpoint path for resume")
     return parser.parse_args()
 
 
 def main() -> int:
     args = parse_args()
+    resume_from = args.resume_from or os.environ.get("RADA_RESUME_FROM")
     config = TrainingConfig(
         model_id=args.model_id,
         backend=args.backend,
@@ -64,6 +68,9 @@ def main() -> int:
         epochs=args.epochs,
         batch_size=args.batch_size,
         output_run_id=args.output_run_id,
+        resume_from=resume_from,
+        checkpoint_interval=int(os.environ.get("RADA_CHECKPOINT_INTERVAL", "100")),
+        checkpoint_keep_last=int(os.environ.get("RADA_CHECKPOINT_KEEP_LAST", "3")),
     )
     config.lora.rank = args.lora_rank
 
diff --git a/src/rada/adapters/scenario_reasoner.py b/src/rada/adapters/scenario_reasoner.py
index 99280a5..40c6daf 100644
--- a/src/rada/adapters/scenario_reasoner.py
+++ b/src/rada/adapters/scenario_reasoner.py
@@ -4,7 +4,7 @@
 
 from rada.interfaces import BaseReasoner
 from rada.schemas import ActionDirection, DecisionTrace, MarketEvent, ProposedAction
-from rada.search.simulation import ShockScenario, generate_shock_scenario
+from rada.search.simulation import ShockScenario
 
 
 class ScenarioReasoner(BaseReasoner):
@@ -20,21 +20,39 @@ def __init__(self, scenario: ShockScenario | None = None) -> None:
             steps=3,
         )
 
+    def _shock_threshold_price(self) -> float:
+        return self._scenario.base_price * (1.0 + self._scenario.price_delta_pct / 100.0)
+
+    def _is_shock_active(self, event: MarketEvent) -> bool:
+        if event.symbol != self._scenario.symbol:
+            return False
+        return event.price < self._shock_threshold_price()
+
+    def _suggested_size(self, event: MarketEvent) -> float:
+        return max(0.1, min(event.volume, 10.0))
+
     async def reason(self, event: MarketEvent) -> DecisionTrace:
-        events = generate_shock_scenario(self._scenario)
-        shock_active = any(
-            e.symbol == event.symbol and e.price < self._scenario.base_price for e in events
-        )
+        shock_active = self._is_shock_active(event)
         direction = ActionDirection.SELL if shock_active else ActionDirection.HOLD
         return DecisionTrace(
             model_name="scenario-reasoner-mock",
-            rationale=f"Shock scenario {self._scenario.name}: suggest {direction.value}",
-            assumptions=[f"price_delta_pct={self._scenario.price_delta_pct}"],
+            rationale=(
+                f"Shock scenario {self._scenario.name}: live price {event.price:.2f} "
+                f"vs threshold {self._shock_threshold_price():.2f} -> {direction.value}"
+            ),
+            assumptions=[
+                f"price_delta_pct={self._scenario.price_delta_pct}",
+                f"event_volume={event.volume}",
+            ],
             faithfulness_score=0.75 if shock_active else 0.9,
         )
 
     async def propose_from_event(self, event: MarketEvent) -> ProposedAction:
-        trace = await self.reason(event)
-        if "SELL" in trace.rationale:
-            return ProposedAction(direction=ActionDirection.SELL, size=1.0, cvar_impact=0.04)
+        shock_active = self._is_shock_active(event)
+        if shock_active:
+            return ProposedAction(
+                direction=ActionDirection.SELL,
+                size=self._suggested_size(event),
+                cvar_impact=0.04,
+            )
         return ProposedAction(direction=ActionDirection.HOLD, size=0.0, cvar_impact=0.0)
diff --git a/src/rada/audit/api.py b/src/rada/audit/api.py
index 25bcde2..d892005 100644
--- a/src/rada/audit/api.py
+++ b/src/rada/audit/api.py
@@ -5,12 +5,15 @@
 import json
 from datetime import datetime
 
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
 from fastapi.responses import StreamingResponse
 
 from rada.audit.store import AuditStore
+from rada.security.auth import require_api_key
 
-router = APIRouter(prefix="/audit", tags=["audit"])
+router = APIRouter(prefix="/audit", tags=["audit"], dependencies=[Depends(require_api_key)])
+
+_MAX_EXPORT_ROWS = 10_000
 
 
 def _get_store(request: Request) -> AuditStore:
@@ -21,6 +24,16 @@ def _get_store(request: Request) -> AuditStore:
     return store
 
 
+def _parse_iso_timestamp(value: str, *, field: str) -> datetime:
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"invalid {field} timestamp: {value}",
+        ) from exc
+
+
 @router.get("/decision/{decision_id}")
 async def get_decision_audit(decision_id: str, request: Request) -> dict:
     store = _get_store(request)
@@ -36,11 +49,13 @@ async def export_audit(
     request: Request,
     from_: str | None = None,
     to: str | None = None,
+    limit: int = Query(default=1000, ge=1, le=_MAX_EXPORT_ROWS),
 ) -> StreamingResponse:
     store = _get_store(request)
-    from_ts = datetime.fromisoformat(from_.replace("Z", "+00:00")) if from_ else None
-    to_ts = datetime.fromisoformat(to.replace("Z", "+00:00")) if to else None
+    from_ts = _parse_iso_timestamp(from_, field="from") if from_ else None
+    to_ts = _parse_iso_timestamp(to, field="to") if to else None
     events = await store.export_range(from_ts, to_ts)
+    events = events[:limit]
 
     def _stream():
         for event in events:
diff --git a/src/rada/audit/store.py b/src/rada/audit/store.py
index cb70f09..fce3381 100644
--- a/src/rada/audit/store.py
+++ b/src/rada/audit/store.py
@@ -41,6 +41,14 @@ def _run() -> None:
                     END
                     """
                 )
+                conn.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_audit_events_decision_id "
+                    "ON audit_events(decision_id)"
+                )
+                conn.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_audit_events_timestamp "
+                    "ON audit_events(timestamp)"
+                )
                 conn.commit()
 
         await asyncio.to_thread(_run)
diff --git a/src/rada/audit/writer.py b/src/rada/audit/writer.py
index c710cde..8ecfa72 100644
--- a/src/rada/audit/writer.py
+++ b/src/rada/audit/writer.py
@@ -3,18 +3,28 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from typing import Any
 
 from rada.audit.schemas import AuditEvent, AuditEventType
 from rada.audit.store import AuditStore
 from rada.observability.metrics import get_metrics
 
+logger = logging.getLogger(__name__)
+
 
 class AuditWriter:
-    def __init__(self, store: AuditStore | None = None, queue_maxsize: int = 512) -> None:
+    def __init__(
+        self,
+        store: AuditStore | None = None,
+        queue_maxsize: int = 512,
+        *,
+        enqueue_timeout_sec: float = 5.0,
+    ) -> None:
         self._store = store or AuditStore()
         self._queue: asyncio.Queue[AuditEvent | None] = asyncio.Queue(maxsize=queue_maxsize)
         self._task: asyncio.Task[None] | None = None
+        self._enqueue_timeout_sec = enqueue_timeout_sec
 
     def start(self) -> None:
         if self._task is None or self._task.done():
@@ -45,11 +55,39 @@ def emit(
         try:
             self._queue.put_nowait(event)
         except asyncio.QueueFull:
-            get_metrics().inc("rada_loop_errors_total")
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._enqueue_with_timeout(event))
+            except RuntimeError:
+                logger.error("audit queue full and no running loop; dropping event %s", event_type)
+                get_metrics().inc("rada_audit_queue_drops_total")
+
+    async def _enqueue_with_timeout(self, event: AuditEvent) -> None:
+        try:
+            await asyncio.wait_for(
+                self._queue.put(event),
+                timeout=self._enqueue_timeout_sec,
+            )
+        except TimeoutError:
+            logger.error(
+                "audit queue full after %.1fs; dropping %s for decision_id=%s",
+                self._enqueue_timeout_sec,
+                event.event_type,
+                event.decision_id,
+            )
+            get_metrics().inc("rada_audit_queue_drops_total")
 
     async def _consumer(self) -> None:
         while True:
             event = await self._queue.get()
             if event is None:
                 break
-            await self._store.append(event)
+            try:
+                await self._store.append(event)
+            except Exception:
+                logger.exception(
+                    "audit append failed for %s decision_id=%s",
+                    event.event_type,
+                    event.decision_id,
+                )
+                get_metrics().inc("rada_loop_errors_total")
diff --git a/src/rada/calc/engine.py b/src/rada/calc/engine.py
index 8ee74ac..a5b5ede 100644
--- a/src/rada/calc/engine.py
+++ b/src/rada/calc/engine.py
@@ -29,12 +29,26 @@ def _result(
 
 def compute_cvar(returns: list[float], *, alpha: float = 0.05) -> CalcResult:
     if len(returns) < 5:
-        return _result("cvar", 0.0, "fraction", CalcConfidence.LOW, "insufficient_samples")
+        return _result(
+            "cvar",
+            float("nan"),
+            "fraction",
+            CalcConfidence.LOW,
+            "insufficient_samples",
+            {"n": len(returns)},
+        )
     arr = np.asarray(returns, dtype=np.float64)
     var_threshold = np.quantile(arr, alpha)
     tail = arr[arr <= var_threshold]
     if tail.size == 0:
-        return _result("cvar", float(-var_threshold), "fraction", CalcConfidence.MEDIUM, "numpy_quantile")
+        return _result(
+            "cvar",
+            float("nan"),
+            "fraction",
+            CalcConfidence.LOW,
+            "empty_tail",
+            {"alpha": alpha, "var_threshold": float(var_threshold)},
+        )
     cvar = float(-np.mean(tail))
     conf = CalcConfidence.HIGH if len(returns) >= 20 else CalcConfidence.MEDIUM
     return _result("cvar", cvar, "fraction", conf, "historical_cvar", {"alpha": alpha, "n": len(returns)})
diff --git a/src/rada/calc/runner.py b/src/rada/calc/runner.py
index 979f348..a456728 100644
--- a/src/rada/calc/runner.py
+++ b/src/rada/calc/runner.py
@@ -2,22 +2,40 @@
 
 from __future__ import annotations
 
+import math
+
 from rada.calc.engine import compute_cvar, compute_drawdown, compute_position_size
 from rada.calc.schemas import CalcResult
 from rada.schemas import MarketEvent
 
+_MAX_SYNTHETIC_VOLATILITY = 1.0
+
 
 def run_event_calcs(event: MarketEvent) -> list[CalcResult]:
-    """Compute verified metrics from event context for decision trace."""
+    """Compute illustrative metrics from event context (synthetic, not verified)."""
     returns = [-0.02, -0.01, 0.0, 0.01, -0.015, 0.005, -0.03, event.volume * 0.001]
     equity = [100.0, 102.0, 101.0, 100.0 - abs(event.price * 0.0001), 99.5]
-    return [
+    volatility = min(_MAX_SYNTHETIC_VOLATILITY, max(0.05, event.volume * 0.01))
+    results = [
         compute_cvar(returns),
         compute_position_size(
             capital=100_000.0,
             risk_budget=0.02,
             price=event.price,
-            volatility=max(0.05, event.volume * 0.01),
+            volatility=volatility,
         ),
         compute_drawdown(equity),
     ]
+    for result in results:
+        result.context["synthetic"] = True
+    return results
+
+
+def synthetic_context_from_results(results: list[CalcResult]) -> dict[str, float]:
+    """Build synthetic context map, omitting NaN values."""
+    context: dict[str, float] = {}
+    for result in results:
+        if math.isnan(result.value):
+            continue
+        context[result.expression] = result.value
+    return context
diff --git a/src/rada/core/decision_loop.py b/src/rada/core/decision_loop.py
index ef06a7b..61bccb6 100644
--- a/src/rada/core/decision_loop.py
+++ b/src/rada/core/decision_loop.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+import math
 from typing import TYPE_CHECKING
 
-from rada.calc.runner import run_event_calcs
+from rada.calc.runner import run_event_calcs, synthetic_context_from_results
 from rada.core.reasoner_loop import ActionTarget, ReasonerLoop
 from rada.interfaces import BaseDataStore, BasePolicy, BaseReasoner, BaseRiskOptimizer
 from rada.schemas import ActionDirection, Decision, DecisionTrace, MarketEvent, ProposedAction
@@ -67,23 +68,28 @@ def __init__(
         self._cvar_limit = cvar_limit
         self._audit_writer = audit_writer
 
+    def _effective_cvar_limit(self, synthetic_cvar: float | None) -> float:
+        if synthetic_cvar is None or math.isnan(synthetic_cvar):
+            return self._cvar_limit
+        return min(self._cvar_limit, max(synthetic_cvar, 0.01))
+
     def _select_from_targets(
         self,
         event: MarketEvent,
         trace: DecisionTrace,
         targets: list[ActionTarget],
+        *,
+        cvar_limit: float,
     ) -> ProposedAction:
+        _ = trace
         candidates = [t.action for t in targets]
         if not candidates:
             return ProposedAction(direction=ActionDirection.HOLD, size=0)
-        selected = select_cvar_feasible_action(
+        return select_cvar_feasible_action(
             candidates,
             price=event.price,
-            tailwarp=TailWarpStub(cvar_limit=self._cvar_limit),
+            tailwarp=TailWarpStub(cvar_limit=cvar_limit),
         )
-        if selected.direction == ActionDirection.HOLD and candidates:
-            _ = trace
-        return selected
 
     async def process_one(self, event: MarketEvent) -> Decision:
         from rada.observability.metrics import LatencyTimer, get_metrics
@@ -97,25 +103,41 @@ async def process_one(self, event: MarketEvent) -> Decision:
 
             with tracer.start_span("calc") as calc_span:
                 calc_results = run_event_calcs(event)
-                verified = {r.expression: r.value for r in calc_results}
-                cvar_value = verified.get("cvar", 0.0)
+                synthetic = synthetic_context_from_results(calc_results)
+                cvar_raw = synthetic.get("cvar")
+                cvar_value = cvar_raw if cvar_raw is not None else float("nan")
+                effective_cvar_limit = self._effective_cvar_limit(
+                    cvar_raw if cvar_raw is not None else None
+                )
                 calc_span.set_attribute("cvar_value", cvar_value)
-                self._cvar_limit = min(self._cvar_limit, max(cvar_value, 0.01))
 
             with tracer.start_span("select") as select_span:
                 trace, targets = await self._reasoner_loop.propose_targets(event)
+                assumptions = list(trace.assumptions)
+                if not math.isnan(cvar_value):
+                    assumptions.append(f"synthetic_cvar={cvar_value:.4f}")
                 trace = trace.model_copy(
                     update={
                         "calc_results": [r.model_dump() for r in calc_results],
-                        "verified_context": verified,
-                        "assumptions": list(trace.assumptions) + [f"verified_cvar={cvar_value:.4f}"],
+                        "synthetic_context": synthetic,
+                        "assumptions": assumptions,
                     }
                 )
-                proposed = self._select_from_targets(event, trace, targets)
+                proposed = self._select_from_targets(
+                    event,
+                    trace,
+                    targets,
+                    cvar_limit=effective_cvar_limit,
+                )
                 if proposed.direction == ActionDirection.HOLD:
                     proposed = await self._policy.propose(event, trace)
                 if self._search_loop is not None and self._search_loop.enabled:
-                    proposed = await self._search_loop.refine_proposal(event, trace, proposed)
+                    proposed = await self._search_loop.refine_proposal(
+                        event,
+                        trace,
+                        proposed,
+                        cvar_limit=effective_cvar_limit,
+                    )
                 select_span.set_attribute("direction", proposed.direction.value)
 
             with tracer.start_span("risk_gate", cvar_value=cvar_value) as gate_span:
@@ -145,7 +167,7 @@ async def process_one(self, event: MarketEvent) -> Decision:
                 self._audit_writer.emit(
                     AuditEventType.CALC,
                     decision_id=decision.decision_id,
-                    payload_after={"verified_context": verified},
+                    payload_after={"synthetic_context": synthetic},
                 )
 
             metrics.inc("rada_decisions_total")
diff --git a/src/rada/core/reflection_loop.py b/src/rada/core/reflection_loop.py
index 913c244..6cab299 100644
--- a/src/rada/core/reflection_loop.py
+++ b/src/rada/core/reflection_loop.py
@@ -1,22 +1,25 @@
-"""Async reflection loop — off the hot decision path (S3-03).
-
-Completed decisions are enqueued without blocking ``DecisionLoop``. A background
-consumer runs auditor scoring, sets outcome stubs, updates policy checkpoint,
-and emits batch export rows.
-"""
+"""Async reflection loop — off the hot decision path (S3-03)."""
 
 from __future__ import annotations
 
 import asyncio
+import logging
+from collections import deque
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from pathlib import Path
 
 from rada.data.export_batch import export_decisions
 from rada.interfaces import BaseAuditor, BaseDataStore, BasePolicy
+from rada.observability.metrics import get_metrics
 from rada.schemas import Decision, DecisionTrace
 from rada.utils.metrics import record_reflection_processed
 
+logger = logging.getLogger(__name__)
+
+_EXPORT_BATCH_SIZE = 10
+_MAX_SCORE_HISTORY = 1000
+
 
 def stub_outcome(decision: Decision) -> dict[str, object]:
     """Reflection-path outcome stub for export filter compatibility."""
@@ -36,7 +39,7 @@ class PolicyCheckpoint:
     audit_count: int = 0
     mean_faithfulness: float = 0.0
     last_rationale: str = ""
-    policy_update_signals: list[str] = field(default_factory=list)
+    policy_update_signals: deque[str] = field(default_factory=lambda: deque(maxlen=_MAX_SCORE_HISTORY))
 
 
 @dataclass(slots=True)
@@ -94,6 +97,7 @@ def __init__(
         data_store: BaseDataStore | None = None,
         export_dir: Path | None = None,
         queue_maxsize: int = 256,
+        export_batch_size: int = _EXPORT_BATCH_SIZE,
     ) -> None:
         self._auditor = auditor or StubAuditor()
         self._policy_updater = policy_updater or ReflectionPolicyUpdater()
@@ -101,9 +105,10 @@ def __init__(
         self._export_dir = export_dir or Path("exports/reflection_runtime")
         self._queue: asyncio.Queue[Decision | None] = asyncio.Queue(maxsize=queue_maxsize)
         self._consumer_task: asyncio.Task[None] | None = None
-        self._audit_scores: list[float] = []
+        self._audit_scores: deque[float] = deque(maxlen=_MAX_SCORE_HISTORY)
         self._processed_with_outcome: list[Decision] = []
         self._last_summary = ReflectionSummary()
+        self._export_batch_size = export_batch_size
 
     @property
     def policy_checkpoint(self) -> PolicyCheckpoint:
@@ -122,7 +127,11 @@ def enqueue(self, decision: Decision) -> None:
         try:
             self._queue.put_nowait(decision)
         except asyncio.QueueFull:
-            return
+            logger.error(
+                "reflection queue full; dropping decision_id=%s",
+                decision.decision_id,
+            )
+            get_metrics().inc("rada_reflection_queue_drops_total")
 
     async def drain_one(self) -> bool:
         """Process a single queued decision (for tests without background task)."""
@@ -145,6 +154,7 @@ async def drain_all(self) -> int:
     async def run_batch_from_store(self, *, limit: int | None = 100) -> ReflectionSummary:
         """Read action DB off hot path, audit, export, and update policy checkpoint."""
         if self._data_store is None:
+            logger.warning("reflection batch skipped: data_store is not configured")
             return ReflectionSummary()
         decisions = await self._data_store.list_decisions(limit=limit)
         for decision in decisions:
@@ -157,7 +167,10 @@ def start(self) -> None:
 
     async def stop(self) -> None:
         if self._consumer_task is not None:
-            await self._queue.put(None)
+            try:
+                self._queue.put_nowait(None)
+            except asyncio.QueueFull:
+                await self._queue.put(None)
             await self._consumer_task
             self._consumer_task = None
 
@@ -166,29 +179,59 @@ async def _consumer_loop(self) -> None:
             decision = await self._queue.get()
             if decision is None:
                 break
-            await self._process(decision)
+            try:
+                await self._process(decision)
+            except Exception:
+                logger.exception(
+                    "reflection processing failed for decision_id=%s",
+                    decision.decision_id,
+                )
+                get_metrics().inc("rada_loop_errors_total")
+
+    async def _persist_outcome(self, decision: Decision) -> None:
+        if self._data_store is None:
+            return
+        update = getattr(self._data_store, "update_decision", None)
+        if update is None:
+            return
+        try:
+            await update(decision)
+        except Exception:
+            logger.exception(
+                "failed to persist reflection outcome for decision_id=%s",
+                decision.decision_id,
+            )
+
+    async def _maybe_export_batch(self, checkpoint: PolicyCheckpoint) -> None:
+        if len(self._processed_with_outcome) < self._export_batch_size:
+            return
+        summary = export_decisions(
+            self._processed_with_outcome,
+            output_dir=self._export_dir,
+            batch_id=f"reflection-{checkpoint.version}",
+        )
+        self._last_summary = ReflectionSummary(
+            processed=len(self._processed_with_outcome),
+            exported_batch_id=summary["batch_id"],
+            export_paths=summary,
+            checkpoint_version=checkpoint.version,
+        )
+        self._processed_with_outcome.clear()
 
     async def _process(self, decision: Decision) -> None:
         audit_trace = await self._auditor.audit(decision)
         score = audit_trace.faithfulness_score or 0.0
         self._audit_scores.append(score)
 
-        enriched = decision.model_copy(update={"outcome": stub_outcome(decision)})
+        enriched = decision.model_copy(
+            update={
+                "outcome": stub_outcome(decision),
+                "trace": audit_trace,
+            }
+        )
+        await self._persist_outcome(enriched)
         self._processed_with_outcome.append(enriched)
 
         checkpoint = await self._policy_updater.apply(enriched, audit_trace)
         record_reflection_processed(checkpoint.mean_faithfulness)
-
-        if len(self._processed_with_outcome) >= 1:
-            summary = export_decisions(
-                self._processed_with_outcome,
-                output_dir=self._export_dir,
-                batch_id=f"reflection-{checkpoint.version}",
-            )
-            self._last_summary = ReflectionSummary(
-                processed=len(self._processed_with_outcome),
-                exported_batch_id=summary["batch_id"],
-                export_paths=summary,
-                checkpoint_version=checkpoint.version,
-            )
-            self._processed_with_outcome.clear()
+        await self._maybe_export_batch(checkpoint)
diff --git a/src/rada/core/search_loop.py b/src/rada/core/search_loop.py
index c42361d..04edbaf 100644
--- a/src/rada/core/search_loop.py
+++ b/src/rada/core/search_loop.py
@@ -4,10 +4,10 @@
 
 import os
 
+from rada.interfaces import BaseRiskOptimizer
 from rada.schemas import ActionDirection, DecisionTrace, MarketEvent, ProposedAction
 from rada.search.mcts import MCTSPlanner, TrinityPolicyStub
-from rada.interfaces import BaseRiskOptimizer
-from rada.search.risk_selection import select_cvar_feasible_action
+from rada.search.risk_selection import TailWarpStub, select_cvar_feasible_action
 from rada.utils.metrics import record_search_invocation
 
 
@@ -23,8 +23,10 @@ def __init__(
         *,
         risk_optimizer: BaseRiskOptimizer,
         enabled: bool | None = None,
+        cvar_limit: float = 0.05,
     ) -> None:
         self._enabled = search_enabled() if enabled is None else enabled
+        self._cvar_limit = cvar_limit
         self._planner = MCTSPlanner(risk_optimizer=risk_optimizer)
         self._policy_stub = TrinityPolicyStub()
 
@@ -37,19 +39,37 @@ async def refine_proposal(
         event: MarketEvent,
         trace: DecisionTrace,
         proposed: ProposedAction,
+        *,
+        cvar_limit: float | None = None,
     ) -> ProposedAction:
+        _ = trace
         record_search_invocation(self._enabled)
         if not self._enabled:
             return proposed
 
+        effective_limit = cvar_limit if cvar_limit is not None else self._cvar_limit
+        tailwarp = TailWarpStub(cvar_limit=effective_limit)
+
         plan = await self._planner.plan(event, trace)
         best = plan.get("best_action", {})
-        direction = best.get("direction", proposed.direction.value)
-        size = float(best.get("size", proposed.size))
+        try:
+            mcts_direction = ActionDirection(best.get("direction", proposed.direction.value))
+        except ValueError:
+            mcts_direction = proposed.direction
+        mcts_size = float(best.get("size", proposed.size))
+        mcts_action = ProposedAction(direction=mcts_direction, size=mcts_size)
 
         candidates = self._policy_stub.propose_candidates(event, top_k=3)
-        if candidates:
-            chosen = select_cvar_feasible_action(candidates, price=event.price)
-            return chosen
+        merged: list[ProposedAction] = [mcts_action]
+        for candidate in candidates:
+            if candidate.direction != mcts_action.direction or candidate.size != mcts_action.size:
+                merged.append(candidate)
+
+        if merged:
+            return select_cvar_feasible_action(
+                merged,
+                price=event.price,
+                tailwarp=tailwarp,
+            )
 
-        return ProposedAction(direction=ActionDirection(direction), size=size)
+        return mcts_action
diff --git a/src/rada/data/analytics.py b/src/rada/data/analytics.py
index d1a937d..81c457f 100644
--- a/src/rada/data/analytics.py
+++ b/src/rada/data/analytics.py
@@ -17,6 +17,8 @@ class RollingPnLTracker:
     _values: deque[float] = field(default_factory=deque)
 
     def record(self, decision: Decision) -> float:
+        if self.window <= 0:
+            raise ValueError("window must be > 0")
         pnl = pnl_stub_from_decision(decision)
         self._values.append(pnl)
         while len(self._values) > self.window:
diff --git a/src/rada/data/bus.py b/src/rada/data/bus.py
index 6f8b2e4..0739a5e 100644
--- a/src/rada/data/bus.py
+++ b/src/rada/data/bus.py
@@ -4,12 +4,15 @@
 
 import asyncio
 import json
+import logging
 import os
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator
 
 from rada.schemas import MarketEvent
 
+logger = logging.getLogger(__name__)
+
 
 class BaseEventBus(ABC):
     """Async queue abstraction for MarketEvent ingest."""
@@ -22,6 +25,9 @@ async def enqueue(self, event: MarketEvent) -> None:
     async def dequeue(self) -> MarketEvent:
         """Block until one market event is available."""
 
+    async def close(self) -> None:
+        """Release backend resources when supported."""
+
 
 class InMemoryEventBus(BaseEventBus):
     def __init__(self) -> None:
@@ -50,6 +56,9 @@ async def dequeue(self) -> MarketEvent:
         _, payload = await self._client.blpop(self._channel)
         return MarketEvent.model_validate_json(payload)
 
+    async def close(self) -> None:
+        await self._client.aclose()
+
 
 class KafkaEventBus(BaseEventBus):
     """Kafka-backed bus using aiokafka when installed; falls back to in-memory."""
@@ -74,6 +83,7 @@ def __init__(
             self._consumer_cls = AIOKafkaConsumer
             self._use_kafka = True
         except ImportError:
+            logger.warning("aiokafka not installed; KafkaEventBus uses in-memory fallback")
             self._use_kafka = False
 
     async def _ensure_kafka(self) -> None:
@@ -104,9 +114,17 @@ async def dequeue(self) -> MarketEvent:
         msg = await self._consumer.getone()
         return MarketEvent.model_validate_json(msg.value.decode())
 
+    async def close(self) -> None:
+        if self._producer is not None:
+            await self._producer.stop()
+            self._producer = None
+        if self._consumer is not None:
+            await self._consumer.stop()
+            self._consumer = None
+
 
 class ZeroMQEventBus(BaseEventBus):
-    """ZeroMQ PUB/SUB bus; uses in-memory fallback when pyzmq unavailable."""
+    """ZeroMQ PUB/SUB bus; local dequeue only (cross-process subscribe not implemented)."""
 
     def __init__(self, endpoint: str) -> None:
         self._endpoint = endpoint
@@ -124,6 +142,7 @@ def __init__(self, endpoint: str) -> None:
             self._zmq_asyncio = zmq.asyncio
             self._use_zmq = True
         except ImportError:
+            logger.warning("pyzmq not installed; ZeroMQEventBus uses in-memory fallback")
             self._use_zmq = False
 
     async def _ensure_zmq(self) -> None:
@@ -160,6 +179,10 @@ async def build_event_bus(mode: str | None = None) -> BaseEventBus:
         try:
             return RedisEventBus(redis_url)
         except Exception:
+            logger.exception(
+                "failed to initialize RedisEventBus for %s; falling back to in-memory",
+                redis_url,
+            )
             return InMemoryEventBus()
 
     if selected == "kafka":
diff --git a/src/rada/data/storage.py b/src/rada/data/storage.py
index a796361..97a1be1 100644
--- a/src/rada/data/storage.py
+++ b/src/rada/data/storage.py
@@ -32,6 +32,11 @@ async def save_decision(self, decision: Decision) -> None:
     async def get_decision(self, decision_id: str) -> Decision | None:
         return self._items.get(decision_id)
 
+    async def update_decision(self, decision: Decision) -> None:
+        if decision.decision_id not in self._items:
+            raise KeyError(f"decision not found: {decision.decision_id}")
+        self._items[decision.decision_id] = decision
+
     async def list_decisions(
         self,
         *,
@@ -108,6 +113,24 @@ async def get_decision(self, decision_id: str) -> Decision | None:
             return None
         return Decision.model_validate_json(row[0])
 
+    async def update_decision(self, decision: Decision) -> None:
+        await self.ensure_ready()
+        rowcount = await self._execute_update(
+            "UPDATE decisions SET payload = ? WHERE decision_id = ?",
+            (decision.model_dump_json(), decision.decision_id),
+        )
+        if rowcount == 0:
+            raise KeyError(f"decision not found: {decision.decision_id}")
+
+    async def _execute_update(self, query: str, params: tuple[object, ...]) -> int:
+        def _run() -> int:
+            with sqlite3.connect(self._db_path) as conn:
+                cursor = conn.execute(query, params)
+                conn.commit()
+                return cursor.rowcount
+
+        return await asyncio.to_thread(_run)
+
     async def list_decisions(
         self,
         *,
diff --git a/src/rada/data/timescale_store.py b/src/rada/data/timescale_store.py
index c1e4152..b4191a8 100644
--- a/src/rada/data/timescale_store.py
+++ b/src/rada/data/timescale_store.py
@@ -7,7 +7,6 @@
 
 import asyncpg
 
-from rada.data.query import filter_decisions
 from rada.interfaces import BaseDataStore
 from rada.schemas import Decision
 
@@ -96,6 +95,12 @@ async def ensure_ready(self) -> None:
                 ON decision_traces(model_name, ts DESC)
                 """
             )
+            await conn.execute(
+                """
+                CREATE INDEX IF NOT EXISTS idx_decisions_created_at
+                ON decisions(created_at DESC)
+                """
+            )
 
             has_timescaledb = await conn.fetchval(
                 "SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb')"
@@ -131,8 +136,12 @@ async def save_decision(self, decision: Decision) -> None:
             async with conn.transaction():
                 try:
                     await conn.execute(
-                        "INSERT INTO decisions (decision_id, payload) VALUES ($1, $2::jsonb)",
+                        """
+                        INSERT INTO decisions (decision_id, created_at, payload)
+                        VALUES ($1, $2, $3::jsonb)
+                        """,
                         decision.decision_id,
+                        decision.timestamp,
                         json.dumps(payload),
                     )
                 except asyncpg.UniqueViolationError as exc:
@@ -186,6 +195,24 @@ async def get_decision(self, decision_id: str) -> Decision | None:
             return None
         return Decision.model_validate_json(payload)
 
+    async def update_decision(self, decision: Decision) -> None:
+        await self.ensure_ready()
+        pool = await self._pool_or_create()
+        payload = json.dumps(json.loads(decision.model_dump_json()))
+        async with pool.acquire() as conn:
+            result = await conn.execute(
+                """
+                UPDATE decisions
+                SET payload = $2::jsonb, created_at = $3
+                WHERE decision_id = $1
+                """,
+                decision.decision_id,
+                payload,
+                decision.timestamp,
+            )
+        if result.split()[-1] == "0":
+            raise KeyError(f"decision not found: {decision.decision_id}")
+
     async def list_decisions(
         self,
         *,
@@ -196,23 +223,24 @@ async def list_decisions(
         await self.ensure_ready()
         pool = await self._pool_or_create()
 
-        query = "SELECT payload::text FROM decisions"
+        clauses: list[str] = []
         params: list[object] = []
         if since is not None:
-            query += " WHERE created_at >= $1"
             params.append(since)
-        query += " ORDER BY created_at DESC"
+            clauses.append(f"created_at >= ${len(params)}")
+        if policy_ids:
+            params.append(policy_ids)
+            clauses.append(f"payload->>'policy_id' = ANY(${len(params)})")
+        where = f" WHERE {' AND '.join(clauses)}" if clauses else ""
+        query = f"SELECT payload::text FROM decisions{where} ORDER BY created_at DESC"
         if limit is not None and limit > 0:
-            query += f" LIMIT ${len(params) + 1}"
             params.append(limit)
+            query += f" LIMIT ${len(params)}"
 
         async with pool.acquire() as conn:
             rows = await conn.fetch(query, *params)
 
-        decisions = [Decision.model_validate_json(row[0]) for row in rows]
-        if policy_ids:
-            decisions = filter_decisions(decisions, policy_ids=policy_ids)
-        return decisions
+        return [Decision.model_validate_json(row[0]) for row in rows]
 
     async def close(self) -> None:
         """Gracefully close pool for process shutdown hooks and tests."""
diff --git a/src/rada/feedback/api.py b/src/rada/feedback/api.py
index d98e552..117502e 100644
--- a/src/rada/feedback/api.py
+++ b/src/rada/feedback/api.py
@@ -2,14 +2,18 @@
 
 from __future__ import annotations
 
-from fastapi import APIRouter, Request
+from datetime import UTC, datetime
+from uuid import uuid4
+
+from fastapi import APIRouter, Depends, HTTPException, Request, status
 
 from rada.audit.schemas import AuditEventType
 from rada.audit.writer import AuditWriter
-from rada.feedback.schemas import HumanFeedback
-from rada.feedback.store import FeedbackStore
+from rada.feedback.schemas import HumanFeedback, HumanFeedbackSubmit
+from rada.feedback.store import FeedbackDuplicateError, FeedbackStore
+from rada.security.auth import require_api_key
 
-router = APIRouter(prefix="/feedback", tags=["feedback"])
+router = APIRouter(prefix="/feedback", tags=["feedback"], dependencies=[Depends(require_api_key)])
 
 
 def _feedback_store(request: Request) -> FeedbackStore:
@@ -30,9 +34,20 @@ def _audit_writer(request: Request) -> AuditWriter:
 
 
 @router.post("/submit")
-async def submit_feedback(feedback: HumanFeedback, request: Request) -> dict:
+async def submit_feedback(payload: HumanFeedbackSubmit, request: Request) -> dict:
     store = _feedback_store(request)
-    saved = await store.submit(feedback)
+    feedback = HumanFeedback(
+        feedback_id=str(uuid4()),
+        decision_id=payload.decision_id,
+        action=payload.action,
+        note=payload.note,
+        timestamp=datetime.now(tz=UTC),
+        reviewer=payload.reviewer,
+    )
+    try:
+        saved = await store.submit(feedback)
+    except FeedbackDuplicateError as exc:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc
     _audit_writer(request).emit(
         AuditEventType.HUMAN_FEEDBACK,
         decision_id=saved.decision_id,
diff --git a/src/rada/feedback/auto_flag.py b/src/rada/feedback/auto_flag.py
index 849d2ec..45ef38a 100644
--- a/src/rada/feedback/auto_flag.py
+++ b/src/rada/feedback/auto_flag.py
@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from datetime import UTC, datetime
+from uuid import uuid4
+
 from rada.feedback.schemas import FeedbackAction, HumanFeedback
 from rada.schemas import Decision
 
@@ -9,6 +12,8 @@
 def should_auto_flag(decision: Decision, *, cvar_limit: float = 0.05) -> tuple[bool, str]:
     """Return (flag, reason) for CVaR breach or low LLM confidence."""
     cvar = decision.trace.verified_context.get("cvar")
+    if cvar is None:
+        cvar = decision.trace.synthetic_context.get("cvar")
     if cvar is not None and cvar > cvar_limit:
         return True, f"CVaR breach: {cvar:.4f} > {cvar_limit}"
 
@@ -25,8 +30,10 @@ def should_auto_flag(decision: Decision, *, cvar_limit: float = 0.05) -> tuple[b
 
 def build_flag_feedback(decision: Decision, reason: str) -> HumanFeedback:
     return HumanFeedback(
+        feedback_id=str(uuid4()),
         decision_id=decision.decision_id,
         action=FeedbackAction.FLAG,
         note=reason,
+        timestamp=datetime.now(tz=UTC),
         reviewer="auto-flag",
     )
diff --git a/src/rada/feedback/schemas.py b/src/rada/feedback/schemas.py
index 05d2bf6..4c976d9 100644
--- a/src/rada/feedback/schemas.py
+++ b/src/rada/feedback/schemas.py
@@ -4,9 +4,8 @@
 
 from datetime import UTC, datetime
 from enum import Enum
-from uuid import uuid4
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 class FeedbackAction(str, Enum):
@@ -16,10 +15,27 @@ class FeedbackAction(str, Enum):
     ANNOTATE = "ANNOTATE"
 
 
+class HumanFeedbackSubmit(BaseModel):
+    """Client-submitted feedback payload (server assigns id/timestamp)."""
+
+    decision_id: str = Field(min_length=1, max_length=128)
+    action: FeedbackAction
+    note: str = Field(default="", max_length=4000)
+    reviewer: str = Field(default="operator", min_length=1, max_length=128)
+
+    @field_validator("decision_id", "reviewer")
+    @classmethod
+    def strip_non_empty(cls, value: str) -> str:
+        stripped = value.strip()
+        if not stripped:
+            raise ValueError("must not be empty")
+        return stripped
+
+
 class HumanFeedback(BaseModel):
-    feedback_id: str = Field(default_factory=lambda: str(uuid4()))
+    feedback_id: str
     decision_id: str
     action: FeedbackAction
     note: str = ""
-    timestamp: datetime = Field(default_factory=lambda: datetime.now(tz=UTC))
+    timestamp: datetime
     reviewer: str = "operator"
diff --git a/src/rada/feedback/store.py b/src/rada/feedback/store.py
index 6f1a19c..1e7ecab 100644
--- a/src/rada/feedback/store.py
+++ b/src/rada/feedback/store.py
@@ -7,9 +7,15 @@
 import sqlite3
 from pathlib import Path
 
+from datetime import datetime
+
 from rada.feedback.schemas import FeedbackAction, HumanFeedback
 
 
+class FeedbackDuplicateError(Exception):
+    """Raised when feedback_id already exists."""
+
+
 class FeedbackStore:
     def __init__(self, db_path: str = "./rada_feedback.db") -> None:
         self._db_path = db_path
@@ -49,46 +55,63 @@ async def submit(self, feedback: HumanFeedback) -> HumanFeedback:
 
         def _run() -> None:
             with sqlite3.connect(self._db_path) as conn:
-                conn.execute(
-                    """
-                    INSERT INTO human_feedback
-                    (feedback_id, decision_id, action, note, timestamp, reviewer, status)
-                    VALUES (?, ?, ?, ?, ?, ?, 'submitted')
-                    """,
-                    (
-                        feedback.feedback_id,
-                        feedback.decision_id,
-                        feedback.action.value,
-                        feedback.note,
-                        feedback.timestamp.isoformat(),
-                        feedback.reviewer,
-                    ),
-                )
-                conn.commit()
+                try:
+                    conn.execute(
+                        """
+                        INSERT INTO human_feedback
+                        (feedback_id, decision_id, action, note, timestamp, reviewer, status)
+                        VALUES (?, ?, ?, ?, ?, ?, 'submitted')
+                        """,
+                        (
+                            feedback.feedback_id,
+                            feedback.decision_id,
+                            feedback.action.value,
+                            feedback.note,
+                            feedback.timestamp.isoformat(),
+                            feedback.reviewer,
+                        ),
+                    )
+                    conn.commit()
+                except sqlite3.IntegrityError as exc:
+                    raise FeedbackDuplicateError(
+                        f"feedback_id already exists: {feedback.feedback_id}"
+                    ) from exc
 
         await asyncio.to_thread(_run)
         return feedback
 
-    async def list_pending(self) -> list[HumanFeedback]:
+    async def list_pending(self, *, limit: int = 100) -> list[HumanFeedback]:
         await self.ensure_ready()
 
         def _run() -> list[HumanFeedback]:
             with sqlite3.connect(self._db_path) as conn:
                 rows = conn.execute(
-                    "SELECT feedback_id, decision_id, action, note, timestamp, reviewer "
-                    "FROM human_feedback WHERE action = ? ORDER BY timestamp DESC",
-                    (FeedbackAction.FLAG.value,),
+                    """
+                    SELECT feedback_id, decision_id, action, note, timestamp, reviewer
+                    FROM human_feedback
+                    WHERE action = ? AND status = 'submitted'
+                    ORDER BY timestamp DESC
+                    LIMIT ?
+                    """,
+                    (FeedbackAction.FLAG.value, limit),
                 ).fetchall()
-            return [
-                HumanFeedback(
-                    feedback_id=row[0],
-                    decision_id=row[1],
-                    action=FeedbackAction(row[2]),
-                    note=row[3],
-                    timestamp=__import__("datetime").datetime.fromisoformat(row[4]),
-                    reviewer=row[5],
+            seen: set[str] = set()
+            items: list[HumanFeedback] = []
+            for row in rows:
+                decision_id = row[1]
+                if decision_id in seen:
+                    continue
+                seen.add(decision_id)
+                items.append(
+                    HumanFeedback(
+                        feedback_id=row[0],
+                        decision_id=decision_id,
+                        action=FeedbackAction(row[2]),
+                        note=row[3],
+                        timestamp=datetime.fromisoformat(row[4]),
+                        reviewer=row[5],
+                    )
                 )
-                for row in rows
-            ]
+            return items
 
         return await asyncio.to_thread(_run)
diff --git a/src/rada/interfaces/data_store.py b/src/rada/interfaces/data_store.py
index 1010579..d968e76 100644
--- a/src/rada/interfaces/data_store.py
+++ b/src/rada/interfaces/data_store.py
@@ -19,6 +19,10 @@ async def save_decision(self, decision: Decision) -> None:
     async def get_decision(self, decision_id: str) -> Decision | None:
         """Fetch one decision artifact by immutable identifier."""
 
+    async def update_decision(self, decision: Decision) -> None:
+        """Update a persisted decision (e.g. attach reflection outcome)."""
+        raise NotImplementedError(f"{type(self).__name__} does not support update_decision")
+
     async def list_decisions(
         self,
         *,
diff --git a/src/rada/llm_integration/adapters/_http_base.py b/src/rada/llm_integration/adapters/_http_base.py
index 17b0427..28b0429 100644
--- a/src/rada/llm_integration/adapters/_http_base.py
+++ b/src/rada/llm_integration/adapters/_http_base.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 import time
 from typing import Any
 
@@ -11,6 +12,11 @@
 from rada.llm_integration.config import LLMConfig
 from rada.llm_integration.context import resolve_max_tokens
 
+logger = logging.getLogger(__name__)
+
+_MAX_RETRIES = 3
+_RETRY_STATUS_CODES = {408, 429, 500, 502, 503, 504}
+
 
 class OpenAICompatibleAdapter(LLMProvider):
     """Base for vLLM/Ollama/custom OpenAI-compatible endpoints."""
@@ -19,11 +25,63 @@ def __init__(self, config: LLMConfig, *, backend_id: str, default_base_url: str)
         self._config = config
         self._backend_id = backend_id
         self._base_url = (config.base_url or default_base_url).rstrip("/")
+        self._client: httpx.AsyncClient | None = None
 
     @property
     def backend_id(self) -> str:
         return self._backend_id
 
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(timeout=60.0)
+        return self._client
+
+    async def aclose(self) -> None:
+        if self._client is not None and not self._client.is_closed:
+            await self._client.aclose()
+            self._client = None
+
+    def _extract_completion_text(self, data: dict[str, Any]) -> str:
+        choices = data.get("choices")
+        if not choices:
+            msg = "LLM response missing choices"
+            raise ValueError(msg)
+        message = choices[0].get("message") if isinstance(choices[0], dict) else None
+        if not isinstance(message, dict):
+            msg = "LLM response missing message"
+            raise ValueError(msg)
+        content = message.get("content")
+        if content is None:
+            msg = "LLM response content is null"
+            raise ValueError(msg)
+        return str(content)
+
+    async def _post_with_retries(
+        self,
+        url: str,
+        *,
+        payload: dict[str, Any],
+        headers: dict[str, str],
+    ) -> dict[str, Any]:
+        client = await self._get_client()
+        last_error: Exception | None = None
+        for attempt in range(_MAX_RETRIES):
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                if response.status_code in _RETRY_STATUS_CODES and attempt < _MAX_RETRIES - 1:
+                    await response.aread()
+                    continue
+                response.raise_for_status()
+                return response.json()
+            except (httpx.HTTPError, ValueError) as exc:
+                last_error = exc
+                if attempt >= _MAX_RETRIES - 1:
+                    break
+        if last_error is not None:
+            raise last_error
+        msg = "LLM request failed without error"
+        raise RuntimeError(msg)
+
     async def complete(self, prompt: str, model_id: str, **kwargs: Any) -> Completion:
         api_key = self._config.resolve_api_key()
         headers: dict[str, str] = {"Content-Type": "application/json"}
@@ -42,16 +100,12 @@ async def complete(self, prompt: str, model_id: str, **kwargs: Any) -> Completio
         }
         url = f"{self._base_url}/v1/chat/completions"
         started = time.perf_counter()
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            response = await client.post(url, json=payload, headers=headers)
-            response.raise_for_status()
-            data = response.json()
-
-        choice = data["choices"][0]["message"]["content"]
+        data = await self._post_with_retries(url, payload=payload, headers=headers)
+        choice = self._extract_completion_text(data)
         usage = data.get("usage", {})
         latency_ms = (time.perf_counter() - started) * 1000
         return Completion(
-            text=str(choice),
+            text=choice,
             model_id=model_id,
             backend_id=self._backend_id,
             token_usage={
diff --git a/src/rada/llm_integration/adapters/custom_adapter.py b/src/rada/llm_integration/adapters/custom_adapter.py
index 7dc19d2..eb803f5 100644
--- a/src/rada/llm_integration/adapters/custom_adapter.py
+++ b/src/rada/llm_integration/adapters/custom_adapter.py
@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+import logging
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 from rada.llm_integration.adapters._http_base import OpenAICompatibleAdapter
 from rada.llm_integration.adapters.litellm_adapter import LiteLLMAdapter
 from rada.llm_integration.adapters.mock_adapter import MockLLMAdapter
@@ -31,7 +34,8 @@ async def complete(self, prompt: str, model_id: str, **kwargs: Any) -> Completio
             return await self._mock.complete(prompt, model_id, **kwargs)
         try:
             return await super().complete(prompt, model_id, **kwargs)
-        except Exception:  # noqa: BLE001 — optional fallback chain
+        except Exception as exc:  # noqa: BLE001 — optional fallback chain
+            logger.warning("custom adapter failed for model_id=%s: %s", model_id, exc)
             if self._litellm is not None:
                 return await self._litellm.complete(prompt, model_id, **kwargs)
             return await self._mock.complete(prompt, model_id, **kwargs)
diff --git a/src/rada/llm_integration/adapters/litellm_adapter.py b/src/rada/llm_integration/adapters/litellm_adapter.py
index f9637ea..943ffb2 100644
--- a/src/rada/llm_integration/adapters/litellm_adapter.py
+++ b/src/rada/llm_integration/adapters/litellm_adapter.py
@@ -40,7 +40,11 @@ async def complete(self, prompt: str, model_id: str, **kwargs: Any) -> Completio
         )
         started = time.perf_counter()
         last_error: Exception | None = None
-        for candidate in self._models or [model_id]:
+        candidates: list[str] = []
+        for candidate in [model_id, *(self._models or [])]:
+            if candidate not in candidates:
+                candidates.append(candidate)
+        for candidate in candidates:
             try:
                 response = await litellm.acompletion(
                     model=candidate,
diff --git a/src/rada/llm_integration/context.py b/src/rada/llm_integration/context.py
index 578c20a..0f3f2d8 100644
--- a/src/rada/llm_integration/context.py
+++ b/src/rada/llm_integration/context.py
@@ -211,26 +211,54 @@ def assemble(self, segments: list[ContextSegment]) -> AssembledContext:
             )
 
         order = {seg.name: idx for idx, seg in enumerate(segments)}
-        ranked = sorted(segments, key=lambda s: (s.priority, order[s.name]))
+        protected = [seg for seg in segments if seg.protected]
+        unprotected = [seg for seg in segments if not seg.protected]
+        ranked_unprotected = sorted(unprotected, key=lambda s: (s.priority, order[s.name]))
 
         kept: list[tuple[str, str]] = []
         dropped: list[str] = []
         truncated: list[str] = []
         budget = self.max_input_tokens
 
-        for seg in ranked:
+        def _separator_reserve(count: int) -> int:
+            if count <= 1:
+                return 0
+            return estimate_tokens("\n\n" * (count - 1), model_id=self.model_id)
+
+        for seg in protected:
+            tokens = estimate_tokens(seg.content, model_id=self.model_id)
+            reserve = _separator_reserve(len(kept) + 1)
+            if tokens + reserve > budget:
+                trimmed = _truncate_to_tokens(
+                    seg.content,
+                    max(1, budget - reserve),
+                    model_id=self.model_id,
+                )
+                if trimmed:
+                    kept.append((seg.name, trimmed))
+                    truncated.append(seg.name)
+                    budget -= estimate_tokens(trimmed, model_id=self.model_id) + reserve
+                else:
+                    dropped.append(seg.name)
+                continue
+            kept.append((seg.name, seg.content))
+            budget -= tokens + reserve
+
+        for seg in ranked_unprotected:
             tokens = estimate_tokens(seg.content, model_id=self.model_id)
-            if tokens <= budget:
+            reserve = _separator_reserve(len(kept) + 1)
+            if tokens + reserve <= budget:
                 kept.append((seg.name, seg.content))
-                budget -= tokens
+                budget -= tokens + reserve
                 continue
 
-            if budget > 0:
-                trimmed = _truncate_to_tokens(seg.content, budget, model_id=self.model_id)
+            remaining = budget - reserve
+            if remaining > 0:
+                trimmed = _truncate_to_tokens(seg.content, remaining, model_id=self.model_id)
                 if trimmed:
                     kept.append((seg.name, trimmed))
                     truncated.append(seg.name)
-                    budget -= estimate_tokens(trimmed, model_id=self.model_id)
+                    budget -= estimate_tokens(trimmed, model_id=self.model_id) + reserve
                     continue
 
             dropped.append(seg.name)
diff --git a/src/rada/main.py b/src/rada/main.py
index 026ce20..6c63634 100644
--- a/src/rada/main.py
+++ b/src/rada/main.py
@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import logging
 import os
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 
-from fastapi import FastAPI, Request, Response
+from fastapi import Depends, FastAPI, Request, Response
+
+logger = logging.getLogger(__name__)
 
 from rada.audit.api import router as audit_router
 from rada.audit.store import AuditStore
@@ -18,6 +21,7 @@
     NoOpReasoner,
     PassThroughRiskOptimizer,
 )
+from rada.core.search_loop import SearchLoop
 from rada.feedback.auto_flag import build_flag_feedback, should_auto_flag
 from rada.core.reasoner_loop import ReasonerLoop
 from rada.core.reflection_loop import ReflectionLoop
@@ -30,6 +34,7 @@
 from rada.interfaces import BaseDataStore
 from rada.observability.metrics import get_metrics
 from rada.schemas import Decision, MarketEvent
+from rada.security.auth import require_api_key
 from rada.utils.metrics import (
     get_metrics_snapshot,
     record_decision_processed,
@@ -41,7 +46,7 @@
 class RuntimeSettings:
     event_bus_mode: str = os.getenv("RADA_EVENT_BUS_MODE", "inmemory")
     data_store_mode: str = os.getenv("RADA_DATA_STORE_MODE", "sqlite")
-    database_url: str = os.getenv("RADA_DATABASE_URL", "postgresql://rada:rada@localhost:5432/rada")
+    database_url: str = os.getenv("RADA_DATABASE_URL", "")
     sqlite_url: str = os.getenv("RADA_SQLITE_URL", "sqlite:///./rada.db")
     audit_db_path: str = os.getenv("RADA_AUDIT_DB_PATH", "./rada_audit.db")
     feedback_db_path: str = os.getenv("RADA_FEEDBACK_DB_PATH", "./rada_feedback.db")
@@ -57,6 +62,8 @@ def build_data_store(settings: RuntimeSettings) -> BaseDataStore:
     if mode == "sqlite":
         return SQLiteDecisionStore(settings.sqlite_url)
     if mode == "timescale":
+        if not settings.database_url:
+            raise ValueError("RADA_DATABASE_URL is required when RADA_DATA_STORE_MODE=timescale")
         return TimescaleDecisionStore(settings.database_url)
 
     raise ValueError(f"Unsupported RADA_DATA_STORE_MODE={settings.data_store_mode!r}")
@@ -66,6 +73,8 @@ def build_reasoner(settings: RuntimeSettings):
     mode = settings.reasoner_mode.lower().strip()
     if mode in {"mock", "scenario"}:
         return ScenarioReasoner()
+    if mode not in {"", "noop"}:
+        logger.warning("Unknown RADA_REASONER_MODE=%r, using NoOpReasoner", mode)
     return NoOpReasoner()
 
 
@@ -88,12 +97,15 @@ def build_decision_loop(
 ) -> DecisionLoop:
     settings = settings or RuntimeSettings()
     reasoner = build_reasoner(settings)
+    risk_optimizer = PassThroughRiskOptimizer()
+    search_loop = SearchLoop(risk_optimizer=risk_optimizer)
     return DecisionLoop(
         reasoner=reasoner,
         policy=HoldPolicy(),
-        risk_optimizer=PassThroughRiskOptimizer(),
+        risk_optimizer=risk_optimizer,
         data_store=store,
         reasoner_loop=ReasonerLoop(reasoner),
+        search_loop=search_loop,
         audit_writer=audit_writer,
     )
 
@@ -112,9 +124,14 @@ async def run_bootstrap_once(
     async for event in synthetic_market_events(count=event_count):
         await event_bus.enqueue(event)
 
-    first_event = await event_bus.dequeue()
-    decision = await loop.process_one(first_event)
-    record_decision_processed()
+    decision: Decision | None = None
+    for _ in range(event_count):
+        event = await event_bus.dequeue()
+        decision = await loop.process_one(event)
+        record_decision_processed()
+    if decision is None:
+        msg = "bootstrap produced no decisions"
+        raise RuntimeError(msg)
     return decision
 
 
@@ -127,9 +144,14 @@ async def run_bootstrap_once_inmemory(event_count: int = 1) -> Decision:
     async for event in synthetic_market_events(count=event_count):
         await event_bus.enqueue(event)
 
-    first_event = await event_bus.dequeue()
-    decision = await loop.process_one(first_event)
-    record_decision_processed()
+    decision: Decision | None = None
+    for _ in range(event_count):
+        event = await event_bus.dequeue()
+        decision = await loop.process_one(event)
+        record_decision_processed()
+    if decision is None:
+        msg = "bootstrap produced no decisions"
+        raise RuntimeError(msg)
     return decision
 
 
@@ -193,7 +215,7 @@ async def metrics_json() -> dict[str, object]:
     return {"legacy": get_metrics_snapshot(), "observability": get_metrics().snapshot()}
 
 
-@app.post("/ingest", tags=["demo"])
+@app.post("/ingest", tags=["demo"], dependencies=[Depends(require_api_key)])
 async def ingest_event(event: MarketEvent, request: Request) -> dict[str, str]:
     """Ingest one market event through the decision pipeline."""
     loop: DecisionLoop = request.app.state.decision_loop
diff --git a/src/rada/policies/registry.py b/src/rada/policies/registry.py
index 06f8e06..1f92e53 100644
--- a/src/rada/policies/registry.py
+++ b/src/rada/policies/registry.py
@@ -23,10 +23,18 @@ class PolicyProfile(BaseModel):
 
 
 def load_profile(name: str) -> PolicyProfile:
-    path = _PROFILES_DIR / f"{name}.yaml"
+    from rada.security.validation import SAFE_ID_PATTERN
+
+    if not SAFE_ID_PATTERN.fullmatch(name):
+        raise ValueError(f"invalid policy profile name: {name}")
+    path = (_PROFILES_DIR / f"{name}.yaml").resolve()
+    if _PROFILES_DIR.resolve() not in path.parents:
+        raise ValueError(f"invalid policy profile path: {name}")
     if not path.exists():
         raise FileNotFoundError(f"policy profile not found: {name}")
     data = yaml.safe_load(path.read_text(encoding="utf-8"))
+    if data is None:
+        raise ValueError(f"policy profile is empty: {name}")
     return PolicyProfile.model_validate(data)
 
 
@@ -46,6 +54,11 @@ async def propose(self, event: MarketEvent, trace: DecisionTrace) -> ProposedAct
         cvar = action.cvar_impact if action.cvar_impact is not None else 0.0
         if cvar > self._profile.cvar_max:
             return ProposedAction(direction=ActionDirection.HOLD, size=0.0, cvar_impact=cvar)
+        drawdown = trace.synthetic_context.get("drawdown")
+        if drawdown is None:
+            drawdown = trace.verified_context.get("drawdown")
+        if drawdown is not None and drawdown > self._profile.drawdown_max:
+            return ProposedAction(direction=ActionDirection.HOLD, size=0.0, cvar_impact=cvar)
         scaled_size = action.size * self._profile.size_scaling
         if scaled_size <= 0 and action.direction != ActionDirection.HOLD:
             return ProposedAction(direction=ActionDirection.HOLD, size=0.0, cvar_impact=cvar)
diff --git a/src/rada/schemas.py b/src/rada/schemas.py
index 6a760ed..fb9926a 100644
--- a/src/rada/schemas.py
+++ b/src/rada/schemas.py
@@ -49,6 +49,7 @@ class DecisionTrace(BaseModel):
     faithfulness_score: float | None = None
     calc_results: list[dict[str, Any]] = Field(default_factory=list)
     verified_context: dict[str, float] = Field(default_factory=dict)
+    synthetic_context: dict[str, float] = Field(default_factory=dict)
 
 
 class ProposedAction(BaseModel):
diff --git a/src/rada/search/constants.py b/src/rada/search/constants.py
new file mode 100644
index 0000000..56ba5ae
--- /dev/null
+++ b/src/rada/search/constants.py
@@ -0,0 +1,3 @@
+"""Shared constants for search and risk sizing stubs."""
+
+DEFAULT_CAPITAL_NOTIONAL = 1_000_000.0
diff --git a/src/rada/search/game_theory.py b/src/rada/search/game_theory.py
index 7506d78..aa3dc70 100644
--- a/src/rada/search/game_theory.py
+++ b/src/rada/search/game_theory.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from rada.schemas import MarketEvent
+from rada.search.constants import DEFAULT_CAPITAL_NOTIONAL
 
 
 def _signal_strength(market_hits: list[dict[str, str]]) -> float:
@@ -57,7 +58,7 @@ def nash_spread_search_stub(
     else:
         direction = "HOLD"
 
-    size = max(reference_price / 100000.0, 0.0)
+    size = max(reference_price / DEFAULT_CAPITAL_NOTIONAL, 0.0)
 
     return {
         "symbol": symbol,
diff --git a/src/rada/search/mcts.py b/src/rada/search/mcts.py
index 4b91e97..3a713cf 100644
--- a/src/rada/search/mcts.py
+++ b/src/rada/search/mcts.py
@@ -8,13 +8,13 @@
 
 from rada.interfaces import BaseRiskOptimizer
 from rada.schemas import ActionDirection, DecisionTrace, MarketEvent, ProposedAction
+from rada.search.constants import DEFAULT_CAPITAL_NOTIONAL
 
 
 @dataclass(slots=True)
 class MCTSConfig:
     iterations: int = 64
     rollout_depth: int = 3
-    exploration: float = 1.414
 
 
 class TrinityPolicyStub:
@@ -119,7 +119,7 @@ def _rollout_reward(event: MarketEvent, action: ProposedAction, *, depth: int) -
     }[action.direction]
     size = action.risk_adjusted_size if action.risk_adjusted_size is not None else action.size
     scale = max(depth, 1)
-    return direction_multiplier * size * event.price / (100000.0 * scale)
+    return direction_multiplier * size * event.price / (DEFAULT_CAPITAL_NOTIONAL * scale)
 
 
 async def run_mcts_benchmark_fixture(
diff --git a/src/rada/search/risk_selection.py b/src/rada/search/risk_selection.py
index 5f89eda..50732c3 100644
--- a/src/rada/search/risk_selection.py
+++ b/src/rada/search/risk_selection.py
@@ -7,20 +7,28 @@
 from rada.schemas import ActionDirection, ProposedAction
 
 
+from rada.search.constants import DEFAULT_CAPITAL_NOTIONAL
+
+
 @dataclass(slots=True)
 class TailWarpStub:
-    """Mock TailWarp adapter returning deterministic tail-loss estimates."""
+    """Mock TailWarp adapter returning tail-loss as a fraction of capital."""
 
     cvar_limit: float = 0.05
+    capital: float = DEFAULT_CAPITAL_NOTIONAL
 
     def estimate_tail_loss(self, action: ProposedAction, *, price: float) -> float:
+        """Return estimated tail loss as a fraction of capital (comparable to CVaR fractions)."""
+        if price <= 0:
+            return 0.0
         size = action.risk_adjusted_size if action.risk_adjusted_size is not None else action.size
         direction_scale = {
             ActionDirection.BUY: 1.0,
             ActionDirection.SELL: 1.2,
             ActionDirection.HOLD: 0.0,
         }[action.direction]
-        return direction_scale * size * price / 1_000_000.0
+        notional = direction_scale * size * price
+        return notional / self.capital
 
 
 def select_cvar_feasible_action(
diff --git a/src/rada/security/__init__.py b/src/rada/security/__init__.py
new file mode 100644
index 0000000..1a76903
--- /dev/null
+++ b/src/rada/security/__init__.py
@@ -0,0 +1,6 @@
+"""Security helpers for API authentication and input validation."""
+
+from rada.security.auth import require_api_key
+from rada.security.validation import SAFE_ID_PATTERN, validate_safe_id
+
+__all__ = ["SAFE_ID_PATTERN", "require_api_key", "validate_safe_id"]
diff --git a/src/rada/security/auth.py b/src/rada/security/auth.py
new file mode 100644
index 0000000..a038e15
--- /dev/null
+++ b/src/rada/security/auth.py
@@ -0,0 +1,32 @@
+"""API key authentication dependency."""
+
+from __future__ import annotations
+
+import os
+
+from fastapi import Header, HTTPException, status
+
+
+def _api_key_required() -> bool:
+    env = os.getenv("RADA_ENV", "dev").lower().strip()
+    if env in {"dev", "development", "test"}:
+        configured = os.getenv("RADA_API_KEY", "").strip()
+        return bool(configured)
+    return True
+
+
+def require_api_key(x_api_key: str | None = Header(default=None, alias="X-API-Key")) -> None:
+    """Validate X-API-Key when required by environment."""
+    expected = os.getenv("RADA_API_KEY", "").strip()
+    if not _api_key_required():
+        return
+    if not expected:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="RADA_API_KEY is not configured",
+        )
+    if x_api_key != expected:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or missing API key",
+        )
diff --git a/src/rada/security/validation.py b/src/rada/security/validation.py
new file mode 100644
index 0000000..0db157a
--- /dev/null
+++ b/src/rada/security/validation.py
@@ -0,0 +1,25 @@
+"""Shared input validation helpers."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+SAFE_ID_PATTERN = re.compile(r"^[A-Za-z0-9_-]+$")
+
+
+def validate_safe_id(value: str, *, field: str = "id") -> str:
+    if not SAFE_ID_PATTERN.fullmatch(value):
+        msg = f"invalid {field}: must match {SAFE_ID_PATTERN.pattern}"
+        raise ValueError(msg)
+    return value
+
+
+def resolve_within_root(root: Path, *parts: str) -> Path:
+    """Resolve a path and ensure it stays within root."""
+    candidate = (root / Path(*parts)).resolve()
+    root_resolved = root.resolve()
+    if root_resolved not in candidate.parents and candidate != root_resolved:
+        msg = f"path escapes root: {candidate}"
+        raise ValueError(msg)
+    return candidate
diff --git a/src/rada/utils/artifact_manifest.py b/src/rada/utils/artifact_manifest.py
index 6c4e51a..765ba93 100644
--- a/src/rada/utils/artifact_manifest.py
+++ b/src/rada/utils/artifact_manifest.py
@@ -11,11 +11,10 @@
 
 
 def adapter_store_root() -> Path:
-    """Canonical root: RADA_ADAPTER_STORE_ROOT or experiments/adapters."""
-    env = os.environ.get("RADA_ADAPTER_STORE_ROOT")
-    if env:
-        return Path(env).expanduser().resolve()
-    return Path("experiments/adapters").resolve()
+    """Canonical adapter root shared with model resolver."""
+    from rada.models.resolver import get_adapter_root
+
+    return get_adapter_root()
 
 
 def eval_export_root() -> Path:
@@ -37,9 +36,12 @@ class ArtifactManifest:
     extra: dict[str, Any] = field(default_factory=dict)
 
     def write(self, root: Path | None = None) -> Path:
+        from rada.security.validation import resolve_within_root, validate_safe_id
+
+        validate_safe_id(self.run_id, field="run_id")
         root = root or adapter_store_root()
         root.mkdir(parents=True, exist_ok=True)
-        out = root / self.run_id / "manifest.json"
+        out = resolve_within_root(root, self.run_id, "manifest.json")
         out.parent.mkdir(parents=True, exist_ok=True)
         out.write_text(json.dumps(asdict(self), indent=2), encoding="utf-8")
         return out
diff --git a/storage/ftp_sync.py b/storage/ftp_sync.py
index dd130a0..14f2acf 100644
--- a/storage/ftp_sync.py
+++ b/storage/ftp_sync.py
@@ -31,6 +31,8 @@ def _remote_date_prefix(remote_root: str, repo: str) -> str:
 
 
 def _ensure_ftp_dirs(ftp: ftplib.FTP, remote_path: str) -> None:
+    """Create remote directories from FTP root using absolute paths."""
+    ftp.cwd("/")
     parts = [p for p in remote_path.split("/") if p]
     current = ""
     for part in parts:
@@ -50,6 +52,7 @@ def _remote_file_size(ftp: ftplib.FTP, remote_file: str) -> int | None:
 
 
 def _upload_file_ftp(ftp: ftplib.FTP, local: Path, remote_file: str) -> bool:
+    ftp.cwd("/")
     remote_size = _remote_file_size(ftp, remote_file)
     local_size = local.stat().st_size
     if remote_size is not None and remote_size == local_size:
diff --git a/storage/sync_daemon.sh b/storage/sync_daemon.sh
index ed40cf5..7370038 100644
--- a/storage/sync_daemon.sh
+++ b/storage/sync_daemon.sh
@@ -11,6 +11,8 @@ cd "${REPO_ROOT}"
 
 while true; do
   echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] checking disk usage (threshold=${THRESHOLD}%)"
-  python "${SCRIPT_DIR}/ftp_sync.py" --check-threshold "${THRESHOLD}" --local-root "${REPO_ROOT}" || true
+  if ! python "${SCRIPT_DIR}/ftp_sync.py" --check-threshold "${THRESHOLD}" --local-root "${REPO_ROOT}"; then
+    echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] ftp sync failed (exit $?)" >&2
+  fi
   sleep "${INTERVAL}"
 done
diff --git a/tests/integration/test_api_auth.py b/tests/integration/test_api_auth.py
new file mode 100644
index 0000000..cc03eac
--- /dev/null
+++ b/tests/integration/test_api_auth.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from rada.audit.store import AuditStore
+from rada.feedback.store import FeedbackStore
+from rada.main import app
+
+
+@pytest.mark.integration
+def test_audit_requires_api_key_in_production(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    monkeypatch.setenv("RADA_ENV", "production")
+    monkeypatch.setenv("RADA_API_KEY", "secret-key")
+    store = AuditStore(db_path=str(tmp_path / "audit.db"))
+    app.state.audit_store = store
+    client = TestClient(app)
+
+    denied = client.get("/audit/export")
+    assert denied.status_code == 401
+
+    allowed = client.get("/audit/export", headers={"X-API-Key": "secret-key"})
+    assert allowed.status_code == 200
+
+
+@pytest.mark.integration
+def test_feedback_submit_requires_api_key_in_production(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    monkeypatch.setenv("RADA_ENV", "production")
+    monkeypatch.setenv("RADA_API_KEY", "secret-key")
+    app.state.feedback_store = FeedbackStore(db_path=str(tmp_path / "fb.db"))
+    client = TestClient(app)
+
+    payload = {
+        "decision_id": "dec-auth",
+        "action": "FLAG",
+        "note": "test",
+        "reviewer": "tester",
+    }
+    denied = client.post("/feedback/submit", json=payload)
+    assert denied.status_code == 401
+
+    allowed = client.post(
+        "/feedback/submit",
+        json=payload,
+        headers={"X-API-Key": "secret-key"},
+    )
+    assert allowed.status_code == 200
diff --git a/tests/integration/test_feedback_api.py b/tests/integration/test_feedback_api.py
index fbb0def..d6a4019 100644
--- a/tests/integration/test_feedback_api.py
+++ b/tests/integration/test_feedback_api.py
@@ -3,7 +3,6 @@
 import pytest
 from fastapi.testclient import TestClient
 
-from rada.feedback.schemas import FeedbackAction, HumanFeedback
 from rada.feedback.store import FeedbackStore
 from rada.main import app
 
@@ -14,12 +13,13 @@ def test_feedback_submit_and_pending(tmp_path) -> None:
     app.state.feedback_store = store
     client = TestClient(app)
 
-    payload = HumanFeedback(
-        decision_id="dec-100",
-        action=FeedbackAction.FLAG,
-        note="CVaR breach review",
-    )
-    resp = client.post("/feedback/submit", json=payload.model_dump(mode="json"))
+    payload = {
+        "decision_id": "dec-100",
+        "action": "FLAG",
+        "note": "CVaR breach review",
+        "reviewer": "tester",
+    }
+    resp = client.post("/feedback/submit", json=payload)
     assert resp.status_code == 200
 
     pending = client.get("/feedback/pending")
diff --git a/tests/integration/test_search_decision_integration.py b/tests/integration/test_search_decision_integration.py
index 577204b..947c0e5 100644
--- a/tests/integration/test_search_decision_integration.py
+++ b/tests/integration/test_search_decision_integration.py
@@ -51,8 +51,5 @@ async def test_decision_loop_with_search_enabled_may_change_action() -> None:
         timestamp=datetime(2026, 6, 1, tzinfo=UTC),
     )
     decision = await loop.process_one(event)
-    assert decision.proposed_action.direction in {
-        ActionDirection.BUY,
-        ActionDirection.SELL,
-        ActionDirection.HOLD,
-    }
+    assert isinstance(decision.trace.synthetic_context, dict)
+    assert decision.trace.synthetic_context.get("position_size", 0) > 0
diff --git a/tests/unit/test_bus.py b/tests/unit/test_bus.py
index 80f1c08..0a6ed80 100644
--- a/tests/unit/test_bus.py
+++ b/tests/unit/test_bus.py
@@ -3,6 +3,7 @@
 import pytest
 
 from rada.data.bus import InMemoryEventBus, build_event_bus
+from rada.schemas import MarketEvent
 
 
 @pytest.mark.unit
diff --git a/tests/unit/test_data_query.py b/tests/unit/test_data_query.py
new file mode 100644
index 0000000..57f685a
--- /dev/null
+++ b/tests/unit/test_data_query.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import pytest
+
+from rada.data.query import filter_decisions
+from rada.schemas import ActionDirection, Decision, DecisionTrace, MarketEvent, ProposedAction
+
+
+def _decision(
+    *,
+    decision_id: str,
+    policy_id: str = "balanced",
+    ts: datetime,
+) -> Decision:
+    event = MarketEvent(
+        symbol="BTCUSD",
+        price=100.0,
+        volume=1.0,
+        timestamp=ts,
+    )
+    return Decision(
+        decision_id=decision_id,
+        policy_id=policy_id,
+        timestamp=ts,
+        market_event=event,
+        proposed_action=ProposedAction(direction=ActionDirection.HOLD, size=0),
+        trace=DecisionTrace(),
+    )
+
+
+@pytest.mark.unit
+def test_filter_decisions_since_limit_and_policy() -> None:
+    t1 = datetime(2026, 6, 1, tzinfo=UTC)
+    t2 = datetime(2026, 6, 2, tzinfo=UTC)
+    decisions = [
+        _decision(decision_id="a", policy_id="balanced", ts=t1),
+        _decision(decision_id="b", policy_id="aggressive", ts=t2),
+        _decision(decision_id="c", policy_id="balanced", ts=t2),
+    ]
+    filtered = filter_decisions(
+        decisions,
+        since=datetime(2026, 6, 2, tzinfo=UTC),
+        limit=1,
+        policy_ids=["balanced"],
+    )
+    assert len(filtered) == 1
+    assert filtered[0].decision_id == "c"
diff --git a/tests/unit/test_feedback_export_cards.py b/tests/unit/test_feedback_export_cards.py
index 97f1e8b..3f4c225 100644
--- a/tests/unit/test_feedback_export_cards.py
+++ b/tests/unit/test_feedback_export_cards.py
@@ -6,7 +6,9 @@
 import pytest
 
 from rada.core.decision_loop import DecisionLoop, HoldPolicy, NoOpReasoner, PassThroughRiskOptimizer
-from rada.data.cards import DecisionExportRow, FeedbackRecord
+from pydantic import ValidationError
+
+from rada.data.cards import DecisionExportRow, FeedbackLabels, FeedbackRecord
 from rada.data.storage import InMemoryDecisionStore
 from rada.schemas import MarketEvent
 
@@ -55,3 +57,9 @@ async def test_feedback_record_validates_score_bounds() -> None:
     record = FeedbackRecord.from_decision_stub(decision, score=0.75)
     assert record.labels.score == 0.75
     json.loads(record.model_dump_json())
+
+
+@pytest.mark.unit
+def test_feedback_labels_reject_invalid_score() -> None:
+    with pytest.raises(ValidationError):
+        FeedbackLabels(score=1.5)
diff --git a/tests/unit/test_http_adapter.py b/tests/unit/test_http_adapter.py
new file mode 100644
index 0000000..0d1e6d2
--- /dev/null
+++ b/tests/unit/test_http_adapter.py
@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import httpx
+import pytest
+
+from rada.llm_integration.adapters._http_base import OpenAICompatibleAdapter
+from rada.llm_integration.config import LLMConfig
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_http_adapter_retries_transient_error() -> None:
+    config = LLMConfig(provider="custom", model_id="test-model", base_url="http://localhost:9000")
+    adapter = OpenAICompatibleAdapter(config, backend_id="test", default_base_url="http://localhost:9000")
+
+    response_ok = httpx.Response(
+        200,
+        json={
+            "choices": [{"message": {"content": "ok"}}],
+            "usage": {"prompt_tokens": 1, "completion_tokens": 1},
+        },
+        request=httpx.Request("POST", "http://localhost:9000/v1/chat/completions"),
+    )
+    response_fail = httpx.Response(
+        503,
+        request=httpx.Request("POST", "http://localhost:9000/v1/chat/completions"),
+    )
+
+    mock_client = AsyncMock()
+    mock_client.is_closed = False
+    mock_client.post = AsyncMock(side_effect=[response_fail, response_ok])
+
+    with patch.object(adapter, "_get_client", return_value=mock_client):
+        completion = await adapter.complete("hello", "test-model")
+
+    assert completion.text == "ok"
+    assert mock_client.post.await_count == 2
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_http_adapter_rejects_empty_choices() -> None:
+    config = LLMConfig(provider="custom", model_id="test-model", base_url="http://localhost:9000")
+    adapter = OpenAICompatibleAdapter(config, backend_id="test", default_base_url="http://localhost:9000")
+
+    response_ok = httpx.Response(
+        200,
+        json={"choices": []},
+        request=httpx.Request("POST", "http://localhost:9000/v1/chat/completions"),
+    )
+    mock_client = AsyncMock()
+    mock_client.is_closed = False
+    mock_client.post = AsyncMock(return_value=response_ok)
+
+    with patch.object(adapter, "_get_client", return_value=mock_client):
+        with pytest.raises(ValueError, match="missing choices"):
+            await adapter.complete("hello", "test-model")
diff --git a/tests/unit/test_model_registry.py b/tests/unit/test_model_registry.py
index 74ed55d..f05bb3d 100644
--- a/tests/unit/test_model_registry.py
+++ b/tests/unit/test_model_registry.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import json
-import os
 from pathlib import Path
 
 import pytest
@@ -75,8 +74,7 @@ def test_default_registry_lists_seven_models() -> None:
     assert "qwen3-0.6b" in registry.list_model_ids()
 
 
-def test_env_expansion_in_defaults(monkeypatch: pytest.MonkeyPatch, registry_path: Path) -> None:
+def test_env_expansion_in_defaults(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setenv("RADA_MODEL_CACHE_ROOT", "/custom/cache")
     registry = load_model_registry()
-    # default registry uses env expansion on load
-    assert registry.defaults.cache_root or os.environ.get("RADA_MODEL_CACHE_ROOT")
+    assert registry.defaults.cache_root == "/custom/cache"
diff --git a/tests/unit/test_smoke.py b/tests/unit/test_smoke.py
index 6027469..388b0dc 100644
--- a/tests/unit/test_smoke.py
+++ b/tests/unit/test_smoke.py
@@ -1,6 +1,47 @@
+"""Import smoke tests for core package modules."""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+
 import pytest
 
+import rada
+
+
+@pytest.mark.unit
+def test_rada_package_imports() -> None:
+    assert rada.__name__ == "rada"
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    "module_name",
+    [
+        "rada.main",
+        "rada.schemas",
+        "rada.core.decision_loop",
+        "rada.core.reflection_loop",
+        "rada.core.search_loop",
+        "rada.calc.engine",
+        "rada.audit.api",
+        "rada.feedback.api",
+        "rada.models.registry",
+        "rada.models.resolver",
+        "rada.llm_integration.factory",
+        "rada.training.config",
+    ],
+)
+def test_import_core_modules(module_name: str) -> None:
+    importlib.import_module(module_name)
+
 
 @pytest.mark.unit
-def test_smoke() -> None:
-    assert True
+def test_import_all_rada_submodules() -> None:
+    """Every discoverable rada submodule should import without error."""
+    prefix = f"{rada.__name__}."
+    for module_info in pkgutil.walk_packages(rada.__path__, prefix):
+        if module_info.name.endswith(".adapters._http_base"):
+            continue
+        importlib.import_module(module_info.name)
diff --git a/tests/unit/test_utils_metrics.py b/tests/unit/test_utils_metrics.py
new file mode 100644
index 0000000..3d2f667
--- /dev/null
+++ b/tests/unit/test_utils_metrics.py
@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import pytest
+
+from rada.utils import metrics as legacy_metrics
+
+
+@pytest.mark.unit
+def test_legacy_metrics_increment_and_render() -> None:
+    legacy_metrics.increment_counter("rada_decisions_processed_total", 2)
+    snapshot = legacy_metrics.get_metrics_snapshot()
+    assert snapshot["decisions_processed"] >= 2
+    rendered = legacy_metrics.render_prometheus_text()
+    assert "rada_decisions_processed_total" in rendered