@allansantos-dev/smart-tool 0.9.43 → 0.9.46

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## 0.9.46 - beta
+
+- The interface speaks Portuguese and English. It follows the Windows display language (any Portuguese shows Brazilian
+  Portuguese, anything else English) until the user picks one: a globe button (PT/EN) in the header of the settings,
+  projects and map pages, and an "Idioma / Language" submenu in the tray, both saved as `language` in the config. The
+  settings and projects pages, including the text their scripts write, the tray menu, tooltip and notifications, the
+  Windows toasts, the folder picker and the update screen are translated; agent-facing text (tool answers, hook
+  messages) stays English. English is the catalog key (`locales/pt-BR.json`, read by `i18n.py`); the pages translate
+  their rendered text in the browser, and `tests/test_i18n.py` fails when a visible string has no entry.
+- Updating never opens a console window. "Check for updates" now says "Checking for updates…" in a Windows notification,
+  and an update shows its own small window with no buttons (`update_splash.py`): the version change, the current step
+  (downloading, copying files, installing dependencies…) and the result, in the interface language. The install command
+  runs with no console, so npm, the installer, pip, PowerShell and schtasks share one hidden console; its output goes to
+  `~/.smart-tool/data/update.log`, and a failed update says so on the screen and in a toast with the log path.
+- The tray menu no longer flashes console windows when it opens: its "Start with Windows" check ran `schtasks` from the
+  window-less tray without `CREATE_NO_WINDOW`.
+- The tray tells "Smart Tool updated from X to Y" also when the daemon started first after the update: both record the
+  new running version, and the tray keeps its own marker (`tray_told`) instead of needing to be the one that found it.
+
+## 0.9.45 - beta
+
+- The Playwright MCP server starts on first use. What the clients register is now `lazy_mcp_proxy.py` around
+  the real command: it answers `initialize`, `ping` and `tools/list` from the handshake the setup probe saved
+  (`playwright-mcp-handshake.json`) and starts the Node server on the first other request, replaying the client's
+  handshake to it, then passes everything through and kills the server's process tree when the client closes. Before, each
+  Claude session started its own Node server (about 97 MB of commit) whether or not it opened a browser. A missing or
+  broken cache fails loudly (exit 2, reason on stderr), never as an empty tool list; the heal at startup also checks the
+  real server's executable. Tests in `tests/test_lazy_mcp_proxy.py` and `tests/test_browser_control.py`.
+- Web searches record who asked. Each provider call (`web-search-health.jsonl`) and each research record
+  (`research-metrics.jsonl`) carries `requester` (`client`, `mcp_session`, `session`, `project`, `source`): the PreToolUse
+  hook, which gets the Claude Code session and folder, now also matches `web_search` and `web_fetch`, and the MCP call
+  claims that note by tool and arguments. Without the hook (Codex, or a hook not yet updated) only the client and the MCP
+  session are known and `source` is `none`. A redirected native WebSearch/WebFetch is attributed from the hook payload,
+  and `integration-metrics.jsonl` carries the same field. The query text is stored nowhere new. Tests in
+  `tests/test_requester.py`. The startup heal also rebuilds a registration that still starts the Node server directly or
+  whose handshake cache is gone, and the proxy gives up on a real server silent for 60 s on its first `initialize`.
+- The resident search browser's exit after 300 s without requests is now covered by a test that runs the real service
+  loop with a stub browser (`tests/test_browser_idle.py`); the value is unchanged.
+
+## 0.9.44 - beta
+
+- New tool `read_document`: a PDF, Word, PowerPoint or Excel file read as compact text, a range at a time. The answer opens
+  with the type, size, page, slide, sheet or part count and the estimated tokens of all the text, then the text of the
+  `range` asked for (`3`, `3-5`, `7-`, `-4`, `1,4-6`, a sheet name) up to `max_chars`, with a `next:` line to continue;
+  `info_only` returns just the facts. PDF pages are compacted (ligatures, hyphenated line ends, wrapped lines); a docx is
+  markdown (headings, lists, GFM tables, notes, headers) in parts of about 6,000 characters, since it has no fixed pages;
+  a slide carries its speaker notes; a sheet is one tab-separated line per row with cached formula values. A scanned PDF,
+  a password, a corrupt or hostile file and a range outside the document fail with the reason. Opt-in: the native Read is
+  not redirected and the tool is not loaded upfront (the server instructions say to load it with ToolSearch). No new
+  dependency; the extractors of the index now return their units (`pdf_pages`, `pptx_slides`, `xlsx_sheets`) and the
+  indexed text is unchanged. Sources and the measurement in `docs/research/2026-10-30-read-document.md`; tests in
+  `tests/test_read_document.py`.
+
 ## 0.9.43 - beta
 
 - The session-start audit report (Claude Code and Codex) is also given after a compaction and after a fork, the two

package/README.md

@@ -8,6 +8,7 @@ A local MCP server that gives coding agents (Claude Code, Codex) cheaper, sharpe
 | `smart_scout` | Answers a question about the code with the lines that answer it: reads the candidate files inside Smart Tool and returns `path:lines` with the literal text, so the files never enter the agent's context; with a `scout_model`, a small model also writes a short answer and keeps only the lines that support it; a question about why something is as it is (why, reason, decided) also lists up to three decision notes from the notes the project keeps about its intent, as ids with one excerpt each |
 | `web_search` / `web_search_result` | Web search across several sources in parallel, in the query language and in English, with a cache shared across sessions; `depth="research"` runs a multi-round research loop |
 | `web_fetch` | Reads a known URL and returns only the answer to your prompt, written by a small model; pages are cached for 24 h. Pages over 60,000 characters are not cut: the model reads the parts closest to the prompt (needs an `embedding_model`) |
+| `read_document` | Reads a PDF, Word, PowerPoint or Excel file as compact text, a range at a time: type, size, page/slide/sheet count and estimated tokens first, then only the pages, slides or sheets asked for (`range="3-5"`), so the file never enters the agent's context whole. Opt-in: the native Read is not redirected. Scanned PDFs fail with that reason (no OCR) |
 | `project_manage` | Registers and indexes projects, shows coverage, code maps, duplicated functions and index storage; `graph` with `symbol` tells what changing a function touches: callers, calls, the tests that reach it and the files that import it |
 
 Agents that must click, type or log in also get Microsoft's [Playwright MCP](https://github.com/microsoft/playwright-mcp),
@@ -16,7 +17,7 @@ registered as the `playwright` server where this machine lets a browser be drive
 An optional hook routes the agent's native Grep/Glob/Read/Bash/WebSearch/WebFetch calls to these tools when they
 are cheaper, or just tells the agent what Smart Tool would do.
 
-**Status:** 0.9.43 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
+**Status:** 0.9.46 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
 
 ## How it works
 
@@ -86,12 +87,17 @@ npx @allansantos-dev/smart-tool@latest install
 ```
 
 Updates install themselves, on by default: the tray checks npm when it starts (at logon) and every 24 h, and when there
-is a newer version it runs this same command in a visible console (once per version; a failed version is tried again
-after 24 h, with the previous version kept). You are told each time: a Windows notification from the tray (newer version,
+is a newer version it runs this same command behind its own small update window, with no console window (once per
+version; a failed version is tried again after 24 h, with the previous version kept). The window has no buttons: it shows
+the version change, the current step and the result, and closes by itself; the command's output is kept in
+`~/.smart-tool/data/update.log`. You are told each time: a Windows notification from the tray (newer version,
 updating, updated, update failed), and agent sessions get the same line on their first `smart_search` (and at session
 start when the SessionStart report is on, shown to you too) with the link to the changes. The tray menu has "Update to
 X" (or "Check for updates") on demand and an "Update automatically" switch; `SMART_TOOL_AUTO_UPDATE=off` also turns
-automatic updates off, and the newer-version notice then carries the command to run. Running the command by hand also updates; `~/.smart-tool` is kept. It downloads [uv](https://docs.astral.sh/uv/) (checksum
+automatic updates off, and the newer-version notice then carries the command to run. The interface (tray, notifications,
+settings and projects pages, update window) is in Brazilian Portuguese or English: it follows the Windows display
+language until you pick one with the globe button (PT/EN) at the top of the pages or the tray's "Idioma / Language"
+submenu. Running the command by hand also updates; `~/.smart-tool` is kept. It downloads [uv](https://docs.astral.sh/uv/) (checksum
 verified) and a private Python 3.12 into `~/.smart-tool/runtime`, with nothing added to `PATH` and, in the registry, only two per-user (HKCU) keys that make the notification buttons work, then
 copies Smart Tool to `%LOCALAPPDATA%\Programs\SmartTool` with its own virtual environment,
 installs the web runtime, registers a per-user Scheduled Task that starts the tray at logon and starts the daemon on
@@ -149,7 +155,21 @@ Redirects) and Maintenance (Setup audit, Startup).
    `browser_run_code_unsafe`, which runs arbitrary JavaScript in the server process, is denied in the client
    (`permissions.deny` in `~/.claude/settings.json`, `disabled_tools` in `~/.codex/config.toml`); if it cannot be
    denied, the server is not registered. A `playwright` server you registered yourself is never touched. Remove it with
-   `claude mcp remove playwright -s user` / `codex mcp remove playwright`.
+   `claude mcp remove playwright -s user` / `codex mcp remove playwright`. The registered command is a small stdio
+   proxy (`lazy_mcp_proxy.py`, standard library only) that answers the handshake and the tool list from a cache the
+   probe writes and starts the Node server on the first tool call, so a session that never opens a browser does not
+   keep a 97 MB Node process; it ends with the session.
+
+   **Who asked for a web search**: every provider call in `~/.smart-tool/data/web-search-health.jsonl` and every
+   record of `research-metrics.jsonl` made for a `web_search` carries `requester`: `client`, `mcp_session` (first 12
+   characters of the daemon's session id), `session` and `project` (the Claude Code session id and folder) and `source`
+   (`hook`: the PreToolUse hook saw this call; `mcp-session`: an earlier call of the same MCP session was attributed;
+   `none`: only the client name is known, which is what Codex gives, since its hook does not cover MCP tools). The
+   query text is not stored there. The folder and session come from the installed hook: after an update, "Update hook"
+   on the setup page adds `web_search` and `web_fetch` to its matcher. A native WebSearch or WebFetch that the hook
+   redirects is attributed from the hook payload itself (`mcp_session` empty). `integration-metrics.jsonl` carries the
+   same `requester` on the web events. A `deep` crawl job writes no provider record, so it has none. The hook's note
+   waits up to 60 s for its MCP call; an identical query from two sessions at once can swap their notes.
 
    The hook behaviors:
    - **Redirect** (default): the call is not denied. Smart Tool answers it and the answer comes back as the output

package/autostart.py

@@ -14,6 +14,8 @@ import tempfile
 import toast_notice
 
 TASK_NAME = os.environ.get("SMART_TOOL_TASK_NAME", "SmartTool-Tray")
+# The tray runs under pythonw (no console): schtasks without this flag flashed a console each time its menu was drawn.
+_NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0)
 
 
 class AutostartError(Exception):
@@ -138,7 +140,7 @@ def _task_installed():
     try:
         result = subprocess.run(
             ["schtasks", "/Query", "/TN", TASK_NAME],
-            capture_output=True, text=True, timeout=20,
+            capture_output=True, text=True, timeout=20, creationflags=_NO_WINDOW,
         )
     except (OSError, subprocess.SubprocessError):
         return False
@@ -159,7 +161,7 @@ def install():
                 f.write(xml.encode("utf-16"))
             result = subprocess.run(
                 ["schtasks", "/Create", "/TN", TASK_NAME, "/XML", tmp_path, "/F"],
-                capture_output=True, text=True, timeout=20,
+                capture_output=True, text=True, timeout=20, creationflags=_NO_WINDOW,
             )
         finally:
             try:
@@ -182,7 +184,7 @@ def remove():
     try:
         result = subprocess.run(
             ["schtasks", "/Delete", "/TN", TASK_NAME, "/F"],
-            capture_output=True, text=True, timeout=20,
+            capture_output=True, text=True, timeout=20, creationflags=_NO_WINDOW,
         )
         if result.returncode == 0:
             removed.append("task")

package/browser_control.py

@@ -7,6 +7,10 @@ as the agent would: machines whose policy forbids it (corporate IT blocking remo
 keep today's read-only behavior, and the reason is shown in the setup screen instead of an error. A server named
 `playwright` the user already registered is left untouched.
 
+The registered command is lazy_mcp_proxy.py around the real server: every session starts the registered servers, and
+a Node process kept idle in each session that never opens a browser cost about 97 MB of commit each. The proxy answers
+the handshake from the cache the probe writes (HANDSHAKE_PATH) and starts the real server on the first tool call.
+
 Pages the agent opens are untrusted input. The server never exposes tools a page registers (WebMCP); every request
 the browser makes carries AGENT_HEADER, which the daemon refuses, so a page cannot steer the agent into Smart Tool's
 own setup page and its token (redirects included); `browser_run_code_unsafe` (arbitrary JavaScript in the server
@@ -18,6 +22,7 @@ import os
 import queue
 import re
 import subprocess
+import sys
 import tempfile
 import threading
 import time
@@ -26,6 +31,7 @@ import tomllib
 import atomic_io
 import endpoint_sync
 import install_runtime
+import lazy_mcp_proxy
 import node_locator
 import paths
 
@@ -34,6 +40,8 @@ CLI = install_runtime.PLAYWRIGHT_MCP_CLI
 STATUS_PATH = os.path.join(paths.DATA_DIR, "browser-control.json")
 OUTPUT_DIR = os.path.join(paths.DATA_DIR, "playwright-mcp")
 CONFIG_PATH = os.path.join(paths.DATA_DIR, "playwright-mcp.json")
+HANDSHAKE_PATH = os.path.join(paths.DATA_DIR, "playwright-mcp-handshake.json")
+PROXY = os.path.join(os.path.dirname(os.path.abspath(__file__)), "lazy_mcp_proxy.py")
 AGENT_HEADER = "X-Smart-Tool-Agent-Browser"
 OUTPUT_MAX_BYTES = 100 * 1024 * 1024
 PROBE_TIMEOUT_S = 60
@@ -68,6 +76,15 @@ def server_command():
             "--output-max-size", str(OUTPUT_MAX_BYTES)]
 
 
+def lazy_command(command):
+    """The command registered in the clients: lazy_mcp_proxy.py (console Python of this installation) around command,
+    the real server line, answering from HANDSHAKE_PATH until a tool call needs the real one."""
+    python = sys.executable
+    if os.path.basename(python).lower() == "pythonw.exe":
+        python = os.path.join(os.path.dirname(python), "python.exe")
+    return [python, PROXY, "--handshake", HANDSHAKE_PATH, "--", *command]
+
+
 def write_config():
     """Writes the Playwright MCP config file that adds AGENT_HEADER to every request of the browser (navigations,
     redirects, subresources; measured: no CORS preflight is added) and returns its path."""
@@ -77,14 +94,16 @@ def write_config():
     return CONFIG_PATH
 
 
-def probe(command, timeout=PROBE_TIMEOUT_S):
+def probe(command, timeout=PROBE_TIMEOUT_S, handshake_path=None):
     """Starts the server over stdio, opens about:blank and closes it, as an agent's first call would.
-    Returns None when the browser opened, else the reason it did not (a policy block, a crash, a timeout)."""
+    Returns None when the browser opened, else the reason it did not (a policy block, a crash, a timeout). With
+    handshake_path, a successful probe also saves the server's initialize result and tool list there, the cache
+    lazy_mcp_proxy answers from."""
     with tempfile.TemporaryDirectory(prefix="st-browser-probe-", ignore_cleanup_errors=True) as workdir:
-        return _probe(command, workdir, timeout)
+        return _probe(command, workdir, timeout, handshake_path)
 
 
-def _probe(command, workdir, timeout):
+def _probe(command, workdir, timeout, handshake_path=None):
     """probe() inside workdir, the server's working folder."""
     flags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
     try:
@@ -118,14 +137,20 @@ def _probe(command, workdir, timeout):
                 return message["result"]
 
     try:
-        call(1, "initialize", {"protocolVersion": "2025-06-18", "capabilities": {},
-                               "clientInfo": {"name": "smart-tool-probe", "version": "1"}})
+        initialized = call(1, "initialize", {"protocolVersion": "2025-06-18", "capabilities": {},
+                                             "clientInfo": {"name": "smart-tool-probe", "version": "1"}})
         proc.stdin.write(json.dumps({"jsonrpc": "2.0", "method": "notifications/initialized"}) + "\n")
+        tools = call(4, "tools/list", {}).get("tools") if handshake_path else None
         result = call(2, "tools/call", {"name": "browser_navigate", "arguments": {"url": "about:blank"}})
         if result.get("isError"):
             text = " ".join(part.get("text", "") for part in result.get("content") or [])
             return f"browser did not open: {' '.join(text.split())[:300]}"
         call(3, "tools/call", {"name": "browser_close", "arguments": {}})
+        if handshake_path:
+            if not tools:
+                return "the server listed no tools"
+            os.makedirs(os.path.dirname(handshake_path), exist_ok=True)
+            atomic_io.write_secret_text(handshake_path, json.dumps({"initialize": initialized, "tools": tools}))
         return None
     except (OSError, RuntimeError, TimeoutError) as exc:
         return str(exc)
@@ -158,8 +183,9 @@ def registered():
     return found
 
 
-def registered_command(client):
-    """Executable the client's `playwright` server is registered with, or None when it is not registered."""
+def registered_executables(client):
+    """Executables the client's `playwright` server needs: the registered command and, behind lazy_mcp_proxy, the real
+    server's too; an empty list when it is not registered."""
     try:
         if client == "claude":
             with open(endpoint_sync.claude_json(), encoding="utf-8") as stream:
@@ -168,9 +194,32 @@ def registered_command(client):
             with open(_codex_config(), encoding="utf-8") as stream:
                 entry = (tomllib.loads(stream.read()).get("mcp_servers") or {}).get(SERVER)
     except (OSError, ValueError, AttributeError):
-        return None
+        return []
     command = entry.get("command") if isinstance(entry, dict) else None
-    return command if isinstance(command, str) else None
+    if not isinstance(command, str):
+        return []
+    args = entry.get("args") if isinstance(entry.get("args"), list) else []
+    real = args[args.index("--") + 1] if "--" in args and args.index("--") + 1 < len(args) else None
+    return [command] + ([real] if isinstance(real, str) else [])
+
+
+def _lazy_registration_usable(client):
+    """Whether the client's registration goes through lazy_mcp_proxy and the handshake cache it answers from is
+    readable: a registration of an older version (the Node server directly) or a lost cache both need ensure."""
+    try:
+        if client == "claude":
+            with open(endpoint_sync.claude_json(), encoding="utf-8") as stream:
+                entry = (json.load(stream).get("mcpServers") or {}).get(SERVER)
+        else:
+            with open(_codex_config(), encoding="utf-8") as stream:
+                entry = (tomllib.loads(stream.read()).get("mcp_servers") or {}).get(SERVER)
+        args = entry.get("args") or []
+        if PROXY not in args:
+            return False
+        lazy_mcp_proxy.load_handshake(HANDSHAKE_PATH)
+    except (OSError, ValueError, AttributeError, RuntimeError):
+        return False
+    return True
 
 
 def heal(log=None):
@@ -179,9 +228,10 @@ def heal(log=None):
     {client: ensure's outcome} for the clients refreshed."""
     refreshed = {}
     for client in ("claude", "codex"):
-        command = registered_command(client)
+        executables = registered_executables(client)
         ours = status().get(client, {}).get("state") in ("registered", "undenied")
-        if ours and command and not node_locator.exists(command):
+        if ours and executables and not (all(node_locator.exists(path) for path in executables)
+                                         and _lazy_registration_usable(client)):
             refreshed[client] = ensure(client, log)
     return refreshed
 
@@ -302,6 +352,12 @@ def _record(client, state, reason="", log=None):
     return data[client]
 
 
+def _clip(text, limit=300):
+    """text within limit characters, keeping its start and its end: a failed CLI call names the long command first and
+    the CLI's own message last."""
+    return text if len(text) <= limit else text[:limit // 3] + " ... " + text[-(limit - limit // 3 - 5):]
+
+
 def ensure(client, log=None):
     """Registers Playwright MCP in the client, or refreshes the registration Smart Tool made before (Node, Chromium
     and install paths change between versions). A `playwright` server the user registered is kept. When the browser
@@ -315,7 +371,7 @@ def ensure(client, log=None):
         return _record(client, "kept", "a playwright MCP server you registered is kept")
     try:
         command = server_command()
-        problem = probe(command)
+        problem = probe(command, handshake_path=HANDSHAKE_PATH)
     except (OSError, RuntimeError, subprocess.SubprocessError) as exc:
         problem = str(exc)
     try:
@@ -325,7 +381,7 @@ def ensure(client, log=None):
             if ours and client == "claude":
                 set_claude_deny(False)
             return _record(client, "unavailable", problem[:300], log)
-        endpoint_sync.run_cli(register_command(client, command))
+        endpoint_sync.run_cli(register_command(client, lazy_command(command)))
         if not registered().get(client):
             return _record(client, "unavailable", "the client CLI finished, but the server did not appear in its "
                            "configuration", log)
@@ -342,5 +398,5 @@ def ensure(client, log=None):
     except (OSError, RuntimeError, ValueError) as exc:
         # Our registration still in place after a failure (its removal failed) stays ours, flagged, never "kept".
         state = "undenied" if ours and registered().get(client) else "unavailable"
-        return _record(client, state, str(exc)[:300], log)
+        return _record(client, state, _clip(str(exc)), log)
     return _record(client, "registered")

package/client_hooks.py

@@ -29,7 +29,7 @@ HOME = os.path.expanduser("~")
 PREVIEW_TTL_S = 600
 CLIENTS = {
     "claude": {"label": "Claude Code", "names": {"claude-code"}, "files": [os.path.join(endpoint_sync.claude_dir(), "settings.json")],
-               "docs": "https://code.claude.com/docs/en/hooks", "event": "PreToolUse", "matcher": "Grep|Glob|Read|Bash|PowerShell|WebSearch|WebFetch|Edit|MultiEdit|Write|mcp__smart-tool__smart_search", "http": True,
+               "docs": "https://code.claude.com/docs/en/hooks", "event": "PreToolUse", "matcher": "Grep|Glob|Read|Bash|PowerShell|WebSearch|WebFetch|Edit|MultiEdit|Write|mcp__smart-tool__smart_search|mcp__smart-tool__web_search|mcp__smart-tool__web_fetch", "http": True,
                "post_matcher": "Grep|Bash|PowerShell|WebFetch|WebSearch"},
     "codex": {"label": "Codex", "prefix": "codex", "files": [os.path.join(endpoint_sync.codex_dir(), "hooks.json"), os.path.join(endpoint_sync.codex_dir(), "config.toml")],
               "docs": "https://learn.chatgpt.com/docs/hooks", "event": "PreToolUse", "matcher": "Bash|apply_patch",
@@ -120,7 +120,7 @@ def _entry_changes(event, matcher, expected, groups):
     covered = str(group.get("matcher") or "").split("|")
     left_out = [tool for tool in matcher.split("|") if tool not in covered]
     if left_out:
-        changes.append(f"Its {event} entry does not cover " + ", ".join(left_out) + ".")
+        changes.append(f"Its {event} entry does not cover {', '.join(left_out)}.")
     found = next(hook for hook in group["hooks"] if _our_hook(hook))
     if _target(found) != _target(expected):
         changes.append(f"It calls {_target(found)} instead of {_target(expected)}.")

package/config.py

@@ -39,6 +39,7 @@ DEFAULT_CONFIG = {
     "duplicate_mode": "warn",
     "dependency_mode": "warn",
     "auto_update": True,
+    "language": "",
     "pattern_proposals": "on",
     "contact": "",
     "model_adapter": "",
@@ -132,6 +133,17 @@ def auto_update(cfg=None):
     return value
 
 
+LANGUAGES = ("pt-BR", "en")
+
+
+def language(cfg=None):
+    """Interface language the user picked ("pt-BR" or "en"), or "" to follow the Windows display language."""
+    value = (cfg if cfg is not None else load_config()).get("language", DEFAULT_CONFIG["language"])
+    if value not in ("", *LANGUAGES):
+        raise ValueError(f"Invalid language ({value!r}) in {CONFIG_PATH}: use one of {', '.join(LANGUAGES)} or \"\".")
+    return value
+
+
 def hook_mode(cfg=None):
     value = (cfg if cfg is not None else load_config()).get("hook_mode") or DEFAULT_CONFIG["hook_mode"]
     if value not in HOOK_MODES: