prompture 1.12.4.dev1__tar.gz → 1.12.5.dev1__tar.gz

{prompture-1.12.4.dev1 → prompture-1.12.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.12.4.dev1
+Version: 1.12.5.dev1
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

{prompture-1.12.4.dev1 → prompture-1.12.5.dev1}/prompture/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.12.4.dev1'
-__version_tuple__ = version_tuple = (1, 12, 4, 'dev1')
+__version__ = version = '1.12.5.dev1'
+__version_tuple__ = version_tuple = (1, 12, 5, 'dev1')
 
 __commit_id__ = commit_id = None

{prompture-1.12.4.dev1 → prompture-1.12.5.dev1}/prompture/cli/cli.py

@@ -212,7 +212,12 @@ def test_suite(specfile: str, providers: str | None, models: str | None, fmt: st
     type=int,
     help="Stop when this process exits (used by apps that start the companion for themselves).",
 )
-def companion(port: int, db_path: str | None, exit_with_pid: int | None) -> None:
+@click.option(
+    "--coding-tools/--no-coding-tools",
+    default=True,
+    help="Also count the usage local coding agents (Claude Code, Codex, Kimi Code, …) log on disk (default: on).",
+)
+def companion(port: int, db_path: str | None, exit_with_pid: int | None, coding_tools: bool) -> None:
     """Serve this machine's Prompture usage to desktop companions (no hub needed).
 
     Reads the usage ledger every Prompture call writes to, plus rate-limit
@@ -221,13 +226,15 @@ def companion(port: int, db_path: str | None, exit_with_pid: int | None) -> None
     written to ~/.prompture/companion.json. If a companion is already running,
     this prints its address and exits.
     """
-    from ..companion import CompanionServer, LedgerSource, running_instance
+    from ..companion import CodingToolSource, CompanionServer, LedgerSource, running_instance
 
     existing = running_instance()
     if existing:
         click.echo(f"Prompture companion already running at {existing['url']} (pid {existing.get('pid')}).")
         return
-    server = CompanionServer(LedgerSource(db_path), port=port)
+    server = CompanionServer(
+        LedgerSource(db_path), port=port, coding_tools=CodingToolSource() if coding_tools else None
+    )
     click.echo(f"Prompture companion on {server.url} - ledger {server.ledger.db_path}")
     click.echo("Address and token in ~/.prompture/companion.json. Ctrl+C to stop.")
     if exit_with_pid:

{prompture-1.12.4.dev1 → prompture-1.12.5.dev1}/prompture/companion/__init__.py

@@ -6,12 +6,14 @@ Two servers speak it:
   adds keys, projects, alert rules and controls.
 - **the local companion** (``prompture companion``) — no hub needed; reports
   this machine's Prompture usage from the usage ledger, rate-limit headroom and
-  provider account balances.
+  provider account balances, plus the usage local coding agents (Claude Code,
+  Codex, Kimi Code, Gemini CLI, Qwen Code, OpenCode, Cline, …) log on disk.
 
 This package holds what both share — the live event bus, the spend / limits
 aggregations and the API version — plus the local server itself.
 """
 
+from .coding_tools import CodingToolSource
 from .live import LiveBus, get_bus, new_request_id, sse_event, visible
 from .local import LedgerSource
 from .server import CompanionServer, read_state, running_instance
@@ -29,6 +31,7 @@ from .summary import (
 __all__ = [
     "COMPANION_API_VERSION",
     "PERIODS",
+    "CodingToolSource",
     "CompanionServer",
     "LedgerSource",
     "LiveBus",

prompture-1.12.5.dev1/prompture/companion/coding_tools.py

@@ -0,0 +1,188 @@
+"""Usage from coding agents that don't run through Prompture, for the companion.
+
+The reading happens in the engine — :mod:`prompture.infra.coding_agent_usage`
+and one reader per agent in :mod:`prompture.infra.coding_agent_readers`
+(Claude Code, Codex, Kimi Code, Gemini CLI, Qwen Code, OpenCode, Cline,
+Roo Code, Continue; Cursor and Antigravity are detected only). This module
+adapts it to the companion API:
+
+- calls join the ledger's rows in ``/v1/spend`` and stream as
+  ``request.finished`` events tagged with the agent (``key_name``, ``tool``);
+- plan windows (Codex from its logs; Claude Code only when opted in) join
+  ``/v1/limits`` as ``source: "plan"`` targets;
+- ``/v1/tools`` lists every agent: installed, runnable by Prompture, and its
+  usage for the period.
+
+Costs are what the same tokens would cost on the API; subscriptions don't
+bill per token. Only token counts, model names, times and folder names are
+read — never prompts, replies or tool output.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from ..infra.coding_agent_usage import AgentCall, CodingAgentUsage, UsageReader, coding_agents_overview
+from .live import LiveBus
+from .summary import UsageRow, window_start
+
+logger = logging.getLogger("prompture.companion")
+
+#: Seconds an installed-agents answer is reused (it looks up executables on PATH).
+OVERVIEW_TTL = 60.0
+#: How far back calls are kept: a year of activity, plus a week of slack.
+RETENTION = timedelta(days=372)
+#: Companion choices that outlive a restart (today: whether Claude plan windows are fetched).
+PREFS_FILE = Path.home() / ".prompture" / "companion-prefs.json"
+
+
+def _load_prefs(path: Path) -> dict[str, Any]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def call_event(call: AgentCall, name: str) -> dict[str, Any]:
+    """A ``request.finished`` payload for an agent call, shaped like the ledger's."""
+    return {
+        "request_id": call.id,
+        "ts": call.ts.isoformat(),
+        "key_id": None,
+        "key_name": name,
+        "model": call.model,
+        "served_by": None,
+        "project": call.project,
+        "status": "ok",
+        "error": None,
+        "prompt_tokens": call.input_tokens,
+        "completion_tokens": call.output_tokens,
+        "cost_usd": call.cost_usd,
+        "latency_ms": 0,
+        "attempts": 1,
+        "fallback": False,
+        "deprioritized": [],
+        "tool": call.agent,
+    }
+
+
+class CodingToolSource:
+    """Every local coding agent's usage, as the companion needs it.
+
+    With no arguments every registered reader runs. ``claude_dir`` /
+    ``codex_dir`` (tests, custom locations) restrict it to Claude Code and
+    Codex at those folders; ``readers`` sets the list explicitly.
+    """
+
+    def __init__(
+        self,
+        claude_dir: str | Path | None = None,
+        codex_dir: str | Path | None = None,
+        *,
+        plan_usage: bool | None = None,
+        cache_dir: str | Path | None = None,
+        readers: list[UsageReader] | None = None,
+        prefs_file: str | Path | None = PREFS_FILE,
+    ) -> None:
+        from ..infra.coding_agent_readers import ClaudeCodeReader, CodexReader
+        from ..infra.coding_agent_usage import USAGE_READERS
+
+        self.prefs_file = Path(prefs_file) if prefs_file else None
+        explicit_dirs = bool(claude_dir or codex_dir)
+        if plan_usage is None and not explicit_dirs and "PROMPTURE_CLAUDE_PLAN_USAGE" not in os.environ:
+            # The environment wins; otherwise the choice made in a companion app.
+            plan_usage = bool(_load_prefs(self.prefs_file).get("claude_plan_usage")) if self.prefs_file else None
+        if readers is None:
+            claude = ClaudeCodeReader(claude_dir, plan_usage=plan_usage, cache_dir=cache_dir)
+            codex = CodexReader(codex_dir)
+            if explicit_dirs:
+                readers = [claude, codex]
+            else:
+                others = [cls() for agent, cls in USAGE_READERS.items() if agent not in ("claude", "codex")]
+                readers = [claude, codex, *others]
+        self.usage = CodingAgentUsage(readers, retention=RETENTION)
+        self.names = {r.agent: r.display_name for r in readers}
+        self._overview: tuple[float, list[dict[str, Any]]] | None = None
+
+    @property
+    def plan_usage(self) -> bool:
+        """Whether Claude Code's plan windows are fetched (opt-in; see ``ClaudeCodeReader``)."""
+        return any(getattr(r, "plan_usage", False) for r in self.usage.readers)
+
+    def set_claude_plan_usage(self, enabled: bool) -> None:
+        """Turn Claude Code's plan windows on or off, and remember the choice."""
+        for reader in self.usage.readers:
+            if hasattr(reader, "plan_usage"):
+                reader.plan_usage = enabled
+                if not enabled:
+                    reader._plan = None  # forget the last answer too
+        if self.prefs_file:
+            prefs = _load_prefs(self.prefs_file)
+            prefs["claude_plan_usage"] = enabled
+            try:
+                self.prefs_file.parent.mkdir(parents=True, exist_ok=True)
+                self.prefs_file.write_text(json.dumps(prefs), encoding="utf-8")
+            except OSError:
+                logger.debug("could not save companion prefs", exc_info=True)
+
+    def refresh(self, *, force: bool = False) -> list[AgentCall]:
+        """Read what the logs gained since the last scan; returns the new calls."""
+        return self.usage.refresh(force=force)
+
+    def calls(self, period: str = "day", now: datetime | None = None, offset_minutes: int = 0) -> list[AgentCall]:
+        return self.usage.calls(window_start(period, now, offset_minutes))
+
+    def rows(self, period: str = "day", now: datetime | None = None, offset_minutes: int = 0) -> list[UsageRow]:
+        """Calls in the current ``period`` window, as usage rows."""
+        return [
+            UsageRow(model=c.model, cost_usd=c.cost_usd, tokens=c.tokens, project=c.project)
+            for c in self.calls(period, now, offset_minutes)
+        ]
+
+    def rate_limits(self) -> dict[str, dict[str, Any]]:
+        """Plan windows keyed like provider targets: ``openai/codex``, ``claude/claude-code``."""
+        self.usage.refresh()
+        return self.usage.plan_limits()
+
+    def event(self, call: AgentCall) -> dict[str, Any]:
+        return call_event(call, self.names.get(call.agent, call.agent))
+
+    def tools(self, period: str = "day", now: datetime | None = None, offset_minutes: int = 0) -> dict[str, Any]:
+        """``/v1/tools``: each agent's usage for the period, plus what is installed."""
+        if self._overview is None or time.monotonic() - self._overview[0] > OVERVIEW_TTL:
+            try:
+                self._overview = (time.monotonic(), coding_agents_overview())
+            except Exception:
+                logger.debug("coding agent overview failed", exc_info=True)
+                self._overview = (time.monotonic(), [])
+        start = window_start(period, now, offset_minutes)
+        return {
+            "period": period,
+            "start": start.isoformat(),
+            "agents": self.usage.summary(start),
+            "installed": [a for a in self._overview[1] if a["installed"]],
+            "claude_plan_usage": self.plan_usage,
+        }
+
+    def events_since(self, since: datetime, limit: int = 500) -> list[dict[str, Any]]:
+        """``request.finished`` payloads for calls at or after ``since``, newest last."""
+        return [self.event(c) for c in self.usage.calls(since)[-limit:]]
+
+    def tail(self, bus: LiveBus, stop: threading.Event, interval: float = 3.0) -> None:
+        """Publish a ``request.finished`` event for every call logged from now on."""
+        self.refresh(force=True)
+        while not stop.wait(interval):
+            try:
+                for call in sorted(self.refresh(force=True), key=lambda c: c.ts):
+                    if datetime.now(timezone.utc) - call.ts < timedelta(minutes=30):
+                        bus.publish("request.finished", self.event(call))
+            except Exception:  # a bad log line must never stop the companion
+                logger.debug("coding tool scan failed", exc_info=True)

{prompture-1.12.4.dev1 → prompture-1.12.5.dev1}/prompture/companion/local.py

@@ -80,9 +80,9 @@ class LedgerSource:
             project=_project(r["tags"]),
         )
 
-    def rows(self, period: str = "day", now: datetime | None = None) -> list[UsageRow]:
-        """Calls in the current UTC ``period`` window."""
-        start = window_start(period, now).isoformat()
+    def rows(self, period: str = "day", now: datetime | None = None, offset_minutes: int = 0) -> list[UsageRow]:
+        """Calls in the current ``period`` window (UTC unless ``offset_minutes`` is given)."""
+        start = window_start(period, now, offset_minutes).isoformat()
         return [
             self._row(r)
             for r in self._query(
@@ -91,6 +91,23 @@ class LedgerSource:
             )
         ]
 
+    def daily(self, since: datetime, offset_minutes: int = 0) -> dict[str, dict[str, Any]]:
+        """Calls, tokens and cost per local day since ``since``.
+
+        ``offset_minutes`` is the reader's UTC offset as JavaScript reports it
+        (minutes *behind* UTC, e.g. 240 for UTC-4), so days break at local midnight.
+        """
+        rows = self._query(
+            "SELECT date(timestamp, ?) AS day, COUNT(*) AS n, SUM(total_tokens) AS tokens, SUM(cost) AS cost "
+            "FROM usage_events WHERE timestamp >= ? GROUP BY day",
+            (f"{-offset_minutes:+d} minutes", since.isoformat()),
+        )
+        return {
+            r["day"]: {"requests": int(r["n"]), "tokens": int(r["tokens"] or 0), "cost_usd": float(r["cost"] or 0.0)}
+            for r in rows
+            if r["day"]
+        }
+
     def rate_limits(self) -> dict[str, dict[str, Any]]:
         """Latest rate-limit snapshot per model, from recent calls' metadata."""
         out: dict[str, dict[str, Any]] = {}
@@ -109,14 +126,25 @@ class LedgerSource:
         rows = self._query("SELECT MAX(rowid) AS last FROM usage_events")
         return int(rows[0]["last"] or 0) if rows else 0
 
+    _EVENT_COLUMNS = (
+        "SELECT rowid, id, timestamp, model_name, cost, prompt_tokens, completion_tokens, total_tokens, "
+        "elapsed_ms, status, error_message, tags, metadata FROM usage_events "
+    )
+
     def events_after(self, rowid: int) -> list[tuple[int, dict[str, Any]]]:
         """``request.finished`` payloads for rows newer than *rowid*."""
+        return self._events(self._EVENT_COLUMNS + "WHERE rowid > ? ORDER BY rowid", (rowid,))
+
+    def events_since(self, since: datetime, limit: int = 500) -> list[dict[str, Any]]:
+        """``request.finished`` payloads for calls at or after ``since``, newest last."""
+        rows = self._events(
+            self._EVENT_COLUMNS + "WHERE timestamp >= ? ORDER BY rowid DESC LIMIT ?", (since.isoformat(), limit)
+        )
+        return [event for _, event in reversed(rows)]
+
+    def _events(self, sql: str, params: tuple) -> list[tuple[int, dict[str, Any]]]:
         out = []
-        for r in self._query(
-            "SELECT rowid, id, timestamp, model_name, cost, prompt_tokens, completion_tokens, total_tokens, "
-            "elapsed_ms, status, error_message, tags, metadata FROM usage_events WHERE rowid > ? ORDER BY rowid",
-            (rowid,),
-        ):
+        for r in self._query(sql, params):
             meta = _meta(r["metadata"])
             route = meta.get("route") if isinstance(meta.get("route"), dict) else {}
             attempts = sum(1 for a in route.get("attempts", []) if a.get("outcome") in ("ok", "error")) or 1

{prompture-1.12.4.dev1 → prompture-1.12.5.dev1}/prompture/companion/server.py

@@ -9,6 +9,11 @@ Prompture usage with no hub at all:
 - ``GET /v1/spend?period=day|week|month`` and ``GET /v1/limits``.
 - ``GET /v1/alerts`` — always empty; alert rules live in the hub.
 
+With a :class:`~.coding_tools.CodingToolSource` it also counts the calls local
+coding agents (Claude Code, Codex, Kimi Code, Gemini CLI, …) log on disk, adds
+their plan windows to the limits, and serves ``GET /v1/tools?period=`` — each
+agent's usage plus which agents are installed.
+
 It listens on ``127.0.0.1`` only, on a free port the OS picks, and writes the
 address and a random bearer token to ``~/.prompture/companion.json`` (readable
 only by the current user on POSIX). Readers take both from there. Only the
@@ -29,9 +34,10 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import parse_qs, urlparse
 
+from .coding_tools import CodingToolSource
 from .live import LiveBus, get_bus, sse_event
 from .local import LedgerSource
-from .summary import COMPANION_API_VERSION, PERIODS, account_limits, provider_limits, summarize_spend
+from .summary import COMPANION_API_VERSION, PERIODS, UsageRow, account_limits, provider_limits, summarize_spend
 
 logger = logging.getLogger("prompture.companion")
 
@@ -39,13 +45,23 @@ STATE_FILE = Path.home() / ".prompture" / "companion.json"
 HEARTBEAT_SECONDS = 15.0
 
 #: What a client can rely on from this server. The hub advertises more.
-FEATURES = {"live": "/v1/live", "limits": "/v1/limits", "spend": "/v1/spend", "alerts": "/v1/alerts"}
+FEATURES = {
+    "live": "/v1/live",
+    "limits": "/v1/limits",
+    "spend": "/v1/spend",
+    "alerts": "/v1/alerts",
+    "tools": "/v1/tools",
+    "activity": "/v1/activity",
+    "recent": "/v1/recent",
+}
 CAPABILITIES = {
     "running_calls": False,  # the ledger only sees calls after they finish
     "projects": True,
     "key_controls": False,
     "provider_controls": False,
     "alert_rules": False,
+    "coding_tools": False,
+    "activity": True,
 }
 
 
@@ -58,14 +74,14 @@ def _version() -> str:
         return "0"
 
 
-def info() -> dict[str, Any]:
+def info(coding_tools: bool = False) -> dict[str, Any]:
     return {
         "service": "prompture",
         "mode": "local",
         "version": _version(),
         "api_version": COMPANION_API_VERSION,
         "features": dict(FEATURES),
-        "capabilities": dict(CAPABILITIES),
+        "capabilities": {**CAPABILITIES, "coding_tools": coding_tools},
     }
 
 
@@ -87,6 +103,14 @@ def _write_state(path: Path, data: dict[str, Any]) -> None:
     os.replace(tmp, path)
 
 
+def _tz_offset(query: dict[str, str]) -> int:
+    """``tz_offset`` (minutes behind UTC, as JavaScript reports it); 0 = UTC windows."""
+    try:
+        return min(840, max(-840, int(query.get("tz_offset", "0"))))
+    except ValueError:
+        return 0
+
+
 class _Handler(BaseHTTPRequestHandler):
     server: CompanionServer  # type: ignore[assignment]
     protocol_version = "HTTP/1.1"
@@ -108,22 +132,66 @@ class _Handler(BaseHTTPRequestHandler):
         token = header[7:].strip() if header.lower().startswith("bearer ") else ""
         return bool(token) and secrets.compare_digest(token, self.server.token)
 
+    def do_POST(self) -> None:
+        url = urlparse(self.path)
+        if not self._authorized():
+            return self._json(401, {"detail": "Missing or wrong companion token (see ~/.prompture/companion.json)."})
+        if url.path == "/v1/tools/claude-plan" and self.server.coding_tools is not None:
+            try:
+                length = int(self.headers.get("Content-Length") or 0)
+                body = json.loads(self.rfile.read(length) or b"{}")
+            except ValueError:
+                return self._json(400, {"detail": "Body must be JSON."})
+            if not isinstance(body, dict) or not isinstance(body.get("enabled"), bool):
+                return self._json(422, {"detail": 'Send {"enabled": true|false}.'})
+            self.server.coding_tools.set_claude_plan_usage(body["enabled"])
+            return self._json(200, {"claude_plan_usage": self.server.coding_tools.plan_usage})
+        return self._json(404, {"detail": "Not found"})
+
     def do_GET(self) -> None:
         url = urlparse(self.path)
         query = {k: v[-1] for k, v in parse_qs(url.query).items()}
         if url.path == "/v1/companion/info":
-            return self._json(200, info())
+            return self._json(200, info(self.server.coding_tools is not None))
         if not self._authorized():
             return self._json(401, {"detail": "Missing or wrong companion token (see ~/.prompture/companion.json)."})
         if url.path == "/v1/spend":
             period = query.get("period", "day")
             if period not in PERIODS:
                 return self._json(422, {"detail": "period must be day, week or month"})
-            return self._json(200, summarize_spend(self.server.ledger.rows(period), period))
+            sources = query.get("sources", "all")
+            if sources not in ("all", "api"):
+                return self._json(422, {"detail": "sources must be all or api"})
+            # "api": only calls made through Prompture, billed per token — what budgets measure.
+            offset = _tz_offset(query)
+            rows = self.server.rows(period, api_only=sources == "api", offset_minutes=offset)
+            return self._json(200, summarize_spend(rows, period, offset_minutes=offset))
         if url.path == "/v1/limits":
             return self._json(200, self.server.limits(accounts=query.get("accounts", "true") != "false"))
         if url.path == "/v1/alerts":
             return self._json(200, [])
+        if url.path == "/v1/recent":
+            try:
+                minutes = min(24 * 60, max(1, int(query.get("minutes", "30"))))
+            except ValueError:
+                return self._json(422, {"detail": "minutes must be an integer"})
+            return self._json(200, self.server.recent(minutes))
+        if url.path == "/v1/activity":
+            try:
+                days = min(400, max(1, int(query.get("days", "371"))))
+                offset = min(840, max(-840, int(query.get("tz_offset", "0"))))
+            except ValueError:
+                return self._json(422, {"detail": "days and tz_offset must be integers"})
+            return self._json(200, self.server.activity(days, offset))
+        if url.path == "/v1/tools":
+            if self.server.coding_tools is None:
+                return self._json(
+                    404, {"detail": "Coding-tool usage is off (companion started with --no-coding-tools)."}
+                )
+            period = query.get("period", "day")
+            if period not in PERIODS:
+                return self._json(422, {"detail": "period must be day, week or month"})
+            return self._json(200, self.server.coding_tools.tools(period, offset_minutes=_tz_offset(query)))
         if url.path == "/v1/live":
             return self._live(query)
         return self._json(404, {"detail": "Not found"})
@@ -196,25 +264,105 @@ class CompanionServer(ThreadingHTTPServer):
         token: str | None = None,
         bus: LiveBus | None = None,
         state_path: Path | None = STATE_FILE,
+        coding_tools: CodingToolSource | None = None,
     ) -> None:
         super().__init__(("127.0.0.1", port), _Handler)
         self.ledger = ledger or LedgerSource()
         self.token = token or secrets.token_urlsafe(32)
         self.bus = bus or get_bus()
         self.state_path = state_path
+        self.coding_tools = coding_tools
         self.stopping = threading.Event()
 
     @property
     def url(self) -> str:
         return f"http://127.0.0.1:{self.server_address[1]}"
 
+    def rows(self, period: str, *, api_only: bool = False, offset_minutes: int = 0) -> list[UsageRow]:
+        """The ledger's rows for *period*, plus coding-tool calls when enabled (unless ``api_only``)."""
+        rows = self.ledger.rows(period, offset_minutes=offset_minutes)
+        if self.coding_tools is not None and not api_only:
+            rows += self.coding_tools.rows(period, offset_minutes=offset_minutes)
+        return rows
+
+    def rate_limits(self) -> dict[str, dict[str, Any]]:
+        limits = self.ledger.rate_limits()
+        if self.coding_tools is not None:
+            try:
+                limits.update(self.coding_tools.rate_limits())
+            except Exception:  # coding-tool limits are extra context, never a failure
+                logger.debug("coding tool limits failed", exc_info=True)
+        return limits
+
+    def _tail(self) -> None:
+        threading.Thread(target=self.ledger.tail, args=(self.bus, self.stopping), daemon=True).start()
+        if self.coding_tools is not None:
+            threading.Thread(target=self.coding_tools.tail, args=(self.bus, self.stopping), daemon=True).start()
+
+    def recent(self, minutes: int = 30, limit: int = 500) -> list[dict[str, Any]]:
+        """Calls that finished in the last ``minutes``, oldest first, as ``request.finished`` payloads.
+
+        Lets a client that just connected fill its recent-calls view before new
+        calls stream in over ``/v1/live``.
+        """
+        from datetime import datetime, timedelta, timezone
+
+        since = datetime.now(timezone.utc) - timedelta(minutes=minutes)
+        events = self.ledger.events_since(since, limit)
+        if self.coding_tools is not None:
+            events += self.coding_tools.events_since(since, limit)
+        events.sort(key=lambda e: str(e.get("ts") or ""))
+        return [{"type": "request.finished", **e} for e in events[-limit:]]
+
+    def activity(self, days: int = 371, offset_minutes: int = 0) -> dict[str, Any]:
+        """Per-day totals for the last ``days`` local days: Prompture calls plus coding tools.
+
+        Only days with activity are listed; each names what contributed
+        (``sources``: "Prompture" and each coding agent, by tokens).
+        """
+        from datetime import datetime, timedelta, timezone
+
+        local_now = datetime.now(timezone.utc) - timedelta(minutes=offset_minutes)
+        first_day = local_now.date() - timedelta(days=days - 1)
+        since = datetime.combine(first_day, datetime.min.time(), timezone.utc) + timedelta(minutes=offset_minutes)
+        merged: dict[str, dict[str, Any]] = {}
+
+        def add(day: str, requests: int, tokens: int, cost: float, name: str) -> None:
+            d = merged.setdefault(day, {"date": day, "requests": 0, "tokens": 0, "cost_usd": 0.0, "sources": {}})
+            d["requests"] += requests
+            d["tokens"] += tokens
+            d["cost_usd"] += cost
+            s = d["sources"].setdefault(name, {"name": name, "requests": 0, "tokens": 0, "cost_usd": 0.0})
+            s["requests"] += requests
+            s["tokens"] += tokens
+            s["cost_usd"] += cost
+
+        for day, t in self.ledger.daily(since, offset_minutes).items():
+            add(day, t["requests"], t["tokens"], t["cost_usd"], "Prompture")
+        if self.coding_tools is not None:
+            names = self.coding_tools.names
+            for day, t in self.coding_tools.usage.daily(since, offset_minutes).items():
+                for agent, a in t["agents"].items():
+                    add(day, a["requests"], a["tokens"], a["cost_usd"], names.get(agent, agent))
+        out = []
+        for day in sorted(merged):
+            if day < first_day.isoformat():
+                continue
+            d = merged[day]
+            d["cost_usd"] = round(d["cost_usd"], 6)
+            d["sources"] = sorted(
+                ({**s, "cost_usd": round(s["cost_usd"], 6)} for s in d["sources"].values()), key=lambda s: -s["tokens"]
+            )
+            out.append(d)
+        return {"start": first_day.isoformat(), "end": local_now.date().isoformat(), "days": out}
+
     def limits(self, *, accounts: bool = True) -> dict[str, Any]:
         from datetime import datetime, timezone
 
         body: dict[str, Any] = {
             "generated_at": datetime.now(timezone.utc).isoformat(),
             "keys": [],
-            "providers": provider_limits(self.ledger.rate_limits()),
+            "providers": provider_limits(self.rate_limits()),
             "accounts": None,
             "paused_providers": [],
         }
@@ -228,7 +376,7 @@ class CompanionServer(ThreadingHTTPServer):
 
     def start_background(self) -> threading.Thread:
         """Start tailing the ledger and serving on background threads (for tests and embedding)."""
-        threading.Thread(target=self.ledger.tail, args=(self.bus, self.stopping), daemon=True).start()
+        self._tail()
         thread = threading.Thread(target=self.serve_forever, daemon=True)
         thread.start()
         return thread
@@ -237,7 +385,7 @@ class CompanionServer(ThreadingHTTPServer):
         """Serve until interrupted, advertising the address in the state file."""
         if self.state_path is not None:
             _write_state(self.state_path, {"url": self.url, "token": self.token, "pid": os.getpid()})
-        threading.Thread(target=self.ledger.tail, args=(self.bus, self.stopping), daemon=True).start()
+        self._tail()
         try:
             self.serve_forever()
         finally: