Remove app.py (old llama.cpp entrypoint, replaced by server.py)

app.py

@@ -1,1324 +0,0 @@
-from __future__ import annotations
-
-import json
-import html
-import os
-import shutil
-from pathlib import Path
-from typing import Any
-
-import gradio as gr
-
-from tiny_trigger.actions import dispatch_events
-from tiny_trigger.automation import evaluate_video_detections, load_automation_text
-from tiny_trigger.detector import parse_class_prompt
-from tiny_trigger.llm import compile_automation_with_llamacpp
-from tiny_trigger.store import (
-    EVENTS_PATH,
-    RuntimeState,
-    append_events,
-    load_local_config,
-    load_runtime_state,
-    load_saved_automations,
-    save_automations,
-    save_runtime_state,
-)
-from tiny_trigger.video import process_video, render_automation_video
-
-
-LOCAL_CONFIG = load_local_config()
-DEFAULT_CLASSES = os.getenv(
-    "TINY_TRIGGER_CLASSES",
-    LOCAL_CONFIG.default_classes or "person, wheel, clothes, chair, monitor, steering wheel, bag, sticker",
-)
-DEFAULT_MODEL = os.getenv("TINY_TRIGGER_YOLOE_MODEL", LOCAL_CONFIG.default_detector_model or "yoloe-26s-seg.pt")
-DEFAULT_DEVICE = os.getenv("TINY_TRIGGER_DEVICE", LOCAL_CONFIG.default_device or "auto")
-DEFAULT_IMAGE_SIZE = int(os.getenv("TINY_TRIGGER_IMAGE_SIZE", LOCAL_CONFIG.default_image_size or 960))
-DEFAULT_MAX_DETECTIONS = int(os.getenv("TINY_TRIGGER_MAX_DETECTIONS", LOCAL_CONFIG.default_max_detections or 100))
-DEFAULT_WEBHOOK_URL = os.getenv("TINY_TRIGGER_WEBHOOK_URL", LOCAL_CONFIG.webhook_url or "")
-DEFAULT_LLAMACPP_BASE_URL = os.getenv(
-    "TINY_TRIGGER_LLAMACPP_BASE_URL",
-    LOCAL_CONFIG.llamacpp_base_url or "http://127.0.0.1:8080/v1",
-)
-DEFAULT_LLAMACPP_MODEL = os.getenv(
-    "TINY_TRIGGER_LLAMACPP_MODEL",
-    LOCAL_CONFIG.llamacpp_model or "ggml-org/Qwen3-1.7B-GGUF:Q4_K_M",
-)
-
-
-def _ensure_ffmpeg_available() -> None:
-    if shutil.which("ffmpeg") and shutil.which("ffprobe"):
-        return
-
-    try:
-        import static_ffmpeg
-
-        static_ffmpeg.add_paths()
-    except ImportError:
-        pass
-    if shutil.which("ffmpeg") and shutil.which("ffprobe"):
-        return
-
-    try:
-        import imageio_ffmpeg
-    except ImportError:
-        return
-
-    ffmpeg_exe = Path(imageio_ffmpeg.get_ffmpeg_exe())
-    local_bin = Path(".local") / "bin"
-    local_bin.mkdir(parents=True, exist_ok=True)
-    ffmpeg_link = local_bin / ("ffmpeg.exe" if os.name == "nt" else "ffmpeg")
-    if not ffmpeg_link.exists():
-        try:
-            ffmpeg_link.symlink_to(ffmpeg_exe)
-        except OSError:
-            shutil.copy2(ffmpeg_exe, ffmpeg_link)
-            ffmpeg_link.chmod(0o755)
-    os.environ["PATH"] = f"{local_bin.resolve()}{os.pathsep}{os.environ.get('PATH', '')}"
-
-
-_ensure_ffmpeg_available()
-
-APP_CSS = """
-:root {
-  --tt-bg: #f6f7f8;
-  --tt-surface: #ffffff;
-  --tt-surface-soft: #eef2f5;
-  --tt-text: #17202a;
-  --tt-muted: #687484;
-  --tt-border: #dce1e7;
-  --tt-border-strong: #cbd3dd;
-  --tt-red: #d93a2f;
-  --tt-red-dark: #b92f27;
-  --tt-teal: #109f8f;
-  --tt-blue: #3569d4;
-  --tt-lime: #d5ef4a;
-  --tt-shadow: 0 20px 45px rgba(31, 41, 55, 0.08);
-  --tt-radius: 8px;
-}
-
-body,
-.gradio-container {
-  background:
-    linear-gradient(180deg, rgba(16, 159, 143, 0.08), rgba(246, 247, 248, 0) 310px),
-    var(--tt-bg) !important;
-  color: var(--tt-text) !important;
-  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif !important;
-  letter-spacing: 0 !important;
-}
-
-.gradio-container {
-  max-width: 1440px !important;
-  margin: 0 auto !important;
-  padding: 22px 24px 32px !important;
-}
-
-footer {
-  display: none !important;
-}
-
-.tt-hero {
-  display: flex;
-  align-items: flex-start;
-  justify-content: space-between;
-  gap: 18px;
-  margin-bottom: 18px;
-}
-
-.tt-kicker {
-  margin: 0 0 5px;
-  color: var(--tt-muted);
-  font-size: 12px;
-  font-weight: 800;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-}
-
-.tt-title {
-  margin: 0;
-  color: var(--tt-text);
-  font-size: 31px;
-  line-height: 1.05;
-  font-weight: 820;
-}
-
-.tt-subtitle {
-  margin: 8px 0 0;
-  color: var(--tt-muted);
-  font-size: 14px;
-}
-
-.tt-chips {
-  display: flex;
-  flex-wrap: wrap;
-  justify-content: flex-end;
-  gap: 9px;
-}
-
-.tt-chip {
-  display: inline-flex;
-  align-items: center;
-  min-height: 31px;
-  padding: 0 12px;
-  border: 1px solid var(--tt-border);
-  border-radius: 999px;
-  background: rgba(255, 255, 255, 0.76);
-  color: var(--tt-text);
-  font-size: 12px;
-  font-weight: 800;
-  white-space: nowrap;
-  box-shadow: 0 8px 20px rgba(31, 41, 55, 0.04);
-}
-
-.tt-chip.live {
-  border-color: transparent;
-  background: var(--tt-teal);
-  color: #ffffff;
-}
-
-.tt-grid {
-  gap: 16px !important;
-  align-items: stretch !important;
-}
-
-.tt-panel {
-  border: 1px solid var(--tt-border) !important;
-  border-radius: var(--tt-radius) !important;
-  background: var(--tt-surface) !important;
-  color: var(--tt-text) !important;
-  box-shadow: var(--tt-shadow) !important;
-  overflow: hidden !important;
-}
-
-.tt-panel > div,
-.tt-panel .form,
-.tt-panel .block,
-.tt-panel .wrap,
-.tt-panel .contain,
-.tt-video-panel > div,
-.tt-data-panel > div {
-  background: var(--tt-surface) !important;
-  color: var(--tt-text) !important;
-}
-
-.tt-panel > .form,
-.tt-panel .form {
-  border: 0 !important;
-  background: transparent !important;
-}
-
-.tt-panel-title h2,
-.tt-panel-title h3,
-.tt-section h2,
-.tt-section h3 {
-  margin: 0 !important;
-  color: var(--tt-muted) !important;
-  font-size: 12px !important;
-  font-weight: 850 !important;
-  letter-spacing: 0.08em !important;
-  line-height: 1.2 !important;
-  text-transform: uppercase !important;
-}
-
-.tt-panel-title {
-  margin-bottom: 10px !important;
-}
-
-.tt-panel .block,
-.tt-panel .block.padded {
-  border-color: var(--tt-border) !important;
-  border-radius: 7px !important;
-}
-
-.tt-panel label,
-.tt-panel .label-wrap,
-.tt-panel .wrap label,
-.tt-panel .block-label {
-  color: var(--tt-muted) !important;
-  font-size: 12px !important;
-  font-weight: 780 !important;
-}
-
-.tt-panel textarea,
-.tt-panel input,
-.tt-panel select {
-  color: var(--tt-text) !important;
-  background: #ffffff !important;
-}
-
-.tt-panel textarea,
-.tt-panel input {
-  border-color: var(--tt-border-strong) !important;
-}
-
-.tt-panel .secondary,
-.tt-panel button.secondary {
-  border: 1px solid var(--tt-border) !important;
-  background: var(--tt-surface-soft) !important;
-  color: var(--tt-text) !important;
-}
-
-.tt-primary button,
-.tt-panel button.primary,
-button.primary {
-  border: 0 !important;
-  background: var(--tt-red) !important;
-  color: #ffffff !important;
-  font-weight: 820 !important;
-}
-
-.tt-panel button.primary:hover,
-button.primary:hover {
-  background: var(--tt-red-dark) !important;
-}
-
-.tt-run-row {
-  gap: 10px !important;
-  align-items: stretch !important;
-  flex-wrap: nowrap !important;
-}
-
-.tt-run-row button,
-.tt-panel button {
-  min-height: 40px !important;
-  border-radius: 7px !important;
-  padding: 0 14px !important;
-  font-size: 13px !important;
-  font-weight: 820 !important;
-  line-height: 1.1 !important;
-  white-space: nowrap !important;
-}
-
-.tt-run-row button {
-  width: 100% !important;
-}
-
-.tt-run-row .form,
-.tt-run-row > div {
-  flex: 1 1 0 !important;
-  min-width: 0 !important;
-}
-
-.gradio-container button[role="tab"] {
-  min-height: 36px !important;
-  border: 1px solid var(--tt-border) !important;
-  border-radius: 7px !important;
-  background: rgba(255, 255, 255, 0.78) !important;
-  color: var(--tt-text) !important;
-  font-size: 13px !important;
-  font-weight: 820 !important;
-  box-shadow: none !important;
-}
-
-.gradio-container button[role="tab"][aria-selected="true"] {
-  border-color: transparent !important;
-  background: var(--tt-blue) !important;
-  color: #ffffff !important;
-}
-
-.tt-video-panel {
-  border: 1px solid var(--tt-border) !important;
-  border-radius: var(--tt-radius) !important;
-  background: var(--tt-surface) !important;
-  box-shadow: var(--tt-shadow) !important;
-  overflow: hidden !important;
-}
-
-.tt-video-panel .tabs,
-.tt-data-panel .tabs,
-.tt-automation-panel .tabs {
-  border: 0 !important;
-}
-
-.tt-video-panel .tab-nav,
-.tt-data-panel .tab-nav,
-.tt-automation-panel .tab-nav {
-  gap: 7px !important;
-  padding: 0 !important;
-  border: 0 !important;
-}
-
-.tt-video-panel button[role="tab"],
-.tt-data-panel button[role="tab"],
-.tt-automation-panel button[role="tab"] {
-  min-height: 34px !important;
-  border: 1px solid var(--tt-border) !important;
-  border-radius: 7px !important;
-  background: var(--tt-surface-soft) !important;
-  color: var(--tt-text) !important;
-  font-size: 12px !important;
-  font-weight: 820 !important;
-}
-
-.tt-video-panel button[role="tab"][aria-selected="true"],
-.tt-data-panel button[role="tab"][aria-selected="true"],
-.tt-automation-panel button[role="tab"][aria-selected="true"] {
-  background: var(--tt-blue) !important;
-  color: #ffffff !important;
-}
-
-.tt-result-video {
-  min-height: 430px !important;
-}
-
-.tt-result-video video {
-  border-radius: 8px !important;
-  background:
-    linear-gradient(90deg, rgba(23, 32, 42, 0.07) 1px, transparent 1px),
-    linear-gradient(0deg, rgba(23, 32, 42, 0.07) 1px, transparent 1px),
-    #edf1f5 !important;
-  background-size: 48px 48px, 48px 48px, 100% 100% !important;
-}
-
-.tt-status-grid {
-  gap: 10px !important;
-}
-
-.tt-status-card {
-  min-height: 82px;
-  padding: 13px 14px;
-  border: 1px solid var(--tt-border);
-  border-radius: var(--tt-radius);
-  background: #ffffff;
-  box-shadow: inset 0 0 0 1px rgba(255,255,255,0.4);
-}
-
-.tt-status-card strong {
-  display: block;
-  margin-bottom: 4px;
-  color: var(--tt-text);
-  font-size: 14px;
-  line-height: 1.2;
-}
-
-.tt-status-card span {
-  display: block;
-  color: var(--tt-muted);
-  font-size: 12px;
-  line-height: 1.35;
-}
-
-.tt-status-card.success {
-  border-color: rgba(16, 159, 143, 0.35);
-  background: rgba(16, 159, 143, 0.08);
-}
-
-.tt-status-card.action {
-  border-color: rgba(217, 58, 47, 0.32);
-  background: rgba(217, 58, 47, 0.09);
-}
-
-.tt-status-card.warning {
-  border-color: rgba(213, 160, 20, 0.38);
-  background: rgba(213, 160, 20, 0.11);
-}
-
-.tt-status-card.idle {
-  background: #f8fafc;
-}
-
-.tt-label-audit {
-  display: grid;
-  gap: 10px;
-  padding: 13px 14px;
-  border: 1px solid rgba(16, 159, 143, 0.28);
-  border-radius: var(--tt-radius);
-  background: rgba(16, 159, 143, 0.07);
-}
-
-.tt-label-audit strong {
-  display: block;
-  color: var(--tt-text);
-  font-size: 14px;
-  line-height: 1.2;
-}
-
-.tt-label-audit span {
-  color: var(--tt-muted);
-  font-size: 12px;
-}
-
-.tt-chip-row {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 8px;
-}
-
-.tt-flow-copy {
-  margin: 0 0 12px;
-  color: var(--tt-muted);
-  font-size: 13px;
-  line-height: 1.45;
-}
-
-.tt-code textarea,
-.tt-code code,
-.tt-code pre {
-  font-family: "SFMono-Regular", Consolas, "Liberation Mono", monospace !important;
-  font-size: 12px !important;
-  line-height: 1.45 !important;
-}
-
-.tt-data-panel {
-  border: 1px solid var(--tt-border) !important;
-  border-radius: var(--tt-radius) !important;
-  background: var(--tt-surface) !important;
-  box-shadow: var(--tt-shadow) !important;
-  overflow: hidden !important;
-}
-
-.tt-data-panel table {
-  font-size: 13px !important;
-}
-
-.tt-data-panel th {
-  color: var(--tt-muted) !important;
-  font-size: 11px !important;
-  font-weight: 820 !important;
-  text-transform: uppercase !important;
-}
-
-.tt-compact textarea {
-  min-height: 84px !important;
-}
-
-.tt-demo-state {
-  margin-top: 10px;
-}
-
-@media (max-width: 980px) {
-  .gradio-container {
-    padding: 16px !important;
-  }
-
-  .tt-hero {
-    flex-direction: column;
-  }
-
-  .tt-chips {
-    justify-content: flex-start;
-  }
-
-  .tt-result-video {
-    min-height: 300px !important;
-  }
-}
-"""
-
-FALLBACK_RULES = """rules:
-  - name: person-near-steering-wheel
-    when:
-      all:
-        - present: {label: person, min_count: 1}
-        - near: {a: person, b: steering wheel, max_distance: 0.45}
-    gate:
-      enabled: true
-      cooldown: {key: turn-on-pc, minutes: 5}
-    then:
-      - type: webhook
-        name: turn on pc
-"""
-SAVED_AUTOMATIONS = load_saved_automations()
-DEFAULT_RULES = (
-    SAVED_AUTOMATIONS.model_dump_json(by_alias=True, indent=2)
-    if SAVED_AUTOMATIONS
-    else FALLBACK_RULES
-)
-
-
-def _detection_rows(detections: list[Any]) -> list[list[Any]]:
-    return [
-        [
-            det.frame_index,
-            round(det.timestamp_sec, 2),
-            det.label,
-            round(det.confidence, 3),
-            [round(value, 1) for value in det.bbox_xyxy],
-            [round(value, 3) for value in det.bbox_xyxy_norm],
-        ]
-        for det in detections
-    ]
-
-
-def _event_rows(events: list[Any]) -> list[list[Any]]:
-    return [
-        [
-            event.rule,
-            event.action,
-            event.type,
-            event.status,
-            event.frame_index,
-            round(event.timestamp_sec, 2),
-            event.response_status or "",
-            event.error or "",
-        ]
-        for event in events
-    ]
-
-
-def _result_json(result: Any) -> dict[str, Any]:
-    return json.loads(result.model_dump_json())
-
-
-def _status_card(tone: str, title: str, body: str) -> str:
-    return f"""
-<div class="tt-status-card {tone}">
-  <strong>{title}</strong>
-  <span>{body}</span>
-</div>
-"""
-
-
-def _rules_json(document: Any) -> dict[str, Any]:
-    return json.loads(document.model_dump_json(by_alias=True))
-
-
-def _automation_labels_from_document(document: Any) -> list[str]:
-    labels: list[str] = []
-    for rule in document.rules:
-        for condition in [*rule.when.all_conditions, *rule.when.any_conditions]:
-            if condition.present:
-                labels.append(condition.present.label)
-            if condition.count:
-                labels.append(condition.count.label)
-            if condition.near:
-                labels.extend([condition.near.a, condition.near.b])
-    return parse_class_prompt(labels)
-
-
-def _automation_labels_from_text(rules_text: str) -> list[str]:
-    return _automation_labels_from_document(load_automation_text(rules_text))
-
-
-def _automation_labels_from_rule(rule: Any) -> list[str]:
-    labels: list[str] = []
-    for condition in [*rule.when.all_conditions, *rule.when.any_conditions]:
-        if condition.present:
-            labels.append(condition.present.label)
-        if condition.count:
-            labels.append(condition.count.label)
-        if condition.near:
-            labels.extend([condition.near.a, condition.near.b])
-    return parse_class_prompt(labels)
-
-
-def _labels_summary(labels: list[str]) -> str:
-    if not labels:
-        return "No detector labels found in the active automations."
-    return ", ".join(labels)
-
-
-def _labels_card(labels: list[str]) -> str:
-    chips = "".join(f"<span class=\"tt-chip\">{html.escape(label)}</span>" for label in labels)
-    chips = chips or "<span class=\"tt-chip\">No labels</span>"
-    return f"""
-<div class="tt-label-audit">
-  <div>
-    <strong>Detector audit</strong>
-    <span>{len(labels)} label{'s' if len(labels) != 1 else ''} derived from active automations</span>
-  </div>
-  <div class="tt-chip-row">{chips}</div>
-</div>
-"""
-
-
-def _condition_summary(rule: Any) -> str:
-    parts: list[str] = []
-    for condition in [*rule.when.all_conditions, *rule.when.any_conditions]:
-        if condition.present:
-            parts.append(f"present {condition.present.label}")
-        if condition.count:
-            parts.append(f"{condition.count.label} >= {condition.count.minimum}")
-        if condition.near:
-            parts.append(f"{condition.near.a} near {condition.near.b}")
-        if condition.cooldown:
-            duration = condition.cooldown.minutes or condition.cooldown.seconds or 0
-            unit = "min" if condition.cooldown.minutes is not None else "sec"
-            parts.append(f"cooldown {duration:g}{unit}")
-    return " + ".join(parts)
-
-
-def _action_summary(rule: Any) -> str:
-    return ", ".join(f"{action.type}: {action.name}" for action in rule.then)
-
-
-def _rule_rows(document: Any) -> list[list[Any]]:
-    rows: list[list[Any]] = []
-    for rule in document.rules:
-        rows.append(
-            [
-                "on" if rule.gate.enabled else "off",
-                rule.name,
-                _labels_summary(_automation_labels_from_rule(rule)),
-                _condition_summary(rule),
-                _action_summary(rule),
-            ]
-        )
-    return rows
-
-
-def _rule_names(document: Any) -> list[str]:
-    return [rule.name for rule in document.rules]
-
-
-def _rule_enabled(document: Any, rule_name: str | None) -> bool:
-    for rule in document.rules:
-        if rule.name == rule_name:
-            return rule.gate.enabled
-    return False
-
-
-def _rules_text_from_data(data: dict[str, Any]) -> str:
-    document = load_automation_text(json.dumps(data))
-    return document.model_dump_json(by_alias=True, indent=2)
-
-
-def _merge_generated_rules(existing_rules_text: str, generated_document: Any) -> Any:
-    try:
-        existing_data = _rules_json(load_automation_text(existing_rules_text))
-        existing_rules = existing_data["rules"]
-    except Exception:
-        existing_rules = []
-
-    generated_rules = _rules_json(generated_document)["rules"]
-    merged_by_name: dict[str, dict[str, Any]] = {rule["name"]: rule for rule in existing_rules}
-    ordered_names = [rule["name"] for rule in existing_rules]
-    for rule in generated_rules:
-        if rule["name"] not in merged_by_name:
-            ordered_names.append(rule["name"])
-        merged_by_name[rule["name"]] = rule
-
-    merged_rules = [merged_by_name[name] for name in ordered_names]
-    return load_automation_text(json.dumps({"rules": merged_rules}))
-
-
-def refresh_automation_manager(rules_text: str) -> tuple[list[list[Any]], Any, bool, dict[str, Any], str, str, str]:
-    try:
-        document = load_automation_text(rules_text)
-    except Exception as exc:
-        raise gr.Error(f"Rules did not validate: {exc}") from exc
-    names = _rule_names(document)
-    selected = names[0] if names else None
-    labels = _automation_labels_from_document(document)
-    return (
-        _rule_rows(document),
-        gr.update(choices=names, value=selected),
-        _rule_enabled(document, selected),
-        {"status": "valid", "rules": _rules_json(document)["rules"], "labels": labels},
-        _status_card("success", "Manager refreshed", f"{len(names)} automation(s) loaded."),
-        _labels_card(labels),
-        _labels_card(labels),
-    )
-
-
-def select_managed_rule(rules_text: str, rule_name: str | None) -> tuple[bool, str]:
-    document = load_automation_text(rules_text)
-    return (
-        _rule_enabled(document, rule_name),
-        _status_card("idle", "Automation selected", rule_name or "No automation selected."),
-    )
-
-
-def set_rule_enabled(rules_text: str, rule_name: str | None, enabled: bool) -> tuple[
-    str,
-    list[list[Any]],
-    Any,
-    bool,
-    dict[str, Any],
-    str,
-    str,
-    str,
-]:
-    if not rule_name:
-        raise gr.Error("Choose an automation first.")
-
-    document = load_automation_text(rules_text)
-    data = _rules_json(document)
-    changed = False
-    for rule in data["rules"]:
-        if rule["name"] == rule_name:
-            rule.setdefault("gate", {})
-            rule["gate"]["enabled"] = enabled
-            changed = True
-            break
-    if not changed:
-        raise gr.Error(f"Automation not found: {rule_name}")
-
-    updated_text = _rules_text_from_data(data)
-    updated_document = load_automation_text(updated_text)
-    labels = _automation_labels_from_document(updated_document)
-    names = _rule_names(updated_document)
-    return (
-        updated_text,
-        _rule_rows(updated_document),
-        gr.update(choices=names, value=rule_name),
-        enabled,
-        {"status": "updated", "rules": _rules_json(updated_document)["rules"], "labels": labels},
-        _status_card("success", "Automation updated", f"{rule_name} is {'on' if enabled else 'off'}."),
-        _labels_card(labels),
-        _labels_card(labels),
-    )
-
-
-def _video_file_path(value: Any) -> str | None:
-    if value is None:
-        return None
-    if isinstance(value, str):
-        return value
-    if isinstance(value, Path):
-        return str(value)
-    if isinstance(value, dict):
-        return value.get("path") or value.get("name")
-    path = getattr(value, "path", None) or getattr(value, "name", None)
-    return str(path) if path else None
-
-
-def reset_demo_state() -> tuple[str, dict[str, Any]]:
-    save_runtime_state(RuntimeState())
-    if EVENTS_PATH.exists():
-        EVENTS_PATH.unlink()
-    return (
-        _status_card("success", "Demo state reset", "Cooldown memory and action history are clear."),
-        {"status": "reset", "last_fired": {}, "events": "cleared"},
-    )
-
-
-def run_detector(
-    video_path: str | None,
-    class_prompt: str,
-    confidence: float,
-    frame_stride: int,
-    max_frames: int,
-    model_name: str,
-    image_size: int,
-    device: str,
-    max_detections: int,
-) -> tuple[str | None, list[list[Any]], dict[str, Any], str]:
-    if not video_path:
-        raise gr.Error("Upload a video first.")
-    if not parse_class_prompt(class_prompt):
-        raise gr.Error("Enter at least one class prompt.")
-
-    result = process_video(
-        video_path=video_path,
-        class_prompt=class_prompt,
-        confidence=confidence,
-        frame_stride=frame_stride,
-        max_frames=max_frames,
-        model_name=model_name or DEFAULT_MODEL,
-        image_size=image_size,
-        device=None if device == "auto" else device,
-        max_detections=max_detections,
-    )
-    return (
-        result.output_video_path,
-        _detection_rows(result.detections),
-        _result_json(result),
-        _status_card(
-            "success",
-            f"{len(result.detections)} detections",
-            f"Processed {result.processed_frames} frames at {result.output_fps:.1f} FPS output.",
-        ),
-    )
-
-
-def compile_rules(
-    instruction: str,
-    current_rules_text: str,
-    label_hints: str,
-    base_url: str,
-    model: str,
-) -> tuple[str, dict[str, Any], str, str, list[list[Any]], Any, bool, str]:
-    if not instruction.strip():
-        raise gr.Error("Describe the automation first.")
-
-    try:
-        compiled = compile_automation_with_llamacpp(
-            instruction=instruction,
-            class_names=parse_class_prompt(label_hints),
-            base_url=base_url or DEFAULT_LLAMACPP_BASE_URL,
-            model=model or DEFAULT_LLAMACPP_MODEL,
-        )
-    except Exception as exc:
-        raise gr.Error(f"Could not compile automation: {exc}") from exc
-    merged_document = _merge_generated_rules(current_rules_text, compiled.document)
-    rules_json = merged_document.model_dump_json(by_alias=True, indent=2)
-    labels = _automation_labels_from_document(merged_document)
-    names = _rule_names(merged_document)
-    generated_names = _rule_names(compiled.document)
-    selected = generated_names[0] if generated_names else (names[0] if names else None)
-    labels_card = _labels_card(labels)
-    return (
-        rules_json,
-        {
-            "raw_text": compiled.raw_text,
-            "generated": _rules_json(compiled.document)["rules"],
-            "active_rules": json.loads(rules_json)["rules"],
-            "labels": labels,
-        },
-        _status_card(
-            "success",
-            "Generated and added",
-            f"{len(compiled.document.rules)} new rule(s). {len(merged_document.rules)} active automation(s).",
-        ),
-        labels_card,
-        _rule_rows(merged_document),
-        gr.update(choices=names, value=selected),
-        _rule_enabled(merged_document, selected),
-        labels_card,
-    )
-
-
-def validate_rules(rules_text: str) -> tuple[dict[str, Any], str, str, list[list[Any]], Any, bool, str]:
-    try:
-        document = load_automation_text(rules_text)
-    except Exception as exc:
-        raise gr.Error(f"Rules did not validate: {exc}") from exc
-    labels = _automation_labels_from_document(document)
-    names = _rule_names(document)
-    selected = names[0] if names else None
-    labels_card = _labels_card(labels)
-    return (
-        {"status": "valid", "rules": _rules_json(document)["rules"], "labels": labels},
-        _status_card("success", "Validation passed", f"{len(document.rules)} rule(s) checked."),
-        labels_card,
-        _rule_rows(document),
-        gr.update(choices=names, value=selected),
-        _rule_enabled(document, selected),
-        labels_card,
-    )
-
-
-def save_rules(rules_text: str) -> tuple[str, dict[str, Any], str, str, list[list[Any]], Any, bool, str]:
-    document = load_automation_text(rules_text)
-    save_automations(document)
-    rules_json = document.model_dump_json(by_alias=True, indent=2)
-    labels = _automation_labels_from_document(document)
-    names = _rule_names(document)
-    selected = names[0] if names else None
-    labels_card = _labels_card(labels)
-    return (
-        rules_json,
-        {"status": "saved", "rules": json.loads(rules_json), "labels": labels},
-        _status_card(
-            "success",
-            "Saved locally",
-            f"{len(document.rules)} rule(s) stored. Monitor will watch: {_labels_summary(labels)}.",
-        ),
-        labels_card,
-        _rule_rows(document),
-        gr.update(choices=names, value=selected),
-        _rule_enabled(document, selected),
-        labels_card,
-    )
-
-
-def run_monitor_clip(
-    clip_file: Any,
-    rules_text: str,
-    confidence: float,
-    frame_stride: int,
-    max_frames: int,
-    model_name: str,
-    image_size: int,
-    device: str,
-    max_detections: int,
-    enable_webhooks: bool,
-    webhook_url: str,
-) -> tuple[str | None, list[list[Any]], list[list[Any]], dict[str, Any], str, str]:
-    video_path = _video_file_path(clip_file)
-    if not video_path:
-        raise gr.Error("Upload a clip first.")
-
-    rules = load_automation_text(rules_text)
-    labels = _automation_labels_from_document(rules)
-    if not labels:
-        raise gr.Error("The active automations do not mention any detector labels.")
-
-    state = load_runtime_state()
-    result = process_video(
-        video_path=video_path,
-        class_prompt=labels,
-        confidence=confidence,
-        frame_stride=frame_stride,
-        max_frames=max_frames,
-        model_name=model_name or DEFAULT_MODEL,
-        image_size=image_size,
-        device=None if device == "auto" else device,
-        max_detections=max_detections,
-    )
-    events, last_fired = evaluate_video_detections(rules.rules, result.detections, last_fired=state.last_fired)
-    dispatched = dispatch_events(events, enable_webhooks=enable_webhooks, webhook_url=webhook_url or None)
-    state.last_fired = last_fired
-    save_runtime_state(state)
-    append_events(dispatched)
-    automation_video_path = render_automation_video(
-        source_video_path=video_path,
-        detections=result.detections,
-        events=dispatched,
-        frame_stride=frame_stride,
-        max_frames=max_frames,
-    )
-
-    action_count = len(dispatched)
-    status_tone = "action" if action_count else "warning"
-    status_title = f"{action_count} event{'s' if action_count != 1 else ''}"
-    status_body = (
-        "Replay rendered with fired automation overlays."
-        if action_count
-        else f"No automations fired. Watched: {_labels_summary(labels)}."
-    )
-    return (
-        automation_video_path,
-        _event_rows(dispatched),
-        _detection_rows(result.detections),
-        {
-            "watched_labels": labels,
-            "video": _result_json(result),
-            "actions": [event.model_dump(mode="json") for event in dispatched],
-        },
-        _status_card(status_tone, status_title, status_body),
-        _labels_card(labels),
-    )
-
-
-def run_detector_and_automations(
-    video_path: str | None,
-    class_prompt: str,
-    confidence: float,
-    frame_stride: int,
-    max_frames: int,
-    model_name: str,
-    image_size: int,
-    device: str,
-    max_detections: int,
-    rules_text: str,
-    enable_webhooks: bool,
-    webhook_url: str,
-) -> tuple[str | None, list[list[Any]], list[list[Any]], dict[str, Any], str]:
-    if not video_path:
-        raise gr.Error("Upload a video first.")
-
-    rules = load_automation_text(rules_text)
-    state = load_runtime_state()
-    result = process_video(
-        video_path=video_path,
-        class_prompt=class_prompt,
-        confidence=confidence,
-        frame_stride=frame_stride,
-        max_frames=max_frames,
-        model_name=model_name or DEFAULT_MODEL,
-        image_size=image_size,
-        device=None if device == "auto" else device,
-        max_detections=max_detections,
-    )
-    events, last_fired = evaluate_video_detections(rules.rules, result.detections, last_fired=state.last_fired)
-    dispatched = dispatch_events(events, enable_webhooks=enable_webhooks, webhook_url=webhook_url or None)
-    state.last_fired = last_fired
-    save_runtime_state(state)
-    append_events(dispatched)
-    automation_video_path = render_automation_video(
-        source_video_path=video_path,
-        detections=result.detections,
-        events=dispatched,
-        frame_stride=frame_stride,
-        max_frames=max_frames,
-    )
-    action_count = len(dispatched)
-    status_tone = "action" if action_count else "warning"
-    status_title = f"{action_count} action{'s' if action_count != 1 else ''} fired"
-    status_body = (
-        "Automation replay rendered with fired-action overlay."
-        if action_count
-        else "Rules validated, but no frame matched the automation."
-    )
-    return (
-        automation_video_path,
-        _detection_rows(result.detections),
-        _event_rows(dispatched),
-        {
-            "video": _result_json(result),
-            "actions": [event.model_dump(mode="json") for event in dispatched],
-        },
-        _status_card(status_tone, status_title, status_body),
-    )
-
-
-try:
-    INITIAL_RULE_DOCUMENT = load_automation_text(DEFAULT_RULES)
-    INITIAL_RULE_LABELS = _automation_labels_from_document(INITIAL_RULE_DOCUMENT)
-    INITIAL_RULE_ROWS = _rule_rows(INITIAL_RULE_DOCUMENT)
-    INITIAL_RULE_NAMES = _rule_names(INITIAL_RULE_DOCUMENT)
-    INITIAL_SELECTED_RULE = INITIAL_RULE_NAMES[0] if INITIAL_RULE_NAMES else None
-    INITIAL_SELECTED_ENABLED = _rule_enabled(INITIAL_RULE_DOCUMENT, INITIAL_SELECTED_RULE)
-except Exception:
-    INITIAL_RULE_DOCUMENT = None
-    INITIAL_RULE_LABELS = []
-    INITIAL_RULE_ROWS = []
-    INITIAL_RULE_NAMES = []
-    INITIAL_SELECTED_RULE = None
-    INITIAL_SELECTED_ENABLED = False
-
-
-with gr.Blocks(title="Tiny Trigger") as demo:
-    gr.HTML(
-        """
-<header class="tt-hero">
-  <div>
-    <p class="tt-kicker">Hackathon MVP</p>
-    <h1 class="tt-title">Tiny Trigger</h1>
-    <p class="tt-subtitle">Video events from validated automations</p>
-  </div>
-  <div class="tt-chips">
-    <span class="tt-chip live">Validated rules</span>
-    <span class="tt-chip">Open vocabulary</span>
-    <span class="tt-chip">Camera-ready skeleton</span>
-  </div>
-</header>
-"""
-    )
-
-    with gr.Tabs():
-        with gr.Tab("Monitor"):
-            with gr.Row(elem_classes=["tt-grid"]):
-                with gr.Column(scale=4, min_width=320):
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Clip Intake", elem_classes=["tt-panel-title"])
-                        gr.Markdown(
-                            "Upload a short clip. Tiny Trigger scans for the labels required by the active automations and renders the event replay.",
-                            elem_classes=["tt-flow-copy"],
-                        )
-                        monitor_clip_input = gr.File(
-                            label="Video clip",
-                            file_types=[".mp4", ".mov", ".m4v", ".webm"],
-                            type="filepath",
-                        )
-                        monitor_run_button = gr.Button("Run clip", variant="primary")
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Active Watch", elem_classes=["tt-panel-title"])
-                        monitor_labels_output = gr.HTML(_labels_card(INITIAL_RULE_LABELS))
-                        monitor_status = gr.HTML(
-                            _status_card("idle", "Waiting for clip", "Upload a clip to run the active automations.")
-                        )
-
-                with gr.Column(scale=7, min_width=520):
-                    with gr.Group(elem_classes=["tt-video-panel"]):
-                        gr.Markdown("### Event Replay", elem_classes=["tt-panel-title"])
-                        automation_video = gr.Video(
-                            label="Automation replay",
-                            format="mp4",
-                            autoplay=True,
-                            elem_classes=["tt-result-video"],
-                        )
-                    with gr.Group(elem_classes=["tt-data-panel"]):
-                        gr.Markdown("### Events", elem_classes=["tt-panel-title"])
-                        actions_table = gr.Dataframe(
-                            headers=["rule", "action", "type", "status", "frame", "time", "response", "error"],
-                            datatype=["str", "str", "str", "str", "number", "number", "str", "str"],
-                            label="Action timeline",
-                        )
-                        with gr.Accordion("Run details", open=False):
-                            automation_detections = gr.Dataframe(
-                                headers=["frame", "time", "label", "confidence", "bbox", "bbox_norm"],
-                                datatype=["number", "number", "str", "number", "str", "str"],
-                                label="Detections",
-                            )
-                            automation_json = gr.JSON(label="Run JSON")
-
-        with gr.Tab("Automations"):
-            with gr.Row(elem_classes=["tt-grid"]):
-                with gr.Column(scale=4, min_width=340):
-                    with gr.Group(elem_classes=["tt-panel", "tt-automation-panel"]):
-                        gr.Markdown("### Generate Automation", elem_classes=["tt-panel-title"])
-                        instruction = gr.Textbox(
-                            label="Intent",
-                            value="If person near steering wheel then you have to turn on pc.",
-                            lines=5,
-                            elem_classes=["tt-compact"],
-                        )
-                        label_hints = gr.Textbox(
-                            label="Label hints for the generator",
-                            value=DEFAULT_CLASSES,
-                            lines=3,
-                            elem_classes=["tt-compact"],
-                        )
-                        with gr.Accordion("Compiler endpoint", open=False):
-                            llama_base_url = gr.Textbox(label="llama.cpp base URL", value=DEFAULT_LLAMACPP_BASE_URL)
-                            llama_model = gr.Textbox(label="llama.cpp model", value=DEFAULT_LLAMACPP_MODEL)
-                        with gr.Row(elem_classes=["tt-run-row"]):
-                            compile_button = gr.Button("Generate", variant="primary")
-                            validate_rules_button = gr.Button("Test", variant="secondary")
-                            save_rules_button = gr.Button("Save", variant="secondary")
-
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Manage Automations", elem_classes=["tt-panel-title"])
-                        automation_table = gr.Dataframe(
-                            headers=["state", "automation", "labels", "when", "then"],
-                            datatype=["str", "str", "str", "str", "str"],
-                            value=INITIAL_RULE_ROWS,
-                            interactive=False,
-                            label="Active automations",
-                        )
-                        managed_rule = gr.Dropdown(
-                            label="Automation",
-                            choices=INITIAL_RULE_NAMES,
-                            value=INITIAL_SELECTED_RULE,
-                        )
-                        managed_enabled = gr.Checkbox(label="Enabled", value=INITIAL_SELECTED_ENABLED)
-                        with gr.Row(elem_classes=["tt-run-row"]):
-                            apply_rule_button = gr.Button("Apply", variant="primary")
-                            refresh_manager_button = gr.Button("Refresh", variant="secondary")
-                            manager_save_button = gr.Button("Save all", variant="secondary")
-
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Audit", elem_classes=["tt-panel-title"])
-                        rules_status = gr.HTML(
-                            _status_card("idle", "Rules loaded", "Generate or test rules before running a clip.")
-                        )
-                        rules_labels_output = gr.HTML(_labels_card(INITIAL_RULE_LABELS))
-
-                with gr.Column(scale=7, min_width=520):
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Active Rules", elem_classes=["tt-panel-title"])
-                        rules_text = gr.Code(
-                            label="Rules JSON/YAML",
-                            language="yaml",
-                            value=DEFAULT_RULES,
-                            lines=22,
-                            elem_classes=["tt-code"],
-                        )
-                    with gr.Group(elem_classes=["tt-data-panel"]):
-                        gr.Markdown("### Compile Test", elem_classes=["tt-panel-title"])
-                        compiled_json = gr.JSON(label="Rule audit")
-
-        with gr.Tab("Settings"):
-            with gr.Row(elem_classes=["tt-grid"]):
-                with gr.Column(scale=4, min_width=320):
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Detector", elem_classes=["tt-panel-title"])
-                        model_name = gr.Textbox(label="YOLOE model", value=DEFAULT_MODEL)
-                        device = gr.Dropdown(label="Device", choices=["auto", "mps", "cuda:0", "cpu"], value=DEFAULT_DEVICE)
-                        image_size = gr.Slider(label="Image size", minimum=320, maximum=1536, step=32, value=DEFAULT_IMAGE_SIZE)
-                        confidence = gr.Slider(label="Sensitivity", minimum=0.05, maximum=0.95, step=0.05, value=0.25)
-                        frame_stride = gr.Slider(label="Frame stride", minimum=1, maximum=30, step=1, value=5)
-                        max_frames = gr.Slider(label="Max processed frames", minimum=10, maximum=600, step=10, value=120)
-                        max_detections = gr.Slider(
-                            label="Max detections",
-                            minimum=1,
-                            maximum=300,
-                            step=1,
-                            value=DEFAULT_MAX_DETECTIONS,
-                        )
-                with gr.Column(scale=4, min_width=320):
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Dispatch", elem_classes=["tt-panel-title"])
-                        enable_webhooks = gr.Checkbox(label="Enable webhook POSTs", value=False)
-                        webhook_url = gr.Textbox(label="Fallback webhook URL", value=DEFAULT_WEBHOOK_URL)
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### Demo State", elem_classes=["tt-panel-title"])
-                        demo_state_output = gr.HTML(
-                            _status_card("idle", "Ready for replay", "Cooldown memory is kept between automation runs."),
-                            elem_classes=["tt-demo-state"],
-                        )
-                        reset_state_button = gr.Button("Reset cooldowns and history", variant="secondary")
-                        demo_state_json = gr.JSON(label="State event", visible=False)
-                with gr.Column(scale=4, min_width=320):
-                    with gr.Group(elem_classes=["tt-panel"]):
-                        gr.Markdown("### IP Camera Skeleton", elem_classes=["tt-panel-title"])
-                        gr.Markdown(
-                            "The MVP runs uploaded clips. This section reserves the next product path: a persistent camera feed that runs the same active automations on a schedule.",
-                            elem_classes=["tt-flow-copy"],
-                        )
-                        camera_url = gr.Textbox(label="Camera / RTSP URL", value=LOCAL_CONFIG.camera_url or "")
-                        poll_interval = gr.Slider(label="Polling interval seconds", minimum=1, maximum=60, step=1, value=5)
-                        gr.HTML(_status_card("idle", "Not active in MVP", "Prepared for continuous monitoring after the hackathon demo."))
-
-    monitor_inputs = [
-        monitor_clip_input,
-        rules_text,
-        confidence,
-        frame_stride,
-        max_frames,
-        model_name,
-        image_size,
-        device,
-        max_detections,
-        enable_webhooks,
-        webhook_url,
-    ]
-    monitor_outputs = [
-        automation_video,
-        actions_table,
-        automation_detections,
-        automation_json,
-        monitor_status,
-        monitor_labels_output,
-    ]
-    generated_rule_outputs = [
-        rules_text,
-        compiled_json,
-        rules_status,
-        rules_labels_output,
-        automation_table,
-        managed_rule,
-        managed_enabled,
-        monitor_labels_output,
-    ]
-    tested_rule_outputs = [
-        compiled_json,
-        rules_status,
-        rules_labels_output,
-        automation_table,
-        managed_rule,
-        managed_enabled,
-        monitor_labels_output,
-    ]
-    manager_refresh_outputs = [
-        automation_table,
-        managed_rule,
-        managed_enabled,
-        compiled_json,
-        rules_status,
-        rules_labels_output,
-        monitor_labels_output,
-    ]
-    manager_apply_outputs = [
-        rules_text,
-        automation_table,
-        managed_rule,
-        managed_enabled,
-        compiled_json,
-        rules_status,
-        rules_labels_output,
-        monitor_labels_output,
-    ]
-    monitor_clip_input.change(run_monitor_clip, inputs=monitor_inputs, outputs=monitor_outputs)
-    monitor_run_button.click(run_monitor_clip, inputs=monitor_inputs, outputs=monitor_outputs)
-    compile_button.click(
-        compile_rules,
-        inputs=[instruction, rules_text, label_hints, llama_base_url, llama_model],
-        outputs=generated_rule_outputs,
-    )
-    validate_rules_button.click(
-        validate_rules,
-        inputs=[rules_text],
-        outputs=tested_rule_outputs,
-    )
-    save_rules_button.click(
-        save_rules,
-        inputs=[rules_text],
-        outputs=generated_rule_outputs,
-    )
-    manager_save_button.click(save_rules, inputs=[rules_text], outputs=generated_rule_outputs)
-    refresh_manager_button.click(refresh_automation_manager, inputs=[rules_text], outputs=manager_refresh_outputs)
-    managed_rule.change(select_managed_rule, inputs=[rules_text, managed_rule], outputs=[managed_enabled, rules_status])
-    apply_rule_button.click(
-        set_rule_enabled,
-        inputs=[rules_text, managed_rule, managed_enabled],
-        outputs=manager_apply_outputs,
-    )
-    reset_state_button.click(reset_demo_state, outputs=[demo_state_output, demo_state_json])
-
-
-if __name__ == "__main__":
-    demo.launch(ssr_mode=False, css=APP_CSS)