@allansantos-dev/smart-tool 0.9.25 → 0.9.26

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.9.26 - beta
+
+- The daemon no longer re-reads and re-hashes every watched folder in a loop. Measured on the owner's machine: one
+  daemon process read 181 GB and wrote 29.7 GB in 15 h (3.6 MB/s read, 2.2 MB/s write while idle), which kept the disk
+  busy and made Defender scan the files again and again. Causes, all fixed:
+  - A file-event buffer overflow, or more than 1 000 changed paths, raised a full check that opened and hashed every
+    file of the scope; the flag was cleared only when no event arrived during the job, so under constant events (the
+    `~/.claude` session logs, a state folder) every job hashed everything again, and the stuck scope flag also asked the
+    scope model to decide the scope again on every job. An overflow now asks for a stat comparison (mtime and size) of
+    the scope, and a finished job clears the full-check and scope flags raised before it started.
+  - An event under a folder the scope leaves out (`plugins/cache`, `projects/*.jsonl` of `~/.claude`) marked the project
+    dirty and queued an index job. Events are now filtered by the saved scope, which is reloaded only when its file
+    changes.
+  - A folder growing inside an excluded one counted as a structure change and called the scope model again. The
+    structure kept in the scope and the one compared against it skip excluded folders.
+  - The runtime folders of a `.claude` home (`plugins`, `projects`, `sessions`, `shell-snapshots`, `file-history`,
+    `cache`, `debug`, `telemetry`, ...) are excluded mechanically, whatever the scope says.
+  - The monitor decrypted up to 50 job payloads per watched folder every second just to learn whether a job was
+    pending; it now asks the `status` column once per tick. A Git folder is identified again (four git processes)
+    only when `HEAD`, the index or the refs moved, not every 5 s. With a live watcher the stat reconciliation runs
+    every 15 min instead of 3; the tick sleeps 5 s instead of 1 s while nothing is pending.
+  - A burst of events cost two reads and two writes of the project registry per batch; it is one of each, and the
+    registry schema is created once per process instead of per connection.
+  - Every save of a job (several per index job) ordered the whole `jobs` table, payloads included, to prune the history:
+    1.7 MB read per save. The pruning now takes its threshold from an `updated_at` index (50 saves: 85.7 MB read before,
+    5.0 MB after, `tests/save_job_io_probe.py`).
+  - The pending-job query of the monitor tick scanned the whole `jobs` table (2.7 MB) every second; it now reads the
+    covering index `jobs_status`.
+  - A folder that changes all the time (the orchestrator's state folder queued an index job every 8 s) is indexed by the
+    monitor at most once a minute; the changes accumulate and one job covers them.
+  - Measured with `tests/monitor_io_probe.py` on a copy of the real registry (14 watched folders, 100 event batches
+    under excluded folders with a buffer overflow every 10th): 149 MB read and 45.7 MB written before, 28 MB read and
+    5.4 MB written after; folders left with a pending full check 14 before, 0 after.
 ## 0.9.25 - beta
 
 - A redirected search made while the first index of a folder is still being built no longer waits in the folder's queue

package/README.md

@@ -15,7 +15,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.25 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
+**Status:** 0.9.26 beta. Windows only. What changed in each version: [CHANGELOG.md](CHANGELOG.md).
 
 ## How it works
 

package/index_scope.py

@@ -41,6 +41,19 @@ _ALWAYS_EXCLUDE_FILES = {
 
 _ROOT_DOC_NAMES = ("AGENTS.md", "CLAUDE.md", "README.md", "README")
 
+# Runtime folders a tool keeps inside its own config home (conversation logs, plugin caches, snapshots): never project
+# source, written all day by the tool itself. Keyed by the root's folder name; excluded mechanically, whatever the
+# scope decision says, so a registered `~/.claude` never indexes or re-scans them.
+_TOOL_STATE_DIRS = {
+    ".claude": ("backups", "cache", "daemon", "debug", "downloads", "file-history", "ide", "paste-cache", "plugins",
+                "projects", "session-env", "sessions", "shell-snapshots", "state", "statsig", "telemetry", "todos"),
+}
+
+
+def tool_state_excludes(root):
+    """Names of the tool-runtime folders under `root` (empty unless `root` is a known tool config home)."""
+    return _TOOL_STATE_DIRS.get(os.path.basename(os.path.normpath(root)).casefold(), ())
+
 
 def always_excluded(name):
     """Directory name in _ALWAYS_EXCLUDE, entries may be globs (e.g. *.egg-info)."""
@@ -173,11 +186,14 @@ def save_scope(root, scope):
         {**scope, "root": project_identity.canonical_root(root)}, indent=2, ensure_ascii=False))
 
 
-def _structure(root, max_dirs=1500):
+def _structure(root, max_dirs=1500, keep=None):
+    """Relative folders of `root` (at most `max_dirs`). `keep(rel)` prunes the walk: a folder it rejects is neither
+    listed nor entered."""
     found = []
     for current, dirs, _files in os.walk(root):
         dirs[:] = sorted(d for d in dirs if not d.startswith(".") and not always_excluded(d)
-                         and _within_root(root, os.path.join(current, d)))
+                         and _within_root(root, os.path.join(current, d))
+                         and (keep is None or keep(os.path.relpath(os.path.join(current, d), root).replace(os.sep, "/"))))
         for name in dirs:
             found.append(os.path.relpath(os.path.join(current, name), root).replace(os.sep, "/"))
             if len(found) >= max_dirs:
@@ -200,8 +216,10 @@ def needs_rescan(root, cached_scope):
         return True
     known = set(cached_scope.get("top_level_dirs", []))
     current = set(_top_level_dirs(root))
+    # A folder the scope excludes (a cache that grows all day) is not a structure change: the walk skips it.
     return (not current.issubset(known) or
-            not set(_structure(root)).issubset(set(cached_scope.get("structure", []))))
+            not set(_structure(root, keep=scope_filter(cached_scope, root))).issubset(
+                set(cached_scope.get("structure", []))))
 
 
 def _read_root_docs(root, max_chars=4000):
@@ -315,7 +333,7 @@ def decide_scope(root, router_model, force=False, deadline=None, cancel_check=No
         return cached
 
     top_level_dirs = _top_level_dirs(root)
-    ambiguous_dirs = [d for d in top_level_dirs if not always_excluded(d)]
+    ambiguous_dirs = [d for d in top_level_dirs if not always_excluded(d) and d not in tool_state_excludes(root)]
     root_files = _root_level_files(root, _exclude_matcher(_ALWAYS_EXCLUDE_FILES))
     doc_context = _read_root_docs(root)
 
@@ -374,14 +392,17 @@ def decide_scope(root, router_model, force=False, deadline=None, cancel_check=No
 
     if decision is None:
         raise RuntimeError("The model did not define a valid scope. Check the model or set the scope manually.")
+    final = {"include": (decision or {}).get("include") or [],
+             "exclude": [*((decision or {}).get("exclude") or []), *tool_state_excludes(root)],
+             "user_exclude": (cached or {}).get("user_exclude", [])}
     scope = {
-        "include": (decision or {}).get("include") or [],
-        "exclude": (decision or {}).get("exclude") or [],
+        "include": final["include"],
+        "exclude": final["exclude"],
         "top_level_dirs": top_level_dirs,
         "scope_version": SCOPE_VERSION,
-        "structure": _structure(root),
+        "structure": _structure(root, keep=scope_filter(final, root)),
         "docs_digest": _docs_digest(root),
-        "user_exclude": (cached or {}).get("user_exclude", []),
+        "user_exclude": final["user_exclude"],
         "decided_at": time.time(),
     }
     save_scope(root, scope)
@@ -441,20 +462,32 @@ def _exclude_matcher(exclude):
     return matches
 
 
-def in_scope(scope, rel_path):
-    """Whether resolve_included_files would list rel_path: under an include base, outside the exclusions and outside
-    hidden folders."""
-    rel_path = rel_path.replace("\\", "/")
+def scope_filter(scope, root=None):
+    """Predicate `keep(rel_path)`: whether resolve_included_files would list rel_path (a file) or walk it (a folder) —
+    under an include base, outside the exclusions, outside hidden folders. Built once so a burst of file events does not
+    rebuild the matcher per path; `root` adds the tool-runtime folders of a known config home."""
     include = scope.get("include") or [""]
     matcher = _exclude_matcher(set(scope.get("exclude") or []) | set(scope.get("user_exclude") or []) |
-                               _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
-    parts = rel_path.split("/")
-    if matcher(rel_path) or any(part.startswith(".") for part in parts[:-1]):
-        return False
-    if any(base in ("", ".") for base in include):
-        return True
-    return len(parts) == 1 or any(rel_path == base.strip("/") or rel_path.startswith(base.strip("/") + "/")
-                                  for base in include)
+                               set(tool_state_excludes(root) if root else ()) | _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
+    bases = [base.strip("/") for base in include]
+    whole = any(base in ("", ".") for base in include)
+
+    def keep(rel_path):
+        rel_path = rel_path.replace("\\", "/")
+        parts = rel_path.split("/")
+        if matcher(rel_path) or any(part.startswith(".") for part in parts[:-1]):
+            return False
+        if whole or len(parts) == 1:
+            return True
+        return any(rel_path == base or rel_path.startswith(base + "/") for base in bases)
+
+    return keep
+
+
+def in_scope(scope, rel_path, root=None):
+    """Whether resolve_included_files would list rel_path: under an include base, outside the exclusions and outside
+    hidden folders."""
+    return scope_filter(scope, root)(rel_path)
 
 
 def resolve_included_files(root, scope, cancel_check=None):
@@ -462,7 +495,7 @@ def resolve_included_files(root, scope, cancel_check=None):
         raise ValueError("Invalid scope; request a new project analysis.")
     include = scope.get("include") or [""]
     matcher = _exclude_matcher(set(scope.get("exclude") or []) | set(scope.get("user_exclude") or []) |
-                               _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
+                               set(tool_state_excludes(root)) | _ALWAYS_EXCLUDE | _ALWAYS_EXCLUDE_FILES)
     files = []
     def walk_error(error):
         raise OSError("Could not list a folder in the scope; try again when it is accessible.") from error

package/index_views.py

@@ -97,6 +97,11 @@ def storage_key(root):
     return key + '.v-' + view['view_id'] if view['git'] else key
 
 
+def stamp_changed(view):
+    """Whether the Git files that define `view` moved since it was described (a stat of five files, no process)."""
+    return bool(view.get('git')) and _stamp(view) != view.get('stamp')
+
+
 def assert_current(view):
     if view.get('git') and _stamp(view) != view.get('stamp'):
         _CACHE.pop(view['root'], None)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.25",
+  "version": "0.9.26",
   "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/project_monitor.py

@@ -13,6 +13,13 @@ import index_views
 
 DEBOUNCE_S = 5
 RECONCILE_S = 180
+# With a live watcher the events carry the changes; the stat reconciliation is only the safety net for what the buffer
+# lost, so it runs less often (a buffer overflow already forces a stat comparison of the whole scope).
+RECONCILE_WATCHED_S = 900
+IDLE_TICK_S = 5
+# A folder that changes all the time (a tool's state folder) is indexed at most this often by the monitor; the changes
+# keep accumulating and one job covers them, and a search meanwhile reads the stale files straight from disk.
+MIN_JOB_GAP_S = 60
 FULL_CHECK_S = 86400
 MAX_EVENT_PATHS = 1000
 
@@ -50,6 +57,9 @@ class ProjectMonitor:
         self._git_seen = {}
         self._git_checked = {}
         self._pending = {}
+        self._next_job = {}
+        self._filters = {}
+        self._views = {}
         self._lock = threading.RLock()
         self._stop = threading.Event()
         self._thread = None
@@ -71,16 +81,33 @@ class ProjectMonitor:
     def refresh(self):
         self._checked.clear()
 
+    def _scope_for(self, project):
+        """`(scope, keep)` for the project's current view; reloaded only when the saved scope file changed, so a burst
+        of events does not read the scope and rebuild its matcher once per batch."""
+        path = index_scope.scope_path(project["root"])
+        try:
+            stamp = (path, os.stat(path).st_mtime_ns)
+        except OSError:
+            stamp = (path, None)
+        cached = self._filters.get(project["id"])
+        if cached and cached[0] == stamp:
+            return cached[1], cached[2]
+        scope = index_scope.load_scope(project["root"]) or {}
+        keep = index_scope.scope_filter(scope, project["root"]) if scope else (lambda rel: True)
+        self._filters[project["id"]] = (stamp, scope, keep)
+        return scope, keep
+
     def events(self, project_id, rows, overflow=False):
         project = project_store.get(project_id)
         if not project or project.get("paused") or not project.get("watch") or not project.get("enabled"):
             return
-        paths = {row["path"] for row in rows if relevant_path(row.get("path", ""))}
+        # An event under a folder the scope leaves out (plugin cache, session logs) changes nothing in the index.
+        scope, keep = self._scope_for(project)
+        paths = {row["path"] for row in rows if relevant_path(row.get("path", "")) and keep(row["path"])}
         if not paths and not overflow:
             return
         # Um diretório existente também recebe MODIFIED ao mudar um arquivo filho.
         # Só uma estrutura nova ou documentação da raiz exige reavaliar o escopo.
-        scope = index_scope.load_scope(project["root"]) or {}
         known_dirs = {p.casefold() for p in scope.get("structure", [])}
         docs = {name.casefold() for name in index_scope._ROOT_DOC_NAMES}
         force_scope = any(path.casefold() in docs for path in paths) or any(
@@ -94,12 +121,12 @@ class ProjectMonitor:
             state["revision"] = state.get("revision", 0) + 1
             state["paths"].update(paths)
             state["last"] = time.monotonic()
-            state["full"] |= overflow or len(state["paths"]) > MAX_EVENT_PATHS
             state["force_scope"] |= force_scope
-            if state["full"]:
+            # Lost or too many events: the update compares stat of the whole scope (mtime and size), which finds what
+            # changed without reading and hashing every file the way a full check does.
+            if len(state["paths"]) > MAX_EVENT_PATHS:
                 state["paths"].clear()
-        project_store.mark_dirty(project_id, "Changes detected by the monitor.")
-        project_store.record_changes(project_id, paths, full=overflow, scope=force_scope)
+        project_store.note_changes(project_id, "Changes detected by the monitor.", paths, scope=force_scope)
 
     def _watch_error(self, project_id, message):
         project_store.update(project_id, watch_backend="reconciliation", watch_error=message[:300])
@@ -132,6 +159,7 @@ class ProjectMonitor:
         now = time.monotonic()
         projects = project_store.all_projects()
         self._sync_watchers(projects, now)
+        busy = project_store.projects_with_pending_job()
         for project in projects:
             key = project["id"]
             if not project.get("watch") or not project.get("enabled") or project.get("paused"):
@@ -139,16 +167,21 @@ class ProjectMonitor:
             if not os.path.isdir(project["root"]):
                 project_store.update(key, status="unavailable", last_error="The folder is not accessible.")
                 continue
-            if any(job.get("status") == "pending" for job in project_store.jobs(key, limit=50)):
+            if key in busy:
                 continue  # Não planejar outra geração com metadados de uma ainda em curso.
             if now - self._git_checked.get(key, -5) >= 5:
-                view = index_views.describe(project['root'], fresh=True)
+                # A Git view is re-identified (four git processes) only when the files that define it moved.
+                view = self._views.get(key)
+                if view is None or not view.get('git') or index_views.stamp_changed(view):
+                    view = self._views[key] = index_views.describe(project['root'], fresh=True)
                 signature = (view['view_id'], view.get('commit'))
                 if key in self._git_seen and signature != self._git_seen[key]:
                     self.events(key, [], overflow=True)
                 self._git_seen[key] = signature
                 self._git_checked[key] = now
-            if now - self._checked.get(key, -RECONCILE_S) >= RECONCILE_S:
+            watcher = self._watchers.get(key)
+            interval = RECONCILE_WATCHED_S if watcher is not None and watcher.alive else RECONCILE_S
+            if now - self._checked.get(key, -interval) >= interval:
                 self._checked[key] = now
                 scope = index_scope.load_scope(project["root"])
                 meta = indexer.info(project["root"])
@@ -177,7 +210,7 @@ class ProjectMonitor:
                 continue
             with self._lock:
                 pending = self._pending.get(key)
-                if not pending or now - pending["last"] < DEBOUNCE_S:
+                if not pending or now - pending["last"] < DEBOUNCE_S or now < self._next_job.get(key, 0):
                     continue
                 options = {"changed_paths": sorted(pending["paths"]), "full_check": pending["full"],
                            "force_scope": pending["force_scope"]}
@@ -190,6 +223,7 @@ class ProjectMonitor:
             except Exception as exc:
                 project_store.update(key, status="error", last_error=str(exc)[:300], next_retry_at=time.time() + 60)
                 continue
+            self._next_job[key] = now + MIN_JOB_GAP_S
             with self._lock:
                 # Um evento recebido durante o submit continua pendente para a próxima geração.
                 if self._pending.get(key) is pending and pending.get("revision", 0) == revision:
@@ -201,4 +235,4 @@ class ProjectMonitor:
                 self.tick()
             except Exception:
                 pass  # Falha opcional do monitor não derruba o daemon MCP.
-            self._stop.wait(1)
+            self._stop.wait(1 if self._pending else IDLE_TICK_S)

package/project_store.py

@@ -13,18 +13,25 @@ import secret_store
 
 DB_PATH = os.path.join(paths.DATA_DIR, "projects.sqlite3")
 _LOCK = threading.RLock()
+_SCHEMA_READY = set()
 MAX_JOBS = 500
 
 
 @contextmanager
 def _db():
     os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    if not os.path.isfile(DB_PATH):
+        _SCHEMA_READY.discard(DB_PATH)
     db = sqlite3.connect(DB_PATH, timeout=10)
     try:
         db.execute("PRAGMA secure_delete=ON")
-        db.execute("CREATE TABLE IF NOT EXISTS projects(id TEXT PRIMARY KEY, root TEXT NOT NULL, data TEXT NOT NULL, updated_at REAL NOT NULL)")
-        db.execute("CREATE TABLE IF NOT EXISTS jobs(id TEXT PRIMARY KEY, project_id TEXT, status TEXT NOT NULL, updated_at REAL NOT NULL, payload TEXT NOT NULL)")
-        db.execute("CREATE INDEX IF NOT EXISTS jobs_project ON jobs(project_id,updated_at)")
+        if DB_PATH not in _SCHEMA_READY:
+            db.execute("CREATE TABLE IF NOT EXISTS projects(id TEXT PRIMARY KEY, root TEXT NOT NULL, data TEXT NOT NULL, updated_at REAL NOT NULL)")
+            db.execute("CREATE TABLE IF NOT EXISTS jobs(id TEXT PRIMARY KEY, project_id TEXT, status TEXT NOT NULL, updated_at REAL NOT NULL, payload TEXT NOT NULL)")
+            db.execute("CREATE INDEX IF NOT EXISTS jobs_project ON jobs(project_id,updated_at)")
+            db.execute("CREATE INDEX IF NOT EXISTS jobs_updated ON jobs(updated_at)")
+            db.execute("CREATE INDEX IF NOT EXISTS jobs_status ON jobs(status,project_id)")
+            _SCHEMA_READY.add(DB_PATH)
         with db:
             yield db
     finally:
@@ -102,17 +109,62 @@ def record_changes(project_id, paths=(), full=False, scope=False):
         project = get(project_id)
         if not project:
             return
-        merged = set(project.get('dirty_paths', [])) | set(paths)
-        full = full or project.get('needs_full_check', False) or len(merged) > 1000
-        update(project_id, dirty_paths=[] if full else sorted(merged), needs_full_check=full,
-               scope_dirty=scope or project.get('scope_dirty', False))
+        update(project_id, **_changes_fields(project, paths, full, scope))
+
+
+def _changes_fields(project, paths, full, scope):
+    """`needs_full_check` / `scope_dirty` remember the `dirty_seq` at which they were raised (`*_seq`), so a job that ran
+    after that sequence can clear them even while events keep arriving."""
+    merged = set(project.get('dirty_paths', [])) | set(paths)
+    full = full or project.get('needs_full_check', False)
+    scope = scope or project.get('scope_dirty', False)
+    seq = project.get('dirty_seq', 0)
+    # Past 1000 paths the list stops helping: the update compares stat of the whole scope instead.
+    return {"dirty_paths": [] if len(merged) > 1000 else sorted(merged), "needs_full_check": full,
+            "scope_dirty": scope,
+            "full_check_seq": seq if full and not project.get('needs_full_check') else project.get('full_check_seq', 0),
+            "scope_dirty_seq": seq if scope and not project.get('scope_dirty') else project.get('scope_dirty_seq', 0)}
+
+
+def note_changes(project_id, reason, paths=(), full=False, scope=False):
+    """mark_dirty + record_changes in one read and one write of the registry; a burst of file events costs one commit per
+    batch instead of two reads and two commits."""
+    with _LOCK, _db() as db:
+        row = db.execute("SELECT data FROM projects WHERE id=?", (project_id,)).fetchone()
+        if not row:
+            return None
+        data = json.loads(row[0])
+        data["dirty_seq"] = data.get("dirty_seq", 0) + 1
+        data.update(status="dirty" if not data.get("paused") else "paused", dirty_reason=reason,
+                    last_event=time.time(), **_changes_fields(data, paths, full, scope))
+        db.execute("UPDATE projects SET data=?,updated_at=? WHERE id=?",
+                   (json.dumps(data, ensure_ascii=False), time.time(), project_id))
+    return data
 
 
 def confirm_changes(project_id, sequence):
+    """Clears what the finished job covered: the path list only if nothing changed since the job captured `sequence`;
+    the full-check and scope flags if they were raised at or before it (the job did both from that state)."""
     with _LOCK:
         project = get(project_id)
-        if project and project.get('dirty_seq', 0) == sequence:
-            update(project_id, dirty_paths=[], needs_full_check=False, scope_dirty=False)
+        if not project:
+            return
+        fields = {}
+        if project.get('dirty_seq', 0) == sequence:
+            fields.update(dirty_paths=[], needs_full_check=False, scope_dirty=False)
+        else:
+            if project.get('needs_full_check') and project.get('full_check_seq', 0) <= sequence:
+                fields["needs_full_check"] = False
+            if project.get('scope_dirty') and project.get('scope_dirty_seq', 0) <= sequence:
+                fields["scope_dirty"] = False
+        if fields:
+            update(project_id, **fields)
+
+
+def projects_with_pending_job():
+    """Ids of the projects with a job still pending, from the `status` column: no job payload is decrypted."""
+    with _LOCK, _db() as db:
+        return {row[0] for row in db.execute("SELECT DISTINCT project_id FROM jobs WHERE status='pending'")}
 
 
 def save_job(job_id, payload):
@@ -123,8 +175,10 @@ def save_job(job_id, payload):
     with _LOCK, _db() as db:
         db.execute("INSERT OR REPLACE INTO jobs VALUES(?,?,?,?,?)",
                    (job_id, payload.get("project_id"), payload.get("status", "pending"), time.time(), protected))
-        db.execute("DELETE FROM jobs WHERE status!='pending' AND id NOT IN "
-                   "(SELECT id FROM jobs ORDER BY updated_at DESC LIMIT ?)", (MAX_JOBS,))
+        # The threshold comes from the updated_at index alone: ordering the payload rows read the whole jobs table
+        # (1.7 MB) on every save, several saves per job.
+        db.execute("DELETE FROM jobs WHERE status!='pending' AND updated_at < "
+                   "(SELECT updated_at FROM jobs ORDER BY updated_at DESC LIMIT 1 OFFSET ?)", (MAX_JOBS - 1,))
 
 
 def _decode(payload):

package/smart_tool_daemon.py

@@ -1873,7 +1873,8 @@ def _project_action_locked(arguments):
                 "storage_dir": indexer.INDEX_DIR,
                 "gateway": dict(_GATEWAY_STATUS),
                 "monitor": {"debounce_s": project_monitor.DEBOUNCE_S,
-                            "reconcile_s": project_monitor.RECONCILE_S}}
+                            "reconcile_s": project_monitor.RECONCILE_S,
+                            "reconcile_watched_s": project_monitor.RECONCILE_WATCHED_S}}
     if action == "register":
         root = arguments.get("project_root")
         if not isinstance(root, str) or not os.path.isabs(root):

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.25"
+VERSION = "0.9.26"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")