watchlight-agent-sdk 0.5.0__py3-none-any.whl

watchlight_agent_sdk-0.5.0.dist-info/METADATA

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: watchlight-agent-sdk
+Version: 0.5.0
+Summary: Watchlight Agent SDK — build governed AI-agent plugins for any framework
+Author-email: Watchlight AI <team@watchlight.ai>
+License: Apache-2.0
+Project-URL: Homepage, https://www.watchlight.ai
+Project-URL: Documentation, https://docs.watchlight.ai
+Project-URL: Repository, https://github.com/watchlight-ai-beacon/watchlight
+Project-URL: Plugin SDK Guide, https://github.com/watchlight-ai-beacon/watchlight/tree/main/plugins
+Keywords: watchlight,ai-governance,agent-runtime,ai-agents,agent-sdk,policy-decision-point,cedar-policy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: typing-extensions>=4.5; python_version < "3.12"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: cryptography>=42; extra == "dev"
+Requires-Dist: requests>=2.32; extra == "dev"
+Provides-Extra: otlp
+Requires-Dist: opentelemetry-api>=1.20; extra == "otlp"
+Requires-Dist: opentelemetry-sdk>=1.20; extra == "otlp"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20; extra == "otlp"
+
+# watchlight-core
+
+Shared HTTP client and governance primitives used by every Watchlight
+AI framework plugin (`watchlight-adk`, `watchlight-langgraph`,
+`watchlight-bedrock`, …).
+
+## Why this exists
+
+Until #312, the same APDP HTTP client lived as three near-identical
+copies under each framework plugin. As the contract stabilised across
+ADK / LangGraph / Bedrock, three copies became the right trigger for
+extraction. This package is the single source of truth for:
+
+- The HTTP wire format with WL-APDP (`ApdpClient`)
+- Plan-validation / preflight result wrappers (`PlanResult`,
+  `PreflightResult`)
+- The plan-normalisation contract (`normalize_plan`)
+- The framework-agnostic `GovernanceState` shape consumed by the
+  Beacon Dashboard / Streamlit governance card
+- The base run-handle lifecycle (`BaseRunHandle`)
+- Shared error types and the `governance_mode` env reader
+- Plugin telemetry contract (`GovernanceTelemetry`)
+
+## What's intentionally NOT here
+
+Framework-specific behaviour stays in the plugin packages:
+
+- ADK lifecycle callbacks + `PlanReActPlanner` parser + `BaseToolset`
+  — `watchlight-adk`
+- LangGraph plan-and-execute primitives — `watchlight-langgraph`
+- AWS Bedrock event parsing + Lambda action-group decorator +
+  `bedrock_session_attributes()` helper — `watchlight-bedrock`
+
+## Install
+
+```bash
+# Minimal — APDP client + governance primitives only
+pip install watchlight-core
+
+# With OpenTelemetry export support (adds ~50MB of OTel SDK deps)
+pip install 'watchlight-core[otlp]'
+
+# Or in this monorepo:
+pip install -e plugins/watchlight-core
+pip install -e 'plugins/watchlight-core[otlp]'
+```
+
+Plugins depend on it explicitly via their `pyproject.toml`; the core
+package depends only on `httpx` and (on Python 3.10) `typing-extensions`.
+The `[otlp]` extra pulls in `opentelemetry-api`, `opentelemetry-sdk`, and
+`opentelemetry-exporter-otlp-proto-http` — optional so cold-start-
+sensitive environments (Lambda, Cloudflare Workers) don't pay the install
+weight when they're not exporting to OTel.
+
+## Public API
+
+```python
+from watchlight_core import (
+    # HTTP client
+    ApdpClient,
+
+    # Errors
+    WatchlightError,
+    AgentNotRegistered,
+    GovernanceUnavailable,
+
+    # Result wrappers
+    PlanResult,
+    PreflightResult,
+
+    # Plan / state
+    normalize_plan,
+    GovernanceState,
+    GovernanceTelemetry,
+    state_from_attrs,
+
+    # Lifecycle
+    BaseRunHandle,
+    GovernedPlugin,
+
+    # Custom-agent SDK (EN.6)
+    watchlight,
+
+    # OpenTelemetry export (EN.6) — requires [otlp] extra at construction
+    OtlpConfig,
+    OtlpProfile,
+    WatchlightOtlpExporter,
+
+    # Env
+    governance_mode,
+)
+```
+
+### Custom-agent SDK (`@watchlight`)
+
+For agents NOT built on a framework with a Watchlight plugin (LangGraph,
+ADK, Bedrock), the `@watchlight` decorator emits the canonical lineage
+events for any Python function:
+
+```python
+from watchlight_core import ApdpClient, watchlight
+
+client = ApdpClient(base_url="http://localhost:8081")
+
+@watchlight(agent_id="custom-research", apdp_client=client)
+async def run_research(query: str) -> str:
+    # Your agent logic — emits execution_started / completed / failed
+    return result
+```
+
+### OpenTelemetry export
+
+Opt-in customer observability — sends a deliberate **subset** of the
+lineage stream to your OTel collector. Default is `profile=off`; the
+exporter is a no-op until you turn it on.
+
+```python
+from watchlight_core import OtlpConfig, WatchlightOtlpExporter
+
+# Profile ladder: off ⊂ metrics ⊂ standard ⊂ governance
+otlp = WatchlightOtlpExporter(OtlpConfig.from_env())
+# WL_OTLP_PROFILE=standard
+# WL_OTLP_ENDPOINT=http://otel-collector:4318
+```
+
+Tool arguments, LLM prompts, ABR raw scores, drift baselines, and
+security-internal anomalies never leave Watchlight. The exported subset
+is documented in `dev-docs/architecture/otlp-export.md`.
+
+The package exposes a `py.typed` marker so type checkers (mypy, pyright)
+pick up the inline annotations directly.
+
+## Contract stability
+
+Anything in `watchlight_core/__init__.py`'s `__all__` is a **stable
+public API** under SemVer minor-version compatibility. Anything else
+is internal and may move between minor versions.
+
+When changing the wire format with WL-APDP (e.g. adding a route or
+field), update `ApdpClient` here — the plugins inherit it for free.
+
+## Building a new plugin
+
+Implement the framework integration surface (lifecycle hooks, native
+plan format, etc.) in your plugin package and use this package for
+everything else:
+
+1. Inherit `GovernanceTelemetry` to satisfy the `last_*` contract.
+2. For frameworks with explicit primitives (LangGraph, Bedrock):
+   subclass `BaseRunHandle` and add framework-specific helpers; expose
+   `start_run(slug)` returning your subclass.
+3. For frameworks with lifecycle callbacks (ADK): use `ApdpClient`
+   directly and populate the `last_*` attributes from your callbacks.
+4. Provide a one-line `state_from_<framework>_plugin` state helper
+   using `state_from_attrs(plugin, framework="<name>")`.
+
+The `GovernanceState` shape parity test in your plugin's test suite
+guarantees the dashboard renders consistently across frameworks.
+
+## Cross-references
+
+- Multi-framework contract: `dev-docs/architecture/proxy-plugin-interop.md` §6
+- Threat model: `dev-docs/security/HARDENING.md` (entries #301, #312, plus this PR's entry)
+
+## Open-source by design — the plugin is glue
+
+This package (and the framework plugins built on it) ships as readable,
+Apache-2.0 source. That's safe because **all authorization decisions, scope
+strict-subset attenuation, lineage/audit signing, and drift/anomaly scoring are
+server-side** — in the compiled Rust core (`wl-apdp`) and the governed platform.
+The plugin registers hooks, shapes a request, round-trips it to the PDP, and
+projects the answer.
+
+There is **no differentiating IP to strip** for a community build: the
+difference between Developer Edition and Enterprise is the *backend* the plugin
+talks to (the in-process DE engine vs. the full governed plane), never the
+plugin code. And because any decision made client-side is *bypassable*, keeping
+enforcement server-side is a security rule, not just an IP one.
+
+This boundary is documented in [`plugins/CONTRIBUTING.md`](../CONTRIBUTING.md)
+and enforced in CI by the plugin IP-boundary gate
+(`scripts/ci/check_plugin_ip_boundary.py`).

watchlight_agent_sdk-0.5.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+watchlight_core/__init__.py,sha256=eQ13zudOF7ke3wzdzagyYEUCvlsh6nXe41o0HOVv1FQ,10364
+watchlight_core/__main__.py,sha256=lmWetuNAdAjx-hRhPB-OLEG44yj-qZ-aOYuPmf398uA,397
+watchlight_core/apdp_client.py,sha256=m5BIlWSfIDzIe75ertnbGh521ADyq8GRVPjNSapQFpo,40039
+watchlight_core/conformance.py,sha256=jsPa5BE1_EkgcwMeBYy4mGLXybRUwmBY9UBJ1bj2-zM,94460
+watchlight_core/connect_proxy.py,sha256=T0kvze0OAeb27kAwJBRog3WkCRdt4h21rxmRdOY8NlA,26246
+watchlight_core/credentials.py,sha256=qYDpcEye2uHDv_ooNJvAz0XZFYerqiYFn6x1ccIxYzQ,25452
+watchlight_core/decision.py,sha256=fWJQNNrKB3VCYqTLpwvKkL6-Juw91a3FSknB48rWj5I,49198
+watchlight_core/declare_intent.py,sha256=qXlvuHfToYM0M8o3l74lv7qkkf4vQFhqs1aZx0Vwfdw,14043
+watchlight_core/decorator.py,sha256=hKNBKCKx7pWw2xmRR833QPy5NMnHWgyGHkfj4StHz9I,15332
+watchlight_core/env.py,sha256=ff-jDECh0-NhW8c52EzHek7NY8IZZovYPtipyXWEuk4,832
+watchlight_core/errors.py,sha256=Txfox_uwoXC3pm0vxmigvpqZ7D_yJ6WrbsMzLio4_68,11458
+watchlight_core/events_schema.py,sha256=JLppEas6jdJ3gMA83TtNagOgvo8l3C3t39OuyrhbajI,30209
+watchlight_core/in_process_client.py,sha256=x58KGszayu0iqFqNz9BsM1INTCPlHy95v6sQg1H6QqM,11812
+watchlight_core/kill_signal.py,sha256=1p9ytEm_CaMmjHeZDPbDQn-anOzn09AVIE4hEW0bQOw,19474
+watchlight_core/otlp.py,sha256=1dWvn8bAo4qkZhNoiHILZMChMHUPwZU8N8wf9LJIC14,36485
+watchlight_core/plan.py,sha256=yZL3DxZTp0uXxxLdn0bNz7dw9xCsC2ssmVVHgZPyiAQ,3437
+watchlight_core/plan_event.py,sha256=Nm7xzqMLRr9_78VT-tQW6CcTZBRg-EHOCrs1pmmtUFc,6353
+watchlight_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+watchlight_core/results.py,sha256=Gb2x8BomDXL7TC3opiY2hwyrYXK83vttkSS0SakKz-A,8491
+watchlight_core/run_handle.py,sha256=wgVe-CeTTksyo1DbQy5Q56oHBHnWdzgPaN0XuIWrz3s,179209
+watchlight_core/scope.py,sha256=AwAp-12Kv21a_T_m08e3hRNm83JiEUCuIL9RKewUNHc,19007
+watchlight_core/sidecar.py,sha256=QU4ST4CQyz3o-EnJeqREkWjrRZSxv74VMuQe5O_BNnU,9476
+watchlight_core/state.py,sha256=CNWdklncaNB0z2Kw9E5rOnb1Nzsji8xGlUg8p9Mq4Dw,4380
+watchlight_core/subagent_registry.py,sha256=jdUo72zkeBPd8XCpsttbccWneo2Sz8XXONX0DBwrbBI,19613
+watchlight_core/telemetry.py,sha256=5oC9LgLisMZco3H4yXZweD0WBH8mJXRVjzBEeRMxl58,3162
+watchlight_core/testing.py,sha256=czSvy5xfYl5uWICbc6RzQJ8ihlS-Me4jfm1FqNffZPg,31639
+watchlight_agent_sdk-0.5.0.dist-info/METADATA,sha256=jH-Abcl07GjCJdM0H7ob7heBC_Dm1yT6zU5vCK9TjBw,8159
+watchlight_agent_sdk-0.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+watchlight_agent_sdk-0.5.0.dist-info/entry_points.txt,sha256=ZQf77xM52PLaOlyLLIJ9S2hC6uURm3zCzxHI6_ez1ts,77
+watchlight_agent_sdk-0.5.0.dist-info/top_level.txt,sha256=rdAml4jKiOja7d6WmXx57XXRLO1lIbPmtlmjOu0mw-k,16
+watchlight_agent_sdk-0.5.0.dist-info/RECORD,,

watchlight_agent_sdk-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

watchlight_agent_sdk-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+watchlight-conformance = watchlight_core.conformance:_main

watchlight_agent_sdk-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+watchlight_core

watchlight_core/__init__.py

@@ -0,0 +1,355 @@
+"""Watchlight AI shared governance primitives — used by every framework plugin.
+
+This package is the single source of truth for:
+
+- The HTTP wire format with WL-APDP (``ApdpClient``)
+- The plan-validation / preflight result wrappers
+- The plan-normalisation contract
+- The framework-agnostic ``GovernanceState`` shape rendered by the
+  Streamlit / Beacon Dashboard governance card
+- The base run-handle lifecycle (resolve → session → manifest → close)
+- Shared error types and the ``governance_mode`` env reader
+
+Framework-specific behaviour stays in the plugin packages
+(``watchlight-adk``, ``watchlight-langgraph``, ``watchlight-bedrock``,
+…). When you bring up a new plugin, you only own the framework
+integration surface; everything in this module is reused.
+
+Public API is intentionally narrow. Anything not re-exported here is
+considered internal to a future minor release.
+"""
+
+from .apdp_client import ApdpClient
+from .in_process_client import GovernanceBackend, InProcessClient
+from .connect_proxy import (
+    install_connect_proxy,
+    is_connect_proxy_installed,
+    uninstall_connect_proxy,
+)
+from .sidecar import (
+    install_sidecar,
+    is_sidecar_installed,
+    uninstall_sidecar,
+)
+from .credentials import (
+    Credential,
+    CredentialKind,
+    CredentialNotFound,
+    InvalidCredential,
+    PluginCredential,
+    ServiceCredential,
+)
+from .declare_intent import (
+    BROWNFIELD,
+    DECLARE_INTENT_RESPONSE_STATUS,
+    DECLARE_INTENT_TOOL_DESCRIPTION,
+    DECLARE_INTENT_TOOL_NAME,
+    GREENFIELD,
+    INTENT_ENFORCEMENT_MODE_ENV_VAR,
+    WATCHLIGHT_DECLARE_INTENT_TOOL,
+    handle_declare_intent_call,
+    is_declare_intent_tool_call,
+    is_declare_intent_tool_name,
+    resolve_intent_enforcement_mode,
+    should_inject_synthetic_tool,
+    truncate_intent_objective,
+)
+from .decision import (
+    AgentQuarantinedError,
+    AgentRevokedError,
+    AllowDecision,
+    Attenuation,
+    AuthorizationDecision,
+    DenyDecision,
+    Escalation,
+    ExecutionTerminatedError,
+    NeedsApprovalDecision,
+    Observation,
+    QuarantineDecision,
+    RevokeDecision,
+    RunHandleState,
+    SeverSubtreeDecision,
+    SubtreeSeveredError,
+    TerminateDecision,
+    parse_authorization_decision,
+)
+from .decorator import watchlight
+from .errors import (
+    AgentNotRegistered,
+    CredentialProbeFailed,
+    GovernanceUnavailable,
+    InsecureChannelError,
+    RunHandleInvalidated,
+    ScopeAttenuationDenied,
+    ScopeViolationDimension,
+    WatchlightContractError,
+    WatchlightError,
+)
+from .env import governance_mode
+from .events_schema import (
+    EVENT_ID_PATTERN,
+    EVENT_ID_RE,
+    ERROR_MESSAGE_MAX_CHARS,
+    INPUT_SUMMARY_MAX_CHARS,
+    INTENT_OBJECTIVE_MAX_BYTES,
+    LIFT_REASON_MAX_BYTES,
+    MAX_CONTRIBUTING_FEATURES,
+    REASON_MAX_BYTES,
+    ActionRef,
+    CredentialRef,
+    EventEnvelope,
+    EventType,
+    ExecutionEvent,
+    ExecutionQuarantinedPayload,
+    ExecutionResumedPayload,
+    FeatureContribution,
+    IntentProvenance,
+    PrincipalRef,
+    ResourceRef,
+    summarize_arg_keys,
+    truncate_error_message,
+    truncate_summary,
+)
+from .kill_signal import (
+    DISPOSITION_GRACEFUL,
+    DISPOSITION_PROXY_HARD_KILL,
+    InterceptorKillRegistry,
+    KILL_SIGNAL_GRACEFUL_WINDOW_MS,
+    KillSignalResult,
+    LLM_CALL_INTERRUPTED_REASON_HARD_TIMEOUT,
+    LLM_CALL_INTERRUPTED_REASON_MANUAL_TERMINATE,
+    LLM_CALL_INTERRUPTED_REASON_POLICY_TERMINATE,
+    LLM_CALL_INTERRUPTED_REASON_QUARANTINE,
+    LLM_CALL_INTERRUPTED_REASON_REVOKE,
+    LLM_CALL_INTERRUPTED_REASON_SCOPE_VIOLATION,
+    LLM_CALL_INTERRUPTED_REASON_SEVER_SUBTREE,
+    LlmCallInterruptedPayload,
+    LlmCallInterruptedValidationError,
+    RegisterRequestOptions,
+    httpx_hard_kill_escalator,
+)
+from .otlp import (
+    OtlpConfig,
+    OtlpProfile,
+    WatchlightOtlpExporter,
+)
+from .plan import normalize_plan
+from .plan_event import (
+    PLAN_INTENDED_TOOLS_MAX,
+    PLAN_RATIONALE_MAX_BYTES,
+    PLAN_TOOL_NAME_PATTERN,
+    PLAN_TOOL_NAME_RE,
+    PlanKind,
+    PlanValidationError,
+    build_plan_payload,
+    filter_valid_tool_names,
+    is_valid_tool_name,
+    truncate_rationale,
+)
+from .results import AuthorizeResult, PlanResult, PreflightResult
+from .run_handle import (
+    BaseRunHandle,
+    GovernedPlugin,
+    HandleLineage,
+    current_handle_lineage,
+    current_subagent_handle,
+)
+from .scope import (
+    GrantedScope,
+    ParentSignature,
+    RequestedScope,
+    ResourceMatcher,
+    SpawnSubagentRequest,
+    SpawnSubagentResponse,
+    granted_scope_from_dict,
+    granted_scope_to_dict,
+    parent_signature_from_dict,
+    parent_signature_to_dict,
+    requested_scope_from_dict,
+    requested_scope_to_dict,
+    resource_matcher_from_dict,
+    resource_matcher_to_dict,
+    spawn_subagent_request_from_dict,
+    spawn_subagent_request_to_dict,
+    spawn_subagent_response_from_dict,
+    spawn_subagent_response_to_dict,
+)
+from .state import GovernanceState, state_from_attrs
+from .subagent_registry import (
+    DEFAULT_SUBAGENT_SCOPE_ENV_VAR,
+    SubagentRegistry,
+    default_subagent_scope_from_env,
+)
+from .telemetry import GovernanceTelemetry
+
+__all__ = [
+    # Client
+    "ApdpClient",
+    "InProcessClient",
+    "GovernanceBackend",
+    # CONNECT local sidecar proxy (M37-B3)
+    "install_connect_proxy",
+    "is_connect_proxy_installed",
+    "uninstall_connect_proxy",
+    "install_sidecar",
+    "is_sidecar_installed",
+    "uninstall_sidecar",
+    # Credentials
+    "Credential",
+    "CredentialKind",
+    "CredentialNotFound",
+    "InvalidCredential",
+    "PluginCredential",
+    "ServiceCredential",
+    # Decorator (custom-agent SDK)
+    "watchlight",
+    # Errors
+    "WatchlightError",
+    "WatchlightContractError",
+    "AgentNotRegistered",
+    "CredentialProbeFailed",
+    "GovernanceUnavailable",
+    "InsecureChannelError",
+    # M43-E — sub-agent scope attenuation typed errors
+    "RunHandleInvalidated",
+    "ScopeAttenuationDenied",
+    "ScopeViolationDimension",
+    # OTLP export (EN.6)
+    "OtlpConfig",
+    "OtlpProfile",
+    "WatchlightOtlpExporter",
+    # Result wrappers
+    "AuthorizeResult",
+    "PlanResult",
+    "PreflightResult",
+    # Plan
+    "normalize_plan",
+    # PlanObserved event helpers (MCP.1)
+    "PLAN_INTENDED_TOOLS_MAX",
+    "PLAN_RATIONALE_MAX_BYTES",
+    "PLAN_TOOL_NAME_PATTERN",
+    "PLAN_TOOL_NAME_RE",
+    "PlanKind",
+    "PlanValidationError",
+    "build_plan_payload",
+    "filter_valid_tool_names",
+    "is_valid_tool_name",
+    "truncate_rationale",
+    # State + telemetry
+    "GovernanceState",
+    "GovernanceTelemetry",
+    "state_from_attrs",
+    # Lifecycle base
+    "BaseRunHandle",
+    "GovernedPlugin",
+    # M43-E — sub-agent contextvar accessor
+    "current_subagent_handle",
+    # #889 — lineage propagation contextvar (CONNECT sidecar reads this
+    # to inject ``X-Wl-Execution-Id`` headers on outbound CONNECTs so
+    # wl-proxy emits per-tunnel events with the orchestrator's
+    # execution_id instead of phantom fallbacks).
+    "HandleLineage",
+    "current_handle_lineage",
+    # Env
+    "governance_mode",
+    # Events schema (SDK 0.4.0 — pydantic mirror of wl-lineage::events)
+    "ActionRef",
+    "CredentialRef",
+    "EventEnvelope",
+    "EventType",
+    "ExecutionEvent",
+    "PrincipalRef",
+    "ResourceRef",
+    "EVENT_ID_PATTERN",
+    "EVENT_ID_RE",
+    "INPUT_SUMMARY_MAX_CHARS",
+    "ERROR_MESSAGE_MAX_CHARS",
+    "summarize_arg_keys",
+    "truncate_error_message",
+    "truncate_summary",
+    # M46-B — intent provenance enum + byte cap (mirror of
+    # wl-lineage::events::IntentProvenance + INTENT_OBJECTIVE_MAX_BYTES)
+    "INTENT_OBJECTIVE_MAX_BYTES",
+    "IntentProvenance",
+    # M45-E — quarantine event payload mirrors + size constants
+    "ExecutionQuarantinedPayload",
+    "ExecutionResumedPayload",
+    "FeatureContribution",
+    "LIFT_REASON_MAX_BYTES",
+    "MAX_CONTRIBUTING_FEATURES",
+    "REASON_MAX_BYTES",
+    # M45-F — typed authorization decision + handle state machine
+    "AgentQuarantinedError",
+    "AgentRevokedError",
+    "AllowDecision",
+    "Attenuation",
+    "AuthorizationDecision",
+    "DenyDecision",
+    "Escalation",
+    "ExecutionTerminatedError",
+    "NeedsApprovalDecision",
+    "Observation",
+    "QuarantineDecision",
+    "RevokeDecision",
+    "RunHandleState",
+    "SeverSubtreeDecision",
+    "SubtreeSeveredError",
+    "TerminateDecision",
+    "parse_authorization_decision",
+    # M45-I — kill-signal protocol for HTTP interceptors
+    "InterceptorKillRegistry",
+    "KILL_SIGNAL_GRACEFUL_WINDOW_MS",
+    "DISPOSITION_GRACEFUL",
+    "DISPOSITION_PROXY_HARD_KILL",
+    "LLM_CALL_INTERRUPTED_REASON_QUARANTINE",
+    "LLM_CALL_INTERRUPTED_REASON_SCOPE_VIOLATION",
+    "LLM_CALL_INTERRUPTED_REASON_MANUAL_TERMINATE",
+    "LLM_CALL_INTERRUPTED_REASON_HARD_TIMEOUT",
+    "LLM_CALL_INTERRUPTED_REASON_POLICY_TERMINATE",
+    "LLM_CALL_INTERRUPTED_REASON_SEVER_SUBTREE",
+    "LLM_CALL_INTERRUPTED_REASON_REVOKE",
+    "LlmCallInterruptedPayload",
+    "LlmCallInterruptedValidationError",
+    "KillSignalResult",
+    "RegisterRequestOptions",
+    "httpx_hard_kill_escalator",
+    # M46-K — synthetic ``watchlight.declare_intent`` tool contract.
+    "BROWNFIELD",
+    "DECLARE_INTENT_RESPONSE_STATUS",
+    "DECLARE_INTENT_TOOL_DESCRIPTION",
+    "DECLARE_INTENT_TOOL_NAME",
+    "GREENFIELD",
+    "INTENT_ENFORCEMENT_MODE_ENV_VAR",
+    "WATCHLIGHT_DECLARE_INTENT_TOOL",
+    "handle_declare_intent_call",
+    "is_declare_intent_tool_call",
+    "is_declare_intent_tool_name",
+    "resolve_intent_enforcement_mode",
+    "should_inject_synthetic_tool",
+    "truncate_intent_objective",
+    # M43-B — sub-agent scope attenuation wire shapes.
+    "GrantedScope",
+    "ParentSignature",
+    "RequestedScope",
+    "ResourceMatcher",
+    "SpawnSubagentRequest",
+    "SpawnSubagentResponse",
+    "granted_scope_from_dict",
+    "granted_scope_to_dict",
+    "parent_signature_from_dict",
+    "parent_signature_to_dict",
+    "requested_scope_from_dict",
+    "requested_scope_to_dict",
+    "resource_matcher_from_dict",
+    "resource_matcher_to_dict",
+    "spawn_subagent_request_from_dict",
+    "spawn_subagent_request_to_dict",
+    "spawn_subagent_response_from_dict",
+    "spawn_subagent_response_to_dict",
+    # Uniform governed-spawn routing primitive.
+    "SubagentRegistry",
+    "DEFAULT_SUBAGENT_SCOPE_ENV_VAR",
+    "default_subagent_scope_from_env",
+]
+
+__version__ = "0.5.0"

watchlight_core/__main__.py

@@ -0,0 +1,18 @@
+"""Module-level CLI dispatch for ``python -m watchlight_core``.
+
+Currently dispatches to the conformance runner; future commands
+(scaffold new plugin, validate event schema, etc.) plug in here.
+
+Usage:
+
+    python -m watchlight_core.conformance my_plugin_package
+"""
+
+from __future__ import annotations
+
+import sys
+
+from .conformance import _main
+
+if __name__ == "__main__":
+    sys.exit(_main())