aif-normative-agent 0.3.1__py3-none-any.whl

aif_normative_agent-0.3.1.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: aif-normative-agent
+Version: 0.3.1
+Summary: Norm-Native Agent SDK — Harness + Host loop over EDA / Normbase / Schemo HTTP APIs
+License: Proprietary License
+        
+        Copyright (c) 2026 LangXAI. All rights reserved.
+        
+        The Agent Information Field (AIF) software, documentation, and related
+        materials in this repository are proprietary and confidential.
+        
+        No part of this software may be copied, modified, merged, published,
+        distributed, sublicensed, or sold without prior written permission from
+        LangXAI.
+        
+        Access and use are permitted only for authorized users under applicable
+        service terms, license agreements, or other written authorization from
+        LangXAI.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+        OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+        LANGXAI BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+        ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: aiohttp>=3.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Dynamic: license-file
+
+# aif-normative-agent
+
+PyPI distribution for the **Norm-Native Agent SDK** (`normative_agent`).
+
+Thin HTTP client + Host tool loop over remote **EDA**, **Normbase**, and **Schemo** APIs. Does **not** ship Normbase, EDA server, Platform, MCP adapters, or Facilitator code.
+
+Sibling package: [`aif-mcp`](../aif-mcp/README.md) (MCP tool surface over the same HTTP APIs).
+
+## Install
+
+```bash
+pip install aif-normative-agent
+```
+
+Editable install from monorepo (full-stack development):
+
+```bash
+pip install -e .
+# at AIF repository root (aif-normbase)
+```
+
+SDK-only wheel build (this directory):
+
+```bash
+cd packaging/normative-agent
+python sync_sources.py
+python -m build --wheel
+python verify_wheel.py dist/aif_normative_agent-0.3.1-py3-none-any.whl
+python verify_wheel_imports.py dist/aif_normative_agent-0.3.1-py3-none-any.whl
+```
+
+Or from repo root:
+
+```bash
+pwsh ./scripts/publish/publish_normative_agent.ps1
+```
+
+## Verify import
+
+```bash
+python -c "from normative_agent import NormativeAgent; print('ok')"
+```
+
+## Configuration
+
+| Variable | Purpose |
+|----------|---------|
+| `AIF_AGENT_API_KEY` | Agent API key for `NormativeAgent.from_api_key` |
+| `EDA_BASE_URL` | EDA HTTP API (default `http://localhost:8002`) |
+| `NORMBASE_BASE_URL` | Normbase HTTP API (default `http://localhost:8001`) |
+| `SCHEMO_QUERY_BASE_URL` | Schemo read API |
+| `AIF_INTERNAL_SERVICE_TOKEN` | Optional internal Bearer for mixed deployments |
+
+## Monorepo note
+
+Source lives under `normative_agent/`, plus shared helpers `ontology/schemo/client`, `ontology/schemo/contracts`, and `security/auth` (same shared layer as `aif-mcp`).
+
+Norm bind **build** logic stays in `eda_agent/norm_projection.py` (server). SDK formats EDA `bound_norm_projections` via `normative_agent.harness.projection_format`.
+
+Developer guide: `normative_agent/docs/developer-guide.md` in the AIF monorepo (not shipped in the wheel).
+
+Host app devkit: `docs/agent-app-devkit/` in the AIF repository.
+
+Publish: `pwsh ./scripts/publish/publish_normative_agent.ps1`
+
+## Package scope
+
+Bundled:
+
+- `normative_agent` (Harness + Host)
+- `ontology.schemo.client` / `contracts`
+- `security.auth`
+
+Not bundled:
+
+- `eda_agent`, `normbase`, `aif_platform`, `integrations`, `llm`, SDK docs under `normative_agent/docs/`
+
+Optional LLM semantic governance uses monorepo `llm` or inject your own `ToolCallingModel` / `SemanticTriggerClassifier`.

aif_normative_agent-0.3.1.dist-info/RECORD

@@ -0,0 +1,57 @@
+aif_normative_agent-0.3.1.dist-info/licenses/LICENSE,sha256=8XZjXNNp7M3ESlQanFGFqUabP-2uYRKS40j-aRewAeg,946
+normative_agent/__init__.py,sha256=YSkrwzpRjiToD47jbeCYp8lYUm69Hm1G6TnEiBevyoE,1986
+normative_agent/agent.py,sha256=xYc6a1k6inHD8UmDcOJjRvOj-QIDKo3JPVo7qejfep0,13207
+normative_agent/harness/__init__.py,sha256=pKUQ96nVre2K8f_43qR_va0hQmNavq5Ue1S9hxKSJ5s,1650
+normative_agent/harness/eda_client.py,sha256=CFcrQUbMYG5HMFdnTYW_YIYDpX_HaswF4H0pzUzP7rI,5237
+normative_agent/harness/eda_session.py,sha256=8yQ6r4BlLe9X0vRt3DI74do22nMV9Anu9qePAzcZc7E,6634
+normative_agent/harness/lfta_phases.py,sha256=opmJSQTYXxE3R3a1xV3F4PnO4LUxfCdfep7fLq5y_pw,1664
+normative_agent/harness/normbase_client.py,sha256=XfOmthY-iMf3eMz9LTCjSszqXVNyBVSRoWnimjCSAvQ,4471
+normative_agent/harness/projection_format.py,sha256=B8-pB8ZQ97JNFPfhurf7zQeSzmbz-_BP7kKoYvxADfA,1202
+normative_agent/harness/snapshot_prompt.py,sha256=PcpBvHiZXG79c3LQOnXIg_vQrIkrauz5iCU0Jj6v1pA,55151
+normative_agent/harness/tool_executor.py,sha256=NA4sYf2jLIQv1wx1rf9ZtTqGMN9ROOf8Qj38n0uydQY,734
+normative_agent/harness/urls.py,sha256=QTy_3Ym6e3Pdy4NjeqkspRTrNrwJskpvBNUCsF1K1N4,985
+normative_agent/harness/beliefs/__init__.py,sha256=nJU2jVjfH5i6jlZfva79ybkU--qOV7sz0I7e335qGgM,936
+normative_agent/harness/beliefs/builders.py,sha256=CIVxvNoJg9RUakGYm2YUwlXHYuH6MRdRQikrbk5ZliI,2795
+normative_agent/harness/beliefs/merge.py,sha256=sYQmDh5Sf18ej8bji5p8QlaudyAVz7GHwE7VoNskguQ,1173
+normative_agent/harness/beliefs/render.py,sha256=ty-8pSPKoo24uT_s-_UvsPcX-2dmxc8wrDVzv3vP4eo,373
+normative_agent/harness/beliefs/task.py,sha256=oyvU5LxUY1QKQM31Pp-s9VCmgDwEioM8tOYb6_8220I,1520
+normative_agent/host/__init__.py,sha256=AmaU8lap23G_5eethWgx72dr1ROLT5sl7NLIc1sq9xQ,1491
+normative_agent/host/bind_context.py,sha256=OEyMYfMRpsaJKZlXoYpptnIEwfiALhJ__HQL5EsXoF8,1179
+normative_agent/host/candidate_actions.py,sha256=49fOz6-8XFfmWWIgimoPZEKo2wciIu5LIyaqTBSpn8I,2679
+normative_agent/host/gather_policy.py,sha256=BHvTzeSGe8iyFot7zNu2VI-pEw5KIBlqoIoQD7j2wbg,4330
+normative_agent/host/governance_hitl.py,sha256=UoDS3LNOMca_3_CLg7ro7Pv9XFbYL0LcYpz2FfzzMZw,3083
+normative_agent/host/hitl.py,sha256=TAChj21WrQ_MjAqKV4DTcYrN_47YJADt9DYEQK6ztZ8,2753
+normative_agent/host/loop.py,sha256=d7BmfQx8EOsecE_HR3dIwJDQ2OftWrh62DD4nZEY42s,36456
+normative_agent/host/mcp_bridge.py,sha256=s3xi5qwEV1vHZazBfXuIo18eCC3o2rQdFQwafLQ191s,3603
+normative_agent/host/norm_coverage.py,sha256=VFHRrLEGhIXJ0Up9z_4qxjJGqRIDL9GHqyKS4WCXqM0,3421
+normative_agent/host/policy.py,sha256=HS9XY8Och6G6EPNJBICApiXxuvABdAMIelc1vxBMjSk,3787
+normative_agent/host/prompt_context.py,sha256=tpKj_JvDMRPsFWBV_M2uZZyfzJzZXP-2ABHKbTVFeQw,6823
+normative_agent/host/reflection.py,sha256=lf4T28qI1_2l6TgSUx4yi5m9xNUyTgpv5pgbRNNS_BU,10444
+normative_agent/host/reflection_hitl.py,sha256=_YuJw-jn91U7Or4qAIMceMGmXdGegcw9OsgeIIr3_Q8,2178
+normative_agent/host/schemo_tools.py,sha256=zZD1n58oZzDJBOjgY5mnb0km743YIoBscBAB0Kyimlk,30484
+normative_agent/host/tools.py,sha256=NQ0H_zEq5wba2OxGoj8AV_iQghHXCIFN4_ynkHLorj8,18123
+normative_agent/host/trigger_classifier.py,sha256=CvaYr-nd8PtcnYkjLwhlW0I0a9intF02xVzHyWpxLyI,5137
+ontology/__init__.py,sha256=d76WqS5RxaUYieqWJ-HfM8GHgVBN1_ymZ9ZgZPZeKo8,276
+ontology/schemo/__init__.py,sha256=o0PK86m90TGBgdxii4V2mJVbCpwzBJUPJVlX3FU_GIY,165
+ontology/schemo/client/__init__.py,sha256=My1oqM1vMzSKfr9YH_1D09hHHef0ejDyfD_KcpIbojA,1104
+ontology/schemo/client/auth.py,sha256=qo8cAeEWldSOffsaNCRg09_XOCpraLl5dVbd6VbA7r8,1101
+ontology/schemo/client/http.py,sha256=gqtih3saIml3ypmTTHYq9dVUPTuXXfpPvHGnP9GlLXI,28146
+ontology/schemo/contracts/__init__.py,sha256=tSo1tSA8KYwRGtrEfnF3Km3zrwEAhxabSTskMYQXVsM,1294
+ontology/schemo/contracts/belief_proposition.py,sha256=--8Zo7NhRKrhdT8lWpwFAxTiJLTznAeAJxaqnS1akDo,1594
+ontology/schemo/contracts/belief_render.py,sha256=VRqasrrvmRq-qXrc7tBH3kp9x-Mtej0FGJvyJ9GAOgA,6846
+ontology/schemo/contracts/query_facts.py,sha256=3n5Woa67h6naaTGr7BbW19064KqnDw0W-byKyordY0Y,4758
+ontology/schemo/contracts/role_seeding_facts.py,sha256=82cXgti7YOcfVeQ3Me155dIyCEEEFej_h1OVvVuxst8,1975
+ontology/schemo/contracts/task_facts.py,sha256=sjedC2vziKsNztcdtzeEPFXHZ2ovhmCrmfqh5CkcUbo,2545
+security/__init__.py,sha256=sHFe6p73O-VL_R-riB4RwwzJAdZ-xtfhMJAlumZQm_Q,61
+security/auth/__init__.py,sha256=rZirZiwA7bdWGef2l30kBJ6CY_cSVMDqXfzMeP196Is,430
+security/auth/api_keys.py,sha256=HFYbZ0ew-lAZXTbgYyhqcqLkjpioY6q7e06K_HqJi0Y,1665
+security/auth/core.py,sha256=Ysz1tWTEZWIO2Vu5gxJUVKzQUJEDGXQIgsLWuKWvq3I,13860
+security/auth/mcp_tool_policy.json,sha256=pYi5g6SsbKnFQWVCMRtWM8GEwtGj1zFcBA5yYE8vDZg,3359
+security/auth/models.py,sha256=uD5eHUAEuCGUJ6kB7QOr3tjX2HECGrpOoPIPKsK9Qxw,566
+security/auth/org_access.py,sha256=mdMWk_rUq5WcVKcqknEJ9QcVcCETNlw4wtaYHKVdBuI,3249
+security/auth/tool_policy.py,sha256=S2lRsikMY73ERM9Pkkp7mIAXYc8wGNpOEuXHEMphWEQ,3216
+security/auth/verifier.py,sha256=308_Q4mqEtA74EztfHmI3BtyAMZLe2ZisYNiOgLCoZw,1419
+aif_normative_agent-0.3.1.dist-info/METADATA,sha256=TNIYyIK5uR0c1yDtGWdSNtyuaycf_yZGDjyCSpoOGd4,4069
+aif_normative_agent-0.3.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+aif_normative_agent-0.3.1.dist-info/top_level.txt,sha256=Ra-LeoJVqrUelej7QxmiYH_I9YXeIjks5CdA54g3wd4,34
+aif_normative_agent-0.3.1.dist-info/RECORD,,

aif_normative_agent-0.3.1.dist-info/WHEEL

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

aif_normative_agent-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+Proprietary License
+
+Copyright (c) 2026 LangXAI. All rights reserved.
+
+The Agent Information Field (AIF) software, documentation, and related
+materials in this repository are proprietary and confidential.
+
+No part of this software may be copied, modified, merged, published,
+distributed, sublicensed, or sold without prior written permission from
+LangXAI.
+
+Access and use are permitted only for authorized users under applicable
+service terms, license agreements, or other written authorization from
+LangXAI.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+LANGXAI BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

aif_normative_agent-0.3.1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+normative_agent
+ontology
+security

normative_agent/__init__.py

@@ -0,0 +1,81 @@
+"""Norm-Native Agent SDK (`normative_agent`) — Harness + Host for organizational LLM agents."""
+
+from normative_agent.agent import NormativeAgent
+from normative_agent.harness import (
+    DEFAULT_EDA_BASE_URL,
+    DEFAULT_NORMBASE_BASE_URL,
+    EdaAgentSession,
+    EdaHttpClient,
+    LftaPhase,
+    NormbaseHttpClient,
+    NoopToolExecutor,
+    ToolExecutor,
+    bind_context_for_phase,
+    cold_start_peer_beliefs,
+    cold_start_self_beliefs,
+    lens_for_phase,
+    SnapshotPromptOptions,
+    SnapshotPhase,
+    infer_snapshot_phase,
+    make_belief,
+    render_snapshot_prompt,
+    resolved_eda_base_url,
+    resolved_normbase_base_url,
+    task_beliefs_for_mandate,
+)
+from normative_agent.host import (
+    AgentLoopResult,
+    HitlPause,
+    MemoryLayers,
+    OrgAgentLoop,
+    ToolCallingModel,
+    ToolDefinition,
+    ToolRegistry,
+    TriggerDecision,
+    TriggerMode,
+    assemble_turn_messages,
+    classify_trigger,
+    eda_phases_for_mode,
+    register_eda_tools,
+    register_normbase_tools,
+    register_schemo_tools,
+    validate_candidate_actions_shape,
+)
+
+__all__ = [
+    "DEFAULT_EDA_BASE_URL",
+    "DEFAULT_NORMBASE_BASE_URL",
+    "AgentLoopResult",
+    "EdaAgentSession",
+    "EdaHttpClient",
+    "HitlPause",
+    "LftaPhase",
+    "MemoryLayers",
+    "NormativeAgent",
+    "NormbaseHttpClient",
+    "NoopToolExecutor",
+    "OrgAgentLoop",
+    "ToolCallingModel",
+    "ToolDefinition",
+    "ToolExecutor",
+    "ToolRegistry",
+    "TriggerDecision",
+    "TriggerMode",
+    "bind_context_for_phase",
+    "classify_trigger",
+    "assemble_turn_messages",
+    "cold_start_peer_beliefs",
+    "cold_start_self_beliefs",
+    "eda_phases_for_mode",
+    "infer_snapshot_phase",
+    "lens_for_phase",
+    "make_belief",
+    "register_eda_tools",
+    "register_normbase_tools",
+    "register_schemo_tools",
+    "render_snapshot_prompt",
+    "resolved_eda_base_url",
+    "resolved_normbase_base_url",
+    "task_beliefs_for_mandate",
+    "validate_candidate_actions_shape",
+]

normative_agent/agent.py

@@ -0,0 +1,336 @@
+"""Norm-Native Agent SDK (`normative_agent`): Harness + optional Host factory."""
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from security.auth.core import resolve_agent_api_key
+
+from normative_agent.harness.eda_client import EdaHttpClient
+from normative_agent.harness.eda_session import EdaAgentSession
+from normative_agent.harness.urls import resolved_eda_base_url, resolved_normbase_base_url
+from normative_agent.host.loop import OrgAgentLoop, ToolCallingModel
+from normative_agent.host.tools import ToolRegistry, register_eda_tools, register_normbase_tools, register_schemo_tools
+
+
+class NormativeAgent:
+    """
+    Facade for Norm-Native Agent SDK: **Harness** (EDA) + optional **Host** (agent loop).
+
+    **Harness** — :attr:`eda`, :meth:`eda_session`: read/write E/D/A, audit via EDA trace.
+    **Host** — :meth:`create_tool_registry`, :meth:`create_agent_loop`: Cursor-style tool loop.
+
+    Product name: Norm-Native Agent; Python package: ``normative_agent``. See ``docs/norm-native-agent-naming.md``.
+
+    Normbase remains the norm source of truth. Meta-phases are expressed in snapshot prompt
+    and ``OrgAgentLoop``; use ``eda_session()`` for deterministic EDA step sequences in tests.
+    """
+
+    def __init__(
+        self,
+        *,
+        agent_id: str,
+        eda_base_url: str | None = None,
+        normbase_base_url: str | None = None,
+        agent_api_key: str | None = None,
+        timeout_seconds: float = 60.0,
+    ) -> None:
+        self._normbase_base_url = resolved_normbase_base_url(normbase_base_url)
+        self.eda = EdaHttpClient(
+            base_url=resolved_eda_base_url(eda_base_url),
+            agent_id=agent_id,
+            agent_api_key=agent_api_key,
+            timeout_seconds=timeout_seconds,
+        )
+
+    @classmethod
+    async def from_api_key(
+        cls,
+        *,
+        agent_api_key: str,
+        eda_base_url: str | None = None,
+        normbase_base_url: str | None = None,
+        timeout_seconds: float = 60.0,
+    ) -> NormativeAgent:
+        key = (agent_api_key or "").strip()
+        if not key:
+            raise ValueError("agent_api_key must be non-empty")
+
+        nb = resolved_normbase_base_url(normbase_base_url)
+        resolved = await resolve_agent_api_key(key, normbase_base_url=nb)
+        if resolved is None:
+            raise ValueError("Invalid agent API key or key is not an agent key")
+        raw_agent = (resolved.agent_id or "").strip()
+        if not raw_agent:
+            raise ValueError("API key is not bound to an agent")
+        try:
+            agent_uuid = str(UUID(raw_agent))
+        except ValueError as exc:
+            raise ValueError("API key returned invalid agent_id") from exc
+
+        return cls(
+            agent_id=agent_uuid,
+            eda_base_url=eda_base_url,
+            normbase_base_url=nb,
+            agent_api_key=key,
+            timeout_seconds=timeout_seconds,
+        )
+
+    def eda_session(self) -> EdaAgentSession:
+        """Harness: MCP-aligned EDA session."""
+        return EdaAgentSession(self.eda)
+
+    async def resolve_org_id(self, *, org_id: str | None = None) -> str:
+        """
+        Resolve tenant ``org_id`` for Schemo org tools.
+
+        Uses explicit ``org_id`` when provided; otherwise reads ``org_id`` from the
+        bound EDA agent profile (``GET /agents/{id}``), which is available with the
+        same Agent API key as runtime calls.
+        """
+        explicit = (org_id or "").strip()
+        if explicit:
+            try:
+                return str(UUID(explicit))
+            except ValueError as exc:
+                raise ValueError(f"Invalid org_id: {explicit!r}") from exc
+
+        profile = await self.eda.get_agent()
+        raw = profile.get("org_id")
+        text = str(raw).strip() if raw is not None else ""
+        if not text:
+            raise ValueError(
+                "org_id is required for Schemo tools; agent profile has no org_id. "
+                "Pass org_id= explicitly."
+            )
+        try:
+            return str(UUID(text))
+        except ValueError as exc:
+            raise ValueError(f"Agent profile returned invalid org_id: {raw!r}") from exc
+
+    def _schemo_credentials(self) -> "SchemoClientCredentials":
+        from ontology.schemo.client.auth import SchemoClientCredentials
+
+        return SchemoClientCredentials(
+            agent_api_key=self.eda.agent_api_key,
+            agent_id=self.eda.agent_id,
+        )
+
+    def create_tool_registry(
+        self,
+        *,
+        include_eda: bool = True,
+        include_normbase: bool = True,
+        include_schemo: bool = True,
+        include_host_reflection: bool = True,
+        org_id: str | None = None,
+        schemo_base_url: str | None = None,
+    ) -> ToolRegistry:
+        """Host: tool registry with default ``eda_*``, Normbase, and Schemo org tools."""
+        if include_schemo and not (org_id or "").strip():
+            raise ValueError(
+                "org_id is required for Schemo tools. "
+                "Use await create_tool_registry_async(...) or pass org_id=."
+            )
+        if include_normbase and not self.eda.agent_api_key:
+            raise ValueError(
+                "agent_api_key is required for Normbase tools. "
+                "Use NormativeAgent.from_api_key(...)."
+            )
+        registry = ToolRegistry()
+        if include_eda:
+            register_eda_tools(registry, self.eda_session())
+        if include_normbase:
+            register_normbase_tools(
+                registry,
+                eda=self.eda,
+                normbase_base_url=self._normbase_base_url,
+            )
+        if include_schemo:
+            register_schemo_tools(
+                registry,
+                org_id=str(org_id or ""),
+                base_url=schemo_base_url,
+                credentials=self._schemo_credentials(),
+            )
+        if include_host_reflection:
+            from normative_agent.host.reflection import register_host_reflection_tools
+
+            register_host_reflection_tools(registry)
+        return registry
+
+    async def create_tool_registry_async(
+        self,
+        *,
+        include_eda: bool = True,
+        include_normbase: bool = True,
+        include_schemo: bool = True,
+        include_host_reflection: bool = True,
+        org_id: str | None = None,
+        schemo_base_url: str | None = None,
+    ) -> ToolRegistry:
+        """Host: like :meth:`create_tool_registry` but resolves ``org_id`` from EDA when omitted."""
+        resolved_org: str | None = org_id
+        if include_schemo:
+            resolved_org = await self.resolve_org_id(org_id=org_id)
+        return self.create_tool_registry(
+            include_eda=include_eda,
+            include_normbase=include_normbase,
+            include_schemo=include_schemo,
+            include_host_reflection=include_host_reflection,
+            org_id=resolved_org,
+            schemo_base_url=schemo_base_url,
+        )
+
+    async def build_system_prompt(
+        self,
+        *,
+        registry: ToolRegistry | None = None,
+        session: EdaAgentSession | None = None,
+        extra_instructions: str = "",
+        include_runtime_contract: bool = True,
+        include_info_routing: bool = True,
+        bind_completed: bool | None = None,
+        org_id: str | None = None,
+        schemo_base_url: str | None = None,
+        snapshot_prompt_options: "SnapshotPromptOptions | None" = None,
+    ) -> str:
+        """Homomorphic system prompt from EDA ``normative-snapshot`` (+ optional tool manifest)."""
+        from normative_agent.harness.snapshot_prompt import SnapshotPromptOptions
+
+        sess = session or self.eda_session()
+        tool_names: list[str] | None = None
+        if registry is not None:
+            tool_names = list(registry.tools.keys())
+        options = snapshot_prompt_options or SnapshotPromptOptions(
+            include_runtime_contract=include_runtime_contract,
+            include_info_routing=include_info_routing,
+            bind_completed=bind_completed,
+        )
+        resolved_org = (org_id or "").strip() or None
+        if not resolved_org and registry is not None and any(
+            k.startswith("schemo_") for k in registry.tools
+        ):
+            try:
+                resolved_org = await self.resolve_org_id()
+            except ValueError:
+                resolved_org = None
+        return await sess.build_system_prompt(
+            tool_names=tool_names,
+            extra_instructions=extra_instructions,
+            options=options,
+            org_id=resolved_org,
+            schemo_base_url=schemo_base_url,
+            schemo_credentials=self._schemo_credentials(),
+        )
+
+    async def create_agent_loop(
+        self,
+        model: ToolCallingModel,
+        *,
+        registry: ToolRegistry | None = None,
+        max_steps: int = 24,
+        system_prompt: str = "",
+        auto_system_prompt: bool = False,
+        auto_refresh_prompt: bool = False,
+        initialize: dict | None = None,
+        extra_system_instructions: str = "",
+        require_execute_before_org: bool = True,
+        run_warmup: bool | None = None,
+        hitl_on_missing_role_norms: bool = True,
+        include_normbase: bool = True,
+        include_schemo: bool = True,
+        include_eda: bool = True,
+        org_id: str | None = None,
+        schemo_base_url: str | None = None,
+        trigger_classifier: Any | None = None,
+        snapshot_prompt_options: Any | None = None,
+        on_after_tool: Any | None = None,
+        require_reflection_gates: bool = True,
+        require_assess_before_report: bool = True,
+        require_dual_query_when_insufficient: bool = True,
+        perceive_on_bypass: bool = True,
+        runtime_timezone: str | None = None,
+    ) -> OrgAgentLoop:
+        """
+        Host: Cursor-style loop over ``registry`` and injected ``model``.
+
+        Default registry includes EDA, Normbase, and Schemo (``schemo_*``) tools.
+        Prefer :meth:`create_tool_registry_async` so ``org_id`` resolves from the EDA agent profile.
+
+        When ``auto_system_prompt=True``, fetches EDA ``normative-snapshot`` after optional
+        ``initialize`` and renders the system prompt (``system_prompt`` wins if non-empty).
+        When ``run_warmup`` is omitted, it defaults to ``auto_system_prompt`` (perceive + bind at each ``run()``).
+        """
+        reg = registry or await self.create_tool_registry_async(
+            include_eda=include_eda,
+            include_normbase=include_normbase,
+            include_schemo=include_schemo,
+            org_id=org_id,
+            schemo_base_url=schemo_base_url,
+        )
+        prompt_opts = snapshot_prompt_options
+        prompt = system_prompt.strip()
+        sess = self.eda_session()
+        resolved_org = (org_id or "").strip() or None
+        uses_schemo = include_schemo if registry is None else any(
+            k.startswith("schemo_") for k in reg.tools
+        )
+        if not resolved_org and uses_schemo:
+            try:
+                resolved_org = await self.resolve_org_id(org_id=org_id)
+            except ValueError:
+                resolved_org = None
+
+        prompt_builder = None
+        if auto_system_prompt and not prompt:
+            if initialize is not None:
+                await sess.initialize(initialize)
+            prompt = await self.build_system_prompt(
+                registry=reg,
+                session=sess,
+                org_id=resolved_org,
+                schemo_base_url=schemo_base_url,
+                snapshot_prompt_options=prompt_opts,
+            )
+
+        async def _prompt_builder() -> str:
+            return await self.build_system_prompt(
+                registry=reg,
+                session=sess,
+                org_id=resolved_org,
+                schemo_base_url=schemo_base_url,
+                snapshot_prompt_options=prompt_opts,
+            )
+
+        if auto_system_prompt:
+            prompt_builder = _prompt_builder
+
+        effective_warmup = run_warmup if run_warmup is not None else auto_system_prompt
+        from normative_agent.host.prompt_context import DEFAULT_RUNTIME_TIMEZONE
+
+        resolved_timezone = (
+            (runtime_timezone or DEFAULT_RUNTIME_TIMEZONE).strip() or DEFAULT_RUNTIME_TIMEZONE
+        )
+
+        return OrgAgentLoop(
+            reg,
+            model,
+            max_steps=max_steps,
+            system_prompt=prompt,
+            client_system_prompt=extra_system_instructions,
+            require_execute_before_org=require_execute_before_org,
+            prompt_builder=prompt_builder,
+            auto_refresh_prompt=auto_refresh_prompt,
+            eda_session=sess,
+            run_warmup=effective_warmup,
+            hitl_on_missing_role_norms=hitl_on_missing_role_norms,
+            trigger_classifier=trigger_classifier,
+            on_after_tool=on_after_tool,
+            require_reflection_gates=require_reflection_gates,
+            require_assess_before_report=require_assess_before_report,
+            require_dual_query_when_insufficient=require_dual_query_when_insufficient,
+            perceive_on_bypass=perceive_on_bypass,
+            runtime_timezone=resolved_timezone,
+        )
+

normative_agent/harness/__init__.py

@@ -0,0 +1,52 @@
+"""Harness: EDA session, L-FTA lenses, beliefs, and org tool executor protocol (no agent loop)."""
+
+from normative_agent.harness.eda_client import EdaHttpClient
+from normative_agent.harness.eda_session import EdaAgentSession
+from normative_agent.harness.snapshot_prompt import (
+    SnapshotPromptOptions,
+    SnapshotPhase,
+    infer_phase_from_prompt_text,
+    infer_snapshot_phase,
+    render_snapshot_prompt,
+    render_turn_directive,
+)
+from normative_agent.harness.lfta_phases import LftaPhase, bind_context_for_phase, lens_for_phase
+from normative_agent.harness.tool_executor import NoopToolExecutor, ToolExecutor
+from normative_agent.harness.urls import (
+    DEFAULT_EDA_BASE_URL,
+    DEFAULT_NORMBASE_BASE_URL,
+    resolved_eda_base_url,
+    resolved_normbase_base_url,
+)
+from normative_agent.harness.normbase_client import NormbaseHttpClient, active_field_ids_from_eda
+from normative_agent.harness.beliefs import (
+    cold_start_peer_beliefs,
+    cold_start_self_beliefs,
+    make_belief,
+    task_beliefs_for_mandate,
+)
+
+__all__ = [
+    "DEFAULT_EDA_BASE_URL",
+    "DEFAULT_NORMBASE_BASE_URL",
+    "EdaAgentSession",
+    "EdaHttpClient",
+    "LftaPhase",
+    "NormbaseHttpClient",
+    "SnapshotPromptOptions",
+    "SnapshotPhase",
+    "ToolExecutor",
+    "active_field_ids_from_eda",
+    "bind_context_for_phase",
+    "cold_start_peer_beliefs",
+    "cold_start_self_beliefs",
+    "infer_phase_from_prompt_text",
+    "infer_snapshot_phase",
+    "lens_for_phase",
+    "make_belief",
+    "render_snapshot_prompt",
+    "render_turn_directive",
+    "resolved_eda_base_url",
+    "resolved_normbase_base_url",
+    "task_beliefs_for_mandate",
+]