Refactor store dwell alert management API and dwell engine

- Updated argument parsing in manage_api.py to include new threshold parameters. - Enhanced _config_payload to include thresholds and webhook configurations. - Modified _build_summary to track queue metrics and adjust alert reporting. - Refactored DwellEngine to utilize queue thresholds for alerting and reporting. - Added queue metrics calculations and status change tracking in dwell_engine.py. - Updated notifier.py to support posting JSON events to webhooks. - Adjusted example configuration to reflect new threshold parameters. - Enhanced Docker entrypoint script for better process management. - Updated tests to cover new queue metrics and thresholds. - Improved ManagedServiceDetail and ManagedServices Vue components to display queue metrics.
2026-05-09 11:35:55 +08:00
parent be5014c582
commit ea618fd674
26 changed files with 1605 additions and 117 deletions
--- a/3
+++ b/3
@@ -1,7 +1,8 @@
 FROM swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/library/golang:1.25.4-alpine AS builder

 ENV TZ=Asia/Shanghai \
-    GOPROXY=https://goproxy.cn,direct
+    GOPROXY=https://goproxy.cn,direct \
+    GOSUMDB=sum.golang.google.cn

 RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories
 RUN apk add --no-cache ca-certificates tzdata
--- a/deploy/managed-portal.10.8.0.11.env
+++ b/deploy/managed-portal.10.8.0.11.env
@@ -0,0 +1,13 @@
+IMAGE_VERSION=dev
+TZ=Asia/Shanghai
+MANAGED_PORTAL_WEB_PORT=13000
+
+MANAGED_STORE_DWELL_CAMERA_ID=cam_192_168_3_3
+MANAGED_STORE_DWELL_RTSP_URL=rtsp://admin:Zxjp2026@192.168.3.3:554/h264/ch1/main/av_stream
+MANAGED_STORE_DWELL_EVENT_SINK_PATH=logs/events.jsonl
+MANAGED_STORE_DWELL_CONFIG_DIR=../managed/store_dwell_alert/config
+MANAGED_STORE_DWELL_DATA_DIR=../managed/store_dwell_alert/data
+
+MANAGED_PEOPLE_FLOW_RTSP_URL=rtsp://admin:Zxjp2026@192.168.3.3:554/h264/ch1/main/av_stream
+MANAGED_PEOPLE_FLOW_CONFIG_DIR=../managed/people_flow_project/config
+MANAGED_PEOPLE_FLOW_OUTPUT_DIR=../managed/people_flow_project/outputs
--- a/docs/managed-queue-webhook.md
+++ b/docs/managed-queue-webhook.md
@@ -0,0 +1,249 @@
+# Managed Queue Webhook 对接说明
+
+本文档说明 `managed/store_dwell_alert` 和 `managed/people_flow_project` 两个工程新增的排队统计与 webhook 推送结构，便于接收方按统一协议完成对接。
+
+## 业务规则
+
+- 统计窗口固定为每 30 分钟一个窗口。
+- 每个窗口统计两类人数：
+  - `over_threshold_count`：该窗口内累计排队时间大于等于 5 分钟的人数。
+  - `under_threshold_count`：该窗口内累计排队时间小于 5 分钟但大于 0 的人数。
+- 一阶段排队等级规则：
+  - `crowded`：`over_threshold_count > 5`
+  - `normal`：`2 <= over_threshold_count <= 5`
+  - `few`：`over_threshold_count < 2`
+- 状态变化规则：
+  - `queue_increased`：`normal -> crowded` 或 `few -> crowded`
+  - `queue_decreased`：`normal -> few` 或 `crowded -> few`
+  - `queue_normalized`：`crowded -> normal` 或 `few -> normal`
+  - `unchanged`：窗口等级未变化
+  - `initial`：首个统计窗口，没有上一个窗口可比较
+
+## 配置方式
+
+### store_dwell_alert
+
+配置文件示例：`managed/store_dwell_alert/config/config.example.yaml`
+
+```yaml
+thresholds:
+  queue_time_threshold_seconds: 300
+  crowded_count_threshold: 5
+  normal_count_threshold: 2
+  pause_timeout_seconds: 300
+  alert_cooldown_seconds: 600
+
+webhook:
+  url: "https://receiver.example.com/queue-report"
+  timeout_seconds: 5.0
+```
+
+### people_flow_project
+
+配置文件示例：`managed/people_flow_project/config/config.example.yaml`
+
+```yaml
+queue:
+  enabled: true
+  area: [0.0, 0.0, 1.0, 1.0]
+  area_mode: "normalized"
+  queue_time_threshold_seconds: 300
+  crowded_count_threshold: 5
+  normal_count_threshold: 2
+  pause_timeout_seconds: 5
+  source_id: "queue_cam_01"
+
+webhook:
+  url: "https://receiver.example.com/queue-report"
+  timeout_seconds: 5.0
+  event_log_path: "outputs/rtsp_stream/webhook_events.jsonl"
+```
+
+说明：
+
+- `queue.area` 用于限定排队区域，默认 `[0, 0, 1, 1]` 表示全画面。
+- `queue.area_mode=normalized` 表示区域坐标按画面宽高归一化。
+- 两个工程都会先把 webhook 数据写入本地结果文件，再尝试 HTTP POST。
+
+## 推送时机
+
+- 两个工程都会在每个 30 分钟窗口结束时推送一次 `half_hour_report`。
+- `store_dwell_alert` 仍会继续生成本地事件日志；用于对接的窗口报文以本文档的 `half_hour_report` 结构为准。
+
+## 公共字段
+
+两个工程的 webhook 都包含以下公共字段：
+
+| 字段            | 类型   | 说明                                                                                           |
+| --------------- | ------ | ---------------------------------------------------------------------------------------------- |
+| `event`         | string | 固定为 `half_hour_report`                                                                      |
+| `project_type`  | string | 工程类型，值为 `store_dwell_alert` 或 `people_flow_project`                                    |
+| `source_id`     | string | 数据源标识。`store_dwell_alert` 使用 `camera_id`，`people_flow_project` 使用 `queue.source_id` |
+| `window_start`  | string | 窗口开始时间，ISO 8601                                                                         |
+| `window_end`    | string | 窗口结束时间，ISO 8601                                                                         |
+| `queue_metrics` | object | 排队统计主体                                                                                   |
+
+`queue_metrics` 结构：
+
+| 字段                           | 类型        | 说明                                                                                 |
+| ------------------------------ | ----------- | ------------------------------------------------------------------------------------ |
+| `queue_time_threshold_seconds` | integer     | 长等待阈值，当前默认 300 秒                                                          |
+| `over_threshold_count`         | integer     | 窗口内累计排队时间大于等于阈值的人数                                                 |
+| `under_threshold_count`        | integer     | 窗口内累计排队时间小于阈值但大于 0 的人数                                            |
+| `queue_level`                  | string      | `few` / `normal` / `crowded`                                                         |
+| `previous_queue_level`         | string/null | 上一个窗口的等级                                                                     |
+| `status_change`                | string      | `initial` / `unchanged` / `queue_increased` / `queue_decreased` / `queue_normalized` |
+| `people`                       | array       | 当前窗口内参与统计的人员列表                                                         |
+
+`queue_metrics.people[]` 结构：
+
+| 字段            | 类型    | 说明                                  |
+| --------------- | ------- | ------------------------------------- |
+| `person_id`     | string  | 人员标识                              |
+| `queue_seconds` | integer | 该窗口内累计排队秒数                  |
+| `bucket`        | string  | `over_threshold` 或 `under_threshold` |
+
+## store_dwell_alert 完整报文
+
+`store_dwell_alert` 会额外带上门店停留会话明细：
+
+```json
+{
+  "event": "half_hour_report",
+  "project_type": "store_dwell_alert",
+  "camera_id": "store_cam_01",
+  "source_id": "store_cam_01",
+  "window_start": "2026-05-08T09:00:00+08:00",
+  "window_end": "2026-05-08T09:30:00+08:00",
+  "active_customer_count": 3,
+  "active_customers": [
+    {
+      "person_id": "cust_101",
+      "session_id": "cust_101-s1",
+      "role": "customer",
+      "status": "active",
+      "dwell_seconds": 820,
+      "window_queue_seconds": 820
+    },
+    {
+      "person_id": "cust_102",
+      "session_id": "cust_102-s1",
+      "role": "customer",
+      "status": "active",
+      "dwell_seconds": 460,
+      "window_queue_seconds": 460
+    }
+  ],
+  "closed_customers": [
+    {
+      "person_id": "cust_103",
+      "session_id": "cust_103-s1",
+      "final_dwell_seconds": 260,
+      "window_queue_seconds": 260
+    }
+  ],
+  "staff_seen_count": 1,
+  "queue_metrics": {
+    "queue_time_threshold_seconds": 300,
+    "over_threshold_count": 6,
+    "under_threshold_count": 2,
+    "queue_level": "crowded",
+    "previous_queue_level": "normal",
+    "status_change": "queue_increased",
+    "people": [
+      {
+        "person_id": "cust_101",
+        "queue_seconds": 820,
+        "bucket": "over_threshold"
+      },
+      {
+        "person_id": "cust_102",
+        "queue_seconds": 460,
+        "bucket": "over_threshold"
+      },
+      {
+        "person_id": "cust_103",
+        "queue_seconds": 260,
+        "bucket": "under_threshold"
+      }
+    ]
+  }
+}
+```
+
+## people_flow_project 完整报文
+
+`people_flow_project` 会额外带上过线统计和属性统计结果：
+
+```json
+{
+  "event": "half_hour_report",
+  "project_type": "people_flow_project",
+  "source_type": "rtsp",
+  "source": "rtsp://user:password@camera-ip:554/h264/ch1/main/av_stream",
+  "source_id": "queue_cam_01",
+  "window_index": 12,
+  "window_start": "2026-05-08T09:00:00+08:00",
+  "window_end": "2026-05-08T09:30:00+08:00",
+  "window_duration_seconds": 1800,
+  "config_path": "/opt/people_flow_project/config/local.yaml",
+  "line": {
+    "coordinates": [0.1, 0.55, 0.9, 0.55],
+    "mode": "normalized"
+  },
+  "total_people": 7,
+  "age_counts": {
+    "minor": 1,
+    "adult": 5,
+    "senior": 1
+  },
+  "gender_counts": {
+    "male": 4,
+    "female": 3
+  },
+  "unknown_attributes": 2,
+  "tracks": [
+    {
+      "track_id": 1,
+      "direction": "in",
+      "age": 26,
+      "age_bucket": "adult",
+      "gender": "male",
+      "samples_used": 3
+    }
+  ],
+  "queue_metrics": {
+    "queue_time_threshold_seconds": 300,
+    "over_threshold_count": 6,
+    "under_threshold_count": 2,
+    "queue_level": "crowded",
+    "previous_queue_level": "normal",
+    "status_change": "queue_increased",
+    "people": [
+      {
+        "person_id": "track_12",
+        "queue_seconds": 810,
+        "bucket": "over_threshold"
+      },
+      {
+        "person_id": "track_21",
+        "queue_seconds": 180,
+        "bucket": "under_threshold"
+      }
+    ]
+  }
+}
+```
+
+## 接收方建议
+
+- 按 `event + project_type + source_id + window_end` 做幂等去重。
+- 业务判断优先读取 `queue_metrics.queue_level` 和 `queue_metrics.status_change`。
+- 如果只关心图片里的需求，最少只需要解析：
+  - `source_id`
+  - `window_start`
+  - `window_end`
+  - `queue_metrics.over_threshold_count`
+  - `queue_metrics.under_threshold_count`
+  - `queue_metrics.queue_level`
+  - `queue_metrics.status_change`
--- a/managed/people_flow_project/config/config.example.yaml
+++ b/managed/people_flow_project/config/config.example.yaml
@@ -39,3 +39,18 @@ rtsp:
  stream_open_timeout_seconds: 10.0
  idle_sleep_seconds: 0.05
  output_subdir: "rtsp_stream"
+
+queue:
+  enabled: true
+  area: [0.0, 0.0, 1.0, 1.0]
+  area_mode: "normalized"
+  queue_time_threshold_seconds: 300
+  crowded_count_threshold: 5
+  normal_count_threshold: 2
+  pause_timeout_seconds: 5
+  source_id: "people_flow_queue"
+
+webhook:
+  url: ""
+  timeout_seconds: 5.0
+  event_log_path: "outputs/rtsp_stream/webhook_events.jsonl"
--- a/managed/people_flow_project/configs/default_config.yaml
+++ b/managed/people_flow_project/configs/default_config.yaml
@@ -35,3 +35,18 @@ rtsp:
  stream_open_timeout_seconds: 10.0
  idle_sleep_seconds: 0.05
  output_subdir: "rtsp_stream"
+
+queue:
+  enabled: true
+  area: [0.0, 0.0, 1.0, 1.0]
+  area_mode: "normalized"
+  queue_time_threshold_seconds: 300
+  crowded_count_threshold: 5
+  normal_count_threshold: 2
+  pause_timeout_seconds: 5
+  source_id: "people_flow_queue"
+
+webhook:
+  url: ""
+  timeout_seconds: 5.0
+  event_log_path: "outputs/rtsp_stream/webhook_events.jsonl"
--- a/managed/people_flow_project/scripts/docker-entrypoint.sh
+++ b/managed/people_flow_project/scripts/docker-entrypoint.sh
@@ -37,4 +37,67 @@ config_path.write_text(
 )
 PY

-exec python main.py --config "${CONFIG_PATH}" manage-api --host "${API_HOST}" --port "${API_PORT}"
+exec python - "$CONFIG_PATH" "$API_HOST" "$API_PORT" <<'PY'
+import signal
+import subprocess
+import sys
+import time
+
+config_path, api_host, api_port = sys.argv[1:4]
+commands = [
+  [sys.executable, "main.py", "--config", config_path, "rtsp"],
+  [
+    sys.executable,
+    "main.py",
+    "--config",
+    config_path,
+    "manage-api",
+    "--host",
+    api_host,
+    "--port",
+    api_port,
+  ],
+]
+processes = [subprocess.Popen(command) for command in commands]
+
+
+def terminate_all(signum, _frame):
+  for process in processes:
+    if process.poll() is None:
+      process.terminate()
+  deadline = time.time() + 10
+  for process in processes:
+    if process.poll() is not None:
+      continue
+    timeout = max(0, deadline - time.time())
+    try:
+      process.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+      process.kill()
+  raise SystemExit(128 + signum)
+
+
+for handled_signal in (signal.SIGINT, signal.SIGTERM):
+  signal.signal(handled_signal, terminate_all)
+
+while True:
+  for index, process in enumerate(processes):
+    return_code = process.poll()
+    if return_code is None:
+      continue
+    for other_index, other_process in enumerate(processes):
+      if other_index == index or other_process.poll() is not None:
+        continue
+      other_process.terminate()
+    deadline = time.time() + 10
+    for other_index, other_process in enumerate(processes):
+      if other_index == index or other_process.poll() is not None:
+        continue
+      timeout = max(0, deadline - time.time())
+      try:
+        other_process.wait(timeout=timeout)
+      except subprocess.TimeoutExpired:
+        other_process.kill()
+    raise SystemExit(return_code)
+  time.sleep(0.5)
+PY
--- a/managed/people_flow_project/src/people_flow/config.py
+++ b/managed/people_flow_project/src/people_flow/config.py
@@ -10,8 +10,10 @@ from .models import (
    AttributeConfig,
    CountingConfig,
    OutputConfig,
+    QueueConfig,
    RtspConfig,
    RuntimeConfig,
+    WebhookConfig,
    YoloConfig,
 )

@@ -59,6 +61,8 @@ def load_config(config_path: Path) -> AppConfig:
        attributes=AttributeConfig(**data.get("attributes", {})),
        output=OutputConfig(**data.get("output", {})),
        rtsp=RtspConfig(**data.get("rtsp", {})),
+        queue=QueueConfig(**_normalize_queue_config(data.get("queue", {}))),
+        webhook=WebhookConfig(**data.get("webhook", {})),
        runtime=RuntimeConfig(**data.get("runtime", {})),
        config_path=config_path.resolve(),
    )
@@ -73,6 +77,14 @@ def _normalize_counting_config(data: dict) -> dict:
    return normalized


+def _normalize_queue_config(data: dict) -> dict:
+    normalized = dict(data)
+    area = normalized.get("area")
+    if area is not None:
+        normalized["area"] = tuple(float(value) for value in area)
+    return normalized
+
+
 def parse_line_override(raw_line: str) -> tuple[float, float, float, float]:
    parts = [part.strip() for part in raw_line.split(",")]
    if len(parts) != 4:
--- a/managed/people_flow_project/src/people_flow/manage_api.py
+++ b/managed/people_flow_project/src/people_flow/manage_api.py
@@ -16,7 +16,6 @@ from .config import (
    save_config_document,
 )

-
 PROJECT_TYPE = "people_flow_project"
 DEFAULT_MANAGE_PORT = 18082
 MAX_PREVIEW_LINES = 2000
@@ -135,7 +134,12 @@ def parse_args() -> ArgumentParser:
    parser = ArgumentParser(description="People flow management API")
    parser.add_argument("--config", required=True, help="Path to YAML config file")
    parser.add_argument("--host", default="0.0.0.0", help="Host for the management API")
-    parser.add_argument("--port", type=int, default=DEFAULT_MANAGE_PORT, help="Port for the management API")
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=DEFAULT_MANAGE_PORT,
+        help="Port for the management API",
+    )
    return parser


@@ -160,6 +164,19 @@ def _config_payload(ctx: ManageContext) -> dict:
            "output_subdir": config.rtsp.output_subdir,
            "window_seconds": config.rtsp.window_seconds,
        },
+        "queue": {
+            "source_id": config.queue.source_id,
+            "queue_time_threshold_seconds": config.queue.queue_time_threshold_seconds,
+            "crowded_count_threshold": config.queue.crowded_count_threshold,
+            "normal_count_threshold": config.queue.normal_count_threshold,
+        },
+        "webhook": {
+            "url": config.webhook.url,
+            "event_log_path": str(
+                resolve_project_path(ctx.project_root, config.webhook.event_log_path)
+            ),
+            "timeout_seconds": config.webhook.timeout_seconds,
+        },
    }


@@ -191,15 +208,33 @@ def _build_summary(ctx: ManageContext) -> dict:

    total_people = _int_value(payload.get("total_people"))
    window_end = _string_value(payload.get("window_end"))
+    queue_metrics = (
+        payload.get("queue_metrics")
+        if isinstance(payload.get("queue_metrics"), dict)
+        else {}
+    )
    return {
        "result_type": PROJECT_TYPE,
-        "headline": f"Latest window counted {total_people} people",
+        "headline": (
+            "Latest report shows "
+            f"{_string_value(queue_metrics.get('queue_level')) or 'few'} queue, "
+            f"{_int_value(queue_metrics.get('over_threshold_count'))} over 5 min and "
+            f"{_int_value(queue_metrics.get('under_threshold_count'))} under 5 min"
+        ),
        "last_result_time": window_end,
        "metrics": {
            "summary_path": str(summary_path) if summary_path else "",
            "window_start": _string_value(payload.get("window_start")),
            "window_end": window_end,
            "total_people": total_people,
+            "queue_level": _string_value(queue_metrics.get("queue_level")),
+            "over_threshold_count": _int_value(
+                queue_metrics.get("over_threshold_count")
+            ),
+            "under_threshold_count": _int_value(
+                queue_metrics.get("under_threshold_count")
+            ),
+            "status_change": _string_value(queue_metrics.get("status_change")),
            "direction_counts": direction_counts,
            "age_counts": _map_string_int(payload.get("age_counts")),
            "gender_counts": _map_string_int(payload.get("gender_counts")),
@@ -246,6 +281,14 @@ def _load_window_stats(ctx: ManageContext) -> list[dict]:
                "window_start": _string_value(payload.get("window_start")),
                "window_end": _string_value(payload.get("window_end")),
                "total_people": _int_value(payload.get("total_people")),
+                "queue_level": _queue_metric_value(payload, "queue_level"),
+                "over_threshold_count": _queue_metric_int(
+                    payload, "over_threshold_count"
+                ),
+                "under_threshold_count": _queue_metric_int(
+                    payload, "under_threshold_count"
+                ),
+                "status_change": _queue_metric_value(payload, "status_change"),
                "age_counts": _map_string_int(payload.get("age_counts")),
                "gender_counts": _map_string_int(payload.get("gender_counts")),
                "unknown_attributes": _int_value(payload.get("unknown_attributes")),
@@ -259,6 +302,7 @@ def _list_result_files(ctx: ManageContext) -> list[dict]:
    files: list[dict] = []
    for path, label in (
        (_latest_json_path(ctx), "Latest Summary"),
+        (_webhook_log_path(ctx), "Webhook Event Log"),
        (_runtime_log_path(ctx), "Runtime Log"),
    ):
        if path.exists() and path.is_file():
@@ -305,6 +349,11 @@ def _runtime_log_path(ctx: ManageContext) -> Path:
    return _output_root(ctx) / "rtsp_run.log"


+def _webhook_log_path(ctx: ManageContext) -> Path:
+    config = load_config(ctx.config_path)
+    return resolve_project_path(ctx.project_root, config.webhook.event_log_path)
+
+
 def _window_files(ctx: ManageContext) -> list[Path]:
    windows_dir = _windows_dir(ctx)
    if not windows_dir.exists():
@@ -385,5 +434,19 @@ def _map_string_int(value) -> dict[str, int]:
    return {str(key): _int_value(raw) for key, raw in value.items()}


+def _queue_metric_value(payload: dict, field: str) -> str:
+    queue_metrics = payload.get("queue_metrics")
+    if not isinstance(queue_metrics, dict):
+        return ""
+    return _string_value(queue_metrics.get(field))
+
+
+def _queue_metric_int(payload: dict, field: str) -> int:
+    queue_metrics = payload.get("queue_metrics")
+    if not isinstance(queue_metrics, dict):
+        return 0
+    return _int_value(queue_metrics.get(field))
+
+
 if __name__ == "__main__":
    raise SystemExit(main())
--- a/managed/people_flow_project/src/people_flow/models.py
+++ b/managed/people_flow_project/src/people_flow/models.py
@@ -20,7 +20,9 @@ class CountingConfig:
    line_mode: str = "normalized"
    crossing_tolerance: float = 12.0

-    def to_pixel_line(self, width: int, height: int) -> tuple[float, float, float, float]:
+    def to_pixel_line(
+        self, width: int, height: int
+    ) -> tuple[float, float, float, float]:
        x1, y1, x2, y2 = self.line
        if self.line_mode == "pixel":
            return x1, y1, x2, y2
@@ -58,6 +60,33 @@ class RtspConfig:
    output_subdir: str = "rtsp_stream"


+@dataclass
+class QueueConfig:
+    enabled: bool = True
+    area: tuple[float, float, float, float] = (0.0, 0.0, 1.0, 1.0)
+    area_mode: str = "normalized"
+    queue_time_threshold_seconds: int = 300
+    crowded_count_threshold: int = 5
+    normal_count_threshold: int = 2
+    pause_timeout_seconds: int = 5
+    source_id: str = "people_flow_queue"
+
+    def to_pixel_area(
+        self, width: int, height: int
+    ) -> tuple[float, float, float, float]:
+        x1, y1, x2, y2 = self.area
+        if self.area_mode == "pixel":
+            return x1, y1, x2, y2
+        return x1 * width, y1 * height, x2 * width, y2 * height
+
+
+@dataclass
+class WebhookConfig:
+    url: str = ""
+    timeout_seconds: float = 5.0
+    event_log_path: str = "outputs/rtsp_stream/webhook_events.jsonl"
+
+
@dataclass
 class RuntimeConfig:
    rtsp_url: str = "rtsp://user:password@camera-ip:554/h264/ch1/main/av_stream"
@@ -71,6 +100,8 @@ class AppConfig:
    attributes: AttributeConfig = field(default_factory=AttributeConfig)
    output: OutputConfig = field(default_factory=OutputConfig)
    rtsp: RtspConfig = field(default_factory=RtspConfig)
+    queue: QueueConfig = field(default_factory=QueueConfig)
+    webhook: WebhookConfig = field(default_factory=WebhookConfig)
    runtime: RuntimeConfig = field(default_factory=RuntimeConfig)
    config_path: Path | None = None

--- a/managed/people_flow_project/src/people_flow/pipeline.py
+++ b/managed/people_flow_project/src/people_flow/pipeline.py
@@ -20,8 +20,9 @@ from .io_utils import (
    write_window_json,
 )
 from .models import AppConfig
+from .queue_analytics import QueueWindowTracker
 from .tracking import extract_person_tracks
-
+from .webhook import dispatch_json_event

 SUPPORTED_EXTENSIONS = {".mp4", ".mov", ".mkv", ".avi"}

@@ -104,7 +105,9 @@ class PeopleFlowPipeline:

        writer = None
        if self.config.output.save_video:
-            writer = make_video_writer(video_output_path, width=width, height=height, fps=fps)
+            writer = make_video_writer(
+                video_output_path, width=width, height=height, fps=fps
+            )

        counter = LineCrossCounter(pixel_line, self.config.counting)
        attributes = AttributeAggregator(self.config.attributes)
@@ -118,7 +121,9 @@ class PeopleFlowPipeline:
            observations = self._track_frame(frame)

            for observation in observations:
-                attributes.maybe_collect(frame=frame, frame_index=frame_index, track=observation)
+                attributes.maybe_collect(
+                    frame=frame, frame_index=frame_index, track=observation
+                )

            counter.update(observations)

@@ -154,7 +159,9 @@ class PeopleFlowPipeline:
        sample_interval = max(float(self.config.rtsp.sample_interval_seconds), 0.01)
        window_seconds = max(int(self.config.rtsp.window_seconds), 1)
        reconnect_delay = max(float(self.config.rtsp.reconnect_delay_seconds), 0.1)
-        open_timeout_seconds = max(float(self.config.rtsp.stream_open_timeout_seconds), 1.0)
+        open_timeout_seconds = max(
+            float(self.config.rtsp.stream_open_timeout_seconds), 1.0
+        )
        idle_sleep = max(float(self.config.rtsp.idle_sleep_seconds), 0.0)

        window_index = 0
@@ -168,7 +175,18 @@ class PeopleFlowPipeline:
        capture = None
        pixel_line = None
        counter = None
+        queue_tracker = None
        attributes = AttributeAggregator(self.config.attributes)
+        project_root = (
+            self.config.config_path.parent.parent
+            if self.config.config_path is not None
+            else self.output_root
+        )
+        webhook_event_log_path = (
+            project_root / self.config.webhook.event_log_path
+            if not Path(self.config.webhook.event_log_path).is_absolute()
+            else Path(self.config.webhook.event_log_path)
+        )

        try:
            while True:
@@ -181,6 +199,7 @@ class PeopleFlowPipeline:
                        window_end=window_end,
                        counter=counter,
                        attributes=attributes,
+                        queue_tracker=queue_tracker,
                    )
                    json_path = write_window_json(
                        rtsp_paths["windows"],
@@ -188,6 +207,12 @@ class PeopleFlowPipeline:
                        payload,
                        window_end,
                    )
+                    dispatch_json_event(
+                        webhook_event_log_path,
+                        payload,
+                        webhook_url=self.config.webhook.url,
+                        timeout_seconds=self.config.webhook.timeout_seconds,
+                    )
                    print(f"window_json={json_path}", flush=True)
                    print(f"window_total_people={payload['total_people']}", flush=True)
                    window_index += 1
@@ -195,6 +220,8 @@ class PeopleFlowPipeline:
                    window_end = window_start + timedelta(seconds=window_seconds)
                    if counter is not None:
                        counter.reset()
+                    if queue_tracker is not None:
+                        queue_tracker.reset()
                    attributes.reset()
                    now = datetime.now().astimezone()

@@ -213,8 +240,14 @@ class PeopleFlowPipeline:

                if pixel_line is None:
                    height, width = frame.shape[:2]
-                    pixel_line = self.config.counting.to_pixel_line(width=width, height=height)
+                    pixel_line = self.config.counting.to_pixel_line(
+                        width=width, height=height
+                    )
                    counter = LineCrossCounter(pixel_line, self.config.counting)
+                    queue_tracker = QueueWindowTracker(
+                        self.config.queue,
+                        self.config.queue.to_pixel_area(width=width, height=height),
+                    )

                current_time = time.monotonic()
                if current_time - last_processed_at < sample_interval:
@@ -225,9 +258,13 @@ class PeopleFlowPipeline:
                last_processed_at = current_time
                observations = self._track_frame(frame)
                for observation in observations:
-                    attributes.maybe_collect(frame=frame, frame_index=frame_index, track=observation)
+                    attributes.maybe_collect(
+                        frame=frame, frame_index=frame_index, track=observation
+                    )
                if counter is not None:
                    counter.update(observations)
+                if queue_tracker is not None and self.config.queue.enabled:
+                    queue_tracker.observe(observations, now)
                    if current_time >= next_heartbeat_at:
                        self._print_rtsp_heartbeat(
                            process_started_at=process_started_at,
@@ -283,7 +320,9 @@ class PeopleFlowPipeline:
        capture.release()
        return None

-    def _build_live_stats(self, counter: LineCrossCounter, attributes: AttributeAggregator) -> dict:
+    def _build_live_stats(
+        self, counter: LineCrossCounter, attributes: AttributeAggregator
+    ) -> dict:
        age_counts = {"minor": 0, "adult": 0, "senior": 0}
        gender_counts = {"male": 0, "female": 0}
        unknown_attributes = 0
@@ -313,7 +352,9 @@ class PeopleFlowPipeline:
        last_processed_wall_time: datetime | None,
    ) -> None:
        stats = self._build_live_stats(counter, attributes)
-        runtime_seconds = int((datetime.now().astimezone() - process_started_at).total_seconds())
+        runtime_seconds = int(
+            (datetime.now().astimezone() - process_started_at).total_seconds()
+        )
        last_processed = (
            last_processed_wall_time.isoformat(timespec="seconds")
            if last_processed_wall_time is not None
@@ -387,20 +428,41 @@ class PeopleFlowPipeline:
        window_end: datetime,
        counter: LineCrossCounter | None,
        attributes: AttributeAggregator,
+        queue_tracker: QueueWindowTracker | None,
    ) -> dict:
-        age_counts, gender_counts, unknown_attributes, track_summaries = self._collect_track_summaries(
+        age_counts, gender_counts, unknown_attributes, track_summaries = (
+            self._collect_track_summaries(
                counter,
                attributes,
            )
+        )
        total_people = 0 if counter is None else counter.total_people
+        queue_metrics = (
+            queue_tracker.build_queue_metrics(window_start, window_end)
+            if queue_tracker is not None and self.config.queue.enabled
+            else {
+                "queue_time_threshold_seconds": self.config.queue.queue_time_threshold_seconds,
+                "over_threshold_count": 0,
+                "under_threshold_count": 0,
+                "queue_level": "few",
+                "previous_queue_level": None,
+                "status_change": "initial",
+                "people": [],
+            }
+        )
        return {
+            "event": "half_hour_report",
+            "project_type": "people_flow_project",
            "source_type": "rtsp",
            "source": source,
+            "source_id": self.config.queue.source_id,
            "window_index": window_index,
            "window_start": window_start.isoformat(),
            "window_end": window_end.isoformat(),
            "window_duration_seconds": int((window_end - window_start).total_seconds()),
-            "config_path": str(self.config.config_path) if self.config.config_path else None,
+            "config_path": (
+                str(self.config.config_path) if self.config.config_path else None
+            ),
            "line": {
                "coordinates": list(self.config.counting.line),
                "mode": self.config.counting.line_mode,
@@ -410,6 +472,7 @@ class PeopleFlowPipeline:
            "gender_counts": gender_counts,
            "unknown_attributes": unknown_attributes,
            "tracks": track_summaries,
+            "queue_metrics": queue_metrics,
        }

    def _finalize_summary(
@@ -419,15 +482,19 @@ class PeopleFlowPipeline:
        attributes: AttributeAggregator,
        json_path: Path,
    ) -> dict:
-        age_counts, gender_counts, unknown_attributes, track_summaries = self._collect_track_summaries(
+        age_counts, gender_counts, unknown_attributes, track_summaries = (
+            self._collect_track_summaries(
                counter,
                attributes,
            )
+        )

        payload = {
            "video_name": video_path.name,
            "video_path": str(video_path),
-            "config_path": str(self.config.config_path) if self.config.config_path else None,
+            "config_path": (
+                str(self.config.config_path) if self.config.config_path else None
+            ),
            "line": {
                "coordinates": list(self.config.counting.line),
                "mode": self.config.counting.line_mode,
--- a/managed/people_flow_project/src/people_flow/queue_analytics.py
+++ b/managed/people_flow_project/src/people_flow/queue_analytics.py
@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from .models import QueueConfig, TrackObservation
+
+
+@dataclass
+class QueueTrackState:
+    track_id: int
+    entered_at: datetime
+    accumulated_queue_seconds: int = 0
+    active_started_at: datetime | None = None
+    last_seen_at: datetime | None = None
+    pause_started_at: datetime | None = None
+    completed_periods: list[tuple[datetime, datetime]] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if self.active_started_at is None:
+            self.active_started_at = self.entered_at
+        if self.last_seen_at is None:
+            self.last_seen_at = self.entered_at
+
+    def mark_seen(self, when: datetime) -> None:
+        if self.active_started_at is None:
+            self.active_started_at = when
+        self.last_seen_at = when
+        self.pause_started_at = None
+
+    def pause(self, when: datetime) -> None:
+        if self.active_started_at is None:
+            return
+        self.completed_periods.append((self.active_started_at, when))
+        self.accumulated_queue_seconds += max(
+            0,
+            int((when - self.active_started_at).total_seconds()),
+        )
+        self.active_started_at = None
+        self.pause_started_at = when
+        self.last_seen_at = when
+
+    def expire(self, when: datetime, pause_timeout_seconds: int) -> bool:
+        if self.pause_started_at is None:
+            return False
+        return (
+            int((when - self.pause_started_at).total_seconds()) > pause_timeout_seconds
+        )
+
+    def window_queue_seconds(self, window_start: datetime, window_end: datetime) -> int:
+        total = 0
+        for period_start, period_end in self.completed_periods:
+            total += _overlap_seconds(
+                period_start, period_end, window_start, window_end
+            )
+        if self.active_started_at is not None:
+            current_end = self.last_seen_at or window_end
+            total += _overlap_seconds(
+                self.active_started_at, current_end, window_start, window_end
+            )
+        return total
+
+
+class QueueWindowTracker:
+    def __init__(
+        self, config: QueueConfig, pixel_area: tuple[float, float, float, float]
+    ) -> None:
+        self.config = config
+        self.pixel_area = pixel_area
+        self.states: dict[int, QueueTrackState] = {}
+        self.closed_states: list[QueueTrackState] = []
+        self.last_queue_level: str | None = None
+
+    def observe(self, observations: list[TrackObservation], when: datetime) -> None:
+        seen_ids: set[int] = set()
+        for observation in observations:
+            if not _point_in_area(observation.center, self.pixel_area):
+                continue
+            seen_ids.add(observation.track_id)
+            state = self.states.get(observation.track_id)
+            if state is None:
+                state = QueueTrackState(track_id=observation.track_id, entered_at=when)
+                self.states[observation.track_id] = state
+            state.mark_seen(when)
+
+        for track_id, state in list(self.states.items()):
+            if track_id in seen_ids:
+                continue
+            if state.active_started_at is not None:
+                state.pause(when)
+            if state.expire(when, self.config.pause_timeout_seconds):
+                self.closed_states.append(state)
+                del self.states[track_id]
+
+    def build_queue_metrics(self, window_start: datetime, window_end: datetime) -> dict:
+        totals: dict[int, int] = {}
+        for state in self.closed_states:
+            queue_seconds = state.window_queue_seconds(window_start, window_end)
+            if queue_seconds > 0:
+                totals[state.track_id] = totals.get(state.track_id, 0) + queue_seconds
+        for track_id, state in self.states.items():
+            queue_seconds = state.window_queue_seconds(window_start, window_end)
+            if queue_seconds > 0:
+                totals[track_id] = queue_seconds
+
+        over_threshold_count = sum(
+            1
+            for queue_seconds in totals.values()
+            if queue_seconds >= self.config.queue_time_threshold_seconds
+        )
+        under_threshold_count = sum(
+            1
+            for queue_seconds in totals.values()
+            if 0 < queue_seconds < self.config.queue_time_threshold_seconds
+        )
+        queue_level = _queue_level(
+            over_threshold_count,
+            crowded_count_threshold=self.config.crowded_count_threshold,
+            normal_count_threshold=self.config.normal_count_threshold,
+        )
+        previous_queue_level = self.last_queue_level
+        status_change = _queue_status_change(previous_queue_level, queue_level)
+        self.last_queue_level = queue_level
+        return {
+            "queue_time_threshold_seconds": self.config.queue_time_threshold_seconds,
+            "over_threshold_count": over_threshold_count,
+            "under_threshold_count": under_threshold_count,
+            "queue_level": queue_level,
+            "previous_queue_level": previous_queue_level,
+            "status_change": status_change,
+            "people": [
+                {
+                    "person_id": f"track_{track_id}",
+                    "queue_seconds": queue_seconds,
+                    "bucket": (
+                        "over_threshold"
+                        if queue_seconds >= self.config.queue_time_threshold_seconds
+                        else "under_threshold"
+                    ),
+                }
+                for track_id, queue_seconds in sorted(
+                    totals.items(), key=lambda item: item[1], reverse=True
+                )
+            ],
+        }
+
+    def reset(self) -> None:
+        self.states.clear()
+        self.closed_states.clear()
+
+
+def _point_in_area(
+    point: tuple[float, float],
+    area: tuple[float, float, float, float],
+) -> bool:
+    px, py = point
+    x1, y1, x2, y2 = area
+    left = min(x1, x2)
+    right = max(x1, x2)
+    top = min(y1, y2)
+    bottom = max(y1, y2)
+    return left <= px <= right and top <= py <= bottom
+
+
+def _overlap_seconds(
+    period_start: datetime,
+    period_end: datetime,
+    window_start: datetime,
+    window_end: datetime,
+) -> int:
+    overlap_start = max(period_start, window_start)
+    overlap_end = min(period_end, window_end)
+    if overlap_end <= overlap_start:
+        return 0
+    return int((overlap_end - overlap_start).total_seconds())
+
+
+def _queue_level(
+    over_threshold_count: int,
+    crowded_count_threshold: int,
+    normal_count_threshold: int,
+) -> str:
+    if over_threshold_count > crowded_count_threshold:
+        return "crowded"
+    if over_threshold_count >= normal_count_threshold:
+        return "normal"
+    return "few"
+
+
+def _queue_status_change(previous_level: str | None, current_level: str) -> str:
+    if previous_level is None:
+        return "initial"
+    if previous_level == current_level:
+        return "unchanged"
+    if current_level == "crowded" and previous_level in {"normal", "few"}:
+        return "queue_increased"
+    if current_level == "few" and previous_level in {"normal", "crowded"}:
+        return "queue_decreased"
+    if current_level == "normal" and previous_level in {"crowded", "few"}:
+        return "queue_normalized"
+    return "changed"
--- a/managed/people_flow_project/src/people_flow/webhook.py
+++ b/managed/people_flow_project/src/people_flow/webhook.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from urllib import request
+
+
+def dispatch_json_event(
+    path: str | Path,
+    payload: dict,
+    webhook_url: str = "",
+    timeout_seconds: float = 5.0,
+) -> None:
+    output_path = Path(path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with output_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+    if not webhook_url.strip():
+        return
+
+    req = request.Request(
+        url=webhook_url,
+        data=json.dumps(payload).encode("utf-8"),
+        method="POST",
+    )
+    req.add_header("Content-Type", "application/json")
+    with request.urlopen(req, timeout=timeout_seconds):
+        return
--- a/managed/people_flow_project/tests/test_manage_api.py
+++ b/managed/people_flow_project/tests/test_manage_api.py
@@ -16,7 +16,15 @@ def build_client(project_root: Path):
        "  rtsp_url: rtsp://before-update\n"
        "  output_dir: outputs\n"
        "rtsp:\n"
-        "  output_subdir: rtsp_stream\n",
+        "  output_subdir: rtsp_stream\n"
+        "queue:\n"
+        "  source_id: queue_cam_01\n"
+        "  queue_time_threshold_seconds: 300\n"
+        "  crowded_count_threshold: 5\n"
+        "  normal_count_threshold: 2\n"
+        "webhook:\n"
+        "  url: https://example.test/webhook\n"
+        "  event_log_path: outputs/rtsp_stream/webhook_events.jsonl\n",
        encoding="utf-8",
    )

@@ -24,13 +32,23 @@ def build_client(project_root: Path):
    windows_dir = rtsp_dir / "windows"
    windows_dir.mkdir(parents=True, exist_ok=True)
    latest_payload = {
+        "event": "half_hour_report",
        "source_type": "rtsp",
+        "source_id": "queue_cam_01",
        "window_start": "2026-04-16T09:30:00+08:00",
        "window_end": "2026-04-16T10:00:00+08:00",
        "total_people": 7,
        "age_counts": {"minor": 1, "adult": 5, "senior": 1},
        "gender_counts": {"male": 4, "female": 3},
        "unknown_attributes": 2,
+        "queue_metrics": {
+            "queue_time_threshold_seconds": 300,
+            "over_threshold_count": 6,
+            "under_threshold_count": 2,
+            "queue_level": "crowded",
+            "previous_queue_level": "normal",
+            "status_change": "queue_increased",
+        },
        "tracks": [
            {"track_id": 1, "direction": "in"},
            {"track_id": 2, "direction": "out"},
@@ -47,6 +65,14 @@ def build_client(project_root: Path):
                "window_start": "2026-04-16T09:00:00+08:00",
                "window_end": "2026-04-16T09:30:00+08:00",
                "total_people": 5,
+                "queue_metrics": {
+                    "queue_time_threshold_seconds": 300,
+                    "over_threshold_count": 2,
+                    "under_threshold_count": 1,
+                    "queue_level": "normal",
+                    "previous_queue_level": None,
+                    "status_change": "initial",
+                },
                "age_counts": {"minor": 0, "adult": 4, "senior": 1},
                "gender_counts": {"male": 2, "female": 3},
                "unknown_attributes": 1,
@@ -58,7 +84,12 @@ def build_client(project_root: Path):
        json.dumps(latest_payload),
        encoding="utf-8",
    )
-    (project_root / "outputs" / "rtsp_run.log").write_text("rtsp ok\n", encoding="utf-8")
+    (project_root / "outputs" / "rtsp_run.log").write_text(
+        "rtsp ok\n", encoding="utf-8"
+    )
+    (rtsp_dir / "webhook_events.jsonl").write_text(
+        json.dumps(latest_payload) + "\n", encoding="utf-8"
+    )

    app = create_app(config_path)
    app.testing = True
@@ -85,6 +116,8 @@ def test_get_manage_config(tmp_path: Path):
    assert response.json["config_path"] == str(config_path)
    assert response.json["runtime"]["rtsp_url"] == "rtsp://before-update"
    assert response.json["rtsp"]["output_subdir"] == "rtsp_stream"
+    assert response.json["queue"]["source_id"] == "queue_cam_01"
+    assert response.json["webhook"]["url"] == "https://example.test/webhook"


 def test_put_manage_config_updates_rtsp_url(tmp_path: Path):
@@ -111,8 +144,15 @@ def test_get_manage_summary(tmp_path: Path):
    assert response.json["result_type"] == "people_flow_project"
    assert response.json["last_result_time"] == "2026-04-16T10:00:00+08:00"
    assert response.json["metrics"]["total_people"] == 7
+    assert response.json["metrics"]["queue_level"] == "crowded"
+    assert response.json["metrics"]["over_threshold_count"] == 6
+    assert response.json["metrics"]["under_threshold_count"] == 2
+    assert response.json["metrics"]["status_change"] == "queue_increased"
    assert response.json["metrics"]["direction_counts"] == {"in": 2, "out": 1}
-    assert response.json["metrics"]["recent_window_stats"][0]["window_end"] == "2026-04-16T10:00:00+08:00"
+    assert (
+        response.json["metrics"]["recent_window_stats"][0]["window_end"]
+        == "2026-04-16T10:00:00+08:00"
+    )


 def test_get_manage_windows(tmp_path: Path):
@@ -126,6 +166,7 @@ def test_get_manage_windows(tmp_path: Path):
    assert response.json["page_size"] == 1
    assert response.json["items"][0]["window_end"] == "2026-04-16T10:00:00+08:00"
    assert response.json["items"][0]["total_people"] == 7
+    assert response.json["items"][0]["queue_level"] == "crowded"


 def test_get_manage_files(tmp_path: Path):
@@ -137,6 +178,7 @@ def test_get_manage_files(tmp_path: Path):
    assert {item["path"] for item in response.json["files"]} == {
        "outputs/rtsp_run.log",
        "outputs/rtsp_stream/latest.json",
+        "outputs/rtsp_stream/webhook_events.jsonl",
        "outputs/rtsp_stream/windows/stats_2026-04-16_09-00-00.json",
        "outputs/rtsp_stream/windows/stats_2026-04-16_09-30-00.json",
    }
--- a/managed/people_flow_project/tests/test_queue_analytics.py
+++ b/managed/people_flow_project/tests/test_queue_analytics.py
@@ -0,0 +1,43 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+from src.people_flow.models import QueueConfig, TrackObservation
+from src.people_flow.queue_analytics import QueueWindowTracker
+
+TZ = ZoneInfo("Asia/Shanghai")
+
+
+def test_queue_window_tracker_builds_crowded_report():
+    tracker = QueueWindowTracker(
+        QueueConfig(
+            queue_time_threshold_seconds=300,
+            crowded_count_threshold=5,
+            normal_count_threshold=2,
+            pause_timeout_seconds=5,
+        ),
+        pixel_area=(0, 0, 100, 100),
+    )
+    start = datetime(2026, 4, 15, 11, 0, tzinfo=TZ)
+    crowded_tracks = [
+        TrackObservation(
+            track_id=index, bbox=(0, 0, 10, 10), confidence=0.9, center=(10, 10)
+        )
+        for index in range(1, 7)
+    ]
+    short_tracks = [
+        TrackObservation(
+            track_id=index, bbox=(0, 0, 10, 10), confidence=0.9, center=(10, 10)
+        )
+        for index in range(7, 9)
+    ]
+
+    tracker.observe(crowded_tracks, start)
+    tracker.observe(crowded_tracks, start.replace(minute=6))
+    tracker.observe(crowded_tracks + short_tracks, start.replace(minute=27))
+    tracker.observe(short_tracks, start.replace(minute=30))
+
+    queue_metrics = tracker.build_queue_metrics(start, start.replace(minute=30))
+
+    assert queue_metrics["over_threshold_count"] == 6
+    assert queue_metrics["under_threshold_count"] == 2
+    assert queue_metrics["queue_level"] == "crowded"
--- a/managed/store_dwell_alert/app/config.py
+++ b/managed/store_dwell_alert/app/config.py
@@ -8,8 +8,9 @@ import yaml

@dataclass(slots=True)
 class Thresholds:
-    min_people: int = 5
-    min_dwell_seconds: int = 600
+    queue_time_threshold_seconds: int = 300
+    crowded_count_threshold: int = 5
+    normal_count_threshold: int = 2
    pause_timeout_seconds: int = 300
    alert_cooldown_seconds: int = 600

@@ -30,6 +31,7 @@ class StaffConfig:

@dataclass(slots=True)
 class WebhookConfig:
+    url: str = ""
    alert_url: str = ""
    report_url: str = ""
    timeout_seconds: float = 5.0
@@ -52,7 +54,16 @@ class AppConfig:


 def _load_section(raw: dict, key: str, cls):
-    return cls(**raw.get(key, {}))
+    payload = dict(raw.get(key, {}))
+    if cls is Thresholds:
+        if (
+            "queue_time_threshold_seconds" not in payload
+            and "min_dwell_seconds" in payload
+        ):
+            payload["queue_time_threshold_seconds"] = payload["min_dwell_seconds"]
+        if "crowded_count_threshold" not in payload and "min_people" in payload:
+            payload["crowded_count_threshold"] = payload["min_people"]
+    return cls(**payload)


 def resolve_config_path(config_path: str | Path | None = None) -> Path:
--- a/managed/store_dwell_alert/app/main.py
+++ b/managed/store_dwell_alert/app/main.py
@@ -15,7 +15,7 @@ from app.config import (
 from app.modules.detector_tracker import YOLOTrackerAdapter
 from app.modules.dwell_engine import DwellEngine
 from app.modules.identity_resolver import IdentityResolver
-from app.modules.notifier import append_json_event
+from app.modules.notifier import dispatch_json_event
 from app.modules.staff_filter import StaffMatcher, load_staff_gallery
 from app.modules.stream_reader import RTSPFrameReader

@@ -46,12 +46,20 @@ def build_app(config_path: str | Path | None = None) -> dict:
        ),
        "dwell_engine": DwellEngine(
            camera_id=config.camera_id,
-            min_people=config.thresholds.min_people,
-            min_dwell_seconds=config.thresholds.min_dwell_seconds,
+            queue_time_threshold_seconds=config.thresholds.queue_time_threshold_seconds,
+            crowded_count_threshold=config.thresholds.crowded_count_threshold,
+            normal_count_threshold=config.thresholds.normal_count_threshold,
            pause_timeout_seconds=config.thresholds.pause_timeout_seconds,
            alert_cooldown_seconds=config.thresholds.alert_cooldown_seconds,
        ),
-        "notifier": append_json_event,
+        "notifier": lambda path, event: dispatch_json_event(
+            path,
+            event,
+            webhook_url=config.webhook.url
+            or config.webhook.report_url
+            or config.webhook.alert_url,
+            timeout_seconds=config.webhook.timeout_seconds,
+        ),
        "event_sink_path": event_sink_path,
    }

@@ -102,14 +110,18 @@ def run_forever(app: dict, max_frames: int | None = None) -> int:
 def parse_args() -> ArgumentParser:
    parser = ArgumentParser(description="Store dwell alert service bootstrap")
    parser.add_argument("--config", help="Path to YAML config file")
-    parser.add_argument("--once", action="store_true", help="Read and process one frame")
+    parser.add_argument(
+        "--once", action="store_true", help="Read and process one frame"
+    )
    parser.add_argument(
        "--manage-api",
        action="store_true",
        help="Start the management API instead of the RTSP worker loop",
    )
    parser.add_argument("--host", default="0.0.0.0", help="Host for the management API")
-    parser.add_argument("--port", type=int, default=18081, help="Port for the management API")
+    parser.add_argument(
+        "--port", type=int, default=18081, help="Port for the management API"
+    )
    parser.add_argument(
        "--max-frames",
        type=int,
--- a/managed/store_dwell_alert/app/manage_api.py
+++ b/managed/store_dwell_alert/app/manage_api.py
@@ -17,7 +17,6 @@ from app.config import (
    save_config_document,
 )

-
 PROJECT_TYPE = "store_dwell_alert"
 DEFAULT_MANAGE_PORT = 18081
 MAX_PREVIEW_LINES = 2000
@@ -136,7 +135,12 @@ def parse_args() -> ArgumentParser:
    parser = ArgumentParser(description="Store dwell alert management API")
    parser.add_argument("--config", help="Path to YAML config file")
    parser.add_argument("--host", default="0.0.0.0", help="Host for the management API")
-    parser.add_argument("--port", type=int, default=DEFAULT_MANAGE_PORT, help="Port for the management API")
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=DEFAULT_MANAGE_PORT,
+        help="Port for the management API",
+    )
    return parser


@@ -160,9 +164,18 @@ def _config_payload(ctx: ManageContext) -> dict:
            "sample_fps": config.stream.sample_fps,
            "reconnect_backoff_seconds": config.stream.reconnect_backoff_seconds,
        },
+        "thresholds": {
+            "queue_time_threshold_seconds": config.thresholds.queue_time_threshold_seconds,
+            "crowded_count_threshold": config.thresholds.crowded_count_threshold,
+            "normal_count_threshold": config.thresholds.normal_count_threshold,
+        },
        "event_sink": {
            "path": str(event_sink_path),
        },
+        "webhook": {
+            "url": config.webhook.url,
+            "timeout_seconds": config.webhook.timeout_seconds,
+        },
    }


@@ -179,11 +192,13 @@ def _build_summary(ctx: ManageContext) -> dict:
            },
        }

-    alert_count = 0
-    last_alert_time = ""
    last_report_time = ""
    active_count = 0
    longest_dwell_seconds = 0
+    queue_level = ""
+    over_threshold_count = 0
+    under_threshold_count = 0
+    status_change = ""
    window_stats: list[dict] = []

    with events_path.open("r", encoding="utf-8") as handle:
@@ -196,10 +211,7 @@ def _build_summary(ctx: ManageContext) -> dict:
            except json.JSONDecodeError:
                continue

-            if payload.get("event") == "long_stay_alert":
-                alert_count += 1
-                last_alert_time = _string_value(payload.get("ts"))
-            elif payload.get("event") == "half_hour_report":
+            if payload.get("event") == "half_hour_report":
                last_report_time = _string_value(payload.get("window_end"))
                active_count = _int_value(payload.get("active_customer_count"))
                stat = _build_window_stat(payload)
@@ -208,31 +220,36 @@ def _build_summary(ctx: ManageContext) -> dict:
                    longest_dwell_seconds,
                    stat["max_wait_seconds"],
                )
+                queue_level = stat["queue_level"]
+                over_threshold_count = stat["over_threshold_count"]
+                under_threshold_count = stat["under_threshold_count"]
+                status_change = stat["status_change"]

    window_stats.sort(
        key=lambda item: _parse_timestamp(item["window_end"]),
        reverse=True,
    )

-    headline = "No alerts or reports yet"
+    headline = "No reports yet"
    if last_report_time:
        headline = (
            "Latest report shows "
-            f"{active_count} active customers, longest dwell {longest_dwell_seconds}s"
+            f"{queue_level or 'unknown'} queue, "
+            f"{over_threshold_count} over 5 min and {under_threshold_count} under 5 min"
        )
-    elif alert_count > 0:
-        headline = f"Observed {alert_count} alert(s), latest alert at {last_alert_time}"

    return {
        "result_type": PROJECT_TYPE,
        "headline": headline,
-        "last_result_time": _latest_timestamp(last_alert_time, last_report_time),
+        "last_result_time": _latest_timestamp(last_report_time),
        "metrics": {
-            "alert_count": alert_count,
-            "last_alert_time": last_alert_time,
            "last_half_hour_report_time": last_report_time,
            "active_customer_count": active_count,
            "longest_dwell_seconds": longest_dwell_seconds,
+            "queue_level": queue_level,
+            "over_threshold_count": over_threshold_count,
+            "under_threshold_count": under_threshold_count,
+            "status_change": status_change,
            "events_path": str(events_path),
            "recent_window_stats": window_stats[:24],
            "all_window_stats": window_stats,
@@ -260,7 +277,9 @@ def _list_result_files(ctx: ManageContext) -> list[dict]:
                "label": label,
                "kind": path.suffix.lstrip(".").lower(),
                "size": info.st_size,
-                "modified_at": datetime.fromtimestamp(info.st_mtime).astimezone().isoformat(),
+                "modified_at": datetime.fromtimestamp(info.st_mtime)
+                .astimezone()
+                .isoformat(),
            }
        )

@@ -279,12 +298,21 @@ def _build_window_stat(payload: dict) -> dict:
        payload.get("closed_customers"),
        "final_dwell_seconds",
    )
+    queue_metrics = (
+        payload.get("queue_metrics")
+        if isinstance(payload.get("queue_metrics"), dict)
+        else {}
+    )
    return {
        "window_start": _string_value(payload.get("window_start")),
        "window_end": _string_value(payload.get("window_end")),
        "active_customer_count": _int_value(payload.get("active_customer_count")),
        "active_wait_seconds": active_wait_seconds,
        "closed_wait_seconds": closed_wait_seconds,
+        "queue_level": _string_value(queue_metrics.get("queue_level")),
+        "over_threshold_count": _int_value(queue_metrics.get("over_threshold_count")),
+        "under_threshold_count": _int_value(queue_metrics.get("under_threshold_count")),
+        "status_change": _string_value(queue_metrics.get("status_change")),
        "max_wait_seconds": max(
            max(active_wait_seconds, default=0),
            max(closed_wait_seconds, default=0),
--- a/managed/store_dwell_alert/app/modules/dwell_engine.py
+++ b/managed/store_dwell_alert/app/modules/dwell_engine.py
@@ -1,6 +1,6 @@
 from __future__ import annotations

-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime

 from app.modules.reporter import floor_half_hour, previous_half_hour_window
@@ -18,6 +18,7 @@ class DwellSession:
    last_seen_at: datetime | None = None
    pause_started_at: datetime | None = None
    closed_at: datetime | None = None
+    completed_periods: list[tuple[datetime, datetime]] = field(default_factory=list)

    def __post_init__(self) -> None:
        if self.active_started_at is None:
@@ -46,6 +47,7 @@ class DwellSession:
    def pause(self, when: datetime) -> None:
        if self.state != "active" or self.active_started_at is None:
            return
+        self.completed_periods.append((self.active_started_at, when))
        self.accumulated_dwell_seconds += max(
            0,
            int((when - self.active_started_at).total_seconds()),
@@ -73,19 +75,41 @@ class DwellSession:
            "dwell_seconds": self.dwell_seconds(when),
        }

+    def window_dwell_seconds(
+        self,
+        window_start: datetime,
+        window_end: datetime,
+        when: datetime | None = None,
+    ) -> int:
+        total = 0
+        for period_start, period_end in self.completed_periods:
+            total += _overlap_seconds(
+                period_start, period_end, window_start, window_end
+            )
+
+        if self.state == "active" and self.active_started_at is not None:
+            current_end = when or self.last_seen_at or window_end
+            total += _overlap_seconds(
+                self.active_started_at, current_end, window_start, window_end
+            )
+
+        return total
+

 class DwellEngine:
    def __init__(
        self,
        camera_id: str,
-        min_people: int,
-        min_dwell_seconds: int,
+        queue_time_threshold_seconds: int,
+        crowded_count_threshold: int,
+        normal_count_threshold: int,
        pause_timeout_seconds: int,
        alert_cooldown_seconds: int,
    ) -> None:
        self.camera_id = camera_id
-        self.min_people = min_people
-        self.min_dwell_seconds = min_dwell_seconds
+        self.queue_time_threshold_seconds = queue_time_threshold_seconds
+        self.crowded_count_threshold = crowded_count_threshold
+        self.normal_count_threshold = normal_count_threshold
        self.pause_timeout_seconds = pause_timeout_seconds
        self.alert_cooldown_seconds = alert_cooldown_seconds
        self.sessions: dict[str, DwellSession] = {}
@@ -94,13 +118,16 @@ class DwellEngine:
        self.alert_rearmed = True
        self.last_alert_at: datetime | None = None
        self.last_report_boundary: datetime | None = None
+        self.last_queue_level: str | None = None

    def _next_session_id(self, person_id: str) -> str:
        next_index = self.session_counts.get(person_id, 0) + 1
        self.session_counts[person_id] = next_index
        return f"{person_id}-s{next_index}"

-    def _create_session(self, person_id: str, role: str, when: datetime) -> DwellSession:
+    def _create_session(
+        self, person_id: str, role: str, when: datetime
+    ) -> DwellSession:
        session = DwellSession(
            person_id=person_id,
            session_id=self._next_session_id(person_id),
@@ -110,7 +137,9 @@ class DwellEngine:
        self.sessions[person_id] = session
        return session

-    def process_observations(self, observations: list[dict], when: datetime) -> list[dict]:
+    def process_observations(
+        self, observations: list[dict], when: datetime
+    ) -> list[dict]:
        events: list[dict] = []
        seen_people: set[str] = set()

@@ -151,12 +180,12 @@ class DwellEngine:
            for session in self.sessions.values()
            if session.role == "customer"
            and session.state == "active"
-            and session.dwell_seconds(when) >= self.min_dwell_seconds
+            and session.dwell_seconds(when) >= self.queue_time_threshold_seconds
        ]

    def _build_alert_event(self, when: datetime) -> dict | None:
        long_stay_sessions = self._active_customer_sessions(when)
-        if len(long_stay_sessions) < self.min_people:
+        if len(long_stay_sessions) < self.crowded_count_threshold:
            self.alert_rearmed = True
            return None
        if not self.alert_rearmed:
@@ -168,8 +197,8 @@ class DwellEngine:
            "camera_id": self.camera_id,
            "ts": when.isoformat(),
            "threshold": {
-                "min_people": self.min_people,
-                "min_dwell_seconds": self.min_dwell_seconds,
+                "min_people": self.crowded_count_threshold,
+                "min_dwell_seconds": self.queue_time_threshold_seconds,
            },
            "active_long_stay_count": len(long_stay_sessions),
            "people": [
@@ -192,8 +221,15 @@ class DwellEngine:
            return None

        window_start, window_end = previous_half_hour_window(when)
+        queue_totals = self._queue_totals(window_start, window_end, when)
+        queue_metrics = self._build_queue_metrics(queue_totals)
        active_customers = [
-            session.as_event_dict(when)
+            {
+                **session.as_event_dict(when),
+                "window_queue_seconds": session.window_dwell_seconds(
+                    window_start, window_end, when
+                ),
+            }
            for session in self.sessions.values()
            if session.role == "customer" and session.state == "active"
        ]
@@ -202,25 +238,147 @@ class DwellEngine:
                "person_id": session.person_id,
                "session_id": session.session_id,
                "final_dwell_seconds": session.dwell_seconds(window_end),
+                "window_queue_seconds": session.window_dwell_seconds(
+                    window_start, window_end, window_end
+                ),
            }
            for session in self.closed_sessions
            if session.role == "customer"
            and session.closed_at is not None
            and window_start < session.closed_at <= window_end
        ]
-        staff_seen_count = sum(1 for session in self.sessions.values() if session.role == "staff")
+        staff_seen_count = sum(
+            1 for session in self.sessions.values() if session.role == "staff"
+        )
        self.last_report_boundary = boundary
        return {
            "event": "half_hour_report",
+            "project_type": "store_dwell_alert",
            "camera_id": self.camera_id,
+            "source_id": self.camera_id,
            "window_start": window_start.isoformat(),
            "window_end": window_end.isoformat(),
            "active_customer_count": len(active_customers),
            "active_customers": active_customers,
            "closed_customers": closed_customers,
            "staff_seen_count": staff_seen_count,
+            "queue_metrics": queue_metrics,
        }

+    def _queue_totals(
+        self,
+        window_start: datetime,
+        window_end: datetime,
+        when: datetime,
+    ) -> dict[str, int]:
+        totals: dict[str, int] = {}
+        for session in self.closed_sessions:
+            if session.role != "customer":
+                continue
+            window_seconds = session.window_dwell_seconds(
+                window_start, window_end, window_end
+            )
+            if window_seconds > 0:
+                totals[session.person_id] = (
+                    totals.get(session.person_id, 0) + window_seconds
+                )
+
+        for session in self.sessions.values():
+            if session.role != "customer":
+                continue
+            window_seconds = session.window_dwell_seconds(
+                window_start, window_end, when
+            )
+            if window_seconds > 0:
+                totals[session.person_id] = (
+                    totals.get(session.person_id, 0) + window_seconds
+                )
+
+        return totals
+
+    def _build_queue_metrics(self, queue_totals: dict[str, int]) -> dict:
+        over_threshold_count = sum(
+            1
+            for seconds in queue_totals.values()
+            if seconds >= self.queue_time_threshold_seconds
+        )
+        under_threshold_count = sum(
+            1
+            for seconds in queue_totals.values()
+            if 0 < seconds < self.queue_time_threshold_seconds
+        )
+        queue_level = _queue_level(
+            over_threshold_count,
+            crowded_count_threshold=self.crowded_count_threshold,
+            normal_count_threshold=self.normal_count_threshold,
+        )
+        previous_queue_level = self.last_queue_level
+        status_change = _queue_status_change(previous_queue_level, queue_level)
+        self.last_queue_level = queue_level
+        return {
+            "queue_time_threshold_seconds": self.queue_time_threshold_seconds,
+            "over_threshold_count": over_threshold_count,
+            "under_threshold_count": under_threshold_count,
+            "queue_level": queue_level,
+            "previous_queue_level": previous_queue_level,
+            "status_change": status_change,
+            "people": [
+                {
+                    "person_id": person_id,
+                    "queue_seconds": queue_seconds,
+                    "bucket": (
+                        "over_threshold"
+                        if queue_seconds >= self.queue_time_threshold_seconds
+                        else "under_threshold"
+                    ),
+                }
+                for person_id, queue_seconds in sorted(
+                    queue_totals.items(),
+                    key=lambda item: item[1],
+                    reverse=True,
+                )
+            ],
+        }
+
+
+def _overlap_seconds(
+    period_start: datetime,
+    period_end: datetime,
+    window_start: datetime,
+    window_end: datetime,
+) -> int:
+    overlap_start = max(period_start, window_start)
+    overlap_end = min(period_end, window_end)
+    if overlap_end <= overlap_start:
+        return 0
+    return int((overlap_end - overlap_start).total_seconds())
+
+
+def _queue_level(
+    over_threshold_count: int,
+    crowded_count_threshold: int,
+    normal_count_threshold: int,
+) -> str:
+    if over_threshold_count > crowded_count_threshold:
+        return "crowded"
+    if over_threshold_count >= normal_count_threshold:
+        return "normal"
+    return "few"
+
+
+def _queue_status_change(previous_level: str | None, current_level: str) -> str:
+    if previous_level is None:
+        return "initial"
+    if previous_level == current_level:
+        return "unchanged"
+    if current_level == "crowded" and previous_level in {"normal", "few"}:
+        return "queue_increased"
+    if current_level == "few" and previous_level in {"normal", "crowded"}:
+        return "queue_decreased"
+    if current_level == "normal" and previous_level in {"crowded", "few"}:
+        return "queue_normalized"
+    return "changed"
+

 def long_stay_count(sessions: list[dict], min_dwell_seconds: int) -> int:
    return sum(
--- a/managed/store_dwell_alert/app/modules/notifier.py
+++ b/managed/store_dwell_alert/app/modules/notifier.py
@@ -5,7 +5,9 @@ from pathlib import Path
 from urllib import request


-def build_json_request(url: str, payload: dict, timeout_seconds: float = 5.0) -> request.Request:
+def build_json_request(
+    url: str, payload: dict, timeout_seconds: float = 5.0
+) -> request.Request:
    data = json.dumps(payload).encode("utf-8")
    req = request.Request(url=url, data=data, method="POST")
    req.add_header("Content-Type", "application/json")
@@ -18,3 +20,22 @@ def append_json_event(path: str | Path, payload: dict) -> None:
    output_path.parent.mkdir(parents=True, exist_ok=True)
    with output_path.open("a", encoding="utf-8") as handle:
        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+
+def post_json_event(url: str, payload: dict, timeout_seconds: float = 5.0) -> None:
+    if not url.strip():
+        return
+    req = build_json_request(url, payload, timeout_seconds=timeout_seconds)
+    with request.urlopen(req, timeout=timeout_seconds):
+        return
+
+
+def dispatch_json_event(
+    path: str | Path,
+    payload: dict,
+    webhook_url: str = "",
+    timeout_seconds: float = 5.0,
+) -> None:
+    append_json_event(path, payload)
+    if webhook_url.strip():
+        post_json_event(webhook_url, payload, timeout_seconds=timeout_seconds)
--- a/managed/store_dwell_alert/config/config.example.yaml
+++ b/managed/store_dwell_alert/config/config.example.yaml
@@ -2,8 +2,9 @@ camera_id: store_cam_01
 timezone: Asia/Shanghai

 thresholds:
-  min_people: 5
-  min_dwell_seconds: 600
+  queue_time_threshold_seconds: 300
+  crowded_count_threshold: 5
+  normal_count_threshold: 2
  pause_timeout_seconds: 300
  alert_cooldown_seconds: 600

@@ -21,6 +22,7 @@ event_sink:
  path: logs/events.jsonl

 webhook:
+  url: ""
  alert_url: ""
  report_url: ""
  timeout_seconds: 5.0
--- a/managed/store_dwell_alert/scripts/docker-entrypoint.sh
+++ b/managed/store_dwell_alert/scripts/docker-entrypoint.sh
@@ -40,4 +40,67 @@ config_path.write_text(
 )
 PY

-exec python -m app.manage_api --config "${CONFIG_PATH}" --host "${API_HOST}" --port "${API_PORT}"
+exec python - "$CONFIG_PATH" "$API_HOST" "$API_PORT" <<'PY'
+import signal
+import subprocess
+import sys
+import time
+
+config_path, api_host, api_port = sys.argv[1:4]
+commands = [
+  [sys.executable, "-m", "app.main", "--config", config_path],
+  [
+    sys.executable,
+    "-m",
+    "app.manage_api",
+    "--config",
+    config_path,
+    "--host",
+    api_host,
+    "--port",
+    api_port,
+  ],
+]
+processes = [subprocess.Popen(command) for command in commands]
+
+
+def terminate_all(signum, _frame):
+  for process in processes:
+    if process.poll() is None:
+      process.terminate()
+  deadline = time.time() + 10
+  for process in processes:
+    if process.poll() is not None:
+      continue
+    timeout = max(0, deadline - time.time())
+    try:
+      process.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+      process.kill()
+  raise SystemExit(128 + signum)
+
+
+for handled_signal in (signal.SIGINT, signal.SIGTERM):
+  signal.signal(handled_signal, terminate_all)
+
+while True:
+  for index, process in enumerate(processes):
+    return_code = process.poll()
+    if return_code is None:
+      continue
+    for other_index, other_process in enumerate(processes):
+      if other_index == index or other_process.poll() is not None:
+        continue
+      other_process.terminate()
+    deadline = time.time() + 10
+    for other_index, other_process in enumerate(processes):
+      if other_index == index or other_process.poll() is not None:
+        continue
+      timeout = max(0, deadline - time.time())
+      try:
+        other_process.wait(timeout=timeout)
+      except subprocess.TimeoutExpired:
+        other_process.kill()
+    raise SystemExit(return_code)
+  time.sleep(0.5)
+PY
--- a/managed/store_dwell_alert/tests/test_config.py
+++ b/managed/store_dwell_alert/tests/test_config.py
@@ -8,16 +8,18 @@ def test_load_config_reads_thresholds(tmp_path: Path):
    cfg.write_text(
        "camera_id: store_cam_01\n"
        "thresholds:\n"
-        "  min_people: 5\n"
-        "  min_dwell_seconds: 600\n",
+        "  queue_time_threshold_seconds: 300\n"
+        "  crowded_count_threshold: 5\n"
+        "  normal_count_threshold: 2\n",
        encoding="utf-8",
    )

    data = load_config(cfg)

    assert data.camera_id == "store_cam_01"
-    assert data.thresholds.min_people == 5
-    assert data.thresholds.min_dwell_seconds == 600
+    assert data.thresholds.queue_time_threshold_seconds == 300
+    assert data.thresholds.crowded_count_threshold == 5
+    assert data.thresholds.normal_count_threshold == 2


 def test_load_config_uses_defaults_for_optional_sections(tmp_path: Path):
@@ -29,4 +31,5 @@ def test_load_config_uses_defaults_for_optional_sections(tmp_path: Path):
    assert data.stream.sample_fps == 2.0
    assert data.staff.min_hits == 3
    assert data.event_sink.path == "logs/events.jsonl"
+    assert data.webhook.url == ""
    assert data.webhook.timeout_seconds == 5.0
--- a/managed/store_dwell_alert/tests/test_dwell_engine.py
+++ b/managed/store_dwell_alert/tests/test_dwell_engine.py
@@ -1,8 +1,7 @@
 from datetime import datetime
 from zoneinfo import ZoneInfo

-from app.modules.dwell_engine import DwellEngine, DwellSession, long_stay_count
-
+from app.modules.dwell_engine import DwellEngine, DwellSession

 TZ = ZoneInfo("Asia/Shanghai")

@@ -12,34 +11,81 @@ def test_session_pauses_without_adding_absence_time():
    session = DwellSession(person_id="cust_1", session_id="cust_1-s1", entered_at=start)
    session.mark_seen(start.replace(minute=2))
    session.pause(start.replace(minute=2, second=10))
-    session.close_if_expired(start.replace(minute=7, second=11), pause_timeout_seconds=300)
+    session.close_if_expired(
+        start.replace(minute=7, second=11), pause_timeout_seconds=300
+    )
    assert session.state == "closed"
    assert session.dwell_seconds() == 130


-def test_engine_emits_alert_when_five_long_stays_are_active():
+def test_engine_emits_half_hour_report_with_queue_classification():
    engine = DwellEngine(
        camera_id="store_cam_01",
-        min_people=5,
-        min_dwell_seconds=600,
+        queue_time_threshold_seconds=300,
+        crowded_count_threshold=5,
+        normal_count_threshold=2,
        pause_timeout_seconds=300,
        alert_cooldown_seconds=600,
    )
-    now = datetime(2026, 4, 15, 11, 20, tzinfo=TZ)
-    observations = [{"person_id": f"cust_{idx}", "role": "customer"} for idx in range(5)]
+    start = datetime(2026, 4, 15, 11, 0, tzinfo=TZ)
+    crowded_group = [
+        {"person_id": f"cust_{idx}", "role": "customer"} for idx in range(6)
+    ]
+    short_wait_group = [
+        {"person_id": f"short_{idx}", "role": "customer"} for idx in range(2)
+    ]

-    engine.process_observations(observations, now.replace(minute=9, second=0))
-    events = engine.process_observations(observations, now)
+    engine.process_observations(crowded_group, start.replace(minute=0, second=0))
+    engine.process_observations(crowded_group, start.replace(minute=6, second=0))
+    engine.process_observations(
+        crowded_group + short_wait_group, start.replace(minute=27, second=0)
+    )
+    events = engine.process_observations(
+        short_wait_group, start.replace(minute=30, second=0)
+    )

-    assert [event["event"] for event in events] == ["long_stay_alert"]
-    assert events[0]["active_long_stay_count"] == 5
+    report = next(event for event in events if event["event"] == "half_hour_report")
+    assert report["queue_metrics"]["over_threshold_count"] == 6
+    assert report["queue_metrics"]["under_threshold_count"] == 2
+    assert report["queue_metrics"]["queue_level"] == "crowded"
+    assert report["queue_metrics"]["status_change"] == "initial"
+
+
+def test_engine_tracks_queue_status_change_between_windows():
+    engine = DwellEngine(
+        camera_id="store_cam_01",
+        queue_time_threshold_seconds=300,
+        crowded_count_threshold=5,
+        normal_count_threshold=2,
+        pause_timeout_seconds=300,
+        alert_cooldown_seconds=600,
+    )
+    start = datetime(2026, 4, 15, 11, 0, tzinfo=TZ)
+    engine.process_observations(
+        [{"person_id": f"crowded_{idx}", "role": "customer"} for idx in range(6)],
+        start,
+    )
+    engine.process_observations([], start.replace(minute=30))
+    engine.process_observations(
+        [{"person_id": f"normal_{idx}", "role": "customer"} for idx in range(3)],
+        start.replace(minute=31),
+    )
+    report_events = engine.process_observations([], start.replace(hour=12, minute=0))
+
+    report = next(
+        event for event in report_events if event["event"] == "half_hour_report"
+    )
+    assert report["queue_metrics"]["queue_level"] == "normal"
+    assert report["queue_metrics"]["status_change"] == "queue_normalized"
+    assert report["queue_metrics"]["previous_queue_level"] == "crowded"


 def test_engine_emits_half_hour_report_with_closed_customers():
    engine = DwellEngine(
        camera_id="store_cam_01",
-        min_people=5,
-        min_dwell_seconds=600,
+        queue_time_threshold_seconds=300,
+        crowded_count_threshold=5,
+        normal_count_threshold=2,
        pause_timeout_seconds=300,
        alert_cooldown_seconds=600,
    )
@@ -53,11 +99,5 @@ def test_engine_emits_half_hour_report_with_closed_customers():
    report = next(event for event in events if event["event"] == "half_hour_report")
    assert report["window_end"] == "2026-04-15T11:30:00+08:00"
    assert report["closed_customers"][0]["person_id"] == "cust_1"
-
-
-def test_long_stay_count_excludes_staff():
-    sessions = [
-        {"role": "customer", "state": "active", "dwell_seconds": 700},
-        {"role": "staff", "state": "active", "dwell_seconds": 40000},
-    ]
-    assert long_stay_count(sessions, min_dwell_seconds=600) == 1
+    assert report["queue_metrics"]["over_threshold_count"] == 0
+    assert report["queue_metrics"]["under_threshold_count"] == 1
--- a/managed/store_dwell_alert/tests/test_manage_api.py
+++ b/managed/store_dwell_alert/tests/test_manage_api.py
@@ -14,6 +14,10 @@ def build_client(project_root: Path):
    config_path.write_text(
        "camera_id: store_cam_01\n"
        "timezone: Asia/Shanghai\n"
+        "thresholds:\n"
+        "  queue_time_threshold_seconds: 300\n"
+        "  crowded_count_threshold: 5\n"
+        "  normal_count_threshold: 2\n"
        "stream:\n"
        "  rtsp_url: rtsp://before-update\n"
        "  sample_fps: 2.0\n"
@@ -28,13 +32,6 @@ def build_client(project_root: Path):
    (logs_dir / "events.jsonl").write_text(
        "\n".join(
            [
-                json.dumps(
-                    {
-                        "event": "long_stay_alert",
-                        "camera_id": "store_cam_01",
-                        "ts": "2026-04-16T09:00:00+08:00",
-                    }
-                ),
                json.dumps(
                    {
                        "event": "half_hour_report",
@@ -50,6 +47,14 @@ def build_client(project_root: Path):
                            {"person_id": "cust_3", "final_dwell_seconds": 450}
                        ],
                        "staff_seen_count": 1,
+                        "queue_metrics": {
+                            "queue_time_threshold_seconds": 300,
+                            "over_threshold_count": 2,
+                            "under_threshold_count": 1,
+                            "queue_level": "normal",
+                            "previous_queue_level": null,
+                            "status_change": "initial",
+                        },
                    }
                ),
                json.dumps(
@@ -67,6 +72,14 @@ def build_client(project_root: Path):
                            {"person_id": "cust_6", "final_dwell_seconds": 120},
                        ],
                        "staff_seen_count": 0,
+                        "queue_metrics": {
+                            "queue_time_threshold_seconds": 300,
+                            "over_threshold_count": 6,
+                            "under_threshold_count": 2,
+                            "queue_level": "crowded",
+                            "previous_queue_level": "normal",
+                            "status_change": "queue_increased",
+                        },
                    }
                ),
            ]
@@ -126,10 +139,14 @@ def test_get_manage_summary(tmp_path: Path):
    assert response.status_code == 200
    assert response.json["result_type"] == "store_dwell_alert"
    assert response.json["last_result_time"] == "2026-04-16T10:00:00+08:00"
-    assert response.json["metrics"]["alert_count"] == 1
-    assert response.json["metrics"]["active_customer_count"] == 1
-    assert response.json["metrics"]["longest_dwell_seconds"] == 900
-    assert response.json["metrics"]["recent_window_stats"][0]["window_end"] == "2026-04-16T10:00:00+08:00"
+    assert response.json["metrics"]["queue_level"] == "crowded"
+    assert response.json["metrics"]["over_threshold_count"] == 6
+    assert response.json["metrics"]["under_threshold_count"] == 2
+    assert response.json["metrics"]["status_change"] == "queue_increased"
+    assert (
+        response.json["metrics"]["recent_window_stats"][0]["window_end"]
+        == "2026-04-16T10:00:00+08:00"
+    )


 def test_get_manage_windows(tmp_path: Path):
--- a/web/src/views/ManagedServiceDetail.vue
+++ b/web/src/views/ManagedServiceDetail.vue
@@ -5,15 +5,13 @@
        <el-button link @click="router.push('/managed-services')">
          返回列表
        </el-button>
-        <h3 class="page-title">{{ service?.display_name || route.params.id }}</h3>
+        <h3 class="page-title">
+          {{ service?.display_name || route.params.id }}
+        </h3>
      </div>
      <div class="toolbar-actions">
        <el-button @click="loadDetail" :loading="loading">刷新</el-button>
-        <el-button
-          type="warning"
-          @click="handleRestart"
-          :loading="restarting"
-        >
+        <el-button type="warning" @click="handleRestart" :loading="restarting">
          重启容器
        </el-button>
        <el-button type="primary" @click="openEdit">编辑 RTSP</el-button>
@@ -96,6 +94,36 @@

          <div v-if="service?.summary">
            <p class="summary-headline">{{ service.summary.headline }}</p>
+            <div v-if="hasQueueMetrics" class="queue-summary-panel">
+              <div class="queue-summary-card queue-summary-card--level">
+                <span class="queue-summary-label">排队等级</span>
+                <div class="queue-summary-main">
+                  <el-tag
+                    :type="queueLevelType(queueSummaryMetrics.queue_level)"
+                  >
+                    {{ queueLevelText(queueSummaryMetrics.queue_level) }}
+                  </el-tag>
+                </div>
+              </div>
+              <div class="queue-summary-card">
+                <span class="queue-summary-label">超 5 分钟人数</span>
+                <span class="queue-summary-value">
+                  {{ queueSummaryMetrics.over_threshold_count ?? 0 }}
+                </span>
+              </div>
+              <div class="queue-summary-card">
+                <span class="queue-summary-label">低于 5 分钟人数</span>
+                <span class="queue-summary-value">
+                  {{ queueSummaryMetrics.under_threshold_count ?? 0 }}
+                </span>
+              </div>
+              <div class="queue-summary-card">
+                <span class="queue-summary-label">状态变化</span>
+                <span class="queue-summary-value queue-summary-value--text">
+                  {{ queueChangeText(queueSummaryMetrics.status_change) }}
+                </span>
+              </div>
+            </div>
            <el-descriptions :column="1" border>
              <el-descriptions-item
                v-for="item in summaryEntries"
@@ -150,6 +178,32 @@
            </template>
          </el-table-column>

+          <el-table-column label="排队等级" width="120">
+            <template #default="{ row }">
+              <el-tag :type="queueLevelType(row.queue_level)">
+                {{ queueLevelText(row.queue_level) }}
+              </el-tag>
+            </template>
+          </el-table-column>
+
+          <el-table-column
+            prop="over_threshold_count"
+            label="超 5 分钟人数"
+            width="130"
+          />
+
+          <el-table-column
+            prop="under_threshold_count"
+            label="低于 5 分钟人数"
+            width="130"
+          />
+
+          <el-table-column label="状态变化" min-width="120">
+            <template #default="{ row }">
+              {{ queueChangeText(row.status_change) }}
+            </template>
+          </el-table-column>
+
          <template v-if="isStoreDwell">
            <el-table-column
              prop="active_customer_count"
@@ -181,7 +235,9 @@
            <el-table-column prop="total_people" label="人流总数" width="110" />
            <el-table-column label="年龄分布" min-width="180">
              <template #default="{ row }">
-                <span class="break-all">{{ formatCounts(row.age_counts) }}</span>
+                <span class="break-all">{{
+                  formatCounts(row.age_counts)
+                }}</span>
              </template>
            </el-table-column>
            <el-table-column label="男女人数" min-width="160">
@@ -394,7 +450,11 @@ const previewFile = async (file) => {
  previewLines.value = [];

  try {
-    const res = await getManagedServicePreview(serviceId.value, file.path, 2000);
+    const res = await getManagedServicePreview(
+      serviceId.value,
+      file.path,
+      2000,
+    );
    previewLines.value = res.lines || [];
  } catch (error) {
    ElMessage.error(error.message || "加载文件预览失败");
@@ -404,14 +464,23 @@ const previewFile = async (file) => {
 };

 const downloadFile = (file) => {
-  window.open(getManagedServiceDownloadUrl(serviceId.value, file.path), "_blank");
+  window.open(
+    getManagedServiceDownloadUrl(serviceId.value, file.path),
+    "_blank",
+  );
 };

 const summaryEntries = computed(() => {
  const metrics = service.value?.summary?.metrics || {};
  return Object.entries(metrics)
    .filter(
-      ([key]) => key !== "recent_window_stats" && key !== "all_window_stats",
+      ([key]) =>
+        key !== "recent_window_stats" &&
+        key !== "all_window_stats" &&
+        key !== "queue_level" &&
+        key !== "over_threshold_count" &&
+        key !== "under_threshold_count" &&
+        key !== "status_change",
    )
    .map(([key, value]) => ({
      key,
@@ -419,6 +488,20 @@ const summaryEntries = computed(() => {
    }));
 });

+const queueSummaryMetrics = computed(
+  () => service.value?.summary?.metrics || {},
+);
+
+const hasQueueMetrics = computed(() => {
+  const metrics = queueSummaryMetrics.value;
+  if (!metrics || typeof metrics !== "object") {
+    return false;
+  }
+  return ["queue_level", "over_threshold_count", "under_threshold_count"].some(
+    (key) => key in metrics,
+  );
+});
+
 const recentWindowStats = computed(() => {
  const stats = service.value?.summary?.metrics?.recent_window_stats;
  return Array.isArray(stats) ? stats : [];
@@ -483,6 +566,35 @@ const formatCounts = (value) => {
  return entries.map(([key, count]) => `${key}: ${count}`).join(", ");
 };

+const queueLevelText = (value) => {
+  const map = {
+    crowded: "人多",
+    normal: "正常",
+    few: "人少",
+  };
+  return map[value] || value || "-";
+};
+
+const queueLevelType = (value) => {
+  const map = {
+    crowded: "danger",
+    normal: "warning",
+    few: "success",
+  };
+  return map[value] || "info";
+};
+
+const queueChangeText = (value) => {
+  const map = {
+    initial: "初始窗口",
+    unchanged: "无变化",
+    queue_increased: "人数变多",
+    queue_decreased: "人数变少",
+    queue_normalized: "人数变正常",
+  };
+  return map[value] || value || "-";
+};
+
 const formatTime = (value) => {
  if (!value) {
    return "-";
@@ -578,6 +690,50 @@ watch(serviceId, loadDetail, { immediate: true });
  font-weight: 600;
 }

+.queue-summary-panel {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+  margin-bottom: 16px;
+}
+
+.queue-summary-card {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 14px 16px;
+  border: 1px solid var(--el-border-color-lighter);
+  border-radius: 12px;
+  background: linear-gradient(180deg, #fbfbf5 0%, #f6f7f1 100%);
+}
+
+.queue-summary-card--level {
+  justify-content: space-between;
+}
+
+.queue-summary-label {
+  color: var(--el-text-color-secondary);
+  font-size: 12px;
+}
+
+.queue-summary-main {
+  display: flex;
+  align-items: center;
+  min-height: 32px;
+}
+
+.queue-summary-value {
+  color: var(--el-text-color-primary);
+  font-size: 28px;
+  font-weight: 700;
+  line-height: 1;
+}
+
+.queue-summary-value--text {
+  font-size: 15px;
+  line-height: 1.4;
+}
+
 .error-tags {
  display: flex;
  flex-direction: column;
@@ -617,4 +773,16 @@ watch(serviceId, loadDetail, { immediate: true });
 .break-all {
  word-break: break-all;
 }
+
+@media (max-width: 1200px) {
+  .queue-summary-panel {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 640px) {
+  .queue-summary-panel {
+    grid-template-columns: 1fr;
+  }
+}
 </style>
--- a/web/src/views/ManagedServices.vue
+++ b/web/src/views/ManagedServices.vue
@@ -46,13 +46,47 @@
            <span class="section-label">摘要</span>
            <div class="summary-text">
              {{
-                service.summary?.headline ||
-                service.result_error ||
-                "暂无摘要"
+                service.summary?.headline || service.result_error || "暂无摘要"
              }}
            </div>
          </div>

+          <div
+            v-if="hasQueueMetrics(service.summary?.metrics)"
+            class="service-section queue-section"
+          >
+            <span class="section-label">排队概览</span>
+            <div class="queue-metrics-grid">
+              <div class="queue-metric-item queue-metric-item--highlight">
+                <span class="queue-metric-label">排队等级</span>
+                <el-tag
+                  size="small"
+                  :type="queueLevelType(service.summary.metrics.queue_level)"
+                >
+                  {{ queueLevelText(service.summary.metrics.queue_level) }}
+                </el-tag>
+              </div>
+              <div class="queue-metric-item">
+                <span class="queue-metric-label">超 5 分钟</span>
+                <span class="queue-metric-value">
+                  {{ service.summary.metrics.over_threshold_count ?? 0 }}
+                </span>
+              </div>
+              <div class="queue-metric-item">
+                <span class="queue-metric-label">低于 5 分钟</span>
+                <span class="queue-metric-value">
+                  {{ service.summary.metrics.under_threshold_count ?? 0 }}
+                </span>
+              </div>
+              <div class="queue-metric-item">
+                <span class="queue-metric-label">状态变化</span>
+                <span class="queue-metric-value queue-metric-value--text">
+                  {{ queueChangeText(service.summary.metrics.status_change) }}
+                </span>
+              </div>
+            </div>
+          </div>
+
          <div
            v-if="
              service.config_error ||
@@ -236,6 +270,44 @@ const formatTime = (value) => {
  return date.toLocaleString();
 };

+const hasQueueMetrics = (metrics) => {
+  if (!metrics || typeof metrics !== "object") {
+    return false;
+  }
+  return ["queue_level", "over_threshold_count", "under_threshold_count"].some(
+    (key) => key in metrics,
+  );
+};
+
+const queueLevelText = (value) => {
+  const map = {
+    crowded: "人多",
+    normal: "正常",
+    few: "人少",
+  };
+  return map[value] || value || "-";
+};
+
+const queueLevelType = (value) => {
+  const map = {
+    crowded: "danger",
+    normal: "warning",
+    few: "success",
+  };
+  return map[value] || "info";
+};
+
+const queueChangeText = (value) => {
+  const map = {
+    initial: "初始窗口",
+    unchanged: "无变化",
+    queue_increased: "人数变多",
+    queue_decreased: "人数变少",
+    queue_normalized: "人数变正常",
+  };
+  return map[value] || value || "-";
+};
+
 onMounted(loadServices);
 </script>

@@ -297,6 +369,49 @@ onMounted(loadServices);
  word-break: break-word;
 }

+.queue-section {
+  padding: 12px;
+  border: 1px solid var(--el-border-color-lighter);
+  border-radius: 10px;
+  background: linear-gradient(180deg, #fcfcf7 0%, #f7f9f4 100%);
+}
+
+.queue-metrics-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.queue-metric-item {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: rgba(255, 255, 255, 0.78);
+}
+
+.queue-metric-item--highlight {
+  border: 1px solid rgba(140, 120, 56, 0.16);
+}
+
+.queue-metric-label {
+  color: #909399;
+  font-size: 12px;
+}
+
+.queue-metric-value {
+  color: #303133;
+  font-size: 20px;
+  font-weight: 700;
+  line-height: 1;
+}
+
+.queue-metric-value--text {
+  font-size: 14px;
+  line-height: 1.4;
+}
+
 .service-errors {
  display: flex;
  gap: 8px;
@@ -309,4 +424,10 @@ onMounted(loadServices);
  gap: 12px;
  flex-wrap: wrap;
 }
+
+@media (max-width: 640px) {
+  .queue-metrics-grid {
+    grid-template-columns: 1fr;
+  }
+}
 </style>