synap-git 2.1.4__tar.gz → 2.1.6__tar.gz

{synap_git-2.1.4 → synap_git-2.1.6}/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.5] - 2026-06-11
+
+## [2.1.6] - 2026-06-29
+
+### Added
+- **Universal Language Expansion**: Expanded tree-sitter AST parsing support from 4 hardcoded languages to dynamically supporting over ~50 languages using `tree-sitter-languages`. Also added dynamic shebang detection (`#!`) to parse extensionless scripts as python, ruby, node, and bash scripts.
+- **API Rate Limiting**: Implemented a global `RateLimitedProvider` to throttle LLM and embedding calls to 3 requests per second to mitigate resource exhaustion on the diagnostic API.
+
+### Fixed
+- **Broad Exception Handling**: Eradicated remaining `except Exception:` blocks across diagnostics, daemon execution, indexer scanning, and module resolution, and replaced them with `OSError`, `sqlite3.Error`, and specific errors to prevent silent data corruption.
+- **Async Sleep Compatibility**: Fixed thread-blocking `time.sleep()` in LLM retries by delegating to `anyio.from_thread.run(anyio.sleep)` if invoked inside FastMCP worker threads.
+- **Edge Resolution & Source Paths**: Added support for resolving Javascript, Java, C++, Ruby, and more during import/edge resolution.
+- **Module Path Trimming**: Improved module path mapping by trimming `internal/`, `source/`, `packages/`, `main/`, `java/`, `kotlin/`, `scala/` from module keys.
+- **Wipe Confirmation**: Added a `--yes` confirmation bypass flag for `synap wipe` and enforced safety confirmation in non-interactive terminals.
+- **Metadata Fixes**: Corrected repository URLs in `pyproject.toml` to correctly point to `synapse` instead of `synap-git`.
+
+### Refactored
+- **Daemon Teardown**: Refactored the forceful SIGTERM daemon teardown logic to safely toggle via `force_exit=True` rather than a blanket catch-all. Makes programmatic `daemon.stop()` safer without blocking terminal UI interactions.
+
 ## [2.1.4] - 2026-06-11
 
 ### Fixed

{synap_git-2.1.4 → synap_git-2.1.6}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: synap-git
-Version: 2.1.4
+Version: 2.1.6
 Summary: Persistent structural context infrastructure for AI coding agents.
-Project-URL: Homepage, https://github.com/saahilpal/synap-git
-Project-URL: Repository, https://github.com/saahilpal/synap-git
-Project-URL: Issues, https://github.com/saahilpal/synap-git/issues
-Project-URL: Changelog, https://github.com/saahilpal/synap-git/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/saahilpal/synapse
+Project-URL: Repository, https://github.com/saahilpal/synapse
+Project-URL: Issues, https://github.com/saahilpal/synapse/issues
+Project-URL: Changelog, https://github.com/saahilpal/synapse/blob/main/CHANGELOG.md
 Author: Synap contributors
 License: Apache-2.0
 License-File: LICENSE.md
@@ -443,15 +443,19 @@ synap mcp config .
 
 ## Supported Languages
 
-Synap processes syntax for the following formats:
+Synap now processes syntax dynamically for **over 50 programming languages** via `tree-sitter-languages`, including:
+
 * **Python** (`.py`)
-* **JavaScript / JSX** (`.js`, `.jsx`)
-* **TypeScript / TSX** (`.ts`, `.tsx`)
-* **Go** (`.go`)
-* **Rust** (`.rs`)
-* **Java** (`.java`)
-* **C / C++** (`.cpp`, `.cc`, `.cxx`, `.hpp`, `.h`)
-* **Ruby** (`.rb`)
+* **JavaScript / TypeScript** (`.js`, `.jsx`, `.ts`, `.tsx`)
+* **C / C++ / C#** (`.c`, `.cpp`, `.h`, `.hpp`, `.cs`)
+* **Java / Kotlin / Scala** (`.java`, `.kt`, `.kts`, `.scala`)
+* **Go / Rust / Swift** (`.go`, `.rs`, `.swift`)
+* **Ruby / PHP / Perl** (`.rb`, `.php`, `.pl`)
+* **Shell Scripts** (`.sh`, `.bash`, or via `#!` shebang detection)
+* **Data / Config** (`.sql`, `.json`, `.yaml`, `.toml`, `.xml`)
+* **Web** (`.html`, `.css`, `.scss`)
+
+Even extensionless scripts are gracefully detected via shebang parsing. Missing grammars automatically degrade gracefully to plaintext indexing.
 
 ---
 

{synap_git-2.1.4 → synap_git-2.1.6}/README.md

@@ -393,15 +393,19 @@ synap mcp config .
 
 ## Supported Languages
 
-Synap processes syntax for the following formats:
+Synap now processes syntax dynamically for **over 50 programming languages** via `tree-sitter-languages`, including:
+
 * **Python** (`.py`)
-* **JavaScript / JSX** (`.js`, `.jsx`)
-* **TypeScript / TSX** (`.ts`, `.tsx`)
-* **Go** (`.go`)
-* **Rust** (`.rs`)
-* **Java** (`.java`)
-* **C / C++** (`.cpp`, `.cc`, `.cxx`, `.hpp`, `.h`)
-* **Ruby** (`.rb`)
+* **JavaScript / TypeScript** (`.js`, `.jsx`, `.ts`, `.tsx`)
+* **C / C++ / C#** (`.c`, `.cpp`, `.h`, `.hpp`, `.cs`)
+* **Java / Kotlin / Scala** (`.java`, `.kt`, `.kts`, `.scala`)
+* **Go / Rust / Swift** (`.go`, `.rs`, `.swift`)
+* **Ruby / PHP / Perl** (`.rb`, `.php`, `.pl`)
+* **Shell Scripts** (`.sh`, `.bash`, or via `#!` shebang detection)
+* **Data / Config** (`.sql`, `.json`, `.yaml`, `.toml`, `.xml`)
+* **Web** (`.html`, `.css`, `.scss`)
+
+Even extensionless scripts are gracefully detected via shebang parsing. Missing grammars automatically degrade gracefully to plaintext indexing.
 
 ---
 

{synap_git-2.1.4 → synap_git-2.1.6}/pyproject.toml

@@ -40,10 +40,10 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/saahilpal/synap-git"
-Repository = "https://github.com/saahilpal/synap-git"
-Issues = "https://github.com/saahilpal/synap-git/issues"
-Changelog = "https://github.com/saahilpal/synap-git/blob/main/CHANGELOG.md"
+Homepage = "https://github.com/saahilpal/synapse"
+Repository = "https://github.com/saahilpal/synapse"
+Issues = "https://github.com/saahilpal/synapse/issues"
+Changelog = "https://github.com/saahilpal/synapse/blob/main/CHANGELOG.md"
 
 
 [project.optional-dependencies]

{synap_git-2.1.4 → synap_git-2.1.6}/src/synap_git/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "2.1.4"
+__version__ = "2.1.6"

{synap_git-2.1.4 → synap_git-2.1.6}/src/synap_git/api/app.py

@@ -104,7 +104,7 @@ def create_app(runtime: SynapRuntime) -> FastAPI:
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
 
         wiki_path = runtime.wiki.wiki_dir / f"{target}.md"
         exists = await asyncio.to_thread(wiki_path.exists)

synap_git-2.1.6/src/synap_git/cli/checkpoint.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from synap_git.cli.main import (
+    _settings,
+    console,
+)
+from synap_git.indexer.engine import SynapRuntime
+
+app = typer.Typer(help="Checkpoint commands.", no_args_is_help=True)
+
+
+@app.command("create")
+def checkpoint_create(
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+    doing: Annotated[
+        str, typer.Option(help="What the agent is currently doing.")
+    ] = "Manual snapshot",
+    files: Annotated[str, typer.Option(help="Comma-separated list of changed files.")] = "",
+    next_step: Annotated[str, typer.Option(help="The next step to be taken.")] = "",
+    blockers: Annotated[str, typer.Option(help="Current blockers or obstacles.")] = "",
+) -> None:
+    """Create a new context checkpoint."""
+    runtime = SynapRuntime(_settings(path))
+
+    checkpoint_id = str(uuid.uuid4())
+    status = runtime.status()
+    branch = status.branch
+    commit = status.git_commit or "unknown"
+
+    file_list = [f.strip() for f in files.split(",") if f.strip()]
+
+    runtime.store.put_checkpoint(
+        checkpoint_id=checkpoint_id,
+        branch=branch,
+        commit_hash=commit,
+        doing=doing,
+        changed_files=json.dumps(file_list),
+        next_step=next_step,
+        blockers=blockers,
+    )
+    console.print(f"[green]✓ Checkpoint {checkpoint_id} created for branch '{branch}'.[/green]")
+
+
+@app.command("list")
+def checkpoint_list(
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """List checkpoints for the active branch."""
+    runtime = SynapRuntime(_settings(path))
+    status = runtime.status()
+    branch = status.branch
+    cps = runtime.store.get_checkpoints(branch)
+
+    if not cps:
+        console.print(f"[yellow]No checkpoints found for branch '{branch}'.[/yellow]")
+        return
+
+    table = Table(
+        title=f"Checkpoints for branch '{branch}'", show_header=True, header_style="bold cyan"
+    )
+    table.add_column("Checkpoint ID")
+    table.add_column("Commit Hash")
+    table.add_column("Doing")
+    table.add_column("Changed Files")
+    table.add_column("Created At")
+
+    for cp in cps:
+        created = datetime.fromtimestamp(cp["created_at"]).isoformat()
+        try:
+            ch_files = ", ".join(json.loads(cp["changed_files"]))
+        except Exception:
+            ch_files = cp["changed_files"]
+        table.add_row(
+            cp["checkpoint_id"][:16] + "…",
+            cp["commit_hash"][:7],
+            cp["doing"],
+            ch_files if ch_files else "None",
+            created,
+        )
+    console.print(table)
+
+
+@app.command("restore")
+def checkpoint_restore(
+    checkpoint_id: Annotated[
+        str, typer.Argument(help="The ID of the checkpoint to restore (defaults to latest).")
+    ] = "latest",
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """Restore and show details of a checkpoint."""
+    runtime = SynapRuntime(_settings(path))
+    status = runtime.status()
+    branch = status.branch
+
+    if checkpoint_id == "latest":
+        cp = runtime.store.get_latest_checkpoint(branch)
+    else:
+        cp = runtime.store.get_checkpoint(checkpoint_id)
+
+    if not cp:
+        console.print(f"[red]✗ Checkpoint '{checkpoint_id}' not found.[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[bold green]✓ Checkpoint '{cp['checkpoint_id']}' details:[/bold green]")
+    console.print(f"  [bold]Branch:[/bold] {cp['branch']}")
+    console.print(f"  [bold]Commit:[/bold] {cp['commit_hash']}")
+    console.print(f"  [bold]Doing:[/bold] {cp['doing']}")
+    try:
+        ch_files = ", ".join(json.loads(cp["changed_files"]))
+    except Exception:
+        ch_files = cp["changed_files"]
+    console.print(f"  [bold]Changed Files:[/bold] {ch_files if ch_files else 'None'}")
+    console.print(f"  [bold]Next Step:[/bold] {cp['next_step'] or 'None'}")
+    console.print(f"  [bold]Blockers:[/bold] {cp['blockers'] or 'None'}")
+    console.print(
+        f"  [bold]Created At:[/bold] {datetime.fromtimestamp(cp['created_at']).isoformat()}"
+    )

synap_git-2.1.6/src/synap_git/cli/lessons.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import questionary
+import typer
+from rich.panel import Panel
+
+from synap_git.cli.main import (
+    _settings,
+    console,
+)
+from synap_git.indexer.engine import SynapRuntime
+
+app = typer.Typer(help="Lessons commands.", no_args_is_help=True)
+
+
+@app.command("approve")
+def lessons_approve(
+    lesson_id: Annotated[str, typer.Argument(help="The ID of the lesson to approve.")],
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """Approve a pending lesson."""
+    runtime = SynapRuntime(_settings(path))
+    # Fetch to ensure it exists and is pending
+    pending = runtime.store.get_lessons("pending")
+    target = next((lesson for lesson in pending if lesson["lesson_id"] == lesson_id), None)
+
+    if not target:
+        console.print(f"[red]✗ Pending lesson {lesson_id} not found.[/red]")
+        raise typer.Exit(1)
+
+    runtime.store.update_lesson(lesson_id, target["why_failed"], "approved", actor="cli_user")
+    console.print(f"[green]✓ Lesson {lesson_id} approved. Memory updated.[/green]")
+
+
+@app.command("review")
+def lessons_review(
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """Interactively review and manage pending lessons."""
+
+    runtime = SynapRuntime(_settings(path))
+    pending = runtime.store.get_lessons("pending")
+
+    if not pending:
+        console.print("[yellow]No pending lessons to review.[/yellow]")
+        return
+
+    console.print(f"[bold cyan]Reviewing {len(pending)} pending lessons...[/bold cyan]\n")
+
+    approved_count = 0
+    rejected_count = 0
+    skipped_count = 0
+
+    for lesson in pending:
+        lesson_id = lesson["lesson_id"]
+
+        # Build detail view
+        details = (
+            f"[bold]Revert Commit:[/bold] {lesson['revert_commit'][:8]}\n"
+            f"[bold]Reverted From:[/bold] {lesson['reverted_from'][:8]}\n"
+            f"[bold]Files Affected:[/bold] {lesson['files_affected']}\n"
+            f"[bold]What Failed:[/bold] {lesson['what_failed']}\n"
+            f"[bold]Proposed Lesson:[/bold] {lesson['why_failed']}"
+        )
+
+        console.print(Panel(details, title=f"Lesson {lesson_id[:8]}", expand=False))
+
+        choice = questionary.select(
+            "Action:",
+            choices=[
+                questionary.Choice("Approve", value="approve"),
+                questionary.Choice("Edit & Approve", value="edit"),
+                questionary.Choice("Reject", value="reject"),
+                questionary.Choice("Skip", value="skip"),
+            ],
+        ).ask()
+
+        if choice == "approve":
+            runtime.store.update_lesson(
+                lesson_id, lesson["why_failed"], "approved", actor="cli_user"
+            )
+            console.print("[green]✓ Approved.[/green]\n")
+            approved_count += 1
+        elif choice == "edit":
+            edited = questionary.text("Edit lesson text:", default=lesson["why_failed"]).ask()
+            if edited:
+                runtime.store.update_lesson(lesson_id, edited, "approved", actor="cli_user")
+                console.print("[green]✓ Edited and Approved.[/green]\n")
+                approved_count += 1
+            else:
+                console.print("[yellow]Skipping edit.[/yellow]\n")
+                skipped_count += 1
+        elif choice == "reject":
+            runtime.store.update_lesson(
+                lesson_id, lesson["why_failed"], "rejected", actor="cli_user"
+            )
+            console.print("[red]✗ Rejected.[/red]\n")
+            rejected_count += 1
+        elif choice == "skip":
+            console.print("[yellow]Skipped.[/yellow]\n")
+            skipped_count += 1
+        else:
+            console.print("[yellow]Aborting review.[/yellow]")
+            break
+
+    console.print("[bold cyan]Review Summary:[/bold cyan]")
+    console.print(f"  [green]Approved:[/green] {approved_count}")
+    console.print(f"  [red]Rejected:[/red] {rejected_count}")
+    console.print(f"  [yellow]Skipped:[/yellow]  {skipped_count}")
+
+
+@app.command("reject")
+def lessons_reject(
+    lesson_id: Annotated[str, typer.Argument(help="The ID of the lesson to reject.")],
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """Reject a pending or approved lesson."""
+    runtime = SynapRuntime(_settings(path))
+    pending = runtime.store.get_lessons("pending")
+    approved = runtime.store.get_lessons("approved")
+    target = next(
+        (lesson for lesson in pending + approved if lesson["lesson_id"] == lesson_id), None
+    )
+
+    if not target:
+        console.print(f"[red]✗ Lesson {lesson_id} not found in pending or approved queues.[/red]")
+        raise typer.Exit(1)
+
+    runtime.store.update_lesson(lesson_id, target["why_failed"], "rejected", actor="cli_user")
+    console.print(f"[yellow]✓ Lesson {lesson_id} rejected. Memory updated.[/yellow]")

{synap_git-2.1.4 → synap_git-2.1.6}/src/synap_git/cli/main.py

@@ -143,7 +143,13 @@ app.add_typer(usage_app, name="usage")
 def setup(
     path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
 ) -> None:
-    """Interactive first-run setup and onboarding."""
+    """
+    Interactive first-run setup and onboarding.
+
+    Examples:
+        synap setup
+        synap setup /path/to/repo
+    """
     import sys
 
     import httpx
@@ -516,7 +522,13 @@ def init(
     quiet: Annotated[bool, typer.Option("--quiet", help="Suppress output.")] = False,
     json_output: Annotated[bool, JSON_OPTION] = False,
 ) -> None:
-    """Initialize local Synap state and perform first scan."""
+    """
+    Initialize local Synap state and perform first scan.
+
+    Examples:
+        synap init
+        synap init --force --skip-llm
+    """
     settings = _settings(path, json_output=json_output)
     if skip_llm:
         settings.llm_provider = None
@@ -547,9 +559,14 @@ def init(
 @app.command()
 def wipe(
     path: Annotated[str, typer.Argument(help="Repository path to wipe.")] = ".",
+    yes: Annotated[
+        bool, typer.Option("--yes", "-y", help="Skip confirmation prompt and force wipe")
+    ] = False,
 ) -> None:
     """Completely purge the local index for a fresh rebuild."""
-    if not typer.confirm("This will delete all indexed symbols and embeddings. Continue?"):
+    if not yes and not typer.confirm(
+        "This will delete all indexed symbols and embeddings. Continue?"
+    ):
         raise typer.Abort()
     runtime = SynapRuntime(_settings(path))
     runtime.wipe_index()
@@ -651,7 +668,7 @@ def start(
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
 
     # 2. Spawn detached daemon process
     cmd = [sys.executable, "-m", "synap_git.cli", "daemon-run", abs_path.as_posix()]
@@ -718,8 +735,9 @@ def daemon_run(
     daemon = RuntimeDaemon(settings)
     asyncio.run(daemon.start())
 
-    # Forceful process exit to prevent atexit thread-join blocking
-    os._exit(0)
+    import sys
+
+    sys.exit(0)
 
 
 @app.command()
@@ -802,7 +820,7 @@ def stop(
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
         success = not _is_process_running(pid)
 
     # Clean up lockfiles
@@ -968,7 +986,13 @@ def search(
         int, typer.Option("--max-tokens", help="Maximum context window tokens.")
     ] = 4000,
 ) -> None:
-    """Execute a hybrid structural search across the repository."""
+    """
+    Execute a hybrid structural search across the repository.
+
+    Examples:
+        synap search "database connection logic"
+        synap search "authentication middleware" --path /path/to/repo --max-tokens 8000
+    """
     settings = _settings(path)
     runtime = SynapRuntime(settings)
 
@@ -1247,7 +1271,7 @@ def rollback(
     except Exception as e:
         import structlog
 
-        structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
+        structlog.get_logger().error("suppressed_error_caught", exc_info=True)
 
     with console.status(
         f"[yellow]Reindexing repository to match {selected_commit}...[/yellow]", spinner="dots"
@@ -1322,7 +1346,7 @@ def repair(
         except Exception as e:
             import structlog
 
-            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
+            structlog.get_logger().error("suppressed_error_caught", exc_info=True)
 
     status_info = runtime.status()
     console.print(f"\n[green]✓ Recovery complete. {status_info.files} files restored.[/green]")

synap_git-2.1.6/src/synap_git/cli/mcp.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+import time
+import uuid
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from rich.table import Table
+
+from synap_git.cli.main import (
+    _settings,
+    console,
+)
+from synap_git.indexer.engine import SynapRuntime
+from synap_git.mcp.server import SynapMCPFacade, SynapMCPServer
+
+app = typer.Typer(help="Mcp commands.", no_args_is_help=True)
+
+
+@app.command("start")
+def mcp_start(
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """Start the MCP server."""
+    settings = _settings(path, json_output=True)
+    runtime = SynapRuntime(settings)
+    runtime.bootstrap()
+
+    server = SynapMCPServer(runtime)
+    asyncio.run(server.run())
+
+
+@app.command("config")
+def mcp_config(
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """Output the MCP server configuration for manual IDE setup."""
+    abs_path = Path(path).resolve().as_posix()
+
+    config = {
+        "mcpServers": {
+            "synap": {
+                "command": sys.executable,
+                "args": ["-m", "synap_git.cli", "mcp", "start", abs_path],
+                "autoConnect": True,
+            }
+        }
+    }
+    typer.echo(json.dumps(config, indent=2))
+
+
+@app.command("verify")
+def mcp_verify(
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
+) -> None:
+    """Verify MCP tools, schemas, and transport stability."""
+
+    console.print("[bold cyan]Synap MCP Verification[/bold cyan]\n")
+
+    settings = _settings(path)
+    runtime = SynapRuntime(settings)
+    runtime.bootstrap()
+
+    facade = SynapMCPFacade(runtime)
+
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Stage")
+    table.add_column("Status")
+    table.add_column("Latency (ms)")
+    table.add_column("Details")
+
+    with console.status(
+        "[bold yellow]Verifying MCP transport and tools...[/bold yellow]"
+    ) as status:
+
+        def _simulate_mcp_call(tool_name: str, *args: Any, **kwargs: Any) -> bool:
+            status.update(
+                f"[bold yellow]Verifying stage: [white]{tool_name}[/white]...[/bold yellow]"
+            )
+            start = time.monotonic()
+            try:
+                status_info = facade.runtime.status()
+                dirty = status_info.is_dirty
+                warnings = ["Working tree is dirty. Index may be stale."] if dirty else []
+
+                method = getattr(facade, tool_name)
+                data = method(*args, **kwargs)
+
+                response = {
+                    "ok": True,
+                    "data": data,
+                    "warnings": warnings,
+                    "trace_id": str(uuid.uuid4()),
+                    "dirty_tree": dirty,
+                }
+
+                # Verify strict schema
+                assert "ok" in response
+                assert "data" in response
+                assert "warnings" in response
+                assert "trace_id" in response
+                assert "dirty_tree" in response
+
+                latency = (time.monotonic() - start) * 1000
+
+                if tool_name == "search":
+                    # Check trace payload exists
+                    assert "trace" in data, "Trace payload missing in search data"
+
+                details = f"keys: {list(data.keys())}"
+                table.add_row(tool_name, "[green]PASS[/green]", f"{latency:.1f}", details)
+                time.sleep(0.1)  # Visual breathing room
+                return True
+            except Exception as e:
+                latency = (time.monotonic() - start) * 1000
+                table.add_row(tool_name, "[red]FAIL[/red]", f"{latency:.1f}", str(e))
+                return False
+
+        results = [
+            _simulate_mcp_call("get_status"),
+            _simulate_mcp_call("verify_system"),
+            _simulate_mcp_call("search", "User"),
+            _simulate_mcp_call("create_checkpoint", "Testing MCP", ["test.py"], "Next", "None"),
+            _simulate_mcp_call("restore_checkpoint", "latest"),
+        ]
+
+    console.print(table)
+
+    if all(results):
+        console.print("\n[bold green]✓ MCP Protocol Verified. All contracts passed.[/bold green]")
+    else:
+        console.print("\n[bold red]✗ MCP Protocol Verification Failed.[/bold red]")
+        raise typer.Exit(1)