feat: Add Python plugins from AutoMetabuilder + restructure workflow folder

Restructure workflow/ for multi-language plugin support:
- Rename src/ to core/ (engine code: DAG executor, registry, types)
- Create executor/{cpp,python,ts}/ for language-specific runtimes
- Consolidate plugins to plugins/{ts,python}/ by language then category

Add 80+ Python plugins from AutoMetabuilder in 14 categories:
- control: bot control, switch logic, state management
- convert: type conversions (json, boolean, dict, list, number, string)
- core: AI requests, context management, tool calls
- dict: dictionary operations (get, set, keys, values, merge)
- list: list operations (concat, find, sort, slice, filter)
- logic: boolean logic (and, or, xor, equals, comparisons)
- math: arithmetic operations (add, subtract, multiply, power, etc.)
- string: string manipulation (concat, split, replace, format)
- notifications: Slack, Discord integrations
- test: assertion helpers and test suite runner
- tools: file operations, git, docker, testing utilities
- utils: filtering, mapping, reducing, condition branching
- var: variable store operations (get, set, delete, exists)
- web: Flask server, environment variables, JSON handling

Add language executor runtimes:
- TypeScript: direct import execution (default, fast startup)
- Python: child process with JSON stdin/stdout communication
- C++: placeholder for native FFI bindings (Phase 3)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

workflow/plugins/python/control/__init__.py

@@ -0,0 +1 @@
+"""Control flow plugins: bot control and switch logic."""

workflow/plugins/python/control/control_get_bot_status.py

@@ -0,0 +1,39 @@
+"""Workflow plugin: get current bot execution status."""
+
+# Global state for bot process
+_bot_process = None
+_mock_running = False
+_current_run_config = {}
+
+
+def get_bot_state():
+    """Get the current bot state (public interface).
+
+    Returns:
+        dict: Bot state with keys: is_running, config, process
+    """
+    return {
+        "is_running": _bot_process is not None or _mock_running,
+        "config": _current_run_config,
+        "process": _bot_process,
+    }
+
+
+def reset_bot_state():
+    """Reset the bot state (public interface)."""
+    global _bot_process, _current_run_config, _mock_running
+    _bot_process = None
+    _current_run_config = {}
+    _mock_running = False
+
+
+def run(_runtime, _inputs):
+    """Get current bot execution status.
+
+    Returns:
+        Dictionary with:
+            - is_running: bool - Whether the bot is currently running
+            - config: dict - Current run configuration (empty if not running)
+            - process: object - Bot process object (or None if not running)
+    """
+    return get_bot_state()

workflow/plugins/python/control/control_reset_bot_state.py

@@ -0,0 +1,13 @@
+"""Workflow plugin: reset bot execution state."""
+from .control_get_bot_status import reset_bot_state
+
+
+def run(_runtime, _inputs):
+    """Reset bot execution state.
+
+    Returns:
+        Dictionary with:
+            - reset: bool - Always True to indicate state was reset
+    """
+    reset_bot_state()
+    return {"reset": True}

workflow/plugins/python/control/control_start_bot.py

@@ -0,0 +1,97 @@
+"""Workflow plugin: start bot execution in background thread."""
+import os
+import subprocess
+import sys
+import threading
+import time
+
+from .control_get_bot_status import (
+    get_bot_state,
+    reset_bot_state,
+    _bot_process,
+    _mock_running,
+    _current_run_config
+)
+
+# Import global state
+import workflow.plugins.python.control.control_get_bot_status as bot_status
+
+
+def _run_bot_task(mode: str, iterations: int, yolo: bool, stop_at_mvp: bool) -> None:
+    """Execute bot task in background thread."""
+    bot_status._current_run_config = {
+        "mode": mode,
+        "iterations": iterations,
+        "yolo": yolo,
+        "stop_at_mvp": stop_at_mvp,
+    }
+
+    if os.environ.get("MOCK_WEB_UI") == "true":
+        bot_status._mock_running = True
+        time.sleep(5)
+        bot_status._mock_running = False
+        reset_bot_state()
+        return
+
+    try:
+        cmd = [sys.executable, "-m", "autometabuilder.main"]
+        if yolo:
+            cmd.append("--yolo")
+        if mode == "once":
+            cmd.append("--once")
+        if mode == "iterations" and iterations > 1:
+            for _ in range(iterations):
+                if stop_at_mvp:
+                    # Check MVP status
+                    pass
+                bot_status._bot_process = subprocess.Popen(
+                    cmd + ["--once"],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT
+                )
+                bot_status._bot_process.wait()
+        else:
+            bot_status._bot_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT
+            )
+            bot_status._bot_process.wait()
+    finally:
+        reset_bot_state()
+
+
+def run(_runtime, inputs):
+    """Start bot execution in background thread.
+
+    Args:
+        inputs: Dictionary with keys:
+            - mode: str (default: "once") - Execution mode ("once", "iterations", etc.)
+            - iterations: int (default: 1) - Number of iterations for "iterations" mode
+            - yolo: bool (default: True) - Run in YOLO mode
+            - stop_at_mvp: bool (default: False) - Stop when MVP is reached
+
+    Returns:
+        Dictionary with:
+            - started: bool - Whether the bot was started successfully
+            - error: str (optional) - Error message if bot is already running
+    """
+    mode = inputs.get("mode", "once")
+    iterations = inputs.get("iterations", 1)
+    yolo = inputs.get("yolo", True)
+    stop_at_mvp = inputs.get("stop_at_mvp", False)
+
+    # Check if bot is already running
+    state = get_bot_state()
+    if state["is_running"]:
+        return {"started": False, "error": "Bot already running"}
+
+    # Start bot in background thread
+    thread = threading.Thread(
+        target=_run_bot_task,
+        args=(mode, iterations, yolo, stop_at_mvp),
+        daemon=True
+    )
+    thread.start()
+
+    return {"started": True}

workflow/plugins/python/control/control_switch.py

@@ -0,0 +1,11 @@
+"""Workflow plugin: switch/case control flow."""
+
+
+def run(_runtime, inputs):
+    """Switch on value and return matching case."""
+    value = inputs.get("value")
+    cases = inputs.get("cases", {})
+    default = inputs.get("default")
+
+    result = cases.get(str(value), default)
+    return {"result": result, "matched": str(value) in cases}