@allansantos-dev/smart-tool 0.9.5 → 0.9.7

package/CHANGELOG.md

@@ -1,5 +1,72 @@
 # Changelog
 
+## 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.
+
+- `project_manage action=duplicates` reads the files the index does not reflect yet (working tree, files changed on
+  disk, commits after the last indexing) and says how many it read: it kept reporting a function removed in a commit
+  made after the last indexing, with no sign that the index was behind.
+- In `graph` impact results, a test or caller that is an anonymous callback registered with `test('title', fn)`,
+  `it()` or `describe()` shows its title (`test "embedder (Q47): ..."`) instead of `callback`.
+- `graph` with `symbol` accepts a partial path before `::` (`brain-embedder.js::loadConfig`), matching the files whose
+  path ends with it; it needed the full path from the project root.
+
+Automatic updates.
+
+- When the tray starts (at logon, before agent sessions use the daemon) and npm has a newer version, it runs the
+  install command in a visible console that closes on success and stays open on failure. Each version is installed
+  automatically once: a failed update restores the previous version and restarts the tray, which then only offers it.
+- The tray menu has "Update to X" (or "Check for updates", which says when the installed version is the latest) and an
+  "Update automatically" switch (`auto_update`, on by default). Later daily checks only notify.
+
+Agents that ignored the hook's redirect: only 44 of 368 blocked calls (12%) were followed by a `smart_search` within
+30 s; the rest rewrote the search in Bash, node or python.
+
+- The block message names the exact tool and arguments (`mcp__smart-tool__smart_search` with the project root filled
+  in, `web_fetch` with the URL), says it is a routing rule and not a failure, that redoing the search through Bash,
+  python, node or PowerShell bypasses it, and, in Claude Code, how to load the tool with ToolSearch.
+- The MCP server sends instructions on what to do when a call is blocked, and `smart_search`, `web_fetch`,
+  `web_search` and their `_result` tools load upfront (`anthropic/alwaysLoad`): Claude Code defers MCP tools, so a
+  blocked agent often did not have the replacement in its tool list. In real `claude -p` sessions, an agent asked to
+  read a page went straight to `web_fetch`, and one asked to run a broad `grep -rn` switched to `smart_search` after
+  the block.
+- `cd dir; grep -n x file.py` was measured as a search over the whole tree (the `;` stuck to the directory name hid
+  the file): 45 of the 92 logged Bash redirects with `cd dir;` were reads of one file. A command with a recursive
+  search after a file read (`sed -n 1,9p a.py; grep -rn x src`) is still measured by the directory it searches.
+- A subagent whose tool list has no Smart Tool tool (claude-code-guide, statusline-setup, or an agent in
+  `.claude/agents` with a `tools` list without it) is not redirected: it had nothing to switch to and gave up.
+- Bash commands that change files, the repository or dependencies (`git checkout`, `rm`, `sed -i`, `writeFileSync`,
+  `npm run`, ...) are never redirected and skip the router model: 12 of 283 Bash redirects were such commands.
+
 ## 0.9.5 - beta
 
 Reported by the claude-code-boss session on its first day using 0.9.4.

package/README.md

@@ -29,7 +29,9 @@ are cheaper, or just tells the agent what Smart Tool would do.
 npx @allansantos-dev/smart-tool@latest install
 ```
 
-Run the same command to update; `~/.smart-tool` is kept. It downloads [uv](https://docs.astral.sh/uv/) (checksum
+Updates install themselves: when the tray starts (at logon) and npm has a newer version, it runs this same command in
+a visible console, once per version; the tray menu has "Update to X" (or "Check for updates") on demand and an
+"Update automatically" switch. 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` or the registry, 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
@@ -46,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/code_impact.py

@@ -2,6 +2,7 @@
 which tests reach it through static calls and which files import its module, each with the first line of its
 docstring. Answers the question an agent asks before an edit without a chain of searches and file reads."""
 import os
+import re
 from collections import defaultdict
 
 import code_graph
@@ -17,7 +18,7 @@ NOTE = ("Static analysis of the indexed snapshot plus the files changed in the w
 def _matches(symbols, name):
     path, _sep, wanted = name.strip().rpartition("::")
     path = path.replace("\\", "/").removeprefix("./")
-    pool = [s for s in symbols if s["path"] == path] if path else symbols
+    pool = [s for s in symbols if s["path"] == path or s["path"].endswith("/" + path)] if path else symbols
     exact = [s for s in pool if s["id"] == wanted or s["name"] == wanted]
     return exact or [s for s in pool if s["name"].split(".")[-1] == wanted]
 
@@ -49,6 +50,31 @@ def summaries(root, symbols, wanted_ids):
             if s["id"] in wanted_ids and (s["path"], s["start_line"]) in docs}
 
 
+_TEST_TITLE = re.compile(r"""\b(test|it|describe|suite)(?:\.\w+)?\s*\(\s*(['"`])(.+?)\2""")
+
+
+def _name_test_callbacks(root, by_id, sites):
+    """Anonymous callbacks registered with test('title', fn), it(), describe() are named after their title, so a test
+    reads 'test "loads the config"' instead of 'callback'."""
+    lines_of = {}
+    for site in sites:
+        symbol = by_id.get(site.get("id")) or {}
+        if symbol.get("name", "").split(".")[-1] not in ("callback", "anonymous"):
+            continue
+        path = symbol["path"]
+        if path not in lines_of:
+            try:
+                with open(os.path.join(root, path), encoding="utf-8") as stream:
+                    lines_of[path] = stream.read().splitlines()
+            except (OSError, UnicodeDecodeError):
+                lines_of[path] = []
+        start = symbol["start_line"]
+        text = " ".join(lines_of[path][max(start - 2, 0):start])
+        match = _TEST_TITLE.search(text)
+        if match:
+            site["function"] = f'{match.group(1)} "{match.group(3)[:80]}"'
+
+
 def impact(root, symbol, view_id=None, depth=3, limit=30):
     if not isinstance(symbol, str) or not symbol.strip():
         raise ValueError("Pass symbol: a function, method (Class.method) or class name.")
@@ -92,6 +118,7 @@ def impact(root, symbol, view_id=None, depth=3, limit=30):
     importers = sorted({d["source"] for d in data["dependencies"] if d.get("target") in files and d["source"] not in files})
     ordered_tests = sorted(tests.values(), key=lambda t: (t["hops"], t["path"], t["line"]))
     shown = direct[:limit] + outgoing[:limit] + ordered_tests[:limit]
+    _name_test_callbacks(root, by_id, shown)
     docs = summaries(root, data["symbols"], targets | {site["id"] for site in shown})
     for site in shown:
         doc = docs.get(site.pop("id"))

package/config.py

@@ -33,6 +33,8 @@ DEFAULT_CONFIG = {
     "hook_mode": "redirect",
     "doc_mode": "remind",
     "duplicate_mode": "warn",
+    "auto_update": True,
+    "pattern_proposals": "on",
     "contact": "",
     "model_adapter": "",
     "model_adapter_options": {},
@@ -50,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):
@@ -66,6 +71,23 @@ 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"])
+    if not isinstance(value, bool):
+        raise ValueError(f"Invalid auto_update ({value!r}) in {CONFIG_PATH}: use true or false.")
+    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:

package/duplicates.py

@@ -199,13 +199,16 @@ def _entry(path, name, start, end, file_lines, ext):
             "hash": hashlib.sha1(normalized.encode("utf-8")).hexdigest(), **_features(body, ext, short)}
 
 
-def _working_tree_functions(root, changes, profile):
-    """Production functions of the files changed in the working tree, read from disk, so a copy of a function written
-    earlier in the same session is caught before the index catches up."""
+def _working_tree_functions(root, changes, profile, include_tests=False):
+    """Functions of the files the index does not reflect yet, read from disk (production code, plus tests when
+    include_tests), with the same identity as indexed ones, so a copy written earlier in the session is caught and
+    a function removed since the last indexing is not reported."""
     found = []
+    kinds = ("code", "test") if include_tests else ("code",)
     for rel, status in changes.items():
         ext = rel.rsplit(".", 1)[-1].lower() if "." in rel else ""
-        if status == "deleted" or ext not in _LANG or index_profile.kind(rel, profile) != "code":
+        kind = index_profile.kind(rel, profile)
+        if status == "deleted" or ext not in _LANG or kind not in kinds:
             continue
         try:
             with open(os.path.join(root, rel), encoding="utf-8") as stream:
@@ -215,12 +218,18 @@ def _working_tree_functions(root, changes, profile):
         if _GENERATED.search(source[:4000]):
             continue
         lines = source.splitlines()
-        for function in doc_check.functions(rel, source):
-            if function["end"] - function["start"] + 1 < MIN_LINES:
+        functions = doc_check.functions(rel, source)
+        occurrences = {}
+        for function in functions:
+            if function["end"] - function["start"] + 1 < MIN_LINES or any(
+                    other is not function and other["start"] <= function["start"] and function["end"] <= other["end"]
+                    and (other["start"], other["end"]) != (function["start"], function["end"]) for other in functions):
                 continue
             entry = _entry(rel, function["name"], function["start"], function["end"], lines, ext)
             if entry:
-                found.append({**entry, "kind": "code"})
+                occurrence = occurrences[entry["hash"]] = occurrences.get(entry["hash"], 0) + 1
+                found.append({**entry, "kind": kind, "fp": hashlib.sha1(
+                    f"{rel}\0{entry['hash']}\0{occurrence}".encode("utf-8")).hexdigest()})
     return found
 
 
@@ -359,6 +368,13 @@ def find(root, embed, configured_model, min_similarity=DEFAULT_MIN_SIMILARITY, i
     started = time.monotonic()
     dismissed = dismissed or {}
     functions, notes, view = _functions(root, include_tests)
+    if view.get("current"):
+        pending = code_graph.pending_changes(root, view["path"])
+        if pending:
+            profile = index_profile.current((index_scope.load_scope(root) or {}).get("profile"))
+            functions = [f for f in functions if f["path"] not in pending] + _working_tree_functions(
+                root, pending, profile, include_tests)
+            notes.append(f"{len(pending)} file(s) changed since the last indexing were read from disk.")
     groups = {}
     for f in functions:
         groups.setdefault(f["hash"], []).append(f)