dir-core 0.4.0__tar.gz → 0.4.2__tar.gz

{dir_core-0.4.0 → dir_core-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dir-core
-Version: 0.4.0
+Version: 0.4.2
 Summary: Decision Intelligence Runtime - deterministic Kernel Space for agentic AI
 Author-email: Artur Huk <artur.huk.it@gmail.com>
 License-Expression: Apache-2.0

{dir_core-0.4.0 → dir_core-0.4.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 # dir-core keeps pip install name and import path aligned (frictionless adoption).
 name = "dir-core"
-version = "0.4.0"
+version = "0.4.2"
 description = "Decision Intelligence Runtime - deterministic Kernel Space for agentic AI"
 readme = "README.md"
 license = "Apache-2.0"

{dir_core-0.4.0 → dir_core-0.4.2}/src/dir_core/__init__.py

@@ -94,7 +94,7 @@ from .pci import (
     hash_content,
     proposal_params_for_hash,
 )
-from .contract_projection import project_contract
+from .contract_projection import project_contract, responsibility_contract_from_projection
 from .invariants import evaluate_invariants
 from .amendments import validate_amendment_patch
 from .wakeup import (
@@ -227,6 +227,7 @@ __all__ = [
     "ContractParameterAmendment",
     "AmendmentResult",
     "project_contract",
+    "responsibility_contract_from_projection",
     "evaluate_invariants",
     "validate_amendment_patch",
     "PolicyProposal",

{dir_core-0.4.0 → dir_core-0.4.2}/src/dir_core/contract_projection.py

@@ -10,6 +10,7 @@ from .models import (
     ContractParameterAmendment,
     ContractReleaseRef,
     InvariantSpec,
+    ResponsibilityContract,
     RuntimeContractProjection,
 )
 
@@ -105,6 +106,7 @@ def _build_projection_from_contract_mapping(data: Mapping[str, Any]) -> RuntimeC
         release=release,
         agent_id=str(subject.get("agent_id", data.get("agent_id", ""))),
         role=subject.get("role", data.get("role", "EXECUTOR")),
+        parent_agent_id=subject.get("parent_agent_id", data.get("parent_agent_id")),
         mission=str(mission_value),
         allowed_policy_types=list(
             authority.get("allowed_policy_types")
@@ -186,3 +188,51 @@ def project_contract(contract: Mapping[str, Any]) -> RuntimeContractProjection:
     if _is_projection_dump(data):
         return _parse_projection_dump(data)
     return ensure_projection_invariants(_build_projection_from_contract_mapping(data))
+
+
+def _limit_value(projection: RuntimeContractProjection, key: str) -> float | None:
+    raw = projection.transaction_limits.get(key)
+    if not isinstance(raw, Mapping):
+        return None
+    value = raw.get("value")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    return float(value)
+
+
+def responsibility_contract_from_projection(
+    projection: RuntimeContractProjection,
+) -> ResponsibilityContract:
+    """Derive the flat agent-facing ``ResponsibilityContract`` from a projection.
+
+    ``max_drawdown_limit`` is a fraction (0.04 = 4%); ``max_drawdown_limit_pct`` is in percent points.
+    """
+    fields: dict[str, Any] = {
+        "agent_id": projection.agent_id,
+        "role": projection.role,
+        "mission": projection.mission,
+        "authorized_instruments": list(
+            projection.resource_scope.get("instruments")
+            or projection.resource_scope.get("categories")
+            or []
+        ),
+        "allowed_policy_types": list(projection.allowed_policy_types),
+        "parent_agent_id": projection.parent_agent_id,
+    }
+
+    confidence_below = projection.escalation_policy.get("confidence_below")
+    if confidence_below is not None:
+        fields["escalate_on_uncertainty"] = float(confidence_below)
+
+    wake_up = projection.execution_conditions.get("wake_up_threshold_pct")
+    if wake_up is not None:
+        fields["wake_up_threshold_pct"] = float(wake_up)
+
+    drawdown = _limit_value(projection, "max_drawdown_limit")
+    if drawdown is None:
+        drawdown_pct = _limit_value(projection, "max_drawdown_limit_pct")
+        drawdown = drawdown_pct / 100.0 if drawdown_pct is not None else None
+    if drawdown is not None:
+        fields["max_drawdown_limit"] = drawdown
+
+    return ResponsibilityContract(**fields)

{dir_core-0.4.0 → dir_core-0.4.2}/src/dir_core/invariants.py

@@ -30,11 +30,24 @@ def get_nested_value(obj: Any, path: str) -> Any:
     return current
 
 
+def resolve_field(
+    field: str,
+    proposal: PolicyProposal,
+    context: Optional[dict[str, Any]] = None,
+) -> Any:
+    """Resolve a rule field: ``state.*`` reads authoritative state, anything else the proposal."""
+    if field.startswith("state."):
+        state = (context or {}).get("state")
+        return get_nested_value(state, field.removeprefix("state."))
+    return get_nested_value(proposal, field)
+
+
 def evaluate_range_rule(
     rule: InvariantSpec,
     proposal: PolicyProposal,
+    context: Optional[dict[str, Any]] = None,
 ) -> Optional[InvariantEvaluationFailure]:
-    value = get_nested_value(proposal, rule.field)
+    value = resolve_field(rule.field, proposal, context)
     if value is None:
         return InvariantEvaluationFailure(
             reason=DimReasonCode.CONTRACT_PARAMETER_MISSING,
@@ -63,8 +76,9 @@ def evaluate_range_rule(
 def evaluate_set_rule(
     rule: InvariantSpec,
     proposal: PolicyProposal,
+    context: Optional[dict[str, Any]] = None,
 ) -> Optional[InvariantEvaluationFailure]:
-    value = get_nested_value(proposal, rule.field)
+    value = resolve_field(rule.field, proposal, context)
     if value is None:
         return InvariantEvaluationFailure(
             reason=DimReasonCode.CONTRACT_PARAMETER_MISSING,
@@ -184,9 +198,9 @@ def evaluate_invariants(
         ):
             continue
         if rule.type == "range":
-            failure = evaluate_range_rule(rule, proposal)
+            failure = evaluate_range_rule(rule, proposal, context)
         elif rule.type == "set":
-            failure = evaluate_set_rule(rule, proposal)
+            failure = evaluate_set_rule(rule, proposal, context)
         elif rule.type == "state_match":
             failure = evaluate_state_match_rule(rule, proposal, context)
         else:

{dir_core-0.4.0 → dir_core-0.4.2}/src/dir_core/models.py

@@ -130,6 +130,7 @@ class RuntimeContractProjection(BaseModel):
     release: ContractReleaseRef = Field(default_factory=ContractReleaseRef)
     agent_id: str
     role: ContractRole = ContractRole.EXECUTOR
+    parent_agent_id: Optional[str] = None
     mission: str = ""
     allowed_policy_types: List[str] = Field(default_factory=list)
     resource_scope: Dict[str, List[str]] = Field(default_factory=dict)

{dir_core-0.4.0 → dir_core-0.4.2}/src/dir_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dir-core
-Version: 0.4.0
+Version: 0.4.2
 Summary: Decision Intelligence Runtime - deterministic Kernel Space for agentic AI
 Author-email: Artur Huk <artur.huk.it@gmail.com>
 License-Expression: Apache-2.0

{dir_core-0.4.0 → dir_core-0.4.2}/src/dir_core.egg-info/SOURCES.txt

@@ -67,6 +67,8 @@ tests/test_ollama.py
 tests/test_pci.py
 tests/test_pg_repo.py
 tests/test_resource_lock.py
+tests/test_responsibility_adapter.py
 tests/test_runtime.py
 tests/test_saga.py
+tests/test_samples_isolation.py
 tests/test_wakeup.py

{dir_core-0.4.0 → dir_core-0.4.2}/tests/test_contract_studio.py

@@ -3,19 +3,18 @@
 from __future__ import annotations
 
 import json
-import os
 import tempfile
 from pathlib import Path
 
 import pytest
 
+from samples.shared.llm.clients import MockLLMClient
 from tools.contract.db.store import ContractStudioStore
 from tools.contract.llm_interview import (
     empty_draft_contract,
     mock_contract_llm_strategy,
     process_chat_turn,
 )
-from samples.shared.llm.clients import MockLLMClient
 
 
 @pytest.fixture
@@ -77,6 +76,42 @@ def test_process_chat_turn_mock() -> None:
     assert turn.change_summary
 
 
+def test_noncanonical_analysis_key_remains_warning_through_integrity() -> None:
+    from tools.contract.integrity import verify_contract_yaml
+    from tools.contract.schema import IRREVERSIBLE_LIMIT_KEYS
+
+    def strategy(prompt: str, system: str | None = None) -> str:
+        response = json.loads(mock_contract_llm_strategy(prompt, system))
+        response["governance_analysis"]["invariant_candidates"][0][
+            "linked_limit_key"
+        ] = "max_payout_usd"
+        return json.dumps(response)
+
+    turn = process_chat_turn(
+        MockLLMClient(strategy=strategy),
+        current_contract=empty_draft_contract("trading"),
+        chat_history=[],
+        user_message="Build a crypto trading agent with limits",
+        preset="trading",
+    )
+    assert turn.validation_ok
+    assert not turn.blocking_errors
+    assert any("INVALID_LIMIT_KEY" in warning for warning in turn.warnings)
+
+    result = verify_contract_yaml(
+        turn.contract_yaml,
+        preset="trading",
+        governance_analysis=turn.governance_analysis,
+    )
+    assert result["integrity_ok"]
+    assert result["checks"]["contract_validation"]["ok"]
+    assert not result["errors"]
+    warning = next(w for w in result["validation_warnings"] if "INVALID_LIMIT_KEY" in w)
+    assert "max_payout_usd" in warning
+    for key in IRREVERSIBLE_LIMIT_KEYS:
+        assert key in warning
+
+
 @pytest.fixture
 def studio_client(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
     pytest.importorskip("fastapi")
@@ -118,14 +153,15 @@ def test_api_create_chat_export(studio_client) -> None:
     assert vbody["checks"]["bootstrap"]["ok"] is True
     assert vbody["sha256"]
 
-    export = studio_client.post(
-        f"/api/sessions/{session_id}/export",
-        json={"emit": "registry"},
-    )
-    assert export.status_code == 200
-    paths = export.json()["paths"]
-    assert any(p.endswith(".yaml") for p in paths)
-    assert Path(paths[0]).is_file()
+    with tempfile.TemporaryDirectory() as output_dir:
+        export = studio_client.post(
+            f"/api/sessions/{session_id}/export",
+            json={"emit": "registry", "out": output_dir},
+        )
+        assert export.status_code == 200
+        paths = export.json()["paths"]
+        assert any(p.endswith(".yaml") for p in paths)
+        assert Path(paths[0]).is_file()
 
     revisions = studio_client.get(f"/api/sessions/{session_id}/revisions")
     assert revisions.status_code == 200
@@ -239,6 +275,12 @@ def test_index_serves_versioned_assets(studio_client) -> None:
     assert 'id="yamlEditor"' in res.text
     assert "/static/app.js?v=" in res.text
     assert "/static/styles.css?v=" in res.text
+    assert '<details id="integrityPanel"' in res.text
+    assert '<details id="governancePanel"' in res.text
+    assert 'id="integritySummary"' in res.text
+    assert 'id="yamlHighlight" aria-hidden="true"' in res.text
+    assert 'wrap="off"' in res.text
+    assert "<details" in res.text and " open" not in res.text
 
 
 def test_verify_contract_yaml_rejects_garbage() -> None:
@@ -249,6 +291,32 @@ def test_verify_contract_yaml_rejects_garbage() -> None:
     assert result["checks"]["yaml_parse"]["ok"] is False
 
 
+def test_integrity_preserves_authoring_export_block(studio_client) -> None:
+    session_id = studio_client.post(
+        "/api/sessions", json={"title": "Blocked", "preset": "trading"}
+    ).json()["session"]["id"]
+    chat = studio_client.post(
+        f"/api/sessions/{session_id}/chat", json={"message": "Build a crypto trading agent"}
+    ).json()
+    edited = chat["contract_yaml"].replace("jane.doe@example.com", "owner@example.com")
+    saved = studio_client.put(
+        f"/api/sessions/{session_id}/contract", json={"yaml": edited}
+    ).json()
+    assert saved["saved"]
+    assert not saved["validation_ok"]
+    result = studio_client.post(
+        f"/api/sessions/{session_id}/validate", json={}
+    ).json()
+    assert not result["integrity_ok"]
+    assert not result["validation_ok"]
+    assert not result["checks"]["contract_validation"]["ok"]
+    assert any("PLACEHOLDER_IDENTITY" in error for error in result["validation_errors"])
+    assert studio_client.get(f"/api/sessions/{session_id}").json()["session"]["status"] == "drafting"
+    assert studio_client.post(
+        f"/api/sessions/{session_id}/export", json={}
+    ).status_code == 400
+
+
 def test_rename_and_delete_session(studio_client) -> None:
     a = studio_client.post("/api/sessions", json={"title": "Alpha", "preset": "generic"})
     b = studio_client.post("/api/sessions", json={"title": "Beta", "preset": "trading"})
@@ -323,3 +391,76 @@ responsibility:
     result = verify_contract_yaml(yaml_text, preset="generic")
     assert result["integrity_ok"] is True
     assert result["checks"]["bootstrap"]["ok"] is True
+
+
+def test_normalize_llm_resource_scope_and_invariant_candidate() -> None:
+    from tools.contract.invariants import compile_authority_invariants
+    from tools.contract.schema import CanonicalContract, normalize_contract_dict
+    from tools.contract.validation import validate_contract
+
+    raw = empty_draft_contract("generic")
+    raw["metadata"].update(
+        contract_id="storm_claims_agent",
+        owner="claims.owner@example.org",
+    )
+    raw["subject"]["agent_id"] = "storm_claims_agent"
+    raw["mission"]["statement"] = "Review residential storm damage claims."
+    raw["authority"]["limits"] = {
+        "max_transaction_usd": {"value": 5000.0, "unit": "USD"}
+    }
+    raw["authority"]["resource_scope"] = {
+        "coverage": ["homeowner policy endorsement"],
+        "category": ["fine arts and rugs"],
+        "exclusions": {},
+        "match": {
+            "substring": ["contents coverage", "fine arts and rugs"]
+        },
+    }
+    raw["authority"]["invariants"] = [
+        {
+            "invariant_id": "INV-RUG-PAYMENT-RANGE",
+            "constraint_class": "transaction_invariant",
+            "predicate": {
+                "op": "and",
+                "left": {
+                    "op": "ge",
+                    "variable": "proposed_rug_payment_usd",
+                    "value": 0,
+                },
+                "right": {
+                    "op": "le",
+                    "variable": "proposed_rug_payment_usd",
+                    "value": 5000,
+                },
+            },
+            "code": "POLICY_SUBLIMIT_EXCEEDED",
+            "applies_to_actions": ["PROPOSE_SETTLEMENT"],
+            "linked_limit_key": "max_transaction_usd",
+        }
+    ]
+
+    normalized = normalize_contract_dict(raw)
+    contract = CanonicalContract.model_validate(normalized)
+    validated, validation_ok, errors, _ = validate_contract(
+        normalized, preset="generic"
+    )
+    invariants = compile_authority_invariants(contract)
+    rug_limit = next(inv for inv in invariants if inv.id == "INV-RUG-PAYMENT-RANGE")
+
+    assert validated is not None
+    assert not validation_ok
+    assert any("RUNTIME_PROJECTION_INVALID" in error for error in errors)
+    assert contract.authority.exclusions == {}
+    assert contract.authority.resource_scope["match"] == {
+        "substring": ["contents coverage", "fine arts and rugs"]
+    }
+    assert rug_limit.type == "range"
+    assert rug_limit.field == "params.proposed_rug_payment_usd"
+    assert rug_limit.min == 0
+    assert rug_limit.max == 5000
+    assert rug_limit.reason_code == "POLICY_SUBLIMIT_EXCEEDED"
+    assert rug_limit.applies_to_policy_kinds == ["PROPOSE_SETTLEMENT"]
+
+    del normalized["authority"]["resource_scope"]["match"]
+    _, validation_ok, errors, _ = validate_contract(normalized, preset="generic")
+    assert validation_ok, errors

{dir_core-0.4.0 → dir_core-0.4.2}/tests/test_contract_tool.py

@@ -1,48 +1,204 @@
-"""Tests for tools/contract Bootstrap wizard."""
+"""Tests for contract validation, compilation and canonical rendering."""
 
 from __future__ import annotations
 
+import json
 import tempfile
 from pathlib import Path
 
+import pytest
 import yaml
 
-from dir_core import ResponsibilityContract, RuntimeContractProjection, project_contract
+from dir_core import RuntimeContractProjection, project_contract
+from samples.shared.contracts.provider import YamlContractProvider
 from tools.contract.bootstrap_rules import validate_bootstrap
-from tools.contract.flatten import flatten_canonical, flatten_contract_dict
-from tools.contract.from_sample import answers_from_sample
+from tools.contract.cli import main
 from tools.contract.render import render_registry_yaml, render_sample_fragment
-from tools.contract.schema import CanonicalContract, InterviewAnswers
-from samples.shared.contracts.provider import YamlContractProvider
+from tools.contract.schema import CanonicalContract
+from tools.contract.validation import validate_contract
+
+
+@pytest.fixture
+def contract_path(tmp_path: Path) -> Path:
+    contract = CanonicalContract(
+        agent_id="payments_01",
+        owner="payments.owner@example.org",
+        mission="Issue bounded refunds.",
+        authority={
+            "allowed_policy_types": ["REFUND"],
+            "limits": {"max_refund_usd": {"value": 50.0, "unit": "USD"}},
+            "invariants": [
+                {
+                    "id": "INV_COUNTRY",
+                    "type": "set",
+                    "field": "state.property.country",
+                    "denied": ["KP", "IR", "SY"],
+                }
+            ],
+        },
+    )
+    path = tmp_path / "contract.yaml"
+    path.write_text(render_registry_yaml(contract), encoding="utf-8")
+    return path
+
+
+def test_cli_validate(contract_path: Path, capsys) -> None:
+    assert main(["validate", str(contract_path)]) == 0
+    captured = capsys.readouterr()
+    assert captured.out.startswith("OK:")
+    assert "ANALYSIS_MISSING" in captured.err
+
+
+def test_cli_compile_stdout_is_projection_json(contract_path: Path, capsys) -> None:
+    assert main(["compile", str(contract_path)]) == 0
+    captured = capsys.readouterr()
+    result = json.loads(captured.out)
+    projection = RuntimeContractProjection.model_validate(result)
+    expected = project_contract(
+        CanonicalContract.from_raw(yaml.safe_load(contract_path.read_text(encoding="utf-8")))
+        .model_dump(mode="json", exclude_none=True)
+    )
+    assert projection == expected
+    assert projection.release.contract_id == "payments_01"
+    assert projection.release.contract_version == "1.0.0"
+    assert any(spec.field == "state.property.country" for spec in projection.invariants)
+    assert any(spec.max == 50 for spec in projection.invariants)
+    assert "ANALYSIS_MISSING" in captured.err
+    assert main(["compile", str(contract_path)]) == 0
+    assert capsys.readouterr().out == captured.out
+
+
+def test_cli_compile_file(contract_path: Path, tmp_path: Path, capsys) -> None:
+    output = tmp_path / "projection.json"
+    assert main(["compile", str(contract_path), "--out", str(output)]) == 0
+    assert capsys.readouterr().out == ""
+    projection = RuntimeContractProjection.model_validate_json(output.read_text(encoding="utf-8"))
+    assert projection.agent_id == "payments_01"
+
+
+@pytest.mark.parametrize("command", ["validate", "compile"])
+@pytest.mark.parametrize("content", ["", "- item", "authority: {{{", "null", "42"])
+def test_cli_invalid_yaml(command: str, content: str, tmp_path: Path, capsys) -> None:
+    path = tmp_path / "invalid.yaml"
+    path.write_text(content, encoding="utf-8")
+    assert main([command, str(path)]) == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "failed" in captured.err.lower()
+
+
+@pytest.mark.parametrize("command", ["validate", "compile"])
+def test_cli_missing_file(command: str, tmp_path: Path, capsys) -> None:
+    assert main([command, str(tmp_path / "missing.yaml")]) == 1
+    assert capsys.readouterr().err
+
+
+def test_cli_invalid_contract_does_not_overwrite_output(contract_path: Path, tmp_path: Path, capsys) -> None:
+    contract_path.write_text(
+        contract_path.read_text(encoding="utf-8").replace("payments.owner@example.org", "owner@example.com"),
+        encoding="utf-8",
+    )
+    output = tmp_path / "projection.json"
+    output.write_text("unchanged", encoding="utf-8")
+    assert main(["compile", str(contract_path), "--out", str(output)]) == 1
+    assert output.read_text(encoding="utf-8") == "unchanged"
+    assert "PLACEHOLDER_IDENTITY" in capsys.readouterr().err
+
+
+def test_cli_compile_reports_write_failure(contract_path: Path, tmp_path: Path, capsys) -> None:
+    assert main(["compile", str(contract_path), "--out", str(tmp_path)]) == 1
+    assert "compile failed" in capsys.readouterr().err
+
+
+def test_cli_preset_validation(contract_path: Path, capsys) -> None:
+    assert main(["validate", str(contract_path), "--preset", "trading"]) == 1
+    assert "max_order_size_usd" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("command", ["init", "from-sample"])
+def test_cli_authoring_commands_removed(command: str, capsys) -> None:
+    with pytest.raises(SystemExit) as exc:
+        main([command])
+    assert exc.value.code == 2
+    assert "invalid choice" in capsys.readouterr().err
+
+
+def test_shared_validation_rejects_runtime_incompatible_role(contract_path: Path) -> None:
+    data = yaml.safe_load(contract_path.read_text(encoding="utf-8"))
+    data["subject"]["role"] = "INTERFACE"
+    data["authority"] = {}
+    contract, ok, errors, _ = validate_contract(data)
+    assert contract is not None
+    assert not ok
+    assert any("RUNTIME_PROJECTION_INVALID" in error for error in errors)
+    assert data["subject"]["role"] == "INTERFACE"
+
+
+@pytest.mark.parametrize("command", ["validate", "compile"])
+def test_cli_rejects_runtime_incompatible_scope(command: str, contract_path: Path, capsys) -> None:
+    data = yaml.safe_load(contract_path.read_text(encoding="utf-8"))
+    data["authority"]["resource_scope"] = {"match": {"substring": ["home"]}}
+    contract_path.write_text(yaml.safe_dump(data), encoding="utf-8")
+    assert main([command, str(contract_path)]) == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "RUNTIME_PROJECTION_INVALID" in captured.err
+
+
+def test_shared_validation_rejects_invalid_invariant(contract_path: Path) -> None:
+    data = yaml.safe_load(contract_path.read_text(encoding="utf-8"))
+    data["authority"]["invariants"][0]["allowed"] = ["US"]
+    _, ok, errors, _ = validate_contract(data)
+    assert not ok
+    assert any("INVARIANT_SET_MODE" in error for error in errors)
+
+
+def test_integrity_revalidates_governance_analysis(contract_path: Path) -> None:
+    from tools.contract.governance.models import GoalModel, GovernanceAnalysis, SourceBinding
+    from tools.contract.integrity import verify_contract_yaml
+
+    analysis = GovernanceAnalysis(
+        goal=GoalModel(
+            objective="Issue bounded refunds",
+            source_bindings=[SourceBinding(clause_id="UNKNOWN_CLAUSE")],
+        )
+    )
+    result = verify_contract_yaml(
+        contract_path.read_text(encoding="utf-8"), governance_analysis=analysis
+    )
+    assert not result["integrity_ok"]
+    assert any("INVALID_CLAUSE_REF" in error for error in result["errors"])
 
 
-def test_interview_answers_to_canonical_and_validate() -> None:
-    answers = InterviewAnswers(
-        preset="fraud_gate",
+def test_canonical_contract_and_validate() -> None:
+    contract = CanonicalContract(
         agent_id="fraud_guard_v1",
-        owner="owner@example.com",
+        owner="fraud.owner@example.org",
         role="EXECUTOR",
         mission="Evaluate transactions.",
-        allowed_policy_types=["ALLOW", "BLOCK"],
-        irreversible_limits={"max_transaction_usd": 5000.0},
+        authority={
+            "allowed_policy_types": ["ALLOW", "BLOCK"],
+            "limits": {"max_transaction_usd": {"value": 5000.0, "unit": "USD"}},
+        },
     )
-    contract = answers.to_canonical()
     validate_bootstrap(contract, preset="fraud_gate")
     limit = contract.authority.limits["max_transaction_usd"]
     assert limit.value == 5000.0
     assert limit.unit == "USD"
     assert contract.subject.agent_id == "fraud_guard_v1"
-    assert contract.metadata.owner == "owner@example.com"
+    assert contract.metadata.owner == "fraud.owner@example.org"
 
 
 def test_renderers_emit_only_canonical_contract_shape() -> None:
-    contract = InterviewAnswers(
+    contract = CanonicalContract(
         agent_id="bot_01",
         owner="owner@example.com",
         mission="Trade safely.",
-        allowed_policy_types=["BUY"],
-        irreversible_limits={"max_order_size_usd": 1000.0},
-    ).to_canonical()
+        authority={
+            "allowed_policy_types": ["BUY"],
+            "limits": {"max_order_size_usd": {"value": 1000.0, "unit": "USD"}},
+        },
+    )
 
     for rendered in (render_registry_yaml(contract), render_sample_fragment(contract)):
         data = yaml.safe_load(rendered)
@@ -172,41 +328,6 @@ def test_validate_authoring_rejects_placeholder_and_dup_limit() -> None:
     assert any("AGGREGATE_DUP_LIMIT" in e for e in errors)
 
 
-def test_flatten_round_trip_dir_core() -> None:
-    contract = CanonicalContract(
-        agent_id="bot_01",
-        owner="o@example.com",
-        mission="Trade safely.",
-        authority={
-            "authorized_instruments": ["ETH-USD"],
-            "allowed_policy_types": ["BUY"],
-            "max_order_size_usd": 1000.0,
-            "max_drawdown_limit_pct": 4.0,
-        },
-    )
-    flat = flatten_canonical(contract)
-    rc = ResponsibilityContract(**flat)
-    assert rc.agent_id == "bot_01"
-    assert rc.max_drawdown_limit == 0.04
-    assert flat["permissions"]["max_order_size_usd"] == 1000.0
-
-
-def test_flatten_contract_dict_nested() -> None:
-    nested = {
-        "agent_id": "a1",
-        "role": "EXECUTOR",
-        "mission": "m",
-        "authority": {
-            "allowed_policy_types": ["HOLD"],
-            "max_order_size_usd": 500.0,
-        },
-        "responsibility": {"escalate_on_uncertainty": 0.8},
-    }
-    flat = flatten_contract_dict(nested)
-    assert flat["allowed_policy_types"] == ["HOLD"]
-    assert flat["permissions"]["max_order_size_usd"] == 500.0
-
-
 def test_project_contract_canonical_shape() -> None:
     projection = project_contract(
         {
@@ -324,31 +445,6 @@ def test_explicit_invariant_conflict_detected() -> None:
     assert errors
 
 
-def test_from_sample_quick_start() -> None:
-    repo_root = Path(__file__).resolve().parents[1]
-    answers = answers_from_sample(repo_root / "samples" / "00_quick_start")
-    assert answers.agent_id == "trading_bot_01"
-    assert "max_order_size_usd" in answers.irreversible_limits
-    assert "max_drawdown_limit_pct" in answers.irreversible_limits
-    contract = answers.to_canonical()
-    validate_bootstrap(contract, preset=answers.preset)
-
-
-def test_from_sample_preserves_canonical_invariant_ir() -> None:
-    repo_root = Path(__file__).resolve().parents[1]
-    answers = answers_from_sample(
-        repo_root / "samples" / "33_insurance_underwriting"
-    )
-    contract = answers.to_canonical()
-    limit = next(
-        spec
-        for spec in contract.authority.invariants
-        if spec.id == "INV_LIMIT_PROPOSAL_TIV"
-    )
-    assert limit.max == 3000000.0
-    assert limit.field == "params.total_insured_value"
-
-
 def test_normalize_preserves_explicit_currency_limit() -> None:
     contract = CanonicalContract.from_raw(
         {
@@ -371,38 +467,6 @@ def test_normalize_preserves_explicit_currency_limit() -> None:
     assert contract.authority.limits["max_refund_eur"].unit == "EUR"
 
 
-def test_yaml_contract_provider_flattens_nested() -> None:
-    from samples.shared.contracts.provider import YamlContractProvider
-
-    nested = {
-        "agents": [
-            {
-                "agent_id": "nested_agent",
-                "contract": {
-                    "role": "EXECUTOR",
-                    "mission": "Test nested load.",
-                    "authority": {
-                        "allowed_policy_types": ["ACTION"],
-                        "max_transaction_usd": 100.0,
-                    },
-                    "responsibility": {"escalate_on_uncertainty": 0.6},
-                },
-            }
-        ]
-    }
-    with tempfile.NamedTemporaryFile("w", suffix=".yaml", delete=False) as handle:
-        yaml.dump(nested, handle)
-        path = handle.name
-
-    try:
-        provider = YamlContractProvider(path)
-        contract = provider.get_contract("nested_agent")
-        assert contract.agent_id == "nested_agent"
-        assert contract.allowed_policy_types == ["ACTION"]
-    finally:
-        Path(path).unlink(missing_ok=True)
-
-
 def test_yaml_contract_provider_loads_canonical_envelope() -> None:
     nested = {
         "agents": [

{dir_core-0.4.0 → dir_core-0.4.2}/tests/test_governance_validation.py

@@ -4,13 +4,14 @@ from __future__ import annotations
 
 from tools.contract.governance.models import (
     ActionClass,
-    GovernanceAnalysis,
     GoalModel,
+    GovernanceAnalysis,
     InvariantCandidate,
     PredicateAST,
     SourceBinding,
 )
 from tools.contract.governance.validation import validate_governance_analysis
+from tools.contract.schema import IRREVERSIBLE_LIMIT_KEYS
 
 
 def _valid_analysis() -> GovernanceAnalysis:
@@ -130,3 +131,24 @@ def test_valid_analysis_passes() -> None:
     }
     report = validate_governance_analysis(analysis=analysis, contract_dict=contract)
     assert report.blocking_ok
+
+
+def test_noncanonical_linked_limit_is_warning_with_allowed_keys() -> None:
+    analysis = _valid_analysis()
+    analysis.invariant_candidates[0].linked_limit_key = "max_payout_usd"
+    report = validate_governance_analysis(
+        analysis=analysis,
+        contract_dict={
+            "authority": {
+                "allowed_policy_types": ["BUY"],
+                "limits": {"max_order_size_usd": {"value": 50000.0, "unit": "USD"}},
+            },
+        },
+    )
+
+    assert report.blocking_ok
+    issue = next(issue for issue in report.warnings if issue.code == "INVALID_LIMIT_KEY")
+    assert issue.severity == "warning"
+    assert "max_payout_usd" in issue.message
+    for key in IRREVERSIBLE_LIMIT_KEYS:
+        assert key in issue.message

{dir_core-0.4.0 → dir_core-0.4.2}/tests/test_invariants.py

@@ -203,3 +203,49 @@ def test_evaluate_invariants_collects_all_failures() -> None:
         "PROHIBITED_TERRITORY",
         "AUTHORITY_CEILING",
     ]
+
+
+def test_set_rule_allowlist_reads_authoritative_state() -> None:
+    rule = InvariantSpec(
+        id="INV_SUPPORTED_POLICY_TYPES",
+        type="set",
+        field="state.policy.type",
+        allowed=["HOMEOWNERS", "CONDO"],
+        reason_code="UNSUPPORTED_POLICY_TYPE",
+    )
+    proposal = _proposal(params={})
+    assert evaluate_set_rule(rule, proposal, {"state": {"policy": {"type": "CONDO"}}}) is None
+    failure = evaluate_set_rule(rule, proposal, {"state": {"policy": {"type": "COMMERCIAL"}}})
+    assert failure is not None
+    assert failure.reason == "UNSUPPORTED_POLICY_TYPE"
+
+
+def test_set_rule_on_state_ignores_value_claimed_by_agent() -> None:
+    rule = InvariantSpec(
+        id="INV_RESTRICTED_COUNTRIES",
+        type="set",
+        field="state.property.country",
+        denied=["KP", "IR", "SY"],
+        reason_code="COUNTRY_NOT_PERMITTED",
+    )
+    lying_proposal = _proposal(params={"property_country": "US"})
+    failure = evaluate_set_rule(
+        rule,
+        lying_proposal,
+        {"state": {"property": {"country": "KP"}}},
+    )
+    assert failure is not None
+    assert failure.reason == "COUNTRY_NOT_PERMITTED"
+
+
+def test_range_rule_on_state_fails_closed_when_state_missing() -> None:
+    rule = InvariantSpec(
+        id="INV_STATE_LIMIT",
+        type="range",
+        field="state.claim.reserve_usd",
+        max=1000,
+    )
+    failure = evaluate_range_rule(rule, _proposal(params={"reserve_usd": 1}), {"state": {}})
+    assert failure is not None
+    assert failure.reason == DimReasonCode.CONTRACT_PARAMETER_MISSING
+    assert evaluate_range_rule(rule, _proposal(params={}), None) is not None

dir_core-0.4.2/tests/test_responsibility_adapter.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import pytest
+
+from dir_core import (
+    ContractRole,
+    RuntimeContractProjection,
+    project_contract,
+    responsibility_contract_from_projection,
+)
+
+
+def _canonical(**overrides):
+    contract = {
+        "api_version": "roa.dir/v1",
+        "kind": "ResponsibilityContract",
+        "metadata": {"version": "1.0.0"},
+        "subject": {
+            "agent_id": "pos_01",
+            "role": "EXECUTOR",
+            "parent_agent_id": "strategist_01",
+        },
+        "mission": {"statement": "Hold safely."},
+        "authority": {
+            "allowed_policy_types": ["HOLD", "CLOSE"],
+            "resource_scope": {"instruments": ["ETH-USD"]},
+            "limits": {"max_order_size_usd": {"value": 1000, "unit": "USD"}},
+        },
+        "execution_conditions": {"wake_up_threshold_pct": 0.25},
+        "responsibility": {"escalation": {"mode": "mandatory", "confidence_below": 0.6}},
+    }
+    contract.update(overrides)
+    return contract
+
+
+def test_projection_keeps_parent_agent_id() -> None:
+    projection = project_contract(_canonical())
+    assert isinstance(projection, RuntimeContractProjection)
+    assert projection.parent_agent_id == "strategist_01"
+
+
+def test_adapter_maps_canonical_projection_to_flat_contract() -> None:
+    rc = responsibility_contract_from_projection(project_contract(_canonical()))
+    assert rc.agent_id == "pos_01"
+    assert rc.role == ContractRole.EXECUTOR
+    assert rc.mission == "Hold safely."
+    assert rc.authorized_instruments == ["ETH-USD"]
+    assert rc.allowed_policy_types == ["HOLD", "CLOSE"]
+    assert rc.escalate_on_uncertainty == 0.6
+    assert rc.wake_up_threshold_pct == 0.25
+    assert rc.parent_agent_id == "strategist_01"
+
+
+def test_adapter_uses_defaults_when_optional_blocks_missing() -> None:
+    contract = _canonical(execution_conditions={}, responsibility={})
+    rc = responsibility_contract_from_projection(project_contract(contract))
+    assert rc.escalate_on_uncertainty == 0.7
+    assert rc.wake_up_threshold_pct == 0.5
+    assert rc.max_drawdown_limit == 0.05
+
+
+def test_adapter_drawdown_fraction_and_percent() -> None:
+    fraction = _canonical()
+    fraction["authority"]["limits"]["max_drawdown_limit"] = {"value": 0.04, "unit": "fraction"}
+    assert responsibility_contract_from_projection(project_contract(fraction)).max_drawdown_limit == 0.04
+
+    percent = _canonical()
+    percent["authority"]["limits"]["max_drawdown_limit_pct"] = {"value": 4.0, "unit": "percent"}
+    assert responsibility_contract_from_projection(project_contract(percent)).max_drawdown_limit == pytest.approx(0.04)

dir_core-0.4.2/tests/test_samples_isolation.py

@@ -0,0 +1,39 @@
+"""Samples are Runtime consumers: they may depend on ``dir_core`` but never on Build-Time ``tools``."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+SAMPLES_DIR = Path(__file__).resolve().parents[1] / "samples"
+
+
+def _imported_modules(path: Path) -> list[str]:
+    tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    modules: list[str] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            modules.extend(alias.name for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module:
+            modules.append(node.module)
+    return modules
+
+
+def test_samples_do_not_import_build_time_tools() -> None:
+    offenders = [
+        f"{path.relative_to(SAMPLES_DIR)}: {module}"
+        for path in SAMPLES_DIR.rglob("*.py")
+        if "__pycache__" not in path.parts
+        for module in _imported_modules(path)
+        if module == "tools" or module.startswith("tools.")
+    ]
+    assert not offenders, f"samples must not depend on tools: {offenders}"
+
+
+def test_samples_do_not_mutate_sys_path_with_repo_root() -> None:
+    offenders = [
+        str(path.relative_to(SAMPLES_DIR))
+        for path in SAMPLES_DIR.rglob("*.py")
+        if "__pycache__" not in path.parts and "parents[3]" in path.read_text(encoding="utf-8")
+    ]
+    assert not offenders, f"samples must not add the repo root to sys.path: {offenders}"