qaas-python 0.1.0__py3-none-any.whl

qaas/tasks.py

@@ -0,0 +1,361 @@
+"""The task each agent is given: the user turn, distinct from its system prompt.
+
+The system prompt says who an agent is and what its standards are; that is
+stable across every run and lives in `prompts/`. The task says what to do this
+time — which application, which environment, which findings — and is built here
+from the target profile.
+
+Nothing in this module may name a specific application. A prompt that mentions
+one repository's directory layout or one app's seeded users works exactly once.
+"""
+
+from __future__ import annotations
+
+from qaas.config import SystemConfig
+from qaas.envelope import DefectEnvelope
+from qaas.target import TargetProfile
+
+
+def _profile(config: SystemConfig) -> TargetProfile:
+    if config.profile is None:
+        raise ValueError(
+            "no target profile loaded. Point `target:` in system.yaml at a file "
+            "in config/targets/, or create one with `qaas init <path-to-repo>`."
+        )
+    return config.profile
+
+
+def _where(config: SystemConfig) -> str:
+    """How to name the application under test to an agent.
+
+    The resolved path, not `profile.root`. An agent's process cwd *is* the
+    target root, and `root:` is spelled relative to the qaas project -- so
+    telling a run "the application at `target-app`" sent it looking for
+    `<target>/target-app`, a directory that does not exist. Resolved, the
+    sentence is true from wherever the agent happens to be standing.
+    """
+    return str(config.target_root())
+
+
+def _environment_brief(profile: TargetProfile) -> str:
+    """What an agent can and cannot do to the running application."""
+    env = profile.environment
+    if env.mode == "none":
+        return (
+            "There is no running instance of this application available. Work "
+            "statically: read the code, the schema, the spec and the tests. Say so "
+            "plainly in any finding you cannot execute — a defect you reasoned to "
+            "but did not observe is a weaker claim, and its confidence should show "
+            "that."
+        )
+
+    lines = []
+    if env.api_url:
+        lines.append(f"API: {env.api_url}")
+    if env.web_url:
+        lines.append(f"web: {env.web_url}")
+    where = "; ".join(lines)
+
+    if env.mode == "external":
+        return (
+            f"The application is already running ({where}) and this system does not "
+            "own it. You may read it and exercise it. You may NOT reset it, reseed "
+            "it, or destroy state — someone else may be relying on it. Prefer "
+            "read-only calls, and never send a request whose side effect you would "
+            "not want to explain."
+        )
+    return (
+        f"Bring the application up with `env_control` ({where}). You own this "
+        "environment: seed it, reset it between journeys, and tear it down when "
+        "done. Reset between independent checks so one test's leftovers are not "
+        "the next one's bug."
+    )
+
+
+def _auth_brief(profile: TargetProfile) -> str:
+    auth = profile.auth
+    if auth.mode == "none":
+        return "The application needs no authentication."
+    if auth.mode == "token":
+        return (
+            f"Authenticate with the bearer token in ${auth.token_env}. "
+            "`env_control.impersonate` will hand it to you."
+        )
+    roles = "\n".join(
+        f"  - `{name}` ({r.username}){': ' + r.description if r.description else ''}"
+        for name, r in auth.roles.items()
+    )
+    return (
+        f"Sign in via `{auth.login_endpoint}`. `env_control.impersonate(role)` returns "
+        f"a token for any of these accounts:\n{roles}\n"
+        "Use more than one. A permission defect is invisible from a single role."
+    )
+
+
+def cartographer(config: SystemConfig) -> str:
+    p = _profile(config)
+    spec = (
+        f"`{p.layout.spec}` is the declared API contract — read it for the intended "
+        "surface, but record what the code actually implements, and put any "
+        "disagreement in `drift`."
+        if p.layout.spec
+        else "There is no API specification in this repository. Record the surface "
+        "the code actually exposes, and note the absence of a spec in `gaps`."
+    )
+    ownership = (
+        f"`{p.layout.ownership}` is the ownership source."
+        if p.layout.ownership
+        else "There is no CODEOWNERS file. Leave ownership null rather than guessing "
+        "a team from a directory name — a misrouted ticket is worse than an "
+        "unassigned one."
+    )
+    return f"""Map the application at `{_where(config)}` — your working directory.
+
+{p.description.strip() or "No description was supplied; work it out from the code."}
+
+Known layout — {p.layout.described()}. Treat that as a starting point, not an
+inventory: verify it and record what is actually there.
+
+{spec}
+
+{ownership}
+
+Ignore these directories entirely: {', '.join(p.layout.exclude)}.
+
+Explore with Read, Grep and Glob, then publish one complete map with
+`put_system_map`. Get the shape of the repository before reading any single file
+closely. Breadth first: every route and every table matters more than a deep
+read of any one handler.
+
+Publish the map once, when it is complete."""
+
+
+def conduit(config: SystemConfig, mode: str) -> str:
+    p = _profile(config)
+    spec_line = (
+        f"Compare the implementation against `{p.layout.spec}` with `diff_openapi`, "
+        "and judge each difference by consumer impact with `classify_breaking`."
+        if p.layout.spec
+        else "There is no specification to diff against, so the contract is implicit. "
+        "Judge each endpoint against what its own code promises and what its "
+        "consumers assume: look for handlers that disagree with each other."
+    )
+    prove = (
+        "Prove what you report. Call the endpoint and capture the real request and "
+        "response. A finding you have not observed is a hypothesis, not a defect, "
+        "and its confidence should say so."
+        if p.environment.is_reachable
+        else "You cannot call this API, so every finding is a reading of the code. "
+        "Quote the lines that support it, and keep confidence honest about the "
+        "fact that you did not observe the behaviour."
+    )
+    filing = (
+        "This is a diagnostic run: report what you find, but nothing will be filed."
+        if mode == "incident"
+        else "Findings that survive reproduction become tickets. Hold yourself to that bar."
+    )
+    return f"""Audit the API of the application at `{_where(config)}` — your working directory.
+
+Start with `get_system_map` for the route inventory. Do not rediscover it.
+
+{_environment_brief(p)}
+
+{_auth_brief(p)}
+
+Then work the surface systematically. For each endpoint: does the implementation
+match what is declared? Who is allowed to call it, and does the code actually
+check that? What happens on the error paths, and with a large or hostile input?
+
+{spec_line}
+
+The structural questions a tool can answer for you. The ones it cannot — is this
+endpoint scoped to the caller's tenant, is this check the right check — need you
+to read the handler and compare it against its neighbours. Endpoints in the same
+file that disagree with each other are where the defects are.
+
+{prove}
+
+{filing}"""
+
+
+def surface(config: SystemConfig, mode: str) -> str:
+    p = _profile(config)
+    if not p.environment.is_reachable or not p.environment.web_url:
+        return f"""There is no running UI for the application at `{_where(config)}`, so there is
+nothing for you to explore.
+
+Report that in your final message and stop. Do not substitute reading the
+frontend source for driving it: your entire value is that you see what a user
+sees, and a static read of a component is a different, weaker claim that another
+agent is better placed to make."""
+
+    scope = (
+        "Walk the primary journeys from the task graph only. This run is time-boxed, "
+        "so depth on the critical paths beats coverage."
+        if mode == "pr-check"
+        else "Walk the primary journeys from the task graph first, then explore. "
+        "Exploratory wandering is where you find what nobody wrote a test for — "
+        "take the paths a confused or impatient user would take."
+    )
+    return f"""Explore the running product at {p.environment.web_url} as a user experiences it.
+
+{p.description.strip()}
+
+Start with `get_system_map` for `ui_routes` and `task_graph`. That is your itinerary.
+
+{_environment_brief(p)}
+
+{_auth_brief(p)}
+
+{scope}
+
+At every step: read the page, check the console, interact, observe what changed.
+When something is wrong, find the shortest path to it, then capture a screenshot
+and the console output as evidence before moving on.
+
+Judge like a user, not like a reviewer with opinions about the code. Report what
+fails, misleads, blocks or excludes someone. Do not report what you would have
+designed differently."""
+
+
+def forge(envelope: DefectEnvelope, config: SystemConfig, flake_runs: int) -> str:
+    p = _profile(config)
+    evidence = "\n".join(f"  - {e.type.value}: {e.uri} {e.note}".rstrip() for e in envelope.evidence)
+    managed = p.environment.is_managed
+    pinning = (
+        "Pin the environment with `env_control` — a known fixture, known flags, a "
+        "known branch — so the reproduction runs identically later."
+        if managed
+        else "You cannot reset this environment, so pin what you can and record the "
+        "rest: note in `environment` exactly what state you found it in. An "
+        "unpinnable reproduction is worth recording as such, not worth faking."
+    )
+    return f"""Reproduce this finding, or demote it.
+
+  id:         {envelope.id}
+  reported by {envelope.discovered_by} as {envelope.severity.value} / {envelope.domain.value}
+  title:      {envelope.title}
+  summary:    {envelope.summary}
+  location:   {envelope.location.model_dump(exclude_none=True)}
+  confidence: {envelope.confidence:.2f}
+  evidence:
+{evidence or "  (none attached)"}
+
+The application is at `{_where(config)}`, which is your working directory. {pinning}
+
+Find the shortest path that makes the defect appear. Write a failing test for it
+under `qa/repro/` on a `qa/repro/*` branch, and run it {flake_runs} times with
+`run_n_times` to measure flake.
+
+Finish by calling `record_reproduction` with your verdict. If you could not make
+it happen, say `not_reproducible` and lower the confidence to match. That is a
+useful, correct outcome — it is the filter this whole system depends on, and
+passing through a finding you could not reproduce costs more than dropping a
+real one."""
+
+
+def clerk(config: SystemConfig, cap: int) -> str:
+    p = _profile(config)
+    owners = (
+        f"Resolve component and team from the system map's ownership section, which "
+        f"came from `{p.layout.ownership}`."
+        if p.layout.ownership
+        else "This repository records no ownership, so file unassigned and say so. "
+        "Do not infer a team from a directory name."
+    )
+    return f"""Triage this run's findings and file what deserves to be filed.
+
+Call `list_envelopes` with `fileable_only: true` to see what reached you.
+Findings that failed the evidence or confidence gate are not in that list and are
+not yours to file — they are already in the human review queue.
+
+For each one, in this order:
+
+1. `search_similar` and `get_occurrences` first. An existing ticket gets the new
+   evidence and an incremented count, not a second ticket.
+2. Score severity against the rubric, by consequence to users.
+3. {owners}
+4. Compose the ticket in the house format, with FORGE's steps verbatim and the
+   failing test as the acceptance criterion.
+5. Route by class. Security findings go to the restricted project.
+6. `record` the defect in memory with its ticket key, so the next run dedupes
+   against it.
+
+You may file at most {cap} tickets in this run. If you reach that, stop and
+escalate rather than filing more."""
+
+
+def proof(ticket_key: str, envelope: DefectEnvelope | None, branch: str) -> str:
+    repro = ""
+    if envelope:
+        steps = "\n".join(f"    {i}. {s}" for i, s in enumerate(envelope.reproduction.steps, 1))
+        repro = f"""
+The original finding:
+
+  title:        {envelope.title}
+  failing test: {envelope.reproduction.failing_test or "(none recorded)"}
+  environment:  {envelope.reproduction.environment.model_dump()}
+  steps:
+{steps or "    (none recorded)"}
+"""
+    return f"""Verify the fix on ticket {ticket_key}, on branch `{branch}`.
+{repro}
+Bring up the patched build with `env_control`, using the same fixture and flags
+as the original reproduction — a different environment proves nothing.
+
+Run the original failing test first. It must now pass. Then run the regression
+suite for the affected area, selected with `affected_tests` against the diff.
+
+Return exactly one verdict — VERIFIED, NOT_FIXED or REGRESSED — and transition
+the ticket accordingly. Say what you actually observed, including anything you
+skipped or could not run."""
+
+
+def mender(
+    ticket_key: str,
+    envelope: DefectEnvelope | None,
+    config: SystemConfig | None = None,
+) -> str:
+    """The fix task. MENDER is Phase 3; the conductor's loop calls this once it exists."""
+    where = f"the application at `{_where(config)}`" if config and config.profile else "the target application"
+    detail = ""
+    if envelope:
+        steps = "\n".join(f"    {i}. {s}" for i, s in enumerate(envelope.reproduction.steps, 1))
+        detail = f"""
+  title:        {envelope.title}
+  summary:      {envelope.summary}
+  location:     {envelope.location.model_dump(exclude_none=True)}
+  failing test: {envelope.reproduction.failing_test or "(none recorded)"}
+  steps:
+{steps or "    (none recorded)"}
+"""
+    return f"""Fix ticket {ticket_key} in {where}.
+{detail}
+Read the affected code with the system map for context, then write the smallest
+change that makes the failing test pass. Add a regression test. Run the affected
+suite locally before you open anything.
+
+The failing test defines success and you may not edit it. If you believe the test
+itself is wrong, that is an escalation, not a licence to change it.
+
+Work on a `fix/*` branch. Open the pull request as a draft with a rollback note.
+Never merge — merge is a human decision."""
+
+
+def arbiter(ticket_key: str, envelope: DefectEnvelope | None = None) -> str:
+    """The adversarial review task. ARBITER is Phase 3."""
+    context = ""
+    if envelope:
+        context = (
+            f"\n\nThe defect it claims to fix: {envelope.title}\n"
+            f"The test that defines success: {envelope.reproduction.failing_test or '(none recorded)'}\n"
+        )
+    return f"""Review the fix for {ticket_key} as an adversarial reviewer.{context}
+
+Does the change address the root cause or only the symptom? Is the diff minimal?
+Does it break a contract, a schema, or a public API? Does it introduce a security
+or performance regression? Are the regression tests real, or asserted to pass?
+Is the rollback note viable?
+
+Return APPROVE, REQUEST_CHANGES with specifics, or ESCALATE_TO_HUMAN. You have no
+write access to code: your judgement is the deliverable."""

qaas/trace.py

@@ -0,0 +1,270 @@
+"""Reading the run ledger back: the timeline behind `qaas trace` and `qaas show`.
+
+The ledger has always been the richest thing a run produces -- every dispatch,
+every tool call, every guardrail refusal, every verdict, appended in order (§8).
+Nothing could read it. `qaas show` looked at exactly one of the 28 kinds
+(`denial`) and printed no cost, no mode, no duration, no verdicts. So the audit
+trail existed and the audit did not.
+
+This module is *read-only over an append-only file*. It never writes, and it
+holds no opinion about what a run should have done -- it renders what the run
+recorded. The one performance rule that shapes it: `RunStore.ledger(kind)` is a
+full-file linear scan, so callers read the file **once** here and filter the
+list in memory, rather than scanning it once per kind of interest.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Iterable, Sequence
+
+from qaas.store import LedgerEntry, LedgerKind, RunStore
+
+#: How much of a rendered detail line to keep before truncating. A `verdict`
+#: carries paragraphs of observed behaviour and a `denial` carries the agent's
+#: whole Bash command; a timeline that wraps for ten lines is not a timeline.
+DETAIL_WIDTH = 110
+
+#: Fields worth showing per kind, in the order they read best. Anything not
+#: listed falls back to "every key, in insertion order" -- a new kind is still
+#: legible before anyone teaches this table about it.
+DETAIL_FIELDS: dict[LedgerKind, tuple[str, ...]] = {
+    LedgerKind.RUN_STARTED: ("mode", "agents", "budget_usd", "target_sha", "target_dirty"),
+    LedgerKind.RUN_FINISHED: ("agents_run", "cost_usd", "failed", "stopped_early"),
+    LedgerKind.AGENT_STARTED: ("model", "task_chars", "task_preview"),
+    LedgerKind.AGENT_FINISHED: ("subtype", "cost_usd", "num_turns", "envelopes", "error"),
+    LedgerKind.TOOL_CALL: ("tool", "allowed"),
+    LedgerKind.DENIAL: ("tool", "reason"),
+    LedgerKind.ENVELOPE: ("severity", "domain", "confidence", "envelope_id"),
+    LedgerKind.REPRODUCTION: ("status", "fileable", "flake_rate", "envelope_id"),
+    LedgerKind.TICKET: ("action", "key", "severity", "envelope_id"),
+    LedgerKind.VERDICT: ("ticket_key", "verdict", "observed"),
+    LedgerKind.REVIEW: ("ticket_key", "decision", "reasoning"),
+    LedgerKind.VERIFIED: ("ticket_key", "reopens"),
+    LedgerKind.REOPENED: ("ticket_key", "attempt"),
+    LedgerKind.REVIEW_ROUND_TRIP: ("ticket_key", "trip"),
+    LedgerKind.ESCALATION: ("reason",),
+    LedgerKind.SKIPPED: ("reason",),
+    LedgerKind.VCS: ("action", "branch", "path", "sha"),
+    LedgerKind.ENV: ("action", "services", "role", "fixture"),
+    LedgerKind.SYSTEM_MAP: ("version", "sections"),
+    LedgerKind.CONTRACT_TEST: ("endpoint", "path"),
+    LedgerKind.DEFECT_MEMORY: ("action", "ticket_key", "fingerprint"),
+    LedgerKind.AGENT_ERROR: ("error",),
+    LedgerKind.STOP_BLOCKED: ("missing",),
+    LedgerKind.CONTRACT_UNMET: ("missing", "reason"),
+    LedgerKind.SKILLS_MISSING: ("missing", "declared"),
+    LedgerKind.TOOL_ERROR: ("tool",),
+    LedgerKind.DRY_RUN: ("tool",),
+    LedgerKind.REGRESSION: ("fingerprint", "ticket_key"),
+}
+
+
+def read_ledger(store: RunStore) -> list[LedgerEntry]:
+    """The whole ledger, in order, in one pass. Filter the result, not the file."""
+    return list(store.ledger())
+
+
+def parse_kinds(names: Iterable[str]) -> list[LedgerKind]:
+    """Validate `--kind` arguments against the enum.
+
+    Raises ValueError naming the offender and the legal set, because "no output"
+    is what a mistyped filter used to look like and it is indistinguishable from
+    "this run has none of those".
+    """
+    kinds: list[LedgerKind] = []
+    for name in names:
+        try:
+            kinds.append(LedgerKind(name))
+        except ValueError:
+            legal = ", ".join(sorted(k.value for k in LedgerKind))
+            raise ValueError(f"unknown ledger kind {name!r}. Known kinds: {legal}") from None
+    return kinds
+
+
+def select(
+    entries: Sequence[LedgerEntry],
+    *,
+    agent: str | None = None,
+    kinds: Sequence[LedgerKind] | None = None,
+) -> list[LedgerEntry]:
+    """Filter in memory. Agent match is case-insensitive; agent names are shouted."""
+    wanted = set(kinds) if kinds else None
+    name = agent.upper() if agent else None
+    return [
+        e for e in entries
+        if (wanted is None or e.kind in wanted)
+        and (name is None or (e.agent or "").upper() == name)
+    ]
+
+
+def _short(value: Any) -> str:
+    if isinstance(value, list):
+        return f"[{len(value)}]" if len(value) > 4 else ", ".join(str(v) for v in value)
+    if isinstance(value, float):
+        return f"{value:.4g}"
+    # Newlines are the reason a `verdict` used to be unprintable on one line.
+    text = " ".join(str(value).split())
+    # A dedupe fingerprint is 71 characters of hex that nobody reads in full; a
+    # prefix is still enough to see two entries carry the same one. `qaas trace
+    # --json` keeps the whole thing, which is where an exact match belongs.
+    if text.startswith("sha256:"):
+        return text[: len("sha256:") + 8] + "…"
+    return text
+
+
+def describe(entry: LedgerEntry, *, width: int = DETAIL_WIDTH) -> str:
+    """One line of detail for one entry, truncated to stay in a column."""
+    detail = entry.detail
+    fields = DETAIL_FIELDS.get(entry.kind) or tuple(detail)
+    bits = []
+    for key in fields:
+        value = detail.get(key)
+        if value is None or value == "" or value == []:
+            continue  # an absent field is noise; False and 0 are findings
+        bits.append(_short(value) if len(fields) == 1 else f"{key}={_short(value)}")
+    text = "  ".join(bits)
+    return text if len(text) <= width else text[: width - 1] + "…"
+
+
+@dataclass
+class Row:
+    """One printable line of the timeline.
+
+    `count` > 1 means consecutive identical-kind entries were folded together.
+    """
+
+    at: datetime
+    offset_s: float
+    agent: str
+    kind: str
+    detail: str
+    cost_usd: float | None = None
+    count: int = 1
+
+
+def _fold_tool_calls(run: list[LedgerEntry]) -> str:
+    tools: dict[str, int] = {}
+    for e in run:
+        tools[str(e.detail.get("tool", "?"))] = tools.get(str(e.detail.get("tool", "?")), 0) + 1
+    ranked = sorted(tools.items(), key=lambda kv: (-kv[1], kv[0]))
+    shown = ", ".join(f"{t}×{n}" for t, n in ranked[:6])
+    return shown + (f", +{len(ranked) - 6} more" if len(ranked) > 6 else "")
+
+
+def timeline(entries: Sequence[LedgerEntry], *, fold_tool_calls: bool = True) -> list[Row]:
+    """Rows in run order, with cost accumulating.
+
+    A real run logs ~2400 `tool_call` lines against ~150 of everything else, so
+    printing one row each buries the dispatches, denials and verdicts that are
+    the point of looking. Consecutive tool calls by the same agent fold into a
+    single row that names the tools and how many -- folding only *consecutive*
+    runs, so an interleaved denial still lands in the right place and the order
+    stays honest. `--json` is exempt: an export must be faithful, not readable.
+    """
+    if not entries:
+        return []
+    origin = entries[0].at
+    rows: list[Row] = []
+    running = 0.0
+    i = 0
+    while i < len(entries):
+        entry = entries[i]
+        span = 1
+        if fold_tool_calls and entry.kind == LedgerKind.TOOL_CALL:
+            while (
+                i + span < len(entries)
+                and entries[i + span].kind == LedgerKind.TOOL_CALL
+                and entries[i + span].agent == entry.agent
+            ):
+                span += 1
+        cost = entry.detail.get("cost_usd") if entry.kind == LedgerKind.AGENT_FINISHED else None
+        if isinstance(cost, (int, float)):
+            running += float(cost)
+        rows.append(
+            Row(
+                at=entry.at,
+                offset_s=(entry.at - origin).total_seconds(),
+                agent=entry.agent or "-",
+                kind=str(entry.kind),
+                detail=describe(entry) if span == 1 else _fold_tool_calls(entries[i : i + span]),
+                cost_usd=running if cost is not None else None,
+                count=span,
+            )
+        )
+        i += span
+    return rows
+
+
+@dataclass
+class RunSummary:
+    """The header facts about a run, all of them read back from the ledger.
+
+    Deliberately derived rather than stored: a run that was killed mid-flight
+    never wrote `run_finished`, and it is exactly that run someone needs to look
+    at. Everything here degrades to None instead of raising.
+    """
+
+    run_id: str
+    mode: str | None = None
+    started: datetime | None = None
+    finished: datetime | None = None
+    target_sha: str | None = None
+    target_dirty: bool | None = None
+    budget_usd: float | None = None
+    agents: list[str] = field(default_factory=list)
+    cost_usd: float = 0.0
+    escalations: list[str] = field(default_factory=list)
+    #: ticket key -> its latest verdict, or None if PROOF never reached it.
+    tickets: dict[str, str | None] = field(default_factory=dict)
+    counts: dict[str, int] = field(default_factory=dict)
+    stopped_early: str | None = None
+    completed: bool = False
+
+    @property
+    def duration_s(self) -> float | None:
+        if self.started is None or self.finished is None:
+            return None
+        return (self.finished - self.started).total_seconds()
+
+
+def summarise(store: RunStore, entries: Sequence[LedgerEntry] | None = None) -> RunSummary:
+    """Fold a run's ledger into the header `qaas show` prints."""
+    entries = list(entries) if entries is not None else read_ledger(store)
+    summary = RunSummary(run_id=store.run_id)
+    if entries:
+        summary.started = entries[0].at
+        summary.finished = entries[-1].at
+
+    for entry in entries:
+        summary.counts[str(entry.kind)] = summary.counts.get(str(entry.kind), 0) + 1
+        detail = entry.detail
+        if entry.kind == LedgerKind.RUN_STARTED:
+            summary.mode = detail.get("mode")
+            summary.budget_usd = detail.get("budget_usd")
+            summary.agents = list(detail.get("agents") or [])
+            summary.target_sha = detail.get("target_sha")
+            summary.target_dirty = detail.get("target_dirty")
+        elif entry.kind == LedgerKind.RUN_FINISHED:
+            summary.completed = True
+            summary.stopped_early = detail.get("stopped_early")
+        elif entry.kind == LedgerKind.ESCALATION:
+            reason = detail.get("reason")
+            if reason:
+                summary.escalations.append(str(reason))
+        elif entry.kind == LedgerKind.TICKET and detail.get("key"):
+            summary.tickets.setdefault(str(detail["key"]), None)
+        elif entry.kind == LedgerKind.VERDICT and detail.get("ticket_key"):
+            # Last verdict wins, matching how the conductor itself reads these
+            # back (`_latest_verdict`); a reopened ticket is verdicted twice.
+            summary.tickets[str(detail["ticket_key"])] = detail.get("verdict")
+        elif entry.kind == LedgerKind.VERIFIED and detail.get("ticket_key"):
+            summary.tickets[str(detail["ticket_key"])] = "VERIFIED"
+
+    # Cost comes from the per-invocation result files, not from summing ledger
+    # lines: `put_result` writes one file per invocation precisely so repeated
+    # agents (FORGE, MENDER) are not under-counted, and this must agree with
+    # `qaas runs`.
+    summary.cost_usd = store.total_cost_usd()
+    return summary