From 1f8100e2cae947f8f263b70a6d99fbffb9533eeb Mon Sep 17 00:00:00 2001
From: Robert Lippmann <robert.lippmann.development@gmail.com>
Date: Wed, 19 Aug 2026 01:18:43 -0400
Subject: [PATCH 1/4] chore: bump OpenWebUI pipe version to 0.10.0

---
 python/reference_integrations/openwebui_pipe/open_webui_pipe.py | 2 +-
 .../openwebui_pipe/open_webui_pipe_with_directive_drafter.py    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/reference_integrations/openwebui_pipe/open_webui_pipe.py b/python/reference_integrations/openwebui_pipe/open_webui_pipe.py
index 42f45d8..cef5dd3 100644
--- a/python/reference_integrations/openwebui_pipe/open_webui_pipe.py
+++ b/python/reference_integrations/openwebui_pipe/open_webui_pipe.py
@@ -2,7 +2,7 @@
 title: Context Compiler Open WebUI Pipe
 author: rlippmann
 author_url: https://github.com/rlippmann/context-compiler-example-integrations
-version: 0.9.4
+version: 0.10.0
 requirements: context-compiler>=0.9.0dev13
 
 Minimal Open WebUI Pipe integration for Context Compiler.
diff --git a/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py b/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
index e4e404a..f0af75b 100644
--- a/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
+++ b/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
@@ -2,7 +2,7 @@
 title: Context Compiler Open WebUI Pipe (Directive Drafter)
 author: rlippmann
 author_url: https://github.com/rlippmann/context-compiler-example-integrations
-version: 0.9.4
+version: 0.10.0
 requirements: context-compiler>=0.9.0dev13, context-compiler-directive-drafter>=0.2.0dev2
 
 Open WebUI integration with Context Compiler directive drafter.

From cfbc90b95fd92c052a0ed777b3ecc85ce3a5e1e3 Mon Sep 17 00:00:00 2001
From: Robert Lippmann <robert.lippmann.development@gmail.com>
Date: Wed, 19 Aug 2026 02:05:38 -0400
Subject: [PATCH 2/4] feat: add OpenWebUI HITL approval flow

---
 .../openwebui_pipe/README.md                  |   9 +-
 .../open_webui_pipe_with_directive_drafter.py |  83 ++++++++--
 ...t_openwebui_pipe_with_directive_drafter.py | 145 +++++++++++++++---
 3 files changed, 199 insertions(+), 38 deletions(-)

diff --git a/python/reference_integrations/openwebui_pipe/README.md b/python/reference_integrations/openwebui_pipe/README.md
index d45b6b4..f0db733 100644
--- a/python/reference_integrations/openwebui_pipe/README.md
+++ b/python/reference_integrations/openwebui_pipe/README.md
@@ -140,6 +140,8 @@ Suggested verification:
 - Send `please use docker` and confirm either:
   - the Directive Drafter converts it into a local state update, or
   - trace shows the turn followed the normal compiler path without a silent state change
+- When a canonical directive is drafted, keep the approval response in the conversation and send `y`; confirm the next request returns `State updated.` and `show state` reports `Use: docker`.
+- Repeat the draft flow with `n`; confirm the pipe returns `Directive discarded. No state change was applied.` and `show state` remains unchanged.
 - Send `please use docker`, then `prohibit docker`, and confirm the second request is rejected without creating resumable state
 - Send `use docker and prohibit peanuts` and confirm the pipe responds locally that multiple directives are not supported and must be submitted separately
 - Send a normal prompt such as `what should I run?` and confirm trace shows a forwarded turn with compiler state included
@@ -148,13 +150,15 @@ Advanced check:
 
 - If you have a local proxy or stub, inspect the forwarded request and confirm it contains exactly one `[[cc_state]]` system message reflecting the active state.
 - Confirm that saved premise appears as `Premise: ...` and saved policy appears as `Use: ...` or `Prohibit: ...`.
+- Confirm that the approval response remains in the Open WebUI message history between the draft and the `y`/`n` request. The pipe stores the pending canonical directive in a host-visible conversation marker, restores it as a `CanonicalDirective`, and strips the marker before downstream model calls.
 
 ### Optional extra checks
 
 If you want a slightly broader manual pass:
 
 - verify chat isolation with separate real chat ids
-- verify state is lost after restart because these examples do not use external persistence
+- verify a pending approval survives chat continuation, including pipe object replacement, while the conversation transcript is retained
+- verify this does not imply that authoritative state survives a server restart; engine state is lost after restart because these examples do not use external persistence
 - verify non-text input is bypassed
 
 ### Notes
@@ -165,7 +169,8 @@ If you want a slightly broader manual pass:
 
 ## Limits
 
-- No durable external persistence
+- Pending approval survives chat continuation only when Open WebUI resends the prior assistant message in the conversation transcript
+- Authoritative state does not survive a server restart; it remains in-memory because these examples have no durable external persistence
 - No multi-worker or cross-process guarantees
 - No Redis, DB, or external storage for checkpoints
 - No Filters or Pipelines
diff --git a/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py b/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
index f0af75b..cb8b43c 100644
--- a/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
+++ b/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
@@ -15,8 +15,9 @@
    calling `engine.step(...)`
 
 Core decision handling remains the same as the base integration.
-Failed transitions are rejected for the current request and do not leave
-resumable in-memory engine state behind.
+Pending approvals are carried in the Open WebUI conversation transcript so
+they survive the transition between requests without relying on pipe object
+lifetime.
 """
 
 import inspect
@@ -56,7 +57,7 @@ def Field(*, default: Any, description: str = "") -> Any:  # type: ignore[no-red
     Engine,
     PolicyValue,
 )
-from context_compiler.grammar import CanonicalDirective
+from context_compiler.grammar import CanonicalDirective, decompose_directive
 from context_compiler_directive_drafter import (
     DirectiveDrafter,
     DraftResult,
@@ -68,8 +69,9 @@ def Field(*, default: Any, description: str = "") -> Any:  # type: ignore[no-red
 logger = logging.getLogger(__name__)
 
 _CC_MARKER = "[[cc_state]]"
+_PENDING_MARKER_PREFIX = "<!-- cc_pending_directive:"
+_PENDING_MARKER_SUFFIX = " -->"
 _ENGINES_BY_CHAT_KEY: dict[str, Engine] = {}
-_PENDING_PROPOSALS_BY_CHAT_KEY: dict[str, str] = {}
 
 
 class _EngineSnapshot(TypedDict):
@@ -85,8 +87,16 @@ def _is_explicit_rejection(message: str) -> bool:
     return message.strip().lower() in {"n", "no"}
 
 
-def _render_proposal_prompt(directive_text: str) -> str:
-    return f"This is what I think the directive is:\n{directive_text}\nApply it? (y/n)"
+def _render_proposal_prompt(directive: CanonicalDirective, chat_key: str) -> str:
+    marker = json.dumps(
+        {"chat_key": chat_key, "directive": directive.text},
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+    return (
+        f"This is what I think the directive is:\n{directive.text}\nApply it? (y/n)\n"
+        f"{_PENDING_MARKER_PREFIX}{marker}{_PENDING_MARKER_SUFFIX}"
+    )
 
 
 def _resolve_chat_key(
@@ -115,6 +125,49 @@ def _extract_latest_user_text(messages: list[dict[str, Any]]) -> str | None:
     return None
 
 
+def _extract_pending_directive(
+    messages: list[dict[str, Any]], chat_key: str
+) -> CanonicalDirective | None:
+    """Restore the latest unresolved approval from Open WebUI chat history."""
+    for index in range(len(messages) - 1, -1, -1):
+        message = messages[index]
+        if message.get("role") != "assistant":
+            continue
+        content = message.get("content")
+        if not isinstance(content, str):
+            continue
+        marker_start = content.rfind(_PENDING_MARKER_PREFIX)
+        if marker_start < 0:
+            continue
+        marker_end = content.find(_PENDING_MARKER_SUFFIX, marker_start)
+        if marker_end < 0:
+            continue
+        # A later assistant response means this marker was already resolved.
+        if any(item.get("role") == "assistant" for item in messages[index + 1 :]):
+            continue
+        payload_text = content[marker_start + len(_PENDING_MARKER_PREFIX) : marker_end]
+        try:
+            payload = json.loads(payload_text)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(payload, dict) or payload.get("chat_key") != chat_key:
+            continue
+        directive_text = payload.get("directive")
+        if not isinstance(directive_text, str):
+            continue
+        directive = decompose_directive(directive_text)
+        if isinstance(directive, CanonicalDirective):
+            return directive
+    return None
+
+
+def _strip_pending_marker_from_text(content: str) -> str:
+    pattern = (
+        re.escape(_PENDING_MARKER_PREFIX) + r".*?" + re.escape(_PENDING_MARKER_SUFFIX)
+    )
+    return re.sub(pattern, "", content, flags=re.DOTALL).rstrip()
+
+
 def _snapshot_engine_state(engine: Engine) -> _EngineSnapshot:
     return {"premise": engine.premise, "policies": dict(engine.policies)}
 
@@ -278,7 +331,9 @@ def _strip_trace_blocks_from_messages(
         msg = dict(message)
         content = msg.get("content")
         if isinstance(content, str):
-            msg["content"] = _strip_trace_block_from_text(content)
+            msg["content"] = _strip_pending_marker_from_text(
+                _strip_trace_block_from_text(content)
+            )
         cleaned.append(msg)
     return cleaned
 
@@ -822,15 +877,14 @@ async def pipe(
         if latest_user_text.strip().lower() == "show state":
             return _render_show_state_summary(engine)
 
-        pending_proposal = _PENDING_PROPOSALS_BY_CHAT_KEY.get(chat_key)
-        if pending_proposal is not None:
+        pending_directive = _extract_pending_directive(messages, chat_key)
+        if pending_directive is not None:
             if _is_explicit_approval(latest_user_text):
-                del _PENDING_PROPOSALS_BY_CHAT_KEY[chat_key]
                 state_before = _snapshot_engine_state(engine)
                 engine_snapshot_json = engine.export_json()
-                compile_input = pending_proposal
+                compile_input = pending_directive.text
                 logger.debug("preprocessor: approved_pending_input=%r", compile_input)
-                decision = engine.step(compile_input)
+                decision = engine.apply_directive(pending_directive)
                 if decision.kind == DecisionKind.ERROR:
                     kind = DecisionKind.ERROR.value
                 elif decision.kind == DecisionKind.UPDATE:
@@ -912,9 +966,7 @@ async def pipe(
                     state_injected=state_injected,
                 )
             if _is_explicit_rejection(latest_user_text):
-                del _PENDING_PROPOSALS_BY_CHAT_KEY[chat_key]
                 return "Directive discarded. No state change was applied."
-            del _PENDING_PROPOSALS_BY_CHAT_KEY[chat_key]
 
         state_before = _snapshot_engine_state(engine)
         preprocess_error: str | None = None
@@ -953,5 +1005,4 @@ async def pipe(
             )
 
         compile_input = drafted_result.result.text
-        _PENDING_PROPOSALS_BY_CHAT_KEY[chat_key] = compile_input
-        return _render_proposal_prompt(compile_input)
+        return _render_proposal_prompt(drafted_result.result, chat_key)
diff --git a/python/tests/test_openwebui_pipe_with_directive_drafter.py b/python/tests/test_openwebui_pipe_with_directive_drafter.py
index b4d315b..626a6da 100644
--- a/python/tests/test_openwebui_pipe_with_directive_drafter.py
+++ b/python/tests/test_openwebui_pipe_with_directive_drafter.py
@@ -89,7 +89,6 @@ def _guarded_import(
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)
     module._ENGINES_BY_CHAT_KEY.clear()
-    module._PENDING_PROPOSALS_BY_CHAT_KEY.clear()
     return module
 
 
@@ -137,9 +136,10 @@ async def fake_draft(*args, **kwargs):
         )
     )
 
-    assert result == (
+    assert result.startswith(
         "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
     )
+    assert "<!-- cc_pending_directive:" in result
     assert show_state == "Premise: none\nUse: none\nProhibit: none"
 
 
@@ -150,13 +150,13 @@ def test_approval_applies_stored_directive(monkeypatch) -> None:
 
     def Engine_with_tracking():
         engine = real_Engine()
-        original_step = engine.step
+        original_apply_directive = engine.apply_directive
 
-        def tracked_step(user_input: str):
-            compile_inputs.append(user_input)
-            return original_step(user_input)
+        def tracked_apply_directive(directive):
+            compile_inputs.append(directive.text)
+            return original_apply_directive(directive)
 
-        engine.step = tracked_step
+        engine.apply_directive = tracked_apply_directive
         return engine
 
     monkeypatch.setattr(module, "Engine", Engine_with_tracking)
@@ -187,7 +187,13 @@ async def update_draft(*args, **kwargs):
     )
     follow_up = asyncio.run(
         pipe.pipe(
-            {"model": "pipe-model", "messages": [{"role": "user", "content": "y"}]},
+            {
+                "model": "pipe-model",
+                "messages": [
+                    {"role": "assistant", "content": seed},
+                    {"role": "user", "content": "y"},
+                ],
+            },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-failed-transition",
@@ -205,7 +211,7 @@ async def update_draft(*args, **kwargs):
         )
     )
 
-    assert seed == (
+    assert seed.startswith(
         "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
     )
     assert follow_up == "State updated."
@@ -225,6 +231,70 @@ async def update_draft(*args, **kwargs):
     assert compile_inputs == ["use docker"]
 
 
+def test_pending_approval_survives_pipe_object_lifetime(monkeypatch) -> None:
+    module = _load_module("owui_with_drafter_pending_lifecycle", monkeypatch)
+
+    async def update_draft(*args, **kwargs):
+        return DraftResult(
+            source="test",
+            result=CanonicalDirective(
+                kind=DirectiveKind.USE_ITEM,
+                operands=MappingProxyType({"item": "docker"}),
+            ),
+        )
+
+    monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
+    first_pipe = module.Pipe()
+    first_pipe.valves.BASE_MODEL_ID = "base-model"
+    first_pipe.valves.PREPROCESSOR_MODEL_ID = "prep-model"
+    chat_id = "chat-pending-lifecycle"
+    proposal = asyncio.run(
+        first_pipe.pipe(
+            {
+                "model": "pipe-model",
+                "messages": [{"role": "user", "content": "please use docker"}],
+            },
+            __user__={"id": "u1"},
+            __request__=object(),
+            __chat_id__=chat_id,
+        )
+    )
+
+    # Simulate Open WebUI reloading/replacing the pipe object between requests.
+    module._ENGINES_BY_CHAT_KEY.clear()
+    second_pipe = module.Pipe()
+    second_pipe.valves.BASE_MODEL_ID = "base-model"
+    second_pipe.valves.PREPROCESSOR_MODEL_ID = "prep-model"
+    approved = asyncio.run(
+        second_pipe.pipe(
+            {
+                "model": "pipe-model",
+                "messages": [
+                    {"role": "assistant", "content": proposal},
+                    {"role": "user", "content": "y"},
+                ],
+            },
+            __user__={"id": "u1"},
+            __request__=object(),
+            __chat_id__=chat_id,
+        )
+    )
+
+    assert approved == "State updated."
+    state = asyncio.run(
+        second_pipe.pipe(
+            {
+                "model": "pipe-model",
+                "messages": [{"role": "user", "content": "show state"}],
+            },
+            __user__={"id": "u1"},
+            __request__=object(),
+            __chat_id__=chat_id,
+        )
+    )
+    assert state == "Premise: none\nUse: docker\nProhibit: none"
+
+
 def test_rejection_does_not_mutate_state(monkeypatch) -> None:
     module = _load_module(
         "owui_with_drafter_failed_transition_state_preserved", monkeypatch
@@ -243,7 +313,7 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
-    asyncio.run(
+    proposal = asyncio.run(
         pipe.pipe(
             {
                 "model": "pipe-model",
@@ -256,7 +326,13 @@ async def update_draft(*args, **kwargs):
     )
     rejected = asyncio.run(
         pipe.pipe(
-            {"model": "pipe-model", "messages": [{"role": "user", "content": "n"}]},
+            {
+                "model": "pipe-model",
+                "messages": [
+                    {"role": "assistant", "content": proposal},
+                    {"role": "user", "content": "n"},
+                ],
+            },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-state-preserved",
@@ -393,14 +469,20 @@ async def no_draft(*args, **kwargs):
     monkeypatch.setattr(module.Pipe, "_draft_user_input", no_draft)
     follow_up = asyncio.run(
         pipe.pipe(
-            {"model": "pipe-model", "messages": [{"role": "user", "content": "hello"}]},
+            {
+                "model": "pipe-model",
+                "messages": [
+                    {"role": "assistant", "content": proposal},
+                    {"role": "user", "content": "hello"},
+                ],
+            },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-pending-unrelated-followup",
         )
     )
 
-    assert proposal == (
+    assert proposal.startswith(
         "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
     )
     assert follow_up == {"choices": [{"message": {"content": "downstream"}}]}
@@ -455,7 +537,7 @@ async def no_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
-    asyncio.run(
+    proposal = asyncio.run(
         pipe.pipe(
             {
                 "model": "pipe-model",
@@ -468,9 +550,15 @@ async def no_draft(*args, **kwargs):
     )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", no_draft)
-    asyncio.run(
+    follow_up = asyncio.run(
         pipe.pipe(
-            {"model": "pipe-model", "messages": [{"role": "user", "content": "hello"}]},
+            {
+                "model": "pipe-model",
+                "messages": [
+                    {"role": "assistant", "content": proposal},
+                    {"role": "user", "content": "hello"},
+                ],
+            },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-no-stale-pending",
@@ -478,7 +566,18 @@ async def no_draft(*args, **kwargs):
     )
     later_yes = asyncio.run(
         pipe.pipe(
-            {"model": "pipe-model", "messages": [{"role": "user", "content": "yes"}]},
+            {
+                "model": "pipe-model",
+                "messages": [
+                    {"role": "assistant", "content": proposal},
+                    {"role": "user", "content": "hello"},
+                    {
+                        "role": "assistant",
+                        "content": follow_up["choices"][0]["message"]["content"],
+                    },
+                    {"role": "user", "content": "yes"},
+                ],
+            },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-no-stale-pending",
@@ -587,7 +686,7 @@ async def no_draft(*args, **kwargs):
         )
     )
 
-    assert proposal == (
+    assert proposal.startswith(
         "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
     )
     assert passthrough == {"choices": [{"message": {"content": "downstream"}}]}
@@ -730,7 +829,7 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
-    asyncio.run(
+    proposal = asyncio.run(
         pipe.pipe(
             {
                 "model": "pipe-model",
@@ -743,7 +842,13 @@ async def update_draft(*args, **kwargs):
     )
     asyncio.run(
         pipe.pipe(
-            {"model": "pipe-model", "messages": [{"role": "user", "content": "y"}]},
+            {
+                "model": "pipe-model",
+                "messages": [
+                    {"role": "assistant", "content": proposal},
+                    {"role": "user", "content": "y"},
+                ],
+            },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__=chat_id,

From 8fe0609d1d11644ea82280fb0a454735184aaea2 Mon Sep 17 00:00:00 2001
From: Robert Lippmann <robert.lippmann.development@gmail.com>
Date: Wed, 19 Aug 2026 02:52:56 -0400
Subject: [PATCH 3/4] feat: use native OpenWebUI confirmation for HITL

---
 .../openwebui_pipe/README.md                  |  13 +-
 .../open_webui_pipe_with_directive_drafter.py | 275 +++++++-----------
 ...t_openwebui_pipe_with_directive_drafter.py | 208 +++++++------
 3 files changed, 243 insertions(+), 253 deletions(-)

diff --git a/python/reference_integrations/openwebui_pipe/README.md b/python/reference_integrations/openwebui_pipe/README.md
index f0db733..a2910f8 100644
--- a/python/reference_integrations/openwebui_pipe/README.md
+++ b/python/reference_integrations/openwebui_pipe/README.md
@@ -140,8 +140,8 @@ Suggested verification:
 - Send `please use docker` and confirm either:
   - the Directive Drafter converts it into a local state update, or
   - trace shows the turn followed the normal compiler path without a silent state change
-- When a canonical directive is drafted, keep the approval response in the conversation and send `y`; confirm the next request returns `State updated.` and `show state` reports `Use: docker`.
-- Repeat the draft flow with `n`; confirm the pipe returns `Directive discarded. No state change was applied.` and `show state` remains unchanged.
+- When a canonical directive is drafted, confirm the native Open WebUI approval dialog; accepting it returns `State updated.` and `show state` reports `Use: docker`.
+- Repeat the draft flow and reject it in the native confirmation dialog; confirm the pipe returns `Directive discarded. No state change was applied.` and `show state` remains unchanged.
 - Send `please use docker`, then `prohibit docker`, and confirm the second request is rejected without creating resumable state
 - Send `use docker and prohibit peanuts` and confirm the pipe responds locally that multiple directives are not supported and must be submitted separately
 - Send a normal prompt such as `what should I run?` and confirm trace shows a forwarded turn with compiler state included
@@ -150,26 +150,27 @@ Advanced check:
 
 - If you have a local proxy or stub, inspect the forwarded request and confirm it contains exactly one `[[cc_state]]` system message reflecting the active state.
 - Confirm that saved premise appears as `Premise: ...` and saved policy appears as `Use: ...` or `Prohibit: ...`.
-- Confirm that the approval response remains in the Open WebUI message history between the draft and the `y`/`n` request. The pipe stores the pending canonical directive in a host-visible conversation marker, restores it as a `CanonicalDirective`, and strips the marker before downstream model calls.
+- Confirm that the approval prompt is a native Open WebUI confirmation dialog and that no approval marker or pending directive is added to the conversation transcript.
 
 ### Optional extra checks
 
 If you want a slightly broader manual pass:
 
 - verify chat isolation with separate real chat ids
-- verify a pending approval survives chat continuation, including pipe object replacement, while the conversation transcript is retained
-- verify this does not imply that authoritative state survives a server restart; engine state is lost after restart because these examples do not use external persistence
+- verify the native confirmation flow does not depend on pipe object lifetime
+- verify authoritative engine state is lost after restart because these examples do not use external persistence
 - verify non-text input is bypassed
 
 ### Notes
 
 - Trace is the easiest way to verify behavior from the Open WebUI chat output.
+- Native approval requires an active Open WebUI browser session because `__event_call__` waits for the confirmation response during the current request.
 - Forwarded-request inspection is optional and most useful when you already have a local proxy or stub.
 - Exact `show state` is a local-state check and does not rely on trace output.
 
 ## Limits
 
-- Pending approval survives chat continuation only when Open WebUI resends the prior assistant message in the conversation transcript
+- Approval state is held only for the active native confirmation call; no pending approval state is stored in chat content
 - Authoritative state does not survive a server restart; it remains in-memory because these examples have no durable external persistence
 - No multi-worker or cross-process guarantees
 - No Redis, DB, or external storage for checkpoints
diff --git a/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py b/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
index cb8b43c..42c89eb 100644
--- a/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
+++ b/python/reference_integrations/openwebui_pipe/open_webui_pipe_with_directive_drafter.py
@@ -15,9 +15,8 @@
    calling `engine.step(...)`
 
 Core decision handling remains the same as the base integration.
-Pending approvals are carried in the Open WebUI conversation transcript so
-they survive the transition between requests without relying on pipe object
-lifetime.
+Pending approvals use Open WebUI's native confirmation event and do not add
+state to the conversation transcript.
 """
 
 import inspect
@@ -51,13 +50,12 @@ def Field(*, default: Any, description: str = "") -> Any:  # type: ignore[no-red
 from context_compiler import (
     Decision,
     DecisionKind,
-    DECISION_UPDATE,
     POLICY_PROHIBIT,
     POLICY_USE,
     Engine,
     PolicyValue,
 )
-from context_compiler.grammar import CanonicalDirective, decompose_directive
+from context_compiler.grammar import CanonicalDirective
 from context_compiler_directive_drafter import (
     DirectiveDrafter,
     DraftResult,
@@ -69,8 +67,6 @@ def Field(*, default: Any, description: str = "") -> Any:  # type: ignore[no-red
 logger = logging.getLogger(__name__)
 
 _CC_MARKER = "[[cc_state]]"
-_PENDING_MARKER_PREFIX = "<!-- cc_pending_directive:"
-_PENDING_MARKER_SUFFIX = " -->"
 _ENGINES_BY_CHAT_KEY: dict[str, Engine] = {}
 
 
@@ -79,24 +75,16 @@ class _EngineSnapshot(TypedDict):
     policies: dict[str, PolicyValue]
 
 
-def _is_explicit_approval(message: str) -> bool:
-    return message.strip().lower() in {"y", "yes"}
-
-
-def _is_explicit_rejection(message: str) -> bool:
-    return message.strip().lower() in {"n", "no"}
-
-
-def _render_proposal_prompt(directive: CanonicalDirective, chat_key: str) -> str:
-    marker = json.dumps(
-        {"chat_key": chat_key, "directive": directive.text},
-        sort_keys=True,
-        separators=(",", ":"),
-    )
-    return (
-        f"This is what I think the directive is:\n{directive.text}\nApply it? (y/n)\n"
-        f"{_PENDING_MARKER_PREFIX}{marker}{_PENDING_MARKER_SUFFIX}"
-    )
+def _confirmation_was_accepted(response: object) -> bool:
+    if isinstance(response, bool):
+        return response
+    if isinstance(response, dict):
+        for key in ("confirmed", "approved", "value"):
+            if key in response:
+                return _confirmation_was_accepted(response[key])
+    if isinstance(response, str):
+        return response.strip().lower() in {"y", "yes", "true", "1", "ok"}
+    return False
 
 
 def _resolve_chat_key(
@@ -125,49 +113,6 @@ def _extract_latest_user_text(messages: list[dict[str, Any]]) -> str | None:
     return None
 
 
-def _extract_pending_directive(
-    messages: list[dict[str, Any]], chat_key: str
-) -> CanonicalDirective | None:
-    """Restore the latest unresolved approval from Open WebUI chat history."""
-    for index in range(len(messages) - 1, -1, -1):
-        message = messages[index]
-        if message.get("role") != "assistant":
-            continue
-        content = message.get("content")
-        if not isinstance(content, str):
-            continue
-        marker_start = content.rfind(_PENDING_MARKER_PREFIX)
-        if marker_start < 0:
-            continue
-        marker_end = content.find(_PENDING_MARKER_SUFFIX, marker_start)
-        if marker_end < 0:
-            continue
-        # A later assistant response means this marker was already resolved.
-        if any(item.get("role") == "assistant" for item in messages[index + 1 :]):
-            continue
-        payload_text = content[marker_start + len(_PENDING_MARKER_PREFIX) : marker_end]
-        try:
-            payload = json.loads(payload_text)
-        except json.JSONDecodeError:
-            continue
-        if not isinstance(payload, dict) or payload.get("chat_key") != chat_key:
-            continue
-        directive_text = payload.get("directive")
-        if not isinstance(directive_text, str):
-            continue
-        directive = decompose_directive(directive_text)
-        if isinstance(directive, CanonicalDirective):
-            return directive
-    return None
-
-
-def _strip_pending_marker_from_text(content: str) -> str:
-    pattern = (
-        re.escape(_PENDING_MARKER_PREFIX) + r".*?" + re.escape(_PENDING_MARKER_SUFFIX)
-    )
-    return re.sub(pattern, "", content, flags=re.DOTALL).rstrip()
-
-
 def _snapshot_engine_state(engine: Engine) -> _EngineSnapshot:
     return {"premise": engine.premise, "policies": dict(engine.policies)}
 
@@ -331,9 +276,7 @@ def _strip_trace_blocks_from_messages(
         msg = dict(message)
         content = msg.get("content")
         if isinstance(content, str):
-            msg["content"] = _strip_pending_marker_from_text(
-                _strip_trace_block_from_text(content)
-            )
+            msg["content"] = _strip_trace_block_from_text(content)
         cleaned.append(msg)
     return cleaned
 
@@ -804,6 +747,71 @@ async def _forward_passthrough(
             return normalized_error
         return response
 
+    async def _apply_approved_directive(
+        self,
+        directive: CanonicalDirective,
+        *,
+        body: dict[str, Any],
+        user_payload: dict[str, Any],
+        request: Request,
+        base_model_id: str | None,
+        chat_key: str,
+        original_input: str,
+        engine: Engine,
+    ) -> Any:
+        state_before = _snapshot_engine_state(engine)
+        engine_snapshot_json = engine.export_json()
+        compile_input = directive.text
+        logger.debug("preprocessor: approved_input=%r", compile_input)
+        decision = engine.apply_directive(directive)
+        state_after = _snapshot_engine_state(engine)
+
+        if decision.kind == DecisionKind.ERROR:
+            _ENGINES_BY_CHAT_KEY[chat_key] = _restore_engine_from_snapshot(
+                engine_snapshot_json
+            )
+            return self._with_trace(
+                decision.message,
+                original_input=original_input,
+                compiler_input=compile_input,
+                decision=decision,
+                state_before=state_before,
+                state_after=state_after,
+                preprocessor_output=compile_input,
+                llm_called=False,
+            )
+        if decision.kind == DecisionKind.UPDATE:
+            return self._with_trace(
+                "State updated.",
+                original_input=original_input,
+                compiler_input=compile_input,
+                decision=decision,
+                state_before=state_before,
+                state_after=state_after,
+                preprocessor_output=compile_input,
+                llm_called=False,
+            )
+
+        state_injected = "yes" if _has_non_empty_authoritative_state(engine) else "no"
+        response = await self._forward_passthrough(
+            body,
+            user_payload,
+            request,
+            base_model_id=base_model_id,
+            engine=engine,
+        )
+        return self._with_trace(
+            response,
+            original_input=original_input,
+            compiler_input=compile_input,
+            decision=decision,
+            state_before=state_before,
+            state_after=state_after,
+            preprocessor_output=compile_input,
+            llm_called=base_model_id is not None,
+            state_injected=state_injected,
+        )
+
     async def pipe(
         self,
         body: dict[str, Any],
@@ -811,6 +819,7 @@ async def pipe(
         __request__: Request,
         __chat_id__: str | None = None,
         __metadata__: dict[str, Any] | None = None,
+        __event_call__: Any | None = None,
     ) -> Any:
         # Open WebUI integration entrypoint:
         # 1) extract latest user input
@@ -877,97 +886,6 @@ async def pipe(
         if latest_user_text.strip().lower() == "show state":
             return _render_show_state_summary(engine)
 
-        pending_directive = _extract_pending_directive(messages, chat_key)
-        if pending_directive is not None:
-            if _is_explicit_approval(latest_user_text):
-                state_before = _snapshot_engine_state(engine)
-                engine_snapshot_json = engine.export_json()
-                compile_input = pending_directive.text
-                logger.debug("preprocessor: approved_pending_input=%r", compile_input)
-                decision = engine.apply_directive(pending_directive)
-                if decision.kind == DecisionKind.ERROR:
-                    kind = DecisionKind.ERROR.value
-                elif decision.kind == DecisionKind.UPDATE:
-                    kind = DECISION_UPDATE
-                else:
-                    kind = DecisionKind.NO_DIRECTIVE.value
-                logger.debug("preprocessor: decision=%s", kind)
-                state_after = _snapshot_engine_state(engine)
-
-                if decision.kind == DecisionKind.ERROR:
-                    _ENGINES_BY_CHAT_KEY[chat_key] = _restore_engine_from_snapshot(
-                        engine_snapshot_json
-                    )
-                    return self._with_trace(
-                        decision.message
-                        if decision.kind == DecisionKind.ERROR
-                        else None or "",
-                        original_input=latest_user_text,
-                        compiler_input=compile_input,
-                        decision=decision,
-                        state_before=state_before,
-                        state_after=state_after,
-                        preprocessor_output=compile_input,
-                        llm_called=False,
-                    )
-                if decision.kind == DecisionKind.NO_DIRECTIVE:
-                    state_injected = (
-                        "yes" if _has_non_empty_authoritative_state(engine) else "no"
-                    )
-                    response = await self._forward_passthrough(
-                        body,
-                        __user__,
-                        __request__,
-                        base_model_id=base_model_id,
-                        engine=engine,
-                    )
-                    return self._with_trace(
-                        response,
-                        original_input=latest_user_text,
-                        compiler_input=compile_input,
-                        decision=decision,
-                        state_before=state_before,
-                        state_after=state_after,
-                        preprocessor_output=compile_input,
-                        llm_called=base_model_id is not None,
-                        state_injected=state_injected,
-                    )
-                if decision.kind == DecisionKind.UPDATE:
-                    return self._with_trace(
-                        "State updated.",
-                        original_input=latest_user_text,
-                        compiler_input=compile_input,
-                        decision=decision,
-                        state_before=state_before,
-                        state_after=state_after,
-                        preprocessor_output=compile_input,
-                        llm_called=False,
-                    )
-
-                state_injected = (
-                    "yes" if _has_non_empty_authoritative_state(engine) else "no"
-                )
-                response = await self._forward_passthrough(
-                    body,
-                    __user__,
-                    __request__,
-                    base_model_id=base_model_id,
-                    engine=engine,
-                )
-                return self._with_trace(
-                    response,
-                    original_input=latest_user_text,
-                    compiler_input=compile_input,
-                    decision=decision,
-                    state_before=state_before,
-                    state_after=state_after,
-                    preprocessor_output=compile_input,
-                    llm_called=base_model_id is not None,
-                    state_injected=state_injected,
-                )
-            if _is_explicit_rejection(latest_user_text):
-                return "Directive discarded. No state change was applied."
-
         state_before = _snapshot_engine_state(engine)
         preprocess_error: str | None = None
         drafted_result, preprocess_error = await self._preprocess_user_input(
@@ -1004,5 +922,34 @@ async def pipe(
                 state_injected=state_injected,
             )
 
-        compile_input = drafted_result.result.text
-        return _render_proposal_prompt(drafted_result.result, chat_key)
+        if __event_call__ is None:
+            return (
+                "Context Compiler pipe misconfigured: Open WebUI confirmation support "
+                "(__event_call__) is required for Directive Drafter approvals."
+            )
+
+        approval_response = await __event_call__(
+            {
+                "type": "confirmation",
+                "data": {
+                    "title": "Approve directive",
+                    "message": (
+                        "This is what I think the directive is:\n"
+                        f"{drafted_result.result.text}\n\nApply it?"
+                    ),
+                },
+            }
+        )
+        if not _confirmation_was_accepted(approval_response):
+            return "Directive discarded. No state change was applied."
+
+        return await self._apply_approved_directive(
+            drafted_result.result,
+            body=body,
+            user_payload=__user__,
+            request=__request__,
+            base_model_id=base_model_id,
+            chat_key=chat_key,
+            original_input=latest_user_text,
+            engine=engine,
+        )
diff --git a/python/tests/test_openwebui_pipe_with_directive_drafter.py b/python/tests/test_openwebui_pipe_with_directive_drafter.py
index 626a6da..46671b3 100644
--- a/python/tests/test_openwebui_pipe_with_directive_drafter.py
+++ b/python/tests/test_openwebui_pipe_with_directive_drafter.py
@@ -92,7 +92,64 @@ def _guarded_import(
     return module
 
 
-def test_canonical_draft_creates_approval_prompt_and_does_not_mutate_state(
+def test_native_confirmation_applies_canonical_draft(monkeypatch) -> None:
+    module = _load_module("owui_with_drafter_native_confirmation", monkeypatch)
+
+    async def fake_draft(*args, **kwargs):
+        return DraftResult(
+            source="test",
+            result=CanonicalDirective(
+                kind=DirectiveKind.USE_ITEM,
+                operands=MappingProxyType({"item": "docker"}),
+            ),
+        )
+
+    confirmation_events: list[dict[str, object]] = []
+
+    async def confirm(event: dict[str, object]) -> bool:
+        confirmation_events.append(event)
+        return True
+
+    monkeypatch.setattr(module.Pipe, "_draft_user_input", fake_draft)
+    pipe = module.Pipe()
+    pipe.valves.BASE_MODEL_ID = "base-model"
+    pipe.valves.PREPROCESSOR_MODEL_ID = "prep-model"
+    chat_id = "chat-native-confirmation"
+
+    result = asyncio.run(
+        pipe.pipe(
+            {
+                "model": "pipe-model",
+                "messages": [{"role": "user", "content": "please use docker"}],
+            },
+            __user__={"id": "u1"},
+            __request__=object(),
+            __chat_id__=chat_id,
+            __event_call__=confirm,
+        )
+    )
+
+    assert result == "State updated."
+    assert len(confirmation_events) == 1
+    assert confirmation_events[0]["type"] == "confirmation"
+    assert "use docker" in str(confirmation_events[0])
+    assert "cc_pending_directive" not in str(confirmation_events[0])
+
+    show_state = asyncio.run(
+        pipe.pipe(
+            {
+                "model": "pipe-model",
+                "messages": [{"role": "user", "content": "show state"}],
+            },
+            __user__={"id": "u1"},
+            __request__=object(),
+            __chat_id__=chat_id,
+        )
+    )
+    assert show_state == "Premise: none\nUse: docker\nProhibit: none"
+
+
+def test_confirmation_dialog_does_not_write_marker_to_output(
     monkeypatch,
 ) -> None:
     module = _load_module("owui_with_drafter_before_step", monkeypatch)
@@ -113,6 +170,9 @@ async def fake_draft(*args, **kwargs):
     pipe.valves.PREPROCESSOR_MODEL_ID = "prep-model"
     chat_id = "chat-before-step"
 
+    async def confirm(event: dict[str, object]) -> bool:
+        return False
+
     result = asyncio.run(
         pipe.pipe(
             {
@@ -122,6 +182,7 @@ async def fake_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__=chat_id,
+            __event_call__=confirm,
         )
     )
     show_state = asyncio.run(
@@ -136,14 +197,12 @@ async def fake_draft(*args, **kwargs):
         )
     )
 
-    assert result.startswith(
-        "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
-    )
-    assert "<!-- cc_pending_directive:" in result
+    assert result == "Directive discarded. No state change was applied."
+    assert "cc_pending_directive" not in result
     assert show_state == "Premise: none\nUse: none\nProhibit: none"
 
 
-def test_approval_applies_stored_directive(monkeypatch) -> None:
+def test_approval_applies_directive_through_engine_path(monkeypatch) -> None:
     module = _load_module("owui_with_drafter_failed_transition_followup", monkeypatch)
     compile_inputs: list[str] = []
     real_Engine = module.Engine
@@ -174,7 +233,11 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
-    seed = asyncio.run(
+
+    async def confirm(event: dict[str, object]) -> bool:
+        return True
+
+    result = asyncio.run(
         pipe.pipe(
             {
                 "model": "pipe-model",
@@ -183,20 +246,7 @@ async def update_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-failed-transition",
-        )
-    )
-    follow_up = asyncio.run(
-        pipe.pipe(
-            {
-                "model": "pipe-model",
-                "messages": [
-                    {"role": "assistant", "content": seed},
-                    {"role": "user", "content": "y"},
-                ],
-            },
-            __user__={"id": "u1"},
-            __request__=object(),
-            __chat_id__="chat-failed-transition",
+            __event_call__=confirm,
         )
     )
     show_state = asyncio.run(
@@ -211,27 +261,14 @@ async def update_draft(*args, **kwargs):
         )
     )
 
-    assert seed.startswith(
-        "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
-    )
-    assert follow_up == "State updated."
+    assert result == "State updated."
     assert show_state == "Premise: none\nUse: docker\nProhibit: none"
     assert compile_inputs == ["use docker"]
 
-    second_follow_up = asyncio.run(
-        pipe.pipe(
-            {"model": "pipe-model", "messages": [{"role": "user", "content": "yes"}]},
-            __user__={"id": "u1"},
-            __request__=object(),
-            __chat_id__="chat-failed-transition",
-        )
-    )
-
-    assert second_follow_up != "State updated."
     assert compile_inputs == ["use docker"]
 
 
-def test_pending_approval_survives_pipe_object_lifetime(monkeypatch) -> None:
+def test_confirmation_flow_does_not_depend_on_pipe_object_lifetime(monkeypatch) -> None:
     module = _load_module("owui_with_drafter_pending_lifecycle", monkeypatch)
 
     async def update_draft(*args, **kwargs):
@@ -244,11 +281,15 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
+
+    async def confirm(event: dict[str, object]) -> bool:
+        return True
+
     first_pipe = module.Pipe()
     first_pipe.valves.BASE_MODEL_ID = "base-model"
     first_pipe.valves.PREPROCESSOR_MODEL_ID = "prep-model"
     chat_id = "chat-pending-lifecycle"
-    proposal = asyncio.run(
+    first_result = asyncio.run(
         first_pipe.pipe(
             {
                 "model": "pipe-model",
@@ -257,30 +298,30 @@ async def update_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__=chat_id,
+            __event_call__=confirm,
         )
     )
 
-    # Simulate Open WebUI reloading/replacing the pipe object between requests.
+    # Simulate Open WebUI replacing the pipe object between independent requests.
     module._ENGINES_BY_CHAT_KEY.clear()
     second_pipe = module.Pipe()
     second_pipe.valves.BASE_MODEL_ID = "base-model"
     second_pipe.valves.PREPROCESSOR_MODEL_ID = "prep-model"
-    approved = asyncio.run(
+    second_result = asyncio.run(
         second_pipe.pipe(
             {
                 "model": "pipe-model",
-                "messages": [
-                    {"role": "assistant", "content": proposal},
-                    {"role": "user", "content": "y"},
-                ],
+                "messages": [{"role": "user", "content": "please use docker"}],
             },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__=chat_id,
+            __event_call__=confirm,
         )
     )
 
-    assert approved == "State updated."
+    assert first_result == "State updated."
+    assert second_result == "State updated."
     state = asyncio.run(
         second_pipe.pipe(
             {
@@ -313,29 +354,20 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
-    proposal = asyncio.run(
-        pipe.pipe(
-            {
-                "model": "pipe-model",
-                "messages": [{"role": "user", "content": "please use docker"}],
-            },
-            __user__={"id": "u1"},
-            __request__=object(),
-            __chat_id__="chat-state-preserved",
-        )
-    )
+
+    async def reject(event: dict[str, object]) -> bool:
+        return False
+
     rejected = asyncio.run(
         pipe.pipe(
             {
                 "model": "pipe-model",
-                "messages": [
-                    {"role": "assistant", "content": proposal},
-                    {"role": "user", "content": "n"},
-                ],
+                "messages": [{"role": "user", "content": "please use docker"}],
             },
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-state-preserved",
+            __event_call__=reject,
         )
     )
 
@@ -366,7 +398,7 @@ async def update_draft(*args, **kwargs):
     assert after_rejection != "State updated."
 
 
-def test_pending_approval_does_not_affect_show_state(monkeypatch) -> None:
+def test_rejected_confirmation_does_not_affect_show_state(monkeypatch) -> None:
     module = _load_module("owui_with_drafter_pending_show_state", monkeypatch)
     pipe = module.Pipe()
     pipe.valves.BASE_MODEL_ID = "base-model"
@@ -382,7 +414,11 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
-    asyncio.run(
+
+    async def reject(event: dict[str, object]) -> bool:
+        return False
+
+    result = asyncio.run(
         pipe.pipe(
             {
                 "model": "pipe-model",
@@ -391,6 +427,7 @@ async def update_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-pending-show-state",
+            __event_call__=reject,
         )
     )
 
@@ -406,10 +443,12 @@ async def update_draft(*args, **kwargs):
         )
     )
 
+    assert result == "Directive discarded. No state change was applied."
+    assert "cc_pending_directive" not in result
     assert show_state == "Premise: none\nUse: none\nProhibit: none"
 
 
-def test_unrelated_follow_up_while_pending_does_not_apply_proposal(monkeypatch) -> None:
+def test_rejected_confirmation_does_not_apply_follow_up(monkeypatch) -> None:
     module = _load_module("owui_with_drafter_pending_unrelated_followup", monkeypatch)
     compile_inputs: list[str] = []
     forwarded: list[dict[str, object]] = []
@@ -454,6 +493,10 @@ async def no_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
+
+    async def reject(event: dict[str, object]) -> bool:
+        return False
+
     proposal = asyncio.run(
         pipe.pipe(
             {
@@ -463,6 +506,7 @@ async def no_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-pending-unrelated-followup",
+            __event_call__=reject,
         )
     )
 
@@ -482,15 +526,13 @@ async def no_draft(*args, **kwargs):
         )
     )
 
-    assert proposal.startswith(
-        "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
-    )
+    assert proposal == "Directive discarded. No state change was applied."
     assert follow_up == {"choices": [{"message": {"content": "downstream"}}]}
     assert compile_inputs == []
     assert len(forwarded) == 1
 
 
-def test_no_stale_pending_proposal_remains_after_non_approval_response(
+def test_rejected_confirmation_does_not_leave_state(
     monkeypatch,
 ) -> None:
     module = _load_module("owui_with_drafter_no_stale_pending", monkeypatch)
@@ -537,6 +579,10 @@ async def no_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
+
+    async def reject(event: dict[str, object]) -> bool:
+        return False
+
     proposal = asyncio.run(
         pipe.pipe(
             {
@@ -546,6 +592,7 @@ async def no_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-no-stale-pending",
+            __event_call__=reject,
         )
     )
 
@@ -653,6 +700,10 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
+
+    async def confirm(event: dict[str, object]) -> bool:
+        return True
+
     proposal = asyncio.run(
         pipe.pipe(
             {
@@ -662,6 +713,7 @@ async def update_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__="chat-update",
+            __event_call__=confirm,
         )
     )
 
@@ -686,9 +738,7 @@ async def no_draft(*args, **kwargs):
         )
     )
 
-    assert proposal.startswith(
-        "This is what I think the directive is:\nuse docker\nApply it? (y/n)"
-    )
+    assert proposal == "State updated."
     assert passthrough == {"choices": [{"message": {"content": "downstream"}}]}
     assert len(forwarded) == 1
 
@@ -829,6 +879,10 @@ async def update_draft(*args, **kwargs):
         )
 
     monkeypatch.setattr(module.Pipe, "_draft_user_input", update_draft)
+
+    async def confirm(event: dict[str, object]) -> bool:
+        return True
+
     proposal = asyncio.run(
         pipe.pipe(
             {
@@ -838,22 +892,10 @@ async def update_draft(*args, **kwargs):
             __user__={"id": "u1"},
             __request__=object(),
             __chat_id__=chat_id,
+            __event_call__=confirm,
         )
     )
-    asyncio.run(
-        pipe.pipe(
-            {
-                "model": "pipe-model",
-                "messages": [
-                    {"role": "assistant", "content": proposal},
-                    {"role": "user", "content": "y"},
-                ],
-            },
-            __user__={"id": "u1"},
-            __request__=object(),
-            __chat_id__=chat_id,
-        )
-    )
+    assert proposal == "State updated."
 
     async def no_draft(*args, **kwargs):
         return DraftResult(

From feb523a10180ad25f6c81a9d7144c9162856f821 Mon Sep 17 00:00:00 2001
From: Robert Lippmann <robert.lippmann.development@gmail.com>
Date: Wed, 19 Aug 2026 03:19:36 -0400
Subject: [PATCH 4/4] docs: update OpenWebUI compatibility documentation

---
 .../openwebui_pipe/README.md                  | 25 +++++++++++++------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/python/reference_integrations/openwebui_pipe/README.md b/python/reference_integrations/openwebui_pipe/README.md
index a2910f8..bef080c 100644
--- a/python/reference_integrations/openwebui_pipe/README.md
+++ b/python/reference_integrations/openwebui_pipe/README.md
@@ -40,7 +40,7 @@ shapes the downstream request.
 ## Files
 
 - `open_webui_pipe.py`: basic integration, no Directive Drafter layer (recommended/default).
-- `open_webui_pipe_with_directive_drafter.py`: optional/experimental Directive Drafter layer (heuristic check first, then optional model fallback) before `engine.step(...)`.
+- `open_webui_pipe_with_directive_drafter.py`: optional Directive Drafter layer (heuristic check first, then optional model fallback) before `engine.step(...)`.
 
 ## Setup
 
@@ -119,7 +119,7 @@ Use this pipe when you want the simplest Open WebUI integration path.
 
 Suggested verification:
 
-- Send `use docker` and confirm you get `State updated: Use docker.` with trace showing a local turn
+- Send `use docker` and confirm the native OpenWebUI confirmation dialog appears first; after approval, confirm `State updated: Use docker.` with trace showing a local turn
 - Send a normal prompt such as `what should I run?` and confirm trace shows a forwarded turn with compiler state included
 - Send `use docker`, then `prohibit docker`, and confirm Open WebUI rejects the second request instead of changing state
 - Optionally send `show state` and confirm the state summary is returned locally
@@ -133,6 +133,18 @@ Advanced check:
 
 Use this pipe when you want the same runtime behavior plus Directive Drafter preprocessing.
 
+When the drafter produces a `CanonicalDirective`, the pipe uses Open WebUI's
+native `__event_call__` confirmation dialog for HITL approval. The lifecycle is:
+
+1. Directive Drafter drafts a canonical directive.
+2. Open WebUI asks the user to confirm the drafted directive.
+3. An approved directive is applied through the Context Compiler `Engine` path.
+4. A rejected directive is discarded without changing authoritative state.
+
+The confirmation is request-scoped. It remains active while the current
+Open WebUI request waits for the user's response, but it is not durable pending
+state and does not survive an Open WebUI server restart.
+
 Suggested verification:
 
 - Send `use docker` and confirm you get `State updated: Use docker.` with trace showing a local turn
@@ -221,11 +233,10 @@ If you want a slightly broader manual pass:
 
 ## Compatibility
 
-Tested target: Open WebUI `v0.8.12`.
-Validated at runtime on stock Docker Open WebUI with a real backend model provider.
-
-Compatibility note: OpenWebUI `0.9.x` changed `Users.get_user_by_id` to async.
-These examples support both sync (`0.8.x`) and async (`0.9.x`) user lookup.
+Tested and validated at runtime on Open WebUI `v0.11.0` with a real Ollama
+backend model provider. Both the basic Pipe and Directive Drafter Pipe loaded
+and completed live requests, including native confirmation approval and
+rejection flows.
 
 ## Troubleshooting