superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/hooks/stop_outcome_hook.py

@@ -1,138 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — Track A.2 (LLD-09 / LLD-00)
-
-"""Stop hook — finalize every pending outcome for this session.
-
-Flow (<500 ms typical, <1 s hard):
-  1. Read stdin JSON {session_id}.
-  2. SELECT outcome_id FROM pending_outcomes
-     WHERE session_id = ? AND status = 'pending'.
-  3. For each outcome_id, call
-     ``EngagementRewardModel.finalize_outcome(outcome_id=...)``.
-     The reward model owns the action_outcomes INSERT (profile_id
-     populated per SEC-C-05) and the pending→settled transition.
-  4. Cleanup: delete the per-session state file (best effort).
-  5. Emit ``{}`` on stdout, exit 0.
-
-Contract (LLD-00 §2): the EngagementRewardModel finalize entry point
-takes ``outcome_id=`` as its only keyword argument. Any other form
-(positional args, or a ``query_id=`` keyword) is forbidden and the
-Stage-5b CI gate fails the build on sight.
-"""
-
-from __future__ import annotations
-
-import sys
-import time
-
-from superlocalmemory.hooks._outcome_common import (
-    emit_empty_json,
-    log_perf,
-    memory_db_path,
-    open_memory_db,
-    read_stdin_json,
-    session_state_file,
-)
-
-
-_HOOK_NAME = "stop_outcome"
-
-
-def _inner_main() -> str:
-    payload = read_stdin_json()
-    if payload is None:
-        return "invalid_payload"
-
-    session_id = payload.get("session_id")
-    if not isinstance(session_id, str) or not session_id:
-        return "no_session"
-
-    # Enumerate pending outcomes for this session.
-    conn = None
-    try:
-        conn = open_memory_db()
-        rows = conn.execute(
-            "SELECT outcome_id FROM pending_outcomes "
-            "WHERE session_id = ? AND status = 'pending'",
-            (session_id,),
-        ).fetchall()
-    except Exception:
-        return "db_locked"
-    finally:
-        if conn is not None:
-            conn.close()
-
-    if not rows:
-        _cleanup_session_state(session_id)
-        return "no_pending"
-
-    # Delayed import of the model — the hot-path budget for Stop is 500 ms,
-    # generous enough to pay the import tax once per session end.
-    try:
-        from superlocalmemory.learning.reward import EngagementRewardModel
-    except Exception:
-        return "import_fail"
-
-    try:
-        model = EngagementRewardModel(memory_db_path())
-    except Exception:
-        return "model_init_fail"
-
-    finalized = 0
-    try:
-        for r in rows:
-            oid = r["outcome_id"]
-            # CRITICAL: kwarg-only per LLD-00 §2. Never positional.
-            # Never the legacy ``query_id=``. Stage-5b CI gate enforces.
-            try:
-                model.finalize_outcome(outcome_id=oid)
-                finalized += 1
-            except Exception:  # pragma: no cover — reward returns 0.5 on error
-                continue
-    finally:
-        try:
-            model.close()
-        except Exception:
-            pass
-
-    _cleanup_session_state(session_id)
-    return f"finalized_{finalized}"
-
-
-def _cleanup_session_state(session_id: str) -> None:
-    """Remove the session_state JSON file, if any. Best effort."""
-    p = session_state_file(session_id)
-    if p is None:
-        return
-    try:
-        if p.exists():
-            p.unlink()
-    except Exception:
-        pass
-
-
-def main() -> int:
-    t0 = time.perf_counter()
-    outcome = "exception"
-    try:
-        outcome = _inner_main()
-    except Exception as exc:  # pragma: no cover
-        try:
-            sys.stderr.write(
-                f"slm-hook {_HOOK_NAME}: {type(exc).__name__}\n"
-            )
-        except Exception:
-            pass
-    finally:
-        duration_ms = (time.perf_counter() - t0) * 1000.0
-        emit_empty_json()
-        try:
-            log_perf(_HOOK_NAME, duration_ms, outcome)
-        except Exception:
-            pass
-    return 0
-
-
-if __name__ == "__main__":  # pragma: no cover — CLI entry only
-    sys.exit(main())

package/src/superlocalmemory/hooks/sync_loop.py

@@ -1,114 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-05 §9
-
-"""Background sync loop — keeps every cross-platform adapter fresh.
-
-LLD-05 §9. Runs as an asyncio task in the unified daemon's lifespan.
-Default interval 900 s; first run at t=5 s so users see files quickly.
-Adapter errors are logged but NEVER abort the loop (A8).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import time
-from typing import Iterable
-
-from superlocalmemory.hooks.adapter_base import Adapter
-
-logger = logging.getLogger(__name__)
-
-
-DEFAULT_INTERVAL_SECONDS = 900
-FIRST_RUN_DELAY_SECONDS = 5.0
-
-
-def _interval_from_env(default: int = DEFAULT_INTERVAL_SECONDS) -> int:
-    raw = os.environ.get("SLM_CROSS_PLATFORM_SYNC_INTERVAL")
-    if not raw:
-        return default
-    try:
-        value = int(raw)
-    except ValueError:
-        return default
-    return max(30, value)
-
-
-async def cross_platform_sync_loop(
-    adapters: Iterable[Adapter],
-    *,
-    interval: float | None = None,
-    first_run_delay: float = FIRST_RUN_DELAY_SECONDS,
-    iterations: int | None = None,
-) -> int:
-    """Top-level coroutine. Returns number of iterations run.
-
-    ``iterations`` cap is used by tests to bound the loop. Production
-    callers pass ``None`` and rely on task cancellation for shutdown.
-    """
-    adapters = list(adapters)
-    step = float(interval) if interval is not None else float(_interval_from_env())
-    await asyncio.sleep(first_run_delay)
-
-    count = 0
-    while True:
-        await run_once(adapters)
-        count += 1
-        if iterations is not None and count >= iterations:
-            return count
-        try:
-            await asyncio.sleep(step)
-        except asyncio.CancelledError:  # pragma: no cover — shutdown
-            raise
-
-
-async def run_once(adapters: Iterable[Adapter]) -> dict[str, str]:
-    """Run a single sync cycle over all adapters. Never raises.
-
-    E.3 (v3.4.22 perf): ``adapter.sync()`` is synchronous file I/O
-    (opens/reads/writes JSON files in ~/.cursor, ~/.antigravity, etc.)
-    and used to run directly on the event loop — a slow disk or a
-    large workspace could block the daemon for tens of milliseconds,
-    stalling every concurrent request. We now off-load each sync to
-    the default thread pool via ``asyncio.to_thread``.
-    """
-    results: dict[str, str] = {}
-
-    def _one(adapter: Adapter) -> tuple[str, str, float]:
-        """Sync a single adapter; returns (name, outcome, elapsed_ms)."""
-        name = getattr(adapter, "name", "?")
-        try:
-            if not adapter.is_active():
-                return name, "inactive", 0.0
-            start = time.monotonic()
-            wrote = adapter.sync()
-            elapsed_ms = (time.monotonic() - start) * 1000
-            return name, ("wrote" if wrote else "skipped"), elapsed_ms
-        except Exception as exc:
-            logger.warning("adapter %s sync failed: %s", name, exc)
-            return name, f"error:{type(exc).__name__}", 0.0
-
-    for adapter in adapters:
-        name, outcome, elapsed_ms = await asyncio.to_thread(_one, adapter)
-        results[name] = outcome
-        if outcome in ("wrote", "skipped"):
-            logger.debug("adapter %s sync %s (%.1f ms)",
-                         name, outcome, elapsed_ms)
-    return results
-
-
-def schedule(adapters: Iterable[Adapter]) -> asyncio.Task:
-    """Fire-and-forget scheduling for the daemon lifespan."""
-    return asyncio.create_task(cross_platform_sync_loop(adapters))
-
-
-__all__ = (
-    "DEFAULT_INTERVAL_SECONDS",
-    "FIRST_RUN_DELAY_SECONDS",
-    "cross_platform_sync_loop",
-    "run_once",
-    "schedule",
-)

package/src/superlocalmemory/hooks/topic_shift_hook.py

@@ -1,302 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.43 — Topic-shift detection on UserPromptSubmit
-
-"""Topic-shift detection hook — replaces time-based recall nag.
-
-Replaces the time-based "[SLM] 15+ min since last context refresh" reminder
-emitted by _hook_checkpoint with event-based detection. Fires a single-line
-recall reminder only when the current prompt's content-word set has zero
-overlap with EVERY recent prompt in a 5-prompt sliding window — the strictest
-defensible signal for a genuine topic pivot.
-
-Dispatch: `slm hook topic_shift` (UserPromptSubmit).
-
-HOT-PATH CONTRACT
-=================
-- stdlib-only imports at module load.
-- Reads {"session_id", "prompt"} from stdin JSON.
-- On topic shift: prints one-line reminder to stdout (Claude Code surfaces
-  as system-reminder).
-- On no-shift / any error: silent exit 0. Never blocks the prompt.
-- Latency budget: <10 ms (regex + set ops on bounded input). Verified
-  by the algorithm itself; subprocess startup adds ~30-40 ms but that's
-  outside the budget for the Python logic.
-- State file per root and session:
-  /tmp/slm-topicstate-{root_hash}-{sha256(session_id)[:16]}.json
-  Schema: {"window": [[word, ...], ...], "version": 1}.
-
-DESIGN NOTES (NASA-grade — defensible thresholds, e2e-tuned)
-============================================================
-- N=5 sliding window — spans conversational follow-ups, still detects shifts
-  in long sessions.
-- Algorithm: per-prompt MAX overlap (NOT jaccard-vs-union). True pivots share
-  zero content words with EVERY recent prompt; same-topic follow-ups share
-  at least one anchor word with at least ONE recent prompt (often not with
-  the union). Per-prompt max captures this; jaccard-vs-union over-fires.
-- |current_words| >= 5 — skip short utterances. Trade-off: very short pivots
-  ("monsoon forecast Mumbai") miss firing. Bounded cost: one missed reminder;
-  Claude self-trigger covers the residual.
-- >= 2 prior window entries — don't trigger on prompt 2 (insufficient baseline).
-- Word regex drops hyphens vs the topic_signature regex: compound technical
-  terms like "varunpratap-website" split into ["varunpratap", "website"] so
-  each half independently anchors against the window.
-- Extended stopword list (generic temporal connectors: "next", "back",
-  "week"...) prevents false-negative bridges across unrelated topics.
-- Observability: every decision logged TSV to a per-user log file unless
-  SLM_TOPIC_SHIFT_LOG=0 in environment.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import os
-import re
-import sys
-import tempfile
-import time
-
-# --------------------------------------------------------------------------
-# Config — frozen for v3.4.43. Tune via real-conversation log analysis.
-# --------------------------------------------------------------------------
-
-_WINDOW_SIZE = 5
-_MIN_CURRENT_WORDS = 5
-_MIN_WINDOW_ENTRIES = 2
-_MAX_PER_PROMPT_OVERLAP = 0
-_STATE_MAX_AGE_SEC = 24 * 3600
-_MAX_PROMPT_CHARS = 4000
-
-_TMP = tempfile.gettempdir()
-
-_STOPWORDS: frozenset[str] = frozenset({
-    "a", "about", "above", "after", "again", "against", "all", "am", "an",
-    "and", "any", "are", "as", "at", "be", "because", "been", "before",
-    "being", "below", "between", "both", "but", "by", "can", "cannot",
-    "could", "did", "do", "does", "doing", "don", "down", "during", "each",
-    "few", "for", "from", "further", "had", "has", "have", "having", "he",
-    "her", "here", "hers", "herself", "him", "himself", "his", "how", "i",
-    "if", "in", "into", "is", "it", "its", "itself", "just", "let", "me",
-    "more", "most", "my", "myself", "no", "nor", "not", "now", "of", "off",
-    "on", "once", "only", "or", "other", "ought", "our", "ours", "ourselves",
-    "out", "over", "own", "same", "she", "should", "so", "some", "such",
-    "than", "that", "the", "their", "theirs", "them", "themselves", "then",
-    "there", "these", "they", "this", "those", "through", "to", "too",
-    "under", "until", "up", "use", "using", "very", "was", "we", "were",
-    "what", "when", "where", "which", "while", "who", "whom", "why", "will",
-    "with", "would", "you", "your", "yours", "yourself", "yourselves",
-    "ok", "okay", "yes", "no", "yep", "nope", "thanks", "please", "go",
-    "tell", "let's", "lets", "want", "need", "would", "could", "make",
-    "also", "still", "really", "actually",
-    "next", "back", "here", "there", "now", "then", "again", "today",
-    "tomorrow", "yesterday", "week", "month", "year", "day", "time",
-    "thing", "things", "stuff", "way", "ways", "case", "cases",
-})
-
-# Linear-time non-backtracking word regex. Hyphens excluded so compound
-# technical terms split into independently-matchable halves.
-_WORD = re.compile(r"[A-Za-z0-9][A-Za-z0-9']{2,}")
-
-_ACK_RE = re.compile(
-    r"^\s*(yes|no|ok|okay|approved|thanks|thank you|go|sure|yep|nope|done|y|n|"
-    r"cool|got it|right|correct)([\s]+(yes|no|ok|okay|approved|thanks|done|\d+))*\s*[\.\!\?]?\s*$",
-    re.IGNORECASE,
-)
-
-_SHIFT_REMINDER = (
-    "[SLM] Topic shift detected. Consider calling "
-    "mcp__superlocalmemory__recall with the new topic to surface relevant "
-    "memories before responding."
-)
-
-# Optional test/embedder overrides. Runtime defaults are resolved dynamically
-# through the canonical data-root authority so environment switches in a
-# long-lived process do not continue logging to the first observed namespace.
-_LOG_DIR: str | None = None
-_LOG_PATH: str | None = None
-_LOG_ENABLED = os.environ.get("SLM_TOPIC_SHIFT_LOG", "1") != "0"
-_LOG_PROMPT_PREVIEW_CHARS = 80
-
-
-# --------------------------------------------------------------------------
-# Pure logic — testable without IO.
-# --------------------------------------------------------------------------
-
-def extract_content_words(prompt: str) -> list[str]:
-    """Tokenize → lowercase → filter stopwords + len<3. Bounded input."""
-    if not prompt:
-        return []
-    if len(prompt) > _MAX_PROMPT_CHARS:
-        prompt = prompt[:_MAX_PROMPT_CHARS]
-    words = _WORD.findall(prompt.lower())
-    return [w for w in words if w not in _STOPWORDS and len(w) >= 3]
-
-
-def is_substantive(prompt: str) -> bool:
-    """Substantive = length >= 10 AND not a pure conversational ack."""
-    if not prompt or len(prompt) < 10:
-        return False
-    if len(prompt) <= 30 and _ACK_RE.match(prompt):
-        return False
-    return True
-
-
-def detect_shift(
-    current_words: list[str],
-    window: list[list[str]],
-) -> tuple[bool, int]:
-    """Pure decision function.
-
-    Returns (fired, max_overlap_or_-1_when_gated).
-    """
-    if len(current_words) < _MIN_CURRENT_WORDS:
-        return False, -1
-    if len(window) < _MIN_WINDOW_ENTRIES:
-        return False, -1
-    cur = set(current_words)
-    max_overlap = max(len(cur & set(wl)) for wl in window)
-    return max_overlap <= _MAX_PER_PROMPT_OVERLAP, max_overlap
-
-
-# --------------------------------------------------------------------------
-# IO — state file + stdin parsing + stdout emission.
-# --------------------------------------------------------------------------
-
-def state_path(session_id: str) -> str:
-    """Hash canonical root and session ID for an isolated safe filename."""
-    from superlocalmemory.infra.data_root import canonical_data_root
-
-    root_digest = hashlib.sha256(
-        str(canonical_data_root()).encode("utf-8")
-    ).hexdigest()[:16]
-    session_digest = hashlib.sha256(
-        session_id.encode("utf-8")
-    ).hexdigest()[:16]
-    return os.path.join(
-        _TMP,
-        f"slm-topicstate-{root_digest}-{session_digest}.json",
-    )
-
-
-def load_state(path: str) -> list[list[str]]:
-    """Load window from disk. Empty on any failure or staleness."""
-    try:
-        st = os.stat(path)
-        if (time.time() - st.st_mtime) > _STATE_MAX_AGE_SEC:
-            return []
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        if not isinstance(data, dict):
-            return []
-        if data.get("version") != 1:
-            return []
-        win = data.get("window", [])
-        if not isinstance(win, list):
-            return []
-        out: list[list[str]] = []
-        for entry in win[-_WINDOW_SIZE:]:
-            if isinstance(entry, list) and all(isinstance(w, str) for w in entry):
-                out.append(entry)
-        return out
-    except (FileNotFoundError, json.JSONDecodeError, OSError, ValueError):
-        return []
-
-
-def save_state(path: str, window: list[list[str]]) -> None:
-    """Persist window. Silent on any IO failure."""
-    tmp = f"{path}.{os.getpid()}.{time.time_ns()}.tmp"
-    try:
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump({"version": 1, "window": window[-_WINDOW_SIZE:]}, f)
-        os.replace(tmp, path)
-    except OSError:
-        try:
-            os.remove(tmp)
-        except OSError:
-            pass
-
-
-def _topic_log_paths() -> tuple[str, str]:
-    """Return ``(directory, file)`` while retaining explicit test overrides."""
-    if _LOG_PATH is not None:
-        directory = _LOG_DIR or os.path.dirname(_LOG_PATH)
-        return directory, _LOG_PATH
-    if _LOG_DIR is not None:
-        return _LOG_DIR, os.path.join(_LOG_DIR, "topic-shift.log")
-
-    from superlocalmemory.infra.data_root import state_path as runtime_state_path
-
-    path = str(runtime_state_path("logs", "topic-shift.log"))
-    return os.path.dirname(path), path
-
-
-def _read_input() -> tuple[str, str]:
-    """Parse stdin JSON. Returns ('', '') on any failure."""
-    try:
-        raw = sys.stdin.read()
-        if not raw:
-            return "", ""
-        data = json.loads(raw)
-        if not isinstance(data, dict):
-            return "", ""
-        sid = data.get("session_id", "")
-        prompt = data.get("prompt", "")
-        if not isinstance(sid, str) or not isinstance(prompt, str):
-            return "", ""
-        return sid, prompt
-    except (json.JSONDecodeError, ValueError, OSError):
-        return "", ""
-
-
-def _log_decision(
-    session_id: str,
-    current_words: list[str],
-    window: list[list[str]],
-    max_overlap: int,
-    fired: bool,
-    prompt: str,
-) -> None:
-    """Append one decision line for observability. Silent on failure."""
-    if not _LOG_ENABLED:
-        return
-    try:
-        log_dir, log_path = _topic_log_paths()
-        os.makedirs(log_dir, exist_ok=True)
-        ts = time.strftime("%Y-%m-%dT%H:%M:%S")
-        sh = hashlib.sha256(session_id.encode()).hexdigest()[:8]
-        preview = (prompt[:_LOG_PROMPT_PREVIEW_CHARS]
-                   .replace("\t", " ").replace("\n", " "))
-        line = (f"{ts}\t{sh}\t{len(current_words)}\t{len(window)}"
-                f"\t{max_overlap}\t{int(fired)}\t{preview}\n")
-        with open(log_path, "a", encoding="utf-8") as f:
-            f.write(line)
-    except OSError:
-        pass
-
-
-def main() -> int:
-    """Entry point. Always returns 0 — fail-open contract."""
-    try:
-        session_id, prompt = _read_input()
-        if not session_id or not prompt:
-            return 0
-        if not is_substantive(prompt):
-            return 0
-
-        current = extract_content_words(prompt)
-        path = state_path(session_id)
-        window = load_state(path)
-
-        fired, max_overlap = detect_shift(current, window)
-
-        if fired:
-            print(_SHIFT_REMINDER)
-
-        _log_decision(session_id, current, window, max_overlap, fired, prompt)
-
-        window.append(current)
-        save_state(path, window)
-    except Exception:  # noqa: BLE001 — fail-open contract
-        pass
-    return 0

package/src/superlocalmemory/hooks/user_prompt_hook.py

@@ -1,131 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-01 §4.3
-
-"""UserPromptSubmit hook — Python fallback (compiled binary preferred).
-
-
-HARD RULES (enforced by tests):
-  - stdlib-only imports at module load (SLM modules delayed-imported).
-  - NEVER raises to Claude Code — always prints a valid JSON and exits 0.
-  - Returns the Claude Code April-2026 envelope on cache hit:
-      ``{"hookSpecificOutput": {"hookEventName": "UserPromptSubmit",
-                                "additionalContext": "..."}}``
-  - Returns ``{}`` on miss / malformed input / DB absent / any error.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-
-
-def main() -> int:
-    """Entry point. Reads JSON from stdin, writes JSON to stdout, returns 0.
-
-    The dispatcher in ``hook_handlers.handle_hook`` routes
-    ``slm hook user_prompt_submit`` here when the compiled binary is
-    absent (see LLD-06 for the binary path).
-    """
-    try:
-        raw = sys.stdin.read()
-    except Exception:  # pragma: no cover — stdin unreadable in container
-        sys.stdout.write("{}")
-        return 0
-
-    if not raw:
-        sys.stdout.write("{}")
-        return 0
-
-    try:
-        payload = json.loads(raw)
-    except Exception:
-        sys.stdout.write("{}")
-        return 0
-
-    if not isinstance(payload, dict):
-        sys.stdout.write("{}")
-        return 0
-
-    session_id = payload.get("session_id")
-    prompt = payload.get("prompt")
-    if not isinstance(session_id, str) or not session_id:
-        sys.stdout.write("{}")
-        return 0
-    if not isinstance(prompt, str) or not prompt:
-        sys.stdout.write("{}")
-        return 0
-
-    # S9-DASH-10: register this session_id as the most recent active
-    # Claude session so the MCP ``recall`` tool can pick it up when
-    # the MCP protocol doesn't thread the session_id through tool
-    # arguments. Fail-soft — never raises on the hot path.
-    try:
-        from superlocalmemory.hooks.session_registry import (
-            mark_active,
-            resolve_active_profile,
-        )
-        mark_active(
-            session_id,
-            agent_type="claude",
-            profile_id=resolve_active_profile(),
-        )
-    except Exception:
-        pass
-
-    # Delayed imports keep cold-start small and isolate any pathological
-    # import-time failure of the SLM modules from the hot path.
-    try:
-        from superlocalmemory.core.context_cache import read_entry_fast
-        from superlocalmemory.core.topic_signature import compute_topic_signature
-    except Exception:  # pragma: no cover — SLM modules unimportable
-        sys.stdout.write("{}")
-        return 0
-
-    # LLD-13 Track C.1: inline trigram entity detection. Layer A of the
-    # two-layer detector — bounded (<2 ms p99), stdlib-only, silent on
-    # any failure (falls through to regex-only signature).
-    entity_hits: list[str] = []
-    try:
-        from superlocalmemory.learning import trigram_index as _ti
-        _idx = _ti.get_or_none()
-        if _idx is not None:
-            entity_hits = [eid for eid, _hits in _idx.lookup(prompt)]
-    except Exception:
-        entity_hits = []
-
-    try:
-        topic_sig = compute_topic_signature(prompt, entity_hits=entity_hits)
-        entry = read_entry_fast(session_id, topic_sig, require_current_admission=True)
-    except Exception:
-        sys.stdout.write("{}")
-        return 0
-
-    if entry is None:
-        sys.stdout.write("{}")
-        return 0
-
-    from superlocalmemory.core.injection import render_untrusted_text
-    wrapped = render_untrusted_text(
-        entry.content,
-        source_type="context-cache",
-        source_id=str(getattr(entry, "topic_signature", "") or ""),
-    )
-    if not wrapped:
-        sys.stdout.write("{}")
-        return 0
-    envelope = {
-        "hookSpecificOutput": {
-            "hookEventName": "UserPromptSubmit",
-            "additionalContext": wrapped,
-        }
-    }
-    try:
-        sys.stdout.write(json.dumps(envelope))
-    except Exception:  # pragma: no cover — str content unserializable
-        sys.stdout.write("{}")
-    return 0
-
-
-if __name__ == "__main__":  # pragma: no cover — CLI entry only
-    sys.exit(main())