sql-code-graph 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.2.2
+Version: 1.3.0
 Summary: SQL code graph analyzer and lineage tracer
 Project-URL: Homepage, https://github.com/Warhorze/sql-code-graph
 Project-URL: Repository, https://github.com/Warhorze/sql-code-graph

{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.3.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-sqlcg/__init__.py,sha256=6jzbRxs0WG3Yq2KYIDG9bagxRZvhbhp6agviO4_nXwM,115
+sqlcg/__init__.py,sha256=Zwww9eU1OV0KsLzksvKQE65bNgEFPPwTUb0XCSW4JIE,115
 sqlcg/__main__.py,sha256=1YoFLcqEgTwYq1J3TbUwpkdG0zeeLIf2fJvwWI-CLFU,109
 sqlcg/cli/__init__.py,sha256=W8fD0LpMq2xm_5WKGNMvJh2WBL1ho5E8hUeAqXQYT1g,28
 sqlcg/cli/main.py,sha256=WmdTjsOlz1ozi2Y3Aq4ezR_FCRl-Lc1YOKw3_d48dlY,1650
 sqlcg/cli/commands/__init__.py,sha256=oSHtr6VD-jNubOjuCQyZj2tBppjMEpQDh-IGQ8of9eA,30
 sqlcg/cli/commands/analyze.py,sha256=xr3RHmO4eFTP4VKZn4DAx3BJzSi60_DIZmdE-QLfsHI,13601
-sqlcg/cli/commands/db.py,sha256=iUPnSxkSjt2EZzj_zmXiIyM39NTTCpazD4Y8Q9iPZEc,7725
+sqlcg/cli/commands/db.py,sha256=paW096LE8fMpxPNvoW9zHmZ9xjb-dEbwVmfHR1bcg7U,8676
 sqlcg/cli/commands/find.py,sha256=zTYN9goILalYq4R9x6lIR6MmNcydDbR17UXkx1gPRsI,2913
 sqlcg/cli/commands/gain.py,sha256=Kws76u1na2XxmbWN_YWrPaYHYmYBLC6DDDf7xqnltqc,9126
-sqlcg/cli/commands/git.py,sha256=yMgWOuoTCTBr2P1QgmghRi5ikmUYHuxDUVyBDYerErw,5728
-sqlcg/cli/commands/index.py,sha256=xMnxKDiUt5LH_3lKAotoRctL4VSOvcw7Gq--idLPtm0,11091
+sqlcg/cli/commands/git.py,sha256=9a8T2FVxcAHq1H6Cslaq34t10w9fBGf4T2reiLk33t8,6135
+sqlcg/cli/commands/index.py,sha256=1ElHRPkn-CPprIz869A__98aSyf-P5E56PVA0lq7xBw,17462
 sqlcg/cli/commands/install.py,sha256=KNABvrLbamPyYnmnVdCaM_MNezbDc-pr6IkignCWI8k,9186
-sqlcg/cli/commands/mcp.py,sha256=2gDsNvtj1Ql7PkjX9dHWAzOK0uCPRR5DGdBAzJa8PIU,6005
-sqlcg/cli/commands/reindex.py,sha256=n1mQTYAZshtCKPgpR12S6ZMCqO3cSUtpCXjzb1PuZxU,11857
+sqlcg/cli/commands/mcp.py,sha256=QYaupf69lLpYzIoqsPJoCPiAggLVkYBzwpuOLRzxJDU,9140
+sqlcg/cli/commands/reindex.py,sha256=Ki5BHbI_nuM6ML0-w7qnVZqSAhELSpsFaUo6BVqzhRo,13812
 sqlcg/cli/commands/report.py,sha256=JU0qjyMxwOukE7bN3XvvIzOI7zMg_Gsnvk_8F6pKNpA,4915
 sqlcg/cli/commands/uninstall.py,sha256=IYwQaqnMmmzW0Nlls40wD-L3tVkMgKIMRXUkcXPMUc4,9398
 sqlcg/cli/commands/watch.py,sha256=7N6c-QuvxAEGHzDZ0C3CU2BkHSraZW9YtgoFnz7SaQo,2373
@@ -20,7 +20,7 @@ sqlcg/core/config.py,sha256=qNR-yXkfYfS8Y8WX4Qo6Zkq8PPP_ZiTrvX0DLmEZkGY,14821
 sqlcg/core/freshness.py,sha256=gRb8pRPw5SdIUxAYkMXIJ00DTdQ6CegRZPAvWnv0rU0,4575
 sqlcg/core/graph_db.py,sha256=Aa85wPFg26H-Ud9SrZyxCHH-99iitAI5S3X9T_62Yyw,7957
 sqlcg/core/jobs.py,sha256=Je-fCdSKRgiSsv1W8SgNAlp36a7t7-pJZ-qKPbka9OE,3298
-sqlcg/core/kuzu_backend.py,sha256=3kL8bGEQm70fuxYUdt1p7fsY12lCLQ07x01NYg6FOGA,16821
+sqlcg/core/kuzu_backend.py,sha256=PHW7VqI7oCLKsHnm4OoBoNnE2XT19ohxUpQMMIJnjlY,17038
 sqlcg/core/neo4j_backend.py,sha256=AM1TncP9GBGph-rSHwalZPmGUV2kFILzaJP-PSB0UYw,8437
 sqlcg/core/queries.cypher,sha256=cvPOVe5GUOzJN4bxUvDxNI--xIIP8gm42TR-gUnea4U,4685
 sqlcg/core/queries.py,sha256=gkl4bhkZM8FsvbSA-IaK17sRFcO3hB5YlVCemkCXgWM,2064
@@ -38,7 +38,7 @@ sqlcg/lineage/__init__.py,sha256=Da1DlYwtK13WHv_RnHjAtNkHTOuFbhxqCjT1Le7DsWM,46
 sqlcg/lineage/aggregator.py,sha256=LVyNcmvLBHWbh8SrDsJJBKd7sLg3-2NhEWwEndG7Jbc,4144
 sqlcg/lineage/schema_resolver.py,sha256=iXt6LYF6UVWsGUpcfbmjmGn9wCgXl721lTGf_8AaWcc,7320
 sqlcg/metrics/__init__.py,sha256=hLJ6wm4St8qqYwKh3o9QG7lcEt1BEYM31ccqO9tGpIg,133
-sqlcg/metrics/store.py,sha256=BaMf7QYTmYMlX_Jzi1GNU8R2sMVkWdn07f-ZSndtcNk,8879
+sqlcg/metrics/store.py,sha256=O1UoBu4dIZYIgNBqLWIyL3vLAnSgWrJinOgSLhQigHM,10596
 sqlcg/parsers/__init__.py,sha256=AamA8wBbDZV9_zEtZCI4Hyen5UAVKHmBwjTghTt2PZE,785
 sqlcg/parsers/ansi_parser.py,sha256=mGZvijMOMQ4i1BybpwU29a8jnIGViefhy9fxzkSpsRM,17193
 sqlcg/parsers/base.py,sha256=IiOkVsm6jz9-48RqDCXiW-UXAraNxQ4pKXvSA7aolnA,49907
@@ -53,14 +53,15 @@ sqlcg/server/exceptions.py,sha256=EONw34icOByCTpppSQrvQBW6asc4hfqaGDCAFjv96II,46
 sqlcg/server/models.py,sha256=l7ORy6sbtzBW1y3qVaeLwEukbyAgBkz9S5VIm2q4b24,19378
 sqlcg/server/noise_filter.py,sha256=idSBGgdKWWccJdpOo9qgbM2350Oew-2l5W6Yc9GYQqY,6337
 sqlcg/server/read_client.py,sha256=ncoJK7UckGhWtN9bv1CgViNMNtac96zBUE7RPYQ8_WI,7783
-sqlcg/server/server.py,sha256=QBb7N4lc5o7KBh1Ik6MAiOvBV8SW81ahtkM1ZOVuyXE,18983
+sqlcg/server/server.py,sha256=9SilAu18cHTZUQvSo8S8e9CxSM6CUlG8rX2OnHBUh1Y,24178
 sqlcg/server/skill.py,sha256=GE8eeimk6yiGGJ74erGypqYAviur5peSR6_2a4QQWVM,12828
-sqlcg/server/tools.py,sha256=JvijDC0h5uHjZyZUIZq9sztNG3W5sr-Yy5rHwOVuJec,66642
+sqlcg/server/tools.py,sha256=DTaDwZQmL6jzNF8vgJeNhVMGRoIrrpcxNiXOMpWvx-A,72401
+sqlcg/server/writer.py,sha256=gagS6EVG8A4OKpf0GAb--MUielnaiIULwVVik58pT6k,24693
 sqlcg/utils/__init__.py,sha256=--iqt5ThTXmT8Wz7da8hs3n0zDfYPl8P-z5OgRJ_77E,154
 sqlcg/utils/hashing.py,sha256=H25-sYfxHKb3_IERFnHyAIYNiXN470Oqo5sJT_D3YOA,438
 sqlcg/utils/ignore.py,sha256=wJjwa0mjnQ_xJExOUxk25y00g065XmmzJapqV3ifD5o,1151
 sqlcg/utils/logging.py,sha256=u0fCmYsLj9o81vawm3xZTHaw68GQYVm7JxG-gP81u8A,840
-sql_code_graph-1.2.2.dist-info/METADATA,sha256=e4llIRyH4QYoHbIznQIpZ_wreqsuscvDzuLBVQBv33M,14148
-sql_code_graph-1.2.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sql_code_graph-1.2.2.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
-sql_code_graph-1.2.2.dist-info/RECORD,,
+sql_code_graph-1.3.0.dist-info/METADATA,sha256=2QJqn9Q606zlPKDgeYrNzq0d1QW35jIRCxmvDCvvNIE,14148
+sql_code_graph-1.3.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sql_code_graph-1.3.0.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.3.0.dist-info/RECORD,,

sqlcg/__init__.py

@@ -1,5 +1,5 @@
 """SQL Code Graph - SQL lineage and dependency analysis tool."""
 
-__version__ = "1.2.2"
+__version__ = "1.3.0"
 
 __all__ = ["__version__"]

sqlcg/cli/commands/db.py

@@ -45,6 +45,29 @@ def db_reset(  # noqa: B008
     repo: str | None = typer.Option(None, "--repo", help="Reset only this repo path"),  # noqa: B008
 ) -> None:
     """Wipe the database or a single repo's subgraph."""
+    import socket as _socket
+
+    from sqlcg.server.control import sock_path
+
+    # Step 3.4 (OD-3 / W2): refuse cleanly when a server is live — both the
+    # full reset and the --repo partial reset open the RW backend directly and
+    # would fight the server's lock.  Guard runs BEFORE either destructive branch.
+    sp = sock_path()
+    if sp.exists():
+        try:
+            with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
+                s.settimeout(1)
+                s.connect(str(sp))
+            # Connection succeeded — a server is live.
+            console.print(
+                "[red]A server is running on this database; stop it first "
+                "('sqlcg mcp stop') before resetting the database.[/red]"
+            )
+            raise typer.Exit(1)
+        except (FileNotFoundError, ConnectionRefusedError, OSError):
+            # No live server — fall through to destructive action.
+            pass
+
     if repo:
         # Delete all nodes for this repo (use run_write for mutation)
         with get_backend() as backend:

sqlcg/cli/commands/git.py

@@ -33,7 +33,7 @@ _HOOKS: list[_HookSpec] = [
             '[ "$3" = "1" ] || exit 0\n'
             '{sqlcg_bin} reindex --from "$1" --to "$2"'
             ' "$(git rev-parse --show-toplevel)" --dialect auto --quiet --notify'
-            ' || echo "sqlcg: graph not updated (server busy/locked)'
+            ' || echo "sqlcg: graph not updated (reindex failed)'
             " -- run 'sqlcg mcp status'\" >&2\n"
         ),
     ),
@@ -50,10 +50,10 @@ PREV=$(git rev-parse --verify --quiet ORIG_HEAD)
 TOP=$(git rev-parse --show-toplevel)
 if [ -n "$PREV" ]; then
   {sqlcg_bin} reindex --from "$PREV" --to HEAD "$TOP" --dialect auto --quiet --notify \\
-    || echo "sqlcg: graph not updated (server busy/locked) -- run 'sqlcg mcp status'" >&2
+    || echo "sqlcg: graph not updated (reindex failed) -- run 'sqlcg mcp status'" >&2
 else
   {sqlcg_bin} reindex "$TOP" --dialect auto --quiet --notify \\
-    || echo "sqlcg: graph not updated (server busy/locked) -- run 'sqlcg mcp status'" >&2
+    || echo "sqlcg: graph not updated (reindex failed) -- run 'sqlcg mcp status'" >&2
 fi
 """,
     ),
@@ -101,7 +101,14 @@ def _install_single_hook(hooks_dir: Path, spec: _HookSpec, sqlcg_bin: str) -> No
     if hook_path.exists():
         existing_content = hook_path.read_text()
         if spec.sentinel in existing_content:
-            # Already installed — idempotent, skip silently
+            if existing_content == script:
+                # Byte-identical current template — true idempotency, silent skip.
+                return
+            # Sentinel present but content differs: sqlcg-owned but stale hook.
+            # Overwrite with the current rendered template and report the upgrade.
+            hook_path.write_text(script)
+            hook_path.chmod(0o755)
+            console.print(f"[green]Upgraded git hook:[/green] .git/hooks/{spec.filename}")
             return
         else:
             # Foreign hook without sqlcg sentinel

sqlcg/cli/commands/index.py

@@ -1,6 +1,8 @@
 """Index command for scanning and indexing SQL files."""
 
+import json
 import os
+import socket as _socket
 from pathlib import Path
 
 import typer
@@ -19,6 +21,10 @@ from sqlcg.indexer.indexer import Indexer
 
 console = Console()
 
+# Socket timeout for the index-via-server path.
+# Generous budget: full index of a large repo can take several minutes.
+_INDEX_SOCKET_TIMEOUT_S = 600
+
 
 def index_cmd(  # noqa: B008
     path: Path = typer.Argument(..., help="Directory to index"),  # noqa: B008
@@ -71,9 +77,24 @@ def index_cmd(  # noqa: B008
             "Marks freshness as 'indexed with working-tree changes'."
         ),
     ),
+    detach: bool = typer.Option(  # noqa: B008
+        False,
+        "--detach",
+        help=(
+            "When routing through a live server, return immediately after enqueueing "
+            "(fire-and-forget). Default is to wait for the index to complete."
+        ),
+    ),
 ) -> None:
     """Index SQL files in a directory.
 
+    When a server is live on this DB, the index is routed through the server's
+    control socket so the DB is never opened directly (avoids lock contention).
+    Use --detach to enqueue and return immediately (fire-and-forget).
+
+    With no server live, falls back to the direct-write path unchanged
+    (zero-config small-repo invariant).
+
     Schema aliases (staging schema → canonical schema) can be configured in
     .sqlcg.toml under sqlcg.schema_aliases, e.g. da_tmp = "da".
     """
@@ -85,6 +106,26 @@ def index_cmd(  # noqa: B008
     logging.getLogger("sqlcg").setLevel(level)
     logging.getLogger("sqlglot").setLevel(level)
 
+    # Resolve path early so socket routing uses the absolute path.
+    path = path.resolve()
+
+    # Resolve dialect before routing so the WriterRequest always carries a concrete
+    # dialect (never the literal sentinel "auto").  Bug A: the route call was before
+    # this resolution, causing the server to receive "auto" and fail with
+    # "Unknown dialect 'auto'" on every server-routed index.
+    if dialect == "auto":
+        dialect = get_dialect(path)
+
+    # Step 3.2 — probe for a live server and route through the socket if present.
+    _routed = _try_route_index_via_server(
+        path=path,
+        dialect=dialect,
+        wait=not detach,
+        quiet=quiet,
+    )
+    if _routed:
+        return
+
     # Route parse warnings to stderr (--verbose) or to the configured log file.
     sqlcg_log = logging.getLogger("sqlcg")
 
@@ -117,10 +158,6 @@ def index_cmd(  # noqa: B008
     if buffer_pool_size > 0:
         os.environ["SQLCG_BUFFER_POOL_MB"] = str(buffer_pool_size)
 
-    # Resolve dialect: 'auto' reads from .sqlcg.toml, otherwise use provided value
-    if dialect == "auto":
-        dialect = get_dialect(path)
-
     if not quiet and not config_file_present(path):
         console.print(
             f"[yellow]No .sqlcg.toml found at {path}/.sqlcg.toml — "
@@ -172,6 +209,132 @@ def index_cmd(  # noqa: B008
         )
 
 
+def _try_route_index_via_server(
+    *,
+    path: Path,
+    dialect: str | None,
+    wait: bool,
+    quiet: bool,
+) -> bool:
+    """Probe for a live server and route the index through the socket if found.
+
+    Returns True if the index was handled via the server (caller should return).
+    Returns False if no server is live (caller should fall through to direct path).
+    """
+    from sqlcg.server.control import sock_path
+
+    sp = sock_path()
+    if not sp.exists():
+        return False
+
+    payload = {
+        "op": "index",
+        "root": str(path),
+        "dialect": dialect,
+        "wait": wait,
+        "requested_by": "cli",
+    }
+    payload_bytes = json.dumps(payload).encode()
+    frame = f"{len(payload_bytes)}\n".encode() + payload_bytes
+
+    try:
+        with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
+            s.settimeout(_INDEX_SOCKET_TIMEOUT_S)
+            s.connect(str(sp))
+            s.sendall(frame)
+
+            if not wait:
+                # Fire-and-forget: read one framed acknowledgement frame.
+                f = s.makefile("rb")
+                length_line = f.readline()
+                if length_line:
+                    try:
+                        body_len = int(length_line.strip())
+                        resp_bytes = f.read(body_len)
+                        resp = json.loads(resp_bytes)
+                        if "error" in resp:
+                            err = resp["error"]
+                            if "SQLCG_DB_PATH" in err or "write lock" in err:
+                                console.print(f"[red]{err}[/red]")
+                            else:
+                                console.print(f"[red]Server error: {err}[/red]")
+                            raise typer.Exit(1)
+                        if not quiet:
+                            pos = resp.get("position", "?")
+                            console.print(f"[green]Queued via server[/green] (position {pos})")
+                    except (ValueError, json.JSONDecodeError):
+                        pass
+                return True
+
+            # wait=True: stream framed frames until done:true.
+            f = s.makefile("rb")
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                MofNCompleteColumn(),
+                TimeRemainingColumn(),
+                console=console,
+                redirect_stderr=True,
+            ) as progress:
+                task = progress.add_task("Indexing via server", total=None)
+
+                while True:
+                    length_line = f.readline()
+                    if not length_line:
+                        break
+                    try:
+                        body_len = int(length_line.strip())
+                    except ValueError:
+                        break
+                    frame_bytes = f.read(body_len)
+                    frame_resp = json.loads(frame_bytes)
+
+                    if frame_resp.get("done"):
+                        if not frame_resp.get("ok"):
+                            err = frame_resp.get("error", "unknown error")
+                            if "SQLCG_DB_PATH" in err or "write lock" in err:
+                                console.print(f"[red]{err}[/red]")
+                            else:
+                                console.print(f"[red]Server index error: {err}[/red]")
+                            raise typer.Exit(1)
+                        srv_summary = frame_resp.get("summary", {})
+                        if not quiet:
+                            console.print(
+                                f"[green]Indexed via server[/green] "
+                                f"{srv_summary.get('files_parsed', '?')} files — "
+                                f"{srv_summary.get('tables_found', '?')} tables, "
+                                f"{srv_summary.get('lineage_edges_created', '?')} edges"
+                            )
+                        break
+                    # Progress frame
+                    files_done = frame_resp.get("files_done", 0)
+                    files_total = frame_resp.get("files_total")
+                    if files_total:
+                        progress.update(task, completed=files_done, total=files_total)
+
+        return True
+
+    except TimeoutError:
+        import sys as _sys
+
+        print(
+            f"Server is still applying the index (timed out waiting after "
+            f"{_INDEX_SOCKET_TIMEOUT_S}s); the graph will update when it finishes "
+            "— check 'sqlcg mcp status'.",
+            file=_sys.stderr,
+        )
+        raise typer.Exit(0) from None
+    except (FileNotFoundError, ConnectionRefusedError, OSError):
+        # No live server — fall through to direct path.
+        return False
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        console.print(f"[red]Socket routing failed: {exc}[/red]")
+        raise typer.Exit(1) from exc
+
+
 def _run_index(
     *,
     path: Path,

sqlcg/cli/commands/mcp.py

@@ -78,7 +78,12 @@ def mcp_status() -> None:
     """Print server status JSON (connects to control socket).
 
     Returns JSON with fields: running, pid, db_path, indexed_sha, head_sha,
-    stale_by_commits, connected_clients, uptime when a server is live.
+    stale_by_commits, connected_clients, uptime, writer_queue when a server
+    is live.
+
+    The status response is length-prefixed framed (v1.3.0, B3) so large
+    writer_queue payloads are received in full — the client uses the
+    recv-exactly makefile+readline+read(n) pattern, NOT a single recv(4096).
 
     When no server is found: {"running": false}.
     When the PID file exists with a live process but the socket is unavailable:
@@ -89,6 +94,7 @@ def mcp_status() -> None:
     to the PID-file probe — never hangs or errors on a dead socket.
     """
     import socket as _socket
+    from datetime import datetime
 
     from sqlcg.server.control import is_pid_alive, read_pid, sock_path
 
@@ -98,8 +104,69 @@ def mcp_status() -> None:
             s.settimeout(2)
             s.connect(str(sp))
             s.sendall(json.dumps({"op": "status"}).encode() + b"\n")
-            data = s.recv(4096)
-        console.print_json(data.decode())
+            # Framed recv-exactly (B3 / OD-4): read length line then exactly that many bytes.
+            # This replaces the old s.recv(4096) which would truncate large writer_queue payloads.
+            f = s.makefile("rb")
+            length_line = f.readline()
+            if length_line:
+                try:
+                    body_len = int(length_line.strip())
+                    data = f.read(body_len)
+                except (ValueError, OSError):
+                    data = length_line  # fallback: treat first line as body
+            else:
+                data = b""
+
+        status = json.loads(data.decode())
+
+        # Pretty-print the base fields.
+        console.print_json(json.dumps({k: v for k, v in status.items() if k != "writer_queue"}))
+
+        # Render the writer_queue block separately for readability.
+        wq = status.get("writer_queue")
+        if wq:
+            console.print("\n[bold]writer_queue[/bold]")
+            active = wq.get("active")
+            if active:
+                console.print(f"  active: op={active.get('op')!r} root={active.get('root')!r}")
+                prog = wq.get("active_progress", {})
+                if prog.get("state") == "running":
+                    files_done = prog.get("files_done", 0)
+                    files_total = prog.get("files_total")
+                    if files_total:
+                        console.print(f"    progress: {files_done}/{files_total} files")
+            else:
+                console.print("  active: none")
+
+            pending = wq.get("pending", [])
+            console.print(f"  pending: {len(pending)}")
+
+            total_coalesced = wq.get("coalesced_since_start", 0)
+            by_reason = wq.get("coalesced_by_reason", {})
+            if total_coalesced:
+                from sqlcg.server.writer import (
+                    COALESCE_COLLAPSED_INTO_PENDING_REINDEX,
+                    COALESCE_REINDEX_DROPPED_INDEX_PENDING,
+                    COALESCE_SUPERSEDED_BY_INDEX,
+                )
+
+                n_sup = by_reason.get(COALESCE_SUPERSEDED_BY_INDEX, 0)
+                n_col = by_reason.get(COALESCE_COLLAPSED_INTO_PENDING_REINDEX, 0)
+                n_drop = by_reason.get(COALESCE_REINDEX_DROPPED_INDEX_PENDING, 0)
+                console.print(
+                    f"  coalesced: {total_coalesced} "
+                    f"(superseded_by_index={n_sup}, "
+                    f"collapsed_into_pending_reindex={n_col}, "
+                    f"reindex_dropped_index_pending={n_drop})"
+                )
+                last_at = wq.get("last_coalesce_at")
+                last_reason = wq.get("last_coalesce_reason")
+                if last_at and last_reason:
+                    last_human = datetime.fromtimestamp(last_at).strftime("%Y-%m-%d %H:%M:%S")
+                    console.print(f"  last coalesce: {last_reason} at {last_human}")
+            else:
+                console.print("  coalesced: 0")
+
     except (FileNotFoundError, ConnectionRefusedError, OSError):
         # Socket unavailable — probe via PID file (R3: stale-socket fall-through)
         rec = read_pid()