probe-contracts 0.1.0__tar.gz

probe_contracts-0.1.0/.gitignore

@@ -0,0 +1,57 @@
+# Python
+__pycache__/
+*.py[cod]
+# No trailing slash: a worktree's .venv is often a SYMLINK to a shared venv,
+# and `.venv/` matches only directories (one was committed in #3276).
+.venv
+venv/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# Env / secrets
+.env
+.env.*
+!.env.example
+.secrets/*
+!.secrets/research.env.example
+!.secrets/engine.env.example
+
+# Node / Next.js
+node_modules
+dashboard/.next/
+dashboard/out/
+dashboard/.vercel/
+*.tsbuildinfo
+
+# Session planning scratch (not product)
+tasks/
+
+# OS
+.DS_Store
+.gstack/
+
+# The tap plugin is stdlib-only and ships via the marketplace, not as a
+# resolved package. `uv run --with pytest` writes a lockfile here that reflects
+# test tooling, not the plugin's dependencies.
+agent/plugins/probe-research-tap/uv.lock
+
+# Scratch dir for the coverage-dataset capture (authored tasks, trial trees).
+.work/
+
+# Summary bench: NOTHING under fixtures/ or results/ is ever committed.
+# Fixtures are raw production table slices -- customer data -- and live in
+# the governed bench bucket, fetched by pointer (see
+# scripts/benches/summary_bench/README.md). Reports rendered over them inherit the
+# same tier. Only the harness code and the fixture POINTER manifests belong
+# in git.
+scripts/benches/summary_bench/results/
+scripts/benches/summary_bench/fixtures/
+# Hints bench: prompts, engine answers and labels are customer data and live
+# in a scratchpad (scripts/benches/hints_bench/RECIPE.md); never a .jsonl in the repo.
+scripts/benches/hints_bench/**/*.jsonl
+.venv-agent/
+
+# Reproducible onboarding bundle built from dashboard/onboarding-tutorial.
+dashboard/public/onboarding-tutorial-assets/

probe_contracts-0.1.0/DESIGN.md

@@ -0,0 +1,67 @@
+# probe-contracts: design
+
+## Why a package
+
+Before it, each shared thing had a source and generated or hand-kept copies pinned by parity
+tests: the credential scrubber (3 server copies plus the engine's), the harness registry
+(8 places), the agent view vocabulary, the supersede parser, the overview CSP allowlist, and
+the run/project/artifact vocabularies the dashboard re-spelled in `constants.ts`. This
+package is the one place each of them is defined; consumers import it, and a consumer that
+cannot import a package (a stdlib-only hook, the tap, the dashboard) gets a generated copy
+with a `--check`.
+
+## Records and projections (plan O5)
+
+One record per concept. A record never goes on the wire: every request and response is a
+named projection (`Record.project(*names, **overrides)`) that copies the named fields, in
+order, into a plain model the server subclasses under its wire name. So:
+
+- the frozen ingest `RunOut` keeps exactly its field set while `Run` grows;
+- the projection carries no docstring, config or validator of its own, so a wire shape's
+  OpenAPI schema is byte-identical to the hand-written class it replaced;
+- PATCH bodies stay plain models: `model_fields_set` still tells "sent" from "left out".
+
+Field docs live as comments, not `Field(description=...)`: a description would change
+every projection's OpenAPI schema.
+
+## Vendoring
+
+Imports inside the package are relative, so the CLI wheel can carry it under any parent
+(`probe/_vendor/probe_contracts`). The scrubber's caches key on `__name__.startswith("probe.")`:
+top-level `probe_contracts` (the server) keeps them off, a copy under `probe.` would turn
+them on, as the SDK's own copy does today.
+
+The front door is lazy (`__getattr__`): importing a stdlib-only part must not load pydantic.
+
+## The knowledge engine (engine step 3)
+
+`transcripts/` (the session renderer and the per-event ATIF fragment builder) and `knowledge/`
+(the graph vocabulary research-os writes into the engine, and the gatherer deadlines its client
+timeouts sit above) moved here from prbe-knowledge, so each is defined once. The engine is
+private and cannot install this folder, so it carries a copy: `vendor/probe_contracts/` plus
+`vendor/CONTRACTS_REF` (the research-os commit and every file's sha256), written by
+`scripts/codegen/sync_engine_contracts.py --knowledge-root <engine>` and checked by the engine's parity
+test. Change these files here, then re-vendor the engine and the tap
+(`agent/tools/sync/sync_atif_fragment.py`) together: the engine rebuilds every fragment a client
+sends and compares. Once probe-contracts is on PyPI the engine pins it like any dependency.
+
+## The analytics event catalog (plan X11)
+
+`analytics/events.json` names every product event any Probe runtime sends, once: its enum key,
+its wire name, who sends it (`server`, `agent`, `plugin`, `dashboard`) and one line of why.
+`python -m probe_contracts.codegen` draws each runtime's `Event` from it (server
+`app/external/analytics/generated/`, agent `probe/analytics/generated/`, `@probe/analytics`
+`src/generated/`), and `--check` (test_contracts_codegen.py) fails on a stale copy. JSON, not
+Python, so any runtime can read it and nothing imports it at run time.
+
+- A NAME is unique in the whole catalog and never changes: PostHog insights, dashboards and the
+  Slack destinations key on it. The safety net pins every runtime's names from the code
+  (`tests/safety_net/analytics/`), so the catalog itself cannot drift them silently.
+- A KEY is unique per runtime only: the server's `onboarding.completed` and the browser's
+  `onboarding_completed` are both `ONBOARDING_COMPLETED` in their own enum, and renaming either
+  would rewrite call sites for nothing.
+- The plugin hooks are stdlib scripts loaded by path, so they keep their own constants;
+  `tests/unit/external/test_contracts_analytics.py` pins them to the catalog.
+- Domain lifecycle events are not here: they are `EventType` (`app/shared/event_log.py`), the
+  tenant `events` table's vocabulary, which `record_event` forwards. The test above refuses a
+  catalog name that is also an `EventType`.

probe_contracts-0.1.0/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 prbe.ai
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

probe_contracts-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.5
+Name: probe-contracts
+Version: 0.1.0
+Summary: Probe Research's shared contracts: domain records, their generated client views, and the vocabularies every surface reads.
+Author-email: Probe <team@prbe.ai>
+License: Apache-2.0
+License-File: LICENSE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.9
+Description-Content-Type: text/markdown
+
+# probe-contracts
+
+What Probe Research's server, SDK/CLI and dashboard must agree on, defined once:
+
+- `probe_contracts.records`: the shared domain concepts as classes (`Run`, `Experiment`,
+  `Project`, `Artifact`, `MetricPoint`, `Span`) and the vocabularies their fields use.
+  Wire shapes are named projections of a record (`Run.project(...)`), never the record itself.
+- `probe_contracts.analytics`: the one product-analytics event catalog (`events.json`) and its
+  checked loader (`EventCatalog`).
+- `probe_contracts.codegen`: draws every client view of the records and each runtime's `Event`
+  enum (`python -m probe_contracts.codegen [--check]`).
+- `probe_contracts.transcripts` and `probe_contracts.knowledge`: what the CLI's tap, this server and
+  the knowledge engine must build and name the same way (ATIF fragments, graph vocabulary).
+
+Licensed Apache-2.0. The research-os server installs it from this folder; the
+`probe-research` wheel vendors it at build time until it is published on PyPI.

probe_contracts-0.1.0/README.md

@@ -0,0 +1,16 @@
+# probe-contracts
+
+What Probe Research's server, SDK/CLI and dashboard must agree on, defined once:
+
+- `probe_contracts.records`: the shared domain concepts as classes (`Run`, `Experiment`,
+  `Project`, `Artifact`, `MetricPoint`, `Span`) and the vocabularies their fields use.
+  Wire shapes are named projections of a record (`Run.project(...)`), never the record itself.
+- `probe_contracts.analytics`: the one product-analytics event catalog (`events.json`) and its
+  checked loader (`EventCatalog`).
+- `probe_contracts.codegen`: draws every client view of the records and each runtime's `Event`
+  enum (`python -m probe_contracts.codegen [--check]`).
+- `probe_contracts.transcripts` and `probe_contracts.knowledge`: what the CLI's tap, this server and
+  the knowledge engine must build and name the same way (ATIF fragments, graph vocabulary).
+
+Licensed Apache-2.0. The research-os server installs it from this folder; the
+`probe-research` wheel vendors it at build time until it is published on PyPI.

probe_contracts-0.1.0/probe_contracts/__init__.py

@@ -0,0 +1,51 @@
+"""probe-contracts: what the server, the SDK/CLI and the dashboard must agree on, defined once.
+
+The front door is lazy: `import probe_contracts.scrubber` must not pay for
+pydantic and every record class. `from probe_contracts import Run` loads them.
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+_RECORDS = (
+    "AnchorLevel",
+    "Artifact",
+    "ArtifactStatus",
+    "Experiment",
+    "LineageEntityType",
+    "LineageRelation",
+    "MetricNonFinite",
+    "MetricPoint",
+    "ParentRelation",
+    "Project",
+    "ProjectKind",
+    "Record",
+    "Run",
+    "RunCounts",
+    "RunStatus",
+    "Span",
+)
+
+_CLIENT_MESSAGES = (
+    "Action",
+    "Audience",
+    "ClientMessage",
+    "ClientMessageList",
+    "ClientRefusalBody",
+    "MessageCode",
+    "Severity",
+)
+
+__all__ = [*_RECORDS, *_CLIENT_MESSAGES, "CONTRACTS", "Contracts"]
+
+
+def __getattr__(name: str) -> Any:
+    if name in _RECORDS:
+        return getattr(importlib.import_module(".records", __name__), name)
+    if name in _CLIENT_MESSAGES:
+        return getattr(importlib.import_module(".client_messages", __name__), name)
+    if name in ("CONTRACTS", "Contracts"):
+        return getattr(importlib.import_module(".probe_contracts", __name__), name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

probe_contracts-0.1.0/probe_contracts/agent_surface/DESIGN.md

@@ -0,0 +1,104 @@
+# contracts/probe_contracts/agent_surface: the view vocabulary both agent surfaces speak
+
+## Why one vocabulary, in a module that imports nothing (`agent_surface.py`)
+
+Probe has two agent surfaces over the same research record: the MCP server
+(`agent/src/probe/mcp/`), which external coding agents and the dashboard assistant both read
+through, and the page-generation agent (`app/generation/agent/`). Both answer the same question
+("open this run and show me its trajectory"). If they answer to different words, a researcher who
+learns one surface has learned nothing about the other, and a fix to one silently diverges from
+the other. The MCP already fixed a lineage bug by making that view return ancestry and edges; a
+second, independent matrix would re-break it.
+
+So the vocabulary lives here with no dependencies: the backend reads it directly, and it is
+generated into the agent package (`agent/tools/codegen/gen_views.py`, `make gen-views`). That is the
+direction `agent/schema/openapi.json` already flows: the agent pulls from the backend, the backend
+never writes into the agent.
+
+Coverage may differ, spelling may not. `VIEW_MATRIX` is the union of what the surfaces offer,
+because they genuinely differ. Each surface declares the subset it serves and a test holds it to
+that. Neither may invent a second word for a read the other already named.
+
+## trial (`ViewKind.TRIAL`, 0135)
+
+A rollout as an entity, not a span. It is reached by its rollout span id, which is both the URL
+identity the dashboard uses and the durable metric-point -> rollout -> manifest join, so an agent
+handed a trial link opens the same record a person is looking at. It carries an authored title,
+description and notes, which is what makes it an entity rather than a filter on a run's spans: a
+caveat written on one rollout is invisible from the run that contains 500.
+
+`View.TRIALS` lists them under a run, named like `GROUPS` on an experiment: a trial only ever
+exists under one run, so enumerating them is a view on the container, not a listing with a
+mandatory parent. Before it, a run's trials were reachable only by reading every span the run
+logged and filtering for `rollout`, which returns the span, not the authored Trial, so it cannot
+see a title, a description or a note.
+
+## trial views (the `ViewKind.TRIAL` row of `VIEW_MATRIX`)
+
+A trial is not a notes carrier, the only research entity that is not: a rollout ran once and is
+immutable afterwards, so `description` holds what a later reader needs, and a notes document
+beside it is one more place to look. So it gets identity plus the one read that is its own.
+
+`trajectory` is not reachable by narrowing the run's: the rollout's descendants are a subtree,
+and the spans route filters by direct `parent_span_id` only, so an agent asking a run for "the
+spans of trial X" gets one level and reads it as the whole rollout.
+
+No `artifacts` and no `diff`, both on purpose:
+
+- Run artifacts carry a `span_id`, but the list route has no `span_id` filter, so the view could
+  only narrow a bounded page client-side and would report "no artifacts" for a trial whose
+  manifest sat past the cap.
+- `diff` stays on the run because the sandbox-state route is keyed by the provider's trial name,
+  which a researcher-customized `Trial.name` no longer matches; pointing it at a trial id would
+  404 exactly on the trials someone had bothered to rename.
+
+## Other kinds and views
+
+- `ViewKind.PAPER` (0152): a kind, not a filter on the project's `papers` view, so "open this
+  paper" is a read of a thing, not a narrowing of a list.
+- `ViewKind.TEAM_NOTE`: MCP-only as a readable entity. The assistant is handed this document in
+  its system prompt every turn (`render_team_note`), so a read tool for it would be a second copy
+  of something already in context, and its cap is exactly the assistant's whole tool-result
+  budget.
+- `View.LINEAGE`: both relations, not one or the other (see `_view_run_lineage` in the MCP). The
+  ancestry walk alone answered "no lineage" for a run that had plainly consumed a dataset and
+  produced three artifacts, which an agent reads as fact. On an artifact (0255) it is the
+  file-side half of "what produced this number".
+- `View.VIEWS`: the assistant could create a saved metric view and, before this, not list one
+  back, so a view it saved last week was unfindable by the agent that saved it.
+- `View.CONTENT`: the artifact-content lane (1.36) as a view rather than a generation-only
+  expansion. Publish means publish, so an unpublished artifact refuses this view rather than
+  returning bytes.
+- `View.SUMMARY_HISTORY`: the page's history was a dashboard-only surface, and a recorder that
+  rewrites the summary needs to see what it is replacing and what a person last wrote.
+- `View.PICKS` (#3624): the current pick rode the branches header alone, so pick churn (who
+  overwrote whose pick, and how often) was unreadable by agents.
+
+## VIEW_PURPOSE
+
+One agent-facing line per view, for the error a wrong view raises: it lists the kind's views with
+what each returns. `available_views` on a response stays a bare list (see `_views_offered` in the
+agent's MCP service for why).
+
+Separate from the `#:` comments on `View`, deliberately. Those are for whoever maintains the file
+and say why a view exists, which incident shaped it, what it used to do wrong. The purpose lines
+say what an agent gets if it asks, in one line, and nothing else: a maintainer's note shipped into
+a tool response is context spent on history the caller cannot act on.
+
+Kept beside `VIEW_MATRIX` rather than in the MCP package for the same reason as the matrix: two
+agent surfaces answer with the same words, and a second copy of the vocabulary goes stale. A view
+absent here still works; the list surfaces print its name bare, as they all did before this
+existed (`tests/unit/core/test_agent_view_vocabulary_is_generated.py` still requires a line for every
+view).
+
+## GENERATION_VIEWS
+
+The subset the generation surface serves, declared rather than discovered. It is a third surface,
+and the one that cannot afford a silent miss: an unserved (kind, view) that falls through to a
+card returns a confident answer to a different question, and the summary says it checked
+something it never read. So the pairs are enumerated, a structural test holds the dispatcher to
+exactly this table, and anything outside it refuses by naming what is valid.
+
+It is narrower than `VIEW_MATRIX` where a read has no in-process reader yet (`reproduce`,
+`events`, `diff`, `views`, `handoff`, `code`, `readme`). Those are gaps to close, not words to
+invent: the spelling is already agreed.

probe_contracts-0.1.0/probe_contracts/agent_surface/__init__.py

@@ -0,0 +1 @@
+"""The view vocabulary both agent surfaces speak (`agent_surface.py`)."""