cmpnd 0.67.0__tar.gz → 0.69.0__tar.gz

{cmpnd-0.67.0 → cmpnd-0.69.0}/PKG-INFO

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

{cmpnd-0.67.0 → cmpnd-0.69.0}/cmpnd/_authored_import.py

@@ -263,7 +263,6 @@ def _program_facts(
     lm = packaging._extract_lm_object(program)
     lm_kwargs = getattr(lm, "kwargs", {}) if lm is not None else {}
     facts = ProgramFacts(
-        program_signature_hash=identity.compute_program_hash(program),
         entrypoint_kind=kind,
         module_class=type(program).__name__,
         litellm_model=getattr(lm, "model", None),

{cmpnd-0.67.0 → cmpnd-0.69.0}/cmpnd/authored.py

@@ -43,7 +43,6 @@ class SourceCheckError(ValueError):
 class ProgramFacts:
     """Facts derived by importing the staged program without calling forward."""
 
-    program_signature_hash: int | None = None
     entrypoint_kind: str = "instance"
     module_class: str | None = None
     signature_name: str | None = None
@@ -72,11 +71,7 @@ class ProgramFacts:
 
     def deploy_body(self) -> dict[str, Any]:
         """Return fields the deployment create route accepts."""
-        from . import identity
-
         body: dict[str, Any] = {}
-        if self.program_signature_hash is not None:
-            body["program_signature_hash"] = identity.format_signature_hash(self.program_signature_hash)
         for name in (
             "module_class",
             "signature_name",

{cmpnd-0.67.0 → cmpnd-0.69.0}/cmpnd/cli/commands/programs.py

@@ -207,6 +207,19 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     purge.add_argument("--force", action="store_true", help="Skip the confirmation (required when not on a terminal)")
     purge.set_defaults(func=handle_purge)
 
+    rename = sub.add_parser(
+        "rename",
+        help="Name or rename a program",
+        description=(
+            "Make NAME the current name of PROGRAM. The name it had keeps resolving to it, so code that still "
+            "declares the old name reaches the same program, with its id and history. A name another program "
+            "answers to is refused."
+        ),
+    )
+    rename.add_argument("program", metavar="PROGRAM", help="Program name or p_ id")
+    rename.add_argument("new_name", metavar="NAME", help="The program's new name, unique in your organization")
+    rename.set_defaults(func=handle_rename)
+
     select = sub.add_parser("select", help="Pin an optimization run as this program's chosen version")
     select.add_argument("id", help=_COMPILED_HASH_HELP)
     select.add_argument("--run", dest="run_id", required=True, help="Optimization run ID (op_...) to pin")
@@ -624,6 +637,38 @@ def handle_purge(client: api_client.ApiClient, args: Any) -> Any:
     return _trash_write(client, f"/api/v1/programs/{program_id}/purge")
 
 
+def handle_rename(client: api_client.ApiClient, args: Any) -> Any:
+    """Make ``args.new_name`` the current name of the program ``args.program`` names, keeping its id."""
+    from ... import programs
+    from . import top
+
+    try:
+        programs.validate_program_name(args.new_name)
+    except ValueError as exc:
+        raise api_client.CliError(str(exc)) from exc
+    program_id, trashed = resolve(client, args.program, old_server_remedy=_rename_remedy())
+    if trashed:
+        raise api_client.CliError(
+            f"{args.program} is in the Trash. Restore it with `{top.hint_programs('restore', args.program)}` "
+            "before you rename it."
+        )
+    try:
+        return client.post(f"/api/v1/programs/{program_id}/rename", json={"name": args.new_name})
+    except api_client.CliError as exc:
+        # A server from before the rename route answers 405, because its GET dispatcher owns the path.
+        if exc.status_code == 405:
+            _refuse_if_old(client, exc, _rename_remedy(program_id))
+            raise api_client.CliError(
+                f"this cmpnd server predates renaming a program through the API. {_rename_remedy(program_id)}"
+            ) from exc
+        raise
+
+
+def _rename_remedy(program_id: str = "") -> str:
+    where = f"on its page in the web app, at /ui/programs/{program_id}" if program_id else "in the web app"
+    return f"Rename the program {where}, or upgrade the server."
+
+
 def _trash_listing(client: api_client.ApiClient) -> Any:
     """GET the Trash. On a server from before the Trash API it answers 404, which is the old-server signal."""
     try:

{cmpnd-0.67.0 → cmpnd-0.69.0}/cmpnd/cli/verbs.py

@@ -167,6 +167,7 @@ DOMAIN_VERBS: dict[str, str] = {
     "trash": "moves a program to the Trash, where it stays restorable, and delete would read as the permanent purge",
     "restore": "returns a program from the Trash with its history, which create would not",
     "purge": "deletes a program in the Trash for good, the irreversible step after trash",
+    "rename": "gives a program a new current name and keeps the old one resolving to it, which update would hide",
 }
 
 #: Leaves naming a related collection or sub-record rather than an action.

{cmpnd-0.67.0 → cmpnd-0.69.0}/cmpnd/deployment.py

@@ -527,13 +527,10 @@ def deploy_module_under(
     # Package the module
     zip_bytes = packaging.generate_source_zip(module, metric, mcp_tools=pinned_mcp_tools)
 
-    # Compute program identity via the IR reflector on the live module (class
-    # tag included); the signature is kept around only for display metadata.
+    # The deployment names its program by id alone; the signature only describes it.
     sig = packaging._get_module_signature(module)
-    program_signature_hash = identity.compute_program_hash(module) or 0
 
     deploy_body: dict[str, Any] = {
-        "program_signature_hash": identity.format_signature_hash(program_signature_hash),
         # Declare the ZIP's exact length so the server can reject an oversized
         # deploy before the upload.
         "declared_content_length": len(zip_bytes),

{cmpnd-0.67.0 → cmpnd-0.69.0}/docs/cli.md

@@ -99,6 +99,24 @@ also names the `cmpnd programs optimized` command for a compiled program hash.
 program hash, the value in the `program_hash` column of
 `cmpnd programs optimized list`, as `cmpnd programs select` does.
 
+## Renaming a program
+
+`cmpnd programs rename PROGRAM NAME` makes NAME the current name of PROGRAM,
+which is a program name or a `p_` id. The program keeps its id and its
+history. The CLI checks NAME's syntax before it sends anything, looks a
+PROGRAM name up as the other `cmpnd programs` commands do, and sends
+`POST /api/v1/programs/{id}/rename`. The command needs `traces:write` or
+`optimizations:write`.
+
+The old name keeps resolving to the program, so code that still declares it
+reaches the same program. A program with no name takes its first name this
+way, and code that declares the new name with `cmpnd.Program(name, ...)`
+traces to it. Serve refuses a name another live
+program answers to, as its current or a retired name. A program in the Trash
+is refused until `cmpnd programs restore` returns it. A server from before the
+rename route says so, and the error points at the program's page in the web
+app, which renames it too.
+
 ## The Trash
 
 A program in the Trash leaves every view, and its traces with it, until it is

{cmpnd-0.67.0 → cmpnd-0.69.0}/docs/sdk-instrumentation.md

@@ -803,7 +803,9 @@ name form. A program name wins over the config's id. `configure()`
 checks the id's shape and raises `ValueError` on a bad one, and a `Config` built directly
 is checked the same way.
 
-The id rides every body that can declare a program, beside `program_signature_hash`:
+The id rides every body that can declare a program. A deployment create names its program
+by the id alone and sends no `program_signature_hash`. The other bodies still carry the
+hash beside the id:
 
 | Body | Where | Built by |
 |---|---|---|

{cmpnd-0.67.0 → cmpnd-0.69.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.67.0"
+version = "0.69.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.67.0 → cmpnd-0.69.0}/scripts/seed_review_run.py

@@ -25,6 +25,11 @@ Each run is made fresh: every trace/span UUID is remapped to a new one, a fresh
 reserve-then-PUT shape), the traces are linked to it, and all timestamps are
 shifted so the run lands at "now".
 
+Every seeded program is named. The seeder resolves each name to its `p_` id
+through `PUT /api/v1/programs/by-name/{name}` and declares that id on the
+program's traces, runs and deployments, and pins by it. The replayed payloads
+keep the `program_signature_hash` the SDK captured, as the SDK still sends it.
+
 Non-gating: any failure logs and exits 0 (the review pipeline must not break on it).
 
 Env: CMPND_E2E_ENDPOINT, CMPND_E2E_API_KEY (the review app URL + key; no LM keys).
@@ -148,9 +153,9 @@ def _transform(obj, uuid_map: dict[str, str], delta: datetime.timedelta, opt_run
 # A realistic GEPA `log_dir` (== gepa `run_dir`) the resume pair shares. The
 # completed run and its interrupted twin are the SAME job (CMP-442): a laptop
 # sleep / power cut split one optimization into a stuck `running` row plus a
-# separate `completed` row, keyed on this directory. `program_signature_hash`
-# already matches (both are the same committee `Predict`); the shared `log_dir`
-# is what makes them read as one interrupted-then-resumed job.
+# separate `completed` row, keyed on this directory. Both declare the committee
+# program's `p_` id; the shared `log_dir` is what makes them read as one
+# interrupted-then-resumed job.
 _LOG_DIR = "/home/researcher/gepa_runs/committee-3b"
 
 # Freeze the captured run right after iteration 2 — the point where GEPA has
@@ -625,6 +630,50 @@ def _replay_flat_fixture(
     }
 
 
+# The name of each program the seed plants. The seeder resolves each to its p_ id
+# and declares that id; a review app makes each program on its first seed.
+_PROGRAM_COMMITTEE = "committee-extractor"
+_PROGRAM_DISTRICT_COUNTER = "district-counter"
+_PROGRAM_SOURCE_CATEGORIZER = "source-categorizer"
+_PROGRAM_TOOL_KIND_DEMO = "tool-kind-demo"
+_PROGRAM_REACT_COMMITTEE = "react-committee"
+
+
+def _declare_program(payload: dict, program_id: str | None) -> dict:
+    """A copy of a trace or optimization run payload that declares ``program_id``.
+    With no id, the copy declares no program."""
+    out = dict(payload)
+    if program_id is not None:
+        out["program_id"] = program_id
+    return out
+
+
+def _declare_program_traces(traces: list, module_class: str, program_id: str | None) -> list:
+    """Declare ``program_id`` on the captured run's program traces: those whose root
+    module is the run's program class. The optimizer's own traces (GEPA) belong to
+    no program and stay undeclared."""
+    return [
+        _declare_program(t, program_id) if isinstance(t, dict) and t.get("module_class") == module_class else t
+        for t in traces
+    ]
+
+
+def _ensure_program(endpoint: str, api_key: str, name: str) -> str | None:
+    """The p_ id of the program named ``name``, made on first use. Non-gating:
+    None on any failure, and the seed goes on without the program."""
+    try:
+        _status, resp = _post(
+            endpoint, "/api/v1/programs/by-name/" + urllib.parse.quote(name, safe=""), {}, api_key, method="PUT"
+        )
+    except Exception as exc:  # noqa: BLE001 - non-gating, matches the seeder's philosophy
+        log.warning("resolve program %s failed (non-gating): %s", name, exc)
+        return None
+    program_id = resp.get("program_id") if isinstance(resp, dict) else None
+    if not program_id:
+        log.warning("resolve program %s returned no id", name)
+    return program_id
+
+
 def _post(endpoint: str, path: str, payload, api_key: str, method: str = "POST"):
     body = json.dumps(payload).encode("utf-8")
     req = urllib.request.Request(
@@ -650,20 +699,21 @@ def _reserve_optimization(endpoint: str, api_key: str) -> str | None:
     return run_id
 
 
-def _create_deployment(endpoint: str, api_key: str, program_signature_hash: int) -> str | None:
+def _create_deployment(endpoint: str, api_key: str, program_id: str) -> str | None:
     """Create a real deployment row (no ZIP upload) and return its `d_…` id.
 
     The traces-index Deployment filter (CMP-277) reads distinct deployment_id
     off traces, and the ingest sanitizer strips any deployment_id that isn't a
     real deployment for the org — so seeded traces need real rows to point at.
     A create-only POST suffices; the row exists (pending upload) and the
-    sanitizer accepts its id. The program hash lets the filter menu + Deployments
-    page resolve a human program-name label. Non-gating: returns None on any
-    failure so the seed proceeds without the deployment dimension.
+    sanitizer accepts its id. The program id, which the route requires, lets the
+    filter menu + Deployments page resolve a human program-name label.
+    Non-gating: returns None on any failure so the seed proceeds without the
+    deployment dimension.
     """
     payload = {
+        "program_id": program_id,
         "litellm_model": "openai/gpt-4o",
-        "program_signature_hash": program_signature_hash,
         "metadata": {"seed": "true"},
     }
     try:
@@ -677,16 +727,16 @@ def _create_deployment(endpoint: str, api_key: str, program_signature_hash: int)
 def _stamp_deployments(traces: list[dict], dep_for) -> None:
     """Stamp ~2/3 of the traces with the deployment for their own program (every
     third trace left unstamped for a visible deployed/undeployed mix), keying on
-    each trace's program_signature_hash so a deployment's traces coherently share
-    its program. `dep_for(hash) -> id | None` lazily creates + caches one
-    deployment per program hash. No-op for traces without a hash."""
+    each trace's declared program_id so a deployment's traces coherently share
+    its program. `dep_for(program_id) -> id | None` lazily creates + caches one
+    deployment per program. No-op for traces that declare no program."""
     for i, trace in enumerate(traces):
         if i % 3 == 0 or not isinstance(trace, dict):
             continue
-        h = trace.get("program_signature_hash")
-        if h is None:
+        program_id = trace.get("program_id")
+        if not program_id:
             continue
-        dep = dep_for(h)
+        dep = dep_for(program_id)
         if dep:
             trace["deployment_id"] = dep
 
@@ -703,13 +753,6 @@ _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
@@ -718,12 +761,12 @@ def _scrape_csrf(html: str) -> str | None:
     return m.group(1) if m else None
 
 
-def _pin_committee_program(endpoint: str, display_hash: str) -> None:
+def _pin_committee_program(endpoint: str, program_id: 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.
+    Pins are per-user web state, and serve's Pin() is reachable ONLY through the
+    session+CSRF web route POST /ui/programs/{id}/pin, which takes the program's
+    p_ id — 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.
@@ -761,13 +804,13 @@ def _pin_committee_program(endpoint: str, display_hash: str) -> None:
     # 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}"))
+    pin_csrf = _scrape_csrf(get(f"/ui/programs/{program_id}"))
     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)
+    status = post(f"/ui/programs/{program_id}/pin", {"csrf_token": pin_csrf})
+    log.info("pinned committee program %s (status %s)", program_id, status)
 
 
 def main() -> int:
@@ -778,19 +821,19 @@ def main() -> int:
         return 0
 
     try:
-        # Lazily create one real deployment row per program hash the first time a
+        # Lazily create one real deployment row per program the first time a
         # trace of that program is stamped, tied to the program so the filter
         # menu + Deployments page resolve a human program-name label. The ingest
         # sanitizer strips any id without a backing row, so real rows are
         # required for the traces-index Deployment filter (CMP-277). Review apps
         # run CMPND_DEPLOY_BACKEND=lambda, so the create forwards through the
         # per-PR deploy stack; non-gating (cached None) if that's down.
-        dep_cache: dict[int, str | None] = {}
+        dep_cache: dict[str, str | None] = {}
 
-        def dep_for(program_signature_hash: int) -> str | None:
-            if program_signature_hash not in dep_cache:
-                dep_cache[program_signature_hash] = _create_deployment(endpoint, api_key, program_signature_hash)
-            return dep_cache[program_signature_hash]
+        def dep_for(program_id: str) -> str | None:
+            if program_id not in dep_cache:
+                dep_cache[program_id] = _create_deployment(endpoint, api_key, program_id)
+            return dep_cache[program_id]
 
         parts = json.loads(gzip.decompress(_FIXTURE.read_bytes()))
 
@@ -807,11 +850,21 @@ def main() -> int:
         # record to it. It carries the shared `log_dir` so its interrupted twin
         # (step 3) reads as the same job.
         opt = next(p for p in parts if p["kind"] == "optimization")
+        # The captured run optimizes one program, whose root module class the run
+        # records as its program_name. Its runs and program traces declare it.
+        committee_class = opt["payload"].get("program_name") or "Predict"
+        committee_id = _ensure_program(endpoint, api_key, _PROGRAM_COMMITTEE)
         new_op = _reserve_optimization(endpoint, api_key)
         if not new_op:
             log.warning("could not reserve an optimization run id; aborting seed")
             return 0
-        opt_payload = _transform(_with_log_dir(opt["payload"]), uuid_map, delta, opt_run=new_op, tags=_TAGS_COMPLETE)
+        opt_payload = _transform(
+            _declare_program(_with_log_dir(opt["payload"]), committee_id),
+            uuid_map,
+            delta,
+            opt_run=new_op,
+            tags=_TAGS_COMPLETE,
+        )
         _post(endpoint, f"/api/v1/optimizations/{new_op}", opt_payload, api_key, method="PUT")
         log.info("seeded optimization run %s", new_op)
 
@@ -819,7 +872,10 @@ def main() -> int:
         n_traces = n_spans = 0
         for p in parts:
             if p["kind"] == "traces_batch":
-                payload = [_transform(item, uuid_map, delta, new_op, _TAGS_COMPLETE) for item in p["payload"]]
+                payload = [
+                    _transform(item, uuid_map, delta, new_op, _TAGS_COMPLETE)
+                    for item in _declare_program_traces(p["payload"], committee_class, committee_id)
+                ]
                 _stamp_deployments(payload, dep_for)
                 _post(endpoint, "/api/v1/traces/batch", payload, api_key)
                 n_traces += len(payload)
@@ -837,11 +893,10 @@ def main() -> int:
         # 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)))
+            if committee_id is not None:
+                _pin_committee_program(endpoint, committee_id)
             else:
-                log.warning("pin: optimization payload has no program_signature_hash; skipping pin")
+                log.warning("pin: the committee program has no id; 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)
 
@@ -855,7 +910,11 @@ def main() -> int:
         running_op = _reserve_optimization(endpoint, api_key)
         if running_op:
             interrupted = _transform(
-                _interrupted_variant(opt["payload"]), umap, delta, opt_run=running_op, tags=_TAGS_RUNNING
+                _declare_program(_interrupted_variant(opt["payload"]), committee_id),
+                umap,
+                delta,
+                opt_run=running_op,
+                tags=_TAGS_RUNNING,
             )
             code, _ = _post(endpoint, f"/api/v1/optimizations/{running_op}", interrupted, api_key, method="PUT")
             log.info("seeded running (interrupted) optimization run %s", running_op)
@@ -863,7 +922,11 @@ def main() -> int:
             n_it = 0
             for p in parts:
                 if p["kind"] == "traces_batch":
-                    kept = [t for t in p["payload"] if t.get("trace_id") in keep]
+                    kept = [
+                        t
+                        for t in _declare_program_traces(p["payload"], committee_class, committee_id)
+                        if t.get("trace_id") in keep
+                    ]
                     if kept:
                         payload = [_transform(item, umap, delta, running_op, _TAGS_RUNNING) for item in kept]
                         _post(endpoint, "/api/v1/traces/batch", payload, api_key)
@@ -900,7 +963,9 @@ def main() -> int:
         umap = {u: str(uuid.uuid4()) for u in acc}
         rid = _reserve_optimization(endpoint, api_key)
         if rid:
-            failed = _lifecycle_variant(_transform(opt["payload"], umap, delta, rid, _TAGS_FAILED), "failed")
+            failed = _lifecycle_variant(
+                _transform(_declare_program(opt["payload"], committee_id), umap, delta, rid, _TAGS_FAILED), "failed"
+            )
             code, _ = _post(endpoint, f"/api/v1/optimizations/{rid}", failed, api_key, method="PUT")
             log.info("seeded failed optimization run %s (status %s)", rid, code)
         else:
@@ -909,7 +974,8 @@ def main() -> int:
         # 4) Plant a synthetic RLM (predict-with-REPL) trace so the notebook
         # view (CMP-372) has trajectory data to render — the captured
         # optimization run has none. Unlinked to any optimization run.
-        notebook_batch = [_notebook_trace(now)]
+        district_counter_id = _ensure_program(endpoint, api_key, _PROGRAM_DISTRICT_COUNTER)
+        notebook_batch = [_declare_program(_notebook_trace(now), district_counter_id)]
         _stamp_deployments(notebook_batch, dep_for)
         code, _ = _post(endpoint, "/api/v1/traces/batch", notebook_batch, api_key)
         log.info("seeded RLM notebook trace (status %s)", code)
@@ -919,7 +985,12 @@ def main() -> int:
         # 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)
+        code, _ = _post(
+            endpoint,
+            "/api/v1/traces/batch",
+            [_declare_program(_notebook_trace_in_progress(now), district_counter_id)],
+            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
@@ -930,26 +1001,32 @@ def main() -> int:
         tool_demos: list[dict] = []
         if _SOURCE_CATEGORIZER_FIXTURE.exists():
             tool_demos.append(
-                _replay_flat_fixture(
-                    _SOURCE_CATEGORIZER_FIXTURE,
-                    now,
-                    "RLM",
-                    _SEED_TAGS + ["tool-demo"],
-                    "vector_pdf source_table/glenn-pdf-p15.pdf (page 1)",
-                    "candidate_columns, precinct",
+                _declare_program(
+                    _replay_flat_fixture(
+                        _SOURCE_CATEGORIZER_FIXTURE,
+                        now,
+                        "RLM",
+                        _SEED_TAGS + ["tool-demo"],
+                        "vector_pdf source_table/glenn-pdf-p15.pdf (page 1)",
+                        "candidate_columns, precinct",
+                    ),
+                    _ensure_program(endpoint, api_key, _PROGRAM_SOURCE_CATEGORIZER),
                 )
             )
         else:
             log.warning("skipping SourceCategorizer seed: fixture missing at %s", _SOURCE_CATEGORIZER_FIXTURE)
         if _TOOL_KIND_DEMO_FIXTURE.exists():
             tool_demos.append(
-                _replay_flat_fixture(
-                    _TOOL_KIND_DEMO_FIXTURE,
-                    now,
-                    "ToolKindDemo",
-                    _SEED_TAGS + ["tool-demo"],
-                    "espresso place review (function-tool + module-tool)",
-                    "The speaker loved the new downtown espresso place and its incredible pastries.",
+                _declare_program(
+                    _replay_flat_fixture(
+                        _TOOL_KIND_DEMO_FIXTURE,
+                        now,
+                        "ToolKindDemo",
+                        _SEED_TAGS + ["tool-demo"],
+                        "espresso place review (function-tool + module-tool)",
+                        "The speaker loved the new downtown espresso place and its incredible pastries.",
+                    ),
+                    _ensure_program(endpoint, api_key, _PROGRAM_TOOL_KIND_DEMO),
                 )
             )
         else:
@@ -959,13 +1036,16 @@ def main() -> int:
         # 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",
+                _declare_program(
+                    _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",
+                    ),
+                    _ensure_program(endpoint, api_key, _PROGRAM_REACT_COMMITTEE),
                 )
             )
         else:

{cmpnd-0.67.0 → cmpnd-0.69.0}/tests/e2e/test_assessments_cli.py

@@ -29,18 +29,13 @@ def _ns(**kw: object) -> argparse.Namespace:
 
 class TestAssessmentsCliE2E:
     def test_create_list_show_against_live_api(self, server_client, trace_capture):
-        # Produce a real trace to assess under a minted program, then read back its
-        # program hash + a span.
+        # Produce a real trace to assess under a minted program, then read back a span.
         with declaring_program("test_assessments_cli") as program_id:
             dspy.Predict("question -> answer")(question="Who represents District 4?")
             flush_and_wait()
         trace_id = trace_capture.last_trace_id
         assert trace_id is not None, "no trace captured"
         data = server_client.get_trace(trace_id)
-        # The trace API returns the hash as a signed int64 (decimal); the
-        # assessments and modules APIs speak the 16-hex display form. Normalize
-        # so the create/list calls and the assertion compare like for like.
-        program_hash = format(int(data["trace"]["program_signature_hash"]) & 0xFFFFFFFFFFFFFFFF, "016x")
         assert data["spans"], "trace has no spans to annotate"
         span_id = data["spans"][0]["span_id"]
 
@@ -62,9 +57,9 @@ class TestAssessmentsCliE2E:
         )
         assert created["id"].startswith("as_")
         assert created["conclusion"] == "down"
-        # The program hash the server copied off the trace round-trips as the same
-        # 16-hex string the trace read returned — the CLI passes it through verbatim.
-        assert created["program_signature_hash"] == program_hash
+        # The assessment names the trace's program by its id, never by a signature hash.
+        assert created["program_id"] == program_id
+        assert "program_signature_hash" not in created
         anns = {(a["kind"], a["ref"]): a for a in created["annotations"]}
         assert ("span", span_id) in anns
         assert ("output", "/answer") in anns

{cmpnd-0.67.0 → cmpnd-0.69.0}/tests/e2e/test_deploy_programs.py

@@ -219,7 +219,6 @@ class TestDeployBadImportRejected:
             create_resp = client.post(
                 f"{config.endpoint}/api/v1/deployments",
                 json={
-                    "program_signature_hash": 0,
                     "declared_content_length": len(zip_bytes),
                     "program_id": program_id_for(f"test_deploy_programs-{uuid.uuid4().hex[:8]}"),
                     # A worker that spends egress tokens needs the model a token names, so