cluxion-agentplugin-preprocessing 0.3.17__tar.gz → 0.3.18__tar.gz

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-preprocessing
-Version: 0.3.17
+Version: 0.3.18
 Summary: Universal agent plugin for Cluxion preprocessing, honesty contracts, clarification, Rust work queue, and resource-aware harness handoff.
 Project-URL: Homepage, https://github.com/cluxion/cluxion-Agentplugin-preprocessing
 Project-URL: Repository, https://github.com/cluxion/cluxion-Agentplugin-preprocessing

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-preprocessing"
-version = "0.3.17"
+version = "0.3.18"
 description = "Universal agent plugin for Cluxion preprocessing, honesty contracts, clarification, Rust work queue, and resource-aware harness handoff."
 readme = "README.md"
 requires-python = ">=3.11"

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_agentplugin_preprocessing/guard_watch.py

@@ -26,6 +26,12 @@ _last_watch_at: float | None = None
 _last_warning_at: float | None = None
 
 
+def on_session_end(**_: Any) -> None:
+    """Stop the guard daemon on clean session end so orphans do not linger."""
+    with contextlib.suppress(Exception):
+        guard_bridge.stop_daemon()
+
+
 def on_session_start(**_: Any) -> None:
     """Start the guard daemon unless ``CLUXION_GUARD_AUTOSTART=0`` or ``false``.
 
@@ -111,4 +117,4 @@ def _warn(message: str) -> None:
     print(message, file=sys.stderr)
 
 
-__all__ = ["on_session_start", "post_tool_call"]
+__all__ = ["on_session_end", "on_session_start", "post_tool_call"]

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_agentplugin_preprocessing/plugin.py

@@ -43,6 +43,7 @@ def register(ctx: object) -> None:
     register_hook = getattr(ctx, "register_hook", None)
     if callable(register_hook):
         register_hook("on_session_start", guard_watch.on_session_start)
+        register_hook("on_session_end", guard_watch.on_session_end)
         register_hook("post_tool_call", guard_watch.post_tool_call)
 
     register_mw = getattr(ctx, "register_middleware", None)

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_agentplugin_preprocessing/plugin.yaml

@@ -1,13 +1,22 @@
-name: hermes-cluxion
-version: 0.1.9
+name: cluxion-agentplugin-preprocessing
+version: 0.3.18
 description: "Universal agent preprocessing plugin: honesty contracts, clarification, Rust work queue, resource-aware harness handoff. Connected AI calls cluxion tools; plugin does not own models."
 author: cluxion
 kind: standalone
 provides_tools:
-  - cluxion_bootstrap
   - cluxion_plan
+  - cluxion_clarify
+  - cluxion_bootstrap
   - cluxion_serve_local
   - cluxion_hermes_config
   - cluxion_queue_next
   - cluxion_queue_record
   - cluxion_queue_brief
+  - cluxion_context_compress
+  - cluxion_guard
+  - cluxion_web_search
+  - cluxion_browser_open
+  - cluxion_browser_extract
+  - cluxion_browser_click
+  - cluxion_browser_type
+  - cluxion_doctor

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_agentplugin_preprocessing/runner.py

@@ -247,10 +247,23 @@ def _execute_json(command: Sequence[str], stdin: str | None, command_runner: Com
     except OSError as exc:
         return RuntimeResult(False, tuple(command), {"error": str(exc)})
     if completed.returncode != 0:
+        error = "cluxion-runtime failed"
+        stderr = completed.stderr.strip()
+        stdout = completed.stdout.strip()
+        for payload_text in (stderr, stdout):
+            if not payload_text:
+                continue
+            try:
+                parsed_err = json.loads(payload_text)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(parsed_err, dict) and parsed_err.get("error"):
+                error = str(parsed_err["error"])
+                break
         return RuntimeResult(
             False,
             tuple(command),
-            {"error": "cluxion-runtime failed", "stderr": completed.stderr.strip(), "returncode": completed.returncode},
+            {"error": error, "stderr": stderr, "returncode": completed.returncode},
         )
     try:
         parsed = json.loads(completed.stdout)

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_runtime/cli.py

@@ -206,11 +206,27 @@ def _run_context_compress(_: argparse.Namespace) -> int:
     return 0
 
 
+_VALID_GUARD_ACTIONS = frozenset({"status", "start", "stop", "enforce", "auto-enforce"})
+
+
+def _guard_action_error(action: str) -> str:
+    return (
+        f"unknown guard action: {action} "
+        "(expected: status|start|stop|enforce|auto-enforce)"
+    )
+
+
 def _run_guard(_: argparse.Namespace) -> int:
     from cluxion_runtime.resources import guard_bridge
 
     payload = _payload_from_stdin()
     action = str(payload.get("action", "status"))
+    if action not in _VALID_GUARD_ACTIONS:
+        print(
+            json.dumps({"ok": False, "error": _guard_action_error(action)}, ensure_ascii=False, sort_keys=True),
+            file=sys.stderr,
+        )
+        return 1
     try:
         if action == "start":
             result = guard_bridge.start_daemon(
@@ -256,9 +272,8 @@ def _run_guard(_: argparse.Namespace) -> int:
                 result["scan"] = guard_bridge.scan([int(pid) for pid in owned_roots])
         else:
             print(
-                json.dumps(
-                    {"ok": False, "error": f"unknown guard action: {action}"}, ensure_ascii=False, sort_keys=True
-                )
+                json.dumps({"ok": False, "error": _guard_action_error(action)}, ensure_ascii=False, sort_keys=True),
+                file=sys.stderr,
             )
             return 1
     except RuntimeError as exc:

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_runtime/core/llm_compress.py

@@ -35,13 +35,15 @@ _SUMMARY_INSTRUCTIONS = (
 
 _HARD_TOKEN_RE = re.compile(
     r"\b(?:"
-    r"\d+(?:\.\d+)?(?:k|m|만|억)?"
+    r"\d+(?:[._]\d+)+(?:k|m|만|억)?"
+    r"|\d+(?:\.\d+)?(?:k|m|만|억)?"
     r"|[A-Za-z][\w.-]*\d[\w.-]*"
     r"|\d[\w.-]+"
     r")\b",
     re.IGNORECASE,
 )
 _NUMERIC_SUFFIX_RE = re.compile(r"^(\d+(?:\.\d+)?)(k|m|만|억)?$", re.IGNORECASE)
+_MULTI_GROUP_NUMERIC_RE = re.compile(r"^\d+(?:[._]\d+)+$")
 _STRIP_LABEL_PREFIX_RE = re.compile(r"(?:\w+:\s*)+", re.IGNORECASE)
 _SUFFIX_MULTIPLIERS = {"k": 1000, "m": 1_000_000, "만": 10_000, "억": 100_000_000}
 
@@ -129,10 +131,25 @@ def _numeric_variants(token: str) -> set[str]:
     return variants
 
 
+def _bounded_numeric_in_source(norm_token: str, norm_source: str) -> bool:
+    """Match a dotted/underscored numeric token only as a complete identifier."""
+    pattern = rf"(?<![\d._]){re.escape(norm_token)}(?![\d._])"
+    return re.search(pattern, norm_source) is not None
+
+
 def _token_traceable_in_source(token: str, source: str) -> bool:
     norm_source = _normalize_for_match(source)
     norm_token = _normalize_for_match(token)
 
+    # Version/IP/port-like tokens must match atomically — never as a substring prefix
+    # of a longer value (e.g. 0.3.1 must not trace to source 0.3.17).
+    if _MULTI_GROUP_NUMERIC_RE.match(norm_token):
+        if _bounded_numeric_in_source(norm_token, norm_source):
+            return True
+        return any(
+            _bounded_numeric_in_source(variant, norm_source) for variant in _numeric_variants(token)
+        )
+
     if norm_token in norm_source:
         return True
 

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_runtime/guard_daemon_host.py

@@ -15,8 +15,9 @@ import psutil
 STATE_FILE_NAME = "guard_state.json"
 HEARTBEAT_FILE_NAME = "guard_heartbeat"
 PID_FILE_NAME = "guard_daemon.pid"
-DEFAULT_IDLE_TTL_MS = 600_000
+DEFAULT_IDLE_TTL_MS = 120_000
 PROC_SCAN_EVERY_N_TICKS = 5
+STATE_WRITE_EVERY_N_TICKS = 30
 _MAX_REPORTED_PIDS = 50
 _MIN_INTERVAL_MS = 100
 _MIN_WINDOW = 1
@@ -145,6 +146,35 @@ def _write_state_atomically(store_dir: Path, state: dict[str, Any]) -> None:
     os.replace(tmp_path, state_path)
 
 
+def _state_write_fingerprint(state: dict[str, Any]) -> str:
+    """Stable snapshot key excluding volatile timestamps."""
+    current = dict(state.get("current", {}))
+    current.pop("sampled_at_ms", None)
+    window = state.get("window")
+    payload = {
+        "current": current,
+        "window": window,
+        "interval_ms": state.get("interval_ms"),
+    }
+    return json.dumps(payload, separators=(",", ":"), sort_keys=True)
+
+
+def _write_state_if_changed(
+    store_dir: Path,
+    state: dict[str, Any],
+    *,
+    last_fingerprint: str | None,
+    tick: int,
+) -> str:
+    fingerprint = _state_write_fingerprint(state)
+    if (
+        fingerprint != last_fingerprint
+        or tick % STATE_WRITE_EVERY_N_TICKS == 0
+    ):
+        _write_state_atomically(store_dir, state)
+    return fingerprint
+
+
 def _idle_ttl_ms() -> int:
     raw = os.environ.get("CLUXION_GUARD_IDLE_TTL_MS")
     if raw is None:
@@ -192,10 +222,11 @@ def _daemon_loop_step(
     interval_ms: int,
     tick: int,
     idle_ttl_ms: int,
+    last_fingerprint: str | None = None,
     now_ms: int | None = None,
-) -> tuple[bool, ProcessScanCache]:
+) -> tuple[bool, ProcessScanCache, str]:
     if _check_idle_exit(base, idle_ttl_ms, now_ms=now_ms):
-        return False, process_cache
+        return False, process_cache, last_fingerprint or ""
     state, process_cache = _python_daemon_tick(
         process_cache,
         cpu_window,
@@ -204,8 +235,13 @@ def _daemon_loop_step(
         interval_ms,
         tick,
     )
-    _write_state_atomically(base, state)
-    return True, process_cache
+    fingerprint = _write_state_if_changed(
+        base,
+        state,
+        last_fingerprint=last_fingerprint,
+        tick=tick,
+    )
+    return True, process_cache, fingerprint
 
 
 def _run_python_daemon(store_dir: str, interval_ms: int, window: int) -> None:
@@ -219,9 +255,10 @@ def _run_python_daemon(store_dir: str, interval_ms: int, window: int) -> None:
     cpu_window: list[float] = []
     ram_window: list[int] = []
     tick = 0
+    last_fingerprint: str | None = None
 
     while True:
-        keep_running, process_cache = _daemon_loop_step(
+        keep_running, process_cache, last_fingerprint = _daemon_loop_step(
             base,
             process_cache=process_cache,
             cpu_window=cpu_window,
@@ -230,6 +267,7 @@ def _run_python_daemon(store_dir: str, interval_ms: int, window: int) -> None:
             interval_ms=interval_ms,
             tick=tick,
             idle_ttl_ms=idle_ttl_ms,
+            last_fingerprint=last_fingerprint,
         )
         if not keep_running:
             return

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/src/cluxion_runtime/resources/queue_bridge.py

@@ -114,15 +114,72 @@ def queue_status(*, store_dir: Path | None = None) -> dict[str, object]:
 
 def compress_context(payload: Mapping[str, object]) -> dict[str, object]:
     """Deterministic context compression — pure function, no store_dir involved."""
+    from cluxion_runtime.core import context_compress
+
     body = dict(payload)
     backend = resolve_backend()
+    if backend == "python":
+        return context_compress.compress(body)
     if backend == "native":
-        return _invoke_native("context-compress", body)
-    if backend == "subprocess":
-        return _invoke_subprocess("context-compress", body)
+        stage1 = _invoke_native("context-compress", body)
+    else:
+        stage1 = _invoke_subprocess("context-compress", body)
+    return _finalize_context_compress(body, stage1)
+
+
+def _context_trigger_ratio(payload: Mapping[str, object]) -> float:
+    from cluxion_runtime.core.context_compress import DEFAULT_TRIGGER_RATIO
+
+    value = payload.get("trigger_ratio")
+    if isinstance(value, (int, float)) and not isinstance(value, bool) and 0.0 < float(value) < 1.0:
+        return float(value)
+    return DEFAULT_TRIGGER_RATIO
+
+
+def _context_bool_flag(payload: Mapping[str, object], key: str, default: bool) -> bool:
+    value = payload.get(key)
+    if isinstance(value, bool):
+        return value
+    return default
+
+
+def _finalize_context_compress(body: Mapping[str, object], stage1: dict[str, object]) -> dict[str, object]:
+    """After Rust Stage-1, continue the Python pipeline when still above trigger."""
     from cluxion_runtime.core import context_compress
 
-    return context_compress.compress(body)
+    trigger_ratio = _context_trigger_ratio(body)
+    usage_after = float(stage1.get("usage_after", 0))
+    if usage_after <= trigger_ratio:
+        stage1["reached_target"] = True
+        return stage1
+
+    enable_llm = _context_bool_flag(body, "enable_llm_summary", True)
+    enable_forget = _context_bool_flag(body, "enable_forget", True)
+    if not enable_llm and not enable_forget:
+        stage1["reached_target"] = False
+        if stage1.get("ai_summary_request"):
+            stage1["requires_summary"] = True
+        return stage1
+
+    continued_body = dict(body)
+    messages = stage1.get("messages")
+    if isinstance(messages, list):
+        continued_body["messages"] = messages
+    continued = context_compress.compress(continued_body)
+    continued_usage = float(continued.get("usage_after", 1.0))
+    continued["reached_target"] = continued_usage <= trigger_ratio
+    if not continued["reached_target"] and continued.get("ai_summary_request"):
+        continued["requires_summary"] = True
+
+    stage1_stages = stage1.get("stages_applied")
+    continued_stages = continued.get("stages_applied")
+    if isinstance(stage1_stages, list) and isinstance(continued_stages, list):
+        merged = list(stage1_stages)
+        for stage in continued_stages:
+            if stage not in merged:
+                merged.append(stage)
+        continued["stages_applied"] = merged
+    return continued
 
 
 def _invoke(command: str, payload: Mapping[str, object], *, store_dir: Path | None) -> dict[str, object]:

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/tests/runtime/test_context_compress.py

@@ -121,7 +121,59 @@ def test_model_registry_resolution(backend) -> None:
 def test_backend_matches_python_reference(backend) -> None:
     reference = context_compress.compress(dict(_COMPRESSIBLE))
     result = queue_bridge.compress_context(_COMPRESSIBLE)
-    assert result == reference
+    if backend == "python":
+        assert result == reference
+    else:
+        # Stage-1 backends may add reached_target when continuing the pipeline.
+        result_compare = {k: v for k, v in result.items() if k not in {"reached_target", "requires_summary"}}
+        reference_compare = dict(reference)
+        assert result_compare == reference_compare
+
+
+def test_tool_path_continues_when_stage1_above_trigger(monkeypatch) -> None:
+    """Rust Stage-1-only output above trigger must continue into Python pipeline."""
+    messages = [
+        {"role": "user", "content": "task intent"},
+        {"role": "assistant", "content": _long(80_000)},
+        {"role": "tool", "content": _long(80_000)},
+        {"role": "user", "content": "recent question"},
+    ]
+    full_payload = {
+        "messages": messages,
+        "context_limit_tokens": 40_000,
+        "keep_recent_turns": 1,
+        "enable_llm_summary": False,
+        "enable_forget": True,
+    }
+    stage1 = {
+        "ok": True,
+        "compressed": True,
+        "tokens_before": 90_000,
+        "tokens_after": 34_000,
+        "usage_before": 2.25,
+        "usage_after": 0.85,
+        "context_limit": 40_000,
+        "stages_applied": ["truncate", "digest"],
+        "pinned_indices": [0, 3],
+        "messages": messages,
+        "ai_summary_request": {
+            "reason": "deterministic stages insufficient",
+            "current_tokens": 34_000,
+            "target_tokens": 12_000,
+            "summarize_indices": [1, 2],
+            "instructions": "summarize",
+        },
+    }
+    assert float(stage1["usage_after"]) > 0.70
+
+    monkeypatch.setenv(queue_bridge.QUEUE_BACKEND_ENV, "native")
+    monkeypatch.setattr(queue_bridge, "_invoke_native", lambda *a, **k: dict(stage1))
+    monkeypatch.setattr(context_compress, "hermes_available", lambda: False)
+
+    result = queue_bridge.compress_context(full_payload)
+    trigger = 0.70
+    assert result.get("reached_target") is True
+    assert float(result["usage_after"]) <= trigger
 
 
 def test_missing_messages_raises(backend) -> None:

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/tests/runtime/test_context_compress_llm_forget.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+import json
 import subprocess
 
+import pytest
+
 from cluxion_runtime.core import context_compress
 from cluxion_runtime.core.context_compress import _Msg
 from cluxion_runtime.core.hybrid_forget import _cold_demote, apply_hybrid_forget
@@ -270,6 +273,48 @@ def test_hallucination_guard_keeps_korean_normalized_number(monkeypatch) -> None
     assert "5433" in result[0]
 
 
+@pytest.mark.parametrize(
+    "fabricated",
+    ["0.3.7", "0.3.1", "3.17", "0.17", "0.31.7", "1.3.17"],
+)
+def test_hallucination_guard_strips_fabricated_version_parts(fabricated: str, monkeypatch) -> None:
+    from cluxion_runtime.core import llm_compress
+
+    source = "deployed version 0.3.17 of the package"
+    llm_json = json.dumps({"0": f"Package version {fabricated} deployed."})
+    monkeypatch.setattr(llm_compress, "hermes_available", lambda: True)
+    monkeypatch.setattr(llm_compress, "_call_hermes_oneshot", lambda *a, **k: llm_json)
+
+    result = llm_compress.summarize_messages([_msg(source)], [0])
+    assert result is not None
+    assert fabricated not in result[0]
+    assert "0.3.17" in result[0] or "version" in result[0].lower()
+
+
+def test_hallucination_guard_keeps_exact_version(monkeypatch) -> None:
+    from cluxion_runtime.core import llm_compress
+
+    source = "deployed version 0.3.17 of the package"
+    llm_json = '{"0": "Deployed version 0.3.17."}'
+    monkeypatch.setattr(llm_compress, "hermes_available", lambda: True)
+    monkeypatch.setattr(llm_compress, "_call_hermes_oneshot", lambda *a, **k: llm_json)
+
+    result = llm_compress.summarize_messages([_msg(source)], [0])
+    assert result is not None
+    assert "0.3.17" in result[0]
+
+
+def test_apply_hallucination_guard_strips_invented_version() -> None:
+    from cluxion_runtime.core import llm_compress
+
+    source = "Current package is version 0.3.17 only."
+    summary = "We bumped to version 1.2.3 for this release."
+    guarded, stripped = llm_compress._apply_hallucination_guard(summary, source)
+    assert stripped >= 1
+    assert guarded is not None
+    assert "1.2.3" not in guarded
+
+
 def test_hallucination_guard_all_fabricated_returns_none(monkeypatch) -> None:
     from cluxion_runtime.core import llm_compress
 

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/tests/runtime/test_guard_daemon_host.py

@@ -11,13 +11,16 @@ from typing import Any
 import pytest
 
 from cluxion_runtime.guard_daemon_host import (
+    DEFAULT_IDLE_TTL_MS,
     HEARTBEAT_FILE_NAME,
     PID_FILE_NAME,
     PROC_SCAN_EVERY_N_TICKS,
+    STATE_WRITE_EVERY_N_TICKS,
     ProcessScanCache,
     _daemon_loop_step,
     _python_daemon_tick,
     _run_python_daemon,
+    _write_state_if_changed,
     is_idle,
 )
 
@@ -178,7 +181,7 @@ def test_daemon_loop_step_exits_idle_and_removes_pidfile(tmp_path: Path) -> None
     pid_path.write_text("4242", encoding="utf-8")
 
     process_cache = ProcessScanCache(process_count=0, zombie_count=0, zombie_pids=[])
-    keep_running, _ = _daemon_loop_step(
+    keep_running, _, _ = _daemon_loop_step(
         tmp_path,
         process_cache=process_cache,
         cpu_window=[],
@@ -218,7 +221,7 @@ def test_daemon_loop_step_keeps_running_with_fresh_heartbeat(tmp_path: Path) ->
     pid_path.write_text("4242", encoding="utf-8")
 
     process_cache = ProcessScanCache(process_count=0, zombie_count=0, zombie_pids=[])
-    keep_running, refreshed_cache = _daemon_loop_step(
+    keep_running, refreshed_cache, _ = _daemon_loop_step(
         tmp_path,
         process_cache=process_cache,
         cpu_window=[],
@@ -233,4 +236,24 @@ def test_daemon_loop_step_keeps_running_with_fresh_heartbeat(tmp_path: Path) ->
     assert keep_running is True
     assert pid_path.exists()
     assert refreshed_cache.process_count > 0
-    assert (tmp_path / "guard_state.json").exists()
+    assert (tmp_path / "guard_state.json").exists()
+
+
+def test_default_idle_ttl_is_two_minutes() -> None:
+    assert DEFAULT_IDLE_TTL_MS == 120_000
+
+
+def test_write_state_if_changed_skips_identical_fingerprint(tmp_path: Path) -> None:
+    process_cache = ProcessScanCache(process_count=0, zombie_count=0, zombie_pids=[])
+    state, _ = _python_daemon_tick(process_cache, [], [], 5, 1000, tick=0)
+    state_path = tmp_path / "guard_state.json"
+
+    fp = _write_state_if_changed(tmp_path, state, last_fingerprint=None, tick=1)
+    first_mtime = state_path.stat().st_mtime
+    assert state_path.exists()
+
+    _write_state_if_changed(tmp_path, state, last_fingerprint=fp, tick=2)
+    assert state_path.stat().st_mtime == first_mtime
+
+    _write_state_if_changed(tmp_path, state, last_fingerprint=fp, tick=STATE_WRITE_EVERY_N_TICKS)
+    assert state_path.stat().st_mtime >= first_mtime

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/tests/test_guard_watch.py

@@ -43,6 +43,7 @@ def test_register_adds_guard_hooks_when_supported() -> None:
 
     assert ctx.hooks == {
         "on_session_start": guard_watch.on_session_start,
+        "on_session_end": guard_watch.on_session_end,
         "post_tool_call": guard_watch.post_tool_call,
     }
     assert "cluxion_guard" in ctx.tools

{cluxion_agentplugin_preprocessing-0.3.17 → cluxion_agentplugin_preprocessing-0.3.18}/tests/test_runner.py

@@ -205,6 +205,14 @@ def test_context_compress_rejects_malformed_messages() -> None:
         raise AssertionError("expected ValueError")
 
 
+def test_guard_unknown_action_returns_clear_error() -> None:
+    result = runner.guard({"action": "sample"})
+    payload = json.loads(result.to_json())
+    assert result.ok is False
+    assert "unknown guard action: sample" in payload["error"]
+    assert "status|start|stop|enforce|auto-enforce" in payload["error"]
+
+
 def test_context_compress_accepts_valid_messages_structure() -> None:
     try:
         runner.context_compress({"messages": [{"content": "hello world"}]})