data-olympus 0.3.2__tar.gz → 0.3.4__tar.gz

{data_olympus-0.3.2 → data_olympus-0.3.4}/CHANGELOG.md

@@ -12,6 +12,58 @@ This project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.4] - 2026-07-05
+
+### Fixed
+
+- **Enforcement gate false-positives on prose that merely mentions a governed
+  keyword, for tool calls with a known file path.** `IntentClassifier.classify`
+  scanned `action_diff` (the raw Write/Edit content or Bash command text, up
+  to 4000 chars) for free-text keywords like `auth`, `rls`, `tenant`, `secret`
+  in addition to `intent`, for every tool call. A scratch write whose text
+  simply discussed one of those words as a topic - not an actual governed
+  action - tripped the pre-tool gate regardless of the real (ungoverned)
+  write target, and a fresh `kb_consult` call did not clear it because the
+  consult's own classification (`intent`-only) and the gate's classification
+  (`intent + action_diff`) disagreed on whether the action was governed.
+  Keyword matching on `action_diff` now only applies when the tool call
+  carries no `action_path` (Bash commands and OpenCode's `patch`, whose
+  content is the only signal available); when an `action_path` is present
+  (Write/Edit/MultiEdit), classification uses the path globs and dependency
+  command patterns, unchanged, so this keeps full detection for real governed
+  edits (a patch touching `package.json`) without flagging unrelated prose in
+  files the path globs don't consider governed. Found via a company-knowledge
+  KB audit session that reproduced it live (a scratch `.txt` file containing
+  "RLS tenant boundaries auth trust model" was blocked with no governed path
+  or command in sight); independently reviewed via `codex exec` before
+  release.
+  - The audit's other finding (CX1: the pre-tool gate and the pre-commit
+    `report --staged` gate resolving two different workspace keys) was
+    already fixed in v0.2.0 (#64, worktree-invariant workspace key); no
+    further change needed. It was still visible in that audit only because
+    it predated the deployed kn-dev redeploy.
+
+## [0.3.3] - 2026-07-05
+
+### Fixed
+
+- **MCP streamable-HTTP session churn under long-lived clients.** A persistent
+  client (notably `opencode serve`) that holds the `GET /mcp` SSE stream open was
+  being forced to reconnect on a cycle, piling up abandoned transports on the
+  server and leaking event listeners on the client until it degraded. Two causes
+  addressed:
+  - The activity middleware now keeps a session non-idle for as long as its SSE
+    stream is actually open (re-stamping every `KB_SESSION_TOUCH_INTERVAL_SEC`,
+    default 30s, clamped to a third of the idle window), so the reaper evicts a
+    session only after its stream has genuinely closed. With that safety in
+    place, the idle-reap default (`KB_SESSION_IDLE_TIMEOUT_SEC`) drops from 1800s
+    to 300s, so an abandoned handshake is cleared in minutes instead of half an
+    hour.
+  - The shipped ingress manifest (`deploy/k8s/ingress.yaml`) now sets a long
+    `proxy-read-timeout`/`proxy-send-timeout` and disables buffering, so a proxy
+    with a short default idle timeout (nginx: 60s) no longer closes the SSE
+    stream and triggers the reconnect loop. See `docs/serving.md`.
+
 ## [0.3.2] - 2026-07-05
 
 ### Fixed
@@ -1029,7 +1081,8 @@ This project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - `docs/adoption.md`: bring-your-own-KB guide (author, lint, index, serve, wire an agent).
 - `docs/comparison.md`: how data-olympus relates to OKF, enterprise catalogs, markdown KB tools, agent-context conventions, RAG, and ADR tooling.
 
-[Unreleased]: https://github.com/knaisoma/data-olympus/compare/v0.3.2...HEAD
+[Unreleased]: https://github.com/knaisoma/data-olympus/compare/v0.3.3...HEAD
+[0.3.3]: https://github.com/knaisoma/data-olympus/compare/v0.3.2...v0.3.3
 [0.3.2]: https://github.com/knaisoma/data-olympus/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/knaisoma/data-olympus/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/knaisoma/data-olympus/compare/v0.2.0...v0.3.0

{data_olympus-0.3.2 → data_olympus-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-olympus
-Version: 0.3.2
+Version: 0.3.4
 Summary: Governance-grade knowledge-base format (OKF-compatible) plus CLI and single-writer MCP server
 Project-URL: Homepage, https://github.com/knaisoma/data-olympus
 Project-URL: Repository, https://github.com/knaisoma/data-olympus

{data_olympus-0.3.2 → data_olympus-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "data-olympus"
-version = "0.3.2"
+version = "0.3.4"
 description = "Governance-grade knowledge-base format (OKF-compatible) plus CLI and single-writer MCP server"
 readme = "README.md"
 requires-python = ">=3.13"

{data_olympus-0.3.2 → data_olympus-0.3.4}/src/data_olympus/config.py

@@ -65,8 +65,15 @@ class Config:
     # Streamable-http session reaping: terminate transports idle beyond this many
     # seconds to bound _server_instances (see session_metrics). 0 disables the
     # reaper (observability-only). The scan runs every session_reap_interval_sec.
-    session_idle_timeout_sec: int = 1800
+    # An in-flight GET SSE stream is kept non-idle by the activity middleware, so
+    # this window only clears sessions whose stream has actually closed (an
+    # abandoned handshake); 5 minutes keeps those from piling up.
+    session_idle_timeout_sec: int = 300
     session_reap_interval_sec: int = 60
+    # How often the activity middleware re-stamps a session while its GET SSE
+    # stream is open, so a quiet-but-connected client is never reaped. Clamped
+    # below session_idle_timeout_sec at wiring time.
+    session_touch_interval_sec: int = 30
     # Optional override for the status-aware reranker's status->weight map
     # (issue #37). None means "use the Index built-in default map". A negative
     # weight boosts an in-force status, a positive one penalizes a retired one.
@@ -191,8 +198,9 @@ def load_config() -> Config:
     auth_principals = parse_principals_env(os.getenv("KB_AUTH_PRINCIPALS", ""))
     consult_ttl_sec = int(os.getenv("KB_CONSULT_TTL_SEC", "300"))
     ledger_path = os.getenv("KB_LEDGER_PATH", "/state/ledger.json")
-    session_idle_timeout_sec = int(os.getenv("KB_SESSION_IDLE_TIMEOUT_SEC", "1800"))
+    session_idle_timeout_sec = int(os.getenv("KB_SESSION_IDLE_TIMEOUT_SEC", "300"))
     session_reap_interval_sec = int(os.getenv("KB_SESSION_REAP_INTERVAL_SEC", "60"))
+    session_touch_interval_sec = int(os.getenv("KB_SESSION_TOUCH_INTERVAL_SEC", "30"))
     status_weights = _load_status_weights(os.getenv("KB_STATUS_WEIGHTS", ""))
     read_only = _env_bool(os.getenv("KB_READ_ONLY", ""))
     from data_olympus.cooccurrence import (
@@ -254,6 +262,7 @@ def load_config() -> Config:
         ledger_path=ledger_path,
         session_idle_timeout_sec=session_idle_timeout_sec,
         session_reap_interval_sec=session_reap_interval_sec,
+        session_touch_interval_sec=session_touch_interval_sec,
         status_weights=status_weights,
         read_only=read_only,
         cooccurrence_enabled=cooc_enabled,

{data_olympus-0.3.2 → data_olympus-0.3.4}/src/data_olympus/enforce_policy.py

@@ -81,7 +81,21 @@ class IntentClassifier:
         action_diff: str = "",
     ) -> ClassifyResult:
         signals: list[str] = []
-        text = f"{intent} {action_diff}".lower()
+        # Free-text keyword signals always scan `intent` (a short, deliberate
+        # statement of what the agent is about to do - kb_consult's argument -
+        # so a keyword there is a real signal). They scan `action_diff` too,
+        # but ONLY when there is no `action_path`: `action_diff` is arbitrary
+        # write/command CONTENT up to 4000 chars (Write.content, Edit.new_string,
+        # Bash.command, OpenCode patch text), and when a concrete action_path is
+        # already given, path-glob matching below is the intended signal for
+        # that action - layering the free-text net on top blocked benign writes
+        # to ungoverned files that merely discussed a keyword as a topic (a
+        # scratch file quoting "RLS"/"auth" from a security standard). Bash
+        # commands and OpenCode's `patch` tool carry no action_path at all
+        # (their action_diff IS the only content available), so the free-text
+        # net still applies there - dropping it entirely would silently lose
+        # the only governed-decision signal for those two tool shapes.
+        text = intent.lower() if action_path else f"{intent} {action_diff}".lower()
         for kw, rx in self._keyword_res:
             if rx.search(text):
                 signals.append(f"keyword:{kw}")

{data_olympus-0.3.2 → data_olympus-0.3.4}/src/data_olympus/server.py

@@ -251,8 +251,9 @@ def build_app(
     audit_hmac_key: str = "",
     audit_max_bytes: int = 0,
     ledger_path: str | None = None,
-    session_idle_timeout_sec: int = 1800,
+    session_idle_timeout_sec: int = 300,
     session_reap_interval_sec: int = 60,
+    session_touch_interval_sec: int = 30,
     status_weights: dict[str, float] | None = None,
     read_only: bool = False,
     embeddings_enabled: bool = False,
@@ -300,6 +301,7 @@ def build_app(
         audit_max_bytes=audit_max_bytes,
         session_idle_timeout_sec=session_idle_timeout_sec,
         session_reap_interval_sec=session_reap_interval_sec,
+        session_touch_interval_sec=session_touch_interval_sec,
         status_weights=status_weights,
         read_only=read_only,
         embeddings_enabled=embeddings_enabled,
@@ -888,6 +890,7 @@ def build_app_from_config(config: Config, *, bootstrap_now: bool = True) -> Fast
         ledger_path=config.ledger_path,
         session_idle_timeout_sec=config.session_idle_timeout_sec,
         session_reap_interval_sec=config.session_reap_interval_sec,
+        session_touch_interval_sec=config.session_touch_interval_sec,
         status_weights=config.status_weights,
         read_only=config.read_only,
         embeddings_enabled=config.embeddings_enabled,
@@ -983,9 +986,25 @@ def main() -> None:
     )
 
     tracker = SessionActivityTracker()
+    # Re-stamp an in-flight SSE session at least 3x per idle window, so a
+    # quiet-but-connected client is never reaped even if an operator sets a short
+    # idle timeout. Falls back to the configured interval when the idle window is
+    # generous.
+    _idle = config.session_idle_timeout_sec
+    _touch_interval = float(config.session_touch_interval_sec)
+    if _idle > 0:
+        # Always strictly below the idle window (>= 3 touches per window) even for
+        # a tiny idle value; a small positive floor avoids a zero/negative sleep.
+        _touch_interval = max(0.1, min(_touch_interval, _idle / 3))
     http_app = app.http_app(
         transport="streamable-http",
-        middleware=[StarletteMiddleware(SessionActivityMiddleware, tracker=tracker)],
+        middleware=[
+            StarletteMiddleware(
+                SessionActivityMiddleware,
+                tracker=tracker,
+                touch_interval_sec=_touch_interval,
+            )
+        ],
     )
     # Health surfaces the live session count; the manager is only reachable once
     # the lifespan has started, so this returns None before then (never raises).

{data_olympus-0.3.2 → data_olympus-0.3.4}/src/data_olympus/session_metrics.py

@@ -45,6 +45,7 @@ these internals, discovery returns ``None`` and the count is reported as
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 import time
 from typing import TYPE_CHECKING, Any, Protocol
@@ -195,20 +196,61 @@ class SessionActivityTracker:
 
 class SessionActivityMiddleware:
     """ASGI middleware that stamps :class:`SessionActivityTracker` on each request
-    carrying an ``mcp-session-id`` header. Pure pass-through otherwise; adds no
-    latency beyond a header scan."""
+    carrying an ``mcp-session-id`` header.
+
+    The ``GET /mcp`` Server-Sent-Events stream is a *single* long-lived request
+    that emits no further ASGI events while the session is quiet. Stamping only
+    at request start would let the idle reaper evict a still-connected client
+    after the idle window (forcing a reconnect, the exact churn that piles up
+    transports server-side and leaks listeners in a persistent client like
+    ``opencode serve``). So for an in-flight GET stream this middleware re-stamps
+    the session every ``touch_interval_sec`` for as long as the stream stays open;
+    when the client disconnects the request completes, re-stamping stops, and only
+    then does the session go idle and become reap-eligible. Short GET/POST
+    requests finish before the first tick, so they pay only the initial stamp.
+    """
 
-    def __init__(self, app: ASGIApp, tracker: SessionActivityTracker) -> None:
+    def __init__(
+        self,
+        app: ASGIApp,
+        tracker: SessionActivityTracker,
+        *,
+        touch_interval_sec: float = 30.0,
+    ) -> None:
         self.app = app
         self._tracker = tracker
+        self._touch_interval = touch_interval_sec
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope.get("type") == "http":
-            for key, value in scope.get("headers", []):
-                if key.lower() == _MCP_SESSION_ID_HEADER and value:
-                    self._tracker.touch(value.decode("latin-1"))
-                    break
-        await self.app(scope, receive, send)
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+        session_id = ""
+        for key, value in scope.get("headers", []):
+            if key.lower() == _MCP_SESSION_ID_HEADER and value:
+                session_id = value.decode("latin-1")
+                break
+        if not session_id:
+            await self.app(scope, receive, send)
+            return
+        self._tracker.touch(session_id)
+        # Only the long-lived GET SSE stream needs keep-alive re-stamping.
+        if scope.get("method") != "GET":
+            await self.app(scope, receive, send)
+            return
+
+        async def _keep_active() -> None:
+            while True:
+                await asyncio.sleep(self._touch_interval)
+                self._tracker.touch(session_id)
+
+        task = asyncio.create_task(_keep_active())
+        try:
+            await self.app(scope, receive, send)
+        finally:
+            task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await task
 
 
 async def reap_idle_sessions(