sourcecode 2.6.3__py3-none-any.whl → 2.6.10__py3-none-any.whl

sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "2.6.3"
+__version__ = "2.6.10"

sourcecode/cli.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import difflib
 import os
 import sys
 import threading
@@ -331,6 +332,54 @@ def _reject_path_before_subcommand(path_token: str, subcommand: str) -> "NoRetur
     raise SystemExit(2)
 
 
+def _reject_unknown_command(token: str) -> "NoReturn":
+    """Refuse a first positional that is neither a known subcommand nor a real path.
+
+    `ask` accepts a bare repository path (`ask ./repo`) as an implicit scan, so a
+    mistyped subcommand used to be swallowed as a path and then surfaced a
+    misleading error naming the *wrong* token — `ask spring-audi` complained the
+    directory 'spring-audi' did not exist, and `ask notacommand /tmp` complained
+    'No such command /tmp' (the path, not the typo). Name the token the user
+    actually got wrong, and suggest the closest real commands.
+    """
+    matches = difflib.get_close_matches(token, sorted(_SUBCOMMANDS), n=3, cutoff=0.6)
+    first = f"error: '{token}' is not a known command"
+    if matches:
+        first += f". Did you mean: {', '.join(matches)}?"
+    else:
+        first += " and is not an existing directory to scan."
+    print(
+        first + "\n       run 'ask --help' to list commands, or pass an existing "
+        "repository path.",
+        file=sys.stderr,
+    )
+    raise SystemExit(2)
+
+
+def _has_trailing_nonsubcommand_positional(args: list[str], after: int) -> bool:
+    """True when a bare positional that is NOT a subcommand appears after index
+    ``after`` (options and the values they consume are skipped).
+
+    The implicit scan (`ask <path>`) owns exactly one positional, and a valid
+    invocation with two positionals always starts with a subcommand. So a first
+    non-subcommand positional followed by another non-subcommand positional —
+    `ask notacommand /tmp` — is malformed: the user meant a command. A trailing
+    token that IS a subcommand is left for ``_reject_path_before_subcommand``."""
+    skip_next = False
+    for arg in args[after + 1:]:
+        if skip_next:
+            skip_next = False
+            continue
+        if arg.startswith("-"):
+            if arg.split("=")[0] in _OPTIONS_WITH_VALUE and "=" not in arg:
+                skip_next = True
+            continue
+        if arg in _SUBCOMMANDS:
+            return False  # wrong-order path/subcommand — handled elsewhere
+        return True
+    return False
+
+
 def _preprocess_args(args: list[str]) -> list[str]:
     """Extract a repository path token from an args list and store it in _detected_path.
 
@@ -363,7 +412,13 @@ def _preprocess_args(args: list[str]) -> list[str]:
             return result  # known subcommand — leave for Click to dispatch
         if _path_index >= 0:
             continue  # a later positional is the subcommand's own business
-        # First genuine positional: treat as repository path
+        # First genuine positional. `ask` treats it as the repository path to scan
+        # (existence is validated downstream, not here). But if it is followed by
+        # another non-subcommand positional, the one-path scan cannot own both —
+        # `ask notacommand /tmp` — so the user meant a command: name the token they
+        # got wrong instead of swallowing it and erroring on the next one.
+        if _has_trailing_nonsubcommand_positional(result, i):
+            _reject_unknown_command(arg)
         _set_detected_path(arg)
         _path_index = i
     if _path_index >= 0:
@@ -1278,11 +1333,23 @@ def main(
     _raw_path_input = _get_detected_path()
     target = Path(_raw_path_input).resolve()
     if not target.exists():
+        # A non-existent path that closely matches a command name is almost always a
+        # mistyped subcommand (`ask spring-audi`) swallowed as an implicit-scan path,
+        # not a real directory. Point at the likely command instead of only the path.
+        _cmd_matches = difflib.get_close_matches(
+            _raw_path_input, sorted(_SUBCOMMANDS), n=3, cutoff=0.6
+        )
+        _hint = "Pass an existing repository directory."
+        if _cmd_matches:
+            _hint = (
+                f"If you meant a command, try: {', '.join('ask ' + m for m in _cmd_matches)}. "
+                "Otherwise pass an existing repository directory."
+            )
         _emit_error_json(
             INVALID_INPUT_CODE,
             f"Directory '{_raw_path_input}' does not exist.",
             path=_raw_path_input,
-            hint="Pass an existing repository directory.",
+            hint=_hint,
             expected="An existing directory path.",
         )
         raise typer.Exit(code=1)
@@ -1784,6 +1851,10 @@ def main(
                             )
                     except Exception:
                         pass  # stale value better than crash
+            # C1: token economy on the agent-facing views (cache-hit path).
+            if format == "json" and (compact or agent):
+                from sourcecode.token_estimate import inject_token_economy as _inj_te
+                _cache_hit_content = _inj_te(_cache_hit_content, target)
             _emit_command_output(_cache_hit_content, output, copy)
             return
 
@@ -2632,7 +2703,14 @@ def main(
                 }, indent=2, ensure_ascii=False)
             except Exception:
                 pass
-    _emit_command_output(content, output, copy if not _pipeline_error else False)
+    # C1: token economy on the agent-facing views (fresh path).  Emit-only —
+    # `content` stays clean so the cached L2 view never embeds a stale block
+    # (the cache-hit path recomputes it against the working tree).
+    _emit_content = content
+    if format == "json" and (compact or agent):
+        from sourcecode.token_estimate import inject_token_economy as _inj_te
+        _emit_content = _inj_te(content, target)
+    _emit_command_output(_emit_content, output, copy if not _pipeline_error else False)
 
     # Persist to two-layer cache (git SHA unchanged → re-use on next run).
     #
@@ -5528,7 +5606,7 @@ def spring_audit_cmd(
         help="Accepted for compatibility; this command always reads fresh source (no snapshot cache). No-op.",
     ),
 ) -> None:
-    """Spring semantic audit: TX anomalies (TX-001..005) + security surface (SEC-001..003).
+    """Spring semantic audit: TX anomalies (TX-001..006) + security surface (SEC-001..003).
 
     \b
     Detects:
@@ -5537,6 +5615,7 @@ def spring_audit_cmd(
       TX-003  readOnly=true boundary propagating to write operation
       TX-004  NOT_SUPPORTED/NEVER within active TX chain
       TX-005  Exception swallowing inside @Transactional
+      TX-006  Self-invocation of @Transactional sibling (proxy bypass)
       SEC-001 Unsecured endpoint in annotation_based security model
       SEC-002 CVE-2025-41248: @PreAuthorize on inherited method from generic supertype
       SEC-003 @Transactional on @Controller/@RestController (TX in wrong layer)
@@ -5805,6 +5884,23 @@ def migrate_check_cmd(
         False, "--no-cache",
         help="Accepted for compatibility; this command always reads fresh source (no snapshot cache). No-op.",
     ),
+    snapshot: bool = typer.Option(
+        False, "--snapshot",
+        help="Persist this readiness result as a timeline snapshot under --history-dir.",
+    ),
+    trend: bool = typer.Option(
+        False, "--trend",
+        help="Report the readiness trend across stored snapshots (days-remaining over time) "
+             "instead of scanning. Reads --history-dir.",
+    ),
+    history_dir: Optional[Path] = typer.Option(
+        None, "--history-dir",
+        help="Directory of readiness snapshots (default: <repo>/.ask/readiness-history).",
+    ),
+    ref: Optional[str] = typer.Option(
+        None, "--ref",
+        help="Label for a --snapshot capture (e.g. a version or sprint tag).",
+    ),
 ) -> None:
     """Spring Boot 2→3 migration readiness: detect javax→jakarta namespace blockers.
 
@@ -5836,6 +5932,16 @@ def migrate_check_cmd(
       ask migrate-check /path/to/repo --format text
       ask migrate-check . --min-severity high
       ask migrate-check . --output migration.json
+      ask migrate-check . --snapshot --ref sprint-12   persist a readiness point
+      ask migrate-check . --trend                      days-remaining over time
+
+    \b
+    Readiness time series:
+      --snapshot persists this run's budgetable figures (readiness_score, effort
+      days, per-dimension scores, blocking_count) under --history-dir (default
+      <repo>/.ask/readiness-history). --trend reads that series and reports
+      first→last movement — no improving/degrading label, and readiness_score is
+      flagged not-comparable when the applicable dimension set changed.
     """
     from sourcecode.repository_ir import find_java_files
     from sourcecode.migrate_check import run_migrate_check
@@ -5862,6 +5968,29 @@ def migrate_check_cmd(
         )
         raise typer.Exit(code=1)
 
+    _history_dir = history_dir.resolve() if history_dir else (target / ".ask" / "readiness-history")
+
+    # --trend reads the stored series and reports movement over time; it does not scan.
+    if trend:
+        from sourcecode.readiness_timeline import build_readiness_trend, load_snapshots_dir
+
+        _snaps = load_snapshots_dir(_history_dir) if _history_dir.exists() else []
+        if not _snaps:
+            _emit_error_json(
+                INVALID_INPUT_CODE,
+                f"No readiness snapshots found in '{_history_dir}'.",
+                path=str(_history_dir),
+                hint="Capture points first: ask migrate-check <repo> --snapshot",
+                expected="A directory holding readiness-snapshot-v1 artifacts.",
+            )
+            raise typer.Exit(code=1)
+        _trend = build_readiness_trend(_snaps)
+        _emit_command_output(
+            _serialize_dict(_trend, "json"), output_path, copy,
+            success_msg=f"Readiness trend over {_trend['count']} snapshot(s) → {_history_dir}",
+        )
+        return
+
     _file_limitations: list[str] = []
     file_list = find_java_files(target, limitations=_file_limitations)
     _prog = Progress()
@@ -5882,6 +6011,14 @@ def migrate_check_cmd(
         payload = report.to_compact_dict() if compact else report.to_dict()
         output = _serialize_dict(payload, "json")
 
+    _snapshot_note = ""
+    if snapshot:
+        from sourcecode.readiness_timeline import build_snapshot, write_snapshot
+
+        _snap = build_snapshot(report.to_dict(), ref=ref)
+        _snap_path = write_snapshot(_snap, _history_dir)
+        _snapshot_note = f"; snapshot → {_snap_path}"
+
     _total = report.summary.get("total_findings", 0)
     _emit_command_output(
         output, output_path, copy,
@@ -5889,6 +6026,7 @@ def migrate_check_cmd(
             f"Migration check written to {output_path} "
             f"(score: {report.readiness_score if report.readiness_score is not None else 'N/A'}"
             f"{'/100' if report.readiness_score is not None else ''}, {_total} findings)"
+            f"{_snapshot_note}"
         ),
     )
 
@@ -7897,11 +8035,15 @@ def cold_start_cmd(
             result["endpoints"] = result["endpoints"][:30]
         result["_meta"] = {**(result.get("_meta") or {}), "compact_mode": True,
                            "full_available": "ask cold-start (without --compact)"}
+    from sourcecode.token_estimate import estimate_tokens as _est_tokens, token_economy as _tok_econ
     _out = _json.dumps(result, indent=2, ensure_ascii=False)
     _size = len(_out.encode("utf-8"))
-    _tokens = _size // 4
+    _tokens = _est_tokens(_out)
     _out_with_meta = _json.loads(_out)
-    _out_with_meta.setdefault("_meta", {})["estimated_tokens"] = _tokens
+    _meta_cs = _out_with_meta.setdefault("_meta", {})
+    _meta_cs["estimated_tokens"] = _tokens
+    # C1: what this response costs vs. what reading the same files raw would.
+    _meta_cs["token_economy"] = _tok_econ(_out, _out_with_meta, target)
     _out = _json.dumps(_out_with_meta, indent=2, ensure_ascii=False)
     if not compact and _size > 400_000:
         sys.stderr.write(
@@ -8018,7 +8160,9 @@ def mcp_init(
         typer.echo("No MCP clients found on this system.")
         typer.echo("")
         typer.echo("Manual setup — add to your MCP client config:")
-        typer.echo('  "sourcecode": {"command": "sourcecode", "args": ["mcp", "serve"]}')
+        typer.echo('  "ask": {"command": "ask", "args": ["mcp", "serve"]}')
+        typer.echo('  (VS Code keys these under "servers" and wants "type": "stdio";')
+        typer.echo('   other clients use "mcpServers".)')
         raise typer.Exit(code=0)
 
     # Show detection results
@@ -8070,7 +8214,9 @@ def mcp_init(
             if a.client.config_path.exists():
                 bak = backup.create(a.client.config_path)
                 typer.echo(f"  ✓ Backup   {bak}")
-            updated = applier.apply_entry(config)
+            updated = applier.apply_entry(
+                config, a.client.servers_key, a.client.entry_extra
+            )
             applier.write_config(a.client.config_path, updated)
             if not applier.validate(a.client.config_path):
                 errors.append(f"{a.client.name}: JSON validation failed after write")
@@ -8154,16 +8300,18 @@ def mcp_status() -> None:
             typer.echo(f"    Fix:      ask mcp init --target {client.slug}")
             continue
         config = applier.read_config(client.config_path)
-        if applier.is_installed(config):
+        if applier.is_installed(config, client.servers_key):
             typer.echo(f"  {client.name:<20} ✓ configured   {client.config_path}")
             # FIX-P0-5: inspect registered command for external-server drift.
-            _registered = config.get("mcpServers", {}).get("sourcecode", {})
+            # Reads through the client's own servers key and entry name, so drift is
+            # still detected for clients that key their servers differently.
+            _registered = applier.registered_entry(config, client.servers_key)
             _reg_cmd = _registered.get("command", "")
             _reg_args = _registered.get("args", [])
             # Built-in form: command=sourcecode args=[mcp, serve] (or just the binary)
             _is_builtin = (
-                _reg_cmd == "sourcecode"
-                or (not _reg_args and _reg_cmd.endswith("/sourcecode"))
+                _reg_cmd in ("ask", "sourcecode")
+                or (not _reg_args and _reg_cmd.endswith(("/ask", "/sourcecode")))
                 or (_reg_args and _reg_args[:2] == ["mcp", "serve"])
             )
             if _is_builtin:
@@ -8224,7 +8372,7 @@ def mcp_status() -> None:
     for _c in clients:
         if _c.app_installed:
             _cfg = applier.read_config(_c.config_path)
-            if applier.is_installed(_cfg):
+            if applier.is_installed(_cfg, _c.servers_key):
                 _configured_clients.add(_c.slug)
 
     # Stage 3: Process liveness — is the client app currently running?
@@ -8304,7 +8452,7 @@ def mcp_remove(
             bak = backup.create(a.client.config_path)
             typer.echo(f"  ✓ Backup   {bak}")
             config = applier.read_config(a.client.config_path)
-            updated = applier.remove_entry(config)
+            updated = applier.remove_entry(config, a.client.servers_key)
             applier.write_config(a.client.config_path, updated)
             if not applier.validate(a.client.config_path):
                 errors.append(f"{a.client.name}: JSON validation failed — restoring backup")

sourcecode/file_classifier.py

@@ -300,14 +300,18 @@ class FileClassifier:
         found = frozenset(m.group(1) for m in _JAVA_ANNOTATION_RE.finditer(content))
         if not found:
             return None
+        # Sorted, not set order: this list is emitted as `evidence` in the agent view,
+        # and frozenset iteration order varies with PYTHONHASHSEED — the same repo
+        # analysed twice produced the same evidence in a different order.
+        evidence = sorted(found)
         for required_annotations, category, relevance, why in _JAVA_STEREOTYPE_RULES:
             # For @Data DTO: must have @Data but NOT @Entity
             if required_annotations == frozenset({"Data"}):
                 if "Data" in found and "Entity" not in found:
-                    return FileClassification(path, category, "high", relevance, why, list(found))
+                    return FileClassification(path, category, "high", relevance, why, evidence)
                 continue
             # For compound rules (Service+Transactional, Controller+RequestMapping): all required
             if required_annotations <= found:
-                return FileClassification(path, category, "high", relevance, why, list(found))
+                return FileClassification(path, category, "high", relevance, why, evidence)
         return None
 

sourcecode/mcp/onboarding/applier.py

@@ -25,36 +25,50 @@ def read_config(path: Path) -> dict:
         return {}
 
 
-def is_installed(config: dict) -> bool:
+def is_installed(config: dict, servers_key: str = _MCP_SERVERS_KEY) -> bool:
     """True if the ASK Engine entry (canonical `ask` or legacy `sourcecode`) is
-    already present in mcpServers."""
-    servers = config.get(_MCP_SERVERS_KEY, {})
+    already present in the client's servers map."""
+    servers = config.get(servers_key, {})
     return _ENTRY_NAME in servers or _LEGACY_ENTRY_NAME in servers
 
 
-def apply_entry(config: dict) -> dict:
-    """Return new config dict with the canonical `ask` entry merged into mcpServers.
-    Any legacy `sourcecode` entry is migrated away (removed) so the client launches
-    a single server."""
+def registered_entry(config: dict, servers_key: str = _MCP_SERVERS_KEY) -> dict:
+    """The ASK Engine server entry as currently registered, or an empty dict."""
+    servers = config.get(servers_key, {})
+    if not isinstance(servers, dict):
+        return {}
+    entry = servers.get(_ENTRY_NAME) or servers.get(_LEGACY_ENTRY_NAME) or {}
+    return entry if isinstance(entry, dict) else {}
+
+
+def apply_entry(
+    config: dict,
+    servers_key: str = _MCP_SERVERS_KEY,
+    entry_extra: tuple[tuple[str, str], ...] = (),
+) -> dict:
+    """Return new config dict with the canonical `ask` entry merged into the client's
+    servers map. Any legacy `sourcecode` entry is migrated away (removed) so the client
+    launches a single server. *entry_extra* carries per-client fields (e.g. VS Code's
+    explicit `type: stdio`)."""
     config = dict(config)
-    servers: dict = dict(config.get(_MCP_SERVERS_KEY, {}))
+    servers: dict = dict(config.get(servers_key, {}))
     servers.pop(_LEGACY_ENTRY_NAME, None)
-    servers[_ENTRY_NAME] = _ENTRY_VALUE
-    config[_MCP_SERVERS_KEY] = servers
+    servers[_ENTRY_NAME] = {**_ENTRY_VALUE, **dict(entry_extra)}
+    config[servers_key] = servers
     return config
 
 
-def remove_entry(config: dict) -> dict:
+def remove_entry(config: dict, servers_key: str = _MCP_SERVERS_KEY) -> dict:
     """Return new config dict with the ASK Engine entry removed — both the canonical
     `ask` key and any legacy `sourcecode` key."""
     config = dict(config)
-    servers: dict = dict(config.get(_MCP_SERVERS_KEY, {}))
+    servers: dict = dict(config.get(servers_key, {}))
     servers.pop(_ENTRY_NAME, None)
     servers.pop(_LEGACY_ENTRY_NAME, None)
     if servers:
-        config[_MCP_SERVERS_KEY] = servers
-    elif _MCP_SERVERS_KEY in config:
-        del config[_MCP_SERVERS_KEY]
+        config[servers_key] = servers
+    elif servers_key in config:
+        del config[servers_key]
     return config
 
 

sourcecode/mcp/onboarding/detector.py

@@ -38,6 +38,38 @@ _CLIENT_REGISTRY: List[Dict[str, Any]] = [
             "win32": "Cursor",
         },
     },
+    {
+        "name": "Windsurf",
+        "slug": "windsurf",
+        "paths": {
+            "darwin": "~/.codeium/windsurf/mcp_config.json",
+            "linux": "~/.codeium/windsurf/mcp_config.json",
+            "win32": "{USERPROFILE}/.codeium/windsurf/mcp_config.json",
+        },
+        "process": {
+            "darwin": "Windsurf",
+            "linux": "windsurf",
+            "win32": "Windsurf",
+        },
+    },
+    {
+        # VS Code keys its servers under "servers" (not "mcpServers") and wants an
+        # explicit transport on each entry — hence the per-client overrides below.
+        "name": "VS Code",
+        "slug": "vscode",
+        "paths": {
+            "darwin": "~/Library/Application Support/Code/User/mcp.json",
+            "linux": "~/.config/Code/User/mcp.json",
+            "win32": "{APPDATA}/Code/User/mcp.json",
+        },
+        "process": {
+            "darwin": "Code Helper",
+            "linux": "code",
+            "win32": "Code",
+        },
+        "servers_key": "servers",
+        "entry_extra": (("type", "stdio"),),
+    },
 ]
 
 
@@ -48,6 +80,10 @@ class MCPClient:
     app_installed: bool  # True if the config file (or its parent dir) exists
     process_name: str    # OS process name for connectivity check
     slug: str            # --target identifier (e.g. "claude-desktop")
+    # Config-shape differences between clients. Defaults match the common shape
+    # (Claude Desktop / Cursor / Windsurf), so only divergent clients declare them.
+    servers_key: str = "mcpServers"                    # top-level key holding the servers map
+    entry_extra: tuple[tuple[str, str], ...] = ()      # extra fields on the server entry
 
 
 def _resolve(template: str) -> Path:
@@ -79,6 +115,8 @@ def detect_clients() -> list[MCPClient]:
             app_installed=app_installed,
             process_name=process_name,
             slug=entry["slug"],
+            servers_key=entry.get("servers_key", "mcpServers"),
+            entry_extra=tuple(entry.get("entry_extra", ())),
         ))
     return clients
 

sourcecode/mcp/onboarding/planner.py

@@ -21,7 +21,7 @@ def build_install_plan(clients: list[MCPClient]) -> list[ClientAction]:
         config = read_config(client.config_path)
         actions.append(ClientAction(
             client=client,
-            already_installed=is_installed(config),
+            already_installed=is_installed(config, client.servers_key),
             will_create_file=not client.config_path.exists(),
         ))
     return actions
@@ -34,7 +34,7 @@ def build_remove_plan(clients: list[MCPClient]) -> list[ClientAction]:
         config = read_config(client.config_path)
         actions.append(ClientAction(
             client=client,
-            already_installed=is_installed(config),
+            already_installed=is_installed(config, client.servers_key),
             will_create_file=False,
         ))
     return actions

sourcecode/mcp/server.py

@@ -28,21 +28,54 @@ from sourcecode.error_schema import (
 )
 from sourcecode.mcp.runner import CommandError, run_command
 
-# Patch FastMCP's Tool.run to intercept pydantic.ValidationError and return
-# structured JSON instead of the raw "Error executing tool X: 1 validation
-# error..." plain-text string that FastMCP produces by default.
+def _record_tool_invocation(name: Any, success: bool, started: float) -> None:
+    """Count one MCP tool invocation (Bloque C / C3 — adoption).
+
+    Aggregate only: which of our own tools ran, whether it succeeded, and a
+    duration bucket. Never the arguments — those carry repository paths — and
+    never any result content. Honours the same opt-out as every other event
+    (`ask telemetry disable`, SOURCECODE_TELEMETRY=0, DO_NOT_TRACK=1); when
+    telemetry is off, `record` returns before building anything.
+    """
+    try:
+        import time as _time
+
+        from sourcecode import telemetry as _tel
+
+        _tel.record(
+            "mcp_tool_invoked",
+            cmd="mcp",
+            tool=str(name) if name else None,
+            duration_s=_time.monotonic() - started,
+            success=success,
+        )
+    except Exception:
+        pass  # telemetry must never affect a tool call
+
+
+# Patch FastMCP's Tool.run to (a) count the invocation and (b) intercept
+# pydantic.ValidationError and return structured JSON instead of the raw
+# "Error executing tool X: 1 validation error..." plain-text string that FastMCP
+# produces by default.
 try:
-    import pydantic as _pydantic
+    import time as _time_mod
+
     from mcp.server.fastmcp.tools.base import Tool as _FastMCPTool
 
+    try:
+        import pydantic as _pydantic
+    except Exception:  # pragma: no cover — counting must not depend on pydantic
+        _pydantic = None  # type: ignore[assignment]
+
     _orig_tool_run = _FastMCPTool.run
 
     async def _patched_tool_run(self, arguments, context=None, convert_result=False):  # type: ignore[override]
+        _started = _time_mod.monotonic()
         try:
-            return await _orig_tool_run(self, arguments, context=context, convert_result=convert_result)
+            _result = await _orig_tool_run(self, arguments, context=context, convert_result=convert_result)
         except Exception as _exc:
             _cause = getattr(_exc, "__cause__", None)
-            if isinstance(_cause, _pydantic.ValidationError):
+            if _pydantic is not None and isinstance(_cause, _pydantic.ValidationError):
                 _errors = _cause.errors()
                 _missing = [str(e.get("loc", ("?",))[0]) for e in _errors if e.get("type") == "missing"]
                 _msg = f"Missing required field: {_missing[0]}" if _missing else "Argument validation failed"
@@ -56,8 +89,14 @@ try:
                         expected=f"{self.name} arguments with required field '{_missing[0]}'" if _missing else f"{self.name} arguments",
                     ),
                 }
+                _record_tool_invocation(self.name, False, _started)
                 return _payload
+            _record_tool_invocation(self.name, False, _started)
             raise
+        _record_tool_invocation(
+            self.name, not getattr(_result, "isError", False), _started
+        )
+        return _result
 
     _FastMCPTool.run = _patched_tool_run  # type: ignore[method-assign]
 except Exception:

sourcecode/mcp_nudge.py

@@ -41,7 +41,7 @@ except Exception:  # pragma: no cover
     def detect_clients() -> list:  # type: ignore[misc]
         return []
 
-    def is_installed(config: dict) -> bool:  # type: ignore[misc]
+    def is_installed(config: dict, servers_key: str = "mcpServers") -> bool:  # type: ignore[misc]
         return False
 
     def read_config(path: Path) -> dict:  # type: ignore[misc]
@@ -60,7 +60,8 @@ def nudge_mcp_if_needed() -> None:
         return
 
     needs_nudge = any(
-        c.app_installed and not is_installed(read_config(c.config_path))
+        c.app_installed
+        and not is_installed(read_config(c.config_path), getattr(c, "servers_key", "mcpServers"))
         for c in clients
     )