hyperagents 1.2.3rc5.post3__py3-none-any.whl

hyperclaw/default_config/models.yaml

@@ -0,0 +1,161 @@
+# HyperClaw Model Registry
+# Thinking/effort per model come from hyperclaw/anthropic_params.py (capability
+# table). Override per model here, e.g.
+#   claude-sonnet-5-5: {thinking: adaptive, effort: high}
+#   claude-haiku-4-5:  {thinking: enabled, thinking_budget: 4000}
+# thinking: adaptive | enabled | none; effort: low | medium | high | xhigh | max.
+# A mode the model rejects (enabled on the 5.x generation) is never sent.
+models:
+  claude-fable-5:
+    provider: anthropic
+    cost_per_1k_input: 0.010
+    cost_per_1k_output: 0.050
+    latency_ms: 6000
+    max_tokens: 16000
+    suitable_tasks: [research, analysis, synthesis, planning, code, health, finance, scientific]
+    note: "Top tier — hardest multi-step work. Thinking always on."
+
+  claude-sonnet-5:
+    provider: anthropic
+    cost_per_1k_input: 0.002
+    cost_per_1k_output: 0.010
+    latency_ms: 2000
+    max_tokens: 16000
+    suitable_tasks: [research, analysis, synthesis, planning, code, health, finance, scientific]
+
+  claude-opus-5:
+    provider: anthropic
+    cost_per_1k_input: 0.005
+    cost_per_1k_output: 0.025
+    latency_ms: 4000
+    max_tokens: 16000
+    suitable_tasks: [research, analysis, synthesis, planning, code, health, finance, scientific]
+
+  claude-haiku-4-5:
+    provider: anthropic
+    cost_per_1k_input: 0.001
+    cost_per_1k_output: 0.005
+    latency_ms: 500
+    max_tokens: 4096
+    suitable_tasks: [routing, classification, quick_lookup, summarization, draft, triage, status_check]
+
+  claude-code:
+    provider: anthropic
+    cost_per_1k_input: 0.003
+    cost_per_1k_output: 0.015
+    latency_ms: 3000
+    max_tokens: 8192
+    suitable_tasks: [code]
+
+  chatjimmy:
+    provider: chatjimmy
+    cost_per_1k_input: 0.000001
+    cost_per_1k_output: 0.000001
+    latency_ms: 50
+    max_tokens: 2048
+    suitable_tasks: [routing, classification, quick_lookup, summarization, draft, triage, status_check]
+    note: "Powered by Taalas HC1 silicon — Llama 3.1 8B at 17,000 tokens/sec. Never auto-certified."
+
+  nim-local:
+    provider: nim
+    cost_per_1k_input: 0.0
+    cost_per_1k_output: 0.0
+    latency_ms: 500
+    max_tokens: 4096
+    suitable_tasks: [research, analysis, code]
+
+  zimage-turbo:
+    provider: replicate
+    type: image_generation
+    cost_per_image: 0.004
+    latency_ms: 1000
+    max_resolution: 1024x1024
+    suitable_tasks: [image_generation, illustration, diagram, visualization, creative_art, mockup, logo]
+    note: "Zimage Turbo via Replicate — 6B params, sub-second generation, strong text rendering"
+
+# ── Provider routing (1.2.0; V2 default 1.2.3) ───────────────────────────
+# A provider is LIVE only if every *_env below resolves to a non-empty
+# value (or has a package default); slot ladders are filtered to live
+# providers at startup.
+#
+# origin: hyper    -> Hyper's own model (HyperSpeed V2), the default.
+# origin: customer -> the customer's own provider; off unless they add a key,
+#                     labelled "your own provider (<label>)". A Hyper-deployed
+#                     install (HYPERCLAW_DEPLOYMENT=hyper) loads origin: hyper only.
+#
+# `capabilities` DECLARES what a provider can do. tool_use is GRANTED only
+# when a qualification record says that provider+model is QUALIFIED
+# (hyperclaw/qualification.py); otherwise the provider is chat-only.
+providers:
+  hyperspeed:
+    origin: hyper
+    label: HyperSpeed V2
+    kind: openai_compat
+    # Base URL and model come from hyperclaw/hyperspeed.py; the customer only
+    # supplies a Hyper access key. HYPERSPEED_BASE_URL / HYPERSPEED_MODEL override.
+    package_defaults: hyperspeed_v2
+    base_url_env: HYPERSPEED_BASE_URL
+    api_key_env: HYPERSPEED_API_KEY
+    model_env: HYPERSPEED_MODEL
+    # V2 limits as documented by the serving team (13 Oct; not yet confirmed
+    # against a live GET /v1/models): max-model-len 65536, max output 16384,
+    # plus up to 8192 reasoning tokens when thinking is on for the call. Every
+    # call sets its own max output, never above max_output_tokens
+    # (hyperclaw/cost_guard.py max_output); the cost guard reserves the max
+    # output plus max_reasoning_tokens for a call with thinking on.
+    max_output_tokens: 16384
+    max_reasoning_tokens: 8192
+    # tool_use is declared but NOT granted until a qualification record says
+    # QUALIFIED for the served model; until then V2 is chat-only.
+    capabilities: [chat, streaming, tool_use]
+  anthropic:
+    origin: customer
+    label: Anthropic
+    kind: anthropic            # native Messages API
+    api_key_env: ANTHROPIC_API_KEY
+    capabilities: [chat, streaming, tool_use, images, documents, thinking]
+    models: {default: claude-sonnet-4-6, fast: claude-haiku-4-5-20251001, strong: claude-opus-4-8,
+             standard: claude-sonnet-5, premium: claude-opus-5, flagship: claude-fable-5}
+  chatjimmy:
+    origin: customer
+    label: ChatJimmy
+    kind: openai_compat
+    base_url_env: CHATJIMMY_BASE_URL   # official Taalas API URL (by application); NOT the chatjimmy.ai demo
+    api_key_env: CHATJIMMY_API_KEY
+    model_env: CHATJIMMY_MODEL
+    capabilities: [chat, streaming, fast]
+  openai:
+    origin: customer
+    label: OpenAI
+    kind: openai
+    api_key_env: OPENAI_API_KEY
+    capabilities: [chat, streaming, tool_use, images, embeddings, image_generation]
+    models: {default: gpt-5.2, fast: gpt-5.2-mini}
+  xai:
+    origin: customer
+    label: xAI
+    kind: openai_compat        # OpenAI-compatible chat completions, Bearer XAI_API_KEY
+    base_url_env: XAI_BASE_URL
+    base_url_default: https://api.x.ai/v1
+    api_key_env: XAI_API_KEY
+    model_env: XAI_MODEL
+    # tool_use is declared but NOT granted: no signed qualification record
+    # ships for any Grok model, so Grok is chat-only (hyperclaw/xai.py).
+    capabilities: [chat, streaming, tool_use]
+    models: {default: grok-4.7, fast: grok-4.20-0309-non-reasoning}
+  openai_default:
+    origin: customer
+    label: OpenAI-compatible
+    kind: openai_compat
+    api_key_env: OPENAI_API_KEY
+    base_url_env: OPENAI_BASE_URL
+    model_env: OPENAI_MODEL
+    capabilities: [chat, streaming]
+
+slots:
+  primary:    [hyperspeed, openai_default, anthropic, openai, xai]
+  tools:      [anthropic, openai, hyperspeed]
+  vision:     [anthropic, hyperspeed]
+  fast:       [chatjimmy, anthropic:fast, hyperspeed]
+  embeddings: [openai, hyperspeed]
+  images:     [openai]

hyperclaw/deployment.py

@@ -0,0 +1,39 @@
+"""Install mode.
+
+- ``standard``: the customer's own install. HyperSpeed V2 is the default;
+  the customer may add their own providers.
+- ``hyper``: a Hyper-deployed install (client and team installs). It runs only the models
+  on its allowed list, which Hyper sets in the managed config
+  (hyperclaw.managed_config; default: HyperSpeed V2 only). Providers cannot
+  be added through the app; keys for providers not on the list are ignored
+  (spec §11, 2026-10-03; model policy 2026-10-12).
+
+Set with HYPERCLAW_DEPLOYMENT=hyper (wins) or ``"deployment": "hyper"`` in
+config.json.
+"""
+from __future__ import annotations
+
+import os
+
+HYPER = "hyper"
+STANDARD = "standard"
+
+REFUSAL = ("This is a Hyper-deployed install: Hyper sets the models it can use, "
+           "and providers cannot be added here.")
+
+
+def mode() -> str:
+    env = os.environ.get("HYPERCLAW_DEPLOYMENT", "").strip().lower()
+    if env:
+        return HYPER if env == HYPER else STANDARD
+    try:
+        from hyperclaw.userconfig import load_config
+        if str(load_config().get("deployment", "")).strip().lower() == HYPER:
+            return HYPER
+    except Exception:
+        pass
+    return STANDARD
+
+
+def is_hyper() -> bool:
+    return mode() == HYPER

hyperclaw/digest/__init__.py

@@ -0,0 +1,9 @@
+"""Connected daily digest (docs/CONNECTED-DIGEST.md).
+
+Code reads the owner's own Slack mentions/DMs and GitLab MRs, to-dos and
+activity with the owner's own read-only tokens; HyperSpeed V2 only writes the
+summary. The model gets no tools and never sees a token.
+"""
+from hyperclaw.digest.errors import DigestError, Reason
+
+__all__ = ["DigestError", "Reason"]

hyperclaw/digest/cli.py

@@ -0,0 +1,117 @@
+"""`hyperclaw digest ...` commands (local terminal = the owner).
+
+Tokens are read with a masked prompt and never printed.
+"""
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+digest_app = typer.Typer(help="Connected daily digest: your Slack and GitLab, summarized by "
+                              "HyperSpeed V2 (read-only)")
+
+SOURCES = ("slack", "gitlab")
+PROMPTS = {
+    "slack": "Slack user token (xoxp-..., read scopes only; input hidden)",
+    "gitlab": "GitLab personal access token (read_api; input hidden)",
+}
+
+
+def _env() -> None:
+    from hyperclaw.userconfig import load_env_into_process
+    load_env_into_process()
+
+
+def _source(value: str, allow_all: bool = False) -> str:
+    v = (value or "").strip().lower()
+    ok = SOURCES + (("all",) if allow_all else ())
+    if v not in ok:
+        typer.echo(f"Choose one of: {', '.join(ok)}.")
+        raise typer.Exit(2)
+    return v
+
+
+@digest_app.command("connect")
+def connect_cmd(source: str = typer.Argument(..., help="slack | gitlab"),
+                gitlab_url: str = typer.Option("", "--gitlab-url",
+                                               help="Self-managed GitLab URL (default gitlab.com)")) -> None:
+    """Connect your own Slack or GitLab account with a read-only token."""
+    from hyperclaw.digest.errors import DigestError
+    from hyperclaw.digest.service import connect
+    src = _source(source)
+    token = typer.prompt(PROMPTS[src], hide_input=True).strip()
+    try:
+        info = connect(src, token, gitlab_url=gitlab_url)
+    except DigestError as e:
+        typer.echo(f"Not connected: {e.text}. Nothing was saved.")
+        raise typer.Exit(1)
+    finally:
+        token = ""
+    who = info.get("account", "")
+    where = info.get("workspace") or info.get("url") or ""
+    typer.echo(f"Connected {src} as {who}" + (f" ({where})" if where else "") +
+               f". Read-only scopes: {', '.join(info.get('scopes') or [])}. "
+               f"Token stored in the {info['store']}.")
+
+
+@digest_app.command("disconnect")
+def disconnect_cmd(source: str = typer.Argument(..., help="slack | gitlab | all")) -> None:
+    """Remove a stored token."""
+    from hyperclaw.digest.service import disconnect
+    src = _source(source, allow_all=True)
+    for s in (SOURCES if src == "all" else (src,)):
+        typer.echo(f"{s}: " + ("disconnected." if disconnect(s) else "was not connected."))
+
+
+@digest_app.command("now")
+def now_cmd() -> None:
+    """Build the digest once now and show it (also saved as the latest)."""
+    _env()
+    from hyperclaw.digest.service import run_digest
+    out = run_digest()
+    typer.echo(out.text)
+    if not out.ok:
+        raise typer.Exit(1)
+
+
+@digest_app.command("status")
+def status_cmd() -> None:
+    """Connections, schedule and last run. Never shows a token."""
+    _env()
+    from hyperclaw.digest.service import ready, status
+    st = status()
+    conns = st["connections"]
+    for s in SOURCES:
+        c = conns.get(s)
+        if c:
+            where = c.get("workspace") or c.get("url") or ""
+            typer.echo(f"{s}: connected as {c.get('account', '')}" + (f" ({where})" if where else "")
+                       + f"; scopes {', '.join(c.get('scopes') or [])}; stored in {c.get('store', '')}"
+                       + (f"; token expires {c['expires_at']}" if c.get("expires_at") else ""))
+        else:
+            typer.echo(f"{s}: not connected")
+    runnable, why = ready()
+    gate = ("on" if st["unattended"] else "off (needs HYPERCLAW_UNATTENDED=1)")
+    typer.echo(f"Schedule: job connected_digest at {st['time']} daily; unattended mode {gate}; "
+               f"opted in: {'yes' if st['opted_in'] else 'no (hyperclaw digest schedule on)'}"
+               + ("" if runnable else f"; cannot run: {why}"))
+    last = st["last_result"]
+    if st["last_run"]:
+        typer.echo(f"Last run: {st['last_run']} — " + ("ok" if last.get("ok") else "failed"))
+        typer.echo(f"Latest digest: {st['latest_path']}")
+    else:
+        typer.echo("Last run: never")
+
+
+@digest_app.command("schedule")
+def schedule_cmd(value: str = typer.Argument(..., help="on | off")) -> None:
+    """Opt the named job connected_digest in or out (runs only in unattended mode)."""
+    from hyperclaw.digest import state
+    v = value.strip().lower()
+    if v not in ("on", "off"):
+        typer.echo("Use: hyperclaw digest schedule on|off")
+        raise typer.Exit(2)
+    state.set_scheduled(v == "on")
+    typer.echo(f"connected_digest scheduling is {v}. It runs only when HYPERCLAW_UNATTENDED=1; "
+               "restart the HyperClaw server to apply.")

hyperclaw/digest/errors.py

@@ -0,0 +1,100 @@
+"""Named, fixed failure reasons.
+
+Every failure the digest can report is one of these. Notices and the
+"Sources" line use the fixed text only, never exception text, so internal
+error details (URLs, response bodies, tokens) cannot reach a chat.
+"""
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Reason(str, Enum):
+    SLACK_NOT_CONNECTED = "slack_not_connected"
+    SLACK_TOKEN_EXPIRED = "slack_token_expired"
+    SLACK_NOT_USER_TOKEN = "slack_not_user_token"
+    SLACK_WRITE_SCOPE = "slack_write_scope"
+    SLACK_MISSING_SCOPE = "slack_missing_scope"
+    SLACK_RATE_LIMITED = "slack_rate_limited"
+    SLACK_UNREACHABLE = "slack_unreachable"
+    GITLAB_NOT_CONNECTED = "gitlab_not_connected"
+    GITLAB_TOKEN_EXPIRED = "gitlab_token_expired"
+    GITLAB_WRITE_SCOPE = "gitlab_write_scope"
+    GITLAB_MISSING_SCOPE = "gitlab_missing_scope"
+    GITLAB_RATE_LIMITED = "gitlab_rate_limited"
+    GITLAB_UNREACHABLE = "gitlab_unreachable"
+    GITLAB_UNVERIFIED = "gitlab_unverified"
+    TOKEN_FORMAT = "token_format"
+    INSECURE_URL = "insecure_url"
+    TOKEN_FILE_OPEN = "token_file_open"
+    TOKEN_STORE = "token_store"
+    NO_SOURCES = "no_sources"
+    ALL_SOURCES_FAILED = "all_sources_failed"
+    V2_NOT_CONFIGURED = "v2_not_configured"
+    V2_THIRD_PARTY = "v2_third_party"
+    V2_FAILED = "v2_failed"
+    COST_CAP = "cost_cap"
+    NOT_OWNER = "not_owner"
+
+
+TEXT = {
+    Reason.SLACK_NOT_CONNECTED: "Slack isn't connected",
+    Reason.SLACK_TOKEN_EXPIRED: "Slack token expired or was revoked",
+    Reason.SLACK_NOT_USER_TOKEN: "that is not a Slack user token (xoxp-); the digest reads only your own account",
+    Reason.SLACK_WRITE_SCOPE: "the Slack token has write or admin scopes; the digest accepts read-only tokens only",
+    Reason.SLACK_MISSING_SCOPE: "the Slack token is missing a read scope the digest needs",
+    Reason.SLACK_RATE_LIMITED: "Slack rate limit reached",
+    Reason.SLACK_UNREACHABLE: "Slack couldn't be reached",
+    Reason.GITLAB_NOT_CONNECTED: "GitLab isn't connected",
+    Reason.GITLAB_TOKEN_EXPIRED: "GitLab token expired or was revoked",
+    Reason.GITLAB_WRITE_SCOPE: "the GitLab token has write scopes (api, write_repository, ...); the digest accepts read_api tokens only",
+    Reason.GITLAB_MISSING_SCOPE: "the GitLab token doesn't have the read_api scope",
+    Reason.GITLAB_RATE_LIMITED: "GitLab rate limit reached",
+    Reason.GITLAB_UNREACHABLE: "GitLab couldn't be reached",
+    Reason.GITLAB_UNVERIFIED: "GitLab couldn't confirm the token's scopes (a personal access token is required)",
+    Reason.INSECURE_URL: "the API address must use https:// (tokens are never sent unencrypted)",
+    Reason.TOKEN_FORMAT: "that doesn't look like a token (unexpected characters)",
+    Reason.TOKEN_FILE_OPEN: "the digest token file permissions are too open (must be owner-only, 0600)",
+    Reason.TOKEN_STORE: "the stored token couldn't be read or saved",
+    Reason.NO_SOURCES: "no source is connected",
+    Reason.ALL_SOURCES_FAILED: "no source could be read",
+    Reason.V2_NOT_CONFIGURED: "HyperSpeed V2 isn't configured (the digest is written only by Hyper's own model)",
+    Reason.V2_THIRD_PARTY: "the digest model must be HyperSpeed V2, and this install points it at a third-party service",
+    Reason.V2_FAILED: "HyperSpeed V2 didn't answer",
+    Reason.COST_CAP: "today's model spending cap was reached",
+    Reason.NOT_OWNER: "the digest is available to the owner only",
+}
+
+# What the owner can do about it (appended to notices).
+FIX = {
+    Reason.SLACK_NOT_CONNECTED: "Connect it with `hyperclaw digest connect slack`.",
+    Reason.SLACK_TOKEN_EXPIRED: "Reconnect with `hyperclaw digest connect slack`.",
+    Reason.SLACK_MISSING_SCOPE: "Add the scope to your Slack app's user token and reconnect.",
+    Reason.SLACK_WRITE_SCOPE: "Create a user token with read scopes only and reconnect.",
+    Reason.GITLAB_NOT_CONNECTED: "Connect it with `hyperclaw digest connect gitlab`.",
+    Reason.GITLAB_TOKEN_EXPIRED: "Create a new read_api token and run `hyperclaw digest connect gitlab`.",
+    Reason.GITLAB_WRITE_SCOPE: "Create a token with read_api only and reconnect.",
+    Reason.GITLAB_MISSING_SCOPE: "Create a token with read_api and reconnect.",
+    Reason.TOKEN_FILE_OPEN: "Run `chmod 600` on the digest token file, or reconnect.",
+    Reason.NO_SOURCES: "Connect one with `hyperclaw digest connect slack` or `... gitlab`.",
+    Reason.V2_NOT_CONFIGURED: "Add your Hyper access key with `hyperclaw provider hyper-key`.",
+    Reason.V2_FAILED: "It will try again at the next scheduled time, or run `hyperclaw digest now`.",
+    Reason.COST_CAP: "Raise the cap with `hyperclaw cost raise --daily <USD>` or wait for tomorrow.",
+}
+
+
+class DigestError(Exception):
+    """A named digest failure. str() is the fixed text, never a detail."""
+
+    def __init__(self, reason: Reason, detail: str = ""):
+        self.reason = Reason(reason)
+        self.detail = detail          # for logs only; never sent to a chat
+        super().__init__(TEXT[self.reason])
+
+    @property
+    def text(self) -> str:
+        return TEXT[self.reason]
+
+    @property
+    def fix(self) -> str:
+        return FIX.get(self.reason, "")

hyperclaw/digest/gitlab.py

@@ -0,0 +1,187 @@
+"""GitLab collector: the owner's MRs, to-dos and own activity, read-only.
+
+Calls (GET, PRIVATE-TOKEN header): /personal_access_tokens/self, /user,
+/merge_requests (assigned / reviewing / authored), /todos, /events,
+/projects/:id (names only). See docs/CONNECTED-DIGEST.md §1.
+"""
+from __future__ import annotations
+
+from datetime import date, datetime, timedelta
+from typing import Optional
+
+from hyperclaw.digest.errors import DigestError, Reason
+from hyperclaw.digest.http import ReadOnlyHttp, SourceResult, clip, parse_time
+from hyperclaw.digest.redact import redact
+from hyperclaw.taint import mark
+
+DEFAULT_URL = "https://gitlab.com"
+READ_SCOPES = frozenset({"read_api", "read_user", "read_repository", "read_registry"})
+MAX_MRS = 30
+MAX_TODOS = 30
+MAX_EVENTS = 50
+MAX_PROJECT_LOOKUPS = 10
+MAX_PAGES = 10
+TEXT_CHARS = 400
+
+
+class GitLabCollector:
+    source = "gitlab"
+
+    def __init__(self, token: str, *, url: str = "", client=None, sleep=None):
+        self.url = (url or DEFAULT_URL).rstrip("/")
+        kw = {"client": client}
+        if sleep is not None:
+            kw["sleep"] = sleep
+        self.http = ReadOnlyHttp(self.url + "/api/v4", {"PRIVATE-TOKEN": token},
+                                 rate_limited=Reason.GITLAB_RATE_LIMITED,
+                                 unreachable=Reason.GITLAB_UNREACHABLE, **kw)
+        self.info: dict = {}
+        self._projects: dict = {}
+
+    def _get(self, path: str, params: Optional[dict] = None):
+        resp = self.http.get(path, params)
+        if resp.status_code == 401:
+            raise DigestError(Reason.GITLAB_TOKEN_EXPIRED, f"{path}: 401")
+        if resp.status_code == 403:
+            raise DigestError(Reason.GITLAB_MISSING_SCOPE, f"{path}: 403")
+        if resp.status_code >= 400:
+            raise DigestError(Reason.GITLAB_UNREACHABLE, f"{path}: HTTP {resp.status_code}")
+        try:
+            return resp.json(), resp
+        except ValueError:
+            raise DigestError(Reason.GITLAB_UNREACHABLE, f"{path}: not JSON")
+
+    def _pages(self, path: str, params: dict, cap: int) -> list:
+        out, page = [], 1
+        for _ in range(MAX_PAGES):
+            data, resp = self._get(path, {**params, "per_page": 100, "page": page})
+            if not isinstance(data, list):
+                break
+            out.extend(data)
+            nxt = (resp.headers.get("X-Next-Page") or "").strip()
+            if not nxt or len(out) >= cap:
+                break
+            page = int(nxt)
+        return out
+
+    def verify(self, today: Optional[date] = None) -> dict:
+        """Token scopes must be read-only and include read_api."""
+        resp = self.http.get("personal_access_tokens/self")
+        if resp.status_code == 401:
+            raise DigestError(Reason.GITLAB_TOKEN_EXPIRED, "self: 401")
+        if resp.status_code in (403, 404):
+            raise DigestError(Reason.GITLAB_UNVERIFIED, f"self: {resp.status_code}")
+        if resp.status_code >= 400:
+            raise DigestError(Reason.GITLAB_UNREACHABLE, f"self: {resp.status_code}")
+        try:
+            tok = resp.json()
+        except ValueError:
+            raise DigestError(Reason.GITLAB_UNREACHABLE, "self: not JSON")
+        scopes = sorted(str(s) for s in (tok.get("scopes") or []))
+        bad = sorted(set(scopes) - READ_SCOPES)
+        if bad:
+            raise DigestError(Reason.GITLAB_WRITE_SCOPE, ",".join(bad))
+        if "read_api" not in scopes:
+            raise DigestError(Reason.GITLAB_MISSING_SCOPE, "read_api")
+        if tok.get("revoked") or tok.get("active") is False:
+            raise DigestError(Reason.GITLAB_TOKEN_EXPIRED, "inactive")
+        exp = tok.get("expires_at")
+        if exp:
+            try:
+                if date.fromisoformat(str(exp)[:10]) < (today or date.today()):
+                    raise DigestError(Reason.GITLAB_TOKEN_EXPIRED, "past expires_at")
+            except ValueError:
+                pass
+        user, _ = self._get("user")
+        self.info = {"user_id": user.get("id"), "account": str(user.get("username") or ""),
+                     "name": str(user.get("name") or ""), "scopes": scopes, "url": self.url,
+                     "expires_at": str(exp or "")}
+        return self.info
+
+    def collect(self, since: datetime) -> SourceResult:
+        info = self.info or self.verify()
+        res = SourceResult(self.source, account=f"{info['account']} ({self.url})")
+        lists = (
+            ("mr_assigned", {"scope": "assigned_to_me", "state": "opened"}),
+            ("mr_reviewing", {"scope": "all", "reviewer_username": info["account"],
+                              "state": "opened"}),
+            ("mr_authored", {"scope": "created_by_me", "state": "opened"}),
+        )
+        for kind, params in lists:
+            mrs = self._pages("merge_requests", params, MAX_MRS)
+            if len(mrs) > MAX_MRS:
+                res.notes.append(f"{len(mrs) - MAX_MRS}+ more {kind.replace('_', ' ')} MRs not shown.")
+            for mr in mrs[:MAX_MRS]:
+                updated = parse_time(mr.get("updated_at"))
+                res.items.append({
+                    "kind": kind,
+                    "ref": ((mr.get("references") or {}).get("full") or f"!{mr.get('iid', '')}"),
+                    "title": redact(clip(mr.get("title", ""), 200)),
+                    "author": ((mr.get("author") or {}).get("username") or ""),
+                    "draft": bool(mr.get("draft") or mr.get("work_in_progress")),
+                    "updated": updated.isoformat(timespec="minutes") if updated else "",
+                    "changed_since_last_digest": bool(updated and updated >= since),
+                    "link": mr.get("web_url", ""),
+                })
+        todos = self._pages("todos", {"state": "pending"}, MAX_TODOS * 3)
+        older = 0
+        new = []
+        for t in todos:
+            created = parse_time(t.get("created_at"))
+            if created and created >= since:
+                new.append((created, t))
+            else:
+                older += 1
+        for created, t in new[:MAX_TODOS]:
+            target = t.get("target") or {}
+            res.items.append({
+                "kind": "todo", "action": t.get("action_name", ""),
+                "target_type": t.get("target_type", ""),
+                "title": redact(clip(target.get("title", ""), 200)),
+                "from": ((t.get("author") or {}).get("username") or ""),
+                "when": created.isoformat(timespec="minutes"),
+                "text": redact(clip(t.get("body", ""), TEXT_CHARS)),
+                "link": t.get("target_url", ""),
+            })
+        if len(new) > MAX_TODOS:
+            res.notes.append(f"{len(new) - MAX_TODOS} more new to-dos not shown.")
+        if older:
+            res.notes.append(f"{older} older pending to-dos (from before this digest's window).")
+        after = (since - timedelta(days=1)).date().isoformat()
+        events = [e for e in self._pages("events", {"after": after}, MAX_EVENTS * 2)
+                  if (parse_time(e.get("created_at")) or since) >= since]
+        if len(events) > MAX_EVENTS:
+            res.notes.append(f"{len(events) - MAX_EVENTS} more activity events not shown.")
+        for e in events[:MAX_EVENTS]:
+            push = e.get("push_data") or {}
+            note = e.get("note") or {}
+            res.items.append({
+                "kind": "activity", "action": e.get("action_name", ""),
+                "target_type": e.get("target_type") or ("push" if push else ""),
+                "title": redact(clip(e.get("target_title") or push.get("commit_title") or "", 200)),
+                "ref": push.get("ref", ""),
+                "commits": push.get("commit_count", 0) if push else 0,
+                "comment": redact(clip(note.get("body", ""), TEXT_CHARS)) if note else "",
+                "project": self._project_name(e.get("project_id")),
+                "when": (parse_time(e.get("created_at")) or since).isoformat(timespec="minutes"),
+            })
+        res.items = mark(res.items, "gitlab", "gitlab")   # connector content (hyperclaw.taint)
+        return res
+
+    def _project_name(self, pid) -> str:
+        if not pid:
+            return ""
+        if pid not in self._projects:
+            name = str(pid)
+            if len(self._projects) < MAX_PROJECT_LOOKUPS:
+                try:
+                    data, _ = self._get(f"projects/{int(pid)}")
+                    name = str(data.get("path_with_namespace") or pid)
+                except DigestError as e:
+                    if e.reason in (Reason.GITLAB_TOKEN_EXPIRED, Reason.GITLAB_RATE_LIMITED):
+                        raise
+            self._projects[pid] = name
+        return self._projects[pid]
+
+    def close(self) -> None:
+        self.http.close()