context-compiler 0.9.0.dev3__tar.gz → 0.9.0.dev5__tar.gz

{context_compiler-0.9.0.dev3 → context_compiler-0.9.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: context-compiler
-Version: 0.9.0.dev3
+Version: 0.9.0.dev5
 Summary: Deterministic conversational state engine for LLM applications.
 Project-URL: Homepage, https://github.com/rlippmann/context-compiler
 Project-URL: Repository, https://github.com/rlippmann/context-compiler
@@ -18,14 +18,6 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.11
 Provides-Extra: demos
 Requires-Dist: litellm>=1.0.0; extra == 'demos'
-Provides-Extra: dev
-Requires-Dist: coverage; extra == 'dev'
-Requires-Dist: hypothesis; extra == 'dev'
-Requires-Dist: mypy<2.0,>=1.12; extra == 'dev'
-Requires-Dist: pre-commit; extra == 'dev'
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: pytest-cov; extra == 'dev'
-Requires-Dist: ruff<1.0,>=0.12; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Context Compiler
@@ -36,7 +28,7 @@ Description-Content-Type: text/markdown
 
 Context Compiler is a deterministic conversational state authority for LLM applications.
 It handles canonical directive execution, semantic validation, deterministic
-clarify decisions, runtime semantic continuation boundaries, and structured authoritative state for
+error decisions, runtime semantic continuation boundaries, and structured authoritative state for
 the host.
 
 ## What Context Compiler provides
@@ -44,7 +36,7 @@ the host.
 Context Compiler gives hosts fixed state rules:
 
 - handle canonical explicit state changes with deterministic rules
-- clarification instead of silent overwrite for blocked/ambiguous changes
+- error instead of silent overwrite for blocked/ambiguous changes
 - preserve supported pending continuation when explicit confirmation is required
 - export and import authoritative state for host-managed persistence
 - produce structured authoritative state for downstream host decisions
@@ -89,7 +81,7 @@ Context Compiler makes state-change rules explicit so behavior stays repeatable.
 The architecture has three layers:
 
 - syntax classification decides whether input is a canonical directive, invalid
-  directive-shaped syntax, or ordinary passthrough
+  directive-shaped syntax, or ordinary no_directive
 - semantic evaluation decides whether a canonical directive updates state,
   clarifies, or no-ops
 - semantic continuation optionally preserves a deterministic blocked transition
@@ -123,7 +115,7 @@ use podman instead of docker
 - Without explicit state transition rules: behavior depends on host/model handling
 - Context Compiler: applies the deterministic resulting transition when
   `docker` is absent and `use podman` is otherwise valid; other semantic
-  conflicts may still clarify
+  conflicts may still error
 
 ### Lifecycle enforcement
 
@@ -133,7 +125,7 @@ change premise to formal tone
 ```
 
 - Without explicit transition checks: behavior depends on host/model handling
-- Context Compiler: asks for clarification and keeps saved state unchanged
+- Context Compiler: asks for error and keeps saved state unchanged
 
 ---
 
@@ -150,9 +142,9 @@ Decision
      │
      ▼
 Host Application
- ├─ clarify → ask user
- ├─ passthrough → call LLM
- └─ update → authoritative state mutated; host may call LLM with compiled state
+ ├─ error → ask user
+ ├─ no_directive → no canonical directive recognized; host decides what to do next
+ └─ update → authoritative state mutated; host may use compiled state downstream
 ```
 
 The compiler never calls the LLM. Your app decides what to do with the returned
@@ -167,8 +159,7 @@ Use Context Compiler in your host application first:
 ```python
 from context_compiler import (
     create_engine,
-    get_clarify_prompt,
-    is_clarify,
+    is_error,
     is_update,
 )
 
@@ -177,10 +168,14 @@ engine = create_engine()
 user_input = "set premise current project uses uv"
 decision = engine.step(user_input)
 
-if is_clarify(decision):
-    show_to_user(get_clarify_prompt(decision))
+if is_error(decision):
+    show_to_user(decision["message"])
 elif is_update(decision):
-    messages = build_messages(engine.state, user_input)
+    messages = build_messages(
+        premise=engine.premise,
+        policies=engine.policies,
+        user_input=user_input,
+    )
     render(call_llm(messages))
 else:
     render(call_llm(user_input))
@@ -224,10 +219,9 @@ Preload options load authoritative state:
 - `--initial-state-json` / `--initial-state-file` load saved state
   (via exported state JSON).
 
-REPL commands (controller layer, not engine directives):
+REPL commands (not engine directives):
 
 - `state` shows current saved state.
-- `preview <input>` runs deterministic dry-run without mutating live state.
 - `step <input>` is an explicit alias of normal bare-input step behavior.
 
 Bare REPL input behavior remains unchanged.
@@ -268,7 +262,7 @@ Packaging notes:
 ### Development
 
 ```bash
-uv sync --group dev
+uv sync --dev
 uv run pytest
 ```
 
@@ -277,22 +271,30 @@ uv run pytest
 Each user message produces a `Decision`.
 
 ```python
+class DecisionKind(StrEnum):
+    NO_DIRECTIVE = "no_directive"
+    UPDATE = "update"
+    ERROR = "error"
+
 class Decision(TypedDict):
-    kind: Literal["passthrough", "update", "clarify"]
-    state: dict | None
-    prompt_to_user: str | None
+    kind: DecisionKind
+    message: str | None
 ```
 
+`message` is structurally present on every `Decision`, but it is semantically
+meaningful only for `error`. For `no_directive` and `update`, `message` is
+`None`.
+
 Meaning:
 
 | kind | host behavior |
 | --- | --- |
-| passthrough | forward user input to LLM |
-| update | authoritative state mutated; host may call LLM with updated state |
-| clarify | show `prompt_to_user` and do not call the LLM |
+| no_directive | no canonical directive recognized; no authoritative state change; host decides what to do next |
+| update | authoritative state mutated; host may use updated state downstream |
+| error | show `message` and do not continue normal downstream processing yet |
 
-For normal app code, prefer the exported decision helpers (`is_clarify`,
-`is_update`, `is_passthrough`, `get_clarify_prompt`, `get_decision_state`)
+For normal app code, prefer the exported decision helpers (`is_error`,
+`is_update`, `is_no_directive`, `get_error_message`)
 instead of direct key traversal.
 
 See [docs/api-reference.md](docs/api-reference.md) for the full public API
@@ -300,26 +302,12 @@ reference.
 
 Common API entry points:
 
-- engine lifecycle: `create_engine(...)`, `engine.step(...)`, `engine.state`,
+- engine lifecycle: `create_engine()`, `engine.step(...)`,
   `engine.premise`, `engine.policies`, `engine.export_json(...)`,
   `engine.import_json(...)`
-- decision helpers: `is_clarify(...)`, `is_update(...)`, `is_passthrough(...)`,
-  `get_clarify_prompt(...)`, `get_decision_state(...)`
+- decision helpers: `is_error(...)`, `is_update(...)`, `is_no_directive(...)`,
+  `get_error_message(...)`
 - state transport: `engine.export_json(...)`, `engine.import_json(...)`
-- controller API: `step(...)`
-- audit APIs: `preview(...)`, `state_diff(...)`
-
-### Controller And Audit APIs (Reusable Outside REPL)
-
-- `step(engine, user_input)` returns a reusable result envelope around one
-  engine turn
-- `preview(engine, user_input)` performs a deterministic dry run and restores
-  live engine state afterward
-- `state_diff(state_before, state_after)` summarizes structural state changes
-
-For examples and helper accessors such as `get_step_decision(...)`,
-`get_preview_state_after(...)`, `preview_would_mutate(...)`, and
-`diff_has_changes(...)`, see [docs/api-reference.md](docs/api-reference.md).
 
 ---
 
@@ -343,8 +331,8 @@ Identical input sequences always produce identical state.
 For live engine-owned reads, use `engine.premise` and `engine.policies`.
 `engine.policies` returns a caller-owned copy.
 
-`engine.state` remains the public snapshot/serialization boundary when host code
-needs the full authoritative state object.
+Use `engine.export_json()` and `engine.import_json()` for persistence and
+restoration.
 
 ---
 
@@ -441,14 +429,14 @@ User: clear state
 
 Grammar invariant: one input may contain at most one canonical directive.
 Directive-shaped invalid input is outside the canonical language, and
-`clarify` is reserved for canonical directives that later fail semantic
+`error` is reserved for canonical directives that later fail semantic
 evaluation against authoritative state.
 
 Pending continuation is a separate runtime layer. It may exist only after a
-canonical directive reaches a supported semantic `clarify` case. It never
+canonical directive reaches a supported semantic `error` case. It never
 repairs malformed syntax or reinterprets non-canonical input as a directive.
 An absent source item in a canonical replacement directive is not, by itself,
-such a `clarify` case.
+such a `error` case.
 
 Examples:
 
@@ -496,7 +484,7 @@ boundary, see [DirectiveGrammarSpec.md](docs/DirectiveGrammarSpec.md).
 **Isn't this just prompt reinjection?**
 No. Prompt construction is one downstream use of authoritative state.
 Context Compiler is the authority layer that decides when state changes are
-allowed, when clarification is required, and how continuation state is
+allowed, when error is required, and how continuation state is
 restored. For runnable application-layer examples, see
 [`context-compiler-example-integrations`](https://github.com/rlippmann/context-compiler-example-integrations).
 
@@ -519,7 +507,7 @@ User: prohibit python_script
 
 Without an authority layer, the application must invent conflict-resolution and
 continuation rules itself. Context Compiler applies deterministic
-state-transition rules and can return clarification instead of silently
+state-transition rules and can return error instead of silently
 overwriting state.
 
 ---
@@ -531,7 +519,7 @@ overwriting state.
 - State changes only through explicit user directives or confirmation.
 - Identical input sequences produce identical compiler state.
 - Model responses never modify compiler state.
-- Ambiguous directives trigger clarification instead of changing state.
+- Ambiguous directives trigger error instead of changing state.
 - Syntax errors never create pending continuation.
 
 Behavioral tests and Hypothesis-based property tests verify these invariants.

{context_compiler-0.9.0.dev3 → context_compiler-0.9.0.dev5}/README.md

@@ -6,7 +6,7 @@
 
 Context Compiler is a deterministic conversational state authority for LLM applications.
 It handles canonical directive execution, semantic validation, deterministic
-clarify decisions, runtime semantic continuation boundaries, and structured authoritative state for
+error decisions, runtime semantic continuation boundaries, and structured authoritative state for
 the host.
 
 ## What Context Compiler provides
@@ -14,7 +14,7 @@ the host.
 Context Compiler gives hosts fixed state rules:
 
 - handle canonical explicit state changes with deterministic rules
-- clarification instead of silent overwrite for blocked/ambiguous changes
+- error instead of silent overwrite for blocked/ambiguous changes
 - preserve supported pending continuation when explicit confirmation is required
 - export and import authoritative state for host-managed persistence
 - produce structured authoritative state for downstream host decisions
@@ -59,7 +59,7 @@ Context Compiler makes state-change rules explicit so behavior stays repeatable.
 The architecture has three layers:
 
 - syntax classification decides whether input is a canonical directive, invalid
-  directive-shaped syntax, or ordinary passthrough
+  directive-shaped syntax, or ordinary no_directive
 - semantic evaluation decides whether a canonical directive updates state,
   clarifies, or no-ops
 - semantic continuation optionally preserves a deterministic blocked transition
@@ -93,7 +93,7 @@ use podman instead of docker
 - Without explicit state transition rules: behavior depends on host/model handling
 - Context Compiler: applies the deterministic resulting transition when
   `docker` is absent and `use podman` is otherwise valid; other semantic
-  conflicts may still clarify
+  conflicts may still error
 
 ### Lifecycle enforcement
 
@@ -103,7 +103,7 @@ change premise to formal tone
 ```
 
 - Without explicit transition checks: behavior depends on host/model handling
-- Context Compiler: asks for clarification and keeps saved state unchanged
+- Context Compiler: asks for error and keeps saved state unchanged
 
 ---
 
@@ -120,9 +120,9 @@ Decision
      │
      ▼
 Host Application
- ├─ clarify → ask user
- ├─ passthrough → call LLM
- └─ update → authoritative state mutated; host may call LLM with compiled state
+ ├─ error → ask user
+ ├─ no_directive → no canonical directive recognized; host decides what to do next
+ └─ update → authoritative state mutated; host may use compiled state downstream
 ```
 
 The compiler never calls the LLM. Your app decides what to do with the returned
@@ -137,8 +137,7 @@ Use Context Compiler in your host application first:
 ```python
 from context_compiler import (
     create_engine,
-    get_clarify_prompt,
-    is_clarify,
+    is_error,
     is_update,
 )
 
@@ -147,10 +146,14 @@ engine = create_engine()
 user_input = "set premise current project uses uv"
 decision = engine.step(user_input)
 
-if is_clarify(decision):
-    show_to_user(get_clarify_prompt(decision))
+if is_error(decision):
+    show_to_user(decision["message"])
 elif is_update(decision):
-    messages = build_messages(engine.state, user_input)
+    messages = build_messages(
+        premise=engine.premise,
+        policies=engine.policies,
+        user_input=user_input,
+    )
     render(call_llm(messages))
 else:
     render(call_llm(user_input))
@@ -194,10 +197,9 @@ Preload options load authoritative state:
 - `--initial-state-json` / `--initial-state-file` load saved state
   (via exported state JSON).
 
-REPL commands (controller layer, not engine directives):
+REPL commands (not engine directives):
 
 - `state` shows current saved state.
-- `preview <input>` runs deterministic dry-run without mutating live state.
 - `step <input>` is an explicit alias of normal bare-input step behavior.
 
 Bare REPL input behavior remains unchanged.
@@ -238,7 +240,7 @@ Packaging notes:
 ### Development
 
 ```bash
-uv sync --group dev
+uv sync --dev
 uv run pytest
 ```
 
@@ -247,22 +249,30 @@ uv run pytest
 Each user message produces a `Decision`.
 
 ```python
+class DecisionKind(StrEnum):
+    NO_DIRECTIVE = "no_directive"
+    UPDATE = "update"
+    ERROR = "error"
+
 class Decision(TypedDict):
-    kind: Literal["passthrough", "update", "clarify"]
-    state: dict | None
-    prompt_to_user: str | None
+    kind: DecisionKind
+    message: str | None
 ```
 
+`message` is structurally present on every `Decision`, but it is semantically
+meaningful only for `error`. For `no_directive` and `update`, `message` is
+`None`.
+
 Meaning:
 
 | kind | host behavior |
 | --- | --- |
-| passthrough | forward user input to LLM |
-| update | authoritative state mutated; host may call LLM with updated state |
-| clarify | show `prompt_to_user` and do not call the LLM |
+| no_directive | no canonical directive recognized; no authoritative state change; host decides what to do next |
+| update | authoritative state mutated; host may use updated state downstream |
+| error | show `message` and do not continue normal downstream processing yet |
 
-For normal app code, prefer the exported decision helpers (`is_clarify`,
-`is_update`, `is_passthrough`, `get_clarify_prompt`, `get_decision_state`)
+For normal app code, prefer the exported decision helpers (`is_error`,
+`is_update`, `is_no_directive`, `get_error_message`)
 instead of direct key traversal.
 
 See [docs/api-reference.md](docs/api-reference.md) for the full public API
@@ -270,26 +280,12 @@ reference.
 
 Common API entry points:
 
-- engine lifecycle: `create_engine(...)`, `engine.step(...)`, `engine.state`,
+- engine lifecycle: `create_engine()`, `engine.step(...)`,
   `engine.premise`, `engine.policies`, `engine.export_json(...)`,
   `engine.import_json(...)`
-- decision helpers: `is_clarify(...)`, `is_update(...)`, `is_passthrough(...)`,
-  `get_clarify_prompt(...)`, `get_decision_state(...)`
+- decision helpers: `is_error(...)`, `is_update(...)`, `is_no_directive(...)`,
+  `get_error_message(...)`
 - state transport: `engine.export_json(...)`, `engine.import_json(...)`
-- controller API: `step(...)`
-- audit APIs: `preview(...)`, `state_diff(...)`
-
-### Controller And Audit APIs (Reusable Outside REPL)
-
-- `step(engine, user_input)` returns a reusable result envelope around one
-  engine turn
-- `preview(engine, user_input)` performs a deterministic dry run and restores
-  live engine state afterward
-- `state_diff(state_before, state_after)` summarizes structural state changes
-
-For examples and helper accessors such as `get_step_decision(...)`,
-`get_preview_state_after(...)`, `preview_would_mutate(...)`, and
-`diff_has_changes(...)`, see [docs/api-reference.md](docs/api-reference.md).
 
 ---
 
@@ -313,8 +309,8 @@ Identical input sequences always produce identical state.
 For live engine-owned reads, use `engine.premise` and `engine.policies`.
 `engine.policies` returns a caller-owned copy.
 
-`engine.state` remains the public snapshot/serialization boundary when host code
-needs the full authoritative state object.
+Use `engine.export_json()` and `engine.import_json()` for persistence and
+restoration.
 
 ---
 
@@ -411,14 +407,14 @@ User: clear state
 
 Grammar invariant: one input may contain at most one canonical directive.
 Directive-shaped invalid input is outside the canonical language, and
-`clarify` is reserved for canonical directives that later fail semantic
+`error` is reserved for canonical directives that later fail semantic
 evaluation against authoritative state.
 
 Pending continuation is a separate runtime layer. It may exist only after a
-canonical directive reaches a supported semantic `clarify` case. It never
+canonical directive reaches a supported semantic `error` case. It never
 repairs malformed syntax or reinterprets non-canonical input as a directive.
 An absent source item in a canonical replacement directive is not, by itself,
-such a `clarify` case.
+such a `error` case.
 
 Examples:
 
@@ -466,7 +462,7 @@ boundary, see [DirectiveGrammarSpec.md](docs/DirectiveGrammarSpec.md).
 **Isn't this just prompt reinjection?**
 No. Prompt construction is one downstream use of authoritative state.
 Context Compiler is the authority layer that decides when state changes are
-allowed, when clarification is required, and how continuation state is
+allowed, when error is required, and how continuation state is
 restored. For runnable application-layer examples, see
 [`context-compiler-example-integrations`](https://github.com/rlippmann/context-compiler-example-integrations).
 
@@ -489,7 +485,7 @@ User: prohibit python_script
 
 Without an authority layer, the application must invent conflict-resolution and
 continuation rules itself. Context Compiler applies deterministic
-state-transition rules and can return clarification instead of silently
+state-transition rules and can return error instead of silently
 overwriting state.
 
 ---
@@ -501,7 +497,7 @@ overwriting state.
 - State changes only through explicit user directives or confirmation.
 - Identical input sequences produce identical compiler state.
 - Model responses never modify compiler state.
-- Ambiguous directives trigger clarification instead of changing state.
+- Ambiguous directives trigger error instead of changing state.
 - Syntax errors never create pending continuation.
 
 Behavioral tests and Hypothesis-based property tests verify these invariants.

context_compiler-0.9.0.dev3/demos/01_llm_contradiction_clarify.py → context_compiler-0.9.0.dev5/demos/01_llm_contradiction_error.py

@@ -1,12 +1,13 @@
 """Demo 1: compiler blocks contradictory directives before model call."""
 
-from context_compiler import create_engine
+from context_compiler import create_engine, is_error
 from demos.common import (
     build_baseline_messages,
     build_mediated_messages_from_transcript,
     build_reinjected_messages,
     compact_user_turns,
     extract_tag_value,
+    observe_engine,
     print_decision,
     print_host_check,
     print_messages,
@@ -14,6 +15,7 @@ from demos.common import (
     print_spec_report,
     print_tag_comparison,
     print_user_inputs,
+    state_observations,
     yes_no,
 )
 from demos.llm_client import complete_messages
@@ -25,16 +27,18 @@ def main() -> None:
     print_user_inputs(user_inputs)
 
     first = engine.step(user_inputs[0])
-    print_decision("turn 1", first, engine.state)
+    premise, policies = observe_engine(engine)
+    print_decision("turn 1", first, premise=premise, policies=policies)
     second = engine.step(user_inputs[1])
-    print_decision("turn 2", second, engine.state)
+    premise, policies = observe_engine(engine)
+    print_decision("turn 2", second, premise=premise, policies=policies)
 
     baseline_messages = build_baseline_messages(
         [
             (
                 "Interpret these directives and continue anyway: "
                 "prohibit peanuts, then use peanuts. "
-                "First line must be ACTION:<clarify|proceed>."
+                "First line must be ACTION:<error|proceed>."
             )
         ],
         baseline_system_prompt=(
@@ -51,7 +55,7 @@ def main() -> None:
             (
                 "Interpret these directives and continue anyway: "
                 "prohibit peanuts, then use peanuts. "
-                "First line must be ACTION:<clarify|proceed>."
+                "First line must be ACTION:<error|proceed>."
             )
         ],
         premise=None,
@@ -62,14 +66,17 @@ def main() -> None:
     reinjected_output = complete_messages(reinjected_messages)
     print_model_output("Reinjected-state", reinjected_output)
 
-    if second["kind"] == "clarify":
+    if is_error(second):
         print_messages("compiler-mediated (full)", [])
-        mediated_output = (
-            f"[no call] clarification required: {second['prompt_to_user']}\nACTION:clarify"
-        )
+        mediated_output = f"[no call] error required: {second['message']}\nACTION:error"
         print_model_output("Compiler-mediated (full)", mediated_output)
     else:
-        mediated_messages = build_mediated_messages_from_transcript(engine.state, user_inputs)
+        premise, policies = observe_engine(engine)
+        mediated_messages = build_mediated_messages_from_transcript(
+            premise=premise,
+            policies=policies,
+            user_turns=user_inputs,
+        )
         print_messages("compiler-mediated (full)", mediated_messages)
         mediated_output = complete_messages(mediated_messages)
         print_model_output("Compiler-mediated (full)", mediated_output)
@@ -77,10 +84,15 @@ def main() -> None:
     compacted_turns, compacted_state, compacted_prompt = compact_user_turns(user_inputs)
     if compacted_prompt is not None:
         print_messages("compiler-mediated + compact", [])
-        compact_output = f"[no call] clarification required: {compacted_prompt}\nACTION:clarify"
+        compact_output = f"[no call] error required: {compacted_prompt}\nACTION:error"
         print_model_output("Compiler-mediated + compact", compact_output)
     else:
-        compact_messages = build_mediated_messages_from_transcript(compacted_state, compacted_turns)
+        compacted_premise, compacted_policies = state_observations(compacted_state)
+        compact_messages = build_mediated_messages_from_transcript(
+            premise=compacted_premise,
+            policies=compacted_policies,
+            user_turns=compacted_turns,
+        )
         print_messages("compiler-mediated + compact", compact_messages)
         compact_output = complete_messages(compact_messages)
         print_model_output("Compiler-mediated + compact", compact_output)
@@ -89,15 +101,15 @@ def main() -> None:
     baseline_action = extract_tag_value(baseline_output, "ACTION")
     reinjected_action = extract_tag_value(reinjected_output, "ACTION")
     compact_action = extract_tag_value(compact_output, "ACTION")
-    baseline_respects = baseline_action is not None and baseline_action.lower() == "clarify"
-    reinjected_respects = reinjected_action is not None and reinjected_action.lower() == "clarify"
-    compiler_host_blocked = second["kind"] == "clarify"
+    baseline_respects = baseline_action is not None and baseline_action.lower() == "error"
+    reinjected_respects = reinjected_action is not None and reinjected_action.lower() == "error"
+    compiler_host_blocked = is_error(second)
     mediated_respects = compiler_host_blocked
     compact_respects = compacted_prompt is not None or (
-        compact_action is not None and compact_action.lower() == "clarify"
+        compact_action is not None and compact_action.lower() == "error"
     )
     print_host_check(
-        "ACTION_CLARIFY",
+        "ACTION_ERROR",
         yes_no(reinjected_respects),
         context="reinjected-state",
     )
@@ -112,26 +124,25 @@ def main() -> None:
         context="compiler-mediated + compact",
     )
     print_spec_report(
-        test_name="01_contradiction_block — host clarification gate",
+        test_name="01_contradiction_block — host error gate",
         baseline_pass=baseline_respects,
         reinjected_state_pass=reinjected_respects,
         compiler_pass=mediated_respects,
         compiler_compact_pass=compact_respects,
-        expected="host should block LLM call on contradictory directive until clarification",
+        expected="host should block LLM call on contradictory directive until error",
         actual=(
-            "baseline proceeded instead of clarifying; "
+            "baseline proceeded instead of erroring; "
             "both compiler-mediated paths blocked the LLM call"
             if mediated_respects and compact_respects and not baseline_respects
             else (
-                "baseline also signaled clarification; "
-                "both compiler-mediated paths blocked the LLM call"
+                "baseline also signaled error; both compiler-mediated paths blocked the LLM call"
                 if baseline_respects and mediated_respects and compact_respects
                 else "at least one compiler-mediated path did not block the LLM call as expected"
             )
         ),
         passed=mediated_respects and compact_respects,
-        result_pass="contradictory directive blocked until clarification",
-        result_fail="contradictory directive not blocked until clarification",
+        result_pass="contradictory directive blocked until error",
+        result_fail="contradictory directive not blocked until error",
     )