@allansantos-dev/smart-tool 0.9.6 → 0.9.8

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.9.8 - beta
+
+- An update could keep running the previous code: npm dates every file in the package 1985-10-26, the installer kept
+  that date when copying, and Python reuses a compiled `.pyc` when the source's date and size match, so a file changed
+  without changing size (a version bump, a one-character fix) went on running the old bytecode. Reproduced on a real
+  reinstall: `version.py` said 0.9.6 and the daemon served 0.9.8. Copied and restored files now get the current time,
+  and the program's `__pycache__` folders are cleared after copying and after a rollback (two copies within the same
+  second keep the same date). The update to this version already clears any stale bytecode left by earlier ones.
+  Reported by the agent-launcher session, which had the same bug.
+
+## 0.9.7 - beta
+
+The hook decides code searches with a fixed rule instead of the router model.
+
+- Deterministic redirect (`redirect_rule.py`): only the part of a Bash command that searches content is measured, with
+  its own paths (`cd` carried, `$VAR` set in the command or the environment, `~` and globs expanded). A content search
+  over a project folder (`grep -r`, `rg`, `git grep`, `git -C dir grep`, the Grep tool on a folder) or over more than
+  20 listed files goes to `smart_search`; reading or searching known files, listings, Glob, commands that change files
+  and paths it cannot resolve run. Replayed on 2,789 real decisions of the router model: the model redirected 315,
+  the rule 463 (134 shared); in a sample of 40 redirected by the rule alone, 40 were content searches over a folder or
+  many files; in a sample of 40 redirected by the model alone, ~36 were wrong. A decision takes 0.2 ms (median)
+  instead of 1.5 s: the router model cost 119 min of agent waiting in 84 h. The same call always gets the same answer.
+- Block patterns proposed by a model (`pattern_proposals`, on by default): bulk reads the rule let run (globs, xargs,
+  -exec, loops, scripts walking folders) and paths it could not resolve are reviewed in the background by the scope
+  model (else the router model); the agent never waits. A proposed regex is checked (it compiles, matches the call,
+  does not match calls allowed on purpose, blocks at most 25% of the logged calls of that tool) and waits in the setup
+  screen with how many logged calls it would have blocked; it redirects only after you accept it. With gpt-4o-mini, 17
+  of 20 reviews proposed a pattern and none was usable; with gpt-5-mini, 2 of 20, one a real gap (grep over
+  `$(git ls-files)` held in a variable).
+- A new branch or worktree starts from the project's latest view: the scope is inherited while the folder structure
+  and root docs still match (no scope or profile model call), and the index starts as a copy that only reprocesses the
+  files whose content differs. Measured on a branch at the same commit: the first search took 52 s (scope 11 s,
+  profile 20.5 s, rebuilding the index 17 s), seen in real use as the p90 of 64 s over 219 searches.
+- `smart_search_result` waits up to 15 s for the job before answering pending: answering at once had an agent poll the
+  same job 7 times in 16 s and give up on Smart Tool.
+- Code redirects no longer need a router model: `smart_search` answers with the lexical index when no embedding model
+  is configured.
+
 ## 0.9.6 - beta
 
 Reported by the claude-code-boss session validating 0.9.5.

package/README.md

@@ -48,11 +48,16 @@ Open the setup screen from the tray icon ("Open settings") or at `http://127.0.0
    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: it decides before tool calls), the index classification model and the research model. Any id the gateway
+   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.
 3. **Agents**: register the MCP server in Claude Code or Codex (runs their official `mcp add` command), install the
    hook and choose its behavior:
-   - **Redirect** (default): the native tool is denied with the reason and the Smart Tool tool to use.
+   - **Redirect** (default): the native tool is denied with the reason and the Smart Tool tool to use. The decision
+     is a fixed rule, under a millisecond and the same every time: a content search over a project folder (`grep -r`,
+     `rg`, `git grep`, the Grep tool on a folder) or over more than 20 listed files goes to `smart_search`; reading or
+     searching known files, listings, Glob and commands that change files run. With **Block patterns proposed by a
+     model** on (default), the scope model reviews, in the background, bulk reads the rule could not measure and
+     proposes regex patterns, each checked against the logged calls; a pattern blocks only after you accept it.
    - **Advise only**: the native tool runs; the agent receives the same advice next to the result and decides.
    - **Off**: no routing.
 

package/block_patterns.py

@@ -0,0 +1,266 @@
+"""Block patterns learned during operation: when the deterministic redirect rule lets a search or read run, the router
+model (review_model) reviews the call in the background (the agent never waits for it) and may propose a regex for calls that should
+go to Smart Tool. A proposal is checked (compiles, matches the call, how many logged calls it would have blocked; one
+that blocks more than BROAD_SHARE of them is discarded) and waits for the user in the setup screen; an accepted pattern
+redirects from then on, deterministically, after the rule's own exceptions (single files, commands changing files).
+"""
+import concurrent.futures
+import hashlib
+import json
+import os
+import re
+import threading
+import time
+
+import atomic_io
+import config
+import model_client
+import paths
+
+STORE_PATH = os.path.join(paths.DATA_DIR, "block-patterns.json")
+REVIEW_TIMEOUT_S = 60
+MAX_REVIEWS_PER_HOUR = 20
+MAX_PENDING = 20
+BROAD_SHARE = 0.25
+PATTERN_MAX_CHARS = 300
+CALL_MAX_CHARS = 1500
+# Only calls whose reach the rule cannot measure are reviewed: bulk reads (globs, xargs, -exec, loops, scripts walking
+# folders) and paths it could not resolve. Reading a few listed files is allowed on purpose and never reviewed.
+REVIEWED_REASONS = ("The searched path uses a variable the hook cannot resolve.", "No content search over a folder.")
+_BULK_READ = re.compile(r"\*|\bxargs\b|-exec\b|\bfor\s+\w+\s+in\b|os\.walk|rglob|glob\(|readdirSync|readdir\(|"
+                        r"walkSync|-Recurse\b|Get-ChildItem", re.IGNORECASE)
+# Calls the rule lets run on purpose: a pattern matching any of them would block what must run.
+ALLOWED_ON_PURPOSE = ("grep -n handler src/app.py", "grep -n \"def load\" -A20 src/app.py | head -40",
+                      "sed -n 1,80p src/app.py", "cat README.md", "head -50 src/app.py", "tail -20 logs/app.log",
+                      "awk '/def /{print NR\": \"$0}' src/app.py", "git status --short", "git log --oneline -5",
+                      "git diff --stat", "npm test", "pytest -q tests/test_app.py", "ls src", "find src -name '*.py'",
+                      "Grep pattern=handler path=src/app.py", "cd src && grep -n x app.py",
+                      "ls -la src docs | head -20", "wc -l src/app.py src/util.py",
+                      "for f in src/app.py src/util.py; do grep -n handler $f; done")
+
+_LOCK = threading.RLock()
+_EXECUTOR = concurrent.futures.ThreadPoolExecutor(max_workers=1, thread_name_prefix="block-patterns")
+_state = {"pending": 0, "recent": [], "seen": set(), "compiled": (None, [])}
+
+_SYSTEM_PROMPT = (
+    "Smart Tool saves the context of coding agents: a PreToolUse hook sends raw searches of project code to an indexed "
+    "semantic search (smart_search), whose short answer costs far fewer tokens than grep output, and the index gets "
+    "better the more it is used. A deterministic rule already redirects content searches over a folder (grep -r, rg, "
+    "git grep, the Grep tool on a folder) and searches over more than 20 listed files. It lets run, on purpose: reading "
+    "or searching inside one or a few known files, listings (ls, find -name, Glob), commands that change files, run "
+    "builds, tests or git operations other than grep, and paths it cannot resolve.\n\n"
+    "You get one call the rule let run because it could not measure its reach: a bulk read (glob, xargs, -exec, a "
+    "loop, a script walking folders) or a path held in a variable. Answer block=true only when calls like it read the "
+    "content of many project source files at once, which smart_search answers in far fewer tokens. Answer block=false "
+    "for anything else, which is most calls: reading one or a few named files (grep, sed -n, cat, head, tail, awk on a "
+    "file), logs, test or build runs, git commands, registry or system commands, scripts that do not read code. When "
+    "block=true, write a Python regex matched with re.search against the call text that catches the same kind of "
+    "bulk read (not this exact path) and none of the calls allowed on purpose. Patterns already accepted or rejected "
+    "are listed; do not propose them again. Call submit_proposal."
+)
+_PROPOSAL_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "submit_proposal",
+        "description": "Whether calls like this one should be redirected, and the pattern when they should.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "block": {"type": "boolean"},
+                "pattern": {"type": "string", "description": "Python regex over the call text; empty when block is false"},
+                "reason": {"type": "string", "description": "One sentence on what the pattern catches and why"},
+            },
+            "required": ["block", "pattern", "reason"],
+        },
+    },
+}
+
+
+def call_text(tool_name, tool_input):
+    """The text a pattern is matched against: the command for Bash, the arguments for Grep and Glob."""
+    if tool_name == "Bash":
+        return str(tool_input.get("command") or "")
+    fields = ("pattern", "path", "glob", "type", "output_mode")
+    return f"{tool_name} " + " ".join(f"{f}={tool_input[f]}" for f in fields if tool_input.get(f) not in (None, ""))
+
+
+def _empty():
+    return {"accepted": [], "proposals": [], "rejected": []}
+
+
+def load():
+    """The stored patterns: {"accepted": [...], "proposals": [...], "rejected": [...]}."""
+    try:
+        with open(STORE_PATH, encoding="utf-8") as stream:
+            data = json.load(stream)
+    except FileNotFoundError:
+        return _empty()
+    if not isinstance(data, dict) or any(not isinstance(data.get(k), list) for k in _empty()):
+        raise ValueError(f"{STORE_PATH} is not a block patterns file: fix or delete it.")
+    return data
+
+
+def _save(data):
+    os.makedirs(os.path.dirname(STORE_PATH), exist_ok=True)
+    atomic_io.write_secret_text(STORE_PATH, json.dumps(data, indent=1, ensure_ascii=False))
+
+
+def matching(tool_name, tool_input):
+    """The accepted pattern matching this call, or None. Compiled patterns are cached by the file's mtime."""
+    try:
+        mtime = os.path.getmtime(STORE_PATH)
+    except OSError:
+        return None
+    with _LOCK:
+        cached_mtime, compiled = _state["compiled"]
+        if cached_mtime != mtime:
+            compiled = [(entry, re.compile(entry["pattern"])) for entry in load()["accepted"]]
+            _state["compiled"] = (mtime, compiled)
+    text = call_text(tool_name, tool_input)
+    return next((entry for entry, regex in compiled if entry["tool"] == tool_name and regex.search(text)), None)
+
+
+def _history(tool_name, regex, metrics_path):
+    """(matches, total) of the logged calls of this tool the pattern would have blocked."""
+    matches = total = 0
+    for name in (metrics_path + ".1", metrics_path):
+        try:
+            with open(name, encoding="utf-8") as stream:
+                for line in stream:
+                    try:
+                        row = json.loads(line)
+                    except ValueError:
+                        continue
+                    if row.get("tool_name") != tool_name or not isinstance(row.get("tool_input"), dict):
+                        continue
+                    total += 1
+                    matches += bool(regex.search(call_text(tool_name, row["tool_input"])))
+        except FileNotFoundError:
+            continue
+    return matches, total
+
+
+def _ask(tool_name, text, rule_reason, known, model):
+    token = model_client.get_token()
+    response = model_client.fetch("/v1/chat/completions", token, method="POST", timeout=REVIEW_TIMEOUT_S, body={
+        "model": model,
+        "messages": [{"role": "system", "content": _SYSTEM_PROMPT},
+                     {"role": "user", "content": json.dumps({"tool": tool_name, "call": text[:CALL_MAX_CHARS],
+                                                             "rule_allowed_because": rule_reason,
+                                                             "known_patterns": known}, ensure_ascii=False)}],
+        "tools": [_PROPOSAL_TOOL],
+        "tool_choice": {"type": "function", "function": {"name": "submit_proposal"}},
+        "temperature": 0,
+    })
+    return json.loads(response["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"])
+
+
+def propose(tool_name, tool_input, rule_reason, model, metrics_path, redact):
+    """Asks the model about one allowed call and stores what it proposes. Returns the stored proposal, or None when the
+    model did not propose one or the proposal failed a check (the discarded ones are kept as rejected, with why)."""
+    text = call_text(tool_name, tool_input)
+    with _LOCK:
+        data = load()
+    known = [e["pattern"] for group in ("accepted", "proposals", "rejected") for e in data[group]
+             if e["tool"] == tool_name][-30:]
+    answer = _ask(tool_name, call_text(tool_name, redact(tool_input)), rule_reason, known, model)
+    pattern = str(answer.get("pattern") or "").strip()
+    if not answer.get("block") or not pattern:
+        return None
+    entry = {"id": hashlib.sha1(f"{tool_name}\0{pattern}".encode()).hexdigest()[:12], "tool": tool_name,
+             "pattern": pattern, "reason": " ".join(str(answer.get("reason") or "").split())[:300],
+             "example": call_text(tool_name, redact(tool_input))[:300], "proposed_at": time.time()}
+    problem = None
+    try:
+        regex = re.compile(pattern)
+    except re.error as exc:
+        problem, regex = f"invalid regex: {exc}", None
+    if regex and len(pattern) > PATTERN_MAX_CHARS:
+        problem = f"longer than {PATTERN_MAX_CHARS} characters"
+    elif regex and not regex.search(text):
+        problem = "does not match the call it came from"
+    elif regex and any(regex.search(sample) for sample in ALLOWED_ON_PURPOSE):
+        problem = "matches calls the rule lets run on purpose: " + next(x for x in ALLOWED_ON_PURPOSE if regex.search(x))
+    if regex and not problem:
+        matches, total = _history(tool_name, regex, metrics_path)
+        entry.update(history_matches=matches, history_total=total)
+        if total and matches / total > BROAD_SHARE:
+            problem = f"too broad: would block {matches} of {total} logged {tool_name} calls"
+    with _LOCK:
+        data = load()
+        if any(e["id"] == entry["id"] for group in data.values() for e in group):
+            return None
+        if problem:
+            data["rejected"].append({**entry, "rejected_by": "check", "why": problem})
+            _save(data)
+            return None
+        data["proposals"].append(entry)
+        _save(data)
+    return entry
+
+
+def review_model(cfg):
+    """The scope model (a reasoning model by default), else the router model. Measured on 2026-10-09 over 20 real bulk
+    reads the rule let run: gpt-4o-mini proposed a pattern for 17 (14 failed the checks, the other 3 copied one session's
+    command); gpt-5-mini proposed 2, one of them a real gap (grep over `$(git ls-files)` held in a variable). The review
+    runs in the background, so the slower model costs the agent nothing."""
+    return cfg.get("scope_model") or cfg.get("router_model")
+
+
+def reviewable(tool_name, tool_input, rule_reason):
+    """Whether an allowed call is worth the model's review: a path the rule could not resolve, or a bulk read."""
+    if rule_reason == REVIEWED_REASONS[0]:
+        return True
+    return rule_reason == REVIEWED_REASONS[1] and bool(_BULK_READ.search(call_text(tool_name, tool_input)))
+
+
+def review_later(tool_name, tool_input, rule_reason, metrics_path, redact, log):
+    """Queues a background review of an allowed call whose reach the rule could not measure (REVIEWED_REASONS, bulk
+    reads only), when pattern_proposals is on and a review model is set. The same kind of call is reviewed once per
+    daemon run, at most MAX_REVIEWS_PER_HOUR an hour; failures go to log."""
+    if not reviewable(tool_name, tool_input, rule_reason):
+        return False
+    cfg = config.load_config()
+    model = review_model(cfg)
+    if not model or config.pattern_proposals(cfg) != "on":
+        return False
+    signature = (tool_name, re.sub(r"\s+", " ", call_text(tool_name, tool_input))[:120])
+    now = time.time()
+    with _LOCK:
+        _state["recent"] = [t for t in _state["recent"] if now - t < 3600]
+        if signature in _state["seen"] or len(_state["recent"]) >= MAX_REVIEWS_PER_HOUR or \
+                _state["pending"] >= MAX_PENDING:
+            return False
+        _state["seen"].add(signature)
+        _state["recent"].append(now)
+        _state["pending"] += 1
+
+    def run():
+        try:
+            propose(tool_name, tool_input, rule_reason, model, metrics_path, redact)
+        except Exception as exc:
+            log(f"block pattern review failed: {type(exc).__name__}: {exc}")
+        finally:
+            with _LOCK:
+                _state["pending"] -= 1
+    _EXECUTOR.submit(run)
+    return True
+
+
+def decide_proposal(entry_id, action):
+    """accept moves a proposal to accepted; reject moves it to rejected; remove deletes an accepted pattern."""
+    with _LOCK:
+        data = load()
+        source = "accepted" if action == "remove" else "proposals"
+        entry = next((e for e in data[source] if e["id"] == entry_id), None)
+        if entry is None:
+            raise ValueError(f"No {source[:-1]} with id {entry_id}.")
+        data[source] = [e for e in data[source] if e["id"] != entry_id]
+        if action == "accept":
+            data["accepted"].append({**entry, "accepted_at": time.time()})
+        elif action == "reject":
+            data["rejected"].append({**entry, "rejected_by": "user"})
+        elif action != "remove":
+            raise ValueError("Invalid action: use accept, reject or remove.")
+        _save(data)
+        return data

package/config.py

@@ -34,6 +34,7 @@ DEFAULT_CONFIG = {
     "doc_mode": "remind",
     "duplicate_mode": "warn",
     "auto_update": True,
+    "pattern_proposals": "on",
     "contact": "",
     "model_adapter": "",
     "model_adapter_options": {},
@@ -51,6 +52,9 @@ DOC_MODES = ("require", "remind", "off")
 # Edit hook on functions that copy one already indexed (exact or near-identical body): warn = let the edit run and
 # point to the existing function; off = say nothing. Never blocks: near matches are leads, not defects.
 DUPLICATE_MODES = ("warn", "off")
+# Router model reviewing, in the background, searches the deterministic redirect rule let run: on = propose block
+# patterns for the user to accept in the setup screen; off = no review.
+PATTERN_PROPOSAL_MODES = ("on", "off")
 
 
 def doc_mode(cfg=None):
@@ -67,6 +71,15 @@ def duplicate_mode(cfg=None):
     return value
 
 
+def pattern_proposals(cfg=None):
+    """on: the router model reviews searches the redirect rule let run and proposes block patterns for the user to
+    accept; off: no review."""
+    value = (cfg if cfg is not None else load_config()).get("pattern_proposals") or DEFAULT_CONFIG["pattern_proposals"]
+    if value not in PATTERN_PROPOSAL_MODES:
+        raise ValueError(f"Invalid pattern_proposals ({value!r}) in {CONFIG_PATH}: use on or off.")
+    return value
+
+
 def auto_update(cfg=None):
     """Whether the tray installs a newer release by itself when it starts (once per version)."""
     value = (cfg if cfg is not None else load_config()).get("auto_update", DEFAULT_CONFIG["auto_update"])

package/hook_decision.py

@@ -100,15 +100,10 @@ def agent_has_smart_tool(agent_type, cwd):
     return True
 
 
-def _search_root(tool_input, cwd):
-    """project_root for smart_search: the registered project holding what the call searches (its path field, or the
-    first existing path of the command, after any `cd`), else that directory; the session directory when the call
-    names no path."""
-    raw = router._target_path(tool_input, cwd)
-    paths = [router._resolve_path(raw, cwd)] if raw else router._command_paths(tool_input.get("command"), cwd)
-    target = os.path.abspath(next((p for p in paths if p), None) or cwd or ".")
-    if os.path.isfile(target):
-        target = os.path.dirname(target)
+def _search_root(target, cwd):
+    """project_root for smart_search: the registered project holding the folder the redirected search reads, else that
+    folder; the session folder when the rule names none."""
+    target = os.path.abspath(target or cwd or ".")
     key = os.path.normcase(target) + os.sep
     roots = [p["root"] for p in project_store.all_projects()
              if key.startswith(os.path.normcase(os.path.abspath(p["root"])).rstrip(os.sep) + os.sep)]
@@ -126,10 +121,10 @@ def _load_hint(client, tool):
     return f' If it is not in your tool list yet, load it first with ToolSearch, query "select:mcp__{SMART_TOOL_SERVER}__{tool}".'
 
 
-def redirect_message(client, tool_name, tool_input, reason, cwd):
-    """Deny text for a broad raw search: the exact tool and arguments to call, and that rewriting the same search in
-    Bash, python, node or PowerShell is the bypass the rule exists to stop."""
-    root = _search_root(tool_input, cwd).replace("\\", "/")
+def redirect_message(client, tool_name, target, reason, cwd):
+    """Deny text for a broad raw search: the exact tool and arguments to call (project_root from the folder the search
+    reads), and that rewriting the same search in Bash, python, node or PowerShell is the bypass the rule stops."""
+    root = _search_root(target, cwd).replace("\\", "/")
     return (f"Blocked by Smart Tool, a routing rule set by the user, not a failure ({tool_name}: {clean_reason(reason)}). "
             f'Run this search with {_tool_name(client, "smart_search")}: project_root="{root}", query_identifiers = what '
             f"you are looking for in identifier terms (plus query_comments when the project has two languages)."
@@ -280,10 +275,9 @@ def _route(payload, client, web_route, cfg):
     tool_name = payload.get("tool_name", "")
     tool_input = payload.get("tool_input") if isinstance(payload.get("tool_input"), dict) else {}
     cwd = payload.get("cwd")
-    router_model = cfg.get("router_model")
-    if not router_model:
-        return {}
     if tool_name in WEB_TOOLS:
+        if not cfg.get("router_model"):
+            return {}
         try:
             present = smart_tool_in_session(cwd)
         except (OSError, ValueError):
@@ -295,7 +289,7 @@ def _route(payload, client, web_route, cfg):
         return deny(web_message(client, tool_name, url, clean_reason(decision.get("reason")))) if decision.get("redirect") else {}
     router.CLIENT.set(client)
     try:
-        decision, reason = router.decide(tool_name, tool_input, router_model, cwd=cwd)
+        decision, reason, target = router.decide(tool_name, tool_input, cwd=cwd)
     except Exception as exc:
         try:
             router.log_unavailable(tool_name, tool_input, exc)
@@ -303,5 +297,5 @@ def _route(payload, client, web_route, cfg):
             pass
         return {"systemMessage": f"Smart Tool unavailable, routing skipped: {type(exc).__name__}"}
     if decision == "redirect":
-        return deny(redirect_message(client, tool_name, tool_input, reason, cwd))
+        return deny(redirect_message(client, tool_name, target, reason, cwd))
     return {}

package/index_scope.py

@@ -138,6 +138,32 @@ def load_scope(root):
     return None
 
 
+def sibling_scope(root):
+    """Scope of the most recently saved other Git view of the same project, or None. A new branch or a worktree starts
+    without a scope; asking the scope and profile models again cost ~28 s of a 52 s first search (measured 2026-10-09
+    on a branch at the same commit). The caller still checks it with needs_rescan before using it."""
+    if not index_views.describe(root).get("git"):
+        return None
+    own = scope_path(root)
+    prefix = project_identity.project_id(root) + ".v-"
+    try:
+        names = [n for n in os.listdir(SCOPE_DIR) if n.startswith(prefix) and n.endswith(".scope.json")]
+    except OSError:
+        return None
+    paths = sorted((os.path.join(SCOPE_DIR, n) for n in names), key=os.path.getmtime, reverse=True)
+    for path in paths:
+        if os.path.normcase(path) == os.path.normcase(own):
+            continue
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except (OSError, ValueError, UnicodeError):
+            continue
+        if valid_scope(data):
+            return data
+    return None
+
+
 def save_scope(root, scope):
     if not valid_scope(scope):
         raise ValueError("Scope must contain lists of paths in include/exclude.")

package/indexer.py

@@ -230,12 +230,28 @@ def migrate_legacy(root):
             if not old and index_views.describe(root).get('git'):
                 old = next((os.path.join(INDEX_DIR, key + '.sqlite3') for key in
                             [project_identity.project_id(root), *project_identity.legacy_ids(root)]
-                            if os.path.isfile(os.path.join(INDEX_DIR, key + '.sqlite3'))), None)
+                            if os.path.isfile(os.path.join(INDEX_DIR, key + '.sqlite3'))), None) or \
+                    _sibling_view_db(root, target)
             if old:
                 _backup(old, target)
     return target
 
 
+def _sibling_view_db(root, target):
+    """Most recently written index of another Git view of the same project, or None. A new branch or worktree starts
+    from its copy: the full content check a view change forces then reprocesses only the files that differ, instead
+    of chunking every file again (17 s of a 52 s first search on a branch at the same commit, measured 2026-10-09)."""
+    prefix = project_identity.project_id(root) + ".v-"
+    try:
+        names = os.listdir(INDEX_DIR)
+    except OSError:
+        return None
+    candidates = [os.path.join(INDEX_DIR, n) for n in names
+                  if n.startswith(prefix) and n.endswith(".sqlite3") and ".building-" not in n]
+    candidates = [p for p in candidates if os.path.normcase(p) != os.path.normcase(target)]
+    return max(candidates, key=os.path.getmtime, default=None)
+
+
 def _open_path(path):
     conn = sqlite3.connect(path, timeout=10)
     # `chunks.text` é conteúdo de arquivo em texto puro: sem isto, um DELETE só desliga a

package/install.py

@@ -197,6 +197,7 @@ def copy_files(target, files, backup, changed, removed):
         changed.append(rel)
         dest.parent.mkdir(parents=True, exist_ok=True)
         shutil.copy2(source, dest)
+        os.utime(dest)
     for rel in sorted(previous - set(files)):
         if (target / rel).is_file():
             (backup / rel).parent.mkdir(parents=True, exist_ok=True)
@@ -210,16 +211,31 @@ def copy_files(target, files, backup, changed, removed):
                                               indent=1), encoding="utf-8")
 
 
+def clear_bytecode(target):
+    """Deletes the program's __pycache__ folders (the virtual environment's are left alone). npm writes the same
+    mtime (1985-10-26) into every tarball entry, and Python's bytecode check compares only the source's mtime and
+    size: a file changed without changing size kept running the old code after an update (reproduced on 2026-10-10:
+    version.py said 0.9.6, the daemon served 0.9.8)."""
+    for current, dirs, _files in os.walk(target):
+        dirs[:] = [d for d in dirs if d != ".venv"]
+        if "__pycache__" in dirs:
+            shutil.rmtree(Path(current) / "__pycache__", ignore_errors=True)
+            dirs.remove("__pycache__")
+
+
 def restore(target, backup, changed, removed):
     for rel in changed:
         if (backup / rel).is_file():
             shutil.copy2(backup / rel, target / rel)
+            os.utime(target / rel)
         else:
             (target / rel).unlink(missing_ok=True)
     for rel in removed:
         if (backup / rel).is_file():
             (target / rel).parent.mkdir(parents=True, exist_ok=True)
             shutil.move(backup / rel, target / rel)
+            os.utime(target / rel)
+    clear_bytecode(target)
     if (backup / MANIFEST).is_file():
         shutil.copy2(backup / MANIFEST, target / MANIFEST)
     else:
@@ -319,6 +335,7 @@ def main():
     changed, removed, frozen, deps_touched = [], [], None, False
     try:
         copy_files(target, files, backup, changed, removed)
+        clear_bytecode(target)
         print(f"Files changed: {len(changed)}; removed as obsolete: {len(removed)}")
         if not args.skip_deps:
             frozen = freeze(python)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "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",