kepil 0.2.0__py3-none-any.whl

kepil/__init__.py

@@ -0,0 +1,3 @@
+"""Kepil — оператор ИИ-агентов."""
+
+__version__ = "0.1.0"

kepil/admin/__init__.py

@@ -0,0 +1,5 @@
+"""Панель оператора: заказы, профессии, агенты, журнал."""
+
+from .app import serve
+
+__all__ = ["serve"]

kepil/admin/__main__.py

@@ -0,0 +1,7 @@
+"""python -m kepil.admin [порт]"""
+
+import sys
+
+from .app import serve
+
+serve(int(sys.argv[1]) if len(sys.argv) > 1 else 7317)

kepil/admin/app.py

@@ -0,0 +1,492 @@
+"""HTTP-панель оператора.
+
+Стандартная библиотека, серверный рендеринг, обычные формы. Ни одного внешнего
+пакета: ядро должно ставиться в закрытом контуре и проходить требование о доле
+локализации (см. NOTICE.md).
+
+Запуск:
+    python -m kepil.admin            # http://localhost:7317
+    python -m kepil.admin 8080
+"""
+
+from __future__ import annotations
+
+import sys
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any, Callable
+
+from .. import compliance, meter, notify
+from ..journal import Journal, anchor, anchors
+from ..orders import service as orders
+from ..professions import definition as professions
+from ..registry import store as agents
+from ..storage import data_dir
+from . import views
+
+Params = dict[str, str]
+Handler = Callable[["Request"], "Response"]
+
+
+class Response:
+    def __init__(self, body: str = "", status: int = 200, redirect: str | None = None,
+                 content_type: str = "text/html; charset=utf-8",
+                 raw: bytes | None = None, filename: str | None = None) -> None:
+        self.body, self.status, self.redirect = body, status, redirect
+        self.content_type, self.raw, self.filename = content_type, raw, filename
+
+
+class Request:
+    def __init__(self, path: str, params: Params, query: Params) -> None:
+        self.path, self.params, self.query = path, params, query
+
+    def form(self, name: str, default: str = "") -> str:
+        return self.params.get(name, default).strip()
+
+    def lines(self, name: str) -> list[str]:
+        return [x.strip() for x in self.params.get(name, "").splitlines() if x.strip()]
+
+    def pairs(self, name: str) -> dict[str, str]:
+        out: dict[str, str] = {}
+        for line in self.lines(name):
+            key, _, value = line.partition("=")
+            if key.strip():
+                out[key.strip()] = value.strip()
+        return out
+
+
+# --- страницы ---------------------------------------------------------------
+
+def _counts() -> dict[str, int]:
+    awaiting = sum(1 for o in orders.list_orders() if o.status == "awaiting")
+    return {"orders": awaiting} if awaiting else {}
+
+
+def page(title: str, active: str, body: str, message=None) -> Response:
+    return Response(views.layout(title, active, body, _counts(), message))
+
+
+def overview(_: Request) -> Response:
+    return page("Обзор", "overview", views.overview(
+        orders.list_orders(), professions.load_all(), agents.all_passports(),
+        orders.verify_journal(), agents.review_due()))
+
+
+def orders_list(_: Request) -> Response:
+    return page("Заказы", "orders",
+                views.orders_page(orders.list_orders(), professions.load_all()))
+
+
+def order_create(request: Request) -> Response:
+    client = {"name": request.form("client_name"),
+              "bin": request.form("client_bin") or "000000000000"}
+    days = int(request.form("days") or 7)
+    order = orders.create(request.form("profession"), client, days=days)
+    return Response(redirect=f"/orders/{order.id}")
+
+
+def order_view(request: Request) -> Response:
+    order = orders.get(request.query["id"])
+    records = [r for r in Journal(orders.journal_path()) if r.get("order_id") == order.id]
+    return page(f"Заказ {order.id}", "orders",
+                views.order_page(order, order.definition(),
+                                 views.journal_table(records)))
+
+
+def order_step(request: Request) -> Response:
+    orders.run_next(orders.get(request.query["id"]))
+    return Response(redirect=f"/orders/{request.query['id']}")
+
+
+def order_confirm(request: Request) -> Response:
+    order = orders.get(request.query["id"])
+    orders.confirm(order, request.form("approve") == "1", request.form("note"))
+    return Response(redirect=f"/orders/{order.id}")
+
+
+def order_stop(request: Request) -> Response:
+    orders.stop(orders.get(request.query["id"]), request.form("reason"))
+    return Response(redirect=f"/orders/{request.query['id']}")
+
+
+def order_resume(request: Request) -> Response:
+    orders.resume(orders.get(request.query["id"]))
+    return Response(redirect=f"/orders/{request.query['id']}")
+
+
+def order_rollback(request: Request) -> Response:
+    order = orders.get(request.query["id"])
+    done, message = orders.rollback(order, request.form("step"))
+    order = orders.get(order.id)
+    records = [r for r in Journal(orders.journal_path()) if r.get("order_id") == order.id]
+    body = views.order_page(order, order.definition(), views.journal_table(records),
+                            message if done else "")
+    return page(f"Заказ {order.id}", "orders", body,
+                None if done else ("err", message))
+
+
+def order_reset(request: Request) -> Response:
+    order = orders.get(request.query["id"])
+    order.cursor, order.results, order.pending, order.status = 0, [], None, "new"
+    order.mandate["spent"] = {}
+    order.save()
+    return Response(redirect=f"/orders/{order.id}")
+
+
+def professions_list(_: Request) -> Response:
+    return page("Профессии", "professions",
+                views.professions_page(professions.load_all()))
+
+
+def profession_view(request: Request) -> Response:
+    definition = professions.get(request.query["id"])
+    return page(definition.name, "professions", views.profession_form(definition))
+
+
+def profession_save(request: Request) -> Response:
+    current = professions.get(request.query["id"])
+    try:
+        steps = [professions.Step.parse(line, i)
+                 for i, line in enumerate(request.lines("steps"))]
+    except ValueError as exc:
+        return page(current.name, "professions",
+                    views.profession_form(current), ("err", str(exc)))
+
+    limits: dict[str, float] = {}
+    for key, value in request.pairs("limits").items():
+        try:
+            limits[key] = float(value.replace(",", "."))
+        except ValueError:
+            return page(current.name, "professions", views.profession_form(current),
+                        ("err", f"лимит «{key}»: нужно число"))
+
+    updated = professions.ProfessionDefinition(
+        id=current.id,
+        name=request.form("name") or current.name,
+        summary=request.form("summary"),
+        purpose=request.form("purpose"),
+        does_not=request.lines("does_not"),
+        intake=request.lines("intake"),
+        steps=steps,
+        irreversible=request.lines("irreversible"),
+        rollback=request.pairs("rollback"),
+        limits=limits,
+        allowed_systems=request.lines("allowed_systems"),
+        forbidden_actions=request.lines("forbidden_actions"),
+        risk_class=request.form("risk_class") or current.risk_class,
+        risk_rationale=request.form("risk_rationale"),
+        deliverable=request.form("deliverable"),
+        human_baseline_minutes=float(request.form("human_baseline_minutes") or 0),
+    )
+    problems = updated.validate()
+    if problems:
+        return page(updated.name, "professions",
+                    views.profession_form(updated, problems))
+    professions.save(updated)
+    return Response(redirect="/professions")
+
+
+def profession_new(request: Request) -> Response:
+    new_id, name = request.form("id"), request.form("name")
+    blank = professions.ProfessionDefinition(
+        id=new_id, name=name or new_id, summary="",
+        purpose="Опишите, что делает агент этой профессии",
+        does_not=["опишите границы: чего агент не делает никогда"],
+        intake=["что нужно получить от клиента до старта"],
+        steps=[professions.Step.parse("read:source | Первый шаг", 0)],
+    )
+    problems = blank.validate()
+    if problems:
+        return page("Профессии", "professions",
+                    views.professions_page(professions.load_all()),
+                    ("err", "; ".join(problems)))
+    professions.save(blank)
+    return Response(redirect=f"/professions/{new_id}")
+
+
+def profession_duplicate(request: Request) -> Response:
+    source = request.query["id"]
+    existing = professions.load_all()
+    new_id = f"{source}_copy"
+    index = 2
+    while new_id in existing:
+        new_id, index = f"{source}_copy{index}", index + 1
+    professions.duplicate(source, new_id, f"{existing[source].name} (копия)")
+    return Response(redirect=f"/professions/{new_id}")
+
+
+def profession_delete(request: Request) -> Response:
+    try:
+        professions.delete(request.query["id"])
+    except KeyError as exc:
+        return page("Профессии", "professions",
+                    views.professions_page(professions.load_all()), ("err", str(exc)))
+    return Response(redirect="/professions")
+
+
+def agents_list(_: Request) -> Response:
+    return page("Агенты", "agents", views.agents_page(agents.all_passports()))
+
+
+def agent_status(request: Request) -> Response:
+    agents.set_status(request.query["id"], request.form("status"))
+    return Response(redirect="/agents")
+
+
+def agent_reissue(request: Request) -> Response:
+    agents.reissue(request.query["id"])
+    return Response(redirect="/agents")
+
+
+def journal_view(request: Request) -> Response:
+    journal = Journal(orders.journal_path())
+    records = list(journal)
+    return page("Журнал", "journal",
+                views.journal_page(records[-40:], orders.verify_journal(),
+                                   len(records), views.anchors_block(anchors(journal))))
+
+
+def journal_anchor(request: Request) -> Response:
+    try:
+        anchor(Journal(orders.journal_path()))
+    except ValueError as exc:
+        return page("Журнал", "journal",
+                    views.journal_page([], orders.verify_journal(), 0), ("err", str(exc)))
+    return Response(redirect="/journal")
+
+
+# --- счётчик и комплаенс ----------------------------------------------------
+
+def meter_view(_: Request) -> Response:
+    return page("Счётчик", "meter", views.meter_page(
+        meter.totals(), meter.by_profession(), meter.by_agent(),
+        professions.load_all()))
+
+
+def _pack_id(request: "Request") -> str | None:
+    """Выбранный пакет документации; по умолчанию — встроенный универсальный."""
+    return request.query.get("pack") or request.params.get("pack") or None
+
+
+def _compliance_set(agent_id: str, pack_id: str | None = None):
+    passport = agents.get(agent_id)
+    if passport is None:
+        raise KeyError(f"паспорт '{agent_id}' не найден")
+    profession_id = agent_id.split(".")[1]
+    definition = professions.get(profession_id)
+    counters = meter.by_agent().get(agent_id, meter.Counters())
+    stats = {"actions": counters.actions, "denied": counters.denied,
+             "confirmations": counters.confirmations, "returns": counters.returns,
+             "journal_ok": orders.verify_journal()[0]}
+    return definition, compliance.build(definition, passport, agents.settings(),
+                                        stats, pack_id)
+
+
+def compliance_index(request: Request) -> Response:
+    pack_id = _pack_id(request)
+    items = []
+    for passport in agents.all_passports():
+        try:
+            definition, documents = _compliance_set(passport["agent_id"], pack_id)
+        except KeyError:
+            continue
+        items.append({
+            "agent_id": passport["agent_id"],
+            "profession_name": definition.name,
+            "risk_class": passport["risk_class"],
+            "required": sum(1 for d in documents if d.required),
+            "total": len(documents),
+            "todo": compliance.missing_marks(documents),
+        })
+    return page("Комплаенс", "compliance",
+                views.compliance_index(items, compliance.available_packs(), pack_id))
+
+
+def compliance_view(request: Request) -> Response:
+    pack_id = _pack_id(request)
+    _, documents = _compliance_set(request.query["id"], pack_id)
+    selected = request.query.get("doc") or documents[0].key
+    body = next((d.body for d in documents if d.key == selected), documents[0].body)
+    return page("Комплаенс", "compliance",
+                views.compliance_set(request.query["id"], documents, selected, body))
+
+
+def compliance_download(request: Request) -> Response:
+    import io
+    import zipfile
+
+    agent_id = request.query["id"]
+    _, documents = _compliance_set(agent_id, _pack_id(request))
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as archive:
+        for document in documents:
+            archive.writestr(document.filename, document.body)
+    return Response(raw=buffer.getvalue(), content_type="application/zip",
+                    filename=f"{agent_id}-compliance.zip")
+
+
+def journal_export(_: Request) -> Response:
+    path = orders.journal_path()
+    body = path.read_bytes() if path.exists() else b""
+    return Response(raw=body, content_type="application/x-ndjson",
+                    filename="journal.jsonl")
+
+
+def settings_view(_: Request) -> Response:
+    return page("Настройки", "settings",
+                views.settings_page(agents.settings(), data_dir().resolve()))
+
+
+def settings_save(request: Request) -> Response:
+    agents.save_settings({
+        "name": request.form("name"),
+        "bin": request.form("bin"),
+        "operator": request.form("operator"),
+        "telegram_token": request.form("telegram_token"),
+        "telegram_chat_id": request.form("telegram_chat_id"),
+    })
+    return Response(redirect="/settings")
+
+
+def settings_test(_: Request) -> Response:
+    """Проверка канала: бот должен прислать сообщение в указанный чат."""
+    client = notify.bot()
+    if client is None:
+        message = ("err", "заполните токен и чат, затем сохраните настройки")
+    else:
+        try:
+            message = ("ok", f"связь есть: сообщение отправлено ботом @{client.check()}")
+        except notify.TelegramError as exc:
+            message = ("err", f"не получилось: {exc}")
+    return page("Настройки", "settings",
+                views.settings_page(agents.settings(), data_dir().resolve()), message)
+
+
+ROUTES: list[tuple[str, str, Handler]] = [
+    ("GET", "/", overview),
+    ("GET", "/orders", orders_list),
+    ("POST", "/orders/new", order_create),
+    ("GET", "/orders/<id>", order_view),
+    ("POST", "/orders/<id>/step", order_step),
+    ("POST", "/orders/<id>/confirm", order_confirm),
+    ("POST", "/orders/<id>/reset", order_reset),
+    ("POST", "/orders/<id>/stop", order_stop),
+    ("POST", "/orders/<id>/resume", order_resume),
+    ("POST", "/orders/<id>/rollback", order_rollback),
+    ("GET", "/professions", professions_list),
+    ("POST", "/professions/new", profession_new),
+    ("GET", "/professions/<id>", profession_view),
+    ("POST", "/professions/<id>", profession_save),
+    ("POST", "/professions/<id>/duplicate", profession_duplicate),
+    ("POST", "/professions/<id>/delete", profession_delete),
+    ("GET", "/agents", agents_list),
+    ("POST", "/agents/<id>/status", agent_status),
+    ("POST", "/agents/<id>/reissue", agent_reissue),
+    ("GET", "/meter", meter_view),
+    ("GET", "/compliance", compliance_index),
+    ("GET", "/compliance/<id>", compliance_view),
+    ("GET", "/compliance/<id>/download", compliance_download),
+    ("GET", "/journal", journal_view),
+    ("POST", "/journal/anchor", journal_anchor),
+    ("POST", "/journal/verify", journal_view),
+    ("GET", "/journal/export", journal_export),
+    ("GET", "/settings", settings_view),
+    ("POST", "/settings", settings_save),
+    ("POST", "/settings/test", settings_test),
+]
+
+
+def resolve(method: str, path: str) -> tuple[Handler, Params] | None:
+    """Сопоставляет путь с маршрутом; <id> — единственный вид параметра."""
+    parts = [p for p in path.strip("/").split("/") if p]
+    for route_method, pattern, handler in ROUTES:
+        if route_method != method:
+            continue
+        expected = [p for p in pattern.strip("/").split("/") if p]
+        if len(expected) != len(parts):
+            continue
+        query: Params = {}
+        for want, got in zip(expected, parts):
+            if want == "<id>":
+                query["id"] = urllib.parse.unquote(got)
+            elif want != got:
+                break
+        else:
+            return handler, query
+    return None
+
+
+class _Handler(BaseHTTPRequestHandler):
+    server_version = "Kepil"
+
+    def log_message(self, *args: Any) -> None:
+        pass
+
+    def do_GET(self) -> None:
+        self._dispatch("GET")
+
+    def do_POST(self) -> None:
+        self._dispatch("POST")
+
+    def _dispatch(self, method: str) -> None:
+        parsed = urllib.parse.urlparse(self.path)
+        path = parsed.path
+        found = resolve(method, path)
+        if not found:
+            self._send(Response("<h1>404</h1><p>Страница не найдена. "
+                                "<a href=\"/\">На главную</a></p>", status=404))
+            return
+        handler, query = found
+        for key, value in urllib.parse.parse_qs(parsed.query).items():
+            query.setdefault(key, value[0])
+        params: Params = {}
+        if method == "POST":
+            length = int(self.headers.get("Content-Length") or 0)
+            raw = self.rfile.read(length).decode("utf-8") if length else ""
+            params = {k: v[0] for k, v in urllib.parse.parse_qs(raw).items()}
+        try:
+            response = handler(Request(path, params, query))
+        except KeyError as exc:
+            response = Response(f"<h1>Не найдено</h1><p>{exc}</p>", status=404)
+        except Exception as exc:  # ошибка панели не должна ронять сервер
+            response = Response(f"<h1>Ошибка</h1><pre>{exc!r}</pre>", status=500)
+        self._send(response)
+
+    def _send(self, response: Response) -> None:
+        if response.redirect:
+            self.send_response(303)
+            self.send_header("Location", response.redirect)
+            self.end_headers()
+            return
+        body = response.raw if response.raw is not None else response.body.encode("utf-8")
+        self.send_response(response.status)
+        self.send_header("Content-Type", response.content_type)
+        self.send_header("Content-Length", str(len(body)))
+        if response.filename:
+            self.send_header("Content-Disposition",
+                             f'attachment; filename="{response.filename}"')
+        self.end_headers()
+        self.wfile.write(body)
+
+
+def _start_telegram() -> None:
+    """Приём нажатий из Telegram живёт рядом с панелью, если канал настроен."""
+    import threading
+
+    client = notify.bot()
+    if client is None:
+        print("Telegram не настроен: подтверждения ждут в панели")
+        return
+    threading.Thread(target=notify.run, args=(client,), daemon=True).start()
+    print("Telegram подключён: подтверждения придут в телефон")
+
+
+def serve(port: int = 7317, host: str = "127.0.0.1") -> None:
+    print(f"Kepil · панель оператора: http://localhost:{port}")
+    print(f"данные: {data_dir().resolve()}")
+    _start_telegram()
+    ThreadingHTTPServer((host, port), _Handler).serve_forever()
+
+
+if __name__ == "__main__":
+    serve(int(sys.argv[1]) if len(sys.argv) > 1 else 7317)

kepil/admin/theme.py

@@ -0,0 +1,109 @@
+"""Оформление панели.
+
+Панель оператора — плотный рабочий инструмент, а не витрина: тёмный фон, чтобы
+не выжигать глаза в смену, моноширинный шрифт для всего, что сверяют глазами
+(хеши, действия, идентификаторы), и цвет только там, где он означает решение:
+разрешено, отказано, ждёт человека.
+"""
+
+CSS = """
+:root{
+  --bg:#12140F; --panel:#191C16; --panel-2:#20241D; --line:#2E332A;
+  --ink:#E9ECE3; --ink-2:#A6AE9E; --ink-3:#767E70;
+  --ok:#7FBFA6; --deny:#D98A7B; --wait:#D6AC5A; --accent:#7FBFA6;
+}
+*{box-sizing:border-box}
+html,body{height:100%}
+body{margin:0;background:var(--bg);color:var(--ink);display:flex;
+  font:14px/1.5 "Segoe UI",system-ui,sans-serif}
+a{color:var(--accent);text-decoration:none}
+a:hover{text-decoration:underline}
+.mono,code{font-family:Consolas,"Cascadia Mono",monospace}
+
+nav{width:210px;flex:none;background:var(--panel);border-right:1px solid var(--line);
+  padding:16px 0;display:flex;flex-direction:column;height:100vh;position:sticky;top:0}
+nav .brand{padding:0 18px 16px;border-bottom:1px solid var(--line);margin-bottom:10px}
+nav .brand b{font-size:18px;letter-spacing:.02em}
+nav .brand span{display:block;color:var(--ink-3);font-size:11.5px;margin-top:2px}
+nav a{display:flex;justify-content:space-between;gap:8px;padding:8px 18px;
+  color:var(--ink-2);font-size:13.5px;border-left:2px solid transparent}
+nav a:hover{color:var(--ink);text-decoration:none;background:var(--panel-2)}
+nav a.on{color:var(--ink);border-left-color:var(--accent);background:var(--panel-2)}
+nav a .count{color:var(--ink-3);font-family:Consolas,monospace;font-size:11.5px}
+nav .foot{margin-top:auto;padding:12px 18px 0;border-top:1px solid var(--line);
+  color:var(--ink-3);font-size:11.5px}
+
+main{flex:1;min-width:0;padding:22px 30px 60px;max-width:1180px}
+h1{font-size:21px;margin:0 0 4px;font-weight:600;letter-spacing:.01em}
+.lede{color:var(--ink-3);font-size:13px;margin:0 0 22px}
+h2{font-size:11px;letter-spacing:.11em;text-transform:uppercase;color:var(--ink-3);
+  margin:26px 0 11px;font-weight:600}
+h2:first-of-type{margin-top:0}
+
+.grid{display:grid;gap:14px}
+.g2{grid-template-columns:repeat(auto-fit,minmax(300px,1fr))}
+.g3{grid-template-columns:repeat(auto-fit,minmax(220px,1fr))}
+.card{background:var(--panel);border:1px solid var(--line);padding:14px 16px}
+.card h3{margin:0 0 8px;font-size:14.5px;font-weight:600}
+.card p{margin:0 0 8px;color:var(--ink-2);font-size:13px}
+.card p:last-child{margin-bottom:0}
+.tile .n{font-family:Consolas,monospace;font-size:26px;line-height:1.1}
+.tile .l{color:var(--ink-3);font-size:12px;margin-top:4px}
+
+table{width:100%;border-collapse:collapse;font-size:13px}
+th{text-align:left;font-weight:500;color:var(--ink-3);font-size:11px;
+  letter-spacing:.08em;text-transform:uppercase;padding:0 12px 8px 0;
+  border-bottom:1px solid var(--line)}
+td{padding:8px 12px 8px 0;border-bottom:1px solid var(--line);vertical-align:top}
+tr:last-child td{border-bottom:none}
+td.mono,th.mono{font-family:Consolas,monospace;font-size:12px}
+
+.pill{display:inline-block;font-size:11.5px;padding:2px 8px;border:1px solid var(--line);
+  border-radius:2px;color:var(--ink-2);white-space:nowrap}
+.pill.ok{color:var(--ok);border-color:#2C4A40}
+.pill.deny{color:var(--deny);border-color:#4A2E28}
+.pill.wait{color:var(--wait);border-color:#4A3D1E}
+
+.steps{display:flex;flex-direction:column;gap:1px;background:var(--line);
+  border:1px solid var(--line)}
+.step{display:grid;grid-template-columns:22px 1fr auto;gap:10px;
+  background:var(--panel);padding:9px 13px}
+.step.idle{background:var(--panel-2);opacity:.45}
+.step .m{font-family:Consolas,monospace}
+.step.ok .m{color:var(--ok)} .step.deny .m{color:var(--deny)} .step.wait .m{color:var(--wait)}
+.step .t{font-size:13.5px}
+.step .a{font-family:Consolas,monospace;font-size:11.5px;color:var(--ink-3);margin-top:2px}
+.step .w{font-size:12.5px;margin-top:5px;padding-left:10px;border-left:2px solid var(--line)}
+.step.deny .w{color:var(--deny)} .step.wait .w{color:var(--wait)} .step.ok .w{color:var(--ink-3)}
+.step .c{font-family:Consolas,monospace;font-size:11.5px;color:var(--ink-3);white-space:nowrap}
+
+form.inline{display:inline}
+label{display:block;color:var(--ink-3);font-size:11.5px;letter-spacing:.06em;
+  text-transform:uppercase;margin:14px 0 5px}
+label .hint{text-transform:none;letter-spacing:0;color:var(--ink-3);font-size:12px;
+  display:block;margin-top:3px;opacity:.85}
+input[type=text],input[type=number],select,textarea{width:100%;background:var(--panel-2);
+  border:1px solid var(--line);color:var(--ink);padding:8px 10px;font:inherit;font-size:13.5px}
+textarea{font-family:Consolas,monospace;font-size:12.5px;line-height:1.6;resize:vertical}
+input:focus,select:focus,textarea:focus{outline:none;border-color:var(--accent)}
+.row{display:flex;gap:10px;flex-wrap:wrap;align-items:center;margin-top:16px}
+.cols{display:grid;gap:14px;grid-template-columns:repeat(auto-fit,minmax(240px,1fr))}
+
+button{font:inherit;font-size:13.5px;padding:8px 15px;border:1px solid var(--line);
+  background:var(--panel-2);color:var(--ink);cursor:pointer}
+button:hover{border-color:var(--accent)}
+button:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+button.primary{background:var(--accent);color:#10130F;border-color:var(--accent);font-weight:600}
+button.danger{color:var(--deny)}
+button:disabled{opacity:.35;cursor:not-allowed}
+
+.msg{padding:11px 14px;border:1px solid var(--line);margin-bottom:18px;font-size:13.5px}
+.msg.ok{border-left:3px solid var(--ok)}
+.msg.err{border-left:3px solid var(--deny);color:var(--deny)}
+.meter{height:4px;background:var(--panel-2);border:1px solid var(--line);margin-top:6px}
+.meter i{display:block;height:100%;background:var(--accent)}
+dl.kv{display:grid;grid-template-columns:170px 1fr;gap:6px 14px;margin:0;font-size:13px}
+dl.kv dt{color:var(--ink-3)}
+dl.kv dd{margin:0;overflow-wrap:anywhere}
+.empty{color:var(--ink-3);font-size:13px;padding:10px 0}
+"""