devops-bot-sdk 1.6.25__tar.gz → 1.6.26__tar.gz

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.25
+Version: 1.6.26
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary
@@ -21,11 +21,13 @@ Provides-Extra: ui
 Requires-Dist: fastapi>=0.110; extra == "ui"
 Requires-Dist: uvicorn>=0.29; extra == "ui"
 Requires-Dist: psutil>=5.9; extra == "ui"
+Requires-Dist: python-multipart>=0.0.9; extra == "ui"
 Provides-Extra: all
 Requires-Dist: Pillow>=10.0; extra == "all"
 Requires-Dist: psutil>=5.9; extra == "all"
 Requires-Dist: fastapi>=0.110; extra == "all"
 Requires-Dist: uvicorn>=0.29; extra == "all"
+Requires-Dist: python-multipart>=0.0.9; extra == "all"
 
 # DevOpsBot SDK
 

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.25
+Version: 1.6.26
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary
@@ -21,11 +21,13 @@ Provides-Extra: ui
 Requires-Dist: fastapi>=0.110; extra == "ui"
 Requires-Dist: uvicorn>=0.29; extra == "ui"
 Requires-Dist: psutil>=5.9; extra == "ui"
+Requires-Dist: python-multipart>=0.0.9; extra == "ui"
 Provides-Extra: all
 Requires-Dist: Pillow>=10.0; extra == "all"
 Requires-Dist: psutil>=5.9; extra == "all"
 Requires-Dist: fastapi>=0.110; extra == "all"
 Requires-Dist: uvicorn>=0.29; extra == "all"
+Requires-Dist: python-multipart>=0.0.9; extra == "all"
 
 # DevOpsBot SDK
 

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ sdk/platform_compat.py
 sdk/py.typed
 sdk/run_auto.py
 sdk/scheduler.py
+sdk/self_report.py
 sdk/sse.py
 sdk/task_file.py
 sdk/test.py
@@ -98,6 +99,7 @@ sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
 sdk/ui/static/index.html
 sdk/ui/static/login.html
+sdk/ui/static/report.html
 sdk/ui/static/runs.html
 sdk/ui/static/schedules.html
 sdk/ui/static/setup.html
@@ -140,6 +142,7 @@ tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py
 tests/test_schedule_api.py
 tests/test_scheduler.py
+tests/test_self_report.py
 tests/test_service_token_warning.py
 tests/test_task_file_and_plan_run.py
 tests/test_task_file_format_doc.py

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/devops_bot_sdk.egg-info/requires.txt

@@ -9,6 +9,7 @@ Pillow>=10.0
 psutil>=5.9
 fastapi>=0.110
 uvicorn>=0.29
+python-multipart>=0.0.9
 
 [process]
 psutil>=5.9
@@ -20,3 +21,4 @@ Pillow>=10.0
 fastapi>=0.110
 uvicorn>=0.29
 psutil>=5.9
+python-multipart>=0.0.9

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/pyproject.toml

@@ -36,12 +36,17 @@ ui = [
                             # bootstrap installs `[ui]` only, so without it here every
                             # VPS reports "resources.available: False" and the health
                             # cron can only send status + IP.
+    "python-multipart>=0.0.9",  # POST /api/ui/reports/self — the ONE multipart route in
+                            # the panel (self-report proofs are file uploads). Starlette
+                            # raises at request time without it, so it belongs in [ui]
+                            # alongside fastapi rather than in an optional extra.
 ]
 all = [
     "Pillow>=10.0",
     "psutil>=5.9",
     "fastapi>=0.110",
     "uvicorn>=0.29",
+    "python-multipart>=0.0.9",
 ]
 
 [project.scripts]

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.25
+Version: 1.6.26
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.25"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.26"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/sdk/agents/activity.py

@@ -124,6 +124,46 @@ def _lines_block(lines: list[str]) -> str:
     return "\n".join(reversed(out))
 
 
+def mirror_to_auto_log_line(text: str, *, pointer: str = "") -> bool:
+    """Append ONE already-composed summary line to ``~/.agentos/auto.log``.
+
+    The append-with-opt-out core of :func:`mirror_to_auto_log`, split out so a
+    caller that is not an agent run can use it. `agentos-auto logs [-f]` tails
+    that file and nothing else, so anything a person should be able to watch
+    live has to land here — including a self-report submission, which has no
+    agent, no `agent_dir()` and no `describe()` verb to render.
+
+    `text` is written verbatim under the shared `  • [<stamp>] ` prefix so every
+    line in the file reads the same way. `pointer` adds the indented `↳` line
+    the agent path uses for a transcript path; pass an empty string for none.
+
+    Honours ``AGENTOS_NO_AGENT_LOG_MIRROR=1`` and never raises: a log line must
+    never break the work that produced it. Returns True when a line was written.
+    """
+    line = str(text or "").strip()
+    if not line:
+        return False
+    if os.getenv("AGENTOS_NO_AGENT_LOG_MIRROR"):
+        return False
+    try:
+        from sdk.run_auto import _LOG_FILE
+    except Exception:  # noqa: BLE001 — never break a caller over a log line
+        return False
+
+    stamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%SZ")
+    out = f"  • [{stamp}] {line}"
+    if pointer:
+        out += f"\n    ↳ {pointer}"
+    try:
+        _LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with _LOG_FILE.open("a", encoding="utf-8") as fh:
+            fh.write(out + "\n")
+        return True
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("auto.log mirror failed err=%s", exc)
+        return False
+
+
 def mirror_to_auto_log(name: str, kind: str, result: dict | None,
                        duration_s: float = 0.0, *, detail: str = "",
                        task_id: str = "") -> bool:
@@ -141,18 +181,20 @@ def mirror_to_auto_log(name: str, kind: str, result: dict | None,
     the pointer below is how you get from one to the other. Best-effort and
     silent on failure: a log line must never break a run. Set
     ``AGENTOS_NO_AGENT_LOG_MIRROR=1`` to turn it off.
+
+    The append itself lives in :func:`mirror_to_auto_log_line`; what stays here
+    is the AGENT-shaped part — the `describe()` verb, the ticket suffix and the
+    `agent_dir()` transcript pointer — none of which a non-agent caller wants.
     """
     if os.getenv("AGENTOS_NO_AGENT_LOG_MIRROR"):
         return False
     try:
         from sdk.agents.run_log import agent_dir
-        from sdk.run_auto import _LOG_FILE
     except Exception:  # noqa: BLE001 — never break a run over a log line
         return False
 
     res = result or {}
-    stamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%SZ")
-    line = f"  • [{stamp}] {describe(name, kind, res, duration_s, detail)}"
+    line = describe(name, kind, res, duration_s, detail)
     # agentd passes the ticket BOTH as `detail` ("task T1") and as `task_id`, so an
     # unconditional suffix renders "… — task T1 · task T1".
     if task_id and f"task {task_id}" not in line:
@@ -161,17 +203,8 @@ def mirror_to_auto_log(name: str, kind: str, result: dict | None,
         where = agent_dir(name)
     except Exception:  # noqa: BLE001
         where = None
-    if where:
-        line += f"\n    ↳ transcript: {where}"
-
-    try:
-        _LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
-        with _LOG_FILE.open("a", encoding="utf-8") as fh:
-            fh.write(line + "\n")
-        return True
-    except Exception as exc:  # noqa: BLE001
-        logger.debug("auto.log mirror failed agent=%s err=%s", name, exc)
-        return False
+    return mirror_to_auto_log_line(
+        line, pointer=f"transcript: {where}" if where else "")
 
 
 async def emit(name: str, kind: str, result: dict | None, duration_s: float = 0.0,

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/sdk/cli.py

@@ -58,6 +58,19 @@ Command surface:
     agentos integration rm <name>
         Remove a registered integration.
 
+    agentos report submit [--date YYYY-MM-DD] (--text "…" | --file PATH)
+                          [--project NAME] [--proof PATH|URL]… [--no-wait]
+        Report work that never reached Jira or GitHub, attach proofs (local
+        files and/or http(s) URLs), and have the submission SCORED against
+        them. Prints the submission id, the score and the verdict. The same
+        mechanism the control panel's Report work page uses — see
+        sdk/self_report.py.
+    agentos report list [--limit N]
+        Recent submissions, newest first: date, score, verdict, id.
+    agentos report show <ID>
+        One submission in full — its text, its proofs and the evaluator's
+        per-criterion reasoning.
+
     agentos agentd start [--foreground]
         Start the local agent daemon (background by default).
     agentos agentd status
@@ -123,12 +136,16 @@ def main() -> None:
         _github_command(rest)
         return
 
+    if noun == "report":
+        _report_command(rest)
+        return
+
     _print_usage()
     sys.exit(1)
 
 
 def _print_usage() -> None:
-    print("usage: agentos <configure|chat|agent|integration|default-agents|agentd|github> ...")
+    print("usage: agentos <configure|chat|agent|integration|default-agents|agentd|github|report> ...")
     print()
     print("  agentos configure [--rotate]")
     print("  agentos chat [--product-id ID] [--pv-id ID] [--no-autorun]   # requirements → ticket")
@@ -138,6 +155,7 @@ def _print_usage() -> None:
     print("  agentos default-agents list [--department-id UUID]   # read-only; agents are created in the web app")
     print("  agentos agentd <start [--foreground]|status>")
     print("  agentos github <ingest [--days N]|status>            # PR ingestion; --days N backfills N days")
+    print("  agentos report <submit|list|show ID>                 # report work Jira/GitHub never saw")
 
 
 # ── agent ────────────────────────────────────────────────────────────────
@@ -703,5 +721,214 @@ def _github_command(args: list[str]) -> None:
     sys.exit(1)
 
 
+# ── report ───────────────────────────────────────────────────────────────
+
+def _report_usage() -> None:
+    print("usage: agentos report submit [--date YYYY-MM-DD] (--text \"…\" | --file PATH)")
+    print("                            [--project NAME] [--proof PATH|URL]… [--no-wait]")
+    print("       agentos report list [--limit N]")
+    print("       agentos report show <ID>")
+    print()
+    print("  Report work that never reached Jira or GitHub, attach proofs, and have the")
+    print("  submission scored against them. It then appears in your daily and overall")
+    print("  reports and in the reporting chat.")
+    print()
+    print("  --date     the day the work happened (default: today; never the future)")
+    print("  --text     the report body; --file reads it from a file instead")
+    print("  --proof    repeatable — a local file path OR an http(s) URL")
+    print("  --no-wait  submit and exit without waiting for the verdict")
+
+
+def _report_flag(args: list[str], name: str) -> list[str]:
+    """Every ``--name VALUE`` in args, in order. Repeatable flags collect.
+
+    Same hand-rolled shape as `run_auto._flag_values` — this CLI has no
+    argparse subparsers by design (see the module docstring).
+    """
+    out: list[str] = []
+    for i, a in enumerate(args):
+        if a == name and i + 1 < len(args):
+            out.append(args[i + 1])
+        elif a.startswith(name + "="):
+            out.append(a.split("=", 1)[1])
+    return out
+
+
+def _report_command(args: list[str]) -> None:
+    """``agentos report submit|list|show`` — the CLI half of self-reporting.
+
+    Every verb resolves the backend client the same way and fails the same way
+    when the box has no ``co_`` token: the shared "not configured" message
+    ``agentos configure`` prints, and exit 1 — never a traceback.
+    """
+    from sdk.exceptions import TokenNotConfigured
+    from sdk.self_report import SelfReportError
+
+    verb = args[0] if args else None
+    rest = args[1:]
+
+    try:
+        if verb == "submit":
+            _report_submit(rest)
+            return
+        if verb == "list":
+            limits = _report_flag(rest, "--limit")
+            _report_list(int(limits[0]) if limits and limits[0].isdigit() else 25)
+            return
+        if verb == "show" and rest and not rest[0].startswith("-"):
+            _report_show(rest[0])
+            return
+    except TokenNotConfigured as exc:
+        # The same failure every other verb gives on an unconfigured machine —
+        # `sdk.config` composes a cause-specific message; we only add the prefix.
+        print(f"error: {exc}")
+        sys.exit(1)
+    except SelfReportError as exc:
+        print(f"error: {exc}")
+        sys.exit(1)
+
+    _report_usage()
+    sys.exit(1)
+
+
+def _report_submit(args: list[str]) -> None:
+    """Submit one report, then print the id, the score and the verdict."""
+    from sdk import self_report
+
+    texts = _report_flag(args, "--text")
+    files = _report_flag(args, "--file")
+    if not texts and not files:
+        # A usage line and a non-zero exit — not an empty submission.
+        print("error: say what you did — pass --text \"…\" or --file report.md")
+        _report_usage()
+        sys.exit(1)
+
+    body = texts[0] if texts else ""
+    if files:
+        src = Path(files[0]).expanduser()
+        if not src.is_file():
+            print(f"error: no such file: {src}")
+            sys.exit(1)
+        try:
+            # --file supplies the body; a --text alongside it is a header line.
+            file_body = src.read_text(encoding="utf-8", errors="replace").strip()
+        except OSError as exc:
+            print(f"error: cannot read {src}: {exc}")
+            sys.exit(1)
+        body = f"{body}\n\n{file_body}".strip() if body else file_body
+
+    dates = _report_flag(args, "--date")
+    projects = _report_flag(args, "--project")
+    proofs, rejected = self_report.collect_proofs(_report_flag(args, "--proof"))
+    for r in rejected:
+        print(f"⚠ proof skipped — {r.get('name', '')}: {r.get('reason', '')}")
+
+    result = asyncio.run(self_report.submit_and_evaluate(
+        date=dates[0] if dates else "",
+        text=body,
+        project=projects[0] if projects else "",
+        proofs=proofs,
+        rejected=rejected,
+        wait="--no-wait" not in args,
+    ))
+
+    status = str(result.get("status") or "")
+    if status == "failed":
+        print(f"error: {result.get('error') or 'the submission was not stored.'}")
+        sys.exit(1)
+
+    print(f"submission : {result.get('id') or '(no id returned)'}")
+    print(f"date       : {result.get('date', '')}"
+          + (f"   project: {result['project']}" if result.get("project") else ""))
+    print(f"proofs     : {len(result.get('proofs') or [])} accepted"
+          + (f", {len(result.get('rejected') or [])} skipped" if result.get("rejected") else ""))
+    if status == "evaluated":
+        print(f"score      : {result.get('score', 0)}/100")
+        print(f"verdict    : {result.get('verdict') or 'unknown'}")
+    elif status == "evaluation_failed":
+        print("score      : —")
+        print("verdict    : evaluation failed — the submission is stored and can be "
+              "re-evaluated")
+    else:
+        print(f"status     : {status or 'accepted'} — not evaluated yet; "
+              f"`agentos report show {result.get('id', '')}` for the verdict")
+    # Exit 0 whenever the submission was STORED. A failed evaluation is a
+    # backend-side outcome the person cannot act on, and it is recorded, not lost.
+
+
+def _report_list(limit: int) -> None:
+    """Recent submissions, newest first — date, score, verdict, id."""
+    from sdk import self_report
+
+    rows = asyncio.run(self_report.list_reports(limit))
+    if not rows:
+        print("no submissions yet — `agentos report submit --text \"…\"` records one.")
+        return
+    print(f"{'DATE':<12}{'SCORE':<8}{'VERDICT':<26}{'ID':<26}WHAT")
+    for r in rows:
+        ev = r.get("evaluation") or {}
+        score = f"{ev.get('score')}/100" if r.get("status") == "evaluated" else "—"
+        verdict = (ev.get("verdict") or r.get("status") or "")[:25]
+        what = " ".join(str(r.get("text") or "").split())[:46]
+        print(f"{str(r.get('date', '')):<12}{score:<8}{verdict:<26}"
+              f"{str(r.get('id', '')):<26}{what}")
+
+
+def _report_show(report_id: str) -> None:
+    """One submission in full — its text, its proofs, and the per-criterion reasoning."""
+    from sdk import self_report
+
+    sub = asyncio.run(self_report.show_report(report_id))
+    if not sub:
+        print(f"error: no submission {report_id} (or it is not yours).")
+        sys.exit(1)
+
+    ev = sub.get("evaluation") or {}
+    print(f"submission : {sub.get('id', report_id)}")
+    print(f"date       : {sub.get('date', '')}")
+    if sub.get("project"):
+        print(f"project    : {sub['project']}")
+    print(f"status     : {sub.get('status', '')}")
+    if sub.get("status") == "evaluated":
+        print(f"score      : {ev.get('score', 0)}/100")
+        print(f"verdict    : {ev.get('verdict', '')}")
+    print()
+    print("what I did")
+    for line in str(sub.get("text") or "").splitlines() or [""]:
+        print(f"  {line}")
+
+    proofs = sub.get("proofs") or []
+    print()
+    print(f"proofs ({len(proofs)})")
+    if not proofs:
+        print("  (none — an unproven report is recorded, never silently dropped)")
+    for p in proofs:
+        head = f"  · {p.get('name') or p.get('url') or 'proof'}"
+        judged = p.get("judgement") or "not judged"
+        print(f"{head}  [{judged}]")
+        if p.get("url"):
+            print(f"      url  : {p['url']}")
+        if p.get("size_bytes"):
+            print(f"      size : {p['size_bytes']} bytes  {p.get('content_type', '')}")
+        if p.get("reason"):
+            print(f"      why  : {p['reason']}")
+
+    findings = ev.get("findings") or []
+    print()
+    print(f"evaluator findings ({len(findings)})")
+    if ev.get("summary"):
+        print(f"  {ev['summary']}")
+    for f in findings:
+        print(f"  · [{f.get('verdict', '')}] {f.get('criterion', '')}")
+        if f.get("detail"):
+            print(f"      {f['detail']}")
+    if not findings and sub.get("status") == "evaluation_failed":
+        print("  the evaluator returned unparseable output — the raw response is retained "
+              "server-side for diagnosis, and the submission can be re-evaluated.")
+
+    for r in (sub.get("rejected") or []):
+        print(f"⚠ proof not accepted — {r.get('name', '')}: {r.get('reason', '')}")
+
+
 if __name__ == "__main__":
     main()

{devops_bot_sdk-1.6.25 → devops_bot_sdk-1.6.26}/sdk/client.py

@@ -1544,6 +1544,152 @@ class BackendClient:
         _check_status(resp.status_code, self._base_url)
         return WebhookAck(**resp.json())
 
+    # ── Self-reports (a person reporting their own work, with proofs) ──
+    # The INBOUND half of the reporting feed: work that never reached Jira or
+    # GitHub, submitted by the person who did it and scored against the proofs
+    # they attach. The backend owns the store (`daily_summaries`, channel_type
+    # `self_report`), the blob upload and the evaluator; the SDK only speaks
+    # HTTP to it with the co_ token, exactly like every other method here.
+    #
+    # Best-effort return shapes (dict / None) rather than raised errors, so the
+    # panel and the CLI can present a partial result instead of a traceback —
+    # the same posture `create_task_ml` and `list_jira_projects` take.
+
+    async def submit_self_report(
+        self,
+        *,
+        date: str,
+        text: str,
+        project: str = "",
+        proof_urls: list[str] | None = None,
+        files: list[tuple[str, bytes, str]] | None = None,
+        client_ref: str = "",
+        user_id: str = "",
+    ) -> dict | None:
+        """POST /api/v1/reports/self — submit one self-report. Returns the 202 ack.
+
+        Multipart, following the `update_task_ml` convention (:meth:`update_task_ml`):
+        ``Content-Type`` is dropped from the headers so httpx sets the boundary,
+        scalar fields go as ``(name, (None, value))`` and each proof file as
+        ``(name, (filename, bytes, content_type))``. ``proofUrl[]`` and ``file[]``
+        repeat, which is how a submission carries several proofs.
+
+        ``files`` is a list of ``(filename, data, content_type)`` — the BYTES,
+        read by the caller. The panel reads them inside the request handler on
+        purpose: an ``UploadFile``'s spooled temp file dies with the request,
+        while the evaluation job deliberately outlives it.
+
+        Returns the parsed 202 body (``{id, job_id, status, status_url, …}``)
+        or None on any failure.
+        """
+        url = self._url("/api/v1/reports/self")
+        headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
+        headers["accept"] = "application/json"
+
+        uid = str(user_id or "").strip() or self._user_id_from_token()
+        parts: list[tuple[str, Any]] = [
+            ("date", (None, str(date or ""))),
+            ("text", (None, str(text or ""))),
+        ]
+        if project:
+            parts.append(("project", (None, str(project))))
+        if client_ref:
+            parts.append(("clientRef", (None, str(client_ref))))
+        if uid:
+            parts.append(("userId", (None, uid)))
+        for u in (proof_urls or []):
+            if str(u or "").strip():
+                parts.append(("proofUrl[]", (None, str(u).strip())))
+        for name, data, ctype in (files or []):
+            parts.append(("file[]", (name or "proof", data,
+                                     ctype or "application/octet-stream")))
+        try:
+            # Generous: the request itself uploads every proof's bytes.
+            async with httpx.AsyncClient(timeout=180.0) as client:
+                resp = await client.post(url, files=parts, headers=headers)
+            if resp.status_code >= 400:
+                logger.warning("client.submit_self_report failed status=%s body=%s",
+                               resp.status_code, resp.text[:300])
+                return None
+            body = resp.json() or {}
+            return body if isinstance(body, dict) else None
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.submit_self_report error err=%s", exc)
+            return None
+
+    async def get_self_report(self, report_id: str) -> dict | None:
+        """GET /api/v1/reports/self/{id} — one submission and its current verdict.
+
+        This is what the poll loop reads while evaluation runs server-side;
+        `status` moves through `accepted` → `evaluating` → `evaluated` |
+        `evaluation_failed`. None on any failure.
+        """
+        rid = str(report_id or "").strip()
+        if not rid:
+            return None
+        url = self._url(f"/api/v1/reports/self/{rid}")
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.get(url, headers=self._headers)
+            if resp.status_code >= 400:
+                logger.warning("client.get_self_report failed id=%s status=%s body=%s",
+                               rid, resp.status_code, resp.text[:200])
+                return None
+            body = resp.json() or {}
+            return body if isinstance(body, dict) else None
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.get_self_report error id=%s err=%s", rid, exc)
+            return None
+
+    async def list_self_reports(self, limit: int = 25, user_id: str = "") -> list[dict]:
+        """GET /api/v1/reports/self — this caller's submissions, newest first.
+
+        Returns [] on any failure — the panel renders an empty list rather than
+        an error banner, and the CLI says "no submissions yet".
+        """
+        url = self._url("/api/v1/reports/self")
+        params: dict[str, Any] = {"limit": max(1, min(int(limit or 25), 200))}
+        uid = str(user_id or "").strip() or self._user_id_from_token()
+        if uid:
+            params["userId"] = uid
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.get(url, params=params, headers=self._headers)
+            if resp.status_code >= 400:
+                logger.warning("client.list_self_reports failed status=%s body=%s",
+                               resp.status_code, resp.text[:200])
+                return []
+            body = resp.json() or {}
+            rows = body.get("reports") if isinstance(body, dict) else body
+            return [r for r in (rows or []) if isinstance(r, dict)]
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.list_self_reports error err=%s", exc)
+            return []
+
+    async def reevaluate_self_report(self, report_id: str) -> dict | None:
+        """POST /api/v1/reports/self/{id}/evaluate — score an existing submission again.
+
+        The backend REPLACES the stored verdict rather than appending a second
+        one (the previous verdict moves into the submission's audit trail), so
+        this is safe to call repeatedly. None on any failure.
+        """
+        rid = str(report_id or "").strip()
+        if not rid:
+            return None
+        url = self._url(f"/api/v1/reports/self/{rid}/evaluate")
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                resp = await client.post(url, json={}, headers=self._headers)
+            if resp.status_code >= 400:
+                logger.warning("client.reevaluate_self_report failed id=%s status=%s body=%s",
+                               rid, resp.status_code, resp.text[:300])
+                return None
+            body = resp.json() or {}
+            return body if isinstance(body, dict) else None
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.reevaluate_self_report error id=%s err=%s", rid, exc)
+            return None
+
     # ── OAuth ─────────────────────────────────────────────────────────
 
     async def oauth_flow_start(self, service: str) -> OAuthStarted: