diff --git a/README.md b/README.md
index 2aabc1f..59f0a39 100644
--- a/README.md
+++ b/README.md
@@ -104,6 +104,77 @@ Inspect the agent's layered orientation and pending re-entries anytime with the
 
 ---
 
+## Real-Time Signal Processing
+
+LeapFlow continuously observes the operating environment through a unified signal pipeline — signals are never dropped, noise never reaches the agent, and resources are never wasted on redundant data.
+
+### End-to-End Pipeline
+
+```
+Signal Sources ─────────────────────────────────────────────────────────────
+  app_focus │ clipboard │ fs_watcher │ input_tap │ gateway │ perception
+       │          │           │           │          │          │
+       ▼──────────▼───────────▼───────────▼──────────▼──────────▼
+EventBus ─────────────────────────────────────────────────────────────────
+  normalize → privacy gate → dedup (2s) → memory ingest → subscriber fan-out
+       │                                              │
+       ▼                                              ▼
+  EventReorderBuffer (50ms settle, monotonic sort)    Monitor / Scheduler
+       │                                              │
+       ▼                                              ▼
+CausalFusionPipeline (<10ms SLA)                   EventTrigger → Finding
+  denoise → chain_build → infer → hotspots            │
+       │                                              ▼
+       ▼                                         NotificationBus → LeapBoard
+CausalGraph (ring_limit=100)
+       │
+       ▼
+Learning (Progressive Trust: DRAFT → CANDIDATE → VERIFIED → PRODUCTION)
+```
+
+### Signal Sources
+
+| Source | Transport | Rate / Throttle | Module |
+|--------|-----------|-----------------|--------|
+| `app_focus` | 0.5s polling | — | `platform/observers/` |
+| `clipboard` | 1.0s polling | — | `platform/observers/` |
+| `fs_watcher` | watchdog push | — | `platform/observers/` |
+| `input_tap` | CGEventTap / pynput | 50ms throttle | `platform/observers/` |
+| `gateway` | NDJSON / webhook / long-poll | per-platform | `gateway/` |
+| `perception` | information-gain gated | max 5 fps | `perception/` |
+
+### Core Mechanisms
+
+- **EventBus** (`platform/event_bus.py`) — single entry point for all signals. Applies normalization, a privacy gate (redaction before downstream), deduplication within a 2-second sliding window, and routes to subscribers in batch.
+- **EventReorderBuffer** — optional 50ms settling window that re-sorts out-of-order events by monotonic timestamp before processing, critical for fusing cross-channel signals.
+- **CausalFusionPipeline** (`causal/`) — T1 tier with <10ms SLA; constructs causal chains from temporally adjacent events, infers reliability, and maintains a ring-buffered `CausalGraph` (100 nodes max).
+- **Monitor / EventBridge** (`monitor/`) — pattern-matched subscribers (fnmatch globs) with 1s debounce; triggers wake the Scheduler (<2s), which drives Producers to emit scored Findings onto the NotificationBus.
+
+### LeapBoard Observation
+
+The `/board` web dashboard exposes real-time signal health:
+
+- **Signal Health** — subscriber count, active triggers, watches, drops, debounced events
+- **Live Signal Stream** — last 50 raw events, rolling
+- **Watch Portfolio** — active event-driven watches and their trigger state
+- **Recent Findings** — latest scored observations from Producers
+
+### Testing Signals Locally
+
+```bash
+# Emit mock signals for development / integration tests
+uv run pytest tests/mock_signals/ -q
+
+# Inject a synthetic event into the running EventBus
+from leapflow.platform.event_bus import EventBus
+bus = EventBus()
+bus.handle_event("clipboard_change", {"content": "test", "app": "Terminal"})
+```
+
+See `tests/mock_signals/` for ready-made fixtures covering all six source types.
+
+---
+
 ## Built-in Coding Tools
 
 LeapFlow ships a first-class coding toolset so the agent can *locate → read → edit → verify* code precisely instead of rewriting whole files or shelling out blindly. Every tool is registered with governance metadata (`x_leapflow`) so it flows through the existing idempotency, approval, redaction, path-sensitivity, and audit paths.
diff --git a/src/leapflow/cache/manager.py b/src/leapflow/cache/manager.py
index 29c3549..aa65306 100644
--- a/src/leapflow/cache/manager.py
+++ b/src/leapflow/cache/manager.py
@@ -3,6 +3,7 @@
 
 import hashlib
 import json
+import threading
 import time
 from dataclasses import dataclass, field
 from enum import Enum
@@ -51,6 +52,7 @@ class CacheManager:
     def __init__(self, layout: CacheLayout, *, profile_id: str) -> None:
         self._layout = layout
         self._profile_id = profile_id
+        self._connect_lock = threading.Lock()
         self._layout.ensure()
         self._init_schema()
 
@@ -322,7 +324,9 @@ def _build_entry(
         )
 
     def _connect(self):
-        return duckdb.connect(str(self._layout.index_path))
+        """Create a DuckDB connection, serialized to protect against concurrent writes."""
+        with self._connect_lock:
+            return duckdb.connect(str(self._layout.index_path))
 
     def _is_managed_path(self, path: Path) -> bool:
         try:
diff --git a/src/leapflow/causal/pipeline.py b/src/leapflow/causal/pipeline.py
index bba0bc5..6064d07 100644
--- a/src/leapflow/causal/pipeline.py
+++ b/src/leapflow/causal/pipeline.py
@@ -57,6 +57,17 @@ class ReorderBuffer:
     Holds events for up to `window_s` seconds before releasing them in
     timestamp order. This handles platform-level delivery jitter (e.g.,
     app_switch arriving 200ms after the keyboard shortcut that caused it).
+
+    Timebase note:
+        This buffer sorts by ``CausalEvent.timestamp`` (wall-clock, ``time.time()``
+        origin) because causal events are domain objects that may be serialized,
+        persisted, and correlated across sessions — monotonic clocks are not
+        comparable across processes or restarts.
+
+        In contrast, :class:`~leapflow.platform.reorder_buffer.EventReorderBuffer`
+        sorts by ``payload["_mono_ts"]`` (``time.monotonic()``) because it operates
+        within a single process lifetime on raw observer events where monotonic
+        ordering is both available and more reliable than wall-clock.
     """
 
     __slots__ = ("_window_s", "_buffer")
diff --git a/src/leapflow/cli/commands/daemon.py b/src/leapflow/cli/commands/daemon.py
index c1d9bbb..4b7fd32 100644
--- a/src/leapflow/cli/commands/daemon.py
+++ b/src/leapflow/cli/commands/daemon.py
@@ -163,6 +163,12 @@ def _print_runtime_status(status: dict) -> None:
             print(f"host_capability: {host['capability_version']}")
         if host.get("last_error"):
             print(f"host_error: {host['last_error']}")
+    build = status.get("build")
+    if isinstance(build, dict) and build.get("commit"):
+        stale = build.get("stale")
+        stale_text = "UNKNOWN" if stale is None else ("STALE — restart with 'leap daemon restart'" if stale else "fresh")
+        dirty = " (dirty)" if build.get("dirty_digest") else ""
+        print(f"build: commit={build['commit']}{dirty} pid={build.get('pid')} status={stale_text}")
 
 
 def _start(settings: object, mock_host: bool) -> int:
diff --git a/src/leapflow/cli/commands/interactive.py b/src/leapflow/cli/commands/interactive.py
index 63da6d8..cb68dac 100644
--- a/src/leapflow/cli/commands/interactive.py
+++ b/src/leapflow/cli/commands/interactive.py
@@ -1573,6 +1573,9 @@ async def _refresh_watch_count() -> None:
                         app.invalidate()
                     elif event_type == "watch.state":
                         await _refresh_watch_count()
+                    elif event_type == "signal.stream":
+                        # Track signal flow activity for health visibility
+                        status.increment_signal_stream()
                     elif event_type == "monitor.error":
                         logger.debug("monitor error notification: %s", payload)
             except (DaemonUnavailableError, OSError, asyncio.IncompleteReadError):
diff --git a/src/leapflow/cli/commands/registry.py b/src/leapflow/cli/commands/registry.py
index ca1dcda..f4ffdac 100644
--- a/src/leapflow/cli/commands/registry.py
+++ b/src/leapflow/cli/commands/registry.py
@@ -137,6 +137,7 @@ def supports_runtime(self, runtime: CommandRuntime) -> bool:
     # Board & Monitors (LeapBoard) — one analysis target (current session),
     # rendered through a selectable template lens.
     CommandDef("board", "Analyze the current session; optionally pick a template lens", "Board", args_hint="[<template> | templates|refresh|pause|resume|stop|status]", effect=CommandEffect.SESSION, execution=CommandExecution.SHORT_OPERATION),
+    CommandDef("board signals", "View signal flow health and live event stream", "Board", effect=CommandEffect.READ_ONLY, execution=CommandExecution.SHORT_OPERATION),
     CommandDef("board templates", "List, add, remove, or show board templates", "Board", args_hint="[list|add <path.yaml> [--name id] [--force]|remove <id>|show <id>]", effect=CommandEffect.SESSION, execution=CommandExecution.SHORT_OPERATION),
     CommandDef("board refresh", "Re-analyze the current session (or a watch by id) now", "Board", args_hint="[<id>]", effect=CommandEffect.SESSION, execution=CommandExecution.SHORT_OPERATION),
     CommandDef("board pause", "Pause session analysis (or a watch by id)", "Board", args_hint="[<id>]", effect=CommandEffect.SESSION),
diff --git a/src/leapflow/cli/commands/slash_handlers.py b/src/leapflow/cli/commands/slash_handlers.py
index d0ce849..1e64144 100644
--- a/src/leapflow/cli/commands/slash_handlers.py
+++ b/src/leapflow/cli/commands/slash_handlers.py
@@ -1233,7 +1233,7 @@ async def _execute_dashboard(
     if verb == "templates":
         return _execute_board_templates(ctx, rest_tokens)
     if verb == "status":
-        return _execute_board_status(ctx, monitors)
+        return await _execute_board_status(ctx, monitors)
     if verb in ("refresh", "pause", "resume", "stop"):
         return await _execute_board_control(
             ctx, monitors, verb, target=rest_tokens[0] if rest_tokens else "",
@@ -1356,18 +1356,22 @@ def _find_session_watch_id(monitors: Any) -> str:
     return ""
 
 
-def _execute_board_status(ctx: "Context", monitors: Any) -> dict[str, Any]:
+async def _execute_board_status(ctx: "Context", monitors: Any) -> dict[str, Any]:
     """Return session-observation status: watch detail + recent findings + lenses.
 
     Fields:
       - ``templates`` / ``default``: available lenses and the default.
       - ``watches``: every watch with state, run/finding counts, and last-run age.
       - ``findings``: recent findings (severity, title, summary, age) across watches.
+      - ``signal_flow``: real-time signal health metrics (if available).
+      - ``server``: the *separate* LeapBoard web server process's own build
+        fingerprint and staleness verdict, when one is currently running (see
+        ``_board_server_health``).
     """
     library = _template_library(ctx)
     data: dict[str, Any] = {
         "ok": True, "view": "dashboard", "mode": "status",
-        "templates": library.names(), "default": "generic",
+        "templates": library.visible_names(), "default": "generic",
         "watches": [], "findings": [],
     }
     if monitors is None:
@@ -1380,9 +1384,62 @@ def _execute_board_status(ctx: "Context", monitors: Any) -> dict[str, Any]:
         data["findings"] = [f.to_dict() for f in monitors.list_findings(limit=20)]
     except Exception:
         logger.debug("dashboard: finding list unavailable", exc_info=True)
+
+    # Signal flow health metrics (best-effort, non-blocking)
+    try:
+        from leapflow.monitor.signal_metrics import SignalMetricsCollector
+
+        collector = SignalMetricsCollector()
+        event_bus = getattr(ctx, "event_bus", None)
+        snapshot = collector.collect(
+            event_bus=event_bus,
+            monitor_manager=monitors,
+        )
+        data["signal_flow"] = {
+            "event_subscriber_count": snapshot.event_subscriber_count,
+            "active_trigger_count": snapshot.active_trigger_count,
+            "signal_buffer_dropped": snapshot.signal_buffer_dropped,
+            "signal_noise_suppressed": snapshot.signal_noise_suppressed,
+            "signal_noise_seen": snapshot.signal_noise_seen,
+            "active_watch_count": snapshot.active_watch_count,
+            "recent_findings_count": snapshot.recent_findings_count,
+        }
+    except Exception:
+        logger.debug("dashboard: signal metrics unavailable", exc_info=True)
+
+    data["server"] = await _board_server_health(ctx)
     return data
 
 
+async def _board_server_health(ctx: "Context") -> dict[str, Any] | None:
+    """Best-effort staleness check for the separately running LeapBoard web server.
+
+    The dashboard is a distinct long-lived process from leapd (spawned by
+    ``leap board`` and never restarted automatically); editing dashboard source
+    does not reach it until it is restarted. Returns None when no dashboard
+    server is currently running/discoverable, or the probe fails — this is a
+    diagnostic side-channel, never a reason to fail ``/board status``.
+    """
+    import asyncio
+
+    settings = getattr(ctx, "settings", None)
+    if settings is None:
+        return None
+    try:
+        from leapflow.dashboard import launcher
+
+        state = launcher.load_state(settings)
+        if not state:
+            return None
+        return await asyncio.to_thread(
+            launcher.fetch_server_info,
+            str(state.get("bind") or ""), int(state.get("port") or 0), str(state.get("token") or ""),
+        )
+    except Exception:
+        logger.debug("dashboard: board server health probe failed", exc_info=True)
+        return None
+
+
 def _execute_board_templates(ctx: "Context", rest_tokens: list[str]) -> dict[str, Any]:
     """Template hub: list / add / remove / show board templates."""
     from leapflow.dashboard.templates import sanitize_template_id
@@ -1392,7 +1449,7 @@ def _execute_board_templates(ctx: "Context", rest_tokens: list[str]) -> dict[str
     args = rest_tokens[1:]
 
     if op == "list":
-        items = [library.describe(name) or {"name": name} for name in library.names()]
+        items = [library.describe(name) or {"name": name} for name in library.visible_names()]
         return {"ok": True, "view": "dashboard", "mode": "templates",
                 "templates": items, "default": "generic"}
 
@@ -1899,6 +1956,31 @@ def _board_page_url() -> str:
         return ""
 
 
+def _render_board_server_health(console: "LeapConsole", server: Any) -> None:
+    """Render the LeapBoard web server's own staleness verdict, if known.
+
+    ``server`` is None when no dashboard server is currently running, or the
+    probe failed — both render nothing, since there is nothing actionable to
+    report. A definite ``stale`` verdict is the whole point of this warning:
+    the browser page a developer is looking at right now was built from code
+    that predates the current source tree.
+    """
+    if not isinstance(server, dict):
+        return
+    build = server.get("build") if isinstance(server.get("build"), dict) else {}
+    stale = server.get("stale")
+    if stale is None:
+        return  # unknown (not a git checkout) — nothing to warn about
+    if stale:
+        console.warning(
+            f"LeapBoard web server (pid={build.get('pid')}) predates the current source "
+            "tree — restart it to pick up recent changes: run /board again after killing "
+            f"pid {build.get('pid')}, or 'leap board --serve' manually."
+        )
+    else:
+        console.system(f"LeapBoard web server (pid={build.get('pid')}) is up to date.")
+
+
 def _render_dashboard_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
     from rich.table import Table
 
@@ -1964,6 +2046,7 @@ def _render_dashboard_view(console: "LeapConsole", payload: dict[str, Any]) -> N
                 console.system(line)
         else:
             console.system("Findings: none yet.")
+        _render_board_server_health(console, payload.get("server"))
         return
 
     if mode == "templates":
diff --git a/src/leapflow/cli/tui_app/status.py b/src/leapflow/cli/tui_app/status.py
index 6ca1786..27f0cd0 100644
--- a/src/leapflow/cli/tui_app/status.py
+++ b/src/leapflow/cli/tui_app/status.py
@@ -103,6 +103,7 @@ def __init__(self, theme: Optional[Theme | ResolvedTheme] = None) -> None:
         self.daemon_turn_waiting: int = 0
         self.watch_count: int = 0
         self.alert_count: int = 0
+        self.signal_stream_count: int = 0
         self.last_turn_elapsed: float = 0.0
         self._turn_start: float = 0.0
         self._session_start: float = time.monotonic()
@@ -302,4 +303,8 @@ def update_monitor_counts(
         if watches is not None:
             self.watch_count = max(0, watches)
         if alerts is not None:
-            self.alert_count = max(0, alerts)
\ No newline at end of file
+            self.alert_count = max(0, alerts)
+
+    def increment_signal_stream(self) -> None:
+        """Increment the signal stream event counter (called on each signal.stream push)."""
+        self.signal_stream_count += 1
\ No newline at end of file
diff --git a/src/leapflow/config.py b/src/leapflow/config.py
index 55b1ace..f628427 100644
--- a/src/leapflow/config.py
+++ b/src/leapflow/config.py
@@ -449,6 +449,32 @@ class Settings:
     # signal collection entirely (V0 baseline).
     signal_channels: frozenset = frozenset()
     signal_reactive_capture: bool = False
+    signal_noise_gate_enabled: bool = True
+    signal_noise_same_source_cooldown_s: float = 2.0
+    signal_noise_allow_fs_outside_workspace: bool = False
+    signal_noise_path_fragments: tuple = (
+        "/Library/Caches/",
+        "/Library/Logs/",
+        "/Library/Preferences/",
+        "/Application Support/Qoder/User/globalStorage/",
+        "/Application Support/Qoder/SharedClientCache/",
+        "/Application Support/Qoder/SharedCredentialCache/",
+        "/Application Support/Qoder/Partitions/native-browser/Cache/",
+        "/Application Support/Cursor/User/globalStorage/",
+        "/Application Support/DuetExpertCenter/",
+        "/.cache/",
+        "/.hermes/",
+        "/.r2c/logs/",
+    )
+    signal_noise_dir_names: tuple = (
+        ".git", ".hg", ".svn", ".venv", "__pycache__", ".pytest_cache", ".ruff_cache",
+        "node_modules", "Cache", "Caches", "SharedCredentialCache", "globalStorage",
+        "Code Cache", "GPUCache",
+    )
+    signal_noise_suffixes: tuple = (
+        ".tmp", ".temp", ".swp", ".lock", ".log", ".pyc", ".pyo",
+        "-journal", "-shm", "-wal", ".db-shm", ".db-wal", ".sqlite-journal",
+    )
 
     # ── RPC Transport ──
     # Default fallback timeout (seconds) used by CuaDriverClient when no
@@ -938,6 +964,25 @@ def _build_settings_from_env(
         ) & ALL_SIGNAL_CHANNELS
     signal_reactive_capture = _bool("LEAPFLOW_SIGNAL_REACTIVE_CAPTURE", "false")
 
+    def _tuple_env(key: str, default: tuple) -> tuple:
+        raw = os.getenv(key, ",".join(str(item) for item in default)).strip()
+        return tuple(item.strip() for item in raw.split(",") if item.strip())
+
+    signal_noise_gate_enabled = _bool("LEAPFLOW_SIGNAL_NOISE_GATE_ENABLED", "true")
+    signal_noise_same_source_cooldown_s = float(os.getenv("LEAPFLOW_SIGNAL_NOISE_SAME_SOURCE_COOLDOWN_S", "2.0"))
+    signal_noise_allow_fs_outside_workspace = _bool(
+        "LEAPFLOW_SIGNAL_NOISE_ALLOW_FS_OUTSIDE_WORKSPACE", "false",
+    )
+    signal_noise_path_fragments = _tuple_env(
+        "LEAPFLOW_SIGNAL_NOISE_PATH_FRAGMENTS", Settings.signal_noise_path_fragments,
+    )
+    signal_noise_dir_names = _tuple_env(
+        "LEAPFLOW_SIGNAL_NOISE_DIR_NAMES", Settings.signal_noise_dir_names,
+    )
+    signal_noise_suffixes = _tuple_env(
+        "LEAPFLOW_SIGNAL_NOISE_SUFFIXES", Settings.signal_noise_suffixes,
+    )
+
     # RPC Transport
     rpc_timeout_default = float(os.getenv("LEAPFLOW_RPC_TIMEOUT_DEFAULT", "30.0"))
 
@@ -1256,6 +1301,12 @@ def _build_settings_from_env(
         # Signal Fusion
         signal_channels=signal_channels,
         signal_reactive_capture=signal_reactive_capture,
+        signal_noise_gate_enabled=signal_noise_gate_enabled,
+        signal_noise_same_source_cooldown_s=signal_noise_same_source_cooldown_s,
+        signal_noise_allow_fs_outside_workspace=signal_noise_allow_fs_outside_workspace,
+        signal_noise_path_fragments=signal_noise_path_fragments,
+        signal_noise_dir_names=signal_noise_dir_names,
+        signal_noise_suffixes=signal_noise_suffixes,
         # RPC Transport
         rpc_timeout_default=rpc_timeout_default,
         # Cua Driver
diff --git a/src/leapflow/config_service.py b/src/leapflow/config_service.py
index 9f0cf08..e3f4c67 100644
--- a/src/leapflow/config_service.py
+++ b/src/leapflow/config_service.py
@@ -178,6 +178,12 @@ class ConfigSnapshot:
     "web.extractor": "HTML reader for web_fetch. auto prefers trafilatura when the `web` extra is installed (`pip install 'leapflow[web]'`) and falls back to the built-in stdlib reader; stdlib pins the dependency-free reader.",
     "web.private_targets": "How web_fetch treats URLs resolving to loopback, private, link-local, or cloud-metadata addresses. approval asks the user each session (default), deny refuses without prompting (for unattended deployments), allow permits them silently and is only appropriate on a trusted network.",
     "web.cache_ttl_s": "Seconds a fetched body is reused from the session cache (0 disables caching). Entries are session-scoped and never synced.",
+    "signal.noise_gate_enabled": "Enable monitor/LeapBoard suppression of low-value signal noise before it wakes watches or enters the live stream.",
+    "signal.noise_same_source_cooldown_s": "Suppress repeated fs.change events from the same source path within this many seconds (0 disables burst suppression).",
+    "signal.noise_allow_fs_outside_workspace": "Allow fs.change events outside the active workspace into monitor/LeapBoard signal flow (default false to avoid system and unrelated-project churn).",
+    "signal.noise_path_fragments": "Path fragments treated as monitor/display noise for fs.change events, e.g. OS caches and tool state directories.",
+    "signal.noise_dir_names": "Directory names treated as monitor/display noise for fs.change events.",
+    "signal.noise_suffixes": "Filename suffixes treated as transient fs.change noise, e.g. WAL/SHM/journal/temp/log files.",
 }
 
 _SECTION_CATEGORIES = {
@@ -226,6 +232,9 @@ class ConfigSnapshot:
     "daemon.log_level": "DEBUG|INFO|WARNING|ERROR",
     "recording.mode": "video|default|vision_only",
     "signal.channels": "all or comma-separated channel names",
+    "signal.noise_path_fragments": "comma-separated path fragments",
+    "signal.noise_dir_names": "comma-separated directory names",
+    "signal.noise_suffixes": "comma-separated suffixes",
     "web.transport": "auto|httpx|curl",
     "web.extractor": "auto|stdlib",
     "web.private_targets": "approval|deny|allow",
diff --git a/src/leapflow/daemon/_transport.py b/src/leapflow/daemon/_transport.py
index 3dca2bd..602fd89 100644
--- a/src/leapflow/daemon/_transport.py
+++ b/src/leapflow/daemon/_transport.py
@@ -89,7 +89,13 @@ def _port_path(self, runtime_dir: Path) -> Path:
 
     def _read_port(self, runtime_dir: Path) -> int:
         port_path = self._port_path(runtime_dir)
-        return int(port_path.read_text(encoding="utf-8").strip())
+        try:
+            port = int(port_path.read_text(encoding="utf-8").strip())
+        except ValueError as exc:
+            raise OSError(f"invalid daemon port file: {port_path}") from exc
+        if port <= 0 or port > 65535:
+            raise OSError(f"invalid daemon port value: {port}")
+        return port
 
     async def start_server(
         self,
diff --git a/src/leapflow/daemon/client.py b/src/leapflow/daemon/client.py
index c1d471e..e1d601b 100644
--- a/src/leapflow/daemon/client.py
+++ b/src/leapflow/daemon/client.py
@@ -282,6 +282,16 @@ async def session_analyze(self) -> dict[str, Any]:
         """Ensure a session-analysis watch and run one analysis cycle now."""
         return dict(await self.request("session.analyze") or {})
 
+    async def signal_record(self, event_type: str, payload: dict[str, Any]) -> dict[str, Any]:
+        """Inject a signal event into the daemon's EventBus."""
+        return dict(await self.request(
+            "signal.record", {"signal_data": {"type": event_type, "payload": payload}},
+        ) or {})
+
+    async def monitor_signal_metrics(self) -> dict[str, Any]:
+        """Fetch signal flow metrics from daemon."""
+        return dict(await self.request("monitor.signal_metrics") or {})
+
     async def shutdown(self) -> None:
         """Request graceful daemon shutdown."""
         await self.request("daemon.shutdown")
diff --git a/src/leapflow/daemon/monitor_coordinator.py b/src/leapflow/daemon/monitor_coordinator.py
index 3c8ce06..268403c 100644
--- a/src/leapflow/daemon/monitor_coordinator.py
+++ b/src/leapflow/daemon/monitor_coordinator.py
@@ -6,16 +6,31 @@
 from __future__ import annotations
 
 import logging
-from typing import Any
+import time
+from collections import deque
+from typing import Any, Callable, Optional
+
+from leapflow.daemon.notifications import Notification
+from leapflow.monitor.signal_noise import SignalNoiseConfig, SignalNoiseGate
 
 logger = logging.getLogger(__name__)
 
+# Rate-limit: max pushes per event_type per second.
+_SIGNAL_STREAM_MAX_PER_SEC = 2
+
 
 class MonitorCoordinator:
     """Manages the daemon-hosted monitor runtime (watches, findings, tickers)."""
 
     def __init__(self) -> None:
         self._monitors: Any | None = None
+        self._bridge_subscribed: bool = False
+        self._bridge_callback: Any | None = None
+        self._event_bus: Any | None = None
+        self._signal_stream_subscriber: Optional[Callable[..., None]] = None
+        self._notification_bus: Any | None = None
+        self._signal_stream_buffer: deque[dict[str, Any]] = deque(maxlen=50)
+        self._signal_noise_gate: SignalNoiseGate | None = None
 
     # ── Lifecycle ─────────────────────────────────────────────────────────
 
@@ -25,6 +40,7 @@ async def start(self, ctx: Any, notification_bus: Any, settings: Any) -> None:
             return
         try:
             from leapflow.monitor import MonitorManager, SessionAnalysisProducer
+            from leapflow.monitor.signal_producer import SignalObservationProducer
 
             bus = notification_bus
             self._monitors = MonitorManager(
@@ -35,8 +51,26 @@ async def start(self, ctx: Any, notification_bus: Any, settings: Any) -> None:
                 grace_seconds=float(getattr(settings, "scheduler_grace_seconds", 120.0)),
             )
             self._monitors.producers.register(SessionAnalysisProducer())
+            self._monitors.producers.register(SignalObservationProducer())
             setattr(ctx, "monitors", self._monitors)
             await self._monitors.start()
+
+            # Subscribe one monitor/display boundary callback to EventBus. The
+            # callback applies SignalNoiseGate once, then fans accepted events
+            # into both EventBridge (watch activation) and LeapBoard stream.
+            event_bus = getattr(ctx, "event_bus", None)
+            self._signal_noise_gate = SignalNoiseGate(SignalNoiseConfig.from_settings(settings))
+            if event_bus is not None and hasattr(event_bus, "subscribe") and not self._bridge_subscribed:
+                self._bridge_callback = self._make_monitor_signal_subscriber(
+                    self._monitors.event_bridge.on_event,
+                    bus,
+                )
+                event_bus.subscribe(self._bridge_callback)
+                self._bridge_subscribed = True
+                self._event_bus = event_bus
+                self._notification_bus = bus
+                logger.debug("daemon: monitor signal subscriber registered")
+
             # A fresh daemon lifetime owns no interactive clients yet, so any
             # persisted client-coupled watch (e.g. a session-analysis watch left
             # over from a prior run or an unclean client exit) is stale. Drop it
@@ -47,6 +81,10 @@ async def start(self, ctx: Any, notification_bus: Any, settings: Any) -> None:
                     logger.info("daemon: swept %d stale client-coupled watch(es) on startup", swept)
             except Exception:
                 logger.debug("daemon: client-coupled watch sweep failed", exc_info=True)
+
+            # Auto-arm default event-driven watches (idempotent).
+            await self._arm_default_watches()
+
             logger.debug("daemon: monitor runtime started")
         except Exception:
             logger.debug("daemon: monitor runtime start skipped", exc_info=True)
@@ -65,9 +103,148 @@ def _build_services_proxy(self, ctx: Any, settings: Any) -> Any:
         # _ProducerServices is built in service.py and passed to start().
         return None
 
+    def update_settings(self, settings: Any) -> None:
+        """Hot-apply signal noise policy settings to the running gate."""
+        gate = self._signal_noise_gate
+        if gate is not None:
+            gate.update_config(SignalNoiseConfig.from_settings(settings))
+
+    def _make_monitor_signal_subscriber(
+        self,
+        event_bridge_callback: Callable[[Any], None],
+        notification_bus: Any,
+    ) -> Callable[..., None]:
+        """Apply noise policy once, then route accepted events to watch + stream."""
+        stream_callback = self._make_signal_stream_subscriber(notification_bus)
+
+        def _on_event(event: Any) -> None:
+            gate = self._signal_noise_gate
+            if gate is not None and not gate.should_pass(event):
+                return
+            event_bridge_callback(event)
+            stream_callback(event)
+
+        return _on_event
+
+    def _make_signal_stream_subscriber(self, notification_bus: Any) -> Callable[..., None]:
+        """Build a rate-limited callback that pushes signal summaries to NotificationBus.
+
+        Every event (regardless of rate-limit) is appended to the ring buffer so
+        the dashboard can display the full recent stream.
+        """
+        last_push: dict[str, float] = {}
+        min_interval = 1.0 / _SIGNAL_STREAM_MAX_PER_SEC
+
+        def _on_event(event: Any) -> None:
+            event_type = getattr(event, "event_type", "")
+            if not event_type:
+                return
+            summary = {
+                "event_type": event_type,
+                "source": getattr(event, "source", ""),
+                "ts": getattr(event, "timestamp", time.time()),
+            }
+            # Always record into ring buffer for dashboard polling.
+            self._signal_stream_buffer.append(summary)
+            # Rate-limited push to notification bus.
+            now = time.monotonic()
+            prev = last_push.get(event_type, 0.0)
+            if now - prev < min_interval:
+                return
+            last_push[event_type] = now
+            notification_bus.emit(Notification(event_type="signal.stream", payload=summary))
+
+        return _on_event
+
+    def get_signal_stream(self) -> list[dict[str, Any]]:
+        """Return recent accepted signal events (up to 50) from the ring buffer."""
+        return list(self._signal_stream_buffer)
+
+    @property
+    def signal_noise_stats(self) -> dict[str, Any]:
+        """Return monitor/display noise-gate counters for metrics."""
+        gate = self._signal_noise_gate
+        return gate.stats if gate is not None else {}
+
+    # ── Default event-driven watches ──────────────────────────────────────
+
+    # Default watches to arm on daemon startup. Each tuple:
+    # (name, domain, trigger_expr)
+    _DEFAULT_WATCHES = [
+        ("fs-observer", "signal", "event:fs.*"),
+        ("gateway-observer", "signal", "event:gateway.*"),
+    ]
+
+    async def _arm_default_watches(self) -> None:
+        """Arm built-in event-driven watches if not already present (idempotent).
+
+        Stale watches (state=done/failed) with the same trigger pattern are
+        removed and re-created so daemon restarts always restore monitoring.
+        """
+        from leapflow.monitor import WatchSpec
+
+        monitors = self._monitors
+        if monitors is None:
+            return
+
+        # Map trigger -> (view, is_active) for existing watches
+        existing: dict[str, tuple[Any, bool]] = {}
+        _ACTIVE_STATES = {"armed", "watching", "due", "confirming", "executing"}
+        try:
+            for view in monitors.list_watches():
+                is_active = str(view.state) in _ACTIVE_STATES
+                existing[view.trigger] = (view, is_active)
+        except Exception:
+            logger.debug("daemon: failed to list watches for default arm", exc_info=True)
+            return
+
+        for name, domain, trigger_expr in self._DEFAULT_WATCHES:
+            expected_trigger = f"event:{trigger_expr.removeprefix('event:')}"
+            entry = existing.get(expected_trigger)
+            if entry is not None:
+                view, is_active = entry
+                if is_active:
+                    # Already armed and active — nothing to do.
+                    continue
+                # Stale (done/failed/suspended) — remove so we can re-arm.
+                try:
+                    monitors.stop_watch(view.watch_id)
+                except Exception:
+                    pass
+                try:
+                    monitors._task_store.delete(view.watch_id)
+                except Exception:
+                    logger.debug("daemon: failed to delete stale watch %s", name, exc_info=True)
+            try:
+                await monitors.arm_watch(
+                    WatchSpec(
+                        name=name,
+                        domain=domain,
+                        trigger_expr=trigger_expr,
+                    )
+                )
+                logger.debug("daemon: armed default watch %s (%s)", name, trigger_expr)
+            except Exception:
+                logger.debug("daemon: failed to arm default watch %s", name, exc_info=True)
+
     async def stop(self) -> None:
         """Stop the monitor runtime."""
         if self._monitors is not None:
+            # Unsubscribe signal stream subscriber.
+            if self._signal_stream_subscriber is not None:
+                if self._event_bus is not None and hasattr(self._event_bus, "unsubscribe"):
+                    self._event_bus.unsubscribe(self._signal_stream_subscriber)
+                self._signal_stream_subscriber = None
+                self._notification_bus = None
+            # Unsubscribe event bridge before stopping monitors.
+            if self._bridge_subscribed and self._bridge_callback is not None:
+                if self._event_bus is not None and hasattr(self._event_bus, "unsubscribe"):
+                    self._event_bus.unsubscribe(self._bridge_callback)
+                self._bridge_subscribed = False
+                self._bridge_callback = None
+                self._event_bus = None
+                self._notification_bus = None
+                self._signal_noise_gate = None
             try:
                 await self._monitors.stop()
             except Exception:
diff --git a/src/leapflow/daemon/protocol.py b/src/leapflow/daemon/protocol.py
index ef34fbe..a996aa1 100644
--- a/src/leapflow/daemon/protocol.py
+++ b/src/leapflow/daemon/protocol.py
@@ -370,4 +370,5 @@ async def gateway_send(
     "gateway.status": "gateway_status",
     "gateway.send": "gateway_send",
     "events.subscribe": "subscribe_notifications",
+    "monitor.signal_metrics": "monitor_signal_metrics",
 }
diff --git a/src/leapflow/daemon/service.py b/src/leapflow/daemon/service.py
index 0c13f64..08ad755 100644
--- a/src/leapflow/daemon/service.py
+++ b/src/leapflow/daemon/service.py
@@ -39,6 +39,7 @@
 from leapflow.daemon.turn_admission import TurnAdmission
 from leapflow.engine import StreamEvent
 from leapflow.memory.protocol import MemoryQuery
+from leapflow.utils.build_info import capture_build_info, is_stale
 
 logger = logging.getLogger(__name__)
 
@@ -67,6 +68,10 @@ def __init__(self, settings: Any, *, mock_host: bool = False) -> None:
         )
         self._session_coordinator = SessionCoordinator()
         self._started_at = time.time()
+        # Captured once at daemon startup so status() can tell a developer
+        # this process is stale (source changed since it started) instead of
+        # a fixed behavior change looking like a code defect.
+        self._build_info = capture_build_info()
         self._client_count: Callable[[], int] = lambda: 0
         self._client_leases: Callable[[], list[ClientLeaseSnapshot]] = lambda: []
         self._approval_coordinator = ApprovalCoordinator(
@@ -74,6 +79,7 @@ def __init__(self, settings: Any, *, mock_host: bool = False) -> None:
         )
         self._active_engine_request_id: str = ""
         self._active_engines: dict[str, Any] = {}
+        self._observation: Any | None = None
         self._engine_request_ledger: dict[str, dict[str, Any]] = {}
         self._request_ledger_ttl_s = max(1.0, float(getattr(settings, "daemon_request_ledger_ttl_s", 600.0) or 600.0))
         self._request_ledger_max_entries = max(1, int(getattr(settings, "daemon_request_ledger_max_entries", 128) or 128))
@@ -114,6 +120,18 @@ async def start(self) -> None:
                 request_approval=self._request_approval,
             )
 
+        # Platform observers: start FS/clipboard/focus signal collection
+        if getattr(settings, "observation_enabled", True):
+            event_bus = getattr(ctx, "event_bus", None)
+            if event_bus is not None:
+                try:
+                    from leapflow.platform.observers.daemon import ObservationDaemon
+                    self._observation = ObservationDaemon(bus=event_bus)
+                    await self._observation.start()
+                except Exception:
+                    logger.debug("daemon: observation subsystem start failed", exc_info=True)
+                    self._observation = None
+
     async def shutdown(self) -> None:
         if self._ctx is None:
             return
@@ -140,6 +158,12 @@ async def shutdown(self) -> None:
             except (asyncio.CancelledError, Exception):
                 pass
         await self._reentry_coordinator.stop()
+        if self._observation is not None:
+            try:
+                await self._observation.stop()
+            except Exception:
+                logger.debug("daemon: observation stop failed", exc_info=True)
+            self._observation = None
         await self._monitor_coordinator.stop()
         checkpoint_open_connection(ctx)
         await ctx.cleanup()
@@ -291,6 +315,7 @@ async def engine_chat(self, message: str, **kwargs: Any) -> AsyncIterator[Stream
             try:
                 if ctx.reload_runtime_config_if_changed():
                     self._settings = ctx.settings
+                    self._monitor_coordinator.update_settings(ctx.settings)
                     chunk = StreamChunk(
                         request_id=request_id,
                         content="Configuration reloaded in leapd.",
@@ -605,6 +630,22 @@ async def host_restart(self) -> dict[str, Any]:
                 return {"ok": False, "started": False, "last_error": "host lifecycle is unavailable"}
             return dict(await restart())
 
+    # ── Delegate: signal metrics ──────────────────────────────────────
+
+    async def monitor_signal_metrics(self) -> dict[str, Any]:
+        """Collect real-time signal flow metrics from runtime components."""
+        from leapflow.monitor.signal_metrics import SignalMetricsCollector
+
+        ctx = self._ctx
+        collector = SignalMetricsCollector()
+        snapshot = collector.collect(
+            event_bus=getattr(ctx, "event_bus", None) if ctx else None,
+            monitor_manager=self._monitor_coordinator._monitors,
+            signal_noise_gate=self._monitor_coordinator.signal_noise_stats,
+        )
+        stream = self._monitor_coordinator.get_signal_stream()
+        return {"ok": True, "metrics": snapshot.to_dict(), "signal_stream": stream}
+
     # ── Delegate: memory / signal ────────────────────────────────────
 
     async def signal_record(self, signal_data: dict[str, Any]) -> dict[str, Any]:
@@ -715,6 +756,7 @@ async def status(self, session_id: str = "") -> dict[str, Any]:
         self._approval_coordinator.prune_stale()
         clients = await asyncio.to_thread(self._safe_client_lease_summaries)
         host = await asyncio.to_thread(host_backend_status, ctx)
+        build_stale = await asyncio.to_thread(is_stale, self._build_info)
         return {
             "pid": os.getpid(),
             "profile": getattr(settings, "profile", "default"),
@@ -757,6 +799,9 @@ async def status(self, session_id: str = "") -> dict[str, Any]:
             "deferred_init": self._deferred_init_status(ctx),
             "watch_summary": self._monitor_coordinator.get_summary(),
             "host_backend": host,
+            # Whether *this* daemon process still matches the source tree on
+            # disk (None when outside a git checkout, e.g. a packaged install).
+            "build": {**self._build_info.to_dict(), "stale": build_stale},
         }
 
     # ── Internal helpers ─────────────────────────────────────────────
diff --git a/src/leapflow/dashboard/launcher.py b/src/leapflow/dashboard/launcher.py
index b6ab3f3..4853fd3 100644
--- a/src/leapflow/dashboard/launcher.py
+++ b/src/leapflow/dashboard/launcher.py
@@ -70,7 +70,11 @@ def write_state(settings: Any, state: dict[str, Any]) -> None:
 
 
 def clear_state(settings: Any) -> None:
-    state_path(settings).unlink(missing_ok=True)
+    """Best-effort removal of dashboard discovery state."""
+    try:
+        state_path(settings).unlink(missing_ok=True)
+    except OSError:
+        logger.debug("dashboard: failed to clear discovery state", exc_info=True)
 
 
 def _host_for_bind(bind: str) -> str:
@@ -138,6 +142,33 @@ def probe_token(bind: str, port: int, token: str, *, timeout: float = 0.6) -> bo
         return False
 
 
+def fetch_server_info(bind: str, port: int, token: str, *, timeout: float = 0.8) -> Optional[dict[str, Any]]:
+    """Fetch the running dashboard server's own build/staleness self-report.
+
+    Best-effort: this is a diagnostic side-channel (``/board status`` and
+    ``leap daemon status`` use it to warn a developer that the *separate*
+    long-lived web server process has not picked up a recent source change),
+    never a hard dependency — any failure (server down, wrong token, bad JSON,
+    old server predating this endpoint) returns None rather than raising.
+    """
+    import json
+    import urllib.error
+    import urllib.request
+
+    if not token:
+        return None
+    try:
+        with urllib.request.urlopen(  # noqa: S310 - fixed localhost URL
+            build_url(bind, port, token, path="/api/server-info"), timeout=timeout
+        ) as response:
+            if not (200 <= int(getattr(response, "status", 200)) < 400):
+                return None
+            payload = json.loads(response.read().decode("utf-8"))
+    except (urllib.error.URLError, OSError, ValueError, UnicodeDecodeError):
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
 def server_running(settings: Any) -> Optional[dict[str, Any]]:
     """Return live dashboard state when a server accepts the stored token, else None.
 
@@ -293,6 +324,7 @@ def ensure_server(settings: Any, *, wait_s: float = 8.0) -> dict[str, Any]:
     "build_view_url",
     "is_port_open",
     "probe_token",
+    "fetch_server_info",
     "server_running",
     "open_in_browser",
     "ensure_server",
diff --git a/src/leapflow/dashboard/server.py b/src/leapflow/dashboard/server.py
index 1c35dfe..a2c52b0 100644
--- a/src/leapflow/dashboard/server.py
+++ b/src/leapflow/dashboard/server.py
@@ -25,11 +25,13 @@
 from leapflow.dashboard.service import DaemonDataProvider, DashboardViewBuilder
 from leapflow.dashboard.templates import TemplateLibrary
 from leapflow.monitor.types import EVENT_ERROR, EVENT_FINDING, EVENT_HEARTBEAT, EVENT_WATCH_STATE
+from leapflow.utils.build_info import capture_build_info, is_stale
 
 logger = logging.getLogger(__name__)
 
+
 STATIC_DIR = Path(__file__).parent / "static"
-_MONITOR_EVENTS = frozenset({EVENT_FINDING, EVENT_WATCH_STATE, EVENT_ERROR, EVENT_HEARTBEAT})
+_MONITOR_EVENTS = frozenset({EVENT_FINDING, EVENT_WATCH_STATE, EVENT_ERROR, EVENT_HEARTBEAT, "signal.stream"})
 # Only these RPCs may be triggered by browser actions (least privilege).
 _ALLOWED_RPC = frozenset({"watch.pause", "watch.resume", "watch.stop", "watch.refresh", "watch.mute"})
 # Exact loopback hosts accepted in the Origin header (see _check_origin).
@@ -56,6 +58,10 @@ def __init__(
         self._builder = DashboardViewBuilder(templates or TemplateLibrary())
         self._provider = DaemonDataProvider(client)
         self._upstream_task: Optional[asyncio.Task[None]] = None
+        # Captured once at server startup so /api/server-info and the ViewSpec
+        # meta can report whether this long-lived process is still fresh
+        # relative to the source tree (see leapflow.utils.build_info).
+        self._build_info = capture_build_info()
 
     # ── App wiring ─────────────────────────────────────────────────────────
 
@@ -66,6 +72,7 @@ def build_app(self) -> Any:
         app = web.Application()
         app.router.add_get("/", self._handle_index)
         app.router.add_get("/api/view", self._handle_view)
+        app.router.add_get("/api/server-info", self._handle_server_info)
         app.router.add_post("/api/action", self._handle_action)
         app.router.add_get("/ws", self._handle_ws)
         if STATIC_DIR.exists():
@@ -118,7 +125,9 @@ async def _handle_index(self, request: Any) -> Any:
             return web.Response(status=401, text="missing or invalid token")
         index = STATIC_DIR / "index.html"
         if index.exists():
-            return web.FileResponse(index)
+            response = web.FileResponse(index)
+            response.headers["Cache-Control"] = "no-store"
+            return response
         return web.Response(text="<h1>LeapFlow dashboard</h1>", content_type="text/html")
 
     async def _handle_view(self, request: Any) -> Any:
@@ -130,8 +139,31 @@ async def _handle_view(self, request: Any) -> Any:
             "template": request.query.get("template", ""),
         })
         spec = await self._builder.build(intent, self._provider)
+        if isinstance(spec, dict):
+            meta = spec.setdefault("meta", {})
+            if isinstance(meta, dict):
+                meta["server"] = await self._server_info()
         return web.json_response(spec)
 
+    async def _handle_server_info(self, request: Any) -> Any:
+        """Self-report this process's build fingerprint and staleness verdict.
+
+        A tiny, single-purpose diagnostic endpoint (distinct from the ViewSpec
+        the browser renders) so ``/board status`` and ``leap daemon status``
+        can check on this *separate* long-lived process without depending on
+        SDUI schema shape.
+        """
+        from aiohttp import web
+
+        if not self._check_token(request):
+            return web.json_response({"error": "unauthorized"}, status=401)
+        return web.json_response(await self._server_info())
+
+    async def _server_info(self) -> dict[str, Any]:
+        """Build the {build, stale} payload shared by the view meta and the endpoint."""
+        stale = await asyncio.to_thread(is_stale, self._build_info)
+        return {"build": self._build_info.to_dict(), "stale": stale}
+
     async def _handle_action(self, request: Any) -> Any:
         from aiohttp import web
 
diff --git a/src/leapflow/dashboard/service.py b/src/leapflow/dashboard/service.py
index 9dd2978..4f803a7 100644
--- a/src/leapflow/dashboard/service.py
+++ b/src/leapflow/dashboard/service.py
@@ -20,7 +20,7 @@
 
 @runtime_checkable
 class DashboardDataProvider(Protocol):
-    """Read-only data access the builder needs (watches and findings)."""
+    """Read-only data access the builder needs (watches, findings, signal metrics)."""
 
     async def watches(self) -> list[dict[str, Any]]:
         """Return all watch views."""
@@ -30,6 +30,10 @@ async def findings(self, *, watch_id: str = "", limit: int = 50) -> list[dict[st
         """Return findings, optionally scoped to a watch."""
         ...
 
+    async def signal_metrics(self) -> dict[str, Any]:
+        """Return signal flow health metrics."""
+        ...
+
 
 class DaemonDataProvider:
     """Adapt a DaemonClient's ``watch_*`` RPCs to the provider protocol."""
@@ -43,6 +47,16 @@ async def watches(self) -> list[dict[str, Any]]:
     async def findings(self, *, watch_id: str = "", limit: int = 50) -> list[dict[str, Any]]:
         return list(await self._client.watch_findings(watch_id=watch_id, limit=limit))
 
+    async def signal_metrics(self) -> dict[str, Any]:
+        """Return signal flow health metrics and live stream from the daemon."""
+        result = await self._client.monitor_signal_metrics()
+        if result.get("ok"):
+            return {
+                "metrics": result.get("metrics", {}),
+                "signal_stream": result.get("signal_stream", []),
+            }
+        return {"metrics": {}, "signal_stream": []}
+
 
 def select_template(template: str, names: list[str]) -> str:
     """Return the requested template if available, else the generic fallback.
@@ -53,6 +67,64 @@ def select_template(template: str, names: list[str]) -> str:
     return template if template and template in names else "generic"
 
 
+def _safe_int(value: Any) -> int:
+    try:
+        return int(value or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _sum_int_values(value: Any) -> int:
+    if isinstance(value, dict):
+        values = value.values()
+    elif isinstance(value, (list, tuple)):
+        values = value
+    else:
+        return 0
+    return sum(_safe_int(item) for item in values)
+
+
+def _distribution(rows: list[dict[str, Any]], key: str) -> list[dict[str, Any]]:
+    counts: dict[str, int] = {}
+    for row in rows:
+        label = str(row.get(key) or "unknown")
+        counts[label] = counts.get(label, 0) + 1
+    return [{"label": label, "value": count} for label, count in sorted(counts.items())]
+
+
+def _event_family(event_type: str) -> str:
+    normalized = str(event_type or "unknown").replace(":", ".")
+    return normalized.split(".", 1)[0] or "unknown"
+
+
+def _safe_float(value: Any) -> float:
+    try:
+        return float(value or 0.0)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _signal_stream_item(evt: dict[str, Any]) -> dict[str, Any]:
+    event_type = str(evt.get("event_type") or evt.get("type") or "")
+    source = str(evt.get("source") or "")
+    family = _event_family(event_type)
+    timestamp = _safe_float(evt.get("ts") or evt.get("timestamp"))
+    return {
+        "title": event_type,
+        "event_type": event_type,
+        "summary": source,
+        "source": source,
+        "severity": "info",
+        "family": family,
+        "ts": timestamp,
+    }
+
+
+def _short_id(value: Any) -> str:
+    text = str(value or "")
+    return text[:8] if len(text) > 8 else text
+
+
 class DashboardViewBuilder:
     """Assemble ViewSpecs for dashboard intents."""
 
@@ -65,6 +137,9 @@ async def build(self, intent: DashboardIntent, provider: DashboardDataProvider)
         LeapBoard has one analysis target (the current session); the intent only
         carries which template lens to render it with.
         """
+        template_name = intent.template
+        if template_name == "signals":
+            return await self._build_signals(template_name, provider)
         return await self._build_session(intent.template, provider)
 
     async def _build_session(self, template: str, provider: DashboardDataProvider) -> dict[str, Any]:
@@ -113,7 +188,64 @@ async def _build_session(self, template: str, provider: DashboardDataProvider) -
         if isinstance(spec, dict):
             meta = spec.setdefault("meta", {})
             if isinstance(meta, dict):
-                meta["templates"] = self._templates.names()
+                meta["templates"] = self._templates.visible_names()
+                meta["hidden_templates"] = self._templates.hidden_names()
+                meta["active_template"] = name
+        return spec
+
+    async def _build_signals(self, template: str, provider: DashboardDataProvider) -> dict[str, Any]:
+        """Build signal flow observation view."""
+        metrics_result = await provider.signal_metrics()
+        watches = await provider.watches()
+        findings = await provider.findings(limit=20)
+        raw_metrics = metrics_result.get("metrics", {}) if isinstance(metrics_result, dict) else metrics_result
+        metrics = dict(raw_metrics or {}) if isinstance(raw_metrics, dict) else {}
+
+        # Use the raw signal event stream from the daemon ring buffer. Sort by
+        # event timestamp descending so "recent" is true on first render; the
+        # frontend still receives the full ring buffer and handles tab/limit UI.
+        raw_stream = metrics_result.get("signal_stream", []) if isinstance(metrics_result, dict) else []
+        stream_events = [dict(evt) for evt in raw_stream if isinstance(evt, dict)]
+        stream_events.sort(key=lambda evt: _safe_float(evt.get("ts") or evt.get("timestamp")), reverse=True)
+        signal_stream = [_signal_stream_item(evt) for evt in stream_events] or None
+
+        debounce_total = _sum_int_values(metrics.get("debounce_stats"))
+        metrics["total_debounced"] = debounce_total
+        metrics["signal_stream_count"] = len(stream_events)
+        metrics["total_drop_count"] = (
+            _safe_int(metrics.get("signal_buffer_dropped"))
+            + _safe_int(metrics.get("composite_source_dropped"))
+        )
+
+        trigger_rows = []
+        for trigger in metrics.get("trigger_stats") or []:
+            if not isinstance(trigger, dict):
+                continue
+            trigger_rows.append({
+                "watch": _short_id(trigger.get("watch_id")),
+                "pattern": str(trigger.get("pattern") or ""),
+                "triggered": "yes" if trigger.get("triggered") else "no",
+                "last_event": str(trigger.get("last_event") or ""),
+            })
+
+        event_family_rows = [{"family": str(evt.get("family") or "unknown")} for evt in (signal_stream or [])]
+        data = {
+            "signal_metrics": metrics,
+            "signal_stream": signal_stream,
+            "watches": watches if watches else None,
+            "findings": findings if findings else None,
+            "trigger_rows": trigger_rows,
+            "event_family_distribution": _distribution(event_family_rows, "family") if event_family_rows else None,
+            "watch_state_distribution": _distribution(watches, "state") if watches else None,
+            "finding_severity_distribution": _distribution(findings, "severity") if findings else None,
+        }
+        name = select_template(template, self._templates.names())
+        spec = self._templates.render(name, data)
+        if isinstance(spec, dict):
+            meta = spec.setdefault("meta", {})
+            if isinstance(meta, dict):
+                meta["templates"] = self._templates.visible_names()
+                meta["hidden_templates"] = self._templates.hidden_names()
                 meta["active_template"] = name
         return spec
 
diff --git a/src/leapflow/dashboard/static/app.js b/src/leapflow/dashboard/static/app.js
index c44c7bd..ff14206 100644
--- a/src/leapflow/dashboard/static/app.js
+++ b/src/leapflow/dashboard/static/app.js
@@ -15,20 +15,173 @@
   const browserLocale = (navigator.language || "en").slice(0, 2).toLowerCase();
   let locale = storedLocale || (["en", "zh", "fr", "es", "ar", "ru"].includes(browserLocale) ? browserLocale : "en");
   let current = { template: params.get("template") || "" };
+  const HIDDEN_NAV_TEMPLATES = new Set(["finance", "research", "sentiment"]);
   let figSeq = 0;  // academic figure counter, reset each render()
   let tblSeq = 0;  // academic table counter, reset each render()
 
+  // ── Signal auto-refresh state ──
+  let _signalRefreshTimer = null;
+  let _signalEventCount = 0;
+
+  function getCurrentTemplate() { return current.template || ""; }
+
+  function startSignalAutoRefresh() {
+    stopSignalAutoRefresh();
+    _signalRefreshTimer = setInterval(function () {
+      if (getCurrentTemplate() === "signals") fetchView();
+    }, 5000);
+  }
+
+  function stopSignalAutoRefresh() {
+    if (_signalRefreshTimer) { clearInterval(_signalRefreshTimer); _signalRefreshTimer = null; }
+  }
+
+  function incrementSignalCounter() {
+    _signalEventCount++;
+    var counterEl = document.getElementById("signal-event-counter");
+    if (counterEl) counterEl.textContent = String(_signalEventCount);
+  }
+
+  function injectSignalRefreshBtn() {
+    if (getCurrentTemplate() !== "signals") return;
+    // Find the page title or first section title to attach the controls.
+    var title = rootEl.querySelector(".page-title") || rootEl.querySelector(".section-title");
+    if (!title) return;
+    // Avoid duplicates; controls belong to the title node, never the page
+    // container, so the page keeps its vertical document flow.
+    var header = title;
+    if (header.querySelector(".refresh-btn")) return;
+    header.classList.add("with-actions");
+    var btn = document.createElement("button");
+    btn.className = "refresh-btn";
+    btn.textContent = "\u21bb";  // ↻
+    btn.title = "Refresh signal metrics";
+    btn.addEventListener("click", function () {
+      btn.disabled = true;
+      btn.classList.add("refreshing");
+      fetchView().then(function () {
+        setTimeout(function () { btn.disabled = false; btn.classList.remove("refreshing"); }, 400);
+      }).catch(function () {
+        btn.disabled = false; btn.classList.remove("refreshing");
+      });
+    });
+    header.appendChild(btn);
+    // Also inject event counter badge next to the button
+    var counter = document.createElement("span");
+    counter.className = "signal-counter-badge";
+    counter.id = "signal-event-counter";
+    counter.textContent = String(_signalEventCount);
+    counter.title = "WebSocket events received";
+    header.appendChild(counter);
+  }
+
   const I18N = {
     en: { "manual_refresh": "manual refresh", "first_observation": "first observation", "artifact_changed": "artifact changed", "batch_turns": "turn threshold", "batch_tokens": "token threshold", "model_salience": "model salience", "text_only": "conversation text", "text_and_artifacts": "conversation + files", "partial_artifacts": "partial files" },
-    zh: { "Overview": "概览", "Session": "会话", "Language": "语言", "connecting…": "连接中…", "live": "实时", "reconnecting…": "重连中…", "Loading…": "加载中…", "No content yet.": "暂无内容。", "Failed to load view": "视图加载失败", "Action failed": "操作失败", "Candlestick": "K线", "Series": "序列", "Gauge": "仪表", "Custom": "自定义", "unknown": "未知", "Watch portfolio": "观察组合", "Refresh cadence": "刷新节奏", "Active watches": "活跃观察", "Recent findings": "最新发现", "Watches": "观察任务", "Findings": "发现", "Signals": "信号", "Watch": "观察", "Price action": "价格行为", "Signal mix": "信号结构", "Market brief": "市场简报", "Latest sentiment": "最新情绪", "Mentions": "提及", "Sentiment structure": "情绪结构", "Narrative pulse": "叙事脉搏", "New papers": "新论文", "Research pipeline": "研究管线", "Evidence stream": "证据流", "Executive brief": "执行摘要", "Storyline": "叙事线", "Insights": "洞察", "Action items": "行动项", "Decisions": "决策", "Open questions": "待回答问题", "Entities": "实体", "Suggested next prompts": "建议追问", "Timeline": "时间线", "Severity mix": "严重度结构", "alert": "警报", "notable": "重要", "info": "信息", "Observation status": "观察状态", "Refresh state": "刷新状态", "Refresh reason": "刷新原因", "Coverage": "覆盖率", "Artifacts": "副产物", "Observed context": "已观察上下文", "File artifacts": "文件副产物", "File": "文件", "Status": "状态", "Note": "说明", "manual_refresh": "手动刷新", "first_observation": "首次观察", "artifact_changed": "文件副产物变化", "batch_turns": "轮次阈值", "batch_tokens": "上下文阈值", "model_salience": "模型显著性", "Session Analysis": "会话分析", "Observation": "观察", "Operating agenda": "行动议程", "Context map": "上下文图谱", "Next prompts": "后续追问", "Turns": "轮次", "Tokens": "词元", "Reason": "原因", "Abstract": "摘要", "No entries.": "暂无条目。", "Insight count by severity.": "按严重度统计的洞察数。", "Session file artifacts.": "会话文件副产物。", "Coverage · storyline · severity": "覆盖率 · 叙事 · 严重度", "Trigger and context": "触发与上下文", "Key observations": "关键观察", "Decisions and actions": "决策与行动", "Entities and follow-ups": "实体与后续", "Extracted from this session's tool/file output (not model-generated).": "数据来自本次会话的工具/文件产物（非模型生成）。" },
-    fr: { "Overview": "Vue d’ensemble", "Session": "Session", "Language": "Langue", "connecting…": "connexion…", "live": "direct", "reconnecting…": "reconnexion…", "Loading…": "chargement…", "No content yet.": "Aucun contenu.", "Failed to load view": "Échec du chargement", "Action failed": "Action échouée", "Watch": "Veille", "Watches": "Veilles", "Findings": "Constats", "Recent findings": "Constats récents", "Signals": "Signaux", "Insights": "Analyses", "Action items": "Actions", "Decisions": "Décisions", "Open questions": "Questions ouvertes", "Entities": "Entités", "Suggested next prompts": "Prochaines invites", "Executive brief": "Synthèse exécutive", "Storyline": "Narratif", "Timeline": "Chronologie", "Severity mix": "Mix de sévérité", "alert": "alerte", "notable": "notable", "info": "info", "Observation status": "Statut d’observation", "Refresh state": "État", "Refresh reason": "Raison", "Coverage": "Couverture", "Artifacts": "Artefacts", "Observed context": "Contexte observé", "File artifacts": "Fichiers", "File": "Fichier", "Status": "Statut", "Note": "Note", "manual_refresh": "actualisation manuelle", "first_observation": "première observation", "artifact_changed": "artefact modifié", "batch_turns": "seuil de tours", "batch_tokens": "seuil de jetons", "model_salience": "saillance modèle", "Session Analysis": "Analyse de session", "Observation": "Observation", "Operating agenda": "Programme d’action", "Context map": "Carte de contexte", "Next prompts": "Invites suivantes", "Turns": "Tours", "Tokens": "Jetons", "Reason": "Raison", "Abstract": "Résumé", "No entries.": "Aucune entrée.", "Insight count by severity.": "Nombre d’analyses par sévérité.", "Session file artifacts.": "Artefacts de fichiers de session.", "Coverage · storyline · severity": "Couverture · récit · sévérité", "Trigger and context": "Déclencheur et contexte", "Key observations": "Observations clés", "Decisions and actions": "Décisions et actions", "Entities and follow-ups": "Entités et suivis" },
-    es: { "Overview": "Resumen", "Session": "Sesión", "Language": "Idioma", "connecting…": "conectando…", "live": "en vivo", "reconnecting…": "reconectando…", "Loading…": "cargando…", "No content yet.": "Sin contenido.", "Failed to load view": "Error al cargar", "Action failed": "Acción fallida", "Watch": "Vigilancia", "Watches": "Vigilancias", "Findings": "Hallazgos", "Recent findings": "Hallazgos recientes", "Signals": "Señales", "Insights": "Ideas", "Action items": "Acciones", "Decisions": "Decisiones", "Open questions": "Preguntas abiertas", "Entities": "Entidades", "Suggested next prompts": "Siguientes preguntas", "Executive brief": "Resumen ejecutivo", "Storyline": "Narrativa", "Timeline": "Cronología", "Severity mix": "Mezcla de severidad", "alert": "alerta", "notable": "relevante", "info": "info", "Observation status": "Estado de observación", "Refresh state": "Estado", "Refresh reason": "Motivo", "Coverage": "Cobertura", "Artifacts": "Artefactos", "Observed context": "Contexto observado", "File artifacts": "Archivos", "File": "Archivo", "Status": "Estado", "Note": "Nota", "manual_refresh": "actualización manual", "first_observation": "primera observación", "artifact_changed": "artefacto cambiado", "batch_turns": "umbral de turnos", "batch_tokens": "umbral de tokens", "model_salience": "relevancia del modelo", "Session Analysis": "Análisis de sesión", "Observation": "Observación", "Operating agenda": "Agenda operativa", "Context map": "Mapa de contexto", "Next prompts": "Siguientes prompts", "Turns": "Turnos", "Tokens": "Tokens", "Reason": "Motivo", "Abstract": "Resumen", "No entries.": "Sin entradas.", "Insight count by severity.": "Recuento de hallazgos por severidad.", "Session file artifacts.": "Artefactos de archivos de sesión.", "Coverage · storyline · severity": "Cobertura · relato · severidad", "Trigger and context": "Disparador y contexto", "Key observations": "Observaciones clave", "Decisions and actions": "Decisiones y acciones", "Entities and follow-ups": "Entidades y seguimientos" },
-    ar: { "Overview": "نظرة عامة", "Session": "الجلسة", "Language": "اللغة", "connecting…": "جارٍ الاتصال…", "live": "مباشر", "reconnecting…": "إعادة الاتصال…", "Loading…": "جارٍ التحميل…", "No content yet.": "لا يوجد محتوى بعد.", "Failed to load view": "فشل تحميل العرض", "Action failed": "فشل الإجراء", "Watch": "مراقبة", "Watches": "المراقبات", "Findings": "النتائج", "Recent findings": "أحدث النتائج", "Signals": "الإشارات", "Insights": "الرؤى", "Action items": "إجراءات", "Decisions": "قرارات", "Open questions": "أسئلة مفتوحة", "Entities": "كيانات", "Suggested next prompts": "أسئلة مقترحة", "Executive brief": "ملخص تنفيذي", "Storyline": "السرد", "Timeline": "الخط الزمني", "Severity mix": "توزيع الشدة", "alert": "تنبيه", "notable": "مهم", "info": "معلومة", "Observation status": "حالة المراقبة", "Refresh state": "حالة التحديث", "Refresh reason": "سبب التحديث", "Coverage": "التغطية", "Artifacts": "المخرجات", "Observed context": "السياق المرصود", "File artifacts": "ملفات", "File": "ملف", "Status": "الحالة", "Note": "ملاحظة", "manual_refresh": "تحديث يدوي", "first_observation": "أول مراقبة", "artifact_changed": "تغير ملف", "batch_turns": "حد الجولات", "batch_tokens": "حد الرموز", "model_salience": "أهمية النموذج", "Session Analysis": "تحليل الجلسة", "Observation": "الرصد", "Operating agenda": "خطة العمل", "Context map": "خريطة السياق", "Next prompts": "المطالبات التالية", "Turns": "الأدوار", "Tokens": "الرموز", "Reason": "السبب", "Abstract": "ملخص", "No entries.": "لا توجد إدخالات.", "Insight count by severity.": "عدد الرؤى حسب الخطورة.", "Session file artifacts.": "مخرجات ملفات الجلسة.", "Coverage · storyline · severity": "التغطية · السرد · الخطورة", "Trigger and context": "المُشغِّل والسياق", "Key observations": "ملاحظات رئيسية", "Decisions and actions": "القرارات والإجراءات", "Entities and follow-ups": "الكيانات والمتابعات" },
-    ru: { "Overview": "Обзор", "Session": "Сессия", "Language": "Язык", "connecting…": "подключение…", "live": "онлайн", "reconnecting…": "переподключение…", "Loading…": "загрузка…", "No content yet.": "Пока нет данных.", "Failed to load view": "Не удалось загрузить", "Action failed": "Действие не выполнено", "Watch": "Наблюдение", "Watches": "Наблюдения", "Findings": "Находки", "Recent findings": "Последние находки", "Signals": "Сигналы", "Insights": "Инсайты", "Action items": "Действия", "Decisions": "Решения", "Open questions": "Открытые вопросы", "Entities": "Сущности", "Suggested next prompts": "Следующие запросы", "Executive brief": "Краткий обзор", "Storyline": "Сюжет", "Timeline": "Хронология", "Severity mix": "Структура важности", "alert": "тревога", "notable": "важно", "info": "инфо", "Observation status": "Статус наблюдения", "Refresh state": "Состояние", "Refresh reason": "Причина", "Coverage": "Покрытие", "Artifacts": "Артефакты", "Observed context": "Наблюдаемый контекст", "File artifacts": "Файлы", "File": "Файл", "Status": "Статус", "Note": "Заметка", "manual_refresh": "ручное обновление", "first_observation": "первое наблюдение", "artifact_changed": "файл изменён", "batch_turns": "порог ходов", "batch_tokens": "порог токенов", "model_salience": "значимость модели", "Session Analysis": "Анализ сессии", "Observation": "Наблюдение", "Operating agenda": "Рабочая повестка", "Context map": "Карта контекста", "Next prompts": "Следующие запросы", "Turns": "Ходы", "Tokens": "Токены", "Reason": "Причина", "Abstract": "Аннотация", "No entries.": "Нет записей.", "Insight count by severity.": "Число инсайтов по важности.", "Session file artifacts.": "Файловые артефакты сессии.", "Coverage · storyline · severity": "Покрытие · сюжет · важность", "Trigger and context": "Триггер и контекст", "Key observations": "Ключевые наблюдения", "Decisions and actions": "Решения и действия", "Entities and follow-ups": "Сущности и продолжения" }
+    zh: { "Overview": "概览", "Session": "会话", "Language": "语言", "connecting…": "连接中…", "live": "实时", "reconnecting…": "重连中…", "Loading…": "加载中…", "No content yet.": "暂无内容。", "Failed to load view": "视图加载失败", "Action failed": "操作失败", "Candlestick": "K线", "Series": "序列", "Gauge": "仪表", "Custom": "自定义", "unknown": "未知", "Watch portfolio": "观察组合", "Refresh cadence": "刷新节奏", "Active watches": "活跃观察", "Recent findings": "最新发现", "Watches": "观察任务", "Findings": "发现", "Signals": "信号", "Watch": "观察", "Price action": "价格行为", "Signal mix": "信号结构", "Market brief": "市场简报", "Latest sentiment": "最新情绪", "Mentions": "提及", "Sentiment structure": "情绪结构", "Narrative pulse": "叙事脉搏", "New papers": "新论文", "Research pipeline": "研究管线", "Evidence stream": "证据流", "Executive brief": "执行摘要", "Storyline": "叙事线", "Insights": "洞察", "Action items": "行动项", "Decisions": "决策", "Open questions": "待回答问题", "Entities": "实体", "Suggested next prompts": "建议追问", "Timeline": "时间线", "Severity mix": "严重度结构", "alert": "警报", "notable": "重要", "info": "信息", "Observation status": "观察状态", "Refresh state": "刷新状态", "Refresh reason": "刷新原因", "Coverage": "覆盖率", "Artifacts": "副产物", "Observed context": "已观察上下文", "File artifacts": "文件副产物", "File": "文件", "Status": "状态", "Note": "说明", "manual_refresh": "手动刷新", "first_observation": "首次观察", "artifact_changed": "文件副产物变化", "batch_turns": "轮次阈值", "batch_tokens": "上下文阈值", "model_salience": "模型显著性", "Session Analysis": "会话分析", "Observation": "观察", "Operating agenda": "行动议程", "Context map": "上下文图谱", "Next prompts": "后续追问", "Turns": "轮次", "Tokens": "词元", "Reason": "原因", "Abstract": "摘要", "No entries.": "暂无条目。", "Insight count by severity.": "按严重度统计的洞察数。", "Session file artifacts.": "会话文件副产物。", "Coverage · storyline · severity": "覆盖率 · 叙事 · 严重度", "Trigger and context": "触发与上下文", "Key observations": "关键观察", "Decisions and actions": "决策与行动", "Entities and follow-ups": "实体与后续", "Extracted from this session's tool/file output (not model-generated).": "数据来自本次会话的工具/文件产物（非模型生成）。", "Signal flow": "信号流", "Subscribers": "订阅者", "Active triggers": "活跃触发器", "Buffer dropped": "缓冲丢弃", "Debounced": "去抖", "Live signal stream": "实时信号流", "Recent events (last 50)": "最近事件（最新50条）", "Active event-driven monitors": "活跃的事件驱动监视器", "Name": "名称", "Domain": "领域", "Trigger": "触发器", "Latest observation results": "最新观测结果" },
+    fr: { "Overview": "Vue d’ensemble", "Session": "Session", "Language": "Langue", "connecting…": "connexion…", "live": "direct", "reconnecting…": "reconnexion…", "Loading…": "chargement…", "No content yet.": "Aucun contenu.", "Failed to load view": "Échec du chargement", "Action failed": "Action échouée", "Watch": "Veille", "Watches": "Veilles", "Findings": "Constats", "Recent findings": "Constats récents", "Signals": "Signaux", "Insights": "Analyses", "Action items": "Actions", "Decisions": "Décisions", "Open questions": "Questions ouvertes", "Entities": "Entités", "Suggested next prompts": "Prochaines invites", "Executive brief": "Synthèse exécutive", "Storyline": "Narratif", "Timeline": "Chronologie", "Severity mix": "Mix de sévérité", "alert": "alerte", "notable": "notable", "info": "info", "Observation status": "Statut d’observation", "Refresh state": "État", "Refresh reason": "Raison", "Coverage": "Couverture", "Artifacts": "Artefacts", "Observed context": "Contexte observé", "File artifacts": "Fichiers", "File": "Fichier", "Status": "Statut", "Note": "Note", "manual_refresh": "actualisation manuelle", "first_observation": "première observation", "artifact_changed": "artefact modifié", "batch_turns": "seuil de tours", "batch_tokens": "seuil de jetons", "model_salience": "saillance modèle", "Session Analysis": "Analyse de session", "Observation": "Observation", "Operating agenda": "Programme d’action", "Context map": "Carte de contexte", "Next prompts": "Invites suivantes", "Turns": "Tours", "Tokens": "Jetons", "Reason": "Raison", "Abstract": "Résumé", "No entries.": "Aucune entrée.", "Insight count by severity.": "Nombre d’analyses par sévérité.", "Session file artifacts.": "Artefacts de fichiers de session.", "Coverage · storyline · severity": "Couverture · récit · sévérité", "Trigger and context": "Déclencheur et contexte", "Key observations": "Observations clés", "Decisions and actions": "Décisions et actions", "Entities and follow-ups": "Entités et suivis", "Signal flow": "Flux de signaux", "Subscribers": "Abonnés", "Active triggers": "Déclencheurs actifs", "Buffer dropped": "Tampon perdu", "Debounced": "Antirebond", "Live signal stream": "Flux de signaux en direct", "Recent events (last 50)": "Événements récents (50 derniers)", "Active event-driven monitors": "Moniteurs événementiels actifs", "Name": "Nom", "Domain": "Domaine", "Trigger": "Déclencheur", "Latest observation results": "Derniers résultats d'observation" },
+    es: { "Overview": "Resumen", "Session": "Sesión", "Language": "Idioma", "connecting…": "conectando…", "live": "en vivo", "reconnecting…": "reconectando…", "Loading…": "cargando…", "No content yet.": "Sin contenido.", "Failed to load view": "Error al cargar", "Action failed": "Acción fallida", "Watch": "Vigilancia", "Watches": "Vigilancias", "Findings": "Hallazgos", "Recent findings": "Hallazgos recientes", "Signals": "Señales", "Insights": "Ideas", "Action items": "Acciones", "Decisions": "Decisiones", "Open questions": "Preguntas abiertas", "Entities": "Entidades", "Suggested next prompts": "Siguientes preguntas", "Executive brief": "Resumen ejecutivo", "Storyline": "Narrativa", "Timeline": "Cronología", "Severity mix": "Mezcla de severidad", "alert": "alerta", "notable": "relevante", "info": "info", "Observation status": "Estado de observación", "Refresh state": "Estado", "Refresh reason": "Motivo", "Coverage": "Cobertura", "Artifacts": "Artefactos", "Observed context": "Contexto observado", "File artifacts": "Archivos", "File": "Archivo", "Status": "Estado", "Note": "Nota", "manual_refresh": "actualización manual", "first_observation": "primera observación", "artifact_changed": "artefacto cambiado", "batch_turns": "umbral de turnos", "batch_tokens": "umbral de tokens", "model_salience": "relevancia del modelo", "Session Analysis": "Análisis de sesión", "Observation": "Observación", "Operating agenda": "Agenda operativa", "Context map": "Mapa de contexto", "Next prompts": "Siguientes prompts", "Turns": "Turnos", "Tokens": "Tokens", "Reason": "Motivo", "Abstract": "Resumen", "No entries.": "Sin entradas.", "Insight count by severity.": "Recuento de hallazgos por severidad.", "Session file artifacts.": "Artefactos de archivos de sesión.", "Coverage · storyline · severity": "Cobertura · relato · severidad", "Trigger and context": "Disparador y contexto", "Key observations": "Observaciones clave", "Decisions and actions": "Decisiones y acciones", "Entities and follow-ups": "Entidades y seguimientos", "Signal flow": "Flujo de señales", "Subscribers": "Suscriptores", "Active triggers": "Disparadores activos", "Buffer dropped": "Buffer perdido", "Debounced": "Antirrebote", "Live signal stream": "Flujo de señales en vivo", "Recent events (last 50)": "Eventos recientes (últimos 50)", "Active event-driven monitors": "Monitores por eventos activos", "Name": "Nombre", "Domain": "Dominio", "Trigger": "Disparador", "Latest observation results": "Últimos resultados de observación" },
+    ar: { "Overview": "نظرة عامة", "Session": "الجلسة", "Language": "اللغة", "connecting…": "جارٍ الاتصال…", "live": "مباشر", "reconnecting…": "إعادة الاتصال…", "Loading…": "جارٍ التحميل…", "No content yet.": "لا يوجد محتوى بعد.", "Failed to load view": "فشل تحميل العرض", "Action failed": "فشل الإجراء", "Watch": "مراقبة", "Watches": "المراقبات", "Findings": "النتائج", "Recent findings": "أحدث النتائج", "Signals": "الإشارات", "Insights": "الرؤى", "Action items": "إجراءات", "Decisions": "قرارات", "Open questions": "أسئلة مفتوحة", "Entities": "كيانات", "Suggested next prompts": "أسئلة مقترحة", "Executive brief": "ملخص تنفيذي", "Storyline": "السرد", "Timeline": "الخط الزمني", "Severity mix": "توزيع الشدة", "alert": "تنبيه", "notable": "مهم", "info": "معلومة", "Observation status": "حالة المراقبة", "Refresh state": "حالة التحديث", "Refresh reason": "سبب التحديث", "Coverage": "التغطية", "Artifacts": "المخرجات", "Observed context": "السياق المرصود", "File artifacts": "ملفات", "File": "ملف", "Status": "الحالة", "Note": "ملاحظة", "manual_refresh": "تحديث يدوي", "first_observation": "أول مراقبة", "artifact_changed": "تغير ملف", "batch_turns": "حد الجولات", "batch_tokens": "حد الرموز", "model_salience": "أهمية النموذج", "Session Analysis": "تحليل الجلسة", "Observation": "الرصد", "Operating agenda": "خطة العمل", "Context map": "خريطة السياق", "Next prompts": "المطالبات التالية", "Turns": "الأدوار", "Tokens": "الرموز", "Reason": "السبب", "Abstract": "ملخص", "No entries.": "لا توجد إدخالات.", "Insight count by severity.": "عدد الرؤى حسب الخطورة.", "Session file artifacts.": "مخرجات ملفات الجلسة.", "Coverage · storyline · severity": "التغطية · السرد · الخطورة", "Trigger and context": "المُشغِّل والسياق", "Key observations": "ملاحظات رئيسية", "Decisions and actions": "القرارات والإجراءات", "Entities and follow-ups": "الكيانات والمتابعات", "Signal flow": "تدفق الإشارات", "Subscribers": "المشتركون", "Active triggers": "المُشغِّلات النشطة", "Buffer dropped": "ذاكرة مؤقتة مُسقَطة", "Debounced": "مُزال الارتداد", "Live signal stream": "تدفق الإشارات المباشر", "Recent events (last 50)": "الأحداث الأخيرة (آخر 50)", "Active event-driven monitors": "مراقبات حدثية نشطة", "Name": "الاسم", "Domain": "المجال", "Trigger": "المُشغِّل", "Latest observation results": "أحدث نتائج الرصد" },
+    ru: { "Overview": "Обзор", "Session": "Сессия", "Language": "Язык", "connecting…": "подключение…", "live": "онлайн", "reconnecting…": "переподключение…", "Loading…": "загрузка…", "No content yet.": "Пока нет данных.", "Failed to load view": "Не удалось загрузить", "Action failed": "Действие не выполнено", "Watch": "Наблюдение", "Watches": "Наблюдения", "Findings": "Находки", "Recent findings": "Последние находки", "Signals": "Сигналы", "Insights": "Инсайты", "Action items": "Действия", "Decisions": "Решения", "Open questions": "Открытые вопросы", "Entities": "Сущности", "Suggested next prompts": "Следующие запросы", "Executive brief": "Краткий обзор", "Storyline": "Сюжет", "Timeline": "Хронология", "Severity mix": "Структура важности", "alert": "тревога", "notable": "важно", "info": "инфо", "Observation status": "Статус наблюдения", "Refresh state": "Состояние", "Refresh reason": "Причина", "Coverage": "Покрытие", "Artifacts": "Артефакты", "Observed context": "Наблюдаемый контекст", "File artifacts": "Файлы", "File": "Файл", "Status": "Статус", "Note": "Заметка", "manual_refresh": "ручное обновление", "first_observation": "первое наблюдение", "artifact_changed": "файл изменён", "batch_turns": "порог ходов", "batch_tokens": "порог токенов", "model_salience": "значимость модели", "Session Analysis": "Анализ сессии", "Observation": "Наблюдение", "Operating agenda": "Рабочая повестка", "Context map": "Карта контекста", "Next prompts": "Следующие запросы", "Turns": "Ходы", "Tokens": "Токены", "Reason": "Причина", "Abstract": "Аннотация", "No entries.": "Нет записей.", "Insight count by severity.": "Число инсайтов по важности.", "Session file artifacts.": "Файловые артефакты сессии.", "Coverage · storyline · severity": "Покрытие · сюжет · важность", "Trigger and context": "Триггер и контекст", "Key observations": "Ключевые наблюдения", "Decisions and actions": "Решения и действия", "Entities and follow-ups": "Сущности и продолжения", "Signal flow": "Поток сигналов", "Subscribers": "Подписчики", "Active triggers": "Активные триггеры", "Buffer dropped": "Потери буфера", "Debounced": "Дебаунс", "Live signal stream": "Поток сигналов (live)", "Recent events (last 50)": "Последние события (50)", "Active event-driven monitors": "Активные событийные мониторы", "Name": "Имя", "Domain": "Домен", "Trigger": "Триггер", "Latest observation results": "Последние результаты наблюдений" }
   };
 
-  function t(key) { return (I18N[locale] && I18N[locale][key]) || key; }
+  const I18N_PATCH = {
+    en: {
+      "All": "All",
+      "connecting…": "connecting",
+      "live": "connected",
+      "reconnecting…": "reconnecting",
+      "seconds ago": "{count}s ago",
+      "minutes ago": "{count}m ago",
+      "hours ago": "{count}h ago",
+      "Showing {shown} of {total} recent events.": "Showing {shown} of {total} recent events.",
+      "Showing {shown} of {total} {family} events.": "Showing {shown} of {total} {family} events.",
+      "stale build": "stale build",
+      "stale_build_title": "This LeapBoard server (pid {pid}) predates the current source tree. Restart it to pick up recent changes.",
+      "Stream events": "Stream events", "Active watches": "Active watches", "Watch portfolio": "Watch portfolio", "Noise suppressed": "Noise suppressed", "Source dropped": "Source dropped", "Reorder pending": "Reorder pending",
+      "Signal health summary": "Signal health summary", "Ingress": "Ingress", "Pressure": "Pressure", "Recent event families": "Recent event families",
+      "Finding severity mix": "Finding severity mix", "Watch state mix": "Watch state mix", "Watch states": "Watch states", "Trigger coverage": "Trigger coverage",
+      "Latest daemon events · grouped by signal family · newest first.": "Latest daemon events · grouped by signal family · newest first.",
+      "Ingress fan-out, pipeline pressure, and recent dimensional mix.": "Ingress fan-out, pipeline pressure, and recent dimensional mix.",
+      "Event count by normalized family in the live ring buffer.": "Event count by normalized family in the live ring buffer.",
+      "Observation count by severity across recent findings.": "Observation count by severity across recent findings.",
+      "Current monitor lifecycle states.": "Current monitor lifecycle states.", "Active and completed event-driven monitors.": "Active and completed event-driven monitors.",
+      "Latest observation results.": "Latest observation results.", "Event patterns registered with the monitor event bridge.": "Event patterns registered with the monitor event bridge.",
+      "Triggers": "Triggers", "Watches": "Watches", "Pattern": "Pattern", "Triggered": "Triggered", "Last event": "Last event", "Value": "Value", "Dimension": "Dimension", "Signal": "Signal",
+      "armed": "armed", "done": "done", "suspended": "suspended", "yes": "yes", "no": "no",
+      "signal.family.fs": "fs", "signal.family.gateway": "gateway", "signal.family.ui": "ui", "signal.family.clipboard": "clipboard", "signal.family.app": "app", "signal.family.unknown": "unknown"
+    },
+    zh: {
+      "All": "全部",
+      "connecting…": "正在连接",
+      "live": "已连接",
+      "reconnecting…": "正在重连",
+      "seconds ago": "{count}秒前", "minutes ago": "{count}分钟前", "hours ago": "{count}小时前",
+      "Showing {shown} of {total} recent events.": "显示最近 {total} 个事件中的 {shown} 个。",
+      "Showing {shown} of {total} {family} events.": "显示 {total} 个{family}事件中的 {shown} 个。",
+      "stale build": "构建已过期", "stale_build_title": "LeapBoard 服务（pid {pid}）早于当前源码树启动。请重启以加载最近的更改。",
+      "Stream events": "流事件", "Active watches": "活跃观察", "Watch portfolio": "观察组合", "Noise suppressed": "已压制噪声", "Source dropped": "源丢弃", "Reorder pending": "重排待处理",
+      "Signal health summary": "信号健康摘要", "Ingress": "输入", "Pressure": "压力", "Recent event families": "最近事件类别",
+      "Finding severity mix": "发现严重度分布", "Watch state mix": "观察状态分布", "Watch states": "观察状态", "Trigger coverage": "触发覆盖",
+      "Latest daemon events · grouped by signal family · newest first.": "最新 daemon 事件 · 按信号类别分组 · 最新优先。",
+      "Ingress fan-out, pipeline pressure, and recent dimensional mix.": "输入扇出、管线压力和最近维度分布。",
+      "Event count by normalized family in the live ring buffer.": "实时环形缓冲区中按标准化类别统计的事件数。",
+      "Observation count by severity across recent findings.": "最近发现中按严重度统计的观察数。",
+      "Current monitor lifecycle states.": "当前监视器生命周期状态。", "Active and completed event-driven monitors.": "活跃和已完成的事件驱动监视器。",
+      "Latest observation results.": "最新观察结果。", "Event patterns registered with the monitor event bridge.": "监视器事件桥注册的事件模式。",
+      "Triggers": "触发器", "Watches": "观察任务", "Pattern": "模式", "Triggered": "已触发", "Last event": "最后事件", "Value": "值", "Dimension": "维度", "Signal": "信号",
+      "armed": "已布防", "done": "完成", "suspended": "已暂停", "yes": "是", "no": "否",
+      "signal.family.fs": "文件", "signal.family.gateway": "网关", "signal.family.ui": "界面", "signal.family.clipboard": "剪贴板", "signal.family.app": "应用", "signal.family.unknown": "未知"
+    },
+    fr: {
+      "All": "Tout", "connecting…": "connexion", "live": "connecté", "reconnecting…": "reconnexion", "seconds ago": "il y a {count} s", "minutes ago": "il y a {count} min", "hours ago": "il y a {count} h",
+      "Showing {shown} of {total} recent events.": "Affichage de {shown} sur {total} événements récents.", "Showing {shown} of {total} {family} events.": "Affichage de {shown} sur {total} événements {family}.",
+      "stale build": "build obsolète", "stale_build_title": "Ce serveur LeapBoard (pid {pid}) est antérieur à l'arbre source actuel. Redémarrez-le pour charger les changements récents.",
+      "Stream events": "Événements de flux", "Active watches": "Veilles actives", "Watch portfolio": "Portefeuille de veilles", "Noise suppressed": "Bruit supprimé", "Source dropped": "Source rejetée", "Reorder pending": "Réordonnancement en attente",
+      "Signal health summary": "Résumé santé des signaux", "Ingress": "Entrée", "Pressure": "Pression", "Recent event families": "Familles d'événements récentes", "Finding severity mix": "Répartition des constats", "Watch state mix": "États des veilles", "Watch states": "États des veilles", "Trigger coverage": "Couverture des déclencheurs",
+      "Latest daemon events · grouped by signal family · newest first.": "Derniers événements daemon · groupés par famille · plus récents d'abord.", "Ingress fan-out, pipeline pressure, and recent dimensional mix.": "Diffusion d'entrée, pression du pipeline et dimensions récentes.", "Event count by normalized family in the live ring buffer.": "Nombre d'événements par famille normalisée dans le tampon live.", "Observation count by severity across recent findings.": "Nombre d'observations par sévérité dans les constats récents.", "Current monitor lifecycle states.": "États courants du cycle de vie des moniteurs.", "Active and completed event-driven monitors.": "Moniteurs événementiels actifs et terminés.", "Latest observation results.": "Derniers résultats d'observation.", "Event patterns registered with the monitor event bridge.": "Motifs d'événements enregistrés dans le pont des moniteurs.",
+      "Triggers": "Déclencheurs", "Watches": "Veilles", "Pattern": "Motif", "Triggered": "Déclenché", "Last event": "Dernier événement", "Value": "Valeur", "Dimension": "Dimension", "Signal": "Signal", "armed": "armé", "done": "terminé", "suspended": "suspendu", "yes": "oui", "no": "non",
+      "signal.family.fs": "fichiers", "signal.family.gateway": "passerelle", "signal.family.ui": "interface", "signal.family.clipboard": "presse-papiers", "signal.family.app": "application", "signal.family.unknown": "inconnu"
+    },
+    es: {
+      "All": "Todo", "connecting…": "conectando", "live": "conectado", "reconnecting…": "reconectando", "seconds ago": "hace {count} s", "minutes ago": "hace {count} min", "hours ago": "hace {count} h",
+      "Showing {shown} of {total} recent events.": "Mostrando {shown} de {total} eventos recientes.", "Showing {shown} of {total} {family} events.": "Mostrando {shown} de {total} eventos {family}.",
+      "stale build": "build obsoleto", "stale_build_title": "Este servidor LeapBoard (pid {pid}) es anterior al árbol de código actual. Reinícialo para cargar los cambios recientes.",
+      "Stream events": "Eventos de flujo", "Active watches": "Vigilancias activas", "Watch portfolio": "Cartera de vigilancias", "Noise suppressed": "Ruido suprimido", "Source dropped": "Fuente descartada", "Reorder pending": "Reordenación pendiente",
+      "Signal health summary": "Resumen de salud de señales", "Ingress": "Entrada", "Pressure": "Presión", "Recent event families": "Familias de eventos recientes", "Finding severity mix": "Mezcla de severidad", "Watch state mix": "Estados de vigilancia", "Watch states": "Estados de vigilancia", "Trigger coverage": "Cobertura de disparadores",
+      "Latest daemon events · grouped by signal family · newest first.": "Últimos eventos del daemon · agrupados por familia · recientes primero.", "Ingress fan-out, pipeline pressure, and recent dimensional mix.": "Difusión de entrada, presión del pipeline y mezcla dimensional reciente.", "Event count by normalized family in the live ring buffer.": "Conteo de eventos por familia normalizada en el búfer live.", "Observation count by severity across recent findings.": "Conteo de observaciones por severidad en hallazgos recientes.", "Current monitor lifecycle states.": "Estados actuales del ciclo de vida de monitores.", "Active and completed event-driven monitors.": "Monitores por eventos activos y completados.", "Latest observation results.": "Últimos resultados de observación.", "Event patterns registered with the monitor event bridge.": "Patrones de eventos registrados en el puente de monitores.",
+      "Triggers": "Disparadores", "Watches": "Vigilancias", "Pattern": "Patrón", "Triggered": "Disparado", "Last event": "Último evento", "Value": "Valor", "Dimension": "Dimensión", "Signal": "Señal", "armed": "armado", "done": "terminado", "suspended": "suspendido", "yes": "sí", "no": "no",
+      "signal.family.fs": "archivos", "signal.family.gateway": "gateway", "signal.family.ui": "interfaz", "signal.family.clipboard": "portapapeles", "signal.family.app": "aplicación", "signal.family.unknown": "desconocido"
+    },
+    ar: {
+      "All": "الكل", "connecting…": "جارٍ الاتصال", "live": "متصل", "reconnecting…": "جارٍ إعادة الاتصال", "seconds ago": "قبل {count} ث", "minutes ago": "قبل {count} د", "hours ago": "قبل {count} س",
+      "Showing {shown} of {total} recent events.": "عرض {shown} من أصل {total} حدثاً حديثاً.", "Showing {shown} of {total} {family} events.": "عرض {shown} من أصل {total} من أحداث {family}.",
+      "stale build": "بناء قديم", "stale_build_title": "خادم LeapBoard (pid {pid}) أقدم من شجرة المصدر الحالية. أعد تشغيله لتحميل التغييرات الأخيرة.",
+      "Stream events": "أحداث التدفق", "Active watches": "المراقبات النشطة", "Watch portfolio": "محفظة المراقبات", "Noise suppressed": "الضجيج المحجوب", "Source dropped": "مصدر مُسقط", "Reorder pending": "إعادة الترتيب معلقة",
+      "Signal health summary": "ملخص صحة الإشارات", "Ingress": "الدخول", "Pressure": "الضغط", "Recent event families": "عائلات الأحداث الأخيرة", "Finding severity mix": "توزيع شدة النتائج", "Watch state mix": "توزيع حالات المراقبة", "Watch states": "حالات المراقبة", "Trigger coverage": "تغطية المُشغّلات",
+      "Latest daemon events · grouped by signal family · newest first.": "أحدث أحداث daemon · مجمعة حسب عائلة الإشارة · الأحدث أولاً.", "Ingress fan-out, pipeline pressure, and recent dimensional mix.": "تفرع الدخول وضغط الأنبوب وتوزيع الأبعاد الأخير.", "Event count by normalized family in the live ring buffer.": "عدد الأحداث حسب العائلة الموحدة في المخزن الحلقي المباشر.", "Observation count by severity across recent findings.": "عدد الملاحظات حسب الشدة في النتائج الأخيرة.", "Current monitor lifecycle states.": "حالات دورة حياة المراقبات الحالية.", "Active and completed event-driven monitors.": "المراقبات الحدثية النشطة والمكتملة.", "Latest observation results.": "أحدث نتائج الرصد.", "Event patterns registered with the monitor event bridge.": "أنماط الأحداث المسجلة في جسر أحداث المراقبة.",
+      "Triggers": "المُشغّلات", "Watches": "المراقبات", "Pattern": "النمط", "Triggered": "تم التشغيل", "Last event": "آخر حدث", "Value": "القيمة", "Dimension": "البعد", "Signal": "الإشارة", "armed": "مسلح", "done": "منتهي", "suspended": "معلق", "yes": "نعم", "no": "لا",
+      "signal.family.fs": "ملفات", "signal.family.gateway": "بوابة", "signal.family.ui": "واجهة", "signal.family.clipboard": "الحافظة", "signal.family.app": "تطبيق", "signal.family.unknown": "مجهول"
+    },
+    ru: {
+      "All": "Все", "connecting…": "подключение", "live": "подключено", "reconnecting…": "переподключение", "seconds ago": "{count} с назад", "minutes ago": "{count} мин назад", "hours ago": "{count} ч назад",
+      "Showing {shown} of {total} recent events.": "Показано {shown} из {total} последних событий.", "Showing {shown} of {total} {family} events.": "Показано {shown} из {total} событий {family}.",
+      "stale build": "устаревшая сборка", "stale_build_title": "Сервер LeapBoard (pid {pid}) старее текущего дерева исходников. Перезапустите его, чтобы применить изменения.",
+      "Stream events": "События потока", "Active watches": "Активные наблюдения", "Watch portfolio": "Портфель наблюдений", "Noise suppressed": "Шум подавлен", "Source dropped": "Источник отброшен", "Reorder pending": "Ожидает сортировки",
+      "Signal health summary": "Сводка здоровья сигналов", "Ingress": "Вход", "Pressure": "Давление", "Recent event families": "Недавние семейства событий", "Finding severity mix": "Важность находок", "Watch state mix": "Состояния наблюдений", "Watch states": "Состояния наблюдений", "Trigger coverage": "Покрытие триггеров",
+      "Latest daemon events · grouped by signal family · newest first.": "Последние события daemon · по семействам сигналов · новые первыми.", "Ingress fan-out, pipeline pressure, and recent dimensional mix.": "Входной fan-out, давление конвейера и недавнее распределение измерений.", "Event count by normalized family in the live ring buffer.": "Число событий по нормализованным семействам в live-буфере.", "Observation count by severity across recent findings.": "Число наблюдений по важности среди последних находок.", "Current monitor lifecycle states.": "Текущие состояния жизненного цикла мониторов.", "Active and completed event-driven monitors.": "Активные и завершённые событийные мониторы.", "Latest observation results.": "Последние результаты наблюдений.", "Event patterns registered with the monitor event bridge.": "Шаблоны событий, зарегистрированные в мосте мониторов.",
+      "Triggers": "Триггеры", "Watches": "Наблюдения", "Pattern": "Шаблон", "Triggered": "Сработал", "Last event": "Последнее событие", "Value": "Значение", "Dimension": "Измерение", "Signal": "Сигнал", "armed": "взведено", "done": "готово", "suspended": "приостановлено", "yes": "да", "no": "нет",
+      "signal.family.fs": "файлы", "signal.family.gateway": "шлюз", "signal.family.ui": "интерфейс", "signal.family.clipboard": "буфер", "signal.family.app": "приложение", "signal.family.unknown": "неизвестно"
+    }
+  };
+  Object.entries(I18N_PATCH).forEach(([lang, patch]) => {
+    I18N[lang] = Object.assign({}, I18N.en || {}, I18N[lang] || {}, patch);
+  });
+
+  function t(key) { return (I18N[locale] && I18N[locale][key]) || (I18N.en && I18N.en[key]) || key; }
   function tx(value) { return typeof value === "string" ? t(value) : value; }
+  function fmt(key, vars) {
+    return t(key).replace(/\{(\w+)\}/g, (_m, name) => (vars && vars[name] != null ? String(vars[name]) : ""));
+  }
 
   function applyLocale() {
     document.documentElement.lang = locale === "zh" ? "zh-CN" : locale;
@@ -37,6 +190,12 @@
     document.querySelectorAll("[data-i18n]").forEach((node) => { node.textContent = t(node.dataset.i18n); });
   }
 
+  function setConnectionStatus(key) {
+    if (!statusEl) return;
+    statusEl.dataset.i18n = key;
+    statusEl.textContent = t(key);
+  }
+
   function api(path) {
     const url = new URL(path, location.origin);
     url.searchParams.set("token", TOKEN);
@@ -44,6 +203,7 @@
   }
 
   async function fetchView(intent) {
+    var prevTemplate = current.template;
     current = Object.assign({}, current, intent || {});
     const url = new URL("/api/view", location.origin);
     url.searchParams.set("token", TOKEN);
@@ -54,16 +214,51 @@
       const spec = await resp.json();
       render(spec);
       renderNav(spec.meta || {});
+      renderServerHealth(spec.meta || {});
+      // Manage signal auto-refresh lifecycle on template switch
+      var newTemplate = (spec.meta && spec.meta.active_template) || current.template || "";
+      if (newTemplate === "signals") {
+        startSignalAutoRefresh();
+        injectSignalRefreshBtn();
+      } else if (prevTemplate === "signals" && newTemplate !== "signals") {
+        stopSignalAutoRefresh();
+      }
     } catch (err) {
       rootEl.innerHTML = '<div class="empty">' + esc(t("Failed to load view") + ": " + String(err)) + "</div>";
     }
   }
 
+  // Long-lived-process staleness: warns when this dashboard server process
+  // predates the current source tree (see leapflow.utils.build_info). Purely
+  // informational — the page still renders whatever data the stale process
+  // returns; this just tells the developer *why* it might look wrong.
+  function renderServerHealth(meta) {
+    if (!statusEl) return;
+    var old = document.getElementById("server-stale-badge");
+    if (old) old.remove();
+    var server = meta.server;
+    if (!server || server.stale !== true) return;
+    var build = server.build || {};
+    var badge = el("span", "server-stale-badge");
+    badge.id = "server-stale-badge";
+    badge.textContent = "\u26a0 " + t("stale build");
+    badge.title = fmt("stale_build_title", { pid: build.pid || "?" });
+    statusEl.insertAdjacentElement("afterend", badge);
+  }
+
   // Template switcher: the current session, rendered through each lens.
   function renderNav(meta) {
     const nav = document.getElementById("nav");
     if (!nav) return;
-    const names = Array.isArray(meta.templates) ? meta.templates : [];
+    const hidden = new Set(Array.isArray(meta.hidden_templates) ? meta.hidden_templates : []);
+    HIDDEN_NAV_TEMPLATES.forEach((name) => hidden.add(name));
+    const seen = new Set();
+    const names = (Array.isArray(meta.templates) ? meta.templates : []).filter((name) => {
+      name = String(name || "");
+      if (!name || hidden.has(name) || seen.has(name)) return false;
+      seen.add(name);
+      return true;
+    });
     const active = meta.active_template || "";
     nav.innerHTML = "";
     names.forEach((name) => {
@@ -129,6 +324,7 @@
       const d = el("div", "mini-chart card"); d.appendChild(el("div", "card-title", t("Candlestick")));
       d.appendChild(el("div", "chart-placeholder", esc(data.length + " " + t("Series")))); return d; },
     gauge: (p) => renderGaugeValue(p.label || "Gauge", p.data),
+    signalTimeline: renderSignalTimeline,
   };
 
   function asArray(value) { return Array.isArray(value) ? value : []; }
@@ -155,6 +351,96 @@
   function gridCols(props) { const c = _clampInt(props.cols, 2, 6); return c ? " cols-" + c : ""; }
   function applySpan(dom, props) { const s = _clampInt(props.span, 2, 4); if (s && dom && dom.classList) dom.classList.add("span-" + s); }
 
+  function signalFamily(item) {
+    var raw = String((item && (item.family || item.event_type || item.title)) || "unknown").replace(":", ".");
+    return raw.split(".", 1)[0] || "unknown";
+  }
+
+  function signalTimestamp(item) {
+    var raw = Number(item && item.ts);
+    if (!Number.isFinite(raw) || raw <= 0) return 0;
+    return raw < 100000000000 ? raw * 1000 : raw;
+  }
+
+  function signalFamilyLabel(family) {
+    const key = "signal.family." + String(family || "unknown");
+    const label = t(key);
+    return label === key ? String(family || "unknown") : label;
+  }
+
+  function signalTimeLabel(item) {
+    var ms = signalTimestamp(item);
+    if (!ms) return "--:--:--";
+    var d = new Date(ms);
+    var clock = d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+    var age = Math.max(0, Date.now() - ms);
+    if (age < 60000) return clock + " · " + fmt("seconds ago", { count: Math.max(0, Math.round(age / 1000)) });
+    if (age < 3600000) return clock + " · " + fmt("minutes ago", { count: Math.round(age / 60000) });
+    return clock + " · " + fmt("hours ago", { count: Math.round(age / 3600000) });
+  }
+
+  function normalizeSignalItems(data) {
+    return asArray(data).filter((it) => it && typeof it === "object")
+      .map((it) => Object.assign({}, it, { family: signalFamily(it), _ts: signalTimestamp(it) }))
+      .sort((a, b) => (b._ts || 0) - (a._ts || 0));
+  }
+
+  function signalCategories(items) {
+    const counts = {}; items.forEach((it) => { counts[it.family] = (counts[it.family] || 0) + 1; });
+    return [{ key: "all", label: t("All"), count: items.length }]
+      .concat(Object.keys(counts).sort().map((key) => ({ key, label: signalFamilyLabel(key), count: counts[key] })));
+  }
+
+  function renderSignalTimeline(props) {
+    const box = el("div", "signal-timeline");
+    box._signalTimelineOptions = { maxItems: _clampInt(props.max_items || props.maxItems || 12, 1, 24) || 12 };
+    renderSignalTimelineInto(box, props.data || []);
+    window._signalStream = normalizeSignalItems(props.data || []);
+    return box;
+  }
+
+  function renderSignalTimelineInto(box, data) {
+    const opts = box._signalTimelineOptions || { maxItems: 12 };
+    const items = normalizeSignalItems(data);
+    const categories = signalCategories(items);
+    var active = window._signalTimelineActiveFamily || box.dataset.activeFamily || "all";
+    if (!categories.some((c) => c.key === active)) active = "all";
+    window._signalTimelineActiveFamily = active;
+    box.dataset.activeFamily = active;
+    box.innerHTML = "";
+    if (!items.length) { box.appendChild(el("div", "empty-inline", esc(t("No entries.")))); return box; }
+
+    const tabs = el("div", "signal-tabs");
+    categories.forEach((cat) => {
+      const btn = el("button", "signal-tab" + (cat.key === active ? " active" : ""));
+      btn.type = "button"; btn.textContent = cat.label + " " + cat.count;
+      btn.addEventListener("click", () => { window._signalTimelineActiveFamily = cat.key; renderSignalTimelineInto(box, items); });
+      tabs.appendChild(btn);
+    });
+    box.appendChild(tabs);
+
+    const filtered = active === "all" ? items : items.filter((it) => it.family === active);
+    const shown = filtered.slice(0, opts.maxItems);
+    const list = el("div", "signal-stream-list timeline");
+    shown.forEach((it) => {
+      const row = el("div", "signal-row timeline-item sev-" + severityOf(it));
+      const meta = el("div", "signal-event-meta");
+      meta.appendChild(el("span", "signal-time", esc(signalTimeLabel(it))));
+      meta.appendChild(el("span", "signal-family", esc(signalFamilyLabel(it.family))));
+      row.appendChild(meta);
+      row.appendChild(el("div", "timeline-title signal-type", esc(it.event_type || it.title || "")));
+      if (it.source || it.summary) row.appendChild(el("div", "summary signal-source", esc(it.source || it.summary)));
+      list.appendChild(row);
+    });
+    box.appendChild(list);
+    const footer = el("div", "signal-stream-footer");
+    footer.textContent = active === "all"
+      ? fmt("Showing {shown} of {total} recent events.", { shown: shown.length, total: filtered.length })
+      : fmt("Showing {shown} of {total} {family} events.", { shown: shown.length, total: filtered.length, family: signalFamilyLabel(active) });
+    box.appendChild(footer);
+    return box;
+  }
+
   // Format the storyline like a paper abstract: bold lead-in sentence + body.
   function renderAbstract(text) {
     const s = String(text == null ? "" : text).trim();
@@ -219,7 +505,7 @@
     const max = Math.max(1, ...rows.map((r) => r.value));
     rows.forEach((row) => {
       const line = el("div", "bar-row");
-      line.appendChild(el("span", "bar-label", esc(row.label)));
+      line.appendChild(el("span", "bar-label", esc(tx(row.label))));
       const track = el("span", "bar-track");
       const fill = el("span", "bar-fill" + (severity ? " sev-" + row.key : "")); fill.style.width = Math.round((row.value / max) * 100) + "%";
       track.appendChild(fill); line.appendChild(track); line.appendChild(el("span", "bar-value", esc(row.value))); d.appendChild(line);
@@ -314,7 +600,7 @@
     if (p.caption) table.appendChild(tableCaption(p.caption));
     const head = document.createElement("thead"); const headRow = document.createElement("tr");
     cols.forEach((c) => headRow.appendChild(el("th", null, esc(tx(c.label || c.key || c))))); head.appendChild(headRow); table.appendChild(head);
-    const body = document.createElement("tbody"); rows.forEach((row) => { const tr = document.createElement("tr"); cols.forEach((c) => tr.appendChild(el("td", null, esc(row && row[c.key || c] != null ? row[c.key || c] : "")))); body.appendChild(tr); }); table.appendChild(body); return table;
+    const body = document.createElement("tbody"); rows.forEach((row) => { const tr = document.createElement("tr"); cols.forEach((c) => { const v = row && row[c.key || c] != null ? row[c.key || c] : ""; tr.appendChild(el("td", null, esc(tx(v)))); }); body.appendChild(tr); }); table.appendChild(body); return table;
   }
 
   function renderTimeline(node) {
@@ -423,16 +709,41 @@
   function connectWS() {
     const proto = location.protocol === "https:" ? "wss" : "ws";
     const ws = new WebSocket(proto + "://" + location.host + "/ws?token=" + encodeURIComponent(TOKEN));
-    ws.onopen = () => { statusEl.textContent = t("live"); };
-    ws.onclose = () => { statusEl.textContent = t("reconnecting…"); setTimeout(connectWS, 3000); };
+    ws.onopen = () => { setConnectionStatus("live"); };
+    ws.onclose = () => { setConnectionStatus("reconnecting…"); setTimeout(connectWS, 3000); };
     ws.onmessage = (ev) => {
       let msg; try { msg = JSON.parse(ev.data); } catch (_) { return; }
       if (msg.type === "monitor.finding") { toast(msg.payload || {}); fetchView(); }
       else if (msg.type === "watch.state") { fetchView(); }
+      else if (msg.type === "signal.stream") {
+        // Append to local signal stream buffer (max 50)
+        if (!window._signalStream) window._signalStream = [];
+        var payload = msg.payload || {};
+        window._signalStream.push(payload);
+        if (window._signalStream.length > 50) window._signalStream.shift();
+        updateSignalTimeline(window._signalStream);
+        // Increment live event counter
+        incrementSignalCounter();
+      }
       else if (msg.type === "view.replace" && msg.spec) { render(msg.spec); }
     };
   }
 
+  function updateSignalTimeline(stream) {
+    if (current.template !== "signals") return;
+    var custom = document.querySelector(".signal-timeline");
+    if (custom) { renderSignalTimelineInto(custom, stream); return; }
+    var container = document.querySelector(".timeline");
+    if (!container) return;
+    container.innerHTML = "";
+    normalizeSignalItems(stream).slice(0, 12).forEach(function (item) {
+      var row = el("div", "timeline-item sev-info");
+      row.appendChild(el("div", "timeline-title", esc(item.event_type || item.title || "")));
+      if (item.source || item.summary) row.appendChild(el("div", "summary", esc(item.source || item.summary)));
+      container.appendChild(row);
+    });
+  }
+
   if (localeEl) {
     localeEl.addEventListener("change", () => {
       locale = localeEl.value || "en";
diff --git a/src/leapflow/dashboard/static/index.html b/src/leapflow/dashboard/static/index.html
index 2c86f78..c86b214 100644
--- a/src/leapflow/dashboard/static/index.html
+++ b/src/leapflow/dashboard/static/index.html
@@ -7,7 +7,7 @@
   <link rel="preconnect" href="https://fonts.googleapis.com" />
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700;800&family=Source+Serif+4:opsz,wght@8..60,400;8..60,600&display=swap" rel="stylesheet" />
-  <link rel="stylesheet" href="/static/styles.css" />
+  <link rel="stylesheet" href="/static/styles.css?v=status-i18n-20260808" />
 </head>
 <body>
   <header class="topbar">
@@ -30,6 +30,6 @@
   </header>
   <main id="root" class="root"><div class="empty" data-i18n="Loading…">Loading…</div></main>
   <div id="toasts" class="toasts"></div>
-  <script src="/static/app.js"></script>
+  <script src="/static/app.js?v=status-i18n-20260808"></script>
 </body>
 </html>
diff --git a/src/leapflow/dashboard/static/styles.css b/src/leapflow/dashboard/static/styles.css
index f5663e6..0e17d1e 100644
--- a/src/leapflow/dashboard/static/styles.css
+++ b/src/leapflow/dashboard/static/styles.css
@@ -51,6 +51,10 @@ body {
   border-radius: 0; padding: 3px 7px; font-size: 0.85rem;
 }
 .status { margin-left: auto; color: var(--muted); font-size: 0.85rem; font-variant-numeric: tabular-nums; }
+.server-stale-badge {
+  color: var(--alert); font-size: 0.79rem; border: 1px solid var(--alert);
+  padding: 1px 6px; cursor: help;
+}
 
 /* ── Page scaffold + numbering counters ──────────────────────────────────── */
 .root { padding: 18px 22px 40px; max-width: 1480px; margin: 0 auto; }
@@ -61,7 +65,11 @@ body {
   margin: 2px 0 14px; padding-bottom: 8px; border-bottom: 2px solid var(--ink);
 }
 
-/* ── Sections (Swiss numeric index + uppercase label) ────────────────────── */
+/* Title controls are scoped to the heading only. They must never turn the page
+   container into a flex row, or the dashboard columns collapse sideways. */
+.page-title.with-actions, .section-title.with-actions { display: flex; align-items: center; gap: 6px; }
+.page-title.with-actions .refresh-btn, .section-title.with-actions .refresh-btn { margin-inline-start: auto; }
+
 .section { margin-bottom: 18px; }
 .section-title {
   color: var(--ink); font-size: 0.85rem; letter-spacing: .13em; text-transform: uppercase;
@@ -76,11 +84,15 @@ body {
 
 /* ── Layout primitives (dense modular grid) ──────────────────────────────── */
 .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); gap: 9px; align-items: start; }
+.grid > * { min-width: 0; }
 .grid.cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
 .grid.cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
 .grid.cols-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
 .span-2 { grid-column: span 2; }
 .span-3 { grid-column: span 3; }
+@media (max-width: 1100px) {
+  .grid.cols-3, .grid.cols-4 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+}
 @media (max-width: 760px) {
   .grid, .grid[class*="cols-"] { grid-template-columns: 1fr; }
   [class*="span-"] { grid-column: auto; }
@@ -176,13 +188,30 @@ body {
 .timeline-item.sev-alert::before { background: var(--alert); }
 .timeline-item.sev-notable::before { background: var(--notable); }
 .timeline-title { font-weight: 600; }
+.signal-timeline { border: 1px solid var(--line); background: var(--panel); padding: 8px 10px; }
+.signal-tabs { display: flex; flex-wrap: wrap; gap: 5px; margin-bottom: 8px; }
+.signal-tab {
+  padding: 3px 8px; font-size: 0.78rem; color: var(--muted); border: 1px solid var(--line);
+  background: var(--panel); text-transform: uppercase; letter-spacing: .06em;
+}
+.signal-tab.active { color: var(--accent); border-color: var(--accent); }
+.signal-stream-list { gap: 6px; }
+.signal-row { padding-top: 5px; padding-bottom: 5px; }
+.signal-event-meta { display: flex; gap: 6px; align-items: center; margin-bottom: 1px; }
+.signal-time, .signal-family {
+  color: var(--muted); font-size: 0.76rem; letter-spacing: .04em; font-variant-numeric: tabular-nums;
+}
+.signal-family { color: var(--info); text-transform: uppercase; }
+.signal-type { font-size: 0.92rem; }
+.signal-source { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 100%; }
+.signal-stream-footer { margin-top: 7px; color: var(--muted); font-size: 0.8rem; border-top: 1px solid var(--line); padding-top: 5px; }
 .progress { height: 8px; background: var(--track); border-radius: 0; overflow: hidden; margin-top: 9px; }
 .progress-fill { display: block; height: 100%; background: var(--accent); border-radius: 0; }
 
 /* ── Tables (dense academic rules + tabular figures) ─────────────────────── */
-table { width: 100%; border-collapse: collapse; font-variant-numeric: tabular-nums; }
-.data-table { font-size: 0.85rem; }
-th, td { text-align: left; padding: 3px 7px; border-bottom: 1px solid var(--line); }
+table { width: 100%; border-collapse: collapse; table-layout: fixed; font-variant-numeric: tabular-nums; }
+.data-table { font-size: 0.85rem; min-width: 0; }
+th, td { text-align: left; padding: 3px 7px; border-bottom: 1px solid var(--line); overflow-wrap: anywhere; }
 thead th { border-bottom: 1.5px solid var(--ink); }
 th { color: var(--muted); font-weight: 600; font-size: 0.81rem; letter-spacing: .04em; text-transform: uppercase; position: sticky; top: 0; background: var(--panel); }
 caption { caption-side: top; text-align: left; color: var(--muted); font-size: 0.81rem; padding-bottom: 5px; }
@@ -216,3 +245,23 @@ button:hover { border-color: var(--accent); color: var(--accent); }
 }
 .toast.sev-alert { border-left-color: var(--alert); }
 .toast.sev-notable { border-left-color: var(--notable); }
+
+/* ── Signal refresh button + counter badge ──────────────────────────────────────── */
+.refresh-btn {
+  background: none; border: 1px solid var(--line); border-radius: 0;
+  cursor: pointer; font-size: 0.82rem; margin-inline-start: 6px;
+  padding: 1px 5px; color: var(--muted); vertical-align: middle;
+  transition: border-color .15s, color .15s, opacity .15s;
+  line-height: 1;
+}
+.refresh-btn:hover { border-color: var(--accent); color: var(--accent); }
+.refresh-btn:disabled, .refresh-btn.refreshing {
+  opacity: .45; cursor: default; pointer-events: none;
+}
+.refresh-btn.refreshing { animation: spin-once .5s linear; }
+@keyframes spin-once { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
+.signal-counter-badge {
+  display: inline-block; margin-inline-start: 5px; padding: 1px 5px;
+  border: 1px solid var(--line); font-size: 0.7rem; font-variant-numeric: tabular-nums;
+  color: var(--muted); vertical-align: middle;
+}
diff --git a/src/leapflow/dashboard/templates.py b/src/leapflow/dashboard/templates.py
index 5208a24..3f300ee 100644
--- a/src/leapflow/dashboard/templates.py
+++ b/src/leapflow/dashboard/templates.py
@@ -19,6 +19,7 @@
 _FULL_RE = re.compile(r"^\{\{\s*(.+?)\s*\}\}$")
 _PART_RE = re.compile(r"\{\{\s*(.+?)\s*\}\}")
 _TEMPLATE_ID_RE = re.compile(r"[^a-z0-9._-]+")
+_ALWAYS_HIDDEN_TEMPLATE_NAMES = frozenset({"finance", "research", "sentiment"})
 
 
 def sanitize_template_id(raw: str) -> str:
@@ -196,6 +197,23 @@ def names(self) -> list[str]:
                     found.add(path.stem)
         return sorted(found)
 
+    def visible_names(self) -> list[str]:
+        """Return template names excluding templates hidden from navigation."""
+        return [name for name in self.names() if not self._is_hidden(name)]
+
+    def hidden_names(self) -> list[str]:
+        """Return template names that must not appear in navigation."""
+        return [name for name in self.names() if self._is_hidden(name)]
+
+    def _is_hidden(self, name: str) -> bool:
+        """Check whether a template is hidden from the navigation switcher."""
+        if name in _ALWAYS_HIDDEN_TEMPLATE_NAMES:
+            return True
+        raw = self.load(name)
+        if raw is None:
+            return False
+        return bool(raw.get("hidden"))
+
     def load(self, name: str) -> Optional[dict[str, Any]]:
         """Load a raw template dict by name, or None when not found."""
         import yaml
diff --git a/src/leapflow/dashboard/templates/finance.yaml b/src/leapflow/dashboard/templates/finance.yaml
index ab23dd5..4fd310b 100644
--- a/src/leapflow/dashboard/templates/finance.yaml
+++ b/src/leapflow/dashboard/templates/finance.yaml
@@ -1,5 +1,6 @@
 template: finance
 version: 1
+hidden: true
 title: "{{ title }}"
 domain: finance
 meta:
diff --git a/src/leapflow/dashboard/templates/research.yaml b/src/leapflow/dashboard/templates/research.yaml
index 9c9aeb6..51b6518 100644
--- a/src/leapflow/dashboard/templates/research.yaml
+++ b/src/leapflow/dashboard/templates/research.yaml
@@ -1,5 +1,6 @@
 template: research
 version: 1
+hidden: true
 title: "{{ title }}"
 domain: research
 meta:
diff --git a/src/leapflow/dashboard/templates/sentiment.yaml b/src/leapflow/dashboard/templates/sentiment.yaml
index 7906621..eb3bcca 100644
--- a/src/leapflow/dashboard/templates/sentiment.yaml
+++ b/src/leapflow/dashboard/templates/sentiment.yaml
@@ -1,5 +1,6 @@
 template: sentiment
 version: 1
+hidden: true
 title: "{{ title }}"
 domain: sentiment
 meta:
diff --git a/src/leapflow/dashboard/templates/signals.yaml b/src/leapflow/dashboard/templates/signals.yaml
new file mode 100644
index 0000000..32031e8
--- /dev/null
+++ b/src/leapflow/dashboard/templates/signals.yaml
@@ -0,0 +1,221 @@
+# Signal Flow Observation template for LeapBoard
+# Provides real-time visibility into the signal processing pipeline.
+template: signals
+version: 1
+title: "Signal flow"
+domain: signals
+meta:
+  title: "Signal flow"
+  description: "Real-time signal processing pipeline health and live event stream."
+layout:
+  - type: Page
+    props:
+      title: "Signal flow"
+    children:
+      # Top health band: fan-out, trigger coverage, pressure, and observation yield.
+      - type: Row
+        props:
+          variant: metrics
+        children:
+          - type: Stat
+            props:
+              label: "Subscribers"
+              value: "{{ signal_metrics.event_subscriber_count }}"
+          - type: Stat
+            props:
+              label: "Active triggers"
+              value: "{{ signal_metrics.active_trigger_count }}"
+          - type: Stat
+            props:
+              label: "Active watches"
+              value: "{{ signal_metrics.active_watch_count }}"
+          - type: Stat
+            props:
+              label: "Stream events"
+              value: "{{ signal_metrics.signal_stream_count }}"
+          - type: Stat
+            props:
+              label: "Recent findings"
+              value: "{{ signal_metrics.recent_findings_count }}"
+          - type: Stat
+            props:
+              label: "Noise suppressed"
+              value: "{{ signal_metrics.signal_noise_suppressed }}"
+          - type: Stat
+            props:
+              label: "Buffer dropped"
+              value: "{{ signal_metrics.signal_buffer_dropped }}"
+          - type: Stat
+            props:
+              label: "Source dropped"
+              value: "{{ signal_metrics.composite_source_dropped }}"
+          - type: Stat
+            props:
+              label: "Reorder pending"
+              value: "{{ signal_metrics.reorder_buffer_pending }}"
+          - type: Stat
+            props:
+              label: "Debounced"
+              value: "{{ signal_metrics.total_debounced }}"
+
+      - type: Section
+        props:
+          title: "Signal health summary"
+          subtitle: "Ingress fan-out, pipeline pressure, and recent dimensional mix."
+        children:
+          - type: Grid
+            props:
+              cols: 3
+            children:
+              - type: Card
+                props:
+                  title: "Ingress"
+                children:
+                  - type: Row
+                    props:
+                      variant: meta
+                    children:
+                      - type: Stat
+                        props:
+                          label: "Subscribers"
+                          value: "{{ signal_metrics.event_subscriber_count }}"
+                      - type: Stat
+                        props:
+                          label: "Triggers"
+                          value: "{{ signal_metrics.active_trigger_count }}"
+                      - type: Stat
+                        props:
+                          label: "Watches"
+                          value: "{{ signal_metrics.active_watch_count }}"
+                      - type: Stat
+                        props:
+                          label: "Findings"
+                          value: "{{ signal_metrics.recent_findings_count }}"
+              - type: Card
+                props:
+                  title: "Pressure"
+                children:
+                  - type: Row
+                    props:
+                      variant: meta
+                    children:
+                      - type: Stat
+                        props:
+                          label: "Noise suppressed"
+                          value: "{{ signal_metrics.signal_noise_suppressed }}"
+                      - type: Stat
+                        props:
+                          label: "Buffer dropped"
+                          value: "{{ signal_metrics.signal_buffer_dropped }}"
+                      - type: Stat
+                        props:
+                          label: "Source dropped"
+                          value: "{{ signal_metrics.composite_source_dropped }}"
+                      - type: Stat
+                        props:
+                          label: "Reorder pending"
+                          value: "{{ signal_metrics.reorder_buffer_pending }}"
+                      - type: Stat
+                        props:
+                          label: "Debounced"
+                          value: "{{ signal_metrics.total_debounced }}"
+              - type: BarChart
+                when: event_family_distribution
+                props:
+                  title: "Recent event families"
+                  caption: "Event count by normalized family in the live ring buffer."
+                  bind: event_family_distribution
+              - type: BarChart
+                when: finding_severity_distribution
+                props:
+                  title: "Finding severity mix"
+                  caption: "Observation count by severity across recent findings."
+                  bind: finding_severity_distribution
+
+      - type: Grid
+        props:
+          cols: 3
+        children:
+          - type: Section
+            when: signal_stream
+            props:
+              title: "Live signal stream"
+              subtitle: "Latest daemon events · grouped by signal family · newest first."
+              span: 2
+            children:
+              - type: Custom
+                props:
+                  render: signalTimeline
+                  bind: signal_stream
+                  max_items: 12
+          - type: Section
+            when: watch_state_distribution
+            props:
+              title: "Watch state mix"
+              subtitle: "Current monitor lifecycle states."
+            children:
+              - type: BarChart
+                props:
+                  title: "Watch states"
+                  bind: watch_state_distribution
+
+      - type: Grid
+        props:
+          cols: 3
+        children:
+          - type: Section
+            when: watches
+            props:
+              title: "Watch portfolio"
+              subtitle: "Active and completed event-driven monitors."
+              span: 2
+            children:
+              - type: Table
+                props:
+                  bind: watches
+                  columns:
+                    - key: name
+                      label: "Name"
+                    - key: domain
+                      label: "Domain"
+                    - key: trigger
+                      label: "Trigger"
+                    - key: state
+                      label: "Status"
+                    - key: finding_count
+                      label: "Findings"
+          - type: Section
+            when: findings
+            props:
+              title: "Recent findings"
+              subtitle: "Latest observation results."
+            children:
+              - type: Grid
+                children:
+                  - type: FindingCard
+                    repeat: findings
+                    as: f
+                    props:
+                      title: "{{ f.title }}"
+                      summary: "{{ f.summary }}"
+                      severity: "{{ f.severity }}"
+                      bind: f
+
+      - type: Section
+        when: trigger_rows
+        props:
+          title: "Trigger coverage"
+          subtitle: "Event patterns registered with the monitor event bridge."
+        children:
+          - type: Table
+            props:
+              bind: trigger_rows
+              columns:
+                - key: watch
+                  label: "Watch"
+                - key: pattern
+                  label: "Pattern"
+                - key: triggered
+                  label: "Triggered"
+                - key: last_event
+                  label: "Last event"
diff --git a/src/leapflow/domain/events.py b/src/leapflow/domain/events.py
index 8394000..7feea49 100644
--- a/src/leapflow/domain/events.py
+++ b/src/leapflow/domain/events.py
@@ -17,12 +17,22 @@
 
 @dataclass(frozen=True)
 class SystemEvent:
-    """Normalized system event — uniform across all platforms."""
+    """Normalized system event — uniform across all platforms.
+
+    Timebase convention:
+    - ``timestamp``: wall-clock time (``time.time()`` epoch seconds). Suitable
+      for persistence and display but **not** for ordering or causal inference
+      because wall-clock can jump (NTP, suspend/resume, manual adjustment).
+    - ``payload["_mono_ts"]``: monotonic origin time (``time.monotonic()``)
+      injected by each observer at event creation. Used by
+      :class:`~leapflow.platform.reorder_buffer.EventReorderBuffer` for
+      arrival-order correction and temporal sorting.
+    """
 
     event_type: str
     source: str
     payload: Dict[str, Any]
-    timestamp: float
+    timestamp: float  # Wall-clock (time.time()); for storage/display only, NOT for ordering.
     platform_hint: str = ""
     priority: int = PRIORITY_NORMAL
 
diff --git a/src/leapflow/gateway/connectors/composite_event_source.py b/src/leapflow/gateway/connectors/composite_event_source.py
index b366ac4..76f59cb 100644
--- a/src/leapflow/gateway/connectors/composite_event_source.py
+++ b/src/leapflow/gateway/connectors/composite_event_source.py
@@ -10,36 +10,53 @@
 import logging
 from typing import AsyncIterator, Sequence
 
-from leapflow.gateway.connectors.protocol import BackendEvent, EventSourceStatus
+from leapflow.gateway.connectors.protocol import (
+    BackendEvent,
+    BackendEventSource,
+    EventSourceStatus,
+)
 
 logger = logging.getLogger(__name__)
 
 _SENTINEL = object()
 
 
+_DEFAULT_QUEUE_SIZE = 2048
+
+
 class CompositeEventSource:
     """Merges multiple BackendEventSource streams into one.
 
     Satisfies the ``BackendEventSource`` protocol.  Each child source
     gets its own consumer task that pushes events into a shared
-    ``asyncio.Queue``.  ``events()`` yields from the queue.
+    bounded ``asyncio.Queue``.  ``events()`` yields from the queue.
+
+    When the queue is full, the oldest event is discarded to make room
+    for the incoming one (drop-oldest back-pressure strategy).
+
+    The *maxsize* parameter controls the internal queue capacity
+    (default: ``_DEFAULT_QUEUE_SIZE = 2048``).  Callers can override it
+    to tune back-pressure behavior for high-throughput or
+    resource-constrained deployments.
     """
 
     backend_kind = "composite"
 
     def __init__(
         self,
-        sources: Sequence[object],
+        sources: Sequence[BackendEventSource],
         *,
         platform_id: str = "",
+        maxsize: int = _DEFAULT_QUEUE_SIZE,
     ) -> None:
         self._sources = list(sources)
         self.platform_id = platform_id or (
-            self._sources[0].platform_id if self._sources else "unknown"  # type: ignore[union-attr]
+            self._sources[0].platform_id if self._sources else "unknown"
         )
-        self._queue: asyncio.Queue[BackendEvent | object] = asyncio.Queue()
+        self._queue: asyncio.Queue[BackendEvent | object] = asyncio.Queue(maxsize=maxsize)
         self._tasks: list[asyncio.Task[None]] = []
         self._running = False
+        self._drop_count: int = 0
 
     async def start(self, *, checkpoint: str = "") -> EventSourceStatus:
         """Start all child sources."""
@@ -48,7 +65,7 @@ async def start(self, *, checkpoint: str = "") -> EventSourceStatus:
 
         results: list[EventSourceStatus] = []
         for src in self._sources:
-            status = await src.start(checkpoint=checkpoint)  # type: ignore[union-attr]
+            status = await src.start(checkpoint=checkpoint)
             results.append(status)
 
         all_ok = all(r.ok for r in results)
@@ -74,7 +91,7 @@ async def stop(self) -> EventSourceStatus:
 
         for src in self._sources:
             try:
-                await src.stop()  # type: ignore[union-attr]
+                await src.stop()
             except Exception:
                 logger.debug("Error stopping child source", exc_info=True)
 
@@ -112,11 +129,30 @@ async def events(self) -> AsyncIterator[BackendEvent]:
                 await asyncio.gather(*self._tasks, return_exceptions=True)
             self._tasks.clear()
 
-    async def _consume_child(self, index: int, source: object) -> None:
+    @property
+    def drop_count(self) -> int:
+        """Number of events dropped due to queue back-pressure."""
+        return self._drop_count
+
+    async def _consume_child(self, index: int, source: BackendEventSource) -> None:
         """Read events from one child source and push them to the shared queue."""
         try:
-            async for event in source.events():  # type: ignore[union-attr]
-                await self._queue.put(event)
+            async for event in source.events():  # type: ignore[attr-defined]  # async-gen vs Protocol
+                try:
+                    self._queue.put_nowait(event)
+                except asyncio.QueueFull:
+                    # Drop oldest event to make room (back-pressure strategy).
+                    try:
+                        self._queue.get_nowait()
+                    except asyncio.QueueEmpty:
+                        pass
+                    self._queue.put_nowait(event)
+                    self._drop_count += 1
+                    logger.debug(
+                        "Composite queue full, dropped oldest event "
+                        "(child=%d, platform=%s, total_drops=%d)",
+                        index, self.platform_id, self._drop_count,
+                    )
         except asyncio.CancelledError:
             pass
         except Exception:
@@ -132,7 +168,7 @@ async def status(self) -> EventSourceStatus:
         statuses = []
         for src in self._sources:
             try:
-                statuses.append(await src.status())  # type: ignore[union-attr]
+                statuses.append(await src.status())
             except Exception:
                 statuses.append(EventSourceStatus(
                     ok=False, backend_kind="unknown", detail="status check failed",
diff --git a/src/leapflow/gateway/connectors/event_sources.py b/src/leapflow/gateway/connectors/event_sources.py
index cca55f5..a34d523 100644
--- a/src/leapflow/gateway/connectors/event_sources.py
+++ b/src/leapflow/gateway/connectors/event_sources.py
@@ -5,11 +5,13 @@
 import json
 import logging
 import re
+import signal
 from contextlib import suppress
 from dataclasses import dataclass, field
 from typing import Any, AsyncIterator, Mapping
 
 from leapflow.gateway.connectors.protocol import BackendEvent, EventSourceStatus
+from leapflow.utils.process_group import ProcessGroup
 
 logger = logging.getLogger(__name__)
 
@@ -104,6 +106,7 @@ def __init__(self, config: CliEventSourceConfig) -> None:
         self._config = config
         self.platform_id = config.platform_id
         self._proc: asyncio.subprocess.Process | None = None
+        self._group: ProcessGroup | None = None
         self._running = False
         self._ready = asyncio.Event()
         self._restart_count = 0
@@ -232,7 +235,11 @@ async def status(self) -> EventSourceStatus:
     # ── Internal ─────────────────────────────────────────────
 
     async def _spawn_process(self) -> None:
-        """Spawn the CLI subprocess with stdin/stdout/stderr pipes."""
+        """Spawn the CLI subprocess with stdin/stdout/stderr pipes.
+
+        Uses ProcessGroup to track the process tree so that termination
+        kills all descendants, preventing orphan accumulation.
+        """
         if self._stderr_task is not None and not self._stderr_task.done():
             self._stderr_task.cancel()
             with suppress(asyncio.CancelledError):
@@ -250,7 +257,20 @@ async def _spawn_process(self) -> None:
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             env=env,
+            start_new_session=True,
         )
+        # Attach to a ProcessGroup immediately so the whole process tree
+        # can be terminated cleanly on stop/restart.
+        try:
+            self._group = ProcessGroup()
+            self._group.attach(self._proc.pid)
+        except OSError:
+            logger.debug(
+                "Event source %s: process group unavailable",
+                self.platform_id, exc_info=True,
+            )
+            self._group = None
+
         self._stderr_task = asyncio.create_task(
             self._monitor_stderr(),
             name=f"stderr-{self.platform_id}",
@@ -341,7 +361,7 @@ async def _restart_with_backoff(self) -> None:
             logger.error("Event source %s spawn failed: %s", self.platform_id, exc)
 
     async def _kill_process(self) -> None:
-        """Terminate the subprocess gracefully, then forcefully."""
+        """Terminate the subprocess gracefully, then forcefully via ProcessGroup."""
         if self._stderr_task and not self._stderr_task.done():
             self._stderr_task.cancel()
             with suppress(asyncio.CancelledError):
@@ -349,10 +369,13 @@ async def _kill_process(self) -> None:
             self._stderr_task = None
 
         proc = self._proc
+        group = self._group
         self._proc = None
+        self._group = None
         if proc is None or proc.returncode is not None:
             return
 
+        # Graceful: close stdin (signals the CLI to exit on its own).
         if proc.stdin and not proc.stdin.is_closing():
             proc.stdin.close()
             with suppress(Exception):
@@ -361,13 +384,21 @@ async def _kill_process(self) -> None:
         try:
             await asyncio.wait_for(proc.wait(), timeout=5.0)
         except asyncio.TimeoutError:
-            with suppress(ProcessLookupError):
-                proc.terminate()
+            # Escalate: use ProcessGroup to SIGTERM the whole tree.
+            if group:
+                group.terminate(signal.SIGTERM)
+            else:
+                with suppress(ProcessLookupError):
+                    proc.terminate()
             try:
                 await asyncio.wait_for(proc.wait(), timeout=3.0)
             except asyncio.TimeoutError:
-                with suppress(ProcessLookupError):
-                    proc.kill()
+                # Final escalation: SIGKILL via group or direct kill.
+                if group:
+                    group.terminate(signal.SIGKILL)
+                else:
+                    with suppress(ProcessLookupError):
+                        proc.kill()
                 with suppress(ProcessLookupError):
                     await proc.wait()
 
diff --git a/src/leapflow/monitor/__init__.py b/src/leapflow/monitor/__init__.py
index 211cf35..3d0d101 100644
--- a/src/leapflow/monitor/__init__.py
+++ b/src/leapflow/monitor/__init__.py
@@ -7,6 +7,7 @@
 - ``MonitorManager`` orchestrating watch lifecycle, persistence, and push
 """
 
+from leapflow.monitor.event_bridge import EventBridge
 from leapflow.monitor.finding_store import FindingStore
 from leapflow.monitor.manager import EmitFn, MonitorManager
 from leapflow.monitor.producers import ProducerRegistry
@@ -16,6 +17,7 @@
     ensure_session_watch,
     session_watch_params,
 )
+from leapflow.monitor.signal_producer import SignalObservationProducer
 from leapflow.monitor.types import (
     EVENT_ERROR,
     EVENT_FINDING,
@@ -33,6 +35,7 @@
 )
 
 __all__ = [
+    "EventBridge",
     "EVENT_FINDING",
     "EVENT_WATCH_STATE",
     "EVENT_ERROR",
@@ -52,6 +55,7 @@
     "EmitFn",
     "SessionAnalysisProducer",
     "SessionAnalysisServices",
+    "SignalObservationProducer",
     "ensure_session_watch",
     "session_watch_params",
 ]
diff --git a/src/leapflow/monitor/event_bridge.py b/src/leapflow/monitor/event_bridge.py
new file mode 100644
index 0000000..a7be491
--- /dev/null
+++ b/src/leapflow/monitor/event_bridge.py
@@ -0,0 +1,172 @@
+"""Bridge between EventBus and MonitorManager event-triggered watches.
+
+Subscribes to EventBus as a callback. When a SystemEvent arrives,
+checks all registered EventTrigger instances for pattern matches
+and activates matched triggers (marking corresponding watches as DUE).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Callable, Dict, Optional, Set
+
+from leapflow.domain.events import SystemEvent
+from leapflow.scheduler.triggers.event import EventTrigger
+
+logger = logging.getLogger(__name__)
+
+
+class EventBridge:
+    """Adapter that fans out EventBus notifications to registered EventTriggers.
+
+    Usage:
+        bridge = EventBridge()
+        event_bus.subscribe(bridge.on_event)
+        bridge.register(watch_id, trigger)
+
+    When EventBus delivers a SystemEvent, the bridge checks each registered
+    trigger's pattern against `event.event_type`. Matched triggers are marked
+    as fired so the scheduler's next tick picks them up immediately.
+    """
+
+    def __init__(
+        self,
+        *,
+        default_debounce_s: float = 1.0,
+        scheduler_wake: Optional[Callable[[], None]] = None,
+        mark_due: Optional[Callable[[str, float], None]] = None,
+    ) -> None:
+        self._triggers: Dict[str, EventTrigger] = {}
+        self._active_patterns: Set[str] = set()
+        self._debounce_windows: Dict[str, float] = {}
+        self._last_triggered: Dict[str, float] = {}
+        self._debounced_count: Dict[str, int] = {}
+        self._default_debounce_s = default_debounce_s
+        self._scheduler_wake = scheduler_wake
+        self._mark_due = mark_due
+
+    # ------------------------------------------------------------------
+    # Registration
+    # ------------------------------------------------------------------
+
+    def register(
+        self, watch_id: str, trigger: EventTrigger, *, debounce_s: float | None = None
+    ) -> None:
+        """Register an event trigger for a watch.
+
+        Args:
+            watch_id: Unique identifier of the watch owning this trigger.
+            trigger: The EventTrigger instance to check on each event.
+            debounce_s: Minimum interval in seconds between successive
+                trigger activations for this watch.  When *None*, uses the
+                instance-level ``default_debounce_s`` (default: 1.0).
+        """
+        effective_debounce = debounce_s if debounce_s is not None else self._default_debounce_s
+        self._triggers[watch_id] = trigger
+        self._debounce_windows[watch_id] = effective_debounce
+        self._active_patterns.add(trigger.event_pattern)
+        logger.debug(
+            "EventBridge: registered watch=%s pattern=%s (total=%d)",
+            watch_id[:8],
+            trigger.event_pattern,
+            len(self._triggers),
+        )
+
+    def unregister(self, watch_id: str) -> None:
+        """Remove an event trigger for a watch.
+
+        Args:
+            watch_id: The watch whose trigger should be removed.
+        """
+        trigger = self._triggers.pop(watch_id, None)
+        if trigger is not None:
+            # Rebuild active_patterns from remaining triggers
+            self._active_patterns = {
+                t.event_pattern for t in self._triggers.values()
+            }
+            self._debounce_windows.pop(watch_id, None)
+            self._last_triggered.pop(watch_id, None)
+            self._debounced_count.pop(watch_id, None)
+            logger.debug(
+                "EventBridge: unregistered watch=%s (total=%d)",
+                watch_id[:8],
+                len(self._triggers),
+            )
+
+    # ------------------------------------------------------------------
+    # EventBus subscriber callback
+    # ------------------------------------------------------------------
+
+    def on_event(self, event: SystemEvent) -> None:
+        """EventBus subscriber callback: fan out event to registered triggers.
+
+        This is a synchronous method matching the EventBus subscriber contract
+        (`Callable[[SystemEvent], None]`).
+
+        Short-circuits immediately when no triggers are registered.
+        Applies per-watch debounce: if a trigger fires within its debounce
+        window since the last activation, the event is suppressed.
+
+        Args:
+            event: The normalized SystemEvent from EventBus.
+        """
+        if not self._triggers:
+            return
+
+        now = time.monotonic()
+        event_name = event.event_type
+        for watch_id, trigger in self._triggers.items():
+            if trigger.matches(event_name):
+                debounce_s = self._debounce_windows.get(watch_id, 1.0)
+                last = self._last_triggered.get(watch_id)
+                if last is not None and (now - last) < debounce_s:
+                    # Within debounce window — suppress
+                    self._debounced_count[watch_id] = (
+                        self._debounced_count.get(watch_id, 0) + 1
+                    )
+                    logger.debug(
+                        "EventBridge: debounced watch=%s event=%s "
+                        "(suppressed=%d)",
+                        watch_id[:8],
+                        event_name,
+                        self._debounced_count[watch_id],
+                    )
+                    continue
+                # First trigger or outside debounce window — fire
+                trigger.notify(event_name)
+                self._last_triggered[watch_id] = now
+                logger.debug(
+                    "EventBridge: trigger fired watch=%s event=%s pattern=%s",
+                    watch_id[:8],
+                    event_name,
+                    trigger.event_pattern,
+                )
+                # Persist the due time so the scheduler SQL query finds this task.
+                if self._mark_due is not None:
+                    try:
+                        self._mark_due(watch_id, trigger.next_due_at)
+                    except Exception:  # noqa: BLE001
+                        logger.debug("EventBridge: mark_due failed for %s", watch_id[:8], exc_info=True)
+                if self._scheduler_wake is not None:
+                    self._scheduler_wake()
+
+    # ------------------------------------------------------------------
+    # Properties
+    # ------------------------------------------------------------------
+
+    def debounced_count(self, watch_id: str) -> int:
+        """Return the number of events suppressed by debounce for a watch.
+
+        Args:
+            watch_id: The watch to query.
+
+        Returns:
+            Count of suppressed events, 0 if none or watch not found.
+        """
+        return self._debounced_count.get(watch_id, 0)
+
+    @property
+    def active_count(self) -> int:
+        """Number of currently registered event triggers."""
+        return len(self._triggers)
diff --git a/src/leapflow/monitor/manager.py b/src/leapflow/monitor/manager.py
index 4d9fb08..943ac8b 100644
--- a/src/leapflow/monitor/manager.py
+++ b/src/leapflow/monitor/manager.py
@@ -15,6 +15,7 @@
 from dataclasses import replace
 from typing import Any, Callable, List, Optional
 
+from leapflow.monitor.event_bridge import EventBridge
 from leapflow.monitor.finding_store import FindingStore
 from leapflow.monitor.producers import ProducerRegistry
 from leapflow.monitor.types import (
@@ -33,6 +34,7 @@
 from leapflow.scheduler.coordinator import TaskCoordinator
 from leapflow.scheduler.local_scheduler import LocalScheduler
 from leapflow.scheduler.store import TaskStore
+from leapflow.scheduler.triggers.event import EventTrigger
 from leapflow.scheduler.types import ArmedTask, TaskState
 
 logger = logging.getLogger(__name__)
@@ -191,6 +193,10 @@ def __init__(
             cloud_dispatcher=None,
             default_tier="local",
         )
+        self._event_bridge = EventBridge(
+            scheduler_wake=self._scheduler.wake,
+            mark_due=self._task_store.advance_next_due,
+        )
         self._started = False
         self._background_tasks: set[asyncio.Task[Any]] = set()
 
@@ -210,6 +216,11 @@ async def stop(self) -> None:
         await self._scheduler.stop()
         self._started = False
 
+    @property
+    def event_bridge(self) -> EventBridge:
+        """Expose the event bridge for external EventBus subscription."""
+        return self._event_bridge
+
     @property
     def finding_store(self) -> FindingStore:
         """Expose the finding store for read-only queries by hosts."""
@@ -237,6 +248,13 @@ async def arm_watch(self, spec: WatchSpec) -> WatchView:
             METADATA_CLIENT_COUPLED_KEY: bool(spec.client_coupled),
         }
         self._task_store.save(task)
+
+        # Register event trigger with the bridge for instant activation
+        if task.trigger_type == "event":
+            trigger_cfg = task.trigger_config if isinstance(task.trigger_config, dict) else {}
+            event_trigger = EventTrigger.deserialize(trigger_cfg)
+            self._event_bridge.register(task.task_id, event_trigger)
+
         self._emit_state(task)
         return self._to_view(task)
 
@@ -300,6 +318,7 @@ def resume_watch(self, watch_id: str) -> Optional[WatchView]:
 
     def stop_watch(self, watch_id: str) -> Optional[WatchView]:
         """Terminally stop a watch (kept for history)."""
+        self._event_bridge.unregister(watch_id)
         return self._transition(watch_id, TaskState.DONE.value)
 
     def set_muted(self, watch_id: str, muted: bool) -> Optional[WatchView]:
diff --git a/src/leapflow/monitor/signal_metrics.py b/src/leapflow/monitor/signal_metrics.py
new file mode 100644
index 0000000..7a045f0
--- /dev/null
+++ b/src/leapflow/monitor/signal_metrics.py
@@ -0,0 +1,144 @@
+"""Signal flow metrics collection for real-time observability.
+
+Aggregates health metrics from EventBus, EventBridge, buffers, and monitors
+into a single snapshot. No persistence — pure in-memory queries.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, asdict
+from typing import Any, Dict, List
+
+
+@dataclass(frozen=True)
+class TriggerStat:
+    """Stats for a single event trigger pattern."""
+
+    watch_id: str
+    pattern: str
+    triggered: bool
+    last_event: str
+
+
+@dataclass(frozen=True)
+class SignalMetricsSnapshot:
+    """Point-in-time signal flow health snapshot."""
+
+    timestamp: float
+    event_subscriber_count: int
+    active_trigger_count: int
+    trigger_stats: List[Dict[str, Any]]
+    debounce_stats: Dict[str, int]  # watch_id -> debounced_count
+    signal_buffer_dropped: int
+    reorder_buffer_pending: int
+    composite_source_dropped: int
+    active_watch_count: int
+    recent_findings_count: int
+    signal_noise_seen: int = 0
+    signal_noise_passed: int = 0
+    signal_noise_suppressed: int = 0
+    signal_noise_by_reason: Dict[str, int] | None = None
+    signal_noise_by_family: Dict[str, int] | None = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize snapshot to plain dict for RPC transport."""
+        return asdict(self)
+
+
+class SignalMetricsCollector:
+    """Gather real-time signal flow metrics from various components."""
+
+    def collect(
+        self,
+        *,
+        event_bus: Any = None,
+        monitor_manager: Any = None,
+        signal_buffer: Any = None,
+        reorder_buffer: Any = None,
+        composite_source: Any = None,
+        signal_noise_gate: Any = None,
+    ) -> SignalMetricsSnapshot:
+        """Collect current metrics snapshot (synchronous, fast)."""
+        # EventBus stats
+        subscriber_count = (
+            len(getattr(event_bus, "_subscribers", []))
+            if event_bus
+            else 0
+        )
+
+        # EventBridge stats
+        bridge = (
+            getattr(monitor_manager, "_event_bridge", None)
+            if monitor_manager
+            else None
+        )
+        trigger_count = getattr(bridge, "active_count", 0) if bridge else 0
+        triggers = getattr(bridge, "_triggers", {}) if bridge else {}
+        debounce: Dict[str, int] = {}
+        trigger_stats_list: List[Dict[str, Any]] = []
+
+        if bridge:
+            for watch_id, trigger in triggers.items():
+                trigger_stats_list.append(
+                    {
+                        "watch_id": watch_id,
+                        "pattern": getattr(trigger, "event_pattern", ""),
+                        "triggered": getattr(trigger, "is_triggered", False),
+                        "last_event": getattr(trigger, "last_event", ""),
+                    }
+                )
+            debounce_counts = getattr(bridge, "_debounced_count", {})
+            debounce = dict(debounce_counts)
+
+        # Buffer stats
+        buffer_dropped = (
+            getattr(signal_buffer, "dropped_count", 0) if signal_buffer else 0
+        )
+        reorder_pending = (
+            getattr(reorder_buffer, "pending_count", 0) if reorder_buffer else 0
+        )
+        source_dropped = (
+            getattr(composite_source, "drop_count", 0) if composite_source else 0
+        )
+        noise_stats = {}
+        if signal_noise_gate is not None:
+            try:
+                raw_stats = signal_noise_gate if isinstance(signal_noise_gate, dict) else getattr(signal_noise_gate, "stats", {})
+                noise_stats = dict(raw_stats) if isinstance(raw_stats, dict) else {}
+            except Exception:
+                noise_stats = {}
+
+        # Monitor stats
+        active_watches = 0
+        findings_count = 0
+        if monitor_manager:
+            try:
+                watches = monitor_manager.list_watches()
+                active_watches = len(
+                    [w for w in watches if w.state in ("armed", "watching", "due")]
+                )
+            except Exception:
+                pass
+            try:
+                findings = monitor_manager.list_findings(limit=100)
+                findings_count = len(findings)
+            except Exception:
+                pass
+
+        return SignalMetricsSnapshot(
+            timestamp=time.time(),
+            event_subscriber_count=subscriber_count,
+            active_trigger_count=trigger_count,
+            trigger_stats=trigger_stats_list,
+            debounce_stats=debounce,
+            signal_buffer_dropped=buffer_dropped,
+            reorder_buffer_pending=reorder_pending,
+            composite_source_dropped=source_dropped,
+            active_watch_count=active_watches,
+            recent_findings_count=findings_count,
+            signal_noise_seen=int(noise_stats.get("seen", 0) or 0),
+            signal_noise_passed=int(noise_stats.get("passed", 0) or 0),
+            signal_noise_suppressed=int(noise_stats.get("suppressed", 0) or 0),
+            signal_noise_by_reason=dict(noise_stats.get("by_reason", {}) or {}),
+            signal_noise_by_family=dict(noise_stats.get("by_family", {}) or {}),
+        )
diff --git a/src/leapflow/monitor/signal_noise.py b/src/leapflow/monitor/signal_noise.py
new file mode 100644
index 0000000..9a4e6ad
--- /dev/null
+++ b/src/leapflow/monitor/signal_noise.py
@@ -0,0 +1,253 @@
+"""Signal noise gate for monitor and LeapBoard live-stream ingestion.
+
+This gate is intentionally *signal-attribute based* rather than natural-language
+routing: it classifies stable, observable noise properties (cache dirs, transient
+suffixes, same-source bursts) before events wake monitor watches or enter the
+LeapBoard live stream. The raw EventBus pipeline can still ingest/remember the
+normalized event; this gate controls the monitor/display boundary where high
+frequency OS/tool churn has the highest user-facing cost.
+"""
+from __future__ import annotations
+
+import time
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any
+
+from leapflow.domain.events import SystemEvent
+
+_DEFAULT_NOISY_PATH_FRAGMENTS = (
+    "/Library/Caches/",
+    "/Library/Logs/",
+    "/Library/Preferences/",
+    "/Application Support/Qoder/User/globalStorage/",
+    "/Application Support/Qoder/SharedClientCache/",
+    "/Application Support/Qoder/SharedCredentialCache/",
+    "/Application Support/Qoder/Partitions/native-browser/Cache/",
+    "/Application Support/Cursor/User/globalStorage/",
+    "/Application Support/DuetExpertCenter/",
+    "/.cache/",
+    "/.hermes/",
+    "/.r2c/logs/",
+)
+
+_DEFAULT_NOISY_DIR_NAMES = (
+    ".git",
+    ".hg",
+    ".svn",
+    ".venv",
+    "__pycache__",
+    ".pytest_cache",
+    ".ruff_cache",
+    "node_modules",
+    "Cache",
+    "Caches",
+    "SharedCredentialCache",
+    "globalStorage",
+    "Code Cache",
+    "GPUCache",
+)
+
+_DEFAULT_NOISY_SUFFIXES = (
+    ".tmp",
+    ".temp",
+    ".swp",
+    ".lock",
+    ".log",
+    ".pyc",
+    ".pyo",
+    "-journal",
+    "-shm",
+    "-wal",
+    ".db-shm",
+    ".db-wal",
+    ".sqlite-journal",
+)
+
+
+@dataclass(frozen=True)
+class SignalNoiseConfig:
+    """Runtime policy for monitor/display signal noise suppression."""
+
+    enabled: bool = True
+    workspace_root: str = ""
+    same_source_cooldown_s: float = 2.0
+    allow_fs_outside_workspace: bool = False
+    path_fragments: tuple[str, ...] = _DEFAULT_NOISY_PATH_FRAGMENTS
+    dir_names: tuple[str, ...] = _DEFAULT_NOISY_DIR_NAMES
+    suffixes: tuple[str, ...] = _DEFAULT_NOISY_SUFFIXES
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "SignalNoiseConfig":
+        """Build policy from Settings-like objects while keeping safe defaults."""
+        return cls(
+            enabled=bool(getattr(settings, "signal_noise_gate_enabled", True)),
+            workspace_root=str(getattr(settings, "workspace_root", "") or ""),
+            same_source_cooldown_s=max(
+                0.0, float(getattr(settings, "signal_noise_same_source_cooldown_s", 2.0) or 0.0)
+            ),
+            allow_fs_outside_workspace=bool(
+                getattr(settings, "signal_noise_allow_fs_outside_workspace", False)
+            ),
+            path_fragments=tuple(
+                getattr(settings, "signal_noise_path_fragments", _DEFAULT_NOISY_PATH_FRAGMENTS)
+                or ()
+            ),
+            dir_names=tuple(
+                getattr(settings, "signal_noise_dir_names", _DEFAULT_NOISY_DIR_NAMES)
+                or ()
+            ),
+            suffixes=tuple(
+                getattr(settings, "signal_noise_suffixes", _DEFAULT_NOISY_SUFFIXES)
+                or ()
+            ),
+        )
+
+
+@dataclass
+class SignalNoiseStats:
+    """Counters exposed to dashboard metrics for transparency."""
+
+    seen: int = 0
+    passed: int = 0
+    suppressed: int = 0
+    by_reason: Counter[str] = field(default_factory=Counter)
+    by_family: Counter[str] = field(default_factory=Counter)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize counters without exposing sampled file paths."""
+        return {
+            "seen": self.seen,
+            "passed": self.passed,
+            "suppressed": self.suppressed,
+            "by_reason": dict(self.by_reason),
+            "by_family": dict(self.by_family),
+        }
+
+
+@dataclass(frozen=True)
+class SignalNoiseDecision:
+    """One classification verdict."""
+
+    pass_event: bool
+    reason: str = ""
+
+
+class SignalNoiseGate:
+    """Suppress low-value monitor/display events before they trigger UI churn."""
+
+    def __init__(self, config: SignalNoiseConfig | None = None) -> None:
+        self.config = config or SignalNoiseConfig()
+        self._stats = SignalNoiseStats()
+        self._last_seen_by_source: dict[str, float] = {}
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """Return a stable snapshot for metrics collectors."""
+        return self._stats.to_dict()
+
+    def update_config(self, config: SignalNoiseConfig) -> None:
+        """Apply new policy without resetting suppression counters."""
+        self.config = config
+
+    def should_pass(self, event: SystemEvent) -> bool:
+        """Classify and update counters. True means monitor/display may see it."""
+        self._stats.seen += 1
+        decision = self._decide(event)
+        if decision.pass_event:
+            self._stats.passed += 1
+            self._remember_source(event)
+            return True
+        self._stats.suppressed += 1
+        reason = decision.reason or "noise"
+        self._stats.by_reason[reason] += 1
+        self._stats.by_family[_event_family(event.event_type)] += 1
+        return False
+
+    def _decide(self, event: SystemEvent) -> SignalNoiseDecision:
+        if not self.config.enabled:
+            return SignalNoiseDecision(True)
+        event_type = str(event.event_type or "")
+        if event_type != "fs.change":
+            return SignalNoiseDecision(True)
+        source = str(event.source or event.payload.get("path") or "")
+        if not source:
+            return SignalNoiseDecision(True)
+        normalized = source.replace("\\", "/")
+        workspace_root = self.config.workspace_root.replace("\\", "/").rstrip("/")
+        in_workspace = bool(workspace_root and _is_relative_to(normalized, workspace_root))
+
+        if self._is_same_source_burst(event):
+            return SignalNoiseDecision(False, "same_source_burst")
+        if self._matches_suffix(normalized):
+            return SignalNoiseDecision(False, "transient_suffix")
+        if self._matches_path_fragment(normalized):
+            return SignalNoiseDecision(False, "path_fragment")
+        if self._matches_noisy_dir(normalized):
+            return SignalNoiseDecision(False, "noisy_dir")
+        if workspace_root and not in_workspace and not self.config.allow_fs_outside_workspace:
+            return SignalNoiseDecision(False, "outside_workspace")
+        # Outside-workspace hidden app-state roots (e.g. ~/.hermes, ~/.cache)
+        # are almost always runtime churn; keep workspace hidden dirs governed by
+        # the explicit dir/suffix checks above so project dotfiles remain visible.
+        if not in_workspace and _has_hidden_state_segment(normalized):
+            return SignalNoiseDecision(False, "hidden_state")
+        return SignalNoiseDecision(True)
+
+    def _remember_source(self, event: SystemEvent) -> None:
+        key = _event_key(event)
+        if key:
+            self._last_seen_by_source[key] = time.monotonic()
+
+    def _is_same_source_burst(self, event: SystemEvent) -> bool:
+        cooldown = float(self.config.same_source_cooldown_s or 0.0)
+        if cooldown <= 0:
+            return False
+        key = _event_key(event)
+        if not key:
+            return False
+        previous = self._last_seen_by_source.get(key, 0.0)
+        return (time.monotonic() - previous) < cooldown
+
+    def _matches_path_fragment(self, path: str) -> bool:
+        return any(fragment and fragment in path for fragment in self.config.path_fragments)
+
+    def _matches_suffix(self, path: str) -> bool:
+        lowered = path.lower()
+        return any(suffix and lowered.endswith(str(suffix).lower()) for suffix in self.config.suffixes)
+
+    def _matches_noisy_dir(self, path: str) -> bool:
+        parts = _path_parts(path)
+        return any(name in parts for name in self.config.dir_names)
+
+
+def _event_family(event_type: str) -> str:
+    normalized = str(event_type or "unknown").replace(":", ".")
+    return normalized.split(".", 1)[0] or "unknown"
+
+
+def _event_key(event: SystemEvent) -> str:
+    source = str(event.source or event.payload.get("path") or "")
+    return f"{event.event_type}:{source}" if source else ""
+
+
+def _is_relative_to(path: str, root: str) -> bool:
+    path = path.rstrip("/")
+    return path == root or path.startswith(root + "/")
+
+
+def _path_parts(path: str) -> set[str]:
+    """Split POSIX, Windows, and mixed-separator paths without OS-dependent Path.parts."""
+    return {part for part in str(path).replace("\\", "/").split("/") if part}
+
+
+def _has_hidden_state_segment(path: str) -> bool:
+    return bool(_path_parts(path) & {".cache", ".hermes", ".qoder", ".r2c"})
+
+
+__all__ = [
+    "SignalNoiseConfig",
+    "SignalNoiseDecision",
+    "SignalNoiseGate",
+    "SignalNoiseStats",
+]
diff --git a/src/leapflow/monitor/signal_producer.py b/src/leapflow/monitor/signal_producer.py
new file mode 100644
index 0000000..bb1bedf
--- /dev/null
+++ b/src/leapflow/monitor/signal_producer.py
@@ -0,0 +1,35 @@
+"""Lightweight signal observation producer for event-driven watches.
+
+Produces a Finding summarizing recent signal activity for the watched domain.
+No LLM calls — pure rule-based observation with sub-millisecond execution.
+"""
+
+from __future__ import annotations
+
+from leapflow.monitor.types import Finding, ProducerContext, Severity
+
+
+class SignalObservationProducer:
+    """Produces findings based on signal flow activity (no LLM).
+
+    Registered for the ``signal`` domain, this producer is triggered by
+    event-driven watches (e.g. fs.*, gateway.*) and emits an INFO-level
+    finding confirming the trigger fired.
+    """
+
+    domain = "signal"
+
+    async def observe(self, ctx: ProducerContext) -> list[Finding]:
+        """Report that an event-driven trigger fired."""
+        return [
+            Finding(
+                watch_id=ctx.spec.watch_id or "",
+                domain=self.domain,
+                title="Signal activity detected",
+                description=f"Event-driven trigger fired for {ctx.spec.name} (run #{ctx.run_count + 1})",
+                severity=Severity.INFO,
+            )
+        ]
+
+
+__all__ = ["SignalObservationProducer"]
diff --git a/src/leapflow/perception/signals.py b/src/leapflow/perception/signals.py
index 94c5839..f81a895 100644
--- a/src/leapflow/perception/signals.py
+++ b/src/leapflow/perception/signals.py
@@ -22,18 +22,22 @@
 class SignalBuffer:
     """Thread-safe bounded buffer for interaction signals between polling frames."""
 
-    __slots__ = ("_signals", "_lock", "_capacity")
+    __slots__ = ("_signals", "_lock", "_capacity", "_dropped_count")
 
     def __init__(self, capacity: int = _MAX_SIGNALS_PER_INTERVAL) -> None:
         self._signals: List[InteractionSignal] = []
         self._lock = threading.Lock()
         self._capacity = capacity
+        self._dropped_count: int = 0
 
     def record(self, signal: InteractionSignal) -> None:
         """Append a signal to the buffer (dropped if at capacity)."""
         with self._lock:
             if len(self._signals) < self._capacity:
                 self._signals.append(signal)
+            else:
+                self._dropped_count += 1
+                logger.debug("SignalBuffer at capacity (%d), dropping signal", self._capacity)
 
     def drain(self) -> List[InteractionSignal]:
         """Return all buffered signals and clear the buffer."""
@@ -43,9 +47,15 @@ def drain(self) -> List[InteractionSignal]:
             return result
 
     def clear(self) -> None:
-        """Discard all buffered signals."""
+        """Discard all buffered signals and reset drop counter."""
         with self._lock:
             self._signals.clear()
+            self._dropped_count = 0
+
+    @property
+    def dropped_count(self) -> int:
+        """Number of signals dropped due to capacity overflow."""
+        return self._dropped_count
 
     @property
     def count(self) -> int:
diff --git a/src/leapflow/platform/event_bus.py b/src/leapflow/platform/event_bus.py
index debaa90..4c0dbca 100644
--- a/src/leapflow/platform/event_bus.py
+++ b/src/leapflow/platform/event_bus.py
@@ -26,6 +26,7 @@
 EventCallback = Callable[[SystemEvent], None]
 
 _DEDUP_WINDOW_S = 2.0
+_SLOW_SUBSCRIBER_THRESHOLD_S = 0.1
 
 
 class EventBus:
@@ -203,51 +204,80 @@ def _ingest_to_memory(self, event: SystemEvent) -> None:
 
     def _notify_subscribers(self, event: SystemEvent) -> None:
         for cb in self._subscribers:
+            t0 = time.monotonic()
             try:
                 cb(event)
             except Exception:
                 logger.error("Event subscriber error", exc_info=True)
+            elapsed = time.monotonic() - t0
+            if elapsed >= _SLOW_SUBSCRIBER_THRESHOLD_S:
+                name = getattr(cb, "__qualname__", repr(cb))
+                logger.warning(
+                    "Slow event subscriber: %s took %.3fs", name, elapsed,
+                )
 
     def _fallback_normalize(self, event_type: str, payload: Dict[str, Any]) -> SystemEvent:
         """Legacy normalization when no EventNormalizer is configured."""
         import time
 
+        mono_ts = payload.get("_mono_ts")
+
         if event_type == EventTypes.FS_CHANGE:
             path = str(payload.get("path", ""))
             flags = payload.get("flags", 0)
             action = _infer_fs_action(int(flags))
+            normalized: Dict[str, Any] = {"path": path, "action": action, "raw_flags": flags}
+            if mono_ts is not None:
+                normalized["_mono_ts"] = mono_ts
             return SystemEvent(
                 event_type="fs.change",
                 source=path,
-                payload={"path": path, "action": action, "raw_flags": flags},
+                payload=normalized,
                 timestamp=payload.get("ts", time.time()),
             )
         if event_type == EventTypes.CLIPBOARD_CHANGE:
             text = str(payload.get("text", ""))
+            normalized = {"text": text, "char_count": len(text)}
+            if mono_ts is not None:
+                normalized["_mono_ts"] = mono_ts
             return SystemEvent(
                 event_type="clipboard.change",
                 source="system.clipboard",
-                payload={"text": text, "char_count": len(text)},
+                payload=normalized,
                 timestamp=payload.get("change_ts", time.time()),
             )
         if event_type == EventTypes.APP_FOCUS_CHANGE:
             bundle_id = str(payload.get("bundle_id", ""))
             app_name = str(payload.get("app_name", bundle_id))
+            normalized = {"bundle_id": bundle_id, "app_name": app_name}
+            if mono_ts is not None:
+                normalized["_mono_ts"] = mono_ts
             return SystemEvent(
                 event_type="app.focus_change",
                 source=bundle_id,
-                payload={"bundle_id": bundle_id, "app_name": app_name},
+                payload=normalized,
                 timestamp=time.time(),
             )
         if event_type == EventTypes.UI_ACTION:
             action = str(payload.get("action", "unknown"))
             app_bundle_id = str(payload.get("app_bundle_id", ""))
+            # UI_ACTION already spreads the full payload which includes _mono_ts
             return SystemEvent(
                 event_type="ui.action",
                 source=app_bundle_id,
                 payload={"sub_type": action, "app_bundle_id": app_bundle_id, **payload},
                 timestamp=payload.get("timestamp", time.time()),
             )
+        # Gateway/daemon events are pre-normalized upstream; pass through so
+        # downstream subscribers see the original event_type for matching.
+        if event_type.startswith("gateway.") or event_type.startswith("daemon."):
+            return SystemEvent(
+                event_type=event_type,
+                source=str(payload.get("_platform", payload.get("source", event_type))),
+                payload=payload,
+                timestamp=payload.get("timestamp", payload.get("ts", time.time())),
+            )
+        # internal.unmapped spreads the full payload which includes _mono_ts
         return SystemEvent(
             event_type="internal.unmapped",
             source=event_type,
diff --git a/src/leapflow/platform/normalizer.py b/src/leapflow/platform/normalizer.py
index 3066fd4..727c844 100644
--- a/src/leapflow/platform/normalizer.py
+++ b/src/leapflow/platform/normalizer.py
@@ -141,6 +141,17 @@ def normalize(self, event_type: str, payload: Dict[str, Any]) -> SystemEvent:
             event = self._normalize_context(payload)
         elif event_type == "event.intent_signal":
             event = self._normalize_intent(payload)
+        elif event_type.startswith("gateway.") or event_type.startswith("daemon."):
+            # Gateway/daemon events are pre-normalized; pass through as-is so
+            # downstream subscribers (e.g. MonitorManager EventBridge) see the
+            # original event_type for pattern-matching.
+            event = SystemEvent(
+                event_type=event_type,
+                source=str(payload.get("_platform", payload.get("source", event_type))),
+                payload=payload,
+                timestamp=payload.get("timestamp", payload.get("ts", time.time())),
+                platform_hint=self._manifest.platform_id.value,
+            )
         else:
             event = SystemEvent(
                 event_type="internal.unmapped",
@@ -165,6 +176,9 @@ def _normalize_fs(self, payload: Dict[str, Any]) -> SystemEvent:
             "semantic_actions": actions,
             "raw_flags": payload.get("flags"),
         }
+        mono_ts = payload.get("_mono_ts")
+        if mono_ts is not None:
+            normalized["_mono_ts"] = mono_ts
         return SystemEvent(
             event_type="fs.change",
             source=path,
@@ -175,10 +189,14 @@ def _normalize_fs(self, payload: Dict[str, Any]) -> SystemEvent:
 
     def _normalize_clipboard(self, payload: Dict[str, Any]) -> SystemEvent:
         text = str(payload.get("text", ""))
+        normalized: Dict[str, Any] = {"text": text, "char_count": len(text)}
+        mono_ts = payload.get("_mono_ts")
+        if mono_ts is not None:
+            normalized["_mono_ts"] = mono_ts
         return SystemEvent(
             event_type="clipboard.change",
             source="system.clipboard",
-            payload={"text": text, "char_count": len(text)},
+            payload=normalized,
             timestamp=payload.get("change_ts", payload.get("ts", time.time())),
             platform_hint=self._manifest.platform_id.value,
         )
@@ -190,6 +208,9 @@ def _normalize_focus(self, payload: Dict[str, Any]) -> SystemEvent:
         window_title = payload.get("window_title")
         if window_title:
             normalized["window_title"] = str(window_title)
+        mono_ts = payload.get("_mono_ts")
+        if mono_ts is not None:
+            normalized["_mono_ts"] = mono_ts
         return SystemEvent(
             event_type="app.focus_change",
             source=bundle_id,
@@ -245,6 +266,10 @@ def _normalize_ui_action(self, payload: Dict[str, Any]) -> SystemEvent:
             normalized["mouse_x"] = payload.get("mouse_x", 0)
             normalized["mouse_y"] = payload.get("mouse_y", 0)
 
+        mono_ts = payload.get("_mono_ts")
+        if mono_ts is not None:
+            normalized["_mono_ts"] = mono_ts
+
         return SystemEvent(
             event_type="ui.action",
             source=app_bundle_id or "unknown",
@@ -274,6 +299,9 @@ def _normalize_drag(
             "end_app": str(payload.get("end_app", "")),
             "cross_app": bool(payload.get("cross_app", False)),
         }
+        mono_ts = payload.get("_mono_ts")
+        if mono_ts is not None:
+            normalized["_mono_ts"] = mono_ts
         return SystemEvent(
             event_type="ui.action",
             source=app_bundle_id or "unknown",
@@ -292,6 +320,9 @@ def _normalize_context(self, payload: Dict[str, Any]) -> SystemEvent:
         url = payload.get("url")
         if url:
             normalized["url"] = str(url)
+        mono_ts = payload.get("_mono_ts")
+        if mono_ts is not None:
+            normalized["_mono_ts"] = mono_ts
         return SystemEvent(
             event_type="context.change",
             source=bundle_id,
diff --git a/src/leapflow/platform/observers/app_focus.py b/src/leapflow/platform/observers/app_focus.py
index 31c3734..5851b1b 100644
--- a/src/leapflow/platform/observers/app_focus.py
+++ b/src/leapflow/platform/observers/app_focus.py
@@ -98,6 +98,7 @@ async def _emit(self, info: Dict[str, Any]) -> None:
             "pid": info.get("pid", 0),
             "window_title": info.get("window_title", ""),
             "ts": time.time(),
+            "_mono_ts": time.monotonic(),
         }
         try:
             await self._bus.handle_event(EventTypes.APP_FOCUS_CHANGE, payload)
diff --git a/src/leapflow/platform/observers/clipboard.py b/src/leapflow/platform/observers/clipboard.py
index dd6a766..e116cf4 100644
--- a/src/leapflow/platform/observers/clipboard.py
+++ b/src/leapflow/platform/observers/clipboard.py
@@ -117,6 +117,7 @@ async def _emit(self, content: str) -> None:
             "content_type": content_type,
             "source_app": "",  # Platform-specific enrichment possible
             "change_ts": time.time(),
+            "_mono_ts": time.monotonic(),
         }
         try:
             await self._bus.handle_event(EventTypes.CLIPBOARD_CHANGE, payload)
diff --git a/src/leapflow/platform/observers/fs_watcher.py b/src/leapflow/platform/observers/fs_watcher.py
index 672b338..5be0a60 100644
--- a/src/leapflow/platform/observers/fs_watcher.py
+++ b/src/leapflow/platform/observers/fs_watcher.py
@@ -129,6 +129,7 @@ def _on_fs_event(self, path: str, action: str, is_dir: bool) -> None:
             "path": path,
             "action": action,
             "is_dir": is_dir,
+            "_mono_ts": time.monotonic(),
         }
         # Schedule coroutine from watchdog's thread
         asyncio.run_coroutine_threadsafe(
diff --git a/src/leapflow/platform/observers/input_tap.py b/src/leapflow/platform/observers/input_tap.py
index 16d929e..8eb95d0 100644
--- a/src/leapflow/platform/observers/input_tap.py
+++ b/src/leapflow/platform/observers/input_tap.py
@@ -224,6 +224,7 @@ def _handle_quartz_event(self, event_type: int, event: Any) -> None:
                     "mouse_x": int(loc.x),
                     "mouse_y": int(loc.y),
                     "timestamp": time.time(),
+                    "_mono_ts": time.monotonic(),
                 }
                 self._schedule_emit(payload)
 
@@ -236,6 +237,7 @@ def _handle_quartz_event(self, event_type: int, event: Any) -> None:
                     "app_bundle_id": "",
                     "key_code": int(keycode),
                     "timestamp": time.time(),
+                    "_mono_ts": time.monotonic(),
                 }
                 self._schedule_emit(payload)
 
@@ -253,6 +255,7 @@ def _handle_quartz_event(self, event_type: int, event: Any) -> None:
                     "mouse_x": int(loc.x),
                     "mouse_y": int(loc.y),
                     "timestamp": time.time(),
+                    "_mono_ts": time.monotonic(),
                 }
                 self._schedule_emit(payload)
 
@@ -308,6 +311,7 @@ def _on_pynput_click(
             "mouse_x": int(x),
             "mouse_y": int(y),
             "timestamp": time.time(),
+            "_mono_ts": time.monotonic(),
         }
         self._schedule_emit(payload)
 
@@ -326,6 +330,7 @@ def _on_pynput_scroll(
             "mouse_x": int(x),
             "mouse_y": int(y),
             "timestamp": time.time(),
+            "_mono_ts": time.monotonic(),
         }
         self._schedule_emit(payload)
 
@@ -352,5 +357,6 @@ def _on_pynput_key(self, key: Any) -> None:
             "key_code": key_code,
             "char": key_str,
             "timestamp": time.time(),
+            "_mono_ts": time.monotonic(),
         }
         self._schedule_emit(payload)
diff --git a/src/leapflow/platform/reorder_buffer.py b/src/leapflow/platform/reorder_buffer.py
index 7a94436..60904d0 100644
--- a/src/leapflow/platform/reorder_buffer.py
+++ b/src/leapflow/platform/reorder_buffer.py
@@ -29,9 +29,10 @@ class EventReorderBuffer:
       relative to each other, but placed after all timestamped events in the window).
     """
 
-    def __init__(self, settle_s: float, emit: EmitFn) -> None:
+    def __init__(self, settle_s: float, emit: EmitFn, max_buffer_size: int = 5000) -> None:
         self._settle_s = settle_s
         self._emit = emit
+        self._max_buffer_size = max_buffer_size
         self._buffer: List[Tuple[float, str, Dict[str, Any]]] = []
         self._flush_task: Optional[asyncio.Task[None]] = None
         self._arrival_counter: int = 0
@@ -43,17 +44,25 @@ async def submit(self, event_type: str, payload: Dict[str, Any]) -> None:
             self._arrival_counter += 1
             ts = float("inf") - 1.0 / self._arrival_counter
         self._buffer.append((ts, event_type, payload))
+
+        if len(self._buffer) >= self._max_buffer_size:
+            logger.warning(
+                "EventReorderBuffer reached capacity (%d), forcing flush",
+                self._max_buffer_size,
+            )
+            # Wait for any in-progress flush to complete (do NOT cancel it)
+            if self._flush_task is not None and not self._flush_task.done():
+                await self._flush_task
+            await self._flush()
+            return
+
         if self._flush_task is None or self._flush_task.done():
             self._flush_task = asyncio.create_task(self._delayed_flush())
 
     async def drain(self) -> None:
         """Flush all buffered events immediately (used on recording stop)."""
         if self._flush_task is not None and not self._flush_task.done():
-            self._flush_task.cancel()
-            try:
-                await self._flush_task
-            except asyncio.CancelledError:
-                pass
+            await self._flush_task  # Wait instead of cancel
         await self._flush()
 
     @property
diff --git a/src/leapflow/scheduler/local_scheduler.py b/src/leapflow/scheduler/local_scheduler.py
index 4d89aa0..69a84e0 100644
--- a/src/leapflow/scheduler/local_scheduler.py
+++ b/src/leapflow/scheduler/local_scheduler.py
@@ -44,6 +44,8 @@ def __init__(
         self._grace_seconds = grace_seconds
         self._task: Optional[asyncio.Task] = None  # type: ignore[type-arg]
         self._running = False
+        self._wake_event: asyncio.Event = asyncio.Event()
+        self._last_wake_time: float = 0.0
 
     # ------------------------------------------------------------------
     # Lifecycle
@@ -90,6 +92,19 @@ async def cancel(self, task_id: str) -> None:
     # Tick loop
     # ------------------------------------------------------------------
 
+    def wake(self) -> None:
+        """Signal the scheduler to check for due tasks immediately.
+
+        Called by EventBridge when an event-driven trigger fires,
+        reducing latency from poll-interval to near-zero.
+        Thread-safe: asyncio.Event.set() is safe to call from any thread.
+        """
+        now = time.monotonic()
+        if now - self._last_wake_time < 1.0:
+            return
+        self._last_wake_time = now
+        self._wake_event.set()
+
     async def _tick_loop(self) -> None:
         """Background loop: check and execute due tasks every tick."""
         while self._running:
@@ -97,7 +112,12 @@ async def _tick_loop(self) -> None:
                 await self._tick()
             except Exception as e:
                 logger.error("Scheduler tick error: %s", e, exc_info=True)
-            await asyncio.sleep(self._tick_seconds)
+            # Wait for either the tick interval or an external wake signal
+            try:
+                await asyncio.wait_for(self._wake_event.wait(), timeout=self._tick_seconds)
+            except asyncio.TimeoutError:
+                pass
+            self._wake_event.clear()
 
     async def _tick(self) -> None:
         """Single tick: find due tasks, advance, execute."""
diff --git a/src/leapflow/utils/build_info.py b/src/leapflow/utils/build_info.py
new file mode 100644
index 0000000..19b48f3
--- /dev/null
+++ b/src/leapflow/utils/build_info.py
@@ -0,0 +1,150 @@
+"""Best-effort source-tree fingerprint for long-lived-process staleness checks.
+
+Long-lived local processes (the ``leapd`` daemon, the LeapBoard web server)
+keep running whatever code was imported at process start; editing a source
+file on disk does not hot-reload that in-memory logic (only per-request-read
+YAML/JS/CSS reflect edits immediately). This module lets a process capture its
+own fingerprint once at startup (:func:`capture_build_info`), then later ask
+whether the source tree has moved on since (:func:`is_stale`) via a *fresh*
+subprocess call — which always reflects the current disk state, unlike the
+caller's own possibly-ancient Python import cache. Callers use this to tell a
+developer "this process is stale, restart it" instead of silently serving
+outdated behavior that looks like a code defect (see AGENTS.md, "User-Centric
+Reliability").
+
+Best-effort by design: outside a git checkout (e.g. a packaged release install)
+there is no fingerprint to compare, so every function degrades to ``None``
+("unknown") rather than a false verdict — never raises, never blocks longer
+than ``_GIT_TIMEOUT_S``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from leapflow.version import __version__
+
+# Short timeout: this runs on request paths (dashboard HTTP handlers, daemon
+# status RPC), so a hung git process must not hang the caller.
+_GIT_TIMEOUT_S = 1.5
+
+
+def _repo_root() -> Path:
+    """Best-effort source checkout root for git fingerprinting.
+
+    Source checkouts use ``.../src/leapflow/utils/build_info.py``, but packaged
+    installs may live under ``site-packages/leapflow`` without any repository
+    metadata. Walk upward looking for a real git checkout or a source-tree
+    ``pyproject.toml``; otherwise return the package directory. A non-checkout
+    cwd simply makes the later git calls return None (unknown), which is the
+    intended graceful degradation.
+    """
+    try:
+        here = Path(__file__).resolve()
+    except (OSError, RuntimeError, ValueError):
+        return Path.cwd()
+    for candidate in here.parents:
+        if (candidate / ".git").exists():
+            return candidate
+        if (candidate / "pyproject.toml").exists() and (candidate / "src" / "leapflow").exists():
+            return candidate
+    try:
+        return here.parents[1]
+    except IndexError:
+        return here.parent
+
+
+def _run_git(args: List[str], cwd: Path) -> Optional[str]:
+    """Run a short-lived, read-only git command; None on any failure or timeout."""
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=_GIT_TIMEOUT_S,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def _fingerprint(cwd: Path) -> Tuple[Optional[str], Optional[str]]:
+    """Return ``(commit, dirty_digest)`` for the source tree rooted at ``cwd``.
+
+    ``dirty_digest`` changes with any uncommitted edit (a short hash of
+    ``git status --porcelain``, so file contents themselves are never
+    retained). Both are None when ``cwd`` is not a git checkout, or git is
+    unavailable — callers must treat that as "unknown", never as a verdict.
+    """
+    commit = _run_git(["rev-parse", "--short=12", "HEAD"], cwd)
+    if commit is None:
+        return None, None
+    porcelain = _run_git(["status", "--porcelain", "--untracked-files=no"], cwd)
+    digest = (
+        hashlib.sha1(porcelain.encode("utf-8")).hexdigest()[:12]
+        if porcelain is not None
+        else None
+    )
+    return commit, digest
+
+
+@dataclass(frozen=True)
+class BuildInfo:
+    """A process's captured identity: package version + source-tree fingerprint."""
+
+    version: str
+    commit: Optional[str]
+    dirty_digest: Optional[str]
+    pid: int
+    started_at: float
+
+    def to_dict(self) -> dict:
+        """Serialize to a plain, JSON-safe dict for RPC/HTTP transport."""
+        return {
+            "version": self.version,
+            "commit": self.commit or "",
+            "dirty_digest": self.dirty_digest or "",
+            "pid": self.pid,
+            "started_at": self.started_at,
+        }
+
+
+def capture_build_info() -> BuildInfo:
+    """Capture this process's build fingerprint once, at startup."""
+    commit, digest = _fingerprint(_repo_root())
+    return BuildInfo(
+        version=__version__,
+        commit=commit,
+        dirty_digest=digest,
+        pid=os.getpid(),
+        started_at=time.time(),
+    )
+
+
+def is_stale(captured: BuildInfo) -> Optional[bool]:
+    """Return True when ``captured`` no longer matches the current source tree.
+
+    Always re-derives the *current* fingerprint via a fresh subprocess call, so
+    the answer reflects disk state right now — regardless of how long this
+    calling process itself has been running. None means "unknown" (no git
+    checkout found); render that distinctly from a definite fresh/stale verdict.
+    """
+    if captured.commit is None:
+        return None
+    commit, digest = _fingerprint(_repo_root())
+    if commit is None:
+        return None
+    return commit != captured.commit or digest != captured.dirty_digest
+
+
+__all__ = ["BuildInfo", "capture_build_info", "is_stale"]
diff --git a/src/leapflow/version.py b/src/leapflow/version.py
index e677663..3aa2f2f 100644
--- a/src/leapflow/version.py
+++ b/src/leapflow/version.py
@@ -1,3 +1,3 @@
 """Version information for leapflow."""
 
-__version__ = "0.0.8+main"
+__version__ = "0.0.9+main"
diff --git a/tests/README.md b/tests/README.md
index 4b4d28b..6e07668 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -268,6 +268,76 @@ make test-live      # or: make record-traffic
 
 ---
 
+## Mock Signal Injection (`tests/mock_signals/`)
+
+Standalone framework for injecting simulated real-time streaming signals into the full LeapFlow pipeline. Exercises: EventBus → normalize → memory → EventBridge → EventTrigger → MonitorManager → Finding.
+
+### How it works
+
+```
+SignalGenerator(config) → EventBus.handle_event(event_type, payload)
+  → normalize → privacy gate → memory ingest → _notify_subscribers()
+    → EventBridge.on_event() → trigger.matches() → debounce → trigger.notify()
+      → MonitorManager.run_watch_once() → Producer.observe() → Finding
+```
+
+The runner builds an in-process pipeline (pure-memory providers + temp DuckDB), arms event-driven watches for each signal type, then injects events concurrently via `asyncio.gather`.
+
+### Usage
+
+```bash
+# Local mode (in-process pipeline, no daemon needed)
+python -m tests.mock_signals                     # Default "normal" profile
+python -m tests.mock_signals -p burst            # High-frequency burst
+python -m tests.mock_signals -p stress           # Max throughput stress test
+python -m tests.mock_signals -p mixed            # All signal types simultaneously
+python -m tests.mock_signals -p gateway          # External platform signals
+python -m tests.mock_signals --list              # Show all profiles
+python -m tests.mock_signals -p normal -d 30     # Override duration (seconds)
+python -m tests.mock_signals -p burst -f 2.0     # Frequency multiplier
+
+# Daemon mode (inject into running leapd — TUI + LeapBoard see results in real time)
+python -m tests.mock_signals --daemon                  # Normal profile → leapd
+python -m tests.mock_signals --daemon -p burst         # Burst → leapd
+python -m tests.mock_signals --daemon -p stress -d 30  # 30s stress test → leapd
+```
+
+**Local mode** builds an isolated in-process pipeline for fast iteration. **Daemon mode** (`--daemon`) connects to the running `leapd` via RPC and injects signals into the daemon's live EventBus — use this to verify the full end-to-end chain including TUI notifications, LeapBoard updates (`/board signals`), and event-driven watch triggers.
+
+### Signal types
+
+| Generator | Event type | Configurable parameters |
+|-----------|------------|------------------------|
+| `FsChangeGenerator` | `fs.change` | paths, actions (created/modified/deleted/moved) |
+| `AppFocusGenerator` | `app.focus_change` | apps (bundle_id + app_name) |
+| `ClipboardGenerator` | `clipboard.change` | texts, content_type |
+| `InputGenerator` | `ui.action` | action_type (click/type/scroll), app_bundle_id |
+| `GatewaySignalGenerator` | `gateway.signal` | platform_id, signal_type |
+| `GatewayMessageGenerator` | `gateway.message.received` | platform_id, sender |
+
+### SignalConfig (common to all generators)
+
+| Parameter | Default | Meaning |
+|-----------|---------|---------|
+| `frequency_hz` | 1.0 | Events per second |
+| `burst_size` | 1 | Events per burst |
+| `burst_interval_s` | 0.0 | Pause between bursts |
+| `duration_s` | 5.0 | Total generation time |
+| `jitter_ms` | 50.0 | Random timing jitter |
+
+### File structure
+
+```
+tests/mock_signals/
+├── __init__.py       # Public API exports
+├── __main__.py       # CLI entry point
+├── generators.py     # 6 signal generators (BaseGenerator + subclasses)
+├── profiles.py       # 5 predefined scenarios (normal/burst/mixed/stress/gateway)
+└── runner.py         # Orchestrator: pipeline setup → inject → measure → report
+```
+
+---
+
 ## Quick Start
 
 ```bash
diff --git a/tests/mock_signals/__init__.py b/tests/mock_signals/__init__.py
new file mode 100644
index 0000000..e58ca1c
--- /dev/null
+++ b/tests/mock_signals/__init__.py
@@ -0,0 +1,29 @@
+"""Mock signal injection framework for LeapFlow end-to-end testing."""
+
+from tests.mock_signals.generators import (
+    BaseGenerator,
+    SignalConfig,
+    FsChangeGenerator,
+    AppFocusGenerator,
+    ClipboardGenerator,
+    InputGenerator,
+    GatewaySignalGenerator,
+    GatewayMessageGenerator,
+)
+from tests.mock_signals.profiles import PROFILES, ScenarioProfile
+from tests.mock_signals.runner import MockSignalRunner, RunResult
+
+__all__ = [
+    "SignalConfig",
+    "BaseGenerator",
+    "FsChangeGenerator",
+    "AppFocusGenerator",
+    "ClipboardGenerator",
+    "InputGenerator",
+    "GatewaySignalGenerator",
+    "GatewayMessageGenerator",
+    "PROFILES",
+    "ScenarioProfile",
+    "MockSignalRunner",
+    "RunResult",
+]
diff --git a/tests/mock_signals/__main__.py b/tests/mock_signals/__main__.py
new file mode 100644
index 0000000..c704d8d
--- /dev/null
+++ b/tests/mock_signals/__main__.py
@@ -0,0 +1,97 @@
+"""Mock signal injection for LeapFlow end-to-end testing.
+
+Usage:
+    python -m tests.mock_signals                    # Run default "normal" profile
+    python -m tests.mock_signals --profile burst    # Run "burst" profile
+    python -m tests.mock_signals --profile stress   # Run "stress" profile
+    python -m tests.mock_signals --daemon           # Inject into running leapd
+    python -m tests.mock_signals --list             # List available profiles
+    python -m tests.mock_signals --profile normal --duration 30  # Override duration
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+
+from tests.mock_signals.profiles import PROFILES
+from tests.mock_signals.runner import MockSignalRunner
+
+
+def _list_profiles() -> None:
+    """Print all available profiles with descriptions."""
+    print("\nAvailable signal profiles:\n")
+    for name, profile in sorted(PROFILES.items()):
+        print(f"  {name:<12} {profile.description}")
+        gen_names = [g[0] for g in profile.generators]
+        print(f"  {'':12} generators: {', '.join(gen_names)}")
+        print()
+
+
+async def _run_profile(
+    profile_name: str,
+    *,
+    daemon_mode: bool = False,
+    duration_override: float | None = None,
+    freq_multiplier: float | None = None,
+) -> int:
+    """Run a profile and print results. Returns exit code."""
+    mode_label = "DAEMON (injecting into running leapd)" if daemon_mode else "LOCAL (in-process pipeline)"
+    print(f"  Mode: {mode_label}")
+    runner = MockSignalRunner(
+        profile_name,
+        daemon_mode=daemon_mode,
+        duration_override=duration_override,
+        freq_multiplier=freq_multiplier,
+    )
+    result = await runner.run()
+    print(result.summary())
+    return 0 if not result.errors else 1
+
+
+def main() -> None:
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="LeapFlow mock signal injection framework"
+    )
+    parser.add_argument(
+        "--profile", "-p", default="normal", help="Signal profile name"
+    )
+    parser.add_argument(
+        "--list", "-l", action="store_true", help="List available profiles"
+    )
+    parser.add_argument(
+        "--duration", "-d", type=float, help="Override duration (seconds)"
+    )
+    parser.add_argument(
+        "--frequency", "-f", type=float, help="Override frequency multiplier"
+    )
+    parser.add_argument(
+        "--daemon", action="store_true",
+        help="Inject signals into running leapd via RPC (affects TUI/LeapBoard)",
+    )
+    args = parser.parse_args()
+
+    if args.list:
+        _list_profiles()
+        return
+
+    if args.profile not in PROFILES:
+        print(f"Error: unknown profile {args.profile!r}", file=sys.stderr)
+        print(f"Available: {', '.join(sorted(PROFILES))}", file=sys.stderr)
+        sys.exit(1)
+
+    exit_code = asyncio.run(
+        _run_profile(
+            args.profile,
+            daemon_mode=args.daemon,
+            duration_override=args.duration,
+            freq_multiplier=args.frequency,
+        )
+    )
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/mock_signals/generators.py b/tests/mock_signals/generators.py
new file mode 100644
index 0000000..2822501
--- /dev/null
+++ b/tests/mock_signals/generators.py
@@ -0,0 +1,294 @@
+"""Signal generators for mock injection testing.
+
+Each generator class produces events conforming to the LeapFlow observer
+payload contract.  All generators share a common SignalConfig and yield
+(event_type, payload) tuples on demand.
+"""
+
+from __future__ import annotations
+
+import random
+import string
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Any, Dict, Iterator, List, Optional
+
+
+@dataclass
+class SignalConfig:
+    """Common configuration for all signal generators."""
+
+    frequency_hz: float = 1.0
+    burst_size: int = 1
+    burst_interval_s: float = 0.0
+    duration_s: float = 5.0
+    jitter_ms: float = 50.0
+
+
+class BaseGenerator:
+    """Base class for signal generators.
+
+    Subclasses override ``_make_payload()`` to produce type-specific payloads.
+    The ``generate()`` iterator handles timing, bursting, and jitter uniformly.
+    """
+
+    event_type: str = "event.unknown"
+
+    def __init__(self, config: SignalConfig) -> None:
+        self.config = config
+
+    def generate(self) -> Iterator[tuple[str, Dict[str, Any]]]:
+        """Yield (event_type, payload) tuples according to config timing."""
+        cfg = self.config
+        interval = 1.0 / cfg.frequency_hz if cfg.frequency_hz > 0 else cfg.duration_s
+        start = time.monotonic()
+        deadline = start + cfg.duration_s
+
+        while time.monotonic() < deadline:
+            for _ in range(cfg.burst_size):
+                if time.monotonic() >= deadline:
+                    return
+                yield (self.event_type, self._make_payload())
+            # Simulate inter-event wait as a yield marker (actual sleeping
+            # is done by the runner to allow async interleaving)
+            jitter = random.uniform(0, cfg.jitter_ms / 1000.0)
+            wait = interval + jitter
+            if cfg.burst_interval_s > 0 and cfg.burst_size > 1:
+                wait = cfg.burst_interval_s + jitter
+            # Cap wait at remaining duration to avoid overshooting the deadline
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return
+            wait = min(wait, remaining)
+            yield ("__wait__", {"seconds": wait})
+
+    def _make_payload(self) -> Dict[str, Any]:
+        """Override in subclass to produce type-specific payload."""
+        raise NotImplementedError
+
+
+# ─── Concrete generators ─────────────────────────────────────────────────
+
+
+class FsChangeGenerator(BaseGenerator):
+    """File system change events."""
+
+    event_type = "event.fs_change"
+
+    def __init__(
+        self,
+        config: SignalConfig,
+        *,
+        paths: Optional[List[str]] = None,
+        actions: Optional[List[str]] = None,
+    ) -> None:
+        super().__init__(config)
+        self.paths = paths or [
+            f"/tmp/test/project/src/module_{i}.py" for i in range(20)
+        ]
+        self.actions = actions or ["created", "modified", "deleted", "modified", "modified"]
+
+    def _make_payload(self) -> Dict[str, Any]:
+        return {
+            "path": random.choice(self.paths),
+            "action": random.choice(self.actions),
+            "is_dir": False,
+            "_mono_ts": time.monotonic(),
+        }
+
+
+class AppFocusGenerator(BaseGenerator):
+    """Application focus change events."""
+
+    event_type = "event.app_focus_change"
+
+    _DEFAULT_APPS = [
+        {"bundle_id": "com.apple.Safari", "app_name": "Safari"},
+        {"bundle_id": "com.microsoft.VSCode", "app_name": "Visual Studio Code"},
+        {"bundle_id": "com.apple.Terminal", "app_name": "Terminal"},
+        {"bundle_id": "com.tinyspeck.slackmacgap", "app_name": "Slack"},
+        {"bundle_id": "com.apple.finder", "app_name": "Finder"},
+    ]
+
+    def __init__(
+        self,
+        config: SignalConfig,
+        *,
+        apps: Optional[List[Dict[str, str]]] = None,
+    ) -> None:
+        super().__init__(config)
+        self.apps = apps or self._DEFAULT_APPS
+
+    def _make_payload(self) -> Dict[str, Any]:
+        app = random.choice(self.apps)
+        return {
+            "bundle_id": app["bundle_id"],
+            "app_name": app["app_name"],
+            "pid": random.randint(1000, 99999),
+            "window_title": f"{app['app_name']} — Document {random.randint(1, 10)}",
+            "ts": time.time(),
+            "_mono_ts": time.monotonic(),
+        }
+
+
+class ClipboardGenerator(BaseGenerator):
+    """Clipboard change events."""
+
+    event_type = "event.clipboard_change"
+
+    _SAMPLE_TEXTS = [
+        "def hello_world():\n    print('Hello, World!')",
+        "SELECT * FROM users WHERE active = true;",
+        "https://github.com/leapflow/leapflow/pull/42",
+        "The quick brown fox jumps over the lazy dog.",
+        "import asyncio\n\nasync def main():\n    await asyncio.sleep(1)",
+        "ERROR: Connection refused at 127.0.0.1:5432",
+        '{"status": "ok", "data": [1, 2, 3]}',
+    ]
+
+    def __init__(
+        self,
+        config: SignalConfig,
+        *,
+        texts: Optional[List[str]] = None,
+        content_type: str = "text",
+    ) -> None:
+        super().__init__(config)
+        self.texts = texts or self._SAMPLE_TEXTS
+        self.content_type = content_type
+
+    def _make_payload(self) -> Dict[str, Any]:
+        text = random.choice(self.texts)
+        return {
+            "text": text,
+            "content_type": self.content_type,
+            "source_app": "",
+            "change_ts": time.time(),
+            "_mono_ts": time.monotonic(),
+        }
+
+
+class InputGenerator(BaseGenerator):
+    """User input events (click, type, scroll)."""
+
+    event_type = "event.ui_action"
+
+    def __init__(
+        self,
+        config: SignalConfig,
+        *,
+        action_type: str = "click",
+        app_bundle_id: str = "com.apple.Safari",
+    ) -> None:
+        super().__init__(config)
+        self.action_type = action_type
+        self.app_bundle_id = app_bundle_id
+
+    def _make_payload(self) -> Dict[str, Any]:
+        base: Dict[str, Any] = {
+            "action": self.action_type,
+            "app_bundle_id": self.app_bundle_id,
+            "timestamp": time.time(),
+            "_mono_ts": time.monotonic(),
+        }
+        if self.action_type == "click":
+            base["mouse_x"] = random.randint(0, 1920)
+            base["mouse_y"] = random.randint(0, 1080)
+        elif self.action_type == "type":
+            char = random.choice(string.ascii_lowercase + string.digits + " ")
+            base["key_code"] = random.randint(0, 127)
+            base["char"] = char
+        elif self.action_type == "scroll":
+            base["delta_x"] = 0
+            base["delta_y"] = random.choice([-3, -2, -1, 1, 2, 3])
+            base["mouse_x"] = random.randint(0, 1920)
+            base["mouse_y"] = random.randint(0, 1080)
+        return base
+
+
+class GatewaySignalGenerator(BaseGenerator):
+    """External platform signal events."""
+
+    event_type = "gateway.signal"
+
+    _SIGNAL_TYPES = ["message", "reaction", "mention", "status_change", "callback"]
+
+    def __init__(
+        self,
+        config: SignalConfig,
+        *,
+        platform_id: str = "feishu",
+        signal_type: str = "message",
+    ) -> None:
+        super().__init__(config)
+        self.platform_id = platform_id
+        self.signal_type = signal_type
+
+    def _make_payload(self) -> Dict[str, Any]:
+        return {
+            "event_id": uuid.uuid4().hex,
+            "platform_id": self.platform_id,
+            "signal_type": self.signal_type,
+            "_platform": self.platform_id,
+            "_mono_ts": time.monotonic(),
+        }
+
+
+class GatewayMessageGenerator(BaseGenerator):
+    """External platform message events."""
+
+    event_type = "gateway.message.received"
+
+    _SAMPLE_MESSAGES = [
+        "Hey, can you check the latest PR?",
+        "Meeting at 3pm today",
+        "The deployment failed again",
+        "LGTM, ship it!",
+        "Can you help me debug this issue?",
+        "Updated the design doc, please review",
+    ]
+
+    def __init__(
+        self,
+        config: SignalConfig,
+        *,
+        platform_id: str = "feishu",
+        sender: str = "test_user",
+    ) -> None:
+        super().__init__(config)
+        self.platform_id = platform_id
+        self.sender = sender
+
+    def _make_payload(self) -> Dict[str, Any]:
+        return {
+            "event_id": uuid.uuid4().hex,
+            "platform_id": self.platform_id,
+            "sender": self.sender,
+            "text": random.choice(self._SAMPLE_MESSAGES),
+            "_platform": self.platform_id,
+            "_mono_ts": time.monotonic(),
+        }
+
+
+# Generator class registry for dynamic resolution by name
+GENERATOR_REGISTRY: Dict[str, type] = {
+    "FsChangeGenerator": FsChangeGenerator,
+    "AppFocusGenerator": AppFocusGenerator,
+    "ClipboardGenerator": ClipboardGenerator,
+    "InputGenerator": InputGenerator,
+    "GatewaySignalGenerator": GatewaySignalGenerator,
+    "GatewayMessageGenerator": GatewayMessageGenerator,
+}
+
+__all__ = [
+    "SignalConfig",
+    "BaseGenerator",
+    "FsChangeGenerator",
+    "AppFocusGenerator",
+    "ClipboardGenerator",
+    "InputGenerator",
+    "GatewaySignalGenerator",
+    "GatewayMessageGenerator",
+    "GENERATOR_REGISTRY",
+]
diff --git a/tests/mock_signals/profiles.py b/tests/mock_signals/profiles.py
new file mode 100644
index 0000000..1b00103
--- /dev/null
+++ b/tests/mock_signals/profiles.py
@@ -0,0 +1,74 @@
+"""Predefined signal injection scenarios (profiles).
+
+Each profile describes a complete scenario with a mix of generators and their
+configuration.  Profiles are resolved by name in the runner and CLI.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Tuple
+
+from tests.mock_signals.generators import SignalConfig
+
+
+@dataclass
+class ScenarioProfile:
+    """A complete signal injection scenario."""
+
+    name: str
+    description: str
+    generators: List[Tuple[str, Dict[str, Any]]] = field(default_factory=list)
+
+
+PROFILES: Dict[str, ScenarioProfile] = {
+    "normal": ScenarioProfile(
+        name="normal",
+        description="Normal user workflow: periodic fs changes, occasional app switches, typing",
+        generators=[
+            ("FsChangeGenerator", {"config": SignalConfig(frequency_hz=0.5, duration_s=10)}),
+            ("AppFocusGenerator", {"config": SignalConfig(frequency_hz=0.1, duration_s=10)}),
+            ("InputGenerator", {"config": SignalConfig(frequency_hz=2.0, duration_s=10), "action_type": "type"}),
+        ],
+    ),
+    "burst": ScenarioProfile(
+        name="burst",
+        description="High-frequency burst: rapid file saves, fast typing",
+        generators=[
+            ("FsChangeGenerator", {"config": SignalConfig(frequency_hz=20.0, burst_size=5, duration_s=5)}),
+            ("InputGenerator", {"config": SignalConfig(frequency_hz=10.0, duration_s=5), "action_type": "type"}),
+        ],
+    ),
+    "mixed": ScenarioProfile(
+        name="mixed",
+        description="Mixed signals: all types simultaneously",
+        generators=[
+            ("FsChangeGenerator", {"config": SignalConfig(frequency_hz=1.0, duration_s=8)}),
+            ("AppFocusGenerator", {"config": SignalConfig(frequency_hz=0.3, duration_s=8)}),
+            ("ClipboardGenerator", {"config": SignalConfig(frequency_hz=0.2, duration_s=8)}),
+            ("InputGenerator", {"config": SignalConfig(frequency_hz=3.0, duration_s=8), "action_type": "click"}),
+            ("GatewaySignalGenerator", {"config": SignalConfig(frequency_hz=0.5, duration_s=8)}),
+        ],
+    ),
+    "stress": ScenarioProfile(
+        name="stress",
+        description="Stress test: maximum throughput across all signal types",
+        generators=[
+            ("FsChangeGenerator", {"config": SignalConfig(frequency_hz=50.0, burst_size=10, duration_s=10)}),
+            ("InputGenerator", {"config": SignalConfig(frequency_hz=20.0, duration_s=10), "action_type": "click"}),
+            ("ClipboardGenerator", {"config": SignalConfig(frequency_hz=5.0, duration_s=10)}),
+            ("GatewaySignalGenerator", {"config": SignalConfig(frequency_hz=10.0, duration_s=10)}),
+        ],
+    ),
+    "gateway": ScenarioProfile(
+        name="gateway",
+        description="Gateway focused: external platform signals and messages",
+        generators=[
+            ("GatewaySignalGenerator", {"config": SignalConfig(frequency_hz=2.0, duration_s=10)}),
+            ("GatewayMessageGenerator", {"config": SignalConfig(frequency_hz=1.0, duration_s=10)}),
+        ],
+    ),
+}
+
+
+__all__ = ["ScenarioProfile", "PROFILES"]
diff --git a/tests/mock_signals/runner.py b/tests/mock_signals/runner.py
new file mode 100644
index 0000000..a053cfa
--- /dev/null
+++ b/tests/mock_signals/runner.py
@@ -0,0 +1,459 @@
+"""Orchestrator: build pipeline, inject signals, collect metrics, report results.
+
+The runner constructs a minimal in-memory LeapFlow pipeline (EventBus + MonitorManager)
+and drives generated signals through it, measuring throughput, latency, debounce
+behavior, and finding production.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import tempfile
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Sequence
+
+from leapflow.memory.providers.episodic import EpisodicMemoryProvider
+from leapflow.memory.providers.working import WorkingMemoryProvider
+from leapflow.monitor.manager import MonitorManager
+from leapflow.monitor.producers import ProducerRegistry
+from leapflow.monitor.types import (
+    Finding,
+    ProducerContext,
+    Severity,
+    WatchSpec,
+)
+from leapflow.platform.event_bus import EventBus
+from leapflow.storage.connection import LocalConnectionHolder
+
+from tests.mock_signals.generators import GENERATOR_REGISTRY, BaseGenerator, SignalConfig
+from tests.mock_signals.profiles import PROFILES
+
+
+# ─── Passthrough producer ────────────────────────────────────────────────
+
+
+class _PassthroughProducer:
+    """Trivial producer that always emits a finding when triggered.
+
+    Used to verify that the event-driven watch pipeline fires end-to-end.
+    """
+
+    def __init__(self, domain: str) -> None:
+        self._domain = domain
+        self.call_count = 0
+
+    @property
+    def domain(self) -> str:
+        return self._domain
+
+    async def observe(self, ctx: ProducerContext) -> Sequence[Finding]:
+        self.call_count += 1
+        return [
+            Finding(
+                watch_id=ctx.spec.watch_id,
+                domain=self._domain,
+                title=f"Signal observed ({self._domain})",
+                summary=f"Run #{self.call_count}",
+                severity=Severity.INFO,
+            )
+        ]
+
+
+# ─── Result dataclass ────────────────────────────────────────────────────
+
+
+@dataclass
+class RunResult:
+    """Aggregated results from a mock signal injection run."""
+
+    profile: str
+    daemon_mode: bool = False
+    duration_s: float = 0.0
+    events_injected: int = 0
+    events_per_type: Dict[str, int] = field(default_factory=dict)
+    triggers_fired: int = 0
+    debounced_count: int = 0
+    findings_produced: int = 0
+    avg_latency_ms: float = 0.0
+    p99_latency_ms: float = 0.0
+    max_latency_ms: float = 0.0
+    errors: List[str] = field(default_factory=list)
+
+    def summary(self) -> str:
+        """Return a formatted human-readable summary."""
+        if self.daemon_mode:
+            return self._daemon_summary()
+        return self._local_summary()
+
+    def _daemon_summary(self) -> str:
+        """Summary format for daemon injection mode."""
+        lines: List[str] = []
+        sep = "\u2550" * 55
+        lines.append(f"\n{sep}")
+        lines.append(f"  LeapFlow Mock Signal Injection \u2014 {self.profile}")
+        lines.append("  Mode: DAEMON (leapd RPC)")
+        lines.append(sep)
+        lines.append("")
+        lines.append(f"  Duration:        {self.duration_s:.2f}s")
+        lines.append(f"  Events injected: {self.events_injected}")
+        lines.append("  Events by type:")
+        total = max(self.events_injected, 1)
+        for etype, count in sorted(self.events_per_type.items(), key=lambda x: -x[1]):
+            pct = count / total * 100
+            lines.append(f"    {etype:<20} {count:>5} ({pct:.1f}%)")
+        lines.append("")
+        if self.duration_s > 0:
+            rate = self.events_injected / self.duration_s
+            lines.append(f"  Injection rate:  {rate:.1f} events/s")
+        lines.append(f"  Errors: {len(self.errors)}")
+        if self.errors:
+            for err in self.errors[:5]:
+                lines.append(f"    - {err}")
+        lines.append("")
+        status = "\u2713 DONE (check TUI/LeapBoard for results)" if not self.errors else "\u2717 FAIL"
+        lines.append(f"  Status: {status}")
+        lines.append(sep)
+        return "\n".join(lines)
+
+    def _local_summary(self) -> str:
+        """Summary format for local in-process mode."""
+        lines: List[str] = []
+        sep = "\u2550" * 55
+        lines.append(f"\n{sep}")
+        lines.append(f"  LeapFlow Mock Signal Injection \u2014 Profile: {self.profile}")
+        lines.append(sep)
+        lines.append("")
+        lines.append(f"  Duration:          {self.duration_s:.2f}s")
+        lines.append(f"  Events injected:   {self.events_injected}")
+        lines.append("  Events by type:")
+        total = max(self.events_injected, 1)
+        for etype, count in sorted(self.events_per_type.items(), key=lambda x: -x[1]):
+            pct = count / total * 100
+            lines.append(f"    {etype:<20} {count:>5} ({pct:.1f}%)")
+        lines.append("")
+        lines.append("  Monitor results:")
+        lines.append(f"    Triggers fired:  {self.triggers_fired:>5}")
+        lines.append(f"    Debounced:       {self.debounced_count:>5}")
+        lines.append(f"    Findings:        {self.findings_produced:>5}")
+        lines.append("")
+        lines.append("  Latency (event \u2192 trigger):")
+        lines.append(f"    Avg:             {self.avg_latency_ms:.1f}ms")
+        lines.append(f"    P99:             {self.p99_latency_ms:.1f}ms")
+        lines.append(f"    Max:             {self.max_latency_ms:.1f}ms")
+        lines.append("")
+        lines.append(f"  Errors: {len(self.errors)}")
+        if self.errors:
+            for err in self.errors[:5]:
+                lines.append(f"    - {err}")
+        lines.append("")
+        status = "\u2713 PASS" if not self.errors else "\u2717 FAIL"
+        lines.append(f"  Status: {status}")
+        lines.append(sep)
+        return "\n".join(lines)
+
+
+# ─── Runner ──────────────────────────────────────────────────────────────
+
+
+class MockSignalRunner:
+    """Orchestrates signal injection and validates end-to-end pipeline."""
+
+    def __init__(
+        self,
+        profile_name: str = "normal",
+        *,
+        daemon_mode: bool = False,
+        tmp_dir: Optional[Path] = None,
+        duration_override: Optional[float] = None,
+        freq_multiplier: Optional[float] = None,
+    ) -> None:
+        if profile_name not in PROFILES:
+            raise ValueError(
+                f"Unknown profile: {profile_name!r}. "
+                f"Available: {', '.join(sorted(PROFILES))}"
+            )
+        self._profile_name = profile_name
+        self._profile = PROFILES[profile_name]
+        self._daemon_mode = daemon_mode
+        self._tmp_dir = tmp_dir
+        self._duration_override = duration_override
+        self._freq_multiplier = freq_multiplier
+
+    async def run(self) -> RunResult:
+        """Execute the full scenario and return results."""
+        if self._daemon_mode:
+            return await self._run_daemon_mode()
+        return await self._run_local_mode()
+
+    async def _run_daemon_mode(self) -> RunResult:
+        """Inject signals into running leapd via RPC.
+
+        Generators run concurrently (matching local mode) so that
+        different signal types overlap realistically.  Inter-event
+        waits use the profile-intended timing so the daemon's
+        EventBridge debounce windows work as designed.
+        """
+        from leapflow.config import _bootstrap_profile_layout
+        from leapflow.daemon.client import DaemonClient, DaemonUnavailableError
+
+        result = RunResult(profile=self._profile_name, daemon_mode=True)
+
+        # Resolve socket path from profile layout
+        try:
+            layout = _bootstrap_profile_layout()
+            sock_path = layout.runtime_dir / "leapd.sock"
+        except Exception as e:
+            result.errors.append(f"Cannot resolve daemon socket path: {e}")
+            return result
+
+        client = DaemonClient(sock_path, timeout_s=10.0)
+
+        # Verify daemon connectivity
+        try:
+            await client.status()
+        except DaemonUnavailableError as e:
+            result.errors.append(f"Cannot connect to leapd: {e}")
+            return result
+        except Exception as e:
+            result.errors.append(f"Cannot connect to leapd: {e}")
+            return result
+
+        # Build generators (same as local mode)
+        generators = self._build_generators()
+        t0 = time.monotonic()
+        _lock = asyncio.Lock()
+        injected = 0
+        errors: List[str] = []
+        events_per_type: Dict[str, int] = {}
+        _progress_count = 0
+
+        async def _inject_from(gen: BaseGenerator) -> None:
+            """Inject events from a single generator concurrently."""
+            nonlocal injected, _progress_count
+            for event_type, payload in gen.generate():
+                if event_type == "__wait__":
+                    wait_s = payload.get("seconds", 0.01)
+                    await asyncio.sleep(wait_s)
+                    continue
+                try:
+                    await client.signal_record(event_type, payload)
+                except Exception as exc:
+                    async with _lock:
+                        errors.append(f"{event_type}: {exc}")
+                    continue
+                async with _lock:
+                    injected += 1
+                    _progress_count += 1
+                    display_type = self._display_event_type(event_type)
+                    events_per_type[display_type] = events_per_type.get(display_type, 0) + 1
+                    if _progress_count % 20 == 0:
+                        elapsed = time.monotonic() - t0
+                        print(f"    \r  injected {_progress_count} events ({elapsed:.1f}s)", end="", flush=True)
+
+        await asyncio.gather(*[_inject_from(gen) for gen in generators])
+
+        # Clear progress line
+        if _progress_count >= 20:
+            print()
+
+        result.duration_s = time.monotonic() - t0
+        result.events_injected = injected
+        result.events_per_type = events_per_type
+        result.errors = errors
+        return result
+
+    async def _run_local_mode(self) -> RunResult:
+        """Run in-process pipeline (original behavior)."""
+        tmp = self._tmp_dir or Path(tempfile.mkdtemp(prefix="leapflow-mock-"))
+        db_path = tmp / "mock.duckdb"
+
+        # 1. Build infrastructure
+        episodic = EpisodicMemoryProvider(ttl=300.0)
+        working = WorkingMemoryProvider(max_tokens=2048)
+        event_bus = EventBus(immediate=episodic, working=working)
+
+        holder = LocalConnectionHolder(db_path)
+        producers = ProducerRegistry()
+        monitor = MonitorManager(holder=holder, producers=producers, tick_seconds=1)
+
+        # 2. Wire EventBus -> EventBridge
+        event_bus.subscribe(monitor.event_bridge.on_event)
+
+        # 3. Register producers and arm watches for each signal domain
+        domain_patterns = self._resolve_domain_patterns()
+        producer_instances: Dict[str, _PassthroughProducer] = {}
+        watch_ids: List[str] = []
+
+        await monitor.start()
+
+        for domain, pattern in domain_patterns.items():
+            producer = _PassthroughProducer(domain)
+            producers.register(producer)
+            producer_instances[domain] = producer
+
+            spec = WatchSpec(
+                name=f"mock-{domain}",
+                domain=domain,
+                trigger_expr=f"event:{pattern}",
+                sensitivity="info",
+            )
+            view = await monitor.arm_watch(spec)
+            watch_ids.append(view.watch_id)
+
+        # 4. Build generators
+        generators = self._build_generators()
+
+        # 5. Inject events concurrently from all generators
+        result = RunResult(profile=self._profile_name)
+        latencies: List[float] = []
+        _lock = asyncio.Lock()
+        t0 = time.monotonic()
+
+        async def _inject_from(gen: BaseGenerator) -> None:
+            """Inject events from a single generator."""
+            for event_type, payload in gen.generate():
+                if event_type == "__wait__":
+                    wait_s = payload.get("seconds", 0.01)
+                    await asyncio.sleep(min(wait_s, 0.05))
+                    continue
+
+                inject_ts = time.monotonic()
+                try:
+                    await event_bus.handle_event(event_type, payload)
+                    latency_ms = (time.monotonic() - inject_ts) * 1000.0
+                except Exception as exc:
+                    async with _lock:
+                        result.errors.append(f"{event_type}: {exc}")
+                    continue
+
+                async with _lock:
+                    latencies.append(latency_ms)
+                    result.events_injected += 1
+                    display_type = self._display_event_type(event_type)
+                    result.events_per_type[display_type] = (
+                        result.events_per_type.get(display_type, 0) + 1
+                    )
+
+        await asyncio.gather(*[_inject_from(gen) for gen in generators])
+
+        # Allow final triggers/ticks to process
+        await asyncio.sleep(0.1)
+
+        # Manually run each watch once to simulate scheduler executing
+        # triggered event watches (the scheduler tick creates new trigger
+        # instances from serialized config and can't see in-memory state).
+        for wid in watch_ids:
+            try:
+                await monitor.run_watch_once(wid)
+            except Exception:
+                pass
+
+        result.duration_s = time.monotonic() - t0
+
+        # 6. Collect statistics
+        # triggers_fired = non-debounced events that passed through EventBridge
+        total_debounced = sum(
+            monitor.event_bridge.debounced_count(wid) for wid in watch_ids
+        )
+        total_findings = sum(
+            len(monitor.list_findings(watch_id=wid)) for wid in watch_ids
+        )
+
+        result.triggers_fired = sum(p.call_count for p in producer_instances.values())
+        result.debounced_count = total_debounced
+        result.findings_produced = total_findings
+
+        if latencies:
+            latencies.sort()
+            result.avg_latency_ms = sum(latencies) / len(latencies)
+            p99_idx = int(len(latencies) * 0.99)
+            result.p99_latency_ms = latencies[min(p99_idx, len(latencies) - 1)]
+            result.max_latency_ms = latencies[-1]
+
+        # 7. Cleanup
+        await monitor.stop()
+        await event_bus.shutdown()
+        holder.close()
+
+        return result
+
+    def _resolve_domain_patterns(self) -> Dict[str, str]:
+        """Map generator event types to monitor domain + event pattern pairs."""
+        mapping: Dict[str, str] = {}
+        for gen_name, _ in self._profile.generators:
+            cls = GENERATOR_REGISTRY.get(gen_name)
+            if cls is None:
+                continue
+            etype = cls.event_type
+            # Derive a domain key and an fnmatch pattern
+            if etype.startswith("event."):
+                # e.g. "event.fs_change" -> domain "fs", pattern "fs.*"
+                suffix = etype.removeprefix("event.")
+                domain = suffix.split("_")[0]
+                # Normalized event type from EventBus fallback
+                normalized = self._normalized_event_type(etype)
+                pattern = f"{normalized}*" if not normalized.endswith("*") else normalized
+                mapping[domain] = pattern
+            elif etype.startswith("gateway."):
+                domain = "gateway"
+                mapping[domain] = "gateway.*"
+            else:
+                domain = etype.replace(".", "_")
+                mapping[domain] = f"{etype}*"
+        return mapping
+
+    def _normalized_event_type(self, raw_type: str) -> str:
+        """Predict the normalized event_type that EventBus will produce."""
+        type_map = {
+            "event.fs_change": "fs.change",
+            "event.clipboard_change": "clipboard.change",
+            "event.app_focus_change": "app.focus_change",
+            "event.ui_action": "ui.action",
+        }
+        return type_map.get(raw_type, raw_type)
+
+    def _display_event_type(self, raw_type: str) -> str:
+        """Return a compact display name for output."""
+        display_map = {
+            "event.fs_change": "fs.change",
+            "event.clipboard_change": "clipboard.change",
+            "event.app_focus_change": "app.focus_change",
+            "event.ui_action": "ui.action",
+            "gateway.signal": "gateway.signal",
+            "gateway.message.received": "gateway.message",
+        }
+        return display_map.get(raw_type, raw_type)
+
+    def _build_generators(self) -> List[BaseGenerator]:
+        """Instantiate generators from profile spec with optional overrides."""
+        generators: List[BaseGenerator] = []
+        for gen_name, kwargs in self._profile.generators:
+            cls = GENERATOR_REGISTRY.get(gen_name)
+            if cls is None:
+                continue
+            gen_kwargs = dict(kwargs)
+            config = gen_kwargs.pop("config", SignalConfig())
+            # Apply overrides
+            if self._duration_override is not None:
+                config = SignalConfig(
+                    frequency_hz=config.frequency_hz,
+                    burst_size=config.burst_size,
+                    burst_interval_s=config.burst_interval_s,
+                    duration_s=self._duration_override,
+                    jitter_ms=config.jitter_ms,
+                )
+            if self._freq_multiplier is not None:
+                config = SignalConfig(
+                    frequency_hz=config.frequency_hz * self._freq_multiplier,
+                    burst_size=config.burst_size,
+                    burst_interval_s=config.burst_interval_s,
+                    duration_s=config.duration_s,
+                    jitter_ms=config.jitter_ms,
+                )
+            generators.append(cls(config, **gen_kwargs))
+        return generators
+
+
+__all__ = ["MockSignalRunner", "RunResult"]
diff --git a/tests/test_build_info.py b/tests/test_build_info.py
new file mode 100644
index 0000000..7c2eea5
--- /dev/null
+++ b/tests/test_build_info.py
@@ -0,0 +1,187 @@
+"""Hermetic tests for leapflow.utils.build_info (long-lived-process staleness).
+
+All git subprocess calls are monkeypatched at the module's ``_fingerprint``
+seam, so these tests never depend on the actual repository's git state (or
+git being installed at all) and run identically in any CI environment.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional, Tuple
+
+import pytest
+
+from leapflow.utils import build_info
+from leapflow.version import __version__
+
+
+def _patch_fingerprint(monkeypatch: pytest.MonkeyPatch, values) -> None:
+    """Make ``_fingerprint`` return successive ``values`` on each call."""
+    it = iter(values)
+
+    def _fake(cwd: Path) -> Tuple[Optional[str], Optional[str]]:
+        return next(it)
+
+    monkeypatch.setattr(build_info, "_fingerprint", _fake)
+
+
+# ── capture_build_info ───────────────────────────────────────────────────────
+
+
+def test_capture_build_info_reports_process_identity(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_fingerprint(monkeypatch, [("abc123", "d1")])
+
+    info = build_info.capture_build_info()
+
+    assert info.version == __version__
+    assert info.pid == os.getpid()
+    assert info.commit == "abc123"
+    assert info.dirty_digest == "d1"
+    assert info.started_at > 0
+
+
+def test_capture_build_info_outside_git_checkout_is_unknown(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_fingerprint(monkeypatch, [(None, None)])
+
+    info = build_info.capture_build_info()
+
+    assert info.commit is None
+    assert info.dirty_digest is None
+
+
+# ── is_stale ─────────────────────────────────────────────────────────────────
+
+
+def test_is_stale_false_when_fingerprint_unchanged(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_fingerprint(monkeypatch, [("abc123", "d1"), ("abc123", "d1")])
+
+    info = build_info.capture_build_info()
+    assert build_info.is_stale(info) is False
+
+
+def test_is_stale_true_when_commit_advances(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Simulates: process starts at commit abc123, a new commit lands afterwards.
+    _patch_fingerprint(monkeypatch, [("abc123", "d1"), ("def456", "d1")])
+
+    info = build_info.capture_build_info()
+    assert build_info.is_stale(info) is True
+
+
+def test_is_stale_true_when_working_tree_becomes_dirty(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Same commit, but an uncommitted edit landed after the process started.
+    _patch_fingerprint(monkeypatch, [("abc123", "d1"), ("abc123", "d2")])
+
+    info = build_info.capture_build_info()
+    assert build_info.is_stale(info) is True
+
+
+def test_is_stale_none_outside_git_checkout(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_fingerprint(monkeypatch, [(None, None), (None, None)])
+
+    info = build_info.capture_build_info()
+    assert build_info.is_stale(info) is None
+
+
+def test_is_stale_none_when_git_disappears_after_capture(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Captured inside a checkout, but the live re-check can no longer find git
+    # (e.g. run from a different cwd) — must degrade to unknown, not "stale".
+    _patch_fingerprint(monkeypatch, [("abc123", "d1"), (None, None)])
+
+    info = build_info.capture_build_info()
+    assert build_info.is_stale(info) is None
+
+
+# ── to_dict ──────────────────────────────────────────────────────────────────
+
+
+def test_to_dict_is_plain_json_safe_and_coerces_none_to_empty_string(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _patch_fingerprint(monkeypatch, [(None, None)])
+    info = build_info.capture_build_info()
+
+    data = info.to_dict()
+
+    assert data == {
+        "version": __version__,
+        "commit": "",
+        "dirty_digest": "",
+        "pid": os.getpid(),
+        "started_at": info.started_at,
+    }
+
+
+# ── _run_git: graceful degradation on subprocess failure ────────────────────
+
+
+def test_run_git_returns_none_when_binary_missing(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _raise(*args, **kwargs):
+        raise FileNotFoundError("git not found")
+
+    monkeypatch.setattr(subprocess, "run", _raise)
+    assert build_info._run_git(["rev-parse", "HEAD"], Path(".")) is None
+
+
+def test_run_git_returns_none_on_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _raise(*args, **kwargs):
+        raise subprocess.TimeoutExpired(cmd="git", timeout=1.5)
+
+    monkeypatch.setattr(subprocess, "run", _raise)
+    assert build_info._run_git(["status"], Path(".")) is None
+
+
+def test_run_git_returns_none_on_nonzero_exit(monkeypatch: pytest.MonkeyPatch) -> None:
+    class _FakeResult:
+        returncode = 128
+        stdout = ""
+
+    monkeypatch.setattr(subprocess, "run", lambda *a, **k: _FakeResult())
+    assert build_info._run_git(["rev-parse", "HEAD"], Path(".")) is None
+
+
+# ── _repo_root: source checkout and packaged-install degradation ─────────────
+
+
+def test_repo_root_finds_source_checkout_above_src_layout(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    root = tmp_path / "repo"
+    module_file = root / "src" / "leapflow" / "utils" / "build_info.py"
+    module_file.parent.mkdir(parents=True)
+    (root / ".git").mkdir()
+    monkeypatch.setattr(build_info, "__file__", str(module_file))
+
+    assert build_info._repo_root() == root
+
+
+def test_repo_root_degrades_without_fixed_parent_depth(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    package_root = tmp_path / "site-packages" / "leapflow"
+    module_file = package_root / "utils" / "build_info.py"
+    module_file.parent.mkdir(parents=True)
+    monkeypatch.setattr(build_info, "__file__", str(module_file))
+
+    # Packaged installs have no .git/pyproject source root; this must still
+    # return a usable cwd for git probing (which then degrades to None), never
+    # raise from a fixed parents[3] assumption.
+    assert build_info._repo_root() == package_root
+
+
+# ── Integration smoke: this repository really is a git checkout ────────────
+
+
+def test_capture_build_info_against_real_repo_is_internally_consistent() -> None:
+    """No monkeypatch: exercises the real git subprocess calls once.
+
+    This repository is a git checkout, so commit should resolve; whatever it
+    resolves to, checking staleness immediately afterward must be False
+    (nothing changed between the two calls a few milliseconds apart).
+    """
+    info = build_info.capture_build_info()
+    if info.commit is None:
+        pytest.skip("not a git checkout in this environment")
+    assert build_info.is_stale(info) is False
diff --git a/tests/test_cli_ndjson_event_source.py b/tests/test_cli_ndjson_event_source.py
index 8049c88..3088bde 100644
--- a/tests/test_cli_ndjson_event_source.py
+++ b/tests/test_cli_ndjson_event_source.py
@@ -70,6 +70,7 @@ def __init__(
             else [b"[event] ready event_key=test.event\n"],
         )
         self.stdin = FakeStreamWriter()
+        self.pid: int = 99999  # Fake PID for ProcessGroup.attach()
         self.returncode: int | None = None
         self._exit_code = exit_code
 
diff --git a/tests/test_config_and_path_contracts.py b/tests/test_config_and_path_contracts.py
index a6f3f73..6e67c93 100644
--- a/tests/test_config_and_path_contracts.py
+++ b/tests/test_config_and_path_contracts.py
@@ -167,6 +167,26 @@ def test_describe_exposes_every_field_the_contract_requires(monkeypatch, tmp_pat
     assert view.value_hint
 
 
+def test_signal_noise_config_fields_are_discoverable(monkeypatch, tmp_path) -> None:
+    monkeypatch.setenv("LEAPFLOW_HOME", str(tmp_path / "home"))
+    from leapflow.config import get_settings
+
+    service = ConfigService(get_settings())
+
+    for key in (
+        "signal.noise_gate_enabled",
+        "signal.noise_same_source_cooldown_s",
+        "signal.noise_allow_fs_outside_workspace",
+        "signal.noise_path_fragments",
+        "signal.noise_dir_names",
+        "signal.noise_suffixes",
+    ):
+        view = service.describe(key)
+        assert view.category == "Signal Fusion"
+        assert view.description
+        assert view.hot_reload in _VALID_HOT_RELOAD
+
+
 def test_unknown_key_is_rejected_rather_than_silently_accepted(monkeypatch, tmp_path) -> None:
     """Both read and write reject an unknown key loudly.
 
diff --git a/tests/test_daemon_rpc.py b/tests/test_daemon_rpc.py
index 2eb97a1..872edf0 100644
--- a/tests/test_daemon_rpc.py
+++ b/tests/test_daemon_rpc.py
@@ -526,6 +526,26 @@ async def test_runtime_service_default_admission_capacity_is_three(tmp_path) ->
     assert status["turn_admission"]["waiting"] == 0
 
 
+@pytest.mark.asyncio
+async def test_runtime_service_status_reports_own_build_staleness(tmp_path, monkeypatch) -> None:
+    """status() must self-report whether this daemon process (captured once at
+    __init__) still matches the source tree, so a stale long-lived leapd is
+    diagnosable from 'leap daemon status' instead of looking like a bug.
+    """
+    from conftest import make_settings
+    import leapflow.daemon.service as service_module
+
+    service = service_module.RuntimeLeapService(make_settings(str(tmp_path)), mock_host=True)
+    captured_pid = service._build_info.pid
+    monkeypatch.setattr(service_module, "is_stale", lambda info: True)
+
+    status = await service.status()
+
+    assert status["build"]["pid"] == captured_pid
+    assert status["build"]["version"]
+    assert status["build"]["stale"] is True
+
+
 @pytest.mark.asyncio
 async def test_engine_chat_emits_queued_status_when_busy() -> None:
     """When the daemon is at capacity (all turn slots busy), a waiting client
diff --git a/tests/test_daemon_transport.py b/tests/test_daemon_transport.py
new file mode 100644
index 0000000..18c5770
--- /dev/null
+++ b/tests/test_daemon_transport.py
@@ -0,0 +1,24 @@
+"""Hermetic tests for cross-platform daemon transport helpers."""
+from __future__ import annotations
+
+import pytest
+
+from leapflow.daemon._transport import TcpLoopbackTransport
+
+
+def test_tcp_loopback_transport_rejects_corrupt_port_file(tmp_path) -> None:
+    transport = TcpLoopbackTransport()
+    (tmp_path / "leapd.port").write_text("not-a-port", encoding="utf-8")
+
+    with pytest.raises(OSError, match="invalid daemon port file"):
+        transport._read_port(tmp_path)
+    assert transport.probe_healthy(tmp_path) is False
+
+
+def test_tcp_loopback_transport_rejects_out_of_range_port(tmp_path) -> None:
+    transport = TcpLoopbackTransport()
+    (tmp_path / "leapd.port").write_text("70000", encoding="utf-8")
+
+    with pytest.raises(OSError, match="invalid daemon port value"):
+        transport._read_port(tmp_path)
+    assert transport.probe_healthy(tmp_path) is False
diff --git a/tests/test_dashboard_i18n_static.py b/tests/test_dashboard_i18n_static.py
new file mode 100644
index 0000000..886dabe
--- /dev/null
+++ b/tests/test_dashboard_i18n_static.py
@@ -0,0 +1,71 @@
+"""Static regression guards for LeapBoard frontend i18n coverage.
+
+There is no JS test runner in this repository yet, so these tests protect the
+high-value failure mode directly in the source: dynamic LeapBoard strings must
+use t()/tx()/fmt() instead of hardcoded English in render paths.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+_APP_JS = Path(__file__).parents[1] / "src" / "leapflow" / "dashboard" / "static" / "app.js"
+
+
+def _source() -> str:
+    return _APP_JS.read_text(encoding="utf-8")
+
+
+def test_signal_timeline_dynamic_text_uses_i18n_helpers() -> None:
+    src = _source()
+
+    assert 'fmt("seconds ago"' in src
+    assert 'fmt("minutes ago"' in src
+    assert 'fmt("hours ago"' in src
+    assert 't("All")' in src
+    assert 'fmt("Showing {shown} of {total} recent events."' in src
+    assert 'fmt("Showing {shown} of {total} {family} events."' in src
+    assert 'badge.textContent = "\\u26a0 " + t("stale build")' in src
+    assert 'badge.textContent = "\\u26a0 stale build"' not in src
+    assert '+ "s ago"' not in src
+    assert 'footer.textContent = "Showing " +' not in src
+
+
+def test_tables_and_chart_labels_route_through_translation() -> None:
+    src = _source()
+
+    assert 'esc(tx(row.label))' in src
+    assert 'esc(tx(v))' in src
+
+
+def test_connection_status_updates_data_i18n_and_text_together() -> None:
+    src = _source()
+
+    assert "function setConnectionStatus(key)" in src
+    assert "statusEl.dataset.i18n = key" in src
+    assert "statusEl.textContent = t(key)" in src
+    assert 'ws.onopen = () => { setConnectionStatus("live"); };' in src
+    assert 'ws.onclose = () => { setConnectionStatus("reconnecting…");' in src
+    assert 'statusEl.textContent = t("live")' not in src
+    assert 'statusEl.textContent = t("reconnecting…")' not in src
+
+
+def test_i18n_patch_covers_supported_locales_and_signal_keys() -> None:
+    src = _source()
+
+    for lang in ("en", "zh", "fr", "es", "ar", "ru"):
+        assert f"    {lang}: {{" in src
+    for key in (
+        "Noise suppressed",
+        "Stream events",
+        "Active watches",
+        "Watch portfolio",
+        "Signal health summary",
+        "Trigger coverage",
+        "stale_build_title",
+        "signal.family.clipboard",
+        "connected",
+        "正在连接",
+        "已连接",
+        "正在重连",
+    ):
+        assert key in src
diff --git a/tests/test_dashboard_launcher.py b/tests/test_dashboard_launcher.py
index 3b63c9c..bb6837b 100644
--- a/tests/test_dashboard_launcher.py
+++ b/tests/test_dashboard_launcher.py
@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+import json
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -46,6 +47,20 @@ def test_state_roundtrip(tmp_path: Path) -> None:
     assert launcher.load_state(settings) is None
 
 
+def test_clear_state_is_best_effort_on_permission_error(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    settings = _settings(tmp_path)
+
+    class _DeniedPath:
+        def unlink(self, *, missing_ok: bool = False) -> None:
+            raise PermissionError("sandbox denied")
+
+    monkeypatch.setattr(launcher, "state_path", lambda _settings: _DeniedPath())
+
+    launcher.clear_state(settings)  # must not raise; /board can pick a fresh port
+
+
 def test_server_running_requires_open_port_and_valid_token(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
@@ -100,6 +115,63 @@ def test_ensure_server_requires_aiohttp(tmp_path: Path, monkeypatch: pytest.Monk
         launcher.ensure_server(settings)
 
 
+# ── fetch_server_info: probes the *separate* long-lived server's own staleness ──
+
+
+class _FakeUrlResponse:
+    def __init__(self, status: int, body: bytes) -> None:
+        self.status = status
+        self._body = body
+
+    def read(self) -> bytes:
+        return self._body
+
+    def __enter__(self) -> "_FakeUrlResponse":
+        return self
+
+    def __exit__(self, *exc: object) -> bool:
+        return False
+
+
+def test_fetch_server_info_parses_json_payload(monkeypatch: pytest.MonkeyPatch) -> None:
+    payload = {"build": {"commit": "abc123", "pid": 42}, "stale": True}
+
+    def _fake_urlopen(url: str, timeout: float = 0.0) -> _FakeUrlResponse:
+        assert "/api/server-info" in url and "token=tok" in url
+        return _FakeUrlResponse(200, json.dumps(payload).encode("utf-8"))
+
+    monkeypatch.setattr("urllib.request.urlopen", _fake_urlopen)
+    assert launcher.fetch_server_info("127.0.0.1", 8766, "tok") == payload
+
+
+def test_fetch_server_info_returns_none_without_token() -> None:
+    assert launcher.fetch_server_info("127.0.0.1", 8766, "") is None
+
+
+def test_fetch_server_info_returns_none_when_unreachable(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _raise(url: str, timeout: float = 0.0) -> None:
+        raise OSError("connection refused")
+
+    monkeypatch.setattr("urllib.request.urlopen", _raise)
+    assert launcher.fetch_server_info("127.0.0.1", 8766, "tok") is None
+
+
+def test_fetch_server_info_returns_none_on_non_2xx(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        "urllib.request.urlopen",
+        lambda url, timeout=0.0: _FakeUrlResponse(401, b'{"error": "unauthorized"}'),
+    )
+    assert launcher.fetch_server_info("127.0.0.1", 8766, "tok") is None
+
+
+def test_fetch_server_info_returns_none_on_malformed_json(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        "urllib.request.urlopen",
+        lambda url, timeout=0.0: _FakeUrlResponse(200, b"not json"),
+    )
+    assert launcher.fetch_server_info("127.0.0.1", 8766, "tok") is None
+
+
 def test_retire_stale_server_skips_kill_when_pid_unverified(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
@@ -191,3 +263,64 @@ def test_server_build_app_requires_aiohttp() -> None:
     server = DashboardServer(client=_FakeClient(), token="t")
     app = server.build_app()
     assert app is not None
+
+
+# ── DashboardServer build/staleness self-report (own long-lived-process check) ──
+
+
+class _FakeViewProvider:
+    """Minimal DashboardDataProvider double: enough for _handle_view to render."""
+
+    async def watches(self) -> list:
+        return []
+
+    async def findings(self, *, watch_id: str = "", limit: int = 50) -> list:
+        return []
+
+    async def signal_metrics(self) -> dict:
+        return {"metrics": {}, "signal_stream": []}
+
+
+async def test_handle_view_attaches_server_build_meta() -> None:
+    pytest.importorskip("aiohttp")
+    server = DashboardServer(client=_FakeClient(), token="t")
+    server._provider = _FakeViewProvider()
+    request = SimpleNamespace(query={"token": "t", "template": "generic"}, headers={})
+
+    response = await server._handle_view(request)
+    spec = json.loads(response.text)
+
+    server_meta = spec["meta"]["server"]
+    assert server_meta["build"]["pid"] == server._build_info.pid
+    assert server_meta["stale"] in (True, False, None)
+
+
+async def test_handle_server_info_requires_token() -> None:
+    pytest.importorskip("aiohttp")
+    server = DashboardServer(client=_FakeClient(), token="t")
+    request = SimpleNamespace(query={}, headers={})
+
+    response = await server._handle_server_info(request)
+
+    assert response.status == 401
+
+
+async def test_handle_server_info_reports_captured_build_and_stale_verdict(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pytest.importorskip("aiohttp")
+    from leapflow.dashboard import server as server_module
+
+    server = DashboardServer(client=_FakeClient(), token="t")
+    # This process's own fingerprint check is irrelevant to the endpoint's
+    # wiring; pin the verdict so the assertion is deterministic.
+    monkeypatch.setattr(server_module, "is_stale", lambda info: True)
+    request = SimpleNamespace(query={"token": "t"}, headers={})
+
+    response = await server._handle_server_info(request)
+    payload = json.loads(response.text)
+
+    assert payload["stale"] is True
+    assert payload["build"]["pid"] == server._build_info.pid
+    assert payload["build"]["version"] == server._build_info.version
+
diff --git a/tests/test_dashboard_sdui.py b/tests/test_dashboard_sdui.py
index 79b7fc2..1eeb469 100644
--- a/tests/test_dashboard_sdui.py
+++ b/tests/test_dashboard_sdui.py
@@ -150,6 +150,26 @@ def test_template_library_unknown_falls_back_to_generic() -> None:
     assert spec["meta"]["template"] == "generic"
 
 
+def test_template_library_hides_retired_builtin_nav_even_with_override(tmp_path) -> None:
+    for name in ("finance", "research", "sentiment"):
+        (tmp_path / f"{name}.yaml").write_text(
+            f"template: {name}\ntitle: '{name}'\nlayout:\n  - type: Page\n    props:\n      title: '{name}'\n",
+            encoding="utf-8",
+        )
+    (tmp_path / "crypto.yaml").write_text(
+        "template: crypto\ntitle: 'Crypto'\nlayout:\n  - type: Page\n    props:\n      title: 'Crypto'\n",
+        encoding="utf-8",
+    )
+
+    lib = TemplateLibrary(override_dir=tmp_path)
+
+    assert "crypto" in lib.visible_names()
+    assert "finance" not in lib.visible_names()
+    assert "research" not in lib.visible_names()
+    assert "sentiment" not in lib.visible_names()
+    assert {"finance", "research", "sentiment"}.issubset(set(lib.hidden_names()))
+
+
 # ── DashboardIntent (dual entry) ────────────────────────────────────────────
 
 
diff --git a/tests/test_dashboard_view.py b/tests/test_dashboard_view.py
index b0670d3..9bba646 100644
--- a/tests/test_dashboard_view.py
+++ b/tests/test_dashboard_view.py
@@ -14,9 +14,15 @@
 
 
 class _FakeProvider:
-    def __init__(self, watches: list[dict], findings: list[dict]) -> None:
+    def __init__(
+        self,
+        watches: list[dict],
+        findings: list[dict],
+        signal_result: dict[str, Any] | None = None,
+    ) -> None:
         self._watches = watches
         self._findings = findings
+        self._signal_result = signal_result or {"metrics": {}, "signal_stream": []}
 
     async def watches(self) -> list[dict[str, Any]]:
         return list(self._watches)
@@ -25,6 +31,9 @@ async def findings(self, *, watch_id: str = "", limit: int = 50) -> list[dict[st
         items = [f for f in self._findings if f.get("watch_id") == watch_id] if watch_id else list(self._findings)
         return items[:limit]
 
+    async def signal_metrics(self) -> dict[str, Any]:
+        return dict(self._signal_result)
+
 
 def _flatten(spec: dict) -> list[dict]:
     flat: list[dict] = []
@@ -94,10 +103,88 @@ async def test_builder_unknown_template_falls_back_to_generic() -> None:
 
 async def test_builder_exposes_template_switcher_meta() -> None:
     # The web client renders its lens switcher from this meta (no hardcoding).
+    # Only visible (non-hidden) templates appear in the switcher.
     builder = DashboardViewBuilder(TemplateLibrary())
     spec = await builder.build(DashboardIntent(template="finance"), _session_provider())
     assert spec["meta"]["active_template"] == "finance"
-    assert {"generic", "finance", "sentiment", "research"}.issubset(set(spec["meta"]["templates"]))
+    assert {"generic", "signals"}.issubset(set(spec["meta"]["templates"]))
+    # Hidden templates must NOT appear in the switcher, and are exposed as a
+    # client-side deny list so stale/custom metadata cannot re-render them.
+    assert "finance" not in spec["meta"]["templates"]
+    assert "research" not in spec["meta"]["templates"]
+    assert "sentiment" not in spec["meta"]["templates"]
+    assert {"finance", "research", "sentiment"}.issubset(set(spec["meta"]["hidden_templates"]))
+
+
+async def test_builder_signals_template_renders_dense_operational_layout() -> None:
+    builder = DashboardViewBuilder(TemplateLibrary())
+    provider = _FakeProvider(
+        watches=[
+            {"watch_id": "abcdef123", "name": "Session", "domain": "session", "trigger": "every 2m", "state": "armed", "finding_count": 1},
+            {"watch_id": "sig123", "name": "fs-observer", "domain": "signal", "trigger": "event:fs.*", "state": "done", "finding_count": 0},
+        ],
+        findings=[{"finding_id": "f1", "watch_id": "abcdef123", "domain": "session", "title": "analysis", "summary": "s", "severity": "notable"}],
+        signal_result={
+            "metrics": {
+                "event_subscriber_count": 6,
+                "active_trigger_count": 2,
+                "active_watch_count": 1,
+                "recent_findings_count": 1,
+                "signal_noise_suppressed": 9,
+                "signal_buffer_dropped": 3,
+                "composite_source_dropped": 4,
+                "reorder_buffer_pending": 2,
+                "debounce_stats": {"sig123": 5},
+                "trigger_stats": [{"watch_id": "sig123456", "pattern": "fs.*", "triggered": True, "last_event": "fs.modified"}],
+            },
+            "signal_stream": [
+                {"event_type": "fs.modified", "source": "fs-old", "ts": 100.0},
+                {"event_type": "gateway.message", "source": "gateway-new", "ts": 300.0},
+                {"event_type": "clipboard.change", "source": "clipboard-mid", "ts": 200.0},
+            ],
+        },
+    )
+
+    spec = await builder.build(DashboardIntent(template="signals"), provider)
+
+    assert spec["meta"]["active_template"] == "signals"
+    flat = _flatten(spec)
+    stats = [n for n in flat if n["type"] == "Stat"]
+    labels = {n["props"]["label"] for n in stats}
+    assert {
+        "Subscribers",
+        "Active triggers",
+        "Active watches",
+        "Stream events",
+        "Recent findings",
+        "Noise suppressed",
+        "Buffer dropped",
+        "Source dropped",
+        "Reorder pending",
+        "Debounced",
+    }.issubset(labels)
+    assert len(stats) >= 9
+    signal_widget = next(
+        n for n in flat
+        if n["type"] == "Custom" and n["props"].get("render") == "signalTimeline"
+    )
+    stream = signal_widget["props"]["data"]
+    assert signal_widget["props"]["max_items"] == 12
+    assert [item["event_type"] for item in stream] == [
+        "gateway.message",
+        "clipboard.change",
+        "fs.modified",
+    ]
+    assert [item["family"] for item in stream] == ["gateway", "clipboard", "fs"]
+    assert stream[0]["source"] == "gateway-new"
+    assert stream[0]["ts"] == 300.0
+    assert len([n for n in flat if n["type"] == "BarChart"]) >= 2
+    assert any(n["type"] == "Section" and n["props"].get("span") == 2 for n in flat)
+    trigger_table = next(
+        n for n in flat
+        if n["type"] == "Table" and any(c.get("key") == "pattern" for c in n["props"].get("columns", []))
+    )
+    assert trigger_table["props"]["data"][0]["watch"] == "sig12345"
 
 
 # -- ViewHub fan-out ----------------------------------------------------------
diff --git a/tests/test_dashboard_watch_rpc.py b/tests/test_dashboard_watch_rpc.py
index 5eb80aa..c9ecce3 100644
--- a/tests/test_dashboard_watch_rpc.py
+++ b/tests/test_dashboard_watch_rpc.py
@@ -155,7 +155,43 @@ async def test_board_status_and_templates_are_discoverable(tmp_path: Path) -> No
     templates = await command_execute(ctx, "board templates", "")
     assert templates["mode"] == "templates"
     names = {t["name"] for t in templates["templates"]}
-    assert {"generic", "finance", "sentiment", "research"}.issubset(names)
+    # Only visible (non-hidden) templates are listed.
+    assert {"generic", "signals"}.issubset(names)
+    assert "finance" not in names
+    assert "research" not in names
+    assert "sentiment" not in names
+
+
+async def test_board_status_reports_none_without_a_configured_settings(tmp_path: Path) -> None:
+    # No settings -> no dashboard-server discovery is possible; 'server' must
+    # be a graceful None, never an error, never a missing key.
+    ctx = SimpleNamespace(monitors=_manager(tmp_path), settings=None, engine=None)
+
+    status_payload = await command_execute(ctx, "board status", "")
+
+    assert status_payload["server"] is None
+
+
+async def test_board_status_surfaces_running_dashboard_server_staleness(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """/board status must warn when the *separate* LeapBoard web server process
+    (not the daemon itself) predates the current source tree — the exact class
+    of bug a developer cannot otherwise detect from the terminal.
+    """
+    from leapflow.dashboard import launcher
+
+    settings = SimpleNamespace(runtime_dir=tmp_path)
+    launcher.write_state(settings, {"bind": "127.0.0.1", "port": 8766, "token": "tok", "pid": 999})
+    monkeypatch.setattr(
+        launcher, "fetch_server_info",
+        lambda bind, port, token: {"build": {"pid": 999, "commit": "abc"}, "stale": True},
+    )
+    ctx = SimpleNamespace(monitors=_manager(tmp_path), settings=settings, engine=None)
+
+    status_payload = await command_execute(ctx, "board status", "")
+
+    assert status_payload["server"] == {"build": {"pid": 999, "commit": "abc"}, "stale": True}
 
 
 async def test_board_refresh_reanalyzes_session(tmp_path: Path) -> None:
@@ -365,3 +401,32 @@ def test_render_dashboard_payload_covers_new_modes() -> None:
     failed = _CaptureConsole()
     render_command_payload(failed, {"ok": False, "message": "Could not add template: bad"})
     assert any("Could not add" in line for line in failed.lines)
+
+
+def test_render_board_status_warns_when_web_server_is_stale() -> None:
+    from leapflow.cli.commands.slash_handlers import render_command_payload
+
+    stale = _CaptureConsole()
+    render_command_payload(stale, {
+        "ok": True, "view": "dashboard", "mode": "status",
+        "templates": ["generic"], "default": "generic", "watches": [], "findings": [],
+        "server": {"build": {"pid": 4242, "commit": "abc123"}, "stale": True},
+    })
+    assert any("4242" in line and "restart" in line.lower() for line in stale.lines)
+
+    fresh = _CaptureConsole()
+    render_command_payload(fresh, {
+        "ok": True, "view": "dashboard", "mode": "status",
+        "templates": ["generic"], "default": "generic", "watches": [], "findings": [],
+        "server": {"build": {"pid": 4242, "commit": "abc123"}, "stale": False},
+    })
+    assert any("up to date" in line for line in fresh.lines)
+
+    # No dashboard server currently running (or verdict unknown): render nothing.
+    silent = _CaptureConsole()
+    render_command_payload(silent, {
+        "ok": True, "view": "dashboard", "mode": "status",
+        "templates": ["generic"], "default": "generic", "watches": [], "findings": [],
+        "server": None,
+    })
+    assert not any("stale" in line.lower() or "up to date" in line for line in silent.lines)
diff --git a/tests/test_event_bridge.py b/tests/test_event_bridge.py
new file mode 100644
index 0000000..ab94358
--- /dev/null
+++ b/tests/test_event_bridge.py
@@ -0,0 +1,207 @@
+"""Hermetic tests for EventBridge — EventBus to EventTrigger adapter.
+
+No network, no LLM: pure in-memory trigger matching logic.
+"""
+
+from __future__ import annotations
+
+import time
+from unittest.mock import patch
+
+from leapflow.domain.events import SystemEvent
+from leapflow.monitor.event_bridge import EventBridge
+from leapflow.scheduler.triggers.event import EventTrigger
+
+
+def _make_event(event_type: str, source: str = "test") -> SystemEvent:
+    """Create a minimal SystemEvent for testing."""
+    return SystemEvent(
+        event_type=event_type,
+        source=source,
+        payload={},
+        timestamp=time.time(),
+    )
+
+
+# ── Registration and triggering ───────────────────────────────────────────
+
+
+def test_event_bridge_register_and_trigger() -> None:
+    """Register a pattern='fs.*' trigger, send 'fs.change', verify activated."""
+    bridge = EventBridge()
+    trigger = EventTrigger(event_pattern="fs.*")
+
+    bridge.register("watch-1", trigger)
+    assert bridge.active_count == 1
+    assert not trigger.is_triggered
+
+    bridge.on_event(_make_event("fs.change"))
+
+    assert trigger.is_triggered
+    assert trigger.last_event == "fs.change"
+
+
+def test_event_bridge_no_match() -> None:
+    """Register 'fs.*' trigger, send 'app.focus_change', verify NOT activated."""
+    bridge = EventBridge()
+    trigger = EventTrigger(event_pattern="fs.*")
+
+    bridge.register("watch-2", trigger)
+    bridge.on_event(_make_event("app.focus_change"))
+
+    assert not trigger.is_triggered
+    assert trigger.last_event == ""
+
+
+def test_event_bridge_unregister() -> None:
+    """Register then unregister; matching event should not fire trigger."""
+    bridge = EventBridge()
+    trigger = EventTrigger(event_pattern="fs.*")
+
+    bridge.register("watch-3", trigger)
+    assert bridge.active_count == 1
+
+    bridge.unregister("watch-3")
+    assert bridge.active_count == 0
+
+    bridge.on_event(_make_event("fs.change"))
+
+    assert not trigger.is_triggered
+
+
+def test_event_bridge_empty_short_circuit() -> None:
+    """Calling on_event with no registered triggers raises no exception."""
+    bridge = EventBridge()
+    assert bridge.active_count == 0
+
+    # Should not raise
+    bridge.on_event(_make_event("fs.change"))
+    bridge.on_event(_make_event("app.focus_change"))
+
+
+# ── Multiple triggers ─────────────────────────────────────────────────────
+
+
+def test_event_bridge_multiple_triggers() -> None:
+    """Multiple triggers: only matching ones fire."""
+    bridge = EventBridge()
+    fs_trigger = EventTrigger(event_pattern="fs.*")
+    app_trigger = EventTrigger(event_pattern="app.*")
+
+    bridge.register("watch-fs", fs_trigger)
+    bridge.register("watch-app", app_trigger)
+    assert bridge.active_count == 2
+
+    bridge.on_event(_make_event("fs.change"))
+
+    assert fs_trigger.is_triggered
+    assert not app_trigger.is_triggered
+
+
+def test_event_bridge_unregister_nonexistent() -> None:
+    """Unregistering a non-existent watch_id is a no-op."""
+    bridge = EventBridge()
+    trigger = EventTrigger(event_pattern="fs.*")
+    bridge.register("watch-x", trigger)
+
+    # Should not raise
+    bridge.unregister("nonexistent")
+    assert bridge.active_count == 1
+
+
+# ── Debounce ───────────────────────────────────────────────────────────────
+
+
+def test_event_bridge_debounce_suppresses_rapid_events() -> None:
+    """Rapid successive events within debounce window fire trigger only once."""
+    bridge = EventBridge()
+    trigger = EventTrigger(event_pattern="fs.*")
+    bridge.register("watch-d1", trigger, debounce_s=1.0)
+
+    # Use a fixed monotonic clock to simulate rapid events
+    fake_time = [100.0]
+
+    def _monotonic() -> float:
+        return fake_time[0]
+
+    with patch("leapflow.monitor.event_bridge.time.monotonic", side_effect=_monotonic):
+        # First event fires
+        bridge.on_event(_make_event("fs.change"))
+        assert trigger.is_triggered
+
+        # Reset trigger state to detect re-fires
+        trigger.advance(0)
+        assert not trigger.is_triggered
+
+        # Send 4 more events at the same timestamp (within debounce window)
+        for _ in range(4):
+            bridge.on_event(_make_event("fs.change"))
+
+    # Trigger should NOT have been re-fired
+    assert not trigger.is_triggered
+    # All 4 subsequent events should have been debounced
+    assert bridge.debounced_count("watch-d1") == 4
+
+
+def test_event_bridge_debounce_allows_after_window() -> None:
+    """Events after the debounce window has elapsed are allowed through."""
+    bridge = EventBridge()
+    trigger = EventTrigger(event_pattern="fs.*")
+    bridge.register("watch-d2", trigger, debounce_s=1.0)
+
+    fake_time = [100.0]
+
+    def _monotonic() -> float:
+        return fake_time[0]
+
+    with patch("leapflow.monitor.event_bridge.time.monotonic", side_effect=_monotonic):
+        # First event fires
+        bridge.on_event(_make_event("fs.change"))
+        assert trigger.is_triggered
+
+        trigger.advance(0)
+        assert not trigger.is_triggered
+
+        # Advance time past debounce window
+        fake_time[0] = 101.1  # 1.1s later, > 1.0s debounce
+
+        # Second event should fire
+        bridge.on_event(_make_event("fs.change"))
+        assert trigger.is_triggered
+
+    assert bridge.debounced_count("watch-d2") == 0
+
+
+def test_event_bridge_debounce_per_watch() -> None:
+    """Each watch has its own independent debounce tracking."""
+    bridge = EventBridge()
+    trigger_a = EventTrigger(event_pattern="fs.*")
+    trigger_b = EventTrigger(event_pattern="fs.*")
+
+    bridge.register("watch-a", trigger_a, debounce_s=1.0)
+    bridge.register("watch-b", trigger_b, debounce_s=1.0)
+
+    fake_time = [100.0]
+
+    def _monotonic() -> float:
+        return fake_time[0]
+
+    with patch("leapflow.monitor.event_bridge.time.monotonic", side_effect=_monotonic):
+        # First event fires both
+        bridge.on_event(_make_event("fs.change"))
+        assert trigger_a.is_triggered
+        assert trigger_b.is_triggered
+
+        trigger_a.advance(0)
+        trigger_b.advance(0)
+
+        # Advance time: past window for watch-a only by manipulating
+        # per-watch last_triggered directly
+        # Instead, send another event — both should be debounced
+        bridge.on_event(_make_event("fs.change"))
+        assert not trigger_a.is_triggered
+        assert not trigger_b.is_triggered
+
+    # Both suppressed equally
+    assert bridge.debounced_count("watch-a") == 1
+    assert bridge.debounced_count("watch-b") == 1
diff --git a/tests/test_event_driven_watch.py b/tests/test_event_driven_watch.py
new file mode 100644
index 0000000..37de2ed
--- /dev/null
+++ b/tests/test_event_driven_watch.py
@@ -0,0 +1,233 @@
+"""End-to-end tests for event-driven Watch full chain.
+
+Verifies the complete pipeline:
+  EventBus emit → EventBridge match → EventTrigger activate →
+  MonitorManager recognises DUE → Producer executes → Finding persisted.
+
+No network, no LLM: uses a temporary DuckDB and a fake in-process producer.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from leapflow.domain.events import SystemEvent
+from leapflow.monitor import (
+    EVENT_FINDING,
+    Finding,
+    MonitorManager,
+    ProducerRegistry,
+    Severity,
+    WatchSpec,
+)
+from leapflow.monitor.types import ProducerContext
+from leapflow.storage.connection import LocalConnectionHolder
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+class _MockProducer:
+    """Deterministic producer returning a fixed finding per cycle."""
+
+    def __init__(self, domain: str, findings: list[Finding]) -> None:
+        self._domain = domain
+        self._findings = findings
+        self.calls = 0
+
+    @property
+    def domain(self) -> str:
+        return self._domain
+
+    async def observe(self, ctx: ProducerContext) -> list[Finding]:
+        self.calls += 1
+        return list(self._findings)
+
+
+def _holder(tmp_path: Path) -> LocalConnectionHolder:
+    return LocalConnectionHolder(tmp_path / "leap.duckdb")
+
+
+def _make_event(event_type: str, source: str = "test") -> SystemEvent:
+    """Create a minimal SystemEvent for testing."""
+    return SystemEvent(
+        event_type=event_type,
+        source=source,
+        payload={},
+        timestamp=time.time(),
+    )
+
+
+# ── 1. Full chain E2E ────────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_event_driven_watch_full_chain(tmp_path: Path) -> None:
+    """Full chain: event → bridge → trigger → run_watch_once → finding persisted."""
+    emitted: list[tuple[str, dict]] = []
+    producers = ProducerRegistry()
+    producer = _MockProducer("filesystem", [
+        Finding(
+            watch_id="",
+            domain="filesystem",
+            title="file changed",
+            severity=Severity.ALERT,
+            dedup_key="f1",
+        ),
+    ])
+    producers.register(producer)
+
+    manager = MonitorManager(
+        holder=_holder(tmp_path),
+        producers=producers,
+        emit=lambda et, payload: emitted.append((et, payload)),
+    )
+
+    # Step 1: arm watch with event trigger
+    view = await manager.arm_watch(
+        WatchSpec(name="FSWatch", domain="filesystem", trigger_expr="event:fs.*")
+    )
+    assert view.state == "armed"
+    assert manager.event_bridge.active_count == 1
+
+    # Step 2: deliver a matching event through the bridge
+    manager.event_bridge.on_event(_make_event("fs.change"))
+
+    # Step 3: verify the trigger is activated
+    trigger = manager.event_bridge._triggers[view.watch_id]
+    assert trigger.is_triggered is True
+    assert trigger.last_event == "fs.change"
+
+    # Step 4: manually run the watch cycle (simulates scheduler tick)
+    result = await manager.run_watch_once(view.watch_id)
+    assert result["ok"] is True
+    assert result["findings"] == 1
+
+    # Step 5: verify finding was pushed and persisted
+    finding_events = [p for et, p in emitted if et == EVENT_FINDING]
+    assert len(finding_events) == 1
+    assert finding_events[0]["title"] == "file changed"
+
+    assert manager.finding_store.count(watch_id=view.watch_id) == 1
+    assert producer.calls == 1
+
+
+# ── 2. Debounce suppression ──────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_event_driven_watch_debounce_suppression(tmp_path: Path) -> None:
+    """Rapid events within debounce window fire trigger only once."""
+    producers = ProducerRegistry()
+    producers.register(_MockProducer("filesystem", [
+        Finding(watch_id="", domain="filesystem", title="x", severity=Severity.INFO),
+    ]))
+    manager = MonitorManager(
+        holder=_holder(tmp_path),
+        producers=producers,
+    )
+
+    view = await manager.arm_watch(
+        WatchSpec(name="FSWatch", domain="filesystem", trigger_expr="event:fs.change")
+    )
+
+    # Use a fixed monotonic clock so all events land within the debounce window
+    fake_time = [100.0]
+
+    def _monotonic() -> float:
+        return fake_time[0]
+
+    with patch("leapflow.monitor.event_bridge.time.monotonic", side_effect=_monotonic):
+        # First event fires the trigger
+        manager.event_bridge.on_event(_make_event("fs.change"))
+        trigger = manager.event_bridge._triggers[view.watch_id]
+        assert trigger.is_triggered is True
+
+        # Send 9 more rapid events — all should be debounced
+        for _ in range(9):
+            manager.event_bridge.on_event(_make_event("fs.change"))
+
+    # Trigger was only activated once (the first)
+    assert trigger.is_triggered is True  # still set from the first fire
+
+    # 9 events were suppressed by debounce
+    assert manager.event_bridge.debounced_count(view.watch_id) == 9
+
+
+# ── 3. No match, no trigger ──────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_event_driven_watch_no_match_no_trigger(tmp_path: Path) -> None:
+    """Non-matching event does not activate trigger."""
+    manager = MonitorManager(holder=_holder(tmp_path))
+    view = await manager.arm_watch(
+        WatchSpec(name="FSWatch", domain="filesystem", trigger_expr="event:fs.*")
+    )
+
+    # Send an unrelated event type
+    manager.event_bridge.on_event(_make_event("app.focus_change"))
+
+    # Trigger should NOT be activated
+    trigger = manager.event_bridge._triggers[view.watch_id]
+    assert trigger.is_triggered is False
+    assert trigger.last_event == ""
+
+
+# ── 4. Latency under 200ms ───────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_event_driven_watch_latency_under_200ms(tmp_path: Path) -> None:
+    """Pure internal path (no LLM) completes within 200ms budget."""
+    producers = ProducerRegistry()
+    producers.register(_MockProducer("perf", [
+        Finding(watch_id="", domain="perf", title="fast", severity=Severity.ALERT),
+    ]))
+    manager = MonitorManager(
+        holder=_holder(tmp_path),
+        producers=producers,
+    )
+
+    t0 = time.monotonic()
+
+    view = await manager.arm_watch(
+        WatchSpec(name="PerfWatch", domain="perf", trigger_expr="event:perf.*")
+    )
+    manager.event_bridge.on_event(_make_event("perf.tick"))
+    result = await manager.run_watch_once(view.watch_id)
+
+    elapsed_ms = (time.monotonic() - t0) * 1000
+
+    assert result["ok"] is True
+    assert result["findings"] == 1
+    assert elapsed_ms < 200, f"Latency {elapsed_ms:.1f}ms exceeds 200ms budget"
+
+
+# ── 5. Stop unregisters from bridge ─────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_event_driven_watch_stop_unregisters(tmp_path: Path) -> None:
+    """Stopping a watch unregisters its trigger from EventBridge."""
+    manager = MonitorManager(holder=_holder(tmp_path))
+
+    view = await manager.arm_watch(
+        WatchSpec(name="FSWatch", domain="filesystem", trigger_expr="event:fs.*")
+    )
+    assert manager.event_bridge.active_count == 1
+
+    # Stop the watch
+    stopped = manager.stop_watch(view.watch_id)
+    assert stopped.state == "done"
+    assert manager.event_bridge.active_count == 0
+
+    # Sending a matching event should have no effect (trigger already removed)
+    manager.event_bridge.on_event(_make_event("fs.change"))
+
+    # No trigger should be in the bridge anymore
+    assert view.watch_id not in manager.event_bridge._triggers
diff --git a/tests/test_gateway_consumer_loop.py b/tests/test_gateway_consumer_loop.py
index e9d34eb..3418eae 100644
--- a/tests/test_gateway_consumer_loop.py
+++ b/tests/test_gateway_consumer_loop.py
@@ -379,3 +379,85 @@ def test_has_rich_formatting_detects_headers_and_lists() -> None:
 
     md = "# Title\n\n- item one\n- item two"
     assert _has_rich_formatting(md) is True
+
+
+# ── Gateway signal → EventBus → Monitor EventBridge integration ───────
+
+
+@pytest.mark.asyncio
+async def test_gateway_signal_reaches_monitor_event_bridge(tmp_path: Any) -> None:
+    """BackendEvent(SIGNAL) → GatewayEventBridge → EventBus → Monitor EventBridge.
+
+    Verifies the full bypass path: a platform signal event flows through the
+    GatewayEventBridge into EventBus, and the Monitor EventBridge's trigger
+    fires when subscribed as an EventBus subscriber.
+    """
+    from leapflow.gateway.event_bridge import GatewayEventBridge
+    from leapflow.monitor.event_bridge import EventBridge as MonitorEventBridge
+    from leapflow.platform.event_bus import EventBus
+    from leapflow.memory.providers.episodic import EpisodicMemoryProvider
+    from leapflow.memory.providers.working import WorkingMemoryProvider
+    from leapflow.scheduler.triggers.event import EventTrigger
+
+    # Build a minimal EventBus (no normalizer — uses fallback, but we
+    # now have passthrough for gateway.* event types).
+    episodic = EpisodicMemoryProvider(ttl=60.0)
+    working = WorkingMemoryProvider()
+    event_bus = EventBus(immediate=episodic, working=working)
+
+    # Wire GatewayEventBridge → EventBus
+    gw_bridge = GatewayEventBridge(event_bus)
+
+    # Wire Monitor EventBridge ← EventBus (subscriber)
+    monitor_bridge = MonitorEventBridge()
+    trigger = EventTrigger(event_pattern="gateway.*")
+    monitor_bridge.register("watch-gw", trigger)
+    event_bus.subscribe(monitor_bridge.on_event)
+
+    # Simulate a SIGNAL BackendEvent arriving via gateway on_event callback
+    signal_event = BackendEvent(
+        event_id="ev_signal_1",
+        event_type="im.message.reaction.created_v1",
+        platform_id="feishu",
+        payload={"sender_id": "ou_user1"},
+    )
+    await gw_bridge.on_gateway_event(signal_event)
+
+    # The Monitor EventBridge trigger should have fired
+    assert trigger.is_triggered
+    assert trigger.last_event == "gateway.signal"
+
+
+@pytest.mark.asyncio
+async def test_gateway_message_event_reaches_monitor_event_bridge(tmp_path: Any) -> None:
+    """GatewayMessageReceived → GatewayEventBridge → EventBus → Monitor trigger."""
+    from leapflow.gateway.event_bridge import GatewayEventBridge
+    from leapflow.gateway.events import GatewayMessageReceived
+    from leapflow.gateway.protocol import MessageSource
+    from leapflow.monitor.event_bridge import EventBridge as MonitorEventBridge
+    from leapflow.platform.event_bus import EventBus
+    from leapflow.memory.providers.episodic import EpisodicMemoryProvider
+    from leapflow.memory.providers.working import WorkingMemoryProvider
+    from leapflow.scheduler.triggers.event import EventTrigger
+
+    episodic = EpisodicMemoryProvider(ttl=60.0)
+    working = WorkingMemoryProvider()
+    event_bus = EventBus(immediate=episodic, working=working)
+
+    gw_bridge = GatewayEventBridge(event_bus)
+
+    monitor_bridge = MonitorEventBridge()
+    trigger = EventTrigger(event_pattern="gateway.message.*")
+    monitor_bridge.register("watch-msg", trigger)
+    event_bus.subscribe(monitor_bridge.on_event)
+
+    # Simulate a GatewayMessageReceived event
+    msg_event = GatewayMessageReceived(
+        source=MessageSource(platform="feishu", chat_id="oc_1", user_id="ou_1"),
+        session_key="feishu:oc_1",
+        text="hello world",
+    )
+    await gw_bridge.on_gateway_event(msg_event)
+
+    assert trigger.is_triggered
+    assert trigger.last_event == "gateway.message.received"
diff --git a/tests/test_gateway_tool_e2e.py b/tests/test_gateway_tool_e2e.py
index eba0603..05d220f 100644
--- a/tests/test_gateway_tool_e2e.py
+++ b/tests/test_gateway_tool_e2e.py
@@ -993,6 +993,82 @@ async def events(self):
     assert composite._tasks == []
 
 
+@pytest.mark.asyncio
+async def test_composite_event_source_drop_oldest_on_burst() -> None:
+    """When child sources burst faster than the consumer drains, oldest events
+    are dropped and drop_count is incremented correctly."""
+    from leapflow.gateway.connectors.composite_event_source import CompositeEventSource
+    from leapflow.gateway.connectors.protocol import BackendEvent, EventSourceStatus
+
+    QUEUE_SIZE = 4
+    BURST_SIZE = 10  # more than queue capacity
+
+    class BurstSource:
+        platform_id = "burst"
+        backend_kind = "test"
+
+        async def start(self, *, checkpoint: str = "") -> EventSourceStatus:
+            return EventSourceStatus(ok=True, backend_kind=self.backend_kind)
+
+        async def stop(self) -> EventSourceStatus:
+            return EventSourceStatus(ok=True, backend_kind=self.backend_kind)
+
+        async def status(self) -> EventSourceStatus:
+            return EventSourceStatus(ok=True, backend_kind=self.backend_kind)
+
+        async def events(self):
+            for i in range(BURST_SIZE):
+                yield BackendEvent(
+                    event_id=f"ev_{i}",
+                    event_type="test.burst",
+                    platform_id="burst",
+                    payload={"seq": i},
+                )
+
+    source = BurstSource()
+    composite = CompositeEventSource([source], platform_id="burst", maxsize=QUEUE_SIZE)
+    await composite.start()
+
+    received = []
+    async for event in composite.events():
+        received.append(event)
+
+    # We should have received QUEUE_SIZE events (the queue was drained at the end)
+    # and dropped (BURST_SIZE - QUEUE_SIZE) events.
+    assert composite.drop_count == BURST_SIZE - QUEUE_SIZE
+    assert len(received) == QUEUE_SIZE
+    # The retained events should be the NEWEST ones (drop-oldest strategy).
+    expected_ids = [f"ev_{i}" for i in range(BURST_SIZE - QUEUE_SIZE, BURST_SIZE)]
+    assert [e.event_id for e in received] == expected_ids
+
+
+@pytest.mark.asyncio
+async def test_composite_event_source_drop_count_property() -> None:
+    """drop_count property starts at zero and is publicly accessible."""
+    from leapflow.gateway.connectors.composite_event_source import CompositeEventSource
+    from leapflow.gateway.connectors.protocol import EventSourceStatus
+
+    class EmptySource:
+        platform_id = "empty"
+        backend_kind = "test"
+
+        async def start(self, *, checkpoint: str = "") -> EventSourceStatus:
+            return EventSourceStatus(ok=True, backend_kind=self.backend_kind)
+
+        async def stop(self) -> EventSourceStatus:
+            return EventSourceStatus(ok=True, backend_kind=self.backend_kind)
+
+        async def status(self) -> EventSourceStatus:
+            return EventSourceStatus(ok=True, backend_kind=self.backend_kind)
+
+        async def events(self):
+            if False:
+                yield {}
+
+    composite = CompositeEventSource([EmptySource()], platform_id="empty")
+    assert composite.drop_count == 0
+
+
 @pytest.mark.asyncio
 async def test_lark_event_source_kills_identity_subprocess_on_timeout(monkeypatch) -> None:
     import leapflow.gateway.connectors.lark_event_source as lark_event_source
diff --git a/tests/test_monitor_signal_noise.py b/tests/test_monitor_signal_noise.py
new file mode 100644
index 0000000..f7c25a9
--- /dev/null
+++ b/tests/test_monitor_signal_noise.py
@@ -0,0 +1,74 @@
+"""Tests for daemon MonitorCoordinator signal-noise boundary behavior."""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+
+from leapflow.daemon.monitor_coordinator import MonitorCoordinator
+from leapflow.domain.events import SystemEvent
+from leapflow.monitor.signal_noise import SignalNoiseConfig, SignalNoiseGate
+
+
+@dataclass
+class _NotificationBus:
+    events: list[tuple[str, dict]]
+
+    def emit(self, notification) -> None:
+        self.events.append((notification.event_type, notification.payload))
+
+
+def _event(event_type: str, source: str) -> SystemEvent:
+    return SystemEvent(event_type=event_type, source=source, payload={"path": source}, timestamp=time.time())
+
+
+def test_monitor_signal_subscriber_filters_noise_before_bridge_and_stream() -> None:
+    coordinator = MonitorCoordinator()
+    coordinator._signal_noise_gate = SignalNoiseGate(
+        SignalNoiseConfig(workspace_root="/repo", same_source_cooldown_s=0.0)
+    )
+    notifications = _NotificationBus([])
+    bridged: list[str] = []
+    subscriber = coordinator._make_monitor_signal_subscriber(
+        lambda event: bridged.append(event.source),
+        notifications,
+    )
+
+    noisy = _event(
+        "fs.change",
+        "/Users/jason/Library/Application Support/Qoder/User/globalStorage/state.vscdb-shm",
+    )
+    clean = _event("fs.change", "/repo/src/app.py")
+
+    subscriber(noisy)
+    subscriber(clean)
+
+    assert bridged == ["/repo/src/app.py"]
+    assert coordinator.get_signal_stream() == [
+        {"event_type": "fs.change", "source": "/repo/src/app.py", "ts": clean.timestamp}
+    ]
+    assert notifications.events == [
+        ("signal.stream", {"event_type": "fs.change", "source": "/repo/src/app.py", "ts": clean.timestamp})
+    ]
+    assert coordinator.signal_noise_stats["seen"] == 2
+    assert coordinator.signal_noise_stats["passed"] == 1
+    assert coordinator.signal_noise_stats["suppressed"] == 1
+
+
+def test_monitor_signal_subscriber_keeps_gateway_events() -> None:
+    coordinator = MonitorCoordinator()
+    coordinator._signal_noise_gate = SignalNoiseGate(SignalNoiseConfig(workspace_root="/repo"))
+    notifications = _NotificationBus([])
+    bridged: list[str] = []
+    subscriber = coordinator._make_monitor_signal_subscriber(
+        lambda event: bridged.append(event.event_type),
+        notifications,
+    )
+    event = _event("gateway.signal", "lark")
+
+    subscriber(event)
+
+    assert bridged == ["gateway.signal"]
+    assert coordinator.get_signal_stream() == [
+        {"event_type": "gateway.signal", "source": "lark", "ts": event.timestamp}
+    ]
+    assert coordinator.signal_noise_stats["suppressed"] == 0
diff --git a/tests/test_monitor_subsystem.py b/tests/test_monitor_subsystem.py
index 532b3a7..f794e37 100644
--- a/tests/test_monitor_subsystem.py
+++ b/tests/test_monitor_subsystem.py
@@ -7,6 +7,8 @@
 
 from pathlib import Path
 
+import pytest
+
 from leapflow.monitor import (
     EVENT_FINDING,
     Evidence,
@@ -19,6 +21,9 @@
 )
 from leapflow.monitor.finding_store import FindingStore
 from leapflow.monitor.types import ProducerContext
+from leapflow.scheduler.coordinator import parse_trigger_expression
+from leapflow.scheduler.triggers import create_trigger
+from leapflow.scheduler.triggers.event import EventTrigger
 from leapflow.storage.connection import LocalConnectionHolder
 
 
@@ -242,3 +247,92 @@ async def test_sweep_client_coupled_watches_is_noop_without_session_watches(tmp_
     await manager.arm_watch(WatchSpec(name="F", domain="finance"))
     assert manager.sweep_client_coupled_watches() == 0
     assert len(manager.list_watches()) == 1
+
+
+# ── Event trigger expression tests ────────────────────────────────────────────
+
+
+def test_parse_event_trigger_fs_change() -> None:
+    """event:fs.change parses to trigger_type='event' with correct pattern."""
+    trigger_type, trigger_config = parse_trigger_expression("event:fs.change")
+    assert trigger_type == "event"
+    assert trigger_config == {"event_pattern": "fs.change"}
+
+    # Verify the config creates a valid EventTrigger
+    trigger = create_trigger(trigger_type, trigger_config)
+    assert isinstance(trigger, EventTrigger)
+    assert trigger.event_pattern == "fs.change"
+
+
+def test_parse_event_trigger_wildcard_pattern() -> None:
+    """event:monitor.* parses correctly and supports glob matching."""
+    trigger_type, trigger_config = parse_trigger_expression("event:monitor.*")
+    assert trigger_type == "event"
+    assert trigger_config == {"event_pattern": "monitor.*"}
+
+    trigger = create_trigger(trigger_type, trigger_config)
+    assert isinstance(trigger, EventTrigger)
+    assert trigger.event_pattern == "monitor.*"
+    # Glob matching works
+    assert trigger.matches("monitor.cpu") is True
+    assert trigger.matches("monitor.mem") is True
+    assert trigger.matches("fs.change") is False
+
+
+def test_parse_event_trigger_gateway_signal() -> None:
+    """event:gateway.signal parses correctly."""
+    trigger_type, trigger_config = parse_trigger_expression("event:gateway.signal")
+    assert trigger_type == "event"
+    assert trigger_config == {"event_pattern": "gateway.signal"}
+
+    trigger = create_trigger(trigger_type, trigger_config)
+    assert isinstance(trigger, EventTrigger)
+    assert trigger.event_pattern == "gateway.signal"
+
+
+def test_parse_event_trigger_empty_pattern_raises() -> None:
+    """event: with empty pattern raises ValueError."""
+    with pytest.raises(ValueError, match="event name"):
+        parse_trigger_expression("event:")
+
+
+def test_parse_event_trigger_whitespace_only_raises() -> None:
+    """event: followed by whitespace only raises ValueError."""
+    with pytest.raises(ValueError, match="event name"):
+        parse_trigger_expression("event:   ")
+
+
+def test_parse_event_trigger_case_insensitive_prefix() -> None:
+    """The 'event:' prefix is recognized case-insensitively."""
+    trigger_type, trigger_config = parse_trigger_expression("Event:ci.passed")
+    assert trigger_type == "event"
+    assert trigger_config == {"event_pattern": "ci.passed"}
+
+    trigger_type2, trigger_config2 = parse_trigger_expression("EVENT:deploy.done")
+    assert trigger_type2 == "event"
+    assert trigger_config2 == {"event_pattern": "deploy.done"}
+
+
+async def test_arm_watch_with_event_trigger_registers_bridge(tmp_path: Path) -> None:
+    """arm_watch with event trigger registers the trigger in EventBridge."""
+    manager = MonitorManager(holder=_holder(tmp_path))
+    view = await manager.arm_watch(
+        WatchSpec(name="FSWatch", domain="filesystem", trigger_expr="event:fs.change")
+    )
+    assert view.state == "armed"
+    # Verify EventBridge has registered this watch
+    assert manager.event_bridge.active_count == 1
+
+
+async def test_arm_watch_with_event_trigger_glob_pattern(tmp_path: Path) -> None:
+    """arm_watch with glob event pattern registers correctly."""
+    manager = MonitorManager(holder=_holder(tmp_path))
+    view = await manager.arm_watch(
+        WatchSpec(name="AllMonitor", domain="monitor", trigger_expr="event:monitor.*")
+    )
+    assert view.state == "armed"
+    assert manager.event_bridge.active_count == 1
+
+    # Stop removes from bridge
+    manager.stop_watch(view.watch_id)
+    assert manager.event_bridge.active_count == 0
diff --git a/tests/test_reorder_buffer_capacity.py b/tests/test_reorder_buffer_capacity.py
new file mode 100644
index 0000000..5d788df
--- /dev/null
+++ b/tests/test_reorder_buffer_capacity.py
@@ -0,0 +1,95 @@
+"""Tests for EventReorderBuffer capacity hard limit (Task #4)."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, List, Tuple
+
+import pytest
+
+from leapflow.platform.reorder_buffer import EventReorderBuffer
+
+
+@pytest.mark.asyncio
+async def test_forced_flush_on_capacity_exceeded() -> None:
+    """Submitting max_buffer_size events triggers an immediate forced flush."""
+    emitted: List[Tuple[str, Dict[str, Any]]] = []
+
+    async def capture(event_type: str, payload: Dict[str, Any]) -> None:
+        emitted.append((event_type, payload))
+
+    max_size = 5
+    buf = EventReorderBuffer(settle_s=10.0, emit=capture, max_buffer_size=max_size)
+
+    # Submit exactly max_buffer_size events (should trigger flush on the 5th)
+    for i in range(max_size):
+        await buf.submit("test.event", {"_mono_ts": float(i), "seq": i})
+
+    # Flush should have happened immediately — buffer drained
+    assert buf.pending_count == 0
+    assert len(emitted) == max_size
+    # Events should be emitted in sorted timestamp order
+    seqs = [e[1]["seq"] for e in emitted]
+    assert seqs == list(range(max_size))
+
+
+@pytest.mark.asyncio
+async def test_forced_flush_on_capacity_plus_one() -> None:
+    """Submitting max_buffer_size + 1 events triggers flush at max_buffer_size."""
+    emitted: List[Tuple[str, Dict[str, Any]]] = []
+
+    async def capture(event_type: str, payload: Dict[str, Any]) -> None:
+        emitted.append((event_type, payload))
+
+    max_size = 3
+    buf = EventReorderBuffer(settle_s=10.0, emit=capture, max_buffer_size=max_size)
+
+    # Submit max_size + 1 events
+    for i in range(max_size + 1):
+        await buf.submit("test.event", {"_mono_ts": float(i), "seq": i})
+
+    # First max_size events flushed, the extra one remains buffered
+    assert len(emitted) == max_size
+    assert buf.pending_count == 1
+
+    # Drain to collect the remaining event
+    await buf.drain()
+    assert len(emitted) == max_size + 1
+    assert buf.pending_count == 0
+
+
+@pytest.mark.asyncio
+async def test_normal_behavior_below_capacity() -> None:
+    """Events below capacity accumulate and flush only on settle timeout."""
+    emitted: List[Tuple[str, Dict[str, Any]]] = []
+
+    async def capture(event_type: str, payload: Dict[str, Any]) -> None:
+        emitted.append((event_type, payload))
+
+    max_size = 100
+    buf = EventReorderBuffer(settle_s=0.01, emit=capture, max_buffer_size=max_size)
+
+    # Submit far fewer events than capacity
+    for i in range(5):
+        await buf.submit("test.event", {"_mono_ts": float(i), "seq": i})
+
+    # Events should still be buffered (settle timer not yet fired)
+    assert buf.pending_count == 5
+    assert len(emitted) == 0
+
+    # Wait for settle window to fire the delayed flush
+    await asyncio.sleep(0.05)
+    assert buf.pending_count == 0
+    assert len(emitted) == 5
+
+
+@pytest.mark.asyncio
+async def test_default_max_buffer_size() -> None:
+    """Default max_buffer_size is 5000."""
+    emitted: List[Tuple[str, Dict[str, Any]]] = []
+
+    async def capture(event_type: str, payload: Dict[str, Any]) -> None:
+        emitted.append((event_type, payload))
+
+    buf = EventReorderBuffer(settle_s=1.0, emit=capture)
+    assert buf._max_buffer_size == 5000
diff --git a/tests/test_signal_buffer_overflow.py b/tests/test_signal_buffer_overflow.py
new file mode 100644
index 0000000..0115bde
--- /dev/null
+++ b/tests/test_signal_buffer_overflow.py
@@ -0,0 +1,58 @@
+"""Tests for SignalBuffer overflow observability (dropped_count tracking)."""
+from __future__ import annotations
+
+from leapflow.perception.signals import SignalBuffer
+from leapflow.perception.types import InteractionSignal
+
+
+def _make_signal(label: str = "click") -> InteractionSignal:
+    return InteractionSignal(timestamp=0.0, signal_type=label)
+
+
+def test_dropped_count_increments_on_overflow() -> None:
+    buf = SignalBuffer(capacity=3)
+    for i in range(4):
+        buf.record(_make_signal(f"s{i}"))
+
+    assert buf.count == 3
+    assert buf.dropped_count == 1
+
+
+def test_dropped_count_accumulates_across_drains() -> None:
+    buf = SignalBuffer(capacity=2)
+    # Fill and overflow
+    buf.record(_make_signal("a"))
+    buf.record(_make_signal("b"))
+    buf.record(_make_signal("c"))  # dropped
+    assert buf.dropped_count == 1
+
+    # Drain frees capacity but does NOT reset drop counter
+    drained = buf.drain()
+    assert len(drained) == 2
+    assert buf.dropped_count == 1
+
+    # Fill and overflow again
+    buf.record(_make_signal("d"))
+    buf.record(_make_signal("e"))
+    buf.record(_make_signal("f"))  # dropped
+    assert buf.dropped_count == 2
+
+
+def test_clear_resets_dropped_count() -> None:
+    buf = SignalBuffer(capacity=1)
+    buf.record(_make_signal("x"))
+    buf.record(_make_signal("y"))  # dropped
+    assert buf.dropped_count == 1
+
+    buf.clear()
+    assert buf.dropped_count == 0
+    assert buf.count == 0
+
+
+def test_no_drops_when_under_capacity() -> None:
+    buf = SignalBuffer(capacity=10)
+    for i in range(10):
+        buf.record(_make_signal(f"s{i}"))
+
+    assert buf.count == 10
+    assert buf.dropped_count == 0
diff --git a/tests/test_signal_noise.py b/tests/test_signal_noise.py
new file mode 100644
index 0000000..84e6d7e
--- /dev/null
+++ b/tests/test_signal_noise.py
@@ -0,0 +1,165 @@
+"""Hermetic tests for monitor/display signal noise suppression."""
+from __future__ import annotations
+
+import time
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from leapflow.domain.events import SystemEvent
+from leapflow.monitor.signal_metrics import SignalMetricsCollector
+from leapflow.monitor.signal_noise import SignalNoiseConfig, SignalNoiseGate
+
+
+def _event(event_type: str, source: str) -> SystemEvent:
+    return SystemEvent(event_type=event_type, source=source, payload={"path": source}, timestamp=time.time())
+
+
+def _gate() -> SignalNoiseGate:
+    return SignalNoiseGate(SignalNoiseConfig(workspace_root="/repo", same_source_cooldown_s=2.0))
+
+
+def test_signal_noise_gate_passes_workspace_source_file() -> None:
+    gate = _gate()
+
+    assert gate.should_pass(_event("fs.change", "/repo/src/leapflow/dashboard/service.py")) is True
+    assert gate.stats["passed"] == 1
+    assert gate.stats["suppressed"] == 0
+
+
+def test_signal_noise_gate_suppresses_cache_paths_and_tracks_reason() -> None:
+    gate = _gate()
+
+    assert gate.should_pass(_event(
+        "fs.change",
+        "/Users/jason/Library/Application Support/Qoder/User/globalStorage/state.vscdb-shm",
+    )) is False
+
+    stats = gate.stats
+    assert stats["suppressed"] == 1
+    assert stats["by_reason"] == {"transient_suffix": 1}
+    assert stats["by_family"] == {"fs": 1}
+
+
+def test_signal_noise_gate_suppresses_noisy_dirs_inside_workspace() -> None:
+    gate = _gate()
+
+    assert gate.should_pass(_event("fs.change", "/repo/.git/index.lock")) is False
+
+    assert gate.stats["suppressed"] == 1
+    assert gate.stats["by_reason"] == {"transient_suffix": 1}
+
+
+def test_signal_noise_gate_suppresses_windows_style_noisy_dirs() -> None:
+    gate = SignalNoiseGate(SignalNoiseConfig(workspace_root="C:/repo", same_source_cooldown_s=0.0))
+
+    assert gate.should_pass(_event("fs.change", r"C:\repo\.cache\state.db")) is False
+    assert gate.should_pass(_event("fs.change", "C:/repo/node_modules/pkg/index.js")) is False
+
+    assert gate.stats["suppressed"] == 2
+    assert gate.stats["by_reason"] == {"path_fragment": 1, "noisy_dir": 1}
+
+
+def test_signal_noise_gate_handles_mixed_windows_separators_for_workspace() -> None:
+    gate = SignalNoiseGate(SignalNoiseConfig(workspace_root=r"C:\repo", same_source_cooldown_s=0.0))
+
+    assert gate.should_pass(_event("fs.change", "C:/repo/src/main.py")) is True
+
+    assert gate.stats["passed"] == 1
+    assert gate.stats["suppressed"] == 0
+
+
+def test_signal_noise_gate_suppresses_fs_changes_outside_workspace_by_default() -> None:
+    gate = _gate()
+
+    assert gate.should_pass(_event("fs.change", "/Users/jason/other-project/src/main.py")) is False
+
+    assert gate.stats["suppressed"] == 1
+    assert gate.stats["by_reason"] == {"outside_workspace": 1}
+
+
+def test_signal_noise_gate_can_allow_fs_changes_outside_workspace() -> None:
+    gate = SignalNoiseGate(SignalNoiseConfig(
+        workspace_root="/repo",
+        allow_fs_outside_workspace=True,
+        same_source_cooldown_s=0.0,
+    ))
+
+    assert gate.should_pass(_event("fs.change", "/Users/jason/other-project/src/main.py")) is True
+
+    assert gate.stats["passed"] == 1
+    assert gate.stats["suppressed"] == 0
+
+
+def test_signal_noise_gate_suppresses_same_source_burst_but_allows_later() -> None:
+    gate = _gate()
+    clock = [100.0]
+
+    def _monotonic() -> float:
+        return clock[0]
+
+    with patch("leapflow.monitor.signal_noise.time.monotonic", side_effect=_monotonic):
+        assert gate.should_pass(_event("fs.change", "/repo/src/main.py")) is True
+        clock[0] = 101.0
+        assert gate.should_pass(_event("fs.change", "/repo/src/main.py")) is False
+        clock[0] = 103.1
+        assert gate.should_pass(_event("fs.change", "/repo/src/main.py")) is True
+
+    assert gate.stats["passed"] == 2
+    assert gate.stats["suppressed"] == 1
+    assert gate.stats["by_reason"] == {"same_source_burst": 1}
+
+
+def test_signal_noise_gate_keeps_non_fs_signals() -> None:
+    gate = _gate()
+
+    assert gate.should_pass(_event("gateway.signal", "lark")) is True
+    assert gate.should_pass(_event("ui.action", "keyboard")) is True
+    assert gate.should_pass(_event("clipboard.change", "system.clipboard")) is True
+
+    assert gate.stats["passed"] == 3
+    assert gate.stats["suppressed"] == 0
+
+
+def test_signal_noise_gate_can_be_disabled() -> None:
+    gate = SignalNoiseGate(SignalNoiseConfig(enabled=False, workspace_root="/repo"))
+
+    assert gate.should_pass(_event("fs.change", "/Users/jason/Library/Caches/noise.log")) is True
+
+    assert gate.stats["passed"] == 1
+    assert gate.stats["suppressed"] == 0
+
+
+def test_signal_noise_config_reads_settings_overrides() -> None:
+    settings = SimpleNamespace(
+        workspace_root="/work",
+        signal_noise_gate_enabled=False,
+        signal_noise_same_source_cooldown_s=0.5,
+        signal_noise_allow_fs_outside_workspace=True,
+        signal_noise_path_fragments=("/custom/noise/",),
+        signal_noise_dir_names=("Generated",),
+        signal_noise_suffixes=(".cachefile",),
+    )
+
+    config = SignalNoiseConfig.from_settings(settings)
+
+    assert config.enabled is False
+    assert config.workspace_root == "/work"
+    assert config.same_source_cooldown_s == 0.5
+    assert config.allow_fs_outside_workspace is True
+    assert config.path_fragments == ("/custom/noise/",)
+    assert config.dir_names == ("Generated",)
+    assert config.suffixes == (".cachefile",)
+
+
+def test_signal_metrics_collector_includes_noise_gate_stats() -> None:
+    gate = _gate()
+    gate.should_pass(_event("fs.change", "/repo/src/main.py"))
+    gate.should_pass(_event("fs.change", "/Users/jason/.hermes/kanban.db-shm"))
+
+    snapshot = SignalMetricsCollector().collect(signal_noise_gate=gate)
+
+    assert snapshot.signal_noise_seen == 2
+    assert snapshot.signal_noise_passed == 1
+    assert snapshot.signal_noise_suppressed == 1
+    assert snapshot.signal_noise_by_reason == {"transient_suffix": 1}
+    assert snapshot.signal_noise_by_family == {"fs": 1}