cluxion-agentplugin-preprocessing 0.3.14__tar.gz → 0.3.16__tar.gz

{cluxion_agentplugin_preprocessing-0.3.14 → cluxion_agentplugin_preprocessing-0.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-preprocessing
-Version: 0.3.14
+Version: 0.3.16
 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.14 → cluxion_agentplugin_preprocessing-0.3.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-preprocessing"
-version = "0.3.14"
+version = "0.3.16"
 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.14 → cluxion_agentplugin_preprocessing-0.3.16}/src/cluxion_runtime/core/context_compress.py

@@ -6,8 +6,10 @@ lockstep so the three backends produce identical Stage-1 output (parity-tested).
 
 Stages 2 (LLM summarization via ``hermes -z``) and 3 (hybrid forgetting) are
 Python-only; the Rust mirror intentionally does not replicate LLM or forgetforge
-calls. Disable them with ``enable_llm_summary`` / ``enable_forget`` for Stage-1
-parity.
+calls. Stage 4 (last-resort truncation of pinned recent turns) is also
+Python-only — it runs when every remaining message is pinned yet still exceeds
+the target. Disable stages 2-4 with ``enable_llm_summary`` / ``enable_forget``
+for Stage-1 parity.
 
 What stays untouched: pinned messages (explicit ``pinned``, the first
 user message = task intent, the most recent ``keep_recent`` turns).
@@ -152,13 +154,26 @@ def compress(payload: Mapping[str, object]) -> dict[str, object]:
             stages.append("forget")
         pinned = _pinned_indices(messages, keep_recent)
 
+    intent_idx = _first_user_index(messages)
+    if total > target_tokens and (
+        over_target_pinned_only or not any(idx not in pinned for idx in range(len(messages)))
+    ):
+        total, changed = _stage_truncate_pinned_recent(
+            messages, keep_recent, total, target_tokens, intent_idx=intent_idx
+        )
+        if changed:
+            stages.append("truncate_pinned_recent")
+        over_target_pinned_only = False
+
     if total > target_tokens:
         if summary_request is None:
             summary_request = _build_summary_request(messages, pinned, total, target_tokens)
-        if over_target_pinned_only or not any(idx not in pinned for idx in range(len(messages))):
-            over_target_pinned_only = True
-        if total / context_limit > trigger_ratio:
+        intent_tokens = (
+            estimate_tokens(messages[intent_idx].content) if intent_idx is not None else 0
+        )
+        if intent_tokens > target_tokens:
             forced_over_target = True
+            over_target_pinned_only = True
 
     return _result_payload(
         messages,
@@ -208,6 +223,10 @@ def _bool_flag(payload: Mapping[str, object], key: str, default: bool) -> bool:
     return default
 
 
+def _first_user_index(messages: list[_Msg]) -> int | None:
+    return next((idx for idx, msg in enumerate(messages) if msg.role == "user"), None)
+
+
 def _pinned_indices(messages: list[_Msg], keep_recent: int) -> list[int]:
     pinned = [idx for idx, msg in enumerate(messages) if msg.pinned]
     first_user = next((idx for idx, msg in enumerate(messages) if msg.role == "user"), None)
@@ -221,6 +240,17 @@ def _pinned_indices(messages: list[_Msg], keep_recent: int) -> list[int]:
     return pinned
 
 
+def _apply_head_tail_truncate(content: str) -> str | None:
+    if estimate_tokens(content) <= TRUNCATE_MIN_TOKENS:
+        return None
+    if len(content) <= TRUNCATE_HEAD_CHARS + TRUNCATE_TAIL_CHARS:
+        return None
+    elided = len(content) - TRUNCATE_HEAD_CHARS - TRUNCATE_TAIL_CHARS
+    head = content[:TRUNCATE_HEAD_CHARS]
+    tail = content[len(content) - TRUNCATE_TAIL_CHARS :]
+    return f"{head}\n[...cluxion: {elided} chars elided...]\n{tail}"
+
+
 def _stage_truncate(messages: list[_Msg], pinned: list[int], total: int, target: int) -> tuple[int, bool]:
     changed = False
     for idx, msg in enumerate(messages):
@@ -228,21 +258,53 @@ def _stage_truncate(messages: list[_Msg], pinned: list[int], total: int, target:
             break
         if idx in pinned:
             continue
-        tokens = estimate_tokens(msg.content)
-        if tokens <= TRUNCATE_MIN_TOKENS:
+        replacement = _apply_head_tail_truncate(msg.content)
+        if replacement is None:
             continue
-        if len(msg.content) <= TRUNCATE_HEAD_CHARS + TRUNCATE_TAIL_CHARS:
-            continue
-        elided = len(msg.content) - TRUNCATE_HEAD_CHARS - TRUNCATE_TAIL_CHARS
-        head = msg.content[:TRUNCATE_HEAD_CHARS]
-        tail = msg.content[len(msg.content) - TRUNCATE_TAIL_CHARS :]
-        replacement = f"{head}\n[...cluxion: {elided} chars elided...]\n{tail}"
+        tokens = estimate_tokens(msg.content)
         total = total - tokens + estimate_tokens(replacement)
         msg.content = replacement
         changed = True
     return total, changed
 
 
+def _pinned_recent_indices(messages: list[_Msg], keep_recent: int, intent_idx: int | None) -> list[int]:
+    recent_start = max(0, len(messages) - keep_recent)
+    return [idx for idx in range(recent_start, len(messages)) if idx != intent_idx]
+
+
+def _stage_truncate_pinned_recent(
+    messages: list[_Msg],
+    keep_recent: int,
+    total: int,
+    target: int,
+    *,
+    intent_idx: int | None,
+) -> tuple[int, bool]:
+    """Last-resort: truncate pinned recent turns (never intent) until total <= target."""
+    if total <= target:
+        return total, False
+
+    candidates = _pinned_recent_indices(messages, keep_recent, intent_idx)
+    changed = False
+    while total > target:
+        progressed = False
+        for idx in candidates:
+            if total <= target:
+                break
+            replacement = _apply_head_tail_truncate(messages[idx].content)
+            if replacement is None:
+                continue
+            tokens = estimate_tokens(messages[idx].content)
+            total = total - tokens + estimate_tokens(replacement)
+            messages[idx].content = replacement
+            changed = True
+            progressed = True
+        if not progressed:
+            break
+    return total, changed
+
+
 def _stage_dedup(messages: list[_Msg], pinned: list[int], total: int, target: int) -> tuple[int, bool]:
     changed = False
     seen: dict[str, int] = {}

cluxion_agentplugin_preprocessing-0.3.16/src/cluxion_runtime/core/llm_compress.py

@@ -0,0 +1,261 @@
+"""LLM-backed message summarization for context compression stage 2.
+
+Calls the main model via ``hermes -z`` (or ``cluxion_hermes_call`` when available).
+Stage 2 is Python-only; the Rust ``context.rs`` mirror intentionally does not
+replicate LLM calls.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import shutil
+import subprocess
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+DEFAULT_TIMEOUT_S = 120.0
+_HERMES_BIN = "hermes"
+logger = logging.getLogger(__name__)
+
+_SUMMARY_INSTRUCTIONS = (
+    "Summarize each message by importance. PRESERVE ABOVE ALL: the user's intent and "
+    "direction, decisions made, unresolved items, file paths / identifiers / commands — "
+    "regardless of language (Korean or English). "
+    "ONLY summarize content actually present in the message. NEVER invent, add, infer, "
+    "or fabricate any identifier, number, name, port, path, or fact that is not in the "
+    "original. If unsure whether something is in the source, OMIT it. "
+    "Compress everything else. Each summary < 10% of the original. "
+    'Output STRICT JSON: {"<index>": "<summary>", ...} only.'
+)
+
+_HARD_TOKEN_RE = re.compile(
+    r"\b(?:"
+    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)
+_STRIP_LABEL_PREFIX_RE = re.compile(r"(?:\w+:\s*)+", re.IGNORECASE)
+_SUFFIX_MULTIPLIERS = {"k": 1000, "m": 1_000_000, "만": 10_000, "억": 100_000_000}
+
+
+class _MessageLike(Protocol):
+    role: str
+    content: str
+
+
+def hermes_available() -> bool:
+    return shutil.which(_HERMES_BIN) is not None
+
+
+def summarize_messages(
+    messages: Sequence[_MessageLike],
+    indices: Sequence[int],
+    instructions: str | None = None,
+    *,
+    model: str | None = None,
+    timeout_s: float = DEFAULT_TIMEOUT_S,
+) -> dict[int, str] | None:
+    """Summarize selected messages via hermes -z. Returns None on any failure."""
+    if not indices:
+        return {}
+    if not hermes_available():
+        return None
+    prompt = _build_prompt(messages, indices, instructions or _SUMMARY_INSTRUCTIONS)
+    try:
+        stdout = _call_hermes_oneshot(prompt, model=model, timeout_s=timeout_s)
+    except (OSError, subprocess.TimeoutExpired, subprocess.CalledProcessError):
+        return None
+    parsed = _parse_summary_json(stdout)
+    if parsed is None:
+        return None
+    result: dict[int, str] = {}
+    hallucination_stripped = 0
+    for idx in indices:
+        key = str(idx)
+        if key not in parsed or not isinstance(parsed[key], str) or not parsed[key].strip():
+            continue
+        summary = parsed[key].strip()
+        if idx < 0 or idx >= len(messages):
+            result[idx] = summary
+            continue
+        try:
+            guarded, stripped = _apply_hallucination_guard(summary, messages[idx].content)
+        except Exception:
+            logger.exception("llm_compress: hallucination guard failed for message %s", idx)
+            return None
+        if guarded is None:
+            return None
+        hallucination_stripped += stripped
+        result[idx] = guarded
+    if not result:
+        return None
+    if hallucination_stripped > 0:
+        logger.info(
+            "llm_compress: stripped %d hallucinated token(s) from summaries",
+            hallucination_stripped,
+        )
+    return result
+
+
+def _normalize_for_match(text: str) -> str:
+    return re.sub(r"[,\s]+", "", text.lower())
+
+
+def _numeric_variants(token: str) -> set[str]:
+    norm = _normalize_for_match(token)
+    variants = {norm}
+    match = _NUMERIC_SUFFIX_RE.match(norm)
+    if not match:
+        return variants
+    base, suffix = match.group(1), match.group(2)
+    variants.add(_normalize_for_match(base))
+    if suffix:
+        multiplier = _SUFFIX_MULTIPLIERS.get(suffix.lower())
+        if multiplier is not None:
+            try:
+                expanded = str(int(float(base) * multiplier))
+            except ValueError:
+                expanded = None
+            if expanded:
+                variants.add(expanded)
+    return variants
+
+
+def _token_traceable_in_source(token: str, source: str) -> bool:
+    norm_source = _normalize_for_match(source)
+    norm_token = _normalize_for_match(token)
+
+    if norm_token in norm_source:
+        return True
+
+    for variant in _numeric_variants(token):
+        if variant in norm_source:
+            return True
+
+    digit_groups = re.findall(r"\d+", norm_token)
+    if digit_groups:
+        all_digits_traceable = True
+        for digits in digit_groups:
+            if digits in norm_source:
+                continue
+            traceable = any(variant in norm_source for variant in _numeric_variants(digits))
+            if not traceable:
+                all_digits_traceable = False
+                break
+        if all_digits_traceable:
+            alpha_prefix = re.sub(r"[\d._-]+", "", norm_token)
+            if not alpha_prefix or alpha_prefix in norm_source:
+                return True
+
+    if "." in norm_token:
+        without_dots = norm_token.replace(".", "")
+        if without_dots in norm_source or without_dots in norm_source.replace(".", ""):
+            return True
+
+    return False
+
+
+def _extract_hard_tokens(summary: str) -> list[str]:
+    return list(dict.fromkeys(_HARD_TOKEN_RE.findall(summary)))
+
+
+def _strip_fabricated_token(summary: str, token: str) -> str | None:
+    escaped = re.escape(token)
+    pattern = rf"(?:{_STRIP_LABEL_PREFIX_RE.pattern})?{escaped}\b"
+    stripped = re.sub(pattern, "", summary, count=1, flags=re.IGNORECASE)
+    stripped = re.sub(r"\s+", " ", stripped).strip(" \t\n\r,;:-")
+    stripped = re.sub(r"[,;:\-]\s*$", "", stripped).strip()
+    if not stripped or not re.search(r"\w", stripped):
+        return None
+    return stripped
+
+
+def _apply_hallucination_guard(summary: str, source: str) -> tuple[str | None, int]:
+    guarded = summary
+    stripped_count = 0
+    for token in _extract_hard_tokens(summary):
+        if _token_traceable_in_source(token, source):
+            continue
+        updated = _strip_fabricated_token(guarded, token)
+        if updated is None:
+            return None, stripped_count
+        guarded = updated
+        stripped_count += 1
+    return guarded, stripped_count
+
+
+def _build_prompt(
+    messages: Sequence[_MessageLike],
+    indices: Sequence[int],
+    instructions: str,
+) -> str:
+    blocks: list[str] = [instructions, "", "Messages to summarize:"]
+    for idx in indices:
+        if idx < 0 or idx >= len(messages):
+            continue
+        msg = messages[idx]
+        blocks.append(f"--- message index {idx} ({msg.role}) ---")
+        blocks.append(msg.content)
+        blocks.append("")
+    return "\n".join(blocks)
+
+
+def _call_hermes_oneshot(prompt: str, *, model: str | None, timeout_s: float) -> str:
+    prev = os.environ.get("CLUXION_PREPROCESS_IN_COMPRESS")
+    os.environ["CLUXION_PREPROCESS_IN_COMPRESS"] = "1"
+    try:
+        try:
+            from cluxion_hermes_call.core import hermes_oneshot  # type: ignore[import-not-found]
+
+            return str(hermes_oneshot(prompt, model=model, timeout_s=timeout_s))
+        except ImportError:
+            pass
+
+        cmd = [_HERMES_BIN, "-z", prompt]
+        if model:
+            cmd[1:1] = ["-m", model]
+        completed = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout_s,
+        )
+        return completed.stdout
+    finally:
+        if prev is None:
+            os.environ.pop("CLUXION_PREPROCESS_IN_COMPRESS", None)
+        else:
+            os.environ["CLUXION_PREPROCESS_IN_COMPRESS"] = prev
+
+
+def _parse_summary_json(stdout: str) -> Mapping[str, object] | None:
+    text = stdout.strip()
+    if not text:
+        return None
+    fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
+    if fence:
+        text = fence.group(1)
+    else:
+        start = text.find("{")
+        end = text.rfind("}")
+        if start >= 0 and end > start:
+            text = text[start : end + 1]
+    try:
+        parsed = json.loads(text)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(parsed, dict):
+        return None
+    return parsed
+
+
+__all__ = ["DEFAULT_TIMEOUT_S", "hermes_available", "summarize_messages"]

{cluxion_agentplugin_preprocessing-0.3.14 → cluxion_agentplugin_preprocessing-0.3.16}/tests/runtime/test_context_compress_llm_forget.py

@@ -179,6 +179,116 @@ def test_summarize_messages_returns_none_on_bad_json(monkeypatch) -> None:
     assert llm_compress.summarize_messages([type("M", (), {"role": "user", "content": "hi"})()], [0]) is None
 
 
+def _msg(content: str):
+    return type("M", (), {"role": "user", "content": content})()
+
+
+def test_hallucination_guard_strips_fabricated_port(monkeypatch) -> None:
+    from cluxion_runtime.core import llm_compress
+
+    source = "Connect to Redis on port 5433 for caching. File: recon_v4.py"
+    llm_json = (
+        '{"0": "Redis caching on port 5433. recon_v4.py. Hot: Redis:6390"}'
+    )
+    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 "6390" not in result[0]
+    assert "Hot:" not in result[0]
+    assert "5433" in result[0]
+    assert "recon_v4.py" in result[0]
+
+
+def test_hallucination_guard_keeps_normalized_number(monkeypatch) -> None:
+    from cluxion_runtime.core import llm_compress
+
+    source = "Daily traffic is 482,000 requests with peak at 14 months uptime."
+    llm_json = '{"0": "Traffic 482k requests, 14mo uptime."}'
+    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 "482k" in result[0]
+    assert "14mo" in result[0]
+
+
+def test_hallucination_guard_keeps_korean_normalized_number(monkeypatch) -> None:
+    from cluxion_runtime.core import llm_compress
+
+    source = "일평균 482,000건 처리, Redis 포트 5433 사용."
+    llm_json = '{"0": "일평균 482k/day, Redis 5433."}'
+    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 "482k" in result[0]
+    assert "5433" in result[0]
+
+
+def test_hallucination_guard_all_fabricated_returns_none(monkeypatch) -> None:
+    from cluxion_runtime.core import llm_compress
+
+    source = "Discuss caching strategy for the API layer."
+    llm_json = '{"0": "Hot: Redis:6390"}'
+    monkeypatch.setattr(llm_compress, "hermes_available", lambda: True)
+    monkeypatch.setattr(llm_compress, "_call_hermes_oneshot", lambda *a, **k: llm_json)
+
+    assert llm_compress.summarize_messages([_msg(source)], [0]) is None
+
+
+def test_pinned_recent_last_resort_brings_under_target(monkeypatch) -> None:
+    """Live edge case: all messages pinned and huge — intent preserved, usage <= target."""
+    monkeypatch.setattr(context_compress, "hermes_available", lambda: False)
+    intent = "TASK_INTENT: implement pinned-overflow guard"
+    payload = {
+        "messages": [
+            {"role": "user", "content": intent + _long(160_000)},
+            {"role": "assistant", "content": _long(160_000)},
+            {"role": "tool", "content": _long(160_000)},
+            {"role": "assistant", "content": _long(160_000)},
+            {"role": "user", "content": _long(160_000)},
+        ],
+        # 5 x ~40k tokens ~ 200k total -> usage 0.80 at this limit (live edge case).
+        "context_limit_tokens": 250_000,
+        "keep_recent_turns": 4,
+        "enable_llm_summary": False,
+        "enable_forget": True,
+    }
+    result = context_compress.compress(payload)
+    target = int(0.30 * result["context_limit"])
+    assert result["usage_before"] >= 0.70
+    assert result["messages"][0]["content"].startswith(intent)
+    assert result["tokens_after"] <= target
+    assert result.get("over_target_pinned_only") is not True
+    assert "truncate_pinned_recent" in result["stages_applied"]
+
+
+def test_lone_giant_intent_forced_over_target(monkeypatch) -> None:
+    """When intent alone exceeds target, truncate everything else and flag forced_over_target."""
+    monkeypatch.setattr(context_compress, "hermes_available", lambda: False)
+    intent = "GIANT_INTENT"
+    payload = {
+        "messages": [
+            {"role": "user", "content": intent + _long(12_000)},
+            {"role": "assistant", "content": _long(12_000)},
+        ],
+        "context_limit_tokens": 1000,
+        "keep_recent_turns": 2,
+        "enable_llm_summary": False,
+        "enable_forget": True,
+    }
+    result = context_compress.compress(payload)
+    assert result["messages"][0]["content"].startswith(intent)
+    assert result.get("forced_over_target") is True
+    assert result.get("over_target_pinned_only") is True
+    assert "[...cluxion:" in result["messages"][1]["content"]
+    assert result["tokens_after"] > int(0.30 * result["context_limit"])
+
+
 def test_korean_decision_survives_stage3() -> None:
     body = _long(4000)
     digest = f"[cluxion digest] tool: {body[:80]} [900 tokens elided]"

cluxion_agentplugin_preprocessing-0.3.14/src/cluxion_runtime/core/llm_compress.py

@@ -1,138 +0,0 @@
-"""LLM-backed message summarization for context compression stage 2.
-
-Calls the main model via ``hermes -z`` (or ``cluxion_hermes_call`` when available).
-Stage 2 is Python-only; the Rust ``context.rs`` mirror intentionally does not
-replicate LLM calls.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import shutil
-import subprocess
-from typing import TYPE_CHECKING, Protocol
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping, Sequence
-
-DEFAULT_TIMEOUT_S = 120.0
-_HERMES_BIN = "hermes"
-
-_SUMMARY_INSTRUCTIONS = (
-    "Summarize each message by importance. PRESERVE ABOVE ALL: the user's intent and "
-    "direction, decisions made, unresolved items, file paths / identifiers / commands — "
-    "regardless of language (Korean or English). "
-    "Compress everything else. Each summary < 10% of the original. "
-    'Output STRICT JSON: {"<index>": "<summary>", ...} only.'
-)
-
-
-class _MessageLike(Protocol):
-    role: str
-    content: str
-
-
-def hermes_available() -> bool:
-    return shutil.which(_HERMES_BIN) is not None
-
-
-def summarize_messages(
-    messages: Sequence[_MessageLike],
-    indices: Sequence[int],
-    instructions: str | None = None,
-    *,
-    model: str | None = None,
-    timeout_s: float = DEFAULT_TIMEOUT_S,
-) -> dict[int, str] | None:
-    """Summarize selected messages via hermes -z. Returns None on any failure."""
-    if not indices:
-        return {}
-    if not hermes_available():
-        return None
-    prompt = _build_prompt(messages, indices, instructions or _SUMMARY_INSTRUCTIONS)
-    try:
-        stdout = _call_hermes_oneshot(prompt, model=model, timeout_s=timeout_s)
-    except (OSError, subprocess.TimeoutExpired, subprocess.CalledProcessError):
-        return None
-    parsed = _parse_summary_json(stdout)
-    if parsed is None:
-        return None
-    result: dict[int, str] = {}
-    for idx in indices:
-        key = str(idx)
-        if key in parsed and isinstance(parsed[key], str) and parsed[key].strip():
-            result[idx] = parsed[key].strip()
-    if not result:
-        return None
-    return result
-
-
-def _build_prompt(
-    messages: Sequence[_MessageLike],
-    indices: Sequence[int],
-    instructions: str,
-) -> str:
-    blocks: list[str] = [instructions, "", "Messages to summarize:"]
-    for idx in indices:
-        if idx < 0 or idx >= len(messages):
-            continue
-        msg = messages[idx]
-        blocks.append(f"--- message index {idx} ({msg.role}) ---")
-        blocks.append(msg.content)
-        blocks.append("")
-    return "\n".join(blocks)
-
-
-def _call_hermes_oneshot(prompt: str, *, model: str | None, timeout_s: float) -> str:
-    prev = os.environ.get("CLUXION_PREPROCESS_IN_COMPRESS")
-    os.environ["CLUXION_PREPROCESS_IN_COMPRESS"] = "1"
-    try:
-        try:
-            from cluxion_hermes_call.core import hermes_oneshot  # type: ignore[import-not-found]
-
-            return str(hermes_oneshot(prompt, model=model, timeout_s=timeout_s))
-        except ImportError:
-            pass
-
-        cmd = [_HERMES_BIN, "-z", prompt]
-        if model:
-            cmd[1:1] = ["-m", model]
-        completed = subprocess.run(
-            cmd,
-            check=True,
-            capture_output=True,
-            text=True,
-            timeout=timeout_s,
-        )
-        return completed.stdout
-    finally:
-        if prev is None:
-            os.environ.pop("CLUXION_PREPROCESS_IN_COMPRESS", None)
-        else:
-            os.environ["CLUXION_PREPROCESS_IN_COMPRESS"] = prev
-
-
-def _parse_summary_json(stdout: str) -> Mapping[str, object] | None:
-    text = stdout.strip()
-    if not text:
-        return None
-    fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
-    if fence:
-        text = fence.group(1)
-    else:
-        start = text.find("{")
-        end = text.rfind("}")
-        if start >= 0 and end > start:
-            text = text[start : end + 1]
-    try:
-        parsed = json.loads(text)
-    except json.JSONDecodeError:
-        return None
-    if not isinstance(parsed, dict):
-        return None
-    return parsed
-
-
-__all__ = ["DEFAULT_TIMEOUT_S", "hermes_available", "summarize_messages"]