fix(session): wire auto-commit threshold into add_messages

_auto_commit_threshold (default 8000) and the pending_tokens signal
were both maintained by _append_messages but never connected — the
threshold param was dead code, assigned at __init__ and never read.
Only the offline ingest poller (maybe_commit_on_threshold in
replay.py) committed on threshold. In-process sessions (HTTP/SDK
add_messages path used by the CC plugin and HTTP clients) never
auto-committed, so real-time sessions accumulated messages without
extraction — a root cause of the low session→memory conversion rate.

Add _maybe_auto_commit() called at the end of add_messages: when
pending_tokens >= threshold, fire commit_async(keep_recent_count)
as a background task. Fire-and-forget keeps add_messages
non-blocking; commit_async's path-lock + empty-messages early-return
make a concurrent plugin-initiated commit a safe no-op. threshold <= 0
disables; no-op without a running event loop (sync CLI callers).

Adds 5 unit tests (tests/unit/session/test_session_autocommit.py)
covering fire/skip/disable/forward/boundary via Session.__new__ —
no VikingFS/vectordb dependency.

Author: lg320531124

openviking/session/session.py

@@ -956,8 +956,40 @@ def add_messages(
                 all_messages.append(msg)
 
         self._append_messages(all_messages)
+        self._maybe_auto_commit()
         return all_messages
 
+    def _maybe_auto_commit(self) -> None:
+        """Trigger a background commit when accumulated pending tokens cross the
+        auto-commit threshold.
+
+        The threshold (``_auto_commit_threshold``) and the ``pending_tokens``
+        signal were both maintained by ``_append_messages`` but never connected,
+        so in-process sessions (HTTP/SDK ``add_messages`` path) never
+        auto-committed — only the offline ingest poller
+        (``maybe_commit_on_threshold``) did. This left real-time sessions
+        accumulating without extraction, the root cause of the low
+        session→memory conversion rate.
+
+        Fire-and-forget: archive (Phase 1) and extraction (Phase 2) both run
+        in the background so ``add_messages`` stays non-blocking.
+        ``commit_async``'s path-lock + empty-messages early-return make a
+        concurrent plugin-initiated commit a safe no-op. Threshold <= 0
+        disables. No-op when no running event loop (sync CLI callers).
+        """
+        threshold = int(self._auto_commit_threshold or 0)
+        if threshold <= 0:
+            return
+        if int(self._meta.pending_tokens or 0) < threshold:
+            return
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return  # No running loop (sync CLI path) — skip, plugin/HTTP will commit.
+        loop.create_task(
+            self.commit_async(keep_recent_count=int(self._meta.keep_recent_count or 0))
+        )
+
     def add_message(
         self,
         role: str,

tests/unit/session/test_session_autocommit.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+
+"""Unit tests for threshold-driven auto-commit on Session.add_messages.
+
+The auto-commit threshold (_auto_commit_threshold) and the pending_tokens
+signal were both maintained by _append_messages but never connected, so
+in-process sessions (HTTP/SDK add_messages path) never auto-committed —
+only the offline ingest poller (maybe_commit_on_threshold) did. This left
+real-time sessions accumulating without extraction, the root cause of the
+low session→memory conversion rate. _maybe_auto_commit wires them.
+
+These target the _maybe_auto_commit wiring on Session via __new__ to avoid
+the heavy VikingFS/vectordb __init__ path — no running server needed.
+"""
+
+import asyncio
+from unittest.mock import AsyncMock
+
+import pytest
+
+from openviking.session.session import Session, SessionMeta
+
+
+def _bare_session() -> Session:
+    """A Session with only the fields _maybe_auto_commit reads."""
+    s = Session.__new__(Session)
+    s._auto_commit_threshold = 0
+    s._meta = SessionMeta(
+        session_id="test",
+        created_at=0,
+        updated_at=0,
+        created_by_account_id="",
+        created_by_user_id="",
+        message_count=0,
+        commit_count=0,
+    )
+    s.commit_async = AsyncMock(return_value={"status": "accepted"})
+    return s
+
+
+class TestAutoCommit:
+    """Threshold-driven auto-commit wiring."""
+
+    async def test_auto_commit_fires_when_threshold_crossed(self):
+        """pending_tokens >= threshold schedules a background commit_async."""
+        s = _bare_session()
+        s._auto_commit_threshold = 100
+        s._meta.pending_tokens = 150  # over threshold
+
+        s._maybe_auto_commit()
+        await asyncio.sleep(0)  # let the fire-and-forget task run
+
+        assert s.commit_async.called
+
+    async def test_auto_commit_skipped_below_threshold(self):
+        """Below threshold, _maybe_auto_commit must not schedule a commit."""
+        s = _bare_session()
+        s._auto_commit_threshold = 999_999
+        s._meta.pending_tokens = 10
+
+        s._maybe_auto_commit()
+        await asyncio.sleep(0)
+
+        assert not s.commit_async.called
+
+    async def test_auto_commit_disabled_when_threshold_zero(self):
+        """threshold <= 0 disables auto-commit entirely."""
+        s = _bare_session()
+        s._auto_commit_threshold = 0
+        s._meta.pending_tokens = 10_000
+
+        s._maybe_auto_commit()
+        await asyncio.sleep(0)
+
+        assert not s.commit_async.called
+
+    async def test_auto_commit_forwards_keep_recent_count(self):
+        """keep_recent_count from session meta is forwarded to commit_async."""
+        s = _bare_session()
+        s._auto_commit_threshold = 1
+        s._meta.pending_tokens = 10
+        s._meta.keep_recent_count = 7
+
+        s._maybe_auto_commit()
+        await asyncio.sleep(0)
+
+        assert s.commit_async.call_args.kwargs["keep_recent_count"] == 7
+
+    async def test_auto_commit_equal_threshold_fires(self):
+        """Boundary: pending_tokens == threshold should fire (>=)."""
+        s = _bare_session()
+        s._auto_commit_threshold = 50
+        s._meta.pending_tokens = 50  # exactly at threshold
+
+        s._maybe_auto_commit()
+        await asyncio.sleep(0)
+
+        assert s.commit_async.called