@allansantos-dev/smart-tool 0.9.0 → 0.9.2

package/install.py

@@ -3,6 +3,7 @@ import argparse
 import filecmp
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -15,6 +16,10 @@ import paths
 
 SOURCE = Path(__file__).resolve().parent
 DEFAULT_TARGET = Path(os.environ.get("LOCALAPPDATA", str(Path.home() / "AppData" / "Local"))) / "Programs" / "SmartTool"
+TASK_NAME = "SmartTool-Tray"
+ENTRY_SCRIPTS = ("tray.py", "smart_tool_daemon.py", "pretool_router.py")
+STARTUP_SCRIPT = Path(os.environ.get("APPDATA", str(Path.home() / "AppData" / "Roaming"))) / "Microsoft" / "Windows" / \
+    "Start Menu" / "Programs" / "Startup" / "SmartTool-Tray.vbs"
 MANIFEST = ".install-manifest.json"
 REGISTRY = Path(paths.DATA_DIR) / "daemon.json"
 BLOCKED = {"__pycache__", ".token-guard", ".git", ".pytest_cache", ".data", ".artifacts", ".claude", ".vscode",
@@ -23,12 +28,6 @@ BLOCKED = {"__pycache__", ".token-guard", ".git", ".pytest_cache", ".data", ".ar
 PACKAGE_ONLY = {"bin", "package.json", ".npmignore"}
 REQUIRED_TOOLS = {"smart_search", "smart_search_result", "web_search", "project_manage"}
 _OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
-_FIND = ("$tray = $env:SMART_TRAY.ToLowerInvariant(); $daemon = $env:SMART_DAEMON.ToLowerInvariant(); "
-         "Get-CimInstance Win32_Process -Filter \"Name = 'pythonw.exe' OR Name = 'python.exe'\" | "
-         "Where-Object { $_.CommandLine -and ($_.CommandLine.ToLowerInvariant().Contains($tray) -or "
-         "$_.CommandLine.ToLowerInvariant().Contains($daemon)) }")
-
-
 def ships(rel):
     parts = Path(rel).parts
     *folders, name = parts
@@ -56,16 +55,41 @@ def powershell(script, env=None, timeout=30):
                           capture_output=True, text=True, timeout=timeout)
 
 
+def _processes():
+    """(pid, command line) of every python/pythonw process."""
+    listed = powershell("Get-CimInstance Win32_Process -Filter \"Name = 'pythonw.exe' OR Name = 'python.exe'\" | "
+                        "ForEach-Object { \"$($_.ProcessId)`t$($_.CommandLine)\" }").stdout
+    rows = (row.partition("\t") for row in listed.splitlines())
+    return [(int(pid), line) for pid, _tab, line in rows if pid.strip().isdigit()]
+
+
+def _script_folder(script):
+    path = Path(script)
+    return path.parent.parent if path.name == "pretool_router.py" else path.parent
+
+
+def _same_folder(path, folder):
+    """Compares through resolve(), which turns 8.3 short and mixed spellings into the long name."""
+    try:
+        return path.resolve() == folder.resolve()
+    except OSError:
+        return False
+
+
 def stop_processes(target):
-    env = {"SMART_TRAY": str(target / "tray.py"), "SMART_DAEMON": str(target / "smart_tool_daemon.py")}
-    powershell(_FIND + " | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }", env=env)
+    def running():
+        return [pid for pid, line in _processes() for script in _script_paths(line)
+                if Path(script).name != "pretool_router.py" and _same_folder(_script_folder(script), target)]
+
+    for pid in running():
+        powershell(f"Stop-Process -Id {pid} -Force -ErrorAction SilentlyContinue")
     deadline = time.monotonic() + 10
     while True:
-        left = powershell("@(" + _FIND + ").Count", env=env).stdout.strip()
-        if left == "0":
+        left = running()
+        if not left:
             return
         if time.monotonic() > deadline:
-            raise RuntimeError(f"Could not close the running Smart Tool ({left or '?'} process(es) still active).")
+            raise RuntimeError(f"Could not close the running Smart Tool ({len(left)} process(es) still active).")
         time.sleep(0.5)
 
 
@@ -86,6 +110,79 @@ def _daemon_up():
         return False
 
 
+def hook_files():
+    claude = Path(os.environ.get("CLAUDE_CONFIG_DIR") or Path.home() / ".claude")
+    return claude / "settings.json", Path.home() / ".codex" / "hooks.json"
+
+
+def _script_paths(text):
+    """Absolute paths ending in an entry script, as written in text, tried from every drive letter (paths may hold
+    spaces)."""
+    script = re.compile(r'[^"\r\n]*?(?:' + "|".join(map(re.escape, ENTRY_SCRIPTS)) + ")")
+    for drive in re.finditer(r"[A-Za-z]:[\\/]", text):
+        found = script.match(text, drive.start())
+        if found:
+            yield found.group(0)
+
+
+def _install_folder(script):
+    folder = _script_folder(script)
+    try:
+        return folder.resolve() if (folder / MANIFEST).is_file() and (folder / "smart_tool_daemon.py").is_file() else None
+    except OSError:
+        return None
+
+
+def _task_definition():
+    result = subprocess.run(["schtasks", "/Query", "/TN", TASK_NAME, "/XML"], capture_output=True, text=True,
+                            timeout=20)
+    return result.stdout if result.returncode == 0 else ""
+
+
+def other_installs(target):
+    """Installer-made Smart Tool folders other than target, found through what still runs or points at them: tray and
+    daemon processes, the logon task or Startup script, and agent hook commands."""
+    texts = [line for _pid, line in _processes()] + [_task_definition()]
+    texts += [path.read_text(encoding="utf-8", errors="replace") for path in (STARTUP_SCRIPT, *hook_files())
+              if path.is_file()]
+    folders = {_install_folder(script) for text in texts for script in _script_paths(text)}
+    return sorted(folder for folder in folders
+                  if folder and not _same_folder(folder, target) and not _same_folder(folder, SOURCE))
+
+
+def _repointed(text, folder, target):
+    """text with each spelling of folder found in front of an entry script (long, 8.3 or mixed) replaced by target."""
+    for script in set(_script_paths(text)):
+        cut = len(Path(script).name) + 1 + (len("hooks") + 1 if Path(script).name == "pretool_router.py" else 0)
+        spelled = script[:-cut]
+        if _same_folder(Path(spelled), folder):
+            text = text.replace(spelled, target.as_posix() if "/" in spelled else str(target))
+    return text
+
+
+def remove_other_installs(target):
+    """An older installation in another folder keeps the port and the hooks: stop it, point the hooks at target and
+    delete its program folder. Its state folders are left alone."""
+    removed = []
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    for folder in other_installs(target):
+        print(f"Older Smart Tool installation found at {folder}; removing it.")
+        stop_processes(folder)
+        for path in hook_files():
+            original = path.read_text(encoding="utf-8") if path.is_file() else ""
+            text = _repointed(original, folder, target)
+            if text != original:
+                shutil.copy2(path, path.with_name(f"{path.name}.smart-tool-backup-{stamp}"))
+                path.write_text(text, encoding="utf-8")
+                print(f"Hooks in {path} now point to {target}.")
+        startup = STARTUP_SCRIPT.read_text(encoding="utf-8", errors="replace") if STARTUP_SCRIPT.is_file() else ""
+        if any(_same_folder(_script_folder(script), folder) for script in _script_paths(startup)):
+            STARTUP_SCRIPT.unlink()
+        shutil.rmtree(folder)
+        removed.append(folder)
+    return removed
+
+
 def copy_files(target, files, backup, changed, removed):
     previous = set(json.loads((target / MANIFEST).read_text(encoding="utf-8"))["files"]) if (target / MANIFEST).is_file() else set()
     if (target / MANIFEST).is_file():
@@ -105,6 +202,10 @@ def copy_files(target, files, backup, changed, removed):
             (backup / rel).parent.mkdir(parents=True, exist_ok=True)
             shutil.move(target / rel, backup / rel)
             removed.append(rel)
+            folder = (target / rel).parent
+            while folder != target and not any(folder.iterdir()):
+                folder.rmdir()
+                folder = folder.parent
     (target / MANIFEST).write_text(json.dumps({"installed_at": time.time(), "source": str(SOURCE), "files": files},
                                               indent=1), encoding="utf-8")
 
@@ -209,6 +310,7 @@ def main():
     existed = (target / "smart_tool_daemon.py").is_file()
     print(("Updating" if existed else "Installing") + f" Smart Tool at {target} ({len(files)} files from {SOURCE})")
     target.mkdir(parents=True, exist_ok=True)
+    remove_other_installs(target)
     stop_processes(target)
     if not args.no_start:
         wait_port_free()

package/install_runtime.py

@@ -5,6 +5,7 @@ Uso: python install_runtime.py [--check]
 Não altera ~/.claude nem instala pacotes npm globalmente.
 """
 import argparse
+import collections
 import hashlib
 import json
 import os
@@ -13,6 +14,7 @@ import shutil
 import subprocess
 import sys
 import tempfile
+import threading
 import time
 import urllib.request
 import venv
@@ -114,39 +116,73 @@ def _install_node():
     print(f"Node {version} installed inside Smart Tool.")
 
 
-def _run(args, *, cwd=None, label="Web dependency", timeout_s=600):
+def _run(args, *, cwd=None, label="Web dependency", idle_s=600, stream=False, attempts=1):
+    """Runs a step with UTF-8 output and closed stdin (a prompt fails at once instead of hanging); it is stopped only
+    after idle_s without any output, and stream shows the output live."""
     env = os.environ.copy()
+    env.update(PYTHONUTF8="1", PYTHONIOENCODING="utf-8")
     if NODE_RUNTIME.is_dir():
         env["PATH"] = str(NODE_RUNTIME) + os.pathsep + env.get("PATH", "")
     flags = (subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW) if os.name == "nt" else 0
-    print(f"{label}: starting...", flush=True)
-    started = time.monotonic()
-    process = subprocess.Popen(args, cwd=cwd, env=env, stdout=subprocess.PIPE,
-                               stderr=subprocess.PIPE, text=True, encoding="utf-8",
-                               errors="replace", creationflags=flags)
-    while True:
-        remaining = timeout_s - (time.monotonic() - started)
-        if remaining <= 0:
-            if os.name == "nt":
-                subprocess.run(["taskkill", "/PID", str(process.pid), "/T", "/F"],
-                               capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
-            else:
-                process.kill()
-            try:
-                process.communicate(timeout=5)
-            except subprocess.TimeoutExpired:
-                process.kill()
-                process.communicate(timeout=5)
-            raise RuntimeError(f"{label} exceeded {timeout_s}s; check network, proxy and access to the package registry.")
+    for attempt in range(1, attempts + 1):
+        print(f"{label}: starting{f' (attempt {attempt} of {attempts})' if attempt > 1 else ''}...", flush=True)
         try:
-            stdout, stderr = process.communicate(timeout=min(30, remaining))
-            break
-        except subprocess.TimeoutExpired:
-            print(f"{label}: waiting for {int(time.monotonic() - started)}s...", flush=True)
-    if process.returncode:
-        detail = (stderr or stdout).strip()[-1500:]
-        raise RuntimeError(f"{' '.join(map(str, args[:3]))} failed: {detail}")
-    print(f"{label}: done.", flush=True)
+            _run_once(args, cwd, env, flags, label, idle_s, stream)
+            print(f"{label}: done.", flush=True)
+            return
+        except RuntimeError as exc:
+            if attempt == attempts:
+                raise
+            print(f"{exc}; trying again.", flush=True)
+
+
+def _run_once(args, cwd, env, flags, label, idle_s, stream):
+    with subprocess.Popen(args, cwd=cwd, env=env, stdin=subprocess.DEVNULL,
+                          stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, encoding="utf-8",
+                          errors="replace", creationflags=flags) as process:
+        tail = collections.deque(maxlen=40)
+        last_output = [time.monotonic()]
+        shown = {"stage": None, "tens": -1}
+
+        def pump():
+            for line in process.stdout:
+                line = line.rstrip()
+                if not line:
+                    continue
+                tail.append(line)
+                last_output[0] = time.monotonic()
+                percent = re.match(r"(.*?)(\d{1,3})%$", line)
+                if percent:
+                    stage, tens = percent.group(1), int(percent.group(2)) // 10
+                    if stage == shown["stage"] and tens <= shown["tens"]:
+                        continue
+                    shown.update(stage=stage, tens=tens)
+                if stream:
+                    print(f"{label}: {line}", flush=True)
+
+        reader = threading.Thread(target=pump, daemon=True)
+        reader.start()
+        started = noted = time.monotonic()
+        while process.poll() is None:
+            now = time.monotonic()
+            if now - last_output[0] > idle_s:
+                if os.name == "nt":
+                    subprocess.run(["taskkill", "/PID", str(process.pid), "/T", "/F"],
+                                   capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
+                else:
+                    process.kill()
+                process.wait(timeout=10)
+                raise RuntimeError(f"{label} stopped: no output for {idle_s}s; last output: {tail[-1] if tail else 'none'}")
+            if not stream and now - noted >= 30:
+                noted = now
+                print(f"{label}: waiting for {int(now - started)}s...", flush=True)
+            time.sleep(0.5)
+        reader.join(timeout=10)
+        if process.returncode:
+            if not stream:
+                for line in list(tail)[-15:]:
+                    print(f"{label}: {line}", flush=True)
+            raise RuntimeError(f"{label} failed (exit {process.returncode}): {tail[-1] if tail else 'no output'}")
 
 
 def _check():
@@ -159,6 +195,8 @@ def _check():
         "angular_parser":bool(node and ANGULAR_PARSER.is_file()),
         "browser_python": BROWSER_PYTHON.is_file(),
         "browser_packages": False,
+        "camoufox_browser": False,
+        "chromium_browser": False,
     }
     if status["browser_python"]:
         try:
@@ -169,9 +207,36 @@ def _check():
             status["browser_packages"] = result.returncode == 0
         except subprocess.TimeoutExpired:
             status["browser_packages"] = False
+    if status["browser_packages"]:
+        status.update(_browser_executables())
     return status
 
 
+_BROWSERS_PROBE = """
+import json, os
+from camoufox.pkgman import LAUNCH_FILE, OS_NAME, camoufox_path
+from playwright.sync_api import sync_playwright
+found = {}
+try:
+    found["camoufox_browser"] = os.path.isfile(os.path.join(camoufox_path(download_if_missing=False), LAUNCH_FILE[OS_NAME]))
+except Exception:
+    found["camoufox_browser"] = False
+with sync_playwright() as playwright:
+    found["chromium_browser"] = os.path.isfile(playwright.chromium.executable_path)
+print(json.dumps(found))
+"""
+
+
+def _browser_executables():
+    """Both browsers must exist on disk: a download tool reporting success is not enough."""
+    try:
+        result = subprocess.run([str(BROWSER_PYTHON), "-c", _BROWSERS_PROBE], capture_output=True, text=True,
+                                encoding="utf-8", errors="replace", check=False, timeout=60)
+        return json.loads(result.stdout.strip().splitlines()[-1])
+    except (subprocess.TimeoutExpired, ValueError, IndexError):
+        return {"camoufox_browser": False, "chromium_browser": False}
+
+
 def _link_existing_browser(existing, link):
     try:
         os.symlink(existing, link, target_is_directory=True)
@@ -199,7 +264,7 @@ def install(reuse_browser_runtime=None):
         node, npm = _node_commands()
     if not all(path.is_file() for path in (OPEN_WEBSEARCH_CLI,TYPESCRIPT_PARSER,JAVA_PARSER,ANGULAR_PARSER)):
         _run([npm, "ci", "--omit=dev", "--no-audit", "--no-fund"], cwd=NODE_DIR,
-             label="Web adapters and code parser via npm", timeout_s=300)
+             label="Web adapters and code parser via npm", idle_s=300)
     if reuse_browser_runtime:
         existing = Path(reuse_browser_runtime).expanduser().resolve()
         if not (existing / "Scripts" / "python.exe").is_file():
@@ -214,13 +279,13 @@ def install(reuse_browser_runtime=None):
     if not _check()["browser_packages"]:
         _run([str(BROWSER_PYTHON), "-m", "pip", "install", "--disable-pip-version-check",
               "--no-input", "-r", str(BROWSER_DIR / "requirements.txt")],
-             label="Camoufox and Crawl4AI via pip", timeout_s=600)
+             label="Camoufox and Crawl4AI via pip", idle_s=600)
     # Camoufox usa Firefox modificado; Crawl4AI usa Chromium via Playwright.
     if not reuse_browser_runtime:
-        _run([str(BROWSER_PYTHON), "-m", "camoufox", "fetch"],
-             label="Camoufox browser", timeout_s=600)
+        _run([str(BROWSER_PYTHON), str(BROWSER_DIR / "fetch_camoufox.py")], label="Camoufox browser (1.3 GB)",
+             idle_s=180, stream=True, attempts=3)
         _run([str(BROWSER_PYTHON), "-m", "playwright", "install", "chromium"],
-             label="Chromium browser", timeout_s=600)
+             label="Chromium browser", idle_s=180, stream=True, attempts=3)
     status = _check()
     if not all(status.values()):
         raise RuntimeError(f"Incomplete web runtime: {status}")
@@ -234,9 +299,10 @@ def main():
                         help="Reuse an existing venv without duplicating files (useful when disk is low)")
     args = parser.parse_args()
     if args.check:
-        for name, ready in _check().items():
+        status = _check()
+        for name, ready in status.items():
             print(f"{name}: {'ok' if ready else 'missing'}")
-        return 0 if all(_check().values()) else 1
+        return 0 if all(status.values()) else 1
     try:
         install(args.reuse_browser_runtime)
     except (OSError, RuntimeError, subprocess.SubprocessError) as exc:

package/integration_metrics.py

@@ -1,82 +1,82 @@
-import collections
-import json
-import os
-import paths
-import threading
-import time
-
-import atomic_io
-import router
-
-PATH = os.path.join(paths.DATA_DIR, "integration-metrics.jsonl")
-MAX_BYTES = 20 * 1024 * 1024
-_LOCK = threading.Lock()
-
-
-def record(event, **fields):
-    line = json.dumps({"ts": time.time(), "event": event, **fields}, ensure_ascii=False)
-    with _LOCK:
-        os.makedirs(os.path.dirname(PATH), exist_ok=True)
-        atomic_io.rotate(PATH, MAX_BYTES)
-        with open(PATH, "a", encoding="utf-8") as stream:
-            stream.write(line + "\n")
-
-
-def _read(path, since):
-    rows = []
-    for candidate in (path + ".1", path):
-        try:
-            with open(candidate, encoding="utf-8") as stream:
-                for line in stream:
-                    try:
-                        row = json.loads(line)
-                    except ValueError:
-                        continue
-                    if isinstance(row, dict) and isinstance(row.get("ts"), (int, float)) and row["ts"] >= since:
-                        rows.append(row)
-        except FileNotFoundError:
-            continue
-    return rows
-
-
-def summary(days=7):
-    since = time.time() - days * 86400
-    events = _read(PATH, since)
-    by_client = collections.defaultdict(collections.Counter)
-    reasons, rejects = collections.Counter(), collections.Counter()
-    for row in events:
-        by_client[row.get("client") or "desconhecido"][row.get("event", "?")] += 1
-        if row.get("event") == "search" and row.get("single_language_reason"):
-            reasons[row["single_language_reason"][:120]] += 1
-        if row.get("event") == "reject":
-            rejects[row.get("kind", "outro")] += 1
-    web = [row for row in events if row.get("event") == "web_search"]
-    origin = lambda row: "error" if row.get("error") else row.get("cache", "?")
-    by_cache = collections.Counter(origin(row) for row in web)
-    elapsed = collections.defaultdict(list)
-    for row in web:
-        if isinstance(row.get("elapsed_s"), (int, float)):
-            elapsed[origin(row)].append(row["elapsed_s"])
-    reused = sum(count for status, count in by_cache.items() if status not in ("fresh", "error"))
-    web_cache = {
-        "calls": len(web), "reused": reused, "reuse_rate": round(reused / len(web), 3) if web else None,
-        "by_cache": dict(by_cache),
-        "probes": sum(1 for row in web if row.get("probe")),
-        "probe_verdicts": dict(collections.Counter(row["verdict"] for row in web if row.get("verdict"))),
-        "errors": dict(collections.Counter(row["error"] for row in web if row.get("error"))),
-        "reused_volatility": dict(collections.Counter(row.get("volatility") or "?" for row in web
-                                                      if origin(row) not in ("fresh", "error"))),
-        "bilingual": sum(1 for row in web if row.get("bilingual")),
-        "degraded": sum(1 for row in web if row.get("degraded")),
-        "with_warnings": sum(1 for row in web if row.get("warnings")),
-        "avg_elapsed_s": {status: round(sum(values) / len(values), 2) for status, values in elapsed.items()},
-    }
-    routed = _read(router.METRICS_PATH, since)
-    decisions = collections.defaultdict(collections.Counter)
-    for row in routed:
-        decisions[row.get("client") or "no client"][row.get("decision", "?")] += 1
-    return {"days": days, "events_by_client": {k: dict(v) for k, v in by_client.items()},
-            "rejects_by_kind": dict(rejects), "single_language_reasons": dict(reasons.most_common(20)),
-            "hook_decisions_by_client": {k: dict(v) for k, v in decisions.items()},
-            "web_search_cache": web_cache,
-            "files": {"integration": PATH, "router": router.METRICS_PATH}}
+import collections
+import json
+import os
+import paths
+import threading
+import time
+
+import atomic_io
+import router
+
+PATH = os.path.join(paths.DATA_DIR, "integration-metrics.jsonl")
+MAX_BYTES = 20 * 1024 * 1024
+_LOCK = threading.Lock()
+
+
+def record(event, **fields):
+    line = json.dumps({"ts": time.time(), "event": event, **fields}, ensure_ascii=False)
+    with _LOCK:
+        os.makedirs(os.path.dirname(PATH), exist_ok=True)
+        atomic_io.rotate(PATH, MAX_BYTES)
+        with open(PATH, "a", encoding="utf-8") as stream:
+            stream.write(line + "\n")
+
+
+def _read(path, since):
+    rows = []
+    for candidate in (path + ".1", path):
+        try:
+            with open(candidate, encoding="utf-8") as stream:
+                for line in stream:
+                    try:
+                        row = json.loads(line)
+                    except ValueError:
+                        continue
+                    if isinstance(row, dict) and isinstance(row.get("ts"), (int, float)) and row["ts"] >= since:
+                        rows.append(row)
+        except FileNotFoundError:
+            continue
+    return rows
+
+
+def summary(days=7):
+    since = time.time() - days * 86400
+    events = _read(PATH, since)
+    by_client = collections.defaultdict(collections.Counter)
+    reasons, rejects = collections.Counter(), collections.Counter()
+    for row in events:
+        by_client[row.get("client") or "desconhecido"][row.get("event", "?")] += 1
+        if row.get("event") == "search" and row.get("single_language_reason"):
+            reasons[row["single_language_reason"][:120]] += 1
+        if row.get("event") == "reject":
+            rejects[row.get("kind", "outro")] += 1
+    web = [row for row in events if row.get("event") == "web_search"]
+    origin = lambda row: "error" if row.get("error") else row.get("cache", "?")
+    by_cache = collections.Counter(origin(row) for row in web)
+    elapsed = collections.defaultdict(list)
+    for row in web:
+        if isinstance(row.get("elapsed_s"), (int, float)):
+            elapsed[origin(row)].append(row["elapsed_s"])
+    reused = sum(count for status, count in by_cache.items() if status not in ("fresh", "error"))
+    web_cache = {
+        "calls": len(web), "reused": reused, "reuse_rate": round(reused / len(web), 3) if web else None,
+        "by_cache": dict(by_cache),
+        "probes": sum(1 for row in web if row.get("probe")),
+        "probe_verdicts": dict(collections.Counter(row["verdict"] for row in web if row.get("verdict"))),
+        "errors": dict(collections.Counter(row["error"] for row in web if row.get("error"))),
+        "reused_volatility": dict(collections.Counter(row.get("volatility") or "?" for row in web
+                                                      if origin(row) not in ("fresh", "error"))),
+        "bilingual": sum(1 for row in web if row.get("bilingual")),
+        "degraded": sum(1 for row in web if row.get("degraded")),
+        "with_warnings": sum(1 for row in web if row.get("warnings")),
+        "avg_elapsed_s": {status: round(sum(values) / len(values), 2) for status, values in elapsed.items()},
+    }
+    routed = _read(router.METRICS_PATH, since)
+    decisions = collections.defaultdict(collections.Counter)
+    for row in routed:
+        decisions[row.get("client") or "no client"][row.get("decision", "?")] += 1
+    return {"days": days, "events_by_client": {k: dict(v) for k, v in by_client.items()},
+            "rejects_by_kind": dict(rejects), "single_language_reasons": dict(reasons.most_common(20)),
+            "hook_decisions_by_client": {k: dict(v) for k, v in decisions.items()},
+            "web_search_cache": web_cache,
+            "files": {"integration": PATH, "router": router.METRICS_PATH}}