sediment-api 0.6.1__tar.gz → 0.7.0__tar.gz

{sediment_api-0.6.1 → sediment_api-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sediment-api
-Version: 0.6.1
+Version: 0.7.0
 Summary: Sediment ingest API: facts in through three doors
 Project-URL: Source, https://github.com/sediment-ai/sediment
 Project-URL: Documentation, https://github.com/sediment-ai/sediment/tree/main/docs
@@ -12,9 +12,9 @@ Requires-Python: >=3.12
 Requires-Dist: anyio>=4.15.1
 Requires-Dist: fastapi>=0.142.2
 Requires-Dist: httpx>=0.27
-Requires-Dist: pydantic-settings>=2.16.0
-Requires-Dist: sediment-capture==0.6.1
-Requires-Dist: sediment-core==0.6.1
-Requires-Dist: sediment-derive==0.6.1
-Requires-Dist: sediment-export==0.6.1
+Requires-Dist: pydantic-settings>=2.16.2
+Requires-Dist: sediment-capture==0.7.0
+Requires-Dist: sediment-core==0.7.0
+Requires-Dist: sediment-derive==0.7.0
+Requires-Dist: sediment-export==0.7.0
 Requires-Dist: uvicorn>=0.54.0

{sediment_api-0.6.1 → sediment_api-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sediment-api"
-version = "0.6.1"
+version = "0.7.0"
 description = "Sediment ingest API: facts in through three doors"
 requires-python = ">=3.12"
 license = "AGPL-3.0-or-later"
@@ -11,11 +11,11 @@ dependencies = [
     "fastapi>=0.142.2",
     "httpx>=0.27",
     "uvicorn>=0.54.0",
-    "pydantic-settings>=2.16.0",
-    "sediment-core==0.6.1",
-    "sediment-capture==0.6.1",
-    "sediment-derive==0.6.1",
-    "sediment-export==0.6.1",
+    "pydantic-settings>=2.16.2",
+    "sediment-core==0.7.0",
+    "sediment-capture==0.7.0",
+    "sediment-derive==0.7.0",
+    "sediment-export==0.7.0",
 ]
 
 [project.urls]

{sediment_api-0.6.1 → sediment_api-0.7.0}/sediment_api/__init__.py

@@ -3,4 +3,4 @@
 
 # Single source for the API version string — FastAPI's ``app.version``
 # (reported by /health) and GET /v1/me both read it, so the two cannot drift.
-__version__ = "0.6.1"
+__version__ = "0.7.0"

{sediment_api-0.6.1 → sediment_api-0.7.0}/sediment_api/main.py

@@ -34,7 +34,7 @@ from sqlalchemy.exc import (
 from . import __version__
 from .config import settings
 from .deps import BodySizeLimitMiddleware
-from .routers import ci_vendor, forge, gateway, otlp, query, reports, v1
+from .routers import ci_vendor, compute, forge, gateway, otlp, query, reports, v1
 from .workers import WorkerSupervisor
 
 logging.basicConfig(
@@ -229,6 +229,7 @@ app.include_router(gateway.router, prefix="/ingest")
 # free for a vendor-neutral push door later.
 app.include_router(forge.router, prefix="/ingest/github")
 app.include_router(ci_vendor.router, prefix="/ingest")
+app.include_router(compute.router, prefix="/ingest")
 # OTLP receiver: path fixed by the exporter (<endpoint>/v1/logs), no prefix.
 app.include_router(otlp.router)
 app.include_router(query.router, prefix="/query")

sediment_api-0.7.0/sediment_api/reports/compute_report.py

@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Compute report: Session completion time by final Compute allocation.
+
+sediment report compute --org acme-corp
+sediment report compute --org acme-corp --json
+sediment report compute --org acme-corp --rows-out sessions.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from sediment_core import normalize_org_id
+from sediment_derive import ComputeArm
+from sediment_export import (
+    ComputeReport,
+    DurationDistribution,
+    compute_report_to_json,
+    compute_timings_to_export_rows,
+    generate_compute_report_result,
+    write_jsonl,
+)
+from sediment_export.significance import MedianDifference
+
+from ..database import add_database_url_argument, one_shot_fact_store
+
+
+def _arm(arm: ComputeArm) -> str:
+    cpu = "unknown" if arm.cpu_millicores is None else f"{arm.cpu_millicores}m"
+    memory = (
+        "unknown" if arm.memory_bytes is None else f"{arm.memory_bytes / 2**30:.2f}GiB"
+    )
+    return f"{arm.allocation_source.value} cpu={cpu} memory={memory}"
+
+
+def _seconds(milliseconds: float | None) -> str:
+    return "n/a" if milliseconds is None else f"{milliseconds / 1000:.1f}s"
+
+
+def _distribution(name: str, distribution: DurationDistribution) -> str:
+    return (
+        f"{name} median={_seconds(distribution.median)} "
+        f"p25={_seconds(distribution.p25)} p75={_seconds(distribution.p75)}"
+    )
+
+
+def _difference(name: str, difference: MedianDifference) -> str:
+    sizes = f"n={difference.n_a}/{difference.n_b}"
+    if difference.insufficient_data:
+        return f"    {name}: insufficient data ({sizes})"
+    flag = " small-n" if difference.small_n else ""
+    level = round(difference.confidence * 100)
+    return (
+        f"    {name}: {_seconds(difference.difference)} "
+        f"[{level}% CI {_seconds(difference.ci_low)}, "
+        f"{_seconds(difference.ci_high)}] {sizes}{flag}"
+    )
+
+
+def _print_table(report: ComputeReport) -> None:
+    print(f"Sessions with a Compute allocation: {report.sessions_with_allocation}")
+    print(f"timed Sessions: {report.timed_sessions}")
+    skipped = ", ".join(f"{key}={value}" for key, value in report.skipped.items())
+    print(f"skipped Sessions: {skipped}")
+    print(
+        "randomized Sessions reassigned to another source: "
+        f"{report.randomized_reassigned_sessions} "
+        "(excluded from randomized comparisons)"
+    )
+    if not report.arms:
+        print("arms: no data")
+    for summary in report.arms:
+        print(
+            f"{_arm(summary.arm)}: n={summary.sessions} "
+            f"(allocation changed in {summary.allocation_changed_sessions})"
+        )
+        for name in ("elapsed_ms", "model_ms", "between_calls_ms"):
+            print(f"  {_distribution(name, getattr(summary, name))}")
+    if report.comparisons:
+        print("comparisons (arm B minus arm A; negative means arm B finished faster):")
+    for comparison in report.comparisons:
+        reading = "randomized" if comparison.randomized else "observational"
+        print(f"  {_arm(comparison.arm_a)} -> {_arm(comparison.arm_b)} ({reading})")
+        print(_difference("elapsed_ms", comparison.elapsed_ms))
+        print(_difference("between_calls_ms", comparison.between_calls_ms))
+    print(f"provenance: {report.provenance}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Return the argv contract consumed by the generated CLI reference."""
+    parser = argparse.ArgumentParser(
+        prog="compute_report",
+        description=(
+            "Compare Session completion time across final Compute allocations."
+        ),
+    )
+    parser.add_argument(
+        "--org",
+        default=os.environ.get("SEDIMENT_ORG_ID"),
+        required=not os.environ.get("SEDIMENT_ORG_ID"),
+        help="org id (default: $SEDIMENT_ORG_ID)",
+    )
+    parser.add_argument(
+        "--json", action="store_true", help="emit JSON instead of a text report"
+    )
+    parser.add_argument(
+        "--rows-out",
+        metavar="FILE",
+        help="write one Session compute timing per line to FILE as JSONL",
+    )
+    add_database_url_argument(parser)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        org_id = normalize_org_id(args.org)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    with one_shot_fact_store(
+        args.database_url, operation="generate compute report"
+    ) as store:
+        result = generate_compute_report_result(store, org_id)
+    if args.json:
+        print(json.dumps(compute_report_to_json(result.report), indent=2))
+    else:
+        _print_table(result.report)
+    if args.rows_out:
+        try:
+            write_result = write_jsonl(
+                compute_timings_to_export_rows(result.timings),
+                args.rows_out,
+                split_enabled=False,
+            )
+        except (OSError, TypeError, ValueError) as exc:
+            print(f"error: couldn't write compute timing rows: {exc}", file=sys.stderr)
+            return 1
+        if write_result.written:
+            print(
+                f"wrote {len(result.timings)} compute timing rows to {args.rows_out}",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                f"wrote 0 compute timing rows; left {args.rows_out} unchanged",
+                file=sys.stderr,
+            )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sediment_api-0.7.0/sediment_api/routers/compute.py

@@ -0,0 +1,102 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""
+POST /ingest/compute — vendor-neutral Compute allocation ingest.
+
+The execution platform that runs a coding agent (a sandbox, a container
+scheduler, a CI runner) posts the CPU and memory limits a Session's
+environment received: once when the environment starts, and again on every
+resize. ``allocation_source`` records who chose the allocation, so the
+compute report never presents an agent's own request as an assigned
+treatment. The sender is bearer-authenticated; Sediment stores its assertion
+and does not verify it against the platform.
+
+Dedup: the store's ``uq_compute_allocations_natural`` UNIQUE index on the
+complete allocation collapses redeliveries; ``stored: false`` means success,
+not an error.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from sediment_core import (
+    ComputeAllocation,
+    ComputeAllocationSource,
+    FactStore,
+    NonEmptyId,
+    UtcRepresentableDatetime,
+)
+
+from ..config import settings
+from ..deps import get_store, verify_ingest_token
+
+router = APIRouter(tags=["compute"])
+
+
+class ComputeAllocationRequest(BaseModel):
+    """One Compute allocation as the execution platform observed it.
+
+    ``extra="forbid"`` so a caller naming an org or fabricating fields is
+    rejected at the boundary. The limits carry the Fact's own bounds, so
+    malformed input 422s at the door rather than inside the handler."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    session_id: NonEmptyId = Field(
+        description=(
+            "The Session ID the coding agent's captured Facts carry, such as "
+            "the gateway Session header"
+        )
+    )
+    allocation_source: ComputeAllocationSource = Field(
+        description=(
+            "Who chose the allocation: default, agent_request, operator, or "
+            "randomized. Only randomized supports a causal comparison"
+        )
+    )
+    cpu_millicores: int | None = Field(
+        default=None,
+        ge=1,
+        le=2**63 - 1,
+        strict=True,
+        description="CPU limit in millicores; 1000 is one CPU",
+    )
+    memory_bytes: int | None = Field(
+        default=None,
+        ge=1,
+        le=2**63 - 1,
+        strict=True,
+        description="Memory limit in bytes",
+    )
+    occurred_at: UtcRepresentableDatetime = Field(
+        description=(
+            "When the allocation took effect, by the sender's clock; it must "
+            "convert to a UTC instant"
+        )
+    )
+
+    @model_validator(mode="after")
+    def _require_limit(self):
+        if self.cpu_millicores is None and self.memory_bytes is None:
+            raise ValueError("send cpu_millicores, memory_bytes, or both")
+        return self
+
+
+@router.post("/compute")
+def ingest_compute_allocation(
+    body: ComputeAllocationRequest,
+    _: None = Depends(verify_ingest_token),
+    store: FactStore = Depends(get_store),
+) -> dict[str, Any]:
+    allocation = ComputeAllocation(
+        org_id=settings.org_id,
+        session_id=body.session_id,
+        allocation_source=body.allocation_source,
+        cpu_millicores=body.cpu_millicores,
+        memory_bytes=body.memory_bytes,
+        occurred_at=body.occurred_at,
+    )
+    receipt = store.store_compute_allocation_receipt(allocation)
+    return {"fact_id": receipt.fact_id, "stored": receipt.stored}

{sediment_api-0.6.1 → sediment_api-0.7.0}/sediment_api/routers/query.py

@@ -34,6 +34,7 @@ from sediment_core import (
     AgentHarness,
     CIProvider,
     CIResult,
+    ComputeAllocationSource,
     ContextCommitAnchor,
     FactStore,
     FactTable,
@@ -530,6 +531,7 @@ class SessionCoverageResponse:
     edit_observations: SessionFactCoverageResponse
     rejected_edits: SessionFactCoverageResponse
     retry_linkages: SessionFactCoverageResponse
+    compute_allocations: SessionFactCoverageResponse
 
 
 SessionEventType = Literal[
@@ -579,6 +581,23 @@ class SessionTimelineEvent:
     accepted_call_id: str | None = None
 
 
+@dataclass(frozen=True)
+class ComputeAllocationSummary:
+    """One visible Compute allocation; a list beside the timeline, never in it.
+
+    ``sediment doctor`` copies on developer machines reject timeline event
+    types outside their fixed set, so the timeline vocabulary stays closed.
+    The route omits null fields, so an unknown limit is an absent key; the
+    defaults keep that absence inside the published contract."""
+
+    allocation_id: str
+    allocation_source: ComputeAllocationSource
+    occurred_at: datetime
+    captured_at: datetime
+    cpu_millicores: int | None = None
+    memory_bytes: int | None = None
+
+
 @dataclass(frozen=True)
 class AttributedCommitSummary:
     """Observation-backed Session edge with compatibility Attribution fields.
@@ -621,6 +640,7 @@ class SessionDossierFound:
     omitted_events: int
     gaps: list[SessionGap]
     timeline: list[SessionTimelineEvent]
+    compute_allocations: list[ComputeAllocationSummary]
     attributed_commits: list[AttributedCommitSummary]
     pushes: list[PushSummary]
     ci_outcomes: list[SessionCIOutcomeSummary]
@@ -1031,6 +1051,9 @@ def _run_session_query(
         if dossier is None:
             return SessionDossierNotFound(found=False)
 
+        allocations = snapshot.read_compute_allocations(
+            settings.org_id, session_ids={session_id}, limit=_SESSION_DOSSIER_LIMIT
+        )
         # One request boundary and complete context precede the Session filter.
         boundary = datetime.now(UTC)
         context = read_repository_context(snapshot, settings.org_id, as_of=boundary)
@@ -1101,12 +1124,31 @@ def _run_session_query(
             edit_observations=_fact_coverage(dossier, "edit_observations"),
             rejected_edits=_fact_coverage(dossier, "rejected_edits"),
             retry_linkages=_fact_coverage(dossier, "retry_linkages"),
+            compute_allocations=_fact_coverage(dossier, "compute_allocations"),
         ),
+        # Timeline omissions only: quarantined Compute allocations stay in
+        # their own coverage, so they never mark decision evidence incomplete.
         omitted_events=sum(
-            coverage.quarantined for coverage in dossier.coverage.values()
+            coverage.quarantined
+            for fact_type, coverage in dossier.coverage.items()
+            if fact_type != "compute_allocations"
         ),
         gaps=gaps,
         timeline=[_timeline_event(row) for row in dossier.timeline],
+        compute_allocations=[
+            ComputeAllocationSummary(
+                allocation_id=item.allocation_id,
+                allocation_source=item.allocation_source,
+                cpu_millicores=item.cpu_millicores,
+                memory_bytes=item.memory_bytes,
+                occurred_at=item.occurred_at,
+                captured_at=item.captured_at,
+            )
+            for item in sorted(
+                allocations,
+                key=lambda item: (item.occurred_at.astimezone(UTC), item.allocation_id),
+            )
+        ],
         attributed_commits=attributed_commits,
         session_commit_unobserved=int(not attributed_commits),
         repository_skipped=dict(binding_result.skipped),

{sediment_api-0.6.1 → sediment_api-0.7.0}/sediment_api/routers/v1.py

@@ -35,6 +35,7 @@ _SESSION_FACT_TABLES = (
     FactTable.EDIT_OBSERVATIONS,
     FactTable.REJECTED_EDITS,
     FactTable.RETRY_LINKAGES,
+    FactTable.COMPUTE_ALLOCATIONS,
 )
 
 

sediment_api-0.7.0/tests/test_compute_ingest.py

@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Compute allocation ingest and Session dossier exposure — real FactStore."""
+
+from __future__ import annotations
+
+from fastapi.testclient import TestClient
+from sediment_api.config import settings
+from sediment_api.main import app
+from sediment_core import ComputeAllocationSource, FactTable
+
+INGEST = {"Authorization": "Bearer test-ingest-token-3a7e-9d21"}
+OPERATOR = {"Authorization": "Bearer test-operator-token-3a7e-2f6c"}
+
+
+def _payload(**changes) -> dict:
+    body = {
+        "session_id": "sandbox-session",
+        "allocation_source": "agent_request",
+        "cpu_millicores": 8000,
+        "memory_bytes": 16 * 2**30,
+        "occurred_at": "2026-10-01T12:00:00Z",
+    }
+    body.update(changes)
+    return {key: value for key, value in body.items() if value is not None}
+
+
+def test_compute_ingest_stores_and_collapses_redelivery(client: TestClient) -> None:
+    first = client.post("/ingest/compute", json=_payload(), headers=INGEST)
+    assert first.status_code == 200
+    assert first.json()["stored"] is True
+
+    again = client.post("/ingest/compute", json=_payload(), headers=INGEST)
+    assert again.status_code == 200
+    assert again.json() == {"fact_id": first.json()["fact_id"], "stored": False}
+
+    [stored] = app.state.fact_store.read_compute_allocations(settings.org_id)
+    assert stored.allocation_id == first.json()["fact_id"]
+    assert stored.org_id == settings.org_id
+    assert stored.allocation_source is ComputeAllocationSource.AGENT_REQUEST
+    assert (stored.cpu_millicores, stored.memory_bytes) == (8000, 16 * 2**30)
+
+
+def test_compute_ingest_accepts_one_limit(client: TestClient) -> None:
+    response = client.post(
+        "/ingest/compute",
+        json=_payload(memory_bytes=None, allocation_source="default"),
+        headers=INGEST,
+    )
+    assert response.status_code == 200
+    [stored] = app.state.fact_store.read_compute_allocations(settings.org_id)
+    assert stored.memory_bytes is None
+    # The dossier omits the unknown limit, and the contract marks it optional.
+    dossier = client.get("/query/session/sandbox-session", headers=OPERATOR).json()
+    [item] = dossier["compute_allocations"]
+    assert item["cpu_millicores"] == 8000
+    assert "memory_bytes" not in item
+    schema = app.openapi()["components"]["schemas"]["ComputeAllocationSummary"]
+    assert "memory_bytes" not in schema["required"]
+    assert "cpu_millicores" not in schema["required"]
+
+
+def test_compute_ingest_rejects_malformed_envelopes(client: TestClient) -> None:
+    for payload in (
+        _payload(cpu_millicores=None, memory_bytes=None),
+        _payload(cpu_millicores=0),
+        _payload(cpu_millicores=1.5),
+        _payload(cpu_millicores="8000"),
+        _payload(memory_bytes=True),
+        _payload(memory_bytes=2**63),
+        _payload(allocation_source="autoscaler"),
+        _payload(occurred_at="2026-10-01T12:00:00"),
+        _payload(occurred_at="9999-12-31T23:59:59-14:00"),
+        _payload(occurred_at="0001-01-01T00:00:00+14:00"),
+        _payload(session_id="   "),
+        {**_payload(), "org_id": "another-org"},
+    ):
+        response = client.post("/ingest/compute", json=payload, headers=INGEST)
+        assert response.status_code == 422, payload
+    assert app.state.fact_store.read_compute_allocations(settings.org_id) == []
+
+
+def test_session_dossier_shows_compute_allocations(client: TestClient) -> None:
+    client.post(
+        "/ingest/compute",
+        json=_payload(allocation_source="default", cpu_millicores=2000),
+        headers=INGEST,
+    )
+    client.post(
+        "/ingest/compute",
+        json=_payload(occurred_at="2026-10-01T12:05:00Z"),
+        headers=INGEST,
+    )
+
+    response = client.get("/query/session/sandbox-session", headers=OPERATOR)
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["coverage"]["compute_allocations"] == {
+        "total": 2,
+        "visible": 2,
+        "quarantined": 0,
+    }
+    # Installed `sediment doctor` copies reject unknown timeline event types.
+    assert body["timeline"] == []
+    assert [
+        (item["allocation_source"], item["cpu_millicores"])
+        for item in body["compute_allocations"]
+    ] == [("default", 2000), ("agent_request", 8000)]
+    assert all(
+        item["memory_bytes"] == 16 * 2**30 for item in body["compute_allocations"]
+    )
+    assert "no_inference_calls_observed" in body["gaps"]
+
+    first = body["compute_allocations"][0]["allocation_id"]
+    app.state.fact_store.quarantine_fact(
+        settings.org_id, FactTable.COMPUTE_ALLOCATIONS, first, reason="test"
+    )
+    quarantined = client.get("/query/session/sandbox-session", headers=OPERATOR)
+    body = quarantined.json()
+    # A quarantined allocation never marks decision evidence incomplete.
+    assert body["omitted_events"] == 0
+    assert body["coverage"]["compute_allocations"]["quarantined"] == 1
+    assert [item["allocation_id"] for item in body["compute_allocations"]] != [first]
+    assert len(body["compute_allocations"]) == 1

sediment_api-0.7.0/tests/test_compute_report_cli.py

@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Operator rendering for the compute report, over a real Fact store."""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime, timedelta
+
+from sediment_api.reports import compute_report as cli
+from sediment_core import (
+    ComputeAllocation,
+    ComputeAllocationSource,
+    GatewayProvider,
+    InferenceCall,
+)
+
+T0 = datetime(2026, 10, 1, 12, 0, tzinfo=UTC)
+
+
+def _seed(store) -> None:
+    for index, (cpu, work_s) in enumerate(
+        [(2000, 60), (2000, 70), (2000, 80), (8000, 20), (8000, 30), (8000, 40)]
+    ):
+        session_id = f"session-{index}"
+        store.store_compute_allocation(
+            ComputeAllocation(
+                org_id="acme",
+                session_id=session_id,
+                allocation_source=ComputeAllocationSource.RANDOMIZED,
+                cpu_millicores=cpu,
+                memory_bytes=None,
+                occurred_at=T0 - timedelta(minutes=1),
+            )
+        )
+        for call, end_s in enumerate((5, 10 + work_s)):
+            store.store_inference_call(
+                InferenceCall(
+                    inference_call_id=f"{session_id}-{call}",
+                    org_id="acme",
+                    session_id=session_id,
+                    gateway_provider=GatewayProvider.LITELLM,
+                    input_messages=[],
+                    output_messages=[],
+                    duration_ms=5_000,
+                    observed_at=T0 + timedelta(seconds=end_s),
+                )
+            )
+    store.store_compute_allocation(
+        ComputeAllocation(
+            org_id="acme",
+            session_id="never-called",
+            allocation_source=ComputeAllocationSource.AGENT_REQUEST,
+            cpu_millicores=16000,
+            occurred_at=T0,
+        )
+    )
+
+
+def test_compute_report_table_names_arms_comparisons_and_skips(
+    postgres_store, postgres_database_url, capsys
+) -> None:
+    _seed(postgres_store)
+
+    assert cli.main(["--org", "acme", "--database-url", postgres_database_url]) == 0
+
+    output = capsys.readouterr().out
+    assert "Sessions with a Compute allocation: 7" in output
+    assert "timed Sessions: 6" in output
+    assert "no_inference_calls=1" in output
+    assert "randomized Sessions reassigned to another source: 0" in output
+    assert "randomized cpu=2000m memory=unknown: n=3" in output
+    assert "between_calls_ms median=70.0s" in output
+    assert (
+        "randomized cpu=2000m memory=unknown -> randomized cpu=8000m "
+        "memory=unknown (randomized)"
+    ) in output
+    assert "    elapsed_ms: -40.0s [95% CI" in output
+    assert "small-n" in output
+    assert "policy_version=1 quarantine_revision=0" in output
+
+
+def test_compute_report_json_and_rows_out(
+    postgres_store, postgres_database_url, tmp_path, capsys
+) -> None:
+    _seed(postgres_store)
+    destination = tmp_path / "sessions.jsonl"
+
+    assert (
+        cli.main(
+            [
+                "--org",
+                "acme",
+                "--database-url",
+                postgres_database_url,
+                "--json",
+                "--rows-out",
+                str(destination),
+            ]
+        )
+        == 0
+    )
+
+    output = capsys.readouterr()
+    report = json.loads(output.out)
+    assert report["timed_sessions"] == 6
+    assert report["skipped"]["no_inference_calls"] == 1
+    assert report["randomized_reassigned_sessions"] == 0
+    assert report["comparisons"][0]["randomized"] is True
+    assert "wrote 6 compute timing rows" in output.err
+    rows = [json.loads(line) for line in destination.read_text().splitlines()]
+    assert [row["session_id"] for row in rows] == [f"session-{i}" for i in range(6)]
+    assert rows[0]["elapsed_ms"] == 70_000

{sediment_api-0.6.1 → sediment_api-0.7.0}/tests/test_credential_authorities.py

@@ -10,7 +10,7 @@ from pydantic import SecretStr
 from sediment_api.config import Settings
 from sediment_api.main import app
 
-INGEST = {"/ingest/gateway", "/ingest/ci", "/v1/logs"}
+INGEST = {"/ingest/gateway", "/ingest/ci", "/ingest/compute", "/v1/logs"}
 BEARER_ROUTES = [
     (method, path)
     for path, item in app.openapi()["paths"].items()

{sediment_api-0.6.1 → sediment_api-0.7.0}/tests/test_v1.py

@@ -101,7 +101,7 @@ def test_me_happy_path(client: TestClient) -> None:
     assert resp.status_code == 200
     assert resp.json() == {
         "org_id": ORG,
-        "version": "0.6.1",
+        "version": "0.7.0",
         "authority": "operator",
         "client_id": "operator",
     }
@@ -184,6 +184,7 @@ def test_session_facts_counts_only_the_named_session(client: TestClient) -> None
             "edit_observations": {"total": 0, "visible": 0},
             "rejected_edits": {"total": 0, "visible": 0},
             "retry_linkages": {"total": 0, "visible": 0},
+            "compute_allocations": {"total": 0, "visible": 0},
         },
     }