feat: workflow builder with visual DAG editor

.gitignore

@@ -1,3 +1,6 @@
+# Git worktrees
+.worktrees/
+
 # OMC state
 .omc/
 

api/config.py

@@ -163,6 +163,11 @@ def sqlite_db_path(self) -> Path:
         """Get the SQLite metadata database path."""
         return self.karma_base / "metadata.db"
 
+    @property
+    def workflow_db_path(self) -> Path:
+        """Get the SQLite workflow database path."""
+        return self.karma_base / "workflow.db"
+
 
 # Global settings instance
 settings = Settings()

api/db/schema.py

@@ -10,7 +10,7 @@
 
 logger = logging.getLogger(__name__)
 
-SCHEMA_VERSION = 10
+SCHEMA_VERSION = 11
 
 SCHEMA_SQL = """
 -- Schema versioning
@@ -214,6 +214,8 @@
 );
 
 CREATE UNIQUE INDEX IF NOT EXISTS idx_projects_slug ON projects(slug);
+
+-- Workflow tables moved to workflow.db (schema version 10)
 """
 
 
@@ -426,6 +428,42 @@ def ensure_schema(conn: sqlite3.Connection) -> None:
             # Nudge mtime to force re-index of all sessions
             conn.execute("UPDATE sessions SET jsonl_mtime = jsonl_mtime - 1")
 
+        if current_version < 11:
+            logger.info("Migrating → v11: dropping workflow tables (moved to workflow.db)")
+            from config import settings
+
+            # Only drop if workflow.db migration was confirmed successful
+            should_drop = False
+            wf_path = settings.workflow_db_path
+            if wf_path.exists():
+                try:
+                    import sqlite3 as _sqlite3
+
+                    wf_check = _sqlite3.connect(str(wf_path), timeout=5.0)
+                    migrated = wf_check.execute(
+                        "SELECT 1 FROM wf_migration_log WHERE source = 'metadata_db'"
+                    ).fetchone()
+                    wf_check.close()
+                    should_drop = migrated is not None
+                except Exception:
+                    logger.warning(
+                        "Could not verify workflow.db migration; "
+                        "keeping workflow tables in metadata.db"
+                    )
+
+            if should_drop:
+                conn.executescript("""
+                    DROP TABLE IF EXISTS workflow_run_steps;
+                    DROP TABLE IF EXISTS workflow_runs;
+                    DROP TABLE IF EXISTS workflows;
+                """)
+                logger.info("Dropped workflow tables from metadata.db")
+            else:
+                logger.info(
+                    "Workflow migration not confirmed; "
+                    "keeping workflow tables in metadata.db until next restart"
+                )
+
     # Record version
     conn.execute(
         "INSERT OR REPLACE INTO schema_version (version) VALUES (?)",

api/db/workflow_db.py

@@ -0,0 +1,98 @@
+"""
+SQLite connection management for workflow.db.
+
+Mirrors the reader/writer pattern from connection.py but for the
+separate workflow database. Single writer connection, per-request readers.
+"""
+
+import logging
+import sqlite3
+import threading
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Writer singleton state
+_wf_writer: Optional[sqlite3.Connection] = None
+_wf_writer_lock = threading.Lock()
+
+
+def get_workflow_db_path() -> Path:
+    """Get the workflow database file path."""
+    from config import settings
+
+    return settings.workflow_db_path
+
+
+def get_wf_writer() -> sqlite3.Connection:
+    """
+    Get or create the singleton writer connection for workflow.db.
+
+    Initializes schema and runs migration from metadata.db on first call.
+    """
+    global _wf_writer
+
+    if _wf_writer is not None:
+        return _wf_writer
+
+    with _wf_writer_lock:
+        if _wf_writer is not None:
+            return _wf_writer
+
+        db_path = get_workflow_db_path()
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.info("Opening workflow DB writer connection at %s", db_path)
+
+        conn = sqlite3.connect(
+            str(db_path),
+            check_same_thread=False,
+            timeout=10.0,
+        )
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA synchronous=NORMAL")
+        conn.execute("PRAGMA foreign_keys=ON")
+        conn.execute("PRAGMA busy_timeout=5000")
+
+        from .workflow_schema import ensure_workflow_schema, migrate_from_metadata_db
+
+        ensure_workflow_schema(conn)
+        try:
+            migrate_from_metadata_db(conn)
+        except Exception:
+            logger.warning("Workflow migration from metadata.db failed; skipping", exc_info=True)
+
+        _wf_writer = conn
+        logger.info("Workflow DB writer connection ready")
+        return _wf_writer
+
+
+def create_wf_read_conn() -> sqlite3.Connection:
+    """
+    Create a new read-only connection for workflow.db.
+
+    Caller is responsible for closing the connection.
+    """
+    db_path = get_workflow_db_path()
+
+    conn = sqlite3.connect(
+        f"file:{db_path}?mode=ro",
+        uri=True,
+        timeout=5.0,
+    )
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA busy_timeout=5000")
+    return conn
+
+
+def close_wf_db() -> None:
+    """Close the singleton writer. Called during app shutdown."""
+    global _wf_writer
+
+    with _wf_writer_lock:
+        if _wf_writer is not None:
+            logger.info("Closing workflow DB writer connection")
+            _wf_writer.close()
+            _wf_writer = None