synapse-cli-agent 0.1.18__tar.gz → 0.1.19__tar.gz

{synapse_cli_agent-0.1.18 → synapse_cli_agent-0.1.19}/CHANGELOG.md

@@ -7,6 +7,22 @@ The release workflow automatically extracts the matching section as release note
 
 ---
 
+## v0.1.19
+
+### 新增功能
+
+- Codex OAuth 用量底部栏组件：展示 5h/1d 用量窗口、重置剩余时间和账号到期时间；低于 50% 时红色显示。
+- Codex 速率限制重置能力：直接通过 HTTP 请求 wham/rate-limit-reset-credits 读取可用重置次数与到期详情，支持在弹窗中一键消费重置。
+- /codex reset、/codex credits 命令打开重置详情弹窗；底部栏 Codex 区域支持 hover 高亮与点击。
+- 启动时配置错误友好提示：models.json、settings.json 或内联 JSON 环境变量格式错误时输出简洁错误与修复提示，不再抛出完整 traceback。
+
+### 修复
+
+- /compact 改为后台 worker 执行，避免模型摘要阻塞 TUI；执行期间禁止取消，防止压缩状态损坏。
+- 兼容 LangChain 1.3 编译图闭包中的 SummarizationMiddleware 定位。
+
+---
+
 ## v0.1.18
 
 ### 新功能

{synapse_cli_agent-0.1.18 → synapse_cli_agent-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-cli-agent
-Version: 0.1.18
+Version: 0.1.19
 Summary: Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)
 Project-URL: Homepage, https://github.com/alex8224/synapse-agent
 Project-URL: Repository, https://github.com/alex8224/synapse-agent

{synapse_cli_agent-0.1.18 → synapse_cli_agent-0.1.19}/docs/config.md

@@ -113,6 +113,12 @@ Synapse 使用 **Pydantic Settings** 实现分层配置系统。
 
 参见 [模型配置](models.md) 页面。
 
+### 配置错误提示
+
+启动时如果 `models.json`、`settings.json` 或内联 JSON 环境变量格式错误，Synapse 会输出
+简短的错误说明和修复提示后退出，不会显示完整 Python traceback。对于 `models.json`，错误信息会
+包含出错文件路径和 JSON 的行列位置；修复配置后重新启动即可。
+
 ## `.coding-agent/mcp_servers.json` 格式
 
 参见 [MCP Server](mcp.md) 页面。

{synapse_cli_agent-0.1.18 → synapse_cli_agent-0.1.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synapse-cli-agent"
-version = "0.1.18"
+version = "0.1.19"
 description = "Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)"
 readme = "README.md"
 authors = [

synapse_cli_agent-0.1.19/release_body.md

@@ -0,0 +1,15 @@
+## v0.1.19
+
+### 新增功能
+
+- Codex OAuth 用量底部栏组件：展示 5h/1d 用量窗口、重置剩余时间和账号到期时间；低于 50% 时红色显示。
+- Codex 速率限制重置能力：直接通过 HTTP 请求 wham/rate-limit-reset-credits 读取可用重置次数与到期详情，支持在弹窗中一键消费重置。
+- /codex reset、/codex credits 命令打开重置详情弹窗；底部栏 Codex 区域支持 hover 高亮与点击。
+- 启动时配置错误友好提示：models.json、settings.json 或内联 JSON 环境变量格式错误时输出简洁错误与修复提示，不再抛出完整 traceback。
+
+### 修复
+
+- /compact 改为后台 worker 执行，避免模型摘要阻塞 TUI；执行期间禁止取消，防止压缩状态损坏。
+- 兼容 LangChain 1.3 编译图闭包中的 SummarizationMiddleware 定位。
+
+---

{synapse_cli_agent-0.1.18 → synapse_cli_agent-0.1.19}/src/synapse/cli.py

@@ -93,6 +93,15 @@ def _print_auth_error(settings, exc: Exception) -> None:
         )
 
 
+def _print_settings_error(exc: Exception) -> None:
+    """Print a concise, actionable configuration error without a traceback."""
+    print_error(f"Configuration error: {exc}")
+    print_info(
+        "Check models.json, settings.json, and inline JSON environment variables "
+        "(MODELS_JSON / MCP_SERVERS_JSON)."
+    )
+
+
 # ---------------------------------------------------------------------------
 # Authentication commands
 # ---------------------------------------------------------------------------
@@ -252,14 +261,18 @@ def _launch_tui(
     debug: bool,
 ) -> None:
     """Bootstrap settings and open the full-screen Textual TUI."""
-    env_path = _bootstrap_env()
-    settings = _resolve_settings(
-        workspace=workspace,
-        model=model,
-        require_approval=require_approval,
-        debug=debug,
-        readonly=readonly,
-    )
+    try:
+        env_path = _bootstrap_env()
+        settings = _resolve_settings(
+            workspace=workspace,
+            model=model,
+            require_approval=require_approval,
+            debug=debug,
+            readonly=readonly,
+        )
+    except (OSError, ValueError) as exc:
+        _print_settings_error(exc)
+        raise typer.Exit(code=1) from exc
     try:
         from synapse.ui.tui import run_tui
     except ImportError as exc:  # pragma: no cover - dependency missing
@@ -965,4 +978,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()

synapse_cli_agent-0.1.19/src/synapse/integrations/openai_usage.py

@@ -0,0 +1,406 @@
+"""Read-only Codex OAuth usage snapshots for the TUI bottombar."""
+
+from __future__ import annotations
+
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+import httpx
+
+from synapse.integrations.openai_oauth import OpenAIOAuthStore, OpenAIOAuthTokenProvider
+
+OPENAI_USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage"
+OPENAI_RESET_CREDITS_ENDPOINT = (
+    "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits"
+)
+OPENAI_CONSUME_RESET_ENDPOINT = (
+    "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume"
+)
+USAGE_CACHE_TTL_SECONDS = 300.0
+
+
+@dataclass(frozen=True, slots=True)
+class UsageWindow:
+    """One Codex rate-limit window."""
+    used_percent: float | None
+    window_minutes: int | None
+    reset_at: float | None
+    @property
+    def remaining_percent(self) -> int | None:
+        if self.used_percent is None:
+            return None
+        return round(max(0.0, min(100.0, 100.0 - self.used_percent)))
+
+
+@dataclass(frozen=True, slots=True)
+class ResetCreditDetail:
+    """One available / consumed rate-limit reset credit."""
+    id: str
+    reset_type: str
+    status: str
+    granted_at: float | None
+    expires_at: float | None
+    title: str | None
+    description: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class ResetCredits:
+    """Aggregated reset-credit snapshot from the backend."""
+    available_count: int
+    credits: list[ResetCreditDetail] = field(default_factory=list)
+
+
+@dataclass(frozen=True, slots=True)
+class ConsumeResetResult:
+    """Outcome of a single reset-credit redemption."""
+    outcome: str
+    idempotency_key: str
+
+
+@dataclass(frozen=True, slots=True)
+class CodexUsageSnapshot:
+    """Parsed Codex primary/secondary usage windows + optional reset credits."""
+    primary: UsageWindow | None = None
+    secondary: UsageWindow | None = None
+    captured_at: float = 0.0
+    expires_at: float | None = None
+    reset_credits: ResetCredits | None = None
+    @property
+    def lowest_remaining_percent(self) -> int | None:
+        values = [
+            value for value in (
+                self.primary.remaining_percent if self.primary else None,
+                self.secondary.remaining_percent if self.secondary else None,
+            ) if value is not None
+        ]
+        return min(values) if values else None
+
+
+class CodexUsageClient:
+    """Fetch and cache the Codex OAuth usage / reset-credit endpoints."""
+    def __init__(self, *, store=None, timeout=10.0, cache_ttl=USAGE_CACHE_TTL_SECONDS):
+        self._store = store or OpenAIOAuthStore()
+        self._token_provider = OpenAIOAuthTokenProvider(self._store)
+        self._timeout = max(1.0, float(timeout))
+        self._cache_ttl = max(0.0, float(cache_ttl))
+        self._lock = threading.RLock()
+        self._cached: CodexUsageSnapshot | None = None
+        self._cached_at = 0.0
+        self._cached_details: ResetCredits | None = None
+        self._cached_details_at = 0.0
+
+    def _auth_headers(self) -> dict[str, str]:
+        tokens = self._store.load()
+        if tokens is None:
+            raise RuntimeError("OpenAI Codex OAuth is not logged in")
+        access_token = self._token_provider.access_token()
+        tokens = self._store.load() or tokens
+        headers: dict[str, str] = {
+            "Authorization": f"Bearer {access_token}",
+            "originator": "synapse",
+        }
+        if tokens.account_id:
+            headers["ChatGPT-Account-Id"] = tokens.account_id
+        return headers
+
+    def get_cached(self) -> CodexUsageSnapshot | None:
+        with self._lock:
+            if self._cached is None:
+                return None
+            if time.monotonic() - self._cached_at > self._cache_ttl:
+                return None
+            return self._cached
+
+    def fetch(self, *, force=False) -> CodexUsageSnapshot:
+        with self._lock:
+            if not force:
+                cached = self.get_cached()
+                if cached is not None:
+                    return cached
+        headers = self._auth_headers()
+        response = httpx.get(OPENAI_USAGE_ENDPOINT, headers=headers, timeout=self._timeout)
+        response.raise_for_status()
+        payload = response.json()
+        tokens = self._store.load()
+        snapshot = parse_usage_payload(payload, expires_at=tokens.expires_at if tokens else None)
+        with self._lock:
+            self._cached = snapshot
+            self._cached_at = time.monotonic()
+        return snapshot
+
+    def get_cached_details(self) -> ResetCredits | None:
+        with self._lock:
+            if self._cached_details is None:
+                return None
+            if time.monotonic() - self._cached_details_at > self._cache_ttl:
+                return None
+            return self._cached_details
+
+    def fetch_reset_credits(self, *, force=False) -> ResetCredits:
+        with self._lock:
+            if not force:
+                cached = self.get_cached_details()
+                if cached is not None:
+                    return cached
+        headers = self._auth_headers()
+        response = httpx.get(OPENAI_RESET_CREDITS_ENDPOINT, headers=headers, timeout=self._timeout)
+        response.raise_for_status()
+        details = parse_reset_credits_details(response.json())
+        with self._lock:
+            self._cached_details = details
+            self._cached_details_at = time.monotonic()
+        return details
+
+    def consume_reset_credit(self, *, credit_id=None, idempotency_key=None) -> ConsumeResetResult:
+        key = idempotency_key or uuid.uuid4().hex
+        headers = self._auth_headers()
+        body: dict[str, str] = {"redeem_request_id": key}
+        if credit_id:
+            body["credit_id"] = credit_id
+        response = httpx.post(
+            OPENAI_CONSUME_RESET_ENDPOINT, headers=headers, json=body, timeout=self._timeout,
+        )
+        response.raise_for_status()
+        payload = response.json()
+        outcome = str(payload.get("outcome") or payload.get("code") or "unknown")
+        return ConsumeResetResult(outcome=outcome, idempotency_key=key)
+
+
+def parse_usage_payload(payload, *, expires_at=None, captured_at=None) -> CodexUsageSnapshot:
+    if not isinstance(payload, dict):
+        raise ValueError("Codex usage response must be a JSON object")
+    rate_limit = payload.get("rate_limit")
+    if not isinstance(rate_limit, dict):
+        raise ValueError("Codex usage response has no rate_limit object")
+    return CodexUsageSnapshot(
+        primary=_parse_window(rate_limit.get("primary_window")),
+        secondary=_parse_window(rate_limit.get("secondary_window")),
+        captured_at=time.time() if captured_at is None else float(captured_at),
+        expires_at=expires_at,
+        reset_credits=_parse_reset_credits_summary(payload.get("rate_limit_reset_credits")),
+    )
+
+
+def parse_reset_credits_details(payload) -> ResetCredits:
+    if not isinstance(payload, dict):
+        raise ValueError("Reset-credits response must be a JSON object")
+    count = _as_int(payload.get("available_count")) or 0
+    raw = payload.get("credits")
+    credits: list[ResetCreditDetail] = []
+    if isinstance(raw, list):
+        for item in raw:
+            if isinstance(item, dict):
+                credits.append(_parse_reset_credit_detail(item))
+    return ResetCredits(available_count=count, credits=credits)
+
+
+def _parse_reset_credits_summary(raw) -> ResetCredits | None:
+    if not isinstance(raw, dict):
+        return None
+    count = _as_int(raw.get("available_count"))
+    if count is None:
+        return None
+    raw_list = raw.get("credits")
+    credits: list[ResetCreditDetail] = []
+    if isinstance(raw_list, list):
+        for item in raw_list:
+            if isinstance(item, dict):
+                credits.append(_parse_reset_credit_detail(item))
+    return ResetCredits(available_count=count, credits=credits)
+
+
+def _parse_reset_credit_detail(raw: dict[str, Any]) -> ResetCreditDetail:
+    return ResetCreditDetail(
+        id=str(raw.get("id") or ""),
+        reset_type=str(raw.get("resetType") or raw.get("reset_type") or "unknown"),
+        status=str(raw.get("status") or "unknown"),
+        granted_at=_as_timestamp(raw.get("grantedAt") or raw.get("granted_at")),
+        expires_at=_as_timestamp(raw.get("expiresAt") or raw.get("expires_at")),
+        title=raw.get("title") or None,
+        description=raw.get("description") or None,
+    )
+
+
+def _as_timestamp(value: Any) -> float | None:
+    """Parse Unix seconds or an ISO 8601 timestamp from backend responses."""
+    number = _as_float(value)
+    if number is not None:
+        return number
+    if not isinstance(value, str) or not value.strip():
+        return None
+    from datetime import datetime
+
+    normalized = value.strip().replace("Z", "+00:00")
+    try:
+        return datetime.fromisoformat(normalized).timestamp()
+    except ValueError:
+        return None
+
+
+def _parse_window(raw) -> UsageWindow | None:
+    if not isinstance(raw, dict):
+        return None
+    used = _as_float(raw.get("used_percent"))
+    if used is None:
+        return None
+    seconds = _as_int(raw.get("limit_window_seconds"))
+    return UsageWindow(
+        used_percent=max(0.0, min(100.0, used)),
+        window_minutes=(seconds + 59) // 60 if seconds and seconds > 0 else None,
+        reset_at=_as_float(raw.get("reset_at")),
+    )
+
+
+def _as_float(value) -> float | None:
+    if isinstance(value, bool) or value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _as_int(value) -> int | None:
+    number = _as_float(value)
+    return int(number) if number is not None else None
+
+
+def format_reset_remaining(reset_at, *, now=None) -> str:
+    if reset_at is None:
+        return "--"
+    seconds = max(0, int(reset_at - (time.time() if now is None else now)))
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes = (seconds + 59) // 60
+    if minutes < 60:
+        return f"{minutes}m"
+    hours = (minutes + 59) // 60
+    if hours < 24:
+        return f"{hours}h"
+    return f"{(hours + 23) // 24}d"
+
+
+def format_usage_label(snapshot) -> str:
+    if snapshot is None:
+        return "codex n/a"
+    parts: list[str] = []
+    for label, window in (("5h", snapshot.primary), ("1d", snapshot.secondary)):
+        if window is None or window.remaining_percent is None:
+            continue
+        reset = format_reset_remaining(window.reset_at)
+        parts.append(f"{label} {window.remaining_percent}%/{reset}")
+    if snapshot.reset_credits is not None and snapshot.reset_credits.available_count > 0:
+        parts.append(f"resets {snapshot.reset_credits.available_count}")
+    if snapshot.expires_at is not None:
+        parts.append(f"exp {format_reset_remaining(snapshot.expires_at)}")
+    return " · ".join(parts) if parts else "codex n/a"
+
+
+def usage_style(snapshot) -> str:
+    if snapshot is not None and snapshot.lowest_remaining_percent is not None:
+        if snapshot.lowest_remaining_percent < 50:
+            return "#f28b82"
+    return "#8ab4f8"
+
+
+# ---------------------------------------------------------------------------
+# TUI-facing service — owns cache / refresh / consume state
+# ---------------------------------------------------------------------------
+
+
+class CodexUsageService:
+    """State holder that the TUI binds to a bottombar component.
+
+    The TUI calls :meth:`refresh_usage` and :meth:`open_reset_dialog` on a
+    Textual worker thread.  This object stores the latest snapshot / details
+    and exposes a ``label`` property for the render path so the bottombar
+    never blocks on I/O.
+    """
+
+    def __init__(self, settings=None) -> None:
+        self._client = CodexUsageClient()
+        self.snapshot: CodexUsageSnapshot | None = None
+        self.loading = False
+        self.error = False
+        self.reset_credits: ResetCredits | None = None
+        self.consuming = False
+        self._last_refresh = 0.0
+        self._settings = settings
+
+    # -- helpers called from the TUI UI thread --------------------------------
+
+    @property
+    def label(self) -> object:
+        """Return rich Text or a plain str for the bottombar render path."""
+        from rich.text import Text
+
+        if self.loading and self.snapshot is None:
+            return Text("codex ...", style="#5f6368")
+        if self.snapshot is None:
+            return Text("codex n/a", style="#5f6368")
+        return Text(
+            format_usage_label(self.snapshot),
+            style=usage_style(self.snapshot),
+        )
+
+    def has_oauth_profile(self) -> bool:
+        """Return True when the active model profile uses Codex OAuth."""
+        settings = self._settings
+        if settings is None:
+            return False
+        try:
+            from synapse.models.registry import registry_from_settings
+
+            registry = registry_from_settings(settings)
+            selected = getattr(settings, "active_model", None) or registry.default
+            return registry.get(selected).auth == "openai_oauth"
+        except Exception:  # noqa: BLE001
+            return False
+
+    def invalidate(self) -> None:
+        """Clear all state (non-OAuth model selected)."""
+        self.snapshot = None
+        self.loading = False
+        self.error = False
+        self.reset_credits = None
+        self._last_refresh = 0.0
+
+    # -- refresh (called from TUI worker thread) ------------------------------
+
+    def should_refresh(self, *, force: bool = False) -> bool:
+        if not self.has_oauth_profile():
+            return False
+        if force:
+            return True
+        if time.monotonic() - self._last_refresh < 300:
+            return False
+        if self.loading:
+            return False
+        return True
+
+    def refresh_usage(self, *, force: bool = False) -> None:
+        """Blocking call — run on a worker thread."""
+        self.loading = True
+        self.error = False
+        self._last_refresh = time.monotonic()
+        try:
+            self.snapshot = self._client.fetch(force=force)
+            self.loading = False
+        except Exception:  # noqa: BLE001
+            self.loading = False
+            self.error = True
+
+    def fetch_reset_credits(self) -> None:
+        """Blocking call — fetch detailed reset-credit rows."""
+        try:
+            self.reset_credits = self._client.fetch_reset_credits()
+        except Exception:  # noqa: BLE001
+            pass
+
+    def consume_reset(self, credit_id: str) -> ConsumeResetResult:
+        """Blocking call — redeem one reset credit."""
+        return self._client.consume_reset_credit(credit_id=credit_id)

{synapse_cli_agent-0.1.18 → synapse_cli_agent-0.1.19}/src/synapse/models/registry.py

@@ -518,25 +518,41 @@ def _profiles_from_mapping(data: dict[str, Any]) -> ModelRegistry:
 
 
 def load_models_config(path: Path | str | None) -> ModelRegistry | None:
-    """Load models JSON if path exists; return None when unset/missing."""
+    """Load models JSON if path exists; return None when unset/missing.
+
+    Raises:
+        ValueError: If the file does not contain valid JSON or a valid model registry.
+    """
     if path is None:
         return None
     p = Path(path).expanduser()
     if not p.is_file():
         return None
-    data = json.loads(p.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
-        raise ValueError("models config root must be an object")
-    return _profiles_from_mapping(data)
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            raise ValueError("root must be an object")
+        return _profiles_from_mapping(data)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"invalid models config JSON in {p}: {exc}") from exc
+    except (OSError, ValueError) as exc:
+        raise ValueError(f"invalid models config in {p}: {exc}") from exc
 
 
 def load_models_json_blob(blob: str | None) -> ModelRegistry | None:
+    """Load an inline MODELS_JSON registry, if configured."""
     if not blob or not blob.strip():
         return None
-    data = json.loads(blob)
+    try:
+        data = json.loads(blob)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"invalid MODELS_JSON: {exc}") from exc
     if not isinstance(data, dict):
         raise ValueError("MODELS_JSON root must be an object")
-    return _profiles_from_mapping(data)
+    try:
+        return _profiles_from_mapping(data)
+    except ValueError as exc:
+        raise ValueError(f"invalid MODELS_JSON: {exc}") from exc
 
 
 def merge_model_profiles(base: ModelProfile, override: ModelProfile) -> ModelProfile:

{synapse_cli_agent-0.1.18 → synapse_cli_agent-0.1.19}/src/synapse/runtime/context_compact.py

@@ -7,6 +7,9 @@ helpers without registering a model-callable compaction tool.
 
 from __future__ import annotations
 
+import functools
+import inspect
+from collections.abc import Iterator, Mapping
 from typing import Any
 
 
@@ -98,16 +101,65 @@ def force_compact_via_agent(
 
 
 def _find_summarization_middleware(agent: Any) -> Any | None:
-    """Return deepagents' built-in automatic summarization middleware."""
+    """Return deepagents' built-in automatic summarization middleware.
+
+    LangChain 1.3 compiles model-call middleware into the ``model`` node's
+    function closure, whereas older versions exposed it through
+    ``node.bound.middleware``. Support both representations so ``/compact``
+    continues to work across the supported dependency range.
+    """
     nodes = getattr(agent, "nodes", None)
     node = nodes.get("model") if isinstance(nodes, dict) else None
-    middleware = getattr(node, "bound", None)
-    for candidate in getattr(middleware, "middleware", ()):
+    bound = getattr(node, "bound", None)
+    for candidate in getattr(bound, "middleware", ()):
+        if getattr(candidate, "name", None) == "SummarizationMiddleware":
+            return candidate
+
+    for candidate in _iter_closure_values(getattr(bound, "func", None)):
+        if getattr(candidate, "name", None) == "SummarizationMiddleware":
+            return candidate
+    for candidate in _iter_closure_values(getattr(bound, "afunc", None)):
         if getattr(candidate, "name", None) == "SummarizationMiddleware":
             return candidate
     return None
 
 
+def _iter_closure_values(root: Any) -> Iterator[Any]:
+    """Yield nonlocal objects captured by a compiled model-node callable.
+
+    This deliberately follows only closure cells and their lightweight
+    containers. It avoids arbitrary ``__dict__`` traversal while still finding
+    middleware instances nested in LangChain's composed call handlers.
+    """
+    pending: list[Any] = [root]
+    seen: set[int] = set()
+    max_items = 256
+
+    while pending and len(seen) < max_items:
+        value = pending.pop()
+        if value is None or id(value) in seen:
+            continue
+        seen.add(id(value))
+        yield value
+
+        if inspect.ismethod(value):
+            pending.extend((value.__self__, value.__func__))
+        elif inspect.isfunction(value):
+            try:
+                closure = inspect.getclosurevars(value)
+            except (TypeError, ValueError):
+                continue
+            pending.extend(closure.nonlocals.values())
+        elif isinstance(value, functools.partial):
+            pending.append(value.func)
+            pending.extend(value.args)
+            pending.extend((value.keywords or {}).values())
+        elif isinstance(value, Mapping):
+            pending.extend(value.values())
+        elif isinstance(value, (list, tuple, set, frozenset)):
+            pending.extend(value)
+
+
 def context_status_lines(agent: Any, thread_id: str) -> list[str]:
     """Report message count + last summarization event for current thread."""
     lines: list[str] = [f"thread_id={thread_id}"]
@@ -216,4 +268,3 @@ def is_context_compact_text(text: str | None) -> bool:
     if has_intent and ("ARTIFACTS" in body or "NEXT STEPS" in body):
         return True
     return False
-