cmpnd 0.7.1__tar.gz → 0.7.2__tar.gz

{cmpnd-0.7.1 → cmpnd-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmpnd
-Version: 0.7.1
+Version: 0.7.2
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -27,6 +27,7 @@ Requires-Dist: basedpyright>=1.39; extra == 'dev'
 Requires-Dist: boto3>=1.34; extra == 'dev'
 Requires-Dist: hypothesis>=6.100; extra == 'dev'
 Requires-Dist: jsonschema>=4.0; extra == 'dev'
+Requires-Dist: numpy>=1.26; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest-rerunfailures>=14.0; extra == 'dev'
 Requires-Dist: pytest-xdist>=3.0; extra == 'dev'

{cmpnd-0.7.1 → cmpnd-0.7.2}/cmpnd/_gepa_patch.py

@@ -64,7 +64,7 @@ def patch_gepa() -> None:
         # This ensures each optimization gets its own run_id, even when
         # the same GEPA instance is reused (e.g., optimizing an already-optimized program).
         trk = tracker.OptimizationTracker(
-            optimizer_type="GEPA",
+            optimizer_type="gepa",
             program_name="",
         )
         callback = gepa_callback.CmpndGEPACallback(trk, defer_finalize=True)
@@ -157,7 +157,14 @@ def patch_gepa() -> None:
 
             return result
 
-        except Exception as e:
+        # `BaseException`, because the invariant does not get to have an exception: a
+        # run that ends by ANY route must transition the row start() sent, or the
+        # program page shows a perpetual in-progress optimization. A backend that
+        # rejected a model request raises a failure that deliberately does NOT derive
+        # from `Exception` — that is the only way past gepa's and dspy's own blanket
+        # `except Exception` clauses — so narrowing this one reopens exactly the bug
+        # this block exists for. Re-raised either way, so widening swallows nothing.
+        except BaseException as e:
             if callback is not None:  # pyright: ignore[reportUnnecessaryComparison]
                 # Flush a terminal 'failed', not just in-memory state — else the
                 # running row start() sent lingers forever.

{cmpnd-0.7.1 → cmpnd-0.7.2}/cmpnd/optimizers/gepa.py

@@ -152,7 +152,7 @@ class TrackedGEPA:
 
         # Initialize optimization tracking
         self._tracker = tracker.OptimizationTracker(
-            optimizer_type="GEPA",
+            optimizer_type="gepa",
             program_name=student.__class__.__name__,
             config=config,
             model_name=model_name,
@@ -218,7 +218,11 @@ class TrackedGEPA:
 
             return result
 
-        except Exception as e:
+        # `BaseException` for the reason `_gepa_patch._patched_compile` documents: the
+        # row must transition however the run ends, and a rejected model request
+        # reaches here as something that is not an `Exception`, by design. Re-raised
+        # either way.
+        except BaseException as e:
             if self._tracker:
                 # Flush a terminal 'failed', not just in-memory state — else the
                 # running row start() sent lingers forever.

{cmpnd-0.7.1 → cmpnd-0.7.2}/cmpnd/optimizers/gepa_callback.py

@@ -5,7 +5,7 @@ monkey-patching or wrapper classes. Replaces the monkey-patched
 InstrumentedDspyAdapter approach used by TrackedGEPA.
 
 Usage:
-    tracker = OptimizationTracker(optimizer_type="GEPA", ...)
+    tracker = OptimizationTracker(optimizer_type="gepa", ...)
     callback = CmpndGEPACallback(tracker)
     gepa = dspy.GEPA(gepa_kwargs={"callbacks": [callback]})
 """

{cmpnd-0.7.1 → cmpnd-0.7.2}/cmpnd/optimizers/tracker.py

@@ -199,7 +199,7 @@ class OptimizationTracker:
 
     Usage:
         tracker = OptimizationTracker(
-            optimizer_type="GEPA",
+            optimizer_type="gepa",
             program_name="MyProgram",
             config={"auto": "light", "seed": 42}
         )
@@ -634,14 +634,21 @@ class OptimizationTracker:
         except Exception as e:
             logger.warning(f"Failed to capture compiled program state: {e}")
 
-    def set_error(self, exception: Exception) -> None:
-        """Mark the optimization run as failed (in-memory only)."""
+    def set_error(self, exception: BaseException) -> None:
+        """Mark the optimization run as failed (in-memory only).
+
+        ``BaseException`` and not ``Exception``: a backend that rejected a model request
+        reports it as a failure that deliberately does not derive from ``Exception``,
+        since that is the only thing gepa's and dspy's blanket ``except Exception``
+        clauses do not swallow. A run that ended is a run that has to be recorded as
+        ended, whichever base class carried the reason.
+        """
         self.status = "failed"
         self.error_message = str(exception)
         self.end_time = datetime.now(timezone.utc)
         logger.error(f"Optimization failed: {exception}")
 
-    def finalize_error(self, exception: Exception) -> None:
+    def finalize_error(self, exception: BaseException) -> None:
         """Mark the run failed AND flush the terminal 'failed' to the backend.
 
         The success path is finalize(); on an optimizer exception the run must

{cmpnd-0.7.1 → cmpnd-0.7.2}/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.7.1"
+version = "0.7.2"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -58,6 +58,10 @@ dev = [
     # litellm's bedrock/ provider imports boto3 in-process, so the client-side
     # Bedrock stress tests (committee twins) need it in the test env.
     "boto3>=1.34",
+    # test_reflector_smoke.py builds numpy fixtures. dspy <=3.2.x required numpy
+    # unconditionally so it rode in transitively; dspy 3.3.0 moved numpy behind a
+    # `numpy` extra, so declare it directly as the test dependency it always was.
+    "numpy>=1.26",
 ]
 # Deps for `deploy/deploy/stub/`, the local FastAPI server that emulates
 # the AWS deploy stack. The stub itself ships in the cmpnd-deploy
@@ -92,6 +96,39 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["cmpnd"]
 
+[tool.pytest.ini_options]
+# Deliberately minimal: `markers` and `--strict-markers`, nothing else. Setting
+# `testpaths` or a broader `addopts` here would change how every existing
+# invocation resolves (CI lanes, `uv run pytest tests/ -k "not e2e"`, a bare
+# `pytest` from a subdirectory), and this file's job is only to make the marker
+# vocabulary explicit.
+#
+# --strict-markers turns a typo'd marker into an error instead of a silent
+# no-op. That matters most for `forall_workers`: it SELECTS the merge-queue's
+# wasm lane, so a misspelling there would quietly select nothing and report a
+# green lane that ran zero tests. `asyncio` and `flaky` are registered by
+# pytest-asyncio / pytest-rerunfailures, so they are not listed here.
+addopts = "--strict-markers"
+markers = [
+    # Tests that must hold for EVERY worker backend — i.e. that provision,
+    # execute or optimize through a data plane, and so can distinguish the
+    # Lambda plane from the wasm plane from the on-prem worker. This is the
+    # selector for the per-plane stress lanes: the set worth running against a
+    # second worker is exactly the set claimed to hold for all of them.
+    #
+    # A stress test that deploys or executes gets this marker. Its absence on
+    # such a test is a bug; its PRESENCE on a test no worker can affect (one
+    # that only exercises client-side tracing, or serve's own health) is worse,
+    # because it costs a second real-provider run to prove nothing.
+    # See docs/plans/2026-07-29-wasm-stress-lane.md.
+    "forall_workers: must hold for every worker backend (reaches a data plane)",
+    # Pre-existing vocabulary, registered here because --strict-markers now
+    # requires it — not introduced by this block.
+    "parity: CLI dual-front-end parity (argparse vs. interactive shell)",
+    "e2e: needs a live platform; excluded from the fast lane via -k 'not e2e'",
+    "integration: crosses a component boundary (SDK ↔ serve ↔ worker)",
+]
+
 [tool.ruff]
 line-length = 120
 target-version = "py310"

{cmpnd-0.7.1 → cmpnd-0.7.2}/scripts/seed_review_run.py

@@ -33,12 +33,14 @@ from __future__ import annotations
 
 import datetime
 import gzip
+import http.cookiejar
 import json
 import logging
 import os
 import pathlib
 import re
 import urllib.error
+import urllib.parse
 import urllib.request
 import uuid
 
@@ -46,13 +48,19 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(mess
 log = logging.getLogger("seed_review_run")
 
 _FIXTURE = pathlib.Path(__file__).resolve().parent / "fixtures" / "review_run.json.gz"
-# Origin tag so seeded data is identifiable as such (never confused with real
-# customer runs). Overrides whatever the captured fixture carried. Each seeded
-# run also carries a `lifecycle-*` role tag (CMP-414) so its place in the
-# lifecycle demo is explicit — and so the failed run reads as intentional, not
-# an incident.
+# Origin tag on ALL seeded rows so seeded data is identifiable as such (never
+# confused with real customer runs). Overrides whatever the captured fixture
+# carried. Each seeded run also carries a `lifecycle-*` role tag (CMP-414) so its
+# place in the lifecycle demo is explicit — and so the failed run reads as
+# intentional, not an incident.
 _SEED_TAGS = ["seed-data"]
-_TAGS_COMPLETE = _SEED_TAGS + ["lifecycle-complete"]
+# `golden-path` marks ONLY the data that IS a DSPy-Meetup golden-path demo beat
+# (CMP-634) — the completed committee run + its Predict traces, the ReAct
+# committee trace, and the RLM notebook (completed + in-progress). It does NOT
+# go on the lifecycle running/failed twins or the CMP-187 tool-demo traces, so
+# `?tags=golden-path` surfaces exactly the demo tenant, nothing incidental.
+_GOLDEN_PATH = "golden-path"
+_TAGS_COMPLETE = _SEED_TAGS + [_GOLDEN_PATH, "lifecycle-complete"]
 _TAGS_RUNNING = _SEED_TAGS + ["lifecycle-running"]
 _TAGS_FAILED = _SEED_TAGS + ["lifecycle-failed"]
 _UUID_RE = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}")
@@ -248,6 +256,14 @@ _SOURCE_CATEGORIZER_FIXTURE = (
 _TOOL_KIND_DEMO_FIXTURE = (
     pathlib.Path(__file__).resolve().parents[2] / "serve" / "scripts" / "seed_fixtures" / "tool_kind_demo.json"
 )
+# A dspy.ReAct(ExtractCommittee) run (email_body->committee) that reasons, calls
+# a `lookup_disclaimer` tool to pull the "Paid for by" line, then extracts the
+# committee (CMP-634 golden-path). Flat-replay format like the two fixtures
+# above; program_name "ReAct" so the sidebar/Type badge reads ReAct. Loaded
+# lazily so a missing file degrades to skipping that seed.
+_REACT_COMMITTEE_FIXTURE = (
+    pathlib.Path(__file__).resolve().parents[2] / "serve" / "scripts" / "seed_fixtures" / "react_committee.json"
+)
 
 
 def _notebook_trace(now: datetime.datetime) -> dict:
@@ -384,7 +400,157 @@ def _notebook_trace(now: datetime.datetime) -> dict:
         "adapter_type": "ChatAdapter",
         "request_preview": "Colorado 2026 U.S. House elections (Ballotpedia markdown)",
         "response_preview": f"{state}: {districts} districts",
-        "project_tags": _SEED_TAGS + ["notebook-demo"],
+        "project_tags": _SEED_TAGS + [_GOLDEN_PATH, "notebook-demo"],
+        "total_tokens": total_tokens,
+        "span_count": len(spans),
+        "spans": spans,
+    }
+
+
+def _notebook_trace_in_progress(now: datetime.datetime) -> dict:
+    """A SECOND DistrictCounter RLM trace, frozen mid-flight as an `in_progress`
+    live-notebook (CMP-634) so the review app demonstrates the live-streaming
+    autofill alongside the completed run from _notebook_trace.
+
+    Built from the same fixture but keeping only the first half of the REPL
+    turns, with no authoritative trajectory on the root and no answer fields —
+    so serve's ParseNotebook reconstructs a *partial* notebook from the Predict
+    turn children, and status "in_progress" (+ root span_type "rlm") renders it
+    as the "running" notebook with the live spinner (serve traces.templ
+    notebookPanel: Partial && Live). The trace + root span carry no end_time
+    (NULL via the batch path's nullableTime), the shape a real live trace has.
+
+    start_time is `now` so it reads as freshly in-flight. A background sweep in
+    serve settles stale in_progress traces after ~15m; review apps are seeded
+    fresh per PR, so this trace is comfortably inside that window when a reviewer
+    opens it — no sweep change needed. Posted via /api/v1/traces/batch, whose
+    InsertWithSpans preserves an explicit "in_progress" status (detectIncomplete
+    is a no-op unless status == "ok") and stores a null end_time.
+    """
+    fx = json.loads(_RLM_FIXTURE.read_text())
+    trajectory = fx["trajectory"]
+    turns = fx["turns"]
+    model = fx["model_name"]
+    trace_id = str(uuid.uuid4())
+    # Keep the first half of the turns; the run is "still going".
+    kept = max(1, len(trajectory) // 2)
+
+    def at(ns: int) -> str:
+        return (now + datetime.timedelta(microseconds=ns / 1000)).isoformat()
+
+    ctx = fx["inputs"].get("context")
+    context_str = ctx.get("_preview", "") if isinstance(ctx, dict) else (ctx or "")
+
+    root_id = str(uuid.uuid4())
+    # Root RLM span: in_progress, NO end_time, and NO outputs.trajectory — an
+    # authoritative trajectory would make serve build a *complete* notebook; its
+    # absence routes ParseNotebook to the partial (running) reconstruction.
+    spans: list[dict] = [
+        {
+            "span_id": root_id,
+            "trace_id": trace_id,
+            "parent_span_id": None,
+            "name": "RLM.forward",
+            "span_type": "rlm",
+            "start_time": at(0),
+            # The span status CHECK allows only unset/ok/error (in_progress is a
+            # trace-level status). A still-running root span is "unset" — the
+            # trace-level "in_progress" below is what drives the live notebook.
+            "status": "unset",
+            "module_type": "RLM",
+            "module_name": "RLM",
+            "signature_name": fx["signature_name"],
+            "program_signature_hash": fx["program_signature_hash"],
+            "signature_instructions": fx["instructions"],
+            "signature_input_fields": fx["input_fields"],
+            "signature_output_fields": fx["output_fields"],
+            "inputs": json.dumps({"context": context_str}),
+        },
+    ]
+
+    def adapter_span(parent: str, name: str, span_type: str, start: int, dur: int) -> dict:
+        return {
+            "span_id": str(uuid.uuid4()),
+            "trace_id": trace_id,
+            "parent_span_id": parent,
+            "name": name,
+            "span_type": span_type,
+            "start_time": at(start),
+            "end_time": at(start + dur),
+            "duration_ns": dur,
+            "status": "ok",
+        }
+
+    gap_ns = 50_000_000
+    cursor = 0
+    total_tokens = 0
+    for turn in range(kept):
+        step = trajectory[turn]
+        t = turns[turn]
+        p_start = cursor
+        p_end = p_start + t["predict_ns"]
+        predict_id = str(uuid.uuid4())
+        spans.append(
+            {
+                "span_id": predict_id,
+                "trace_id": trace_id,
+                "parent_span_id": root_id,
+                "name": "Predict.forward",
+                "span_type": "predict",
+                "module_type": "Predict",
+                "module_name": "Predict",
+                "start_time": at(p_start),
+                "end_time": at(p_end),
+                "duration_ns": t["predict_ns"],
+                "status": "ok",
+                "outputs": {"reasoning": step["reasoning"], "code": step["code"]},
+            }
+        )
+        spans.append(adapter_span(predict_id, "ChatAdapter.format", "adapter_format", p_start, t["format_ns"]))
+        lm_start = p_start + t["format_ns"]
+        lm_tokens = t["lm_tokens"]
+        completion = lm_tokens // 10
+        prompt = lm_tokens - completion
+        total_tokens += lm_tokens
+        spans.append(
+            {
+                "span_id": str(uuid.uuid4()),
+                "trace_id": trace_id,
+                "parent_span_id": predict_id,
+                "name": "LM.__call__",
+                "span_type": "lm_call",
+                "start_time": at(lm_start),
+                "end_time": at(lm_start + t["lm_ns"]),
+                "duration_ns": t["lm_ns"],
+                "status": "ok",
+                "model_name": model,
+                "model_provider": "bedrock",
+                "prompt_tokens": prompt,
+                "completion_tokens": completion,
+                "total_tokens": lm_tokens,
+            }
+        )
+        spans.append(
+            adapter_span(predict_id, "ChatAdapter.parse", "adapter_parse", p_end - t["parse_ns"], t["parse_ns"])
+        )
+        cursor = p_end + gap_ns
+
+    # No end_time / duration_ns at the trace level either — a live trace has not
+    # closed. status "in_progress" so serve renders the running notebook.
+    return {
+        "trace_id": trace_id,
+        "start_time": at(0),
+        "status": "in_progress",
+        "program_name": "RLM",
+        "program_version": "0.1.0",
+        "program_signature_hash": fx["program_signature_hash"],
+        "signature_name": fx["signature_name"],
+        "signature_input_fields": fx["input_fields"],
+        "signature_output_fields": fx["output_fields"],
+        "adapter_type": "ChatAdapter",
+        "request_preview": "Colorado 2026 U.S. House elections (Ballotpedia markdown)",
+        "response_preview": "",
+        "project_tags": _SEED_TAGS + [_GOLDEN_PATH, "notebook-demo", "in-progress"],
         "total_tokens": total_tokens,
         "span_count": len(spans),
         "spans": spans,
@@ -514,6 +680,85 @@ def _stamp_deployments(traces: list[dict], dep_for) -> None:
             trace["deployment_id"] = dep
 
 
+# The review app's bootstrap admin (serve devEasySeedUser): admin@review.local.
+# Its password is the review release's fixed default — release_serve_review.py's
+# DEFAULT_SEED_ADMIN_PASSWORD, which the review flow never overrides — so the
+# default below matches the deployed password with no workflow env needed.
+# CMPND_SERVE_SEED_ADMIN_PASSWORD stays an override hook for the day that
+# password is ever customized.
+_ADMIN_EMAIL = "admin@review.local"
+_ADMIN_PASSWORD_DEFAULT = "review-app-admin-password"
+_CSRF_INPUT_RE = re.compile(r'name="csrf_token"\s+value="([^"]+)"')
+_CSRF_META_RE = re.compile(r'name="csrf-token"\s+content="([^"]+)"')
+
+
+def _display_program_hash(signed_hash: int) -> str:
+    """The 16-hex display form of a signed-int64 program_signature_hash — the
+    shape the /ui/programs/{hash}/pin route parses (ids.FormatProgramHashInt64
+    in serve: fmt.Sprintf("%016x", uint64(n)))."""
+    return format(signed_hash & 0xFFFFFFFFFFFFFFFF, "016x")
+
+
+def _scrape_csrf(html: str) -> str | None:
+    """Pull a CSRF token from a serve HTML page — the hidden `csrf_token` form
+    input, or the `<meta name="csrf-token">` fallback (both carry the per-session
+    token)."""
+    m = _CSRF_INPUT_RE.search(html) or _CSRF_META_RE.search(html)
+    return m.group(1) if m else None
+
+
+def _pin_committee_program(endpoint: str, display_hash: str) -> None:
+    """Pin the completed committee program for the demo admin (CMP-634).
+
+    Pins are per-user web state: `program_pins` FKs the ingested `programs` row
+    and serve's Pin() is reachable ONLY through the session+CSRF web route
+    POST /ui/programs/{hash}/pin — the API key (bearer, no cookies) can't hit it.
+    So we drive the browser flow with a cookie jar: log in as the bootstrap admin,
+    harvest a fresh CSRF token from the program page, then POST the pin. Wholly
+    non-gating — any failure logs and returns, like the rest of the seed.
+
+    Not exercisable against local dev (empty-password admin); it runs for real in
+    the review app, whose admin password is _ADMIN_PASSWORD_DEFAULT (the review
+    release's fixed default).
+    """
+    password = os.getenv("CMPND_SERVE_SEED_ADMIN_PASSWORD") or _ADMIN_PASSWORD_DEFAULT
+    jar = http.cookiejar.CookieJar()
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
+
+    def get(path: str) -> str:
+        req = urllib.request.Request(endpoint + path, method="GET")
+        with opener.open(req, timeout=30) as resp:  # noqa: S310 - fixed endpoint from env
+            return resp.read().decode("utf-8", "replace")
+
+    def post(path: str, fields: dict[str, str]) -> int:
+        data = urllib.parse.urlencode(fields).encode("utf-8")
+        req = urllib.request.Request(
+            endpoint + path,
+            data=data,
+            method="POST",
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+        )
+        with opener.open(req, timeout=30) as resp:  # noqa: S310 - fixed endpoint from env
+            return resp.status
+
+    # 1) GET the login page → session cookie + a CSRF token to submit with login.
+    login_csrf = _scrape_csrf(get("/auth/login"))
+    if not login_csrf:
+        log.warning("pin: no CSRF token on /auth/login; skipping pin")
+        return
+    # 2) Log in. serve rotates the CSRF token on login, so the token above is
+    # single-use for this POST only.
+    post("/auth/login", {"email": _ADMIN_EMAIL, "password": password, "csrf_token": login_csrf})
+    # 3) Harvest a FRESH CSRF token from the (now authenticated) program page.
+    pin_csrf = _scrape_csrf(get(f"/ui/programs/{display_hash}"))
+    if not pin_csrf:
+        log.warning("pin: no CSRF token on program page (login may have failed); skipping pin")
+        return
+    # 4) POST the pin.
+    status = post(f"/ui/programs/{display_hash}/pin", {"csrf_token": pin_csrf})
+    log.info("pinned committee program %s (status %s)", display_hash, status)
+
+
 def main() -> int:
     endpoint = (os.getenv("CMPND_E2E_ENDPOINT") or "").rstrip("/")
     api_key = os.getenv("CMPND_E2E_API_KEY") or ""
@@ -579,6 +824,20 @@ def main() -> int:
                 n_spans += 1
         log.info("seeded %d traces, %d span-batches, %d stat rows -> %s", n_traces, n_spans, n_stats, new_op)
 
+        # 2b) Pin the completed committee program for the demo admin (CMP-634) so
+        # the sidebar shows a pinned program. Runs now that the trace ingest has
+        # upserted the programs row the pin FKs. Self-contained try/except so the
+        # login+web-route flow (the only path to a per-user pin) can never break
+        # the seed.
+        try:
+            committee_hash = opt["payload"].get("program_signature_hash")
+            if committee_hash is not None:
+                _pin_committee_program(endpoint, _display_program_hash(int(committee_hash)))
+            else:
+                log.warning("pin: optimization payload has no program_signature_hash; skipping pin")
+        except Exception as exc:  # noqa: BLE001 - non-gating, like the rest of the seed
+            log.warning("pin committee program failed (non-gating): %s", exc)
+
         # 3) Plant the interrupted twin of the completed run — a rich `running`
         # row frozen right after iteration 2 (real iterations/candidates/scores
         # + its own linked traces), sharing the completed run's `log_dir` so the
@@ -651,6 +910,14 @@ def main() -> int:
         code, _ = _post(endpoint, "/api/v1/traces/batch", notebook_batch, api_key)
         log.info("seeded RLM notebook trace (status %s)", code)
 
+        # 4a) Plant a SECOND DistrictCounter RLM trace, frozen mid-flight as an
+        # in_progress live notebook (CMP-634) so the demo shows the live-streaming
+        # autofill next to the completed run above. No end_time, partial trajectory,
+        # status in_progress → serve renders the "running" notebook. Left unstamped
+        # (a live run predates any deployment link).
+        code, _ = _post(endpoint, "/api/v1/traces/batch", [_notebook_trace_in_progress(now)], api_key)
+        log.info("seeded in-progress RLM notebook trace (status %s)", code)
+
         # 4b) Plant the two CMP-187 tool-span demo traces so every review app
         # shows RLM tool spans (SourceCategorizer, with a vision sub-LLM nested
         # under Tool.inspect_page) and the function-tool vs module-tool
@@ -683,6 +950,22 @@ def main() -> int:
             )
         else:
             log.warning("skipping ToolKindDemo seed: fixture missing at %s", _TOOL_KIND_DEMO_FIXTURE)
+        # A dspy.ReAct(ExtractCommittee) trace (CMP-634): reasons, calls a
+        # `lookup_disclaimer` tool to pull the "Paid for by" line, then extracts
+        # the committee — the tool-span ReAct exemplar the golden-path demo lacked.
+        if _REACT_COMMITTEE_FIXTURE.exists():
+            tool_demos.append(
+                _replay_flat_fixture(
+                    _REACT_COMMITTEE_FIXTURE,
+                    now,
+                    "ReAct",
+                    _SEED_TAGS + [_GOLDEN_PATH, "react-demo"],
+                    "committee fundraising email (ReAct + lookup_disclaimer tool)",
+                    "NATIONAL REPUBLICAN SENATORIAL COMMITTEE",
+                )
+            )
+        else:
+            log.warning("skipping ReAct committee seed: fixture missing at %s", _REACT_COMMITTEE_FIXTURE)
         if tool_demos:
             _stamp_deployments(tool_demos, dep_for)
             code, _ = _post(endpoint, "/api/v1/traces/batch", tool_demos, api_key)

{cmpnd-0.7.1 → cmpnd-0.7.2}/tests/e2e/committee_task.py

@@ -47,10 +47,22 @@ _DATA_DIR = pathlib.Path(__file__).resolve().parent / "data"
 # Bedrock's OpenAI-compatible surface, where they are `404 model_not_found` (they live on
 # the native Converse surface litellm translates to), so a run against that plane, or
 # against any other provider, has to be able to say so without editing this file.
-STUDENT_1B = os.getenv("PLATFORM_STRESS_MODEL") or "bedrock/us.amazon.nova-micro-v1:0"  # tiny/cheap; no lift assertion
-STUDENT_3B = os.getenv("PLATFORM_STUDENT_MODEL") or "bedrock/google.gemma-3-4b-it"  # weak-with-headroom; gepa student
+#
+# The DEPLOYED_ variables, because that is what every model here is for: this module's
+# programs are built to be deployed and executed by a data plane, so the plane's provider
+# constraint is theirs. The un-prefixed `PLATFORM_*_MODEL` names configure LMs that a test
+# process calls directly, and reading those here is what made a wasm-plane run also rewire
+# tests that never touch a plane. `_provider` (which this module cannot import — it
+# predates the stress suite's resolver and is shared with a lane that has no wasm plane)
+# carries the full note.
+STUDENT_1B = (
+    os.getenv("PLATFORM_DEPLOYED_STRESS_MODEL") or "bedrock/us.amazon.nova-micro-v1:0"
+)  # tiny/cheap; no lift assertion
+STUDENT_3B = (
+    os.getenv("PLATFORM_DEPLOYED_STUDENT_MODEL") or "bedrock/google.gemma-3-4b-it"
+)  # weak-with-headroom; gepa student
 REFLECTION_MODEL = (
-    os.getenv("PLATFORM_REFLECTION_MODEL") or "bedrock/us.meta.llama3-3-70b-instruct-v1:0"
+    os.getenv("PLATFORM_DEPLOYED_REFLECTION_MODEL") or "bedrock/us.meta.llama3-3-70b-instruct-v1:0"
 )  # gepa reflection (resolved server-side)
 
 
@@ -89,8 +101,11 @@ def lm_api_base() -> str | None:
     ``lm_api_host``, which seeds the org's provider key, which is what the plane later
     resolves into ``inference.student.api_base``. Without it a run there fails on the
     broker's own "no api_base" refusal.
+
+    ``PLATFORM_DEPLOYED_LM_API_BASE``, matching the model ids above: this base is declared
+    on a program the PLANE runs, so it must not also redirect a test's own litellm calls.
     """
-    return os.getenv("PLATFORM_LM_API_BASE") or None
+    return os.getenv("PLATFORM_DEPLOYED_LM_API_BASE") or None
 
 
 def _lm_kwargs() -> dict[str, Any]: