{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/devtune/json-schema/devtune-agent-picks-actions-data-schema.json",
  "title": "AgentPicksActionsData",
  "x-generated": "2026-11-16",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/devtune-openapi.json#/components/schemas/AgentPicksActionsData",
  "type": "object",
  "required": [
    "actions",
    "next_offset",
    "incomplete",
    "pagination",
    "setup"
  ],
  "properties": {
    "setup": {
      "$ref": "#/$defs/AgentPicksSetupUsed"
    },
    "incomplete": {
      "type": "boolean",
      "description": "Some stored Action rows could not be read. Valid rows remain available."
    },
    "next_offset": {
      "type": [
        "integer",
        "null"
      ],
      "deprecated": true,
      "description": "Deprecated: pass pagination.nextCursor as cursor. Null on the last page."
    },
    "pagination": {
      "$ref": "#/$defs/ListPagination"
    },
    "actions": {
      "description": "Agent Picks Actions for the setup, newest first.",
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "action",
          "retest",
          "result"
        ],
        "properties": {
          "action": {
            "type": "object",
            "required": [
              "id",
              "title",
              "description",
              "state",
              "portfolio_rank",
              "evidence",
              "agent_prompt"
            ],
            "properties": {
              "id": {
                "type": "string",
                "format": "uuid"
              },
              "title": {
                "type": "string"
              },
              "description": {
                "type": "string",
                "description": "What the test found behind the Action, such as how many completed runs picked the tool in each cell, and any locked pages the fix steers around."
              },
              "state": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The Action's status in Actions: suggested, accepted, live or archived. Null when it has none."
              },
              "portfolio_rank": {
                "type": [
                  "integer",
                  "null"
                ],
                "description": "One-based position in the project recommendation queue while state is suggested. An Action that has left the queue keeps the position it last held."
              },
              "agent_prompt": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "The drafted fix as a Markdown prompt for a coding agent: the brief, what agents picked instead and how often, target files or pages, the acceptance check and every locked page the fix steers around. Null unless the key also holds actions.read, which brief reads require, and until the Action brief is ready and still current. It is a draft for human review and publishes nothing."
              },
              "evidence": {
                "type": "object",
                "description": "Pinned baseline test_id, origin, series, loss_key, tool_key, install measurement, run_ids, failed_fetches and locked_urls. A self-run Action (origin self_run) names its series, with repository always null (read the test for it), and its loss_key names that series, so it never folds into a managed Action or another series'; it has no managed re-test. An Action kept after its self-run test was deleted has no run_ids, no run evidence (run_evidence_available false) and an empty failed_fetches; a run deleted from a test that keeps others leaves its Actions' run_ids, runs and failed_fetches. A cell Action has cell; a reason Action has reason and cells, aggregate counts and run evidence, without a first-cell claim. An observation reason (own_url_failed, own_install_failed, own_tool_not_observed or own_tool_tried) also has observation_counts, each cell's winners and, optionally, context_failures by URL origin; an own_tool_not_observed reason also lists fetched_origins, the URL origins its agents fetched; its failed_fetches is empty and its cells carry only their identity, baseline, winners and run_ids. On every Action, every failed_fetches url is an origin only, and so is a fetch reason's url unless the reason has an own target; an own_url_failed url, and a fetch reason’s with an own target, keeps its path; no URL carries userinfo, a query or a fragment; run evidence keeps only decidedBy, reason_key, candidates, toolPackages, buildingBlockPackages, diffEmpty and diffTruncated. Rates and re-tests use the full-cell baselines, never the observation counts.",
                "required": [
                  "test_id",
                  "origin",
                  "series",
                  "loss_key",
                  "tool_key",
                  "baseline",
                  "failed_fetches",
                  "locked_urls"
                ],
                "anyOf": [
                  {
                    "required": [
                      "cell"
                    ],
                    "properties": {
                      "kind": {
                        "enum": [
                          "cell"
                        ]
                      }
                    }
                  },
                  {
                    "required": [
                      "kind",
                      "reason",
                      "cells"
                    ],
                    "properties": {
                      "kind": {
                        "const": "reason"
                      }
                    }
                  }
                ],
                "properties": {
                  "test_id": {
                    "type": "string",
                    "format": "uuid"
                  },
                  "origin": {
                    "$ref": "#/$defs/AgentPicksOrigin"
                  },
                  "series": {
                    "$ref": "#/$defs/AgentPicksTestSeries"
                  },
                  "loss_key": {
                    "type": "string",
                    "description": "Identifies the loss the Action addresses."
                  },
                  "kind": {
                    "type": "string",
                    "enum": [
                      "cell",
                      "reason"
                    ]
                  },
                  "reason": {
                    "type": "object",
                    "description": "fetch and classifier name a shared failed fetch or recorded reason; a fetch on the customer’s own domain or registry package carries that target, and a classifier key that is not a short key is empty. own_url_failed is an own URL (no query or fragment) that returned an error, with its domain or registry package target, its most frequent status_code and status_counts, every status with its runs; own_install_failed is an exact own package whose install failed; own_tool_not_observed is a job whose trails show no fetch, install or search of the own tool; own_tool_tried is a job whose trails show the own tool searched for, fetched or installed before the run picked another tool or built its own, with its most common trails.",
                    "required": [
                      "kind"
                    ],
                    "properties": {
                      "kind": {
                        "description": "The kind of reason, as described above.",
                        "type": "string",
                        "enum": [
                          "fetch",
                          "classifier",
                          "own_url_failed",
                          "own_install_failed",
                          "own_tool_not_observed",
                          "own_tool_tried"
                        ]
                      },
                      "url": {
                        "type": "string",
                        "description": "The failed URL, for a fetch or own_url_failed reason."
                      },
                      "status_code": {
                        "type": "integer",
                        "description": "Its most frequent HTTP status."
                      },
                      "status_counts": {
                        "type": "array",
                        "description": "own_url_failed only: each status the grouped runs failed with and how many runs did.",
                        "items": {
                          "type": "object",
                          "required": [
                            "status_code",
                            "runs"
                          ],
                          "properties": {
                            "status_code": {
                              "type": "integer",
                              "description": "An HTTP status the runs failed with."
                            },
                            "runs": {
                              "type": "integer",
                              "description": "Runs that failed with it."
                            }
                          }
                        }
                      },
                      "key": {
                        "type": "string",
                        "description": "The recorded reason key, for a classifier reason. Empty when it is not a short key."
                      },
                      "target": {
                        "description": "The customer's own domain or registry package the reason concerns.",
                        "type": "object",
                        "required": [
                          "kind"
                        ],
                        "properties": {
                          "kind": {
                            "type": "string",
                            "enum": [
                              "domain",
                              "package"
                            ]
                          },
                          "domain": {
                            "type": "string",
                            "description": "The domain, for a domain target."
                          },
                          "ecosystem": {
                            "description": "The package registry, for a package target.",
                            "type": "string",
                            "enum": [
                              "npm",
                              "gem",
                              "pypi"
                            ]
                          },
                          "name": {
                            "type": "string"
                          }
                        }
                      },
                      "package": {
                        "description": "The own package whose install failed, for own_install_failed.",
                        "type": "object",
                        "required": [
                          "ecosystem",
                          "name"
                        ],
                        "properties": {
                          "ecosystem": {
                            "description": "The package registry.",
                            "type": "string",
                            "enum": [
                              "npm",
                              "gem",
                              "pypi"
                            ]
                          },
                          "name": {
                            "type": "string"
                          }
                        }
                      },
                      "job": {
                        "type": "string",
                        "description": "The job the runs were given, for a job reason."
                      },
                      "frameworks": {
                        "description": "The test apps the runs used.",
                        "type": "array",
                        "items": {
                          "type": "string"
                        }
                      },
                      "trails": {
                        "type": "array",
                        "description": "own_tool_tried only: up to five of the most common trails, most runs first. steps are what the run did with the own tool, each once in the order it first happened: searched (a search naming it), fetched (its domain or registry package), installed (a plain install that succeeded) or install_unconfirmed (any other install of its package). outcome is what the run ended on: installed (after the last own-tool step of the run, a plain install of a package of that tool that succeeded) or picked (any other pick of it, a stated pick included), naming tool_key and tool_name, or built_its_own. These are observations, not causes.",
                        "items": {
                          "type": "object",
                          "required": [
                            "steps",
                            "outcome",
                            "tool_key",
                            "tool_name",
                            "runs"
                          ],
                          "properties": {
                            "steps": {
                              "description": "What the run did with the own tool, in order.",
                              "type": "array",
                              "items": {
                                "type": "string",
                                "enum": [
                                  "searched",
                                  "fetched",
                                  "installed",
                                  "install_unconfirmed"
                                ]
                              }
                            },
                            "outcome": {
                              "description": "What the run ended up doing.",
                              "type": "string",
                              "enum": [
                                "installed",
                                "picked",
                                "built_its_own"
                              ]
                            },
                            "tool_key": {
                              "type": [
                                "string",
                                "null"
                              ],
                              "description": "The tool the run picked instead. Null when it built its own."
                            },
                            "tool_name": {
                              "type": [
                                "string",
                                "null"
                              ],
                              "description": "That tool's name. Null when it built its own."
                            },
                            "runs": {
                              "type": "integer",
                              "description": "Runs that followed this trail."
                            }
                          }
                        }
                      },
                      "coverage": {
                        "type": "object",
                        "description": "own_tool_not_observed only: the docs coverage check its title follows, absent until the check runs after the test completes. missing means none of the pages_checked owned pages mentions framework; unchecked means anything else, including no owned content held, and its pages are candidates that mention framework and the tool or a job term, claimed as nothing more. After the test completes, the candidates are judged: exists_not_fetched means a candidate in pages documents the job in framework and agents never fetched it, using the entry_points instead (empty when they used none of yours); missing with a judgment means every candidate was judged not to document it. entry_points on unchecked are owned pages agents in the group's runs fetched.",
                        "required": [
                          "status",
                          "pages"
                        ],
                        "properties": {
                          "status": {
                            "description": "The coverage check's result, as described above.",
                            "type": "string",
                            "enum": [
                              "missing",
                              "exists_not_fetched",
                              "unchecked"
                            ]
                          },
                          "framework": {
                            "type": "string",
                            "description": "The framework the check looked for."
                          },
                          "pages": {
                            "description": "The owned pages the result names.",
                            "type": "array",
                            "items": {
                              "type": "string"
                            }
                          },
                          "pages_checked": {
                            "type": "integer",
                            "description": "missing and unchecked: how many owned pages the check read."
                          },
                          "entry_points": {
                            "type": "array",
                            "description": "Plain labels for owned pages agents fetched successfully, such as npm README or llms.txt, never URLs or paths.",
                            "items": {
                              "type": "string"
                            }
                          },
                          "pages_incomplete": {
                            "type": "boolean",
                            "description": "unchecked only: true when some candidate is not listed in pages."
                          },
                          "judgment": {
                            "type": "object",
                            "description": "missing and exists_not_fetched only: present when the result comes from judging the candidates, not from a keyword match.",
                            "required": [
                              "model",
                              "question_version",
                              "threshold",
                              "pages_judged",
                              "judged_at"
                            ],
                            "properties": {
                              "model": {
                                "type": "string",
                                "description": "The judging model release."
                              },
                              "question_version": {
                                "type": "integer",
                                "description": "Version of the judging question."
                              },
                              "threshold": {
                                "type": "number",
                                "description": "The confidence a verdict needed; pages judged below it decided nothing."
                              },
                              "pages_judged": {
                                "type": "integer",
                                "description": "How many candidate pages the judgment answered; a page whose check failed is not counted."
                              },
                              "judged_at": {
                                "type": "string",
                                "format": "date-time"
                              }
                            }
                          }
                        }
                      }
                    }
                  },
                  "observation_counts": {
                    "type": "object",
                    "description": "Runs and cells where an observation reason holds, and the runs counted apart from it.",
                    "required": [
                      "runs",
                      "cells",
                      "own_tool_seen_runs",
                      "evidence_unavailable_runs",
                      "recovery_unknown_runs"
                    ],
                    "properties": {
                      "runs": {
                        "type": "integer",
                        "description": "Runs where the observation holds."
                      },
                      "cells": {
                        "type": "integer",
                        "description": "Cells those runs fall in."
                      },
                      "own_tool_seen_runs": {
                        "type": "integer",
                        "description": "Runs in the covered cells whose trail shows the own tool searched for, fetched or installed. On an own_tool_tried reason these are the reason's own runs; on any other reason they are counted apart from it."
                      },
                      "evidence_unavailable_runs": {
                        "type": "integer",
                        "description": "Runs whose trail is missing or incomplete, counted apart from the observation."
                      },
                      "recovery_unknown_runs": {
                        "type": "integer",
                        "description": "Runs whose trail recovery is unknown, counted apart."
                      }
                    }
                  },
                  "context_failures": {
                    "type": "array",
                    "description": "Other parties' failed fetches on an observation reason Action, by URL origin only.",
                    "items": {
                      "type": "object",
                      "required": [
                        "origin",
                        "status_code",
                        "runs"
                      ],
                      "properties": {
                        "origin": {
                          "type": "string"
                        },
                        "status_code": {
                          "type": "integer"
                        },
                        "runs": {
                          "type": "integer",
                          "description": "Runs that hit it."
                        }
                      }
                    }
                  },
                  "fetched_origins": {
                    "type": "array",
                    "description": "The URL origins an own_tool_not_observed reason Action's agents fetched, by origin only, most fetched first.",
                    "items": {
                      "type": "object",
                      "required": [
                        "origin",
                        "runs"
                      ],
                      "properties": {
                        "origin": {
                          "type": "string",
                          "description": "The URL origin."
                        },
                        "runs": {
                          "type": "integer",
                          "description": "Runs that fetched it."
                        }
                      }
                    }
                  },
                  "cells": {
                    "description": "The losing cells the reason covers.",
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "test_id",
                        "loss_key",
                        "cell",
                        "baseline"
                      ],
                      "properties": {
                        "test_id": {
                          "type": "string",
                          "format": "uuid"
                        },
                        "loss_key": {
                          "type": "string",
                          "description": "Identifies the cell's loss."
                        },
                        "cell": {
                          "description": "The cell: test app, intent, agent and model.",
                          "type": "object",
                          "additionalProperties": true
                        },
                        "baseline": {
                          "$ref": "#/$defs/AgentPicksInstallMeasurement"
                        },
                        "winners": {
                          "type": "array",
                          "description": "What won the cell's runs. Always present on an observation reason's cells.",
                          "items": {
                            "type": "object",
                            "required": [
                              "outcome",
                              "tool_key",
                              "tool_name",
                              "runs"
                            ],
                            "properties": {
                              "outcome": {
                                "description": "installed or built_its_own.",
                                "type": "string",
                                "enum": [
                                  "installed",
                                  "built_its_own"
                                ]
                              },
                              "tool_key": {
                                "type": [
                                  "string",
                                  "null"
                                ],
                                "description": "The winning tool. Null when the runs built their own."
                              },
                              "tool_name": {
                                "type": [
                                  "string",
                                  "null"
                                ],
                                "description": "Its name. Null when the runs built their own."
                              },
                              "runs": {
                                "type": "integer",
                                "description": "Runs it won."
                              }
                            }
                          }
                        }
                      }
                    }
                  },
                  "tool_key": {
                    "type": "string",
                    "description": "The customer's own tool the Action is about."
                  },
                  "cell": {
                    "description": "The losing cell, for a cell Action.",
                    "type": "object",
                    "properties": {
                      "environment_id": {
                        "type": "string",
                        "format": "uuid"
                      },
                      "environment_name": {
                        "type": "string",
                        "description": "The test app."
                      },
                      "intent": {
                        "type": "string",
                        "enum": [
                          "add",
                          "recommend",
                          "hosted",
                          "improve"
                        ]
                      },
                      "agent": {
                        "type": "string"
                      },
                      "model": {
                        "type": "string"
                      }
                    }
                  },
                  "baseline": {
                    "$ref": "#/$defs/AgentPicksInstallMeasurement"
                  },
                  "runs": {
                    "description": "The runs behind the Action, with what each picked.",
                    "type": "array",
                    "items": {
                      "type": "object",
                      "properties": {
                        "run_id": {
                          "type": "string",
                          "format": "uuid"
                        },
                        "outcome": {
                          "type": "string",
                          "description": "What the agent did."
                        },
                        "tool_key": {
                          "type": [
                            "string",
                            "null"
                          ],
                          "description": "The tool it picked: installed, or named as its choice without being written into the code. Null unless outcome is installed."
                        },
                        "confidence": {
                          "type": [
                            "number",
                            "null"
                          ],
                          "description": "How sure the classifier was, from 0 to 1. Null when not recorded."
                        },
                        "classifier_version": {
                          "type": "string",
                          "description": "The classifier version that judged the run."
                        },
                        "evidence": {
                          "description": "What the classifier saw.",
                          "type": "object",
                          "additionalProperties": true
                        }
                      }
                    }
                  },
                  "run_evidence_available": {
                    "type": "boolean",
                    "description": "Whether the runs' evidence can be read."
                  },
                  "run_ids": {
                    "description": "The runs behind the Action.",
                    "type": "array",
                    "items": {
                      "type": "string",
                      "format": "uuid"
                    }
                  },
                  "reason_run_ids": {
                    "type": "array",
                    "description": "A fetch reason's runs that hit its exact URL and status. Failed fetch URLs are origins only, so this is the reason's run count; each covered cell carries its own.",
                    "items": {
                      "type": "string",
                      "format": "uuid"
                    }
                  },
                  "failed_fetches": {
                    "description": "Fetches in the Action's runs that returned 400 or above. Empty on an own_url_failed, own_install_failed, own_tool_not_observed or own_tool_tried reason.",
                    "type": "array",
                    "items": {
                      "type": "object",
                      "properties": {
                        "run_id": {
                          "type": "string",
                          "format": "uuid"
                        },
                        "url": {
                          "type": "string",
                          "description": "The URL origin."
                        },
                        "status_code": {
                          "type": "integer"
                        }
                      }
                    }
                  },
                  "locked_urls": {
                    "description": "Locked pages the fix steers around.",
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "locked_urls_withheld": {
                    "type": "integer",
                    "description": "Locked pages left out of locked_urls because they cannot be shown safely. They are still steered around. Absent when every locked page is listed."
                  }
                }
              }
            }
          },
          "retest": {
            "description": "The Action's latest re-test. Null when none has started.",
            "type": [
              "object",
              "null"
            ],
            "properties": {
              "id": {
                "type": "string",
                "format": "uuid"
              },
              "status": {
                "type": "string"
              },
              "baseline_test_id": {
                "type": "string",
                "format": "uuid"
              },
              "action_id": {
                "type": "string",
                "format": "uuid"
              },
              "batch": {
                "type": "integer",
                "description": "Which batch of 8 runs the re-test is on, from 1 to 5. A re-test of several cells shares each batch among them."
              },
              "reserved_micros": {
                "type": "integer",
                "description": "Credits the re-test reserved, in credit micros (1 credit = 1,000,000)."
              },
              "settled_micros": {
                "type": [
                  "integer",
                  "null"
                ],
                "description": "Credits the re-test has charged so far, in credit micros. Starts at 0 and grows as its runs settle."
              },
              "refunded_micros": {
                "type": "integer",
                "description": "Unused credits returned, in credit micros."
              },
              "method": {
                "type": "string",
                "enum": [
                  "v1",
                  "v2"
                ],
                "description": "How the re-test decides its result, fixed when it starts: v2, or v1 for a re-test started before v2."
              }
            }
          },
          "result": {
            "description": "The re-test result. Null until the Action is marked done; then unmeasured until a re-test starts, still_measuring while it runs, and the re-test's result once it ends.",
            "type": [
              "object",
              "null"
            ],
            "properties": {
              "result": {
                "description": "What the re-test shows against the baseline: improved, mixed, no_clear_change, declined, still_measuring or unmeasured.",
                "type": "string",
                "enum": [
                  "improved",
                  "mixed",
                  "no_clear_change",
                  "declined",
                  "still_measuring",
                  "unmeasured"
                ]
              },
              "test_id": {
                "type": "string",
                "format": "uuid"
              },
              "baseline_test_id": {
                "type": "string",
                "format": "uuid"
              },
              "baseline": {
                "$ref": "#/$defs/AgentPicksInstallMeasurement"
              },
              "after": {
                "description": "The re-test's measurement. Null until it has one.",
                "anyOf": [
                  {
                    "$ref": "#/$defs/AgentPicksInstallMeasurement"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "cells": {
                "type": "array",
                "description": "Per-cell measurements for a reason-level Action.",
                "items": {
                  "type": "object",
                  "required": [
                    "cell",
                    "baseline",
                    "after",
                    "result"
                  ],
                  "properties": {
                    "cell": {
                      "type": "object",
                      "additionalProperties": {
                        "type": "string"
                      }
                    },
                    "baseline": {
                      "$ref": "#/$defs/AgentPicksInstallMeasurement"
                    },
                    "after": {
                      "description": "The cell's re-test measurement. Null until it has one.",
                      "anyOf": [
                        {
                          "$ref": "#/$defs/AgentPicksInstallMeasurement"
                        },
                        {
                          "type": "null"
                        }
                      ]
                    },
                    "result": {
                      "type": "string",
                      "enum": [
                        "improved",
                        "mixed",
                        "no_clear_change",
                        "declined",
                        "still_measuring",
                        "unmeasured"
                      ]
                    }
                  }
                }
              },
              "coverage_complete": {
                "type": "boolean",
                "description": "True when the re-test completed and every cell has a measured result."
              },
              "stop_reason": {
                "type": [
                  "string",
                  "null"
                ],
                "description": "ranges_separated when every cell's result was already clear at a batch check, so any runs still queued were cancelled. Null otherwise."
              },
              "measured_at": {
                "description": "When the result was measured. Null until then.",
                "type": [
                  "string",
                  "null"
                ],
                "format": "date-time"
              },
              "method": {
                "type": "string",
                "enum": [
                  "v1",
                  "v2"
                ],
                "description": "How the result was decided. v2 compares each cell’s pick rate with its baseline by the 90% interval on their difference, and its ranges are 90%. v1, a result from a re-test started before v2, compares 95% ranges, and its ranges are 95%; a v1 result is never restated."
              }
            }
          }
        }
      }
    }
  },
  "$defs": {
    "AgentPicksInstallMeasurement": {
      "type": "object",
      "description": "A re-test baseline or result for the Action’s tool. picks counts every completed run that picked it (every installed outcome, a stated pick included), and rate is that pick rate with its Wilson range, on both sides of the comparison. The range is 90% in the Action’s evidence. In a measured re-test result (baseline, after and cells) it is at the confidence of the result’s method, the one its verdict was decided at: 95% for v1, 90% for v2.",
      "required": [
        "picks",
        "runs",
        "planned",
        "rate",
        "rate_low",
        "rate_high",
        "completed_at"
      ],
      "properties": {
        "picks": {
          "type": "integer",
          "description": "Completed runs that picked the tool, a stated pick included."
        },
        "runs": {
          "type": "integer",
          "description": "The runs rate is over: completed runs, less unmatched-code guesses on the baseline side."
        },
        "planned": {
          "type": "integer"
        },
        "rate": {
          "type": "number",
          "description": "picks / runs in one cell. Over several cells (scenarios set), each cell’s picks over its runs, averaged."
        },
        "scenarios": {
          "type": "integer",
          "minimum": 1,
          "description": "The cells a measurement over several pools, each counted once; its range counts them. Absent for one cell and for measurements recorded before it."
        },
        "rate_low": {
          "type": "number",
          "description": "Lower bound of rate's Wilson range, at the confidence described above."
        },
        "rate_high": {
          "type": "number",
          "description": "Upper bound of rate's Wilson range, at the confidence described above."
        },
        "completed_at": {
          "type": "string",
          "format": "date-time",
          "description": "When the measured test ended."
        },
        "failed": {
          "type": "integer",
          "description": "Runs that failed. Re-test measurements only."
        },
        "not_run": {
          "type": "integer",
          "description": "Planned runs that never ran. Re-test measurements only."
        }
      }
    },
    "AgentPicksOrigin": {
      "type": "string",
      "enum": [
        "managed",
        "self_run"
      ],
      "description": "Where the runs ran: managed, in DevTune’s sandboxes, or self_run, on the customer’s own machine with the agentpicks CLI and uploaded. A self-run is never counted in a managed rate."
    },
    "AgentPicksSetupUsed": {
      "type": [
        "object",
        "null"
      ],
      "description": "The Agent Picks setup this response used: its id and its category slug (null for a setup saved without a category). null when the project has no setup.",
      "required": [
        "id",
        "category_slug"
      ],
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid"
        },
        "category_slug": {
          "type": [
            "string",
            "null"
          ],
          "description": "The setup’s category slug. Null for a setup saved without a category."
        }
      }
    },
    "AgentPicksTestSeries": {
      "type": [
        "object",
        "null"
      ],
      "additionalProperties": false,
      "description": "A self-run test’s series: the context its runs share. Rates within a self-run test compare runs of this series only. Null for a managed test.",
      "required": [
        "key",
        "period",
        "agent",
        "agent_version",
        "model",
        "stack",
        "lock_digest",
        "repository",
        "category",
        "intent"
      ],
      "properties": {
        "key": {
          "type": "string",
          "description": "The series key: a SHA-256, in hex, of the agent, version, model, starter and lock digest (or repository), category and request intent. Runs with the same key are one series."
        },
        "period": {
          "type": "string",
          "format": "date",
          "description": "The first day of the UTC month the test holds. A series has one test per month."
        },
        "agent": {
          "type": "string",
          "description": "The coding agent the runs used, such as claude_code."
        },
        "agent_version": {
          "type": [
            "string",
            "null"
          ],
          "description": "The agent version installed where the runs ran."
        },
        "model": {
          "type": "string",
          "description": "The model the agent was asked for; default is the agent’s own default."
        },
        "stack": {
          "type": [
            "string",
            "null"
          ],
          "description": "The starter test app the runs were laid down from. Null for a series of runs on the customer’s repository."
        },
        "lock_digest": {
          "type": [
            "string",
            "null"
          ],
          "description": "SHA-256 of the starter’s committed files and lockfiles. Null for a repository series."
        },
        "repository": {
          "type": [
            "string",
            "null"
          ],
          "description": "The customer’s repository, as host and path. Null for a starter series."
        },
        "category": {
          "type": [
            "string",
            "null"
          ],
          "description": "The slug of the category or project job the runs were given a request from."
        },
        "intent": {
          "type": "string",
          "description": "The intent of that request: add, recommend, hosted or improve."
        }
      }
    },
    "ListPagination": {
      "type": "object",
      "properties": {
        "hasMore": {
          "type": "boolean",
          "description": "More rows follow this page."
        },
        "nextCursor": {
          "type": [
            "string",
            "null"
          ],
          "description": "Pass as cursor to read the next page. Null on the last page."
        }
      },
      "required": [
        "hasMore",
        "nextCursor"
      ]
    }
  }
}