cmpnd 0.6.1__tar.gz → 0.6.2__tar.gz

{cmpnd-0.6.1 → cmpnd-0.6.2}/CLAUDE.md

@@ -2,6 +2,23 @@
 
 Part of the CMPND monorepo. See `../CLAUDE.md` for cross-cutting rules (hash architecture, null handling, testing philosophy).
 
+## This code is released publicly — no private references
+
+Unlike the rest of the monorepo (private), the `cmpnd` package ships to PyPI:
+`python-sdk/cmpnd/**` is **public source**. Anything written there is
+world-readable in the published wheel. So **never put private information in the
+shipped package** — no internal issue-tracker IDs (`CMP-…`), internal URLs or
+dashboards, customer/org names, infra hostnames, or secrets — and that includes
+comments, docstrings, `--help`/CLI strings, error messages, and log lines, not
+just code. Reference an internal ticket in the **commit message or PR
+description** (those live in the private repo), never in the source that ships.
+
+This applies only to the shipped package (`python-sdk/cmpnd/`). Tests
+(`python-sdk/tests/`), `docs/`, and `docs/plans/` are not published in the
+wheel, but prefer keeping issue IDs out of docstrings you might later move into
+the package. When you cite prior work in shipped code, describe the behavior,
+not the ticket.
+
 ## Documentation discipline (docs are as-built, updated in the same commit)
 
 This mirrors the practice that has kept `serve/docs/` in sync with the Go

{cmpnd-0.6.1 → cmpnd-0.6.2}/PKG-INFO

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

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/__init__.py

@@ -131,13 +131,13 @@ def auto_instrument() -> CmpndCallback:
 
     # Persist the compiled-from lineage tag across state-only save/load so a
     # continued optimization still stamps compiled_from_run_id after a disk
-    # reload / process restart (CMP-444).
+    # reload / process restart.
     from . import _program_patch
 
     _program_patch.patch_program_state()
 
     # Emit tool spans for dspy.RLM tool calls, which otherwise bypass
-    # dspy.Tool.__call__'s callbacks and produce no spans (CMP-187).
+    # dspy.Tool.__call__'s callbacks and produce no spans.
     from . import _rlm_patch
 
     _rlm_patch.patch_rlm_tools()

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/_gepa_patch.py

@@ -84,7 +84,7 @@ def patch_gepa() -> None:
 
             # Build the config dict from the GEPA instance, then hand the live
             # program to the shared enrichment helper (one definition of the
-            # optimization_run payload shape, reused by the deploy path — CMP-323).
+            # optimization_run payload shape, reused by the deploy path).
             config = {}
             for key in ["auto", "max_metric_calls", "max_full_evals", "seed", "log_dir"]:
                 val = getattr(self, key, None)
@@ -97,7 +97,7 @@ def patch_gepa() -> None:
             except Exception:
                 pass
 
-            # Restore the up-front budget estimate (CMP-555): for an `auto`
+            # Restore the up-front budget estimate: for an `auto`
             # preset `self.max_metric_calls` is None until GEPA's first budget
             # event, so the initial "running" record shipped 0 and the progress
             # bar / ETA had no denominator. Estimate now instead.
@@ -160,7 +160,7 @@ def patch_gepa() -> None:
         except Exception 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 (CMP-414).
+                # running row start() sent lingers forever.
                 callback._tracker.finalize_error(e)
             raise
 

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/_program_patch.py

@@ -17,7 +17,7 @@ the state-only path, which is the one DSPy steers users toward.)
 
 DSPy exposes no extension point for out-of-band instance state (no
 ``get_extra_state`` / attribute allowlist; ``metadata`` is DSPy-owned). Rather
-than change DSPy upstream (CMP-444 decision), ``patch_program_state()`` wraps
+than change DSPy upstream, ``patch_program_state()`` wraps
 ``dump_state`` / ``load_state`` on the two classes that define them — the
 composite ``Module`` path and the bare ``Predict`` path — to round-trip the tag
 under a namespaced carrier key. Installed lazily from

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/_rlm_patch.py

@@ -1,4 +1,4 @@
-"""Emit tool spans for ``dspy.RLM`` tool calls (CMP-187).
+"""Emit tool spans for ``dspy.RLM`` tool calls.
 
 cmpnd creates a ``TOOL`` span only from DSPy's ``on_tool_start``/``on_tool_end``
 callbacks, and those fire only through ``dspy.Tool.__call__`` (decorated

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/callback.py

@@ -71,7 +71,7 @@ class _CallbackBase:
         self._capture_inputs = (
             capture_inputs if capture_inputs is not None else (config.capture_inputs if config else True)
         )
-        # Emit an in_progress start for every root trace, not just RLM (CMP-257).
+        # Emit an in_progress start for every root trace, not just RLM.
         self._stream_trace_starts = (
             stream_trace_starts if stream_trace_starts is not None else (config.stream_trace_starts if config else True)
         )
@@ -117,7 +117,7 @@ class _CallbackBase:
         self._eval_handler = eval_handler.EvalHandler(self)
 
         # Active optimization run ID - stored on instance for same thread-safety reason.
-        # Prefixed text id (`op_…`), minted via cmpnd.identity (CMP-238).
+        # Prefixed text id (`op_…`), minted via cmpnd.identity.
         self._active_optimization_run_id: str | None = None
 
         # Token usage from LM calls without a trace context (e.g., GEPA reflection calls)
@@ -188,7 +188,7 @@ class _ModuleMixin(_CallbackBase):
             context.set_current_trace(trace)
 
             # Carry the root module's type so serve can classify the trace at
-            # start (CMP-537) — before any span lands — instead of inferring it
+            # start — before any span lands — instead of inferring it
             # from span shape later.
             trace.root_span_type = span_type.value
             # RLM traces use streaming export (per-span); everything else
@@ -197,7 +197,7 @@ class _ModuleMixin(_CallbackBase):
                 trace.streaming = True
             self._streaming_traces[str(trace.trace_id)] = trace.streaming
 
-            # Emit an in_progress start row for EVERY root trace (CMP-257), not
+            # Emit an in_progress start row for EVERY root trace, not
             # just streaming/RLM ones, so a non-RLM program is visible the moment
             # it starts (`traces search --status in_progress`, a lookupable id)
             # instead of only appearing at finalize. `trace.streaming` still
@@ -251,7 +251,7 @@ class _ModuleMixin(_CallbackBase):
                     # Surface the previous turn's code output on THIS (turn N+1)
                     # span so a streaming reader can fill in turn N's notebook
                     # output mid-run, rather than waiting for the whole trajectory
-                    # on the RLM parent span at finalize (CMP-537). The prior
+                    # on the RLM parent span at finalize. The prior
                     # turn's span has already ended + been exported, so it rides
                     # here instead; the RLM's final turn (no successor) still
                     # resolves at finalize. Capped like an output field so a large
@@ -433,7 +433,7 @@ class _ModuleMixin(_CallbackBase):
                         trace._batch_spans = trace_spans
                         exp.export_trace(trace)
 
-                # Correlate the returned Prediction to its trace (CMP-291).
+                # Correlate the returned Prediction to its trace.
                 # Stored under a leading underscore so it stays a plain instance
                 # attribute — a bare name would route into dspy.Prediction's field
                 # store and surface as a phantom output field. Read it back via the
@@ -785,7 +785,7 @@ class _LMMixin(_CallbackBase):
         # new instructions, between evaluations) and metric (an LLM-as-judge /
         # semantic metric scoring outputs, during evaluation). Rather than drop
         # them, wrap each in its own trace linked to the optimization run so it
-        # shows up alongside the student traces (CMP-485). serve's
+        # shows up alongside the student traces. serve's
         # TracedTokensForRun then accounts for their cost from the span, so these
         # must NOT also be added to _orphaned_lm_usage / untraced_lm_usage — that
         # would double-count them in the optimization total.
@@ -821,7 +821,7 @@ class _LMMixin(_CallbackBase):
         is running — instead of assuming every untraced call is reflection (that
         would mislabel judge calls). The trace is named with the umbrella "GEPA";
         the specific model stays on the span's model_name, and `gepa.phase`
-        carries the distinction (CMP-485). Each becomes a standalone one-span
+        carries the distinction. Each becomes a standalone one-span
         trace so the prompt, response, tokens and cost are visible alongside the
         student traces instead of being reduced to an aggregate token count.
         """
@@ -842,7 +842,7 @@ class _LMMixin(_CallbackBase):
         # context stack, so on_lm_start stamped this span with a parent_span_id for
         # a span that isn't in this standalone one-span trace. This span IS the
         # trace's root, so force it parentless and pin it to this trace so tree/root
-        # reconstruction works (CMP-485, Greptile P1).
+        # reconstruction works.
         span.parent_span_id = None
         span.trace_id = trace.trace_id
         trace.signature_name = span.model_name or phase

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/cli/__init__.py

@@ -87,7 +87,7 @@ def main() -> None:
     auth.register(subparsers)
     login.register(subparsers)
 
-    # Org membership (owner-facing approval queue, CMP-126). Always
+    # Org membership (owner-facing approval queue). Always
     # registered — the server gates each action on org ownership, so a
     # non-owner just gets a 403, not a hidden command.
     org.register(subparsers)
@@ -99,7 +99,7 @@ def main() -> None:
     if os.environ.get("CMPND_CLI_ADMIN") == "1":
         admin.register(subparsers)
 
-    # CMP-70: resource subcommands are dev-only until productized.
+    # Resource subcommands are dev-only until productized.
     # Set CMPND_CLI_DEV=1 to expose programs, traces, optimizations,
     # evals, datasets, and deployments in --help.
     if os.environ.get("CMPND_CLI_DEV") == "1":

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/cli/commands/admin.py

@@ -1,7 +1,7 @@
 """Platform-operator commands, hidden behind CMPND_CLI_ADMIN=1.
 
 `cmpnd admin org create|set-owner|list|get|set-limit|set-github-login|elect-owner`
-is the closed-beta org bootstrap and steward surface (CMP-126/CMP-278/CMP-472):
+is the closed-beta org bootstrap and steward surface:
 stand up a shared org with its GitHub auto-join key, anoint its first owner,
 adjust its member cap or GitHub link, and grant ownership from the election
 queue. `cmpnd admin user …` is the operator's user-lifecycle surface (list,

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/cli/commands/org.py

@@ -1,7 +1,7 @@
 """Org membership + ownership commands (customer-facing).
 
-`cmpnd org members …` is the owner's delegated membership surface (CMP-126,
-CMP-278): list the GitHub users who auto-joined and are awaiting approval and
+`cmpnd org members …` is the owner's delegated membership surface: list
+the GitHub users who auto-joined and are awaiting approval and
 admit/decline them (the pull direction), and issue/list/revoke single-use
 invite links for teammates you want to add (the push direction — `invite`
 prints a URL you share out-of-band; the invitee joins as a member when they
@@ -15,7 +15,7 @@ hit /api/v1/org/ownership-requests and are self-scoped to the calling key's
 user — no owner check (a platform admin grants ownership from the election
 queue; the request is just recorded intent).
 
-`cmpnd org keys list|create|revoke` is your own API-key surface (CMP-472):
+`cmpnd org keys list|create|revoke` is your own API-key surface:
 list the keys you've minted, mint a new scoped key (the response carries the
 one-time token — the server stores only its hash), and revoke one. These hit
 /api/v1/org/keys and are self-scoped to the calling key's user — you only ever

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/cli/commands/top.py

@@ -113,8 +113,8 @@ def _hash_fallback(sig: Any) -> str:
     is what someone would copy/paste. Names should be the common case once the
     Program registry has caught up — this is just the fallback.
     """
-    # program_signature_hash now arrives as a decimal string on the wire
-    # (CMP-331); int(sig) below handles both forms. "0" is the unset sentinel
+    # program_signature_hash now arrives as a decimal string on the wire;
+    # int(sig) below handles both forms. "0" is the unset sentinel
     # alongside numeric 0 / None / "".
     if sig in (None, "", 0, "0"):
         return "—"
@@ -379,7 +379,7 @@ def _render_status(d: dict[str, Any], endpoint: str) -> None:
         print(f"  Deploy prog:   {deploy_program_id}")
     print(f"  Status:        {_status(d.get('status', '—'))}  ({age})")
     print(f"  Created:       {d.get('created_at', '—')}")
-    # The caller's deploy(metadata=…) blob, if any (CMP-293) — the
+    # The caller's deploy(metadata=…) blob, if any — the
     # checkpoint/cursor that produced this program. Omitted when empty ({}).
     metadata = d.get("metadata") or {}
     if metadata:

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/cli/shell.py

@@ -92,7 +92,7 @@ def _logged_out_banner(endpoint: str) -> str:
         f"{_c('cmpnd shell', 'bold')} — not signed in ({endpoint}).\n"
         f"  Set {_c('CMPND_API_KEY', 'bold')} (and optionally "
         f"{_c('CMPND_ENDPOINT', 'bold')}), then restart.\n"
-        f"  Browser-based {_c('cmpnd login', 'bold')} is on the way (CMP-69).\n"
+        f"  Browser-based {_c('cmpnd login', 'bold')} is on the way.\n"
     )
 
 
@@ -300,7 +300,7 @@ def _parse_signature_inputs(program_name: str | None) -> list[str]:
     ``run(body=None, **kwargs)`` form for those.
 
     Stopgap: the deployment record only carries ``program_name`` as a
-    string today, not structured input/output fields. CMP-91 tracks
+    string today, not structured input/output fields. A follow-up tracks
     surfacing those on the serializer (sourced from what the deploy
     service already produces for ``/openapi``). Once that lands, delete
     this function and key off the structured fields instead — they'll

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/cli/trace_render.py

@@ -1,6 +1,6 @@
 """Render a trace's span forest as a tree or an ASCII timeline.
 
-Consumed by ``cmpnd traces show <id>`` (CMP-260). The raw
+Consumed by ``cmpnd traces show <id>``. The raw
 ``GET /api/v1/traces/{id}`` response — ``{"trace": {...}, "spans": [...]}``
 with flat, raw-column-named spans — is turned into something readable when the
 caller opts into ``--tree`` / ``--timeline`` (``show`` is JSON by default, like
@@ -241,7 +241,7 @@ def span_line(span: dict[str, Any], *, color: bool) -> str:
     """One span rendered as a single line: '<type label>  <name> · <duration> ·
     <tokens> · <model>', mirroring serve's span-badge + span-name, then the same
     duration string. Used both as a tree node body and as `traces follow`'s
-    per-span line (CMP-258)."""
+    per-span line."""
     # Two visually distinct segments: the span-type label carries the status
     # hue (green/red/yellow), the span name is bold default-foreground. Bold on
     # the terminal's own fg reads on any background; the two never share a color.

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/configuration.py

@@ -78,12 +78,12 @@ class Config:
     max_queue_size: int = 10000
     max_export_workers: int = 4
 
-    # Emit an in_progress trace_start for every root trace (CMP-257), not just
+    # Emit an in_progress trace_start for every root trace, not just
     # RLM, so non-RLM programs (Predict/ReAct/CoT/optimizer students) are
     # visible while running instead of appearing only at finalize. The exporter
     # coalesces start + batch in one flush, so a fast trace still pays a single
     # insert. Set False to opt out of the extra start (traces then reappear only
-    # at finalize, the pre-CMP-257 behavior).
+    # at finalize, the prior behavior).
     stream_trace_starts: bool = True
 
     # Feature flags

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/context.py

@@ -20,7 +20,7 @@ _span_stack: ContextVar[list[models.SpanBuilder] | None] = ContextVar("cmpnd_spa
 _current_eval_run: ContextVar[models.EvalRunBuilder | None] = ContextVar("cmpnd_current_eval_run", default=None)
 
 # Current optimization run context (set during optimization, used to link
-# evals). Prefixed text id (`op_…`), minted via cmpnd.identity (CMP-238).
+# evals). Prefixed text id (`op_…`), minted via cmpnd.identity.
 _current_optimization_run_id: ContextVar[str | None] = ContextVar("cmpnd_current_optimization_run_id", default=None)
 
 

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/deployment.py

@@ -20,7 +20,7 @@ from . import configuration, execution, identity, packaging
 
 logger = logging.getLogger(__name__)
 
-# CMP-293: the deploy metadata blob is a free-form JSON object committed with
+# The deploy metadata blob is a free-form JSON object committed with
 # the deployment record (the checkpoint/cursor that produced the program). Cap
 # its size — a checkpoint/cursor is a pointer, not a payload. Mirrors serve's
 # maxMetadataBytes so the call-site error matches the server's 413.
@@ -127,7 +127,7 @@ def deploy(module, metric=None, timeout=300, metadata=None):
         metadata: Optional free-form structured dict committed atomically with
             the deployment record — somewhere to put the checkpoint/cursor that
             produced this program, so the deployment is self-describing for a
-            continual-learning loop (CMP-293). Must be a JSON-serializable dict
+            continual-learning loop. Must be a JSON-serializable dict
             with string keys, within 64 KiB. Read it back via the deployment
             record (``cmpnd.status`` / the deployment GET API).
 
@@ -155,7 +155,7 @@ def deploy(module, metric=None, timeout=300, metadata=None):
         # slot and reject an oversized deploy before signing it (Slice E).
         "declared_content_length": len(zip_bytes),
     }
-    # CMP-293: carry the caller's metadata blob (validated at the call site) as a
+    # Carry the caller's metadata blob (validated at the call site) as a
     # reserved top-level body key, committed with the deployment record server-side.
     if metadata is not None:
         _validate_deploy_metadata(metadata)
@@ -170,7 +170,7 @@ def deploy(module, metric=None, timeout=300, metadata=None):
 
     # Forward LM credentials so the server can auto-create a Provider+ProviderKey.
     #
-    # CMP-289 credential policy: forward ONLY a key explicitly set on the LM
+    # Credential policy: forward ONLY a key explicitly set on the LM
     # (`lm.kwargs["api_key"]`). Never harvest it from the environment or the
     # boto3 credential chain — auto-resolving and forwarding env credentials
     # (especially AWS access key / secret / session token for a `bedrock/...`
@@ -211,7 +211,7 @@ def deploy(module, metric=None, timeout=300, metadata=None):
         # Surface non-fatal deploy-time warnings (e.g. no provider credential
         # resolves yet, so execute will 422 until one is configured). The
         # server decides — it knows whether a provider exists — so the SDK only
-        # relays. Backward-compatible: absent on older servers (CMP-289).
+        # relays. Backward-compatible: absent on older servers.
         for warning in data.get("warnings") or []:
             logger.warning("deploy: %s", warning)
 

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/eval_handler.py

@@ -51,7 +51,7 @@ class EvalHandler:
 
         dspy, _ = callback._get_dspy()
 
-        # Create the eval run. CMP-313: no id minted here — the server assigns
+        # Create the eval run. No id minted here — the server assigns
         # it via the synchronous export_eval_start below, once the header
         # fields (program/metric/dataset) are populated.
         eval_run = models.EvalRunBuilder(
@@ -180,7 +180,7 @@ class EvalHandler:
             f"dataset_size={eval_run.dataset_size}"
         )
 
-        # CMP-313: the SDK doesn't mint the eval_run_id — the component behind
+        # The SDK doesn't mint the eval_run_id — the component behind
         # the exporter (serve/observe, or deploy in-Lambda) assigns it. Obtain
         # it synchronously now, before any eval trace ships, since every
         # in-flight trace and the dict keys / span below are stamped with it.

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/exporter_http.py

@@ -30,12 +30,12 @@ if TYPE_CHECKING:
     from .optimizers import tracker
 
 # Named for the module this code used to live in, not for the one it lives in
-# now: the per-flush "cmpnd: published N records" line (CMP-291) is a
+# now: the per-flush "cmpnd: published N records" line is a
 # user-visible INFO log, and a logger rename would silently break anyone who
 # filters or levels on `cmpnd.exporter`.
 logger = logging.getLogger("cmpnd.exporter")
 
-# Every exporter body ships gzipped (CMP-314). The motivation is bandwidth on
+# Every exporter body ships gzipped. The motivation is bandwidth on
 # multithreaded GEPA runs over cached LM calls — the same pressure that used to
 # drive thinning adapter spans, which stripped the inputs/outputs people want
 # when debugging an adapter. Compressing the wire instead lets the SDK send the
@@ -88,7 +88,7 @@ class BatchExporter:
         self._transport = transport
         self._queue: queue.Queue[ExportItem] = queue.Queue(maxsize=config.max_queue_size)
         self._shutdown = threading.Event()
-        # Non-destructive flush (CMP-291): a mid-run reader signals the export
+        # Non-destructive flush: a mid-run reader signals the export
         # loop to drain its current batch without ending the loop, then waits
         # for confirmation. Distinct from _shutdown, which ends the loop.
         #
@@ -104,7 +104,7 @@ class BatchExporter:
         self._client: httpx.Client | None = None
         self._executor: ThreadPoolExecutor | None = None
 
-        # Synchronous client for the blocking "start" round-trips (CMP-313).
+        # Synchronous client for the blocking "start" round-trips.
         # Distinct from the background _client (which lives on the export
         # thread); created lazily on first start so unconfigured exporters
         # never open a socket. httpx.Client is safe to share across threads.
@@ -231,7 +231,7 @@ class BatchExporter:
 
     def export_eval_start(self, eval_run: models.EvalRunBuilder) -> str:
         """Create the "running" eval record server-side and return the
-        server-assigned ``eval_run_id`` (CMP-313).
+        server-assigned ``eval_run_id``.
 
         Synchronous and blocking, mirroring ``export_optimization_start``: the
         id must exist before the first eval trace ships. The SDK sends the
@@ -244,7 +244,7 @@ class BatchExporter:
     def export_eval_run(self, eval_run: models.EvalRunBuilder) -> None:
         """Queue an eval-run completion for export (non-blocking).
 
-        CMP-313: this is the completion half of the start/complete split — it
+        This is the completion half of the start/complete split — it
         PATCHes the running record (created by export_eval_start) with results.
         Async is fine; no id is needed back.
         """
@@ -268,7 +268,7 @@ class BatchExporter:
 
     def export_optimization_start(self, optimization_run: tracker.OptimizationTracker) -> str:
         """Create the "running" optimization record server-side and return the
-        server-assigned ``optimization_run_id`` (CMP-313).
+        server-assigned ``optimization_run_id``.
 
         Synchronous and blocking: the id must exist before the first trace
         ships, since every in-flight trace is stamped with it. The SDK no
@@ -378,7 +378,7 @@ class BatchExporter:
                     batch = []
                     last_flush = time.time()
 
-                # Non-destructive flush request (CMP-291): drain everything
+                # Non-destructive flush request: drain everything
                 # currently pending — the local batch (items already pulled off
                 # the queue, which a bare get_nowait() drain would miss) plus
                 # any items still sitting in the queue — then confirm. The loop
@@ -446,7 +446,7 @@ class BatchExporter:
             return
 
         # Snapshot the counters so the end-of-flush confirmation reports what the
-        # server actually accepted, not what we attempted (CMP-291). Safe to read
+        # server actually accepted, not what we attempted. Safe to read
         # without the lock here: _flush_batch runs only on the export thread (or
         # the main thread during shutdown, after the export thread is joined), and
         # all per-flush increments happen on dispatch threads we join via
@@ -506,7 +506,7 @@ class BatchExporter:
                     new_spans[trace_id] = []
                 new_spans[trace_id].append(span_dict)
 
-        # Coalesce start + batch within one flush (CMP-257): if a trace's full
+        # Coalesce start + batch within one flush: if a trace's full
         # batch trace is in this same flush, sending it upserts the row to its
         # final status directly (serve traceUpsertSQL, ON CONFLICT on
         # org_id,trace_id,start_time), so the in_progress start POST is
@@ -574,8 +574,8 @@ class BatchExporter:
                 with self._stats_lock:
                     self._error_count += 1
 
-        # One default-verbosity confirmation per flush that did something
-        # (CMP-291), so a user at INFO can tell "configured" from "actually
+        # One default-verbosity confirmation per flush that did something,
+        # so a user at INFO can tell "configured" from "actually
         # published". Reports the delta in accepted records (a 2xx increments
         # _exported_count) — NOT what we attempted — so a rejected or dropped
         # item never reads as a false success; failures show in the dropped/
@@ -679,7 +679,7 @@ class BatchExporter:
                 self._error_count += len(stats_to_send)
 
     def _send_eval_runs(self, eval_runs_to_send: list[dict[str, Any]]) -> None:
-        # CMP-313: completion is a PATCH to the running record created by the
+        # Completion is a PATCH to the running record created by the
         # synchronous export_eval_start, keyed by the server-assigned id.
         client = self._require_client()
         for eval_run_dict in eval_runs_to_send:

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/helpers.py

@@ -13,7 +13,7 @@ def truncate_field(value: Any, max_size: int, depth: int = 0) -> Any:
 
     Thin delegate to ``models.truncate_field`` — the one truncator, homed in
     ``models`` so ``SpanBuilder.to_dict`` can reach it without the
-    ``helpers``→``models`` circular import (CMP-489). The callback capture path
+    ``helpers``→``models`` circular import. The callback capture path
     (``clean_inputs``/``clean_outputs``/``truncate_outputs``) keeps calling this.
     ``depth`` forwards so a caller entering per-field-value truncation can mark
     the value as nested (``depth=1``) and get the dict key-cap, matching

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/identity.py

@@ -19,7 +19,7 @@ import types as _stdtypes
 import typing
 from typing import Any
 
-# CMP-313: the SDK no longer mints eval/optimization/example ids. They are
+# The SDK no longer mints eval/optimization/example ids. They are
 # server-assigned and opaque to the SDK — the server (observe UUIDs, serve
 # `op_`/`ev_`/`ex_` base62) mints on the synchronous start POST / on ingest,
 # and the SDK adopts whatever it returns. The old new_eval_run_id /
@@ -105,7 +105,7 @@ def format_signature_hash(value: int | None) -> str | None:
     unsafe: any consumer that decodes through an untyped path floats it and
     loses precision above 2^53 (Go ``any``/``map[string]any``, JavaScript
     natively). Carrying it as a string makes the safe representation automatic
-    end to end (CMP-331). Storage stays signed int64; only the wire value is a
+    end to end. Storage stays signed int64; only the wire value is a
     string. ``None`` stays ``None`` (nullable optimization hash); the trace/span
     ``0`` sentinel renders as ``"0"``.
     """
@@ -211,7 +211,7 @@ def compute_valset_identity_hash(example_hashes: list[str]) -> str:
     (``_example_input_hash`` emits ``""``); such a set has no trustworthy identity,
     so return "" (excluded from grouping) rather than hashing the blanks —
     otherwise two unrelated all-blank sets of the same length would collide into
-    one false comparable group (CMP-552 review).
+    one false comparable group.
     """
     if not example_hashes or any(h == "" for h in example_hashes):
         return ""
@@ -269,7 +269,7 @@ def compute_metric_hash(metric_fn: Any) -> str:
     not move when the source gains a comment or reflows whitespace; and it is
     never empty. This replaces an earlier ``inspect.getsource`` hash that
     produced a *different* value per environment (source vs. qualname fallback)
-    and per cosmetic edit, splitting families that should compare (CMP-551).
+    and per cosmetic edit, splitting families that should compare.
     Editing a metric's logic without renaming keeps the hash — intended: runs of
     "the same metric" stay grouped.
     """

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/models.py

@@ -143,7 +143,7 @@ def _safe_serialize(value: Any, _stack: set[int] | None = None) -> Any:
 from . import configuration  # noqa: E402
 
 _MAX_FIELD_JSON_SIZE = 65536  # 64 KB — a whole-payload cap, not just per-leaf
-_MAX_DICT_KEYS = 50  # nested-dict key ceiling (CMP-489); root exempt from the ceiling
+_MAX_DICT_KEYS = 50  # nested-dict key ceiling; root exempt from the ceiling
 
 
 def truncate_field(value: Any, max_size: int = _MAX_FIELD_JSON_SIZE, depth: int = 0) -> Any:
@@ -154,7 +154,7 @@ def truncate_field(value: Any, max_size: int = _MAX_FIELD_JSON_SIZE, depth: int
     leaves become ``{"_truncated": True, ...}`` envelopes. Lives here (not in
     ``helpers``) because ``helpers`` imports ``models``; ``helpers.truncate_field``
     delegates to this so both the callback capture path and ``SpanBuilder.to_dict``
-    share one truncator (CMP-489). ``max_size`` is a whole-payload bound: the
+    share one truncator. ``max_size`` is a whole-payload bound: the
     returned value serializes within ``max_size`` at the top level (depth 0), not
     merely per leaf. ``depth`` exempts the root ``inputs``/``outputs`` dict from the
     nested-dict key ceiling (it still obeys the whole-payload bound — see
@@ -167,7 +167,7 @@ def truncate_field(value: Any, max_size: int = _MAX_FIELD_JSON_SIZE, depth: int
         # branches and the exporter use. json.dumps quotes and (ensure_ascii
         # default) escapes non-ASCII to \uXXXX, matching the exporter's wire
         # bytes (exporter.py); a raw char count or UTF-8 byte count both
-        # undercount that (CMP-489). _size_chars stays the char count.
+        # undercount that. _size_chars stays the char count.
         if len(json.dumps(value)) > max_size:
             return {
                 "_truncated": True,
@@ -187,7 +187,7 @@ def truncate_field(value: Any, max_size: int = _MAX_FIELD_JSON_SIZE, depth: int
         # Show the first up-to-10 items, each recursively truncated to its own
         # slice of the budget. This guarantees >=1 item always survives — an
         # oversized first item becomes its own nested truncated envelope rather
-        # than breaking the loop with an empty preview (CMP-489) — while total
+        # than breaking the loop with an empty preview — while total
         # preview stays bounded to ~max_size. _shown_items equals len(_preview).
         shown = [truncate_field(item, max_size // 10, depth + 1) for item in value[:10]]
         # Whole-payload guard: drop trailing preview items until the emitted
@@ -266,7 +266,7 @@ def _truncate_dict(value: dict[Any, Any], max_size: int, depth: int) -> dict[Any
     ceiling, and a whole-payload size guard.
 
     Never drops a key to save a sibling's bytes (a missing key reads as "data
-    wasn't captured" — the CMP-489 symptom — whereas a truncated value reads as
+    wasn't captured" whereas a truncated value reads as
     expected): keeps small values whole and splits the remaining budget across
     the large ones. Two things can still drop keys, both recorded via a
     ``_type:"dict"`` envelope (``_total_keys``/``_shown_keys``, kept keys nested
@@ -534,7 +534,7 @@ class TraceBuilder:
     span_count: int = 0
 
     # Run associations - link traces to eval and optimization runs.
-    # Prefixed text ids (`ev_…`/`op_…`), minted via cmpnd.identity (CMP-238);
+    # Prefixed text ids (`ev_…`/`op_…`), minted via cmpnd.identity;
     # serve stores them in text columns. trace_id stays a UUID (OTel, Family 1).
     eval_run_id: str | None = None
     optimization_run_id: str | None = None
@@ -546,7 +546,7 @@ class TraceBuilder:
     streaming: bool = False
     # The root module's span type (e.g. "rlm"), sent in the /start payload so
     # serve can classify a streaming trace the moment it starts — before any
-    # span has landed — rather than inferring it from span shape later (CMP-537).
+    # span has landed — rather than inferring it from span shape later.
     root_span_type: str | None = None
     _batch_spans: list["SpanBuilder"] = field(default_factory=list)
 
@@ -678,7 +678,7 @@ class EvalExampleBuilder:
 
     # eval_run_id links the example to its run (`ev_…`/UUID, server-assigned,
     # so str | None — it mirrors the run's id, which is None until eval start).
-    # example_id is NOT carried: the server mints it on ingest (CMP-313), so
+    # example_id is NOT carried: the server mints it on ingest, so
     # the SDK never sends one. trace_id stays a UUID (OTel, Family 1).
     eval_run_id: str | None
     example_index: int
@@ -751,7 +751,7 @@ class EvalExampleBuilder:
 class EvalRunBuilder:
     """Mutable builder for tracking evaluation runs."""
 
-    # CMP-313: server-assigned at eval start (was SDK-minted). Stays None until
+    # Server-assigned at eval start (was SDK-minted). Stays None until
     # export_eval_start adopts the server's value (`ev_…` on serve, UUID on
     # observe); the SDK never mints or inspects its shape.
     eval_run_id: str | None = None
@@ -773,7 +773,7 @@ class EvalRunBuilder:
     adapter_type: str | None = None
 
     # Optimization link (set when eval is conducted during an optimization run).
-    # Prefixed text id (`op_…`), minted via cmpnd.identity (CMP-238).
+    # Prefixed text id (`op_…`), minted via cmpnd.identity.
     optimization_run_id: str | None = None
 
     # Status
@@ -868,7 +868,7 @@ class EvalRunBuilder:
             self.duration_ms = int((self.end_time - self.start_time).total_seconds() * 1000)
 
     def to_start_dict(self) -> dict[str, Any]:
-        """Minimal 'running' header for the synchronous eval-start POST (CMP-313).
+        """Minimal 'running' header for the synchronous eval-start POST.
 
         Sends the "new" sentinel — the server mints the eval_run_id and returns
         it. Carries only what's needed to persist a running header; per-example

{cmpnd-0.6.1 → cmpnd-0.6.2}/cmpnd/optimization.py

@@ -21,7 +21,7 @@ Flow per :func:`optimize` call:
 Returns the best :class:`~cmpnd.execution.DeployedProgram` directly — call it
 like the module you handed in. Its ``.score`` carries the best score found, so
 ``optimize()`` matches ``deploy()``'s shape (a program you call) and just also
-tells you how good it is. (Per-step lineage / baseline scoring is CMP-283.)
+tells you how good it is.
 """
 
 from __future__ import annotations
@@ -367,7 +367,7 @@ def _upload_bundle(client: httpx.Client, initiated: dict[str, Any], bundle: byte
     """Upload the optimization bundle to the slot the initiate step returned.
 
     Two postures, one path — keyed on ``upload_fields`` exactly as the deploy
-    upload is (CMP-94):
+    upload is:
 
     - **Presigned POST** (the deploy Lambda stack): ``upload_fields`` is a
       non-empty form the destination key is pinned by; the bundle rides as the