cmpnd 0.81.0__tar.gz → 0.82.0__tar.gz

{cmpnd-0.81.0 → cmpnd-0.82.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.81.0
+Version: 0.82.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>

{cmpnd-0.81.0 → cmpnd-0.82.0}/cmpnd/cli/commands/optimizations.py

@@ -6,7 +6,7 @@ import sys
 from argparse import ArgumentParser, _SubParsersAction
 from typing import Any
 
-from .. import api_client, deprecation, pagination
+from .. import api_client, deprecation, pagination, views
 from . import top
 
 
@@ -20,6 +20,7 @@ def _add_list_args(p: ArgumentParser) -> None:
     p.add_argument("--optimizer-type", help="Filter by optimizer type")
     p.add_argument("--min-score", type=float, help="Minimum best score")
     pagination.add_args(p, with_page_aliases=True, default_limit=50)
+    views.add_text_flag(p)
 
 
 def _add_comparability_args(p: ArgumentParser) -> None:
@@ -172,7 +173,8 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     failed.set_defaults(func=handle_compare_failed_examples)
 
     iters = sub.add_parser("iterations", help="List iterations for an optimization run")
-    iters.add_argument("id", help="Optimization run ID (UUID)")
+    iters.add_argument("id", help="Optimization run ID (op_...)")
+    views.add_text_flag(iters)
     iters.set_defaults(func=handle_iterations)
 
     cands = sub.add_parser(
@@ -187,6 +189,7 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         "optimization actually wrote. Off by default: the text dwarfs the metrics, "
         "and listing candidates is usually how you find the one worth reading",
     )
+    views.add_text_flag(cands)
     cands.set_defaults(func=handle_candidates)
 
     compiled = sub.add_parser(
@@ -226,7 +229,11 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
 def handle_list(client: api_client.ApiClient, args: Any) -> Any:
     if getattr(args, "status", None) == "queued":
-        return _list_queued(client, args)
+        payload = _list_queued(client, args)
+        if getattr(args, "text", False):
+            _render_queued(payload)
+            return None
+        return payload
     # This route paginates by page/per_page; the shared helper maps the
     # user-facing --limit/--offset onto that pair.
     body: dict[str, Any] = pagination.wire(args, "per_page")
@@ -239,7 +246,112 @@ def handle_list(client: api_client.ApiClient, args: Any) -> Any:
         val = getattr(args, attr, None)
         if val is not None:
             body[key] = val
-    return client.post("/api/v1/optimizations/search", json=body)
+    payload = client.post("/api/v1/optimizations/search", json=body)
+    if getattr(args, "text", False):
+        _render_runs(payload)
+        return None
+    return payload
+
+
+# The statuses of a run that has not settled. Serve's open set: `interrupted` is open and
+# not progressing, and any delivered progress returns it to `running`.
+_OPEN_STATUSES = ("running", "interrupted")
+
+# What a cell shows for a value serve does not hold. Never a zero: a zero is a value.
+_UNRECORDED = "-"
+
+
+def _rows(payload: Any, key: str) -> list[dict[str, Any]]:
+    items = payload.get(key) if isinstance(payload, dict) else None
+    return [item for item in items or [] if isinstance(item, dict)]
+
+
+def _table(header: tuple[str, ...], rows: list[tuple[str, ...]]) -> None:
+    """Print rows under a header, each column as wide as its widest cell."""
+    widths = [max(len(row[i]) for row in [header, *rows]) for i in range(len(header))]
+    for row in [header, *rows]:
+        print("  ".join(cell.ljust(widths[i]) for i, cell in enumerate(row)).rstrip())
+
+
+def _score(value: Any) -> str:
+    return f"{value:.3f}" if isinstance(value, (int, float)) and not isinstance(value, bool) else _UNRECORDED
+
+
+def _int(value: Any) -> str:
+    return str(value) if isinstance(value, int) and not isinstance(value, bool) else _UNRECORDED
+
+
+def _metric_calls(run: dict[str, Any]) -> str:
+    """Metric calls spent of the budget. An open run reads its live counter, which serve
+    keeps the total in step with; a settled run reads its total."""
+    used = run.get("total_metric_calls")
+    live = run.get("current_metric_calls")
+    if isinstance(live, int) and (not isinstance(used, int) or live > used):
+        used = live
+    budget = run.get("max_metric_calls")
+    if not isinstance(used, int):
+        return _UNRECORDED
+    return f"{used}/{budget}" if isinstance(budget, int) and budget > 0 else str(used)
+
+
+def _best_score(run: dict[str, Any]) -> str:
+    """The run's best score. Serve sends `best_score` as zero until the run records one,
+    and flags that with `best_score_recorded: false`. A serve that sends no flag leaves
+    an unrecorded score indistinguishable from a measured zero, so the score shows."""
+    if run.get("best_score_recorded") is False:
+        return _UNRECORDED
+    return _score(run.get("best_score"))
+
+
+def _verdicts(run: dict[str, Any]) -> str:
+    """Accepted and rejected proposals, as the run's producer counted them. A run that
+    never reported them shows a dash rather than 0/0."""
+    accepted, rejected = run.get("candidates_accepted"), run.get("candidates_rejected")
+    if accepted is None and rejected is None:
+        return _UNRECORDED
+    return f"{_int(accepted)}/{_int(rejected)}"
+
+
+def _render_runs(payload: Any) -> None:
+    runs = _rows(payload, "optimization_runs")
+    if not runs:
+        print("No optimization runs match.")
+        return
+    rows = [
+        (
+            str(run.get("run_id") or ""),
+            str(run.get("status") or ""),
+            str(run.get("program_name") or _UNRECORDED),
+            str(run.get("optimizer_type") or ""),
+            _metric_calls(run),
+            _verdicts(run),
+            _best_score(run),
+            str(run.get("start_time") or ""),
+        )
+        for run in runs
+    ]
+    _table(("RUN", "STATUS", "PROGRAM", "OPTIMIZER", "METRIC CALLS", "ACCEPTED/REJECTED", "BEST", "STARTED"), rows)
+    total = payload.get("total") if isinstance(payload, dict) else None
+    if isinstance(total, int) and total > len(runs):
+        print(f"{len(runs)} of {total} runs. Page with --limit and --offset.")
+
+
+def _render_queued(payload: Any) -> None:
+    queued = _rows(payload, "optimizations")
+    if not queued:
+        print("No optimization runs are queued.")
+        return
+    rows = [
+        (
+            _int(run.get("position")),
+            str(run.get("optimization_id") or ""),
+            str(run.get("status") or "queued"),
+            str(run.get("optimizer") or ""),
+            str(run.get("created_at") or ""),
+        )
+        for run in queued
+    ]
+    _table(("POSITION", "RUN", "STATUS", "OPTIMIZER", "QUEUED AT"), rows)
 
 
 def _list_queued(client: api_client.ApiClient, args: Any) -> Any:
@@ -370,12 +482,114 @@ def handle_compare_failed_examples(client: api_client.ApiClient, args: Any) -> A
 
 
 def handle_iterations(client: api_client.ApiClient, args: Any) -> Any:
-    return client.get(f"/api/v1/optimizations/{args.id}/iterations")
+    payload = client.get(f"/api/v1/optimizations/{args.id}/iterations")
+    if not getattr(args, "text", False):
+        return payload
+    _render_iterations(args.id, payload)
+    return None
+
+
+def _verdict(iteration: dict[str, Any]) -> str:
+    accepted = iteration.get("accepted")
+    if accepted is None:
+        return _UNRECORDED
+    return "accepted" if accepted else "rejected"
+
+
+def _result(iteration: dict[str, Any]) -> str:
+    """The candidate an accepted proposal became, with its validation score."""
+    idx = iteration.get("result_candidate_idx")
+    if not isinstance(idx, int):
+        return _UNRECORDED
+    score = iteration.get("validation_score")
+    return f"{idx} ({_score(score)})" if isinstance(score, (int, float)) else str(idx)
+
+
+def _render_iterations(run_id: str, payload: Any) -> None:
+    """One row per iteration: the candidate it mutated and that candidate's minibatch mean,
+    the proposal's mean over the same minibatch, gepa's verdict, and the candidate an
+    accepted proposal became. A dash is a value serve does not hold for that iteration."""
+    iterations = _rows(payload, "iterations")
+    if not iterations:
+        print(f"{run_id} has no iterations yet.")
+        return
+    rows = [
+        (
+            _int(it.get("idx")),
+            _int(it.get("parent_candidate_idx")),
+            str(it.get("batch_size") or _UNRECORDED),
+            _score(it.get("parent_minibatch_score")),
+            _score(it.get("proposal_minibatch_score")),
+            _verdict(it),
+            _result(it),
+            str(it.get("duration") or _UNRECORDED),
+        )
+        for it in iterations
+    ]
+    _table(
+        ("ITER", "PARENT", "BATCH", "PARENT SCORE", "PROPOSAL SCORE", "VERDICT", "CANDIDATE", "DURATION"),
+        rows,
+    )
+    print(
+        "Scores are means over the iteration's minibatch. CANDIDATE is the candidate an accepted "
+        "proposal became, with its validation score."
+    )
+    if any(_UNRECORDED in row[1:] for row in rows):
+        print(
+            f"{_UNRECORDED}: not recorded for that iteration. An open run holds what its optimizer "
+            "has reported so far, and the settled record fills the rest."
+        )
 
 
 def handle_candidates(client: api_client.ApiClient, args: Any) -> Any:
     params = {"include": "instructions"} if getattr(args, "full", False) else None
-    return client.get(f"/api/v1/optimizations/{args.id}/candidates", params=params)
+    payload = client.get(f"/api/v1/optimizations/{args.id}/candidates", params=params)
+    if not getattr(args, "text", False):
+        return payload
+    _render_candidates(args.id, payload, full=getattr(args, "full", False))
+    return None
+
+
+def _origin(candidate: dict[str, Any]) -> str:
+    """How the candidate entered the pool. The seed starts it; every other candidate came
+    from an accepted proposal, a reflective mutation or a merge."""
+    if "accepted" not in candidate or candidate.get("mutation_type") == "seed":
+        return "seed"
+    return f"accepted ({candidate.get('mutation_type') or 'proposal'})"
+
+
+def _render_candidates(run_id: str, payload: Any, *, full: bool) -> None:
+    candidates = _rows(payload, "candidates")
+    status = payload.get("run_status") if isinstance(payload, dict) else None
+    summary = [f"{run_id}: {status}" if status else run_id]
+    if isinstance(payload, dict) and ("candidates_accepted" in payload or "candidates_rejected" in payload):
+        summary.append(
+            f"{_int(payload.get('candidates_accepted'))} accepted, {_int(payload.get('candidates_rejected'))} rejected"
+        )
+    summary.append(f"{len(candidates)} candidate{'' if len(candidates) == 1 else 's'} listed")
+    print(" · ".join(summary))
+    if candidates:
+        rows = [
+            (
+                str(c.get("candidate_id") or ""),
+                _int(c.get("candidate_idx", c.get("idx"))),
+                _int(c.get("parent_candidate_idx")),
+                str(c.get("generation") or _UNRECORDED),
+                _score(c.get("aggregate_score")),
+                _origin(c),
+                "yes" if c.get("is_pareto_member") else "",
+            )
+            for c in candidates
+        ]
+        _table(("CANDIDATE", "IDX", "PARENT", "GEN", "VAL SCORE", "ORIGIN", "PARETO"), rows)
+        if full:
+            for c in candidates:
+                print(f"{c.get('candidate_id')}: {_first_line(_instruction_texts(c.get('instructions')))}")
+    if status in _OPEN_STATUSES:
+        print(
+            "The run is open: the list grows as the optimizer reports each candidate it accepts, "
+            "and the settled record completes it."
+        )
 
 
 def handle_compiled_program(client: api_client.ApiClient, args: Any) -> Any:

{cmpnd-0.81.0 → cmpnd-0.82.0}/docs/cli.md

@@ -190,8 +190,9 @@ does the same.
 A namespaced read, such as `cmpnd traces show`, `cmpnd deployments list` or
 `cmpnd tool-servers list`, prints the API's JSON by default, so a script can
 pipe it to `jq`. A human view is an opt-in flag: `--tree` and `--timeline` on
-`traces show`, and `--text` on `tool-servers list`, `tool-servers show` and
-`credentials list`. Those three accept `--json` as well, so older scripts keep
+`traces show`, and `--text` on `tool-servers list`, `tool-servers show`,
+`credentials list`, `optimizations list`, `optimizations iterations` and
+`optimizations candidates`. Those accept `--json` as well, so older scripts keep
 working. An action command may print a short result and take `--json` for the
 whole answer: `cmpnd programs create` prints the new id, and
 `cmpnd optimizations continue` prints the best deployment. The top-level
@@ -798,6 +799,36 @@ live objects and takes named models through its `lms` argument. An authored file
 binding cannot be combined with `lms` in the parent call or `config["lms"]`.
 The CLI has no named-model flag.
 
+### Watch a run
+
+A hosted run reports its progress while it runs, so these reads show an open
+run as it is. Each prints the API's JSON, and `--text` renders a table.
+
+- `cmpnd optimizations list --text` shows each run's status, its metric calls
+  of the budget, its accepted and rejected proposals and its best score. The
+  JSON's `total_metric_calls` keeps pace with `current_metric_calls` while the
+  run is open, and `total_candidates` counts the candidates the platform holds
+  for it, which `candidates` lists. `best_score` reads 0 until the run
+  records a score, and `best_score_recorded` is `false` until then, so
+  `--text` shows a dash. `show` and `list` read the same row, so they agree.
+- `cmpnd optimizations iterations RUN_ID` lists each iteration: the candidate
+  it mutated (`parent_candidate_idx`) and that candidate's mean over the
+  iteration's minibatch (`parent_minibatch_score`), the proposal's mean over the
+  same minibatch (`proposal_minibatch_score`), whether gepa `accepted` it, the
+  candidate an accepted proposal became (`result_candidate_idx`) with its
+  `validation_score`, and its `batch_size` and `duration_ms`. A field the
+  platform does not hold for an iteration is left out, and `--text` shows a
+  dash. A run the SDK tracks on your machine reports only each iteration's
+  number and score until it settles.
+- `cmpnd optimizations candidates RUN_ID` lists every candidate the run holds,
+  beside its `run_status` and its `candidates_accepted` and
+  `candidates_rejected` counts. An open hosted run lists each candidate as the
+  optimizer accepts it, and the settled record completes the list and keeps
+  each `ca_` id. A run the SDK tracks lists its candidates once it settles.
+  The seed carries no `accepted`, because no verdict admitted it.
+- `cmpnd optimizations show RUN_ID` names the run's `reflection_model_name`
+  from the moment it starts.
+
 ### Cancel a run
 
 `cmpnd optimizations cancel RUN_ID` stops an open run and keeps its record,

{cmpnd-0.81.0 → cmpnd-0.82.0}/pyproject.toml

@@ -5,7 +5,7 @@ name = "cmpnd"
 # it's new) — no git tags. Bump with `uv version --bump {minor,patch}` or by
 # hand. Runtime `cmpnd.__version__` reads installed metadata, so it tracks
 # this automatically. See docs/plans/2026-07-02-sdk-pypi-tag-free-publish.md.
-version = "0.81.0"
+version = "0.82.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.81.0 → cmpnd-0.82.0}/tests/test_cli/test_optimizations.py

@@ -438,3 +438,213 @@ class TestOptimizationsCompareFailedExamples:
         parser = _build_parser()
         with pytest.raises(SystemExit):
             parser.parse_args(["optimizations", "failed-examples"])
+
+
+# An open GEPA run 28 minutes in, with a budget of 30 metric calls, as serve answers it
+# once the heartbeat reports its iterations and candidates.
+_OPEN_RUN = {
+    "run_id": "op_OpenBBBBBBBB",
+    "status": "running",
+    "program_name": "headline-ranker",
+    "optimizer_type": "gepa",
+    "model_name": "openai/deepseek-4.1-flash",
+    "reflection_model_name": "openai/deepseek-4.1-flash",
+    "start_time": "2026-11-04T11:26:02Z",
+    "total_metric_calls": 18,
+    "current_metric_calls": 18,
+    "max_metric_calls": 30,
+    "total_candidates": 2,
+    "candidates_accepted": 1,
+    "candidates_rejected": 1,
+    "best_score": 0.557,
+}
+_SETTLED_RUN = {
+    "run_id": "op_SettledAAAAA",
+    "status": "completed",
+    "program_name": "headline-ranker",
+    "optimizer_type": "gepa",
+    "start_time": "2026-11-03T09:00:00Z",
+    "total_metric_calls": 33,
+    "max_metric_calls": 30,
+    "total_candidates": 3,
+    "best_score": 0.567,
+}
+
+
+def _text(argv: list[str]) -> argparse.Namespace:
+    return _build_parser().parse_args(["optimizations", *argv])
+
+
+class TestOptimizationsListText:
+    def test_json_stays_the_default(self, mock_client):
+        mock_client.post.return_value = {"optimization_runs": [_OPEN_RUN]}
+        result = handle_list(mock_client, _text(["list"]))
+        assert result == {"optimization_runs": [_OPEN_RUN]}
+
+    def test_a_row_shows_its_status_and_an_open_runs_live_progress(self, mock_client, capsys):
+        mock_client.post.return_value = {"optimization_runs": [_OPEN_RUN, _SETTLED_RUN], "total": 2}
+        assert handle_list(mock_client, _text(["list", "--text"])) is None
+        lines = capsys.readouterr().out.splitlines()
+        header, open_row, settled_row = lines[0], lines[1], lines[2]
+        for column in ("RUN", "STATUS", "PROGRAM", "METRIC CALLS", "ACCEPTED/REJECTED", "BEST"):
+            assert column in header, header
+        assert "op_OpenBBBBBBBB" in open_row and "running" in open_row
+        assert "18/30" in open_row and "1/1" in open_row and "0.557" in open_row
+        assert "op_SettledAAAAA" in settled_row and "completed" in settled_row
+        assert "33/30" in settled_row and "0.567" in settled_row
+
+    def test_a_counter_the_run_never_reported_reads_as_a_dash(self, mock_client, capsys):
+        run = {k: v for k, v in _OPEN_RUN.items() if k not in ("candidates_accepted", "candidates_rejected")}
+        mock_client.post.return_value = {"optimization_runs": [run]}
+        handle_list(mock_client, _text(["list", "--text"]))
+        row = capsys.readouterr().out.splitlines()[1]
+        assert " - " in row and "0/0" not in row, row
+
+    def test_a_best_score_the_run_has_not_recorded_reads_as_a_dash(self, mock_client, capsys):
+        unrecorded = {**_OPEN_RUN, "best_score": 0, "best_score_recorded": False}
+        measured_zero = {**_SETTLED_RUN, "best_score": 0, "best_score_recorded": True}
+        mock_client.post.return_value = {"optimization_runs": [unrecorded, measured_zero]}
+        handle_list(mock_client, _text(["list", "--text"]))
+        lines = capsys.readouterr().out.splitlines()
+        header, open_row, settled_row = lines[0], lines[1], lines[2]
+        best = header.index("BEST")
+        assert open_row[best:].split()[0] == "-", open_row
+        assert settled_row[best:].split()[0] == "0.000", settled_row
+
+    def test_an_older_serve_without_the_flag_keeps_showing_its_score(self, mock_client, capsys):
+        older = {k: v for k, v in _OPEN_RUN.items() if k != "best_score_recorded"}
+        mock_client.post.return_value = {"optimization_runs": [{**older, "best_score": 0}]}
+        handle_list(mock_client, _text(["list", "--text"]))
+        header, row = capsys.readouterr().out.splitlines()[:2]
+        assert row[header.index("BEST") :].split()[0] == "0.000", row
+
+    def test_queued_runs_render_in_line_order(self, mock_client, capsys):
+        mock_client.get.return_value = {
+            "optimizations": [
+                {"optimization_id": "op_1", "status": "queued", "optimizer": "gepa", "position": 1},
+            ]
+        }
+        handle_list(mock_client, _text(["list", "--status", "queued", "--text"]))
+        out = capsys.readouterr().out
+        assert "op_1" in out and "queued" in out and "gepa" in out
+
+
+class TestOptimizationsIterationsText:
+    _ITERATIONS = {
+        "iterations": [
+            # A point from a producer that reported only the score.
+            {"idx": 1, "label": "Iter 1", "score": "0.560", "parent_minibatch_score": 0.56, "eval_trace_ids": []},
+            {
+                "idx": 2,
+                "label": "Iter 2 · candidate 1",
+                "score": "0.604",
+                "candidate_idx": "1",
+                "parent_candidate_idx": 1,
+                "parent_minibatch_score": 0.6036,
+                "proposal_minibatch_score": 0.3895,
+                "accepted": False,
+                "batch_size": "3",
+                "duration": "6m 52s",
+                "duration_ms": 412000,
+                "eval_trace_ids": [],
+            },
+            {
+                "idx": 3,
+                "label": "Iter 3 · candidate 0",
+                "score": "0.389",
+                "candidate_idx": "0",
+                "parent_candidate_idx": 0,
+                "parent_minibatch_score": 0.389,
+                "proposal_minibatch_score": 0.7,
+                "accepted": True,
+                "result_candidate_idx": 2,
+                "validation_score": 0.567,
+                "batch_size": "3",
+                "duration": "5m 1s",
+                "duration_ms": 301000,
+                "eval_trace_ids": [],
+            },
+        ],
+        "total": 3,
+    }
+
+    def test_json_stays_the_default(self, mock_client):
+        mock_client.get.return_value = self._ITERATIONS
+        assert handle_iterations(mock_client, _text(["iterations", "op_1"])) == self._ITERATIONS
+
+    def test_each_iteration_says_what_it_did(self, mock_client, capsys):
+        mock_client.get.return_value = self._ITERATIONS
+        assert handle_iterations(mock_client, _text(["iterations", "op_1", "--text"])) is None
+        lines = capsys.readouterr().out.splitlines()
+        header = lines[0]
+        for column in ("ITER", "PARENT", "BATCH", "PARENT SCORE", "PROPOSAL SCORE", "VERDICT", "CANDIDATE", "DURATION"):
+            assert column in header, header
+        rejected, accepted = lines[2], lines[3]
+        assert "0.604" in rejected and "0.390" in rejected and "rejected" in rejected and "6m 52s" in rejected
+        assert "accepted" in accepted and "0.700" in accepted and "5m 1s" in accepted
+        # The accepted proposal became candidate 2, with its validation score.
+        assert "2 (0.567)" in accepted, accepted
+
+    def test_what_serve_does_not_record_is_never_shown_as_zero(self, mock_client, capsys):
+        mock_client.get.return_value = self._ITERATIONS
+        handle_iterations(mock_client, _text(["iterations", "op_1", "--text"]))
+        out = capsys.readouterr().out
+        thin = out.splitlines()[1]
+        assert "0µs" not in thin and " 0 " not in thin.replace("0.560", ""), thin
+        assert "not recorded" in out
+
+
+class TestOptimizationsCandidatesText:
+    _CANDIDATES = {
+        "candidates": [
+            {
+                "candidate_id": "ca_seedAAAAAAAA",
+                "candidate_idx": 0,
+                "idx": 0,
+                "parent_candidate_id": "",
+                "aggregate_score": 0.463,
+                "generation": "0",
+                "mutation_type": "seed",
+                "is_pareto_member": False,
+            },
+            {
+                "candidate_id": "ca_nextAAAAAAAA",
+                "candidate_idx": 1,
+                "idx": 1,
+                "parent_candidate_id": "ca_seedAAAAAAAA",
+                "parent_candidate_idx": 0,
+                "aggregate_score": 0.557,
+                "accepted": True,
+                "generation": "1",
+                "mutation_type": "reflective",
+                "is_pareto_member": True,
+            },
+        ],
+        "total": 2,
+        "run_status": "running",
+        "candidates_accepted": 1,
+        "candidates_rejected": 1,
+    }
+
+    def test_json_stays_the_default(self, mock_client):
+        mock_client.get.return_value = self._CANDIDATES
+        assert handle_candidates(mock_client, _text(["candidates", "op_1"])) == self._CANDIDATES
+
+    def test_an_open_run_says_its_verdict_counts_and_lists_its_candidates(self, mock_client, capsys):
+        mock_client.get.return_value = self._CANDIDATES
+        assert handle_candidates(mock_client, _text(["candidates", "op_1", "--text"])) is None
+        lines = capsys.readouterr().out.splitlines()
+        assert "running" in lines[0] and "1 accepted" in lines[0] and "1 rejected" in lines[0], lines[0]
+        table = "\n".join(lines)
+        seed = next(line for line in lines if "ca_seedAAAAAAAA" in line)
+        child = next(line for line in lines if "ca_nextAAAAAAAA" in line)
+        assert "seed" in seed and "rejected" not in seed, seed
+        assert "0.557" in child and "accepted" in child, child
+        assert "open" in table, "an open run's list says it grows"
+
+    def test_full_prints_each_candidates_first_instruction_line(self, mock_client, capsys):
+        payload = json.loads(json.dumps(self._CANDIDATES))
+        payload["candidates"][1]["instructions"] = {"predict": "Spot rising trends.\nThen rank them."}
+        mock_client.get.return_value = payload
+        handle_candidates(mock_client, _text(["candidates", "op_1", "--full", "--text"]))
+        assert "Spot rising trends." in capsys.readouterr().out

{cmpnd-0.81.0 → cmpnd-0.82.0}/uv.lock

@@ -505,7 +505,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.81.0"
+version = "0.82.0"
 source = { editable = "." }
 default-groups = ["dspy-3-4-1"]
 dependencies = [