draft-protocol 1.0.0__tar.gz → 1.1.0__tar.gz

{draft_protocol-1.0.0 → draft_protocol-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draft-protocol
-Version: 1.0.0
+Version: 1.1.0
 Summary: DRAFT Protocol — Intake governance for AI tool calls. Ensures AI understands human intent before execution begins.
 Project-URL: Homepage, https://github.com/manifold-vectors/draft-protocol
 Project-URL: Documentation, https://github.com/manifold-vectors/draft-protocol#readme

{draft_protocol-1.0.0 → draft_protocol-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draft-protocol"
-version = "1.0.0"
+version = "1.1.0"
 description = "DRAFT Protocol — Intake governance for AI tool calls. Ensures AI understands human intent before execution begins."
 readme = "README.md"
 license = "Apache-2.0"

{draft_protocol-1.0.0 → draft_protocol-1.1.0}/src/draft_protocol/__init__.py

@@ -13,7 +13,7 @@ Usage:
     from draft_protocol.providers import llm_available, embed_available
 """
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 
 # Public API — importable from `draft_protocol` directly
 from draft_protocol.engine import (

{draft_protocol-1.0.0 → draft_protocol-1.1.0}/src/draft_protocol/engine.py

@@ -6,6 +6,9 @@ Features:
   3. Context-aware suggestions — optional LLM scaffolds or static templates
   4. Classification confidence scoring — 0.0-1.0 on all assessments
   5. Graceful degradation — works without any LLM, better with one
+  6. Closed session guards — all operations reject closed sessions (M1.3)
+  7. Tier enum validation — rejects invalid tier strings (M1.4)
+  8. Context enrichment — gate PASS returns full dimensional mapping (M1.5)
 
 Supports any LLM provider via DRAFT_LLM_PROVIDER env var:
   ollama, openai (+ compatible APIs), anthropic, or none (keyword-only).
@@ -23,6 +26,18 @@ from draft_protocol.config import (
     STANDARD_TRIGGERS,
 )
 
+# ── M1.3: Closed Session Guard ───────────────────────────
+
+_CLOSED_SESSION_ERROR = "Session {sid} is closed. Start new session with draft_intake."
+
+
+def _check_open(session_id: str) -> dict | None:
+    """Return error dict if session is closed or missing, else None."""
+    if storage.is_session_closed(session_id):
+        return {"error": _CLOSED_SESSION_ERROR.format(sid=session_id)}
+    return None
+
+
 # ── LLM Schemas ───────────────────────────────────────────
 
 TIER_SCHEMA = {
@@ -218,6 +233,11 @@ def _field_enrichment(field_key: str) -> str:
 
 def map_dimensions(session_id: str, context: str) -> dict:
     """Map DRAFT dimensions against user context using LLM or heuristics."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return closed
+
     session = storage.get_session(session_id)
     if not session:
         return {"error": f"Session {session_id} not found"}
@@ -388,6 +408,11 @@ def _context_suggests_applicable(dim_key: str, context: str) -> bool:
 
 def generate_elicitation(session_id: str) -> list[dict]:
     """Generate targeted questions for MISSING/AMBIGUOUS fields."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return [closed]
+
     session = storage.get_session(session_id)
     if not session:
         return [{"error": f"Session {session_id} not found"}]
@@ -465,6 +490,11 @@ def _suggest_answer(field_key: str, intent: str) -> str | None:
 
 def generate_assumptions(session_id: str) -> list[dict]:
     """Surface key assumptions as falsifiable claims."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return [closed]
+
     session = storage.get_session(session_id)
     if not session:
         return [{"error": f"Session {session_id} not found"}]
@@ -508,6 +538,11 @@ def generate_assumptions(session_id: str) -> list[dict]:
 
 def check_gate(session_id: str) -> dict:
     """Check whether all applicable fields are confirmed."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return {"passed": False, "blockers": [closed["error"]], "summary": "ERROR"}
+
     session = storage.get_session(session_id)
     if not session:
         return {"passed": False, "blockers": ["Session not found"], "summary": "ERROR"}
@@ -554,7 +589,7 @@ def check_gate(session_id: str) -> dict:
 
     storage.log_audit(session_id, "draft_gate", "gate_check", f"{'PASS' if passed else 'FAIL'}: {confirmed}/{total}")
 
-    return {
+    result = {
         "passed": passed,
         "confirmed": confirmed,
         "total": total,
@@ -562,12 +597,40 @@ def check_gate(session_id: str) -> dict:
         "summary": f"{'[PASS]' if passed else '[BLOCKED]'}: {confirmed}/{total}",
     }
 
+    # M1.5: Context enrichment — compliant agents get rich context for free
+    if passed:
+        enrichment = {}
+        for dim_key in ["D", "R", "A", "F", "T"]:
+            dim_fields = dims.get(dim_key, {})
+            if isinstance(dim_fields, dict) and dim_fields.get("_screened"):
+                enrichment[dim_key] = {"_screened": True, "_reason": dim_fields.get("_reason", "N/A")}
+                continue
+            dim_data = {}
+            for fk, info in dim_fields.items():
+                if fk.startswith("_") or not isinstance(info, dict):
+                    continue
+                dim_data[fk] = {
+                    "value": info.get("extracted", ""),
+                    "question": info.get("question", ""),
+                    "status": info.get("status", "UNKNOWN"),
+                }
+            enrichment[dim_key] = dim_data
+        result["context_enrichment"] = enrichment
+        result["tier"] = session.get("tier", "UNKNOWN")
+
+    return result
+
 
 # ── Field Operations ──────────────────────────────────────
 
 
 def confirm_field(session_id: str, field_key: str, value: str) -> dict:
     """Confirm a DRAFT field with a human-provided answer."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return closed
+
     session = storage.get_session(session_id)
     if not session:
         return {"error": "Session not found"}
@@ -611,6 +674,11 @@ def confirm_field(session_id: str, field_key: str, value: str) -> dict:
 
 def unscreen_dimension(session_id: str, dimension_key: str) -> dict:
     """Reverse screening on a dimension incorrectly marked N/A."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return closed
+
     session = storage.get_session(session_id)
     if not session:
         return {"error": "Session not found"}
@@ -637,6 +705,11 @@ def unscreen_dimension(session_id: str, dimension_key: str) -> dict:
 
 def add_assumption(session_id: str, claim: str, source: str = "manual", falsifier: str = "") -> dict:
     """Add a manually authored assumption."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return closed
+
     session = storage.get_session(session_id)
     if not session:
         return {"error": "Session not found"}
@@ -658,6 +731,11 @@ def add_assumption(session_id: str, claim: str, source: str = "manual", falsifie
 
 def override_gate(session_id: str, reason: str) -> dict:
     """Override a blocked gate with logged reason (authorized override)."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return closed
+
     session = storage.get_session(session_id)
     if not session:
         return {"error": "Session not found"}
@@ -677,6 +755,11 @@ def override_gate(session_id: str, reason: str) -> dict:
 
 def verify_assumption(session_id: str, index: int, verified: bool, note: str = "") -> dict:
     """Verify or reject an assumption."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return closed
+
     session = storage.get_session(session_id)
     if not session:
         return {"error": "Session not found"}
@@ -698,6 +781,11 @@ def verify_assumption(session_id: str, index: int, verified: bool, note: str = "
 
 def elicitation_review(session_id: str) -> dict:
     """Self-assessment of elicitation quality."""
+    # M1.3: Closed session guard
+    closed = _check_open(session_id)
+    if closed:
+        return closed
+
     session = storage.get_session(session_id)
     if not session:
         return {"error": "Session not found"}

{draft_protocol-1.0.0 → draft_protocol-1.1.0}/src/draft_protocol/storage.py

@@ -7,6 +7,9 @@ from datetime import datetime, timezone
 
 from draft_protocol.config import DB_PATH
 
+# M1.4: Valid tier enum — reject anything not in this set
+VALID_TIERS = {"CASUAL", "STANDARD", "CONSEQUENTIAL"}
+
 
 def get_db() -> sqlite3.Connection:
     conn = sqlite3.connect(str(DB_PATH))
@@ -57,6 +60,9 @@ def _now() -> str:
 
 def create_session(tier: str, intent: str) -> str:
     """Create a new DRAFT session. Returns session_id."""
+    # M1.4: Validate tier enum
+    if tier not in VALID_TIERS:
+        raise ValueError(f"Invalid tier '{tier}'. Must be one of: {', '.join(sorted(VALID_TIERS))}")
     sid = str(uuid.uuid4())[:12]
     conn = get_db()
     now = _now()
@@ -83,6 +89,16 @@ def get_session(session_id: str) -> dict | None:
     return d
 
 
+def is_session_closed(session_id: str) -> bool:
+    """Check if a session is closed. M1.3: Closed session guard."""
+    conn = get_db()
+    row = conn.execute("SELECT closed_at FROM sessions WHERE id = ?", (session_id,)).fetchone()
+    conn.close()
+    if not row:
+        return True  # Nonexistent sessions treated as closed
+    return row["closed_at"] is not None
+
+
 def get_active_session() -> dict | None:
     """Get the most recent unclosed session."""
     conn = get_db()
@@ -98,6 +114,9 @@ def get_active_session() -> dict | None:
 
 def update_session(session_id: str, **kwargs):
     """Update session fields. JSON fields auto-serialized."""
+    # M1.4: Validate tier if being updated
+    if "tier" in kwargs and kwargs["tier"] not in VALID_TIERS:
+        raise ValueError(f"Invalid tier '{kwargs['tier']}'. Must be one of: {', '.join(sorted(VALID_TIERS))}")
     conn = get_db()
     sets = ["updated_at = ?"]
     vals = [_now()]

{draft_protocol-1.0.0 → draft_protocol-1.1.0}/tests/test_draft_protocol.py

@@ -21,10 +21,12 @@ from draft_protocol.engine import (  # noqa: E402
     verify_assumption,
 )
 from draft_protocol.storage import (  # noqa: E402
+    VALID_TIERS,
     close_session,
     create_session,
     get_active_session,
     get_session,
+    is_session_closed,
     log_audit,
 )
 
@@ -377,3 +379,199 @@ class TestProviderConfig:
         assert "ollama" in _EMBED_PROVIDERS
         assert "openai" in _EMBED_PROVIDERS
         assert "anthropic" in _EMBED_PROVIDERS
+
+
+# ── M1.3: Closed Session Guards ───────────────────────────
+
+
+class TestClosedSessionGuard:
+    """M1.3: All operations on closed sessions must return error."""
+
+    def _make_closed_session(self):
+        sid = create_session("STANDARD", "test")
+        map_dimensions(sid, "Build a tool for processing")
+        close_session(sid)
+        return sid
+
+    def test_is_session_closed(self):
+        sid = create_session("STANDARD", "test")
+        assert not is_session_closed(sid)
+        close_session(sid)
+        assert is_session_closed(sid)
+
+    def test_nonexistent_treated_as_closed(self):
+        assert is_session_closed("nonexistent_id_xyz")
+
+    def test_map_dimensions_blocked(self):
+        sid = self._make_closed_session()
+        result = map_dimensions(sid, "some context")
+        assert "error" in result
+        assert "closed" in result["error"].lower()
+
+    def test_generate_elicitation_blocked(self):
+        sid = self._make_closed_session()
+        result = generate_elicitation(sid)
+        assert len(result) == 1
+        assert "error" in result[0]
+        assert "closed" in result[0]["error"].lower()
+
+    def test_confirm_field_blocked(self):
+        sid = self._make_closed_session()
+        result = confirm_field(sid, "D1", "Some value here")
+        assert "error" in result
+        assert "closed" in result["error"].lower()
+
+    def test_check_gate_blocked(self):
+        sid = self._make_closed_session()
+        result = check_gate(sid)
+        assert not result["passed"]
+        assert any("closed" in b.lower() for b in result["blockers"])
+
+    def test_generate_assumptions_blocked(self):
+        sid = self._make_closed_session()
+        result = generate_assumptions(sid)
+        assert len(result) == 1
+        assert "error" in result[0]
+
+    def test_verify_assumption_blocked(self):
+        sid = self._make_closed_session()
+        result = verify_assumption(sid, 0, True)
+        assert "error" in result
+        assert "closed" in result["error"].lower()
+
+    def test_add_assumption_blocked(self):
+        sid = self._make_closed_session()
+        result = add_assumption(sid, "Test claim")
+        assert "error" in result
+        assert "closed" in result["error"].lower()
+
+    def test_override_gate_blocked(self):
+        sid = self._make_closed_session()
+        result = override_gate(sid, "Override reason")
+        assert "error" in result
+        assert "closed" in result["error"].lower()
+
+    def test_unscreen_dimension_blocked(self):
+        sid = self._make_closed_session()
+        result = unscreen_dimension(sid, "R")
+        assert "error" in result
+        assert "closed" in result["error"].lower()
+
+    def test_elicitation_review_blocked(self):
+        sid = self._make_closed_session()
+        result = elicitation_review(sid)
+        assert "error" in result
+        assert "closed" in result["error"].lower()
+
+    def test_error_message_includes_session_id(self):
+        sid = self._make_closed_session()
+        result = confirm_field(sid, "D1", "Some value")
+        assert sid in result["error"]
+
+
+# ── M1.4: Tier Enum Validation ────────────────────────────
+
+
+class TestTierEnumValidation:
+    """M1.4: Invalid tier strings must be rejected."""
+
+    def test_valid_tiers_constant_exists(self):
+        assert {"CASUAL", "STANDARD", "CONSEQUENTIAL"} == VALID_TIERS
+
+    def test_create_session_valid_tiers(self):
+        for tier in VALID_TIERS:
+            sid = create_session(tier, "test")
+            session = get_session(sid)
+            assert session["tier"] == tier
+
+    def test_create_session_invalid_tier_rejected(self):
+        import pytest
+        with pytest.raises(ValueError, match="Invalid tier"):
+            create_session("SUPER_HIGH", "test")
+
+    def test_create_session_lowercase_rejected(self):
+        import pytest
+        with pytest.raises(ValueError, match="Invalid tier"):
+            create_session("casual", "test")
+
+    def test_create_session_empty_tier_rejected(self):
+        import pytest
+        with pytest.raises(ValueError, match="Invalid tier"):
+            create_session("", "test")
+
+    def test_update_session_invalid_tier_rejected(self):
+        import pytest
+
+        from draft_protocol.storage import update_session
+        sid = create_session("CASUAL", "test")
+        with pytest.raises(ValueError, match="Invalid tier"):
+            update_session(sid, tier="INVALID")
+
+
+# ── M1.5: Context Enrichment Return ──────────────────────
+
+
+class TestContextEnrichment:
+    """M1.5: Gate PASS returns full dimensional mapping as structured context."""
+
+    def _make_passed_session(self):
+        sid = create_session("STANDARD", "test")
+        map_dimensions(sid, "Build a tool for processing data")
+        session = get_session(sid)
+        dims = session["dimensions"]
+        for _dk, fields in dims.items():
+            if isinstance(fields, dict) and fields.get("_screened"):
+                continue
+            for fk in fields:
+                if not fk.startswith("_"):
+                    confirm_field(sid, fk, f"Confirmed value for {fk} with enough content")
+        return sid
+
+    def test_gate_pass_includes_enrichment(self):
+        sid = self._make_passed_session()
+        gate = check_gate(sid)
+        assert gate["passed"]
+        assert "context_enrichment" in gate
+
+    def test_enrichment_has_all_dimensions(self):
+        sid = self._make_passed_session()
+        gate = check_gate(sid)
+        enrichment = gate["context_enrichment"]
+        for dim_key in ["D", "R", "A", "F", "T"]:
+            assert dim_key in enrichment
+
+    def test_enrichment_fields_have_value_and_question(self):
+        sid = self._make_passed_session()
+        gate = check_gate(sid)
+        enrichment = gate["context_enrichment"]
+        for _dim_key, dim_data in enrichment.items():
+            if dim_data.get("_screened"):
+                continue
+            for fk, info in dim_data.items():
+                if fk.startswith("_"):
+                    continue
+                assert "value" in info
+                assert "question" in info
+                assert "status" in info
+
+    def test_enrichment_includes_tier(self):
+        sid = self._make_passed_session()
+        gate = check_gate(sid)
+        assert "tier" in gate
+        assert gate["tier"] == "STANDARD"
+
+    def test_gate_fail_no_enrichment(self):
+        sid = create_session("STANDARD", "test")
+        map_dimensions(sid, "Build a tool")
+        gate = check_gate(sid)
+        assert not gate["passed"]
+        assert "context_enrichment" not in gate
+
+    def test_screened_dimensions_marked_in_enrichment(self):
+        sid = self._make_passed_session()
+        gate = check_gate(sid)
+        if gate["passed"]:
+            enrichment = gate["context_enrichment"]
+            for _dim_key, dim_data in enrichment.items():
+                if dim_data.get("_screened"):
+                    assert "_reason" in dim_data