fix(openviking): commit session on /new and context compression

The OpenViking memory provider extracts memories when its session is
committed (POST /api/v1/sessions/{id}/commit).  Before this fix, the
CLI had two code paths that changed the active session_id without ever
committing the outgoing OpenViking session:

1. /new (new_session() in cli.py) — called flush_memories() to write
   MEMORY.md, then immediately discarded the old session_id.  The
   accumulated OpenViking session was never committed, so all context
   from that session was lost before extraction could run.

2. /compress and auto-compress (_compress_context() in run_agent.py) —
   split the SQLite session (new session_id) but left the OpenViking
   provider pointing at the old session_id with no commit, meaning all
   messages synced to OpenViking were silently orphaned.

The gateway already handles session commit on /new and /reset via
shutdown_memory_provider() on the cached agent; the CLI path did not.

Fix: introduce a lightweight session-transition lifecycle alongside
the existing full shutdown path:

- OpenVikingMemoryProvider.reset_session(new_session_id): waits for
  in-flight background threads, resets per-session counters, and
  creates the new OV session via POST /api/v1/sessions — without
  tearing down the HTTP client (avoids connection overhead on /new).

- MemoryManager.restart_session(new_session_id): calls reset_session()
  on providers that implement it; falls back to initialize() for
  providers that do not.  Skips the builtin provider (no per-session
  state).

- AIAgent.commit_memory_session(messages): wraps
  memory_manager.on_session_end() without shutdown — commits OV session
  for extraction but leaves the provider alive for the next session.

- AIAgent.reinitialize_memory_session(new_session_id): wraps
  memory_manager.restart_session() — transitions all external providers
  to the new session after session_id has been assigned.

Call sites:
- cli.py new_session(): commit BEFORE session_id changes, reinitialize
  AFTER — ensuring OV extraction runs on the correct session and the
  new session is immediately ready for the next turn.
- run_agent._compress_context(): same pattern, inside the
  if self._session_db: block where the session_id split happens.

/compress and auto-compress are functionally identical at this layer:
both call _compress_context(), so both are fixed by the same change.

Tests added to tests/agent/test_memory_provider.py:
- TestMemoryManagerRestartSession: reset_session() routing, builtin
  skip, initialize() fallback, failure tolerance, empty-manager noop.
- TestOpenVikingResetSession: session_id update, per-session state
  clear, POST /api/v1/sessions call, API failure tolerance, no-client
  noop.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

plugins/memory/openviking/__init__.py

@@ -533,6 +533,34 @@ class OpenVikingMemoryProvider(MemoryProvider):
         except Exception as e:
             return tool_error(str(e))
 
+    def reset_session(self, new_session_id: str) -> None:
+        """Transition to a new session without tearing down the HTTP client.
+
+        Called by MemoryManager.restart_session() after on_session_end() has
+        committed the old session (e.g. after CLI /new or context compression).
+        Lighter than shutdown() + initialize(): keeps the httpx client alive,
+        resets per-session counters, and creates the new OV session.
+        """
+        for t in (self._sync_thread, self._prefetch_thread):
+            if t and t.is_alive():
+                t.join(timeout=5.0)
+
+        self._session_id = new_session_id
+        self._turn_count = 0
+        self._prefetch_result = ""
+        self._sync_thread = None
+        self._prefetch_thread = None
+
+        if self._client:
+            try:
+                self._client.post("/api/v1/sessions", {"session_id": self._session_id})
+                logger.info("OpenViking new session %s created", self._session_id)
+            except Exception as e:
+                logger.debug("OpenViking session creation on reset: %s", e)
+
+        global _last_active_provider
+        _last_active_provider = self
+
     def shutdown(self) -> None:
         # Wait for background threads to finish
         for t in (self._sync_thread, self._prefetch_thread):