agent-tokenops 0.1.2__tar.gz → 0.2.0__tar.gz

{agent_tokenops-0.1.2/src/agent_tokenops.egg-info → agent_tokenops-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-tokenops
-Version: 0.1.2
+Version: 0.2.0
 Summary: TokenOps control plane and SDK for run-aware agent token governance
 Author: Susheem Koul, Tisha Chawla
 License-Expression: MIT
@@ -60,7 +60,11 @@ Cap spend and steer behavior across a whole agent workflow — not per request
 
 <br>
 
-<img src="https://raw.githubusercontent.com/theagentplane/tokenops/main/examples/demo-assets/videos/02_governance_on_budget_cap.png" alt="TokenOps Dashboard: governance halt when worst-case cost exceeds remaining run budget" width="720" />
+<a href="https://github.com/theagentplane/tokenops/raw/main/examples/demo-assets/videos/02_governance_on_budget_cap.webm">
+<img src="https://raw.githubusercontent.com/theagentplane/tokenops/main/examples/demo-assets/videos/02_governance_on_budget_cap.gif" alt="TokenOps demo: a governed Research to Summarize run halts when worst-case cost exceeds the remaining run budget, then the Dashboard shows spend and governance per agent" width="720" />
+</a>
+
+<sub><i>Governed Research → Summarize run: the budget cap halts spend mid-run, then the Dashboard attributes cost per agent. <a href="https://github.com/theagentplane/tokenops/raw/main/examples/demo-assets/videos/02_governance_on_budget_cap.webm">Full video</a>.</i></sub>
 
 </div>
 

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/README.md

@@ -14,7 +14,11 @@ Cap spend and steer behavior across a whole agent workflow — not per request
 
 <br>
 
-<img src="https://raw.githubusercontent.com/theagentplane/tokenops/main/examples/demo-assets/videos/02_governance_on_budget_cap.png" alt="TokenOps Dashboard: governance halt when worst-case cost exceeds remaining run budget" width="720" />
+<a href="https://github.com/theagentplane/tokenops/raw/main/examples/demo-assets/videos/02_governance_on_budget_cap.webm">
+<img src="https://raw.githubusercontent.com/theagentplane/tokenops/main/examples/demo-assets/videos/02_governance_on_budget_cap.gif" alt="TokenOps demo: a governed Research to Summarize run halts when worst-case cost exceeds the remaining run budget, then the Dashboard shows spend and governance per agent" width="720" />
+</a>
+
+<sub><i>Governed Research → Summarize run: the budget cap halts spend mid-run, then the Dashboard attributes cost per agent. <a href="https://github.com/theagentplane/tokenops/raw/main/examples/demo-assets/videos/02_governance_on_budget_cap.webm">Full video</a>.</i></sub>
 
 </div>
 

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-tokenops"
-version = "0.1.2"
+version = "0.2.0"
 description = "TokenOps control plane and SDK for run-aware agent token governance"
 readme = "README.md"
 requires-python = ">=3.10"

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0/src/agent_tokenops.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-tokenops
-Version: 0.1.2
+Version: 0.2.0
 Summary: TokenOps control plane and SDK for run-aware agent token governance
 Author: Susheem Koul, Tisha Chawla
 License-Expression: MIT
@@ -60,7 +60,11 @@ Cap spend and steer behavior across a whole agent workflow — not per request
 
 <br>
 
-<img src="https://raw.githubusercontent.com/theagentplane/tokenops/main/examples/demo-assets/videos/02_governance_on_budget_cap.png" alt="TokenOps Dashboard: governance halt when worst-case cost exceeds remaining run budget" width="720" />
+<a href="https://github.com/theagentplane/tokenops/raw/main/examples/demo-assets/videos/02_governance_on_budget_cap.webm">
+<img src="https://raw.githubusercontent.com/theagentplane/tokenops/main/examples/demo-assets/videos/02_governance_on_budget_cap.gif" alt="TokenOps demo: a governed Research to Summarize run halts when worst-case cost exceeds the remaining run budget, then the Dashboard shows spend and governance per agent" width="720" />
+</a>
+
+<sub><i>Governed Research → Summarize run: the budget cap halts spend mid-run, then the Dashboard attributes cost per agent. <a href="https://github.com/theagentplane/tokenops/raw/main/examples/demo-assets/videos/02_governance_on_budget_cap.webm">Full video</a>.</i></sub>
 
 </div>
 

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/src/agent_tokenops.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ src/tokenops/control/crossing.py
 src/tokenops/control/engine.py
 src/tokenops/control/governance_cache.py
 src/tokenops/control/http.py
+src/tokenops/control/http_store.py
 src/tokenops/control/instrument.py
 src/tokenops/control/integration.py
 src/tokenops/control/ledger.py

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/src/tokenops/__init__.py

@@ -4,7 +4,7 @@ from tokenops.env import load_env
 
 load_env()
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 
 def init() -> None:

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/src/tokenops/control/client.py

@@ -15,9 +15,10 @@ from __future__ import annotations
 import logging
 import os
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, cast
 
 from tokenops.control.http import post_run, post_run_sync
+from tokenops.control.http_store import HttpStore
 from tokenops.control.models import (
     GovernanceMode,
     RunAlreadyRegisteredError,
@@ -58,23 +59,27 @@ class ControlPlaneClient:
             raise ValueError("exactly one of url or store is required")
         self._url = url.rstrip("/") if url else None
         self._store = store
-        self._hybrid_store: Store | None = None
+        self._hybrid_store: Any = None
         self._timeout = timeout
 
     @classmethod
     def from_env(cls, *, timeout: float = 30.0) -> ControlPlaneClient:
         """Build a client from ``TOKENOPS_URL`` / ``TOKENOPS_EMBEDDED`` / ``TOKENOPS_DB``.
 
-        * ``TOKENOPS_URL`` set and ``TOKENOPS_EMBEDDED`` not ``1`` → HTTP to the plane.
-        * otherwise → embedded :class:`Store` at ``TOKENOPS_DB`` (default ``tokenops.db``).
-
-        Also installs the Chronicle crossing hook (idempotent; design notes §17).
+        * ``TOKENOPS_URL`` or ``CONTROL_PLANE_URL`` set and ``TOKENOPS_EMBEDDED`` not ``1``
+          → HTTP to the plane (no local SQLite).
+        * otherwise → embedded :class:`Store` at ``TOKENOPS_DB``.
         """
         from tokenops.control.crossing import install_crossing_hook
 
         install_crossing_hook()
         embedded = os.environ.get("TOKENOPS_EMBEDDED", "").strip() == "1"
-        url = (os.environ.get("TOKENOPS_URL") or "").strip()
+        url = (
+            os.environ.get("CONTROL_PLANE_URL")
+            or os.environ.get("TOKENOPS_URL")
+            or os.environ.get("TOKENOPS_CONTROL_PLANE_URL")
+            or ""
+        ).strip()
         if url and not embedded:
             return cls(url=url, timeout=timeout)
         db = os.environ.get("TOKENOPS_DB", "tokenops.db")
@@ -98,19 +103,18 @@ class ControlPlaneClient:
         return self._store
 
     def require_store(self) -> Store:
-        """Backing Store for ledger / config / dashboard rows (escape hatch).
+        """Backing store for ledger / config / dashboard rows.
 
-        Embedded mode returns the in-process Store. Remote registration mode
-        lazily opens shared ``TOKENOPS_DB`` for ledger and config until those
-        plane APIs are HTTP (§4 / later waves).
+        Embedded mode returns the in-process SQLite Store. Remote mode returns
+        :class:`HttpStore` — never a local DB file.
         """
         if self._store is not None:
             return self._store
         if self._hybrid_store is None:
-            db = os.environ.get("TOKENOPS_DB", "tokenops.db")
-            logger.debug("tokenops.client hybrid_store path=%s", db)
-            self._hybrid_store = Store(db)
-        return self._hybrid_store
+            assert self._url is not None
+            key = os.environ.get("CONTROL_PLANE_API_KEY") or os.environ.get("TOKENOPS_API_KEY")
+            self._hybrid_store = HttpStore(self._url, api_key=key, timeout=self._timeout)
+        return cast(Store, self._hybrid_store)
 
     def register_run(
         self,

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/src/tokenops/control/http.py

@@ -6,6 +6,7 @@ wrap handlers here so Halt/Throttled map to HTTP responses.
 
 from __future__ import annotations
 
+import os
 from collections.abc import Awaitable, Callable, Mapping
 from typing import Any
 
@@ -107,6 +108,15 @@ def _raise_for_response(response: httpx.Response) -> None:
         ) from exc
 
 
+def _plane_auth_headers() -> dict[str, str]:
+    key = (
+        os.environ.get("CONTROL_PLANE_API_KEY") or os.environ.get("TOKENOPS_API_KEY") or ""
+    ).strip()
+    if not key:
+        return {}
+    return {"Authorization": f"Bearer {key}"}
+
+
 async def post_run(
     url: str,
     payload: dict[str, Any],
@@ -116,7 +126,7 @@ async def post_run(
     """POST ``/v1/runs`` at *url*. Prefer :class:`~tokenops.control.client.ControlPlaneClient`."""
     base = url.rstrip("/")
     async with httpx.AsyncClient(timeout=timeout) as client:
-        response = await client.post(f"{base}/v1/runs", json=payload)
+        response = await client.post(f"{base}/v1/runs", json=payload, headers=_plane_auth_headers())
         _raise_for_response(response)
         return response.json()
 
@@ -130,6 +140,6 @@ def post_run_sync(
     """Sync POST ``/v1/runs`` at *url*. Prefer :class:`~tokenops.control.client.ControlPlaneClient`."""
     base = url.rstrip("/")
     with httpx.Client(timeout=timeout) as client:
-        response = client.post(f"{base}/v1/runs", json=payload)
+        response = client.post(f"{base}/v1/runs", json=payload, headers=_plane_auth_headers())
         _raise_for_response(response)
         return response.json()

agent_tokenops-0.2.0/src/tokenops/control/http_store.py

@@ -0,0 +1,217 @@
+"""HTTP-backed Store used when TOKENOPS_URL / CONTROL_PLANE_URL is set.
+
+Does not open SQLite. All ledger, governance, and run-history traffic goes to
+the control plane process.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from tokenops.control.models import (
+    BudgetSpec,
+    PolicyInstance,
+    RunAlreadyRegisteredError,
+    RunNotRegisteredError,
+    RunRecord,
+    RunRegistration,
+    Segment,
+    parse_governance_mode,
+)
+
+
+class HttpStore:
+    def __init__(self, base_url: str, *, api_key: str | None = None, timeout: float = 30.0) -> None:
+        self.path = base_url.rstrip("/")
+        headers = {}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        self._client = httpx.Client(base_url=self.path, timeout=timeout, headers=headers)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        response = self._client.request(method, path, **kwargs)
+        if response.status_code == 409:
+            body = response.json()
+            raise RunAlreadyRegisteredError(body.get("error", "run already registered"))
+        if response.status_code == 404:
+            return response
+        response.raise_for_status()
+        return response
+
+    def register_run(self, reg: RunRegistration) -> RunRegistration:
+        r = self._request(
+            "POST",
+            "/v1/runs",
+            json={
+                "run_id": reg.run_id,
+                "intent": reg.intent,
+                "user_dims": dict(reg.user_dims),
+                "mode": reg.mode.value,
+            },
+        )
+        body = r.json()
+        return RunRegistration(
+            run_id=str(body["run_id"]),
+            intent=str(body.get("intent") or reg.intent),
+            user_dims={str(k): str(v) for k, v in (body.get("user_dims") or reg.user_dims).items()},
+            mode=parse_governance_mode(body.get("mode") or reg.mode),
+        )
+
+    def resolve_run(self, run_id: str) -> RunRegistration:
+        r = self._client.get(f"/v1/runs/{run_id}/registration")
+        if r.status_code == 404:
+            raise RunNotRegisteredError(f"run {run_id!r} is not registered")
+        r.raise_for_status()
+        body = r.json()
+        return RunRegistration(
+            run_id=str(body["run_id"]),
+            intent=str(body.get("intent", "")),
+            user_dims={str(k): str(v) for k, v in (body.get("user_dims") or {}).items()},
+            mode=parse_governance_mode(body.get("mode")),
+        )
+
+    def get_run_registration(self, run_id: str) -> RunRegistration | None:
+        try:
+            return self.resolve_run(run_id)
+        except RunNotRegisteredError:
+            return None
+
+    def governance_config_for(self, agent: str) -> dict:
+        return self._request("GET", f"/v1/governance/{agent}").json()
+
+    def create_run(self, rec: RunRecord) -> RunRecord:
+        payload = {
+            "run_id": rec.run_id,
+            "agent": rec.agent,
+            "status": rec.status,
+            "parent_run": rec.parent_run,
+            "parent_span": rec.parent_span,
+            "halt_reason": rec.halt_reason,
+            "detector": rec.detector,
+            "cost_micros": rec.cost_micros,
+            "steps": rec.steps,
+            "started_at": rec.started_at,
+            "ended_at": rec.ended_at,
+            "task": rec.task,
+            "dims": dict(rec.dims),
+            "governance_events": list(rec.governance_events or []),
+        }
+        self._request("PUT", "/v1/run-records", json=payload)
+        return rec
+
+    def update_run(self, run_id: str, **fields: Any) -> None:
+        self._request("PATCH", f"/v1/run-records/{run_id}", json=fields)
+
+    def get_run(self, run_id: str) -> RunRecord | None:
+        r = self._client.get(f"/v1/run-records/{run_id}")
+        if r.status_code == 404:
+            return None
+        r.raise_for_status()
+        return _run(r.json())
+
+    def list_runs(self, *, problematic_only: bool = False, limit: int = 200) -> list[RunRecord]:
+        r = self._request(
+            "GET",
+            "/v1/run-records",
+            params={"problematic_only": problematic_only, "limit": limit},
+        )
+        return [_run(x) for x in r.json()]
+
+    def ledger_add_spent(self, budget_id: str, segment_key: str, period: str, delta: int) -> int:
+        r = self._request(
+            "POST",
+            "/v1/ledger/spent/add",
+            json={
+                "budget_id": budget_id,
+                "segment_key": segment_key,
+                "period": period,
+                "delta": delta,
+            },
+        )
+        return int(r.json()["spent_micros"])
+
+    def ledger_get_spent(self, budget_id: str, segment_key: str, period: str) -> int:
+        r = self._request(
+            "GET",
+            "/v1/ledger/spent",
+            params={"budget_id": budget_id, "segment_key": segment_key, "period": period},
+        )
+        return int(r.json()["spent_micros"])
+
+    def ledger_admit(self, segment_key: str) -> int:
+        r = self._request("POST", "/v1/ledger/inflight/admit", json={"segment_key": segment_key})
+        return int(r.json()["count"])
+
+    def ledger_complete(self, segment_key: str) -> int:
+        r = self._request("POST", "/v1/ledger/inflight/complete", json={"segment_key": segment_key})
+        return int(r.json()["count"])
+
+    def ledger_inflight(self, segment_key: str) -> int:
+        r = self._request("GET", "/v1/ledger/inflight", params={"segment_key": segment_key})
+        return int(r.json()["count"])
+
+    def ledger_mark_halted(self, run_id: str, reason: str = "") -> None:
+        self._request("POST", "/v1/ledger/halt/mark", json={"run_id": run_id, "reason": reason})
+
+    def ledger_is_halted(self, run_id: str) -> bool:
+        r = self._request("GET", f"/v1/ledger/halt/{run_id}")
+        return bool(r.json().get("halted"))
+
+    def ledger_halt_reason(self, run_id: str) -> str | None:
+        r = self._client.get(f"/v1/ledger/halt/{run_id}")
+        r.raise_for_status()
+        return r.json().get("halt_reason")
+
+    def ledger_clear_halt(self, run_id: str) -> None:
+        self._request("POST", "/v1/ledger/halt/clear", json={"run_id": run_id})
+
+    # Trajectory index is plane-local for now; no-ops keep policies from crashing.
+    def save_trajectory_snapshot(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+    def enqueue_trajectory_build(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+    def lookup_trajectory_index(self, **kwargs: Any) -> dict[str, Any] | None:
+        return None
+
+    def upsert_segment(self, seg: Segment) -> Segment:
+        self._request("PUT", "/v1/segments", json=seg.__dict__)
+        return seg
+
+    def list_segments(self) -> list[Segment]:
+        return [Segment(**x) for x in self._request("GET", "/v1/segments").json()]
+
+    def upsert_budget(self, b: BudgetSpec) -> BudgetSpec:
+        self._request("PUT", "/v1/budgets", json=b.__dict__)
+        return b
+
+    def list_budgets(self) -> list[BudgetSpec]:
+        return [BudgetSpec(**x) for x in self._request("GET", "/v1/budgets").json()]
+
+    def list_policy_instances(self) -> list[PolicyInstance]:
+        return [PolicyInstance(**x) for x in self._request("GET", "/v1/policies").json()]
+
+
+def _run(data: dict[str, Any]) -> RunRecord:
+    return RunRecord(
+        run_id=str(data["run_id"]),
+        agent=str(data["agent"]),
+        status=data.get("status", "running"),
+        parent_run=data.get("parent_run"),
+        parent_span=data.get("parent_span"),
+        halt_reason=data.get("halt_reason"),
+        detector=data.get("detector"),
+        cost_micros=int(data.get("cost_micros", 0)),
+        steps=int(data.get("steps", 0)),
+        started_at=float(data.get("started_at", 0.0)),
+        ended_at=data.get("ended_at"),
+        task=data.get("task"),
+        dims={str(k): str(v) for k, v in (data.get("dims") or {}).items()},
+        governance_events=list(data.get("governance_events") or []),
+    )

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/src/tokenops/control/store.py

@@ -32,6 +32,7 @@ import uuid
 from collections.abc import Callable
 from typing import Any, TypeVar
 
+from tokenops.control.ledger import LIFETIME, RUN_TOTAL_BUDGET
 from tokenops.control.models import (
     BudgetSpec,
     PolicyInstance,
@@ -377,6 +378,18 @@ class Store:
             (reg.run_id, reg.intent, json.dumps(reg.user_dims), reg.mode.value, time.time()),
         )
         self._db.commit()
+        # Dashboard reads ``runs``; registration alone must make the run visible.
+        # Explicit create_run/update_run remain for richer status/cost/steps (REPLACE-safe).
+        agent = reg.intent or "agent"
+        self.create_run(
+            RunRecord(
+                run_id=reg.run_id,
+                agent=agent,
+                status="running",
+                dims=dict(reg.user_dims),
+                task=reg.intent or None,
+            )
+        )
         return reg
 
     @_locked
@@ -484,7 +497,7 @@ class Store:
     @_locked
     def get_run(self, run_id: str) -> RunRecord | None:
         row = self._db.execute("SELECT * FROM runs WHERE run_id=?", (run_id,)).fetchone()
-        return _run(row) if row else None
+        return self._run_with_ledger_cost(row) if row else None
 
     @_locked
     def list_runs(self, *, problematic_only: bool = False, limit: int = 200) -> list[RunRecord]:
@@ -492,7 +505,19 @@ class Store:
         if problematic_only:
             sql += " WHERE status IN ('halted','throttled','error')"
         sql += " ORDER BY started_at DESC LIMIT ?"
-        return [_run(r) for r in self._db.execute(sql, (limit,))]
+        return [self._run_with_ledger_cost(r) for r in self._db.execute(sql, (limit,))]
+
+    def _run_with_ledger_cost(self, row: sqlite3.Row) -> RunRecord:
+        """Build a RunRecord; prefer ``__run_total__`` ledger spend when present."""
+        rec = _run(row)
+        spent_row = self._db.execute(
+            "SELECT spent_micros FROM ledger_spent "
+            "WHERE budget_id=? AND segment_key=? AND period=?",
+            (RUN_TOTAL_BUDGET.budget_id, f"run:{rec.run_id}", LIFETIME),
+        ).fetchone()
+        if spent_row is not None:
+            rec.cost_micros = int(spent_row[0])
+        return rec
 
     @_locked
     def run_tag_keys(self, *, limit: int = 500) -> list[str]:
@@ -581,6 +606,11 @@ class Store:
             "halt_reason=COALESCE(excluded.halt_reason, ledger_halt.halt_reason)",
             (run_id, reason or None),
         )
+        # Keep dashboard row in sync when present; ignore missing runs rows.
+        self._db.execute(
+            "UPDATE runs SET status='halted', halt_reason=? WHERE run_id=?",
+            (reason or None, run_id),
+        )
         self._db.commit()
 
     @_locked
@@ -606,6 +636,11 @@ class Store:
             "ON CONFLICT(run_id) DO UPDATE SET halted=0, halt_reason=NULL",
             (run_id,),
         )
+        # Clear halt_reason only — do not invent a completed/running status.
+        self._db.execute(
+            "UPDATE runs SET halt_reason=NULL WHERE run_id=?",
+            (run_id,),
+        )
         self._db.commit()
 
     # ---- trajectory hint index -------------------------------------------- #

{agent_tokenops-0.1.2 → agent_tokenops-0.2.0}/tests/test_store.py

@@ -6,7 +6,14 @@ import pytest
 
 from conftest import toy_price
 from tokenops.control import build_governor
-from tokenops.control.models import BudgetSpec, PolicyInstance, RunRecord, Segment
+from tokenops.control.ledger import LIFETIME, RUN_TOTAL_BUDGET
+from tokenops.control.models import (
+    BudgetSpec,
+    PolicyInstance,
+    RunRecord,
+    RunRegistration,
+    Segment,
+)
 from tokenops.control.store import Store
 
 
@@ -77,6 +84,59 @@ def test_run_records_and_problematic_filter(store):
     assert problematic[0].halt_reason == "budget exhausted"
 
 
+def test_register_run_creates_dashboard_row(store):
+    """Registration alone must surface on the Admin Dashboard (list_runs / get_run)."""
+    store.register_run(
+        RunRegistration(
+            run_id="reg-only",
+            intent="summarize",
+            user_dims={"team": "growth"},
+        )
+    )
+    got = store.get_run("reg-only")
+    assert got is not None
+    assert got.agent == "summarize"
+    assert got.status == "running"
+    assert got.task == "summarize"
+    assert got.dims == {"team": "growth"}
+    assert got.cost_micros == 0
+    listed = store.list_runs()
+    assert [r.run_id for r in listed] == ["reg-only"]
+
+    store.ledger_add_spent(RUN_TOTAL_BUDGET.budget_id, "run:reg-only", LIFETIME, 12_345)
+    assert store.get_run("reg-only").cost_micros == 12_345
+    assert store.list_runs()[0].cost_micros == 12_345
+
+    # Explicit create_run after register remains REPLACE-safe.
+    store.create_run(
+        RunRecord(
+            run_id="reg-only",
+            agent="summarize",
+            status="completed",
+            cost_micros=99,
+            dims={"team": "growth"},
+            task="summarize",
+        )
+    )
+    after = store.get_run("reg-only")
+    assert after.status == "completed"
+    assert after.cost_micros == 12_345  # ledger still overlays
+
+    store.ledger_mark_halted("reg-only", reason="budget exhausted")
+    halted = store.get_run("reg-only")
+    assert halted.status == "halted"
+    assert halted.halt_reason == "budget exhausted"
+
+    store.ledger_clear_halt("reg-only")
+    cleared = store.get_run("reg-only")
+    assert cleared.halt_reason is None
+    assert cleared.status == "halted"  # clear does not invent a new status
+
+    store.register_run(RunRegistration(run_id="no-intent"))
+    assert store.get_run("no-intent").agent == "agent"
+    assert store.get_run("no-intent").task is None
+
+
 def test_seed_default_governance_if_empty(tmp_path, monkeypatch):
     monkeypatch.delenv("TOKENOPS_SKIP_GOVERNANCE_SEED", raising=False)
     s = Store(str(tmp_path / "seed.db"), auto_seed=False)