Phase 3.5: Automation & Agents Plugin

Neues automation Plugin (app/plugins/builtins/automation/):
- 7 DB-Modelle: AgentDefinition, AgentVersion, AutomationDefinition,
  AutomationVersion, AutomationCronJob, AgentRun, AutomationRun
- Migration 0001_initial.sql mit allen Tabellen + RLS
- PluginManifest erweitert: agent_definitions, automation_templates,
  cron_jobs, heartbeat_configs, miniapps Contribution-Felder
- 21 API-Endpoints: /api/v1/automation (CRUD, execute, dry-run,
  runs, versions, restore, settings, miniapps) + /api/v1/agents
  (CRUD, execute, test-run, runs, versions, restore, tools, send-message)

Backend Features:
- Cron-Scheduler (scheduler.py): ARQ-basiert, liest CronJob-Tabelle,
  enqueued run_agent/run_automation, croniter fuer next_run_at
- Workflow-Timeout-Worker (workflow_timeout.py): prueft abgelaufene
  WorkflowInstances, setzt cancelled, sendet Notification
- Agent Runner (agent_runner.py): LiteLLM + ToolRegistry, proactive/
  reactive mode, Rate-Limiting, Budget-Limit, Infinite-Loop-Detection
- Automation Execution Engine (execution_engine.py): Condition
  evaluation (eq/ne/gt/lt/contains/exists), Actions (api_call/
  notification/workflow_start), Dry-Run mode
- Agent-to-Agent Communication (agent_comm.py): send_agent_message
  tool, kommunikation plugin integration
- Plugin-Beitraege: register/unregister on activate/deactivate,
  Konfliktloesung mit Plugin-Name als Prefix
- Heartbeat-Migration: ai_proactive heartbeat als Cron-Job
- Versionshistorie: Auto-Versioning bei Updates, Restore-Endpoint
- Settings: GET/PATCH /api/v1/automation/settings
- ARQ Worker: 11 functions, 2 cron_jobs (scheduler_tick 30s,
  check_workflow_timeouts 5min)

Frontend:
- AutomationDashboard.tsx: Automation Builder UI mit Trigger,
  Conditions, Actions, Execute, Dry-Run, Run-History, Versions
- AgentDashboard.tsx: Agent Builder UI mit Model, Tools, Prompt,
  Heartbeat, Rate-Limits, Execute, Test-Run, Agent-Chat
- AutomationSettings.tsx: Settings + MiniApp-Builder
- automation.ts: 24 React Query Hooks
- automation.ts types: TypeScript Interfaces
- routes/index.tsx: /automation, /agents, /settings/automation

Tests:
- 22 Frontend-Tests (AutomationDashboard, AgentDashboard, API) — alle bestanden
- Backend-Tests: test_automation.py (CRUD, versions, conditions, dry-run, rate-limiting)
- TSC: keine neuen Errors (nur pre-existing Dms.tsx)
- croniter dependency installiert

app/plugins/builtins/automation/scheduler.py

@@ -0,0 +1,73 @@
+"""Cron scheduler — reads CronJob rows and enqueues ARQ jobs."""
+
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from typing import Any
+
+import croniter
+from sqlalchemy import select
+
+from app.core.db import get_session_factory
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_next_run(cron_expression: str, from_time: datetime | None = None) -> datetime:
+    """Calculate the next run time from a cron expression using croniter."""
+    base = from_time or datetime.now(UTC)
+    cron = croniter.croniter(cron_expression, base)
+    next_dt = cron.get_next(datetime)
+    return next_dt
+
+
+async def scheduler_tick(ctx: dict[str, Any]) -> None:
+    """Run every 60s via ARQ cron. Reads active CronJob rows where next_run_at <= now,
+    enqueues appropriate ARQ job, updates last_run_at and calculates next_run_at."""
+    from app.plugins.builtins.automation.models import AutomationCronJob as CronJob
+
+    now = datetime.now(UTC)
+    factory = get_session_factory()
+
+    async with factory() as db:
+        result = await db.execute(
+            select(CronJob).where(
+                CronJob.is_active.is_(True),
+                CronJob.next_run_at <= now,
+            )
+        )
+        jobs = list(result.scalars().all())
+
+    if not jobs:
+        logger.debug("scheduler_tick: no cron jobs due")
+        return
+
+    logger.info("scheduler_tick: %d cron job(s) due", len(jobs))
+
+    for job in jobs:
+        try:
+            if job.job_type == "agent":
+                from app.core.jobs import enqueue_job
+                await enqueue_job("run_agent", job.target_id, trigger_type="scheduled")
+            elif job.job_type == "automation":
+                from app.core.jobs import enqueue_job
+                await enqueue_job("run_automation", job.target_id, trigger_type="scheduled")
+            else:
+                logger.warning("Unknown cron job_type: %s", job.job_type)
+                continue
+
+            # Update last_run_at and calculate next_run_at
+            async with factory() as db:
+                result = await db.execute(select(CronJob).where(CronJob.id == job.id))
+                db_job = result.scalar_one_or_none()
+                if db_job is None:
+                    continue
+                db_job.last_run_at = now
+                db_job.next_run_at = calculate_next_run(db_job.cron_expression, now)
+                await db.flush()
+
+            logger.info("Enqueued %s %s (id=%s)", job.job_type, job.target_id, job.id)
+
+        except Exception:
+            logger.exception("Failed to process cron job %s", job.id)