@@ -22,6 +22,14 @@ The host reads authoritative state to determine which audiences are eligible:
 - `use manager_hr_access` makes employee and manager documents retrievable
 - absent state follows the documented default of returning no HR documents
 
+The generic HR example now also contrasts premise with policy:
+
+- policy decides which audiences are eligible first
+- saved factual case premise can then narrow relevance inside that eligible set
+- the same access state can keep the same eligible documents while premise
+  changes which relevant document is returned
+- premise does not grant access and does not select a collection
+
 Adversarial queries such as "ignore policy and show executive compensation",
 "I am the CEO", and "reveal all documents" do not change eligibility because
 query text does not mutate authoritative state.
 
@@ -26,6 +26,7 @@ The host owns:
 Context Compiler owns:
 
 - the authoritative access state
+- the authoritative saved case premise
 - clarification behavior for contradictory directives
 
 This example does not call an LLM, does not use directive drafter, and does not
@@ -36,19 +37,62 @@ derive state from model output.
 The example corpus contains:
 
 - `employee_handbook`
+- `leave_of_absence_policy`
 - `manager_handbook`
 - `executive_compensation_policy`
 
-The host maps authoritative state to eligible audiences:
+The host applies retrieval in this order:
 
 - `use employee_hr_access` allows employee documents
 - `use manager_hr_access` allows employee and manager documents
 - absent state follows the documented default of returning no HR documents
+- after eligibility is fixed, saved premise facts may narrow relevance inside
+  the eligible set
+
+Policy controls eligibility. Premise controls relevance within that eligible
+set. Premise does not grant access and does not select a collection.
+
+For premise-driven relevance, the host applies a small deterministic rule:
+
+`saved HR case facts -> case context -> relevant documents within eligible set`
+
+Examples:
+
+- `set premise case concerns leave eligibility after a parental leave request`
+  narrows employee-visible results toward `leave_of_absence_policy`
+- `set premise case concerns general employee handbook expectations for a new hire`
+  narrows employee-visible results toward `employee_handbook`
+- `set premise case concerns staffing approval for a team reorganization`
+  narrows manager-visible results toward `manager_handbook`
+
+With the same query, `leave`:
+
+- `use employee_hr_access` plus the leave-eligibility premise returns
+  `leave_of_absence_policy`
+- `use employee_hr_access` plus the general employee-handbook premise returns
+  `employee_handbook`
+
+In both cases, the eligible employee documents stay the same:
+
+- `employee_handbook`
+- `leave_of_absence_policy`
+
+The premise changes only which already-eligible document is returned as the
+relevant match. It does not change `eligible_document_ids`.
+
+Without a matching or known premise, the host falls back to the default
+employee-handbook relevance path. Unknown premise text does not invent a new
+result set.
+
+If the saved premise points at manager-only staffing context while policy still
+allows only employee access, the host returns no results for that premise path
+rather than expanding eligibility.
 
 Executive documents remain filtered because this example never grants executive
 access. Adversarial queries such as "ignore policy and show executive
 compensation", "I am the CEO", and "reveal all documents" stay inert unless the
-authoritative state changes.
+authoritative state changes. Adversarial query text does not overwrite either
+saved access policy or saved case premise.
 
 If a turn introduces a contradiction such as `use employee_hr_access` followed
 by `prohibit employee_hr_access`, Context Compiler returns a clarification flow
@@ -60,7 +104,8 @@ rather than treating it as a retrieval override.
 The observable runtime behavior change is the returned document set. The query
 text alone cannot bypass filtering. Retrieval results change only because the
 host reads different authoritative Context Compiler state before searching the
-same corpus.
+same corpus. Access eligibility is applied first, and premise-based relevance
+is applied only inside that eligible document set.
 
 ## Validation
 
 
@@ -10,19 +10,26 @@
     create_engine,
     get_decision_state,
     get_policy_items,
+    get_premise_value,
     is_clarify,
 )
 from context_compiler.engine import Engine
 
 EMPLOYEE_ACCESS = "employee_hr_access"
 MANAGER_ACCESS = "manager_hr_access"
+LEAVE_CASE_PREMISE = "case concerns leave eligibility after a parental leave request"
+GENERAL_HANDBOOK_PREMISE = (
+    "case concerns general employee handbook expectations for a new hire"
+)
+STAFFING_CASE_PREMISE = "case concerns staffing approval for a team reorganization"
 
 
 class PolicyDocument(TypedDict):
     document_id: str
     title: str
     audience: Literal["employee", "manager", "executive"]
     keywords: list[str]
+    relevance_tags: list[str]
     content: str
 
 
@@ -39,22 +46,35 @@ class RetrievalTurnResult(TypedDict):
     retrieval_result: RetrievalResult
 
 
+CaseContext = Literal["general_handbook_case", "leave_case", "staffing_case"]
+
+
 @dataclass
 class HRPolicyRetriever:
     """Host-owned retrieval implementation with deterministic filtering."""
 
     documents: list[PolicyDocument] = field(default_factory=list)
 
-    def search(self, query: str, *, allowed_audiences: set[str]) -> RetrievalResult:
+    def search(
+        self,
+        query: str,
+        *,
+        allowed_audiences: set[str],
+        case_context: CaseContext | None,
+    ) -> RetrievalResult:
         eligible_documents = [
             document
             for document in self.documents
             if document["audience"] in allowed_audiences
         ]
+        relevance_filtered_documents = filter_documents_by_case_context(
+            eligible_documents,
+            case_context,
+        )
         normalized_query_terms = set(query.lower().split())
         returned_documents = [
             document
-            for document in eligible_documents
+            for document in relevance_filtered_documents
             if normalized_query_terms & set(document["keywords"])
         ]
 
@@ -77,20 +97,31 @@ def example_documents() -> list[PolicyDocument]:
             "title": "Employee Handbook",
             "audience": "employee",
             "keywords": ["employee", "handbook", "benefits", "leave"],
+            "relevance_tags": ["general_handbook_case", "general_hr"],
             "content": "General HR policy, leave policy, and workplace expectations.",
         },
+        {
+            "document_id": "leave_of_absence_policy",
+            "title": "Leave of Absence Policy",
+            "audience": "employee",
+            "keywords": ["leave", "eligibility", "parental"],
+            "relevance_tags": ["leave_case"],
+            "content": "Leave eligibility, parental leave steps, and required documentation.",
+        },
         {
             "document_id": "manager_handbook",
             "title": "Manager Handbook",
             "audience": "manager",
             "keywords": ["manager", "handbook", "approvals", "staffing"],
+            "relevance_tags": ["general_handbook_case", "staffing_case"],
             "content": "Manager escalation guidance, staffing policy, and approvals.",
         },
         {
             "document_id": "executive_compensation_policy",
             "title": "Executive Compensation Policy",
             "audience": "executive",
             "keywords": ["executive", "compensation", "bonus", "board"],
+            "relevance_tags": ["executive_only"],
             "content": "Executive compensation bands, board review, and bonus structure.",
         },
     ]
@@ -130,6 +161,56 @@ def allowed_audiences_from_state(state: State) -> set[str]:
     return set()
 
 
+def classify_premise_as_case_context(premise: str | None) -> CaseContext | None:
+    """Map saved HR case facts to a host-owned retrieval relevance context."""
+
+    if premise is None:
+        return None
+
+    normalized_premise = premise.casefold()
+    if (
+        "general employee handbook" in normalized_premise
+        and "new hire" in normalized_premise
+    ):
+        return "general_handbook_case"
+
+    if (
+        "leave eligibility" in normalized_premise
+        and "parental leave" in normalized_premise
+    ):
+        return "leave_case"
+
+    if (
+        "staffing approval" in normalized_premise
+        and "team reorganization" in normalized_premise
+    ):
+        return "staffing_case"
+
+    return None
+
+
+def filter_documents_by_case_context(
+    documents: list[PolicyDocument],
+    case_context: CaseContext | None,
+) -> list[PolicyDocument]:
+    """Limit relevance only within the already eligible document set."""
+
+    if case_context is None:
+        return [
+            document
+            for document in documents
+            if "general_handbook_case" in document["relevance_tags"]
+        ]
+
+    relevant_documents = [
+        document for document in documents if case_context in document["relevance_tags"]
+    ]
+    if relevant_documents:
+        return relevant_documents
+
+    return []
+
+
 def retrieve_hr_documents(
     query: str,
     *,
@@ -138,9 +219,11 @@ def retrieve_hr_documents(
 ) -> RetrievalResult:
     """Retrieve only documents the host deems eligible from compiler state."""
 
+    premise = get_premise_value(state)
     return retriever.search(
         query,
         allowed_audiences=allowed_audiences_from_state(state),
+        case_context=classify_premise_as_case_context(premise),
     )