tic: run per-user under a system-agent scheduler, with a run log

Reframe TIC from an ownerless global loop into a per-user system agent.
The events it reads live in each user's own encrypted mcp_events, the
connectors that produced them run in that user's container, and the
notifications go to that user's hub — so the previous design (built
against the ownerless Conversation bundle, writing into system.db and
notifying a hub with no subscribers) was inert by construction.

Core changes
- TicManager owns no timer and no user list. It now exposes
  run_for(user_id, pool, sessions, hub): one tick for one user, over
  deps unpacked from that user's UserContext. Removed from the
  Conversation bundle; Skald::tic_manager() is gone.
- New spawn_system_agents in wiring.rs: one instance-wide loop, spawned
  post-construction with a Weak<Skald> (like spawn_user_lifecycle).
  Each pass walks the directory and runs TIC for one user at a time —
  sequential, because a pass is N container round-trips and N LLM calls
  nobody is waiting on. A ConfigKeyUpdated on the interval key cuts the
  current wait short; enabled is re-read per pass.
- A user whose database is still locked is skipped (normal, not an
  error): the pool is the unlock token, so a user who hasn't logged in
  since restart has no readable events and nowhere to record a skip.
- The configured tic.security_group is re-checked per user through
  run_context::reconcile_group_for_user — a restricted member never
  gets a tool set their role wouldn't grant; unconfigured starts from
  role_default_run_context, never None (None = catch-all = wider).
- New system_agent_runs owner table (no user_id column — the file is
  the owner): start/finish split so a crash leaves a visible 'running'
  row, swept to 'failed' by the next start; safe because the scheduler
  is sequential and single-instance. An idle tick writes nothing.
- counting_notify wraps the notify tool so the run log can report
  notifications emitted without the tool knowing it's counted.
- The session's event channel is drained by a spawned task instead of
  a dropped receiver — the translator awaits its sends and would wedge
  at capacity.

EventLog::{Persist,Discard} on McpManager::new
- mcp_events is an owner table and its only reader (TIC) is per-user,
  so an event is something that happened to someone. The per-user
  runtime gets Persist; the ownerless global runtime gets Discard (its
  pool is system.db, rows would be unattributable and unread).

API + UI
- GET /api/system-agents/runs: the caller's own run history, scoped
  through require_context with no admin override (same promise as the
  rest of the private pool).
- web/components/system-agents.js replaces tic-sessions.js. The old
  #tic debug page inferred runs from leftover ephemeral sessions; the
  new #system-agents page (sidebar group 'extensions', visible to
  everyone — the data is the caller's own) reads the real run log.
- i18n: tic.* keys replaced with system_agents.* in en/it/fr.

Docs
- New docs/system-agents.md (user-facing: what TIC does, why it runs
  per person, why a run can be missing). Updated docs/settings.md and
  docs/index.md.
- agents/tic/AGENT.md reframed per-user: events are that person's,
  memory is user-memory/ (private) — never shared-memory/.
- CLAUDE.md records the system-agents design and the EventLog seam.

crates/skald-core/src/mcp/mod.rs

@@ -59,13 +59,50 @@ pub struct McpManager {
     data_root:       PathBuf,
 }
 
+/// Whether a runtime's server-pushed notifications are persisted to `mcp_events`.
+///
+/// `mcp_events` is an **owner** table and its only consumer is TIC, which is
+/// per-user: an event is something that happened to *someone*. The global
+/// runtime has no owner — its pool is `system.db` — so persisting there would
+/// produce rows nobody can attribute and nobody will ever read.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EventLog {
+    /// Per-user runtime: notifications land in that user's `mcp_events`.
+    Persist,
+    /// Global runtime: notifications are dropped after the diagnostic log line.
+    Discard,
+}
+
 impl McpManager {
-    pub fn new(pool: Arc<SqlitePool>, shutdown: CancellationToken, data_root: impl Into<PathBuf>) -> Self {
+    pub fn new(
+        pool:      Arc<SqlitePool>,
+        shutdown:  CancellationToken,
+        data_root: impl Into<PathBuf>,
+        event_log: EventLog,
+    ) -> Self {
         let (notification_tx, notification_rx) = mpsc::unbounded_channel::<McpNotification>();
         let (log_tx, log_rx) = mpsc::unbounded_channel::<McpLogLine>();
 
         let pool_bg = pool.clone();
-        tokio::spawn(Self::notification_consumer(pool_bg, notification_rx, shutdown.clone()));
+        match event_log {
+            EventLog::Persist => {
+                tokio::spawn(Self::notification_consumer(pool_bg, notification_rx, shutdown.clone()));
+            }
+            // Still drain the channel: the senders are unbounded, but a receiver
+            // dropped here would make every `send` fail and log noise per event.
+            EventLog::Discard => {
+                let sd = shutdown.clone();
+                tokio::spawn(async move {
+                    let mut rx = notification_rx;
+                    loop {
+                        tokio::select! {
+                            _ = sd.cancelled() => break,
+                            msg = rx.recv() => if msg.is_none() { break },
+                        }
+                    }
+                });
+            }
+        }
         tokio::spawn(logs::log_consumer(log_rx, shutdown));
 
         Self {