@allansantos-dev/smart-tool 0.9.32 → 0.9.33

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.9.33 - beta
+
+- Recommended models prefer the Vertex route. When the gateway lists a model on several routes, `model_defaults` now
+  picks `vertex_ai.*` first, any other route next and `bedrock.*` only when nothing else serves the model (Bedrock was
+  chosen before because ids were taken in alphabetical order). `DEFAULTS_VERSION` is 2, so users who already hold the
+  Bedrock ids get the "New recommended models" offer again and decide whether to apply it.
+- `tests/vertex_route_probe.py` asks the live gateway: every recommended chat id must resolve (Anthropic ones on
+  Vertex) and answer a real request. Result of 2026-10-26 in `docs/research/2026-10-26-rota-vertex-nas-recomendacoes.md`.
+
 ## 0.9.32 - beta
 
 - Users who updated are told about the new recommended models. `model_upgrade` compares the saved `router_model`,

package/README.md

@@ -16,7 +16,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.32 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
+**Status:** 0.9.33 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
 
 ## How it works
 
@@ -111,8 +111,18 @@ Redirects) and Maintenance (Setup audit, Startup).
    URL ending where the API starts, like the OpenAI SDK `base_url` (`https://api.openai.com/v1`,
    `https://openrouter.ai/api/v1`, `http://localhost:11434/v1`), and an optional API key. Saving tests `/models` first.
 2. **Models**: embedding, rerank (optional; without it results use the hybrid order), the router model (small, no
-   reasoning: web search tier order and result checks), the index classification model (also reviews block patterns) and the research model. Any id the gateway
-   accepts works; the catalog is shown as suggestions.
+   reasoning: web search tier order and result checks), the index classification model (also reviews block patterns), the
+   scout model (the short answer of `smart_scout`) and the research model. Any id the gateway accepts works; the catalog is
+   shown as suggestions. Empty roles are filled with the recommended models the gateway offers.
+
+   When a new version recommends other models than the ones you use, a Windows notification (**Apply now**, **Don't
+   show again**) and the **New recommended models** card on this page offer them: nothing changes until you apply, the
+   models you had are kept, and **Switch back to my previous models** undoes it. The **Model failures (last 24 h)** table
+   lists every failed gateway call by role, model and tool; a model that fails half of its calls (5 or more) also raises a
+   notification and a tray alert. A failure inside a tool call also comes back as a warning line in the tool answer;
+   calls made by a hook or by background work (index scope and profile, block-pattern proposals) have no answer to
+   carry it, so they show only in the table, the log and the notification. The local embedder is not in that table or in
+   the usage meter: it is a sidecar on your machine with no price, and its state is the **Local models** section.
 3. **Agents**: register the MCP server in Claude Code or Codex (runs their official `mcp add` command), install the
    hook and choose its behavior under **Agent rules**. A hook written by an older Smart Tool shows as outdated, with
    what an update changes; updating previews the entry and rewrites only Smart Tool's, after a backup.
@@ -177,11 +187,13 @@ Redirects) and Maintenance (Setup audit, Startup).
    plus changed tests and tests using a pytest fixture whose `conftest.py` imports the changed code, ordered with the
    likeliest failures first, and the command to run them. Changed files are read from disk, so new files and imports
    count before the project is reindexed. `run_all` is true, with
-   the reason, when a configuration or lockfile changed or a changed code file is outside the import graph.
+   the reason, when a configuration or lockfile changed or a changed code file is outside the import graph. Go is read
+   by package: a file that imports a package depends on every file of it, so a changed package selects the tests of every
+   package that imports it (`go test ./pkg ...`); the Go and Rust documentation and duplicate hooks stay silent.
 
    `project_manage` with `action=setup_audit` and a `project_root` (or `python setup_audit.py --project <folder>`)
-   reports what Claude Code and Codex actually load for that folder (settings layers, enabled plugins, hooks, MCP
-   servers, skills, CLAUDE.md and AGENTS.md) and where they collide: several hooks deciding on the same tool in
+   reports what Claude Code and Codex actually load for that folder (settings layers, enabled plugins of both,
+   hooks, MCP servers, skills, CLAUDE.md and AGENTS.md) and where they collide: several hooks deciding on the same tool in
    parallel, hook scripts that do not exist or hide their errors, hooks calling an MCP server that is not configured,
    MCP servers that do not start or offer the same tools twice (a gateway re-exposing a server also registered
    directly), skills sharing a name or over the description budget, an AGENTS.md only Codex reads, broken `@imports`

package/affected_tests.py

@@ -22,7 +22,7 @@ RUN_ALL = re.compile(
     r"bun\.lockb?|pyproject\.toml|setup\.cfg|setup\.py|pytest\.ini|tox\.ini|requirements[^/]*\.txt|poetry\.lock|"
     r"uv\.lock|Pipfile(\.lock)?|tsconfig[^/]*\.json|jsconfig\.json|(jest|vitest|vite|babel)\.config\.[^/]+|"
     r"\.babelrc|\.mocharc[^/]*|pom\.xml|build\.gradle(\.kts)?|settings\.gradle(\.kts)?|gradle\.properties|"
-    r"\.env[^/]*)$")
+    r"\.env[^/]*|go\.(mod|sum|work(\.sum)?))$")
 CI_CONFIG = re.compile(r"(^|/)(\.github|\.circleci|\.buildkite)/|(^|/)(\.gitlab-ci\.ya?ml|azure-pipelines\.ya?ml|"
                        r"Jenkinsfile|\.travis\.ya?ml|bitbucket-pipelines\.ya?ml|\.gitignore|\.gitattributes|"
                        r"\.editorconfig|\.mailmap|CODEOWNERS|LICENSE(\.[^/]*)?|\.npmignore)$")
@@ -31,7 +31,7 @@ NOTE = ("Selection from the indexed import graph: tests that load code through s
         "suite before committing; run_all is true when a changed file can change every test (config, lockfile, "
         "unanalyzed code). Changed files and files committed after the last indexing are read from disk, so new "
         "files and imports count before reindexing; pytest fixtures link a test to the conftest.py that defines them.")
-TEST_SOURCES = (".py", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts", ".java")
+TEST_SOURCES = (".py", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts", ".java", ".go")
 _PATH_LITERAL = re.compile(r"""['"`]((?:\.{0,2}/)?[\w.-]+(?:/[\w.-]+)*\.(?:py|js|mjs|cjs|ts|mts|cts|java))['"`]""")
 _STRING_LITERAL = re.compile(r"""'([^'\n]*)'|"([^"\n]*)\"""")
 _IMPORT_STATEMENT = re.compile(r"(?:^|;)\s*(?:import|from)\s+([A-Za-z_]\w*(?:\.\w+)*)")
@@ -132,6 +132,9 @@ def _commands(root, tests):
             if runner is None and re.search(rf"\bnode\s+(\./)?{re.escape(local)}\b", scripts):
                 runner = "node-script"
             groups[(folder or "", runner)].append(path)
+        elif lower.endswith(".go"):
+            folder, name = _nearest(root, path, ("go.mod",))
+            groups[(folder or "", "go" if name else None)].append(path)
         elif lower.endswith(".java"):
             folder, name = _nearest(root, path, ("pom.xml", "build.gradle", "build.gradle.kts"))
             groups[(folder or "", "maven" if name == "pom.xml" else "gradle" if name else None)].append(path)
@@ -147,6 +150,8 @@ def _commands(root, tests):
         if runner == "maven":
             names = ",".join(sorted({os.path.basename(f).rsplit(".", 1)[0] for f in files}))
             line = f"mvn test -Dtest={names} -Dsurefire.failIfNoSpecifiedTests=false"
+        elif runner == "go":
+            line = "go test " + " ".join(sorted({"./" + posixpath.dirname(f) if posixpath.dirname(f) else "." for f in local}))
         elif runner == "node-script":
             commands.extend({"cwd": folder or ".", "command": f"node {f}"} for f in sorted(local))
             continue
@@ -260,6 +265,7 @@ _TEST_CASES = {
     ".py": re.compile(r"^\s*(async\s+)?def\s+test\w*\s*\(|^\s*class\s+Test\w*|unittest\.TestCase", re.M),
     ".java": re.compile(r"@(Test|ParameterizedTest|RepeatedTest|TestFactory|TestTemplate|RunWith|Suite)\b|"
                         r"\bstatic\s+\w*Test\s+suite\s*\(|\bextends\s+TestCase\b|\bvoid\s+test\w*\s*\("),
+    ".go": re.compile(r"^func\s+(Test|Benchmark|Fuzz|Example)\w*\s*\(", re.M),
     "script": re.compile(r"\b(it|test|describe|suite)(\.\w+)?\s*\(|\bDeno\.test\b|\bnode:test\b|\bassert\b"),
 }
 

package/code_graph.py

@@ -20,10 +20,11 @@ import index_scope
 import project_identity
 import web_search_adapters
 import web_document_graph
+import code_graph_go
 import document_text
 
-VERSION = 2
-SOURCE_EXTENSIONS = ('.py','.java','.js','.jsx','.ts','.tsx','.mjs','.cjs','.mts','.cts','.json','.html','.htm','.css','.scss','.sass','.less','.md','.markdown')
+VERSION = 3
+SOURCE_EXTENSIONS = ('.py','.go','.mod','.java','.js','.jsx','.ts','.tsx','.mjs','.cjs','.mts','.cts','.json','.html','.htm','.css','.scss','.sass','.less','.md','.markdown')
 MAX_OVERLAY_BYTES = 5 * 1024 * 1024
 MAX_FILES = 3000
 MAX_TEXT = 24 * 1024 * 1024
@@ -284,7 +285,7 @@ def _analyze(path):
 def _analyze_sources(files,sources,diagnostics,truncated):
     merged={'symbols':[],'dependencies':[],'calls':[],'unresolved':[],'diagnostics':diagnostics,'parsed':[]}
     retryable=False
-    for output in (_python_graph(sources),_javascript_graph(sources,[f['path'] for f in files]),_java_graph(sources),web_document_graph.analyze(sources,[f['path'] for f in files])):
+    for output in (_python_graph(sources),_javascript_graph(sources,[f['path'] for f in files]),_java_graph(sources),code_graph_go.analyze(sources),web_document_graph.analyze(sources,[f['path'] for f in files])):
         for key in merged:merged[key].extend(output.get(key,[]))
         truncated |= output.get('truncated',False)
         retryable |= output.get('retryable',False)

package/code_graph_go.py

@@ -0,0 +1,85 @@
+"""Imports between Go files, read from the package clause and the import declarations of the indexed snapshot.
+
+A Go package is a directory, so a file that imports a package depends on every non-test file of that directory, and an
+internal test file (`package x` in `x_test.go`) depends on every non-test file of its own directory. Import paths are
+resolved against the nearest `go.mod` module path; with no `go.mod` in the snapshot an import resolves to the longest
+directory whose path ends the import path. No symbols or calls are produced: the doc and duplicate hooks stay silent
+for Go until their thresholds are measured on it, and `affected_tests` selects by package import."""
+import posixpath
+import re
+
+_COMMENT = re.compile(r"//[^\n]*|/\*.*?\*/", re.S)
+_PACKAGE = re.compile(r"^package\s+(\w+)", re.M)
+_IMPORT_BLOCK = re.compile(r"^import\s*\((.*?)^\)", re.M | re.S)
+_IMPORT_ONE = re.compile(r'^import\s+(?:[\w.]+\s+)?"([^"]+)"', re.M)
+_IMPORT_SPEC = re.compile(r'^\s*(?:[\w.]+\s+)?"([^"]+)"', re.M)
+_MODULE = re.compile(r"^module\s+(\S+)", re.M)
+
+
+def _module_roots(sources):
+    """Folder of each go.mod in the snapshot -> its module path."""
+    roots = {}
+    for path, text in sources.items():
+        if posixpath.basename(path) == "go.mod":
+            match = _MODULE.search(_COMMENT.sub("", text))
+            if match:
+                roots[posixpath.dirname(path)] = match.group(1).strip('"')
+    return roots
+
+
+def _enclosing_module(folder, roots):
+    """(module folder, module path) of the nearest go.mod above `folder`, or (None, None)."""
+    while True:
+        if folder in roots:
+            return folder, roots[folder]
+        if not folder:
+            return None, None
+        folder = posixpath.dirname(folder)
+
+
+def _imports(text):
+    """Import paths of one Go file (comments already blanked)."""
+    found = [match.group(1) for match in _IMPORT_ONE.finditer(text)]
+    for block in _IMPORT_BLOCK.finditer(text):
+        found.extend(spec.group(1) for spec in _IMPORT_SPEC.finditer(block.group(1)))
+    return found
+
+
+def analyze(sources):
+    go_files = {path: text for path, text in sources.items() if path.endswith(".go")}
+    parsed = [path for path in sources if path.endswith(".go") or posixpath.basename(path) == "go.mod"]
+    if not go_files:
+        return {"parsed": parsed}
+    roots = _module_roots(sources)
+    packages = {}
+    for path in go_files:
+        if not path.endswith("_test.go"):
+            packages.setdefault(posixpath.dirname(path), []).append(path)
+
+    def package_dir(path, spec):
+        folder, module = _enclosing_module(posixpath.dirname(path), roots)
+        if module is not None:
+            if spec != module and not spec.startswith(module + "/"):
+                return None
+            return folder if spec == module else posixpath.normpath(posixpath.join(folder, spec[len(module) + 1:]))
+        candidates = [d for d in packages if d and (spec == d or spec.endswith("/" + d))]
+        return max(candidates, key=len, default=None)
+
+    dependencies = []
+    for path, text in sorted(go_files.items()):
+        bare = _COMMENT.sub(lambda m: re.sub(r"[^\n]", " ", m.group(0)), text)
+        for spec in _imports(bare):
+            folder = package_dir(path, spec)
+            line = bare[:bare.find(f'"{spec}"')].count("\n") + 1
+            targets = [t for t in packages.get(folder, ()) if t != path] if folder is not None else []
+            if not targets:
+                dependencies.append({"source": path, "target": None, "specifier": spec, "line": line, "kind": "import",
+                                     "resolution": "external"})
+            dependencies.extend({"source": path, "target": target, "specifier": spec, "line": line, "kind": "import",
+                                 "resolution": "resolved"} for target in targets)
+        clause = _PACKAGE.search(bare)
+        if path.endswith("_test.go") and clause and not clause.group(1).endswith("_test"):
+            dependencies.extend({"source": path, "target": target, "specifier": posixpath.dirname(path) or ".",
+                                 "line": 1, "kind": "package", "resolution": "resolved"}
+                                for target in packages.get(posixpath.dirname(path), ()))
+    return {"dependencies": dependencies, "parsed": parsed}

package/config.py

@@ -20,6 +20,9 @@ CONFIG_PATH = os.path.join(CONFIG_DIR, "config.json")
 # RLock: update_config() chama load/save sob o mesmo lock; Lock travaria a própria thread.
 _LOCK = threading.RLock()
 
+# The config fields that select a gateway model; every per-role table (recommended models, failure log) keys on these.
+MODEL_ROLES = ("router_model", "scope_model", "scout_model", "research_model", "embedding_model", "rerank_model")
+
 DEFAULT_CONFIG = {
     "router_model": "",
     "scope_model": "",

package/index_profile.py

@@ -12,10 +12,12 @@ KINDS = ("code", "test", "doc")
 RETRY_AFTER_S = 3600
 MAX_DIRS = 90
 PROSE = {"md", "txt", "docx", "rst", "adoc"}
-# Data and markup inside a documentation folder are reports, not code (GitHub Linguist treats docs/ as documentation).
+# Data and markup inside a documentation, design or data-dump folder are reports and mockups, not code (GitHub Linguist
+# treats docs/ as documentation; a design/ HTML or a probe's JSON result pushed hook_decision.py out of the code block).
 DOC_DATA = {"html", "htm", "json", "csv", "xml", "yaml", "yml", "svg"}
 _NAME_DOC = re.compile(r"(^|/)(readme|changelog|license|licence|contributing|install|history|authors)(\.[^/]*)?$", re.I)
 _DIR_DOC = re.compile(r"(^|/)(docs?|adrs?|documentation)/", re.I)
+_DIR_DOC_DATA = re.compile(r"(^|/)(docs?|adrs?|documentation|designs?|references?|mockups?|prototypes?|data|datasets?|reports?|results?)/", re.I)
 _TEST = re.compile(r"(^|/)(tests?|__tests__|spec|specs|e2e|fixtures?|testdata|test-utils?)(/|$)|(^|/)test_[^/]+\.py$|"
                    r"(^|/)conftest\.py$|_test\.(py|go)$|\.(test|spec)(-d)?\.[cm]?[jt]sx?$|(^|/)[^/]*[a-z0-9](?-i:Tests?)\.java$|"
                    r"(^|/)src/test/|(^|/)test[-_][^/]*\.[cm]?[jt]sx?$|[-_]test\.[cm]?[jt]sx?$", re.I)
@@ -151,7 +153,7 @@ def kind(path, profile):
         return _model_kind(path, groups or [{"path": ".", "kind": "doc"}])
     if _TEST.search(path):
         return "test"
-    if ext in DOC_DATA and _DIR_DOC.search(path) and _explicit_kind(path, groups) != "code":
+    if ext in DOC_DATA and _DIR_DOC_DATA.search(path) and _explicit_kind(path, groups) != "code":
         return "doc"
     if not ext and _NAME_DOC.search(path):
         return "doc"

package/model_defaults.py

@@ -11,7 +11,7 @@ import model_catalog
 # first and price second (docs/research/2026-10-24-modelos-do-scout-e-dos-outros-papeis.md): the router answers pages
 # and the scout reads code excerpts, where Claude Haiku 5.5 answered every request and led the no-index path; scope and
 # research pick the GPT-5.4 nano, as accurate there at about half the price and without the long reasoning of the mini.
-RECOMMENDED_MODELS = {
+_CHOICES = {
     "router_model": ("chat", "claude-haiku-5-5"),
     "scope_model": ("chat", "gpt-5.4-nano"),
     "scout_model": ("chat", "claude-haiku-5-5"),
@@ -19,10 +19,18 @@ RECOMMENDED_MODELS = {
     "embedding_model": ("embedding", "text-embedding-3-small"),
     "rerank_model": ("rerank", "rerank-3-5"),
 }
+RECOMMENDED_MODELS = {role: _CHOICES[role] for role in config.MODEL_ROLES}
+
+
+def _route_rank(model_id):
+    """Vertex first (the owner's gateway is stable there), Bedrock only when nothing else serves the model."""
+    route = re.split(r"[/.:]", model_id)[0].lower()
+    return 0 if route.startswith("vertex") else 2 if route.startswith("bedrock") else 1
 
 
 def _matching(catalog, name):
-    return next((model_id for model_id in sorted(catalog) if re.split(r"[/.:]", model_id)[-1] == name
+    return next((model_id for model_id in sorted(catalog, key=lambda found: (_route_rank(found), found))
+                 if re.split(r"[/.:]", model_id)[-1] == name
                  or model_id.endswith(("/" + name, "." + name)) or model_id == name), None)
 
 

package/model_health.py

@@ -23,7 +23,6 @@ MUTE_S = 7 * 24 * 3600
 KEEP_S = 7 * 24 * 3600
 KEEP_FAILURES = 500
 ERROR_CHARS = 300
-_ROLES = ("router_model", "scope_model", "scout_model", "research_model", "embedding_model", "rerank_model")
 _PATHS = ("/v1/chat/completions", "/v1/embeddings", "/v1/rerank")
 _TOOL = contextvars.ContextVar("model_health_tool", default=None)
 _COLLECTED = contextvars.ContextVar("model_health_collected", default=None)
@@ -60,7 +59,7 @@ def _tables(db):
 def role_of(model, cfg=None):
     """Name of the config field that selects `model` ('other' when none does)."""
     cfg = cfg if cfg is not None else config.load_config()
-    return next((field for field in _ROLES if cfg.get(field) == model), "other")
+    return next((field for field in config.MODEL_ROLES if cfg.get(field) == model), "other")
 
 
 def error_text(exc):

package/model_upgrade.py

@@ -14,7 +14,7 @@ import config
 import model_catalog
 import model_defaults
 
-DEFAULTS_VERSION = 1
+DEFAULTS_VERSION = 2
 ROLES = ("router_model", "scope_model", "scout_model", "research_model")
 REMIND_EVERY_S = 24 * 3600
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.32",
+  "version": "0.9.33",
   "description": "Local MCP server that gives coding agents (Claude Code, Codex) cheaper, sharper tools than their built-in search. Windows.",
   "license": "Apache-2.0",
   "author": "Allan Santos",

package/setup_audit.py

@@ -11,6 +11,7 @@ Usage: python setup_audit.py [--project DIR] [--no-probe] [--json]
 """
 import argparse
 import concurrent.futures
+import glob
 import hashlib
 import json
 import os
@@ -41,18 +42,22 @@ PROBE_MAX_AGE_S = 6 * 3600
 SKILL_DESCRIPTION_MAX = 1536
 SKILL_BUDGET_CHARS = 8000
 CODEX_PROJECT_DOC_MAX = 32 * 1024
+SMART_TOOL_SERVER = "smart-tool"
 CLAUDE_TOOLS = ("Bash", "Read", "Grep", "Glob", "LS", "Edit", "MultiEdit", "Write", "NotebookEdit", "WebFetch",
                 "WebSearch", "Task")
 CODEX_TOOLS = ("Bash", "apply_patch")
 DECIDING_EVENTS = ("PreToolUse",)
 DOCS = {"claude_hooks": "https://code.claude.com/docs/en/hooks.md", "codex_hooks": "https://learn.chatgpt.com/docs/hooks.md",
         "claude_skills": "https://code.claude.com/docs/en/skills.md",
+        "claude_subagents": "https://code.claude.com/docs/en/sub-agents",
         "codex_skills": "https://learn.chatgpt.com/docs/build-skills.md",
         "claude_memory": "https://code.claude.com/docs/en/memory.md",
         "codex_agents_md": "https://developers.openai.com/codex/guides/agents-md",
         "claude_mcp": "https://code.claude.com/docs/en/mcp.md", "mcp_lifecycle":
         "https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle"}
 _SCRIPT_RE = re.compile(r"""["']?([^\s"'|&;<>]+\.(?:js|cjs|mjs|py|ps1|sh|bat|cmd|exe))["']?""", re.IGNORECASE)
+# The quoted program text after -e / -c / -p / -Command / --eval: code, not a file the hook runs.
+_INLINE_CODE_RE = re.compile(r"""\s(?:-e|-c|-p|-Command|--eval)\s+(?:"(?:[^"\\]|\\.)*"|'[^']*')""", re.IGNORECASE)
 _SILENCED_RE = re.compile(r"\|\|\s*(?:true|exit\s+0)\b|2>\s*(?:/dev/null|nul)\b|;\s*exit\s+0\s*$", re.IGNORECASE)
 _IMPORT_RE = re.compile(r"(?<![\w`])@((?:~|\.{1,2})?/?[\w.\-/\\]+\.\w+)")
 
@@ -204,6 +209,20 @@ def _approvals(data, approval):
     approval["off"].update(data.get("disabledMcpjsonServers") or [])
 
 
+def _agents(snapshot, folder, scope):
+    """Subagent definitions (*.md with frontmatter) in folder: name, scope, path and `tools` (None when the field is
+    absent, which makes the agent inherit every tool, MCP included)."""
+    found = []
+    for path in sorted(glob.glob(os.path.join(folder, "*.md"))):
+        meta = _frontmatter(snapshot.read(path))
+        tools = meta.get("tools")
+        if isinstance(tools, str):
+            tools = [item.strip() for item in tools.split(",") if item.strip()]
+        found.append({"name": str(meta.get("name") or os.path.basename(path)[:-3]), "scope": scope, "path": path,
+                      "tools": [str(item) for item in tools] if isinstance(tools, list) else None})
+    return found
+
+
 def collect_claude(project, snapshot):
     """Claude Code's effective set for project: settings layers, enabled plugins, hooks, MCP, skills, CLAUDE.md."""
     layers = [(path, "managed") for path in _managed_settings()] + [
@@ -234,6 +253,8 @@ def collect_claude(project, snapshot):
     mcp += [e for e in shared if e["name"] not in unapproved]
     skills = _skills(snapshot, os.path.join(endpoint_sync.claude_dir(), "skills"), "user", disabled=disabled_skills)
     skills += _skills(snapshot, os.path.join(project, ".claude", "skills"), "project", disabled=disabled_skills)
+    agents = _agents(snapshot, os.path.join(endpoint_sync.claude_dir(), "agents"), "user")
+    agents += _agents(snapshot, os.path.join(project, ".claude", "agents"), "project")
     plugins = []
     installed = snapshot.json(os.path.join(endpoint_sync.claude_dir(), "plugins", "installed_plugins.json")) or {}
     for plugin_id, installs in (installed.get("plugins") or {}).items():
@@ -261,10 +282,64 @@ def collect_claude(project, snapshot):
         text = snapshot.read(path)
         if text is not None:
             instructions.append({"path": path, "kind": kind, "bytes": len(text.encode("utf-8")), "_text": text})
-    return {"settings": settings, "plugins": plugins, "hooks": hooks, "mcp": mcp, "skills": skills,
+    return {"settings": settings, "plugins": plugins, "hooks": hooks, "mcp": mcp, "skills": skills, "agents": agents,
             "instructions": instructions, "unapproved_mcp": unapproved}
 
 
+def _codex_plugin_root(market, name):
+    """Newest installed version folder of a Codex plugin (`plugins/cache/<marketplace>/<name>/<version>/`), skipping
+    the `latest` alias unless it is all there is; None when the plugin is not in the cache."""
+    base = os.path.join(codex_dir(), "plugins", "cache", market, name)
+    if not os.path.isdir(base):
+        return None
+    versions = [os.path.join(base, entry) for entry in os.listdir(base) if os.path.isdir(os.path.join(base, entry))]
+    real = [path for path in versions if os.path.basename(path) != "latest"]
+    return max(real or versions, key=os.path.getmtime) if versions else None
+
+
+def _codex_plugin_path(manifest, key, root, defaults):
+    """Path a Codex plugin manifest names for `key` (relative to the plugin root), else the first default that exists."""
+    named = manifest.get(key)
+    if isinstance(named, str):
+        return os.path.join(root, named)
+    return next((os.path.join(root, d) for d in defaults if os.path.exists(os.path.join(root, d))), None)
+
+
+def _collect_codex_plugins(config, snapshot):
+    """Skills, hooks and MCP servers of the Codex plugins enabled in config.toml (`[plugins."<name>@<marketplace>"]`
+    unless `enabled = false`), read from the plugin cache: manifest `.codex-plugin/plugin.json`, `skills/`,
+    `hooks/hooks.json`, `.mcp.json`. A plugin whose folder or manifest is missing is reported as not verified."""
+    plugins, hooks, mcp, skills = [], [], [], []
+    for plugin_id, options in (config.get("plugins") or {}).items():
+        if isinstance(options, dict) and options.get("enabled") is False:
+            continue
+        name, _, market = plugin_id.rpartition("@")
+        root = _codex_plugin_root(market, name) if name else None
+        if not root:
+            snapshot.unverified.append(f"Codex plugin {plugin_id}: not found under {os.path.join(codex_dir(), 'plugins', 'cache')}")
+            continue
+        manifest_path = next((p for p in (os.path.join(root, ".codex-plugin", "plugin.json"),
+                                          os.path.join(root, "plugin.json")) if os.path.exists(p)), None)
+        manifest = snapshot.json(manifest_path) if manifest_path else None
+        if manifest is None:
+            snapshot.unverified.append(f"Codex plugin {plugin_id}: no readable manifest (.codex-plugin/plugin.json) in {root}")
+            continue
+        plugins.append({"id": plugin_id, "path": root})
+        hook_file = _codex_plugin_path(manifest, "hooks", root, (os.path.join("hooks", "hooks.json"),))
+        hooks += _hooks_from(snapshot.json(hook_file) if hook_file else None, f"plugin:{name}", root)
+        mcp_file = _codex_plugin_path(manifest, "mcpServers", root, (".mcp.json", "mcp.json"))
+        plugin_mcp = snapshot.json(mcp_file) if mcp_file else None
+        if plugin_mcp is None and isinstance(manifest.get("mcpServers"), dict):
+            plugin_mcp = manifest["mcpServers"]
+        plugin_mcp = plugin_mcp or {}
+        mcp += _mcp_entries(plugin_mcp.get("mcpServers", plugin_mcp), f"plugin:{name}", mcp_file or manifest_path,
+                            f"plugin:{name}:", {"PLUGIN_ROOT": root})
+        skill_dir = _codex_plugin_path(manifest, "skills", root, ("skills",))
+        skills += [{**s, "name": f"{name}:{s['name']}"} for s in
+                   _skills(snapshot, skill_dir, f"plugin:{name}", recursive=True)] if skill_dir else []
+    return plugins, hooks, mcp, skills
+
+
 def collect_codex(project, snapshot):
     """Codex's effective set for project: config.toml (MCP, hooks), hooks.json, skills, AGENTS.md chain."""
     config = snapshot.toml(os.path.join(codex_dir(), "config.toml")) or {}
@@ -274,6 +349,10 @@ def collect_codex(project, snapshot):
     skills = _skills(snapshot, os.path.join(codex_dir(), "skills"), "user", recursive=True)
     skills += _skills(snapshot, _home(".agents", "skills"), "user-agents")
     skills += _skills(snapshot, os.path.join(project, ".agents", "skills"), "project")
+    plugins, plugin_hooks, plugin_mcp, plugin_skills = _collect_codex_plugins(config, snapshot)
+    hooks += plugin_hooks
+    mcp += plugin_mcp
+    skills += plugin_skills
     instructions = []
     for name in ("AGENTS.override.md", "AGENTS.md"):
         text = snapshot.read(os.path.join(codex_dir(), name))
@@ -292,8 +371,7 @@ def collect_codex(project, snapshot):
                 instructions.append({"path": os.path.join(folder, name), "kind": "project",
                                      "bytes": len(text.encode("utf-8")), "_text": text})
                 break
-    return {"hooks": hooks, "mcp": mcp, "skills": skills, "instructions": instructions,
-            "plugins_unverified": bool(config.get("plugins"))}
+    return {"plugins": plugins, "hooks": hooks, "mcp": mcp, "skills": skills, "instructions": instructions}
 
 
 def _finding(check, severity, harness, subject, detail, source, evidence=()):
@@ -336,8 +414,9 @@ def check_hook_overlap(harness, hooks, tools):
 
 
 def _expand(token, root):
-    """A hook script path with ${CLAUDE_PLUGIN_ROOT}, ~ and environment variables expanded."""
-    token = token.replace("${CLAUDE_PLUGIN_ROOT}", root or "${CLAUDE_PLUGIN_ROOT}")
+    """A hook script path with ${CLAUDE_PLUGIN_ROOT} / ${PLUGIN_ROOT}, ~ and environment variables expanded."""
+    for variable in ("CLAUDE_PLUGIN_ROOT", "PLUGIN_ROOT"):
+        token = token.replace("${%s}" % variable, root or "${%s}" % variable)
     return os.path.expandvars(os.path.expanduser(token))
 
 
@@ -348,7 +427,9 @@ def check_hook_targets(harness, hooks, mcp_names, probe):
     for hook in hooks:
         where = f"{hook['source']} {hook['event']} {hook['matcher'] or '*'}"
         if hook["type"] == "command" and hook["command"]:
-            for token in _SCRIPT_RE.findall(hook["command"]):
+            for token in _SCRIPT_RE.findall(_INLINE_CODE_RE.sub(" ", hook["command"])):
+                if not re.search(r"[\\/]", token) and shutil.which(token):
+                    continue
                 path = _expand(token, hook.get("root"))
                 if "$" in path or "%" in path:
                     continue
@@ -384,6 +465,24 @@ def _reachable(url):
         return str(exc)
 
 
+def check_agents(claude):
+    """Subagents whose `tools` list names no Smart Tool tool while the smart-tool server is registered: the redirect
+    leaves them alone (nothing to redirect to), so they search folders with Grep and Read at full cost. A subagent
+    with no `tools` field inherits every tool, MCP included; with the field, only what it lists."""
+    if not any(entry["name"] == SMART_TOOL_SERVER for entry in claude["mcp"]):
+        return []
+    blind = [a for a in claude.get("agents", []) if a["tools"] is not None
+             and not any(tool == "*" or tool.startswith(f"mcp__{SMART_TOOL_SERVER}") for tool in a["tools"])]
+    if not blind:
+        return []
+    names = ", ".join(sorted(a["name"] for a in blind)[:8]) + (" ..." if len(blind) > 8 else "")
+    return [_finding("agent_without_smart_tool", "warn", "claude", "subagents without Smart Tool",
+                     f"{len(blind)} subagent(s) list tools but none of mcp__{SMART_TOOL_SERVER}__*: {names}. Add "
+                     f"mcp__{SMART_TOOL_SERVER}__smart_search and mcp__{SMART_TOOL_SERVER}__smart_search_result to "
+                     "their `tools`, or drop the `tools` line to inherit every tool.", DOCS["claude_subagents"],
+                     [a["path"] for a in blind[:8]])]
+
+
 def check_skills(harness, skills):
     """Skill name collisions, descriptions over Claude's per-skill cut, and the total over the list budget."""
     findings, by_name = [], {}
@@ -635,6 +734,7 @@ def run(project, probe=True, save=True, probe_max_age=0, trigger="manual"):
         results = (probe_mcp(data["mcp"], project, max_age=probe_max_age) if probe
                    else [None] * len(data["mcp"]))
         findings += check_mcp(harness, data["mcp"], results)
+    findings += check_agents(claude)
     findings += check_instructions(project, claude, codex)
     unverified = list(snapshot.unverified)
     if not probe:
@@ -642,8 +742,6 @@ def run(project, probe=True, save=True, probe_max_age=0, trigger="manual"):
     for name in claude["unapproved_mcp"]:
         unverified.append(f".mcp.json server '{name}' is not approved in Claude Code, so it is neither loaded nor "
                           "started here")
-    if codex.get("plugins_unverified"):
-        unverified.append("Codex plugins (their skills and hooks) are not collected yet")
     unverified += ["skill trigger overlap and contradictions between instructions need a model (not run)",
                    "the order between two parallel rewrites is undocumented and cannot be checked"]
     key = hashlib.sha256(json.dumps(sorted(snapshot.files.items())).encode()).hexdigest()[:16]

package/version.py

@@ -1,7 +1,7 @@
 """Single source of the Smart Tool version and of the User-Agent sent to public APIs."""
 import re
 
-VERSION = "0.9.32"
+VERSION = "0.9.33"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")