sourcecode 2.6.5__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.5"
+__version__ = "2.6.10"

sourcecode/cli.py

@@ -1851,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
 
@@ -2699,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).
     #
@@ -5873,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.
 
@@ -5904,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
@@ -5930,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()
@@ -5950,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,
@@ -5957,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}"
         ),
     )
 
@@ -7965,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(
@@ -8086,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
@@ -8138,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")
@@ -8222,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:
@@ -8292,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?
@@ -8372,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
     )
 

sourcecode/readiness_timeline.py

@@ -0,0 +1,178 @@
+"""readiness_timeline.py — migration-readiness time series.
+
+Persists a compact ``readiness-snapshot-v1`` artifact per capture and projects a
+trend across N snapshots ordered by capture time. The moat is the *quantified,
+budgetable* readiness score and estimated effort tracked over time — the
+"days-remaining" line a migration lead can put in front of management.
+
+Discipline (matches architectural_baseline / the product's measured-not-ROI rule):
+  * Movement only. The trend reports first→last deltas; it never labels a change
+    "improving" or "degrading" — the reader decides what a rising score means.
+  * Honest gaps. A delta is emitted only when BOTH endpoints carry the value;
+    a ``None`` readiness (no applicable migration dimension) yields no delta, and
+    a change in ``applicable_dimensions`` flags the score as not strictly
+    comparable rather than silently diffing incomparable numbers.
+  * Deterministic projection. A fixed set of snapshots always yields the same
+    trend; only the wall-clock capture time (a real event) varies between runs.
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+READINESS_SNAPSHOT_SCHEMA = "readiness-snapshot-v1"
+READINESS_TREND_SCHEMA = "readiness-trend-v1"
+
+# Budgetable score fields lifted from a migrate-check report, tracked over time.
+_SCORE_FIELDS: tuple[str, ...] = (
+    "readiness_score",
+    "jakarta_readiness",
+    "boot3_readiness",
+    "hibernate_readiness",
+    "jdk_modernization",
+)
+# Numeric tracks that carry a first→last delta (scores + the two headline totals).
+_DELTA_FIELDS: tuple[str, ...] = _SCORE_FIELDS + ("blocking_count", "estimated_effort_days")
+
+
+def _utc_now() -> str:
+    # Microsecond precision so two captures in the same second stay distinct and
+    # the lexicographic ISO sort remains chronological (same rule as baselines).
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+def _tool_version() -> str:
+    try:
+        from sourcecode import __version__
+        return str(__version__)
+    except Exception:
+        return ""
+
+
+def build_snapshot(report: dict, *, ref: Optional[str] = None) -> dict:
+    """Freeze the budgetable readiness fields of a migrate-check report dict.
+
+    ``report`` is the dict from ``MigrateCheckReport.to_dict()``. Only the
+    timeseries-relevant fields are kept — the snapshot is a point on a line, not
+    a full re-storable report.
+    """
+    snap: dict[str, Any] = {
+        "schema_version": READINESS_SNAPSHOT_SCHEMA,
+        "captured_at": _utc_now(),
+        "ref": ref or "",
+        "git_head": report.get("git_head") or "",
+        "repo_id": report.get("repo_id") or "",
+        "tool_version": _tool_version(),
+        "readiness_aggregate": report.get("readiness_aggregate"),
+        "applicable_dimensions": sorted(report.get("applicable_dimensions") or []),
+        "blocking_count": report.get("blocking_count"),
+        "estimated_effort_days": report.get("estimated_effort_days"),
+    }
+    for f in _SCORE_FIELDS:
+        snap[f] = report.get(f)
+    return snap
+
+
+def _snapshot_filename(snapshot: dict) -> str:
+    """Timestamp-stemmed filename (microsecond-unique) so re-scans never collide."""
+    stem = snapshot.get("captured_at") or "snapshot"
+    safe = "".join(c if (c.isalnum() or c in "-_.") else "-" for c in str(stem))
+    return f"{safe}.json"
+
+
+def write_snapshot(snapshot: dict, out_dir: Path) -> Path:
+    """Write `snapshot` as deterministic JSON under `out_dir`; return the path."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    path = out_dir / _snapshot_filename(snapshot)
+    path.write_text(
+        json.dumps(snapshot, sort_keys=True, indent=2) + "\n", encoding="utf-8"
+    )
+    return path
+
+
+def load_snapshot(path: Path) -> dict:
+    """Load and validate one readiness-snapshot artifact."""
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(data, dict) or data.get("schema_version") != READINESS_SNAPSHOT_SCHEMA:
+        raise ValueError(
+            f"{path}: not a {READINESS_SNAPSHOT_SCHEMA} artifact "
+            f"(schema_version={data.get('schema_version') if isinstance(data, dict) else type(data).__name__})."
+        )
+    return data
+
+
+def load_snapshots_dir(directory: Path) -> list[dict]:
+    """Load every readiness snapshot in `directory`, sorted by capture time.
+
+    Malformed / foreign JSON files are skipped, not fatal — a snapshots directory
+    can hold unrelated files without breaking the trend.
+    """
+    out: list[dict] = []
+    for p in sorted(Path(directory).glob("*.json")):
+        try:
+            out.append(load_snapshot(p))
+        except (ValueError, json.JSONDecodeError, OSError):
+            continue
+    out.sort(key=lambda s: (str(s.get("captured_at", "")), str(s.get("git_head", ""))))
+    return out
+
+
+def build_readiness_trend(snapshots: list[dict]) -> dict:
+    """Project a readiness trend across time-ordered snapshots.
+
+    Emits one point per snapshot plus first→last deltas for the numeric tracks.
+    Movement only — no improving/degrading verdict.
+    """
+    points = [
+        {
+            "captured_at": s.get("captured_at"),
+            "ref": s.get("ref") or "",
+            "git_head": s.get("git_head") or "",
+            "tool_version": s.get("tool_version") or "",
+            "readiness_aggregate": s.get("readiness_aggregate"),
+            "applicable_dimensions": list(s.get("applicable_dimensions") or []),
+            **{f: s.get(f) for f in _DELTA_FIELDS},
+        }
+        for s in snapshots
+    ]
+
+    deltas: dict[str, Any] = {}
+    if len(snapshots) >= 2:
+        first, last = snapshots[0], snapshots[-1]
+        for f in _DELTA_FIELDS:
+            a, b = first.get(f), last.get(f)
+            if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+                deltas[f] = round(b - a, 3) if isinstance(b - a, float) else b - a
+            else:
+                deltas[f] = None  # honest: value missing at an endpoint → no delta
+
+    # Comparability: the readiness_score is a min over applicable dimensions, so it
+    # is only strictly comparable when the applicable set is unchanged end-to-end.
+    dims_changed = False
+    if len(snapshots) >= 2:
+        dims_changed = (
+            sorted(snapshots[0].get("applicable_dimensions") or [])
+            != sorted(snapshots[-1].get("applicable_dimensions") or [])
+        )
+
+    notes = ["Movement only — the series reports change, not an improving/degrading verdict."]
+    if dims_changed:
+        notes.append(
+            "applicable_dimensions changed across the series — readiness_score endpoints "
+            "are not strictly comparable (the score is a min over a different dimension set)."
+        )
+
+    return {
+        "schema_version": READINESS_TREND_SCHEMA,
+        "count": len(snapshots),
+        "span": (
+            {"from": snapshots[0].get("captured_at"), "to": snapshots[-1].get("captured_at")}
+            if snapshots else {"from": None, "to": None}
+        ),
+        "points": points,
+        "deltas": deltas,
+        "comparable": (not dims_changed) if len(snapshots) >= 2 else None,
+        "notes": notes,
+    }

sourcecode/telemetry/__init__.py

@@ -78,6 +78,7 @@ def record(
     success: bool = True,
     error_kind: Optional[str] = None,
     feature: Optional[str] = None,
+    tool: Optional[str] = None,
     repo_size: Optional[str] = None,
 ) -> None:
     """Record a telemetry event. Fire-and-forget — never blocks or raises.
@@ -107,6 +108,7 @@ def record(
             success=success,
             error_kind=error_kind,
             feature=feature,
+            tool=tool,
             install=get_install_id(),
             session=_SESSION,
         )

sourcecode/telemetry/consent.py

@@ -20,7 +20,8 @@ _NOTICE = """\
   Anonymous usage metrics help improve sourcecode.
 
   Collected: tool version, Python version, OS, commands used,
-  flags used, approximate repo size, execution duration, errors.
+  flags used, MCP tool names invoked, approximate repo size,
+  execution duration, errors.
 
   Never collected: source code, file paths, file names, secrets,
   tokens, environment variables, or any repository content.

sourcecode/telemetry/events.py

@@ -60,6 +60,8 @@ class TelemetryEvent:
         success     — True/False
         error_kind  — exception class name only (no message, no traceback)
         feature     — gated feature / task name (closed categorical set) or None
+        tool        — MCP tool name for mcp_tool_invoked events, or None. A product
+                      identifier from our own tool registry, never user input.
         install     — stable anonymous install UUID (random, no PII); enables
                       unique-user / conversion / retention metrics
         session     — 8-char random hex, ephemeral, NOT persisted
@@ -79,5 +81,6 @@ class TelemetryEvent:
     success: bool = True
     error_kind: Optional[str] = None
     feature: Optional[str] = None
+    tool: Optional[str] = None
     install: str = ""
     session: str = ""

sourcecode/telemetry/filters.py

@@ -56,7 +56,7 @@ _SAFE_FLAGS: frozenset[str] = frozenset({
 
 _SAFE_OS: frozenset[str] = frozenset({"linux", "macos", "windows", "other"})
 _SAFE_ARCH: frozenset[str] = frozenset({"x64", "arm64", "other"})
-_SAFE_CMD: frozenset[str] = frozenset({"analyze", "prepare-context", "telemetry", "unknown"})
+_SAFE_CMD: frozenset[str] = frozenset({"analyze", "prepare-context", "telemetry", "mcp", "unknown"})
 _SAFE_EVENTS: frozenset[str] = frozenset({
     "command_executed",
     "execution_completed",
@@ -65,6 +65,7 @@ _SAFE_EVENTS: frozenset[str] = frozenset({
     "telemetry_disabled",
     "gate_blocked",
     "activation",
+    "mcp_tool_invoked",
 })
 # Closed set of gated features / task names. Used to learn which capability
 # drives Pro demand. All values are fixed product identifiers — no user data.
@@ -109,6 +110,20 @@ def _safe_error_kind(value: str | None) -> str | None:
     return name[:64] if name else None
 
 
+def _safe_tool(value: str | None) -> str | None:
+    """Keep an MCP tool name only if it looks like one of our own identifiers.
+
+    Tool names are product identifiers minted by the MCP registry (snake_case
+    ASCII, e.g. `get_compact_context`) — a caller cannot invoke a name we did not
+    register, so no user data can reach this field. The shape is still enforced
+    here rather than trusted: anything with a path separator, whitespace, an
+    unusual character or excess length is dropped outright.
+    """
+    if not value:
+        return None
+    return value if re.match(r"^[a-z][a-z0-9_]{0,47}$", value) else None
+
+
 def _safe_session(value: str) -> str:
     """Session ID must be a short hex string only."""
     if re.match(r"^[0-9a-f]{1,16}$", value):
@@ -151,6 +166,10 @@ def sanitize(event: TelemetryEvent) -> dict[str, Any]:
     if event.feature:
         safe["feature"] = _safe_str(event.feature, _SAFE_FEATURES, "other")
 
+    tool = _safe_tool(event.tool)
+    if tool:
+        safe["tool"] = tool
+
     install = _safe_install(event.install)
     if install:
         safe["install"] = install

sourcecode/token_estimate.py

@@ -0,0 +1,213 @@
+"""Token accounting for agent-facing responses (Bloque C / C1).
+
+Two numbers, both measured, neither invented:
+
+- ``emitted``            — tokens the response itself costs the agent.
+- ``baseline_raw_read``  — tokens the same agent would have spent reading, raw,
+  the files this response is derived from and points at (the counterfactual).
+
+``saved = max(0, baseline_raw_read - emitted)``.
+
+Honesty contract (F-1 / measured-not-ROI):
+
+- It is an ESTIMATE and declares itself as one (``basis``, ``token_model``).
+- The token model is ``chars/4`` — an approximation, declared, no tokenizer
+  dependency and no per-vendor tokenizer branching.
+- It is an UPPER BOUND of the saving, clamped at 0. Never inflated to the whole
+  repository, never expressed as money or ROI.
+- It is deterministic: a pure function of (response, files on disk).
+
+VAI: file selection is structural — a string counts as a citation only when it
+resolves to a real file under the repo root; anchors come from the existing
+manifest primitives in :mod:`sourcecode.scanner`. No branching on proprietary
+names.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any, Iterable
+
+#: Declared token model. Approximation, not a tokenizer.
+TOKEN_MODEL = "chars/4"
+
+#: Declared counterfactual basis.
+ECONOMY_BASIS = "counterfactual_raw_read_estimate:cited_files+build_anchors"
+
+#: Bound on how many strings are inspected while harvesting citations.
+_MAX_STRINGS_SCANNED = 20_000
+
+#: Bound on how many distinct files are stat-ed for the baseline.
+_MAX_FILES_COUNTED = 2_000
+
+#: Trailing ``:123`` / ``:123:45`` location suffixes on cited paths.
+_LOC_SUFFIX = re.compile(r":\d+(?::\d+)?$")
+
+
+def estimate_tokens(text: str | bytes) -> int:
+    """Estimate tokens for *text* under the declared ``chars/4`` model.
+
+    Uses UTF-8 byte length so multi-byte content is not under-counted.
+    """
+    if isinstance(text, str):
+        raw = text.encode("utf-8")
+    else:
+        raw = text
+    return len(raw) // 4
+
+
+def _iter_strings(node: Any, budget: list[int]) -> Iterable[str]:
+    """Yield every string in a nested dict/list payload, bounded by *budget*."""
+    if budget[0] <= 0:
+        return
+    if isinstance(node, str):
+        budget[0] -= 1
+        yield node
+    elif isinstance(node, dict):
+        for value in node.values():
+            yield from _iter_strings(value, budget)
+            if budget[0] <= 0:
+                return
+    elif isinstance(node, (list, tuple)):
+        for value in node:
+            yield from _iter_strings(value, budget)
+            if budget[0] <= 0:
+                return
+
+
+def collect_cited_files(payload: Any, root: Path) -> list[str]:
+    """Repo-relative paths cited by *payload* that resolve to real files.
+
+    A string is a citation only if it resolves to an existing regular file
+    inside *root* — structural test, no name heuristics. Fully-qualified class
+    names, prose and identifiers therefore never count.
+    """
+    try:
+        root = root.resolve()
+    except OSError:
+        return []
+    seen: set[str] = set()
+    for text in _iter_strings(payload, [_MAX_STRINGS_SCANNED]):
+        candidate = _LOC_SUFFIX.sub("", text.strip())
+        if not candidate or len(candidate) > 512 or "\n" in candidate:
+            continue
+        if "/" not in candidate and "\\" not in candidate:
+            continue  # bare names are ambiguous — never guessed
+        try:
+            path = Path(candidate)
+            resolved = (root / path).resolve() if not path.is_absolute() else path.resolve()
+            rel = resolved.relative_to(root)
+        except (OSError, ValueError):
+            continue
+        if not resolved.is_file():
+            continue
+        seen.add(str(rel))
+        if len(seen) >= _MAX_FILES_COUNTED:
+            break
+    return sorted(seen)
+
+
+def collect_anchor_files(root: Path) -> list[str]:
+    """Build manifests at depth 0–1 — the files any agent reads to orient.
+
+    Reuses the scanner's manifest primitives rather than a private name list.
+    """
+    try:
+        from sourcecode.scanner import DEFAULT_EXCLUDES, find_manifest_paths
+    except Exception:
+        return []
+    try:
+        root = root.resolve()
+        paths = find_manifest_paths(root, DEFAULT_EXCLUDES)
+    except Exception:
+        return []
+    out: set[str] = set()
+    for p in paths:
+        try:
+            out.add(str(Path(p).resolve().relative_to(root)))
+        except (OSError, ValueError):
+            continue
+    return sorted(out)
+
+
+def _sum_file_tokens(root: Path, rel_paths: Iterable[str]) -> tuple[int, int]:
+    """(tokens, files_counted) for *rel_paths*, by on-disk size under the model."""
+    total = 0
+    counted = 0
+    for rel in rel_paths:
+        try:
+            size = (root / rel).stat().st_size
+        except OSError:
+            continue
+        total += size // 4
+        counted += 1
+    return total, counted
+
+
+def token_economy(
+    rendered: str,
+    payload: Any,
+    root: Path,
+    *,
+    extra_files: Iterable[str] = (),
+) -> dict[str, Any]:
+    """Measured token economy block for a response.
+
+    Args:
+        rendered: the response exactly as it will be emitted (pre-injection).
+        payload: the parsed response, harvested for file citations.
+        root: repository root the citations are relative to.
+        extra_files: additional repo-relative paths to count in the baseline.
+
+    Returns a dict destined for ``_meta.token_economy``.
+    """
+    try:
+        root = Path(root).resolve()
+    except OSError:
+        root = Path(root)
+
+    files = set(collect_cited_files(payload, root))
+    files.update(collect_anchor_files(root))
+    for extra in extra_files:
+        files.add(str(extra))
+
+    baseline, counted = _sum_file_tokens(root, sorted(files))
+    emitted = estimate_tokens(rendered)
+    return {
+        "emitted": emitted,
+        "baseline_raw_read": baseline,
+        "saved": max(0, baseline - emitted),
+        "files_counted": counted,
+        "basis": ECONOMY_BASIS,
+        "token_model": TOKEN_MODEL,
+        "estimate": True,
+        "note": (
+            "Upper-bound estimate: tokens an agent would spend reading the cited "
+            "files and build manifests raw, minus this response. Measured from "
+            "file sizes under the declared token model — not exact, not a "
+            "monetary figure. 'emitted' excludes this block."
+        ),
+    }
+
+
+def inject_token_economy(content: str, root: Path) -> str:
+    """Add ``_meta.token_economy`` to a JSON response string.
+
+    Returns *content* unchanged on any parse failure or non-dict payload, so a
+    YAML/plain response passes straight through.
+    """
+    import json as _json
+
+    try:
+        payload = _json.loads(content)
+        if not isinstance(payload, dict):
+            return content
+        economy = token_economy(content, payload, root)
+        meta = payload.get("_meta")
+        if not isinstance(meta, dict):
+            meta = {}
+        meta["token_economy"] = economy
+        payload["_meta"] = meta
+        return _json.dumps(payload, indent=2, ensure_ascii=False)
+    except Exception:
+        return content

{sourcecode-2.6.5.dist-info → sourcecode-2.6.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 2.6.5
+Version: 2.6.10
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm

{sourcecode-2.6.5.dist-info → sourcecode-2.6.10.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=P9Q5ycRTxeFZymRbTTRJpWf5WptRYL1ZBeI0mayU4iI,308
+sourcecode/__init__.py,sha256=28Itwr5b8-1VcEBeVmo63jQmi5T8llZbG2Sve5wnruA,309
 sourcecode/adaptive_scanner.py,sha256=yJBKjNpkY6bpueYJ2YnRezen3sYZDecEt7WaaNWdqug,9466
 sourcecode/archetype.py,sha256=UrmiONHfqLl7UfGzjECoQBO28hcM_1rvzn0hCt0EtjU,35033
 sourcecode/architectural_baseline.py,sha256=7QzJri4pbL3nzAn9gNutZW6mZR8HHD6H2C2H1EEwYPE,17904
@@ -13,7 +13,7 @@ sourcecode/canonical_ir.py,sha256=LdP_Ri3rl0M5p-MY0ypVvQwhq1WuUF1FmaHid7zyzEg,29
 sourcecode/change_plan.py,sha256=MNgNyu4zrLGvBBaXPwyCh-T2ZGaUQX3Hm4W87uuhZ3w,7750
 sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,12078
 sourcecode/classifier.py,sha256=JBzPwSSrDG-tUHAbcKB678HRbjLpD-ohzbzzO62mgpo,20114
-sourcecode/cli.py,sha256=UZzhlXAHXT0saZcnhr0QQ2LXUIkP2qfB-V_hlf9tDJ4,366305
+sourcecode/cli.py,sha256=BgfbJPIpItFNmw1HzcasWxi1emhgNJ4ne7wPmQIQfdE,370433
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/compare.py,sha256=jdePg0dNCxFpysiTGMsROL5XABLjy_zVUgVeySvdb0o,7514
 sourcecode/confidence_analyzer.py,sha256=vnbPI-20FnHdjO6STxHW8fbaxmB4A7y58io63ibFZjc,21586
@@ -37,7 +37,7 @@ sourcecode/error_schema.py,sha256=uwosfNaSujtYm11_732Hu92z5ITV040fQDaIyefSvR4,16
 sourcecode/evidence_provider.py,sha256=GSSL44JEaouO5AHks2sB3d1YvC9xIKIld1yBYxZpXxo,4277
 sourcecode/explain.py,sha256=HnHWVTNNf9fzeR3FP-A-eXKeKZvBcUEuODgIO3rJQkQ,22312
 sourcecode/file_chunker.py,sha256=3vkM3mDQ5eE_yTPvUgjyjpGFBIjkW6_mrBmIbrylnA8,16444
-sourcecode/file_classifier.py,sha256=A0fEABqtfVu1MfoaxnPAvGpZgneGgVXlJDhT74NYXxE,15314
+sourcecode/file_classifier.py,sha256=pJCeN9KqWpAwKMCgGP4KDsBjuWMeo4zlbj5fv3hk9dA,15587
 sourcecode/filter_surface.py,sha256=qunis3-yY_nhOIj5K3mVFtbSyKfc6ugIX23OSxTolwE,7079
 sourcecode/format_contract.py,sha256=U83J_LtrpMQSN3_H_HBBxpanlo7xnfvbZw7sP3ew8_M,3678
 sourcecode/fqn_utils.py,sha256=XLU7zDkNBXz_RZkIUNfpPmp1nekWtqP-fxV92tDV1vg,2158
@@ -47,7 +47,7 @@ sourcecode/graph_evidence.py,sha256=rENNsYRZeNstX_ExNCLlbHJAruFQwxo5d00x6wO3xwI,
 sourcecode/hibernate_strat.py,sha256=h0leIhlWvSjYq3F99LxvLIDLrJ-xPYxWAREG4LkqZ-4,61190
 sourcecode/jdk_exports.py,sha256=fCrlwNAXUT9gge_joq6kMnY3zJxYB2pxqy-0w3o3MJI,874
 sourcecode/license.py,sha256=keFuwNxdAtvK2Ds91Wl79GMYxuxWYnN5Wbw1qBpaoUI,24896
-sourcecode/mcp_nudge.py,sha256=yjwclsBVsDg1BtocGdEi6GYV4vzPo-SBlC9pIcNmlDM,2910
+sourcecode/mcp_nudge.py,sha256=lKemOqK_wny2u7Ymcr2Idi5Kx8pXY02jCi-_nJYLGMg,2992
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
 sourcecode/migrate_check.py,sha256=hsKNwipl-bSqRsYqG1O_CLbXpMlqtnN-Bif3hpHpnjg,108676
 sourcecode/openapi_surface.py,sha256=BTt0K-woZbkbWTN77IkqeBm_Okag9owR0848fmot8sk,16207
@@ -60,6 +60,7 @@ sourcecode/pr_impact.py,sha256=dCDVw83EDbyVf6F9ZmEQmsFz8ruVH7d4mpeKQCIZHM0,16805
 sourcecode/prepare_context.py,sha256=GkdI_a0RG8Y8dh8x6SpCNKZwWi7qs8sqAbFSYJegBxY,225473
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
+sourcecode/readiness_timeline.py,sha256=T5NKLuRHS83lPslE2kMs_RSVENd8jZJ11N1c9gpkpH8,7244
 sourcecode/reconciliation.py,sha256=GU-1PTcVr8zcbtC7BASfpHcZndP9AdboXPNQiBc0fzo,34251
 sourcecode/redactor.py,sha256=SB4hwIvg8h-hvcqKcDWaZvA-aSyn-at-BIRwa0tUv5E,3227
 sourcecode/relevance_scorer.py,sha256=0AgEt4KrV73nioMqBgjhGjtY7L2C7L7cSyKtj3IKcrw,9408
@@ -85,6 +86,7 @@ sourcecode/spring_security_audit.py,sha256=Rk-aSohezdc7YDYbSoJquVnwpkDB8ty1BCD-4
 sourcecode/spring_semantic.py,sha256=jteQ1PkY9ArFJv0embg_jBIdbOxqrk9mQ2Xz8OF_FKA,14214
 sourcecode/spring_tx_analyzer.py,sha256=lp0h5Pzzd3fPxHAAagMmG8PqR1-v2uVpFIG1o7tCWQs,41148
 sourcecode/summarizer.py,sha256=sr0-tfecFKCr-fSkPPWbl-t9HC7SY2ZxkjnnXX8DB2A,26621
+sourcecode/token_estimate.py,sha256=ZP3C54aQLExuf32Yvrjok2TAS2oSSyNVRA_HjhsD6Eg,7165
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/type_usage_surface.py,sha256=51IrKRQoIoRnlsiDjHnqpJBn2rc6E59aRhgS0HTzAF0,4428
 sourcecode/validation_inference.py,sha256=KN3tEBQzxNinwlo7buer6lx5Kqdn71JAs_wuu44McfU,17475
@@ -118,12 +120,12 @@ sourcecode/mcp/__init__.py,sha256=XU4HfRGbdid8wdUA0x_4f7uKZD1z3mv_XUY_WU_T9Mw,17
 sourcecode/mcp/orchestrator.py,sha256=diVoQgn24QmgPL3Ev8Sp6hsvh02OqY3MktHXOzrlodo,36525
 sourcecode/mcp/registry.py,sha256=OCUCRLPRM176FCw850rF7dNh74f5Zj0h3a9lpxrf8mI,68171
 sourcecode/mcp/runner.py,sha256=RGimCwhLyHxjCvH7q72y12HWEnATXZLC-NBWhkzlu0I,2852
-sourcecode/mcp/server.py,sha256=yCp1YmmZ4hQE7KIHC8XcdxnToYCwSe9vxp4E-YMzVg0,63713
+sourcecode/mcp/server.py,sha256=P6JqQrlat2jP8OK0ysxSWNwqfUYF-bTc3X05FszR1_4,65180
 sourcecode/mcp/onboarding/__init__.py,sha256=sj2PWqEBmMc4zBNkomg89WtL0M6S7A9yb7_wAuSWNP4,66
-sourcecode/mcp/onboarding/applier.py,sha256=Z2ZqzPh7dTTzT7tfxDbfjDJKiBNQ18CPQCaReRTM3AY,2630
+sourcecode/mcp/onboarding/applier.py,sha256=Sx9vHTaXr_M1Bs4uMjO7qa_a2_p4J9oz93oJsKQ7ds4,3298
 sourcecode/mcp/onboarding/backup.py,sha256=ihqGOR8QTX8HASRSEDyfFyXr5bkXrygPHamv4p9KTmk,1452
-sourcecode/mcp/onboarding/detector.py,sha256=kDc0U6kXMuq_GivqwKrgJzIVLVeoLr3RQl63ksW10I8,3327
-sourcecode/mcp/onboarding/planner.py,sha256=Fopg5f72FDiPfldF7NOxYjcBA_w8hi_jBJpSz39lPb8,1332
+sourcecode/mcp/onboarding/detector.py,sha256=_WMlVecYE8jvNof3yQliICTldNg_rygnYZRHC2FAAd8,4875
+sourcecode/mcp/onboarding/planner.py,sha256=GEKLxVP244hLT1hHEoxMUAz3QIOg8vZOEst9Bh3VqTs,1372
 sourcecode/retrieval/__init__.py,sha256=h5pKDzXOlu_NQy-YxOaqMSD6UDNoYsmsYSoNLRRZ5uM,5478
 sourcecode/retrieval/context.py,sha256=hjm_RxReZar6GZvVVg4XNR9sVMOUuilbi1Jt7iUoerU,11116
 sourcecode/retrieval/errors.py,sha256=U-zqxzlzCWe3NYCNOBASTSPn1xS8j9D7LfwpGBiznL4,1452
@@ -142,14 +144,14 @@ sourcecode/retrieval/steps_impact.py,sha256=M0AwU5Ue7nkj-A7DYgQI2BP0BV1b0TFZRrYI
 sourcecode/retrieval/steps_intf.py,sha256=Jx5Gnm7UT1jOE7YloD0ee3d8PuliX5FgpdvlHh36OBs,9341
 sourcecode/retrieval/steps_struct.py,sha256=jO9L49hziTlS_xhuhCGUavgyAL3ZAnJSOZB-UA4GaRM,13893
 sourcecode/retrieval/steps_txsec.py,sha256=ltyxFAFLHfUglGLGz7i3tY_bovBoKo1d6R2t1xZTcnk,13608
-sourcecode/telemetry/__init__.py,sha256=6wsJnXsgsL_BtMK4hr5Ae1GToHeWej53F4o_-Tc23MQ,3406
+sourcecode/telemetry/__init__.py,sha256=a-cy2Gypx9fzJfBHK-e3hstYi6FLNlUj-k62yWyugMY,3461
 sourcecode/telemetry/config.py,sha256=u_zctgmA1pVT3Ai5jm-pdLY_5kJTRg4Xq2bvIbGBQE4,3727
-sourcecode/telemetry/consent.py,sha256=LIAO9ohJZF8OuZwM4u1VWtALlYfTCCKq4wV3Vwc7i5Q,2194
-sourcecode/telemetry/events.py,sha256=LtzYfaX9Ilckj5PTvAcTpDa9mLqDsYPDUiDkRa58piY,2580
-sourcecode/telemetry/filters.py,sha256=NHa5T-6DaZduQPFuC34jOqHWQgSizM-Ygq8aZ4j19ng,5834
+sourcecode/telemetry/consent.py,sha256=GuhCiA_x2n3LwGBkZnvyIwtFcf5Zwa8O0DdLqkATIr0,2220
+sourcecode/telemetry/events.py,sha256=4_yeO58U-Cwc1Qb27VB0_EjhmroY0k91n3_VGxeALB8,2776
+sourcecode/telemetry/filters.py,sha256=RzxauTz8HliO4BllQnXEXc7zTeqdCZi5MgqGEDuW7OQ,6570
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-2.6.5.dist-info/METADATA,sha256=Sxx6ytWQ8YgF4odFcMnh42AC-_r5zj1mqkoSFb9Cmyo,10851
-sourcecode-2.6.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-2.6.5.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-2.6.5.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-2.6.5.dist-info/RECORD,,
+sourcecode-2.6.10.dist-info/METADATA,sha256=RQ1LFmY3uZZd9zTw3iA3rkChqyLlb5DjgH7VvpRTFXg,10852
+sourcecode-2.6.10.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-2.6.10.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-2.6.10.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-2.6.10.dist-info/RECORD,,